@nomix-ai/nomix-harness 0.2.4 → 0.2.6

package/dist/kernel/client-web/lib/types/boot-page.js

@@ -0,0 +1,93 @@
+import css from './boot-page.module.css';
+/** Create a div with one module class and optional text. */
+function div(className, text) {
+    const el = document.createElement('div');
+    el.className = className ?? '';
+    if (text !== undefined)
+        el.textContent = text;
+    return el;
+}
+/** Kernel-owned page mounted below the application's root element. */
+export class BootPage {
+    root;
+    card;
+    wordmark;
+    spinner;
+    hint;
+    states = new Map();
+    active = new Set();
+    total = 0;
+    failure;
+    /**
+     * Build and attach the boot page.
+     * @param container - Application mount point.
+     */
+    constructor(container) {
+        this.root = div(css.boot);
+        this.root.dataset.nomixBoot = '';
+        this.card = div(css.card);
+        this.wordmark = div(css.wordmark, 'HARNESS');
+        this.spinner = div(css.spinner);
+        this.spinner.dataset.nomixBootSpinner = '';
+        this.hint = div(css.hint, 'Loading plugins…');
+        this.card.append(this.wordmark, this.spinner, this.hint);
+        this.root.append(this.card);
+        container.append(this.root);
+        this.updateProgress();
+    }
+    /**
+     * Set the number of loader entries represented by the progress arc.
+     * @param total - Complete boot roster size.
+     */
+    setTotal(total) {
+        this.total = total;
+        this.updateProgress();
+    }
+    /**
+     * Project one loader entry's fiber state.
+     * @param id - Loader entry name.
+     * @param state - Projected fiber state.
+     */
+    setState(id, state) {
+        this.states.set(id, state);
+        if (state === 'active')
+            this.active.add(id);
+        this.updateProgress();
+        this.render();
+    }
+    /**
+     * Display the boot failure report.
+     * @param message - Failure report text.
+     */
+    fail(message) {
+        this.failure = message;
+        this.render();
+    }
+    /** Detach the page before or after the UI renderer takes the mount point. */
+    dispose() {
+        this.root.remove();
+    }
+    /** Redraw the state-dependent content below the wordmark. */
+    render() {
+        const failed = [...this.states].filter(([, state]) => state === 'failed').map(([id]) => id);
+        if (this.failure === undefined && failed.length === 0) {
+            if (this.spinner.parentElement !== this.card) {
+                this.card.replaceChildren(this.wordmark, this.spinner, this.hint);
+            }
+            return;
+        }
+        const report = div(css.failed);
+        report.append(div(css.failedTitle, 'Failed to load plugins'));
+        for (const id of failed)
+            report.append(div(css.failedItem, id));
+        if (this.failure !== undefined)
+            report.append(div(css.failedItem, this.failure));
+        this.card.replaceChildren(this.wordmark, report);
+    }
+    /** Grow the rotating arc monotonically as loader entries activate. */
+    updateProgress() {
+        const ratio = this.total === 0 ? 0 : Math.min(this.active.size / this.total, 1);
+        this.spinner.style.setProperty('--nomix-boot-arc', `${String(Math.round(72 + ratio * 216))}deg`);
+    }
+}
+//# sourceMappingURL=boot-page.js.map

package/dist/kernel/client-web/lib/types/boot.d.ts

@@ -1,49 +1,36 @@
-import { type ClientModuleSystemOptions } from '../../../client-modules/lib/client.js';
+import type { ClientModuleCreateOptions } from '../../../client-modules/lib/client.js';
 import './base.css';
