@superpanel-sdk/runtime 0.0.1-internal.1

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

@@ -0,0 +1,177 @@
+import type { TopLevelCondition } from 'json-rules-engine';
+import type { FuncRef } from '../functions/func-ref.js';
+import type { FieldPath } from '../slot/path.js';
+export type Channel = 'call' | 'sms' | 'email' | 'webchat';
+/** Nested condition from the engine (`all` members): leaf or `TopLevelCondition`. */
+export type Condition = Extract<TopLevelCondition, {
+    all: unknown;
+}>['all'][number];
+export type JsonRulesCondition = Condition;
+/**
+ * Shared by applyWhen and finishWhen:
+ * json-rules object, JSON string, boolFunction, or null (always).
+ */
+export type When = FuncRef | Condition | Condition[] | null;
+export type ApplyWhen = When;
+export type FinishWhen = When;
+/** Compile-time sentinel for branch()/switchOn(); expanded before flatten. */
+export type OtherwiseSentinel = {
+    op: 'otherwise';
+    notAny?: When[];
+};
+export type AuthoringWhen = When | OtherwiseSentinel;
+export type CompiledWhen = {
+    kind: 'always';
+} | {
+    kind: 'fn';
+    fn: string;
+} | {
+    kind: 'rules';
+    condition: JsonRulesCondition;
+};
+export type OnNoProgress = {
+    maxTurns: number;
+    action: 'move-on' | 'handoff' | 'schedule-callback';
+};
+export type FirstMessage = {
+    kind: 'template';
+    text: string;
+} | {
+    kind: 'fn';
+    fn: string;
+};
+export type Interrupt = {
+    id: string;
+    label: string;
+    tool: {
+        name: string;
+        description: string;
+    };
+    action: {
+        type: 'transfer';
+        numbers: string[];
+        mode: 'cold' | 'warm';
+    } | {
+        type: 'switch-language';
+        languages: string[];
+    };
+    priority: number;
+};
+export type AgendaHeader = {
+    channel: Channel;
+    systemPrompt: string | null;
+    firstMessage: FirstMessage | null;
+    firstMessageMode: 'assistant-speaks-first' | 'user-speaks-first' | null;
+    voicemailPrompt: string | null;
+    interrupts: Interrupt[];
+};
+export type TopicBlock = {
+    kind: 'topic';
+    id: string;
+    label: string;
+    instructions: string;
+    fields: FieldPath[] | null;
+    finishWhen: FinishWhen;
+    onNoProgress: OnNoProgress | null;
+};
+export type ActionBlock = {
+    kind: 'action';
+    id: string;
+    label: string;
+    run: FuncRef;
+    finishWhen: FinishWhen;
+    say: string | null;
+};
+export type TransferBlock = {
+    kind: 'transfer';
+    id: string;
+    label: string;
+    numbers: string[];
+    mode: 'cold' | 'warm';
+    say: string;
+    unsuccessfulSay: string | null;
+};
+export type AgendaBlock = TopicBlock | ActionBlock | TransferBlock;
+export type CompiledTopicBlock = Omit<TopicBlock, 'fields' | 'finishWhen'> & {
+    fields: FieldPath[];
+    finishWhen: CompiledWhen;
+};
+export type CompiledActionBlock = Omit<ActionBlock, 'run' | 'finishWhen'> & {
+    run: string;
+    finishWhen: CompiledWhen;
+};
+export type CompiledTransferBlock = TransferBlock & {
+    finishWhen: CompiledWhen;
+    resultField: FieldPath;
+};
+export type CompiledAgendaBlock = CompiledTopicBlock | CompiledActionBlock | CompiledTransferBlock;
+export type SectionPlacement = {
+    kind: 'section';
+    placementId: string;
+    label: string;
+    applyWhen: AuthoringWhen;
+    children: Placement[];
+};
+export type NodePlacement = {
+    kind: 'node';
+    placementId: string;
+    blockId: string;
+    applyWhen: AuthoringWhen;
+};
+export type Placement = SectionPlacement | NodePlacement;
+export type AgendaConfig = {
+    id: string;
+    header: AgendaHeader | null;
+    placements: Placement[];
+};
+export type SequenceAgendas = {
+    blocks: Record<string, AgendaBlock>;
+    agendas: Record<string, AgendaConfig>;
+};
+export type FlatNodePlacement = {
+    placementId: string;
+    applyWhen: CompiledWhen;
+    groupPath: string[];
+};
+export type FlatTopicItem = CompiledTopicBlock & FlatNodePlacement;
+export type FlatActionItem = CompiledActionBlock & FlatNodePlacement;
+export type FlatTransferItem = CompiledTransferBlock & FlatNodePlacement;
+export type FlatAgendaItem = FlatTopicItem | FlatActionItem | FlatTransferItem;
+export type CompiledAgenda = {
+    header: AgendaHeader | null;
+    flat: FlatAgendaItem[];
+};
+export type TopicNode = TopicBlock & {
+    applyWhen: AuthoringWhen;
+};
+export type ActionNode = ActionBlock & {
+    applyWhen: AuthoringWhen;
+};
+export type TransferNode = TransferBlock & {
+    applyWhen: AuthoringWhen;
+};
+export type SectionNode = {
+    kind: 'section';
+    id: string;
+    label: string;
+    applyWhen: AuthoringWhen;
+    children: AuthoringNode[];
+};
+export type BranchNode = {
+    kind: 'branch';
+    children: AuthoringNode[];
+};
+export type SwitchOnNode = {
+    kind: 'switchOn';
+    field: FieldPath;
+    cases: Record<string, AuthoringNode[]>;
+    otherwise?: AuthoringNode[];
+};
+export type AuthoringNode = TopicNode | ActionNode | TransferNode | SectionNode | BranchNode | SwitchOnNode;
+export type AgendaTree = {
+    kind: 'agenda';
+    id: string;
+    header: AgendaHeader | null;
+    tree: AuthoringNode[];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/core/stage/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,11 @@
+import type { FuncMap } from '../functions/types.js';
+import type { CompiledSlotSchema, ValidationIssue, ValidationResult } from '../slot/types.js';
+import type { CompiledAgenda } from './types.js';
+export type ValidateAgendaOptions = {
+    schema: CompiledSlotSchema;
+    functions?: FuncMap;
+    agendaId?: string;
+};
+export declare function validateCompiledAgenda(compiled: CompiledAgenda, options: ValidateAgendaOptions): ValidationResult;
+export declare function fatalAgendaIssues(issues: ValidationIssue[]): ValidationIssue[];
+//# sourceMappingURL=validate.d.ts.map

package/dist/core/stage/validate.js

@@ -0,0 +1,226 @@
+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 { LAST_TRANSFER_RESULT_FIELD } from './transfer-fields.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);
+        }
+    }
+    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);
+    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 (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 (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 === '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`);
+            }
+            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',
+    'transfer-result-before-node',
+    'action-run-not-custom',
+    'duplicate-placement',
+    'block-kind-mismatch',
+]);
+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

