@superpanel-sdk/runtime 0.0.1-internal.1

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

@@ -0,0 +1,50 @@
+import { platformSurfaces } from '../../core/context/platform-registry.js';
+import { docusignMockService } from '../../core/context/docusign.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' };
+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,
+};
+export const emptyIntegration = () => ({
+    hubspots: [hubspotStub],
+    twilios: [twilioStub],
+    filevines: [filevineStub],
+    docusigns: [docusignStub],
+    envs: [envStub],
+});
+/** Each registered surface backed by its mock, with per-method overrides applied on top. */
+export const defaultPlatformApis = (overrides = {}) => {
+    const entries = Object.entries(platformSurfaces).map(([key, surface]) => [
+        key,
+        { ...surface.mock, ...overrides[key] },
+    ]);
+    return Object.fromEntries(entries);
+};
+//# sourceMappingURL=empty-api.js.map

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

@@ -0,0 +1,12 @@
+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 PlatformApiOverrides } from './empty-api.js';
+export type FakeApiHostOptions = PlatformApiOverrides & {
+    integration?: Partial<IntegrationApi>;
+    log?: Logger;
+    http?: Partial<HttpApi>;
+};
+/** In-process ApiHost for local unit tests (`makeCtx` uses this). */
+export declare function createFakeApiHost(options?: FakeApiHostOptions): ApiHost;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,22 @@
+import { defaultHttpApi } from '../../core/context/http.js';
+import { noopLog } from '../log.js';
+import { defaultPlatformApis, emptyIntegration } from './empty-api.js';
+/** In-process ApiHost for local unit tests (`makeCtx` uses this). */
+export function createFakeApiHost(options = {}) {
+    const integration = {
+        ...emptyIntegration(),
+        ...options.integration,
+    };
+    const api = {
+        ...defaultPlatformApis(options),
+        integration,
+        log: options.log ?? noopLog,
+        http: { ...defaultHttpApi(), ...options.http },
+    };
+    return {
+        async buildApi() {
+            return api;
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,9 @@
+export type { ActionContext, ActionDataSlice, ApiHost, RunScope } from './types.js';
+export { buildActionContext, type BuildActionContextOptions } from './build-context.js';
+export { createFakeApiHost, type FakeApiHostOptions } from './fake/index.js';
+export { defaultPlatformApis, emptyIntegration, type PlatformApiOverrides } from './fake/empty-api.js';
+export { createRpcApiHost, REQUEST_ID_HEADER, readRequestIdHeader } from './rpc/index.js';
+export { bindLogMeta, noopLog } from './log.js';
+export { makeCtx, makeCtxAsync } from './make-ctx.js';
+export { defaultHttpApi } from '../core/context/http.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/fn-context/index.js

@@ -0,0 +1,8 @@
+export { buildActionContext } from './build-context.js';
+export { createFakeApiHost } from './fake/index.js';
+export { defaultPlatformApis, emptyIntegration } from './fake/empty-api.js';
+export { createRpcApiHost, REQUEST_ID_HEADER, readRequestIdHeader } from './rpc/index.js';
+export { bindLogMeta, noopLog } from './log.js';
+export { makeCtx, makeCtxAsync } from './make-ctx.js';
+export { defaultHttpApi } from '../core/context/http.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,8 @@
+import type { Logger, SystemContext } from '../core/context/types.js';
+export declare const noopLog: Logger;
+/**
+ * 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.
+ */
+export declare function bindLogMeta(log: Logger, meta: SystemContext['meta']): Logger;
+//# sourceMappingURL=log.d.ts.map

package/dist/fn-context/log.js

@@ -0,0 +1,29 @@
+export const noopLog = {
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+/** Identity fields that LogContext already stores first-class (mars ctx). */
+const CONTEXT_KEYS = ['companyId', 'sequenceId', 'contactId'];
+/** Remaining SystemContext.meta fields; carried on log extra. */
+const EXTRA_META_KEYS = ['environmentId', 'entry', 'caseId'];
+/**
+ * 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.
+ */
+export function bindLogMeta(log, meta) {
+    const bind = (extra) => {
+        const stamped = {};
+        for (const key of CONTEXT_KEYS)
+            stamped[key] = meta[key];
+        for (const key of EXTRA_META_KEYS)
+            stamped[key] = meta[key];
+        return { ...stamped, ...extra };
+    };
+    return {
+        info: (message, extra) => log.info(message, bind(extra)),
+        warn: (message, extra) => log.warn(message, bind(extra)),
+        error: (message, extra) => log.error(message, bind(extra)),
+    };
+}
+//# sourceMappingURL=log.js.map

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

@@ -0,0 +1,9 @@
+import type { MakeCtxOverrides, SystemContext } from '../core/context/types.js';
+/**
+ * Build a fake SystemContext for local unit tests.
+ * Uses {@link createFakeApiHost}; sync because FakeApiHost has no I/O.
+ */
+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>;
+//# sourceMappingURL=make-ctx.d.ts.map

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

@@ -0,0 +1,51 @@
+import { defaultHttpApi } from '../core/context/http.js';
+import { buildActionContext } from './build-context.js';
+import { createFakeApiHost } from './fake/index.js';
+import { defaultPlatformApis, emptyIntegration } from './fake/empty-api.js';
+import { bindLogMeta, noopLog } from './log.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 },
+        meta: {
+            companyId: 'company',
+            environmentId: 'sandbox',
+            sequenceId: 'sequence',
+            entry: 'test',
+            contactId: 'contact',
+            caseId: 'case',
+            ...overrides.meta,
+        },
+        config: {
+            frontendUrl: 'http://localhost:3000',
+            backendUrl: 'http://localhost:4000',
+            ...overrides.config,
+        },
+    };
+}
+/**
+ * Build a fake SystemContext for local unit tests.
+ * Uses {@link createFakeApiHost}; sync because FakeApiHost has no I/O.
+ */
+export function makeCtx(overrides = {}) {
+    const data = toDataSlice(overrides);
+    const api = {
+        ...defaultPlatformApis(overrides.api),
+        integration: { ...emptyIntegration(), ...overrides.api?.integration },
+        log: bindLogMeta(overrides.api?.log ?? noopLog, data.meta),
+        http: { ...defaultHttpApi(), ...overrides.api?.http },
+    };
+    return { ...data, api };
+}
+/** Async makeCtx via {@link buildActionContext} + FakeApiHost (same result as {@link makeCtx}). */
+export async function makeCtxAsync(overrides = {}) {
+    return buildActionContext(toDataSlice(overrides), createFakeApiHost({
+        ...overrides.api,
+        integration: overrides.api?.integration,
+        log: overrides.api?.log,
+        http: overrides.api?.http,
+    }));
+}
+//# sourceMappingURL=make-ctx.js.map

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

@@ -0,0 +1,25 @@
+import { TRPCError } from '@trpc/server';
+import type { z } from 'zod';
+export type RpcErrorCode = ConstructorParameters<typeof TRPCError>[0]['code'];
+/**
+ * tRPC reports any non-TRPCError as INTERNAL_SERVER_ERROR, which would file caller mistakes and
+ * denied access under "server fault" — noisy in monitoring and wrongly retriable. A domain error
+ * opts out by declaring the status it deserves; everything else stays a 500 on purpose.
+ */
+export type RpcCodedError = Error & {
+    readonly rpcCode: RpcErrorCode;
+};
+export declare function isRpcCodedError(error: unknown): error is RpcCodedError;
+/**
+ * Raised when a caller passes params that fail a method's schema. Distinct from a bare ZodError
+ * because surfaces also validate their *responses* with zod, and "you sent bad params" must not
+ * be confused with "we produced a bad response".
+ */
+export declare class ScriptInputError extends Error implements RpcCodedError {
+    readonly rpcCode = "BAD_REQUEST";
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare function parseScriptInput<S extends z.ZodType>(schema: S, input: unknown): z.infer<S>;
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1,23 @@
+export function isRpcCodedError(error) {
+    return error instanceof Error && typeof error.rpcCode === 'string';
+}
+/**
+ * Raised when a caller passes params that fail a method's schema. Distinct from a bare ZodError
+ * because surfaces also validate their *responses* with zod, and "you sent bad params" must not
+ * be confused with "we produced a bad response".
+ */
+export class ScriptInputError extends Error {
+    rpcCode = 'BAD_REQUEST';
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'ScriptInputError';
+    }
+}
+export function parseScriptInput(schema, input) {
+    const parsed = schema.safeParse(input);
+    if (!parsed.success) {
+        throw new ScriptInputError(parsed.error.message, { cause: parsed.error });
+    }
+    return parsed.data;
+}
+//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1,10 @@
+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 { createPlatformRouter, type PlatformInvokeHandler } from './platform.js';
+export { createLogRouter, type LogEmitHandler } from './log.js';
+export { createRpcApiHost } from './trpc-client.js';
+export { REQUEST_ID_HEADER, readRequestIdHeader } from './request-id.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,9 @@
+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 { createPlatformRouter } from './platform.js';
+export { createLogRouter } from './log.js';
+export { createRpcApiHost } from './trpc-client.js';
+export { REQUEST_ID_HEADER, readRequestIdHeader } from './request-id.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,51 @@
+import type { IntegrationTarget } from '../../../core/context/types.js';
+import { type RpcContext } from '../trpc-init.js';
+import { createListBindingsProcedure } from './list-bindings.js';
+/**
+ * Provider-agnostic entry point for script surfaces: the target's provider decides
+ * which methods exist, so adding one never touches the RPC layer.
+ */
+export type IntegrationInvokeHandler = (input: {
+    target: IntegrationTarget;
+    method: string;
+    params: Record<string, unknown>;
+    ctx: RpcContext;
+}) => Promise<unknown>;
+export declare function createIntegrationRouter(modules: {
+    listBindings: ReturnType<typeof createListBindingsProcedure>;
+    invoke: IntegrationInvokeHandler;
+}): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: RpcContext;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    listBindings: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            surfaceKey: "docusigns" | "envs" | "filevines" | "hubspots" | "twilios";
+            target: {
+                kind: "account" | "resource";
+                id: string;
+            };
+            name: string;
+            methods: string[];
+            credentials: Record<string, unknown>;
+            config: Record<string, unknown>;
+        }[];
+        meta: object;
+    }>;
+    invoke: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            target: {
+                kind: "account" | "resource";
+                id: string;
+            };
+            method: string;
+            params?: Record<string, unknown> | undefined;
+        };
+        output: unknown;
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { publicProcedure, router } from '../trpc-init.js';
+const integrationInvokeInput = z.object({
+    target: z.object({
+        kind: z.enum(['account', 'resource']),
+        id: z.string(),
+    }),
+    method: z.string(),
+    params: z.record(z.string(), z.unknown()).optional(),
+});
+export function createIntegrationRouter(modules) {
+    return router({
+        listBindings: modules.listBindings,
+        invoke: publicProcedure
+            .input(integrationInvokeInput)
+            .mutation(async ({ ctx, input }) => modules.invoke({ target: input.target, method: input.method, params: input.params ?? {}, ctx })),
+    });
+}
+//# sourceMappingURL=index.js.map

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

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

