@superpanel-sdk/runtime 0.2.2 → 0.5.0

package/dist/core/slot/platform-session-fields.js

@@ -1,48 +0,0 @@
-import { idField } from './schema.js';
-export const PLATFORM_SESSION_FIELDS = {
-    is_inbound_call: {
-        derived: false,
-        label: 'Inbound call',
-        dataType: 'boolean',
-        source: 'system',
-        extraction: 'Set by the conversation entry pipeline',
-        enum: null,
-        nullable: false,
-        identifier: null,
-        ref: null,
-    },
-    is_first_call: {
-        derived: false,
-        label: 'First call',
-        dataType: 'boolean',
-        source: 'system',
-        extraction: 'No prior session for this case contact',
-        enum: null,
-        nullable: false,
-        identifier: null,
-        ref: null,
-    },
-    is_new_user: {
-        derived: false,
-        label: 'New user',
-        dataType: 'boolean',
-        source: 'system',
-        extraction: 'No existing contact for this party',
-        enum: null,
-        nullable: false,
-        identifier: null,
-        ref: null,
-    },
-};
-export function createPlatformSessionTable() {
-    return {
-        label: 'Session',
-        rows: 'single',
-        description: 'Per-conversation session fields',
-        fields: {
-            id: { ...idField, ref: null },
-            ...PLATFORM_SESSION_FIELDS,
-        },
-    };
-}
-//# sourceMappingURL=platform-session-fields.js.map

package/dist/core/slot/sf-schema.d.ts

@@ -1,23 +0,0 @@
-import type { FieldPath } from './path.js';
-import type { CompiledSlotSchema } from './types.js';
-type JsonSchema = Record<string, unknown>;
-export type SfSchemaOptions = {
-    /**
-     * Field paths included with full definitions.
-     * When omitted, all conversation fields are included (full-schema / hangup pass).
-     */
-    focusFields?: Iterable<FieldPath>;
-};
-/**
- * Build JSON Schema for Slot Filling structured output.
- * Derived and `source: system` fields are never included.
- */
-export declare function buildSlotFillingJsonSchema(schema: CompiledSlotSchema, options?: SfSchemaOptions): JsonSchema;
-/** Compact catalog for out-of-focus conversation fields (C1). */
-export declare function buildFieldCatalog(schema: CompiledSlotSchema, exclude?: Iterable<FieldPath>): Array<{
-    path: FieldPath;
-    label: string;
-    extraction: string;
-}>;
-export {};
-//# sourceMappingURL=sf-schema.d.ts.map

package/dist/core/slot/sf-schema.js

