@nisli/core 0.49.2 → 0.51.0

package/dist/hmr/registry.d.ts

@@ -0,0 +1,58 @@
+/**
+ * hmr/registry.ts — Transport-agnostic HMR core for Nisli (ADR 0021, ADR 0110).
+ *
+ * The tag→setup registry, the stable indirection thunk, and the in-place
+ * re-mount through the custom-element lifecycle. This is the part that is
+ * IDENTICAL regardless of how change notifications arrive — change
+ * (`../esbuild-hmr/*`) or Vite `import.meta.hot` (`../vite-hmr/*`) both drive
+ * the same registry. Keeping it here means one implementation, one set of
+ * correctness guarantees (ADR 0008.1 disposal), and no duplication.
+ *
+ * DEV-ONLY: reachable only via the dev subpaths, never from the `@nisli/core`
+ * `.` entry, so it contributes zero production bytes.
+ */
+/** The author's setup function, kept opaque here (props proxy, host). */
+export type HmrSetup = (props: unknown, host: HTMLElement) => unknown;
+/**
+ * Begin a caller-owned drain window: suppress auto-scheduling AND cancel any
+ * pending microtask drain, so the caller can re-evaluate a whole bundle and
+ * register ALL changed tags before a single explicit `drainRemounts()`. Used by
+ * the Vite path drains per-module.
+ */
+export declare function beginManualDrain(): void;
+/** End a caller-owned drain window (re-enable auto-scheduling). */
+export declare function endManualDrain(): void;
+/**
+ * Register (or update) the setup for a tag and return a STABLE indirection
+ * thunk that always reads the *current* setup from the registry.
+ *
+ * First registration for a tag (initial load) schedules no re-mount. A
+ * subsequent registration with a *different* setup reference (a rebuild
+ * re-evaluating the module) queues the tag for re-mount.
+ *
+ * The returned thunk is what `component()` hands to the real
+ * `FrameworkComponent`; because it reads `registry.get(tag)` lazily, the live
+ * element picks up new setup with no class swap or tag re-definition.
+ */
+export declare function __register(tag: string, setup: HmrSetup): HmrSetup;
+/** Number of tags awaiting a re-mount (for orchestration/tests). */
+export declare function pendingRemountCount(): number;
+/** Drain and re-mount every pending tag. Returns the tags that were remounted. */
+export declare function drainRemounts(): string[];
+/**
+ * Re-mount every live element of `tag` in place, on the SAME instance:
+ *
+ *   disconnectedCallback()  — resets `_mounted`, disposes effects + template
+ *                             (the ADR 0008.1 disposal contract)
+ *   replaceChildren()       — clears old DOM, firing nested custom elements'
+ *                             disconnectedCallback so their disposers run too
+ *   connectedCallback()     — re-runs the NEW setup (via the registry thunk)
+ *                             inside the same `untrack(...)` mount path
+ *
+ * Props survive because `_propsProxy` is constructor-owned (component.ts), and
+ * the element node identity is preserved — siblings, scroll, route, and global
+ * stores are untouched.
+ */
+export declare function remount(tag: string): void;
+/** Test-only: clear the registry and pending state between cases. */
+export declare function __resetRegistry(): void;

package/dist/hmr/registry.js