@@ -0,0 +1,34 @@
+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 WalkResult = {
+    hit: FlatAgendaItem | null;
+    reason: WalkHitReason | 'complete';
+    skipped: WalkSkip[];
+    decisions: WalkDecision[];
+};
+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

@@ -0,0 +1,96 @@
+import { evaluateWhen } from './finish-when.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) {
+    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';
+    }
+    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';
+    }
+    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) {
+    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)) === 'hit') {
+            return item;
+        }
+    }
+    return null;
+}
+export async function walkAgenda(items, snapshot, options = {}) {
+    const skip = options.skipPlacementIds ?? new Set();
+    const skipped = [];
+    const decisions = [];
+    const considered = new Set();
+    const currentId = options.currentPlacementId ?? null;
+    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);
+                if (hit) {
+                    return { hit, reason: 'sticky', skipped, decisions };
+                }
+            }
+        }
+    }
+    const hit = await firstHit(items, snapshot, options.compute, skip, 'scan', skipped, decisions, considered);
+    if (hit)
+        return { hit, reason: 'scan', skipped, decisions };
+    return { hit: null, reason: 'complete', skipped, decisions };
+}
+export async function unresolvedFinishWhenFields(item, snapshot, compute) {
+    return (await evaluateWhen(item.finishWhen, snapshot, compute)).failedFields;
+}
+//# sourceMappingURL=walk.js.map

package/dist/dev-overlay/protocol.d.ts

