@serve.zone/interfaces 31.9.0 → 32.0.1

package/ts/data/runtimeterminalreceipt.ts

@@ -1,14 +1,14 @@
 import type { TSha256Digest } from './immutableimage.js';
 import { isSha256Digest } from './immutableimage.js';
-import type { IRuntimeAssignmentReferenceV1, IRuntimeAssignmentV1 } from './runtimeassignment.js';
-import { evaluateRuntimeAssignmentV1, getRuntimeAssignmentV1Reference,
-  snapshotRuntimeAssignmentV1 } from './runtimeassignment.js';
-import type { IRuntimeSessionBindingV1, TRuntimeObservationAuthorityUseV1 } from './runtimesession.js';
-import { bindRuntimeReporterSessionV1, snapshotRuntimeSessionBindingV1 } from './runtimesession.js';
+import type { IRuntimeAssignmentReference, IRuntimeAssignment } from './runtimeassignment.js';
+import { evaluateRuntimeAssignment, getRuntimeAssignmentReference,
+  snapshotRuntimeAssignment } from './runtimeassignment.js';
+import type { IRuntimeSessionBinding, TRuntimeObservationAuthorityUse } from './runtimesession.js';
+import { bindRuntimeReporterSession, snapshotRuntimeSessionBinding } from './runtimesession.js';
 import { canonicalizeStrictJson, createCanonicalJsonSha256Hex } from '../private/canonicaljson.js';
 
 /** Exact value-free native terminal evidence; terminal inspection does not collect addresses. */
