@superpanel-sdk/runtime 0.2.2 → 0.5.0

package/dist/core/stage/drive.js

@@ -1,77 +0,0 @@
-import { evaluateWhen } from './finish-when.js';
-import { unresolvedFinishWhenFields, walkAgenda } from './walk.js';
-export const DEFAULT_MAX_ACTIONS_PER_TURN = 10;
-/**
- * Walk until a topic/transfer/complete, executing actions inline.
- * Action returning null is skipped for this tick; writes trigger a full re-walk.
- */
-export async function driveAgenda(items, state, compute, hooks, options = {}) {
-    const maxActions = options.maxActions ?? DEFAULT_MAX_ACTIONS_PER_TURN;
-    let snapshot = state.snapshot;
-    let currentPlacementId = state.currentPlacementId;
-    const skip = new Set();
-    let actionsRun = 0;
-    let lastWalk = await walkAgenda(items, snapshot, { currentPlacementId, compute, skipPlacementIds: skip });
-    while (true) {
-        lastWalk = await walkAgenda(items, snapshot, { currentPlacementId, compute, skipPlacementIds: skip });
-        const hit = lastWalk.hit;
-        if (!hit || hit.kind === 'topic' || hit.kind === 'transfer') {
-            return {
-                snapshot,
-                currentPlacementId: hit?.placementId ?? currentPlacementId,
-                walk: lastWalk,
-                actionsRun,
-                fused: false,
-            };
-        }
-        if (actionsRun >= maxActions) {
-            return {
-                snapshot,
-                currentPlacementId: hit.placementId,
-                walk: lastWalk,
-                actionsRun,
-                fused: true,
-            };
-        }
-        actionsRun += 1;
-        const writes = await hooks.runAction(hit, snapshot);
-        if (writes && Object.keys(writes).length > 0) {
-            snapshot = await hooks.applyWrites(writes, snapshot);
-            skip.clear();
-            currentPlacementId = hit.placementId;
-            continue;
-        }
-        skip.add(hit.placementId);
-    }
-}
-export async function advanceAgenda(items, state, compute, hooks, options = {}) {
-    const current = (state.currentPlacementId ? items.find((item) => item.placementId === state.currentPlacementId) : null) ??
-        (await walkAgenda(items, state.snapshot, { compute })).hit;
-    if (current?.kind === 'topic') {
-        const finished = await evaluateWhen(current.finishWhen, state.snapshot, compute);
-        if (!finished.done) {
-            return {
-                ok: false,
-                missing: await unresolvedFinishWhenFields(current, state.snapshot, compute),
-                item: current,
-            };
-        }
-    }
-    const drive = await driveAgenda(items, state, compute, hooks, options);
-    return { ok: true, drive };
-}
-export async function watchdogHint(item, snapshot, compute) {
-    if (!item || item.kind !== 'topic')
-        return null;
-    const finished = await evaluateWhen(item.finishWhen, snapshot, compute);
-    if (!finished.done)
-        return null;
-    return 'This section is complete. Wrap up naturally and advance.';
-}
-export function transferWrites(item, result) {
-    return {
-        [item.resultField]: result,
-        'session.last_transfer_result': result,
-    };
-}
-//# sourceMappingURL=drive.js.map

package/dist/core/stage/finish-when.d.ts

@@ -1,20 +0,0 @@
-import type { FuncMap } from '../functions/types.js';
-import type { ComputeHost } from '../../compute-host/compute-host.js';
-import type { FieldPath } from '../slot/path.js';
-import type { RuntimeSlotsSnapshot } from '../slot/types.js';
-import { type ConditionEval } from './condition.js';
-import type { AuthoringWhen, CompiledWhen, When } from './types.js';
-export declare function compileWhen(raw: When, functions?: FuncMap): CompiledWhen;
-export declare function compileAuthoringWhen(raw: AuthoringWhen, functions?: FuncMap): CompiledWhen;
-export declare function andCompiledWhen(a: CompiledWhen, b: CompiledWhen): CompiledWhen;
-export declare function notAnyWhen(items: CompiledWhen[]): CompiledWhen;
-export declare function whenFields(when: CompiledWhen): FieldPath[];
-export type WhenEval = ConditionEval & {
-    done: boolean;
-};
-export declare function evaluateWhen(when: CompiledWhen, snapshot: RuntimeSlotsSnapshot, compute?: ComputeHost): Promise<WhenEval>;
-export declare const compileFinishWhen: typeof compileWhen;
-export declare const evaluateFinishWhen: typeof evaluateWhen;
-export declare const finishWhenFields: typeof whenFields;
-export type FinishWhenEval = WhenEval;
-//# sourceMappingURL=finish-when.d.ts.map

package/dist/core/stage/finish-when.js

