@greatwait/contracts 0.2.3 → 0.3.0

package/dist/configuration.d.ts

@@ -0,0 +1,71 @@
+export declare const CONFIGURATION_DEFAULTS: Readonly<{
+    bulkMaxTargets: 100000;
+    bulkExecutionLifetimeSeconds: 604800;
+    bulkPreviewLifetimeSeconds: 300;
+    bulkResultRetentionSeconds: 1209600;
+    bulkBatchSize: 25;
+    bulkWorkerConcurrency: 1;
+    bulkActiveJobLimit: 1;
+    bulkWorkBudgetSeconds: 3;
+    bulkCarrierBatchSize: 100;
+    attemptDetailRetentionSeconds: 604800;
+    forecastHorizonSeconds: number;
+    historyRetentionSeconds: 1209600;
+    inlinePayloadBytes: 65536;
+    payloadRetentionSeconds: 259200;
+    usageWindowDays: 366;
+}>;
+export type DeploymentContext = "local" | "staging" | "production";
+export type ConfigurationScope = "global" | "organization";
+export type ConfigurationLayer = "default" | "global" | "deployment" | "organization";
+export interface ConfigurationValues {
+    readonly bulkMaxTargets?: number;
+    readonly bulkExecutionLifetimeSeconds?: number;
+    readonly bulkPreviewLifetimeSeconds?: number;
+    readonly bulkResultRetentionSeconds?: number;
+    readonly bulkBatchSize?: number;
+    readonly bulkWorkerConcurrency?: number;
+    readonly bulkActiveJobLimit?: number;
+    readonly bulkWorkBudgetSeconds?: number;
+    readonly bulkCarrierBatchSize?: number;
+    readonly inlinePayloadBytes?: number;
+    readonly partitionKeyCeiling?: number;
+    readonly forecastHorizonSeconds?: number;
+    readonly usageWindowDays?: number;
+    readonly attemptDetailRetentionSeconds?: number;
+    readonly historyRetentionSeconds?: number;
+    readonly payloadRetentionSeconds?: number;
+    readonly pageLimit?: number;
+}
+export interface ConfigurationSetting {
+    readonly key: keyof ConfigurationValues;
+    readonly type: "integer";
+    readonly unit: "bytes" | "count" | "seconds" | "days";
+    readonly default?: number;
+    readonly minimum: number;
+    readonly maximum: number;
+    readonly layers: readonly ConfigurationLayer[];
+    readonly change: "live" | "deployment";
+    readonly rationale: string;
+    readonly enforcement: readonly string[];
+    readonly exhaustion: string;
+    readonly visibility: "customer";
+}
+export declare const CONFIGURATION_CATALOG: readonly ConfigurationSetting[];
+export declare function validateConfigurationValues(value: unknown, scope: ConfigurationScope): ConfigurationValues;
+export interface EffectiveConfiguration {
+    readonly values: ConfigurationValues;
+    readonly revision: {
+        readonly global: number;
+        readonly organization: number;
+    };
+    readonly provenance: Readonly<Record<string, ConfigurationLayer>>;
+}
+export declare function resolveEffectiveConfiguration(input: {
+    readonly deployment: DeploymentContext;
+    readonly baseline?: ConfigurationValues;
+    readonly global?: ConfigurationValues;
+    readonly organization?: ConfigurationValues;
+    readonly globalRevision?: number;
+    readonly organizationRevision?: number;
+}): EffectiveConfiguration;

package/dist/configuration.js

