@superpanel-sdk/runtime 0.2.3 → 0.7.0

package/dist/core/stage/validate.js

@@ -1,330 +0,0 @@
-import { getCompiledTable } from '../slot/compile-schema.js';
-import { parseFieldPath } from '../slot/path.js';
-import { extractTemplateFields } from './condition.js';
-import { whenFields } from './finish-when.js';
-import { headerHasTransferInterrupt, validateInterrupts } from './interrupts.js';
-import { LAST_TRANSFER_RESULT_FIELD } from './transfer-fields.js';
-import { validateTransferDestinations } from './transfer-spec.js';
-function fieldExists(schema, path) {
-    const parsed = parseFieldPath(path);
-    if (!parsed)
-        return false;
-    return getCompiledTable(schema, parsed.table)?.fields[parsed.field] != null;
-}
-function requireFields(schema, fields, issues, path, code = 'unknown-field') {
-    for (const field of fields) {
-        if (!parseFieldPath(field)) {
-            issues.push({ code: 'invalid-field-path', message: `Invalid field path: ${field}`, path: `${path}:${field}` });
-            continue;
-        }
-        if (!fieldExists(schema, field)) {
-            issues.push({ code, message: `Unknown field: ${field}`, path: `${path}:${field}` });
-        }
-    }
-}
-function earlierCollected(items, index) {
-    const collected = new Set();
-    for (let i = 0; i < index; i++) {
-        const item = items[i];
-        if (item.kind === 'topic') {
-            for (const field of item.fields)
-                collected.add(field);
-        }
-        if (item.kind === 'ivr') {
-            for (const field of whenFields(item.finishWhen))
-                collected.add(field);
-        }
-    }
-    return collected;
-}
-function transferIndexByResultField(items) {
-    const map = new Map();
-    items.forEach((item, index) => {
-        if (item.kind === 'transfer') {
-            map.set(item.resultField, index);
-        }
-    });
-    return map;
-}
-function listedCustomFunctions(functions) {
-    const names = Object.entries(functions)
-        .filter(([, def]) => def.kind === 'custom')
-        .map(([name]) => name)
-        .sort((a, b) => a.localeCompare(b));
-    return names.length > 0 ? names.join(', ') : 'none';
-}
-function requireBoolWhen(when, functions, issues, path, label) {
-    if (when.kind === 'fn') {
-        const def = functions?.[when.fn];
-        if (functions && !def) {
-            issues.push({ code: 'unknown-function', message: `${label} fn not found: ${when.fn}`, path });
-        }
-        else if (def && def.kind !== 'boolCompute') {
-            issues.push({
-                code: label === 'applyWhen' ? 'apply-when-not-bool' : 'finish-when-not-bool',
-                message: `${label} fn '${when.fn}' must be defineBoolComputeFunc`,
-                path,
-            });
-        }
-        return;
-    }
-}
-function firstTransferIndex(items) {
-    return items.findIndex((item) => item.kind === 'transfer');
-}
-export function validateCompiledAgenda(compiled, options) {
-    const issues = [];
-    const { schema, functions } = options;
-    const prefix = options.agendaId ?? 'agenda';
-    const items = compiled.flat;
-    const seenPlacement = new Set();
-    const transferByResult = transferIndexByResultField(items);
-    const firstTransfer = firstTransferIndex(items);
-    const transferInterrupt = headerHasTransferInterrupt(compiled.header);
-    if (compiled.header) {
-        issues.push(...validateInterrupts(compiled.header.interrupts, {
-            schema,
-            agendaId: prefix,
-        }));
-    }
-    if (compiled.header?.channel && compiled.header.channel !== 'call') {
-        for (const item of items) {
-            if (item.kind === 'transfer') {
-                issues.push({
-                    code: 'transfer-channel',
-                    message: `Transfer ${item.id} is only valid on call agendas`,
-                    path: `${prefix}/${item.placementId}`,
-                });
-            }
-            if (item.kind === 'ivr') {
-                issues.push({
-                    code: 'ivr-channel',
-                    message: `IVR ${item.id} is only valid on call agendas`,
-                    path: `${prefix}/${item.placementId}`,
-                });
-            }
-        }
-    }
-    if (compiled.header?.firstMessage?.kind === 'template') {
-        requireFields(schema, extractTemplateFields(compiled.header.firstMessage.text), issues, `${prefix}/header/firstMessage`);
-    }
-    if (compiled.header?.firstMessage?.kind === 'fn') {
-        const name = compiled.header.firstMessage.fn;
-        const def = functions?.[name];
-        if (functions && !def) {
-            issues.push({
-                code: 'unknown-function',
-                message: `firstMessage fn not found: ${name}`,
-                path: `${prefix}/header/firstMessage`,
-            });
-        }
-        else if (def && def.kind !== 'system') {
-            issues.push({
-                code: 'invalid-function-kind',
-                message: `firstMessage fn must be a system function: ${name}`,
-                path: `${prefix}/header/firstMessage`,
-            });
-        }
-    }
-    for (let index = 0; index < items.length; index++) {
-        const item = items[index];
-        const path = `${prefix}/${item.placementId}`;
-        if (seenPlacement.has(item.placementId)) {
-            issues.push({ code: 'duplicate-placement', message: `Duplicate placementId: ${item.placementId}`, path });
-        }
-        seenPlacement.add(item.placementId);
-        requireFields(schema, whenFields(item.applyWhen), issues, `${path}/applyWhen`);
-        const collected = earlierCollected(items, index);
-        for (const field of whenFields(item.applyWhen)) {
-            if (field.startsWith('session.transfer_') && field.endsWith('_result')) {
-                const writer = transferByResult.get(field);
-                if (writer == null || writer >= index) {
-                    issues.push({
-                        code: 'transfer-result-before-node',
-                        message: `applyWhen reads ${field} before the transfer node`,
-                        path: `${path}/applyWhen`,
-                    });
-                }
-                continue;
-            }
-            if (field === LAST_TRANSFER_RESULT_FIELD) {
-                if (!transferInterrupt && (firstTransfer < 0 || firstTransfer >= index)) {
-                    issues.push({
-                        code: 'transfer-result-before-node',
-                        message: `applyWhen reads ${LAST_TRANSFER_RESULT_FIELD} before any transfer`,
-                        path: `${path}/applyWhen`,
-                    });
-                }
-                continue;
-            }
-            const parsed = parseFieldPath(field);
-            const def = parsed ? getCompiledTable(schema, parsed.table)?.fields[parsed.field] : undefined;
-            if (def?.derived)
-                continue;
-            if (def && !def.derived && def.source === 'system')
-                continue;
-            if (!collected.has(field)) {
-                issues.push({
-                    code: 'fork-field-not-collected',
-                    message: `applyWhen field ${field} is not collected by an earlier topic`,
-                    path: `${path}/applyWhen`,
-                });
-            }
-        }
-        requireBoolWhen(item.applyWhen, functions, issues, `${path}/applyWhen`, 'applyWhen');
-        if (item.kind === 'ivr') {
-            requireBoolWhen(item.finishWhen, functions, issues, `${path}/finishWhen`, 'finishWhen');
-            if (item.finishWhen.kind === 'rules') {
-                requireFields(schema, whenFields(item.finishWhen), issues, `${path}/finishWhen`);
-            }
-            const run = functions?.[item.onDtmfResult];
-            if (functions && !run) {
-                issues.push({
-                    code: 'unknown-function',
-                    message: `IVR '${item.id}' onDtmfResult unknown function '${item.onDtmfResult}'. Custom functions: ${listedCustomFunctions(functions)}`,
-                    path: `${path}/onDtmfResult`,
-                });
-            }
-            else if (run && run.kind !== 'custom') {
-                issues.push({
-                    code: 'ivr-run-not-custom',
-                    message: `IVR '${item.id}' onDtmfResult '${item.onDtmfResult}' must be defineCustomFunc`,
-                    path: `${path}/onDtmfResult`,
-                });
-            }
-            if (!item.loopSay.trim()) {
-                issues.push({
-                    code: 'ivr-say-empty',
-                    message: 'ivr loopSay must not be empty',
-                    path: `${path}/loopSay`,
-                });
-            }
-            if (!(item.confirmTimeoutMs > 0) || !(item.pauseAfterSayMs >= 0)) {
-                issues.push({
-                    code: 'ivr-timing',
-                    message: 'ivr confirmTimeoutMs must be > 0 and pauseAfterSayMs must be >= 0',
-                    path: `${path}/timing`,
-                });
-            }
-            if (item.fallbackAction !== 'end-call' && item.fallbackAction !== 'restore-normal-call-state') {
-                issues.push({
-                    code: 'ivr-fallback',
-                    message: 'ivr fallbackAction must be end-call or restore-normal-call-state',
-                    path: `${path}/fallbackAction`,
-                });
-            }
-            const digits = (item.validateDigits ?? []).map((digit) => digit.trim()).filter(Boolean);
-            if (!item.finishOnKey && digits.length === 0) {
-                issues.push({
-                    code: 'ivr-digits-empty',
-                    message: 'ivr needs validateDigits when finishOnKey is not set',
-                    path: `${path}/validateDigits`,
-                });
-            }
-        }
-        if (item.kind === 'topic') {
-            requireFields(schema, item.fields, issues, `${path}/fields`);
-            const referenced = whenFields(item.finishWhen);
-            requireFields(schema, referenced, issues, `${path}/finishWhen`);
-            requireBoolWhen(item.finishWhen, functions, issues, `${path}/finishWhen`, 'finishWhen');
-            if (item.finishWhen.kind !== 'fn') {
-                for (const field of referenced) {
-                    if (!item.fields.includes(field)) {
-                        issues.push({
-                            code: 'finish-when-not-in-fields',
-                            message: `finishWhen field ${field} is not in topic fields`,
-                            path: `${path}/finishWhen`,
-                        });
-                    }
-                }
-            }
-        }
-        if (item.kind === 'action') {
-            requireBoolWhen(item.finishWhen, functions, issues, `${path}/finishWhen`, 'finishWhen');
-            if (item.finishWhen.kind === 'rules') {
-                requireFields(schema, whenFields(item.finishWhen), issues, `${path}/finishWhen`);
-            }
-            const run = functions?.[item.run];
-            if (functions && !run) {
-                issues.push({
-                    code: 'unknown-function',
-                    message: `Action '${item.id}' runs unknown function '${item.run}'. Custom functions: ${listedCustomFunctions(functions)}`,
-                    path: `${path}/run`,
-                });
-            }
-            else if (run && run.kind !== 'custom') {
-                issues.push({
-                    code: 'action-run-not-custom',
-                    message: `Action '${item.id}' runs '${item.run}', which is ${run.kind}. Actions must use defineCustomFunc.`,
-                    path: `${path}/run`,
-                });
-            }
-        }
-        if (item.kind === 'transfer') {
-            for (const number of item.numbers) {
-                requireFields(schema, extractTemplateFields(number), issues, `${path}/numbers`);
-            }
-            if (item.arguments) {
-                for (const key of ['sendDigits', 'sipUrl', 'sipUsername', 'sipPassword']) {
-                    const text = item.arguments[key];
-                    if (text) {
-                        requireFields(schema, extractTemplateFields(text), issues, `${path}/arguments/${key}`);
-                    }
-                }
-            }
-            if (typeof item.say === 'string') {
-                requireFields(schema, extractTemplateFields(item.say), issues, `${path}/say`);
-            }
-            else if (item.say) {
-                for (const text of Object.values(item.say)) {
-                    requireFields(schema, extractTemplateFields(text), issues, `${path}/say`);
-                }
-            }
-            issues.push(...validateTransferDestinations(item.numbers, {
-                path: `${path}/numbers`,
-                code: 'transfer-target',
-            }));
-            requireFields(schema, [item.resultField, LAST_TRANSFER_RESULT_FIELD], issues, `${path}/result`);
-        }
-    }
-    return issues.length === 0 ? { ok: true } : { ok: false, issues };
-}
-const FATAL_AGENDA_CODES = new Set([
-    'unknown-block',
-    'unknown-field',
-    'invalid-field-path',
-    'invalid-finish-when',
-    'unknown-function',
-    'finish-when-not-bool',
-    'apply-when-not-bool',
-    'invalid-apply-when',
-    'finish-when-not-in-fields',
-    'fork-field-not-collected',
-    'otherwise-not-unique',
-    'otherwise-not-last',
-    'branch-no-explicit',
-    'otherwise-unexpanded',
-    'transfer-channel',
-    'ivr-channel',
-    'ivr-run-not-custom',
-    'ivr-fallback',
-    'ivr-timing',
-    'ivr-say-empty',
-    'ivr-digits-empty',
-    'transfer-result-before-node',
-    'action-run-not-custom',
-    'duplicate-placement',
-    'block-kind-mismatch',
-    'interrupt-tool-reserved',
-    'interrupt-tool-duplicate',
-    'interrupt-priority-tie',
-    'interrupt-languages-empty',
-    'interrupt-language-field',
-    'interrupt-transfer-number',
-    'interrupt-escalation-criteria',
-    'transfer-target',
-]);
-export function fatalAgendaIssues(issues) {
-    return issues.filter((issue) => FATAL_AGENDA_CODES.has(issue.code));
-}
-//# sourceMappingURL=validate.js.map

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

