@w6w/embed 0.0.0-stage → 0.1.1

package/dist/lib/workflow-live-run.d.ts

@@ -0,0 +1,165 @@
+import { RunStatus } from '@w6w/sdk';
+export type { RunStatus };
+/**
+ * The five states a workflow step's execution can be in — a thin LOCAL copy
+ * of `@w6w/ui`'s `StepStatus` (itself a thin local copy of the engine's
+ * `StepStatus` — see `run-visuals.ts`'s own header in `packages/ui`, the
+ * same house idiom). `@w6w/sdk/console`'s `RunState.steps` is deliberately
+ * typed `Record<string, unknown>` — opaque pass-through, by that module's
+ * own documented design — so the real per-step shape has to be re-stated
+ * here rather than imported.
+ */
+export type StepStatus = "pending" | "running" | "succeeded" | "failed" | "skipped";
+/** The per-step metadata (which app/version/action/connection ran) — one
+ *  local structural copy of the pinned `StepMeta`. A `type` alias, not an
+ *  `interface`, so it stays assignable to index-signature types. */
+export type StepMetaLike = {
+    app: string;
+    version: string;
+    action: string;
+    connectionId: string | null;
+};
+/** The slice of a `StepExecution` this module reads, to build one
+ *  `ExecutionLogPanel` row. */
+export interface StepExecutionLike {
+    status: StepStatus;
+    startedAt?: string;
+    finishedAt?: string;
+    input?: unknown;
+    output?: unknown;
+    /** `StepExecution.error` — a `StepError` on `failed` per rfcs/workflow.md
+     *  §StepExecution, but read as `unknown` because `RunState.steps` is opaque
+     *  on the wire; {@link toLogError} normalises whatever actually arrives. */
+    error?: unknown;
+    /** Recorded metadata; absent (or null) for steps that recorded none. */
+    meta?: StepMetaLike | null;
+}
+/** A step or run error, as the run log panel renders it — field-for-field
+ *  `@w6w/ui`'s `ExecutionLogError` (rfcs/workflow.md §StepError's
+ *  `code`/`message`/`phase`/`retryable`), restated locally for the same reason
+ *  as {@link ExecutionLogStepLike} below. `message` is never empty. */
+export interface LogErrorLike {
+    code?: string;
+    message: string;
+    phase?: string;
+    retryable?: boolean;
+}
+/** One `RunState.stepErrors` entry the panel shows at run level — field-for-field
+ *  `@w6w/ui`'s `ExecutionLogRecordedError`, restated locally (see above). */
+export interface RecordedLogErrorLike {
+    stepId: string;
+    label?: string;
+    error: LogErrorLike;
+}
+/** The slice of a `RunState` {@link runLevelErrors} reads. */
+export interface RunErrorSourceLike {
+    status?: string;
+    error?: unknown;
+    stepErrors?: ReadonlyArray<{
+        stepId: string;
+        error: unknown;
+    }>;
+}
+/** The slice of a saved step-test fixture (`StepTest`) {@link latestFixtureInput}
+ *  reads — `with` is what the trigger's Test tab invokes it with. */
+export interface StepTestFixtureLike {
+    with?: unknown;
+}
+/** The row-level fallback for a `failed` step that carries no `error` at all. */
+export declare const STEP_FAILED_NO_REASON = "Step failed without reporting a reason.";
+/** The run-level fallback for a `failed` run where nothing carries a reason. */
+export declare const RUN_FAILED_NO_REASON = "Run failed without reporting a reason.";
+/** One `ExecutionLogPanel` row — field-for-field `@w6w/ui`'s
+ *  `ExecutionLogStep`, restated locally for the same reason as
+ *  {@link StepExecutionLike} above (no runtime dependency on `@w6w/ui`,
+ *  which this module must not import — see the file header). */
+export interface ExecutionLogStepLike {
+    id: string;
+    status: StepStatus;
+    startedAt?: string;
+    finishedAt?: string;
+    input?: unknown;
+    output?: unknown;
+    error?: LogErrorLike;
+    meta?: StepMetaLike;
+}
+/** How a cancel-request failure should be handled (A6). */
+export type CancelErrorOutcome = "reconcile" | "surface";
+/**
+ * A2/M1 — the `refetchInterval` decision: keep polling (`true`) until the
+ * run's status is terminal (`false`), including while no run has answered
+ * yet (`status === undefined` — the very first poll hasn't landed, or no run
+ * is active at all).
+ */
+export declare function shouldContinuePolling(status: RunStatus | undefined): boolean;
+/**
+ * A4/M2/M3 — is a run currently "in flight" from this page's point of view?
+ * `true` only while the poll has a live, non-terminal status AND the poll
+ * itself hasn't given up/errored — a failed poll unlocks the canvas exactly
+ * like reaching a real terminal status does (A4's own named failure case: "a
+ * canvas that stays locked after a cancel"). Drives the canvas's `readOnly`
+ * prop, the Stop button's visibility, and the Run button's disabled state —
+ * one function, three call sites, so they can never drift out of sync with
+ * each other.
+ */
+export declare function isRunInFlight(status: RunStatus | undefined, pollFailed: boolean): boolean;
+/** A1/A6 — what the Run button should read right now. */
+export declare function runButtonLabel(status: RunStatus | undefined, pollFailed: boolean): string;
+/**
+ * A6/M6 — classify a `cancel()` failure. `run_not_cancelable` (409) means
+ * the run already reached a terminal state before the cancel request landed
+ * — not a user-facing error, just reconcile to whatever the next poll
+ * reports. Everything else (`unknown_run`, a network failure, …) is a real
+ * failure the page's existing error affordance must show.
+ */
+export declare function classifyCancelError(code: string): CancelErrorOutcome;
+/**
+ * G5 — map a `RunState`'s opaque `steps` record onto `ExecutionLogPanel`'s
+ * row shape, in the record's own key order (the order the server checkpoints
+ * steps in, so it already reads as execution order). `ExecutionLogPanel`'s
+ * own contract is "never re-sorted" (`ExecutionLogPanel.tsx`'s header), so
+ * this function must not reorder either.
+ */
+export declare function mapRunStateToLogSteps(steps: Record<string, StepExecutionLike> | undefined): ExecutionLogStepLike[];
+/**
+ * Normalise whatever a step or run reported as its error into the panel's
+ * {@link LogErrorLike}. `null`/`undefined` mean "no error". A non-empty string
+ * is the message. An object contributes `code` (string), `message` (its own
+ * non-empty `message`, else a non-empty `code`, else its JSON), `phase`
+ * (string) and `retryable` (boolean). Anything else is stringified. The
+ * returned `message` is never empty.
+ */
+export declare function toLogError(raw: unknown): LogErrorLike | undefined;
+/**
+ * The run-level half of the run log: `RunState.error` as `runError`, plus the
+ * `RunState.stepErrors` entries whose step has NO row already carrying an
+ * error (a `continue-record` failure is usually also on its own row — showing
+ * it twice would read as two failures), in their given order. A row showing
+ * only {@link STEP_FAILED_NO_REASON} does not count as carrying an error here,
+ * so the reason recorded for that step is still surfaced. A `failed` run where
+ * nothing — run, rows or surfaced step errors — carries a reason gets
+ * {@link RUN_FAILED_NO_REASON}. `runError` is omitted when it duplicates a
+ * row's error (equal `message` and equal `code`), since the step failure that
+ * stopped the run is already shown on its row. It is likewise omitted when it
+ * duplicates a surfaced `stepErrors` entry's error, by the same equality.
+ * Keys are omitted when empty.
+ */
+export declare function runLevelErrors(run: RunErrorSourceLike | undefined, rows: ReadonlyArray<ExecutionLogStepLike>): {
+    runError?: LogErrorLike;
+    stepErrors?: RecordedLogErrorLike[];
+};
+/**
+ * The header Run's `input`: the LAST saved fixture's `with` (`listStepTests`
+ * answers oldest-first — the same "last is latest" reading
+ * `@w6w/ui`'s `TriggerFillForm` seeds from), when it is a plain object.
+ * Sent verbatim — `{type:"expr",…}` values included.
+ */
+export declare function latestFixtureInput(tests: ReadonlyArray<StepTestFixtureLike> | undefined): Record<string, unknown> | undefined;
+/**
+ * Resolve the header Run's `input` for the manual trigger `triggerStepId`.
+ * No trigger id → `undefined` without fetching. A fetch that throws or
+ * rejects → `undefined`: a missing fixture never blocks the run. Fetched at
+ * click time on purpose — a cached `stepTestsKey` query can be stale, since
+ * saving a fixture does not invalidate it.
+ */
+export declare function resolveHeaderRunInput(triggerStepId: string | undefined, list: (stepId: string) => Promise<ReadonlyArray<StepTestFixtureLike> | undefined>): Promise<Record<string, unknown> | undefined>;

