@synergenius/flow-weaver 0.13.3 → 0.14.0

package/dist/cli/templates/index.js

@@ -15,6 +15,11 @@ 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';
@@ -46,6 +51,10 @@ export const workflowTemplates = [
     errorHandlerTemplate,
     aiAgentDurableTemplate,
     aiPipelineDurableTemplate,
+    cicdTestDeployTemplate,
+    cicdDockerTemplate,
+    cicdMultiEnvTemplate,
+    cicdMatrixTemplate,
 ];
 /**
  * All available node templates

package/dist/cli/templates/workflows/cicd-docker.d.ts

@@ -0,0 +1,9 @@
+/**
+ * CI/CD: Docker Pipeline template
+ *
+ * Generates a Flow Weaver workflow for building and pushing Docker images:
+ * checkout → docker-login → docker-build → docker-push
+ */
+import type { WorkflowTemplate } from '../index.js';
+export declare const cicdDockerTemplate: WorkflowTemplate;
+//# sourceMappingURL=cicd-docker.d.ts.map

package/dist/cli/templates/workflows/cicd-docker.js

@@ -0,0 +1,110 @@
+/**
+ * CI/CD: Docker Pipeline template
+ *
+ * Generates a Flow Weaver workflow for building and pushing Docker images:
+ * checkout → docker-login → docker-build → docker-push
+ */
+const configSchema = {
+    platform: {
+        type: 'select',
+        label: 'CI/CD Platform',
+        default: 'github-actions',
+        options: [
+            { value: 'github-actions', label: 'GitHub Actions' },
+            { value: 'gitlab-ci', label: 'GitLab CI' },
+        ],
+    },
+    registry: {
+        type: 'select',
+        label: 'Container Registry',
+        default: 'ghcr',
+        options: [
+            { value: 'ghcr', label: 'GitHub Container Registry (ghcr.io)' },
+            { value: 'dockerhub', label: 'Docker Hub' },
+            { value: 'ecr', label: 'AWS ECR' },
+            { value: 'gcr', label: 'Google Container Registry' },
+        ],
+    },
+};
+export const cicdDockerTemplate = {
+    id: 'cicd-docker',
+    name: 'CI/CD: Docker Pipeline',
+    description: 'Build and push Docker images to a container registry',
+    category: 'automation',
+    configSchema,
+    generate: (opts) => {
+        const name = opts.workflowName || 'dockerPipeline';
+        const registry = opts.config?.registry || 'ghcr';
+        const registrySecrets = {
+            ghcr: ' * @secret GITHUB_TOKEN - GitHub token for ghcr.io',
+            dockerhub: ' * @secret DOCKER_USERNAME - Docker Hub username\n * @secret DOCKER_PASSWORD - Docker Hub password',
+            ecr: ' * @secret AWS_ACCESS_KEY_ID - AWS access key\n * @secret AWS_SECRET_ACCESS_KEY - AWS secret key',
+            gcr: ' * @secret GCR_KEY - Google Cloud service account key',
+        };
+        const registryConnect = {
+            ghcr: ' * @connect secret:GITHUB_TOKEN -> login.token',
+            dockerhub: ' * @connect secret:DOCKER_USERNAME -> login.username\n * @connect secret:DOCKER_PASSWORD -> login.password',
+            ecr: ' * @connect secret:AWS_ACCESS_KEY_ID -> login.accessKey\n * @connect secret:AWS_SECRET_ACCESS_KEY -> login.secretKey',
+            gcr: ' * @connect secret:GCR_KEY -> login.serviceAccountKey',
+        };
+        return `/** @flowWeaver nodeType
+ * @expression
+ * @label Checkout code
+ */
+function checkout(): { repo: string } { return { repo: '.' }; }
+
+/** @flowWeaver nodeType
+ * @expression
+ * @label Docker login
+ */
+function dockerLogin(${registry === 'dockerhub' ? 'username: string = \'\', password: string = \'\'' : registry === 'ecr' ? 'accessKey: string = \'\', secretKey: string = \'\'' : registry === 'gcr' ? 'serviceAccountKey: string = \'\'' : 'token: string = \'\''}): { loggedIn: boolean } { return { loggedIn: true }; }
+
+/** @flowWeaver nodeType
+ * @expression
+ * @label Docker build
+ */
+function dockerBuild(): { imageTag: string } { return { imageTag: 'latest' }; }
+
+/** @flowWeaver nodeType
+ * @expression
+ * @label Docker push
+ */
+function dockerPush(): { digest: string } { return { digest: 'sha256:abc123' }; }
+
+/**
+ * @flowWeaver workflow
+ * @trigger push branches="main" paths="Dockerfile,src/**"
+ * @trigger tag pattern="v*"
+ * @runner ubuntu-latest
+${registrySecrets[registry]}
+ *
+ * @node co checkout [job: "build"] [position: 270 0]
+ * @node login dockerLogin [job: "build"] [position: 540 0]
+ * @node build dockerBuild [job: "build"] [position: 810 0]
+ * @node push dockerPush [job: "build"] [position: 1080 0]
+ *
+ * @path Start -> co -> login -> build -> push -> Exit
+ * @position Start 0 0
+ * @position Exit 1350 0
+${registryConnect[registry]}
+ * @connect push.digest -> Exit.imageDigest
+ *
+ * @param execute [order:-1] - Execute
+ * @param params [order:0] - Params
+ * @returns onSuccess [order:-2] - On Success
+ * @returns onFailure [order:-1] - On Failure
+ * @returns imageDigest [order:0] - Docker image digest
+ */
+export async function ${name}(
+  execute: boolean,
+  params: Record<string, never> = {},
+): Promise<{ onSuccess: boolean; onFailure: boolean; imageDigest: string | null }> {
+  // @flow-weaver-body-start
+  throw new Error('Compile with: npx flow-weaver compile <this-file>');
+  // @flow-weaver-body-end
+  return { onSuccess: false, onFailure: true, imageDigest: null };
+}
+`;
+    },
+};
+//# sourceMappingURL=cicd-docker.js.map

