@voltro/plugin-ai-flows 0.84.0 → 0.86.0

package/dist/web.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
@@ -29,12 +29,12 @@ export declare interface BriefField {
 export declare const cadenceMatches: (cadence: FlowCadence, now: Date) => boolean;
 
 /** The comparison a `when:` performs. */
-declare const ConditionOp: Schema.Literal<["truthy", "falsy", "eq", "neq", "contains"]>;
+declare const ConditionOp: Schema.Literals<readonly ["truthy", "falsy", "eq", "neq", "contains"]>;
 
 declare type ConditionOp = typeof ConditionOp.Type;
 
 /** Where a cost figure came from. `unpriced` means the number beside it is a placeholder, not a price. */
-declare const CostSource: Schema.Literal<["gateway", "estimated", "unpriced"]>;
+declare const CostSource: Schema.Literals<readonly ["gateway", "estimated", "unpriced"]>;
 
 declare type CostSource = typeof CostSource.Type;
 
@@ -43,19 +43,19 @@ export declare const DEFAULT_FLOW_RPC_TAGS: FlowRpcTags;
 /** 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>>;
 }>;
 
 /**
@@ -81,12 +81,12 @@ export declare interface FlowCadence {
 /** 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}. */
@@ -110,19 +110,19 @@ export declare interface FlowHookOptions {
 /** 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>;
     }>;
 }>;
 
@@ -130,11 +130,11 @@ 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;
@@ -191,18 +191,18 @@ export declare interface FlowRunView {
 
 /** Submission evidence, separate from the flow run's execution status. */
 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>;
         }>>;
     }>;
 }>;
@@ -210,7 +210,7 @@ declare const FlowStartReceipt: Schema.Struct<{
 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;
 
@@ -221,43 +221,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,
@@ -268,12 +268,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>;
 }>;
 
 /**
@@ -321,10 +321,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}. */
@@ -336,7 +336,7 @@ export declare interface HumanResponse {
 }
 
 /** A JSON value (for `params` / `input` / a `structured` step's JSON Schema). */
-declare const Json: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+declare const Json: Schema.$Record<Schema.String, Schema.Unknown>;
 
 declare type Json = typeof Json.Type;
 
@@ -351,28 +351,28 @@ export declare type LaunchFlowResult = FlowStartReceipt;
 /** 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. */
 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>;
 }>;
 
 declare type MediaArtifact = typeof MediaArtifact.Type;
 
-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>;
+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>;
 }>]>>;
 
 declare type MediaInputs = typeof MediaInputs.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;
 
@@ -383,25 +383,25 @@ export declare type Modality = typeof Modality.Type;
  */
 export declare const nextRuns: (cadence: FlowCadence, from: Date, count?: number) => ReadonlyArray<Date>;
 
-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;
@@ -413,62 +413,62 @@ export declare type RunReview = typeof RunReview.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;
     }>>;
 }>;
 
@@ -500,16 +500,16 @@ export declare interface RunStep {
     readonly review?: RunReview | undefined;
 }
 
-declare const RunStepStatus: Schema.Literal<["pending", "running", "waiting", "succeeded", "failed", "skipped"]>;
+declare const RunStepStatus: Schema.Literals<readonly ["pending", "running", "waiting", "succeeded", "failed", "skipped"]>;
 
 declare type RunStepStatus = typeof RunStepStatus.Type;
 
 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
@@ -522,7 +522,7 @@ declare interface StepCondition {
 }
 
 /** 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;
 
@@ -537,10 +537,10 @@ export declare type StepType = typeof StepType.Type;
  * later, or reconciled against an invoice.
  */
 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>;
 }>;
 
 declare type StepUsage = typeof StepUsage.Type;