package/dist/lib/workflow-poll.d.ts

@@ -0,0 +1,8 @@
+import { RunState } from '@w6w/sdk/console';
+/**
+ * Poll `getRun` until the run reaches a terminal status, or 600 polls (~5
+ * minutes at the default 500ms interval) elapse — whichever comes first.
+ * Ported verbatim from `api/client.ts`'s `runWorkflow`; see
+ * `../repos/workflows.ts` for the caller.
+ */
+export declare function pollRunToTerminal(getRun: () => Promise<RunState>, sleep?: (ms: number) => Promise<void>): Promise<RunState>;

package/dist/lib/workflow-route.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Read the legacy `edit` parameter off a location's search string.
+ *
+ * Returns `null` when there is nothing to redirect: no `edit` key at all, or
+ * one that is empty (`?edit=` is not an id). Otherwise `id` is the `edit`
+ * value and `search` is the rest of the query — `edit` removed, every other
+ * parameter kept in its original order — as a leading-`?` search string, or
+ * `""` when nothing is left.
+ *
+ *   legacyEditRedirect("?edit=wf_a")                  // { id: "wf_a", search: "" }
+ *   legacyEditRedirect("?edit=wf_a&tab=steps")        // { id: "wf_a", search: "?tab=steps" }
+ */
+export declare function legacyEditRedirect(search: string): {
+    id: string;
+    search: string;
+} | null;
+/**
+ * Read the `run` query param off a location's search string, honouring it
+ * only when it looks like a real run id.
+ *
+ *   runParamFromSearch("?run=run_1&x=1")   // "run_1"
+ *   runParamFromSearch("?run=")            // null
+ *   runParamFromSearch("?run=wf_1")        // null — not a run id
+ *   runParamFromSearch("")                 // null
+ */
+export declare function runParamFromSearch(search: string): string | null;