package/dist/fn-context/rpc/integration/list-bindings.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { integrationSurfaceKeys } from '../../../core/context/types.js';
+import { publicProcedure } from '../trpc-init.js';
+const boundIntegrationMeta = z.object({
+    surfaceKey: z.enum(integrationSurfaceKeys),
+    target: z.object({
+        kind: z.enum(['account', 'resource']),
+        id: z.string(),
+    }),
+    name: z.string(),
+    methods: z.array(z.string()),
+    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));
+}
+//# sourceMappingURL=list-bindings.js.map

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

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { type RpcContext } from './trpc-init.js';
+export declare const logEmitInput: z.ZodObject<{
+    level: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warn: "warn";
+    }>;
+    message: z.ZodString;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type LogEmitHandler = (input: {
+    level: 'info' | 'warn' | 'error';
+    message: string;
+    extra?: Record<string, unknown>;
+    ctx: RpcContext;
+}) => Promise<void>;
+export declare function createLogRouter(emit: LogEmitHandler): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: RpcContext;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    emit: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            level: "error" | "info" | "warn";
+            message: string;
+            extra?: Record<string, unknown> | undefined;
+        };
+        output: {
+            ok: true;
+        };
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=log.d.ts.map

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { publicProcedure, router } from './trpc-init.js';
+export const logEmitInput = z.object({
+    level: z.enum(['info', 'warn', 'error']),
+    message: z.string(),
+    extra: z.record(z.string(), z.unknown()).optional(),
+});
+export function createLogRouter(emit) {
+    return router({
+        emit: publicProcedure.input(logEmitInput).mutation(async ({ ctx, input }) => {
+            await emit({ level: input.level, message: input.message, extra: input.extra, ctx });
+            return { ok: true };
+        }),
+    });
+}
+//# sourceMappingURL=log.js.map

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

