@greatwait/contracts 0.1.0-alpha.3 → 0.1.0-alpha.5

package/dist/scheduling.d.ts

@@ -1,4 +1,6 @@
-import { z } from "zod";
+import { z } from "./zod.js";
+import { type CursorBinding } from "./protocol.js";
+import type { FieldError } from "./problems.js";
 import { type CallbackTrigger, type ResponseClass } from "./signatures.js";
 /**
  * The scheduling resource family: schedules, the occurrences they produce, and
@@ -33,13 +35,40 @@ import { type CallbackTrigger, type ResponseClass } from "./signatures.js";
  * question.
  */
 export declare const SCHEDULE_STATUSES: readonly ["active", "paused", "cancelled", "completed"];
-export declare const scheduleStatusSchema: z.ZodEnum<{
-    paused: "paused";
+export declare const scheduleStatusSchema: import("zod").ZodEnum<{
     active: "active";
-    cancelled: "cancelled";
     completed: "completed";
+    paused: "paused";
+    cancelled: "cancelled";
 }>;
 export type ScheduleStatus = z.infer<typeof scheduleStatusSchema>;
+/**
+ * The statuses a schedule never leaves, and from which it never fires again on
+ * its own.
+ *
+ * **"Never fires again on its own" rather than "never delivers again", and the
+ * distinction is real.** A member can still press Redeliver on a completed
+ * occurrence, and the repository admits that for a `completed` schedule as well
+ * as an `active` one. What is terminal here is the schedule's own timetable, not
+ * every possible future delivery.
+ *
+ * Exported for the same reason as {@link TERMINAL_OCCURRENCE_STATES}: so a
+ * caller enumerates them rather than writing the list out and quietly missing
+ * one if another is ever added. Three places had already written it out — the
+ * `archivedAt` validator in `scheduling-records.ts`, the dashboard's schedule
+ * controls, and the dashboard's pending-action rules — and the third had missed
+ * it entirely, which is the defect this list was extracted for.
+ */
+export declare const TERMINAL_SCHEDULE_STATUSES: readonly ["cancelled", "completed"];
+/**
+ * Whether this schedule has finished, either on its own or because somebody
+ * stopped it.
+ *
+ * `paused` is deliberately not terminal: it is reversible, so a paused schedule
+ * pointed at a broken destination is still a problem worth telling somebody
+ * about.
+ */
+export declare function isTerminalScheduleStatus(status: ScheduleStatus): boolean;
 /**
  * How promptly an occurrence expects to be dispatched.
  *
@@ -48,29 +77,95 @@ export type ScheduleStatus = z.infer<typeof scheduleStatusSchema>;
  * anything to anybody. `realtime` gets preference without starving `bulk`.
  */
 export declare const LATENCY_CLASSES: readonly ["realtime", "bulk"];
-export declare const latencyClassSchema: z.ZodEnum<{
+export declare const latencyClassSchema: import("zod").ZodEnum<{
     realtime: "realtime";
     bulk: "bulk";
 }>;
 export type LatencyClass = z.infer<typeof latencyClassSchema>;
 /**
- * How long a receiver may take to answer, as a ladder rather than a number.
- *
- * **A ladder because every rung is a different product.** The first two are the
- * ordinary path: a delivery is carried inside the partition's own dispatch and
- * holds one of six in-flight slots for its whole duration, so the cost of a slow
- * receiver is paid by every other schedule in that
- * `(organization, project, environment)`. The rungs above are carried elsewhere
- * and priced, because that is the only honest way to sell them.
- *
- * **Deliberately not a free-form integer.** A caller that could ask for 47
- * seconds would be asking a question this product has no answer to: 47 is past
- * the point where a delivery may occupy a partition slot and short of the point
- * where it is worth carrying separately. The ladder is what makes "which side of
- * the line is this" a decision somebody took rather than a comparison somebody
- * wrote.
+ * What happens when an occurrence reaches its first attempt after its planned
+ * instant.
+ *
+ * `skipAhead` never carries a recurring first arrival across its next planned
+ * instant (and a shorter custom window may retire it earlier). `catchUp`
+ * admits one first arrival while it is still inside the schedule's staleness
+ * window, even after later recurrence instants passed. A one-shot has no next
+ * recurrence, so either explicit policy uses its staleness window and its
+ * default is `catchUp`. Neither choice applies to an occurrence already on its
+ * retry ladder: that work arrived, failed, and keeps the retry/give-up policy
+ * it started under.
+ */
+export declare const LATENESS_POLICIES: readonly ["skipAhead", "catchUp"];
+export declare const latenessPolicySchema: import("zod").ZodEnum<{
+    skipAhead: "skipAhead";
+    catchUp: "catchUp";
+}>;
+export type LatenessPolicy = z.infer<typeof latenessPolicySchema>;
+/** The inherited one-shot staleness window: twenty-four hours. */
+export declare const DEFAULT_ONE_SHOT_MAX_STALENESS_SECONDS = 86400;
+/**
+ * The per-schedule lateness choices a caller may state.
+ *
+ * Both members are optional so a caller can override only the part whose
+ * default does not fit. The policy defaults from recurrence kind. An omitted
+ * staleness bound uses the recurrence's own default: twenty-four hours for a
+ * one-shot, and one recurrence interval for a recurring schedule.
+ */
+export declare const scheduleLatenessRequestSchema: import("zod").ZodObject<{
+    maxStalenessSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+    policy: import("zod").ZodOptional<import("zod").ZodEnum<{
+        skipAhead: "skipAhead";
+        catchUp: "catchUp";
+    }>>;
+}, import("zod/v4/core").$strict>;
+export type ScheduleLatenessRequest = z.infer<typeof scheduleLatenessRequestSchema>;
+/**
+ * Lateness settings as a schedule reads back.
+ *
+ * The policy is always effective and therefore required. The numeric member
+ * remains optional because it records a per-schedule override, not a duplicated
+ * copy of a default that can be derived from the recurrence.
+ */
+export declare const scheduleLatenessSchema: import("zod").ZodObject<{
+    maxStalenessSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+    policy: import("zod").ZodEnum<{
+        skipAhead: "skipAhead";
+        catchUp: "catchUp";
+    }>;
+}, import("zod/v4/core").$strict>;
+export type LatenessSettings = z.infer<typeof scheduleLatenessSchema>;
+/**
+ * The durations this product used to sell, one rung at a time.
+ *
+ * **Kept, and no longer the whole of what is accepted** (FXO-2258). The ladder
+ * was the argument that 47 seconds is a question with no answer — past the
+ * point where a delivery may occupy a partition slot, short of the point where
+ * it is worth carrying separately. The operator overruled it after the walk:
+ * "This can have a completely user definable timeout, they don't cost us hardly
+ * anything, but we should cap at something anyway, 24h is still fine."
+ *
+ * What the rungs were actually carrying survives without them. The line that
+ * matters commercially is {@link FREE_DELIVERY_DURATION_SECONDS} — above thirty
+ * seconds a delivery is carried outside the partition and needs a plan that
+ * allows it — and that line is a comparison, not a membership test. The line
+ * that matters technically is {@link RESPONSE_DELIVERY_MAX_DURATION_SECONDS},
+ * which is also a comparison. Neither ever needed eight fixed values to be
+ * expressible; the ladder was how they were *sold*, and per-rung pricing is
+ * what the operator withdrew.
+ *
+ * The list stays because a schedule saved on a rung must keep working, because
+ * the delivery-class rules are still exercised against exactly these values,
+ * and because the dashboard offers them as the shortcuts most people want.
  */
 export declare const DELIVERY_DURATION_TIERS: readonly [5, 30, 300, 900, 1800, 3600, 43200, 86400];
+/**
+ * The longest duration any delivery may be given, in seconds.
+ *
+ * Twenty-four hours, which is the ladder's own top rung — so widening the field
+ * to a free-form integer admits nothing that was not already for sale. "24h is
+ * still fine."
+ */
+export declare const MAX_DELIVERY_DURATION_SECONDS = 86400;
 /**
  * What a schedule gets without asking, in seconds.
  *
@@ -127,7 +222,22 @@ export declare const FREE_DELIVERY_DURATION_SECONDS = 30;
  * than thirty minutes has to do is answer immediately and call us back.
  */
 export declare const RESPONSE_DELIVERY_MAX_DURATION_SECONDS = 1800;
-export declare const deliveryDurationSecondsSchema: z.ZodLiteral<300 | 5 | 30 | 900 | 1800 | 3600 | 43200 | 86400>;
+/**
+ * How long the receiver may take to answer, in whole seconds.
+ *
+ * **A bounded integer since FXO-2258, and every value the enum accepted is
+ * still accepted.** A widening is the one shape of contract change that cannot
+ * break a caller: a request that was valid before is valid now, and a stored
+ * schedule reads back and re-saves unchanged.
+ *
+ * The two bounds that are real are still enforced, and neither of them was ever
+ * the enum's doing: `maxDurationSeconds` above
+ * {@link RESPONSE_DELIVERY_MAX_DURATION_SECONDS} is refused unless `completion`
+ * is `callback` (checked in `scheduleRequestSchema`'s refinement, because it is
+ * a relation between two fields), and above
+ * {@link FREE_DELIVERY_DURATION_SECONDS} it needs a plan that allows it.
+ */
+export declare const deliveryDurationSecondsSchema: import("zod").ZodNumber;
 export type DeliveryDurationSeconds = z.infer<typeof deliveryDurationSecondsSchema>;
 /** Whether a duration is past the point where it needs a plan that allows it. */
 export declare function isLongRunningDuration(seconds: number): boolean;
@@ -156,7 +266,7 @@ export declare function isLongRunningDuration(seconds: number): boolean;
  * untouched, and so is what a rung costs.
  */
 export declare const DELIVERY_COMPLETION_MODES: readonly ["response", "callback"];
-export declare const deliveryCompletionModeSchema: z.ZodEnum<{
+export declare const deliveryCompletionModeSchema: import("zod").ZodEnum<{
     response: "response";
     callback: "callback";
 }>;
@@ -182,7 +292,7 @@ export type DeliveryCompletionMode = z.infer<typeof deliveryCompletionModeSchema
  * - `queue` — run it when the previous one finishes.
  */
 export declare const DELIVERY_OVERLAP_POLICIES: readonly ["skip", "queue"];
-export declare const deliveryOverlapPolicySchema: z.ZodEnum<{
+export declare const deliveryOverlapPolicySchema: import("zod").ZodEnum<{
     skip: "skip";
     queue: "queue";
 }>;
@@ -197,7 +307,7 @@ export declare const DEFAULT_DELIVERY_OVERLAP_POLICY: DeliveryOverlapPolicy;
  * would make pausing and resuming a schedule invalidate occurrences that are
  * still perfectly valid.
  */
-export declare const generationSchema: z.ZodNumber;
+export declare const generationSchema: import("zod").ZodNumber;
 export type Generation = z.infer<typeof generationSchema>;
 /**
  * A customer-supplied fairness key.
@@ -210,7 +320,7 @@ export type Generation = z.infer<typeof generationSchema>;
  * another Durable Object namespace.
  */
 export declare const PARTITION_KEY_MAX_LENGTH = 64;
-export declare const partitionKeySchema: z.ZodString;
+export declare const partitionKeySchema: import("zod").ZodString;
 export type PartitionKey = z.infer<typeof partitionKeySchema>;
 /**
  * Every state one occurrence can be in.
@@ -226,18 +336,64 @@ export type PartitionKey = z.infer<typeof partitionKeySchema>;
  * occurrence went stale need different explanations.
  */
 export declare const OCCURRENCE_STATES: readonly ["planned", "due", "dispatching", "retry_wait", "ambiguous", "succeeded", "terminal_failed", "cancelled", "skipped_stale"];
-export declare const occurrenceStateSchema: z.ZodEnum<{
+export declare const occurrenceStateSchema: import("zod").ZodEnum<{
+    due: "due";
     succeeded: "succeeded";
     ambiguous: "ambiguous";
     cancelled: "cancelled";
     planned: "planned";
-    due: "due";
     dispatching: "dispatching";
     retry_wait: "retry_wait";
     terminal_failed: "terminal_failed";
     skipped_stale: "skipped_stale";
 }>;
 export type OccurrenceState = z.infer<typeof occurrenceStateSchema>;
+/**
+ * One project-wide walk over retained occurrences, newest first.
+ *
+ * There is deliberately no order parameter: the Executions page answers what
+ * happened most recently, and making that fixed lets its index and cursor say
+ * the same thing. The date range is half-open, like every other time window in
+ * this contract, so adjacent requests neither overlap nor leave a gap.
+ */
+export declare const projectOccurrenceListRequestSchema: import("zod").ZodObject<{
+    cursor: import("zod").ZodOptional<import("zod").ZodString>;
+    limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+    endpoint: import("zod").ZodOptional<import("zod").ZodString>;
+    from: import("zod").ZodOptional<import("zod").ZodString>;
+    outcome: import("zod").ZodOptional<import("zod").ZodEnum<{
+        due: "due";
+        succeeded: "succeeded";
+        ambiguous: "ambiguous";
+        cancelled: "cancelled";
+        planned: "planned";
+        dispatching: "dispatching";
+        retry_wait: "retry_wait";
+        terminal_failed: "terminal_failed";
+        skipped_stale: "skipped_stale";
+    }>>;
+    schedule: import("zod").ZodOptional<import("zod").ZodString>;
+    to: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>;
+export type ProjectOccurrenceListRequest = z.infer<typeof projectOccurrenceListRequestSchema>;
+export type ProjectOccurrenceListRequestParse = {
+    readonly ok: true;
+    readonly page: ProjectOccurrenceListRequest;
+} | {
+    readonly ok: false;
+    readonly errors: readonly FieldError[];
+};
+/** Read the project occurrence filters exactly as REST and MCP send them. */
+export declare function parseProjectOccurrenceListRequest(query: URLSearchParams): ProjectOccurrenceListRequestParse;
+/**
+ * The exact operation and filters a project occurrence cursor belongs to.
+ *
+ * Cursor and limit do not affect which ordered collection is being walked, so
+ * neither belongs in the binding. Every actual filter does. Optional values
+ * stay absent rather than becoming empty strings, which are invalid inputs and
+ * must never collide with an unfiltered request.
+ */
+export declare function projectOccurrenceCursorBinding(request: ProjectOccurrenceListRequest): CursorBinding;
 /**
  * The states an occurrence never leaves.
  *
@@ -257,7 +413,7 @@ export declare function isTerminalOccurrenceState(state: OccurrenceState): boole
  * sanctioned mapping between them.
  */
 export declare const ATTEMPT_STATES: readonly ["succeeded", "retryable_failure", "terminal_failure", "ambiguous"];
-export declare const attemptStateSchema: z.ZodEnum<{
+export declare const attemptStateSchema: import("zod").ZodEnum<{
     succeeded: "succeeded";
     ambiguous: "ambiguous";
     retryable_failure: "retryable_failure";
@@ -265,10 +421,10 @@ export declare const attemptStateSchema: z.ZodEnum<{
 }>;
 export type AttemptState = z.infer<typeof attemptStateSchema>;
 /** Safe diagnostic codes produced by the W3-03 delivery classifier. */
-export declare const attemptDiagnosticSchema: z.ZodEnum<{
+export declare const attemptDiagnosticSchema: import("zod").ZodEnum<{
     rate_limited: "rate_limited";
-    completion_timed_out: "completion_timed_out";
     delivered: "delivered";
+    completion_timed_out: "completion_timed_out";
     duplicate_inflight: "duplicate_inflight";
     endpoint_unavailable: "endpoint_unavailable";
     endpoint_unsafe: "endpoint_unsafe";
@@ -288,7 +444,7 @@ export type AttemptDiagnostic = z.infer<typeof attemptDiagnosticSchema>;
  * payload, or secret. `review_retry_policy` names the historical category
  * without promising that the occurrence still has automatic work to do.
  */
-export declare const ATTEMPT_REMEDIATIONS: readonly ["none", "review_retry_policy", "inspect_receiver", "verify_endpoint", "replace_payload", "contact_support", "review_before_redelivery"];
+export declare const ATTEMPT_REMEDIATIONS: readonly ["none", "review_retry_policy", "inspect_receiver", "review_endpoint", "replace_payload", "contact_support", "review_before_redelivery"];
 /**
  * How much of one retained response header is published, in characters.
  *
@@ -300,11 +456,11 @@ export declare const ATTEMPT_REMEDIATIONS: readonly ["none", "review_retry_polic
 export declare const ATTEMPT_RESPONSE_HEADER_MAX_LENGTH = 256;
 /** How much of a failed receiver's body is published, in characters. */
 export declare const ATTEMPT_FAILURE_SNIPPET_MAX_LENGTH = 4096;
-export declare const attemptRemediationSchema: z.ZodEnum<{
+export declare const attemptRemediationSchema: import("zod").ZodEnum<{
     none: "none";
     review_retry_policy: "review_retry_policy";
     inspect_receiver: "inspect_receiver";
-    verify_endpoint: "verify_endpoint";
+    review_endpoint: "review_endpoint";
     replace_payload: "replace_payload";
     contact_support: "contact_support";
     review_before_redelivery: "review_before_redelivery";
@@ -326,12 +482,12 @@ export declare function remediationForAttempt(diagnostic: AttemptDiagnostic): At
  * and the failure mode of that drift is a receiver that re-runs work for a
  * cause the history says never happened.
  */
-export declare const attemptTriggerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"automatic">;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"redelivery">;
-    sourceAttemptId: z.ZodString;
-}, z.core.$strip>], "kind">;
+export declare const attemptTriggerSchema: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"automatic">;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"redelivery">;
+    sourceAttemptId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>], "kind">;
 export type AttemptTrigger = CallbackTrigger;
 /**
  * The largest elapsed time JSON can carry without losing integer precision.
@@ -364,15 +520,35 @@ export declare const SCHEDULING_BOUNDS: {
      * Attempts made against one occurrence before it is terminal, including the
      * first. Bounded so a permanently broken receiver cannot make one occurrence
      * cost an unbounded amount of work.
+     *
+     * **Eight, and the number is load-bearing against a second limit rather than
+     * on its own.** `MAX_BUDGETED_DELIVERY_FAILURES` stops an occurrence after
+     * five failures the *receiver* caused; a rate limit and this product's own
+     * infrastructure faults are exempt from that count. The gap between the two
+     * is what the exemption spends — an occurrence throttled twice still has
+     * five receiver failures left. Lowering this to five was considered during
+     * the W4-10 walk and rejected once the pair was understood: it would make
+     * both limits fire on the same attempt and leave the exemption buying
+     * nothing.
      */
     readonly attemptsPerOccurrence: 8;
     /**
      * The longest fixed interval a recurring schedule may ask for, in seconds.
      *
-     * Thirty days, which is the copied scheduler's `MAX_INTERVAL_SECONDS` kept
-     * rather than a new number invented beside it, and its reason is the
-     * platform's rather than the product's: a Durable Object alarm is not
-     * arbitrarily far in the future.
+     * One year. **The thirty days this replaces had no reason of its own** — it
+     * was the copied scheduler's `MAX_INTERVAL_SECONDS`, carried over on the
+     * belief that "a Durable Object alarm is not arbitrarily far in the future".
+     * Cloudflare documents no maximum distance for `setAlarm()`, and the belief
+     * predates the PostgreSQL authority besides: the durable fact is a row, and
+     * the alarm is only what wakes a bucket to read it.
+     *
+     * What makes a distant alarm safe is not the alarm. `TimerBucketRepairer`
+     * asks PostgreSQL for occurrences whose instant has passed and re-signals
+     * their bucket, on committed truth, never asking whether an alarm was armed
+     * — so an alarm that is somehow lost costs lateness rather than the run.
+     *
+     * Widening a bound is additive by `classifyChange` and narrowing it is
+     * breaking, so this direction is the safe one to move in.
      */
     readonly everySecondsMax: number;
     /**
@@ -480,7 +656,7 @@ export declare const CRON_EXPRESSION_MAX_LENGTH = 120;
  * fire on a second boundary is refused by the partition, because a minute is
  * the granularity both arms of recurrence promise.
  */
-export declare const cronExpressionSchema: z.ZodString;
+export declare const cronExpressionSchema: import("zod").ZodString;
 export type CronExpression = z.infer<typeof cronExpressionSchema>;
 /**
  * How a schedule recurs, as a caller reads it back.
@@ -498,17 +674,19 @@ export type CronExpression = z.infer<typeof cronExpressionSchema>;
  * on that arm rather than optional, so a read always says which wall clock a
  * cron schedule is on instead of leaving the caller to assume UTC.
  */
-export declare const recurrenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"at">;
-}, z.core.$strip>, z.ZodObject<{
-    everySeconds: z.ZodNumber;
-    kind: z.ZodLiteral<"every">;
-}, z.core.$strip>, z.ZodObject<{
-    cron: z.ZodString;
-    kind: z.ZodLiteral<"cron">;
-    timeZone: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-}, z.core.$strip>], "kind">;
+export declare const recurrenceSchema: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"at">;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    everySeconds: import("zod").ZodNumber;
+    kind: import("zod").ZodLiteral<"every">;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    cron: import("zod").ZodString;
+    kind: import("zod").ZodLiteral<"cron">;
+    timeZone: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+}, import("zod/v4/core").$strip>], "kind">;
 export type Recurrence = z.infer<typeof recurrenceSchema>;
+/** The customer-safe default for a schedule's recurrence kind. */
+export declare function defaultLatenessPolicyForRecurrence(kind: Recurrence["kind"]): LatenessPolicy;
 /**
  * A schedule, as a client sees it.
  *
@@ -517,109 +695,144 @@ export type Recurrence = z.infer<typeof recurrenceSchema>;
  * endpoint id is useful definition metadata; the encrypted payload is content
  * and stays only in the authoritative partition.
  */
-export declare const scheduleSchema: z.ZodObject<{
-    archivedAt: z.ZodOptional<z.ZodString>;
-    createdAt: z.ZodString;
-    delivery: z.ZodOptional<z.ZodObject<{
-        completion: z.ZodEnum<{
+/**
+ * A schedule's name: for people, never an identifier, and free to collide.
+ *
+ * Generated on save when nobody types one (W4-14, FXO-2255) — "Every 60s →
+ * flowxo.com" — and stored as any other name, so editing the recurrence
+ * later rewrites nothing. Two schedules may share a name: two on the same
+ * cadence against the same host both generate the same one, and the operator
+ * chose to let them collide, with the other columns and the identifier
+ * telling them apart. Endpoints get the opposite rule.
+ */
+/** The most a schedule's name may hold; the generated one is cut to fit it. */
+export declare const SCHEDULE_NAME_MAX_LENGTH = 120;
+export declare const scheduleNameSchema: import("zod").ZodString;
+export declare const scheduleSchema: import("zod").ZodObject<{
+    archivedAt: import("zod").ZodOptional<import("zod").ZodString>;
+    data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
+    createdAt: import("zod").ZodString;
+    delivery: import("zod").ZodOptional<import("zod").ZodObject<{
+        completion: import("zod").ZodEnum<{
             response: "response";
             callback: "callback";
         }>;
-        maxDurationSeconds: z.ZodNumber;
-        onOverlap: z.ZodEnum<{
+        maxDurationSeconds: import("zod").ZodNumber;
+        onOverlap: import("zod").ZodEnum<{
             skip: "skip";
             queue: "queue";
         }>;
-    }, z.core.$strip>>;
-    endpoint: z.ZodOptional<z.ZodString>;
-    generation: z.ZodNumber;
-    id: z.ZodString;
-    latencyClass: z.ZodEnum<{
+    }, import("zod/v4/core").$strip>>;
+    endpoint: import("zod").ZodOptional<import("zod").ZodString>;
+    endpointUrl: import("zod").ZodOptional<import("zod").ZodString>;
+    generation: import("zod").ZodNumber;
+    id: import("zod").ZodString;
+    latencyClass: import("zod").ZodEnum<{
         realtime: "realtime";
         bulk: "bulk";
     }>;
-    partitionKey: z.ZodOptional<z.ZodString>;
-    recurrence: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"at">;
-    }, z.core.$strip>, z.ZodObject<{
-        everySeconds: z.ZodNumber;
-        kind: z.ZodLiteral<"every">;
-    }, z.core.$strip>, z.ZodObject<{
-        cron: z.ZodString;
-        kind: z.ZodLiteral<"cron">;
-        timeZone: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-    }, z.core.$strip>], "kind">;
-    status: z.ZodEnum<{
-        paused: "paused";
+    lateness: import("zod").ZodObject<{
+        maxStalenessSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+        policy: import("zod").ZodEnum<{
+            skipAhead: "skipAhead";
+            catchUp: "catchUp";
+        }>;
+    }, import("zod/v4/core").$strict>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    partitionKey: import("zod").ZodOptional<import("zod").ZodString>;
+    nextDueAt: import("zod").ZodOptional<import("zod").ZodString>;
+    recurrence: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"at">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        everySeconds: import("zod").ZodNumber;
+        kind: import("zod").ZodLiteral<"every">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        cron: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"cron">;
+        timeZone: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+    }, import("zod/v4/core").$strip>], "kind">;
+    status: import("zod").ZodEnum<{
         active: "active";
-        cancelled: "cancelled";
         completed: "completed";
+        paused: "paused";
+        cancelled: "cancelled";
     }>;
-    updatedAt: z.ZodString;
-    version: z.ZodNumber;
-}, z.core.$strip>;
+    updatedAt: import("zod").ZodString;
+    version: import("zod").ZodNumber;
+}, import("zod/v4/core").$strip>;
 export type Schedule = z.infer<typeof scheduleSchema>;
 /**
  * A page of schedules.
  *
  * Items are schedules rather than schedule *views*. A cross-partition listing is
- * served from the D1 projection W2-06 built, and that projection holds a route
+ * served from the control-plane projection W2-06 built, and that projection holds a route
  * and a summary rather than every partition's live occurrence — so a page that
  * promised an occurrence would either lie about its freshness or force the
  * listing back through every partition it spans. Detail is where the occurrence
  * is authoritative, and detail is one call away.
  */
-export declare const schedulePageSchema: z.ZodObject<{
-    data: z.ZodArray<z.ZodObject<{
-        archivedAt: z.ZodOptional<z.ZodString>;
-        createdAt: z.ZodString;
-        delivery: z.ZodOptional<z.ZodObject<{
-            completion: z.ZodEnum<{
+export declare const schedulePageSchema: import("zod").ZodObject<{
+    data: import("zod").ZodArray<import("zod").ZodObject<{
+        archivedAt: import("zod").ZodOptional<import("zod").ZodString>;
+        data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
+        createdAt: import("zod").ZodString;
+        delivery: import("zod").ZodOptional<import("zod").ZodObject<{
+            completion: import("zod").ZodEnum<{
                 response: "response";
                 callback: "callback";
             }>;
-            maxDurationSeconds: z.ZodNumber;
-            onOverlap: z.ZodEnum<{
+            maxDurationSeconds: import("zod").ZodNumber;
+            onOverlap: import("zod").ZodEnum<{
                 skip: "skip";
                 queue: "queue";
             }>;
-        }, z.core.$strip>>;
-        endpoint: z.ZodOptional<z.ZodString>;
-        generation: z.ZodNumber;
-        id: z.ZodString;
-        latencyClass: z.ZodEnum<{
+        }, import("zod/v4/core").$strip>>;
+        endpoint: import("zod").ZodOptional<import("zod").ZodString>;
+        endpointUrl: import("zod").ZodOptional<import("zod").ZodString>;
+        generation: import("zod").ZodNumber;
+        id: import("zod").ZodString;
+        latencyClass: import("zod").ZodEnum<{
             realtime: "realtime";
             bulk: "bulk";
         }>;
-        partitionKey: z.ZodOptional<z.ZodString>;
-        recurrence: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"at">;
-        }, z.core.$strip>, z.ZodObject<{
-            everySeconds: z.ZodNumber;
-            kind: z.ZodLiteral<"every">;
-        }, z.core.$strip>, z.ZodObject<{
-            cron: z.ZodString;
-            kind: z.ZodLiteral<"cron">;
-            timeZone: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        }, z.core.$strip>], "kind">;
-        status: z.ZodEnum<{
-            paused: "paused";
+        lateness: import("zod").ZodObject<{
+            maxStalenessSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+            policy: import("zod").ZodEnum<{
+                skipAhead: "skipAhead";
+                catchUp: "catchUp";
+            }>;
+        }, import("zod/v4/core").$strict>;
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        partitionKey: import("zod").ZodOptional<import("zod").ZodString>;
+        nextDueAt: import("zod").ZodOptional<import("zod").ZodString>;
+        recurrence: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"at">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            everySeconds: import("zod").ZodNumber;
+            kind: import("zod").ZodLiteral<"every">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            cron: import("zod").ZodString;
+            kind: import("zod").ZodLiteral<"cron">;
+            timeZone: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+        }, import("zod/v4/core").$strip>], "kind">;
+        status: import("zod").ZodEnum<{
             active: "active";
-            cancelled: "cancelled";
             completed: "completed";
+            paused: "paused";
+            cancelled: "cancelled";
         }>;
-        updatedAt: z.ZodString;
-        version: z.ZodNumber;
-    }, z.core.$strip>>;
-    freshness: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"authoritative">;
-    }, z.core.$strip>, z.ZodObject<{
-        asOf: z.ZodString;
-        kind: z.ZodLiteral<"projected">;
-        lagSeconds: z.ZodNumber;
-    }, z.core.$strip>], "kind">;
-    nextCursor: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+        updatedAt: import("zod").ZodString;
+        version: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>;
+    freshness: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"authoritative">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        asOf: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"projected">;
+        lagSeconds: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>], "kind">;
+    nextCursor: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>;
 export type SchedulePage = z.infer<typeof schedulePageSchema>;
 /**
  * One concrete occurrence of a schedule.
@@ -629,26 +842,35 @@ export type SchedulePage = z.infer<typeof schedulePageSchema>;
  * numbering starts again. Together `(schedule, generation, sequence)` is what
  * makes an occurrence identifiable without depending on when it was written.
  */
-export declare const occurrenceSchema: z.ZodObject<{
-    attemptCount: z.ZodNumber;
-    generation: z.ZodNumber;
-    id: z.ZodString;
-    plannedFor: z.ZodString;
-    schedule: z.ZodString;
-    sequence: z.ZodNumber;
-    settledAt: z.ZodOptional<z.ZodString>;
-    state: z.ZodEnum<{
+export declare const occurrenceSchema: import("zod").ZodObject<{
+    generation: import("zod").ZodNumber;
+    id: import("zod").ZodString;
+    plannedFor: import("zod").ZodString;
+    schedule: import("zod").ZodString;
+    sequence: import("zod").ZodNumber;
+    settledAt: import("zod").ZodOptional<import("zod").ZodString>;
+    state: import("zod").ZodEnum<{
+        due: "due";
         succeeded: "succeeded";
         ambiguous: "ambiguous";
         cancelled: "cancelled";
         planned: "planned";
-        due: "due";
         dispatching: "dispatching";
         retry_wait: "retry_wait";
         terminal_failed: "terminal_failed";
         skipped_stale: "skipped_stale";
     }>;
-}, z.core.$strip>;
+    firstAttemptLatenessMs: import("zod").ZodOptional<import("zod").ZodInt>;
+    firstAttemptStartedAt: import("zod").ZodOptional<import("zod").ZodString>;
+    timingEligibility: import("zod").ZodOptional<import("zod").ZodEnum<{
+        customer_blocked: "customer_blocked";
+        eligible: "eligible";
+        platform_blocked: "platform_blocked";
+    }>>;
+    timingEligibilityReason: import("zod").ZodOptional<import("zod").ZodString>;
+    timingPolicyVersion: import("zod").ZodOptional<import("zod").ZodString>;
+    attemptCount: import("zod").ZodNumber;
+}, import("zod/v4/core").$strip>;
 export type Occurrence = z.infer<typeof occurrenceSchema>;
 /**
  * One delivery attempt against one occurrence.
@@ -674,10 +896,10 @@ export type Occurrence = z.infer<typeof occurrenceSchema>;
  * can look up in their own logs. Cookies, `Authorization` and
  * `WWW-Authenticate` have no representation here at all.
  */
-export declare const attemptResponseHeaderSchema: z.ZodObject<{
-    name: z.ZodString;
-    value: z.ZodString;
-}, z.core.$strip>;
+export declare const attemptResponseHeaderSchema: import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    value: import("zod").ZodString;
+}, import("zod/v4/core").$strip>;
 export type AttemptResponseHeader = z.infer<typeof attemptResponseHeaderSchema>;
 /**
  * What a failing receiver said, bounded and access-controlled.
@@ -692,194 +914,247 @@ export type AttemptResponseHeader = z.infer<typeof attemptResponseHeaderSchema>;
  * that is exactly the bound and a body that was cut at the bound are different
  * facts and only one of them should show a customer an ellipsis.
  */
-export declare const attemptFailureSnippetSchema: z.ZodObject<{
-    contentType: z.ZodString;
-    text: z.ZodString;
-    truncated: z.ZodBoolean;
-}, z.core.$strip>;
+export declare const attemptFailureSnippetSchema: import("zod").ZodObject<{
+    contentType: import("zod").ZodString;
+    text: import("zod").ZodString;
+    truncated: import("zod").ZodBoolean;
+}, import("zod/v4/core").$strip>;
 export type AttemptFailureSnippet = z.infer<typeof attemptFailureSnippetSchema>;
-export declare const attemptSchema: z.ZodObject<{
-    attemptNumber: z.ZodNumber;
-    classifiedAt: z.ZodOptional<z.ZodString>;
-    delivery: z.ZodString;
-    diagnostic: z.ZodOptional<z.ZodEnum<{
-        rate_limited: "rate_limited";
-        completion_timed_out: "completion_timed_out";
-        delivered: "delivered";
-        duplicate_inflight: "duplicate_inflight";
-        endpoint_unavailable: "endpoint_unavailable";
-        endpoint_unsafe: "endpoint_unsafe";
-        http_refused: "http_refused";
-        http_retryable: "http_retryable";
-        http_terminal: "http_terminal";
-        identity_conflict: "identity_conflict";
-        network_ambiguous: "network_ambiguous";
-        payload_unavailable: "payload_unavailable";
-    }>>;
-    durationMs: z.ZodOptional<z.ZodNumber>;
-    id: z.ZodString;
-    occurrence: z.ZodString;
-    remediation: z.ZodOptional<z.ZodEnum<{
+export declare const attemptSchema: import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    localReceiptRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;
+    occurrence: import("zod").ZodString;
+    rescues: import("zod").ZodOptional<import("zod").ZodInt>;
+    remediation: import("zod").ZodOptional<import("zod").ZodEnum<{
         none: "none";
         review_retry_policy: "review_retry_policy";
         inspect_receiver: "inspect_receiver";
-        verify_endpoint: "verify_endpoint";
+        review_endpoint: "review_endpoint";
         replace_payload: "replace_payload";
         contact_support: "contact_support";
         review_before_redelivery: "review_before_redelivery";
     }>>;
-    failureSnippet: z.ZodOptional<z.ZodObject<{
-        contentType: z.ZodString;
-        text: z.ZodString;
-        truncated: z.ZodBoolean;
-    }, z.core.$strip>>;
-    responseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        value: z.ZodString;
-    }, z.core.$strip>>>;
-    responseStatus: z.ZodOptional<z.ZodNumber>;
-    startedAt: z.ZodString;
-    state: z.ZodOptional<z.ZodEnum<{
+    failureSnippet: import("zod").ZodOptional<import("zod").ZodObject<{
+        contentType: import("zod").ZodString;
+        text: import("zod").ZodString;
+        truncated: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>>;
+    responseHeaders: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        value: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>;
+    responseStatus: import("zod").ZodOptional<import("zod").ZodNumber>;
+    startedAt: import("zod").ZodString;
+    state: import("zod").ZodOptional<import("zod").ZodEnum<{
         succeeded: "succeeded";
         ambiguous: "ambiguous";
         retryable_failure: "retryable_failure";
         terminal_failure: "terminal_failure";
     }>>;
-    trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"automatic">;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"redelivery">;
-        sourceAttemptId: z.ZodString;
-    }, z.core.$strip>], "kind">;
-}, z.core.$strip>;
+    trigger: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"automatic">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"redelivery">;
+        sourceAttemptId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>], "kind">;
+    firstAttemptLatenessMs: import("zod").ZodOptional<import("zod").ZodInt>;
+    firstAttemptStartedAt: import("zod").ZodOptional<import("zod").ZodString>;
+    timingEligibility: import("zod").ZodOptional<import("zod").ZodEnum<{
+        customer_blocked: "customer_blocked";
+        eligible: "eligible";
+        platform_blocked: "platform_blocked";
+    }>>;
+    timingEligibilityReason: import("zod").ZodOptional<import("zod").ZodString>;
+    timingPolicyVersion: import("zod").ZodOptional<import("zod").ZodString>;
+    attemptNumber: import("zod").ZodNumber;
+    classifiedAt: import("zod").ZodOptional<import("zod").ZodString>;
+    delivery: import("zod").ZodString;
+    diagnostic: import("zod").ZodOptional<import("zod").ZodEnum<{
+        rate_limited: "rate_limited";
+        delivered: "delivered";
+        completion_timed_out: "completion_timed_out";
+        duplicate_inflight: "duplicate_inflight";
+        endpoint_unavailable: "endpoint_unavailable";
+        endpoint_unsafe: "endpoint_unsafe";
+        http_refused: "http_refused";
+        http_retryable: "http_retryable";
+        http_terminal: "http_terminal";
+        identity_conflict: "identity_conflict";
+        network_ambiguous: "network_ambiguous";
+        payload_unavailable: "payload_unavailable";
+    }>>;
+    dispatchRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;
+    durationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>;
 export type Attempt = z.infer<typeof attemptSchema>;
 /** An authoritative page over one schedule's retained occurrences. */
-export declare const occurrencePageSchema: z.ZodObject<{
-    data: z.ZodArray<z.ZodObject<{
-        attemptCount: z.ZodNumber;
-        generation: z.ZodNumber;
-        id: z.ZodString;
-        plannedFor: z.ZodString;
-        schedule: z.ZodString;
-        sequence: z.ZodNumber;
-        settledAt: z.ZodOptional<z.ZodString>;
-        state: z.ZodEnum<{
+export declare const occurrencePageSchema: import("zod").ZodObject<{
+    data: import("zod").ZodArray<import("zod").ZodObject<{
+        generation: import("zod").ZodNumber;
+        id: import("zod").ZodString;
+        plannedFor: import("zod").ZodString;
+        schedule: import("zod").ZodString;
+        sequence: import("zod").ZodNumber;
+        settledAt: import("zod").ZodOptional<import("zod").ZodString>;
+        state: import("zod").ZodEnum<{
+            due: "due";
             succeeded: "succeeded";
             ambiguous: "ambiguous";
             cancelled: "cancelled";
             planned: "planned";
-            due: "due";
             dispatching: "dispatching";
             retry_wait: "retry_wait";
             terminal_failed: "terminal_failed";
             skipped_stale: "skipped_stale";
         }>;
-    }, z.core.$strip>>;
-    nextCursor: z.ZodOptional<z.ZodString>;
-    freshness: z.ZodObject<{
-        kind: z.ZodLiteral<"authoritative">;
-    }, z.core.$strip>;
-}, z.core.$strip>;
+        firstAttemptLatenessMs: import("zod").ZodOptional<import("zod").ZodInt>;
+        firstAttemptStartedAt: import("zod").ZodOptional<import("zod").ZodString>;
+        timingEligibility: import("zod").ZodOptional<import("zod").ZodEnum<{
+            customer_blocked: "customer_blocked";
+            eligible: "eligible";
+            platform_blocked: "platform_blocked";
+        }>>;
+        timingEligibilityReason: import("zod").ZodOptional<import("zod").ZodString>;
+        timingPolicyVersion: import("zod").ZodOptional<import("zod").ZodString>;
+        attemptCount: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>;
+    nextCursor: import("zod").ZodOptional<import("zod").ZodString>;
+    freshness: import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"authoritative">;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>;
 export type OccurrencePage = z.infer<typeof occurrencePageSchema>;
-/** An authoritative occurrence detail response. */
-export declare const occurrenceViewSchema: z.ZodObject<{
-    freshness: z.ZodObject<{
-        kind: z.ZodLiteral<"authoritative">;
-    }, z.core.$strip>;
-    occurrence: z.ZodObject<{
-        attemptCount: z.ZodNumber;
-        generation: z.ZodNumber;
-        id: z.ZodString;
-        plannedFor: z.ZodString;
-        schedule: z.ZodString;
-        sequence: z.ZodNumber;
-        settledAt: z.ZodOptional<z.ZodString>;
-        state: z.ZodEnum<{
+/** A project-wide occurrence page and its plan's normal history boundary. */
+export declare const projectOccurrencePageSchema: import("zod").ZodObject<{
+    data: import("zod").ZodArray<import("zod").ZodObject<{
+        generation: import("zod").ZodNumber;
+        id: import("zod").ZodString;
+        plannedFor: import("zod").ZodString;
+        schedule: import("zod").ZodString;
+        sequence: import("zod").ZodNumber;
+        settledAt: import("zod").ZodOptional<import("zod").ZodString>;
+        state: import("zod").ZodEnum<{
+            due: "due";
             succeeded: "succeeded";
             ambiguous: "ambiguous";
             cancelled: "cancelled";
             planned: "planned";
+            dispatching: "dispatching";
+            retry_wait: "retry_wait";
+            terminal_failed: "terminal_failed";
+            skipped_stale: "skipped_stale";
+        }>;
+        firstAttemptLatenessMs: import("zod").ZodOptional<import("zod").ZodInt>;
+        firstAttemptStartedAt: import("zod").ZodOptional<import("zod").ZodString>;
+        timingEligibility: import("zod").ZodOptional<import("zod").ZodEnum<{
+            customer_blocked: "customer_blocked";
+            eligible: "eligible";
+            platform_blocked: "platform_blocked";
+        }>>;
+        timingEligibilityReason: import("zod").ZodOptional<import("zod").ZodString>;
+        timingPolicyVersion: import("zod").ZodOptional<import("zod").ZodString>;
+        attemptCount: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>;
+    nextCursor: import("zod").ZodOptional<import("zod").ZodString>;
+    freshness: import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"authoritative">;
+    }, import("zod/v4/core").$strip>;
+    retention: import("zod").ZodObject<{
+        from: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>;
+export type ProjectOccurrencePage = z.infer<typeof projectOccurrencePageSchema>;
+/** An authoritative occurrence detail response. */
+export declare const occurrenceViewSchema: import("zod").ZodObject<{
+    freshness: import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"authoritative">;
+    }, import("zod/v4/core").$strip>;
+    occurrence: import("zod").ZodObject<{
+        generation: import("zod").ZodNumber;
+        id: import("zod").ZodString;
+        plannedFor: import("zod").ZodString;
+        schedule: import("zod").ZodString;
+        sequence: import("zod").ZodNumber;
+        settledAt: import("zod").ZodOptional<import("zod").ZodString>;
+        state: import("zod").ZodEnum<{
             due: "due";
+            succeeded: "succeeded";
+            ambiguous: "ambiguous";
+            cancelled: "cancelled";
+            planned: "planned";
             dispatching: "dispatching";
             retry_wait: "retry_wait";
             terminal_failed: "terminal_failed";
             skipped_stale: "skipped_stale";
         }>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
+        firstAttemptLatenessMs: import("zod").ZodOptional<import("zod").ZodInt>;
+        firstAttemptStartedAt: import("zod").ZodOptional<import("zod").ZodString>;
+        timingEligibility: import("zod").ZodOptional<import("zod").ZodEnum<{
+            customer_blocked: "customer_blocked";
+            eligible: "eligible";
+            platform_blocked: "platform_blocked";
+        }>>;
+        timingEligibilityReason: import("zod").ZodOptional<import("zod").ZodString>;
+        timingPolicyVersion: import("zod").ZodOptional<import("zod").ZodString>;
+        attemptCount: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>;
 export type OccurrenceView = z.infer<typeof occurrenceViewSchema>;
 /** An authoritative page over one retained occurrence's immutable attempts. */
-export declare const attemptPageSchema: z.ZodObject<{
-    data: z.ZodArray<z.ZodObject<{
-        attemptNumber: z.ZodNumber;
-        classifiedAt: z.ZodOptional<z.ZodString>;
-        delivery: z.ZodString;
-        diagnostic: z.ZodOptional<z.ZodEnum<{
-            rate_limited: "rate_limited";
-            completion_timed_out: "completion_timed_out";
-            delivered: "delivered";
-            duplicate_inflight: "duplicate_inflight";
-            endpoint_unavailable: "endpoint_unavailable";
-            endpoint_unsafe: "endpoint_unsafe";
-            http_refused: "http_refused";
-            http_retryable: "http_retryable";
-            http_terminal: "http_terminal";
-            identity_conflict: "identity_conflict";
-            network_ambiguous: "network_ambiguous";
-            payload_unavailable: "payload_unavailable";
-        }>>;
-        durationMs: z.ZodOptional<z.ZodNumber>;
-        id: z.ZodString;
-        occurrence: z.ZodString;
-        remediation: z.ZodOptional<z.ZodEnum<{
+export declare const attemptPageSchema: import("zod").ZodObject<{
+    data: import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        localReceiptRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;
+        occurrence: import("zod").ZodString;
+        rescues: import("zod").ZodOptional<import("zod").ZodInt>;
+        remediation: import("zod").ZodOptional<import("zod").ZodEnum<{
             none: "none";
             review_retry_policy: "review_retry_policy";
             inspect_receiver: "inspect_receiver";
-            verify_endpoint: "verify_endpoint";
+            review_endpoint: "review_endpoint";
             replace_payload: "replace_payload";
             contact_support: "contact_support";
             review_before_redelivery: "review_before_redelivery";
         }>>;
-        failureSnippet: z.ZodOptional<z.ZodObject<{
-            contentType: z.ZodString;
-            text: z.ZodString;
-            truncated: z.ZodBoolean;
-        }, z.core.$strip>>;
-        responseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            value: z.ZodString;
-        }, z.core.$strip>>>;
-        responseStatus: z.ZodOptional<z.ZodNumber>;
-        startedAt: z.ZodString;
-        state: z.ZodOptional<z.ZodEnum<{
+        failureSnippet: import("zod").ZodOptional<import("zod").ZodObject<{
+            contentType: import("zod").ZodString;
+            text: import("zod").ZodString;
+            truncated: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>>;
+        responseHeaders: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>>;
+        responseStatus: import("zod").ZodOptional<import("zod").ZodNumber>;
+        startedAt: import("zod").ZodString;
+        state: import("zod").ZodOptional<import("zod").ZodEnum<{
             succeeded: "succeeded";
             ambiguous: "ambiguous";
             retryable_failure: "retryable_failure";
             terminal_failure: "terminal_failure";
         }>>;
-        trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"automatic">;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<"redelivery">;
-            sourceAttemptId: z.ZodString;
-        }, z.core.$strip>], "kind">;
-    }, z.core.$strip>>;
-    nextCursor: z.ZodOptional<z.ZodString>;
-    freshness: z.ZodObject<{
-        kind: z.ZodLiteral<"authoritative">;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type AttemptPage = z.infer<typeof attemptPageSchema>;
-/** An authoritative attempt detail or redelivery response. */
-export declare const attemptViewSchema: z.ZodObject<{
-    attempt: z.ZodObject<{
-        attemptNumber: z.ZodNumber;
-        classifiedAt: z.ZodOptional<z.ZodString>;
-        delivery: z.ZodString;
-        diagnostic: z.ZodOptional<z.ZodEnum<{
+        trigger: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"automatic">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"redelivery">;
+            sourceAttemptId: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>], "kind">;
+        firstAttemptLatenessMs: import("zod").ZodOptional<import("zod").ZodInt>;
+        firstAttemptStartedAt: import("zod").ZodOptional<import("zod").ZodString>;
+        timingEligibility: import("zod").ZodOptional<import("zod").ZodEnum<{
+            customer_blocked: "customer_blocked";
+            eligible: "eligible";
+            platform_blocked: "platform_blocked";
+        }>>;
+        timingEligibilityReason: import("zod").ZodOptional<import("zod").ZodString>;
+        timingPolicyVersion: import("zod").ZodOptional<import("zod").ZodString>;
+        attemptNumber: import("zod").ZodNumber;
+        classifiedAt: import("zod").ZodOptional<import("zod").ZodString>;
+        delivery: import("zod").ZodString;
+        diagnostic: import("zod").ZodOptional<import("zod").ZodEnum<{
             rate_limited: "rate_limited";
-            completion_timed_out: "completion_timed_out";
             delivered: "delivered";
+            completion_timed_out: "completion_timed_out";
             duplicate_inflight: "duplicate_inflight";
             endpoint_unavailable: "endpoint_unavailable";
             endpoint_unsafe: "endpoint_unsafe";
@@ -890,46 +1165,87 @@ export declare const attemptViewSchema: z.ZodObject<{
             network_ambiguous: "network_ambiguous";
             payload_unavailable: "payload_unavailable";
         }>>;
-        durationMs: z.ZodOptional<z.ZodNumber>;
-        id: z.ZodString;
-        occurrence: z.ZodString;
-        remediation: z.ZodOptional<z.ZodEnum<{
+        dispatchRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;
+        durationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    nextCursor: import("zod").ZodOptional<import("zod").ZodString>;
+    freshness: import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"authoritative">;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>;
+export type AttemptPage = z.infer<typeof attemptPageSchema>;
+/** An authoritative attempt detail or redelivery response. */
+export declare const attemptViewSchema: import("zod").ZodObject<{
+    attempt: import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        localReceiptRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;
+        occurrence: import("zod").ZodString;
+        rescues: import("zod").ZodOptional<import("zod").ZodInt>;
+        remediation: import("zod").ZodOptional<import("zod").ZodEnum<{
             none: "none";
             review_retry_policy: "review_retry_policy";
             inspect_receiver: "inspect_receiver";
-            verify_endpoint: "verify_endpoint";
+            review_endpoint: "review_endpoint";
             replace_payload: "replace_payload";
             contact_support: "contact_support";
             review_before_redelivery: "review_before_redelivery";
         }>>;
-        failureSnippet: z.ZodOptional<z.ZodObject<{
-            contentType: z.ZodString;
-            text: z.ZodString;
-            truncated: z.ZodBoolean;
-        }, z.core.$strip>>;
-        responseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            value: z.ZodString;
-        }, z.core.$strip>>>;
-        responseStatus: z.ZodOptional<z.ZodNumber>;
-        startedAt: z.ZodString;
-        state: z.ZodOptional<z.ZodEnum<{
+        failureSnippet: import("zod").ZodOptional<import("zod").ZodObject<{
+            contentType: import("zod").ZodString;
+            text: import("zod").ZodString;
+            truncated: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>>;
+        responseHeaders: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>>;
+        responseStatus: import("zod").ZodOptional<import("zod").ZodNumber>;
+        startedAt: import("zod").ZodString;
+        state: import("zod").ZodOptional<import("zod").ZodEnum<{
             succeeded: "succeeded";
             ambiguous: "ambiguous";
             retryable_failure: "retryable_failure";
             terminal_failure: "terminal_failure";
         }>>;
-        trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"automatic">;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<"redelivery">;
-            sourceAttemptId: z.ZodString;
-        }, z.core.$strip>], "kind">;
-    }, z.core.$strip>;
-    freshness: z.ZodObject<{
-        kind: z.ZodLiteral<"authoritative">;
-    }, z.core.$strip>;
-}, z.core.$strip>;
+        trigger: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"automatic">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"redelivery">;
+            sourceAttemptId: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>], "kind">;
+        firstAttemptLatenessMs: import("zod").ZodOptional<import("zod").ZodInt>;
+        firstAttemptStartedAt: import("zod").ZodOptional<import("zod").ZodString>;
+        timingEligibility: import("zod").ZodOptional<import("zod").ZodEnum<{
+            customer_blocked: "customer_blocked";
+            eligible: "eligible";
+            platform_blocked: "platform_blocked";
+        }>>;
+        timingEligibilityReason: import("zod").ZodOptional<import("zod").ZodString>;
+        timingPolicyVersion: import("zod").ZodOptional<import("zod").ZodString>;
+        attemptNumber: import("zod").ZodNumber;
+        classifiedAt: import("zod").ZodOptional<import("zod").ZodString>;
+        delivery: import("zod").ZodString;
+        diagnostic: import("zod").ZodOptional<import("zod").ZodEnum<{
+            rate_limited: "rate_limited";
+            delivered: "delivered";
+            completion_timed_out: "completion_timed_out";
+            duplicate_inflight: "duplicate_inflight";
+            endpoint_unavailable: "endpoint_unavailable";
+            endpoint_unsafe: "endpoint_unsafe";
+            http_refused: "http_refused";
+            http_retryable: "http_retryable";
+            http_terminal: "http_terminal";
+            identity_conflict: "identity_conflict";
+            network_ambiguous: "network_ambiguous";
+            payload_unavailable: "payload_unavailable";
+        }>>;
+        dispatchRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;
+        durationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>;
+    freshness: import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"authoritative">;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>;
 export type AttemptView = z.infer<typeof attemptViewSchema>;
 /**
  * A schedule together with the occurrence that is next to happen.
@@ -939,69 +1255,89 @@ export type AttemptView = z.infer<typeof attemptViewSchema>;
  * that has to make a second request to answer it will cache the first answer and
  * be wrong.
  */
-export declare const scheduleViewSchema: z.ZodObject<{
-    occurrence: z.ZodObject<{
-        attemptCount: z.ZodNumber;
-        generation: z.ZodNumber;
-        id: z.ZodString;
-        plannedFor: z.ZodString;
-        schedule: z.ZodString;
-        sequence: z.ZodNumber;
-        settledAt: z.ZodOptional<z.ZodString>;
-        state: z.ZodEnum<{
+export declare const scheduleViewSchema: import("zod").ZodObject<{
+    occurrence: import("zod").ZodObject<{
+        generation: import("zod").ZodNumber;
+        id: import("zod").ZodString;
+        plannedFor: import("zod").ZodString;
+        schedule: import("zod").ZodString;
+        sequence: import("zod").ZodNumber;
+        settledAt: import("zod").ZodOptional<import("zod").ZodString>;
+        state: import("zod").ZodEnum<{
+            due: "due";
             succeeded: "succeeded";
             ambiguous: "ambiguous";
             cancelled: "cancelled";
             planned: "planned";
-            due: "due";
             dispatching: "dispatching";
             retry_wait: "retry_wait";
             terminal_failed: "terminal_failed";
             skipped_stale: "skipped_stale";
         }>;
-    }, z.core.$strip>;
-    schedule: z.ZodObject<{
-        archivedAt: z.ZodOptional<z.ZodString>;
-        createdAt: z.ZodString;
-        delivery: z.ZodOptional<z.ZodObject<{
-            completion: z.ZodEnum<{
+        firstAttemptLatenessMs: import("zod").ZodOptional<import("zod").ZodInt>;
+        firstAttemptStartedAt: import("zod").ZodOptional<import("zod").ZodString>;
+        timingEligibility: import("zod").ZodOptional<import("zod").ZodEnum<{
+            customer_blocked: "customer_blocked";
+            eligible: "eligible";
+            platform_blocked: "platform_blocked";
+        }>>;
+        timingEligibilityReason: import("zod").ZodOptional<import("zod").ZodString>;
+        timingPolicyVersion: import("zod").ZodOptional<import("zod").ZodString>;
+        attemptCount: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
+    schedule: import("zod").ZodObject<{
+        archivedAt: import("zod").ZodOptional<import("zod").ZodString>;
+        data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
+        createdAt: import("zod").ZodString;
+        delivery: import("zod").ZodOptional<import("zod").ZodObject<{
+            completion: import("zod").ZodEnum<{
                 response: "response";
                 callback: "callback";
             }>;
-            maxDurationSeconds: z.ZodNumber;
-            onOverlap: z.ZodEnum<{
+            maxDurationSeconds: import("zod").ZodNumber;
+            onOverlap: import("zod").ZodEnum<{
                 skip: "skip";
                 queue: "queue";
             }>;
-        }, z.core.$strip>>;
-        endpoint: z.ZodOptional<z.ZodString>;
-        generation: z.ZodNumber;
-        id: z.ZodString;
-        latencyClass: z.ZodEnum<{
+        }, import("zod/v4/core").$strip>>;
+        endpoint: import("zod").ZodOptional<import("zod").ZodString>;
+        endpointUrl: import("zod").ZodOptional<import("zod").ZodString>;
+        generation: import("zod").ZodNumber;
+        id: import("zod").ZodString;
+        latencyClass: import("zod").ZodEnum<{
             realtime: "realtime";
             bulk: "bulk";
         }>;
-        partitionKey: z.ZodOptional<z.ZodString>;
-        recurrence: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"at">;
-        }, z.core.$strip>, z.ZodObject<{
-            everySeconds: z.ZodNumber;
-            kind: z.ZodLiteral<"every">;
-        }, z.core.$strip>, z.ZodObject<{
-            cron: z.ZodString;
-            kind: z.ZodLiteral<"cron">;
-            timeZone: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        }, z.core.$strip>], "kind">;
-        status: z.ZodEnum<{
-            paused: "paused";
+        lateness: import("zod").ZodObject<{
+            maxStalenessSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+            policy: import("zod").ZodEnum<{
+                skipAhead: "skipAhead";
+                catchUp: "catchUp";
+            }>;
+        }, import("zod/v4/core").$strict>;
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        partitionKey: import("zod").ZodOptional<import("zod").ZodString>;
+        nextDueAt: import("zod").ZodOptional<import("zod").ZodString>;
+        recurrence: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"at">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            everySeconds: import("zod").ZodNumber;
+            kind: import("zod").ZodLiteral<"every">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            cron: import("zod").ZodString;
+            kind: import("zod").ZodLiteral<"cron">;
+            timeZone: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+        }, import("zod/v4/core").$strip>], "kind">;
+        status: import("zod").ZodEnum<{
             active: "active";
-            cancelled: "cancelled";
             completed: "completed";
+            paused: "paused";
+            cancelled: "cancelled";
         }>;
-        updatedAt: z.ZodString;
-        version: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>;
+        updatedAt: import("zod").ZodString;
+        version: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>;
 export type ScheduleView = z.infer<typeof scheduleViewSchema>;
 /**
  * The four ways a caller may say when a schedule happens.
@@ -1027,32 +1363,42 @@ export declare const RECURRENCE_REQUEST_FIELDS: readonly ["at", "cron", "delaySe
  * `ambiguous_schedule`, and a scheduler that silently picks one of two instants
  * a customer named is the worst kind of helpful.
  */
-export declare const scheduleRequestSchema: z.ZodObject<{
-    at: z.ZodOptional<z.ZodString>;
-    cron: z.ZodOptional<z.ZodString>;
-    data: z.ZodOptional<z.ZodJSONSchema>;
-    delaySeconds: z.ZodOptional<z.ZodNumber>;
-    delivery: z.ZodOptional<z.ZodObject<{
-        onOverlap: z.ZodOptional<z.ZodEnum<{
+export declare const scheduleRequestSchema: import("zod").ZodObject<{
+    at: import("zod").ZodOptional<import("zod").ZodString>;
+    cron: import("zod").ZodOptional<import("zod").ZodString>;
+    data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
+    delaySeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+    delivery: import("zod").ZodOptional<import("zod").ZodObject<{
+        onOverlap: import("zod").ZodOptional<import("zod").ZodEnum<{
             skip: "skip";
             queue: "queue";
         }>>;
-        completion: z.ZodOptional<z.ZodEnum<{
+        completion: import("zod").ZodOptional<import("zod").ZodEnum<{
             response: "response";
             callback: "callback";
         }>>;
-        maxDurationSeconds: z.ZodOptional<z.ZodLiteral<300 | 5 | 30 | 900 | 1800 | 3600 | 43200 | 86400>>;
-    }, z.core.$strict>>;
-    everySeconds: z.ZodOptional<z.ZodNumber>;
-    endpoint: z.ZodOptional<z.ZodString>;
-    latencyClass: z.ZodOptional<z.ZodEnum<{
+        maxDurationSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strict>>;
+    everySeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+    endpoint: import("zod").ZodOptional<import("zod").ZodString>;
+    latencyClass: import("zod").ZodOptional<import("zod").ZodEnum<{
         realtime: "realtime";
         bulk: "bulk";
     }>>;
-    partitionKey: z.ZodOptional<z.ZodString>;
-    timeZone: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
-}, z.core.$strict>;
+    lateness: import("zod").ZodOptional<import("zod").ZodObject<{
+        maxStalenessSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+        policy: import("zod").ZodOptional<import("zod").ZodEnum<{
+            skipAhead: "skipAhead";
+            catchUp: "catchUp";
+        }>>;
+    }, import("zod/v4/core").$strict>>;
+    partitionKey: import("zod").ZodOptional<import("zod").ZodString>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    timeZone: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>>;
+}, import("zod/v4/core").$strict>;
 export type ScheduleRequest = z.infer<typeof scheduleRequestSchema>;
+/** Resolve the lateness settings a create or replacement request runs under. */
+export declare function deriveLatenessSettings(request: ScheduleRequest): LatenessSettings;
 /**
  * The class a request runs under: the caller's, or the one its recurrence
  * implies.