@superpanel-sdk/runtime 0.5.0 → 0.7.0

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

@@ -1,16 +1,19 @@
+import { ROW_ID_FIELD } from './schema.js';
 function formatValues(values) {
     return values.join(', ');
 }
 /**
  * Type changes that only widen: every stored value of `before` is a valid value of `after`
- * (18-record-search-index §5, 27 §2.3): a short value as a long one; an option or a time of day as
- * a short value.
+ * (18-record-search-index §5, 27 §2.3): an option or a time of day as a short value. Nothing becomes
+ * `text`: a `text` field is not in the field index, so the change would drop every stored entry of the
+ * field at once, in the release's go-live (2026-11-10).
  */
-const WIDENINGS = new Set(['string>text', 'select>string', 'select>text', 'time>string', 'time>text']);
-function normalFieldIssues(path, before, after) {
+const WIDENINGS = new Set(['select>string', 'time>string']);
+const NOT_TO_TEXT = 'a released field does not become text: add a text field and mark this one deprecated';
+function fieldIssues(path, before, after) {
     const issues = [];
     if (before.dataType !== after.dataType && !WIDENINGS.has(`${before.dataType}>${after.dataType}`)) {
-        issues.push(`field '${path}' dataType: ${before.dataType} → ${after.dataType}`);
+        issues.push(`field '${path}' dataType: ${before.dataType} → ${after.dataType}${after.dataType === 'text' ? ` (${NOT_TO_TEXT})` : ''}`);
     }
     // More options only widen; a dropped one may be stored.
     if (before.dataType === after.dataType && before.options && after.options) {
@@ -54,37 +57,34 @@ function refIssues(path, before, after) {
     }
     return [];
 }
-function fieldIssues(path, before, after) {
-    return normalFieldIssues(path, before, after);
-}
-/** A session field has no ref: the rest of a company field's rules. */
-function sessionFieldIssues(path, before, after) {
-    return normalFieldIssues(path, before, after);
-}
 /**
  * Why `after`'s company schema cannot replace `before`'s without breaking slot data stored under
- * it; empty for an additive (01-slot-db §2.3) evolution. One pass covers the whole repo: sequence
- * overlays only change usage. The session fields (`schema/session.ts`) follow the same rules, since
- * `Session.data` keeps their values (11-remove-sequence-schema §3.1).
+ * it; empty for an additive (01-slot-db §2.3) evolution. Both are a build's compiled schema
+ * (`CompanyPart.schema`): one for the whole repo, sequences have none of their own. The session
+ * table (`schema/session.ts`) follows the same rules, since `Session.data` keeps its values
+ * (11-remove-sequence-schema §3.1); a session field has no ref, so the ref rules never apply to it.
  *
  * Compatible: new tables (with their parent), fields (lookups included), more options, a widened
- * type (`string` → `text`, `select` / `time` → `string`), and presentation changes (label,
+ * type (`select` / `time` → `string`), and presentation changes (label,
  * description, extraction, deprecated); a new field may be `unique`. Incompatible: removing a table or
- * field (mark it `deprecated` instead); any other change of a field's dataType, `unique` added to or
+ * field (mark it `deprecated` instead); any other change of a field's dataType (to `text` included), `unique` added to or
  * dropped from a field (18-record-search-index §4.5), any ref change (added, removed, retargeted, parent ↔ lookup), a parent added to a
  * table `before` has (its stored rows have no parent edge, 13-data-model-v1 §22.5), a removed option.
  */
-export function companyMetadataCompatibilityIssues(before, after) {
+export function companySchemaCompatibilityIssues(before, after) {
     const issues = [];
-    for (const [tableName, beforeTable] of Object.entries(before.tables)) {
-        const afterTable = after.tables[tableName];
+    for (const [tableName, beforeTable] of Object.entries(before)) {
+        const afterTable = Object.hasOwn(after, tableName) ? after[tableName] : undefined;
         if (!afterTable) {
             issues.push(`table '${tableName}' was removed`);
             continue;
         }
         for (const [fieldName, beforeField] of Object.entries(beforeTable.fields)) {
+            // The row id is the platform's, the same on every table.
+            if (fieldName === ROW_ID_FIELD)
+                continue;
             const path = `${tableName}.${fieldName}`;
-            const afterField = afterTable.fields[fieldName];
+            const afterField = Object.hasOwn(afterTable.fields, fieldName) ? afterTable.fields[fieldName] : undefined;
             if (!afterField) {
                 const instead = beforeField.ref?.kind === 'parent' ? PARENT_FIXED : 'mark it deprecated instead';
                 issues.push(`field '${path}' was removed (${instead})`);
@@ -93,20 +93,11 @@ export function companyMetadataCompatibilityIssues(before, after) {
             issues.push(...fieldIssues(path, beforeField, afterField));
         }
         for (const [fieldName, afterField] of Object.entries(afterTable.fields)) {
-            if (fieldName in beforeTable.fields || afterField.ref?.kind !== 'parent')
+            if (Object.hasOwn(beforeTable.fields, fieldName) || afterField.ref?.kind !== 'parent')
                 continue;
             issues.push(`table '${tableName}' gained a parent '${fieldName}': its stored rows have none (${PARENT_FIXED})`);
         }
     }
-    for (const [fieldName, beforeField] of Object.entries(before.session.fields)) {
-        const path = `session.${fieldName}`;
-        const afterField = after.session.fields[fieldName];
-        if (!afterField) {
-            issues.push(`field '${path}' was removed (mark it deprecated instead)`);
-            continue;
-        }
-        issues.push(...sessionFieldIssues(path, beforeField, afterField));
-    }
     return issues;
 }
 //# sourceMappingURL=schema-compat.js.map

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

@@ -1,7 +1,8 @@
 import { z } from 'zod';
 /**
- * A field's type (18-record-search-index §4.2): `string` is a short value (at most 255 characters,
- * `LIMITS.stringChars`), `text` a long one (notes, descriptions; not indexed); `phone` is stored in
+ * A field's type (18-record-search-index §4.2): `string` is a value to find and sort by, `text` one
+ * only kept (notes, descriptions; not indexed); a `string` holds up to `LIMITS.stringBytes` (its index
+ * entries keep it whole), a `text` up to `LIMITS.textBytes` (34-string-length); `phone` is stored in
  * E.164 and `email` lower-cased, both checked on write. `select` is one of the field's `options`,
  * `multi_select` a list of them, `time` a time of day `HH:mm` (27-field-types-and-history).
  */
@@ -374,62 +375,5 @@ export declare const sessionSchemaSchema: z.ZodObject<{
         deprecated: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export declare const compiledCompanyMetadataSchema: z.ZodObject<{
-    tables: z.ZodRecord<z.ZodString, z.ZodObject<{
-        label: z.ZodString;
-        description: z.ZodString;
-        fields: z.ZodRecord<z.ZodString, z.ZodObject<{
-            label: z.ZodString;
-            dataType: z.ZodEnum<{
-                boolean: "boolean";
-                contact_schedule: "contact_schedule";
-                date: "date";
-                datetime: "datetime";
-                email: "email";
-                multi_select: "multi_select";
-                number: "number";
-                phone: "phone";
-                select: "select";
-                string: "string";
-                text: "text";
-                time: "time";
-            }>;
-            extraction: z.ZodString;
-            options: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            ref: z.ZodOptional<z.ZodObject<{
-                table: z.ZodString;
-                kind: z.ZodEnum<{
-                    lookup: "lookup";
-                    parent: "parent";
-                }>;
-                relatedName: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>>;
-            unique: z.ZodOptional<z.ZodLiteral<true>>;
-            deprecated: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    session: z.ZodObject<{
-        fields: z.ZodRecord<z.ZodString, z.ZodObject<{
-            label: z.ZodString;
-            extraction: z.ZodString;
-            options: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            dataType: z.ZodEnum<{
-                boolean: "boolean";
-                date: "date";
-                datetime: "datetime";
-                email: "email";
-                multi_select: "multi_select";
-                number: "number";
-                phone: "phone";
-                select: "select";
-                string: "string";
-                text: "text";
-                time: "time";
-            }>;
-            deprecated: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type CompiledCompanyMetadata = z.infer<typeof compiledCompanyMetadataSchema>;
 export declare function isCompanySchema(value: unknown): value is CompanySchema;
 //# sourceMappingURL=schema.d.ts.map

package/dist/core/slot/schema.js

@@ -164,21 +164,6 @@ export const sessionFieldDefSchema = normalFieldCoreSchema
 export const sessionSchemaSchema = z
     .object({ fields: z.record(z.string().min(1), sessionFieldDefSchema) })
     .strict();
-export const compiledCompanyMetadataSchema = z
-    .object({
-    /**
-     * The whole company schema of the build: every table and field, without sequence overlays.
-     * Prod keeps it additive-only (01-slot-db §2.3).
-     */
-    tables: companySchemaSchema,
-    /** The session fields (`schema/session.ts`), additive-only like the tables. */
-    session: sessionSchemaSchema,
-})
-    .strict()
-    .refine((metadata) => !!metadata.tables.contact, {
-    message: 'company metadata must define the contact table',
-    path: ['tables', 'contact'],
-});
 export function isCompanySchema(value) {
     return companySchemaSchema.safeParse(value).success;
 }

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

@@ -1,14 +1,10 @@
 import type { ContactSchedule, DataType, TableRef } from './schema.js';
 import type { FieldState } from '../context/types.js';
 export type UpdatedBy = 'slot-filling' | 'function' | 'human' | 'import' | 'platform';
-/** Prior generation archived into FieldValue.history (no reason — 01-slot-db §4.1). */
-export type FieldHistoryEntry = {
-    value: SlotValue;
-    state: FieldState;
-    at: number;
-    by: UpdatedBy;
-};
-/** In-memory field envelope (01-slot-design §2 + 01-slot-db §4 history). */
+/**
+ * In-memory field envelope (01-slot-design §2): the current value only. Earlier values are in the
+ * change log (`SlotWriteLog`, 36 §3).
+ */
 export type FieldValue = {
     /**
      * Dialogue evidence quote or write justification (`null` when the writer gave none: plain
@@ -25,8 +21,6 @@ export type FieldValue = {
     /** Epoch milliseconds of the last value/state change. */
     updatedAt: number;
     updatedBy: UpdatedBy;
-    /** Past generations ascending; excludes current. Appended only on C5 change. */
-    history: FieldHistoryEntry[];
 };
 export type SlotValue = string | number | boolean | string[] | ContactSchedule | null;
 export type RuntimeFieldDef = {

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

@@ -20,6 +20,8 @@ export declare const EMAIL_VALUE_PATTERN: string;
 export declare function stringChars(value: string): number;
 /** UTF-8 bytes of a string. */
 export declare function utf8Bytes(value: string): number;
+/** UTF-8 bytes a `string` takes in its indexes: as written, or lower-cased if that is longer. */
+export declare function indexedBytes(value: string): number;
 /** What a value of `dataType` must look like, for messages. */
 export declare function dataTypeFormat(dataType: DataType): string;
 export declare function isValidDataTypeValue(dataType: DataType, value: unknown): boolean;

package/dist/core/slot/value.js

@@ -33,11 +33,15 @@ export function stringChars(value) {
 export function utf8Bytes(value) {
     return utf8.encode(value).length;
 }
+/** UTF-8 bytes a `string` takes in its indexes: as written, or lower-cased if that is longer. */
+export function indexedBytes(value) {
+    return Math.max(utf8Bytes(value), utf8Bytes(value.toLowerCase()));
+}
 /** What a value of `dataType` must look like, for messages. */
 export function dataTypeFormat(dataType) {
     switch (dataType) {
         case 'string':
-            return `a string of at most ${LIMITS.stringChars} characters (use text for longer)`;
+            return `a string of at most ${LIMITS.stringBytes} bytes (UTF-8; a longer value is a text field)`;
         case 'text':
             return `a string of at most ${LIMITS.textBytes} bytes`;
         case 'phone':
@@ -63,7 +67,7 @@ export function isValidDataTypeValue(dataType, value) {
         return true;
     switch (dataType) {
         case 'string':
-            return typeof value === 'string' && stringChars(value) <= LIMITS.stringChars;
+            return typeof value === 'string' && indexedBytes(value) <= LIMITS.stringBytes;
         case 'text':
             return typeof value === 'string' && utf8Bytes(value) <= LIMITS.textBytes;
         case 'phone':

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

@@ -1,6 +1,5 @@
 import type { ActionDataSlice } from '../fn-context/types.js';
-import type { CompanyBuild } from '../builder/types.js';
-import type { CompiledCompanyMetadata } from '../core/slot/schema.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
@@ -42,6 +41,14 @@ 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;
@@ -51,9 +58,13 @@ export type OverlayNoticeMessage = {
 export type OverlayPushMessage = {
     type: 'overlay';
     generation: number;
+    /** `build.company.schema` is compiled from the local `schema/`; the backend uses it while serving. */
     build: CompanyBuild;
-    /** Company metadata compiled from the local `schema/`; the backend uses it while serving. */
-    companyMetadata: CompiledCompanyMetadata;
+    /**
+     * 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';
@@ -68,6 +79,13 @@ export type OverlayExecuteMessage = {
     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';
@@ -79,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 | OverlayNoticeMessage;
+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.js

@@ -1,5 +1,7 @@
 import { bindLogMeta } from './log.js';
-import { dayIn, formatTime } from '../core/page/time-format.js';
+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,
@@ -7,9 +9,13 @@ function resolveRunScope(data, options) {
         entry: options.run?.entry ?? data.meta.entry,
     };
 }
+/** 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, format: formatTime, day: dayIn },
+        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) },
@@ -20,12 +26,12 @@ function assembleContext(data, meta, api) {
  * 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));
+    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));
+    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/index.d.ts

@@ -14,6 +14,8 @@ export type FakeApiHostOptions = PlatformApiOverrides & {
 /** 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 & CaseOrchestratorApiHost;
 //# sourceMappingURL=index.d.ts.map

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

@@ -12,7 +12,8 @@ export function unfaked(what) {
         }),
     });
 }
-function fakeTools(overrides = {}) {
+/** `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] ??
@@ -33,14 +34,15 @@ export function createFakeApiHost(options = {}) {
         integration,
         log: options.log ?? noopLog,
         db: options.db ?? unfaked('db'),
+        // Every function's (38 §2.7).
+        tools: fakeTools(options.tools),
     };
-    const tools = fakeTools(options.tools);
     return {
         async buildApi() {
             return api;
         },
         async buildCaseOrchestratorApi() {
-            return { ...api, tools };
+            return api;
         },
     };
 }

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

@@ -1,6 +1,3 @@
-/**
- * `invocation.params` for `case` / `noCase` functions: an object (empty when omitted).
- * The case (`c`: `{ subject, instanceId }`) is passed apart, not here.
- */
-export declare function resolveFnParams(params: unknown): object;
+/** 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

@@ -1,13 +1,10 @@
-/**
- * `invocation.params` for `case` / `noCase` functions: an object (empty when omitted).
- * The case (`c`: `{ subject, instanceId }`) is passed apart, not here.
- */
-export function resolveFnParams(params) {
-    if (params == null)
+/** A function's `args` (38 §2.1): an object, `{}` when the caller gave none. */
+export function resolveFnParams(args) {
+    if (args == null)
         return {};
-    if (typeof params !== 'object' || Array.isArray(params)) {
-        throw new Error('function params must be an object');
+    if (typeof args !== 'object' || Array.isArray(args)) {
+        throw new Error('function args must be an object');
     }
-    return params;
+    return args;
 }
 //# sourceMappingURL=fn-params.js.map

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

@@ -1,4 +1,4 @@
-export type { ActionContext, ActionDataSlice, ApiHost, CaseOrchestratorActionContext, CaseOrchestratorApiHost, CaseOrchestratorRunScope, RunClaims, RunScope, } from './types.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';

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

@@ -1,14 +1,14 @@
 import { buildActionContext, buildCaseOrchestratorContext } from './build-context.js';
-import { createFakeApiHost, unfaked } from './fake/index.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 } from '../core/page/time-format.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',
@@ -35,8 +35,9 @@ export function makeCtx(overrides = {}) {
         integration: { ...emptyIntegration(), ...overrides.api?.integration },
         log: bindLogMeta(overrides.api?.log ?? noopLog, data.meta),
         db: overrides.api?.db ?? unfaked('db'),
+        tools: fakeTools(overrides.api?.tools),
     };
-    return { ...data, meta: data.meta, time: { ...data.time, format: formatTime, day: dayIn }, 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 = {}) {

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

@@ -2,20 +2,28 @@ import { type RpcContext } from './trpc-init.js';
 export type CaseOrchestratorToolInvokeHandler = (input: {
     tool: string;
     input: unknown;
-    callKey: string;
     ctx: RpcContext;
 }) => Promise<unknown>;
 export declare function createCaseOrchestratorToolsRouter(invoke: CaseOrchestratorToolInvokeHandler): 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<{
     invoke: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             tool: string;
             input: unknown;
-            callKey: string;
         };
         output: unknown;
         meta: object;

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

@@ -3,7 +3,6 @@ import { publicProcedure, router } from './trpc-init.js';
 const invokeInput = z.object({
     tool: z.string().min(1),
     input: z.unknown(),
-    callKey: z.string().min(1).max(200),
 });
 export function createCaseOrchestratorToolsRouter(invoke) {
     return router({

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,6 +1,6 @@
 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 { createListSurfacesProcedure } from './integration/list-surfaces.js';
 export { createPlatformRouter, type PlatformInvokeHandler } from './platform.js';

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

@@ -1,5 +1,5 @@
 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 { createListSurfacesProcedure } from './integration/list-surfaces.js';
 export { createPlatformRouter } from './platform.js';

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

@@ -17,7 +17,17 @@ export declare function createIntegrationRouter(modules: {
 }): 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<{
     listSurfaces: import("@trpc/server").TRPCQueryProcedure<{

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

@@ -20,7 +20,17 @@ export type LogEmitHandler = (input: {
 export declare function createLogRouter(emit: LogEmitHandler): 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<{
     emit: import("@trpc/server").TRPCMutationProcedure<{