@lapxo/bound 0.1.3 → 0.1.4

package/dist/host/lifetime.js

@@ -0,0 +1,40 @@
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+// This is a host mechanism, not a wire reader or a provider. The parent supplies its already selected policy.
+const request = JSON.parse(readFileSync(0, 'utf8'));
+if (!Number.isSafeInteger(request.limits.timeoutMs) || request.limits.timeoutMs <= 0 || !Number.isSafeInteger(request.limits.responseBytes) || request.limits.responseBytes <= 0)
+    throw Error('REFUSE·reader invalid process limits');
+const grouped = process.platform !== 'win32';
+const child = spawn(request.command, [...request.args], { cwd: request.cwd, env: request.env, detached: grouped, stdio: ['pipe', 'pipe', 'pipe'] });
+const stdout = [], stderr = [];
+let size = 0, failure, finished = false;
+const cancel = () => { if (child.pid === undefined)
+    return; try {
+    if (grouped)
+        process.kill(-child.pid, 'SIGKILL');
+    else
+        child.kill('SIGKILL');
+}
+catch { } };
+const refuse = (why) => { failure ?? (failure = why); cancel(); };
+const receive = (chunks, bytes) => { size += bytes.length; if (size > request.limits.responseBytes) {
+    refuse('response exceeds declared byte bound');
+    return;
+} chunks.push(bytes); };
+child.stdout.on('data', (bytes) => receive(stdout, bytes));
+child.stderr.on('data', (bytes) => receive(stderr, bytes));
+child.stdin.on('error', error => { if (!finished)
+    refuse(`input failed: ${error.message}`); });
+const timer = setTimeout(() => refuse('declared timeout exhausted'), request.limits.timeoutMs);
+const finish = (status, signal) => {
+    if (finished)
+        return;
+    finished = true;
+    clearTimeout(timer);
+    cancel();
+    const result = { stdout: failure ? '' : Buffer.concat(stdout).toString('utf8'), stdoutBytes: failure ? '' : Buffer.concat(stdout).toString('base64'), stderr: failure ? '' : Buffer.concat(stderr).toString('utf8'), status, signal, ...(failure ? { failure } : {}) };
+    process.stdout.write(JSON.stringify(result));
+};
+child.on('error', error => { failure = error.message; finish(null, null); });
+child.on('close', finish);
+child.stdin.end(request.input);

package/dist/host/objects.js

