@superpanel-sdk/runtime 0.2.3 → 0.5.0

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

@@ -1,21 +1,31 @@
 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 } from '../core/page/time-format.js';
+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);
+}
+function assembleContext(data, meta, api) {
     return {
-        time: data.time,
-        meta: data.meta,
+        time: { ...data.time, format: formatTime, day: dayIn },
+        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));
+    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));
+    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,19 @@
+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;
 /** 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,27 @@
-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`);
+            },
+        }),
+    });
+}
+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 +32,16 @@ export function createFakeApiHost(options = {}) {
         ...defaultPlatformApis(options),
         integration,
         log: options.log ?? noopLog,
-        http: { ...defaultHttpApi(), ...options.http },
+        db: options.db ?? unfaked('db'),
     };
+    const tools = fakeTools(options.tools);
     return {
         async buildApi() {
             return api;
         },
+        async buildCaseOrchestratorApi() {
+            return { ...api, tools };
+        },
     };
 }
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,6 @@
+/**
+ * `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;
+//# sourceMappingURL=fn-params.d.ts.map

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

@@ -0,0 +1,13 @@
+/**
+ * `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)
+        return {};
+    if (typeof params !== 'object' || Array.isArray(params)) {
+        throw new Error('function params must be an object');
+    }
+    return params;
+}
+//# 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, 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,8 +1,8 @@
-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, 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';
 function toDataSlice(overrides) {
     const timezone = overrides.timezone ?? 'UTC';
     const today = overrides.today ?? '1970-01-01';
@@ -14,8 +14,7 @@ function toDataSlice(overrides) {
             environmentId: 'sandbox',
             sequenceId: 'sequence',
             entry: 'test',
-            contactId: 'contact',
-            caseId: 'case',
+            instanceId: 'instance',
             ...overrides.meta,
         },
         config: {
@@ -35,9 +34,9 @@ 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'),
     };
-    return { ...data, api };
+    return { ...data, meta: data.meta, time: { ...data.time, format: formatTime, day: dayIn }, api };
 }
 /** Async makeCtx via {@link buildActionContext} + FakeApiHost (same result as {@link makeCtx}). */
 export async function makeCtxAsync(overrides = {}) {
@@ -45,7 +44,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,24 @@
+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;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    invoke: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            tool: string;
+            input: unknown;
+            callKey: string;
+        };
+        output: unknown;
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=case-orchestrator-tools.d.ts.map

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+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({
+        invoke: publicProcedure.input(invokeInput).mutation(({ ctx, input }) => invoke({ ...input, ctx })),
+    });
+}
+//# sourceMappingURL=case-orchestrator-tools.js.map

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

