langflower 0.1.0 → 0.1.2

package/vendor/server/dist/workflow/apply-editor-mutation.test.js

@@ -1,397 +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 { applyEditorAddEdge, applyEditorAddNode, applyEditorPaste, applyEditorRemoveEdge, applyEditorRemoveNode, applyEditorUpdateNode, bindWorkflowToSessionEditor, normalizeEditorUpdateNodePayload, } from './apply-editor-mutation.js';
-const resolveDefinition = (node) => {
-    const definition = resolveWorkflowNodeDefinition({
-        type: node.type,
-        data: { params: node.params },
-    });
-    if (definition === undefined) {
-        return undefined;
-    }
-    return definition;
-};
-const stringNode = (id, value = 'hello') => ({
-    id,
-    type: 'common-string',
-    params: {},
-    inputs: { value },
-    ui: { position: { x: 0, y: 0 } },
-});
-const previewNode = (id) => ({
-    id,
-    type: 'common-preview',
-    params: {},
-    inputs: {},
-    ui: { position: { x: 240, y: 0 } },
-});
-const numberNode = (id) => ({
-    id,
-    type: 'common-number',
-    params: {},
-    inputs: { value: 0 },
-    ui: { position: { x: 480, y: 0 } },
-});
-const delayNode = (id) => ({
-    id,
-    type: 'common-delay',
-    params: {},
-    inputs: { delay: 0 },
-    ui: { position: { x: 480, y: 0 } },
-});
-function seedActiveWorkflow(session, nodes, edges = []) {
-    const document = {
-        metadata: {
-            id: 'test',
-            name: 'test',
-            createdAt: '2026-06-25T00:00:00.000Z',
-            updatedAt: '2026-06-25T00:00:00.000Z',
-        },
-        graph: { viewport: { x: 0, y: 0, scale: 1 }, nodes, edges },
-    };
-    session.activeWorkflow = document;
-    session.activeWorkflowId = document.metadata.id;
-    const bindResult = bindWorkflowToSessionEditor(session.runtime.editor, projectDir, document, resolveDefinition);
-    if (!bindResult.ok) {
-        throw new Error(bindResult.message);
-    }
-}
-let projectDir;
-describe('applyEditorAddNode', () => {
-    beforeEach(async () => {
-        projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lf-editor-add-'));
-    });
-    afterEach(async () => {
-        await fs.rm(projectDir, { recursive: true, force: true });
-    });
-    it('returns added node on success', () => {
-        const session = new LangflowerSession();
-        seedActiveWorkflow(session, []);
-        const result = applyEditorAddNode(session, projectDir, {
-            type: 'common-string',
-            position: { x: 0, y: 0 },
-            inputs: { value: 'hello' },
-        }, resolveDefinition);
-        expect(result).toHaveLength(1);
-        expect(result[0]?.type).toBe('common-string');
-        expect(result[0]?.inputs).toEqual({ value: 'hello' });
-        expect(session.runtime.editor.getNode(result[0].id)).not.toBe(false);
-    });
-    it('seeds inputs from the definition default value when omitted', () => {
-        const session = new LangflowerSession();
-        seedActiveWorkflow(session, []);
-        const result = applyEditorAddNode(session, projectDir, {
-            type: 'common-string',
-            position: { x: 0, y: 0 },
-        }, resolveDefinition);
-        expect(result[0]?.inputs).toEqual({ value: '' });
-    });
-    it('returns empty array when graph is locked', () => {
-        const session = new LangflowerSession();
-        seedActiveWorkflow(session, []);
-        session.runnerStatus = 'running';
-        const result = applyEditorAddNode(session, projectDir, {
-            type: 'common-string',
-            position: { x: 0, y: 0 },
-        }, resolveDefinition);
-        expect(result).toEqual([]);
-    });
-    it('returns empty array for unknown node type', () => {
-        const session = new LangflowerSession();
-        seedActiveWorkflow(session, []);
-        const result = applyEditorAddNode(session, projectDir, {
-            type: 'unknown-type',
-            position: { x: 0, y: 0 },
-        }, resolveDefinition);
-        expect(result).toEqual([]);
-    });
-});
-describe('applyEditorPaste', () => {
-    beforeEach(async () => {
-        projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lf-editor-paste-'));
-    });
-    afterEach(async () => {
-        await fs.rm(projectDir, { recursive: true, force: true });
-    });
-    it('remaps clientIds and pastes nodes with edges and size', () => {
-        const session = new LangflowerSession();
-        seedActiveWorkflow(session, []);
-        const result = applyEditorPaste(session, projectDir, {
-            nodes: [
-                {
-                    clientId: 'tmp-src',
-                    type: 'common-string',
-                    position: { x: 10, y: 20, width: 200, height: 80 },
-                    inputs: { value: 'pasted' },
-                    label: 'Src',
-                },
-                {
-                    clientId: 'tmp-sink',
-                    type: 'common-preview',
-                    position: { x: 240, y: 20 },
-                },
-            ],
-            edges: [
-                {
-                    fromClientId: 'tmp-src',
-                    fromPort: ['value', 0],
-                    toClientId: 'tmp-sink',
-                    toPort: ['text', 0],
-                },
-            ],
-        }, resolveDefinition);
-        expect(result.nodes).toHaveLength(2);
-        expect(result.edges).toHaveLength(1);
-        expect(result.nodes[0]?.ui.position).toEqual({
-            x: 10,
-            y: 20,
-            width: 200,
-            height: 80,
-        });
-        expect(result.nodes[0]?.ui.label).toBe('Src');
-        expect(result.edges[0]?.fromNodeId).toBe(result.nodes[0]?.id);
-        expect(result.edges[0]?.toNodeId).toBe(result.nodes[1]?.id);
-        expect(session.currentStatus).toBe('dirty');
-    });
-    it('returns empty when graph is locked', () => {
-        const session = new LangflowerSession();
-        seedActiveWorkflow(session, []);
-        session.runnerStatus = 'running';
-        const result = applyEditorPaste(session, projectDir, {
-            nodes: [
-                {
-                    clientId: 'tmp',
-                    type: 'common-string',
-                    position: { x: 0, y: 0 },
-                },
-            ],
-            edges: [],
-        }, resolveDefinition);
-        expect(result).toEqual({ nodes: [], edges: [] });
-    });
-});
-describe('applyEditorAddEdge', () => {
-    let session;
-    beforeEach(async () => {
-        projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lf-editor-edge-'));
-        session = new LangflowerSession();
-        seedActiveWorkflow(session, [
-            stringNode('string-1'),
-            previewNode('preview-1'),
-        ]);
-    });
-    afterEach(async () => {
-        await fs.rm(projectDir, { recursive: true, force: true });
-    });
-    it('returns persisted edge on success', () => {
-        const payload = {
-            fromNodeId: 'string-1',
-            fromPort: ['value', 0],
-            toNodeId: 'preview-1',
-            toPort: ['text', 0],
-        };
-        const result = applyEditorAddEdge(session, payload);
-        expect(result.added).toHaveLength(1);
-        expect(result.removed).toEqual([]);
-        expect(result.added[0]?.fromNodeId).toBe('string-1');
-        expect(result.added[0]?.toNodeId).toBe('preview-1');
-    });
-    it('returns empty result when graph is locked', () => {
-        session.runnerStatus = 'running';
-        const result = applyEditorAddEdge(session, {
-            fromNodeId: 'string-1',
-            fromPort: ['value', 0],
-            toNodeId: 'preview-1',
-            toPort: ['text', 0],
-        });
-        expect(result).toEqual({ removed: [], added: [] });
-    });
-    it('replaces edge on occupied target port', () => {
-        seedActiveWorkflow(session, [
-            stringNode('string-1'),
-            stringNode('string-2'),
-            previewNode('preview-1'),
-        ]);
-        const first = applyEditorAddEdge(session, {
-            fromNodeId: 'string-1',
-            fromPort: ['value', 0],
-            toNodeId: 'preview-1',
-            toPort: ['text', 0],
-        });
-        const result = applyEditorAddEdge(session, {
-            fromNodeId: 'string-2',
-            fromPort: ['value', 0],
-            toNodeId: 'preview-1',
-            toPort: ['text', 0],
-        });
-        expect(result.removed).toEqual([first.added[0]]);
-        expect(result.added).toHaveLength(1);
-        expect(result.added[0]?.fromNodeId).toBe('string-2');
-        expect(session.runtime.editor.getEdges()).toHaveLength(1);
-        expect(session.runtime.editor.getEdges()[0]?.fromNodeId).toBe('string-2');
-    });
-    it('replaces incoming edge without removing downstream passthrough wire', () => {
-        seedActiveWorkflow(session, [
-            stringNode('string-1'),
-            stringNode('string-2'),
-            previewNode('preview-1'),
-            delayNode('delay-1'),
-        ]);
-        const incoming = applyEditorAddEdge(session, {
-            fromNodeId: 'string-1',
-            fromPort: ['value', 0],
-            toNodeId: 'preview-1',
-            toPort: ['text', 0],
-        });
-        const downstream = applyEditorAddEdge(session, {
-            fromNodeId: 'preview-1',
-            fromPort: ['text', 0],
-            toNodeId: 'delay-1',
-            toPort: ['value', 0],
-        });
-        expect(downstream.added).toHaveLength(1);
-        const result = applyEditorAddEdge(session, {
-            fromNodeId: 'string-2',
-            fromPort: ['value', 0],
-            toNodeId: 'preview-1',
-            toPort: ['text', 0],
-        });
-        expect(result.removed).toEqual([incoming.added[0]]);
-        expect(result.added).toHaveLength(1);
-        expect(result.added[0]?.fromNodeId).toBe('string-2');
-        expect(session.runtime.editor.getEdges()).toHaveLength(2);
-        expect(session.runtime.editor
-            .getEdges()
-            .some((edge) => edge.edgeId === downstream.added[0]?.edgeId)).toBe(true);
-        expect(session.activeWorkflow?.graph.edges).toHaveLength(2);
-        expect(session.activeWorkflow?.graph.edges.filter((edge) => edge.toNodeId === 'preview-1' && edge.toPort[0] === 'text')).toHaveLength(1);
-    });
-    it('returns empty result for duplicate edge request', () => {
-        applyEditorAddEdge(session, {
-            fromNodeId: 'string-1',
-            fromPort: ['value', 0],
-            toNodeId: 'preview-1',
-            toPort: ['text', 0],
-        });
-        const result = applyEditorAddEdge(session, {
-            fromNodeId: 'string-1',
-            fromPort: ['value', 0],
-            toNodeId: 'preview-1',
-            toPort: ['text', 0],
-        });
-        expect(result).toEqual({ removed: [], added: [] });
-    });
-});
-describe('applyEditorRemoveNode', () => {
-    beforeEach(async () => {
-        projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lf-editor-rm-node-'));
-    });
-    afterEach(async () => {
-        await fs.rm(projectDir, { recursive: true, force: true });
-    });
-    it('returns removed node snapshot', () => {
-        const session = new LangflowerSession();
-        const node = stringNode('string-1');
-        seedActiveWorkflow(session, [node, previewNode('preview-1')]);
-        const result = applyEditorRemoveNode(session, 'string-1');
-        expect(result).toEqual([node]);
-        expect(session.runtime.editor.getNode('string-1')).toBe(false);
-    });
-    it('returns empty array for unknown node id', () => {
-        const session = new LangflowerSession();
-        seedActiveWorkflow(session, [stringNode('string-1')]);
-        expect(applyEditorRemoveNode(session, 'missing')).toEqual([]);
-    });
-});
-describe('applyEditorRemoveEdge', () => {
-    beforeEach(async () => {
-        projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lf-editor-rm-edge-'));
-    });
-    afterEach(async () => {
-        await fs.rm(projectDir, { recursive: true, force: true });
-    });
-    it('returns removed edge snapshots', () => {
-        const session = new LangflowerSession();
-        seedActiveWorkflow(session, [
-            stringNode('string-1'),
-            previewNode('preview-1'),
-        ]);
-        const { added } = applyEditorAddEdge(session, {
-            fromNodeId: 'string-1',
-            fromPort: ['value', 0],
-            toNodeId: 'preview-1',
-            toPort: ['text', 0],
-        });
-        const edge = added[0];
-        const result = applyEditorRemoveEdge(session, edge.edgeId);
-        expect(result).toEqual([edge]);
-        expect(session.runtime.editor.getEdges()).toEqual([]);
-    });
-    it('returns empty array when edge id is missing', () => {
-        const session = new LangflowerSession();
-        seedActiveWorkflow(session, [stringNode('string-1')]);
-        expect(applyEditorRemoveEdge(session, 'missing-edge')).toEqual([]);
-    });
-});
-describe('applyEditorUpdateNode', () => {
-    beforeEach(async () => {
-        projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lf-editor-update-'));
-    });
-    afterEach(async () => {
-        await fs.rm(projectDir, { recursive: true, force: true });
-    });
-    it('updates position and ui without runtime rebind', () => {
-        const session = new LangflowerSession();
-        seedActiveWorkflow(session, [stringNode('string-1')]);
-        const payload = {
-            nodeId: 'string-1',
-            position: { x: 120, y: 48 },
-            ui: { width: 200, height: 96, label: 'Moved' },
-        };
-        const result = applyEditorUpdateNode(session, projectDir, payload, resolveDefinition);
-        expect(result).toHaveLength(1);
-        expect(result[0]?.ui.position).toEqual({
-            x: 120,
-            y: 48,
-            width: 200,
-            height: 96,
-        });
-        expect(result[0]?.ui.label).toBe('Moved');
-    });
-    it('coerces numeric inline inputs on the server before persisting', () => {
-        const session = new LangflowerSession();
-        seedActiveWorkflow(session, [numberNode('number-1')]);
-        const result = applyEditorUpdateNode(session, projectDir, {
-            nodeId: 'number-1',
-            inputs: { value: '1000' },
-        }, resolveDefinition);
-        expect(result).toHaveLength(1);
-        expect(result[0]?.inputs).toEqual({ value: 1000 });
-    });
-    it('normalizes incoming update payloads before they are applied', () => {
-        const normalized = normalizeEditorUpdateNodePayload({
-            nodeId: 'number-1',
-            inputs: { value: '1000' },
-        }, numberNode('number-1'), resolveDefinition);
-        expect(normalized.inputs).toEqual({ value: 1000 });
-    });
-    it('returns empty array when no update fields are present', () => {
-        const session = new LangflowerSession();
-        seedActiveWorkflow(session, [stringNode('string-1')]);
-        expect(applyEditorUpdateNode(session, projectDir, { nodeId: 'string-1' }, resolveDefinition)).toEqual([]);
-    });
-    it('returns empty array while graph is locked', () => {
-        const session = new LangflowerSession();
-        seedActiveWorkflow(session, [stringNode('string-1')]);
-        session.runnerStatus = 'running';
-        expect(applyEditorUpdateNode(session, projectDir, {
-            nodeId: 'string-1',
-            position: { x: 10, y: 10 },
-        }, resolveDefinition)).toEqual([]);
-    });
-});
-//# sourceMappingURL=apply-editor-mutation.test.js.map

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

