@volter/world-core 2.0.36 → 3.0.0

package/dist/src/protobuf.d.ts

@@ -0,0 +1,28 @@
+export type ProtoField = {
+    name: string;
+    json: string;
+    number: number;
+    type: string;
+    kind: 'scalar' | 'message' | 'enum';
+    repeated?: true;
+    map?: {
+        key: string;
+        value: string;
+        valueKind: 'scalar' | 'message' | 'enum';
+    };
+};
+export type ProtoSchema = {
+    messages: Record<string, ProtoField[]>;
+    enums: Record<string, Record<string, number>>;
+    rpcs: Record<string, {
+        operation: string;
+        request: string;
+        response: string;
+        serverStreams?: true;
+        clientStreams?: true;
+    }>;
+};
+/** A message's JSON form (proto3 JSON) as its binary encoding. */
+export declare function encodeMessage(schema: ProtoSchema, type: string, value: unknown): Uint8Array;
+/** A message's binary encoding as its JSON form (proto3 JSON; a field at its default is left out). */
+export declare function decodeMessage(schema: ProtoSchema, type: string, bytes: Uint8Array): unknown;

package/dist/src/protobuf.js

@@ -0,0 +1,332 @@
+// PROTOCOL BUFFERS (architecture, "Other wires": the gRPC wire): a message's proto3 JSON form
+// (https://protobuf.dev/programming-guides/json/) to its binary encoding (https://protobuf.dev/programming-guides/encoding/)
+// and back, over the schema the derive writes for a proto unit (`src/generated/proto.gen.json`, twin-standard's
+// `protoSchema`). A handler reads and answers the JSON form; the wire carries the bytes. The JSON form names a field by
+// its JSON name, writes 64-bit integers as decimal strings, bytes as base64, enums by their value names, a map as an
+// object, and leaves out a field holding its default; `google.protobuf.Timestamp`, `Duration`, the wrappers and `Empty`
+// take their own JSON forms. Importing it does nothing.
+const VARINT = new Set(['int32', 'int64', 'uint32', 'uint64', 'sint32', 'sint64', 'bool']);
+const FIXED64 = new Set(['fixed64', 'sfixed64', 'double']);
+const FIXED32 = new Set(['fixed32', 'sfixed32', 'float']);
+const LONG = new Set(['int64', 'uint64', 'sint64', 'fixed64', 'sfixed64']);
+const WRAPPERS = {
+    'google.protobuf.DoubleValue': 'double', 'google.protobuf.FloatValue': 'float', 'google.protobuf.Int64Value': 'int64',
+    'google.protobuf.UInt64Value': 'uint64', 'google.protobuf.Int32Value': 'int32', 'google.protobuf.UInt32Value': 'uint32',
+    'google.protobuf.BoolValue': 'bool', 'google.protobuf.StringValue': 'string', 'google.protobuf.BytesValue': 'bytes',
+};
+const ENC = new TextEncoder();
+const DEC = new TextDecoder();
+const wireOf = (f) => f.kind === 'enum' || VARINT.has(f.type) ? 0 : FIXED64.has(f.type) ? 1 : FIXED32.has(f.type) ? 5 : 2;
+// ── writing ────────────────────────────────────────────────────────────────────────────────────
+class Writer {
+    parts = [];
+    varint(v) {
+        let x = BigInt.asUintN(64, v);
+        while (x >= 0x80n) {
+            this.parts.push(Number((x & 0x7fn) | 0x80n));
+            x >>= 7n;
+        }
+        this.parts.push(Number(x));
+    }
+    tag(number, wire) { this.varint((BigInt(number) << 3n) | BigInt(wire)); }
+    bytes(b) { this.varint(BigInt(b.length)); for (const x of b)
+        this.parts.push(x); }
+    raw(b) { for (const x of b)
+        this.parts.push(x); }
+    fixed(v, size, float = false) {
+        const buf = new DataView(new ArrayBuffer(size));
+        if (float) {
+            if (size === 8)
+                buf.setFloat64(0, Number(v), true);
+            else
+                buf.setFloat32(0, Number(v), true);
+        }
+        else if (size === 8)
+            buf.setBigUint64(0, BigInt.asUintN(64, BigInt(v)), true);
+        else
+            buf.setUint32(0, Number(BigInt.asUintN(32, BigInt(v))), true);
+        for (const x of new Uint8Array(buf.buffer))
+            this.parts.push(x);
+    }
+    done() { return Uint8Array.from(this.parts); }
+}
+const zigzag = (v, bits) => (v << 1n) ^ (v >> BigInt(bits - 1));
+const b64decode = (s) => Uint8Array.from(atob(s.replace(/-/g, '+').replace(/_/g, '/')), (c) => c.charCodeAt(0));
+const b64encode = (b) => btoa(Array.from(b, (x) => String.fromCharCode(x)).join(''));
+function enumNumber(schema, type, v) {
+    if (typeof v === 'number')
+        return v;
+    const n = schema.enums[type]?.[String(v)];
+    if (n === undefined)
+        throw new Error(`protobuf: ${String(v)} is not a value of ${type}`);
+    return n;
+}
+function writeScalar(w, type, v) {
+    switch (type) {
+        case 'int32':
+        case 'int64':
+        case 'uint32':
+        case 'uint64':
+            w.varint(BigInt(v));
+            break;
+        case 'sint32':
+            w.varint(zigzag(BigInt(v), 32));
+            break;
+        case 'sint64':
+            w.varint(zigzag(BigInt(v), 64));
+            break;
+        case 'bool':
+            w.varint(v ? 1n : 0n);
+            break;
+        case 'fixed64':
+        case 'sfixed64':
+            w.fixed(BigInt(v), 8);
+            break;
+        case 'double':
+            w.fixed(Number(v), 8, true);
+            break;
+        case 'fixed32':
+        case 'sfixed32':
+            w.fixed(Number(v), 4);
+            break;
+        case 'float':
+            w.fixed(Number(v), 4, true);
+            break;
+        default: throw new Error(`protobuf: ${type} is not a packable scalar`);
+    }
+}
+/** A well-known type's JSON form as the message it stands for, or undefined for any other type. */
+function wellKnownIn(type, v) {
+    if (type === 'google.protobuf.Timestamp' && typeof v === 'string') {
+        const ms = Date.parse(v);
+        const frac = /\.(\d+)/.exec(v)?.[1] ?? '';
+        return { seconds: String(Math.floor(ms / 1000)), nanos: Number(frac.padEnd(9, '0').slice(0, 9)) };
+    }
+    if (type === 'google.protobuf.Duration' && typeof v === 'string') {
+        const [s, f = ''] = v.replace(/s$/, '').split('.');
+        return { seconds: s, nanos: (s.startsWith('-') ? -1 : 1) * Number(f.padEnd(9, '0').slice(0, 9)) };
+    }
+    if (WRAPPERS[type] !== undefined)
+        return { value: v };
+    return undefined;
+}
+function writeValue(schema, w, f, v) {
+    if (f.kind === 'message') {
+        w.tag(f.number, 2);
+        w.bytes(encodeMessage(schema, f.type, v));
+        return;
+    }
+    if (f.kind === 'enum') {
+        w.tag(f.number, 0);
+        w.varint(BigInt(enumNumber(schema, f.type, v)));
+        return;
+    }
+    if (f.type === 'string') {
+        w.tag(f.number, 2);
+        w.bytes(ENC.encode(String(v)));
+        return;
+    }
+    if (f.type === 'bytes') {
+        w.tag(f.number, 2);
+        w.bytes(typeof v === 'string' ? b64decode(v) : v);
+        return;
+    }
+    w.tag(f.number, wireOf(f));
+    writeScalar(w, f.type, v);
+}
+/** A message's JSON form (proto3 JSON) as its binary encoding. */
+export function encodeMessage(schema, type, value) {
+    const known = wellKnownIn(type, value);
+    const v = (known ?? (value && typeof value === 'object' ? value : {}));
+    const fields = schema.messages[type];
+    if (!fields)
+        throw new Error(`protobuf: ${type} is not a message of the schema`);
+    const w = new Writer();
+    for (const f of fields) {
+        const x = v[f.json] ?? v[f.name];
+        if (x === undefined || x === null)
+            continue;
+        if (f.map) {
+            for (const [k, mv] of Object.entries(x)) {
+                const entry = new Writer();
+                const keyType = f.map.key;
+                writeValue(schema, entry, { number: 1, type: keyType, kind: 'scalar' }, keyType === 'bool' ? k === 'true' : k);
+                writeValue(schema, entry, { number: 2, type: f.map.value, kind: f.map.valueKind }, mv);
+                w.tag(f.number, 2);
+                w.bytes(entry.done());
+            }
+        }
+        else if (f.repeated) {
+            const list = x;
+            if (f.kind === 'enum' || (f.kind === 'scalar' && f.type !== 'string' && f.type !== 'bytes')) {
+                // proto3 packs repeated scalars and enums
+                const packed = new Writer();
+                for (const item of list) {
+                    if (f.kind === 'enum')
+                        packed.varint(BigInt(enumNumber(schema, f.type, item)));
+                    else
+                        writeScalar(packed, f.type, item);
+                }
+                w.tag(f.number, 2);
+                w.bytes(packed.done());
+            }
+            else
+                for (const item of list)
+                    writeValue(schema, w, f, item);
+        }
+        else
+            writeValue(schema, w, f, x);
+    }
+    return w.done();
+}
+// ── reading ────────────────────────────────────────────────────────────────────────────────────
+class Reader {
+    b;
+    at = 0;
+    constructor(b) {
+        this.b = b;
+    }
+    get done() { return this.at >= this.b.length; }
+    varint() {
+        let out = 0n;
+        let shift = 0n;
+        for (;;) {
+            if (this.at >= this.b.length)
+                throw new Error('protobuf: a varint runs past the end');
+            const x = this.b[this.at++];
+            out |= BigInt(x & 0x7f) << shift;
+            if (!(x & 0x80))
+                return out;
+            shift += 7n;
+        }
+    }
+    take(n) {
+        if (n < 0 || this.at + n > this.b.length)
+            throw new Error(`protobuf: a field runs past the message's end (${n} bytes at ${this.at} of ${this.b.length})`);
+        const out = this.b.subarray(this.at, this.at + n);
+        this.at += n;
+        return out;
+    }
+    bytes() { return this.take(Number(this.varint())); }
+    skip(wire) {
+        if (wire === 0)
+            this.varint();
+        else if (wire === 1)
+            this.take(8);
+        else if (wire === 5)
+            this.take(4);
+        else if (wire === 2)
+            this.bytes();
+        else
+            throw new Error(`protobuf: wire type ${wire} is not supported`);
+    }
+}
+const unzigzag = (v) => (v >> 1n) ^ -(v & 1n);
+function readScalar(r, type) {
+    switch (type) {
+        case 'int32': return Number(BigInt.asIntN(32, r.varint()));
+        case 'uint32': return Number(BigInt.asUintN(32, r.varint()));
+        case 'int64': return String(BigInt.asIntN(64, r.varint()));
+        case 'uint64': return String(BigInt.asUintN(64, r.varint()));
+        case 'sint32': return Number(unzigzag(r.varint()));
+        case 'sint64': return String(unzigzag(r.varint()));
+        case 'bool': return r.varint() !== 0n;
+        case 'fixed64': return String(new DataView(r.take(8).slice().buffer).getBigUint64(0, true));
+        case 'sfixed64': return String(new DataView(r.take(8).slice().buffer).getBigInt64(0, true));
+        case 'double': return new DataView(r.take(8).slice().buffer).getFloat64(0, true);
+        case 'fixed32': return new DataView(r.take(4).slice().buffer).getUint32(0, true);
+        case 'sfixed32': return new DataView(r.take(4).slice().buffer).getInt32(0, true);
+        case 'float': return new DataView(r.take(4).slice().buffer).getFloat32(0, true);
+        default: throw new Error(`protobuf: ${type} is not a scalar`);
+    }
+}
+function enumName(schema, type, n) {
+    for (const [name, v] of Object.entries(schema.enums[type] ?? {}))
+        if (v === n)
+            return name;
+    return n;
+}
+function readValue(schema, r, f, wire) {
+    if (f.kind === 'message')
+        return decodeMessage(schema, f.type, r.bytes());
+    if (f.kind === 'enum')
+        return enumName(schema, f.type, Number(BigInt.asIntN(32, r.varint())));
+    if (f.type === 'string')
+        return DEC.decode(r.bytes());
+    if (f.type === 'bytes')
+        return b64encode(r.bytes());
+    void wire;
+    return readScalar(r, f.type);
+}
+/** A well-known message's JSON form from its decoded fields, or the fields as they are for any other type. */
+function wellKnownOut(type, m) {
+    if (type === 'google.protobuf.Timestamp') {
+        const whole = new Date(Number(m.seconds ?? 0) * 1000).toISOString().replace(/\.000Z$/, '');
+        const nanos = Number(m.nanos ?? 0);
+        return `${whole}${protoFraction(nanos)}Z`;
+    }
+    if (type === 'google.protobuf.Duration') {
+        const seconds = BigInt(String(m.seconds ?? '0'));
+        const nanos = Number(m.nanos ?? 0);
+        const negative = seconds < 0n || nanos < 0;
+        return `${negative ? '-' : ''}${seconds < 0n ? -seconds : seconds}${protoFraction(Math.abs(nanos))}s`;
+    }
+    if (WRAPPERS[type] !== undefined)
+        return m.value ?? (WRAPPERS[type] === 'bool' ? false : WRAPPERS[type] === 'string' || WRAPPERS[type] === 'bytes' ? '' : 0);
+    return m;
+}
+/** ProtoJSON emits 0, 3, 6 or 9 fractional digits, retaining the full nanosecond value. */
+function protoFraction(nanos) {
+    if (!nanos)
+        return '';
+    const digits = String(nanos).padStart(9, '0');
+    return `.${digits.slice(0, nanos % 1e6 === 0 ? 3 : nanos % 1000 === 0 ? 6 : 9)}`;
+}
+/** A message's binary encoding as its JSON form (proto3 JSON; a field at its default is left out). */
+export function decodeMessage(schema, type, bytes) {
+    const fields = schema.messages[type];
+    if (!fields)
+        throw new Error(`protobuf: ${type} is not a message of the schema`);
+    const byNumber = new Map(fields.map((f) => [f.number, f]));
+    const out = {};
+    const r = new Reader(bytes);
+    while (!r.done) {
+        const key = Number(r.varint());
+        const number = key >>> 3;
+        const wire = key & 7;
+        const f = byNumber.get(number);
+        if (!f) {
+            r.skip(wire);
+            continue;
+        }
+        if (f.map) {
+            const entry = new Reader(r.bytes());
+            let k;
+            let v;
+            while (!entry.done) {
+                const ek = Number(entry.varint());
+                if ((ek >>> 3) === 1)
+                    k = readValue(schema, entry, { type: f.map.key, kind: 'scalar' }, ek & 7);
+                else if ((ek >>> 3) === 2)
+                    v = readValue(schema, entry, { type: f.map.value, kind: f.map.valueKind }, ek & 7);
+                else
+                    entry.skip(ek & 7);
+            }
+            (out[f.json] ??= {})[String(k ?? '')] = v;
+        }
+        else if (f.repeated) {
+            const list = (out[f.json] ??= []);
+            // a packed run of scalars or enums, or one element
+            if (wire === 2 && (f.kind === 'enum' || (f.kind === 'scalar' && f.type !== 'string' && f.type !== 'bytes'))) {
+                const packed = new Reader(r.bytes());
+                while (!packed.done)
+                    list.push(f.kind === 'enum' ? enumName(schema, f.type, Number(BigInt.asIntN(32, packed.varint()))) : readScalar(packed, f.type));
+            }
+            else
+                list.push(readValue(schema, r, f, wire));
+        }
+        else
+            out[f.json] = readValue(schema, r, f, wire);
+    }
+    return wellKnownOut(type, out);
+}

