@graphrefly/ts 0.0.0

package/dist/orchestration/index.js

@@ -0,0 +1,1004 @@
+import {
+  timeout
+} from "../chunk-JR4IKCR2.js";
+import {
+  backoffDelayMs,
+  nextRetryDelayMs,
+  noBackoff,
+  retryPolicy,
+  shouldRetry
+} from "../chunk-OOEN33FB.js";
+import "../chunk-G4M3NHRJ.js";
+import "../chunk-PKVBHGBM.js";
+import "../chunk-I3IHOHCJ.js";
+import "../chunk-4VLAQHZI.js";
+import {
+  depBatch
+} from "../chunk-SWTLEQL6.js";
+import "../chunk-DK554R7P.js";
+
+// src/orchestration/index.ts
+var processCommandSources = /* @__PURE__ */ new WeakMap();
+function retryStatusBundle(graph, events, opts = {}) {
+  const policy = opts.policy ?? retryPolicy();
+  const name = opts.name ?? "retry";
+  const status = graph.node(
+    [events],
+    (ctx) => {
+      let next = ctx.state.get() ?? { state: "idle", attempt: 0, maxAttempts: policy.maxAttempts };
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "attempt") {
+          next = { state: "running", attempt: event.attempt, maxAttempts: policy.maxAttempts };
+        } else if (event.kind === "retry") {
+          next = {
+            state: "waiting",
+            attempt: event.attempt,
+            maxAttempts: policy.maxAttempts,
+            delayMs: event.delayMs
+          };
+        } else if (event.kind === "success") {
+          next = {
+            state: "succeeded",
+            attempt: event.attempt ?? next.attempt,
+            maxAttempts: policy.maxAttempts
+          };
+        } else if (event.kind === "failure") {
+          const attempt = event.attempt ?? next.attempt;
+          next = {
+            state: shouldRetry(policy, attempt) ? "failed" : "exhausted",
+            attempt,
+            maxAttempts: policy.maxAttempts,
+            delayMs: shouldRetry(policy, attempt) ? nextRetryDelayMs(policy, attempt + 1) : void 0
+          };
+        } else {
+          next = {
+            state: "exhausted",
+            attempt: event.attempt,
+            maxAttempts: policy.maxAttempts
+          };
+        }
+      }
+      ctx.state.set(next);
+      ctx.down([["DATA", next]]);
+    },
+    { name: `${name}/status`, factory: "retryStatus" }
+  );
+  const errors = graph.node(
+    [events],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if ("error" in event) ctx.down([["DATA", event.error]]);
+      }
+    },
+    { name: `${name}/errors`, factory: "retryErrors" }
+  );
+  return { status, errors };
+}
+function breakerBundle(graph, events, opts) {
+  if (!Number.isInteger(opts.failureThreshold) || opts.failureThreshold <= 0) {
+    throw new RangeError("breakerBundle: failureThreshold must be a positive integer");
+  }
+  const name = opts.name ?? "breaker";
+  const now = opts.now ?? Date.now;
+  const status = graph.node(
+    [events],
+    (ctx) => {
+      let next = ctx.state.get() ?? { state: "closed", failures: 0 };
+      if (next.state === "open" && opts.resetAfterMs !== void 0 && next.openedAtMs !== void 0 && now() - next.openedAtMs >= opts.resetAfterMs) {
+        next = { ...next, state: "half-open" };
+      }
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "success") {
+          next = { state: "closed", failures: 0 };
+        } else if (event.kind === "failure" || event.kind === "exhausted") {
+          const failures = next.failures + 1;
+          next = failures >= opts.failureThreshold ? { state: "open", failures, openedAtMs: now() } : { ...next, failures };
+        }
+      }
+      ctx.state.set(next);
+      ctx.down([["DATA", next]]);
+    },
+    { name: `${name}/status`, factory: "breakerStatus" }
+  );
+  const allowed = graph.node(
+    [status],
+    (ctx) => {
+      const statusBatch = depBatch(ctx, 0) ?? [];
+      for (const value of statusBatch) {
+        ctx.down([["DATA", value.state !== "open"]]);
+      }
+    },
+    { name: `${name}/allowed`, factory: "breakerAllowed" }
+  );
+  return { status, allowed };
+}
+function rateLimitBundle(graph, source, opts) {
+  if (!Number.isInteger(opts.max) || opts.max <= 0) {
+    throw new RangeError("rateLimitBundle: max must be a positive integer");
+  }
+  if (!Number.isFinite(opts.windowMs) || opts.windowMs <= 0) {
+    throw new RangeError("rateLimitBundle: windowMs must be positive");
+  }
+  const now = opts.now ?? Date.now;
+  const name = opts.name ?? "rateLimit";
+  const events = graph.node(
+    [source],
+    (ctx) => {
+      const current = now();
+      let state = ctx.state.get() ?? { count: 0, resetAtMs: current + opts.windowMs, allowed: 0, dropped: 0 };
+      if (current >= state.resetAtMs) {
+        state = { ...state, count: 0, resetAtMs: current + opts.windowMs };
+      }
+      for (const value of depBatch(ctx, 0) ?? []) {
+        const allowed2 = state.count < opts.max;
+        state = allowed2 ? { ...state, count: state.count + 1, allowed: state.allowed + 1 } : { ...state, dropped: state.dropped + 1 };
+        const status2 = {
+          allowed: state.allowed,
+          dropped: state.dropped,
+          remaining: Math.max(0, opts.max - state.count),
+          resetAtMs: state.resetAtMs
+        };
+        ctx.down([
+          [
+            "DATA",
+            allowed2 ? { kind: "allowed", value, status: status2 } : { kind: "dropped", value, status: status2 }
+          ]
+        ]);
+      }
+      ctx.state.set(state);
+    },
+    { name: `${name}/events`, factory: "rateLimitEvents" }
+  );
+  const allowed = graph.node(
+    [events],
+    (ctx) => {
+      for (const event of depBatch(ctx, 0) ?? []) {
+        const typed = event;
+        if (typed.kind === "allowed") ctx.down([["DATA", typed.value]]);
+      }
+    },
+    { name: `${name}/allowed`, factory: "rateLimitAllowed" }
+  );
+  const dropped = graph.node(
+    [events],
+    (ctx) => {
+      for (const event of depBatch(ctx, 0) ?? []) {
+        const typed = event;
+        if (typed.kind === "dropped") ctx.down([["DATA", typed.value]]);
+      }
+    },
+    { name: `${name}/dropped`, factory: "rateLimitDropped" }
+  );
+  const status = graph.node(
+    [events],
+    (ctx) => {
+      for (const event of depBatch(ctx, 0) ?? []) {
+        ctx.down([["DATA", event.status]]);
+      }
+    },
+    { name: `${name}/status`, factory: "rateLimitStatus" }
+  );
+  return { allowed, dropped, status };
+}
+function timeoutBundle(graph, source, ms, opts = {}) {
+  const name = opts.name ?? "timeout";
+  const node = timeout(source, ms);
+  const status = graph.node(
+    [node],
+    (ctx) => {
+      const terminal = ctx.terminal[0];
+      if (terminal === true) ctx.down([["DATA", "completed"]]);
+      else if (terminal !== false && terminal !== void 0) ctx.down([["DATA", "errored"]]);
+      else if ((depBatch(ctx, 0) ?? []).length > 0) ctx.down([["DATA", "running"]]);
+    },
+    { name: `${name}/status`, factory: "timeoutStatus" }
+  );
+  const errors = graph.node(
+    [node],
+    (ctx) => {
+      const terminal = ctx.terminal[0];
+      if (terminal !== true && terminal !== false && terminal !== void 0) {
+        ctx.down([["DATA", terminal]]);
+      }
+    },
+    { name: `${name}/errors`, factory: "timeoutErrors" }
+  );
+  return { node, status, errors };
+}
+function processBundle(graph, opts) {
+  if (typeof opts.reduce !== "function") {
+    throw new TypeError("processBundle: reduce must be a function");
+  }
+  if (opts.initialState === void 0) {
+    throw new TypeError("processBundle: initialState must not be undefined");
+  }
+  const name = opts.name ?? "process";
+  const now = opts.now ?? Date.now;
+  const topology = graph.topologyGroup({ name: `${name}.process` });
+  const command = topology.node([], null, {
+    name: `${name}/command`,
+    factory: "processCommand",
+    completeWhenDepsComplete: false,
+    errorWhenDepsError: false
+  });
+  const runtime = topology.node(
+    [command],
+    (ctx) => {
+      let state2 = ctx.state.get() ?? {
+        eventSeq: 0,
+        effectSeq: 0,
+        commandCount: 0,
+        errorCount: 0,
+        auditSeq: 0,
+        seenEventIds: [],
+        seenEffectIds: [],
+        state: opts.initialState
+      };
+      ctx.state.persist(true);
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        state2 = reduceProcessCommandFact(
+          raw,
+          state2,
+          opts.reduce,
+          now,
+          (fact) => ctx.down([["DATA", fact]])
+        );
+        ctx.state.set(state2);
+      }
+    },
+    {
+      name: `${name}/runtime`,
+      factory: "processRuntime",
+      meta: { process: "facts-plus-reducer", d: "D136" },
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const events = processProjection(
+    topology,
+    runtime,
+    `${name}/events`,
+    "processEvents",
+    (fact) => fact.kind === "event" ? fact.event : void 0
+  );
+  const state = processProjection(
+    topology,
+    runtime,
+    `${name}/state`,
+    "processState",
+    (fact) => fact.kind === "state" ? fact.state : void 0
+  );
+  const audit = processProjection(
+    topology,
+    runtime,
+    `${name}/audit`,
+    "processAudit",
+    (fact) => fact.kind === "audit" ? fact.audit : void 0
+  );
+  const effectRequests = processProjection(
+    topology,
+    runtime,
+    `${name}/effectRequests`,
+    "processEffectRequests",
+    (fact) => fact.kind === "effect-request" ? fact.effect : void 0
+  );
+  const status = processProjection(
+    topology,
+    runtime,
+    `${name}/status`,
+    "processStatus",
+    (fact) => fact.kind === "status" ? fact.status : void 0
+  );
+  const errors = processProjection(
+    topology,
+    runtime,
+    `${name}/errors`,
+    "processErrors",
+    (fact) => fact.kind === "error" ? fact.error : void 0
+  );
+  const cursor = processProjection(
+    topology,
+    runtime,
+    `${name}/cursor`,
+    "processCursor",
+    (fact) => fact.kind === "cursor" ? fact.cursor : void 0
+  );
+  const retainProcessNodes = () => [
+    graph.retain(runtime, { reason: `${name}.process.runtime` }),
+    graph.retain(events, { reason: `${name}.process.events` }),
+    graph.retain(state, { reason: `${name}.process.state` }),
+    graph.retain(audit, { reason: `${name}.process.audit` }),
+    graph.retain(effectRequests, { reason: `${name}.process.effectRequests` }),
+    graph.retain(status, { reason: `${name}.process.status` }),
+    graph.retain(errors, { reason: `${name}.process.errors` }),
+    graph.retain(cursor, { reason: `${name}.process.cursor` })
+  ];
+  let releaseRetains = retainProcessNodes();
+  let released = false;
+  const bundle = {
+    command,
+    events,
+    state,
+    audit,
+    effectRequests,
+    status,
+    errors,
+    cursor,
+    dispatch(next) {
+      command.down([["DATA", next]]);
+      return next;
+    },
+    release() {
+      if (released) return;
+      const activeRetains = releaseRetains;
+      releaseRetains = [];
+      for (const releaseRetain of activeRetains) releaseRetain();
+      try {
+        topology.release({ reason: `${name}.process.release` });
+        released = true;
+        processCommandSources.delete(
+          bundle
+        );
+      } catch (error) {
+        releaseRetains = retainProcessNodes();
+        throw error;
+      }
+    }
+  };
+  processCommandSources.set(
+    bundle,
+    { sources: [] }
+  );
+  return bundle;
+}
+function processEffectRunner(graph, process, opts) {
+  if (opts.outcomes.length === 0) {
+    throw new RangeError("processEffectRunner: outcomes must contain at least one node");
+  }
+  const name = opts.name ?? "processEffectRunner";
+  const topology = graph.topologyGroup({ name: `${name}.effectRunner` });
+  const requests = topology.node(
+    [process.effectRequests],
+    (ctx) => {
+      for (const request of depBatch(ctx, 0) ?? []) {
+        ctx.down([["DATA", request]]);
+      }
+    },
+    {
+      name: `${name}/requests`,
+      factory: "processEffectRunnerRequests",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const runtime = topology.node(
+    [...opts.outcomes],
+    (ctx) => {
+      for (let i = 0; i < opts.outcomes.length; i += 1) {
+        for (const raw of depBatch(ctx, i) ?? []) {
+          const parsed = parseProcessEffectOutcome(raw);
+          if (typeof parsed === "string") {
+            const error = {
+              code: "malformed-outcome",
+              message: parsed,
+              outcome: raw
+            };
+            ctx.down([["DATA", { kind: "error", error }]]);
+            continue;
+          }
+          const outcome = parsed;
+          const command = processEffectOutcomeCommand(outcome);
+          ctx.down([["DATA", { kind: "outcome", outcome }]]);
+          ctx.down([["DATA", { kind: "command", command }]]);
+        }
+      }
+    },
+    {
+      name: `${name}/runtime`,
+      factory: "processEffectRunner",
+      meta: { process: "effect-runner", d: "D156" },
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const outcomes = processEffectRunnerProjection(
+    topology,
+    runtime,
+    `${name}/outcomes`,
+    "processEffectRunnerOutcomes",
+    (fact) => fact.kind === "outcome" ? fact.outcome : void 0
+  );
+  const commands = processEffectRunnerProjection(
+    topology,
+    runtime,
+    `${name}/commands`,
+    "processEffectRunnerCommands",
+    (fact) => fact.kind === "command" ? fact.command : void 0
+  );
+  const errors = processEffectRunnerProjection(
+    topology,
+    runtime,
+    `${name}/errors`,
+    "processEffectRunnerErrors",
+    (fact) => fact.kind === "error" ? fact.error : void 0
+  );
+  const status = topology.node(
+    [requests, runtime],
+    (ctx) => {
+      let state = ctx.state.get() ?? { requested: 0, commanded: 0, rejected: 0 };
+      for (const request of depBatch(ctx, 0) ?? []) {
+        state = { ...state, requested: state.requested + 1 };
+        const typedRequest = request;
+        ctx.down([
+          [
+            "DATA",
+            {
+              state: "requested",
+              effectId: typedRequest.id,
+              effectType: typedRequest.type,
+              requested: state.requested,
+              commanded: state.commanded,
+              rejected: state.rejected
+            }
+          ]
+        ]);
+      }
+      for (const fact of depBatch(ctx, 1) ?? []) {
+        const typedFact = fact;
+        if (typedFact.kind === "command") {
+          state = { ...state, commanded: state.commanded + 1 };
+          ctx.down([
+            [
+              "DATA",
+              {
+                state: "commanded",
+                effectId: typedFact.command.payload.effectId,
+                effectType: typedFact.command.payload.effectType,
+                commandId: typedFact.command.id,
+                commandType: typedFact.command.type,
+                requested: state.requested,
+                commanded: state.commanded,
+                rejected: state.rejected
+              }
+            ]
+          ]);
+        }
+        if (typedFact.kind === "error") {
+          state = { ...state, rejected: state.rejected + 1 };
+          ctx.down([
+            [
+              "DATA",
+              {
+                state: "rejected",
+                effectId: typedFact.error.effectId,
+                effectType: typedFact.error.effectType,
+                requested: state.requested,
+                commanded: state.commanded,
+                rejected: state.rejected
+              }
+            ]
+          ]);
+        }
+      }
+      ctx.state.set(state);
+    },
+    {
+      name: `${name}/status`,
+      factory: "processEffectRunnerStatus",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const retainRunnerNodes = () => [
+    graph.retain(requests, { reason: `${name}.effectRunner.requests` }),
+    graph.retain(outcomes, { reason: `${name}.effectRunner.outcomes` }),
+    graph.retain(commands, { reason: `${name}.effectRunner.commands` }),
+    graph.retain(status, { reason: `${name}.effectRunner.status` }),
+    graph.retain(errors, { reason: `${name}.effectRunner.errors` })
+  ];
+  let releaseRetains = retainRunnerNodes();
+  try {
+    attachProcessCommandSource(process, commands);
+  } catch (error) {
+    for (const releaseRetain of releaseRetains) releaseRetain();
+    releaseRetains = [];
+    topology.release({ reason: `${name}.effectRunner.failedAttach` });
+    throw error;
+  }
+  let released = false;
+  return {
+    requests,
+    outcomes,
+    commands,
+    status,
+    errors,
+    release() {
+      if (released) return;
+      const activeRetains = releaseRetains;
+      releaseRetains = [];
+      for (const releaseRetain of activeRetains) releaseRetain();
+      detachProcessCommandSource(process, commands);
+      try {
+        topology.release({ reason: `${name}.effectRunner.release` });
+        released = true;
+      } catch (error) {
+        attachProcessCommandSource(process, commands);
+        releaseRetains = retainRunnerNodes();
+        throw error;
+      }
+    }
+  };
+}
+function constantBackoff(delayMs) {
+  return { kind: "constant", delayMs };
+}
+function processEffectRunnerProjection(topology, runtime, name, factory, pick) {
+  return topology.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 parseProcessEffectOutcome(raw) {
+  if (!isObjectRecord(raw)) return "processEffectRunner: outcome must be an object";
+  if (typeof raw.kind !== "string") {
+    return "processEffectRunner: outcome kind must be a string";
+  }
+  if (raw.kind !== "result" && raw.kind !== "failure" && raw.kind !== "cancel" && raw.kind !== "timeout") {
+    return "processEffectRunner: outcome kind must be result, failure, cancel, or timeout";
+  }
+  if (typeof raw.effectId !== "string" || raw.effectId.length === 0) {
+    return "processEffectRunner: outcome effectId must be a non-empty string";
+  }
+  if (typeof raw.effectType !== "string" || raw.effectType.length === 0) {
+    return "processEffectRunner: outcome effectType must be a non-empty string";
+  }
+  if ("commandId" in raw && raw.commandId !== void 0) {
+    if (typeof raw.commandId !== "string" || raw.commandId.length === 0) {
+      return "processEffectRunner: outcome commandId must be a non-empty string";
+    }
+  }
+  for (const key of ["processId", "correlationId", "causationId"]) {
+    if (key in raw && raw[key] !== void 0 && typeof raw[key] !== "string") {
+      return `processEffectRunner: outcome ${key} must be a string`;
+    }
+  }
+  if ("metadata" in raw && raw.metadata !== void 0 && !isObjectRecord(raw.metadata)) {
+    return "processEffectRunner: outcome metadata must be a plain object";
+  }
+  if (raw.kind === "result" && !("value" in raw)) {
+    return "processEffectRunner: result outcome must carry value";
+  }
+  if ((raw.kind === "failure" || raw.kind === "timeout") && !("error" in raw)) {
+    return `processEffectRunner: ${raw.kind} outcome must carry error`;
+  }
+  if (raw.kind === "cancel" && "reason" in raw && raw.reason !== void 0 && typeof raw.reason !== "string") {
+    return "processEffectRunner: cancel outcome reason must be a string";
+  }
+  return raw;
+}
+function processEffectOutcomeCommand(outcome) {
+  const commandType = processEffectCommandType(outcome.kind);
+  return {
+    id: outcome.commandId ?? `${outcome.effectId}:${commandType}`,
+    type: commandType,
+    payload: processEffectCommandPayload(outcome),
+    processId: outcome.processId,
+    correlationId: outcome.correlationId,
+    causationId: outcome.causationId,
+    metadata: outcome.metadata
+  };
+}
+function processEffectCommandType(kind) {
+  switch (kind) {
+    case "result":
+      return "effect.result";
+    case "failure":
+      return "effect.failure";
+    case "cancel":
+      return "effect.cancel";
+    case "timeout":
+      return "effect.timeout";
+  }
+}
+function processEffectCommandPayload(outcome) {
+  const base = {
+    effectId: outcome.effectId,
+    effectType: outcome.effectType,
+    processId: outcome.processId,
+    correlationId: outcome.correlationId,
+    causationId: outcome.causationId,
+    metadata: outcome.metadata
+  };
+  switch (outcome.kind) {
+    case "result":
+      return { ...base, kind: "result", value: outcome.value };
+    case "failure":
+      return { ...base, kind: "failure", error: outcome.error };
+    case "cancel":
+      return { ...base, kind: "cancel", reason: outcome.reason };
+    case "timeout":
+      return { ...base, kind: "timeout", error: outcome.error };
+  }
+}
+function attachProcessCommandSource(process, source) {
+  const attached = processCommandSources.get(process);
+  if (attached === void 0) {
+    throw new Error("processEffectRunner: process command source registry missing");
+  }
+  const sources = attached.sources;
+  const previousSources = [...sources];
+  if (!sources.includes(source)) sources.push(source);
+  try {
+    process.command.replaceDeps([...sources], processCommandSourceFn(sources.length));
+  } catch (error) {
+    sources.splice(0, sources.length, ...previousSources);
+    process.command.replaceDeps(
+      [...previousSources],
+      processCommandSourceFn(previousSources.length)
+    );
+    throw error;
+  }
+}
+function detachProcessCommandSource(process, source) {
+  const attached = processCommandSources.get(process);
+  if (attached === void 0) {
+    throw new Error("processEffectRunner: process command source registry missing");
+  }
+  const sources = attached.sources;
+  if (!sources.includes(source)) return;
+  const previousSources = [...sources];
+  const nextSources = sources.filter((candidate) => candidate !== source);
+  sources.splice(0, sources.length, ...nextSources);
+  try {
+    process.command.replaceDeps([...nextSources], processCommandSourceFn(nextSources.length));
+  } catch (error) {
+    sources.splice(0, sources.length, ...previousSources);
+    process.command.replaceDeps(
+      [...previousSources],
+      processCommandSourceFn(previousSources.length)
+    );
+    throw error;
+  }
+}
+function processCommandSourceFn(sourceCount) {
+  return (ctx) => {
+    for (let i = 0; i < sourceCount; i += 1) {
+      for (const command of depBatch(ctx, i) ?? []) {
+        ctx.down([["DATA", command]]);
+      }
+    }
+  };
+}
+function processRuntimeDraft(state) {
+  return {
+    eventSeq: state.eventSeq,
+    effectSeq: state.effectSeq,
+    commandCount: state.commandCount,
+    errorCount: state.errorCount,
+    auditSeq: state.auditSeq,
+    seenEventIds: [...state.seenEventIds],
+    seenEffectIds: [...state.seenEffectIds],
+    state: state.state
+  };
+}
+function reduceProcessCommandFact(raw, state, reduce, now, emit) {
+  const draft = processRuntimeDraft(state);
+  draft.commandCount += 1;
+  const parsed = parseProcessCommand(raw);
+  if (typeof parsed === "string") {
+    emitProcessFailure(draft, emit, raw, void 0, "malformed-command", parsed);
+    return draft;
+  }
+  const command = parsed;
+  let reduction;
+  const reducerState = cloneProcessState(state.state);
+  if (!reducerState.ok) {
+    emitProcessFailure(draft, emit, command, command, "malformed-state", reducerState.message);
+    return draft;
+  }
+  try {
+    reduction = reduce(command, reducerState.value);
+  } catch (error) {
+    rethrowGraphRuntimeInvariant(error);
+    emitProcessFailure(draft, emit, command, command, "reducer-threw", errorMessage(error));
+    return draft;
+  }
+  if (!isObjectRecord(reduction) || !("state" in reduction)) {
+    emitProcessFailure(
+      draft,
+      emit,
+      command,
+      command,
+      "malformed-state",
+      "processBundle: reducer must return { state, events?, effects? }"
+    );
+    return draft;
+  }
+  if (reduction.state === void 0) {
+    emitProcessFailure(
+      draft,
+      emit,
+      command,
+      command,
+      "malformed-state",
+      "processBundle: reducer state must not be undefined"
+    );
+    return draft;
+  }
+  const privateState = cloneProcessState(reduction.state);
+  if (!privateState.ok) {
+    emitProcessFailure(draft, emit, command, command, "malformed-state", privateState.message);
+    return draft;
+  }
+  const visibleState = cloneProcessState(privateState.value);
+  if (!visibleState.ok) {
+    emitProcessFailure(draft, emit, command, command, "malformed-state", visibleState.message);
+    return draft;
+  }
+  const preparedEvents = prepareProcessEvents(command, draft, reduction.events ?? []);
+  if (typeof preparedEvents === "string") {
+    emitProcessFailure(draft, emit, command, command, "malformed-event", preparedEvents);
+    return draft;
+  }
+  const preparedEffects = prepareProcessEffects(command, draft, reduction.effects ?? []);
+  if (typeof preparedEffects === "string") {
+    emitProcessFailure(draft, emit, command, command, "malformed-effect", preparedEffects);
+    return draft;
+  }
+  const timestampMs = readTimestampMs(now);
+  if (typeof timestampMs === "string") {
+    emitProcessFailure(draft, emit, command, command, "clock-threw", timestampMs);
+    return draft;
+  }
+  draft.state = privateState.value;
+  emit({ kind: "state", state: visibleState.value, cursor: processCursorOf(draft) });
+  const events = [];
+  for (const eventDraft of preparedEvents) {
+    draft.eventSeq += 1;
+    draft.seenEventIds.push(eventDraft.id);
+    const event = {
+      id: eventDraft.id,
+      type: eventDraft.type,
+      seq: draft.eventSeq,
+      cursor: draft.eventSeq,
+      commandId: command.id,
+      commandType: command.type,
+      payload: eventDraft.payload,
+      timestampMs,
+      ...eventDraft.processId === void 0 ? {} : { processId: eventDraft.processId },
+      ...eventDraft.correlationId === void 0 ? {} : { correlationId: eventDraft.correlationId },
+      ...eventDraft.causationId === void 0 ? {} : { causationId: eventDraft.causationId },
+      ...eventDraft.metadata === void 0 ? {} : { metadata: eventDraft.metadata }
+    };
+    events.push(event);
+    emit({ kind: "event", event });
+  }
+  const effects = [];
+  for (const effectDraft of preparedEffects) {
+    draft.effectSeq += 1;
+    draft.seenEffectIds.push(effectDraft.id);
+    const effect = {
+      id: effectDraft.id,
+      type: effectDraft.type,
+      seq: draft.effectSeq,
+      cursor: draft.effectSeq,
+      commandId: command.id,
+      commandType: command.type,
+      payload: effectDraft.payload,
+      timestampMs,
+      ...effectDraft.processId === void 0 ? {} : { processId: effectDraft.processId },
+      ...effectDraft.correlationId === void 0 ? {} : { correlationId: effectDraft.correlationId },
+      ...effectDraft.causationId === void 0 ? {} : { causationId: effectDraft.causationId },
+      ...effectDraft.metadata === void 0 ? {} : { metadata: effectDraft.metadata }
+    };
+    effects.push(effect);
+    emit({ kind: "effect-request", effect });
+  }
+  emitProcessStatus(draft, emit, command, "accepted", events.length, effects.length);
+  emitProcessAudit(draft, emit, command, "success", events, effects, void 0, void 0);
+  emit({ kind: "cursor", cursor: processCursorOf(draft) });
+  return draft;
+}
+function processProjection(graph, runtime, name, factory, select) {
+  return graph.node(
+    [runtime],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const selected = select(raw);
+        if (selected !== void 0) ctx.down([["DATA", selected]]);
+      }
+    },
+    { name, factory, completeWhenDepsComplete: false, errorWhenDepsError: false }
+  );
+}
+function parseProcessCommand(value) {
+  if (!isObjectRecord(value)) return "processBundle: command fact must be an object";
+  if (typeof value.id !== "string" || value.id.length === 0) {
+    return "processBundle: command id must be a non-empty string";
+  }
+  if (typeof value.type !== "string" || value.type.length === 0) {
+    return "processBundle: command type must be a non-empty string";
+  }
+  return {
+    id: value.id,
+    type: value.type,
+    payload: value.payload,
+    ...typeof value.processId === "string" ? { processId: value.processId } : {},
+    ...typeof value.correlationId === "string" ? { correlationId: value.correlationId } : {},
+    ...typeof value.causationId === "string" ? { causationId: value.causationId } : {},
+    ...isObjectRecord(value.metadata) ? { metadata: value.metadata } : {}
+  };
+}
+function prepareProcessEvents(command, state, drafts) {
+  if (!Array.isArray(drafts)) return "processBundle: events must be an array";
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (let i = 0; i < drafts.length; i += 1) {
+    const draft = drafts[i];
+    if (!isObjectRecord(draft) || typeof draft.type !== "string" || draft.type.length === 0) {
+      return "processBundle: event draft must have a non-empty type";
+    }
+    const id = typeof draft.id === "string" && draft.id.length > 0 ? draft.id : `${command.id}:event:${state.eventSeq + i + 1}`;
+    if (seen.has(id)) return `processBundle: duplicate event '${id}'`;
+    if (state.seenEventIds.includes(id)) return `processBundle: duplicate event '${id}'`;
+    seen.add(id);
+    out.push({
+      id,
+      type: draft.type,
+      payload: draft.payload,
+      ...typeof draft.processId === "string" ? { processId: draft.processId } : {},
+      ...typeof draft.correlationId === "string" ? { correlationId: draft.correlationId } : {},
+      ...typeof draft.causationId === "string" ? { causationId: draft.causationId } : {},
+      ...isObjectRecord(draft.metadata) ? { metadata: draft.metadata } : {}
+    });
+  }
+  return out;
+}
+function prepareProcessEffects(command, state, drafts) {
+  if (!Array.isArray(drafts)) return "processBundle: effects must be an array";
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (let i = 0; i < drafts.length; i += 1) {
+    const draft = drafts[i];
+    if (!isObjectRecord(draft) || typeof draft.type !== "string" || draft.type.length === 0) {
+      return "processBundle: effect draft must have a non-empty type";
+    }
+    const id = typeof draft.id === "string" && draft.id.length > 0 ? draft.id : `${command.id}:effect:${state.effectSeq + i + 1}`;
+    if (seen.has(id)) return `processBundle: duplicate effect '${id}'`;
+    if (state.seenEffectIds.includes(id)) return `processBundle: duplicate effect '${id}'`;
+    seen.add(id);
+    out.push({
+      id,
+      type: draft.type,
+      payload: draft.payload,
+      ...typeof draft.processId === "string" ? { processId: draft.processId } : {},
+      ...typeof draft.correlationId === "string" ? { correlationId: draft.correlationId } : {},
+      ...typeof draft.causationId === "string" ? { causationId: draft.causationId } : {},
+      ...isObjectRecord(draft.metadata) ? { metadata: draft.metadata } : {}
+    });
+  }
+  return out;
+}
+function emitProcessFailure(state, emit, raw, command, code, message) {
+  state.errorCount += 1;
+  const cursor = processCursorOf(state);
+  const error = {
+    code,
+    message,
+    command: raw,
+    ...command === void 0 ? {} : { commandId: command.id, commandType: command.type },
+    cursor
+  };
+  emit({ kind: "error", error });
+  emitProcessStatus(state, emit, command, "rejected", 0, 0, code);
+  emitProcessAudit(state, emit, command, "failure", [], [], code, message);
+  emit({ kind: "cursor", cursor: processCursorOf(state) });
+}
+function emitProcessStatus(state, emit, command, statusState, eventCount, effectCount, errorCode) {
+  emit({
+    kind: "status",
+    status: {
+      state: statusState,
+      ...command === void 0 ? {} : { commandId: command.id, commandType: command.type },
+      eventCount,
+      effectCount,
+      ...errorCode === void 0 ? {} : { errorCode },
+      cursor: processCursorOf(state)
+    }
+  });
+}
+function emitProcessAudit(state, emit, command, outcome, events, effects, errorCode, errorMessage2) {
+  state.auditSeq += 1;
+  emit({
+    kind: "audit",
+    audit: {
+      seq: state.auditSeq,
+      ...command === void 0 ? {} : { commandId: command.id, commandType: command.type },
+      outcome,
+      eventIds: events.map((event) => event.id),
+      eventTypes: events.map((event) => event.type),
+      effectIds: effects.map((effect) => effect.id),
+      effectTypes: effects.map((effect) => effect.type),
+      ...errorCode === void 0 ? {} : { errorCode },
+      ...errorMessage2 === void 0 ? {} : { errorMessage: errorMessage2 },
+      cursor: processCursorOf(state)
+    }
+  });
+}
+function processCursorOf(state) {
+  return {
+    eventSeq: state.eventSeq,
+    effectSeq: state.effectSeq,
+    commandCount: state.commandCount,
+    errorCount: state.errorCount,
+    auditSeq: state.auditSeq
+  };
+}
+function cloneProcessState(state) {
+  if (typeof state !== "object" || state === null) return { ok: true, value: state };
+  try {
+    if (typeof globalThis.structuredClone === "function") {
+      return { ok: true, value: globalThis.structuredClone(state) };
+    }
+    return { ok: true, value: JSON.parse(JSON.stringify(state)) };
+  } catch (error) {
+    return {
+      ok: false,
+      message: `processBundle: state must be cloneable before reducer execution (${errorMessage(error)})`
+    };
+  }
+}
+function readTimestampMs(now) {
+  try {
+    const timestampMs = now();
+    if (!Number.isFinite(timestampMs)) return "processBundle: now() must return a finite number";
+    return timestampMs;
+  } catch (error) {
+    return errorMessage(error);
+  }
+}
+function rethrowGraphRuntimeInvariant(error) {
+  const message = errorMessage(error);
+  if (message.includes("R-reentrancy") || message.includes("R-rewire") || message.includes("R-graph-domain") || message.includes("D37") || message.includes("D22") || message.includes("different graph") || message.includes("cross-graph") || message.includes("wire bridge") || message.includes("mid-fn topology mutation") || message.includes("reentrant dep mutation") || message.includes("feedback cycle")) {
+    throw error;
+  }
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export {
+  backoffDelayMs,
+  breakerBundle,
+  constantBackoff,
+  nextRetryDelayMs,
+  noBackoff,
+  processBundle,
+  processEffectRunner,
+  rateLimitBundle,
+  retryPolicy,
+  retryStatusBundle,
+  shouldRetry,
+  timeoutBundle
+};
+//# sourceMappingURL=index.js.map