merge: refresh PR #707 with main and cover inherited render paths

Refs #688 #707 #777 #716 #743

Preserve inherited captures and actual TS targets; cover dynamic bases and assertion guards

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

Author: owjs3901

.changepacks/changepack_log_deterministic_numbering.json

@@ -0,0 +1,13 @@
+{
+  "changes": {
+    "bindings/devup-ui-wasm/package.json": "Patch",
+    "packages/plugin-utils/package.json": "Patch",
+    "packages/vite-plugin/package.json": "Patch",
+    "packages/webpack-plugin/package.json": "Patch",
+    "packages/rsbuild-plugin/package.json": "Patch",
+    "packages/next-plugin/package.json": "Patch",
+    "packages/bun-plugin/package.json": "Patch"
+  },
+  "note": "Class names and file numbers no longer depend on the order files are processed in. Every plugin walks the files it can extract (the project's source and the included packages) before the first transform and numbers them in path order (a file collapsed into a bucket is numbered as the bucket, and only files that mention the package, StyleX or an aliased package take numbers) through the new seedFileMap, so identical builds give identical class prefixes, CSS file names and output hashes; in development, files that appear later are numbered after the existing ones. Styles are given class names in a fixed order, not the order of a hash set. The exported class, file and canonical maps are canonical JSON (sorted keys). Stylesheet evaluation (vanilla-extract) refuses Math.random(), Date.now(), new Date() and Date(), which differ between builds, with a build error; fixed dates such as new Date(0) are unchanged. resetBuildState starts a build from its own options: the prefix, atom hoisting, routes, buckets, names, numbers and styles an earlier build in the process left are cleared, and the prefix is set on every setup even when it is absent. Engine snapshots from concurrent transforms are written one after another per file, so an older snapshot is never written last. File lists are ordered by code point rather than the locale",
+  "date": "2026-10-01T00:00:00.000Z"
+}

.changepacks/changepack_log_emotion_css.json

@@ -0,0 +1,9 @@
+{
+  "changes": {
+    "packages/plugin-utils/package.json": "Patch",
+    "packages/react/package.json": "Patch",
+    "bindings/devup-ui-wasm/package.json": "Patch"
+  },
+  "note": "@emotion/css is aliased by default: css and keyframes compile like Devup UI's own (numbers in px, as Emotion reads them), injectGlobal declares global CSS. cx takes class names, as in Emotion: strings and runtime values are classes kept as written (falsy values are skipped), an object is a { name: condition } class map, arrays nest, and inline css() calls and css() classes compose with the rules css(a, b) uses. merge(className) splits what the build can read (string tokens, template literal parts) and composes the css() classes in it, keeping a runtime string it cannot split as it is. Namespace members, constant-string bracket access, const destructuring and const alias chains compile through these same named APIs with scope-aware binding resolution; numeric values retain Emotion units after constant inlining and build-time evaluation. The Emotion import disappears when no runtime-only member is used. Ambient declarations type the styling imports (cx(...args: ClassNamesArg[]), merge(className: string)). New located build errors: cx() cannot use a spread, a getter, a setter or a method in a class map, or a template literal call; merge() takes exactly one class string, not a spread or a template literal call; the root module has no default export, namespace member keys must be constant strings naming supported exports, and styling functions cannot be passed, mutated or re-exported. Optional styling reads/calls, namespace rest destructuring, styling defaults or nested patterns, non-const aliases, exported styling bindings and reads whose initialization order cannot be established are build errors instead of runtime dependencies. Styling loaded through require, import-equals or dynamic import must use static ES module imports; an unawaited dynamic namespace that the build cannot follow is also a located error. Its runtime-only APIs (cache, flush, hydrate, sheet, getRegisteredStyles) stay on @emotion/css, including their nested/default destructuring, optional reads and recognized runtime-loader access",
+  "date": "2026-10-01T00:00:00.000Z"
+}

.changepacks/changepack_log_ts_styled_output.json

@@ -0,0 +1,7 @@
+{
+  "changes": {
+    "bindings/devup-ui-wasm/package.json": "Patch"
+  },
+  "note": "Generate React JSX-runtime calls for styled components in non-JSX source modules while preserving JSX and TSX output. No new build errors.",
+  "date": "2026-10-13T00:00:00.000Z"
+}

bindings/devup-ui-wasm/src/lib.rs

