@greatwait/contracts 0.2.2 → 0.3.0

package/dist/bulk-operations.js

@@ -0,0 +1,610 @@
+import { nonnegativeMicrodollarAmountSchema, BILLING_ACTIVATION_MODES, } from "./billing.js";
+import { z } from "./zod.js";
+import { authoritySchema } from "./authority.js";
+import { bulkJobIdSchema, scheduleIdSchema, occurrenceIdSchema, attemptIdSchema, } from "./identifiers.js";
+import { scheduleSelectionSchema, normalizeScheduleSelection, } from "./schedule-selection.js";
+import { executionSelectionSchema, normalizeExecutionSelection, } from "./execution-selection.js";
+import { timestampSchema, timeZoneSchema } from "./time.js";
+import { latenessPolicySchema, deliveryOverlapPolicySchema, } from "./scheduling.js";
+import { BULK_CONFIGURATION_MAXIMA, FIXED_INTERVAL_MIN_SECONDS, FIXED_INTERVAL_MAX_SECONDS, } from "./configuration-bounds.js";
+import { CONFIGURATION_DEFAULTS } from "./configuration.js";
+import { pageRequestSchema, requiredIdempotencyRequestHeaderSchema, } from "./protocol.js";
+import { defineOperations, API_UNUSED_RESPONSE_SCHEMA, } from "./operation-definitions.js";
+export const BULK_OPERATIONS = [
+    "retry",
+    "cancel",
+    "reschedule",
+    "pause",
+    "resume",
+];
+export const bulkOperationSchema = z.enum(BULK_OPERATIONS);
+export const bulkTargetSchema = z.enum([
+    "schedules",
+    "parent_schedules",
+    "occurrences",
+]);
+/** The action registry owns targets, permissions and one canonical effect path. */
+export const BULK_OPERATION_REGISTRY = Object.freeze({
+    retry: {
+        targets: ["occurrences"],
+        scopes: ["occurrences:read", "occurrences:redeliver"],
+        effect: "occurrences.redeliver",
+        duplicateEffectAcknowledgment: true,
+    },
+    cancel: {
+        targets: ["schedules", "parent_schedules"],
+        scopes: ["schedules:read", "schedules:write"],
+        effect: "schedules.cancel",
+        duplicateEffectAcknowledgment: false,
+    },
+    reschedule: {
+        targets: ["schedules", "parent_schedules"],
+        scopes: ["schedules:read", "schedules:write"],
+        effect: "schedules.replace",
+        duplicateEffectAcknowledgment: false,
+    },
+    pause: {
+        targets: ["schedules", "parent_schedules"],
+        scopes: ["schedules:read", "schedules:write"],
+        effect: "schedules.pause",
+        duplicateEffectAcknowledgment: false,
+    },
+    resume: {
+        targets: ["schedules", "parent_schedules"],
+        scopes: ["schedules:read", "schedules:write"],
+        effect: "schedules.resume",
+        duplicateEffectAcknowledgment: false,
+    },
+});
+const scheduleFilter = scheduleSelectionSchema
+    .strict()
+    .refine((filter) => filter.dueAfter === undefined ||
+    filter.dueBefore === undefined ||
+    Date.parse(filter.dueAfter) < Date.parse(filter.dueBefore), { message: "dueBefore must be later than dueAfter", path: ["dueBefore"] });
+const executionFilter = executionSelectionSchema
+    .strict()
+    .refine((filter) => filter.from === undefined ||
+    filter.to === undefined ||
+    Date.parse(filter.from) < Date.parse(filter.to), { message: "to must be later than from", path: ["to"] });
+export const bulkSelectionSchema = z.union([
+    z
+        .object({
+        kind: z.literal("ids"),
+        resource: z.literal("schedules"),
+        ids: z
+            .array(scheduleIdSchema)
+            .max(BULK_CONFIGURATION_MAXIMA.bulkMaxTargets),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("ids"),
+        resource: z.literal("executions"),
+        ids: z
+            .array(occurrenceIdSchema)
+            .max(BULK_CONFIGURATION_MAXIMA.bulkMaxTargets),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("all_matching"),
+        resource: z.literal("schedules"),
+        filter: scheduleFilter,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("all_matching"),
+        resource: z.literal("executions"),
+        filter: executionFilter,
+    })
+        .strict(),
+]);
+export function normalizeBulkSelection(selection) {
+    if (selection.kind === "ids")
+        return { ...selection, ids: [...new Set(selection.ids)].sort() };
+    return selection.resource === "schedules"
+        ? { ...selection, filter: normalizeScheduleSelection(selection.filter) }
+        : { ...selection, filter: normalizeExecutionSelection(selection.filter) };
+}
+export const bulkRescheduleParametersSchema = z.discriminatedUnion("mode", [
+    z.object({ mode: z.literal("absolute"), at: timestampSchema }).strict(),
+    z
+        .object({
+        mode: z.literal("shift_existing"),
+        seconds: z
+            .number()
+            .int()
+            .min(-FIXED_INTERVAL_MAX_SECONDS)
+            .max(FIXED_INTERVAL_MAX_SECONDS)
+            .refine((seconds) => seconds !== 0, "shift must be nonzero"),
+    })
+        .strict(),
+    z
+        .object({
+        mode: z.literal("delay_from_reference"),
+        seconds: z.number().int().min(1).max(FIXED_INTERVAL_MAX_SECONDS),
+    })
+        .strict(),
+    z
+        .object({
+        mode: z.literal("definition"),
+        definition: z.union([
+            z
+                .object({
+                everySeconds: z
+                    .number()
+                    .int()
+                    .min(FIXED_INTERVAL_MIN_SECONDS)
+                    .max(FIXED_INTERVAL_MAX_SECONDS),
+            })
+                .strict(),
+            z
+                .object({
+                cron: z.string().min(1).max(256),
+                timeZone: timeZoneSchema,
+            })
+                .strict(),
+        ]),
+    })
+        .strict(),
+]);
+const previewFields = {
+    target: bulkTargetSchema,
+    selection: bulkSelectionSchema,
+};
+export const bulkPreviewRequestSchema = z
+    .discriminatedUnion("operation", [
+    z
+        .object({
+        ...previewFields,
+        operation: z.literal("retry"),
+        parameters: z
+            .object({ includeSucceeded: z.boolean().optional() })
+            .strict(),
+    })
+        .strict(),
+    z
+        .object({
+        ...previewFields,
+        operation: z.literal("reschedule"),
+        parameters: bulkRescheduleParametersSchema,
+    })
+        .strict(),
+    ...["cancel", "pause", "resume"].map((operation) => z
+        .object({
+        ...previewFields,
+        operation: z.literal(operation),
+        parameters: z.object({}).strict(),
+    })
+        .strict()),
+])
+    .superRefine((request, context) => {
+    const registry = BULK_OPERATION_REGISTRY[request.operation];
+    if (!registry.targets.includes(request.target))
+        context.addIssue({
+            code: "custom",
+            path: ["target"],
+            message: "unsupported target for this operation",
+        });
+    if ((request.target === "schedules" &&
+        request.selection.resource !== "schedules") ||
+        (request.target === "parent_schedules" &&
+            request.selection.resource !== "executions") ||
+        (request.target === "occurrences" &&
+            request.selection.resource !== "executions"))
+        context.addIssue({
+            code: "custom",
+            path: ["selection", "resource"],
+            message: "resource does not match the explicitly chosen target",
+        });
+    if (request.operation === "resume" &&
+        request.selection.kind === "all_matching" &&
+        request.selection.filter.status !== undefined &&
+        request.selection.filter.status !== "paused")
+        context.addIssue({
+            code: "custom",
+            path: ["selection", "filter", "status"],
+            message: "bulk Resume candidates must be paused",
+        });
+});
+export const bulkConfirmRequestSchema = z
+    .object({
+    intentDigest: z.string().regex(/^[a-f0-9]{64}$/u),
+    confirmed: z.literal(true),
+    acknowledgeDuplicateEffects: z.boolean(),
+})
+    .strict();
+export const BULK_JOB_STATES = [
+    "preparing",
+    "awaiting_confirmation",
+    "queued",
+    "running",
+    "paused",
+    "blocked",
+    "completed",
+    "completed_with_failures",
+    "cancelled",
+    "expired",
+    "refused",
+];
+export const bulkJobStateSchema = z.enum(BULK_JOB_STATES);
+export const BULK_ITEM_STATES = [
+    "pending",
+    "running",
+    "succeeded",
+    "no_op",
+    "skipped",
+    "conflicted",
+    "failed",
+    "cancelled",
+];
+export const bulkItemStateSchema = z.enum(BULK_ITEM_STATES);
+export const BULK_REASON_CODES = [
+    "eligible",
+    "already_active",
+    "already_paused",
+    "already_cancelled",
+    "invalid_state",
+    "unsupported_target",
+    "expired_input",
+    "unauthorized",
+    "concurrently_changed",
+    "past_time",
+    "attempt_limit",
+    "operation_failed",
+    "transient_failure",
+    "selection_too_large",
+    "preparation_incomplete",
+    "preview_expired",
+    "job_expired",
+    "job_cancelled",
+    "quota_exceeded",
+    "spending_limit",
+    "in_flight",
+];
+export const bulkReasonSchema = z.enum(BULK_REASON_CODES);
+export const bulkCountsSchema = z.object({
+    matched: z.number().int().nonnegative(),
+    eligible: z.number().int().nonnegative(),
+    ineligible: z.number().int().nonnegative(),
+    pending: z.number().int().nonnegative(),
+    running: z.number().int().nonnegative(),
+    succeeded: z.number().int().nonnegative(),
+    noOp: z.number().int().nonnegative(),
+    skipped: z.number().int().nonnegative(),
+    conflicted: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+    cancelled: z.number().int().nonnegative(),
+});
+export const bulkReadbackSchema = z
+    .object({
+    status: z.string().optional(),
+    plannedFor: timestampSchema.optional(),
+    recurrence: z.string().optional(),
+    timeZone: z.string().optional(),
+    affectedFutureRuns: z.number().int().nonnegative().optional(),
+    latenessPolicy: latenessPolicySchema.optional(),
+    maxStalenessSeconds: z
+        .number()
+        .int()
+        .nonnegative()
+        .max(Number.MAX_SAFE_INTEGER)
+        .optional(),
+    overlapPolicy: deliveryOverlapPolicySchema.optional(),
+    nextRunNote: z.string().min(1).max(1_000).optional(),
+})
+    .strict();
+export const bulkItemSchema = z
+    .object({
+    id: z.string().min(1),
+    jobId: bulkJobIdSchema,
+    scheduleId: scheduleIdSchema,
+    occurrenceId: occurrenceIdSchema.optional(),
+    state: bulkItemStateSchema,
+    reason: bulkReasonSchema,
+    eligible: z.boolean(),
+    retryable: z.boolean(),
+    fence: z.string().min(1),
+    before: bulkReadbackSchema,
+    after: bulkReadbackSchema.optional(),
+    attemptId: attemptIdSchema.optional(),
+    actionId: z.string().min(1).optional(),
+    updatedAt: timestampSchema,
+    expiresAt: timestampSchema.optional(),
+})
+    .strict();
+export const bulkJobSchema = z
+    .object({
+    id: bulkJobIdSchema,
+    authority: authoritySchema,
+    intent: bulkPreviewRequestSchema,
+    state: bulkJobStateSchema,
+    version: z.number().int().positive(),
+    createdAt: timestampSchema,
+    updatedAt: timestampSchema,
+    referenceAt: timestampSchema,
+    preparationExpiresAt: timestampSchema,
+    previewExpiresAt: timestampSchema.optional(),
+    executionExpiresAt: timestampSchema.optional(),
+    resultsExpireAt: timestampSchema.optional(),
+    intentDigest: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .optional(),
+    complete: z.boolean(),
+    counts: bulkCountsSchema,
+    reasons: z.array(z.object({
+        reason: bulkReasonSchema,
+        count: z.number().int().nonnegative(),
+    })),
+    warnings: z.array(z.string()),
+    samples: z.array(bulkItemSchema).max(10),
+    limits: z.object({
+        maxTargets: z.number().int().positive(),
+        executionLifetimeSeconds: z.number().int().positive(),
+        previewLifetimeSeconds: z.number().int().positive(),
+        resultRetentionSeconds: z.number().int().nonnegative(),
+        batchSize: z.number().int().positive(),
+        workerConcurrency: z.number().int().positive(),
+    }),
+    billing: z.object({
+        additionalAttemptsMinimum: z.number().int().nonnegative(),
+        additionalAttemptsMaximum: z.number().int().nonnegative().optional(),
+        currentLimits: z
+            .object({
+            capturedAt: timestampSchema,
+            billingMode: z.enum(BILLING_ACTIVATION_MODES),
+            attemptsPerOccurrence: z.number().int().positive(),
+            dailyAttemptQuota: z.literal("none"),
+            availableCreditMicrodollars: nonnegativeMicrodollarAmountSchema.optional(),
+            spendingCapMicrodollars: nonnegativeMicrodollarAmountSchema
+                .nullable()
+                .optional(),
+            remainingToSpendingCapMicrodollars: nonnegativeMicrodollarAmountSchema.optional(),
+        })
+            .strict()
+            .optional(),
+        exactChargeKnown: z.literal(false),
+        note: z.string(),
+    }),
+    reason: bulkReasonSchema.optional(),
+})
+    .strict();
+export const bulkJobPageSchema = z.object({
+    data: z.array(bulkJobSchema),
+    nextCursor: z.string().min(1).optional(),
+});
+export const bulkItemPageSchema = z.object({
+    data: z.array(bulkItemSchema),
+    nextCursor: z.string().min(1).optional(),
+});
+export const bulkListRequestSchema = pageRequestSchema.extend({
+    state: bulkJobStateSchema.optional(),
+});
+export const bulkItemListRequestSchema = pageRequestSchema.extend({
+    state: bulkItemStateSchema.optional(),
+});
+export const bulkControlRequestSchema = z
+    .object({ expectedVersion: z.number().int().positive() })
+    .strict();
+const exampleIntent = {
+    operation: "pause",
+    target: "schedules",
+    selection: {
+        kind: "all_matching",
+        resource: "schedules",
+        filter: { tag: "reminders" },
+    },
+    parameters: {},
+};
+const exampleJob = {
+    id: "bjo_01h8xyz9k2m4n6p8r0t2v4w6y8",
+    authority: {
+        organization: "org_01h8xyz9k2m4n6p8r0t2v4w6y8",
+        project: "proj_01h8xyz9k2m4n6p8r0t2v4w6y8",
+        environment: "env_01h8xyz9k2m4n6p8r0t2v4w6y8",
+        environmentKind: "test",
+    },
+    intent: exampleIntent,
+    state: "awaiting_confirmation",
+    version: 1,
+    createdAt: "2035-06-01T00:00:00.000Z",
+    updatedAt: "2035-06-01T00:00:00.000Z",
+    referenceAt: "2035-06-01T00:00:00.000Z",
+    preparationExpiresAt: "2035-06-08T00:00:00.000Z",
+    previewExpiresAt: "2035-06-01T00:05:00.000Z",
+    intentDigest: "a".repeat(64),
+    complete: true,
+    counts: {
+        matched: 0,
+        eligible: 0,
+        ineligible: 0,
+        pending: 0,
+        running: 0,
+        succeeded: 0,
+        noOp: 0,
+        skipped: 0,
+        conflicted: 0,
+        failed: 0,
+        cancelled: 0,
+    },
+    reasons: [],
+    warnings: [],
+    samples: [],
+    limits: {
+        maxTargets: CONFIGURATION_DEFAULTS.bulkMaxTargets,
+        executionLifetimeSeconds: CONFIGURATION_DEFAULTS.bulkExecutionLifetimeSeconds,
+        previewLifetimeSeconds: CONFIGURATION_DEFAULTS.bulkPreviewLifetimeSeconds,
+        resultRetentionSeconds: CONFIGURATION_DEFAULTS.bulkResultRetentionSeconds,
+        batchSize: CONFIGURATION_DEFAULTS.bulkBatchSize,
+        workerConcurrency: CONFIGURATION_DEFAULTS.bulkWorkerConcurrency,
+    },
+    billing: {
+        additionalAttemptsMinimum: 0,
+        exactChargeKnown: false,
+        note: "Ordinary per-attempt billing and quota admission apply; preview creates no delivery or charge.",
+    },
+};
+const runtime = globalThis;
+const requestOnly = runtime.GREATWAIT_API_REQUEST_REGISTRY;
+const contractsOnly = runtime.GREATWAIT_RUNTIME_CONTRACTS_ONLY;
+const withoutExamples = runtime.GREATWAIT_RUNTIME_WITHOUT_EXAMPLES;
+const shared = {
+    principals: ["api-credential", "oauth", "session"],
+    scopes: [],
+    sessionAuthority: "headers",
+    surfaces: ["api", "mock"],
+    problems: ["invalid_request", "not_found", "service_unavailable"],
+    mcp: { kind: "tool", destructive: false, openWorld: false },
+};
+/** Resolved action scopes from BULK_OPERATION_REGISTRY are mandatory on every endpoint. */
+export const BULK_API_OPERATIONS = defineOperations([
+    {
+        ...shared,
+        id: "bulk.preview",
+        problems: [...shared.problems, "plan_limit_reached"],
+        method: "POST",
+        path: "/v1/bulk/jobs",
+        creates: true,
+        mutates: true,
+        idempotent: false,
+        summary: requestOnly ? "" : "Preview a bulk operation",
+        description: contractsOnly
+            ? ""
+            : "Prepares one bounded frozen selection for retry, cancel, reschedule, pause or resume. Requires the selected action's ordinary scopes and execution reads for parent mapping. Preview creates no deliveries, lifecycle mutations or billable attempts. Only complete awaiting_confirmation jobs may be confirmed.",
+        request: bulkPreviewRequestSchema,
+        requestExample: withoutExamples ? {} : exampleIntent,
+        response: runtime.GREATWAIT_API_REQUEST_REGISTRY
+            ? API_UNUSED_RESPONSE_SCHEMA
+            : bulkJobSchema,
+        example: runtime.GREATWAIT_RUNTIME_WITHOUT_EXAMPLES ? {} : exampleJob,
+    },
+    {
+        ...shared,
+        id: "bulk.confirm",
+        problems: [
+            ...shared.problems,
+            "state_conflict",
+            "version_conflict",
+            "idempotency_key_reused",
+            "plan_limit_reached",
+        ],
+        method: "POST",
+        path: "/v1/bulk/jobs/{jobId}/confirm",
+        creates: false,
+        mutates: true,
+        idempotent: true,
+        mcp: { kind: "tool", destructive: true, openWorld: true },
+        summary: requestOnly ? "" : "Confirm an exact bulk preview",
+        description: contractsOnly
+            ? ""
+            : "Confirms the complete unexpired frozen target manifest by intent digest and explicit acknowledgment. Requires Idempotency-Key, the action's current scopes, and duplicate-effect acknowledgment for retry. Changed resources conflict; repeated identical submissions return the same job without applying work twice.",
+        request: bulkConfirmRequestSchema,
+        requestHeaders: requiredIdempotencyRequestHeaderSchema,
+        requestExample: withoutExamples
+            ? {}
+            : {
+                intentDigest: "a".repeat(64),
+                confirmed: true,
+                acknowledgeDuplicateEffects: false,
+            },
+        response: runtime.GREATWAIT_API_REQUEST_REGISTRY
+            ? API_UNUSED_RESPONSE_SCHEMA
+            : bulkJobSchema,
+        example: runtime.GREATWAIT_RUNTIME_WITHOUT_EXAMPLES
+            ? {}
+            : { ...exampleJob, state: "queued" },
+    },
+    {
+        ...shared,
+        id: "bulk.read",
+        method: "GET",
+        path: "/v1/bulk/jobs/{jobId}",
+        creates: false,
+        mutates: false,
+        idempotent: true,
+        summary: requestOnly ? "" : "Read bulk preview or job progress",
+        description: contractsOnly
+            ? ""
+            : "Reads one scoped job, exact counts when preparation is complete, limits, warnings and reconciled durable outcomes. Requires the resolved action's current scopes; job records contain no callback payloads or secrets.",
+        response: runtime.GREATWAIT_API_REQUEST_REGISTRY
+            ? API_UNUSED_RESPONSE_SCHEMA
+            : bulkJobSchema,
+        example: runtime.GREATWAIT_RUNTIME_WITHOUT_EXAMPLES ? {} : exampleJob,
+    },
+    {
+        ...shared,
+        id: "bulk.list",
+        method: "GET",
+        path: "/v1/bulk/jobs",
+        creates: false,
+        mutates: false,
+        idempotent: true,
+        summary: requestOnly ? "" : "List authorized bulk jobs",
+        description: contractsOnly
+            ? ""
+            : "Lists retained jobs in the current authority; only jobs whose action remains authorized are visible. Pagination is cursor based and bound to authority and state.",
+        query: bulkListRequestSchema,
+        response: runtime.GREATWAIT_API_REQUEST_REGISTRY
+            ? API_UNUSED_RESPONSE_SCHEMA
+            : bulkJobPageSchema,
+        example: runtime.GREATWAIT_RUNTIME_WITHOUT_EXAMPLES
+            ? {}
+            : { data: [exampleJob] },
+    },
+    {
+        ...shared,
+        id: "bulk.items",
+        method: "GET",
+        path: "/v1/bulk/jobs/{jobId}/items",
+        creates: false,
+        mutates: false,
+        idempotent: true,
+        summary: requestOnly ? "" : "Inspect frozen bulk targets and results",
+        description: contractsOnly
+            ? ""
+            : "Pages through the frozen manifest and secret-safe item outcomes. Requires the resolved action's current scopes. Cursors bind this job and item-state filter; retained history cutoffs still apply.",
+        query: bulkItemListRequestSchema,
+        response: runtime.GREATWAIT_API_REQUEST_REGISTRY
+            ? API_UNUSED_RESPONSE_SCHEMA
+            : bulkItemPageSchema,
+        example: withoutExamples ? {} : { data: [] },
+    },
+    ...["pause", "resume", "cancel"].map((action) => ({
+        ...shared,
+        id: `bulk.${action}`,
+        problems: [
+            ...shared.problems,
+            "state_conflict",
+            "version_conflict",
+        ],
+        method: "POST",
+        path: `/v1/bulk/jobs/{jobId}/${action}`,
+        creates: false,
+        mutates: true,
+        idempotent: true,
+        mcp: { kind: "tool", destructive: true, openWorld: false },
+        summary: requestOnly
+            ? ""
+            : `${action[0].toUpperCase()}${action.slice(1)} a bulk job`,
+        description: contractsOnly
+            ? ""
+            : `Controls remaining bulk-job work with a mandatory expectedVersion fence and current resolved-action authorization. ${action === "resume" ? "Keeps the confirmed manifest and retries only eligible unfinished transient work." : "Already-started items may finish; completed callbacks and history remain."} This does not ${action} the selected schedules.`,
+        request: bulkControlRequestSchema,
+        requestExample: withoutExamples ? {} : { expectedVersion: 1 },
+        response: runtime.GREATWAIT_API_REQUEST_REGISTRY
+            ? API_UNUSED_RESPONSE_SCHEMA
+            : bulkJobSchema,
+        example: runtime.GREATWAIT_RUNTIME_WITHOUT_EXAMPLES
+            ? {}
+            : {
+                ...exampleJob,
+                state: action === "resume"
+                    ? "queued"
+                    : action === "pause"
+                        ? "paused"
+                        : "cancelled",
+            },
+    })),
+]);

