@nomix-ai/nomix-harness 0.2.5 → 0.2.6

package/dist/kernel/host-frontend-static/lib/types/index.js

@@ -1,13 +1,13 @@
 /**
  * @nomix-ai/nomix-host-frontend-static — SPA dist server over the webserver
- * fallback seat: serves the built frontend directory with the semantics the
- * Web shell locked at step1 — traversal outside the dist root is 403, any
- * miss falls back to index.html with HTTP 200 (SPA routing), unknown
- * extensions ship as octet-stream, non-GET/HEAD is 405. Every index response
- * runs through the webserver's registered index taps (boot-manifest
- * injection). The dist location is workspace knowledge of the composing
- * application, so `distIndex` is typically supplied through a `!!js`
- * expression, never hardcoded by a deployment.
+ * fallback seat: serves the built frontend directory with explicit index
+ * entry points. A readable index renders at the dist root and configured index
+ * path; missing paths return 404, traversal outside the dist root is 403,
+ * unknown extensions ship as octet-stream, and non-GET/HEAD is 405. Every
+ * index response runs through the webserver's index render (structured
+ * injection rows, then raw taps). The dist location is workspace knowledge of
+ * the composing application, so `distIndex` is typically supplied through a
+ * `!!js` expression, never hardcoded by a deployment.
  * @module @nomix-ai/nomix-host-frontend-static
  */
 import { readFile } from 'node:fs/promises';
@@ -20,8 +20,9 @@ export const inject = ['webServer'];
 export const Config = z.object({
     distIndex: z.string().required(),
 });
