@superpanel-sdk/runtime 0.0.1-internal.1

package/dist/core/stage/flatten.js

@@ -0,0 +1,464 @@
+import { resolveFuncName } from '../functions/func-ref.js';
+import { isOtherwise, jsonRules } from './condition.js';
+import { andCompiledWhen, compileAuthoringWhen, compileWhen, whenFields } from './finish-when.js';
+import { transferResultField } from './transfer-fields.js';
+function isTopicNode(node) {
+    return node.kind === 'topic';
+}
+function isActionNode(node) {
+    return node.kind === 'action';
+}
+function isTransferNode(node) {
+    return node.kind === 'transfer';
+}
+function isSectionNode(node) {
+    return node.kind === 'section';
+}
+function applyWhenOf(node) {
+    if (node.kind === 'branch' || node.kind === 'switchOn')
+        return null;
+    return node.applyWhen;
+}
+function toAgendaBlock(node) {
+    if (node.kind === 'topic') {
+        return {
+            kind: 'topic',
+            id: node.id,
+            label: node.label,
+            instructions: node.instructions,
+            fields: node.fields,
+            finishWhen: node.finishWhen,
+            onNoProgress: node.onNoProgress,
+        };
+    }
+    if (node.kind === 'action') {
+        return {
+            kind: 'action',
+            id: node.id,
+            label: node.label,
+            run: node.run,
+            finishWhen: node.finishWhen,
+            say: node.say,
+        };
+    }
+    return {
+        kind: 'transfer',
+        id: node.id,
+        label: node.label,
+        numbers: node.numbers,
+        mode: node.mode,
+        say: node.say,
+        unsuccessfulSay: node.unsuccessfulSay,
+    };
+}
+function compileBlock(block, functions, issues, path) {
+    try {
+        if (block.kind === 'topic') {
+            const finishWhen = compileWhen(block.finishWhen, functions);
+            const fields = block.fields ?? whenFields(finishWhen);
+            return { ...block, fields, finishWhen };
+        }
+        if (block.kind === 'action') {
+            const finishWhen = compileWhen(block.finishWhen, functions);
+            const run = resolveFuncName(block.run, functions);
+            return { ...block, run, finishWhen };
+        }
+        const resultField = transferResultField(block.id);
+        const finishWhen = compileWhen(jsonRules({
+            fact: resultField,
+            path: '$.state',
+            operator: 'in',
+            value: ['filled', 'asked_unknown', 'declined'],
+        }), functions);
+        return { ...block, finishWhen, resultField };
+    }
+    catch (error) {
+        issues.push({
+            code: 'invalid-finish-when',
+            message: error instanceof Error ? error.message : String(error),
+            path,
+        });
+        return null;
+    }
+}
+function registerBlock(block, compiled, functions, issues, path) {
+    const existing = compiled[block.id];
+    if (existing && existing.kind !== block.kind) {
+        issues.push({
+            code: 'block-kind-mismatch',
+            message: `Block ${block.id} kind mismatch`,
+            path,
+        });
+        return existing;
+    }
+    const next = compileBlock(block, functions, issues, path);
+    if (!next)
+        return existing ?? null;
+    compiled[block.id] = next;
+    return next;
+}
+function expandSugar(nodes, issues, path) {
+    const out = [];
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        const childPath = `${path}[${i}]`;
+        if (node.kind === 'branch') {
+            out.push(...expandBranch(node, issues, childPath));
+        }
+        else if (node.kind === 'switchOn') {
+            out.push(...expandSwitchOn(node, issues, childPath));
+        }
+        else if (node.kind === 'section') {
+            out.push({ ...node, children: expandSugar(node.children, issues, `${childPath}/${node.id}`) });
+        }
+        else {
+            out.push(node);
+        }
+    }
+    return out;
+}
+function expandBranch(node, issues, path) {
+    const children = expandSugar(node.children, issues, path);
+    const otherwiseIndexes = [];
+    for (let i = 0; i < children.length; i++) {
+        if (isOtherwise(applyWhenOf(children[i])))
+            otherwiseIndexes.push(i);
+    }
+    if (otherwiseIndexes.length > 1) {
+        issues.push({
+            code: 'otherwise-not-unique',
+            message: 'branch() otherwise must appear at most once',
+            path,
+        });
+    }
+    if (otherwiseIndexes.length === 1 && otherwiseIndexes[0] !== children.length - 1) {
+        issues.push({
+            code: 'otherwise-not-last',
+            message: 'branch() otherwise must be last',
+            path,
+        });
+    }
+    const explicit = children.filter((child) => !isOtherwise(applyWhenOf(child)));
+    if (explicit.length === 0) {
+        issues.push({
+            code: 'branch-no-explicit',
+            message: 'branch() needs at least one explicit condition branch',
+            path,
+        });
+        return children;
+    }
+    const explicitWhens = [];
+    for (const child of explicit) {
+        const when = applyWhenOf(child);
+        if (when == null) {
+            issues.push({
+                code: 'branch-null-sibling',
+                message: 'branch() explicit sibling cannot have applyWhen: null',
+                path,
+            });
+            continue;
+        }
+        if (isOtherwise(when))
+            continue;
+        explicitWhens.push(when);
+    }
+    if (otherwiseIndexes.length === 1 && explicitWhens.length > 0) {
+        const index = otherwiseIndexes[0];
+        const child = children[index];
+        children[index] = withApplyWhen(child, { op: 'otherwise', notAny: explicitWhens });
+    }
+    return children;
+}
+function expandSwitchOn(node, issues, path) {
+    const children = [];
+    for (const [key, tree] of Object.entries(node.cases)) {
+        children.push({
+            kind: 'section',
+            id: key,
+            label: key,
+            applyWhen: jsonRules({ fact: node.field, operator: 'equal', value: key }),
+            children: tree,
+        });
+    }
+    if (node.otherwise) {
+        children.push({
+            kind: 'section',
+            id: 'otherwise',
+            label: 'otherwise',
+            applyWhen: { op: 'otherwise' },
+            children: node.otherwise,
+        });
+    }
+    return expandBranch({ kind: 'branch', children }, issues, path);
+}
+function withApplyWhen(node, applyWhen) {
+    if (node.kind === 'branch' || node.kind === 'switchOn')
+        return node;
+    return { ...node, applyWhen };
+}
+function tryCompileAuthoringWhen(raw, functions, issues, path) {
+    try {
+        return compileAuthoringWhen(raw, functions);
+    }
+    catch (error) {
+        issues.push({
+            code: 'invalid-apply-when',
+            message: error instanceof Error ? error.message : String(error),
+            path,
+        });
+        return null;
+    }
+}
+function uniquePlacementId(base, used) {
+    if (!used.has(base)) {
+        used.add(base);
+        return base;
+    }
+    let i = 2;
+    while (used.has(`${base}-${i}`))
+        i += 1;
+    const id = `${base}-${i}`;
+    used.add(id);
+    return id;
+}
+function flattenAuthoring(nodes, inherited, groupPath, compiled, functions, issues, usedIds, path) {
+    const expanded = expandSugar(nodes, issues, path);
+    const items = [];
+    for (let i = 0; i < expanded.length; i++) {
+        const node = expanded[i];
+        const childPath = `${path}[${i}]`;
+        if (isSectionNode(node)) {
+            if (isOtherwise(node.applyWhen) && node.applyWhen.notAny == null) {
+                issues.push({
+                    code: 'otherwise-unexpanded',
+                    message: 'otherwise() is only valid inside branch() / switchOn()',
+                    path: childPath,
+                });
+                continue;
+            }
+            const compiledWhen = tryCompileAuthoringWhen(node.applyWhen, functions, issues, childPath);
+            if (!compiledWhen)
+                continue;
+            const merged = andCompiledWhen(inherited, compiledWhen);
+            const sectionId = uniquePlacementId(node.id, usedIds);
+            items.push(...flattenAuthoring(node.children, merged, [...groupPath, sectionId], compiled, functions, issues, usedIds, `${childPath}/${node.id}`));
+            continue;
+        }
+        if (node.kind === 'branch') {
+            items.push(...flattenAuthoring(node.children, inherited, groupPath, compiled, functions, issues, usedIds, childPath));
+            continue;
+        }
+        if (node.kind === 'switchOn') {
+            items.push(...flattenAuthoring(expandSwitchOn(node, issues, childPath), inherited, groupPath, compiled, functions, issues, usedIds, childPath));
+            continue;
+        }
+        if (isOtherwise(node.applyWhen) && node.applyWhen.notAny == null) {
+            issues.push({
+                code: 'otherwise-unexpanded',
+                message: 'otherwise() is only valid inside branch() / switchOn()',
+                path: childPath,
+            });
+            continue;
+        }
+        const compiledBlock = registerBlock(toAgendaBlock(node), compiled, functions, issues, childPath);
+        if (!compiledBlock)
+            continue;
+        const compiledWhen = tryCompileAuthoringWhen(node.applyWhen, functions, issues, childPath);
+        if (!compiledWhen)
+            continue;
+        const placementId = uniquePlacementId(node.id, usedIds);
+        items.push({
+            ...compiledBlock,
+            placementId,
+            applyWhen: andCompiledWhen(inherited, compiledWhen),
+            groupPath,
+        });
+    }
+    return items;
+}
+function flattenPlacements(placements, blocks, inherited, groupPath, compiled, functions, issues, usedIds, path) {
+    const items = [];
+    for (let i = 0; i < placements.length; i++) {
+        const placement = placements[i];
+        const childPath = `${path}[${i}]`;
+        if (placement.kind === 'section') {
+            if (isOtherwise(placement.applyWhen) && placement.applyWhen.notAny == null) {
+                issues.push({
+                    code: 'otherwise-unexpanded',
+                    message: 'otherwise() is only valid inside branch() / switchOn()',
+                    path: childPath,
+                });
+                continue;
+            }
+            const compiledWhen = tryCompileAuthoringWhen(placement.applyWhen, functions, issues, childPath);
+            if (!compiledWhen)
+                continue;
+            const merged = andCompiledWhen(inherited, compiledWhen);
+            const sectionId = uniquePlacementId(placement.placementId, usedIds);
+            items.push(...flattenPlacements(placement.children, blocks, merged, [...groupPath, sectionId], compiled, functions, issues, usedIds, `${childPath}/${placement.placementId}`));
+            continue;
+        }
+        const block = blocks[placement.blockId];
+        if (!block) {
+            issues.push({
+                code: 'unknown-block',
+                message: `Unknown block: ${placement.blockId}`,
+                path: childPath,
+            });
+            continue;
+        }
+        if (isOtherwise(placement.applyWhen) && placement.applyWhen.notAny == null) {
+            issues.push({
+                code: 'otherwise-unexpanded',
+                message: 'otherwise() is only valid inside branch() / switchOn()',
+                path: childPath,
+            });
+            continue;
+        }
+        const compiledBlock = registerBlock(block, compiled, functions, issues, childPath);
+        if (!compiledBlock)
+            continue;
+        const compiledWhen = tryCompileAuthoringWhen(placement.applyWhen, functions, issues, childPath);
+        if (!compiledWhen)
+            continue;
+        const placementId = uniquePlacementId(placement.placementId, usedIds);
+        items.push({
+            ...compiledBlock,
+            placementId,
+            applyWhen: andCompiledWhen(inherited, compiledWhen),
+            groupPath,
+        });
+    }
+    return items;
+}
+function asSectionPlacement(node, usedIds, path, issues) {
+    if (isSectionNode(node)) {
+        return {
+            kind: 'section',
+            placementId: uniquePlacementId(node.id, usedIds),
+            label: node.label,
+            applyWhen: node.applyWhen,
+            children: node.children.map((child, i) => asPlacement(child, usedIds, `${path}/${node.id}[${i}]`, issues)),
+        };
+    }
+    if (isTopicNode(node) || isActionNode(node) || isTransferNode(node)) {
+        return {
+            kind: 'node',
+            placementId: uniquePlacementId(node.id, usedIds),
+            blockId: node.id,
+            applyWhen: node.applyWhen,
+        };
+    }
+    issues.push({
+        code: 'invalid-placement',
+        message: `Cannot place ${node.kind} as a placement child before sugar expansion`,
+        path,
+    });
+    return {
+        kind: 'section',
+        placementId: uniquePlacementId('_invalid', usedIds),
+        label: '_invalid',
+        applyWhen: null,
+        children: [],
+    };
+}
+function asPlacement(node, usedIds, path, issues) {
+    return asSectionPlacement(node, usedIds, path, issues);
+}
+/** Extract reusable blocks from an inline agenda tree. */
+export function extractBlocksFromTree(tree, blocks = {}) {
+    visit(tree);
+    return blocks;
+    function visit(nodes) {
+        for (const node of nodes) {
+            if (isTopicNode(node) || isActionNode(node) || isTransferNode(node)) {
+                blocks[node.id] = toAgendaBlock(node);
+            }
+            else if (isSectionNode(node) || node.kind === 'branch') {
+                visit(node.children);
+            }
+            else if (node.kind === 'switchOn') {
+                for (const children of Object.values(node.cases))
+                    visit(children);
+                if (node.otherwise)
+                    visit(node.otherwise);
+            }
+        }
+    }
+}
+export function flattenAgendaTree(tree, options = {}) {
+    const issues = [];
+    const compiled = {};
+    const items = flattenAuthoring(tree, { kind: 'always' }, [], compiled, options.functions, issues, new Set(), 'tree');
+    return { items, blocks: compiled, issues };
+}
+export function flattenAgendaPlacements(placements, blocks, options = {}) {
+    const issues = [];
+    const compiled = {};
+    const items = flattenPlacements(placements, blocks, { kind: 'always' }, [], compiled, options.functions, issues, new Set(), 'placements');
+    return { items, blocks: compiled, issues };
+}
+export function flattenAgendaConfig(config, blocks, options = {}) {
+    if (config.tree)
+        return flattenAgendaTree(config.tree, options);
+    return flattenAgendaPlacements(config.placements ?? [], blocks, options);
+}
+export function treeToPlacements(tree) {
+    const issues = [];
+    const expanded = expandSugar(tree, issues, 'tree');
+    const blocks = extractBlocksFromTree(expanded);
+    const usedIds = new Set();
+    const placements = expanded.map((node, i) => asPlacement(node, usedIds, `tree[${i}]`, issues));
+    return { blocks, placements };
+}
+export function isAgendaTree(value) {
+    return (value != null &&
+        typeof value === 'object' &&
+        value.kind === 'agenda' &&
+        typeof value.id === 'string' &&
+        Array.isArray(value.tree));
+}
+export function isSequenceAgendas(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const obj = value;
+    return isPlainBlocks(obj.blocks) && isPlainAgendas(obj.agendas);
+}
+function isPlainBlocks(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+function isPlainAgendas(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+export function normalizeSequenceAgendas(value) {
+    if (isSequenceAgendas(value))
+        return value;
+    if (isAgendaTree(value)) {
+        const { blocks, placements } = treeToPlacements(value.tree);
+        return {
+            blocks,
+            agendas: {
+                [value.id]: { id: value.id, header: value.header, placements },
+            },
+        };
+    }
+    if (Array.isArray(value) && value.every(isAgendaTree)) {
+        const blocks = {};
+        const agendas = {};
+        for (const tree of value) {
+            const extracted = treeToPlacements(tree.tree);
+            Object.assign(blocks, extracted.blocks);
+            agendas[tree.id] = { id: tree.id, header: tree.header, placements: extracted.placements };
+        }
+        return { blocks, agendas };
+    }
+    if (value != null && typeof value === 'object' && !Array.isArray(value)) {
+        const record = value;
+        const trees = Object.values(record);
+        if (trees.length > 0 && trees.every(isAgendaTree)) {
+            return normalizeSequenceAgendas(trees);
+        }
+    }
+    throw new Error('Could not find agendas export as SequenceAgendas or agenda() tree');
+}
+//# sourceMappingURL=flatten.js.map

package/dist/core/stage/index.d.ts

@@ -0,0 +1,11 @@
+export type { ActionBlock, ActionNode, AgendaBlock, AgendaConfig, AgendaHeader, AgendaTree, ApplyWhen, AuthoringNode, AuthoringWhen, BranchNode, Channel, CompiledActionBlock, CompiledAgenda, CompiledAgendaBlock, CompiledTopicBlock, CompiledTransferBlock, CompiledWhen, Condition, FirstMessage, FinishWhen, FlatActionItem, FlatAgendaItem, FlatNodePlacement, FlatTopicItem, FlatTransferItem, Interrupt, SequenceAgendas, JsonRulesCondition, NodePlacement, OnNoProgress, OtherwiseSentinel, Placement, SectionNode, SectionPlacement, SwitchOnNode, TopicBlock, TopicNode, TransferBlock, TransferNode, When, } from './types.js';
+export { collectJsonRulesFacts, evaluateJsonRules, extractTemplateFields, isOtherwise, jsonRules, looksLikeJsonRules, normalizeJsonRules, otherwise, parseJsonRules, type ConditionEval, } from './condition.js';
+export { andCompiledWhen, compileAuthoringWhen, compileFinishWhen, compileWhen, evaluateFinishWhen, evaluateWhen, finishWhenFields, notAnyWhen, whenFields, type FinishWhenEval, type WhenEval, } from './finish-when.js';
+export { action, agenda, branch, section, switchOn, topic, transfer } from './builders.js';
+export { extractBlocksFromTree, flattenAgendaConfig, flattenAgendaPlacements, flattenAgendaTree, isAgendaTree, isSequenceAgendas, normalizeSequenceAgendas, treeToPlacements, type FlattenOptions, type FlattenResult, } from './flatten.js';
+export { LAST_TRANSFER_RESULT_FIELD, collectTransferBlocks, registerTransferSessionFields, transferFieldKey, transferResultField, } from './transfer-fields.js';
+export { fatalAgendaIssues, validateCompiledAgenda, type ValidateAgendaOptions } from './validate.js';
+export { unresolvedFinishWhenFields, walkAgenda, type WalkDecision, type WalkHitReason, type WalkOptions, type WalkResult, type WalkSkip, type WalkSkipReason, } from './walk.js';
+export { simulateAgenda, type SimulateResult, type SimulatedItem, type SimulatedItemStatus } from './simulate.js';
+export { DEFAULT_MAX_ACTIONS_PER_TURN, advanceAgenda, driveAgenda, transferWrites, watchdogHint, type AdvanceResult, type StageDriveHooks, type StageDriveResult, type StageDriveState, } from './drive.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/stage/index.js

@@ -0,0 +1,10 @@
+export { collectJsonRulesFacts, evaluateJsonRules, extractTemplateFields, isOtherwise, jsonRules, looksLikeJsonRules, normalizeJsonRules, otherwise, parseJsonRules, } from './condition.js';
+export { andCompiledWhen, compileAuthoringWhen, compileFinishWhen, compileWhen, evaluateFinishWhen, evaluateWhen, finishWhenFields, notAnyWhen, whenFields, } from './finish-when.js';
+export { action, agenda, branch, section, switchOn, topic, transfer } from './builders.js';
+export { extractBlocksFromTree, flattenAgendaConfig, flattenAgendaPlacements, flattenAgendaTree, isAgendaTree, isSequenceAgendas, normalizeSequenceAgendas, treeToPlacements, } from './flatten.js';
+export { LAST_TRANSFER_RESULT_FIELD, collectTransferBlocks, registerTransferSessionFields, transferFieldKey, transferResultField, } from './transfer-fields.js';
+export { fatalAgendaIssues, validateCompiledAgenda } from './validate.js';
+export { unresolvedFinishWhenFields, walkAgenda, } from './walk.js';
+export { simulateAgenda } from './simulate.js';
+export { DEFAULT_MAX_ACTIONS_PER_TURN, advanceAgenda, driveAgenda, transferWrites, watchdogHint, } from './drive.js';
+//# sourceMappingURL=index.js.map

package/dist/core/stage/simulate.d.ts

@@ -0,0 +1,24 @@
+import type { ComputeHost } from '../../compute-host/compute-host.js';
+import type { RuntimeSlotsSnapshot } from '../slot/types.js';
+import { type WalkResult } from './walk.js';
+import type { FlatAgendaItem } from './types.js';
+export type SimulatedItemStatus = 'folded' | 'done' | 'selected' | 'open';
+export type SimulatedItem = {
+    placementId: string;
+    blockId: string;
+    kind: FlatAgendaItem['kind'];
+    groupPath: string[];
+    status: SimulatedItemStatus;
+    applyWhen: boolean;
+    finishWhen: boolean | null;
+};
+export type SimulateResult = {
+    selected: FlatAgendaItem | null;
+    walk: WalkResult;
+    items: SimulatedItem[];
+};
+export declare function simulateAgenda(items: FlatAgendaItem[], snapshot: RuntimeSlotsSnapshot, options?: {
+    currentPlacementId?: string | null;
+    compute?: ComputeHost;
+}): Promise<SimulateResult>;
+//# sourceMappingURL=simulate.d.ts.map

package/dist/core/stage/simulate.js

@@ -0,0 +1,33 @@
+import { evaluateWhen } from './finish-when.js';
+import { walkAgenda } from './walk.js';
+export async function simulateAgenda(items, snapshot, options = {}) {
+    const walk = await walkAgenda(items, snapshot, {
+        currentPlacementId: options.currentPlacementId,
+        compute: options.compute,
+    });
+    const simulated = [];
+    for (const item of items) {
+        const applies = (await evaluateWhen(item.applyWhen, snapshot, options.compute)).pass;
+        const finished = applies ? (await evaluateWhen(item.finishWhen, snapshot, options.compute)).done : null;
+        let status;
+        if (!applies)
+            status = 'folded';
+        else if (finished)
+            status = 'done';
+        else if (walk.hit?.placementId === item.placementId)
+            status = 'selected';
+        else
+            status = 'open';
+        simulated.push({
+            placementId: item.placementId,
+            blockId: item.id,
+            kind: item.kind,
+            groupPath: item.groupPath,
+            status,
+            applyWhen: applies,
+            finishWhen: finished,
+        });
+    }
+    return { selected: walk.hit, walk, items: simulated };
+}
+//# sourceMappingURL=simulate.js.map

package/dist/core/stage/transfer-fields.d.ts

@@ -0,0 +1,14 @@
+import type { FieldPath } from '../slot/path.js';
+import type { CompiledSlotSchema } from '../slot/types.js';
+import type { AgendaBlock, AuthoringNode, TransferBlock } from './types.js';
+/** Sanitize a transfer node id into a session field fragment. */
+export declare function transferFieldKey(nodeId: string): string;
+export declare function transferResultField(nodeId: string): FieldPath;
+export declare const LAST_TRANSFER_RESULT_FIELD: `${string}.${string}`;
+export declare function collectTransferBlocks(blocks: Record<string, AgendaBlock>, nodes?: AuthoringNode[]): TransferBlock[];
+/**
+ * Register per-node `session.transfer_<id>_result` and `session.last_transfer_result`.
+ * Existing session fields with the same name are left untouched.
+ */
+export declare function registerTransferSessionFields(schema: CompiledSlotSchema, transferIds: Iterable<string>): CompiledSlotSchema;
+//# sourceMappingURL=transfer-fields.d.ts.map

package/dist/core/stage/transfer-fields.js

@@ -0,0 +1,88 @@
+import { idField } from '../slot/schema.js';
+import { getCompiledTable } from '../slot/compile-schema.js';
+import { formatFieldPath } from '../slot/path.js';
+const RESULT_ENUM = ['connected', 'failed'];
+function transferFieldCore(label) {
+    return {
+        derived: false,
+        label,
+        dataType: 'string',
+        source: 'system',
+        extraction: 'Platform transfer result',
+        enum: [...RESULT_ENUM],
+        nullable: true,
+        identifier: null,
+        ref: null,
+    };
+}
+/** Sanitize a transfer node id into a session field fragment. */
+export function transferFieldKey(nodeId) {
+    const cleaned = nodeId.replace(/[^A-Za-z0-9_]/g, '_');
+    return cleaned.length > 0 ? cleaned : 'node';
+}
+export function transferResultField(nodeId) {
+    return formatFieldPath('session', `transfer_${transferFieldKey(nodeId)}_result`);
+}
+export const LAST_TRANSFER_RESULT_FIELD = formatFieldPath('session', 'last_transfer_result');
+export function collectTransferBlocks(blocks, nodes = []) {
+    const out = [];
+    const seen = new Set();
+    for (const block of Object.values(blocks)) {
+        if (block.kind === 'transfer' && !seen.has(block.id)) {
+            seen.add(block.id);
+            out.push(block);
+        }
+    }
+    visit(nodes);
+    return out;
+    function visit(list) {
+        for (const node of list) {
+            if (node.kind === 'transfer' && !seen.has(node.id)) {
+                seen.add(node.id);
+                out.push(node);
+            }
+            else if (node.kind === 'section' || node.kind === 'branch') {
+                visit(node.children);
+            }
+            else if (node.kind === 'switchOn') {
+                for (const children of Object.values(node.cases))
+                    visit(children);
+                if (node.otherwise)
+                    visit(node.otherwise);
+            }
+        }
+    }
+}
+/**
+ * Register per-node `session.transfer_<id>_result` and `session.last_transfer_result`.
+ * Existing session fields with the same name are left untouched.
+ */
+export function registerTransferSessionFields(schema, transferIds) {
+    const ids = [...new Set(transferIds)];
+    if (ids.length === 0)
+        return schema;
+    const session = getCompiledTable(schema, 'session');
+    if (!session)
+        return schema;
+    const fields = { ...session.fields };
+    if (!fields.id)
+        fields.id = { ...idField, ref: null };
+    for (const id of ids) {
+        const name = `transfer_${transferFieldKey(id)}_result`;
+        if (!fields[name]) {
+            fields[name] = transferFieldCore(`Transfer ${id} result`);
+        }
+    }
+    if (!fields.last_transfer_result) {
+        fields.last_transfer_result = transferFieldCore('Last transfer result');
+    }
+    const nextSession = {
+        ...session,
+        fields,
+    };
+    return {
+        ...schema,
+        session: nextSession,
+    };
+}
+//# sourceMappingURL=transfer-fields.js.map