@jsleekr/graft 5.7.0

package/dist/program-index.d.ts

@@ -0,0 +1,21 @@
+import { Program, ContextDecl, NodeDecl, MemoryDecl, EdgeDecl, GraphDecl, TypeExpr, Expr } from './parser/ast.js';
+import type { SourceLocation } from './errors/diagnostics.js';
+export interface LetBinding {
+    name: string;
+    value: Expr;
+    graphName: string;
+    location?: SourceLocation;
+}
+export declare class ProgramIndex {
+    readonly contextMap: Map<string, ContextDecl>;
+    readonly nodeMap: Map<string, NodeDecl>;
+    readonly memoryMap: Map<string, MemoryDecl>;
+    readonly edgesBySource: Map<string, EdgeDecl[]>;
+    readonly producesNodeMap: Map<string, NodeDecl>;
+    readonly graphMap: Map<string, GraphDecl>;
+    readonly producesFieldsMap: Map<string, Map<string, TypeExpr>>;
+    readonly memoryFieldsMap: Map<string, Map<string, TypeExpr>>;
+    readonly letBindingMap: Map<string, LetBinding>;
+    constructor(program: Program);
+    private collectLetBindings;
+}

package/dist/program-index.js

@@ -0,0 +1,74 @@
+export class ProgramIndex {
+    contextMap;
+    nodeMap;
+    memoryMap;
+    edgesBySource;
+    producesNodeMap;
+    graphMap;
+    producesFieldsMap;
+    memoryFieldsMap;
+    letBindingMap;
+    constructor(program) {
+        this.contextMap = new Map();
+        for (const c of program.contexts) {
+            this.contextMap.set(c.name, c);
+        }
+        this.nodeMap = new Map();
+        this.producesNodeMap = new Map();
+        for (const n of program.nodes) {
+            this.nodeMap.set(n.name, n);
+            this.producesNodeMap.set(n.produces.name, n);
+        }
+        this.memoryMap = new Map();
+        for (const m of program.memories) {
+            this.memoryMap.set(m.name, m);
+        }
+        this.edgesBySource = new Map();
+        for (const e of program.edges) {
+            const existing = this.edgesBySource.get(e.source) ?? [];
+            existing.push(e);
+            this.edgesBySource.set(e.source, existing);
+        }
+        this.graphMap = new Map();
+        for (const g of program.graphs) {
+            this.graphMap.set(g.name, g);
+        }
+        this.producesFieldsMap = new Map();
+        for (const n of program.nodes) {
+            const fields = new Map();
+            for (const f of n.produces.fields) {
+                fields.set(f.name, f.type);
+            }
+            // Keyed by both node name AND produces name for different lookup patterns
+            this.producesFieldsMap.set(n.name, fields);
+            this.producesFieldsMap.set(n.produces.name, fields);
+        }
+        this.memoryFieldsMap = new Map();
+        for (const m of program.memories) {
+            const fields = new Map();
+            for (const f of m.fields) {
+                fields.set(f.name, f.type);
+            }
+            this.memoryFieldsMap.set(m.name, fields);
+        }
+        this.letBindingMap = new Map();
+        for (const g of program.graphs) {
+            this.collectLetBindings(g.flow, g.name);
+        }
+    }
+    collectLetBindings(nodes, graphName) {
+        for (const step of nodes) {
+            if (step.kind === 'let') {
+                this.letBindingMap.set(step.name, {
+                    name: step.name,
+                    value: step.value,
+                    graphName,
+                    location: step.location,
+                });
+            }
+            else if (step.kind === 'foreach') {
+                this.collectLetBindings(step.body, graphName);
+            }
+        }
+    }
+}

package/dist/resolver/resolver.d.ts

@@ -0,0 +1,9 @@
+import { Program } from '../parser/ast.js';
+import { GraftError } from '../errors/diagnostics.js';
+export type FileReader = (absolutePath: string) => string;
+export interface ResolveResult {
+    program: Program;
+    resolvedFiles: string[];
+    errors: GraftError[];
+}
+export declare function resolve(entryProgram: Program, sourceFile: string, readFile?: FileReader): ResolveResult;

package/dist/resolver/resolver.js