package/dist/cli/templates/workflows/cicd-matrix.d.ts

@@ -0,0 +1,9 @@
+/**
+ * CI/CD: Matrix Testing template
+ *
+ * Generates a pipeline with matrix strategy for testing across
+ * multiple Node.js versions and/or operating systems.
+ */
+import type { WorkflowTemplate } from '../index.js';
+export declare const cicdMatrixTemplate: WorkflowTemplate;
+//# sourceMappingURL=cicd-matrix.d.ts.map

package/dist/cli/templates/workflows/cicd-matrix.js

@@ -0,0 +1,112 @@
+/**
+ * CI/CD: Matrix Testing template
+ *
+ * Generates a pipeline with matrix strategy for testing across
+ * multiple Node.js versions and/or operating systems.
+ */
+const configSchema = {
+    platform: {
+        type: 'select',
+        label: 'CI/CD Platform',
+        default: 'github-actions',
+        options: [
+            { value: 'github-actions', label: 'GitHub Actions' },
+            { value: 'gitlab-ci', label: 'GitLab CI' },
+        ],
+    },
+    versions: {
+        type: 'string',
+        label: 'Node.js Versions',
+        description: 'Comma-separated versions to test',
+        default: '18,20,22',
+    },
+    operatingSystems: {
+        type: 'string',
+        label: 'Operating Systems',
+        description: 'Comma-separated OS labels',
+        default: 'ubuntu-latest',
+    },
+};
+export const cicdMatrixTemplate = {
+    id: 'cicd-matrix',
+    name: 'CI/CD: Matrix Testing',
+    description: 'Test across multiple Node.js versions and operating systems',
+    category: 'automation',
+    configSchema,
+    generate: (opts) => {
+        const name = opts.workflowName || 'matrixTest';
+        const versions = (opts.config?.versions || '18,20,22')
+            .split(',')
+            .map((v) => v.trim());
+        const oses = (opts.config?.operatingSystems || 'ubuntu-latest')
+            .split(',')
+            .map((o) => o.trim());
+        const matrixNode = ` * @matrix node="${versions.join(',')}" os="${oses.join(',')}"`;
+        return `/** @flowWeaver nodeType
+ * @expression
+ * @label Checkout code
+ */
+function checkout(): { repo: string } { return { repo: '.' }; }
+
+/** @flowWeaver nodeType
+ * @expression
+ * @label Setup Node.js
+ */
+function setupNode(): { nodeVersion: string } { return { nodeVersion: '20' }; }
+
+/** @flowWeaver nodeType
+ * @expression
+ * @label Install dependencies
+ */
+function npmInstall(): { installed: boolean } { return { installed: true }; }
+
+/** @flowWeaver nodeType
+ * @expression
+ * @label Run shell command
+ */
+function shellCommand(): { exitCode: number } { return { exitCode: 0 }; }
+
+/** @flowWeaver nodeType
+ * @expression
+ * @label Run tests
+ */
+function npmTest(): { exitCode: number } { return { exitCode: 0 }; }
+
+/**
+ * @flowWeaver workflow
+ * @trigger push branches="main"
+ * @trigger pull_request branches="main"
+ * @runner ubuntu-latest
+${matrixNode}
+ * @cache npm key="package-lock.json"
+ *
+ * @node co checkout [job: "test"] [position: 270 0]
+ * @node setup setupNode [job: "test"] [position: 540 0]
+ * @node install npmInstall [job: "test"] [position: 810 0]
+ * @node lint shellCommand [job: "test"] [position: 1080 0]
+ * @node test npmTest [job: "test"] [position: 1350 0]
+ *
+ * @path Start -> co -> setup -> install -> lint -> test -> Exit
+ * @position Start 0 0
+ * @position Exit 1620 0
+ * @connect test.exitCode -> Exit.testResult
+ *
+ * @param execute [order:-1] - Execute
+ * @param params [order:0] - Params
+ * @returns onSuccess [order:-2] - On Success
+ * @returns onFailure [order:-1] - On Failure
+ * @returns testResult [order:0] - Test result
+ */
+export async function ${name}(
+  execute: boolean,
+  params: Record<string, never> = {},
+): Promise<{ onSuccess: boolean; onFailure: boolean; testResult: string | null }> {
+  // @flow-weaver-body-start
+  throw new Error('Compile with: npx flow-weaver compile <this-file>');
+  // @flow-weaver-body-end
+  return { onSuccess: false, onFailure: true, testResult: null };
+}
+`;
+    },
+};
+//# sourceMappingURL=cicd-matrix.js.map

