@lapxo/bound 0.2.1 → 0.2.3

package/dist/fold/bootstrap-anchor.js

@@ -0,0 +1,28 @@
+import { join } from 'node:path';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { storeOf } from "../land/ledger.js";
+/** Read the existing place-local root of trust. Names and current claims select no authority. */
+export function bootstrapAnchor(root) {
+    const store = storeOf(root);
+    const files = existsSync(store) ? readdirSync(store).filter(name => name.endsWith('.keys')).sort() : [];
+    if (!files.length)
+        return undefined;
+    const candidates = files.map(name => {
+        let keys;
+        try {
+            keys = JSON.parse(readFileSync(join(store, name), 'utf8'));
+        }
+        catch {
+            throw Error('REFUSE·act bootstrap anchor is unreadable');
+        }
+        const anchors = Object.values(keys ?? {}), anchor = anchors[0];
+        if (anchors.length !== 1 || !anchor || typeof anchor.id !== 'string' || !anchor.id || typeof anchor.publicKey !== 'string' || !anchor.publicKey || !Array.isArray(anchor.coverage) || !anchor.coverage.length || anchor.coverage.some(scope => typeof scope !== 'string' || !scope))
+            throw Error('REFUSE·act historical admission requires one bootstrap anchor');
+        return anchor;
+    });
+    const identities = new Set(candidates.map(anchor => JSON.stringify([anchor.id, anchor.publicKey, [...new Set(anchor.coverage)].sort()])));
+    if (identities.size !== 1)
+        throw Error('REFUSE·act conflicting bootstrap anchors');
+    const anchor = candidates[0];
+    return { id: anchor.id, publicKey: anchor.publicKey, coverage: anchor.coverage };
+}

package/dist/fold/ceilings.js

@@ -127,3 +127,16 @@ export function foldCeilings(input) {
         readings: said,
     };
 }
+function listed(misses) {
+    const by = new Map();
+    for (const o of misses)
+        by.set(o.ceiling, [...(by.get(o.ceiling) ?? []), o.question === o.ceiling ? o.got : `${o.question}=${o.got}`]);
+    return [...by].map(([scope, got]) => `${scope} · ${got.length > 4 ? `${got.slice(0, 4).join(' ')} +${got.length - 4}` : got.join(' ')}`);
+}
+/** One summary for fresh and retained judgments over the same declared bounds. */
+export function ceilingSummary(fold, total, shared = new Set()) {
+    return { read: fold.read.length, total, unread: fold.unread.map(line => fieldOf(line, 'scope')),
+        vacuous: fold.vacuous.map(line => fieldOf(line, 'scope')),
+        short: listed(fold.over.filter(one => one.side === 'short' && !shared.has(one.question))),
+        over: listed(fold.over.filter(one => one.side === 'over')) };
+}

package/dist/fold/own.js

@@ -27,6 +27,12 @@ import { writtenIn } from "./signed.js";
 import { laidDiffers } from "./laid.js";
 import { heldBytes } from "../land/held.js";
 import { capsuleAt, placesIn, worldAt } from "./places.js";