@@ -0,0 +1,204 @@
+/**
+ * Product-owned adaptation of Flow XO Agents FXO-2600 catalog metadata,
+ * precedence, immutable resolution and value provenance (82bcc247).
+ * Operator updates are strict; historical values are never silently clamped.
+ * This leaf imports no application, database or Worker implementation.
+ */
+import { BULK_CONFIGURATION_MAXIMA, MAX_INLINE_PAYLOAD_BYTES, MAX_FORECAST_HORIZON_SECONDS, MAX_USAGE_WINDOW_DAYS, MAX_PARTITION_KEY_CEILING, PUBLIC_PAGE_SIZE, } from "./configuration-bounds.js";
+export const CONFIGURATION_DEFAULTS = Object.freeze({
+    bulkMaxTargets: 100_000,
+    bulkExecutionLifetimeSeconds: 604_800,
+    bulkPreviewLifetimeSeconds: 300,
+    bulkResultRetentionSeconds: 1_209_600,
+    bulkBatchSize: 25,
+    bulkWorkerConcurrency: 1,
+    bulkActiveJobLimit: 1,
+    bulkWorkBudgetSeconds: 3,
+    bulkCarrierBatchSize: 100,
+    attemptDetailRetentionSeconds: 604_800,
+    forecastHorizonSeconds: MAX_FORECAST_HORIZON_SECONDS,
+    historyRetentionSeconds: 1_209_600,
+    inlinePayloadBytes: MAX_INLINE_PAYLOAD_BYTES,
+    payloadRetentionSeconds: 259_200,
+    usageWindowDays: MAX_USAGE_WINDOW_DAYS,
+});
+const allowanceLayers = ["default", "global", "organization"];
+const deploymentLayers = ["default", "deployment"];
+export const CONFIGURATION_CATALOG = Object.freeze([
+    ...[
+        "bulkMaxTargets",
+        "bulkExecutionLifetimeSeconds",
+        "bulkPreviewLifetimeSeconds",
+        "bulkResultRetentionSeconds",
+        "bulkBatchSize",
+        "bulkWorkerConcurrency",
+        "bulkActiveJobLimit",
+        "bulkWorkBudgetSeconds",
+        "bulkCarrierBatchSize",
+    ].map((key) => ({
+        key,
+        type: "integer",
+        unit: key.endsWith("Seconds") ? "seconds" : "count",
+        default: CONFIGURATION_DEFAULTS[key],
+        minimum: 1,
+        maximum: BULK_CONFIGURATION_MAXIMA[key],
+        layers: allowanceLayers,
+        change: "live",
+        visibility: "customer",
+        rationale: "Owner-approved bounded bulk preparation and execution. Backlog limits do not increase in-flight work or ordinary delivery quotas; result retention is additionally capped by effective history retention.",
+        enforcement: ["bulk-operations"],
+        exhaustion: "Oversized selections refuse; deadlines expire remaining work; durable checkpoints preserve completed effects.",
+    })),
+    {
+        key: "inlinePayloadBytes",
+        type: "integer",
+        unit: "bytes",
+        default: CONFIGURATION_DEFAULTS.inlinePayloadBytes,
+        minimum: 0,
+        maximum: MAX_INLINE_PAYLOAD_BYTES,
+        layers: allowanceLayers,
+        change: "live",
+        rationale: "The operator removed the lower storage allowance. Default is the existing public payload envelope; a deliberate override may narrow it. Unbounded bodies would exceed the existing SQL and receiver representations.",
+        enforcement: ["authority-service", "schedule-draft"],
+        exhaustion: "Local validation and authoritative plan-limit-reached",
+        visibility: "customer",
+    },
+    {
+        key: "partitionKeyCeiling",
+        type: "integer",
+        unit: "count",
+        minimum: 1,
+        maximum: MAX_PARTITION_KEY_CEILING,
+        layers: allowanceLayers,
+        change: "live",
+        rationale: "No inherited count cap. A deliberate override uses indexed successor seeks bounded to ceiling plus one; its supported bound preserves the existing transaction work envelope.",
+        enforcement: ["authority-service", "postgres-repository"],
+        exhaustion: "New keys refused; existing keys and committed schedules preserved",
+        visibility: "customer",
+    },
+    {
+        key: "forecastHorizonSeconds",
+        type: "integer",
+        unit: "seconds",
+        default: CONFIGURATION_DEFAULTS.forecastHorizonSeconds,
+        minimum: 60,
+        maximum: MAX_FORECAST_HORIZON_SECONDS,
+        layers: allowanceLayers,
+        change: "live",
+        rationale: "The operator removed the six-hour allowance. Default is the existing public forecast horizon; explicit work exhaustion cannot masquerade as complete coverage.",
+        enforcement: ["authority-reads"],
+        exhaustion: "Window clipped; exhausted work returns explicit incomplete refusal",
+        visibility: "customer",
+    },
+    {
+        key: "usageWindowDays",
+        type: "integer",
+        unit: "days",
+        default: CONFIGURATION_DEFAULTS.usageWindowDays,
+        minimum: 1,
+        maximum: MAX_USAGE_WINDOW_DAYS,
+        layers: allowanceLayers,
+        change: "live",
+        rationale: "The operator removed the 31-day allowance. Default is the existing public usage envelope; it does not extend retention or restore purged data.",
+        enforcement: ["authority-reads"],
+        exhaustion: "Read window constrained to effective policy",
+        visibility: "customer",
+    },
+    ...[
+        "attemptDetailRetentionSeconds",
+        "historyRetentionSeconds",
+        "payloadRetentionSeconds",
+    ].map((key) => ({
+        key,
+        type: "integer",
+        unit: "seconds",
+        default: CONFIGURATION_DEFAULTS[key],
+        minimum: 0,
+        maximum: 9_007_199_254_740,
+        layers: deploymentLayers,
+        change: "deployment",
+        rationale: "Accepted retention policy, separately governed. Stored schedule durations preserve committed policy; increases cannot restore purged data.",
+        enforcement: ["authority-service", "authority-reads", "retention"],
+        exhaustion: "Read cutoff and bounded purge; no organization override",
+        visibility: "customer",
+    })),
+    {
+        key: "pageLimit",
+        type: "integer",
+        unit: "count",
+        minimum: PUBLIC_PAGE_SIZE.min,
+        maximum: PUBLIC_PAGE_SIZE.max,
+        layers: deploymentLayers,
+        change: "deployment",
+        rationale: "Public page protocol maximum; continuation preserves completeness.",
+        enforcement: ["authority-reads"],
+        exhaustion: "Bounded page with continuation",
+        visibility: "customer",
+    },
+]);
+export function validateConfigurationValues(value, scope) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new TypeError("configuration values must be an object");
+    if (scope !== "global" && scope !== "organization")
+        throw new TypeError("unsupported configuration scope");
+    const parsed = {};
+    for (const [key, candidate] of Object.entries(value)) {
+        const definition = CONFIGURATION_CATALOG.find((entry) => entry.key === key);
+        if (definition === undefined || !definition.layers.includes(scope))
+            throw new TypeError(`configuration setting ${key} does not support ${scope} edits`);
+        if (typeof candidate !== "number" ||
+            !Number.isSafeInteger(candidate) ||
+            candidate < definition.minimum ||
+            candidate > definition.maximum)
+            throw new RangeError(`configuration setting ${key} must be an integer from ${String(definition.minimum)} to ${String(definition.maximum)} ${definition.unit}`);
+        parsed[key] = candidate;
+    }
+    return Object.freeze(parsed);
+}
+export function resolveEffectiveConfiguration(input) {
+    if (!["local", "staging", "production"].includes(input.deployment))
+        throw new TypeError("unsupported deployment context");
+    const global = validateConfigurationValues(input.global ?? {}, "global");
+    const organization = validateConfigurationValues(input.organization ?? {}, "organization");
+    const values = { ...CONFIGURATION_DEFAULTS };
+    const provenance = Object.fromEntries(Object.keys(values).map((key) => [key, "default"]));
+    const apply = (layer, changes) => {
+        for (const [key, value] of Object.entries(changes)) {
+            values[key] = value;
+            provenance[key] = layer;
+        }
+    };
+    if (input.baseline !== undefined) {
+        for (const [key, candidate] of Object.entries(input.baseline)) {
+            const setting = CONFIGURATION_CATALOG.find((entry) => entry.key === key);
+            if (setting === undefined ||
+                typeof candidate !== "number" ||
+                !Number.isSafeInteger(candidate) ||
+                candidate < setting.minimum ||
+                candidate > setting.maximum)
+                throw new RangeError("invalid deployment baseline");
+        }
+        for (const key of Object.keys(values))
+            delete values[key];
+        for (const key of Object.keys(provenance))
+            delete provenance[key];
+        apply("deployment", input.baseline);
+    }
+    apply("global", global);
+    apply("organization", organization);
+    for (const revision of [
+        input.globalRevision ?? 0,
+        input.organizationRevision ?? 0,
+    ]) {
+        if (!Number.isSafeInteger(revision) || revision < 0)
+            throw new RangeError("configuration revision must be a nonnegative integer");
+    }
+    return Object.freeze({
+        values: Object.freeze(values),
+        revision: Object.freeze({
+            global: input.globalRevision ?? 0,
+            organization: input.organizationRevision ?? 0,
+        }),
+        provenance: Object.freeze(provenance),
+    });
+}

