@superpanel-sdk/runtime 0.2.3 → 0.7.0

package/dist/core/slot/write.js

@@ -1,426 +0,0 @@
-import { getCompiledTable, isSnapshotSingleRow } from './compile-schema.js';
-import { commitFieldWrite, makeFieldValue } from './field.js';
-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,
-        value: extracted.value,
-        state: extracted.state,
-        updatedBy,
-        updatedAt: now,
-    });
-}
-function assertWritableNormal(schema, snapshot, path, options, rowId) {
-    const { table, field: fieldName } = requireFieldPath(path);
-    const tableDef = getCompiledTable(schema, table);
-    const field = tableDef?.fields[fieldName];
-    if (!tableDef || !field) {
-        return [{ code: 'unknown-field', message: `Unknown field: ${path}`, path }];
-    }
-    if (isRowIdField(fieldName)) {
-        return [
-            {
-                code: 'id-readonly',
-                message: `Cannot write row id: ${path}`,
-                path,
-            },
-        ];
-    }
-    if (field.derived) {
-        return [
-            {
-                code: 'derived-readonly',
-                message: `Cannot write derived field: ${path}`,
-                path,
-            },
-        ];
-    }
-    const systemOnly = options.systemOnly ??
-        (options.source === 'function' || options.source === 'platform' || options.source === 'import');
-    if (systemOnly && field.source !== 'system') {
-        return [
-            {
-                code: 'write-forbidden',
-                message: `Source ${options.source} cannot write conversation field ${path}`,
-                path,
-            },
-        ];
-    }
-    if (!isSnapshotSingleRow(tableDef) && !writeTargetRow(schema, snapshot, table, rowId)) {
-        return [
-            {
-                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) {
-    const normalized = normalizeWrites(writes);
-    if (!normalized) {
-        return { snapshot, changed: [], history: [] };
-    }
-    const now = options.now ?? Date.now();
-    const next = cloneSnapshot(snapshot);
-    const changed = [];
-    const history = [];
-    const errors = [];
-    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;
-        }
-        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) {
-        throw new Error(`applyWrites failed:\n${errors.map((e) => `- ${e.path ?? ''}: ${e.message}`).join('\n')}`);
-    }
-    return { snapshot: next, changed, history };
-}
-/**
- * Apply one human/admin field edit, including explicit slot state.
- * Unlike bare writes, this supports a selected row in a multi-row entity table.
- */
-export function applyFieldPatch(schema, snapshot, patch, options) {
-    const parsed = requireFieldPath(patch.path);
-    const table = getCompiledTable(schema, parsed.table);
-    const field = table?.fields[parsed.field];
-    if (!table || !field)
-        throw new Error(`Unknown field: ${patch.path}`);
-    if (isRowIdField(parsed.field))
-        throw new Error(`Cannot write row id: ${patch.path}`);
-    if (field.derived)
-        throw new Error(`Cannot write derived field: ${patch.path}`);
-    const value = patch.state === 'filled' ? patch.value : null;
-    if (patch.state !== 'empty') {
-        const issues = validateExtractedField(field, {
-            value,
-            state: patch.state,
-            reason: patch.reason ?? 'Human edit',
-        }, patch.path);
-        if (issues.length > 0) {
-            throw new Error(`applyFieldPatch failed:\n${issues.map((issue) => `- ${issue.path ?? ''}: ${issue.message}`).join('\n')}`);
-        }
-    }
-    const now = options.now ?? Date.now();
-    const next = cloneSnapshot(snapshot);
-    const data = getSnapshotTable(next, parsed.table);
-    const row = isSnapshotSingleRow(table)
-        ? data
-        : data?.find((candidate) => candidate.id === patch.rowId);
-    if (!row)
-        throw new Error(`Slot row not found: ${parsed.table}:${patch.rowId ?? 'single'}`);
-    const previous = getRowField(row, parsed.field);
-    if (!previous)
-        throw new Error(`Slot field not initialized: ${patch.path}`);
-    const committed = commitFieldWrite(previous, makeFieldValue({
-        value,
-        state: patch.state,
-        reason: patch.reason ?? 'Human edit',
-        updatedBy: options.source,
-        updatedAt: now,
-    }));
-    row[parsed.field] = committed.field;
-    if (!committed.changed)
-        return { snapshot: next, changed: [], history: [] };
-    return {
-        snapshot: next,
-        changed: [parsed.path],
-        history: committed.historyEntry ? [{ path: parsed.path, entry: committed.historyEntry }] : [],
-    };
-}
-/**
- * C4: apply accepted Slot Filling projection (full replace for present fields/rows).
- * Multi-row: projection is the full set of rows; omitted existing rows are deleted.
- */
-export function applySlotFilling(schema, snapshot, output, options = {}) {
-    const now = options.now ?? Date.now();
-    const next = cloneSnapshot(snapshot);
-    const changed = new Set();
-    const history = [];
-    const rowKeyMap = options.rowKeyMap ?? new Map();
-    for (const [tableName, projection] of Object.entries(output)) {
-        if (isReservedTableName(tableName))
-            continue;
-        const table = getCompiledTable(schema, tableName);
-        if (!table)
-            continue;
-        if (isSnapshotSingleRow(table)) {
-            const tableData = getSnapshotTable(next, tableName);
-            for (const [fieldName, extracted] of Object.entries(projection)) {
-                const field = table.fields[fieldName];
-                if (!field || field.derived || field.source !== 'conversation')
-                    continue;
-                const path = formatFieldPath(tableName, fieldName);
-                const issues = validateExtractedField(field, extracted, path);
-                if (issues.length > 0) {
-                    throw new Error(issues.map((i) => i.message).join('; '));
-                }
-                if (isRowIdField(fieldName))
-                    continue;
-                const prev = getRowField(tableData, fieldName);
-                if (!prev)
-                    continue;
-                const committed = commitFieldWrite(prev, extractedToFieldValue(extracted, 'slot-filling', now));
-                tableData[fieldName] = committed.field;
-                if (committed.changed) {
-                    changed.add(path);
-                    if (committed.historyEntry) {
-                        history.push({
-                            path,
-                            entry: committed.historyEntry,
-                            rowId: typeof tableData.id === 'string' && tableData.id ? tableData.id : undefined,
-                        });
-                    }
-                }
-            }
-        }
-        else {
-            const prevRows = getSnapshotTable(snapshot, tableName) ?? [];
-            const prevById = new Map(prevRows.map((r) => [r.id, r]));
-            const projectionRows = projection;
-            const nextRows = [];
-            let structuralChange = false;
-            for (const row of projectionRows) {
-                let id = row.rowKey;
-                if (row.rowKey.startsWith('new-')) {
-                    id = rowKeyMap.get(row.rowKey) ?? mintRowId();
-                    rowKeyMap.set(row.rowKey, id);
-                    structuralChange = true;
-                }
-                else if (!prevById.has(row.rowKey)) {
-                    structuralChange = true;
-                }
-                const prevRow = prevById.get(id);
-                const nextRow = { id };
-                for (const fieldName of slotFieldNames(table.fields)) {
-                    const field = table.fields[fieldName];
-                    if (field.derived)
-                        continue;
-                    const extracted = row.fields[fieldName];
-                    const prevFv = prevRow ? getRowField(prevRow, fieldName) : undefined;
-                    if (extracted) {
-                        const path = formatFieldPath(tableName, fieldName);
-                        const issues = validateExtractedField(field, extracted, path);
-                        if (issues.length > 0) {
-                            throw new Error(issues.map((i) => i.message).join('; '));
-                        }
-                        const committed = commitFieldWrite(prevFv, extractedToFieldValue(extracted, 'slot-filling', now));
-                        nextRow[fieldName] = committed.field;
-                        if (committed.changed) {
-                            changed.add(path);
-                            if (committed.historyEntry) {
-                                history.push({ path, entry: committed.historyEntry, rowId: id });
-                            }
-                        }
-                    }
-                    else if (prevFv) {
-                        nextRow[fieldName] = prevFv;
-                    }
-                    else {
-                        nextRow[fieldName] = makeFieldValue({
-                            value: null,
-                            state: 'empty',
-                            updatedBy: 'slot-filling',
-                            updatedAt: now,
-                        });
-                    }
-                }
-                nextRows.push(nextRow);
-            }
-            const prevIds = new Set(prevRows.map((r) => r.id));
-            const nextIds = new Set(nextRows.map((r) => r.id));
-            for (const id of prevIds) {
-                if (!nextIds.has(id))
-                    structuralChange = true;
-            }
-            if (prevRows.length !== nextRows.length)
-                structuralChange = true;
-            next[tableName] = nextRows;
-            if (structuralChange) {
-                for (const fieldName of slotFieldNames(table.fields)) {
-                    changed.add(formatFieldPath(tableName, fieldName));
-                }
-            }
-        }
-    }
-    return { snapshot: next, changed: [...changed], history };
-}
-/**
- * Mark remaining conversation fields as asked_unknown (Topic move-on).
- */
-export function markAskedUnknown(schema, snapshot, fields, options = {}) {
-    const now = options.now ?? Date.now();
-    const next = cloneSnapshot(snapshot);
-    const changed = [];
-    const history = [];
-    for (const path of fields) {
-        const parsed = requireFieldPath(path);
-        const table = getCompiledTable(schema, parsed.table);
-        const field = table?.fields[parsed.field];
-        if (!table || !field || field.derived)
-            continue;
-        if (field.source !== 'conversation')
-            continue;
-        if (!isSnapshotSingleRow(table))
-            continue;
-        const tableData = getSnapshotTable(next, parsed.table);
-        const prev = getRowField(tableData, parsed.field);
-        if (!prev || prev.state !== 'empty')
-            continue;
-        const committed = commitFieldWrite(prev, makeFieldValue({
-            value: null,
-            state: 'asked_unknown',
-            reason: options.reason ?? 'move-on',
-            updatedBy: 'platform',
-            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,
-                });
-            }
-        }
-    }
-    return { snapshot: next, changed, history };
-}
-//# sourceMappingURL=write.js.map

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

