@w6w/ui 0.2.11 → 0.2.55

package/dist/components/ExpressionOptions.d.ts

@@ -5,7 +5,18 @@ import { SecretValue } from '../types.ts';
  * sources — a step cannot reference its own output.
  */
 export declare function excludeSelfStep(steps: ExpressionStepSource[], selfId: string | null | undefined): ExpressionStepSource[];
-/** An upstream step whose output this field can reference (`steps.<id>.output`). */
+/** One pickable output field of a step / trigger event, as the rail lists it. */
+export interface ExpressionFieldSource {
+    key: string;
+    label?: string;
+    path?: boolean;
+    /**
+     * `true` for a key the app DECLARES but the step's real (fresh/persisted) shape lacks:
+     * offered muted, "declared by the app".
+     */
+    declaredOnly?: true;
+}
+/** An upstream step whose output this field can reference (`nodes.<id>.output`). */
 export interface ExpressionStepSource {
     /** Step id — the key under `steps` in the run scope. */
     id: string;
@@ -15,7 +26,7 @@ export interface ExpressionStepSource {
      * The step's output field keys, when any are known (a manual trigger's
      * configured `fields`, a built-in node's static output, or an app action's
      * shape — see `outputsFrom`). Each entry feeds exactly one ref —
-     * `steps.<id>.output.<key>` — which is the canonical form the engine resolves
+     * `nodes.<id>.output.<key>` — which is the canonical form the engine resolves (`steps.<id>…` is its compat alias)
      * (`RunScope.steps`; `core/rfcs/workflow.md` §"Expressions", `core/rfcs/node-types.md`
      * "Executing a trigger node yields the run's start payload … which downstream
      * nodes read as `steps.<triggerId>.output`").
@@ -27,18 +38,14 @@ export interface ExpressionStepSource {
      * **Omitted** (not `[]`) when the step declares no outputs, so a consumer can
      * tell "nothing declared" from "declared none" without a special case.
      */
-    outputs?: {
-        key: string;
-        label?: string;
-        path?: boolean;
-    }[];
+    outputs?: ExpressionFieldSource[];
     /**
-     * Where `outputs` came from, for an app-action step: the action's declared
-     * `output`, its `sample`, or the step's last test run (`output-shape.ts`).
+     * Where `outputs` came from, for an app-action step: a fresh test output, the persisted
+     * test shape, the action's declared `output`, or its `sample` (`output-shape.ts`).
      * An entry with `path: true` is a dot path into nested output (`start.utc`),
      * checked segment by segment; without it the key is one literal key.
      */
-    outputsFrom?: "declared" | "sample" | "test";
+    outputsFrom?: "fresh" | "persisted" | "declared" | "sample";
     /**
      * `true` when the step is an app action that declares no output shape and has
      * no test run yet — the picker tells the author to run a test to see fields.
@@ -46,12 +53,35 @@ export interface ExpressionStepSource {
     needsTest?: boolean;
     /**
      * `true` for an EXTERNAL app-action step only (R-7): the picker then offers a fixed
-     * Metadata group (`steps.<id>.meta.app|version|action|connectionId`). **Omitted, not
-     * `false`**, for triggers and every `@w6w/*` node. Carries no metadata VALUE: the group
-     * is just labels, and the value exists only at run time.
+     * Metadata group (`nodes.<id>.meta.app|version|action|connectionId`). **Omitted, not
+     * `false`**, for triggers and every `@w6w/*` node. Carries no metadata VALUE: the static
+     * values come from {@link ExpressionOptions.nodeMeta}.
      */
     hasMeta?: boolean;
 }
+/**
+ * One field of the merged workflow STATE a step reads (`state-shape.ts`), offered as
+ * `state.<key>` in the picker's "State" section. `paths` says whether every entry path into the
+ * step sets it (`all`) or only some (`some` — e.g. one of two converging triggers writes it).
+ */
+export interface ExpressionStateField extends ExpressionFieldSource {
+    paths: "all" | "some";
+}
+/**
+ * The For each a step sits in the body of: offered as the rail's "Loop" group (Current item,
+ * Index, one row per item field). Present only for a loop-body step.
+ */
+export interface ExpressionLoopSource {
+    foreachId: string;
+    /** Element [0] of the For each's resolved `items`. OMITTED (key absent) when unresolvable. */
+    itemSample?: unknown;
+    /** `inferOutputFields(itemSample)`. OMITTED when none. */
+    itemOutputs?: {
+        key: string;
+        label?: string;
+        path?: boolean;
+    }[];
+}
 /**
  * A document contributing pickable refs (`documents.<key>`, and one
  * `documents.<key>.<field>` per top-level field when it qualifies).
@@ -97,6 +127,12 @@ export interface ExpressionDocumentSource {
 /** Known variable/secret names offered in an ExpressionInput's insert menu. */
 export interface ExpressionOptions {
     vars?: string[];
+    /**
+     * Account-level constants (`const.<name>`): read-only, set by an
+     * administrator, ordinary data (not secret). Offered as insertable chips
+     * only — there is deliberately no create callback.
+     */
+    constants?: string[];
     secrets?: string[];
     /**
      * Function/run input keys in scope (`inputs.<name>`). Present when the field
@@ -113,15 +149,65 @@ export interface ExpressionOptions {
     documents?: ExpressionDocumentSource[];
     /**
      * The workflow state leading to this step: upstream steps whose output is in
-     * scope (`steps.<id>.output`). Present only in a workflow context; omitted for
+     * scope (`nodes.<id>.output`). Present only in a workflow context; omitted for
      * a standalone field.
      */
     steps?: ExpressionStepSource[];
+    /** The enclosing For each, when the field belongs to a loop-body step (`foreach.item` / `foreach.index`). */
+    loop?: ExpressionLoopSource;
+    /**
+     * The merged workflow state this step reads (starting data, variables and upstream writers;
+     * `state-shape.ts`). The picker lists it as the "State" section, only when non-empty.
+     */
+    stateShape?: {
+        fields: ExpressionStateField[];
+    };
     /** Whether a trigger event is in scope (`trigger.event`). */
     hasTrigger?: boolean;
+    /**
+     * The trigger event's fields, offered as `trigger.event.<key>` under the `trigger.event`
+     * chip: the payload the entry trigger last ran with, else an app trigger's declared event
+     * fields. Omitted when none are known.
+     */
+    eventOutputs?: ExpressionFieldSource[];
+    /**
+     * Where {@link eventOutputs} came from: a test this session (`fresh`), the server's remembered
+     * sample (`persisted`), the trigger's declared `output`, or its `sample`.
+     */
+    eventOutputsFrom?: ExpressionStepSource["outputsFrom"];
+    /**
+     * Which tier each value in {@link sampleValues} came from, keyed by the same full ref:
+     * a fresh test output, the persisted test (`from last test`) or the app's declared
+     * `sample` (`example from the app`). A ref absent here is not a step/event value.
+     */
+    valueSources?: Record<string, "fresh" | "persisted" | "sample">;
+    /**
+     * Every node's configuration keys, read as `nodes.<id>.config.<key>` on any run whether or not
+     * the node runs — its literal settings, and a webhook trigger's `url`. Offered as the rail's
+     * "Node settings" group, for every node, not only upstream ones. Workflow context only.
+     */
+    nodeConfigs?: {
+        id: string;
+        keys: string[];
+    }[];
+    /**
+     * Each node's configuration VALUES, keyed by node id — what a run reads at
+     * `nodes.<id>.meta.config` (`nodeConfigOf`): authored literal params (never a secret, never a
+     * binding) plus a webhook trigger's `url` from its subscription. The Test tab and the Result
+     * preview resolve config refs against it. Workflow context only.
+     */
+    nodeConfig?: Record<string, Record<string, unknown>>;
+    /**
+     * Each node's static metadata VALUES, keyed by node id — what a run reads at
+     * `nodes.<id>.meta.<key>` whether or not the node ran (`nodeMetaOf`): `app`, `action`,
+     * `connectionId`, the `version` the canvas labels it with, and a webhook trigger's
+     * `subscriptionId` / `url`. Offered as Metadata leaves
+     * in the picker and resolved by the previews. Workflow context only.
+     */
+    nodeMeta?: Record<string, Record<string, unknown>>;
     /**
      * Design-time sample values the Result preview substitutes for known refs,
-     * keyed by FULL ref (`"vars.from_email"`, `"documents.test"`). Seeded by the
+     * keyed by FULL ref (`"var.from_email"`, `"documents.test"`). Seeded by the
      * host from the project's real vars/documents so the preview shows actual
      * values instead of the raw `{{ ref }}` template. Optional — a user-typed
      * Sample value still overrides, and unknown refs keep the raw fallback.

package/dist/components/HtmlPreview.d.ts

@@ -0,0 +1,7 @@
+/** Vendor HTML is hostile. NEVER dangerouslySetInnerHTML it; this is the only render path. */
+export declare const HTML_PREVIEW_CSP = "default-src 'none'; style-src 'unsafe-inline'; img-src data:; base-uri 'none'; form-action 'none'";
+/** The CSP meta is FIRST so it is parsed into <head> before any payload byte. */
+export declare function htmlPreviewSrcDoc(html: string): string;
+export declare function HtmlPreview({ html }: {
+    html: string;
+}): import("react").JSX.Element;

package/dist/components/JsonTree.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A read-only, dependency-free tree for a parsed JSON value.
+ *
+ * Deliberately NOT exported from `src/index.ts` (`T0.1.1` pin 2): the public
+ * way to show a result is `ResultViewer`, which owns the format decision and
+ * the toolbar. `JsonTree` is the piece `ResultViewer` composes for
+ * `format: "json"`, so it stays private until a consumer needs a bare tree.
+ *
+ * Two properties everything here is built around:
+ *
+ *  - **Nothing is injected.** Every key, every scalar and every brace reaches
+ *    the DOM as a React text child — there is no `dangerouslySetInnerHTML`
+ *    anywhere in this file. A property key such as `"<img onerror=…>"` is just
+ *    text, which is the whole point: the value came from a vendor API.
+ *  - **Collapsing is a native `<details>`.** The children are always rendered
+ *    and the browser hides them, so collapsed text stays in the DOM: it is
+ *    selectable, findable by the browser's find-in-page, and readable by a
+ *    test. Re-rendering the subtree "only when open" would silently make the
+ *    collapsed content unreachable.
+ */
+export interface JsonTreeProps {
+    /** Any value; objects and arrays become collapsible nodes, the rest leaves. */
+    value: unknown;
+    /**
+     * How many levels start open. A node at depth `d` (root `d = 0`) is open iff
+     * `d < expandDepth`, so the default `2` opens the root and its children —
+     * enough to see the shape of a response without scrolling. `Infinity` opens
+     * everything; `1` leaves only the root open.
+     */
+    expandDepth?: number;
+}
+export declare function JsonTree({ value, expandDepth }: JsonTreeProps): import("react").JSX.Element;

package/dist/components/ResolvedParams.d.ts

@@ -15,6 +15,11 @@ export interface ResolvedParamsProps {
      * the trigger arm, and two side by side is a defect, not a feature).
      */
     view?: "props" | "code";
+    /**
+     * Param keys the host sends as SOURCE TEXT, never resolved (`@w6w/script`'s `code`, the
+     * engine's `LITERAL_PARAMS`): shown verbatim, so a `{{ }}` in them never reads as a value.
+     */
+    literalKeys?: readonly string[];
 }
 /**
  * Read-only sibling of `ParamsForm`: for every configured param, shows the
@@ -28,4 +33,4 @@ export interface ResolvedParamsProps {
  * the static chip vocabulary (`varLabel`, `.w6w-expr-chip-*`) rather than
  * `expression-dom.ts`'s DOM-painting, which is for the editable field.
  */
-export declare function ResolvedParams({ params, values, testStartState, view, }: ResolvedParamsProps): import("react").JSX.Element;
+export declare function ResolvedParams({ params, values, testStartState, view, literalKeys, }: ResolvedParamsProps): import("react").JSX.Element;

package/dist/components/ResultViewer.d.ts

@@ -0,0 +1,46 @@
+export interface ResultViewerProps {
+    /** The result as the host received it: an already-parsed value, or a raw
+     *  response body string. The format is sniffed from this ROOT value only
+     *  (`detectResultFormat`); string leaves inside a JSON tree stay text. */
+    value: unknown;
+    /** Keep an already-parsed payload as JSON, including strings; default sniffs the format. */
+    format?: "auto" | "json";
+    /** Height cap of the scrolling body, in px. Default 320. */
+    maxHeight?: number;
+    /** Extra class on the root, for spacing in the consuming pane. */
+    className?: string;
+}
+/**
+ * Read-only display of one result value, chosen by its format:
+ *
+ * | format     | body                                                       |
+ * | ---------- | ---------------------------------------------------------- |
+ * | `json`     | a collapsible `JsonTree`, with Expand all / Collapse all    |
+ * | `xml`      | source (`CodeBlock`, `markup`, when small enough)           |
+ * | `html`     | `HtmlPreview` — an empty-sandbox iframe — or source         |
+ * | `markdown` | `Markdown` — or source                                      |
+ * | `text`     | a plain `<pre>`                                             |
+ *
+ * Read-only means read-only: nothing here takes an `onChange`, and the one
+ * interactive affordance besides the collapsers and the Rendered/Source
+ * toggle is `Copyable`'s button, overlaying the top-right corner and revealed
+ * on hover (`w6w-copyable--hover`).
+ *
+ * **Vendor HTML never touches this document.** The `html` format renders only
+ * through `HtmlPreview` — an `<iframe sandbox="">` whose `srcdoc` opens with a
+ * restrictive CSP meta as its first element — so a hostile payload cannot run
+ * script and cannot reach this page's origin or its data. Nothing in this
+ * component is ever passed to `dangerouslySetInnerHTML`. Accepted residual: a
+ * reader's CLICK on a link inside the preview navigates the frame itself (a
+ * page load in a sandboxed, scriptless, cookie-less document) — nothing more.
+ * Above `RESULT_RENDER_MAX_CHARS` even that path is skipped: an oversized
+ * document is shown as source, with a note saying so. Source views are handed
+ * to `renderSource`, which drops Prism above `RESULT_HIGHLIGHT_MAX_CHARS`.
+ *
+ * The copy button always writes `resultCopyText(detected)` — pretty-printed
+ * JSON for a tree, the raw string for every other format — so what lands on
+ * the clipboard is what the reader means by "the result", not the on-screen
+ * rendering. If that computation throws (circular value, `BigInt`), the view
+ * still renders and the button writes a best-effort string instead.
+ */
+export declare function ResultViewer(props: ResultViewerProps): import("react").JSX.Element;

package/dist/components/ScriptBindingsNotice.d.ts

@@ -0,0 +1,31 @@
+export interface ScriptConversion {
+    /** What the open-time conversion did, until Undo. */
+    converted: number;
+    undo: () => void;
+}
+/**
+ * A Run script's `{{ }}` markers, converted when the step opens. The host never substitutes
+ * inside code (see `script-bindings.ts`), so a marker there is literal text at run time. When
+ * the step opens, each convertible marker is rewritten to the code read it names
+ * (`$.get(root, ...keys)` in JavaScript/TypeScript); {@link ScriptBindingsNotice} says so,
+ * with Undo. Runs once per mount of the step editor, so after Undo the code stays as it was
+ * until the step is opened again. Read-only (or not a script), nothing is rewritten.
+ */
+export declare function useScriptConversion({ enabled, values, onChange, }: {
+    /** A writable `@w6w/script` step. */
+    enabled: boolean;
+    /** The step's `with`: `code`, `language`, `input`. */
+    values: Record<string, unknown>;
+    onChange: (next: Record<string, unknown>) => void;
+}): ScriptConversion | null;
+/**
+ * The quiet line under a Run script's Configure tab: "Converted 2 references to code reads ·
+ * Undo" after the open-time conversion, and, for any marker still in the code, that it stays
+ * literal text. Renders nothing otherwise.
+ */
+export declare function ScriptBindingsNotice({ values, conversion, readOnly, }: {
+    /** The step's `with`: `code`, `language`. */
+    values: Record<string, unknown>;
+    conversion: ScriptConversion | null;
+    readOnly?: boolean;
+}): import("react").JSX.Element | null;

package/dist/components/ScriptCodeField.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { ScriptLanguage } from '../script-bindings.ts';
+import { ActionParam } from '../types.ts';
+/** Script picker and node chips insert literal-key reads for every script language. */
+export declare function ScriptCodeField({ param, value, language, label, req, readOnly, onChange, }: {
+    param: ActionParam;
+    value: string;
+    language: ScriptLanguage;
+    label: string;
+    req: ReactNode;
+    readOnly?: boolean;
+    onChange: (next: string) => void;
+}): import("react").JSX.Element;

package/dist/components/StepStatusPill.d.ts

@@ -8,6 +8,13 @@ import { ReactNode } from 'react';
  * the same precedent `HealthStatusPill`'s `HealthPillState` establishes.
  */
 export type StepStatus = "pending" | "running" | "succeeded" | "failed" | "skipped";
+/**
+ * Why a `skipped` step did not run — the engine's `NodeExecution.skipReason`, again a thin
+ * LOCAL literal. `not_on_path`: the step is not downstream of the fired trigger (or outside a
+ * run-from-node scope), so it was never part of the run; the other three are real skips. A
+ * record from before the engine stamped reasons has none.
+ */
+export type SkipReason = "not_on_path" | "condition" | "stopped" | "disabled";
 /**
  * The five states a whole EXECUTION (an invocation, an endpoint call, a
  * workflow run) can be in — the run-level sibling of `StepStatus`, and again a

package/dist/components/expression-authoring.d.ts

@@ -0,0 +1,13 @@
+import { ExprPart } from '../types.ts';
+import { ExpressionOptions } from './ExpressionOptions.tsx';
+/** Compile an entire condition, including picker chips followed by typed operators. Plain
+ * text/templates stay unchanged. The persisted value uses the existing JSONLogic wire format. */
+export declare function compileAuthoredParts(original: ExprPart[], options: ExpressionOptions): {
+    parts: ExprPart[];
+    error: string | null;
+};
+/** Sample fields include those inside comparisons, not just standalone reference chips. */
+export declare function authoredReferences(parts: ExprPart[]): string[];
+/** Evaluate supported conditions with the same evaluator as workflow execution. Other legacy
+ * expression forms keep their existing template preview. Explicit samples preserve JSON types. */
+export declare function previewAuthoredParts(parts: ExprPart[], seeds?: Record<string, unknown>, overrides?: Record<string, string>): string;

package/dist/components/expression-dom.d.ts

@@ -3,14 +3,14 @@ import { ExprPart } from '../types.ts';
  * The name a source or chip DISPLAYS. Never the ref it SAVES.
  *
  * A saved ref is always canonical and engine-resolvable — the run scope offers
- * exactly `vars.* · steps.<id>.output.* · steps.<id>.meta.* · trigger.* · secrets.* · documents.* ·
+ * exactly `var.* · steps.<id>.output.* · steps.<id>.meta.* · trigger.* · secrets.* · documents.* · const.* ·
  * inputs.* · foreach.* · output.*` (`core/rfcs/workflow.md` §Expressions, built
  * in `w6w-workflow/packages/engine/src/run.ts`). Those read long in a field, so
  * the label drops the root the chip's sigil and colour already imply:
  *
  * | ref                         | label          |
  * |-----------------------------|----------------|
- * | `vars.from_email`           | `from_email`   |
+ * | `var.from_email`            | `from_email`   |
  * | `steps.gate_1.output`       | `gate_1`       |
  * | `steps.gate_1.output.email` | `gate_1.email` |
  * | `steps.gate_1.meta.version` | `gate_1 meta · version` |
@@ -41,6 +41,21 @@ export declare function isRefSafeKey(key: string): boolean;
  * {@link isRefSafeKey} on its own.
  */
 export declare function isRefSafePath(path: string): boolean;
+/**
+ * Lay a step's flat output fields out as a tree for the picker: each row shows only its OWN
+ * name, nested under the nearest listed ancestor. `event`, `event.tz`, `event.start.utc` read as
+ * `event` › `tz`, `start.utc` — the step id and the shared prefix are what truncated every row to
+ * the same `eventbrite_to_cohost_1.event.…`. A literal key (no `path`) is one name at depth 0.
+ * Display only: the ref is still built from the verbatim `key`.
+ */
+export declare function outputFieldTree<F extends {
+    key: string;
+    path?: boolean;
+}>(fields: F[]): {
+    field: F;
+    depth: number;
+    name: string;
+}[];
 /**
  * Build the non-editable inline chip (tag) DOM node for a part.
  *

package/dist/components/expression-template.d.ts

@@ -19,13 +19,23 @@ import { ExprPart, ExprValue, SecretValue } from '../types.ts';
  */
 export { parseTemplate, serializeTemplate };
 /**
- * Serialize parts to the leanest faithful VALUE: prune empty text, collapse a
- * lone text segment to a plain string (backward-compat), else an `ExprValue`.
- * Shared by the inline field and the expression editor modal.
+ * Serialize parts to the value that is saved: the `{{ }}` template STRING — exactly what the
+ * author sees (core Workflow RFC amendment, 2026-10-29). Text parts are source text, kept
+ * verbatim (an escaped `\{{ var.x }}` stays escaped). The one exception is a `render` part,
+ * which has no `{{ }}` spelling by design (RFC, *The `render` part kind*): a value holding one
+ * is saved as an `ExprValue` envelope. Shared by the inline field and the expression editor
+ * modal.
  */
 export declare function partsToValue(parts: ExprPart[]): ExprValue | string;
 /** Every root name, for tests that pin the derived set without reaching into the type. */
 export declare const RUN_SCOPE_ROOT_NAMES: readonly string[];
+/**
+ * THE alias rule for the state tree: `state`, `var` and `vars` are one object. For a ref whose
+ * root is one of them (followed by `.` or end of string) this gives the lookup spellings in order:
+ * the ref exactly as written, then `state.<rest>`, `var.<rest>`, `vars.<rest>` (deduplicated).
+ * Any other root gives only the ref itself (`steps`/`nodes` are NOT aliased here).
+ */
+export declare function stateAliasSpellings(ref: string): string[];
 /**
  * Root-anchored parse (CONDUCTOR AMENDMENT 2026-08-14): builds every marker in
  * `s` via `parseTemplate` (never a second `{{ }}` scanner), then requires:
@@ -49,6 +59,18 @@ export declare const RUN_SCOPE_ROOT_NAMES: readonly string[];
  * vendor placeholders with no root of their own).
  */
 export declare function parseRootAnchoredTemplate(s: string): ExprPart[];
+/**
+ * True when `v` holds a reference the run resolves — an `ExprValue` envelope, or a string with
+ * at least one live marker of ours. Since the editor saves template STRINGS, this (not
+ * `isExprValue`) is the test for "this field is an expression".
+ */
+export declare function holdsExpression(v: unknown): boolean;
+/**
+ * Parse a string the way the engine resolves a `with` string (`parseResolvableTemplate`):
+ * parts with escapes consumed, or `null` when the engine would pass it through untouched (no
+ * marker of ours, or one marker that is not ours). For previews.
+ */
+export declare function parseResolvableText(s: string): ExprPart[] | null;
 /**
  * Parse an incoming value into editable parts (+ any sealed secret to display).
  * The inverse of {@link partsToValue} for the editable forms; a sealed

package/dist/components/icons.d.ts

@@ -4,7 +4,7 @@ import { ReactNode } from 'react';
  * never for the studio component that happened to draw it, so a caller asks for
  * `icon="history"` rather than `icon="history-icon-tsx"`.
  */
-export type IconName = "edit" | "edit-2" | "delete" | "copy" | "check" | "close" | "history" | "info" | "clock" | "json" | "code" | "sync" | "cloud-download" | "eye" | "play" | "stop" | "warning" | "file-text" | "settings" | "github" | "user" | "bot" | "users" | "logout" | "id-card" | "dashboard" | "pulse" | "workflow" | "globe" | "lambda" | "sliders" | "file" | "plug" | "grid" | "folder" | "git-branch" | "coin" | "building" | "server" | "price-tag" | "lang-node" | "terminal" | "lang-python" | "lang-curl" | "sun" | "moon" | "circle-half" | "layout" | "run" | "trash" | "maximize" | "form" | "braces" | "settings-2" | "sticky-note" | "frame" | "bold" | "grip" | "chevron-down";
+export type IconName = "edit" | "edit-2" | "delete" | "copy" | "check" | "close" | "history" | "info" | "clock" | "json" | "code" | "sync" | "cloud-download" | "eye" | "play" | "stop" | "warning" | "file-text" | "settings" | "github" | "user" | "bot" | "users" | "logout" | "id-card" | "dashboard" | "pulse" | "workflow" | "globe" | "lambda" | "sliders" | "file" | "plug" | "grid" | "folder" | "git-branch" | "coin" | "building" | "server" | "price-tag" | "lang-node" | "terminal" | "lang-python" | "lang-curl" | "sun" | "moon" | "circle-half" | "layout" | "run" | "pause" | "ban" | "trash" | "maximize" | "form" | "braces" | "settings-2" | "sticky-note" | "frame" | "bold" | "grip" | "chevron-down" | "database";
 /**
  * Which attributes the shared `<svg>` root carries — i.e. how the glyph is
  * painted. The sources are not uniform, and forcing them into one shape would

package/dist/components/json-compose.d.ts

@@ -0,0 +1,53 @@
+import { StepStartState } from '../provider.tsx';
+/** True when `pos` sits inside a JSON string literal of `text` (after its opening quote). */
+export declare function insideJsonString(text: string, pos: number): boolean;
+/** The text to insert for `ref` at `pos` of `text`: a marker in a string, else a quoted one. */
+export declare function refInsertion(text: string, pos: number, ref: string): string;
+/**
+ * The property name a reference gets when it is added to an object: its last meaningful
+ * segment — `var.region` → `region`, `nodes.get_event.output.id` → `id`,
+ * `nodes.get_event.output` → `get_event`, `nodes.get_event.meta` → `get_event_meta`.
+ */
+export declare function keyForRef(ref: string): string;
+/**
+ * Add a reference to a draft the author is working on — never replacing it. `pos` is the caret.
+ *
+ * - Inside a JSON string: `{{ ref }}`, interpolated.
+ * - Where a value goes (after `:`, after `[`, or after `,` in an array): `"{{ ref }}"`.
+ * - Where a property goes (after `{`, or after `,` in an object): `"key": "{{ ref }}"`.
+ * - Anywhere else (the caret is not somewhere a value fits — e.g. it was never placed): a draft
+ *   that is an object gets a new property at its end, an array a new element at its end.
+ *   Otherwise the quoted marker goes at the caret.
+ *
+ * With `literal`, the same placement inserts that VALUE instead of the reference (a literal-JSON
+ * field such as a workflow's starting state, where no `{{ }}` marker is ever evaluated): as JSON
+ * where a value goes, as its text inside a string. The key is still named after `ref`.
+ *
+ * Returns the new text and the caret after the inserted reference.
+ */
+export declare function addRefToDraft(text: string, pos: number, ref: string, literal?: {
+    value: unknown;
+}): {
+    text: string;
+    caret: number;
+};
+export declare function bareRefBinding(text: string): string | null;
+/**
+ * The ref a whole-value binding names — `"{{ ref }}"` (exactly one `var` marker, nothing
+ * else), or a legacy `{ "$": "ref" }` — else `null`.
+ */
+export declare function wholeValueRef(value: unknown): string | null;
+/**
+ * The `steps` start state a preview resolves against, rebuilt from the host's flat sample
+ * values: `steps.<id>.output` / `nodes.<id>.output` keys give a step's output, and
+ * `steps.<id>.meta.<field>` keys its metadata.
+ */
+export declare function sampleStepsState(sampleValues: Record<string, unknown> | undefined): StepStartState;
+/**
+ * Resolve a composed value the way the engine resolves a `with` value: a `{ "$": ref }` object
+ * and a string holding rooted `{{ ref }}` markers are resolved by `resolveLeaf` wherever they
+ * sit; other arrays and objects are walked. A string whose markers are not all rooted stays
+ * literal, as in the engine. `resolveLeaf` is the ui's top-level resolver
+ * (`resolveParamJson` against a scope), which reads only the value it is handed.
+ */
+export declare function resolveComposed(value: unknown, resolveLeaf: (leaf: unknown) => unknown): unknown;

package/dist/components/result-format.d.ts

@@ -0,0 +1,13 @@
+/** What a result pane is showing, decided once from the ROOT value (never per leaf). */
+export type DetectedResult = {
+    format: "json";
+    data: unknown;
+} | {
+    format: "xml" | "html" | "markdown" | "text";
+    text: string;
+};
+/** Above this many characters html/markdown are shown as source only, never rendered. */
+export declare const RESULT_RENDER_MAX_CHARS = 262144;
+export declare function detectResultFormat(value: unknown): DetectedResult;
+/** The exact text the copy button writes: pretty JSON for a tree, else the raw string. */
+export declare function resultCopyText(d: DetectedResult): string;

package/dist/condition-editor.d.ts

@@ -0,0 +1,44 @@
+import { ExprValue, SecretValue } from './types.ts';
+/** The comparisons the condition builder offers, in menu order, with their labels. */
+export declare const CONDITION_OPERATORS: readonly [readonly ["is-true", "is true"], readonly ["is-false", "is false"], readonly ["===", "equals"], readonly ["!==", "does not equal"], readonly [">", "greater than"], readonly [">=", "at least"], readonly ["<", "less than"], readonly ["<=", "at most"], readonly ["in", "in"], readonly ["includes", "includes value"], readonly ["include-any", "includes any of (list)"], readonly ["include-all", "includes all of (list)"]];
+/** Operand order for membership comparisons; shown on the selected operator and its options. */
+export declare const CONDITION_OPERATOR_HINTS: Record<string, string>;
+/** A comparison operator as the builder names it (`===` → "equals"); unknown ones as written. */
+export declare function conditionOperatorLabel(op: string): string;
+/** One comparison row of the builder: `left <operator> right`. */
+export interface ConditionComparison {
+    left: unknown;
+    operator: string;
+    right: unknown;
+    /** Invert this comparison before combining it with the other rows. */
+    negated?: boolean;
+}
+/** How the builder joins its rows: all of (`and`), any of (`or`), exactly one of (`xor`). */
+export type ConditionCombinator = "and" | "or" | "xor";
+/** The combinators the builder offers, in menu order, with their labels. `xor` is the
+ * `@w6w/expr` extension (JSONLogic has none): true when exactly one row is. */
+export declare const CONDITION_COMBINATORS: readonly [readonly ["and", "All of (AND)"], readonly ["or", "Any of (OR)"], readonly ["xor", "Exactly one of (XOR)"]];
+/** A combinator as the builder names it (`or` → "Any of (OR)"); unknown ones as written. */
+export declare function conditionCombinatorLabel(combinator: string): string;
+/** The builder's whole condition: flat rows joined by one combinator (no nested groups). */
+export interface ConditionGroup {
+    combinator: ConditionCombinator;
+    rows: ConditionComparison[];
+}
+/** Decode only two-operand comparisons; all other conditions keep the full editor. */
+export declare function readComparison(value: unknown): ConditionComparison | undefined;
+/**
+ * Decode a condition the builder can show: one comparison, or an `and` / `or` / `xor` of
+ * comparisons. Anything else (a nested group, another operator) is `undefined`, and the
+ * editor keeps the code view for it.
+ */
+export declare function readConditionGroup(value: unknown): ConditionGroup | undefined;
+/**
+ * The stored condition for a builder group. A row with no field is still being written and
+ * is left out; no complete row is `false`, one is that comparison alone (the shape a
+ * one-row condition always had), more are joined by the combinator.
+ */
+export declare function writeConditionGroup(group: ConditionGroup): unknown;
+/** Typed scalar or JSON array input. Quotes preserve text that looks like a typed value. */
+export declare function conditionOperandValue(value: string | ExprValue | SecretValue): unknown;
+export declare function conditionOperandText(value: unknown): string;