@@ -243,7 +243,14 @@ pub fn export_sheet() -> Result<String, JsValue> {
 
 /// Internal function to export class map as JSON string (testable without `JsValue`)
 pub fn export_class_map_internal() -> Result<String, String> {
-    with_class_map(serde_json::to_string).map_err(|e| e.to_string())
+    with_class_map(|map| {
+        let sorted: BTreeMap<&String, BTreeMap<&String, &usize>> = map
+            .iter()
+            .map(|(file, classes)| (file, classes.iter().collect()))
+            .collect();
+        serde_json::to_string(&sorted)
+    })
+    .map_err(|e| e.to_string())
 }
 
 #[wasm_bindgen(js_name = "importClassMap")]
@@ -261,7 +268,11 @@ pub fn export_class_map() -> Result<String, JsValue> {
 
 /// Internal function to export file map as JSON string (testable without `JsValue`)
 pub fn export_file_map_internal() -> Result<String, String> {
-    with_file_map(serde_json::to_string).map_err(|e| e.to_string())
+    with_file_map(|map| {
+        let sorted: BTreeMap<&String, &usize> = map.iter().collect();
+        serde_json::to_string(&sorted)
+    })
+    .map_err(|e| e.to_string())
 }
 
 #[wasm_bindgen(js_name = "importFileMap")]
@@ -284,7 +295,11 @@ pub fn import_canonical_map_internal(map: HashMap<String, String>) {
 
 /// Internal function to export the canonical map as JSON string (testable without `JsValue`)
 pub fn export_canonical_map_internal() -> Result<String, String> {
-    with_canonical_map(serde_json::to_string).map_err(|e| e.to_string())
+    with_canonical_map(|map| {
+        let sorted: BTreeMap<&String, &String> = map.iter().collect();
+        serde_json::to_string(&sorted)
+    })
+    .map_err(|e| e.to_string())
 }
 
 #[wasm_bindgen(js_name = "importCanonicalMap")]
@@ -300,6 +315,34 @@ pub fn export_canonical_map() -> Result<String, JsValue> {
     export_canonical_map_internal().map_err(js_error)
 }
 
+/// Number every file in `files` now, in path order, keeping numbers files
+/// already hold, so class prefixes depend on the paths and not on the order
+/// workers reach files in.
+#[wasm_bindgen(js_name = "seedFileMap")]
+pub fn seed_file_map(files: Vec<String>) {
+    css::file_map::seed_file_numbers(&files);
+}
+
+/// Forget everything one build left in the engine.
+///
+/// That is names, numbers, styles, buckets, routes, the prefix, atom hoisting
+/// and the module resolver, so the next build starts from its own options
+/// alone. Theme, shorthands and debug mode are set by every build, and stay.
+pub fn reset_build_state_internal() {
+    css::class_map::reset_class_map();
+    css::file_map::reset_file_map();
+    css::file_map::reset_canonical_map();
+    css::file_routes::set_file_routes(HashMap::new());
+    css::atom_hoist::set_atom_hoist(None);
+    css::set_prefix(None);
+    with_style_sheet_mut(|sheet| *sheet = StyleSheet::default());
+    MODULE_RESOLVER.with_borrow_mut(|current| *current = None);
+}
+
+#[wasm_bindgen(js_name = "resetBuildState")]
+pub fn reset_build_state() {
+    reset_build_state_internal();
+}
 /// Set the atom-level hoist threshold.
 ///
 /// When set to `Some(n)`, a style atom whose content is used by `>= n` distinct
@@ -1929,6 +1972,60 @@ mod tests {
         assert!(json_str.starts_with('{') || json_str.starts_with("[]"));
     }
 
+    #[test]
+    #[serial]
+    fn test_exported_maps_are_canonical_json() {
+        css::class_map::reset_class_map();
+        css::file_map::reset_file_map();
+        css::file_map::reset_canonical_map();
+        css::class_map::set_class_map(HashMap::from([
+            (
+                "b.tsx".to_string(),
+                HashMap::from([("z".to_string(), 1), ("a".to_string(), 0)]),
+            ),
+            ("a.tsx".to_string(), HashMap::from([("k".to_string(), 0)])),
+        ]));
+        assert_eq!(
+            export_class_map_internal().unwrap(),
+            r#"{"a.tsx":{"k":0},"b.tsx":{"a":0,"z":1}}"#
+        );
+        seed_file_map(vec!["b.tsx".to_string(), "a.tsx".to_string()]);
+        assert_eq!(
+            export_file_map_internal().unwrap(),
+            r#"{"a.tsx":0,"b.tsx":1}"#
+        );
+        import_canonical_map_internal(HashMap::from([
+            ("y".to_string(), "b".to_string()),
+            ("x".to_string(), "a".to_string()),
+        ]));
+        assert_eq!(
+            export_canonical_map_internal().unwrap(),
+            r#"{"x":"a","y":"b"}"#
+        );
+        reset_build_state();
+        assert_eq!(export_class_map_internal().unwrap(), "{}");
+        assert_eq!(export_file_map_internal().unwrap(), "{}");
+        assert_eq!(export_canonical_map_internal().unwrap(), "{}");
+        assert_eq!(get_prefix(), None);
+    }
+
+    #[test]
+    #[serial]
+    fn test_numbers_do_not_depend_on_the_order_files_are_seen() {
+        let files = ["src/b.tsx", "src/a.tsx", "src/c.tsx"];
+        let mut maps = Vec::new();
+        for order in [[0, 1, 2], [2, 1, 0], [1, 2, 0]] {
+            reset_build_state_internal();
+            seed_file_map(files.iter().map(ToString::to_string).collect());
+            for index in order {
+                let _ = css::file_map::get_file_num_by_filename(files[index]);
+            }
+            maps.push(export_file_map_internal().unwrap());
+        }
+        assert_eq!(maps[0], r#"{"src/a.tsx":0,"src/b.tsx":1,"src/c.tsx":2}"#);
+        assert_eq!(maps[0], maps[1]);
+        assert_eq!(maps[0], maps[2]);
+    }
     #[test]
     #[serial]
     fn test_code_extract_internal_success() {

libs/css/src/file_map.rs

@@ -93,6 +93,19 @@ pub fn get_file_num_by_filename(filename: &str) -> usize {
     })
 }
 
+/// Give every file in `files` a number now, in path order.
+///
+/// Numbers files already hold are kept, and a file collapsed into a bucket is numbered as the bucket. The numbers files get then depend on the paths alone,
+/// not on which file a worker reaches first; files that appear later (in
+/// development) are numbered after the existing ones.
+pub fn seed_file_numbers(files: &[String]) {
+    let mut sorted: Vec<String> = files.iter().map(|file| canonical(file)).collect();
+    sorted.sort_unstable();
+    sorted.dedup();
+    for file in sorted {
+        let _ = get_file_num_by_filename(&file);
+    }
+}
 #[must_use]
 pub fn get_filename_by_file_num(file_num: usize) -> String {
     with_file_map(|map| {
@@ -196,6 +209,47 @@ mod tests {
 
     use super::*;
 
+    #[test]
+    #[serial]
+    fn test_seed_file_numbers_numbers_buckets_not_their_members() {
+        reset_file_map();
+        set_canonical_map(std::collections::HashMap::from([(
+            "x.tsx".to_string(),
+            "a.tsx".to_string(),
+        )]));
+        seed_file_numbers(&[
+            "x.tsx".to_string(),
+            "b.tsx".to_string(),
+            "a.tsx".to_string(),
+        ]);
+        assert_eq!(get_file_num_by_filename("a.tsx"), 0);
+        assert_eq!(get_file_num_by_filename("b.tsx"), 1);
+        assert_eq!(get_file_map().len(), 2);
+        reset_canonical_map();
+        reset_file_map();
+    }
+
+    #[test]
+    #[serial]
+    fn test_seed_file_numbers_is_independent_of_order() {
+        reset_file_map();
+        seed_file_numbers(&[
+            "b.tsx".to_string(),
+            "a.tsx".to_string(),
+            "b.tsx".to_string(),
+        ]);
+        assert_eq!(get_file_num_by_filename("a.tsx"), 0);
+        assert_eq!(get_file_num_by_filename("b.tsx"), 1);
+        seed_file_numbers(&[
+            "c.tsx".to_string(),
+            "0.tsx".to_string(),
+            "a.tsx".to_string(),
+        ]);
+        assert_eq!(get_file_num_by_filename("a.tsx"), 0);
+        assert_eq!(get_file_num_by_filename("0.tsx"), 2);
+        assert_eq!(get_file_num_by_filename("c.tsx"), 3);
+        reset_file_map();
+    }
     #[test]
     #[serial]
     fn test_set_and_get_file_map() {