@animus-ui/vite-plugin 0.1.3 → 0.1.5

package/README.md

@@ -50,9 +50,9 @@ import { createAppearanceBootstrap } from '@animus-ui/system/bootstrap';
 import { animusExtract } from '@animus-ui/vite-plugin';
 import { defineConfig } from 'vite';
 
-import { tokens } from './src/ds';
+import { theme } from './src/ds';
 
-const appearanceBootstrap = createAppearanceBootstrap(tokens);
+const appearanceBootstrap = createAppearanceBootstrap(theme);
 
 export default defineConfig({
   plugins: [animusExtract({ system: './src/ds.ts', appearanceBootstrap })],

package/dist/build-start.d.ts

@@ -3,7 +3,9 @@ import type { PluginContext } from './context';
  * buildStart: load the system, discover and ingest sources (local +
  * external packages), run whole-project analysis, and log the report.
  * `resolveSpecifier` is the bundler seam — Vite's `this.resolve` mapped to
- * an absolute id.
+ * an absolute id. `emitAsset` (build mode only) is Rollup's `this.emitFile`
+ * for `asset()` placeholder substitution; absent in dev, where resolved
+ * files are served via base + `/@fs/` instead.
  */
-export declare function runBuildStart(ctx: PluginContext, resolveSpecifier: (specifier: string) => Promise<string | null>): Promise<void>;
+export declare function runBuildStart(ctx: PluginContext, resolveSpecifier: (specifier: string) => Promise<string | null>, emitAsset?: (fileName: string, source: Uint8Array) => string): Promise<void>;
 //# sourceMappingURL=build-start.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"build-start.d.ts","sourceRoot":"","sources":["../src/build-start.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,aAAa,EAClB,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GAC9D,OAAO,CAAC,IAAI,CAAC,CAsNf"}
+{"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"}

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAE3C;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,aAAa,EAClB,MAAM,EAAE,cAAc,GACrB,IAAI,CAqDN"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAE3C;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,aAAa,EAClB,MAAM,EAAE,cAAc,GACrB,IAAI,CAwDN"}

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

@@ -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
@@ -84,17 +123,23 @@ export declare class PluginContext {
     storedSystemPropMapJson: string;
     storedDynamicPropsJson: string;
     storedTransformsSource: string;
+    systemPropsModuleMemo: string | null;
     fileCache: Map<string, {
         hash: string;
         source: string;
     }>;
     readonly hotUpdateEvents: HotUpdateEvents;
     packageMap: Record<string, string>;
+    base: string;
+    assetUrlBySpecifier: Map<string, string>;
+    assetResolutionFailures: Set<string>;
+    assetPassComplete: boolean;
     externalPackageDirs: string[];
+    externalDirOwners: Record<string, string>;
+    externalFileOwners: Record<string, string>;
     externalSourceEntries: Map<string, string>;
     externalPackageOutcomes: ExternalPackageOutcome[];
     devServer: any;
-    bridgeInjected: boolean;
     resolvedSystemPath: string | null;
     systemDependencyKeys: Set<string>;
     systemDependencyPaths: string[];
@@ -103,8 +148,15 @@ export declare class PluginContext {
     private v2DriftWarned;
     /** Single engine choke-point for every native extraction call. */
     readonly engineApi: () => any;
-    constructor(options: AnimusExtractOptions);
+    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;
     /**
@@ -122,6 +174,24 @@ export declare class PluginContext {
         source: string;
         hash?: string;
     }>): void;
+    /** Base-prefixed dev URL for an absolute file (Vite mounts /@fs under base). */
+    devFsUrl(absPath: string): string;
+    /**
+     * The shared unresolvable-asset policy: fail the build under `strict`,
+     * else warn and record the identity mapping so the specifier emits
+     * literally.
+     */
+    assetFallback(specifier: string, message: string, cause?: unknown): void;
+    /**
+     * The one asset-substitution pass per analysis. In dev, a specifier not
+     * already mapped by buildStart's bundler-resolved pass (a geological
+     * reset regenerates globalCss from an edited system, which may reference
+     * NEW assets) is resolved Node-side first — host aliases, then Node,
+     * then package root; bundler-only resolutions can differ, since the
+     * plugin hook context is unavailable on this path. Strict semantics
+     * match buildStart.
+     */
+    private applyAssetSubstitutions;
     private resetCoalescer;
     /**
      * Schedule a geological reset through the burst coalescer. N dependency
@@ -129,6 +199,15 @@ export declare class PluginContext {
      * running reset produce exactly one follow-up.
      */
     requestGeologicalReset(trigger: string): void;
+    /**
+     * A failed reset must surface without killing the server: the coalescer
+     * fires from a bare timer, OUTSIDE Vite's handleHMRUpdate catch, so a
+     * strict-mode throw (asset resolution, token contracts, system load)
+     * would otherwise be an unhandled exception that exits the process.
+     * Strict-in-dev means the error overlay, matching the transform/HMR
+     * strict paths that Vite itself catches.
+     */
+    private geologicalResetFailed;
     /**
      * The geological reset: reload the system (refreshing the dependency
      * set), clear the Rust per-file cache, re-analyze everything with full
@@ -164,6 +243,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;
     /**
@@ -171,9 +257,21 @@ export declare class PluginContext {
      * (external-package-file-discovery: silence is never an outcome). An
      * unresolvable `.includes()` specifier warns in non-strict mode and FAILS
      * the build under `strict: true`, naming every offending specifier —
-     * a typo'd include must not ship a build missing its component CSS.
+     * a typo'd include must not ship a build missing its component CSS. A
+     * stale dist entry under an extended package (first-class-extension D13)
+     * rides the same seam: a merge against it would silently skew registry
+     * content the discovered sources no longer match.
      */
     enforceIncludeResolution(): void;
+    /**
+     * The post-analysis gate over cross-source token contracts
+     * (extraction-diagnostics): a discovered component referencing a token its
+     * OWN package defines but the consumer theme does not gets the teaching
+     * error naming the token, component, source package, and the missing
+     * `createTheme().extend(...)`. Wiring and severity routing live in the
+     * shared pipeline gate (next-plugin parity by construction).
+     */
+    enforceExternalTokenContracts(): void;
     runSelfVerify(): void;
 }
 //# sourceMappingURL=context.d.ts.map

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":"AAeA,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,10 @@
  * - `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.
  */
 export type HotUpdateResult = {
     kind: 'ignored';
@@ -18,6 +21,7 @@ export type HotUpdateResult = {
 } | {
     kind: 'analyzed';
     staleDefinitionFiles: string[];
+    systemPropsChanged: 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;;;;;;;;;;;;;;;GAeG;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;CAC7B,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",
@@ -26,10 +49,15 @@ const DEFAULT_EXCLUDE = [
 * buildStart: load the system, discover and ingest sources (local +
 * external packages), run whole-project analysis, and log the report.
 * `resolveSpecifier` is the bundler seam — Vite's `this.resolve` mapped to
-* an absolute id.
+* an absolute id. `emitAsset` (build mode only) is Rollup's `this.emitFile`
+* for `asset()` placeholder substitution; absent in dev, where resolved
+* files are served via base + `/@fs/` instead.
 */
-async function runBuildStart(ctx, resolveSpecifier) {
+async function runBuildStart(ctx, resolveSpecifier, emitAsset) {
 	(0, _animus_ui_extract_pipeline.clearEngineCache)(ctx.engineApi);
+	ctx.assetPassComplete = false;
+	ctx.assetUrlBySpecifier.clear();
+	ctx.assetResolutionFailures.clear();
 	let t0 = performance.now();
 	ctx.loadSystem();
 	if (ctx.options.layers) {
@@ -106,6 +134,8 @@ async function runBuildStart(ctx, resolveSpecifier) {
 	});
 	ctx.packageMap = collected.packageMap;
 	ctx.externalPackageOutcomes = collected.outcomes;
+	ctx.externalDirOwners = collected.dirOwners;
+	ctx.externalFileOwners = collected.fileOwners;
 	ctx.enforceIncludeResolution();
 	for (const [specifier, srcEntry] of collected.sourceEntries) ctx.externalSourceEntries.set(specifier, srcEntry);
 	for (const entry of collected.entries) {
@@ -126,6 +156,23 @@ async function runBuildStart(ctx, resolveSpecifier) {
 	ctx.log(`Discovered ${fileEntries.length} files (${packageFileCount} from packages) (${Math.round(performance.now() - t0)}ms)`);
 	t0 = performance.now();
 	ctx.runAnalysis(fileEntries);
+	const assetSpecifiers = (0, _animus_ui_extract_pipeline.findAssetSpecifiers)(ctx.globalCss);
+	for (const specifier of assetSpecifiers) {
+		const resolvedPath = await resolveSpecifier(specifier);
+		if (!resolvedPath) {
+			ctx.assetFallback(specifier, `[animus-extract] unresolvable asset() specifier: ${specifier}`);
+			continue;
+		}
+		if (emitAsset) try {
+			const referenceId = emitAsset((0, path.basename)(resolvedPath), (0, fs.readFileSync)(resolvedPath));
+			ctx.assetUrlBySpecifier.set(specifier, `__VITE_ASSET__${referenceId}__`);
+		} catch (err) {
+			ctx.assetFallback(specifier, `[animus-extract] failed to emit asset() specifier ${specifier}: ${String(err)}`, err);
+		}
+		else ctx.assetUrlBySpecifier.set(specifier, ctx.devFsUrl(resolvedPath));
+	}
+	ctx.globalCss = (0, _animus_ui_extract_pipeline.substituteAssetPlaceholders)(ctx.globalCss, ctx.assetUrlBySpecifier);
+	ctx.assetPassComplete = true;
 	if (ctx.storedManifest) {
 		const report = ctx.storedManifest.report;
 		if (report) {
@@ -169,6 +216,7 @@ function applyResolvedConfig(ctx, config) {
 	ctx.isProd = config.command === "build";
 	ctx.rootDir = config.root;
 	ctx.logger = config.logger;
+	ctx.base = config.base ?? "/";
 	ctx.lcssTargets = (0, _animus_ui_extract_pipeline.resolveLightningTargets)(ctx.options.targets, ctx.rootDir);
 	ctx.log(`Lightning CSS targets resolved (${Object.keys(ctx.lcssTargets).length} browsers)`);
 	const rawAlias = config.resolve?.alias;
@@ -261,8 +309,9 @@ var ResetCoalescer = class {
 	timer = null;
 	running = false;
 	dirty = false;
-	constructor(run, quietMs = 60, schedule = (fn, ms) => setTimeout(fn, ms), cancel = (timer) => clearTimeout(timer)) {
+	constructor(run, onError, quietMs = 60, schedule = (fn, ms) => setTimeout(fn, ms), cancel = (timer) => clearTimeout(timer)) {
 		this.run = run;
+		this.onError = onError;
 		this.quietMs = quietMs;
 		this.schedule = schedule;
 		this.cancel = cancel;
@@ -279,6 +328,8 @@ var ResetCoalescer = class {
 			this.running = true;
 			try {
 				this.run();
+			} catch (err) {
+				this.onError(err);
 			} finally {
 				this.running = false;
 				if (this.dirty) {
@@ -321,6 +372,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
@@ -367,14 +468,20 @@ var PluginContext = class {
 	storedSystemPropMapJson = "{}";
 	storedDynamicPropsJson = "{}";
 	storedTransformsSource = "{}";
+	systemPropsModuleMemo = null;
 	fileCache = /* @__PURE__ */ new Map();
 	hotUpdateEvents = new HotUpdateEvents();
 	packageMap = {};
+	base = "/";
+	assetUrlBySpecifier = /* @__PURE__ */ new Map();
+	assetResolutionFailures = /* @__PURE__ */ new Set();
+	assetPassComplete = false;
 	externalPackageDirs = [];
+	externalDirOwners = {};
+	externalFileOwners = {};
 	externalSourceEntries = /* @__PURE__ */ new Map();
 	externalPackageOutcomes = [];
 	devServer;
-	bridgeInjected = false;
 	resolvedSystemPath = null;
 	systemDependencyKeys = /* @__PURE__ */ new Set();
 	systemDependencyPaths = [];
@@ -383,11 +490,15 @@ var PluginContext = class {
 	v2DriftWarned = false;
 	/** Single engine choke-point for every native extraction call. */
 	engineApi;
-	constructor(options) {
+	constructor(options, engineApiOverride) {
 		this.options = options;
 		this.staticCssJson = (0, _animus_ui_extract_pipeline.serializeStaticCss)(options.staticCss);
 		this.verbose = options.verbose || process.env.ANIMUS_DEBUG === "1" || process.env.ANIMUS_DEBUG === "true";
 		this.extensionsSet = new Set(options.extensions ?? _animus_ui_extract_pipeline.DEFAULT_EXTENSIONS);
+		if (engineApiOverride) {
+			this.engineApi = engineApiOverride;
+			return;
+		}
 		const engineModuleId = "@animus-ui/extract";
 		this.engineApi = (0, _animus_ui_extract_pipeline.createV2EngineApi)({
 			label: "animus-extract",
@@ -418,6 +529,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}`);
 	}
