langflower 0.1.0 → 0.1.2

package/vendor/server/dist/workflow/create-empty-workflow-in-session.test.js

@@ -1,54 +0,0 @@
-import { resolveWorkflowNodeDefinition } from '@langflower/common-nodes';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { LangflowerSession } from '../session/langflower-session.js';
-import { createEmptyWorkflowInSession } from './create-empty-workflow-in-session.js';
-import { WorkflowService } from './workflow.service.js';
-const resolveDefinition = (node) => {
-    const definition = resolveWorkflowNodeDefinition({
-        type: node.type,
-        data: { params: node.params },
-    });
-    if (definition === undefined) {
-        return undefined;
-    }
-    return definition;
-};
-describe('createEmptyWorkflowInSession', () => {
-    let projectDir;
-    let service;
-    beforeEach(async () => {
-        projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lf-wf-create-'));
-        service = new WorkflowService(projectDir, resolveDefinition);
-    });
-    afterEach(async () => {
-        await fs.rm(projectDir, { recursive: true, force: true });
-    });
-    it('opens an empty dirty Untitled workflow without writing disk', async () => {
-        const session = new LangflowerSession();
-        const ok = await createEmptyWorkflowInSession(session, service, projectDir);
-        expect(ok).toBe(true);
-        expect(session.activeWorkflow?.metadata.name).toBe('Untitled');
-        expect(session.activeWorkflow?.metadata.id).toBe('untitled');
-        expect(session.activeWorkflow?.graph.nodes).toEqual([]);
-        expect(session.currentStatus).toBe('dirty');
-        expect(await service.exists('untitled')).toBe(false);
-    });
-    it('allocates a unique id when untitled already exists', async () => {
-        await service.save({
-            metadata: {
-                id: 'untitled',
-                name: 'Untitled',
-                createdAt: '2026-06-17T00:00:00.000Z',
-                updatedAt: '2026-06-17T00:00:00.000Z',
-            },
-            graph: { viewport: { x: 0, y: 0, scale: 1 }, nodes: [], edges: [] },
-        });
-        const session = new LangflowerSession();
-        await createEmptyWorkflowInSession(session, service, projectDir);
-        expect(session.activeWorkflow?.metadata.id).toBe('untitled-2');
-    });
-});
-//# sourceMappingURL=create-empty-workflow-in-session.test.js.map

package/vendor/server/dist/workflow/load-workflow-into-session.d.ts

@@ -1,15 +0,0 @@
-import type { WorkflowLoadFailedCode } from '@langflower/shared/langflower.js';
-import type { LangflowerSession } from '../session/langflower-session.js';
-import type { ResolveNodeDefinition } from './workflow-document.js';
-import type { WorkflowService } from './workflow.service.js';
-export type LoadWorkflowResult = {
-    readonly ok: true;
-    readonly repaired: boolean;
-    readonly droppedNodeIds: readonly string[];
-    readonly droppedEdgeIds: readonly string[];
-} | {
-    readonly ok: false;
-    readonly code: WorkflowLoadFailedCode;
-    readonly message: string;
-};
-export declare const loadWorkflowIntoSession: (session: LangflowerSession, workflowService: WorkflowService, projectDir: string, workflowId: string, resolveDefinition: ResolveNodeDefinition) => Promise<LoadWorkflowResult>;

package/vendor/server/dist/workflow/load-workflow-into-session.js

