refactor(javascript): parse runtime evidence into one verified owner

src/domain/javascript/javascriptRuntimeReconciliationInputValidation.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import type { Evidence } from "../evidence.js";
+
+/** Prefix caller paths on a nested Zod validation boundary. */
+export const parseAtPath = <Value>(
+  parse: (input: unknown) => Value,
+  input: unknown,
+  path: readonly (string | number)[],
+): Value => {
+  try {
+    return parse(input);
+  } catch (cause: unknown) {
+    if (cause instanceof z.ZodError)
+      throw new z.ZodError(
+        cause.issues.map((issue) => ({
+          ...issue,
+          path: [...path, ...issue.path],
+        })),
+      );
+    throw cause;
+  }
+};
+
+/** Represent one semantic caller constraint as a standard validation issue. */
+export const invalidInput = (
+  path: readonly (string | number)[],
+  message: string,
+): z.ZodError => new z.ZodError([{ code: "custom", path: [...path], message }]);
+
+/** Verify an authenticated Evidence record against one runtime workflow. */
+export const assertEvidenceIdentity = (
+  evidence: Evidence,
+  expected: {
+    readonly operation: string;
+    readonly predicate: string;
+    readonly providerId: string;
+    readonly providerName: string;
+    readonly providerVersion: string;
+    readonly authority: Evidence["authority"];
+    readonly confidence: Evidence["confidence"];
+  },
+  path: readonly (string | number)[],
+): void => {
+  if (
+    evidence.operation !== expected.operation ||
+    evidence.predicate_type !== expected.predicate ||
+    evidence.provider.id !== expected.providerId ||
+    evidence.provider.name !== expected.providerName ||
+    evidence.provider.version !== expected.providerVersion ||
+    evidence.authority !== expected.authority ||
+    evidence.confidence !== expected.confidence
+  )
+    throw invalidInput(
+      path,
+      `Evidence does not match the supported ${expected.operation} contract`,
+    );
+};