@superpanel-sdk/runtime 0.2.3 → 0.7.0

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

@@ -1,10 +1,16 @@
 import type { ActionDataSlice } from '../fn-context/types.js';
-import type { SequenceBuild } from '../builder/types.js';
+import type { CompanyBuild, SourceMaps } from '../builder/types.js';
+import type { ComputeInvocation } from '../compute-host/compute-host.js';
+/**
+ * Serve takes the whole environment (22-sequence-as-business-unit §6): while a session holds it, every
+ * sequence there runs the local repository's code, and one with no local directory has none.
+ */
 export type OverlayAuthMessage = {
     type: 'auth';
-    apiKey: string;
-    companyId: string;
-    names?: string[];
+    /** Browser-issued, serve-scoped token. */
+    token: string;
+    /** Required environment id. */
+    environment?: string;
 };
 export type OverlayAuthOkMessage = {
     type: 'auth.ok';
@@ -12,29 +18,74 @@ export type OverlayAuthOkMessage = {
 export type OverlayAuthErrorMessage = {
     type: 'auth.error';
     error: string;
+    /**
+     * No default on the sending side — every send site picks one explicitly (see gateway-state.ts's
+     * `rejectAuth` and gateway-connection.ts's `failAuth`), so a future call site can't silently
+     * inherit the wrong one. The CLI (`toOverlayError` in packages/runtime/src/cli/serve/index.ts)
+     * maps each code to how it reacts.
+     * `authorization`: the serve token is invalid/expired, or a heartbeat found the user's access to
+     * the company was revoked — re-authenticate and retry.
+     * `unavailable`: a transient condition (infra hiccup, an unexpected internal error, a lease that
+     * was just replaced) — retry with backoff, no user action needed.
+     * `request`: the request itself is permanently invalid (missing or unknown environment, prod) —
+     * retrying the same request will never succeed; stop and tell the user.
+     */
+    code: 'authorization' | 'unavailable' | 'request';
 };
+/** Another serve took the environment: this session ends. */
 export type OverlayReplacedMessage = {
     type: 'replaced';
 };
 export declare const OVERLAY_REPLACED_CLOSE_CODE = 4000;
+/**
+ * Informational only: the session keeps serving. Sent e.g. when the pushed company schema is not
+ * backward compatible with this environment's or prod's live release.
+ */
+/**
+ * The push of `generation` is served: registered, so every api instance runs it from now on. Sent after
+ * each push; a client may wait for it before it calls anything that should run the pushed code.
+ */
+export type OverlayOkMessage = {
+    type: 'overlay.ok';
+    generation: number;
+};
+export type OverlayNoticeMessage = {
+    type: 'notice';
+    message: string;
+    details: string[];
+};
+/** The local company build, every sequence of the repository; each push replaces the previous one. */
 export type OverlayPushMessage = {
     type: 'overlay';
-    sequenceId: string;
     generation: number;
-    build: SequenceBuild;
+    /** `build.company.schema` is compiled from the local `schema/`; the backend uses it while serving. */
+    build: CompanyBuild;
+    /**
+     * Source maps of the code serve hands the backend to run (its page scripts), by `functionKey`: a page's
+     * failure is shown on the repository's own files with them.
+     */
+    sourceMaps?: SourceMaps;
 };
 export type OverlayExecuteMessage = {
     type: 'execute';
     requestId: string;
+    /** The sequence's directory name. */
     sequenceId: string;
     name: string;
-    args?: unknown[];
+    invocation?: ComputeInvocation;
     data?: ActionDataSlice;
     runToken?: string;
     /** Logger request id for `ctx.api` RPC; not the overlay execute correlation id. */
     logRequestId?: string;
     /** Logger tags inherited from the backend execution context. */
     logTags?: string[];
+    /**
+     * Epoch ms after which the backend no longer waits for this request: serve does not start it then, so
+     * a request reported as failed never runs later. Set once by the process that started the call, by the
+     * backend's clock; serve compares it with its own, which assumes the two agree (NTP) to well within the
+     * execute timeout.
+     */
+    deadline: number;
 };
 export type OverlayExecuteResultMessage = {
     type: 'execute.result';
@@ -46,9 +97,24 @@ export type OverlayExecuteResultMessage = {
     requestId: string;
     ok: false;
     error: string;
+    /**
+     * Where it failed: the error's first line and the frames of the repository's own files, by their
+     * path from its root (the company's logs show it). Absent when the error had no stack.
+     */
+    stack?: string;
+    /**
+     * Nothing of the company's ran (expired before it started, an unknown sequence): the platform's
+     * failure, not the company's code's (67 §4.1).
+     */
+    notStarted?: true;
+    /**
+     * The code failed on a `PlatformUnavailableError` it did not catch (74 §3.2): the platform's failure,
+     * not the company's code's.
+     */
+    platform?: true;
 };
 export type OverlayClientMessage = OverlayAuthMessage | OverlayPushMessage | OverlayExecuteResultMessage;
-export type OverlayServerMessage = OverlayAuthOkMessage | OverlayAuthErrorMessage | OverlayReplacedMessage | OverlayExecuteMessage;
+export type OverlayServerMessage = OverlayAuthOkMessage | OverlayAuthErrorMessage | OverlayReplacedMessage | OverlayExecuteMessage | OverlayNoticeMessage | OverlayOkMessage;
 export type OverlayMessage = OverlayClientMessage | OverlayServerMessage;
 export declare function encodeOverlayMessage(message: OverlayMessage): string;
 export declare function parseOverlayMessage(raw: string): OverlayMessage;

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

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

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

@@ -1,21 +1,37 @@
 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 = {
+import { dayIn, formatTime, timeAt, timeParts } from '../core/page/time-format.js';
+/** A run in an environment that is not being tested (68 §6.2): every contact hour holds. */
+const NOTHING_IGNORED = Object.freeze({ contactHours: false, contactSchedule: false });
+function resolveRunScope(data, options) {
+    return {
         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);
+}
+/** What the call brought for the api, besides the context: the integrations the platform listed. */
+function given(data) {
+    return data.surfaces ? { surfaces: data.surfaces } : {};
+}
+function assembleContext(data, meta, api) {
     return {
-        time: data.time,
-        meta: data.meta,
+        time: { ...data.time, ignore: data.time.ignore ?? NOTHING_IGNORED, format: formatTime, day: dayIn, at: timeAt, parts: timeParts },
+        meta,
         config: data.config,
         api: { ...api, log: bindLogMeta(api.log, data.meta) },
     };
 }
+/**
+ * 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 api = await host.buildApi(resolveRunScope(data, options), given(data));
+    return assembleContext(data, data.meta, api);
+}
+/** Assemble the `orchestrator` ctx (without `params`), its api from the host. */
+export async function buildCaseOrchestratorContext(data, host, options = {}) {
+    const api = await host.buildCaseOrchestratorApi(resolveRunScope(data, options), given(data));
+    return assembleContext(data, data.meta, api);
+}
 //# sourceMappingURL=build-context.js.map

package/dist/fn-context/fake/empty-api.js

@@ -1,43 +1,24 @@
 import { platformSurfaces } from '../../core/context/platform-registry.js';
-import { docusignMockService } from '../../core/context/docusign.js';
+import { emailMockService } from '../../core/context/email.js';
 import { envMockService } from '../../core/context/env.js';
-import { filevineMockService } from '../../core/context/filevine.js';
-import { hubspotMockService } from '../../core/context/hubspot.js';
-import { twilioMockService } from '../../core/context/twilio.js';
-const MOCK_HUBSPOT_TARGET = { kind: 'account', id: 'mock-hubspot-main' };
-const MOCK_TWILIO_TARGET = { kind: 'account', id: 'mock-twilio-main' };
-const MOCK_FILEVINE_TARGET = { kind: 'account', id: 'mock-filevine-main' };
-const MOCK_DOCUSIGN_TARGET = { kind: 'account', id: 'mock-docusign-main' };
 const MOCK_ENV_TARGET = { kind: 'account', id: 'mock-env-main' };
+const MOCK_EMAIL_TARGET = { kind: 'resource', id: 'mock-email-main' };
 function mockAccount(target, name) {
     return { target, name, credentials: {}, config: {} };
 }
-const hubspotStub = {
-    ...mockAccount(MOCK_HUBSPOT_TARGET, 'main'),
-    ...hubspotMockService,
-};
-const twilioStub = {
-    ...mockAccount(MOCK_TWILIO_TARGET, 'main'),
-    ...twilioMockService,
-};
-const filevineStub = {
-    ...mockAccount(MOCK_FILEVINE_TARGET, 'main'),
-    ...filevineMockService,
-};
-const docusignStub = {
-    ...mockAccount(MOCK_DOCUSIGN_TARGET, 'main'),
-    ...docusignMockService,
-};
 const envStub = {
     ...mockAccount(MOCK_ENV_TARGET, 'main'),
     ...envMockService,
 };
+const emailStub = {
+    ...mockAccount(MOCK_EMAIL_TARGET, 'intake@example.com'),
+    address: 'intake@example.com',
+    provider: 'gmail',
+    ...emailMockService,
+};
 export const emptyIntegration = () => ({
-    hubspots: [hubspotStub],
-    twilios: [twilioStub],
-    filevines: [filevineStub],
-    docusigns: [docusignStub],
     envs: [envStub],
+    emails: [emailStub],
 });
 /** Each registered surface backed by its mock, with per-method overrides applied on top. */
 export const defaultPlatformApis = (overrides = {}) => {

package/dist/fn-context/fake/index.d.ts

@@ -1,12 +1,21 @@
+import { type CaseOrchestratorTools } from '../../core/case-orchestrator/types.js';
 import type { IntegrationApi, Logger } from '../../core/context/types.js';
-import { type HttpApi } from '../../core/context/http.js';
-import type { ApiHost } from '../types.js';
+import type { Db } from '../../core/page/define.js';
+import type { ApiHost, CaseOrchestratorApiHost } from '../types.js';
 import { type PlatformApiOverrides } from './empty-api.js';
 export type FakeApiHostOptions = PlatformApiOverrides & {
     integration?: Partial<IntegrationApi>;
     log?: Logger;
-    http?: Partial<HttpApi>;
+    /** Case Orchestrator tools; a tool left out rejects when called. */
+    tools?: Partial<CaseOrchestratorTools>;
+    /** `ctx.api.db`; left out, every call rejects. */
+    db?: Db;
 };
+/** Every table, every method: rejects when called (`what` names it in the error). */
+/** A stand-in whose every call rejects, saying it is not faked. */
+export declare function unfaked<T extends object>(what: string): T;
+/** `ctx.api.tools` for fake contexts: a tool left out rejects when called. */
+export declare function fakeTools(overrides?: Partial<CaseOrchestratorTools>): CaseOrchestratorTools;
 /** In-process ApiHost for local unit tests (`makeCtx` uses this). */
-export declare function createFakeApiHost(options?: FakeApiHostOptions): ApiHost;
+export declare function createFakeApiHost(options?: FakeApiHostOptions): ApiHost & CaseOrchestratorApiHost;
 //# sourceMappingURL=index.d.ts.map

package/dist/fn-context/fake/index.js

@@ -1,6 +1,28 @@
-import { defaultHttpApi } from '../../core/context/http.js';
+import { CASE_ORCHESTRATOR_TOOL_NAMES } from '../../core/case-orchestrator/types.js';
 import { noopLog } from '../log.js';
 import { defaultPlatformApis, emptyIntegration } from './empty-api.js';
+/** Every table, every method: rejects when called (`what` names it in the error). */
+/** A stand-in whose every call rejects, saying it is not faked. */
+export function unfaked(what) {
+    return new Proxy({}, {
+        get: (_, table) => new Proxy({}, {
+            get: (__, method) => async () => {
+                throw new Error(`FakeApiHost: ${what}.${String(table)}.${String(method)} is not faked`);
+            },
+        }),
+    });
+}
+/** `ctx.api.tools` for fake contexts: a tool left out rejects when called. */
+export function fakeTools(overrides = {}) {
+    const tools = CASE_ORCHESTRATOR_TOOL_NAMES.map((tool) => [
+        tool,
+        overrides[tool] ??
+            (async () => {
+                throw new Error(`FakeApiHost: tools.${tool} is not faked`);
+            }),
+    ]);
+    return Object.fromEntries(tools);
+}
 /** In-process ApiHost for local unit tests (`makeCtx` uses this). */
 export function createFakeApiHost(options = {}) {
     const integration = {
@@ -11,12 +33,17 @@ export function createFakeApiHost(options = {}) {
         ...defaultPlatformApis(options),
         integration,
         log: options.log ?? noopLog,
-        http: { ...defaultHttpApi(), ...options.http },
+        db: options.db ?? unfaked('db'),
+        // Every function's (38 §2.7).
+        tools: fakeTools(options.tools),
     };
     return {
         async buildApi() {
             return api;
         },
+        async buildCaseOrchestratorApi() {
+            return api;
+        },
     };
 }
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,3 @@
+/** A function's `args` (38 §2.1): an object, `{}` when the caller gave none. */
+export declare function resolveFnParams(args: unknown): object;
+//# sourceMappingURL=fn-params.d.ts.map

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

@@ -0,0 +1,10 @@
+/** A function's `args` (38 §2.1): an object, `{}` when the caller gave none. */
+export function resolveFnParams(args) {
+    if (args == null)
+        return {};
+    if (typeof args !== 'object' || Array.isArray(args)) {
+        throw new Error('function args must be an object');
+    }
+    return args;
+}
+//# sourceMappingURL=fn-params.js.map

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

@@ -1,10 +1,10 @@
-export type { ActionContext, ActionDataSlice, ApiHost, RunScope } from './types.js';
-export { buildActionContext, type BuildActionContextOptions } from './build-context.js';
-export { resolveSystemFnParams } from './system-args.js';
+export type { ActionContext, ActionDataSlice, ApiGiven, ApiHost, CaseOrchestratorActionContext, CaseOrchestratorApiHost, CaseOrchestratorRunScope, RunClaims, RunScope, } from './types.js';
+export { buildActionContext, buildCaseOrchestratorContext, type BuildActionContextOptions, } from './build-context.js';
+export { asCaseOrchestratorRun } from './run-scope.js';
+export { resolveFnParams } from './fn-params.js';
 export { createFakeApiHost, type FakeApiHostOptions } from './fake/index.js';
 export { defaultPlatformApis, emptyIntegration, type PlatformApiOverrides } from './fake/empty-api.js';
 export { createRpcApiHost, LOG_TAGS_HEADER, REQUEST_ID_HEADER, RUNTIME_VERSION_HEADER, encodeLogTagsHeader, formatRuntimeVersion, readLogTagsHeader, readRequestIdHeader, readRuntimeVersionHeader, } from './rpc/index.js';
 export { bindLogMeta, noopLog } from './log.js';
-export { makeCtx, makeCtxAsync } from './make-ctx.js';
-export { defaultHttpApi } from '../core/context/http.js';
+export { makeCaseOrchestratorCtx, makeCtx, makeCtxAsync } from './make-ctx.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/fn-context/index.js

@@ -1,9 +1,9 @@
-export { buildActionContext } from './build-context.js';
-export { resolveSystemFnParams } from './system-args.js';
+export { buildActionContext, buildCaseOrchestratorContext, } from './build-context.js';
+export { asCaseOrchestratorRun } from './run-scope.js';
+export { resolveFnParams } from './fn-params.js';
 export { createFakeApiHost } from './fake/index.js';
 export { defaultPlatformApis, emptyIntegration } from './fake/empty-api.js';
 export { createRpcApiHost, LOG_TAGS_HEADER, REQUEST_ID_HEADER, RUNTIME_VERSION_HEADER, encodeLogTagsHeader, formatRuntimeVersion, readLogTagsHeader, readRequestIdHeader, readRuntimeVersionHeader, } from './rpc/index.js';
 export { bindLogMeta, noopLog } from './log.js';
-export { makeCtx, makeCtxAsync } from './make-ctx.js';
-export { defaultHttpApi } from '../core/context/http.js';
+export { makeCaseOrchestratorCtx, makeCtx, makeCtxAsync } from './make-ctx.js';
 //# sourceMappingURL=index.js.map

package/dist/fn-context/log.js

@@ -4,9 +4,9 @@ export const noopLog = {
     error: () => { },
 };
 /** Identity fields that LogContext already stores first-class (mars ctx). */
-const CONTEXT_KEYS = ['companyId', 'sequenceId', 'contactId'];
+const CONTEXT_KEYS = ['companyId', 'sequenceId'];
 /** Remaining SystemContext.meta fields; carried on log extra. */
-const EXTRA_META_KEYS = ['environmentId', 'entry', 'caseId'];
+const EXTRA_META_KEYS = ['environmentId', 'entry', 'instanceId'];
 /**
  * Stamp every `ctx.api.log` call with SystemContext.meta. First-class ids stay
  * on extra so RpcApiHost can send them; the backend lifts them into LogContext.

package/dist/fn-context/make-ctx.d.ts

@@ -1,4 +1,7 @@
+import type { CaseOrchestratorTools } from '../core/case-orchestrator/types.js';
 import type { MakeCtxOverrides, SystemContext } from '../core/context/types.js';
+import type { Db } from '../core/page/define.js';
+import type { CaseOrchestratorActionContext } from './types.js';
 /**
  * Build a fake SystemContext for local unit tests.
  * Uses {@link createFakeApiHost}; sync because FakeApiHost has no I/O.
@@ -6,4 +9,12 @@ import type { MakeCtxOverrides, SystemContext } from '../core/context/types.js';
 export declare function makeCtx(overrides?: MakeCtxOverrides): SystemContext;
 /** Async makeCtx via {@link buildActionContext} + FakeApiHost (same result as {@link makeCtx}). */
 export declare function makeCtxAsync(overrides?: MakeCtxOverrides): Promise<SystemContext>;
+/**
+ * Fake `orchestrator` ctx (without `params`) for local unit tests: `tools` fakes `ctx.api.tools`,
+ * `db` fakes `ctx.api.db` (left out, every call rejects).
+ */
+export declare function makeCaseOrchestratorCtx(overrides?: MakeCtxOverrides & {
+    tools?: Partial<CaseOrchestratorTools>;
+    db?: Db;
+}): Promise<CaseOrchestratorActionContext>;
 //# sourceMappingURL=make-ctx.d.ts.map

package/dist/fn-context/make-ctx.js

@@ -1,21 +1,20 @@
-import { defaultHttpApi } from '../core/context/http.js';
-import { buildActionContext } from './build-context.js';
-import { createFakeApiHost } from './fake/index.js';
+import { buildActionContext, buildCaseOrchestratorContext } from './build-context.js';
+import { createFakeApiHost, fakeTools, unfaked } from './fake/index.js';
 import { defaultPlatformApis, emptyIntegration } from './fake/empty-api.js';
 import { bindLogMeta, noopLog } from './log.js';
+import { dayIn, formatTime, timeAt, timeParts } from '../core/page/time-format.js';
 function toDataSlice(overrides) {
     const timezone = overrides.timezone ?? 'UTC';
     const today = overrides.today ?? '1970-01-01';
     const now = overrides.now ?? Date.parse(`${today}T00:00:00.000Z`);
     return {
-        time: { now, timezone, today },
+        time: { now, timezone, today, ignore: overrides.ignore ?? { contactHours: false, contactSchedule: false } },
         meta: {
             companyId: 'company',
             environmentId: 'sandbox',
             sequenceId: 'sequence',
             entry: 'test',
-            contactId: 'contact',
-            caseId: 'case',
+            instanceId: 'instance',
             ...overrides.meta,
         },
         config: {
@@ -35,9 +34,10 @@ export function makeCtx(overrides = {}) {
         ...defaultPlatformApis(overrides.api),
         integration: { ...emptyIntegration(), ...overrides.api?.integration },
         log: bindLogMeta(overrides.api?.log ?? noopLog, data.meta),
-        http: { ...defaultHttpApi(), ...overrides.api?.http },
+        db: overrides.api?.db ?? unfaked('db'),
+        tools: fakeTools(overrides.api?.tools),
     };
-    return { ...data, api };
+    return { ...data, meta: data.meta, time: { ...data.time, ignore: data.time.ignore ?? { contactHours: false, contactSchedule: false }, format: formatTime, day: dayIn, at: timeAt, parts: timeParts }, api };
 }
 /** Async makeCtx via {@link buildActionContext} + FakeApiHost (same result as {@link makeCtx}). */
 export async function makeCtxAsync(overrides = {}) {
@@ -45,7 +45,18 @@ export async function makeCtxAsync(overrides = {}) {
         ...overrides.api,
         integration: overrides.api?.integration,
         log: overrides.api?.log,
-        http: overrides.api?.http,
+    }));
+}
+/**
+ * Fake `orchestrator` ctx (without `params`) for local unit tests: `tools` fakes `ctx.api.tools`,
+ * `db` fakes `ctx.api.db` (left out, every call rejects).
+ */
+export async function makeCaseOrchestratorCtx(overrides = {}) {
+    return buildCaseOrchestratorContext(toDataSlice({ ...overrides, meta: { entry: 'orchestrator', ...overrides.meta } }), createFakeApiHost({
+        ...overrides.api,
+        log: overrides.api?.log,
+        tools: overrides.tools,
+        db: overrides.db,
     }));
 }
 //# sourceMappingURL=make-ctx.js.map

package/dist/fn-context/rpc/case-orchestrator-tools.d.ts

@@ -0,0 +1,32 @@
+import { type RpcContext } from './trpc-init.js';
+export type CaseOrchestratorToolInvokeHandler = (input: {
+    tool: string;
+    input: unknown;
+    ctx: RpcContext;
+}) => Promise<unknown>;
+export declare function createCaseOrchestratorToolsRouter(invoke: CaseOrchestratorToolInvokeHandler): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: RpcContext;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+        message: string;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+        data: {
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+            reason: string;
+        };
+    };
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    invoke: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            tool: string;
+            input: unknown;
+        };
+        output: unknown;
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=case-orchestrator-tools.d.ts.map

package/dist/fn-context/rpc/case-orchestrator-tools.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { publicProcedure, router } from './trpc-init.js';
+const invokeInput = z.object({
+    tool: z.string().min(1),
+    input: z.unknown(),
+});
+export function createCaseOrchestratorToolsRouter(invoke) {
+    return router({
+        invoke: publicProcedure.input(invokeInput).mutation(({ ctx, input }) => invoke({ ...input, ctx })),
+    });
+}
+//# sourceMappingURL=case-orchestrator-tools.js.map

package/dist/fn-context/rpc/errors.d.ts

@@ -22,4 +22,17 @@ export declare class ScriptInputError extends Error implements RpcCodedError {
     });
 }
 export declare function parseScriptInput<S extends z.ZodType>(schema: S, input: unknown): z.infer<S>;
+/**
+ * The business code a refused call carries to company code as `error.code` (`subject_busy`, `run_ended`, a
+ * write's code, 13 §16.3 item 8): the message reads `<reason>: <message>` for people, and the reason travels
+ * apart from it (`data.reason`), so `catch (error) { if (error.code === 'subject_busy') … }` works (64 §12).
+ */
+export declare class RpcReasonError extends Error {
+    readonly reason: string;
+    constructor(reason: string, message: string);
+}
+/** A refusal with the HTTP-like `code` tRPC answers with and the business `reason` the caller sees. */
+export declare function reasonError(code: RpcErrorCode, reason: string, message: string): TRPCError;
+/** The business reason a server error carries, if any. */
+export declare function rpcErrorReason(error: unknown): string | undefined;
 //# sourceMappingURL=errors.d.ts.map

package/dist/fn-context/rpc/errors.js

@@ -1,3 +1,4 @@
+import { TRPCError } from '@trpc/server';
 export function isRpcCodedError(error) {
     return error instanceof Error && typeof error.rpcCode === 'string';
 }
@@ -20,4 +21,25 @@ export function parseScriptInput(schema, input) {
     }
     return parsed.data;
 }
+/**
+ * The business code a refused call carries to company code as `error.code` (`subject_busy`, `run_ended`, a
+ * write's code, 13 §16.3 item 8): the message reads `<reason>: <message>` for people, and the reason travels
+ * apart from it (`data.reason`), so `catch (error) { if (error.code === 'subject_busy') … }` works (64 §12).
+ */
+export class RpcReasonError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+        this.name = 'RpcReasonError';
+    }
+}
+/** A refusal with the HTTP-like `code` tRPC answers with and the business `reason` the caller sees. */
+export function reasonError(code, reason, message) {
+    return new TRPCError({ code, message: `${reason}: ${message}`, cause: new RpcReasonError(reason, message) });
+}
+/** The business reason a server error carries, if any. */
+export function rpcErrorReason(error) {
+    return error instanceof RpcReasonError ? error.reason : undefined;
+}
 //# sourceMappingURL=errors.js.map