@@ -1,43 +0,0 @@
-import { activateWorkflowInSession, } from './activate-workflow-in-session.js';
-const uniqueIds = (ids) => [
-    ...new Set(ids),
-];
-export const loadWorkflowIntoSession = async (session, workflowService, projectDir, workflowId, resolveDefinition) => {
-    if (session.isGraphLocked()) {
-        return {
-            ok: false,
-            code: 'GRAPH_LOCKED',
-            message: 'Cannot load workflow while the graph is locked',
-        };
-    }
-    const result = await workflowService.load({ workflowId });
-    if (!result.ok) {
-        const code = result.code === 'INVALID_GRAPH' ? 'INVALID_GRAPH' : 'NOT_FOUND';
-        return {
-            ok: false,
-            code,
-            message: result.message,
-        };
-    }
-    const activated = activateWorkflowInSession(session, projectDir, result.document, { dirty: result.repaired }, resolveDefinition);
-    if (!activated.ok) {
-        return activated;
-    }
-    const droppedNodeIds = uniqueIds([
-        ...result.droppedNodeIds,
-        ...activated.droppedNodeIds,
-    ]);
-    const droppedEdgeIds = uniqueIds([
-        ...result.droppedEdgeIds,
-        ...activated.droppedEdgeIds,
-    ]);
-    const repaired = result.repaired ||
-        droppedNodeIds.length > 0 ||
-        droppedEdgeIds.length > 0;
-    return {
-        ok: true,
-        repaired,
-        droppedNodeIds,
-        droppedEdgeIds,
-    };
-};

package/vendor/server/dist/workflow/rename-active-workflow.d.ts

@@ -1,14 +0,0 @@
-import type { WorkflowLoadedPayload } from '@langflower/shared/langflower.js';
-import type { LangflowerSession } from '../session/langflower-session.js';
-import type { WorkflowService } from './workflow.service.js';
-export type RenameActiveWorkflowResult = {
-    readonly document: WorkflowLoadedPayload;
-    readonly catalogChanged: boolean;
-};
-/**
- * Partial-save rename: updates session identity immediately; when a file for
- * the previous stem exists, rewrites `{nextId}.json` with on-disk graph (not
- * the dirty in-memory graph) and removes the old file. Dirty/pristine is
- * preserved.
- */
-export declare const renameActiveWorkflow: (session: LangflowerSession, workflowService: WorkflowService, name: string) => Promise<RenameActiveWorkflowResult | null>;

package/vendor/server/dist/workflow/rename-active-workflow.js

@@ -1,60 +0,0 @@
-import { slugifyWorkflowId } from './workflow-id.js';
-/**
- * Partial-save rename: updates session identity immediately; when a file for
- * the previous stem exists, rewrites `{nextId}.json` with on-disk graph (not
- * the dirty in-memory graph) and removes the old file. Dirty/pristine is
- * preserved.
- */
-export const renameActiveWorkflow = async (session, workflowService, name) => {
-    const active = session.activeWorkflow;
-    if (active === null) {
-        return null;
-    }
-    const trimmed = name.trim();
-    if (trimmed.length === 0 || trimmed === active.metadata.name) {
-        return null;
-    }
-    const nextWorkflowId = slugifyWorkflowId(trimmed);
-    const previousWorkflowId = active.workflowId;
-    if (nextWorkflowId !== previousWorkflowId &&
-        (await workflowService.exists(nextWorkflowId))) {
-        return null;
-    }
-    const previousStatus = session.currentStatus;
-    const diskLoad = await workflowService.load({
-        workflowId: previousWorkflowId,
-    });
-    let catalogChanged = false;
-    if (diskLoad.ok) {
-        const now = new Date().toISOString();
-        const saveResult = await workflowService.save({
-            workflowId: nextWorkflowId,
-            metadata: {
-                ...diskLoad.document.metadata,
-                name: trimmed,
-                updatedAt: now,
-            },
-            graph: diskLoad.document.graph,
-            ...(nextWorkflowId !== previousWorkflowId
-                ? { previousWorkflowId }
-                : {}),
-        });
-        if (!saveResult.ok) {
-            return null;
-        }
-        catalogChanged = true;
-    }
-    const nextDocument = {
-        workflowId: nextWorkflowId,
-        metadata: {
-            ...active.metadata,
-            name: trimmed,
-        },
-        graph: active.graph,
-    };
-    session.activeWorkflow = nextDocument;
-    session.activeWorkflowId = nextWorkflowId;
-    session.pendingPreviousId = undefined;
-    session.currentStatus = previousStatus;
-    return { document: nextDocument, catalogChanged };
-};

