langflower 0.0.1

package/vendor/shared/dist/langflower-bus-config.d.ts

@@ -0,0 +1,424 @@
+import type { RuntimeEdge, RuntimeRunnerEvent } from '@langflower/runtime';
+import type { DividerPositions, ExecutionFeedSnapshotPayload, RunnerSnapshotPayload, SessionStateSnapshotPayload, ToolConfigSnapshotPayload } from './types/langflower-bootstrap.js';
+import type { LangflowerConfigSaveRequestedPayload, LangflowerConfigSnapshotPayload, LangflowerModelsCatalogSnapshotPayload, RunnerPermissionAskPayload, RunnerPermissionReplyPayload } from './types/langflower-config.js';
+import type { RunnerCheckpointDiscardRequestedPayload, RunnerCheckpointsSnapshotPayload, RunnerResumeFailedPayload, RunnerResumeRequestedPayload, WorkflowCheckpointSummary } from './types/workflow-checkpoint.js';
+import type { EditorAddEdgeRequestedPayload, EditorAddNodeRequestedPayload, EditorPasteRequestedPayload, EditorSelectedNodePayload, EditorSelectNodeRequestedPayload, EditorUpdateNodeRequestedPayload } from './types/langflower-editor.js';
+import type { CustomPaletteSnapshotPayload } from './types/langflower-custom-palette.js';
+import type { PaletteConfigPayload } from './types/langflower-palette.js';
+import type { ProjectBootstrapResultPayload } from './types/langflower-project-bootstrap.js';
+import type { SessionReadyPayload } from './types/langflower-server.js';
+import type { CanvasViewport, WorkflowCurrentSnapshotPayload, WorkflowCurrentStatusPayload, WorkflowCopyPayload, WorkflowCreatePayload, WorkflowDeletePayload, WorkflowListSnapshotPayload, WorkflowLoadPayload, WorkflowNodePersisted, WorkflowRenameCurrentPayload, WorkflowSaveCurrentPayload } from './types/langflower-workflow.js';
+/**
+ * Typed internal WebSocket registry for co-versioned Langflower
+ * UI/server/runtime (ws-bridge, **pure event-driven**).
+ *
+ * Runtime APIs are the protocol source of truth by design: changing runtime
+ * method shapes should fail fast at compile time across server and UI instead
+ * of spawning DTO adapters that can drift. The shared transport path/port lives
+ * here for the same reason — client and server consume one source of truth.
+ *
+ * No RPC envelopes, no `requestId`. Client emits `*.requested` intents; the server
+ * executes and broadcasts authoritative snapshots (see {@link workflowManagerConfig}
+ * for multi-tab workflow sync). Clients **replace local projection from snapshots**
+ * — they do not correlate replies to “their” command.
+ *
+ * ## State sync model (snapshot vs event-sourcing)
+ *
+ * Several tabs may share one server session. On **connect / reconnect** (browser
+ * refresh, new tab) each client must reach the same authoritative state without
+ * replaying full history. Domains use **dedicated snapshot keys** — slim
+ * {@link SessionStateSnapshotPayload} is **not** a fat reconnect bundle.
+ *
+ * | Domain | Model | Reconnect | Live updates |
+ * | ------ | ----- | --------- | -------------- |
+ * | Session chrome (dividers, selection) + effective `langflowerConfig` | **snapshot only** | slim `session.state.snapshot` | dividers / selection via `editor.dividers.snapshot` / `editor.nodeSelected` |
+ * | Langflower project config (full layers) | **snapshot only** | `langflower.config.snapshot` after `session.ready`; effective also in slim session | full slice replace |
+ * | Live provider model catalogs | **snapshot only** | `langflower.models.catalog.snapshot` after config (async on connect) + after Save | full map replace |
+ * | Tool config | **snapshot only** | `toolConfig.snapshot` | full slice replace |
+ * | Workflow catalog + active doc | **snapshot only** | `workflow.list.snapshot` / `workflow.current.snapshot` | full slice replace |
+ * | Workflow dirty/pristine | **snapshot only** | `currentStatus` in `workflow.current.snapshot`; `workflow.currentStatus.snapshot` after editor mutations | status slice replace |
+ * | Palette (system) | **snapshot only** | `palette.snapshot` on connect (server-pushed) | full slice replace |
+ * | Custom palette | **snapshot only** | `customPalette.snapshot` after system palette | full slice replace |
+ * | Canvas graph (topology) | **snapshot** in workflow slice | `activeWorkflow` in `workflow.current.snapshot` | `editor.*.delta` (broadcast to all tabs) |
+ * | Canvas viewport (pan/zoom) | **snapshot + event-sourcing** | `activeWorkflow.graph.viewport` in `workflow.current.snapshot` | `editor.viewport.delta` (broadcast to all tabs) |
+ * | Runtime / execution on graph | **snapshot + event-sourcing** | `runner.snapshot` + `executionFeed.snapshot` (+ `runner.checkpoints.snapshot`) | `runner.*` (`RuntimeRunnerEvent`) — **new events only** |
+ *
+ * **Reconnect sequence** (authoritative:
+ * `packages/server/src/bridge/emit-bootstrap.ts`):
+ * `session.state.snapshot` → `runner.snapshot` → `executionFeed.snapshot` →
+ * `runner.checkpoints.snapshot` → `toolConfig.snapshot` →
+ * `workflow.list.snapshot` → `workflow.current.snapshot` → `session.ready` →
+ * `langflower.config.snapshot` → (async) `langflower.models.catalog.snapshot` →
+ * `palette.snapshot` → `customPalette.snapshot`. Later workflow intents
+ * broadcast `workflow.*.snapshot`.
+ *
+ * **Runtime after reconnect:** hydrate the log / port state from
+ * `executionFeed.snapshot`, then append live `runner.output-emitted`,
+ * `runner.input-received`, `runner.done`, … — no replay of the full runner
+ * history on every mutation, only the dedicated feed snapshot plus new frames.
+ *
+ * Partials: {@link editorConfig} | {@link runnerConfig} |
+ * {@link bootstrapConfig} | {@link langflowerProjectConfig} |
+ * {@link paletteConfig} | {@link customPaletteConfig} |
+ * {@link workflowManagerConfig}.
+ */
+export declare const langflowerWsConfig: {
+    readonly transport: {
+        readonly path: "/ws";
+        readonly port: 4010;
+    };
+    readonly fromClientToServer: {
+        /**
+         * Serialize the session's in-memory active workflow to disk.
+         * Server builds the save payload from `session.activeWorkflow`.
+         */
+        readonly 'workflow.saveCurrent.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<WorkflowSaveCurrentPayload>;
+        /**
+         * Rename active workflow identity (name + id + `{id}.json`).
+         * Partial save: metadata is persisted immediately; dirty graph edits
+         * remain uncommitted until `workflow.saveCurrent.requested`.
+         */
+        readonly 'workflow.renameCurrent.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<WorkflowRenameCurrentPayload>;
+        /**
+         * Start an empty workflow in the session (dirty, not written to disk).
+         */
+        readonly 'workflow.create.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<WorkflowCreatePayload>;
+        /**
+         * Copy a persisted workflow to a new `{id}-copy.json` file and open it.
+         */
+        readonly 'workflow.copy.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<WorkflowCopyPayload>;
+        /**
+         * Load one workflow by `workflowId` from disk into the server session
+         * (bind-replay into editor).
+         */
+        readonly 'workflow.load.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<WorkflowLoadPayload>;
+        /**
+         * Refresh workflow catalog (metadata only, no graphs).
+         */
+        readonly 'workflow.list.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<Record<string, never>>;
+        /**
+         * Delete one persisted workflow by id.
+         */
+        readonly 'workflow.delete.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<WorkflowDeletePayload>;
+        /**
+         * Recompile project custom packs and refresh the custom registry.
+         *
+         * Server broadcasts `customPalette.snapshot` (`compiling`, then final).
+         */
+        readonly 'customPalette.update.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<Record<string, never>>;
+        /**
+         * Refresh the system palette catalog (no custom-node compile).
+         *
+         * Emits `palette.snapshot`. May broadcast to other connections.
+         */
+        readonly 'palette.reload.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<Record<string, never>>;
+        /**
+         * Settings Save — persist one scope (project or global), then
+         * broadcast {@link LangflowerConfigSnapshotPayload}. No parallel
+         * `settings.*` bus.
+         */
+        readonly 'langflower.config.save.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<LangflowerConfigSaveRequestedPayload>;
+        /**
+         * Settings → Bootstrap — force-reseed skeleton templates into the
+         * open project (workflows / skills / my-nodes / instructions).
+         * Never rewrites `langflower.jsonc`. Rejected while a run is active.
+         * Replies with {@link ProjectBootstrapResultPayload}; on success also
+         * broadcasts workflow / custom-palette snapshots.
+         */
+        readonly 'project.bootstrap.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<Record<string, never>>;
+        /**
+         * Run the **current session graph** (already in editor). Wires all
+         * edges, seeds open inputs, sets status `'running'`.
+         *
+         * Server calls {@link RuntimeRunnerApi.start}. Emits `runner.started`
+         * (`runId`) then port telemetry.
+         */
+        readonly 'runner.start.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<[initialPayload?: Readonly<Record<string, readonly import("@langflower/runtime").RuntimeSeedPortValue[]>> | undefined, runId?: import("@langflower/runtime").RunId | undefined]>;
+        /**
+         * Run-from-node — wire only the weakly connected cluster of `nodeId`.
+         *
+         * Server calls {@link RuntimeRunnerApi.startNode}. Emits
+         * `runner.startNode.started`.
+         */
+        readonly 'runner.startNode.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<[nodeId: import("@langflower/runtime").NodeId, initialPayload?: Readonly<Record<string, readonly import("@langflower/runtime").RuntimeSeedPortValue[]>> | undefined, runId?: import("@langflower/runtime").RunId | undefined]>;
+        /**
+         * Cancel active run (Stop). Unsubscribes wiring, status `'stopped'`.
+         *
+         * Server calls {@link RuntimeRunnerApi.interrupt} (`'cancel'`). Emits
+         * `runner.interrupted`.
+         */
+        readonly 'runner.interrupt.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<"cancel">;
+        /**
+         * Push a value into a node input via
+         * {@link RuntimeRunnerApi.pushIntoInput}.
+         *
+         * Used for canvas HITL gates (`inputsConfigs[].config.hitl`) and for
+         * soft Pause / Steer on the hidden LLM inventory port `steerControl`
+         * (docs ADR-032) — `{ kind: 'pause' | 'steer' | 'resume', … }`. One
+         * event targets one
+         * `nodeId` / `portId`. Multiple awaits may be open concurrently.
+         * Message name is historical; not limited to visible HITL chrome.
+         */
+        readonly 'runner.hitl.event': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<{
+            nodeId: import("@langflower/runtime").NodeId;
+            portId: string;
+            payload: unknown;
+        }>;
+        /**
+         * Allow / Deny for a runtime permission ask inside the tool loop
+         * (not a canvas HITL port — see `runner.permission.ask`).
+         */
+        readonly 'runner.permission.reply': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<RunnerPermissionReplyPayload>;
+        /**
+         * Clear the execution feed (work log). Server drops the runner event
+         * log and re-broadcasts an empty `executionFeed.snapshot`. No payload.
+         */
+        readonly 'runner.executionFeed.clear.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<{}>;
+        /**
+         * Continue from a durable checkpoint after Stop / process restart.
+         * Payload requires `runId` (picker-chosen entry; no latest-only omit).
+         */
+        readonly 'runner.resume.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<RunnerResumeRequestedPayload>;
+        /**
+         * Discard a durable checkpoint (corrupt / abandoned job).
+         */
+        readonly 'runner.checkpoint.discard.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<RunnerCheckpointDiscardRequestedPayload>;
+        /**
+         * Palette drop or explicit add-node intent — minimal
+         * {@link EditorAddNodeRequestedPayload}.
+         *
+         * UI sends node `type`, canvas `position`, and optional initial
+         * `params`, `inputs`, and `label`. Server owns `nodeId` assignment,
+         * default param/input filling, runtime materialization, graph insertion,
+         * and dirty marking when runner is not `'running'`.
+         *
+         * Emits `editor.addNode.delta` with added nodes or `[]` (broadcast).
+         */
+        readonly 'editor.addNode.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<EditorAddNodeRequestedPayload>;
+        /**
+         * Committed update for one existing node — unified
+         * {@link EditorUpdateNodeRequestedPayload}.
+         *
+         * Payload uses `nodeId` plus any combination of optional root-level
+         * `position`, `ui`, `params`, and `inputs`. Covers move, resize, label,
+         * panel params, inline params, and open input seed values. Server rejects
+         * payloads with no update fields and while the graph is locked.
+         *
+         * `ui` / `position` / panel `params` update the session document only
+         * (params never rebind the runtime mirror — they are next-run ctx seeds).
+         * `inputs` updates also rebind the runtime mirror while unlocked.
+         * Panel `params` apply even while `runnerStatus === 'running'`;
+         * `position` / `ui` / `inputs` return `[]` while locked.
+         *
+         * Emits `editor.updateNodes` with updated nodes or `[]` (broadcast).
+         */
+        readonly 'editor.updateNode.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<EditorUpdateNodeRequestedPayload>;
+        /**
+         * User connected two ports on the canvas.
+         *
+         * Server materializes runtime ports and calls
+         * {@link RuntimeEditorApi.addEdge}. Emits `editor.addEdge.delta`
+         * with added edges or `[]` (broadcast).
+         */
+        readonly 'editor.addEdge.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<EditorAddEdgeRequestedPayload>;
+        /**
+         * Clipboard paste batch — {@link EditorPasteRequestedPayload}.
+         *
+         * Client strips optimistic local clones then sends remappable
+         * `clientId`s. Server materializes nodes (honoring optional size on
+         * `position`) and edges in one dirty mark, then emits
+         * `editor.addNodes` then `editor.addEdges` (broadcast).
+         */
+        readonly 'editor.paste.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<EditorPasteRequestedPayload>;
+        /**
+         * User deleted an edge — payload is the canvas edge id.
+         */
+        readonly 'editor.removeEdge.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<string>;
+        /**
+         * User deleted a node — payload is the canvas node id.
+         */
+        readonly 'editor.removeNode.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<string>;
+        /**
+         * Canvas pan/zoom committed — shared session viewport slice.
+         *
+         * Does not lock with graph edits; server stores on session and
+         * broadcasts `editor.viewport.delta` to all tabs.
+         */
+        readonly 'editor.viewport.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<CanvasViewport>;
+        /**
+         * Divider positions changed — client sends on drag end.
+         *
+         * Server validates, updates session, broadcasts to all tabs, and
+         * persists to `langflower.jsonc`.
+         */
+        readonly 'editor.dividers.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<DividerPositions>;
+        /**
+         * Canvas selection changed — `nodeId` is the clicked node, or `null`
+         * to clear. Shared session state, like {@link CanvasViewport}: not
+         * locked with graph edits, not persisted to the workflow document.
+         *
+         * Server validates `nodeId` against the active graph, stores it on
+         * the session, and broadcasts `editor.nodeSelected` to all tabs.
+         */
+        readonly 'editor.selectNode.requested': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<EditorSelectNodeRequestedPayload>;
+    };
+    readonly fromServerToClient: {
+        /**
+         * Active workflow document and dirty/pristine state.
+         * Pushed after workflow manager intents (load/save/rename/delete).
+         */
+        readonly 'workflow.current.snapshot': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<WorkflowCurrentSnapshotPayload>;
+        /**
+         * Dirty/pristine flag only — broadcast after editor mutations without
+         * replacing the canvas graph (see `editor.*.delta`).
+         */
+        readonly 'workflow.currentStatus.snapshot': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<WorkflowCurrentStatusPayload>;
+        /**
+         * Workflow catalog (metadata only). Pushed on list intent and after
+         * save/delete when the on-disk catalog changes.
+         */
+        readonly 'workflow.list.snapshot': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<WorkflowListSnapshotPayload>;
+        /**
+         * Authoritative custom-node slice for the Custom palette section.
+         */
+        readonly 'customPalette.snapshot': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<CustomPaletteSnapshotPayload>;
+        /**
+         * Authoritative **system** catalog — outcome of
+         * `palette.reload.requested` or connect bootstrap.
+         */
+        readonly 'palette.snapshot': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<PaletteConfigPayload>;
+        /**
+         * Authoritative config — emitted per connection after `session.ready`
+         * and after Settings Save. Includes effective + layer slices.
+         */
+        readonly 'langflower.config.snapshot': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<LangflowerConfigSnapshotPayload>;
+        /**
+         * Authoritative live model catalogs for all configured providers.
+         * Server-pushed after {@link LangflowerConfigSnapshotPayload} on
+         * connect (async, non-blocking) and after Settings Save. Static
+         * jsonc models remain in config; UI merges both. No client refresh
+         * intent — server owns fetch.
+         */
+        readonly 'langflower.models.catalog.snapshot': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<LangflowerModelsCatalogSnapshotPayload>;
+        /**
+         * Outcome of `project.bootstrap.requested` (Result — expected failures
+         * are `ok: false`, not throws).
+         */
+        readonly 'project.bootstrap.result': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<ProjectBootstrapResultPayload>;
+        /**
+         * Slim session projection — emitted on **every** connect and reconnect,
+         * first in the bootstrap sequence (before domain snapshots and
+         * `session.ready`).
+         *
+         * Payload is only {@link SessionStateSnapshotPayload}: `version`,
+         * `langflowerConfig`, `dividerPositions`, `selectedNode`. Replace those
+         * slices from this event; hydrate workflows / runner / feed / viewport /
+         * tool config from their dedicated snapshot keys (see state-sync table
+         * on {@link langflowerWsConfig}).
+         */
+        readonly 'session.state.snapshot': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<SessionStateSnapshotPayload>;
+        /**
+         * Terminal marker: bootstrap sequence for this connection is complete.
+         * Client enables diagram interactions after this.
+         *
+         * Follows slim `session.state.snapshot` **and** the dedicated domain
+         * snapshots on the same connection (`runner.snapshot`,
+         * `executionFeed.snapshot`, `toolConfig.snapshot`,
+         * `workflow.*.snapshot`, …). `version` bumps when bootstrap semantics
+         * change.
+         */
+        readonly 'session.ready': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<SessionReadyPayload>;
+        /**
+         * Runner snapshot — run gate status (idle/running, runId, activeWorkflowId).
+         */
+        readonly 'runner.snapshot': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<RunnerSnapshotPayload>;
+        /**
+         * Execution feed snapshot — replay of `RuntimeRunnerEvent` frames.
+         * `null` when no run exists or the feed was cleared.
+         */
+        readonly 'executionFeed.snapshot': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<ExecutionFeedSnapshotPayload | null>;
+        /**
+         * Tool config snapshot — `.langflower/config.json` settings.
+         */
+        readonly 'toolConfig.snapshot': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<ToolConfigSnapshotPayload>;
+        /**
+         * {@link RuntimeRunnerApi.start} succeeded — payload is `runId`.
+         * Empty graph → instant `runner.done` and status `'idle'`.
+         */
+        readonly 'runner.started': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<false | import("@langflower/runtime").RunId>;
+        /**
+         * {@link RuntimeRunnerApi.startNode} succeeded — payload is `runId`.
+         */
+        readonly 'runner.startNode.started': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<false | import("@langflower/runtime").RunId>;
+        /**
+         * {@link RuntimeRunnerApi.resume} succeeded — payload is `runId`.
+         */
+        readonly 'runner.resume.started': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<false | import("@langflower/runtime").RunId>;
+        /**
+         * Resume rejected — corrupt / stale / missing checkpoint, or busy.
+         */
+        readonly 'runner.resume.failed': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<RunnerResumeFailedPayload>;
+        /**
+         * {@link RuntimeRunnerApi.interrupt} applied — payload is reason
+         * (today only `'cancel'`).
+         */
+        readonly 'runner.interrupted': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<"cancel">;
+        /**
+         * Output port signal — {@link RuntimeRunnerEvent} with
+         * `kind === 'output-emitted'`.
+         */
+        readonly 'runner.output-emitted': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<RuntimeRunnerEvent>;
+        /**
+         * Input port signal — {@link RuntimeRunnerEvent} with
+         * `kind === 'input-received'` (wires, seeds).
+         */
+        readonly 'runner.input-received': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<RuntimeRunnerEvent>;
+        /**
+         * Natural run end — {@link RuntimeRunnerEvent} with `kind === 'done'`
+         * (empty graph, {@link RuntimeNode.stopsRun}, or forced complete).
+         * Runner status becomes `'idle'`.
+         */
+        readonly 'runner.done': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<RuntimeRunnerEvent>;
+        /**
+         * Runtime permission ask for a gated harness tool call (feed + composer).
+         * Stays inside the internal tool loop — not a graph HITL edge.
+         */
+        readonly 'runner.permission.ask': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<RunnerPermissionAskPayload>;
+        /**
+         * Resumable checkpoints for the active workflow (bootstrap + after
+         * Stop / discard / complete).
+         */
+        readonly 'runner.checkpoints.snapshot': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<RunnerCheckpointsSnapshotPayload>;
+        /**
+         * One checkpoint write succeeded (stage boundary or Stop).
+         */
+        readonly 'runner.checkpointed': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<WorkflowCheckpointSummary>;
+        /** Added nodes — client applies delta. Empty array = no change applied. */
+        readonly 'editor.addNodes': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<WorkflowNodePersisted[]>;
+        /** Updated nodes — client applies delta. Empty array = no change applied. */
+        readonly 'editor.updateNodes': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<WorkflowNodePersisted[]>;
+        /** Added edges — client merges / remaps ids. Empty array = no change applied. */
+        readonly 'editor.addEdges': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<RuntimeEdge[]>;
+        /** Removed nodes — client deletes by `id`. Empty array = no change applied. */
+        readonly 'editor.deleteNodes': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<WorkflowNodePersisted[]>;
+        /** Removed edges (incl. cascade) — client deletes by `id`. Empty array = no change applied. */
+        readonly 'editor.deleteEdges': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<RuntimeEdge[]>;
+        /** Shared canvas viewport — client applies via ng-diagram `setViewport`. */
+        readonly 'editor.viewport.delta': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<CanvasViewport>;
+        /** Divider positions — broadcast to all tabs after server persistence. */
+        readonly 'editor.dividers.snapshot': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<DividerPositions>;
+        /**
+         * Authoritative selected node — full {@link WorkflowNodePersisted}
+         * plus its {@link PaletteNodeDefinition} (for Inspector panel
+         * `uiSchema` fields), or `node: null` when nothing is selected.
+         *
+         * Broadcast to all tabs after `editor.selectNode.requested`, after an
+         * `editor.updateNode.requested` that touches the selected node, and
+         * when the selection is invalidated (node removed, workflow switched).
+         * Client renders the Inspector directly from this payload — no local
+         * lookup against other node lists.
+         */
+        readonly 'editor.nodeSelected': import("@langflower/websocket-bridge").WsBridgeMessageDefinition<EditorSelectedNodePayload>;
+    };
+};
+//# sourceMappingURL=langflower-bus-config.d.ts.map

