@jsleekr/graft 5.7.0

package/dist/analyzer/types.js

@@ -0,0 +1,323 @@
+import { BUILTIN_FUNCTIONS } from '../parser/ast.js';
+import { GraftError } from '../errors/diagnostics.js';
+import { ProgramIndex } from '../program-index.js';
+export class TypeChecker {
+    program;
+    index;
+    constructor(program, index) {
+        this.program = program;
+        this.index = index ?? new ProgramIndex(program);
+    }
+    check() {
+        const diagnostics = [];
+        this.checkEdgeTransforms(diagnostics);
+        this.checkWritesSchemaOverlap(diagnostics);
+        this.checkConditionTypes(diagnostics);
+        this.checkExprTypes(diagnostics);
+        return diagnostics;
+    }
+    checkWritesSchemaOverlap(diagnostics) {
+        for (const node of this.program.nodes) {
+            if (node.writes.length === 0)
+                continue;
+            const producesFields = this.index.producesFieldsMap.get(node.name);
+            if (!producesFields)
+                continue; // scope checker catches
+            for (const writeRef of node.writes) {
+                const memoryFields = this.index.memoryFieldsMap.get(writeRef.memory);
+                if (!memoryFields)
+                    continue; // scope checker catches undeclared
+                let hasOverlap = false;
+                for (const field of producesFields.keys()) {
+                    if (memoryFields.has(field)) {
+                        hasOverlap = true;
+                        break;
+                    }
+                }
+                if (!hasOverlap) {
+                    diagnostics.push(new GraftError(`Node '${node.name}' writes to memory '${writeRef.memory}' but produces no matching fields`, node.location, 'warning', 'TYPE_SCHEMA_MISMATCH'));
+                }
+            }
+        }
+    }
+    checkEdgeTransforms(errors) {
+        for (const edge of this.program.edges) {
+            const sourceFields = this.index.producesFieldsMap.get(edge.source);
+            if (!sourceFields)
+                continue; // scope checker will catch this
+            for (const transform of edge.transforms) {
+                if (transform.type === 'select') {
+                    for (const f of transform.fields) {
+                        if (!sourceFields.has(f)) {
+                            errors.push(new GraftError(`select: field '${f}' does not exist in '${edge.source}' output`, edge.location, 'error', 'TYPE_FIELD_NOT_FOUND'));
+                        }
+                    }
+                }
+                else if (transform.type === 'filter') {
+                    if (!sourceFields.has(transform.field)) {
+                        errors.push(new GraftError(`filter: field '${transform.field}' does not exist in '${edge.source}' output`, edge.location, 'error', 'TYPE_FIELD_NOT_FOUND'));
+                    }
+                }
+                else if (transform.type === 'drop') {
+                    if (!sourceFields.has(transform.field)) {
+                        errors.push(new GraftError(`drop: field '${transform.field}' does not exist in '${edge.source}' output`, edge.location, 'error', 'TYPE_FIELD_NOT_FOUND'));
+                    }
+                }
+            }
+        }
+    }
+    checkConditionTypes(errors) {
+        for (const edge of this.program.edges) {
+            if (edge.target.kind !== 'conditional')
+                continue;
+            const sourceFields = this.index.producesFieldsMap.get(edge.source);
+            if (!sourceFields)
+                continue; // scope checker catches this
+            for (const branch of edge.target.branches) {
+                if (!branch.condition)
+                    continue; // else branch
+                const cond = branch.condition;
+                if (cond.kind !== 'binary')
+                    continue;
+                const { op } = cond;
+                // Only ordered comparisons need numeric types
+                if (op === '==' || op === '!=')
+                    continue;
+                // Extract field name from left side
+                const field = cond.left.kind === 'field_access'
+                    ? cond.left.segments.join('.')
+                    : cond.left.kind === 'call'
+                        ? `${cond.left.name}(...)`
+                        : '<expr>';
+                const fieldType = sourceFields.get(field);
+                if (!fieldType)
+                    continue; // scope checker catches this
+                if (!isNumericType(fieldType)) {
+                    errors.push(new GraftError(`Ordered comparison '${op}' requires numeric type, but field '${field}' has type '${fieldType.kind === 'primitive' ? fieldType.name : fieldType.kind}'`, edge.location, 'error', 'TYPE_CONDITION_MISMATCH'));
+                }
+            }
+        }
+    }
+    checkExprTypes(errors) {
+        for (const graph of this.program.graphs) {
+            const varTypes = new Map();
+            this.walkFlowForTypes(graph.flow, varTypes, errors);
+            this.checkVarConditionTypes(varTypes, errors);
+        }
+    }
+    walkFlowForTypes(nodes, varTypes, errors) {
+        for (const step of nodes) {
+            if (step.kind === 'let') {
+                const inferred = this.inferExprType(step.value, varTypes);
+                varTypes.set(step.name, inferred);
+                this.checkExprTypeErrors(step.value, varTypes, errors);
+            }
+            else if (step.kind === 'foreach') {
+                const bodyTypes = new Map(varTypes);
+                bodyTypes.set(step.binding, 'unknown');
+                this.walkFlowForTypes(step.body, bodyTypes, errors);
+            }
+        }
+    }
+    inferExprType(expr, varTypes) {
+        switch (expr.kind) {
+            case 'literal': {
+                const v = expr.value;
+                if (typeof v === 'number')
+                    return 'number';
+                if (typeof v === 'string')
+                    return 'string';
+                if (typeof v === 'boolean')
+                    return 'boolean';
+                return 'unknown';
+            }
+            case 'field_access': {
+                // Single-segment: check varTypes first (variable-first resolution)
+                if (expr.segments.length === 1) {
+                    const varType = varTypes.get(expr.segments[0]);
+                    if (varType)
+                        return varType;
+                }
+                // Multi-segment: first segment is node name, second is field name
+                if (expr.segments.length >= 2) {
+                    const fields = this.index.producesFieldsMap.get(expr.segments[0]);
+                    if (fields) {
+                        const fieldType = fields.get(expr.segments[1]);
+                        if (fieldType)
+                            return typeExprToInferred(fieldType);
+                    }
+                }
+                return 'unknown';
+            }
+            case 'binary': {
+                const leftType = this.inferExprType(expr.left, varTypes);
+                const rightType = this.inferExprType(expr.right, varTypes);
+                // Null coalescing: result type is right side (fallback) if left is unknown
+                if (expr.op === '??') {
+                    if (leftType !== 'unknown')
+                        return leftType;
+                    return rightType;
+                }
+                // Logical and comparison operators return boolean
+                if (expr.op === '&&' || expr.op === '||')
+                    return 'boolean';
+                if (expr.op === '<' || expr.op === '>' || expr.op === '<=' || expr.op === '>=' || expr.op === '==' || expr.op === '!=') {
+                    return 'boolean';
+                }
+                if (expr.op === '+') {
+                    if (leftType === 'string' || rightType === 'string')
+                        return 'string';
+                    if (leftType === 'number' && rightType === 'number')
+                        return 'number';
+                    return 'unknown';
+                }
+                return 'number'; // -, *, /, % produce numbers
+            }
+            case 'unary': {
+                if (expr.op === '!')
+                    return 'boolean';
+                return 'number'; // unary minus
+            }
+            case 'group':
+                return this.inferExprType(expr.inner, varTypes);
+            case 'call': {
+                const builtin = BUILTIN_FUNCTIONS[expr.name];
+                return builtin?.returnType ?? 'unknown';
+            }
+            case 'template':
+                return 'string';
+            case 'conditional': {
+                const consequentType = this.inferExprType(expr.consequent, varTypes);
+                const alternateType = this.inferExprType(expr.alternate, varTypes);
+                if (consequentType === alternateType)
+                    return consequentType;
+                return 'unknown';
+            }
+            default: {
+                const _exhaustive = expr;
+                return _exhaustive;
+            }
+        }
+    }
+    checkExprTypeErrors(expr, varTypes, errors) {
+        if (expr.kind === 'binary') {
+            const leftType = this.inferExprType(expr.left, varTypes);
+            const rightType = this.inferExprType(expr.right, varTypes);
+            if (leftType !== 'unknown' && rightType !== 'unknown') {
+                if (expr.op === '??') {
+                    // No constraints — any types allowed
+                }
+                else if (expr.op === '&&' || expr.op === '||') {
+                    if (leftType !== 'boolean' || rightType !== 'boolean') {
+                        errors.push(new GraftError(`Operator '${expr.op}' expects boolean operands, got '${leftType}' and '${rightType}'`, expr.location, 'warning', 'TYPE_EXPR_MISMATCH'));
+                    }
+                }
+                else if (expr.op === '==' || expr.op === '!=') {
+                    // Equality allows any types
+                }
+                else if (expr.op === '<' || expr.op === '>' || expr.op === '<=' || expr.op === '>=') {
+                    if (leftType !== 'number' || rightType !== 'number') {
+                        errors.push(new GraftError(`Operator '${expr.op}' requires numeric operands, got '${leftType}' and '${rightType}'`, expr.location, 'error', 'TYPE_EXPR_MISMATCH'));
+                    }
+                }
+                else if (expr.op === '+') {
+                    if (leftType !== rightType) {
+                        errors.push(new GraftError(`Operator '+' cannot be applied to types '${leftType}' and '${rightType}'`, expr.location, 'error', 'TYPE_EXPR_MISMATCH'));
+                    }
+                }
+                else {
+                    if (leftType !== 'number' || rightType !== 'number') {
+                        errors.push(new GraftError(`Operator '${expr.op}' requires numeric operands, got '${leftType}' and '${rightType}'`, expr.location, 'error', 'TYPE_EXPR_MISMATCH'));
+                    }
+                }
+            }
+            this.checkExprTypeErrors(expr.left, varTypes, errors);
+            this.checkExprTypeErrors(expr.right, varTypes, errors);
+        }
+        else if (expr.kind === 'unary') {
+            const operandType = this.inferExprType(expr.operand, varTypes);
+            if (operandType !== 'unknown') {
+                if (expr.op === '!' && operandType !== 'boolean') {
+                    errors.push(new GraftError(`Operator '!' requires boolean operand, got '${operandType}'`, expr.location, 'error', 'TYPE_EXPR_MISMATCH'));
+                }
+                else if (expr.op === '-' && operandType !== 'number') {
+                    errors.push(new GraftError(`Unary '-' requires numeric operand, got '${operandType}'`, expr.location, 'error', 'TYPE_EXPR_MISMATCH'));
+                }
+            }
+            this.checkExprTypeErrors(expr.operand, varTypes, errors);
+        }
+        else if (expr.kind === 'group') {
+            this.checkExprTypeErrors(expr.inner, varTypes, errors);
+        }
+        else if (expr.kind === 'call') {
+            const builtin = BUILTIN_FUNCTIONS[expr.name];
+            if (builtin && expr.args.length !== builtin.arity) {
+                errors.push(new GraftError(`Function '${expr.name}' expects ${builtin.arity} argument(s), got ${expr.args.length}`, expr.location, 'error', 'TYPE_FUNC_ARITY'));
+            }
+            for (const arg of expr.args) {
+                this.checkExprTypeErrors(arg, varTypes, errors);
+            }
+        }
+        else if (expr.kind === 'template') {
+            for (const part of expr.parts) {
+                if (part.kind === 'expr') {
+                    this.checkExprTypeErrors(part.value, varTypes, errors);
+                }
+            }
+        }
+        else if (expr.kind === 'conditional') {
+            const consType = this.inferExprType(expr.consequent, varTypes);
+            const altType = this.inferExprType(expr.alternate, varTypes);
+            if (consType !== 'unknown' && altType !== 'unknown' && consType !== altType) {
+                errors.push(new GraftError(`Conditional branches have different types: '${consType}' and '${altType}'`, expr.location, 'warning', 'TYPE_CONDITIONAL_MISMATCH'));
+            }
+            this.checkExprTypeErrors(expr.condition, varTypes, errors);
+            this.checkExprTypeErrors(expr.consequent, varTypes, errors);
+            this.checkExprTypeErrors(expr.alternate, varTypes, errors);
+        }
+    }
+    checkVarConditionTypes(varTypes, errors) {
+        for (const edge of this.program.edges) {
+            if (edge.target.kind !== 'conditional')
+                continue;
+            for (const branch of edge.target.branches) {
+                if (!branch.condition)
+                    continue;
+                const cond = branch.condition;
+                if (cond.kind !== 'binary')
+                    continue;
+                const { op, left } = cond;
+                if (op === '==' || op === '!=')
+                    continue;
+                // Check if condition LHS is a variable reference (single-segment field_access)
+                if (left.kind === 'field_access' && left.segments.length === 1) {
+                    const varName = left.segments[0];
+                    const varType = varTypes.get(varName);
+                    if (varType && varType !== 'unknown' && varType !== 'number') {
+                        errors.push(new GraftError(`Ordered comparison '${op}' requires numeric type, but variable '${varName}' has type '${varType}'`, edge.location, 'error', 'TYPE_VAR_CONDITION'));
+                    }
+                }
+            }
+        }
+    }
+}
+function typeExprToInferred(type) {
+    if (type.kind === 'primitive') {
+        switch (type.name) {
+            case 'String': return 'string';
+            case 'Int':
+            case 'Float': return 'number';
+            case 'Bool': return 'boolean';
+        }
+    }
+    if (type.kind === 'primitive_range')
+        return 'number';
+    return 'unknown';
+}
+function isNumericType(type) {
+    if (type.kind === 'primitive')
+        return type.name === 'Int' || type.name === 'Float';
+    if (type.kind === 'primitive_range')
+        return true;
+    return false;
+}

