@animus-ui/vite-plugin 0.1.4 → 0.1.6

package/dist/build-start.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-start.d.ts","sourceRoot":"","sources":["../src/build-start.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C;;;;;;;GAOG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,aAAa,EAClB,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,EAC/D,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,KAAK,MAAM,GAC3D,OAAO,CAAC,IAAI,CAAC,CAkRf"}
+{"version":3,"file":"build-start.d.ts","sourceRoot":"","sources":["../src/build-start.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C;;;;;;;GAOG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,aAAa,EAClB,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,EAC/D,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,KAAK,MAAM,GAC3D,OAAO,CAAC,IAAI,CAAC,CAuRf"}

package/dist/constants.d.ts

@@ -1,9 +1,31 @@
+/**
+ * The namespace every virtual module this plugin owns lives under. Exported so
+ * the `transform` guard that keeps those modules out of source-file handling
+ * matches on the same string the ids are built from — a rename of the
+ * namespace cannot leave the guard behind.
+ */
+export declare const VIRTUAL_PREFIX = "virtual:animus/";
 export declare const VIRTUAL_CSS_ID = "virtual:animus/styles.css";
 export declare const RESOLVED_CSS_ID = "\0virtual:animus/styles.css";
 export declare const VIRTUAL_COMPONENTS_ID = "virtual:animus/components.js";
 export declare const RESOLVED_COMPONENTS_ID = "\0virtual:animus/components.js";
 export declare const VIRTUAL_BRIDGE_ID = "virtual:animus/hmr-bridge.js";
 export declare const RESOLVED_BRIDGE_ID = "\0virtual:animus/hmr-bridge.js";
+/**
+ * Browser-addressable URL for the bridge, used as the `src` of the dev
+ * `<script type="module">` (see index-html.ts). THE explanation of the `/@id/`
+ * convention lives here; everything else points at it.
+ *
+ * Vite reserves `/@id/` for module ids that are not file paths. Its transform
+ * middleware normalizes such a URL before serving it (`unwrapId`): strip the
+ * prefix, then decode the `__x00__` placeholder back to a NUL byte. The
+ * UNPREFIXED specifier is what travels here — `resolveVirtualId` is the hook
+ * that answers it, and it answers with the `\0` form. (Vite's own `wrapId`
+ * encodes an already-`\0`-prefixed id as `__x00__`; that form resolves too, but
+ * it leans on the placeholder convention rather than on this plugin's own
+ * `resolveId` contract.)
+ */
+export declare const BRIDGE_SCRIPT_SRC = "/@id/virtual:animus/hmr-bridge.js";
 export declare const VIRTUAL_SYSTEM_PROPS_ID = "virtual:animus/system-props";
 export declare const RESOLVED_SYSTEM_PROPS_ID = "\0virtual:animus/system-props";
 export declare const DEFAULT_EXCLUDE: string[];

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,8BAA8B,CAAC;AAC1D,eAAO,MAAM,eAAe,gCAAgC,CAAC;AAE7D,eAAO,MAAM,qBAAqB,iCAAiC,CAAC;AACpE,eAAO,MAAM,sBAAsB,mCAAmC,CAAC;AAEvE,eAAO,MAAM,iBAAiB,iCAAiC,CAAC;AAChE,eAAO,MAAM,kBAAkB,mCAAmC,CAAC;AAEnE,eAAO,MAAM,uBAAuB,gCAAgC,CAAC;AACrE,eAAO,MAAM,wBAAwB,kCAAkC,CAAC;AAExE,eAAO,MAAM,eAAe,UAA+C,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,cAAc,oBAAoB,CAAC;AAEhD,eAAO,MAAM,cAAc,8BAAgC,CAAC;AAC5D,eAAO,MAAM,eAAe,gCAAwB,CAAC;AAErD,eAAO,MAAM,qBAAqB,iCAAmC,CAAC;AACtE,eAAO,MAAM,sBAAsB,mCAA+B,CAAC;AAEnE,eAAO,MAAM,iBAAiB,iCAAmC,CAAC;AAClE,eAAO,MAAM,kBAAkB,mCAA2B,CAAC;AAE3D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,sCAA8B,CAAC;AAE7D,eAAO,MAAM,uBAAuB,gCAAkC,CAAC;AACvE,eAAO,MAAM,wBAAwB,kCAAiC,CAAC;AAEvE,eAAO,MAAM,eAAe,UAA+C,CAAC"}

package/dist/context.d.ts

@@ -1,7 +1,7 @@
 import { HotUpdateEvents } from './hot-update-events';
 import type { LightningTargets } from './css';
 import type { AnimusExtractOptions } from './index';
-import type { ExternalPackageOutcome, SystemConfig } from '@animus-ui/extract/pipeline';
+import type { ExternalPackageOutcome, ManifestDiagnostic, SystemConfig } from '@animus-ui/extract/pipeline';
 import type { Logger } from 'vite';
 /**
  * Structured per-layer CSS sheets from the Rust crate (dev split delivery).
@@ -33,6 +33,45 @@ export declare function buildFileEntriesFromCache(cache: Map<string, {
     source: string;
     hash: string;
 }>;
+/**
+ * The exact source `virtual:animus/system-props` serves for the current state.
+ * One definition, so the served bytes and the change decision below can never
+ * be computed from different inputs.
+ *
+ * A real context carries the module already generated (`systemPropsModuleMemo`,
+ * refreshed wherever the four inputs move), so serving it and deciding whether
+ * it changed are both reads. Contexts that publish those inputs by hand — the
+ * behavioral test doubles — carry no memo and generate here instead.
+ */
+export declare function systemPropsModuleSource(ctx: PluginContext): string;
+/**
+ * Run project analysis and report whether the served system-props module
+ * CHANGED.
+ *
+ * The module is imported by every module that renders a system prop, so
+ * re-delivering it pushes an update through all of them; every analysis
+ * republishes its inputs whether or not they moved, so a new analysis is not
+ * itself an admissible trigger (openspec: vite-extraction-plugin, "System prop
+ * map HMR invalidation").
+ *
+ * The comparison is over the GENERATED MODULE, not over the prop map alone.
+ * The map is one of four inputs, and they move independently: widening a
+ * component's `.system({ ... })` opt-in adds a `dynamicPropConfig` entry while
+ * minting no new utility class, so a map-only comparison reports "unchanged"
+ * and the client is left with a config missing the new prop — permanently,
+ * since Vite keeps serving the module's cached transform result across full
+ * page reloads. Comparing the artifact itself needs no argument about which
+ * inputs are volatile this month.
+ *
+ * A free function rather than a method: the comparison must run for real
+ * against any context the caller holds, including the behavioral test doubles
+ * that stand in for the engine.
+ */
+export declare function runAnalysisTrackingSystemProps(ctx: PluginContext, fileEntries: Array<{
+    path: string;
+    source: string;
+    hash?: string;
+}>): boolean;
 /**
  * Drop a deleted (or renamed-away) file from the dev file cache so its
  * last-known source stops riding along as a ghost entry on every later
@@ -52,7 +91,7 @@ export declare function pruneFileCache(cache: Map<string, {
  * index.ts only wires Vite hooks to those functions.
  *
  * A class rather than closure variables so each hook module names exactly
- * the state it touches, and the engine store (DEF-1: per-instance, never
+ * the state it touches, and the engine store (per-instance, never
  * module-level) is explicit.
  */
 export declare class PluginContext {
@@ -74,16 +113,24 @@ export declare class PluginContext {
     resolvedComponentCss: string;
     storedSheets: CssSheets | null;
     layerDeclaration: string;
-    fragmentCache: Map<string, {
-        base?: string;
-        variants?: string;
-        compounds?: string;
-        states?: string;
-    }>;
+    transformOutputHashes: Map<string, string>;
+    recordTransformOutput(relativePath: string, code: string): void;
+    /**
+     * Merge `Keyframes` collections from discovered external package entries
+     * into the system's collections (keyframes-only carve-out — the consumer
+     * system stays the singular config authority). Runs after buildStart
+     * discovery AND after every geological-reset system reload, since a reload
+     * rebuilds `this.system` from the consumer entry alone.
+     */
+    applyExternalKeyframes(): void;
+    /** Discovery-time keyframes diagnostics awaiting the next analysis's
+     *  shared surfacing pass. */
+    externalKeyframesDiagnostics: ManifestDiagnostic[];
     reverseProvenance: Record<string, string[]>;
     storedSystemPropMapJson: string;
     storedDynamicPropsJson: string;
     storedTransformsSource: string;
+    systemPropsModuleMemo: string | null;
     fileCache: Map<string, {
         hash: string;
         source: string;
@@ -100,7 +147,6 @@ export declare class PluginContext {
     externalSourceEntries: Map<string, string>;
     externalPackageOutcomes: ExternalPackageOutcome[];
     devServer: any;
-    bridgeInjected: boolean;
     resolvedSystemPath: string | null;
     systemDependencyKeys: Set<string>;
     systemDependencyPaths: string[];
@@ -111,6 +157,13 @@ export declare class PluginContext {
     readonly engineApi: () => any;
     constructor(options: AnimusExtractOptions, engineApiOverride?: () => any);
     log(msg: string): void;
+    /**
+     * Standard-level information — emitted whether or not `verbose` is on.
+     * Reserved for events a developer must see without opting in, e.g. a file
+     * created after buildStart being folded into the analysis (openspec:
+     * hmr-new-file-detection, "New file detection logging").
+     */
+    info(msg: string): void;
     warn(msg: string): void;
     logTimingWaterfall(timing: Record<string, number>): void;
     /**
@@ -197,6 +250,13 @@ export declare class PluginContext {
      * `getModuleById` searches the client AND ssr environment graphs and its
      * `invalidateModule` invalidates both instances behind the returned node,
      * which is exactly the reach this path wants. It stays the seam here.
+     *
+     * Both modules are invalidated unconditionally, and deliberately so: the
+     * appearance or disappearance of a whole component file is not the
+     * steady-state edit the change-gated path governs, and a client reload does
+     * NOT rescue a module that was never invalidated — Vite keeps serving its
+     * cached transform result across reloads (openspec: hmr-new-file-detection,
+     * "CSS invalidation after new file analysis").
      */
     invalidateExtractedModules(): void;
     /**

package/dist/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"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"}

package/dist/hmr.d.ts

@@ -19,5 +19,5 @@ import type { DevEnvironment, EnvironmentModuleNode, HotUpdateOptions } from 'vi
  * graph, so system dependencies registered through `watcher.add` outside the
  * root still reach the reset branch, with an empty `modules` list.
  */
-export declare function handleHotUpdate(ctx: PluginContext, environment: DevEnvironment, { type, file, timestamp, modules }: HotUpdateOptions): Promise<EnvironmentModuleNode[] | void>;
+export declare function handleHotUpdate(ctx: PluginContext, environment: DevEnvironment, { type, file, timestamp, modules, read }: HotUpdateOptions): Promise<EnvironmentModuleNode[] | void>;
 //# sourceMappingURL=hmr.d.ts.map

package/dist/hmr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hmr.d.ts","sourceRoot":"","sources":["../src/hmr.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,gBAAgB,EACjB,MAAM,MAAM,CAAC;AAEd;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,aAAa,EAClB,WAAW,EAAE,cAAc,EAC3B,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,gBAAgB,GACnD,OAAO,CAAC,qBAAqB,EAAE,GAAG,IAAI,CAAC,CAgEzC"}
+{"version":3,"file":"hmr.d.ts","sourceRoot":"","sources":["../src/hmr.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,gBAAgB,EACjB,MAAM,MAAM,CAAC;AAEd;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,aAAa,EAClB,WAAW,EAAE,cAAc,EAC3B,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,gBAAgB,GACzD,OAAO,CAAC,qBAAqB,EAAE,GAAG,IAAI,CAAC,CAmEzC"}

package/dist/hot-update-events.d.ts

@@ -9,7 +9,19 @@
  * - `analyzed` — re-analysis ran; every environment invalidates the affected
  *   modules in its own graph. `staleDefinitionFiles` are rootDir-relative
  *   definition files whose component replacement changed (the changed file
- *   itself is never listed).
+ *   itself is never listed). `systemPropsChanged` reports whether the served
+ *   system-props module moved (see `runAnalysisTrackingSystemProps` in
+ *   context.ts) — only the owning dispatch holds the before/after values, so
+ *   it travels with the decision rather than being re-derived per environment.
+ *   `presentationOnly` reports that the changed file's transform output is
+ *   byte-identical before and after the edit (style values are not part of
+ *   the emitted replacement — class names hash `filename::binding`): every
+ *   environment then excludes the file's own modules from the update it
+ *   returns, so the module never re-executes and React component identity,
+ *   generated IDs, focus, and DOM-owned state survive the edit. Computed once
+ *   by the owning dispatch (it needs the pre-edit source and manifest, which
+ *   the owner consumed while re-analyzing) — the same travel rule as
+ *   `systemPropsChanged`.
  */
 export type HotUpdateResult = {
     kind: 'ignored';
@@ -18,6 +30,8 @@ export type HotUpdateResult = {
 } | {
     kind: 'analyzed';
     staleDefinitionFiles: string[];
+    systemPropsChanged: boolean;
+    presentationOnly: boolean;
 };
 /**
  * Once-per-file-event coordination across the `hotUpdate` dispatches.

package/dist/hot-update-events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hot-update-events.d.ts","sourceRoot":"","sources":["../src/hot-update-events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GACrB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,oBAAoB,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,eAAe;IAGd,OAAO,CAAC,QAAQ,CAAC,YAAY;IAFzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;IAE9D,YAA6B,YAAY,SAAK,EAAI;IAElD,0EAA0E;IAC1E,KAAK,CAAC,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAUvE;IAED,wEAAwE;IACxE,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAErE;IAED,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,eAAe,CAEzD;CACF"}
+{"version":3,"file":"hot-update-events.d.ts","sourceRoot":"","sources":["../src/hot-update-events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GACrB;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEN;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,eAAe;IAGd,OAAO,CAAC,QAAQ,CAAC,YAAY;IAFzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;IAE9D,YAA6B,YAAY,SAAK,EAAI;IAElD,0EAA0E;IAC1E,KAAK,CAAC,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAUvE;IAED,wEAAwE;IACxE,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAErE;IAED,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,eAAe,CAEzD;CACF"}

package/dist/index-html.d.ts

@@ -3,16 +3,18 @@ import type { HtmlTagDescriptor } from 'vite';
 /**
  * transformIndexHtml: build the head-prepend tag set.
  *
- * Two independent tags, both delivery-only:
+ * Three independent tags, all delivery-only:
  * - the appearance bootstrap script, when the host build passed a
  *   pre-generated artifact via `appearanceBootstrap` (absent otherwise);
- * - the `@layer` declaration style, when `buildStart` computed one.
+ * - the `@layer` declaration style, when `buildStart` computed one;
+ * - the HMR bridge module script, in dev only.
  *
- * Both branches are guarded on non-empty CONTENT, not on mere presence: an
- * artifact whose `code` is empty is a caller defect, and emitting
+ * The two build-time branches are guarded on non-empty CONTENT, not on mere
+ * presence: an artifact whose `code` is empty is a caller defect, and emitting
  * `<script data-animus-bootstrap></script>` for it would break the
  * unconfigured-parity contract in spirit (a tag that does nothing) while
- * hiding the defect. Symmetric with `layerDeclaration`.
+ * hiding the defect. Symmetric with `layerDeclaration`. The bridge has no
+ * content of its own — it is a `src` reference — so its only guard is the mode.
  *
  * Ordering: every descriptor rides the same `head-prepend` bucket, which Vite
  * serializes in array order (`serializeTags`) and splices in immediately after
@@ -20,8 +22,8 @@ import type { HtmlTagDescriptor } from 'vite';
  * before the layer declaration and — since built stylesheet links are appended
  * at `</head>` — before any stylesheet reference.
  *
- * When neither input is set the array is empty, so an unconfigured build emits
- * no tag, attribute, or whitespace of its own.
+ * With neither build-time input set, a production build emits no tag,
+ * attribute, or whitespace of its own.
  */
 export declare function buildIndexHtmlTags(ctx: PluginContext): HtmlTagDescriptor[];
 //# sourceMappingURL=index-html.d.ts.map

package/dist/index-html.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index-html.d.ts","sourceRoot":"","sources":["../src/index-html.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,aAAa,GAAG,iBAAiB,EAAE,CAuB1E"}
+{"version":3,"file":"index-html.d.ts","sourceRoot":"","sources":["../src/index-html.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,aAAa,GAAG,iBAAiB,EAAE,CAyD1E"}

package/dist/index.cjs

@@ -7,13 +7,36 @@ let fs = require("fs");
 let path = require("path");
 let crypto = require("crypto");
 //#region src/constants.ts
-const VIRTUAL_CSS_ID = "virtual:animus/styles.css";
-const RESOLVED_CSS_ID = "\0virtual:animus/styles.css";
-const VIRTUAL_COMPONENTS_ID = "virtual:animus/components.js";
-const RESOLVED_COMPONENTS_ID = "\0virtual:animus/components.js";
-const VIRTUAL_BRIDGE_ID = "virtual:animus/hmr-bridge.js";
-const RESOLVED_BRIDGE_ID = "\0virtual:animus/hmr-bridge.js";
-const RESOLVED_SYSTEM_PROPS_ID = "\0virtual:animus/system-props";
+/**
+* The namespace every virtual module this plugin owns lives under. Exported so
+* the `transform` guard that keeps those modules out of source-file handling
+* matches on the same string the ids are built from — a rename of the
+* namespace cannot leave the guard behind.
+*/
+const VIRTUAL_PREFIX = "virtual:animus/";
+const VIRTUAL_CSS_ID = `${VIRTUAL_PREFIX}styles.css`;
+const RESOLVED_CSS_ID = `\0${VIRTUAL_CSS_ID}`;
+const VIRTUAL_COMPONENTS_ID = `${VIRTUAL_PREFIX}components.js`;
+const RESOLVED_COMPONENTS_ID = `\0${VIRTUAL_COMPONENTS_ID}`;
+const VIRTUAL_BRIDGE_ID = `${VIRTUAL_PREFIX}hmr-bridge.js`;
+const RESOLVED_BRIDGE_ID = `\0${VIRTUAL_BRIDGE_ID}`;
+/**
+* Browser-addressable URL for the bridge, used as the `src` of the dev
+* `<script type="module">` (see index-html.ts). THE explanation of the `/@id/`
+* convention lives here; everything else points at it.
+*
+* Vite reserves `/@id/` for module ids that are not file paths. Its transform
+* middleware normalizes such a URL before serving it (`unwrapId`): strip the
+* prefix, then decode the `__x00__` placeholder back to a NUL byte. The
+* UNPREFIXED specifier is what travels here — `resolveVirtualId` is the hook
+* that answers it, and it answers with the `\0` form. (Vite's own `wrapId`
+* encodes an already-`\0`-prefixed id as `__x00__`; that form resolves too, but
+* it leans on the placeholder convention rather than on this plugin's own
+* `resolveId` contract.)
+*/
+const BRIDGE_SCRIPT_SRC = `/@id/${VIRTUAL_BRIDGE_ID}`;
+const VIRTUAL_SYSTEM_PROPS_ID = `${VIRTUAL_PREFIX}system-props`;
+const RESOLVED_SYSTEM_PROPS_ID = `\0${VIRTUAL_SYSTEM_PROPS_ID}`;
 const DEFAULT_EXCLUDE = [
 	"node_modules",
 	"dist",
@@ -129,6 +152,7 @@ async function runBuildStart(ctx, resolveSpecifier, emitAsset) {
 	}
 	ctx.externalPackageDirs = collected.packageDirs;
 	ctx.registerSystemWatchPaths();
+	ctx.applyExternalKeyframes();
 	const packageFileCount = fileEntries.length - localFileCount;
 	ctx.log(`Discovered ${fileEntries.length} files (${packageFileCount} from packages) (${Math.round(performance.now() - t0)}ms)`);
 	t0 = performance.now();
@@ -349,6 +373,56 @@ function buildFileEntriesFromCache(cache, changedPath) {
 	});
 	return entries;
 }
+/** Generate the module from the four inputs the context currently holds. */
+function generateSystemPropsModule(ctx) {
+	return (0, _animus_ui_extract_pipeline.buildSystemPropsModule)({
+		systemPropMapJson: ctx.storedSystemPropMapJson,
+		groupRegistryJson: ctx.system.groupRegistryJson,
+		dynamicProps: JSON.parse(ctx.storedDynamicPropsJson),
+		transformsSource: ctx.storedTransformsSource
+	});
+}
+/**
+* The exact source `virtual:animus/system-props` serves for the current state.
+* One definition, so the served bytes and the change decision below can never
+* be computed from different inputs.
+*
+* A real context carries the module already generated (`systemPropsModuleMemo`,
+* refreshed wherever the four inputs move), so serving it and deciding whether
+* it changed are both reads. Contexts that publish those inputs by hand — the
+* behavioral test doubles — carry no memo and generate here instead.
+*/
+function systemPropsModuleSource(ctx) {
+	return ctx.systemPropsModuleMemo ??= generateSystemPropsModule(ctx);
+}
+/**
+* Run project analysis and report whether the served system-props module
+* CHANGED.
+*
+* The module is imported by every module that renders a system prop, so
+* re-delivering it pushes an update through all of them; every analysis
+* republishes its inputs whether or not they moved, so a new analysis is not
+* itself an admissible trigger (openspec: vite-extraction-plugin, "System prop
+* map HMR invalidation").
+*
+* The comparison is over the GENERATED MODULE, not over the prop map alone.
+* The map is one of four inputs, and they move independently: widening a
+* component's `.system({ ... })` opt-in adds a `dynamicPropConfig` entry while
+* minting no new utility class, so a map-only comparison reports "unchanged"
+* and the client is left with a config missing the new prop — permanently,
+* since Vite keeps serving the module's cached transform result across full
+* page reloads. Comparing the artifact itself needs no argument about which
+* inputs are volatile this month.
+*
+* A free function rather than a method: the comparison must run for real
+* against any context the caller holds, including the behavioral test doubles
+* that stand in for the engine.
+*/
+function runAnalysisTrackingSystemProps(ctx, fileEntries) {
+	const before = systemPropsModuleSource(ctx);
+	ctx.runAnalysis(fileEntries);
+	return systemPropsModuleSource(ctx) !== before;
+}
 /**
 * Drop a deleted (or renamed-away) file from the dev file cache so its
 * last-known source stops riding along as a ghost entry on every later
@@ -368,7 +442,7 @@ function pruneFileCache(cache, rootDir, absPath) {
 * index.ts only wires Vite hooks to those functions.
 *
 * A class rather than closure variables so each hook module names exactly
-* the state it touches, and the engine store (DEF-1: per-instance, never
+* the state it touches, and the engine store (per-instance, never
 * module-level) is explicit.
 */
 var PluginContext = class {
@@ -390,11 +464,31 @@ var PluginContext = class {
 	resolvedComponentCss = "";
 	storedSheets = null;
 	layerDeclaration = "";
-	fragmentCache = /* @__PURE__ */ new Map();
+	transformOutputHashes = /* @__PURE__ */ new Map();
+	recordTransformOutput(relativePath, code) {
+		this.transformOutputHashes.set(relativePath, (0, _animus_ui_extract_pipeline.contentHash)(code));
+	}
+	/**
+	* Merge `Keyframes` collections from discovered external package entries
+	* into the system's collections (keyframes-only carve-out — the consumer
+	* system stays the singular config authority). Runs after buildStart
+	* discovery AND after every geological-reset system reload, since a reload
+	* rebuilds `this.system` from the consumer entry alone.
+	*/
+	applyExternalKeyframes() {
+		if (this.externalSourceEntries.size === 0) return;
+		const merge = (0, _animus_ui_extract_pipeline.mergeExternalKeyframes)((entry, root) => this.engineApi().scanKeyframesExports(entry, root), this.system.keyframesJson, this.externalSourceEntries.values(), this.rootDir);
+		this.system.keyframesJson = merge.keyframesJson;
+		this.externalKeyframesDiagnostics = merge.diagnostics;
+	}
+	/** Discovery-time keyframes diagnostics awaiting the next analysis's
+	*  shared surfacing pass. */
+	externalKeyframesDiagnostics = [];
 	reverseProvenance = {};
 	storedSystemPropMapJson = "{}";
 	storedDynamicPropsJson = "{}";
 	storedTransformsSource = "{}";
+	systemPropsModuleMemo = null;
 	fileCache = /* @__PURE__ */ new Map();
 	hotUpdateEvents = new HotUpdateEvents();
 	packageMap = {};
@@ -408,7 +502,6 @@ var PluginContext = class {
 	externalSourceEntries = /* @__PURE__ */ new Map();
 	externalPackageOutcomes = [];
 	devServer;
-	bridgeInjected = false;
 	resolvedSystemPath = null;
 	systemDependencyKeys = /* @__PURE__ */ new Set();
 	systemDependencyPaths = [];
@@ -456,6 +549,15 @@ var PluginContext = class {
 	log(msg) {
 		if (this.verbose) (this.logger ?? console).info(`[animus] ${msg}`);
 	}
+	/**
+	* Standard-level information — emitted whether or not `verbose` is on.
+	* Reserved for events a developer must see without opting in, e.g. a file
+	* created after buildStart being folded into the analysis (openspec:
+	* hmr-new-file-detection, "New file detection logging").
+	*/
+	info(msg) {
+		(this.logger ?? console).info(`[animus] ${msg}`);
+	}
 	warn(msg) {
 		(this.logger ?? console).warn(`[animus] ${msg}`);
 	}
@@ -487,10 +589,12 @@ var PluginContext = class {
 			this.systemDependencyKeys = keys;
 			this.systemDependencyPaths = deps;
 			this.registerSystemWatchPaths();
+			this.applyExternalKeyframes();
 		} catch (e) {
 			if (this.options.strict) throw new Error(`[animus-extract] Failed to load system from ${this.resolvedSystemPath}: ${e}`, { cause: e });
 			console.warn(`[animus-extract] Failed to load system from ${this.resolvedSystemPath}:`, e);
 		}
+		this.systemPropsModuleMemo = generateSystemPropsModule(this);
 	}
 	/**
 	* Run project analysis via the shared `runProjectAnalysis` and update
@@ -510,18 +614,14 @@ var PluginContext = class {
 				staticCssJson: this.staticCssJson,
 				externalDirs: this.externalPackageDirs.map((dir) => (0, path.relative)(this.rootDir, dir)),
 				devMode: !this.isProd,
-				warn: (m) => this.warn(m)
+				warn: (m) => this.warn(m),
+				strict: this.options.strict,
+				extraDiagnostics: this.externalKeyframesDiagnostics
 			});
 			this.storedManifest = result.manifest;
 			this.storedManifestJson = result.manifestJson;
 			this.storedSystemPropMapJson = JSON.stringify(result.manifest?.system_prop_map ?? {});
 			this.storedDynamicPropsJson = JSON.stringify(result.manifest?.dynamic_props ?? {});
-			this.bridgeInjected = false;
-			const newFragments = result.manifest?.component_fragments;
-			if (newFragments && typeof newFragments === "object") {
-				this.fragmentCache.clear();
-				for (const [id, sheets] of Object.entries(newFragments)) this.fragmentCache.set(id, sheets);
-			}
 			this.reverseProvenance = result.manifest?.reverse_provenance ?? {};
 			this.storedSheets = result.manifest?.sheets ?? null;
 			this.globalCss = result.globalCss;
@@ -531,6 +631,7 @@ var PluginContext = class {
 			console.warn("[animus-extract] analyzeProject failed:", e);
 			return;
 		}
+		this.systemPropsModuleMemo = generateSystemPropsModule(this);
 		this.applyAssetSubstitutions();
 		this.enforceExternalTokenContracts();
 	}
@@ -665,6 +766,13 @@ var PluginContext = class {
 	* `getModuleById` searches the client AND ssr environment graphs and its
 	* `invalidateModule` invalidates both instances behind the returned node,
 	* which is exactly the reach this path wants. It stays the seam here.
+	*
+	* Both modules are invalidated unconditionally, and deliberately so: the
+	* appearance or disappearance of a whole component file is not the
+	* steady-state edit the change-gated path governs, and a client reload does
+	* NOT rescue a module that was never invalidated — Vite keeps serving its
+	* cached transform result across reloads (openspec: hmr-new-file-detection,
+	* "CSS invalidation after new file analysis").
 	*/
 	invalidateExtractedModules() {
 		const server = this.devServer;
@@ -741,6 +849,82 @@ var PluginContext = class {
 	}
 };
 //#endregion
+//#region src/transform.ts
+/**
+* The dev-mode bridge prepend, shared with the hot-update gate so both
+* compute byte-identical served output. The import goes AFTER the directive
+* prologue the engine hoists to byte 0 — prepending above it would demote
+* 'use client'/'use strict' to an ordinary expression statement, silently
+* un-marking client modules on exactly the RSC-capable hosts this delivery
+* path serves.
+*/
+function applyDevBridgeImport(code) {
+	const prologue = /^(?:(['"])use [a-z -]+\1;?\r?\n)*/.exec(code)?.[0] ?? "";
+	return prologue + `import '${VIRTUAL_BRIDGE_ID}';\n` + code.slice(prologue.length);
+}
+/**
+* transform: replace builder chains with `createComponent()` calls using
+* the pre-built manifest; detect files created after buildStart and fold
+* them into the analysis.
+*
+* The HMR bridge is NOT injected here — `transformIndexHtml` delivers it as a
+* `<script type="module">` per served document (openspec:
+* dev-stylesheet-management, "HMR bridge auto-injected in dev mode"; "Transform
+* emitter unchanged" forbids the emitter importing it).
+*/
+function transformSource(ctx, code, id) {
+	if (!ctx.storedManifest) return null;
+	if (id.startsWith("\0") || id.startsWith("virtual:animus/")) return null;
+	const isExternalPkg = ctx.externalPackageDirs.some((dir) => id.startsWith(dir + path.sep) || id === dir);
+	const relativePath = (0, path.relative)(ctx.rootDir, id);
+	if (!isExternalPkg) {
+		if (!/\.[jt]sx?$/.test(id)) return null;
+		if (id.includes("node_modules")) return null;
+		if (relativePath.startsWith("..") || (0, path.isAbsolute)(relativePath)) return null;
+	}
+	if (!ctx.storedManifest.files?.[relativePath]?.length) {
+		if (!ctx.isProd && !ctx.fileCache.has(relativePath)) {
+			if (isExternalPkg) {
+				const owner = Object.entries(ctx.externalDirOwners).find(([dir]) => id === dir || id.startsWith(dir + path.sep));
+				if (owner) ctx.externalFileOwners[relativePath] = owner[1];
+			}
+			const hash = (0, _animus_ui_extract_pipeline.contentHash)(code);
+			ctx.fileCache.set(relativePath, {
+				hash,
+				source: code
+			});
+			const fileEntries = buildFileEntriesFromCache(ctx.fileCache, relativePath);
+			ctx.runAnalysis(fileEntries);
+			const compCount = ctx.storedManifest.files?.[relativePath]?.length ?? 0;
+			ctx.info(`New file detected: ${relativePath} — ${compCount ? `${compCount} components extracted` : "no components"}`);
+			ctx.invalidateExtractedModules();
+		}
+		if (!ctx.storedManifest.files?.[relativePath]?.length) return null;
+	}
+	try {
+		const { transformFile } = ctx.engineApi();
+		const result = transformFile(code, relativePath, ctx.storedManifestJson);
+		if (!result.hasComponents) return null;
+		if (ctx.verbose) {
+			const compCount = ctx.storedManifest.files?.[relativePath]?.length ?? 0;
+			ctx.log(`transform ${relativePath}: ${compCount} components`);
+		}
+		let outputCode = result.code;
+		if (!ctx.isProd) {
+			outputCode = applyDevBridgeImport(result.code);
+			ctx.recordTransformOutput(relativePath, outputCode);
+		}
+		return {
+			code: outputCode,
+			map: null
+		};
+	} catch (e) {
+		if (ctx.options.strict) throw new Error(`[animus-extract] Failed to transform ${id}: ${e}`, { cause: e });
+		console.warn(`[animus-extract] Failed to transform ${id}:`, e);
+		return null;
+	}
+}
+//#endregion
 //#region src/hmr.ts
 /**
 * hotUpdate: the single dev file-event hook. Handles system-dependency
@@ -761,13 +945,16 @@ var PluginContext = class {
 * graph, so system dependencies registered through `watcher.add` outside the
 * root still reach the reset branch, with an empty `modules` list.
 */
-async function handleHotUpdate(ctx, environment, { type, file, timestamp, modules }) {
+async function handleHotUpdate(ctx, environment, { type, file, timestamp, modules, read }) {
 	if (ctx.isProd) return;
 	const ownsEvent = ctx.hotUpdateEvents.claim(environment.name, file, timestamp);
 	const absFile = (0, path.resolve)(file);
 	ctx.log(`hotUpdate ${type} ${(0, path.relative)(ctx.rootDir, absFile)} env=${environment.name} owns=${ownsEvent}`);
 	if (ctx.isSystemDependency(absFile)) {
-		if (ownsEvent) ctx.requestGeologicalReset((0, path.relative)(ctx.rootDir, absFile));
+		if (ownsEvent) {
+			await reconcileSourceEntry(ctx, absFile, type, read);
+			ctx.requestGeologicalReset((0, path.relative)(ctx.rootDir, absFile));
+		}
 		return [];
 	}
 	if (type === "create") return;
@@ -775,18 +962,69 @@ async function handleHotUpdate(ctx, environment, { type, file, timestamp, module
 		if (ownsEvent) pruneDeletedFile(ctx, absFile);
 		return;
 	}
-	if (ownsEvent) ctx.hotUpdateEvents.record(file, timestamp, await analyzeChangedFile(ctx, file, absFile));
+	if (ownsEvent) ctx.hotUpdateEvents.record(file, timestamp, await analyzeChangedFile(ctx, file, absFile, read));
 	const result = ctx.hotUpdateEvents.resultOf(file, timestamp);
 	if (result.kind === "ignored") return;
 	if (result.kind === "unchanged") return [];
-	return invalidateStaleModules(ctx, environment, modules, result.staleDefinitionFiles);
+	return invalidateStaleModules(ctx, environment, modules, result);
+}
+/**
+* The changed file's text.
+*
+* Editors save atomically — truncate, then rewrite — so a watcher event can
+* arrive while the path is momentarily EMPTY. Vite's `read()` helper retries on
+* empty content for exactly that reason; reading the path directly at the same
+* moment yields `''`, and since the corrective content produces no second
+* event, that empty source would be cached permanently.
+*
+* Vite always supplies `read`, so the direct read is NOT a fallback for Vite:
+* it exists for hosts that drive this hook without one. The dev-lane's adapter
+* contract is deliberately bundler-neutral, and a second runtime satisfying it
+* must not be forced to fabricate a helper to get correct behavior.
+*/
+async function readChangedSource(absFile, read) {
+	return read ? await read() : (0, fs.readFileSync)(absFile, "utf-8");
+}
+/**
+* Reconcile the `fileCache` entry of a file that is BOTH a system dependency
+* and a discovered component source, since the dependency branch is terminal —
+* neither the edit path's cache write nor `pruneDeletedFile` runs for it.
+*
+* An edit refreshes the entry: `performGeologicalReset` rebuilds its
+* full-source analysis from this cache, so a stale entry would be re-analyzed
+* on every later reset. A delete prunes it, exactly as the ordinary delete path
+* would (openspec: hmr-new-file-detection, "Watcher deletion pruning") — a
+* surviving entry is a ghost source no watcher event can ever name again.
+*
+* Dependency-only files have no entry: `pruneFileCache` no-ops for them, and
+* the edit path must not create one — the cache is the component-source set,
+* and a phantom entry would feed the engine a file it never discovered.
+*/
+async function reconcileSourceEntry(ctx, absFile, type, read) {
+	if (type === "delete") {
+		pruneFileCache(ctx.fileCache, ctx.rootDir, absFile);
+		return;
+	}
+	const relPath = (0, path.relative)(ctx.rootDir, absFile);
+	if (!ctx.fileCache.has(relPath)) return;
+	let source;
+	try {
+		source = await readChangedSource(absFile, read);
+	} catch {
+		ctx.warn(`could not re-read ${relPath} after a system-dependency edit — geological resets will analyze its pre-edit text until a later edit is read successfully`);
+		return;
+	}
+	ctx.fileCache.set(relPath, {
+		hash: (0, _animus_ui_extract_pipeline.contentHash)(source),
+		source
+	});
 }
 /**
 * The once-per-event analysis half: gate the file, diff its content hash,
 * refresh the cache, and re-run project analysis. The returned result is what
 * the remaining environments act on.
 */
-async function analyzeChangedFile(ctx, file, absFile) {
+async function analyzeChangedFile(ctx, file, absFile, read) {
 	const ext = (0, path.extname)(file);
 	if (!ctx.extensionsSet.has(ext)) return { kind: "ignored" };
 	const excludePatterns = ctx.options.exclude ?? DEFAULT_EXCLUDE;
@@ -794,7 +1032,7 @@ async function analyzeChangedFile(ctx, file, absFile) {
 	const relPath = (0, path.relative)(ctx.rootDir, absFile);
 	let source;
 	try {
-		source = (0, fs.readFileSync)(absFile, "utf-8");
+		source = await readChangedSource(absFile, read);
 	} catch {
 		return { kind: "ignored" };
 	}
@@ -840,8 +1078,7 @@ async function analyzeChangedFile(ctx, file, absFile) {
 	}
 	if (ctx.verbose && invalidatedIds.size > directComponentIds.length) ctx.log(`HMR: ${directComponentIds.length} direct + ${invalidatedIds.size - directComponentIds.length} transitive components invalidated`);
 	const analysisStart = performance.now();
-	const fileEntries = buildFileEntriesFromCache(ctx.fileCache, relPath);
-	ctx.runAnalysis(fileEntries);
+	const systemPropsChanged = runAnalysisTrackingSystemProps(ctx, buildFileEntriesFromCache(ctx.fileCache, relPath));
 	const analysisMs = Math.round(performance.now() - analysisStart);
 	const staleDefinitionFiles = [];
 	if (ctx.storedManifest?.components) {
@@ -852,15 +1089,44 @@ async function analyzeChangedFile(ctx, file, absFile) {
 			staleDefinitionFiles.push(defFile);
 		}
 	}
+	const presentationOnly = isPresentationOnlyEdit(ctx, scannerRelPath, source);
 	const hmrMs = Math.round(performance.now() - hmrStart);
-	ctx.log(`HMR update: ${relPath} — analysis ${analysisMs}ms, total ${hmrMs}ms`);
+	ctx.log(`HMR update: ${relPath} — analysis ${analysisMs}ms, total ${hmrMs}ms${presentationOnly ? " (presentation-only)" : ""}`);
 	ctx.logTimingWaterfall(ctx.storedManifest?.timing ?? {});
 	return {
 		kind: "analyzed",
-		staleDefinitionFiles
+		staleDefinitionFiles,
+		systemPropsChanged,
+		presentationOnly
 	};
 }
 /**
+* True when the changed file's transform output is byte-identical across the
+* edit — a presentation-only change (style values are not part of the emitted
+* replacement, whose class names hash `filename::binding`).
+*
+* Compares a POST-analysis re-transform of the file (the engine transforms
+* from its retained facts, so this runs against the just-updated analysis)
+* with the hash of what the module LAST SERVED (`recordTransformOutput` in
+* the transform hook, bridge import included). Comparing the full served
+* output — never replacement strings — is what keeps a mixed style+code edit
+* deliverable. Fails open: a transform error, a file the manifest does not
+* list, or a module that never served (no recorded hash) delivers normally.
+*/
+function isPresentationOnlyEdit(ctx, scannerRelPath, source) {
+	const servedHash = ctx.transformOutputHashes.get(scannerRelPath);
+	if (!servedHash || !ctx.storedManifestJson) return false;
+	if (!ctx.storedManifest?.files?.[scannerRelPath]?.length) return false;
+	try {
+		const { transformFile } = ctx.engineApi();
+		const fresh = transformFile(source, scannerRelPath, ctx.storedManifestJson);
+		if (!fresh.hasComponents) return false;
+		return (0, _animus_ui_extract_pipeline.contentHash)(applyDevBridgeImport(fresh.code)) === servedHash;
+	} catch {
+		return false;
+	}
+}
+/**
 * Reconcile a deleted file in dev.
 *
 * Without this the removed file's last-known source stays in `ctx.fileCache`,
@@ -880,17 +1146,19 @@ function pruneDeletedFile(ctx, absFile) {
 * (virtual:animus/styles.css) is NOT invalidated here — it only changes on a
 * geological reset (vars/globals are stable during dev).
 */
-function invalidateStaleModules(ctx, environment, modules, staleDefinitionFiles) {
+function invalidateStaleModules(ctx, environment, modules, analyzed) {
 	const graph = environment.moduleGraph;
-	const modulesToUpdate = [...modules];
-	for (const moduleId of [RESOLVED_COMPONENTS_ID, RESOLVED_SYSTEM_PROPS_ID]) {
+	const modulesToUpdate = analyzed.presentationOnly ? [] : [...modules];
+	const moduleIds = [RESOLVED_COMPONENTS_ID];
+	if (analyzed.systemPropsChanged) moduleIds.push(RESOLVED_SYSTEM_PROPS_ID);
+	for (const moduleId of moduleIds) {
 		const mod = graph.getModuleById(moduleId);
 		if (mod) {
 			graph.invalidateModule(mod);
 			modulesToUpdate.push(mod);
 		}
 	}
-	for (const defFile of staleDefinitionFiles) {
+	for (const defFile of analyzed.staleDefinitionFiles) {
 		const absDefPath = (0, path.resolve)(ctx.rootDir, defFile);
 		const defModule = graph.getModuleById(absDefPath) ?? graph.getModulesByFile(absDefPath)?.values().next().value;
 		if (defModule) {
@@ -899,6 +1167,11 @@ function invalidateStaleModules(ctx, environment, modules, staleDefinitionFiles)
 			modulesToUpdate.push(defModule);
 		}
 	}
+	if (analyzed.presentationOnly) {
+		ctx.log(`HMR (${environment.name}): presentation-only — ${modules.length} module update(s) suppressed, CSS delivered`);
+		for (const mod of modules) if (mod.url) environment.transformRequest?.(mod.url)?.catch(() => {});
+		return modulesToUpdate;
+	}
 	const invalidated = modulesToUpdate.length - modules.length;
 	if (invalidated > 0) {
 		ctx.log(`HMR (${environment.name}): ${invalidated} modules invalidated`);
@@ -910,16 +1183,18 @@ function invalidateStaleModules(ctx, environment, modules, staleDefinitionFiles)
 /**
 * transformIndexHtml: build the head-prepend tag set.
 *
-* Two independent tags, both delivery-only:
+* Three independent tags, all delivery-only:
 * - the appearance bootstrap script, when the host build passed a
 *   pre-generated artifact via `appearanceBootstrap` (absent otherwise);
-* - the `@layer` declaration style, when `buildStart` computed one.
+* - the `@layer` declaration style, when `buildStart` computed one;
+* - the HMR bridge module script, in dev only.
 *
-* Both branches are guarded on non-empty CONTENT, not on mere presence: an
-* artifact whose `code` is empty is a caller defect, and emitting
+* The two build-time branches are guarded on non-empty CONTENT, not on mere
+* presence: an artifact whose `code` is empty is a caller defect, and emitting
 * `<script data-animus-bootstrap><\/script>` for it would break the
 * unconfigured-parity contract in spirit (a tag that does nothing) while
-* hiding the defect. Symmetric with `layerDeclaration`.
+* hiding the defect. Symmetric with `layerDeclaration`. The bridge has no
+* content of its own — it is a `src` reference — so its only guard is the mode.
 *
 * Ordering: every descriptor rides the same `head-prepend` bucket, which Vite
 * serializes in array order (`serializeTags`) and splices in immediately after
@@ -927,8 +1202,8 @@ function invalidateStaleModules(ctx, environment, modules, staleDefinitionFiles)
 * before the layer declaration and — since built stylesheet links are appended
 * at `</head>` — before any stylesheet reference.
 *
-* When neither input is set the array is empty, so an unconfigured build emits
-* no tag, attribute, or whitespace of its own.
+* With neither build-time input set, a production build emits no tag,
+* attribute, or whitespace of its own.
 */
 function buildIndexHtmlTags(ctx) {
 	const tags = [];
@@ -945,74 +1220,25 @@ function buildIndexHtmlTags(ctx) {
 		children: ctx.layerDeclaration,
 		injectTo: "head-prepend"
 	});
+	if (!ctx.isProd) tags.push({
+		tag: "script",
+		attrs: {
+			type: "module",
+			src: BRIDGE_SCRIPT_SRC,
+			"data-animus-bridge": ""
+		},
+		injectTo: "head-prepend"
+	});
 	return tags;
 }
 //#endregion
-//#region src/transform.ts
-/**
-* transform: replace builder chains with `createComponent()` calls using
-* the pre-built manifest; inject the HMR bridge import once in dev; detect
-* files created after buildStart and fold them into the analysis.
-*/
-function transformSource(ctx, code, id) {
-	if (!ctx.storedManifest) return null;
-	const isExternalPkg = ctx.externalPackageDirs.some((dir) => id.startsWith(dir + path.sep) || id === dir);
-	if (!isExternalPkg) {
-		if (!/\.[jt]sx?$/.test(id)) return null;
-		if (id.includes("node_modules")) return null;
-	}
-	const relativePath = (0, path.relative)(ctx.rootDir, id);
-	if (!ctx.storedManifest.files?.[relativePath]?.length) {
-		if (!ctx.isProd && !ctx.fileCache.has(relativePath)) {
-			if (isExternalPkg) {
-				const owner = Object.entries(ctx.externalDirOwners).find(([dir]) => id === dir || id.startsWith(dir + path.sep));
-				if (owner) ctx.externalFileOwners[relativePath] = owner[1];
-			}
-			const hash = (0, _animus_ui_extract_pipeline.contentHash)(code);
-			ctx.fileCache.set(relativePath, {
-				hash,
-				source: code
-			});
-			const fileEntries = buildFileEntriesFromCache(ctx.fileCache, relativePath);
-			ctx.runAnalysis(fileEntries);
-			const compCount = ctx.storedManifest.files?.[relativePath]?.length ?? 0;
-			ctx.log(`New file detected: ${relativePath} — ${compCount ? `${compCount} components extracted` : "no components"}`);
-			if (compCount) ctx.invalidateExtractedModules();
-		}
-		if (!ctx.storedManifest.files?.[relativePath]?.length) return null;
-	}
-	try {
-		const { transformFile } = ctx.engineApi();
-		const result = transformFile(code, relativePath, ctx.storedManifestJson);
-		if (!result.hasComponents) return null;
-		let transformedCode = result.code;
-		if (!ctx.isProd && !ctx.bridgeInjected && ctx.storedSheets) {
-			transformedCode = `import '${VIRTUAL_BRIDGE_ID}';\n${transformedCode}`;
-			ctx.bridgeInjected = true;
-			ctx.log("HMR bridge injected via transform");
-		}
-		if (ctx.verbose) {
-			const compCount = ctx.storedManifest.files?.[relativePath]?.length ?? 0;
-			ctx.log(`transform ${relativePath}: ${compCount} components`);
-		}
-		return {
-			code: transformedCode,
-			map: null
-		};
-	} catch (e) {
-		if (ctx.options.strict) throw new Error(`[animus-extract] Failed to transform ${id}: ${e}`, { cause: e });
-		console.warn(`[animus-extract] Failed to transform ${id}:`, e);
-		return null;
-	}
-}
-//#endregion
 //#region src/virtual-modules.ts
 /** resolveId: map virtual ids and redirect external DS package imports. */
 function resolveVirtualId(ctx, id) {
-	if (id === "virtual:animus/styles.css") return RESOLVED_CSS_ID;
-	if (id === "virtual:animus/components.js") return RESOLVED_COMPONENTS_ID;
-	if (id === "virtual:animus/hmr-bridge.js") return RESOLVED_BRIDGE_ID;
-	if (id === "virtual:animus/system-props") return RESOLVED_SYSTEM_PROPS_ID;
+	if (id === VIRTUAL_CSS_ID) return RESOLVED_CSS_ID;
+	if (id === VIRTUAL_COMPONENTS_ID) return RESOLVED_COMPONENTS_ID;
+	if (id === VIRTUAL_BRIDGE_ID) return RESOLVED_BRIDGE_ID;
+	if (id === VIRTUAL_SYSTEM_PROPS_ID) return RESOLVED_SYSTEM_PROPS_ID;
 	const srcEntry = ctx.externalSourceEntries.get(id);
 	if (srcEntry) return srcEntry;
 	return null;
@@ -1025,7 +1251,7 @@ function loadVirtualModule(ctx, id) {
 		targets: ctx.lcssTargets,
 		warnFn: (msg) => ctx.warn(msg)
 	};
-	if (id === "\0virtual:animus/styles.css") {
+	if (id === RESOLVED_CSS_ID) {
 		if (!ctx.isProd && ctx.storedSheets) {
 			const { variables, body } = (0, _animus_ui_extract_pipeline.assembleStylesheet)({
 				layers: ctx.options.layers,
@@ -1047,36 +1273,44 @@ function loadVirtualModule(ctx, id) {
 		});
 		return [variables, (0, _animus_ui_extract_pipeline.postProcessCss)(body, lcssOpts)].filter(Boolean).join("\n");
 	}
-	if (id === "\0virtual:animus/components.js") return `export default \`${(0, _animus_ui_extract_pipeline.postProcessCss)((0, _animus_ui_extract_pipeline.stripLeadingLayerDeclaration)(ctx.resolvedComponentCss || ""), {
+	if (id === RESOLVED_COMPONENTS_ID) return `export default \`${(0, _animus_ui_extract_pipeline.postProcessCss)((0, _animus_ui_extract_pipeline.stripLeadingLayerDeclaration)(ctx.resolvedComponentCss || ""), {
 		...lcssOpts,
 		minify: false
 	}).replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`;`;
-	if (id === "\0virtual:animus/hmr-bridge.js") return `
+	if (id === RESOLVED_BRIDGE_ID) return `
 import css from '${VIRTUAL_COMPONENTS_ID}';
 
 const GLOBAL_KEY = '__animus_sheet_${(0, crypto.createHash)("md5").update(ctx.options.system).digest("hex").slice(0, 8)}__';
 let sheet = globalThis[GLOBAL_KEY] || null;
 
-if (typeof CSSStyleSheet !== 'undefined' && 'adoptedStyleSheets' in document) {
-  if (!sheet) {
-    sheet = new CSSStyleSheet();
-    globalThis[GLOBAL_KEY] = sheet;
-    document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
-  }
-  sheet.replaceSync(css);
-} else {
-  // Fallback: inject or update <style> tag
-  let el = document.querySelector('style[data-animus-components]');
-  if (!el) {
-    el = document.createElement('style');
-    el.setAttribute('data-animus-components', '');
-    document.head.appendChild(el);
+// Server evaluation is a no-op: SSR hosts reach this module through the
+// bridge import prepended to transformed component modules, and only the
+// browser pass owns a document.
+if (typeof document !== 'undefined') {
+  if (typeof CSSStyleSheet !== 'undefined' && 'adoptedStyleSheets' in document) {
+    if (!sheet) {
+      sheet = new CSSStyleSheet();
+      globalThis[GLOBAL_KEY] = sheet;
+      document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
+    }
+    sheet.replaceSync(css);
+  } else {
+    // Fallback: inject or update <style> tag
+    let el = document.querySelector('style[data-animus-components]');
+    if (!el) {
+      el = document.createElement('style');
+      el.setAttribute('data-animus-components', '');
+      document.head.appendChild(el);
+    }
+    el.textContent = css;
   }
-  el.textContent = css;
 }
 
 if (import.meta.hot) {
   import.meta.hot.accept('${VIRTUAL_COMPONENTS_ID}', (newModule) => {
+    // The server module runner has a hot channel too; only the browser
+    // pass owns a document to update.
+    if (typeof document === 'undefined') return;
     if (sheet) {
       sheet.replaceSync(newModule.default);
     } else {
@@ -1086,12 +1320,7 @@ if (import.meta.hot) {
   });
 }
 `;
-	if (id === "\0virtual:animus/system-props") return (0, _animus_ui_extract_pipeline.buildSystemPropsModule)({
-		systemPropMapJson: ctx.storedSystemPropMapJson,
-		groupRegistryJson: ctx.system.groupRegistryJson,
-		dynamicProps: JSON.parse(ctx.storedDynamicPropsJson),
-		transformsSource: ctx.storedTransformsSource
-	});
+	if (id === RESOLVED_SYSTEM_PROPS_ID) return systemPropsModuleSource(ctx);
 	return null;
 }
 //#endregion
@@ -1107,6 +1336,9 @@ function animusExtract(options) {
 	return {
 		name: "animus-extract",
 		enforce: "pre",
+		config(_config, env) {
+			return { define: { __ANIMUS_DEV__: env.command !== "build" } };
+		},
 		configureServer(server) {
 			ctx.devServer = server;
 			ctx.registerSystemWatchPaths();

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEnC,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAE5D,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,gCAAgC;IAChC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,qGAAqG;IACrG,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,IAAI,CAAC;IACd;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,mBAAmB,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACzD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,MAAM,CAmEnE;eAEc,aAAa"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEnC,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAE5D,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,gCAAgC;IAChC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,qGAAqG;IACrG,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,IAAI,CAAC;IACd;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,mBAAmB,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACzD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,MAAM,CA0EnE;eAEc,aAAa"}

package/dist/transform.d.ts

@@ -1,8 +1,22 @@
 import type { PluginContext } from './context';
+/**
+ * The dev-mode bridge prepend, shared with the hot-update gate so both
+ * compute byte-identical served output. The import goes AFTER the directive
+ * prologue the engine hoists to byte 0 — prepending above it would demote
+ * 'use client'/'use strict' to an ordinary expression statement, silently
+ * un-marking client modules on exactly the RSC-capable hosts this delivery
+ * path serves.
+ */
+export declare function applyDevBridgeImport(code: string): string;
 /**
  * transform: replace builder chains with `createComponent()` calls using
- * the pre-built manifest; inject the HMR bridge import once in dev; detect
- * files created after buildStart and fold them into the analysis.
+ * the pre-built manifest; detect files created after buildStart and fold
+ * them into the analysis.
+ *
+ * The HMR bridge is NOT injected here — `transformIndexHtml` delivers it as a
+ * `<script type="module">` per served document (openspec:
+ * dev-stylesheet-management, "HMR bridge auto-injected in dev mode"; "Transform
+ * emitter unchanged" forbids the emitter importing it).
  */
 export declare function transformSource(ctx: PluginContext, code: string, id: string): {
     code: string;

package/dist/transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,aAAa,EAClB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,IAAI,CAAA;CAAE,GAAG,IAAI,CAuFpC"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,aAAa,EAClB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,IAAI,CAAA;CAAE,GAAG,IAAI,CAqHpC"}

package/dist/virtual-modules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"virtual-modules.d.ts","sourceRoot":"","sources":["../src/virtual-modules.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,aAAa,EAClB,EAAE,EAAE,MAAM,GACT,MAAM,GAAG,IAAI,CAYf;AAED;wDACwD;AACxD,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,aAAa,EAClB,EAAE,EAAE,MAAM,GACT,MAAM,GAAG,IAAI,CAyGf"}
+{"version":3,"file":"virtual-modules.d.ts","sourceRoot":"","sources":["../src/virtual-modules.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,aAAa,EAClB,EAAE,EAAE,MAAM,GACT,MAAM,GAAG,IAAI,CAYf;AAED;wDACwD;AACxD,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,aAAa,EAClB,EAAE,EAAE,MAAM,GACT,MAAM,GAAG,IAAI,CA8Gf"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@animus-ui/vite-plugin",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Animus static CSS extraction Vite plugin",
   "keywords": [
     "animus",
@@ -39,7 +39,7 @@
     "compile": "tsc --noEmit"
   },
   "dependencies": {
-    "@animus-ui/extract": "0.1.4",
+    "@animus-ui/extract": "0.1.6",
     "browserslist": "^4.24.0",
     "lightningcss": "^1.29.0"
   },