package/dist/fn-context/rpc/index.d.ts

@@ -1,10 +1,12 @@
 export { createAppRouter, type AppRouter } from './trpc-router-factory.js';
 export type { RpcContext } from './trpc-init.js';
-export { ScriptInputError, isRpcCodedError, parseScriptInput, type RpcCodedError, type RpcErrorCode, } from './errors.js';
+export { ScriptInputError, isRpcCodedError, parseScriptInput, reasonError, RpcReasonError, type RpcCodedError, type RpcErrorCode, } from './errors.js';
 export { createIntegrationRouter, type IntegrationInvokeHandler } from './integration/index.js';
-export { createListBindingsProcedure } from './integration/list-bindings.js';
+export { createListSurfacesProcedure } from './integration/list-surfaces.js';
 export { createPlatformRouter, type PlatformInvokeHandler } from './platform.js';
 export { createLogRouter, type LogEmitHandler } from './log.js';
 export { createRpcApiHost } from './trpc-client.js';
+export { createCaseOrchestratorToolsRouter, type CaseOrchestratorToolInvokeHandler, } from './case-orchestrator-tools.js';
+export { createRecordsRouter, type RecordsReadInput, type RecordsHandlers, type RecordsResult, type RecordsWriteInput, } from './records.js';
 export { LOG_TAGS_HEADER, REQUEST_ID_HEADER, RUNTIME_VERSION_HEADER, encodeLogTagsHeader, formatRuntimeVersion, readLogTagsHeader, readRequestIdHeader, readRuntimeVersionHeader, } from './request-id.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/fn-context/rpc/index.js

