@graphrefly/ts 0.0.1 → 0.0.3

package/dist/{types-CcPIn7sy.d.cts → types-CTN3XoMl.d.cts}

@@ -6,7 +6,7 @@ import { L as LockId, W as Wave, P as PullDemand, M as Message } from './message
  * Canonical authority: ~/src/graphrefly/spec/rules.jsonl
  *   R-handle (D7), R-dispatch-all (D21), R-sync-core (D20/D21).
  *
- * Lifted from the validated handle-dispatch PoC (packages/pure-ts r8-poc, R8/R9):
+ * Lifted from the validated retired handle-dispatch PoC (R8/R9):
  * fn lives in an external pool, indexed by handle; `dispatcher.invoke` is uniformly
  * SYNC void — async/remote behavior lives in the fn body (it kicks off async work
  * and emits later via `ctx.down`), not in a different call mechanism.
@@ -290,21 +290,6 @@ type NodeVersionJson = NodeVersion;
  */
 declare function defaultNodeVersionHash(bytes: Uint8Array): string;
 
-/**
- * The node primitive — the thinnest substrate object (R-node-thin / D5).
- *
- * Holds a fn handle + deps + the wave state machine; ZERO inspection cruft
- * (naming/find/describe are the graph layer, CSP-2). Canonical authority:
- * ~/src/graphrefly/spec/rules.jsonl (R-node-*, R-two-phase, R-diamond, R-resolved-undirty,
- * R-first-run-gate, R-push-subscribe, R-rom-ram, R-fn-contract, R-initial, R-ctx-up).
- *
- * Slice 1 = core wave: state node, compute node, two-phase DIRTY->DATA, diamond
- * pending-counter join, first-run gate, substrate-synthesized undirty RESOLVED
- * (R-resolved-undirty / D49 — no equals-substitution; every occurrence is DATA),
- * push-on-subscribe, lazy activation, ROM/RAM. Lifecycle (terminal/INVALIDATE/cleanup),
- * control (PAUSE/async), batch, and dynamicNode land in later slices.
- */
-
 type Status = "sentinel" | "pending" | "dirty" | "settled" | "resolved" | "completed" | "errored";
 interface NodeOptions<T = unknown> {
     /** Pre-populate cache; source pushes [DATA, initial] on subscribe (R-initial). `null` is valid. */
@@ -336,8 +321,9 @@ interface NodeOptions<T = unknown> {
      * then RE-QUIETS (1:1). Delivery content =
      * the orthogonal `pausable` mode: `true` → coalesced LATEST (one DATA); `'resumeAll'` → buffered
      * BACKLOG. `pullId` + `pausable:false` is REJECTED at construction. A SELF-triggered demand (a
-     * consumer demanding a dep it ALSO reads) must defer via {@link Ctx.upNext} (R-rewire-deferred /
-     * D37). Author the pullId as a shared module const used at both this node and the demander's fn.
+     * consumer demanding a dep it ALSO reads) must defer via {@link import("../ctx/types.js").Ctx.upNext}
+     * (R-rewire-deferred / D37). Author the pullId as a shared module const used at both this node and
+     * the demander's fn.
      */
     pullId?: LockId;
     /** Buffer the last N outgoing DATA for late subscribers (R-replay-buffer). */
@@ -364,6 +350,37 @@ interface NodeOptions<T = unknown> {
      */
     factory?: string;
 }
+
+/**
+ * The node primitive — the thinnest substrate object (R-node-thin / D5).
+ *
+ * Holds a fn handle + deps + the wave state machine; ZERO inspection cruft
+ * (naming/find/describe are the graph layer, CSP-2). Canonical authority:
+ * ~/src/graphrefly/spec/rules.jsonl (R-node-*, R-two-phase, R-diamond, R-resolved-undirty,
+ * R-first-run-gate, R-push-subscribe, R-rom-ram, R-fn-contract, R-initial, R-ctx-up).
+ *
+ * Slice 1 = core wave: state node, compute node, two-phase DIRTY->DATA, diamond
+ * pending-counter join, first-run gate, substrate-synthesized undirty RESOLVED
+ * (R-resolved-undirty / D49 — no equals-substitution; every occurrence is DATA),
+ * push-on-subscribe, lazy activation, ROM/RAM. Lifecycle (terminal/INVALIDATE/cleanup),
+ * control (PAUSE/async), batch, and dynamicNode land in later slices.
+ */
+
+/**
+ * Reactive substrate node that owns dependencies, wave handling, lifecycle, and subscribers.
+ *
+ * @example
+ * ```ts
+ * import { node } from "@graphrefly/ts";
+ *
+ * const source = node<number>([], null);
+ * source.subscribe((value) => console.log(value));
+ * source.down([["DATA", 1]]);
+ * ```
+ * @remarks **Substrate primitive:** `Node` is graph-agnostic; use `graph().node`,
+ *   `graph().state`, or `graph().derived` when you want inspection and lifecycle ownership.
+ * @category core
+ */
 declare class Node<T = unknown> {
     private readonly _core;
     private readonly _id;
@@ -381,6 +398,7 @@ declare class Node<T = unknown> {
     private _released;
     private get _syncCtx();
     private set _syncCtx(value);
+    private static _retainIndirectRuntimeMethods;
     constructor(deps: Node<unknown>[], handleOrFn: Handle | NodeFn | null, opts?: NodeOptions<T>);
     /** R-pull (D55/D272): true while a pull node is not serving a PULL demand pulse. */
     private _isPullQuiet;
@@ -421,23 +439,6 @@ declare class Node<T = unknown> {
      * ONE declared edge (R-up-routing directed-up); omitted = broadcast up all deps.
      */
     up(msgs: Wave, towardDep?: number): void;
-    /**
-     * Enqueue a deferred self-rewire op (issued from this node's fn via `ctx.rewireNext`).
-     * Applied at the committed wave boundary (boundary.ts drain), never in place — the in-fn
-     * immediate path (`subscribeDep`/`replaceDeps`/`unsubscribeDep`) still throws mid-run (D37/R-reentrancy).
-     */
-    private _requestRewireNext;
-    /**
-     * Enqueue a deferred up-going control/demand wave (R-up-routing / R-pull / D269): at the committed wave
-     * boundary, route `msgs` up from THIS node (broadcast, or up the single `towardDep` edge). The
-     * deferred form of `ctx.up` — the SELF-demand path: a consumer issues `ctx.upNext([[PULL,
-     * { pullId }]])` to demand a dep it ALSO reads; the demand applies at the boundary (not mid-fn), so
-     * the pull node's delivery loops back as a FRESH wave rather than re-entering the consumer (D37 /
-     * R-reentrancy). Rides the same R-rewire-deferred (D47) drain as ctx.rewireNext.
-     */
-    private _requestUpNext;
-    /** Apply one queued self-rewire at the boundary (drain thunk). */
-    private _applyRewireNext;
     /**
      * Replace this node's deps atomically (surgical, Option-C). Requires an explicit
      * `fn` (SD-1 fn-deps pairing — user fns read dep input positionally). Kept deps
@@ -450,57 +451,29 @@ declare class Node<T = unknown> {
     subscribeDep(depNode: Node<unknown>, fn: NodeFn): number;
     /** Unsubscribe from one dep (special case of replaceDeps); idempotent if absent (fn swap still applies). */
     unsubscribeDep(depNode: Node<unknown>, fn: NodeFn): void;
+    private _requestRewireNext;
+    private _requestUpNext;
+    private _applyRewireNext;
     private _dedupDeps;
-    /** Is `target` reachable upstream from `from` (following deps)? Cycle-prevention DFS. */
     private _reachableUpstream;
     private _assertRewireDepOwner;
     private _rewire;
     private _activate;
-    /**
-     * Subscribe to a dep. The dispatch callback reads the dep's CURRENT index from a
-     * mutable box (O(1)); a surgical rewire that reorders kept deps just updates the box
-     * (R-rewire Option-C / D42) — no re-subscribe, no per-message indexOf scan. A removed
-     * dep's box is set to -1 so any stale in-flight callback drops (drain).
-     */
-    private _subscribeDepAt;
-    private _seedRestoredDepAt;
     private _deactivate;
     private _assertNotReleased;
     private _subscriberCount;
     private _isRuntimeQuiescentForRelease;
     private _releaseRuntime;
     private _resetDepState;
+    private _subscribeDepAt;
+    private _seedRestoredDepAt;
     private _recordDepProjection;
     private _depProjectionHasData;
     private _receiveFromDep;
-    /**
-     * R-terminal-settles-dirty (B35): release a dep's outstanding in-wave DIRTY contribution.
-     * A settle-class event for that dep (DATA/RESOLVED inline above, INVALIDATE, and now
-     * COMPLETE/ERROR) clears its dirty flag + decrements _pending. No-op if the dep already
-     * settled this wave (DATA/RESOLVED ran first) — so the normal DATA-then-COMPLETE flow is
-     * unaffected. This makes the exactly-one-settle invariant a single, shared step.
-     */
     private _releaseDepDirty;
-    /**
-     * R-terminal-settles-dirty (B35): settle a node whose dirtied dep was released by an ABSORBED
-     * terminal that is NOT a real input (a plain derived/effect — the common default-node case when
-     * one of several deps completes while others stay live). Runs only when the release drained
-     * _pending while the node still owes a downstream settle (it broadcast DIRTY this wave):
-     *   - if some OTHER dep delivered real DATA this wave (a value occurred) → recompute (→ DATA);
-     *   - else the terminal's signalled change did not materialise (no value) → one undirty RESOLVED
-     *     (R-resolved-undirty), keeping the cache (a terminal, unlike INVALIDATE, leaves the value).
-     * A terminalAsRealInput node instead recomputes unconditionally (its fn reads the terminal).
-     */
     private _settleAfterAbsorbedTerminal;
     private _markDirty;
     private _maybeRun;
-    /**
-     * R-rewire atomic settle (after a rewire that warrants a recompute): emit a proper
-     * two-phase DIRTY→DATA wave (R-dirty-before-data — a rewire-triggered settle is a wave),
-     * once, with every added dep already wired. Mirrors _maybeRun/_tryRun's pause + gate +
-     * pending guards, then injects the phase-1 DIRTY the added dep's [START,DATA] handshake
-     * did not carry.
-     */
     private _settleRewire;
     private _tryRun;
     private _allDepsSettled;
@@ -513,14 +486,6 @@ declare class Node<T = unknown> {
     private _down;
     private _up;
     private _markDemandRouted;
-    /**
-     * Forward one up-going control message toward deps (R-up-routing): up the single declared edge
-     * `towardDep` (directed — prunes other branches; only meaningful on the issuer's FIRST hop) or
-     * broadcast up ALL deps. A depless source has no deps → the message DROPS here (the terminus —
-     * e.g. a cone-routed PULL whose pullId no node up this cone holds, R-up-at-source). Recursive
-     * forwarding carries the same per-wave route state and no `towardDep` → broadcast beyond the
-     * first hop.
-     */
     private _forwardUp;
     private _isPaused;
     private _hasBoundaryPauseLock;
@@ -528,48 +493,17 @@ declare class Node<T = unknown> {
     private _pauseAcquire;
     private _pauseRelease;
     private _onResume;
-    /**
-     * R-pull (D269): can this pull node fire a demand NOW? — not terminal, settle-ready (_pending===0),
-     * and no OTHER (non-pullId) lock holds it paused. The gate that decides fire-now vs OWE.
-     */
     private _canFireDemand;
-    /**
-     * R-pull (D269/D272): deliver ONE demand pulse — install activePull so the demand wave may
-     * emit, fire it, then clear activePull so the node is quiet again (1:1).
-     */
     private _deliverPullDemand;
-    /**
-     * R-pull (D269): a cone-routed PULL of THIS node's pullId arrived (R-up-routing) = a DEMAND.
-     * Fire immediately if able; else OWE it — pin-5 (a dep DIRTY in flight, _pending>0) or F4/F5 (an
-     * external PAUSE lock co-holds the node) — and fire when the node next becomes able. A demand
-     * arriving WHILE a delivery is in flight (synchronous re-entry) is DROPPED (1:1, QA guard).
-     */
     private _onDemand;
-    /**
-     * R-pull (D55): service ONE demand. Delivery content = the orthogonal pausable mode:
-     *   - 'resumeAll' → drain the buffered BACKLOG (each `_down` re-synthesizes a leading DIRTY, so
-     *     the per-entry replay is DIRTY-before-DATA — R-pause-modes per-entry arrival order);
-     *   - true → deliver the coalesced LATEST as ONE DIRTY-before-DATA wave (pin 2: the quiet absorb
-     *     suppressed the dep's original DIRTY, so the demand wave restores it before the value).
-     * Neither branch fires when nothing changed since the last demand → the demand is SILENT.
-     * Called by `_deliverPullDemand` only when settle-ready; the caller has released the pullId, so
-     * `_markDirty` relays the leading DIRTY (not absorbed).
-     */
     private _firePullDemand;
-    /**
-     * R-pull (D269): fire a demand that was OWED (deferred at demand time) once the node becomes
-     * able — called from the dep-settle arms (DATA/RESOLVED/INVALIDATE/terminal drain _pending, pin-5
-     * + B1/F6) and from `_pauseRelease` (an external PAUSE lock releases, F4/F5).
-     */
     private _fireOwedDemandIfReady;
-    /** Should an outgoing settle slice be deferred into the pause buffer? */
     private _shouldBufferOnPause;
-    /** R-invalidate-idempotent: clear cache + flush + cascade; no-op if nothing cached. */
     private _invalidate;
     private _allDepsTerminal;
+    private _emitToSubs;
     /** R-terminal: resubscribable reset clears terminal + dep state + re-arms the gate. */
     private _resetLifecycle;
-    private _emitToSubs;
     /** Batch commit (R-batch-coalesce): deliver the deferred tier-3 wave now. */
     __commitBatchedWave(wave: Wave): void;
     /** Batch rollback: balance the immediate DIRTY with a RESOLVED so downstream un-dirties. */
@@ -583,6 +517,21 @@ declare class Node<T = unknown> {
  *   node([], fn)                        — producer (runs on activation)
  *   node([a, b], fn)                    — compute / derived
  *   node([dep])                         — passthrough wire
+ *
+ * @param deps - Upstream nodes this node reads positionally from `ctx`.
+ * @param handleOrFn - Dispatcher handle, node function, or `null` for a manual source/state node.
+ * @param opts - Node runtime options such as `initial`, `name`, pool, dispatcher, and restore data.
+ * @returns A graph-agnostic `Node`.
+ * @example
+ * ```ts
+ * import { depLatest, node } from "@graphrefly/ts";
+ *
+ * const source = node<number>([], null, { initial: 1 });
+ * const doubled = node<number>([source], (ctx) => {
+ *   ctx.down([["DATA", Number(depLatest(ctx, 0)) * 2]]);
+ * });
+ * ```
+ * @category core
  */
 declare function node<T = unknown>(deps?: Node<unknown>[], handleOrFn?: Handle | NodeFn | null, opts?: NodeOptions<T>): Node<T>;
 /**

package/dist/types-CV_ohy5T.d.cts

@@ -0,0 +1,357 @@
+import { DataIssue } from './data/index.cjs';
+import { L as LockId } from './messages-CAzUPPJM.cjs';
+import { N as Node } from './types-CTN3XoMl.cjs';
+import { d as MessageBus } from './types-BAw2QVVE.cjs';
+
+interface WorkQueueOptions<_T = unknown> {
+    readonly queueId: string;
+    readonly bus: MessageBus;
+    readonly topic: string;
+    readonly subscriptionId: string;
+    readonly from?: "earliest" | "latest" | number;
+    readonly name?: string;
+    readonly now?: () => number;
+    readonly leaseDurationMs?: number;
+    readonly retry?: WorkQueueRetryPolicy;
+}
+interface WorkQueueRetryPolicy {
+    readonly maxAttempts?: number;
+    readonly delayMs?: number;
+}
+interface WorkQueueCommandBase {
+    readonly commandId: string;
+    readonly queueId?: string;
+    readonly idempotencyKey?: string;
+    readonly correlationId?: string;
+    readonly causationId?: string;
+    readonly sourceRefs?: readonly string[];
+    readonly policyRefs?: readonly string[];
+    readonly actorRefs?: readonly string[];
+    readonly auditRefs?: readonly string[];
+    readonly nowMs?: number;
+}
+type WorkQueueCommand<T = unknown> = (WorkQueueCommandBase & {
+    readonly kind: "submit";
+    readonly payload: T;
+    readonly workId?: string;
+    readonly priority?: number;
+    readonly tags?: readonly string[];
+    readonly requirements?: readonly string[];
+    readonly notBeforeMs?: number;
+    readonly deadlineMs?: number;
+}) | (WorkQueueCommandBase & {
+    readonly kind: "claim";
+    readonly workerId: string;
+    readonly requestedWorkIds?: readonly string[];
+    readonly limit?: number;
+    readonly leaseDurationMs?: number;
+}) | (WorkQueueCommandBase & {
+    readonly kind: "renew-lease";
+    readonly workId: string;
+    readonly leaseId: string;
+    readonly attempt: number;
+    readonly workerId: string;
+    readonly leaseDurationMs?: number;
+    readonly leaseExpiresAtMs?: number;
+}) | (WorkQueueCommandBase & {
+    readonly kind: "release";
+    readonly workId: string;
+    readonly leaseId: string;
+    readonly attempt: number;
+    readonly workerId: string;
+    readonly reason?: string;
+}) | (WorkQueueCommandBase & {
+    readonly kind: "complete";
+    readonly workId: string;
+    readonly leaseId: string;
+    readonly attempt: number;
+    readonly workerId: string;
+    readonly result?: unknown;
+}) | (WorkQueueCommandBase & {
+    readonly kind: "fail";
+    readonly workId: string;
+    readonly leaseId: string;
+    readonly attempt: number;
+    readonly workerId: string;
+    readonly error?: unknown;
+    readonly retryable?: boolean;
+}) | (WorkQueueCommandBase & {
+    readonly kind: "cancel";
+    readonly workId: string;
+    readonly reason?: string;
+}) | (WorkQueueCommandBase & {
+    readonly kind: "schedule";
+    readonly workId: string;
+    readonly scheduleId?: string;
+    readonly scheduleAtMs?: number;
+    readonly runAtMs?: number;
+    readonly notBeforeMs: number;
+    readonly deadlineMs?: number;
+    readonly reason?: string;
+}) | (WorkQueueCommandBase & {
+    readonly kind: "expire-leases";
+    readonly workIds?: readonly string[];
+    readonly limit?: number;
+});
+interface WorkQueueRecordBase {
+    readonly kind: string;
+    readonly recordSeq: number;
+    readonly queueId: string;
+    readonly workId?: string;
+    readonly commandId?: string;
+    readonly idempotencyKey?: string;
+    readonly correlationId?: string;
+    readonly causationId?: string;
+    readonly sourceRefs?: readonly string[];
+    readonly policyRefs?: readonly string[];
+    readonly actorRefs?: readonly string[];
+    readonly auditRefs?: readonly string[];
+    readonly issueRefs?: readonly string[];
+    readonly recordedAtMs: number;
+}
+type WorkQueueRecord<T = unknown> = (WorkQueueRecordBase & {
+    readonly kind: "work-admitted";
+    readonly workId: string;
+    readonly payload: T;
+    readonly messageBus: {
+        readonly topic: string;
+        readonly seq: number;
+        readonly subscriptionId: string;
+    };
+    readonly priority?: number;
+    readonly tags?: readonly string[];
+    readonly requirements?: readonly string[];
+    readonly notBeforeMs?: number;
+    readonly deadlineMs?: number;
+}) | (WorkQueueRecordBase & {
+    readonly kind: "work-rejected" | "admission-rejected";
+    readonly workId?: string;
+    readonly messageBus?: {
+        readonly topic: string;
+        readonly seq: number;
+        readonly subscriptionId: string;
+    };
+    readonly reason: string;
+    readonly existingWorkId?: string;
+}) | (WorkQueueRecordBase & {
+    readonly kind: "work-scheduled";
+    readonly workId: string;
+    readonly scheduleId?: string;
+    readonly scheduleAtMs?: number;
+    readonly runAtMs?: number;
+    readonly notBeforeMs: number;
+    readonly deadlineMs?: number;
+    readonly reason?: string;
+}) | (WorkQueueRecordBase & {
+    readonly kind: "work-claimed";
+    readonly workId: string;
+    readonly leaseId: string;
+    readonly attempt: number;
+    readonly workerId: string;
+    readonly claimedAtMs: number;
+    readonly leaseExpiresAtMs: number;
+}) | (WorkQueueRecordBase & {
+    readonly kind: "lease-renewed";
+    readonly workId: string;
+    readonly leaseId: string;
+    readonly attempt: number;
+    readonly workerId: string;
+    readonly previousLeaseExpiresAtMs: number;
+    readonly leaseExpiresAtMs: number;
+    readonly renewedAtMs: number;
+}) | (WorkQueueRecordBase & {
+    readonly kind: "work-released";
+    readonly workId: string;
+    readonly leaseId: string;
+    readonly attempt: number;
+    readonly workerId: string;
+    readonly releasedAtMs: number;
+    readonly reason?: string;
+}) | (WorkQueueRecordBase & {
+    readonly kind: "lease-expired";
+    readonly workId: string;
+    readonly leaseId: string;
+    readonly attempt: number;
+    readonly workerId: string;
+    readonly leaseExpiresAtMs: number;
+    readonly expiredAtMs: number;
+}) | (WorkQueueRecordBase & {
+    readonly kind: "attempt-completed" | "work-completed";
+    readonly workId: string;
+    readonly leaseId: string;
+    readonly attempt: number;
+    readonly workerId: string;
+    readonly result?: unknown;
+}) | (WorkQueueRecordBase & {
+    readonly kind: "attempt-failed";
+    readonly workId: string;
+    readonly leaseId: string;
+    readonly attempt: number;
+    readonly workerId: string;
+    readonly error?: unknown;
+    readonly retryable?: boolean;
+}) | (WorkQueueRecordBase & {
+    readonly kind: "retry-scheduled";
+    readonly workId: string;
+    readonly retryAtMs: number;
+    readonly delayMs: number;
+    readonly reason?: string;
+}) | (WorkQueueRecordBase & {
+    readonly kind: "work-dead-lettered";
+    readonly workId: string;
+    readonly reason: string;
+    readonly exhaustedAttempts?: number;
+}) | (WorkQueueRecordBase & {
+    readonly kind: "work-canceled";
+    readonly workId: string;
+    readonly reason?: string;
+    readonly canceledAtMs: number;
+    readonly canceledLeaseId?: string;
+    readonly attempt?: number;
+}) | (WorkQueueRecordBase & {
+    readonly kind: "lifecycle-rejected" | "admission-deduped";
+    readonly workId?: string;
+    readonly messageBus?: {
+        readonly topic: string;
+        readonly seq: number;
+        readonly subscriptionId: string;
+    };
+    readonly reason: string;
+    readonly existingWorkId?: string;
+});
+interface WorkQueueStatus {
+    readonly kind: "command-accepted" | "command-rejected" | "admission-accepted" | "admission-rejected" | "admission-retryable" | "projection-ready" | "projection-partial" | "projection-stale" | "maintenance-applied" | "maintenance-noop" | "policy-warning";
+    readonly queueId: string;
+    readonly workId?: string;
+    readonly commandId?: string;
+    readonly recordSeq?: number;
+    readonly asOfRecordSeq?: number;
+    readonly issueCode?: string;
+    readonly timestampMs: number;
+    readonly details?: unknown;
+}
+interface WorkQueueAvailableItem<T = unknown> {
+    readonly workId: string;
+    readonly state: WorkQueueDerivedState;
+    readonly payload: T;
+    readonly admissionSeq: number;
+    readonly priority?: number;
+    readonly tags?: readonly string[];
+    readonly requirements?: readonly string[];
+    readonly notBeforeMs?: number;
+    readonly retryAtMs?: number;
+    readonly deadlineMs?: number;
+}
+interface WorkQueueAvailablePage<T = unknown> {
+    readonly items: readonly WorkQueueAvailableItem<T>[];
+    readonly nextAfterWorkId?: string;
+    readonly nextAfterAdmissionSeq?: number;
+    readonly hasMore: boolean;
+    readonly asOfRecordSeq: number;
+}
+interface WorkQueueWorkSnapshot<T = unknown> {
+    readonly workId: string;
+    readonly state?: WorkQueueDerivedState;
+    readonly payload?: T;
+    readonly activeLease?: {
+        readonly leaseId: string;
+        readonly attempt: number;
+        readonly workerId: string;
+        readonly leaseExpiresAtMs: number;
+    };
+    readonly records: readonly WorkQueueRecord<T>[];
+    readonly asOfRecordSeq: number;
+}
+interface WorkQueueDeadLetterPage<T = unknown> {
+    readonly entries: readonly WorkQueueRecord<T>[];
+    readonly nextAfterDeadLetterSeq?: number;
+    readonly hasMore: boolean;
+    readonly asOfRecordSeq: number;
+}
+interface WorkQueueAvailableParams {
+    readonly limit?: number;
+    readonly afterWorkId?: string;
+    readonly afterAdmissionSeq?: number;
+    readonly nowMs?: number;
+    readonly includeIssues?: boolean;
+}
+interface WorkQueueDeadLetterParams {
+    readonly limit?: number;
+    readonly afterDeadLetterSeq?: number;
+    readonly afterWorkId?: string;
+}
+type WorkQueueDerivedState = "scheduled" | "ready" | "leased" | "retry-wait" | "completed" | "canceled" | "dead-lettered";
+interface WorkQueueProjection<TPage> {
+    readonly snapshot: Node<TPage>;
+    readonly snapshotPullId: LockId;
+    readonly status: Node<WorkQueueStatus>;
+    readonly issues: Node<DataIssue>;
+}
+interface WorkQueueAvailableProjection<T = unknown> {
+    readonly available: Node<WorkQueueAvailablePage<T>>;
+    readonly availablePullId: LockId;
+    readonly status: Node<WorkQueueStatus>;
+    readonly issues: Node<DataIssue>;
+}
+interface WorkQueue<T = unknown> {
+    readonly commands: Node<WorkQueueCommand<T>>;
+    readonly records: Node<WorkQueueRecord<T>>;
+    readonly status: Node<WorkQueueStatus>;
+    readonly issues: Node<DataIssue>;
+    submit(payload: T, opts?: Omit<Partial<Extract<WorkQueueCommand<T>, {
+        kind: "submit";
+    }>>, "kind" | "payload" | "commandId"> & {
+        commandId?: string;
+    }): unknown;
+    claim(opts: Omit<Extract<WorkQueueCommand<T>, {
+        kind: "claim";
+    }>, "kind" | "commandId"> & {
+        commandId?: string;
+    }): WorkQueueCommand<T>;
+    renewLease(opts: Omit<Extract<WorkQueueCommand<T>, {
+        kind: "renew-lease";
+    }>, "kind" | "commandId"> & {
+        commandId?: string;
+    }): WorkQueueCommand<T>;
+    release(opts: Omit<Extract<WorkQueueCommand<T>, {
+        kind: "release";
+    }>, "kind" | "commandId"> & {
+        commandId?: string;
+    }): WorkQueueCommand<T>;
+    complete(opts: Omit<Extract<WorkQueueCommand<T>, {
+        kind: "complete";
+    }>, "kind" | "commandId"> & {
+        commandId?: string;
+    }): WorkQueueCommand<T>;
+    fail(opts: Omit<Extract<WorkQueueCommand<T>, {
+        kind: "fail";
+    }>, "kind" | "commandId"> & {
+        commandId?: string;
+    }): WorkQueueCommand<T>;
+    cancel(opts: Omit<Extract<WorkQueueCommand<T>, {
+        kind: "cancel";
+    }>, "kind" | "commandId"> & {
+        commandId?: string;
+    }): WorkQueueCommand<T>;
+    schedule(opts: Omit<Extract<WorkQueueCommand<T>, {
+        kind: "schedule";
+    }>, "kind" | "commandId"> & {
+        commandId?: string;
+    }): WorkQueueCommand<T>;
+    expireLeases(opts?: Omit<Extract<WorkQueueCommand<T>, {
+        kind: "expire-leases";
+    }>, "kind" | "commandId"> & {
+        commandId?: string;
+    }): WorkQueueCommand<T>;
+    available(opts?: {
+        name?: string;
+    }): WorkQueueAvailableProjection<T>;
+    work(workId: string, opts?: {
+        name?: string;
+    }): WorkQueueProjection<WorkQueueWorkSnapshot<T>>;
+    deadLetter(opts?: {
+        name?: string;
+    }): WorkQueueProjection<WorkQueueDeadLetterPage<T>>;
+}
+
+export type { WorkQueueCommand as W, WorkQueueRecord as a, WorkQueueOptions as b, WorkQueue as c, WorkQueueAvailableItem as d, WorkQueueAvailablePage as e, WorkQueueAvailableParams as f, WorkQueueAvailableProjection as g, WorkQueueDeadLetterPage as h, WorkQueueDeadLetterParams as i, WorkQueueDerivedState as j, WorkQueueProjection as k, WorkQueueRetryPolicy as l, WorkQueueStatus as m, WorkQueueWorkSnapshot as n };