@kitman-sh/loops 0.0.0-stage → 0.7.0

package/types/packages/core/src/schedule.d.ts

@@ -0,0 +1,136 @@
+import * as Schema from 'effect/Schema';
+import type { TriggerIngress } from './trigger-dispatch';
+import { SafeJson } from './run';
+export declare const ScheduleMisfirePolicies: readonly ['skip', 'fire_once', 'catch_up'];
+export type ScheduleMisfirePolicy = (typeof ScheduleMisfirePolicies)[number];
+export declare const ScheduleOverlapPolicies: readonly ['allow', 'skip', 'coalesce'];
+export type ScheduleOverlapPolicy = (typeof ScheduleOverlapPolicies)[number];
+export declare const ScheduleVersionStatuses: readonly ['draft', 'published', 'disabled', 'archived'];
+declare const ScheduleDispositions: readonly ['on_time', 'catch_up', 'catch_up_bounded', 'misfire_skipped', 'dst_gap_skipped', 'overlap_skipped', 'overlap_coalesced'];
+export type ScheduleDisposition = (typeof ScheduleDispositions)[number];
+export declare const ScheduleRule: Schema.Union<readonly [Schema.Struct<{
+    readonly frequency: Schema.Literals<readonly ["daily", "weekly"]>;
+    readonly hour: Schema.Int;
+    readonly minute: Schema.Int;
+    readonly second: Schema.optionalKey<Schema.Int>;
+    readonly daysOfWeek: Schema.optionalKey<Schema.$Array<Schema.Int>>;
+}>, Schema.Struct<{
+    readonly cron: Schema.String;
+}>]>;
+export type ScheduleRule = (typeof ScheduleRule)['Type'];
+/** Whether `value` is a Schedule rule: a calendar rule, or cron whose every field is in range. */
+export declare function isScheduleRule(value: unknown): value is ScheduleRule;
+export declare const ScheduleVersion: Schema.Struct<{
+    readonly contractVersion: Schema.Literal<"schedule.v1">;
+    readonly id: Schema.String;
+    readonly scheduleId: Schema.String;
+    readonly workspaceId: Schema.String;
+    readonly projectId: Schema.optionalKey<Schema.String>;
+    /** New versions bind one stable Loop; historical rows may not have a binding. */
+    readonly loopId: Schema.optionalKey<Schema.String>;
+    readonly name: Schema.optionalKey<Schema.String>;
+    readonly version: Schema.Int;
+    readonly status: Schema.Literals<readonly ["draft", "published", "disabled", "archived"]>;
+    readonly timezone: Schema.String;
+    readonly rule: Schema.Union<readonly [Schema.Struct<{
+        readonly frequency: Schema.Literals<readonly ["daily", "weekly"]>;
+        readonly hour: Schema.Int;
+        readonly minute: Schema.Int;
+        readonly second: Schema.optionalKey<Schema.Int>;
+        readonly daysOfWeek: Schema.optionalKey<Schema.$Array<Schema.Int>>;
+    }>, Schema.Struct<{
+        readonly cron: Schema.String;
+    }>]>;
+    readonly misfirePolicy: Schema.Literals<readonly ["skip", "fire_once", "catch_up"]>;
+    readonly overlapPolicy: Schema.Literals<readonly ["allow", "skip", "coalesce"]>;
+    readonly maxCatchUp: Schema.Int;
+    readonly misfireGraceSeconds: Schema.optionalKey<Schema.Int>;
+    readonly inputSchemaRef: Schema.optionalKey<Schema.Struct<{
+        readonly kind: Schema.Literal<"typebox_ref">;
+        readonly name: Schema.String;
+        readonly version: Schema.optionalKey<Schema.String>;
+        readonly sha256: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly input: Schema.optionalKey<Schema.Codec<SafeJson, SafeJson, never, never>>;
+    readonly createdAt: Schema.String;
+}>;
+export type ScheduleVersion = (typeof ScheduleVersion)['Type'];
+export interface ScheduleCursor {
+    readonly lastEvaluatedAt?: string;
+    readonly lastFireKey?: string;
+    readonly resourceVersion?: number;
+}
+export declare function scheduleDefinitionDigest(version: Pick<ScheduleVersion, 'timezone' | 'rule' | 'misfirePolicy' | 'overlapPolicy' | 'maxCatchUp' | 'misfireGraceSeconds' | 'loopId'> & Partial<Pick<ScheduleVersion, 'status' | 'inputSchemaRef' | 'input' | 'name'>>): string;
+interface FireIdentityInput {
+    readonly scheduleId: string;
+    readonly scheduleVersion: number;
+    readonly bindingId: string;
+    readonly localDate: string;
+    readonly localTime: string;
+    readonly fold: 0 | 1;
+}
+export declare function fireIdentity(input: FireIdentityInput): string;
+type ResolvedLocalDateTime = {
+    readonly kind: 'gap';
+    readonly instants: readonly [];
+} | {
+    readonly kind: 'unique';
+    readonly instants: readonly [Date];
+} | {
+    readonly kind: 'fold';
+    readonly instants: readonly [Date, Date];
+};
+/**
+ * Resolve a wall-clock time without silently normalizing gaps or folds. Each Schedule Host tick re-enumerates the days
+ * around now for every Schedule, and each resolution costs several Intl calls, so resolutions are kept.
+ */
+export declare function resolveLocalDateTime(timezone: string, date: string, time: string): ResolvedLocalDateTime;
+export interface ScheduleCandidate {
+    readonly fireKey: string;
+    readonly scheduleId: string;
+    readonly scheduleVersion: number;
+    readonly bindingId: string;
+    readonly timezone: string;
+    readonly localDate: string;
+    readonly localTime: string;
+    readonly fold: 0 | 1;
+    readonly scheduledAt?: string;
+    readonly resolution: 'unique' | 'fold' | 'gap';
+}
+/**
+ * Create one explicit test occurrence without advancing or colliding with the
+ * Schedule's normal calendar binding. Repeating a request with the same key
+ * produces the same durable Event identity.
+ */
+export declare function scheduleTestCandidate(input: {
+    readonly version: ScheduleVersion;
+    readonly idempotencyKey: string;
+    readonly requestedAt: string;
+}): ScheduleCandidate;
+/** Enumerate deterministic local-time candidates. Fold candidates are deliberately separate fires. */
+export declare function enumerateScheduleCandidates(input: {
+    readonly version: ScheduleVersion;
+    readonly bindingId: string;
+    readonly from: string;
+    readonly to: string;
+}): readonly ScheduleCandidate[];
+export interface ScheduleDecision extends ScheduleCandidate {
+    readonly disposition: ScheduleDisposition;
+    readonly shouldIngress: boolean;
+}
+export declare function planSchedule(input: {
+    readonly version: ScheduleVersion;
+    readonly candidates: readonly ScheduleCandidate[];
+    readonly now: string;
+    readonly cursor: ScheduleCursor;
+    readonly activeBindingRuns?: ReadonlySet<string>;
+}): readonly ScheduleDecision[];
+export declare function scheduleTriggerIngress(input: {
+    readonly version: ScheduleVersion;
+    readonly candidate: ScheduleCandidate;
+    readonly loopId: string;
+    readonly projectId?: string;
+    readonly receivedAt: string;
+    readonly misfireDisposition?: 'on_time' | 'catch_up' | 'coalesced';
+}): TriggerIngress;
+export {};

package/types/packages/core/src/schema.d.ts

@@ -0,0 +1,89 @@
+import * as JsonSchema from 'effect/JsonSchema';
+import * as Schema from 'effect/Schema';
+import type { StandardSchemaV1 } from 'effect/StandardSchema';
+import { type JsonObject, type JsonValue } from './runtime-type';
+/** An RFC 3339 date-time string with a zone, as JSON Schema's `date-time` format requires. */
+export declare const isDateTime: import("effect/SchemaAST").Filter<string>;
+/** A number, or a numeric string read as one, as a query or a JSON body may carry it. */
+export declare const Numeric: Schema.Union<readonly [Schema.Finite, Schema.FiniteFromString]>;
+/**
+ * A whole `Numeric`. Its JSON Schema is `multipleOf: 1`, which holds for the string a query carries where `isInt`'s
+ * `type: integer` would not.
+ */
+export declare const isWholeNumber: import("effect/SchemaAST").Filter<number>;
+/**
+ * A type guard that holds only when `input` already is a `schema` value, without properties the schema does not model,
+ * as a TypeBox `Check` of a closed object did: no transformation or decoding default applies.
+ */
+export declare function guard<S extends Schema.ConstraintDecoder<unknown>>(schema: S): <I>(input: I) => input is I & S['Type'];
+/** `Schema.toStandardSchemaV1(schema)`, with a passing value decoded synchronously first. */
+export declare function standardSchemaV1<S extends Schema.ConstraintDecoder<unknown>>(schema: S): StandardSchemaV1<S["Encoded"], S["Type"]> & S & {
+    '~standard': {
+        version: 1;
+        vendor: string;
+        types?: import("effect/StandardSchema").StandardTypedV1.Types<S["Encoded"], S["Type"]> | undefined;
+        validate: <Value>(value: Value) => Promise<StandardSchemaV1.Result<S["Type"]>> | StandardSchemaV1.Result<S["Type"]>;
+    };
+};
+/** The JSON Schema (draft 2020-12) of `schema`, with objects closed to the properties they model. */
+export declare function jsonSchema(schema: Schema.Top): JsonSchema.JsonSchema;
+/**
+ * `value` with every `$defs` entry inside it moved out to `definitions`, and its `#/$defs/` refs pointed at `prefix`. A
+ * ref resolves against the whole document, so once a schema that carries its own `$defs` is embedded in a larger one,
+ * such as an OpenAPI operation, its refs hold only after the entries sit where `prefix` names. Each schema names its
+ * entries on its own, so an entry that would replace a different one under the same name, `known` ones included, moves
+ * under a new name.
+ */
+export declare function hoistDefinitions(value: JsonValue, prefix: string, known?: JsonObject): {
+    value: JsonValue;
+    definitions: {
+        [k: string]: JsonValue;
+    };
+};
+/**
+ * `schema` as a Standard Schema validator with its JSON Schema, for Elysia routes and their OpenAPI. Validation strips
+ * properties the schema does not model; the JSON Schema closes objects, as the TypeBox contracts did. An invalid value
+ * answers `status`, 400 as TypeBox routes did, with `refused` in place of the message, which otherwise quotes the
+ * value. The validator is a copy, so the shared schema stays as it is.
+ */
+export declare function standard<S extends Schema.Top & Schema.ConstraintDecoder<unknown>>(schema: S, options?: {
+    readonly refused?: string;
+    readonly status?: number;
+}): StandardSchemaV1<S["Encoded"], S["Type"]> & S & {
+    invalidStatus: number;
+    refused?: string;
+    '~standard': {
+        version: 1;
+        vendor: string;
+        types?: import("effect/StandardSchema").StandardTypedV1.Types<S["Encoded"], S["Type"]> | undefined;
+        validate: <Value>(value: Value) => Promise<StandardSchemaV1.Result<S["Type"]>> | StandardSchemaV1.Result<S["Type"]>;
+        jsonSchema: {
+            input: (target: {
+                readonly target: string;
+            }) => JsonSchema.JsonSchema;
+            output: (target: {
+                readonly target: string;
+            }) => JsonSchema.JsonSchema;
+        };
+    };
+};
+/**
+ * `schema` as an Elysia response validator: the handler's value encodes to what the wire carries, without properties
+ * the schema does not model, and the JSON Schema on both sides is that encoded form.
+ */
+export declare function standardResponse<S extends Schema.Top & Schema.ConstraintEncoder<unknown>>(schema: S): StandardSchemaV1<(S extends Schema.flip<infer F extends Schema.Top> ? F["Rebuild"] : Schema.flip<S>)["Encoded"], (S extends Schema.flip<infer F extends Schema.Top> ? F["Rebuild"] : Schema.flip<S>)["Type"]> & (S extends Schema.flip<infer F extends Schema.Top> ? F["Rebuild"] : Schema.flip<S>) & {
+    '~standard': {
+        version: 1;
+        vendor: string;
+        types?: import("effect/StandardSchema").StandardTypedV1.Types<(S extends Schema.flip<infer F extends Schema.Top> ? F["Rebuild"] : Schema.flip<S>)["Encoded"], (S extends Schema.flip<infer F extends Schema.Top> ? F["Rebuild"] : Schema.flip<S>)["Type"]> | undefined;
+        validate: <Value>(value: Value) => Promise<StandardSchemaV1.Result<(S extends Schema.flip<infer F extends Schema.Top> ? F["Rebuild"] : Schema.flip<S>)["Type"]>> | StandardSchemaV1.Result<(S extends Schema.flip<infer F extends Schema.Top> ? F["Rebuild"] : Schema.flip<S>)["Type"]>;
+        jsonSchema: {
+            input: (options: {
+                readonly target: string;
+            }) => JsonSchema.JsonSchema;
+            output: (options: {
+                readonly target: string;
+            }) => JsonSchema.JsonSchema;
+        };
+    };
+};

package/types/packages/core/src/trigger-dispatch.d.ts

@@ -0,0 +1,421 @@
+import * as Schema from 'effect/Schema';
+import { SafeJson } from './run';
+declare const TriggerSourceKinds: readonly ['manual', 'domain', 'webhook', 'schedule', 'message', 'result', 'parent', 'child'];
+export type TriggerSourceKind = (typeof TriggerSourceKinds)[number];
+export declare const TriggerSourceKind: Schema.Literals<readonly ["manual", "domain", "webhook", "schedule", "message", "result", "parent", "child"]>;
+export declare const TriggerSource: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"manual">;
+    readonly actor: Schema.Struct<{
+        readonly actorType: Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"human">, Schema.Literal<"delegated_agent">, Schema.Literal<"agent">]>, Schema.Literal<"runner">]>;
+        readonly actorId: Schema.String;
+        readonly delegatedByUserId: Schema.optionalKey<Schema.String>;
+        readonly agentIdentityId: Schema.optionalKey<Schema.String>;
+        readonly runnerId: Schema.optionalKey<Schema.String>;
+    }>;
+    readonly requestId: Schema.String;
+    readonly requestIdempotencyKey: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"domain">;
+    readonly producer: Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly id: Schema.String;
+    }>;
+    readonly transactionId: Schema.String;
+    readonly eventId: Schema.String;
+    readonly aggregate: Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly id: Schema.String;
+    }>;
+    readonly aggregateVersion: Schema.optionalKey<Schema.Int>;
+    readonly outboxSequence: Schema.optionalKey<Schema.String>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"webhook">;
+    readonly integrationId: Schema.String;
+    readonly provider: Schema.String;
+    readonly host: Schema.optionalKey<Schema.String>;
+    readonly deliveryId: Schema.optionalKey<Schema.String>;
+    readonly normalizedEventName: Schema.String;
+    readonly bodyDigest: Schema.String;
+    readonly signature: Schema.Struct<{
+        readonly scheme: Schema.Union<readonly [Schema.Literal<"hmac">, Schema.Literal<"asymmetric">, Schema.Literal<"provider_verified">]>;
+        readonly keyRef: Schema.String;
+        readonly verified: Schema.Literal<true>;
+        readonly verifiedAt: Schema.String;
+        readonly bodyDigest: Schema.String;
+        readonly replayWindowSeconds: Schema.optionalKey<Schema.Int>;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"schedule">;
+    readonly scheduleId: Schema.String;
+    readonly scheduleVersion: Schema.Int;
+    readonly bindingId: Schema.String;
+    readonly fireIndex: Schema.String;
+    readonly scheduledAt: Schema.String;
+    readonly timezone: Schema.String;
+    readonly misfireDisposition: Schema.Union<readonly [Schema.Literal<"on_time">, Schema.Literal<"catch_up">, Schema.Literal<"coalesced">]>;
+    readonly coalescedRange: Schema.optionalKey<Schema.Struct<{
+        readonly firstScheduledAt: Schema.String;
+        readonly lastScheduledAt: Schema.String;
+        readonly count: Schema.Int;
+    }>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"message">;
+    readonly messageId: Schema.String;
+    readonly streamKey: Schema.String;
+    readonly sequence: Schema.Int;
+    readonly recipient: Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly id: Schema.String;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"result">;
+    readonly resultId: Schema.String;
+    readonly runId: Schema.String;
+    readonly outcome: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"parent">;
+    readonly runLinkId: Schema.String;
+    readonly parentRunId: Schema.String;
+    readonly childRunId: Schema.String;
+    readonly relation: Schema.Union<readonly [Schema.Literal<"awaited_child">, Schema.Literal<"detached_child">]>;
+    readonly childOutcome: Schema.optionalKey<Schema.String>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"child">;
+    readonly parentRunId: Schema.String;
+    readonly rootRunId: Schema.String;
+    readonly parentStepKey: Schema.String;
+    readonly parentAttempt: Schema.Int;
+    readonly loopVersionId: Schema.String;
+    readonly requestId: Schema.String;
+}>]>;
+export type TriggerSource = (typeof TriggerSource)['Type'];
+export declare const Event: Schema.Struct<{
+    readonly contractVersion: Schema.Literal<"run.v1">;
+    readonly id: Schema.String;
+    readonly workspaceId: Schema.String;
+    readonly projectId: Schema.optionalKey<Schema.String>;
+    readonly sourceKind: Schema.Literals<readonly ["manual", "domain", "webhook", "schedule", "message", "result", "parent", "child"]>;
+    readonly eventType: Schema.String;
+    readonly source: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"manual">;
+        readonly actor: Schema.Struct<{
+            readonly actorType: Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"human">, Schema.Literal<"delegated_agent">, Schema.Literal<"agent">]>, Schema.Literal<"runner">]>;
+            readonly actorId: Schema.String;
+            readonly delegatedByUserId: Schema.optionalKey<Schema.String>;
+            readonly agentIdentityId: Schema.optionalKey<Schema.String>;
+            readonly runnerId: Schema.optionalKey<Schema.String>;
+        }>;
+        readonly requestId: Schema.String;
+        readonly requestIdempotencyKey: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"domain">;
+        readonly producer: Schema.Struct<{
+            readonly kind: Schema.String;
+            readonly id: Schema.String;
+        }>;
+        readonly transactionId: Schema.String;
+        readonly eventId: Schema.String;
+        readonly aggregate: Schema.Struct<{
+            readonly kind: Schema.String;
+            readonly id: Schema.String;
+        }>;
+        readonly aggregateVersion: Schema.optionalKey<Schema.Int>;
+        readonly outboxSequence: Schema.optionalKey<Schema.String>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"webhook">;
+        readonly integrationId: Schema.String;
+        readonly provider: Schema.String;
+        readonly host: Schema.optionalKey<Schema.String>;
+        readonly deliveryId: Schema.optionalKey<Schema.String>;
+        readonly normalizedEventName: Schema.String;
+        readonly bodyDigest: Schema.String;
+        readonly signature: Schema.Struct<{
+            readonly scheme: Schema.Union<readonly [Schema.Literal<"hmac">, Schema.Literal<"asymmetric">, Schema.Literal<"provider_verified">]>;
+            readonly keyRef: Schema.String;
+            readonly verified: Schema.Literal<true>;
+            readonly verifiedAt: Schema.String;
+            readonly bodyDigest: Schema.String;
+            readonly replayWindowSeconds: Schema.optionalKey<Schema.Int>;
+        }>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"schedule">;
+        readonly scheduleId: Schema.String;
+        readonly scheduleVersion: Schema.Int;
+        readonly bindingId: Schema.String;
+        readonly fireIndex: Schema.String;
+        readonly scheduledAt: Schema.String;
+        readonly timezone: Schema.String;
+        readonly misfireDisposition: Schema.Union<readonly [Schema.Literal<"on_time">, Schema.Literal<"catch_up">, Schema.Literal<"coalesced">]>;
+        readonly coalescedRange: Schema.optionalKey<Schema.Struct<{
+            readonly firstScheduledAt: Schema.String;
+            readonly lastScheduledAt: Schema.String;
+            readonly count: Schema.Int;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"message">;
+        readonly messageId: Schema.String;
+        readonly streamKey: Schema.String;
+        readonly sequence: Schema.Int;
+        readonly recipient: Schema.Struct<{
+            readonly kind: Schema.String;
+            readonly id: Schema.String;
+        }>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"result">;
+        readonly resultId: Schema.String;
+        readonly runId: Schema.String;
+        readonly outcome: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"parent">;
+        readonly runLinkId: Schema.String;
+        readonly parentRunId: Schema.String;
+        readonly childRunId: Schema.String;
+        readonly relation: Schema.Union<readonly [Schema.Literal<"awaited_child">, Schema.Literal<"detached_child">]>;
+        readonly childOutcome: Schema.optionalKey<Schema.String>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"child">;
+        readonly parentRunId: Schema.String;
+        readonly rootRunId: Schema.String;
+        readonly parentStepKey: Schema.String;
+        readonly parentAttempt: Schema.Int;
+        readonly loopVersionId: Schema.String;
+        readonly requestId: Schema.String;
+    }>]>;
+    readonly auth: Schema.Union<readonly [Schema.Struct<{
+        readonly mode: Schema.Literal<"actor">;
+        readonly actor: Schema.Struct<{
+            readonly actorType: Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"human">, Schema.Literal<"delegated_agent">, Schema.Literal<"agent">]>, Schema.Literal<"runner">]>;
+            readonly actorId: Schema.String;
+            readonly delegatedByUserId: Schema.optionalKey<Schema.String>;
+            readonly agentIdentityId: Schema.optionalKey<Schema.String>;
+            readonly runnerId: Schema.optionalKey<Schema.String>;
+        }>;
+    }>, Schema.Struct<{
+        readonly mode: Schema.Literal<"transactional_outbox">;
+        readonly producer: Schema.Struct<{
+            readonly kind: Schema.String;
+            readonly id: Schema.String;
+        }>;
+        readonly transactionId: Schema.String;
+    }>, Schema.Struct<{
+        readonly mode: Schema.Literal<"verified_signature">;
+        readonly signature: Schema.Struct<{
+            readonly scheme: Schema.Union<readonly [Schema.Literal<"hmac">, Schema.Literal<"asymmetric">, Schema.Literal<"provider_verified">]>;
+            readonly keyRef: Schema.String;
+            readonly verified: Schema.Literal<true>;
+            readonly verifiedAt: Schema.String;
+            readonly bodyDigest: Schema.String;
+            readonly replayWindowSeconds: Schema.optionalKey<Schema.Int>;
+        }>;
+    }>, Schema.Struct<{
+        readonly mode: Schema.Literal<"scheduler">;
+        readonly scheduleId: Schema.String;
+        readonly scheduleVersion: Schema.Int;
+    }>, Schema.Struct<{
+        readonly mode: Schema.Literal<"canonical_run_transition">;
+        readonly subject: Schema.Struct<{
+            readonly kind: Schema.String;
+            readonly id: Schema.String;
+        }>;
+        readonly eventId: Schema.String;
+    }>]>;
+    readonly subject: Schema.optionalKey<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly id: Schema.String;
+    }>>;
+    readonly correlation: Schema.$Record<Schema.String, Schema.Codec<SafeJson, SafeJson, never, never>>;
+    readonly occurredAt: Schema.String;
+    readonly receivedAt: Schema.String;
+    readonly ordering: Schema.Struct<{
+        readonly key: Schema.String;
+        readonly guarantee: Schema.Union<readonly [Schema.Literal<"transaction">, Schema.Literal<"source">, Schema.Literal<"provider">, Schema.Literal<"arrival">, Schema.Literal<"none">]>;
+        readonly sourcePosition: Schema.optionalKey<Schema.String>;
+        readonly predecessorPosition: Schema.optionalKey<Schema.String>;
+        readonly gapPolicy: Schema.Union<readonly [Schema.Literal<"wait">, Schema.Literal<"process_arrival">, Schema.Literal<"block_manual">]>;
+    }>;
+    readonly payload: Schema.Struct<{
+        readonly schema: Schema.Struct<{
+            readonly kind: Schema.Literal<"typebox_ref">;
+            readonly name: Schema.String;
+            readonly version: Schema.String;
+            readonly sha256: Schema.String;
+        }>;
+        readonly data: Schema.Codec<SafeJson, SafeJson, never, never>;
+        readonly digest: Schema.String;
+    }>;
+    readonly deduplication: Schema.Struct<{
+        readonly scope: Schema.String;
+        readonly keyDigest: Schema.String;
+        readonly basis: Schema.Union<readonly [Schema.Literal<"actor_idempotency">, Schema.Literal<"transaction_event">, Schema.Literal<"provider_delivery">, Schema.Literal<"provider_body_digest">, Schema.Literal<"schedule_fire">, Schema.Literal<"message_id">, Schema.Literal<"result_id">, Schema.Literal<"run_link_id">, Schema.Literal<"child_call">]>;
+    }>;
+    readonly createdAt: Schema.String;
+}>;
+export type Event = (typeof Event)['Type'];
+export declare const TriggerIngress: Schema.Struct<{
+    readonly event: Schema.Struct<{
+        readonly contractVersion: Schema.Literal<"run.v1">;
+        readonly id: Schema.String;
+        readonly workspaceId: Schema.String;
+        readonly projectId: Schema.optionalKey<Schema.String>;
+        readonly sourceKind: Schema.Literals<readonly ["manual", "domain", "webhook", "schedule", "message", "result", "parent", "child"]>;
+        readonly eventType: Schema.String;
+        readonly source: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"manual">;
+            readonly actor: Schema.Struct<{
+                readonly actorType: Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"human">, Schema.Literal<"delegated_agent">, Schema.Literal<"agent">]>, Schema.Literal<"runner">]>;
+                readonly actorId: Schema.String;
+                readonly delegatedByUserId: Schema.optionalKey<Schema.String>;
+                readonly agentIdentityId: Schema.optionalKey<Schema.String>;
+                readonly runnerId: Schema.optionalKey<Schema.String>;
+            }>;
+            readonly requestId: Schema.String;
+            readonly requestIdempotencyKey: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"domain">;
+            readonly producer: Schema.Struct<{
+                readonly kind: Schema.String;
+                readonly id: Schema.String;
+            }>;
+            readonly transactionId: Schema.String;
+            readonly eventId: Schema.String;
+            readonly aggregate: Schema.Struct<{
+                readonly kind: Schema.String;
+                readonly id: Schema.String;
+            }>;
+            readonly aggregateVersion: Schema.optionalKey<Schema.Int>;
+            readonly outboxSequence: Schema.optionalKey<Schema.String>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"webhook">;
+            readonly integrationId: Schema.String;
+            readonly provider: Schema.String;
+            readonly host: Schema.optionalKey<Schema.String>;
+            readonly deliveryId: Schema.optionalKey<Schema.String>;
+            readonly normalizedEventName: Schema.String;
+            readonly bodyDigest: Schema.String;
+            readonly signature: Schema.Struct<{
+                readonly scheme: Schema.Union<readonly [Schema.Literal<"hmac">, Schema.Literal<"asymmetric">, Schema.Literal<"provider_verified">]>;
+                readonly keyRef: Schema.String;
+                readonly verified: Schema.Literal<true>;
+                readonly verifiedAt: Schema.String;
+                readonly bodyDigest: Schema.String;
+                readonly replayWindowSeconds: Schema.optionalKey<Schema.Int>;
+            }>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"schedule">;
+            readonly scheduleId: Schema.String;
+            readonly scheduleVersion: Schema.Int;
+            readonly bindingId: Schema.String;
+            readonly fireIndex: Schema.String;
+            readonly scheduledAt: Schema.String;
+            readonly timezone: Schema.String;
+            readonly misfireDisposition: Schema.Union<readonly [Schema.Literal<"on_time">, Schema.Literal<"catch_up">, Schema.Literal<"coalesced">]>;
+            readonly coalescedRange: Schema.optionalKey<Schema.Struct<{
+                readonly firstScheduledAt: Schema.String;
+                readonly lastScheduledAt: Schema.String;
+                readonly count: Schema.Int;
+            }>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"message">;
+            readonly messageId: Schema.String;
+            readonly streamKey: Schema.String;
+            readonly sequence: Schema.Int;
+            readonly recipient: Schema.Struct<{
+                readonly kind: Schema.String;
+                readonly id: Schema.String;
+            }>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"result">;
+            readonly resultId: Schema.String;
+            readonly runId: Schema.String;
+            readonly outcome: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"parent">;
+            readonly runLinkId: Schema.String;
+            readonly parentRunId: Schema.String;
+            readonly childRunId: Schema.String;
+            readonly relation: Schema.Union<readonly [Schema.Literal<"awaited_child">, Schema.Literal<"detached_child">]>;
+            readonly childOutcome: Schema.optionalKey<Schema.String>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"child">;
+            readonly parentRunId: Schema.String;
+            readonly rootRunId: Schema.String;
+            readonly parentStepKey: Schema.String;
+            readonly parentAttempt: Schema.Int;
+            readonly loopVersionId: Schema.String;
+            readonly requestId: Schema.String;
+        }>]>;
+        readonly auth: Schema.Union<readonly [Schema.Struct<{
+            readonly mode: Schema.Literal<"actor">;
+            readonly actor: Schema.Struct<{
+                readonly actorType: Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"human">, Schema.Literal<"delegated_agent">, Schema.Literal<"agent">]>, Schema.Literal<"runner">]>;
+                readonly actorId: Schema.String;
+                readonly delegatedByUserId: Schema.optionalKey<Schema.String>;
+                readonly agentIdentityId: Schema.optionalKey<Schema.String>;
+                readonly runnerId: Schema.optionalKey<Schema.String>;
+            }>;
+        }>, Schema.Struct<{
+            readonly mode: Schema.Literal<"transactional_outbox">;
+            readonly producer: Schema.Struct<{
+                readonly kind: Schema.String;
+                readonly id: Schema.String;
+            }>;
+            readonly transactionId: Schema.String;
+        }>, Schema.Struct<{
+            readonly mode: Schema.Literal<"verified_signature">;
+            readonly signature: Schema.Struct<{
+                readonly scheme: Schema.Union<readonly [Schema.Literal<"hmac">, Schema.Literal<"asymmetric">, Schema.Literal<"provider_verified">]>;
+                readonly keyRef: Schema.String;
+                readonly verified: Schema.Literal<true>;
+                readonly verifiedAt: Schema.String;
+                readonly bodyDigest: Schema.String;
+                readonly replayWindowSeconds: Schema.optionalKey<Schema.Int>;
+            }>;
+        }>, Schema.Struct<{
+            readonly mode: Schema.Literal<"scheduler">;
+            readonly scheduleId: Schema.String;
+            readonly scheduleVersion: Schema.Int;
+        }>, Schema.Struct<{
+            readonly mode: Schema.Literal<"canonical_run_transition">;
+            readonly subject: Schema.Struct<{
+                readonly kind: Schema.String;
+                readonly id: Schema.String;
+            }>;
+            readonly eventId: Schema.String;
+        }>]>;
+        readonly subject: Schema.optionalKey<Schema.Struct<{
+            readonly kind: Schema.String;
+            readonly id: Schema.String;
+        }>>;
+        readonly correlation: Schema.$Record<Schema.String, Schema.Codec<SafeJson, SafeJson, never, never>>;
+        readonly occurredAt: Schema.String;
+        readonly receivedAt: Schema.String;
+        readonly ordering: Schema.Struct<{
+            readonly key: Schema.String;
+            readonly guarantee: Schema.Union<readonly [Schema.Literal<"transaction">, Schema.Literal<"source">, Schema.Literal<"provider">, Schema.Literal<"arrival">, Schema.Literal<"none">]>;
+            readonly sourcePosition: Schema.optionalKey<Schema.String>;
+            readonly predecessorPosition: Schema.optionalKey<Schema.String>;
+            readonly gapPolicy: Schema.Union<readonly [Schema.Literal<"wait">, Schema.Literal<"process_arrival">, Schema.Literal<"block_manual">]>;
+        }>;
+        readonly payload: Schema.Struct<{
+            readonly schema: Schema.Struct<{
+                readonly kind: Schema.Literal<"typebox_ref">;
+                readonly name: Schema.String;
+                readonly version: Schema.String;
+                readonly sha256: Schema.String;
+            }>;
+            readonly data: Schema.Codec<SafeJson, SafeJson, never, never>;
+            readonly digest: Schema.String;
+        }>;
+        readonly deduplication: Schema.Struct<{
+            readonly scope: Schema.String;
+            readonly keyDigest: Schema.String;
+            readonly basis: Schema.Union<readonly [Schema.Literal<"actor_idempotency">, Schema.Literal<"transaction_event">, Schema.Literal<"provider_delivery">, Schema.Literal<"provider_body_digest">, Schema.Literal<"schedule_fire">, Schema.Literal<"message_id">, Schema.Literal<"result_id">, Schema.Literal<"run_link_id">, Schema.Literal<"child_call">]>;
+        }>;
+        readonly createdAt: Schema.String;
+    }>;
+    readonly idempotencyKey: Schema.optionalKey<Schema.String>;
+    readonly requestId: Schema.optionalKey<Schema.String>;
+    readonly traceparent: Schema.optionalKey<Schema.String>;
+}>;
+export type TriggerIngress = (typeof TriggerIngress)['Type'];
+export {};