+/** Measurements of this invocation; never evidence of an earlier kept fold. */
+export function currentActReadings(under) {
+    const receipts = receiptsSeen();
+    return placeOnly({ idle: idleCount(), s: actSeconds(), 'walk-read': receipts.count, 'walk-ms': receipts.ms,
+        'kept-folds-read-under-another-instrument': foldsElsewhere() }, under);
+}
 const entered = { foreign: 0 };
 /** Host and instrument measurements. Domain contracts require their selected readers; missing readings are not fabricated zeroes. */
 function shipped(root, store, standing, under) {
@@ -193,12 +199,8 @@ export function ownReadings(input) {
         ...Object.fromEntries(standing.filter((line) => isCeiling(line) && (fieldOf(line, 'measure') === 'reader-modules' || fieldOf(line, 'scope').split('/').pop() === 'reader-modules'))
             .flatMap((line) => ((place) => place === undefined ? [] : [[fieldOf(line, 'scope'), tree(() => exporting(observed, `${place}/`, ['observe', 'run']))]])(fieldOf(line, 'scope').split('/').find((step) => capsuleAt(root, step))))),
         ...ownFrom(ceilingsNamed(standing, 'world-lines-outside-their-capsule').find((line) => fieldOf(line, 'form') === 'interval'), 'world-lines-outside-their-capsule', tree(() => outsideTheirCapsule(root, standing, standing).length)),
-        idle: idleCount(),
-        s: actSeconds(),
+        ...currentActReadings(),
         'cli-verbs': VERB_NAMES.length,
-        'walk-read': receiptsSeen().count,
-        'walk-ms': receiptsSeen().ms,
-        'kept-folds-read-under-another-instrument': tree(() => foldsElsewhere()),
         'accepts-that-refolded': tree(() => counted(store, standing, 'beat/accept', 'folded')),
         ...(keyOf(store, 'attest') === undefined ? {} : { [`${keyOf(store, 'attest')}-ms`]: tree(() => attestBeat(store, standing)) }),
         ship: took('ship', () => shipped(root, store, standing, under)),

package/dist/fold/signers.js

@@ -1,11 +1,9 @@
-import { existsSync, join } from "../host/io.js";
+import { bootstrapAnchor } from "./bootstrap-anchor.js";
 import { authorityOf, isKeyClaim, signersOf } from '@lapxo/topos/wire';
 import { verifiesFields } from "../land/sign.js";
-import { fieldOf, selfName, parsedLine as parse } from "./claims.js";
+import { fieldOf, parsedLine as parse } from "./claims.js";
 import { keyFor, lockStanding } from "./keys.js";
-import { storeRoot } from "../host/ports/store.js";
 import { storeOf } from "../land/ledger.js";
-import { observeText } from "../observe/files.js";
 /** A lock line about the signers: the authority fold reads it. */
 export function isSignerLock(line) {
     const got = parse(line);
@@ -38,11 +36,9 @@ export function writerFor(standing, kind) {
     return undefined;
 }
 export function publicKeyOf(root, keyId) {
-    const at = [join(storeRoot(root), `${selfName()}.keys`), join(storeOf(root), `${selfName()}.keys`)].find((one) => existsSync(one));
-    const keys = at === undefined ? {} : JSON.parse(observeText(at) ?? '{}');
-    const anchored = keys[keyId]?.publicKey;
-    if (anchored !== undefined)
-        return anchored;
+    const anchor = bootstrapAnchor(root);
+    if (anchor?.id === keyId)
+        return anchor.publicKey;
     const said = lockStanding(storeOf(root))
         .find((line) => fieldOf(line, 'scope') === `keys/${keyId}` && fieldOf(line, 'measure') === 'public-key' && fieldOf(line, 'value') !== 'withdraw');
     return said === undefined ? undefined : fieldOf(said, 'value');

package/dist/host/native/loader.js

@@ -7,6 +7,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import { sha256 as digest } from "../hash.js";
+import { compareStrings as order } from "../order.js";
 import { realpathSync } from 'node:fs';
 import { dirname, join, relative, isAbsolute, sep } from 'node:path';
 import { readBoundedFile } from "./bounded-file.js";
@@ -70,7 +71,6 @@ export function installNativeResolutionReuse(declaration) {
                 fail('invalid/ambiguous logical library coordinate');
             namedCoordinates.add(coordinate);
         }
-    const order = (a, b) => a < b ? -1 : a > b ? 1 : 0;
     const identity = digest(Buffer.from(JSON.stringify([declaration.platform, files.map(member => [member.path, member.digest, member.bytes]).sort((a, b) => order(String(a[0]), String(b[0]))), [...libraries].sort(([a], [b]) => order(a, b)).map(([name, manifest]) => [name, manifest, coordinates.get(name) ?? null])])));
     if (resolutionIdentity !== undefined) {
         if (identity !== resolutionIdentity)

package/dist/host/native/module-closure.d.ts

@@ -0,0 +1,35 @@
+export interface ModuleClosureMember {
+    readonly digest: string;
+    readonly source: string;
+}
+export interface ModuleClosureSnapshot {
+    readonly identity: string;
+    readonly entry: string;
+    readonly members: ReadonlyMap<string, ModuleClosureMember>;
+}
+export interface ModuleClosureReading {
+    readonly snapshot: string;
+    readonly coordinate: string;
+    readonly digest: string;
+}
+export interface ModuleClosureLimits {
+    readonly members: number;
+    readonly bytes: number;
+    readonly portableESM?: boolean;
+    readonly signal?: AbortSignal;
+}
+/** Host-selected archive and entry, never a verifier assertion from the program.
+ * This proves content identity only; standing admission and runtime capabilities
+ * are separate prerequisites. Binary resources are not executable text members.
+ */
+export declare function moduleSnapshot(archive: Uint8Array, expected: string, entry: string): ModuleClosureSnapshot;
+/** The host supplies authenticated snapshot identities and its library resolver.
+ * Each reached text member is verified here against its exact UTF-8 bytes.
+ * Authentication of the snapshot envelope remains a separate host prerequisite.
+ * A capsule cannot select either verifier or resolver.
+ * This reads declared module edges, not arbitrary I/O or a JavaScript sandbox. Computed edges are unpaid, never absent.
+ * Activation requires an admitted host policy; existing inventory callers are not silently changed.
+ */
+export declare function moduleClosure(snapshot: ModuleClosureSnapshot, library: (specifier: string, parent: ModuleClosureSnapshot) => ModuleClosureSnapshot | undefined): readonly ModuleClosureReading[];
+/** Multiple needs share the existing traversal and one optional act budget. */
+export declare function moduleClosures(snapshots: readonly ModuleClosureSnapshot[], library: (specifier: string, parent: ModuleClosureSnapshot) => ModuleClosureSnapshot | undefined, limits?: ModuleClosureLimits): readonly ModuleClosureReading[];

package/dist/host/native/module-closure.js

@@ -38,7 +38,14 @@ export function moduleSnapshot(archive, expected, entry) {
  * Activation requires an admitted host policy; existing inventory callers are not silently changed.
  */
 export function moduleClosure(snapshot, library) {
+    return moduleClosures([snapshot], library);
+}
+/** Multiple needs share the existing traversal and one optional act budget. */
+export function moduleClosures(snapshots, library, limits) {
+    if (limits && (!Number.isSafeInteger(limits.members) || limits.members < 1 || !Number.isSafeInteger(limits.bytes) || limits.bytes < 1))
+        throw Error('REFUSE·module closure missing input resources');
     const seen = new Map();
+    let totalBytes = 0;
     const coordinate = (name) => {
         const normalized = posix.normalize(name);
         if (!name || name.includes('\0') || name.includes('\\') || posix.isAbsolute(name) || normalized === '..' || normalized.startsWith('../'))
@@ -46,12 +53,19 @@ export function moduleClosure(snapshot, library) {
         return normalized;
     };
     const walk = (one, name) => {
+        if (limits?.signal?.aborted)
+            throw Error('REFUSE·module closure cancelled');
         const at = coordinate(name), key = JSON.stringify([one.identity, at]);
+        if (limits?.portableESM && /[%?#]/.test(at))
+            throw Error('REFUSE·module closure unsupported URL coordinate ' + at);
         const member = one.members.get(at);
         if (member === undefined)
             throw Error('REFUSE·module closure missing ' + one.identity + ' ' + at);
         if (typeof member.source !== 'string' || !/^sha256:[0-9a-f]{64}$/.test(member.digest))
             throw Error('REFUSE·module closure unnamed bytes ' + one.identity + ' ' + at);
+        const size = Buffer.byteLength(member.source, 'utf8');
+        if (limits && !seen.has(key) && (seen.size >= limits.members || size > limits.bytes - totalBytes))
+            throw Error('REFUSE·module closure input resources');
         const bytes = Buffer.from(member.source, 'utf8');
         if (bytes.toString('utf8') !== member.source)
             throw Error('REFUSE·module closure invalid UTF-8 text ' + one.identity + ' ' + at);
@@ -63,18 +77,34 @@ export function moduleClosure(snapshot, library) {
                 throw Error('REFUSE·module closure conflicting member ' + one.identity + ' ' + at);
             return;
         }
+        totalBytes += size;
         seen.set(key, { snapshot: one.identity, coordinate: at, digest: member.digest });
+        if (limits?.portableESM && !['.js', '.json'].includes(posix.extname(at)))
+            throw Error('REFUSE·module closure unsupported ESM member ' + at);
         // JSON is data under the loader contract, not module syntax.
-        if (posix.extname(at) === '.json')
+        if (posix.extname(at) === '.json') {
+            if (limits?.portableESM) {
+                try {
+                    JSON.parse(member.source);
+                }
+                catch {
+                    throw Error('REFUSE·module closure invalid JSON member ' + at);
+                }
+            }
             return;
-        const syntax = moduleImportSyntax(member.source, at);
+        }
+        const syntax = moduleImportSyntax(member.source, at, limits?.portableESM ? { esmOnly: true } : undefined);
         if (syntax.unresolved.length)
             throw Error('REFUSE·module closure unresolved ' + at + ' ' + syntax.unresolved.join(' · '));
         for (const specifier of syntax.imports) {
+            if (limits?.portableESM && /[%?#\\]/.test(specifier))
+                throw Error('REFUSE·module closure unsupported URL specifier ' + specifier + ' from ' + at);
             // createRequire/registerHooks can select executable edges not present in this graph.
             // Their runtime closure needs its own host contract; an arbitrary alias is not a literal edge.
             if (specifier === 'node:module' || specifier === 'module')
                 throw Error('REFUSE·module closure runtime loader requires declared closure ' + specifier + ' from ' + at);
+            if (limits?.portableESM && (specifier.startsWith('node:') || builtinModules.includes(specifier)))
+                throw Error('REFUSE·module closure host builtin in portable delivery ' + specifier + ' from ' + at);
             if (specifier.startsWith('node:')) {
                 if (!builtinModules.includes(specifier) && !builtinModules.includes(specifier.slice(5)))
                     throw Error('REFUSE·module closure unknown builtin ' + specifier + ' from ' + at);
@@ -94,6 +124,7 @@ export function moduleClosure(snapshot, library) {
             walk(pinned, pinned.entry);
         }
     };
-    walk(snapshot, snapshot.entry);
+    for (const snapshot of snapshots)
+        walk(snapshot, snapshot.entry);
     return [...seen.values()];
 }

package/dist/host/native/module-delivery.d.ts

@@ -0,0 +1,62 @@
+import { type ModuleClosureSnapshot, type ModuleClosureLimits } from './module-closure.ts';
+export { moduleSnapshot, type ModuleClosureSnapshot } from './module-closure.ts';
+export interface ClosureDeliveryLimits extends Omit<ModuleClosureLimits, 'portableESM'> {
+    readonly responseBytes: number;
+}
+export interface ClosureNotice {
+    readonly snapshot: string;
+    readonly coordinate: string;
+    readonly digest: string;
+    readonly source: string;
+}
+export interface ClosureDeliveryManifest {
+    readonly format: 'esm-file-closure/1';
+    readonly needs: readonly {
+        name: string;
+        snapshot: string;
+        entry: string;
+    }[];
+    readonly modules: readonly {
+        snapshot: string;
+        coordinate: string;
+        digest: string;
+        path: string;
+    }[];
+    readonly libraries: readonly {
+        parent: string;
+        specifier: string;
+        snapshot: string;
+        entry: string;
+    }[];
+    readonly notices: readonly {
+        snapshot: string;
+        coordinate: string;
+        digest: string;
+        path: string;
+    }[];
+}
+export interface ClosureDelivery {
+    readonly closure: string;
+    readonly digest: string;
+    readonly bytes: Uint8Array;
+    readonly manifest: ClosureDeliveryManifest;
+    readonly files: readonly {
+        path: string;
+        source: string;
+    }[];
+    readonly importMap: {
+        imports: Record<string, string>;
+        scopes: Record<string, Record<string, string>>;
+    };
+}
+type Library = (specifier: string, parent: ModuleClosureSnapshot) => ModuleClosureSnapshot | undefined;
+/** The host selects already authenticated snapshots and resolution, never the
+ * offered program. This prepares unchanged ESM files, not a JS sandbox, signer,
+ * browser host or symbol-pruning bundler. Existing native/Acorn routes remain.
+ */
+export declare function deliverModuleClosure(needs: readonly string[], entries: ReadonlyMap<string, ModuleClosureSnapshot>, library: Library, limits: ClosureDeliveryLimits, notices?: readonly ClosureNotice[]): ClosureDelivery;
+/** Verify exact pinned delivery bytes and run the same pre-execution closure
+ * verifier again over the delivered set. No callbacks, install paths or verifier
+ * chosen by the payload. The returned import map is derived, never trusted input.
+ */
+export declare function verifyModuleDelivery(bytes: Uint8Array, expected: string, limits: ClosureDeliveryLimits): ClosureDelivery;

package/dist/host/native/module-delivery.js

@@ -0,0 +1,151 @@
+import { posix } from 'node:path';
+import { sha256, isSha256 } from "../hash.js";
+import { archiveCoordinate } from "../archive.js";
+import { compareStrings as compare } from "../order.js";
+import { moduleClosures } from "./module-closure.js";
+export { moduleSnapshot } from "./module-closure.js";
+const fail = (why) => { throw Error('REFUSE·closure delivery ' + why); };
+const key = (identity, coordinate) => JSON.stringify([identity, coordinate]);
+const pathOf = (identity, coordinate) => {
+    if (!isSha256(identity))
+        return fail('snapshot identity is not SHA-256');
+    return 'modules/' + identity.slice(7) + '/' + coordinate;
+};
+const urlOf = (path) => './' + path.split('/').map(encodeURIComponent).join('/');
+const resourceLimits = (limits) => {
+    if (!limits || !Number.isSafeInteger(limits.members) || limits.members < 1 || !Number.isSafeInteger(limits.bytes) || limits.bytes < 1 || !Number.isSafeInteger(limits.responseBytes) || limits.responseBytes < 1)
+        fail('missing resources');
+    if (limits.signal?.aborted)
+        fail('cancelled');
+};
+/** The host selects already authenticated snapshots and resolution, never the
+ * offered program. This prepares unchanged ESM files, not a JS sandbox, signer,
+ * browser host or symbol-pruning bundler. Existing native/Acorn routes remain.
+ */
+export function deliverModuleClosure(needs, entries, library, limits, notices = []) {
+    resourceLimits(limits);
+    if (!Array.isArray(notices) || notices.length >= limits.members)
+        fail('notice resources');
+    let noticeBytes = 0;
+    const noticePaths = new Set();
+    const retainedNotices = notices.map(n => {
+        if (!n || typeof n.coordinate !== 'string' || archiveCoordinate(n.coordinate) !== n.coordinate || typeof n.source !== 'string' || !isSha256(n.digest) || sha256(n.source) !== n.digest || (noticeBytes += Buffer.byteLength(n.source)) >= limits.bytes)
+            fail('notice bytes/resources');
+        const path = 'notices/' + pathOf(n.snapshot, n.coordinate).slice('modules/'.length);
+        if (noticePaths.has(path))
+            fail('duplicate notice');
+        noticePaths.add(path);
+        return { snapshot: n.snapshot, coordinate: n.coordinate, digest: n.digest, path };
+    }).sort((a, b) => compare(a.path, b.path));
+    if (!Array.isArray(needs) || !needs.length || needs.length > limits.members || needs.some(n => typeof n !== 'string' || !n || Buffer.byteLength(n) > limits.bytes))
+        fail('missing/oversized needs');
+    const requested = [...new Set(needs)].sort(compare), snapshots = new Map(), bindings = new Map();
+    const hold = (one) => {
+        if (!one || !isSha256(one.identity))
+            return fail('snapshot identity is not SHA-256');
+        const old = snapshots.get(one.identity);
+        // Different entry points may share one immutable snapshot, not different members.
+        if (old && old.members !== one.members)
+            fail('ambiguous snapshot members');
+        snapshots.set(one.identity, one);
+        return one;
+    };
+    const roots = requested.map(name => { const one = entries.get(name); if (!one)
+        return fail('unknown need ' + name); return hold(one); });
+    const reached = moduleClosures(roots, (specifier, parent) => {
+        const found = library(specifier, parent);
+        if (!found)
+            return;
+        const one = hold(found), at = key(parent.identity, specifier), binding = { parent: parent.identity, specifier, snapshot: one.identity, entry: one.entry }, old = bindings.get(at);
+        if (old && (old.snapshot !== one.identity || old.entry !== one.entry))
+            fail('ambiguous library resolution');
+        if (!old && bindings.size >= limits.members)
+            fail('library resources');
+        bindings.set(at, binding);
+        return one;
+    }, { ...limits, members: limits.members - notices.length, bytes: limits.bytes - noticeBytes, portableESM: true });
+    if (notices.some(n => !reached.some(r => r.snapshot === n.snapshot)))
+        fail('notice outside reached snapshots');
+    const modules = [...reached].sort((a, b) => compare(key(a.snapshot, a.coordinate), key(b.snapshot, b.coordinate))).map(r => ({ ...r, path: pathOf(r.snapshot, r.coordinate) }));
+    const files = modules.map(r => {
+        const source = snapshots.get(r.snapshot)?.members.get(r.coordinate)?.source;
+        if (source === undefined || sha256(source) !== r.digest)
+            fail('snapshot changed during delivery');
+        return { path: r.path, source: source };
+    });
+    for (const n of retainedNotices)
+        files.push({ path: n.path, source: notices.find(one => one.snapshot === n.snapshot && one.coordinate === n.coordinate).source });
+    const manifest = { format: 'esm-file-closure/1', needs: requested.map((name, i) => ({ name, snapshot: roots[i].identity, entry: posix.normalize(roots[i].entry) })), modules, libraries: [...bindings.values()].sort((a, b) => compare(key(a.parent, a.specifier), key(b.parent, b.specifier))), notices: retainedNotices };
+    const closure = sha256(JSON.stringify(manifest));
+    const bytes = Buffer.from(JSON.stringify({ manifest, files }), 'utf8');
+    if (bytes.length > limits.responseBytes)
+        fail('response resources');
+    if (limits.signal?.aborted)
+        fail('cancelled');
+    const imports = Object.fromEntries(manifest.needs.map(n => [n.name, urlOf(pathOf(n.snapshot, n.entry))]));
+    const scopes = {};
+    for (const b of manifest.libraries) {
+        const scope = './modules/' + b.parent.slice(7) + '/';
+        const values = scopes[scope] ?? (scopes[scope] = Object.create(null));
+        values[b.specifier] = urlOf(pathOf(b.snapshot, posix.normalize(b.entry)));
+    }
+    return { closure, digest: sha256(bytes), bytes: new Uint8Array(bytes), manifest, files, importMap: { imports, scopes } };
+}
+/** Verify exact pinned delivery bytes and run the same pre-execution closure
+ * verifier again over the delivered set. No callbacks, install paths or verifier
+ * chosen by the payload. The returned import map is derived, never trusted input.
+ */
+export function verifyModuleDelivery(bytes, expected, limits) {
+    resourceLimits(limits);
+    if (!(bytes instanceof Uint8Array) || bytes.byteLength > limits.responseBytes || !isSha256(expected) || sha256(bytes) !== expected)
+        fail('bundle bytes differ or exceed resources');
+    let value;
+    try {
+        value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+    }
+    catch {
+        return fail('invalid JSON bytes');
+    }
+    const manifest = value?.manifest;
+    if (manifest?.format !== 'esm-file-closure/1' || !Array.isArray(manifest.needs) || !Array.isArray(manifest.modules) || !Array.isArray(manifest.libraries) || !Array.isArray(manifest.notices) || !Array.isArray(value.files) || manifest.modules.length + manifest.notices.length > limits.members || value.files.length !== manifest.modules.length + manifest.notices.length || manifest.needs.length > limits.members || manifest.libraries.length > limits.members)
+        fail('invalid manifest resources');
+    const snapshots = new Map(), files = new Map();
+    let size = 0;
+    for (const file of value.files) {
+        if (typeof file?.path !== 'string' || typeof file.source !== 'string' || files.has(file.path) || (size += Buffer.byteLength(file.source)) > limits.bytes)
+            fail('invalid/duplicate file resources');
+        files.set(file.path, file.source);
+    }
+    for (const m of manifest.modules) {
+        if (!m || typeof m.coordinate !== 'string' || typeof m.path !== 'string' || m.path !== pathOf(m.snapshot, m.coordinate) || !isSha256(m.digest))
+            fail('invalid module');
+        const source = files.get(m.path);
+        if (source === undefined || sha256(source) !== m.digest)
+            fail('module bytes differ');
+        const members = snapshots.get(m.snapshot) ?? new Map();
+        if (members.has(m.coordinate))
+            fail('duplicate module');
+        members.set(m.coordinate, { source, digest: m.digest });
+        snapshots.set(m.snapshot, members);
+    }
+    const snapshot = (identity, entry) => { const members = snapshots.get(identity); if (!members || typeof entry !== 'string')
+        return fail('unknown snapshot/entry'); return { identity, entry, members }; };
+    const entries = new Map();
+    for (const n of manifest.needs) {
+        if (typeof n?.name !== 'string' || entries.has(n.name))
+            fail('invalid/duplicate need');
+        entries.set(n.name, snapshot(n.snapshot, n.entry));
+    }
+    const bindings = new Map();
+    for (const b of manifest.libraries) {
+        if (typeof b?.parent !== 'string' || typeof b.specifier !== 'string' || bindings.has(key(b.parent, b.specifier)))
+            fail('invalid/duplicate library');
+        bindings.set(key(b.parent, b.specifier), snapshot(b.snapshot, b.entry));
+    }
+    const notices = manifest.notices.map(n => { if (!n || typeof n.path !== 'string' || !files.has(n.path))
+        return fail('missing notice'); return { snapshot: n.snapshot, coordinate: n.coordinate, digest: n.digest, source: files.get(n.path) }; });
+    const prepared = deliverModuleClosure([...entries.keys()], entries, (specifier, parent) => bindings.get(key(parent.identity, specifier)), limits, notices);
+    if (prepared.digest !== expected)
+        fail('noncanonical, extra or unresolved delivery members');
+    return prepared;
+}

package/dist/host/native/module-syntax.js

@@ -7,7 +7,7 @@ const require = nodeModule.createRequire(import.meta.url);
 const { parse } = require('acorn');
 const stripTypeScriptTypes = nodeModule.stripTypeScriptTypes;
 /** Syntax inventory is not an execution-closure certificate: unresolved expressions stay explicit. */
-export function moduleImportSyntax(source, coordinate) {
+export function moduleImportSyntax(source, coordinate, options) {
     const code = extname(coordinate) === '.ts' ? stripTypeScriptTypes(source, { mode: 'transform' }) : source;
     let tree;
     try {
@@ -18,12 +18,12 @@ export function moduleImportSyntax(source, coordinate) {
     }
     const found = new Set(), unresolved = new Set();
     const literal = stringLiteral;
-    const visit = (node, parent, key) => {
+    const visit = (node, parent, key, reexportSource = false) => {
         if (!node || typeof node !== 'object')
             return;
         if (Array.isArray(node)) {
             for (const child of node)
-                visit(child, parent, key);
+                visit(child, parent, key, reexportSource);
             return;
         }
         const n = node;
@@ -32,7 +32,11 @@ export function moduleImportSyntax(source, coordinate) {
         if (n['type'] === 'Identifier' && n['name'] === 'require') {
             const direct = parent?.['type'] === 'CallExpression' && key === 'callee';
             const namedProperty = (parent?.['type'] === 'MemberExpression' && key === 'property' && !parent['computed']) || ((parent?.['type'] === 'Property' || parent?.['type'] === 'MethodDefinition') && key === 'key' && !parent['computed'] && !parent['shorthand']);
-            if (!direct && !namedProperty)
+            // Declaration names are not loader references. This does not resolve shadowing:
+            // references to a binding named require remain conservative, including local calls.
+            const declarationName = ((parent?.['type'] === 'ImportSpecifier' || parent?.['type'] === 'ImportDefaultSpecifier' || parent?.['type'] === 'ImportNamespaceSpecifier') && (key === 'imported' || key === 'local')) || (parent?.['type'] === 'FunctionDeclaration' && key === 'id');
+            const reexportName = parent?.['type'] === 'ExportSpecifier' && (key === 'exported' || (key === 'local' && reexportSource));
+            if (!direct && !namedProperty && !declarationName && !reexportName)
                 unresolved.add('require reference at ' + String(n['start']));
         }
         let specifier;
@@ -44,6 +48,8 @@ export function moduleImportSyntax(source, coordinate) {
         if (n['type'] === 'CallExpression') {
             const callee = n['callee'];
             if (callee?.['type'] === 'Identifier' && callee['name'] === 'require') {
+                if (options?.esmOnly)
+                    throw Error('REFUSE·module closure CommonJS load in ESM delivery ' + coordinate);
                 specifier = literal(n['arguments'][0]);
                 if (specifier === undefined)
                     unresolved.add('require expression at ' + String(n['start']));
@@ -52,7 +58,7 @@ export function moduleImportSyntax(source, coordinate) {
         if (specifier !== undefined)
             found.add(specifier);
         for (const [childKey, child] of Object.entries(n))
-            visit(child, n, childKey);
+            visit(child, n, childKey, n['type'] === 'ExportNamedDeclaration' ? n['source'] !== null && n['source'] !== undefined : reexportSource);
     };
     visit(tree);
     return { imports: [...found], unresolved: [...unresolved] };

package/dist/host/order.js

@@ -0,0 +1,2 @@
+/** Locale-independent UTF-16 code-unit ordering, shared by host delivery formats. */
+export const compareStrings = (a, b) => a < b ? -1 : a > b ? 1 : 0;

package/docs/contracts/closure-delivery.md

@@ -0,0 +1,23 @@
+# Verified executable closure delivery
+
+Needs are arbitrary declared names, not a kernel profile enumeration.
+
+All requested entries share the existing moduleClosure traversal; no second walker, parser or algebra.
+
+Host requires already authenticated snapshot identities; a bundle digest establishes content identity, not authority or correctness.
+
+Delivery preserves each reached JS/JSON member and explicitly pinned notices byte for byte. Separate digests identify the closure manifest and the exact UTF-8 JSON container.
+
+Canonical delivery sorts needs, reached modules, library bindings and notices; duplicate needs do not duplicate code; unsupported executable forms refuse by name.
+
+Mandatory member, source byte and response byte budgets apply before delivery. Pre-aborted or observed cancellation refuses. Synchronous work is not a preemptible execution sandbox.
+
+Portable ESM delivery refuses host builtins, runtime loader access, CommonJS loads, calculated/escaped loader expressions and unsupported URL spellings before entry execution.
+
+Consumer verifies the expected container digest and repeats the same closure preflight over exactly the delivered members. Derived import maps are never trusted as authority.
+
+The host must verify actual mounted bytes again before execution; the test host demonstrates this but is not a public browser host.
+
+Existing native, program and worker custody remain unchanged. Acorn routes stay explicitly retained under A-F gate.
+
+No external fetch or general demand resolver is introduced. Missing bytes remain outside completed delivery and must be resolved by the existing host contract.

package/docs/contracts/closure-delivery.publication.json

@@ -0,0 +1,25 @@
+{
+  "scope": "contract/published/closure-delivery",
+  "members": [
+    {
+      "role": "contract",
+      "path": "docs/contracts/closure-delivery.md",
+      "digest": "sha256:bdadeefcf8042749e642a453adc7d07944ceab3fbd62de46209ea3ed25d05c2e"
+    },
+    {
+      "role": "yes",
+      "path": "samples/module-delivery/inputs/delivery.json",
+      "digest": "sha256:a6df1d11537a0792c9772b1874c7e127e0fda22203f756d6f0eb104d072a9df1"
+    },
+    {
+      "role": "vector",
+      "path": "vectors/native/module-delivery.vector.json",
+      "digest": "sha256:3de9f160f89764e1153a2719ab04447142fe187bf476b3060d860e81e9c37c02"
+    },
+    {
+      "role": "no",
+      "path": "samples/no/module-delivery/delivery.json",
+      "digest": "sha256:f95b1c3129896baaecb4ae7860afc11dcaaef0a2e47221b73044bc5a4681181f"
+    }
+  ]
+}

package/docs/contracts/readme.publication.json

@@ -4,7 +4,7 @@
     {
       "role": "contract",
       "path": "README.md",
-      "digest": "sha256:183fe27e7a8bfdb04f4aefaa785f2b1845da1c5a93562a06a300175a960c72da"
+      "digest": "sha256:bc8277eaef68f8ab8a049607003502a1979fb58a36f9468d6224ec14df7e131f"
     },
     {
       "role": "yes",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lapxo/bound",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "type": "module",
   "description": "Read the bounds you already wrote, fold them, and name the contradictions.",
   "main": "dist/cli/verb.js",
@@ -28,6 +28,10 @@
     "./reference/native": {
       "types": "./dist/host/reference-native-api.d.ts",
       "default": "./dist/host/reference-native-api.js"
+    },
+    "./closure/native": {
+      "types": "./dist/host/native/module-delivery.d.ts",
+      "default": "./dist/host/native/module-delivery.js"
     }
   },
   "scripts": {
@@ -162,13 +166,21 @@
     "docs/contracts/readme.publication.json",
     "samples/readme/yes.json",
     "samples/readme/no.json",
-    "vectors/native/readme.vector.json"
+    "vectors/native/readme.vector.json",
+    "samples/engine-place/inputs/closure.json",
+    "dist/host/native/module-delivery.d.ts",
+    "dist/host/native/module-closure.d.ts",
+    "docs/contracts/closure-delivery.md",
+    "docs/contracts/closure-delivery.publication.json",
+    "samples/module-delivery/inputs/delivery.json",
+    "samples/no/module-delivery/delivery.json",
+    "vectors/native/module-delivery.vector.json"
   ],
   "author": "Lapxo",
   "license": "MIT",
   "dependencies": {
-    "@lapxo/obligations": "0.3.5",
-    "@lapxo/topos": "^0.2.0",
+    "@lapxo/obligations": "0.4.3",
+    "@lapxo/topos": "^0.2.1",
     "acorn": "8.19.0"
   },
   "devDependencies": {