@@ -0,0 +1,136 @@
+// src/resolver/resolver.ts
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { Lexer } from '../lexer/lexer.js';
+import { Parser } from '../parser/parser.js';
+import { GraftError } from '../errors/diagnostics.js';
+function extractExportables(program) {
+    const contexts = new Map();
+    for (const c of program.contexts)
+        contexts.set(c.name, c);
+    const nodes = new Map();
+    for (const n of program.nodes)
+        nodes.set(n.name, n);
+    return { contexts, nodes };
+}
+function parseSource(source) {
+    const lexer = new Lexer(source);
+    const tokens = lexer.tokenize();
+    const parser = new Parser(tokens);
+    const { program, errors } = parser.parse();
+    if (errors.length > 0) {
+        throw errors[0];
+    }
+    return program;
+}
+function emptyProgram() {
+    return { imports: [], memories: [], contexts: [], nodes: [], edges: [], graphs: [] };
+}
+export function resolve(entryProgram, sourceFile, readFile = (p) => fs.readFileSync(p, 'utf-8')) {
+    const absSourceFile = path.resolve(sourceFile);
+    const errors = [];
+    const ctx = {
+        entryFile: absSourceFile,
+        exportCache: new Map(),
+        ancestors: new Set([absSourceFile]),
+        declaredNames: new Map(),
+        resolvedFiles: [absSourceFile],
+        errors,
+        readFile,
+    };
+    // Register entry file's local names
+    for (const c of entryProgram.contexts)
+        ctx.declaredNames.set(c.name, absSourceFile);
+    for (const n of entryProgram.nodes)
+        ctx.declaredNames.set(n.name, absSourceFile);
+    // Cache entry file's exportables (for diamond import scenarios)
+    ctx.exportCache.set(absSourceFile, extractExportables(entryProgram));
+    // Resolve all imports
+    for (const importDecl of entryProgram.imports) {
+        resolveImport(importDecl, absSourceFile, entryProgram, ctx);
+    }
+    return { program: entryProgram, resolvedFiles: ctx.resolvedFiles, errors: ctx.errors };
+}
+function resolveImport(importDecl, importingFile, importingProgram, ctx) {
+    const targetPath = path.resolve(path.dirname(importingFile), importDecl.path);
+    importDecl.resolvedPath = targetPath; // v2.0-R05
+    // Validate .gft extension
+    if (!importDecl.path.endsWith('.gft')) {
+        ctx.errors.push(new GraftError(`Import path must end with .gft: "${importDecl.path}"`, importDecl.location, 'error', 'IMPORT_INVALID_PATH'));
+        return;
+    }
+    // Circular import detection
+    if (ctx.ancestors.has(targetPath)) {
+        ctx.errors.push(new GraftError(`Circular import detected: "${importDecl.path}"`, importDecl.location, 'error', 'IMPORT_CIRCULAR'));
+        return;
+    }
+    // Parse and cache target file if not already cached
+    if (!ctx.exportCache.has(targetPath)) {
+        let targetSource;
+        try {
+            targetSource = ctx.readFile(targetPath);
+        }
+        catch {
+            ctx.errors.push(new GraftError(`Import file not found: "${importDecl.path}"`, importDecl.location, 'error', 'IMPORT_NOT_FOUND'));
+            return;
+        }
+        let targetProgram;
+        try {
+            targetProgram = parseSource(targetSource);
+        }
+        catch (e) {
+            if (e instanceof GraftError) {
+                ctx.errors.push(new GraftError(`Error parsing imported file "${importDecl.path}": ${e.message}`, importDecl.location, 'error', 'IMPORT_PARSE_ERROR'));
+            }
+            else {
+                throw e;
+            }
+            return;
+        }
+        // CRITICAL INVARIANT: Extract exportables BEFORE recursing.
+        const exportables = extractExportables(targetProgram);
+        ctx.exportCache.set(targetPath, exportables);
+        if (!ctx.resolvedFiles.includes(targetPath)) {
+            ctx.resolvedFiles.push(targetPath);
+        }
+        // Recurse into target's imports
+        ctx.ancestors.add(targetPath);
+        for (const nestedImport of targetProgram.imports) {
+            resolveImport(nestedImport, targetPath, targetProgram, ctx);
+        }
+        ctx.ancestors.delete(targetPath);
+    }
+    // Only merge names into the importing program if this is the entry file.
+    // Nested imports only need to parse and cache for transitive re-export prevention.
+    if (importingFile !== ctx.entryFile)
+        return;
+    // Look up requested names from cached exportables
+    const exportables = ctx.exportCache.get(targetPath);
+    const availableNames = [...exportables.contexts.keys(), ...exportables.nodes.keys()];
+    for (const name of importDecl.names) {
+        const context = exportables.contexts.get(name);
+        const node = exportables.nodes.get(name);
+        if (!context && !node) {
+            const suggestion = availableNames.length > 0
+                ? `. Available: ${availableNames.join(', ')}`
+                : '. File has no importable declarations';
+            ctx.errors.push(new GraftError(`Name "${name}" not found in "${importDecl.path}"${suggestion}`, importDecl.location, 'error', 'IMPORT_NAME_NOT_FOUND'));
+            continue;
+        }
+        // Duplicate detection
+        if (ctx.declaredNames.has(name)) {
+            const existingFile = ctx.declaredNames.get(name);
+            ctx.errors.push(new GraftError(`Duplicate name "${name}": already declared in ${path.basename(existingFile)}`, importDecl.location, 'error', 'IMPORT_DUPLICATE_NAME'));
+            continue;
+        }
+        ctx.declaredNames.set(name, targetPath);
+        if (context) {
+            context.sourceFile = targetPath;
+            importingProgram.contexts.push(context);
+        }
+        if (node) {
+            node.sourceFile = targetPath;
+            importingProgram.nodes.push(node);
+        }
+    }
+}