+const HTML_MIME = 'text/html; charset=utf-8';
 const MIME = {
-    '.html': 'text/html; charset=utf-8',
+    '.html': HTML_MIME,
     '.js': 'text/javascript; charset=utf-8',
     '.css': 'text/css; charset=utf-8',
     '.svg': 'image/svg+xml',
@@ -29,14 +30,19 @@ const MIME = {
     '.map': 'application/json',
     '.webmanifest': 'application/manifest+json',
 };
+const STATIC_MISS_CODES = new Set([
+    'ENOENT',
+    'EISDIR',
+    'ENOTDIR',
+]);
 /**
  * Serve one GET/HEAD static request from the dist root.
  * @param pathname - decoded URL pathname of the request.
  * @param res - the node:http response to write.
  * @param distRoot - absolute dist root directory (resolved by the caller).
  * @param distIndex - absolute path of index.html inside distRoot.
- * @param renderIndex - produces the index.html body (index-tap injection) for
- * `/` and every SPA fallback.
+ * @param renderIndex - produces the index.html body (structured injection
+ * rendering) for the dist root and configured index path.
  */
 export async function serveStatic(pathname, res, distRoot, distIndex, renderIndex) {
     const target = resolve(normalize(join(distRoot, pathname)));
@@ -48,24 +54,29 @@ export async function serveStatic(pathname, res, distRoot, distIndex, renderInde
         res.end();
         return;
     }
-    const serveIndex = async () => {
-        const body = await renderIndex();
-        res.writeHead(200, { 'content-type': MIME['.html'] });
-        res.end(body);
-    };
-    if (target === distRoot || target === distIndex) {
-        await serveIndex();
-        return;
-    }
+    let body;
+    let type;
     try {
-        const body = await readFile(target);
-        res.writeHead(200, { 'content-type': MIME[extname(target)] ?? 'application/octet-stream' });
-        res.end(body);
+        if (target === distRoot || target === distIndex) {
+            body = await renderIndex();
+            type = HTML_MIME;
+        }
+        else {
+            body = await readFile(target);
+            type = MIME[extname(target)] ?? 'application/octet-stream';
+        }
     }
-    catch {
-        // Miss (ENOENT/EISDIR) falls back to index.html with 200 (SPA routing).
-        await serveIndex();
+    catch (error) {
+        // Only absent or non-file targets are 404; other filesystem failures reach
+        // the webserver's request-failure handling.
+        if (!STATIC_MISS_CODES.has(error.code))
+            throw error;
+        res.writeHead(404);
+        res.end();
+        return;
     }
+    res.writeHead(200, { 'content-type': type });
+    res.end(body);
 }
 /**
  * Claim the webserver fallback seat and serve the dist.
@@ -75,7 +86,7 @@ export async function serveStatic(pathname, res, distRoot, distIndex, renderInde
 export function apply(ctx, config) {
     const distIndex = config.distIndex;
     const distRoot = dirname(distIndex);
-    const renderIndex = async () => ctx.webServer.applyIndexTaps(await readFile(distIndex, 'utf8'));
+    const renderIndex = async () => ctx.webServer.renderIndex(await readFile(distIndex, 'utf8'));
     ctx.effect(() => ctx.webServer.registerFallback(async (req, res) => {
         // Non-GET/HEAD without a matching named route is 405 (fallback-only
         // semantics: named routes own their method handling).

package/dist/kernel/host-frontend-static/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-host-frontend-static",
-  "description": "SPA dist server for the Web shell: owns the webserver fallback seat, serving the built frontend with index-tap injection, traversal rejection, and SPA index fallback",
-  "version": "0.2.5",
+  "description": "SPA dist server for the Web shell: owns the webserver fallback seat, serving explicit index entries and static assets with traversal rejection and 404 misses",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/host-plugin-inventory/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-host-plugin-inventory",
   "description": "Read-only Remote projection of current Cordis Loader plugin state",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/host-webserver/lib/index.js

@@ -1,12 +1,87 @@
 import { createServer } from "node:http";
 import { Service } from "../../cordis/lib/index.js";
 import z from "../../schemastery/lib/index.mjs";
+//#region lib/types/injections.js
+/**
+* Structured index injections: the typed rows plugins contribute to the boot
+* HTML instead of raw `tapIndex` string transforms. Rows are pure
+* JSON-serializable data because one table feeds two renderers: the served
+* form renders rows into the index.html text ({@link renderIndexInjections}),
+* and a static worker deployment ships the same rows over its boot payload
+* for a page-side interpreter. Anything not expressible as a row stays on
+* `tapIndex`, which runs after row rendering.
+*/
+/** Escape a row value before placing it in a quoted HTML attribute. */
+function escapeHtmlAttribute(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function assertNever(row) {
+	throw new Error(`webserver: unknown index injection row ${JSON.stringify(row)}`);
+}
+/** Render one row to markup with its placement. */
+function renderRow(row) {
+	switch (row.kind) {
+		case "global": return {
+			placement: "head",
+			markup: `<script>globalThis[${JSON.stringify(row.name).replaceAll("<", "\\u003c")}] = ${row.value === void 0 ? "undefined" : JSON.stringify(row.value).replaceAll("<", "\\u003c")}<\/script>`
+		};
+		case "script": return {
+			placement: row.placement,
+			markup: `<script>${row.text}<\/script>`
+		};
+		case "script-src": return {
+			placement: row.placement,
+			markup: `<script src="${escapeHtmlAttribute(row.src)}"><\/script>`
+		};
+		case "style": return {
+			placement: "head",
+			markup: `<style>${row.text}</style>`
+		};
+		case "html": return {
+			placement: row.placement,
+			markup: row.html
+		};
+		default: return assertNever(row);
+	}
+}
+/** Insert `markup` into `html` at `at`. */
+function splice(html, at, markup) {
+	return `${html.slice(0, at)}${markup}${html.slice(at)}`;
+}
+/**
+* Render rows into an index.html body: head rows immediately after the
+* opening head tag, body rows immediately after the opening body tag, each
+* group in table order.
+* @param html - the raw index.html body.
+* @param rows - the collected injection table.
+* @returns the html with every row rendered.
+*/
+function renderIndexInjections(html, rows) {
+	let head = "";
+	let body = "";
+	for (const row of rows) {
+		const rendered = renderRow(row);
+		if (rendered.placement === "head") head += rendered.markup;
+		else body += rendered.markup;
+	}
+	let out = html;
+	if (head !== "") {
+		const open = /<head(?:\s[^>]*)?>/i.exec(out);
+		out = open === null ? `${head}${out}` : splice(out, open.index + open[0].length, head);
+	}
+	if (body !== "") {
+		const open = /<body(?:\s[^>]*)?>/i.exec(out);
+		out = open === null ? `${out}${body}` : splice(out, open.index + open[0].length, body);
+	}
+	return out;
+}
+//#endregion
 //#region lib/types/index.js
 /**
 * @nomix-ai/nomix-host-webserver — Web route-registration plugin: a node:http
-* server plus the `webServer` service (HTTP and upgrade route registries,
-* index transform taps, and the single fallback seat for everything no route
-* claims). Knows no harness concepts and serves no files; the composing
+* server plus the `webServer` service (HTTP and upgrade route registries, the
+* structured index injection table with raw transform taps behind it, and the
+* single fallback seat for everything no route claims). Knows no harness concepts and serves no files; the composing
 * application's frontend plugin owns dist serving through the fallback hook.
 * Web shape only — Electron loads dist over file:// and carries fetch over an
 * IPC bridge. This package never prints: the URL line belongs to the shell.
@@ -87,8 +162,9 @@ var WebServer = class extends Service {
 		};
 	}
 	/**
-	* Register an index.html transform, applied by the fallback owner to every
-	* index response ({@link applyIndexTaps}) in registration order.
+	* Register a raw-HTML index transform, the escape hatch for markup no
+	* {@link IndexInjection} row expresses: {@link renderIndex} applies taps in
+	* registration order after rendering the structured rows.
 	* @param transform - pure html-to-html function.
 	* @returns the disposer removing the transform.
 	*/
@@ -212,6 +288,26 @@ var WebServer = class extends Service {
 		for (const transform of this.indexTaps) out = transform(out);
 		return out;
 	}
+	/**
+	* Gather the structured injection table: one `webserver/index-inject` emit,
+	* every subscriber pushes its current rows. Fresh per call, so subscribers
+	* read live state (module graph, theme preference) at emit time.
+	* @returns rows in subscriber activation order.
+	*/
+	collectIndexInjections() {
+		const table = [];
+		this.ctx.emit("webserver/index-inject", table);
+		return table;
+	}
+	/**
+	* Render one index.html body: the structured injection table first, then
+	* the raw `tapIndex` transforms over the result.
+	* @param html - the raw index.html body.
+	* @returns the transformed body.
+	*/
+	renderIndex(html) {
+		return this.applyIndexTaps(renderIndexInjections(html, this.collectIndexInjections()));
+	}
 };
 //#endregion
-export { WebServer, WebServer as default };
+export { WebServer, WebServer as default, renderIndexInjections };

package/dist/kernel/host-webserver/lib/types/index.d.ts

@@ -1,8 +1,8 @@
 /**
  * @nomix-ai/nomix-host-webserver — Web route-registration plugin: a node:http
- * server plus the `webServer` service (HTTP and upgrade route registries,
- * index transform taps, and the single fallback seat for everything no route
- * claims). Knows no harness concepts and serves no files; the composing
+ * server plus the `webServer` service (HTTP and upgrade route registries, the
+ * structured index injection table with raw transform taps behind it, and the
+ * single fallback seat for everything no route claims). Knows no harness concepts and serves no files; the composing
  * application's frontend plugin owns dist serving through the fallback hook.
  * Web shape only — Electron loads dist over file:// and carries fetch over an
  * IPC bridge. This package never prints: the URL line belongs to the shell.
@@ -11,10 +11,23 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Duplex } from 'node:stream';
 import { Context, Service } from '../../../cordis/lib/index.js';
 import z from '../../../schemastery/lib/index.mjs';
+import { type IndexInjection } from './injections.ts';
+export { renderIndexInjections } from './injections.ts';
+export type { IndexInjection, IndexInjectionPlacement } from './injections.ts';
 declare module '@nomix-ai/cordis' {
     interface Context {
         webServer: WebServer;
     }
+    interface Events {
+        /**
+         * Collect the structured index injection table. Emitted on every index
+         * render and every worker boot-payload request; listeners push their
+         * current rows, so a row's data is read fresh at emit time.
+         * @param table - Mutable row table; listeners append in activation order.
+         * @mode emit
+         */
+        'webserver/index-inject'(table: IndexInjection[]): void;
+    }
 }
 /** Route match kind: 'exact' matches the pathname verbatim; 'prefix' p matches p and p/<anything>. */
 export type WebRouteKind = 'exact' | 'prefix';
