@markii/host 0.17.0-next.3 → 0.17.0-next.4

package/dist/node.js

@@ -4,10 +4,11 @@
 // The main entry (`./index.ts`) is environment-neutral. This entry adds:
 // - the worker_threads isolate and the pinned network provider (`node:*`);
 // - the Node-backed file-system seams the neutral code takes by injection;
-// - the `@markii/html`-backed static export engine;
+//
+// The `@markii/html`-backed static export engine is its own entry,
+// `@markii/host/html-engine`, so importing this one needs no optional peer.
 //
 // A Node host imports from both entries. No browser bundle imports this one.
 export { createNodeHostIsolate, workerThreadIsolate, } from './run/node-isolate.js';
 export { createNetProvider } from './run/net-provider.js';
-export { createNodeArchiveExtractFs, createNodeDirectoryLister, createNodeFileReader, createNodePackDiscoveryIo, createNodeReader as createNodePackScriptsReader, } from './node-fs.js';
-export { createHtmlExportEngine } from './html-engine.js';
+export { createNodeDirectoryLister, createNodeFileReader, createNodePackDiscoveryIo, createNodeReader as createNodePackScriptsReader, } from './node-fs.js';

package/dist/packs/discover.d.ts

@@ -30,6 +30,8 @@ export interface DiscoveredPack {
     /** The configured folder this pack was discovered in (absolute path, as given). */
     readonly folder: string;
     readonly manifest: PackManifest;
+    /** The exact text of the pack's `pack.json`, as read. A compiled script registers this text unchanged. Discovery always sets it; it is absent only on a pack a host assembled by hand. */
+    readonly manifestText?: string;
     /** Local component name -> absolute path to its declared source file (`manifest.components[name]`, resolved against `folder`). Informational: what a host consumes them for (bundling, `import()`, or locating the pack's prebuilt registration script) is that host's own concern. */
     readonly componentPaths: Readonly<Record<string, string>>;
     /** Engine id -> (local component name -> absolute source path), for every engine any component declares a source for. `componentPaths` is the `react` slice of this. A terminal build (`ansi`) reads its slice here. */

package/dist/packs/discover.js

@@ -102,6 +102,7 @@ async function tryLoadPackAt(folder, readFile) {
         pack: {
             folder,
             manifest: result.manifest,
+            manifestText: text,
             componentPaths,
             componentPathsByEngine,
             scriptsDir: joinPath(folder, 'scripts'),

package/dist/run/net-bridge.js

@@ -1,3 +1,4 @@
+import { isNetRefusal } from './net-refusal.js';
 export function isNetBridgeRequest(value) {
     if (typeof value !== 'object' || value === null)
         return false;
@@ -49,11 +50,12 @@ export async function serveNetRequest(request, provider, post) {
             id: request.id,
             ok: false,
             error: error instanceof Error ? error.message : String(error),
-            // Everything the host's provider refuses IS a policy denial: the
-            // provider's own failures are allowlist, redirect, size, and pinning
-            // refusals. Marking them so keeps the worker's classification
-            // identical to the in-worker case.
-            denied: true,
+            // A policy refusal (allowlist, redirect, size, address range) is
+            // marked by the provider and crosses as a denial, so the worker
+            // classifies it exactly as it would in-worker. A transport failure
+            // (DNS, connection, timeout, abort) is unmarked and crosses as an
+            // ordinary failure with its reason. Both reach the script as errors.
+            denied: isNetRefusal(error),
         });
     }
 }

package/dist/run/net-pinning.d.ts

@@ -40,6 +40,8 @@ export type PinResult = {
 } | {
     ok: false;
     reason: string;
+    /** `unresolved`: the name did not resolve (a transport failure). `refused`: the address policy refused it. */
+    kind: 'unresolved' | 'refused';
 };
 export interface PinPolicy {
     /**

package/dist/run/net-pinning.js

@@ -79,29 +79,43 @@ export async function pinHostAddress(hostname, policy, lookup) {
     catch {
         // Deliberately not the resolver's own message: it varies by platform and
         // says nothing a note's author can act on.
-        return { ok: false, reason: `host "${hostname}" could not be resolved` };
+        return {
+            ok: false,
+            kind: 'unresolved',
+            reason: `host "${hostname}" could not be resolved`,
+        };
     }
     if (addresses.length === 0) {
-        return { ok: false, reason: `host "${hostname}" resolved to no address` };
+        return {
+            ok: false,
+            kind: 'unresolved',
+            reason: `host "${hostname}" resolved to no address`,
+        };
     }
     for (const candidate of addresses) {
         const scope = classifyIpAddress(candidate.address);
         if (scope === undefined) {
             return {
                 ok: false,
+                kind: 'refused',
                 reason: `host "${hostname}" resolved to an unusable address`,
             };
         }
         if (isRestrictedScope(scope) && !policy.allowRestrictedAddresses) {
             return {
                 ok: false,
+                kind: 'refused',
                 reason: `host "${hostname}" resolves to ${describeScope(scope)}`,
             };
         }
     }
     const chosen = addresses[0];
     if (chosen === undefined) {
-        return { ok: false, reason: `host "${hostname}" resolved to no address` };
+        return {
+            ok: false,
+            kind: 'unresolved',
+            reason: `host "${hostname}" resolved to no address`,
+        };
     }
     const scope = classifyIpAddress(chosen.address) ?? 'reserved';
     return {

package/dist/run/net-provider.js

@@ -21,6 +21,7 @@
 import * as http from 'node:http';
 import * as https from 'node:https';
 import * as dns from 'node:dns';
+import { netRefusal } from './net-refusal.js';
 import { pinHostAddress, pinnedLookup, } from './net-pinning.js';
 function describeThrown(err) {
     return err instanceof Error ? err.message : String(err);
@@ -161,12 +162,14 @@ denial, signal) {
             res.on('error', (err) => settleReject(err));
         });
         req.on('error', (err) => {
-            settleReject(denial(`request failed: ${describeThrown(err)}`));
+            // A transport failure (connection refused, reset, timeout): an
+            // ordinary runtime failure with the reason, not a policy refusal.
+            settleReject(new Error(`request failed: ${describeThrown(err)}`));
         });
         if (signal !== undefined) {
             const onAbort = () => {
                 req.destroy();
-                settleReject(denial('the run has ended'));
+                settleReject(new Error('the run has ended'));
             };
             if (signal.aborted)
                 onAbort();
@@ -241,6 +244,10 @@ denial, lookup = defaultHostLookup,
 /** Aborted when the run ends: an in-flight request is destroyed and no further hop is made. */
 signal) {
     const allowed = new Set(allowlist.map((host) => host.toLowerCase()));
+    // Every policy refusal is built by the injected `denial` and then marked,
+    // so the net bridge can tell it from a transport failure without importing
+    // the Lua runtime. A transport failure is a plain `Error`.
+    const refuse = (message) => netRefusal(denial(message));
     async function fetchAllowed(startUrl, method, body) {
         let currentUrl = startUrl;
         for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
@@ -249,43 +256,47 @@ signal) {
                 parsed = new URL(currentUrl);
             }
             catch {
-                throw denial(`"${currentUrl}" is not a valid URL`);
+                throw refuse(`"${currentUrl}" is not a valid URL`);
             }
             if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-                throw denial(`scheme "${parsed.protocol}" is not allowed`);
+                throw refuse(`scheme "${parsed.protocol}" is not allowed`);
             }
             // N-4: a URL carrying credentials is refused outright, on every hop.
             if (parsed.username !== '' || parsed.password !== '') {
-                throw denial(`URL "${currentUrl}" embeds credentials, which is not allowed`);
+                throw refuse(`URL "${currentUrl}" embeds credentials, which is not allowed`);
             }
             if (signal?.aborted)
-                throw denial('the run has ended');
+                throw new Error('the run has ended');
             const host = parsed.hostname.toLowerCase();
             if (!allowed.has(host)) {
-                throw denial(`host "${host}" is not on the run's allowlist`);
+                throw refuse(`host "${host}" is not on the run's allowlist`);
             }
             // Issue #10: resolve-then-pin, closing the DNS-rebinding / private-
             // range SSRF gap a hostname allowlist alone cannot see.
             const pinResult = await pinHostAddress(host, policy, lookup);
             if (!pinResult.ok) {
-                throw denial(pinResult.reason);
+                // A name that does not resolve is a transport failure; an address
+                // the policy refuses is a policy refusal.
+                throw pinResult.kind === 'unresolved'
+                    ? new Error(pinResult.reason)
+                    : refuse(pinResult.reason);
             }
-            const response = await issueRequest(parsed, method, body, pinResult.pinned, maxFetchBytes, denial, signal);
+            const response = await issueRequest(parsed, method, body, pinResult.pinned, maxFetchBytes, refuse, signal);
             if (response.status >= 300 && response.status < 400) {
                 if (!response.location) {
-                    throw denial('redirect response carried no Location header');
+                    throw refuse('redirect response carried no Location header');
                 }
                 try {
                     currentUrl = new URL(response.location, currentUrl).toString();
                 }
                 catch {
-                    throw denial('redirect response carried an unparseable Location header');
+                    throw refuse('redirect response carried an unparseable Location header');
                 }
                 continue;
             }
             return { status: response.status, body: response.body };
         }
