@greatwait/contracts 0.2.3 → 0.3.1

package/dist/attempt-search.d.ts

@@ -0,0 +1,235 @@
+import { z } from "./zod.js";
+import { type CursorBinding } from "./protocol.js";
+import type { FieldError } from "./problems.js";
+/** Actual attempt start, never occurrence planned time. Boundaries are [start, end). */
+export declare const projectAttemptSearchRequestSchema: import("zod").ZodObject<{
+    cursor: import("zod").ZodOptional<import("zod").ZodString>;
+    limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+    startedFrom: import("zod").ZodString;
+    startedBefore: import("zod").ZodString;
+    responseStatus: import("zod").ZodOptional<import("zod").ZodNumber>;
+    statusClass: import("zod").ZodOptional<import("zod").ZodEnum<{
+        "1xx": "1xx";
+        "2xx": "2xx";
+        "3xx": "3xx";
+        "4xx": "4xx";
+        "5xx": "5xx";
+    }>>;
+    outcome: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+        ambiguous: "ambiguous";
+        succeeded: "succeeded";
+        retryable_failure: "retryable_failure";
+        terminal_failure: "terminal_failure";
+    }>, import("zod").ZodLiteral<"in_flight">]>>;
+    diagnostic: import("zod").ZodOptional<import("zod").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";
+    }>>;
+    endpoint: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<"none">]>>;
+    schedule: import("zod").ZodOptional<import("zod").ZodString>;
+    external_identifier: import("zod").ZodOptional<import("zod").ZodString>;
+    tag: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>;
+export type ProjectAttemptSearchRequest = z.infer<typeof projectAttemptSearchRequestSchema>;
+export type NormalizedAttemptSelection = {
+    readonly startedFrom: string;
+    readonly startedBefore: string;
+} & {
+    readonly [Key in Exclude<keyof ProjectAttemptSearchRequest, "cursor" | "limit" | "startedFrom" | "startedBefore">]?: Exclude<ProjectAttemptSearchRequest[Key], undefined>;
+};
+export declare function normalizeAttemptSelection(request: ProjectAttemptSearchRequest): NormalizedAttemptSelection;
+export declare function projectAttemptCursorBinding(request: ProjectAttemptSearchRequest): CursorBinding;
+export declare function parseProjectAttemptSearchRequest(query: URLSearchParams): {
+    readonly ok: true;
+    readonly page: ProjectAttemptSearchRequest;
+} | {
+    readonly ok: false;
+    readonly errors: readonly FieldError[];
+};
+/** Safe search summary: content and secret-bearing HTTP evidence is detail-only. */
+export declare const projectAttemptSearchResultSchema: import("zod").ZodObject<{
+    attempt: import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        attemptNumber: import("zod").ZodNumber;
+        occurrence: import("zod").ZodString;
+        startedAt: import("zod").ZodString;
+        state: import("zod").ZodOptional<import("zod").ZodEnum<{
+            ambiguous: "ambiguous";
+            succeeded: "succeeded";
+            retryable_failure: "retryable_failure";
+            terminal_failure: "terminal_failure";
+        }>>;
+        classifiedAt: import("zod").ZodOptional<import("zod").ZodString>;
+        durationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+        responseStatus: import("zod").ZodOptional<import("zod").ZodNumber>;
+        diagnostic: import("zod").ZodOptional<import("zod").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";
+        }>>;
+        remediation: import("zod").ZodOptional<import("zod").ZodEnum<{
+            none: "none";
+            review_retry_policy: "review_retry_policy";
+            inspect_receiver: "inspect_receiver";
+            review_endpoint: "review_endpoint";
+            replace_payload: "replace_payload";
+            contact_support: "contact_support";
+            review_before_redelivery: "review_before_redelivery";
+        }>>;
+        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">;
+    }, 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<{
+            planned: "planned";
+            due: "due";
+            dispatching: "dispatching";
+            retry_wait: "retry_wait";
+            ambiguous: "ambiguous";
+            succeeded: "succeeded";
+            terminal_failed: "terminal_failed";
+            cancelled: "cancelled";
+            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>;
+    schedule: import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        endpoint: import("zod").ZodOptional<import("zod").ZodString>;
+        external_identifier: import("zod").ZodOptional<import("zod").ZodString>;
+        tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>;
+export type ProjectAttemptSearchResult = z.infer<typeof projectAttemptSearchResultSchema>;
+export declare const projectAttemptPageSchema: import("zod").ZodObject<{
+    data: import("zod").ZodArray<import("zod").ZodObject<{
+        attempt: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            attemptNumber: import("zod").ZodNumber;
+            occurrence: import("zod").ZodString;
+            startedAt: import("zod").ZodString;
+            state: import("zod").ZodOptional<import("zod").ZodEnum<{
+                ambiguous: "ambiguous";
+                succeeded: "succeeded";
+                retryable_failure: "retryable_failure";
+                terminal_failure: "terminal_failure";
+            }>>;
+            classifiedAt: import("zod").ZodOptional<import("zod").ZodString>;
+            durationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+            responseStatus: import("zod").ZodOptional<import("zod").ZodNumber>;
+            diagnostic: import("zod").ZodOptional<import("zod").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";
+            }>>;
+            remediation: import("zod").ZodOptional<import("zod").ZodEnum<{
+                none: "none";
+                review_retry_policy: "review_retry_policy";
+                inspect_receiver: "inspect_receiver";
+                review_endpoint: "review_endpoint";
+                replace_payload: "replace_payload";
+                contact_support: "contact_support";
+                review_before_redelivery: "review_before_redelivery";
+            }>>;
+            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">;
+        }, 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<{
+                planned: "planned";
+                due: "due";
+                dispatching: "dispatching";
+                retry_wait: "retry_wait";
+                ambiguous: "ambiguous";
+                succeeded: "succeeded";
+                terminal_failed: "terminal_failed";
+                cancelled: "cancelled";
+                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>;
+        schedule: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+            endpoint: import("zod").ZodOptional<import("zod").ZodString>;
+            external_identifier: import("zod").ZodOptional<import("zod").ZodString>;
+            tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strip>;
+    }, 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;
+        detailsFrom: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>;
+export type ProjectAttemptPage = z.infer<typeof projectAttemptPageSchema>;

package/dist/attempt-search.js

@@ -0,0 +1,101 @@
+import { z } from "./zod.js";
+import { pageRequestSchema, pageSchema } from "./protocol.js";
+import { endpointIdSchema, scheduleIdSchema } from "./identifiers.js";
+import { externalIdentifierSchema, scheduleTagSchema, scheduleTagsSchema, } from "./host-correlation.js";
+import { timestampSchema } from "./time.js";
+import { attemptSearchSummaryShape, attemptStateSchema, attemptDiagnosticSchema, occurrenceSchema, scheduleNameSchema, } from "./scheduling.js";
+/** Actual attempt start, never occurrence planned time. Boundaries are [start, end). */
+export const projectAttemptSearchRequestSchema = /* @__PURE__ */ (() => pageRequestSchema
+    .extend({
+    startedFrom: timestampSchema,
+    startedBefore: timestampSchema,
+    responseStatus: z.number().int().min(100).max(599).optional(),
+    statusClass: z.enum(["1xx", "2xx", "3xx", "4xx", "5xx"]).optional(),
+    outcome: z.union([attemptStateSchema, z.literal("in_flight")]).optional(),
+    diagnostic: attemptDiagnosticSchema.optional(),
+    endpoint: z.union([endpointIdSchema, z.literal("none")]).optional(),
+    schedule: scheduleIdSchema.optional(),
+    external_identifier: externalIdentifierSchema.optional(),
+    tag: scheduleTagSchema.optional(),
+})
+    .refine((value) => Date.parse(value.startedFrom) < Date.parse(value.startedBefore), {
+    message: "must be later than startedFrom",
+    path: ["startedBefore"],
+}))();
+export function normalizeAttemptSelection(request) {
+    return Object.fromEntries(Object.entries(request).filter(([key, value]) => key !== "cursor" && key !== "limit" && value !== undefined));
+}
+export function projectAttemptCursorBinding(request) {
+    return {
+        operation: "attempts.search",
+        parameters: Object.fromEntries(Object.entries(normalizeAttemptSelection(request)).map(([key, value]) => [
+            key,
+            String(value),
+        ])),
+    };
+}
+export function parseProjectAttemptSearchRequest(query) {
+    const raw = {};
+    const errors = [];
+    for (const field of Object.keys(projectAttemptSearchRequestSchema.shape)) {
+        const values = query.getAll(field);
+        if (values.length > 1) {
+            errors.push({
+                pointer: `/${field}`,
+                reason: "must be given at most once",
+            });
+            continue;
+        }
+        const value = values[0];
+        if (value !== undefined)
+            raw[field] =
+                (field === "limit" || field === "responseStatus") &&
+                    /^-?\d+$/u.test(value)
+                    ? Number(value)
+                    : value;
+    }
+    if (errors.length)
+        return { ok: false, errors };
+    const parsed = projectAttemptSearchRequestSchema.safeParse(raw);
+    return parsed.success
+        ? { ok: true, page: parsed.data }
+        : {
+            ok: false,
+            errors: parsed.error.issues.map((issue) => ({
+                pointer: `/${issue.path.join("/")}`,
+                reason: issue.message,
+            })),
+        };
+}
+/** Safe search summary: content and secret-bearing HTTP evidence is detail-only. */
+export const projectAttemptSearchResultSchema = /* @__PURE__ */ (() => z.object({
+    attempt: z.object({
+        id: attemptSearchSummaryShape.id,
+        attemptNumber: attemptSearchSummaryShape.attemptNumber,
+        occurrence: attemptSearchSummaryShape.occurrence,
+        startedAt: attemptSearchSummaryShape.startedAt,
+        state: attemptSearchSummaryShape.state,
+        classifiedAt: attemptSearchSummaryShape.classifiedAt,
+        durationMs: attemptSearchSummaryShape.durationMs,
+        responseStatus: attemptSearchSummaryShape.responseStatus,
+        diagnostic: attemptSearchSummaryShape.diagnostic,
+        remediation: attemptSearchSummaryShape.remediation,
+        trigger: attemptSearchSummaryShape.trigger,
+    }),
+    occurrence: occurrenceSchema,
+    schedule: z.object({
+        id: scheduleIdSchema,
+        name: scheduleNameSchema.optional(),
+        endpoint: endpointIdSchema.optional(),
+        external_identifier: externalIdentifierSchema.optional(),
+        tags: scheduleTagsSchema.optional(),
+    }),
+}))();
+export const projectAttemptPageSchema = /* @__PURE__ */ (() => pageSchema(projectAttemptSearchResultSchema).extend({
+    freshness: z.object({ kind: z.literal("authoritative") }),
+    /** Normal plan horizons; older live/retained records may still be returned. */
+    retention: z.object({
+        from: timestampSchema,
+        detailsFrom: timestampSchema,
+    }),
+}))();

package/dist/authority.js

@@ -26,13 +26,13 @@ import { environmentIdSchema, organizationIdSchema, projectIdSchema, } from "./i
  * third if one is ever added.
  */
 export const ENVIRONMENT_KINDS_IN_ORDER = ["test", "live"];
-export const environmentKindSchema = z.enum(ENVIRONMENT_KINDS_IN_ORDER);
-export const authoritySchema = z.object({
+export const environmentKindSchema = /* @__PURE__ */ (() => z.enum(ENVIRONMENT_KINDS_IN_ORDER))();
+export const authoritySchema = /* @__PURE__ */ (() => z.object({
     environment: environmentIdSchema,
     environmentKind: environmentKindSchema,
     organization: organizationIdSchema,
     project: projectIdSchema,
-});
+}))();
 /**
  * The initial scope vocabulary. Scopes are `resource:action`, lower case, and
  * additive — a new scope is a compatible change, removing or narrowing one is
@@ -126,7 +126,7 @@ export const SCOPES = [
      */
     "usage:read",
 ];