package/vendor/shared/dist/langflower-bus-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"langflower-bus-config.d.ts","sourceRoot":"","sources":["../src/langflower-bus-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,WAAW,EAGX,kBAAkB,EAClB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EACX,gBAAgB,EAChB,4BAA4B,EAC5B,qBAAqB,EACrB,2BAA2B,EAC3B,yBAAyB,EACzB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EACX,oCAAoC,EACpC,+BAA+B,EAC/B,sCAAsC,EACtC,0BAA0B,EAC1B,4BAA4B,EAC5B,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EACX,uCAAuC,EACvC,gCAAgC,EAChC,yBAAyB,EACzB,4BAA4B,EAC5B,yBAAyB,EACzB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EACX,6BAA6B,EAC7B,6BAA6B,EAC7B,2BAA2B,EAC3B,yBAAyB,EACzB,gCAAgC,EAChC,gCAAgC,EAChC,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,sCAAsC,CAAC;AACzF,OAAO,KAAK,EACX,oBAAoB,EAEpB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,yCAAyC,CAAC;AAC7F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,KAAK,EACX,cAAc,EACd,8BAA8B,EAC9B,4BAA4B,EAC5B,mBAAmB,EACnB,qBAAqB,EACrB,qBAAqB,EACrB,2BAA2B,EAC3B,mBAAmB,EACnB,qBAAqB,EACrB,4BAA4B,EAC5B,0BAA0B,EAC1B,MAAM,gCAAgC,CAAC;AAqkBxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,kBAAkB;;;;;;QApH7B;;;WAGG;;QAGH;;;;WAIG;;QAIH;;WAEG;;QAGH;;WAEG;;QAGH;;;WAGG;;QAGH;;WAEG;;QAGH;;WAEG;;QA1FH;;;;WAIG;;QA5BH;;;;WAIG;;QAzDH;;;;WAIG;;QAIH;;;;;;WAMG;;QAlOH;;;;;;WAMG;;QAIH;;;;;WAKG;;QAIH;;;;;WAKG;;QAIH;;;;;;;;;;WAUG;;;;;;QAIH;;;WAGG;;QAGH;;;WAGG;;QAGH;;;WAGG;;QAGH;;WAEG;;QA/MH;;;;;;;;;;WAUG;;QAGH;;;;;;;;;;;;;;;;WAgBG;;QAIH;;;;;;WAMG;;QAGH;;;;;;;WAOG;;QAGH;;WAEG;;QAGH;;WAEG;;QAGH;;;;;WAKG;;QAGH;;;;;WAKG;;QAGH;;;;;;;WAOG;;;;QA2bH;;;WAGG;;QAGH;;;WAGG;;QAIH;;;WAGG;;QAtGH;;WAEG;;QA1BH;;;WAGG;;QA9CH;;;WAGG;;QAIH;;;;;;WAMG;;QAIH;;;WAGG;;QA7FH;;;;;;;;;;WAUG;;QAGH;;;;;;;;;WASG;;QAGH;;WAEG;;QAGH;;;WAGG;;QAIH;;WAEG;;QAjIH;;;WAGG;;QAGH;;WAEG;;QAIH;;WAEG;;QAIH;;WAEG;;QAGH;;;WAGG;;QAIH;;;WAGG;;QAGH;;;WAGG;;QAGH;;;;WAIG;;QAGH;;;WAGG;;QAGH;;;WAGG;;QAIH;;WAEG;;QA1LH,2EAA2E;;QAG3E,6EAA6E;;QAG7E,iFAAiF;;QAGjF,+EAA+E;;QAG/E,+FAA+F;;QAG/F,4EAA4E;;QAG5E,0EAA0E;;QAG1E;;;;;;;;;;WAUG;;;CAsf8B,CAAC"}