@synergenius/flow-weaver 0.17.1 → 0.17.2

package/dist/marketplace/registry.js

@@ -97,4 +97,81 @@ export function getInstalledPackageManifest(projectDir, packageName) {
         return null;
     }
 }
+/**
+ * Discover all tag handlers from installed pack manifests.
+ */
+export async function discoverTagHandlers(projectDir) {
+    const packages = await listInstalledPackages(projectDir);
+    const handlers = [];
+    for (const pkg of packages) {
+        const manifest = pkg.manifest;
+        if (!manifest.tagHandlers)
+            continue;
+        for (const handler of manifest.tagHandlers) {
+            handlers.push({
+                ...handler,
+                absoluteFile: path.join(pkg.path, handler.file),
+                packageName: pkg.name,
+            });
+        }
+    }
+    return handlers;
+}
+/**
+ * Discover all validation rule sets from installed pack manifests.
+ */
+export async function discoverValidationRuleSets(projectDir) {
+    const packages = await listInstalledPackages(projectDir);
+    const ruleSets = [];
+    for (const pkg of packages) {
+        const manifest = pkg.manifest;
+        if (!manifest.validationRuleSets)
+            continue;
+        for (const ruleSet of manifest.validationRuleSets) {
+            ruleSets.push({
+                ...ruleSet,
+                absoluteFile: path.join(pkg.path, ruleSet.file),
+                packageName: pkg.name,
+            });
+        }
+    }
+    return ruleSets;
+}
+/**
+ * Discover all doc topics from installed pack manifests.
+ */
+export async function discoverDocTopics(projectDir) {
+    const packages = await listInstalledPackages(projectDir);
+    const topics = [];
+    for (const pkg of packages) {
+        const manifest = pkg.manifest;
+        if (!manifest.docs)
+            continue;
+        for (const doc of manifest.docs) {
+            topics.push({
+                ...doc,
+                absoluteFile: path.join(pkg.path, doc.file),
+                packageName: pkg.name,
+            });
+        }
+    }
+    return topics;
+}
+/**
+ * Discover all init contributions from installed pack manifests.
+ */
+export async function discoverInitContributions(projectDir) {
+    const packages = await listInstalledPackages(projectDir);
+    const contributions = [];
+    for (const pkg of packages) {
+        const manifest = pkg.manifest;
+        if (!manifest.initContributions)
+            continue;
+        contributions.push({
+            ...manifest.initContributions,
+            packageName: pkg.name,
+        });
+    }
+    return contributions;
+}
 //# sourceMappingURL=registry.js.map

package/dist/marketplace/types.d.ts