package/dist/cli/templates/workflows/cicd-multi-env.d.ts

@@ -0,0 +1,9 @@
+/**
+ * CI/CD: Multi-Environment Deploy template
+ *
+ * Generates a pipeline with staging → production promotion:
+ * test → deploy-staging → deploy-production (with environment protection)
+ */
+import type { WorkflowTemplate } from '../index.js';
+export declare const cicdMultiEnvTemplate: WorkflowTemplate;
+//# sourceMappingURL=cicd-multi-env.d.ts.map

package/dist/cli/templates/workflows/cicd-multi-env.js

@@ -0,0 +1,118 @@
+/**
+ * CI/CD: Multi-Environment Deploy template
+ *
+ * Generates a pipeline with staging → production promotion:
+ * test → deploy-staging → deploy-production (with environment protection)
+ */
+const configSchema = {
+    platform: {
+        type: 'select',
+        label: 'CI/CD Platform',
+        default: 'github-actions',
+        options: [
+            { value: 'github-actions', label: 'GitHub Actions' },
+            { value: 'gitlab-ci', label: 'GitLab CI' },
+        ],
+    },
+    environments: {
+        type: 'string',
+        label: 'Environments',
+        description: 'Comma-separated environment names',
+        default: 'staging,production',
+    },
+};
+export const cicdMultiEnvTemplate = {
+    id: 'cicd-multi-env',
+    name: 'CI/CD: Multi-Environment',
+    description: 'Multi-environment deployment pipeline with staging and production stages',
+    category: 'automation',
+    configSchema,
+    generate: (opts) => {
+        const name = opts.workflowName || 'multiEnvPipeline';
+        const envs = (opts.config?.environments || 'staging,production')
+            .split(',')
+            .map((e) => e.trim());
+        const envAnnotations = envs
+            .map((env) => ` * @environment ${env} url="https://${env}.example.com"`)
+            .join('\n');
+        let x = 270;
+        const nodeAnnotations = [];
+        const pathParts = ['Start'];
+        // Test job
+        nodeAnnotations.push(` * @node co checkout [job: "test"] [position: ${x} 0]`);
+        pathParts.push('co');
+        x += 270;
+        nodeAnnotations.push(` * @node test npmTest [job: "test"] [position: ${x} 0]`);
+        pathParts.push('test');
+        x += 270;
+        nodeAnnotations.push(` * @node build npmBuild [job: "build"] [position: ${x} 0]`);
+        pathParts.push('build');
+        x += 270;
+        // Deploy jobs for each environment
+        for (const env of envs) {
+            const id = `deploy_${env.replace(/[^a-zA-Z0-9]/g, '_')}`;
+            nodeAnnotations.push(` * @node ${id} deploySsh [job: "deploy-${env}"] [environment: "${env}"] [position: ${x} 0]`);
+            pathParts.push(id);
+            x += 270;
+        }
+        pathParts.push('Exit');
+        return `/** @flowWeaver nodeType
+ * @expression
+ * @label Checkout code
+ */
+function checkout(): { repo: string } { return { repo: '.' }; }
+
+/** @flowWeaver nodeType
+ * @expression
+ * @label Run tests
+ */
+function npmTest(): { exitCode: number } { return { exitCode: 0 }; }
+
+/** @flowWeaver nodeType
+ * @expression
+ * @label Build project
+ */
+function npmBuild(): { output: string } { return { output: 'dist/' }; }
+
+/** @flowWeaver nodeType
+ * @expression
+ * @label Deploy via SSH
+ */
+function deploySsh(sshKey: string = ''): { result: string } { return { result: 'deployed' }; }
+
+/**
+ * @flowWeaver workflow
+ * @trigger push branches="main"
+ * @runner ubuntu-latest
+ * @secret DEPLOY_KEY - SSH deployment key
+${envAnnotations}
+ * @cache npm key="package-lock.json"
+ * @artifact dist path="dist/" retention=3
+ *
+${nodeAnnotations.join('\n')}
+ *
+ * @path ${pathParts.join(' -> ')}
+ * @position Start 0 0
+ * @position Exit ${x} 0
+ * @connect secret:DEPLOY_KEY -> ${`deploy_${envs[0].replace(/[^a-zA-Z0-9]/g, '_')}`}.sshKey
+${envs.slice(1).map((env) => ` * @connect secret:DEPLOY_KEY -> deploy_${env.replace(/[^a-zA-Z0-9]/g, '_')}.sshKey`).join('\n')}
+ *
+ * @param execute [order:-1] - Execute
+ * @param params [order:0] - Params
+ * @returns onSuccess [order:-2] - On Success
+ * @returns onFailure [order:-1] - On Failure
+ * @returns summary [order:0] - Deployment summary
+ */
+export async function ${name}(
+  execute: boolean,
+  params: Record<string, never> = {},
+): Promise<{ onSuccess: boolean; onFailure: boolean; summary: string | null }> {
+  // @flow-weaver-body-start
+  throw new Error('Compile with: npx flow-weaver compile <this-file>');
+  // @flow-weaver-body-end
+  return { onSuccess: false, onFailure: true, summary: null };
+}
+`;
+    },
+};
+//# sourceMappingURL=cicd-multi-env.js.map

