@volter/world-core 3.0.38 → 3.0.40

package/dist/src/redis/stream.js

@@ -0,0 +1,335 @@
+import { RedisStatus, commandInteger, commandShapeError, globMatch } from "./engine.js";
+import { binaryBytes, binaryText, inlineCommand, readResp, respReply } from "./frames.js";
+export function createRedisStream(options) {
+    const sessions = new Set();
+    let nextId = 0, commandCount = 0;
+    let serial = Promise.resolve();
+    const ordered = (f) => { const p = serial.then(f); serial = p.catch(() => { }); return p; };
+    const error = (message) => ({ error: message });
+    const ok = new RedisStatus('OK');
+    const answer = (s, v) => { if (!s.closed)
+        s.sink.write(binaryBytes(respReply(v))); };
+    const close = (s) => { s.closed = true; if (s.blocked?.timer)
+        clearTimeout(s.blocked.timer); sessions.delete(s); };
+    const unblock = (s, v) => { if (s.blocked?.timer)
+        clearTimeout(s.blocked.timer); s.blocked = undefined; answer(s, v); queueMicrotask(() => { void s.pump?.(); }); };
+    const blockRun = async (s, argv) => {
+        if (argv[0].toUpperCase() === 'BZPOPMIN') {
+            for (const key of argv.slice(1, -1)) {
+                const res = (await options.run([['ZPOPMIN', key]], s.database)).items[0];
+                if ('error' in res)
+                    return res;
+                if (Array.isArray(res.result) && res.result.length)
+                    return [key, ...res.result];
+            }
+            return null;
+        }
+        throw new Error('the blocking command has no executor');
+    };
+    const wake = async () => { for (const s of sessions)
+        if (s.blocked) {
+            const v = await blockRun(s, s.blocked.command);
+            if (v !== null)
+                unblock(s, v);
+        } };
+    const command = async (s, argv, executing = false) => {
+        if (!argv.length || s.closed)
+            return;
+        commandCount++;
+        const cmd = argv[0].toUpperCase(), a = argv.slice(1);
+        const shape = commandShapeError(argv, options.dialect);
+        if (shape) {
+            if (s.queue)
+                s.dirty = true;
+            answer(s, error(shape));
+            return;
+        }
+        if (!executing && !s.authenticated && !['AUTH', 'QUIT'].includes(cmd)) {
+            answer(s, error('NOAUTH Authentication required.'));
+            return;
+        }
+        if (!executing && s.subscriptions.size + s.patterns.size > 0 && !['SUBSCRIBE', 'PSUBSCRIBE', 'UNSUBSCRIBE', 'PUNSUBSCRIBE', 'PING', 'QUIT'].includes(cmd)) {
+            answer(s, error(`ERR Can't execute '${cmd.toLowerCase()}': only (P|S)SUBSCRIBE / (P|S)UNSUBSCRIBE / PING / QUIT / RESET are allowed in this context`));
+            return;
+        }
+        if (s.queue && !['EXEC', 'MULTI', 'DISCARD', 'QUIT'].includes(cmd)) {
+            s.queue.push(argv);
+            answer(s, new RedisStatus('QUEUED'));
+            return;
+        }
+        switch (cmd) {
+            // source: https://raw.githubusercontent.com/redis/redis/c9d29f6a918c335bc1778d9f68e521c1bbb36a0f/src/acl.c "Only two or three argument forms are allowed."
+            case 'AUTH': {
+                if (a.length > 2) {
+                    answer(s, error("ERR syntax error"));
+                    return;
+                }
+                if (!options.password && a.length === 1) {
+                    answer(s, error('ERR AUTH <password> called without any password configured for the default user. Are you sure your configuration is correct?'));
+                    return;
+                }
+                if (a.length === 2 && a[0] !== 'default' || options.password && a.at(-1) !== options.password) {
+                    answer(s, error('WRONGPASS invalid username-password pair or user is disabled.'));
+                    return;
+                }
+                s.authenticated = true;
+                answer(s, ok);
+                return;
+            }
+            case 'SELECT': {
+                let db;
+                try {
+                    db = commandInteger(a[0]);
+                }
+                catch {
+                    answer(s, error('ERR value is not an integer or out of range'));
+                    return;
+                }
+                if (db < -2147483648 || db > 2147483647) {
+                    answer(s, error('ERR value is out of range, value must between -2147483648 and 2147483647'));
+                    return;
+                }
+                if (db < 0 || db >= options.databases) {
+                    answer(s, error('ERR DB index is out of range'));
+                    return;
+                }
+                s.database = String(db);
+                answer(s, ok);
+                return;
+            }
+            case 'CLIENT': {
+                const sub = a[0].toUpperCase();
+                if (sub === 'SETNAME') {
+                    if (/[^\x21-\x7e]/.test(a[1] ?? '')) {
+                        answer(s, error('ERR Client names cannot contain spaces, newlines or special characters.'));
+                        return;
+                    }
+                    s.name = a[1] ?? '';
+                    answer(s, ok);
+                }
+                else if (sub === 'SETINFO') {
+                    if (!['LIB-NAME', 'LIB-VER'].includes(a[1].toUpperCase())) {
+                        answer(s, error(`ERR Unrecognized option '${a[1]}'`));
+                        return;
+                    }
+                    if (/[^\x21-\x7e]/.test(a[2])) {
+                        answer(s, error(`ERR ${a[1]} cannot contain spaces, newlines or special characters.`));
+                        return;
+                    }
+                    s.lib[a[1].toUpperCase()] = a[2];
+                    answer(s, ok);
+                }
+                else if (sub === 'LIST') {
+                    let clients = [...sessions];
+                    // source: https://raw.githubusercontent.com/redis/redis/c9d29f6a918c335bc1778d9f68e521c1bbb36a0f/src/networking.c "Invalid client ID"
+                    if (a[1]?.toUpperCase() === 'ID' && a.length > 2) {
+                        let ids;
+                        try {
+                            ids = a.slice(2).map((raw) => commandInteger(raw, 'ERR Invalid client ID'));
+                        }
+                        catch (e) {
+                            answer(s, error(e.message));
+                            return;
+                        }
+                        clients = ids.flatMap((id) => [...sessions].filter((x) => x.id === id));
+                    }
+                    else if (a[1]?.toUpperCase() === 'TYPE' && a.length === 3) {
+                        const type = a[2].toLowerCase();
+                        if (!['normal', 'pubsub', 'master', 'replica'].includes(type)) {
+                            answer(s, error(`ERR Unknown client type '${a[2]}'`));
+                            return;
+                        }
+                        clients = clients.filter((x) => type === (x.subscriptions.size + x.patterns.size ? 'pubsub' : 'normal'));
+                    }
+                    else if (a.length !== 1) {
+                        answer(s, error('ERR syntax error'));
+                        return;
+                    }
+                    answer(s, clients.map((x) => `id=${x.id} addr=127.0.0.1:0 name=${x.name} db=${x.database} flags=${x.subscriptions.size + x.patterns.size ? 'P' : 'N'} lib-name=${x.lib['LIB-NAME'] ?? ''} lib-ver=${x.lib['LIB-VER'] ?? ''}\n`).join(''));
+                }
+                else
+                    answer(s, error(options.dialect.unknownCommand(argv)));
+                return;
+            }
+            // source: https://raw.githubusercontent.com/redis/redis/c9d29f6a918c335bc1778d9f68e521c1bbb36a0f/src/server.c "It works in a different way if the client is in"
+            case 'PING':
+                if (a.length > 1) {
+                    answer(s, error("ERR wrong number of arguments for 'ping' command"));
+                    return;
+                }
+                answer(s, s.subscriptions.size + s.patterns.size ? ['pong', a[0] ?? ''] : a.length ? a[0] : new RedisStatus('PONG'));
+                return;
+            case 'INFO': {
+                const blocks = { server: `# Server\r\nredis_version:${options.version}\r\nredis_mode:standalone\r\n`, clients: `# Clients\r\nconnected_clients:${sessions.size}\r\nblocked_clients:${[...sessions].filter((x) => x.blocked).length}\r\n`, memory: `# Memory\r\nmaxmemory:0\r\nmaxmemory_policy:noeviction\r\n`, stats: `# Stats\r\ntotal_connections_received:${nextId}\r\ntotal_commands_processed:${commandCount}\r\n`, persistence: '# Persistence\r\nloading:0\r\n' };
+                answer(s, a.length && !['ALL', 'DEFAULT'].includes(a[0].toUpperCase()) ? a.map((x) => blocks[x.toLowerCase()] ?? '').join('') : Object.values(blocks).join('\r\n'));
+                return;
+            }
+            case 'MULTI':
+                if (s.queue)
+                    answer(s, error('ERR MULTI calls can not be nested'));
+                else {
+                    s.queue = [];
+                    s.dirty = false;
+                    answer(s, ok);
+                }
+                return;
+            case 'DISCARD':
+                if (!s.queue)
+                    answer(s, error('ERR DISCARD without MULTI'));
+                else {
+                    s.queue = null;
+                    s.dirty = false;
+                    answer(s, ok);
+                }
+                return;
+            case 'EXEC': {
+                if (!s.queue) {
+                    answer(s, error('ERR EXEC without MULTI'));
+                    return;
+                }
+                const q = s.queue;
+                s.queue = null;
+                if (s.dirty) {
+                    s.dirty = false;
+                    answer(s, error('EXECABORT Transaction discarded because of previous errors.'));
+                    return;
+                } // source: https://raw.githubusercontent.com/redis/redis/c9d29f6a918c335bc1778d9f68e521c1bbb36a0f/src/multi.c "Exec all the queued commands"
+                // Redis writes the queue length before dispatch; pub/sub may write multiple acknowledgement frames.
+                s.sink.write(binaryBytes(`*${q.length}\r\n`));
+                for (const queued of q)
+                    await command(s, queued, true);
+                await wake();
+                return;
+            }
+            case 'QUIT':
+                answer(s, ok);
+                close(s);
+                s.sink.end();
+                return;
+            case 'SUBSCRIBE':
+            case 'PSUBSCRIBE':
+            case 'UNSUBSCRIBE':
+            case 'PUNSUBSCRIBE': {
+                const target = cmd.includes('PSUB') || cmd.includes('PUNSUB') ? s.patterns : s.subscriptions;
+                const removing = cmd.includes('UNSUB');
+                const names = a.length ? a : [...target];
+                for (const name of names.length ? names : [null]) {
+                    if (name !== null) {
+                        if (removing)
+                            target.delete(name);
+                        else
+                            target.add(name);
+                    }
+                    answer(s, [cmd.toLowerCase(), name, s.subscriptions.size + s.patterns.size]);
+                }
+                return;
+            }
+            case 'PUBLISH': {
+                let count = 0;
+                for (const target of sessions) {
+                    if (target.subscriptions.has(a[0])) {
+                        answer(target, ['message', a[0], a[1]]);
+                        count++;
+                    }
+                    for (const pattern of target.patterns)
+                        if (globMatch(pattern, a[0])) {
+                            answer(target, ['pmessage', pattern, a[0], a[1]]);
+                            count++;
+                        }
+                }
+                answer(s, count);
+                return;
+            }
+            case 'BZPOPMIN': {
+                // source: https://raw.githubusercontent.com/redis/redis/c9d29f6a918c335bc1778d9f68e521c1bbb36a0f/src/timeout.c "timeout is negative"
+                const raw = a.at(-1);
+                const infinite = /^[+-]?inf(?:inity)?$/i.test(raw);
+                if (raw !== raw.trim() || raw === '' || !infinite && !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(raw)) {
+                    answer(s, error('ERR timeout is not a float or out of range'));
+                    return;
+                }
+                const millis = (infinite ? raw.startsWith('-') ? -Infinity : Infinity : Number(raw)) * 1000;
+                if (millis > 9223372036854775807) {
+                    answer(s, error('ERR timeout is out of range'));
+                    return;
+                }
+                const timeout = Math.ceil(millis);
+                if (!Number.isFinite(timeout) || timeout < 0) {
+                    answer(s, error('ERR timeout is negative'));
+                    return;
+                }
+                const v = await blockRun(s, argv);
+                if (v !== null) {
+                    answer(s, v);
+                    return;
+                }
+                // source: https://raw.githubusercontent.com/redis/redis/c9d29f6a918c335bc1778d9f68e521c1bbb36a0f/src/multi.c "we do not want to allow blocking commands inside multi"
+                if (executing) {
+                    answer(s, null);
+                    return;
+                }
+                const initial = await options.run([], s.database);
+                s.blocked = { command: argv, deadline: timeout === 0 ? Infinity : (initial.instant ?? 0) + timeout };
+                const poll = () => { if (!s.blocked || s.closed)
+                    return; s.blocked.timer = setTimeout(() => { void ordered(async () => { if (!s.blocked)
+                    return; const now = await options.run([], s.database); if ((now.instant ?? 0) >= s.blocked.deadline)
+                    unblock(s, null);
+                else
+                    poll(); }); }, 50); };
+                poll();
+                return;
+            }
+            default: {
+                const res = await options.run([argv], s.database);
+                const item = res.items[0];
+                answer(s, 'error' in item ? item : item.result);
+                if (res.wrote && !executing)
+                    await wake();
+            }
+        }
+    };
+    return (sink) => {
+        const s = { id: ++nextId, name: '', lib: {}, database: '0', authenticated: !options.password, queue: null, dirty: false, subscriptions: new Set(), patterns: new Set(), sink, closed: false };
+        sessions.add(s);
+        let buffer = '', chain = Promise.resolve();
+        const pending = [];
+        const pump = async () => { while (pending.length && !s.blocked && !s.closed)
+            await ordered(() => command(s, pending.shift())); };
+        s.pump = pump;
+        return {
+            data(chunk) { if (s.closed)
+                return; buffer += binaryText(chunk); try {
+                while (buffer.length) {
+                    let argv;
+                    let end;
+                    if (buffer[0] === '*') {
+                        const f = readResp(buffer);
+                        if (!f)
+                            break;
+                        if (!Array.isArray(f.value) || f.value.some((x) => typeof x !== 'string'))
+                            throw new Error('Protocol error: expected bulk string');
+                        argv = f.value;
+                        end = f.end;
+                    }
+                    else {
+                        const at = buffer.indexOf('\r\n');
+                        if (at < 0)
+                            break;
+                        argv = inlineCommand(buffer.slice(0, at));
+                        end = at + 2;
+                    }
+                    buffer = buffer.slice(end);
+                    pending.push(argv);
+                }
+                chain = chain.then(pump);
+            }
+            catch (e) {
+                answer(s, error(`ERR ${e.message}`));
+                close(s);
+                sink.end();
+            } },
+            settled: () => chain,
+            close: () => close(s),
+        };
+    };
+}