@@ -1,54 +0,0 @@
-import type { FuncRef } from '../functions/func-ref.js';
-import type { FieldPath } from '../slot/path.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;
-    instructions: string;
-    fields: FieldPath[] | null;
-    finishWhen: FinishWhen;
-    onNoProgress: OnNoProgress | null;
-}): TopicNode;
-export declare function action(id: string, config: {
-    label: string;
-    applyWhen: AuthoringWhen;
-    finishWhen: FinishWhen;
-    run: FuncRef;
-    say: string | null;
-}): ActionNode;
-export declare function transfer(id: string, config: {
-    label: string;
-    applyWhen: AuthoringWhen;
-    numbers: string[];
-    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;
-}, children: AuthoringNode[]): SectionNode;
-export declare function branch(children: AuthoringNode[]): BranchNode;
-export declare function switchOn(field: FieldPath, cases: Record<string, AuthoringNode[]> & {
-    otherwise?: AuthoringNode[];
-}): SwitchOnNode;
-export declare function agenda(id: string, header: AgendaHeader | null, tree: AuthoringNode[]): AgendaTree;
-//# sourceMappingURL=builders.d.ts.map

package/dist/core/stage/builders.js

@@ -1,31 +0,0 @@
-export function topic(id, config) {
-    return { kind: 'topic', id, ...config };
-}
-export function action(id, config) {
-    return { kind: '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 };
-}
-export function branch(children) {
-    return { kind: 'branch', children };
-}
-export function switchOn(field, cases) {
-    const { otherwise: otherwiseChildren, ...rest } = cases;
-    return {
-        kind: 'switchOn',
-        field,
-        cases: rest,
-        ...(otherwiseChildren ? { otherwise: otherwiseChildren } : {}),
-    };
-}
-export function agenda(id, header, tree) {
-    return { kind: 'agenda', id, header, tree };
-}
-//# sourceMappingURL=builders.js.map

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

@@ -1,17 +0,0 @@
-import type { FieldPath } from '../slot/path.js';
-import type { Condition, JsonRulesCondition, OtherwiseSentinel } from './types.js';
-export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
-export declare function isOtherwise(value: unknown): value is OtherwiseSentinel;
-export declare function looksLikeJsonRules(value: string): boolean;
-export declare function jsonRules(rules: Condition | Condition[] | string): Condition;
-export declare function otherwise(): OtherwiseSentinel;
-export declare function parseJsonRules(input: string): JsonRulesCondition;
-export declare function normalizeJsonRules(raw: unknown): JsonRulesCondition;
-export declare function collectJsonRulesFacts(condition: JsonRulesCondition | null | undefined): FieldPath[];
-export type ConditionEval = {
-    pass: boolean;
-    failedFields: FieldPath[];
-};
-export declare function evaluateJsonRules(condition: JsonRulesCondition, caseContext: unknown): Promise<ConditionEval>;
-export declare function extractTemplateFields(text: string): FieldPath[];
-//# sourceMappingURL=condition.d.ts.map