package/vendor/server/dist/workflow/rename-active-workflow.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=rename-active-workflow.test.d.ts.map

package/vendor/server/dist/workflow/rename-active-workflow.test.js

@@ -1,111 +0,0 @@
-import { resolveWorkflowNodeDefinition } from '@langflower/common-nodes';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { LangflowerSession } from '../session/langflower-session.js';
-import { renameActiveWorkflow } from './rename-active-workflow.js';
-import { WorkflowService } from './workflow.service.js';
-const resolveDefinition = (node) => {
-    const definition = resolveWorkflowNodeDefinition({
-        type: node.type,
-        data: { params: node.params },
-    });
-    if (definition === undefined) {
-        return undefined;
-    }
-    return definition;
-};
-const emptyDocument = (id, name, inputsValue) => ({
-    metadata: {
-        id,
-        name,
-        createdAt: '2026-06-17T00:00:00.000Z',
-        updatedAt: '2026-06-17T00:00:00.000Z',
-    },
-    graph: {
-        viewport: { x: 0, y: 0, scale: 1 },
-        nodes: inputsValue === undefined
-            ? []
-            : [
-                {
-                    id: 'string-1',
-                    type: 'common-string',
-                    params: {},
-                    inputs: { value: inputsValue },
-                    ui: {
-                        position: { x: 0, y: 0 },
-                        label: 'String',
-                    },
-                },
-            ],
-        edges: [],
-    },
-});
-describe('renameActiveWorkflow', () => {
-    let projectDir;
-    let service;
-    beforeEach(async () => {
-        projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lf-wf-rename-'));
-        service = new WorkflowService(projectDir, resolveDefinition);
-    });
-    afterEach(async () => {
-        await fs.rm(projectDir, { recursive: true, force: true });
-    });
-    it('returns null when no active workflow', async () => {
-        const session = new LangflowerSession();
-        expect(await renameActiveWorkflow(session, service, 'Next')).toBeNull();
-    });
-    it('renames identity on disk without committing dirty graph edits', async () => {
-        await service.save(emptyDocument('demo', 'Demo', 'on-disk'));
-        const session = new LangflowerSession();
-        session.activeWorkflow = emptyDocument('demo', 'Demo', 'in-memory');
-        session.activeWorkflowId = 'demo';
-        session.markDirty();
-        const renamed = await renameActiveWorkflow(session, service, 'Renamed Flow');
-        expect(renamed?.document.metadata.name).toBe('Renamed Flow');
-        expect(renamed?.document.metadata.id).toBe('renamed-flow');
-        expect(renamed?.catalogChanged).toBe(true);
-        expect(session.currentStatus).toBe('dirty');
-        expect(session.pendingPreviousId).toBeUndefined();
-        expect(session.activeWorkflow?.graph.nodes[0]?.inputs.value).toBe('in-memory');
-        expect(await service.exists('demo')).toBe(false);
-        const disk = await service.load({ workflowId: 'renamed-flow' });
-        expect(disk.ok).toBe(true);
-        if (disk.ok) {
-            expect(disk.document.metadata.name).toBe('Renamed Flow');
-            expect(disk.document.graph.nodes[0]?.inputs.value).toBe('on-disk');
-        }
-    });
-    it('updates session only when file was never saved', async () => {
-        const session = new LangflowerSession();
-        session.activeWorkflow = emptyDocument('untitled', 'Untitled');
-        session.activeWorkflowId = 'untitled';
-        session.markDirty();
-        const renamed = await renameActiveWorkflow(session, service, 'Fresh Name');
-        expect(renamed?.catalogChanged).toBe(false);
-        expect(session.activeWorkflow?.metadata.id).toBe('fresh-name');
-        expect(session.currentStatus).toBe('dirty');
-        expect(await service.exists('fresh-name')).toBe(false);
-    });
-    it('preserves pristine when renaming a saved workflow', async () => {
-        await service.save(emptyDocument('demo', 'Demo'));
-        const session = new LangflowerSession();
-        session.activeWorkflow = emptyDocument('demo', 'Demo');
-        session.activeWorkflowId = 'demo';
-        const renamed = await renameActiveWorkflow(session, service, 'Renamed Flow');
-        expect(renamed?.catalogChanged).toBe(true);
-        expect(session.currentStatus).toBe('pristine');
-    });
-    it('ignores blank names and target id collisions', async () => {
-        await service.save(emptyDocument('demo', 'Demo'));
-        await service.save(emptyDocument('taken', 'Taken'));
-        const session = new LangflowerSession();
-        session.activeWorkflow = emptyDocument('demo', 'Demo');
-        session.activeWorkflowId = 'demo';
-        expect(await renameActiveWorkflow(session, service, '   ')).toBeNull();
-        expect(await renameActiveWorkflow(session, service, 'Taken')).toBeNull();
-        expect(session.activeWorkflow?.metadata.id).toBe('demo');
-    });
-});
-//# sourceMappingURL=rename-active-workflow.test.js.map