@@ -0,0 +1,125 @@
+/**
+ * hmr/registry.ts — Transport-agnostic HMR core for Nisli (ADR 0021, ADR 0110).
+ *
+ * The tag→setup registry, the stable indirection thunk, and the in-place
+ * re-mount through the custom-element lifecycle. This is the part that is
+ * IDENTICAL regardless of how change notifications arrive — change
+ * (`../esbuild-hmr/*`) or Vite `import.meta.hot` (`../vite-hmr/*`) both drive
+ * the same registry. Keeping it here means one implementation, one set of
+ * correctness guarantees (ADR 0008.1 disposal), and no duplication.
+ *
+ * DEV-ONLY: reachable only via the dev subpaths, never from the `@nisli/core`
+ * `.` entry, so it contributes zero production bytes.
+ */
+// ── Tag → setup registry (Ruling 2) ─────────────────────────────────
+const registry = new Map();
+/** Tags whose setup changed since the last drain — pending a re-mount. */
+const pendingRemounts = new Set();
+let remountScheduled = false;
+/**
+ * When true, `__register` accumulates pending tags but does NOT auto-schedule a
+ * microtask drain — the caller owns the drain so it can wait for a full module
+ * re-eval to register ALL changed tags first.
+ * The Vite path leaves this false and drains explicitly from its accept hook.
+ */
+let suppressAutoDrain = false;
+/**
+ * Begin a caller-owned drain window: suppress auto-scheduling AND cancel any
+ * pending microtask drain, so the caller can re-evaluate a whole bundle and
+ * register ALL changed tags before a single explicit `drainRemounts()`. Used by
+ * the Vite path drains per-module.
+ */
+export function beginManualDrain() {
+    suppressAutoDrain = true;
+    remountScheduled = false;
+}
+/** End a caller-owned drain window (re-enable auto-scheduling). */
+export function endManualDrain() {
+    suppressAutoDrain = false;
+}
+/**
+ * Register (or update) the setup for a tag and return a STABLE indirection
+ * thunk that always reads the *current* setup from the registry.
+ *
+ * First registration for a tag (initial load) schedules no re-mount. A
+ * subsequent registration with a *different* setup reference (a rebuild
+ * re-evaluating the module) queues the tag for re-mount.
+ *
+ * The returned thunk is what `component()` hands to the real
+ * `FrameworkComponent`; because it reads `registry.get(tag)` lazily, the live
+ * element picks up new setup with no class swap or tag re-definition.
+ */
+export function __register(tag, setup) {
+    const prev = registry.get(tag);
+    registry.set(tag, setup);
+    if (prev !== undefined && prev !== setup) {
+        pendingRemounts.add(tag);
+        if (!suppressAutoDrain)
+            scheduleRemount();
+    }
+    return (props, host) => {
+        const current = registry.get(tag);
+        if (!current)
+            throw new Error(`[nisli-hmr] no setup registered for <${tag}>`);
+        return current(props, host);
+    };
+}
+/** Number of tags awaiting a re-mount (for orchestration/tests). */
+export function pendingRemountCount() {
+    return pendingRemounts.size;
+}
+/** Drain and re-mount every pending tag. Returns the tags that were remounted. */
+export function drainRemounts() {
+    const tags = [...pendingRemounts];
+    pendingRemounts.clear();
+    remountScheduled = false;
+    for (const tag of tags)
+        remount(tag);
+    return tags;
+}
+function scheduleRemount() {
+    if (remountScheduled)
+        return;
+    remountScheduled = true;
+    // Defer so a full module re-eval can register *all* changed tags first.
+    queueMicrotask(() => {
+        if (remountScheduled)
+            drainRemounts();
+    });
+}
+// ── Re-mount through the existing lifecycle (Ruling 3) ──────────────
+/**
+ * Re-mount every live element of `tag` in place, on the SAME instance:
+ *
+ *   disconnectedCallback()  — resets `_mounted`, disposes effects + template
+ *                             (the ADR 0008.1 disposal contract)
+ *   replaceChildren()       — clears old DOM, firing nested custom elements'
+ *                             disconnectedCallback so their disposers run too
+ *   connectedCallback()     — re-runs the NEW setup (via the registry thunk)
+ *                             inside the same `untrack(...)` mount path
+ *
+ * Props survive because `_propsProxy` is constructor-owned (component.ts), and
+ * the element node identity is preserved — siblings, scroll, route, and global
+ * stores are untouched.
+ */
+export function remount(tag) {
+    const elements = document.querySelectorAll(tag);
+    elements.forEach((node) => {
+        const el = node;
+        // Dispose first: must run BEFORE clearing DOM or effects/subscriptions
+        // leak across reloads (ADR 0008.1 hazard).
+        el.disconnectedCallback?.();
+        // Clear old DOM — removal fires nested children's disconnectedCallback.
+        el.replaceChildren();
+        // Re-run setup + re-mount on the same instance.
+        el.connectedCallback?.();
+    });
+}
+/** Test-only: clear the registry and pending state between cases. */
+export function __resetRegistry() {
+    registry.clear();
+    pendingRemounts.clear();
+    remountScheduled = false;
+    suppressAutoDrain = false;
+}
+//# sourceMappingURL=registry.js.map