package/dist/codegen/agents.d.ts

@@ -0,0 +1,2 @@
+import { NodeDecl } from '../parser/ast.js';
+export declare function generateAgent(node: NodeDecl, memoryNames?: Set<string>, inputOverrides?: Map<string, string>): string;

package/dist/codegen/agents.js

@@ -0,0 +1,109 @@
+import { MODEL_MAP } from '../constants.js';
+import { fieldsToJsonExample } from '../utils.js';
+const TOOL_MAP = {
+    file_read: ['Read'],
+    file_write: ['Write', 'Edit'],
+    terminal: ['Bash'],
+    ast_parse: ['Bash'],
+    test_run: ['Bash'],
+    lint: ['Bash'],
+    browser: ['Bash'],
+};
+export function generateAgent(node, memoryNames = new Set(), inputOverrides = new Map()) {
+    const name = node.name.toLowerCase();
+    const resolvedModel = MODEL_MAP[node.model] || node.model;
+    const tools = resolveTools(node.tools);
+    const jsonSchema = fieldsToJsonExample(node.produces.fields);
+    const failureSection = formatFailure(node);
+    const writesSection = formatWrites(node, memoryNames);
+    const toolsLine = tools.length > 0 ? `\ntools: [${tools.join(', ')}]` : '';
+    return `---
+name: ${name}
+description: ${node.name} agent — produces ${node.produces.name}
+model: ${resolvedModel}${toolsLine}
+---
+
+# ${node.name} Agent
+
+## Context Loading
+${formatReads(node, memoryNames, inputOverrides)}
+${writesSection}## Output Contract
+Produce JSON output matching this schema:
+\`\`\`json
+${JSON.stringify(jsonSchema, null, 2)}
+\`\`\`
+
+## Token Discipline
+- Input budget: ${node.budgetIn} tokens. Read only what is necessary.
+- Output budget: ${node.budgetOut} tokens. No explanations, no reasoning traces.
+- Output ONLY the JSON result.
+
+## Completion Protocol
+1. Write result to \`.graft/session/node_outputs/${name}.json\`
+2. Output: \`===NODE_COMPLETE:${name}===\`
+
+${failureSection}`;
+}
+function resolveTools(tools) {
+    const resolved = new Set();
+    for (const tool of tools) {
+        const mapped = TOOL_MAP[tool];
+        if (mapped) {
+            for (const t of mapped)
+                resolved.add(t);
+        }
+        else {
+            resolved.add(tool);
+        }
+    }
+    return [...resolved];
+}
+function formatReads(node, memoryNames, inputOverrides = new Map()) {
+    if (node.reads.length === 0)
+        return 'No external context required.';
+    return node.reads.map(ref => {
+        const isMemory = memoryNames.has(ref.context);
+        const fieldLabel = ref.field
+            ? (ref.field.length === 1 ? `.${ref.field[0]}` : `.{${ref.field.join(', ')}}`)
+            : '';
+        // Check if there's an edge-transformed input override for this context
+        const override = inputOverrides.get(ref.context);
+        if (override) {
+            return `- Load \`${ref.context}${fieldLabel}\` from \`${override}\``;
+        }
+        const dir = isMemory ? `.graft/memory/${ref.context.toLowerCase()}.json` : '.graft/session/';
+        return `- Load \`${ref.context}${fieldLabel}\` from \`${dir}\``;
+    }).join('\n');
+}
+function formatWrites(node, memoryNames) {
+    const memoryWrites = node.writes.filter(w => memoryNames.has(w.memory));
+    if (memoryWrites.length === 0)
+        return '';
+    return `
+## Memory Saving
+After producing output, save to persistent memory:
+${memoryWrites.map(w => {
+        const fieldLabel = w.field ? `.${w.field}` : '';
+        return `- Save to \`.graft/memory/${w.memory.toLowerCase()}.json\`${fieldLabel ? ` (field: ${w.field})` : ''}`;
+    }).join('\n')}
+
+`;
+}
+function formatFailure(node) {
+    const name = node.name.toLowerCase();
+    if (!node.onFailure) {
+        return `## Failure Protocol\nOn failure, output: \`===NODE_FAILED:${name}===\``;
+    }
+    switch (node.onFailure.type) {
+        case 'retry':
+            return `## Failure Protocol\nRetry up to ${node.onFailure.max} times. After ${node.onFailure.max} failures, output: \`===NODE_FAILED:${name}===\``;
+        case 'fallback':
+            return `## Failure Protocol\nOn failure, delegate to ${node.onFailure.node} agent. If fallback also fails, output: \`===NODE_FAILED:${name}===\``;
+        case 'retry_then_fallback':
+            return `## Failure Protocol\nRetry up to ${node.onFailure.max} times. After ${node.onFailure.max} failures, delegate to ${node.onFailure.node} agent. If fallback also fails, output: \`===NODE_FAILED:${name}===\``;
+        case 'skip':
+            return `## Failure Protocol\nOn failure, skip this node. Output: \`===NODE_SKIPPED:${name}===\``;
+        case 'abort':
+            return `## Failure Protocol\nOn failure, abort the entire pipeline. Output: \`===PIPELINE_ABORTED:${name}===\``;
+    }
+}