@@ -1,39 +0,0 @@
-import type { ComputeHost } from '../../compute-host/compute-host.js';
-import type { FieldPath } from '../slot/path.js';
-import type { RuntimeSlotsSnapshot } from '../slot/types.js';
-import type { FlatAgendaItem } from './types.js';
-export type WalkSkipReason = 'folded' | 'done' | 'skipped';
-export type WalkSkip = {
-    placementId: string;
-    blockId: string;
-    reason: WalkSkipReason;
-};
-export type WalkHitReason = 'sticky' | 'scan';
-export type WalkStats = {
-    durationMs: number;
-    evals: number;
-};
-export type WalkResult = {
-    hit: FlatAgendaItem | null;
-    reason: WalkHitReason | 'complete';
-    skipped: WalkSkip[];
-    decisions: WalkDecision[];
-    stats: WalkStats;
-};
-export type WalkDecision = {
-    placementId: string;
-    blockId: string;
-    status: 'folded' | 'done' | 'hit' | 'skipped';
-    via: WalkHitReason;
-    applyWhen: boolean | null;
-    finishWhen: boolean | null;
-};
-export type WalkOptions = {
-    currentPlacementId?: string | null;
-    /** This-tick skips (action returned null). */
-    skipPlacementIds?: ReadonlySet<string>;
-    compute?: ComputeHost;
-};
-export declare function walkAgenda(items: FlatAgendaItem[], snapshot: RuntimeSlotsSnapshot, options?: WalkOptions): Promise<WalkResult>;
-export declare function unresolvedFinishWhenFields(item: FlatAgendaItem, snapshot: RuntimeSlotsSnapshot, compute?: ComputeHost): Promise<FieldPath[]>;
-//# sourceMappingURL=walk.d.ts.map