package/vendor/server/dist/workflow/repair-workflow-graph.d.ts

@@ -1,12 +0,0 @@
-import type { WorkflowPersistedGraph } from '@langflower/shared/langflower.js';
-import type { ResolveNodeDefinition } from './workflow-document.js';
-export type WorkflowGraphRepairResult = {
-    readonly graph: WorkflowPersistedGraph;
-    readonly droppedNodeIds: readonly string[];
-    readonly droppedEdgeIds: readonly string[];
-};
-/**
- * Strip unknown node types and edges that reference missing nodes or ports.
- * No rename / rewrite heuristics — keep only what the catalog can bind.
- */
-export declare const repairWorkflowGraph: (graph: WorkflowPersistedGraph, resolveDefinition: ResolveNodeDefinition) => WorkflowGraphRepairResult;

package/vendor/server/dist/workflow/repair-workflow-graph.js

@@ -1,62 +0,0 @@
-const definitionHasOutputPort = (definition, portId) => {
-    if (Object.hasOwn(definition.bypassPorts, portId)) {
-        return true;
-    }
-    return definition.outputsConfigs.some((config) => config.portId === portId);
-};
-const definitionHasInputPort = (definition, portId) => {
-    if (Object.hasOwn(definition.bypassPorts, portId)) {
-        return true;
-    }
-    return definition.inputsConfigs.some((config) => config.portId === portId);
-};
-/**
- * Strip unknown node types and edges that reference missing nodes or ports.
- * No rename / rewrite heuristics — keep only what the catalog can bind.
- */
-export const repairWorkflowGraph = (graph, resolveDefinition) => {
-    const droppedNodeIds = [];
-    const keptNodes = [];
-    const definitionByNodeId = new Map();
-    for (const node of graph.nodes) {
-        const definition = resolveDefinition(node);
-        if (definition === undefined) {
-            droppedNodeIds.push(node.id);
-            continue;
-        }
-        keptNodes.push(node);
-        definitionByNodeId.set(node.id, definition);
-    }
-    const keptNodeIds = new Set(keptNodes.map((node) => node.id));
-    const droppedEdgeIds = [];
-    const keptEdges = graph.edges.filter((edge) => {
-        if (!keptNodeIds.has(edge.fromNodeId) ||
-            !keptNodeIds.has(edge.toNodeId)) {
-            droppedEdgeIds.push(edge.edgeId);
-            return false;
-        }
-        const fromDefinition = definitionByNodeId.get(edge.fromNodeId);
-        const toDefinition = definitionByNodeId.get(edge.toNodeId);
-        if (fromDefinition === undefined || toDefinition === undefined) {
-            droppedEdgeIds.push(edge.edgeId);
-            return false;
-        }
-        const [fromPortId] = edge.fromPort;
-        const [toPortId] = edge.toPort;
-        if (!definitionHasOutputPort(fromDefinition, fromPortId) ||
-            !definitionHasInputPort(toDefinition, toPortId)) {
-            droppedEdgeIds.push(edge.edgeId);
-            return false;
-        }
-        return true;
-    });
-    return {
-        graph: {
-            viewport: graph.viewport,
-            nodes: keptNodes,
-            edges: keptEdges,
-        },
-        droppedNodeIds,
-        droppedEdgeIds,
-    };
-};