-        throw denial(`exceeded ${MAX_REDIRECTS} redirects`);
+        throw refuse(`exceeded ${MAX_REDIRECTS} redirects`);
     }
     return {
         get: (url) => fetchAllowed(url, 'GET', undefined),

package/dist/run/net-refusal.d.ts

@@ -0,0 +1,4 @@
+/** Returns `error` marked as a policy refusal. A network provider throws one for every request it refuses on policy grounds. */
+export declare function netRefusal(error: Error): Error;
+/** True when `error` was marked by {@link netRefusal}. */
+export declare function isNetRefusal(error: unknown): boolean;

package/dist/run/net-refusal.js

@@ -0,0 +1,24 @@
+/**
+ * Marks an `Error` as a network POLICY refusal (an unlisted host, a refused
+ * address range, an over-size body) as opposed to a transport failure (DNS,
+ * connection, timeout, abort).
+ *
+ * The brand is a global `Symbol.for` key on the error object, so it needs no
+ * runtime import and survives being created in one bundle and read in
+ * another. The net bridge reads it to decide whether a failure crosses to
+ * the worker as a capability denial or as an ordinary runtime failure. A
+ * refusal is always an error: a script can never read one as a success.
+ *
+ * It is a plain property, not a classification the Lua side trusts: the
+ * worker rebuilds its own branded denial from the `denied` flag on the wire.
+ */
+const NET_REFUSAL = Symbol.for('markii.net.refusal');
+/** Returns `error` marked as a policy refusal. A network provider throws one for every request it refuses on policy grounds. */
+export function netRefusal(error) {
+    return Object.assign(error, { [NET_REFUSAL]: true });
+}
+/** True when `error` was marked by {@link netRefusal}. */
+export function isNetRefusal(error) {
+    return (error instanceof Error &&
+        error[NET_REFUSAL] === true);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markii/host",
-  "version": "0.17.0-next.3",
-  "description": "Shared, host-neutral script-running layer for Markii hosts: tier gating, the grant model, address pinning, and the terminatable-isolate watchdog, plus the HostAdapter contract and createMarkiiHost. Entries: the neutral main entry, /node, /browser, /conformance.",
+  "version": "0.17.0-next.4",
+  "description": "Shared, host-neutral script-running layer for Markii hosts: tier gating, the grant model, address pinning, and the terminatable-isolate watchdog, plus the HostAdapter contract and createMarkiiHost. Entries: the neutral main entry, /internal (no semver promise), /node, /html-engine, /browser, /browser-worker-classic, /conformance.",
   "keywords": [
     "markdown",
     "mk.md",
@@ -27,11 +27,21 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "import": "./dist/internal.js",
+      "default": "./dist/internal.js"
+    },
     "./node": {
       "types": "./dist/node.d.ts",
       "import": "./dist/node.js",
       "default": "./dist/node.js"
     },
+    "./html-engine": {
+      "types": "./dist/html-engine.d.ts",
+      "import": "./dist/html-engine.js",
+      "default": "./dist/html-engine.js"
+    },
     "./node-worker": {
       "default": "./dist/node-worker.js"
     },
@@ -40,12 +50,18 @@
       "import": "./dist/browser.js",
       "default": "./dist/browser.js"
     },
+    "./browser-worker-classic": {
+      "default": "./dist/browser-worker.classic.js"
+    },
     "./conformance": {
       "types": "./dist/conformance.d.ts",
       "import": "./dist/conformance.js",
       "default": "./dist/conformance.js"
     }
   },