-export interface IRuntimeAssignmentTerminalEvidenceV1 {
+export interface IRuntimeAssignmentTerminalEvidence {
   phase: 'stopped' | 'absent';
   sandboxId: string | null;
   containerId: string | null;
@@ -28,12 +28,11 @@ export interface IRuntimeAssignmentTerminalEvidenceV1 {
  * liveness, storage relocation, whole-host, Docker/Coreflow absence, other
  * controller or cross-organization authority. It has no authoritative wall clock.
  */
-export interface IRuntimeAssignmentTerminalReceiptV1 {
-  schemaVersion: 1;
+export interface IRuntimeAssignmentTerminalReceipt {
   /** Exact generation 2 stop or generation 3 remove revision. */
-  assignment: IRuntimeAssignmentReferenceV1;
+  assignment: IRuntimeAssignmentReference;
   /** Exact immutable generation 1 run revision. */
-  runAssignment: IRuntimeAssignmentReferenceV1;
+  runAssignment: IRuntimeAssignmentReference;
   reporterSessionId: string;
   sequence: 1 | 2;
   operation: {
@@ -41,32 +40,32 @@ export interface IRuntimeAssignmentTerminalReceiptV1 {
     action: 'stop' | 'remove';
     bootId: string;
     status: 'completed';
-    evidence: IRuntimeAssignmentTerminalEvidenceV1;
+    evidence: IRuntimeAssignmentTerminalEvidence;
   };
   /** Null for stop; the exact accepted stop receipt digest for remove. */
   previousReceiptDigest: TSha256Digest | null;
   digest: TSha256Digest;
 }
 
-export interface IReportRuntimeAssignmentTerminalReceiptRequestV1 {
+export interface IReportRuntimeAssignmentTerminalReceiptRequest {
   /** Current physical peer binding, even when the immutable receipt is historical. */
-  session: IRuntimeSessionBindingV1;
-  receipt: IRuntimeAssignmentTerminalReceiptV1;
+  session: IRuntimeSessionBinding;
+  receipt: IRuntimeAssignmentTerminalReceipt;
 }
 
-export interface IReportRuntimeAssignmentTerminalReceiptResponseV1 {
+export interface IReportRuntimeAssignmentTerminalReceiptResponse {
   /** Exact immutable body after the owning durable receipt transaction. */
-  receipt: IRuntimeAssignmentTerminalReceiptV1;
+  receipt: IRuntimeAssignmentTerminalReceipt;
   /** Historical recovery never restores active readiness, routes or liveness. */
-  authorityUse: TRuntimeObservationAuthorityUseV1;
+  authorityUse: TRuntimeObservationAuthorityUse;
 }
 
-export type TRuntimeAssignmentTerminalReceiptDecisionV1 =
-  | { status: 'accept' | 'replay'; receipt: IRuntimeAssignmentTerminalReceiptV1 }
+export type TRuntimeAssignmentTerminalReceiptDecision =
+  | { status: 'accept' | 'replay'; receipt: IRuntimeAssignmentTerminalReceipt }
   | { status: 'reject'; reason: 'invalid' | 'conflict' | 'sequence-gap' | 'predecessor-mismatch' };
 
-export const runtimeAssignmentTerminalReceiptV1Contract = Object.freeze({
-  digestDomain: 'serve.zone/runtime-assignment-terminal-receipt-v1',
+export const runtimeAssignmentTerminalReceiptContract = Object.freeze({
+  digestDomain: 'serve.zone/runtime-assignment-terminal-receipt',
   maximumReceiptCanonicalBytes: 16_384,
   maximumHistoryCanonicalBytes: 98_304,
   maximumReceipts: 2,
@@ -74,7 +73,7 @@ export const runtimeAssignmentTerminalReceiptV1Contract = Object.freeze({
   error: 'Runtime terminal receipt contract rejected.',
 } as const);
 
-const fail = (): never => { throw new Error(runtimeAssignmentTerminalReceiptV1Contract.error); };
+const fail = (): never => { throw new Error(runtimeAssignmentTerminalReceiptContract.error); };
 function requireValue(conditionArg: unknown): asserts conditionArg { if (!conditionArg) fail(); }
 const safe = <T>(operationArg: () => T): T => { try { return operationArg(); } catch { return fail(); } };
 const canonical = (valueArg: unknown): string => canonicalizeStrictJson(valueArg, fail);
@@ -89,7 +88,7 @@ const digest = (valueArg: unknown): TSha256Digest => {
 };
 
 /** Bounded inert copy before hashing or calling any nested validator. */
-const capture = (valueArg: unknown, maximumBytesArg: number = runtimeAssignmentTerminalReceiptV1Contract.maximumHistoryCanonicalBytes): unknown => safe(() => {
+const capture = (valueArg: unknown, maximumBytesArg: number = runtimeAssignmentTerminalReceiptContract.maximumHistoryCanonicalBytes): unknown => safe(() => {
   let nodes = 0;
   let bytes = 0;
   const ancestors = new Set<object>();
@@ -141,13 +140,13 @@ const record = (valueArg: unknown, keysArg: string[]): Record<string, unknown> =
   requireValue(keys.length === keysArg.length && keys.every((key) => keysArg.includes(key)));
   return valueArg as Record<string, unknown>;
 };
-const reference = (valueArg: unknown): IRuntimeAssignmentReferenceV1 => {
+const reference = (valueArg: unknown): IRuntimeAssignmentReference => {
   const value = record(valueArg, ['assignmentId', 'generation', 'digest']);
   requireValue(typeof value.generation === 'number' && Number.isSafeInteger(value.generation)
     && value.generation >= 1 && value.generation <= 3);
   return { assignmentId: identifier(value.assignmentId), generation: value.generation, digest: digest(value.digest) };
 };
-const evidence = (valueArg: unknown): IRuntimeAssignmentTerminalEvidenceV1 => {
+const evidence = (valueArg: unknown): IRuntimeAssignmentTerminalEvidence => {
   const value = record(valueArg, ['phase', 'sandboxId', 'containerId', 'imageConfigDigest', 'ipAddresses', 'exitCode']);
   requireValue(value.phase === 'absent' || value.phase === 'stopped');
   for (const field of ['sandboxId', 'containerId']) requireValue(value[field] === null
@@ -161,35 +160,35 @@ const evidence = (valueArg: unknown): IRuntimeAssignmentTerminalEvidenceV1 => {
     ? value.sandboxId === null && value.containerId === null && value.imageConfigDigest === null && value.exitCode === null
     : value.sandboxId !== null);
   requireValue(value.containerId !== null || (value.imageConfigDigest === null && value.exitCode === null));
-  return value as unknown as IRuntimeAssignmentTerminalEvidenceV1;
+  return value as unknown as IRuntimeAssignmentTerminalEvidence;
 };
 
 /** Detached exact-schema assertion only; digest, journal provenance and authority remain unverified. */
-export const snapshotRuntimeAssignmentTerminalReceiptV1 = (valueArg: unknown): IRuntimeAssignmentTerminalReceiptV1 => safe(() => {
-  const value = record(capture(valueArg, runtimeAssignmentTerminalReceiptV1Contract.maximumReceiptCanonicalBytes),
-    ['schemaVersion', 'assignment', 'runAssignment', 'reporterSessionId', 'sequence', 'operation', 'previousReceiptDigest', 'digest']);
+export const snapshotRuntimeAssignmentTerminalReceipt = (valueArg: unknown): IRuntimeAssignmentTerminalReceipt => safe(() => {
+  const value = record(capture(valueArg, runtimeAssignmentTerminalReceiptContract.maximumReceiptCanonicalBytes),
+    ['assignment', 'runAssignment', 'reporterSessionId', 'sequence', 'operation', 'previousReceiptDigest', 'digest']);
   const assignment = reference(value.assignment);
   const runAssignment = reference(value.runAssignment);
   const operation = record(value.operation, ['id', 'action', 'bootId', 'status', 'evidence']);
   const terminalEvidence = evidence(operation.evidence);
-  requireValue(value.schemaVersion === 1 && (value.sequence === 1 || value.sequence === 2)
+  requireValue((value.sequence === 1 || value.sequence === 2)
     && operation.status === 'completed' && assignment.generation === value.sequence + 1
     && runAssignment.generation === 1 && runAssignment.assignmentId === assignment.assignmentId);
   requireValue(typeof operation.bootId === 'string'
     && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(operation.bootId));
   requireValue(value.sequence === 1 ? operation.action === 'stop' && value.previousReceiptDigest === null
     : operation.action === 'remove' && terminalEvidence.phase === 'absent' && value.previousReceiptDigest !== null);
-  return { schemaVersion: 1, assignment, runAssignment, reporterSessionId: identifier(value.reporterSessionId),
+  return { assignment, runAssignment, reporterSessionId: identifier(value.reporterSessionId),
     sequence: value.sequence, operation: { id: identifier(operation.id), action: operation.action as 'stop' | 'remove',
       bootId: operation.bootId, status: 'completed', evidence: terminalEvidence },
     previousReceiptDigest: value.previousReceiptDigest === null ? null : digest(value.previousReceiptDigest), digest: digest(value.digest) };
 });
 
 /** Bounded exact receipt history for synchronous persistence assertions; hashes remain unchecked. */
-export const snapshotRuntimeAssignmentTerminalReceiptHistoryV1 = (valueArg: unknown): IRuntimeAssignmentTerminalReceiptV1[] => safe(() => {
+export const snapshotRuntimeAssignmentTerminalReceiptHistory = (valueArg: unknown): IRuntimeAssignmentTerminalReceipt[] => safe(() => {
   const values = capture(valueArg);
-  requireValue(Array.isArray(values) && values.length <= runtimeAssignmentTerminalReceiptV1Contract.maximumReceipts);
-  const receipts = values.map(snapshotRuntimeAssignmentTerminalReceiptV1);
+  requireValue(Array.isArray(values) && values.length <= runtimeAssignmentTerminalReceiptContract.maximumReceipts);
+  const receipts = values.map(snapshotRuntimeAssignmentTerminalReceipt);
   for (const [index, receipt] of receipts.entries()) {
     requireValue(receipt.sequence === index + 1);
     if (index > 0) requireValue(receipt.previousReceiptDigest === receipts[0].digest
@@ -199,41 +198,41 @@ export const snapshotRuntimeAssignmentTerminalReceiptHistoryV1 = (valueArg: unkn
   return receipts;
 });
 
-const assignments = (valueArg: unknown): IRuntimeAssignmentV1[] => {
+const assignments = (valueArg: unknown): IRuntimeAssignment[] => {
   const values = capture(valueArg);
   requireValue(Array.isArray(values) && values.length >= 2
-    && values.length <= runtimeAssignmentTerminalReceiptV1Contract.maximumAssignmentRevisions);
-  return values.map(snapshotRuntimeAssignmentV1);
+    && values.length <= runtimeAssignmentTerminalReceiptContract.maximumAssignmentRevisions);
+  return values.map(snapshotRuntimeAssignment);
 };
-const checkAssignmentHistory = async (historyArg: IRuntimeAssignmentV1[]): Promise<void> => {
+const checkAssignmentHistory = async (historyArg: IRuntimeAssignment[]): Promise<void> => {
   const run = historyArg[0];
   const scope = { controller: run.controller, organizationId: run.organizationId,
     nodeId: run.nodeId, runtimeNamespace: run.runtimeNamespace };
   for (const [index, assignment] of historyArg.entries()) {
     requireValue(assignment.generation === index + 1
       && assignment.disposition === ['run', 'stop-preserve', 'remove-runtime-preserve-storage'][index]);
-    requireValue((await evaluateRuntimeAssignmentV1(assignment, index === 0 ? null : historyArg[index - 1], scope)).status === 'accept');
+    requireValue((await evaluateRuntimeAssignment(assignment, index === 0 ? null : historyArg[index - 1], scope)).status === 'accept');
   }
 };
-const computeSnapshotDigest = async (receiptArg: IRuntimeAssignmentTerminalReceiptV1): Promise<TSha256Digest> => {
+const computeSnapshotDigest = async (receiptArg: IRuntimeAssignmentTerminalReceipt): Promise<TSha256Digest> => {
   const { digest: _digest, ...payload } = receiptArg;
   return `sha256:${await createCanonicalJsonSha256Hex(canonical({
-    domain: runtimeAssignmentTerminalReceiptV1Contract.digestDomain, payload,
+    domain: runtimeAssignmentTerminalReceiptContract.digestDomain, payload,
   }), fail)}`;
 };
 /** Domain-separated exact body digest; captures before asynchronous hashing. */
-export const computeRuntimeAssignmentTerminalReceiptV1Digest = async (
-  valueArg: IRuntimeAssignmentTerminalReceiptV1,
+export const computeRuntimeAssignmentTerminalReceiptDigest = async (
+  valueArg: IRuntimeAssignmentTerminalReceipt,
 ): Promise<TSha256Digest> => {
-  try { return await computeSnapshotDigest(snapshotRuntimeAssignmentTerminalReceiptV1(valueArg)); } catch { return fail(); }
+  try { return await computeSnapshotDigest(snapshotRuntimeAssignmentTerminalReceipt(valueArg)); } catch { return fail(); }
 };
 const checkReceipt = async (
-  receiptArg: IRuntimeAssignmentTerminalReceiptV1, historyArg: IRuntimeAssignmentV1[],
-  previousArg: IRuntimeAssignmentTerminalReceiptV1 | null,
+  receiptArg: IRuntimeAssignmentTerminalReceipt, historyArg: IRuntimeAssignment[],
+  previousArg: IRuntimeAssignmentTerminalReceipt | null,
 ): Promise<void> => {
   requireValue(historyArg.length > receiptArg.sequence
-    && canonical(receiptArg.runAssignment) === canonical(getRuntimeAssignmentV1Reference(historyArg[0]))
-    && canonical(receiptArg.assignment) === canonical(getRuntimeAssignmentV1Reference(historyArg[receiptArg.sequence]))
+    && canonical(receiptArg.runAssignment) === canonical(getRuntimeAssignmentReference(historyArg[0]))
+    && canonical(receiptArg.assignment) === canonical(getRuntimeAssignmentReference(historyArg[receiptArg.sequence]))
     && receiptArg.digest === await computeSnapshotDigest(receiptArg));
   if (receiptArg.sequence === 1) requireValue(previousArg === null);
   else {
@@ -244,17 +243,17 @@ const checkReceipt = async (
 };
 
 /** Full immutable run/stop/remove chain and exact prior stop receipt are mandatory for removal. */
-export const validateRuntimeAssignmentTerminalReceiptV1 = async (
+export const validateRuntimeAssignmentTerminalReceipt = async (
   valueArg: unknown, assignmentHistoryArg: unknown, previousReceiptArg: unknown,
 ): Promise<string[]> => {
   try {
-    const receipt = snapshotRuntimeAssignmentTerminalReceiptV1(valueArg);
+    const receipt = snapshotRuntimeAssignmentTerminalReceipt(valueArg);
     const history = assignments(assignmentHistoryArg);
-    const previous = previousReceiptArg === null ? null : snapshotRuntimeAssignmentTerminalReceiptV1(previousReceiptArg);
+    const previous = previousReceiptArg === null ? null : snapshotRuntimeAssignmentTerminalReceipt(previousReceiptArg);
     await checkAssignmentHistory(history);
     await checkReceipt(receipt, history, previous);
     return [];
-  } catch { return [runtimeAssignmentTerminalReceiptV1Contract.error]; }
+  } catch { return [runtimeAssignmentTerminalReceiptContract.error]; }
 };
 
 /**
@@ -263,19 +262,19 @@ export const validateRuntimeAssignmentTerminalReceiptV1 = async (
  * only a previously persisted exact body can replay after the incumbent changes.
  * The helper cannot prove either condition. Retain both bodies after removal.
  */
-export const evaluateRuntimeAssignmentTerminalReceiptV1 = async (
+export const evaluateRuntimeAssignmentTerminalReceipt = async (
   valueArg: unknown, acceptedHistoryArg: unknown, assignmentHistoryArg: unknown,
-): Promise<TRuntimeAssignmentTerminalReceiptDecisionV1> => {
+): Promise<TRuntimeAssignmentTerminalReceiptDecision> => {
   try {
-    const receipt = snapshotRuntimeAssignmentTerminalReceiptV1(valueArg);
-    const accepted = snapshotRuntimeAssignmentTerminalReceiptHistoryV1(acceptedHistoryArg);
+    const receipt = snapshotRuntimeAssignmentTerminalReceipt(valueArg);
+    const accepted = snapshotRuntimeAssignmentTerminalReceiptHistory(acceptedHistoryArg);
     const history = assignments(assignmentHistoryArg);
     await checkAssignmentHistory(history);
     for (const existing of accepted) await checkReceipt(existing, history, existing.sequence === 1 ? null : accepted[0]);
     if (receipt.digest !== await computeSnapshotDigest(receipt)
       || history.length <= receipt.sequence
-      || canonical(receipt.runAssignment) !== canonical(getRuntimeAssignmentV1Reference(history[0]))
-      || canonical(receipt.assignment) !== canonical(getRuntimeAssignmentV1Reference(history[receipt.sequence]))) {
+      || canonical(receipt.runAssignment) !== canonical(getRuntimeAssignmentReference(history[0]))
+      || canonical(receipt.assignment) !== canonical(getRuntimeAssignmentReference(history[receipt.sequence]))) {
       return { status: 'reject', reason: 'invalid' };
     }
     const existing = accepted[receipt.sequence - 1];
@@ -288,18 +287,18 @@ export const evaluateRuntimeAssignmentTerminalReceiptV1 = async (
   } catch { return { status: 'reject', reason: 'invalid' }; }
 };
 
-export const snapshotReportRuntimeAssignmentTerminalReceiptRequestV1 = (
+export const snapshotReportRuntimeAssignmentTerminalReceiptRequest = (
   valueArg: unknown,
-): IReportRuntimeAssignmentTerminalReceiptRequestV1 => safe(() => {
+): IReportRuntimeAssignmentTerminalReceiptRequest => safe(() => {
   const value = record(capture(valueArg), ['session', 'receipt']);
-  return { session: snapshotRuntimeSessionBindingV1(value.session), receipt: snapshotRuntimeAssignmentTerminalReceiptV1(value.receipt) };
+  return { session: snapshotRuntimeSessionBinding(value.session), receipt: snapshotRuntimeAssignmentTerminalReceipt(value.receipt) };
 });
-export const snapshotReportRuntimeAssignmentTerminalReceiptResponseV1 = (
+export const snapshotReportRuntimeAssignmentTerminalReceiptResponse = (
   valueArg: unknown,
-): IReportRuntimeAssignmentTerminalReceiptResponseV1 => safe(() => {
+): IReportRuntimeAssignmentTerminalReceiptResponse => safe(() => {
   const value = record(capture(valueArg), ['receipt', 'authorityUse']);
   requireValue(value.authorityUse === 'current-session' || value.authorityUse === 'historical-recovery');
-  return { receipt: snapshotRuntimeAssignmentTerminalReceiptV1(value.receipt), authorityUse: value.authorityUse };
+  return { receipt: snapshotRuntimeAssignmentTerminalReceipt(value.receipt), authorityUse: value.authorityUse };
 });
 
 /**
@@ -308,16 +307,16 @@ export const snapshotReportRuntimeAssignmentTerminalReceiptResponseV1 = (
  * come from the durable owner. This binds content; it does not authenticate,
  * prove the local operation join, advance CAS, or admit a replacement.
  */
-export const bindReportRuntimeAssignmentTerminalReceiptRequestV1 = async (
+export const bindReportRuntimeAssignmentTerminalReceiptRequest = async (
   valueArg: unknown, assignmentHistoryArg: unknown, previousReceiptArg: unknown,
   trustedSessionArg: unknown, reporterHistoryArg: unknown,
-): Promise<{ request: IReportRuntimeAssignmentTerminalReceiptRequestV1; authorityUse: TRuntimeObservationAuthorityUseV1 }> => {
+): Promise<{ request: IReportRuntimeAssignmentTerminalReceiptRequest; authorityUse: TRuntimeObservationAuthorityUse }> => {
   try {
-    const request = snapshotReportRuntimeAssignmentTerminalReceiptRequestV1(valueArg);
+    const request = snapshotReportRuntimeAssignmentTerminalReceiptRequest(valueArg);
     const history = assignments(assignmentHistoryArg);
-    const previous = previousReceiptArg === null ? null : snapshotRuntimeAssignmentTerminalReceiptV1(previousReceiptArg);
+    const previous = previousReceiptArg === null ? null : snapshotRuntimeAssignmentTerminalReceipt(previousReceiptArg);
     requireValue(history.length > request.receipt.sequence);
-    const binding = bindRuntimeReporterSessionV1(request.session, request.receipt.reporterSessionId,
+    const binding = bindRuntimeReporterSession(request.session, request.receipt.reporterSessionId,
       history[request.receipt.sequence], trustedSessionArg, reporterHistoryArg);
     await checkAssignmentHistory(history);
     await checkReceipt(request.receipt, history, previous);
@@ -326,11 +325,11 @@ export const bindReportRuntimeAssignmentTerminalReceiptRequestV1 = async (
 };
 
 /** Exact ACK of the immutable outbox body; no rewritten session, operation or chain. */
-export const bindReportRuntimeAssignmentTerminalReceiptResponseV1 = (
+export const bindReportRuntimeAssignmentTerminalReceiptResponse = (
   valueArg: unknown, requestArg: unknown,
-): IReportRuntimeAssignmentTerminalReceiptResponseV1 => safe(() => {
-  const response = snapshotReportRuntimeAssignmentTerminalReceiptResponseV1(valueArg);
-  const request = snapshotReportRuntimeAssignmentTerminalReceiptRequestV1(requestArg);
+): IReportRuntimeAssignmentTerminalReceiptResponse => safe(() => {
+  const response = snapshotReportRuntimeAssignmentTerminalReceiptResponse(valueArg);
+  const request = snapshotReportRuntimeAssignmentTerminalReceiptRequest(requestArg);
   requireValue(canonical(response.receipt) === canonical(request.receipt)
     && response.authorityUse === (request.receipt.reporterSessionId === request.session.reporterSessionId
       ? 'current-session' : 'historical-recovery'));