package/dist/data-export.d.ts

@@ -6,8 +6,8 @@ export declare const dataExportIdSchema: import("zod").ZodString;
 export declare function newDataExportId(randomBytes?: RandomBytes): string;
 export declare const DATA_EXPORT_STATES: readonly ["active", "complete", "cancelled"];
 export declare const dataExportStateSchema: import("zod").ZodEnum<{
-    active: "active";
     cancelled: "cancelled";
+    active: "active";
     complete: "complete";
 }>;
 /** Creating an export takes no authority from the body. */
@@ -18,8 +18,8 @@ export declare const dataExportSchema: import("zod").ZodObject<{
     cutoffAt: import("zod").ZodString;
     id: import("zod").ZodString;
     state: import("zod").ZodEnum<{
-        active: "active";
         cancelled: "cancelled";
+        active: "active";
         complete: "complete";
     }>;
     updatedAt: import("zod").ZodString;
@@ -46,8 +46,8 @@ export declare const dataExportCancelledSchema: import("zod").ZodObject<{
         cutoffAt: import("zod").ZodString;
         id: import("zod").ZodString;
         state: import("zod").ZodEnum<{
-            active: "active";
             cancelled: "cancelled";
+            active: "active";
             complete: "complete";
         }>;
         updatedAt: import("zod").ZodString;

package/dist/effective-limits.d.ts

@@ -8,26 +8,26 @@ export declare const effectiveCustomerLimitsSchema: import("zod").ZodObject<{
     }, import("zod/v4/core").$strict>;
     provenance: import("zod").ZodObject<{
         inlinePayloadBytes: import("zod").ZodEnum<{
-            default: "default";
             organization: "organization";
+            default: "default";
             global: "global";
             deployment: "deployment";
         }>;
         partitionKeyCeiling: import("zod").ZodOptional<import("zod").ZodEnum<{
-            default: "default";
             organization: "organization";
+            default: "default";
             global: "global";
             deployment: "deployment";
         }>>;
         forecastHorizonSeconds: import("zod").ZodEnum<{
-            default: "default";
             organization: "organization";
+            default: "default";
             global: "global";
             deployment: "deployment";
         }>;
         usageWindowDays: import("zod").ZodEnum<{
-            default: "default";
             organization: "organization";
+            default: "default";
             global: "global";
             deployment: "deployment";
         }>;

package/dist/execution-selection.d.ts

@@ -0,0 +1,48 @@
+import { z } from "./zod.js";
+/** Retained execution search extends the same current-parent predicates. */
+export declare const executionSelectionSchema: import("zod").ZodObject<{
+    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>;
+    status: import("zod").ZodOptional<import("zod").ZodEnum<{
+        cancelled: "cancelled";
+        active: "active";
+        paused: "paused";
+        completed: "completed";
+    }>>;
+    recurrence: import("zod").ZodOptional<import("zod").ZodEnum<{
+        at: "at";
+        every: "every";
+        cron: "cron";
+    }>>;
+    text: import("zod").ZodOptional<import("zod").ZodString>;
+    from: import("zod").ZodOptional<import("zod").ZodString>;
+    to: import("zod").ZodOptional<import("zod").ZodString>;
+    outcome: import("zod").ZodOptional<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";
+    }>>;
+}, import("zod/v4/core").$strip>;
+export type ExecutionSelection = z.infer<typeof executionSelectionSchema>;
+export declare function normalizeExecutionSelection(selection: ExecutionSelection): {
+    outcome?: "planned" | "due" | "dispatching" | "retry_wait" | "ambiguous" | "succeeded" | "terminal_failed" | "cancelled" | "skipped_stale";
+    to?: string;
+    from?: string;
+    external_identifier?: string;
+    tag?: string;
+    status?: "cancelled" | "active" | "paused" | "completed";
+    recurrence?: "at" | "every" | "cron";
+    endpoint?: string;
+    text?: string;
+    schedule?: string;
+    dueAfter?: string;
+    dueBefore?: string;
+};

package/dist/execution-selection.js

@@ -0,0 +1,21 @@
+import { z } from "./zod.js";
+import { occurrenceStateSchema } from "./occurrence-states.js";
+import { scheduleSelectionSchema, normalizeScheduleSelection, } from "./schedule-selection.js";
+import { timestampSchema } from "./time.js";
+/** Retained execution search extends the same current-parent predicates. */
+export const executionSelectionSchema = scheduleSelectionSchema
+    .omit({ dueBefore: true, dueAfter: true })
+    .extend({
+    from: timestampSchema.optional(),
+    to: timestampSchema.optional(),
+    outcome: occurrenceStateSchema.optional(),
+});
+export function normalizeExecutionSelection(selection) {
+    const parent = normalizeScheduleSelection(selection);
+    return {
+        ...parent,
+        ...(selection.from === undefined ? {} : { from: selection.from }),
+        ...(selection.to === undefined ? {} : { to: selection.to }),
+        ...(selection.outcome === undefined ? {} : { outcome: selection.outcome }),
+    };
+}

package/dist/http-request.d.ts

@@ -158,9 +158,9 @@ export declare const storedHttpRequestSchema: import("zod").ZodObject<{
         GET: "GET";
     }>;
     bodyMode: import("zod").ZodEnum<{
+        none: "none";
         envelope: "envelope";
         json: "json";
-        none: "none";
     }>;
     headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
         name: import("zod").ZodString;

package/dist/identifiers.d.ts

@@ -17,6 +17,7 @@ export declare const ID_PREFIXES: {
     readonly apiCredential: "ak";
     readonly apiCredentialEvent: "ake";
     readonly attempt: "att";
+    readonly bulkJob: "bjo";
     readonly authorizationRequest: "oar";
     readonly callbackSigningKey: "csk";
     readonly delivery: "dlv";
@@ -49,6 +50,7 @@ export declare const oauthGrantIdSchema: import("zod").ZodString;
 export declare const oauthGrantEventIdSchema: import("zod").ZodString;
 export declare const scheduleIdSchema: import("zod").ZodString;
 export declare const occurrenceIdSchema: import("zod").ZodString;
+export declare const bulkJobIdSchema: import("zod").ZodString;
 export declare const attemptIdSchema: import("zod").ZodString;
 export declare const deliveryIdSchema: import("zod").ZodString;
 export declare const endpointIdSchema: import("zod").ZodString;

package/dist/identifiers.js

@@ -21,6 +21,7 @@ export const ID_PREFIXES = {
     // would make an identifier ambiguous about which stream it belongs to.
     apiCredentialEvent: "ake",
     attempt: "att",
+    bulkJob: "bjo",
     // A pending OAuth authorization, alive only between the client's redirect and
     // the member's answer. It is an identifier rather than an opaque blob because
     // the consent screen has to fetch it by name, and a blob in a URL is a blob
@@ -79,6 +80,7 @@ export const oauthGrantIdSchema = idSchema("oauthGrant");
 export const oauthGrantEventIdSchema = idSchema("oauthGrantEvent");
 export const scheduleIdSchema = idSchema("schedule");
 export const occurrenceIdSchema = idSchema("occurrence");
+export const bulkJobIdSchema = idSchema("bulkJob");
 export const attemptIdSchema = idSchema("attempt");
 export const deliveryIdSchema = idSchema("delivery");
 export const endpointIdSchema = idSchema("endpoint");

package/dist/identity.d.ts

@@ -71,8 +71,8 @@ export type MembershipRole = z.infer<typeof membershipRoleSchema>;
  */
 export declare const MEMBERSHIP_STATUSES: readonly ["active", "suspended", "removed"];
 export declare const membershipStatusSchema: import("zod").ZodEnum<{
-    removed: "removed";
     active: "active";
+    removed: "removed";
     suspended: "suspended";
 }>;
 export type MembershipStatus = z.infer<typeof membershipStatusSchema>;
@@ -105,8 +105,8 @@ export declare const membershipSchema: import("zod").ZodObject<{
         billing: "billing";
     }>;
     status: import("zod").ZodEnum<{
-        removed: "removed";
         active: "active";
+        removed: "removed";
         suspended: "suspended";
     }>;
     user: import("zod").ZodString;
@@ -147,8 +147,8 @@ export declare const membershipChangeSchema: import("zod").ZodObject<{
         billing: "billing";
     }>;
     status: import("zod").ZodEnum<{
-        removed: "removed";
         active: "active";
+        removed: "removed";
         suspended: "suspended";
     }>;
     user: import("zod").ZodString;

package/dist/index.d.ts

@@ -35,3 +35,8 @@ export * from "./http-request.js";
 export { sanitizedDiagnosticText, diagnosticBodyText, responseBodySentence, requestCaptureSentence, attemptStatusGuidance, } from "./attempt-diagnostics.js";
 export { PROJECT_NOTIFICATION_OPERATIONS, notificationEmailRecipientsSchema, notificationEmailSettingsSchema, statusWebhookEventSchema, statusWebhookConfigurationSchema, projectNotificationSettingsSchema, projectNotificationSettingsUpdateRequestSchema, statusSigningKeyRequestSchema, statusSigningKeyCreatedSchema, statusWebhookPayloadSchema, statusWebhookDeliverySchema, statusWebhookDeliveryPageSchema, type ProjectNotificationSettings, type ProjectNotificationSettingsUpdateRequest, type StatusSigningKeyCreated, type StatusWebhookEvent, type StatusWebhookPayload, type StatusWebhookDelivery, type StatusWebhookDeliveryPage, } from "./project-notifications.js";
 export { externalIdentifierSchema, scheduleTagSchema, scheduleTagsSchema, } from "./host-correlation.js";
+export { scheduleSelectionSchema, normalizeScheduleSelection, type ScheduleSelection, } from "./schedule-selection.js";
+export * from "./bulk-operations.js";
+export { executionSelectionSchema, normalizeExecutionSelection, type ExecutionSelection, } from "./execution-selection.js";
+export { bulkJobIdSchema } from "./identifiers.js";
+export * from "./attempt-search.js";

package/dist/index.js

@@ -35,3 +35,8 @@ export * from "./http-request.js";
 export { sanitizedDiagnosticText, diagnosticBodyText, responseBodySentence, requestCaptureSentence, attemptStatusGuidance, } from "./attempt-diagnostics.js";
 export { PROJECT_NOTIFICATION_OPERATIONS, notificationEmailRecipientsSchema, notificationEmailSettingsSchema, statusWebhookEventSchema, statusWebhookConfigurationSchema, projectNotificationSettingsSchema, projectNotificationSettingsUpdateRequestSchema, statusSigningKeyRequestSchema, statusSigningKeyCreatedSchema, statusWebhookPayloadSchema, statusWebhookDeliverySchema, statusWebhookDeliveryPageSchema, } from "./project-notifications.js";
 export { externalIdentifierSchema, scheduleTagSchema, scheduleTagsSchema, } from "./host-correlation.js";
+export { scheduleSelectionSchema, normalizeScheduleSelection, } from "./schedule-selection.js";
+export * from "./bulk-operations.js";
+export { executionSelectionSchema, normalizeExecutionSelection, } from "./execution-selection.js";
+export { bulkJobIdSchema } from "./identifiers.js";
+export * from "./attempt-search.js";

package/dist/occurrence-states.d.ts

@@ -0,0 +1,14 @@
+import { z } from "./zod.js";
+export declare const OCCURRENCE_STATES: readonly ["planned", "due", "dispatching", "retry_wait", "ambiguous", "succeeded", "terminal_failed", "cancelled", "skipped_stale"];
+export declare const occurrenceStateSchema: 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";
+}>;
+export type OccurrenceState = z.infer<typeof occurrenceStateSchema>;

package/dist/occurrence-states.js

@@ -0,0 +1,13 @@
+import { z } from "./zod.js";
+export const OCCURRENCE_STATES = [
+    "planned",
+    "due",
+    "dispatching",
+    "retry_wait",
+    "ambiguous",
+    "succeeded",
+    "terminal_failed",
+    "cancelled",
+    "skipped_stale",
+];
+export const occurrenceStateSchema = z.enum(OCCURRENCE_STATES);