package/dist/hmr/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/hmr/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAYH,uEAAuE;AAEvE,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAoB,CAAC;AAE7C,0EAA0E;AAC1E,MAAM,eAAe,GAAG,IAAI,GAAG,EAAU,CAAC;AAC1C,IAAI,gBAAgB,GAAG,KAAK,CAAC;AAE7B;;;;;GAKG;AACH,IAAI,iBAAiB,GAAG,KAAK,CAAC;AAE9B;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB;IAC9B,iBAAiB,GAAG,IAAI,CAAC;IACzB,gBAAgB,GAAG,KAAK,CAAC;AAC3B,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU,cAAc;IAC5B,iBAAiB,GAAG,KAAK,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,UAAU,CAAC,GAAW,EAAE,KAAe;IACrD,MAAM,IAAI,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC/B,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACzB,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC;QACzC,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACzB,IAAI,CAAC,iBAAiB;YAAE,eAAe,EAAE,CAAC;IAC5C,CAAC;IACD,OAAO,CAAC,KAAc,EAAE,IAAiB,EAAE,EAAE;QAC3C,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,wCAAwC,GAAG,GAAG,CAAC,CAAC;QAC9E,OAAO,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC9B,CAAC,CAAC;AACJ,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,mBAAmB;IACjC,OAAO,eAAe,CAAC,IAAI,CAAC;AAC9B,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,aAAa;IAC3B,MAAM,IAAI,GAAG,CAAC,GAAG,eAAe,CAAC,CAAC;IAClC,eAAe,CAAC,KAAK,EAAE,CAAC;IACxB,gBAAgB,GAAG,KAAK,CAAC;IACzB,KAAK,MAAM,GAAG,IAAI,IAAI;QAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IACrC,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,eAAe;IACtB,IAAI,gBAAgB;QAAE,OAAO;IAC7B,gBAAgB,GAAG,IAAI,CAAC;IACxB,wEAAwE;IACxE,cAAc,CAAC,GAAG,EAAE;QAClB,IAAI,gBAAgB;YAAE,aAAa,EAAE,CAAC;IACxC,CAAC,CAAC,CAAC;AACL,CAAC;AAED,uEAAuE;AAEvE;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,OAAO,CAAC,GAAW;IACjC,MAAM,QAAQ,GAAG,QAAQ,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;IAChD,QAAQ,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QACxB,MAAM,EAAE,GAAG,IAAyB,CAAC;QACrC,uEAAuE;QACvE,2CAA2C;QAC3C,EAAE,CAAC,oBAAoB,EAAE,EAAE,CAAC;QAC5B,wEAAwE;QACxE,EAAE,CAAC,eAAe,EAAE,CAAC;QACrB,gDAAgD;QAChD,EAAE,CAAC,iBAAiB,EAAE,EAAE,CAAC;IAC3B,CAAC,CAAC,CAAC;AACL,CAAC;AAED,qEAAqE;AACrE,MAAM,UAAU,eAAe;IAC7B,QAAQ,CAAC,KAAK,EAAE,CAAC;IACjB,eAAe,CAAC,KAAK,EAAE,CAAC;IACxB,gBAAgB,GAAG,KAAK,CAAC;IACzB,iBAAiB,GAAG,KAAK,CAAC;AAC5B,CAAC"}

package/dist/hmr/transform.d.ts

@@ -0,0 +1,21 @@
+/**
+ * hmr/transform.ts — Shared source rewrite for Nisli HMR (ADR 0021, ADR 0110).
+ *
+ * Wraps the `component` a module imports from `@nisli/core` with the registry
+ * indirection so a rebuilt module's `component()` calls re-register their setup
+ * and trigger an in-place re-mount. Transport-agnostic and pure — used by both
+ * the Vite `transform` hook.
+ */
+/**
+ * Rewrite a module's source so the `component` it imports from `coreSpecifier`
+ * is wrapped by the registry indirection from `runtimeSpecifier`.
+ *
+ * Strategy: alias the real import, then shadow `component` with a wrapper that
+ * registers the setup and passes a STABLE thunk to the real `component`. Cost:
+ * one Map write + one thunk allocation per `component()` call.
+ *
+ * Returns the original source unchanged if it does not import `component` from
+ * the core specifier (nothing to wrap) — the caller uses identity to decide
+ * whether the module is HMR-relevant.
+ */
+export declare function transformSource(code: string, coreSpecifier: string, runtimeSpecifier: string): string;

package/dist/hmr/transform.js