package/dist/src/redis/engine.js

@@ -80,7 +80,7 @@ export class ReadOnlyError extends Error {
         this.name = 'ReadOnlyError';
     }
 }
-/** Redis's type name for a stream, as TYPE answers it (a Redis type, not the `stream` pack: scripts/architecture.test.ts). */
+/** Redis's type name for a stream, as TYPE answers it (a Redis type, not a pack name: scripts/architecture-auto.ts A2). */
 const STREAM = 'stream';
 export const KEY_TYPES = ['string', 'list', 'set', 'hash', 'zset', STREAM];
 /** The subject-id prefix of a context's database. */

package/dist/src/request-scope.d.ts

@@ -19,7 +19,7 @@ export declare function runAsReadOnlyRequest<T>(fn: () => T | Promise<T>): Promi
     refused: ReadOnlyRequestError;
 }>;
 /** Run `fn` as the VENDOR's own move (a pack's catch-up): its writes land even under a read-only
- *  request. Outside one it changes nothing. */
+ *  request, and are recorded as the World's own moves, never as the caller's API call (inVendorMove). */
 export declare function runAsVendorMove<T>(fn: () => T): T;
 /** Whether this runs as the vendor's own move (runAsVendorMove). */
 export declare function inVendorMove(): boolean;

package/dist/src/request-scope.js