@@ -87,8 +100,9 @@ export declare class WebServer extends Service {
      */
     registerFallback(handler: WebRoute['handler']): () => void;
     /**
-     * Register an index.html transform, applied by the fallback owner to every
-     * index response ({@link applyIndexTaps}) in registration order.
+     * Register a raw-HTML index transform, the escape hatch for markup no
+     * {@link IndexInjection} row expresses: {@link renderIndex} applies taps in
+     * registration order after rendering the structured rows.
      * @param transform - pure html-to-html function.
      * @returns the disposer removing the transform.
      */
@@ -104,6 +118,20 @@ export declare class WebServer extends Service {
      * @returns the transformed body.
      */
     applyIndexTaps(html: string): string;
+    /**
+     * Gather the structured injection table: one `webserver/index-inject` emit,
+     * every subscriber pushes its current rows. Fresh per call, so subscribers
+     * read live state (module graph, theme preference) at emit time.
+     * @returns rows in subscriber activation order.
+     */
+    collectIndexInjections(): IndexInjection[];
+    /**
+     * Render one index.html body: the structured injection table first, then
+     * the raw `tapIndex` transforms over the result.
+     * @param html - the raw index.html body.
+     * @returns the transformed body.
+     */
+    renderIndex(html: string): string;
 }
 export default WebServer;
 //# sourceMappingURL=index.d.ts.map

package/dist/kernel/host-webserver/lib/types/index.js

@@ -1,8 +1,8 @@
 /**
  * @nomix-ai/nomix-host-webserver — Web route-registration plugin: a node:http
- * server plus the `webServer` service (HTTP and upgrade route registries,
- * index transform taps, and the single fallback seat for everything no route
- * claims). Knows no harness concepts and serves no files; the composing
+ * server plus the `webServer` service (HTTP and upgrade route registries, the
+ * structured index injection table with raw transform taps behind it, and the
+ * single fallback seat for everything no route claims). Knows no harness concepts and serves no files; the composing
  * application's frontend plugin owns dist serving through the fallback hook.
  * Web shape only — Electron loads dist over file:// and carries fetch over an
  * IPC bridge. This package never prints: the URL line belongs to the shell.
@@ -10,6 +10,8 @@
 import { createServer } from 'node:http';
 import { Service } from '../../../cordis/lib/index.js';
 import z from '../../../schemastery/lib/index.mjs';
+import { renderIndexInjections } from "./injections.js";
+export { renderIndexInjections } from "./injections.js";
 /**
  * The browser HTTP carrier service. Activation listens immediately. Route
  * registration order does not affect requests because configured named routes
@@ -86,8 +88,9 @@ export class WebServer extends Service {
         return () => { this.fallback = undefined; };
     }
     /**
-     * Register an index.html transform, applied by the fallback owner to every
-     * index response ({@link applyIndexTaps}) in registration order.
+     * Register a raw-HTML index transform, the escape hatch for markup no
+     * {@link IndexInjection} row expresses: {@link renderIndex} applies taps in
+     * registration order after rendering the structured rows.
      * @param transform - pure html-to-html function.
      * @returns the disposer removing the transform.
      */
@@ -218,6 +221,26 @@ export class WebServer extends Service {
             out = transform(out);
         return out;
     }
+    /**
+     * Gather the structured injection table: one `webserver/index-inject` emit,
+     * every subscriber pushes its current rows. Fresh per call, so subscribers
+     * read live state (module graph, theme preference) at emit time.
+     * @returns rows in subscriber activation order.
+     */
+    collectIndexInjections() {
+        const table = [];
+        this.ctx.emit('webserver/index-inject', table);
+        return table;
+    }
+    /**
+     * Render one index.html body: the structured injection table first, then
+     * the raw `tapIndex` transforms over the result.
+     * @param html - the raw index.html body.
+     * @returns the transformed body.
+     */
+    renderIndex(html) {
+        return this.applyIndexTaps(renderIndexInjections(html, this.collectIndexInjections()));
+    }
 }
 export default WebServer;
 //# sourceMappingURL=index.js.map

