@geonosis/workflows 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1751 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ABANDONED_SWEEP_LIMIT: () => ABANDONED_SWEEP_LIMIT,
+  COMPENSATION_PREFIX: () => COMPENSATION_PREFIX,
+  DEFAULT_STEP_BUDGET: () => DEFAULT_STEP_BUDGET,
+  EVENT_BATCH_LIMIT: () => EVENT_BATCH_LIMIT,
+  EVENT_SWEEP_GRACE_MS: () => EVENT_SWEEP_GRACE_MS,
+  EVENT_SWEEP_LIMIT: () => EVENT_SWEEP_LIMIT,
+  IdempotencyKeyHeldError: () => IdempotencyKeyHeldError,
+  LIFECYCLE_EVENTS: () => LIFECYCLE_EVENTS,
+  RESERVED_STEP_NAMES: () => RESERVED_STEP_NAMES,
+  RUN_OUTCOMES: () => RUN_OUTCOMES,
+  RUN_STATUSES: () => RUN_STATUSES,
+  RunCancelledError: () => RunCancelledError,
+  RunFailedError: () => RunFailedError,
+  STEP_STATUSES: () => STEP_STATUSES,
+  WorkflowsError: () => WorkflowsError,
+  compensationIdempotencyKey: () => compensationIdempotencyKey,
+  compensationStepName: () => compensationStepName,
+  createInProcessSink: () => createInProcessSink,
+  createInlineRunner: () => createInlineRunner,
+  createMemoryJournal: () => createMemoryJournal,
+  createMemoryPlatform: () => createMemoryPlatform,
+  createMemorySink: () => createMemorySink,
+  createRunEmitter: () => createRunEmitter,
+  createRuntime: () => createRuntime,
+  createStep: () => createStep,
+  createStepPrimitive: () => createStepPrimitive,
+  createWorkflow: () => createWorkflow,
+  dispatchEvents: () => dispatchEvents,
+  entrypointFor: () => entrypointFor,
+  envelopeId: () => envelopeId,
+  executeDurable: () => executeDurable,
+  executeRun: () => executeRun,
+  handleQueue: () => handleQueue,
+  handleScheduled: () => handleScheduled,
+  journalConformance: () => journalConformance,
+  lifecycleEnvelopeId: () => lifecycleEnvelopeId,
+  messageOf: () => messageOf,
+  parallelize: () => parallelize,
+  stepDefinitionOf: () => stepDefinitionOf,
+  stepIdempotencyKey: () => stepIdempotencyKey,
+  sweepAbandonedRuns: () => sweepAbandonedRuns,
+  sweepEventOutbox: () => sweepEventOutbox,
+  workflowDefinitionOf: () => workflowDefinitionOf
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/contract.ts
+var LIFECYCLE_EVENTS = {
+  compensated: "workflow.compensated",
+  completed: "workflow.completed"
+};
+var RUN_STATUSES = ["cancelled", "compensated", "completed", "failed", "running"];
+var RUN_OUTCOMES = ["cancelled", "compensated", "completed", "failed"];
+var STEP_STATUSES = ["compensated", "completed", "failed"];
+var RESERVED_STEP_NAMES = {
+  emitEvents: "emit-events",
+  finishRun: "finish-run"
+};
+var COMPENSATION_PREFIX = "compensate:";
+var compensationStepName = (stepName) => `${COMPENSATION_PREFIX}${stepName}`;
+var DEFAULT_STEP_BUDGET = {
+  retry: { backoff: "exponential", delay: "10 seconds", limit: 3 },
+  timeout: "2 minutes"
+};
+
+// src/duration.ts
+var UNIT_MILLISECONDS = {
+  day: 864e5,
+  days: 864e5,
+  hour: 36e5,
+  hours: 36e5,
+  millisecond: 1,
+  milliseconds: 1,
+  minute: 6e4,
+  minutes: 6e4,
+  ms: 1,
+  second: 1e3,
+  seconds: 1e3
+};
+var DURATION = /^\s*(\d+(?:\.\d+)?)\s*([a-z]+)\s*$/i;
+var millisecondsOf = (duration) => {
+  if (typeof duration === "number") return duration;
+  const match = DURATION.exec(duration);
+  const unit = match?.[2] === void 0 ? void 0 : UNIT_MILLISECONDS[match[2].toLowerCase()];
+  if (match?.[1] === void 0 || unit === void 0) {
+    throw new Error(`"${duration}" is not a duration this can read`);
+  }
+  return Number(match[1]) * unit;
+};
+
+// src/inline-runner.ts
+var delayBefore = (retry, attempt) => {
+  const base = millisecondsOf(retry.delay ?? 0);
+  if (retry.backoff === "linear") return base * attempt;
+  if (retry.backoff === "exponential") return base * 2 ** (attempt - 1);
+  return base;
+};
+var createInlineRunner = (options = {}) => {
+  const sleep = options.sleep ?? ((milliseconds) => milliseconds <= 0 ? Promise.resolve() : new Promise((resolve2) => setTimeout(resolve2, milliseconds)));
+  return async (_name, budget, run) => {
+    const retry = budget === DEFAULT_STEP_BUDGET ? void 0 : budget.retry;
+    const attempts = (retry?.limit ?? 0) + 1;
+    let refusal;
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+      try {
+        return await run({ attempt });
+      } catch (error) {
+        refusal = error;
+        if (attempt === attempts || !retry) break;
+        await sleep(delayBefore(retry, attempt));
+      }
+    }
+    throw refusal;
+  };
+};
+
+// src/emit-door.ts
+var import_events = require("@geonosis/events");
+
+// src/identity.ts
+var stepIdempotencyKey = (runId, seq) => `${runId}:${seq}`;
+var compensationIdempotencyKey = (runId, seq) => `${runId}:${seq}:undo`;
+var envelopeId = (runId, ordinal) => `${runId}:${ordinal}`;
+var lifecycleEnvelopeId = (runId, closure) => `${runId}:${closure}`;
+
+// src/emit-door.ts
+var createRunEmitter = (config, run) => {
+  const carried = config.extensionsOf?.(run) ?? {};
+  const extensions = Object.keys(carried);
+  const now = config.now ?? Date.now;
+  const doorMinting = (newId) => {
+    const door = (0, import_events.createEmitDoor)({ extensions, newId, now, source: config.source });
+    return (type, payload) => door.emit(type, payload, carried);
+  };
+  let ordinal = 0;
+  const emission = doorMinting(() => {
+    const id = envelopeId(run.runId, ordinal);
+    ordinal += 1;
+    return id;
+  });
+  return {
+    closure: (closure, type, payload) => doorMinting(() => lifecycleEnvelopeId(run.runId, closure))(type, payload),
+    emission
+  };
+};
+
+// src/outbox.ts
+var EVENT_BATCH_LIMIT = 100;
+var dispatchEvents = async (options) => {
+  let delivered = 0;
+  for (let index = 0; index < options.envelopes.length; index += EVENT_BATCH_LIMIT) {
+    const batch = options.envelopes.slice(index, index + EVENT_BATCH_LIMIT);
+    await options.sink.sendBatch(batch.map((body) => ({ body })));
+    await options.markDispatched(batch.map((message) => message.id));
+    delivered += batch.length;
+  }
+  return delivered;
+};
+var EVENT_SWEEP_LIMIT = 500;
+var EVENT_SWEEP_GRACE_MS = 6e4;
+var sweepEventOutbox = async (options) => {
+  const stranded = await options.journal.listUndispatchedEvents({
+    before: (options.now ?? Date.now()) - (options.olderThanMs ?? EVENT_SWEEP_GRACE_MS),
+    limit: options.limit ?? EVENT_SWEEP_LIMIT
+  });
+  const byTenant = /* @__PURE__ */ new Map();
+  for (const row of stranded) {
+    const carried = byTenant.get(row.tenantId) ?? [];
+    carried.push(row.envelope);
+    byTenant.set(row.tenantId, carried);
+  }
+  let delivered = 0;
+  for (const [tenantId, envelopes] of byTenant) {
+    delivered += await dispatchEvents({
+      envelopes,
+      markDispatched: (ids) => options.journal.markEventsDispatched({ ids, tenantId }),
+      sink: options.sink
+    });
+  }
+  return delivered;
+};
+var ABANDONED_SWEEP_LIMIT = 200;
+var sweepAbandonedRuns = async (options) => {
+  const error = `abandoned: no finish after ${options.olderThanMs}ms`;
+  const abandoned = await options.journal.listAbandonedRuns({
+    execution: "inline",
+    limit: options.limit ?? ABANDONED_SWEEP_LIMIT,
+    startedBefore: (options.now ?? Date.now()) - options.olderThanMs
+  });
+  for (const run of abandoned) {
+    const announcement = options.emit ? createRunEmitter(options.emit, { actor: null, ...run }).closure(
+      "swept",
+      LIFECYCLE_EVENTS.compensated,
+      { error, name: run.name, outcome: "failed", runId: run.runId }
+    ) : void 0;
+    await options.journal.finishRun({
+      error,
+      ...announcement === void 0 ? {} : { events: [announcement] },
+      runId: run.runId,
+      status: "failed",
+      tenantId: run.tenantId
+    });
+  }
+  return abandoned.length;
+};
+
+// src/parallelize.ts
+var parallelize = (...calls) => Promise.all(calls);
+
+// src/errors.ts
+var messageOf = (error) => error instanceof Error ? error.message : String(error);
+var WorkflowsError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "WorkflowsError";
+  }
+};
+var describeFailure = (params) => {
+  const where = params.failedStep ?? "its body";
+  if (params.outcome === "cancelled") {
+    return `workflow ${params.workflowName} was cancelled at ${where} and was fully undone`;
+  }
+  const undone = params.outcome === "compensated" ? "was compensated" : "could not be fully compensated";
+  return `workflow ${params.workflowName} failed at ${where} and ${undone}: ${messageOf(params.cause)}`;
+};
+var RunFailedError = class extends WorkflowsError {
+  /** A literal tag beside `name`, so this slots into tagged-union error handling with no adapter. */
+  _tag = "RunFailedError";
+  /** The steps whose undo came back, in the order they were undone. */
+  compensated;
+  /** The steps whose undo refused. Non-empty means something is still standing. */
+  failedCompensations;
+  failedStep;
+  outcome;
+  runId;
+  workflowName;
+  constructor(params) {
+    super(describeFailure(params), { cause: params.cause });
+    this.name = "RunFailedError";
+    this.runId = params.runId;
+    this.workflowName = params.workflowName;
+    this.failedStep = params.failedStep;
+    this.outcome = params.outcome;
+    this.compensated = params.compensated;
+    this.failedCompensations = params.failedCompensations;
+  }
+};
+var RunCancelledError = class extends WorkflowsError {
+  _tag = "RunCancelledError";
+  runId;
+  constructor(runId) {
+    super(`run ${runId} was asked to stop`);
+    this.name = "RunCancelledError";
+    this.runId = runId;
+  }
+};
+var IdempotencyKeyHeldError = class extends WorkflowsError {
+  idempotencyKey;
+  tenantId;
+  constructor(params) {
+    super(`the idempotency key "${params.idempotencyKey}" is already held`);
+    this.name = "IdempotencyKeyHeldError";
+    this.tenantId = params.tenantId;
+    this.idempotencyKey = params.idempotencyKey;
+  }
+};
+
+// src/runtime.ts
+var UNSCOPED_TENANT = "default";
+var isWorkflow = (candidate) => typeof candidate === "object" && candidate !== null && typeof candidate.name === "string" && typeof candidate.run === "function";
+var createRuntime = (config) => {
+  const runtime = {
+    journal: config.journal,
+    tenantId: config.tenantId ?? UNSCOPED_TENANT,
+    ...config.actor === void 0 ? {} : { actor: config.actor },
+    ...config.context === void 0 ? {} : { context: config.context },
+    ...config.emit === void 0 ? {} : { emit: config.emit },
+    ...config.events === void 0 ? {} : { events: config.events },
+    ...config.observer === void 0 ? {} : { observer: config.observer },
+    ...config.scope === void 0 ? {} : { scope: config.scope }
+  };
+  return {
+    bind: (definitions) => {
+      const bound = {};
+      for (const [key, definition] of Object.entries(definitions)) {
+        if (!isWorkflow(definition)) {
+          throw new WorkflowsError(
+            `"${key}" is not a workflow: it did not come from createWorkflow, so there is nothing to open a run for. Bind the definition rather than a wrapper around it.`
+          );
+        }
+        bound[key] = {
+          name: definition.name,
+          run: ((given) => definition.run({ ...given, runtime }))
+        };
+      }
+      return bound;
+    },
+    for: (narrower) => createRuntime({
+      ...config,
+      actor: narrower.actor === void 0 ? config.actor : narrower.actor,
+      // A worker knows its bindings and nothing about who is asking; a request knows the tenant
+      // and nothing about bindings. So a layer ADDS what it knows: replacing would make the last
+      // caller responsible for everything every earlier one had put there.
+      context: { ...config.context, ...narrower.context },
+      tenantId: narrower.tenantId ?? config.tenantId
+    }),
+    runtime
+  };
+};
+
+// src/run-context.ts
+var import_node_async_hooks = require("async_hooks");
+var frames = new import_node_async_hooks.AsyncLocalStorage();
+var runInFrame = (frame, body) => frames.run(frame, body);
+var frameFor = (stepName) => {
+  const frame = frames.getStore();
+  if (!frame) {
+    throw new WorkflowsError(
+      `the step "${stepName}" was called outside a workflow run. A step is journalled, retried and compensated as part of a run, so there is nowhere for this call to be recorded \u2014 call it inside a createWorkflow body.`
+    );
+  }
+  return frame;
+};
+
+// src/engine.ts
+var watch = (hook, fact) => {
+  if (!hook) return;
+  try {
+    hook(fact());
+  } catch {
+  }
+};
+var UNSCOPED = (body) => body();
+var executeRun = async (execution) => {
+  const { name, runId, runner, runtime } = execution;
+  const held = [];
+  const emitter = runtime.emit ? createRunEmitter(runtime.emit, {
+    actor: runtime.actor ?? null,
+    name,
+    runId,
+    tenantId: runtime.tenantId
+  }) : void 0;
+  const undos = [];
+  const inflight = [];
+  const namesUsed = /* @__PURE__ */ new Map();
+  const compensated = [];
+  const failedCompensations = [];
+  let seq = 0;
+  let failedStep = null;
+  let cancelledAfter = null;
+  const startedAt = Date.now();
+  watch(runtime.observer?.onRunStart, () => ({ name, runId, tenantId: runtime.tenantId }));
+  const scopeFor = () => execution.execution === "durable" && runtime.scope ? runtime.scope.perStep() : UNSCOPED;
+  const contextFor = (idempotencyKey, attempt) => ({
+    ...runtime.context,
+    attempt,
+    idempotencyKey,
+    runId,
+    tenantId: runtime.tenantId
+  });
+  const runStep = async (step, input) => {
+    if (cancelledAfter !== null) throw new RunCancelledError(runId);
+    const used = (namesUsed.get(step.name) ?? 0) + 1;
+    namesUsed.set(step.name, used);
+    const recordedName = used === 1 ? step.name : `${step.name}#${used}`;
+    if (execution.unwindingBegan === true && execution.completedSteps?.has(recordedName) !== true) {
+      throw new WorkflowsError(
+        `the run had already begun unwinding when step '${recordedName}' was reached`
+      );
+    }
+    const current = seq;
+    seq += 1;
+    let cancellationRequested = false;
+    const output2 = await runner(recordedName, step.budget, async ({ attempt }) => {
+      const stepStartedAt = Date.now();
+      watch(runtime.observer?.onStepStart, () => ({
+        attempt,
+        name: recordedName,
+        runId,
+        seq: current
+      }));
+      try {
+        const produced = await scopeFor()(
+          async () => step.invoke(input, contextFor(stepIdempotencyKey(runId, current), attempt))
+        );
+        const recorded = await runtime.journal.recordStep({
+          attempt,
+          name: recordedName,
+          output: produced,
+          runId,
+          seq: current,
+          status: "completed",
+          tenantId: runtime.tenantId
+        });
+        cancellationRequested = recorded.cancellationRequested;
+        watch(runtime.observer?.onStepEnd, () => ({
+          attempt,
+          durationMs: Date.now() - stepStartedAt,
+          name: recordedName,
+          runId,
+          seq: current,
+          status: "completed"
+        }));
+        return produced;
+      } catch (error) {
+        failedStep = recordedName;
+        await runtime.journal.recordStep({
+          attempt,
+          error: messageOf(error),
+          name: recordedName,
+          runId,
+          seq: current,
+          status: "failed",
+          tenantId: runtime.tenantId
+        });
+        watch(runtime.observer?.onStepEnd, () => ({
+          attempt,
+          durationMs: Date.now() - stepStartedAt,
+          name: recordedName,
+          runId,
+          seq: current,
+          status: "failed"
+        }));
+        throw error;
+      }
+    });
+    const declaredCompensate = step.compensate;
+    if (declaredCompensate) {
+      undos.push({
+        budget: step.budget,
+        name: recordedName,
+        run: (undoContext, reason) => declaredCompensate(output2, undoContext, reason),
+        seq: current
+      });
+    }
+    if (cancellationRequested) {
+      cancelledAfter = recordedName;
+      throw new RunCancelledError(runId);
+    }
+    return output2;
+  };
+  const trackedStep = (step, input) => {
+    const running = runStep(step, input);
+    const tracked = {
+      name: step.name,
+      promise: running.then(
+        (value) => {
+          tracked.settled = true;
+          return value;
+        },
+        (error) => {
+          tracked.settled = true;
+          throw error;
+        }
+      ),
+      settled: false
+    };
+    tracked.promise.catch(() => void 0);
+    inflight.push(tracked);
+    return running;
+  };
+  const frame = {
+    call: trackedStep,
+    runId,
+    workflowName: name
+  };
+  const compensate = async (cause) => {
+    await Promise.allSettled(inflight.map((tracked) => tracked.promise));
+    let outcome = "compensated";
+    for (const undo of undos.toSorted((left, right) => right.seq - left.seq)) {
+      const current = seq;
+      seq += 1;
+      if (execution.refused?.has(compensationStepName(undo.name)) === true) {
+        outcome = "failed";
+        failedCompensations.push(undo.name);
+        continue;
+      }
+      try {
+        await runner(compensationStepName(undo.name), undo.budget, async ({ attempt }) => {
+          const undoStartedAt = Date.now();
+          watch(runtime.observer?.onCompensationStart, () => ({
+            attempt,
+            name: undo.name,
+            runId,
+            seq: undo.seq
+          }));
+          try {
+            await scopeFor()(async () => {
+              await undo.run(contextFor(compensationIdempotencyKey(runId, undo.seq), attempt), {
+                cause
+              });
+            });
+            await runtime.journal.recordStep({
+              attempt,
+              name: compensationStepName(undo.name),
+              runId,
+              seq: current,
+              status: "compensated",
+              tenantId: runtime.tenantId
+            });
+            compensated.push(undo.name);
+            watch(runtime.observer?.onCompensationEnd, () => ({
+              attempt,
+              durationMs: Date.now() - undoStartedAt,
+              name: undo.name,
+              runId,
+              seq: undo.seq,
+              status: "compensated"
+            }));
+          } catch (error) {
+            await runtime.journal.recordStep({
+              attempt,
+              error: messageOf(error),
+              name: compensationStepName(undo.name),
+              runId,
+              seq: current,
+              status: "failed",
+              tenantId: runtime.tenantId
+            });
+            watch(runtime.observer?.onCompensationEnd, () => ({
+              attempt,
+              durationMs: Date.now() - undoStartedAt,
+              name: undo.name,
+              runId,
+              seq: undo.seq,
+              status: "failed"
+            }));
+            throw error;
+          }
+        });
+      } catch {
+        outcome = "failed";
+        failedCompensations.push(undo.name);
+      }
+    }
+    return outcome;
+  };
+  let output;
+  try {
+    output = await runInFrame(frame, () => execution.invoke(frame));
+    if (cancelledAfter !== null) throw new RunCancelledError(runId);
+    if (execution.unwindingBegan === true) {
+      throw new WorkflowsError("the run had already begun unwinding before this invocation");
+    }
+    const abandoned = inflight.find((tracked) => !tracked.settled);
+    if (abandoned) throw new WorkflowsError(`step '${abandoned.name}' was not awaited`);
+    for (const [type, payload] of execution.announce?.(output) ?? []) {
+      if (!emitter) {
+        throw new WorkflowsError(
+          `the workflow "${name}" announces "${type}", and this runtime was built without an emit door. Give createRuntime an \`emit\` config with the \`source\` that identifies this producer \u2014 it is the one CloudEvents attribute nothing in a run can stand in for.`
+        );
+      }
+      held.push(emitter.emission(type, payload));
+    }
+  } catch (error) {
+    const undone = await compensate(error);
+    const outcome = error instanceof RunCancelledError && undone === "compensated" ? "cancelled" : undone;
+    const announcement = emitter?.closure("compensated", LIFECYCLE_EVENTS.compensated, {
+      error: messageOf(error),
+      name,
+      outcome,
+      runId
+    });
+    await runner(
+      RESERVED_STEP_NAMES.finishRun,
+      DEFAULT_STEP_BUDGET,
+      () => runtime.journal.finishRun({
+        error: messageOf(error),
+        ...announcement === void 0 ? {} : { events: [announcement] },
+        runId,
+        status: outcome,
+        tenantId: runtime.tenantId
+      })
+    );
+    watch(runtime.observer?.onRunEnd, () => ({
+      durationMs: Date.now() - startedAt,
+      events: announcement ? [announcement.type] : [],
+      name,
+      runId,
+      status: outcome
+    }));
+    throw new RunFailedError({
+      cause: error,
+      compensated,
+      failedCompensations,
+      failedStep: failedStep ?? cancelledAfter,
+      outcome,
+      runId,
+      workflowName: name
+    });
+  }
+  const closure = emitter?.closure("completed", LIFECYCLE_EVENTS.completed, { name, runId });
+  if (closure) held.push(closure);
+  await runner(
+    RESERVED_STEP_NAMES.finishRun,
+    DEFAULT_STEP_BUDGET,
+    () => runtime.journal.finishRun({
+      events: held,
+      output,
+      runId,
+      status: "completed",
+      tenantId: runtime.tenantId
+    })
+  );
+  watch(runtime.observer?.onRunEnd, () => ({
+    durationMs: Date.now() - startedAt,
+    events: held.map((envelope) => envelope.type),
+    name,
+    runId,
+    status: "completed"
+  }));
+  const sink = runtime.events;
+  if (sink && held.length > 0) {
+    await runner(
+      RESERVED_STEP_NAMES.emitEvents,
+      DEFAULT_STEP_BUDGET,
+      () => dispatchEvents({
+        envelopes: held,
+        markDispatched: (ids) => runtime.journal.markEventsDispatched({ ids, tenantId: runtime.tenantId }),
+        sink
+      })
+    ).catch(() => void 0);
+  }
+  return output;
+};
+
+// src/canonical.ts
+var canonicalise = (value) => {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "undefined";
+  if (Array.isArray(value)) return `[${value.map((item) => canonicalise(item)).join(",")}]`;
+  const entries = Object.entries(value).filter(([, item]) => item !== void 0).toSorted(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${canonicalise(item)}`);
+  return `{${entries.join(",")}}`;
+};
+var OFFSET_BASIS = 0xcbf29ce484222325n;
+var PRIME = 0x00000100000001b3n;
+var MASK = 0xffffffffffffffffn;
+var stableHash = (value) => {
+  const rendered = canonicalise(value);
+  let hash = OFFSET_BASIS;
+  for (let index = 0; index < rendered.length; index += 1) {
+    hash ^= BigInt(rendered.charCodeAt(index));
+    hash = hash * PRIME & MASK;
+  }
+  return hash.toString(16).padStart(16, "0");
+};
+
+// src/create-workflow.ts
+var inlineRunner = createInlineRunner();
+var isOne = (announced) => typeof announced[0] === "string";
+var announcementsOf = (announce, output) => {
+  const announced = announce?.(output);
+  if (!announced) return [];
+  return isOne(announced) ? [announced] : announced;
+};
+var DEFINITION = /* @__PURE__ */ Symbol.for("geonosis.workflows.workflow");
+var workflowDefinitionOf = (workflow) => {
+  const carried = workflow[DEFINITION];
+  if (!carried) {
+    throw new WorkflowsError(
+      "this is not a workflow: it did not come from createWorkflow, so there is no body to carry out and no name to journal it under."
+    );
+  }
+  return carried;
+};
+var idempotencyKeyFor = (name, idempotent, input) => {
+  if (idempotent === void 0) return null;
+  if (idempotent === true) return `${name}:${stableHash(input)}`;
+  return idempotent(input);
+};
+var createWorkflow = (name, body, options = {}) => {
+  const execution = options.execution ?? "inline";
+  const run = async (given) => {
+    const { input, runtime } = given;
+    if (execution === "durable") {
+      throw new WorkflowsError(
+        `the workflow "${name}" is declared \`execution: 'durable'\`, and \`.run()\` is the inline door: it holds one request open and never replays. Open the run with \`insertRun({ execution: 'durable' })\` and hand the workflow to the platform's entrypoint, which drives \`executeDurable\`.`
+      );
+    }
+    if (options.announce && !runtime.emit) {
+      throw new WorkflowsError(
+        `the workflow "${name}" announces, and this runtime was built without an emit door. Give createRuntime an \`emit\` config with the \`source\` that identifies this producer \u2014 it is the one CloudEvents attribute nothing in a run can stand in for.`
+      );
+    }
+    const idempotencyKey = given.idempotencyKey ?? idempotencyKeyFor(name, options.idempotent, input);
+    let runId;
+    try {
+      runId = await runtime.journal.insertRun({
+        execution: "inline",
+        idempotencyKey,
+        input,
+        name,
+        parentRunId: given.parentRunId ?? null,
+        tenantId: runtime.tenantId
+      });
+    } catch (error) {
+      if (idempotencyKey === null) throw error;
+      const held = await runtime.journal.findRunByIdempotencyKey({
+        idempotencyKey,
+        tenantId: runtime.tenantId
+      });
+      if (!held) throw error;
+      return { deduplicated: true, ok: true, result: held.output, runId: held.id };
+    }
+    try {
+      const result = await executeRun({
+        announce: (produced) => announcementsOf(options.announce, produced),
+        execution: "inline",
+        invoke: (frame) => body(input, {
+          ...runtime.context,
+          runId: frame.runId,
+          tenantId: runtime.tenantId
+        }),
+        name,
+        runId,
+        runner: inlineRunner,
+        runtime
+      });
+      return { deduplicated: false, ok: true, result, runId };
+    } catch (error) {
+      if (!(error instanceof RunFailedError)) throw error;
+      return { error, ok: false, result: void 0, runId };
+    }
+  };
+  const definition = {
+    announce: (produced) => announcementsOf(options.announce, produced),
+    body,
+    execution,
+    name
+  };
+  return {
+    [DEFINITION]: definition,
+    execution,
+    name,
+    run: async (given) => {
+      const answered = await run(given);
+      if (!answered.ok && given.throwOnError !== false) throw answered.error;
+      return answered;
+    }
+  };
+};
+
+// src/durable.ts
+var entryStateOf = async (journal, tenantId, runId) => {
+  const run = await journal.getRun({ runId, tenantId });
+  if (!run || run.status === "running") return { closed: false };
+  return { closed: true, output: run.output, status: run.status };
+};
+var trailAtEntry = async (journal, tenantId, runId) => {
+  const trail = await journal.listRunSteps({ runId, tenantId });
+  const compensations = trail.filter((entry) => entry.name.startsWith(COMPENSATION_PREFIX));
+  return {
+    completedSteps: new Set(
+      trail.filter((entry) => entry.status === "completed").filter((entry) => !entry.name.startsWith(COMPENSATION_PREFIX)).map((entry) => entry.name)
+    ),
+    refused: new Set(
+      compensations.filter((entry) => entry.status === "failed").map((entry) => entry.name)
+    ),
+    unwindingBegan: compensations.length > 0
+  };
+};
+var executeDurable = async (execution) => {
+  const { input, runId, runtime, step, workflow } = execution;
+  const definition = workflowDefinitionOf(workflow);
+  if (definition.execution !== "durable") {
+    throw new WorkflowsError(
+      `the workflow "${definition.name}" is declared \`execution: '${definition.execution}'\` and this is the durable door. Declare it \`execution: 'durable'\` \u2014 a body written for one request is replayed here, and a read it never journalled answers differently the second time.`
+    );
+  }
+  const entry = await entryStateOf(runtime.journal, runtime.tenantId, runId);
+  if (entry.closed) {
+    if (entry.status === "completed") return entry.output;
+    throw new RunFailedError({
+      cause: new WorkflowsError(
+        `run ${runId} was already ${entry.status} when this invocation began`
+      ),
+      compensated: [],
+      failedCompensations: [],
+      failedStep: null,
+      outcome: entry.status,
+      runId,
+      workflowName: definition.name
+    });
+  }
+  const trail = await trailAtEntry(runtime.journal, runtime.tenantId, runId);
+  return executeRun({
+    ...trail,
+    announce: definition.announce,
+    execution: "durable",
+    invoke: (frame) => definition.body(input, {
+      ...runtime.context,
+      runId: frame.runId,
+      tenantId: runtime.tenantId
+    }),
+    name: definition.name,
+    runId,
+    // The budget travels with the name, so the PLATFORM does the retrying and the waiting. Inline,
+    // the same declaration is spent by the runner holding a request open.
+    runner: (name, budget, run) => step.do(name, budget, run),
+    runtime
+  });
+};
+
+// src/cloudflare/step-primitive.ts
+var platformConfigOf = (budget) => ({
+  ...budget.retry === void 0 ? {} : {
+    retries: {
+      ...budget.retry.backoff === void 0 ? {} : { backoff: budget.retry.backoff },
+      delay: budget.retry.delay ?? 0,
+      limit: budget.retry.limit
+    }
+  },
+  ...budget.timeout === void 0 ? {} : { timeout: budget.timeout }
+});
+var createStepPrimitive = (step) => ({
+  do: (name, budget, run) => step.do(name, platformConfigOf(budget), run),
+  sleep: (name, duration) => step.sleep(name, duration),
+  waitForEvent: async (name, options) => (await step.waitForEvent(name, options)).payload
+});
+
+// src/cloudflare/entrypoint.ts
+var envOf = (instance) => instance.env;
+var resolve = (source, env) => typeof source === "function" ? source(env) : source;
+var registryOf = (workflows) => {
+  const byName = /* @__PURE__ */ new Map();
+  for (const workflow of workflows) {
+    if (byName.has(workflow.name)) {
+      throw new WorkflowsError(
+        `two workflows are registered as "${workflow.name}". A durable run is dispatched by name, so one of them would never be reached.`
+      );
+    }
+    byName.set(workflow.name, workflow);
+  }
+  return byName;
+};
+var entrypointFor = (options) => {
+  const byEnv = /* @__PURE__ */ new WeakMap();
+  const declared = typeof options.workflows === "function" ? void 0 : registryOf(options.workflows);
+  const registryFor = (env) => {
+    if (declared) return declared;
+    const build = () => registryOf(resolve(options.workflows, env));
+    if (env === null || typeof env !== "object") return build();
+    const cached = byEnv.get(env);
+    if (cached) return cached;
+    const registry = build();
+    byEnv.set(env, registry);
+    return registry;
+  };
+  return class extends options.base {
+    async run(event, step) {
+      const { input, name, runId } = event.payload;
+      const registry = registryFor(envOf(this));
+      const workflow = registry.get(name);
+      if (!workflow) {
+        throw new WorkflowsError(
+          `no durable workflow is registered as "${name}" \u2014 known: ${[...registry.keys()].join(", ")}`
+        );
+      }
+      return executeDurable({
+        input,
+        runId,
+        runtime: options.runtime(envOf(this), event.payload).runtime,
+        step: createStepPrimitive(step),
+        workflow
+      });
+    }
+  };
+};
+
+// src/cloudflare/worker.ts
+var handleQueue = (options = {}) => async (batch) => {
+  for (const message of batch.messages) {
+    try {
+      const envelope = message.body;
+      if (options.seen && await options.seen(envelope.id)) {
+        message.ack();
+        continue;
+      }
+      await options.onEvent?.(envelope);
+      message.ack();
+    } catch {
+      message.retry();
+    }
+  }
+};
+var DEFAULT_ABANDONED_AFTER_MS = 15 * 6e4;
+var scheduledTimeOf = (controller) => {
+  const scheduledTime = controller?.scheduledTime;
+  return typeof scheduledTime === "number" ? scheduledTime : void 0;
+};
+var handleScheduled = (source, options = {}) => (
+  // Cloudflare hands a scheduled handler its env, and there is no request here either, so a factory
+  // has nowhere else to be called from.
+  async (controller, env) => {
+    const runtime = (typeof source === "function" ? source(env) : source).runtime;
+    const now = scheduledTimeOf(controller);
+    const sink = runtime.events;
+    const delivered = sink ? await sweepEventOutbox({
+      journal: runtime.journal,
+      sink,
+      ...now === void 0 ? {} : { now },
+      ...options.outboxOlderThanMs === void 0 ? {} : { olderThanMs: options.outboxOlderThanMs }
+    }) : 0;
+    const abandoned = await sweepAbandonedRuns({
+      journal: runtime.journal,
+      olderThanMs: options.abandonedAfterMs ?? DEFAULT_ABANDONED_AFTER_MS,
+      ...now === void 0 ? {} : { now },
+      ...runtime.emit === void 0 ? {} : { emit: runtime.emit }
+    });
+    return { abandoned, delivered };
+  }
+);
+
+// src/memory-platform.ts
+var createMemoryPlatform = (options = {}) => {
+  const budgets = /* @__PURE__ */ new Map();
+  const calls = [];
+  const checkpoints = options.checkpoints ?? /* @__PURE__ */ new Map();
+  let evictedAt = null;
+  return {
+    budgets,
+    calls,
+    checkpoints,
+    evictAt: (stepName) => {
+      evictedAt = stepName;
+    },
+    primitive: {
+      do: async (name, budget, run) => {
+        calls.push(name);
+        budgets.set(name, budget);
+        if (name === evictedAt) throw new Error(`the instance was evicted at "${name}"`);
+        if (checkpoints.has(name)) return checkpoints.get(name);
+        const attempts = (budget.retry?.limit ?? 0) + 1;
+        let refusal;
+        for (let attempt = 1; attempt <= attempts; attempt += 1) {
+          try {
+            const output = await run({ attempt });
+            checkpoints.set(name, structuredClone(output));
+            return output;
+          } catch (error) {
+            refusal = error;
+          }
+        }
+        throw refusal;
+      },
+      sleep: async () => {
+      },
+      waitForEvent: async (name) => {
+        throw new WorkflowsError(
+          `nothing delivers "${name}" to an in-memory platform. waitForEvent needs a runtime that can hold an instance open; drive this case on a real one.`
+        );
+      }
+    }
+  };
+};
+
+// src/conformance.ts
+var import_conformance = require("@geonosis/conformance");
+var TENANT = "tenant_conformance";
+var OTHER = "tenant_other";
+var envelopeOf = (params) => ({
+  id: params.id,
+  occurredAt: params.occurredAt,
+  payload: { id: params.id },
+  source: "/conformance",
+  type: "conformance.event"
+});
+var required = (journal, method, because) => {
+  const read = journal[method];
+  if (typeof read !== "function") {
+    throw new import_conformance.ConformanceFailure(
+      `this journal has no \`${method}\`, and the engine requires it: ${because}. Implement it \u2014 it is one query \u2014 or the ordering claims this engine makes are not true of runs kept here.`
+    );
+  }
+  return read;
+};
+var journalConformance = (createSubject) => {
+  const withSubject = (name, body) => ({
+    name,
+    run: async () => {
+      await body(await createSubject());
+    }
+  });
+  const openRun = (journal, params = {}) => journal.insertRun({
+    execution: params.execution ?? "inline",
+    idempotencyKey: params.idempotencyKey ?? null,
+    input: { asked: true },
+    name: "conformance.workflow",
+    tenantId: params.tenantId ?? TENANT
+  });
+  const closeRun = (journal, runId, status, output) => journal.finishRun({
+    output,
+    runId,
+    status: status === "running" ? "failed" : status,
+    tenantId: TENANT
+  });
+  return [
+    withSubject("insertRun opens a run that is running", async ({ journal, runStatus }) => {
+      const runId = await openRun(journal);
+      (0, import_conformance.assertThat)(typeof runId === "string" && runId.length > 0, "insertRun must answer with an id");
+      (0, import_conformance.assertIs)(await runStatus({ runId, tenantId: TENANT }), "running", "a new run is running");
+    }),
+    withSubject("insertRun records the run a run was started from", async ({ journal }) => {
+      const parent = await openRun(journal);
+      const child = await journal.insertRun({
+        execution: "inline",
+        idempotencyKey: null,
+        input: {},
+        name: "conformance.child",
+        parentRunId: parent,
+        tenantId: TENANT
+      });
+      (0, import_conformance.assertThat)(child !== parent, "a child run is its own run");
+    }),
+    withSubject("insertRun refuses a key a running run holds", async ({ journal }) => {
+      await openRun(journal, { idempotencyKey: "key-a" });
+      await (0, import_conformance.assertRefuses)(
+        () => openRun(journal, { idempotencyKey: "key-a" }),
+        "a key held by a running run must be refused"
+      );
+    }),
+    // Named rather than merely thrown. Every store words a uniqueness violation differently, and an
+    // engine that had to match on the wording would be wrong on the next store somebody brings.
+    withSubject("insertRun names its refusal", async ({ journal }) => {
+      await openRun(journal, { idempotencyKey: "key-named" });
+      const thrown = await openRun(journal, { idempotencyKey: "key-named" }).catch(
+        (error) => error
+      );
+      (0, import_conformance.assertThat)(
+        thrown instanceof IdempotencyKeyHeldError,
+        "a held key must be refused with IdempotencyKeyHeldError"
+      );
+      (0, import_conformance.assertIs)(
+        thrown.idempotencyKey,
+        "key-named",
+        "the refusal names the key"
+      );
+    }),
+    withSubject("insertRun refuses a key a completed run holds", async ({ journal }) => {
+      const runId = await openRun(journal, { idempotencyKey: "key-b" });
+      await closeRun(journal, runId, "completed", { done: true });
+      await (0, import_conformance.assertRefuses)(
+        () => openRun(journal, { idempotencyKey: "key-b" }),
+        "a key held by a completed run must be refused"
+      );
+    }),
+    ...["failed", "compensated", "cancelled"].map(
+      (status) => withSubject(`insertRun accepts a key a ${status} run has released`, async ({ journal }) => {
+        const runId = await openRun(journal, { idempotencyKey: `key-${status}` });
+        await closeRun(journal, runId, status);
+        const second = await openRun(journal, { idempotencyKey: `key-${status}` });
+        (0, import_conformance.assertThat)(second !== runId, `a ${status} run must release its key`);
+      })
+    ),
+    withSubject("insertRun allows one key per tenant", async ({ journal }) => {
+      await openRun(journal, { idempotencyKey: "shared" });
+      const elsewhere = await openRun(journal, { idempotencyKey: "shared", tenantId: OTHER });
+      (0, import_conformance.assertThat)(elsewhere.length > 0, "another tenant may hold the same key");
+    }),
+    withSubject("insertRun allows any number of runs with no key", async ({ journal }) => {
+      const first = await openRun(journal, { idempotencyKey: null });
+      const second = await openRun(journal, { idempotencyKey: null });
+      (0, import_conformance.assertThat)(first !== second, "runs without a key never collide");
+    }),
+    withSubject("findRunByIdempotencyKey answers with the held run", async ({ journal }) => {
+      const runId = await openRun(journal, { idempotencyKey: "key-c" });
+      await closeRun(journal, runId, "completed", { invoice: 7 });
+      const found = await journal.findRunByIdempotencyKey({
+        idempotencyKey: "key-c",
+        tenantId: TENANT
+      });
+      (0, import_conformance.assertIs)(found?.id, runId, "the held run is the one that claimed the key");
+      (0, import_conformance.assertIs)(found?.status, "completed", "the held run reports its status");
+      (0, import_conformance.assertSame)(found?.output, { invoice: 7 }, "the held run reports its output");
+    }),
+    withSubject(
+      "findRunByIdempotencyKey answers with nothing once released",
+      async ({ journal }) => {
+        const runId = await openRun(journal, { idempotencyKey: "key-d" });
+        await closeRun(journal, runId, "compensated");
+        (0, import_conformance.assertIs)(
+          await journal.findRunByIdempotencyKey({ idempotencyKey: "key-d", tenantId: TENANT }),
+          null,
+          "a released key is held by nobody"
+        );
+      }
+    ),
+    withSubject(
+      "findRunByIdempotencyKey answers with nothing for an unknown key",
+      async ({ journal }) => {
+        (0, import_conformance.assertIs)(
+          await journal.findRunByIdempotencyKey({ idempotencyKey: "nothing", tenantId: TENANT }),
+          null,
+          "an unclaimed key is held by nobody"
+        );
+      }
+    ),
+    withSubject("recordStep writes one row per attempt", async ({ countSteps, journal }) => {
+      const runId = await openRun(journal);
+      for (const attempt of [1, 2]) {
+        await journal.recordStep({
+          attempt,
+          error: "refused",
+          name: "charge",
+          runId,
+          seq: 0,
+          status: "failed",
+          tenantId: TENANT
+        });
+      }
+      (0, import_conformance.assertIs)(await countSteps({ runId, tenantId: TENANT }), 2, "each attempt is its own row");
+    }),
+    withSubject(
+      "recordStep is idempotent on run, seq and attempt",
+      async ({ countSteps, journal }) => {
+        const runId = await openRun(journal);
+        for (let write = 0; write < 3; write += 1) {
+          await journal.recordStep({
+            attempt: 1,
+            name: "charge",
+            output: { chargeId: "ch_1" },
+            runId,
+            seq: 0,
+            status: "completed",
+            tenantId: TENANT
+          });
+        }
+        (0, import_conformance.assertIs)(await countSteps({ runId, tenantId: TENANT }), 1, "the same attempt is one row");
+      }
+    ),
+    withSubject("recordStep reports no cancellation by default", async ({ journal }) => {
+      const runId = await openRun(journal);
+      const recorded = await journal.recordStep({
+        attempt: 1,
+        name: "charge",
+        runId,
+        seq: 0,
+        status: "completed",
+        tenantId: TENANT
+      });
+      (0, import_conformance.assertIs)(recorded.cancellationRequested, false, "nobody asked this run to stop");
+    }),
+    withSubject("recordStep reports a cancellation in the same round trip", async ({ journal }) => {
+      const runId = await openRun(journal);
+      await journal.requestCancellation({ runId, tenantId: TENANT });
+      const recorded = await journal.recordStep({
+        attempt: 1,
+        name: "charge",
+        runId,
+        seq: 0,
+        status: "completed",
+        tenantId: TENANT
+      });
+      (0, import_conformance.assertIs)(recorded.cancellationRequested, true, "the flag comes back with the step");
+    }),
+    withSubject("requestCancellation is accepted by a running run", async ({ journal }) => {
+      const runId = await openRun(journal);
+      (0, import_conformance.assertIs)(
+        await journal.requestCancellation({ runId, tenantId: TENANT }),
+        true,
+        "a running run can be asked to stop"
+      );
+    }),
+    withSubject("requestCancellation is refused by a finished run", async ({ journal }) => {
+      const runId = await openRun(journal);
+      await closeRun(journal, runId, "completed");
+      (0, import_conformance.assertIs)(
+        await journal.requestCancellation({ runId, tenantId: TENANT }),
+        false,
+        "a finished run cannot be stopped"
+      );
+    }),
+    withSubject("requestCancellation is refused for another tenant", async ({ journal }) => {
+      const runId = await openRun(journal);
+      (0, import_conformance.assertIs)(
+        await journal.requestCancellation({ runId, tenantId: OTHER }),
+        false,
+        "a run belongs to one tenant"
+      );
+    }),
+    withSubject("requestCancellation is refused for an unknown run", async ({ journal }) => {
+      (0, import_conformance.assertIs)(
+        await journal.requestCancellation({ runId: "run_nowhere", tenantId: TENANT }),
+        false,
+        "a run nobody has heard of cannot be stopped"
+      );
+    }),
+    withSubject("finishRun closes the run", async ({ journal, runStatus }) => {
+      const runId = await openRun(journal);
+      await closeRun(journal, runId, "completed", { done: true });
+      (0, import_conformance.assertIs)(await runStatus({ runId, tenantId: TENANT }), "completed", "the run is closed");
+    }),
+    withSubject("finishRun writes the events it carries", async ({ journal }) => {
+      const runId = await openRun(journal);
+      await journal.finishRun({
+        events: [envelopeOf({ id: `${runId}:0`, occurredAt: 10 })],
+        runId,
+        status: "completed",
+        tenantId: TENANT
+      });
+      const stranded = await journal.listUndispatchedEvents({ before: 1e3, limit: 10 });
+      (0, import_conformance.assertSame)(
+        stranded.map((row) => row.envelope.id),
+        [`${runId}:0`],
+        "the finish queues the events it was given"
+      );
+    }),
+    withSubject(
+      "finishRun is safe to call twice with the same arguments",
+      async ({ journal, runStatus }) => {
+        const runId = await openRun(journal);
+        const events = [envelopeOf({ id: `${runId}:0`, occurredAt: 10 })];
+        await journal.finishRun({ events, runId, status: "completed", tenantId: TENANT });
+        await journal.finishRun({ events, runId, status: "completed", tenantId: TENANT });
+        const stranded = await journal.listUndispatchedEvents({ before: 1e3, limit: 10 });
+        (0, import_conformance.assertIs)(stranded.length, 1, "an outbox row is written once per envelope id");
+        (0, import_conformance.assertIs)(
+          await runStatus({ runId, tenantId: TENANT }),
+          "completed",
+          "the run is still closed"
+        );
+      }
+    ),
+    /*
+     * A zombie must not come back and take a key somebody else now holds.
+     *
+     * The sequence is real: a sweeper closes an abandoned inline run, which releases its key; a
+     * caller asks for the work again and the new run takes the key; then the first run turns out
+     * not to have been dead after all and finishes. Whoever closed the run first decided how it
+     * ended.
+     */
+    withSubject(
+      "finishRun does not reopen a run somebody else already closed",
+      async ({ journal, runStatus }) => {
+        const abandoned = await openRun(journal, { idempotencyKey: "key-zombie" });
+        await closeRun(journal, abandoned, "failed");
+        const replacement = await openRun(journal, { idempotencyKey: "key-zombie" });
+        await journal.finishRun({
+          output: { late: true },
+          runId: abandoned,
+          status: "completed",
+          tenantId: TENANT
+        });
+        (0, import_conformance.assertIs)(
+          await runStatus({ runId: abandoned, tenantId: TENANT }),
+          "failed",
+          "a run that was already closed keeps the ending it was given"
+        );
+        (0, import_conformance.assertIs)(
+          (await journal.findRunByIdempotencyKey({
+            idempotencyKey: "key-zombie",
+            tenantId: TENANT
+          }))?.id,
+          replacement,
+          "the key stays with the run that holds it"
+        );
+      }
+    ),
+    withSubject("markEventsDispatched takes them out of the sweep", async ({ journal }) => {
+      const runId = await openRun(journal);
+      await journal.finishRun({
+        events: [
+          envelopeOf({ id: `${runId}:0`, occurredAt: 10 }),
+          envelopeOf({ id: `${runId}:1`, occurredAt: 20 })
+        ],
+        runId,
+        status: "completed",
+        tenantId: TENANT
+      });
+      await journal.markEventsDispatched({ ids: [`${runId}:0`], tenantId: TENANT });
+      const stranded = await journal.listUndispatchedEvents({ before: 1e3, limit: 10 });
+      (0, import_conformance.assertSame)(
+        stranded.map((row) => row.envelope.id),
+        [`${runId}:1`],
+        "a stamped row is not swept again"
+      );
+    }),
+    withSubject("listUndispatchedEvents answers oldest first", async ({ journal }) => {
+      const runId = await openRun(journal);
+      await journal.finishRun({
+        events: [
+          envelopeOf({ id: `${runId}:1`, occurredAt: 300 }),
+          envelopeOf({ id: `${runId}:0`, occurredAt: 100 })
+        ],
+        runId,
+        status: "completed",
+        tenantId: TENANT
+      });
+      const stranded = await journal.listUndispatchedEvents({ before: 1e3, limit: 10 });
+      (0, import_conformance.assertSame)(
+        stranded.map((row) => row.envelope.id),
+        [`${runId}:0`, `${runId}:1`],
+        "the sweep starts with the oldest"
+      );
+    }),
+    withSubject("listUndispatchedEvents honours the cutoff", async ({ journal }) => {
+      const runId = await openRun(journal);
+      await journal.finishRun({
+        events: [
+          envelopeOf({ id: `${runId}:0`, occurredAt: 100 }),
+          envelopeOf({ id: `${runId}:1`, occurredAt: 900 })
+        ],
+        runId,
+        status: "completed",
+        tenantId: TENANT
+      });
+      const stranded = await journal.listUndispatchedEvents({ before: 500, limit: 10 });
+      (0, import_conformance.assertSame)(
+        stranded.map((row) => row.envelope.id),
+        [`${runId}:0`],
+        "a row younger than the cutoff is left alone"
+      );
+    }),
+    withSubject("listUndispatchedEvents honours the limit", async ({ journal }) => {
+      const runId = await openRun(journal);
+      await journal.finishRun({
+        events: [0, 1, 2].map(
+          (ordinal) => envelopeOf({ id: `${runId}:${ordinal}`, occurredAt: 100 + ordinal })
+        ),
+        runId,
+        status: "completed",
+        tenantId: TENANT
+      });
+      const stranded = await journal.listUndispatchedEvents({ before: 1e3, limit: 2 });
+      (0, import_conformance.assertIs)(stranded.length, 2, "a sweep takes no more than it asked for");
+    }),
+    withSubject("listUndispatchedEvents crosses every tenant", async ({ journal }) => {
+      const mine = await openRun(journal);
+      const theirs = await openRun(journal, { tenantId: OTHER });
+      await journal.finishRun({
+        events: [envelopeOf({ id: `${mine}:0`, occurredAt: 100 })],
+        runId: mine,
+        status: "completed",
+        tenantId: TENANT
+      });
+      await journal.finishRun({
+        events: [envelopeOf({ id: `${theirs}:0`, occurredAt: 200 })],
+        runId: theirs,
+        status: "completed",
+        tenantId: OTHER
+      });
+      const stranded = await journal.listUndispatchedEvents({ before: 1e3, limit: 10 });
+      (0, import_conformance.assertSame)(
+        stranded.map((row) => row.tenantId),
+        [TENANT, OTHER],
+        "the sweep reads for everybody, and says whose each row is"
+      );
+    }),
+    withSubject(
+      "listAbandonedRuns answers with inline runs older than the cutoff",
+      async ({ journal }) => {
+        const runId = await openRun(journal, { execution: "inline" });
+        const abandoned = await journal.listAbandonedRuns({
+          execution: "inline",
+          limit: 10,
+          startedBefore: Date.now() + 6e4
+        });
+        (0, import_conformance.assertSame)(
+          abandoned,
+          [{ name: "conformance.workflow", runId, tenantId: TENANT }],
+          "an abandoned run is answered with its tenant and its name, because closing it announces it"
+        );
+      }
+    ),
+    withSubject("listAbandonedRuns leaves younger inline runs alone", async ({ journal }) => {
+      await openRun(journal, { execution: "inline" });
+      (0, import_conformance.assertIs)(
+        (await journal.listAbandonedRuns({
+          execution: "inline",
+          limit: 10,
+          startedBefore: Date.now() - 6e4
+        })).length,
+        0,
+        "nothing was old enough"
+      );
+    }),
+    withSubject("listAbandonedRuns never answers with a durable run", async ({ journal }) => {
+      await openRun(journal, { execution: "durable" });
+      (0, import_conformance.assertIs)(
+        (await journal.listAbandonedRuns({
+          execution: "inline",
+          limit: 10,
+          startedBefore: Date.now() + 6e4
+        })).length,
+        0,
+        "a durable run may sleep for a week"
+      );
+    }),
+    withSubject("listAbandonedRuns never answers with a run that ended", async ({ journal }) => {
+      const runId = await openRun(journal, { execution: "inline" });
+      await closeRun(journal, runId, "completed");
+      (0, import_conformance.assertIs)(
+        (await journal.listAbandonedRuns({
+          execution: "inline",
+          limit: 10,
+          startedBefore: Date.now() + 6e4
+        })).length,
+        0,
+        "a closed run needs nobody to close it"
+      );
+    }),
+    withSubject("listAbandonedRuns honours the limit", async ({ journal }) => {
+      for (let opened = 0; opened < 3; opened += 1) await openRun(journal, { execution: "inline" });
+      (0, import_conformance.assertIs)(
+        (await journal.listAbandonedRuns({
+          execution: "inline",
+          limit: 2,
+          startedBefore: Date.now() + 6e4
+        })).length,
+        2,
+        "a sweep takes no more than it asked for"
+      );
+    }),
+    // Closing an abandoned run releases its key like any other ending, so the work can be asked for
+    // again.
+    withSubject("a swept run releases its key", async ({ journal }) => {
+      const runId = await openRun(journal, { execution: "inline", idempotencyKey: "key-swept" });
+      await closeRun(journal, runId, "failed");
+      const second = await openRun(journal, { execution: "inline", idempotencyKey: "key-swept" });
+      (0, import_conformance.assertThat)(second !== runId, "work whose run was abandoned can be asked for again");
+    }),
+    /*
+     * The trail at entry, which the study left optional and this contract requires (CONTRACT.md,
+     * D1). A durable invocation reads it to learn two things: which undos this run already refused,
+     * and whether it had begun unwinding at all. Without them a refused undo is retried after undos
+     * that started later, and a body is carried forward into steps that never ran — the ordering
+     * claims of this engine are simply false about runs kept in a journal that cannot answer.
+     */
+    withSubject("listRunSteps answers with the run trail, oldest first", async ({ journal }) => {
+      const read = required(
+        journal,
+        "listRunSteps",
+        "a durable invocation reads the trail before it runs anything, to learn which undos already refused and whether the run had begun unwinding"
+      );
+      const runId = await openRun(journal);
+      for (const [seq, name, status] of [
+        [0, "reserve", "completed"],
+        [1, "charge", "failed"],
+        [2, "compensate:reserve", "compensated"]
+      ]) {
+        await journal.recordStep({ attempt: 1, name, runId, seq, status, tenantId: TENANT });
+      }
+      (0, import_conformance.assertSame)(
+        (await read({ runId, tenantId: TENANT })).map((step) => `${step.name}:${step.status}`),
+        ["reserve:completed", "charge:failed", "compensate:reserve:compensated"],
+        "the trail reads back in the order it was written"
+      );
+    }),
+    withSubject("listRunSteps keeps one run trail out of another tenant", async ({ journal }) => {
+      const read = required(
+        journal,
+        "listRunSteps",
+        "a trail is read under the tenant whose run it is, like every other read in this contract"
+      );
+      const runId = await openRun(journal);
+      await journal.recordStep({
+        attempt: 1,
+        name: "reserve",
+        runId,
+        seq: 0,
+        status: "completed",
+        tenantId: TENANT
+      });
+      (0, import_conformance.assertIs)(
+        (await read({ runId, tenantId: OTHER })).length,
+        0,
+        "a run belongs to one tenant, and so does its trail"
+      );
+    }),
+    /*
+     * The entry guard. The model shows it clean at these bounds once the trail is read — it is
+     * defence in depth — and it is required because it closes a window the trail cannot see: a run
+     * closed by something that left no compensation behind has no trail to read, and only the run's
+     * own status says it has ended.
+     */
+    withSubject("getRun answers with the run and what it decided", async ({ journal }) => {
+      const read = required(
+        journal,
+        "getRun",
+        "a durable invocation reads the run before it runs anything, so a run closed with no compensation behind it is not carried forward"
+      );
+      const runId = await openRun(journal);
+      await closeRun(journal, runId, "completed", { invoice: 7 });
+      const run = await read({ runId, tenantId: TENANT });
+      (0, import_conformance.assertIs)(run?.id, runId, "the run answers under its own id");
+      (0, import_conformance.assertIs)(run?.name, "conformance.workflow", "the run says what it is");
+      (0, import_conformance.assertIs)(run?.status, "completed", "the run says how it ended");
+      (0, import_conformance.assertSame)(run?.output, { invoice: 7 }, "the run says what it decided");
+    }),
+    withSubject("getRun answers with nothing for a run nobody opened", async ({ journal }) => {
+      const read = required(
+        journal,
+        "getRun",
+        "no record is not a closed record, so the absence has to be answerable"
+      );
+      (0, import_conformance.assertIs)(
+        await read({ runId: "run_nowhere", tenantId: TENANT }),
+        null,
+        "a run that is not there is null, never a refusal"
+      );
+    }),
+    // The strongest promise in the contract, and the only one that needs the store to be broken on
+    // purpose: a run is completed IF AND ONLY IF its events are queued. A journal that writes the
+    // two separately can be interrupted between them, and "completed, audit trail lost" is exactly
+    // the state that must not exist.
+    withSubject("finishRun closes nothing when its events cannot be written", async (subject) => {
+      const { journal, runStatus } = subject;
+      const runId = await openRun(journal);
+      await subject.breakOutboxWrites();
+      await (0, import_conformance.assertRefuses)(
+        () => journal.finishRun({
+          events: [envelopeOf({ id: `${runId}:0`, occurredAt: 10 })],
+          runId,
+          status: "completed",
+          tenantId: TENANT
+        }),
+        "a finish that cannot write its events must fail"
+      );
+      (0, import_conformance.assertIs)(
+        await runStatus({ runId, tenantId: TENANT }),
+        "running",
+        "the run must be left running, for somebody to finish"
+      );
+    })
+  ];
+};
+
+// src/create-step.ts
+var DEFINITION2 = /* @__PURE__ */ Symbol.for("geonosis.workflows.step");
+var stepDefinitionOf = (call) => {
+  const carried = call[DEFINITION2];
+  if (!carried) {
+    throw new WorkflowsError(
+      "this is not a step: it did not come from createStep, so it has no name to journal it under and no undo to register."
+    );
+  }
+  return carried;
+};
+var assertNameIsAvailable = (name) => {
+  if (name === "") {
+    throw new WorkflowsError(
+      "a step has no name. The name is what the run record and a durable platform memoise the step by, so it is the one thing that is never optional."
+    );
+  }
+  if (Object.values(RESERVED_STEP_NAMES).includes(name)) {
+    throw new WorkflowsError(
+      `"${name}" is a step name the engine uses for itself. A durable platform memoises by name, so this step would be handed the engine's result on a replay, or hand the engine its own.`
+    );
+  }
+  if (name.startsWith(COMPENSATION_PREFIX)) {
+    throw new WorkflowsError(
+      `a step name may not start with "${COMPENSATION_PREFIX}" \u2014 that is what the engine calls the step that undoes another one, and a trail with both in it could not be read back.`
+    );
+  }
+};
+var budgetOf = (config) => {
+  if (config.retry === void 0 && config.timeout === void 0) return DEFAULT_STEP_BUDGET;
+  if (config.retry !== void 0 && !(config.retry.limit >= 0)) {
+    throw new WorkflowsError(
+      `a retry limit of ${config.retry.limit} is not a budget. Say 0 for "run it once" and leave the key off to take the default.`
+    );
+  }
+  return {
+    ...config.retry === void 0 ? {} : { retry: config.retry },
+    ...config.timeout === void 0 ? {} : { timeout: config.timeout }
+  };
+};
+function createStep(config, invoke, compensate) {
+  const declared = typeof config === "string" ? { name: config } : config;
+  assertNameIsAvailable(declared.name);
+  if (declared.noCompensation === true && compensate !== void 0) {
+    throw new WorkflowsError(
+      `the step "${declared.name}" declares noCompensation and was given a compensate function. One of the two is a mistake, and guessing which would either drop an undo or run one the caller said was not there.`
+    );
+  }
+  const definition = {
+    budget: budgetOf(declared),
+    invoke,
+    name: declared.name,
+    ...compensate === void 0 ? {} : { compensate }
+  };
+  const call = async (input) => frameFor(definition.name).call(definition, input);
+  return Object.assign(call, {
+    [DEFINITION2]: definition,
+    stepName: definition.name
+  });
+}
+
+// src/memory-journal.ts
+var createMemoryJournal = (options = {}) => {
+  const now = options.now ?? (() => Date.now());
+  let outboxWritesFail = false;
+  const runs = [];
+  const steps = [];
+  const finishes = [];
+  const outbox = [];
+  const dispatched = [];
+  const runOf = (tenantId, runId) => runs.find((run) => run.tenantId === tenantId && run.id === runId);
+  const heldRun = (tenantId, idempotencyKey) => runs.find(
+    (run) => run.tenantId === tenantId && run.idempotencyKey === idempotencyKey && (run.status === "running" || run.status === "completed")
+  );
+  const journal = {
+    findRunByIdempotencyKey: async (params) => {
+      const run = heldRun(params.tenantId, params.idempotencyKey);
+      return run ? { id: run.id, output: run.output, status: run.status } : null;
+    },
+    finishRun: async (params) => {
+      if (outboxWritesFail && (params.events?.length ?? 0) > 0) {
+        throw new Error("the outbox is unwritable");
+      }
+      finishes.push({
+        error: params.error ?? null,
+        events: params.events ?? [],
+        output: params.output,
+        runId: params.runId,
+        status: params.status
+      });
+      for (const envelope of params.events ?? []) {
+        if (outbox.some((row) => row.envelope.id === envelope.id)) continue;
+        outbox.push({ envelope, tenantId: params.tenantId });
+      }
+      const run = runs.find((candidate) => candidate.id === params.runId);
+      if (!run) return;
+      if (run.status !== "running") return;
+      run.status = params.status;
+      run.output = params.output;
+      run.error = params.error ?? null;
+      run.finishedAt = now();
+    },
+    getRun: async (params) => {
+      const run = runOf(params.tenantId, params.runId);
+      if (!run) return null;
+      return {
+        error: run.error ?? null,
+        execution: run.execution,
+        finishedAt: run.finishedAt ?? null,
+        id: run.id,
+        input: run.input,
+        name: run.name,
+        output: run.output ?? null,
+        parentRunId: run.parentRunId,
+        replayOf: run.replayOf ?? null,
+        startedAt: run.startedAt,
+        status: run.status
+      };
+    },
+    insertRun: async (params) => {
+      const claimed = params.idempotencyKey !== null && heldRun(params.tenantId, params.idempotencyKey);
+      if (claimed) {
+        throw new IdempotencyKeyHeldError({
+          idempotencyKey: params.idempotencyKey,
+          tenantId: params.tenantId
+        });
+      }
+      const id = `run_${runs.length + 1}`;
+      runs.push({
+        cancelRequested: false,
+        finishedAt: null,
+        id,
+        startedAt: now(),
+        status: "running",
+        ...params,
+        // A column nobody set is null in a table, never undefined. An adapter that answered
+        // otherwise would let a test pass here and fail against a real database.
+        parentRunId: params.parentRunId ?? null,
+        replayOf: params.replayOf ?? null
+      });
+      return id;
+    },
+    listAbandonedRuns: async (params) => runs.filter(
+      (run) => run.execution === params.execution && run.status === "running" && run.startedAt < params.startedBefore
+    ).slice(0, params.limit).map((run) => ({ name: run.name, runId: run.id, tenantId: run.tenantId })),
+    listRunSteps: async (params) => steps.filter((row) => row.tenantId === params.tenantId && row.runId === params.runId).map((row) => ({
+      attempt: row.attempt,
+      error: row.error ?? null,
+      name: row.name,
+      seq: row.seq,
+      status: row.status
+    })),
+    listUndispatchedEvents: async (params) => outbox.filter(
+      (row) => !dispatched.includes(row.envelope.id) && row.envelope.occurredAt <= params.before
+    ).toSorted((left, right) => left.envelope.occurredAt - right.envelope.occurredAt).slice(0, params.limit),
+    markEventsDispatched: async (params) => {
+      dispatched.push(...params.ids);
+    },
+    recordStep: async (params) => {
+      const written = steps.some(
+        (step) => step.runId === params.runId && step.seq === params.seq && step.attempt === params.attempt
+      );
+      if (!written) steps.push({ ...params });
+      const run = runOf(params.tenantId, params.runId);
+      return { cancellationRequested: run?.cancelRequested ?? false };
+    },
+    requestCancellation: async (params) => {
+      const run = runOf(params.tenantId, params.runId);
+      if (!run || run.status !== "running") return false;
+      run.cancelRequested = true;
+      return true;
+    }
+  };
+  return {
+    breakOutboxWrites: () => {
+      outboxWritesFail = true;
+    },
+    dispatched,
+    finishes,
+    journal,
+    outbox,
+    runs,
+    steps
+  };
+};
+var createMemorySink = (options = {}) => {
+  const sent = [];
+  const batches = [];
+  const sink = {
+    sendBatch: async (messages) => {
+      if (options.refuses) throw new Error("the sink is unreachable");
+      const bodies = messages.map((message) => message.body);
+      batches.push(bodies);
+      sent.push(...bodies);
+    }
+  };
+  return { batches, sent, sink };
+};
+var createInProcessSink = (deliver) => ({
+  sendBatch: async (messages) => {
+    for (const message of messages) await deliver(message.body);
+  }
+});