@@ -1,125 +0,0 @@
-import { compiledTableEntries, isSnapshotSingleRow } from './compile-schema.js';
-import { formatFieldPath, parseFieldPath } from './path.js';
-function dataTypeToJsonSchema(dataType, enumValues, nullable) {
-    let base;
-    if (enumValues && enumValues.length > 0) {
-        base = { enum: [...enumValues] };
-    }
-    else {
-        switch (dataType) {
-            case 'string':
-            case 'date':
-            case 'datetime':
-                base = { type: 'string' };
-                break;
-            case 'number':
-                base = { type: 'number' };
-                break;
-            case 'boolean':
-                base = { type: 'boolean' };
-                break;
-        }
-    }
-    if (nullable) {
-        if (base.enum) {
-            return { enum: [...base.enum, null] };
-        }
-        return { type: [base.type, 'null'] };
-    }
-    return base;
-}
-function extractedFieldSchema(field) {
-    return {
-        type: 'object',
-        additionalProperties: false,
-        required: ['reason', 'value', 'state'],
-        properties: {
-            reason: { type: 'string', minLength: 1 },
-            value: dataTypeToJsonSchema(field.dataType, field.enum, true),
-            state: { type: 'string', enum: ['filled', 'asked_unknown', 'declined'] },
-        },
-    };
-}
-/**
- * Build JSON Schema for Slot Filling structured output.
- * Derived and `source: system` fields are never included.
- */
-export function buildSlotFillingJsonSchema(schema, options = {}) {
-    const focus = options.focusFields
-        ? new Set([...options.focusFields].map((p) => {
-            const parsed = parseFieldPath(p);
-            if (!parsed)
-                throw new Error(`Invalid focus field: ${p}`);
-            return parsed.path;
-        }))
-        : null;
-    const tableSchemas = {};
-    for (const [tableName, table] of compiledTableEntries(schema)) {
-        const fieldProps = {};
-        for (const [fieldName, field] of Object.entries(table.fields)) {
-            if (field.derived)
-                continue;
-            if (field.source !== 'conversation')
-                continue;
-            const path = formatFieldPath(tableName, fieldName);
-            if (focus && !focus.has(path))
-                continue;
-            fieldProps[fieldName] = extractedFieldSchema(field);
-        }
-        if (Object.keys(fieldProps).length === 0)
-            continue;
-        if (isSnapshotSingleRow(table)) {
-            tableSchemas[tableName] = {
-                type: 'object',
-                additionalProperties: false,
-                properties: fieldProps,
-            };
-        }
-        else {
-            tableSchemas[tableName] = {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    additionalProperties: false,
-                    required: ['rowKey', 'fields'],
-                    properties: {
-                        rowKey: { type: 'string', minLength: 1 },
-                        fields: {
-                            type: 'object',
-                            additionalProperties: false,
-                            properties: fieldProps,
-                        },
-                    },
-                },
-            };
-        }
-    }
-    return {
-        type: 'object',
-        additionalProperties: false,
-        properties: tableSchemas,
-    };
-}
-/** Compact catalog for out-of-focus conversation fields (C1). */
-export function buildFieldCatalog(schema, exclude = []) {
-    const excluded = new Set([...exclude].map((p) => parseFieldPath(p)?.path).filter(Boolean));
-    const catalog = [];
-    for (const [tableName, table] of compiledTableEntries(schema)) {
-        for (const [fieldName, field] of Object.entries(table.fields)) {
-            if (field.derived)
-                continue;
-            if (field.source !== 'conversation')
-                continue;
-            const path = formatFieldPath(tableName, fieldName);
-            if (excluded.has(path))
-                continue;
-            catalog.push({
-                path,
-                label: field.label,
-                extraction: field.extraction,
-            });
-        }
-    }
-    return catalog;
-}
-//# sourceMappingURL=sf-schema.js.map

package/dist/core/slot/sf-validate.d.ts

@@ -1,14 +0,0 @@
-import type { CompiledSlotSchema, SlotFillingValidateResult } from './types.js';
-export type ValidateSlotFillingOptions = {
-    /** Conversation version carried by the SF task. */
-    taskVersion: number;
-    /** Current conversation version; mismatch → whole pack discarded. */
-    currentVersion: number;
-};
-/**
- * C3 gates for Slot Filling output: version gate, type/enum, write protection.
- * Derived / system fields in the payload are dropped (write protection).
- * Type/enum failures are rejected per-field; valid fields stay accepted.
- */
-export declare function validateSlotFillingOutput(schema: CompiledSlotSchema, raw: unknown, options: ValidateSlotFillingOptions): SlotFillingValidateResult;
-//# sourceMappingURL=sf-validate.d.ts.map

package/dist/core/slot/sf-validate.js

