@sigx/lynx-plugin 0.4.0 → 0.4.2

package/dist/layers.js

@@ -0,0 +1,5 @@
+/** Webpack module layers used to separate the dual-thread bundles. */
+export const LAYERS = {
+    BACKGROUND: 'sigx:background',
+    MAIN_THREAD: 'sigx:main-thread',
+};

package/dist/loaders/hmr-loader.js

@@ -1,20 +1,71 @@
-//#region src/loaders/hmr-loader.ts
-var e = /\bcomponent\s*[<(]/, t = /import\s*\{([^}]*)\bsignal\b([^}]*)\}\s*from\s*(['"])@sigx\/lynx\3/;
-function n(n) {
-	if (this.cacheable(!1), !e.test(n)) return n;
-	let r = this.resourcePath.replace(/\\/g, "/").replace(/\.(tsx?|jsx)$/, ""), i = !!n.match(t), a = n;
-	i && (a = n.replace(t, (e, t, n, r) => `import {${t}signal as __origSignal${n}} from ${r}@sigx/lynx${r}`));
-	let o = [
-		"import { __registerComponentPlugin, __setCurrentInstanceForHMR } from '@sigx/lynx';",
-		"import { initHMR, registerHMRModule } from '@sigx/lynx-runtime/hmr';",
-		"initHMR(__registerComponentPlugin, __setCurrentInstanceForHMR);",
-		`registerHMRModule(${JSON.stringify(r)});`
-	];
-	i && o.push("var __hmrSigPrev = (typeof module !== 'undefined' && module.hot && module.hot.data && module.hot.data.__hmrSigs) || {};", "var __hmrSigStore = {};", "var __hmrSigIdx = 0;", "function signal() {", "  var k = 's' + __hmrSigIdx++;", "  if (k in __hmrSigPrev) { __hmrSigStore[k] = __hmrSigPrev[k]; return __hmrSigPrev[k]; }", "  var s = __origSignal.apply(null, arguments);", "  __hmrSigStore[k] = s;", "  return s;", "}"), o.push("");
-	let s = [""];
-	return i ? s.push("if (typeof module !== 'undefined' && module.hot) {", "  module.hot.dispose(function(data) { data.__hmrSigs = __hmrSigStore; });", "  module.hot.accept();", "}") : s.push("if (typeof module !== 'undefined' && module.hot) { module.hot.accept(); }"), o.join("\n") + a + s.join("\n");
+/**
+ * Rspack loader that injects HMR self-acceptance into component files.
+ *
+ * For every file that contains a `component(` or `component<` call, the
+ * loader prepends:
+ *   1. An import of `__registerComponentPlugin` from `@sigx/lynx` — this
+ *      is the *same* bundle the app uses, so the plugin array is shared.
+ *   2. An import of `initHMR` + `registerHMRModule` from `@sigx/lynx-runtime/hmr`.
+ *   3. Calls to wire them up: `initHMR(__registerComponentPlugin)` (idempotent)
+ *      and `registerHMRModule(moduleId)`.
+ *   4. (If `signal` is imported) A wrapper that preserves signal objects
+ *      across HMR cycles via `module.hot.data`, so module-level reactive
+ *      state (e.g., a route signal) doesn't reset and cause structural tree
+ *      mutations that crash the Lynx native engine.
+ *
+ * And appends `module.hot.accept()` + a dispose handler that snapshots
+ * preserved signals into `module.hot.data` for the next execution.
+ *
+ * On re-execution the HMR runtime patches existing component instances
+ * in-place — only property-level ops are emitted, avoiding the structural
+ * tree mutations that crash Lynx's native engine.
+ */
+// Matches `component(` or `component<`
+const COMPONENT_RE = /\bcomponent\s*[<(]/;
+// Matches an import statement from @sigx/lynx that destructures `signal`.
+// Captures: (1) before-signal names, (2) after-signal names, (3) quote char
+// e.g.  import { signal, component } from '@sigx/lynx';
+//          group 1: ""   group 2: ", component "  group 3: "'"
+const SIGNAL_IMPORT_RE = /import\s*\{([^}]*)\bsignal\b([^}]*)\}\s*from\s*(['"])@sigx\/lynx\3/;
+export default function hmrLoader(source) {
+    this.cacheable(false);
+    if (!COMPONENT_RE.test(source)) {
+        return source;
+    }
+    const moduleId = this.resourcePath
+        .replace(/\\/g, '/')
+        .replace(/\.(tsx?|jsx)$/, '');
+    // Check if the file imports `signal` from @sigx/lynx
+    const signalImportMatch = source.match(SIGNAL_IMPORT_RE);
+    const hasSignalImport = !!signalImportMatch;
+    let transformedSource = source;
+    if (hasSignalImport) {
+        // Rename `signal` → `__origSignal` in the import statement so we can
+        // shadow it with a preserving wrapper.  All call-sites automatically
+        // use the wrapper because the local binding name stays `signal`.
+        transformedSource = source.replace(SIGNAL_IMPORT_RE, (_match, before, after, quote) => `import {${before}signal as __origSignal${after}} from ${quote}@sigx/lynx${quote}`);
+    }
+    const header = [
+        `import { __registerComponentPlugin, __setCurrentInstanceForHMR } from '@sigx/lynx';`,
+        `import { initHMR, registerHMRModule } from '@sigx/lynx-runtime/hmr';`,
+        `initHMR(__registerComponentPlugin, __setCurrentInstanceForHMR);`,
+        `registerHMRModule(${JSON.stringify(moduleId)});`,
+    ];
+    if (hasSignalImport) {
+        // Inject a `signal` wrapper that returns the cached signal object from
+        // the previous HMR cycle when one exists, or delegates to the real
+        // `signal()` for new signals.  This preserves module-level reactive
+        // state (and component-level state inside setup — matching React Fast
+        // Refresh behaviour where hooks state is preserved across HMR).
+        header.push(`var __hmrSigPrev = (typeof module !== 'undefined' && module.hot && module.hot.data && module.hot.data.__hmrSigs) || {};`, `var __hmrSigStore = {};`, `var __hmrSigIdx = 0;`, `function signal() {`, `  var k = 's' + __hmrSigIdx++;`, `  if (k in __hmrSigPrev) { __hmrSigStore[k] = __hmrSigPrev[k]; return __hmrSigPrev[k]; }`, `  var s = __origSignal.apply(null, arguments);`, `  __hmrSigStore[k] = s;`, `  return s;`, `}`);
+    }
+    header.push('');
+    const footer = [''];
+    if (hasSignalImport) {
+        footer.push(`if (typeof module !== 'undefined' && module.hot) {`, `  module.hot.dispose(function(data) { data.__hmrSigs = __hmrSigStore; });`, `  module.hot.accept();`, `}`);
+    }
+    else {
+        footer.push(`if (typeof module !== 'undefined' && module.hot) { module.hot.accept(); }`);
+    }
+    return header.join('\n') + transformedSource + footer.join('\n');
 }
-//#endregion
-export { n as default };
-
-//# sourceMappingURL=hmr-loader.js.map

package/dist/loaders/ignore-css-loader.js

@@ -1,8 +1,17 @@
-//#region src/loaders/ignore-css-loader.ts
-function e(e) {
-	return this.cacheable(!0), e.includes("___CSS_LOADER_EXPORT___") ? "export {}" : e;
+/**
+ * Webpack/Rspack loader that strips CSS from Main-Thread bundles.
+ *
+ * In the Lynx dual-thread model, only the Background Thread needs CSS.
+ * The Main-Thread layer uses `exportOnlyLocals` from css-loader to get
+ * CSS module class name mappings without actual styles.
+ */
+export default function ignoreCssLoader(source) {
+    this.cacheable(true);
+    // If the source contains ___CSS_LOADER_EXPORT___, it is not a CSS Modules
+    // file (exportOnlyLocals is enabled), so we don't need to preserve it.
+    if (source.includes('___CSS_LOADER_EXPORT___')) {
+        return 'export {}';
+    }
+    // Preserve CSS modules export for background layer.
+    return source;
 }
-//#endregion
-export { e as default };
-
-//# sourceMappingURL=ignore-css-loader.js.map

package/dist/loaders/worklet-loader-mt.js

@@ -1,64 +1,144 @@
-import { dirname as e, join as t } from "node:path";
-import { createRequire as n } from "node:module";
-import { transformReactLynxSync as r } from "@lynx-js/react/transform";
-//#region src/loaders/worklet-utils.ts
-function i(e) {
-	let t = e.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/[^\n]*/g, "$1"), n = /* @__PURE__ */ new Set(), r = /(?:from|import)\s+['"]((?:\.[^'"]+)|(?:@sigx\/[^'"]+))['"]/g, i;
-	for (; (i = r.exec(t)) !== null;) n.add(i[1]);
-	return n.size === 0 ? "" : [...n].map((e) => `import '${e}';`).join("\n");
+/**
+ * MT-layer rspack loader for the `'main thread'` worklet directive.
+ *
+ * Runs on every JS/TS file in the MT layer — no rule-level exclude.
+ * Decides per-file what to emit based on directive presence and whether
+ * the file is library code (`node_modules/` or `dist/`) or user code:
+ *
+ *   | Origin       | Directive? | Output                                         |
+ *   |--------------|------------|------------------------------------------------|
+ *   | user code    | no         | bootstrap preamble + side-effect imports       |
+ *   |              |            |   (drops body — sigx's Lepus never executes    |
+ *   |              |            |    React components; `entry-main.ts`'s         |
+ *   |              |            |    `renderPage` builds a placeholder and ops   |
+ *   |              |            |    arrive from BG via `sigxPatchUpdate`)       |
+ *   | user code    | yes        | bootstrap preamble + side-effect imports       |
+ *   |              |            |   + extracted `registerWorkletInternal(...)`   |
+ *   | library      | no         | source unchanged                               |
+ *   |              |            |   (preserves `@sigx/lynx-runtime-main`'s MT    |
+ *   |              |            |    globals — `processData`, `updateGlobalProps`,|
+ *   |              |            |    `sigxRunOnMT` — and barrel re-exports that  |
+ *   |              |            |    BG-side consumers like daisyui import by    |
+ *   |              |            |    name; rspack shares module identity across  |
+ *   |              |            |    BG/MT layers)                                |
+ *   | library      | yes        | source unchanged + appended registrations      |
+ *   |              |            |   (keeps named exports AND registers worklets) |
+ *
+ * Library files skip the bootstrap preamble — the user entry's
+ * preamble has already pulled runtime-main in before any library code
+ * evaluates.
+ *
+ * For files WITH a directive, the LEPUS transform's output is sliced
+ * via `extractRegistrations` so only the `registerWorkletInternal(...)`
+ * calls are kept. The `loadWorkletRuntime` import that upstream emits
+ * is dropped — `registerWorkletInternal` is installed as a global by
+ * `entry-main.ts`.
+ *
+ * Mirrors vue-lynx's `worklet-loader-mt.ts`, minus the `?vue` sub-module
+ * branch (sigx has no Vue SFC pipeline) and minus the shared-imports path
+ * (deferred to Phase 1c).
+ */
+import { transformReactLynxSync } from '@lynx-js/react/transform';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { extractLocalImports, extractRegistrations } from './worklet-utils.js';
+// Same idiomatic-barrel matching as the BG loader (see worklet-loader.ts:23
+// for the full rationale). The LEPUS pass emits an `import { loadWorkletRuntime
+// } from '<runtimePkg>'`, but `extractRegistrations` slices the LEPUS output
+// down to `registerWorkletInternal(...)` calls only — the import is dropped
+// before bundling — so the runtimePkg's actual exports don't need to include
+// loadWorkletRuntime. What matters here is identifier tracking: aligning
+// with '@sigx/lynx' means SWC follows `runOnBackground as s` through
+// '@sigx/lynx' barrel imports just like on the BG side.
+const RUNTIME_PKG = '@sigx/lynx';
+/**
+ * Prepended to every MT-layer file so webpack's dep graph guarantees the
+ * bootstrap modules evaluate BEFORE any user code that calls
+ * `registerWorkletInternal(...)`. Listing these as separate entries in
+ * `entry.ts` doesn't suffice — rspack walks the chunk graph, which can
+ * eval user code first when nothing else explicitly depends on bootstrap.
+ *
+ * Order matters: entry-main's module body sets globalThis.SystemInfo before
+ * worklet-runtime's IIFE reads it.
+ *
+ * Paths are resolved to absolute file URIs at loader-init time so user apps
+ * don't need to declare @lynx-js/react as a direct dep — pnpm hoists it into
+ * our package's node_modules and we hand rspack the resolved path. We resolve
+ * the package's `package.json` (always reachable, no exports-map games), read
+ * the dist subpath relative to it. createRequire(import.meta.url) lets us
+ * walk up from the loader's install location via Node's CJS resolver.
+ */
+const _req = createRequire(import.meta.url);
+function resolvePackageSubpath(pkgName, subpath) {
+    const pkgJsonPath = _req.resolve(`${pkgName}/package.json`);
+    return join(dirname(pkgJsonPath), subpath);
 }
-function a(e) {
-	let t = [], n = 0;
-	for (;;) {
-		let r = e.indexOf("registerWorkletInternal(", n);
-		if (r === -1) break;
-		let i = 0, a = r + 24 - 1;
-		for (; a < e.length; a++) {
-			let t = e[a];
-			if (t === "(") i++;
-			else if (t === ")" && (i--, i === 0)) break;
-		}
-		let o = a + 1;
-		o < e.length && e[o] === ";" && o++, t.push(e.slice(r, o)), n = o;
-	}
-	return t.join("\n");
+const ENTRY_MAIN_PATH = resolvePackageSubpath('@sigx/lynx-runtime-main', 'dist/entry-main.js');
+const WORKLET_RUNTIME_PATH = resolvePackageSubpath('@lynx-js/react', 'runtime/worklet-runtime/main.js');
+const INSTALL_HYBRID_PATH = resolvePackageSubpath('@sigx/lynx-runtime-main', 'dist/install-hybrid-worklet.js');
+const BOOTSTRAP_PREAMBLE = `import ${JSON.stringify(ENTRY_MAIN_PATH)};\n`
+    + `import ${JSON.stringify(WORKLET_RUNTIME_PATH)};\n`
+    + `import ${JSON.stringify(INSTALL_HYBRID_PATH)};\n`;
+// Cheap pre-filter to skip the SWC parse for files that obviously don't
+// contain a worklet directive. A directive is always followed immediately
+// by a statement terminator — either `;` or a newline (ASI). Requiring
+// one of those after the closing quote rejects substrings inside
+// single-line error strings like
+// `"...inside 'main thread' functions..."` from `@sigx/lynx-runtime`'s
+// dist, where the next char is a space then `functions`.
+//
+// This is not a parser. A truly adversarial input (e.g. the literal
+// string `"'main thread';"`) can slip through, and SWC is the final
+// arbiter — for such files it produces no registrations and the MT
+// output reduces to the library branch's source pass-through (for
+// library paths) or to the no-directive user branch's strip (for user
+// paths). Either way: correct, just with the parse work done.
+const DIRECTIVE_RE = /['"]main thread['"]\s*(?:;|\n)/;
+// Library paths (`node_modules/` and any `dist/`) get the body-preserve
+// branches above. Rspack shares module identity across BG/MT layers, so
+// stripping the MT-side body of a library file would wipe its named
+// exports for BG consumers too — daisyui couldn't resolve `useTabs` from
+// lynx-navigation, runtime-main's MT globals would disappear, etc.
+const LIBRARY_PATH_RE = /[\\/](?:node_modules|dist)[\\/]/;
+export default function workletLoaderMT(source) {
+    this.cacheable(true);
+    const localImports = extractLocalImports(source);
+    if (!DIRECTIVE_RE.test(source)) {
+        if (LIBRARY_PATH_RE.test(this.resourcePath)) {
+            return source;
+        }
+        return BOOTSTRAP_PREAMBLE + localImports;
+    }
+    const filename = this.resourcePath;
+    const result = transformReactLynxSync(source, {
+        pluginName: 'sigx:worklet-mt',
+        filename,
+        sourcemap: false,
+        cssScope: false,
+        shake: false,
+        compat: false,
+        refresh: false,
+        defineDCE: false,
+        directiveDCE: false,
+        snapshot: false,
+        worklet: { target: 'LEPUS', filename, runtimePkg: RUNTIME_PKG },
+    });
+    if (result.errors && result.errors.length > 0) {
+        for (const err of result.errors) {
+            this.emitError(new Error(`[sigx-worklet-mt] LEPUS transform: ${err.text}`));
+        }
+        return localImports;
+    }
+    const registrations = extractRegistrations(result.code);
+    // Library files with a directive (e.g. lynx-navigation's `EdgeBackHandle.js`,
+    // `navigator/core.js`): preserve the original source so its named exports
+    // survive cross-layer module identity (BG-side consumers like daisyui
+    // import them by name), and append the `registerWorkletInternal` calls so
+    // the directives are still registered on the MT side. No bootstrap
+    // preamble — user entry code's preamble has already pulled runtime-main
+    // in before any library code is evaluated.
+    if (LIBRARY_PATH_RE.test(this.resourcePath)) {
+        return registrations ? `${source}\n${registrations}` : source;
+    }
+    return BOOTSTRAP_PREAMBLE + [localImports, registrations].filter(Boolean).join('\n');
 }
-//#endregion
-//#region src/loaders/worklet-loader-mt.ts
-var o = "@sigx/lynx-runtime-main", s = n(import.meta.url);
-function c(n, r) {
-	return t(e(s.resolve(`${n}/package.json`)), r);
-}
-var l = c("@sigx/lynx-runtime-main", "dist/entry-main.js"), u = c("@lynx-js/react", "runtime/worklet-runtime/main.js"), d = c("@sigx/lynx-runtime-main", "dist/install-hybrid-worklet.js"), f = `import ${JSON.stringify(l)};\nimport ${JSON.stringify(u)};\nimport ${JSON.stringify(d)};\n`, p = /['"]main thread['"]\s*(?:;|\n)/, m = /[\\/](?:node_modules|dist)[\\/]/;
-function h(e) {
-	this.cacheable(!0);
-	let t = i(e);
-	if (!p.test(e)) return m.test(this.resourcePath) ? e : f + t;
-	let n = this.resourcePath, s = r(e, {
-		pluginName: "sigx:worklet-mt",
-		filename: n,
-		sourcemap: !1,
-		cssScope: !1,
-		shake: !1,
-		compat: !1,
-		refresh: !1,
-		defineDCE: !1,
-		directiveDCE: !1,
-		snapshot: !1,
-		worklet: {
-			target: "LEPUS",
-			filename: n,
-			runtimePkg: o
-		}
-	});
-	if (s.errors && s.errors.length > 0) {
-		for (let e of s.errors) this.emitError(/* @__PURE__ */ Error(`[sigx-worklet-mt] LEPUS transform: ${e.text}`));
-		return t;
-	}
-	let c = a(s.code);
-	return m.test(this.resourcePath) ? c ? `${e}\n${c}` : e : f + [t, c].filter(Boolean).join("\n");
-}
-//#endregion
-export { h as default };
-
-//# sourceMappingURL=worklet-loader-mt.js.map

package/dist/loaders/worklet-loader.js

@@ -1,32 +1,70 @@
-import { transformReactLynxSync as e } from "@lynx-js/react/transform";
-//#region src/loaders/worklet-loader.ts
-var t = "@sigx/lynx-runtime", n = /['"]main thread['"]\s*(?:;|\n)/;
-function r(r) {
-	if (this.cacheable(!0), !n.test(r)) return r;
-	let i = this.resourcePath, a = e(r, {
-		pluginName: "sigx:worklet",
-		filename: i,
-		sourcemap: !1,
-		cssScope: !1,
-		shake: !1,
-		compat: !1,
-		refresh: !1,
-		defineDCE: !1,
-		directiveDCE: !1,
-		snapshot: !1,
-		worklet: {
-			target: "JS",
-			filename: i,
-			runtimePkg: t
-		}
-	});
-	if (a.errors && a.errors.length > 0) {
-		for (let e of a.errors) this.emitError(/* @__PURE__ */ Error(`[sigx-worklet] JS transform: ${e.text}`));
-		return r;
-	}
-	return a.code;
+/**
+ * BG-layer rspack loader for the `'main thread'` worklet directive.
+ *
+ * Delegates to upstream's `transformReactLynxSync` (a framework-agnostic SWC
+ * worklet transform shared with vue-lynx and react-lynx — see
+ * docs/mts-upstream-spike.md). With `target: 'JS'`, each `'main thread'`-marked
+ * function is replaced by a `{ _wkltId, _c? }` placeholder object that the
+ * sigx BG runtime ships through SET_WORKLET_EVENT to MT.
+ *
+ * Files without the directive are passed through unchanged. The MT side is
+ * handled by the sibling `worklet-loader-mt.ts`.
+ */
+import { transformReactLynxSync } from '@lynx-js/react/transform';
+// runtimePkg controls where SWC emits `import { transformToWorklet } from <X>`
+// at the top of transformed BG output (used when `runOnBackground(fn)` is
+// detected inside a `'main thread'` body). Points at @sigx/lynx — the public
+// barrel that re-exports everything from @sigx/lynx-runtime — so the emitted
+// import matches the idiomatic path apps use, with no need for the internal
+// lynx-runtime specifier to be reachable from every consumer.
+//
+// SWC's identifier matching for `runOnBackground` itself is by literal symbol
+// name (see lynx-stack/packages/react/transform/.../extract_ident.rs's
+// `n.callee.sym != "runOnBackground"` check) — it does NOT follow renamed
+// import bindings. Packages that ship precompiled worklet code must therefore
+// preserve the `runOnBackground` identifier in their dist (no mangling). The
+// canonical pattern is the one upstream `@lynx-js/react` uses: `tsc`-only
+// per-file emit, no bundler, no minifier. `@sigx/lynx-gestures` follows that
+// pattern for the same reason — see its package.json `build` script.
+const RUNTIME_PKG = '@sigx/lynx';
+// Cheap pre-filter to skip the SWC parse for files that obviously don't
+// contain a worklet directive. A directive is always followed immediately
+// by a statement terminator — either `;` or a newline (ASI). Requiring
+// one of those after the closing quote rejects substrings inside
+// single-line error strings like
+// `"...inside 'main thread' functions..."` from `@sigx/lynx-runtime`'s
+// dist, where the next char is a space then `functions`.
+//
+// This is not a parser. A truly adversarial input (e.g. the literal
+// string `"'main thread';"`) can slip through, and the SWC transform
+// is the final arbiter — for such files it produces no registrations
+// and the BG output is identical to the no-directive path, just with
+// the parse work done.
+const DIRECTIVE_RE = /['"]main thread['"]\s*(?:;|\n)/;
+export default function workletLoader(source) {
+    this.cacheable(true);
+    if (!DIRECTIVE_RE.test(source)) {
+        return source;
+    }
+    const filename = this.resourcePath;
+    const result = transformReactLynxSync(source, {
+        pluginName: 'sigx:worklet',
+        filename,
+        sourcemap: false,
+        cssScope: false,
+        shake: false,
+        compat: false,
+        refresh: false,
+        defineDCE: false,
+        directiveDCE: false,
+        snapshot: false,
+        worklet: { target: 'JS', filename, runtimePkg: RUNTIME_PKG },
+    });
+    if (result.errors && result.errors.length > 0) {
+        for (const err of result.errors) {
+            this.emitError(new Error(`[sigx-worklet] JS transform: ${err.text}`));
+        }
+        return source;
+    }
+    return result.code;
 }
-//#endregion
-export { r as default };
-
-//# sourceMappingURL=worklet-loader.js.map

package/dist/loaders/worklet-utils.d.ts

@@ -28,19 +28,4 @@
  * _wkltId is looked up in `lynxWorkletImpl._workletMap`.
  */
 export declare function extractLocalImports(source: string): string;
-/**
- * Extract `registerWorkletInternal(...)` calls from a LEPUS-target transform output.
- *
- * Upstream's LEPUS output includes:
- *   - `import { loadWorkletRuntime as __loadWorkletRuntime } from "<runtimePkg>";`
- *   - `var loadWorkletRuntime = __loadWorkletRuntime;`
- *   - the original component code (which we drop — never invoked on MT)
- *   - `const __workletRuntimeLoaded = loadWorkletRuntime(...);`
- *   - `__workletRuntimeLoaded && registerWorkletInternal("main-thread", "<id>", function(...) { ... });`
- *
- * We only need the `registerWorkletInternal(...)` calls — the loadWorkletRuntime
- * gating is redundant because we only inject the calls when the MT bundle is
- * actually being built. Bracket-depth counting handles nested braces in the
- * function body.
- */
 export declare function extractRegistrations(lepusCode: string): string;

package/dist/loaders/worklet-utils.js

@@ -0,0 +1,116 @@
+/**
+ * Helpers shared by worklet-loader (BG) and worklet-loader-mt (MT).
+ *
+ * Mirrors vue-lynx's `worklet-utils.ts` minus the `?vue` sub-module logic
+ * (sigx has no Vue Single-File-Component pipeline) and minus the
+ * `extractSharedImports` path (deferred to Phase 1c — see plan).
+ */
+/**
+ * Extract import statements whose target may contain `'main thread'` worklets
+ * the MT bundle needs to register.
+ *
+ * Two import flavours qualify:
+ *   - Relative paths (`./foo`, `../bar`) — user code split across files.
+ *   - `@sigx/*` package paths — workspace component packages like
+ *     `@sigx/gestures` that ship `<Pressable>`/`<Draggable>` etc. These resolve
+ *     to workspace `src/` (not node_modules) so the MT loader's rule still
+ *     processes them; we just need to preserve the edge so rspack walks there.
+ *
+ * Converts named/default/namespace imports to side-effect-only imports
+ * (`import '@sigx/gestures';`) so webpack still follows the dependency graph
+ * without executing user code on the MT layer.
+ *
+ * Critical for the MT loader: an entry like `main.tsx` may not contain any
+ * `'main thread'` directives itself, but it imports route/component files
+ * that do. Without preserving these edges, webpack would never reach the
+ * files with worklet registrations and MT-side hydration of BG worklet ctxs
+ * would throw "cannot read property bind of undefined" when the unregistered
+ * _wkltId is looked up in `lynxWorkletImpl._workletMap`.
+ */
+export function extractLocalImports(source) {
+    // Strip line and block comments so docstring examples like
+    // `* import X from './foo'` don't get parsed as real imports.
+    // String contents are left intact (we still catch `import './foo'` inside
+    // a string template), but real source rarely encodes import-statement
+    // shapes inside strings, and the false-positive rate with comments stripped
+    // is acceptable for this preserve-edges-only loader.
+    const stripped = source
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/(^|[^:])\/\/[^\n]*/g, '$1');
+    const specifiers = new Set();
+    // Relative paths (./foo, ../bar) and @sigx/* package paths.
+    const re = /(?:from|import)\s+['"]((?:\.[^'"]+)|(?:@sigx\/[^'"]+))['"]/g;
+    let match;
+    while ((match = re.exec(stripped)) !== null) {
+        specifiers.add(match[1]);
+    }
+    if (specifiers.size === 0)
+        return '';
+    return [...specifiers].map((s) => `import '${s}';`).join('\n');
+}
+/**
+ * Extract `registerWorkletInternal(...)` calls from a LEPUS-target transform output.
+ *
+ * Upstream's LEPUS output includes:
+ *   - `import { loadWorkletRuntime as __loadWorkletRuntime } from "<runtimePkg>";`
+ *   - `var loadWorkletRuntime = __loadWorkletRuntime;`
+ *   - the original component code (which we drop — never invoked on MT)
+ *   - `const __workletRuntimeLoaded = loadWorkletRuntime(...);`
+ *   - `__workletRuntimeLoaded && registerWorkletInternal("main-thread", "<id>", function(...) { ... });`
+ *
+ * We only need the `registerWorkletInternal(...)` calls — the loadWorkletRuntime
+ * gating is redundant because we only inject the calls when the MT bundle is
+ * actually being built. Bracket-depth counting handles nested braces in the
+ * function body.
+ *
+ * SWC's LEPUS transform preserves JSDoc / comments verbatim. When source code
+ * carries documentation that *mentions* the literal token
+ * `registerWorkletInternal(...)` (as `lynx-runtime`'s `threading.ts` does), a
+ * naive scan would extract that doc text as a "registration" and append it to
+ * the MT bundle as invalid JS (`function(...) { ... }` isn't real syntax).
+ * Strip comments before scanning so only real statements survive.
+ */
+function stripJsComments(code) {
+    // Two passes — block comments first, then line comments. Block-first
+    // is important: a `// inside */` sequence inside a `/* ... */` block
+    // would otherwise have the inner `//` eaten by the line-comment pass
+    // before the outer block is matched, leaving stray `*/` in the output.
+    // We don't try to be string-literal-aware (a comment-looking sequence
+    // inside a string would be wrongly stripped) because:
+    //   1. The input is SWC output, which doesn't put `//` or `/* */` inside
+    //      strings except in trivial constant cases we don't care about.
+    //   2. `extractRegistrations` only cares about call shapes; the surrounding
+    //      code is discarded anyway.
+    return code
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/(^|[^:])\/\/[^\n]*/g, '$1');
+}
+export function extractRegistrations(lepusCode) {
+    const code = stripJsComments(lepusCode);
+    const out = [];
+    const marker = 'registerWorkletInternal(';
+    let from = 0;
+    while (true) {
+        const idx = code.indexOf(marker, from);
+        if (idx === -1)
+            break;
+        let depth = 0;
+        let i = idx + marker.length - 1; // points at the opening '('
+        for (; i < code.length; i++) {
+            const ch = code[i];
+            if (ch === '(')
+                depth++;
+            else if (ch === ')') {
+                depth--;
+                if (depth === 0)
+                    break;
+            }
+        }
+        let end = i + 1;
+        if (end < code.length && code[end] === ';')
+            end++;
+        out.push(code.slice(idx, end));
+        from = end;
+    }
+    return out.join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigx/lynx-plugin",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Rspack/Rspeedy plugin for SignalX Lynx dual-thread rendering",
   "type": "module",
   "main": "./dist/index.js",
@@ -33,8 +33,9 @@
     "url": "https://github.com/signalxjs/lynx/issues"
   },
   "dependencies": {
-    "@lynx-js/react": "^0.120.0",
-    "@sigx/lynx-runtime-internal": "0.4.0"
+    "@lynx-js/react": "^0.121.0",
+    "ws": "^8.20.1",
+    "@sigx/lynx-runtime-internal": "0.4.2"
   },
   "peerDependencies": {
     "@rspack/core": ">=1.0.0",
@@ -43,8 +44,8 @@
     "@lynx-js/template-webpack-plugin": ">=0.1.0",
     "@lynx-js/runtime-wrapper-webpack-plugin": ">=0.1.0",
     "@lynx-js/webpack-dev-transport": ">=0.1.0",
-    "@sigx/lynx-cli": "^0.4.0",
-    "@sigx/lynx-icons": "^0.4.0"
+    "@sigx/lynx-cli": "^0.4.2",
+    "@sigx/lynx-icons": "^0.4.2"
   },
   "peerDependenciesMeta": {
     "@rspack/core": {
@@ -71,18 +72,19 @@
   },
   "devDependencies": {
     "@rsbuild/core": "^1.7.5",
-    "@sigx/vite": "^0.4.3",
-    "@types/node": "^25.7.0",
+    "@types/node": "^25.9.1",
+    "@types/ws": "^8.5.13",
+    "@typescript/native-preview": "7.0.0-dev.20260521.1",
     "typescript": "^6.0.3",
-    "vite": "^8.0.12",
-    "@sigx/lynx-cli": "0.4.0",
-    "@sigx/lynx-icons": "0.4.0"
+    "@sigx/lynx-cli": "0.4.2",
+    "@sigx/lynx-icons": "0.4.2"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "vite build && tsgo --emitDeclarationOnly",
-    "dev": "vite build --watch"
+    "build": "node ../../scripts/clean.mjs dist && tsgo",
+    "dev": "tsgo --watch",
+    "clean": "node ../../scripts/clean.mjs dist .turbo"
   }
 }