@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/editor-completions/jsDocAnnotations.d.ts

@@ -3,7 +3,7 @@
  *
  * Flow Weaver specific JSDoc annotations for autocompletion.
  */
-import type { FlowWeaverCompletion } from './types.js';
+import type { FlowWeaverCompletion } from './types';
 /**
  * Block types where an annotation is valid.
  * - "workflow": inside a @flowWeaver workflow block

package/dist/editor-completions/modifierCompletions.d.ts

@@ -4,7 +4,7 @@
  * Completions for bracket modifiers like [placement:TOP], [order:1], [hidden:true]
  * These appear on annotation lines inside brackets.
  */
-import type { FlowWeaverCompletion } from './types.js';
+import type { FlowWeaverCompletion } from './types';
 /**
  * Get modifier name completions.
  * Filters by the annotation on the current line if provided.

package/dist/export/index.d.ts

@@ -35,6 +35,12 @@ export interface ExportOptions {
     includeDocs?: boolean;
     /** Use deep generator with per-node durable steps (target-specific) */
     durableSteps?: boolean;
+    /**
+     * The project whose installed packs provide the targets. Defaults to the
+     * working directory, which is right for the CLI and wrong for a long-lived
+     * process such as the console once it has opened another project.
+     */
+    projectDir?: string;
 }
 /**
  * Result of export operation
@@ -61,7 +67,7 @@ export interface ExportResult {
 /**
  * Export a workflow for deployment.
  *
- * Delegates to the target registry — every target is a plugin discovered
+ * Delegates to the target registry, where every target is a plugin discovered
  * from installed marketplace packs. The legacy template system has been
  * replaced by target classes that generate their own handler + config.
  */

package/dist/generated-branding.js

