@ewhauser/world-celld 0.1.1 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 All notable changes to this project will be documented in this file.
 
+## 0.3.0 (2026-08-16)
+
+## What's Changed
+* fix: split Release Please release and PR phases by @ewhauser in https://github.com/ewhauser/world-celld/pull/16
+* feat: target Workflow 5 beta by @ewhauser in https://github.com/ewhauser/world-celld/pull/17
+* fix: enforce Workflow 5 storage contracts by @ewhauser in https://github.com/ewhauser/world-celld/pull/19
+
+
+**Full Changelog**: https://github.com/ewhauser/world-celld/compare/v0.2.0...v0.3.0
+
+## 0.2.0 (2026-08-16)
+
+## What's Changed
+* Patch vulnerable Hono test dependencies by @ewhauser in https://github.com/ewhauser/world-celld/pull/8
+* chore(deps-dev): bump typescript from 5.9.3 to 7.0.2 by @dependabot[bot] in https://github.com/ewhauser/world-celld/pull/3
+* Fix flaky harness teardown by @ewhauser in https://github.com/ewhauser/world-celld/pull/10
+* Add terminal workflow retention by @ewhauser in https://github.com/ewhauser/world-celld/pull/11
+* chore(deps): bump the production-dependencies group across 1 directory with 3 updates by @dependabot[bot] in https://github.com/ewhauser/world-celld/pull/1
+* ci: automate releases with Release Please by @ewhauser in https://github.com/ewhauser/world-celld/pull/13
+* chore(deps-dev): bump the development-dependencies group across 1 directory with 2 updates by @dependabot[bot] in https://github.com/ewhauser/world-celld/pull/12
+* fix: exclude generated changelog from formatting by @ewhauser in https://github.com/ewhauser/world-celld/pull/15
+
+## New Contributors
+* @dependabot[bot] made their first contribution in https://github.com/ewhauser/world-celld/pull/3
+
+**Full Changelog**: https://github.com/ewhauser/world-celld/compare/v0.1.1...v0.2.0
+
 ## 0.1.1 - 2026-08-15
 
 - Publish through npm trusted publishing with OIDC provenance.

package/README.md

@@ -16,6 +16,7 @@ self-hosted alternative to platform-specific Workflow backends.
 - Workflow run, step, event, and hook persistence
 - Durable streams
 - Delayed work, retries, deduplication, and dead-letter storage
+- Configurable cleanup of terminal workflow payloads
 - An authenticated HTTP connection between a Node application and a celld fleet
 - An in-process fleet for local development and conformance testing
 
@@ -64,6 +65,8 @@ const world = createCelldWorld({
   fleetUrl: 'http://fleet.internal:8080',
   secret: process.env.CELLD_WORLD_SECRET!,
   baseUrl: 'https://workflow.example.com',
+  // Keep completed, failed, and cancelled run payloads for 30 days.
+  runRetentionMs: 30 * 24 * 60 * 60 * 1000,
 });
 ```
 
@@ -122,7 +125,7 @@ celld worker router
           |
           | HTTP callbacks
           v
-Workflow application /.well-known/workflow/v1/{flow|step}
+Workflow application /.well-known/workflow/v1/flow
 ```
 
 The application-side package implements the Workflow `World` interface and
@@ -135,15 +138,16 @@ cell that owns the data.
 Application options can be passed to `createCelldWorld()` unless an environment
 variable is shown below.
 
-| Option         | Environment variable  | Default                  |
-| -------------- | --------------------- | ------------------------ |
-| `fleetUrl`     | `CELLD_FLEET_URL`     | required                 |
-| `secret`       | `CELLD_WORLD_SECRET`  | required with `fleetUrl` |
-| `baseUrl`      | `WORKFLOW_BASE_URL`   | `http://localhost:$PORT` |
-| `deploymentId` | `CELLD_DEPLOYMENT_ID` | `celld-default`          |
-| `queueShards`  | —                     | `1`                      |
-| `readPollMs`   | —                     | `250`                    |
-| `rpcTimeoutMs` | —                     | `30000`                  |
+| Option           | Environment variable     | Default                  |
+| ---------------- | ------------------------ | ------------------------ |
+| `fleetUrl`       | `CELLD_FLEET_URL`        | required                 |
+| `secret`         | `CELLD_WORLD_SECRET`     | required with `fleetUrl` |
+| `baseUrl`        | `WORKFLOW_BASE_URL`      | `http://localhost:$PORT` |
+| `deploymentId`   | `CELLD_DEPLOYMENT_ID`    | `celld-default`          |
+| `queueShards`    | —                        | `1`                      |
+| `runRetentionMs` | `CELLD_RUN_RETENTION_MS` | `0` (disabled)           |
+| `readPollMs`     | —                        | `250`                    |
+| `rpcTimeoutMs`   | —                        | `30000`                  |
 
 The deployed worker also accepts these celld variables:
 
