@fungi.computer/carrier 0.2.0 → 0.2.2

package/dist/post.d.ts

@@ -2,9 +2,7 @@ import * as Schema from "effect/Schema";
 import { type PostDeliveryResult } from "./internal/post-contract.js";
 export { PostError, PostDeliveryResultSchema, } from "./internal/post-contract.js";
 export type { PostDeliveryResult } from "./internal/post-contract.js";
-import type { WatchdogRunningJob, WatchdogSqliteOwner, WatchdogRuntime, WatchdogTransactionalProjection } from "@fungi.computer/watchdog";
-export { makePostOutbox, postOutboxPending } from "./post-outbox.js";
-export type { PostOutbox, PostOutboxStore } from "./post-outbox.js";
+import type { WatchdogRunningJob, WatchdogSqliteOwner, WatchdogAttempt, WatchdogRetryPolicy, WatchdogExecutionDecision, WatchdogTransactionalProjection } from "@fungi.computer/watchdog";
 /** Wire envelope parsed at the durable row and receiver boundaries. */
 export declare const PostEnvelopeSchema: Schema.Struct<{
     readonly key: Schema.String;
@@ -21,21 +19,17 @@ export declare const PostRowSchema: Schema.fromJsonString<Schema.Union<readonly
         readonly address: Schema.Unknown;
         readonly event: Schema.Unknown;
     }>;
-    readonly attempts: Schema.Int;
-    readonly nextAttemptAt: Schema.Number;
     readonly deadlineAt: Schema.optional<Schema.Number>;
-    readonly jobId: Schema.optional<Schema.String>;
+    readonly jobId: Schema.String;
     readonly delivery: Schema.optional<Schema.Struct<{
         readonly key: Schema.String;
         readonly kind: Schema.String;
         readonly address: Schema.Unknown;
         readonly event: Schema.Unknown;
     }>>;
-    readonly nextKey: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
     readonly state: Schema.Literal<"delivered">;
     readonly receipt: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-    readonly nextKey: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
     readonly state: Schema.Literal<"dead">;
     readonly envelope: Schema.Struct<{
@@ -54,7 +48,6 @@ export declare const PostRowSchema: Schema.fromJsonString<Schema.Union<readonly
         readonly address: Schema.Unknown;
         readonly event: Schema.Unknown;
     }>>;
-    readonly nextKey: Schema.optional<Schema.String>;
 }>]>>;
 /** One addressed event identified by the producer's stable key. */
 export type PostEnvelope = Schema.Schema.Type<typeof PostEnvelopeSchema>;
@@ -147,13 +140,11 @@ export type PostRuntime<R extends Record<string, PostRegistryRoute>> = Readonly<
         address: Schema.Schema.Type<R[K]["address"]>;
         event: Schema.Schema.Type<R[K]["event"]>;
     }>) => void;
-    /** Run as the Watchdog executor for a claimed Post job. */
-    execute: (job: WatchdogRunningJob) => Promise<Readonly<{
-        kind: "completed";
-    }>>;
-    /** Recover settled delivery jobs and enqueue due retries after a wake. */
-    enqueueDue: (limit?: number, afterKey?: string) => Promise<string | undefined>;
-    /** Release settled pending retries from backoff without resetting attempts. */
+    /** Resolve the retained route deadline or ordinary attempt ceiling. */
+    retryPolicy: (job: WatchdogRunningJob) => Promise<WatchdogRetryPolicy>;
+    /** Deliver using Watchdog's durably reserved attempt. */
+    execute: (job: WatchdogRunningJob, attempt: WatchdogAttempt | undefined, signal?: AbortSignal) => Promise<WatchdogExecutionDecision>;
+    /** Expedite queued deliveries without resetting their charged attempt count. */
     releaseNow: (limit?: number, afterKey?: string) => Promise<string | undefined>;
     /** Read an ordered page of refused, exhausted or expired keys for operators. */
     deadLetters: (limit?: number, afterKey?: string) => Readonly<{
@@ -174,15 +165,12 @@ export type PostRuntime<R extends Record<string, PostRegistryRoute>> = Readonly<
     retry: (key: string) => Promise<void>;
     /** Inspect one producer-local row or receipt. */
     read: (key: string) => PostRow | undefined;
-    /** Earliest pending queue head, including a settled job waiting to retry. */
-    nextWake: () => number | null;
 }>;
 /** Decode at both persisted and DO boundaries with the route's Effect Schema. */
 export declare function createPost<R extends Record<string, PostRegistryRoute>>(options: Readonly<{
     routes: R;
     owner: WatchdogSqliteOwner;
     transactional: WatchdogTransactionalProjection;
-    readJob: WatchdogRuntime["read"];
     now: () => number;
     scheduleWake: (at: number) => Promise<void>;
 }>): PostRuntime<R>;