@@ -1,82 +0,0 @@
-import { resolveFuncName } from '../functions/func-ref.js';
-import { collectJsonRulesFacts, evaluateJsonRules, isOtherwise, looksLikeJsonRules, normalizeJsonRules, parseJsonRules, } from './condition.js';
-function isDefinedFunc(value) {
-    return (value != null &&
-        typeof value === 'object' &&
-        'kind' in value &&
-        'main' in value &&
-        (value.kind === 'compute' || value.kind === 'boolCompute' || value.kind === 'custom' || value.kind === 'system'));
-}
-export function compileWhen(raw, functions) {
-    if (raw == null)
-        return { kind: 'always' };
-    if (typeof raw === 'string') {
-        if (looksLikeJsonRules(raw)) {
-            return { kind: 'rules', condition: parseJsonRules(raw) };
-        }
-        if (!raw)
-            throw new Error('When function name must be a non-empty string');
-        return { kind: 'fn', fn: raw };
-    }
-    if (isDefinedFunc(raw)) {
-        return { kind: 'fn', fn: resolveFuncName(raw, functions) };
-    }
-    return { kind: 'rules', condition: normalizeJsonRules(raw) };
-}
-export function compileAuthoringWhen(raw, functions) {
-    if (isOtherwise(raw)) {
-        const items = (raw.notAny ?? []).map((item) => compileWhen(item, functions));
-        return notAnyWhen(items);
-    }
-    return compileWhen(raw, functions);
-}
-export function andCompiledWhen(a, b) {
-    if (a.kind === 'always')
-        return b;
-    if (b.kind === 'always')
-        return a;
-    if (a.kind === 'rules' && b.kind === 'rules') {
-        return { kind: 'rules', condition: { all: [a.condition, b.condition] } };
-    }
-    throw new Error('Cannot combine boolFunction with another when; use json-rules all/any/not');
-}
-export function notAnyWhen(items) {
-    if (items.length === 0)
-        return { kind: 'always' };
-    if (!items.every((item) => item.kind === 'rules')) {
-        throw new Error('otherwise() siblings must be json-rules; use json-rules any/not');
-    }
-    return {
-        kind: 'rules',
-        condition: { not: { any: items.map((item) => item.condition) } },
-    };
-}
-export function whenFields(when) {
-    if (when.kind !== 'rules')
-        return [];
-    return collectJsonRulesFacts(when.condition);
-}
-export async function evaluateWhen(when, snapshot, compute) {
-    if (when.kind === 'always')
-        return { done: true, pass: true, failedFields: [] };
-    if (when.kind === 'rules') {
-        const caseContext = compute ? await compute.execute('caseContextView', [snapshot]) : snapshot;
-        const result = await evaluateJsonRules(when.condition, caseContext);
-        return { ...result, done: result.pass };
-    }
-    if (when.kind === 'fn') {
-        if (!compute)
-            throw new Error(`when fn '${when.fn}' requires a ComputeHost`);
-        const raw = await compute.execute(when.fn, [snapshot]);
-        if (typeof raw !== 'boolean') {
-            throw new Error(`when fn '${when.fn}' must return boolean, got ${typeof raw}`);
-        }
-        return { done: raw, pass: raw, failedFields: [] };
-    }
-    const _exhaustive = when;
-    return _exhaustive;
-}
-export const compileFinishWhen = compileWhen;
-export const evaluateFinishWhen = evaluateWhen;
-export const finishWhenFields = whenFields;
-//# sourceMappingURL=finish-when.js.map

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

@@ -1,27 +0,0 @@
-import type { FuncMap } from '../functions/types.js';
-import type { ValidationIssue } from '../slot/types.js';
-import type { AgendaBlock, AgendaTree, AuthoringNode, CompiledAgendaBlock, FlatAgendaItem, SequenceAgendas, Placement } from './types.js';
-export type FlattenOptions = {
-    functions?: FuncMap;
-};
-export type FlattenResult = {
-    items: FlatAgendaItem[];
-    blocks: Record<string, CompiledAgendaBlock>;
-    issues: ValidationIssue[];
-};
-/** Extract reusable blocks from an inline agenda tree. */
-export declare function extractBlocksFromTree(tree: AuthoringNode[], blocks?: Record<string, AgendaBlock>): Record<string, AgendaBlock>;
-export declare function flattenAgendaTree(tree: AuthoringNode[], options?: FlattenOptions): FlattenResult;
-export declare function flattenAgendaPlacements(placements: Placement[], blocks: Record<string, AgendaBlock>, options?: FlattenOptions): FlattenResult;
-export declare function flattenAgendaConfig(config: {
-    placements?: Placement[];
-    tree?: AuthoringNode[];
-}, blocks: Record<string, AgendaBlock>, options?: FlattenOptions): FlattenResult;
-export declare function treeToPlacements(tree: AuthoringNode[]): {
-    blocks: Record<string, AgendaBlock>;
-    placements: Placement[];
-};
-export declare function isAgendaTree(value: unknown): value is AgendaTree;
-export declare function isSequenceAgendas(value: unknown): value is SequenceAgendas;
-export declare function normalizeSequenceAgendas(value: unknown): SequenceAgendas;
-//# sourceMappingURL=flatten.d.ts.map

package/dist/core/stage/flatten.js

@@ -1,464 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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