package/dist/lib/workflow-settings.d.ts

@@ -0,0 +1,72 @@
+import { WorkflowStatus } from '@w6w/sdk';
+/**
+ * Read a workflow definition's `status` field as the real three-state value.
+ *
+ * `WorkflowsPage.tsx` used to coerce this with `status === "active" ? "active" :
+ * "draft"` — a two-way ternary that silently collapsed a freshly-archived
+ * workflow back down to `"draft"`, which would have reproduced the same bug one
+ * layer up in the archive/delete button-swap (an archived workflow would render
+ * Archive again instead of Delete). `unknown` because the source is parsed JSON,
+ * not a validated value — anything that isn't exactly `"active"` or `"archived"`
+ * reads as `"draft"`, same fallback the old coercion used for a missing/garbage
+ * status.
+ */
+export declare function readWorkflowStatus(status: unknown): WorkflowStatus;
+/** Authoring presentation for one workflow. Declarative only — the engine ignores it. */
+export type WorkflowSettings = {
+    /** Persist edits without an explicit save. Omitted ⇒ **true**. */
+    autoSave?: boolean;
+    /** Persist step coordinates and `viewport` on save. Omitted ⇒ **true**. */
+    savePosition?: boolean;
+    /** The canvas camera, written by the editor — never by the settings modal. */
+    viewport?: {
+        x: number;
+        y: number;
+        zoom: number;
+    };
+};
+/** Both flags resolved against their defaults. */
+export type EffectiveWorkflowSettings = {
+    autoSave: boolean;
+    savePosition: boolean;
+};
+/**
+ * The effective flags for a workflow, applying the **true-by-default** rule.
+ *
+ * ⚠️ Both flags are `true` when omitted. That is deliberately *unlike* the house
+ * convention `ports` and `onError` follow, where an absent field reproduces
+ * prior behaviour: here the product requires both features on by default, so an
+ * absent `settings` object means auto-save **on** and positions **persisted**.
+ * The RFC states it three ways and names `?? false` as a contradiction. Only an
+ * explicit `false` turns a feature off — hence `!== false`, which also refuses
+ * to read `null`, `0` or `"false"` out of a hand-edited definition as "off".
+ *
+ * Takes `unknown` because the caller's source is parsed JSON, not a validated
+ * value; every non-object reads as "no flags set", i.e. both on.
+ */
+export declare function readSettings(settings: unknown): EffectiveWorkflowSettings;
+/**
+ * Set one flag, returning the `settings` object to store.
+ *
+ * Two rules, both about *not* writing more than was asked:
+ *
+ * 1. **The default is written as absent.** `true` deletes the key instead of
+ *    storing `autoSave: true` (the same idiom as an omitted `onError: "fail"`).
+ *    Otherwise merely opening this modal on a legacy workflow and toggling
+ *    something back would rewrite the definition of every workflow ever
+ *    authored — and with auto-save on, that write happens by itself.
+ * 2. **Everything else survives verbatim**, `viewport` above all: it is the
+ *    author's saved camera, written by the editor, and a whole-object replace
+ *    here would silently discard it on the next toggle.
+ *
+ * Returns `undefined` when nothing is left to store, so the caller drops the
+ * key entirely rather than persisting an empty object.
+ *
+ * The input is `unknown` for the same reason `readSettings`' is — it comes straight
+ * out of `JSON.parse`, and the `</>` editor in the very same header lets an author
+ * write `"settings": "hello"`. Spreading that would persist `{"0":"h","1":"e",…}`,
+ * and with auto-save on the rewrite would repeat on a debounce, without anyone
+ * clicking anything. So anything that is not a plain object reads as "no flags
+ * set", exactly as it does in `readSettings`.
+ */
+export declare function writeSetting(settings: unknown, key: "autoSave" | "savePosition", value: boolean): WorkflowSettings | undefined;

