@ewhauser/world-celld 0.3.0 → 0.3.2

package/dist/worker.d.ts

@@ -12,7 +12,9 @@ interface DONamespaceLike {
 interface WorkerEnv {
   WORKFLOW_DB: DONamespaceLike;
   WORKFLOW_STREAMS: DONamespaceLike;
-  WORKFLOW_INDEX: DONamespaceLike;
+  WORKFLOW_RUN_CATALOG: DONamespaceLike;
+  WORKFLOW_HOOK_TOKENS: DONamespaceLike;
+  WORKFLOW_HOOK_IDS: DONamespaceLike;
   WORKFLOW_QUEUE: DONamespaceLike;
   WORLD_SECRET?: string;
 }
@@ -30,6 +32,8 @@ interface CleanupRecord {
   dueAt: Date;
   queueShards: number;
   phase: CleanupPhase;
+  /** Optimistic-concurrency token for alarm/RPC work that awaits another cell. */
+  generation: number;
   attempts: number;
   lastError?: string;
   lastAttemptAt?: Date;
@@ -45,7 +49,10 @@ interface RunTombstone {
   completedAt: Date;
   expiredAt: Date;
   tombstonedAt: Date;
+  /** Final cleanup accounting retained inside the single authoritative record. */
+  cleanup: CleanupRecord;
 }
+type RunLifecycleStatus = 'active' | 'terminal' | 'expired' | 'missing';
 type RunReadOutcome<T> = {
   ok: true;
   value: T;
@@ -55,29 +62,43 @@ type RunReadOutcome<T> = {
   message: string;
   tombstone: RunTombstone;
 };
-interface HookIndexReference {
-  hookId: string;
-  token: string;
-}
-interface ExpireRunIndexesRequest {
-  runId: string;
-  keys: string[];
-  hooks: HookIndexReference[];
-  expiredAt: number;
-}
 interface ExpireRunIndexesResult {
   deleted: number;
 }
 interface ExpireRunStreamsResult {
   streams: string[];
 }
+interface FinalizeRunStreamsResult {
+  /** Cumulative registry entries removed for this run. */
+  deleted: number;
+  done: boolean;
+}
 interface ExpireStreamResult {
+  /** True only when this call installed the stream's expiration fence. */
   deleted: boolean;
+  /** Chunk rows removed by this bounded call. */
   chunks: number;
+  /** Payload bytes represented by the removed chunk rows. */
+  bytes: number;
+  done: boolean;
 }
-interface ExpireQueueRunResult {
+interface QueueExpiryReceipt {
+  expiredAt: number;
   deleted: number;
 }
+type ExpireQueueRunResult = {
+  /** Cumulative messages removed for this run in this queue shard. */
+  deleted: number;
+} & ({
+  done: false;
+} | {
+  done: true;
+  /** Durable receipt which the cleanup coordinator must acknowledge. */
+  receipt: QueueExpiryReceipt;
+});
+interface AcknowledgeQueueExpiryResult {
+  acknowledged: boolean;
+}
 interface ScheduleCleanupRequest {
   retentionMs: number;
   queueShards: number;
@@ -91,17 +112,19 @@ interface ApplyEventRequest {
   /** Workflow 5 event-log position and preload options. */
   params?: CreateEventParams;
   /**
-   * Current holder of the hook token per the global KV token index
+   * Current holder of the hook token per the sharded token-ownership index
    * (hook_created only). `null` means the token is unclaimed.
    */
   tokenHolder?: {
     runId: string;
     hookId: string;
   } | null;
+  /** Exact token/ID reservation fenced on ambiguous-delivery resolution. */
+  hookClaimId?: string;
   /** Internal world-celld retention policy captured with the event. */
   cleanup?: ScheduleCleanupRequest;
 }
-type ApplyEventErrorCode = 'RUN_NOT_FOUND' | 'STEP_NOT_FOUND' | 'HOOK_NOT_FOUND' | 'WAIT_NOT_FOUND' | 'ENTITY_CONFLICT' | 'RUN_EXPIRED' | 'TOO_EARLY' | 'RUN_NOT_SUPPORTED';
+type ApplyEventErrorCode = 'RUN_NOT_FOUND' | 'STEP_NOT_FOUND' | 'HOOK_NOT_FOUND' | 'WAIT_NOT_FOUND' | 'ENTITY_CONFLICT' | 'HOOK_CLAIM_CANCELLED' | 'RUN_EXPIRED' | 'TOO_EARLY' | 'RUN_NOT_SUPPORTED';
 interface ApplyEventFailure {
   ok: false;
   code: ApplyEventErrorCode;
@@ -121,7 +144,7 @@ interface ApplyEventSuccess {
   wait?: Wait;
   /** True when a lazy step_started atomically created its step. */
   stepCreated?: true;
-  /** Hooks whose tokens must be released from the global KV index. */
+  /** Hooks whose token and ID indexes must be released. */
   releasedHooks: Array<{
     hookId: string;
     token: string;
@@ -131,7 +154,7 @@ interface ApplyEventSuccess {
     workflowName: string;
     createdAt: Date;
   };
-  /** Set when the global KV hook index must be (re)written. */
+  /** Set when the sharded hook indexes must be (re)written. */
   hookToIndex?: Hook;
   /** All events (ascending), preloaded for run_started responses. */
   events?: Event[];
@@ -140,9 +163,38 @@ interface ApplyEventSuccess {
   hasMore?: boolean;
   /** Server-owned event ceiling advertised on run lifecycle writes. */
   maxEvents?: number;
+  /** Deadline for publishing this authoritative mutation to derivative indexes. */
+  indexPublicationExpiresAt?: number;
 }
 type ApplyEventOutcome = ApplyEventSuccess | ApplyEventFailure;
 //#endregion
+//#region src/stream-protocol.d.ts
+type StreamTerminalState = 'open' | 'closed' | 'errored' | 'expired';
+interface StreamErrorData {
+  name: string;
+  message: string;
+}
+interface StreamWriteResult {
+  startIndex: number;
+  count: number;
+  tailIndex: number;
+}
+interface StreamReadRequest {
+  runId: string;
+  startIndex: number;
+  maxChunks: number;
+  maxBytes: number;
+  waitMs: number;
+}
+interface StreamReadResult {
+  startIndex: number;
+  tailIndex: number;
+  chunks: Uint8Array[];
+  state: StreamTerminalState;
+  timedOut: boolean;
+  error?: StreamErrorData;
+}
+//#endregion
 //#region src/queue.d.ts
 type Pathname = 'flow';
 /**
@@ -181,6 +233,29 @@ type EnqueueOutcome = {
   message: string;
 };
 //#endregion
+//#region src/indexes.d.ts
+interface IndexListOptions {
+  prefix?: string;
+  cursor?: string;
+  limit?: number;
+  reverse?: boolean;
+}
+interface IndexListPage {
+  keys: Array<{
+    name: string;
+    value: string;
+  }>;
+  list_complete: boolean;
+  cursor?: string;
+}
+interface CellIdLike {
+  toString(): string;
+}
+interface CellNamespaceLike<T> {
+  idFromName(name: string): CellIdLike;
+  get(id: CellIdLike): T;
+}
+//#endregion
 //#region src/config.d.ts
 interface HookTokenOwner {
   runId: string;
@@ -203,53 +278,68 @@ declare class DurableObject<TEnv = unknown> {
   constructor(ctx: DurableObjectState, env: TEnv);
 }
 //#endregion
-//#region src/worker/durable-objects/IndexDO.d.ts
-/**
- * Global index cell, replacing the Workers KV namespace world-cloudflare
- * uses for run listing and hook token/id lookup.
- *
- * A single cell (named `index`) serializes every read and write. Hook-token
- * reservation, publication, and release use storage transactions so
- * concurrent runs cannot both acquire the same token.
- *
- * The RPC surface matches the storage-layer KVNamespace interface bit-for-bit
- * (including MockKVNamespace's pagination contract: cursor = last returned
- * key, `list_complete` reflects whether further keys exist), so the vendored
- * storage.ts works against it unchanged.
- */
-declare class IndexDO extends DurableObject {
-  get(key: string): Promise<string | null>;
-  put(key: string, value: string): Promise<void>;
-  /** Publish a derived index only while its owning run is not expired. */
-  putOwned(runId: string, key: string, value: string): Promise<{
+//#region src/worker/durable-objects/hook-index-shared.d.ts
+interface RunLifecycleStub {
+  getLifecycleStatus(): Promise<RunLifecycleStatus>;
+}
+interface HookIndexEnv {
+  WORKFLOW_DB?: CellNamespaceLike<RunLifecycleStub>;
+  /** Test seam; celld deployments use Date.now(). */
+  clock?: () => number;
+}
+//#endregion
+//#region src/worker/durable-objects/HookIdDO.d.ts
+/** Hook-ID ownership and lookup shard; every hook ID has one transaction domain. */
+declare class HookIdDO extends DurableObject<HookIndexEnv> {
+  private now;
+  get(hookId: string): Promise<string | null>;
+  reserve(hookId: string, owner: HookTokenOwner, proposedClaimId: string): Promise<{
+    claimed: true;
+    claimId: string;
+  } | {
+    claimed: false;
+    holder: HookTokenOwner;
+  }>;
+  publish(hookId: string, serializedHook: string, owner: HookTokenOwner, claimId?: string): Promise<{
     stored: boolean;
   }>;
-  delete(key: string): Promise<void>;
-  list(options?: {
-    prefix?: string;
-    cursor?: string;
-    limit?: number;
-    reverse?: boolean;
-  }): Promise<{
-    keys: Array<{
-      name: string;
-    }>;
-    list_complete: boolean;
-    cursor?: string;
+  releaseClaim(hookId: string, owner: HookTokenOwner, claimId: string): Promise<void>;
+  releaseBatch(hooks: Array<{
+    hookId: string;
+    owner: HookTokenOwner;
+  }>): Promise<{
+    deleted: number;
   }>;
-  reserveHookToken(token: string, owner: HookTokenOwner): Promise<{
-    claimed: boolean;
-    holder?: HookTokenOwner;
+  alarm(): Promise<void>;
+  private armAtMost;
+  private compactClaims;
+}
+//#endregion
+//#region src/worker/durable-objects/HookTokenDO.d.ts
+/** Token-ownership shard. A token hashes to exactly one shard and transaction domain. */
+declare class HookTokenDO extends DurableObject<HookIndexEnv> {
+  private now;
+  get(token: string): Promise<string | null>;
+  reserve(token: string, owner: HookTokenOwner, proposedClaimId: string): Promise<{
+    claimed: true;
+    claimId: string;
+  } | {
+    claimed: false;
+    holder: HookTokenOwner;
   }>;
-  finalizeHookIndexes(token: string, hookId: string, serializedHook: string, owner: HookTokenOwner): Promise<void>;
-  releaseHookToken(token: string, owner: HookTokenOwner): Promise<void>;
-  deleteHookIndexes(token: string, hookId: string, owner: HookTokenOwner): Promise<void>;
-  /**
-   * Fence a run and remove all of its known derived indexes atomically.
-   * Once the fence exists, putOwned() and hook finalization cannot resurrect
-   * entries from a delayed request.
-   */
-  expireRun(request: ExpireRunIndexesRequest): Promise<ExpireRunIndexesResult>;
+  finalize(token: string, serializedHook: string, owner: HookTokenOwner, claimId?: string): Promise<{
+    stored: boolean;
+  }>;
+  releaseClaim(token: string, owner: HookTokenOwner, claimId: string): Promise<void>;
+  releaseBatch(hooks: Array<{
+    token: string;
+    owner: HookTokenOwner;
+  }>): Promise<{
+    deleted: number;
+  }>;
+  alarm(): Promise<void>;
+  private armAtMost;
+  private compactClaims;
 }
 //#endregion
 //#region src/worker/durable-objects/QueueDO.d.ts
@@ -265,11 +355,15 @@ declare class IndexDO extends DurableObject {
  *   cfg                          pinned QueueCellConfig (first-enqueue wins)
  *   msg:<messageId>              MessageRow
  *   due:<paddedMs>:<messageId>   schedule index -> messageId
- *   inflight:<messageId>         crash-recovery deadline (epoch ms)
+ *   inflight-deadline:<paddedMs>:<messageId>
+ *                                ordered crash-recovery index -> messageId
  *   key:<idempotencyKey>         active dedup claim -> messageId
  *   dlq:<paddedMs>:<messageId>   DeadLetterRow
  *   run:<runId>:<messageId>      QueueRunReference for retention cleanup
- *   expired-run:<runId>          run fence preventing delayed enqueue
+ *   expired-run:<runId>          cumulative cleanup receipt; compactable only
+ *                                after RunDO acknowledgement
+ *   expired-run-gc:<paddedMs>:<runId>
+ *                                ordered compaction deadline -> runId
  *
  * celld gotchas designed around:
  * - celld#144 (alarm handlers can overlap): the storage-only claim phase runs
@@ -329,6 +423,7 @@ declare class QueueDO extends DurableObject {
   }>;
   purgeDeadLetters(): Promise<{
     purged: number;
+    hasMore: boolean;
   }>;
   /**
    * Recovery hatch for celld's six-failure alarm abandonment: derive the due
@@ -338,67 +433,76 @@ declare class QueueDO extends DurableObject {
     alarmAt: number | null;
   }>;
   /** Fence a run and purge every live, inflight, and dead-letter message it owns. */
-  expireRun(runId: string, expiredAt: number): Promise<ExpireQueueRunResult>;
+  expireRun(runId: string, expiredAt: number, options?: {
+    limit?: number;
+  }): Promise<ExpireQueueRunResult>;
+  /** Acknowledge a final cleanup receipt before making its marker compactable. */
+  acknowledgeExpireRun(runId: string, receipt: QueueExpiryReceipt): Promise<AcknowledgeQueueExpiryResult>;
+}
+//#endregion
+//#region src/worker/durable-objects/RunCatalogDO.d.ts
+/** One of a fixed set of run-catalog shards, routed by the stable run ID hash. */
+declare class RunCatalogDO extends DurableObject {
+  private now;
+  upsertRun(runId: string, keys: string[], serializedMetadata: string, publicationExpiresAt: number): Promise<{
+    stored: boolean;
+  }>;
+  list(options?: IndexListOptions): Promise<IndexListPage>;
+  expireRun(runId: string, keys: string[], expiredAt: number): Promise<ExpireRunIndexesResult>;
+  alarm(): Promise<void>;
+  private armAtMost;
+  private compactExpiryFences;
 }
 //#endregion
 //#region src/worker/durable-objects/StreamDO.d.ts
 /**
  * Durable Object backing workflow streams.
  *
- * Two roles, selected by the DO name:
- * - `stream:<name>`: chunk storage for a single stream. A monotonic
- *   per-stream counter (maintained transactionally inside the DO) assigns
- *   each chunk its index; one chunk per storage key.
- * - `run-streams:<runId>`: registry of stream names owned by a run,
- *   powering `listStreamsByRunId`.
+ * Stream cells persist binary chunks under monotonic offset keys. Public
+ * reads are bounded long polls, and writes append a bounded ordered batch in
+ * one storage transaction. Per-run registry cells retain their existing role.
  */
 declare class StreamDO extends DurableObject {
+  private meta;
+  private metaLoad;
+  private mutationTail;
+  private changeVersion;
+  private readonly waiters;
   private getMeta;
   private assertOwner;
+  private assertWritable;
+  private runMutation;
+  private wakeReaders;
+  private waitForChange;
+  private readSnapshot;
+  /** Append one bounded binary batch with contiguous indexes. */
+  writeChunks(runId: string, chunks: Uint8Array[]): Promise<StreamWriteResult>;
   /**
-   * Append a chunk. The index is allocated inside the transaction, so
-   * concurrent writers can never collide or skip.
-   */
-  writeChunk(runId: string, data: Uint8Array): Promise<number>;
-  /**
-   * Close the stream (idempotent). Readers observe `done: true` once all
-   * previously written chunks have been consumed.
+   * Return available binary chunks and terminal metadata in one bounded
+   * operation, waiting at most waitMs when the requested offset is idle.
    */
+  readChunks(request: StreamReadRequest, signal?: AbortSignal): Promise<StreamReadResult>;
+  /** Close idempotently; the first terminal state wins. */
   closeStream(runId: string): Promise<void>;
-  /**
-   * Read up to `limit` chunks starting at `startIndex` (0-based, inclusive).
-   */
-  getChunks(params: {
-    startIndex: number;
-    limit: number;
-  }): Promise<{
-    chunks: Uint8Array[];
-    /** Whether the stream is closed. */
-    done: boolean;
-    /** Index of the last written chunk, -1 when empty. */
-    tailIndex: number;
-  }>;
-  /**
-   * Lightweight stream metadata: last chunk index and completion flag.
-   */
-  getInfo(): Promise<{
-    tailIndex: number;
-    done: boolean;
-  }>;
-  /**
-   * Register a stream name against this per-run registry instance.
-   */
+  /** Persist a terminal stream failure and wake every pending reader. */
+  failStream(runId: string, error: StreamErrorData | string): Promise<void>;
+  /** Register a stream name against this per-run registry instance. */
   registerStream(runId: string, name: string): Promise<void>;
-  /**
-   * List stream names registered against this per-run registry instance.
-   */
   listStreams(): Promise<string[]>;
   /** Fence a run's registry before any stream cells are removed. */
-  expireRegistry(runId: string, expiredAt: number): Promise<ExpireRunStreamsResult>;
-  /** Remove the registry payload after every referenced stream was fenced. */
-  finalizeRegistry(runId: string): Promise<void>;
-  /** Delete stream payload while leaving a small ownership tombstone. */
-  expireStream(runId: string, expiredAt: number): Promise<ExpireStreamResult>;
+  expireRegistry(runId: string, expiredAt: number, options?: {
+    limit?: number;
+  }): Promise<ExpireRunStreamsResult>;
+  /** Remove completed registry entries in a bounded, retry-safe batch. */
+  finalizeRegistry(runId: string, streams: string[]): Promise<FinalizeRunStreamsResult>;
+  /**
+   * Fence the stream and delete one bounded page. Listing size keys avoids
+   * loading payloads, and the transaction makes a crash retry resume safely.
+   */
+  expireStream(runId: string, expiredAt: number, options?: {
+    limit?: number;
+    byteLimit?: number;
+  }): Promise<ExpireStreamResult>;
 }
 //#endregion
 //#region src/worker/durable-objects/WorkflowRunDO.d.ts
@@ -414,11 +518,27 @@ declare class StreamDO extends DurableObject {
  */
 declare class WorkflowRunDO extends DurableObject {
   private now;
-  private expiredTombstone;
+  private tombstoneFrom;
+  private retentionState;
   private read;
+  private readKey;
   /** Apply an event and capture all retention metadata in the same transaction. */
   applyEvent(request: ApplyEventRequest): Promise<ApplyEventOutcome>;
+  /**
+   * Resolve an ambiguous hook-creation RPC in the same serialization domain as
+   * applyEvent. If the hook is absent, the exact reservation is durably fenced
+   * before the caller releases its token and hook-ID claims.
+   */
+  resolveHookTokenClaim(request: {
+    hookId: string;
+    token: string;
+    claimId: string;
+  }): Promise<{
+    committed: boolean;
+  }>;
   getRun(): Promise<RunReadOutcome<WorkflowRun | null>>;
+  /** Single authoritative lifecycle answer used after derivative compaction. */
+  getLifecycleStatus(): Promise<RunLifecycleStatus>;
   getStep(stepId: string): Promise<RunReadOutcome<Step | null>>;
   listSteps(params?: {
     limit?: number;
@@ -455,10 +575,20 @@ declare class WorkflowRunDO extends DurableObject {
   rearmCleanup(): Promise<CleanupRecord | null>;
   alarm(): Promise<void>;
   private namespace;
+  private workflowIndex;
   private setCleanupPhase;
+  private executeScheduledCleanupPage;
   private executeCleanup;
+  private executeTerminalCleanup;
+  private deleteTerminalHookPage;
+  private deleteTerminalHookMarkerPage;
+  private deleteTerminalWaitPage;
+  private deleteIndexPage;
+  private deleteStreamPage;
+  private deleteQueuePage;
   private deletePayloadBatch;
   private recordCleanupFailure;
+  private recordTerminalCleanupFailure;
   claimInflight(params: {
     messageId: string;
     staleMs: number;
@@ -473,5 +603,5 @@ declare const _default: {
   fetch(request: Request, env: WorkerEnv): Promise<Response>;
 };
 //#endregion
-export { IndexDO, QueueDO, StreamDO, type WorkerEnv, WorkflowRunDO, createRouter, _default as default };
+export { HookIdDO, HookTokenDO, QueueDO, RunCatalogDO, StreamDO, type WorkerEnv, WorkflowRunDO, createRouter, _default as default };
 //# sourceMappingURL=worker.d.ts.map

package/dist/worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker.d.ts","names":[],"sources":["../src/worker/router.ts","../src/retention.ts","../src/apply-event.ts","../src/queue.ts","../src/config.ts","../src/worker/do-base.ts","../src/worker/durable-objects/IndexDO.ts","../src/worker/durable-objects/QueueDO.ts","../src/worker/durable-objects/StreamDO.ts","../src/worker/durable-objects/WorkflowRunDO.ts","../src/worker/worker.ts"],"mappings":"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"}
+{"version":3,"file":"worker.d.ts","names":[],"sources":["../src/worker/router.ts","../src/retention.ts","../src/apply-event.ts","../src/stream-protocol.ts","../src/queue.ts","../src/indexes.ts","../src/config.ts","../src/worker/do-base.ts","../src/worker/durable-objects/hook-index-shared.ts","../src/worker/durable-objects/HookIdDO.ts","../src/worker/durable-objects/HookTokenDO.ts","../src/worker/durable-objects/QueueDO.ts","../src/worker/durable-objects/RunCatalogDO.ts","../src/worker/durable-objects/StreamDO.ts","../src/worker/durable-objects/WorkflowRunDO.ts","../src/worker/worker.ts"],"mappings":"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"}