@superpanel-sdk/runtime 0.2.3 → 0.7.0

package/dist/cli/turns/index.d.ts

@@ -0,0 +1,105 @@
+import type { PageChannel } from '../../core/page/define.js';
+export type TurnSummary = {
+    id: string;
+    seq: number;
+    runId: string;
+    callId: string | null;
+    instanceId: string;
+    /** customer | assistant | silence | wrap_up | run */
+    kind: string;
+    channel: string;
+    heard: string | null;
+    said: string[];
+    /** The model's thought at each step: what it heard, what it does, what comes next. */
+    thoughts: string[];
+    actions: Array<{
+        key: string;
+        name: string;
+        kind: string;
+        status: string;
+        args: unknown;
+        result: unknown;
+        error: string | null;
+    }>;
+    writes: Array<{
+        rowId: string;
+        table: string;
+        field: string;
+        value: unknown;
+        state: string | null;
+    }>;
+    outcome: string | null;
+    error: string | null;
+    startedAt: string;
+    endedAt: string | null;
+    /** Whether its snapshot is still kept (30 days). */
+    snapshot: boolean;
+};
+export type TurnRecord = TurnSummary & {
+    format: 1;
+    sequence: string;
+    steps: Array<{
+        thought: string | null;
+        say: string;
+        actions: unknown[];
+        outcomes: Array<{
+            action: string;
+            status: string;
+            detail?: string;
+        }>;
+    }>;
+    platformRules: string;
+};
+export type TurnSnapshot = {
+    pages: Array<{
+        seq: number;
+        step: number;
+        auto: boolean;
+        text: string;
+    }>;
+    data: Record<string, Array<Record<string, unknown>>>;
+    context: Record<string, unknown> | null;
+    history: unknown;
+    start: unknown;
+};
+export type TurnRead = {
+    turn: TurnRecord;
+    snapshot: TurnSnapshot | null;
+};
+export type TurnsQuery = {
+    instanceId?: string;
+    runId?: string;
+    callId?: string;
+    since?: string;
+    limit?: number;
+};
+/** POST to an exec route with the run token; the backend's error as the message. */
+export declare function postExec<T>(backendUrl: string, runToken: string, what: string, body: unknown): Promise<T>;
+/** The turn's directory: `turn.json`, `page/<n>.txt`, `data.json`, `context.json`, `history.json`, `start.json`. */
+export declare function writeTurnExport(dir: string, read: TurnRead): string;
+/** A turn's directory read back. Its snapshot is null when it was exported after the snapshot was dropped. */
+export declare function readTurnExport(dir: string): TurnRead;
+/** One line: where it is in the run, who spoke, what was said, what it did. */
+export declare function formatTurnLine(turn: TurnSummary): string;
+/** The channel of a page a turn's context names. */
+export declare function channelOf(turn: TurnRecord): PageChannel;
+type TurnsOptions = {
+    env?: string;
+    instance?: string;
+    call?: string;
+    run?: string;
+    since?: string;
+    limit?: number;
+    json?: boolean;
+    url?: string;
+};
+/** `turns`: the turns, one line each (or one JSON each with `--json`). */
+export declare function runTurns(repoRoot: string, options: TurnsOptions): Promise<void>;
+/** `turns export <turnId>`: the turn written to `.superpanel/turns/<turnId>/`; prints the directory. */
+export declare function runTurnExport(repoRoot: string, turnId: string, options: {
+    env?: string;
+    url?: string;
+    out?: string;
+}): Promise<void>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/turns/index.js