package/dist/lib/workflow-validity.d.ts

@@ -0,0 +1,92 @@
+/**
+ * The publish-time validity gate (`logs/decisions.jsonl` row 9, verbatim):
+ *
+ * > a step is valid iff (app+action set, or function id set) and all its
+ * > required params are filled (reuse `requiredParamsFilled`,
+ * > `StepBuilderModal.tsx:577-590`) and, where `testRequired` is set for the
+ * > app, its saved test has passed. The workflow is valid iff a trigger exists
+ * > and every step is valid. Graph well-formedness (orphaned/unreachable
+ * > nodes, dangling edges) is explicitly OUT of scope for this project.
+ *
+ * Pure and testable by design: `WorkflowsPage.tsx` is JSX, which Node 24's
+ * type-stripping cannot parse, so nothing in it can be loaded by `node --test`
+ * (same shape as `src/lib/workflow-save.ts` + its `.test.ts`). This module
+ * cannot import `@w6w/ui`/`@w6w/ui/flow` either way: `@w6w/ui`'s
+ * `package.json` `exports["."]` resolves to raw `./src/index.ts`, which
+ * re-exports `StepBuilderModal.tsx` — a `.tsx` file — so `node --test` throws
+ * `ERR_UNKNOWN_FILE_EXTENSION` the moment anything here imports it. Instead,
+ * the two functions the pinned predicate reuses
+ * (`requiredParamsFilled`/`isTestRequired`) are **caller-injected** on
+ * `ValidityContext` — `WorkflowsPage.tsx` (unaffected by the JSX constraint)
+ * imports the real ones from `@w6w/ui` and passes them in. Same for "a
+ * trigger exists": that reads a graph STEP whose `INTERNAL_NODES` entry has
+ * `group === "trigger"` (`@w6w/ui/flow`), never the workflow's top-level
+ * `trigger` field (`rfcs/workflow.md:114`, "Absent means manual-only" — always
+ * present, so it can't gate anything) — so `hasTrigger` is caller-computed too.
+ *
+ * `ActionParamLike`/`WorkflowStepLike`/`WorkflowLike` below are this file's
+ * own minimal local types (see `rfcs/workflow.md` §"Step" for the real shape,
+ * `rfcs/function.md` for the `uses.function` arm).
+ */
+/** A declared action/internal-node param, just enough of it for this gate. */
+export interface ActionParamLike {
+    key: string;
+    type: string;
+    required?: boolean;
+    default?: unknown;
+    children?: ActionParamLike[];
+}
+/** A workflow graph step, just enough of it for this gate. */
+export interface WorkflowStepLike {
+    id: string;
+    uses?: {
+        app?: string;
+        action?: string;
+        /** The "or a function id" arm (`rfcs/function.md:49,260`) — `Step.uses.function`. */
+        function?: string;
+    };
+    with?: Record<string, unknown>;
+}
+/** A workflow definition, just enough of it for this gate. */
+export interface WorkflowLike {
+    steps?: WorkflowStepLike[];
+    /**
+     * Present on real definitions, never read here — graph well-formedness
+     * (orphaned/unreachable nodes, dangling edges) is explicitly out of scope
+     * for the publish gate (`logs/decisions.jsonl` row 9).
+     */
+    edges?: unknown;
+}
+/**
+ * Everything `stepValid`/`workflowValid`/`invalidReason` need that this pure
+ * module cannot compute or import itself — see the module docstring for why
+ * each field is caller-built rather than derived in here.
+ */
+export interface ValidityContext {
+    /** Does the graph contain a step whose (app, action) is a trigger node? */
+    hasTrigger: boolean;
+    /** Declared params for a step's target, keyed `` `${app}::${action}` ``. */
+    actionParamsByKey: Record<string, ActionParamLike[]>;
+    /** The fetched apps list, keyed by app id — only a key present here is test-gated. */
+    appsById: Record<string, unknown>;
+    /** Whether the given step id has a saved test that last ran successfully. */
+    testStatus: Record<string, boolean>;
+    /** `@w6w/ui`'s `requiredParamsFilled`, injected (see module docstring). */
+    requiredParamsFilled: (params: ActionParamLike[], values: Record<string, unknown>) => boolean;
+    /** `@w6w/ui`'s `isTestRequired`, injected (see module docstring). */
+    isTestRequired: (app: unknown) => boolean;
+}
+/** Is this one step valid, per the pinned predicate? */
+export declare function stepValid(step: WorkflowStepLike, ctx: ValidityContext): boolean;
+/**
+ * Is the whole workflow valid? A trigger step must exist and every step must
+ * be individually valid — nothing about graph well-formedness (this never
+ * reads `workflow.edges`, even when present).
+ */
+export declare function workflowValid(workflow: WorkflowLike, ctx: ValidityContext): boolean;
+/**
+ * `null` when the workflow is valid; otherwise names the cause — `"no trigger
+ * step"`, or the id of the first invalid step in declared order plus which
+ * check it fails.
+ */
+export declare function invalidReason(workflow: WorkflowLike, ctx: ValidityContext): string | null;

