@synergenius/flow-weaver 0.17.1 → 0.17.2

package/dist/cli/index.d.ts

@@ -6,4 +6,5 @@
  * Do not add #!/usr/bin/env node here - it will cause duplicate shebangs.
  */
 import './env-setup.js';
+import '../extensions/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -7,6 +7,8 @@
  */
 // Must be imported first: sets up env vars before picocolors reads them
 import './env-setup.js';
+// Load built-in extensions (CI/CD, etc.) before any commands run
+import '../extensions/index.js';
 import { Command, Option } from 'commander';
 import { compileCommand } from './commands/compile.js';
 import { createWorkflowCommand, createNodeCommand } from './commands/create.js';
@@ -102,12 +104,12 @@ program
     .option('--strict', 'Treat type coercion warnings as errors', false)
     .option('--inline-runtime', 'Force inline runtime even when @synergenius/flow-weaver package is installed', false)
     .option('--clean', 'Omit redundant @param/@returns annotations from compiled output', false)
-    .option('--target <target>', 'Compilation target: typescript (default) or inngest (per-node step.run)')
-    .option('--cron <schedule>', 'Set cron trigger schedule (Inngest target only)')
+    .option('--target <target>', 'Compilation target: typescript (default) or a registered extension target')
+    .option('--cron <schedule>', 'Set cron trigger schedule')
     .option('--serve', 'Generate serve() handler for HTTP event reception')
     .option('--framework <name>', 'Framework adapter for serve handler (next, express, hono, fastify, remix)')
     .option('--typed-events', 'Generate Zod event schemas from workflow @param annotations')
