@superpanel-sdk/runtime 0.5.0 → 0.7.0

package/dist/voice-service/types.d.ts

@@ -299,10 +299,7 @@ export interface FishTTSConfig {
 export interface AssistantConfig {
     minNumberOfWordsToInterrupt: number;
     interruptProtectionMs: number;
-    endSpeakTimeoutMs: number;
-    sttProvider: STTProvider;
     ttsProvider: TTSProvider;
-    goodbyePatterns: string[];
     defaultTransferingMessage: string;
     defaultTransferFailedMessage: string;
     shuttingDownMessage: string;
@@ -502,6 +499,11 @@ export interface IncomingOutgoingCall extends AppAction {
      * `cartesia`, …). The AI cannot take the call: it goes to the fallback number.
      */
     unavailableServices?: string[];
+    /**
+     * Outbound: the id of the `Call` the Backend wrote before it asked for the dial (`make-call`'s `callId`),
+     * sent back as it came: the Backend finds the call by it (74 §3.1).
+     */
+    callId?: string;
 }
 export interface ChatWebsocketStartMessage extends IncomingOutgoingCall {
     voiceServiceUrl: string;
@@ -524,8 +526,8 @@ export type ApplicationConfig = {
     reason?: CallFailedReason;
     cfg: VoiceAssistantConfig;
     /**
-     * The number this call is taken as, when it is not the one it came in on (a SIP call routed by its URI,
-     * domain or header): the voice service shows it as the caller ID when it transfers.
+     * A call that came in on no number of ours (a call to one of our SIP addresses): the number the voice
+     * service shows as the caller ID when it transfers (the SIP address's caller-ID number).
      */
     serviceNumber?: string;
 };
@@ -662,6 +664,10 @@ export interface TransferEvt extends AppAction {
     interruptSay: boolean;
     requestor: Requestor;
     warmBriefingPrompt: string;
+    /** Warm and background: the page's whisper, looped to the person before they confirm (76 §2.9). */
+    whisper?: string;
+    /** The language of the person taking the call (BCP-47; English when absent): what they hear, and how they are heard (48 §10.3). */
+    agentLanguage?: string;
     transferType?: TransferType;
     warmTransferConfirmMode?: WarmTransferConfirmMethod[];
     warmTransferConfirmKeypad?: DtmfDigit;
@@ -676,6 +682,8 @@ export interface MakeCallRequest extends MakeCallOptions {
     type: 'make-call';
     fromNumber: string;
     toNumber: string;
+    /** The Backend's `Call` for this dial; the voice service sends it back on `onOutbound` (74 §3.1). */
+    callId?: string;
     options: MakeCallOptions;
 }
 export interface GlobalInterruptibleRequest extends AppAction {
@@ -709,7 +717,9 @@ export interface ReloadAppConfigResponse extends AppAction {
 export interface VoiceServiceResponse {
     success: boolean;
     callSid?: string;
-    failedReason?: 'max-outbound-calls-reached' | 'service-unavailable' | 'twilio-api-error' | 'voice-service-internal-error' | 'on-outbound-request-error' | 'network-error' | 'fetch-twilio-config-error';
+    failedReason?: 'max-outbound-calls-reached' | 'service-unavailable' | 'twilio-api-error' | 'voice-service-internal-error' | 'on-outbound-request-error' | 'network-error'
+    /** The voice service answered with an HTTP error status (`statusCode`): set by the Backend's client. */
+     | 'http-error' | 'fetch-twilio-config-error';
     message?: string;
     errorCode?: number;
     statusCode?: number;

package/dist/worker.d.ts

@@ -5,6 +5,7 @@
  * the Worker carries only this.
  */
 export * from './fn-context/index.js';
-export { isWorkerFunctionKind, type WorkerFunctionKind } from './core/functions/types.js';
 export { parseComputeInvocation, type FunctionInvocation } from './compute-host/compute-host.js';
+export { ORCHESTRATOR_FUNCTION } from './core/case-orchestrator/types.js';
+export { functionScriptFile } from './builder/types.js';
 //# sourceMappingURL=worker.d.ts.map

package/dist/worker.js

@@ -5,6 +5,7 @@
  * the Worker carries only this.
  */
 export * from './fn-context/index.js';
-export { isWorkerFunctionKind } from './core/functions/types.js';
 export { parseComputeInvocation } from './compute-host/compute-host.js';
+export { ORCHESTRATOR_FUNCTION } from './core/case-orchestrator/types.js';
+export { functionScriptFile } from './builder/types.js';
 //# sourceMappingURL=worker.js.map

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@superpanel-sdk/runtime",
-  "version": "0.5.0",
-  "description": "Slot + page runtime: schema, writes, derived recompute, page compile + todos",
+  "version": "0.7.0",
+  "description": "Slot + page runtime: schema, writes, page compile",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {
     "node": ">=22.15"
   },
   "bin": {
-    "superpanel-sdk-runtime": "bin/superpanel-sdk-runtime.mjs"
+    "superpanel-sdk-runtime": "./bin/superpanel-sdk-runtime.mjs"
   },
   "exports": {
     ".": {
@@ -16,6 +16,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js",
+      "default": "./dist/testing.js"
+    },
     "./platform": {
       "superpanel-platform": {
         "types": "./dist/platform.d.ts",
@@ -46,29 +51,28 @@
     "dist/**/*.d.ts"
   ],
   "publishConfig": {
-    "access": "public",
-    "tag": "latest"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tests/tsconfig.json --noEmit",
-    "test": "tsx --tsconfig tests/tsconfig.json --test tests/**/*.test.ts",
-    "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
-    "prepublishOnly": "rm -rf dist tsconfig.tsbuildinfo && tsc -p tsconfig.json"
+    "access": "public"
   },
   "dependencies": {
     "@clack/prompts": "^1.8.1",
-    "@trpc/client": "^11.7.2",
-    "@trpc/server": "^11.7.2",
+    "@trpc/client": "11.18.0",
+    "@trpc/server": "11.18.0",
     "chokidar": "^4.0.3",
     "commander": "^15.0.0",
     "cron-parser": "5.10.0",
     "esbuild": "^0.25.12",
+    "quickjs-emscripten": "^0.32.0",
     "tsx": "^4.23.1",
     "typescript": "7.0.2",
-    "zod": "^4.4.3"
+    "zod": "4.4.3"
   },
   "devDependencies": {
     "@types/node": "^26.1.1"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tests/tsconfig.json --noEmit",
+    "test": "tsx --tsconfig tests/tsconfig.json --test tests/**/*.test.ts",
+    "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput"
   }
-}
+}

package/dist/core/case-orchestrator/follow-ups.d.ts

@@ -1,31 +0,0 @@
-import { type CaseOrchestratorParams, type CaseOrchestratorTools, type ReadExchangeResult } from './types.js';
-type ConversationReadContext = {
-    params: Pick<CaseOrchestratorParams, 'triggers'>;
-    api: {
-        tools: Pick<CaseOrchestratorTools, 'readExchange'>;
-    };
-};
-/**
- * The conversations that started this Run (a connected call, an SMS or email turn), read with
- * `readExchange`: a whole call, the last {@link THREAD_MESSAGES_SHOWN} messages of a thread.
- * A read that fails is left out.
- */
-declare function readTriggeringConversations(ctx: ConversationReadContext): Promise<ReadExchangeResult[]>;
-/**
- * One customer's follow-up block, in their local time: `New conversations:` (only when this
- * customer has one: a whole call, the last messages of a thread), `Pending scheduled actions:` and
- * `Finished agreed follow-ups (last N days):`.
- */
-declare function customerSection(params: Pick<CaseOrchestratorParams, 'activity' | 'scheduledActions' | 'recentAgreedActions'>, contactId: string, conversations: readonly ReadExchangeResult[]): string;
-/**
- * The rules after the company's own: applying day-N rules and keeping agreed follow-ups, every Run;
- * booking agreed follow-ups too when the Run read a conversation.
- */
-declare function rules(conversations: readonly ReadExchangeResult[]): string;
-export declare const followUps: {
-    readTriggeringConversations: typeof readTriggeringConversations;
-    customerSection: typeof customerSection;
-    rules: typeof rules;
-};
-export {};
-//# sourceMappingURL=follow-ups.d.ts.map

package/dist/core/case-orchestrator/follow-ups.js

@@ -1,103 +0,0 @@
-// Bundled into company code as is (part of the company API, `src/index.ts`), so it imports render and types only.
-import { render } from './render.js';
-import { RECENT_AGREED_ACTIONS_DAYS, } from './types.js';
-/**
- * Follow-ups in a company prompt, in the mars next-step format (docs/design/08-case-orchestrator.md
- * §5.3, docs/design/09-agreed-follow-up.md): how to apply day-N rules on this platform, read what
- * was just said, each customer's follow-ups, and the rules for booking and keeping agreed ones. The
- * rules name what the platform computes and writes (`Today is [day N]` from
- * `render.activitySummary`, the headings and marks here, the schedule tools), so use them together.
- */
-/** SMS and email threads are long: the last messages are enough to see what was just agreed. */
-const THREAD_MESSAGES_SHOWN = 10;
-/** Regular follow-ups: applying the company's day-N rules with the schedule tools. */
-const DAY_RULES = `How to apply the rules (day N is the Nth day since the first interaction with that customer):
-- Find each customer's current day ("Today is [day N]") and apply that day's rule. Rules for past days no longer apply.
-- The next follow-up is what we do if the customer stops responding from now on. Every customer always has their next follow-up scheduled; if a pending one still fits the rules, leave it.
-- If today's rule is already done or needs nothing, look ahead to the first later day whose rule needs doing.
-- Give at, the exact time it runs: the time a rule names (e.g. 5 minutes after a call), or for a day rule a time that day inside the hours the company's rules allow and the customer's own hours if shown. It runs then; nothing moves it.
-- Use only an available channel.
-- If no later rule needs doing, schedule nothing.`;
-const AGREED_RULES = `Agreed follow-ups:
-- Pending actions marked [agreed …] were promised. Keep them. Change or cancel one only if the customer changed or withdrew it, and give the reason.
-- Do not schedule a regular follow-up before an agreed one on the same day.
-- If an agreed follow-up failed or was not answered, continue with the day rules.`;
-const BOOKING_RULES = `Booking agreed follow-ups:
-- "New conversations" shows what was just said. If the customer asked us to call, text or email them at a time, or agreed to a time we offered, book it as an agreed follow-up: the schedule tool with agreedInExchangeId, agreedAt (the time of the customer's message saying it, copied from its [time], with the customer's offset), customerQuote (their exact words) and note. Give at, the exact time it runs; for a vague one ("tomorrow afternoon"), pick a time inside what they said and inside the hours the company's rules allow. Resolve relative times ("in 10 minutes", "tomorrow") from the time the customer said it.
-- Do not book: our own promise the customer did not answer, the customer saying they will contact us, a request for a specific person to call, or a request on behalf of someone else.
-- Check the pending and the finished agreed follow-ups first ([agreed in <exchangeId> at <time>] names the message), so a promise already booked or done is not booked again.
-- One agreed follow-up per channel at a time; put any further agreed time in its note.
-- If the customer said they will do something by a time (e.g. send documents by Friday), schedule the next regular follow-up after that time instead of the day rule.`;
-/**
- * One exchange, paging back with `before` until it has `wanted` entries or reaches the
- * start: the newest page has callKey `conversation:<id>`, each earlier one
- * `conversation:<id>:before:<n>`. `null` when the first read fails; a later failed page stops
- * there and `range.from` stays above 0.
- */
-async function readConversation(ctx, exchangeId, wanted) {
-    const first = await ctx.api.tools.readExchange({ exchangeId }, { callKey: `conversation:${exchangeId}` });
-    if (!first.ok)
-        return null;
-    let read = first.value;
-    while (read.range.from > 0 && read.entries.length < wanted) {
-        const before = read.range.from;
-        const page = await ctx.api.tools.readExchange({ exchangeId, before }, { callKey: `conversation:${exchangeId}:before:${before}` });
-        if (!page.ok || page.value.range.to !== before || page.value.range.from >= before)
-            break;
-        read = {
-            ...read,
-            range: { from: page.value.range.from, to: read.range.to },
-            entries: [...page.value.entries, ...read.entries],
-        };
-    }
-    return read;
-}
-/**
- * The conversations that started this Run (a connected call, an SMS or email turn), read with
- * `readExchange`: a whole call, the last {@link THREAD_MESSAGES_SHOWN} messages of a thread.
- * A read that fails is left out.
- */
-async function readTriggeringConversations(ctx) {
-    const read = [];
-    const seen = new Set();
-    for (const trigger of ctx.params.triggers) {
-        const conversation = (trigger.type === 'call.ended' && trigger.result === 'connected') ||
-            trigger.type === 'sms.turn-ended' ||
-            trigger.type === 'email.turn-ended';
-        if (!conversation || seen.has(trigger.exchangeId))
-            continue;
-        seen.add(trigger.exchangeId);
-        const wanted = trigger.type === 'call.ended' ? Number.POSITIVE_INFINITY : THREAD_MESSAGES_SHOWN;
-        const result = await readConversation(ctx, trigger.exchangeId, wanted);
-        if (result)
-            read.push(result);
-    }
-    return read;
-}
-/**
- * One customer's follow-up block, in their local time: `New conversations:` (only when this
- * customer has one: a whole call, the last messages of a thread), `Pending scheduled actions:` and
- * `Finished agreed follow-ups (last N days):`.
- */
-function customerSection(params, contactId, conversations) {
-    const timezone = params.activity.byContact[contactId]?.timezone ?? params.activity.timezone;
-    const said = conversations
-        .filter((conversation) => conversation.contactId === contactId)
-        .map((conversation) => render.conversation(conversation, timezone, conversation.channel === 'call' ? {} : { limit: THREAD_MESSAGES_SHOWN }));
-    const pending = params.scheduledActions.filter((action) => action.contactId === contactId);
-    const finished = params.recentAgreedActions.filter((action) => action.contactId === contactId);
-    return [
-        ...(said.length > 0 ? [`New conversations:\n${said.join('\n\n')}`] : []),
-        `Pending scheduled actions:\n${render.pendingActions(pending, timezone)}`,
-        `Finished agreed follow-ups (last ${RECENT_AGREED_ACTIONS_DAYS} days):\n${render.recentAgreedActions(finished, timezone)}`,
-    ].join('\n\n');
-}
-/**
- * The rules after the company's own: applying day-N rules and keeping agreed follow-ups, every Run;
- * booking agreed follow-ups too when the Run read a conversation.
- */
-function rules(conversations) {
-    return [DAY_RULES, AGREED_RULES, ...(conversations.length > 0 ? [BOOKING_RULES] : [])].join('\n\n');
-}
-export const followUps = { readTriggeringConversations, customerSection, rules };
-//# sourceMappingURL=follow-ups.js.map

package/dist/core/case-orchestrator/tools.d.ts

@@ -1,29 +0,0 @@
-import type { ToolRef } from './types.js';
-/**
- * References to the platform tools an AgentRequest may open. The platform
- * owns each tool's description, parameters and executor; a reference only names it.
- */
-export declare const tools: {
-    /** Read what was said in one call (plus its result and duration), SMS conversation or email thread. */
-    readonly readExchange: () => ToolRef<"readExchange">;
-    /** Find exchanges by time, contact, channel, direction, result or scheduled action; calls carry their duration. */
-    readonly searchExchanges: () => ToolRef<"searchExchanges">;
-    /** Write slot fields; multi-row tables (contact included) need a `rowId`. */
-    readonly updateSlots: () => ToolRef<"updateSlots">;
-    readonly scheduleCall: () => ToolRef<"scheduleCall">;
-    readonly scheduleSms: () => ToolRef<"scheduleSms">;
-    readonly scheduleEmail: () => ToolRef<"scheduleEmail">;
-    /** Write slot fields at a set time, as given then (cancel or reschedule it when it no longer fits). */
-    readonly scheduleUpdateSlots: () => ToolRef<"scheduleUpdateSlots">;
-    /** Move a pending action to a new time; same contact and channel. */
-    readonly rescheduleAction: () => ToolRef<"rescheduleAction">;
-    readonly cancelScheduledAction: () => ToolRef<"cancelScheduledAction">;
-    /** Hand the instance over to another sequence, on the same row or a named one, now or at a set time. */
-    readonly scheduleNextSequence: () => ToolRef<"scheduleNextSequence">;
-    /** End the instance: its pending actions are cancelled and no Run follows. */
-    readonly closeInstance: () => ToolRef<"closeInstance">;
-    /** Wake this Orchestrator up at a set time (a `timer` trigger); one pending per name, booking it again moves it. */
-    readonly scheduleWake: () => ToolRef<"scheduleWake">;
-    readonly cancelWake: () => ToolRef<"cancelWake">;
-};
-//# sourceMappingURL=tools.d.ts.map

package/dist/core/case-orchestrator/tools.js

@@ -1,31 +0,0 @@
-function ref(name) {
-    return () => ({ kind: 'tool', name });
-}
-/**
- * References to the platform tools an AgentRequest may open. The platform
- * owns each tool's description, parameters and executor; a reference only names it.
- */
-export const tools = {
-    /** Read what was said in one call (plus its result and duration), SMS conversation or email thread. */
-    readExchange: ref('readExchange'),
-    /** Find exchanges by time, contact, channel, direction, result or scheduled action; calls carry their duration. */
-    searchExchanges: ref('searchExchanges'),
-    /** Write slot fields; multi-row tables (contact included) need a `rowId`. */
-    updateSlots: ref('updateSlots'),
-    scheduleCall: ref('scheduleCall'),
-    scheduleSms: ref('scheduleSms'),
-    scheduleEmail: ref('scheduleEmail'),
-    /** Write slot fields at a set time, as given then (cancel or reschedule it when it no longer fits). */
-    scheduleUpdateSlots: ref('scheduleUpdateSlots'),
-    /** Move a pending action to a new time; same contact and channel. */
-    rescheduleAction: ref('rescheduleAction'),
-    cancelScheduledAction: ref('cancelScheduledAction'),
-    /** Hand the instance over to another sequence, on the same row or a named one, now or at a set time. */
-    scheduleNextSequence: ref('scheduleNextSequence'),
-    /** End the instance: its pending actions are cancelled and no Run follows. */
-    closeInstance: ref('closeInstance'),
-    /** Wake this Orchestrator up at a set time (a `timer` trigger); one pending per name, booking it again moves it. */
-    scheduleWake: ref('scheduleWake'),
-    cancelWake: ref('cancelWake'),
-};
-//# sourceMappingURL=tools.js.map

package/dist/core/case-orchestrator/validate.d.ts

@@ -1,11 +0,0 @@
-import { type FinalOrchestrationResult, type ResolvedAgentRequest } from './types.js';
-/** A valid result, with an AgentRequest's `tools` resolved (every platform tool when left out). */
-export type CaseOrchestratorResultCheck = {
-    ok: true;
-    value: ResolvedAgentRequest | FinalOrchestrationResult;
-} | {
-    ok: false;
-    issues: string[];
-};
-export declare function validateCaseOrchestratorResult(raw: unknown): CaseOrchestratorResultCheck;
-//# sourceMappingURL=validate.d.ts.map

package/dist/core/case-orchestrator/validate.js

@@ -1,63 +0,0 @@
-import { CASE_ORCHESTRATOR_TOOL_NAMES, } from './types.js';
-const TOOL_NAMES = new Set(CASE_ORCHESTRATOR_TOOL_NAMES);
-const ALL_TOOLS = CASE_ORCHESTRATOR_TOOL_NAMES.map((name) => ({ kind: 'tool', name }));
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function isToolRef(value) {
-    return isRecord(value) && value.kind === 'tool' && typeof value.name === 'string' && TOOL_NAMES.has(value.name);
-}
-function validateTools(raw, issues) {
-    if (raw === undefined)
-        return ALL_TOOLS;
-    if (!Array.isArray(raw)) {
-        issues.push('tools must be an array of tools.*() references (leave it out for every tool, [] for none)');
-        return [];
-    }
-    const seen = new Set();
-    const tools = [];
-    raw.forEach((tool, index) => {
-        if (!isToolRef(tool)) {
-            issues.push(`tools[${index}] is not a registered tool reference`);
-            return;
-        }
-        if (seen.has(tool.name))
-            issues.push(`tools[${index}] repeats '${tool.name}'`);
-        else {
-            seen.add(tool.name);
-            tools.push(tool);
-        }
-    });
-    return tools;
-}
-function validateAgent(raw) {
-    const issues = [];
-    const prompt = typeof raw.prompt === 'string' ? raw.prompt.trim() : '';
-    if (!prompt)
-        issues.push('prompt must be a non-empty string');
-    const tools = validateTools(raw.tools, issues);
-    return issues.length > 0 ? { ok: false, issues } : { ok: true, value: { kind: 'agent', prompt, tools } };
-}
-function validateFinal(raw) {
-    const issues = [];
-    const finalSummary = typeof raw.finalSummary === 'string' ? raw.finalSummary.trim() : '';
-    if (finalSummary.length < 1 || finalSummary.length > 1000) {
-        issues.push('finalSummary must contain 1-1000 characters');
-    }
-    return issues.length > 0
-        ? { ok: false, issues }
-        : {
-            ok: true,
-            value: { kind: 'final', finalSummary },
-        };
-}
-export function validateCaseOrchestratorResult(raw) {
-    if (!isRecord(raw))
-        return { ok: false, issues: ['orchestrator must return an object'] };
-    if (raw.kind === 'agent')
-        return validateAgent(raw);
-    if (raw.kind === 'final')
-        return validateFinal(raw);
-    return { ok: false, issues: ["orchestrator result.kind must be 'agent' or 'final'"] };
-}
-//# sourceMappingURL=validate.js.map

package/dist/core/functions/define/bind.d.ts

@@ -1,25 +0,0 @@
-import type { CaseInput } from '../../case-orchestrator/types.js';
-import type { PageTablesDesc } from '../../page/typed.js';
-import type { EventHandlers } from '../events.js';
-import type { CaseFn, DefinedCaseFunc, DefinedNoCaseFunc, FuncOptions, NoCaseFn } from '../types.js';
-/**
- * The define helpers bound to one sequence: functions' and event handlers' `c` to its case (`C`: the
- * instance and its business root's id), `ctx.api.db` to its `PageTables` (`D`).
- */
-export type BoundDefines<D extends PageTablesDesc | undefined = undefined, C = CaseInput> = {
-    defineCaseFunc: {
-        /** A function that writes with `ctx.api.db` and returns nothing. */
-        <P extends object = object>(main: CaseFn<C, P, void, D>, options?: FuncOptions): DefinedCaseFunc<C, P, void, D>;
-        /** Any other return type, spelled out: `defineCaseFunc<object, string>(…)` (`R` is never inferred). */
-        <P extends object = object, R = never>(main: CaseFn<C, P, NoInfer<R>, D>, options?: FuncOptions): DefinedCaseFunc<C, P, R, D>;
-    };
-    /** Nocase function: no `c`; reads and writes with `ctx.api.db`. */
-    defineNoCaseFunc: <P extends object = object, R = unknown>(main: NoCaseFn<P, R, D>, options?: FuncOptions) => DefinedNoCaseFunc<P, R, D>;
-    defineEvents: (handlers: EventHandlers<C, D>) => EventHandlers<C, D>;
-};
-/**
- * Bind the define helpers to a sequence. `type:gen` emits `__gen/index.ts` calling this, so company
- * code never spells the types: `defineCaseFunc(async (c, ctx) => …)`.
- */
-export declare function bindDefines<D extends PageTablesDesc | undefined = undefined, C = CaseInput>(): BoundDefines<D, C>;
-//# sourceMappingURL=bind.d.ts.map

package/dist/core/functions/define/bind.js

@@ -1,14 +0,0 @@
-import { defineCaseFunc } from './case.js';
-import { defineNoCaseFunc } from './no-case.js';
-/**
- * Bind the define helpers to a sequence. `type:gen` emits `__gen/index.ts` calling this, so company
- * code never spells the types: `defineCaseFunc(async (c, ctx) => …)`.
- */
-export function bindDefines() {
-    return {
-        defineCaseFunc: defineCaseFunc,
-        defineNoCaseFunc: defineNoCaseFunc,
-        defineEvents: (handlers) => handlers,
-    };
-}
-//# sourceMappingURL=bind.js.map

package/dist/core/functions/define/case.d.ts

@@ -1,9 +0,0 @@
-import type { CaseFn, DefinedCaseFunc, FuncOptions } from '../types.js';
-import type { CaseInput } from '../../case-orchestrator/types.js';
-/**
- * Worker function bound to a case: `(c, ctx) => R`, `c` the instance and its business root's id.
- * `R` defaults to `void` (a function that writes with `ctx.api.db`); other callers
- * pass their own. Company code normally uses the bound version from `__gen/index.ts` so `S` is never spelled.
- */
-export declare function defineCaseFunc<S = CaseInput, P extends object = object, R = void>(main: CaseFn<S, P, R>, options?: FuncOptions): DefinedCaseFunc<S, P, R>;
-//# sourceMappingURL=case.d.ts.map

package/dist/core/functions/define/case.js

@@ -1,13 +0,0 @@
-/**
- * Worker function bound to a case: `(c, ctx) => R`, `c` the instance and its business root's id.
- * `R` defaults to `void` (a function that writes with `ctx.api.db`); other callers
- * pass their own. Company code normally uses the bound version from `__gen/index.ts` so `S` is never spelled.
- */
-export function defineCaseFunc(main, options) {
-    return {
-        kind: 'case',
-        main,
-        ...options,
-    };
-}
-//# sourceMappingURL=case.js.map

package/dist/core/functions/define/events.d.ts

@@ -1,20 +0,0 @@
-import type { CaseInput } from '../../case-orchestrator/types.js';
-import type { PageTablesDesc } from '../../page/typed.js';
-import type { EventHandlers, WebhookHandler } from '../events.js';
-/**
- * Author-side helper for the `events` export. The parameter type is fully known,
- * so handler arguments are contextually typed and unknown event names are
- * rejected as excess properties.
- *
- * ```ts
- * export const events = defineEvents({
- *   'call.ended': async (c, ctx) => {
- *     await ctx.api.db.matter.update({ where: { id: c.subject }, data: { last_call: ctx.params.event.outcome } });
- *   },
- * });
- * ```
- */
-export declare function defineEvents<C = CaseInput, D extends PageTablesDesc | undefined = undefined>(handlers: EventHandlers<C, D>): EventHandlers<C, D>;
-/** Author-side helper for `webhook.ts`'s `received`: types `ctx.params.event` and the return. */
-export declare function defineWebhook<D extends PageTablesDesc | undefined = undefined>(handler: WebhookHandler<D>): WebhookHandler<D>;
-//# sourceMappingURL=events.d.ts.map

package/dist/core/functions/define/events.js

@@ -1,21 +0,0 @@
-/**
- * Author-side helper for the `events` export. The parameter type is fully known,
- * so handler arguments are contextually typed and unknown event names are
- * rejected as excess properties.
- *
- * ```ts
- * export const events = defineEvents({
- *   'call.ended': async (c, ctx) => {
- *     await ctx.api.db.matter.update({ where: { id: c.subject }, data: { last_call: ctx.params.event.outcome } });
- *   },
- * });
- * ```
- */
-export function defineEvents(handlers) {
-    return handlers;
-}
-/** Author-side helper for `webhook.ts`'s `received`: types `ctx.params.event` and the return. */
-export function defineWebhook(handler) {
-    return handler;
-}
-//# sourceMappingURL=events.js.map

package/dist/core/functions/define/no-case.d.ts

@@ -1,4 +0,0 @@
-import type { DefinedNoCaseFunc, FuncOptions, NoCaseFn } from '../types.js';
-/** Worker function not bound to a case: `(ctx) => R`. No case (`c`) is passed. */
-export declare function defineNoCaseFunc<P extends object = object, R = unknown>(main: NoCaseFn<P, R>, options?: FuncOptions): DefinedNoCaseFunc<P, R>;
-//# sourceMappingURL=no-case.d.ts.map

package/dist/core/functions/define/no-case.js

@@ -1,9 +0,0 @@
-/** Worker function not bound to a case: `(ctx) => R`. No case (`c`) is passed. */
-export function defineNoCaseFunc(main, options) {
-    return {
-        kind: 'noCase',
-        main,
-        ...options,
-    };
-}
-//# sourceMappingURL=no-case.js.map

package/dist/core/functions/func-ref.d.ts

@@ -1,25 +0,0 @@
-import type { DefinedFunc, FuncMap, FunctionKind } from './types.js';
-/**
- * Author-time function reference:
- * - string key: `'computeIsQualified'`
- * - map value: `functions.computeIsQualified` ({@link DefinedFunc})
- *
- * Compiled / runtime schemas always store the string name.
- */
-export type FuncRef = string | DefinedFunc;
-/**
- * Structural stand-in for narrowed refs such as `DefinedCaseFunc<never, …>`: a function whose
- * `caseContext` is typed `never` is not assignable to `DefinedFunc<any>` (any → never fails),
- * but identity lookup only needs the object.
- */
-export type FuncRefLike = FuncRef | {
-    kind: FunctionKind;
-    main: unknown;
-};
-/**
- * Normalize a {@link FuncRef} to the functions-map key.
- * Object refs need the same `functions` map for identity lookup
- * (plain map values do not carry `name`).
- */
-export declare function resolveFuncName(ref: FuncRefLike, functions?: FuncMap): string;
-//# sourceMappingURL=func-ref.d.ts.map

package/dist/core/functions/func-ref.js

@@ -1,20 +0,0 @@
-/**
- * Normalize a {@link FuncRef} to the functions-map key.
- * Object refs need the same `functions` map for identity lookup
- * (plain map values do not carry `name`).
- */
-export function resolveFuncName(ref, functions) {
-    if (typeof ref === 'string') {
-        if (!ref)
-            throw new Error('Function reference name must be a non-empty string');
-        return ref;
-    }
-    if (functions) {
-        for (const [key, value] of Object.entries(functions)) {
-            if (value === ref)
-                return key;
-        }
-    }
-    throw new Error('Invalid function reference; expected a string name or a value from the functions map');
-}
-//# sourceMappingURL=func-ref.js.map