@@ -1,132 +0,0 @@
-import { getCompiledTable, isSnapshotSingleRow } from './compile-schema.js';
-import { formatFieldPath } from './path.js';
-import { isReservedTableName } from './row.js';
-import { validateExtractedField } from './value.js';
-function isExtractedField(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    const v = value;
-    return (typeof v.reason === 'string' &&
-        'value' in v &&
-        (v.state === 'filled' || v.state === 'asked_unknown' || v.state === 'declined'));
-}
-/**
- * C3 gates for Slot Filling output: version gate, type/enum, write protection.
- * Derived / system fields in the payload are dropped (write protection).
- * Type/enum failures are rejected per-field; valid fields stay accepted.
- */
-export function validateSlotFillingOutput(schema, raw, options) {
-    if (options.taskVersion !== options.currentVersion) {
-        return {
-            ok: false,
-            reason: 'stale-version',
-            issues: [
-                {
-                    code: 'stale-version',
-                    message: `SF version ${options.taskVersion} != current ${options.currentVersion}`,
-                },
-            ],
-        };
-    }
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        return {
-            ok: false,
-            reason: 'invalid-shape',
-            issues: [
-                {
-                    code: 'invalid-shape',
-                    message: 'SlotFillingOutput must be an object of table projections',
-                },
-            ],
-        };
-    }
-    const accepted = {};
-    const rejected = [];
-    const shapeIssues = [];
-    for (const [tableName, projection] of Object.entries(raw)) {
-        if (isReservedTableName(tableName))
-            continue;
-        const table = getCompiledTable(schema, tableName);
-        if (!table) {
-            continue;
-        }
-        if (isSnapshotSingleRow(table)) {
-            if (!projection || typeof projection !== 'object' || Array.isArray(projection)) {
-                shapeIssues.push({
-                    code: 'invalid-projection',
-                    message: `single-row table ${tableName} expects an object projection`,
-                    path: tableName,
-                });
-                continue;
-            }
-            const outFields = {};
-            for (const [fieldName, extracted] of Object.entries(projection)) {
-                const path = formatFieldPath(tableName, fieldName);
-                const field = table.fields[fieldName];
-                if (!field || field.derived || field.source !== 'conversation') {
-                    continue; // write protection: drop
-                }
-                if (!isExtractedField(extracted)) {
-                    rejected.push(path);
-                    continue;
-                }
-                const issues = validateExtractedField(field, extracted, path);
-                if (issues.length > 0) {
-                    rejected.push(path);
-                    continue;
-                }
-                outFields[fieldName] = extracted;
-            }
-            if (Object.keys(outFields).length > 0) {
-                accepted[tableName] = outFields;
-            }
-        }
-        else {
-            if (!Array.isArray(projection)) {
-                shapeIssues.push({
-                    code: 'invalid-projection',
-                    message: `multi-row table ${tableName} expects an array projection`,
-                    path: tableName,
-                });
-                continue;
-            }
-            const outRows = [];
-            for (const row of projection) {
-                if (!row || typeof row !== 'object' || typeof row.rowKey !== 'string') {
-                    shapeIssues.push({
-                        code: 'invalid-row',
-                        message: `multi-row table ${tableName} row missing rowKey`,
-                        path: tableName,
-                    });
-                    continue;
-                }
-                const fieldsIn = row.fields ?? {};
-                const outFields = {};
-                for (const [fieldName, extracted] of Object.entries(fieldsIn)) {
-                    const path = formatFieldPath(tableName, fieldName);
-                    const field = table.fields[fieldName];
-                    if (!field || field.derived || field.source !== 'conversation') {
-                        continue;
-                    }
-                    if (!isExtractedField(extracted)) {
-                        rejected.push(path);
-                        continue;
-                    }
-                    const issues = validateExtractedField(field, extracted, path);
-                    if (issues.length > 0) {
-                        rejected.push(path);
-                        continue;
-                    }
-                    outFields[fieldName] = extracted;
-                }
-                outRows.push({ rowKey: row.rowKey, fields: outFields });
-            }
-            accepted[tableName] = outRows;
-        }
-    }
-    if (shapeIssues.length > 0) {
-        return { ok: false, reason: 'invalid-shape', issues: shapeIssues };
-    }
-    return { ok: true, accepted, rejected };
-}
-//# sourceMappingURL=sf-validate.js.map

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