package/dist/cli/templates/workflows/cicd-test-deploy.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CI/CD: Test and Deploy template
+ *
+ * Generates a Flow Weaver workflow for a standard CI/CD pipeline:
+ * checkout → setup → install → test → build → deploy
+ *
+ * Exports to GitHub Actions or GitLab CI via `fw_export`.
+ */
+import type { WorkflowTemplate } from '../index.js';
+export declare const cicdTestDeployTemplate: WorkflowTemplate;
+//# sourceMappingURL=cicd-test-deploy.d.ts.map

package/dist/cli/templates/workflows/cicd-test-deploy.js

@@ -0,0 +1,149 @@
+/**
+ * CI/CD: Test and Deploy template
+ *
+ * Generates a Flow Weaver workflow for a standard CI/CD pipeline:
+ * checkout → setup → install → test → build → deploy
+ *
+ * Exports to GitHub Actions or GitLab CI via `fw_export`.
+ */
+const configSchema = {
+    platform: {
+        type: 'select',
+        label: 'CI/CD Platform',
+        description: 'Target CI/CD platform for export',
+        default: 'github-actions',
+        options: [
+            { value: 'github-actions', label: 'GitHub Actions' },
+            { value: 'gitlab-ci', label: 'GitLab CI' },
+        ],
+    },
+    nodeVersion: {
+        type: 'string',
+        label: 'Node.js Version',
+        default: '20',
+        description: 'Node.js version for setup-node step',
+    },
+    deployTarget: {
+        type: 'select',
+        label: 'Deploy Method',
+        default: 'ssh',
+        options: [
+            { value: 'ssh', label: 'SSH Deploy' },
+            { value: 's3', label: 'AWS S3' },
+            { value: 'none', label: 'No deploy (test only)' },
+        ],
+    },
+};
+export const cicdTestDeployTemplate = {
+    id: 'cicd-test-deploy',
+    name: 'CI/CD: Test and Deploy',
+    description: 'Standard test-and-deploy pipeline with checkout, setup, test, build, and deploy stages',
+    category: 'automation',
+    configSchema,
+    generate: (opts) => {
+        const name = opts.workflowName || 'ciPipeline';
+        const deployTarget = opts.config?.deployTarget || 'ssh';
+        const hasDeploy = deployTarget !== 'none';
+        const deployNodeType = deployTarget === 'ssh' ? 'deploySsh' : 'deployS3';
+        const deployNode = hasDeploy
+            ? `\n * @node deploy ${deployNodeType} [job: "deploy"] [environment: "production"] [position: 1620 0]`
+            : '';
+        const deployPath = hasDeploy ? ' -> deploy' : '';
+        const deploySecret = deployTarget === 'ssh'
+            ? '\n * @secret DEPLOY_KEY - SSH key for deployment'
+            : deployTarget === 's3'
+                ? '\n * @secret AWS_ACCESS_KEY_ID - AWS access key\n * @secret AWS_SECRET_ACCESS_KEY - AWS secret key'
+                : '';
+        const deployConnect = deployTarget === 'ssh'
+            ? '\n * @connect secret:DEPLOY_KEY -> deploy.sshKey'
+            : deployTarget === 's3'
+                ? '\n * @connect secret:AWS_ACCESS_KEY_ID -> deploy.accessKey\n * @connect secret:AWS_SECRET_ACCESS_KEY -> deploy.secretKey'
+                : '';
+        const deployReturns = hasDeploy ? '\n * @returns deployResult [order:3] - Deploy result' : '';
+        const deployConnect2 = hasDeploy ? '\n * @connect deploy.result -> Exit.deployResult' : '';
+        const deployStub = hasDeploy
+            ? deployTarget === 'ssh'
+                ? `
+/** @flowWeaver nodeType
+ * @expression
+ * @label Deploy via SSH
+ */
+function deploySsh(sshKey: string = ''): { result: string } { return { result: 'deployed' }; }
+`
+                : `
+/** @flowWeaver nodeType
+ * @expression
+ * @label Deploy to S3
+ */
+function deployS3(accessKey: string = '', secretKey: string = ''): { result: string } { return { result: 'deployed' }; }
+`
+            : '';
+        return `/** @flowWeaver nodeType
+ * @expression
+ * @label Checkout code
+ */
+function checkout(): { repo: string } { return { repo: '.' }; }
+
+/** @flowWeaver nodeType
+ * @expression
+ * @label Setup Node.js
+ */
+function setupNode(): { nodeVersion: string } { return { nodeVersion: '20' }; }
+
+/** @flowWeaver nodeType
+ * @expression
+ * @label Install dependencies
+ */
+function npmInstall(npmToken: string = ''): { installed: boolean } { return { installed: true }; }
+
+/** @flowWeaver nodeType
+ * @expression
+ * @label Run tests
+ */
+function npmTest(): { exitCode: number } { return { exitCode: 0 }; }
+
+/** @flowWeaver nodeType
+ * @expression
+ * @label Build project
+ */
+function npmBuild(): { output: string } { return { output: 'dist/' }; }
+${deployStub}
+/**
+ * @flowWeaver workflow
+ * @trigger push branches="main"
+ * @trigger pull_request branches="main"
+ * @runner ubuntu-latest
+ * @secret NPM_TOKEN - npm auth token${deploySecret}
+ * @cache npm key="package-lock.json"
+ *
+ * @node co checkout [job: "test"] [position: 270 0]
+ * @node setup setupNode [job: "test"] [position: 540 0]
+ * @node install npmInstall [job: "test"] [position: 810 0]
+ * @node test npmTest [job: "test"] [position: 1080 0]
+ * @node build npmBuild [job: "build"] [position: 1350 0]${deployNode}
+ *
+ * @path Start -> co -> setup -> install -> test -> build${deployPath} -> Exit
+ * @position Start 0 0
+ * @position Exit ${hasDeploy ? '1890' : '1620'} 0
+ * @connect secret:NPM_TOKEN -> install.npmToken${deployConnect}
+ * @connect build.output -> Exit.buildOutput${deployConnect2}
+ *
+ * @param execute [order:-1] - Execute
+ * @param params [order:0] - Params
+ * @returns onSuccess [order:-2] - On Success
+ * @returns onFailure [order:-1] - On Failure
+ * @returns buildOutput [order:0] - Build output path${deployReturns}
+ */
+export async function ${name}(
+  execute: boolean,
+  params: Record<string, never> = {},
+): Promise<{ onSuccess: boolean; onFailure: boolean; buildOutput: string | null${hasDeploy ? '; deployResult: string | null' : ''} }> {
+  // @flow-weaver-body-start
+  throw new Error('Compile with: npx flow-weaver compile <this-file>');
+  // @flow-weaver-body-end
+  return { onSuccess: false, onFailure: true, buildOutput: null${hasDeploy ? ', deployResult: null' : ''} };
+}
+`;
+    },
+};
+//# sourceMappingURL=cicd-test-deploy.js.map