package/dist/runner.d.ts

@@ -0,0 +1,13 @@
+import { RunResult, SpawnerFn } from './runtime/executor.js';
+export type { RunResult, RunOptions, SpawnerFn } from './runtime/executor.js';
+export interface RunInput {
+    sourceFile: string;
+    inputFile?: string;
+    input?: Record<string, unknown>;
+    workDir?: string;
+    dryRun?: boolean;
+    verbose?: boolean;
+    timeoutMs?: number;
+    spawner?: SpawnerFn;
+}
+export declare function run(opts: RunInput): Promise<RunResult>;

package/dist/runner.js

@@ -0,0 +1,41 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { compile } from './compiler.js';
+import { Executor } from './runtime/executor.js';
+export async function run(opts) {
+    const sourceFile = path.resolve(opts.sourceFile);
+    if (!fs.existsSync(sourceFile)) {
+        return { success: false, graph: '', nodeResults: [], finalOutput: null, totalDurationMs: 0, errors: [`Source file not found: ${sourceFile}`] };
+    }
+    const source = fs.readFileSync(sourceFile, 'utf-8');
+    const workDir = opts.workDir ?? path.dirname(sourceFile);
+    const compileResult = compile(source, sourceFile);
+    if (!compileResult.success || !compileResult.program) {
+        return { success: false, graph: '', nodeResults: [], finalOutput: null, totalDurationMs: 0, errors: compileResult.errors.map(e => e.message) };
+    }
+    const programIndex = compileResult.index;
+    let input;
+    if (opts.input) {
+        input = opts.input;
+    }
+    else if (opts.inputFile) {
+        const inputPath = path.resolve(opts.inputFile);
+        if (!fs.existsSync(inputPath)) {
+            return { success: false, graph: compileResult.program.graphs[0]?.name ?? '', nodeResults: [], finalOutput: null, totalDurationMs: 0, errors: [`Input file not found: ${inputPath}`] };
+        }
+        try {
+            input = JSON.parse(fs.readFileSync(inputPath, 'utf-8'));
+        }
+        catch (e) {
+            return { success: false, graph: compileResult.program.graphs[0]?.name ?? '', nodeResults: [], finalOutput: null, totalDurationMs: 0, errors: [`Failed to parse input JSON: ${e instanceof Error ? e.message : String(e)}`] };
+        }
+    }
+    else {
+        input = {};
+    }
+    const executor = new Executor(compileResult.program, {
+        sourceFile: path.basename(sourceFile), input, workDir,
+        dryRun: opts.dryRun, verbose: opts.verbose, timeoutMs: opts.timeoutMs, spawner: opts.spawner,
+    }, programIndex);
+    return executor.execute();
+}

package/dist/runtime/executor.d.ts