@@ -0,0 +1,52 @@
+/**
+ * hmr/transform.ts — Shared source rewrite for Nisli HMR (ADR 0021, ADR 0110).
+ *
+ * Wraps the `component` a module imports from `@nisli/core` with the registry
+ * indirection so a rebuilt module's `component()` calls re-register their setup
+ * and trigger an in-place re-mount. Transport-agnostic and pure — used by both
+ * the Vite `transform` hook.
+ */
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Rewrite a module's source so the `component` it imports from `coreSpecifier`
+ * is wrapped by the registry indirection from `runtimeSpecifier`.
+ *
+ * Strategy: alias the real import, then shadow `component` with a wrapper that
+ * registers the setup and passes a STABLE thunk to the real `component`. Cost:
+ * one Map write + one thunk allocation per `component()` call.
+ *
+ * Returns the original source unchanged if it does not import `component` from
+ * the core specifier (nothing to wrap) — the caller uses identity to decide
+ * whether the module is HMR-relevant.
+ */
+export function transformSource(code, coreSpecifier, runtimeSpecifier) {
+    const spec = escapeRegExp(coreSpecifier);
+    // Match a named import of `component` (alone or among others) from core.
+    const importRe = new RegExp(`import\\s*\\{([^}]*)\\}\\s*from\\s*['"]${spec}['"]`, 'g');
+    let importsComponent = false;
+    const rewritten = code.replace(importRe, (_full, names) => {
+        const parts = names.split(',').map((s) => s.trim()).filter(Boolean);
+        const next = parts.map((p) => {
+            // Handle `component` and `component as X` — we only wrap the bare name.
+            if (p === 'component') {
+                importsComponent = true;
+                return 'component as __nisliRealComponent';
+            }
+            return p;
+        });
+        return `import { ${next.join(', ')} } from '${coreSpecifier}'`;
+    });
+    if (!importsComponent)
+        return code;
+    // Prepend the registry-import + wrapper. `__register` returns the STABLE
+    // thunk the real component captures; the wrapper preserves the factory's
+    // return value and signature.
+    const preamble = `import { __register as __nisliRegister } from '${runtimeSpecifier}';\n` +
+        `function component(tag, setup, opts) {\n` +
+        `  return __nisliRealComponent(tag, __nisliRegister(tag, setup), opts);\n` +
+        `}\n`;
+    return preamble + rewritten;
+}
+//# sourceMappingURL=transform.js.map

package/dist/hmr/transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.js","sourceRoot":"","sources":["../../src/hmr/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,SAAS,YAAY,CAAC,CAAS;IAC7B,OAAO,CAAC,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;AAClD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY,EAAE,aAAqB,EAAE,gBAAwB;IAC3F,MAAM,IAAI,GAAG,YAAY,CAAC,aAAa,CAAC,CAAC;IACzC,yEAAyE;IACzE,MAAM,QAAQ,GAAG,IAAI,MAAM,CAAC,0CAA0C,IAAI,MAAM,EAAE,GAAG,CAAC,CAAC;IAEvF,IAAI,gBAAgB,GAAG,KAAK,CAAC;IAC7B,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAa,EAAE,KAAa,EAAE,EAAE;QACxE,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACpE,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YAC3B,wEAAwE;YACxE,IAAI,CAAC,KAAK,WAAW,EAAE,CAAC;gBACtB,gBAAgB,GAAG,IAAI,CAAC;gBACxB,OAAO,mCAAmC,CAAC;YAC7C,CAAC;YACD,OAAO,CAAC,CAAC;QACX,CAAC,CAAC,CAAC;QACH,OAAO,YAAY,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,aAAa,GAAG,CAAC;IACjE,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,gBAAgB;QAAE,OAAO,IAAI,CAAC;IAEnC,yEAAyE;IACzE,yEAAyE;IACzE,8BAA8B;IAC9B,MAAM,QAAQ,GACZ,kDAAkD,gBAAgB,MAAM;QACxE,0CAA0C;QAC1C,0EAA0E;QAC1E,KAAK,CAAC;IAER,OAAO,QAAQ,GAAG,SAAS,CAAC;AAC9B,CAAC"}

