@superpanel-sdk/runtime 0.2.3 → 0.5.0

package/dist/core/stage/flatten.js

@@ -1,466 +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 { ivrResultField } from './ivr-fields.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 isIvrNode(node) {
-    return node.kind === 'ivr';
-}
-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,
-        };
-    }
-    const { applyWhen: _applyWhen, ...block } = node;
-    return block;
-}
-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 };
-        }
-        if (block.kind === 'ivr') {
-            const finishWhen = compileWhen(block.finishWhen, functions);
-            const onDtmfResult = resolveFuncName(block.onDtmfResult, functions);
-            return { ...block, onDtmfResult, finishWhen, resultField: ivrResultField(block.id) };
-        }
-        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) || isIvrNode(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) || isIvrNode(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,15 +0,0 @@
-export type { ActionBlock, ActionNode, AgendaBlock, AgendaConfig, AgendaHeader, AgendaTree, ApplyWhen, AuthoringNode, AuthoringWhen, BranchNode, Channel, CompiledActionBlock, CompiledAgenda, CompiledAgendaBlock, CompiledTopicBlock, CompiledIvrBlock, CompiledTransferBlock, CompiledWhen, Condition, FirstMessage, FinishWhen, FlatActionItem, FlatAgendaItem, FlatIvrItem, FlatNodePlacement, FlatTopicItem, FlatTransferItem, DtmfResult, IvrBlock, IvrDigit, IvrFallbackAction, IvrNode, Interrupt, SequenceAgendas, JsonRulesCondition, NodePlacement, OnNoProgress, OtherwiseSentinel, Placement, SectionNode, SectionPlacement, SwitchOnNode, TopicBlock, TopicNode, TransferBlock, TransferInterruptAction, TransferNode, When, } from './types.js';
-export type { TransferArguments, TransferCallerIdShown, TransferConfirmKey, TransferConfirmMethod, TransferDial, TransferFallbackAction, TransferMode, TransferSay, } from './transfer-spec.js';
-export { E164_NUMBER, SIP_URI, interpolateFromSnapshot, interpolateTemplate, isTransferDestinationLiteral, resolveTransferArguments, resolveTransferDestinations, resolveTransferSay, transferArgumentsJson, validateTransferDestinations, } from './transfer-spec.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, ivr, section, switchOn, topic, transfer } from './builders.js';
-export { extractBlocksFromTree, flattenAgendaConfig, flattenAgendaPlacements, flattenAgendaTree, isAgendaTree, isSequenceAgendas, normalizeSequenceAgendas, treeToPlacements, type FlattenOptions, type FlattenResult, } from './flatten.js';
-export { CASE_LAST_TRANSFER_AT, CASE_LAST_TRANSFER_RESULT, CASE_TRANSFER_ATTEMPT_COUNT, LAST_TRANSFER_RESULT_FIELD, collectTransferBlocks, registerTransferSessionFields, transferFieldKey, transferResultField, } from './transfer-fields.js';
-export { collectIvrBlocks, ivrAttempted, ivrResultField, registerIvrSessionFields, type IvrAttemptResult, } from './ivr-fields.js';
-export { fatalAgendaIssues, validateCompiledAgenda, type ValidateAgendaOptions } from './validate.js';
-export { RESERVED_INTERRUPT_TOOL_NAMES, collectTransferInterruptHeaders, headerHasTransferInterrupt, CONTACT_LANGUAGE_FIELD, getContactLang, inboundIvrCollect, isSpokenLanguage, ivrOf, languageFieldOf, validateInterrupts, type SpokenLanguage, } from './interrupts.js';
-export { unresolvedFinishWhenFields, walkAgenda, type WalkDecision, type WalkHitReason, type WalkOptions, type WalkResult, type WalkSkip, type WalkSkipReason, type WalkStats, } 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

@@ -1,13 +0,0 @@
-export { E164_NUMBER, SIP_URI, interpolateFromSnapshot, interpolateTemplate, isTransferDestinationLiteral, resolveTransferArguments, resolveTransferDestinations, resolveTransferSay, transferArgumentsJson, validateTransferDestinations, } from './transfer-spec.js';
-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, ivr, section, switchOn, topic, transfer } from './builders.js';
-export { extractBlocksFromTree, flattenAgendaConfig, flattenAgendaPlacements, flattenAgendaTree, isAgendaTree, isSequenceAgendas, normalizeSequenceAgendas, treeToPlacements, } from './flatten.js';
-export { CASE_LAST_TRANSFER_AT, CASE_LAST_TRANSFER_RESULT, CASE_TRANSFER_ATTEMPT_COUNT, LAST_TRANSFER_RESULT_FIELD, collectTransferBlocks, registerTransferSessionFields, transferFieldKey, transferResultField, } from './transfer-fields.js';
-export { collectIvrBlocks, ivrAttempted, ivrResultField, registerIvrSessionFields, } from './ivr-fields.js';
-export { fatalAgendaIssues, validateCompiledAgenda } from './validate.js';
-export { RESERVED_INTERRUPT_TOOL_NAMES, collectTransferInterruptHeaders, headerHasTransferInterrupt, CONTACT_LANGUAGE_FIELD, getContactLang, inboundIvrCollect, isSpokenLanguage, ivrOf, languageFieldOf, validateInterrupts, } from './interrupts.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/interrupts.d.ts