package/dist/kernel/host-webserver/lib/types/injections.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Structured index injections: the typed rows plugins contribute to the boot
+ * HTML instead of raw `tapIndex` string transforms. Rows are pure
+ * JSON-serializable data because one table feeds two renderers: the served
+ * form renders rows into the index.html text ({@link renderIndexInjections}),
+ * and a static worker deployment ships the same rows over its boot payload
+ * for a page-side interpreter. Anything not expressible as a row stays on
+ * `tapIndex`, which runs after row rendering.
+ */
+/** Document region a rendered row lands in: after the opening head or body tag. */
+export type IndexInjectionPlacement = 'head' | 'body';
+/** One structured index injection row. */
+export type IndexInjection = 
+/** Assign a JSON-serializable value to a `globalThis` property, ahead of later script rows. */
+{
+    kind: 'global';
+    name: string;
+    value: unknown;
+}
+/** Inline classic script. `text` must not contain `</script`, which would close the element early. */
+ | {
+    kind: 'script';
+    placement: IndexInjectionPlacement;
+    text: string;
+}
+/**
+ * External classic script, executed in table order: a parser-blocking tag
+ * when served, an awaited fetch-and-execute in the worker form (whose
+ * loader resolves worker-only URLs such as `/plugins/...`).
+ */
+ | {
+    kind: 'script-src';
+    placement: IndexInjectionPlacement;
+    src: string;
+}
+/** A `<style>` element in the head. `text` must not contain `</style`, which would close the element early. */
+ | {
+    kind: 'style';
+    text: string;
+}
+/** Raw markup fragment. */
+ | {
+    kind: 'html';
+    placement: IndexInjectionPlacement;
+    html: string;
+};
+/**
+ * Render rows into an index.html body: head rows immediately after the
+ * opening head tag, body rows immediately after the opening body tag, each
+ * group in table order.
+ * @param html - the raw index.html body.
+ * @param rows - the collected injection table.
+ * @returns the html with every row rendered.
+ */
+export declare function renderIndexInjections(html: string, rows: readonly IndexInjection[]): string;
+//# sourceMappingURL=injections.d.ts.map