@@ -1,11 +0,0 @@
-import type { RuntimeEditor } from '@langflower/runtime';
-import type { WorkflowLoadedPayload } from '@langflower/shared/langflower.js';
-import type { ResolveNodeDefinition } from './workflow-document.js';
-export declare function bindWorkflowGraphToEditor(editor: RuntimeEditor, projectDir: string, document: WorkflowLoadedPayload, resolveDefinition?: ResolveNodeDefinition): {
-    readonly ok: true;
-} | {
-    readonly ok: false;
-    readonly code: string;
-    readonly message: string;
-};
-//# sourceMappingURL=bind-workflow-graph.d.ts.map

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

@@ -1,16 +0,0 @@
-import { resolveWorkflowNodeDefinition } from '@langflower/common-nodes';
-import { bindWorkflowToSessionEditor } from './apply-editor-mutation.js';
-export function bindWorkflowGraphToEditor(editor, projectDir, document, resolveDefinition = resolveNodeDefinition) {
-    return bindWorkflowToSessionEditor(editor, projectDir, document, resolveDefinition);
-}
-function resolveNodeDefinition(node) {
-    const definition = resolveWorkflowNodeDefinition({
-        type: node.type,
-        data: { params: node.params },
-    });
-    if (definition === undefined) {
-        return undefined;
-    }
-    return definition;
-}
-//# sourceMappingURL=bind-workflow-graph.js.map