@@ -0,0 +1,28 @@
+import { type RpcContext } from './trpc-init.js';
+/**
+ * Single entry point for every platform surface. The handler validates against the surface's
+ * declared schemas, so adding a method never touches this file.
+ */
+export type PlatformInvokeHandler = (input: {
+    surface: string;
+    method: string;
+    params: Record<string, unknown>;
+    ctx: RpcContext;
+}) => Promise<unknown>;
+export declare function createPlatformRouter(invoke: PlatformInvokeHandler): 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: {
+            surface: string;
+            method: string;
+            params?: Record<string, unknown> | undefined;
+        };
+        output: unknown;
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=platform.d.ts.map

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+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(),
+});
+export function createPlatformRouter(invoke) {
+    return router({
+        invoke: publicProcedure
+            .input(platformInvokeInput)
+            .mutation(async ({ ctx, input }) => invoke({ surface: input.surface, method: input.method, params: input.params ?? {}, ctx })),
+    });
+}
+//# sourceMappingURL=platform.js.map

package/dist/fn-context/rpc/request-id.d.ts

@@ -0,0 +1,5 @@
+export declare const REQUEST_ID_HEADER = "x-request-id";
+export declare function readRequestIdHeader(headers: {
+    get(name: string): string | null;
+} | Record<string, string | string[] | undefined>): string | undefined;
+//# sourceMappingURL=request-id.d.ts.map

