langflower 0.0.10 → 0.1.0

package/vendor/common-nodes/dist/flow/checkpoint/node.js

@@ -11,9 +11,13 @@ export const checkpointNode = defineReactiveNode({
     displayName: 'Checkpoint',
     category: 'Flow',
     paletteSecondary: true,
-    description: 'Passthrough that **writes a durable checkpoint** when crossed. ' +
-        'Stop without crossing a Checkpoint does not create a resume point. ' +
-        'Optional **label** appears in the Continue picker.',
+    description: `
+Save a resume point when the run passes this node. Stop without crossing it does **not** create Continue.
+
+Typical uses:
+- A safe place to resume a long job
+- Optional **label** in the Continue picker
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput }) {
         const value = makeInput('value', {

package/vendor/common-nodes/dist/flow/delay/node.d.ts

@@ -1,12 +1,8 @@
 /**
  * Pass-through with configurable RxJS delay on inline `delay` input (ms).
  *
- * Built with `combineInputs(...).pipeValue(concatMap(...))`. The runtime's
- * `tapOutputPort` taps this output and forwards its `pending`/`value` lifecycle
- * over the WS bridge — the bridge now holds an always-on `events$` subscription
- * (see BUG-2026-07-14 in `docs/FOUND_BUGS.md`), so the `pending` pulse is
- * delivered to the UI. `delayMs` is annotated because `combineInputs` passes the
- * combined value as an untyped tuple.
+ * Stamp pending with {@link withLoading} on the raw stream before async
+ * `pipeValue`. `pipeValue(concatMap(delay))` only delays success.
  */
 export declare const delayNode: {
     readonly emitOncePerActivation: boolean;

package/vendor/common-nodes/dist/flow/delay/node.js

@@ -1,21 +1,23 @@
-import { defineReactiveNode } from '@langflower/node-sdk';
 import { concatMap, delay, of } from 'rxjs';
+import { defineReactiveNode, withLoading } from '@langflower/node-sdk';
 /**
  * Pass-through with configurable RxJS delay on inline `delay` input (ms).
  *
- * Built with `combineInputs(...).pipeValue(concatMap(...))`. The runtime's
- * `tapOutputPort` taps this output and forwards its `pending`/`value` lifecycle
- * over the WS bridge — the bridge now holds an always-on `events$` subscription
- * (see BUG-2026-07-14 in `docs/FOUND_BUGS.md`), so the `pending` pulse is
- * delivered to the UI. `delayMs` is annotated because `combineInputs` passes the
- * combined value as an untyped tuple.
+ * Stamp pending with {@link withLoading} on the raw stream before async
+ * `pipeValue`. `pipeValue(concatMap(delay))` only delays success.
  */
 export const delayNode = defineReactiveNode({
     type: 'common-delay',
     displayName: 'Delay',
     category: 'Flow',
     paletteSecondary: true,
-    description: 'Passes through the wired `value` after an inline **delay** in milliseconds.',
+    description: `
+Hold a value for a number of milliseconds, then pass it on unchanged.
+
+Typical uses:
+- Pace a Repeat or Split (paced) loop
+- Wait before the next API or file step
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput, combineInputs }) {
         const value = makeInput('value', {
@@ -29,7 +31,9 @@ export const delayNode = defineReactiveNode({
             inline: 'text',
             defaultValue: 0,
         });
-        const output$ = combineInputs([value, delayInput], ([inputValue, delayMs]) => ({ inputValue, delayMs })).pipeValue(concatMap(({ inputValue, delayMs }) => of(inputValue).pipe(delay(delayMs))));
+        const output$ = combineInputs([value, delayInput], ([inputValue, delayMs]) => ({ inputValue, delayMs }))
+            .pipe(withLoading())
+            .pipeValue(concatMap(({ inputValue, delayMs }) => of(inputValue).pipe(delay(Math.max(0, Number(delayMs) || 0)))));
         return {
             inputs: [value, delayInput],
             outputs: [

package/vendor/common-nodes/dist/flow/loop/node.js

@@ -11,7 +11,13 @@ export const loopNode = defineReactiveNode({
     displayName: 'Loop',
     category: 'Flow',
     paletteSecondary: true,
-    description: 'Map-collect over a runtime list: emit each **item** to an external body, collect **results** (JSON array). Dynamic N without graph rewrite.',
+    description: `
+For each item in a list, run the body you wire, then collect the results.
+
+Typical uses:
+- Process many files or topics without duplicating nodes
+- Map a list through an LLM or a file write
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput }) {
         const items = makeInput('items', {

package/vendor/common-nodes/dist/flow/merge/node.js

@@ -5,7 +5,13 @@ export const mergeNode = defineReactiveNode({
     displayName: 'Merge',
     category: 'Flow',
     paletteSecondary: true,
-    description: 'Merges multiple `value` inputs into a **single stream** as values arrive.',
+    description: `
+Join several wires into one. Each incoming value is forwarded as it arrives.
+
+Typical uses:
+- Fan-in parallel branches
+- Collect results from Router channels
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput }) {
         const value$ = makeInput('value', {

package/vendor/common-nodes/dist/flow/repeat/node.js

@@ -9,7 +9,11 @@ export const repeatNode = defineReactiveNode({
     displayName: 'Repeat',
     category: 'Flow',
     paletteSecondary: true,
-    description: 'Repeats wired `value` **count** times. First emit ASAP; later emits wait for `trigger`. After the last value, the next trigger emits `done: true` instead of another value.',
+    description: `
+Send the same value several times. The first copy starts immediately; pulse **trigger** for the next.
+
+After the last copy, the next trigger fires **done** instead of another value. **index** counts from 0 so you can show progress.
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput, combineInputs }) {
         const value = makeInput('value', {

package/vendor/common-nodes/dist/flow/router/node.js

@@ -5,7 +5,13 @@ export const routerNode = defineReactiveNode({
     type: COMMON_ROUTER_TYPE,
     displayName: 'Router',
     category: 'Flow',
-    description: 'Use for **visual organisation of edges** in complex workflows. Any number of inputs can be connected — input ports expand dynamically.',
+    description: `
+Tidy a busy canvas: any number of inputs can connect, and extra ports appear as you wire more.
+
+Typical uses:
+- Group many edges so they stay readable
+- Fan-out one stream to several destinations
+`.trim(),
     uiSchema: [],
     bind() {
         return { inputs: [], outputs: [] };

package/vendor/common-nodes/dist/hitl/chat-input/node.d.ts

@@ -1,6 +1,6 @@
 /**
- * Conversational run entry — no wireable inputs; the feed composer submits
- * `message`, which cold-starts the cluster via `pushIntoInput`.
+ * Conversational run entry. `message` is hidden + inline: field, no handle.
+ * Prefill on the node or in the composer; Start cold-starts via `pushIntoInput`.
  */
 export declare const chatInputNode: {
     readonly emitOncePerActivation: boolean;

package/vendor/common-nodes/dist/hitl/chat-input/node.js

@@ -1,15 +1,18 @@
 import { defineReactiveNode } from '@langflower/node-sdk';
 import { map } from 'rxjs';
 /**
- * Conversational run entry — no wireable inputs; the feed composer submits
- * `message`, which cold-starts the cluster via `pushIntoInput`.
+ * Conversational run entry. `message` is hidden + inline: field, no handle.
+ * Prefill on the node or in the composer; Start cold-starts via `pushIntoInput`.
  */
 export const chatInputNode = defineReactiveNode({
     type: 'common-chat-input',
     displayName: 'Chat Input',
     category: 'HITL',
-    description: 'Starts a chat-style run from the feed composer. Clusters with this ' +
-        'node are **not** started by plain Run — submit a message instead.',
+    description: `
+Start this graph from the composer **Start** control — not plain Run.
+
+Prefill a message on the node or type in the composer. Stop then Start reuses it.
+`.trim(),
     chatEntry: true,
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput }) {
@@ -17,6 +20,7 @@ export const chatInputNode = defineReactiveNode({
             name: 'Message',
             wireType: 'string',
             hidden: true,
+            inline: 'text-multiline',
             hitl: {
                 title: 'Message',
                 kind: 'textarea',

package/vendor/common-nodes/dist/hitl/review-gate/node.js

@@ -1,11 +1,17 @@
-import { defineReactiveNode } from '@langflower/node-sdk';
-import { filter, map, pipe, switchMap, take } from 'rxjs';
+import { defineReactiveNode, withLoading } from '@langflower/node-sdk';
+import { filter, map, switchMap, take } from 'rxjs';
 /** Review gate: separate HITL inputs for approve vs request-changes. */
 export const hitlReviewGateNode = defineReactiveNode({
     type: 'common-hitl-review-gate',
     displayName: 'Review Gate',
     category: 'HITL',
-    description: 'HITL gate with separate **Approve** and **Request changes** actions.',
+    description: `
+Pause for a human. **Approve** to continue, or **Request changes** with feedback.
+
+Typical uses:
+- Gate a draft before the next stage
+- Collect edits without leaving the editor
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput }) {
         const result = makeInput('result', {
@@ -42,8 +48,8 @@ export const hitlReviewGateNode = defineReactiveNode({
             inferTypeFrom: result,
             feed: { role: 'none' },
         });
-        const response$ = approve.pipeValue(pipe(filter((approved) => approved === true), switchMap(() => result.value$.pipe(take(1))), map((reviewed) => reviewed ?? '')));
-        const feedback$ = requestChanges.pipeValue(map((text) => text ?? ''));
+        const response$ = result.pipe(withLoading()).pipeValue(switchMap((reviewed) => approve.value$.pipe(filter((approved) => approved === true), take(1), map(() => reviewed ?? ''))));
+        const feedback$ = result.pipe(withLoading()).pipeValue(switchMap(() => requestChanges.value$.pipe(take(1), map((text) => text ?? ''))));
         return {
             inputs: [result, approve, requestChanges],
             outputs: [

package/vendor/common-nodes/dist/langflower-tools/node.js

@@ -64,7 +64,11 @@ export const langflowerToolsNode = defineReactiveNode({
     type: 'common-langflower-tools',
     displayName: 'Langflower Tools',
     category: 'Tools',
-    description: 'Emits compile_custom_nodes (Custom → Update over the bus). Wire tools to opt in; later bus actions may be added to this pack.',
+    description: `
+Wire this into an agent so it can recompile custom nodes from chat — same intent as Custom → **Update**.
+
+On starter, Helper and Writer already have this wired.
+`.trim(),
     uiSchema: [],
     bind(ctx, { configureOutput }) {
         return {

package/vendor/common-nodes/dist/logic/assert/node.js

@@ -9,7 +9,13 @@ export const assertNode = defineReactiveNode({
     displayName: 'Assert',
     category: 'Logic',
     paletteSecondary: true,
-    description: 'Fails the run branch when `condition` is not true; otherwise passthrough `value`.',
+    description: `
+Stop this branch if **condition** is not true. Otherwise the **value** passes through.
+
+Typical uses:
+- Fail the run when tests did not pass
+- Block the next stage until a check is green
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput, combineInputs }) {
         const condition = makeInput('condition', {

package/vendor/common-nodes/dist/logic/compare/node.js

@@ -6,7 +6,13 @@ export const compareNode = defineReactiveNode({
     displayName: 'Compare',
     category: 'Logic',
     paletteSecondary: true,
-    description: 'Compares wired `a` and `b` with panel operator (`eq`, `ne`, `lt`, …) → boolean `result`.',
+    description: `
+Compare **a** and **b** (equals, not-equals, less than, …) and emit a boolean.
+
+Typical uses:
+- Drive IF or Gate
+- Check a score or a count
+`.trim(),
     uiSchema: [
         {
             field: 'op',

package/vendor/common-nodes/dist/logic/gate/node.js

@@ -6,7 +6,13 @@ export const gateNode = defineReactiveNode({
     displayName: 'Gate',
     category: 'Logic',
     paletteSecondary: true,
-    description: 'Forwards wired `value` only when boolean `pass` is true; otherwise emits nothing.',
+    description: `
+Forward **value** only when **pass** is true. Otherwise nothing is emitted.
+
+Typical uses:
+- Drop failed reviews
+- Continue a loop only while a flag stays true
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput, combineInputs }) {
         const pass = makeInput('pass', {

package/vendor/common-nodes/dist/logic/if/node.js

@@ -6,7 +6,13 @@ export const ifNode = defineReactiveNode({
     displayName: 'IF',
     category: 'Logic',
     paletteSecondary: true,
-    description: 'Routes wired `value` to the `true` or `false` output from boolean `condition`.',
+    description: `
+Send **value** out **true** or **false** depending on **condition**.
+
+Typical uses:
+- Branch after Compare or Assert
+- Two different follow-up paths from one check
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput, combineInputs }) {
         const condition = makeInput('condition', {

package/vendor/common-nodes/dist/logic/switch/node.js

@@ -14,7 +14,13 @@ export const switchNode = defineReactiveNode({
     displayName: 'Switch',
     category: 'Logic',
     paletteSecondary: true,
-    description: 'Routes string `value` to the first matching rule output (`pass` / `fail`) or `default`.',
+    description: `
+Match a string against rules and send it to **pass**, **fail**, or **default**.
+
+Typical uses:
+- Route by status text
+- Several named outcomes without stacking IF nodes
+`.trim(),
     uiSchema: [
         {
             field: 'rules',

package/vendor/common-nodes/dist/mcp/mcp-http/node.js

@@ -1,8 +1,8 @@
-import { defineReactiveNode, TOOL_HANDLE_WIRE_TYPE, } from '@langflower/node-sdk';
+import { defineReactiveNode, withLoading, TOOL_HANDLE_WIRE_TYPE, } from '@langflower/node-sdk';
 import { buildMcpHandle } from '@langflower/tools/build-mcp-handle';
 import { formatMcpConnectError } from '@langflower/tools/format-mcp-connect-error';
 import { connectMcpHttpWithOptionalLaunch } from '@langflower/tools/mcp-http-client';
-import { distinctUntilChanged, EMPTY, Observable, pipe, switchMap } from 'rxjs';
+import { distinctUntilChanged, filter, Observable, switchMap } from 'rxjs';
 const paramsKey = (params) => JSON.stringify({
     nodeId: params.nodeId,
     projectDir: params.projectDir,
@@ -19,7 +19,11 @@ export const mcpHttpNode = defineReactiveNode({
     type: 'common-mcp-http',
     displayName: 'MCP http',
     category: 'Tools',
-    description: 'Connects to an MCP server over Streamable HTTP and emits its tools for LLM `tools` ports. Optional shell command launches a local process first; URL alone targets an already-running server.',
+    description: `
+Connect to an MCP server over HTTP and give its tools to an agent.
+
+Paste a URL for a server that is already running, or set a launch command to start one first.
+`.trim(),
     uiSchema: [],
     bind(ctx, { makeInput, configureOutput, combineInputs }) {
         const url = makeInput('url', {
@@ -35,60 +39,58 @@ export const mcpHttpNode = defineReactiveNode({
             inline: 'text',
             defaultValue: '',
         });
-        const handle$ = combineInputs([ctx, url, command], ([ec, serverUrl, cli]) => ({
+        const params$ = combineInputs([ctx, url, command], ([ec, serverUrl, cli]) => ({
             nodeId: String(ec.nodeId ?? ''),
             projectDir: String(ec.projectDir ?? ''),
             url: String(serverUrl ?? '').trim(),
             command: String(cli ?? '').trim(),
-        })).pipeValue(pipe(distinctUntilChanged((left, right) => paramsKey(left) === paramsKey(right)), switchMap((params) => {
-            if (params.url.length === 0 ||
-                params.nodeId.trim().length === 0) {
-                return EMPTY;
-            }
-            return new Observable((subscriber) => {
-                let closed = false;
-                let closeSession;
-                const fail = (cause) => {
-                    if (closed || subscriber.closed) {
-                        return;
-                    }
-                    subscriber.error(formatMcpConnectError(cause, {
-                        nodeId: params.nodeId,
-                        kind: 'http',
-                        target: params.url,
-                    }));
-                };
-                const run = async () => {
-                    const session = await connectMcpHttpWithOptionalLaunch({
-                        url: params.url,
-                        ...(params.command.length > 0
-                            ? { command: params.command }
-                            : {}),
-                        ...(params.projectDir.length > 0
-                            ? { cwd: params.projectDir }
-                            : {}),
-                    });
-                    closeSession = () => session.close();
-                    if (closed) {
-                        await session.close();
-                        return;
-                    }
-                    const handle = await buildMcpHandle({
-                        id: params.nodeId,
-                        client: session.client,
-                    });
-                    if (closed) {
-                        await session.close();
-                        return;
-                    }
-                    subscriber.next(handle.tools);
-                };
-                void run().catch(fail);
-                return () => {
-                    closed = true;
-                    void closeSession?.();
-                };
-            });
+        })).pipeValue(distinctUntilChanged((left, right) => paramsKey(left) === paramsKey(right)));
+        const handle$ = params$
+            .pipeValue(filter((params) => params.url.length > 0 &&
+            params.nodeId.trim().length > 0))
+            .pipe(withLoading())
+            .pipeValue(switchMap((params) => new Observable((subscriber) => {
+            let closed = false;
+            let closeSession;
+            const fail = (cause) => {
+                if (closed || subscriber.closed) {
+                    return;
+                }
+                subscriber.error(formatMcpConnectError(cause, {
+                    nodeId: params.nodeId,
+                    kind: 'http',
+                    target: params.url,
+                }));
+            };
+            const run = async () => {
+                const session = await connectMcpHttpWithOptionalLaunch({
+                    url: params.url,
+                    ...(params.command.length > 0
+                        ? { command: params.command }
+                        : {}),
+                    ...(params.projectDir.length > 0
+                        ? { cwd: params.projectDir }
+                        : {}),
+                });
+                closeSession = () => session.close();
+                if (closed) {
+                    await session.close();
+                    return;
+                }
+                const tools = await buildMcpHandle({
+                    client: session.client,
+                });
+                if (closed) {
+                    await session.close();
+                    return;
+                }
+                subscriber.next(tools);
+            };
+            void run().catch(fail);
+            return () => {
+                closed = true;
+                void closeSession?.();
+            };
         })));
         return {
             inputs: [url, command],

package/vendor/common-nodes/dist/mcp/mcp-stdio/node.js

@@ -1,8 +1,8 @@
-import { defineReactiveNode, TOOL_HANDLE_WIRE_TYPE, } from '@langflower/node-sdk';
+import { defineReactiveNode, withLoading, TOOL_HANDLE_WIRE_TYPE, } from '@langflower/node-sdk';
 import { buildMcpHandle } from '@langflower/tools/build-mcp-handle';
 import { formatMcpConnectError } from '@langflower/tools/format-mcp-connect-error';
 import { connectMcpStdioFromCli } from '@langflower/tools/mcp-stdio-client';
-import { distinctUntilChanged, EMPTY, Observable, pipe, switchMap } from 'rxjs';
+import { distinctUntilChanged, filter, Observable, switchMap } from 'rxjs';
 const paramsKey = (params) => JSON.stringify({
     nodeId: params.nodeId,
     projectDir: params.projectDir,
@@ -18,7 +18,13 @@ export const mcpStdioNode = defineReactiveNode({
     type: 'common-mcp-stdio',
     displayName: 'MCP stdio',
     category: 'Tools',
-    description: 'Launches an MCP server over stdio from a shell command line and emits its tools for LLM `tools` ports.',
+    description: `
+Launch an MCP server from a command and give its tools to an agent.
+
+Typical uses:
+- Local stdio MCP (filesystem, browser, …)
+- Extra tools without writing a custom node
+`.trim(),
     uiSchema: [],
     bind(ctx, { makeInput, configureOutput, combineInputs }) {
         const command = makeInput('command', {
@@ -28,56 +34,52 @@ export const mcpStdioNode = defineReactiveNode({
             defaultValue: '',
             required: true,
         });
-        const handle$ = combineInputs([ctx, command], ([ec, cli]) => ({
+        const params$ = combineInputs([ctx, command], ([ec, cli]) => ({
             nodeId: String(ec.nodeId ?? ''),
             projectDir: String(ec.projectDir ?? ''),
             command: String(cli ?? '').trim(),
-        })).pipeValue(pipe(distinctUntilChanged((left, right) => paramsKey(left) === paramsKey(right)), switchMap((params) => {
-            if (params.command.length === 0 ||
-                params.nodeId.trim().length === 0) {
-                return EMPTY;
-            }
-            return new Observable((subscriber) => {
-                let closed = false;
-                let closeClient;
-                const fail = (cause) => {
-                    if (closed || subscriber.closed) {
-                        return;
-                    }
-                    subscriber.error(formatMcpConnectError(cause, {
-                        nodeId: params.nodeId,
-                        kind: 'stdio',
-                        target: params.command,
-                    }));
-                };
-                const run = async () => {
-                    const client = await connectMcpStdioFromCli({
-                        commandLine: params.command,
-                        ...(params.projectDir.length > 0
-                            ? { cwd: params.projectDir }
-                            : {}),
-                    });
-                    closeClient = () => client.close();
-                    if (closed) {
-                        await client.close();
-                        return;
-                    }
-                    const handle = await buildMcpHandle({
-                        id: params.nodeId,
-                        client,
-                    });
-                    if (closed) {
-                        await client.close();
-                        return;
-                    }
-                    subscriber.next(handle.tools);
-                };
-                void run().catch(fail);
-                return () => {
-                    closed = true;
-                    void closeClient?.();
-                };
-            });
+        })).pipeValue(distinctUntilChanged((left, right) => paramsKey(left) === paramsKey(right)));
+        const handle$ = params$
+            .pipeValue(filter((params) => params.command.length > 0 &&
+            params.nodeId.trim().length > 0))
+            .pipe(withLoading())
+            .pipeValue(switchMap((params) => new Observable((subscriber) => {
+            let closed = false;
+            let closeClient;
+            const fail = (cause) => {
+                if (closed || subscriber.closed) {
+                    return;
+                }
+                subscriber.error(formatMcpConnectError(cause, {
+                    nodeId: params.nodeId,
+                    kind: 'stdio',
+                    target: params.command,
+                }));
+            };
+            const run = async () => {
+                const client = await connectMcpStdioFromCli({
+                    commandLine: params.command,
+                    ...(params.projectDir.length > 0
+                        ? { cwd: params.projectDir }
+                        : {}),
+                });
+                closeClient = () => client.close();
+                if (closed) {
+                    await client.close();
+                    return;
+                }
+                const tools = await buildMcpHandle({ client });
+                if (closed) {
+                    await client.close();
+                    return;
+                }
+                subscriber.next(tools);
+            };
+            void run().catch(fail);
+            return () => {
+                closed = true;
+                void closeClient?.();
+            };
         })));
         return {
             inputs: [command],

package/vendor/common-nodes/dist/memory/memory-tools/node.js

@@ -8,6 +8,10 @@ export const memoryToolsNode = defineToolRegistrations({
     type: 'common-memory-tools',
     displayName: 'Memory Tools',
     category: 'Tools',
-    description: 'Emits get_memory_tree / read_memory_section / search_memory_grep / append_memory_log / update_memory_section / create_memory_file for agent inventory.',
+    description: `
+Give an agent tools to read and write the project wiki (tree, search, append, update, create).
+
+Wire **tools** into an LLM. Notes live under the project's memory folder.
+`.trim(),
     tools: MEMORY_TOOL_CONFIGS,
 });

package/vendor/common-nodes/dist/output/finish/node.js

@@ -1,20 +1,32 @@
 import { defineReactiveNode } from '@langflower/node-sdk';
+import { map } from 'rxjs';
 /** Passthrough sink — first output emission stops the run. */
 export const finishNode = defineReactiveNode({
     type: 'common-finish',
     displayName: 'Finish',
     category: 'Output',
-    description: 'Passthrough sink — the first output emission **stops the run**.',
+    description: `
+Last step of a run. When this node outputs, the run **stops**.
+
+Wire the final result here so Start/Stop settle instead of hanging on open work.
+`.trim(),
     stopsRun: true,
     emitOncePerActivation: true,
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput }) {
         const value = makeInput('value', { name: 'value', required: true });
+        const done$ = value.pipeValue(map(() => 'done'));
         return {
             inputs: [value],
             outputs: [
+                configureOutput('done', done$, {
+                    wireType: 'string',
+                    hidden: true,
+                    feed: { role: 'result' },
+                }),
                 configureOutput('value', value, {
                     inferTypeFrom: value,
+                    feed: { role: 'none' },
                 }),
             ],
         };

package/vendor/common-nodes/dist/output/preview/node.js

@@ -19,14 +19,20 @@ export const previewNode = defineReactiveNode({
     type: 'common-preview',
     displayName: 'Preview',
     category: 'Output',
-    description: 'Displays wired **text** in a read-only preview area on the canvas.',
+    description: `
+Show a wired value on the canvas and in the work log so you can inspect it.
+
+Typical uses:
+- Debug a mid-pipeline value
+- A human-readable end of a small graph
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput }) {
         const text = makeInput('text', {
             name: 'text',
             wireType: 'string',
             required: true,
-            inline: 'preview',
+            inline: 'preview-markdown',
         });
         const output$ = text.pipeValue(map(formatPreviewText));
         return {
@@ -34,6 +40,7 @@ export const previewNode = defineReactiveNode({
             outputs: [
                 configureOutput('text', output$, {
                     inferTypeFrom: text,
+                    feed: { role: 'result' },
                 }),
             ],
         };