package/dist/core/stage/walk.js

@@ -1,119 +0,0 @@
-import { evaluateWhen } from './finish-when.js';
-import { ivrAttempted } from './ivr-fields.js';
-function startsWithGroup(groupPath, prefix) {
-    if (prefix.length === 0)
-        return true;
-    if (groupPath.length < prefix.length)
-        return false;
-    return prefix.every((id, i) => groupPath[i] === id);
-}
-async function consider(item, snapshot, compute, skip, via, skipped, decisions, stats) {
-    if (skip.has(item.placementId)) {
-        skipped.push({ placementId: item.placementId, blockId: item.id, reason: 'skipped' });
-        decisions.push({
-            placementId: item.placementId,
-            blockId: item.id,
-            status: 'skipped',
-            via,
-            applyWhen: null,
-            finishWhen: null,
-        });
-        return 'skip';
-    }
-    stats.evals += 1;
-    const applies = await evaluateWhen(item.applyWhen, snapshot, compute);
-    if (!applies.pass) {
-        skipped.push({ placementId: item.placementId, blockId: item.id, reason: 'folded' });
-        decisions.push({
-            placementId: item.placementId,
-            blockId: item.id,
-            status: 'folded',
-            via,
-            applyWhen: false,
-            finishWhen: null,
-        });
-        return 'fold';
-    }
-    if (item.kind === 'ivr' && ivrAttempted(item, snapshot)) {
-        skipped.push({ placementId: item.placementId, blockId: item.id, reason: 'done' });
-        decisions.push({
-            placementId: item.placementId,
-            blockId: item.id,
-            status: 'done',
-            via,
-            applyWhen: true,
-            finishWhen: true,
-        });
-        return 'done';
-    }
-    stats.evals += 1;
-    const finished = await evaluateWhen(item.finishWhen, snapshot, compute);
-    if (finished.done) {
-        skipped.push({ placementId: item.placementId, blockId: item.id, reason: 'done' });
-        decisions.push({
-            placementId: item.placementId,
-            blockId: item.id,
-            status: 'done',
-            via,
-            applyWhen: true,
-            finishWhen: true,
-        });
-        return 'done';
-    }
-    decisions.push({
-        placementId: item.placementId,
-        blockId: item.id,
-        status: 'hit',
-        via,
-        applyWhen: true,
-        finishWhen: false,
-    });
-    return 'hit';
-}
-async function firstHit(items, snapshot, compute, skip, via, skipped, decisions, considered, stats) {
-    for (const item of items) {
-        if (considered.has(item.placementId))
-            continue;
-        considered.add(item.placementId);
-        if ((await consider(item, snapshot, compute, skip, via, skipped, decisions, stats)) === 'hit') {
-            return item;
-        }
-    }
-    return null;
-}
-export async function walkAgenda(items, snapshot, options = {}) {
-    const started = Date.now();
-    const skip = options.skipPlacementIds ?? new Set();
-    const skipped = [];
-    const decisions = [];
-    const considered = new Set();
-    const stats = { evals: 0 };
-    const currentId = options.currentPlacementId ?? null;
-    const finish = (hit, reason) => ({
-        hit,
-        reason,
-        skipped,
-        decisions,
-        stats: { durationMs: Date.now() - started, evals: stats.evals },
-    });
-    if (currentId) {
-        const current = items.find((item) => item.placementId === currentId);
-        if (current && current.groupPath.length > 0) {
-            for (let depth = current.groupPath.length; depth >= 1; depth--) {
-                const prefix = current.groupPath.slice(0, depth);
-                const groupItems = items.filter((item) => startsWithGroup(item.groupPath, prefix));
-                const hit = await firstHit(groupItems, snapshot, options.compute, skip, 'sticky', skipped, decisions, considered, stats);
-                if (hit)
-                    return finish(hit, 'sticky');
-            }
-        }
-    }
-    const hit = await firstHit(items, snapshot, options.compute, skip, 'scan', skipped, decisions, considered, stats);
-    if (hit)
-        return finish(hit, 'scan');
-    return finish(null, 'complete');
-}
-export async function unresolvedFinishWhenFields(item, snapshot, compute) {
-    return (await evaluateWhen(item.finishWhen, snapshot, compute)).failedFields;
-}
-//# sourceMappingURL=walk.js.map