@@ -0,0 +1,128 @@
+/**
+ * `turns`: the turns of a case, a run or a call in a non-prod environment (68 §7.4), one line each, and
+ * `turns export <turnId>`: one turn written to `.superpanel/turns/<turnId>/` (its record and snapshot),
+ * which `fromTurn` reads back for `renderPage`. The same files an integration test's `exportTurn` writes.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { loadCachedServeAuthorization, resolveBackendUrl } from '../auth/auth.js';
+import { apiUrl, requestJson } from '../auth/http.js';
+import { requestExecRun } from '../exec/session.js';
+import { timeOf } from '../logs/index.js';
+/** POST to an exec route with the run token; the backend's error as the message. */
+export async function postExec(backendUrl, runToken, what, body) {
+    const { response, payload } = await requestJson(apiUrl(backendUrl, `cli-auth/exec/${what}`), {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${runToken}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok)
+        throw new Error(`${what}: ${payload.error ?? `the backend answered ${response.status}`}`);
+    return payload;
+}
+/** The turn's directory: `turn.json`, `page/<n>.txt`, `data.json`, `context.json`, `history.json`, `start.json`. */
+export function writeTurnExport(dir, read) {
+    mkdirSync(dir, { recursive: true });
+    const json = (name, value) => writeFileSync(path.join(dir, name), `${JSON.stringify(value, null, 2)}\n`);
+    json('turn.json', read.turn);
+    if (read.snapshot) {
+        mkdirSync(path.join(dir, 'page'), { recursive: true });
+        for (const page of read.snapshot.pages)
+            if (!page.auto)
+                writeFileSync(path.join(dir, 'page', `${page.seq}.txt`), page.text);
+        json('data.json', read.snapshot.data);
+        json('context.json', read.snapshot.context);
+        json('history.json', read.snapshot.history);
+        json('start.json', read.snapshot.start);
+    }
+    return dir;
+}
+/** A turn's directory read back. Its snapshot is null when it was exported after the snapshot was dropped. */
+export function readTurnExport(dir) {
+    const file = (name) => path.join(dir, name);
+    if (!existsSync(file('turn.json')))
+        throw new Error(`${dir}: no turn.json (export a turn with \`turns export <turnId>\`)`);
+    const turn = JSON.parse(readFileSync(file('turn.json'), 'utf8'));
+    if (turn.format !== 1)
+        throw new Error(`${dir}: turn.json format ${String(turn.format)}; this runtime reads format 1`);
+    if (!existsSync(file('data.json')))
+        return { turn, snapshot: null };
+    const json = (name) => JSON.parse(readFileSync(file(name), 'utf8'));
+    const pages = existsSync(file('page'))
+        ? readdirSync(file('page'))
+            .filter((name) => /^\d+\.txt$/.test(name))
+            .map((name) => ({ seq: Number(name.slice(0, -4)), step: 0, auto: false, text: readFileSync(path.join(file('page'), name), 'utf8') }))
+            .sort((a, b) => a.seq - b.seq)
+        : [];
+    return {
+        turn,
+        snapshot: {
+            pages,
+            data: json('data.json'),
+            context: json('context.json'),
+            history: json('history.json'),
+            start: json('start.json'),
+        },
+    };
+}
+const clip = (text, max = 80) => {
+    const one = (text ?? '').replace(/\s+/g, ' ').trim();
+    return one.length > max ? `${one.slice(0, max - 1)}…` : one;
+};
+/** One line: where it is in the run, who spoke, what was said, what it did. */
+export function formatTurnLine(turn) {
+    const parts = [`#${turn.seq} ${turn.kind}`, turn.id];
+    if (turn.heard)
+        parts.push(`heard "${clip(turn.heard)}"`);
+    if (turn.said.length)
+        parts.push(`said "${clip(turn.said.join(' '))}"`);
+    if (turn.actions.length)
+        parts.push(`did ${turn.actions.map((a) => `${a.key}:${a.status}`).join(', ')}`);
+    if (turn.writes.length)
+        parts.push(`wrote ${turn.writes.map((w) => `${w.table}.${w.field}`).join(', ')}`);
+    if (turn.outcome && turn.outcome !== 'done')
+        parts.push(turn.outcome);
+    if (turn.error)
+        parts.push(`error: ${clip(turn.error)}`);
+    return parts.join('  ');
+}
+/** The channel of a page a turn's context names. */
+export function channelOf(turn) {
+    return turn.channel === 'call' || turn.channel === 'sms' || turn.channel === 'email' ? turn.channel : 'call';
+}
+async function execToken(repoRoot, options) {
+    const backendUrl = resolveBackendUrl(repoRoot, options.url);
+    const authorization = await loadCachedServeAuthorization(backendUrl);
+    if (!authorization)
+        throw new Error('not logged in: run `superpanel-sdk-runtime login` first');
+    const run = await requestExecRun(backendUrl, authorization.token, options.env ?? 'sandbox', undefined);
+    return { backendUrl, runToken: run.runToken };
+}
+/** `turns`: the turns, one line each (or one JSON each with `--json`). */
+export async function runTurns(repoRoot, options) {
+    if (!options.instance && !options.call && !options.run)
+        throw new Error('turns: name the case (--instance), the call (--call) or the run (--run)');
+    const { backendUrl, runToken } = await execToken(repoRoot, options);
+    const since = timeOf(options.since);
+    const { turns } = await postExec(backendUrl, runToken, 'turns', {
+        ...(options.instance ? { instanceId: options.instance } : {}),
+        ...(options.call ? { callId: options.call } : {}),
+        ...(options.run ? { runId: options.run } : {}),
+        ...(since ? { since } : {}),
+        ...(options.limit ? { limit: options.limit } : {}),
+    });
+    if (!turns.length)
+        console.error('no turns');
+    for (const turn of turns)
+        console.log(options.json ? JSON.stringify(turn) : formatTurnLine(turn));
+}
+/** `turns export <turnId>`: the turn written to `.superpanel/turns/<turnId>/`; prints the directory. */
+export async function runTurnExport(repoRoot, turnId, options) {
+    const { backendUrl, runToken } = await execToken(repoRoot, options);
+    const read = await postExec(backendUrl, runToken, 'turns/read', { turnId });
+    const dir = writeTurnExport(path.resolve(repoRoot, options.out ?? path.join('.superpanel', 'turns', turnId)), read);
+    if (!read.snapshot)
+        console.error(`turn ${turnId}: its snapshot is no longer kept (30 days); only turn.json was written`);
+    console.log(dir);
+}
+//# sourceMappingURL=index.js.map

package/dist/cli/turns/run.d.ts

@@ -0,0 +1,13 @@
+export type TurnCliOptions = {
+    env?: string;
+    url?: string;
+    from?: string;
+    instance?: string;
+    channel?: 'sms' | 'email' | 'call';
+    say?: string;
+    caller?: string;
+    repeat?: number;
+    json?: boolean;
+};
+export declare function runTurnCli(repoRoot: string, options: TurnCliOptions): Promise<void>;
+//# sourceMappingURL=run.d.ts.map

package/dist/cli/turns/run.js

@@ -0,0 +1,57 @@
+/**
+ * `superpanel-sdk-runtime turn` (68 §8.1): one turn as a shadow, from the command line — on a case now, or
+ * from a turn that ran (its id or its exported directory), with this repository's code serving the
+ * environment while it runs. Each run's words, buttons, writes and functions, one block per run.
+ */
+import { connect } from '../../testing.js';
+function describe(run, n) {
+    const lines = [`── run ${n}`];
+    for (const thought of run.turns.flatMap((t) => t.thoughts ?? []))
+        lines.push(`  (thought) ${thought}`);
+    for (const said of run.said)
+        lines.push(`AI: ${said}`);
+    if (run.outcome && run.outcome.kind !== 'reply')
+        lines.push(`ended: ${run.outcome.kind}${'reason' in run.outcome ? ` (${run.outcome.reason})` : ''}`);
+    for (const action of run.actions)
+        lines.push(`  ${action.name}: ${action.status}${action.error ? ` (${action.error})` : ''}`);
+    for (const write of run.writes)
+        lines.push(`  wrote ${write.table}.${write.field} = ${JSON.stringify(write.value)}${write.state && write.state !== 'filled' ? ` (${write.state})` : ''}`);
+    for (const event of run.events)
+        lines.push(`  on the line: ${JSON.stringify(event)}`);
+    for (const call of run.functions)
+        lines.push(`  function ${call.name}: ${call.how}${call.error ? ` (${call.error})` : ''}`);
+    for (const warning of run.warnings)
+        lines.push(`  ! ${warning}`);
+    return lines.join('\n');
+}
+export async function runTurnCli(repoRoot, options) {
+    if (!options.from && !options.instance)
+        throw new Error('turn: --from <turnId|dir>, or --instance <case id> with --say');
+    const sandbox = await connect({ env: options.env ?? 'sandbox', repoRoot, ...(options.url ? { url: options.url } : {}) });
+    let result;
+    try {
+        result = await sandbox.turn({
+            ...(options.from ? { from: options.from } : {}),
+            ...(options.instance ? { instanceId: options.instance } : {}),
+            ...(options.channel ? { channel: options.channel } : {}),
+            ...(options.say ? { say: options.say } : {}),
+            ...(options.caller ? { caller: options.caller } : {}),
+            ...(options.repeat ? { repeat: options.repeat } : {}),
+        });
+    }
+    finally {
+        await sandbox.close();
+    }
+    if (options.json) {
+        for (const run of result.runs)
+            console.log(JSON.stringify(run));
+    }
+    else {
+        if (result.from)
+            console.log(`from turn ${result.from.turnId} (${result.from.kind})${result.from.heard ? `: "${result.from.heard}"` : ''}`);
+        result.runs.forEach((run, i) => console.log(describe(run, i + 1)));
+        console.log('(a shadow: nothing was kept, sent or booked)');
+    }
+    process.exit(0);
+}
+//# sourceMappingURL=run.js.map

package/dist/cli/turns/shadow.d.ts

@@ -0,0 +1,112 @@
+import type { TextCallEvent } from '../calls/index.js';
+import type { TurnSummary } from './index.js';
+export type TurnInput = {
+    /** The case; left out with `from` (the turn's). */
+    instanceId?: string;
+    channel?: 'sms' | 'email' | 'call';
+    /** What the customer writes or says; with `from`, in place of what they said then. */
+    say?: string;
+    /** The conversation's contact; the case's subject when it is a contact and none is named. */
+    caller?: string;
+    /** The conversation so far, by hand, oldest first; the case's real one when left out. */
+    history?: Array<{
+        customer?: string;
+        ai?: string;
+    }>;
+    /** Start where a turn started: its id, or the directory it was exported to (relative to the repository). */
+    from?: string;
+    /** Run it this many times (1–10), each from the same start: the model answers differently each time. */
+    repeat?: number;
+    /** Results for the company's functions the turn presses, by name; a recorded call (`from`) is replayed first. */
+    functions?: {
+        results?: Record<string, unknown>;
+    };
+};
+/** One run of the turn. */
+export type ShadowRun = {
+    runId: string | null;
+    /** A text or email run: how it ended (`reply` with its `text`, not sent). A call's turn: null. */
+    outcome: {
+        kind: 'reply';
+        text: string;
+        email?: {
+            subject?: string;
+            cc?: string[];
+        };
+        steps: number;
+    } | {
+        kind: 'noReply' | 'handoff' | 'abnormal';
+        reason: string;
+        steps: number;
+    } | null;
+    /** What the AI said, or would have sent. */
+    said: string[];
+    /** `act`: what the platform told the model after running the actions. */
+    stepResult?: string;
+    actions: Array<{
+        name: string;
+        kind: string;
+        args: unknown;
+        status: string;
+        error: string | null;
+        result: unknown;
+    }>;
+    /** Each field it wrote: its row, table and field, the value and state it took, and what it was. */
+    writes: Array<{
+        rowId: string;
+        table: string;
+        field: string;
+        value: unknown;
+        state: string | null;
+        from: {
+            value: unknown;
+            state: string | null;
+        };
+        reason: string | null;
+    }>;
+    /** A call: what it did on the line (a keypad, a transfer, a voicemail). */
+    events: TextCallEvent[];
+    /** A call the AI ended in this turn. */
+    ended: boolean;
+    turns: TurnSummary[];
+    /** Each company function the turn pressed: `replayed` (as it ran then), `given` (yours), `unrecorded` (not run), `skipped` (an event handler). */
+    functions: Array<{
+        name: string;
+        args: unknown;
+        how: 'replayed' | 'given' | 'unrecorded' | 'skipped';
+        result?: unknown;
+        error?: string;
+    }>;
+    /** What it would have done outside the database (a text, an email, an Orchestrator run): none of it happened. */
+    held: string[];
+    /** Where it could not start exactly as asked (a row gone since). */
+    warnings: string[];
+    /** Whether it pressed the button with this run key (or name). */
+    clicked(key: string): boolean;
+    /** Whether it wrote `table.field` (to `value`, when given). */
+    wrote(field: string, value?: unknown): boolean;
+};
+/** What a `turn` or an `act` did: its first run's, and every run with `repeat`. */
+export type RunResult = ShadowRun & {
+    runs: ShadowRun[];
+    /** The turn it started from. */
+    from: {
+        turnId: string;
+        kind: string;
+        heard: string | null;
+    } | null;
+    /** The share of runs `check` holds for, 0–1. */
+    rate(check: (run: ShadowRun) => boolean): number;
+};
+type Post = <T>(what: string, body: unknown) => Promise<T>;
+/** `from` as the backend takes it: a turn id as it is, a directory's files read. */
+export declare function fromOf(repoRoot: string, from: string): string | {
+    turn: unknown;
+    history: unknown;
+    data: unknown;
+};
+export declare function shadowTurn(post: Post, repoRoot: string, what: 'turn' | 'act', input: TurnInput & {
+    actions?: unknown[];
+}): Promise<RunResult>;
+export {};
+//# sourceMappingURL=shadow.d.ts.map

package/dist/cli/turns/shadow.js

@@ -0,0 +1,54 @@
+/**
+ * A single turn, always a shadow (68 §8): `sandbox.turn` / `sandbox.act` and `superpanel-sdk-runtime turn`.
+ * The backend runs it on a shadow of the environment's database, rolled back afterwards; what it did comes
+ * back. `from` names a turn by id, or the directory `turns export` wrote it to (kept in the repository,
+ * it outlives the 30 days a turn's snapshot is kept): its files are sent as they are.
+ */
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+/** `from` as the backend takes it: a turn id as it is, a directory's files read. */
+export function fromOf(repoRoot, from) {
+    const dir = path.resolve(repoRoot, from);
+    const isDir = (() => {
+        try {
+            return statSync(dir).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    })();
+    if (!isDir) {
+        if (/[\\/]/.test(from))
+            throw new Error(`turn: from ${from}: no such directory`);
+        return from;
+    }
+    const json = (name, required) => {
+        const file = path.join(dir, name);
+        if (!existsSync(file)) {
+            if (required)
+                throw new Error(`turn: ${from} has no ${name} (export a turn with \`turns export <turnId>\`)`);
+            return null;
+        }
+        return JSON.parse(readFileSync(file, 'utf8'));
+    };
+    return { turn: json('turn.json', true), history: json('history.json', true), data: json('data.json', false) ?? {} };
+}
+function withChecks(run) {
+    return {
+        ...run,
+        clicked: (key) => run.actions.some((a) => a.status !== 'failed' && (a.name === key || run.turns.some((t) => t.actions.some((ta) => ta.key === key && ta.status !== 'failed')))),
+        wrote: (field, ...value) => run.writes.some((w) => `${w.table}.${w.field}` === field && (value.length === 0 || JSON.stringify(w.value) === JSON.stringify(value[0]))),
+    };
+}
+export async function shadowTurn(post, repoRoot, what, input) {
+    const body = { ...input, ...(input.from ? { from: fromOf(repoRoot, input.from) } : {}) };
+    const wire = await post(what, body);
+    const runs = wire.runs.map(withChecks);
+    return {
+        ...runs[0],
+        runs,
+        from: wire.from,
+        rate: (check) => (runs.length ? runs.filter(check).length / runs.length : 0),
+    };
+}
+//# sourceMappingURL=shadow.js.map

package/dist/cli/type-gen/index.js

@@ -1,11 +1,15 @@
 import path from 'node:path';
 import chokidar from 'chokidar';
-import { checkAll, generateAll, generateSequence, listSequenceIds } from '../../builder/codegen/generate.js';
-async function runOnce(repoRoot) {
-    const results = await generateAll(repoRoot);
+import { checkAll, companyGenPaths, generateAll, listSequenceIds } from '../../builder/codegen/generate.js';
+async function runOnce(repoRoot, sequenceIds) {
+    const results = await generateAll(repoRoot, { sequenceIds });
+    if (!sequenceIds) {
+        for (const outPath of Object.values(companyGenPaths(repoRoot)))
+            console.log(`wrote ${path.relative(repoRoot, outPath)}`);
+    }
     for (const result of results) {
         console.log(`wrote ${path.relative(repoRoot, result.outPath)}`);
-        console.log(`wrote ${path.relative(repoRoot, result.caseContextOutPath)}`);
+        console.log(`wrote ${path.relative(repoRoot, result.indexOutPath)}`);
     }
 }
 /** `sequences/<id>/…` → sequence id */
@@ -36,11 +40,7 @@ async function runWatch(repoRoot) {
                     await runOnce(repoRoot);
                     return;
                 }
-                for (const sequenceId of job.sequences) {
-                    const result = await generateSequence(repoRoot, sequenceId);
-                    console.log(`wrote ${path.relative(repoRoot, result.outPath)}`);
-                    console.log(`wrote ${path.relative(repoRoot, result.caseContextOutPath)}`);
-                }
+                await runOnce(repoRoot, [...job.sequences]);
             }
             catch (error) {
                 console.error('[type:gen] regenerate failed:', error instanceof Error ? error.message : error);

package/dist/compiler.d.ts

@@ -0,0 +1,7 @@
+/**
+ * What the platform's compile child loads from the runtime the company repo installed
+ * (`packages/services/src/release/compile-child.ts`). Platform-only: the package resolves
+ * `./compiler` under the `superpanel-platform` condition, and the child loads it by file path.
+ */
+export { compileRepo, type CompileRepoEvent, type CompileRepoOptions, type CompileRepoSequenceResult, } from './builder/compile/compile-sequence.js';
+//# sourceMappingURL=compiler.d.ts.map

package/dist/compiler.js

@@ -0,0 +1,7 @@
+/**
+ * What the platform's compile child loads from the runtime the company repo installed
+ * (`packages/services/src/release/compile-child.ts`). Platform-only: the package resolves
+ * `./compiler` under the `superpanel-platform` condition, and the child loads it by file path.
+ */
+export { compileRepo, } from './builder/compile/compile-sequence.js';
+//# sourceMappingURL=compiler.js.map

package/dist/compute-host/compute-host.d.ts

@@ -1,38 +1,29 @@
-import type { CaseContextViewFn } from '../core/functions/define/case-context.js';
-import type { RuntimeSlotsSnapshot } from '../core/slot/types.js';
 /**
- * Pluggable host for sequence functions (derived / finishWhen / custom / system).
+ * Pluggable host for sequence functions: every one is `(ctx, args)` (38 §2.1); the host builds `ctx`.
  *
  * - Local unit tests / company CI: {@link createLocalComputeHost} (direct JS call)
  * - Author FuncMap: `createSourceComputeHost`
  * - Platform backend: QuickJS / Cloudflare Worker hosts with the same `execute` surface
  */
 export interface ComputeHost {
-    /**
-     * Invoke a registered function by name, then dispatch on `kind`.
-     * Compute/boolCompute/custom: `args[0]` is the raw snapshot (projected internally).
-     * `caseContextView`: `args[0]` is the raw snapshot (identity when the sequence has no view).
-     */
-    execute(name: string, args?: unknown[]): Promise<unknown>;
+    /** Invoke a registered function with its type-specific invocation. */
+    execute(name: string, invocation?: ComputeInvocation): Promise<unknown>;
     /** Release host-owned resources. No-op when the host has nothing to free. */
     dispose(): void;
 }
+/** What a function is called with besides `ctx`: its `args`, one object (`{}` when left out). */
+export type FunctionInvocation = {
+    args?: object;
+};
+export type ComputeInvocation = FunctionInvocation;
+export declare function parseComputeInvocation(value: unknown): ComputeInvocation | null;
 /**
- * Name → computeFn. Parameter typed as `never` so company-narrowed
- * `ComputeFn<CaseContext>` maps remain assignable (TS contravariance).
+ * Name → plain function of `args` (local tests stand in sequence functions with these).
+ * Parameter typed as `never` so company-narrowed maps remain assignable (TS contravariance).
  */
-export type ComputeFnMap = Record<string, (slots: never) => unknown | Promise<unknown>>;
+export type ComputeFnMap = Record<string, (args: never) => unknown | Promise<unknown>>;
 export type ComputeHostOrFns = ComputeHost | ComputeFnMap;
-export type LocalComputeHostOptions = {
-    /**
-     * Optional `(slots) => CaseContext` projector. Registered under the view.ts
-     * export name `caseContextView` and invoked before each compute fn
-     * (no cross-call cache — snapshot may change mid-recompute).
-     */
-    caseContextView?: CaseContextViewFn<RuntimeSlotsSnapshot, unknown>;
-};
-/** In-process host: call plain JS computeFns. No VM, no I/O fence. */
-export declare function createLocalComputeHost(fns: ComputeFnMap, options?: LocalComputeHostOptions): ComputeHost;
+export declare function createLocalComputeHost(fns: ComputeFnMap): ComputeHost;
 /** Accept either a host or a name→fn map (map is wrapped as local host). */
-export declare function resolveComputeHost(hostOrFns: ComputeHostOrFns, options?: LocalComputeHostOptions): ComputeHost;
+export declare function resolveComputeHost(hostOrFns: ComputeHostOrFns): ComputeHost;
 //# sourceMappingURL=compute-host.d.ts.map

package/dist/compute-host/compute-host.js

@@ -1,45 +1,33 @@
+export function parseComputeInvocation(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return null;
+    const record = value;
+    if (record.args !== undefined &&
+        (typeof record.args !== 'object' || record.args === null || Array.isArray(record.args))) {
+        return null;
+    }
+    return record.args !== undefined ? { args: record.args } : {};
+}
 function isComputeHost(value) {
     return typeof value.execute === 'function';
 }
-function requireSlots(name, args) {
-    const slots = args[0];
-    if (slots == null) {
-        throw new Error(`Function ${name}: args[0] (slots) required`);
-    }
-    return slots;
-}
-/** In-process host: call plain JS computeFns. No VM, no I/O fence. */
-export function createLocalComputeHost(fns, options = {}) {
-    if (Object.hasOwn(fns, 'caseContextView')) {
-        throw new Error(`computeFn name 'caseContextView' collides with the sequence view`);
-    }
-    const viewFn = options.caseContextView ?? ((slots) => slots);
-    const registry = {
-        caseContextView: { kind: 'caseContextView', main: viewFn },
-    };
-    for (const [name, fn] of Object.entries(fns)) {
-        registry[name] = { kind: 'compute', main: fn };
-    }
+export function createLocalComputeHost(fns) {
     return {
-        async execute(name, args = []) {
-            const def = registry[name];
-            if (!def) {
-                throw new Error(`Missing computeFn implementation: ${name}`);
-            }
-            const snapshot = requireSlots(name, args);
-            if (def.kind === 'caseContextView') {
-                return def.main(snapshot);
+        async execute(name, invocation = {}) {
+            const fn = fns[name];
+            if (!fn) {
+                throw new Error(`Missing function implementation: ${name}`);
             }
-            return def.main(viewFn(snapshot));
+            return fn((invocation.args ?? {}));
         },
         dispose() { },
     };
 }
 /** Accept either a host or a name→fn map (map is wrapped as local host). */
-export function resolveComputeHost(hostOrFns, options) {
+export function resolveComputeHost(hostOrFns) {
     if (isComputeHost(hostOrFns)) {
         return hostOrFns;
     }
-    return createLocalComputeHost(hostOrFns, options);
+    return createLocalComputeHost(hostOrFns);
 }
 //# sourceMappingURL=compute-host.js.map

package/dist/compute-host/index.d.ts

@@ -1,7 +1,5 @@
-export { createLocalComputeHost, resolveComputeHost } from './compute-host.js';
-export type { ComputeFnMap, ComputeHost, ComputeHostOrFns, LocalComputeHostOptions } from './compute-host.js';
+export { createLocalComputeHost, parseComputeInvocation, resolveComputeHost } from './compute-host.js';
+export type { ComputeFnMap, ComputeHost, ComputeHostOrFns, ComputeInvocation, FunctionInvocation, } from './compute-host.js';
 export { createSourceComputeHost } from './source-compute-host.js';
 export type { SourceComputeHost, SourceComputeHostOptions } from './source-compute-host.js';
-export { readOnlyComputeNames, withReadOnlyComputeCache } from './read-only-cache.js';
-export type { ReadOnlyComputeCacheOptions } from './read-only-cache.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/compute-host/index.js

@@ -1,4 +1,3 @@
-export { createLocalComputeHost, resolveComputeHost } from './compute-host.js';
+export { createLocalComputeHost, parseComputeInvocation, resolveComputeHost } from './compute-host.js';
 export { createSourceComputeHost } from './source-compute-host.js';
-export { readOnlyComputeNames, withReadOnlyComputeCache } from './read-only-cache.js';
 //# sourceMappingURL=index.js.map