@@ -10,7 +10,7 @@ export async function admittedObjects(root, lines, emit = () => { }) {
     if (history.kind !== 'fact')
         throw Error(`REFUSE·wire ${history.why}`);
     const authority = authorityFor(lines, rootSigner(root), signaturesOf(storeOf(root)).admitted);
-    const context = await objectProvider(history.value.objects, history.value.configuration, { admit: fields => authority.of(canonical(fields)).kind === 'admitted', emit, topos: toposAt, module: contextModuleAt });
+    const context = await objectProvider(history.value.objects, history.value.configuration, { admit: fields => authority.of(canonical(fields)).kind === 'admitted', emit, topos: digest => toposAt(digest, storeOf(root)), module: digest => contextModuleAt(digest, storeOf(root)) });
     const checked = validateObjectContext(history.value.objects, context);
     if (checked.kind !== 'fact')
         throw Error(`REFUSE·context ${checked.why}`);

package/dist/host/ports/transport.d.ts

@@ -0,0 +1 @@
+export declare function transportBytes(location: string, digest: string, lines: readonly string[]): Promise<Uint8Array>;

package/dist/host/ports/transport.js

@@ -0,0 +1,48 @@
+import { readFileSync } from 'node:fs';
+import { contentRequest, transportSelection, parse } from '@lapxo/topos/wire';
+import { boundedProcess } from "../process-lifetime.js";
+import { fetchBytes } from "../adapters/transport/http.js";
+export async function transportBytes(location, digest, lines) {
+    const scheme = new URL(location).protocol.slice(0, -1);
+    const fields = lines.flatMap(line => { const p = parse(line); return p.kind === 'fact' ? [p.value.fields] : []; });
+    const selected = transportSelection(fields, scheme);
+    if (selected === undefined)
+        throw Error(`REFUSE·transport ${scheme} no admitted content-request/1 policy`);
+    if (selected.name === 'fetch') {
+        if (!['http', 'https'].includes(scheme))
+            throw Error(`REFUSE·transport ${scheme} is not supported by this host adapter`);
+        return fetchBytes(location, selected);
+    }
+    const registryPath = process.env['BOUND_TRANSPORTS'];
+    if (!registryPath)
+        throw Error(`REFUSE·transport ${scheme} no host binding for ${selected.name}`);
+    let record;
+    try {
+        const registry = JSON.parse(readFileSync(registryPath, 'utf8'));
+        if (!registry || typeof registry !== 'object' || !Object.prototype.hasOwnProperty.call(registry, selected.name))
+            throw Error();
+        const value = registry[selected.name];
+        if (!value || typeof value !== 'object')
+            throw Error();
+        const f = value;
+        if (f.kind !== 'command' || typeof f.executable !== 'string' || !f.executable || !Array.isArray(f.args) || !f.args.every(x => typeof x === 'string'))
+            throw Error();
+        if (f.environment !== undefined && (!Array.isArray(f.environment) || !f.environment.every(x => typeof x === 'string')))
+            throw Error();
+        const names = (f.environment ?? []);
+        const env = {};
+        if (process.env.PATH !== undefined)
+            env.PATH = process.env.PATH;
+        for (const name of names)
+            if (process.env[name] !== undefined)
+                env[name] = process.env[name];
+        record = { executable: f.executable, args: f.args, env };
+    }
+    catch {
+        throw Error(`REFUSE·transport ${scheme} host binding unavailable or invalid`);
+    }
+    const result = boundedProcess(record.executable, record.args, contentRequest(location, digest, selected), selected, undefined, record.env);
+    if (result.status !== 0 || result.signal !== null)
+        throw Error(`REFUSE·transport ${scheme} failed · status ${result.status ?? result.signal}`);
+    return Buffer.from(result.stdoutBytes ?? '', 'base64');
+}

package/dist/host/process-lifetime.d.ts

@@ -0,0 +1,11 @@
+import type { ReaderLifetime } from '@lapxo/topos/wire';
+export interface ProcessResult {
+    readonly stdout: string;
+    readonly stdoutBytes?: string;
+    readonly stderr: string;
+    readonly status: number | null;
+    readonly signal: NodeJS.Signals | null;
+    readonly failure?: string;
+}
+/** A synchronous fold waits on a supervising host process; the supervisor owns cancellation of its child group. */
+export declare function boundedProcess(command: string, args: readonly string[], input: string, limits: ReaderLifetime, cwd?: string, env?: Readonly<Record<string, string>>): ProcessResult;

package/dist/host/process-lifetime.js

@@ -0,0 +1,12 @@
+import { spawnSync } from 'node:child_process';
+import { processOf } from "../observe/runner.js";
+/** A synchronous fold waits on a supervising host process; the supervisor owns cancellation of its child group. */
+export function boundedProcess(command, args, input, limits, cwd, env) {
+    const run = spawnSync(process.execPath, [processOf('lifetime', 'host')], { input: JSON.stringify({ command, args, input, limits, cwd, env }), encoding: 'utf8', maxBuffer: limits.responseBytes * 12 + 4096 });
+    if (run.error || run.status !== 0)
+        throw Error(`REFUSE·reader lifetime supervisor ${run.error?.message ?? run.status}`);
+    const result = JSON.parse(run.stdout);
+    if (result.failure)
+        throw Error(`REFUSE·reader ${result.failure} · status ${result.status ?? result.signal ?? 'cancelled'}`);
+    return result;
+}

package/dist/host/selected-capsules.js

@@ -1,5 +1,7 @@
 import { capsuleAt } from "./capsule.js";
-import { capsuleOffers } from '@lapxo/topos/standing';
+import { capsuleOffers, providerInputs, providerInputRegions, capsuleDescriptor, assertCapsuleDescriptor } from '@lapxo/topos/standing';
+import { fullDigest } from "./digest.js";
+import { wireAt, parse } from '@lapxo/topos/wire';
 import { selectedTopoi, toposAt } from "./selected-topos.js";
 import { canonical } from '@lapxo/topos/wire';
 import { fieldOf } from "../fold/claims.js";
@@ -8,16 +10,40 @@ import { archiveCoordinate } from "./archive.js";
 /** Only explicit capsule offers request execution. Forms/classes/views do not need an executable alias. */
 export function selectedCapsules(pins, resolve = capsuleAt, select = toposAt, host = ownLock()) {
     return selectedTopoi(pins, select).flatMap(({ digest, topos }) => capsuleOffers(topos).map(offer => {
-        const projections = host.filter(line => fieldOf(line, 'scope').startsWith('dep/') && fieldOf(line, 'role') === 'writes' && fieldOf(line, 'value') === offer.value);
-        if (!projections.length || projections.some(line => !fieldOf(line, 'shape')))
-            throw Error(`REFUSE·pin ${digest} capsule ${offer.value} needs one host projection`);
-        const entries = [...new Set(projections.map(line => archiveCoordinate(fieldOf(line, 'shape'))))];
-        if (entries.length !== 1)
-            throw Error(`REFUSE·pin ${digest} capsule ${offer.value} has conflicting host projections`);
-        const projected = { ...offer, shape: entries[0] };
-        const capsule = resolve(offer.value, projected.shape);
-        if (capsule === undefined)
-            throw Error(`REFUSE·pin ${digest} · ${offer.scope} · offered capsule ${offer.value} unavailable`);
-        return { capsule, offer: canonical(projected) };
+        const load = () => {
+            const projections = host.filter(line => fieldOf(line, 'scope').startsWith('dep/') && fieldOf(line, 'role') === 'writes' && fieldOf(line, 'value') === offer.value);
+            if (!projections.length || projections.some(line => !fieldOf(line, 'shape')))
+                throw Error(`REFUSE·pin ${digest} capsule ${offer.value} needs one host projection`);
+            const entries = [...new Set(projections.map(line => archiveCoordinate(fieldOf(line, 'shape'))))];
+            if (entries.length !== 1)
+                throw Error(`REFUSE·pin ${digest} capsule ${offer.value} has conflicting host projections`);
+            const loaded = resolve(offer.value, entries[0]);
+            if (loaded === undefined)
+                throw Error(`REFUSE·pin ${digest} · ${offer.scope} · offered capsule ${offer.value} unavailable`);
+            return { capsule: loaded, offer: canonical({ ...offer, shape: entries[0] }) };
+        };
+        const descriptor = capsuleDescriptor(topos, offer.scope ?? '');
+        const loaded = descriptor === undefined ? load() : undefined;
+        const capsule = loaded?.capsule ?? {
+            digest: offer.value, selection: `${digest} ${offer.scope}`, ...descriptor, ask: requests => {
+                if (!requests.length)
+                    return [];
+                const actual = load();
+                assertCapsuleDescriptor(descriptor.lines, actual.capsule.lines);
+                return actual.capsule.ask(requests);
+            },
+        };
+        const projected = loaded?.offer ?? canonical(offer);
+        if (!providerInputRegions(topos, offer.scope ?? '').length)
+            return { capsule, offer: projected };
+        const fields = ownLock().flatMap(line => { const p = parse(line); return p.kind === 'fact' ? [p.value.fields] : []; });
+        const wire = wireAt(fields, Number.MAX_SAFE_INTEGER), algorithm = wire && [...wire.digests][0];
+        if (!algorithm)
+            throw Error('REFUSE·input instrument has no admitted digest algorithm');
+        const selected = { ...capsule, selection: `${digest} ${offer.scope}`, ask: requests => capsule.ask(requests.map(request => {
+                const provider = providerInputs(topos, digest, offer.scope ?? '', offer.value, request.region ?? '', bytes => fullDigest(bytes, algorithm));
+                return provider === undefined ? request : { ...request, provider };
+            })) };
+        return { capsule: selected, offer: projected };
     }));
 }

package/dist/host/selected-topos.d.ts

@@ -6,10 +6,10 @@ export interface SelectedTopos {
 }
 export type ToposResolver = (digest: string) => StandingTopos;
 /** Resolve content using the instrument wire's admitted digest algorithms. No transport interpretation. */
-export declare function toposAt(digest: string): StandingTopos;
-export declare function contentAt(digest: string): Uint8Array;
-/** A declared JS context offer uses this host adapter only after selection; execution is not selection. */
-export declare function contextModuleAt(digest: string): string;
+export declare function toposAt(digest: string, store?: string): StandingTopos;
+export declare function contentAt(digest: string, store?: string): Uint8Array;
+/** The declared module runs from the store that supplied its verified bytes. No copy or live-checkout fallback. */
+export declare function contextModuleAt(digest: string, store?: string): string;
 /** Selection verifies standing identity. Requested capabilities verify their artifact bytes separately. */
 export declare function selectedTopoi(pins: readonly string[], resolve?: ToposResolver): readonly SelectedTopos[];
 /** Read a declared wire list without copying a world's claims or executing its offers.

package/dist/host/selected-topos.js

@@ -1,40 +1,18 @@
-import { ContentNeeded } from "./content-needed.js";
-import { createHash } from 'node:crypto';
+import { verifiedContent } from "./content-store.js";
 import { readStanding } from '@lapxo/topos/standing';
 import { parse, wireAt } from '@lapxo/topos/wire';
 import { fieldOf } from "../fold/claims.js";
-import { blobAt } from "../land/ledger.js";
-import { observeFile } from "../observe/files.js";
-import { ownStore, ownLock } from "../observe/runner.js";
 /** Resolve content using the instrument wire's admitted digest algorithms. No transport interpretation. */
-export function toposAt(digest) {
-    const topos = readStanding(Buffer.from(contentAt(digest)).toString('utf8'));
+export function toposAt(digest, store) {
+    const topos = readStanding(Buffer.from(contentAt(digest, store)).toString('utf8'));
     return topos;
 }
-export function contentAt(digest) {
-    const fields = ownLock().flatMap(line => { const got = parse(line); return got.kind === 'fact' ? [got.value.fields] : []; });
-    const wire = wireAt(fields, Number.MAX_SAFE_INTEGER);
-    if (wire === null)
-        throw Error('REFUSE·pin instrument has no admitted wire');
-    const algorithms = wire.digests;
-    const bytesAt = (name) => {
-        const split = name.indexOf(':');
-        const algorithm = name.slice(0, split), hex = name.slice(split + 1);
-        if (split < 1 || !algorithms.has(algorithm) || !/^[a-f0-9]+$/.test(hex))
-            throw Error(`REFUSE·pin ${name} digest is not admitted`);
-        const bytes = observeFile(blobAt(ownStore(), name));
-        if (bytes === undefined)
-            throw new ContentNeeded(name);
-        if (createHash(algorithm).update(bytes).digest('hex') !== hex)
-            throw Error(`REFUSE·pin ${name} content hash mismatch · not laid`);
-        return bytes;
-    };
-    return bytesAt(digest);
+export function contentAt(digest, store) {
+    return verifiedContent(digest, store).bytes;
 }
-/** A declared JS context offer uses this host adapter only after selection; execution is not selection. */
-export function contextModuleAt(digest) {
-    contentAt(digest);
-    return blobAt(ownStore(), digest);
+/** The declared module runs from the store that supplied its verified bytes. No copy or live-checkout fallback. */
+export function contextModuleAt(digest, store) {
+    return verifiedContent(digest, store).path;
 }
 /** Selection verifies standing identity. Requested capabilities verify their artifact bytes separately. */
 export function selectedTopoi(pins, resolve = toposAt) {

package/dist/host/source-content.d.ts

@@ -2,7 +2,7 @@ export interface ContentPort {
     readonly algorithms: ReadonlySet<string>;
     readonly read: (digest: string) => Uint8Array | undefined;
     readonly write: (digest: string, bytes: Uint8Array) => void;
-    readonly fetch: (url: string) => Promise<Uint8Array>;
+    readonly fetch: (url: string, digest?: string) => Promise<Uint8Array>;
 }
 /** Transport uses declared locations; only the requested digest admits bytes into the cache. */
 export declare function resolveSelectedContent(lines: readonly string[], port: ContentPort, requested: readonly string[]): Promise<readonly string[]>;

package/dist/host/source-content.js

@@ -1,9 +1,10 @@
+import { transportBytes } from "./ports/transport.js";
+import { contentStore, verifiedContent } from "./content-store.js";
 import { ContentNeeded } from "./content-needed.js";
 import { createHash } from 'node:crypto';
 import { parse, wireAt } from '@lapxo/topos/wire';
-import { blobAt, landBlob } from "../land/ledger.js";
-import { observeFile } from "../observe/files.js";
-import { ownLock, ownStore } from "../observe/runner.js";
+import { landBlob } from "../land/ledger.js";
+import { ownLock } from "../observe/runner.js";
 /** Transport uses declared locations; only the requested digest admits bytes into the cache. */
 export async function resolveSelectedContent(lines, port, requested) {
     const fields = lines.flatMap(line => { const p = parse(line); return p.kind === 'fact' && p.value.fields.value !== 'withdraw' ? [p.value.fields] : []; });
@@ -44,12 +45,9 @@ export async function resolveSelectedContent(lines, port, requested) {
             throw Error(`REFUSE·pin ${digest} content unavailable · no declared source · not laid`);
         let last;
         for (const url of urls) {
-            const parsed = new URL(url);
-            if (!['https:', 'http:'].includes(parsed.protocol))
-                throw Error(`REFUSE·source ${url} needs an explicit transport adapter`);
             let bytes;
             try {
-                bytes = await port.fetch(url);
+                bytes = await port.fetch(url, digest);
             }
             catch (error) {
                 last = error;
@@ -81,14 +79,16 @@ export async function resolveSources(standing, requested) {
     });
     const received = await resolveSelectedContent([...standing, ...bindings], {
         algorithms: wire.digests,
-        read: digest => observeFile(blobAt(ownStore(), digest)),
-        write: (digest, bytes) => { landBlob(ownStore(), digest, bytes); },
-        fetch: async (url) => {
-            const response = await fetch(url, { signal: AbortSignal.timeout(30000) });
-            if (!response.ok)
-                throw Error(`HTTP ${response.status}`);
-            return new Uint8Array(await response.arrayBuffer());
-        },
+        read: digest => { try {
+            return verifiedContent(digest).bytes;
+        }
+        catch (error) {
+            if (error instanceof ContentNeeded)
+                return undefined;
+            throw error;
+        } },
+        write: (digest, bytes) => { landBlob(contentStore(), digest, bytes); },
+        fetch: async (url, digest) => transportBytes(url, digest, [...ownLock(), ...standing]),
     }, requested);
     for (const digest of received)
         process.stdout.write(`FETCHED  ${digest} · verified\n`);

package/dist/observe/identity.d.ts

@@ -1,3 +1,4 @@
+import type { ReaderLifetime } from '@lapxo/topos/wire';
 import type { Kind } from './run.ts';
 /** Where a reader's vectors lie: in its package, beside its source, under the name of its module, the folder the wire's vector family names. */
 export declare const vectorsOf: (module: string, standing: readonly string[]) => string;
@@ -13,6 +14,7 @@ export declare function identityOf(input: {
     readonly code: string;
     readonly lineage: readonly string[];
     readonly kept: readonly string[];
+    readonly lifetime?: ReaderLifetime;
 }): {
     readonly by: string;
     readonly lines: readonly string[];

package/dist/observe/identity.js

@@ -19,7 +19,7 @@ export function resetsOnEqualEmits(lines) {
     }
     return [...named.values()].filter((ats) => ats.size > 1).length;
 }
-function emitted(store, root, module, kind, cases) {
+function emitted(store, root, module, kind, cases, lifetime) {
     const laid = kind === 'process' ? mkdtempSync(join(tmpdir(), `${selfName()}-vectors-`)) : root;
     try {
         for (const one of kind === 'process' ? cases : []) {
@@ -28,7 +28,7 @@ function emitted(store, root, module, kind, cases) {
                 writeFileSync(join(laid, one.place, name), text);
             }
         }
-        const rows = runReader(resolve(root, module), laid, cases.map((one) => ({ place: one.place, ...(kind === 'js' ? { text: one.text ?? '' } : {}) })));
+        const rows = runReader(resolve(root, module), laid, cases.map((one) => ({ place: one.place, ...(kind === 'js' ? { text: one.text ?? '' } : {}) })), lifetime);
         if (cases.length && rows.every((mine) => !mine.length))
             return undefined;
         const said = rows.map((mine) => mine.filter((row) => !/^(cost|derived|vector-memo)\//.test(row.scope)).map((row) => JSON.stringify(row)).sort());
@@ -50,7 +50,7 @@ export function identityOf(input) {
     const known = mine.find((line) => fieldOf(line, 'measure') === 'extension' && fieldOf(line, 'at') === `place:${key}`);
     if (known !== undefined && fieldOf(known, 'value') === input.code)
         return { by: input.code, lines: [] };
-    const emits = emitted(input.store, input.root, input.module, input.kind, JSON.parse(text).cases ?? []);
+    const emits = emitted(input.store, input.root, input.module, input.kind, JSON.parse(text).cases ?? [], input.lifetime);
     if (emits === undefined)
         return { by: input.code, lines: [] };
     const by = input.code;

package/dist/observe/run.d.ts

@@ -1,3 +1,4 @@
+import type { ReaderLifetime } from '@lapxo/topos/wire';
 export type Kind = 'js' | 'process';
 /** The kinds this host starts. A reader of any other kind is signed and stays potential: nothing here runs it. */
 export declare const runs: (kind: string) => kind is Kind;
@@ -26,5 +27,5 @@ export declare const hostOf: () => string;
  * the file it is handed or alone when it reads the place by running it, as the region it was matched for when its
  * capsule reads with several, and answers one list of claims per place.
  */
-export declare function runReader(module: string, root: string, inputs: readonly Input[]): readonly (readonly Row[])[];
+export declare function runReader(module: string, root: string, inputs: readonly Input[], limits?: ReaderLifetime): readonly (readonly Row[])[];
 export {};

package/dist/observe/run.js

@@ -1,3 +1,4 @@
+import { boundedProcess } from "../host/process-lifetime.js";
 import { spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { PROTOCOL } from '@lapxo/topos/wire';
@@ -13,7 +14,7 @@ export const hostOf = () => processOf('host');
  * the file it is handed or alone when it reads the place by running it, as the region it was matched for when its
  * capsule reads with several, and answers one list of claims per place.
  */
-export function runReader(module, root, inputs) {
+export function runReader(module, root, inputs, limits) {
     if (!inputs.length)
         return [];
     const requests = inputs.map((input) => ({
@@ -23,8 +24,9 @@ export function runReader(module, root, inputs) {
     const reader = readerOf(module);
     if (!existsSync(reader.path))
         throw new Error(`REFUSE·reader ${module} unavailable; its declared capability needs an admitted provider`);
-    const ran = spawnSync(process.execPath, [...reader.flags, hostOf(), reader.path, module], { cwd: root, input: JSON.stringify(requests), encoding: 'utf8', maxBuffer: 1 << 28 });
-    if (ran.error)
+    const args = [...reader.flags, hostOf(), reader.path, module];
+    const ran = limits === undefined ? spawnSync(process.execPath, args, { cwd: root, input: JSON.stringify(requests), encoding: 'utf8', maxBuffer: 1 << 28 }) : boundedProcess(process.execPath, args, JSON.stringify(requests), limits, root);
+    if ('error' in ran && ran.error)
         throw Object.assign(new Error(`${module}: reader process failed: ${ran.error.message}`), { cause: ran.error });
     if (ran.status !== 0)
         throw new Error(`${module}: reader exited ${ran.status ?? `with signal ${ran.signal}`}\n${ran.stderr ?? ''}${ran.stdout ?? ''}`);

package/dist/render/receipts.js

@@ -23,7 +23,8 @@ export function receiptRegion(fold, at) {
     const contract = wireLine(ownLock(), 'receipt-instrument');
     const coordinate = contract === undefined ? undefined : fieldOf(contract, 'value');
     const implementation = coordinate === undefined ? undefined : instrumentDigest(fold.store, sourceOf(), [], ownRoot(), ownLock());
-    const observed = [...receiptsOf(fold), ...(coordinate && implementation ? [canonical({ scope: coordinate, role: 'writes', form: 'alphabet', measure: 'digest', value: implementation, at: `place:${implementation}`, by: 'bound' })] : [])];
+    // The current implementation seal is metadata, not an observation carried from a previous fold.
+    const observed = [...receiptsOf(fold).filter(line => !coordinate || fieldOf(line, 'scope') !== coordinate), ...(coordinate && implementation ? [canonical({ scope: coordinate, role: 'writes', form: 'alphabet', measure: 'digest', value: implementation, at: `place:${implementation}`, by: 'bound' })] : [])];
     const hash = (bytes) => bytesDigest(fold.store, new TextEncoder().encode(bytes));
     const head = keyOf(fold.store, 'attest');
     const projection = receiptProjection(observed, fields, hash, head ? [head] : []);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lapxo/bound",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "description": "Read the bounds you already wrote, fold them, and name the contradictions.",
   "main": "dist/cli/verb.js",
@@ -32,7 +32,7 @@
   "license": "MIT",
   "dependencies": {
     "@lapxo/obligations": "0.3.5",
-    "@lapxo/topos": "0.1.8"
+    "@lapxo/topos": "0.1.9"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",