@piagent/platform 1.6.1 → 1.8.0

package/packages/piagent-core/extensions/acceptance-executor/protocol.mjs

@@ -0,0 +1,248 @@
+import { protocolShape as shape, validateValue } from "./values.mjs";
+import { MAX_SOURCE_BYTES, validateModuleGraph } from "./module-graph.mjs";
+import { CASE_THREAD_CPU_MICROS } from "./budget.mjs";
+import { CASE_CAPABILITY_FIELDS, OBSERVATION_CAPABILITY_FIELDS, callbackIds, validateCaseCapabilities, validateObservedCapabilities } from "./capabilities.mjs";
+import { resolveArguments } from "./references.mjs";
+import { expectedNodeProfile, MAX_TIMER_SCHEDULES, NODE_PROFILE_WORKER_VERSION } from "./node-profile.mjs";
+import { validateInvocation } from "./invocation.mjs";
+export { MAX_STRING_LENGTH, numberValue, validateValue } from "./values.mjs";
+
+export const WORKER_VERSION = "quickjs-contract-worker-v9";
+export const NODE_WORKER_VERSION = NODE_PROFILE_WORKER_VERSION;
+export const MAX_REQUEST_BYTES = 512 * 1024;
+export const MAX_RESPONSE_BYTES = 1024 * 1024;
+const ID = /^[a-zA-Z0-9][a-zA-Z0-9:._-]{0,159}$/;
+const EXPORT = /^[a-zA-Z_$][\w$]{0,127}$/;
+
+export function parseRequest(text) {
+  if (typeof text !== "string" || Buffer.byteLength(text) > MAX_REQUEST_BYTES) throw new TypeError("Request size exceeded");
+  const request = JSON.parse(text);
+  const nodeProfile = request?.schemaVersion === 2;
+  shape(request, ["schemaVersion", "profile", "source", "exportName", "cases", "moduleGraph"],
+    nodeProfile ? ["schemaVersion", "profile", "source", "exportName", "cases"] : ["schemaVersion", "source", "exportName", "cases"]);
+  if (!nodeProfile && request.schemaVersion !== 1 || typeof request.source !== "string" || Buffer.byteLength(request.source) > MAX_SOURCE_BYTES
+    || typeof request.exportName !== "string" || !EXPORT.test(request.exportName)
+    || !Array.isArray(request.cases) || request.cases.length < 1 || request.cases.length > 256) throw new TypeError("Invalid execution request");
+  if (nodeProfile) {
+    shape(request.profile, ["id", "digest", "workerVersion"]);
+    const expected = expectedNodeProfile();
+    if (request.profile.id !== expected.id || request.profile.digest !== expected.digest || request.profile.workerVersion !== expected.workerVersion) {
+      throw new TypeError("Invalid Node profile identity");
+    }
+  } else if (Object.hasOwn(request, "profile")) throw new TypeError("Unexpected execution profile");
+  if (Object.hasOwn(request, "moduleGraph")) validateModuleGraph(request.source, request.moduleGraph, { nodeProfile });
+  const ids = new Map(), closedSequences = new Set();
+  const receivers = new Map();
+  let sequence;
+  for (const item of request.cases) {
+    shape(item, ["id", "args", "clock", "sequence", "exportName", "reset", "observeArgs", "invocation", ...CASE_CAPABILITY_FIELDS],
+      nodeProfile ? ["id", "args", "invocation"] : ["id", "args"]);
+    if (typeof item.id !== "string" || !ID.test(item.id) || ids.has(item.id)
+      || !Array.isArray(item.args) || item.args.length > 16
+      || (Object.hasOwn(item, "clock") && (!Number.isSafeInteger(item.clock) || Math.abs(item.clock) > 8.64e15))) {
+      throw new TypeError("Invalid execution case");
+    }
+    if (Object.hasOwn(item, "sequence") && (typeof item.sequence !== "string" || !ID.test(item.sequence))
+      || Object.hasOwn(item, "exportName") && (typeof item.exportName !== "string" || !EXPORT.test(item.exportName))
+      || Object.hasOwn(item, "reset") && (item.reset !== true || !item.sequence)
+      || Object.hasOwn(item, "observeArgs") && typeof item.observeArgs !== "boolean") throw new TypeError("Invalid sequence operation");
+    if (sequence !== item.sequence) {
+      if (sequence !== undefined) closedSequences.add(sequence);
+      if (closedSequences.has(item.sequence)) throw new TypeError("Non-contiguous sequence");
+      sequence = item.sequence; receivers.clear();
+    }
+    if (item.reset) receivers.clear();
+    if (nodeProfile) {
+      validateInvocation(item.invocation);
+      if (item.invocation.kind === "construct") {
+        if (!item.sequence || receivers.size || receivers.has(item.invocation.receiverId) || item.awaitResult || item.observeIdentity) {
+          throw new TypeError("Invalid receiver construction");
+        }
+        receivers.set(item.invocation.receiverId, item.sequence);
+      } else if (item.invocation.kind === "method") {
+        if (!item.sequence || receivers.get(item.invocation.receiverId) !== item.sequence) throw new TypeError("Unknown receiver");
+      }
+      if (item.invocation.kind === "construct" && item.referencePairs?.some(pair => [pair.left, pair.right].some(selector => selector.root !== "argument"))) {
+        throw new TypeError("Constructed receivers are not observable roots");
+      }
+    } else if (Object.hasOwn(item, "invocation")) throw new TypeError("Unexpected invocation");
+    const budget = nodeProfile ? { rawBytes: 0, textBytes: 0 } : undefined;
+    const callbacks = validateCaseCapabilities(item, { nodeProfile, budget });
+    item.args.forEach((value) => {
+      if (!["result", "error-property"].includes(value?.type)) {
+        validateValue(value, true, callbacks, { typedBytes: nodeProfile, budget }); return;
+      }
+      shape(value, value.type === "result" ? ["type", "value"] : ["type", "value", "key"]);
+      if (typeof value.value !== "string" || !item.sequence || !ids.has(value.value) || ids.get(value.value).sequence !== item.sequence) {
+        throw new TypeError("Result references require an earlier case in the same sequence");
+      }
+      if (value.type === "error-property" && (!ids.get(value.value).observeError || typeof value.key !== "string" || value.key.length > 128)) {
+        throw new TypeError("Error property references require an earlier error observation");
+      }
+    });
+    ids.set(item.id, item);
+  }
+  return request;
+}
+
+export function parseResponse(text, request, requestDigest) {
+  if (typeof text !== "string" || Buffer.byteLength(text) > MAX_RESPONSE_BYTES) throw new TypeError("Response size exceeded");
+  const response = JSON.parse(text);
+  if (request.schemaVersion === 2) return parseNodeResponse(response, request, requestDigest);
+  shape(response, ["schemaVersion", "workerVersion", "requestDigest", "status", "cases", "timeoutReason"],
+    ["schemaVersion", "workerVersion", "requestDigest", "status", "cases"]);
+  if (response.schemaVersion !== 1 || response.workerVersion !== WORKER_VERSION || response.requestDigest !== requestDigest
+    || !["completed", "timeout", "error"].includes(response.status) || !Array.isArray(response.cases)
+    || response.cases.length > request.cases.length
+    || (response.status === "completed" && response.cases.length !== request.cases.length)) throw new TypeError("Invalid worker response");
+  const observations = new Map();
+  for (const [index, item] of response.cases.entries()) {
+    shape(item, ["id", "outcome", "value", "errorClass", "reason", "dateArgsAfter", "clockReads", "argsAfter", "resources", ...OBSERVATION_CAPABILITY_FIELDS], ["id", "outcome"]);
+    if (item.id !== request.cases[index].id || !["return", "throw", "unsupported", "error"].includes(item.outcome)) throw new TypeError("Invalid case observation");
+    if (item.outcome === "return") {
+      validateValue(item.value, false);
+      if (Object.hasOwn(item, "errorClass") || Object.hasOwn(item, "reason")) throw new TypeError("Conflicting return observation");
+    } else if (item.outcome === "throw") {
+      if (!["TypeError", "RangeError", "SyntaxError", "ReferenceError", "EvalError", "URIError", "Error", "non-error"].includes(item.errorClass)
+        || Object.hasOwn(item, "value") || Object.hasOwn(item, "reason")) throw new TypeError("Invalid throw observation");
+    } else if (typeof item.reason !== "string" || !/^[a-z-]{1,64}$/.test(item.reason)
+      || Object.hasOwn(item, "value") || Object.hasOwn(item, "errorClass")) throw new TypeError("Invalid incomplete observation");
+    const resourceStop = item.outcome === "error" && ["guest-cpu-budget", "guest-wall-deadline"].includes(item.reason);
+    if (resourceStop) {
+      shape(item.resources, ["caseCpuMicros", "caseThreadCpuMicros", "caseWallMicros"]);
+      if (!Object.values(item.resources).every(value => Number.isSafeInteger(value) && value >= 0)
+        || (item.reason === "guest-cpu-budget" && item.resources.caseThreadCpuMicros < CASE_THREAD_CPU_MICROS)) {
+        throw new TypeError("Invalid resource stop observation");
+      }
+    } else if (Object.hasOwn(item, "resources")) throw new TypeError("Unexpected resource stop observation");
+    if (["return", "throw"].includes(item.outcome)) {
+      const resolved = resolveArguments(request.cases[index].args, observations);
+      if (resolved.some(arg => arg === undefined)) throw new TypeError("Unavailable referenced observation");
+      const expectedIndexes = resolved.flatMap((arg, argIndex) => arg.type === "date" ? [argIndex] : []);
+      if (!Array.isArray(item.dateArgsAfter) || item.dateArgsAfter.length !== expectedIndexes.length
+        || !Number.isSafeInteger(item.clockReads) || item.clockReads < 0) throw new TypeError("Missing side-effect observation");
+      item.dateArgsAfter.forEach((arg, argIndex) => {
+        shape(arg, ["index", "value"]);
+        if (arg.index !== expectedIndexes[argIndex]) throw new TypeError("Wrong observed argument");
+        validateValue({ type: "number", value: arg.value }, false);
+      });
+      if (request.cases[index].observeArgs) {
+        if (!Array.isArray(item.argsAfter) || item.argsAfter.length !== request.cases[index].args.length) throw new TypeError("Missing argument snapshots");
+        item.argsAfter.forEach((arg) => validateValue(arg, true, callbackIds(request.cases[index])));
+      } else if (Object.hasOwn(item, "argsAfter")) throw new TypeError("Unexpected argument snapshots");
+    } else if (Object.hasOwn(item, "dateArgsAfter") || Object.hasOwn(item, "clockReads") || Object.hasOwn(item, "argsAfter")) throw new TypeError("Unexpected side-effect observation");
+    validateObservedCapabilities(item, request.cases[index]);
+    observations.set(item.id, item);
+  }
+  const timeouts = ["guest-cpu-budget", "guest-wall-deadline"];
+  const errors = response.cases.filter((item) => item.outcome === "error");
+  if (errors.length > 1 || (errors.length && response.cases.at(-1) !== errors[0])) throw new TypeError("Nonterminal worker error");
+  if (response.status === "timeout") {
+    if (!timeouts.includes(response.timeoutReason)
+      || (errors.length && errors[0].reason !== response.timeoutReason)
+      || (response.timeoutReason === "guest-cpu-budget" && errors.length !== 1)) throw new TypeError("Invalid timeout cause");
+  } else if (Object.hasOwn(response, "timeoutReason") || errors.some((item) => timeouts.includes(item.reason))
+    || (response.status === "completed" && errors.length) || (response.status === "error" && errors.length !== 1)) {
+    throw new TypeError("Conflicting worker status");
+  }
+  return response;
+}
+
+const COUNTER_FIELDS = ["calls", "rawBytes", "textBytes", "decodersCreated", "timersScheduled", "denials"];
+function validateServiceCounters(value) {
+  shape(value, COUNTER_FIELDS);
+  if (COUNTER_FIELDS.some(field => !Number.isSafeInteger(value[field]) || value[field] < 0)) throw new TypeError("Invalid Node service counters");
+}
+
+function validateInvocationTrace(value, item, outcome, defaultExport) {
+  const invocation = item.invocation;
+  const fields = invocation.kind === "call" ? ["kind", "exportName", "outcome"]
+    : invocation.kind === "construct" ? ["kind", "receiverId", "outcome"] : ["kind", "receiverId", "method", "outcome"];
+  shape(value, fields);
+  if (value.kind !== invocation.kind || value.outcome !== outcome
+    || invocation.kind === "call" && value.exportName !== (item.exportName ?? defaultExport)
+    || invocation.receiverId && value.receiverId !== invocation.receiverId
+    || invocation.method && value.method !== invocation.method) throw new TypeError("Invalid invocation trace");
+}
+
+function parseNodeResponse(response, request, requestDigest) {
+  shape(response, ["schemaVersion", "workerVersion", "profileDigest", "requestDigest", "status", "cases", "timeoutReason", "services", "quiescence", "timerTrace"],
+    ["schemaVersion", "workerVersion", "profileDigest", "requestDigest", "status", "cases", "services", "quiescence"]);
+  if (response.schemaVersion !== 2 || response.workerVersion !== NODE_WORKER_VERSION || response.profileDigest !== request.profile.digest
+    || response.requestDigest !== requestDigest || !["completed", "timeout", "error"].includes(response.status)
+    || !Array.isArray(response.cases) || response.cases.length > request.cases.length
+    || response.status === "completed" && response.cases.length !== request.cases.length) throw new TypeError("Invalid Node worker response");
+  validateServiceCounters(response.services);
+  shape(response.quiescence, ["pendingTimers", "liveDecoders", "receivers"]);
+  if (Object.values(response.quiescence).some(value => value !== 0)) throw new TypeError("Node worker did not quiesce");
+  if (Object.hasOwn(response, "timerTrace")) {
+    if (!Array.isArray(response.timerTrace) || response.timerTrace.length > MAX_TIMER_SCHEDULES * 3) throw new TypeError("Invalid timer trace");
+    response.timerTrace.forEach((entry, index) => {
+      shape(entry, ["sequence", "event", "id", "delay"], entry.event === "cancel" ? ["sequence", "event", "id"] : ["sequence", "event", "id", "delay"]);
+      if (entry.sequence !== index || !["schedule", "fire", "cancel"].includes(entry.event)
+        || !Number.isSafeInteger(entry.id) || entry.id < 1
+        || Object.hasOwn(entry, "delay") && (!Number.isSafeInteger(entry.delay) || entry.delay < 1 || entry.delay > 5000)) throw new TypeError("Invalid timer event");
+    });
+  }
+  const observations = new Map(), aggregate = Object.fromEntries(COUNTER_FIELDS.map(field => [field, 0]));
+  const typedOutputBudget = { rawBytes: 0 };
+  for (const [index, item] of response.cases.entries()) {
+    const requested = request.cases[index];
+    shape(item, ["id", "outcome", "value", "errorClass", "reason", "dateArgsAfter", "clockReads", "argsAfter", "resources", "invocationTrace", "services", ...OBSERVATION_CAPABILITY_FIELDS],
+      ["id", "outcome", "invocationTrace", "services"]);
+    if (item.id !== requested.id || !["return", "throw", "constructed", "unsupported", "error"].includes(item.outcome)) {
+      throw new TypeError("Invalid Node case observation");
+    }
+    validateInvocationTrace(item.invocationTrace, requested, item.outcome, request.exportName);
+    validateServiceCounters(item.services);
+    COUNTER_FIELDS.forEach(field => { aggregate[field] += item.services[field]; });
+    if (item.outcome === "return") {
+      validateValue(item.value, false, new Set(), { typedBytes: true, typedOutputBudget });
+      if (Object.hasOwn(item, "errorClass") || Object.hasOwn(item, "reason")) throw new TypeError("Conflicting return observation");
+    } else if (item.outcome === "throw") {
+      if (!["TypeError", "RangeError", "SyntaxError", "ReferenceError", "EvalError", "URIError", "Error", "non-error"].includes(item.errorClass)
+        || Object.hasOwn(item, "value") || Object.hasOwn(item, "reason")) throw new TypeError("Invalid throw observation");
+    } else if (item.outcome === "constructed") {
+      if (requested.invocation.kind !== "construct" || Object.hasOwn(item, "value") || Object.hasOwn(item, "errorClass") || Object.hasOwn(item, "reason")) {
+        throw new TypeError("Invalid construction observation");
+      }
+    } else if (typeof item.reason !== "string" || !/^[a-z0-9-]{1,64}$/.test(item.reason)
+      || Object.hasOwn(item, "value") || Object.hasOwn(item, "errorClass")) throw new TypeError("Invalid incomplete observation");
+    const resourceStop = item.outcome === "error" && ["guest-cpu-budget", "guest-wall-deadline"].includes(item.reason);
+    if (resourceStop) {
+      shape(item.resources, ["caseCpuMicros", "caseThreadCpuMicros", "caseWallMicros"]);
+      if (!Object.values(item.resources).every(value => Number.isSafeInteger(value) && value >= 0)
+        || item.reason === "guest-cpu-budget" && item.resources.caseThreadCpuMicros < CASE_THREAD_CPU_MICROS) throw new TypeError("Invalid resource stop observation");
+    } else if (Object.hasOwn(item, "resources")) throw new TypeError("Unexpected resource stop observation");
+    if (["return", "throw", "constructed"].includes(item.outcome)) {
+      const resolved = resolveArguments(requested.args, observations, { nodeProfile: true });
+      if (resolved.some(arg => arg === undefined)) throw new TypeError("Unavailable referenced observation");
+      const expectedIndexes = resolved.flatMap((arg, argIndex) => arg.type === "date" ? [argIndex] : []);
+      if (!Array.isArray(item.dateArgsAfter) || item.dateArgsAfter.length !== expectedIndexes.length
+        || !Number.isSafeInteger(item.clockReads) || item.clockReads < 0) throw new TypeError("Missing side-effect observation");
+      item.dateArgsAfter.forEach((arg, argIndex) => {
+        shape(arg, ["index", "value"]);
+        if (arg.index !== expectedIndexes[argIndex]) throw new TypeError("Wrong observed argument");
+        validateValue({ type: "number", value: arg.value }, false);
+      });
+      if (requested.observeArgs) {
+        if (!Array.isArray(item.argsAfter) || item.argsAfter.length !== requested.args.length) throw new TypeError("Missing argument snapshots");
+        item.argsAfter.forEach(arg => validateValue(arg, true, callbackIds(requested), { typedBytes: true, typedOutputBudget }));
+      } else if (Object.hasOwn(item, "argsAfter")) throw new TypeError("Unexpected argument snapshots");
+    } else if (Object.hasOwn(item, "dateArgsAfter") || Object.hasOwn(item, "clockReads") || Object.hasOwn(item, "argsAfter")) {
+      throw new TypeError("Unexpected side-effect observation");
+    }
+    validateObservedCapabilities(item, requested, { nodeProfile: true, typedOutputBudget });
+    observations.set(item.id, item);
+  }
+  if (COUNTER_FIELDS.some(field => aggregate[field] !== response.services[field])) throw new TypeError("Conflicting Node service totals");
+  const timeouts = ["guest-cpu-budget", "guest-wall-deadline"];
+  const errors = response.cases.filter(item => item.outcome === "error");
+  if (errors.length > 1 || errors.length && response.cases.at(-1) !== errors[0]) throw new TypeError("Nonterminal worker error");
+  if (response.status === "timeout") {
+    if (!timeouts.includes(response.timeoutReason) || errors.length && errors[0].reason !== response.timeoutReason
+      || response.timeoutReason === "guest-cpu-budget" && errors.length !== 1) throw new TypeError("Invalid timeout cause");
+  } else if (Object.hasOwn(response, "timeoutReason") || errors.some(item => timeouts.includes(item.reason))
+    || response.status === "completed" && errors.length || response.status === "error" && errors.length !== 1) throw new TypeError("Conflicting worker status");
+  return response;
+}