package/dist/fn-context/rpc/request-id.js

@@ -0,0 +1,13 @@
+export const REQUEST_ID_HEADER = 'x-request-id';
+function firstString(value) {
+    const raw = Array.isArray(value) ? value[0] : value;
+    return typeof raw === 'string' && raw.length > 0 ? raw : undefined;
+}
+export function readRequestIdHeader(headers) {
+    if (typeof headers.get === 'function') {
+        return firstString(headers.get(REQUEST_ID_HEADER));
+    }
+    const record = headers;
+    return firstString(record[REQUEST_ID_HEADER]);
+}
+//# sourceMappingURL=request-id.js.map

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

@@ -0,0 +1,7 @@
+import type { ApiHost } from '../types.js';
+export declare function createRpcApiHost(options: {
+    baseUrl: string;
+    getToken: () => string | Promise<string>;
+    getRequestId?: () => string | undefined;
+}): ApiHost;
+//# sourceMappingURL=trpc-client.d.ts.map

package/dist/fn-context/rpc/trpc-client.js

@@ -0,0 +1,109 @@
+import { createTRPCClient, httpLink } from '@trpc/client';
+import { platformSurfaces } from '../../core/context/platform-registry.js';
+import { defaultHttpApi } from '../../core/context/http.js';
+import { integrationSurfaceKeys, } from '../../core/context/types.js';
+import { bindEnvService } from '../../core/context/env.js';
+import { REQUEST_ID_HEADER } from './request-id.js';
+function rpcLogger(c) {
+    const emit = (level, message, extra) => {
+        void c.log.emit.mutate({ level, message, extra }).catch(() => { });
+    };
+    return {
+        info: (message, extra) => emit('info', message, extra),
+        warn: (message, extra) => emit('warn', message, extra),
+        error: (message, extra) => emit('error', message, extra),
+    };
+}
+function rpcSafe(promise) {
+    return promise.catch((err) => {
+        if (err instanceof Error && err.constructor?.name === 'TRPCClientError') {
+            throw new Error(`RPC call failed: ${err.message}`);
+        }
+        throw err;
+    });
+}
+/**
+ * Builds the object a script sees at `ctx.api.integration.<surface>[i]`. The provider decides
+ * which methods exist and ships them in `meta.methods`, so this stays provider-agnostic; the
+ * declared surface type is what gives callers their static signatures.
+ */
+function stubSurface(c, meta) {
+    const methods = meta.methods.map((method) => [
+        method,
+        (params = {}) => rpcSafe(c.integration.invoke.mutate({ target: meta.target, method, params })),
+    ]);
+    const stub = {
+        target: meta.target,
+        name: meta.name,
+        credentials: meta.credentials,
+        config: meta.config,
+        ...Object.fromEntries(methods),
+    };
+    if (meta.surfaceKey === 'envs') {
+        return bindEnvService(stub);
+    }
+    return stub;
+}
+function buildSurfaces(c, metas) {
+    const surfaces = Object.fromEntries(integrationSurfaceKeys.map((key) => [key, []]));
+    for (const meta of metas) {
+        surfaces[meta.surfaceKey]?.push(stubSurface(c, meta));
+    }
+    // Both the key set and the element shapes come from IntegrationApi, but TS cannot follow
+    // that through the dynamic construction above.
+    return surfaces;
+}
+/**
+ * Every platform surface routes through one procedure, so the whole set is built from the
+ * registry's method tables rather than hand-wired call by call.
+ */
+function buildPlatformApis(c) {
+    const surfaces = Object.entries(platformSurfaces).map(([surface, spec]) => [
+        surface,
+        Object.fromEntries(Object.keys(spec.methods).map((method) => [
+            method,
+            (params = {}) => rpcSafe(c.platform.invoke.mutate({ surface, method, params })),
+        ])),
+    ]);
+    // The registry is what guarantees the shape; TS cannot follow it through Object.fromEntries.
+    return Object.fromEntries(surfaces);
+}
+export function createRpcApiHost(options) {
+    let client;
+    let lastBaseUrl;
+    function getClient(baseUrl) {
+        if (!client || lastBaseUrl !== baseUrl) {
+            client = createTRPCClient({
+                links: [
+                    httpLink({
+                        url: baseUrl,
+                        headers: async () => {
+                            const headers = {
+                                authorization: `Bearer ${await options.getToken()}`,
+                            };
+                            const requestId = options.getRequestId?.();
+                            if (requestId)
+                                headers[REQUEST_ID_HEADER] = requestId;
+                            return headers;
+                        },
+                    }),
+                ],
+            });
+            lastBaseUrl = baseUrl;
+        }
+        return client;
+    }
+    return {
+        async buildApi(_run) {
+            const c = getClient(options.baseUrl);
+            const metas = await rpcSafe(c.integration.listBindings.query());
+            return {
+                ...buildPlatformApis(c),
+                integration: buildSurfaces(c, metas),
+                log: rpcLogger(c),
+                http: defaultHttpApi(),
+            };
+        },
+    };
+}
+//# sourceMappingURL=trpc-client.js.map

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

@@ -0,0 +1,17 @@
+import type { RunScope } from '../types.js';
+export type RpcContext = {
+    run: RunScope;
+    requestId?: string;
+};
+export declare const router: import("@trpc/server").TRPCRouterBuilder<{
+    ctx: RpcContext;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}>;
+/**
+ * Applied to every procedure so domain errors reach the caller with the status they declared,
+ * without each dispatcher wrapping its own body in try/catch.
+ */
+export declare const publicProcedure: import("@trpc/server").TRPCProcedureBuilder<RpcContext, object, {}, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
+//# sourceMappingURL=trpc-init.d.ts.map