@grimoirelabs/core 0.1.0

package/dist/compiler/ir-generator.js

@@ -0,0 +1,997 @@
+/**
+ * IR Generator
+ * Transforms SpellSource AST into SpellIR
+ */
+import { parseExpression } from "./expression-parser.js";
+/**
+ * Generate IR from parsed SpellSource
+ */
+export function generateIR(source) {
+    const errors = [];
+    const warnings = [];
+    // Generate unique ID and hash
+    const id = source.spell;
+    const hash = generateHash(JSON.stringify(source));
+    // Transform venues
+    const aliases = [];
+    if (source.venues) {
+        for (const [alias, venue] of Object.entries(source.venues)) {
+            aliases.push({
+                alias,
+                chain: venue.chain,
+                address: venue.address,
+                label: venue.label,
+            });
+        }
+    }
+    // Transform assets
+    const assets = [];
+    if (source.assets) {
+        for (const [symbol, asset] of Object.entries(source.assets)) {
+            assets.push({
+                symbol,
+                chain: asset.chain,
+                address: asset.address,
+                decimals: asset.decimals,
+            });
+        }
+    }
+    // Transform params
+    const params = [];
+    if (source.params) {
+        for (const [name, value] of Object.entries(source.params)) {
+            if (typeof value === "object" && value !== null && "type" in value) {
+                const extended = value;
+                params.push({
+                    name,
+                    type: (extended.type ?? "number"),
+                    asset: extended.asset,
+                    default: extended.default,
+                    min: extended.min,
+                    max: extended.max,
+                });
+            }
+            else {
+                // Simple form - infer type from value
+                params.push({
+                    name,
+                    type: inferType(value),
+                    default: value,
+                });
+            }
+        }
+    }
+    // Transform state
+    const state = {
+        persistent: {},
+        ephemeral: {},
+    };
+    if (source.state?.persistent) {
+        for (const [key, value] of Object.entries(source.state.persistent)) {
+            state.persistent[key] = { key, initialValue: value };
+        }
+    }
+    if (source.state?.ephemeral) {
+        for (const [key, value] of Object.entries(source.state.ephemeral)) {
+            state.ephemeral[key] = { key, initialValue: value };
+        }
+    }
+    // Transform skills
+    const skills = [];
+    if (source.skills) {
+        for (const [name, skill] of Object.entries(source.skills)) {
+            skills.push({
+                name,
+                type: skill.type,
+                adapters: skill.adapters,
+                defaultConstraints: skill.default_constraints
+                    ? { maxSlippage: skill.default_constraints.max_slippage }
+                    : undefined,
+            });
+        }
+    }
+    // Transform advisors
+    const advisors = [];
+    if (source.advisors) {
+        for (const [name, advisor] of Object.entries(source.advisors)) {
+            advisors.push({
+                name,
+                model: advisor.model,
+                scope: "read-only",
+                systemPrompt: advisor.system_prompt,
+                skills: advisor.skills,
+                allowedTools: advisor.allowed_tools,
+                mcp: advisor.mcp,
+                defaultTimeout: advisor.timeout,
+                defaultFallback: advisor.fallback,
+                rateLimit: advisor.rate_limit
+                    ? {
+                        maxCallsPerRun: advisor.rate_limit.max_per_run ?? 10,
+                        maxCallsPerHour: advisor.rate_limit.max_per_hour ?? 100,
+                    }
+                    : undefined,
+            });
+        }
+    }
+    // Transform triggers
+    const triggers = [];
+    if (source.trigger) {
+        const trigger = transformTrigger(source.trigger);
+        if (trigger) {
+            triggers.push(trigger);
+        }
+    }
+    else {
+        // Default to manual trigger
+        triggers.push({ type: "manual" });
+    }
+    // Transform steps and build source map
+    const steps = [];
+    const stepIds = new Set();
+    const sourceMap = {};
+    if (source.steps) {
+        for (const rawStep of source.steps) {
+            try {
+                const step = transformStep(rawStep, stepIds, errors);
+                if (step) {
+                    steps.push(step);
+                    stepIds.add(step.id);
+                    // Extract source location from transformer metadata
+                    const loc = rawStep._sourceLocation;
+                    if (loc) {
+                        sourceMap[step.id] = { line: loc.line, column: loc.column };
+                    }
+                }
+            }
+            catch (e) {
+                errors.push({
+                    code: "STEP_TRANSFORM_ERROR",
+                    message: `Failed to transform step: ${e.message}`,
+                });
+            }
+        }
+    }
+    // Transform guards
+    const guards = [];
+    if (source.guards) {
+        for (const rawGuard of source.guards) {
+            try {
+                const guard = transformGuard(rawGuard, errors);
+                if (guard) {
+                    guards.push(guard);
+                }
+            }
+            catch (e) {
+                errors.push({
+                    code: "GUARD_TRANSFORM_ERROR",
+                    message: `Failed to transform guard: ${e.message}`,
+                });
+            }
+        }
+    }
+    // Auto-add "default" advisor if referenced by advisory steps but not declared
+    const advisorNames = new Set(advisors.map((a) => a.name));
+    const referencedAdvisors = new Set();
+    for (const step of steps) {
+        if (step.kind === "advisory" && !advisorNames.has(step.advisor)) {
+            referencedAdvisors.add(step.advisor);
+        }
+    }
+    for (const name of referencedAdvisors) {
+        advisors.push({
+            name,
+            model: "sonnet",
+            scope: "read-only",
+        });
+    }
+    if (errors.length > 0) {
+        return { success: false, errors, warnings };
+    }
+    const ir = {
+        id,
+        version: source.version,
+        meta: {
+            name: source.spell,
+            description: source.description,
+            created: Date.now(),
+            hash,
+        },
+        aliases,
+        assets,
+        skills,
+        advisors,
+        params,
+        state,
+        steps,
+        guards,
+        triggers,
+        sourceMap: Object.keys(sourceMap).length > 0 ? sourceMap : undefined,
+    };
+    return { success: true, ir, errors, warnings };
+}
+/**
+ * Generate a simple hash for content addressing
+ */
+function generateHash(content) {
+    let hash = 0;
+    for (let i = 0; i < content.length; i++) {
+        const char = content.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16).padStart(8, "0");
+}
+/**
+ * Infer parameter type from value
+ */
+function inferType(value) {
+    if (typeof value === "boolean")
+        return "bool";
+    if (typeof value === "number")
+        return "number";
+    if (typeof value === "string") {
+        if (value.startsWith("0x") && value.length === 42)
+            return "address";
+        return "string";
+    }
+    return "string";
+}
+/**
+ * Transform trigger
+ */
+function transformTrigger(raw) {
+    if ("manual" in raw && raw.manual) {
+        return { type: "manual" };
+    }
+    if ("schedule" in raw) {
+        return { type: "schedule", cron: raw.schedule };
+    }
+    if ("condition" in raw) {
+        return {
+            type: "condition",
+            expression: raw.condition,
+            pollInterval: raw.poll_interval ?? 60,
+        };
+    }
+    if ("event" in raw) {
+        return {
+            type: "event",
+            event: raw.event,
+            filter: raw.filter,
+        };
+    }
+    if ("any" in raw && Array.isArray(raw.any)) {
+        const triggers = [];
+        for (const t of raw.any) {
+            const transformed = transformTrigger(t);
+            if (transformed) {
+                triggers.push(transformed);
+            }
+        }
+        return { type: "any", triggers };
+    }
+    return null;
+}
+/**
+ * Transform a raw step object into a Step
+ */
+function transformStep(raw, existingIds, errors) {
+    const id = raw.id;
+    if (!id) {
+        errors.push({ code: "MISSING_STEP_ID", message: "Step must have an 'id' field" });
+        return null;
+    }
+    if (existingIds.has(id)) {
+        errors.push({ code: "DUPLICATE_STEP_ID", message: `Duplicate step id '${id}'` });
+        return null;
+    }
+    // Compute step
+    if ("compute" in raw) {
+        const assignments = [];
+        const compute = raw.compute;
+        for (const [variable, exprValue] of Object.entries(compute)) {
+            try {
+                let expression;
+                if (typeof exprValue === "string") {
+                    expression = parseExpression(exprValue);
+                }
+                else if (typeof exprValue === "number") {
+                    expression = {
+                        kind: "literal",
+                        value: exprValue,
+                        type: Number.isInteger(exprValue) ? "int" : "float",
+                    };
+                }
+                else if (typeof exprValue === "boolean") {
+                    expression = { kind: "literal", value: exprValue, type: "bool" };
+                }
+                else {
+                    throw new Error(`Unsupported value type: ${typeof exprValue}`);
+                }
+                assignments.push({ variable, expression });
+            }
+            catch (e) {
+                errors.push({
+                    code: "EXPRESSION_PARSE_ERROR",
+                    message: `Failed to parse expression for '${variable}': ${e.message}`,
+                });
+            }
+        }
+        return {
+            kind: "compute",
+            id,
+            assignments,
+            dependsOn: [],
+        };
+    }
+    // Conditional step
+    if ("if" in raw && ("then" in raw || "action" in raw)) {
+        // Simple conditional with action
+        if ("action" in raw) {
+            const conditionStr = raw.if;
+            let condition;
+            try {
+                condition = parseExpression(conditionStr);
+            }
+            catch (e) {
+                errors.push({
+                    code: "EXPRESSION_PARSE_ERROR",
+                    message: `Failed to parse condition: ${e.message}`,
+                });
+                return null;
+            }
+            // Transform the action
+            const action = transformAction(raw.action, errors);
+            if (!action)
+                return null;
+            const constraints = transformConstraints(raw.constraints, errors);
+            const onFailure = raw.on_failure ?? "revert";
+            // Create action step with condition check
+            const actionStep = {
+                kind: "action",
+                id,
+                action,
+                constraints,
+                onFailure: onFailure,
+                dependsOn: [],
+            };
+            // Wrap in conditional
+            const _conditionalStep = {
+                kind: "conditional",
+                id: `${id}_cond`,
+                condition,
+                thenSteps: [id],
+                elseSteps: [],
+                dependsOn: [],
+            };
+            // Return the action step (conditional logic handled at execution)
+            // For now, store condition in dependsOn comment
+            return actionStep;
+        }
+        // Full conditional with then/else
+        const conditionStr = raw.if;
+        let condition;
+        try {
+            condition = parseExpression(conditionStr);
+        }
+        catch (e) {
+            errors.push({
+                code: "EXPRESSION_PARSE_ERROR",
+                message: `Failed to parse condition: ${e.message}`,
+            });
+            return null;
+        }
+        return {
+            kind: "conditional",
+            id,
+            condition,
+            thenSteps: raw.then ?? [],
+            elseSteps: raw.else ?? [],
+            dependsOn: [],
+        };
+    }
+    // Action step (without condition)
+    if ("action" in raw) {
+        const action = transformAction(raw.action, errors);
+        if (!action)
+            return null;
+        const constraints = transformConstraints(raw.constraints, errors);
+        const onFailure = raw.on_failure ?? "revert";
+        return {
+            kind: "action",
+            id,
+            action,
+            skill: raw.skill,
+            constraints,
+            outputBinding: raw.output,
+            onFailure: onFailure,
+            dependsOn: [],
+        };
+    }
+    // Loop step
+    if ("repeat" in raw || "for" in raw || "loop" in raw) {
+        return transformLoopStep(raw, id, errors);
+    }
+    // Try step (from atomic blocks or explicit try)
+    if ("try" in raw) {
+        return transformTryStep(raw, id);
+    }
+    // Wait step
+    if ("wait" in raw) {
+        return {
+            kind: "wait",
+            id,
+            duration: raw.wait,
+            dependsOn: [],
+        };
+    }
+    // Emit step
+    if ("emit" in raw) {
+        const emit = raw.emit;
+        const event = emit.event;
+        const dataRaw = emit.data;
+        const data = {};
+        for (const [key, exprStr] of Object.entries(dataRaw)) {
+            try {
+                data[key] = parseExpression(exprStr);
+            }
+            catch (e) {
+                errors.push({
+                    code: "EXPRESSION_PARSE_ERROR",
+                    message: `Failed to parse emit data '${key}': ${e.message}`,
+                });
+            }
+        }
+        return {
+            kind: "emit",
+            id,
+            event,
+            data,
+            dependsOn: [],
+        };
+    }
+    // Halt step (if explicitly marked)
+    if ("halt" in raw) {
+        return {
+            kind: "halt",
+            id,
+            reason: raw.halt,
+            dependsOn: [],
+        };
+    }
+    // Advisory step (AI consultation)
+    if ("advisory" in raw) {
+        const advisory = raw.advisory;
+        const prompt = advisory.prompt;
+        const advisor = advisory.advisor ?? "default";
+        const timeout = advisory.timeout ?? 30;
+        const fallbackValue = advisory.fallback ?? true;
+        const outputBinding = advisory.output ?? `${id}_result`;
+        const outputSchemaRaw = advisory.output_schema;
+        const outputSchema = outputSchemaRaw
+            ? parseOutputSchema(outputSchemaRaw)
+            : { type: "boolean" };
+        return {
+            kind: "advisory",
+            id,
+            advisor,
+            prompt,
+            outputSchema,
+            outputBinding,
+            timeout,
+            fallback: fallbackToExpression(fallbackValue, errors),
+            dependsOn: [],
+        };
+    }
+    // Parallel step
+    if ("parallel" in raw) {
+        const parallel = raw.parallel;
+        const branchesRaw = parallel.branches ?? [];
+        const branches = branchesRaw.map((b) => ({
+            id: `${id}_${b.name}`,
+            name: b.name,
+            steps: b.steps ?? [],
+        }));
+        const joinRaw = parallel.join;
+        let join = { type: "all" };
+        if (joinRaw?.type) {
+            const type = joinRaw.type;
+            if (type === "best") {
+                const metricStr = joinRaw.metric;
+                join = {
+                    type: "best",
+                    metric: metricStr ? parseExpression(metricStr) : parseExpression("0"),
+                    order: joinRaw.order ?? "max",
+                };
+            }
+            else if (type === "any") {
+                join = { type: "any", count: joinRaw.count ?? 1 };
+            }
+            else if (type === "majority") {
+                join = { type: "majority" };
+            }
+            else if (type === "first") {
+                join = { type: "first" };
+            }
+            else {
+                join = { type: "all" };
+            }
+        }
+        return {
+            kind: "parallel",
+            id,
+            branches,
+            join,
+            onFail: parallel.on_fail ?? "abort",
+            timeout: parallel.timeout,
+            outputBinding: raw.output,
+            dependsOn: [],
+        };
+    }
+    // Pipeline step
+    if ("pipeline" in raw) {
+        const pipeline = raw.pipeline;
+        const sourceStr = pipeline.source;
+        const stagesRaw = pipeline.stages ?? [];
+        const stages = stagesRaw.map((stage) => {
+            const op = stage.op;
+            if (op === "reduce") {
+                return {
+                    op: "reduce",
+                    step: stage.step,
+                    initial: parseExpression(String(stage.initial ?? "0")),
+                };
+            }
+            if (op === "take") {
+                return { op: "take", count: stage.count };
+            }
+            if (op === "skip") {
+                return { op: "skip", count: stage.count };
+            }
+            if (op === "sort") {
+                return {
+                    op: "sort",
+                    by: parseExpression(String(stage.by ?? "0")),
+                    order: stage.order ?? "asc",
+                };
+            }
+            if (op === "where") {
+                return { op: "where", predicate: parseExpression(String(stage.predicate ?? "false")) };
+            }
+            return { op: op ?? "map", step: stage.step };
+        });
+        return {
+            kind: "pipeline",
+            id,
+            source: parseExpression(sourceStr),
+            stages,
+            parallel: pipeline.parallel ?? false,
+            outputBinding: raw.output,
+            dependsOn: [],
+        };
+    }
+    errors.push({ code: "UNKNOWN_STEP_TYPE", message: `Unknown step type for id '${id}'` });
+    return null;
+}
+/**
+ * Transform action object
+ */
+function transformAction(raw, errors) {
+    const type = raw.type;
+    switch (type) {
+        case "swap":
+            return {
+                type: "swap",
+                venue: raw.venue,
+                assetIn: raw.asset_in,
+                assetOut: raw.asset_out,
+                amount: parseExpressionSafe(raw.amount, errors),
+                mode: raw.mode ?? "exact_in",
+            };
+        case "lend":
+            return {
+                type: "lend",
+                venue: raw.venue,
+                asset: raw.asset,
+                amount: raw.amount === "max" ? "max" : parseExpressionSafe(raw.amount, errors),
+            };
+        case "withdraw":
+            return {
+                type: "withdraw",
+                venue: raw.venue,
+                asset: raw.asset,
+                amount: raw.amount === "max" ? "max" : parseExpressionSafe(raw.amount, errors),
+            };
+        case "borrow":
+            return {
+                type: "borrow",
+                venue: raw.venue,
+                asset: raw.asset,
+                amount: parseExpressionSafe(raw.amount, errors),
+                collateral: raw.collateral,
+            };
+        case "repay":
+            return {
+                type: "repay",
+                venue: raw.venue,
+                asset: raw.asset,
+                amount: raw.amount === "max" ? "max" : parseExpressionSafe(raw.amount, errors),
+            };
+        case "stake":
+            return {
+                type: "stake",
+                venue: raw.venue,
+                asset: raw.asset,
+                amount: parseExpressionSafe(raw.amount, errors),
+            };
+        case "unstake":
+            return {
+                type: "unstake",
+                venue: raw.venue,
+                asset: raw.asset,
+                amount: raw.amount === "max" ? "max" : parseExpressionSafe(raw.amount, errors),
+            };
+        case "claim":
+            return {
+                type: "claim",
+                venue: raw.venue,
+                assets: raw.assets,
+            };
+        case "bridge": {
+            const toChainValue = raw.to_chain ?? raw.toChain;
+            if (toChainValue === undefined) {
+                errors.push({
+                    code: "MISSING_BRIDGE_CHAIN",
+                    message: "Bridge action requires to_chain",
+                });
+                return null;
+            }
+            return {
+                type: "bridge",
+                venue: raw.venue,
+                asset: raw.asset,
+                amount: parseExpressionSafe(raw.amount, errors),
+                toChain: parseExpressionSafe(toChainValue, errors),
+            };
+        }
+        case "transfer": {
+            const toValue = raw.to;
+            const isAddress = typeof toValue === "string" && toValue.startsWith("0x") && toValue.length === 42;
+            return {
+                type: "transfer",
+                asset: raw.asset,
+                amount: parseExpressionSafe(raw.amount, errors),
+                to: isAddress ? toValue : parseExpressionSafe(toValue, errors),
+            };
+        }
+        default:
+            errors.push({ code: "UNKNOWN_ACTION_TYPE", message: `Unknown action type '${type}'` });
+            return null;
+    }
+}
+/**
+ * Parse expression safely, returning a literal on failure
+ */
+function parseExpressionSafe(input, errors) {
+    if (typeof input === "number") {
+        return { kind: "literal", value: input, type: "int" };
+    }
+    if (typeof input === "boolean") {
+        return { kind: "literal", value: input, type: "bool" };
+    }
+    try {
+        return parseExpression(input);
+    }
+    catch (e) {
+        errors.push({
+            code: "EXPRESSION_PARSE_ERROR",
+            message: `Failed to parse expression '${input}': ${e.message}`,
+        });
+        return { kind: "literal", value: 0, type: "int" };
+    }
+}
+function fallbackToExpression(input, errors) {
+    if (input && typeof input === "object") {
+        if ("__expr" in input) {
+            const exprValue = input.__expr;
+            try {
+                return parseExpression(String(exprValue));
+            }
+            catch (e) {
+                errors.push({
+                    code: "EXPRESSION_PARSE_ERROR",
+                    message: `Failed to parse fallback expression '${exprValue}': ${e.message}`,
+                });
+                return { kind: "literal", value: false, type: "bool" };
+            }
+        }
+        if ("__literal" in input) {
+            return literalFromValue(input.__literal);
+        }
+        return literalFromValue(input);
+    }
+    if (typeof input === "boolean") {
+        return { kind: "literal", value: input, type: "bool" };
+    }
+    if (typeof input === "number") {
+        return {
+            kind: "literal",
+            value: input,
+            type: Number.isInteger(input) ? "int" : "float",
+        };
+    }
+    if (typeof input === "bigint") {
+        return { kind: "literal", value: input, type: "int" };
+    }
+    if (typeof input === "string") {
+        return { kind: "literal", value: input, type: "string" };
+    }
+    try {
+        return parseExpression(String(input));
+    }
+    catch (e) {
+        errors.push({
+            code: "EXPRESSION_PARSE_ERROR",
+            message: `Failed to parse fallback expression '${String(input)}': ${e.message}`,
+        });
+        return { kind: "literal", value: false, type: "bool" };
+    }
+}
+function literalFromValue(input) {
+    if (typeof input === "boolean") {
+        return { kind: "literal", value: input, type: "bool" };
+    }
+    if (typeof input === "number") {
+        return {
+            kind: "literal",
+            value: input,
+            type: Number.isInteger(input) ? "int" : "float",
+        };
+    }
+    if (typeof input === "bigint") {
+        return { kind: "literal", value: input, type: "int" };
+    }
+    if (typeof input === "string") {
+        return { kind: "literal", value: input, type: "string" };
+    }
+    return { kind: "literal", value: input, type: "json" };
+}
+function parseOutputSchema(raw) {
+    const type = raw.type;
+    switch (type) {
+        case "enum":
+            return {
+                type: "enum",
+                values: raw.values ?? [],
+            };
+        case "number":
+            return {
+                type: "number",
+                min: raw.min,
+                max: raw.max,
+            };
+        case "string":
+            return {
+                type: "string",
+                minLength: raw.min_length ?? raw.minLength,
+                maxLength: raw.max_length ?? raw.maxLength,
+                pattern: raw.pattern,
+            };
+        case "object": {
+            const fieldsRaw = raw.fields;
+            const fields = fieldsRaw
+                ? Object.fromEntries(Object.entries(fieldsRaw).map(([key, value]) => [
+                    key,
+                    parseOutputSchema(value),
+                ]))
+                : undefined;
+            return { type: "object", fields };
+        }
+        case "array": {
+            const itemsRaw = raw.items;
+            return {
+                type: "array",
+                items: itemsRaw ? parseOutputSchema(itemsRaw) : undefined,
+            };
+        }
+        default:
+            return { type: "boolean" };
+    }
+}
+/**
+ * Transform constraints
+ */
+function transformConstraints(raw, errors) {
+    if (!raw)
+        return {};
+    const minOutputRaw = (raw.min_output ?? raw.minOutput);
+    const maxInputRaw = (raw.max_input ?? raw.maxInput);
+    const minLiquidityRaw = (raw.min_liquidity ?? raw.minLiquidity);
+    const maxGasRaw = (raw.max_gas ?? raw.maxGas);
+    const maxPriceImpactRaw = (raw.max_price_impact ?? raw.maxPriceImpact);
+    const requireQuoteRaw = (raw.require_quote ?? raw.requireQuote);
+    const requireSimulationRaw = (raw.require_simulation ?? raw.requireSimulation);
+    return {
+        maxSlippageBps: raw.max_slippage,
+        maxPriceImpactBps: typeof maxPriceImpactRaw === "number"
+            ? maxPriceImpactRaw
+            : typeof maxPriceImpactRaw === "string"
+                ? Number.parseFloat(maxPriceImpactRaw)
+                : undefined,
+        deadline: raw.deadline,
+        minOutput: minOutputRaw !== undefined ? parseExpressionSafe(minOutputRaw, errors) : undefined,
+        maxInput: maxInputRaw !== undefined ? parseExpressionSafe(maxInputRaw, errors) : undefined,
+        minLiquidity: minLiquidityRaw !== undefined ? parseExpressionSafe(minLiquidityRaw, errors) : undefined,
+        maxGas: maxGasRaw !== undefined ? parseExpressionSafe(maxGasRaw, errors) : undefined,
+        requireQuote: requireQuoteRaw !== undefined ? parseExpressionSafe(requireQuoteRaw, errors) : undefined,
+        requireSimulation: requireSimulationRaw !== undefined
+            ? parseExpressionSafe(requireSimulationRaw, errors)
+            : undefined,
+    };
+}
+/**
+ * Transform loop step
+ */
+function transformLoopStep(raw, id, errors) {
+    let loopType;
+    if ("repeat" in raw) {
+        loopType = { type: "repeat", count: raw.repeat };
+    }
+    else if ("for" in raw) {
+        const forClause = raw.for;
+        // Parse "var in expression"
+        const match = forClause.match(/^(\w+)\s+in\s+(.+)$/);
+        if (!match) {
+            errors.push({ code: "INVALID_FOR_CLAUSE", message: `Invalid for clause: ${forClause}` });
+            return null;
+        }
+        const [, variable, sourceStr] = match;
+        if (!variable || !sourceStr) {
+            errors.push({ code: "INVALID_FOR_CLAUSE", message: `Invalid for clause: ${forClause}` });
+            return null;
+        }
+        try {
+            const source = parseExpression(sourceStr);
+            loopType = { type: "for", variable, source };
+        }
+        catch (e) {
+            errors.push({
+                code: "EXPRESSION_PARSE_ERROR",
+                message: `Failed to parse for source: ${e.message}`,
+            });
+            return null;
+        }
+    }
+    else if ("loop" in raw) {
+        const loop = raw.loop;
+        try {
+            const condition = parseExpression(loop.until);
+            loopType = { type: "until", condition };
+        }
+        catch (e) {
+            errors.push({
+                code: "EXPRESSION_PARSE_ERROR",
+                message: `Failed to parse loop condition: ${e.message}`,
+            });
+            return null;
+        }
+    }
+    else {
+        return null;
+    }
+    const maxIterations = raw.max ?? raw.loop?.max ?? 100;
+    return {
+        kind: "loop",
+        id,
+        loopType,
+        bodySteps: raw.steps ?? [],
+        maxIterations,
+        parallel: raw.parallel,
+        outputBinding: raw.output,
+        dependsOn: [],
+    };
+}
+/**
+ * Transform guard
+ */
+function transformGuard(raw, errors) {
+    if (!raw.id) {
+        errors.push({ code: "MISSING_GUARD_ID", message: "Guard must have an 'id' field" });
+        return null;
+    }
+    if (raw.advisory) {
+        // Advisory guard
+        return {
+            id: raw.id,
+            advisor: raw.advisory,
+            check: raw.check ?? "",
+            severity: raw.severity,
+            fallback: raw.fallback ?? true,
+        };
+    }
+    // Expression guard
+    if (!raw.check) {
+        errors.push({
+            code: "MISSING_GUARD_CHECK",
+            message: `Guard '${raw.id}' must have a 'check' field`,
+        });
+        return null;
+    }
+    try {
+        const check = parseExpression(raw.check);
+        return {
+            id: raw.id,
+            check,
+            severity: raw.severity,
+            message: raw.message ?? "",
+        };
+    }
+    catch (e) {
+        errors.push({
+            code: "EXPRESSION_PARSE_ERROR",
+            message: `Failed to parse guard check: ${e.message}`,
+        });
+        return null;
+    }
+}
+const VALID_ERROR_TYPES = new Set([
+    "slippage_exceeded",
+    "insufficient_liquidity",
+    "insufficient_balance",
+    "venue_unavailable",
+    "deadline_exceeded",
+    "simulation_failed",
+    "policy_violation",
+    "guard_failed",
+    "tx_reverted",
+    "gas_exceeded",
+]);
+/**
+ * Transform a try step from SpellSource into TryStep IR.
+ *
+ * The transformer emits: { id, try: string[], catch: Array<{ error, action?, steps?, retry? }> }
+ * We convert to the TryStep type expected by the runtime.
+ */
+function transformTryStep(raw, id) {
+    const trySteps = raw.try ?? [];
+    const rawCatch = raw.catch ?? [];
+    const finallySteps = raw.finally ?? undefined;
+    const catchBlocks = rawCatch.map((c) => {
+        const errorField = c.error ?? "*";
+        const errorType = errorField === "*"
+            ? "*"
+            : VALID_ERROR_TYPES.has(errorField)
+                ? errorField
+                : "*";
+        // Map "revert" → "rollback" to match CatchBlock action type
+        let action;
+        if (c.action) {
+            const rawAction = c.action;
+            action = rawAction === "revert" ? "rollback" : rawAction;
+        }
+        const block = { errorType };
+        if (action)
+            block.action = action;
+        if (c.steps)
+            block.steps = c.steps;
+        if (c.retry) {
+            const retry = c.retry;
+            block.retry = {
+                maxAttempts: retry.maxAttempts ?? 3,
+                backoff: retry.backoff?.backoff ?? "none",
+                backoffBase: retry.backoffBase,
+                maxBackoff: retry.maxBackoff,
+            };
+        }
+        return block;
+    });
+    return {
+        kind: "try",
+        id,
+        trySteps,
+        catchBlocks,
+        finallySteps: finallySteps && finallySteps.length > 0 ? finallySteps : undefined,
+        dependsOn: [],
+    };
+}
+//# sourceMappingURL=ir-generator.js.map