@superpanel-sdk/runtime 0.2.3 → 0.5.0

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

package/dist/core/stage/condition.js

@@ -1,198 +0,0 @@
-import { Engine } from 'json-rules-engine';
-import { emptyFieldValue } from '../slot/field.js';
-import { parseFieldPath } from '../slot/path.js';
-import { getRowField } from '../slot/row.js';
-const OPERATORS = new Set([
-    'equal',
-    'notEqual',
-    'in',
-    'notIn',
-    'contains',
-    'doesNotContain',
-    'lessThan',
-    'lessThanInclusive',
-    'greaterThan',
-    'greaterThanInclusive',
-]);
-const PASS_EVENT = 'pass';
-export function isPlainObject(value) {
-    return value != null && typeof value === 'object' && !Array.isArray(value);
-}
-export function isOtherwise(value) {
-    return isPlainObject(value) && value.op === 'otherwise' && !('fact' in value) && !('operator' in value);
-}
-export function looksLikeJsonRules(value) {
-    const trimmed = value.trim();
-    return trimmed.startsWith('{') || trimmed.startsWith('[');
-}
-export function jsonRules(rules) {
-    if (typeof rules === 'string')
-        return parseJsonRules(rules);
-    if (Array.isArray(rules))
-        return { all: rules };
-    return rules;
-}
-export function otherwise() {
-    return { op: 'otherwise' };
-}
-export function parseJsonRules(input) {
-    let parsed;
-    try {
-        parsed = JSON.parse(input);
-    }
-    catch {
-        throw new Error('Invalid json-rules JSON');
-    }
-    return normalizeJsonRules(parsed);
-}
-export function normalizeJsonRules(raw) {
-    if (Array.isArray(raw)) {
-        if (raw.length === 0)
-            throw new Error('json-rules array must not be empty');
-        return { all: raw.map(normalizeJsonRules) };
-    }
-    if (!isPlainObject(raw)) {
-        throw new Error('Invalid json-rules condition');
-    }
-    if ('conditions' in raw) {
-        return normalizeJsonRules(raw.conditions);
-    }
-    if ('all' in raw) {
-        if (!Array.isArray(raw.all))
-            throw new Error('json-rules `all` must be an array');
-        return { all: raw.all.map(normalizeJsonRules) };
-    }
-    if ('any' in raw) {
-        if (!Array.isArray(raw.any))
-            throw new Error('json-rules `any` must be an array');
-        return { any: raw.any.map(normalizeJsonRules) };
-    }
-    if ('not' in raw) {
-        return { not: normalizeJsonRules(raw.not) };
-    }
-    if (typeof raw.fact !== 'string' || typeof raw.operator !== 'string') {
-        throw new Error('json-rules leaf requires `fact` and `operator`');
-    }
-    if (!OPERATORS.has(raw.operator)) {
-        throw new Error(`Unknown json-rules-engine operator: ${raw.operator}`);
-    }
-    const leaf = {
-        fact: raw.fact,
-        operator: raw.operator,
-        value: 'value' in raw ? raw.value : undefined,
-    };
-    if (typeof raw.path === 'string')
-        leaf.path = raw.path;
-    return leaf;
-}
-export function collectJsonRulesFacts(condition) {
-    if (!condition)
-        return [];
-    const out = [];
-    const seen = new Set();
-    visit(condition);
-    return out;
-    function visit(node) {
-        if ('all' in node) {
-            for (const child of node.all)
-                visit(child);
-            return;
-        }
-        if ('any' in node) {
-            for (const child of node.any)
-                visit(child);
-            return;
-        }
-        if ('not' in node) {
-            visit(node.not);
-            return;
-        }
-        if ('fact' in node && node.fact && !seen.has(node.fact)) {
-            seen.add(node.fact);
-            out.push(node.fact);
-        }
-    }
-}
-export async function evaluateJsonRules(condition, caseContext) {
-    const engine = new Engine([], { allowUndefinedFacts: true });
-    engine.addRule({
-        conditions: toEngineConditions(condition),
-        event: { type: PASS_EVENT },
-    });
-    const { events, failureResults } = await engine.run(factsFromCaseContext(condition, caseContext));
-    const pass = events.some((event) => event.type === PASS_EVENT);
-    return {
-        pass,
-        failedFields: pass ? [] : collectFailedFacts(failureResults[0]?.conditions),
-    };
-}
-function toEngineConditions(condition) {
-    const node = applyDefaultPath(condition);
-    if ('all' in node || 'any' in node || 'not' in node)
-        return node;
-    return { all: [node] };
-}
-function applyDefaultPath(condition) {
-    if ('all' in condition)
-        return { ...condition, all: condition.all.map(applyDefaultPath) };
-    if ('any' in condition)
-        return { ...condition, any: condition.any.map(applyDefaultPath) };
-    if ('not' in condition)
-        return { ...condition, not: applyDefaultPath(condition.not) };
-    if ('path' in condition && condition.path)
-        return condition;
-    return { ...condition, path: '$.value' };
-}
-function factsFromCaseContext(condition, caseContext) {
-    const facts = {};
-    for (const fact of collectJsonRulesFacts(condition)) {
-        facts[fact] = getContextField(caseContext, fact) ?? emptyFieldValue();
-    }
-    return facts;
-}
-function getContextField(caseContext, path) {
-    const parsed = parseFieldPath(path);
-    if (!parsed || !isPlainObject(caseContext))
-        return undefined;
-    const row = caseContext[parsed.table];
-    if (!row || typeof row !== 'object' || Array.isArray(row))
-        return undefined;
-    return getRowField(row, parsed.field);
-}
-function collectFailedFacts(node) {
-    const out = [];
-    const seen = new Set();
-    visit(node);
-    return out;
-    function visit(value) {
-        if (value == null || typeof value !== 'object')
-            return;
-        const rec = value;
-        if (typeof rec.fact === 'string' && rec.result === false && !seen.has(rec.fact)) {
-            seen.add(rec.fact);
-            out.push(rec.fact);
-        }
-        if (Array.isArray(rec.all))
-            for (const child of rec.all)
-                visit(child);
-        if (Array.isArray(rec.any))
-            for (const child of rec.any)
-                visit(child);
-        if (rec.not)
-            visit(rec.not);
-    }
-}
-const TEMPLATE_RE = /\{\{\s*([A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g;
-export function extractTemplateFields(text) {
-    const out = [];
-    const seen = new Set();
-    for (const match of text.matchAll(TEMPLATE_RE)) {
-        const path = match[1];
-        if (!seen.has(path)) {
-            seen.add(path);
-            out.push(path);
-        }
-    }
-    return out;
-}
-//# sourceMappingURL=condition.js.map

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

@@ -1,43 +0,0 @@
-import type { Writes } from '../context/types.js';
-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 WalkResult } from './walk.js';
-import type { FlatActionItem, FlatAgendaItem, FlatTransferItem } from './types.js';
-export declare const DEFAULT_MAX_ACTIONS_PER_TURN = 10;
-export type StageDriveHooks = {
-    runAction: (item: FlatActionItem, snapshot: RuntimeSlotsSnapshot) => Promise<Writes | null>;
-    applyWrites: (writes: Writes, snapshot: RuntimeSlotsSnapshot) => Promise<RuntimeSlotsSnapshot>;
-};
-export type StageDriveState = {
-    snapshot: RuntimeSlotsSnapshot;
-    currentPlacementId: string | null;
-};
-export type StageDriveResult = {
-    snapshot: RuntimeSlotsSnapshot;
-    currentPlacementId: string | null;
-    walk: WalkResult;
-    actionsRun: number;
-    fused: boolean;
-};
-/**
- * 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?: {
-    maxActions?: number;
-}): Promise<StageDriveResult>;
-export type AdvanceResult = {
-    ok: true;
-    drive: StageDriveResult;
-} | {
-    ok: false;
-    missing: FieldPath[];
-    item: FlatAgendaItem;
-};
-export declare function advanceAgenda(items: FlatAgendaItem[], state: StageDriveState, compute: ComputeHost, hooks: StageDriveHooks, options?: {
-    maxActions?: number;
-}): Promise<AdvanceResult>;
-export declare function watchdogHint(item: FlatAgendaItem | null, snapshot: RuntimeSlotsSnapshot, compute?: ComputeHost): Promise<string | null>;
-export declare function transferWrites(item: FlatTransferItem, result: 'connected' | 'failed'): Writes;
-//# sourceMappingURL=drive.d.ts.map

package/dist/core/stage/drive.js

@@ -1,78 +0,0 @@
-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/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 = {}) {
-    const maxActions = options.maxActions ?? DEFAULT_MAX_ACTIONS_PER_TURN;
-    let snapshot = state.snapshot;
-    let currentPlacementId = state.currentPlacementId;
-    const skip = new Set();
-    let actionsRun = 0;
-    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' || hit.kind === 'ivr') {
-            return {
-                snapshot,
-                currentPlacementId: hit?.placementId ?? currentPlacementId,
-                walk: lastWalk,
-                actionsRun,
-                fused: false,
-            };
-        }
-        if (actionsRun >= maxActions) {
-            return {
-                snapshot,
-                currentPlacementId: hit.placementId,
-                walk: lastWalk,
-                actionsRun,
-                fused: true,
-            };
-        }
-        actionsRun += 1;
-        const writes = await hooks.runAction(hit, snapshot);
-        if (!writes || !normalizeWrites(writes)) {
-            skip.add(hit.placementId);
-            continue;
-        }
-        snapshot = await hooks.applyWrites(writes, snapshot);
-        skip.clear();
-        currentPlacementId = hit.placementId;
-    }
-}
-export async function advanceAgenda(items, state, compute, hooks, options = {}) {
-    const current = (state.currentPlacementId ? items.find((item) => item.placementId === state.currentPlacementId) : null) ??
-        (await walkAgenda(items, state.snapshot, { compute })).hit;
-    if (current?.kind === 'topic') {
-        const finished = await evaluateWhen(current.finishWhen, state.snapshot, compute);
-        if (!finished.done) {
-            return {
-                ok: false,
-                missing: await unresolvedFinishWhenFields(current, state.snapshot, compute),
-                item: current,
-            };
-        }
-    }
-    const drive = await driveAgenda(items, state, compute, hooks, options);
-    return { ok: true, drive };
-}
-export async function watchdogHint(item, snapshot, compute) {
-    if (!item || item.kind !== 'topic')
-        return null;
-    const finished = await evaluateWhen(item.finishWhen, snapshot, compute);
-    if (!finished.done)
-        return null;
-    return 'This section is complete. Wrap up naturally and advance.';
-}
-export function transferWrites(item, result) {
-    return {
-        [item.resultField]: result,
-        'session.last_transfer_result': result,
-    };
-}
-//# sourceMappingURL=drive.js.map

package/dist/core/stage/finish-when.d.ts

@@ -1,20 +0,0 @@
-import type { FuncMap } from '../functions/types.js';
-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 ConditionEval } from './condition.js';
-import type { AuthoringWhen, CompiledWhen, When } from './types.js';
-export declare function compileWhen(raw: When, functions?: FuncMap): CompiledWhen;
-export declare function compileAuthoringWhen(raw: AuthoringWhen, functions?: FuncMap): CompiledWhen;
-export declare function andCompiledWhen(a: CompiledWhen, b: CompiledWhen): CompiledWhen;
-export declare function notAnyWhen(items: CompiledWhen[]): CompiledWhen;
-export declare function whenFields(when: CompiledWhen): FieldPath[];
-export type WhenEval = ConditionEval & {
-    done: boolean;
-};
-export declare function evaluateWhen(when: CompiledWhen, snapshot: RuntimeSlotsSnapshot, compute?: ComputeHost): Promise<WhenEval>;
-export declare const compileFinishWhen: typeof compileWhen;
-export declare const evaluateFinishWhen: typeof evaluateWhen;
-export declare const finishWhenFields: typeof whenFields;
-export type FinishWhenEval = WhenEval;
-//# sourceMappingURL=finish-when.d.ts.map

package/dist/core/stage/finish-when.js

@@ -1,82 +0,0 @@
-import { resolveFuncName } from '../functions/func-ref.js';
-import { collectJsonRulesFacts, evaluateJsonRules, isOtherwise, looksLikeJsonRules, normalizeJsonRules, parseJsonRules, } from './condition.js';
-function isDefinedFunc(value) {
-    return (value != null &&
-        typeof value === 'object' &&
-        'kind' in value &&
-        'main' in value &&
-        (value.kind === 'compute' || value.kind === 'boolCompute' || value.kind === 'custom' || value.kind === 'system'));
-}
-export function compileWhen(raw, functions) {
-    if (raw == null)
-        return { kind: 'always' };
-    if (typeof raw === 'string') {
-        if (looksLikeJsonRules(raw)) {
-            return { kind: 'rules', condition: parseJsonRules(raw) };
-        }
-        if (!raw)
-            throw new Error('When function name must be a non-empty string');
-        return { kind: 'fn', fn: raw };
-    }
-    if (isDefinedFunc(raw)) {
-        return { kind: 'fn', fn: resolveFuncName(raw, functions) };
-    }
-    return { kind: 'rules', condition: normalizeJsonRules(raw) };
-}
-export function compileAuthoringWhen(raw, functions) {
-    if (isOtherwise(raw)) {
-        const items = (raw.notAny ?? []).map((item) => compileWhen(item, functions));
-        return notAnyWhen(items);
-    }
-    return compileWhen(raw, functions);
-}
-export function andCompiledWhen(a, b) {
-    if (a.kind === 'always')
-        return b;
-    if (b.kind === 'always')
-        return a;
-    if (a.kind === 'rules' && b.kind === 'rules') {
-        return { kind: 'rules', condition: { all: [a.condition, b.condition] } };
-    }
-    throw new Error('Cannot combine boolFunction with another when; use json-rules all/any/not');
-}
-export function notAnyWhen(items) {
-    if (items.length === 0)
-        return { kind: 'always' };
-    if (!items.every((item) => item.kind === 'rules')) {
-        throw new Error('otherwise() siblings must be json-rules; use json-rules any/not');
-    }
-    return {
-        kind: 'rules',
-        condition: { not: { any: items.map((item) => item.condition) } },
-    };
-}
-export function whenFields(when) {
-    if (when.kind !== 'rules')
-        return [];
-    return collectJsonRulesFacts(when.condition);
-}
-export async function evaluateWhen(when, snapshot, compute) {
-    if (when.kind === 'always')
-        return { done: true, pass: true, failedFields: [] };
-    if (when.kind === 'rules') {
-        const caseContext = compute ? await compute.execute('caseContextView', [snapshot]) : snapshot;
-        const result = await evaluateJsonRules(when.condition, caseContext);
-        return { ...result, done: result.pass };
-    }
-    if (when.kind === 'fn') {
-        if (!compute)
-            throw new Error(`when fn '${when.fn}' requires a ComputeHost`);
-        const raw = await compute.execute(when.fn, [snapshot]);
-        if (typeof raw !== 'boolean') {
-            throw new Error(`when fn '${when.fn}' must return boolean, got ${typeof raw}`);
-        }
-        return { done: raw, pass: raw, failedFields: [] };
-    }
-    const _exhaustive = when;
-    return _exhaustive;
-}
-export const compileFinishWhen = compileWhen;
-export const evaluateFinishWhen = evaluateWhen;
-export const finishWhenFields = whenFields;
-//# sourceMappingURL=finish-when.js.map

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

@@ -1,27 +0,0 @@
-import type { FuncMap } from '../functions/types.js';
-import type { ValidationIssue } from '../slot/types.js';
-import type { AgendaBlock, AgendaTree, AuthoringNode, CompiledAgendaBlock, FlatAgendaItem, SequenceAgendas, Placement } from './types.js';
-export type FlattenOptions = {
-    functions?: FuncMap;
-};
-export type FlattenResult = {
-    items: FlatAgendaItem[];
-    blocks: Record<string, CompiledAgendaBlock>;
-    issues: ValidationIssue[];
-};
-/** Extract reusable blocks from an inline agenda tree. */
-export declare function extractBlocksFromTree(tree: AuthoringNode[], blocks?: Record<string, AgendaBlock>): Record<string, AgendaBlock>;
-export declare function flattenAgendaTree(tree: AuthoringNode[], options?: FlattenOptions): FlattenResult;
-export declare function flattenAgendaPlacements(placements: Placement[], blocks: Record<string, AgendaBlock>, options?: FlattenOptions): FlattenResult;
-export declare function flattenAgendaConfig(config: {
-    placements?: Placement[];
-    tree?: AuthoringNode[];
-}, blocks: Record<string, AgendaBlock>, options?: FlattenOptions): FlattenResult;
-export declare function treeToPlacements(tree: AuthoringNode[]): {
-    blocks: Record<string, AgendaBlock>;
-    placements: Placement[];
-};
-export declare function isAgendaTree(value: unknown): value is AgendaTree;
-export declare function isSequenceAgendas(value: unknown): value is SequenceAgendas;
-export declare function normalizeSequenceAgendas(value: unknown): SequenceAgendas;
-//# sourceMappingURL=flatten.d.ts.map