@zaip-ai/cli 6.3.0 → 7.5.0

package/templates/.agents/skills/zaip-skill-lead-measurement/scripts/consent.mjs

@@ -0,0 +1,222 @@
+// Pure synchronous model. Injected callbacks are synthetic; no SDK, network or DB.
+export const PURPOSES = Object.freeze([
+  "contact",
+  "terms",
+  "analytics",
+  "google_ads",
+  "meta_measurement",
+]);
+export const DESTINATIONS = Object.freeze({
+  contact_service: Object.freeze({ purpose: "contact", phases: Object.freeze(["event", "retry"]) }),
+  terms_record: Object.freeze({ purpose: "terms", phases: Object.freeze(["event"]) }),
+  ga4: Object.freeze({
+    purpose: "analytics",
+    phases: Object.freeze(["loader", "base", "page_view", "event", "retry"]),
+  }),
+  google_ads: Object.freeze({
+    purpose: "google_ads",
+    phases: Object.freeze(["loader", "base", "page_view", "event", "retry"]),
+  }),
+  meta_pixel: Object.freeze({
+    purpose: "meta_measurement",
+    phases: Object.freeze(["loader", "base", "page_view", "event", "retry"]),
+  }),
+  meta_capi: Object.freeze({
+    purpose: "meta_measurement",
+    phases: Object.freeze(["event", "retry"]),
+  }),
+});
+const EVENTS = new Set(["lead_accepted", "lead_profile_completed", "lead_qualified"]);
+const token = /^[a-z][a-z0-9_]{0,31}$/;
+const uuid = /^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/;
+const own = (object, key) => Object.hasOwn(object, key);
+function record(value) {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    [Object.prototype, null].includes(Object.getPrototypeOf(value))
+  );
+}
+function dataKeys(value) {
+  if (!record(value)) throw new TypeError("invalid_contract");
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const keys = Reflect.ownKeys(value);
+  if (
+    keys.some(
+      (key) =>
+        typeof key !== "string" ||
+        !own(descriptors[key], "value") ||
+        descriptors[key].enumerable !== true,
+    )
+  ) {
+    throw new TypeError("invalid_contract");
+  }
+  return keys;
+}
+function exact(value, allowed, required = allowed) {
+  if (
+    dataKeys(value).some((key) => !allowed.includes(key)) ||
+    required.some((key) => !own(value, key))
+  )
+    throw new TypeError("invalid_contract");
+}
+function frozen(value) {
+  for (const item of Object.values(value)) if (item && typeof item === "object") frozen(item);
+  return Object.freeze(value);
+}
+
+// Input must already have authenticated provenance in a future application.
+// Sequence is server-owned, monotonic and independent of browser timestamps.
+export function resolveConsent(history) {
+  if (!Array.isArray(history) || history.length > 1000) throw new TypeError("invalid_history");
+  const states = Object.fromEntries(PURPOSES.map((purpose) => [purpose, "unknown"]));
+  const retained = [];
+  let revision = 0;
+  for (const item of history) {
+    exact(item, ["purpose", "state", "sequence"]);
+    if (
+      !PURPOSES.includes(item.purpose) ||
+      !["unknown", "denied", "granted", "revoked"].includes(item.state) ||
+      !Number.isSafeInteger(item.sequence) ||
+      item.sequence <= revision
+    ) {
+      throw new TypeError("invalid_history");
+    }
+    revision = item.sequence;
+    states[item.purpose] = item.state === "revoked" ? "denied" : item.state;
+    retained.push({ purpose: item.purpose, state: item.state, sequence: item.sequence });
+  }
+  return frozen({ states, revision, history: retained });
+}
+
+function preparePolicy(policy) {
+  exact(policy, ["owner", "routes", "catalog"]);
+  if (policy.owner !== "server") throw new TypeError("server_policy_required");
+  exact(policy.catalog, ["service", "budget_band", "qualification"]);
+  for (const values of Object.values(policy.catalog)) {
+    if (
+      !Array.isArray(values) ||
+      !values.length ||
+      values.length > 30 ||
+      values.some((value) => typeof value !== "string" || !token.test(value)) ||
+      new Set(values).size !== values.length
+    )
+      throw new TypeError("invalid_catalog");
+  }
+  if (!dataKeys(policy.routes).length) throw new TypeError("invalid_routes");
+  const routes = {};
+  for (const [destination, route] of Object.entries(policy.routes)) {
+    if (!own(DESTINATIONS, destination)) throw new TypeError("unknown_destination");
+    if (typeof route !== "string") throw new TypeError("invalid_route");
+    let parsed;
+    try {
+      parsed = new URL(route);
+    } catch {
+      throw new TypeError("invalid_route");
+    }
+    if (
+      parsed.protocol !== "https:" ||
+      parsed.username ||
+      parsed.password ||
+      parsed.search ||
+      parsed.hash ||
+      parsed.pathname !== "/lead" ||
+      parsed.href !== route
+    )
+      throw new TypeError("invalid_route");
+    routes[destination] = route;
+  }
+  // Clone so caller mutation cannot change policy after review.
+  return frozen({ routes, catalog: structuredClone(policy.catalog) });
+}
+
+function project(payload, url, destination, policy) {
+  exact(payload, ["event_id", "event_name", "classification"]); // MUT_PAYLOAD_KEYS
+  if (
+    typeof payload.event_id !== "string" ||
+    !uuid.test(payload.event_id) ||
+    !EVENTS.has(payload.event_name)
+  )
+    throw new TypeError("invalid_event");
+  exact(payload.classification, ["service", "budget_band", "qualification"]);
+  for (const [key, value] of Object.entries(payload.classification)) {
+    if (!policy.catalog[key].includes(value)) throw new TypeError("invalid_classification");
+  }
+  if (typeof url !== "string" || url !== policy.routes[destination])
+    throw new TypeError("unsafe_url"); // MUT_URL
+  const data = frozen({
+    event_id: payload.event_id,
+    event_name: payload.event_name,
+    classification: { ...payload.classification }, // MUT_PROJECTION
+  });
+  return { data, url };
+}
+
+export function createConsentGate(options) {
+  exact(options, ["readCurrent", "policy"]);
+  const { readCurrent, policy } = options;
+  if (typeof readCurrent !== "function") throw new TypeError("current_reader_required");
+  const approved = preparePolicy(policy);
+  const loaded = new Set();
+  let lastRevision = -1,
+    lastHistory = null;
+  return function attempt(request, effects) {
+    exact(
+      request,
+      ["destination", "phase", "payload", "url", "cookieless"],
+      ["destination", "phase", "payload", "url"],
+    );
+    const { destination, phase, payload, url, cookieless = false } = request;
+    if (
+      typeof cookieless !== "boolean" ||
+      !own(DESTINATIONS, destination) ||
+      !own(approved.routes, destination) ||
+      !DESTINATIONS[destination].phases.includes(phase)
+    ) {
+      throw new TypeError("invalid_destination_or_phase");
+    }
+    exact(effects, ["load", "emit", "log"]);
+    if (Object.values(effects).some((effect) => typeof effect !== "function"))
+      throw new TypeError("invalid_effects");
+    const projection = project(payload, url, destination, approved);
+    if (cookieless) return { allowed: false, reason: "separate_cookieless_contract_required" }; // MUT_COOKIELESS
+    let current;
+    try {
+      const history = readCurrent(); // MUT_CURRENT
+      current = resolveConsent(history);
+      const signature = JSON.stringify(current.history);
+      if (
+        current.revision < lastRevision ||
+        (current.revision === lastRevision && signature !== lastHistory)
+      )
+        throw new TypeError("stale_history");
+      lastRevision = current.revision;
+      lastHistory = signature;
+    } catch {
+      return { allowed: false, reason: "current_state_unavailable" };
+    }
+    const required = DESTINATIONS[destination].purpose; // MUT_PURPOSE
+    const state = current.states[required];
+    if (state !== "granted") return { allowed: false, reason: "consent_ineligible" }; // MUT_GATE
+    // Always read current state before even the already-loaded path.
+    if (phase === "loader" && loaded.has(destination))
+      return { allowed: true, status: "already_loaded" };
+    const envelope = frozen({ destination, phase, url: projection.url, data: projection.data });
+    if (phase === "loader") {
+      effects.load(envelope);
+      loaded.add(destination);
+    } else {
+      effects.emit(envelope);
+    }
+    effects.log(
+      frozen({
+        destination,
+        phase,
+        event_id: payload.event_id,
+        revision: current.revision,
+        status: "allowed",
+      }),
+    ); // MUT_LOG
+    return { allowed: true, status: "modeled", revision: current.revision };
+  };
+}