package/dist/lib/workflow-variables.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The pure decisions behind a workflow's `variables` list (T1.1.5) — the
+ * Variables tab's authoring surface and the run page's generated-form
+ * projection. `variables` rides inside the workflow **definition**
+ * (`w6w-workflow/packages/types/mod.ts:170`), the same JSON document that
+ * already carries `steps`, so there is no column, no migration and no server
+ * change behind it.
+ *
+ * Pure, React-free, `.ts`, **no value import of `@w6w/ui`** — studio's
+ * `test:unit` is a bare `node --test` with no jsx loader
+ * (`studio/package.json:17`), so a value import of the barrel (which
+ * re-exports `.tsx`) kills the test. Same shape as `workflow-settings.ts`'s
+ * reader/writer discipline and `input-seeding.ts`'s pure-module docstring
+ * rule.
+ *
+ * The row type is defined **locally**, structurally identical to
+ * `WorkflowVariable` (`w6w-workflow/packages/types/mod.ts:40-45`: `key`,
+ * `type?`, `required?`, `default?`), so no cast is needed at the `.tsx`
+ * boundary in either direction.
+ */
+/** One row of a workflow's declared `variables` list. */
+export interface WorkflowVariableRow {
+    key: string;
+    type?: "string" | "number" | "boolean" | "object" | "array";
+    required?: boolean;
+    default?: unknown;
+}
+/**
+ * Read a workflow definition's `variables` field as an array of rows.
+ *
+ * Takes `unknown` because the source is `JSON.parse`d and the `</>` editor
+ * lets an author type anything: a non-array reads as no variables, and a
+ * non-object array entry is dropped rather than crashing the tab. **Never
+ * sorts, never de-dups, never re-orders** — declaration order *is*
+ * resolution order (D-5) and `resolveVariables` iterates the array in order
+ * (`w6w-workflow/packages/engine/src/run.ts:70-83`), so two rows sharing a
+ * key both survive, in the order they were declared.
+ */
+export declare function readVariables(raw: unknown): WorkflowVariableRow[];
+/**
+ * The rows ready to write back into the definition's `variables` field.
+ *
+ * Mirrors `workflow-settings.ts`'s "default written as absent" rule, but here
+ * it applies to a row's **optional flags, not the value**: `required` is
+ * omitted when `false` and `type` is omitted when unset, so opening the tab
+ * and touching nothing does not rewrite a legacy definition into
+ * `{required:false,type:undefined}` rows. `default` is user data and is kept
+ * **verbatim** — including `false`, `0`, `""` and `null` — never dropped as
+ * an optimisation (a "drop falsy" implementation would lose a `false`
+ * default, which is exactly the case the tests pin).
+ *
+ * Returns `undefined` for an empty array (never `[]`) so the caller
+ * (`patchMeta`, via `JSON.stringify`) drops the key entirely — which matters
+ * beyond hygiene here: `draftFromWorkflowVariables`
+ * (`server/packages/api/mcp/tool-schema.ts:310-326`) treats `undefined` and
+ * `length === 0` identically (pass-through), so `[]` and absent already agree
+ * on the wire; this just keeps the definition itself from growing an empty
+ * `"variables": []` on the first open of the tab.
+ */
+export declare function variablesForSave(rows: WorkflowVariableRow[]): WorkflowVariableRow[] | undefined;
+/**
+ * Every index whose `key` repeats an earlier row's key. `resolveVariables`
+ * writes `vars[v.key]` in a loop with no duplicate check (`run.ts:74-80`), so
+ * a later row silently wins — this is informational only (the tab marks the
+ * row; nothing here blocks a save), never de-duping or rejecting.
+ */
+export declare function duplicateKeyIndexes(rows: WorkflowVariableRow[]): number[];
+/**
+ * The `vars.*` names to offer row `index`'s expression rail: the keys of
+ * rows **strictly above** it, then `projectVars`, deduped, with blanks
+ * dropped. Declaration order is resolution order (D-5), so a row can only
+ * reference a variable declared earlier than itself — offering a row at or
+ * below `index` would suggest a forward reference the engine rejects
+ * (T2.1.1). This is the offered rail only; it is not validation.
+ */
+export declare function varsRailFor(rows: WorkflowVariableRow[], index: number, projectVars: string[]): string[];
+/** `true` if `v` is an `ExprValue` envelope — the two-key check `@w6w/ui`'s
+ *  `isExprValue` (`ui/src/types.ts:301-309`) makes, re-implemented locally
+ *  because this module cannot import `@w6w/ui` at value level (see the
+ *  module docstring). Mirrors `trigger-preview.ts:102-119`'s sanctioned
+ *  pattern for the same constraint — this is not duplication. */
+export declare function isExprDefault(v: unknown): boolean;
+/** One field the run page's generated form fills — structurally assignable
+ *  to `@w6w/ui/flow`'s `TriggerFieldDef` (all fields optional) with no cast. */
+export interface RunFormField {
+    key: string;
+    type?: WorkflowVariableRow["type"];
+    default?: unknown;
+    required?: boolean;
+}
+/**
+ * Project a workflow's declared variables into the run page's form fields.
+ *
+ * A row whose `default` is an `ExprValue` envelope is a server-side
+ * computation (its value is resolved at run time, not authored on the
+ * client), so it is emitted with **`default` dropped and `required: false`**
+ * — never as a value `ui`'s `seedValues` would `String(...)` the envelope
+ * into — and its key is listed in `computed` so the host can label the field
+ * "computed at run time" and post nothing for it. A row with a blank/missing
+ * key is dropped, mirroring `@w6w/ui`'s `fieldsToParams`, which does the same
+ * before turning field definitions into a fillable form.
+ */
+export declare function runFormFields(rows: WorkflowVariableRow[]): {
+    fields: RunFormField[];
+    computed: string[];
+};