package/dist/constants.js

@@ -130,12 +130,19 @@ export const VALID_NODE_COLORS = [
 export const KNOWN_NODETYPE_TAGS = new Set([
     'flowWeaver', 'name', 'label', 'description', 'color', 'icon', 'tag',
     'executeWhen', 'scope', 'expression', 'pullExecution', 'input', 'output', 'step',
+    // Deployment annotations
+    'deploy',
 ]);
 export const KNOWN_WORKFLOW_TAGS = new Set([
     'flowWeaver', 'name', 'fwImport', 'description', 'strictTypes', 'autoConnect',
     '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',
 ]);
 export const KNOWN_PATTERN_TAGS = new Set([
     'flowWeaver', 'name', 'description', 'node', 'position', 'connect', 'port',

package/dist/deployment/index.d.ts

@@ -14,18 +14,25 @@ export { DEFAULT_CONFIG, DEFAULT_SERVER_CONFIG, DEFAULT_EXECUTION_CONFIG, getDef
 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, BaseExportTarget, ExportTargetRegistry, } from './targets/base.js';
+export { type ExportTarget, type ExportOptions, type ExportArtifacts, type GeneratedFile, type DeployInstructions, type DeploySchema, type DeploySchemaField, BaseExportTarget, ExportTargetRegistry, } from './targets/base.js';
 export { LambdaTarget } from './targets/lambda.js';
 export { VercelTarget } from './targets/vercel.js';
 export { CloudflareTarget } from './targets/cloudflare.js';
 export { InngestTarget } from './targets/inngest.js';
+export { GitHubActionsTarget } from './targets/github-actions.js';
+export { GitLabCITarget } from './targets/gitlab-ci.js';
+export { BaseCICDTarget, NODE_ACTION_MAP } from './targets/cicd-base.js';
 import { ExportTargetRegistry } from './targets/base.js';
 /**
- * Default export target registry with all built-in targets
- */
-export declare function createTargetRegistry(): ExportTargetRegistry;
-/**
- * Get names of all supported export targets
+ * Create an export target registry via marketplace discovery.
+ *
+ * Scans `node_modules/` for installed `flowweaver-pack-*` packages that
+ * declare `exportTargets` in their `flowweaver.manifest.json`.
+ * Each target class is eagerly imported (to resolve the async import) but
+ * lazily instantiated — the constructor only runs when `registry.get()` is called.
+ *
+ * @param projectDir — project root to scan for installed packs.
+ *   When omitted, returns an empty registry (useful for tests).
  */
-export declare function getSupportedTargetNames(): string[];
+export declare function createTargetRegistry(projectDir?: string): Promise<ExportTargetRegistry>;
 //# sourceMappingURL=index.d.ts.map

package/dist/deployment/index.js

@@ -18,31 +18,43 @@ export { OpenAPIGenerator, generateOpenAPIJson, generateOpenAPIYaml, } from './o
 export { SchemaConverter, schemaConverter, } from './openapi/schema-converter.js';
 // Export Targets
 export { BaseExportTarget, ExportTargetRegistry, } from './targets/base.js';
+// Target implementations — still exported for direct use by pack authors and tests
 export { LambdaTarget } from './targets/lambda.js';
 export { VercelTarget } from './targets/vercel.js';
 export { CloudflareTarget } from './targets/cloudflare.js';
 export { InngestTarget } from './targets/inngest.js';
-// Convenience: Create a pre-configured target registry
+export { GitHubActionsTarget } from './targets/github-actions.js';
+export { GitLabCITarget } from './targets/gitlab-ci.js';
+export { BaseCICDTarget, NODE_ACTION_MAP } from './targets/cicd-base.js';
+import * as path from 'path';
 import { ExportTargetRegistry } from './targets/base.js';
-import { LambdaTarget } from './targets/lambda.js';
-import { VercelTarget } from './targets/vercel.js';
-import { CloudflareTarget } from './targets/cloudflare.js';
-import { InngestTarget } from './targets/inngest.js';
 /**
- * Default export target registry with all built-in targets
+ * Create an export target registry via marketplace discovery.
+ *
+ * Scans `node_modules/` for installed `flowweaver-pack-*` packages that
+ * declare `exportTargets` in their `flowweaver.manifest.json`.
+ * Each target class is eagerly imported (to resolve the async import) but
+ * lazily instantiated — the constructor only runs when `registry.get()` is called.
+ *
+ * @param projectDir — project root to scan for installed packs.
+ *   When omitted, returns an empty registry (useful for tests).
  */
-export function createTargetRegistry() {
+export async function createTargetRegistry(projectDir) {
     const registry = new ExportTargetRegistry();
-    registry.register(new LambdaTarget());
-    registry.register(new VercelTarget());
-    registry.register(new CloudflareTarget());
-    registry.register(new InngestTarget());
+    if (projectDir) {
+        const { listInstalledPackages } = await import('../marketplace/registry.js');
+        const packages = await listInstalledPackages(projectDir);
+        for (const pkg of packages) {
+            for (const def of pkg.manifest.exportTargets ?? []) {
+                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 TargetClass = def.exportName ? mod[def.exportName] : mod.default;
+                registry.register(def.name, () => new TargetClass());
+            }
+        }
+    }
     return registry;
 }
-/**
- * Get names of all supported export targets
- */
-export function getSupportedTargetNames() {
-    return ['lambda', 'vercel', 'cloudflare', 'inngest'];
-}
 //# sourceMappingURL=index.js.map