@w6w/embed 0.2.11 → 0.2.19

package/dist/rail/ConnectionsTool.d.ts

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

package/dist/rail/HistoryTool.d.ts

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

package/dist/rail/StartingStateTool.d.ts

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

package/dist/rail/settings-sections.d.ts

@@ -52,6 +52,8 @@ export declare function SpecChooserModal(props: {
  * "Published: vN" line and Publish / Enable-Disable stay in the main panel.
  */
 export declare function VersionSection(props: {
+    definitionStatus?: "published" | "draft" | "unpublished";
+    publishDisabled?: boolean;
     open: boolean;
     versions: VersionsEnvelope | undefined;
     publishing: boolean;
@@ -73,13 +75,14 @@ export declare function VersionListModal(props: {
     onClose: () => void;
 }): import("react").JSX.Element;
 /**
- * The bottom "danger zone": Archive (until archived) then Delete, with the two confirm modals.
+ * The bottom "danger zone": Archive and Delete for workflows; Archive then Delete for other kinds.
  * Per-kind variance (copy, test ids) is the table above; the caller owns the mutations and the
  * confirm/error state, and renders this only when `hasDelete(kind)`.
  */
 export declare function SettingsDangerZone(props: {
     kind: SettingsKind;
     archived: boolean;
+    pending?: boolean;
     deleteConfirming: boolean;
     archiveConfirming: boolean;
     deleteError: string | null;

package/dist/rail.mjs

@@ -1,7 +1,7 @@
 "use client";
 import { jsx as r } from "react/jsx-runtime";
 import { useMemo as u } from "react";
-import { W as d, R as p, P as m, u as f, a as v, e as b, b as h } from "./editor-tools-B_Lfx3kw.js";
+import { W as d, R as p, P as m, u as f, a as v, e as b, b as h } from "./editor-tools-BR27RGto.js";
 import { r as P, a as j } from "./project-context-Tvp-La7A.js";
 const R = () => {
 };

package/dist/repos/constants.d.ts

@@ -0,0 +1,12 @@
+export interface Constant {
+    name: string;
+    type: "string" | "number" | "boolean" | "json";
+    value: unknown;
+    description: string;
+    /** Computed by the server (e.g. `account_id`), not stored. */
+    derived: boolean;
+}
+/** Query key for the constants list. */
+export declare function constantsKey(): readonly ["constants"];
+/** The account's constants (read-only). */
+export declare function useConstantsQuery(): import('@tanstack/react-query').UseQueryResult<NoInfer<Constant[]>, Error>;

package/dist/repos/data-stores.d.ts

@@ -0,0 +1,84 @@
+import { DataStore, DataStoreCreateInput, DataStoreEntry, DataStoreEntryPage, DataStoreKind, W6WClient } from '@w6w/sdk';
+/** The most requests one "walk every page" read makes (200 stores a page). */
+export declare const DATA_STORE_MAX_PAGES = 10;
+/** Query key for a project's store list. */
+export declare function dataStoresKey(projectId?: string): readonly ["data-stores", string | undefined, "list"];
+/** Query key for one store. */
+export declare function dataStoreKey(id: string, projectId?: string): readonly ["data-stores", string | undefined, "detail", string];
+/** Query key for one store's entries under a key prefix (`""` = no filter). */
+export declare function dataStoreEntriesKey(id: string, projectId: string | undefined, prefix: string): readonly ["data-stores", string | undefined, "entries", string, string];
+/**
+ * The project's stores, walked page by page (at most {@link DATA_STORE_MAX_PAGES} requests),
+ * server order kept. Hook-less so the ui picker's `listDataStores` seam can call it too.
+ */
+export declare function listAllDataStores(client: W6WClient, project: string): Promise<DataStore[]>;
+/** The picker's shape: store names and kinds only. */
+export declare function listDataStores(client: W6WClient, project: string): Promise<{
+    name: string;
+    kind: DataStoreKind;
+}[]>;
+/**
+ * ONE page of the entries of the project's store named `store`, for the ui's `data-store-key`
+ * picker (`W6WApi.listDataStoreEntries`): the name is resolved to its id (remembered), then
+ * `prefix` is the host's server-side key search and `limit` caps the page. An unknown name is an
+ * empty page; a failed entries read forgets the id (renamed or archived) and rethrows.
+ */
+export declare function listDataStoreEntries(client: W6WClient, project: string, store: string, opts?: {
+    prefix?: string;
+    limit?: number;
+    signal?: AbortSignal;
+}): Promise<{
+    items: {
+        key: string;
+        value: unknown;
+        updatedAt: string;
+    }[];
+    more: boolean;
+}>;
+export declare function useDataStoresQuery(projectId?: string): import('@tanstack/react-query').UseQueryResult<NoInfer<DataStore[]>, Error>;
+export declare function useDataStoreQuery(id: string, projectId?: string): import('@tanstack/react-query').UseQueryResult<NoInfer<DataStore>, Error>;
+export declare function useEntriesQuery(id: string, projectId: string | undefined, prefix: string): import('@tanstack/react-query').UseInfiniteQueryResult<import('@tanstack/react-query').InfiniteData<DataStoreEntryPage, unknown>, Error>;
+/** One entry by key, read fresh (the conflict prompt's Reload). */
+export declare function getEntry(client: W6WClient, id: string, key: string, project: string): Promise<DataStoreEntry>;
+export declare function useCreateDataStoreMutation(): import('@tanstack/react-query').UseMutationResult<DataStore, Error, {
+    input: DataStoreCreateInput;
+    project: string;
+}, unknown>;
+export declare function useArchiveDataStoreMutation(): import('@tanstack/react-query').UseMutationResult<void, Error, {
+    id: string;
+    project: string;
+}, unknown>;
+/** `PUT` one entry. `ifVersion` is the optimistic-concurrency guard; `ttlSeconds` keeps an expiry. */
+export declare function useSetEntryMutation(): import('@tanstack/react-query').UseMutationResult<DataStoreEntry, Error, {
+    id: string;
+    key: string;
+    value: unknown;
+    ifVersion?: number;
+    ttlSeconds?: number;
+    project: string;
+}, unknown>;
+/** `POST` one table row; the server generates the key. */
+export declare function useInsertRowMutation(): import('@tanstack/react-query').UseMutationResult<DataStoreEntry, Error, {
+    id: string;
+    row: Record<string, unknown>;
+    ttlSeconds?: number;
+    project: string;
+}, unknown>;
+export declare function useDeleteEntryMutation(): import('@tanstack/react-query').UseMutationResult<void, Error, {
+    id: string;
+    key: string;
+    project: string;
+}, unknown>;
+/** Import CSV text verbatim (`text/csv`). Resolves `{imported}`; a refusal throws an `ApiError`. */
+export declare function useImportCsvMutation(): import('@tanstack/react-query').UseMutationResult<{
+    imported: number;
+}, Error, {
+    id: string;
+    csv: string;
+    project: string;
+}, unknown>;
+/** Export a table store as CSV text. Read-only: nothing is invalidated. */
+export declare function useExportCsvMutation(): import('@tanstack/react-query').UseMutationResult<string, Error, {
+    id: string;
+    project: string;
+}, unknown>;

package/dist/repos/history.d.ts

@@ -22,3 +22,12 @@ export declare function useHasExecutedQuery(callableId: string): {
 /** One execution's full detail, opened from a list row. Disabled while
  *  `summary` is `null` (no row selected). */
 export declare function useExecutionDetailQuery(summary: ExecutionSummary | null): import('@tanstack/react-query').UseQueryResult<NoInfer<import('./index.ts').ExecutionDetailData>, Error>;
+/** Run a listed execution again with the same input (`rerunExecution`),
+ *  resolving to the new execution's row (or `null` if not listed yet). Every
+ *  history list, stat and probe is invalidated once it settles — a failed
+ *  re-run is still a new execution — as is the workflow's own run list. */
+export declare function useRerunExecutionMutation(): import('@tanstack/react-query').UseMutationResult<ExecutionSummary | null, Error, ExecutionSummary, unknown>;
+/** Look one execution of a callable up by id (`findExecution`) — what opens the original from a
+ *  re-run's "Re-run of <id>". A plain function over the embed client, not a query: it runs once per
+ *  click, and the opened detail has its own query. */
+export declare function useFindExecution(): (callableId: string, id: string) => Promise<ExecutionSummary | null>;

package/dist/repos/index.d.ts

@@ -9,9 +9,11 @@ export * from './workflows.ts';
 export * from './versions.ts';
 export * from './step-tests.ts';
 export * from './history.ts';
+export * from './constants.ts';
 export * from './vars.ts';
 export * from './vault.ts';
 export * from './documents.ts';
+export * from './data-stores.ts';
 export * from '../lib/history-query.ts';
 export * from '../lib/workflow-live-run.ts';
 export * from '../lib/workflow-poll.ts';

package/dist/repos/spec-export.d.ts

@@ -1,6 +1,6 @@
 /** The collections that carry a `/spec` export route — `specCollectionForKind`
  *  (`../lib/rail-settings.ts`) is the sole producer of this type's values. */
-export type SpecCollection = "functions" | "endpoints";
+export type SpecCollection = "functions" | "endpoints" | "workflows";
 /**
  * Mirrors T2.1.1's `SpecDocument`, also mirrored by `repos/spec-import.ts`'s
  * `SpecImportDocument` for the sibling import route: the portable document a
@@ -16,8 +16,8 @@ export interface SpecDocument {
 }
 /**
  * `GET /<collection>/:id/spec`. `collection` is `null` for a kind the Export
- * button never renders on (`specCollectionForKind`'s `workflow`/`connection`
- * arms) — passing `null` disables the query regardless of `enabled`, so a
+ * button never renders on (`specCollectionForKind`'s `connection`
+ * arm) — passing `null` disables the query regardless of `enabled`, so a
  * caller need not re-derive that guard itself.
  */
 export declare function useSpecQuery(collection: SpecCollection | null, id: string, enabled: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<SpecDocument>, Error>;

package/dist/repos/spec-import.d.ts

@@ -1,3 +1,4 @@
+import { PreviewDependency, Selection, SpecDependency } from '../lib/import-bindings.ts';
 import { SpecImportListKeys } from '../lib/spec-import-invalidation.ts';
 /**
  * Mirrors `T2.1.1`'s `SpecDocument` (`T2.1.1.contract.md:134-141`): the
@@ -30,7 +31,32 @@ export interface SpecImportResult {
         name?: string;
     };
     references: SpecImportReferenceReport[];
+    dependencies?: ImportDependencyStatus[];
 }
+/** IF-1 `POST /spec/preview` result: one entry per dependency, with server options + suggestion. */
+export interface PreviewResult {
+    kind: "function" | "endpoint" | "workflow";
+    dependencies: PreviewDependency[];
+    references?: SpecImportReferenceReport[];
+}
+/** One dependency's outcome in the import result (IF-1 `dependencies` status[]). */
+export interface ImportDependencyStatus {
+    key: string;
+    kind?: SpecDependency["kind"];
+    name?: string;
+    status: "bound" | "created" | "unconfigured" | string;
+    boundTo?: string;
+    reason?: string;
+}
+/** The preview request body: the document plus the host project, sent explicitly. */
+export declare function buildPreviewBody(document: Record<string, unknown>, project: string | undefined): Record<string, unknown>;
+/** The import request body: the preview body plus the FULL selections map (`unconfigured` included). */
+export declare function buildImportBody(document: Record<string, unknown>, project: string | undefined, selections: Record<string, Selection>): Record<string, unknown>;
+/**
+ * `POST /spec/preview` (IF-1). Read-only on the server; a failure rejects the mutation and the
+ * caller blocks Create — there is NO fallback to posting the document verbatim to `/spec/import`.
+ */
+export declare function useSpecPreviewMutation(project: string | undefined): import('@tanstack/react-query').UseMutationResult<PreviewResult, Error, Record<string, unknown>, unknown>;
 /**
  * `POST /spec/import`. Success is always `201` — including a partially
  * resolved import (T2.1.2 §E: "report, never fail silently"). This mutation
@@ -41,4 +67,7 @@ export interface SpecImportResult {
  * (`listKeys.workflowsKey(project)`), but every caller passes it uniformly rather than branching on kind itself; see
  * `../lib/spec-import-invalidation.ts` for why the key differs by kind.
  */
-export declare function useImportSpecMutation(project: string | undefined, listKeys: SpecImportListKeys): import('@tanstack/react-query').UseMutationResult<SpecImportResult, Error, Record<string, unknown>, unknown>;
+export declare function useImportSpecMutation(project: string | undefined, listKeys: SpecImportListKeys): import('@tanstack/react-query').UseMutationResult<SpecImportResult, Error, {
+    document: Record<string, unknown>;
+    selections: Record<string, Selection>;
+}, unknown>;

package/dist/repos/step-tests.d.ts

@@ -2,6 +2,8 @@ import { W6WClient } from '@w6w/sdk';
 import { StepTest } from '@w6w/sdk/console';
 export type { StepTest } from '@w6w/sdk/console';
 export declare const stepTestsKey: (workflowId: string, stepId: string) => readonly ["stepTests", string, string];
+/** The prefix of every {@link stepTestsKey} of one workflow — invalidates all its steps at once. */
+export declare const workflowStepTestsKey: (workflowId: string) => readonly ["stepTests", string];
 export declare function listStepTests(client: W6WClient, workflowId: string, stepId: string): Promise<StepTest[]>;
 export declare function saveStepTest(client: W6WClient, workflowId: string, stepId: string, body: {
     name?: string;

package/dist/repos/webhook-listen.d.ts

@@ -0,0 +1,35 @@
+import { W6WClient } from '@w6w/sdk';
+/**
+ * "Listen for test event" on a `@w6w/webhook` subscription — `/subscriptions/:id/listen` over
+ * `client.request()`. Not in the SDK's stable contract (Studio reaches it the same way, its
+ * `repos/subscriptions.ts`), and `createW6WUiAdapter` carries none of it, so without these the
+ * embedded editor's webhook Test tab fell back to the paste-a-payload form.
+ */
+/**
+ * Structural mirror of ui's `WebhookListenSession` (this barrel may not import `@w6w/ui`); the
+ * UiBridge assignment typechecks against W6WApi structurally.
+ */
+export interface WebhookListenSession {
+    id: string;
+    subscriptionId: string;
+    nodeId: string | null;
+    expiresAt: string;
+    status: "waiting" | "captured" | "expired";
+    request?: {
+        method: string;
+        path: string;
+        query: Record<string, string>;
+        headers: Record<string, string>;
+        body: unknown;
+    };
+    receivedAt?: string;
+}
+export declare function startWebhookListen(client: W6WClient, subscriptionId: string): Promise<{
+    session: WebhookListenSession;
+    webhookUrl: string;
+}>;
+export declare function pollWebhookListen(client: W6WClient, subscriptionId: string, sessionId: string, opts?: {
+    waitSeconds?: number;
+    signal?: AbortSignal;
+}): Promise<WebhookListenSession>;
+export declare function stopWebhookListen(client: W6WClient, subscriptionId: string, sessionId: string): Promise<void>;

package/dist/repos/workflows.d.ts

@@ -1,5 +1,6 @@
 import { UseMutationResult } from '@tanstack/react-query';
-import { W6WClient, WorkflowRunResult } from '@w6w/sdk';
+import { StateLogRow } from '@w6w/expr';
+import { RunStatus, W6WClient, WorkflowRunResult } from '@w6w/sdk';
 import { RunState } from '@w6w/sdk/console';
 export type { RunState, RunSummary } from '@w6w/sdk/console';
 export type { WorkflowStatus, WorkflowSummary } from '@w6w/sdk';
@@ -51,7 +52,7 @@ export declare function useRunsQuery(workflowId: string): import('@tanstack/reac
  * resolve in a real run. Omitted, that node outputs `{}` and every reference to
  * a trigger field resolves to the empty string — the failure mode filed as
  * `.ai/projects/backlog/26-07-29-01-trigger-run-payload.md`, where a step tests
- * green and then does nothing in production. `variables` seeds `vars.*` and
+ * green and then does nothing in production. `variables` seeds `var.*` and
  * reaches the trigger node not at all.
  *
  * Goes through the typed `client.workflows.run()` with
@@ -95,6 +96,87 @@ export declare function runWorkflowSync(client: W6WClient, id: string, variables
 export declare function startWorkflowRun(client: W6WClient, id: string, variables: Record<string, unknown>, input?: Record<string, unknown>): Promise<{
     runId: string;
 }>;
+/** What {@link startRunFromNode} sends: the paused nodes to stop before, and the start seed. */
+export interface RunFromNodeBody {
+    /** Node ids the run stops BEFORE (they do not execute) — the editor's paused nodes. */
+    stopAt: string[];
+    /** Upstream outputs keyed by node id, seeded from saved step tests / the last run. */
+    nodes?: Record<string, {
+        output?: unknown;
+        meta?: unknown;
+    }>;
+    /** The trigger's filled values, when the run starts at a trigger node. */
+    input?: Record<string, unknown>;
+}
+/**
+ * Run from a node — `POST /workflows/:id/nodes/:nodeId/run` with `continue: true`: a REAL run
+ * that executes `nodeId`, continues through every node downstream of it the way a run follows
+ * its edges, and stops before each `stopAt` node. Answers `202 { runId }` at once, like
+ * {@link startWorkflowRun}, so the caller polls it live ({@link useLiveRunQuery}). The run
+ * executes the STORED definition, so a caller flushes its draft first.
+ *
+ * The plain `client.request()` escape hatch, not a typed `@w6w/sdk` method: the route is a
+ * console authoring aid, and a typed method would pull `packages/wrappers` (every language, in
+ * lockstep) into an editor-only change.
+ */
+export declare function startRunFromNode(client: W6WClient, id: string, nodeId: string, body: RunFromNodeBody): Promise<{
+    runId: string;
+}>;
+/** A node output's structural shape, as the server records it (structural mirror of `@w6w/ui`'s). */
+export type NodeSampleShape = {
+    type: "string" | "number" | "boolean" | "null" | "unknown";
+} | {
+    type: "object";
+    fields: Record<string, NodeSampleShape>;
+} | {
+    type: "array";
+    items?: NodeSampleShape;
+};
+/**
+ * One persisted node sample — structural mirror of `@w6w/ui`'s `NodeSample` (this barrel may not
+ * import `@w6w/ui`; the facade/UiBridge assignment typechecks against `W6WApi` structurally).
+ */
+export interface NodeSample {
+    nodeId: string;
+    shape: NodeSampleShape;
+    sample?: unknown;
+    sampleOmitted?: true;
+    source: "step_test" | "node_run" | "run";
+    runId?: string;
+    updatedAt: string;
+}
+/**
+ * The workflow's persisted node samples — `GET /workflows/:id/node-samples` → `{ nodeSamples }`:
+ * each node's last output shape (and value, when kept), written server-side on every Test, node
+ * run and run. Backs `W6WApi.loadNodeSamples`, so the editor's picker keeps upstream keys across a
+ * reload. The plain `client.request()` escape hatch, for the same reason as {@link startRunFromNode}.
+ */
+export declare function listNodeSamples(client: W6WClient, id: string): Promise<NodeSample[]>;
+/** One remembered node test input — structural mirror of `@w6w/ui`'s `NodeTestInput`. */
+export interface NodeTestInput {
+    nodeId: string;
+    input: Record<string, unknown>;
+    updatedAt: string;
+}
+/**
+ * The test input each node of the workflow last ran with in the editor —
+ * `GET /workflows/:id/test-inputs` → `{ testInputs }` (`node_test_inputs`, 0160). Backs
+ * `W6WApi.loadTestInputs`, so the Run node modal, the Test tabs and the header Run reopen
+ * prefilled. The plain `client.request()` escape hatch, for the same reason as {@link startRunFromNode}.
+ */
+export declare function listTestInputs(client: W6WClient, id: string): Promise<NodeTestInput[]>;
+/**
+ * Remember a node's test input (`{}` clears it) — `PUT /workflows/:id/nodes/:nodeId/test-input`.
+ * Backs `W6WApi.saveTestInput`; the server drops sealed envelopes before the write.
+ */
+export declare function saveTestInput(client: W6WClient, id: string, nodeId: string, input: Record<string, unknown>): Promise<void>;
+export declare function useRunFromNodeMutation(): UseMutationResult<{
+    runId: string;
+}, Error, {
+    id: string;
+    nodeId: string;
+    body: RunFromNodeBody;
+}, unknown>;
 export declare function useStartRunMutation(): UseMutationResult<{
     runId: string;
 }, Error, {
@@ -136,3 +218,24 @@ export declare const runStateKey: (runId: string) => readonly ["run", string];
  * run started yet, or the page navigated to a different workflow).
  */
 export declare function useLiveRunQuery(runId: string | null): import('@tanstack/react-query').UseQueryResult<NoInfer<RunState>, Error>;
+/** `GET /runs/:id/state-writes` — the run's state-write log (plan §2.4). */
+export interface RunStateWrites {
+    writes: StateLogRow[];
+    truncated: boolean;
+}
+/**
+ * One run's state-write log, read for the run log's State block ("state after this
+ * step"). The plain `client.request()` escape hatch, for the same reason as
+ * {@link listNodeSamples}: the route has no typed `@w6w/sdk` method.
+ */
+export declare function getRunStateWrites(client: W6WClient, runId: string): Promise<RunStateWrites>;
+/** Query key for one run's state-write log. The last segment flips from `"live"` to
+ *  `"final"` when the run turns terminal, so the final log is fetched exactly once more. */
+export declare function runStateWritesKey(runId: string, status: RunStatus | undefined): readonly ["run", string, "state-writes", "live" | "final"];
+/**
+ * Poll one run's state-write log beside {@link useLiveRunQuery}: the same 500ms cadence
+ * while the run (as `status`, the live run query's answer) is in flight, no polling once
+ * terminal. `retry: false` — a failed read only leaves the run log without its State
+ * block; it never touches the run poll.
+ */
+export declare function useRunStateWritesQuery(runId: string | null, status: RunStatus | undefined): import('@tanstack/react-query').UseQueryResult<NoInfer<RunStateWrites>, Error>;