package/vendor/server/dist/workflow/repro-bypass.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=repro-bypass.test.d.ts.map

package/vendor/server/dist/workflow/repro-bypass.test.js

@@ -1,63 +0,0 @@
-import { resolveWorkflowNodeDefinition } from '@langflower/common-nodes';
-import os from 'node:os';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { LangflowerSession } from '../session/langflower-session.js';
-import { applyEditorAddEdge, applyEditorAddNode, } from './apply-editor-mutation.js';
-const resolveDefinition = (node) => {
-    const definition = resolveWorkflowNodeDefinition({
-        type: node.type,
-        data: { params: node.params },
-    });
-    return definition;
-};
-const constantNode = () => ({
-    type: 'common-string',
-    params: { value: 'x' },
-    inputs: {},
-    ui: { position: { x: 0, y: 0 } },
-});
-const routerNode = () => ({
-    type: 'common-router',
-    params: {},
-    inputs: {},
-    ui: { position: { x: 240, y: 0 } },
-});
-function seed(session) {
-    const document = {
-        metadata: { id: 't', name: 't', createdAt: '', updatedAt: '' },
-        graph: { viewport: { x: 0, y: 0, scale: 1 }, nodes: [], edges: [] },
-    };
-    session.activeWorkflow = document;
-    session.activeWorkflowId = 't';
-}
-let projectDir;
-describe('repro live addNode path', () => {
-    beforeEach(async () => {
-        projectDir = await os.tmpdir();
-    });
-    afterEach(() => { });
-    it('adds slot 0 then slot 1 via applyEditorAddNode', () => {
-        const session = new LangflowerSession();
-        seed(session);
-        const c = applyEditorAddNode(session, projectDir, { type: 'common-string', position: { x: 0, y: 0 }, params: { value: 'x' } }, resolveDefinition);
-        const r = applyEditorAddNode(session, projectDir, { type: 'common-router', position: { x: 240, y: 0 } }, resolveDefinition);
-        console.log('NODES', c[0]?.id, r[0]?.id);
-        const first = applyEditorAddEdge(session, {
-            fromNodeId: c[0].id,
-            fromPort: ['value', 0],
-            toNodeId: r[0].id,
-            toPort: ['ch', 0],
-        });
-        console.log('FIRST', JSON.stringify(first));
-        const second = applyEditorAddEdge(session, {
-            fromNodeId: c[0].id,
-            fromPort: ['value', 0],
-            toNodeId: r[0].id,
-            toPort: ['ch', 1],
-        });
-        console.log('SECOND', JSON.stringify(second));
-        expect(first.added.length).toBe(1);
-        expect(second.added.length).toBe(1);
-    });
-});
-//# sourceMappingURL=repro-bypass.test.js.map

package/vendor/server/dist/workflow/workflow-document.d.ts

@@ -1,21 +0,0 @@
-import type { ReactiveNodeDefinition } from '@langflower/node-sdk';
-import type { WorkflowLoadedPayload, WorkflowMetadata, WorkflowNodePersisted, WorkflowPersistedGraph } from '@langflower/shared/langflower.js';
-/** On-disk shape — no `workflowId` (that is the filename stem). */
-export type WorkflowDiskDocument = {
-    readonly metadata: WorkflowMetadata;
-    readonly graph: WorkflowPersistedGraph;
-};
-/**
- * Parse on-disk JSON `{ metadata, graph }`. Legacy `metadata.id` is ignored.
- * Callers attach `workflowId` from the filename stem.
- */
-export declare const parseWorkflowDocument: (raw: unknown) => WorkflowDiskDocument;
-export type ResolveNodeDefinition = {
-    (node: Pick<WorkflowNodePersisted, 'type' | 'params'>): ReactiveNodeDefinition | undefined;
-};
-export declare const validateWorkflowStructure: (document: Pick<WorkflowLoadedPayload, "graph">, resolveDefinition: ResolveNodeDefinition) => {
-    readonly ok: true;
-} | {
-    readonly ok: false;
-    readonly message: string;
-};