package/dist/codegen/backend.d.ts

@@ -0,0 +1,16 @@
+import { Program, NodeDecl, EdgeDecl } from '../parser/ast.js';
+import { TokenReport } from '../analyzer/estimator.js';
+import { ProgramIndex } from '../program-index.js';
+export interface CodegenContext {
+    program: Program;
+    report: TokenReport;
+    index: ProgramIndex;
+    sourceFile: string;
+}
+export interface CodegenBackend {
+    readonly name: string;
+    generateAgent(node: NodeDecl, memoryNames: Set<string>, ctx: CodegenContext): string;
+    generateHook(edge: EdgeDecl, ctx: CodegenContext): string | null;
+    generateOrchestration(ctx: CodegenContext): string;
+    generateSettings(ctx: CodegenContext): Record<string, unknown>;
+}

package/dist/codegen/backend.js

@@ -0,0 +1 @@
+export {};

package/dist/codegen/claude-backend.d.ts

@@ -0,0 +1,9 @@
+import { NodeDecl, EdgeDecl } from '../parser/ast.js';
+import { CodegenBackend, CodegenContext } from './backend.js';
+export declare class ClaudeCodeBackend implements CodegenBackend {
+    readonly name = "claude";
+    generateAgent(node: NodeDecl, memoryNames: Set<string>, ctx: CodegenContext): string;
+    generateHook(edge: EdgeDecl, _ctx: CodegenContext): string | null;
+    generateOrchestration(ctx: CodegenContext): string;
+    generateSettings(ctx: CodegenContext): Record<string, unknown>;
+}