@@ -1,28 +0,0 @@
-import type { FieldPath } from '../slot/path.js';
-import type { CompiledSlotSchema, ValidationIssue } from '../slot/types.js';
-import type { AgendaHeader, FlatAgendaItem, FlatIvrItem, Interrupt, IvrDigit, IvrFallbackAction } from './types.js';
-export type SpokenLanguage = string;
-export declare const CONTACT_LANGUAGE_FIELD: "contact.language";
-export declare const RESERVED_INTERRUPT_TOOL_NAMES: Set<string>;
-export declare function isSpokenLanguage(value: unknown): value is SpokenLanguage;
-export declare function ivrOf(items: FlatAgendaItem[] | null | undefined): FlatIvrItem | null;
-export declare function languageFieldOf(): FieldPath;
-/** Voice language. Empty / missing / non-language value → english. */
-export declare function getContactLang(readField?: (path: FieldPath) => unknown): SpokenLanguage;
-export declare function inboundIvrCollect(items: FlatAgendaItem[] | null | undefined): {
-    id: string;
-    fallbackAction: IvrFallbackAction;
-    confirmTimeoutMs: number;
-    pauseAfterSayMs: number;
-    finishOnKey?: IvrDigit | null;
-    minDigits?: number | null;
-    maxDigits?: number | null;
-    validateDigits: IvrDigit[];
-} | null;
-export declare function headerHasTransferInterrupt(header: AgendaHeader | null | undefined): boolean;
-export declare function collectTransferInterruptHeaders(headers: Array<AgendaHeader | null | undefined>): boolean;
-export declare function validateInterrupts(interrupts: Interrupt[], options: {
-    schema: CompiledSlotSchema;
-    agendaId?: string;
-}): ValidationIssue[];
-//# sourceMappingURL=interrupts.d.ts.map

package/dist/core/stage/interrupts.js