@@ -453,6 +573,7 @@ var PluginContext = class {
 			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
@@ -470,6 +591,7 @@ var PluginContext = class {
 				},
 				pathAliasesJson: this.pathAliasesJson,
 				staticCssJson: this.staticCssJson,
+				externalDirs: this.externalPackageDirs.map((dir) => (0, path.relative)(this.rootDir, dir)),
 				devMode: !this.isProd,
 				warn: (m) => this.warn(m)
 			});
@@ -477,7 +599,6 @@ var PluginContext = class {
 			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();
@@ -490,7 +611,45 @@ var PluginContext = class {
 		} catch (e) {
 			if (this.options.strict) throw new Error(`[animus-extract] analyzeProject failed: ${e}`, { cause: e });
 			console.warn("[animus-extract] analyzeProject failed:", e);
+			return;
+		}
+		this.systemPropsModuleMemo = generateSystemPropsModule(this);
+		this.applyAssetSubstitutions();
+		this.enforceExternalTokenContracts();
+	}
+	/** Base-prefixed dev URL for an absolute file (Vite mounts /@fs under base). */
+	devFsUrl(absPath) {
+		return `${this.base.endsWith("/") ? this.base.slice(0, -1) : this.base}/@fs${absPath}`;
+	}
+	/**
+	* The shared unresolvable-asset policy: fail the build under `strict`,
+	* else warn and record the identity mapping so the specifier emits
+	* literally.
+	*/
+	assetFallback(specifier, message, cause) {
+		if (this.options.strict) throw new Error(message, cause === void 0 ? void 0 : { cause });
+		this.warn(message);
+		this.assetUrlBySpecifier.set(specifier, specifier);
+		this.assetResolutionFailures.add(specifier);
+	}
+	/**
+	* The one asset-substitution pass per analysis. In dev, a specifier not
+	* already mapped by buildStart's bundler-resolved pass (a geological
+	* reset regenerates globalCss from an edited system, which may reference
+	* NEW assets) is resolved Node-side first — host aliases, then Node,
+	* then package root; bundler-only resolutions can differ, since the
+	* plugin hook context is unavailable on this path. Strict semantics
+	* match buildStart.
+	*/
+	applyAssetSubstitutions() {
+		if (!this.isProd && this.assetPassComplete) for (const specifier of (0, _animus_ui_extract_pipeline.findAssetSpecifiers)(this.globalCss)) {
+			if (this.assetResolutionFailures.delete(specifier)) this.assetUrlBySpecifier.delete(specifier);
+			if (this.assetUrlBySpecifier.has(specifier)) continue;
+			const resolved = (0, _animus_ui_extract_pipeline.resolveAssetFile)(specifier, this.rootDir, this.pathAliasesJson);
+			if (resolved) this.assetUrlBySpecifier.set(specifier, this.devFsUrl(resolved));
+			else this.assetFallback(specifier, `[animus-extract] unresolvable asset() specifier: ${specifier}`);
 		}
+		this.globalCss = (0, _animus_ui_extract_pipeline.substituteAssetPlaceholders)(this.globalCss, this.assetUrlBySpecifier);
 	}
 	resetCoalescer = null;
 	/**
@@ -500,10 +659,31 @@ var PluginContext = class {
 	*/
 	requestGeologicalReset(trigger) {
 		this.log(`HMR geological reset scheduled: ${trigger}`);
-		this.resetCoalescer ??= new ResetCoalescer(() => this.performGeologicalReset());
+		this.resetCoalescer ??= new ResetCoalescer(() => this.performGeologicalReset(), (err) => this.geologicalResetFailed(err));
 		this.resetCoalescer.request();
 	}
 	/**
+	* A failed reset must surface without killing the server: the coalescer
+	* fires from a bare timer, OUTSIDE Vite's handleHMRUpdate catch, so a
+	* strict-mode throw (asset resolution, token contracts, system load)
+	* would otherwise be an unhandled exception that exits the process.
+	* Strict-in-dev means the error overlay, matching the transform/HMR
+	* strict paths that Vite itself catches.
+	*/
+	geologicalResetFailed(err) {
+		this.warn(`[animus-extract] geological reset failed: ${err}`);
+		const message = err instanceof Error ? err.message : String(err);
+		const stack = err instanceof Error ? err.stack ?? "" : "";
+		this.devServer?.hot?.send({
+			type: "error",
+			err: {
+				message,
+				stack,
+				plugin: "animus-extract"
+			}
+		});
+	}
+	/**
 	* The geological reset: reload the system (refreshing the dependency
 	* set), clear the Rust per-file cache, re-analyze everything with full
 	* sources, then invalidate the static/component/system-prop virtual
@@ -568,6 +748,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;
@@ -585,13 +772,36 @@ var PluginContext = class {
 	* (external-package-file-discovery: silence is never an outcome). An
 	* unresolvable `.includes()` specifier warns in non-strict mode and FAILS
 	* the build under `strict: true`, naming every offending specifier —
-	* a typo'd include must not ship a build missing its component CSS.
+	* a typo'd include must not ship a build missing its component CSS. A
+	* stale dist entry under an extended package (first-class-extension D13)
+	* rides the same seam: a merge against it would silently skew registry
+	* content the discovered sources no longer match.
 	*/
 	enforceIncludeResolution() {
-		const message = (0, _animus_ui_extract_pipeline.unresolvableIncludesMessage)(this.externalPackageOutcomes);
-		if (message === null) return;
-		if (this.options.strict) throw new Error(message);
-		this.warn(message);
+		for (const message of [(0, _animus_ui_extract_pipeline.unresolvableIncludesMessage)(this.externalPackageOutcomes), (0, _animus_ui_extract_pipeline.staleDistIncludesMessage)(this.externalPackageOutcomes)]) {
+			if (message === null) continue;
+			if (this.options.strict) throw new Error(message);
+			this.warn(message);
+		}
+	}
+	/**
+	* The post-analysis gate over cross-source token contracts
+	* (extraction-diagnostics): a discovered component referencing a token its
+	* OWN package defines but the consumer theme does not gets the teaching
+	* error naming the token, component, source package, and the missing
+	* `createTheme().extend(...)`. Wiring and severity routing live in the
+	* shared pipeline gate (next-plugin parity by construction).
+	*/
+	enforceExternalTokenContracts() {
+		(0, _animus_ui_extract_pipeline.enforceExternalTokenContracts)({
+			diagnostics: this.storedManifest?.diagnostics,
+			fileOwners: this.externalFileOwners,
+			dirOwners: this.externalDirOwners,
+			sourceThemeManifestsJson: this.system.sourceThemeManifestsJson,
+			strict: this.options.strict,
+			prefix: "[animus-extract]",
+			warn: (message) => this.warn(message)
+		});
 	}
 	runSelfVerify() {
 		const failures = [];
@@ -641,13 +851,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;
@@ -655,18 +868,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;
@@ -674,7 +938,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" };
 	}
