@superpanel-sdk/runtime 0.2.2 → 0.2.3

package/dist/core/slot/write.js

@@ -4,6 +4,70 @@ import { formatFieldPath, parseFieldPath, requireFieldPath } from './path.js';
 import { getRowField, isReservedTableName, isRowIdField, mintRowId, slotFieldNames } from './row.js';
 import { cloneSnapshot, getSnapshotTable } from './snapshot.js';
 import { validateBareValue, validateExtractedField } from './value.js';
+export function isRowWrite(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const o = value;
+    return (typeof o.table === 'string' &&
+        typeof o.rowId === 'string' &&
+        o.values !== null &&
+        typeof o.values === 'object' &&
+        !Array.isArray(o.values));
+}
+export function isStructuredWrites(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value) || isRowWrite(value))
+        return false;
+    const keys = Object.keys(value);
+    return keys.length > 0 && keys.every((key) => key === 'fields' || key === 'rows');
+}
+export function normalizeWrites(writes) {
+    if (writes == null)
+        return null;
+    if (isRowWrite(writes)) {
+        return { fields: {}, rows: [writes] };
+    }
+    if (isStructuredWrites(writes)) {
+        const fields = writes.fields && typeof writes.fields === 'object' && !Array.isArray(writes.fields) ? writes.fields : {};
+        const rows = Array.isArray(writes.rows) ? writes.rows.filter(isRowWrite) : [];
+        if (Object.keys(fields).length === 0 && rows.length === 0)
+            return null;
+        return { fields, rows };
+    }
+    if (Object.keys(writes).length === 0)
+        return null;
+    return { fields: writes, rows: [] };
+}
+function boundRowId(tableName, current) {
+    if (!current)
+        return undefined;
+    if (tableName === 'contact')
+        return current.contactId;
+    if (tableName === 'case_contact')
+        return current.caseContactId;
+    if (tableName === 'case_file')
+        return current.caseFileId;
+    return undefined;
+}
+function writeTargetRow(schema, snapshot, tableName, rowId) {
+    const table = getCompiledTable(schema, tableName);
+    if (!table)
+        return null;
+    const data = getSnapshotTable(snapshot, tableName);
+    if (!data)
+        return null;
+    if (isSnapshotSingleRow(table) && !Array.isArray(data)) {
+        if (rowId && data.id && data.id !== rowId)
+            return null;
+        return data;
+    }
+    if (Array.isArray(data)) {
+        const id = rowId ?? boundRowId(tableName, snapshot.current);
+        if (!id)
+            return null;
+        return data.find((row) => row.id === id) ?? null;
+    }
+    return null;
+}
 function extractedToFieldValue(extracted, updatedBy, now) {
     return makeFieldValue({
         reason: extracted.reason,
@@ -13,7 +77,7 @@ function extractedToFieldValue(extracted, updatedBy, now) {
         updatedAt: now,
     });
 }
-function assertWritableNormal(schema, path, options) {
+function assertWritableNormal(schema, snapshot, path, options, rowId) {
     const { table, field: fieldName } = requireFieldPath(path);
     const tableDef = getCompiledTable(schema, table);
     const field = tableDef?.fields[fieldName];
@@ -49,23 +113,75 @@ function assertWritableNormal(schema, path, options) {
             },
         ];
     }
-    if (!isSnapshotSingleRow(tableDef)) {
+    if (!isSnapshotSingleRow(tableDef) && !writeTargetRow(schema, snapshot, table, rowId)) {
         return [
             {
-                code: 'multi-path-write',
-                message: `Use Slot Filling / row APIs to write multi-row field ${path}`,
+                code: rowId ? 'row-not-found' : 'multi-path-write',
+                message: rowId
+                    ? `Row ${rowId} not found in ${table}`
+                    : `Use Slot Filling or { table, rowId, values } to write multi-row field ${path}`,
                 path,
             },
         ];
     }
     return [];
 }
+function applyBareFieldWrite(schema, original, next, path, value, rowId, options, now, errors, changed, history) {
+    const writeIssues = assertWritableNormal(schema, original, path, options, rowId);
+    if (writeIssues.length > 0) {
+        errors.push(...writeIssues);
+        return;
+    }
+    const parsed = parseFieldPath(path);
+    if (!parsed) {
+        errors.push({ code: 'unknown-field', message: `Invalid field path: ${path}`, path });
+        return;
+    }
+    const field = getCompiledTable(schema, parsed.table)?.fields[parsed.field];
+    if (!field) {
+        errors.push({ code: 'unknown-field', message: `Unknown field: ${path}`, path });
+        return;
+    }
+    const valueIssues = validateBareValue(field, value, path, {
+        allowNull: !field.derived && field.nullable,
+    });
+    if (valueIssues.length > 0) {
+        errors.push(...valueIssues);
+        return;
+    }
+    const tableData = writeTargetRow(schema, next, parsed.table, rowId);
+    if (!tableData)
+        return;
+    const prev = getRowField(tableData, parsed.field);
+    if (!prev)
+        return;
+    const committed = commitFieldWrite(prev, makeFieldValue({
+        value: (value ?? null),
+        state: 'filled',
+        reason: null,
+        updatedBy: options.source,
+        updatedAt: now,
+    }));
+    tableData[parsed.field] = committed.field;
+    if (committed.changed) {
+        changed.push(parsed.path);
+        if (committed.historyEntry) {
+            history.push({
+                path: parsed.path,
+                entry: committed.historyEntry,
+                rowId: typeof tableData.id === 'string' && tableData.id ? tableData.id : undefined,
+            });
+        }
+    }
+}
 /**
  * Apply bare Writes (function / human / import / platform) onto a snapshot.
  * Validates type/enum and write permissions. Detects C5 changes and appends history.
+ * Multi-row tables: pass `{ table, rowId, values }` (or `rows` on StructuredWrites).
  */
 export function applyWrites(schema, snapshot, writes, options) {
-    if (!writes || Object.keys(writes).length === 0) {
+    const normalized = normalizeWrites(writes);
+    if (!normalized) {
         return { snapshot, changed: [], history: [] };
     }
     const now = options.now ?? Date.now();
@@ -73,38 +189,21 @@ export function applyWrites(schema, snapshot, writes, options) {
     const changed = [];
     const history = [];
     const errors = [];
-    for (const [path, value] of Object.entries(writes)) {
-        const writeIssues = assertWritableNormal(schema, path, options);
-        if (writeIssues.length > 0) {
-            errors.push(...writeIssues);
+    for (const [path, value] of Object.entries(normalized.fields)) {
+        applyBareFieldWrite(schema, snapshot, next, path, value, undefined, options, now, errors, changed, history);
+    }
+    for (const row of normalized.rows) {
+        if (!row.table || !row.rowId) {
+            errors.push({
+                code: 'row-not-found',
+                message: 'Row write requires table and rowId',
+                path: row.table || undefined,
+            });
             continue;
         }
-        const parsed = parseFieldPath(path);
-        const field = getCompiledTable(schema, parsed.table).fields[parsed.field];
-        const valueIssues = validateBareValue(field, value, path, {
-            allowNull: !field.derived && field.nullable,
-        });
-        if (valueIssues.length > 0) {
-            errors.push(...valueIssues);
-            continue;
-        }
-        const tableData = getSnapshotTable(next, parsed.table);
-        const prev = getRowField(tableData, parsed.field);
-        if (!prev)
-            continue;
-        const committed = commitFieldWrite(prev, makeFieldValue({
-            value: (value ?? null),
-            state: 'filled',
-            reason: null,
-            updatedBy: options.source,
-            updatedAt: now,
-        }));
-        tableData[parsed.field] = committed.field;
-        if (committed.changed) {
-            changed.push(parsed.path);
-            if (committed.historyEntry) {
-                history.push({ path: parsed.path, entry: committed.historyEntry });
-            }
+        for (const [fieldName, value] of Object.entries(row.values)) {
+            const path = formatFieldPath(row.table, fieldName);
+            applyBareFieldWrite(schema, snapshot, next, path, value, row.rowId, options, now, errors, changed, history);
         }
     }
     if (errors.length > 0) {
@@ -201,7 +300,11 @@ export function applySlotFilling(schema, snapshot, output, options = {}) {
                 if (committed.changed) {
                     changed.add(path);
                     if (committed.historyEntry) {
-                        history.push({ path, entry: committed.historyEntry });
+                        history.push({
+                            path,
+                            entry: committed.historyEntry,
+                            rowId: typeof tableData.id === 'string' && tableData.id ? tableData.id : undefined,
+                        });
                     }
                 }
             }
@@ -241,7 +344,7 @@ export function applySlotFilling(schema, snapshot, output, options = {}) {
                         if (committed.changed) {
                             changed.add(path);
                             if (committed.historyEntry) {
-                                history.push({ path, entry: committed.historyEntry });
+                                history.push({ path, entry: committed.historyEntry, rowId: id });
                             }
                         }
                     }
@@ -310,7 +413,11 @@ export function markAskedUnknown(schema, snapshot, fields, options = {}) {
         if (committed.changed) {
             changed.push(parsed.path);
             if (committed.historyEntry) {
-                history.push({ path: parsed.path, entry: committed.historyEntry });
+                history.push({
+                    path: parsed.path,
+                    entry: committed.historyEntry,
+                    rowId: typeof tableData.id === 'string' && tableData.id ? tableData.id : undefined,
+                });
             }
         }
     }

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

@@ -1,6 +1,7 @@
 import type { FuncRef } from '../functions/func-ref.js';
 import type { FieldPath } from '../slot/path.js';
-import type { ActionNode, AgendaHeader, AgendaTree, AuthoringNode, AuthoringWhen, BranchNode, FinishWhen, OnNoProgress, SectionNode, SwitchOnNode, TopicNode, TransferNode } from './types.js';
+import type { ActionNode, AgendaHeader, AgendaTree, AuthoringNode, AuthoringWhen, BranchNode, FinishWhen, IvrDigit, IvrFallbackAction, IvrNode, OnNoProgress, SectionNode, SwitchOnNode, TopicNode, TransferNode } from './types.js';
+import type { TransferDial, TransferMode, TransferSay } from './transfer-spec.js';
 export declare function topic(id: string, config: {
     label: string;
     applyWhen: AuthoringWhen;
@@ -20,10 +21,27 @@ export declare function transfer(id: string, config: {
     label: string;
     applyWhen: AuthoringWhen;
     numbers: string[];
-    mode: 'cold' | 'warm';
-    say: string;
-    unsuccessfulSay: string | null;
-}): TransferNode;
+    mode: TransferMode;
+    say: TransferSay;
+    unsuccessfulSay: TransferSay | null;
+} & Omit<TransferDial, 'numbers' | 'mode' | 'say' | 'unsuccessfulSay'>): TransferNode;
+export declare function ivr(id: string, config: {
+    label: string;
+    applyWhen: AuthoringWhen;
+    onDtmfResult: FuncRef;
+    finishWhen: FinishWhen;
+    fallbackAction: IvrFallbackAction;
+    confirmTimeoutMs: number;
+    pauseAfterSayMs: number;
+    loopSay: string;
+    enterSay: string | null;
+    succeedSay: string | null;
+    unsuccessSay: string | null;
+    finishOnKey?: IvrDigit | null;
+    minDigits?: number | null;
+    maxDigits?: number | null;
+    validateDigits?: IvrDigit[] | null;
+}): IvrNode;
 export declare function section(id: string, config: {
     label: string;
     applyWhen: AuthoringWhen;

package/dist/core/stage/builders.js

@@ -7,6 +7,9 @@ export function action(id, config) {
 export function transfer(id, config) {
     return { kind: 'transfer', id, ...config };
 }
+export function ivr(id, config) {
+    return { kind: 'ivr', id, ...config };
+}
 export function section(id, config, children) {
     return { kind: 'section', id, label: config.label, applyWhen: config.applyWhen, children };
 }

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

@@ -21,7 +21,7 @@ export type StageDriveResult = {
     fused: boolean;
 };
 /**
- * Walk until a topic/transfer/complete, executing actions inline.
+ * Walk until a topic/transfer/ivr/complete, executing actions inline.
  * Action returning null is skipped for this tick; writes trigger a full re-walk.
  */
 export declare function driveAgenda(items: FlatAgendaItem[], state: StageDriveState, compute: ComputeHost, hooks: StageDriveHooks, options?: {

package/dist/core/stage/drive.js

@@ -1,8 +1,9 @@
+import { normalizeWrites } from '../slot/write.js';
 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.
+ * Walk until a topic/transfer/ivr/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 = {}) {
@@ -11,11 +12,11 @@ export async function driveAgenda(items, state, compute, hooks, options = {}) {
     let currentPlacementId = state.currentPlacementId;
     const skip = new Set();
     let actionsRun = 0;
-    let lastWalk = await walkAgenda(items, snapshot, { currentPlacementId, compute, skipPlacementIds: skip });
+    let lastWalk;
     while (true) {
         lastWalk = await walkAgenda(items, snapshot, { currentPlacementId, compute, skipPlacementIds: skip });
         const hit = lastWalk.hit;
-        if (!hit || hit.kind === 'topic' || hit.kind === 'transfer') {
+        if (!hit || hit.kind === 'topic' || hit.kind === 'transfer' || hit.kind === 'ivr') {
             return {
                 snapshot,
                 currentPlacementId: hit?.placementId ?? currentPlacementId,
@@ -35,13 +36,13 @@ export async function driveAgenda(items, state, compute, hooks, options = {}) {
         }
         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;
+        if (!writes || !normalizeWrites(writes)) {
+            skip.add(hit.placementId);
             continue;
         }
-        skip.add(hit.placementId);
+        snapshot = await hooks.applyWrites(writes, snapshot);
+        skip.clear();
+        currentPlacementId = hit.placementId;
     }
 }
 export async function advanceAgenda(items, state, compute, hooks, options = {}) {

package/dist/core/stage/flatten.js

@@ -1,6 +1,7 @@
 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';
@@ -11,6 +12,9 @@ function isActionNode(node) {
 function isTransferNode(node) {
     return node.kind === 'transfer';
 }
+function isIvrNode(node) {
+    return node.kind === 'ivr';
+}
 function isSectionNode(node) {
     return node.kind === 'section';
 }
@@ -41,15 +45,8 @@ function toAgendaBlock(node) {
             say: node.say,
         };
     }
-    return {
-        kind: 'transfer',
-        id: node.id,
-        label: node.label,
-        numbers: node.numbers,
-        mode: node.mode,
-        say: node.say,
-        unsuccessfulSay: node.unsuccessfulSay,
-    };
+    const { applyWhen: _applyWhen, ...block } = node;
+    return block;
 }
 function compileBlock(block, functions, issues, path) {
     try {
@@ -63,6 +60,11 @@ function compileBlock(block, functions, issues, path) {
             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,
@@ -341,7 +343,7 @@ function asSectionPlacement(node, usedIds, path, issues) {
             children: node.children.map((child, i) => asPlacement(child, usedIds, `${path}/${node.id}[${i}]`, issues)),
         };
     }
-    if (isTopicNode(node) || isActionNode(node) || isTransferNode(node)) {
+    if (isTopicNode(node) || isActionNode(node) || isTransferNode(node) || isIvrNode(node)) {
         return {
             kind: 'node',
             placementId: uniquePlacementId(node.id, usedIds),
@@ -371,7 +373,7 @@ export function extractBlocksFromTree(tree, blocks = {}) {
     return blocks;
     function visit(nodes) {
         for (const node of nodes) {
-            if (isTopicNode(node) || isActionNode(node) || isTransferNode(node)) {
+            if (isTopicNode(node) || isActionNode(node) || isTransferNode(node) || isIvrNode(node)) {
                 blocks[node.id] = toAgendaBlock(node);
             }
             else if (isSectionNode(node) || node.kind === 'branch') {

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

@@ -1,11 +1,15 @@
-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 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, section, switchOn, topic, transfer } from './builders.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 { LAST_TRANSFER_RESULT_FIELD, collectTransferBlocks, registerTransferSessionFields, transferFieldKey, transferResultField, } from './transfer-fields.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 { unresolvedFinishWhenFields, walkAgenda, type WalkDecision, type WalkHitReason, type WalkOptions, type WalkResult, type WalkSkip, type WalkSkipReason, } from './walk.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,9 +1,12 @@
+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, section, switchOn, topic, transfer } from './builders.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 { LAST_TRANSFER_RESULT_FIELD, collectTransferBlocks, registerTransferSessionFields, transferFieldKey, transferResultField, } from './transfer-fields.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';

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

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

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

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