@teleporthq/teleport-plugin-next-workflows 0.43.1

package/dist/cjs/workflow-project-plugin.js

@@ -0,0 +1,1304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NextWorkflowProjectPlugin = void 0;
+const teleport_types_1 = require("@teleporthq/teleport-types");
+const segment_splitter_1 = require("./segment-splitter");
+const api_route_generator_1 = require("./api-route-generator");
+const secret_collector_1 = require("./secret-collector");
+const graph_utils_1 = require("./graph-utils");
+const nodes_1 = require("./nodes");
+const executor_generator_1 = require("./executor-generator");
+const realtime_generator_1 = require("./realtime-generator");
+const auth_generator_1 = require("./auth-generator");
+const invoice_1 = require("./invoice");
+const webhook_generator_1 = require("./webhook-generator");
+const data_api_route_generator_1 = require("./data-api-route-generator");
+const runtime_storage_generator_1 = require("./runtime-storage-generator");
+const ecommerce_customhandler_rewriter_1 = require("./ecommerce-customhandler-rewriter");
+const security_scanner_1 = require("./security-scanner");
+class NextWorkflowProjectPlugin {
+    async runBefore(structure) {
+        var _a, _b, _c, _d;
+        const { uidl, strategy } = structure;
+        // Codegen-time security gate. Throws CodegenSecurityError if any
+        // `general-custom-js` body references a protected platform secret
+        // or uses an obvious sandbox-escape primitive. Backstop for the GUI
+        // and services-worker static checks; surfaces the failure before
+        // any code is emitted.
+        (0, security_scanner_1.assertWorkflowsAreSecure)(uidl.workflows);
+        if ((_a = uidl.workflows) === null || _a === void 0 ? void 0 : _a.workflows) {
+            const pageRouteMap = this.buildPageRouteMap(uidl, strategy);
+            const unresolvedPageIds = new Set();
+            for (const wf of Object.values(uidl.workflows.workflows)) {
+                for (const node of wf.nodes || []) {
+                    if (node.type === 'navigation-go-to-page' && ((_b = node.config) === null || _b === void 0 ? void 0 : _b.pageId)) {
+                        const resolved = pageRouteMap[node.config.pageId];
+                        if (resolved) {
+                            node.config.pageId = resolved;
+                        }
+                        else {
+                            unresolvedPageIds.add(node.config.pageId);
+                        }
+                    }
+                }
+            }
+            if (unresolvedPageIds.size > 0) {
+                const defaultRouteUrl = this.getDefaultRouteUrl(uidl, strategy);
+                if (defaultRouteUrl !== null) {
+                    const mappedValues = new Set(Object.values(pageRouteMap));
+                    if (!mappedValues.has(defaultRouteUrl)) {
+                        for (const pid of unresolvedPageIds) {
+                            pageRouteMap[pid] = defaultRouteUrl;
+                        }
+                        for (const wf of Object.values(uidl.workflows.workflows)) {
+                            for (const node of wf.nodes || []) {
+                                if (node.type === 'navigation-go-to-page' &&
+                                    ((_c = node.config) === null || _c === void 0 ? void 0 : _c.pageId) &&
+                                    unresolvedPageIds.has(node.config.pageId)) {
+                                    node.config.pageId = pageRouteMap[node.config.pageId];
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if ((_d = uidl.globals) === null || _d === void 0 ? void 0 : _d.env) {
+            for (const key of Object.keys(uidl.globals.env)) {
+                uidl.globals.env[key] = resolveAuthEnvValue(key, uidl.globals.env[key]);
+            }
+        }
+        // Repair AI-generated customHandler nodes that hard-code values the
+        // merchant configures via the e-commerce settings (low-stock
+        // threshold, alert email payload). Must run BEFORE the segment
+        // splitter / generator pipeline so the rewritten code lands in the
+        // emitted segment files. See `ecommerce-customhandler-rewriter.ts`
+        // for the patterns we recognise and the settings we source.
+        (0, ecommerce_customhandler_rewriter_1.rewriteLowStockCustomHandlers)(uidl);
+        return structure;
+    }
+    async runAfter(structure) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const { uidl, files, dependencies } = structure;
+        const hasAuthentication = uidl.authentication && uidl.authentication.enabled;
+        if (hasAuthentication) {
+            this.generateAuthFiles(uidl.authentication, structure);
+        }
+        if (!uidl.workflows || !uidl.workflows.workflows) {
+            if ((_a = uidl.invoiceSettings) === null || _a === void 0 ? void 0 : _a.enabled) {
+                const { dataSourceType, dataSourceConfig } = (0, invoice_1.resolveInvoiceDataSource)(structure);
+                (0, invoice_1.generateInvoiceFiles)(uidl.invoiceSettings, structure, dataSourceType, dataSourceConfig);
+                // The generated /api/invoices/generate route uploads the rendered PDF
+                // to the runtime-storage worker via uploadInvoicePdfToRuntimeStorage.
+                // Register the env vars here too — this early-return path would
+                // otherwise bypass the env registration block lower down.
+                if (!uidl.globals.env) {
+                    uidl.globals.env = {};
+                }
+                if (!uidl.globals.env.RUNTIME_STORAGE_URL) {
+                    uidl.globals.env.RUNTIME_STORAGE_URL = '';
+                }
+                if (!uidl.globals.env.RUNTIME_STORAGE_API_KEY) {
+                    uidl.globals.env.RUNTIME_STORAGE_API_KEY = '';
+                }
+                if (!uidl.globals.env.RUNTIME_STORAGE_PROJECT_ID) {
+                    uidl.globals.env.RUNTIME_STORAGE_PROJECT_ID = '';
+                }
+            }
+            (0, webhook_generator_1.generateWebhookFiles)(structure, uidl.invoiceSettings);
+            if (hasAuthentication) {
+                this.injectSessionProviderIntoApp(structure);
+            }
+            return structure;
+        }
+        const allWorkflows = uidl.workflows.workflows;
+        const customNodes = uidl.workflows.customNodes || {};
+        const usedNodeTypes = (0, graph_utils_1.collectUsedNodeTypes)(uidl.workflows);
+        files.set('workflow-runtime-utils', {
+            path: ['utils', 'workflows'],
+            files: [
+                {
+                    name: 'runtime-utils',
+                    fileType: teleport_types_1.FileType.JS,
+                    content: (0, executor_generator_1.generateSharedRuntimeUtilsCode)(),
+                },
+            ],
+        });
+        files.set('workflow-client-runtime', {
+            path: ['utils', 'workflows'],
+            files: [
+                {
+                    name: 'runtime',
+                    fileType: teleport_types_1.FileType.JS,
+                    content: (0, executor_generator_1.generateClientRuntimeCode)(),
+                },
+            ],
+        });
+        const clientHandlerCode = this.generateNodeHandlerFile(usedNodeTypes, 'client');
+        if (clientHandlerCode) {
+            files.set('workflow-client-handlers', {
+                path: ['utils', 'workflows'],
+                files: [
+                    {
+                        name: 'node-handlers-client',
+                        fileType: teleport_types_1.FileType.JS,
+                        content: clientHandlerCode,
+                    },
+                ],
+            });
+        }
+        // Build server segment info for custom nodes so they can call server-side API routes
+        const customNodeServerUrls = {};
+        if (Object.keys(customNodes).length > 0) {
+            for (const [cnId, cn] of Object.entries(customNodes)) {
+                const pseudoWorkflow = {
+                    nodes: cn.nodes || [],
+                    edges: cn.edges || [],
+                    trigger: { type: 'manual' },
+                };
+                const cnSegments = (0, segment_splitter_1.splitIntoSegments)(pseudoWorkflow);
+                const cnServerSegments = cnSegments.filter((s) => s.env === 'server');
+                if (cnServerSegments.length > 0) {
+                    customNodeServerUrls[cnId] = {};
+                    for (const seg of cnServerSegments) {
+                        const isStreaming = (0, api_route_generator_1.hasStreamingAINode)(seg);
+                        const apiContent = isStreaming
+                            ? (0, api_route_generator_1.generateStreamingServerSegmentAPIRoute)(seg, cn.name || cnId)
+                            : (0, api_route_generator_1.generateServerSegmentAPIRoute)(seg, cn.name || cnId);
+                        const fileName = (0, api_route_generator_1.getAPIRouteFileName)(cnId, seg.id, cn.name || cnId);
+                        customNodeServerUrls[cnId][seg.id] = `/api/workflows/${fileName}`;
+                        files.set(`workflow-api-cn-${cnId}-${seg.id}`, {
+                            path: ['pages', 'api', 'workflows'],
+                            files: [
+                                {
+                                    name: fileName,
+                                    fileType: teleport_types_1.FileType.JS,
+                                    content: apiContent,
+                                },
+                            ],
+                        });
+                    }
+                }
+            }
+            const customNodeCode = this.generateCustomNodesFile(customNodes, customNodeServerUrls);
+            files.set('workflow-custom-nodes', {
+                path: ['utils', 'workflows'],
+                files: [
+                    {
+                        name: 'custom-nodes',
+                        fileType: teleport_types_1.FileType.JS,
+                        content: customNodeCode,
+                    },
+                ],
+            });
+        }
+        let hasServerSegments = Object.keys(customNodeServerUrls).length > 0;
+        // Track which payment providers are already handled by a workflow-driven
+        // webhook (event-webhook-received + webhookConfig) so we can skip the
+        // legacy hard-coded webhook emission for those providers below.
+        const webhookProvidersOwnedByWorkflows = new Set();
+        for (const workflow of Object.values(allWorkflows)) {
+            if (workflow.trigger.type === 'event-cron-triggered') {
+                const cronContent = (0, api_route_generator_1.generateCronAPIRoute)(workflow);
+                const cronFileName = (0, api_route_generator_1.getCronRouteFileName)(workflow);
+                files.set(`workflow-cron-${workflow.id}`, {
+                    path: ['pages', 'api', 'workflows'],
+                    files: [
+                        {
+                            name: cronFileName,
+                            fileType: teleport_types_1.FileType.JS,
+                            content: cronContent,
+                        },
+                    ],
+                });
+                continue;
+            }
+            if (workflow.trigger.type === 'event-webhook-received' && workflow.webhookConfig) {
+                hasServerSegments = true;
+                const webhookContent = (0, api_route_generator_1.generateWebhookWorkflowAPIRoute)(workflow, customNodes);
+                const webhookFileName = (0, api_route_generator_1.getWebhookRouteFileName)(workflow);
+                const webhookPath = (0, api_route_generator_1.getWebhookRoutePath)(workflow);
+                files.set(`workflow-webhook-${workflow.id}`, {
+                    path: webhookPath,
+                    files: [
+                        {
+                            name: webhookFileName,
+                            fileType: teleport_types_1.FileType.JS,
+                            content: webhookContent,
+                        },
+                    ],
+                });
+                // Detect which payment provider this webhook is handling so the
+                // legacy hard-coded emission (webhook-generator.ts) can be skipped
+                // for the same provider. Uses both the URL path and the trigger's
+                // signature algorithm as hints — the former is what the GUI emits,
+                // the latter is a defence in case the path convention changes.
+                const urlPath = (workflow.webhookConfig.urlPath || '').toLowerCase();
+                const sigAlgorithm = (workflow.webhookConfig.signatureAlgorithm || '').toLowerCase();
+                if (urlPath.includes('stripe') || sigAlgorithm.includes('stripe')) {
+                    webhookProvidersOwnedByWorkflows.add('stripe');
+                }
+                if (urlPath.includes('paypal') || sigAlgorithm.includes('paypal')) {
+                    webhookProvidersOwnedByWorkflows.add('paypal');
+                }
+                // signatureSecret may arrive as either a bare env-var-name string or a
+                // DynamicNode {type:'dynamic', content:{referenceType:'secret', id:'NAME'}}.
+                // Extract the underlying env-var name in both cases so the project
+                // correctly pre-registers it in .env / .env.example.
+                if (workflow.webhookConfig.signatureSecret) {
+                    const rawSecret = workflow.webhookConfig.signatureSecret;
+                    let secretEnvName = '';
+                    if (typeof rawSecret === 'string') {
+                        secretEnvName = rawSecret;
+                    }
+                    else if (rawSecret && typeof rawSecret === 'object') {
+                        const anyVal = rawSecret;
+                        if (anyVal.type === 'dynamic' &&
+                            anyVal.content &&
+                            anyVal.content.referenceType === 'secret' &&
+                            typeof anyVal.content.id === 'string') {
+                            secretEnvName = anyVal.content.id;
+                        }
+                    }
+                    if (secretEnvName) {
+                        if (!uidl.globals.env) {
+                            uidl.globals.env = {};
+                        }
+                        if (!uidl.globals.env[secretEnvName]) {
+                            uidl.globals.env[secretEnvName] = '';
+                        }
+                    }
+                }
+                continue;
+            }
+            const segments = (0, segment_splitter_1.splitIntoSegments)(workflow);
+            const serverSegments = segments.filter((s) => s.env === 'server');
+            for (const serverSeg of serverSegments) {
+                hasServerSegments = true;
+                const isStreaming = (0, api_route_generator_1.hasStreamingAINode)(serverSeg);
+                const apiContent = isStreaming
+                    ? (0, api_route_generator_1.generateStreamingServerSegmentAPIRoute)(serverSeg, workflow.name)
+                    : (0, api_route_generator_1.generateServerSegmentAPIRoute)(serverSeg, workflow.name);
+                const fileName = (0, api_route_generator_1.getAPIRouteFileName)(workflow.id, serverSeg.id, workflow.name);
+                files.set(`workflow-api-${workflow.id}-${serverSeg.id}`, {
+                    path: ['pages', 'api', 'workflows'],
+                    files: [
+                        {
+                            name: fileName,
+                            fileType: teleport_types_1.FileType.JS,
+                            content: apiContent,
+                        },
+                    ],
+                });
+            }
+        }
+        if (hasServerSegments) {
+            files.set('workflow-server-runtime', {
+                path: ['utils', 'workflows'],
+                files: [
+                    {
+                        name: 'server-runtime',
+                        fileType: teleport_types_1.FileType.JS,
+                        content: (0, executor_generator_1.generateServerRuntimeCode)(),
+                    },
+                ],
+            });
+            const serverHandlerCode = this.generateNodeHandlerFile(usedNodeTypes, 'server');
+            if (serverHandlerCode) {
+                files.set('workflow-server-handlers', {
+                    path: ['utils', 'workflows'],
+                    files: [
+                        {
+                            name: 'node-handlers-server',
+                            fileType: teleport_types_1.FileType.JS,
+                            content: serverHandlerCode,
+                        },
+                    ],
+                });
+            }
+        }
+        if ((0, data_api_route_generator_1.needsDataAPIRoute)(usedNodeTypes)) {
+            const authUsersTableName = ((_b = uidl.authentication) === null || _b === void 0 ? void 0 : _b.enabled) && ((_c = uidl.authentication) === null || _c === void 0 ? void 0 : _c.tables)
+                ? Object.keys(uidl.authentication.tables)[0] || 'users'
+                : undefined;
+            // Low-stock auto-fire: the data-api wakes up the
+            // /api/ecommerce/low-stock-alert endpoint on the place-order
+            // workflow's stock-check SELECT. Both flags are sourced from
+            // the ecommerce settings so the data-api short-circuits when
+            // the merchant turned the feature off — no detection cost
+            // when stock management isn't even configured.
+            const ecom = uidl.ecommerceSettings;
+            const lowStockAlertsEnabled = !!(ecom &&
+                ecom.stockManagement &&
+                ((_d = ecom.stockManagementConfig) === null || _d === void 0 ? void 0 : _d.lowStockAlerts) &&
+                ((_f = (_e = ecom.stockManagementConfig) === null || _e === void 0 ? void 0 : _e.lowStockAlertConfig) === null || _f === void 0 ? void 0 : _f.provider));
+            const lowStockThreshold = typeof ((_g = ecom === null || ecom === void 0 ? void 0 : ecom.stockManagementConfig) === null || _g === void 0 ? void 0 : _g.lowStockThreshold) === 'number'
+                ? ecom.stockManagementConfig.lowStockThreshold
+                : 5;
+            files.set('workflow-data-api-route', {
+                path: ['pages', 'api', 'data'],
+                files: [
+                    {
+                        name: '[...params]',
+                        fileType: teleport_types_1.FileType.JS,
+                        content: (0, data_api_route_generator_1.generateDataAPIRoute)({
+                            authUsersTableName,
+                            lowStockAlertsEnabled,
+                            lowStockThreshold,
+                        }),
+                    },
+                ],
+            });
+        }
+        if ((0, runtime_storage_generator_1.needsRuntimeStorageRoute)(usedNodeTypes)) {
+            files.set('runtime-storage-upload-route', {
+                path: ['pages', 'api', 'runtime-storage'],
+                files: [
+                    {
+                        name: 'upload',
+                        fileType: teleport_types_1.FileType.JS,
+                        content: (0, runtime_storage_generator_1.generateRuntimeStorageUploadRoute)(),
+                    },
+                ],
+            });
+        }
+        // Runtime-storage env vars are needed whenever something in the generated
+        // project will talk to the runtime-storage worker. Today that is either:
+        //  - a workflow uses a file-storage-* node (uses /api/runtime-storage/upload), OR
+        //  - invoice generation is enabled (server-side /api/invoices/generate uploads
+        //    the rendered PDF directly via uploadInvoicePdfToRuntimeStorage). The
+        //    invoice path does NOT add a file-storage-upload node to the UIDL, so it
+        //    would otherwise be missed by needsRuntimeStorageRoute.
+        const needsRuntimeStorageEnv = (0, runtime_storage_generator_1.needsRuntimeStorageRoute)(usedNodeTypes) || Boolean((_h = uidl.invoiceSettings) === null || _h === void 0 ? void 0 : _h.enabled);
+        if (needsRuntimeStorageEnv) {
+            if (!uidl.globals.env) {
+                uidl.globals.env = {};
+            }
+            if (!uidl.globals.env.RUNTIME_STORAGE_URL) {
+                uidl.globals.env.RUNTIME_STORAGE_URL = '';
+            }
+            if (!uidl.globals.env.RUNTIME_STORAGE_API_KEY) {
+                uidl.globals.env.RUNTIME_STORAGE_API_KEY = '';
+            }
+            if (!uidl.globals.env.RUNTIME_STORAGE_PROJECT_ID) {
+                uidl.globals.env.RUNTIME_STORAGE_PROJECT_ID = '';
+            }
+        }
+        const secrets = (0, secret_collector_1.collectSecrets)(uidl.workflows);
+        if (secrets.length > 0) {
+            if (!uidl.globals.env) {
+                uidl.globals.env = {};
+            }
+            for (const secret of secrets) {
+                uidl.globals.env[secret.envVarName] = secret.value;
+            }
+        }
+        if (usedNodeTypes.has('payment-charge-user')) {
+            if (!uidl.globals.env) {
+                uidl.globals.env = {};
+            }
+            if (!uidl.globals.env.STRIPE_SECRET_KEY) {
+                uidl.globals.env.STRIPE_SECRET_KEY = '';
+            }
+            if (!uidl.globals.env.PAYPAL_CLIENT_ID) {
+                uidl.globals.env.PAYPAL_CLIENT_ID = '';
+            }
+            if (!uidl.globals.env.PAYPAL_CLIENT_SECRET) {
+                uidl.globals.env.PAYPAL_CLIENT_SECRET = '';
+            }
+            // No PAYPAL_ENV — the runtime detects sandbox vs live from the
+            // credentials themselves (see `paypalAuthenticate` in
+            // payment-charge-user.ts) and caches the result.
+        }
+        const globalWorkflows = Object.values(allWorkflows).filter((wf) => wf.trigger.scope === 'global' &&
+            wf.trigger.type !== 'event-cron-triggered' &&
+            wf.trigger.type !== 'event-webhook-received');
+        if (globalWorkflows.length > 0) {
+            const globalWorkflowCode = this.generateGlobalWorkflowsHook(globalWorkflows);
+            files.set('workflow-global-hook', {
+                path: ['utils', 'workflows'],
+                files: [
+                    {
+                        name: 'global-workflows',
+                        fileType: teleport_types_1.FileType.JS,
+                        content: globalWorkflowCode,
+                    },
+                ],
+            });
+            this.injectGlobalWorkflowsIntoApp(structure);
+        }
+        dependencies['node-fetch'] = '^2.7.0';
+        this.collectNodeDependencies(usedNodeTypes, dependencies);
+        if ((0, graph_utils_1.projectUsesRealtime)(uidl.workflows)) {
+            this.generateRealtimeFiles(structure);
+        }
+        if ((_j = uidl.invoiceSettings) === null || _j === void 0 ? void 0 : _j.enabled) {
+            const { dataSourceType, dataSourceConfig } = (0, invoice_1.resolveInvoiceDataSource)(structure);
+            (0, invoice_1.generateInvoiceFiles)(uidl.invoiceSettings, structure, dataSourceType, dataSourceConfig);
+        }
+        (0, webhook_generator_1.generateWebhookFiles)(structure, uidl.invoiceSettings, {
+            skipProviders: webhookProvidersOwnedByWorkflows,
+        });
+        // Toast is now pure DOM-based, no React provider component needed
+        if (hasAuthentication) {
+            this.injectSessionProviderIntoApp(structure);
+        }
+        return structure;
+    }
+    injectToasterIntoApp(structure) {
+        var _a;
+        const { files } = structure;
+        let appFile = null;
+        for (const [key, record] of files.entries()) {
+            if (key === '_app' || key.includes('_app')) {
+                appFile = (_a = record.files) === null || _a === void 0 ? void 0 : _a.find((f) => f.name === '_app' && (f.fileType === 'js' || f.fileType === 'tsx'));
+                if (appFile) {
+                    break;
+                }
+            }
+        }
+        if (!appFile || typeof appFile.content !== 'string') {
+            return;
+        }
+        if (appFile.content.includes('Toaster')) {
+            return;
+        }
+        let content = appFile.content;
+        const importStatement = `import { Toaster } from 'sonner';\n`;
+        const firstImportIdx = content.indexOf('import ');
+        if (firstImportIdx >= 0) {
+            content = content.slice(0, firstImportIdx) + importStatement + content.slice(firstImportIdx);
+        }
+        else {
+            content = importStatement + content;
+        }
+        const returnMatch = content.match(/return\s*\(\s*/);
+        if (returnMatch && returnMatch.index !== undefined) {
+            const afterReturn = returnMatch.index + returnMatch[0].length;
+            const restContent = content.slice(afterReturn);
+            const closingParenIdx = findMatchingClosingParen(restContent);
+            if (closingParenIdx >= 0) {
+                const innerJSX = restContent.slice(0, closingParenIdx);
+                const afterClosing = restContent.slice(closingParenIdx);
+                content =
+                    content.slice(0, afterReturn) + `<>${innerJSX}<Toaster richColors /></>` + afterClosing;
+            }
+        }
+        appFile.content = content;
+    }
+    generateRealtimeFiles(structure) {
+        const { uidl, files, dependencies } = structure;
+        dependencies.ably = '^2.6.0';
+        if (!uidl.globals.env) {
+            uidl.globals.env = {};
+        }
+        if (!uidl.globals.env.REALTIME_SERVER_URL) {
+            uidl.globals.env.ablyE_SERVER_URL = '';
+        }
+        if (!uidl.globals.env.REALTIME_SERVER_API_KEY) {
+            uidl.globals.env.REALTIME_SERVER_API_KEY = '';
+        }
+        files.set('realtime-server-helper', {
+            path: ['utils', 'realtime'],
+            files: [
+                {
+                    name: 'server',
+                    fileType: teleport_types_1.FileType.JS,
+                    content: (0, realtime_generator_1.generateRealtimeServerHelperCode)(),
+                },
+            ],
+        });
+        files.set('realtime-client', {
+            path: ['utils', 'realtime'],
+            files: [
+                {
+                    name: 'client',
+                    fileType: teleport_types_1.FileType.JS,
+                    content: (0, realtime_generator_1.generateRealtimeClientCode)(),
+                },
+            ],
+        });
+        files.set('realtime-api-token', {
+            path: ['pages', 'api', 'realtime'],
+            files: [
+                {
+                    name: 'token',
+                    fileType: teleport_types_1.FileType.JS,
+                    content: (0, realtime_generator_1.generateRealtimeTokenRoute)(),
+                },
+            ],
+        });
+        files.set('realtime-api-join', {
+            path: ['pages', 'api', 'realtime'],
+            files: [
+                {
+                    name: 'join',
+                    fileType: teleport_types_1.FileType.JS,
+                    content: (0, realtime_generator_1.generateRealtimeJoinRoute)(),
+                },
+            ],
+        });
+        files.set('realtime-api-leave', {
+            path: ['pages', 'api', 'realtime'],
+            files: [
+                {
+                    name: 'leave',
+                    fileType: teleport_types_1.FileType.JS,
+                    content: (0, realtime_generator_1.generateRealtimeLeaveRoute)(),
+                },
+            ],
+        });
+        const usedRealtimeActions = (0, graph_utils_1.collectUsedRealtimeActionTypes)(uidl.workflows);
+        if (usedRealtimeActions.has('realtime-send-channel-message')) {
+            files.set('realtime-api-message', {
+                path: ['pages', 'api', 'realtime'],
+                files: [
+                    {
+                        name: 'message',
+                        fileType: teleport_types_1.FileType.JS,
+                        content: (0, realtime_generator_1.generateRealtimeMessageRoute)(),
+                    },
+                ],
+            });
+        }
+        if (usedRealtimeActions.has('realtime-send-channel-event')) {
+            files.set('realtime-api-event', {
+                path: ['pages', 'api', 'realtime'],
+                files: [
+                    {
+                        name: 'event',
+                        fileType: teleport_types_1.FileType.JS,
+                        content: (0, realtime_generator_1.generateRealtimeEventRoute)(),
+                    },
+                ],
+            });
+        }
+        if (usedRealtimeActions.has('realtime-list-channels')) {
+            files.set('realtime-api-channels-list', {
+                path: ['pages', 'api', 'realtime', 'channels'],
+                files: [
+                    {
+                        name: 'list',
+                        fileType: teleport_types_1.FileType.JS,
+                        content: (0, realtime_generator_1.generateRealtimeChannelsListRoute)(),
+                    },
+                ],
+            });
+        }
+        if (usedRealtimeActions.has('realtime-list-channel-members')) {
+            files.set('realtime-api-channels-members', {
+                path: ['pages', 'api', 'realtime', 'channels'],
+                files: [
+                    {
+                        name: 'members',
+                        fileType: teleport_types_1.FileType.JS,
+                        content: (0, realtime_generator_1.generateRealtimeChannelsMembersRoute)(),
+                    },
+                ],
+            });
+        }
+    }
+    collectNodeDependencies(usedNodeTypes, dependencies) {
+        usedNodeTypes.forEach((nodeType) => {
+            const generator = nodes_1.nodeRegistry[nodeType];
+            if (!generator || !generator.dependencies) {
+                return;
+            }
+            for (const [pkg, version] of Object.entries(generator.dependencies)) {
+                if (!dependencies[pkg]) {
+                    dependencies[pkg] = version;
+                }
+            }
+        });
+    }
+    injectGlobalWorkflowsIntoApp(structure) {
+        var _a;
+        const { files } = structure;
+        // Find the _app file in the files Map
+        let appFile = null;
+        for (const [key, record] of files.entries()) {
+            if (key === '_app' || key.includes('_app')) {
+                appFile = (_a = record.files) === null || _a === void 0 ? void 0 : _a.find((f) => f.name === '_app' && (f.fileType === 'js' || f.fileType === 'tsx'));
+                if (appFile) {
+                    break;
+                }
+            }
+        }
+        if (!appFile || typeof appFile.content !== 'string') {
+            return;
+        }
+        const importStatement = `import { useGlobalWorkflows } from '../utils/workflows/global-workflows';\n`;
+        const hookCall = `  useGlobalWorkflows();\n`;
+        if (appFile.content.includes('useGlobalWorkflows')) {
+            return;
+        }
+        let content = appFile.content;
+        if (!content.includes(importStatement.trim())) {
+            const firstImportIdx = content.indexOf('import ');
+            if (firstImportIdx >= 0) {
+                content = content.slice(0, firstImportIdx) + importStatement + content.slice(firstImportIdx);
+            }
+            else {
+                content = importStatement + content;
+            }
+        }
+        const fnBodyMatch = content.match(/function\s+MyApp\s*\([^)]*\)\s*\{/);
+        if (fnBodyMatch && fnBodyMatch.index !== undefined) {
+            const insertPos = fnBodyMatch.index + fnBodyMatch[0].length;
+            content = content.slice(0, insertPos) + '\n' + hookCall + content.slice(insertPos);
+        }
+        appFile.content = content;
+    }
+    generateNodeHandlerFile(usedNodeTypes, env) {
+        const handlers = [];
+        const exportNames = [];
+        usedNodeTypes.forEach((nodeType) => {
+            if (NextWorkflowProjectPlugin.INLINE_HANDLED_NODE_TYPES.has(nodeType)) {
+                return;
+            }
+            const generator = nodes_1.nodeRegistry[nodeType];
+            if (!generator) {
+                return;
+            }
+            const nodeEnv = generator.executionEnv;
+            const isRelevant = nodeEnv === env || nodeEnv === 'universal';
+            if (!isRelevant) {
+                return;
+            }
+            if (env === 'server' && generator.generateServerHandler) {
+                handlers.push(generator.generateServerHandler());
+            }
+            else {
+                handlers.push(generator.generateHandler());
+            }
+            exportNames.push(nodeType);
+        });
+        if (handlers.length === 0) {
+            return '';
+        }
+        const exports = exportNames.map((t) => `  '${t}': ${t.replace(/-/g, '_')}`).join(',\n');
+        return `// Auto-generated workflow node handlers (${env})
+
+${handlers.join('\n\n')}
+
+module.exports = {
+${exports}
+};
+`;
+    }
+    getDefaultRouteUrl(uidl, strategy) {
+        var _a, _b, _c;
+        const routeDef = (_b = (_a = uidl.root) === null || _a === void 0 ? void 0 : _a.stateDefinitions) === null || _b === void 0 ? void 0 : _b.route;
+        if (!(routeDef === null || routeDef === void 0 ? void 0 : routeDef.values) || !routeDef.defaultValue) {
+            return null;
+        }
+        const defaultEntry = routeDef.values.find((rv) => rv.value === routeDef.defaultValue);
+        if (!defaultEntry) {
+            return null;
+        }
+        if ((_c = defaultEntry.pageOptions) === null || _c === void 0 ? void 0 : _c.navLink) {
+            return defaultEntry.pageOptions.navLink;
+        }
+        return '/';
+    }
+    buildPageRouteMap(uidl, strategy) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const map = {};
+        const routeDef = (_b = (_a = uidl.root) === null || _a === void 0 ? void 0 : _a.stateDefinitions) === null || _b === void 0 ? void 0 : _b.route;
+        const useFileNameForNavigation = (_e = (_d = (_c = strategy.pages) === null || _c === void 0 ? void 0 : _c.options) === null || _d === void 0 ? void 0 : _d.useFileNameForNavigation) !== null && _e !== void 0 ? _e : false;
+        if (routeDef === null || routeDef === void 0 ? void 0 : routeDef.values) {
+            const defaultValue = routeDef.defaultValue;
+            for (const routeValue of routeDef.values) {
+                if (!routeValue.pageId) {
+                    continue;
+                }
+                if ((_f = routeValue.pageOptions) === null || _f === void 0 ? void 0 : _f.fallback) {
+                    continue;
+                }
+                const isHome = routeValue.value === defaultValue;
+                const navLink = (_g = routeValue.pageOptions) === null || _g === void 0 ? void 0 : _g.navLink;
+                if (navLink) {
+                    map[routeValue.pageId] = navLink;
+                }
+                else if (isHome) {
+                    map[routeValue.pageId] = '/';
+                }
+                else {
+                    const pageName = routeValue.value.toString();
+                    const fileName = pageName.replace(/\s+/g, '-').toLowerCase();
+                    map[routeValue.pageId] = '/' + (useFileNameForNavigation ? fileName : pageName);
+                }
+            }
+        }
+        const auth = uidl.authentication;
+        if (auth === null || auth === void 0 ? void 0 : auth.authPages) {
+            for (const authPage of Object.values(auth.authPages)) {
+                if (authPage.pageId && authPage.route && !map[authPage.pageId]) {
+                    map[authPage.pageId] = authPage.route;
+                }
+            }
+        }
+        return map;
+    }
+    generateCustomNodesFile(customNodes, customNodeServerUrls) {
+        const functions = [];
+        for (const [id, cn] of Object.entries(customNodes)) {
+            const safeId = id.replace(/[^a-zA-Z0-9]/g, '_');
+            const nodesJson = JSON.stringify(cn.nodes);
+            const edgesJson = JSON.stringify(cn.edges);
+            const params = (cn.parameters || []).map((p) => p.key);
+            // An `event-workflow-error` node in a custom node defines a rollback /
+            // cleanup chain that must run when any upstream node throws. Without
+            // plumbing its id into wfConfig + wrapping the segment loop in a
+            // try/catch the chain is dead code (the top-level executor only looks
+            // at the outer workflow's errorHandlerNodeId), so optimistic global
+            // state updates would never be rolled back and toast-show error
+            // notifications would never fire from inside a shared custom node.
+            const errorHandlerNode = (cn.nodes || []).find((n) => n && n.type === 'event-workflow-error');
+            const errorHandlerNodeId = errorHandlerNode ? errorHandlerNode.id : null;
+            const serverUrls = customNodeServerUrls[id];
+            const hasServerSegments = serverUrls && Object.keys(serverUrls).length > 0;
+            if (hasServerSegments) {
+                // Generate segment-based execution for custom nodes with server-side nodes
+                const pseudoWorkflow = {
+                    nodes: cn.nodes || [],
+                    edges: cn.edges || [],
+                    trigger: { type: 'manual' },
+                };
+                const cnSegments = (0, segment_splitter_1.splitIntoSegments)(pseudoWorkflow);
+                const segmentsJson = JSON.stringify(cnSegments.map((s) => ({
+                    id: s.id,
+                    env: s.env,
+                    hasStreamingAI: (0, api_route_generator_1.hasStreamingAINode)(s),
+                    nodes: s.nodes.map((n) => ({
+                        id: n.id,
+                        type: n.type,
+                        config: n.config,
+                        stepNumber: n.stepNumber,
+                        label: n.label,
+                    })),
+                    edges: s.edges.map((e) => ({
+                        id: e.id,
+                        source: e.source,
+                        target: e.target,
+                        sourceHandle: e.sourceHandle,
+                        targetHandle: e.targetHandle,
+                        data: e.data,
+                    })),
+                })));
+                const serverUrlsJson = JSON.stringify(serverUrls);
+                functions.push(`
+// Custom workflow node: ${cn.name || id}
+// ${cn.description || ''}
+// Parameters: ${params.join(', ')}
+async function customNode_${safeId}(outerContext, parameters, nodeHandlers) {
+  var nodes = ${nodesJson};
+  var edges = ${edgesJson};
+  var segments = ${segmentsJson};
+  var serverUrls = ${serverUrlsJson};
+  var context = Object.assign({}, outerContext);
+  context.__customParams = parameters;
+  context.__isInsideCustomNode = true;
+  var nodeIds = nodes.map(function(n) { return n.id; });
+  context.__customNodeIds = nodeIds;
+  context.__previousNodeResult = null;
+  var wfConfig = { customNodes: __customNodeRegistry, nodes: nodes, edges: edges${errorHandlerNodeId ? `, errorHandlerNodeId: '${errorHandlerNodeId}'` : ''} };
+  var executionId = Date.now().toString();
+  var streamingInfo = __runtime.findStreamingAINodes(nodes, edges);
+  var handledNodeIds = {};
+
+  try {
+  for (var si = 0; si < segments.length; si++) {
+    var seg = segments[si];
+    if (seg.env === 'client') {
+      var clientNodes = seg.nodes.filter(function(n) { return !handledNodeIds[n.id] && !(context.__skippedNodes && context.__skippedNodes[n.id]); });
+      if (clientNodes.length > 0) {
+        await __utils.executeNodes(clientNodes, seg.edges, context, nodeHandlers, wfConfig, null, executionId);
+      }
+      // After a client segment with if-statements, mark non-taken branch
+      // nodes as skipped using the FULL nodes array so branches that span
+      // across server/client segments are correctly skipped.
+      var __cIfNodes = seg.nodes.filter(function(n) { return n.type === 'general-if-statement' && context[n.id]; });
+      for (var __ci = 0; __ci < __cIfNodes.length; __ci++) {
+        var __cIfNode = __cIfNodes[__ci];
+        var __cIfRes = context[__cIfNode.id];
+        if (typeof __cIfRes.result === 'boolean') {
+          var __cSkipH = __cIfRes.result ? 'false' : 'true';
+          var __cSkipEdge = edges.find(function(e) { return e.source === __cIfNode.id && e.sourceHandle === __cSkipH; });
+          if (__cSkipEdge) {
+            var __cSkipBranch = __utils.collectBranchNodes(__cSkipEdge.target, nodes, edges, __cIfNode.id);
+            if (!context.__skippedNodes) context.__skippedNodes = {};
+            for (var __csk = 0; __csk < __cSkipBranch.length; __csk++) {
+              context.__skippedNodes[__cSkipBranch[__csk].id] = true;
+            }
+          }
+        }
+      }
+    } else if (seg.env === 'server') {
+      // Skip entire server segment if all its nodes are in __skippedNodes
+      // (matches the skipping logic in executeWorkflowWithSegments)
+      if (context.__skippedNodes && seg.nodes.length > 0) {
+        var __allSkipped = seg.nodes.every(function(n) { return context.__skippedNodes[n.id]; });
+        if (__allSkipped) continue;
+      }
+      var segUrl = serverUrls[seg.id];
+      if (segUrl) {
+        if (seg.hasStreamingAI) {
+          var streamHandled = await __runtime.callStreamingServerSegment(segUrl, context, streamingInfo, nodes, edges, nodeHandlers, wfConfig, executionId);
+          Object.assign(handledNodeIds, streamHandled);
+        } else {
+          var serverResults = await __runtime.callServerSegment(segUrl, context);
+          if (serverResults) {
+            var rKeys = Object.keys(serverResults);
+            for (var rk = 0; rk < rKeys.length; rk++) {
+              context[rKeys[rk]] = serverResults[rKeys[rk]];
+            }
+          }
+          // Propagate non-taken if-statement branches from this server
+          // segment into subsequent segments. Iterate every if-statement
+          // in the segment (not just the last node), because mid-segment
+          // if-statements followed by further nodes still affect
+          // downstream segments.
+          var segSorted = seg.nodes.slice().sort(function(a, b) { return (a.stepNumber || 0) - (b.stepNumber || 0); });
+          var __segIfNodes = segSorted.filter(function(n) { return n.type === 'general-if-statement' && context[n.id]; });
+          for (var __sifi = 0; __sifi < __segIfNodes.length; __sifi++) {
+            var __sifNode = __segIfNodes[__sifi];
+            var __sifRes = context[__sifNode.id];
+            if (typeof __sifRes.result === 'boolean') {
+              var __skH = __sifRes.result ? 'false' : 'true';
+              var __skE = edges.find(function(e) { return e.source === __sifNode.id && e.sourceHandle === __skH; });
+              if (__skE) {
+                var __skNodes = __utils.collectBranchNodes(__skE.target, nodes, edges, __sifNode.id);
+                if (!context.__skippedNodes) context.__skippedNodes = {};
+                for (var __skI = 0; __skI < __skNodes.length; __skI++) {
+                  context.__skippedNodes[__skNodes[__skI].id] = true;
+                }
+              }
+            }
+          }
+          if (segSorted.length > 0 && context[segSorted[segSorted.length - 1].id]) {
+            context.__previousNodeResult = context[segSorted[segSorted.length - 1].id];
+          }
+        }
+      }
+    }
+    // If the last node returned __terminal, stop the segment loop
+    if (context.__previousNodeResult && context.__previousNodeResult.__terminal) break;
+  }
+  } catch (__error) {
+    if (__error && (__error.__skipErrorHandler || __error.__rateLimited)) {
+      throw __error;
+    }
+    ${errorHandlerNodeId
+                    ? `var __firstErrorEdge = edges.filter(function(e) { return e.source === '${errorHandlerNodeId}'; })[0];
+    if (__firstErrorEdge) {
+      var __errorNodes = __utils.collectBranchNodes(__firstErrorEdge.target, nodes, edges, '${errorHandlerNodeId}');
+      if (__errorNodes.length > 0) {
+        context['${errorHandlerNodeId}'] = {
+          error: { message: (__error && __error.message) || String(__error), stack: (__error && __error.stack) || '' },
+          errorMessage: (__error && __error.message) || String(__error)
+        };
+        try {
+          await __utils.executeNodes(__errorNodes, edges, context, nodeHandlers, wfConfig, null, executionId);
+        } catch (__innerErr) {
+          console.error('Custom workflow node error handler failed:', __innerErr);
+        }
+      } else {
+        throw __error;
+      }
+    } else {
+      throw __error;
+    }`
+                    : 'throw __error;'}
+  }
+
+  var sortedNodeIds = nodes.slice().sort(function(a, b) { return a.stepNumber - b.stepNumber; }).map(function(n) { return n.id; });
+  var lastNodeId = null;
+  for (var __ri = sortedNodeIds.length - 1; __ri >= 0; __ri--) {
+    if (context[sortedNodeIds[__ri]] !== undefined) { lastNodeId = sortedNodeIds[__ri]; break; }
+  }
+  return lastNodeId ? context[lastNodeId] : {};
+}`);
+            }
+            else {
+                // No server segments — simple client-only execution
+                functions.push(`
+// Custom workflow node: ${cn.name || id}
+// ${cn.description || ''}
+// Parameters: ${params.join(', ')}
+async function customNode_${safeId}(outerContext, parameters, nodeHandlers) {
+  var nodes = ${nodesJson};
+  var edges = ${edgesJson};
+  var context = Object.assign({}, outerContext);
+  context.__customParams = parameters;
+  context.__isInsideCustomNode = true;
+  var nodeIds = nodes.map(function(n) { return n.id; });
+  context.__customNodeIds = nodeIds;
+  context.__previousNodeResult = null;
+
+  var wfConfig = { customNodes: __customNodeRegistry${errorHandlerNodeId
+                    ? `, nodes: nodes, edges: edges, errorHandlerNodeId: '${errorHandlerNodeId}'`
+                    : ''} };
+  var executionId = Date.now().toString();
+  try {
+    await __utils.executeNodes(nodes, edges, context, nodeHandlers, wfConfig, null, executionId);
+  } catch (__error) {
+    if (__error && (__error.__skipErrorHandler || __error.__rateLimited)) {
+      throw __error;
+    }
+    ${errorHandlerNodeId
+                    ? `var __firstErrorEdge = edges.filter(function(e) { return e.source === '${errorHandlerNodeId}'; })[0];
+    if (__firstErrorEdge) {
+      var __errorNodes = __utils.collectBranchNodes(__firstErrorEdge.target, nodes, edges, '${errorHandlerNodeId}');
+      if (__errorNodes.length > 0) {
+        context['${errorHandlerNodeId}'] = {
+          error: { message: (__error && __error.message) || String(__error), stack: (__error && __error.stack) || '' },
+          errorMessage: (__error && __error.message) || String(__error)
+        };
+        try {
+          await __utils.executeNodes(__errorNodes, edges, context, nodeHandlers, wfConfig, null, executionId);
+        } catch (__innerErr) {
+          console.error('Custom workflow node error handler failed:', __innerErr);
+        }
+      } else {
+        throw __error;
+      }
+    } else {
+      throw __error;
+    }`
+                    : 'throw __error;'}
+  }
+
+  var sortedNodeIds = nodes.slice().sort(function(a, b) { return a.stepNumber - b.stepNumber; }).map(function(n) { return n.id; });
+  var lastNodeId = null;
+  for (var __ri = sortedNodeIds.length - 1; __ri >= 0; __ri--) {
+    if (context[sortedNodeIds[__ri]] !== undefined) { lastNodeId = sortedNodeIds[__ri]; break; }
+  }
+  return lastNodeId ? context[lastNodeId] : {};
+}`);
+            }
+        }
+        const hasAnyServerSegments = Object.keys(customNodeServerUrls).length > 0;
+        const registryEntries = Object.keys(customNodes)
+            .map((id) => `__customNodeRegistry['${id}'] = customNode_${id.replace(/[^a-zA-Z0-9]/g, '_')};`)
+            .join('\n');
+        return `// Auto-generated custom workflow nodes
+var __utils = require('./runtime-utils');
+${hasAnyServerSegments ? "var __runtime = require('./runtime');" : ''}
+
+var __customNodeRegistry = {};
+${functions.join('\n')}
+
+${registryEntries}
+
+module.exports = __customNodeRegistry;
+`;
+    }
+    generateAuthFiles(auth, structure) {
+        var _a, _b;
+        const { files, dependencies, uidl } = structure;
+        const dataSourceConfig = (auth.dataSourceId && ((_b = (_a = uidl.dataSources) === null || _a === void 0 ? void 0 : _a[auth.dataSourceId]) === null || _b === void 0 ? void 0 : _b.config)) || null;
+        const authOptionsCode = (0, auth_generator_1.generateAuthOptionsFile)(auth, dataSourceConfig);
+        files.set('auth-options', {
+            path: ['utils', 'auth'],
+            files: [
+                {
+                    name: 'auth-options',
+                    fileType: teleport_types_1.FileType.JS,
+                    content: authOptionsCode,
+                },
+            ],
+        });
+        if (auth.passwordAuthEnabled) {
+            const hashPasswordCode = (0, auth_generator_1.generateHashPasswordFile)();
+            files.set('auth-hash-password', {
+                path: ['utils', 'auth'],
+                files: [
+                    {
+                        name: 'hash-password',
+                        fileType: teleport_types_1.FileType.JS,
+                        content: hashPasswordCode,
+                    },
+                ],
+            });
+            const signupRouteCode = (0, auth_generator_1.generateSignupRouteFile)(auth);
+            files.set('auth-signup-route', {
+                path: ['pages', 'api', 'auth'],
+                files: [
+                    {
+                        name: 'signup',
+                        fileType: teleport_types_1.FileType.JS,
+                        content: signupRouteCode,
+                    },
+                ],
+            });
+        }
+        const nextAuthRouteCode = (0, auth_generator_1.generateNextAuthRouteFile)();
+        files.set('auth-nextauth-route', {
+            path: ['pages', 'api', 'auth'],
+            files: [
+                {
+                    name: '[...nextauth]',
+                    fileType: teleport_types_1.FileType.JS,
+                    content: nextAuthRouteCode,
+                },
+            ],
+        });
+        const hasProtectedRoutes = (auth.pageProtection && Object.keys(auth.pageProtection).length > 0) ||
+            (auth.folderProtection && Object.keys(auth.folderProtection).length > 0);
+        if (hasProtectedRoutes) {
+            const middlewareCode = (0, auth_generator_1.generateMiddlewareFile)(auth);
+            files.set('auth-middleware', {
+                path: [],
+                files: [
+                    {
+                        name: 'middleware',
+                        fileType: teleport_types_1.FileType.JS,
+                        content: middlewareCode,
+                    },
+                ],
+            });
+        }
+        const sessionProviderCode = (0, auth_generator_1.generateSessionProviderWrapper)();
+        files.set('auth-session-provider', {
+            path: ['utils', 'auth'],
+            files: [
+                {
+                    name: 'session-provider',
+                    fileType: teleport_types_1.FileType.JS,
+                    content: sessionProviderCode,
+                },
+            ],
+        });
+        dependencies['next-auth'] = '^4.24.0';
+        dependencies.bcryptjs = '^2.4.3';
+        const driverDeps = (0, auth_generator_1.getDatabaseDriverDependencies)(auth.dataSourceType);
+        for (const [pkg, version] of Object.entries(driverDeps)) {
+            if (!dependencies[pkg]) {
+                dependencies[pkg] = version;
+            }
+        }
+        if (auth.envKeys) {
+            if (!uidl.globals.env) {
+                uidl.globals.env = {};
+            }
+            for (const [key, value] of Object.entries(auth.envKeys)) {
+                if (!uidl.globals.env[key]) {
+                    uidl.globals.env[key] = resolveAuthEnvValue(key, String(value));
+                }
+            }
+        }
+    }
+    injectSessionProviderIntoApp(structure) {
+        var _a;
+        const { files } = structure;
+        // Find the _app file in the files Map
+        let appFileRecord = null;
+        let appFile = null;
+        for (const [key, record] of files.entries()) {
+            if (key === '_app' || key.includes('_app')) {
+                appFileRecord = record;
+                appFile = (_a = record.files) === null || _a === void 0 ? void 0 : _a.find((f) => f.name === '_app' && (f.fileType === 'js' || f.fileType === 'tsx'));
+                if (appFile) {
+                    break;
+                }
+            }
+        }
+        if (!appFile || typeof appFile.content !== 'string') {
+            return;
+        }
+        if (appFile.content.includes('AuthSessionProvider') ||
+            appFile.content.includes('SessionProvider')) {
+            return;
+        }
+        let content = appFile.content;
+        const sessionImport = `import AuthSessionProvider from '../utils/auth/session-provider';\n`;
+        const firstImportIdx = content.indexOf('import ');
+        if (firstImportIdx >= 0) {
+            content = content.slice(0, firstImportIdx) + sessionImport + content.slice(firstImportIdx);
+        }
+        else {
+            content = sessionImport + content;
+        }
+        const returnMatch = content.match(/return\s*\(\s*/);
+        if (returnMatch && returnMatch.index !== undefined) {
+            const afterReturn = returnMatch.index + returnMatch[0].length;
+            const restContent = content.slice(afterReturn);
+            const closingParenIdx = findMatchingClosingParen(restContent);
+            if (closingParenIdx >= 0) {
+                const innerJSX = restContent.slice(0, closingParenIdx);
+                const afterClosing = restContent.slice(closingParenIdx);
+                content =
+                    content.slice(0, afterReturn) +
+                        `<AuthSessionProvider pageProps={pageProps}>${innerJSX}</AuthSessionProvider>` +
+                        afterClosing;
+            }
+        }
+        else {
+            const returnSimpleMatch = content.match(/return\s+(<[^;]+);?/);
+            if (returnSimpleMatch && returnSimpleMatch.index !== undefined) {
+                const returnStart = returnSimpleMatch.index;
+                const returnKeyword = content.slice(returnStart, returnStart + 7);
+                const jsx = returnSimpleMatch[1];
+                content =
+                    content.slice(0, returnStart) +
+                        `${returnKeyword}<AuthSessionProvider pageProps={pageProps}>${jsx}</AuthSessionProvider>` +
+                        content.slice(returnStart + returnSimpleMatch[0].length);
+            }
+        }
+        appFile.content = content;
+    }
+    generateGlobalWorkflowsHook(workflows) {
+        const registrations = [];
+        const handlerTypes = new Set();
+        for (const wf of workflows) {
+            const segments = (0, segment_splitter_1.splitIntoSegments)(wf);
+            wf.nodes.forEach((n) => {
+                const seg = segments.find((s) => s.nodeIds.includes(n.id));
+                if (seg && seg.env === 'client') {
+                    handlerTypes.add(n.type);
+                }
+            });
+            const safeId = wf.id.replace(/[^a-zA-Z0-9]/g, '_');
+            const trigger = wf.trigger;
+            if (trigger.type === 'event-unhandled-error') {
+                registrations.push(`
+    const handler_${safeId} = function(event) {
+      const ctx = { message: event.message, stack: event.error ? event.error.stack : '', filename: event.filename, lineno: event.lineno, colno: event.colno };
+      executeWorkflow_${safeId}(ctx).catch(function() {});
+    };
+    window.addEventListener('error', handler_${safeId});
+    cleanups.push(function() { window.removeEventListener('error', handler_${safeId}); });`);
+            }
+            else if (trigger.type === 'event-custom-triggered') {
+                const eventName = trigger.config.eventName;
+                registrations.push(`
+    const handler_${safeId} = function(event) {
+      const ctx = { eventName: '${eventName}', eventData: event.detail, timestamp: Date.now() };
+      executeWorkflow_${safeId}(ctx).catch(function() {});
+    };
+    window.addEventListener('workflow:custom:${eventName}', handler_${safeId});
+    cleanups.push(function() { window.removeEventListener('workflow:custom:${eventName}', handler_${safeId}); });`);
+            }
+            else if (trigger.type === 'event-user-logged-in') {
+                registrations.push(`
+    const handler_${safeId} = function(event) {
+      const ctx = event.detail || { timestamp: Date.now() };
+      executeWorkflow_${safeId}(ctx).catch(function() {});
+    };
+    window.addEventListener('workflow:user-logged-in', handler_${safeId});
+    cleanups.push(function() { window.removeEventListener('workflow:user-logged-in', handler_${safeId}); });`);
+            }
+            else if (trigger.type === 'event-user-logged-out') {
+                registrations.push(`
+    const handler_${safeId} = function(event) {
+      const ctx = event.detail || { timestamp: Date.now() };
+      executeWorkflow_${safeId}(ctx).catch(function() {});
+    };
+    window.addEventListener('workflow:user-logged-out', handler_${safeId});
+    cleanups.push(function() { window.removeEventListener('workflow:user-logged-out', handler_${safeId}); });`);
+            }
+        }
+        const handlers = [];
+        handlerTypes.forEach((t) => {
+            const gen = nodes_1.nodeRegistry[t];
+            if (gen) {
+                handlers.push(gen.generateHandler());
+            }
+        });
+        const handlerEntries = Array.from(handlerTypes)
+            .map((t) => `    '${t}': ${t.replace(/-/g, '_')}`)
+            .join(',\n');
+        return `// Auto-generated global workflow hooks
+import { useEffect } from 'react';
+const workflowRuntime = require('./runtime');
+const executeWorkflowWithSegments = workflowRuntime.executeWorkflowWithSegments;
+
+export function useGlobalWorkflows() {
+${handlers.join('\n')}
+
+  const clientNodeHandlers = {
+${handlerEntries}
+  };
+
+${workflows
+            .map((wf) => {
+            const safeId = wf.id.replace(/[^a-zA-Z0-9]/g, '_');
+            const segments = (0, segment_splitter_1.splitIntoSegments)(wf);
+            const serverSegments = segments.filter((s) => s.env === 'server');
+            const serverUrls = {};
+            serverSegments.forEach((seg) => {
+                serverUrls[seg.id] = `/api/workflows/${(0, api_route_generator_1.getAPIRouteFileName)(wf.id, seg.id, wf.name)}`;
+            });
+            return `  const executeWorkflow_${safeId} = async function(triggerContext) {
+    const wfConfig = {
+      triggerNodeId: '${wf.trigger.nodeId}',
+      segments: ${JSON.stringify(segments.map((s) => ({
+                id: s.id,
+                env: s.env,
+                hasStreamingAI: (0, api_route_generator_1.hasStreamingAINode)(s),
+                nodes: s.nodes.map((n) => ({
+                    id: n.id,
+                    type: n.type,
+                    config: n.config,
+                    stepNumber: n.stepNumber,
+                })),
+                edges: s.edges,
+            })))},
+      ${wf.errorHandler ? `errorHandlerNodeId: '${wf.errorHandler.nodeId}',` : ''}
+      nodes: ${JSON.stringify(wf.nodes.map((n) => ({
+                id: n.id,
+                type: n.type,
+                config: n.config,
+                stepNumber: n.stepNumber,
+            })))},
+      edges: ${JSON.stringify(wf.edges)}
+    };
+    return executeWorkflowWithSegments(wfConfig, triggerContext, clientNodeHandlers, ${JSON.stringify(serverUrls)});
+  };`;
+        })
+            .join('\n')}
+
+  useEffect(function() {
+    const cleanups = [];
+${registrations.join('\n')}
+    return function() { cleanups.forEach(function(fn) { fn(); }); };
+  }, []);
+}
+`;
+    }
+}
+exports.NextWorkflowProjectPlugin = NextWorkflowProjectPlugin;
+NextWorkflowProjectPlugin.INLINE_HANDLED_NODE_TYPES = new Set([
+    'general-if-statement',
+    'general-switch',
+    'general-loop',
+    'general-parallel',
+]);
+const AUTH_ENV_DEFAULTS = {
+    NEXTAUTH_URL: 'http://localhost:3000',
+    NEXTAUTH_SECRET: 'CHANGE_ME_TO_A_RANDOM_SECRET',
+};
+function resolveAuthEnvValue(key, value) {
+    if (value.startsWith('teleporthq.secrets.')) {
+        return AUTH_ENV_DEFAULTS[key] || '';
+    }
+    return value;
+}
+function findMatchingClosingParen(str) {
+    let depth = 0;
+    for (let i = 0; i < str.length; i++) {
+        const ch = str[i];
+        if (ch === '(') {
+            depth++;
+        }
+        if (ch === ')') {
+            if (depth === 0) {
+                return i;
+            }
+            depth--;
+        }
+    }
+    return -1;
+}
+//# sourceMappingURL=workflow-project-plugin.js.map