@@ -1,18 +0,0 @@
-import type { FieldPath } from './path.js';
-import type { CompiledSlotSchema, FieldValue, RuntimeSlotsSnapshot, TableData } from './types.js';
-export type SnapshotSeed = Record<string, unknown>;
-/**
- * Build a runtime snapshot for local tests.
- *
- * - `table.field` keys seed single-row (or current-party) fields
- * - bare multi-table name keys seed row arrays:
- *   `children: [{ id?: string, name: 'Lily', age: 8 }]`
- */
-export declare function snapshotFrom(schema: CompiledSlotSchema, seed?: SnapshotSeed, options?: {
-    now?: number;
-}): RuntimeSlotsSnapshot;
-/** Deep-clone a snapshot (structuredClone when available). */
-export declare function cloneSnapshot(snapshot: RuntimeSlotsSnapshot): RuntimeSlotsSnapshot;
-export declare function getSnapshotTable(snapshot: RuntimeSlotsSnapshot, tableName: string): TableData | undefined;
-export declare function getSingleField(snapshot: RuntimeSlotsSnapshot, path: FieldPath): FieldValue | undefined;
-//# sourceMappingURL=snapshot.d.ts.map

package/dist/core/slot/snapshot.js

@@ -1,138 +0,0 @@
-import { compiledTableEntries, getCompiledTable, isSnapshotSingleRow } from './compile-schema.js';
-import { emptyFieldValue, makeFieldValue } from './field.js';
-import { parseFieldPath } from './path.js';
-import { emptySlotRow, getRowField, isReservedTableName, isRowIdField, slotFieldNames } from './row.js';
-import { validateBareValue } from './value.js';
-function seedToFieldValue(seed, now) {
-    if (seed && typeof seed === 'object' && !Array.isArray(seed) && 'state' in seed) {
-        const s = seed;
-        return makeFieldValue({
-            value: (s.value ?? null),
-            state: s.state,
-            reason: s.reason ?? null,
-            updatedBy: s.updatedBy ?? 'import',
-            updatedAt: s.updatedAt ?? now,
-            history: s.history ?? [],
-        });
-    }
-    if (seed === undefined) {
-        return emptyFieldValue(now);
-    }
-    return makeFieldValue({
-        value: seed,
-        state: 'filled',
-        reason: null,
-        updatedBy: 'import',
-        updatedAt: now,
-    });
-}
-/**
- * Build a runtime snapshot for local tests.
- *
- * - `table.field` keys seed single-row (or current-party) fields
- * - bare multi-table name keys seed row arrays:
- *   `children: [{ id?: string, name: 'Lily', age: 8 }]`
- */
-export function snapshotFrom(schema, seed = {}, options = {}) {
-    const now = options.now ?? 0;
-    const snapshot = {};
-    for (const [tableName, table] of compiledTableEntries(schema)) {
-        if (isSnapshotSingleRow(table)) {
-            snapshot[tableName] = emptySlotRow(table.fields, { now });
-        }
-        else {
-            snapshot[tableName] = [];
-        }
-    }
-    for (const [key, value] of Object.entries(seed)) {
-        const parsed = parseFieldPath(key);
-        if (parsed) {
-            const table = getCompiledTable(schema, parsed.table);
-            if (!table) {
-                throw new Error(`Unknown table in seed: ${parsed.table}`);
-            }
-            if (!isSnapshotSingleRow(table)) {
-                throw new Error(`Field path seed ${key} is only for single-row tables; seed multi rows by table name`);
-            }
-            if (isRowIdField(parsed.field)) {
-                snapshot[parsed.table].id = value == null ? '' : String(value);
-                continue;
-            }
-            const field = table.fields[parsed.field];
-            if (!field) {
-                throw new Error(`Unknown field in seed: ${key}`);
-            }
-            const fv = seedToFieldValue(value, now);
-            if (fv.state === 'filled' || fv.state === 'asked_unknown') {
-                const issues = validateBareValue(field, fv.value, key, {
-                    allowNull: field.derived || (field.derived === false && field.nullable),
-                });
-                if (issues.length > 0) {
-                    throw new Error(issues.map((i) => i.message).join('; '));
-                }
-            }
-            snapshot[parsed.table][parsed.field] = fv;
-            continue;
-        }
-        const table = getCompiledTable(schema, key);
-        if (!table) {
-            throw new Error(`Unknown seed key: ${key}`);
-        }
-        if (isSnapshotSingleRow(table)) {
-            throw new Error(`Seed key ${key} is not a multi-row table`);
-        }
-        if (!Array.isArray(value)) {
-            throw new Error(`Multi-row seed ${key} must be an array`);
-        }
-        const rows = [];
-        let i = 0;
-        for (const rowSeed of value) {
-            if (!rowSeed || typeof rowSeed !== 'object') {
-                throw new Error(`Invalid row seed in ${key}`);
-            }
-            const rowObj = rowSeed;
-            const seededId = rowObj.id ?? rowObj.rowId;
-            const id = typeof seededId === 'string' && seededId.length > 0 ? seededId : `r${++i}`;
-            const row = { id };
-            for (const fieldName of slotFieldNames(table.fields)) {
-                if (fieldName in rowObj) {
-                    row[fieldName] = seedToFieldValue(rowObj[fieldName], now);
-                }
-                else {
-                    row[fieldName] = emptyFieldValue(now);
-                }
-            }
-            rows.push(row);
-        }
-        snapshot[key] = rows;
-    }
-    return snapshot;
-}
-/** Deep-clone a snapshot (structuredClone when available). */
-export function cloneSnapshot(snapshot) {
-    return typeof structuredClone === 'function'
-        ? structuredClone(snapshot)
-        : JSON.parse(JSON.stringify(snapshot));
-}
-export function getSnapshotTable(snapshot, tableName) {
-    if (isReservedTableName(tableName))
-        return undefined;
-    const value = snapshot[tableName];
-    if (value == null)
-        return undefined;
-    if (Array.isArray(value))
-        return value;
-    if (typeof value === 'object' && 'id' in value)
-        return value;
-    return undefined;
-}
-export function getSingleField(snapshot, path) {
-    const parsed = parseFieldPath(path);
-    if (!parsed)
-        return undefined;
-    const table = getSnapshotTable(snapshot, parsed.table);
-    if (!table || Array.isArray(table))
-        return undefined;
-    return getRowField(table, parsed.field);
-}
-//# sourceMappingURL=snapshot.js.map

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