package/dist/lib.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/index'
+export {}

package/dist/lib.mjs

@@ -0,0 +1,62 @@
+"use client";
+import { A as n, b as d, d as c, a as u, c as p, e as m, f as S, g as f, h as g, i as v, j as w, k as R, l as b, m as h, n as y, o as F, p as A, q as K, r as C, s as D, t as E, u as I, v as x, w as P, x as V, y as L, z as U, B as k, C as H, D as W, E as _, F as j, G, H as N, I as O, J as q, K as z, L as B, M as J, N as M, O as T } from "./slug-ByKQgxrf.js";
+import { i as Q, s as X } from "./spec-import-invalidation-D3retX4Q.js";
+function t(s) {
+  const e = new URLSearchParams(s), a = e.get("edit");
+  if (a === null || a === "") return null;
+  e.delete("edit");
+  const i = e.toString();
+  return { id: a, search: i === "" ? "" : `?${i}` };
+}
+function r(s) {
+  const a = new URLSearchParams(s).get("run");
+  return a != null && a.startsWith("run_") ? a : null;
+}
+export {
+  n as ACCOUNT_SLUG_RE,
+  d as buildSnippet,
+  c as definitionWithPolicy,
+  u as documentSampleValues,
+  p as duplicateKeyIndexes,
+  m as errorHandlerSelfDecision,
+  S as evaluateEdit,
+  f as filterKeyInput,
+  g as hasDefinitionActions,
+  v as hasDelete,
+  w as hasVersionHistory,
+  R as invalidReason,
+  Q as invalidateImportedCallable,
+  b as isCodeRailAvailable,
+  h as isEndpointKey,
+  y as isExprDefault,
+  F as isRowArchived,
+  A as isSettingsRailAvailable,
+  K as isUrnAddressable,
+  C as isValidAccountSlug,
+  t as legacyEditRedirect,
+  D as metadataFieldsForKind,
+  E as parseImportPaste,
+  I as policyFromDefinition,
+  x as projectDocumentSources,
+  P as readSettings,
+  V as readVariables,
+  L as readWorkflowStatus,
+  U as restoreRailState,
+  k as runFormFields,
+  r as runParamFromSearch,
+  H as slugify,
+  W as specCollectionForKind,
+  X as specImportListKey,
+  _ as stepValid,
+  j as toSnippetCallable,
+  G as triggerInputSeed,
+  N as triggerPreviews,
+  O as unavailableReason,
+  q as variablesForSave,
+  z as varsRailFor,
+  B as visibleRows,
+  J as workflowKeyEditAllowed,
+  M as workflowValid,
+  T as writeSetting
+};
+//# sourceMappingURL=lib.mjs.map