@@ -11,7 +11,7 @@
 // runs under `runAsVendorMove` and still lands under a read-only request, as a real vendor renews a
 // subscription whoever is looking.
 //
-// Created on first use, never at import: a browser bundle of a mirror client carries the kernel and
+// Created on first use, never at import: a browser bundle carries the kernel and
 // has no AsyncLocalStorage (see serve.ts identitySlot).
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { runWithTraceparent, traceparentForDelivery } from "./trace-context.js";
@@ -23,11 +23,13 @@ export function isReadOnlyRequest(request) {
 }
 /** A write a read-only request attempted: refused before anything was written (rule D3's 405). */
 export class ReadOnlyRequestError extends Error {
+    // a field, not a parameter property: Node runs this module with its types stripped (an application importing the
+    // World clock), and stripping takes no parameter property
     service;
     constructor(service) {
         super(`${service}: this request is read-only (${READ_ONLY_REQUEST_HEADER}: 1); it cannot write`);
-        this.service = service;
         this.name = 'ReadOnlyRequestError';
+        this.service = service;
     }
 }
 let writeScopeStore;
@@ -50,14 +52,14 @@ export async function runAsReadOnlyRequest(fn) {
     }
 }
 /** Run `fn` as the VENDOR's own move (a pack's catch-up): its writes land even under a read-only
- *  request. Outside one it changes nothing. */
+ *  request, and are recorded as the World's own moves, never as the caller's API call (inVendorMove). */
 export function runAsVendorMove(fn) {
     const current = writeScope().getStore();
     // the vendor's move is its own span of the request's trace (a delivery's shape): what it writes is joined to the
     // trace, never to the request's caller, who did not make it
     const own = traceparentForDelivery();
     const run = own ? () => runWithTraceparent(own, fn) : fn;
-    return current ? writeScope().run({ ...current, vendorMove: true }, run) : run();
+    return writeScope().run(current ? { ...current, vendorMove: true } : { readOnly: false, vendorMove: true, refusals: [] }, run);
 }
 /** Whether this runs as the vendor's own move (runAsVendorMove). */
 export function inVendorMove() { return writeScopeStore?.getStore()?.vendorMove === true; }

