@voltro/plugin-ai-flows 0.83.1 → 0.85.0

package/dist/ir.d.ts

@@ -2,11 +2,11 @@ import { Schema } from 'effect';
 
 /** A launch-form field. The run `input` is keyed by these `key`s. */
 export declare const BriefField: Schema.Struct<{
-    key: typeof Schema.String;
-    label: typeof Schema.String;
-    type: Schema.Literal<["text", "textarea", "number", "boolean"]>;
-    required: Schema.optional<typeof Schema.Boolean>;
-    placeholder: Schema.optional<typeof Schema.String>;
+    readonly key: Schema.String;
+    readonly label: Schema.String;
+    readonly type: Schema.Literals<readonly ["text", "textarea", "number", "boolean"]>;
+    readonly required: Schema.optional<Schema.Boolean>;
+    readonly placeholder: Schema.optional<Schema.String>;
 }>;
 
 /** An INTERFACE for the same reason as {@link FlowStep} — it is reached from an
@@ -23,9 +23,9 @@ export declare interface BriefField {
 
 /** Staged follow-up when `chainTo.requireConfirmation` is set. */
 export declare const ChainPending: Schema.Struct<{
-    flowRef: typeof Schema.String;
-    input: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
-    status: Schema.Literal<["pending", "confirmed", "dismissed"]>;
+    readonly flowRef: Schema.String;
+    readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly status: Schema.Literals<readonly ["pending", "confirmed", "dismissed"]>;
 }>;
 
 /** An INTERFACE — reached from `aiFlowRuns.chainPending`; see {@link BriefField}. */