package/vendor/server/dist/workflow/workflow-document.js

@@ -1,58 +0,0 @@
-const isRecord = (value) => typeof value === 'object' && value !== null;
-const parseMetadata = (raw) => {
-    if (!isRecord(raw)) {
-        throw new Error('Workflow metadata must be an object');
-    }
-    const name = raw['name'];
-    const createdAt = raw['createdAt'];
-    const updatedAt = raw['updatedAt'];
-    const description = raw['description'];
-    if (typeof name !== 'string') {
-        throw new Error('Workflow metadata.name must be a string');
-    }
-    if (typeof createdAt !== 'string' || typeof updatedAt !== 'string') {
-        throw new Error('Workflow metadata timestamps must be strings');
-    }
-    return {
-        name,
-        ...(typeof description === 'string' ? { description } : {}),
-        createdAt,
-        updatedAt,
-    };
-};
-/**
- * Parse on-disk JSON `{ metadata, graph }`. Legacy `metadata.id` is ignored.
- * Callers attach `workflowId` from the filename stem.
- */
-export const parseWorkflowDocument = (raw) => {
-    if (!isRecord(raw)) {
-        throw new Error('Workflow document must contain metadata and graph');
-    }
-    if (!isRecord(raw['graph'])) {
-        throw new Error('Workflow document must contain metadata and graph');
-    }
-    return {
-        metadata: parseMetadata(raw['metadata']),
-        graph: raw['graph'],
-    };
-};
-export const validateWorkflowStructure = (document, resolveDefinition) => {
-    const nodeIds = new Set(document.graph.nodes.map((node) => node.id));
-    for (const node of document.graph.nodes) {
-        if (resolveDefinition(node) === undefined) {
-            return {
-                ok: false,
-                message: `Unknown node type: ${node.type}`,
-            };
-        }
-    }
-    for (const edge of document.graph.edges) {
-        if (!nodeIds.has(edge.fromNodeId) || !nodeIds.has(edge.toNodeId)) {
-            return {
-                ok: false,
-                message: `Edge ${edge.edgeId} references missing node`,
-            };
-        }
-    }
-    return { ok: true };
-};

package/vendor/server/dist/workflow/workflow-id.d.ts

@@ -1,2 +0,0 @@
-export declare const slugifyWorkflowId: (name: string) => string;
-export declare const allocateWorkflowId: (base: string, existingIds: ReadonlySet<string> | readonly string[]) => string;

package/vendor/server/dist/workflow/workflow-id.js

@@ -1,19 +0,0 @@
-export const slugifyWorkflowId = (name) => {
-    const slug = name
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '');
-    return slug.length > 0 ? slug : 'workflow';
-};
-export const allocateWorkflowId = (base, existingIds) => {
-    const taken = existingIds instanceof Set ? existingIds : new Set(existingIds);
-    if (!taken.has(base)) {
-        return base;
-    }
-    let suffix = 2;
-    while (taken.has(`${base}-${suffix}`)) {
-        suffix += 1;
-    }
-    return `${base}-${suffix}`;
-};

package/vendor/server/dist/workflow/workflow-id.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=workflow-id.test.d.ts.map

package/vendor/server/dist/workflow/workflow-id.test.js

@@ -1,23 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { allocateWorkflowId, slugifyWorkflowId } from './workflow-id.js';
-describe('slugifyWorkflowId', () => {
-    it('slugifies display names', () => {
-        expect(slugifyWorkflowId('Renamed Flow')).toBe('renamed-flow');
-    });
-    it('falls back when empty', () => {
-        expect(slugifyWorkflowId('   ')).toBe('workflow');
-    });
-});
-describe('allocateWorkflowId', () => {
-    it('returns base when free', () => {
-        expect(allocateWorkflowId('untitled', [])).toBe('untitled');
-    });
-    it('appends numeric suffix on collision', () => {
-        expect(allocateWorkflowId('example-copy', ['example-copy'])).toBe('example-copy-2');
-        expect(allocateWorkflowId('example-copy', [
-            'example-copy',
-            'example-copy-2',
-        ])).toBe('example-copy-3');
-    });
-});
-//# sourceMappingURL=workflow-id.test.js.map