@@ -1,120 +0,0 @@
-import { getCompiledTable } from '../slot/compile-schema.js';
-import { validateTransferDestinations } from './transfer-spec.js';
-export const CONTACT_LANGUAGE_FIELD = 'contact.language';
-export const RESERVED_INTERRUPT_TOOL_NAMES = new Set(['voice_turn', 'record_opt_out', 'advance']);
-export function isSpokenLanguage(value) {
-    return typeof value === 'string' && value.trim().length > 0;
-}
-export function ivrOf(items) {
-    return items?.find((item) => item.kind === 'ivr') ?? null;
-}
-export function languageFieldOf() {
-    return CONTACT_LANGUAGE_FIELD;
-}
-function looksLikeSpokenLanguage(value) {
-    return isSpokenLanguage(value) && /[a-zA-Z]/.test(value);
-}
-/** Voice language. Empty / missing / non-language value → english. */
-export function getContactLang(readField) {
-    if (!readField)
-        return 'english';
-    const raw = readField(CONTACT_LANGUAGE_FIELD);
-    return looksLikeSpokenLanguage(raw) ? raw.trim() : 'english';
-}
-export function inboundIvrCollect(items) {
-    const ivr = ivrOf(items);
-    if (!ivr)
-        return null;
-    const validateDigits = (ivr.validateDigits ?? []).filter((digit) => Boolean(digit?.trim()));
-    if (!ivr.finishOnKey && validateDigits.length === 0)
-        return null;
-    return {
-        id: ivr.id,
-        fallbackAction: ivr.fallbackAction,
-        confirmTimeoutMs: ivr.confirmTimeoutMs,
-        pauseAfterSayMs: ivr.pauseAfterSayMs,
-        finishOnKey: ivr.finishOnKey,
-        minDigits: ivr.minDigits,
-        maxDigits: ivr.maxDigits,
-        validateDigits,
-    };
-}
-export function headerHasTransferInterrupt(header) {
-    return header?.interrupts.some((interrupt) => interrupt.action.type === 'transfer') ?? false;
-}
-export function collectTransferInterruptHeaders(headers) {
-    return headers.some((header) => headerHasTransferInterrupt(header));
-}
-export function validateInterrupts(interrupts, options) {
-    const issues = [];
-    const prefix = `${options.agendaId ?? 'agenda'}/header/interrupts`;
-    const names = new Set();
-    const priorities = new Set();
-    for (const interrupt of interrupts) {
-        const path = `${prefix}/${interrupt.id}`;
-        if (RESERVED_INTERRUPT_TOOL_NAMES.has(interrupt.tool.name)) {
-            issues.push({
-                code: 'interrupt-tool-reserved',
-                message: `Interrupt tool name '${interrupt.tool.name}' is reserved`,
-                path,
-            });
-        }
-        if (names.has(interrupt.tool.name)) {
-            issues.push({
-                code: 'interrupt-tool-duplicate',
-                message: `Interrupt tool name '${interrupt.tool.name}' is not unique`,
-                path,
-            });
-        }
-        names.add(interrupt.tool.name);
-        if (priorities.has(interrupt.priority)) {
-            issues.push({
-                code: 'interrupt-priority-tie',
-                message: `Interrupt priority ${interrupt.priority} is not unique`,
-                path,
-            });
-        }
-        priorities.add(interrupt.priority);
-        if (interrupt.action.type === 'switch-language') {
-            if (interrupt.action.languages.length === 0) {
-                issues.push({
-                    code: 'interrupt-languages-empty',
-                    message: 'switch-language languages must not be empty',
-                    path: `${path}/languages`,
-                });
-            }
-            if (!getCompiledTable(options.schema, 'contact')?.fields.language) {
-                issues.push({
-                    code: 'interrupt-language-field',
-                    message: `switch-language requires ${CONTACT_LANGUAGE_FIELD}`,
-                    path: `${path}/languages`,
-                });
-            }
-        }
-        if (interrupt.action.type === 'transfer') {
-            issues.push(...validateTransferDestinations(interrupt.action.numbers, {
-                path: `${path}/numbers`,
-                code: 'interrupt-transfer-number',
-            }));
-            issues.push(...validateCriteriaList(interrupt.action.escalateCriteria, `${path}/escalateCriteria`));
-            issues.push(...validateCriteriaList(interrupt.action.noEscalationCriteria, `${path}/noEscalationCriteria`));
-        }
-    }
-    return issues;
-}
-function validateCriteriaList(list, path) {
-    if (!list)
-        return [];
-    const issues = [];
-    for (let index = 0; index < list.length; index++) {
-        if (list[index]?.trim())
-            continue;
-        issues.push({
-            code: 'interrupt-escalation-criteria',
-            message: 'escalation criteria entry must not be empty',
-            path: `${path}[${index}]`,
-        });
-    }
-    return issues;
-}
-//# sourceMappingURL=interrupts.js.map

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

@@ -1,9 +0,0 @@
-import type { FieldPath } from '../slot/path.js';
-import type { CompiledSlotSchema, RuntimeSlotsSnapshot } from '../slot/types.js';
-import type { AgendaBlock, AuthoringNode, FlatIvrItem, IvrBlock } from './types.js';
-export type IvrAttemptResult = 'collected' | 'failed';
-export declare function ivrResultField(nodeId: string): FieldPath;
-export declare function ivrAttempted(item: FlatIvrItem, snapshot: RuntimeSlotsSnapshot): boolean;
-export declare function collectIvrBlocks(blocks: Record<string, AgendaBlock>, nodes?: AuthoringNode[]): IvrBlock[];
-export declare function registerIvrSessionFields(schema: CompiledSlotSchema, ivrIds: Iterable<string>): CompiledSlotSchema;
-//# sourceMappingURL=ivr-fields.d.ts.map