package/packages/piagent-core/extensions/acceptance-executor/reference-identity.mjs

@@ -0,0 +1,61 @@
+import { protocolShape as shape } from "./values.mjs";
+
+export function validateReferencePairs(item, { backingStore = false } = {}) {
+  if (!Object.hasOwn(item, "referencePairs")) return;
+  if (!Array.isArray(item.referencePairs) || item.referencePairs.length < 1 || item.referencePairs.length > 16) throw new TypeError("Invalid reference pairs");
+  const ids = new Set();
+  for (const pair of item.referencePairs) {
+    shape(pair, ["id", "left", "right"]);
+    if (typeof pair.id !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9:._-]{0,79}$/.test(pair.id) || ids.has(pair.id)) throw new TypeError("Invalid reference pair id");
+    ids.add(pair.id);
+    for (const selector of [pair.left, pair.right]) {
+      shape(selector, ["root", "index", "path", "projection"], ["root", "path"]);
+      if (!["argument", "return", "error"].includes(selector.root) || !Array.isArray(selector.path) || selector.path.length > 8
+        || selector.path.some(key => typeof key !== "string" || key.length > 128)) throw new TypeError("Invalid reference selector");
+      if (Object.hasOwn(selector, "projection") && (!backingStore || selector.projection !== "backing-store")) {
+        throw new TypeError("Invalid reference projection");
+      }
+      if (selector.root === "argument") {
+        if (!Number.isSafeInteger(selector.index) || selector.index < 0 || selector.index >= item.args.length) throw new TypeError("Invalid reference argument");
+      } else if (Object.hasOwn(selector, "index") || selector.root === "error" && !item.observeError) throw new TypeError("Unobserved reference root");
+    }
+  }
+}
+
+export function validateReferenceIdentity(values, item) {
+  if (!item.referencePairs || !Array.isArray(values) || values.length !== item.referencePairs.length) throw new TypeError("Incomplete reference identities");
+  values.forEach((value, index) => {
+    shape(value, ["id", "same"]);
+    if (value.id !== item.referencePairs[index].id || typeof value.same !== "boolean") throw new TypeError("Invalid reference identity");
+  });
+}
+
+// Included only in the private pre-candidate intrinsics closure. No property
+// lookup can invoke candidate getters, inherited fields or proxy traps.
+export const REFERENCE_INTRINSICS = `
+  function referenceAt(value, path) {
+    for (let i = 0; i < path.length; i += 1) {
+      if (value === null || typeof value !== 'object') return undefined;
+      if (apply(has, proxies, [value])) throw 'reference-path-unsupported';
+      const property = descriptor(value, path[i]);
+      if (!property) return undefined;
+      if (!own(property, 'value')) throw 'reference-path-unsupported';
+      value = property.value;
+    }
+    if (value !== null && typeof value === 'object' && apply(has, proxies, [value])) throw 'reference-path-unsupported';
+    return value;
+  }
+  function backingStore(value) {
+    try { return apply(byteBuffer, value, []); } catch {}
+    try { return apply(dataViewBuffer, value, []); } catch {}
+    try { apply(arrayBufferLength, value, []); return value; } catch { throw 'reference-path-unsupported'; }
+  }
+  function referenceIdentity(left, leftPath, leftProjection, right, rightPath, rightProjection) {
+    try {
+      let a = referenceAt(left, leftPath), b = referenceAt(right, rightPath);
+      if (leftProjection === 'backing-store') a = backingStore(a);
+      if (rightProjection === 'backing-store') b = backingStore(b);
+      return a !== null && typeof a === 'object' && same(a, b) ? '{"same":true}' : '{"same":false}';
+    } catch { return '{"reason":"reference-path-unsupported"}'; }
+  }
+`;