@@ -569,41 +569,41 @@ export declare const useFlowReview: (runId: string | undefined, options?: FlowHo
     /** `true` when there is a review this caller can answer right now. */
     canRespond: boolean;
     respond: (runId: string, stepIndex: number, response: HumanResponse) => Promise<{
-        readonly status: "accepted";
         readonly runId: string;
+        readonly stepIndex: number;
         readonly executionId: string;
         readonly eventId: string;
-        readonly stepIndex: number;
+        readonly status: "accepted";
     }>;
     approve: (runId: string, stepIndex: number, text?: string) => Promise<{
-        readonly status: "accepted";
         readonly runId: string;
+        readonly stepIndex: number;
         readonly executionId: string;
         readonly eventId: string;
-        readonly stepIndex: number;
+        readonly status: "accepted";
     }>;
     reject: (runId: string, stepIndex: number, text?: string) => Promise<{
-        readonly status: "accepted";
         readonly runId: string;
+        readonly stepIndex: number;
         readonly executionId: string;
         readonly eventId: string;
-        readonly stepIndex: number;
+        readonly status: "accepted";
     }>;
     /** Pick one of a `choice` review's options. */
     choose: (runId: string, stepIndex: number, value: string) => Promise<{
-        readonly status: "accepted";
         readonly runId: string;
+        readonly stepIndex: number;
         readonly executionId: string;
         readonly eventId: string;
-        readonly stepIndex: number;
+        readonly status: "accepted";
     }>;
     /** Answer a `text` review. */
     submitText: (runId: string, stepIndex: number, text: string) => Promise<{
-        readonly status: "accepted";
         readonly runId: string;
+        readonly stepIndex: number;
         readonly executionId: string;
         readonly eventId: string;
-        readonly stepIndex: number;
+        readonly status: "accepted";
     }>;
     pending: boolean;
     error: unknown;
@@ -646,8 +646,8 @@ export declare const useLaunchFlow: (options?: FlowHookOptions) => {
             readonly workflowName: string;
             readonly deferral?: {
                 readonly mode: string;
-                readonly retryAfterMs: number | null;
                 readonly dueAt: number | null;
+                readonly retryAfterMs: number | null;
                 readonly intentId: string | null;
             } | undefined;
         };
@@ -664,8 +664,8 @@ export declare const useLaunchFlow: (options?: FlowHookOptions) => {
             readonly workflowName: string;
             readonly deferral?: {
                 readonly mode: string;
-                readonly retryAfterMs: number | null;
                 readonly dueAt: number | null;
+                readonly retryAfterMs: number | null;
                 readonly intentId: string | null;
             } | undefined;
         };
@@ -683,41 +683,41 @@ export declare const useLaunchFlow: (options?: FlowHookOptions) => {
  */
 export declare const useRespondToFlow: (options?: FlowHookOptions) => {
     respond: (runId: string, stepIndex: number, response: HumanResponse) => Promise<{
-        readonly status: "accepted";
         readonly runId: string;
+        readonly stepIndex: number;
         readonly executionId: string;
         readonly eventId: string;
-        readonly stepIndex: number;
+        readonly status: "accepted";
     }>;
     approve: (runId: string, stepIndex: number, text?: string) => Promise<{
-        readonly status: "accepted";
         readonly runId: string;
+        readonly stepIndex: number;
         readonly executionId: string;
         readonly eventId: string;
-        readonly stepIndex: number;
+        readonly status: "accepted";
     }>;
     reject: (runId: string, stepIndex: number, text?: string) => Promise<{
-        readonly status: "accepted";
         readonly runId: string;
+        readonly stepIndex: number;
         readonly executionId: string;
         readonly eventId: string;
-        readonly stepIndex: number;
+        readonly status: "accepted";
     }>;
     /** Pick one of a `choice` review's options. */
     choose: (runId: string, stepIndex: number, value: string) => Promise<{
-        readonly status: "accepted";
         readonly runId: string;
+        readonly stepIndex: number;
         readonly executionId: string;
         readonly eventId: string;
-        readonly stepIndex: number;
+        readonly status: "accepted";
     }>;
     /** Answer a `text` review. */
     submitText: (runId: string, stepIndex: number, text: string) => Promise<{
-        readonly status: "accepted";
         readonly runId: string;
+        readonly stepIndex: number;
         readonly executionId: string;
         readonly eventId: string;
-        readonly stepIndex: number;
+        readonly status: "accepted";
     }>;
     pending: boolean;
     error: unknown;
@@ -735,8 +735,8 @@ export declare const useRetryFlow: (options?: FlowHookOptions) => {
             readonly workflowName: string;
             readonly deferral?: {
                 readonly mode: string;
-                readonly retryAfterMs: number | null;
                 readonly dueAt: number | null;
+                readonly retryAfterMs: number | null;
                 readonly intentId: string | null;
             } | undefined;
         };
@@ -746,7 +746,7 @@ export declare const useRetryFlow: (options?: FlowHookOptions) => {
 };
 
 /** 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;
 

package/dist/web.js

@@ -1,4 +1,4 @@
-import { n as e, t } from "./cadence-_9Izk_fL.js";
+import { cadenceMatches as e, nextRuns as t } from "./cadence.js";
 import { useAction as n, useSubscription as r } from "@voltro/client";
 //#region src/web.ts
 var i = {
@@ -96,4 +96,4 @@ var i = {
 	};
 };
 //#endregion
-export { i as DEFAULT_FLOW_RPC_TAGS, t as cadenceMatches, e as nextRuns, p as useCancelFlow, h as useFlowReview, c as useFlowRun, l as useFlowRuns, u as useFlows, d as useLaunchFlow, m as useRespondToFlow, f as useRetryFlow };
+export { i as DEFAULT_FLOW_RPC_TAGS, e as cadenceMatches, t as nextRuns, p as useCancelFlow, h as useFlowReview, c as useFlowRun, l as useFlowRuns, u as useFlows, d as useLaunchFlow, m as useRespondToFlow, f as useRetryFlow };