@volter/world-core 3.0.125 → 3.0.127

package/dist/src/derived-core.d.ts

@@ -1151,6 +1151,8 @@ export declare function coreFor(m: DerivedManifest, scope?: CoreScope): {
 /** The header the kernel names a scenario's decision in, set by createPackFetch alone (it strips it from every request it
  *  is sent). */
 export declare const SCENARIO_DECISION_HEADER = "x-volter-scenario-decision";
+/** HTTP field values are bytes; JSON escapes retain Unicode without putting it directly in a header. */
+export declare function scenarioDecisionHeader(decision: ScenarioDecision): string;
 export declare function authRefusal(m: DerivedManifest, request: Request, root?: string): Response | undefined;
 export declare function crossCutting(m: DerivedManifest, opts?: CoreScope & {
     readOnly?: boolean;

package/dist/src/derived-core.js

@@ -697,6 +697,8 @@ function recordedInput(m, call, merged) {
 }
 /** The scope each call is served in (serveCore, contextFor), for the contexts a write opens for its hooks. */
 const scopeOfCall = new WeakMap();
+/** The intact copy contextFor already keeps for core(), before a handler can consume its request. */
+const requestOfCall = new WeakMap();
 async function writeDetailed(m, call, resource, id, fields, operation, params, root, occurredAt, checks) {
     const before = stateBeforeWrite(m, resource, id, root);
     const withFiles = async (input) => { const files = input.operationId ? await keptFiles(m, call, root) : undefined; return files ? { ...input, files } : input; };
@@ -736,16 +738,17 @@ async function finishWrite(m, call, resource, row, result, operation, params, ro
     const body = view(m, resource, row);
     // the write's own context for its hooks, in the scope the call was served in (a walk's application answers, a tenant,
     // the managed database), at the write's moment
-    const context = () => contextFor(m, { ...call, request: call.request.clone() }, { ...(scopeOfCall.get(call) ?? {}), ...(root !== undefined ? { root } : {}), clock: () => occurredAt });
+    const request = requestOfCall.get(call) ?? call.request;
+    const context = () => contextFor(m, { ...call, request: request.clone() }, { ...(scopeOfCall.get(call) ?? {}), ...(root !== undefined ? { root } : {}), clock: () => occurredAt });
     if (m.onWrite)
-        await m.onWrite({ operation, storedType: storedType(m, resource), body, ...(root !== undefined ? { root } : {}), occurredAt, request: call.request, context });
+        await m.onWrite({ operation, storedType: storedType(m, resource), body, ...(root !== undefined ? { root } : {}), occurredAt, request: request.clone(), context });
     if (m.events) {
         const events = m.events;
-        const write = { operation, storedType: storedType(m, resource), body, ...(root !== undefined ? { root } : {}), occurredAt, request: call.request };
+        const write = { operation, storedType: storedType(m, resource), body, ...(root !== undefined ? { root } : {}), occurredAt, request: request.clone() };
         await deliverEvents(m.service, events, write, async (type) => (events.render ? events.render(await context(), write, type) : body), undefined, events.values ? async (type) => events.values(await context(), write, type) : undefined);
     }
     if (m.sockets?.length)
-        socketWrite(m.service, root, { operation, storedType: storedType(m, resource), body, ...(root !== undefined ? { root } : {}), occurredAt, request: call.request });
+        socketWrite(m.service, root, { operation, storedType: storedType(m, resource), body, ...(root !== undefined ? { root } : {}), occurredAt, request: request.clone() });
     // a read held until the World writes (held-reads.ts) hears it
     heldReadsWrite(m.service, root, storedType(m, resource));
     // the subject's id as it stands after the write: the vendor's, when a live head minted one
@@ -1311,6 +1314,7 @@ export async function contextFor(m, call, scope) {
     // every read of the body is of a copy, so the handler's own `call.request` and the core's answer (`core()`) each
     // still find it unread, whichever of them reads it first
     const pristine = call.request.clone();
+    requestOfCall.set(call, pristine);
     const params = await boundaryParams(m, { ...call, request: call.request.clone() }, root).catch((error) => {
         // An around context opens before the credential/JSON guard. Keep non-body parameters available to it without
         // turning the guard's declared malformed-body refusal into a context-construction exception.
@@ -1582,6 +1586,10 @@ const hex = (s) => Array.from(new TextEncoder().encode(s), (b) => b.toString(16)
 /** The header the kernel names a scenario's decision in, set by createPackFetch alone (it strips it from every request it
  *  is sent). */
 export const SCENARIO_DECISION_HEADER = 'x-volter-scenario-decision';
+/** HTTP field values are bytes; JSON escapes retain Unicode without putting it directly in a header. */
+export function scenarioDecisionHeader(decision) {
+    return JSON.stringify(decision).replace(/[\u007f-\uffff]/g, (unit) => `\\u${unit.charCodeAt(0).toString(16).padStart(4, '0')}`);
+}
 function scenarioDecisionOf(request) {
     const raw = request.headers.get(SCENARIO_DECISION_HEADER);
     if (!raw)

package/dist/src/pack-fetch.js

@@ -11,7 +11,7 @@ import { ORIGINAL_PATH_HEADER } from "./sigv4.js";
 import { placedCookies, TWIN_PREFIX_HEADER } from "./twin-fetch.js";
 import { PREFIX_PARAMS_HEADER } from "./derived.js";
 import { withHeaders } from "./with-headers.js";
-import { authRefusal, bindSemantics, contextFor, LANE_HEADER, SCENARIO_DECISION_HEADER, coreFor, crossCutting, derivedRequestScopes, vendorError } from "./derived-core.js";
+import { authRefusal, bindSemantics, contextFor, LANE_HEADER, SCENARIO_DECISION_HEADER, scenarioDecisionHeader, coreFor, crossCutting, derivedRequestScopes, vendorError } from "./derived-core.js";
 import { compileSurface, createDerivedFetch, matchOperation, pathParams } from "./derived.js";
 import { isReadOnlyRequest, READ_ONLY_REQUEST_HEADER, runAsVendorMove } from "./request-scope.js";
 import { parseScenarioDocument, ScenarioEngine, ScenarioError, statefulTwinManifest, twinManifest } from "./scenario.js";
@@ -220,7 +220,7 @@ export function createPackFetch(parts, options = {}) {
         }
         if (decision.kind === 'fault')
             return Response.json(decision.result.body, { status: decision.result.status, headers: decision.result.headers ?? {} });
-        return api(withHeaders(request, new Headers([...request.headers, [SCENARIO_DECISION_HEADER, JSON.stringify(decision)]])));
+        return api(withHeaders(request, new Headers([...request.headers, [SCENARIO_DECISION_HEADER, scenarioDecisionHeader(decision)]])));
     };
     const doors = (m.doors ?? []).map((d) => {
         const answer = parts.doors?.[d.id];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/world-core",
-  "version": "3.0.125",
+  "version": "3.0.127",
   "description": "The kernel of Volter World: one log per twin, branches as pointers, checkpoints, the fold that keeps a twin current, the head that performs a write against the vendor, references, and the git plane. A twin package builds on it; the runtime serves it.",
   "keywords": [
     "twin",

package/src/derived-core.ts

@@ -1165,6 +1165,8 @@ function recordedInput(m: DerivedManifest, call: DerivedCall, merged: Record<str
 
 /** The scope each call is served in (serveCore, contextFor), for the contexts a write opens for its hooks. */
 const scopeOfCall = new WeakMap<DerivedCall, CoreScope>();
+/** The intact copy contextFor already keeps for core(), before a handler can consume its request. */
+const requestOfCall = new WeakMap<DerivedCall, Request>();
 
 async function writeDetailed(m: DerivedManifest, call: DerivedCall, resource: string, id: string, fields: Record<string, unknown>, operation: string, params: Record<string, unknown>, root: string | undefined, occurredAt: string, checks?: StateChecks): Promise<{ body: Record<string, unknown>; id: string; vendorData?: unknown }> {
   const before = stateBeforeWrite(m, resource, id, root);
@@ -1215,14 +1217,15 @@ async function finishWrite(m: DerivedManifest, call: DerivedCall, resource: stri
   const body = view(m, resource, row);
   // the write's own context for its hooks, in the scope the call was served in (a walk's application answers, a tenant,
   // the managed database), at the write's moment
-  const context = (): Promise<SemanticsContext> => contextFor(m, { ...call, request: call.request.clone() }, { ...(scopeOfCall.get(call) ?? {}), ...(root !== undefined ? { root } : {}), clock: () => occurredAt });
-  if (m.onWrite) await m.onWrite({ operation, storedType: storedType(m, resource), body, ...(root !== undefined ? { root } : {}), occurredAt, request: call.request, context });
+  const request = requestOfCall.get(call) ?? call.request;
+  const context = (): Promise<SemanticsContext> => contextFor(m, { ...call, request: request.clone() }, { ...(scopeOfCall.get(call) ?? {}), ...(root !== undefined ? { root } : {}), clock: () => occurredAt });
+  if (m.onWrite) await m.onWrite({ operation, storedType: storedType(m, resource), body, ...(root !== undefined ? { root } : {}), occurredAt, request: request.clone(), context });
   if (m.events) {
     const events = m.events;
-    const write = { operation, storedType: storedType(m, resource), body, ...(root !== undefined ? { root } : {}), occurredAt, request: call.request };
+    const write = { operation, storedType: storedType(m, resource), body, ...(root !== undefined ? { root } : {}), occurredAt, request: request.clone() };
     await deliverEvents(m.service, events, write, async (type) => (events.render ? events.render(await context(), write, type) : body), undefined, events.values ? async (type) => events.values!(await context(), write, type) : undefined);
   }
-  if (m.sockets?.length) socketWrite(m.service, root, { operation, storedType: storedType(m, resource), body, ...(root !== undefined ? { root } : {}), occurredAt, request: call.request });
+  if (m.sockets?.length) socketWrite(m.service, root, { operation, storedType: storedType(m, resource), body, ...(root !== undefined ? { root } : {}), occurredAt, request: request.clone() });
   // a read held until the World writes (held-reads.ts) hears it
   heldReadsWrite(m.service, root, storedType(m, resource));
   // the subject's id as it stands after the write: the vendor's, when a live head minted one
@@ -1929,6 +1932,7 @@ export async function contextFor(m: DerivedManifest, call: DerivedCall, scope: C
   // every read of the body is of a copy, so the handler's own `call.request` and the core's answer (`core()`) each
   // still find it unread, whichever of them reads it first
   const pristine = call.request.clone();
+  requestOfCall.set(call, pristine);
   const params = await boundaryParams(m, { ...call, request: call.request.clone() }, root).catch((error) => {
     // An around context opens before the credential/JSON guard. Keep non-body parameters available to it without
     // turning the guard's declared malformed-body refusal into a context-construction exception.
@@ -2184,6 +2188,10 @@ const hex = (s: string): string => Array.from(new TextEncoder().encode(s), (b) =
 /** The header the kernel names a scenario's decision in, set by createPackFetch alone (it strips it from every request it
  *  is sent). */
 export const SCENARIO_DECISION_HEADER = 'x-volter-scenario-decision';
+/** HTTP field values are bytes; JSON escapes retain Unicode without putting it directly in a header. */
+export function scenarioDecisionHeader(decision: ScenarioDecision): string {
+  return JSON.stringify(decision).replace(/[\u007f-\uffff]/g, (unit) => `\\u${unit.charCodeAt(0).toString(16).padStart(4, '0')}`);
+}
 function scenarioDecisionOf(request: Request): ScenarioDecision | undefined {
   const raw = request.headers.get(SCENARIO_DECISION_HEADER);
   if (!raw) return undefined;

package/src/pack-fetch.ts

@@ -11,7 +11,7 @@ import { ORIGINAL_PATH_HEADER } from './sigv4.ts';
 import { placedCookies, TWIN_PREFIX_HEADER } from './twin-fetch.ts';
 import { PREFIX_PARAMS_HEADER } from './derived.ts';
 import { withHeaders } from './with-headers.ts';
-import { authRefusal, bindSemantics, contextFor, LANE_HEADER, SCENARIO_DECISION_HEADER, coreFor, crossCutting, derivedRequestScopes, vendorError, type CoreScope, type DerivedManifest, type ErrorSpec, type Handler, type HandlerContext, type LanesDecl, type VendorManifest } from './derived-core.ts';
+import { authRefusal, bindSemantics, contextFor, LANE_HEADER, SCENARIO_DECISION_HEADER, scenarioDecisionHeader, coreFor, crossCutting, derivedRequestScopes, vendorError, type CoreScope, type DerivedManifest, type ErrorSpec, type Handler, type HandlerContext, type LanesDecl, type VendorManifest } from './derived-core.ts';
 import { compileSurface, createDerivedFetch, matchOperation, pathParams, type DerivedFetch, type DerivedOperation, type DerivedOwner, type DerivedSurface, type Workspace, type BoardFrame } from './derived.ts';
 import { isReadOnlyRequest, READ_ONLY_REQUEST_HEADER, runAsVendorMove } from './request-scope.ts';
 import { parseScenarioDocument, ScenarioEngine, ScenarioError, statefulTwinManifest, twinManifest, type PackScenarioAdapter } from './scenario.ts';
@@ -274,7 +274,7 @@ export function createPackFetch(parts: PackParts, options: PackFetchOptions = {}
       return vendorError(m, { status: 500, code: 'scenario_error', message: `the World's scenario: ${error.message}` });
     }
     if (decision.kind === 'fault') return Response.json(decision.result.body, { status: decision.result.status, headers: decision.result.headers ?? {} });
-    return api(withHeaders(request, new Headers([...request.headers, [SCENARIO_DECISION_HEADER, JSON.stringify(decision)]])));
+    return api(withHeaders(request, new Headers([...request.headers, [SCENARIO_DECISION_HEADER, scenarioDecisionHeader(decision)]])));
   };
   const doors = (m.doors ?? []).map((d) => {
     const answer = parts.doors?.[d.id];