@@ -720,8 +984,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) {
@@ -737,7 +1000,8 @@ async function analyzeChangedFile(ctx, file, absFile) {
 	ctx.logTimingWaterfall(ctx.storedManifest?.timing ?? {});
 	return {
 		kind: "analyzed",
-		staleDefinitionFiles
+		staleDefinitionFiles,
+		systemPropsChanged
 	};
 }
 /**
@@ -760,17 +1024,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 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) {
@@ -790,16 +1056,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
@@ -807,8 +1075,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 = [];
@@ -825,24 +1093,45 @@ 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.
+* 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 (!ctx.externalPackageDirs.some((dir) => id.startsWith(dir + path.sep) || id === dir)) {
+	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;
 	}
-	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,
@@ -851,8 +1140,8 @@ function transformSource(ctx, code, id) {
 			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();
+			ctx.info(`New file detected: ${relativePath} — ${compCount ? `${compCount} components extracted` : "no components"}`);
+			ctx.invalidateExtractedModules();
 		}
 		if (!ctx.storedManifest.files?.[relativePath]?.length) return null;
 	}
@@ -860,18 +1149,17 @@ function transformSource(ctx, code, id) {
 		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`);
 		}
+		let outputCode = result.code;
+		if (!ctx.isProd) {
+			const prologue = /^(?:(['"])use [a-z -]+\1;?\r?\n)*/.exec(result.code)?.[0] ?? "";
+			outputCode = prologue + `import '${VIRTUAL_BRIDGE_ID}';\n` + result.code.slice(prologue.length);
+		}
 		return {
-			code: transformedCode,
+			code: outputCode,
 			map: null
 		};
 	} catch (e) {
@@ -884,10 +1172,10 @@ function transformSource(ctx, code, id) {
 //#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;
@@ -900,7 +1188,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,
@@ -922,36 +1210,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 {
@@ -961,12 +1257,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
@@ -982,6 +1273,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();
@@ -992,7 +1286,11 @@ function animusExtract(options) {
 		async buildStart() {
 			await runBuildStart(ctx, async (specifier) => {
 				return (await this.resolve(specifier))?.id ?? null;
-			});
+			}, ctx.isProd ? (fileName, source) => this.emitFile({
+				type: "asset",
+				name: fileName,
+				source
+			}) : void 0);
 		},
 		resolveId(id) {
 			return resolveVirtualId(ctx, id);

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,CA0DnE;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/reset-coalescer.d.ts

@@ -9,13 +9,14 @@
  */
 export declare class ResetCoalescer {
     private readonly run;
+    private readonly onError;
     private readonly quietMs;
     private readonly schedule;
     private readonly cancel;
     private timer;
     private running;
     private dirty;
-    constructor(run: () => void, quietMs?: number, schedule?: (fn: () => void, ms: number) => unknown, cancel?: (timer: unknown) => void);
+    constructor(run: () => void, onError: (err: unknown) => void, quietMs?: number, schedule?: (fn: () => void, ms: number) => unknown, cancel?: (timer: unknown) => void);
     /** Ask for a reset; bursts within the quiescence window collapse. */
     request(): void;
 }

package/dist/reset-coalescer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reset-coalescer.d.ts","sourceRoot":"","sources":["../src/reset-coalescer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,qBAAa,cAAc;IAMvB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAIzB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAXzB,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,KAAK,CAAS;IAEtB,YACmB,GAAG,EAAE,MAAM,IAAI,EACf,OAAO,SAAK,EACZ,QAAQ,GAAE,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,KAAK,OAGpC,EACN,MAAM,GAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IACS,EACpD;IAEJ,qEAAqE;IACrE,OAAO,IAAI,IAAI,CAmBd;CACF"}
+{"version":3,"file":"reset-coalescer.d.ts","sourceRoot":"","sources":["../src/reset-coalescer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,qBAAa,cAAc;IAMvB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAKpB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAIzB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAhBzB,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,KAAK,CAAS;IAEtB,YACmB,GAAG,EAAE,MAAM,IAAI,EAKf,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,EAC/B,OAAO,SAAK,EACZ,QAAQ,GAAE,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,KAAK,OAGpC,EACN,MAAM,GAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IACS,EACpD;IAEJ,qEAAqE;IACrE,OAAO,IAAI,IAAI,CAqBd;CACF"}

package/dist/transform.d.ts

@@ -1,8 +1,13 @@
 import type { PluginContext } from './context';
 /**
  * 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,CA4EpC"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C;;;;;;;;;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,CA0HpC"}

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.3",
+  "version": "0.1.5",
   "description": "Animus static CSS extraction Vite plugin",
   "keywords": [
     "animus",
@@ -39,7 +39,7 @@
     "compile": "tsc --noEmit"
   },
   "dependencies": {
-    "@animus-ui/extract": "0.1.3",
+    "@animus-ui/extract": "0.1.5",
     "browserslist": "^4.24.0",
     "lightningcss": "^1.29.0"
   },