@@ -0,0 +1,56 @@
+import { Program } from '../parser/ast.js';
+import { SpawnOptions, SpawnResult, TokenUsage } from './subprocess.js';
+import { ProgramIndex } from '../program-index.js';
+export type SpawnerFn = (options: SpawnOptions) => Promise<SpawnResult>;
+export interface RunOptions {
+    sourceFile: string;
+    input: Record<string, unknown>;
+    workDir: string;
+    dryRun?: boolean;
+    verbose?: boolean;
+    timeoutMs?: number;
+    spawner?: SpawnerFn;
+}
+export interface NodeResult {
+    node: string;
+    output: unknown;
+    durationMs: number;
+    success: boolean;
+    error?: string;
+    tokenUsage?: TokenUsage;
+}
+export interface RunResult {
+    success: boolean;
+    graph: string;
+    nodeResults: NodeResult[];
+    finalOutput: unknown;
+    totalDurationMs: number;
+    errors: string[];
+    tokenUsage?: {
+        budget: number;
+        consumed: number;
+        fraction: number;
+        perNode: Array<{
+            node: string;
+            actual?: number;
+            estimated: number;
+        }>;
+    };
+}
+export declare class Executor {
+    private program;
+    private options;
+    private index;
+    private outputs;
+    private spawner;
+    private sessionDir;
+    private nodeOutputDir;
+    private memoryDir;
+    private memoryNames;
+    private tracker;
+    constructor(program: Program, options: RunOptions, index?: ProgramIndex);
+    execute(): Promise<RunResult>;
+    private cleanSession;
+    private executeNode;
+    private storeOutput;
+}

package/dist/runtime/executor.js