package/dist/src/resource-blob.d.ts

@@ -1,5 +1,10 @@
 /** Read a resource payload at this branch, then its retained ancestors. */
 export declare function readResourceBlob(service: string, key: string, root?: string): Promise<Uint8Array | null>;
+/** Write a resource payload on this branch (a stored object's bytes), where a read finds it first. */
+export declare function writeResourceBlob(service: string, key: string, bytes: Uint8Array, root?: string): Promise<void>;
+/** Remove this branch's copy of a resource payload; an ancestor's stays its own (the row that named it is what a
+ *  deletion ends). */
+export declare function removeResourceBlob(service: string, key: string, root?: string): Promise<void>;
 /** A service's resources dir at this branch, then at each retained ancestor's: where a read resolves a payload, and
  *  what a listing that mints ids covers, so a branch serves bytes its parent received and never re-mints a parent's id. */
 export declare function resourceChain(service: string, root?: string): string[];

package/dist/src/resource-blob.js

@@ -12,6 +12,17 @@ export async function readResourceBlob(service, key, root) {
     }
     return null;
 }
+/** Write a resource payload on this branch (a stored object's bytes), where a read finds it first. */
+export async function writeResourceBlob(service, key, bytes, root) {
+    assertResourceKey(key);
+    await getActiveBlobStore().put(join(worldPaths(service, root).resources, key), bytes);
+}
+/** Remove this branch's copy of a resource payload; an ancestor's stays its own (the row that named it is what a
+ *  deletion ends). */
+export async function removeResourceBlob(service, key, root) {
+    assertResourceKey(key);
+    await getActiveBlobStore().remove(join(worldPaths(service, root).resources, key));
+}
 /** A service's resources dir at this branch, then at each retained ancestor's: where a read resolves a payload, and
  *  what a listing that mints ids covers, so a branch serves bytes its parent received and never re-mints a parent's id. */
 export function resourceChain(service, root) {

package/dist/src/runtime.d.ts

@@ -0,0 +1,85 @@
+export { clearRegistry, getPack, hasPack, listPacks, packOf, 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 { authRefusal, bindSemantics, coreFor, crossCutting, flagOf, derivedRequestScopes, observeTransitions, resourcesOfType as twinResourcesOfType, semanticsContext, stateOf, transitionFor, parseBracketForm, readParams, render as renderDerived, serveCore, sse, vendorError } from './derived-core.js';
+export { deliverEvents, fillEnvelope, signEvent, signEventAll, verifyEvent } from './events.js';
+export { equalSecrets, hmac, jwks, jwtDecode, jwtSign, jwtVerify, keyId, lettersFrom, md5, sha256, SIGNING_ALGORITHMS, uuidFrom } from './signing.js';
+export type { HandlerCrypto, Jwk, Jwks, JwtVerdict, SigningKey } from './signing.js';
+export type { EventDelivery, EventRender, EventScheme, EventsDecl, EventTransport, EventWrite } from './events.js';
+export type { Actor, CoreScope, DerivedManifest, ErrorSpec, FieldRule, Handler, HandlerContext, ResourceDecl, WriteHookContext, ScreenDecl, Semantics, SemanticsContext, StateField, Transition, TransitionObserver, SeedCall } 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, callerForHeader, callerFromHeader, journalTwinRequest, readTwinRequestJournalFrom, type TwinRequestJournalCursor, twinRequestJournalFailures, twinRequestCredentials, readTwinRequestJournal, recordedInput, resolveTwinRead, twinRequestJournalEnabled, twinRequestJournalPath, 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';
+export { installedPackageDir, packRepository, isDerivedPack, vendorPackageDir, vendorOfPackModule } from './pack-paths.js';
+export * as git from './git/index.js';
+export * as s3 from './s3/wire.js';
+export { PLACEHOLDER_REMOTE, beginPlaceholderPull, endPlaceholderPull, placeholderPullActive, placeholderPullMarkerPath, withPlaceholderPull, placeholderEventsFor } from './placeholder-remote.js';
+export { aliasesFrom, 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 { referenceField, registerReferences, packReferences, resolveReferences, type ReferenceDeclaration } from './references.js';
+export { serveHttp, serveStream, 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 { multipartBoundary, multipartParts, type MultipartPart } from './multipart.js';
+export { corsHeaders, withCors, type CorsDecl } from './cors.js';
+export { vendorFetch, VendorUnreachableError } from './vendor-call.js';
+export { closeManagedDatabases, EngineDatabaseError, EngineUnavailableError, managedDatabase, quoteIdent, useDatabaseDriver, WORLD_CLOCK_SETTING, worldClockSql, type DatabaseDriver } from './managed-database.js';
+export type { Batch as EngineBatch, ManagedDatabase, Statement as EngineStatement, StatementResult as EngineStatementResult } from './managed-database.js';
+export { readResourceBlob, readResourceBlobRange, removeResourceBlob, resourceBlobSize, resourceChain, writeResourceBlob } from './resource-blob.js';
+export { assertStateRemovable, checkParent, stateGeneration, withAncestryLock, withHistoryLock, withHistoryLocks, withStateLock, 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';