+  "engines": {
+    "node": ">=22"
+  },
   "scripts": {
     "pretest": "npm run generate:doc-css --workspace @markii/html",
     "test": "vitest run",
@@ -55,20 +71,20 @@
     "build:dist": "rm -rf dist && tsc -p tsconfig.build.json && node scripts/build-dist-assets.mjs"
   },
   "dependencies": {
-    "@markii/bundle": "^0.17.0-next.3",
-    "@markii/core": "^0.17.0-next.3",
-    "@markii/lua": "^0.17.0-next.3",
-    "@markii/pack": "^0.17.0-next.3",
-    "@markii/runtime": "^0.17.0-next.3",
-    "@markii/stdlib": "^0.17.0-next.3",
+    "@markii/bundle": "^0.17.0-next.4",
+    "@markii/core": "^0.17.0-next.4",
+    "@markii/lua": "^0.17.0-next.4",
+    "@markii/pack": "^0.17.0-next.4",
+    "@markii/runtime": "^0.17.0-next.4",
+    "@markii/stdlib": "^0.17.0-next.4",
     "fflate": "^0.8.3"
   },
   "files": [
     "dist"
   ],
   "peerDependencies": {
-    "@markii/html": "^0.17.0-next.3",
-    "@markii/react": "^0.17.0-next.3"
+    "@markii/html": "^0.17.0-next.4",
+    "@markii/react": "^0.17.0-next.4"
   },
   "peerDependenciesMeta": {
     "@markii/html": {
@@ -79,8 +95,8 @@
     }
   },
   "devDependencies": {
-    "@markii/html": "^0.17.0-next.3",
-    "@markii/react": "^0.17.0-next.3",
+    "@markii/html": "^0.17.0-next.4",
+    "@markii/react": "^0.17.0-next.4",
     "esbuild": "^0.28.2"
   },
   "publishConfig": {