@@ -0,0 +1,53 @@
+import type { ActionDataSlice } from '../fn-context/types.js';
+import type { SequenceBuild } from '../builder/types.js';
+export type OverlayAuthMessage = {
+    type: 'auth';
+    apiKey: string;
+    companyId: string;
+    names?: string[];
+};
+export type OverlayAuthOkMessage = {
+    type: 'auth.ok';
+};
+export type OverlayAuthErrorMessage = {
+    type: 'auth.error';
+    error: string;
+};
+export type OverlayReplacedMessage = {
+    type: 'replaced';
+};
+export declare const OVERLAY_REPLACED_CLOSE_CODE = 4000;
+export type OverlayPushMessage = {
+    type: 'overlay';
+    sequenceId: string;
+    generation: number;
+    build: SequenceBuild;
+};
+export type OverlayExecuteMessage = {
+    type: 'execute';
+    requestId: string;
+    sequenceId: string;
+    name: string;
+    args?: unknown[];
+    data?: ActionDataSlice;
+    runToken?: string;
+    /** Logger request id for `ctx.api` RPC; not the overlay execute correlation id. */
+    logRequestId?: string;
+};
+export type OverlayExecuteResultMessage = {
+    type: 'execute.result';
+    requestId: string;
+    ok: true;
+    result: unknown;
+} | {
+    type: 'execute.result';
+    requestId: string;
+    ok: false;
+    error: string;
+};
+export type OverlayClientMessage = OverlayAuthMessage | OverlayPushMessage | OverlayExecuteResultMessage;
+export type OverlayServerMessage = OverlayAuthOkMessage | OverlayAuthErrorMessage | OverlayReplacedMessage | OverlayExecuteMessage;
+export type OverlayMessage = OverlayClientMessage | OverlayServerMessage;
+export declare function encodeOverlayMessage(message: OverlayMessage): string;
+export declare function parseOverlayMessage(raw: string): OverlayMessage;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/dev-overlay/protocol.js

@@ -0,0 +1,21 @@
+export const OVERLAY_REPLACED_CLOSE_CODE = 4000;
+function isRecord(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+export function encodeOverlayMessage(message) {
+    return JSON.stringify(message);
+}
+export function parseOverlayMessage(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error('overlay message is not JSON');
+    }
+    if (!isRecord(parsed) || typeof parsed.type !== 'string') {
+        throw new Error('overlay message missing type');
+    }
+    return parsed;
+}
+//# sourceMappingURL=protocol.js.map

package/dist/fn-context/build-context.d.ts

@@ -0,0 +1,11 @@
+import type { ActionContext, ActionDataSlice, ApiHost, RunScope } from './types.js';
+export type BuildActionContextOptions = {
+    /** Defaults from `data.meta` when omitted. */
+    run?: Partial<RunScope>;
+};
+/**
+ * Assemble ActionContext = JSON data slice + api from ApiHost.
+ * Shared by local unit, remote-fc, and (later) Worker-side invoke.
+ */
+export declare function buildActionContext(data: ActionDataSlice, host: ApiHost, options?: BuildActionContextOptions): Promise<ActionContext>;
+//# sourceMappingURL=build-context.d.ts.map

package/dist/fn-context/build-context.js

@@ -0,0 +1,21 @@
+import { bindLogMeta } from './log.js';
+/**
+ * Assemble ActionContext = JSON data slice + api from ApiHost.
+ * Shared by local unit, remote-fc, and (later) Worker-side invoke.
+ */
+export async function buildActionContext(data, host, options = {}) {
+    const run = {
+        companyId: options.run?.companyId ?? data.meta.companyId,
+        environmentId: options.run?.environmentId ?? data.meta.environmentId,
+        sequenceId: options.run?.sequenceId ?? data.meta.sequenceId,
+        entry: options.run?.entry ?? data.meta.entry,
+    };
+    const api = await host.buildApi(run);
+    return {
+        time: data.time,
+        meta: data.meta,
+        config: data.config,
+        api: { ...api, log: bindLogMeta(api.log, data.meta) },
+    };
+}
+//# sourceMappingURL=build-context.js.map

package/dist/fn-context/fake/empty-api.d.ts

@@ -0,0 +1,9 @@
+import { type PlatformApis, type PlatformSurfaceKey } from '../../core/context/platform-registry.js';
+import type { IntegrationApi } from '../../core/context/types.js';
+export declare const emptyIntegration: () => IntegrationApi;
+export type PlatformApiOverrides = Partial<{
+    [K in PlatformSurfaceKey]: Partial<PlatformApis[K]>;
+}>;
+/** Each registered surface backed by its mock, with per-method overrides applied on top. */
+export declare const defaultPlatformApis: (overrides?: PlatformApiOverrides) => PlatformApis;
+//# sourceMappingURL=empty-api.d.ts.map