package/vendor/server/dist/workflow/workflow-persisted-inputs.d.ts

@@ -1,13 +0,0 @@
-import type { ReactiveNodeDefinition } from '@langflower/node-sdk';
-import type { WorkflowLoadedPayload } from '@langflower/shared/langflower.js';
-import type { ResolveNodeDefinition } from './workflow-document.js';
-/**
- * Keep only persistable overrides: visible UI field and value !== current
- * definition defaultValue.
- */
-export declare const prunePersistedInputs: (inputs: Readonly<Record<string, unknown>>, definition: ReactiveNodeDefinition) => Readonly<Record<string, unknown>>;
-/**
- * Strip non-persistable input keys from every node (unknown ports, hidden /
- * wire-only, default-equal). Structural validate stays separate.
- */
-export declare const normalizeWorkflowDocumentInputs: (document: WorkflowLoadedPayload, resolveDefinition: ResolveNodeDefinition) => WorkflowLoadedPayload;

package/vendor/server/dist/workflow/workflow-persisted-inputs.js

@@ -1,71 +0,0 @@
-/**
- * Persisted `node.inputs` hold visible UI overrides only (ADR-028).
- * Wire-only / preview ports and values equal to the current definition
- * `defaultValue` must not be written to disk. Hidden ports with an
- * editable `inline` still persist (Chat Input `message`).
- */
-const valuesEqual = (left, right) => JSON.stringify(left) === JSON.stringify(right);
-const isPreviewInline = (inline) => {
-    if (inline === 'preview' ||
-        inline === 'preview-markdown' ||
-        inline === 'preview-code') {
-        return true;
-    }
-    if (typeof inline === 'object' && inline !== null && 'type' in inline) {
-        const type = inline.type;
-        return (type === 'preview' ||
-            type === 'preview-markdown' ||
-            type === 'preview-code');
-    }
-    return false;
-};
-/** Editable inline field (canvas / inspector), including hidden+inline. */
-const hasVisibleUiInputField = (config) => config.inline !== undefined && !isPreviewInline(config.inline);
-/**
- * Keep only persistable overrides: visible UI field and value !== current
- * definition defaultValue.
- */
-export const prunePersistedInputs = (inputs, definition) => {
-    const next = {};
-    for (const [portId, value] of Object.entries(inputs)) {
-        const config = definition.inputsConfigs.find((entry) => entry.portId === portId);
-        if (config === undefined || typeof config.portId !== 'string') {
-            continue;
-        }
-        if (!hasVisibleUiInputField(config)) {
-            continue;
-        }
-        if (typeof value === 'string' && value.trim() === '') {
-            continue;
-        }
-        if (config.defaultValue !== undefined &&
-            valuesEqual(value, config.defaultValue)) {
-            continue;
-        }
-        next[portId] = value;
-    }
-    return next;
-};
-/**
- * Strip non-persistable input keys from every node (unknown ports, hidden /
- * wire-only, default-equal). Structural validate stays separate.
- */
-export const normalizeWorkflowDocumentInputs = (document, resolveDefinition) => ({
-    ...document,
-    graph: {
-        ...document.graph,
-        nodes: document.graph.nodes.map((node) => {
-            const definition = resolveDefinition(node);
-            if (definition === undefined) {
-                return node;
-            }
-            const inputs = prunePersistedInputs(node.inputs, definition);
-            if (Object.keys(inputs).length ===
-                Object.keys(node.inputs).length &&
-                Object.keys(inputs).every((key) => valuesEqual(inputs[key], node.inputs[key]))) {
-                return node;
-            }
-            return { ...node, inputs };
-        }),
-    },
-});