package/dist/fn-context/rpc/integration/list-bindings.d.ts

@@ -1,21 +0,0 @@
-import { type BoundIntegrationMeta } from '../../../core/context/types.js';
-import { type RpcContext } from '../trpc-init.js';
-export type ListBindingsHandler = (opts: {
-    ctx: RpcContext;
-}) => Promise<BoundIntegrationMeta[]>;
-export declare function createListBindingsProcedure(handler: ListBindingsHandler): import("@trpc/server").TRPCQueryProcedure<{
-    input: void;
-    output: {
-        surfaceKey: "docusigns" | "envs" | "filevines" | "hubspots" | "twilios";
-        target: {
-            kind: "account" | "resource";
-            id: string;
-        };
-        name: string;
-        methods: string[];
-        credentials: Record<string, unknown>;
-        config: Record<string, unknown>;
-    }[];
-    meta: object;
-}>;
-//# sourceMappingURL=list-bindings.d.ts.map

package/dist/fn-context/system-args.d.ts

@@ -1,6 +0,0 @@
-/**
- * `kind: 'system'` — `args[0]` is the params object (empty when omitted).
- * Snapshot projection belongs to compute / custom / caseContextView, not here.
- */
-export declare function resolveSystemFnParams(args: unknown[]): object;
-//# sourceMappingURL=system-args.d.ts.map

package/dist/fn-context/system-args.js

@@ -1,14 +0,0 @@
-/**
- * `kind: 'system'` — `args[0]` is the params object (empty when omitted).
- * Snapshot projection belongs to compute / custom / caseContextView, not here.
- */
-export function resolveSystemFnParams(args) {
-    const raw = args[0];
-    if (raw == null)
-        return {};
-    if (typeof raw !== 'object' || Array.isArray(raw)) {
-        throw new Error('system function args[0] must be a params object');
-    }
-    return raw;
-}
-//# sourceMappingURL=system-args.js.map