@@ -158,12 +162,45 @@ The deployed worker also accepts these celld variables:
 `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
+
+When `runRetentionMs` is greater than zero, a terminal transition atomically
+records the run's `expiredAt` and arms its cell alarm. The complete run, event,
+step, hook, and stream data remains readable until that deadline. Active and
+pending runs are never eligible for automatic cleanup.
+
+At expiration, the run cell fences new writes and removes the run's derived
+indexes, stream chunks, pending and dead-letter queue messages, and durable run
+payloads. Cleanup is a persisted, idempotent state machine: an interrupted
+phase records its error and re-arms itself with capped backoff.
+
+The final state is a metadata-only tombstone, not an empty cell. It prevents a
+delayed queue delivery or stale RPC from recreating an expired run. Reads and
+writes against that run return `RunExpiredError`, and the run no longer appears
+in listings. Tombstones contain no workflow input, output, event, step, hook,
+stream, or queue payload.
+
+The returned World exposes authenticated operational methods:
+
+```ts
+const status = await world.retention.getStatus(runId);
+await world.retention.schedule(runId); // requires runRetentionMs > 0
+await world.retention.cleanupNow(runId);
+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.
+
 ## Operational notes
 
 - Delivery is at least once. Workflow steps and other external side effects
   must be idempotent.
 - Queue cells expose `stats`, `listDeadLetters`, `redriveDeadLetter`,
   `purgeDeadLetters`, and `rearmAlarm` through the authenticated RPC endpoint.
+- Run cells expose retention status, scheduling, immediate cleanup, and alarm
+  recovery through `world.retention`.
 - A new application URL applies to newly enqueued messages. Existing messages
   retain the callback URL with which they were created.
 - Fleet restarts can interrupt in-flight callbacks; expired claims are
@@ -176,7 +213,7 @@ pnpm format
 pnpm check
 ```
 
-`pnpm check` runs formatting, linting, type checking, tests, the build, and the
+`pnpm check` runs formatting, linting, type checking, the build, tests, and the
 worker and npm-package checks. The package check inspects the exact tarball and
 installs it in a clean temporary consumer with lifecycle scripts disabled.
 Oxlint runs its correctness, suspicious, and performance categories with
@@ -193,12 +230,12 @@ pnpm test:integration
 ### Local MinIO performance and loss test
 
 The opt-in performance harness starts a fresh MinIO bucket and a single celld
-node with Docker Compose, sends concurrent queue traffic, and verifies that
-every accepted message reaches a successful callback. A configurable portion
-of callbacks returns one `503` first, so the same run also exercises durable
-redelivery. The result includes enqueue and delivery throughput plus p50, p95,
-p99, and maximum latency for all deliveries, first-attempt successes, and
-retried messages. It is saved to `.perf-results/minio-latest.json`.
+node with Docker Compose. Its queue workload verifies that every accepted
+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/`.
 
 > MinIO Community is **not a supported celld production store**. It does not
 > implement the conditional writes celld needs for ownership fencing. This
@@ -275,12 +312,13 @@ job needs. Third-party actions are pinned to verified release commits. Release
 builds do not use caches, and the exact npm tarball is checksummed, clean-room
 installed, and verified again before publication.
 