-/** Module transport hook the shell passes through (jsdom tests replace the <script> path). */
-export type BootSeams = Pick<ClientModuleSystemOptions, 'loadBundle'>;
-/**
- * The web shell kernel: mounts the loading page into a DOM element and runs
- * the two-stage boot over the host graph. Fields hold only what must exist
- * before cordis does — the parsed manifest, the module system, and the
- * loading-page UI handles; everything else lives in plugins.
- */
+/** Module transport hook replaced by jsdom tests. */
+export type BootSeams = Pick<ClientModuleCreateOptions, 'loadBundle'>;
+/** Browser boot entry consumed by `apps/web`. */
 export declare class AppWebEntry {
-    private readonly el;
+    private readonly container;
     private readonly seams;
-    private readonly status;
-    private readonly settled;
-    private readonly error;
+    private readonly page;
     private ctx;
     private modules;
     private manifest;
-    private root;
     /**
-     * Hold the mount point; all work happens in {@link run}.
-     * @param el - mount point (the app's #root).
-     * @param seams - Optional module transport overrides for test environments.
+     * Draw the boot page; {@link run} starts the loader.
+     * @param container - Application mount point.
+     * @param seams - Optional module transport replacement.
      */
-    constructor(el: HTMLElement, seams?: BootSeams);
+    constructor(container: HTMLElement, seams?: BootSeams);
     /**
-     * Run the boot chain to settlement. Boot-chain failures resolve (not
-     * reject): the loading page stays up and renders the failure report (the
-     * fail-loud surface the kernel owns). Rejects only when the boot manifest
-     * is missing or malformed — there is nothing to boot against.
-     * @returns resolves once the UI settled or the failure report rendered.
+     * Load and activate every client entry, then hand the mount point to the
+     * UI renderer. Plugin failures remain visible on the boot page.
+     * @returns Resolves after application mount or failure rendering.
      */
     run(): Promise<void>;
-    /** Unmount the shell (loading page or settled UI). */
-    dispose(): void;
-    /** Prefetch the immediately tier (factory registration only; failures defer to the import path). */
+    /** Dispose the client plugin tree and whichever page owns the mount point. */
+    dispose(): Promise<void>;
+    /** Mount through a dependency fiber so replacing uiRenderer remounts the application. */
+    private mountApp;
+    /** Prefetch stage-one bundles; their import path owns any eventual failure. */
     private prefetchImmediateTier;
-    /** Plugin face: mount the Loader, inject the `internal` contract, adopt modules, create the graph entries, settle, sweep. */
+    /** Mount the Loader, create all graph entries, await quiescence, and audit activation. */
     private runPluginBoot;
-    /**
-     * Sweep every loader entry after the tree quiesced: an entry without a
-     * fiber failed its import; a fiber not ACTIVE is FAILED (apply threw) or
-     * PENDING (a required service never arrived — cordis inject waiting has no
-     * timeout, so this sweep is the fail-loud compensation).
-     */
+    /** Reject entries that failed import/apply or still wait on missing services. */
     private assertEntriesActive;
 }
 //# sourceMappingURL=boot.d.ts.map

package/dist/kernel/client-web/lib/types/boot.js

@@ -1,196 +1,123 @@
-import { jsx as _jsx } from "react/jsx-runtime";
 /**
- * Web shell boot kernel — the face consumed by the apps/web entry. Everything
- * here is machinery that cannot itself be a loader entry, and none of it
- * value-imports a plugin package (shell self-sufficiency rule: the
- * loading page must work while — especially when — plugins fail). The one
- * sanctioned exception is the modules package (bootstrap
- * identity): the module system cannot arrive through itself, so its class
- * and its client-half wrapper are shell-bundled and the kernel adopts its
- * plugin entry once cordis is up.
- *
- * AppWebEntry.run(), module face first, then plugin face: parse
- * `window.__NOMIX_BOOT__` into the two-view BootManifest (wire boundary)
- * → build the module system over the module-view rows → render the loading
- * page → prefetch every `immediately` row in parallel with mounting the
- * vendored cordis Loader (`internal` contract injection BEFORE any entry exists —
- * the bare-import fallback in tree.import must never run in a browser) →
- * await the prefetch tier, THEN adopt the modules entry and create one
- * loader entry per plugin-view row plus the shell-own app-shell assembly
- * entry → loader.await() + a full fiber sweep (all ACTIVE, else fail
- * listing who/what/which service) → flip the settled signal so AppRoot
- * switches to the real UI in one pass.
- *
- * Entry creation waits for the whole immediately tier: materialization runs
- * synchronous cross-package require edges (e.g. locale → runtime/client) that
- * fiber inject waiting cannot protect — a bundle's factory must be
- * registered before any dependent entry materializes. Per-row prefetch
- * failures still resolve silently (the create-side import reloads and
- * owns the loud failure), so the barrier never turns one bad bundle into a
- * boot-wide fail-fast.
- *
- * Composition lives in the host graph; the shell makes zero composition
- * decisions (the app-shell assembly is itself a graph entry, the only
- * shell-own module registered with the module system).
+ * Web boot kernel. It owns only the module system, Cordis loader, and a
+ * framework-free boot page. The dynamic UI renderer receives the mount
+ * point after every client entry activates.
+ * @module @nomix-ai/nomix-client-web/src/boot
  */