package/dist/kernel/host-webserver/lib/types/injections.js

@@ -0,0 +1,82 @@
+/**
+ * Structured index injections: the typed rows plugins contribute to the boot
+ * HTML instead of raw `tapIndex` string transforms. Rows are pure
+ * JSON-serializable data because one table feeds two renderers: the served
+ * form renders rows into the index.html text ({@link renderIndexInjections}),
+ * and a static worker deployment ships the same rows over its boot payload
+ * for a page-side interpreter. Anything not expressible as a row stays on
+ * `tapIndex`, which runs after row rendering.
+ */
+/** Escape a row value before placing it in a quoted HTML attribute. */
+function escapeHtmlAttribute(value) {
+    return value
+        .replaceAll('&', '&')
+        .replaceAll('"', '"')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;');
+}
+function assertNever(row) {
+    throw new Error(`webserver: unknown index injection row ${JSON.stringify(row)}`);
+}
+/** Render one row to markup with its placement. */
+function renderRow(row) {
+    switch (row.kind) {
+        case 'global': {
+            // `<` is escaped in JSON so a row-controlled string cannot break out of
+            // the script element.
+            const name = JSON.stringify(row.name).replaceAll('<', '\\u003c');
+            const value = row.value === undefined
+                ? 'undefined'
+                : JSON.stringify(row.value).replaceAll('<', '\\u003c');
+            return { placement: 'head', markup: `<script>globalThis[${name}] = ${value}</script>` };
+        }
+        case 'script':
+            return { placement: row.placement, markup: `<script>${row.text}</script>` };
+        case 'script-src':
+            return { placement: row.placement, markup: `<script src="${escapeHtmlAttribute(row.src)}"></script>` };
+        case 'style':
+            return { placement: 'head', markup: `<style>${row.text}</style>` };
+        case 'html':
+            return { placement: row.placement, markup: row.html };
+        default:
+            return assertNever(row);
+    }
+}
+/** Insert `markup` into `html` at `at`. */
+function splice(html, at, markup) {
+    return `${html.slice(0, at)}${markup}${html.slice(at)}`;
+}
+/**
+ * Render rows into an index.html body: head rows immediately after the
+ * opening head tag, body rows immediately after the opening body tag, each
+ * group in table order.
+ * @param html - the raw index.html body.
+ * @param rows - the collected injection table.
+ * @returns the html with every row rendered.
+ */
+export function renderIndexInjections(html, rows) {
+    let head = '';
+    let body = '';
+    for (const row of rows) {
+        const rendered = renderRow(row);
+        if (rendered.placement === 'head')
+            head += rendered.markup;
+        else
+            body += rendered.markup;
+    }
+    let out = html;
+    if (head !== '') {
+        const open = /<head(?:\s[^>]*)?>/i.exec(out);
+        // Headless fixture pages may lack <head>; prepending keeps the rows ahead
+        // of every document script.
+        out = open === null ? `${head}${out}` : splice(out, open.index + open[0].length, head);
+    }
+    if (body !== '') {
+        const open = /<body(?:\s[^>]*)?>/i.exec(out);
+        // Body-less fragments receive the rows at the end, where the HTML parser
+        // has already synthesized a body.
+        out = open === null ? `${out}${body}` : splice(out, open.index + open[0].length, body);
+    }
+    return out;
+}
+//# sourceMappingURL=injections.js.map

package/dist/kernel/host-webserver/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-host-webserver",
   "description": "Web route-registration plugin: HTTP and upgrade routes, index transform taps, and static dist fallback; knows no harness concepts",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/invariants/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-invariants",
   "description": "Registry service for package-owned Nomix Harness runtime invariants",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/jobs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-jobs",
   "description": "Background job registry (ctx.jobs) for the Nomix Harness — shared ids, owner isolation, polling, cancellation, and completion listeners for long-running tool work",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/jobs-local/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-jobs-local",
   "description": "Process-local implementation of the Nomix Harness background job registry seam",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/launch-environment/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-launch-environment",
   "description": "Immutable Nomix Harness launch environment that records which layer supplied each value",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },