@ewhauser/world-celld 0.3.2 → 0.4.1

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 All notable changes to this project will be documented in this file.
 
+## 0.4.1 (2026-08-24)
+
+## What's Changed
+* fix: harden remote transport failure handling by @ewhauser in https://github.com/ewhauser/world-celld/pull/34
+* test: enforce real celld restart recovery by @ewhauser in https://github.com/ewhauser/world-celld/pull/36
+* test: cover index compaction alarm recovery by @ewhauser in https://github.com/ewhauser/world-celld/pull/37
+* test: harden index compaction rollback coverage by @ewhauser in https://github.com/ewhauser/world-celld/pull/38
+* test: harden StreamDO corruption handling by @ewhauser in https://github.com/ewhauser/world-celld/pull/39
+* test: harden configuration and malformed input handling by @ewhauser in https://github.com/ewhauser/world-celld/pull/40
+* fix: enforce negative apply-event contracts by @ewhauser in https://github.com/ewhauser/world-celld/pull/41
+
+
+**Full Changelog**: https://github.com/ewhauser/world-celld/compare/v0.4.0...v0.4.1
+
+## 0.4.0 (2026-08-22)
+
+## What's Changed
+* chore: test against celld v0.3.0 by @ewhauser in https://github.com/ewhauser/world-celld/pull/31
+* feat: add configurable workflow retention by @ewhauser in https://github.com/ewhauser/world-celld/pull/33
+
+
+**Full Changelog**: https://github.com/ewhauser/world-celld/compare/v0.3.2...v0.4.0
+
 ## 0.3.2 (2026-08-19)
 
 ## What's Changed

package/README.md

@@ -75,8 +75,9 @@ requests. It must be reachable from every celld node.
 
 ## Deploy the worker
 