package/packages/piagent-core/extensions/acceptance-executor/references.mjs

@@ -0,0 +1,14 @@
+import { validateValue } from "./values.mjs";
+
+// Copy observed inert data across explicit history steps, never guest handles,
+// expected answers, callbacks or host properties. Missing evidence abstains.
+export function resolveArguments(args, observations, { nodeProfile = false } = {}) {
+  return args.map(arg => {
+    if (!["result", "error-property"].includes(arg.type)) return arg;
+    const observation = observations.get(arg.value);
+    const value = arg.type === "result" ? observation?.outcome === "return" ? observation.value : undefined
+      : observation?.outcome === "throw" ? observation.errorObservation?.properties.value.find(entry => entry.key === arg.key)?.value : undefined;
+    if (value === undefined) return undefined;
+    try { validateValue(value, true, new Set(), { typedBytes: nodeProfile }); return value; } catch { return undefined; }
+  });
+}

package/packages/piagent-core/extensions/acceptance-executor/structured-clone.mjs

@@ -0,0 +1,53 @@
+import { MAX_COLLECTION_LENGTH, MAX_STRING_LENGTH, MAX_VALUE_DEPTH, MAX_VALUE_NODES, MAX_VALUE_TEXT } from "./values.mjs";
+
+// Node-profile support for inert records, arrays, primitives and Dates only.
+// The closure shares the worker's private Proxy registry and captured intrinsics.
+// Unsupported data latches for the realm, even if candidate code catches it.
+export const STRUCTURED_CLONE_INTRINSICS = `
+  const CloneMap = WeakMap, cloneGet = CloneMap.prototype.get, cloneSet = CloneMap.prototype.set;
+  const cloneHas = CloneMap.prototype.has, CloneError = Error;
+  let cloneFailure = null;
+  const denyClone = reason => { cloneFailure ??= reason; throw new CloneError(reason); };
+  function installStructuredClone() {
+    define(globalThis, 'structuredClone', dataDescriptor(function structuredClone(value, options) {
+      if (options !== undefined) return denyClone('structured-clone-options-unsupported');
+      const seen = new CloneMap(); let nodes = 0, text = 0;
+      const boundedText = value => {
+        text += value.length;
+        if (value.length > ${MAX_STRING_LENGTH} || text > ${MAX_VALUE_TEXT}) denyClone('structured-clone-limit');
+      };
+      function copy(value, depth) {
+        if (++nodes > ${MAX_VALUE_NODES} || depth > ${MAX_VALUE_DEPTH}) return denyClone('structured-clone-limit');
+        const type = typeof value;
+        if (value === null || type === 'undefined' || type === 'boolean' || type === 'number' || type === 'bigint') return value;
+        if (type === 'string') { boundedText(value); return value; }
+        if (type !== 'object' || apply(has, proxies, [value])) return denyClone('structured-clone-type-unsupported');
+        if (apply(cloneHas, seen, [value])) return apply(cloneGet, seen, [value]);
+        let timestamp, date = false;
+        try { timestamp = apply(getTime, value, []); date = true; } catch {}
+        if (date) { const out = new D(timestamp); apply(cloneSet, seen, [value, out]); return out; }
+        const array = isArray(value), proto = prototype(value);
+        if (!array && proto !== objectPrototype && proto !== null) return denyClone('structured-clone-type-unsupported');
+        const keys = ownKeys(value);
+        if (keys.length > ${MAX_COLLECTION_LENGTH} + (array ? 1 : 0)) return denyClone('structured-clone-limit');
+        const out = array ? [] : {};
+        if (array) {
+          const length = descriptor(value, 'length').value;
+          if (length > ${MAX_COLLECTION_LENGTH}) return denyClone('structured-clone-limit');
+          const lengthDescriptor = create(null); lengthDescriptor.value = length; define(out, 'length', lengthDescriptor);
+        }
+        apply(cloneSet, seen, [value, out]);
+        for (let i = 0; i < keys.length; i += 1) {
+          const key = keys[i];
+          if (typeof key !== 'string') continue;
+          const property = descriptor(value, key);
+          if (!property || !property.enumerable) continue;
+          if (!own(property, 'value')) return denyClone('structured-clone-accessor-unsupported');
+          boundedText(key); define(out, key, dataDescriptor(copy(property.value, depth + 1), true));
+        }
+        return out;
+      }
+      return copy(value, 0);
+    }, false));
+  }
+`;

