@graphrefly/ts 0.0.0 → 0.0.2

package/dist/orchestration/work-queue.js

@@ -0,0 +1,1289 @@
+import {
+  canonicalPublicSourceRefs,
+  dataIssue,
+  isRecord,
+  projectRuntimeFact,
+  ref,
+  sanitizeGraphVisibleRecord,
+  stableJsonStringify,
+  stableStringHash,
+  uniqueSourceRefs
+} from "../chunk-TQPCAIQI.js";
+import {
+  depBatch
+} from "../chunk-WQIA3GFB.js";
+import "../chunk-S6HXABGL.js";
+import "../chunk-DGUM43GV.js";
+
+// 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;
+}
+export {
+  orchestrationWorkQueueRecipe,
+  processEffectSubmitCommand,
+  workQueueLeaseExpirationCommandProjector,
+  workQueueReadinessHandoffProjector,
+  workQueueScheduledReadinessProjector
+};
+//# sourceMappingURL=work-queue.js.map