@greatwait/contracts 0.1.0-alpha.1

package/dist/scheduling-records.d.ts

@@ -0,0 +1,395 @@
+import { z } from "zod";
+export declare const portableScheduleRecordSchema: z.ZodObject<{
+    authority: z.ZodObject<{
+        environment: z.ZodString;
+        environmentKind: z.ZodEnum<{
+            test: "test";
+            live: "live";
+        }>;
+        organization: z.ZodString;
+        project: z.ZodString;
+    }, z.core.$strict>;
+    retentionClass: z.ZodString;
+    archivedAt: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    delivery: z.ZodOptional<z.ZodObject<{
+        completion: z.ZodEnum<{
+            response: "response";
+            callback: "callback";
+        }>;
+        maxDurationSeconds: z.ZodNumber;
+        onOverlap: z.ZodEnum<{
+            skip: "skip";
+            queue: "queue";
+        }>;
+    }, z.core.$strip>>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    generation: z.ZodNumber;
+    id: z.ZodString;
+    latencyClass: z.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";
+        active: "active";
+        cancelled: "cancelled";
+        completed: "completed";
+    }>;
+    updatedAt: z.ZodString;
+    version: z.ZodNumber;
+}, z.core.$strict>;
+export type PortableScheduleRecord = z.infer<typeof portableScheduleRecordSchema>;
+export declare const portableReceiptRecordSchema: z.ZodObject<{
+    attempt: z.ZodOptional<z.ZodString>;
+    authority: z.ZodObject<{
+        environment: z.ZodString;
+        environmentKind: z.ZodEnum<{
+            test: "test";
+            live: "live";
+        }>;
+        organization: z.ZodString;
+        project: z.ZodString;
+    }, z.core.$strict>;
+    expiresAt: z.ZodString;
+    idempotencyKey: z.ZodString;
+    operation: z.ZodEnum<{
+        "schedules.create": "schedules.create";
+        "occurrences.redeliver": "occurrences.redeliver";
+        "schedules.replace": "schedules.replace";
+    }>;
+    requestFingerprint: z.ZodString;
+    schedule: z.ZodString;
+    storedAt: z.ZodString;
+}, z.core.$strict>;
+export type PortableReceiptRecord = z.infer<typeof portableReceiptRecordSchema>;
+export declare const portableOccurrenceRecordSchema: 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<{
+        succeeded: "succeeded";
+        ambiguous: "ambiguous";
+        cancelled: "cancelled";
+        planned: "planned";
+        due: "due";
+        dispatching: "dispatching";
+        retry_wait: "retry_wait";
+        terminal_failed: "terminal_failed";
+        skipped_stale: "skipped_stale";
+    }>;
+    authority: z.ZodObject<{
+        environment: z.ZodString;
+        environmentKind: z.ZodEnum<{
+            test: "test";
+            live: "live";
+        }>;
+        organization: z.ZodString;
+        project: z.ZodString;
+    }, z.core.$strict>;
+    createdAt: z.ZodString;
+    retentionDueAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodString;
+}, z.core.$strict>;
+export type PortableOccurrenceRecord = z.infer<typeof portableOccurrenceRecordSchema>;
+export declare const portableAttemptRecordSchema: 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<{
+        none: "none";
+        review_retry_policy: "review_retry_policy";
+        inspect_receiver: "inspect_receiver";
+        verify_endpoint: "verify_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<{
+        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">;
+    authority: z.ZodObject<{
+        environment: z.ZodString;
+        environmentKind: z.ZodEnum<{
+            test: "test";
+            live: "live";
+        }>;
+        organization: z.ZodString;
+        project: z.ZodString;
+    }, z.core.$strict>;
+    dispatchEpoch: z.ZodNumber;
+    schedule: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strict>;
+export type PortableAttemptRecord = z.infer<typeof portableAttemptRecordSchema>;
+export declare const portableEncryptedPayloadRecordSchema: z.ZodObject<{
+    aadVersion: z.ZodLiteral<"greatwait.schedule-payload.v1">;
+    authority: z.ZodObject<{
+        environment: z.ZodString;
+        environmentKind: z.ZodEnum<{
+            test: "test";
+            live: "live";
+        }>;
+        organization: z.ZodString;
+        project: z.ZodString;
+    }, z.core.$strict>;
+    envelope: z.ZodObject<{
+        ciphertext: z.ZodString;
+        keyId: z.ZodString;
+        nonce: z.ZodString;
+    }, z.core.$strict>;
+    plaintextBytes: z.ZodNumber;
+    retentionDueAt: z.ZodOptional<z.ZodString>;
+    schedule: z.ZodString;
+    sealedAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strict>;
+export type PortableEncryptedPayloadRecord = z.infer<typeof portableEncryptedPayloadRecordSchema>;
+export declare const portableSchedulingRecordSetSchema: z.ZodObject<{
+    attempts: 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<{
+            none: "none";
+            review_retry_policy: "review_retry_policy";
+            inspect_receiver: "inspect_receiver";
+            verify_endpoint: "verify_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<{
+            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">;
+        authority: z.ZodObject<{
+            environment: z.ZodString;
+            environmentKind: z.ZodEnum<{
+                test: "test";
+                live: "live";
+            }>;
+            organization: z.ZodString;
+            project: z.ZodString;
+        }, z.core.$strict>;
+        dispatchEpoch: z.ZodNumber;
+        schedule: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>>;
+    occurrences: 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<{
+            succeeded: "succeeded";
+            ambiguous: "ambiguous";
+            cancelled: "cancelled";
+            planned: "planned";
+            due: "due";
+            dispatching: "dispatching";
+            retry_wait: "retry_wait";
+            terminal_failed: "terminal_failed";
+            skipped_stale: "skipped_stale";
+        }>;
+        authority: z.ZodObject<{
+            environment: z.ZodString;
+            environmentKind: z.ZodEnum<{
+                test: "test";
+                live: "live";
+            }>;
+            organization: z.ZodString;
+            project: z.ZodString;
+        }, z.core.$strict>;
+        createdAt: z.ZodString;
+        retentionDueAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>>;
+    payload: z.ZodOptional<z.ZodObject<{
+        aadVersion: z.ZodLiteral<"greatwait.schedule-payload.v1">;
+        authority: z.ZodObject<{
+            environment: z.ZodString;
+            environmentKind: z.ZodEnum<{
+                test: "test";
+                live: "live";
+            }>;
+            organization: z.ZodString;
+            project: z.ZodString;
+        }, z.core.$strict>;
+        envelope: z.ZodObject<{
+            ciphertext: z.ZodString;
+            keyId: z.ZodString;
+            nonce: z.ZodString;
+        }, z.core.$strict>;
+        plaintextBytes: z.ZodNumber;
+        retentionDueAt: z.ZodOptional<z.ZodString>;
+        schedule: z.ZodString;
+        sealedAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>>;
+    receipts: z.ZodArray<z.ZodObject<{
+        attempt: z.ZodOptional<z.ZodString>;
+        authority: z.ZodObject<{
+            environment: z.ZodString;
+            environmentKind: z.ZodEnum<{
+                test: "test";
+                live: "live";
+            }>;
+            organization: z.ZodString;
+            project: z.ZodString;
+        }, z.core.$strict>;
+        expiresAt: z.ZodString;
+        idempotencyKey: z.ZodString;
+        operation: z.ZodEnum<{
+            "schedules.create": "schedules.create";
+            "occurrences.redeliver": "occurrences.redeliver";
+            "schedules.replace": "schedules.replace";
+        }>;
+        requestFingerprint: z.ZodString;
+        schedule: z.ZodString;
+        storedAt: z.ZodString;
+    }, z.core.$strict>>;
+    schedule: z.ZodObject<{
+        authority: z.ZodObject<{
+            environment: z.ZodString;
+            environmentKind: z.ZodEnum<{
+                test: "test";
+                live: "live";
+            }>;
+            organization: z.ZodString;
+            project: z.ZodString;
+        }, z.core.$strict>;
+        retentionClass: z.ZodString;
+        archivedAt: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodString;
+        delivery: z.ZodOptional<z.ZodObject<{
+            completion: z.ZodEnum<{
+                response: "response";
+                callback: "callback";
+            }>;
+            maxDurationSeconds: z.ZodNumber;
+            onOverlap: z.ZodEnum<{
+                skip: "skip";
+                queue: "queue";
+            }>;
+        }, z.core.$strip>>;
+        endpoint: z.ZodOptional<z.ZodString>;
+        generation: z.ZodNumber;
+        id: z.ZodString;
+        latencyClass: z.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";
+            active: "active";
+            cancelled: "cancelled";
+            completed: "completed";
+        }>;
+        updatedAt: z.ZodString;
+        version: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type PortableSchedulingRecordSet = z.infer<typeof portableSchedulingRecordSetSchema>;

package/dist/scheduling-records.js

@@ -0,0 +1,284 @@
+import { z } from "zod";
+import { authoritySchema } from "./authority.js";
+import { SCHEDULE_PAYLOAD_AAD_VERSION } from "./delivery.js";
+import { attemptIdSchema, scheduleIdSchema } from "./identifiers.js";
+import { SCHEDULING_BOUNDS, attemptSchema, isTerminalOccurrenceState, occurrenceSchema, scheduleSchema, } from "./scheduling.js";
+import { timestampSchema } from "./time.js";
+/** Backend-neutral scheduling records frozen before PostgreSQL onboarding. */
+const portableAuthoritySchema = z.strictObject(authoritySchema.shape);
+const retentionClassSchema = z
+    .string()
+    .regex(/^[a-z][a-z0-9_-]{0,63}$/u, "must be a bounded lower-case retention class");
+export const portableScheduleRecordSchema = z
+    .strictObject({
+    ...scheduleSchema.shape,
+    authority: portableAuthoritySchema,
+    retentionClass: retentionClassSchema,
+})
+    .superRefine((schedule, context) => {
+    requireAtOrAfter(schedule.updatedAt, schedule.createdAt, "updatedAt must not precede createdAt", ["updatedAt"], context);
+    if (schedule.archivedAt !== undefined) {
+        if (schedule.status !== "cancelled" && schedule.status !== "completed") {
+            context.addIssue({
+                code: "custom",
+                message: "archivedAt is allowed only on a terminal schedule",
+                path: ["archivedAt"],
+            });
+        }
+        requireAtOrAfter(schedule.archivedAt, schedule.createdAt, "archivedAt must not precede createdAt", ["archivedAt"], context);
+    }
+});
+export const portableReceiptRecordSchema = z
+    .strictObject({
+    attempt: attemptIdSchema.optional(),
+    authority: portableAuthoritySchema,
+    expiresAt: timestampSchema,
+    idempotencyKey: z.string().min(1).max(255),
+    operation: z.enum([
+        "occurrences.redeliver",
+        "schedules.create",
+        "schedules.replace",
+    ]),
+    requestFingerprint: z
+        .string()
+        .regex(/^[0-9a-f]{64}$/u, "must be a lower-case SHA-256 digest"),
+    schedule: scheduleIdSchema,
+    storedAt: timestampSchema,
+})
+    .superRefine((receipt, context) => {
+    requireAfter(receipt.expiresAt, receipt.storedAt, "expiresAt must follow storedAt", ["expiresAt"], context);
+    if (receipt.operation === "occurrences.redeliver" &&
+        receipt.attempt === undefined) {
+        context.addIssue({
+            code: "custom",
+            message: "a redelivery receipt must name the attempt it minted",
+            path: ["attempt"],
+        });
+    }
+    if (receipt.operation !== "occurrences.redeliver" &&
+        receipt.attempt !== undefined) {
+        context.addIssue({
+            code: "custom",
+            message: "only a redelivery receipt may name an attempt",
+            path: ["attempt"],
+        });
+    }
+});
+export const portableOccurrenceRecordSchema = occurrenceSchema
+    .safeExtend({
+    authority: portableAuthoritySchema,
+    createdAt: timestampSchema,
+    retentionDueAt: timestampSchema.optional(),
+    updatedAt: timestampSchema,
+})
+    .strict()
+    .superRefine((occurrence, context) => {
+    requireAtOrAfter(occurrence.updatedAt, occurrence.createdAt, "updatedAt must not precede createdAt", ["updatedAt"], context);
+    if (isTerminalOccurrenceState(occurrence.state) !==
+        (occurrence.retentionDueAt !== undefined)) {
+        context.addIssue({
+            code: "custom",
+            message: "retentionDueAt must be present for a terminal state and absent otherwise",
+            path: ["retentionDueAt"],
+        });
+    }
+    if (occurrence.settledAt !== undefined) {
+        requireAtOrAfter(occurrence.settledAt, occurrence.plannedFor, "settledAt must not precede plannedFor", ["settledAt"], context);
+    }
+    if (occurrence.retentionDueAt !== undefined &&
+        occurrence.settledAt !== undefined) {
+        requireAtOrAfter(occurrence.retentionDueAt, occurrence.settledAt, "retentionDueAt must not precede settledAt", ["retentionDueAt"], context);
+    }
+});
+export const portableAttemptRecordSchema = attemptSchema
+    .safeExtend({
+    authority: portableAuthoritySchema,
+    dispatchEpoch: z.number().int().positive(),
+    schedule: scheduleIdSchema,
+    updatedAt: timestampSchema,
+})
+    .strict()
+    .superRefine((attempt, context) => {
+    requireAtOrAfter(attempt.updatedAt, attempt.startedAt, "updatedAt must not precede startedAt", ["updatedAt"], context);
+    if (attempt.classifiedAt !== undefined) {
+        requireAtOrAfter(attempt.classifiedAt, attempt.startedAt, "classifiedAt must not precede startedAt", ["classifiedAt"], context);
+    }
+});
+const base64UrlBytesSchema = z
+    .string()
+    .min(1)
+    .regex(/^[A-Za-z0-9_-]+$/u, "must be unpadded base64url")
+    .refine((value) => decodeBase64UrlBytes(value) !== undefined, {
+    message: "must canonically encode base64url bytes",
+});
+export const portableEncryptedPayloadRecordSchema = z
+    .strictObject({
+    aadVersion: z.literal(SCHEDULE_PAYLOAD_AAD_VERSION),
+    authority: portableAuthoritySchema,
+    envelope: z.strictObject({
+        ciphertext: base64UrlBytesSchema,
+        keyId: z
+            .string()
+            .min(1)
+            .max(128)
+            .regex(/^[A-Za-z0-9._:-]+$/u, "must be a safe key identifier"),
+        nonce: base64UrlBytesSchema.refine((value) => decodeBase64UrlBytes(value)?.length === 12, { message: "must encode exactly 12 bytes" }),
+    }),
+    plaintextBytes: z
+        .number()
+        .int()
+        .nonnegative()
+        .max(SCHEDULING_BOUNDS.payloadBytes),
+    retentionDueAt: timestampSchema.optional(),
+    schedule: scheduleIdSchema,
+    sealedAt: timestampSchema,
+    updatedAt: timestampSchema,
+})
+    .superRefine((payload, context) => {
+    const ciphertext = decodeBase64UrlBytes(payload.envelope.ciphertext);
+    if (ciphertext !== undefined &&
+        ciphertext.length !== payload.plaintextBytes + 16) {
+        context.addIssue({
+            code: "custom",
+            message: "ciphertext must contain the plaintext bytes and a 16-byte AES-GCM tag",
+            path: ["envelope", "ciphertext"],
+        });
+    }
+    requireAtOrAfter(payload.updatedAt, payload.sealedAt, "updatedAt must not precede sealedAt", ["updatedAt"], context);
+    if (payload.retentionDueAt !== undefined) {
+        requireAtOrAfter(payload.retentionDueAt, payload.sealedAt, "retentionDueAt must not precede sealedAt", ["retentionDueAt"], context);
+    }
+});
+export const portableSchedulingRecordSetSchema = z
+    .strictObject({
+    attempts: z.array(portableAttemptRecordSchema),
+    occurrences: z.array(portableOccurrenceRecordSchema),
+    payload: portableEncryptedPayloadRecordSchema.optional(),
+    receipts: z.array(portableReceiptRecordSchema),
+    schedule: portableScheduleRecordSchema,
+})
+    .superRefine((records, context) => {
+    const authority = authorityKey(records.schedule.authority);
+    const occurrenceIds = new Set(records.occurrences.map((item) => item.id));
+    const attemptIds = new Set(records.attempts.map((item) => item.id));
+    const attemptsById = new Map(records.attempts.map((item) => [item.id, item]));
+    checkUnique(records.occurrences.map((item) => item.id), "occurrence identity", ["occurrences"], context);
+    checkUnique(records.occurrences.map((item) => `${item.schedule}:${String(item.generation)}:${String(item.sequence)}`), "schedule/generation/sequence", ["occurrences"], context);
+    checkUnique(records.attempts.map((item) => item.id), "attempt identity", ["attempts"], context);
+    checkUnique(records.attempts.map((item) => item.delivery), "delivery identity", ["attempts"], context);
+    checkUnique(records.attempts.map((item) => `${item.occurrence}:${String(item.attemptNumber)}`), "occurrence/attempt number", ["attempts"], context);
+    checkUnique(records.receipts.map((item) => `${item.operation}:${item.idempotencyKey}`), "operation/idempotency key", ["receipts"], context);
+    for (const [index, item] of records.occurrences.entries()) {
+        requireAuthority(authority, item.authority, ["occurrences", index], context);
+        if (item.schedule !== records.schedule.id) {
+            addIdentityIssue("occurrence names another schedule", ["occurrences", index, "schedule"], context);
+        }
+        if (item.generation > records.schedule.generation) {
+            addIdentityIssue("occurrence generation is newer than its schedule", ["occurrences", index, "generation"], context);
+        }
+        const attemptNumbers = records.attempts
+            .filter((attempt) => attempt.occurrence === item.id)
+            .map((attempt) => attempt.attemptNumber)
+            .sort((left, right) => left - right);
+        if (attemptNumbers.length !== item.attemptCount) {
+            addIdentityIssue("occurrence attemptCount differs from its retained attempts", ["occurrences", index, "attemptCount"], context);
+        }
+        if (attemptNumbers.some((attemptNumber, attemptIndex) => attemptNumber !== attemptIndex + 1)) {
+            addIdentityIssue("occurrence attempts must be numbered contiguously from one", ["occurrences", index, "attemptCount"], context);
+        }
+    }
+    for (const [index, item] of records.attempts.entries()) {
+        requireAuthority(authority, item.authority, ["attempts", index], context);
+        if (item.schedule !== records.schedule.id) {
+            addIdentityIssue("attempt names another schedule", ["attempts", index, "schedule"], context);
+        }
+        if (!occurrenceIds.has(item.occurrence)) {
+            addIdentityIssue("attempt names an occurrence outside this record set", ["attempts", index, "occurrence"], context);
+        }
+        if (item.trigger.kind === "redelivery") {
+            const source = attemptsById.get(item.trigger.sourceAttemptId);
+            if (source === undefined) {
+                addIdentityIssue("redelivery trigger names an attempt outside this record set", ["attempts", index, "trigger", "sourceAttemptId"], context);
+            }
+            else if (source.occurrence !== item.occurrence) {
+                addIdentityIssue("redelivery trigger names an attempt from another occurrence", ["attempts", index, "trigger", "sourceAttemptId"], context);
+            }
+        }
+    }
+    for (const [index, item] of records.receipts.entries()) {
+        requireAuthority(authority, item.authority, ["receipts", index], context);
+        if (item.schedule !== records.schedule.id) {
+            addIdentityIssue("receipt names another schedule", ["receipts", index, "schedule"], context);
+        }
+        if (item.attempt !== undefined && !attemptIds.has(item.attempt)) {
+            addIdentityIssue("receipt names an attempt outside this record set", ["receipts", index, "attempt"], context);
+        }
+        if (item.operation === "occurrences.redeliver") {
+            const minted = item.attempt === undefined
+                ? undefined
+                : attemptsById.get(item.attempt);
+            if (minted !== undefined && minted.trigger.kind !== "redelivery") {
+                addIdentityIssue("redelivery receipt must name the redelivery attempt it minted", ["receipts", index, "attempt"], context);
+            }
+        }
+    }
+    if (records.payload !== undefined) {
+        requireAuthority(authority, records.payload.authority, ["payload"], context);
+        if (records.payload.schedule !== records.schedule.id) {
+            addIdentityIssue("payload names another schedule", ["payload", "schedule"], context);
+        }
+    }
+});
+function decodeBase64UrlBytes(value) {
+    if (value.length === 0 || !/^[A-Za-z0-9_-]+$/u.test(value)) {
+        return undefined;
+    }
+    const remainder = value.length % 4;
+    if (remainder === 1)
+        return undefined;
+    const padding = remainder === 0 ? "" : "=".repeat(4 - remainder);
+    try {
+        const binary = atob(value.replace(/-/gu, "+").replace(/_/gu, "/") + padding);
+        const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+        let encoded = "";
+        for (const byte of bytes)
+            encoded += String.fromCharCode(byte);
+        encoded = btoa(encoded)
+            .replace(/\+/gu, "-")
+            .replace(/\//gu, "_")
+            .replace(/=+$/u, "");
+        return encoded === value ? bytes : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function authorityKey(authority) {
+    return [
+        authority.organization,
+        authority.project,
+        authority.environment,
+        authority.environmentKind,
+    ].join(":");
+}
+function requireAuthority(expected, actual, path, context) {
+    if (authorityKey(actual) !== expected) {
+        addIdentityIssue("record authority differs from its schedule", path, context);
+    }
+}
+function checkUnique(values, name, path, context) {
+    if (new Set(values).size !== values.length) {
+        addIdentityIssue(`duplicate ${name}`, path, context);
+    }
+}
+function addIdentityIssue(message, path, context) {
+    context.addIssue({ code: "custom", message, path });
+}
+function requireAfter(actual, boundary, message, path, context) {
+    if (actual <= boundary)
+        addIdentityIssue(message, path, context);
+}
+function requireAtOrAfter(actual, boundary, message, path, context) {
+    if (actual < boundary)
+        addIdentityIssue(message, path, context);
+}