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

package/dist/test-sink.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "./zod.js";
 import { type CallbackCompletionOutcome } from "./delivery.js";
 /**
  * The deterministic test sink and the receiver contract it and the shipped
@@ -54,7 +54,7 @@ import { type CallbackCompletionOutcome } from "./delivery.js";
  * is the whole of what an integrator rehearsing deferral needs to see.
  */
 export declare const TEST_SINK_BEHAVIORS: readonly ["client_error", "defer_abandon", "defer_fail", "defer_succeed", "delay", "disconnect", "duplicate", "invalid_signature", "rate_limited", "server_error", "success", "timeout"];
-export declare const testSinkBehaviorSchema: z.ZodEnum<{
+export declare const testSinkBehaviorSchema: import("zod").ZodEnum<{
     rate_limited: "rate_limited";
     success: "success";
     server_error: "server_error";
@@ -154,8 +154,8 @@ export declare const TEST_SINK_SERVER_ERROR_STATUSES: readonly [500, 502, 503, 5
  * occurrence's attempts: a sink is a destination and does not get to know which
  * occurrence the sender considers current.
  */
-export declare const testSinkProgramSchema: z.ZodObject<{
-    behavior: z.ZodEnum<{
+export declare const testSinkProgramSchema: import("zod").ZodObject<{
+    behavior: import("zod").ZodEnum<{
         rate_limited: "rate_limited";
         success: "success";
         server_error: "server_error";
@@ -169,12 +169,12 @@ export declare const testSinkProgramSchema: z.ZodObject<{
         invalid_signature: "invalid_signature";
         timeout: "timeout";
     }>;
-    completionDelayMs: z.ZodOptional<z.ZodNumber>;
-    delayMs: z.ZodOptional<z.ZodNumber>;
-    forDeliveries: z.ZodOptional<z.ZodNumber>;
-    retryAfterSeconds: z.ZodOptional<z.ZodNumber>;
-    status: z.ZodOptional<z.ZodNumber>;
-    then: z.ZodOptional<z.ZodEnum<{
+    completionDelayMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+    delayMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+    forDeliveries: import("zod").ZodOptional<import("zod").ZodNumber>;
+    retryAfterSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+    status: import("zod").ZodOptional<import("zod").ZodNumber>;
+    then: import("zod").ZodOptional<import("zod").ZodEnum<{
         rate_limited: "rate_limited";
         success: "success";
         server_error: "server_error";
@@ -188,7 +188,7 @@ export declare const testSinkProgramSchema: z.ZodObject<{
         invalid_signature: "invalid_signature";
         timeout: "timeout";
     }>>;
-}, z.core.$strip>;
+}, import("zod/v4/core").$strip>;
 export type TestSinkProgram = z.infer<typeof testSinkProgramSchema>;
 /**
  * What each behavior does, as data rather than prose, so the published artifact
@@ -382,7 +382,7 @@ export declare function resolveTestSinkAction(program: TestSinkProgram, delivery
  * yet produced.
  */
 export declare const CALLBACK_RECEIVER_DISPOSITIONS: readonly ["body_too_large", "duplicate", "handler_failed", "in_flight", "invalid_envelope", "invalid_headers", "invalid_signature", "processed", "replay", "stale_timestamp"];
-export declare const callbackReceiverDispositionSchema: z.ZodEnum<{
+export declare const callbackReceiverDispositionSchema: import("zod").ZodEnum<{
     duplicate: "duplicate";
     invalid_signature: "invalid_signature";
     body_too_large: "body_too_large";
@@ -406,7 +406,7 @@ export type CallbackReceiverDisposition = z.infer<typeof callbackReceiverDisposi
  * makes that list useful — every member maps to exactly one status.
  */
 export declare const TEST_SINK_DISPOSITIONS: readonly ["body_too_large", "duplicate", "handler_failed", "in_flight", "invalid_envelope", "invalid_headers", "invalid_signature", "processed", "replay", "stale_timestamp", "connection_dropped"];
-export declare const testSinkDispositionSchema: z.ZodEnum<{
+export declare const testSinkDispositionSchema: import("zod").ZodEnum<{
     duplicate: "duplicate";
     invalid_signature: "invalid_signature";
     body_too_large: "body_too_large";
@@ -476,8 +476,8 @@ export declare const CALLBACK_RECEIVER_STATUS: {
  * read by a machine, and a body that carries an exception message is how a
  * receiver leaks its internals to whoever can provoke an error.
  */
-export declare const callbackReceiverAcknowledgementSchema: z.ZodObject<{
-    disposition: z.ZodEnum<{
+export declare const callbackReceiverAcknowledgementSchema: import("zod").ZodObject<{
+    disposition: import("zod").ZodEnum<{
         duplicate: "duplicate";
         invalid_signature: "invalid_signature";
         body_too_large: "body_too_large";
@@ -489,17 +489,17 @@ export declare const callbackReceiverAcknowledgementSchema: z.ZodObject<{
         replay: "replay";
         stale_timestamp: "stale_timestamp";
     }>;
-    occurrenceId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+    occurrenceId: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>;
 export type CallbackReceiverAcknowledgement = z.infer<typeof callbackReceiverAcknowledgementSchema>;
-export declare const testSinkSchema: z.ZodObject<{
-    createdAt: z.ZodString;
-    deliveryCount: z.ZodNumber;
-    endpoint: z.ZodString;
-    environmentKind: z.ZodLiteral<"test">;
-    id: z.ZodString;
-    program: z.ZodObject<{
-        behavior: z.ZodEnum<{
+export declare const testSinkSchema: import("zod").ZodObject<{
+    createdAt: import("zod").ZodString;
+    deliveryCount: import("zod").ZodNumber;
+    endpoint: import("zod").ZodString;
+    environmentKind: import("zod").ZodLiteral<"test">;
+    id: import("zod").ZodString;
+    program: import("zod").ZodObject<{
+        behavior: import("zod").ZodEnum<{
             rate_limited: "rate_limited";
             success: "success";
             server_error: "server_error";
@@ -513,12 +513,12 @@ export declare const testSinkSchema: z.ZodObject<{
             invalid_signature: "invalid_signature";
             timeout: "timeout";
         }>;
-        completionDelayMs: z.ZodOptional<z.ZodNumber>;
-        delayMs: z.ZodOptional<z.ZodNumber>;
-        forDeliveries: z.ZodOptional<z.ZodNumber>;
-        retryAfterSeconds: z.ZodOptional<z.ZodNumber>;
-        status: z.ZodOptional<z.ZodNumber>;
-        then: z.ZodOptional<z.ZodEnum<{
+        completionDelayMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+        delayMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+        forDeliveries: import("zod").ZodOptional<import("zod").ZodNumber>;
+        retryAfterSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+        status: import("zod").ZodOptional<import("zod").ZodNumber>;
+        then: import("zod").ZodOptional<import("zod").ZodEnum<{
             rate_limited: "rate_limited";
             success: "success";
             server_error: "server_error";
@@ -532,21 +532,21 @@ export declare const testSinkSchema: z.ZodObject<{
             invalid_signature: "invalid_signature";
             timeout: "timeout";
         }>>;
-    }, z.core.$strip>;
-    project: z.ZodString;
-    updatedAt: z.ZodString;
-    url: z.ZodURL;
-}, z.core.$strip>;
+    }, import("zod/v4/core").$strip>;
+    project: import("zod").ZodString;
+    updatedAt: import("zod").ZodString;
+    url: import("zod").ZodURL;
+}, import("zod/v4/core").$strip>;
 export type TestSink = z.infer<typeof testSinkSchema>;
-export declare const testSinkPageSchema: z.ZodObject<{
-    data: z.ZodArray<z.ZodObject<{
-        createdAt: z.ZodString;
-        deliveryCount: z.ZodNumber;
-        endpoint: z.ZodString;
-        environmentKind: z.ZodLiteral<"test">;
-        id: z.ZodString;
-        program: z.ZodObject<{
-            behavior: z.ZodEnum<{
+export declare const testSinkPageSchema: import("zod").ZodObject<{
+    data: import("zod").ZodArray<import("zod").ZodObject<{
+        createdAt: import("zod").ZodString;
+        deliveryCount: import("zod").ZodNumber;
+        endpoint: import("zod").ZodString;
+        environmentKind: import("zod").ZodLiteral<"test">;
+        id: import("zod").ZodString;
+        program: import("zod").ZodObject<{
+            behavior: import("zod").ZodEnum<{
                 rate_limited: "rate_limited";
                 success: "success";
                 server_error: "server_error";
@@ -560,12 +560,12 @@ export declare const testSinkPageSchema: z.ZodObject<{
                 invalid_signature: "invalid_signature";
                 timeout: "timeout";
             }>;
-            completionDelayMs: z.ZodOptional<z.ZodNumber>;
-            delayMs: z.ZodOptional<z.ZodNumber>;
-            forDeliveries: z.ZodOptional<z.ZodNumber>;
-            retryAfterSeconds: z.ZodOptional<z.ZodNumber>;
-            status: z.ZodOptional<z.ZodNumber>;
-            then: z.ZodOptional<z.ZodEnum<{
+            completionDelayMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+            delayMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+            forDeliveries: import("zod").ZodOptional<import("zod").ZodNumber>;
+            retryAfterSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+            status: import("zod").ZodOptional<import("zod").ZodNumber>;
+            then: import("zod").ZodOptional<import("zod").ZodEnum<{
                 rate_limited: "rate_limited";
                 success: "success";
                 server_error: "server_error";
@@ -579,25 +579,25 @@ export declare const testSinkPageSchema: z.ZodObject<{
                 invalid_signature: "invalid_signature";
                 timeout: "timeout";
             }>>;
-        }, z.core.$strip>;
-        project: z.ZodString;
-        updatedAt: z.ZodString;
-        url: z.ZodURL;
-    }, 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>;
+        }, import("zod/v4/core").$strip>;
+        project: import("zod").ZodString;
+        updatedAt: import("zod").ZodString;
+        url: import("zod").ZodURL;
+    }, 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 TestSinkPage = z.infer<typeof testSinkPageSchema>;
-export declare const testSinkCreateRequestSchema: z.ZodObject<{
-    endpoint: z.ZodString;
-    program: z.ZodOptional<z.ZodObject<{
-        behavior: z.ZodEnum<{
+export declare const testSinkCreateRequestSchema: import("zod").ZodObject<{
+    endpoint: import("zod").ZodString;
+    program: import("zod").ZodOptional<import("zod").ZodObject<{
+        behavior: import("zod").ZodEnum<{
             rate_limited: "rate_limited";
             success: "success";
             server_error: "server_error";
@@ -611,12 +611,12 @@ export declare const testSinkCreateRequestSchema: z.ZodObject<{
             invalid_signature: "invalid_signature";
             timeout: "timeout";
         }>;
-        completionDelayMs: z.ZodOptional<z.ZodNumber>;
-        delayMs: z.ZodOptional<z.ZodNumber>;
-        forDeliveries: z.ZodOptional<z.ZodNumber>;
-        retryAfterSeconds: z.ZodOptional<z.ZodNumber>;
-        status: z.ZodOptional<z.ZodNumber>;
-        then: z.ZodOptional<z.ZodEnum<{
+        completionDelayMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+        delayMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+        forDeliveries: import("zod").ZodOptional<import("zod").ZodNumber>;
+        retryAfterSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+        status: import("zod").ZodOptional<import("zod").ZodNumber>;
+        then: import("zod").ZodOptional<import("zod").ZodEnum<{
             rate_limited: "rate_limited";
             success: "success";
             server_error: "server_error";
@@ -630,8 +630,8 @@ export declare const testSinkCreateRequestSchema: z.ZodObject<{
             invalid_signature: "invalid_signature";
             timeout: "timeout";
         }>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>;
 export type TestSinkCreateRequest = z.infer<typeof testSinkCreateRequestSchema>;
 /**
  * One received delivery, as the sink recorded it.
@@ -640,8 +640,8 @@ export type TestSinkCreateRequest = z.infer<typeof testSinkCreateRequestSchema>;
  * what a *list* returns. The exact body is available only from the single-record
  * read, capped, and only in a test environment — see `testSinkDeliveryBodySchema`.
  */
-export declare const testSinkDeliverySchema: z.ZodObject<{
-    behavior: z.ZodEnum<{
+export declare const testSinkDeliverySchema: import("zod").ZodObject<{
+    behavior: import("zod").ZodEnum<{
         rate_limited: "rate_limited";
         success: "success";
         server_error: "server_error";
@@ -655,7 +655,7 @@ export declare const testSinkDeliverySchema: z.ZodObject<{
         invalid_signature: "invalid_signature";
         timeout: "timeout";
     }>;
-    disposition: z.ZodEnum<{
+    disposition: import("zod").ZodEnum<{
         duplicate: "duplicate";
         invalid_signature: "invalid_signature";
         body_too_large: "body_too_large";
@@ -668,19 +668,19 @@ export declare const testSinkDeliverySchema: z.ZodObject<{
         stale_timestamp: "stale_timestamp";
         connection_dropped: "connection_dropped";
     }>;
-    delivery: z.ZodString;
-    id: z.ZodString;
-    keyId: z.ZodOptional<z.ZodString>;
-    occurrenceId: z.ZodOptional<z.ZodString>;
-    receivedAt: z.ZodString;
-    respondedWith: z.ZodOptional<z.ZodNumber>;
-    scheduleId: z.ZodOptional<z.ZodString>;
-    sink: z.ZodString;
-}, z.core.$strip>;
+    delivery: import("zod").ZodString;
+    id: import("zod").ZodString;
+    keyId: import("zod").ZodOptional<import("zod").ZodString>;
+    occurrenceId: import("zod").ZodOptional<import("zod").ZodString>;
+    receivedAt: import("zod").ZodString;
+    respondedWith: import("zod").ZodOptional<import("zod").ZodNumber>;
+    scheduleId: import("zod").ZodOptional<import("zod").ZodString>;
+    sink: import("zod").ZodString;
+}, import("zod/v4/core").$strip>;
 export type TestSinkDelivery = z.infer<typeof testSinkDeliverySchema>;
-export declare const testSinkDeliveryPageSchema: z.ZodObject<{
-    data: z.ZodArray<z.ZodObject<{
-        behavior: z.ZodEnum<{
+export declare const testSinkDeliveryPageSchema: import("zod").ZodObject<{
+    data: import("zod").ZodArray<import("zod").ZodObject<{
+        behavior: import("zod").ZodEnum<{
             rate_limited: "rate_limited";
             success: "success";
             server_error: "server_error";
@@ -694,7 +694,7 @@ export declare const testSinkDeliveryPageSchema: z.ZodObject<{
             invalid_signature: "invalid_signature";
             timeout: "timeout";
         }>;
-        disposition: z.ZodEnum<{
+        disposition: import("zod").ZodEnum<{
             duplicate: "duplicate";
             invalid_signature: "invalid_signature";
             body_too_large: "body_too_large";
@@ -707,24 +707,24 @@ export declare const testSinkDeliveryPageSchema: z.ZodObject<{
             stale_timestamp: "stale_timestamp";
             connection_dropped: "connection_dropped";
         }>;
-        delivery: z.ZodString;
-        id: z.ZodString;
-        keyId: z.ZodOptional<z.ZodString>;
-        occurrenceId: z.ZodOptional<z.ZodString>;
-        receivedAt: z.ZodString;
-        respondedWith: z.ZodOptional<z.ZodNumber>;
-        scheduleId: z.ZodOptional<z.ZodString>;
-        sink: z.ZodString;
-    }, 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>;
+        delivery: import("zod").ZodString;
+        id: import("zod").ZodString;
+        keyId: import("zod").ZodOptional<import("zod").ZodString>;
+        occurrenceId: import("zod").ZodOptional<import("zod").ZodString>;
+        receivedAt: import("zod").ZodString;
+        respondedWith: import("zod").ZodOptional<import("zod").ZodNumber>;
+        scheduleId: import("zod").ZodOptional<import("zod").ZodString>;
+        sink: import("zod").ZodString;
+    }, 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 TestSinkDeliveryPage = z.infer<typeof testSinkDeliveryPageSchema>;
 /**
  * One received delivery including the bytes that arrived.
@@ -745,8 +745,8 @@ export type TestSinkDeliveryPage = z.infer<typeof testSinkDeliveryPageSchema>;
  * comparing it against a locally computed one is how a receiver author finds a
  * body-mutation bug; no signing key has a field anywhere in this file.
  */
-export declare const testSinkDeliveryBodySchema: z.ZodObject<{
-    behavior: z.ZodEnum<{
+export declare const testSinkDeliveryBodySchema: import("zod").ZodObject<{
+    behavior: import("zod").ZodEnum<{
         rate_limited: "rate_limited";
         success: "success";
         server_error: "server_error";
@@ -760,7 +760,7 @@ export declare const testSinkDeliveryBodySchema: z.ZodObject<{
         invalid_signature: "invalid_signature";
         timeout: "timeout";
     }>;
-    disposition: z.ZodEnum<{
+    disposition: import("zod").ZodEnum<{
         duplicate: "duplicate";
         invalid_signature: "invalid_signature";
         body_too_large: "body_too_large";
@@ -773,19 +773,19 @@ export declare const testSinkDeliveryBodySchema: z.ZodObject<{
         stale_timestamp: "stale_timestamp";
         connection_dropped: "connection_dropped";
     }>;
-    delivery: z.ZodString;
-    id: z.ZodString;
-    keyId: z.ZodOptional<z.ZodString>;
-    occurrenceId: z.ZodOptional<z.ZodString>;
-    receivedAt: z.ZodString;
-    respondedWith: z.ZodOptional<z.ZodNumber>;
-    scheduleId: z.ZodOptional<z.ZodString>;
-    sink: z.ZodString;
-    body: z.ZodString;
-    bodyTruncated: z.ZodBoolean;
-    receivedBytes: z.ZodNumber;
-    signature: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+    delivery: import("zod").ZodString;
+    id: import("zod").ZodString;
+    keyId: import("zod").ZodOptional<import("zod").ZodString>;
+    occurrenceId: import("zod").ZodOptional<import("zod").ZodString>;
+    receivedAt: import("zod").ZodString;
+    respondedWith: import("zod").ZodOptional<import("zod").ZodNumber>;
+    scheduleId: import("zod").ZodOptional<import("zod").ZodString>;
+    sink: import("zod").ZodString;
+    body: import("zod").ZodString;
+    bodyTruncated: import("zod").ZodBoolean;
+    receivedBytes: import("zod").ZodNumber;
+    signature: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>;
 export type TestSinkDeliveryBody = z.infer<typeof testSinkDeliveryBodySchema>;
 /**
  * Dated, and moved on 2026-08-23 because the sink gained the three deferring

package/dist/test-sink.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "./zod.js";
 import { CALLBACK_DEFERRAL_STATUS, CALLBACK_PENDING_DISCRIMINATOR, } from "./delivery.js";
 import { callbackSigningKeyIdSchema, deliveryIdSchema, endpointIdSchema, occurrenceIdSchema, projectIdSchema, scheduleIdSchema, testSinkDeliveryIdSchema, testSinkIdSchema, } from "./identifiers.js";
 import { CALLBACK_RECEIVER_MAX_BODY_BYTES } from "./callback-receiver.js";

package/dist/time.d.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-export declare const timestampSchema: z.ZodString;
+import { z } from "./zod.js";
+export declare const timestampSchema: import("zod").ZodString;
 export type Timestamp = z.infer<typeof timestampSchema>;
 /** Formats an instant in the one representation the wire accepts. */
 export declare function toTimestamp(instant: Date): Timestamp;
@@ -7,7 +7,7 @@ export declare function toTimestamp(instant: Date): Timestamp;
  * Durations are whole seconds, never strings. Bounds belong to the resource
  * that uses them; this only fixes the representation.
  */
-export declare const durationSecondsSchema: z.ZodNumber;
+export declare const durationSecondsSchema: import("zod").ZodNumber;
 export type DurationSeconds = z.infer<typeof durationSecondsSchema>;
 /**
  * An IANA timezone name, carried alongside a recurrence rather than encoded
@@ -41,5 +41,5 @@ export type DurationSeconds = z.infer<typeof durationSecondsSchema>;
  * `toTimestamp` for instants. Throws on a name the runtime does not know.
  */
 export declare function toTimeZone(value: string): string;
-export declare const timeZoneSchema: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+export declare const timeZoneSchema: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
 export type TimeZone = z.infer<typeof timeZoneSchema>;

package/dist/time.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "./zod.js";
 /**
  * Time on the wire.
  *

package/dist/timing.d.ts

@@ -0,0 +1,65 @@
+import { z } from "./zod.js";
+export declare const DELIVERY_TIMING_TARGETS_MS: readonly [5000, 15000];
+export declare const DELIVERY_TIMING_VERDICTS: readonly ["met", "missed", "unknown"];
+export declare const timingThresholdSummarySchema: import("zod").ZodObject<{
+    breachCount: import("zod").ZodInt;
+    customerBlockedCount: import("zod").ZodInt;
+    eligibleOutstandingBreachCount: import("zod").ZodInt;
+    maturedCount: import("zod").ZodInt;
+    targetMs: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<5000>, import("zod").ZodLiteral<15000>]>;
+    verdict: import("zod").ZodEnum<{
+        unknown: "unknown";
+        met: "met";
+        missed: "missed";
+    }>;
+    withinTargetCount: import("zod").ZodInt;
+}, import("zod/v4/core").$strip>;
+export type TimingThresholdView = z.infer<typeof timingThresholdSummarySchema>;
+/**
+ * Exact rolling 24-hour due-time cohort for one project and timing policy.
+ *
+ * Counts include eligible work that has not fired, so successful deliveries
+ * alone cannot manufacture a healthy verdict. Percentiles describe delivered
+ * samples only and remain separate from the exact threshold counters.
+ */
+export declare const deliveryTimingSummarySchema: import("zod").ZodObject<{
+    customerBlockedCount: import("zod").ZodInt;
+    deliveredSampleCount: import("zod").ZodInt;
+    freshness: import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"authoritative">;
+    }, import("zod/v4/core").$strip>;
+    missingEvidenceCount: import("zod").ZodInt;
+    p95LatenessMs: import("zod").ZodOptional<import("zod").ZodInt>;
+    p99LatenessMs: import("zod").ZodOptional<import("zod").ZodInt>;
+    platformBlockedCount: import("zod").ZodInt;
+    policyVersion: import("zod").ZodString;
+    skippedCount: import("zod").ZodInt;
+    targets: import("zod").ZodTuple<[import("zod").ZodObject<{
+        breachCount: import("zod").ZodInt;
+        customerBlockedCount: import("zod").ZodInt;
+        eligibleOutstandingBreachCount: import("zod").ZodInt;
+        maturedCount: import("zod").ZodInt;
+        targetMs: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<5000>, import("zod").ZodLiteral<15000>]>;
+        verdict: import("zod").ZodEnum<{
+            unknown: "unknown";
+            met: "met";
+            missed: "missed";
+        }>;
+        withinTargetCount: import("zod").ZodInt;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        breachCount: import("zod").ZodInt;
+        customerBlockedCount: import("zod").ZodInt;
+        eligibleOutstandingBreachCount: import("zod").ZodInt;
+        maturedCount: import("zod").ZodInt;
+        targetMs: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<5000>, import("zod").ZodLiteral<15000>]>;
+        verdict: import("zod").ZodEnum<{
+            unknown: "unknown";
+            met: "met";
+            missed: "missed";
+        }>;
+        withinTargetCount: import("zod").ZodInt;
+    }, import("zod/v4/core").$strip>], null>;
+    windowEnd: import("zod").ZodString;
+    windowStart: import("zod").ZodString;
+}, import("zod/v4/core").$strip>;
+export type DeliveryTimingSummaryView = z.infer<typeof deliveryTimingSummarySchema>;

package/dist/timing.js

@@ -0,0 +1,82 @@
+import { z } from "./zod.js";
+import { timestampSchema } from "./time.js";
+export const DELIVERY_TIMING_TARGETS_MS = [5_000, 15_000];
+export const DELIVERY_TIMING_VERDICTS = ["met", "missed", "unknown"];
+const integerSchema = z.int();
+const countSchema = integerSchema.nonnegative();
+export const timingThresholdSummarySchema = z
+    .object({
+    breachCount: countSchema,
+    customerBlockedCount: countSchema,
+    eligibleOutstandingBreachCount: countSchema,
+    maturedCount: countSchema,
+    targetMs: z.union([z.literal(5_000), z.literal(15_000)]),
+    verdict: z.enum(DELIVERY_TIMING_VERDICTS),
+    withinTargetCount: countSchema,
+})
+    .superRefine((value, context) => {
+    const within = BigInt(value.withinTargetCount);
+    const breaches = BigInt(value.breachCount);
+    const matured = BigInt(value.maturedCount);
+    if (within + breaches !== matured) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "within-target and breach counts must equal the matured count",
+        });
+    }
+    if (value.eligibleOutstandingBreachCount > value.breachCount) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "outstanding eligible breaches must be part of the breach count",
+        });
+    }
+    if (value.maturedCount === 0 && value.verdict !== "unknown") {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "a threshold with no matured samples has an unknown verdict",
+        });
+    }
+    const requiredPercentage = value.targetMs === 5_000 ? 95n : 99n;
+    const expectedVerdict = matured === 0n
+        ? "unknown"
+        : within * 100n >= matured * requiredPercentage
+            ? "met"
+            : "missed";
+    if (value.verdict !== expectedVerdict) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `${String(value.targetMs)}ms verdict must match its exact threshold counts`,
+        });
+    }
+});
+/**
+ * Exact rolling 24-hour due-time cohort for one project and timing policy.
+ *
+ * Counts include eligible work that has not fired, so successful deliveries
+ * alone cannot manufacture a healthy verdict. Percentiles describe delivered
+ * samples only and remain separate from the exact threshold counters.
+ */
+export const deliveryTimingSummarySchema = z.object({
+    customerBlockedCount: countSchema,
+    deliveredSampleCount: countSchema,
+    freshness: z.object({ kind: z.literal("authoritative") }),
+    missingEvidenceCount: countSchema,
+    p95LatenessMs: integerSchema.optional(),
+    p99LatenessMs: integerSchema.optional(),
+    platformBlockedCount: countSchema,
+    policyVersion: z.string().min(1).max(64),
+    skippedCount: countSchema,
+    targets: z
+        .tuple([timingThresholdSummarySchema, timingThresholdSummarySchema])
+        .superRefine((targets, context) => {
+        if (targets[0].targetMs !== DELIVERY_TIMING_TARGETS_MS[0] ||
+            targets[1].targetMs !== DELIVERY_TIMING_TARGETS_MS[1]) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "targets must be the pinned 5000ms and 15000ms thresholds",
+            });
+        }
+    }),
+    windowEnd: timestampSchema,
+    windowStart: timestampSchema,
+});