package/dist/codegen/claude-backend.js

@@ -0,0 +1,47 @@
+import { generateAgent } from './agents.js';
+import { generateHook } from './hooks.js';
+import { generateOrchestration } from './orchestration.js';
+import { generateSettings } from './settings.js';
+export class ClaudeCodeBackend {
+    name = 'claude';
+    generateAgent(node, memoryNames, ctx) {
+        // Compute input overrides: map produces names to actual file paths
+        const inputOverrides = new Map();
+        // 1. For edges with transforms: use the transformed output path
+        // 2. For edges without transforms: use the source's raw output path
+        for (const edge of ctx.program.edges) {
+            if (edge.target.kind === 'direct' && edge.target.node === node.name) {
+                const sourceNode = ctx.program.nodes.find(n => n.name === edge.source);
+                if (sourceNode) {
+                    const producesName = sourceNode.produces.name;
+                    if (edge.transforms.length > 0) {
+                        inputOverrides.set(producesName, `.graft/session/node_outputs/${edge.source.toLowerCase()}_to_${node.name.toLowerCase()}.json`);
+                    }
+                    else {
+                        inputOverrides.set(producesName, `.graft/session/node_outputs/${edge.source.toLowerCase()}.json`);
+                    }
+                }
+            }
+        }
+        // 3. For produces reads with no corresponding edge: resolve to producer's raw output
+        for (const ref of node.reads) {
+            if (inputOverrides.has(ref.context) || memoryNames.has(ref.context))
+                continue;
+            // Check if this read references a produces type from another node
+            const producerNode = ctx.program.nodes.find(n => n.produces.name === ref.context);
+            if (producerNode && producerNode.name !== node.name) {
+                inputOverrides.set(ref.context, `.graft/session/node_outputs/${producerNode.name.toLowerCase()}.json`);
+            }
+        }
+        return generateAgent(node, memoryNames, inputOverrides);
+    }
+    generateHook(edge, _ctx) {
+        return generateHook(edge);
+    }
+    generateOrchestration(ctx) {
+        return generateOrchestration(ctx.program, ctx.report);
+    }
+    generateSettings(ctx) {
+        return generateSettings(ctx.program, ctx.sourceFile, ctx.index);
+    }
+}

