@aihu/compiler 1.1.6 → 1.3.0

package/README.md

@@ -21,7 +21,7 @@ npm install @aihu/compiler
 bun add @aihu/compiler
 ```
 
-<sub><i>Auto-generated against `@aihu/compiler@1.1.6`.</i></sub>
+<sub><i>Auto-generated against `@aihu/compiler@1.3.0`.</i></sub>
 
 <!-- END_AUTOGEN: install -->
 
@@ -32,12 +32,12 @@ bun add @aihu/compiler
 
 | | |
 |---|---|
-| **Version** | `1.1.6` |
+| **Version** | `1.3.0` |
 | **Tier** | D — Compiler — Single-File Component (.aihu) → Web Component |
 | **Published files** | 4 entries |
 | **License** | MIT |
 
-<sub><i>Auto-generated against `@aihu/compiler@1.1.6`.</i></sub>
+<sub><i>Auto-generated against `@aihu/compiler@1.3.0`.</i></sub>
 
 <!-- END_AUTOGEN: stats -->
 
@@ -50,7 +50,7 @@ bun add @aihu/compiler
 |---|---|---|
 | `.` | `./dist/index.js` | `—` |
 
-<sub><i>Auto-generated against `@aihu/compiler@1.1.6`.</i></sub>
+<sub><i>Auto-generated against `@aihu/compiler@1.3.0`.</i></sub>
 
 <!-- END_AUTOGEN: exports -->
 
@@ -65,18 +65,18 @@ bun add @aihu/compiler
 
 **Optional dependencies (platform-specific):**
 
-- `@aihu/compiler-darwin-arm64` — `0.1.47`
-- `@aihu/compiler-darwin-x64` — `0.1.47`
-- `@aihu/compiler-linux-x64-gnu` — `0.1.47`
-- `@aihu/compiler-linux-arm64-gnu` — `0.1.47`
-- `@aihu/compiler-win32-x64-msvc` — `0.1.47`
-- `@aihu/compiler-native-darwin-arm64` — `0.1.12`
-- `@aihu/compiler-native-darwin-x64` — `0.1.12`
-- `@aihu/compiler-native-linux-x64-gnu` — `0.1.12`
-- `@aihu/compiler-native-linux-arm64-gnu` — `0.1.12`
-- `@aihu/compiler-native-win32-x64-msvc` — `0.1.12`
+- `@aihu/compiler-darwin-arm64` — `0.1.54`
+- `@aihu/compiler-darwin-x64` — `0.1.54`
+- `@aihu/compiler-linux-x64-gnu` — `0.1.54`
+- `@aihu/compiler-linux-arm64-gnu` — `0.1.54`
+- `@aihu/compiler-win32-x64-msvc` — `0.1.54`
+- `@aihu/compiler-native-darwin-arm64` — `0.1.19`
+- `@aihu/compiler-native-darwin-x64` — `0.1.19`
+- `@aihu/compiler-native-linux-x64-gnu` — `0.1.19`
+- `@aihu/compiler-native-linux-arm64-gnu` — `0.1.19`
+- `@aihu/compiler-native-win32-x64-msvc` — `0.1.19`
 
-<sub><i>Auto-generated against `@aihu/compiler@1.1.6`.</i></sub>
+<sub><i>Auto-generated against `@aihu/compiler@1.3.0`.</i></sub>
 
 <!-- END_AUTOGEN: deps -->
 
@@ -90,7 +90,7 @@ bun add @aihu/compiler
 - [Macro Vocabulary spec](../../docs/superpowers/specs/2026-05-02-spec-macro-vocabulary.md)
 - [Aihu framework root](../../README.md)
 
-<sub><i>Auto-generated against `@aihu/compiler@1.1.6`.</i></sub>
+<sub><i>Auto-generated against `@aihu/compiler@1.3.0`.</i></sub>
 
 <!-- END_AUTOGEN: see-also -->
 
@@ -101,6 +101,6 @@ bun add @aihu/compiler
 
 MIT — see [LICENSE](../../LICENSE).
 
-<sub><i>Auto-generated against `@aihu/compiler@1.1.6`.</i></sub>
+<sub><i>Auto-generated against `@aihu/compiler@1.3.0`.</i></sub>
 
 <!-- END_AUTOGEN: license -->

package/dist/index.d.ts

@@ -1,36 +1,87 @@
-//#region js/envelope.d.ts
+//#region js/native.d.ts
+/**
+ * @aihu/compiler native-addon loader — the in-process compile fast path.
+ *
+ * A `native.ts`-style loader in the mold of packages/server/src/native.ts:
+ * platform matrix → per-platform optionalDependency package → dev fallback,
+ * with explicit escape hatches and a cached three-state result. The addon
+ * (packages/compiler/src-native, napi-rs) exposes
+ * `compileEnvelope(source, optionsJson) → envelopeJson` — one boundary
+ * crossing per file — which `js/envelope.ts` routes `transform()` /
+ * `compileToAst()` / `compileRouteMeta()` through.
+ *
+ * States:
+ *   - loaded:      addon required successfully; compiles run in-process.
+ *   - disabled:    `AIHU_COMPILER_NATIVE=0` — the documented escape hatch.
+ *   - unavailable: no addon for this platform / load failed. UNLIKE
+ *                  @aihu/server's fail-loud contract, a failed load here is a
+ *                  one-shot WARNING, not a throw: the CLI spawn path is a
+ *                  byte-identical fallback that always exists, so failing the
+ *                  whole build over a fast-path load would be strictly worse.
+ *                  The exception is `AIHU_COMPILER_NATIVE_ADDON=<path>` — an
+ *                  explicit override that fails loud (same doctrine as
+ *                  AIHU_COMPILE_BIN: a pinned path that doesn't load is a
+ *                  configuration error, and silently ignoring it hands back a
+ *                  plausible-looking wrong backend).
+ */
+interface CompilerNativeAddon {
+  compileEnvelope(source: string, optionsJson: string): string;
+  /**
+   * The version string baked into the addon at build time. Present since
+   * @aihu/compiler-native 0.1.x; ABSENT on older addons, which is why every
+   * consumer must treat a missing method as "unknown/incompatible" rather
+   * than assuming it is there (see envelope.ts's version handshake).
+   */
+  compilerVersion?(): string;
+}
+/**
+ * Where a loaded addon came from. This decides whether the version handshake
+ * in envelope.ts can say anything meaningful about it:
+ *
+ *   - `package`   — a published per-platform optionalDependency. Its release
+ *                   version is knowable (`packageVersion`) and is exactly the
+ *                   thing `packages/compiler/package.json` pins, so it CAN be
+ *                   compared against the pin.
+ *   - `dev-build` — `src-native/aihu-compiler-native.node`, produced by
+ *                   `scripts/build-native.ts` from THIS source tree. It has no
+ *                   release version at all; it is trusted by construction.
+ *   - `override`  — `AIHU_COMPILER_NATIVE_ADDON=<path>`. Gated like `package`
+ *                   when the pinned file turns out to live inside a published
+ *                   platform package, trusted like `dev-build` otherwise.
+ */
+type CompilerNativeOrigin = 'package' | 'dev-build' | 'override';
+type CompilerNativeState = {
+  kind: 'loaded';
+  addon: CompilerNativeAddon;
+  addonPath: string;
+  origin: CompilerNativeOrigin;
+  /**
+   * The `version` of the published per-platform package the addon was
+   * loaded from, or `null` when the addon did not come from one (a local
+   * cargo build). NOT the crate version reported by `compilerVersion()`:
+   * `src-native/Cargo.toml` is pinned at 0.1.0 and never bumped per
+   * release, so `CARGO_PKG_VERSION` cannot identify a release. The npm
+   * package version can, and it is what the pin in
+   * `packages/compiler/package.json` is expressed in.
+   */
+  packageVersion: string | null;
+} | {
+  kind: 'disabled';
+} | {
+  kind: 'unavailable';
+  error?: Error;
+};
 /**
- * envelope.ts — backend dispatch for the single-parse envelope compile.
- *
- * Every compile request (`transform` / `compileToAst` / `compileRouteMeta`)
- * routes memo-first, then through ONE of three backends, in order:
- *
- *   1. **native addon** (packages/compiler/src-native, napi) — in-process,
- *      zero spawn. Selected once per process by `_resolveCompileBackend()`.
- *   2. **envelope CLI spawn** — the legacy `aihu-compile` spawn args PLUS
- *      `--envelope <options-json>`. A binary that knows the flag answers with
- *      one JSON envelope (single parse, every requested artifact); the JSON
- *      carries the `"envelope": 1` discriminant.
- *   3. **legacy per-output spawn** — an OLDER binary ignores `--envelope`
- *      and answers with its normal single artifact (JS / AST JSON / route
- *      JSON), which the discriminant check detects. That output is used
- *      as-is, so stale binaries keep exactly their historical behavior —
- *      feature detection costs zero extra spawns.
- *
- * Backend selection is CACHED at first use (per module instance):
- * `AIHU_COMPILER_NATIVE=0` forces spawn; an explicit `AIHU_COMPILE_BIN`
- * binary pin forces spawn (working ON the compiler means
- * the pinned binary must actually run — an addon silently shadowing it would
- * reintroduce the exact quiet-wrong-answer failure the pin exists to prevent).
- * The cache means css-engine's mid-build `AIHU_COMPILE_BIN` handshake
- * (which programmatically sets the var AFTER the first transform) cannot
- * de-select an already-active native backend.
- *
- * The memo's "binary stamp" (transform-memo.ts `_binStamp`) generalizes to
- * whichever backend is active: the addon's `.node` file path (stat'd for
- * mtime+size, so a rebuilt addon invalidates entries) when native, the
- * resolved CLI binary path when spawning.
+ * Resolve (and cache) the native compiler addon. This is the ONLY module in
+ * @aihu/compiler that requires a napi `.node` file.
  */
+declare function loadCompilerNative(): CompilerNativeState;
+/** Returns the cached state kind (resolving if needed). @internal */
+declare function _getCompilerNativeStateKind(): CompilerNativeState['kind'];
+/** Reset the cached state. Used by tests that mock detection/env. @internal */
+declare function _resetCompilerNative(): void;
+//#endregion
+//#region js/envelope.d.ts
 /** The wire shape of a compile envelope (Rust `Envelope`, camelCase). */
 interface CompileEnvelope {
   envelope: number;
@@ -87,56 +138,6 @@ type EnvelopeReply = {
  */
 declare function _compileViaBackend(source: string, legacyArgs: string[], options: CompileEnvelopeOptions): EnvelopeReply;
 //#endregion
-//#region js/native.d.ts
-/**
- * @aihu/compiler native-addon loader — the in-process compile fast path.
- *
- * A `native.ts`-style loader in the mold of packages/server/src/native.ts:
- * platform matrix → per-platform optionalDependency package → dev fallback,
- * with explicit escape hatches and a cached three-state result. The addon
- * (packages/compiler/src-native, napi-rs) exposes
- * `compileEnvelope(source, optionsJson) → envelopeJson` — one boundary
- * crossing per file — which `js/envelope.ts` routes `transform()` /
- * `compileToAst()` / `compileRouteMeta()` through.
- *
- * States:
- *   - loaded:      addon required successfully; compiles run in-process.
- *   - disabled:    `AIHU_COMPILER_NATIVE=0` — the documented escape hatch.
- *   - unavailable: no addon for this platform / load failed. UNLIKE
- *                  @aihu/server's fail-loud contract, a failed load here is a
- *                  one-shot WARNING, not a throw: the CLI spawn path is a
- *                  byte-identical fallback that always exists, so failing the
- *                  whole build over a fast-path load would be strictly worse.
- *                  The exception is `AIHU_COMPILER_NATIVE_ADDON=<path>` — an
- *                  explicit override that fails loud (same doctrine as
- *                  AIHU_COMPILE_BIN: a pinned path that doesn't load is a
- *                  configuration error, and silently ignoring it hands back a
- *                  plausible-looking wrong backend).
- */
-interface CompilerNativeAddon {
-  compileEnvelope(source: string, optionsJson: string): string;
-  compilerVersion(): string;
-}
-type CompilerNativeState = {
-  kind: 'loaded';
-  addon: CompilerNativeAddon;
-  addonPath: string;
-} | {
-  kind: 'disabled';
-} | {
-  kind: 'unavailable';
-  error?: Error;
-};
-/**
- * Resolve (and cache) the native compiler addon. This is the ONLY module in
- * @aihu/compiler that requires a napi `.node` file.
- */
-declare function loadCompilerNative(): CompilerNativeState;
-/** Returns the cached state kind (resolving if needed). @internal */
-declare function _getCompilerNativeStateKind(): CompilerNativeState['kind'];
-/** Reset the cached state. Used by tests that mock detection/env. @internal */
-declare function _resetCompilerNative(): void;
-//#endregion
 //#region js/transform-memo.d.ts
 /**
  * FIFO size bound. 1024 entries × a few KB of compiled output ≈ a few MB —
@@ -230,25 +231,64 @@ interface AihuCompilerPluginOptions {
   layoutsDir?: string;
 }
 /**
- * Inject `{ shadowMode: '...' }` (and, for light mode, `lightScopeId: '...'`
- * in the SAME options object) as the third argument to the emitted
- * `defineElement('tag', defineComponent(...))` call. The compiler emits
- * exactly two arguments today; this rewrites the closing of the
- * defineElement call to include the options object. Idempotent — leaves
- * code untouched when the closer is not in the expected shape.
- *
- * `lightScopeId` is folded into this SAME regex operation rather than a
- * second independent injection pass, deliberately: it is only ever set when
- * `mode === 'light'` (see the call site, `index.ts`'s `transform` hook), so
- * every call that needs it ALSO needs a shadowMode injection at the exact
- * same spot — a second pass would just re-match (and fight) the text this
- * one already rewrote. Stamps `data-a` on the root element at runtime
- * (light-DOM leaf flip, LDF §10 step 3) — `packages/runtime/src/
- * define-element.ts`'s `wrapClass` reads `options.lightScopeId`.
+ * Inject `shadowMode: '...'` (and, for light mode, `lightScopeId: '...'` in
+ * the SAME options object) into the third argument of the emitted
+ * `defineElement('tag', defineComponent(...))` call — appending the options
+ * object when the call has two arguments, or merging the fields into an
+ * existing third argument (`$form` emits `, { formAssociated: true }`).
+ * Idempotent — leaves code untouched when the call is not in a recognized
+ * shape or the options already carry a `shadowMode`.
+ *
+ * `lightScopeId` is folded into this SAME injection rather than a second
+ * independent pass, deliberately: it is only ever set when `mode === 'light'`
+ * (see the call site, `index.ts`'s `transform` hook), so every call that
+ * needs it ALSO needs a shadowMode injection at the exact same spot — a
+ * second pass would just re-match (and fight) the text this one already
+ * rewrote. Stamps `data-a` on the root element at runtime (light-DOM leaf
+ * flip, LDF §10 step 3) — `packages/runtime/src/define-element.ts`'s
+ * `wrapClass` reads `options.lightScopeId`.
+ *
+ * History, because this anchor has now been wrong twice:
+ *
+ * 1. The original regex anchor (`defineComponent\([^]*\)\s*\)` — greedy, and
+ *    `[^]` crosses newlines) ran past `defineElement` and matched the LAST
+ *    `)\s*)` pair in the module. On a SERVER-target module the string
+ *    renderer (`__ssrString`) is emitted AFTER the registration, so for any
+ *    component with an `if=` the last such pair is the emitted condition,
+ *    which became `if ((n() > 5), { shadowMode: 'light', … })` — the comma
+ *    operator, always truthy, so a dead branch rendered (the SSR-child
+ *    review's 33-nested-hosts measurement). Same corruption landed inside
+ *    `__aihu_stext(...)` calls (a `(` in text content) and, on ALL targets,
+ *    inside `$form`'s `setFormValue(...)`. The repro was missed at first
+ *    because the probe regex `/if \([^)]*shadowMode/` cannot cross the `)`
+ *    in `(n() > 5)` — evidence in light-scope-export.test.ts.
+ *
+ * 2. The first replacement — a bare balanced-paren count — read parens inside
+ *    string literals (`leaf('(')`), drifted, and silently bailed on
+ *    client/universal modules, stripping the injection those components need.
+ *    Hence `_matchParen`'s lexer, and the tests that pin every shape above.
  *
  * @internal
  */
 declare function _injectShadowMode(code: string, mode: 'light' | 'shadow', lightScopeId?: string): string;
+/**
+ * Fill the Rust codegen's `__AIHU_LIGHT_SCOPE_ID__` placeholder with the
+ * component's real light-DOM scope id (LDF §10 step 3).
+ *
+ * The server-target string renderer (`emit.rs`, wave-3) emits
+ * `const __AIHU_LIGHT_SCOPE_ID__: string | undefined = undefined;` and merges
+ * it into `__ssrString`'s options (`opts.lightScopeId ?? __AIHU_LIGHT_SCOPE_ID__`)
+ * so a compiled light-DOM component can stamp `data-a` on its own rendered
+ * root with NO caller cooperation. Whether the component actually resolves to
+ * light mode is only known here in the JS layer (same reason
+ * `_injectShadowMode` exists), so Rust emits the placeholder and this helper
+ * replaces the literal when the mode resolved to light — exactly the wiring
+ * the Rust-side comment names. Idempotent: no placeholder (client target,
+ * bailed string renderer) → code returned untouched.
+ *
+ * @internal
+ */
+declare function _injectLightScopeId(code: string, lightScopeId: string): string;
 /**
  * Light-DOM (`shadowMode:'light'`) recipes: redirect the authored `@style`
  * block's per-instance `host.adoptedStyleSheets = [__style__]` assignment to
@@ -288,6 +328,153 @@ declare function _globalizeAuthoredStyle(code: string): string;
  * @internal
  */
 declare function _parseIslandMarker(compiledCode: string): 'static' | 'interactive';
+/** Best-effort message text for an unknown thrown value. @internal */
+declare function _errMessage(err: unknown): string;
+/**
+ * Is this `import('vite')` rejection the ONE legitimate "there is no Vite here"
+ * case — a standalone `transform()` caller, a unit test, any non-Vite host?
+ *
+ * The distinction matters because the two outcomes are opposites: "no Vite"
+ * must hand the TypeScript back untouched (the caller owns it and never asked
+ * for a strip), while "Vite is here and something broke" must throw, because
+ * un-stripped TypeScript returned into a Vite build is silent corruption that
+ * only surfaces as an unrelated bundler `PARSE_ERROR` much later.
+ *
+ * The test is deliberately narrow: a module-resolution failure whose subject is
+ * the `vite` specifier itself. Both Node and Bun report `ERR_MODULE_NOT_FOUND`
+ * with a message naming the package (`Cannot find package 'vite' …`). A
+ * resolution failure for something else — a broken transitive dependency of an
+ * installed Vite, say — is NOT this case: Vite is present, the strip is
+ * expected, and swallowing it would be the same silent corruption. So it is
+ * loud.
+ *
+ * @internal
+ */
+declare function _isViteMissing(err: unknown): boolean;
+/**
+ * The message for a strip that failed with Vite present — names the branch, the
+ * Vite version, the environment and the file, and says why it is fatal rather
+ * than swallowed.
+ *
+ * @internal
+ */
+declare function _stripFailure(fn: 'transformWithOxc' | 'transformWithEsbuild', id: string, viteVersion: string, isServerEnv: boolean, err: unknown): string;
+/** What the Vite plugin's `transform` hook hands back after the strip. */
+interface StripTypesResult {
+  readonly code: string;
+  readonly map: null;
+  /** Rolldown-only hint; set ONLY on the last-resort no-transform branch. */
+  readonly moduleType?: 'ts';
+}
+/**
+ * The subset of the Vite module `_stripTypes` uses — the seam tests fake.
+ *
+ * The trailing parameters are `any` on purpose: Vite's real signatures carry
+ * version-specific option/config/watcher types (and MORE parameters on some
+ * versions), and a narrower type here would make the genuine module fail to
+ * satisfy the interface. Only the first two parameters and `code` on the result
+ * are actually depended on.
+ */
+interface ViteStripApi {
+  readonly version?: string;
+  readonly transformWithOxc?: (code: string, id: string, ...rest: any[]) => Promise<{
+    code: string;
+  }>;
+  readonly transformWithEsbuild?: (code: string, id: string, ...rest: any[]) => Promise<{
+    code: string;
+  }>;
+}
+/**
+ * Strip TypeScript from compiler output using whichever transform the resolved
+ * Vite exposes. Takes the Vite module as a PARAMETER so the branch order and
+ * the failure behaviour are testable without installing four Vite versions.
+ *
+ * Branch order, and why:
+ *
+ * 1. `transformWithOxc` — Vite's own transform, needing NO separate esbuild.
+ *    Vite 8 made esbuild an OPTIONAL PEER while still *exporting* a
+ *    `transformWithEsbuild` that throws "It is deprecated and it now requires
+ *    esbuild to be installed separately … migrate to `transformWithOxc`" the
+ *    moment it is called. So this branch is deliberately NOT gated on the
+ *    environment: a fresh consumer install at vite 8 has no esbuild at all, and
+ *    the esbuild branch would throw on the CLIENT build — which every output
+ *    mode (`spa`, `static`, `ssr`) runs.
+ * 2. `transformWithEsbuild` — vite 6 and 5, where `transformWithOxc` does not
+ *    exist (`'transformWithOxc' in vite` is literally false on 6.4.3), so those
+ *    versions keep taking this branch and their output is unchanged.
+ * 3. Neither — hand the TypeScript to Rolldown with `moduleType: 'ts'`. A
+ *    forward-compatibility escape hatch for a Vite that drops both.
+ *
+ * Preferring oxc on vite 8 is a DELIBERATE behaviour change, not a refactor:
+ * oxc lowers class fields with `useDefineForClassFields: true` (the modern-TS
+ * default) where esbuild used `false`, lowers enums to a different (equivalent)
+ * IIFE shape, and does not constant-inline enum member reads. Invisible for
+ * compiler-generated code, observable for user-authored classes in an `.aihu`
+ * script block. Pinned by `tests/strip-branch.test.ts`.
+ *
+ * Failures here are LOUD. Both call sites are individually wrapped so the
+ * thrown error names the branch, the Vite version, the environment and the
+ * file. The alternative — the swallowing `catch` this replaced — returned
+ * un-stripped TypeScript that only surfaced as an unrelated `PARSE_ERROR` from
+ * the bundler two hundred lines of build output later.
+ *
+ * @internal
+ */
+declare function _stripTypes(vite: ViteStripApi, code: string, id: string, isServerEnv: boolean): Promise<StripTypesResult>;
+/**
+ * §22 — parse the `// @aihu:component-tags a,b,c` marker the Rust codegen emits
+ * for every server/universal build, on the same channel as `@aihu:island` above.
+ *
+ * The list comes from `collect_component_tags` — the SAME walk that fills
+ * `route.json`'s `components` array — so it is already sorted, de-duplicated and
+ * kebab-normalized when it arrives here. Deliberately NOT re-sorted or
+ * re-de-duplicated: a second normalization would be a second place the rule
+ * lives, and the two would drift.
+ *
+ * Distinct from the `__aihu_child_tags__` derivation below: this is "tags the
+ * template references AT ALL", not "tags the compiled renderer will look up".
+ * See the comment on the `__aihu_referenced_tags__` export for why both exist.
+ *
+ * Returns `[]` when the marker is absent (an older binary, a client-target
+ * compile, a future emit shape) — the caller treats that identically to "the
+ * template references nothing".
+ *
+ * @internal
+ */
+declare function _parseComponentTagsMarker(compiledCode: string): string[];
+/**
+ * Derive the `__aihu_child_tags__` set from SERVER-TARGET compiled code: the
+ * tags the compiled string renderer will actually look up, read off the
+ * `__aihu_schild('<tag>'` call sites the Rust codegen emitted. Deduped, sorted.
+ *
+ * THE one derivation, deliberately. There are two consumers:
+ *
+ *   1. `aihuCompilerPlugin`'s transform, which turns the result into the
+ *      `export const __aihu_child_tags__` a compiled module carries.
+ *   2. `@aihu/router`'s `genSC`, which needs the SAME edge set at CODEGEN
+ *      time — before any module exists to read an export off — to walk from
+ *      the pages out to the components the server bundle must actually carry.
+ *
+ * `genSC` reaching for this instead of re-deriving is the whole point. The
+ * `__aihu_referenced_tags__` docblock below spends a paragraph arguing that
+ * deriving the runtime edge set a second way would be "one rule written in two
+ * places, and the halves would drift the first time a boundary moved" — and
+ * that argument does not stop applying because the second site happens to live
+ * in another package. `readAihuLayoutComponents` (the source regex) is a THIRD,
+ * differently-defined set and is not a substitute: it counts references the
+ * emitter DECLINES (an attribute, children, a dynamic path), which produce no
+ * call site, so `__aihu_schild` can never look them up. Measured on a
+ * three-way fixture, it bundled a module whose rendered output was empty.
+ *
+ * Takes compiled code, not a source string: a caller with only source runs
+ * `transform(src, id, { target: 'server' }).code` first — which is memoized, so
+ * a file already compiled in this process costs a map lookup. Client- and
+ * universal-target output carries no `__aihu_schild` call sites at all and
+ * yields `[]`, which is correct: there is no server render to feed.
+ *
+ * @internal
+ */
+declare function _deriveChildTags(compiledCode: string): string[];
 /**
  * GX Phase 1 (#437-GX) — parse the `// @aihu:extract read=<v> call=<v>` code
  * marker the Rust compiler emits for every server/universal build (the
@@ -347,6 +534,11 @@ declare function kebabComponentTag(raw: string): string;
  * Anchors on the exact `const createOutletBoundary = () => { … return host; };`
  * block the codegen emits (`packages/compiler/src/codegen/emit.rs`). No-op when
  * the layout declares no `<outlet>`.
+ *
+ * Shape B of the ReDoS note at the top of this file: the head is located with
+ * `indexOf` and the tail scanned once from there, instead of one regex whose
+ * lazy `[\s\S]*?` re-scanned the whole module at every repetition of the head
+ * literal.
  * @internal
  */
 declare function _passivizeOutlet(code: string): string;