-import { Context } from '@nomix-ai/cordis';
-import Loader from '@nomix-ai/cordis-plugin-loader';
-import { createRoot } from 'react-dom/client';
-import * as ModulesClient from '../../../client-modules/lib/client.js';
-import { ClientModuleSystem, parseBootManifest, } from '../../../client-modules/lib/client.js';
-import * as AppShell from "./app-shell.js";
-import { APP_SHELL_ID } from "./app-shell.js";
-import { AppRoot } from "./AppRoot.js";
+import { Context } from '../../../cordis/lib/index.js';
+import Loader from '../../../cordis-plugin-loader/lib/index.js';
+import { BootPage } from "./boot-page.js";
 import { getStaticModules } from "./seed.js";
-import { STATE_LABELS, createLoaderStatusStore, createSignal } from "./loader-status.js";
+import { STATE_LABELS } from "./loader-status.js";
 import './base.css';
-/**
- * The modules package's own graph row id. The kernel adopts that entry
- * itself (its wrapper is statically registered — shell-bundled code, never
- * fetched), so the plugin-row loop must skip it: the vendored Group.create
- * does not deduplicate by name, and a second fiber would provide 'modules'
- * twice.
- */
-const MODULES_ID = '@nomix-ai/nomix-client-modules';
-/**
- * The web shell kernel: mounts the loading page into a DOM element and runs
- * the two-stage boot over the host graph. Fields hold only what must exist
- * before cordis does — the parsed manifest, the module system, and the
- * loading-page UI handles; everything else lives in plugins.
- */
+/** Browser boot entry consumed by `apps/web`. */
 export class AppWebEntry {
-    el;
+    container;
     seams;
-    status = createLoaderStatusStore();
-    settled = createSignal(false);
-    error = createSignal(undefined);
-    // Assigned by run() before any private method or settled-gated closure reads them.
+    page;
     ctx;
     modules;
     manifest;
-    root;
     /**
-     * Hold the mount point; all work happens in {@link run}.
-     * @param el - mount point (the app's #root).
-     * @param seams - Optional module transport overrides for test environments.
+     * Draw the boot page; {@link run} starts the loader.
+     * @param container - Application mount point.
+     * @param seams - Optional module transport replacement.
      */
-    constructor(el, seams) {
-        this.el = el;
+    constructor(container, seams) {
+        this.container = container;
         this.seams = seams;
+        this.page = new BootPage(container);
     }
     /**
-     * Run the boot chain to settlement. Boot-chain failures resolve (not
-     * reject): the loading page stays up and renders the failure report (the
-     * fail-loud surface the kernel owns). Rejects only when the boot manifest
-     * is missing or malformed — there is nothing to boot against.
-     * @returns resolves once the UI settled or the failure report rendered.
+     * Load and activate every client entry, then hand the mount point to the
+     * UI renderer. Plugin failures remain visible on the boot page.
+     * @returns Resolves after application mount or failure rendering.
      */
     async run() {
-        this.manifest = parseBootManifest(globalThis.__NOMIX_BOOT__);
-        this.modules = new ClientModuleSystem({
-            modules: this.manifest.modules, staticModules: getStaticModules(), ...this.seams,
-        });
-        // The app-shell assembly is the only shell-own module: every other graph
-        // row is a plugin bundle arriving through fetch.
-        this.modules.registerStatic(APP_SHELL_ID, AppShell);
-        // Adoption handoff, supply side: register the modules
-        // package's own client half under its bare package name (= graph row id
-        // = entry name — a suffixed key would miss the statics branch and
-        // trigger a real fetch), and put the instance on the kernel slot the
-        // wrapper's apply reads to provide ctx.modules.
-        this.modules.registerStatic(MODULES_ID, ModulesClient);
-        globalThis.__NOMIX_MODULES__ = this.modules;
-        this.root = createRoot(this.el);
-        this.root.render(_jsx(AppRoot, { settled: this.settled, status: this.status, error: this.error, renderApp: () => {
-                const shell = this.ctx.get('appShell');
-                // Unreachable after a clean settle (the app-shell entry is in every graph).
-                if (shell === undefined)
-                    throw new Error('web boot: appShell service missing after settled');
-                return shell.renderApp();
-            } }));
-        // The immediately tier prefetches in parallel with Loader mounting;
-        // runPluginBoot awaits it before creating entries (see module comment:
-        // cross-package synchronous require edges need every immediately-tier
-        // factory registered before any materialization).
-        const prefetching = this.prefetchImmediateTier();
-        this.ctx = new Context();
         try {
-            await this.runPluginBoot(prefetching);
-            this.settled.set(true);
+            const win = globalThis;
+            const moduleLoader = win.__ModuleLoader__;
+            if (moduleLoader === undefined) {
+                throw new Error('web boot: window.__ModuleLoader__ bootstrap facade is missing');
+            }
+            // A pre-injected transport (the worker preview page) owns bundle bytes;
+            // its loadBundle is the default and explicit seams still win. The global
+            // is `ClientTransportHooks`, owned by @nomix-ai/nomix-client-connection;
+            // this structural slice reads one optional member without adding a
+            // package edge.
+            const transport = globalThis.__NOMIX_TRANSPORT__;
+            this.modules = moduleLoader.create({
+                boot: win.__NOMIX_BOOT__,
+                staticModules: getStaticModules(),
+                ...transport?.loadBundle === undefined ? {} : { loadBundle: transport.loadBundle },
+                ...this.seams,
+            });
+            this.manifest = this.modules.manifest;
+            const prefetching = this.prefetchImmediateTier();
+            const ctx = new Context();
+            this.ctx = ctx;
+            await this.runPluginBoot(ctx, prefetching);
+            await this.mountApp(ctx);
         }
         catch (reason) {
-            // Stay on the loading page; surface the sweep report (fail loud).
             console.error(reason);
-            this.error.set(reason instanceof Error ? reason.message : String(reason));
+            this.page.fail(reason instanceof Error ? reason.message : String(reason));
         }
     }
-    /** Unmount the shell (loading page or settled UI). */
-    dispose() {
-        this.root?.unmount();
+    /** Dispose the client plugin tree and whichever page owns the mount point. */
+    async dispose() {
+        const ctx = this.ctx;
+        this.ctx = undefined;
+        if (ctx !== undefined)
+            await ctx.fiber.dispose();
+        this.page.dispose();
+    }
+    /** Mount through a dependency fiber so replacing uiRenderer remounts the application. */
+    async mountApp(ctx) {
+        const mounted = ctx.inject(['uiRenderer'], (scope) => {
+            scope.effect(() => scope.uiRenderer.mount(this.container), 'web boot: application mount');
+        });
+        await mounted;
     }
-    /** Prefetch the immediately tier (factory registration only; failures defer to the import path). */
+    /** Prefetch stage-one bundles; their import path owns any eventual failure. */
     async prefetchImmediateTier() {
+        // A transport carrying loadBundle owns the bundle bytes; HTTP prefetch
+        // against its static deployment answers nothing. A transport without
+        // loadBundle leaves bundles on HTTP, prefetch included.
+        const transport = globalThis.__NOMIX_TRANSPORT__;
+        if (transport?.loadBundle !== undefined)
+            return;
         await Promise.all(this.manifest.plugins
             .filter(row => row.immediately)
-            .map(row => this.modules.prefetch(row.id).catch(() => {
-            // Import reloads and reports this loudly per entry; swallowing
-            // here keeps one failing prefetch from masking the others.
+            .map(row => this.modules.prefetch(row.id).catch((_prefetchError) => {
+            // Prefetch only starts transport early; the Loader import retries and reports this bundle failure.
         })));
     }
-    /** Plugin face: mount the Loader, inject the `internal` contract, adopt modules, create the graph entries, settle, sweep. */
-    async runPluginBoot(prefetching) {
-        const ctx = this.ctx;
+    /** Mount the Loader, create all graph entries, await quiescence, and audit activation. */
+    async runPluginBoot(ctx, prefetching) {
         await ctx.plugin(Loader);
         const loader = ctx.loader;
-        // Inject the module system BEFORE any entry exists: tree.import falls back
-        // to a bare dynamic import when internal is undefined, which in a browser
-        // is a guaranteed loud failure — correct as a tripwire, never as a path.
         loader.internal = this.modules;
-        // Status projection: AppRoot displays fiber truth. Every internal/status
-        // transition under an entry re-projects that entry's row from its ROOT
-        // fiber (child plugin fibers share the same entry).
         ctx.on('internal/status', (fiber) => {
             const entry = fiber.entry;
             if (entry === undefined || entry.fiber === undefined)
                 return;
-            this.status.set(entry.options.name, STATE_LABELS[entry.fiber.state]);
+            this.page.setState(entry.options.name, STATE_LABELS[entry.fiber.state]);
         });
-        // Barrier before any entry exists: entry creation materializes bundles,
-        // and materialization runs synchronous cross-package require edges that
-        // need every immediately-tier factory already registered (module
-        // comment). Resolves even when individual prefetches failed.
+        const rows = this.manifest.plugins.map(row => row.id);
+        this.page.setTotal(rows.length);
         await prefetching;
-        // Adoption handoff, plugin side: the modules entry is created first —
-        // its wrapper apply reads the kernel slot and provides ctx.modules (the
-        // provide lives on the plugin face; see MODULES_ID for why the row loop
-        // must then skip it).
-        const rows = [MODULES_ID, ...this.manifest.plugins.map(row => row.id).filter(id => id !== MODULES_ID), APP_SHELL_ID];
-        // Entry creation order carries no semantics (fiber inject waiting owns
-        // activation order); creating concurrently lets non-prefetched bundle
-        // loads parallelize. The app-shell assembly entry is appended by the
-        // kernel: it is shell-own code (host graph rows are all plugin bundles),
-        // and mounting the assembly is not a composition decision — it rides the
-        // same entry lifecycle so the sweep and status cover it uniformly.
         await Promise.all(rows.map(async (name) => {
-            this.status.set(name, 'loading');
+            this.page.setState(name, 'loading');
             const id = await loader.create({ name });
-            // A failed import leaves the entry fiberless (Entry._init logs and
-            // returns); project it as failed — no fiber means no status event.
-            if (loader.resolve(id).fiber === undefined) {
-                this.status.set(name, 'failed');
-            }
+            if (loader.resolve(id).fiber === undefined)
+                this.page.setState(name, 'failed');
         }));
         await loader.await();
-        this.assertEntriesActive();
+        this.assertEntriesActive(ctx);
     }
-    /**
-     * Sweep every loader entry after the tree quiesced: an entry without a
-     * fiber failed its import; a fiber not ACTIVE is FAILED (apply threw) or
-     * PENDING (a required service never arrived — cordis inject waiting has no
-     * timeout, so this sweep is the fail-loud compensation).
-     */
-    assertEntriesActive() {
-        const ctx = this.ctx;
+    /** Reject entries that failed import/apply or still wait on missing services. */
+    assertEntriesActive(ctx) {
         const failures = [];
         for (const entry of ctx.loader.entries()) {
             const name = entry.options.name;

package/dist/kernel/client-web/lib/types/index.d.ts

@@ -1,17 +1,11 @@
 /**
  * Web shell library entry. The shell's product is {@link AppWebEntry} —
- * apps/web's vite entry runs it against #root; everything else (AppRoot
- * gate, app-shell assembly entry, module-table staticModules, platform constants) is
- * internal to the boot chain. PLATFORM_MODULES is re-exported as the
- * single source of truth for the tsdown client externals projection.
+ * apps/web's Vite entry runs it against #root. The boot page and fiber-state
+ * projection remain internal; the static module table and its platform words
+ * form the package's build-time contract.
  * @module @nomix-ai/nomix-client-web
  */
-export { AppWebEntry, type BootSeams } from './boot.tsx';
-export { AppRoot, type AppRootProps } from './AppRoot.tsx';
-export { buildRenderApp, type AssemblyDeps } from './app.tsx';
-export { DocumentTitle, type DocumentTitleProps } from './DocumentTitle.tsx';
-export { APP_SHELL_ID, type AppShellService } from './app-shell.ts';
+export { AppWebEntry, type BootSeams } from './boot.ts';
 export { getStaticModules } from './seed.ts';
-export { PLATFORM_MODULES, type PlatformModule } from './platform.ts';
-export { STATE_LABELS, FIBER_STATE, createSignal, createLoaderStatusStore, type LoaderStatus, type LoaderEntryState, type KernelSignal, type KernelValueSignal, type LoaderStatusStore, } from './loader-status.ts';
+export { PLATFORM_MODULES, PRELOADED_CLIENT_EXTERNALS, type PlatformModule } from './platform.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/kernel/client-web/lib/types/index.js

@@ -1,17 +1,11 @@
 /**
  * Web shell library entry. The shell's product is {@link AppWebEntry} —
- * apps/web's vite entry runs it against #root; everything else (AppRoot
- * gate, app-shell assembly entry, module-table staticModules, platform constants) is
- * internal to the boot chain. PLATFORM_MODULES is re-exported as the
- * single source of truth for the tsdown client externals projection.
+ * apps/web's Vite entry runs it against #root. The boot page and fiber-state
+ * projection remain internal; the static module table and its platform words
+ * form the package's build-time contract.
  * @module @nomix-ai/nomix-client-web
  */
 export { AppWebEntry } from "./boot.js";
-export { AppRoot } from "./AppRoot.js";
-export { buildRenderApp } from "./app.js";
-export { DocumentTitle } from "./DocumentTitle.js";
-export { APP_SHELL_ID } from "./app-shell.js";
 export { getStaticModules } from "./seed.js";
-export { PLATFORM_MODULES } from "./platform.js";
-export { STATE_LABELS, FIBER_STATE, createSignal, createLoaderStatusStore, } from "./loader-status.js";
+export { PLATFORM_MODULES, PRELOADED_CLIENT_EXTERNALS } from "./platform.js";
 //# sourceMappingURL=index.js.map

package/dist/kernel/client-web/lib/types/invariant.d.ts

@@ -2,7 +2,7 @@
  * Package-owned invariant companion for `@nomix-ai/nomix-client-web`.
  * @module @nomix-ai/nomix-client-web/invariant
  */
-import type { Context } from '@nomix-ai/cordis';
+import type { Context } from '../../../cordis/lib/index.js';
 /** Cordis companion plugin name. */
 export declare const name = "client-web-invariant";
 /** Service required before the companion can reserve package ownership. */

package/dist/kernel/client-web/lib/types/loader-status.d.ts

@@ -1,16 +1,10 @@
 /**
- * Fiber-state projection vocabulary and the kernel-owned status store for the
- * boot loading page. The status AppRoot renders is a projection of the real
- * cordis fiber states (display the truth, not a retelling) — the boot chain
- * subscribes `internal/status` and recomputes one row per loader entry.
- *
- * The store is hand-rolled here because of the shell self-sufficiency rule:
- * the snapshot-store machinery lives in the runtime PLUGIN
- * package, and the shell kernel must not value-import any plugin package —
- * the loading page has to work while (and especially when) plugins fail.
+ * Fiber-state projection vocabulary for the framework-free boot page. The
+ * boot chain subscribes to `internal/status` and projects the owning loader
+ * entry's current state.
  * @module @nomix-ai/nomix-client-web/src/loader-status
  */
-import type { FiberState } from '@nomix-ai/cordis';
+import type { FiberState } from '../../../cordis/lib/index.js';
 /**
  * Value mirror of cordis's `FiberState` const enum: a const enum has no
  * runtime object to import (and esbuild-based pipelines cannot inline it
@@ -29,46 +23,4 @@ export declare const FIBER_STATE: {
 export type LoaderEntryState = 'pending' | 'loading' | 'active' | 'failed' | 'disposed' | 'unloading';
 /** Label for each fiber state, keyed by member (inlining-safe — no reverse mapping). */
 export declare const STATE_LABELS: Record<FiberState, LoaderEntryState>;
-/** Per-entry state projection (AppRoot's status feed), keyed by entry name. */
-export type LoaderStatus = Record<string, LoaderEntryState>;
-/** Minimal observable snapshot the kernel components consume (useSyncExternalStore shape). */
-export interface KernelSignal<T> {
-    /** Current value (stable reference between changes). */
-    getSnapshot: () => T;
-    /**
-     * Subscribe to changes.
-     * @param fn - change listener.
-     * @returns the unsubscribe disposer.
-     */
-    subscribe: (fn: () => void) => () => void;
-}
-/** Writable one-value signal (settled flag, boot failure report). */
-export interface KernelValueSignal<T> extends KernelSignal<T> {
-    /**
-     * Publish a new value and notify subscribers.
-     * @param next - the new value.
-     */
-    set: (next: T) => void;
-}
-/**
- * Create a writable kernel signal.
- * @param init - initial value.
- * @returns the signal.
- */
-export declare function createSignal<T>(init: T): KernelValueSignal<T>;
-/** The boot status store: per-entry rows over a {@link KernelSignal} face. */
-export interface LoaderStatusStore extends KernelSignal<LoaderStatus> {
-    /**
-     * Project one entry's state (copy-on-write so getSnapshot references only
-     * change on writes — useSyncExternalStore contract).
-     * @param id - entry name.
-     * @param state - projected fiber state.
-     */
-    set: (id: string, state: LoaderEntryState) => void;
-}
-/**
- * Create the boot status store.
- * @returns the store (empty until the boot chain projects rows).
- */
-export declare function createLoaderStatusStore(): LoaderStatusStore;
 //# sourceMappingURL=loader-status.d.ts.map

package/dist/kernel/client-web/lib/types/loader-status.js

@@ -21,39 +21,4 @@ export const STATE_LABELS = {
     [FIBER_STATE.DISPOSED]: 'disposed',
     [FIBER_STATE.UNLOADING]: 'unloading',
 };
-/**
- * Create a writable kernel signal.
- * @param init - initial value.
- * @returns the signal.
- */
-export function createSignal(init) {
-    let value = init;
-    const listeners = new Set();
-    return {
-        getSnapshot: () => value,
-        subscribe: (fn) => { listeners.add(fn); return () => { listeners.delete(fn); }; },
-        set: (next) => {
-            value = next;
-            for (const fn of [...listeners])
-                fn();
-        },
-    };
-}
-/**
- * Create the boot status store.
- * @returns the store (empty until the boot chain projects rows).
- */
-export function createLoaderStatusStore() {
-    let value = {};
-    const listeners = new Set();
-    return {
-        getSnapshot: () => value,
-        subscribe: (fn) => { listeners.add(fn); return () => { listeners.delete(fn); }; },
-        set: (id, state) => {
-            value = { ...value, [id]: state };
-            for (const fn of [...listeners])
-                fn();
-        },
-    };
-}
 //# sourceMappingURL=loader-status.js.map

package/dist/kernel/client-web/lib/types/platform.d.ts

@@ -4,7 +4,9 @@
  * @module @nomix-ai/nomix-client-web/src/platform
  */
 /** The module specifiers the shell shares into the frozen module table. */
-export declare const PLATFORM_MODULES: readonly ["react", "react/jsx-runtime", "react-dom", "react-dom/client", "@nomix-ai/cordis", "@nomix-ai/nomix-client-ui-slots", "@nomix-ai/nomix-client-web-react", "@nomix-ai/nomix-client-ui-primitives", "@nomix-ai/nomix-client-ui-attachment", "@nomix-ai/nomix-client-schema-form"];
+export declare const PLATFORM_MODULES: readonly ["react", "react/jsx-runtime", "react-dom", "react-dom/client", "@nomix-ai/cordis", "@nomix-ai/nomix-client-ui-slots", "@nomix-ai/nomix-client-ui-primitives"];
+/** Client-bundle specifiers whose factories the parser preloads before the shell starts. */
+export declare const PRELOADED_CLIENT_EXTERNALS: readonly ["@nomix-ai/nomix-client-runtime/client"];
 /** One platform module specifier (a seed-table key). */
 export type PlatformModule = (typeof PLATFORM_MODULES)[number];
 //# sourceMappingURL=platform.d.ts.map

package/dist/kernel/client-web/lib/types/platform.js

@@ -7,9 +7,10 @@
 export const PLATFORM_MODULES = [
     'react', 'react/jsx-runtime', 'react-dom', 'react-dom/client', '@nomix-ai/cordis',
     '@nomix-ai/nomix-client-ui-slots',
-    '@nomix-ai/nomix-client-web-react',
     '@nomix-ai/nomix-client-ui-primitives',
-    '@nomix-ai/nomix-client-ui-attachment',
-    '@nomix-ai/nomix-client-schema-form',
+];
+/** Client-bundle specifiers whose factories the parser preloads before the shell starts. */
+export const PRELOADED_CLIENT_EXTERNALS = [
+    '@nomix-ai/nomix-client-runtime/client',
 ];
 //# sourceMappingURL=platform.js.map