@superpanel-sdk/runtime 0.2.1 → 0.2.3

package/dist/compute-host/read-only-cache.js

@@ -0,0 +1,61 @@
+const READ_ONLY_KINDS = new Set(['compute', 'boolCompute', 'caseContextView']);
+/** Names safe to cache: `caseContextView` plus every compute / boolCompute. */
+export function readOnlyComputeNames(functions) {
+    const names = new Set(['caseContextView']);
+    if (!functions)
+        return names;
+    for (const [name, entry] of Object.entries(functions)) {
+        if (READ_ONLY_KINDS.has(entry.kind))
+            names.add(name);
+    }
+    return names;
+}
+/**
+ * Cache read-only `execute` results by function name + the single input object.
+ * Calls with extra args bypass the cache so a shared snapshot cannot alias
+ * two different argument lists.
+ *
+ * Do not wrap a host used by derived recompute: that path mutates one snapshot
+ * in place between `compute` calls. Stage walk / when-eval is safe (new snapshot
+ * after writes).
+ */
+export function withReadOnlyComputeCache(host, options) {
+    const allow = resolveAllow(options?.readOnly);
+    const cache = new WeakMap();
+    return {
+        async execute(name, args = []) {
+            const input = args[0];
+            if (!allow(name) || args.length !== 1 || input == null || typeof input !== 'object') {
+                return host.execute(name, args);
+            }
+            let byName = cache.get(input);
+            if (!byName) {
+                byName = new Map();
+                cache.set(input, byName);
+            }
+            const hit = byName.get(name);
+            if (hit)
+                return hit;
+            const pending = host.execute(name, args);
+            byName.set(name, pending);
+            try {
+                return await pending;
+            }
+            catch (error) {
+                if (byName.get(name) === pending)
+                    byName.delete(name);
+                throw error;
+            }
+        },
+        dispose() {
+            host.dispose();
+        },
+    };
+}
+function resolveAllow(readOnly) {
+    if (typeof readOnly === 'function')
+        return readOnly;
+    const names = new Set(readOnly ?? ['caseContextView']);
+    return (name) => names.has(name);
+}
+//# sourceMappingURL=read-only-cache.js.map

package/dist/compute-host/source-compute-host.d.ts

@@ -12,6 +12,10 @@ export type SourceComputeHostOptions = {
     data?: ActionDataSlice;
     /** When set with data.config.backendUrl, uses Http RpcApiHost. */
     runToken?: string;
+    /** Runtime version forwarded on every `ctx.api` RPC. Required when RpcApiHost is used. */
+    runtimeVersion?: string;
+    /** Runtime dependency source forwarded with runtimeVersion. Required when RpcApiHost is used. */
+    runtimeSource?: 'local-file' | 'npm';
     /** Forwarded on every `ctx.api` RPC as `x-request-id`. */
     getRequestId?: () => string | undefined;
     /** Forwarded to script log RPC calls. */

package/dist/compute-host/source-compute-host.js

@@ -49,11 +49,16 @@ export function createSourceComputeHost(options) {
                 const caseContext = viewFn(requireSlots(name, args));
                 const ctx = await systemContext();
                 const fn = def.main;
-                return fn(caseContext, ctx);
+                return fn(caseContext, { ...ctx, params: args[1] ?? {} });
             }
             const params = resolveSystemFnParams(args);
+            const contextStarted = Date.now();
             const ctx = await systemContext();
-            return def.main({ ...ctx, params });
+            console.log(`[source timing] ${name} context ${Date.now() - contextStarted}ms`);
+            const functionStarted = Date.now();
+            const result = await def.main({ ...ctx, params });
+            console.log(`[source timing] ${name} function ${Date.now() - functionStarted}ms`);
+            return result;
         },
         dispose() { },
     };