package/dist/vite-hmr/plugin.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Minimal structural subset of Vite's `Plugin` we implement. Declared
+ * structurally (not imported from `vite`) so `@nisli/core` keeps its
+ * zero-dependency footprint — `vite` is the consumer's dependency, not ours.
+ */
+export interface NisliVitePlugin {
+    name: string;
+    enforce?: 'pre' | 'post';
+    apply?: 'serve' | 'build';
+    transform(code: string, id: string): {
+        code: string;
+        map: null;
+    } | undefined;
+}
+export interface NisliViteHmrOptions {
+    /** The specifier modules import `component` from. Default `@nisli/core`. */
+    coreSpecifier?: string;
+    /** The runtime subpath providing `__register`/`__drain`. Default `@nisli/core/vite-hmr/runtime`. */
+    runtimeSpecifier?: string;
+    /** Which module ids to transform. Default: TS/JS sources. */
+    filter?: RegExp;
+}
+/**
+ * Create the dev-only Nisli Vite HMR plugin. Add it to `plugins` in
+ * `vite.config.ts`; `apply: 'serve'` keeps it off the production build path.
+ */
+export declare function nisliHmr(options?: NisliViteHmrOptions): NisliVitePlugin;

package/dist/vite-hmr/plugin.js

@@ -0,0 +1,62 @@
+/**
+ * vite-hmr/plugin.ts — Dev-only Vite plugin for Nisli HMR (ADR 0110).
+ *
+ * Vite plugin that wraps component() calls (shared `transformSource`),
+ * but drives re-mount through Vite's native `import.meta.hot` instead of an SSE
+ * hub + whole-bundle re-import. For each source module that imports `component`
+ * from `@nisli/core`, it:
+ *   1. wraps `component(tag, setup)` → `component(tag, __register(tag, setup))`
+ *      so a re-evaluated module swaps its setup in the shared registry, and
+ *   2. appends `import.meta.hot.accept(() => __drain())` so Vite replaces JUST
+ *      this module (granular HMR) and the queued re-mounts are applied.
+ *
+ * Because Vite re-evaluates only the changed module against a STABLE framework
+ * module, there is exactly one `@nisli/core` instance — the dual-instance
+ * "split-brain" of whole-bundle re-import cannot occur.
+ *
+ * `apply: 'serve'` makes this dev-only: the production `vite build` never runs
+ * the transform, so no wrapper, no registry import, and no `import.meta.hot`
+ * reach the prod bundle (zero prod HMR bytes).
+ */
+import { transformSource } from '../hmr/transform.js';
+const DEFAULT_FILTER = /\.[mc]?[jt]sx?$/;
+/**
+ * Create the dev-only Nisli Vite HMR plugin. Add it to `plugins` in
+ * `vite.config.ts`; `apply: 'serve'` keeps it off the production build path.
+ */
+export function nisliHmr(options = {}) {
+    const coreSpecifier = options.coreSpecifier ?? '@nisli/core';
+    const runtimeSpecifier = options.runtimeSpecifier ?? '@nisli/core/vite-hmr/runtime';
+    const filter = options.filter ?? DEFAULT_FILTER;
+    return {
+        name: 'nisli-vite-hmr',
+        // Run on the raw TS source before Vite's own transforms rewrite imports.
+        enforce: 'pre',
+        // Dev server only — never transform the production build.
+        apply: 'serve',
+        transform(code, id) {
+            const clean = id.split('?')[0] ?? id;
+            if (clean.includes('node_modules'))
+                return undefined;
+            if (!filter.test(clean))
+                return undefined;
+            const wrapped = transformSource(code, coreSpecifier, runtimeSpecifier);
+            // Identity ⇒ the module does not import `component` — not HMR-relevant.
+            // Leaving it un-accepted lets Vite propagate to a full reload (correct for
+            // services/utils edits).
+            if (wrapped === code)
+                return undefined;
+            const out = `import { __drain as __nisliViteDrain } from ${JSON.stringify(runtimeSpecifier)};\n` +
+                wrapped +
+                `\nif (import.meta.hot) {\n` +
+                `  import.meta.hot.accept(() => { __nisliViteDrain(); });\n` +
+                `}\n`;
+            // map: null — the injection is an additive prepend/append on a handful of
+            // component modules in DEV only; a precise map would require a sourcemap
+            // dependency (magic-string), which `@nisli/core` deliberately avoids to
+            // stay zero-dependency. Original statements keep their column offsets.
+            return { code: out, map: null };
+        },
+    };
+}
+//# sourceMappingURL=plugin.js.map