@@ -2,9 +2,11 @@ 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 { 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 { 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,7 +12,7 @@ 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;
@@ -20,10 +20,10 @@ export declare function createIntegrationRouter(modules: {
     errorShape: import("@trpc/server").TRPCDefaultErrorShape;
     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 })),

package/dist/fn-context/rpc/integration/list-surfaces.d.ts

@@ -0,0 +1,21 @@
+import { type IntegrationSurfaceMeta } from '../../../core/context/types.js';
+import { type RpcContext } from '../trpc-init.js';
+export type ListSurfacesHandler = (opts: {
+    ctx: RpcContext;
+}) => Promise<IntegrationSurfaceMeta[]>;
+export declare function createListSurfacesProcedure(handler: ListSurfacesHandler): import("@trpc/server").TRPCQueryProcedure<{
+    input: void;
+    output: {
+        surfaceKey: "emails" | "envs";
+        target: {
+            kind: "account" | "resource";
+            id: string;
+        };
+        name: string;
+        methods: string[];
+        credentials: Record<string, unknown>;
+        config: Record<string, unknown>;
+    }[];
+    meta: object;
+}>;
+//# sourceMappingURL=list-surfaces.d.ts.map

package/dist/fn-context/rpc/integration/{list-bindings.js → list-surfaces.js}

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { integrationSurfaceKeys } from '../../../core/context/types.js';
 import { publicProcedure } from '../trpc-init.js';
-const boundIntegrationMeta = z.object({
+const integrationSurfaceMeta = z.object({
     surfaceKey: z.enum(integrationSurfaceKeys),
     target: z.object({
         kind: z.enum(['account', 'resource']),
@@ -12,7 +12,7 @@ const boundIntegrationMeta = z.object({
     credentials: z.record(z.string(), z.unknown()),
     config: z.record(z.string(), z.unknown()),
 });
-export function createListBindingsProcedure(handler) {
-    return publicProcedure.output(z.array(boundIntegrationMeta)).query(async (opts) => handler(opts));
+export function createListSurfacesProcedure(handler) {
+    return publicProcedure.output(z.array(integrationSurfaceMeta)).query(async (opts) => handler(opts));
 }
-//# sourceMappingURL=list-bindings.js.map
+//# sourceMappingURL=list-surfaces.js.map

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

@@ -6,7 +6,7 @@ import { type RpcContext } from './trpc-init.js';
 export type PlatformInvokeHandler = (input: {
     surface: string;
     method: string;
-    params: Record<string, unknown>;
+    params: unknown;
     ctx: RpcContext;
 }) => Promise<unknown>;
 export declare function createPlatformRouter(invoke: PlatformInvokeHandler): import("@trpc/server").TRPCBuiltRouter<{
@@ -19,7 +19,7 @@ export declare function createPlatformRouter(invoke: PlatformInvokeHandler): imp
         input: {
             surface: string;
             method: string;
-            params?: Record<string, unknown> | undefined;
+            params?: unknown;
         };
         output: unknown;
         meta: object;

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

@@ -3,7 +3,7 @@ import { publicProcedure, router } from './trpc-init.js';
 const platformInvokeInput = z.object({
     surface: z.string(),
     method: z.string(),
-    params: z.record(z.string(), z.unknown()).optional(),
+    params: z.unknown().optional(),
 });
 export function createPlatformRouter(invoke) {
     return router({

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

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+import { type RpcContext } from './trpc-init.js';
+/**
+ * `ctx.api.db` of every function and the Orchestrator (15 §10.16): the same
+ * reads and writes as a page script and its actions, over RPC, one call per request. A write carries
+ * its call key (its place in the run: `write:1`, `write:2`, …): within an Orchestrator Run the same
+ * request sent again returns the first answer instead of writing twice.
+ */
+declare const readInput: z.ZodObject<{
+    table: z.ZodString;
+    method: z.ZodEnum<{
+        count: "count";
+        findFirst: "findFirst";
+        findMany: "findMany";
+        findUnique: "findUnique";
+    }>;
+    args: z.ZodUnknown;
+}, z.core.$strip>;
+declare const writeInput: z.ZodObject<{
+    table: z.ZodString;
+    method: z.ZodEnum<{
+        create: "create";
+        delete: "delete";
+        update: "update";
+        upsert: "upsert";
+    }>;
+    args: z.ZodUnknown;
+    callKey: z.ZodString;
+}, z.core.$strip>;
+export type RecordsReadInput = z.infer<typeof readInput>;
+export type RecordsWriteInput = z.infer<typeof writeInput>;
+/** What a read or write answers: its value, or the reason it was refused (with its code for a write). */
+export type RecordsResult = {
+    ok: true;
+    value?: unknown;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+export type RecordsHandlers = {
+    read(input: RecordsReadInput & {
+        ctx: RpcContext;
+    }): Promise<RecordsResult>;
+    write(input: RecordsWriteInput & {
+        ctx: RpcContext;
+    }): Promise<RecordsResult>;
+};
+export declare function createRecordsRouter(handlers: RecordsHandlers): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: RpcContext;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    read: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            table: string;
+            method: "count" | "findFirst" | "findMany" | "findUnique";
+            args: unknown;
+        };
+        output: RecordsResult;
+        meta: object;
+    }>;
+    write: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            table: string;
+            method: "create" | "delete" | "update" | "upsert";
+            args: unknown;
+            callKey: string;
+        };
+        output: RecordsResult;
+        meta: object;
+    }>;
+}>>;
+export {};
+//# sourceMappingURL=records.d.ts.map

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

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { publicProcedure, router } from './trpc-init.js';
+/**
+ * `ctx.api.db` of every function and the Orchestrator (15 §10.16): the same
+ * reads and writes as a page script and its actions, over RPC, one call per request. A write carries
+ * its call key (its place in the run: `write:1`, `write:2`, …): within an Orchestrator Run the same
+ * request sent again returns the first answer instead of writing twice.
+ */
+const readInput = z.object({
+    table: z.string().min(1),
+    method: z.enum(['findUnique', 'findFirst', 'findMany', 'count']),
+    args: z.unknown(),
+});
+const writeInput = z.object({
+    table: z.string().min(1),
+    method: z.enum(['create', 'update', 'upsert', 'delete']),
+    args: z.unknown(),
+    callKey: z.string().min(1).max(200),
+});
+export function createRecordsRouter(handlers) {
+    return router({
+        read: publicProcedure.input(readInput).mutation(({ ctx, input }) => handlers.read({ ...input, ctx })),
+        write: publicProcedure.input(writeInput).mutation(({ ctx, input }) => handlers.write({ ...input, ctx })),
+    });
+}
+//# sourceMappingURL=records.js.map

package/dist/fn-context/rpc/trpc-client.d.ts

@@ -1,4 +1,4 @@
-import type { ApiHost } from '../types.js';
+import type { ApiHost, CaseOrchestratorApiHost } from '../types.js';
 export declare function createRpcApiHost(options: {
     baseUrl: string;
     getToken: () => string | Promise<string>;
@@ -7,5 +7,5 @@ export declare function createRpcApiHost(options: {
     getRequestId?: () => string | undefined;
     getTags?: () => string[] | undefined;
     waitUntil?: (promise: Promise<unknown>) => void;
-}): ApiHost;
+}): ApiHost & CaseOrchestratorApiHost;
 //# sourceMappingURL=trpc-client.d.ts.map