package/dist/lib.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.mjs","sources":["../src/lib/workflow-route.ts"],"sourcesContent":["// T4.1.1 (R-3): `/<account>/<project>/workflows/:id` is the workflow visual\n// editor's canonical URL; the older `workflows?edit=<id>` form survives only as\n// an alias. Parsing that alias is a pure URL question with no React and no\n// router in it, so it lives here — `.ts`, zero imports — rather than inline in\n// `WorkflowsPage.tsx`, which `node --test` cannot load (JSX).\n\n/**\n * Read the legacy `edit` parameter off a location's search string.\n *\n * Returns `null` when there is nothing to redirect: no `edit` key at all, or\n * one that is empty (`?edit=` is not an id). Otherwise `id` is the `edit`\n * value and `search` is the rest of the query — `edit` removed, every other\n * parameter kept in its original order — as a leading-`?` search string, or\n * `\"\"` when nothing is left.\n *\n *   legacyEditRedirect(\"?edit=wf_a\")                  // { id: \"wf_a\", search: \"\" }\n *   legacyEditRedirect(\"?edit=wf_a&tab=steps\")        // { id: \"wf_a\", search: \"?tab=steps\" }\n */\nexport function legacyEditRedirect(search: string): { id: string; search: string } | null {\n  const params = new URLSearchParams(search);\n  const id = params.get(\"edit\");\n  if (id === null || id === \"\") return null;\n  params.delete(\"edit\");\n  const rest = params.toString();\n  return { id, search: rest === \"\" ? \"\" : `?${rest}` };\n}\n\n// T2.4.2 — the History page's \"open in visual view\" link lands on\n// `workflows/:id?run=<runId>`; `WorkflowsPage` reads the `run` param on mount\n// and seeds `activeRunId` from it (EXTEND, not rebuild — the live-run\n// overlay machinery already handles a terminal run identically to a live\n// one). Guarded to `run_`-prefixed values only, so an unrelated/garbled\n// param (or this file's OWN `edit` alias from a stale link) never gets\n// treated as a run id.\n\n/**\n * Read the `run` query param off a location's search string, honouring it\n * only when it looks like a real run id.\n *\n *   runParamFromSearch(\"?run=run_1&x=1\")   // \"run_1\"\n *   runParamFromSearch(\"?run=\")            // null\n *   runParamFromSearch(\"?run=wf_1\")        // null — not a run id\n *   runParamFromSearch(\"\")                 // null\n */\nexport function runParamFromSearch(search: string): string | null {\n  const params = new URLSearchParams(search);\n  const run = params.get(\"run\");\n  return run?.startsWith(\"run_\") ? run : null;\n}\n"],"names":["legacyEditRedirect","search","params","id","rest","runParamFromSearch","run"],"mappings":";;;AAkBO,SAASA,EAAmBC,GAAuD;AACxF,QAAMC,IAAS,IAAI,gBAAgBD,CAAM,GACnCE,IAAKD,EAAO,IAAI,MAAM;AAC5B,MAAIC,MAAO,QAAQA,MAAO,GAAI,QAAO;AACrC,EAAAD,EAAO,OAAO,MAAM;AACpB,QAAME,IAAOF,EAAO,SAAA;AACpB,SAAO,EAAE,IAAAC,GAAI,QAAQC,MAAS,KAAK,KAAK,IAAIA,CAAI,GAAA;AAClD;AAmBO,SAASC,EAAmBJ,GAA+B;AAEhE,QAAMK,IADS,IAAI,gBAAgBL,CAAM,EACtB,IAAI,KAAK;AAC5B,SAAOK,KAAA,QAAAA,EAAK,WAAW,UAAUA,IAAM;AACzC;"}

package/dist/project-context-Dbk0Gr1K.js

@@ -0,0 +1,16 @@
+import { createContext as o, useContext as r } from "react";
+const n = o(void 0);
+function u() {
+  return r(n);
+}
+function c(t, e) {
+  return t === void 0 ? e || null : t || null;
+}
+function s(t) {
+  return c(t, u());
+}
+export {
+  n as E,
+  s as u
+};
+//# sourceMappingURL=project-context-Dbk0Gr1K.js.map