@@ -0,0 +1,285 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { spawnClaude, parseCLIOutput } from './subprocess.js';
+import { applyTransforms } from './transforms.js';
+import { TokenTracker } from './token-tracker.js';
+import { MODEL_MAP } from '../constants.js';
+import { loadMemory, saveMemory } from './memory.js';
+import { ProgramIndex } from '../program-index.js';
+import { buildPrompt, generateMockOutput } from './prompt-builder.js';
+import { executeFlowNodes } from './flow-runner.js';
+export class Executor {
+    program;
+    options;
+    index;
+    outputs;
+    spawner;
+    sessionDir;
+    nodeOutputDir;
+    memoryDir;
+    memoryNames;
+    tracker;
+    constructor(program, options, index) {
+        this.program = program;
+        this.options = options;
+        this.index = index ?? new ProgramIndex(program);
+        this.spawner = options.spawner ?? spawnClaude;
+        this.outputs = new Map();
+        this.memoryDir = path.join(options.workDir, '.graft', 'memory');
+        this.memoryNames = new Set(program.memories.map(m => m.name));
+        this.sessionDir = path.join(options.workDir, '.graft', 'session');
+        this.nodeOutputDir = path.join(this.sessionDir, 'node_outputs');
+    }
+    async execute() {
+        const startTime = Date.now();
+        const errors = [];
+        const nodeResults = [];
+        // Find the first graph
+        if (this.program.graphs.length === 0) {
+            return {
+                success: false,
+                graph: '',
+                nodeResults: [],
+                finalOutput: null,
+                totalDurationMs: Date.now() - startTime,
+                errors: ['No graph declaration found'],
+            };
+        }
+        const graph = this.program.graphs[0];
+        // Session cleanup: remove old files, preserve .gitkeep
+        this.cleanSession();
+        // Ensure session directory exists
+        fs.mkdirSync(this.nodeOutputDir, { recursive: true });
+        // Initialize token tracker
+        const tokenLogPath = path.join(this.options.workDir, '.graft', 'token_log.txt');
+        fs.mkdirSync(path.dirname(tokenLogPath), { recursive: true });
+        fs.writeFileSync(tokenLogPath, '');
+        this.tracker = new TokenTracker(graph.budget, tokenLogPath);
+        // Ensure memory directory exists (if memories declared)
+        if (this.program.memories.length > 0) {
+            fs.mkdirSync(this.memoryDir, { recursive: true });
+        }
+        // Write input to session
+        fs.writeFileSync(path.join(this.sessionDir, `${graph.input.toLowerCase()}.json`), JSON.stringify(this.options.input, null, 2));
+        // Execute flow nodes
+        const flowCtx = {
+            executeNode: (name) => this.executeNode(name),
+            getFailureStrategy: (name) => {
+                const nodeDecl = this.index.nodeMap.get(name);
+                return nodeDecl?.onFailure;
+            },
+            getConditionalEdge: (sourceName) => {
+                const edges = this.index.edgesBySource.get(sourceName);
+                if (!edges)
+                    return null;
+                for (const edge of edges) {
+                    if (edge.target.kind === 'conditional') {
+                        return { branches: edge.target.branches, transforms: edge.transforms };
+                    }
+                }
+                return null;
+            },
+            outputs: this.outputs,
+            input: this.options.input,
+        };
+        try {
+            await executeFlowNodes(graph.flow, nodeResults, errors, flowCtx);
+        }
+        catch (e) {
+            errors.push(e instanceof Error ? e.message : String(e));
+        }
+        // Determine final output
+        let finalOutput = null;
+        const outputName = graph.output.toLowerCase();
+        // Check outputs by produces name
+        for (const [key, val] of this.outputs) {
+            if (key.toLowerCase() === outputName) {
+                finalOutput = val;
+                break;
+            }
+        }
+        // If not found by produces name, try the last node result
+        if (finalOutput === null && nodeResults.length > 0) {
+            const lastSuccess = [...nodeResults].reverse().find(r => r.success);
+            if (lastSuccess)
+                finalOutput = lastSuccess.output;
+        }
+        return {
+            success: errors.length === 0,
+            graph: graph.name,
+            nodeResults,
+            finalOutput,
+            totalDurationMs: Date.now() - startTime,
+            errors,
+            tokenUsage: this.tracker.getSummary(),
+        };
+    }
+    cleanSession() {
+        if (!fs.existsSync(this.nodeOutputDir))
+            return;
+        const files = fs.readdirSync(this.nodeOutputDir);
+        for (const file of files) {
+            if (file === '.gitkeep')
+                continue;
+            fs.rmSync(path.join(this.nodeOutputDir, file), { force: true });
+        }
+    }
+    async executeNode(name) {
+        const startTime = Date.now();
+        const nodeDecl = this.index.nodeMap.get(name);
+        if (!nodeDecl) {
+            return {
+                node: name,
+                output: null,
+                durationMs: Date.now() - startTime,
+                success: false,
+                error: `Node '${name}' not found in program`,
+            };
+        }
+        // Load memory for reads that reference memory declarations
+        // ALWAYS reload from disk (no this.outputs.has guard — fixes foreach staleness)
+        for (const ref of nodeDecl.reads) {
+            if (this.memoryNames.has(ref.context)) {
+                const memData = loadMemory(this.memoryDir, ref.context, { verbose: this.options.verbose });
+                if (memData !== null) {
+                    this.outputs.set(ref.context, memData);
+                }
+                else {
+                    this.outputs.delete(ref.context);
+                }
+            }
+        }
+        // Build prompt context
+        const graph = this.program.graphs[0];
+        const promptCtx = {
+            outputs: this.outputs,
+            graphInputName: graph ? graph.input : '',
+            input: this.options.input,
+        };
+        // Dry run: produce mock output
+        if (this.options.dryRun) {
+            const mockOutput = generateMockOutput(nodeDecl);
+            this.storeOutput(nodeDecl, mockOutput);
+            const estimated = { in: nodeDecl.budgetIn, out: nodeDecl.budgetOut };
+            this.tracker.record(name, undefined, estimated);
+            return {
+                node: name,
+                output: mockOutput,
+                durationMs: Date.now() - startTime,
+                success: true,
+            };
+        }
+        // Build prompt
+        const prompt = buildPrompt(nodeDecl, promptCtx);
+        const resolvedModel = MODEL_MAP[nodeDecl.model] || nodeDecl.model;
+        const args = [
+            '--output-format', 'json',
+            '--model', resolvedModel,
+            '--max-tokens', String(nodeDecl.budgetOut),
+            '-p', prompt,
+        ];
+        try {
+            const result = await this.spawner({
+                args,
+                cwd: this.options.workDir,
+                timeoutMs: this.options.timeoutMs ?? 300000,
+            });
+            if (this.options.verbose) {
+                console.log(`[${name}] exit=${result.exitCode} stdout=${result.stdout.length}b stderr=${result.stderr.length}b`);
+            }
+            if (result.exitCode !== 0) {
+                // Try to extract output anyway
+                try {
+                    const cliOutput = parseCLIOutput(result.stdout);
+                    const output = cliOutput.content;
+                    const tokenUsage = cliOutput.tokenUsage;
+                    this.storeOutput(nodeDecl, output);
+                    const estimated = { in: nodeDecl.budgetIn, out: nodeDecl.budgetOut };
+                    this.tracker.record(name, tokenUsage, estimated);
+                    return {
+                        node: name,
+                        output,
+                        durationMs: Date.now() - startTime,
+                        success: true,
+                        tokenUsage,
+                    };
+                }
+                catch {
+                    return {
+                        node: name,
+                        output: null,
+                        durationMs: Date.now() - startTime,
+                        success: false,
+                        error: `Node '${name}' exited with code ${result.exitCode}. stderr: ${result.stderr.slice(0, 500)}`,
+                    };
+                }
+            }
+            const cliOutput = parseCLIOutput(result.stdout);
+            const output = cliOutput.content;
+            const tokenUsage = cliOutput.tokenUsage;
+            this.storeOutput(nodeDecl, output);
+            const estimated = { in: nodeDecl.budgetIn, out: nodeDecl.budgetOut };
+            this.tracker.record(name, tokenUsage, estimated);
+            if (this.options.verbose) {
+                if (this.tracker.isCritical) {
+                    console.log(`[BUDGET] Critical: ${Math.round(this.tracker.fraction * 100)}% of budget consumed`);
+                }
+                else if (this.tracker.isWarning) {
+                    console.log(`[BUDGET] Warning: ${Math.round(this.tracker.fraction * 100)}% of budget consumed`);
+                }
+            }
+            return {
+                node: name,
+                output,
+                durationMs: Date.now() - startTime,
+                success: true,
+                tokenUsage,
+            };
+        }
+        catch (e) {
+            return {
+                node: name,
+                output: null,
+                durationMs: Date.now() - startTime,
+                success: false,
+                error: e instanceof Error ? e.message : String(e),
+            };
+        }
+    }
+    storeOutput(nodeDecl, output) {
+        // Store by node name
+        this.outputs.set(nodeDecl.name, output);
+        // Store by produces name
+        this.outputs.set(nodeDecl.produces.name, output);
+        // Write to session directory
+        const fileName = nodeDecl.name.toLowerCase() + '.json';
+        fs.writeFileSync(path.join(this.nodeOutputDir, fileName), JSON.stringify(output, null, 2));
+        // Also write by produces name
+        const producesFileName = nodeDecl.produces.name.toLowerCase() + '.json';
+        if (producesFileName !== fileName) {
+            fs.writeFileSync(path.join(this.nodeOutputDir, producesFileName), JSON.stringify(output, null, 2));
+        }
+        // Apply edge transforms and write transformed outputs for downstream nodes
+        const edges = this.index.edgesBySource.get(nodeDecl.name) ?? [];
+        for (const edge of edges) {
+            if (edge.transforms.length > 0 && edge.target.kind === 'direct') {
+                const transformed = applyTransforms(output, edge.transforms);
+                const targetName = edge.target.node.toLowerCase();
+                const transformedFileName = `${nodeDecl.name.toLowerCase()}_to_${targetName}.json`;
+                fs.writeFileSync(path.join(this.nodeOutputDir, transformedFileName), JSON.stringify(transformed, null, 2));
+            }
+        }
+        // Save to memory for writes targets
+        for (const writeRef of nodeDecl.writes) {
+            if (this.memoryNames.has(writeRef.memory)) {
+                if (!this.options.dryRun) {
+                    const mem = this.index.memoryMap.get(writeRef.memory);
+                    if (mem) {
+                        const fields = writeRef.field ? [writeRef.field] : undefined;
+                        saveMemory(this.memoryDir, mem, output, fields);
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/runtime/expr-eval.d.ts

@@ -0,0 +1,3 @@
+import { Expr } from '../parser/ast.js';
+export declare function evaluateExpr(expr: Expr, outputs: Map<string, unknown>, variables?: Map<string, unknown>, warnings?: string[]): unknown;
+export declare function resolveNestedField(segments: string[], obj: Record<string, unknown>): unknown;