package/dist/vite-hmr/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/vite-hmr/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAuBtD,MAAM,cAAc,GAAG,iBAAiB,CAAC;AAEzC;;;GAGG;AACH,MAAM,UAAU,QAAQ,CAAC,UAA+B,EAAE;IACxD,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,aAAa,CAAC;IAC7D,MAAM,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,IAAI,8BAA8B,CAAC;IACpF,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,cAAc,CAAC;IAEhD,OAAO;QACL,IAAI,EAAE,gBAAgB;QACtB,yEAAyE;QACzE,OAAO,EAAE,KAAK;QACd,0DAA0D;QAC1D,KAAK,EAAE,OAAO;QACd,SAAS,CAAC,IAAY,EAAE,EAAU;YAChC,MAAM,KAAK,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YACrC,IAAI,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC;gBAAE,OAAO,SAAS,CAAC;YACrD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;gBAAE,OAAO,SAAS,CAAC;YAE1C,MAAM,OAAO,GAAG,eAAe,CAAC,IAAI,EAAE,aAAa,EAAE,gBAAgB,CAAC,CAAC;YACvE,wEAAwE;YACxE,2EAA2E;YAC3E,yBAAyB;YACzB,IAAI,OAAO,KAAK,IAAI;gBAAE,OAAO,SAAS,CAAC;YAEvC,MAAM,GAAG,GACP,+CAA+C,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,KAAK;gBACpF,OAAO;gBACP,4BAA4B;gBAC5B,4DAA4D;gBAC5D,KAAK,CAAC;YAER,0EAA0E;YAC1E,yEAAyE;YACzE,wEAAwE;YACxE,uEAAuE;YACvE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC;QAClC,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/vite-hmr/runtime.d.ts

@@ -0,0 +1,16 @@
+/**
+ * vite-hmr/runtime.ts — Browser runtime for Nisli HMR under Vite (ADR 0110).
+ *
+ * DEV-ONLY. The Vite plugin (`./plugin.ts`) injects calls to these into each
+ * component module:
+ *  - `__register(tag, setup)` wraps `component()` so a re-evaluated module swaps
+ *    its setup in the shared registry and queues an in-place re-mount.
+ *  - `__drain()` is called from the module's `import.meta.hot.accept` hook to
+ *    apply the queued re-mounts.
+ *
+ * Vite re-evaluates ONLY the changed module against a
+ * STABLE framework module — so there is exactly one `@nisli/core` instance and
+ * no lifecycle/reactive split-brain. This module just re-exports the
+ * transport-agnostic registry core.
+ */
+export { __register, drainRemounts as __drain, pendingRemountCount, remount } from '../hmr/registry.js';

package/dist/vite-hmr/runtime.js

@@ -0,0 +1,17 @@
+/**
+ * vite-hmr/runtime.ts — Browser runtime for Nisli HMR under Vite (ADR 0110).
+ *
+ * DEV-ONLY. The Vite plugin (`./plugin.ts`) injects calls to these into each
+ * component module:
+ *  - `__register(tag, setup)` wraps `component()` so a re-evaluated module swaps
+ *    its setup in the shared registry and queues an in-place re-mount.
+ *  - `__drain()` is called from the module's `import.meta.hot.accept` hook to
+ *    apply the queued re-mounts.
+ *
+ * Vite re-evaluates ONLY the changed module against a
+ * STABLE framework module — so there is exactly one `@nisli/core` instance and
+ * no lifecycle/reactive split-brain. This module just re-exports the
+ * transport-agnostic registry core.
+ */
+export { __register, drainRemounts as __drain, pendingRemountCount, remount } from '../hmr/registry.js';
+//# sourceMappingURL=runtime.js.map

package/dist/vite-hmr/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../src/vite-hmr/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,UAAU,EAAE,aAAa,IAAI,OAAO,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nisli/core",
-  "version": "0.49.2",
+  "version": "0.51.0",
   "description": "A reactive web component framework. Signals, templates, dependency injection — no build step, no virtual DOM, no dependencies.",
   "type": "module",
   "license": "MIT",
