@w6w/embed 0.2.1 → 0.2.19

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>;