package/dist/configuration-bounds.d.ts

@@ -11,3 +11,15 @@ export declare const PUBLIC_PAGE_SIZE: Readonly<{
     max: 100;
     min: 1;
 }>;
+/** Transport/engineering envelopes; effective bulk policy is layered configuration. */
+export declare const BULK_CONFIGURATION_MAXIMA: Readonly<{
+    bulkMaxTargets: 1000000;
+    bulkExecutionLifetimeSeconds: 31536000;
+    bulkPreviewLifetimeSeconds: 86400;
+    bulkResultRetentionSeconds: 31536000;
+    bulkBatchSize: 100;
+    bulkWorkerConcurrency: 25;
+    bulkActiveJobLimit: 25;
+    bulkWorkBudgetSeconds: 30;
+    bulkCarrierBatchSize: 1000;
+}>;

package/dist/configuration-bounds.js

@@ -11,3 +11,15 @@ export const PUBLIC_PAGE_SIZE = Object.freeze({
     max: 100,
     min: 1,
 });
+/** Transport/engineering envelopes; effective bulk policy is layered configuration. */
+export const BULK_CONFIGURATION_MAXIMA = Object.freeze({
+    bulkMaxTargets: 1_000_000,
+    bulkExecutionLifetimeSeconds: 31_536_000,
+    bulkPreviewLifetimeSeconds: 86_400,
+    bulkResultRetentionSeconds: 31_536_000,
+    bulkBatchSize: 100,
+    bulkWorkerConcurrency: 25,
+    bulkActiveJobLimit: 25,
+    bulkWorkBudgetSeconds: 30,
+    bulkCarrierBatchSize: 1_000,
+});