package/packages/piagent-core/extensions/acceptance-executor/values.mjs

@@ -0,0 +1,97 @@
+export const MAX_STRING_LENGTH = 4096;
+export const MAX_VALUE_DEPTH = 8;
+export const MAX_VALUE_NODES = 256;
+export const MAX_COLLECTION_LENGTH = 64;
+export const MAX_VALUE_TEXT = 64 * 1024;
+export const MAX_TYPED_BACKING_BYTES = 4096;
+export const MAX_CASE_RAW_AND_TEXT_BYTES = 64 * 1024;
+export const MAX_TYPED_OUTPUT_BYTES = 64 * 1024;
+const SPECIAL_NUMBERS = new Set(["NaN", "Infinity", "-Infinity", "-0"]);
+const TYPED_BYTES = new Set(["uint8array", "buffer", "arraybuffer", "dataview"]);
+
+export function protocolShape(value, keys, required = keys) {
+  if (!value || typeof value !== "object" || Array.isArray(value)
+    || Object.getPrototypeOf(value) !== Object.prototype
+    || Object.keys(value).some((key) => !keys.includes(key))
+    || required.some((key) => !Object.hasOwn(value, key))) throw new TypeError("Invalid protocol object");
+}
+
+/** Typed trees with optional approved callback IDs, never executable code or history references. */
+export function validateValue(value, allowDate = true, callbackIds = new Set(), options = {}) {
+  let nodes = 0, text = 0, textUtf8 = 0, rawBytes = 0;
+  const typedBytes = options.typedBytes === true;
+  const shared = options.budget;
+  const typedOutput = options.typedOutputBudget;
+  function visit(item, depth) {
+    if (++nodes > MAX_VALUE_NODES || depth > MAX_VALUE_DEPTH) throw new TypeError("Value tree limit exceeded");
+    protocolShape(item, ["type", "value"], ["type"]);
+    if (["undefined", "null"].includes(item.type)) {
+      if (Object.hasOwn(item, "value")) throw new TypeError("Unexpected primitive payload");
+    } else if (item.type === "callback" && callbackIds.has(item.value)) {
+      if (typeof item.value !== "string") throw new TypeError("Invalid callback reference");
+    } else if (item.type === "number" || allowDate && item.type === "date") {
+      if (!(typeof item.value === "number" && Number.isFinite(item.value)) && !SPECIAL_NUMBERS.has(item.value)) {
+        throw new TypeError("Invalid numeric payload");
+      }
+    } else if (item.type === "boolean") {
+      if (typeof item.value !== "boolean") throw new TypeError("Invalid boolean payload");
+    } else if (item.type === "string") {
+      if (typeof item.value !== "string" || item.value.length > MAX_STRING_LENGTH) throw new TypeError("Invalid string payload");
+      text += item.value.length; textUtf8 += Buffer.byteLength(item.value);
+    } else if (typedBytes && TYPED_BYTES.has(item.type)) {
+      protocolShape(item, ["type", "value"]);
+      protocolShape(item.value, ["backingBase64", "byteOffset", "byteLength"]);
+      const { backingBase64, byteOffset, byteLength } = item.value;
+      if (typeof backingBase64 !== "string" || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(backingBase64)
+        || !Number.isSafeInteger(byteOffset) || byteOffset < 0 || !Number.isSafeInteger(byteLength) || byteLength < 0) {
+        throw new TypeError("Invalid typed byte payload");
+      }
+      const backing = Buffer.from(backingBase64, "base64");
+      if (backing.toString("base64") !== backingBase64 || backing.length > MAX_TYPED_BACKING_BYTES
+        || byteOffset + byteLength > backing.length
+        || item.type === "arraybuffer" && (byteOffset !== 0 || byteLength !== backing.length)) {
+        throw new TypeError("Invalid typed byte range");
+      }
+      rawBytes += backing.length;
+      if (typedOutput) {
+        typedOutput.rawBytes = (typedOutput.rawBytes ?? 0) + backing.length;
+        if (typedOutput.rawBytes > MAX_TYPED_OUTPUT_BYTES) throw new TypeError("Aggregate typed output budget exceeded");
+      }
+    } else if (["array", "record"].includes(item.type)) {
+      if (!Array.isArray(item.value) || item.value.length > MAX_COLLECTION_LENGTH
+        || Object.keys(item.value).length !== item.value.length) throw new TypeError("Invalid collection payload");
+      const keys = new Set();
+      for (const child of item.value) {
+        if (item.type === "array") visit(child, depth + 1);
+        else {
+          protocolShape(child, ["key", "value"]);
+          if (typeof child.key !== "string" || child.key.length > MAX_STRING_LENGTH || keys.has(child.key)) throw new TypeError("Invalid record key");
+          keys.add(child.key); text += child.key.length; textUtf8 += Buffer.byteLength(child.key); visit(child.value, depth + 1);
+        }
+      }
+    } else throw new TypeError("Unsupported value type");
+    if (text > MAX_VALUE_TEXT) throw new TypeError("Value text limit exceeded");
+  }
+  visit(value, 0);
+  if (shared) {
+    shared.rawBytes = (shared.rawBytes ?? 0) + rawBytes;
+    shared.textBytes = (shared.textBytes ?? 0) + textUtf8;
+    if (shared.rawBytes + shared.textBytes > MAX_CASE_RAW_AND_TEXT_BYTES) throw new TypeError("Case byte and text budget exceeded");
+  }
+  return value;
+}
+
+export function numberValue(value) {
+  if (Number.isNaN(value)) return "NaN";
+  if (Object.is(value, -0)) return "-0";
+  if (!Number.isFinite(value)) return String(value);
+  return value;
+}
+
+/** Record insertion order is not an equality obligation; array order is. */
+export function canonicalValue(value) {
+  if (value.type === "array") return { type: "array", value: value.value.map(canonicalValue) };
+  if (value.type === "record") return { type: "record", value: value.value.map((entry) => ({ key: entry.key, value: canonicalValue(entry.value) }))
+    .sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0) };
+  return value;
+}

