@serve.zone/interfaces 31.8.0 → 32.0.0

package/ts/data/runtimeassignment.ts

@@ -1,8 +1,11 @@
 import type { TSha256Digest, TImmutableContainerPlatform } from './immutableimage.js';
 import { buildDigestPinnedImageReference, isSha256Digest } from './immutableimage.js';
-import { canonicalizeStrictJson, createCanonicalJsonSha256Hex } from '../private/canonicaljson.js';
+import {
+  canonicalizeStrictJson, compareWireTokens, createCanonicalJsonSha256Hex,
+} from '../private/canonicaljson.js';
+import { isCanonicalTokenList } from '../private/tokenlist.js';
 
-export interface IRuntimeControllerV1 {
+export interface IRuntimeController {
   kind: 'cloudly' | 'onebox';
   id: string;
   /** Persisted authority incarnation; changing it requires explicit re-admission. */
@@ -10,33 +13,32 @@ export interface IRuntimeControllerV1 {
 }
 
 /** Content-bound reference, not a credential, mount path or permission grant. */
-export interface IRuntimeAuthorityReferenceV1 {
+export interface IRuntimeAuthorityReference {
   id: string;
   generation: number;
   digest: TSha256Digest;
 }
 
-export interface IRuntimeAssignmentReferenceV1 {
+export interface IRuntimeAssignmentReference {
   assignmentId: string;
   generation: number;
   digest: TSha256Digest;
 }
 
 /** Derived from authenticated transport and locally configured ownership. */
-export interface IRuntimeAssignmentScopeV1 {
-  controller: IRuntimeControllerV1;
+export interface IRuntimeAssignmentScope {
+  controller: IRuntimeController;
   organizationId: string;
   nodeId: string;
   runtimeNamespace: string;
 }
 
-export type TRuntimeAssignmentDispositionV1 =
+export type TRuntimeAssignmentDisposition =
   | 'run'
   | 'stop-preserve'
   | 'remove-runtime-preserve-storage';
 
-export interface IRuntimeAssignmentV1 extends IRuntimeAssignmentScopeV1 {
-  schemaVersion: 1;
+export interface IRuntimeAssignment extends IRuntimeAssignmentScope {
   assignmentId: string;
   serviceId: string;
   /** Stable logical replica; independent of container IDs and execution attempts. */
@@ -48,8 +50,8 @@ export interface IRuntimeAssignmentV1 extends IRuntimeAssignmentScopeV1 {
   siteId: string | null;
   generation: number;
   /** Exact CAS predecessor; null only at generation 1. */
-  previous: IRuntimeAssignmentReferenceV1 | null;
-  disposition: TRuntimeAssignmentDispositionV1;
+  previous: IRuntimeAssignmentReference | null;
+  disposition: TRuntimeAssignmentDisposition;
   /** No automatic relocation or expiry-based claim of a stopped writer. */
   offlinePolicy: 'continue-node-bound';
   workload: {
@@ -58,24 +60,67 @@ export interface IRuntimeAssignmentV1 extends IRuntimeAssignmentScopeV1 {
     imageDigest: TSha256Digest;
     platform: TImmutableContainerPlatform;
     /** Immutable complete invocation/configuration owned by the controller. */
-    config: IRuntimeAuthorityReferenceV1;
-    network: IRuntimeAuthorityReferenceV1 | null;
-    secrets: IRuntimeAuthorityReferenceV1 | null;
+    config: IRuntimeAuthorityReference;
+    network: IRuntimeAuthorityReference | null;
+    secrets: IRuntimeAuthorityReference | null;
     /** Sorted unique reference IDs. Empty means no persistent storage claims. */
-    storage: IRuntimeAuthorityReferenceV1[];
+    storage: IRuntimeAuthorityReference[];
   };
   digest: TSha256Digest;
 }
 
-export type TRuntimeAssignmentDecisionV1 =
-  | { status: 'accept' | 'replay'; assignment: IRuntimeAssignmentV1 }
+/**
+ * What a node must be able to resolve before it may run a workload, named by the workload keys
+ * that carry it. One vocabulary, so a node, a controller and a producer all mean the same thing.
+ */
+export const runtimeWorkloadAuthorities = ['network', 'secrets', 'storage'] as const;
+
+export type TRuntimeWorkloadAuthority = (typeof runtimeWorkloadAuthorities)[number];
+
+/** What each authority looks at on the workload; a record over the union, so none can be missed. */
+const workloadAuthorityDemands: Readonly<Record<
+  TRuntimeWorkloadAuthority,
+  (workloadArg: IRuntimeAssignment['workload']) => boolean
+>> = Object.freeze({
+  network: (workloadArg) => workloadArg.network !== null,
+  secrets: (workloadArg) => workloadArg.secrets !== null,
+  storage: (workloadArg) => workloadArg.storage.length > 0,
+});
+
+/**
+ * The authorities this workload cannot run without.
+ *
+ * Filtered out of the vocabulary and ordered by the canonical comparison, so the result is sorted
+ * and duplicate-free whatever order the vocabulary is declared in, and compares byte-equal against
+ * the list a node resolved. A controller calls this with a workload it read from an assignment on
+ * the wire, so one the demands cannot read is refused by this family's error rather than by a
+ * `TypeError` out of a member read.
+ */
+export const requiredWorkloadAuthorities = (
+  workloadArg: IRuntimeAssignment['workload'],
+): TRuntimeWorkloadAuthority[] => {
+  if (!isExactRecord(workloadArg, workloadKeys) || !Array.isArray(workloadArg.storage)) {
+    fail(workloadSchemaMessage);
+  }
+  return runtimeWorkloadAuthorities
+    .filter((authorityArg) => workloadAuthorityDemands[authorityArg](workloadArg))
+    .sort(compareWireTokens);
+};
+
+/** True when a value is exactly a canonical authority list drawn from the authority vocabulary. */
+export const isResolvedWorkloadAuthorities = (
+  valueArg: unknown,
+): valueArg is TRuntimeWorkloadAuthority[] =>
+  isCanonicalTokenList(valueArg, runtimeWorkloadAuthorities);
+
+export type TRuntimeAssignmentDecision =
+  | { status: 'accept' | 'replay'; assignment: IRuntimeAssignment }
   | { status: 'reject'; reason: 'invalid' | 'scope-mismatch' | 'conflict' | 'stale'
       | 'predecessor-mismatch' | 'attempt-mismatch' | 'disposition-regression' };
 
 /** Value-free execution evidence. Receipt/acceptance alone never means ready. */
-export interface IRuntimeAssignmentObservationV1 {
-  schemaVersion: 1;
-  assignment: IRuntimeAssignmentReferenceV1;
+export interface IRuntimeAssignmentObservation {
+  assignment: IRuntimeAssignmentReference;
   /** Authenticated reporter session; its authority is verified by the receiver. */
   reporterSessionId: string;
   /** Durable per-assignment counter; never resets when a reporter reconnects. */
@@ -91,9 +136,9 @@ export interface IRuntimeAssignmentObservationV1 {
   digest: TSha256Digest;
 }
 
-export const runtimeAssignmentV1Contract = Object.freeze({
-  assignmentDigestDomain: 'serve.zone/runtime-assignment-v1',
-  observationDigestDomain: 'serve.zone/runtime-assignment-observation-v1',
+export const runtimeAssignmentContract = Object.freeze({
+  assignmentDigestDomain: 'serve.zone/runtime-assignment',
+  observationDigestDomain: 'serve.zone/runtime-assignment-observation',
   maximumStorageReferences: 64,
   omission: 'no-effect',
   removal: 'retain-assignment-tombstone-and-storage',
@@ -123,32 +168,37 @@ const isExactRecord = (
   });
 };
 
-const isController = (valueArg: unknown): valueArg is IRuntimeControllerV1 =>
+const isController = (valueArg: unknown): valueArg is IRuntimeController =>
   isExactRecord(valueArg, ['kind', 'id', 'epoch'])
   && (valueArg.kind === 'cloudly' || valueArg.kind === 'onebox')
   && isIdentifier(valueArg.id) && isIdentifier(valueArg.epoch);
-const isAuthorityReference = (valueArg: unknown): valueArg is IRuntimeAuthorityReferenceV1 =>
+const isAuthorityReference = (valueArg: unknown): valueArg is IRuntimeAuthorityReference =>
   isExactRecord(valueArg, ['id', 'generation', 'digest'])
   && isIdentifier(valueArg.id) && isPositiveInteger(valueArg.generation) && isDigest(valueArg.digest);
-const isAssignmentReference = (valueArg: unknown): valueArg is IRuntimeAssignmentReferenceV1 =>
+const isAssignmentReference = (valueArg: unknown): valueArg is IRuntimeAssignmentReference =>
   isExactRecord(valueArg, ['assignmentId', 'generation', 'digest'])
   && isIdentifier(valueArg.assignmentId) && isPositiveInteger(valueArg.generation)
   && isDigest(valueArg.digest);
 
+/** The workload's exact members, read by the authority vocabulary and by the snapshot alike. */
+const workloadKeys = ['registryHost', 'repository', 'imageDigest', 'platform',
+  'config', 'network', 'secrets', 'storage'] as const;
+const workloadSchemaMessage = 'runtime assignment workload must use exact immutable references';
+
 const assignmentKeys = [
-  'schemaVersion', 'controller', 'organizationId', 'nodeId', 'runtimeNamespace',
+  'controller', 'organizationId', 'nodeId', 'runtimeNamespace',
   'assignmentId', 'serviceId', 'replicaId', 'attemptId', 'workerGroupId', 'siteId',
   'generation', 'previous', 'disposition', 'offlinePolicy', 'workload', 'digest',
 ] as const;
 
-const assertAssignment = (valueArg: unknown): IRuntimeAssignmentV1 => {
+const assertAssignment = (valueArg: unknown): IRuntimeAssignment => {
   if (!isExactRecord(valueArg, assignmentKeys)
-    || valueArg.schemaVersion !== 1 || !isController(valueArg.controller)
+    || !isController(valueArg.controller)
     || !isPositiveInteger(valueArg.generation) || !isDigest(valueArg.digest)
     || valueArg.offlinePolicy !== 'continue-node-bound'
     || !['run', 'stop-preserve', 'remove-runtime-preserve-storage'].includes(
       valueArg.disposition as string,
-    )) fail('runtime assignment must use its exact v1 schema');
+    )) fail('runtime assignment must use its exact schema');
   for (const key of ['organizationId', 'nodeId', 'runtimeNamespace', 'assignmentId',
     'serviceId', 'replicaId', 'attemptId']) {
     if (!isIdentifier(valueArg[key])) fail(`runtime assignment ${key} must be a canonical identifier`);
@@ -163,8 +213,7 @@ const assertAssignment = (valueArg: unknown): IRuntimeAssignmentV1 => {
     fail('runtime assignment must bind its exact preceding generation');
   }
   const workload = valueArg.workload;
-  if (!isExactRecord(workload, ['registryHost', 'repository', 'imageDigest', 'platform',
-    'config', 'network', 'secrets', 'storage'])
+  if (!isExactRecord(workload, workloadKeys)
     || typeof workload.registryHost !== 'string' || workload.registryHost.length > 253
     || typeof workload.repository !== 'string' || workload.repository.length > 255
     || !isDigest(workload.imageDigest)
@@ -173,8 +222,8 @@ const assertAssignment = (valueArg: unknown): IRuntimeAssignmentV1 => {
     || (workload.network !== null && !isAuthorityReference(workload.network))
     || (workload.secrets !== null && !isAuthorityReference(workload.secrets))
     || !Array.isArray(workload.storage)
-    || workload.storage.length > runtimeAssignmentV1Contract.maximumStorageReferences) {
-    fail('runtime assignment workload must use exact immutable references');
+    || workload.storage.length > runtimeAssignmentContract.maximumStorageReferences) {
+    fail(workloadSchemaMessage);
   }
   buildDigestPinnedImageReference(workload.registryHost as string,
     workload.repository as string, workload.imageDigest as TSha256Digest);
@@ -188,7 +237,7 @@ const assertAssignment = (valueArg: unknown): IRuntimeAssignmentV1 => {
     previousId = descriptor.value.id;
   }
   canonicalizeStrictJson(valueArg, fail);
-  return valueArg as unknown as IRuntimeAssignmentV1;
+  return valueArg as unknown as IRuntimeAssignment;
 };
 
 const digestPayload = async (domainArg: string, valueArg: { digest: TSha256Digest }): Promise<TSha256Digest> => {
@@ -199,41 +248,41 @@ const digestPayload = async (domainArg: string, valueArg: { digest: TSha256Diges
 };
 
 /** Digest helpers validate structure and exclude only the object's own digest. */
-export const computeRuntimeAssignmentV1Digest = async (
-  assignmentArg: IRuntimeAssignmentV1,
+export const computeRuntimeAssignmentDigest = async (
+  assignmentArg: IRuntimeAssignment,
 ): Promise<TSha256Digest> => digestPayload(
-  runtimeAssignmentV1Contract.assignmentDigestDomain, assertAssignment(assignmentArg),
+  runtimeAssignmentContract.assignmentDigestDomain, assertAssignment(assignmentArg),
 );
 
-export const validateRuntimeAssignmentV1 = async (valueArg: unknown): Promise<string[]> => {
+export const validateRuntimeAssignment = async (valueArg: unknown): Promise<string[]> => {
   try {
-    const assignment = snapshotRuntimeAssignmentV1(valueArg);
-    return assignment.digest === await computeRuntimeAssignmentV1Digest(assignment)
+    const assignment = snapshotRuntimeAssignment(valueArg);
+    return assignment.digest === await computeRuntimeAssignmentDigest(assignment)
       ? [] : ['runtime assignment digest does not match'];
   } catch {
-    return ['runtime assignment must use its exact canonical v1 schema'];
+    return ['runtime assignment must use its exact canonical schema'];
   }
 };
 
 /**
  * Synchronous exact-schema validation and detached canonical copy for persistence
  * assertions. This does not verify the digest, authenticate scope, or admit an
- * attempt. Use validateRuntimeAssignmentV1/evaluateRuntimeAssignmentV1 before
+ * attempt. Use validateRuntimeAssignment/evaluateRuntimeAssignment before
  * acceptance or effects.
  */
-export const snapshotRuntimeAssignmentV1 = (valueArg: unknown): IRuntimeAssignmentV1 =>
-  JSON.parse(canonicalizeStrictJson(assertAssignment(valueArg), fail)) as IRuntimeAssignmentV1;
+export const snapshotRuntimeAssignment = (valueArg: unknown): IRuntimeAssignment =>
+  JSON.parse(canonicalizeStrictJson(assertAssignment(valueArg), fail)) as IRuntimeAssignment;
 
-export const getRuntimeAssignmentV1Reference = (
-  assignmentArg: IRuntimeAssignmentV1,
-): IRuntimeAssignmentReferenceV1 => ({
+export const getRuntimeAssignmentReference = (
+  assignmentArg: IRuntimeAssignment,
+): IRuntimeAssignmentReference => ({
   assignmentId: assignmentArg.assignmentId,
   generation: assignmentArg.generation,
   digest: assignmentArg.digest,
 });
 
 const canonical = (valueArg: unknown): string => canonicalizeStrictJson(valueArg, fail);
-const immutableAttempt = (assignmentArg: IRuntimeAssignmentV1): string => {
+const immutableAttempt = (assignmentArg: IRuntimeAssignment): string => {
   const { generation, previous, disposition, digest, ...attempt } = assignmentArg;
   return canonical(attempt);
 };
@@ -245,27 +294,27 @@ const immutableAttempt = (assignmentArg: IRuntimeAssignmentV1): string => {
  * admission for every older writer. An omitted assignment causes no transition.
  * Persist only the returned detached snapshot, never the mutable input object.
  */
-export const evaluateRuntimeAssignmentV1 = async (
-  incomingArg: IRuntimeAssignmentV1,
-  acceptedArg: IRuntimeAssignmentV1 | null,
-  trustedScopeArg: IRuntimeAssignmentScopeV1,
-): Promise<TRuntimeAssignmentDecisionV1> => {
+export const evaluateRuntimeAssignment = async (
+  incomingArg: IRuntimeAssignment,
+  acceptedArg: IRuntimeAssignment | null,
+  trustedScopeArg: IRuntimeAssignmentScope,
+): Promise<TRuntimeAssignmentDecision> => {
   try {
-    incomingArg = snapshotRuntimeAssignmentV1(incomingArg);
-    acceptedArg = acceptedArg === null ? null : snapshotRuntimeAssignmentV1(acceptedArg);
+    incomingArg = snapshotRuntimeAssignment(incomingArg);
+    acceptedArg = acceptedArg === null ? null : snapshotRuntimeAssignment(acceptedArg);
     if (!isExactRecord(trustedScopeArg, ['controller', 'organizationId', 'nodeId', 'runtimeNamespace'])
       || !isController(trustedScopeArg.controller)
       || !isIdentifier(trustedScopeArg.organizationId) || !isIdentifier(trustedScopeArg.nodeId)
       || !isIdentifier(trustedScopeArg.runtimeNamespace)) return { status: 'reject', reason: 'invalid' };
-    trustedScopeArg = JSON.parse(canonical(trustedScopeArg)) as IRuntimeAssignmentScopeV1;
+    trustedScopeArg = JSON.parse(canonical(trustedScopeArg)) as IRuntimeAssignmentScope;
   } catch {
     return { status: 'reject', reason: 'invalid' };
   }
-  if ((await validateRuntimeAssignmentV1(incomingArg)).length
-    || (acceptedArg !== null && (await validateRuntimeAssignmentV1(acceptedArg)).length)) {
+  if ((await validateRuntimeAssignment(incomingArg)).length
+    || (acceptedArg !== null && (await validateRuntimeAssignment(acceptedArg)).length)) {
     return { status: 'reject', reason: 'invalid' };
   }
-  const matchesScope = (assignmentArg: IRuntimeAssignmentV1): boolean =>
+  const matchesScope = (assignmentArg: IRuntimeAssignment): boolean =>
     assignmentArg.controller.kind === trustedScopeArg.controller.kind
     && assignmentArg.controller.id === trustedScopeArg.controller.id
     && assignmentArg.controller.epoch === trustedScopeArg.controller.epoch
@@ -289,13 +338,13 @@ export const evaluateRuntimeAssignmentV1 = async (
     return incomingArg.digest === acceptedArg.digest
       ? { status: 'replay', assignment: acceptedArg } : { status: 'reject', reason: 'conflict' };
   }
-  if (canonical(incomingArg.previous) !== canonical(getRuntimeAssignmentV1Reference(acceptedArg))) {
+  if (canonical(incomingArg.previous) !== canonical(getRuntimeAssignmentReference(acceptedArg))) {
     return { status: 'reject', reason: 'predecessor-mismatch' };
   }
   if (immutableAttempt(incomingArg) !== immutableAttempt(acceptedArg)) {
     return { status: 'reject', reason: 'attempt-mismatch' };
   }
-  const order: Record<TRuntimeAssignmentDispositionV1, number> = {
+  const order: Record<TRuntimeAssignmentDisposition, number> = {
     run: 0, 'stop-preserve': 1, 'remove-runtime-preserve-storage': 2,
   };
   if (order[incomingArg.disposition] !== order[acceptedArg.disposition] + 1) {
@@ -304,15 +353,15 @@ export const evaluateRuntimeAssignmentV1 = async (
   return { status: 'accept', assignment: incomingArg };
 };
 
-const assertObservation = (valueArg: unknown): IRuntimeAssignmentObservationV1 => {
-  if (!isExactRecord(valueArg, ['schemaVersion', 'assignment', 'reporterSessionId',
+const assertObservation = (valueArg: unknown): IRuntimeAssignmentObservation => {
+  if (!isExactRecord(valueArg, ['assignment', 'reporterSessionId',
     'sequence', 'observedAt', 'phase', 'ready', 'runtime', 'digest'])
-    || valueArg.schemaVersion !== 1 || !isAssignmentReference(valueArg.assignment)
+    || !isAssignmentReference(valueArg.assignment)
     || !isIdentifier(valueArg.reporterSessionId) || !isPositiveInteger(valueArg.sequence)
     || !isPositiveInteger(valueArg.observedAt) || !isDigest(valueArg.digest)
     || typeof valueArg.ready !== 'boolean'
     || !['pending', 'running', 'stopped', 'removed', 'failed', 'unknown'].includes(valueArg.phase as string)) {
-    fail('runtime observation must use its exact v1 schema');
+    fail('runtime observation must use its exact schema');
   }
   if (valueArg.runtime !== null && (!isExactRecord(valueArg.runtime, [
     'sandboxId', 'containerId', 'imageDigest',
@@ -324,13 +373,13 @@ const assertObservation = (valueArg: unknown): IRuntimeAssignmentObservationV1 =
     fail('runtime observation readiness and identity contradict its phase');
   }
   canonical(valueArg);
-  return valueArg as unknown as IRuntimeAssignmentObservationV1;
+  return valueArg as unknown as IRuntimeAssignmentObservation;
 };
 
-export const computeRuntimeAssignmentObservationV1Digest = async (
-  observationArg: IRuntimeAssignmentObservationV1,
+export const computeRuntimeAssignmentObservationDigest = async (
+  observationArg: IRuntimeAssignmentObservation,
 ): Promise<TSha256Digest> => digestPayload(
-  runtimeAssignmentV1Contract.observationDigestDomain, assertObservation(observationArg),
+  runtimeAssignmentContract.observationDigestDomain, assertObservation(observationArg),
 );
 
 /**
@@ -338,24 +387,24 @@ export const computeRuntimeAssignmentObservationV1Digest = async (
  * assignment and reporter authority still require the observation validator and
  * evaluator; a structurally valid observation is never a writer fence.
  */
-export const snapshotRuntimeAssignmentObservationV1 = (
+export const snapshotRuntimeAssignmentObservation = (
   valueArg: unknown,
-): IRuntimeAssignmentObservationV1 =>
-  JSON.parse(canonical(assertObservation(valueArg))) as IRuntimeAssignmentObservationV1;
+): IRuntimeAssignmentObservation =>
+  JSON.parse(canonical(assertObservation(valueArg))) as IRuntimeAssignmentObservation;
 
 /** Checks exact assignment evidence; transport must separately bind reporter/session. */
-export const validateRuntimeAssignmentObservationV1 = async (
+export const validateRuntimeAssignmentObservation = async (
   observationArg: unknown,
-  assignmentArg: IRuntimeAssignmentV1,
+  assignmentArg: IRuntimeAssignment,
 ): Promise<string[]> => {
   try {
-    const observation = snapshotRuntimeAssignmentObservationV1(observationArg);
-    assignmentArg = snapshotRuntimeAssignmentV1(assignmentArg);
-    if ((await validateRuntimeAssignmentV1(assignmentArg)).length) return ['invalid assignment'];
-    if (canonical(observation.assignment) !== canonical(getRuntimeAssignmentV1Reference(assignmentArg))) {
+    const observation = snapshotRuntimeAssignmentObservation(observationArg);
+    assignmentArg = snapshotRuntimeAssignment(assignmentArg);
+    if ((await validateRuntimeAssignment(assignmentArg)).length) return ['invalid assignment'];
+    if (canonical(observation.assignment) !== canonical(getRuntimeAssignmentReference(assignmentArg))) {
       return ['runtime observation does not match the exact assignment'];
     }
-    if (observation.digest !== await computeRuntimeAssignmentObservationV1Digest(observation)) {
+    if (observation.digest !== await computeRuntimeAssignmentObservationDigest(observation)) {
       return ['runtime observation digest does not match'];
     }
     if (observation.ready && (assignmentArg.disposition !== 'run'
@@ -364,12 +413,12 @@ export const validateRuntimeAssignmentObservationV1 = async (
     }
     return [];
   } catch {
-    return ['runtime observation must use its exact canonical v1 schema'];
+    return ['runtime observation must use its exact canonical schema'];
   }
 };
 
-export type TRuntimeObservationDecisionV1 =
-  | { status: 'accept' | 'replay'; observation: IRuntimeAssignmentObservationV1 }
+export type TRuntimeObservationDecision =
+  | { status: 'accept' | 'replay'; observation: IRuntimeAssignmentObservation }
   | { status: 'reject'; reason: 'invalid' | 'session-mismatch' | 'stale' | 'conflict' | 'sequence-gap' };
 
 /**
@@ -380,23 +429,23 @@ export type TRuntimeObservationDecisionV1 =
  * receivers must process each revision's observations in order.
  * These observations are never sufficient authority to relocate a storage writer.
  */
-export const evaluateRuntimeAssignmentObservationV1 = async (
-  incomingArg: IRuntimeAssignmentObservationV1,
-  acceptedArg: IRuntimeAssignmentObservationV1 | null,
-  assignmentArg: IRuntimeAssignmentV1,
+export const evaluateRuntimeAssignmentObservation = async (
+  incomingArg: IRuntimeAssignmentObservation,
+  acceptedArg: IRuntimeAssignmentObservation | null,
+  assignmentArg: IRuntimeAssignment,
   trustedReporterSessionIdArg: string,
-): Promise<TRuntimeObservationDecisionV1> => {
+): Promise<TRuntimeObservationDecision> => {
   try {
-    incomingArg = snapshotRuntimeAssignmentObservationV1(incomingArg);
+    incomingArg = snapshotRuntimeAssignmentObservation(incomingArg);
     acceptedArg = acceptedArg === null ? null
-      : snapshotRuntimeAssignmentObservationV1(acceptedArg);
-    assignmentArg = snapshotRuntimeAssignmentV1(assignmentArg);
+      : snapshotRuntimeAssignmentObservation(acceptedArg);
+    assignmentArg = snapshotRuntimeAssignment(assignmentArg);
     if (!isIdentifier(trustedReporterSessionIdArg)
-      || (await validateRuntimeAssignmentObservationV1(incomingArg, assignmentArg)).length
+      || (await validateRuntimeAssignmentObservation(incomingArg, assignmentArg)).length
       || (acceptedArg !== null && (
-        acceptedArg.digest !== await computeRuntimeAssignmentObservationV1Digest(acceptedArg)
+        acceptedArg.digest !== await computeRuntimeAssignmentObservationDigest(acceptedArg)
         || acceptedArg.assignment.assignmentId !== assignmentArg.assignmentId
-        || (canonical(acceptedArg.assignment) !== canonical(getRuntimeAssignmentV1Reference(assignmentArg))
+        || (canonical(acceptedArg.assignment) !== canonical(getRuntimeAssignmentReference(assignmentArg))
           && canonical(acceptedArg.assignment) !== canonical(assignmentArg.previous))
       ))) return { status: 'reject', reason: 'invalid' };
     if (incomingArg.reporterSessionId !== trustedReporterSessionIdArg) {