@volter/world-core 2.0.37 → 3.0.0

package/dist/src/head.d.ts

@@ -9,6 +9,13 @@ export type PushOutcome = {
     externalId: string;
     url?: string;
     data?: Record<string, unknown>;
+    /** the group's entry the id is for, when it is not the group's first (a cascade writes children first) */
+    actionId?: string;
+    /** the group's other entries the answer named an id for (a resource's `companions`) */
+    also?: Array<{
+        actionId: string;
+        externalId: string;
+    }>;
 };
 /** What a perform is handed beside the executor: a resolver from a local id to the vendor's (an
  *  entry authored against `twin-1` crosses against `REAL-42` once that subject's landing adopted it). */
@@ -22,7 +29,8 @@ export type PerformContext = {
     root?: string;
     credential?: string;
 };
-export type PerformAction = (execute: RemoteExecute, action: TwinAction, ctx: PerformContext) => Promise<PushOutcome>;
+/** One request's entries (a group: they share its `correlationId`), performed as the one call that made them. */
+export type PerformAction = (execute: RemoteExecute, group: TwinAction[], ctx: PerformContext) => Promise<PushOutcome>;
 export declare function performContext(service: string, root?: string, credential?: string): PerformContext;
 /** The user's key-encryption key: `$XDG_CONFIG_HOME/volter/kek` (created on first use). */
 export declare function userKekPath(): string;
@@ -129,9 +137,18 @@ export type DeployReport = {
     skipped: string[];
     /** entries whose landed copy already said `deployed` — not performed again */
     replayed: string[];
+    /** entries the World's own doors made (a door, a screen, the gap, the clock, a seed): never offered to the vendor */
+    worldOnly: string[];
 };
-/** The branch entries a root twin still has to perform: `set` rows, not reverted, whose landed copy
- *  is absent or says `failed`/`skipped` (a `deployed` or `refused` copy settles the entry). */
+/** The branch entries a root twin still has to settle: `set` rows, not reverted, whose landed copy is absent or says
+ *  `failed`/`skipped` (a `deployed` or `refused` copy settles the entry), split into what is offered to the vendor (a
+ *  surface write on a subject the vendor can have) and what is the World's own: a write a door, a screen, the gap, the
+ *  clock or a seed made, and any write on a subject only the World's own writes made. */
+export declare function settlingEntries(service: string, root?: string): {
+    offered: TwinAction[];
+    worldOnly: TwinAction[];
+};
+/** The entries a root twin offers the vendor (settlingEntries' `offered`). */
 export declare function deployableEntries(service: string, root?: string): TwinAction[];
 /**
  * PERFORM this twin's deployable entries against its root, in order, checks in front of every one,
@@ -157,6 +174,18 @@ export declare function performAtHead(service: string, action: Pick<TwinAction,
     externalId?: string;
     data?: unknown;
 }>;
+/** Run a pack fetch's handling of one request with its writes' perform deferred to the group (`performRequestGroup`):
+ *  its answer, and whether it appended (a request that wrote nothing has no group, and consults no head). */
+export declare function deferPerform<T>(request: string, fn: () => Promise<T>): Promise<{
+    value: T;
+    appended: boolean;
+}>;
+/** Under `auto`, perform the entries one request made as one call (the real-system adapters, "Perform"): the ids the
+ *  vendor gave them by local id, or the vendor's refusal or failure, the request's entries reverted as performAtHead
+ *  reverts one. Nothing when the head is not real and auto, or the request wrote nothing the vendor is offered. */
+export declare function performRequestGroup(service: string, request: string, root?: string): Promise<{
+    ids: Map<string, string>;
+} | RefusedWriteError | VendorWriteError>;
 /** Wrap a pack's fetch: a `RefusedWriteError` or `VendorWriteError` the head raised becomes the
  *  vendor's own error body (the pack's `shape`), so an app under live use sees what the vendor
  *  would have said. Anything else propagates. */

package/dist/src/head.js

@@ -18,7 +18,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
-import { confirmAction, isTwinBookkeeping, resolveSubjectId, revertAction } from "./actions.js";
+import { confirmAction, currentCorrelationId, isTwinBookkeeping, resolveSubjectId, revertAction } from "./actions.js";
 import { keySealer } from "./credential.js";
 import { buildRemoteExecute, validateRemoteOrigin } from "./executor.js";
 import { getPack } from "./packRegistry.js";
@@ -250,19 +250,47 @@ function receiptsByEntry(parent) {
             out.set(e.landsId, e.receipt);
     return out;
 }
