@w6w/ui 0.2.0 → 0.2.54

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;

package/dist/data-stores/data-store-view.d.ts

@@ -0,0 +1,371 @@
+/**
+ * The pure, data-free vocabulary of a Data store (F-2, lifted from Studio's
+ * `lib/data-stores-view`, `data-cells`, `data-grid` and `data-store-errors`).
+ *
+ * One import point for every consumer (Studio, `@w6w/embed`, the components in
+ * this package): the wire types, the closed kind/scalar vocabularies, the
+ * cell text codec, the row-draft/write helpers and the error locator. Paths,
+ * query builders and cache keys deliberately stay in Studio.
+ *
+ * Pure and dependency-free on purpose: no React, no SDK, no `fetch`, only
+ * relative imports, so `node --test` loads it with nothing but type-stripping.
+ */
+/** Display label per store kind (shared by every list and picker). */
+export declare const DATA_STORE_KIND_LABEL: {
+    readonly kv: "Key-value";
+    readonly doc: "Document";
+    readonly table: "Table";
+};
+/**
+ * The three store shapes. `kv` holds one value per key, `doc` holds a JSON
+ * document per key, `table` holds rows whose columns are declared in the
+ * store's schema.
+ */
+export type DataStoreKind = "kv" | "doc" | "table";
+/**
+ * The server's scalar vocabulary (S-1). A value of this type is validated
+ * server-side and stored as the string the caller sent — never coerced.
+ */
+export type ScalarType = "string" | "number" | "integer" | "boolean" | "date" | "datetime";
+/** One declared table column (S-2). `default` is the column's JSON default, verbatim. */
+export interface TableColumn {
+    name: string;
+    type: ScalarType;
+    required: boolean;
+    default?: unknown;
+}
+/** A `kv` store's schema (S-2): one scalar type for every value. */
+export interface KvSchema {
+    valueType: ScalarType;
+}
+/** A `table` store's schema (S-2); `key` names the column whose cell is the row's key. */
+export interface TableSchema {
+    columns: TableColumn[];
+    key?: string;
+}
+/** A store as the wire carries it (S-3). Timestamps are ISO-8601 strings. */
+export interface DataStore {
+    id: string;
+    kind: DataStoreKind;
+    name: string;
+    description: string;
+    project: string;
+    schema: Record<string, unknown>;
+    entryCount: number;
+    sizeBytes: number;
+    createdBy: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/** One entry as the wire carries it (S-3). `expiresAt` is `null` when the entry never expires. */
+export interface Entry {
+    key: string;
+    value: unknown;
+    version: number;
+    sizeBytes: number;
+    expiresAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** `GET /data-stores` — one page of stores plus the cursor for the next one. */
+export interface DataStorePage {
+    items: DataStore[];
+    nextCursor?: string;
+}
+/** `GET /data-stores/:id/entries` — one page of entries (a table query never carries a cursor). */
+export interface EntryPage {
+    items: Entry[];
+    nextCursor?: string;
+}
+/** `POST /data-stores/:id/import` — how many CSV rows the host upserted/appended. */
+export interface ImportResult {
+    imported: number;
+}
+/** `POST /data-stores` body. `schema` is the S-2 shape for the chosen `kind`. */
+export interface DataStoreCreateInput {
+    kind: DataStoreKind;
+    name: string;
+    description?: string;
+    schema?: Record<string, unknown>;
+}
+/** `PATCH /data-stores/:id` body — every field optional, none of them the kind. */
+export interface DataStorePatch {
+    name?: string;
+    description?: string;
+    schema?: Record<string, unknown>;
+}
+/** The closed set of store kinds, in the order the create dialog offers them. */
+export declare const DATA_STORE_KINDS: readonly ["kv", "doc", "table"];
+/** The closed set of scalar cell types, in the order the columns editor offers them. */
+export declare const SCALAR_TYPES: readonly ["string", "number", "integer", "boolean", "date", "datetime"];
+/** R-7: a CSV upload is at most 5 MB (5 242 880 bytes). The client checks before sending. */
+export declare const CSV_MAX_BYTES = 5242880;
+/**
+ * A `kv` store's declared value type, defaulting to `"string"` — S-2's own
+ * default, and the only safe reading of a schema the client did not write
+ * (a store created before the field existed, or one whose schema is garbage).
+ */
+export declare function kvValueTypeOf(store: DataStore): ScalarType;
+/**
+ * A `table` store's schema, or `null` when the store is not a table or its
+ * schema has no column array. `null` — not an empty column list — so the grid
+ * can tell "not a table" from "a table with nothing declared".
+ */
+export declare function tableSchemaOf(store: DataStore): TableSchema | null;
+/**
+ * The filename to save an export under: the host's own `filename="…"` from the
+ * `Content-Disposition` header when it sent one, otherwise `<store name>.csv`.
+ * A header without that parameter (`attachment` alone, or `null` when a
+ * proxy stripped it) falls back rather than producing a nameless file.
+ */
+export declare function csvFilenameOf(contentDisposition: string | null, storeName: string): string;
+/** Why a cell's text could not become a value. */
+export type CellProblem = "required" | "not_a_number" | "not_an_integer" | "not_a_boolean" | "not_a_date" | "not_a_datetime";
+/** The one sentence rendered beside the offending cell, per problem. */
+export declare const CELL_PROBLEM_COPY: Record<CellProblem, string>;
+/**
+ * Turn the text an operator typed into the value the wire takes, for a column
+ * of `type`.
+ *
+ * `required` is applied to the EMPTY cell only (R-7): every other rule is the
+ * server's own, so a cell this returns `ok` for is a cell the server accepts.
+ * `string` is the one type that keeps the text as typed — trimming it would
+ * silently edit the operator's value.
+ */
+export declare function parseCell(type: ScalarType, text: string, required: boolean): {
+    ok: true;
+    value: string | number | boolean | undefined;
+} | {
+    ok: false;
+    problem: CellProblem;
+    message: string;
+};
+/**
+ * The text to put in a cell for an already-typed value.
+ *
+ * `undefined`/`null` render as the empty cell (never `"undefined"` or `"null"`);
+ * a string value for a string-ish column is shown as itself; a finite number
+ * and a boolean render as their JSON literals; anything else (an object cell,
+ * a `null` inside a document) falls back to its JSON text so the cell shows
+ * what the server holds rather than `[object Object]`.
+ */
+export declare function serializeCell(type: ScalarType, value: unknown): string;
+/**
+ * Is an already-typed JSON value of `type`? The same rules {@linkcode parseCell}
+ * applies to text, applied to a value that came back from the server — the grid
+ * uses it to mark a row the server would refuse before the operator presses
+ * Save. `required` plays no part here: an absent value is the caller's problem
+ * to decide about, not this predicate's.
+ */
+export declare function isCellValue(type: ScalarType, value: unknown): boolean;
+/** What is shown when the server said nothing a human can read. */
+export declare const DATA_STORE_ERROR_FALLBACK = "The request failed.";
+/** `rawRequest`'s `status: 0` — the request never reached the server. */
+export declare const DATA_STORE_NETWORK_ERROR = "Could not reach the server.";
+/** A failure, flattened into the fields the page needs and nothing else. */
+export interface DataStoreErrorLocator {
+    /** Always present: the server's own sentence, or one of the two copy constants above. */
+    message: string;
+    /** The host's machine-readable code (`invalid_value`, `invalid_cursor`, …). */
+    code?: string;
+    /** The HTTP status; `0` is the transport-failure convention. */
+    status?: number;
+    /** The request-body field the host blamed. */
+    field?: string;
+    /** The 0-based CSV data row the host blamed (header excluded). */
+    row?: number;
+    /** The table column the host blamed. */
+    column?: string;
+}
+/**
+ * Locate a thrown JSON-call failure: an `ApiError` (whose parsed body lives on
+ * `.raw`), a plain `Error`, or anything else at all.
+ *
+ * The message falls back in that order — the envelope's `message`, the error's
+ * own `message`, then {@linkcode DATA_STORE_ERROR_FALLBACK} — so an unfamiliar
+ * throw still produces a sentence rather than an empty panel.
+ */
+export declare function locateDataStoreError(e: unknown): DataStoreErrorLocator;
+/**
+ * Locate a CSV-call failure from P-RAW's `{status, text}` — the body is still
+ * unparsed text because that transport does not know the content type.
+ *
+ * `status: 0` means the request never produced a response, and gets the
+ * transport sentence rather than an attempt to parse an empty body. Otherwise
+ * the body is parsed iff it is JSON: an HTML error page from a proxy is
+ * `{status, message: fallback}`, not a crash.
+ */
+export declare function locateRawResponseError(res: {
+    status: number;
+    text: string;
+}): DataStoreErrorLocator;
+/** Where the message is rendered: under one table cell, under one form field, or over the whole form. */
+export declare function errorPlacement(loc: DataStoreErrorLocator): {
+    kind: "cell";
+    column: string;
+    row?: number;
+} | {
+    kind: "field";
+    field: string;
+} | {
+    kind: "form";
+};
+/**
+ * The operator's 1-based line number in the CSV they uploaded, from the host's
+ * 0-based data-row index: the header row is line 1, so data row 0 is line 2.
+ */
+export declare function csvLineOf(row: number): number;
+/**
+ * The draft id of a row that does not exist yet: a NUL-prefixed sentinel, which
+ * R-5 forbids a real key from ever being (no control characters in a key), so
+ * `id === NEW_ROW_ID` and "this row has no server-side key" are the same fact.
+ */
+export declare const NEW_ROW_ID = "\0new";
+/** Rendered beside a row whose `ifVersion` was stale — never as the server's sentence alone. */
+export declare const VERSION_CONFLICT_COPY = "Changed by someone else since you loaded it.";
+/** A `doc` store holds a JSON object or array; anything else is not a document. */
+export declare const DOC_VALUE_COPY = "Enter a JSON object or array.";
+/** R-7's client-side ceiling copy — the check runs before anything is sent. */
+export declare const CSV_TOO_LARGE_COPY = "The file is larger than 5 MB.";
+/**
+ * One row's editable state: the id it is saved under (`entry.key`, or
+ * {@linkcode NEW_ROW_ID}), the version the save guards with (`null` for a new
+ * row) and the cell TEXT per declared column (never a parsed value — the text
+ * is what the operator is editing, and re-serialising it on every keystroke
+ * would fight their cursor).
+ */
+export interface RowDraft {
+    id: string;
+    version: number | null;
+    cells: Record<string, string>;
+}
+/**
+ * An entry's value read as a table row: the object the server stored, or `{}`
+ * for anything that is not a plain object (a `null`, an array, a scalar from a
+ * column set that has since changed).
+ */
+export declare function rowValueOf(entry: Entry): Record<string, unknown>;
+/** The draft an entry starts as: its key, its version, and each declared column's text. */
+export declare function draftFromEntry(entry: Entry, columns: readonly TableColumn[]): RowDraft;
+/**
+ * The draft a brand-new row starts as: {@linkcode NEW_ROW_ID}, no version, and
+ * each column seeded from its declared `default` (absent default = empty cell).
+ */
+export declare function newRowDraft(columns: readonly TableColumn[]): RowDraft;
+/**
+ * Which declared columns the operator actually changed, in DECLARED order.
+ *
+ * Declared order (not object order) so the answer is stable across browsers and
+ * the row's Save button can decide "dirty" with one empty-array check. An
+ * untouched draft is `[]`.
+ */
+export declare function dirtyColumns(draft: RowDraft, base: RowDraft, columns: readonly TableColumn[]): string[];
+/**
+ * The row body a Save sends, or the per-cell refusals that stop it.
+ *
+ * Every DECLARED column is parsed through {@linkcode parseCell} with its own
+ * `required` flag: an absent value omits the key entirely (R-7's empty-cell
+ * rule, so the host's default applies), a `string` cell keeps its text verbatim
+ * and every other type is the JSON value the server expects — never the typed
+ * text. Failures are keyed by column name so the caller renders them under the
+ * offending cell.
+ */
+export declare function buildRowValue(draft: RowDraft, columns: readonly TableColumn[]): {
+    ok: true;
+    value: Record<string, unknown>;
+} | {
+    ok: false;
+    errors: Record<string, string>;
+};
+/**
+ * The `ttlSeconds` a save must resend so it does not CLEAR an existing expiry
+ * (S-1: a PUT without `ttlSeconds` sets `expires_at = NULL`).
+ *
+ * `undefined` for an entry that never expires, for an unparseable timestamp and
+ * for one already in the past — in all three cases sending nothing is correct
+ * (and a non-positive TTL is not a TTL the host accepts). Rounded UP, so a save
+ * one millisecond before the deadline does not shorten the entry's life.
+ */
+export declare function remainingTtlSeconds(expiresAt: string | null, nowMs: number): number | undefined;
+/**
+ * Which request a draft implies: an INSERT (`POST entries`, no `ifVersion`) for
+ * a row that does not exist yet, otherwise a PUT under the row's key guarded by
+ * the version the operator loaded.
+ *
+ * `ttlSeconds` is present ONLY when the caller has one: it reaches the wire as
+ * a defining key, and an explicit `undefined` would be indistinguishable from
+ * "the caller measured nothing".
+ */
+export declare function rowWriteOf(draft: RowDraft, value: Record<string, unknown>, ttlSeconds: number | undefined): {
+    kind: "insert";
+    value: Record<string, unknown>;
+    ttlSeconds?: number;
+} | {
+    kind: "put";
+    key: string;
+    value: Record<string, unknown>;
+    ifVersion: number;
+    ttlSeconds?: number;
+};
+/**
+ * The cell errors a refusal places, or `null` when it belongs somewhere else
+ * (the form, a request-body field, a column this table does not declare).
+ *
+ * `null` is load-bearing: the grid renders `grid-error` exactly when this
+ * returns `null`, so "the message shows in one slot" is a property of the
+ * answer rather than of the caller's care.
+ */
+export declare function cellErrorsOf(loc: DataStoreErrorLocator, columns: readonly TableColumn[]): Record<string, string> | null;
+/**
+ * Is this failure the optimistic-concurrency refusal — and nothing else?
+ *
+ * `409` alone is not enough: `entry_exists` and `store_exists` share the status
+ * and neither is fixed by reloading, so both halves of the locator must agree.
+ */
+export declare function isVersionConflict(loc: DataStoreErrorLocator): boolean;
+/**
+ * A `doc` store's value from the editor's text: any JSON object or array.
+ *
+ * A scalar is refused rather than wrapped — the store's own `doc` shape is an
+ * object/array (S-2), and the host would refuse `42` anyway; failing here means
+ * the operator sees why without a round trip. `null` parses but is not a
+ * document, so it is refused with the same sentence.
+ */
+export declare function parseDocText(text: string): {
+    ok: true;
+    value: object;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * A `kv` store's value from the editor's text.
+ *
+ * `string` is the one type whose text IS the value, empty string included (an
+ * empty `string` entry is a real value, not an absent one), so it never passes
+ * through {@linkcode parseCell} — which reads an empty cell as absent. Every
+ * other type is parsed exactly as a table cell would be, `required` on, because
+ * a kv entry always has a value.
+ */
+export declare function kvValueOf(type: ScalarType, text: string): {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * What a CSV import's `RawResponse` says to the operator.
+ *
+ * The host is the only parser (R-7): a `200` reports how many rows it took, and
+ * a refusal is located rather than interpreted — a `row` becomes the operator's
+ * own 1-based line (`csvLineOf`), the `column` is named when the host named one,
+ * and everything else is the host's sentence verbatim.
+ */
+export declare function csvImportMessage(res: {
+    status: number;
+    text: string;
+}): {
+    ok: boolean;
+    message: string;
+};

package/dist/dynamic-fields.d.ts

@@ -0,0 +1,60 @@
+import { ActionParam, ParamOption, ResolveFieldsBody } from './types.ts';
+/** Dynamic-field context a ParamsForm host passes. */
+export interface DynamicContext {
+    appId: string;
+    actionKey: string;
+    version?: string;
+    connectionId?: string;
+    appName?: string;
+}
+/** Form values split per D-5: resolvable go to `form`, expression/secret/`$`-object keys to `unresolved`. */
+export interface FormSplit {
+    form: Record<string, unknown>;
+    unresolved: string[];
+}
+/** One planned call: the body minus `connectionId`/`version` (the hook adds them). */
+export type PlannedRequest = Pick<ResolveFieldsBody, "reason" | "form" | "previous" | "changed" | "fields" | "unresolved">;
+/** Outcome of reconciling a stored value against a returned option list. */
+export interface Reconciled {
+    action: "keep" | "flag" | "clear";
+    /** Hint to show when `action === "flag"`. */
+    message?: string;
+}
+/** D-5: expression, secret, or a plain object with own key `$` can't be sent as a literal. */
+export declare function isUnresolvedValue(v: unknown): boolean;
+declare function allowCustomOf(p: ActionParam): boolean;
+/** Params that request form-resolved options (top level + sections only). */
+export declare function dynamicParams(params: ActionParam[]): ActionParam[];
+/**
+ * Split flattened `values` (entered, else declared default) into `form` and
+ * `unresolved` (expression, secret, or plain object with own key `$`).
+ */
+export declare function splitForm(params: ActionParam[], values: Record<string, unknown>): FormSplit;
+/**
+ * Plan the call for `reason`. `init`: every resolveFields field whose
+ * `refreshOn` keys are all resolved. `change`: only fields whose `refreshOn`
+ * contains `changed[0]` (and whose keys are all resolved). Returns null when no call is due.
+ * `previous` (raw pre-commit values) is split the same way and sent as `previous`.
+ */
+export declare function planRequests(params: ActionParam[], values: Record<string, unknown>, reason: "init" | "change", changed?: string[], previous?: Record<string, unknown>): PlannedRequest | null;
+/** Cache key `(app, version, action, connection, field, refreshOn values)`. */
+export declare function cacheKey(ctx: DynamicContext, param: ActionParam, form: Record<string, unknown>): string;
+/** Only `cache: "none"` opts out of the in-memory cache. */
+export declare function isCacheable(param: ActionParam): boolean;
+/** True when two requests' `fields` share a key (the newer aborts the older). */
+export declare function fieldsOverlap(a: readonly string[], b: readonly string[]): boolean;
+/**
+ * Why a dynamic field is NOT requested (A6), with the hint to show, or null
+ * when it is requestable.
+ */
+export declare function noFetchReason(param: ActionParam, params: ActionParam[], values: Record<string, unknown>, ctx: Pick<DynamicContext, "connectionId">): {
+    reason: "no-connection" | "unresolved-dependency";
+    hint: string;
+} | null;
+/** D-6: keep / flag / clear a stored value given the returned options. */
+export declare function reconcileValue(value: unknown, options: ParamOption[], opts: {
+    allowCustom: boolean;
+    reason: "init" | "change";
+    appLabel: string;
+}): Reconciled;
+export { allowCustomOf };

package/dist/editor-theme.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The ONE `EditorView.theme` spec shared by the three CodeMirror editors
+ * (`JsonEditor`, `CodeEditor`, `YamlEditor`) — previously copy-pasted verbatim
+ * into each of them.
+ *
+ * Plain object, **no imports**, so `node --test` asserts it directly. Every
+ * colour/spacing value is a `--w6w-*` custom property so the editors inherit
+ * the consumer's palette.
+ *
+ * Focus mirrors `styles/_fields.scss` (`.w6w-field input:focus { outline: none;
+ * border-color: var(--w6w-accent) }`) instead of drawing an accent ring. The
+ * rule must STAY with an explicit `outline: "none"` — deleting it falls back to
+ * CodeMirror's base theme (`outline: 1px dotted #212121` in
+ * `@codemirror/view`), which is still an outline.
+ *
+ * `".cm-scroller"`'s `borderRadius: "7px"` (8px − the 1px `"&"` border) clips
+ * the gutters and active line to the rounded border. `"&"` never gets
+ * `overflow: hidden`, which would clip lint/hover tooltips mounted inside the
+ * editor.
+ *
+ * `".cm-content"` only sets the vertical longhands: `styles/_fx.scss` owns
+ * `padding-right` while the ƒx/copy overlay is present.
+ */
+export declare const EDITOR_THEME_SPEC: Record<string, Record<string, string>>;

package/dist/eventbrite-trigger-selection.d.ts

@@ -0,0 +1,13 @@
+import { ActionDef } from './types.ts';
+export interface EventbriteTriggerChoices {
+    triggerKey: string;
+    options: {
+        value: string;
+        label: string;
+        triggerKey: string;
+    }[];
+    selected: string[];
+}
+/** Eventbrite's activity trigger registers several events on one webhook. Keep its
+ * event catalog in the app manifest; the editor only adapts the existing trigger keys. */
+export declare function eventbriteTriggerChoices(appId: string, triggers: ActionDef[] | null, triggerKey: string, values: Record<string, unknown>): EventbriteTriggerChoices | null;