@@ -8,8 +8,8 @@
 import type { TDataType } from '../ast/types.js';
 /** Auto-generated manifest describing a marketplace package's contents. */
 export type TMarketplaceManifest = {
-    /** Manifest schema version (currently 1) */
-    manifestVersion: 1;
+    /** Manifest schema version */
+    manifestVersion: 1 | 2;
     /** npm package name */
     name: string;
     /** Semver version */
@@ -28,6 +28,14 @@ export type TMarketplaceManifest = {
     patterns: TManifestPattern[];
     /** Export targets provided by this package */
     exportTargets?: TManifestExportTarget[];
+    /** Tag handlers contributed by this pack (v2) */
+    tagHandlers?: TManifestTagHandler[];
+    /** Validation rule sets contributed by this pack (v2) */
+    validationRuleSets?: TManifestValidationRuleSet[];
+    /** Documentation topics contributed by this pack (v2) */
+    docs?: TManifestDocTopic[];
+    /** Init contributions: use cases and templates (v2) */
+    initContributions?: TManifestInitContribution;
     /** External dependency information */
     dependencies?: {
         /** Flow Weaver peer dependency constraints */
@@ -38,7 +46,7 @@ export type TMarketplaceManifest = {
 };
 /** An export target provided by a marketplace package. */
 export type TManifestExportTarget = {
-    /** Target identifier (e.g. "lambda", "azure-pipelines") */
+    /** Target identifier */
     name: string;
     /** Human-readable description */
     description?: string;
@@ -152,6 +160,71 @@ export type TInstalledPackage = {
     /** Absolute path to the package in node_modules */
     path: string;
 };
+/**
+ * A tag handler contributed by a pack. Declares which JSDoc tags the pack handles,
+ * the deploy namespace to store results in, and the JS file exporting the handler.
+ */
+export type TManifestTagHandler = {
+    /** Tag name(s) this handler processes (e.g., "secret", "runner") */
+    tags: string[];
+    /** Deploy namespace for storing parsed data (e.g., "cicd") */
+    namespace: string;
+    /** Applicable scope: workflow-level tags, nodeType-level tags, or both */
+    scope: 'workflow' | 'nodeType' | 'both';
+    /** Relative path to the compiled JS file exporting the handler function */
+    file: string;
+    /** Named export from the file (default: "default") */
+    exportName?: string;
+};
+/**
+ * A validation rule set contributed by a pack. Declares a detect function
+ * and rules export for conditional validation.
+ */
+export type TManifestValidationRuleSet = {
+    /** Human-readable name for this rule set */
+    name: string;
+    /** Deploy namespace this rule set applies to (e.g., "cicd") */
+    namespace: string;
+    /** Relative path to the compiled JS file exporting detect and getRules */
+    file: string;
+    /** Named export for the detect function (default: "detect") */
+    detectExport?: string;
+    /** Named export for the getRules function (default: "getRules") */
+    rulesExport?: string;
+};
+/**
+ * A documentation topic contributed by a pack.
+ */
+export type TManifestDocTopic = {
+    /** Topic slug (used in fw_docs read) */
+    slug: string;
+    /** Human-readable topic name */
+    name: string;
+    /** Topic description */
+    description?: string;
+    /** Search keywords */
+    keywords?: string[];
+    /** Context presets this topic should be included in */
+    presets?: string[];
+    /** Relative path to the markdown file */
+    file: string;
+};
+/**
+ * Init contributions from a pack: use case entries and template IDs.
+ */
+export type TManifestInitContribution = {
+    /** Use case entry for fw init prompts */
+    useCase?: {
+        /** Use case ID (must be unique across all packs) */
+        id: string;
+        /** Display name */
+        name: string;
+        /** Brief description */
+        description: string;
+    };
+    /** Template IDs this pack provides (must match IDs in the template registry) */
+    templates?: string[];
+};
 export type TMarketInitConfig = {
     /** Package name (e.g., flowweaver-pack-openai) */
     name: string;

package/dist/mcp/server.d.ts

@@ -1,3 +1,4 @@
+import '../extensions/index.js';
 import type { McpServerOptions } from './types.js';
 export declare function startMcpServer(options: McpServerOptions): Promise<void>;
 export declare function mcpServerCommand(options: McpServerOptions): Promise<void>;

package/dist/mcp/server.js

@@ -1,3 +1,5 @@
+// Load built-in extensions (CI/CD, etc.) before tool registration
+import '../extensions/index.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { DEFAULT_SERVER_URL } from '../defaults.js';

package/dist/mcp/tools-export.js

@@ -11,11 +11,11 @@ import { parseWorkflow } from '../api/index.js';
 import { createTargetRegistry } from '../deployment/index.js';
 import { makeToolResult, makeErrorResult } from './response-utils.js';
 export function registerExportTools(mcp) {
-    mcp.tool('fw_export', 'Export workflows as serverless deployments. Generates handler code, platform config, and deploy instructions.', {
+    mcp.tool('fw_export', 'Export workflows as serverless deployments. Generates platform-native config files and deploy instructions. Available targets depend on installed packs.', {
         filePath: z.string().describe('Path to the workflow .ts file'),
         target: z
             .string()
-            .describe('Deployment target platform (e.g. lambda, vercel, cloudflare, inngest, github-actions, gitlab-ci). Run with --list-targets to see installed targets.'),
+            .describe('Deployment target platform. Run with --list-targets to see installed targets.'),
         outputDir: z.string().describe('Output directory for generated files'),
         serviceName: z
             .string()
@@ -40,7 +40,7 @@ export function registerExportTools(mcp) {
         durableSteps: z
             .boolean()
             .optional()
-            .describe('Use deep generator with per-node Inngest steps for durability (inngest target only)'),
+            .describe('Use deep generator with per-node durable steps'),
     }, async (args) => {
         try {
             const filePath = path.resolve(args.filePath);

package/dist/mcp/tools-query.js

@@ -8,7 +8,7 @@ import { WorkflowDiffer } from '../diff/WorkflowDiffer.js';
 import { formatDiff } from '../diff/formatDiff.js';
 import { makeToolResult, makeErrorResult, addHintsToItems } from './response-utils.js';
 import { getFriendlyError } from '../friendly-errors.js';
-import { generateInngestFunction } from '../generator/inngest.js';
+import { compileTargetRegistry } from '../generator/compile-target-registry.js';
 import { AnnotationParser } from '../parser.js';
 /** Detect MULTIPLE_WORKFLOWS_FOUND marker in parse errors and return the right error code */
 function parseErrorCode(errors) {
@@ -130,7 +130,7 @@ export function registerQueryTools(mcp) {
     });
     mcp.tool('fw_compile', 'Compile a workflow to executable code. Only regenerates code inside @flow-weaver-runtime ' +
         'and @flow-weaver-body marker sections — user code outside markers is preserved. ' +
-        'Set production: true to strip debug instrumentation. Use target=inngest for per-node step.run() durability.', {
+        'Set production: true to strip debug instrumentation. Custom targets are available via registered extensions.', {
         filePath: z.string().describe('Path to the workflow file'),
         write: z.boolean().optional().describe('Whether to write the output file (default: true)'),
         production: z
@@ -139,9 +139,9 @@ export function registerQueryTools(mcp) {
             .describe('Production mode — no debug events (default: false)'),
         workflowName: z.string().optional().describe('Specific workflow name'),
         target: z
-            .enum(['typescript', 'inngest'])
+            .string()
             .optional()
-            .describe('Compilation target: typescript (default) or inngest (per-node step.run)'),
+            .describe('Compilation target: typescript (default) or a registered extension target'),
         cron: z.string().optional().describe('Cron schedule expression (e.g. "0 9 * * *"). Overrides @trigger annotation.'),
         serve: z.boolean().optional().describe('Generate serve() handler for HTTP framework integration'),
         framework: z.enum(['next', 'express', 'hono', 'fastify', 'remix']).optional().describe('Framework adapter for serve handler (requires serve=true)'),
@@ -151,10 +151,16 @@ export function registerQueryTools(mcp) {
     }, async (args) => {
         try {
             const filePath = path.resolve(args.filePath);
-            if (args.target === 'inngest') {
-                // Use deep Inngest generator
-                const parser = new AnnotationParser();
-                const parseResult = parser.parse(filePath);
+            const customTarget = args.target && args.target !== 'typescript'
+                ? compileTargetRegistry.get(args.target)
+                : undefined;
+            if (args.target && args.target !== 'typescript') {
+                if (!customTarget) {
+                    const available = compileTargetRegistry.getNames();
+                    return makeErrorResult('COMPILE_ERROR', `Unknown compile target: ${args.target}. Available: typescript${available.length ? ', ' + available.join(', ') : ''}`);
+                }
+                const annotationParser = new AnnotationParser();
+                const parseResult = annotationParser.parse(filePath);
                 if (parseResult.errors.length > 0) {
                     return makeErrorResult('PARSE_ERROR', `Parse errors:\n${parseResult.errors.join('\n')}`);
                 }
@@ -182,19 +188,19 @@ export function registerQueryTools(mcp) {
                     workflow.options = workflow.options || {};
                     workflow.options.timeout = args.timeout;
                 }
-                const code = generateInngestFunction(workflow, allNodeTypes, {
+                const code = customTarget.compile(workflow, allNodeTypes, {
                     production: args.production ?? false,
                     typedEvents: args.typedEvents,
                     serveHandler: args.serve,
                     framework: args.framework,
                 });
-                const outputFile = filePath.replace(/\.ts$/, '.inngest.ts');
+                const outputFile = filePath.replace(/\.ts$/, `.${args.target}.ts`);
                 if (args.write !== false) {
                     const fs = await import('fs');
                     fs.writeFileSync(outputFile, code, 'utf8');
                 }
                 return makeToolResult({
-                    target: 'inngest',
+                    target: args.target,
                     outputFile,
                     workflowName: workflow.name,
                     code: args.write === false ? code : undefined,

package/dist/mcp/tools-template.js

@@ -38,7 +38,7 @@ export function registerTemplateTools(mcp) {
         return makeToolResult(result);
     });
     mcp.tool('fw_scaffold', 'Create a workflow or node from a template.', {
-        template: z.string().describe('Template name (e.g. "sequential", "validator")'),
+        template: z.string().describe('Template name (e.g. "sequential", "validator", "ai-agent")'),
         filePath: z.string().describe('Output file path'),
         name: z.string().optional().describe('Workflow/node function name'),
         preview: z

package/dist/parser/tag-registry.d.ts

@@ -0,0 +1,47 @@
+/**
+ * TagHandlerRegistry: dispatch table for pack-contributed JSDoc tag handlers.
+ *
+ * Packs declare tag handlers in their manifest. The parser populates this
+ * registry at startup and delegates unknown tags to it before emitting
+ * "unknown tag" warnings.
+ */
+export type TTagHandlerContext = {
+    /** The deploy map for this handler's namespace. Handlers mutate this directly. */
+    deploy: Record<string, unknown>;
+    /** Accumulator for parser warnings. */
+    warnings: string[];
+};
+/**
+ * A handler function for a pack-contributed tag.
+ * Receives the tag name, the comment text after the tag, and a context
+ * object with the deploy map for the handler's namespace.
+ */
+export type TTagHandlerFn = (tagName: string, comment: string, ctx: TTagHandlerContext) => void;
+export type TRegisteredTagHandler = {
+    namespace: string;
+    scope: 'workflow' | 'nodeType' | 'both';
+    handler: TTagHandlerFn;
+};
+/**
+ * Registry mapping tag names to pack-provided handler functions.
+ * Used by the JSDoc parser to delegate tags it doesn't natively handle.
+ */
+export declare class TagHandlerRegistry {
+    private handlers;
+    /** Register a handler for one or more tag names. */
+    register(tags: string[], namespace: string, scope: 'workflow' | 'nodeType' | 'both', handler: TTagHandlerFn): void;
+    /** Check if a handler is registered for the given tag. */
+    has(tagName: string): boolean;
+    /** Get all registered tag names. */
+    getRegisteredTags(): string[];
+    /**
+     * Handle a tag by delegating to the registered handler.
+     * The handler writes parsed data into `deployMap[namespace]`.
+     *
+     * @returns true if the tag was handled, false if no handler was found.
+     */
+    handle(tagName: string, comment: string, blockScope: 'workflow' | 'nodeType', deployMap: Record<string, Record<string, unknown>>, warnings: string[]): boolean;
+}
+/** Global tag handler registry singleton. Extensions register handlers here at startup. */
+export declare const tagHandlerRegistry: TagHandlerRegistry;
+//# sourceMappingURL=tag-registry.d.ts.map

package/dist/parser/tag-registry.js

@@ -0,0 +1,57 @@
+/**
+ * TagHandlerRegistry: dispatch table for pack-contributed JSDoc tag handlers.
+ *
+ * Packs declare tag handlers in their manifest. The parser populates this
+ * registry at startup and delegates unknown tags to it before emitting
+ * "unknown tag" warnings.
+ */
+/**
+ * Registry mapping tag names to pack-provided handler functions.
+ * Used by the JSDoc parser to delegate tags it doesn't natively handle.
+ */
+export class TagHandlerRegistry {
+    handlers = new Map();
+    /** Register a handler for one or more tag names. */
+    register(tags, namespace, scope, handler) {
+        const entry = { namespace, scope, handler };
+        for (const tag of tags) {
+            this.handlers.set(tag, entry);
+        }
+    }
+    /** Check if a handler is registered for the given tag. */
+    has(tagName) {
+        return this.handlers.has(tagName);
+    }
+    /** Get all registered tag names. */
+    getRegisteredTags() {
+        return [...this.handlers.keys()];
+    }
+    /**
+     * Handle a tag by delegating to the registered handler.
+     * The handler writes parsed data into `deployMap[namespace]`.
+     *
+     * @returns true if the tag was handled, false if no handler was found.
+     */
+    handle(tagName, comment, blockScope, deployMap, warnings) {
+        const entry = this.handlers.get(tagName);
+        if (!entry)
+            return false;
+        // Check scope compatibility
+        if (entry.scope !== 'both' && entry.scope !== blockScope) {
+            warnings.push(`@${tagName} is registered for ${entry.scope} blocks, not ${blockScope} blocks.`);
+            return true; // consumed, but with a warning
+        }
+        // Ensure the namespace slot exists
+        if (!deployMap[entry.namespace]) {
+            deployMap[entry.namespace] = {};
+        }
+        entry.handler(tagName, comment, {
+            deploy: deployMap[entry.namespace],
+            warnings,
+        });
+        return true;
+    }
+}
+/** Global tag handler registry singleton. Extensions register handlers here at startup. */
+export const tagHandlerRegistry = new TagHandlerRegistry();
+//# sourceMappingURL=tag-registry.js.map

package/dist/parser.d.ts

@@ -1,5 +1,6 @@
 import { Project } from 'ts-morph';
 import type { TNodeTypeAST, TWorkflowAST, TPatternAST } from './ast/types.js';
+import { type TagHandlerRegistry } from './parser/tag-registry.js';
 export interface ParseResult {
     workflows: TWorkflowAST[];
     nodeTypes: TNodeTypeAST[];
@@ -29,6 +30,8 @@ export declare class AnnotationParser {
     private importCache;
     private importStack;
     private parseCache;
+    /** Tag handler registry. Defaults to the global singleton (pre-populated by extensions). */
+    tagRegistry: TagHandlerRegistry;
     constructor();
     private computeHash;
     private detectMinorEdit;

package/dist/parser.js

@@ -14,6 +14,7 @@ import { getPackageExports } from './npm-packages.js';
 import { getSharedProject } from './shared-project.js';
 import { LRUCache } from './utils/lru-cache.js';
 import { COERCION_NODE_TYPES, COERCE_TYPE_MAP } from './built-in-nodes/coercion-types.js';
+import { tagHandlerRegistry } from './parser/tag-registry.js';
 /**
  * Convert a TExternalNodeType to a TNodeTypeAST with sensible defaults.
  * Used to merge runtime-loaded node types into the parser's available types.
@@ -73,6 +74,8 @@ export class AnnotationParser {
     importCache = new LRUCache(200);
     importStack = new Set();
     parseCache = new LRUCache(100);
+    /** Tag handler registry. Defaults to the global singleton (pre-populated by extensions). */
+    tagRegistry = tagHandlerRegistry;
     constructor() {
         this.project = getSharedProject();
     }
@@ -591,7 +594,7 @@ export class AnnotationParser {
         const nodeTypes = [];
         extractFunctionLikes(sourceFile).forEach((fn) => {
             // Parse JSDoc comments
-            const config = jsdocParser.parseNodeType(fn, warnings);
+            const config = jsdocParser.parseNodeType(fn, warnings, this.tagRegistry);
             if (!config) {
                 const jsdocText = fn.getJsDocs().map((d) => d.getFullText()).join('');
                 if (jsdocText.includes('@flowWeaver nodeType')) {
@@ -765,7 +768,7 @@ export class AnnotationParser {
     extractWorkflowSignatures(sourceFile, filePath, warnings) {
         const workflows = [];
         extractFunctionLikes(sourceFile).forEach((fn) => {
-            const config = jsdocParser.parseWorkflow(fn, warnings);
+            const config = jsdocParser.parseWorkflow(fn, warnings, this.tagRegistry);
             if (!config)
                 return;
             const functionName = fn.getName() || 'anonymous';
@@ -823,7 +826,7 @@ export class AnnotationParser {
             .filter((name) => !!name);
         allFunctions.forEach((fn) => {
             // Parse JSDoc comments
-            const config = jsdocParser.parseWorkflow(fn, warnings);
+            const config = jsdocParser.parseWorkflow(fn, warnings, this.tagRegistry);
             if (!config) {
                 const jsdocText = fn.getJsDocs().map((d) => d.getFullText()).join('');
                 if (jsdocText.includes('@flowWeaver workflow')) {
@@ -990,11 +993,7 @@ export class AnnotationParser {
                 ...(Object.keys(ui).length > 0 && { ui }),
                 ...((config.strictTypes !== undefined || config.autoConnect ||
                     config.trigger || config.cancelOn || config.retries !== undefined ||
-                    config.timeout || config.throttle ||
-                    config.secrets || config.runner || config.caches || config.artifacts ||
-                    config.environments || config.matrix || config.services ||
-                    config.concurrency || config.cicdTriggers ||
-                    config.deploy) && {
+                    config.timeout || config.throttle || config.deploy) && {
                     options: {
                         ...(config.strictTypes !== undefined && { strictTypes: config.strictTypes }),
                         ...(config.autoConnect && { autoConnect: true }),
@@ -1003,21 +1002,9 @@ export class AnnotationParser {
                         ...(config.retries !== undefined && { retries: config.retries }),
                         ...(config.timeout && { timeout: config.timeout }),
                         ...(config.throttle && { throttle: config.throttle }),
-                        // CI/CD domain options (grouped)
-                        ...((config.secrets || config.runner || config.caches || config.artifacts ||
-                            config.environments || config.matrix || config.services ||
-                            config.concurrency || config.cicdTriggers) && {
-                            cicd: {
-                                ...(config.secrets && { secrets: config.secrets }),
-                                ...(config.runner && { runner: config.runner }),
-                                ...(config.caches && { caches: config.caches }),
-                                ...(config.artifacts && { artifacts: config.artifacts }),
-                                ...(config.environments && { environments: config.environments }),
-                                ...(config.matrix && { matrix: config.matrix }),
-                                ...(config.services && { services: config.services }),
-                                ...(config.concurrency && { concurrency: config.concurrency }),
-                                ...(config.cicdTriggers && { triggers: config.cicdTriggers }),
-                            },
+                        // CI/CD data comes from deploy['cicd'] (populated by extension tag handler)
+                        ...(config.deploy?.['cicd'] && {
+                            cicd: config.deploy['cicd'],
                         }),
                         // Per-target deployment config
                         ...(config.deploy && { deploy: config.deploy }),

package/dist/validation/rule-registry.d.ts

@@ -0,0 +1,36 @@
+/**
+ * ValidationRuleRegistry: dynamic dispatch for pack-contributed validation rules.
+ *
+ * Replaces the hardcoded `isCICDWorkflow() ? getCICDValidationRules() : []`
+ * pattern. Each registered rule set has a detect predicate and a lazy rule loader.
+ * The validate API calls `getApplicableRules(ast)` and merges results.
+ */
+import type { TValidationRule, TWorkflowAST } from '../ast/types.js';
+export type TValidationRuleSet = {
+    /** Human-readable name for this rule set */
+    name: string;
+    /** Deploy namespace this rule set applies to */
+    namespace: string;
+    /** Predicate: should these rules run for this workflow? */
+    detect: (ast: TWorkflowAST) => boolean;
+    /** Lazy loader for the actual rules. Called only when detect returns true. */
+    getRules: () => TValidationRule[];
+};
+/**
+ * Registry for dynamically contributed validation rule sets.
+ * Core rule sets (like CI/CD) register themselves at startup.
+ * Pack-contributed rule sets are loaded from manifests.
+ */
+export declare class ValidationRuleRegistry {
+    private ruleSets;
+    /** Register a validation rule set. */
+    register(ruleSet: TValidationRuleSet): void;
+    /**
+     * Get all validation rules applicable to the given workflow AST.
+     * Runs each registered detect predicate and collects rules from matching sets.
+     */
+    getApplicableRules(ast: TWorkflowAST): TValidationRule[];
+    /** Get the number of registered rule sets. */
+    get size(): number;
+}
+//# sourceMappingURL=rule-registry.d.ts.map

package/dist/validation/rule-registry.js

@@ -0,0 +1,37 @@
+/**
+ * ValidationRuleRegistry: dynamic dispatch for pack-contributed validation rules.
+ *
+ * Replaces the hardcoded `isCICDWorkflow() ? getCICDValidationRules() : []`
+ * pattern. Each registered rule set has a detect predicate and a lazy rule loader.
+ * The validate API calls `getApplicableRules(ast)` and merges results.
+ */
+/**
+ * Registry for dynamically contributed validation rule sets.
+ * Core rule sets (like CI/CD) register themselves at startup.
+ * Pack-contributed rule sets are loaded from manifests.
+ */
+export class ValidationRuleRegistry {
+    ruleSets = [];
+    /** Register a validation rule set. */
+    register(ruleSet) {
+        this.ruleSets.push(ruleSet);
+    }
+    /**
+     * Get all validation rules applicable to the given workflow AST.
+     * Runs each registered detect predicate and collects rules from matching sets.
+     */
+    getApplicableRules(ast) {
+        const rules = [];
+        for (const ruleSet of this.ruleSets) {
+            if (ruleSet.detect(ast)) {
+                rules.push(...ruleSet.getRules());
+            }
+        }
+        return rules;
+    }
+    /** Get the number of registered rule sets. */
+    get size() {
+        return this.ruleSets.length;
+    }
+}
+//# sourceMappingURL=rule-registry.js.map

package/dist/validator.js

@@ -1,4 +1,4 @@
-import { RESERVED_NODE_NAMES, isStartNode, isExitNode, isExecutePort, isReservedNodeName, VALID_NODE_COLORS, EXECUTION_STRATEGIES, } from './constants.js';
+import { RESERVED_NODE_NAMES, isStartNode, isExitNode, isPseudoNode, isExecutePort, isReservedNodeName, VALID_NODE_COLORS, EXECUTION_STRATEGIES, } from './constants.js';
 import { findClosestMatches } from './utils/string-distance.js';
 import { parseFunctionSignature } from './jsdoc-port-sync/signature-parser.js';
 import { checkTypeCompatibilityFromStrings } from './type-checker.js';
@@ -316,7 +316,7 @@ export class WorkflowValidator {
             const fromNode = conn.from.node;
             const fromPort = conn.from.port;
             const connLocation = this.getConnectionLocation(conn);
-            if (!isStartNode(fromNode) && !instanceMap.has(fromNode)) {
+            if (!isStartNode(fromNode) && !isPseudoNode(fromNode) && !instanceMap.has(fromNode)) {
                 const instanceIds = [...instanceMap.keys()];
                 const suggestions = findClosestMatches(fromNode, instanceIds);
                 const suggestion = suggestions.length > 0 ? ` Did you mean "${suggestions[0]}"?` : '';
@@ -627,7 +627,7 @@ export class WorkflowValidator {
         workflow.connections.forEach((conn) => {
             const fromNode = conn.from.node;
             const toNode = conn.to.node;
-            if (!isStartNode(fromNode) && !isExitNode(fromNode)) {
+            if (!isStartNode(fromNode) && !isExitNode(fromNode) && !isPseudoNode(fromNode)) {
                 referencedNodes.add(fromNode);
             }
             if (!isStartNode(toNode) && !isExitNode(toNode)) {

package/docs/reference/concepts.md

@@ -78,6 +78,7 @@ That is it. Two expression-mode functions, one workflow annotation, zero boilerp
 | Pull execution, merge strategies | `advanced-annotations`       | jsdoc-grammar       |
 | Compile to Inngest               | `compilation`                | cli-reference       |
 | Deploy to cloud                  | `deployment`                 | compilation         |
+| Build a CI/CD pipeline           | `cicd`                       | deployment, scaffold |
 | Use delay/waitForEvent/mocks     | `built-in-nodes`             | debugging           |
 | Publish marketplace packages     | `marketplace`                | —                   |
 
@@ -98,7 +99,7 @@ flow-weaver watch <file>      # Watch mode
 flow-weaver dev <file>        # Watch + compile + run in one command
 flow-weaver serve [dir]       # HTTP server exposing workflows as endpoints
 flow-weaver diagram <file>    # Generate SVG diagram
-flow-weaver export <file>     # Export as serverless function (lambda/vercel/cloudflare/inngest)
+flow-weaver export <file>     # Export as serverless function or CI/CD pipeline
 flow-weaver docs              # Browse documentation
 flow-weaver docs <topic>      # Read a specific topic
 flow-weaver docs search <q>   # Search across all docs