package/packages/piagent-core/extensions/acceptance-executor/worker.mjs

@@ -0,0 +1,75 @@
+import { createHash } from "node:crypto";
+import { newQuickJSWASMModuleFromVariant } from "quickjs-emscripten-core";
+import variant from "@jitl/quickjs-wasmfile-release-sync";
+import { MAX_REQUEST_BYTES, MAX_RESPONSE_BYTES, NODE_WORKER_VERSION, WORKER_VERSION, parseRequest } from "./protocol.mjs";
+import { createGuestSession } from "./guest.mjs";
+import { CPU_EXHAUSTED, WALL_EXHAUSTED, REQUEST_WALL_MS } from "./budget.mjs";
+import { resolveArguments } from "./references.mjs";
+
+// This executable belongs inside the constrained container, never the agent's
+// process. stdout is the trusted runner's channel; QuickJS has no stdout binding.
+try {
+  let bytes = 0;
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    bytes += chunk.length;
+    if (bytes > MAX_REQUEST_BYTES) throw new Error("Request size exceeded");
+    chunks.push(chunk);
+  }
+  const text = Buffer.concat(chunks).toString("utf8");
+  const request = parseRequest(text);
+  const requestDigest = createHash("sha256").update(text).digest("hex");
+  const QuickJS = await newQuickJSWASMModuleFromVariant(variant);
+  const deadline = performance.now() + REQUEST_WALL_MS;
+  const cases = [];
+  let status = "completed";
+  let timeoutReason;
+  const observations = new Map();
+  const typedOutputBudget = { rawBytes: 0 };
+  const timerTrace = [];
+  let quiescence = { pendingTimers: 0, liveDecoders: 0, receivers: 0 };
+  let session, sequence;
+  const disposeSession = () => {
+    const summary = session?.dispose();
+    for (const item of summary?.timerTrace ?? []) timerTrace.push({ ...item, sequence: timerTrace.length });
+    if (summary?.quiescence) quiescence = summary.quiescence;
+    session = undefined;
+  };
+  try {
+    for (const item of request.cases) {
+      if (performance.now() >= deadline) { status = "timeout"; timeoutReason = WALL_EXHAUSTED; break; }
+      if (!session || !item.sequence || sequence !== item.sequence || item.reset) {
+        disposeSession(); session = createGuestSession(QuickJS, request, deadline, typedOutputBudget); sequence = item.sequence;
+      }
+      const args = resolveArguments(item.args, observations, { nodeProfile: request.schemaVersion === 2 });
+      const observation = args.some((arg) => arg === undefined)
+        ? request.schemaVersion === 2
+          ? { id: item.id, outcome: "unsupported", reason: "referenced-result-unavailable",
+            invocationTrace: { ...item.invocation, ...(item.invocation.kind === "call" ? { exportName: item.exportName ?? request.exportName } : {}), outcome: "unsupported" },
+            services: { calls: 0, rawBytes: 0, textBytes: 0, decodersCreated: 0, timersScheduled: 0, denials: 0 } }
+          : { id: item.id, outcome: "unsupported", reason: "referenced-result-unavailable" }
+        : await session.execute({ ...item, args });
+      cases.push(observation);
+      observations.set(item.id, observation);
+      if (observation.outcome === "error") {
+        timeoutReason = [CPU_EXHAUSTED, WALL_EXHAUSTED].includes(observation.reason) ? observation.reason : undefined;
+        status = timeoutReason ? "timeout" : "error";
+        break;
+      }
+    }
+  } finally { disposeSession(); }
+  if (status === "completed" && performance.now() >= deadline) { status = "timeout"; timeoutReason = WALL_EXHAUSTED; }
+  const output = JSON.stringify(request.schemaVersion === 1
+    ? { schemaVersion: 1, workerVersion: WORKER_VERSION, requestDigest, status, cases, ...(timeoutReason ? { timeoutReason } : {}) }
+    : { schemaVersion: 2, workerVersion: NODE_WORKER_VERSION, profileDigest: request.profile.digest, requestDigest, status, cases,
+      ...(timeoutReason ? { timeoutReason } : {}), services: cases.reduce((total, item) => {
+        for (const key of Object.keys(total)) total[key] += item.services?.[key] ?? 0; return total;
+      }, { calls: 0, rawBytes: 0, textBytes: 0, decodersCreated: 0, timersScheduled: 0, denials: 0 }),
+      quiescence, ...(timerTrace.length ? { timerTrace } : {}) });
+  if (Buffer.byteLength(output) > MAX_RESPONSE_BYTES) throw new Error("Response size exceeded");
+  process.stdout.write(output);
+} catch {
+  // Do not echo candidate code, thrown objects, or local environment details.
+  process.stderr.write("isolated-contract-worker-failed\n");
+  process.exitCode = 1;
+}