package/dist/project-context-Dbk0Gr1K.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-context-Dbk0Gr1K.js","sources":["../src/project-context.ts"],"sourcesContent":["/**\n * Which project does an embedded editor save into? One answer, in one place.\n *\n * A project-less workflow save is not harmless: the server resolves a missing `?project=` to the\n * account default and WRITES it on update, silently moving the row there. The editor therefore\n * always names its project explicitly, or refuses. Internal to the embed package (not exported\n * from any barrel).\n */\nimport { createContext, useContext } from \"react\";\n\n/** The provider's project, as frozen with the applied client (see `W6WEmbedProvider`). */\nexport const EmbedProjectContext = createContext<string | undefined>(undefined);\n\nexport function useProvidedProject(): string | undefined {\n  return useContext(EmbedProjectContext);\n}\n\n/**\n * The editor's own prop wins over the provider's project. `undefined` (omitted) defers to the\n * provider; `null` or `\"\"` means \"no project yet\" and REFUSES (`null`) — it never falls through,\n * so a host whose project is still loading cannot have edits saved into the provider's project.\n * (`prop ?? provided` would be wrong: `null` would fall through.)\n */\nexport function resolveEditorProject(\n  prop: string | null | undefined,\n  provided: string | undefined,\n): string | null {\n  if (prop === undefined) return provided ? provided : null;\n  return prop ? prop : null;\n}\n\nexport function useEditorProject(prop: string | null | undefined): string | null {\n  return resolveEditorProject(prop, useProvidedProject());\n}\n"],"names":["EmbedProjectContext","createContext","useProvidedProject","useContext","resolveEditorProject","prop","provided","useEditorProject"],"mappings":";AAWO,MAAMA,IAAsBC,EAAkC,MAAS;AAEvE,SAASC,IAAyC;AACvD,SAAOC,EAAWH,CAAmB;AACvC;AAQO,SAASI,EACdC,GACAC,GACe;AACf,SAAID,MAAS,SAAkBC,KAAsB,OAC9CD,KAAc;AACvB;AAEO,SAASE,EAAiBF,GAAgD;AAC/E,SAAOD,EAAqBC,GAAMH,GAAoB;AACxD;"}

package/dist/project-context.d.ts

@@ -0,0 +1,11 @@
+/** The provider's project, as frozen with the applied client (see `W6WEmbedProvider`). */
+export declare const EmbedProjectContext: import('react').Context<string | undefined>;
+export declare function useProvidedProject(): string | undefined;
+/**
+ * The editor's own prop wins over the provider's project. `undefined` (omitted) defers to the
+ * provider; `null` or `""` means "no project yet" and REFUSES (`null`) — it never falls through,
+ * so a host whose project is still loading cannot have edits saved into the provider's project.
+ * (`prop ?? provided` would be wrong: `null` would fall through.)
+ */
+export declare function resolveEditorProject(prop: string | null | undefined, provided: string | undefined): string | null;
+export declare function useEditorProject(prop: string | null | undefined): string | null;

package/dist/rail/CodeTool.d.ts

@@ -0,0 +1,2 @@
+import { RailTool } from '../chrome/RightRail.tsx';
+export declare const codeTool: RailTool;

package/dist/rail/ErrorHandlingTool.d.ts

@@ -0,0 +1,22 @@
+import { RailTool } from '../chrome/RightRail.tsx';
+import { CallablePolicy } from '../lib/settings-rail.ts';
+/**
+ * `@w6w/ui/flow`'s `CALL_APP`, restated: a VALUE import from the flow subpath would put the whole
+ * canvas on the editor's eager path (the editor loads it with a dynamic `import()` only). A test
+ * (`workflow-editor.test.ts`) pins the two spellings equal.
+ */
+export declare const CALL_APP = "@w6w/call";
+export type ErrorHandlerKind = "function" | "endpoint" | "workflow";
+export interface ErrorHandlerSectionProps {
+    kind: ErrorHandlerKind;
+    id: string;
+    /** The policy as currently stored (already read off the definition or buffer). */
+    policy: CallablePolicy;
+    /** The definition (or buffer) the policy was read from is present. */
+    ready: boolean;
+    saving: boolean;
+    /** Write a whole new policy. `onError` shows a refusal inline. */
+    onPersist(next: CallablePolicy, onError: (message: string) => void): void;
+}
+export declare function ErrorHandlerSection({ kind, id, policy, ready, saving, onPersist, }: ErrorHandlerSectionProps): import("react").JSX.Element;
+export declare const errorHandlingTool: RailTool;

package/dist/rail/ExpressionScope.d.ts

@@ -0,0 +1,21 @@
+import { ExpressionOptions } from '@w6w/ui';
+import { ReactNode } from 'react';
+/**
+ * The current project's expression sources, as an `ExpressionOptions`.
+ *
+ * Exported because a surface that renders OUTSIDE `ProjectExpressionScope` —
+ * or one that needs the values themselves rather than the context — can still
+ * build the same object. Inside the scope, prefer inheriting it.
+ */
+export declare function useProjectExpressionOptions(project: string | null): ExpressionOptions;
+/**
+ * Provide the current project's expression sources to every route below.
+ *
+ * Mount once, inside `ProjectProvider` (it reads the active project) and around
+ * `Layout` (so every page inherits). It contributes no `inputs` and no `steps`
+ * on purpose — see the module doc.
+ */
+export declare function ProjectExpressionScope({ project, children, }: {
+    project: string | null;
+    children: ReactNode;
+}): import("react").JSX.Element;