@greatwait/contracts 0.2.3 → 0.3.1

package/dist/configuration.d.ts

@@ -0,0 +1,75 @@
+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";
+}
+/** Bounds and edit authority shared by validation and the descriptive catalog. */
+export type ConfigurationRule = Pick<ConfigurationSetting, "key" | "unit" | "minimum" | "maximum" | "layers">;
+export declare const CONFIGURATION_RULES: readonly ConfigurationRule[];
+/** Descriptive metadata is only initialized by catalog consumers. */
+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,242 @@
+/**
+ * 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_RULES = Object.freeze([
+    ...[
+        "bulkMaxTargets",
+        "bulkExecutionLifetimeSeconds",
+        "bulkPreviewLifetimeSeconds",
+        "bulkResultRetentionSeconds",
+        "bulkBatchSize",
+        "bulkWorkerConcurrency",
+        "bulkActiveJobLimit",
+        "bulkWorkBudgetSeconds",
+        "bulkCarrierBatchSize",
+    ].map((key) => ({
+        key,
+        unit: key.endsWith("Seconds") ? "seconds" : "count",
+        minimum: 1,
+        maximum: BULK_CONFIGURATION_MAXIMA[key],
+        layers: allowanceLayers,
+    })),
+    {
+        key: "inlinePayloadBytes",
+        unit: "bytes",
+        minimum: 0,
+        maximum: MAX_INLINE_PAYLOAD_BYTES,
+        layers: allowanceLayers,
+    },
+    {
+        key: "partitionKeyCeiling",
+        unit: "count",
+        minimum: 1,
+        maximum: MAX_PARTITION_KEY_CEILING,
+        layers: allowanceLayers,
+    },
+    {
+        key: "forecastHorizonSeconds",
+        unit: "seconds",
+        minimum: 60,
+        maximum: MAX_FORECAST_HORIZON_SECONDS,
+        layers: allowanceLayers,
+    },
+    {
+        key: "usageWindowDays",
+        unit: "days",
+        minimum: 1,
+        maximum: MAX_USAGE_WINDOW_DAYS,
+        layers: allowanceLayers,
+    },
+    ...[
+        "attemptDetailRetentionSeconds",
+        "historyRetentionSeconds",
+        "payloadRetentionSeconds",
+    ].map((key) => ({
+        key,
+        unit: "seconds",
+        minimum: 0,
+        maximum: 9_007_199_254_740,
+        layers: deploymentLayers,
+    })),
+    {
+        key: "pageLimit",
+        unit: "count",
+        minimum: PUBLIC_PAGE_SIZE.min,
+        maximum: PUBLIC_PAGE_SIZE.max,
+        layers: deploymentLayers,
+    },
+]);
+/** Descriptive metadata is only initialized by catalog consumers. */
+export const CONFIGURATION_CATALOG = 
+/* @__PURE__ */ (() => {
+    const metadata = [
+        ...[
+            "bulkMaxTargets",
+            "bulkExecutionLifetimeSeconds",
+            "bulkPreviewLifetimeSeconds",
+            "bulkResultRetentionSeconds",
+            "bulkBatchSize",
+            "bulkWorkerConcurrency",
+            "bulkActiveJobLimit",
+            "bulkWorkBudgetSeconds",
+            "bulkCarrierBatchSize",
+        ].map((key) => ({
+            key,
+            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",
+            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",
+            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",
+            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",
+            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,
+            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",
+            change: "deployment",
+            rationale: "Public page protocol maximum; continuation preserves completeness.",
+            enforcement: ["authority-reads"],
+            exhaustion: "Bounded page with continuation",
+            visibility: "customer",
+        },
+    ];
+    const defaults = CONFIGURATION_DEFAULTS;
+    return Object.freeze(metadata.map((entry) => ({
+        ...CONFIGURATION_RULES.find((rule) => rule.key === entry.key),
+        type: "integer",
+        ...(defaults[entry.key] === undefined
+            ? {}
+            : { default: defaults[entry.key] }),
+        ...entry,
+    })));
+})();
+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_RULES.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_RULES.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/delivery.d.ts

@@ -45,6 +45,7 @@ export interface StoredHttpRequest {
     readonly encryptedTemplate?: EncryptedSchedulePayload;
 }
 export declare const HTTP_HEADER_AAD_VERSION: "greatwait.http-header.v1";
+export { mergeStoredHttpHeaders, validScheduleHttp, validStoredHttpHeaders, } from "./stored-http.js";
 export declare const HTTP_TEMPLATE_AAD_VERSION: "greatwait.http-template.v1";
 /**
  * One immutable delivery attempt, minted by the Scheduler Partition from its

package/dist/delivery.js

@@ -8,6 +8,7 @@
  */
 export const SCHEDULE_PAYLOAD_AAD_VERSION = "greatwait.schedule-payload.v1";
 export const HTTP_HEADER_AAD_VERSION = "greatwait.http-header.v1";
+export { mergeStoredHttpHeaders, validScheduleHttp, validStoredHttpHeaders, } from "./stored-http.js";
 export const HTTP_TEMPLATE_AAD_VERSION = "greatwait.http-template.v1";
 /**
  * What a receiver says about work it acknowledged and then finished.

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/endpoints.js

@@ -20,7 +20,7 @@ import { timestampSchema } from "./time.js";
  * nothing to prove.
  */
 export const CALLBACK_ENDPOINT_STATUSES = ["active", "disabled"];
-export const callbackEndpointStatusSchema = z.enum(CALLBACK_ENDPOINT_STATUSES);
+export const callbackEndpointStatusSchema = /* @__PURE__ */ (() => z.enum(CALLBACK_ENDPOINT_STATUSES))();
 /**
  * Why an address could not be resolved or reached: the classification the
  * DNS inspection at create and update, and the delivery egress, share. It
@@ -37,7 +37,7 @@ export const CALLBACK_EGRESS_FAILURES = [
     "timed_out",
     "unexpected_status",
 ];
-export const callbackEgressFailureSchema = z.enum(CALLBACK_EGRESS_FAILURES);
+export const callbackEgressFailureSchema = /* @__PURE__ */ (() => z.enum(CALLBACK_EGRESS_FAILURES))();
 /**
  * @deprecated The former retained endpoint count ceiling. W0-15 removes count
  * enforcement after the operator's decision; DNS/mutation admission and paged
@@ -56,7 +56,7 @@ export const CALLBACK_ADMISSION_RATE_LIMITS = {
 };
 /** Longest period during which a receiver may accept current and next keys. */
 export const CALLBACK_SIGNING_KEY_ROTATION_OVERLAP_SECONDS = 86_400;
-export const callbackSigningKeysSchema = z.object({
+export const callbackSigningKeysSchema = /* @__PURE__ */ (() => z.object({
     current: callbackSigningKeyIdSchema,
     next: z
         .object({
@@ -66,7 +66,7 @@ export const callbackSigningKeysSchema = z.object({
         overlapEndsAt: timestampSchema,
     })
         .optional(),
-});
+}))();
 /**
  * An endpoint's name: unique within its project and environment, compared
  * exactly (W4-14, FXO-2255).
@@ -80,16 +80,16 @@ export const callbackSigningKeysSchema = z.object({
  * "Prod receiver" and "prod receiver" are both allowed. Deliberately unlike a
  * project's name, which ignores case and spacing.
  */
-export const callbackEndpointNameSchema = z
+export const callbackEndpointNameSchema = /* @__PURE__ */ (() => z
     .string()
     .trim()
     .min(1, "must not be blank")
-    .max(2_048, "must be at most 2048 characters");
+    .max(2_048, "must be at most 2048 characters"))();
 /**
  * A metadata-only endpoint shape. The sealed signing secret has no public
  * field, so list/get/update/disable/enable cannot accidentally recover it.
  */
-export const callbackEndpointSchema = z.object({
+export const callbackEndpointSchema = /* @__PURE__ */ (() => z.object({
     headers: z.array(publicHttpHeaderSchema).optional(),
     createdAt: timestampSchema,
     disabledAt: timestampSchema.optional(),
@@ -107,33 +107,33 @@ export const callbackEndpointSchema = z.object({
     updatedAt: timestampSchema,
     url: z.string().url(),
     version: z.number().int().positive(),
-});
-export const callbackEndpointPageSchema = pageSchema(callbackEndpointSchema);
+}))();
+export const callbackEndpointPageSchema = /* @__PURE__ */ (() => pageSchema(callbackEndpointSchema))();
 /** The one response that carries the per-endpoint secret. */
-export const callbackEndpointCreatedSchema = callbackEndpointSchema.extend({
+export const callbackEndpointCreatedSchema = /* @__PURE__ */ (() => callbackEndpointSchema.extend({
     keyId: callbackSigningKeyIdSchema,
     secret: z.string().min(1),
     shownOnce: z.literal(true),
-});
-export const callbackSigningKeyRotationRequestSchema = z.object({
+}))();
+export const callbackSigningKeyRotationRequestSchema = /* @__PURE__ */ (() => z.object({
     overlapSeconds: z
         .number()
         .int()
         .min(0)
         .max(CALLBACK_SIGNING_KEY_ROTATION_OVERLAP_SECONDS, "must not exceed the maximum endpoint-key overlap")
         .optional(),
-});
-export const callbackEndpointRotatedSchema = z.object({
+}))();
+export const callbackEndpointRotatedSchema = /* @__PURE__ */ (() => z.object({
     endpoint: callbackEndpointSchema,
     keyId: callbackSigningKeyIdSchema,
     secret: z.string().min(1),
     shownOnce: z.literal(true),
-});
+}))();
 /** One signing key and the secret behind it, as a signed-in person may see it. */
-export const callbackEndpointSigningSecretSchema = z.object({
+export const callbackEndpointSigningSecretSchema = /* @__PURE__ */ (() => z.object({
     keyId: callbackSigningKeyIdSchema,
     secret: z.string().min(1),
-});
+}))();
 /**
  * What `endpoints.revealSigningSecret` answers (FXO-2244).
  *
@@ -142,14 +142,14 @@ export const callbackEndpointSigningSecretSchema = z.object({
  * rotation both keys are here, with the instant the overlap ends, because a
  * receiver being moved to the new key needs both until then.
  */
-export const callbackEndpointSigningSecretsSchema = z.object({
+export const callbackEndpointSigningSecretsSchema = /* @__PURE__ */ (() => z.object({
     current: callbackEndpointSigningSecretSchema,
     /** The endpoint these belong to, so an answer names what it is about. */
     id: endpointIdSchema,
     next: callbackEndpointSigningSecretSchema
         .extend({ overlapEndsAt: timestampSchema })
         .optional(),
-});
+}))();
 /**
  * Where an endpoint's signing secret is, for a result that does not carry it
  * (W9-44, FXO-2907).
@@ -166,7 +166,7 @@ export const callbackEndpointSigningSecretsSchema = z.object({
  * reader deciding whether it holds a secret should be told so, not left to
  * infer it from what is missing.
  */
-export const signingSecretNoticeSchema = z.object({
+export const signingSecretNoticeSchema = /* @__PURE__ */ (() => z.object({
     /** One sentence an agent can relay to the person it is working for. */
     guidance: z.string().min(1),
     /** Never `true`: these results do not carry the secret. */
@@ -176,7 +176,7 @@ export const signingSecretNoticeSchema = z.object({
      * reveals the secret. Absent only where this deployment has no dashboard.
      */
     revealUrl: z.string().url().optional(),
-});
+}))();
 /**
  * The dashboard path of one endpoint's page, beneath the project and
  * environment it belongs to. The dashboard's router serves it; a test there
@@ -208,11 +208,11 @@ export function signingSecretNotice(target, dashboardOrigin) {
  * Metadata only, like every endpoint read. There is no `secret` field to fill
  * by mistake; the shape is what keeps it out of an agent's history.
  */
-export const callbackEndpointEnsuredSchema = callbackEndpointSchema.extend({
+export const callbackEndpointEnsuredSchema = /* @__PURE__ */ (() => callbackEndpointSchema.extend({
     /** Whether this call created the endpoint, or found one already there. */
     created: z.boolean(),
     signingSecret: signingSecretNoticeSchema,
-});
+}))();
 /**
  * A callback destination as a caller types it: HTTPS on port 443, no
  * credentials or fragment, a public name or address. The DNS half of the
@@ -233,7 +233,7 @@ export function callbackUrlSchema() {
         }
     });
 }
-export const callbackEndpointRequestSchema = z.object({
+export const callbackEndpointRequestSchema = /* @__PURE__ */ (() => z.object({
     headers: endpointHeaderChangesSchema.optional(),
     /**
      * A name for people (W4-14, FXO-2255). Omitted on a create, the endpoint
@@ -243,4 +243,4 @@ export const callbackEndpointRequestSchema = z.object({
      */
     name: callbackEndpointNameSchema.optional(),
     url: callbackUrlSchema(),
-});
+}))();

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;