package/vendor/server/dist/workflow/build-save-current-payload.d.ts

@@ -1,3 +0,0 @@
-import type { WorkflowSavePayload } from '@langflower/shared/langflower.js';
-import type { LangflowerSession } from '../session/langflower-session.js';
-export declare function buildSaveCurrentPayload(session: LangflowerSession): WorkflowSavePayload | null;

package/vendor/server/dist/workflow/build-save-current-payload.js

@@ -1,17 +0,0 @@
-export function buildSaveCurrentPayload(session) {
-    const active = session.activeWorkflow;
-    if (active === null) {
-        return null;
-    }
-    return {
-        workflowId: active.workflowId,
-        metadata: {
-            ...active.metadata,
-            updatedAt: new Date().toISOString(),
-        },
-        graph: active.graph,
-        ...(session.pendingPreviousId !== undefined
-            ? { previousWorkflowId: session.pendingPreviousId }
-            : {}),
-    };
-}

package/vendor/server/dist/workflow/build-save-current-payload.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=build-save-current-payload.test.d.ts.map

package/vendor/server/dist/workflow/build-save-current-payload.test.js

@@ -1,44 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { LangflowerSession } from '../session/langflower-session.js';
-import { buildSaveCurrentPayload } from './build-save-current-payload.js';
-function createSession(document) {
-    const session = new LangflowerSession();
-    session.activeWorkflow = document;
-    session.activeWorkflowId = document?.metadata.id;
-    return session;
-}
-describe('buildSaveCurrentPayload', () => {
-    it('returns null when no active workflow', () => {
-        expect(buildSaveCurrentPayload(createSession(null))).toBeNull();
-    });
-    it('builds payload from in-memory active workflow', () => {
-        const document = {
-            metadata: {
-                id: 'demo',
-                name: 'Demo',
-                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 payload = buildSaveCurrentPayload(createSession(document));
-        expect(payload?.metadata.id).toBe('demo');
-        expect(payload?.graph).toEqual(document.graph);
-        expect(payload?.previousId).toBeUndefined();
-    });
-    it('includes pendingPreviousId after rename', () => {
-        const session = createSession({
-            metadata: {
-                id: 'new-name',
-                name: 'New Name',
-                createdAt: '2026-06-17T00:00:00.000Z',
-                updatedAt: '2026-06-17T00:00:00.000Z',
-            },
-            graph: { viewport: { x: 0, y: 0, scale: 1 }, nodes: [], edges: [] },
-        });
-        session.pendingPreviousId = 'old-name';
-        const payload = buildSaveCurrentPayload(session);
-        expect(payload?.previousId).toBe('old-name');
-    });
-});
-//# sourceMappingURL=build-save-current-payload.test.js.map

package/vendor/server/dist/workflow/copy-workflow-to-session.d.ts

@@ -1,8 +0,0 @@
-import type { LangflowerSession } from '../session/langflower-session.js';
-import type { ResolveNodeDefinition } from './workflow-document.js';
-import type { WorkflowService } from './workflow.service.js';
-/**
- * Composer: load source → allocate id → save copy → activate in session.
- * Activate is a sibling step (not via loadWorkflowIntoSession reload).
- */
-export declare const copyWorkflowToSession: (session: LangflowerSession, workflowService: WorkflowService, projectDir: string, workflowId: string, resolveDefinition: ResolveNodeDefinition) => Promise<boolean>;

package/vendor/server/dist/workflow/copy-workflow-to-session.js

@@ -1,32 +0,0 @@
-import { activateWorkflowInSession } from './activate-workflow-in-session.js';
-import { allocateWorkflowId } from './workflow-id.js';
-/**
- * Composer: load source → allocate id → save copy → activate in session.
- * Activate is a sibling step (not via loadWorkflowIntoSession reload).
- */
-export const copyWorkflowToSession = async (session, workflowService, projectDir, workflowId, resolveDefinition) => {
-    if (session.isGraphLocked()) {
-        return false;
-    }
-    const loaded = await workflowService.load({ workflowId });
-    if (!loaded.ok) {
-        return false;
-    }
-    const catalog = await workflowService.list();
-    const nextWorkflowId = allocateWorkflowId(`${loaded.document.workflowId}-copy`, catalog.map((entry) => entry.workflowId));
-    const now = new Date().toISOString();
-    const saveResult = await workflowService.save({
-        workflowId: nextWorkflowId,
-        metadata: {
-            ...loaded.document.metadata,
-            name: `${loaded.document.metadata.name} copy`,
-            createdAt: now,
-            updatedAt: now,
-        },
-        graph: loaded.document.graph,
-    });
-    if (!saveResult.ok) {
-        return false;
-    }
-    return activateWorkflowInSession(session, projectDir, saveResult.document, { dirty: false }, resolveDefinition).ok;
-};

package/vendor/server/dist/workflow/copy-workflow-to-session.test.d.ts

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

package/vendor/server/dist/workflow/copy-workflow-to-session.test.js

@@ -1,72 +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 { copyWorkflowToSession } from './copy-workflow-to-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('copyWorkflowToSession', () => {
-    let projectDir;
-    let service;
-    beforeEach(async () => {
-        projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lf-wf-copy-'));
-        service = new WorkflowService(projectDir, resolveDefinition);
-    });
-    afterEach(async () => {
-        await fs.rm(projectDir, { recursive: true, force: true });
-    });
-    it('persists {id}-copy.json and opens it pristine', async () => {
-        await service.save({
-            metadata: {
-                id: 'example',
-                name: 'Example',
-                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();
-        const ok = await copyWorkflowToSession(session, service, projectDir, 'example');
-        expect(ok).toBe(true);
-        expect(session.activeWorkflow?.metadata.id).toBe('example-copy');
-        expect(session.activeWorkflow?.metadata.name).toBe('Example copy');
-        expect(session.currentStatus).toBe('pristine');
-        expect(await service.exists('example')).toBe(true);
-        expect(await service.exists('example-copy')).toBe(true);
-    });
-    it('dedups copy ids', async () => {
-        await service.save({
-            metadata: {
-                id: 'example',
-                name: 'Example',
-                createdAt: '2026-06-17T00:00:00.000Z',
-                updatedAt: '2026-06-17T00:00:00.000Z',
-            },
-            graph: { viewport: { x: 0, y: 0, scale: 1 }, nodes: [], edges: [] },
-        });
-        await service.save({
-            metadata: {
-                id: 'example-copy',
-                name: 'Example copy',
-                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 copyWorkflowToSession(session, service, projectDir, 'example');
-        expect(session.activeWorkflow?.metadata.id).toBe('example-copy-2');
-    });
-});
-//# sourceMappingURL=copy-workflow-to-session.test.js.map

package/vendor/server/dist/workflow/create-empty-workflow-in-session.d.ts

@@ -1,4 +0,0 @@
-import type { LangflowerSession } from '../session/langflower-session.js';
-import type { ResolveNodeDefinition } from './workflow-document.js';
-import type { WorkflowService } from './workflow.service.js';
-export declare const createEmptyWorkflowInSession: (session: LangflowerSession, workflowService: WorkflowService, projectDir: string, resolveDefinition: ResolveNodeDefinition) => Promise<boolean>;

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

@@ -1,34 +0,0 @@
-import { activateWorkflowInSession } from './activate-workflow-in-session.js';
-import { allocateWorkflowId } from './workflow-id.js';
-const EMPTY_VIEWPORT = {
-    x: 0,
-    y: 0,
-    scale: 1,
-};
-export const createEmptyWorkflowInSession = async (session, workflowService, projectDir, resolveDefinition) => {
-    if (session.isGraphLocked()) {
-        return false;
-    }
-    const catalog = await workflowService.list();
-    const workflowId = allocateWorkflowId('untitled', catalog.map((entry) => entry.workflowId));
-    const now = new Date().toISOString();
-    const document = {
-        workflowId,
-        metadata: {
-            name: 'Untitled',
-            createdAt: now,
-            updatedAt: now,
-        },
-        graph: {
-            viewport: EMPTY_VIEWPORT,
-            nodes: [],
-            edges: [],
-        },
-    };
-    const activated = activateWorkflowInSession(session, projectDir, document, { dirty: true }, resolveDefinition);
-    if (!activated.ok) {
-        return false;
-    }
-    session.pendingPreviousId = undefined;
-    return true;
-};

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

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