-    .option('--retries <n>', 'Number of retries per function (Inngest target only)', parseInt)
+    .option('--retries <n>', 'Number of retries per function', parseInt)
     .option('--timeout <duration>', 'Function timeout (e.g. "30m", "1h")')
     .action(wrapAction(async (input, options) => {
     if (options.workflow)
@@ -241,9 +243,9 @@ program
     .option('--clean', 'Omit redundant @param/@returns annotations', false)
     .option('--once', 'Run once then exit', false)
     .option('--json', 'Output result as JSON', false)
-    .option('--target <target>', 'Compilation target: typescript or inngest (default: typescript)')
-    .option('--framework <framework>', 'Framework for serve handler (inngest target only)', 'express')
-    .option('--port <port>', 'Port for dev server (inngest target only)', (v) => parseInt(v, 10), 3000)
+    .option('--target <target>', 'Compilation target (default: typescript)')
+    .option('--framework <framework>', 'Framework for serve handler', 'express')
+    .option('--port <port>', 'Port for dev server', (v) => parseInt(v, 10), 3000)
     .action(wrapAction(async (input, options) => {
     await devCommand(input, options);
 }));
@@ -450,7 +452,7 @@ program
     .option('--multi', 'Export all workflows in file as a single multi-workflow service', false)
     .option('--workflows <names>', 'Comma-separated list of workflows to export (used with --multi)')
     .option('--docs', 'Include API documentation routes (/docs and /openapi.json)', false)
-    .option('--durable-steps', 'Use deep generator with per-node Inngest steps for durability (inngest target only)', false)
+    .option('--durable-steps', 'Use deep generator with per-node durable steps', false)
     .action(wrapAction(async (input, options) => {
     await exportCommand(input, options);
 }));

package/dist/cli/templates/index.d.ts

@@ -84,13 +84,32 @@ export declare const workflowTemplates: WorkflowTemplate[];
  */
 export declare const nodeTemplates: NodeTemplate[];
 /**
- * Get a workflow template by ID
+ * Get a workflow template by ID.
+ * Checks both core templates and any dynamically loaded pack templates.
  */
 export declare function getWorkflowTemplate(id: string): WorkflowTemplate | undefined;
 /**
  * Get a node template by ID
  */
 export declare function getNodeTemplate(id: string): NodeTemplate | undefined;
+/**
+ * Get all workflow templates including pack-contributed ones.
+ */
+export declare function getAllWorkflowTemplates(): WorkflowTemplate[];
+/**
+ * Register workflow templates contributed by a built-in extension.
+ * Unlike loadPackTemplates (which scans npm packages), this is for
+ * in-tree extensions that register at bootstrap time.
+ */
+export declare function registerWorkflowTemplates(templates: WorkflowTemplate[]): void;
+/**
+ * Load workflow templates from installed pack manifests.
+ * Templates declared in `initContributions.templates` are dynamically imported
+ * and appended to the available template list.
+ *
+ * @param projectDir - Project root to scan for installed packs
+ */
+export declare function loadPackTemplates(projectDir: string): Promise<void>;
 /**
  * Convert a string to camelCase
  */

package/dist/cli/templates/index.js

@@ -13,13 +13,6 @@ import { aiChatTemplate } from './workflows/ai-chat.js';
 import { aggregatorTemplate } from './workflows/aggregator.js';
 import { webhookTemplate } from './workflows/webhook.js';
 import { errorHandlerTemplate } from './workflows/error-handler.js';
-import { aiAgentDurableTemplate } from './workflows/ai-agent-durable.js';
-import { aiPipelineDurableTemplate } from './workflows/ai-pipeline-durable.js';
-// Import CI/CD workflow templates
-import { cicdTestDeployTemplate } from './workflows/cicd-test-deploy.js';
-import { cicdDockerTemplate } from './workflows/cicd-docker.js';
-import { cicdMultiEnvTemplate } from './workflows/cicd-multi-env.js';
-import { cicdMatrixTemplate } from './workflows/cicd-matrix.js';
 // Import node templates
 import { validatorNodeTemplate } from './nodes/validator.js';
 import { transformerNodeTemplate } from './nodes/transformer.js';
@@ -49,12 +42,6 @@ export const workflowTemplates = [
     aggregatorTemplate,
     webhookTemplate,
     errorHandlerTemplate,
-    aiAgentDurableTemplate,
-    aiPipelineDurableTemplate,
-    cicdTestDeployTemplate,
-    cicdDockerTemplate,
-    cicdMultiEnvTemplate,
-    cicdMatrixTemplate,
 ];
 /**
  * All available node templates
@@ -74,10 +61,12 @@ export const nodeTemplates = [
     ragRetrieverNodeTemplate,
 ];
 /**
- * Get a workflow template by ID
+ * Get a workflow template by ID.
+ * Checks both core templates and any dynamically loaded pack templates.
  */
 export function getWorkflowTemplate(id) {
-    return workflowTemplates.find((t) => t.id === id);
+    return workflowTemplates.find((t) => t.id === id)
+        ?? packWorkflowTemplates.find((t) => t.id === id);
 }
 /**
  * Get a node template by ID
@@ -85,6 +74,68 @@ export function getWorkflowTemplate(id) {
 export function getNodeTemplate(id) {
     return nodeTemplates.find((t) => t.id === id);
 }
+/**
+ * Dynamically loaded pack templates. Populated by loadPackTemplates().
+ */
+const packWorkflowTemplates = [];
+/**
+ * Get all workflow templates including pack-contributed ones.
+ */
+export function getAllWorkflowTemplates() {
+    return [...workflowTemplates, ...packWorkflowTemplates];
+}
+/**
+ * Register workflow templates contributed by a built-in extension.
+ * Unlike loadPackTemplates (which scans npm packages), this is for
+ * in-tree extensions that register at bootstrap time.
+ */
+export function registerWorkflowTemplates(templates) {
+    for (const tmpl of templates) {
+        if (!packWorkflowTemplates.some((t) => t.id === tmpl.id)) {
+            packWorkflowTemplates.push(tmpl);
+        }
+    }
+}
+/**
+ * Load workflow templates from installed pack manifests.
+ * Templates declared in `initContributions.templates` are dynamically imported
+ * and appended to the available template list.
+ *
+ * @param projectDir - Project root to scan for installed packs
+ */
+export async function loadPackTemplates(projectDir) {
+    try {
+        const { listInstalledPackages } = await import('../../marketplace/registry.js');
+        const packages = await listInstalledPackages(projectDir);
+        for (const pkg of packages) {
+            const contributions = pkg.manifest.initContributions;
+            if (!contributions?.templates)
+                continue;
+            // Pack templates must be exported from the pack's main entry point
+            // or from a templates.js file alongside the manifest
+            try {
+                const templatesPath = await import('path').then((p) => p.join(pkg.path, 'templates.js'));
+                const { existsSync } = await import('fs');
+                if (!existsSync(templatesPath))
+                    continue;
+                const mod = await import(templatesPath);
+                if (mod.workflowTemplates && Array.isArray(mod.workflowTemplates)) {
+                    for (const tmpl of mod.workflowTemplates) {
+                        if (contributions.templates.includes(tmpl.id)) {
+                            packWorkflowTemplates.push(tmpl);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Skip packs that fail to load templates
+            }
+        }
+    }
+    catch {
+        // Marketplace scanning not available (e.g., no node_modules)
+    }
+}
 /**
  * Convert a string to camelCase
  */

package/dist/cli/templates/nodes/human-approval.js

@@ -30,9 +30,8 @@ export const humanApprovalNodeTemplate = {
 // APPROVAL TYPES
 // ============================================================
 //
-// On Inngest targets, consider using the built-in waitForEvent node instead —
-// it maps to step.waitForEvent() for zero-cost durable pauses.
-// See: https://www.inngest.com/docs/reference/functions/step-wait-for-event
+// On durable targets, consider using the built-in waitForEvent node instead.
+// It maps to a platform-native durable pause for zero-cost waiting.
 
 ${APPROVAL_TYPES}
 

package/dist/cli/templates/nodes/rag-retriever.js

@@ -38,7 +38,7 @@ const MOCK_DOCUMENTS: Record<string, RetrievedDocument[]> = {
     { text: 'Flow Weaver compiles workflows to standalone TypeScript functions.', score: 0.95, metadata: { source: 'docs/overview.md' } },
     { text: 'The compiler validates connections at compile time, catching errors before runtime.', score: 0.88, metadata: { source: 'docs/compiler.md' } },
     { text: 'Workflows are standard TypeScript files with JSDoc annotations.', score: 0.82, metadata: { source: 'docs/authoring.md' } },
-    { text: 'Deploy compiled workflows to Lambda, Vercel, Cloudflare, or Inngest.', score: 0.75, metadata: { source: 'docs/deployment.md' } },
+    { text: 'Deploy compiled workflows to any supported target via installed packs.', score: 0.75, metadata: { source: 'docs/deployment.md' } },
     { text: 'The visual editor provides bidirectional editing — code changes update the canvas and vice versa.', score: 0.71, metadata: { source: 'docs/editor.md' } },
   ],
 };

package/dist/constants.d.ts

@@ -81,6 +81,8 @@ export declare function isReservedPortName(name: string): name is ReservedPortNa
 export declare function isStartNode(nodeName: string): boolean;
 export declare function isExitNode(nodeName: string): boolean;
 export declare function isSpecialNode(nodeName: string): boolean;
+/** Pseudo-nodes like `secret:NAME` are connection sources that don't correspond to real node instances. */
+export declare function isPseudoNode(nodeName: string): boolean;
 export declare function isExecutePort(portName: string): boolean;
 export declare function isSuccessPort(portName: string): boolean;
 export declare function isFailurePort(portName: string): boolean;
@@ -103,4 +105,9 @@ export declare const KNOWN_NODETYPE_TAGS: Set<string>;
 export declare const KNOWN_WORKFLOW_TAGS: Set<string>;
 export declare const KNOWN_PATTERN_TAGS: Set<string>;
 export declare const STANDARD_JSDOC_TAGS: Set<string>;
+/**
+ * Build a dynamic known-workflow-tags set that includes core tags
+ * plus any extra tags contributed by pack registries.
+ */
+export declare function getKnownWorkflowTags(extraTags?: string[]): Set<string>;
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -88,6 +88,10 @@ export function isExitNode(nodeName) {
 export function isSpecialNode(nodeName) {
     return isStartNode(nodeName) || isExitNode(nodeName);
 }
+/** Pseudo-nodes like `secret:NAME` are connection sources that don't correspond to real node instances. */
+export function isPseudoNode(nodeName) {
+    return nodeName.startsWith('secret:');
+}
 export function isExecutePort(portName) {
     return portName === RESERVED_PORT_NAMES.EXECUTE;
 }
@@ -138,9 +142,6 @@ export const KNOWN_WORKFLOW_TAGS = new Set([
     'node', 'position', 'connect', 'scope', 'map', 'path', 'fanOut', 'fanIn',
     'coerce', 'trigger', 'cancelOn', 'retries', 'timeout', 'throttle', 'param',
     'return', 'returns',
-    // CI/CD annotations
-    'secret', 'runner', 'cache', 'artifact', 'environment', 'matrix',
-    'service', 'concurrency',
     // Deployment annotations
     'deploy',
 ]);
@@ -151,4 +152,13 @@ export const STANDARD_JSDOC_TAGS = new Set([
     'example', 'see', 'deprecated', 'type', 'typedef', 'template',
     'link', 'since', 'version', 'author',
 ]);
+/**
+ * Build a dynamic known-workflow-tags set that includes core tags
+ * plus any extra tags contributed by pack registries.
+ */
+export function getKnownWorkflowTags(extraTags) {
+    if (!extraTags || extraTags.length === 0)
+        return KNOWN_WORKFLOW_TAGS;
+    return new Set([...KNOWN_WORKFLOW_TAGS, ...extraTags]);
+}
 //# sourceMappingURL=constants.js.map

package/dist/context/index.js

@@ -4,7 +4,7 @@
  * Composes Flow Weaver documentation, annotation grammar, and a profile-specific
  * preamble into a single markdown document suitable for LLM consumption.
  */
-import { readTopic, listTopics } from '../docs/index.js';
+import { readTopic, listTopics, getPackDocTopics } from '../docs/index.js';
 import { getAllGrammars, serializedToEBNF } from '../chevrotain-parser/grammar-diagrams.js';
 // ---------------------------------------------------------------------------
 // Presets
@@ -82,7 +82,13 @@ Tool quick reference:
 - fw_diagram: Visualize. Prefer format "ascii-compact" in chat contexts
 - fw_compile: Generate executable TypeScript from annotations
 - fw_docs: Look up reference docs by topic slug
-- fw_scaffold: Create from templates (sequential, foreach, ai-agent, etc.)
+- fw_scaffold: Create from templates (sequential, foreach, ai-agent, cicd-test-deploy, cicd-docker, etc.)
+- fw_export: Deploy to cloud or generate CI/CD pipelines (targets depend on installed packs)
+
+Flow Weaver can also generate CI/CD pipelines. Use @secret, @runner, @trigger,
+@cache, @matrix, and [job: "name"] annotations to define pipeline structure,
+then export to GitHub Actions YAML or GitLab CI YAML with fw_export.
+For details: fw_docs(action="read", topic="cicd")
 
 File conventions: .ts extension, camelCase node names, PascalCase workflow names.`;
 }
@@ -91,7 +97,11 @@ File conventions: .ts extension, camelCase node names, PascalCase workflow names
 // ---------------------------------------------------------------------------
 export function resolveTopics(preset, explicit, add) {
     const base = explicit ?? PRESETS[preset];
-    const combined = add ? [...base, ...add] : base;
+    // Append pack doc topics that declare this preset
+    const packSlugs = getPackDocTopics()
+        .filter((t) => t.presets?.includes(preset))
+        .map((t) => t.slug);
+    const combined = [...base, ...packSlugs, ...(add ?? [])];
     // Deduplicate while preserving order
     return [...new Set(combined)];
 }

package/dist/deployment/config/loader.js

@@ -6,6 +6,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { pathToFileURL } from 'url';
 import * as YAML from 'js-yaml';
 import { DEFAULT_CONFIG, getDefaultConfig } from './defaults.js';
 /**
@@ -102,7 +103,7 @@ async function loadConfigFromPath(filePath) {
     // TypeScript files - dynamic import
     if (ext === '.ts') {
         try {
-            const module = await import(absolutePath);
+            const module = await import(pathToFileURL(absolutePath).href);
             return (module.default || module);
         }
         catch {

package/dist/deployment/core/adapters.d.ts

@@ -3,7 +3,7 @@
  *
  * Each adapter transforms source-specific input into a unified WorkflowRequest.
  */
-import type { WorkflowRequest, ExecutionContext, ValidationResult, CliInput, HttpInput, LambdaInput, VercelInput, CloudflareInput, Environment } from '../types.js';
+import type { WorkflowRequest, ExecutionContext, ValidationResult, CliInput, HttpInput, Environment } from '../types.js';
 /**
  * Request adapter interface
  */
@@ -57,34 +57,10 @@ export declare class CliRequestAdapter extends BaseRequestAdapter<CliInput> {
 export declare class HttpRequestAdapter extends BaseRequestAdapter<HttpInput> {
     parseRequest(input: HttpInput): WorkflowRequest;
 }
-/**
- * AWS Lambda request adapter
- *
- * Parses API Gateway event into a WorkflowRequest
- */
-export declare class LambdaRequestAdapter extends BaseRequestAdapter<LambdaInput> {
-    parseRequest(input: LambdaInput): WorkflowRequest;
-}
-/**
- * Vercel serverless function request adapter
- */
-export declare class VercelRequestAdapter extends BaseRequestAdapter<VercelInput> {
-    parseRequest(input: VercelInput): WorkflowRequest;
-}
-/**
- * Cloudflare Workers request adapter
- */
-export declare class CloudflareRequestAdapter extends BaseRequestAdapter<CloudflareInput> {
-    parseRequestAsync(input: CloudflareInput): Promise<WorkflowRequest>;
-    parseRequest(_input: CloudflareInput): WorkflowRequest;
-}
 /**
  * Create the appropriate adapter for a given source
  */
 export declare function createAdapter(source: 'cli'): CliRequestAdapter;
 export declare function createAdapter(source: 'http'): HttpRequestAdapter;
-export declare function createAdapter(source: 'lambda'): LambdaRequestAdapter;
-export declare function createAdapter(source: 'vercel'): VercelRequestAdapter;
-export declare function createAdapter(source: 'cloudflare'): CloudflareRequestAdapter;
 export {};
 //# sourceMappingURL=adapters.d.ts.map

package/dist/deployment/core/adapters.js

@@ -145,107 +145,12 @@ export class HttpRequestAdapter extends BaseRequestAdapter {
         };
     }
 }
-/**
- * AWS Lambda request adapter
- *
- * Parses API Gateway event into a WorkflowRequest
- */
-export class LambdaRequestAdapter extends BaseRequestAdapter {
-    parseRequest(input) {
-        // Parse body
-        let params = {};
-        if (typeof input.body === 'string') {
-            try {
-                params = JSON.parse(input.body || '{}');
-            }
-            catch {
-                params = {};
-            }
-        }
-        else if (input.body && typeof input.body === 'object') {
-            params = input.body;
-        }
-        // Get workflow ID from path parameters
-        const workflowId = input.pathParameters?.name ||
-            input.pathParameters?.workflow ||
-            input.pathParameters?.id ||
-            '';
-        const includeTrace = input.queryStringParameters?.trace === 'true';
-        const isProduction = input.requestContext?.stage === 'prod' || input.requestContext?.stage === 'production';
-        return {
-            workflowId,
-            params,
-            context: this.createContext('lambda', {
-                requestId: input.requestContext?.requestId,
-                includeTrace,
-                environment: isProduction ? 'production' : 'development',
-            }),
-        };
-    }
-}
-/**
- * Vercel serverless function request adapter
- */
-export class VercelRequestAdapter extends BaseRequestAdapter {
-    parseRequest(input) {
-        // Workflow ID comes from the file-based routing in Vercel
-        // The caller should provide it, or we extract from query
-        const workflowId = input.query.workflow || input.query.name || '';
-        const includeTrace = input.query.trace === 'true';
-        return {
-            workflowId,
-            params: input.body || {},
-            context: this.createContext('vercel', {
-                requestId: input.headers['x-vercel-id'],
-                includeTrace,
-            }),
-        };
-    }
-}
-/**
- * Cloudflare Workers request adapter
- */
-export class CloudflareRequestAdapter extends BaseRequestAdapter {
-    async parseRequestAsync(input) {
-        // Parse body
-        let params = {};
-        try {
-            params = await input.request.json();
-        }
-        catch {
-            params = {};
-        }
-        // Extract workflow ID from URL path
-        const url = new URL(input.request.url);
-        const pathParts = url.pathname.split('/').filter(Boolean);
-        const workflowId = pathParts[pathParts.length - 1] || '';
-        const includeTrace = url.searchParams.get('trace') === 'true';
-        return {
-            workflowId,
-            params,
-            context: this.createContext('cloudflare', {
-                requestId: input.request.headers.get('cf-ray') || undefined,
-                includeTrace,
-            }),
-        };
-    }
-    // Sync version throws - use parseRequestAsync for Cloudflare
-    parseRequest(_input) {
-        throw new Error('Use parseRequestAsync for Cloudflare Workers');
-    }
-}
 export function createAdapter(source) {
     switch (source) {
         case 'cli':
             return new CliRequestAdapter();
         case 'http':
             return new HttpRequestAdapter();
-        case 'lambda':
-            return new LambdaRequestAdapter();
-        case 'vercel':
-            return new VercelRequestAdapter();
-        case 'cloudflare':
-            return new CloudflareRequestAdapter();
     }
 }
 //# sourceMappingURL=adapters.js.map

package/dist/deployment/core/formatters.d.ts

@@ -27,21 +27,6 @@ export declare function formatHttpResponse<T>(response: WorkflowResponse<T>): {
     body: Record<string, unknown>;
     headers: Record<string, string>;
 };
-/**
- * Format response for AWS Lambda (API Gateway response format)
- */
-export declare function formatLambdaResponse<T>(response: WorkflowResponse<T>): {
-    statusCode: number;
-    headers: Record<string, string>;
-    body: string;
-};
-/**
- * Format response for Cloudflare Workers (returns Response object constructor args)
- */
-export declare function formatCloudflareResponse<T>(response: WorkflowResponse<T>): {
-    body: string;
-    init: ResponseInit;
-};
 /**
  * Format error for consistent error responses
  */

package/dist/deployment/core/formatters.js

@@ -117,30 +117,6 @@ export function formatHttpResponse(response) {
         headers,
     };
 }
-/**
- * Format response for AWS Lambda (API Gateway response format)
- */
-export function formatLambdaResponse(response) {
-    const httpResponse = formatHttpResponse(response);
-    return {
-        statusCode: httpResponse.statusCode,
-        headers: httpResponse.headers,
-        body: JSON.stringify(httpResponse.body),
-    };
-}
-/**
- * Format response for Cloudflare Workers (returns Response object constructor args)
- */
-export function formatCloudflareResponse(response) {
-    const httpResponse = formatHttpResponse(response);
-    return {
-        body: JSON.stringify(httpResponse.body),
-        init: {
-            status: httpResponse.statusCode,
-            headers: httpResponse.headers,
-        },
-    };
-}
 /**
  * Format error for consistent error responses
  */

package/dist/deployment/index.d.ts

@@ -5,19 +5,21 @@
  *
  * @module deployment
  */
-export type { ExecutionSource, Environment, ExecutionContext, WorkflowRequest, WorkflowResponse, WorkflowError, WorkflowErrorCode, ValidationResult, ValidationError, CliInput, HttpInput, LambdaInput, VercelInput, CloudflareInput, AdapterInput, } from './types.js';
+export type { ExecutionSource, Environment, ExecutionContext, WorkflowRequest, WorkflowResponse, WorkflowError, WorkflowErrorCode, ValidationResult, ValidationError, CliInput, HttpInput, AdapterInput, } from './types.js';
 export { UnifiedWorkflowExecutor, createExecutor, type ExecutorOptions } from './core/executor.js';
-export { type RequestAdapter, CliRequestAdapter, HttpRequestAdapter, LambdaRequestAdapter, VercelRequestAdapter, CloudflareRequestAdapter, createAdapter, } from './core/adapters.js';
-export { formatCliResponse, formatHttpResponse, formatLambdaResponse, formatCloudflareResponse, formatError, type CliOutputOptions, } from './core/formatters.js';
+export { type RequestAdapter, CliRequestAdapter, HttpRequestAdapter, createAdapter, } from './core/adapters.js';
+export { formatCliResponse, formatHttpResponse, formatError, type CliOutputOptions, } from './core/formatters.js';
 export type { DeploymentConfig, ServerConfig, ExecutionConfig, SecretsConfig, CorsConfig, RetryConfig, PartialDeploymentConfig, CliConfigOverrides, } from './config/types.js';
 export { DEFAULT_CONFIG, DEFAULT_SERVER_CONFIG, DEFAULT_EXECUTION_CONFIG, getDefaultConfig, } from './config/defaults.js';
 export { loadConfig, loadConfigSync, getConfigValue } from './config/loader.js';
 export { OpenAPIGenerator, generateOpenAPIJson, generateOpenAPIYaml, type OpenAPIDocument, type OpenAPIInfo, type OpenAPIServer, type GeneratorOptions, } from './openapi/generator.js';
 export { SchemaConverter, schemaConverter, type OpenAPISchema, } from './openapi/schema-converter.js';
 export { type ExportTarget, type ExportOptions, type ExportArtifacts, type GeneratedFile, type DeployInstructions, type DeploySchema, type DeploySchemaField, type CompiledWorkflow, type MultiWorkflowArtifacts, type NodeTypeInfo, type NodeTypeExportOptions, type NodeTypeArtifacts, type BundleWorkflow, type BundleNodeType, type BundleArtifacts, BaseExportTarget, ExportTargetRegistry, } from './targets/base.js';
-export { isCICDWorkflow } from '../validation/cicd-detection.js';
+/** @deprecated Import from '@synergenius/flow-weaver/extensions/cicd' instead */
+export { isCICDWorkflow } from '../extensions/cicd/detection.js';
 export { generateStandaloneRuntimeModule } from '../api/inline-runtime.js';
-export { BaseCICDTarget, NODE_ACTION_MAP, type CICDStep, type CICDJob, type ActionMapping, } from './targets/cicd-base.js';
+/** @deprecated Import from '@synergenius/flow-weaver/extensions/cicd' instead */
+export { BaseCICDTarget, NODE_ACTION_MAP, type CICDStep, type CICDJob, type ActionMapping, } from '../extensions/cicd/base-target.js';
 import { ExportTargetRegistry } from './targets/base.js';
 /**
  * Create an export target registry via marketplace discovery.

package/dist/deployment/index.js

@@ -8,9 +8,9 @@
 // Core - Executor
 export { UnifiedWorkflowExecutor, createExecutor } from './core/executor.js';
 // Core - Adapters
-export { CliRequestAdapter, HttpRequestAdapter, LambdaRequestAdapter, VercelRequestAdapter, CloudflareRequestAdapter, createAdapter, } from './core/adapters.js';
+export { CliRequestAdapter, HttpRequestAdapter, createAdapter, } from './core/adapters.js';
 // Core - Formatters
-export { formatCliResponse, formatHttpResponse, formatLambdaResponse, formatCloudflareResponse, formatError, } from './core/formatters.js';
+export { formatCliResponse, formatHttpResponse, formatError, } from './core/formatters.js';
 export { DEFAULT_CONFIG, DEFAULT_SERVER_CONFIG, DEFAULT_EXECUTION_CONFIG, getDefaultConfig, } from './config/defaults.js';
 export { loadConfig, loadConfigSync, getConfigValue } from './config/loader.js';
 // OpenAPI
@@ -19,10 +19,13 @@ export { SchemaConverter, schemaConverter, } from './openapi/schema-converter.js
 // Export Targets
 export { BaseExportTarget, ExportTargetRegistry, } from './targets/base.js';
 // Utilities needed by export target packs
-export { isCICDWorkflow } from '../validation/cicd-detection.js';
+/** @deprecated Import from '@synergenius/flow-weaver/extensions/cicd' instead */
+export { isCICDWorkflow } from '../extensions/cicd/detection.js';
 export { generateStandaloneRuntimeModule } from '../api/inline-runtime.js';
-export { BaseCICDTarget, NODE_ACTION_MAP, } from './targets/cicd-base.js';
+/** @deprecated Import from '@synergenius/flow-weaver/extensions/cicd' instead */
+export { BaseCICDTarget, NODE_ACTION_MAP, } from '../extensions/cicd/base-target.js';
 import * as path from 'path';
+import { pathToFileURL } from 'url';
 import { ExportTargetRegistry } from './targets/base.js';
 /**
  * Create an export target registry via marketplace discovery.
@@ -45,7 +48,7 @@ export async function createTargetRegistry(projectDir) {
                 const filePath = path.join(pkg.path, def.file);
                 // Dynamic import is async, so we resolve the module here
                 // but defer instantiation to the lazy factory
-                const mod = await import(filePath);
+                const mod = await import(pathToFileURL(filePath).href);
                 const TargetClass = def.exportName ? mod[def.exportName] : mod.default;
                 registry.register(def.name, () => new TargetClass());
             }