-/** The branch entries a root twin still has to perform: `set` rows, not reverted, whose landed copy
- *  is absent or says `failed`/`skipped` (a `deployed` or `refused` copy settles the entry). */
-export function deployableEntries(service, root) {
+/** Whether an entry records a call of the vendor's surface (an operation or a GraphQL mutation): what a perform can send
+ *  again (the real-system adapters, "What the derived core records with a write"). */
+function surfaceWrite(e) {
+    return typeof e.input?.operationId === 'string' || (e.input?.graphql !== undefined && e.input.graphql !== null);
+}
+/** The branch entries a root twin still has to settle: `set` rows, not reverted, whose landed copy is absent or says
+ *  `failed`/`skipped` (a `deployed` or `refused` copy settles the entry), split into what is offered to the vendor (a
+ *  surface write on a subject the vendor can have) and what is the World's own: a write a door, a screen, the gap, the
+ *  clock or a seed made, and any write on a subject only the World's own writes made. */
+export function settlingEntries(service, root) {
     const parent = parentEntries(service, root);
     const receipts = receiptsByEntry(parent);
     const branch = branchEntries(service, root);
     const reverted = new Set(branch.filter((e) => e.op === 'revert' && e.revertsActionId).map((e) => e.revertsActionId));
-    return branch.filter((e) => {
-        if (e.op !== 'set' || reverted.has(e.id) || isTwinBookkeeping(e))
-            return false;
-        const r = receipts.get(e.id);
-        return r === undefined || r.status === 'failed' || r.status === 'skipped';
-    });
+    const live = branch.filter((e) => e.op === 'set' && !reverted.has(e.id) && !isTwinBookkeeping(e));
+    // a subject some surface write made (or the vendor holds: the parent log knows it) is the vendor's; one only the
+    // World's own writes made is not, and nothing written to it is sent
+    const key = (e) => `${e.subject.type}\u0000${e.subject.id}`;
+    const first = new Map();
+    for (const e of live)
+        if (!first.has(key(e)))
+            first.set(key(e), e);
+    const vendors = new Set([...[...first].filter(([, e]) => surfaceWrite(e)).map(([k]) => k), ...parent.filter((e) => !e.landsId).map(key)]);
+    const pending = live.filter((e) => { const r = receipts.get(e.id); return r === undefined || r.status === 'failed' || r.status === 'skipped'; });
+    return {
+        offered: pending.filter((e) => surfaceWrite(e) && vendors.has(key(e))),
+        worldOnly: pending.filter((e) => !surfaceWrite(e) || !vendors.has(key(e))),
+    };
+}
+/** The entries a root twin offers the vendor (settlingEntries' `offered`). */
+export function deployableEntries(service, root) {
+    return settlingEntries(service, root).offered;
+}
+/** Entries in groups of the request that made them (their `correlationId`), each group in log order. */
+function groupsOf(entries) {
+    const groups = new Map();
+    for (const e of entries) {
+        const k = e.correlationId ?? e.id;
+        groups.set(k, [...(groups.get(k) ?? []), e]);
+    }
+    return [...groups.values()];
 }
 const queues = new Map(); // one performer per twin: wire writes perform in append order
 /**
@@ -294,63 +322,104 @@ async function performNow(opts) {
     const vendor = bound.vendor;
     const adapters = opts.adapters ?? stateSystemFor(vendor) ?? stateSystemFor(service);
     if (!adapters?.perform)
-        throw new Error(`the ${vendor} twin has no perform adapter — a protocol 2 pack names one in its descriptor and registers itself (registerPack)`);
+        throw new Error(`the ${vendor} twin has no perform adapter — a pack names one in its descriptor and registers itself (registerPack)`);
     // the caller's executor, or the one built over the sealed credential; an unsealed root has no other
-    const execute = opts.execute ?? buildRemoteExecute(validateRemoteOrigin(bound.sealed.url, { allowInsecureLoopback: true }), await openRootCredential(bound.sealed, vendor), authStrategyFor(vendor), getPack(vendor)?.hosts, { custody: rootCustody(bound.sealed, vendor) });
+    const execute = opts.execute ?? buildRemoteExecute(validateRemoteOrigin(bound.sealed.url, { allowInsecureLoopback: true }), await openRootCredential(bound.sealed, vendor), authStrategyFor(vendor), getPack(vendor)?.hosts, { custody: rootCustody(bound.sealed, vendor), vendor });
     // an unsealed root's World is where its state resolves (the root given, PROJECT_ROOT, or the working directory)
     const checks = opts.checks ?? (await loadChecks(bound.sealed ? worldRootOf(bound.sealed) : worldPaths(service, root).root));
-    const deployable = deployableEntries(service, root);
-    const entries = opts.actionIds === undefined ? deployable : opts.actionIds.map((id) => deployable.find((a) => a.id === id)).filter((a) => a !== undefined);
-    const report = { pushed: 0, deployed: [], skipped: [], replayed: [] };
+    const settling = settlingEntries(service, root);
+    const pick = (list) => (opts.actionIds === undefined ? list : opts.actionIds.map((id) => list.find((a) => a.id === id)).filter((a) => a !== undefined));
+    const report = { pushed: 0, deployed: [], skipped: [], replayed: [], worldOnly: pick(settling.worldOnly).map((e) => e.id) };
     if (opts.actionIds) {
         const settled = receiptsByEntry(parentEntries(service, root));
         for (const id of opts.actionIds)
             if (settled.get(id)?.status === 'deployed')
                 report.replayed.push(id);
     }
+    const settle = (action, at, receipt, fields = action.fields ?? {}, vendorSubjectId) => {
+        confirmAction({ service, actionId: action.id, subject: action.subject, fields, occurredAt: at, ...(vendorSubjectId ? { vendorSubjectId } : {}), receipt, ...(root !== undefined ? { root } : {}) });
+    };
+    // the subjects the vendor refused and never took: a request naming one is the World's alone, never sent (the
+    // real-system adapters, "Perform" 3), settled as it landed here
+    const parent = parentEntries(service, root);
+    const taken = new Set();
+    const refusedIds = new Set();
+    for (const e of parent) {
+        if (e.receipt?.status === 'deployed')
+            taken.add(e.aliasOf ?? e.subject.id);
+        else if (e.receipt?.status === 'refused')
+            refusedIds.add(e.subject.id);
+    }
+    for (const id of taken)
+        refusedIds.delete(id);
+    const named = (action) => { const out = []; const walk = (v) => { if (typeof v === 'string')
+        out.push(v);
+    else if (v && typeof v === 'object')
+        for (const x of Object.values(v))
+            walk(x); }; const i = (action.input ?? {}); walk(i.path); walk(i.query); walk(i.body); return out; };
     let stopped = false;
-    for (const action of entries) {
+    for (const group of groupsOf(pick(settling.offered))) {
         if (stopped) {
-            report.skipped.push(action.id);
+            report.skipped.push(...group.map((a) => a.id));
+            continue;
+        }
+        if (named(group[0]).some((v) => refusedIds.has(v))) {
+            const at = opts.at ?? worldNow();
+            for (const action of group) {
+                settle(action, at, { status: 'landed', reason: 'names a subject the vendor refused: the World\'s alone' });
+                refusedIds.add(action.subject.id);
+            }
+            report.worldOnly.push(...group.map((a) => a.id));
             continue;
         }
         const at = opts.at ?? worldNow();
-        const verdict = await runChecks(checks, action, readTree(service, root));
+        // checks in front of every entry: one refused refuses the group, which is one call
+        let verdict = null;
+        for (const action of group) {
+            verdict = await runChecks(checks, action, readTree(service, root));
+            if (verdict)
+                break;
+        }
         if (verdict) {
-            confirmAction({ service, actionId: action.id, subject: action.subject, fields: action.fields ?? {}, occurredAt: at, receipt: { status: 'refused', reason: `${verdict.name}: ${verdict.reason}` }, ...(root !== undefined ? { root } : {}) });
-            report.refused = { actionId: action.id, check: verdict.name, reason: verdict.reason };
+            for (const action of group)
+                settle(action, at, { status: 'refused', reason: `${verdict.name}: ${verdict.reason}` });
+            report.refused = { actionId: group[0].id, check: verdict.name, reason: verdict.reason };
             stopped = true;
             continue;
         }
+        // a declared reference to an adopted id is resolved before the pack sees the entry: the vendor is
+        // asked about #7, never the local #3 (docs/contributing/architecture.md#alias-aware-lookup-at-the-request-boundary)
+        const aliases = aliasesFrom(parentEntries(service, root));
+        const resolved = group.map((action) => { const fields = resolveReferences(service, action.subject.type, action.fields ?? {}, aliases); return fields === action.fields ? action : { ...action, fields }; });
         try {
-            // a declared reference to an adopted id is resolved before the pack sees the entry: the vendor is
-            // asked about #7, never the local #3 (docs/contributing/architecture.md#alias-aware-lookup-at-the-request-boundary)
-            const fields = resolveReferences(service, action.subject.type, action.fields ?? {}, aliasesFrom(parentEntries(service, root)));
-            const outcome = await adapters.perform(execute, fields === action.fields ? action : { ...action, fields }, performContext(service, root, bound.sealed ? rootCredentialFingerprint(bound.sealed) : undefined));
-            // the vendor's answer, when the adapter returned one as fields, is what the landed copy holds
+            const outcome = await adapters.perform(execute, resolved, performContext(service, root, bound.sealed ? rootCredentialFingerprint(bound.sealed) : undefined));
+            // the vendor's answer, when the adapter returned one as fields, is what the primary entry's landed copy holds
             const answered = outcome.data !== null && typeof outcome.data === 'object' && !Array.isArray(outcome.data) ? outcome.data : {};
-            confirmAction({
-                service, actionId: action.id, subject: action.subject, fields: { ...fields, ...answered }, occurredAt: at,
-                ...(outcome.externalId ? { vendorSubjectId: outcome.externalId } : {}),
-                receipt: { status: 'deployed', ...(outcome.url ? { url: outcome.url } : {}) },
-                ...(root !== undefined ? { root } : {}),
-            });
-            report.pushed += 1;
-            report.deployed.push({ actionId: action.id, at, ...(outcome.externalId ? { externalId: outcome.externalId } : {}), ...(outcome.data !== undefined ? { data: outcome.data } : {}) });
+            const primary = resolved.find((a) => a.id === outcome.actionId) ?? resolved[0];
+            const also = new Map((outcome.also ?? []).map((a) => [a.actionId, a.externalId]));
+            for (const action of resolved) {
+                const externalId = action === primary ? outcome.externalId : also.get(action.id);
+                settle(action, at, { status: 'deployed', ...(action === primary && outcome.url ? { url: outcome.url } : {}) }, action === primary ? { ...action.fields, ...answered } : action.fields ?? {}, externalId || undefined);
+                report.pushed += 1;
+                report.deployed.push({ actionId: action.id, at, ...(externalId ? { externalId } : {}), ...(action === primary && outcome.data !== undefined ? { data: outcome.data } : {}) });
+            }
         }
         catch (error) {
-            // a write the pack itself refuses (it can never be sent: its subject never reached the vendor) is
-            // settled as refused, as a check's refusal is, so the next deploy moves on to the entry after it;
-            // anything else failed and stays deployable for a retry
+            // a write the vendor refuses (a 4xx: it can never be sent as it is) settles the group refused, as a check's
+            // refusal does, so the next deploy moves on to the group after it; anything else failed and stays offered
             if (error instanceof RefusedWriteError) {
-                confirmAction({ service, actionId: action.id, subject: action.subject, fields: action.fields ?? {}, occurredAt: at, receipt: { status: 'refused', reason: error.message }, ...(root !== undefined ? { root } : {}) });
-                report.refused = { actionId: action.id, check: error.check, reason: error.reason };
+                for (const action of group) {
+                    settle(action, at, { status: 'refused', reason: error.message });
+                    refusedIds.add(action.subject.id);
+                }
+                report.refused = { actionId: group[0].id, check: error.check, reason: error.reason };
                 stopped = true;
                 continue;
             }
             const message = error instanceof Error ? error.message : String(error);
-            confirmAction({ service, actionId: action.id, subject: action.subject, fields: action.fields ?? {}, occurredAt: at, receipt: { status: 'failed', reason: message }, ...(root !== undefined ? { root } : {}) });
-            report.failed = { actionId: action.id, error: message };
+            for (const action of group)
+                settle(action, at, { status: 'failed', reason: message });
+            report.failed = { actionId: group[0].id, error: message };
             stopped = true;
         }
     }
@@ -362,6 +431,13 @@ async function performNow(opts) {
  * Raises `RefusedWriteError` / `VendorWriteError` for the pack to answer in the vendor's shape.
  */
 export async function performAtHead(service, action, root) {
+    // a pack fetch performs its request's entries as one group after the handler (performRequestGroup)
+    const request = currentCorrelationId();
+    const mark = request !== undefined ? deferred.get(request) : undefined;
+    if (mark) {
+        mark.appended = true;
+        return { performed: false };
+    }
     const head = headOf(service, root);
     if (head.kind !== 'real' || head.deploy !== 'auto')
         return { performed: false };
@@ -384,6 +460,51 @@ export async function performAtHead(service, action, root) {
     const done = report.deployed.find((d) => d.actionId === action.id);
     return { performed: done !== undefined, ...(done?.externalId ? { externalId: done.externalId } : {}), ...(done?.data !== undefined ? { data: done.data } : {}) };
 }
+/** The requests a pack fetch is answering, whose entries it performs as one group when the handler returns, and
+ *  whether each has appended any. */
+const deferred = new Map();
+/** Run a pack fetch's handling of one request with its writes' perform deferred to the group (`performRequestGroup`):
+ *  its answer, and whether it appended (a request that wrote nothing has no group, and consults no head). */
+export async function deferPerform(request, fn) {
+    const mark = { appended: false };
+    deferred.set(request, mark);
+    try {
+        return { value: await fn(), appended: mark.appended };
+    }
+    finally {
+        deferred.delete(request);
+    }
+}
+/** Under `auto`, perform the entries one request made as one call (the real-system adapters, "Perform"): the ids the
+ *  vendor gave them by local id, or the vendor's refusal or failure, the request's entries reverted as performAtHead
+ *  reverts one. Nothing when the head is not real and auto, or the request wrote nothing the vendor is offered. */
+export async function performRequestGroup(service, request, root) {
+    const head = headOf(service, root);
+    const ids = new Map();
+    if (head.kind !== 'real' || head.deploy !== 'auto')
+        return { ids };
+    const group = deployableEntries(service, root).filter((e) => e.correlationId === request);
+    if (!group.length)
+        return { ids };
+    let report;
+    try {
+        report = await performEntries({ service, actionIds: group.map((e) => e.id), ...(root !== undefined ? { root } : {}) });
+    }
+    catch (error) {
+        throw error instanceof HeadError ? error : new HeadError(error instanceof Error ? error.message : String(error));
+    }
+    if (report.refused || report.failed) {
+        for (const e of [...group].reverse())
+            revertAction({ service, actionId: e.id, occurredAt: worldNow(), ...(root !== undefined ? { root } : {}) });
+        return report.refused ? new RefusedWriteError(report.refused.check, report.refused.reason, report.refused.actionId) : new VendorWriteError(report.failed.error, report.failed.actionId);
+    }
+    for (const d of report.deployed) {
+        const e = group.find((g) => g.id === d.actionId);
+        if (e && d.externalId && d.externalId !== e.subject.id)
+            ids.set(e.subject.id, d.externalId);
+    }
+    return { ids };
+}
 /** Wrap a pack's fetch: a `RefusedWriteError` or `VendorWriteError` the head raised becomes the
  *  vendor's own error body (the pack's `shape`), so an app under live use sees what the vendor
  *  would have said. Anything else propagates. */

package/dist/src/history.d.ts

@@ -50,7 +50,7 @@ export declare function saveHistoryView(directory: string, view: HistoryView): s
  *  refuses (`historyEntries`), instead of serving a tree folded from the history it replaced. */
 export declare function inheritedHistoryKey(service: string, root?: string): string;
 export declare function inheritedHistory(service: string, root?: string): HistoryView | undefined;
-/** Capture under the same coordinator as append and complete observation batches. */
+/** Capture under the directory's history lock, as appends and complete observation batches are made. */
 export declare function captureHistory(service: string, root?: string): {
     view: string;
     position: number;

package/dist/src/history.js

@@ -3,7 +3,7 @@ import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { resolveReferences } from "./references.js";
 import { canonicalJson } from "./hash.js";
-import { canonicalStatePath, checkParent, commitParentPin, pinParent, stateGeneration, withAncestryLock } from "./ancestry.js";
+import { canonicalStatePath, checkParent, commitParentPin, pinParent, stateGeneration, withAncestryLock, withHistoryLock } from "./ancestry.js";
 import { getActiveWorldStore } from "./world-store.js";
 import { worldPaths } from "./storage.js";
 import { aliasesFrom, foldHistory, branchEntries, isUrlParent, readBranchMeta, toEntry } from "./log.js";
@@ -144,9 +144,9 @@ export function inheritedHistory(service, root) {
         checkParent(worldPaths(service, parent.at).dir, parent.generation);
     return historyPrefix(readHistoryView(directory, parent.view), parent.position);
 }
-/** Capture under the same coordinator as append and complete observation batches. */
+/** Capture under the directory's history lock, as appends and complete observation batches are made. */
 export function captureHistory(service, root) {
-    return withAncestryLock(() => {
+    return withHistoryLock(worldPaths(service, root).dir, () => {
         const directory = canonicalStatePath(worldPaths(service, root).dir);
         getActiveWorldStore().mkdir(directory);
         if (!getActiveWorldStore().exists(join(directory, 'history-format.json')))
@@ -170,7 +170,7 @@ export function originHead(service, root) {
 }
 /** A complete remote view shares cached rows by content, never by mutable offsets or entry ID. */
 export function publishOriginHistory(service, root, remoteView, layout, entries) {
-    return withAncestryLock(() => {
+    return withHistoryLock(worldPaths(service, root).dir, () => {
         if (entries.length !== historyLength(layout))
             throw new Error('Incomplete origin history view');
         const directory = canonicalStatePath(worldPaths(service, root).dir);
@@ -209,7 +209,7 @@ export function publishOriginHistory(service, root, remoteView, layout, entries)
 }
 /** A changeset binds the complete inherited view, including this root's observations. */
 export function captureParentHistory(service, root) {
-    return withAncestryLock(() => {
+    return withHistoryLock(worldPaths(service, root).dir, () => {
         const head = captureHistory(service, root);
         const position = head.position - head.descriptor.layout.branch;
         return { view: saveHistoryView(worldPaths(service, root).dir, historyPrefix(head.descriptor, position)), position };
@@ -242,7 +242,7 @@ export function historyChanges(service, before, after) {
 }
 /** A timestamp can select across layers; represent it as a view, never a misleading offset. */
 export function historyAtInstant(service, instant, root, selectedView) {
-    return withAncestryLock(() => {
+    return withHistoryLock(worldPaths(service, root).dir, () => {
         const stamp = Date.parse(instant);
         if (!Number.isFinite(stamp))
             throw new Error('Invalid history instant');

package/dist/src/hpack.json

@@ -0,0 +1 @@
+{"source":"RFC 7541 Appendix A and B","staticTable":[[":authority",""],[":method","GET"],[":method","POST"],[":path","/"],[":path","/index.html"],[":scheme","http"],[":scheme","https"],[":status","200"],[":status","204"],[":status","206"],[":status","304"],[":status","400"],[":status","404"],[":status","500"],["accept-charset",""],["accept-encoding","gzip, deflate"],["accept-language",""],["accept-ranges",""],["accept",""],["access-control-allow-origin",""],["age",""],["allow",""],["authorization",""],["cache-control",""],["content-disposition",""],["content-encoding",""],["content-language",""],["content-length",""],["content-location",""],["content-range",""],["content-type",""],["cookie",""],["date",""],["etag",""],["expect",""],["expires",""],["from",""],["host",""],["if-match",""],["if-modified-since",""],["if-none-match",""],["if-range",""],["if-unmodified-since",""],["last-modified",""],["link",""],["location",""],["max-forwards",""],["proxy-authenticate",""],["proxy-authorization",""],["range",""],["referer",""],["refresh",""],["retry-after",""],["server",""],["set-cookie",""],["strict-transport-security",""],["transfer-encoding",""],["user-agent",""],["vary",""],["via",""],["www-authenticate",""]],"huffman":[[8184,13],[8388568,23],[268435426,28],[268435427,28],[268435428,28],[268435429,28],[268435430,28],[268435431,28],[268435432,28],[16777194,24],[1073741820,30],[268435433,28],[268435434,28],[1073741821,30],[268435435,28],[268435436,28],[268435437,28],[268435438,28],[268435439,28],[268435440,28],[268435441,28],[268435442,28],[1073741822,30],[268435443,28],[268435444,28],[268435445,28],[268435446,28],[268435447,28],[268435448,28],[268435449,28],[268435450,28],[268435451,28],[20,6],[1016,10],[1017,10],[4090,12],[8185,13],[21,6],[248,8],[2042,11],[1018,10],[1019,10],[249,8],[2043,11],[250,8],[22,6],[23,6],[24,6],[0,5],[1,5],[2,5],[25,6],[26,6],[27,6],[28,6],[29,6],[30,6],[31,6],[92,7],[251,8],[32764,15],[32,6],[4091,12],[1020,10],[8186,13],[33,6],[93,7],[94,7],[95,7],[96,7],[97,7],[98,7],[99,7],[100,7],[101,7],[102,7],[103,7],[104,7],[105,7],[106,7],[107,7],[108,7],[109,7],[110,7],[111,7],[112,7],[113,7],[114,7],[252,8],[115,7],[253,8],[8187,13],[524272,19],[8188,13],[16380,14],[34,6],[32765,15],[3,5],[35,6],[4,5],[36,6],[5,5],[37,6],[38,6],[39,6],[6,5],[116,7],[117,7],[40,6],[41,6],[42,6],[7,5],[43,6],[118,7],[44,6],[8,5],[9,5],[45,6],[119,7],[120,7],[121,7],[122,7],[123,7],[32766,15],[2044,11],[16381,14],[8189,13],[268435452,28],[1048550,20],[4194258,22],[1048551,20],[1048552,20],[4194259,22],[4194260,22],[4194261,22],[8388569,23],[4194262,22],[8388570,23],[8388571,23],[8388572,23],[8388573,23],[8388574,23],[16777195,24],[8388575,23],[16777196,24],[16777197,24],[4194263,22],[8388576,23],[16777198,24],[8388577,23],[8388578,23],[8388579,23],[8388580,23],[2097116,21],[4194264,22],[8388581,23],[4194265,22],[8388582,23],[8388583,23],[16777199,24],[4194266,22],[2097117,21],[1048553,20],[4194267,22],[4194268,22],[8388584,23],[8388585,23],[2097118,21],[8388586,23],[4194269,22],[4194270,22],[16777200,24],[2097119,21],[4194271,22],[8388587,23],[8388588,23],[2097120,21],[2097121,21],[4194272,22],[2097122,21],[8388589,23],[4194273,22],[8388590,23],[8388591,23],[1048554,20],[4194274,22],[4194275,22],[4194276,22],[8388592,23],[4194277,22],[4194278,22],[8388593,23],[67108832,26],[67108833,26],[1048555,20],[524273,19],[4194279,22],[8388594,23],[4194280,22],[33554412,25],[67108834,26],[67108835,26],[67108836,26],[134217694,27],[134217695,27],[67108837,26],[16777201,24],[33554413,25],[524274,19],[2097123,21],[67108838,26],[134217696,27],[134217697,27],[67108839,26],[134217698,27],[16777202,24],[2097124,21],[2097125,21],[67108840,26],[67108841,26],[268435453,28],[134217699,27],[134217700,27],[134217701,27],[1048556,20],[16777203,24],[1048557,20],[2097126,21],[4194281,22],[2097127,21],[2097128,21],[8388595,23],[4194282,22],[4194283,22],[33554414,25],[33554415,25],[16777204,24],[16777205,24],[67108842,26],[8388596,23],[67108843,26],[134217702,27],[67108844,26],[67108845,26],[134217703,27],[134217704,27],[134217705,27],[134217706,27],[134217707,27],[268435454,28],[134217708,27],[134217709,27],[134217710,27],[134217711,27],[134217712,27],[67108846,26],[1073741823,30]]}

package/dist/src/index.d.ts

@@ -1,76 +1,65 @@
-export { clearRegistry, getPack, hasPack, listPacks, registerPack, pullPosture, assertContinuousPullAllowed, pullOnSchedule, resolvePullVendor, DEFAULT_PULL_POSTURE, DEFAULT_PULL_TRIGGER, PROTOCOL_VERSION, PROTOCOL_MAJOR, protocolStanding } from './packRegistry.js';
-export type { PackTransport, PullPosture, PullTrigger, PullVendor, RoundTripWrite, TwinPack } from './packRegistry.js';
-export { parseScenarioDocument, scenarioFaultResult, ScenarioEngine, ScenarioError, statefulTwinManifest, twinManifest } from './scenario.js';
-export { WORLD_CLOCK_ENV, worldNow } from './world-clock.js';
-export { WORLD_ENV_NAMES_ENV, worldEnvValue } from './world-env.js';
-export { createTwinFetchFromHandler, TWIN_PREFIX_HEADER, TWIN_REQUEST_SCOPES, twinPublicBase, withRequestScopes } from './twin-fetch.js';
-export { isReadOnlyRequest, READ_ONLY_REQUEST_HEADER, ReadOnlyRequestError, runAsReadOnlyRequest, runAsVendorMove, writesRefused } from './request-scope.js';
-export { compileSurface, createDerivedFetch, matchOperation } from './derived.js';
-export { currentTraceparent, deliveryTraceHeaders, newTraceparent, parseTraceparent, runWithRequestTrace, runWithTraceparent, TRACEPARENT_HEADER, traceparentForDelivery, validTraceparent } from './trace-context.js';
-export type { Traceparent } from './trace-context.js';
-export type { DerivedCall, DerivedCoreOutcome, DerivedFetch, DerivedFetchOptions, DerivedHandler, DerivedOperation, DerivedOwner, DerivedSurface } from './derived.js';
-export { bindSemantics, coreFor, crossCutting, derivedRequestScopes, observeTransitions, resourcesOfType as twinResourcesOfType, semanticsContext, stateOf, transitionFor, parseBracketForm, readParams, render as renderDerived, serveCore, sse, vendorError } from './derived-core.js';
-export type { Actor, CoreScope, DerivedManifest, ErrorSpec, FieldRule, Handler, HandlerContext, ResourceDecl, WriteHookContext, ScreenDecl, Semantics, SemanticsContext, StateField, Transition, TransitionObserver } from './derived-core.js';
-export type { RemoteExecute, RemoteExecuteRequest, RemoteExecuteResponse } from './remote-execute.js';
-export type { TwinFetchAdapterConfig, TwinFetchHandlerRequest, TwinFetchHandlerResult, TwinStream, TwinStreamConnection, TwinStreamSink } from './twin-fetch.js';
-export type { PackScenarioAdapter, ScenarioDecision, ScenarioDocument, ScenarioExtractorSpec, ScenarioFault, ScenarioFaultResult, ScenarioFeatures, ScenarioHandler, ScenarioMatcher, ScenarioMissRecord, ScenarioStatus } from './scenario.js';
-export { emitTwinEvent, eventSubscriptionMatches, listEmittable, runEmitCli } from './emit.js';
-export type { EmitDeliveryResult, EmitEndpoint, EmitReport, EmittableEvent, SynthesizedDelivery, TwinEmitter } from './emit.js';
-export { DEFAULT_RATE_BUDGET, MAX_RATE_BUDGET_CEILING, MAX_RATE_BUDGET_WINDOW_MS, MIN_RATE_BUDGET_WEIGHT, MIN_RATE_BUDGET_WINDOW_MS, RateBudget, RateBudgetError, declareRateBudget, hasRateBudgetDeclaration, listRateBudgets, priceCall, rateBudgetPath, rateBudgetPolicy, rateBudgetWeight, resetToSeconds, assertBudgetGuardIntact, } from './rateBudget.js';
-export type { RateBudgetDeclaration, RateBudgetErrorKind, RateBudgetOptions, RateBudgetPolicy, RateBudgetReservation, RateBudgetSnapshot, RateBudgetWeightRule, } from './rateBudget.js';
-export { GenericWorldStateSchema, WorldActorSchema, WorldExternalRefSchema, WorldServiceEventSchema, WorldSubjectSchema, } from './schemas.js';
-export { loadWorldConfig, } from './worldConfig.js';
-export type { WorldConfig, WorldServiceConfig, } from './worldConfig.js';
-export { DELTA_TYPE_SUFFIX, diffSubjectFields, hashFieldValue, subjectKey, deltaAfterFields } from './hash.js';
-export type { FieldChange, SubjectFields, } from './hash.js';
-export { appendDurable, appendEvent, createEvent, emptyGenericState, genericWorldReducer, listEvents, loadState, projectionLockPath, readJsonFile, rebuildGenericState, rebuildState, scrubService, scrubWorld, stateDirName, twinLog, withFileLock, worldPaths, worldStateRoot, ownerStoreRoots, WORLD_DATA_ENV, } from './storage.js';
-export type { AppendEventResult, CommitQueuedEventsResult, GenericWorldState, EnqueueEventResult, QueuedWorldServiceEvent, WorldPaths, WorldReducer, WorldServiceEvent, } from './types.js';
-export type { ScrubResult } from './storage.js';
-export { FsWorldStore, MemoryWorldStore, getActiveWorldStore, setActiveWorldStore, withWorldStore, hydrateInto, flushFrom, } from './world-store.js';
-export type { WorldStore, WorldStat, HydrationSource, HydrationSink } from './world-store.js';
-export type { CheckLoader } from './head.js';
-export { SqlWorldStore } from './world-store-sql.js';
-export type { SqlExec } from './world-store-sql.js';
-export { FsBlobStore, MemoryBlobStore, blobDigest, getActiveBlobStore, setActiveBlobStore, withBlobStore, readBlobRange, } from './blob-store.js';
-export type { BlobStore } from './blob-store.js';
-export { applyTwinWrite, applyTwinWriteAtomic, createTwinServer, CALLER_HEADER, journalTwinRequest, twinRequestJournalFailures, twinRequestCredentials, readTwinRequestJournal, resolveTwinRead, twinRequestJournalEnabled, twinRequestJournalPath, readTwinRequestJournalFrom, type TwinRequestJournalCursor, twinResources, } from './serve.js';
-export type { AtomicTwinWriteDecision, TwinRequestJournalEntry, TwinResource, TwinWriteInput, TwinWriteResult, } from './serve.js';
-export { createTwinProxy } from './proxy.js';
-export type { TwinProxy, TwinProxyOptions, VendorRoute } from './proxy.js';
-export { forkTwin, isFork, readForkMeta, } from './fork.js';
-export type { ForkMeta } from './fork.js';
-export { appendAction, appendTransactionCommit, checkPrecondition, confirmAction, listActions, listTransactionCommits, pendingActions, pushablePendingActions, isTwinBookkeeping, pendingTransactionCommits, projectResources, projectOwnerResources, OwnerStoreAmbiguousError, revertAction, TwinActionPreconditionError, subjectAliases, resolveSubjectId, runWithCorrelationId, currentCorrelationId } from './actions.js';
-export type { ActionProjection, ProjectedDelivery, ProjectedResource, ProjectedResourcePatch, ProjectedResourceRef, TwinAction, TwinActionOp, TwinActionPrecondition, TwinActionPreconditionOp, TwinActionRevertSpec, TwinTransactionCommit, TwinTransactionCommitOp, TwinTransactionPrecondition, TwinTransactionRevertSpec, } from './actions.js';
-export { approveChangeset, assertMarkerBelongsTo, assertSafeChangesetName, assertValidVerifiers, buildChangeset, captureMarker, changesetContentHash, changesetHashMatches, changesetReadiness, approverOf, CHANGESET_KIND, diffLedgers, formatApplication, formatChangeset, formatRebaseReport, narrateActions, narrationDrift, rebaseChangeset, formatChangesetStatus, formatLedgerDelta, formatReplayReport, formatVerification, MARKER_KIND, normalizeChangeset, parseVerifierExpression, replayChangeset, runChangesetVerifiers, summarizeByVendor, twinWriteShape, withApplication, withVerification, worldBootMarker, WORLD_BOOT_MARKER_ID, } from './changeset.js';
-export type { ApplyReceipt, RebaseActionResult, RebaseReport, RebaseTarget, Changeset, ChangesetAction, ChangesetApplication, CompensationEntry, ChangesetApproval, ChangesetReadiness, ChangesetVerification, ChangesetVerifier, ChangesetVerifierResult, LedgerDelta, LedgerPosition, LedgerRef, ReplayActionResult, ReplayReport, ReplayTarget, VendorSummary, WorldMarker, } from './changeset.js';
-export { getActivePackAssets, setActivePackAssets, packAsset, assetContentType, confinedAssetPath, LocalPackAssets, BindingPackAssets, type PackAssetStore } from './pack-assets.js';
+import { bindSemantics as bindAny, type CoreScope, type Handler } from './derived-core.js';
+import type { DerivedHandler, DerivedSurface } from './derived.js';
+import type { DerivedManifest } from './derived-core.js';
+import { type PackDescriptor } from './packRegistry.js';
+export type { PackDescriptor, PackTransport } from './packRegistry.js';
+/** The descriptor a manifest declares, with its vendor ("The descriptor"); given the pack's generated surface (a vendor of
+ *  lanes: each lane's manifest and surface), with the real-system adapters the kernel derives from them. */
+export declare const packOf: (manifest: {
+    vendor: string;
+    descriptor?: Omit<PackDescriptor, "vendor">;
+}, surface?: DerivedSurface | Record<string, {
+    manifest: DerivedManifest;
+    surface: DerivedSurface;
+}>) => PackDescriptor;
+/** The pack registered, so the World finds it. */
+export declare const registerPack: (pack: PackDescriptor) => PackDescriptor;
+export type { Actor, CoreScope, DerivedManifest, ErrorSpec, LaneRoute, LanesDecl, VendorManifest, FieldRule, ResourceDecl, ScreenDecl, SeedCall, StateField, Transition } from './derived-core.js';
+export type { ApplicationAnswer, EndpointsDecl, EventRender, EventScheme, EventsDecl, EventTransport, EventValues, EventWrite } from './events.js';
+export { verifyEvent } from './events.js';
+export { deriveStateSystem, deriveVendorStateSystem } from './derived-real.js';
+export type { IngestDecl } from './derived-core.js';
+export type { SocketDecl, SocketEngine, SocketSession } from './sockets.js';
+export { machinePool, type ExecSpec, type MachinePool, type MachineProcess, type MachineRun, type MachineSpec } from './machines.js';
+export type { CorsDecl } from './cors.js';
+export type { Handler, HandlerContext, WriteHookContext } from './derived-core.js';
+export type { MultipartPart } from './multipart.js';
+/** A pack's handlers, by operationId, bound to the manifest: each is answered over the contract's context. */
+export declare const bindSemantics: (m: Parameters<typeof bindAny>[0], handlers: Record<string, Handler>, scope?: CoreScope) => Record<string, DerivedHandler>;
+export { createPackFetch, createVendorFetch, type LanePart, type PackFetchOptions, type PackParts, type PackScenario } from './pack-fetch.js';
+export { createDerivedFetch } from './derived.js';
+export type { DerivedCall, DerivedFetch, DerivedFetchOptions, DerivedHandler, DerivedOperation, DerivedSurface } from './derived.js';
+export { coreFor, crossCutting, derivedRequestScopes, vendorError } from './derived-core.js';
+export { answerVendorErrors, RefusedWriteError } from './head.js';
+export { GraphqlError, type GraphqlPart, type GraphqlResolver } from './graphql-wire.js';
+export { VendorUnreachableError } from './vendor-call.js';
+export { isReadOnlyRequest, READ_ONLY_REQUEST_HEADER } from './request-scope.js';
+export { serveHttp, serveStream, type HttpHandler, type HttpServer, type ServeHttpOptions } from './serve-http.js';
+export type { TwinStream, TwinStreamConnection, TwinStreamSink } from './twin-fetch.js';
+export { statefulTwinManifest, twinManifest } from './scenario.js';
+export { assetContentType, packAsset } from './pack-assets.js';
+export { bytesResponse, contentTypeOf, fileResponse } from './file-response.js';
+export { certificateOf, digest, digestBytes, equalSecrets, oauth1BaseString, oauth1Encode, oauth1Header, oauth1Signature, hmac, jwks, jwtDecode, jwtSign, jwtVerify, keyId, lettersFrom, md5, publicKeyOf, sha256, signWith, SIGNING_ALGORITHMS, uuidFrom, verifyWith } from './signing.js';
+export type { HandlerCrypto, Jwk, Jwks, JwtVerdict, SigningKey } from './signing.js';
+export { blobDigest } from './blob-store.js';
+export { gunzip, gzip } from './bytes.js';
+export { ownFields } from './log.js';
+export type { TwinResource } from './serve.js';
+export { passwordHash, personOf, personWith, recordPerson, type Person } from './people.js';
+export { EngineDatabaseError, EngineUnavailableError, quoteIdent, worldClockSql } from './managed-database.js';
+export type { Batch as EngineBatch, ManagedDatabase, Statement as EngineStatement, StatementResult as EngineStatementResult } from './managed-database.js';
+export type { Mail, SmtpRoute } from './smtp.js';
+export * as s3 from './s3/wire.js';
+export * as clickhouse from './clickhouse/index.js';
+export { sampleFromSchema } from './schema-sample.js';
+export * as openaiWire from './openai-wire.js';
+export * as anthropicWire from './anthropic-wire.js';
+export * as protobuf from './protobuf.js';
+export * as grpc from './grpc-wire.js';
+export { acceptH2Connection, type H2Handler, type Http1Handler } from './h2.js';
+export { placeholderPng } from './placeholder-image.js';
+export { presignSigV4, signSigV4, verifySigV4, type SigV4Verdict } from './sigv4.js';
+export * as redis from './redis/index.js';
 export * as git from './git/index.js';
-export { PLACEHOLDER_REMOTE, beginPlaceholderPull, endPlaceholderPull, placeholderPullActive, placeholderPullMarkerPath, withPlaceholderPull, placeholderEventsFor } from './placeholder-remote.js';
-export { ownFields, subjectHistory, rebaseBranch, cutCheckpoint, appendParentEntry, wholeLog, branchEntries, branchLogPath, branchMetaPath, CHECKPOINT_EVERY, dropCheckpoint, foldEntries, landedCopy, landedIds, parentEntries, parentLogPath, position, readBranchMeta, readTree, toEntry, toEvent, unpushedEntries, writeBranchMeta } from './log.js';
-export type { BranchMeta, Entry, EntryOp, Receipt } from './log.js';
-export { sealCredential, openSealedCredential, MemoryCredentialStorage, keySealer, transitSealer, type Rewrapped, type Sealer, type TransitSealerOptions, type SealedByVault, type SealedUnderKey } from './credential.js';
-export type { CredentialPayload, CredentialStorage, SealedCredential } from './credential.js';
-export { validateRemoteOrigin, buildRemoteExecute, type CredentialCustody } from './executor.js';
-export type { TwinAuthStrategy } from './executor.js';
-export { clearRoot, authStrategyFor, clearStateSystems, NO_SECRETS_CHECK, readRoot, registerAuthStrategy, registerStateSystem, rootPath, runChecks, stateSystemFor, writeRoot } from './state-system.js';
-export type { Check, CheckVerdict, DeployPolicy, RootConfig, StateSystemAdapters } from './state-system.js';
-export { observeAppends } from './actions.js';
-export { appendActionIfAbsent, appendActionOccurrence } from './actions.js';
-export { answerVendorErrors, performEntries, performAtHead, deployableEntries, headOf, boundRoot, loadChecks, loadCheck, openRootCredential, resealRootCredential, destinationOf, openSealedRecord, sealsThroughVault, rootCustody, sealingKey, setCheckLoader, setSealingKeySource, setSealer, currentSealer, openSealedAt, userKek, userKekPath, vendorOf, worldRootOf, RefusedWriteError, VendorWriteError, HeadError } from './head.js';
-export type { BoundRoot, DeployReport, Head, PerformAction, PerformContext, PushOutcome } from './head.js';
-export { observeResource, observeResources, collectObservations, foldObservations } from './observe.js';
-export type { ObservedResource, ObserveReport, Observation } from './observe.js';
-export { readTreeMap, readParentTreeMap, treeStamp, treeChangesSince, originEntries, appendOriginEntry, originLogPath, isUrlParent, parentPosition, positionAt, splitsBatch, assertBatchBoundary } from './log.js';
-export * from './v1-removed.js';
-export { referenceField, registerReferences, packReferences, resolveReferences, type ReferenceDeclaration } from './references.js';
-export { serveHttp, nodeBuiltin, WORLD_BOOT_PATH, type HttpServer, type ServeHttpOptions, type HttpHandler } from './serve-http.js';
-export { fileResponse, contentTypeOf } from './file-response.js';
-export { bundleClient, filePathOf } from './client-bundle.js';
-export { brandTokensResponse } from './brand-tokens.js';
-export { readResourceBlob, readResourceBlobRange, resourceBlobSize, resourceChain } from './resource-blob.js';
-export { mirrorShellUnder } from './mirror-shell.js';
-export { assertStateRemovable, checkParent, stateGeneration, withAncestryLock, withStateRemoval } from './ancestry.js';
-export { captureHistory, captureParentHistory, historyChanges, historyAtInstant, historyDigest, historyEntries, historyLength, historyPrefix, inheritedHistory, originHead, publishOriginHistory, readHistoryView } from './history.js';
-export type { HistoryView, HistoryLayout, HistoryReference, HistoryOrigin } from './history.js';
-export { foldHistory } from './log.js';
-export { volterHome } from './volter-home.js';
+export { parseScenarioDocument, scenarioFaultResult, ScenarioEngine, ScenarioError } from './scenario.js';
+export type { PackScenarioAdapter, ScenarioDecision, ScenarioDocument, ScenarioExtractorSpec, ScenarioFault, ScenarioFaultResult, ScenarioFeatures, ScenarioHandler, ScenarioMatcher, ScenarioMissRecord, ScenarioStatus } from './scenario.js';