@@ -62,9 +67,14 @@ function resolveApiHost(options) {
     if (options.apiHost)
         return options.apiHost;
     if (options.runToken && options.data?.config.backendUrl) {
+        if (!options.runtimeVersion || !options.runtimeSource) {
+            throw new Error('runtimeVersion and runtimeSource are required when using RpcApiHost');
+        }
         return createRpcApiHost({
             baseUrl: options.data.config.backendUrl,
             getToken: () => options.runToken,
+            runtimeVersion: options.runtimeVersion,
+            runtimeSource: options.runtimeSource,
             getRequestId: options.getRequestId,
             getTags: options.getTags,
         });

package/dist/core/context/types.d.ts

@@ -19,7 +19,25 @@ export type Slots = Record<string, unknown>;
  * With `view.ts`, use `CaseContextOf<typeof caseContextView>` from that module.
  */
 export type CaseContext = Record<string, unknown>;
-export type Writes = Record<FieldPath, unknown>;
+/** Flat writes for single-row tables, or the current-bound row of an entity table. */
+export type FieldWrites = Record<FieldPath, unknown>;
+/** Address one row of a multi-row table (`children`, `contact`, custom arrays). */
+export type RowWrite = {
+    table: string;
+    rowId: string;
+    values: Record<string, unknown>;
+};
+/** Mix flat field writes with explicit row writes in one return. */
+export type StructuredWrites = {
+    fields?: FieldWrites;
+    rows?: RowWrite[];
+};
+/**
+ * Function / platform write payload.
+ * Flat `{ '表.字段': 值 }` for single-row (or current-party) fields;
+ * `{ table, rowId, values }` to write a specific multi-row.
+ */
+export type Writes = FieldWrites | RowWrite | StructuredWrites;
 export type Logger = {
     info: (message: string, extra?: Record<string, unknown>) => void;
     warn: (message: string, extra?: Record<string, unknown>) => void;

package/dist/core/functions/define/custom.d.ts

@@ -1,4 +1,4 @@
 import type { CustomFn, DefinedFunc, FuncOptions } from '../types.js';
 import type { CaseContext } from '../../context/types.js';
-export declare function defineCustomFunc<S = CaseContext>(main: CustomFn<S>, options?: FuncOptions): DefinedFunc;
+export declare function defineCustomFunc<S = CaseContext, P extends object = object>(main: CustomFn<S, P>, options?: FuncOptions): DefinedFunc;
 //# sourceMappingURL=custom.d.ts.map

package/dist/core/functions/types.d.ts

@@ -6,16 +6,16 @@ export type FuncOptions = {
 };
 /** First arg is CaseContext (or Slots when the sequence has no view). */
 export type ComputeFn<S = CaseContext, R = unknown> = (caseContext: S) => R | Promise<R>;
-export type CustomFn<S = CaseContext> = (caseContext: S, ctx: SystemContext) => Promise<Writes | null>;
+export type FunctionCtx<Params extends object> = SystemContext & {
+    params: Params;
+};
+export type CustomFn<S = CaseContext, P extends object = object> = (caseContext: S, ctx: FunctionCtx<P>) => Promise<Writes | null>;
 /** Inbound webhook request payload. */
 export type WebHookFunctionParams = {
     headers: Record<string, string | string[] | undefined>;
     body: unknown;
     rawBody?: string;
 };
-export type FunctionCtx<Params extends object> = SystemContext & {
-    params: Params;
-};
 export type FunctionCall<Params extends object, Return> = (ctx: FunctionCtx<Params>) => Promise<Return>;
 export type WebHookFunction = FunctionCall<WebHookFunctionParams, void>;
 export type GetFirstMessageParams<S = CaseContext> = {

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

@@ -9,7 +9,7 @@ export { isValidDataTypeValue, validateExtractedField, validateBareValue } from
 export { buildSlotFillingJsonSchema, buildFieldCatalog, type SfSchemaOptions } from './sf-schema.js';
 export { validateSlotFillingOutput, type ValidateSlotFillingOptions } from './sf-validate.js';
 export { snapshotFrom, cloneSnapshot, getSingleField, getSnapshotTable, type SnapshotSeed } from './snapshot.js';
-export { applyFieldPatch, applyWrites, applySlotFilling, markAskedUnknown, type ApplySlotFillingOptions, type FieldPatchInput, } from './write.js';
+export { applyFieldPatch, applyWrites, applySlotFilling, markAskedUnknown, isRowWrite, isStructuredWrites, normalizeWrites, type ApplySlotFillingOptions, type FieldPatchInput, } from './write.js';
 export type { ComputeFnMap, ComputeHost, ComputeHostOrFns, LocalComputeHostOptions, RecomputeOptions, } from './derived.js';
 export { createLocalComputeHost, createSourceComputeHost, resolveComputeHost, recomputeDerived, applyFieldPatchAndRecompute, applyWritesAndRecompute, applySlotFillingAndRecompute, } from './derived.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/slot/index.js

@@ -9,6 +9,6 @@ export { isValidDataTypeValue, validateExtractedField, validateBareValue } from
 export { buildSlotFillingJsonSchema, buildFieldCatalog } from './sf-schema.js';
 export { validateSlotFillingOutput } from './sf-validate.js';
 export { snapshotFrom, cloneSnapshot, getSingleField, getSnapshotTable } from './snapshot.js';
-export { applyFieldPatch, applyWrites, applySlotFilling, markAskedUnknown, } from './write.js';
+export { applyFieldPatch, applyWrites, applySlotFilling, markAskedUnknown, isRowWrite, isStructuredWrites, normalizeWrites, } from './write.js';
 export { createLocalComputeHost, createSourceComputeHost, resolveComputeHost, recomputeDerived, applyFieldPatchAndRecompute, applyWritesAndRecompute, applySlotFillingAndRecompute, } from './derived.js';
 //# sourceMappingURL=index.js.map

package/dist/core/slot/types.d.ts

@@ -23,6 +23,8 @@ export type FieldValue = {
 export type HistoryAppend = {
     path: FieldPath;
     entry: FieldHistoryEntry;
+    /** Set when the write targeted a specific snapshot row. */
+    rowId?: string;
 };
 export type ExtractedField = {
     reason: string;

package/dist/core/slot/write.d.ts

@@ -1,9 +1,16 @@
-import type { FieldState, Writes } from '../context/types.js';
+import type { FieldState, FieldWrites, RowWrite, StructuredWrites, Writes } from '../context/types.js';
 import type { FieldPath } from './path.js';
 import type { ApplyWritesOptions, ApplyWritesResult, CompiledSlotSchema, RuntimeSlotsSnapshot, SlotFillingOutput, UpdatedBy } from './types.js';
+export declare function isRowWrite(value: unknown): value is RowWrite;
+export declare function isStructuredWrites(value: unknown): value is StructuredWrites;
+export declare function normalizeWrites(writes: Writes | null | undefined): {
+    fields: FieldWrites;
+    rows: RowWrite[];
+} | null;
 /**
  * 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 declare function applyWrites(schema: CompiledSlotSchema, snapshot: RuntimeSlotsSnapshot, writes: Writes | null | undefined, options: ApplyWritesOptions): ApplyWritesResult;
 export type FieldPatchInput = {

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