@@ -419,49 +611,32 @@ declare function transform(source: string, id: string, options?: {
   map: null;
 };
 /**
- * Fold css-engine-produced scoped CSS into a compiled `.aihu` module.
- *
- * The Rust codegen emits the authored `@style` block (when present) as:
- *
- *   const __style__ = new CSSStyleSheet();
- *   __style__.replaceSync(`<authored css>`);
- *   defineElement('tag', defineComponent((ctx) => {
- *     (ctx.host as ShadowRoot).adoptedStyleSheets = [__style__];
- *     return ...
- *   }))
- *
- * css-engine's `compileSfc` output is the COMPLETE per-SFC stylesheet:
- * `:host` theme tokens, the variant-resolved utility-class rules, AND the
- * folded authored `@style` block (under an `authored @style` CSS comment).
- * So it is authoritative — we adopt it as the single shadow `<style>` and
- * the authored `@style` keeps emitting through it (acceptance: "@style still
- * emits correctly alongside").
- *
- * Two shapes are handled:
- *
- *  1. **SFC has an `@style` block** — the Rust codegen already declared
- *     `__style__` with the raw `@style` body. We REPLACE that body with the
- *     css-engine output (which already CONTAINS the `@style` block) so the
- *     `@style` rules are not duplicated. The existing `adoptedStyleSheets`
- *     assignment is reused unchanged.
- *
- *  2. **SFC has NO `@style` block** — there is no `__style__`. We inject a
- *     fresh `__style__` declaration after the last import and an
- *     `adoptedStyleSheets` assignment as the first statement of the setup
- *     function. The compiler emits the setup param as `_ctx` in this case;
- *     we rename it to `ctx` so the injected `ctx.host` reference resolves.
- *
- * Runs on the RAW compiled output BEFORE the island / HMR / auto-wiring
- * transforms so those passes operate on the folded module uniformly:
- *   - The static-island shim calls `__aihu_setup__({ host: root, ... })`
- *     where `root` is the shadow root, so `ctx.host` is valid there too.
- *   - The HMR / defer passes only touch the `defineElement(...)` wrapper and
- *     the runtime import; they do not disturb `__style__` or the setup body.
- *
- * No-ops (returns input unchanged) when `css` is empty/whitespace.
- *
- * @internal
+ * Fold css-engine utility CSS into the SERVER target's `__aihu_css__` export.
+ *
+ * The shadow-DOM sibling of `_foldCssEngineStyles`. That one rewrites the
+ * client's `__style__.replaceSync(...)`; the server target has no `__style__`
+ * (`CSSStyleSheet` is a DOM dependency and the Rust codegen elides it), it has
+ * `export const __aihu_css__` — the string `__aihu_schild` inlines as `<style>`
+ * inside a declarative shadow template.
+ *
+ * Without this, that template shipped the authored `@style` block ALONE: no
+ * utility classes, no design tokens, no reset. A shadow child prerendered
+ * partially unstyled and repainted once its chunk loaded — precisely the #754
+ * failure the DSD `<style>` exists to prevent. (The step-4 scoping note claimed
+ * no css-engine work was needed. That was true of the Rust emitter, which
+ * applies no scoping transform, and wrong about the pipeline: the per-component
+ * utility CSS is folded HERE, in the JS layer, and the server target was simply
+ * never wired to it.)
+ *
+ * REPLACES rather than appends, for the same reason shape 1 above does: the
+ * css-engine output already contains the authored `@style` rules, so appending
+ * would duplicate them.
+ *
+ * Light-DOM components never reach this — their utilities go through the global
+ * cascade via `_foldCssEngineStylesGlobal`, and their prerendered markup is
+ * covered by the app stylesheet's `@scope([data-a=…])` blocks.
  */
+declare function _foldSsrCssExport(compiledCode: string, css: string): string;
 declare function _foldCssEngineStyles(compiledCode: string, css: string): string;
 /**
  * Virtual-module prefix used by the `shadowMode === 'light'` branch to route
@@ -721,5 +896,5 @@ declare function compileRouteMeta(source: string, id?: string): RouteMeta | null
 declare function _injectAutoWiring(code: string): string;
 declare function aihuCompilerPlugin(options?: AihuCompilerPluginOptions): VitePlugin;
 //#endregion
-export { AihuCompilerPluginOptions, type CompileEnvelope, type CompileEnvelopeOptions, RouteMeta, SfcAst, SfcAttr, SfcMacroValue, SfcMeta, SfcNode, SfcStyleBlock, VIRTUAL_UTILITY_PREFIX, _MEMO_MAX_ENTRIES, _buildDeferredHydration, _buildStaticIsland, _clearTransformMemo, _compileViaBackend, _foldCssEngineStyles, _foldCssEngineStylesGlobal, _formatExtractCensus, _getCompilerNativeStateKind, _globalizeAuthoredStyle, _hashIdForUtilityCss, _injectAutoWiring, _injectShadowMode, _isLayoutFile, _layoutTag, _lightScopeId, _parseExtractMarker, _parseIslandMarker, _passivizeOutlet, _resetCompileBackend, _resetCompilerNative, _resolveCompileBackend, _transformMemoStats, aihuCompilerPlugin, compileRouteMeta, compileSidecar, compileToAst, kebabComponentTag, loadCompilerNative, transform };
+export { AihuCompilerPluginOptions, type CompileEnvelope, type CompileEnvelopeOptions, RouteMeta, SfcAst, SfcAttr, SfcMacroValue, SfcMeta, SfcNode, SfcStyleBlock, StripTypesResult, VIRTUAL_UTILITY_PREFIX, ViteStripApi, _MEMO_MAX_ENTRIES, _buildDeferredHydration, _buildStaticIsland, _clearTransformMemo, _compileViaBackend, _deriveChildTags, _errMessage, _foldCssEngineStyles, _foldCssEngineStylesGlobal, _foldSsrCssExport, _formatExtractCensus, _getCompilerNativeStateKind, _globalizeAuthoredStyle, _hashIdForUtilityCss, _injectAutoWiring, _injectLightScopeId, _injectShadowMode, _isLayoutFile, _isViteMissing, _layoutTag, _lightScopeId, _parseComponentTagsMarker, _parseExtractMarker, _parseIslandMarker, _passivizeOutlet, _resetCompileBackend, _resetCompilerNative, _resolveCompileBackend, _stripFailure, _stripTypes, _transformMemoStats, aihuCompilerPlugin, compileRouteMeta, compileSidecar, compileToAst, kebabComponentTag, loadCompilerNative, transform };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../js/envelope.ts","../js/native.ts","../js/transform-memo.ts","../js/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../js/native.ts","../js/envelope.ts","../js/transform-memo.ts","../js/index.ts"],"mappings":"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"}