package/dist/src/remote-execute.d.ts

@@ -1,4 +1,6 @@
 export type RemoteExecuteRequest = {
+    /** The lane of a vendor of lanes that sends the call: the descriptor's `lanes` strategy picks its own by it. */
+    lane?: string;
     method: string;
     path: string;
     headers?: Record<string, string>;
@@ -16,8 +18,6 @@ export type RemoteExecuteRequest = {
      *  that its upload calls carry instead of the API token), on the root's own origin: it is sent as the request's
      *  Authorization and the sealed credential does not go with it. */
     issued?: string;
-    /** the lane of a vendor of lanes the request is (its strategy, when its lanes authenticate apart) */
-    lane?: string;
 };
 export type RemoteExecuteResponse = {
     status: number;

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

@@ -0,0 +1,11 @@
+/** Compressed-request output only: Node's plain requests remain uncapped; Bun retains its own plain-body limit.
+ * The default is Bun's existing largest plain body (128 MiB), so both runtimes decode the same.
+ * Source: bun-types/serve.d.ts, ServeOptions.maxRequestBodySize (@default 1024 * 1024 * 128),
+ * https://github.com/oven-sh/bun/blob/main/packages/bun-types/serve.d.ts .
+ * A pack's descriptor.maxRequestBodySize overrides decoded output as it does Bun's plain-body limit. */
+export declare const DEFAULT_MAX_DECODED_REQUEST_BODY_SIZE: number;
+export declare class RequestBodyTooLargeError extends Error {
+    constructor();
+}
+export declare const oversizedBody: () => Response;
+export declare const decodedBodyLimit: (declared?: number) => number;

package/dist/src/request-body.js

@@ -0,0 +1,11 @@
+/** Compressed-request output only: Node's plain requests remain uncapped; Bun retains its own plain-body limit.
+ * The default is Bun's existing largest plain body (128 MiB), so both runtimes decode the same.
+ * Source: bun-types/serve.d.ts, ServeOptions.maxRequestBodySize (@default 1024 * 1024 * 128),
+ * https://github.com/oven-sh/bun/blob/main/packages/bun-types/serve.d.ts .
+ * A pack's descriptor.maxRequestBodySize overrides decoded output as it does Bun's plain-body limit. */
+export const DEFAULT_MAX_DECODED_REQUEST_BODY_SIZE = 128 * 1024 * 1024;
+export class RequestBodyTooLargeError extends Error {
+    constructor() { super('Payload Too Large'); this.name = 'RequestBodyTooLargeError'; }
+}
+export const oversizedBody = () => new Response('Payload Too Large', { status: 413 });
+export const decodedBodyLimit = (declared) => declared ?? DEFAULT_MAX_DECODED_REQUEST_BODY_SIZE;

package/dist/src/runtime.d.ts

@@ -11,7 +11,7 @@ export { currentTraceparent, deliveryTraceHeaders, newTraceparent, parseTracepar
 export type { Traceparent } from './trace-context.js';
 export type { DerivedCall, DerivedCoreOutcome, DerivedFetch, DerivedFetchOptions, DerivedHandler, DerivedOperation, DerivedOwner, DerivedSurface, BoardFrame } 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 { deliverEvents, fillEnvelope, setDeliveryObserver, 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';
@@ -69,14 +69,14 @@ export { observeResource, observeResources, collectObservations, foldObservation
 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 { serveHttp, serveStream, connectWebSocket, 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 { multipartBoundary, multipartParts, multipartEnvelope, inferMultipartBoundary, multipartDelimiterPattern, type MultipartPart, type MultipartFramedPart, type MultipartEnvelope } 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 { setInProcessTwins, vendorFetch, VendorUnreachableError, type InProcessTwin } from './vendor-call.js';
+export { closeManagedDatabases, databaseSession, EngineDatabaseError, EngineUnavailableError, managedDatabase, quoteIdent, useDatabaseDriver, type DatabaseDriver, type DatabaseSession } 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';
@@ -84,4 +84,5 @@ export { captureHistory, captureParentHistory, historyChanges, historyAtInstant,
 export type { HistoryView, HistoryLayout, HistoryReference, HistoryOrigin } from './history.js';
 export { foldHistory } from './log.js';
 export { volterHome } from './volter-home.js';
+export type { MachinePool, MachineSpec, MachineProcess, MachineStatus, MachineFiles, MachineFileStat, GuestImage, LightPoolOptions } from './machines.js';
 export { boardFrameKey } from './board-keys.js';

package/dist/src/runtime.js

@@ -17,7 +17,7 @@ export { isReadOnlyRequest, READ_ONLY_REQUEST_HEADER, ReadOnlyRequestError, runA
 export { compileSurface, createDerivedFetch, matchOperation } from "./derived.js";
 export { currentTraceparent, deliveryTraceHeaders, newTraceparent, parseTraceparent, runWithRequestTrace, runWithTraceparent, TRACEPARENT_HEADER, traceparentForDelivery, validTraceparent } from "./trace-context.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 { deliverEvents, fillEnvelope, setDeliveryObserver, signEvent, signEventAll, verifyEvent } from "./events.js";
 export { equalSecrets, hmac, jwks, jwtDecode, jwtSign, jwtVerify, keyId, lettersFrom, md5, sha256, SIGNING_ALGORITHMS, uuidFrom } from "./signing.js";
 export { emitTwinEvent, eventSubscriptionMatches, listEmittable, runEmitCli } from "./emit.js";
 // The vendor-agnostic CLIENT-SIDE RATE BUDGET — the fail-closed backstop a pack's guarded client
@@ -88,16 +88,16 @@ export { observeResource, observeResources, collectObservations, foldObservation
 export { readTreeMap, readParentTreeMap, treeStamp, treeChangesSince, originEntries, appendOriginEntry, originLogPath, isUrlParent, parentPosition, positionAt, splitsBatch, assertBatchBoundary } from "./log.js";
 export { referenceField, registerReferences, packReferences, resolveReferences } from "./references.js";
 // the HTTP server seam: the one place the serve path meets the runtime (Bun or Node)
-export { serveHttp, serveStream, nodeBuiltin, WORLD_BOOT_PATH } from "./serve-http.js";
+export { serveHttp, serveStream, connectWebSocket, nodeBuiltin, WORLD_BOOT_PATH } from "./serve-http.js";
 // two runtime-neutral helpers for a serve path: a file as a Response, a page's client bundle
 export { fileResponse, contentTypeOf } from "./file-response.js";
 export { bundleClient, filePathOf } from "./client-bundle.js";
 // the brand's tokens and faces for a Volter page (the console, the site, the UI kit), fetched at build
 export { brandTokensResponse } from "./brand-tokens.js";
-export { multipartBoundary, multipartParts } from "./multipart.js";
+export { multipartBoundary, multipartParts, multipartEnvelope, inferMultipartBoundary, multipartDelimiterPattern } from "./multipart.js";
 export { corsHeaders, withCors } from "./cors.js";
-export { vendorFetch, VendorUnreachableError } from "./vendor-call.js";
-export { closeManagedDatabases, EngineDatabaseError, EngineUnavailableError, managedDatabase, quoteIdent, useDatabaseDriver, WORLD_CLOCK_SETTING, worldClockSql } from "./managed-database.js";
+export { setInProcessTwins, vendorFetch, VendorUnreachableError } from "./vendor-call.js";
+export { closeManagedDatabases, databaseSession, EngineDatabaseError, EngineUnavailableError, managedDatabase, quoteIdent, useDatabaseDriver } 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";

package/dist/src/s3/wire.d.ts

@@ -14,7 +14,7 @@ export type CorsRule = {
     allowedMethods: string[];
     allowedHeaders: string[];
     exposeHeaders: string[];
-    maxAgeSeconds?: number;
+    maxAgeSeconds?: number | string;
 };
 export declare function parseCors(xml: string): CorsRule[];
 export declare function corsXml(rules: CorsRule[]): string;
@@ -34,11 +34,11 @@ export type LifecycleRule = {
     prefix: string;
     prefixOnRule?: boolean;
     noPrefix?: boolean;
-    expireDays?: number;
+    expireDays?: number | string;
     expireDate?: string;
-    abortMultipartDays?: number;
+    abortMultipartDays?: number | string;
     transitions?: Array<{
-        days?: number;
+        days?: number | string;
         date?: string;
         storageClass: string;
     }>;

package/dist/src/s3/wire.js

@@ -1,3 +1,4 @@
+import { exactInteger } from "../exact-json.js";
 // S3'S WIRE — the XML bodies S3 answers and reads, a bucket's CORS and lifecycle documents, a delete batch, an object's
 // ETag, and a request's body kept as its bytes (docs/contributing/architecture.md, "Other wires": S3's wire is a kernel
 // library, as Redis's command core is). Every vendor that speaks S3's API speaks this wire: AWS S3 itself, Cloudflare
@@ -5,6 +6,7 @@
 // what they refuse, what they implement) is each pack's own. Moved here from the cloudflare pack's R2 lane, which had it
 // ported from the aws pack's S3 code; a pack may import neither (B4). Importing this module does nothing.
 import { createHash } from 'node:crypto';
+const wireInteger = (text) => /^[+-]?\d+$/.test(text) ? exactInteger(text) : Number(text);
 // ── XML ──────────────────────────────────────────────────────────────────────────────────────
 const DECL = '<?xml version="1.0" encoding="UTF-8"?>';
 const NS = 'http://s3.amazonaws.com/doc/2006-03-01/';
@@ -36,7 +38,7 @@ export function parseCors(xml) {
         const b = m[1];
         const id = oneOf(b, 'ID');
         const age = oneOf(b, 'MaxAgeSeconds');
-        return { ...(id ? { id } : {}), allowedOrigins: allOf(b, 'AllowedOrigin'), allowedMethods: allOf(b, 'AllowedMethod'), allowedHeaders: allOf(b, 'AllowedHeader'), exposeHeaders: allOf(b, 'ExposeHeader'), ...(age ? { maxAgeSeconds: Number(age) } : {}) };
+        return { ...(id ? { id } : {}), allowedOrigins: allOf(b, 'AllowedOrigin'), allowedMethods: allOf(b, 'AllowedMethod'), allowedHeaders: allOf(b, 'AllowedHeader'), exposeHeaders: allOf(b, 'ExposeHeader'), ...(age ? { maxAgeSeconds: wireInteger(age) } : {}) };
     });
 }
 export function corsXml(rules) {
@@ -83,11 +85,11 @@ export function parseLifecycle(xml) {
         const transitions = [...b.matchAll(/<Transition>([\s\S]*?)<\/Transition>/g)].map((x) => {
             const d = oneOf(x[1], 'Days');
             const on = oneOf(x[1], 'Date');
-            return { ...(d !== undefined ? { days: Number(d) } : {}), ...(on !== undefined ? { date: on } : {}), storageClass: oneOf(x[1], 'StorageClass') ?? '' };
+            return { ...(d !== undefined ? { days: wireInteger(d) } : {}), ...(on !== undefined ? { date: on } : {}), storageClass: oneOf(x[1], 'StorageClass') ?? '' };
         });
         return {
             id: oneOf(b, 'ID') ?? '', enabled: (oneOf(b, 'Status') ?? 'Enabled') === 'Enabled', prefix: oneOf(b, 'Prefix') ?? '', ...(/<Filter>/.test(b) ? {} : /<Prefix>/.test(b) ? { prefixOnRule: true } : { noPrefix: true }),
-            ...(days ? { expireDays: Number(days) } : {}), ...(date ? { expireDate: date } : {}), ...(after ? { abortMultipartDays: Number(after) } : {}), ...(transitions.length ? { transitions } : {}),
+            ...(days ? { expireDays: wireInteger(days) } : {}), ...(date ? { expireDate: date } : {}), ...(after ? { abortMultipartDays: wireInteger(after) } : {}), ...(transitions.length ? { transitions } : {}),
         };
     });
 }

package/dist/src/scenario.d.ts

@@ -36,6 +36,8 @@ export type PackScenarioAdapter<Req> = {
     scopeKey?: (req: Req) => string;
     /** The VENDOR'S error envelope for a `status` fault — a 429 from this vendor looks like this
      *  vendor's 429. Omitted → the kernel's envelope `{ error: { message, type: "twin_fault" } }`. */
+    /** Opt-in scope check for post-admission model generation failures; absent rejects them. */
+    validateGenerationFault?: (fault: ScenarioGenerationFault, handler: ScenarioHandler) => string | null;
     renderFault?: (fault: ScenarioStatusFault, req: Req) => {
         body: unknown;
         headers?: Record<string, string>;
@@ -49,6 +51,7 @@ export type PackScenarioAdapter<Req> = {
  *    status — answer this HTTP status instead of serving: a 4xx/5xx the vendor's own envelope
  *             (the pack's adapter renders it; a kernel envelope when it declares none), with
  *             `Retry-After` when `retryAfterSeconds` is set;
+ *    generation — opt-in post-admission compute failure, carried to the handler for its SDK error wire;
  *    drop   — never answer: the request hangs until the client's own timeout ends it (what an
  *             outage looks like from the client; a TCP reset is not something a fetch can do),
  *             released after `holdMs` (default 300 000) so a socket is not held forever. */
@@ -60,10 +63,23 @@ export type ScenarioFault = {
     status: number;
     retryAfterSeconds?: number;
     message?: string;
+    errorType?: string;
+    metadata?: Record<string, unknown>;
+} | {
+    kind: "generation";
+    status: number;
+    message: string;
+    errorType: string;
+    metadata?: Record<string, unknown>;
+    partialText?: string;
+    event?: string;
 } | {
     kind: "drop";
     holdMs?: number;
 };
+export type ScenarioGenerationFault = Extract<ScenarioFault, {
+    kind: "generation";
+}>;
 export type ScenarioStatusFault = Extract<ScenarioFault, {
     kind: "status";
 }>;
@@ -186,7 +202,13 @@ export declare function statefulTwinManifest(input: {
     twinOf: string;
     stores: string;
     identity?: string;
+    behavior?: string;
     notes?: string;
+    doors?: ReadonlyArray<{
+        method: string;
+        path: string;
+        note?: string;
+    }>;
 }): Record<string, unknown>;
 /** The GET /twin manifest — the discovery door's body. Education ships INSIDE the twin:
  *  in-world agents have no repos or skills, only HTTP. */