@@ -1,41 +0,0 @@
-import type { FieldState, Writes } from '../context/types.js';
-import type { FieldPath } from './path.js';
-import type { ApplyWritesOptions, ApplyWritesResult, CompiledSlotSchema, RuntimeSlotsSnapshot, SlotFillingOutput, UpdatedBy } from './types.js';
-/**
- * Apply bare Writes (function / human / import / platform) onto a snapshot.
- * Validates type/enum and write permissions. Detects C5 changes and appends history.
- */
-export declare function applyWrites(schema: CompiledSlotSchema, snapshot: RuntimeSlotsSnapshot, writes: Writes | null | undefined, options: ApplyWritesOptions): ApplyWritesResult;
-export type FieldPatchInput = {
-    path: FieldPath;
-    rowId?: string;
-    value: string | number | boolean | null;
-    state: FieldState;
-    reason?: string | null;
-};
-/**
- * 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 declare function applyFieldPatch(schema: CompiledSlotSchema, snapshot: RuntimeSlotsSnapshot, patch: FieldPatchInput, options: {
-    source: UpdatedBy;
-    now?: number;
-}): ApplyWritesResult;
-export type ApplySlotFillingOptions = {
-    now?: number;
-    /** Map SF placeholder row keys (`new-1`) → allocated row ids (mutated in place). */
-    rowKeyMap?: Map<string, string>;
-};
-/**
- * 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 declare function applySlotFilling(schema: CompiledSlotSchema, snapshot: RuntimeSlotsSnapshot, output: SlotFillingOutput, options?: ApplySlotFillingOptions): ApplyWritesResult;
-/**
- * Mark remaining conversation fields as asked_unknown (Topic move-on).
- */
-export declare function markAskedUnknown(schema: CompiledSlotSchema, snapshot: RuntimeSlotsSnapshot, fields: Iterable<FieldPath>, options?: {
-    now?: number;
-    reason?: string;
-}): ApplyWritesResult;
-//# sourceMappingURL=write.d.ts.map