-Before deploying, you need a celld fleet, `esbuild` on `PATH`, and an object
-store that meets celld's conditional-write requirements. Refer to the
+Before deploying, you need a celld v0.3.0 fleet, `esbuild` on `PATH`, and an
+object store that meets celld's conditional-write requirements. v0.3.0 is the
+currently tested runtime baseline. Refer to the
 [celld documentation](https://github.com/denoland/celld) for fleet and storage
 setup.
 
@@ -98,6 +99,7 @@ the same secret to the fleet and the application:
 
 ```sh
 CELLD_VAR_WORLD_SECRET="$CELLD_WORLD_SECRET" \
+CELLD_VAR_WORKFLOW_RETENTION_MS=7776000000 \
 celld --bucket s3://my-cells-bucket \
   --listen 0.0.0.0:8080 \
   --internal-listen 10.0.0.12:8081 \
@@ -108,6 +110,9 @@ Use a secret manager rather than putting the value in `wrangler.jsonc`. Keep
 celld's internal listener on a trusted network; the World bearer token protects
 the worker RPC routes, not celld's administrative endpoints.
 
+The example sets a fleet-wide maximum workflow age of 90 days. Leave
+`WORKFLOW_RETENTION_MS` at `0` to disable that policy.
+
 More deployment detail is in [`celld-worker/README.md`](./celld-worker/README.md).
 
 ## How it works
@@ -118,6 +123,7 @@ Workflow application
   | authenticated HTTP RPC + binary stream batches
   v
 celld worker router
+  |-- scheduled       hourly maximum-age retention discovery
   |-- WorkflowRunDO  one cell per workflow run
   |-- RunCatalogDO   16 stable run-id shards; merged ordered listing
   |-- HookTokenDO    32 stable token-ownership shards
@@ -174,18 +180,59 @@ variable is shown below.
 
 The deployed worker also accepts these celld variables:
 
-| Variable                    | Default  | Purpose                                              |
-| --------------------------- | -------- | ---------------------------------------------------- |
-| `WORLD_SECRET`              | none     | Required bearer secret for RPC routes                |
-| `WORKFLOW_CALLBACK_SECRET`  | none     | Sent with deliveries as `x-workflow-callback-secret` |
-| `QUEUE_MAX_ATTEMPTS`        | `5`      | Attempts before a message is dead-lettered           |
-| `QUEUE_MAX_INFLIGHT`        | `5`      | Concurrent deliveries per queue cell (maximum `128`) |
-| `QUEUE_DELIVERY_TIMEOUT_MS` | `300000` | Callback timeout (maximum `300000`)                  |
+| Variable                          | Default  | Purpose                                              |
+| --------------------------------- | -------- | ---------------------------------------------------- |
+| `WORLD_SECRET`                    | none     | Required bearer secret for RPC routes                |
+| `WORKFLOW_CALLBACK_SECRET`        | none     | Sent with deliveries as `x-workflow-callback-secret` |
+| `QUEUE_MAX_ATTEMPTS`              | `5`      | Attempts before a message is dead-lettered           |
+| `QUEUE_MAX_INFLIGHT`              | `5`      | Concurrent deliveries per queue cell (maximum `128`) |
+| `QUEUE_DELIVERY_TIMEOUT_MS`       | `300000` | Callback timeout (maximum `300000`)                  |
+| `WORKFLOW_RETENTION_MS`           | `0`      | Maximum run age from creation; includes active runs  |
+| `WORKFLOW_RETENTION_BATCH_SIZE`   | `128`    | Runs admitted by each cron sweep (maximum `1000`)    |
+| `WORKFLOW_RETENTION_QUEUE_SHARDS` | `1`      | Queue-shard fallback for older runs                  |
 
 `queueShards` is part of queue placement and is pinned when a queue cell is
-first used. Drain pending work before changing it.
-
-## Terminal run retention
+first used. It may be any positive safe integer; the `128` storage-operation
+batch limit does not cap the fleet's total shard count. Drain pending work
+before changing it.
+
+Queue deadlines use fixed-width 13-digit epoch-millisecond keys. A requested
+`delaySeconds` or handler redelivery timeout is accepted only when its deadline
+is at most `9999999669998`, leaving 330,001 ms for a fresh alarm edge and the
+maximum delivery lease. Every derived due, retry, inflight, and GC deadline is
+checked against the absolute `9999999999999` limit. A production retry which
+cannot preserve that headroom is dead-lettered instead of clamped or rescheduled;
+the test pump terminates the equivalent in-memory message. Long test-mode waits
+are chunked at the host timer limit without changing this deadline contract.
+
+## Workflow retention
+
+### Fleet-wide maximum age
+
+Set the deployed worker's `WORKFLOW_RETENTION_MS` variable to expire every
+workflow after a maximum age measured from `createdAt`. For example,
+`7776000000` is 90 days. This policy applies to pending, running, completed,
+failed, and cancelled runs.
+
+The packaged worker declares an hourly UTC celld cron trigger. Each occurrence
+scans one bounded creation-time catalog page and asks the authoritative run
+cells to enforce the cutoff. A run cell immediately fences reads, writes, stream
+activity, and queue work, removes its catalog entry, then finishes the existing
+bounded stream, queue, and payload cleanup phases through its durable alarm.
+Repeated cron invocations and alarm retries are idempotent.
+
+One occurrence admits at most `WORKFLOW_RETENTION_BATCH_SIZE` runs (default
+`128`, maximum `1000`). If the fleet was down or a shorter policy creates a
+backlog, later occurrences continue with the next oldest entries. Edit
+`triggers.crons` in the copied `celld-worker/wrangler.jsonc` if hourly discovery
+does not provide the desired expiration resolution or catch-up rate.
+
+New runs persist the application's `queueShards` value for complete queue
+cleanup. `WORKFLOW_RETENTION_QUEUE_SHARDS` is the fallback for runs created
+before that metadata existed and must match the placement used by those runs.
+Both values may be any positive safe integer.
+
+### Terminal payload retention
 
 When `runRetentionMs` is greater than zero, a terminal transition atomically
 records the run's `expiredAt` and arms its cell alarm. The complete run, event,
@@ -219,7 +266,8 @@ await world.retention.rearm(runId); // recover a missed or abandoned alarm
 
 The retention deadline is pinned when the run becomes terminal. Changing the
 configuration affects newly terminal runs; call `schedule()` explicitly for
-an existing terminal run that has no cleanup record.
+an existing terminal run that has no cleanup record. If terminal retention and
+fleet-wide maximum age are both enabled, the earlier deadline wins.
 
 ## Operational notes
 
@@ -257,6 +305,33 @@ CELLD_WORLD_SECRET=replace-with-a-secret \
 pnpm test:integration
 ```
 
+### Real celld restart smoke
+
+The required CI smoke owns native celld v0.3.0 and MinIO processes on loopback,
+uses fresh temporary bucket and runtime state, and kills celld with `SIGKILL`
+before deleting its local working state and starting a new process against the
+bucket-backed state. It checks that:
+
+- acknowledged run and stream state survives the process restart;
+- an accepted delayed queue message that becomes due while celld is down is
+  delivered once after the alarm is restored;
+- multi-page retention cleanup continues from a persisted nonterminal phase;
+- cancelling an in-flight HTTP long poll leaves the stream writable and
+  readable.
+
+Run the same bounded smoke locally on Linux x86-64 or macOS arm64:
+
+```sh
+pnpm test:integration:celld-smoke
+```
+
+The runner downloads celld and MinIO artifacts at pinned versions and verifies
+their SHA-256 digests before use. MinIO does not implement the conditional-write
+contract celld requires for production ownership fencing, so the smoke disables
+the storage probe and runs exactly one celld process at a time. It proves the
+single-process restart boundaries above, not multi-node ownership, handoff, or
+failover correctness.
+
 ### Local MinIO performance and loss test
 
 The opt-in performance harness starts a fresh MinIO bucket and a single celld
@@ -265,7 +340,7 @@ message reaches a successful callback, including forced `503` redeliveries. A
 second workload creates terminal runs with streams and delayed queue messages,
 then verifies complete payload cleanup without resurrection. Results include
 queue and cleanup throughput plus p50, p95, p99, and maximum latency and are
-saved under `.perf-results/`.
+saved under `.perf-results/`. The harness currently pins celld v0.3.0.
 
 > MinIO Community is **not a supported celld production store**. It does not
 > implement the conditional writes celld needs for ownership fencing. This
@@ -284,7 +359,7 @@ and force every twentieth message through one `503` redelivery.
 
 #### Reference result
 
-The following directional baseline was recorded on August 15, 2026. MinIO and
+The following directional baseline was recorded on August 21, 2026. MinIO and
 celld ran as native arm64 processes because Docker was unavailable on the test
 machine; container results will differ.
 
@@ -292,21 +367,25 @@ machine; container results will differ.
 | ----------- | -------------------------------------------------------------------------------------------------------- |
 | Machine     | MacBook Pro (Mac15,8), Apple M3 Max, 16 cores (12 performance, 4 efficiency), 64 GB RAM                  |
 | OS          | macOS 26.5.2 (25F84), arm64                                                                              |
-| Services    | celld v0.2.1; MinIO RELEASE.2025-09-07T16-13-09Z                                                         |
+| Services    | celld v0.3.0; MinIO RELEASE.2025-09-07T16-13-09Z                                                         |
 | Workload    | 1,000 messages; concurrency 32; 2 queue shards; 256-byte target payload; every 20th message retried once |
 
 | Metric                  |                                                                            Result |
 | ----------------------- | --------------------------------------------------------------------------------: |
 | Delivery integrity      | 1,000 accepted, 1,000 delivered, 0 missing, 0 duplicate successes, 0 dead letters |
 | Callback attempts       |                                           1,050, including 50 forced redeliveries |
-| Enqueue throughput      |                                                                 882.55 messages/s |
-| Delivery throughput     |                                                                 808.81 messages/s |
-| Enqueue latency         |                          p50 24.37 ms; p95 75.60 ms; p99 176.67 ms; max 200.36 ms |
-| All delivery latency    |                         p50 53.95 ms; p95 167.86 ms; p99 210.84 ms; max 312.03 ms |
-| First-attempt latency   |                         p50 52.55 ms; p95 166.35 ms; p99 209.80 ms; max 212.01 ms |
-| Retried-message latency |                         p50 82.52 ms; p95 262.63 ms; p99 312.03 ms; max 312.03 ms |
+| Enqueue throughput      |                                                                 865.66 messages/s |
+| Delivery throughput     |                                                                 794.60 messages/s |
+| Enqueue latency         |                          p50 26.06 ms; p95 70.72 ms; p99 146.59 ms; max 157.70 ms |
+| All delivery latency    |                         p50 65.05 ms; p95 184.47 ms; p99 225.10 ms; max 328.75 ms |
+| First-attempt latency   |                         p50 63.65 ms; p95 177.93 ms; p99 209.38 ms; max 226.86 ms |
+| Retried-message latency |                        p50 114.81 ms; p95 286.35 ms; p99 328.75 ms; max 328.75 ms |
 | Final queue state       |                         0 pending, 0 in flight, 0 dead letters across both shards |
 
+The retention workload in the same run tombstoned 100 of 100 terminal runs,
+expired all 100 reads, deleted 400 payload keys, 100 streams, and 100 delayed
+queue messages, and left both queue shards empty.
+
 Use these numbers as a smoke-test reference, not a portable performance
 guarantee. For regression tracking, compare repeated runs on the same machine
 and runtime configuration. Two shards gave the best latency balance for this

package/celld-worker/README.md

@@ -19,11 +19,35 @@ celld deploy ./workflow-world --bucket s3://my-cells-bucket
 
 Requirements:
 
+- celld v0.3.0 (the currently tested runtime baseline).
 - `esbuild` on PATH (celld shells out to it).
 - A bucket with conditional-write support (celld's fencing requirement).
 - `WORLD_SECRET` injected at the node level (`CELLD_VAR_WORLD_SECRET=...`) —
   the router fails closed with 503 while it is empty.
 
+## Fleet-wide retention
+
+The bundled `wrangler.jsonc` declares an hourly UTC cron trigger. It does no
+catalog work by default. Set `CELLD_VAR_WORKFLOW_RETENTION_MS` on every node to
+enable a maximum workflow age measured from run creation:
+
+```sh
+CELLD_VAR_WORKFLOW_RETENTION_MS=7776000000 \
+celld --bucket s3://my-cells-bucket
+```
+
+`7776000000` is 90 days. The policy includes pending and running workflows as
+well as terminal ones. Each cron occurrence admits at most
+`WORKFLOW_RETENTION_BATCH_SIZE` runs (default `128`); the existing per-run alarm
+state machine finishes bounded index, stream, queue, and payload cleanup.
+
+New runs persist the application's `queueShards` placement. Set
+`WORKFLOW_RETENTION_QUEUE_SHARDS` to the historical positive-safe-integer
+queue-shard count when cleaning runs created before this worker version. The
+`128` multikey storage-operation limit is not a total-shard ceiling. Edit
+`triggers.crons` in the copied config if hourly discovery is not the desired
+resolution.
+
 Point the app at any node's public listener:
 
 ```ts

package/celld-worker/wrangler.jsonc

@@ -28,6 +28,10 @@
       ],
     },
   ],
+  // Fleet-wide maximum-age retention is discovered hourly. The handler is a
+  // no-op while WORKFLOW_RETENTION_MS is "0". Change this expression if a
+  // different sweep cadence is required; celld cron schedules are UTC.
+  "triggers": { "crons": ["0 * * * *"] },
   "vars": {
     // REQUIRED: bearer secret for the world's RPC and binary stream surface.
     // Authenticated routes fail closed with 503 while this is empty. Inject the real value
@@ -35,6 +39,14 @@
     "WORLD_SECRET": "",
     // Optional: forwarded as x-workflow-callback-secret on queue deliveries.
     "WORKFLOW_CALLBACK_SECRET": "",
+    // Optional fleet-wide maximum workflow age, measured from run creation.
+    // Applies to pending, running, and terminal runs. "0" disables it.
+    "WORKFLOW_RETENTION_MS": "0",
+    // Maximum runs admitted to cleanup by one hourly sweep (1..1000).
+    "WORKFLOW_RETENTION_BATCH_SIZE": "128",
+    // Must match createCelldWorld({ queueShards }) so every queue shard is
+    // included in cleanup for active runs discovered by the sweep.
+    "WORKFLOW_RETENTION_QUEUE_SHARDS": "1",
     // Optional queue tuning (strings): QUEUE_MAX_ATTEMPTS, QUEUE_MAX_INFLIGHT,
     // QUEUE_DELIVERY_TIMEOUT_MS.
   },

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { CreateEventParams, CreateEventRequest, Event, GetChunksOptions, Hook, RunCreatedEventRequest, Step, StreamChunksResponse, StreamInfoResponse, Streamer, TerminalWorkflowRunStatus, ValidQueueName, Wait, WorkflowRun, World } from "@workflow/world";
+import { CreateEventParams, CreateEventRequest, Event, GetChunksOptions, Hook, RunCreatedEventRequest, Step, StreamChunksResponse, StreamInfoResponse, Streamer, TerminalWorkflowRunStatus, ValidQueueName, Wait, WorkflowRun, WorkflowRunStatus, World } from "@workflow/world";
 //#region src/retention.d.ts
 type CleanupPhase = 'retained' | 'index' | 'streams' | 'queues' | 'payload' | 'tombstoned';
 interface CleanupRecord {
@@ -6,8 +6,13 @@ interface CleanupRecord {
   runId: string;
   workflowName: string;
   createdAt: Date;
-  completedAt: Date;
-  terminalStatus: TerminalWorkflowRunStatus;
+  /** Last status observed when cleanup was scheduled. */
+  status?: WorkflowRunStatus;
+  /** Present when cleanup was scheduled for a terminal run. */
+  completedAt?: Date;
+  /** Retained for persisted terminal-retention records created before max-age cleanup. */
+  terminalStatus?: TerminalWorkflowRunStatus;
+  reason?: 'terminal-retention' | 'maximum-age' | 'manual';
   dueAt: Date;
   queueShards: number;
   phase: CleanupPhase;
@@ -24,8 +29,10 @@ interface CleanupRecord {
 interface RunTombstone {
   version: 1;
   runId: string;
-  terminalStatus: TerminalWorkflowRunStatus;
-  completedAt: Date;
+  /** Last status observed before the run expired. */
+  status?: WorkflowRunStatus;
+  completedAt?: Date;
+  terminalStatus?: TerminalWorkflowRunStatus;
   expiredAt: Date;
   tombstonedAt: Date;
   /** Final cleanup accounting retained inside the single authoritative record. */
@@ -54,7 +61,6 @@ interface ReleaseHookIndexesResult {
 }
 interface ExpireRunIndexesRequest {
   runId: string;
-  keys: string[];
   hooks: HookIndexReference[];
   expiredAt: number;
 }
@@ -357,13 +363,17 @@ interface QueueCellNamespace {
 interface IndexListOptions {
   prefix?: string;
   cursor?: string;
+  /** Exclusive upper bound for creation-time retention scans. */
+  end?: string;
   limit?: number;
   reverse?: boolean;
 }
 interface IndexListPage {
+  /** sourceShard is populated by the merged fleet index for exact follow-up mutation. */
   keys: Array<{
     name: string;
     value: string;
+    sourceShard?: string;
   }>;
   list_complete: boolean;
   cursor?: string;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/retention.ts","../src/apply-event.ts","../src/storage.ts","../src/stream-protocol.ts","../src/streamer.ts","../src/queue.ts","../src/indexes.ts","../src/config.ts","../src/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/retention.ts","../src/apply-event.ts","../src/storage.ts","../src/stream-protocol.ts","../src/streamer.ts","../src/queue.ts","../src/indexes.ts","../src/config.ts","../src/index.ts"],"mappings":"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"}