@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/api/generate-in-place.d.ts

@@ -2,18 +2,20 @@
  * In-Place Code Generation
  *
  * Generates executable code directly into the source file while preserving
- * user code (node functions). Updates:
- * - Runtime section (between markers)
- * - Workflow JSDoc annotations (when AST changes)
- * - Function body (between markers)
+ * user code (node functions). This module decides the order of the rewrite
+ * steps and what `annotationsOnly` stops short of; each step lives in
+ * `./in-place/`:
+ * - node-type-functions: JSDoc (and text) of node types the file owns
+ * - built-in-nodes: built-in node functions the workflow uses, inlined
+ * - orphaned-node-types: node type functions no workflow uses any more
+ * - workflow-jsdoc: the workflow function's JSDoc
+ * - fw-imports: import statements for `@fwImport` node types
+ * - runtime-section: the inlined runtime between its markers
+ * - signature: `params`, `__runtime__`, `async` and `Promise<T>`
+ * - function-body: the generated body between its markers
  */
-import type { TWorkflowAST, TModuleFormat } from '../ast/types.js';
-export declare const MARKERS: {
-    RUNTIME_START: string;
-    RUNTIME_END: string;
-    BODY_START: string;
-    BODY_END: string;
-};
+import type { TModuleFormat, TWorkflowAST } from '../ast/types';
+export { MARKERS, hasInPlaceMarkers, stripGeneratedSections } from '../parser/generated-sections';
 export interface InPlaceGenerateOptions {
     /**
      * Whether to generate production-optimized code (no debug events)
@@ -39,6 +41,14 @@ export interface InPlaceGenerateOptions {
      * so these annotations are redundant for non-visual-editor users.
      */
     skipParamReturns?: boolean;
+    /**
+     * When true, only the JSDoc annotations (node types and the workflow) are
+     * rewritten. No runtime section, generated body, inlined built-ins, or
+     * signature edits are produced. Structural edits (`fw modify`, `fw_modify`)
+     * use this on a file that has never been compiled in place, so an
+     * uncompiled source stays an uncompiled source.
+     */
+    annotationsOnly?: boolean;
 }
 export interface InPlaceGenerateResult {
     code: string;
@@ -53,12 +63,4 @@ export interface InPlaceGenerateResult {
  * @returns The updated source code with generated sections
  */
 export declare function generateInPlace(sourceCode: string, ast: TWorkflowAST, options?: InPlaceGenerateOptions): InPlaceGenerateResult;
-/**
- * Check if source code has in-place generation markers
- */
-export declare function hasInPlaceMarkers(source: string): boolean;
-/**
- * Remove all generated sections from source code
- */
-export declare function stripGeneratedSections(source: string): string;
 //# sourceMappingURL=generate-in-place.d.ts.map

package/dist/api/generate.d.ts

@@ -1,4 +1,23 @@
-import type { TGenerateOptions as ASTGenerateOptions, TWorkflowAST, TModuleFormat } from '../ast/types.js';
+/**
+ * Whole-module code generation.
+ *
+ * generateCode decides what a generated workflow module contains and in which
+ * order: the inlined runtime, the type declarations preserved from the
+ * source, imports of node types from other files and packages, source
+ * constants, the local node functions, the same-file workflows used as
+ * nodes, the exported workflow function, and CJS exports. It also decides the
+ * checks made before anything is emitted (stub nodes, async detection) and
+ * how the text is finished (JavaScript output, source map). Each section
+ * lives in `./generated-module/`:
+ * - preamble: the inlined runtime and preserved type declarations
+ * - node-type-imports: where each node type comes from, and its imports
+ * - local-node-functions: source constants, shared helpers, inlined functions
+ * - workflow-functions: the signature, the workflow and its local dependencies
+ * - module-format: ESM/CJS import and export syntax
+ * - module-writer: the text and the source map line tracking
+ */
+import type { TGenerateOptions as ASTGenerateOptions, TWorkflowAST, TModuleFormat } from '../ast/types';
+export { generateImportStatement, generateFunctionExportKeyword, generateModuleExports, } from './generated-module/module-format';
 export interface GenerateOptions extends Partial<ASTGenerateOptions> {
     /**
      * Whether to generate production-optimized code (no debug events)
@@ -42,20 +61,6 @@ export interface GenerateOptions extends Partial<ASTGenerateOptions> {
      */
     generateStubs?: boolean;
 }
-/**
- * Generate an import statement in the appropriate module format
- */
-export declare function generateImportStatement(names: string[], source: string, moduleFormat: TModuleFormat): string;
-/**
- * Generate an export statement for a function in the appropriate module format
- * For ESM: export async function name() { }
- * For CJS: async function name() { } (module.exports added at end)
- */
-export declare function generateFunctionExportKeyword(moduleFormat: TModuleFormat): string;
-/**
- * Generate module.exports statement for CJS format
- */
-export declare function generateModuleExports(functionNames: string[]): string;
 export interface GenerateResult {
     code: string;
     sourceMap?: string;
@@ -80,7 +85,7 @@ export interface GenerateResult {
  * }
  * ```
  */
-export declare function generateCode(ast: TWorkflowAST, options?: GenerateOptions & {
+export declare function generateCode(ast: TWorkflowAST, options: GenerateOptions & {
     sourceMap: true;
 }): GenerateResult;
 export declare function generateCode(ast: TWorkflowAST, options?: GenerateOptions): string;

package/dist/api/generated-module/local-node-functions.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The node functions a generated module carries itself.
+ *
+ * Decides, for each local node function, whether it is imported (the caller
+ * maps it in `externalNodeTypes`, as bundle mode does) or inlined; which text
+ * is inlined (the production variant when there is one, decorators removed);
+ * that the helpers built-in nodes share are emitted once, before the
+ * functions; and that source constants the functions refer to come first.
+ */
+import type { TModuleFormat, TNodeTypeAST } from '../../ast/types';
+import type { ModuleWriter } from './module-writer';
+/**
+ * Emits the constants extracted from the source file(s), which inlined local
+ * functions may reference. Only when there are local functions to need them.
+ */
+export declare function emitSourceConstants(writer: ModuleWriter, constants: string[], localFunctions: TNodeTypeAST[]): void;
+/**
+ * Emits the local node functions: an import of the `_impl` for each one
+ * mapped in `externalNodeTypes`, then the shared helpers and the inlined text
+ * of every other one, each mapped to its source location. npm package
+ * functions are never inlined.
+ */
+export declare function emitLocalNodeFunctions(writer: ModuleWriter, localFunctions: TNodeTypeAST[], externalNodeTypes: Record<string, string>, moduleFormat: TModuleFormat, production: boolean): void;
+//# sourceMappingURL=local-node-functions.d.ts.map

package/dist/api/generated-module/module-format.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Import and export syntax for the module format a generated file uses.
+ *
+ * Decides how an import and an exported function are spelled in ESM and in
+ * CJS: `import { a } from 'x'` or `const { a } = require('x')`, and an
+ * `export` keyword or a `module.exports` statement at the end of the file.
+ */
+import type { TModuleFormat } from '../../ast/types';
+/**
+ * Generate an import statement in the appropriate module format
+ */
+export declare function generateImportStatement(names: string[], source: string, moduleFormat: TModuleFormat): string;
+/**
+ * Generate an export statement for a function in the appropriate module format
+ * For ESM: export async function name() { }
+ * For CJS: async function name() { } (module.exports added at end)
+ */
+export declare function generateFunctionExportKeyword(moduleFormat: TModuleFormat): string;
+/**
+ * Generate module.exports statement for CJS format
+ */
+export declare function generateModuleExports(functionNames: string[]): string;
+//# sourceMappingURL=module-format.d.ts.map

package/dist/api/generated-module/module-writer.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The generated module's text and its source map.
+ *
+ * Decides the generated line each appended piece of text starts on, so a
+ * source mapping can point that line back at the workflow source. A mapping
+ * is only recorded when a source map was requested and the workflow has a
+ * source file.
+ */
+export declare class ModuleWriter {
+    private readonly sourceFile;
+    private readonly lines;
+    /** The 1-based generated line the next appended text starts on. */
+    private currentLine;
+    private readonly sourceMap;
+    constructor(workflowFunctionName: string, sourceFile: string | undefined, withSourceMap: boolean);
+    /** Whether mappings are being recorded (a source map was asked for and there is a source file). */
+    get mapsSource(): boolean;
+    /**
+     * Appends a chunk of generated text, which may span several lines. Only
+     * `\n` ends a line: the chunk is joined with `\n`, so that is what the
+     * generated line numbers count.
+     */
+    push(chunk: string): void;
+    /** Maps the line the next appended text starts on to a line of the workflow source. */
+    map(sourceLine: number, sourceColumn?: number): void;
+    /** The module text. */
+    text(): string;
+    /**
+     * The finished source map, with the workflow source's content embedded, or
+     * undefined when none was asked for.
+     */
+    finishSourceMap(readSource: (file: string) => string): string | undefined;
+}
+//# sourceMappingURL=module-writer.d.ts.map

package/dist/api/generated-module/node-type-imports.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Where each node type of a workflow comes from in the generated module.
+ *
+ * Decides the three categories: npm package nodes (they have an
+ * importSource) are imported from their package; node types defined in
+ * another file are imported from that file's generated module (from
+ * `node-types/` and sibling workflow files in bundle mode); node types of the
+ * workflow's own file, and the built-in nodes it uses, are local and emitted
+ * into the module itself.
+ */
+import type { TModuleFormat, TNodeTypeAST, TWorkflowAST } from '../../ast/types';
+import type { ModuleWriter } from './module-writer';
+export interface NodeTypeOrigins {
+    /** Node types imported from an npm package. */
+    npmPackageNodes: TNodeTypeAST[];
+    /**
+     * Node types whose source is not the workflow's file. Built-in nodes (no
+     * source location) are counted here too; they are not imported, but their
+     * presence still opens the import block.
+     */
+    importedNodes: TNodeTypeAST[];
+    /** Local node functions: the file's own node types and the built-ins the workflow uses. */
+    localFunctions: TNodeTypeAST[];
+    /** Workflows of the same file that this workflow uses as nodes. */
+    localWorkflowNodes: TNodeTypeAST[];
+}
+/** Sorts a workflow's node types by where the generated module gets them from. */
+export declare function classifyNodeTypes(ast: TWorkflowAST): NodeTypeOrigins;
+/**
+ * Emits the import block for node types from other files and npm packages,
+ * framed by blank lines, when there are any.
+ *
+ * A node function is imported from the `.generated` module next to its
+ * source file; in bundle mode each one is imported as its `_impl` from
+ * `../node-types/` (the wrapper is only for HTTP entry points). A workflow is
+ * imported from its generated file; in bundle mode from its sibling file.
+ */
+export declare function emitNodeTypeImports(writer: ModuleWriter, origins: NodeTypeOrigins, bundleMode: boolean, moduleFormat: TModuleFormat): void;
+//# sourceMappingURL=node-type-imports.d.ts.map

package/dist/api/generated-module/preamble.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The top of a generated module: the inlined runtime and the type
+ * declarations preserved from the workflow source.
+ *
+ * Decides that the runtime is always inlined (a compiled workflow has no
+ * runtime dependency) and that every interface and type alias of the source
+ * file is carried over, in source order, so node signatures that name them
+ * still compile.
+ */
+import type { TModuleFormat } from '../../ast/types';
+import type { ModuleWriter } from './module-writer';
+/** Emits the inlined runtime for the production or development build, in the module format. */
+export declare function emitInlineRuntime(writer: ModuleWriter, production: boolean, moduleFormat: TModuleFormat): void;
+/** Emits the interfaces and type aliases declared in the workflow's source file, if any. */
+export declare function emitPreservedTypeDeclarations(writer: ModuleWriter, sourceFile: string | undefined): void;
+//# sourceMappingURL=preamble.d.ts.map

package/dist/api/generated-module/workflow-functions.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The workflow functions in a generated module: the exported workflow itself
+ * and the same-file workflows it uses as nodes.
+ *
+ * Decides the generated signature (the v2 ABI: `execute`, `params`, the
+ * required `__runtime__`, and a return type whose exit ports are optional
+ * when the workflow branches), when a function is async (whenever a node is
+ * async, and always outside production so the debugger can pause), and that
+ * each local workflow dependency is emitted once, dependencies first, with
+ * its own graph identity when the closure is durable.
+ *
+ * Params are deliberately not destructured: the body reads Start ports with
+ * ctx.getVariable, and a destructured param would shadow a node function of
+ * the same name (a 'delay' param would shadow a 'delay' node).
+ */
+import type { TModuleFormat, TNodeTypeAST, TWorkflowAST } from '../../ast/types';
+import type { ModuleWriter } from './module-writer';
+/**
+ * Emits the exported workflow function around its generated body, mapping
+ * its first line to the source line that declares the exported function.
+ */
+export declare function emitWorkflowFunction(writer: ModuleWriter, ast: TWorkflowAST, functionBody: string, shouldBeAsync: boolean, production: boolean, moduleFormat: TModuleFormat): void;
+/**
+ * Emits the same-file workflows this workflow uses as nodes, under a banner,
+ * when there are any and the file's workflows were passed in. A dependency
+ * missing from `allWorkflows` gets a warning comment instead.
+ */
+export declare function emitLocalWorkflowDependencies(writer: ModuleWriter, ast: TWorkflowAST, localWorkflowNodes: TNodeTypeAST[], allWorkflows: TWorkflowAST[], production: boolean, durableSequential: boolean): void;
+//# sourceMappingURL=workflow-functions.d.ts.map

package/dist/api/graph-identity.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The identity of a compiled workflow graph, and the graph a continuation is
+ * checked against.
+ *
+ * Three places need the same answer. The executor fingerprints the graph
+ * before a gated run and hands the continuation graph to `decodeContinuation`.
+ * The artifact compiler writes both into a deployable module's metadata. The
+ * code generator bakes the fingerprint into a gated body so the compiled file
+ * can name its own graph when it yields. One computation here keeps them equal.
+ */
+import type { TWorkflowAST } from '../ast/types.js';
+import type { ContinuationGraphCompatibility } from '../runtime/continuation.js';
+export interface GraphIdentity {
+    /** The workflows the root can reach, in name order. */
+    readonly reachable: readonly TWorkflowAST[];
+    readonly capabilities: {
+        readonly gate: boolean;
+        readonly effect: boolean;
+    };
+    /** SHA-256 over the canonical form of the reachable closure's graph manifest. */
+    readonly graphFingerprint: string;
+    readonly continuationGraph: ContinuationGraphCompatibility;
+}
+/**
+ * Compute the graph identity of `root` within `allWorkflows`.
+ *
+ * What goes into the fingerprint is what replaying a continuation depends
+ * on: the instances and their configuration, the connections, the scopes,
+ * the Start and Exit ports, and each node type's ports by name and role
+ * with its durable classification. What stays out is anything that reads
+ * the same graph differently: source locations (a temp copy parses to the
+ * same identity as the file), port labels (a doc comment is not a graph
+ * change) and type spellings (a built-in injected from the registry and
+ * the same built-in inlined by a compile lose their TypeScript types on
+ * re-parse; the graph is the same graph). A changed node body is the
+ * bundle digest's to catch.
+ */
+export declare function graphIdentity(root: TWorkflowAST, allWorkflows?: readonly TWorkflowAST[]): GraphIdentity;
+//# sourceMappingURL=graph-identity.d.ts.map

package/dist/api/helpers.d.ts

@@ -3,8 +3,9 @@
  * Provides immutability via Immer and validation wrappers
  */
 import { type Draft } from "immer";
-import { type ValidationResult } from "./validate.js";
-import type { TWorkflowAST, TNodeInstanceAST, TPortReference } from "../ast/types.js";
+import { type ValidationResult } from "./validate";
+import type { TWorkflowAST, TNodeInstanceAST } from "../ast/types";
+export { validatePortReference, portReferencesEqual, formatPortReference, } from "./port-references";
 /**
  * Wrapper for all mutation operations that ensures:
  * 1. Immutability via Immer's structural sharing (only clones what changes)
@@ -72,7 +73,7 @@ export declare function withMinimalValidation<T extends TWorkflowAST>(ast: T, op
  * ```typescript
  * const newAst = withoutValidation(ast, draft => {
  *   const node = draft.instances.find(n => n.id === nodeId);
- *   if (node) node.x = 100;
+ *   if (node) node.config = { ...node.config, label: 'Main' };
  * });
  * ```
  */
@@ -103,63 +104,6 @@ export interface NodeFilter {
     /** Custom filter predicate */
     predicate?: (node: TNodeInstanceAST) => boolean;
 }
-/**
- * Validates and normalizes port reference format
- * Accepts either string format ("nodeId.portName") or object format ({ node, port })
- *
- * @param ref - Port reference to validate
- * @returns Validated TPortReference object
- * @throws {Error} If format is invalid
- *
- * @example
- * ```typescript
- * // String format
- * const ref1 = validatePortReference("processor1.input");
- * // Returns: { node: "processor1", port: "input" }
- *
- * // Object format
- * const ref2 = validatePortReference({ node: "processor1", port: "input" });
- * // Returns: { node: "processor1", port: "input" }
- *
- * // Invalid format throws error
- * validatePortReference("invalid"); // Throws: Invalid port reference format
- * ```
- */
-export declare function validatePortReference(ref: string | TPortReference): TPortReference;
-/**
- * Checks if two port references point to the same port
- * Compares both node ID and port name for equality
- *
- * @param a - First port reference
- * @param b - Second port reference
- * @returns True if both references point to the same port
- *
- * @example
- * ```typescript
- * const ref1 = { node: "processor1", port: "input" };
- * const ref2 = { node: "processor1", port: "input" };
- * const ref3 = { node: "processor1", port: "output" };
- *
- * portReferencesEqual(ref1, ref2); // true
- * portReferencesEqual(ref1, ref3); // false
- * ```
- */
-export declare function portReferencesEqual(a: TPortReference, b: TPortReference): boolean;
-/**
- * Formats a port reference object as a string
- * Converts { node, port } to "node.port" format
- *
- * @param ref - Port reference to format
- * @returns String representation in "node.port" format
- *
- * @example
- * ```typescript
- * const ref = { node: "processor1", port: "input" };
- * const str = formatPortReference(ref);
- * // Returns: "processor1.input"
- * ```
- */
-export declare function formatPortReference(ref: TPortReference): string;
 /**
  * Helper to generate unique node IDs
  * Uses base name + incrementing counter

package/dist/api/in-place/built-in-nodes.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Inlined built-in node types.
+ *
+ * Built-in node types (sleep, waitForEvent, and the like) are injected by the
+ * parser and have no source in the workflow file. This module decides which
+ * of them a compiled file needs (those the workflow's instances use), and
+ * writes their shared helpers and annotated functions just above the
+ * workflow's JSDoc, so the compiled file is self-contained and a re-parse
+ * still recognizes them, durable classification included.
+ */
+import type { TWorkflowAST } from '../../ast/types';
+import type { SourceEdit } from './source-file';
+/**
+ * Insert the built-in node functions `ast` uses, in their production or
+ * development form, before the workflow function's JSDoc.
+ */
+export declare function inlineBuiltInNodes(source: string, ast: TWorkflowAST, production: boolean): SourceEdit;
+//# sourceMappingURL=built-in-nodes.d.ts.map

package/dist/api/in-place/function-body.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The generated workflow function body.
+ *
+ * Decides the text between the body markers inside the workflow function:
+ * the body generator's output for the workflow, indented one level under a
+ * do-not-edit banner. A function without markers has its whole body replaced
+ * by the marked section; a function with markers has only the marked text
+ * replaced, so anything the author wrote outside the markers stays.
+ */
+import type { TWorkflowAST } from '../../ast/types';
+import type { GraphIdentityStamp } from '../../generator/unified';
+import { type SourceEdit } from './source-file';
+/**
+ * Generate the workflow function body
+ */
+export declare function generateFunctionBody(ast: TWorkflowAST, production: boolean, isAsync: boolean, durableSequential: boolean, identity?: GraphIdentityStamp): string;
+/**
+ * Replace the body of a workflow function with generated code
+ */
+export declare function replaceWorkflowFunctionBody(source: string, functionName: string, newBody: string): SourceEdit;
+//# sourceMappingURL=function-body.d.ts.map

package/dist/api/in-place/fw-imports.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Executable imports for `@fwImport` node types.
+ *
+ * A node type declared with `@fwImport` lives in a package, and the generated
+ * body calls it by bare name. This module decides the local name such a node
+ * type is called by, and the import statements, between the IMPORTS markers
+ * at the top of the file, that bring those names into scope.
+ */
+import type { TNodeTypeAST, TWorkflowAST } from '../../ast/types';
+import type { SourceEdit } from './source-file';
+/**
+ * The function name an imported node type is called by. An explicitly set
+ * functionName wins; otherwise an `npm/<pkg>/<fn>` name yields `<fn>`.
+ */
+export declare function fwImportFunctionName(nodeType: Pick<TNodeTypeAST, 'name' | 'functionName'>): string;
+/**
+ * Emit executable `import { <fn> } from "<pkg>"` statements for every
+ * `@fwImport` node type (those carrying `importSource`), so the generated
+ * body's bare call (`await waitForApproval(...)`) resolves at run time.
+ *
+ * The block is delimited by IMPORTS markers and inserted at the very top of
+ * the file (before any other content), so it's idempotent across re-runs
+ * and survives alongside the user's own imports. When the workflow uses no
+ * `@fwImport` node types the block is empty (markers only) — harmless.
+ *
+ * The function name is derived the same way as the persisted `@fwImport`
+ * JSDoc (npm/<pkg>/<fn> convention or explicit functionName).
+ */
+export declare function ensureFwImportStatements(source: string, ast: TWorkflowAST): SourceEdit;
+//# sourceMappingURL=fw-imports.d.ts.map

package/dist/api/in-place/macro-coverage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Connections implied by workflow macros.
+ *
+ * Decides whether a connection is already expressed by a `@map`, `@path`,
+ * `@fanOut` or `@fanIn` macro, in which case the workflow JSDoc must not
+ * repeat it as an `@connect` line.
+ */
+import type { TConnectionAST, TWorkflowMacro } from '../../ast/types';
+/**
+ * Check if a connection is covered by a macro (and should not be written as @connect).
+ * Handles @map, @path, @fanOut and @fanIn macros.
+ */
+export declare function isConnectionCoveredByMacro(conn: TConnectionAST, macros: TWorkflowMacro[]): boolean;
+//# sourceMappingURL=macro-coverage.d.ts.map

package/dist/api/in-place/node-type-functions.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Node type functions authored in the workflow file.
+ *
+ * Decides which node types this file owns (declared here, not imported, not a
+ * sibling workflow, not a built-in) and brings each one's function in line
+ * with its AST: the JSDoc is regenerated, a renamed node type is found by its
+ * `@name` tag and renamed, stale duplicate `@flowWeaver` comments are
+ * dropped, a changed function text replaces the old one, and a node type
+ * with no function in the file yet has one inserted.
+ */
+import type { TWorkflowAST } from '../../ast/types';
+import { type SourceEdit } from './source-file';
+/**
+ * Rewrite the JSDoc (and, when the AST carries new text, the function) of
+ * every node type the workflow file owns.
+ */
+export declare function syncNodeTypeFunctions(source: string, ast: TWorkflowAST): SourceEdit;
+//# sourceMappingURL=node-type-functions.d.ts.map

package/dist/api/in-place/node-type-jsdoc.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Node type JSDoc text.
+ *
+ * Decides the `@flowWeaver nodeType` comment written above a node type
+ * function: which tags a node type's AST turns into, in which order, and
+ * which ports are left out because a re-parse infers them anyway.
+ */
+import type { TNodeTypeAST } from '../../ast/types';
+/**
+ * Generate JSDoc comment for node type function
+ */
+export declare function generateNodeTypeJSDoc(nodeType: TNodeTypeAST): string;
+/**
+ * JSDoc lines for a node type's durable classification (`@durableGate <kind>`,
+ * `@durableEffect`, `@durablePure`). Each flag is emitted independently so the
+ * authored state round-trips exactly; a doubled classification is a validation
+ * error, not something the generator silently repairs.
+ */
+export declare function durableClassificationLines(nodeType: Pick<TNodeTypeAST, 'durableGate' | 'durableEffect' | 'durablePure'>): string[];
+//# sourceMappingURL=node-type-jsdoc.d.ts.map

package/dist/api/in-place/orphaned-node-types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Orphaned node type functions.
+ *
+ * Decides which `@flowWeaver nodeType` functions in the file no longer belong
+ * to any workflow (typically left behind by a rename) and removes them with
+ * their JSDoc. In a multi-workflow file a function is kept while any of the
+ * file's workflows still uses it.
+ */
+import type { TWorkflowAST } from '../../ast/types';
+import { type SourceEdit } from './source-file';
+/**
+ * Remove nodeType functions that don't match any AST nodeType.
+ * This cleans up orphaned functions left behind after renames.
+ */
+export declare function removeOrphanedNodeTypeFunctions(source: string, ast: TWorkflowAST, allWorkflows?: TWorkflowAST[]): SourceEdit;
+//# sourceMappingURL=orphaned-node-types.d.ts.map

package/dist/api/in-place/runtime-section.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The inlined runtime section.
+ *
+ * Decides what goes between the runtime markers and where that section sits:
+ * the whole runtime is always inlined (a compiled workflow has no runtime
+ * dependency), and a file compiled for the first time gets the section right
+ * after its last import. On a recompile only the text between the markers is
+ * replaced.
+ */
+import { type SourceEdit } from './source-file';
+/**
+ * Write the runtime section for `production` (or development) between the
+ * runtime markers, inserting the markers after the imports when absent.
+ */
+export declare function replaceOrInsertRuntimeSection(source: string, production: boolean): SourceEdit;
+//# sourceMappingURL=runtime-section.d.ts.map

package/dist/api/in-place/signature.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Workflow function signature.
+ *
+ * Decides the parameter list and the async shape of the compiled workflow
+ * function: `params` is always the second parameter, `__runtime__` is always
+ * the last of at most three, and a workflow that must be async is declared
+ * `async` with a `Promise<T>` return type. Everything else in the authored
+ * signature is left as written.
+ */
+import { type SourceEdit } from './source-file';
+/**
+ * Detect if a workflow function is declared as async
+ */
+export declare function detectFunctionIsAsync(source: string, functionName: string): boolean;
+/**
+ * Ensure the workflow function has the `params` parameter.
+ *
+ * The generated body always references `params`: the recursion-depth guard
+ * reads `params.__rd__`, and every Start data port is read as
+ * `params.<portName>`. A workflow whose author signature declares data ports
+ * already has `params`, but one with NO Start data ports (a single zero-input
+ * node, author signature `(execute)`) omits it, and the generated body then
+ * throws `ReferenceError: params is not defined` at runtime.
+ *
+ * `params` must be the SECOND positional parameter (right after `execute`),
+ * because the runtime invokes the workflow as `fn(execute, params, ...)`.
+ * Insert it immediately after the first parameter. If the function somehow
+ * has no parameters, insert it after the opening paren (the `execute` guard
+ * param is always present in practice, so this is defensive).
+ */
+export declare function ensureParamsParameter(source: string, functionName: string): SourceEdit;
+/**
+ * Ensure the workflow function has exactly one __runtime__ parameter.
+ * The A2 major cutover removes generated debugger and AbortSignal parameters.
+ */
+export declare function ensureRuntimeParameter(source: string, functionName: string): SourceEdit;
+/**
+ * Ensure the workflow function has the correct async/non-async modifier.
+ * If shouldBeAsync is true and the function is not async, adds the `async` keyword.
+ */
+export declare function ensureAsyncKeyword(source: string, functionName: string, shouldBeAsync: boolean): SourceEdit;
+/**
+ * Ensure the workflow function's return type is wrapped in Promise<T> when async is required.
+ * If shouldBeAsync is true and the return type is not already Promise<...>, wraps it.
+ */
+export declare function ensurePromiseReturnType(source: string, functionName: string, shouldBeAsync: boolean): SourceEdit;
+//# sourceMappingURL=signature.d.ts.map

package/dist/api/in-place/source-file.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Source text lookup for the in-place rewriter.
+ *
+ * Every rewrite step works on plain text and re-parses it before it edits, so
+ * positions always match the text in hand. This module decides how a function
+ * is found in that text: a top-level function declaration by name, and when a
+ * name is declared twice, the last declaration wins.
+ */
+import * as ts from 'typescript';
+/** The outcome of one rewrite step: the new text, and whether the step changed anything. */
+export type SourceEdit = {
+    code: string;
+    changed: boolean;
+};
+/** Parse source text with parent pointers set, so nodes can report their own text and positions. */
+export declare function parseSource(source: string): ts.SourceFile;
+/** The last top-level function declaration named `functionName`, if any. */
+export declare function findFunctionDeclaration(sourceFile: ts.SourceFile, functionName: string): ts.FunctionDeclaration | undefined;
+//# sourceMappingURL=source-file.d.ts.map