@@ -1,22 +1,9 @@
-/**
- * Configurable branding for generated output.
- *
- * The library ships with generic defaults. The root project (app/CLI)
- * calls {@link configureGeneratedBranding} at startup to inject
- * organisation-specific values (URLs, attribution text, etc.).
- */
-const WEBSITE_URL = 'https://flowweaver.ai';
-const DEFAULT = {
-    header: (cmd) => cmd
-        ? `// Generated by Flow Weaver (${WEBSITE_URL}) — ${cmd}`
-        : `// Generated by Flow Weaver (${WEBSITE_URL})`,
-    markdown: `*Generated by [Flow Weaver](${WEBSITE_URL})*`,
+import {
+  configureGeneratedBranding,
+  getGeneratedBranding
+} from "./chunks/chunk-AXNQRVJB.js";
+import "./chunks/chunk-SEWDMQ6Q.js";
+export {
+  configureGeneratedBranding,
+  getGeneratedBranding
 };
-let _branding = DEFAULT;
-export function configureGeneratedBranding(branding) {
-    _branding = branding;
-}
-export function getGeneratedBranding() {
-    return _branding;
-}
-//# sourceMappingURL=generated-branding.js.map

package/dist/generated-version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.33.1";
+export declare const VERSION = "0.44.0";
 //# sourceMappingURL=generated-version.d.ts.map

package/dist/generated-version.js

@@ -1,3 +1,7 @@
-// Auto-generated by scripts/generate-version.ts — do not edit manually
-export const VERSION = '0.33.1';
-//# sourceMappingURL=generated-version.js.map
+import {
+  VERSION
+} from "./chunks/chunk-QDE4Z7KW.js";
+import "./chunks/chunk-SEWDMQ6Q.js";
+export {
+  VERSION
+};

package/dist/generator/annotation-generator.d.ts

@@ -0,0 +1,84 @@
+import type { TNodeTypeAST, TNodeInstanceAST, TPortDefinition, TWorkflowAST, TConnectionAST, TWorkflowMacro, THttpRoute } from "../ast/index.js";
+export interface GenerateAnnotationsOptions {
+    includeComments?: boolean;
+    includeMetadata?: boolean;
+    indentSize?: number;
+    skipParamReturns?: boolean;
+}
+/**
+ * Lay a description out as JSDoc lines: every line gets its ` * ` prefix and a
+ * blank line inside the text becomes a bare ` *`. Emitting the whole text as
+ * one line leaves every line after the first without a prefix, which is a
+ * malformed block and reads as broken output to whoever wrote the text.
+ */
+export declare function formatJSDocDescription(description: string): string[];
+/** An `@http` route as its tag text, the exact form the parser reads back. */
+export declare function httpRouteText(r: THttpRoute): string;
+/**
+ * Decide which ports an emitter writes and which of them need an `[order:N]`.
+ *
+ * The parser stores an order on every port -- the author's when there is
+ * one, otherwise one it infers from declaration position -- and it cannot be
+ * told apart afterwards. An emitter that writes every stored order therefore
+ * grows the file on each compile with values a re-parse would infer anyway.
+ * So the orders are recomputed here for the sequence that will be written,
+ * exactly as the parser will recompute them, and only the ones that differ
+ * are written. Mandatory ports at their defaults are left out for the same
+ * reason: the parser adds them back. Round-trip fidelity holds by
+ * construction; nothing that changes a re-parse is dropped.
+ */
+export declare function planPortTags(entries: [string, TPortDefinition][]): Array<{
+    name: string;
+    port: TPortDefinition;
+    writeOrder: boolean;
+}>;
+export declare class AnnotationGenerator {
+    generate(workflow: TWorkflowAST, options?: GenerateAnnotationsOptions): string;
+    private generateNodeTypeAnnotation;
+    private generateJSDocPortTag;
+    private generateTPortDefinition;
+    private generateFunctionSignature;
+    private generateWorkflowAnnotation;
+    private generateWorkflowFunctionSignature;
+    private assignPortOrders;
+    private mapDataTypeToTS;
+}
+/**
+ * Generate JSDoc port tag (e.g., @input name - Description)
+ * Shared with the in-place generator (src/api/in-place).
+ *
+ * New format (types derived from signature):
+ * - @input name - Description
+ * - @output name - Description
+ * - @step name - Description (for explicit STEP/control-flow ports)
+ *
+ * Reserved STEP ports (execute, onSuccess, onFailure) use @input/@output.
+ * Custom STEP ports use @step.
+ */
+export declare function generateJSDocPortTag(rawName: string, port: TPortDefinition, direction: 'input' | 'output', _implicitOrder?: number, options?: {
+    writeOrder?: boolean;
+}): string;
+/**
+ * Check if a connection is covered by a macro (and should not be written as @connect).
+ * Handles both @map and @path macros.
+ */
+export declare function isConnectionCoveredByMacroStatic(conn: TConnectionAST, macros: TWorkflowMacro[]): boolean;
+/**
+ * Simply return ports as-is to preserve exact order from the AST
+ * Don't compute or add any new metadata - only preserve what's already there
+ * This ensures perfect round-trip fidelity
+ * Shared with the in-place generator (src/api/in-place).
+ */
+export declare function assignPortOrders(ports: [string, TPortDefinition][], _direction: 'input' | 'output'): [string, TPortDefinition][];
+/**
+ * Generate @node tag for a single instance
+ * Shared with the in-place generator (src/api/in-place).
+ */
+export declare function generateNodeInstanceTag(instance: TNodeInstanceAST): string;
+/**
+ * Generate a TypeScript function signature from a node type definition.
+ * Handles three modes: stub (declare function), expression (pure function), normal (execute/onSuccess/onFailure).
+ */
+export declare function generateFunctionSignature(nodeType: TNodeTypeAST): string[];
+export declare const annotationGenerator: AnnotationGenerator;
+//# sourceMappingURL=annotation-generator.d.ts.map

package/dist/generator/async-detection.d.ts

@@ -2,7 +2,7 @@
  * Async Detection Logic
  * Determines whether a workflow should be generated as async based on node composition
  */
-import { TWorkflowAST, TNodeTypeAST } from "../ast/types.js";
+import { TWorkflowAST, TNodeTypeAST } from "../ast/types";
 /**
  * Determines if a workflow should be async based on its node composition
  * Rule: Workflow is async if ANY node in its execution graph is async

package/dist/{body-generator.d.ts → generator/body-generator.d.ts}

@@ -1,9 +1,10 @@
-import type { TNodeTypeAST, TWorkflowAST } from "./ast/index.js";
+import type { TNodeTypeAST, TWorkflowAST } from "../ast/index.js";
+import { type GraphIdentityStamp } from "./unified";
 /**
  * Generates executable function body code from workflow ASTs.
  * Delegates to the unified control-flow generator for code emission.
  */
-export declare class BodyGenerator {
+declare class BodyGenerator {
     /**
      * Generates a workflow function body that uses an execution context for
      * tracing, error handling, and runtime state management.
@@ -13,9 +14,11 @@ export declare class BodyGenerator {
      * @param isAsync - Whether to generate async code. Defaults to true.
      * @param production - If true, omits debug event emissions. Defaults to false.
      * @param bundleMode - If true, generates code suitable for bundled deployment. Defaults to false.
+     * @param durableSequential - If true, the graph has a durable gate and runs strictly in order.
+     * @param identity - The graph identity a gated body declares to the engine before it runs.
      * @returns The generated function body as a string.
      */
-    generateWithExecutionContext(workflow: TWorkflowAST, nodeTypes: TNodeTypeAST[], isAsync?: boolean, production?: boolean, bundleMode?: boolean): string;
+    generateWithExecutionContext(workflow: TWorkflowAST, nodeTypes: TNodeTypeAST[], isAsync?: boolean, production?: boolean, bundleMode?: boolean, durableSequential?: boolean, identity?: GraphIdentityStamp): string;
     /**
      * Generates a workflow function body using default settings (async, non-production, non-bundled).
      * Convenience method that wraps {@link generateWithExecutionContext}.
@@ -28,4 +31,5 @@ export declare class BodyGenerator {
 }
 /** Pre-instantiated singleton of {@link BodyGenerator} for convenient use. */
 export declare const bodyGenerator: BodyGenerator;
+export {};
 //# sourceMappingURL=body-generator.d.ts.map

package/dist/generator/code-utils.d.ts

@@ -1,4 +1,4 @@
-import type { TNodeTypeAST, TWorkflowAST, TMergeStrategy, TConnectionAST, TDataType } from '../ast/index.js';
+import type { TMergeStrategy, TConnectionAST, TDataType } from '../ast/index.js';
 /**
  * Get the coercion expression to wrap a value, if coercion is needed.
  * Returns null if no coercion needed.
@@ -18,6 +18,20 @@ export declare function getCoercionWrapper(connection: TConnectionAST, sourceDat
  * @returns A valid JavaScript identifier
  */
 export declare function toValidIdentifier(nodeId: string): string;
+/**
+ * Name the local that holds a node's call result.
+ *
+ * Normally `<nodeId>Result`, but that collides when a node's id plus "Result"
+ * happens to equal the node type it calls -- e.g. `@node rec recResult` emits
+ * `const recResult = recResult(...)`, whose `const` puts the function in the
+ * temporal dead zone and throws "Cannot access 'recResult' before
+ * initialization" at run time. Suffix the local in that case so it can never
+ * shadow the callee.
+ *
+ * @param safeNodeName - The node id, already a valid identifier
+ * @param functionName - The node type function this local's initializer calls
+ */
+export declare function nodeResultVar(safeNodeName: string, functionName: string): string;
 /**
  * Build a JavaScript expression that merges multiple source values based on strategy.
  *
@@ -26,63 +40,4 @@ export declare function toValidIdentifier(nodeId: string): string;
  * @returns JavaScript expression string
  */
 export declare function buildMergeExpression(sources: string[], strategy: TMergeStrategy): string;
-export type TBuildNodeArgsOptions = {
-    node: TNodeTypeAST;
-    workflow: TWorkflowAST;
-    id: string;
-    lines: string[];
-    indent?: string;
-    getCall?: string;
-    isAsync?: boolean;
-    instanceParent?: string;
-    skipPorts?: Set<string>;
-    emitInputEvents?: boolean;
-    setCall?: string;
-    nodeTypeName?: string;
-    bundleMode?: boolean;
-    production?: boolean;
-};
-/**
- * Builds the argument list for a node function call by resolving input port values.
- *
- * This function is central to code generation - it determines where each input port
- * gets its value from: connections, expressions, defaults, or execution strategies.
- *
- * ## Resolution Priority (per port):
- * 1. **Skip Ports**: If port is in skipPorts set, use pre-declared variable
- * 2. **Instance Expression**: Check instance.config.portConfigs for constant expressions
- * 3. **Connection**: Get value from connected output port via ctx.getVariable()
- * 4. **Node Type Expression**: Check nodeType.inputs[port].expression
- * 5. **Default Value**: Use nodeType.inputs[port].default if available
- * 6. **Undefined**: No value source found (may cause runtime error)
- *
- * ## Special Handling:
- * - **execute port**: Always first, handles CONJUNCTION/DISJUNCTION strategies
- * - **Scoped INPUT ports**: Skipped (they're return values from scope functions)
- * - **STEP ports (onSuccess/onFailure)**: Use executionSignal config if present
- * - **Scope functions**: Generated via generateScopeFunctionClosure() for FUNCTION ports
- *
- * ## STEP Port Execution Strategies:
- * - **CONJUNCTION (AND)**: `execute = stepA && stepB && stepC`
- * - **DISJUNCTION (OR)**: `execute = stepA || stepB || stepC`
- * - **CUSTOM**: Uses executionSignal expression
- *
- * @param opts - Configuration object with node, workflow, and generation settings
- * @param opts.node - The node type definition with input/output port specs
- * @param opts.workflow - The workflow AST containing connections and instances
- * @param opts.id - The node instance ID being generated
- * @param opts.lines - Array to push generated code lines into
- * @param opts.indent - Indentation prefix for generated lines (default: "    ")
- * @param opts.getCall - Method to get variables (default: "await ctx.getVariable")
- * @param opts.isAsync - Whether generating async code
- * @param opts.instanceParent - Parent node ID if this node is in a scope
- * @param opts.skipPorts - Ports to skip (already pre-handled)
- * @param opts.emitInputEvents - Whether to emit VARIABLE_SET events for inputs
- * @param opts.setCall - Method to set variables (default: "await ctx.setVariable")
- * @param opts.nodeTypeName - Override for node type name in events
- * @returns Array of argument expressions to pass to the node function
- */
-export declare function buildNodeArgumentsWithContext(opts: TBuildNodeArgsOptions): string[];
-export declare function generateNodeWithExecutionContext(node: TNodeTypeAST, workflow: TWorkflowAST, lines: string[], isAsync: boolean, indent?: string): void;
-export declare function buildExecutionContextReturnForBranch(workflow: TWorkflowAST, lines: string[], isAsync: boolean, branchName: string, indent: string, executedNodes: string[]): string;
 //# sourceMappingURL=code-utils.d.ts.map

package/dist/generator/connection-reads.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Reads of values that other nodes produced, as a node's argument list emits
+ * them.
+ *
+ * Decides, for one connected input, which execution index the read addresses
+ * (Start's, the source node's own, `?? 0` for a pull source), whether that
+ * index can still be undefined when the read runs and so needs a guard, how
+ * the source is named in the context call, which coercion wraps the value,
+ * and how several connections into one port are combined. The execute port's
+ * signal is read here too; its fallbacks (no connection, expression node,
+ * pre-handled) belong to buildNodeArgumentsWithContext.
+ */
+import type { TConnectionAST, TNodeTypeAST, TPortDefinition, TWorkflowAST } from '../ast/index.js';
+/**
+ * Everything the reads of one node's inputs share. buildNodeArgumentsWithContext
+ * resolves it once per node from its options.
+ */
+export interface ArgumentEmission {
+    node: TNodeTypeAST;
+    workflow: TWorkflowAST;
+    /** The node instance id. */
+    id: string;
+    /** `id` as a valid identifier, the prefix of every local this node declares. */
+    safeId: string;
+    lines: string[];
+    indent: string;
+    /** The context read, e.g. `await ctx.getVariable`. */
+    getCall: string;
+    /** The context write input events use, e.g. `await ctx.setVariable`. */
+    setCall: string;
+    isAsync: boolean;
+    /** The enclosing scoped parent, whose index is always assigned when a child reads it. */
+    instanceParent: string | undefined;
+    emitInputEvents: boolean;
+    /** The node type name input events report. */
+    eventNodeTypeName: string;
+    /** Every connection into this node. */
+    inputConnections: TConnectionAST[];
+}
+/**
+ * The type an argument value is cast to: the port's own type when it is a
+ * primitive, otherwise `Parameters<typeof fn>[N]`. The node function is
+ * always in scope in generated code, so naming the parameter through it never
+ * references a type from a module that is not imported.
+ */
+export declare function argumentPortType(node: TNodeTypeAST, portConfig: TPortDefinition, paramIndex: number): string;
+/**
+ * Resolve the TypeScript type of a value read out of an expression reference
+ * (`node.port` inside an `[expr: ...]` annotation). Mirrors the
+ * `Parameters<typeof fn>[N]` trick used for plain connections: a node
+ * instance's function is always in scope in generated code, so its return
+ * type is a safe way to name a non-primitive output type without risking a
+ * bare type name from a module that isn't imported. Start has no function to
+ * reference, so its declared `tsType` is used directly (same caveat the rest
+ * of the generator already accepts for Start ports).
+ */
+export declare function resolveReferencedPortType(workflow: TWorkflowAST, sourceNodeId: string, sourcePort: string): string;
+/**
+ * The index an unguarded read addresses: `?? 0` for a pull source (it runs
+ * lazily, on first read), a non-null assertion for a source that is not
+ * const, the plain index otherwise.
+ */
+export declare function unguardedSourceIndex(em: ArgumentEmission, sourceNode: string): string;
+/** The context call that reads `sourceNode.sourcePort` at `executionIndex`. */
+export declare function contextRead(em: ArgumentEmission, sourceNode: string, sourcePort: string, executionIndex: string): string;
+/**
+ * Emits `const <id>_execute` from the execute port's connections and returns
+ * that local. One connection is read directly; several are coalesced with
+ * `||`. A source that may not have run reads as `false`.
+ */
+export declare function emitExecuteSignal(em: ArgumentEmission, executeConnections: TConnectionAST[]): string;
+/**
+ * Emits `const <varName>` for a data port with exactly one connection.
+ *
+ * Guards against an undefined execution index whenever the source may not
+ * have run: an optional port on a non-const source (DISJUNCTION nodes), or any
+ * source inside a branch region, whose index is unset on the arm that was not
+ * taken. The second case applies even to a required port -- a convergence
+ * node reachable from several arms has to read ports from all of them, and
+ * the ones belonging to arms that did not run are legitimately absent.
+ *
+ * A FUNCTION port's value is resolved through `__resolveFunction`, so a
+ * registry id works as well as a function; any other value gets the
+ * connection's coercion.
+ */
+export declare function emitSingleConnectionValue(em: ArgumentEmission, portConfig: TPortDefinition, connection: TConnectionAST, varName: string, paramIndex: number): void;
+/**
+ * Emits `const <varName>` for a data port with several connections (a
+ * fan-in). Connections from nodes that do not exist are dropped; each
+ * remaining one is read behind its own guard with its own coercion, and the
+ * reads are merged by mergeAttempts.
+ */
+export declare function emitFanInValue(em: ArgumentEmission, portConfig: TPortDefinition, connections: TConnectionAST[], varName: string, paramIndex: number): void;
+//# sourceMappingURL=connection-reads.d.ts.map

package/dist/generator/control-flow-plan.d.ts

@@ -0,0 +1,74 @@
+import type { TNodeTypeAST, TWorkflowAST, TNodeInstanceAST } from '../ast/types';
+/** The nodes a branching node runs on its success arm and on its failure arm. */
+export interface BranchRegion {
+    successNodes: Set<string>;
+    failureNodes: Set<string>;
+}
+/**
+ * Everything the body generator decides about a workflow's control flow
+ * before it emits a single node. The emission and exit phases only read it.
+ */
+export interface ControlFlowPlan {
+    /** Instance ids (plus Start and Exit) in topological order. */
+    readonly executionOrder: string[];
+    /** Nodes with both onSuccess and onFailure, which open an if/else. */
+    readonly branchingNodes: Set<string>;
+    /**
+     * Each branching node's arms, after the promotions below: a node in two
+     * regions, in both arms of one region, or with a data dependency outside
+     * its arm has been removed from every region.
+     */
+    readonly branchRegions: Map<string, BranchRegion>;
+    /**
+     * Nodes whose execution index can stay undefined, so they are declared
+     * with `let` and read behind an undefined check: nodes in a branch arm (as
+     * found before promotion), branching nodes, pull nodes and node-level
+     * scoped children.
+     */
+    readonly conditionalNodes: Set<string>;
+    /**
+     * The conditional nodes that get a top-level `let <id>Idx` declaration, in
+     * instance order: all of them except per-port scoped children, whose
+     * indices live inside their scope closure.
+     */
+    readonly letIndexNodes: string[];
+    /** Children of per-port scopes; they are emitted inside scope closures. */
+    readonly perPortScopedChildren: Set<string>;
+    /**
+     * Safe ids of branching nodes whose `_success` flag is declared at the top
+     * of the body, because a guard outside their branch block may read it. In
+     * declaration order.
+     */
+    readonly topLevelSuccessFlags: Set<string>;
+    /** Nodes taken out of branch arms and emitted at top level behind a STEP guard. */
+    readonly promotedNodes: Set<string>;
+    /** Branching nodes whose `_success` flag a promoted node's STEP guard reads. */
+    readonly branchingNodesNeedingSuccessFlag: Set<string>;
+    /** Flattened sequential branching chains, keyed by chain head. */
+    readonly branchingChains: Map<string, string[]>;
+    /** Non-head chain nodes; their chain head emits them. */
+    readonly chainMembers: Set<string>;
+    /** For each node in a Promise.all group, the whole group. */
+    readonly parallelGroupOf: Map<string, string[]>;
+}
+/**
+ * Whether an instance runs lazily (pull execution), and which port triggers
+ * it. The instance config wins over the node type's default config.
+ */
+export declare function getPullExecutionConfig(instance: TNodeInstanceAST, nodeType: TNodeTypeAST): {
+    enabled: boolean;
+    triggerPort: string;
+};
+/**
+ * Analyzes a workflow's control flow: execution order, branch regions and
+ * which nodes leave them, the nodes that need a `let` index, which
+ * `_success` flags must be tracked, the branching chains to flatten and the
+ * parallel groups. It emits nothing.
+ *
+ * Branching chains and parallel groups are both off for a durable workflow:
+ * a durable execution address must keep every branch frame and run in order.
+ * Parallel groups are also off for a sync body, which has no event loop to
+ * overlap nodes on.
+ */
+export declare function analyzeControlFlow(workflow: TWorkflowAST, nodeTypes: TNodeTypeAST[], isAsync: boolean, durableSequential: boolean): ControlFlowPlan;
+//# sourceMappingURL=control-flow-plan.d.ts.map

package/dist/generator/control-flow.d.ts

@@ -37,7 +37,7 @@ export declare function findAllBranchingNodes(workflow: TWorkflowAST, nodeTypes:
  * - Execute in parent's scope block within main control flow
  */
 export declare function isPerPortScopedChild(instance: TNodeInstanceAST, workflow: TWorkflowAST, nodeTypes: TNodeTypeAST[]): boolean;
-export declare function findNodesInBranch(branchNode: string, branchPort: typeof RESERVED_PORT_NAMES.ON_SUCCESS | typeof RESERVED_PORT_NAMES.ON_FAILURE, workflow: TWorkflowAST, allNodes: Set<string>, stopAtBranchingNodes: Set<string>, _allParsedNodeTypes?: TNodeTypeAST[]): Set<string>;
+export declare function findNodesInBranch(branchNode: string, branchPort: typeof RESERVED_PORT_NAMES.ON_SUCCESS | typeof RESERVED_PORT_NAMES.ON_FAILURE, workflow: TWorkflowAST, allNodes: Set<string>, stopAtBranchingNodes: Set<string>): Set<string>;
 /**
  * Detect sequential chains of branching nodes where flattening can reduce nesting.
  *

package/dist/generator/exit-assembly.d.ts

@@ -0,0 +1,11 @@
+import type { TNodeTypeAST, TWorkflowAST } from '../ast/types';
+import { type ControlFlowPlan } from './control-flow-plan';
+/**
+ * Emits the end of a workflow body: the Exit execution, one value per
+ * declared exit port, the onSuccess/onFailure defaults, and the result that
+ * is reported and returned.
+ *
+ * @param isAsync - The effective async mode (dev bodies are always async).
+ */
+export declare function emitExitAssembly(lines: string[], workflow: TWorkflowAST, nodeTypes: TNodeTypeAST[], plan: ControlFlowPlan, isAsync: boolean, production: boolean): void;
+//# sourceMappingURL=exit-assembly.d.ts.map

package/dist/generator/index.d.ts

@@ -1,11 +1,10 @@
 /**
- * Generator utilities — public barrel for export target packs.
+ * Generator utilities: the public barrel for export target packs.
  *
  * Exposes control-flow analysis and code generation helpers used by
- * compile targets (Inngest deep generator, CI/CD compile target, etc.).
+ * compile targets (e.g. the Inngest deep generator and other pack targets).
  */
 export { buildControlFlowGraph, detectBranchingChains, findAllBranchingNodes, findNodesInBranch, performKahnsTopologicalSort, isPerPortScopedChild, computeParallelLevels, determineExecutionOrder, type ControlFlowGraph, } from './control-flow.js';
-export { toValidIdentifier, getCoercionWrapper, buildMergeExpression, buildNodeArgumentsWithContext, generateNodeWithExecutionContext, buildExecutionContextReturnForBranch, type TBuildNodeArgsOptions, } from './code-utils.js';
-export { compileTargetRegistry, type CompileTarget, } from './compile-target-registry.js';
-export { devModeRegistry, type DevModeProvider, type DevModeOptions, } from './dev-mode-registry.js';
+export { toValidIdentifier, getCoercionWrapper, buildMergeExpression, } from './code-utils.js';
+export { buildNodeArgumentsWithContext, type TBuildNodeArgsOptions, } from './node-arguments.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/generator/index.js

@@ -1,11 +1,34 @@
-/**
- * Generator utilities — public barrel for export target packs.
- *
- * Exposes control-flow analysis and code generation helpers used by
- * compile targets (Inngest deep generator, CI/CD compile target, etc.).
- */
-export { buildControlFlowGraph, detectBranchingChains, findAllBranchingNodes, findNodesInBranch, performKahnsTopologicalSort, isPerPortScopedChild, computeParallelLevels, determineExecutionOrder, } from './control-flow.js';
-export { toValidIdentifier, getCoercionWrapper, buildMergeExpression, buildNodeArgumentsWithContext, generateNodeWithExecutionContext, buildExecutionContextReturnForBranch, } from './code-utils.js';
-export { compileTargetRegistry, } from './compile-target-registry.js';
-export { devModeRegistry, } from './dev-mode-registry.js';
-//# sourceMappingURL=index.js.map
+import {
+  buildMergeExpression,
+  buildNodeArgumentsWithContext,
+  getCoercionWrapper,
+  toValidIdentifier
+} from "../chunks/chunk-5Y3AIUWY.js";
+import {
+  buildControlFlowGraph,
+  computeParallelLevels,
+  detectBranchingChains,
+  determineExecutionOrder,
+  findAllBranchingNodes,
+  findNodesInBranch,
+  isPerPortScopedChild,
+  performKahnsTopologicalSort
+} from "../chunks/chunk-4EUSHAY6.js";
+import "../chunks/chunk-4KDUEOFD.js";
+import "../chunks/chunk-E5WN7IGO.js";
+import "../chunks/chunk-R4QGNK34.js";
+import "../chunks/chunk-SEWDMQ6Q.js";
+export {
+  buildControlFlowGraph,
+  buildMergeExpression,
+  buildNodeArgumentsWithContext,
+  computeParallelLevels,
+  detectBranchingChains,
+  determineExecutionOrder,
+  findAllBranchingNodes,
+  findNodesInBranch,
+  getCoercionWrapper,
+  isPerPortScopedChild,
+  performKahnsTopologicalSort,
+  toValidIdentifier
+};

package/dist/generator/input-port-values.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The value of one data input port in a node's argument list.
+ *
+ * Decides where the value comes from, in priority order: an instance-level
+ * expression, the port's connections, the node type's expression, the port's
+ * default, `undefined` for an optional port, and a typed `undefined` for a
+ * required port nothing feeds. Also emits the input event that makes the
+ * value visible to breakpoints and inspection.
+ */
+import { type ArgumentEmission } from './connection-reads';
+/**
+ * Emits the VARIABLE_SET event for an input port (execute included) when the
+ * caller asked for input events. `durable: false`: an input is visible to
+ * live debugging but is not a graph-owned output a continuation records.
+ */
+export declare function emitInputEvent(em: ArgumentEmission, portName: string, value: string): void;
+/**
+ * Emits `const <id>_<port>` holding a data input port's value and returns
+ * that local. The caller pushes it as the next argument, at `paramIndex`.
+ */
+export declare function emitInputPortValue(em: ArgumentEmission, portName: string, paramIndex: number): string;
+//# sourceMappingURL=input-port-values.d.ts.map