@graphrefly/ts 0.0.0 → 0.0.2

package/dist/orchestration/work-queue.cjs

@@ -0,0 +1,1500 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/orchestration/work-queue.ts
+var work_queue_exports = {};
+__export(work_queue_exports, {
+  orchestrationWorkQueueRecipe: () => orchestrationWorkQueueRecipe,
+  processEffectSubmitCommand: () => processEffectSubmitCommand,
+  workQueueLeaseExpirationCommandProjector: () => workQueueLeaseExpirationCommandProjector,
+  workQueueReadinessHandoffProjector: () => workQueueReadinessHandoffProjector,
+  workQueueScheduledReadinessProjector: () => workQueueScheduledReadinessProjector
+});
+module.exports = __toCommonJS(work_queue_exports);
+
+// src/protocol/messages.ts
+var SENTINEL = void 0;
+
+// src/ctx/types.ts
+function depWaves(ctx, depIndex) {
+  return ctx.waveData[depIndex] ?? [];
+}
+function depBatch(ctx, depIndex) {
+  const waves = depWaves(ctx, depIndex);
+  if (waves.length === 0) return null;
+  const flattened = waves.flat().filter((v) => v !== SENTINEL);
+  return flattened.length === 0 ? [] : flattened;
+}
+
+// src/orchestration/agent-runtime-common.ts
+function uniqueSourceRefs(sourceRefs) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const sourceRef of sourceRefs) {
+    const key = `${sourceRef.kind}:${sourceRef.id}:${JSON.stringify(sourceRef.metadata ?? {})}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(sourceRef);
+  }
+  return Object.freeze(unique);
+}
+function stableJsonStringify(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(value, (_key, child) => {
+    if (typeof child === "bigint") return child.toString();
+    if (typeof child === "function") return "[Function]";
+    if (!isRecord(child) && !Array.isArray(child)) return child;
+    if (seen.has(child)) return "[Circular]";
+    seen.add(child);
+    if (Array.isArray(child)) return child;
+    return Object.keys(child).sort().reduce((out, key) => {
+      out[key] = child[key];
+      return out;
+    }, {});
+  });
+}
+function stableStringHash(value) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i += 1) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+function projectRuntimeFact(graph, runtime, name, factory, pick) {
+  return graph.node(
+    [runtime],
+    (ctx) => {
+      for (const fact of depBatch(ctx, 0) ?? []) {
+        const typed = fact;
+        const value = pick(typed);
+        if (value !== void 0) ctx.down([["DATA", value]]);
+      }
+    },
+    { name, factory }
+  );
+}
+function forbiddenDataKeys(value, path = [], seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "function") return [{ path, reason: "function-value" }];
+  if (typeof value === "symbol" || typeof value === "bigint") {
+    return [{ path, reason: "non-graph-visible-primitive" }];
+  }
+  if (!isRecord(value) && !Array.isArray(value)) return [];
+  if (typeof value === "object" && value !== null) {
+    if (seen.has(value)) return [];
+    seen.add(value);
+  }
+  const issues = [];
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => {
+      issues.push(...forbiddenDataKeys(item, [...path, index], seen));
+    });
+    return issues;
+  }
+  if (!isPlainRecord(value)) return [{ path, reason: "non-plain-runtime-object" }];
+  const symbolKeys = Object.getOwnPropertySymbols(value);
+  if (symbolKeys.length > 0) {
+    issues.push({ path, reason: "symbol-key" });
+  }
+  for (const [key, child] of Object.entries(value)) {
+    const nextPath = [...path, key];
+    if (/^(apiKey|api_key|secret|client|transport|subprocess|sdk|oauth|credential|credentials|accessToken|access_token|refreshToken|refresh_token|idToken|id_token|token|password|passphrase|authorization|authHeader|auth_header|bearer|privateKey|private_key|sessionCookie|session_cookie|cookie)$/i.test(
+      key
+    )) {
+      issues.push({ path: nextPath, reason: "forbidden-runtime-key" });
+    }
+    issues.push(...forbiddenDataKeys(child, nextPath, seen));
+  }
+  return issues;
+}
+function sanitizeGraphVisibleRecord(value, policy) {
+  return sanitizePublicRecord(value, { mode: "graph", policy });
+}
+function canonicalPublicSourceRefs(sourceRefs) {
+  return uniqueSourceRefs(
+    sourceRefs.map((sourceRef) => {
+      const metadata = sanitizePublicRecord(sourceRef.metadata, { mode: "provider" });
+      return metadata === void 0 ? { kind: sourceRef.kind, id: sourceRef.id } : { kind: sourceRef.kind, id: sourceRef.id, metadata };
+    })
+  );
+}
+function sanitizePublicRecord(value, opts) {
+  if (value === void 0 || publicMaterialForbiddenKeys(value, opts.mode).length > 0) {
+    return void 0;
+  }
+  return Object.freeze(boundRecordStrings(value, maxPublicMetadataStringChars(opts.policy)));
+}
+function publicMaterialForbiddenKeys(value, mode) {
+  const forbidden = [...forbiddenDataKeys(value)];
+  if (mode === "provider") forbidden.push(...forbiddenProviderRawMaterialKeys(value));
+  return forbidden;
+}
+function boundPublicText(text, limitChars) {
+  const limit = Math.max(0, limitChars);
+  if (text.length <= limit) {
+    return { text, truncated: false, originalChars: text.length, limitChars: limit };
+  }
+  const bounded = limit <= 1 ? text.slice(0, limit) : limit <= 3 ? text.slice(0, limit) : `${text.slice(0, limit - 3)}...`;
+  return { text: bounded, truncated: true, originalChars: text.length, limitChars: limit };
+}
+function boundRecordStrings(value, limitChars, seen = /* @__PURE__ */ new WeakSet()) {
+  if (seen.has(value)) return {};
+  seen.add(value);
+  return Object.entries(value).reduce((out, [key, child]) => {
+    if (typeof child === "string") {
+      out[key] = boundPublicText(child, limitChars).text;
+    } else if (Array.isArray(child)) {
+      out[key] = child.map(
+        (item) => typeof item === "string" ? boundPublicText(item, limitChars).text : isPlainRecord(item) ? boundRecordStrings(item, limitChars, seen) : item
+      );
+    } else if (isPlainRecord(child)) {
+      out[key] = boundRecordStrings(child, limitChars, seen);
+    } else {
+      out[key] = child;
+    }
+    return out;
+  }, {});
+}
+function maxPublicMetadataStringChars(policy) {
+  return normalizedPublicTextLimit(policy?.maxMetadataStringChars, 256);
+}
+function normalizedPublicTextLimit(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(0, Math.floor(value));
+}
+function forbiddenProviderRawMaterialKeys(value, path = [], seen = /* @__PURE__ */ new WeakSet()) {
+  if (!isRecord(value) && !Array.isArray(value)) return [];
+  if (typeof value === "object" && value !== null) {
+    if (seen.has(value)) return [];
+    seen.add(value);
+  }
+  const issues = [];
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => {
+      issues.push(...forbiddenProviderRawMaterialKeys(item, [...path, index], seen));
+    });
+    return issues;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    const nextPath = [...path, key];
+    if (/^(stdout|stderr|stack|stackTrace|stack_trace|providerRaw|provider_raw|rawResponse|raw_response|diff|patch|fileContents|file_contents|binary|media)$/i.test(
+      key
+    )) {
+      issues.push({ path: nextPath, reason: "raw-provider-material" });
+    }
+    issues.push(...forbiddenProviderRawMaterialKeys(child, nextPath, seen));
+  }
+  return issues;
+}
+function dataIssue(code, message, opts = {}) {
+  return {
+    kind: "issue",
+    code,
+    message,
+    severity: opts.severity ?? "error",
+    subjectId: opts.subjectId,
+    refs: opts.refs?.map((r) => `${r.kind}:${r.id}`),
+    details: opts.details
+  };
+}
+function ref(kind, id) {
+  return { kind, id };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPlainRecord(value) {
+  if (!isRecord(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+// src/orchestration/work-queue-scheduled-readiness.ts
+var MAX_PUBLIC_COORDINATE_ID_CHARS = 160;
+var MAX_COPIED_PUBLIC_REFS = 16;
+var PRIVATE_COORDINATE_PATTERN = /(api[_-]?key|authorization|bearer|credential|oauth|password|private[_-]?key|secret|session[_-]?cookie|token)/i;
+function workQueueScheduledReadinessProjector(graph, opts) {
+  const name = opts.name ?? "workQueueScheduledReadiness";
+  const runtime = graph.node(
+    [opts.records],
+    (ctx) => {
+      const state = ctx.state.get() ?? initialState();
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const translated = translateRecord(raw);
+        if (translated.kind === "none") continue;
+        if (translated.kind === "issue") {
+          emitIssue(ctx, state, translated.issue);
+          emitStatus(ctx, state, translated.status);
+          continue;
+        }
+        const identity = scheduleIdentity(translated.schedule);
+        const recordKey = `${translated.record.queueId}:${translated.record.recordSeq}`;
+        const existingRecordIdentity = state.recordScheduleIdentityByKey.get(recordKey);
+        if (existingRecordIdentity !== void 0) {
+          if (existingRecordIdentity !== identity) emitScheduleConflict(ctx, state, translated);
+          continue;
+        }
+        state.recordScheduleIdentityByKey.set(recordKey, identity);
+        const existing = state.schedulesById.get(translated.schedule.scheduleId);
+        if (existing !== void 0) {
+          if (scheduleIdentity(existing) !== identity) {
+            emitScheduleConflict(ctx, state, translated, existing);
+          }
+          continue;
+        }
+        state.schedulesById.set(translated.schedule.scheduleId, translated.schedule);
+        emitSchedule(ctx, state, translated.schedule);
+        emitStatus(ctx, state, translated.status);
+        emitAudit(ctx, state, "work-queue-scheduled-readiness-translated", {
+          subjectId: translated.schedule.scheduleId,
+          sourceRefs: translated.schedule.sourceRefs,
+          metadata: {
+            queueId: publicCoordinateId(translated.record.queueId),
+            workId: publicCoordinateId(translated.record.workId),
+            recordSeq: translated.record.recordSeq,
+            recordKind: translated.record.kind,
+            readyAtMs: translated.schedule.readyAtMs
+          }
+        });
+      }
+      ctx.down([["DATA", { kind: "views", views: buildViews(state) }]]);
+      ctx.state.set(state);
+    },
+    {
+      name: `${name}/runtime`,
+      factory: "workQueueScheduledReadinessProjector",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    readinessSchedules: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/readinessSchedules`,
+      "workQueueScheduledReadinessSchedules",
+      (fact) => fact.kind === "readiness-schedule" ? fact.schedule : void 0
+    ),
+    status: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/status`,
+      "workQueueScheduledReadinessStatus",
+      (fact) => fact.kind === "status" ? fact.status : void 0
+    ),
+    issues: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/issues`,
+      "workQueueScheduledReadinessIssues",
+      (fact) => fact.kind === "issue" ? fact.issue : void 0
+    ),
+    audit: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/audit`,
+      "workQueueScheduledReadinessAudit",
+      (fact) => fact.kind === "audit" ? fact.audit : void 0
+    ),
+    views: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/views`,
+      "workQueueScheduledReadinessViews",
+      (fact) => fact.kind === "views" ? fact.views : void 0
+    )
+  };
+}
+function workQueueReadinessHandoffProjector(graph, opts) {
+  const name = opts.name ?? "workQueueReadinessHandoff";
+  const deps = opts.overdue === void 0 ? [opts.records, opts.ready] : [opts.records, opts.ready, opts.overdue];
+  const runtime = graph.node(
+    deps,
+    (ctx) => {
+      const state = ctx.state.get() ?? handoffState();
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const record = raw;
+        ingestWorkQueueRecord(state, record);
+      }
+      for (const raw of depBatch(ctx, 1) ?? []) {
+        const ready = raw;
+        state.readyByScheduleId.set(ready.scheduleId, ready);
+      }
+      if (opts.overdue !== void 0) {
+        for (const raw of depBatch(ctx, 2) ?? []) {
+          emitOverdueHandoffStatus(ctx, state, raw);
+        }
+      }
+      evaluateReadyHandoffs(ctx, state);
+      ctx.down([["DATA", { kind: "views", views: buildHandoffViews(state) }]]);
+      ctx.state.set(state);
+    },
+    {
+      name: `${name}/runtime`,
+      factory: "workQueueReadinessHandoffProjector",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    candidates: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/candidates`,
+      "workQueueReadinessHandoffCandidates",
+      (fact) => fact.kind === "candidate" ? fact.candidate : void 0
+    ),
+    status: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/status`,
+      "workQueueReadinessHandoffStatus",
+      (fact) => fact.kind === "status" ? fact.status : void 0
+    ),
+    issues: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/issues`,
+      "workQueueReadinessHandoffIssues",
+      (fact) => fact.kind === "issue" ? fact.issue : void 0
+    ),
+    audit: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/audit`,
+      "workQueueReadinessHandoffAudit",
+      (fact) => fact.kind === "audit" ? fact.audit : void 0
+    ),
+    views: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/views`,
+      "workQueueReadinessHandoffViews",
+      (fact) => fact.kind === "views" ? fact.views : void 0
+    )
+  };
+}
+function workQueueLeaseExpirationCommandProjector(graph, opts) {
+  const name = opts.name ?? "workQueueLeaseExpirationCommands";
+  const runtime = graph.node(
+    [opts.candidates],
+    (ctx) => {
+      const state = ctx.state.get() ?? leaseExpirationCommandState();
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const candidate = raw;
+        if (candidate.candidateKind !== "lease-expiration-eligible") continue;
+        if (state.commandByCandidateId.has(candidate.candidateId)) continue;
+        const command = Object.freeze({
+          kind: "expire-leases",
+          commandId: `${candidate.candidateId}:expire-leases`,
+          queueId: candidate.queueId,
+          workIds: [candidate.workId],
+          limit: 1,
+          nowMs: candidate.nowMs,
+          causationId: candidate.scheduleId,
+          ...sourceRefStrings(candidate.sourceRefs) === void 0 ? {} : { sourceRefs: sourceRefStrings(candidate.sourceRefs) }
+        });
+        state.commandByCandidateId.set(candidate.candidateId, command);
+        ctx.down([["DATA", { kind: "command", command }]]);
+        emitLeaseCommandStatus(ctx, state, command, candidate);
+      }
+      ctx.down([["DATA", { kind: "views", views: buildLeaseCommandViews(state) }]]);
+      ctx.state.set(state);
+    },
+    {
+      name: `${name}/runtime`,
+      factory: "workQueueLeaseExpirationCommandProjector",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    commands: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/commands`,
+      "workQueueLeaseExpirationCommands",
+      (fact) => fact.kind === "command" ? fact.command : void 0
+    ),
+    status: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/status`,
+      "workQueueLeaseExpirationCommandStatus",
+      (fact) => fact.kind === "status" ? fact.status : void 0
+    ),
+    views: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/views`,
+      "workQueueLeaseExpirationCommandViews",
+      (fact) => fact.kind === "views" ? fact.views : void 0
+    )
+  };
+}
+function initialState() {
+  return {
+    recordScheduleIdentityByKey: /* @__PURE__ */ new Map(),
+    schedulesById: /* @__PURE__ */ new Map(),
+    statusById: /* @__PURE__ */ new Map(),
+    emittedKeys: /* @__PURE__ */ new Set(),
+    issueKeys: /* @__PURE__ */ new Set(),
+    auditSeq: 0
+  };
+}
+function handoffState() {
+  return {
+    originsByScheduleId: /* @__PURE__ */ new Map(),
+    worksById: /* @__PURE__ */ new Map(),
+    readyByScheduleId: /* @__PURE__ */ new Map(),
+    candidatesById: /* @__PURE__ */ new Map(),
+    statusById: /* @__PURE__ */ new Map(),
+    emittedKeys: /* @__PURE__ */ new Set(),
+    issueKeys: /* @__PURE__ */ new Set(),
+    auditSeq: 0
+  };
+}
+function leaseExpirationCommandState() {
+  return {
+    commandByCandidateId: /* @__PURE__ */ new Map(),
+    statusById: /* @__PURE__ */ new Map(),
+    emittedKeys: /* @__PURE__ */ new Set()
+  };
+}
+function ingestWorkQueueRecord(state, record) {
+  const translated = translateRecord(record);
+  if (translated.kind === "translated") {
+    state.originsByScheduleId.set(translated.schedule.scheduleId, {
+      record: translated.record,
+      schedule: translated.schedule,
+      scheduleKind: translated.status.scheduleKind
+    });
+  }
+  if (record.workId === void 0) return;
+  const recordWithWorkId = record;
+  const existing = state.worksById.get(
+    handoffWorkKey(recordWithWorkId.queueId, recordWithWorkId.workId)
+  );
+  if (existing !== void 0 && recordWithWorkId.recordSeq < existing.latestRecordSeq) return;
+  const work = ensureHandoffWorkState(state, recordWithWorkId);
+  work.latestRecordSeq = Math.max(work.latestRecordSeq, recordWithWorkId.recordSeq);
+  switch (recordWithWorkId.kind) {
+    case "work-admitted":
+      work.state = recordWithWorkId.notBeforeMs === void 0 ? "ready" : "scheduled";
+      work.notBeforeMs = recordWithWorkId.notBeforeMs;
+      work.retryAtMs = void 0;
+      work.deadlineMs = recordWithWorkId.deadlineMs;
+      clearHandoffLease(work);
+      break;
+    case "work-scheduled":
+      work.state = "scheduled";
+      work.notBeforeMs = recordWithWorkId.notBeforeMs;
+      work.deadlineMs = recordWithWorkId.deadlineMs;
+      break;
+    case "retry-scheduled":
+      work.state = recordWithWorkId.retryAtMs <= recordWithWorkId.recordedAtMs ? "ready" : "retry-wait";
+      work.retryAtMs = recordWithWorkId.retryAtMs;
+      work.notBeforeMs = void 0;
+      break;
+    case "work-claimed":
+      work.state = "leased";
+      work.leaseId = recordWithWorkId.leaseId;
+      work.attempt = recordWithWorkId.attempt;
+      work.workerId = recordWithWorkId.workerId;
+      work.leaseExpiresAtMs = recordWithWorkId.leaseExpiresAtMs;
+      break;
+    case "lease-renewed":
+      work.state = "leased";
+      work.leaseId = recordWithWorkId.leaseId;
+      work.attempt = recordWithWorkId.attempt;
+      work.workerId = recordWithWorkId.workerId;
+      work.leaseExpiresAtMs = recordWithWorkId.leaseExpiresAtMs;
+      break;
+    case "work-released":
+    case "lease-expired":
+      work.state = "ready";
+      clearHandoffLease(work);
+      break;
+    case "work-completed":
+      work.state = "completed";
+      clearHandoffLease(work);
+      break;
+    case "work-canceled":
+      work.state = "canceled";
+      clearHandoffLease(work);
+      break;
+    case "work-dead-lettered":
+      work.state = "dead-lettered";
+      clearHandoffLease(work);
+      break;
+  }
+}
+function ensureHandoffWorkState(state, record) {
+  const key = handoffWorkKey(record.queueId, record.workId);
+  const existing = state.worksById.get(key);
+  if (existing !== void 0) return existing;
+  const next = {
+    queueId: record.queueId,
+    workId: record.workId,
+    state: "ready",
+    latestRecordSeq: record.recordSeq
+  };
+  state.worksById.set(key, next);
+  return next;
+}
+function handoffWorkKey(queueId, workId) {
+  return stableJsonStringify([queueId, workId]);
+}
+function clearHandoffLease(work) {
+  work.leaseId = void 0;
+  work.attempt = void 0;
+  work.workerId = void 0;
+  work.leaseExpiresAtMs = void 0;
+}
+function evaluateReadyHandoffs(ctx, state) {
+  for (const ready of state.readyByScheduleId.values()) {
+    const origin = state.originsByScheduleId.get(ready.scheduleId);
+    if (origin === void 0) {
+      emitHandoffStatus(
+        ctx,
+        state,
+        handoffStatus("pending-origin", {
+          scheduleId: ready.scheduleId,
+          readyAtMs: ready.readyAtMs,
+          nowMs: ready.nowMs,
+          sourceRefs: ready.sourceRefs
+        })
+      );
+      continue;
+    }
+    const work = state.worksById.get(handoffWorkKey(origin.record.queueId, origin.record.workId));
+    if (work === void 0) {
+      emitHandoffStatus(
+        ctx,
+        state,
+        handoffStatus("pending-origin", {
+          queueId: origin.record.queueId,
+          workId: origin.record.workId,
+          scheduleId: ready.scheduleId,
+          readyAtMs: ready.readyAtMs,
+          nowMs: ready.nowMs,
+          sourceRefs: ready.sourceRefs
+        })
+      );
+      continue;
+    }
+    if (origin.record.recordSeq < work.latestRecordSeq) {
+      emitSuperseded(ctx, state, origin, work, ready, {
+        latestRecordSeq: work.latestRecordSeq
+      });
+      continue;
+    }
+    const terminal = terminalHandoffState(work.state);
+    if (terminal) {
+      emitHandoffStatus(
+        ctx,
+        state,
+        handoffStatus("ignored-terminal", {
+          queueId: work.queueId,
+          workId: work.workId,
+          scheduleId: ready.scheduleId,
+          readyAtMs: ready.readyAtMs,
+          nowMs: ready.nowMs,
+          currentState: work.state,
+          sourceRefs: ready.sourceRefs
+        })
+      );
+      continue;
+    }
+    if (origin.scheduleKind === "lease-expiration") {
+      evaluateLeaseExpirationReady(ctx, state, origin, work, ready);
+      continue;
+    }
+    evaluateClaimEligibilityReady(ctx, state, origin, work, ready);
+  }
+}
+function evaluateClaimEligibilityReady(ctx, state, origin, work, ready) {
+  if (work.state === "leased") {
+    emitHandoffStatus(
+      ctx,
+      state,
+      handoffStatus("ignored-stale", {
+        queueId: work.queueId,
+        workId: work.workId,
+        scheduleId: ready.scheduleId,
+        readyAtMs: ready.readyAtMs,
+        nowMs: ready.nowMs,
+        currentState: work.state,
+        sourceRefs: ready.sourceRefs
+      })
+    );
+    return;
+  }
+  if (work.notBeforeMs !== void 0 && work.notBeforeMs > ready.nowMs) {
+    emitSuperseded(ctx, state, origin, work, ready, { notBeforeMs: work.notBeforeMs });
+    return;
+  }
+  if (work.retryAtMs !== void 0 && work.retryAtMs > ready.nowMs) {
+    emitSuperseded(ctx, state, origin, work, ready, { retryAtMs: work.retryAtMs });
+    return;
+  }
+  emitCandidate(ctx, state, candidateFor(origin, ready, "claim-eligible"));
+}
+function evaluateLeaseExpirationReady(ctx, state, origin, work, ready) {
+  if (origin.record.kind !== "work-claimed" && origin.record.kind !== "lease-renewed") {
+    emitHandoffIssue(
+      ctx,
+      state,
+      dataIssue(
+        "work-queue-readiness-handoff-malformed-origin",
+        "Lease-expiration readiness must originate from a lease-bearing workQueue record.",
+        { subjectId: ready.scheduleId, refs: ready.sourceRefs }
+      )
+    );
+    return;
+  }
+  if (work.state !== "leased" || work.leaseId !== origin.record.leaseId || work.attempt !== origin.record.attempt || work.workerId !== origin.record.workerId) {
+    emitHandoffStatus(
+      ctx,
+      state,
+      handoffStatus("ignored-stale", {
+        queueId: work.queueId,
+        workId: work.workId,
+        scheduleId: ready.scheduleId,
+        readyAtMs: ready.readyAtMs,
+        nowMs: ready.nowMs,
+        currentState: work.state,
+        sourceRefs: ready.sourceRefs
+      })
+    );
+    return;
+  }
+  if (work.leaseExpiresAtMs !== origin.record.leaseExpiresAtMs) {
+    emitSuperseded(ctx, state, origin, work, ready, {
+      leaseExpiresAtMs: work.leaseExpiresAtMs
+    });
+    return;
+  }
+  if (work.leaseExpiresAtMs !== void 0 && work.leaseExpiresAtMs > ready.nowMs) {
+    emitSuperseded(ctx, state, origin, work, ready, {
+      leaseExpiresAtMs: work.leaseExpiresAtMs
+    });
+    return;
+  }
+  emitCandidate(ctx, state, candidateFor(origin, ready, "lease-expiration-eligible"));
+}
+function emitSuperseded(ctx, state, origin, work, ready, metadata) {
+  emitHandoffStatus(
+    ctx,
+    state,
+    handoffStatus("ignored-superseded", {
+      queueId: work.queueId,
+      workId: work.workId,
+      scheduleId: ready.scheduleId,
+      readyAtMs: ready.readyAtMs,
+      nowMs: ready.nowMs,
+      currentState: work.state,
+      sourceRefs: ready.sourceRefs,
+      metadata: {
+        originRecordSeq: origin.record.recordSeq,
+        originRecordKind: origin.record.kind,
+        ...metadata
+      }
+    })
+  );
+}
+function candidateFor(origin, ready, candidateKind) {
+  const lease = origin.record.kind === "work-claimed" || origin.record.kind === "lease-renewed" ? {
+    leaseId: origin.record.leaseId,
+    attempt: origin.record.attempt,
+    workerId: origin.record.workerId,
+    leaseExpiresAtMs: origin.record.leaseExpiresAtMs
+  } : {};
+  const metadata = sanitizeGraphVisibleRecord({
+    originRecordSeq: origin.record.recordSeq,
+    originRecordKind: origin.record.kind,
+    scheduleKind: origin.scheduleKind
+  });
+  return Object.freeze({
+    kind: "work-queue-readiness-candidate",
+    candidateId: `${ready.scheduleId}:work-queue:${candidateKind}`,
+    candidateKind,
+    queueId: origin.record.queueId,
+    workId: origin.record.workId,
+    scheduleId: ready.scheduleId,
+    readyAtMs: ready.readyAtMs,
+    nowMs: ready.nowMs,
+    originRecordSeq: origin.record.recordSeq,
+    originRecordKind: origin.record.kind,
+    ...lease,
+    sourceRefs: canonicalPublicSourceRefs(
+      uniqueSourceRefs([
+        ...ready.sourceRefs ?? [],
+        ref("work-queue-record", String(origin.record.recordSeq)),
+        ref("scheduled-readiness-ready", ready.scheduleId)
+      ])
+    ),
+    ...metadata === void 0 ? {} : { metadata }
+  });
+}
+function emitCandidate(ctx, state, candidate) {
+  const key = `candidate:${candidate.candidateId}`;
+  if (!state.emittedKeys.has(key)) {
+    state.emittedKeys.add(key);
+    state.candidatesById.set(candidate.candidateId, candidate);
+    ctx.down([["DATA", { kind: "candidate", candidate }]]);
+    emitHandoffAudit(ctx, state, "work-queue-readiness-candidate", {
+      subjectId: candidate.candidateId,
+      sourceRefs: candidate.sourceRefs,
+      metadata: {
+        candidateKind: candidate.candidateKind,
+        queueId: candidate.queueId,
+        workId: candidate.workId,
+        readyAtMs: candidate.readyAtMs,
+        nowMs: candidate.nowMs
+      }
+    });
+  } else {
+    state.candidatesById.set(candidate.candidateId, candidate);
+  }
+  emitHandoffStatus(
+    ctx,
+    state,
+    handoffStatus("candidate", {
+      queueId: candidate.queueId,
+      workId: candidate.workId,
+      scheduleId: candidate.scheduleId,
+      candidateId: candidate.candidateId,
+      candidateKind: candidate.candidateKind,
+      readyAtMs: candidate.readyAtMs,
+      nowMs: candidate.nowMs,
+      sourceRefs: candidate.sourceRefs
+    })
+  );
+}
+function emitOverdueHandoffStatus(ctx, state, overdue) {
+  const origin = state.originsByScheduleId.get(overdue.scheduleId);
+  emitHandoffStatus(
+    ctx,
+    state,
+    handoffStatus("overdue", {
+      queueId: origin?.record.queueId,
+      workId: origin?.record.workId,
+      scheduleId: overdue.scheduleId,
+      readyAtMs: overdue.readyAtMs,
+      nowMs: overdue.nowMs,
+      sourceRefs: overdue.sourceRefs,
+      metadata: {
+        deadlineMs: overdue.deadlineMs,
+        ...origin === void 0 ? {} : { originRecordSeq: origin.record.recordSeq, originRecordKind: origin.record.kind }
+      }
+    })
+  );
+}
+function handoffStatus(state, opts) {
+  const subject = opts.candidateId ?? opts.scheduleId ?? "unknown-work-queue-readiness";
+  const metadata = sanitizeGraphVisibleRecord(opts.metadata);
+  return Object.freeze({
+    kind: "work-queue-readiness-handoff-status",
+    statusId: `${subject}:work-queue-readiness-handoff-status:${state}`,
+    state,
+    ...opts.queueId === void 0 ? {} : { queueId: opts.queueId },
+    ...opts.workId === void 0 ? {} : { workId: opts.workId },
+    ...opts.scheduleId === void 0 ? {} : { scheduleId: opts.scheduleId },
+    ...opts.candidateId === void 0 ? {} : { candidateId: opts.candidateId },
+    ...opts.candidateKind === void 0 ? {} : { candidateKind: opts.candidateKind },
+    ...opts.readyAtMs === void 0 ? {} : { readyAtMs: opts.readyAtMs },
+    ...opts.nowMs === void 0 ? {} : { nowMs: opts.nowMs },
+    ...opts.currentState === void 0 ? {} : { currentState: opts.currentState },
+    ...opts.sourceRefs === void 0 ? {} : { sourceRefs: canonicalPublicSourceRefs(opts.sourceRefs) },
+    ...opts.issueCodes === void 0 ? {} : { issueCodes: opts.issueCodes },
+    ...metadata === void 0 ? {} : { metadata }
+  });
+}
+function emitHandoffStatus(ctx, state, status) {
+  state.statusById.set(status.statusId, status);
+  const key = `handoff-status:${status.statusId}:${stableJsonStringify(status)}`;
+  if (state.emittedKeys.has(key)) return;
+  state.emittedKeys.add(key);
+  ctx.down([["DATA", { kind: "status", status }]]);
+}
+function emitHandoffIssue(ctx, state, issue) {
+  const key = `${issue.code}:${issue.subjectId ?? ""}:${JSON.stringify(issue.details ?? {})}`;
+  if (state.issueKeys.has(key)) return;
+  state.issueKeys.add(key);
+  ctx.down([["DATA", { kind: "issue", issue }]]);
+  emitHandoffStatus(
+    ctx,
+    state,
+    handoffStatus("issue", {
+      scheduleId: issue.subjectId,
+      sourceRefs: issue.refs?.map(sourceRefFromIssueRef),
+      issueCodes: [issue.code]
+    })
+  );
+}
+function emitHandoffAudit(ctx, state, kind, opts) {
+  state.auditSeq += 1;
+  const metadata = sanitizeGraphVisibleRecord(opts.metadata);
+  ctx.down([
+    [
+      "DATA",
+      {
+        kind: "audit",
+        audit: Object.freeze({
+          id: `work-queue-readiness-handoff-audit-${state.auditSeq}`,
+          kind,
+          subjectId: opts.subjectId,
+          ...opts.sourceRefs === void 0 ? {} : { sourceRefs: canonicalPublicSourceRefs(opts.sourceRefs) },
+          ...metadata === void 0 ? {} : { metadata }
+        })
+      }
+    ]
+  ]);
+}
+function buildHandoffViews(state) {
+  return Object.freeze({
+    candidatesById: new Map(state.candidatesById),
+    statusById: new Map(state.statusById)
+  });
+}
+function emitLeaseCommandStatus(ctx, state, command, candidate) {
+  const status = handoffStatus("candidate", {
+    queueId: candidate.queueId,
+    workId: candidate.workId,
+    scheduleId: candidate.scheduleId,
+    candidateId: candidate.candidateId,
+    candidateKind: candidate.candidateKind,
+    readyAtMs: candidate.readyAtMs,
+    nowMs: candidate.nowMs,
+    sourceRefs: candidate.sourceRefs,
+    metadata: {
+      commandId: command.commandId,
+      commandKind: command.kind
+    }
+  });
+  state.statusById.set(status.statusId, status);
+  const key = `lease-command-status:${status.statusId}`;
+  if (state.emittedKeys.has(key)) return;
+  state.emittedKeys.add(key);
+  ctx.down([["DATA", { kind: "status", status }]]);
+}
+function buildLeaseCommandViews(state) {
+  return Object.freeze({
+    candidatesById: /* @__PURE__ */ new Map(),
+    statusById: new Map(state.statusById)
+  });
+}
+function sourceRefStrings(sourceRefs) {
+  if (sourceRefs === void 0 || sourceRefs.length === 0) return void 0;
+  return sourceRefs.map((sourceRef) => `${sourceRef.kind}:${sourceRef.id}`);
+}
+function sourceRefFromIssueRef(issueRef) {
+  const [kind, ...rest] = issueRef.split(":");
+  return ref(kind || "issue-ref", rest.join(":") || issueRef);
+}
+function terminalHandoffState(state) {
+  return state === "completed" || state === "canceled" || state === "dead-lettered";
+}
+function hasWorkRecordCoordinates(record) {
+  return typeof record.queueId === "string" && typeof record.workId === "string" && typeof record.recordSeq === "number" && Number.isFinite(record.recordSeq);
+}
+function hasLeaseRecordCoordinates(record) {
+  return hasWorkRecordCoordinates(record) && typeof record.leaseId === "string" && typeof record.attempt === "number" && Number.isFinite(record.attempt) && typeof record.workerId === "string";
+}
+function malformedRecord(record, message) {
+  const subjectId = typeof record.kind === "string" ? `work-queue-record:${publicCoordinateId(record.kind)}` : "unknown-work-queue-record";
+  const issue = dataIssue("work-queue-scheduled-readiness-malformed-record", message, {
+    subjectId,
+    refs: [],
+    details: sanitizeGraphVisibleRecord({
+      recordKind: typeof record.kind === "string" ? record.kind : void 0,
+      queueId: typeof record.queueId === "string" ? publicCoordinateId(record.queueId) : void 0,
+      workId: typeof record.workId === "string" ? publicCoordinateId(record.workId) : void 0,
+      recordSeq: typeof record.recordSeq === "number" && Number.isFinite(record.recordSeq) ? record.recordSeq : void 0
+    })
+  });
+  return {
+    kind: "issue",
+    issue,
+    status: issueStatus(subjectId, [issue])
+  };
+}
+function translateRecord(raw) {
+  if (!isRecord(raw)) {
+    const issue = dataIssue(
+      "work-queue-scheduled-readiness-malformed-record",
+      "WorkQueue scheduled readiness requires a graph-visible workQueue record.",
+      { subjectId: "unknown-work-queue-record", refs: [] }
+    );
+    return {
+      kind: "issue",
+      issue,
+      status: issueStatus("unknown-work-queue-record", [issue])
+    };
+  }
+  const unknownRecord = raw;
+  const rawRecord = unknownRecord;
+  switch (rawRecord.kind) {
+    case "work-admitted": {
+      const notBeforeMs = rawRecord.notBeforeMs;
+      if (notBeforeMs === void 0) return { kind: "none" };
+      if (typeof notBeforeMs !== "number") {
+        return malformedRecord(rawRecord, "Delayed work-admitted notBeforeMs must be a number.");
+      }
+      if (!hasWorkRecordCoordinates(rawRecord)) {
+        return malformedRecord(
+          rawRecord,
+          "Delayed work-admitted records require queueId, workId, and recordSeq."
+        );
+      }
+      const admitted = rawRecord;
+      return scheduleFromRecord(admitted, {
+        scheduleKind: "work-admitted",
+        scheduleId: workQueueScheduleId(admitted, "admission", admitted.recordSeq),
+        readyAtMs: notBeforeMs,
+        deadlineMs: admitted.deadlineMs,
+        reason: "work-queue-delayed-admission"
+      });
+    }
+    case "work-scheduled": {
+      if (!hasWorkRecordCoordinates(rawRecord)) {
+        return malformedRecord(
+          rawRecord,
+          "work-scheduled records require queueId, workId, and recordSeq."
+        );
+      }
+      const scheduled = rawRecord;
+      return scheduleFromRecord(scheduled, {
+        scheduleKind: "work-scheduled",
+        scheduleId: workQueueScheduleId(
+          scheduled,
+          "schedule",
+          scheduled.scheduleId ?? scheduled.commandId ?? scheduled.recordSeq
+        ),
+        readyAtMs: scheduled.notBeforeMs,
+        deadlineMs: scheduled.deadlineMs,
+        reason: scheduled.reason ?? "work-queue-schedule"
+      });
+    }
+    case "retry-scheduled": {
+      if (!hasWorkRecordCoordinates(rawRecord)) {
+        return malformedRecord(
+          rawRecord,
+          "retry-scheduled records require queueId, workId, and recordSeq."
+        );
+      }
+      const retry = rawRecord;
+      return scheduleFromRecord(retry, {
+        scheduleKind: "retry-scheduled",
+        scheduleId: workQueueScheduleId(retry, "retry", retry.commandId ?? retry.recordSeq),
+        readyAtMs: retry.retryAtMs,
+        reason: retry.reason ?? "work-queue-retry",
+        metadata: { delayMs: retry.delayMs }
+      });
+    }
+    case "work-claimed": {
+      if (!hasLeaseRecordCoordinates(rawRecord)) {
+        return malformedRecord(
+          rawRecord,
+          "work-claimed records require queueId, workId, recordSeq, leaseId, attempt, and workerId."
+        );
+      }
+      const claimed = rawRecord;
+      return scheduleFromRecord(claimed, {
+        scheduleKind: "lease-expiration",
+        scheduleId: workQueueLeaseScheduleId(claimed),
+        readyAtMs: claimed.leaseExpiresAtMs,
+        reason: "work-queue-lease-expiration",
+        leaseId: claimed.leaseId,
+        metadata: { attempt: claimed.attempt }
+      });
+    }
+    case "lease-renewed": {
+      if (!hasLeaseRecordCoordinates(rawRecord)) {
+        return malformedRecord(
+          rawRecord,
+          "lease-renewed records require queueId, workId, recordSeq, leaseId, attempt, and workerId."
+        );
+      }
+      const renewed = rawRecord;
+      return scheduleFromRecord(renewed, {
+        scheduleKind: "lease-expiration",
+        scheduleId: workQueueLeaseScheduleId(renewed),
+        readyAtMs: renewed.leaseExpiresAtMs,
+        reason: "work-queue-lease-expiration",
+        leaseId: renewed.leaseId,
+        metadata: {
+          attempt: renewed.attempt,
+          previousLeaseExpiresAtMs: renewed.previousLeaseExpiresAtMs
+        }
+      });
+    }
+    default:
+      return { kind: "none" };
+  }
+}
+function scheduleFromRecord(record, opts) {
+  if (!Number.isFinite(opts.readyAtMs) || !finiteOrUndefined(opts.deadlineMs)) {
+    const refs = recordSourceRefs(record, opts.leaseId);
+    const issue = dataIssue(
+      "work-queue-scheduled-readiness-malformed-record",
+      "WorkQueue delayed eligibility record must carry finite readiness and deadline coordinates.",
+      {
+        subjectId: workQueueRecordSubjectId(record),
+        refs,
+        details: {
+          recordKind: record.kind,
+          readyAtMs: opts.readyAtMs,
+          deadlineMs: opts.deadlineMs
+        }
+      }
+    );
+    return {
+      kind: "issue",
+      issue,
+      status: issueStatus(opts.scheduleId, [issue], record, refs)
+    };
+  }
+  const subjectRefs = recordSubjectRefs(record, opts.leaseId);
+  const sourceRefs = recordSourceRefs(record, opts.leaseId);
+  const recordPolicyRefs = policyRefs(record);
+  const metadata = sanitizeGraphVisibleRecord({
+    queueId: publicCoordinateId(record.queueId),
+    workId: publicCoordinateId(record.workId),
+    recordSeq: record.recordSeq,
+    recordKind: record.kind,
+    scheduleKind: opts.scheduleKind,
+    ...record.commandId === void 0 ? {} : { commandId: publicCoordinateId(record.commandId) },
+    ...opts.leaseId === void 0 ? {} : { leaseId: publicCoordinateId(opts.leaseId) },
+    ...opts.metadata ?? {}
+  });
+  const schedule = Object.freeze({
+    kind: "scheduled-readiness-requested",
+    scheduleId: opts.scheduleId,
+    subjectRefs,
+    readyAtMs: opts.readyAtMs,
+    ...opts.deadlineMs === void 0 ? {} : { deadlineMs: opts.deadlineMs },
+    reason: opts.reason,
+    ...recordPolicyRefs === void 0 ? {} : { policyRefs: recordPolicyRefs },
+    sourceRefs,
+    ...metadata === void 0 ? {} : { metadata }
+  });
+  return {
+    kind: "translated",
+    record,
+    schedule,
+    status: Object.freeze({
+      kind: "work-queue-scheduled-readiness-status",
+      statusId: `${opts.scheduleId}:work-queue-scheduled-readiness-status:translated`,
+      queueId: publicCoordinateId(record.queueId),
+      workId: publicCoordinateId(record.workId),
+      recordSeq: record.recordSeq,
+      state: "translated",
+      scheduleKind: opts.scheduleKind,
+      scheduleId: opts.scheduleId,
+      readyAtMs: opts.readyAtMs,
+      ...opts.deadlineMs === void 0 ? {} : { deadlineMs: opts.deadlineMs },
+      sourceRefs,
+      ...metadata === void 0 ? {} : { metadata }
+    })
+  };
+}
+function recordSubjectRefs(record, leaseId) {
+  return canonicalPublicSourceRefs(
+    uniqueSourceRefs([
+      ref("work-queue", publicCoordinateId(record.queueId)),
+      ref("work-queue-work", publicCoordinateId(record.workId)),
+      ref("work-queue-record", String(record.recordSeq)),
+      ...record.commandId === void 0 ? [] : [ref("work-queue-command", publicCoordinateId(record.commandId))],
+      ...leaseId === void 0 ? [] : [ref("work-queue-lease", publicCoordinateId(leaseId))]
+    ])
+  );
+}
+function recordSourceRefs(record, leaseId) {
+  return canonicalPublicSourceRefs(
+    uniqueSourceRefs([
+      ref("work-queue", publicCoordinateId(record.queueId)),
+      ref("work-queue-record", String(record.recordSeq)),
+      ...record.workId === void 0 ? [] : [ref("work-queue-work", publicCoordinateId(record.workId))],
+      ...record.commandId === void 0 ? [] : [ref("work-queue-command", publicCoordinateId(record.commandId))],
+      ...leaseId === void 0 ? [] : [ref("work-queue-lease", publicCoordinateId(leaseId))],
+      ...copiedPublicRefs(record.sourceRefs, "work-queue-source-ref")
+    ])
+  );
+}
+function policyRefs(record) {
+  if (record.policyRefs === void 0 || record.policyRefs.length === 0) return void 0;
+  return canonicalPublicSourceRefs(copiedPublicRefs(record.policyRefs, "work-queue-policy-ref"));
+}
+function workQueueScheduleId(record, part, id) {
+  return `workQueue:${publicCoordinateId(record.queueId)}:${publicCoordinateId(record.workId)}:${part}:${publicCoordinateId(String(id))}`;
+}
+function workQueueLeaseScheduleId(record) {
+  return `workQueue:${publicCoordinateId(record.queueId)}:${publicCoordinateId(record.workId)}:lease:${publicCoordinateId(record.leaseId)}:expires:${record.recordSeq}`;
+}
+function workQueueRecordSubjectId(record) {
+  return `${publicCoordinateId(record.queueId)}:${publicCoordinateId(record.workId)}:${record.recordSeq}`;
+}
+function copiedPublicRefs(ids, kind) {
+  if (ids === void 0 || ids.length === 0) return [];
+  const copied = ids.slice(0, MAX_COPIED_PUBLIC_REFS).map((id) => ref(kind, publicCoordinateId(id)));
+  if (ids.length <= MAX_COPIED_PUBLIC_REFS) return copied;
+  return [
+    ...copied,
+    ref(
+      `${kind}-overflow`,
+      `count:${ids.length}:hash:${stableStringHash(stableJsonStringify(ids))}`
+    )
+  ];
+}
+function publicCoordinateId(id) {
+  if (id.length <= MAX_PUBLIC_COORDINATE_ID_CHARS && !PRIVATE_COORDINATE_PATTERN.test(id)) {
+    return id;
+  }
+  return `bounded:${stableStringHash(id)}:${id.length}`;
+}
+function issueStatus(statusId, issues, record, sourceRefs) {
+  return Object.freeze({
+    kind: "work-queue-scheduled-readiness-status",
+    statusId: `${statusId}:work-queue-scheduled-readiness-status:issue`,
+    ...record?.queueId === void 0 ? {} : { queueId: publicCoordinateId(record.queueId) },
+    ...record?.workId === void 0 ? {} : { workId: publicCoordinateId(record.workId) },
+    ...record?.recordSeq === void 0 ? {} : { recordSeq: record.recordSeq },
+    state: "issue",
+    ...sourceRefs === void 0 ? {} : { sourceRefs },
+    issueCodes: issues.map((issue) => issue.code)
+  });
+}
+function finiteOrUndefined(value) {
+  return value === void 0 || Number.isFinite(value);
+}
+function scheduleIdentity(schedule) {
+  return stableJsonStringify({
+    scheduleId: schedule.scheduleId,
+    subjectRefs: schedule.subjectRefs,
+    readyAtMs: schedule.readyAtMs,
+    deadlineMs: schedule.deadlineMs,
+    reason: schedule.reason,
+    policyRefs: schedule.policyRefs,
+    sourceRefs: schedule.sourceRefs,
+    metadata: schedule.metadata
+  });
+}
+function emitScheduleConflict(ctx, state, translated, existing) {
+  const issue = dataIssue(
+    "work-queue-scheduled-readiness-schedule-conflict",
+    "WorkQueue delayed eligibility replayed with conflicting scheduled-readiness material; the first schedule was retained.",
+    {
+      subjectId: translated.schedule.scheduleId,
+      refs: translated.schedule.sourceRefs,
+      details: {
+        existingReadyAtMs: existing?.readyAtMs,
+        incomingReadyAtMs: translated.schedule.readyAtMs,
+        existingDeadlineMs: existing?.deadlineMs,
+        incomingDeadlineMs: translated.schedule.deadlineMs,
+        recordSeq: translated.record.recordSeq,
+        recordKind: translated.record.kind
+      }
+    }
+  );
+  emitIssue(ctx, state, issue);
+  emitStatus(
+    ctx,
+    state,
+    issueStatus(
+      `${translated.schedule.scheduleId}:conflict:${translated.record.recordSeq}`,
+      [issue],
+      translated.record,
+      translated.schedule.sourceRefs
+    )
+  );
+}
+function emitSchedule(ctx, state, schedule) {
+  const key = `schedule:${schedule.scheduleId}`;
+  if (state.emittedKeys.has(key)) return;
+  state.emittedKeys.add(key);
+  ctx.down([["DATA", { kind: "readiness-schedule", schedule }]]);
+}
+function emitStatus(ctx, state, status) {
+  state.statusById.set(status.statusId, status);
+  const key = `status:${status.statusId}:${(status.issueCodes ?? []).join(",")}`;
+  if (state.emittedKeys.has(key)) return;
+  state.emittedKeys.add(key);
+  ctx.down([["DATA", { kind: "status", status }]]);
+}
+function emitIssue(ctx, state, issue) {
+  const key = `${issue.code}:${issue.subjectId ?? ""}:${JSON.stringify(issue.details ?? {})}`;
+  if (state.issueKeys.has(key)) return;
+  state.issueKeys.add(key);
+  ctx.down([["DATA", { kind: "issue", issue }]]);
+}
+function emitAudit(ctx, state, kind, opts) {
+  state.auditSeq += 1;
+  const metadata = sanitizeGraphVisibleRecord(opts.metadata);
+  ctx.down([
+    [
+      "DATA",
+      {
+        kind: "audit",
+        audit: Object.freeze({
+          id: `work-queue-scheduled-readiness-audit-${state.auditSeq}`,
+          kind,
+          subjectId: opts.subjectId,
+          ...opts.sourceRefs === void 0 ? {} : { sourceRefs: canonicalPublicSourceRefs(opts.sourceRefs) },
+          ...metadata === void 0 ? {} : { metadata }
+        })
+      }
+    ]
+  ]);
+}
+function buildViews(state) {
+  return Object.freeze({
+    schedulesById: new Map(state.schedulesById),
+    statusById: new Map(state.statusById)
+  });
+}
+
+// src/orchestration/work-queue.ts
+function orchestrationWorkQueueRecipe(graph, opts) {
+  const name = opts.name ?? "orchestrationWorkQueue";
+  const submitCommands = opts.effectRequests === void 0 ? void 0 : graph.node(
+    [opts.effectRequests],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        ctx.down([
+          ["DATA", processEffectSubmitCommand(raw)]
+        ]);
+      }
+    },
+    {
+      name: `${name}/submitCommands`,
+      factory: "orchestrationWorkQueueSubmitCommands",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const runtime = graph.node(
+    [opts.records],
+    (ctx) => {
+      const state = ctx.state.get() ?? {
+        payloads: /* @__PURE__ */ new Map(),
+        terminalRecords: /* @__PURE__ */ new Set(),
+        auditSeq: 0
+      };
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        reduceRecord(ctx, state, raw);
+      }
+      ctx.state.set(state);
+    },
+    {
+      name: `${name}/runtime`,
+      factory: "orchestrationWorkQueueRuntime",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    ...submitCommands === void 0 ? {} : { submitCommands },
+    evidence: project(
+      graph,
+      runtime,
+      `${name}/evidence`,
+      "orchestrationWorkQueueEvidence",
+      (fact) => fact.kind === "evidence" ? fact.evidence : void 0
+    ),
+    status: project(
+      graph,
+      runtime,
+      `${name}/status`,
+      "orchestrationWorkQueueStatus",
+      (fact) => fact.kind === "status" ? fact.status : void 0
+    ),
+    issues: project(
+      graph,
+      runtime,
+      `${name}/issues`,
+      "orchestrationWorkQueueIssues",
+      (fact) => fact.kind === "issue" ? fact.issue : void 0
+    ),
+    audit: project(
+      graph,
+      runtime,
+      `${name}/audit`,
+      "orchestrationWorkQueueAudit",
+      (fact) => fact.kind === "audit" ? fact.audit : void 0
+    )
+  };
+}
+function processEffectSubmitCommand(effect, opts = {}) {
+  const payload = {
+    kind: "orchestration-queued-effect",
+    effect,
+    idempotencyKey: opts.idempotencyKey ?? effect.id,
+    sourceRefs: opts.sourceRefs,
+    policyRefs: opts.policyRefs,
+    metadata: opts.metadata
+  };
+  return {
+    kind: "submit",
+    commandId: opts.commandId ?? `${effect.id}:orchestration-work-queue-submit`,
+    workId: opts.workId ?? `process-effect:${effect.id}`,
+    payload,
+    idempotencyKey: opts.idempotencyKey ?? effect.id,
+    sourceRefs: opts.sourceRefs,
+    policyRefs: opts.policyRefs
+  };
+}
+function reduceRecord(ctx, state, record) {
+  if (record.kind === "work-admitted") {
+    if (isQueuedEffectPayload(record.payload)) {
+      state.payloads.set(record.workId, record.payload);
+    } else {
+      emitIssue2(ctx, state, record, "orchestration-queue-malformed-payload");
+    }
+    return;
+  }
+  if (!isTerminalEvidenceRecord(record)) return;
+  const key = `${record.kind}:${record.recordSeq}`;
+  if (state.terminalRecords.has(key)) return;
+  state.terminalRecords.add(key);
+  const payload = record.workId === void 0 ? void 0 : state.payloads.get(record.workId);
+  if (payload === void 0) {
+    emitIssue2(ctx, state, record, "orchestration-queue-record-without-payload");
+    return;
+  }
+  const evidence = evidenceFromRecord(record, payload);
+  emit(ctx, { kind: "evidence", evidence });
+  emit(ctx, { kind: "status", status: statusFromEvidence(evidence, payload) });
+  state.auditSeq += 1;
+  emit(ctx, { kind: "audit", audit: auditFromEvidence(state.auditSeq, evidence, payload) });
+}
+function isTerminalEvidenceRecord(record) {
+  return record.kind === "work-completed" || record.kind === "attempt-completed" || record.kind === "work-canceled" || record.kind === "work-dead-lettered" || record.kind === "attempt-failed";
+}
+function evidenceFromRecord(record, payload) {
+  return {
+    kind: "orchestration-queue-evidence",
+    evidenceId: `work-queue:${record.recordSeq}`,
+    effectId: payload.effect.id,
+    effectType: payload.effect.type,
+    workId: record.workId ?? `unknown:${record.recordSeq}`,
+    queueRecordKind: record.kind,
+    result: "result" in record ? record.result : void 0,
+    error: "error" in record ? record.error : void 0,
+    recordedAtMs: record.recordedAtMs
+  };
+}
+function statusFromEvidence(evidence, payload) {
+  return {
+    kind: "orchestration-queue-status",
+    state: "evidence-recorded",
+    effectId: payload.effect.id,
+    effectType: payload.effect.type,
+    workId: evidence.workId,
+    queueRecordKind: evidence.queueRecordKind,
+    evidenceId: evidence.evidenceId
+  };
+}
+function auditFromEvidence(seq, evidence, payload) {
+  return {
+    kind: "orchestration-queue-audit",
+    seq,
+    outcome: "mapped",
+    effectId: payload.effect.id,
+    effectType: payload.effect.type,
+    workId: evidence.workId,
+    queueRecordKind: evidence.queueRecordKind,
+    evidenceId: evidence.evidenceId
+  };
+}
+function auditFromIssue(seq, record) {
+  return {
+    kind: "orchestration-queue-audit",
+    seq,
+    outcome: "issue",
+    workId: record.workId,
+    queueRecordKind: record.kind
+  };
+}
+function project(graph, runtime, name, factory, pick) {
+  return graph.node(
+    [runtime],
+    (ctx) => {
+      for (const fact of depBatch(ctx, 0) ?? []) {
+        const value = pick(fact);
+        if (value !== void 0) ctx.down([["DATA", value]]);
+      }
+    },
+    { name, factory, partial: true, completeWhenDepsComplete: false, errorWhenDepsError: false }
+  );
+}
+function emit(ctx, fact) {
+  ctx.down([["DATA", fact]]);
+}
+function emitIssue2(ctx, state, record, code) {
+  const issue = queueIssue(record, code);
+  emit(ctx, { kind: "issue", issue });
+  state.auditSeq += 1;
+  emit(ctx, {
+    kind: "status",
+    status: {
+      kind: "orchestration-queue-status",
+      state: "mapping-issue",
+      workId: record.workId,
+      queueRecordKind: record.kind,
+      issues: [issue]
+    }
+  });
+  emit(ctx, {
+    kind: "audit",
+    audit: auditFromIssue(state.auditSeq, record)
+  });
+}
+function queueIssue(record, code) {
+  return {
+    kind: "issue",
+    code,
+    message: `Orchestration workQueue recipe could not map record '${record.kind}'`,
+    severity: "error",
+    source: "orchestration.workQueue",
+    details: record
+  };
+}
+function isQueuedEffectPayload(value) {
+  if (!isObjectRecord(value) || value.kind !== "orchestration-queued-effect") return false;
+  const effect = value.effect;
+  return isObjectRecord(effect) && typeof effect.id === "string" && typeof effect.type === "string";
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  orchestrationWorkQueueRecipe,
+  processEffectSubmitCommand,
+  workQueueLeaseExpirationCommandProjector,
+  workQueueReadinessHandoffProjector,
+  workQueueScheduledReadinessProjector
+});
+//# sourceMappingURL=work-queue.cjs.map