@pixel-point/toolcraft 0.0.15 → 0.0.17

package/templates/runtime/model-import/worker/model-import-worker-protocol-validation.ts

@@ -0,0 +1,714 @@
+import type {
+  ToolcraftModelImportLimits,
+  ToolcraftModelTopologyProfile,
+} from "../../schema/types";
+import { getToolcraftModelRepairPlanEnvelopeByteLimit } from "../topology/model-repair-plan-envelope";
+import { TOOLCRAFT_MODEL_TOPOLOGY_ANALYZER_VERSION } from "../topology/model-topology-analysis";
+import type {
+  ToolcraftModelAppearanceResource,
+  ToolcraftModelTopologyDiagnostic,
+  ToolcraftModelTopologyStatistics,
+  ToolcraftModelWorkerAnalysisSummary,
+} from "../model-import-types";
+import {
+  isToolcraftModelAppearanceMimeType,
+  parseToolcraftModelAppearanceResourceRef,
+} from "../canonical/model-appearance-resource";
+import { TOOLCRAFT_MODEL_IMPORT_LIMIT_NAMES } from "../model-import-limit-values";
+import { normalizeToolcraftModelPackagePath } from "../model-package-path";
+import {
+  TOOLCRAFT_MODEL_WORKER_DIAGNOSTIC_CODE_MAX_LENGTH as MAX_CODE_LENGTH,
+  TOOLCRAFT_MODEL_WORKER_DIAGNOSTIC_EXPLANATION_MAX_LENGTH as MAX_EXPLANATION_LENGTH,
+  TOOLCRAFT_MODEL_WORKER_DIAGNOSTIC_ID_MAX_LENGTH as MAX_ID_LENGTH,
+  TOOLCRAFT_MODEL_WORKER_FEEDBACK_MAX_LENGTH,
+  TOOLCRAFT_MODEL_WORKER_MAX_DIAGNOSTICS,
+  type ToolcraftModelPackageExtractWorkerResult,
+  type ToolcraftModelRepairPlanEnvelope,
+  type ToolcraftModelWorkerOperation,
+  type ToolcraftModelWorkerDraft,
+  type ToolcraftModelWorkerResponse,
+  type ToolcraftModelWorkerResult,
+} from "./model-import-worker-protocol";
+
+const INVALID = Symbol("invalid-worker-protocol-value");
+const SHA256_DIGEST_PATTERN = /^sha256:[0-9a-f]{64}$/u;
+const MAX_JOB_ID_LENGTH = 1_024;
+const arrayBufferByteLengthGetter = Object.getOwnPropertyDescriptor(
+  ArrayBuffer.prototype,
+  "byteLength",
+)?.get;
+
+type RecordValue = Record<PropertyKey, unknown>;
+
+export type ToolcraftModelWorkerExpectedOperation =
+  ToolcraftModelWorkerOperation;
+
+export type ToolcraftModelWorkerValidationContext = Readonly<{
+  expectedArchiveDigest?: string;
+  expectedOperation: ToolcraftModelWorkerExpectedOperation;
+  expectedRepairPlanEnvelope?: Readonly<{
+    byteLength: number;
+    envelopeDigest: string;
+    planDigest: string;
+    version: 1;
+  }>;
+  limits: Readonly<ToolcraftModelImportLimits>;
+  topologyProfile?: ToolcraftModelTopologyProfile;
+}>;
+
+export type ToolcraftModelWorkerMessageIdentity = Readonly<{
+  generation: number;
+  jobId: string;
+}>;
+
+function isRecord(value: unknown): value is RecordValue {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function ownValue(record: RecordValue, key: PropertyKey): unknown | typeof INVALID {
+  const descriptor = Object.getOwnPropertyDescriptor(record, key);
+  return descriptor && "value" in descriptor ? descriptor.value : INVALID;
+}
+
+function hasOnlyKeys(record: RecordValue, allowed: readonly string[]): boolean {
+  return Reflect.ownKeys(record).every(
+    (key) => typeof key === "string" && allowed.includes(key),
+  );
+}
+
+function boundedString(
+  value: unknown,
+  maxLength: number,
+  allowEmpty = false,
+): value is string {
+  return typeof value === "string" && (allowEmpty || value.length > 0) &&
+    value.length <= maxLength;
+}
+
+function nonNegativeSafeInteger(value: unknown): value is number {
+  return Number.isSafeInteger(value) && (value as number) >= 0;
+}
+
+function digest(value: unknown): value is string {
+  return typeof value === "string" && SHA256_DIGEST_PATTERN.test(value);
+}
+
+function arrayBufferByteLength(
+  value: unknown,
+  maximum: number,
+  allowEmpty = false,
+): number | undefined {
+  if (!arrayBufferByteLengthGetter) return undefined;
+  try {
+    const byteLength = Reflect.apply(arrayBufferByteLengthGetter, value, []) as number;
+    return Number.isSafeInteger(byteLength) &&
+      (allowEmpty ? byteLength >= 0 : byteLength > 0) &&
+      byteLength <= maximum
+      ? byteLength
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function arrayBuffer(value: unknown, maximum: number): value is ArrayBuffer {
+  return arrayBufferByteLength(value, maximum) !== undefined;
+}
+
+function readAppearanceResources(
+  value: unknown,
+  limits: Readonly<ToolcraftModelImportLimits>,
+): readonly ToolcraftModelAppearanceResource[] | undefined {
+  if (!Array.isArray(value) || value.length > limits.maxTextureCount) {
+    return undefined;
+  }
+  const resources: ToolcraftModelAppearanceResource[] = [];
+  let aggregateBytes = 0;
+  let previousRef = "";
+  for (let index = 0; index < value.length; index += 1) {
+    if (!Object.prototype.hasOwnProperty.call(value, index)) return undefined;
+    const resource = value[index];
+    if (!isRecord(resource) || !hasOnlyKeys(resource, [
+      "bytes",
+      "contentDigest",
+      "mimeType",
+      "resourceRef",
+    ])) return undefined;
+    const bytes = ownValue(resource, "bytes");
+    const contentDigest = ownValue(resource, "contentDigest");
+    const mimeType = ownValue(resource, "mimeType");
+    const resourceRef = ownValue(resource, "resourceRef");
+    const byteLength = arrayBufferByteLength(bytes, limits.maxTextureBytes);
+    if (
+      byteLength === undefined ||
+      !arrayBuffer(bytes, limits.maxTextureBytes) ||
+      !digest(contentDigest) ||
+      !isToolcraftModelAppearanceMimeType(mimeType) ||
+      typeof resourceRef !== "string" ||
+      parseToolcraftModelAppearanceResourceRef(resourceRef) !== contentDigest ||
+      resourceRef <= previousRef ||
+      aggregateBytes > limits.maxTextureBytes - byteLength
+    ) {
+      return undefined;
+    }
+    aggregateBytes += byteLength;
+    previousRef = resourceRef;
+    resources.push(Object.freeze({
+      bytes,
+      contentDigest,
+      mimeType,
+      resourceRef,
+    }));
+  }
+  return Object.freeze(resources);
+}
+
+function readDiagnostic(
+  value: unknown,
+  allowPrimitiveIndex = false,
+): ToolcraftModelTopologyDiagnostic | undefined {
+  if (!isRecord(value) || !hasOnlyKeys(value, [
+    "affectedCount",
+    "code",
+    "explanation",
+    "primitiveId",
+    ...(allowPrimitiveIndex ? ["primitiveIndex"] : []),
+    "severity",
+  ])) return undefined;
+  const affectedCount = ownValue(value, "affectedCount");
+  const code = ownValue(value, "code");
+  const explanation = ownValue(value, "explanation");
+  const primitiveId = ownValue(value, "primitiveId");
+  const primitiveIndex = ownValue(value, "primitiveIndex");
+  const severity = ownValue(value, "severity");
+  if (!nonNegativeSafeInteger(affectedCount) ||
+      !boundedString(code, MAX_CODE_LENGTH) ||
+      !boundedString(explanation, MAX_EXPLANATION_LENGTH) ||
+      (primitiveId !== INVALID && !boundedString(primitiveId, MAX_ID_LENGTH)) ||
+      (primitiveIndex !== INVALID && !nonNegativeSafeInteger(primitiveIndex)) ||
+      (severity !== "fatal" && severity !== "info" &&
+        severity !== "repairable" && severity !== "warning")) return undefined;
+  return Object.freeze({
+    affectedCount,
+    code: code as ToolcraftModelTopologyDiagnostic["code"],
+    explanation,
+    ...(primitiveId === INVALID ? {} : { primitiveId }),
+    ...(primitiveIndex === INVALID ? {} : { primitiveIndex }),
+    severity,
+  });
+}
+
+function readFeedback(value: unknown) {
+  if (!isRecord(value) || !hasOnlyKeys(value, ["category", "code", "message"])) {
+    return undefined;
+  }
+  const category = ownValue(value, "category");
+  const code = ownValue(value, "code");
+  const message = ownValue(value, "message");
+  if ((category !== "bundle" && category !== "format" && category !== "geometry" &&
+      category !== "repair" && category !== "resource-limit" &&
+      category !== "resource-unavailable" && category !== "topology") ||
+      !boundedString(code, MAX_CODE_LENGTH) ||
+      !boundedString(message, TOOLCRAFT_MODEL_WORKER_FEEDBACK_MAX_LENGTH)) {
+    return undefined;
+  }
+  return Object.freeze({ category, code, message });
+}
+
+function readLimits(
+  value: unknown,
+  expected: Readonly<ToolcraftModelImportLimits>,
+): Readonly<ToolcraftModelImportLimits> | undefined {
+  if (!isRecord(value) ||
+      !hasOnlyKeys(value, TOOLCRAFT_MODEL_IMPORT_LIMIT_NAMES) ||
+      !TOOLCRAFT_MODEL_IMPORT_LIMIT_NAMES.every(
+        (name) => ownValue(value, name) === expected[name],
+      )) {
+    return undefined;
+  }
+  return Object.freeze({ ...expected });
+}
+
+const statisticNames = [
+  "boundaryEdgeCount",
+  "componentCount",
+  "decodedBytes",
+  "edgeCount",
+  "estimatedPeakWorkerBytes",
+  "estimatedRepairBytes",
+  "nodeCount",
+  "nonManifoldEdgeCount",
+  "nonManifoldVertexCount",
+  "primitiveCount",
+  "triangleCount",
+  "unusedVertexCount",
+  "vertexCount",
+] as const satisfies readonly (keyof ToolcraftModelTopologyStatistics)[];
+
+function readStatistics(
+  value: unknown,
+  limits: Readonly<ToolcraftModelImportLimits>,
+): ToolcraftModelTopologyStatistics | undefined {
+  if (!isRecord(value) || !hasOnlyKeys(value, statisticNames)) return undefined;
+  const values = Object.fromEntries(
+    statisticNames.map((name) => [name, ownValue(value, name)]),
+  ) as Record<(typeof statisticNames)[number], unknown>;
+  if (!statisticNames.every((name) => nonNegativeSafeInteger(values[name]))) {
+    return undefined;
+  }
+  const statistics = values as unknown as ToolcraftModelTopologyStatistics;
+  const valid = statistics.triangleCount <= limits.maxTriangles &&
+    statistics.vertexCount <= limits.maxVertices &&
+    statistics.nodeCount <= limits.maxNodes &&
+    statistics.primitiveCount <= limits.maxPrimitives &&
+    statistics.decodedBytes <= limits.maxDecodedBytes &&
+    statistics.estimatedPeakWorkerBytes <= limits.maxEstimatedWorkerBytes &&
+    statistics.estimatedRepairBytes <= limits.maxEstimatedWorkerBytes &&
+    statistics.edgeCount <= statistics.triangleCount * 3 &&
+    statistics.boundaryEdgeCount <= statistics.edgeCount &&
+    statistics.nonManifoldEdgeCount <= statistics.edgeCount &&
+    statistics.nonManifoldVertexCount <= statistics.vertexCount &&
+    statistics.unusedVertexCount <= statistics.vertexCount &&
+    statistics.componentCount <= statistics.triangleCount + statistics.primitiveCount;
+  return valid ? Object.freeze({ ...statistics }) : undefined;
+}
+
+function readAnalysis(
+  value: unknown,
+  context: ToolcraftModelWorkerValidationContext,
+): ToolcraftModelWorkerAnalysisSummary | undefined {
+  if (!isRecord(value) || !hasOnlyKeys(value, [
+    "analyzerVersion",
+    "diagnostics",
+    "limits",
+    "outcome",
+    "profile",
+    "statistics",
+  ])) return undefined;
+  const rawDiagnostics = ownValue(value, "diagnostics");
+  if (!Array.isArray(rawDiagnostics) ||
+      rawDiagnostics.length > TOOLCRAFT_MODEL_WORKER_MAX_DIAGNOSTICS) return undefined;
+  const diagnostics: ToolcraftModelTopologyDiagnostic[] = [];
+  for (let index = 0; index < rawDiagnostics.length; index += 1) {
+    if (!Object.prototype.hasOwnProperty.call(rawDiagnostics, index)) return undefined;
+    const item = readDiagnostic(rawDiagnostics[index], true);
+    if (!item) return undefined;
+    diagnostics.push(item);
+  }
+  const limits = readLimits(ownValue(value, "limits"), context.limits);
+  const statistics = readStatistics(ownValue(value, "statistics"), context.limits);
+  const outcome = ownValue(value, "outcome");
+  const profile = ownValue(value, "profile");
+  if (ownValue(value, "analyzerVersion") !== TOOLCRAFT_MODEL_TOPOLOGY_ANALYZER_VERSION ||
+      !limits || !statistics ||
+      (outcome !== "clean" && outcome !== "fatal" &&
+        outcome !== "repairable" && outcome !== "warning") ||
+      (profile !== "realtime-mesh" && profile !== "solid-mesh") ||
+      (context.topologyProfile !== undefined && profile !== context.topologyProfile)) {
+    return undefined;
+  }
+  return Object.freeze({
+    analyzerVersion: TOOLCRAFT_MODEL_TOPOLOGY_ANALYZER_VERSION,
+    diagnostics: Object.freeze(diagnostics),
+    limits,
+    outcome,
+    profile,
+    statistics,
+  });
+}
+
+function readEnvelope(
+  value: unknown,
+  limits: Readonly<ToolcraftModelImportLimits>,
+): ToolcraftModelRepairPlanEnvelope | undefined {
+  if (!isRecord(value) || !hasOnlyKeys(value, [
+    "bytes",
+    "envelopeDigest",
+    "planDigest",
+    "version",
+  ])) return undefined;
+  const bytes = ownValue(value, "bytes");
+  const envelopeDigest = ownValue(value, "envelopeDigest");
+  const planDigest = ownValue(value, "planDigest");
+  if (!arrayBuffer(bytes, getToolcraftModelRepairPlanEnvelopeByteLimit(limits)) ||
+      !digest(envelopeDigest) || !digest(planDigest) || ownValue(value, "version") !== 1) {
+    return undefined;
+  }
+  return Object.freeze({ bytes, envelopeDigest, planDigest, version: 1 });
+}
+
+function hasConsistentOutcomeEvidence(
+  analysis: ToolcraftModelWorkerAnalysisSummary,
+  hasEnvelope: boolean,
+  operation: ToolcraftModelWorkerExpectedOperation,
+): boolean {
+  const severities = new Set(analysis.diagnostics.map(({ severity }) => severity));
+  const hasFatal = severities.has("fatal");
+  const hasRepairable = severities.has("repairable");
+  const hasWarning = severities.has("warning");
+
+  if (operation === "repair") {
+    return !hasEnvelope && !hasFatal && !hasRepairable &&
+      (analysis.outcome === "warning"
+        ? hasWarning
+        : analysis.outcome === "clean" && !hasWarning);
+  }
+
+  if (analysis.outcome === "fatal") {
+    return hasFatal && !hasEnvelope;
+  }
+  if (analysis.outcome === "repairable") {
+    return !hasFatal && hasRepairable && hasEnvelope;
+  }
+  if (analysis.outcome === "warning") {
+    return !hasFatal && !hasRepairable && hasWarning && !hasEnvelope;
+  }
+  return analysis.outcome === "clean" && !hasFatal && !hasRepairable &&
+    !hasWarning && !hasEnvelope;
+}
+
+function readPackageResult(
+  value: unknown,
+  context: ToolcraftModelWorkerValidationContext,
+): ToolcraftModelPackageExtractWorkerResult | undefined {
+  if (
+    !isRecord(value) ||
+    context.expectedOperation !== "extract-model-package" ||
+    !hasOnlyKeys(value, [
+      "archiveDigest",
+      "entries",
+      "operation",
+      "receiptDigest",
+    ]) ||
+    ownValue(value, "operation") !== "extract-model-package"
+  ) {
+    return undefined;
+  }
+  const archiveDigest = ownValue(value, "archiveDigest");
+  const rawEntries = ownValue(value, "entries");
+  const receiptDigest = ownValue(value, "receiptDigest");
+  if (
+    !digest(archiveDigest) ||
+    archiveDigest !== context.expectedArchiveDigest ||
+    !digest(receiptDigest) ||
+    !Array.isArray(rawEntries) ||
+    rawEntries.length === 0 ||
+    rawEntries.length > context.limits.maxArchiveEntries
+  ) {
+    return undefined;
+  }
+  const entries: ToolcraftModelPackageExtractWorkerResult["entries"][number][] = [];
+  const paths = new Set<string>();
+  let totalCompressedBytes = 0;
+  let totalUncompressedBytes = 0;
+  for (let index = 0; index < rawEntries.length; index += 1) {
+    if (!Object.prototype.hasOwnProperty.call(rawEntries, index)) return undefined;
+    const rawEntry = rawEntries[index];
+    if (!isRecord(rawEntry) || !hasOnlyKeys(rawEntry, [
+      "bytes",
+      "compressedBytes",
+      "contentDigest",
+      "mimeType",
+      "path",
+      "uncompressedBytes",
+    ])) return undefined;
+    const bytes = ownValue(rawEntry, "bytes");
+    const compressedBytes = ownValue(rawEntry, "compressedBytes");
+    const contentDigest = ownValue(rawEntry, "contentDigest");
+    const mimeType = ownValue(rawEntry, "mimeType");
+    const path = ownValue(rawEntry, "path");
+    const uncompressedBytes = ownValue(rawEntry, "uncompressedBytes");
+    const byteLength = arrayBufferByteLength(
+      bytes,
+      context.limits.maxArchiveEntryBytes,
+      true,
+    );
+    if (
+      byteLength === undefined ||
+      !nonNegativeSafeInteger(compressedBytes) ||
+      !nonNegativeSafeInteger(uncompressedBytes) ||
+      byteLength !== uncompressedBytes ||
+      !digest(contentDigest) ||
+      !boundedString(mimeType, 128) ||
+      !boundedString(path, context.limits.maxArchivePathLength) ||
+      normalizeToolcraftModelPackagePath(
+        path,
+        context.limits.maxArchivePathLength,
+      ) !== path ||
+      paths.has(path)
+    ) {
+      return undefined;
+    }
+    if (
+      totalCompressedBytes > context.limits.maxSourceBytes - compressedBytes ||
+      totalUncompressedBytes >
+        context.limits.maxArchiveUncompressedBytes - uncompressedBytes ||
+      (uncompressedBytes > 0 &&
+        uncompressedBytes / Math.max(compressedBytes, 1) >
+          context.limits.maxArchiveCompressionRatio)
+    ) {
+      return undefined;
+    }
+    paths.add(path);
+    totalCompressedBytes += compressedBytes;
+    totalUncompressedBytes += uncompressedBytes;
+    entries.push(Object.freeze({
+      bytes: bytes as ArrayBuffer,
+      compressedBytes,
+      contentDigest,
+      mimeType,
+      path,
+      uncompressedBytes,
+    }));
+  }
+  if (
+    totalUncompressedBytes > 0 &&
+    totalUncompressedBytes / Math.max(totalCompressedBytes, 1) >
+      context.limits.maxArchiveCompressionRatio
+  ) {
+    return undefined;
+  }
+  return Object.freeze({
+    archiveDigest,
+    entries: Object.freeze(entries),
+    operation: "extract-model-package",
+    receiptDigest,
+  });
+}
+
+function readResult(
+  value: unknown,
+  context: ToolcraftModelWorkerValidationContext,
+): ToolcraftModelWorkerResult | undefined {
+  if (!isRecord(value)) return undefined;
+  const operation = ownValue(value, "operation");
+  const decode = operation === "decode-and-analyze";
+  const allowed = decode
+    ? ["analysis", "appearanceResources", "canonicalDocument",
+        "canonicalDocumentDigest", "operation", "receiptDigest",
+        "repairPlanEnvelope"]
+    : ["analysis", "canonicalDocument", "canonicalDocumentDigest", "operation",
+        "receiptDigest", "repairPlanDigest"];
+  if (!hasOnlyKeys(value, allowed) || operation !== context.expectedOperation) {
+    return undefined;
+  }
+  const canonicalDocument = ownValue(value, "canonicalDocument");
+  const canonicalDocumentDigest = ownValue(value, "canonicalDocumentDigest");
+  const receiptDigest = ownValue(value, "receiptDigest");
+  const analysis = readAnalysis(ownValue(value, "analysis"), context);
+  if (!arrayBuffer(canonicalDocument, context.limits.maxDecodedBytes) ||
+      !digest(canonicalDocumentDigest) || !digest(receiptDigest) || !analysis) {
+    return undefined;
+  }
+  if (decode) {
+    const appearanceResources = readAppearanceResources(
+      ownValue(value, "appearanceResources"),
+      context.limits,
+    );
+    if (!appearanceResources) return undefined;
+    const rawEnvelope = ownValue(value, "repairPlanEnvelope");
+    const envelope = rawEnvelope === INVALID
+      ? undefined
+      : readEnvelope(rawEnvelope, context.limits);
+    if ((rawEnvelope !== INVALID && !envelope) ||
+        !hasConsistentOutcomeEvidence(
+          analysis,
+          envelope !== undefined,
+          "decode-and-analyze",
+        )) {
+      return undefined;
+    }
+    return Object.freeze({
+      analysis,
+      appearanceResources,
+      canonicalDocument,
+      canonicalDocumentDigest,
+      operation: "decode-and-analyze",
+      ...(envelope === undefined ? {} : { repairPlanEnvelope: envelope }),
+      receiptDigest,
+    });
+  }
+  const repairPlanDigest = ownValue(value, "repairPlanDigest");
+  const expectedEnvelope = context.expectedRepairPlanEnvelope;
+  if (!digest(repairPlanDigest) || !expectedEnvelope ||
+      repairPlanDigest !== expectedEnvelope.planDigest ||
+      !hasConsistentOutcomeEvidence(analysis, false, "repair")) {
+    return undefined;
+  }
+  return Object.freeze({
+    analysis,
+    canonicalDocument,
+    canonicalDocumentDigest,
+    operation: "repair",
+    receiptDigest,
+    repairPlanDigest,
+  });
+}
+
+function readDraft(
+  value: unknown,
+  context: ToolcraftModelWorkerValidationContext,
+): ToolcraftModelWorkerDraft | undefined {
+  if (
+    context.expectedOperation !== "decode-and-analyze" ||
+    !isRecord(value) ||
+    !hasOnlyKeys(value, [
+      "appearanceResources",
+      "canonicalDocument",
+      "canonicalDocumentDigest",
+      "receiptDigest",
+    ])
+  ) {
+    return undefined;
+  }
+  const canonicalDocument = ownValue(value, "canonicalDocument");
+  const canonicalDocumentDigest = ownValue(value, "canonicalDocumentDigest");
+  const receiptDigest = ownValue(value, "receiptDigest");
+  const appearanceResources = readAppearanceResources(
+    ownValue(value, "appearanceResources"),
+    context.limits,
+  );
+  if (
+    !arrayBuffer(canonicalDocument, context.limits.maxDecodedBytes) ||
+    !digest(canonicalDocumentDigest) ||
+    !digest(receiptDigest) ||
+    !appearanceResources
+  ) {
+    return undefined;
+  }
+  return Object.freeze({
+    appearanceResources,
+    canonicalDocument,
+    canonicalDocumentDigest,
+    receiptDigest,
+  });
+}
+
+export function readToolcraftModelWorkerMessageIdentity(
+  value: unknown,
+): ToolcraftModelWorkerMessageIdentity | undefined {
+  try {
+    if (!isRecord(value)) return undefined;
+    const generation = ownValue(value, "generation");
+    const jobId = ownValue(value, "jobId");
+    if (!Number.isSafeInteger(generation) || (generation as number) <= 0 ||
+        !boundedString(jobId, MAX_JOB_ID_LENGTH)) return undefined;
+    return Object.freeze({ generation: generation as number, jobId });
+  } catch {
+    return undefined;
+  }
+}
+
+export function validateToolcraftModelWorkerResponse(
+  value: unknown,
+  context: ToolcraftModelWorkerValidationContext,
+): ToolcraftModelWorkerResponse | undefined {
+  try {
+    const identity = readToolcraftModelWorkerMessageIdentity(value);
+    if (!identity || !isRecord(value)) return undefined;
+    const kind = ownValue(value, "kind");
+    if (kind === "cancelled" &&
+        hasOnlyKeys(value, ["generation", "jobId", "kind"])) {
+      return Object.freeze({ ...identity, kind });
+    }
+    if (kind === "error" &&
+        hasOnlyKeys(value, ["feedback", "generation", "jobId", "kind"])) {
+      const feedback = readFeedback(ownValue(value, "feedback"));
+      return feedback ? Object.freeze({ ...identity, feedback, kind }) : undefined;
+    }
+    if (kind === "draft" &&
+        hasOnlyKeys(value, ["draft", "generation", "jobId", "kind"])) {
+      const draft = readDraft(ownValue(value, "draft"), context);
+      return draft ? Object.freeze({ ...identity, draft, kind }) : undefined;
+    }
+    if (kind === "diagnostic" &&
+        hasOnlyKeys(value, ["diagnostic", "generation", "jobId", "kind"])) {
+      const diagnostic = readDiagnostic(ownValue(value, "diagnostic"));
+      return diagnostic ? Object.freeze({ ...identity, diagnostic, kind }) : undefined;
+    }
+    if (kind === "progress" && hasOnlyKeys(
+      value,
+      ["generation", "jobId", "kind", "phase", "progress"],
+    )) {
+      const phase = ownValue(value, "phase");
+      const progress = ownValue(value, "progress");
+      return (phase === "analyzing" || phase === "decoding" ||
+        phase === "extracting" || phase === "repairing") &&
+        typeof progress === "number" && Number.isFinite(progress) &&
+        progress >= 0 && progress < 1
+        ? Object.freeze({ ...identity, kind, phase, progress })
+        : undefined;
+    }
+    if (kind === "result" &&
+        hasOnlyKeys(value, ["generation", "jobId", "kind", "result"])) {
+      const result = readResult(ownValue(value, "result"), context);
+      return result ? Object.freeze({ ...identity, kind, result }) : undefined;
+    }
+    if (kind === "package-result" &&
+        hasOnlyKeys(value, ["generation", "jobId", "kind", "result"])) {
+      const result = readPackageResult(ownValue(value, "result"), context);
+      return result ? Object.freeze({ ...identity, kind, result }) : undefined;
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export type ToolcraftModelWorkerResponseLifecycle = Readonly<{
+  accept: (response: ToolcraftModelWorkerResponse) => boolean;
+}>;
+
+export function createToolcraftModelWorkerResponseLifecycle(
+  operation: ToolcraftModelWorkerExpectedOperation,
+): ToolcraftModelWorkerResponseLifecycle {
+  const progress = new Map<string, number>();
+  let diagnosticCount = 0;
+  let draftAccepted = false;
+  let phaseRank = -1;
+  let terminalAccepted = false;
+  return Object.freeze({
+    accept: (response) => {
+      if (terminalAccepted) return false;
+      if (response.kind === "error" || response.kind === "cancelled") {
+        terminalAccepted = true;
+        return true;
+      }
+      const finalRank = operation === "decode-and-analyze" ? 1 : 0;
+      if (response.kind === "progress") {
+        const rank = operation === "decode-and-analyze"
+          ? response.phase === "decoding" ? 0 : response.phase === "analyzing" ? 1 : -1
+          : operation === "extract-model-package"
+            ? response.phase === "extracting" ? 0 : -1
+          : response.phase === "repairing" ? 0 : -1;
+        const previous = progress.get(response.phase) ?? -1;
+        if (rank < 0 || rank < phaseRank || rank > phaseRank + 1 ||
+            (operation === "decode-and-analyze" && rank === 1 && !draftAccepted) ||
+            response.progress <= previous) return false;
+        phaseRank = Math.max(phaseRank, rank);
+        progress.set(response.phase, response.progress);
+        return true;
+      }
+      if (response.kind === "draft") {
+        if (operation !== "decode-and-analyze" || draftAccepted || phaseRank !== 0) {
+          return false;
+        }
+        draftAccepted = true;
+        return true;
+      }
+      if (response.kind === "diagnostic") {
+        diagnosticCount += 1;
+        return operation !== "extract-model-package" && phaseRank === finalRank &&
+          diagnosticCount <= TOOLCRAFT_MODEL_WORKER_MAX_DIAGNOSTICS;
+      }
+      const accepted = phaseRank === finalRank &&
+        (operation !== "decode-and-analyze" || draftAccepted) &&
+        (operation === "extract-model-package"
+          ? response.kind === "package-result" &&
+            response.result.operation === operation
+          : response.kind === "result" && response.result.operation === operation);
+      if (accepted) terminalAccepted = true;
+      return accepted;
+    },
+  });
+}