package/templates/.agents/skills/zaip-skill-lead-measurement/scripts/consent.test.mjs

@@ -0,0 +1,294 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { access, lstat, mkdtemp, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import * as implementation from "./consent.mjs";
+import { registerCore } from "./consent-cases-core.mjs";
+import { registerPrivacy } from "./consent-cases-privacy.mjs";
+import { rollback, rollbackFixture } from "./consent-rollback-support.mjs";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const sourcePath = join(here, "consent.mjs");
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+export function runSuite(api) {
+  const results = [];
+  function test(id, body) {
+    try {
+      body();
+      results.push({ id, passed: true });
+    } catch (error) {
+      results.push({ id, passed: false, assertion: error instanceof assert.AssertionError });
+    }
+  }
+  registerCore(api, test);
+  registerPrivacy(api, test);
+  test("ROLLBACK-reject-same-commit-before-fixture", () => {
+    const commit = "a".repeat(40);
+    let effects = 0;
+    const commands = [];
+    assert.throws(
+      () =>
+        rollbackFixture(
+          commit,
+          commit,
+          (args) => {
+            commands.push(args);
+            return { status: 0 };
+          },
+          () => {
+            effects++;
+          },
+        ),
+      /rollback_base_must_differ/,
+    );
+    assert.deepEqual(commands, [["cat-file", "-e", `${commit}^{commit}`]]);
+    assert.equal(effects, 0);
+  });
+  test("ROLLBACK-reject-unrelated-or-unverified-base-before-fixture", () => {
+    const base = "a".repeat(40),
+      candidate = "b".repeat(40);
+    for (const result of [
+      { status: 1 },
+      { status: 128 },
+      { status: null, error: new Error("synthetic_git_error") },
+    ]) {
+      let effects = 0;
+      const commands = [];
+      assert.throws(
+        () =>
+          rollbackFixture(
+            base,
+            candidate,
+            (args) => {
+              commands.push(args);
+              return args[0] === "cat-file" ? { status: 0 } : result;
+            },
+            () => {
+              effects++;
+            },
+          ),
+        result.status === 1 ? /rollback_base_not_ancestor/ : /rollback_ancestry_unverified/,
+      );
+      assert.deepEqual(commands, [
+        ["cat-file", "-e", `${base}^{commit}`],
+        ["merge-base", "--is-ancestor", base, candidate],
+      ]);
+      assert.equal(effects, 0);
+    }
+  });
+  return {
+    kind: "consent_tests",
+    passed: results.every((result) => result.passed),
+    total_tests: results.length,
+    results,
+  };
+}
+
+function probe(directory) {
+  const run = spawnSync(process.execPath, [join(directory, "consent.test.mjs"), "--probe"], {
+    cwd: directory,
+    encoding: "utf8",
+    windowsHide: true,
+    timeout: 30_000,
+  });
+  if (run.error || run.signal) throw new Error("probe_infrastructure_failure");
+  let report;
+  try {
+    report = JSON.parse(run.stdout.trim());
+  } catch {
+    throw new Error("probe_protocol_failure");
+  }
+  if (report.kind !== "consent_tests" || !Array.isArray(report.results))
+    throw new Error("invalid_probe");
+  return { ...report, exit_code: run.status };
+}
+async function ownedTemp() {
+  const parent = await realpath(tmpdir());
+  const path = await mkdtemp(join(parent, "zaip-consent-"));
+  return { path, parent };
+}
+async function cleanup(owned) {
+  assert.equal(dirname(owned.path), owned.parent);
+  assert.ok(basename(owned.path).startsWith("zaip-consent-"));
+  assert.equal((await lstat(owned.path)).isSymbolicLink(), false);
+  assert.equal(await realpath(owned.path), owned.path);
+  await rm(owned.path, { recursive: true });
+  await assert.rejects(access(owned.path), { code: "ENOENT" });
+}
+const mutants = [
+  {
+    id: "PURPOSE",
+    cases: ["C041-purpose-independence"],
+    edits: [
+      [
+        "const required = DESTINATIONS[destination].purpose;",
+        'const required = destination.startsWith("meta_") ? "terms" : DESTINATIONS[destination].purpose;',
+      ],
+    ],
+  },
+  {
+    id: "PRELOAD",
+    cases: ["C042-all-pre-effect-denials"],
+    edits: [
+      [
+        'if (state !== "granted") return',
+        'if (state !== "granted" && !["loader", "base", "page_view"].includes(phase)) return',
+      ],
+    ],
+  },
+  {
+    id: "STALE-RETRY",
+    cases: ["C042-enqueue-retry-regrant-current"],
+    edits: [
+      [
+        "return function attempt(request, effects) {",
+        "let stale; try { stale = readCurrent(); } catch { stale = []; }\n  return function attempt(request, effects) {",
+      ],
+      [
+        "const history = readCurrent();",
+        'const history = phase === "retry" ? stale : readCurrent();',
+      ],
+    ],
+  },
+  {
+    id: "COOKIELESS",
+    cases: ["C043-no-cookieless-fallback"],
+    edits: [
+      [
+        'if (cookieless) return { allowed: false, reason: "separate_cookieless_contract_required" };',
+        'if (false) return { allowed: false, reason: "separate_cookieless_contract_required" };',
+      ],
+      [
+        "const state = current.states[required];",
+        'const state = cookieless ? "granted" : current.states[required];',
+      ],
+    ],
+  },
+  {
+    id: "PAYLOAD-PII",
+    cases: ["C044-reject-PII-and-free-text"],
+    edits: [
+      [
+        'exact(payload, ["event_id", "event_name", "classification"]);',
+        "/* mutant permits extra public payload keys */",
+      ],
+      [
+        "classification: { ...payload.classification }, // MUT_PROJECTION",
+        "classification: { ...payload.classification }, ...payload, // MUT_PROJECTION",
+      ],
+    ],
+  },
+  {
+    id: "URL-PII",
+    cases: ["C044-reject-URL-data-channels"],
+    edits: [
+      [
+        'if (typeof url !== "string" || url !== policy.routes[destination]) throw new TypeError("unsafe_url");',
+        "/* mutant passes caller URL through */",
+      ],
+    ],
+  },
+  {
+    id: "LOG-ALLOWLIST",
+    cases: ["C044-positive-effect-contract"],
+    edits: [
+      [
+        'effects.log(frozen({ destination, phase, event_id: payload.event_id,\n      revision: current.revision, status: "allowed" }));',
+        "effects.log(frozen({ ...payload, url }));",
+      ],
+    ],
+  },
+];
+
+async function mutation(externalDigest) {
+  if (externalDigest !== undefined && !/^[a-f0-9]{64}$/.test(externalDigest))
+    throw new Error("invalid_baseline_digest");
+  const original = await readFile(sourcePath);
+  const originalHash = hash(original);
+  const owned = await ownedTemp();
+  let result;
+  try {
+    await writeFile(join(owned.path, "consent.mjs"), original);
+    await writeFile(
+      join(owned.path, "consent.test.mjs"),
+      await readFile(fileURLToPath(import.meta.url)),
+    );
+    for (const helper of [
+      "consent-fixtures.mjs",
+      "consent-cases-core.mjs",
+      "consent-cases-privacy.mjs",
+      "consent-rollback-support.mjs",
+    ])
+      await writeFile(join(owned.path, helper), await readFile(join(here, helper)));
+    const baseline = probe(owned.path);
+    assert.equal(baseline.passed, true, "actual baseline must pass");
+    assert.equal(baseline.exit_code, 0);
+    const reports = [];
+    for (const mutant of mutants) {
+      let changed = original.toString("utf8").replace(/\r\n/g, "\n");
+      for (const [before, after] of mutant.edits) {
+        assert.equal(changed.split(before).length, 2, `one mutation target: ${mutant.id}`);
+        changed = changed.replace(before, after);
+      }
+      await writeFile(join(owned.path, "consent.mjs"), changed);
+      const observed = probe(owned.path);
+      const failures = observed.results.filter((item) => !item.passed);
+      const killed =
+        observed.exit_code !== 0 &&
+        !observed.passed &&
+        failures.length > 0 &&
+        failures.every((item) => item.assertion === true) &&
+        failures.some((item) => mutant.cases.includes(item.id));
+      reports.push({
+        id: mutant.id,
+        killed,
+        source_sha256: hash(changed),
+        assertions: failures.map((item) => item.id),
+        infrastructure_failure: failures.some((item) => !item.assertion),
+      });
+      await writeFile(join(owned.path, "consent.mjs"), original);
+      assert.equal(hash(await readFile(join(owned.path, "consent.mjs"))), originalHash);
+    }
+    const restored = probe(owned.path);
+    assert.equal(restored.passed, true);
+    assert.equal(hash(await readFile(sourcePath)), originalHash);
+    result = {
+      kind: "mutation_discrimination",
+      baseline: { passed: baseline.passed, total_tests: baseline.total_tests },
+      baseline_ref_sha256: externalDigest ?? hash(JSON.stringify(baseline)),
+      source_sha256: originalHash,
+      total_mutants: reports.length,
+      killed_mutants: reports.filter((item) => item.killed).length,
+      mutants: reports,
+      restored: { passed: restored.passed, source_sha256: originalHash },
+      passed: reports.every((item) => item.killed) && restored.passed,
+    };
+  } finally {
+    await cleanup(owned);
+  }
+  return { ...result, temporary_removed: true };
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  try {
+    const mode = process.argv[2];
+    let result;
+    if (mode === "--mutation") result = await mutation(process.argv[3]);
+    else if (mode === "--rollback")
+      result = await rollback(process.argv[3], { here, hash, ownedTemp, cleanup });
+    else {
+      assert.ok(mode === undefined || mode === "--probe", "unknown CLI mode");
+      result = runSuite(implementation);
+    }
+    process.stdout.write(JSON.stringify(result) + "\n");
+    if (!result.passed) process.exitCode = 1;
+  } catch {
+    process.stdout.write(
+      JSON.stringify({ kind: "consent_infrastructure_failure", passed: false }) + "\n",
+    );
+    process.exitCode = 1;
+  }
+}

package/templates/.agents/skills/zaip-skill-lead-measurement/scripts/delivery-ledger.mjs

@@ -0,0 +1,179 @@
+// LEGACY DEPRECATED v1: 2xx->sent is historical behavior, never delivery proof.
+// Opt in to delivery-v2.mjs for semantic acceptance and scoped identity.
+import {
+  fingerprint,
+  freeze,
+  projectMeasurement,
+  reject,
+  strictObject,
+  validateConfig,
+  validateRetryPolicy,
+  validTimestamp,
+} from "./lead-measurement.mjs";
+
+const destinations = ["ga4", "google_ads", "meta_pixel", "meta_capi"];
+function validateJob(job) {
+  strictObject(job, [
+    "destination",
+    "event_id",
+    "event_name",
+    "occurred_at",
+    "mapping_version",
+    "catalog_version",
+    "payload",
+    "fingerprint",
+    "policy",
+    "state",
+    "attempts",
+    "next_attempt_at",
+    "last_category",
+    "acceptance_persisted",
+  ]);
+  strictObject(job.payload, [
+    "event_name",
+    "event_id",
+    "occurred_at",
+    "mapping_version",
+    "parameters",
+    ...(job.destination === "google_ads" ? ["source", "primary"] : []),
+  ]);
+  strictObject(job.payload.parameters, ["service", "budget_band", "qualification"]);
+  if (
+    Object.values(job.payload.parameters).some(
+      (value) => typeof value !== "string" || !/^[a-z][a-z0-9_-]{0,39}$/.test(value),
+    ) ||
+    !/^evt_[A-Za-z0-9_-]{8,96}$/.test(job.event_id) ||
+    !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(job.mapping_version) ||
+    !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(job.catalog_version) ||
+    ![null, "succeeded", "transient_failure", "retry_exhausted", "permanent_failure"].includes(
+      job.last_category,
+    ) ||
+    (job.destination === "google_ads" &&
+      (!["ga4_import", "direct"].includes(job.payload.source) || job.payload.primary !== true))
+  )
+    reject("invalid_delivery_job");
+  if (
+    !destinations.includes(job.destination) ||
+    !["pending", "retry", "sent", "review_required"].includes(job.state) ||
+    job.acceptance_persisted !== true ||
+    !Number.isSafeInteger(job.attempts) ||
+    job.attempts < 0 ||
+    fingerprint(job.payload) !== job.fingerprint ||
+    job.payload.event_id !== job.event_id ||
+    job.payload.event_name !== job.event_name ||
+    job.payload.occurred_at !== job.occurred_at ||
+    job.payload.mapping_version !== job.mapping_version ||
+    !validTimestamp(job.occurred_at) ||
+    (job.next_attempt_at !== null && !validTimestamp(job.next_attempt_at))
+  )
+    reject("invalid_delivery_job");
+  validateRetryPolicy(job.policy);
+  if (
+    job.attempts > job.policy.max_attempts ||
+    (job.state === "pending" && (job.attempts !== 0 || job.next_attempt_at !== null)) ||
+    (job.state === "retry" &&
+      (job.attempts < 1 ||
+        job.attempts >= job.policy.max_attempts ||
+        job.next_attempt_at === null)) ||
+    (["sent", "review_required"].includes(job.state) &&
+      (job.attempts < 1 || job.next_attempt_at !== null))
+  )
+    reject("invalid_delivery_state");
+  return job;
+}
+
+/** A pure Map model, not a database transaction or delivery adapter. */
+export function queueMeasurement(ledger, event, suppliedConfig, destination) {
+  if (!(ledger instanceof Map) || !destinations.includes(destination))
+    reject("invalid_delivery_destination");
+  const config = validateConfig(suppliedConfig),
+    payload = projectMeasurement(event, config)[destination];
+  if (payload === null) return { ledger: new Map(ledger), status: "suppressed", job: null };
+  const key = `${destination}:${payload.event_id}`,
+    digest = fingerprint(payload);
+  if (ledger.has(key)) {
+    const existing = validateJob(ledger.get(key));
+    if (existing.destination !== destination || existing.event_id !== payload.event_id)
+      reject("delivery_key_identity_conflict");
+    if (
+      existing.fingerprint !== digest ||
+      existing.catalog_version !== config.catalog_version ||
+      fingerprint(existing.policy) !== fingerprint(config.retry)
+    )
+      reject("delivery_identity_payload_conflict");
+    return { ledger: new Map(ledger), status: "replay", job: freeze(structuredClone(existing)) };
+  }
+  const job = freeze({
+    destination,
+    event_id: payload.event_id,
+    event_name: payload.event_name,
+    occurred_at: payload.occurred_at,
+    mapping_version: payload.mapping_version,
+    catalog_version: config.catalog_version,
+    payload,
+    fingerprint: digest,
+    policy: { ...config.retry },
+    state: "pending",
+    attempts: 0,
+    next_attempt_at: null,
+    last_category: null,
+    acceptance_persisted: true,
+  });
+  const next = new Map(ledger);
+  next.set(key, job);
+  return { ledger: next, status: "queued", job };
+}
+
+export function recordDeliveryAttempt(input, outcome, at) {
+  const job = validateJob(input);
+  strictObject(outcome, ["status", "error", "retry_after_ms"], []);
+  if (!validTimestamp(at)) reject("invalid_attempt_timestamp");
+  const status = outcome.status ?? null,
+    error = outcome.error ?? null,
+    retryAfter = outcome.retry_after_ms ?? 0;
+  if (
+    (status !== null && (!Number.isInteger(status) || status < 100 || status > 599)) ||
+    ![null, "timeout", "network"].includes(error) ||
+    (status === null && error === null) ||
+    !Number.isSafeInteger(retryAfter) ||
+    retryAfter < 0 ||
+    retryAfter > 86_400_000 ||
+    (status !== null && status >= 200 && status < 300 && error !== null)
+  )
+    reject("invalid_delivery_outcome");
+  if (["sent", "review_required"].includes(job.state)) return freeze(structuredClone(job));
+  if (job.next_attempt_at !== null && Date.parse(at) < Date.parse(job.next_attempt_at))
+    reject("retry_not_due");
+  const attempts = job.attempts + 1;
+  if (status !== null && status >= 200 && status < 300)
+    return freeze({
+      ...job,
+      state: "sent",
+      attempts,
+      next_attempt_at: null,
+      last_category: "succeeded",
+    });
+  const transient =
+    error === "timeout" ||
+    error === "network" ||
+    status === 408 ||
+    status === 429 ||
+    (status !== null && status >= 500);
+  if (!transient || attempts >= job.policy.max_attempts)
+    return freeze({
+      ...job,
+      state: "review_required",
+      attempts,
+      next_attempt_at: null,
+      last_category: transient ? "retry_exhausted" : "permanent_failure",
+    });
+  const backoff = Math.min(job.policy.max_delay_ms, job.policy.base_delay_ms * 2 ** (attempts - 1));
+  const nextAttempt = new Date(Date.parse(at) + Math.max(backoff, retryAfter)).toISOString();
+  return freeze({
+    ...job,
+    state: "retry",
+    attempts,
+    next_attempt_at: nextAttempt,
+    last_category: "transient_failure",
+  });
+}