@@ -22,30 +22,17 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
-    "./esbuild-hmr": {
-      "types": "./dist/esbuild-hmr/plugin.d.ts",
-      "default": "./dist/esbuild-hmr/plugin.js"
+    "./vite-hmr": {
+      "types": "./dist/vite-hmr/plugin.d.ts",
+      "default": "./dist/vite-hmr/plugin.js"
     },
-    "./esbuild-hmr/runtime": {
-      "types": "./dist/esbuild-hmr/runtime.d.ts",
-      "default": "./dist/esbuild-hmr/runtime.js"
-    },
-    "./esbuild-hmr/server": {
-      "types": "./dist/esbuild-hmr/server.d.ts",
-      "default": "./dist/esbuild-hmr/server.js"
-    }
-  },
-  "peerDependencies": {
-    "esbuild": "*"
-  },
-  "peerDependenciesMeta": {
-    "esbuild": {
-      "optional": true
+    "./vite-hmr/runtime": {
+      "types": "./dist/vite-hmr/runtime.d.ts",
+      "default": "./dist/vite-hmr/runtime.js"
     }
   },
   "devDependencies": {
-    "@types/node": "^22.0.0",
-    "esbuild": "^0.28.1"
+    "@types/node": "^22.0.0"
   },
   "files": [
     "dist",

package/dist/esbuild-hmr/plugin.d.ts

@@ -1,161 +0,0 @@
-/**
- * esbuild-hmr/plugin.ts — Dev-only esbuild plugin for Nisli component HMR.
- *
- * DEV-ONLY, build-time (Node). Reachable only via `@nisli/core/esbuild-hmr`,
- * never from the runtime `.` entry (ADR 0021, Ruling 1). It is added to the
- * esbuild plugin list ONLY on the `--watch` path; `pnpm build` (no watch) never
- * sees it, so prod is byte-identical by construction (Ruling 5).
- *
- * `esbuild` is an OPTIONAL peerDependency. To keep `@nisli/core` dependency-free
- * we do NOT `import` esbuild here — we type the plugin against a minimal local
- * structural surface. The host build script supplies the real esbuild.
- *
- * What it does:
- *  1. onLoad (Ruling 2): for author modules that import `component` from
- *     `@nisli/core`, rewrite the import so `component(tag, setup, opts)` routes
- *     `setup` through the runtime tag-keyed registry's STABLE indirection thunk.
- *     The real `FrameworkComponent` thus captures a thunk that always reads the
- *     current setup — no class swap, no tag re-definition.
- *  2. onEnd (Ruling 4 transport): diff the metafile outputs against the previous
- *     build and broadcast a `change` payload ({added, removed, updated}) over
- *     SSE so the browser client can escalate (css/js/reload).
- *  3. Inject the browser dev client (`@nisli/core/esbuild-hmr/runtime` +
- *     `connect({ path })`) via esbuild's `inject` option pointed at a VIRTUAL
- *     shim module, so the runtime is RESOLVED + BUNDLED into the output (no
- *     author HTML/JS change needed). We deliberately do NOT use `banner`: a
- *     banner is raw passthrough text that esbuild neither resolves nor bundles,
- *     so a bare `import … from "@nisli/core/esbuild-hmr/runtime"` would leak
- *     verbatim into the output and the browser would throw
- *     `Failed to resolve module specifier` (no import map). `inject` runs the
- *     shim through onResolve/onLoad so the runtime is inlined at build time, and
- *     esbuild applies `inject` ONLY to JS modules — never to file/copy-loaded
- *     entries (e.g. the viewer's `logo.svg`). Verified empirically against
- *     esbuild 0.28.1.
- */
-import type { ChangeBroadcaster } from './server.js';
-/** A subset of esbuild's `OnLoadArgs` we rely on. */
-interface OnLoadArgs {
-    path: string;
-}
-/** A subset of esbuild's `OnLoadResult`. */
-interface OnLoadResult {
-    contents: string;
-    loader?: 'ts' | 'tsx' | 'js' | 'jsx';
-    /** Directory used to resolve imports from a virtual module (the client shim). */
-    resolveDir?: string;
-}
-/** A subset of esbuild's `OnResolveArgs`. */
-interface OnResolveArgs {
-    path: string;
-}
-/** A subset of esbuild's `OnResolveResult`. */
-interface OnResolveResult {
-    path: string;
-    namespace?: string;
-}
-/** A subset of esbuild's metafile. */
-interface Metafile {
-    outputs: Record<string, {
-        bytes: number;
-        hash?: string;
-    }>;
-}
-/** A subset of esbuild's `BuildResult`. */
-interface BuildResult {
-    metafile?: Metafile;
-}
-/** The hooks surface of esbuild's `PluginBuild` we use. */
-interface PluginBuild {
-    initialOptions: {
-        banner?: {
-            js?: string;
-        } & Record<string, string | undefined>;
-        /** Files esbuild injects into every JS module (never file/copy entries). */
-        inject?: string[];
-        /** esbuild's working directory; anchors virtual-module resolution. */
-        absWorkingDir?: string;
-        [key: string]: unknown;
-    };
-    onResolve(options: {
-        filter: RegExp;
-        namespace?: string;
-    }, callback: (args: OnResolveArgs) => OnResolveResult | undefined): void;
-    onLoad(options: {
-        filter: RegExp;
-        namespace?: string;
-    }, callback: (args: OnLoadArgs) => OnLoadResult | undefined): void;
-    onEnd(callback: (result: BuildResult) => void): void;
-}
-/** esbuild's `Plugin` shape (structural). */
-export interface EsbuildPlugin {
-    name: string;
-    setup(build: PluginBuild): void;
-}
-export interface NisliHmrPluginOptions {
-    /**
-     * Broadcaster used to push `change` events to connected clients. Supply the
-     * one returned by `createHmrServer()` (server.ts), or any object with a
-     * `broadcast(payload)` method (e.g. an esbuild `serve` adapter).
-     */
-    broadcaster: ChangeBroadcaster;
-    /**
-     * The module specifier author code imports `component` from.
-     * Defaults to `@nisli/core`.
-     */
-    coreSpecifier?: string;
-    /**
-     * The specifier of the browser dev runtime, inlined into the bundle via the
-     * injected client shim. Defaults to `@nisli/core/esbuild-hmr/runtime`.
-     */
-    runtimeSpecifier?: string;
-    /**
-     * The SSE endpoint the browser dev client connects to. Baked into the injected
-     * shim as `connect({ path: clientUrl })`. Defaults to `/esbuild` (esbuild's
-     * client convention, same-origin).
-     *
-     * Set this to an ABSOLUTE URL when the SSE hub (server.ts) runs on a different
-     * origin than the page server — e.g. `http://localhost:3031/esbuild` when the
-     * hub listens on :3031 and the page is served by Hono on :3040. The hub already
-     * sends `Access-Control-Allow-Origin: '*'`, so cross-origin SSE works.
-     */
-    clientUrl?: string;
-    /** Files to transform. Defaults to TS/JS sources (excludes node_modules). */
-    filter?: RegExp;
-}
-/**
- * Rewrite a module's source so the `component` it imports from `@nisli/core` is
- * wrapped by the registry indirection. Pure function — exported for testing.
- *
- * Strategy: alias the real import, then shadow `component` with a wrapper that
- * registers the setup and passes a STABLE thunk to the real `component`. The
- * wrapper is a no-op-shaped passthrough at runtime cost of one Map write +
- * one thunk allocation per `component()` call.
- *
- * Returns the original source unchanged if it does not import `component` from
- * the core specifier (nothing to wrap).
- */
-export declare function transformSource(code: string, coreSpecifier: string, runtimeSpecifier: string): string;
-/**
- * Source of the virtual client shim that esbuild's `inject` pulls into every JS
- * module. Because it is `inject`ed (not a `banner`), esbuild RESOLVES the
- * `runtimeSpecifier` import and BUNDLES `connect` inline — no bare specifier
- * survives in the output (the 0.49.0 bug). `clientUrl` is baked in so the
- * client targets the right SSE origin. Pure function — exported for testing.
- */
-export declare function clientShimSource(runtimeSpecifier: string, clientUrl: string): string;
-/**
- * Create the dev-only Nisli HMR esbuild plugin. Add it to `plugins` ONLY when
- * building with `--watch`; never on the prod build path.
- */
-export declare function nisliHmrPlugin(options: NisliHmrPluginOptions): EsbuildPlugin;
-/**
- * Diff two output-hash maps into an esbuild-shaped change payload.
- * Returns `null` for the very first build (no previous baseline).
- * Exported for testing.
- */
-export declare function diffOutputs(prev: Map<string, string> | null, next: Map<string, string>): {
-    added: string[];
-    removed: string[];
-    updated: string[];
-} | null;
-export {};