package/dist/post.js

@@ -3,9 +3,7 @@ import { PostError, } from "./internal/post-contract.js";
 export { PostError, PostDeliveryResultSchema, } from "./internal/post-contract.js";
 import { deliverPost, postDisposition, deliveryReceipt, } from "./internal/post-execution.js";
 import { defineIdFamily } from "@fungi.computer/cairn";
-import { backoffDelay } from "@fungi.computer/almanac";
-import { maxDeliveryAttempts, postRetryPolicy } from "./post-outbox.js";
-export { makePostOutbox, postOutboxPending } from "./post-outbox.js";
+import { maxDeliveryAttempts, postRetryPolicy, } from "./internal/post-policy.js";
 const Key = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256));
 const JobPayload = Schema.Struct({ postKey: Key });
 const PageLimit = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(64));
@@ -27,17 +25,13 @@ export const PostRowSchema = Schema.fromJsonString(Schema.Union([
     Schema.Struct({
         state: Schema.Literal("pending"),
         envelope: PostEnvelopeSchema,
-        attempts: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-        nextAttemptAt: Schema.Number.check(Schema.isGreaterThanOrEqualTo(0)),
         deadlineAt: Schema.optional(Schema.Number.check(Schema.isGreaterThanOrEqualTo(0))),
-        jobId: Schema.optional(Key),
+        jobId: Key,
         delivery: Schema.optional(PostEnvelopeSchema),
-        nextKey: Schema.optional(Key),
     }),
     Schema.Struct({
         state: Schema.Literal("delivered"),
         receipt: Schema.optional(Schema.Json),
-        nextKey: Schema.optional(Key),
     }),
     Schema.Struct({
         state: Schema.Literal("dead"),
@@ -47,7 +41,6 @@ export const PostRowSchema = Schema.fromJsonString(Schema.Union([
         deadlineAt: Schema.optional(Schema.Number.check(Schema.isGreaterThanOrEqualTo(0))),
         receipt: Schema.optional(Schema.Json),
         delivery: Schema.optional(PostEnvelopeSchema),
-        nextKey: Schema.optional(Key),
     }),
 ]));
 function receiptOperations(address, event, hooks) {
@@ -103,13 +96,17 @@ export function definePostRoute(route) {
     };
 }
 const StoredRow = Schema.Struct({ key: Schema.String, value: Schema.String });
-const DueRow = Schema.Struct({
-    due: Schema.NullOr(Schema.Number.check(Schema.isGreaterThanOrEqualTo(0))),
-});
 const openPostStore = (owner) => {
     const sql = owner.sql;
     owner.transactionSync(() => {
         sql.exec("CREATE TABLE IF NOT EXISTS carrier_post_rows (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
+        // Rows written before the Watchdog scheduler carry nextAttemptAt or nextKey;
+        // Fungi 0.15.0 resets that store by refusing it, never loading or rewriting it.
+        const preScheduler = sql
+            .exec("SELECT key FROM carrier_post_rows WHERE key LIKE 'post:%' AND (json_type(value,'$.nextAttemptAt') IS NOT NULL OR json_type(value,'$.nextKey') IS NOT NULL) LIMIT 1")
+            .toArray();
+        if (preScheduler.length > 0)
+            throw new PostError("pre-scheduler Post store is not loaded; preserve it and authorize a reset through its owning host", "pre-scheduler-store");
     });
     return {
         commit: (mutation) => owner.transactionSync(mutation),
@@ -127,16 +124,12 @@ const openPostStore = (owner) => {
         list: (limit, afterKey = "") => Schema.decodeUnknownSync(Schema.Array(StoredRow))(sql
             .exec("SELECT key,value FROM carrier_post_rows WHERE key LIKE 'post:%' AND key>? ORDER BY key LIMIT ?", afterKey, limit)
             .toArray()),
-        nextWake: () => Schema.decodeUnknownSync(DueRow)(sql
-            .exec("SELECT MIN(json_extract(value,'$.nextAttemptAt')) AS due FROM carrier_post_rows WHERE key LIKE 'post:%' AND json_extract(value,'$.state')='pending' AND json_type(value,'$.jobId')='text'")
-            .toArray()[0]).due,
     };
 };
 /** Decode at both persisted and DO boundaries with the route's Effect Schema. */
 export function createPost(options) {
     const store = openPostStore(options.owner);
     const rowKey = (key) => `post:${key}`;
-    const tailKey = (queue) => `post-tail:${queue}`;
     const headKey = (kind, queue) => `post-head:${JSON.stringify([kind, queue])}`;
     const readRow = (key) => {
         const raw = store.read(rowKey(key));
@@ -144,7 +137,6 @@ export function createPost(options) {
             ? undefined
             : Schema.decodeUnknownSync(PostRowSchema)(raw);
     };
-    const nextWake = () => store.nextWake();
     const putRow = (key, row) => {
         store.put(rowKey(key), Schema.encodeSync(PostRowSchema)(row));
     };
@@ -159,10 +151,9 @@ export function createPost(options) {
         return JSON.stringify([route.addressKind, route.nameOf(envelope)]);
     };
     const enqueueJob = (row) => {
-        const jobId = ids.work.generate();
-        putRow(row.envelope.key, { ...row, jobId });
+        putRow(row.envelope.key, row);
         options.transactional.enqueueAcceptedJob({
-            jobId,
+            jobId: row.jobId,
             queue: queueOf(row.envelope),
             lane: "post",
             priority: 0,
@@ -182,26 +173,16 @@ export function createPost(options) {
             return;
         }
         const queue = queueOf(envelope);
-        const previousKey = store.read(tailKey(queue));
-        const previous = previousKey === undefined ? undefined : readRow(previousKey);
         const admittedAt = options.now();
         const baseRow = {
             state: "pending",
             envelope,
-            attempts: 0,
-            nextAttemptAt: admittedAt,
+            jobId: ids.work.generate(),
         };
         const row = route.deadlineMs === undefined
             ? baseRow
             : { ...baseRow, deadlineAt: admittedAt + route.deadlineMs };
-        putRow(envelope.key, row);
-        if (previousKey !== undefined && previous?.state === "pending") {
-            putRow(previousKey, { ...previous, nextKey: envelope.key });
-        }
-        else {
-            enqueueJob(row);
-        }
-        store.put(tailKey(queue), envelope.key);
+        enqueueJob(row);
         store.put(headKey(envelope.kind, queue), envelope.key);
     };
     const latest = (kind, address) => {
@@ -222,20 +203,13 @@ export function createPost(options) {
             throw new PostError("latest delivery row is missing");
         return { key, row };
     };
-    const releaseNext = (nextKey) => {
-        if (nextKey === undefined)
-            return;
-        const next = readRow(nextKey);
-        if (next?.state === "pending" && next.jobId === undefined)
-            enqueueJob(next);
-    };
-    const finish = (key, row, terminal, metadata) => {
+    const finish = (key, row, terminal, attempts, metadata) => {
         let receipt;
         if (terminal.state === "dead") {
             const dead = {
                 ...terminal,
                 envelope: row.envelope,
-                attempts: row.attempts,
+                attempts,
             };
             const settled = row.deadlineAt === undefined
                 ? dead
@@ -249,41 +223,45 @@ export function createPost(options) {
             receipt = terminal;
         if (metadata !== undefined)
             receipt = { ...receipt, receipt: metadata };
-        putRow(key, row.nextKey === undefined
-            ? receipt
-            : { ...receipt, nextKey: row.nextKey });
-        releaseNext(row.nextKey);
+        putRow(key, receipt);
     };
-    const execute = async (job) => {
+    const retryPolicy = (job) => {
         const { postKey } = Schema.decodeUnknownSync(JobPayload)(job.payload);
-        const attempt = store.commit(() => {
-            const row = readRow(postKey);
-            if (row === undefined)
+        const row = readRow(postKey);
+        if (row === undefined)
+            throw new PostError("delivery row is missing");
+        const limit = row.state !== "pending" || row.jobId !== job.jobId
+            ? { maxAttempts: 0 }
+            : row.deadlineAt === undefined
+                ? { maxAttempts: maxDeliveryAttempts }
+                : { deadlineAt: row.deadlineAt };
+        return Promise.resolve({ ...postRetryPolicy, limit });
+    };
+    const execute = async (job, reservation, signal) => {
+        if (reservation === undefined)
+            throw new PostError("delivery attempt is missing");
+        const { postKey } = Schema.decodeUnknownSync(JobPayload)(job.payload);
+        const row = store.commit(() => {
+            const current = readRow(postKey);
+            if (current === undefined)
                 throw new PostError("delivery row is missing");
-            if (row.state !== "pending" || row.jobId !== job.jobId)
+            if (current.state !== "pending" || current.jobId !== job.jobId)
                 return undefined;
-            if (row.deadlineAt !== undefined && options.now() >= row.deadlineAt) {
-                finish(postKey, row, { state: "dead", reason: "expired" });
+            if (reservation.status === "exhausted") {
+                finish(postKey, current, {
+                    state: "dead",
+                    reason: current.deadlineAt === undefined ? "exhausted" : "expired",
+                }, reservation.count);
                 return undefined;
             }
-            if (row.deadlineAt === undefined && row.attempts >= maxDeliveryAttempts) {
-                finish(postKey, row, { state: "dead", reason: "exhausted" });
-                return undefined;
-            }
-            const attempts = row.attempts + 1;
-            const nextAttemptAt = Math.min(options.now() + backoffDelay(attempts, postRetryPolicy), row.deadlineAt ?? Number.POSITIVE_INFINITY);
-            const started = { ...row, attempts, nextAttemptAt };
-            // Preserve recovery evidence before invoking the receiver. A failed receipt
-            // write leaves this row available for retry after Watchdog settles the job.
-            putRow(postKey, started);
-            return started;
+            return current;
         });
-        if (attempt === undefined)
+        if (row === undefined)
             return { kind: "completed" };
-        await options.scheduleWake(attempt.nextAttemptAt);
-        const route = routeFor(attempt.envelope);
+        const route = routeFor(row.envelope);
         const evidence = await deliverPost({
-            attempt,
+            attempt: row,
+            signal,
             route,
             savePrepared: (envelope) => {
                 store.commit(() => {
@@ -294,173 +272,65 @@ export function createPost(options) {
                 });
             },
         });
-        let retryAt;
-        store.commit(() => {
-            // Another send may have linked a successor during the remote call.
+        return store.commit(() => {
             const current = readRow(postKey);
             if (current?.state !== "pending" || current.jobId !== job.jobId)
-                return;
-            const disposition = postDisposition(evidence, route, current.attempts, maxDeliveryAttempts, {
+                return { kind: "completed" };
+            const disposition = postDisposition(evidence, route, reservation.count, maxDeliveryAttempts, {
                 deadlineExpired: current.deadlineAt !== undefined &&
                     options.now() >= current.deadlineAt,
                 retryUntilDeadline: current.deadlineAt !== undefined,
             });
-            if (disposition.state === "keep")
-                return;
+            if (disposition.state === "pending" || disposition.state === "keep")
+                return { kind: "retry" };
             if (disposition.state === "delivered") {
                 if (evidence.envelope === undefined)
                     throw new PostError("missing delivered fact");
                 if (disposition.cursor !== undefined)
                     route.recordCursor?.(evidence.envelope, disposition.cursor);
                 route.recordDelivered?.(evidence.envelope);
-                finish(postKey, current, { state: "delivered" }, deliveryReceipt(evidence));
-            }
-            else if (disposition.state === "dead") {
-                if (disposition.reason === "refused" && evidence.envelope !== undefined)
-                    route.recordRefused?.(evidence.envelope);
-                finish(postKey, current, disposition, deliveryReceipt(evidence));
-            }
-            else {
-                const now = options.now();
-                if (current.deadlineAt !== undefined && now >= current.deadlineAt) {
-                    finish(postKey, current, { state: "dead", reason: "expired" });
-                }
-                else {
-                    const due = Math.min(now + backoffDelay(current.attempts, postRetryPolicy), current.deadlineAt ?? Number.POSITIVE_INFINITY);
-                    if (due !== current.nextAttemptAt) {
-                        putRow(postKey, { ...current, nextAttemptAt: due });
-                        retryAt = due;
-                    }
-                }
             }
+            else if (disposition.reason === "refused" &&
+                evidence.envelope !== undefined)
+                route.recordRefused?.(evidence.envelope);
+            finish(postKey, current, disposition, reservation.count, deliveryReceipt(evidence));
+            return { kind: "completed" };
         });
-        if (retryAt !== undefined)
-            await options.scheduleWake(retryAt);
-        return { kind: "completed" };
-    };
-    const enqueueDue = async (limit = 64, afterKey) => {
-        const pageSize = Schema.decodeUnknownSync(PageLimit)(limit);
-        const rows = store.list(pageSize, afterKey);
-        for (const stored of rows) {
-            const row = Schema.decodeUnknownSync(PostRowSchema)(stored.value);
-            if (row.state !== "pending" || row.jobId === undefined)
-                continue;
-            const work = await options.readJob(row.jobId);
-            if (work.status === "missing")
-                throw new PostError("delivery job is missing");
-            if (work.job.state !== "settled")
-                continue;
-            if (row.nextAttemptAt > options.now()) {
-                await options.scheduleWake(row.nextAttemptAt);
-                continue;
-            }
-            store.commit(() => {
-                const current = readRow(row.envelope.key);
-                if (current?.state !== "pending" || current.jobId !== row.jobId)
-                    return;
-                if (current.deadlineAt !== undefined &&
-                    options.now() >= current.deadlineAt)
-                    finish(current.envelope.key, current, {
-                        state: "dead",
-                        reason: "expired",
-                    });
-                else if (current.deadlineAt === undefined &&
-                    current.attempts >= maxDeliveryAttempts)
-                    finish(current.envelope.key, current, {
-                        state: "dead",
-                        reason: "exhausted",
-                    });
-                else
-                    enqueueJob(current);
-            });
-        }
-        return rows.length === pageSize ? rows.at(-1)?.key : undefined;
     };
     const retry = async (input) => {
         const key = Schema.decodeUnknownSync(Key)(input);
-        const row = readRow(key);
-        if (row === undefined || row.state === "delivered")
-            return;
-        const work = row.state === "pending" && row.jobId !== undefined
-            ? await options.readJob(row.jobId)
-            : undefined;
-        if (work?.status === "missing")
-            throw new PostError("delivery job is missing");
-        if (work?.status === "found" && work.job.state !== "settled")
-            return;
         store.commit(() => {
-            const current = readRow(key);
-            if (current === undefined || current.state === "delivered")
+            const row = readRow(key);
+            if (row === undefined || row.state === "delivered")
+                return;
+            if (row.state === "pending") {
+                options.transactional.expediteQueuedJob(row.jobId, options.now());
                 return;
-            if (current.state === "pending") {
-                if (row.state !== "pending" || current.jobId !== row.jobId)
-                    return;
-                const pending = {
-                    ...current,
-                    attempts: 0,
-                    nextAttemptAt: options.now(),
-                };
-                putRow(key, pending);
-                if (current.jobId !== undefined)
-                    enqueueJob(pending);
-            }
-            else {
-                const retry = {
-                    state: "pending",
-                    envelope: current.envelope,
-                    attempts: 0,
-                    nextAttemptAt: options.now(),
-                    delivery: current.delivery,
-                };
-                const pending = current.deadlineAt === undefined
-                    ? retry
-                    : { ...retry, deadlineAt: current.deadlineAt };
-                putRow(key, pending);
-                const queue = queueOf(pending.envelope);
-                const previousKey = store.read(tailKey(queue));
-                const previous = previousKey === undefined || previousKey === key
-                    ? undefined
-                    : readRow(previousKey);
-                if (previous?.state === "pending" && previousKey !== undefined)
-                    putRow(previousKey, { ...previous, nextKey: key });
-                else
-                    enqueueJob(pending);
-                store.put(tailKey(queue), key);
             }
+            enqueueJob({
+                state: "pending",
+                envelope: row.envelope,
+                jobId: ids.work.generate(),
+                delivery: row.delivery,
+                deadlineAt: row.deadlineAt,
+            });
         });
         await options.scheduleWake(options.now());
     };
-    const releasePendingRow = async (row, now) => {
-        if (row.state !== "pending" ||
-            row.jobId === undefined ||
-            row.nextAttemptAt <= now)
-            return false;
-        const work = await options.readJob(row.jobId);
-        if (work.status === "missing")
-            throw new PostError("delivery job is missing");
-        if (work.job.state !== "settled")
-            return false;
-        return store.commit(() => {
-            const current = readRow(row.envelope.key);
-            if (current?.state !== "pending" ||
-                current.jobId !== row.jobId ||
-                current.nextAttemptAt <= now)
-                return false;
-            const pending = { ...current, nextAttemptAt: now };
-            putRow(row.envelope.key, pending);
-            enqueueJob(pending);
-            return true;
-        });
-    };
     const releaseNow = async (limit = 64, afterKey) => {
         const pageSize = Schema.decodeUnknownSync(PageLimit)(limit);
         const rows = store.list(pageSize, afterKey);
         const now = options.now();
-        let released = false;
-        for (const stored of rows) {
-            const row = Schema.decodeUnknownSync(PostRowSchema)(stored.value);
-            released = (await releasePendingRow(row, now)) || released;
-        }
+        const released = store.commit(() => {
+            let changed = false;
+            for (const stored of rows) {
+                const row = Schema.decodeUnknownSync(PostRowSchema)(stored.value);
+                if (row.state === "pending")
+                    changed =
+                        options.transactional.expediteQueuedJob(row.jobId, now) || changed;
+            }
+            return changed;
+        });
         if (released)
             await options.scheduleWake(now);
         return rows.length === pageSize ? rows.at(-1)?.key : undefined;
@@ -491,11 +361,10 @@ export function createPost(options) {
         latest,
         retry,
         execute,
-        enqueueDue,
+        retryPolicy,
         releaseNow,
         deadLetters,
         read: readRow,
-        nextWake,
     });
 }
 /** Consumer admission runs inside the receiver's own SQLite transaction. */

package/docs/api/README.md

@@ -17,4 +17,3 @@
 | [post-d1](post-d1.md)             | -           |
 | [post-postgres](post-postgres.md) | -           |
 | [post](post.md)                   | -           |
-| [testing](testing.md)             | -           |

package/docs/api/inspection.md

@@ -278,4 +278,4 @@ jobs or arming a wake. The trusted host must admit an operator before calling.
 | Name      | Type                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Description                                                                        |
 | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
 | `email()` | (`input`) => \| \{ `status`: `"uninitialized"`; \} \| \{ `status`: `"available"`; `records`: readonly `object`[]; `nextCursor`: `string` \| `null`; \}                                                                                                                                                                                                                                                                                                            | Read aggregate dispatch evidence without email cargo or recipient addresses.       |
-| `post()`  | (`input`) => \| \{ `status`: `"uninitialized"`; \} \| \{ `status`: `"available"`; `records`: readonly ( \| \{ `key`: `string`; `state`: `"delivered"`; \} \| \{ `key`: `string`; `state`: `"pending"`; `kind`: `string`; `attempts`: `number`; `nextAttemptAt`: `number`; \} \| \{ `key`: `string`; `state`: `"dead"`; `kind`: `string`; `attempts`: `number`; `reason`: `"expired"` \| `"refused"` \| `"exhausted"`; \})[]; `nextCursor`: `string` \| `null`; \} | Read Post metadata; filtered pages retain their continuation through other states. |
+| `post()`  | (`input`) => \| \{ `status`: `"uninitialized"`; \} \| \{ `status`: `"available"`; `records`: readonly ( \| \{ `key`: `string`; `state`: `"delivered"`; \} \| \{ `key`: `string`; `state`: `"pending"`; `kind`: `string`; `attempts`: `number`; `nextAttemptAt`: `number`; \} \| \{ `key`: `string`; `state`: `"dead"`; `kind`: `string`; `attempts`: `number`; `reason`: `"expired"` \| `"exhausted"` \| `"refused"`; \})[]; `nextCursor`: `string` \| `null`; \} | Read Post metadata; filtered pages retain their continuation through other states. |

package/docs/api/post-d1.md

@@ -22,7 +22,6 @@ type SqlPostOptions<R> = Readonly<{
     maxDelayMs: number;
   }>;
   now: () => number;
-  scheduleWake: (at) => Promise<void>;
 }>;
 ```
 
@@ -40,15 +39,8 @@ SQL native Carrier runtime configuration; route decisions remain in Post.
 
 ```ts
 type SqlPostRuntime = Readonly<{
-  execute: (
-    job,
-    signal?,
-  ) => Promise<
-    Readonly<{
-      kind: "completed";
-    }>
-  >;
-  enqueueDue: (limit?, afterKey?) => Promise<string | undefined>;
+  retryPolicy: (job) => Promise<WatchdogRetryPolicy>;
+  execute: (job, attempt, signal?) => Promise<WatchdogExecutionDecision>;
   read: (key) => Promise<PostRow | undefined>;
 }>;
 ```
@@ -66,8 +58,7 @@ type D1PostSource = Readonly<{
 }>;
 ```
 
-Trusted SELECT yielding post_key, envelope_json, queue_name, next_attempt_at and
-job_id.
+Trusted SELECT yielding post_key, envelope_json, queue_name and job_id.
 
 ---
 
@@ -124,9 +115,9 @@ Bind the Post registry to D1; route deadlines are rejected with PostError.
 
 #### Parameters
 
-| Parameter | Type                                                                                                                                                                                                                                                                                                                                 |
-| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `options` | `Readonly`\<\{ `routes`: `R`; `failureDetail?`: (`cause`) => `string`; `retry?`: `Readonly`\<\{ `maxAttempts`: `number`; `baseDelayMs`: `number`; `maxDelayMs`: `number`; \}\>; `now`: () => `number`; `scheduleWake`: (`at`) => `Promise`\<`void`\>; \}\> & `Readonly`\<\{ `database`: `D1Database`; `watchdog`: `D1Watchdog`; \}\> |
+| Parameter | Type                                                                                                                                                                                                                                                                                  |
+| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `options` | `Readonly`\<\{ `routes`: `R`; `failureDetail?`: (`cause`) => `string`; `retry?`: `Readonly`\<\{ `maxAttempts`: `number`; `baseDelayMs`: `number`; `maxDelayMs`: `number`; \}\>; `now`: () => `number`; \}\> & `Readonly`\<\{ `database`: `D1Database`; `watchdog`: `D1Watchdog`; \}\> |
 
 #### Returns
 

package/docs/api/post-postgres.md

@@ -63,9 +63,9 @@ PostError.
 
 #### Parameters
 
-| Parameter | Type                                                                                                                                                                                                                                                                                                                                                                     |
-| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `options` | `Readonly`\<\{ `routes`: `R`; `failureDetail?`: (`cause`) => `string`; `retry?`: `Readonly`\<\{ `maxAttempts`: `number`; `baseDelayMs`: `number`; `maxDelayMs`: `number`; \}\>; `now`: () => `number`; `scheduleWake`: (`at`) => `Promise`\<`void`\>; \}\> & `Readonly`\<\{ `database`: `Pick`\<`Pool`, `"query"` \| `"connect"`\>; `watchdog`: `PostgresWatchdog`; \}\> |
+| Parameter | Type                                                                                                                                                                                                                                                                                                                      |
+| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `options` | `Readonly`\<\{ `routes`: `R`; `failureDetail?`: (`cause`) => `string`; `retry?`: `Readonly`\<\{ `maxAttempts`: `number`; `baseDelayMs`: `number`; `maxDelayMs`: `number`; \}\>; `now`: () => `number`; \}\> & `Readonly`\<\{ `database`: `Pick`\<`Pool`, `"query"` \| `"connect"`\>; `watchdog`: `PostgresWatchdog`; \}\> |
 
 #### Returns