@@ -38,17 +38,17 @@ export declare interface ChainPending {
 export declare const clampMaxSteps: (n: number | null | undefined) => number;
 
 /** The comparison a `when:` performs. */
-export declare const ConditionOp: Schema.Literal<["truthy", "falsy", "eq", "neq", "contains"]>;
+export declare const ConditionOp: Schema.Literals<readonly ["truthy", "falsy", "eq", "neq", "contains"]>;
 
 export declare type ConditionOp = typeof ConditionOp.Type;
 
 /** A run's cost verdict over its steps: every step gateway-priced → `actual`; none unpriced → `estimated`; any unpriced → `incomplete`; no priced step → `unknown`. */
-export declare const CostCompleteness: Schema.Literal<["actual", "estimated", "incomplete", "unknown"]>;
+export declare const CostCompleteness: Schema.Literals<readonly ["actual", "estimated", "incomplete", "unknown"]>;
 
 export declare type CostCompleteness = typeof CostCompleteness.Type;
 
 /** Where a cost figure came from. `unpriced` means the number beside it is a placeholder, not a price. */
-export declare const CostSource: Schema.Literal<["gateway", "estimated", "unpriced"]>;
+export declare const CostSource: Schema.Literals<readonly ["gateway", "estimated", "unpriced"]>;
 
 export declare type CostSource = typeof CostSource.Type;
 
@@ -70,19 +70,19 @@ export declare const evaluateCondition: (condition: StepCondition, context: Read
 /** Schedule spec — richer than a single cron expr (weekly interval + anchor,
  *  monthly weekOfMonth), evaluated by the shared `cadenceMatches` predicate. */
 export declare const FlowCadence: Schema.Struct<{
-    frequency: Schema.optional<Schema.Literal<["weekly", "monthly"]>>;
+    readonly frequency: Schema.optional<Schema.Literals<readonly ["weekly", "monthly"]>>;
     /** Weekdays, 0=Monday … 6=Sunday. */
-    repeats: Schema.Array$<typeof Schema.Number>;
+    readonly repeats: Schema.$Array<Schema.Number>;
     /** Weekly cycle length: 1 | 2 | 4 (anchored by anchorDate). */
-    intervalWeeks: Schema.optional<typeof Schema.Number>;
+    readonly intervalWeeks: Schema.optional<Schema.Number>;
     /** ISO YYYY-MM-DD, cycle-0 week (interval > 1). */
-    anchorDate: Schema.optional<typeof Schema.String>;
-    weekOfMonth: Schema.optional<Schema.Union<[Schema.Literal<[1, 2, 3, 4]>, Schema.Literal<["last"]>]>>;
+    readonly anchorDate: Schema.optional<Schema.String>;
+    readonly weekOfMonth: Schema.optional<Schema.Union<readonly [Schema.Literals<readonly [1, 2, 3, 4]>, Schema.Literal<"last">]>>;
     /** 0-23, default 9. */
-    hour: Schema.optional<typeof Schema.Number>;
-    minute: Schema.optional<Schema.Literal<[0, 15, 30, 45]>>;
+    readonly hour: Schema.optional<Schema.Number>;
+    readonly minute: Schema.optional<Schema.Literals<readonly [0, 15, 30, 45]>>;
     /** Brief for unattended cron runs. */
-    defaultInput: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly defaultInput: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
 }>;
 
 /**
@@ -110,39 +110,39 @@ export declare interface FlowCadence {
  * The row never claims `cancelled` on its own: a confirmed engine cancellation
  * is the only receipt that reports a `cancelled` row, every other request
  * outcome leaves the row `cancelling` (or a completion that won a race). */
-export declare const FlowCancelReceipt: Schema.filter<Schema.Struct<{
-    runId: typeof Schema.NonEmptyString;
-    status: Schema.Literal<["pending", "running", "waiting", "cancelling", "succeeded", "failed", "cancelled"]>;
-    engine: Schema.Literal<["cancelled", "accepted", "unknown", "already-terminal", "unreachable", "not-requested"]>;
-    control: Schema.NullOr<Schema.filter<Schema.Struct<{
-        operation: Schema.Literal<["cancel", "resume"]>;
-        kind: Schema.Literal<["accepted", "confirmed", "unknown", "already-terminal"]>;
-        requestId: Schema.NullOr<typeof Schema.NonEmptyString>;
-        snapshot: Schema.Struct<{
-            id: typeof Schema.String;
-            workflowName: typeof Schema.String;
-            executionId: typeof Schema.String;
-            status: Schema.Union<[Schema.Literal<["running", "succeeded", "failed", "cancelled", "suspended"]>, Schema.Literal<["unknown"]>]>;
-            output: Schema.optional<typeof Schema.Unknown>;
-            error: Schema.optional<Schema.Struct<{
-                tag: Schema.NullOr<typeof Schema.String>;
-                message: typeof Schema.String;
+export declare const FlowCancelReceipt: Schema.Struct<{
+    readonly runId: Schema.NonEmptyString;
+    readonly status: Schema.Literals<readonly ["pending", "running", "waiting", "cancelling", "succeeded", "failed", "cancelled"]>;
+    readonly engine: Schema.Literals<readonly ["cancelled", "accepted", "unknown", "already-terminal", "unreachable", "not-requested"]>;
+    readonly control: Schema.NullOr<Schema.Struct<{
+        readonly operation: Schema.Literals<readonly ["cancel", "resume"]>;
+        readonly kind: Schema.Literals<readonly ["accepted", "confirmed", "unknown", "already-terminal"]>;
+        readonly requestId: Schema.NullOr<Schema.NonEmptyString>;
+        readonly snapshot: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly workflowName: Schema.String;
+            readonly executionId: Schema.String;
+            readonly status: Schema.Union<readonly [Schema.Literals<readonly ["running", "succeeded", "failed", "cancelled", "suspended"]>, Schema.Literal<"unknown">]>;
+            readonly output: Schema.optional<Schema.Unknown>;
+            readonly error: Schema.optional<Schema.Struct<{
+                readonly tag: Schema.NullOr<Schema.String>;
+                readonly message: Schema.String;
             }>>;
         }>;
-    }>>>;
-}>>;
+    }>>;
+}>;
 
 export declare type FlowCancelReceipt = typeof FlowCancelReceipt.Type;
 
 /** Follow-up flow spec. On success, map source → the child's brief. */
 export declare const FlowChain: Schema.Struct<{
     /** Child flow id (data) or name (code). */
-    flowRef: typeof Schema.String;
-    mappings: Schema.Array$<Schema.Struct<{
-        targetKey: typeof Schema.String;
-        sourceKey: typeof Schema.String;
+    readonly flowRef: Schema.String;
+    readonly mappings: Schema.$Array<Schema.Struct<{
+        readonly targetKey: Schema.String;
+        readonly sourceKey: Schema.String;
     }>>;
-    requireConfirmation: Schema.optional<typeof Schema.Boolean>;
+    readonly requireConfirmation: Schema.optional<Schema.Boolean>;
 }>;
 
 /** An INTERFACE — reached from `aiFlows.chainTo`; see {@link BriefField}. */
@@ -192,19 +192,19 @@ export declare interface FlowIR {
 /** Execution mode. Replaces the legacy `allowDeviation` boolean — a mode is not
  *  a boolean. `deterministic` runs the plan verbatim (resumable per step);
  *  `agentic` lets an orchestrator LLM adapt the plan via the four tools. */
-export declare const FlowMode: Schema.Literal<["deterministic", "agentic"]>;
+export declare const FlowMode: Schema.Literals<readonly ["deterministic", "agentic"]>;
 
 export declare type FlowMode = typeof FlowMode.Type;
 
 /** Bind the answer to the review actually displayed, not the latest waiting step. */
 export declare const FlowReviewInput: Schema.Struct<{
-    runId: typeof Schema.NonEmptyString;
-    stepIndex: Schema.filter<typeof Schema.Int>;
-    response: Schema.Struct<{
-        decision: Schema.optional<Schema.Literal<["approve", "reject"]>>;
-        value: Schema.optional<typeof Schema.String>;
-        text: Schema.optional<typeof Schema.String>;
-        respondedAt: Schema.optional<typeof Schema.String>;
+    readonly runId: Schema.NonEmptyString;
+    readonly stepIndex: Schema.Int;
+    readonly response: Schema.Struct<{
+        readonly decision: Schema.optional<Schema.Literals<readonly ["approve", "reject"]>>;
+        readonly value: Schema.optional<Schema.String>;
+        readonly text: Schema.optional<Schema.String>;
+        readonly respondedAt: Schema.optional<Schema.String>;
     }>;
 }>;
 
@@ -212,29 +212,29 @@ export declare type FlowReviewInput = typeof FlowReviewInput.Type;
 
 /** Delivery accepted; consumption and the run's eventual outcome remain reactive state. */
 export declare const FlowReviewReceipt: Schema.Struct<{
-    runId: typeof Schema.NonEmptyString;
-    stepIndex: Schema.filter<typeof Schema.Int>;
-    executionId: typeof Schema.NonEmptyString;
-    eventId: typeof Schema.NonEmptyString;
-    status: Schema.Literal<["accepted"]>;
+    readonly runId: Schema.NonEmptyString;
+    readonly stepIndex: Schema.Int;
+    readonly executionId: Schema.NonEmptyString;
+    readonly eventId: Schema.NonEmptyString;
+    readonly status: Schema.Literal<"accepted">;
 }>;
 
 export declare type FlowReviewReceipt = typeof FlowReviewReceipt.Type;
 
 /** Submission evidence, separate from the flow run's execution status. */
 export declare const FlowStartReceipt: Schema.Struct<{
-    runId: typeof Schema.NonEmptyString;
-    requestId: typeof Schema.NonEmptyString;
-    admission: Schema.Struct<{
-        id: typeof Schema.String;
-        workflowName: typeof Schema.String;
-        executionId: Schema.NullOr<typeof Schema.String>;
-        status: Schema.Literal<["running", "succeeded", "queued", "dropped", "skipped", "replayed"]>;
-        deferral: Schema.optional<Schema.Struct<{
-            mode: typeof Schema.String;
-            dueAt: Schema.NullOr<typeof Schema.Number>;
-            retryAfterMs: Schema.NullOr<typeof Schema.Number>;
-            intentId: Schema.NullOr<typeof Schema.String>;
+    readonly runId: Schema.NonEmptyString;
+    readonly requestId: Schema.NonEmptyString;
+    readonly admission: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly workflowName: Schema.String;
+        readonly executionId: Schema.NullOr<Schema.String>;
+        readonly status: Schema.Literals<readonly ["running", "succeeded", "queued", "dropped", "skipped", "replayed"]>;
+        readonly deferral: Schema.optional<Schema.Struct<{
+            readonly mode: Schema.String;
+            readonly dueAt: Schema.NullOr<Schema.Number>;
+            readonly retryAfterMs: Schema.NullOr<Schema.Number>;
+            readonly intentId: Schema.NullOr<Schema.String>;
         }>>;
     }>;
 }>;
@@ -242,7 +242,7 @@ export declare const FlowStartReceipt: Schema.Struct<{
 export declare type FlowStartReceipt = typeof FlowStartReceipt.Type;
 
 /** Flow-definition lifecycle. */
-export declare const FlowStatus: Schema.Literal<["draft", "active", "archived"]>;
+export declare const FlowStatus: Schema.Literals<readonly ["draft", "active", "archived"]>;
 
 export declare type FlowStatus = typeof FlowStatus.Type;
 
@@ -253,43 +253,43 @@ export declare type FlowStatus = typeof FlowStatus.Type;
  * `{{outputKey}}` in `prompt` / media refs.
  */
 export declare const FlowStep: Schema.Struct<{
-    id: typeof Schema.String;
-    title: Schema.optional<typeof Schema.String>;
+    readonly id: Schema.String;
+    readonly title: Schema.optional<Schema.String>;
     /** Informational; shown under the step in the run timeline. */
-    description: Schema.optional<typeof Schema.String>;
-    type: Schema.Literal<["agent", "generate", "structured", "note", "human"]>;
+    readonly description: Schema.optional<Schema.String>;
+    readonly type: Schema.Literals<readonly ["agent", "generate", "structured", "note", "human"]>;
     /** Sanitized [\w.-]; the result-bundle key + the `{{ref}}` name. */
-    outputKey: Schema.optional<typeof Schema.String>;
+    readonly outputKey: Schema.optional<Schema.String>;
     /** Template with `{{key}}` placeholders (brief inputs + prior outputKeys). */
-    prompt: Schema.optional<typeof Schema.String>;
-    modality: Schema.optional<Schema.Literal<["text", "image", "video", "audio"]>>;
-    model: Schema.optional<typeof Schema.String>;
-    params: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
-    mediaInputs: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
-        from: Schema.Literal<["upload"]>;
-        url: typeof Schema.String;
-        mediaType: Schema.optional<typeof Schema.NonEmptyString>;
+    readonly prompt: Schema.optional<Schema.String>;
+    readonly modality: Schema.optional<Schema.Literals<readonly ["text", "image", "video", "audio"]>>;
+    readonly model: Schema.optional<Schema.String>;
+    readonly params: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly mediaInputs: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly from: Schema.Literal<"upload">;
+        readonly url: Schema.String;
+        readonly mediaType: Schema.optional<Schema.NonEmptyString>;
     }>, Schema.Struct<{
-        from: Schema.Literal<["step"]>;
-        ref: typeof Schema.String;
-        artifact: Schema.optional<Schema.filter<typeof Schema.Int>>;
+        readonly from: Schema.Literal<"step">;
+        readonly ref: Schema.String;
+        readonly artifact: Schema.optional<Schema.Int>;
     }>]>>>;
     /** Allowed sub-agent id/name, resolved and authorized by the host. */
-    agentRef: Schema.optional<typeof Schema.String>;
+    readonly agentRef: Schema.optional<Schema.String>;
     /** JSON Schema of the desired object, preserved and validated at run. */
-    schema: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
-    reviewMode: Schema.optional<Schema.Literal<["approve", "choice", "text"]>>;
-    options: Schema.optional<Schema.Array$<Schema.Struct<{
-        value: typeof Schema.String;
-        label: typeof Schema.String;
+    readonly schema: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly reviewMode: Schema.optional<Schema.Literals<readonly ["approve", "choice", "text"]>>;
+    readonly options: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly value: Schema.String;
+        readonly label: Schema.String;
     }>>>;
     /** Gate this step on a prior value. Absent → the step always runs. A step
      *  whose condition is false is SKIPPED, not failed: it produces no output, so
      *  anything referencing its `outputKey` sees an absent value. */
-    when: Schema.optional<Schema.Struct<{
-        ref: typeof Schema.String;
-        op: Schema.Literal<["truthy", "falsy", "eq", "neq", "contains"]>;
-        value: Schema.optional<typeof Schema.Unknown>;
+    readonly when: Schema.optional<Schema.Struct<{
+        readonly ref: Schema.String;
+        readonly op: Schema.Literals<readonly ["truthy", "falsy", "eq", "neq", "contains"]>;
+        readonly value: Schema.optional<Schema.Unknown>;
     }>>;
     /**
      * Fan-out group. CONSECUTIVE steps sharing a group name run CONCURRENTLY,
@@ -300,12 +300,12 @@ export declare const FlowStep: Schema.Struct<{
      * step may not join a group either: it suspends the whole workflow, which is
      * not a thing one branch of a fan-out can do.
      */
-    group: Schema.optional<typeof Schema.String>;
+    readonly group: Schema.optional<Schema.String>;
     /** `human` step only — how long the run parks awaiting this review before it
      *  fails, in milliseconds. Omitted → the flow's `humanTimeoutMs`, then the
      *  engine/plugin default (see `resolveHumanReviewTimeoutMs`). `0` means WAIT
      *  FOREVER (the park is slot-free, so an unbounded wait costs no worker). */
-    timeoutMs: Schema.optional<typeof Schema.Number>;
+    readonly timeoutMs: Schema.optional<Schema.Number>;
 }>;
 
 /**
@@ -353,10 +353,10 @@ export declare interface FlowStep {
 
 /** The HITL answer; the engine projects it after consuming the durable signal. */
 export declare const HumanResponse: Schema.Struct<{
-    decision: Schema.optional<Schema.Literal<["approve", "reject"]>>;
-    value: Schema.optional<typeof Schema.String>;
-    text: Schema.optional<typeof Schema.String>;
-    respondedAt: Schema.optional<typeof Schema.String>;
+    readonly decision: Schema.optional<Schema.Literals<readonly ["approve", "reject"]>>;
+    readonly value: Schema.optional<Schema.String>;
+    readonly text: Schema.optional<Schema.String>;
+    readonly respondedAt: Schema.optional<Schema.String>;
 }>;
 
 /** An INTERFACE — reached from `aiFlowRuns.humanResponse`; see {@link BriefField}. */
@@ -382,7 +382,7 @@ export declare interface HumanResponse {
 export declare const isTruthy: (v: unknown) => boolean;
 
 /** A JSON value (for `params` / `input` / a `structured` step's JSON Schema). */
-export declare const Json: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+export declare const Json: Schema.$Record<Schema.String, Schema.Unknown>;
 
 export declare type Json = typeof Json.Type;
 
@@ -397,31 +397,31 @@ export declare const MAX_STEPS_MIN = 1;
 /** One persisted media artifact. Storage identity is not a provider request ID.
  *  Exactly one artifact per result has role `primary`; other roles are host-defined. */
 export declare const MediaArtifact: Schema.Struct<{
-    url: typeof Schema.NonEmptyString;
-    mediaType: typeof Schema.NonEmptyString;
-    role: typeof Schema.NonEmptyString;
-    storageRefId: Schema.optional<typeof Schema.NonEmptyString>;
-    providerMetadata: Schema.optional<typeof Schema.Unknown>;
+    readonly url: Schema.NonEmptyString;
+    readonly mediaType: Schema.NonEmptyString;
+    readonly role: Schema.NonEmptyString;
+    readonly storageRefId: Schema.optional<Schema.NonEmptyString>;
+    readonly providerMetadata: Schema.optional<Schema.Unknown>;
 }>;
 
 export declare type MediaArtifact = typeof MediaArtifact.Type;
 
-export declare const MediaArtifacts: Schema.filter<Schema.Array$<Schema.Struct<{
-    url: typeof Schema.NonEmptyString;
-    mediaType: typeof Schema.NonEmptyString;
-    role: typeof Schema.NonEmptyString;
-    storageRefId: Schema.optional<typeof Schema.NonEmptyString>;
-    providerMetadata: Schema.optional<typeof Schema.Unknown>;
-}>>>;
-
-export declare const MediaInputs: Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
-    from: Schema.Literal<["upload"]>;
-    url: typeof Schema.String;
-    mediaType: Schema.optional<typeof Schema.NonEmptyString>;
+export declare const MediaArtifacts: Schema.$Array<Schema.Struct<{
+    readonly url: Schema.NonEmptyString;
+    readonly mediaType: Schema.NonEmptyString;
+    readonly role: Schema.NonEmptyString;
+    readonly storageRefId: Schema.optional<Schema.NonEmptyString>;
+    readonly providerMetadata: Schema.optional<Schema.Unknown>;
+}>>;
+
+export declare const MediaInputs: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+    readonly from: Schema.Literal<"upload">;
+    readonly url: Schema.String;
+    readonly mediaType: Schema.optional<Schema.NonEmptyString>;
 }>, Schema.Struct<{
-    from: Schema.Literal<["step"]>;
-    ref: typeof Schema.String;
-    artifact: Schema.optional<Schema.filter<typeof Schema.Int>>;
+    readonly from: Schema.Literal<"step">;
+    readonly ref: Schema.String;
+    readonly artifact: Schema.optional<Schema.Int>;
 }>]>>;
 
 export declare type MediaInputs = typeof MediaInputs.Type;
@@ -429,14 +429,14 @@ export declare type MediaInputs = typeof MediaInputs.Type;
 /** A media-input slot — an absolute HTTP(S) uploaded URL or a reference to a
  *  brief field/prior step's URL output. Keyed by capability slot name
  *  (`referenceImageUrl`, `lastFrameImageUrl`, `referenceVideoUrl`, …). */
-export declare const MediaInputSlot: Schema.Union<[Schema.Struct<{
-    from: Schema.Literal<["upload"]>;
-    url: typeof Schema.String;
-    mediaType: Schema.optional<typeof Schema.NonEmptyString>;
+export declare const MediaInputSlot: Schema.Union<readonly [Schema.Struct<{
+    readonly from: Schema.Literal<"upload">;
+    readonly url: Schema.String;
+    readonly mediaType: Schema.optional<Schema.NonEmptyString>;
 }>, Schema.Struct<{
-    from: Schema.Literal<["step"]>;
-    ref: typeof Schema.String;
-    artifact: Schema.optional<Schema.filter<typeof Schema.Int>>;
+    readonly from: Schema.Literal<"step">;
+    readonly ref: Schema.String;
+    readonly artifact: Schema.optional<Schema.Int>;
 }>]>;
 
 export declare type MediaInputSlot = typeof MediaInputSlot.Type;
@@ -448,20 +448,20 @@ export declare type MediaInputSlot = typeof MediaInputSlot.Type;
  * succeeded one; the run's `costCompleteness` counts it.
  */
 export declare const MediaReceipt: Schema.Struct<{
-    costMicroUsd: Schema.optional<Schema.filter<typeof Schema.Finite>>;
-    costSource: Schema.optional<Schema.Literal<["gateway", "estimated", "unpriced"]>>;
-    requestId: Schema.optional<typeof Schema.NonEmptyString>;
-    usage: Schema.optional<Schema.Struct<{
-        status: Schema.Literal<["reported", "unreported"]>;
-        unit: Schema.optional<Schema.Literal<["tokens", "characters", "seconds"]>>;
-        input: Schema.optional<Schema.filter<typeof Schema.Finite>>;
-        output: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+    readonly costMicroUsd: Schema.optional<Schema.Finite>;
+    readonly costSource: Schema.optional<Schema.Literals<readonly ["gateway", "estimated", "unpriced"]>>;
+    readonly requestId: Schema.optional<Schema.NonEmptyString>;
+    readonly usage: Schema.optional<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["reported", "unreported"]>;
+        readonly unit: Schema.optional<Schema.Literals<readonly ["tokens", "characters", "seconds"]>>;
+        readonly input: Schema.optional<Schema.Finite>;
+        readonly output: Schema.optional<Schema.Finite>;
     }>>;
 }>;
 
 export declare type MediaReceipt = typeof MediaReceipt.Type;
 
-export declare const Modality: Schema.Literal<["text", "image", "video", "audio"]>;
+export declare const Modality: Schema.Literals<readonly ["text", "image", "video", "audio"]>;
 
 export declare type Modality = typeof Modality.Type;
 
@@ -472,31 +472,31 @@ export declare type Modality = typeof Modality.Type;
  */
 export declare const normalizeFlow: (def: FlowDefinitionInput) => FlowIR;
 
-export declare const ReviewMode: Schema.Literal<["approve", "choice", "text"]>;
+export declare const ReviewMode: Schema.Literals<readonly ["approve", "choice", "text"]>;
 
 export declare type ReviewMode = typeof ReviewMode.Type;
 
 export declare const ReviewOption: Schema.Struct<{
-    value: typeof Schema.String;
-    label: typeof Schema.String;
+    readonly value: Schema.String;
+    readonly label: Schema.String;
 }>;
 
 export declare type ReviewOption = typeof ReviewOption.Type;
 
 /** Human-review config projected onto a `waiting` run step. */
 export declare const RunReview: Schema.Struct<{
-    mode: Schema.Literal<["approve", "choice", "text"]>;
-    options: Schema.optional<Schema.Array$<Schema.Struct<{
-        value: typeof Schema.String;
-        label: typeof Schema.String;
+    readonly mode: Schema.Literals<readonly ["approve", "choice", "text"]>;
+    readonly options: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly value: Schema.String;
+        readonly label: Schema.String;
     }>>>;
-    prompt: typeof Schema.String;
+    readonly prompt: Schema.String;
 }>;
 
 export declare type RunReview = typeof RunReview.Type;
 
 /** What triggered a run. */
-export declare const RunSource: Schema.Literal<["manual", "cron"]>;
+export declare const RunSource: Schema.Literals<readonly ["manual", "cron"]>;
 
 export declare type RunSource = typeof RunSource.Type;
 
@@ -507,62 +507,62 @@ export declare type RunSource = typeof RunSource.Type;
  *  confirmed: the row carries that uncertainty until the engine stops the run
  *  (cooperatively, by interruption, or through a later confirmed request).
  *  Only `succeeded`, `failed` and `cancelled` are terminal. */
-export declare const RunStatus: Schema.Literal<["pending", "running", "waiting", "cancelling", "succeeded", "failed", "cancelled"]>;
+export declare const RunStatus: Schema.Literals<readonly ["pending", "running", "waiting", "cancelling", "succeeded", "failed", "cancelled"]>;
 
 export declare type RunStatus = typeof RunStatus.Type;
 
 export declare const RunStep: Schema.Struct<{
-    id: typeof Schema.Number;
-    title: typeof Schema.String;
-    description: Schema.optional<typeof Schema.String>;
-    type: Schema.Literal<["agent", "generate", "structured", "note", "human"]>;
-    status: Schema.Literal<["pending", "running", "waiting", "succeeded", "failed", "skipped"]>;
+    readonly id: Schema.Number;
+    readonly title: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly type: Schema.Literals<readonly ["agent", "generate", "structured", "note", "human"]>;
+    readonly status: Schema.Literals<readonly ["pending", "running", "waiting", "succeeded", "failed", "skipped"]>;
     /** The agent an `agent` step delegated to — a field, so a run view never
      *  parses it out of `title`. */
-    agentRef: Schema.optional<typeof Schema.String>;
+    readonly agentRef: Schema.optional<Schema.String>;
     /** What a `generate` step produced. */
-    modality: Schema.optional<Schema.Literal<["text", "image", "video", "audio"]>>;
-    startedAt: Schema.optional<typeof Schema.String>;
-    completedAt: Schema.optional<typeof Schema.String>;
+    readonly modality: Schema.optional<Schema.Literals<readonly ["text", "image", "video", "audio"]>>;
+    readonly startedAt: Schema.optional<Schema.String>;
+    readonly completedAt: Schema.optional<Schema.String>;
     /** Per-step cost in micro-USD (the app view projects to €/cents). */
-    costMicroUsd: Schema.optional<typeof Schema.Number>;
+    readonly costMicroUsd: Schema.optional<Schema.Number>;
     /** Where that number came from — the gateway's actual charge, a price-table
      *  estimate, or nothing (`unpriced`: the 0 above is not a price). */
-    costSource: Schema.optional<Schema.Literal<["gateway", "estimated", "unpriced"]>>;
+    readonly costSource: Schema.optional<Schema.Literals<readonly ["gateway", "estimated", "unpriced"]>>;
     /** Links a media step to its generation/usage record. */
-    requestId: Schema.optional<typeof Schema.String>;
+    readonly requestId: Schema.optional<Schema.String>;
     /** What the step consumed — also on a FAILED step that was charged. */
-    usage: Schema.optional<Schema.Struct<{
-        status: Schema.Literal<["reported", "unreported"]>;
-        unit: Schema.optional<Schema.Literal<["tokens", "characters", "seconds"]>>;
-        input: Schema.optional<Schema.filter<typeof Schema.Finite>>;
-        output: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+    readonly usage: Schema.optional<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["reported", "unreported"]>;
+        readonly unit: Schema.optional<Schema.Literals<readonly ["tokens", "characters", "seconds"]>>;
+        readonly input: Schema.optional<Schema.Finite>;
+        readonly output: Schema.optional<Schema.Finite>;
     }>>;
     /** Hosted media artifact URL (image/video/audio), via storage. */
-    url: Schema.optional<typeof Schema.String>;
+    readonly url: Schema.optional<Schema.String>;
     /** All media variants, including roles and storage references; url projects the primary artifact. */
-    artifacts: Schema.optional<Schema.filter<Schema.Array$<Schema.Struct<{
-        url: typeof Schema.NonEmptyString;
-        mediaType: typeof Schema.NonEmptyString;
-        role: typeof Schema.NonEmptyString;
-        storageRefId: Schema.optional<typeof Schema.NonEmptyString>;
-        providerMetadata: Schema.optional<typeof Schema.Unknown>;
-    }>>>>;
+    readonly artifacts: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly url: Schema.NonEmptyString;
+        readonly mediaType: Schema.NonEmptyString;
+        readonly role: Schema.NonEmptyString;
+        readonly storageRefId: Schema.optional<Schema.NonEmptyString>;
+        readonly providerMetadata: Schema.optional<Schema.Unknown>;
+    }>>>;
     /** Inline text output (rendered as markdown). */
-    output: Schema.optional<Schema.Struct<{
-        text: typeof Schema.String;
+    readonly output: Schema.optional<Schema.Struct<{
+        readonly text: Schema.String;
     }>>;
-    errorMessage: Schema.optional<typeof Schema.String>;
+    readonly errorMessage: Schema.optional<Schema.String>;
     /** Why a `skipped` step was skipped — the rendered condition, so the timeline
      *  says "{{approved}} is not set" instead of leaving a silent gap. */
-    skipReason: Schema.optional<typeof Schema.String>;
-    review: Schema.optional<Schema.Struct<{
-        mode: Schema.Literal<["approve", "choice", "text"]>;
-        options: Schema.optional<Schema.Array$<Schema.Struct<{
-            value: typeof Schema.String;
-            label: typeof Schema.String;
+    readonly skipReason: Schema.optional<Schema.String>;
+    readonly review: Schema.optional<Schema.Struct<{
+        readonly mode: Schema.Literals<readonly ["approve", "choice", "text"]>;
+        readonly options: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly value: Schema.String;
+            readonly label: Schema.String;
         }>>>;
-        prompt: typeof Schema.String;
+        readonly prompt: Schema.String;
     }>>;
 }>;
 
@@ -594,7 +594,7 @@ export declare interface RunStep {
     readonly review?: RunReview | undefined;
 }
 
-export declare const RunStepStatus: Schema.Literal<["pending", "running", "waiting", "succeeded", "failed", "skipped"]>;
+export declare const RunStepStatus: Schema.Literals<readonly ["pending", "running", "waiting", "succeeded", "failed", "skipped"]>;
 
 export declare type RunStepStatus = typeof RunStepStatus.Type;
 
@@ -603,10 +603,10 @@ export declare const sanitizeOutputKey: (key: string) => string;
 
 declare const StepCondition: Schema.Struct<{
     /** A brief-field key or an EARLIER step's `outputKey`. */
-    ref: typeof Schema.String;
-    op: Schema.Literal<["truthy", "falsy", "eq", "neq", "contains"]>;
+    readonly ref: Schema.String;
+    readonly op: Schema.Literals<readonly ["truthy", "falsy", "eq", "neq", "contains"]>;
     /** The right-hand side for `eq` / `neq` / `contains`. Ignored by the unary ops. */
-    value: Schema.optional<typeof Schema.Unknown>;
+    readonly value: Schema.optional<Schema.Unknown>;
 }>;
 
 /** An INTERFACE, for the same api-report reason as `FlowStep` — it is reached
@@ -621,7 +621,7 @@ export { StepCondition }
 export { StepCondition as StepConditionType }
 
 /** The five step types. `generate` fans out to four modalities. */
-export declare const StepType: Schema.Literal<["agent", "generate", "structured", "note", "human"]>;
+export declare const StepType: Schema.Literals<readonly ["agent", "generate", "structured", "note", "human"]>;
 
 export declare type StepType = typeof StepType.Type;
 
@@ -636,16 +636,16 @@ export declare type StepType = typeof StepType.Type;
  * later, or reconciled against an invoice.
  */
 export declare const StepUsage: Schema.Struct<{
-    status: Schema.Literal<["reported", "unreported"]>;
-    unit: Schema.optional<Schema.Literal<["tokens", "characters", "seconds"]>>;
-    input: Schema.optional<Schema.filter<typeof Schema.Finite>>;
-    output: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+    readonly status: Schema.Literals<readonly ["reported", "unreported"]>;
+    readonly unit: Schema.optional<Schema.Literals<readonly ["tokens", "characters", "seconds"]>>;
+    readonly input: Schema.optional<Schema.Finite>;
+    readonly output: Schema.optional<Schema.Finite>;
 }>;
 
 export declare type StepUsage = typeof StepUsage.Type;
 
 /** Gallery scope. `shared` → per-subject share list; `organization` → tenant. */
-export declare const Visibility: Schema.Literal<["private", "organization", "shared"]>;
+export declare const Visibility: Schema.Literals<readonly ["private", "organization", "shared"]>;
 
 export declare type Visibility = typeof Visibility.Type;