@@ -1,9 +1,11 @@
 export { createAppRouter } from './trpc-router-factory.js';
-export { ScriptInputError, isRpcCodedError, parseScriptInput, } from './errors.js';
+export { ScriptInputError, isRpcCodedError, parseScriptInput, reasonError, RpcReasonError, } from './errors.js';
 export { createIntegrationRouter } from './integration/index.js';
-export { createListBindingsProcedure } from './integration/list-bindings.js';
+export { createListSurfacesProcedure } from './integration/list-surfaces.js';
 export { createPlatformRouter } from './platform.js';
 export { createLogRouter } from './log.js';
 export { createRpcApiHost } from './trpc-client.js';
+export { createCaseOrchestratorToolsRouter, } from './case-orchestrator-tools.js';
+export { createRecordsRouter, } from './records.js';
 export { LOG_TAGS_HEADER, REQUEST_ID_HEADER, RUNTIME_VERSION_HEADER, encodeLogTagsHeader, formatRuntimeVersion, readLogTagsHeader, readRequestIdHeader, readRuntimeVersionHeader, } from './request-id.js';
 //# sourceMappingURL=index.js.map

package/dist/fn-context/rpc/integration/index.d.ts

@@ -1,6 +1,6 @@
 import type { IntegrationTarget } from '../../../core/context/types.js';
 import { type RpcContext } from '../trpc-init.js';