-export const scopeSchema = z.enum(SCOPES);
+export const scopeSchema = /* @__PURE__ */ (() => z.enum(SCOPES))();
 /** Read scopes implied by the matching write scope. */
 const IMPLIED_BY_WRITE = {
     "credentials:write": "credentials:read",
@@ -170,13 +170,13 @@ export function effectiveScopes(granted) {
  *   gives for one that does not exist.
  */
 export const PRINCIPAL_KINDS = ["api-credential", "oauth", "session"];
-export const principalKindSchema = z.enum(PRINCIPAL_KINDS);
-export const principalSchema = z.object({
+export const principalKindSchema = /* @__PURE__ */ (() => z.enum(PRINCIPAL_KINDS))();
+export const principalSchema = /* @__PURE__ */ (() => z.object({
     authority: authoritySchema,
     scopes: z.array(scopeSchema).min(1),
     /** How the principal was established, for audit and refusal messages. */
     via: principalKindSchema,
-});
+}))();
 /**
  * Whether a principal may act on an already-resolved resource.
  *
@@ -298,10 +298,10 @@ export const SESSION_AUTHORITY_HEADERS = {
  * know whether a scope is implied can apply the same published expansion the
  * service does.
  */
-export const credentialContextSchema = z.object({
+export const credentialContextSchema = /* @__PURE__ */ (() => z.object({
     environmentKind: environmentKindSchema,
     /** How this credential authenticated. Never `session`: see the operation. */
     principal: z.enum(["api-credential", "oauth"]),
     project: projectIdSchema,
     scopes: z.array(scopeSchema).min(1),
-});
+}))();

package/dist/billing.d.ts

@@ -1406,8 +1406,8 @@ export declare const promotionGrantViewSchema: import("zod").ZodObject<{
         durationInMonths: import("zod").ZodOptional<import("zod").ZodNumber>;
     }, import("zod/v4/core").$strip>], "kind">;
     state: import("zod").ZodEnum<{
-        expired: "expired";
         active: "active";
+        expired: "expired";
         revoked: "revoked";
     }>;
     startsAt: import("zod").ZodString;
@@ -1450,8 +1450,8 @@ export declare const billingPromotionsSchema: import("zod").ZodObject<{
             durationInMonths: import("zod").ZodOptional<import("zod").ZodNumber>;
         }, import("zod/v4/core").$strip>], "kind">;
         state: import("zod").ZodEnum<{
-            expired: "expired";
             active: "active";
+            expired: "expired";
             revoked: "revoked";
         }>;
         startsAt: import("zod").ZodString;
@@ -1505,8 +1505,8 @@ export declare const billingRedeemResponseSchema: import("zod").ZodObject<{
             durationInMonths: import("zod").ZodOptional<import("zod").ZodNumber>;
         }, import("zod/v4/core").$strip>], "kind">;
         state: import("zod").ZodEnum<{
-            expired: "expired";
             active: "active";
+            expired: "expired";
             revoked: "revoked";
         }>;
         startsAt: import("zod").ZodString;
@@ -1548,8 +1548,8 @@ export declare const billingRedeemResponseSchema: import("zod").ZodObject<{
                 durationInMonths: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>], "kind">;
             state: import("zod").ZodEnum<{
-                expired: "expired";
                 active: "active";
+                expired: "expired";
                 revoked: "revoked";
             }>;
             startsAt: import("zod").ZodString;