package/dist/codegen/codegen.d.ts

@@ -0,0 +1,10 @@
+import { Program } from '../parser/ast.js';
+import { TokenReport } from '../analyzer/estimator.js';
+import { ProgramIndex } from '../program-index.js';
+import { CodegenBackend } from './backend.js';
+export interface GeneratedFile {
+    path: string;
+    content: string;
+}
+export declare function generate(program: Program, report: TokenReport, sourceFile: string, index?: ProgramIndex, backend?: CodegenBackend): GeneratedFile[];
+export declare function writeFiles(files: GeneratedFile[], outDir: string): void;

package/dist/codegen/codegen.js

@@ -0,0 +1,57 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ProgramIndex } from '../program-index.js';
+import { ClaudeCodeBackend } from './claude-backend.js';
+const defaultBackend = new ClaudeCodeBackend();
+export function generate(program, report, sourceFile, index, backend) {
+    const idx = index ?? new ProgramIndex(program);
+    const be = backend ?? defaultBackend;
+    const ctx = { program, report, index: idx, sourceFile };
+    const files = [];
+    const memoryNames = new Set(program.memories.map(m => m.name));
+    // Agents
+    for (const node of program.nodes) {
+        files.push({
+            path: `.claude/agents/${node.name.toLowerCase()}.md`,
+            content: be.generateAgent(node, memoryNames, ctx),
+        });
+    }
+    // Hooks
+    for (const edge of program.edges) {
+        const hook = be.generateHook(edge, ctx);
+        if (hook && edge.target.kind === 'direct') {
+            const source = edge.source.toLowerCase();
+            const target = edge.target.node.toLowerCase();
+            files.push({
+                path: `.claude/hooks/${source}-to-${target}.js`,
+                content: hook,
+            });
+        }
+    }
+    // Orchestration
+    files.push({
+        path: '.claude/CLAUDE.md',
+        content: be.generateOrchestration(ctx),
+    });
+    // Settings
+    const settings = be.generateSettings(ctx);
+    files.push({
+        path: '.claude/settings.json',
+        content: JSON.stringify(settings, null, 2),
+    });
+    // Runtime scaffold
+    files.push({ path: '.graft/session/node_outputs/.gitkeep', content: '' });
+    files.push({ path: '.graft/token_log.txt', content: '' });
+    // Memory scaffold — conditional
+    if (program.memories.length > 0) {
+        files.push({ path: '.graft/memory/.gitkeep', content: '' });
+    }
+    return files;
+}
+export function writeFiles(files, outDir) {
+    for (const file of files) {
+        const fullPath = path.join(outDir, file.path);
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, file.content, 'utf-8');
+    }
+}

package/dist/codegen/hooks.d.ts

@@ -0,0 +1,2 @@
+import { EdgeDecl } from '../parser/ast.js';
+export declare function generateHook(edge: EdgeDecl): string | null;