-Releases publish from GitHub-hosted runners through npm trusted publishing
-(OIDC), without a long-lived npm token. npm records provenance for public
-releases. The Git tag and GitHub release are created only after npm accepts the
-matching tarball; published GitHub releases are immutable. Dependency updates
-use cooldowns, and pnpm permits lifecycle scripts only for an explicit
-allowlist.
+Release Please maintains version and changelog pull requests. Releases publish
+from GitHub-hosted runners through npm trusted publishing (OIDC), without a
+long-lived npm token. npm records provenance for public releases. A draft
+GitHub release holds the release notes while the package is verified; the Git
+tag and public release are created only after npm accepts the matching tarball.
+Published GitHub releases are immutable. Dependency updates use cooldowns, and
+pnpm permits lifecycle scripts only for an explicit allowlist.
 
 See [`SECURITY.md`](./SECURITY.md) to report a vulnerability and
 [`RELEASING.md`](./RELEASING.md) for the release procedure.

package/dist/index.d.ts

@@ -1,9 +1,76 @@
-import { CreateEventRequest, Event, Hook, RunCreatedEventRequest, Step, ValidQueueName, WorkflowRun, World } from "@workflow/world";
+import { CreateEventParams, CreateEventRequest, Event, Hook, RunCreatedEventRequest, Step, TerminalWorkflowRunStatus, ValidQueueName, Wait, WorkflowRun, World } from "@workflow/world";
+//#region src/retention.d.ts
+type CleanupPhase = 'retained' | 'index' | 'streams' | 'queues' | 'payload' | 'tombstoned';
+interface CleanupRecord {
+  version: 1;
+  runId: string;
+  workflowName: string;
+  createdAt: Date;
+  completedAt: Date;
+  terminalStatus: TerminalWorkflowRunStatus;
+  dueAt: Date;
+  queueShards: number;
+  phase: CleanupPhase;
+  attempts: number;
+  lastError?: string;
+  lastAttemptAt?: Date;
+  tombstonedAt?: Date;
+  deletedPayloadKeys: number;
+  deletedStreams: number;
+  deletedQueueMessages: number;
+}
+interface RunTombstone {
+  version: 1;
+  runId: string;
+  terminalStatus: TerminalWorkflowRunStatus;
+  completedAt: Date;
+  expiredAt: Date;
+  tombstonedAt: Date;
+}
+type RunReadOutcome<T> = {
+  ok: true;
+  value: T;
+} | {
+  ok: false;
+  code: 'RUN_EXPIRED';
+  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 ExpireStreamResult {
+  deleted: boolean;
+  chunks: number;
+}
+interface ExpireQueueRunResult {
+  deleted: number;
+}
+interface ScheduleCleanupRequest {
+  retentionMs: number;
+  queueShards: number;
+}
+//#endregion
 //#region src/apply-event.d.ts
 interface ApplyEventRequest {
   /** The effective run id (already resolved / generated by the caller). */
   runId: string;
   data: CreateEventRequest | RunCreatedEventRequest;
+  /** Workflow 5 event-log position and preload options. */
+  params?: CreateEventParams;
   /**
    * Current holder of the hook token per the global KV token index
    * (hook_created only). `null` means the token is unclaimed.
@@ -12,8 +79,10 @@ interface ApplyEventRequest {
     runId: string;
     hookId: string;
   } | null;
+  /** Internal world-celld retention policy captured with the event. */
+  cleanup?: ScheduleCleanupRequest;
 }
-type ApplyEventErrorCode = 'RUN_NOT_FOUND' | 'STEP_NOT_FOUND' | 'HOOK_NOT_FOUND' | 'ENTITY_CONFLICT' | 'RUN_EXPIRED' | 'TOO_EARLY' | 'RUN_NOT_SUPPORTED' | 'LEGACY_RUN_NOT_SUPPORTED';
+type ApplyEventErrorCode = 'RUN_NOT_FOUND' | 'STEP_NOT_FOUND' | 'HOOK_NOT_FOUND' | 'WAIT_NOT_FOUND' | 'ENTITY_CONFLICT' | 'RUN_EXPIRED' | 'TOO_EARLY' | 'RUN_NOT_SUPPORTED';
 interface ApplyEventFailure {
   ok: false;
   code: ApplyEventErrorCode;
@@ -30,6 +99,9 @@ interface ApplyEventSuccess {
   run?: WorkflowRun;
   step?: Step;
   hook?: Hook;
+  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. */
   releasedHooks: Array<{
     hookId: string;
@@ -44,6 +116,11 @@ interface ApplyEventSuccess {
   hookToIndex?: Hook;
   /** All events (ascending), preloaded for run_started responses. */
   events?: Event[];
+  /** Pagination metadata required whenever events are returned. */
+  cursor?: string | null;
+  hasMore?: boolean;
+  /** Server-owned event ceiling advertised on run lifecycle writes. */
+  maxEvents?: number;
 }
 type ApplyEventOutcome = ApplyEventSuccess | ApplyEventFailure;
 //#endregion
@@ -54,36 +131,40 @@ type ApplyEventOutcome = ApplyEventSuccess | ApplyEventFailure;
  */
 interface WorkflowRunDOStub {
   applyEvent(request: ApplyEventRequest): Promise<ApplyEventOutcome>;
-  getRun(): Promise<WorkflowRun | null>;
-  getStep(stepId: string): Promise<Step | null>;
-  getEvent(eventId: string): Promise<Event | null>;
+  getRun(): Promise<RunReadOutcome<WorkflowRun | null>>;
+  getStep(stepId: string): Promise<RunReadOutcome<Step | null>>;
+  getEvent(eventId: string): Promise<RunReadOutcome<Event | null>>;
   listEvents(params?: {
     limit?: number;
     cursor?: string;
     sortOrder?: 'asc' | 'desc';
-  }): Promise<{
+  }): Promise<RunReadOutcome<{
     data: Event[];
     cursor: string | null;
     hasMore: boolean;
-  }>;
+  }>>;
   listSteps(params?: {
     limit?: number;
     cursor?: string;
     sortOrder?: 'asc' | 'desc';
-  }): Promise<{
+  }): Promise<RunReadOutcome<{
     data: Step[];
     cursor: string | null;
     hasMore: boolean;
-  }>;
+  }>>;
   listHooks(params?: {
     limit?: number;
     cursor?: string;
     sortOrder?: 'asc' | 'desc';
-  }): Promise<{
+  }): Promise<RunReadOutcome<{
     data: Hook[];
     cursor: string | null;
     hasMore: boolean;
-  }>;
+  }>>;
+  getCleanupStatus(): Promise<CleanupRecord | null>;
+  scheduleCleanup(request: ScheduleCleanupRequest): Promise<CleanupRecord | null>;
+  cleanupNow(request: ScheduleCleanupRequest): Promise<CleanupRecord | null>;
+  rearmCleanup(): Promise<CleanupRecord | null>;
 }
 interface WorkflowRunDONamespace {
   idFromName(name: string): DurableObjectIdLike;
@@ -100,8 +181,8 @@ interface DurableObjectIdLike {
  * protocol.
  */
 interface StreamDOStub {
-  writeChunk(data: Uint8Array): Promise<number>;
-  closeStream(): Promise<void>;
+  writeChunk(runId: string, data: Uint8Array): Promise<number>;
+  closeStream(runId: string): Promise<void>;
   getChunks(params: {
     startIndex: number;
     limit: number;
@@ -114,8 +195,11 @@ interface StreamDOStub {
     tailIndex: number;
     done: boolean;
   }>;
-  registerStream(name: string): Promise<void>;
+  registerStream(runId: string, name: string): Promise<void>;
   listStreams(): Promise<string[]>;
+  expireRegistry(runId: string, expiredAt: number): Promise<ExpireRunStreamsResult>;
+  finalizeRegistry(runId: string): Promise<void>;
+  expireStream(runId: string, expiredAt: number): Promise<ExpireStreamResult>;
 }
 interface StreamDONamespace {
   idFromName(name: string): StreamDOId;
@@ -126,7 +210,7 @@ interface StreamDOId {
 }
 //#endregion
 //#region src/queue.d.ts
-type Pathname = 'flow' | 'step';
+type Pathname = 'flow';
 /**
  * Enqueue request accepted by a QueueDO cell. The message payload travels
  * pre-encoded with the shared tagged-JSON codec (`body`), so the cell can
@@ -138,6 +222,8 @@ interface EnqueueRequest {
   pathname: Pathname;
   /** `stringify(message)` — the exact bytes POSTed to the app on delivery. */
   body: string;
+  /** Owning workflow run; absent only for health-check messages. */
+  runId?: string;
   idempotencyKey?: string;
   delaySeconds?: number;
   /**
@@ -147,7 +233,7 @@ interface EnqueueRequest {
   config: QueueCellConfig;
 }
 interface QueueCellConfig {
-  /** Base URL of the app; deliveries POST to `${baseUrl}/.well-known/workflow/v1/{flow|step}`. */
+  /** Base URL of the app; deliveries POST to `${baseUrl}/.well-known/workflow/v1/flow`. */
   targetBaseUrl: string;
   queueShards: number;
 }
@@ -157,12 +243,13 @@ type EnqueueOutcome = {
   deduped: boolean;
 } | {
   ok: false;
-  code: 'CONFIG_MISMATCH';
+  code: 'CONFIG_MISMATCH' | 'RUN_EXPIRED';
   message: string;
 };
 /** RPC surface of QueueDO used by the queue producer. */
 interface QueueCellStub {
   enqueue(request: EnqueueRequest): Promise<EnqueueOutcome>;
+  expireRun(runId: string, expiredAt: number): Promise<ExpireQueueRunResult>;
 }
 interface QueueCellNamespace {
   idFromName(name: string): {
@@ -179,6 +266,10 @@ interface IndexNamespace {
   get(key: string): Promise<string | null>;
   put(key: string, value: string): Promise<void>;
   delete(key: string): Promise<void>;
+  putOwned(runId: string, key: string, value: string): Promise<{
+    stored: boolean;
+  }>;
+  expireRun(request: ExpireRunIndexesRequest): Promise<ExpireRunIndexesResult>;
   list(options?: {
     prefix?: string;
     cursor?: string;
@@ -231,12 +322,18 @@ interface CelldWorldConfig {
   deploymentId?: string;
   /**
    * Base URL the app's workflow endpoints are mounted on; QueueDO cells
-   * deliver to `${baseUrl}/.well-known/workflow/v1/{flow|step}`.
+   * deliver to `${baseUrl}/.well-known/workflow/v1/flow`.
    * Default: process.env.WORKFLOW_BASE_URL || `http://localhost:${PORT ?? 3000}`
    */
   baseUrl?: string;
   /** Number of queue cells to spread enqueues over. Default: 1 */
   queueShards?: number;
+  /**
+   * Keep terminal run payloads for this many milliseconds before replacing
+   * them with metadata-only tombstones. Zero disables automatic cleanup.
+   * Default: process.env.CELLD_RUN_RETENTION_MS || 0
+   */
+  runRetentionMs?: number;
   /** Poll interval (ms) while waiting for new chunks on a live stream. Default: 250 */
   readPollMs?: number;
   /** Per-attempt fleet RPC deadline in milliseconds. Default: 30000 */
@@ -244,7 +341,16 @@ interface CelldWorldConfig {
 }
 //#endregion
 //#region src/index.d.ts
-declare function createCelldWorld(config?: CelldWorldConfig): World;
+interface CelldRetentionAdmin {
+  getStatus(runId: string): Promise<CleanupRecord | null>;
+  schedule(runId: string): Promise<CleanupRecord | null>;
+  cleanupNow(runId: string): Promise<CleanupRecord | null>;
+  rearm(runId: string): Promise<CleanupRecord | null>;
+}
+type CelldWorld = World & {
+  retention: CelldRetentionAdmin;
+};
+declare function createCelldWorld(config?: CelldWorldConfig): CelldWorld;
 //#endregion
-export { type CelldWorldConfig, type CelldWorldEnv, type EnqueueOutcome, type EnqueueRequest, type IndexNamespace, type QueueCellConfig, type QueueCellNamespace, type QueueCellStub, type StreamDONamespace, type StreamDOStub, type WorkflowRunDONamespace, type WorkflowRunDOStub, createCelldWorld, createCelldWorld as createWorld };
+export { CelldRetentionAdmin, CelldWorld, type CelldWorldConfig, type CelldWorldEnv, type CleanupPhase, type CleanupRecord, type EnqueueOutcome, type EnqueueRequest, type IndexNamespace, type QueueCellConfig, type QueueCellNamespace, type QueueCellStub, type RunTombstone, type StreamDONamespace, type StreamDOStub, type WorkflowRunDONamespace, type WorkflowRunDOStub, createCelldWorld, createCelldWorld as createWorld };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/apply-event.ts","../src/storage.ts","../src/streamer.ts","../src/queue.ts","../src/config.ts","../src/index.ts"],"mappings":";;UAsFiB;;EAEf;EACA,MAAM,qBAAqB;;;;;EAK3B;IAAgB;IAAe;;;KAGrB;UAUK;EACf;EACA,MAAM;EACN;;EAEA;;EAEA;;UAGe;EACf;;EAEA,QAAQ;EACR,MAAM;EACN,OAAO;EACP,OAAO;;EAEP,eAAe;IAAQ;IAAgB;;;EAEvC;IAAe;IAAsB,WAAW;;;EAEhD,cAAc;;EAEd,SAAS;;KAGC,oBAAoB,oBAAoB;;;;;;;UCrFnC;EACf,WAAW,SAAS,oBAAoB,QAAQ;EAChD,UAAU,QAAQ;EAClB,QAAQ,iBAAiB,QAAQ;EACjC,SAAS,kBAAkB,QAAQ;EACnC,WAAW;IACT;IACA;IACA;MACE;IAAU,MAAM;IAAS;IAAuB;;EACpD,UAAU;IACR;IACA;IACA;MACE;IAAU,MAAM;IAAQ;IAAuB;;EACnD,UAAU;IACR;IACA;IACA;MACE;IAAU,MAAM;IAAQ;IAAuB;;;UAGpC;EACf,WAAW,eAAe;EAC1B,IAAI,IAAI,sBAAsB;;UAGf;EACf;;;;;;;;;UCpDe;EACf,WAAW,MAAM,aAAa;EAC9B,eAAe;EACf,UAAU;IACR;IACA;MACE;IAAU,QAAQ;IAAc;IAAe;;EACnD,WAAW;IAAU;IAAmB;;EACxC,eAAe,eAAe;EAC9B,eAAe;;UAGA;EACf,WAAW,eAAe;EAC1B,IAAI,IAAI,aAAa;;UAGN;EACf;;;;KCYG;;;;;;UAoBY;EACf;EACA,WAAW;EACX,UAAU;;EAEV;EACA;EACA;;;;;EAKA,QAAQ;;UAGO;;EAEf;EACA;;KAGU;EACN;EAAU;EAAmB;;EAC7B;EAAW;EAAyB;;;UAGzB;EACf,QAAQ,SAAS,iBAAiB,QAAQ;;UAG3B;EACf,WAAW;IAAiB;;EAC5B,IAAI;IAAM;MAAuB;;;;;UCtGlB;EACf,IAAI,cAAc;EAClB,IAAI,aAAa,gBAAgB;EACjC,OAAO,cAAc;EACrB,KAAK;IAAY;IAAiB;IAAiB;IAAgB;MAAsB;IACvF,MAAM;MAAQ;;IACd;IACA;;EAEF,iBACE,eACA,OAAO,iBACN;IAAU;IAAkB,SAAS;;EACxC,oBACE,eACA,gBACA,wBACA,OAAO,iBACN;EACH,iBAAiB,eAAe,OAAO,iBAAiB;EACxD,kBAAkB,eAAe,gBAAgB,OAAO,iBAAiB;;UAG1D;EACf;EACA;;UAGe;EACf,aAAa;EACb,gBAAgB;EAChB,gBAAgB;EAChB,kBAAkB;;UAGH;;;;;;;EAOf;;;;;EAKA;;;;;EAKA,MAAM;;EAEN;;;;;;EAMA;;EAEA;;EAEA;;EAEA;;;;iBChDc,iBAAiB,SAAS,mBAAmB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/retention.ts","../src/apply-event.ts","../src/storage.ts","../src/streamer.ts","../src/queue.ts","../src/config.ts","../src/index.ts"],"mappings":"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"}