-import { createListBindingsProcedure } from './list-bindings.js';
+import { createListSurfacesProcedure } from './list-surfaces.js';
 /**
  * Provider-agnostic entry point for script surfaces: the target's provider decides
  * which methods exist, so adding one never touches the RPC layer.
@@ -12,18 +12,28 @@ export type IntegrationInvokeHandler = (input: {
     ctx: RpcContext;
 }) => Promise<unknown>;
 export declare function createIntegrationRouter(modules: {
-    listBindings: ReturnType<typeof createListBindingsProcedure>;
+    listSurfaces: ReturnType<typeof createListSurfacesProcedure>;
     invoke: IntegrationInvokeHandler;
 }): import("@trpc/server").TRPCBuiltRouter<{
     ctx: RpcContext;
     meta: object;
-    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+        message: string;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+        data: {
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+            reason: string;
+        };
+    };
     transformer: false;
 }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-    listBindings: import("@trpc/server").TRPCQueryProcedure<{
+    listSurfaces: import("@trpc/server").TRPCQueryProcedure<{
         input: void;
         output: {
-            surfaceKey: "docusigns" | "envs" | "filevines" | "hubspots" | "twilios";
+            surfaceKey: "emails" | "envs";
             target: {
                 kind: "account" | "resource";
                 id: string;

package/dist/fn-context/rpc/integration/index.js

@@ -10,7 +10,7 @@ const integrationInvokeInput = z.object({
 });
 export function createIntegrationRouter(modules) {
     return router({
-        listBindings: modules.listBindings,
+        listSurfaces: modules.listSurfaces,
         invoke: publicProcedure
             .input(integrationInvokeInput)
             .mutation(async ({ ctx, input }) => modules.invoke({ target: input.target, method: input.method, params: input.params ?? {}, ctx })),