@teamscala/service-boot 0.23.284 → 0.23.286

package/src/discover-blocks.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @system ui-service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Surgical block discovery: at boot, queries every block_schema row in the
+ * registry whose componentPath starts with one of the service's declared
+ * block_packages, then dynamic-imports each one. Per-block try/catch — one
+ * dead componentPath logs and skips, the rest still register and the page
+ * renders the surviving blocks. This replaces the static
+ * `.scala-install/page-manifest.ts` codegen output, which had the failure
+ * mode of a single dead block_schema row crashing the whole manifest at
+ * compile time.
+ *
+ * Empty block_packages is NOT fatal here: it falls back to scanning all
+ * active block_schema (uninstalled packages skip via the per-block try/catch),
+ * so a service whose row is unpopulated but whose blocks are installed still
+ * renders. The real "booted with zero blocks" fail-closed is at the call site
+ * (loaded.length === 0 → BootFatalError). A DB-unreachable error still throws —
+ * no fallback to a package-side puckBlocks scan, which masked blockless boots.
+ */
+import type { RendererComponentEntry } from "./types.ts";
+export interface DiscoveredBlocks {
+    components: Record<string, RendererComponentEntry>;
+    loaded: string[];
+    skipped: string[];
+}
+export declare function discoverBlocks(blockPackages: string[]): Promise<DiscoveredBlocks>;

package/src/expand-roster.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @system server-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Server-side roster expansion — the executor that handles "render N of block X
+ * per data row" so the page never needs a domain-specific panel/list block. A
+ * block authored with `props.dataRepeat: "parties"` is a TEMPLATE; before SSR
+ * this clones it once per roster item into its parent slot (top-level content or
+ * any Container's `content` slot), then drops the marker. Each clone:
+ *   - sets `role` + `dataKey` to the item's key, so a prop-driven block (the
+ *     SignatureField cell) finds its own party with no per-clone wiring;
+ *   - substitutes `{{name}}` / `{{role}}` / `{{company}}` / `{{date}}` /
+ *     `{{status}}` placeholders in any string prop (so a recipient row is plain
+ *     `Container` + `Text` primitives — the copy lives on the page, not here).
+ *     `{{status}}` resolves from the template's own `signedLabel` /
+ *     `awaitingLabel` props (DB-driven copy), never hardcoded.
+ * Generic over any roster; the agreement page passes its parties.
+ */
+export interface RosterItem {
+    key: string;
+    role: string;
+    name: string;
+    title: string | null;
+    company: string | null;
+    signedAt: string | null;
+    signature: string | null;
+}
+/** Agreement-level tokens (one substitution, not per-party). */
+export interface RosterMeta {
+    [token: string]: string;
+}
+/** Expand roster templates + bind agreement-meta placeholders across regions. */
+export declare function expandRosterTemplates(resolved: Record<string, unknown>, parties: RosterItem[], meta?: RosterMeta): void;

package/src/fn-routers/agreement-completion-email.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Completion delivery. When an agreement is fully EXECUTED (every party has
+ * signed), email each party their executed copy + a note to download the
+ * Certificate of Completion. Each link is a per-party magic-link (no email gate,
+ * no OTP — see attach-agreement-magic.ts). Best-effort and self-contained: it
+ * loads its own data and swallows every error, so a send failure is logged and
+ * NEVER undoes the signature (the payment-setup non-fatal rule, applied to mail).
+ * Fire-and-forget from the sign handler: `void sendAgreementCompletionEmails(...)`.
+ */
+export declare function sendAgreementCompletionEmails(agreementId: string, baseUrl: string): Promise<void>;

package/src/fn-routers/agreement-send-router.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * fn.agreementSend.send — authenticated "send for signature" procedure. Emails
+ * each party of an agreement a link to its signing page, stamps the lifecycle
+ * (sent_to / sent_at, status draft→sent), and returns a per-recipient result.
+ *
+ * Off-the-shelf path per building-applications: this is server logic beyond
+ * CRUD, so it is a typed ORPC procedure (not a bespoke endpoint), and it sends
+ * through the shared Resend adapter (@teamscala/api-resend) — the same surface
+ * @teamscala/auth uses for OTP — never a new email integration.
+ *
+ * Per-org sender: emails go FROM the org's display name on the platform's
+ * verified Resend domain ("<Org> via Sign <verified-addr>"), with reply_to set
+ * to the org's contact_email, so replies reach the org without each org needing
+ * its own verified domain. When an org later verifies its own sending domain,
+ * resolveSender is the single place to switch the FROM address.
+ *
+ * Sending is privileged (it reaches real inboxes), so the procedure requires an
+ * authenticated caller — the localhost super-admin bypass authorises operator /
+ * portal-SSR callers; the public signing page cannot invoke it.
+ */
+import * as v from "valibot";
+interface User {
+    id: string;
+    organisationId: string | null;
+}
+interface Context {
+    user: User | null | undefined;
+    headers: Headers;
+    resolveUser?: (headers: Headers, prisma: any) => Promise<User | null>;
+    prisma: any;
+}
+export declare const agreementSendRouter: {
+    send: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<User | null>;
+        prisma: any;
+        user: User;
+    }>, v.ObjectSchema<{
+        readonly agreementId: v.StringSchema<undefined>;
+        /** Public base URL of the signing site, e.g. https://sign-dev.scala.business (no trailing slash). */
+        readonly baseUrl: v.StringSchema<undefined>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        ok: false;
+        error: string;
+        sentAt?: undefined;
+        url?: undefined;
+        sent?: undefined;
+    } | {
+        error?: undefined;
+        ok: boolean;
+        sentAt: string | null;
+        url: string;
+        sent: {
+            email: string;
+            ok: boolean;
+            id?: string;
+            error?: string;
+        }[];
+    }, {
+        ok: false;
+        error: string;
+        sentAt?: undefined;
+        url?: undefined;
+        sent?: undefined;
+    } | {
+        error?: undefined;
+        ok: boolean;
+        sentAt: string | null;
+        url: string;
+        sent: {
+            email: string;
+            ok: boolean;
+            id?: string;
+            error?: string;
+        }[];
+    }>, Record<never, never>, Record<never, never>>;
+};
+export {};

package/src/fn-routers/ai-health-router.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * `fn.aiHealth` — the AI-availability probe the shared chat hook
+ * (`useAIHealthCheck`) polls before showing the chat's health dot. It resolves
+ * the same DB-driven default model the chat engine uses (`ai-default-model`
+ * config → an active `llm_model` row) and reports `{status, mcp, gateway}`;
+ * `status:"ok"` means the chat has a usable model configured.
+ *
+ * Unauthed (a public GPT surface polls it too) and a LIGHTWEIGHT registry read
+ * via the request `prisma` — deliberately NO `@teamscala/chat-completion` import,
+ * so wiring this universal procedure never pulls the AI stack into every
+ * service. Registered into the `fn` namespace by registerFnRouters, so any
+ * chat-capable service answers it instead of 404-ing.
+ */
+interface Context {
+    prisma: {
+        registry_entries: {
+            findFirst: (args: unknown) => Promise<{
+                config?: unknown;
+                id?: string;
+            } | null>;
+        };
+    };
+}
+export interface AiHealthResponse {
+    status: "ok" | "error";
+    mcp: boolean;
+    gateway: boolean;
+    error?: string;
+}
+export declare const aiHealthHandler: import("@orpc/server").DecoratedProcedure<Context & Record<never, never>, Context, import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<AiHealthResponse, AiHealthResponse>, Record<never, never>, Record<never, never>>;
+export {};

package/src/fn-routers/auth-router.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * ORPC procedures for auth checks (isOrgAdmin, resolveAdminOverride).
+ * Extracted from @teamscala/orpc/fn-router — primitives tier must not
+ * contain application-specific auth logic.
+ */
+interface User {
+    id: string;
+    name?: string | null;
+    email?: string;
+    organisationId: string | null;
+}
+interface Context {
+    user: User | null | undefined;
+    headers: Headers;
+    resolveUser?: (headers: Headers, prisma: any) => Promise<User | null>;
+    prisma: any;
+    orgId?: string | null;
+}
+declare const authed: import("@orpc/server").BuilderWithMiddlewares<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+    headers: Headers;
+    resolveUser?: (headers: Headers, prisma: any) => Promise<User | null>;
+    prisma: any;
+    user: User;
+    orgId: string | null | undefined;
+}>, import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<unknown, unknown>, Record<never, never>, Record<never, never>>;
+export declare const authRouter: {
+    isOrgAdmin: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<User | null>;
+        prisma: any;
+        user: User;
+        orgId: string | null | undefined;
+    }>, import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<boolean, boolean>, Record<never, never>, Record<never, never>>;
+    resolveAdminOverride: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<User | null>;
+        prisma: any;
+        user: User;
+        orgId: string | null | undefined;
+    }>, import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<string | null, string | null>, Record<never, never>, Record<never, never>>;
+};
+export type { Context, User };
+export { authed };

package/src/fn-routers/cache-admin-router.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * `fn.cacheAdmin` — ORPC procedures for in-process cache enable/disable/flush.
+ * Replaces the former `/api/data/cache-monitor/*` HANDLER_MAP entries
+ * (orpc-is-the-only-api: every API surface is a typed ORPC procedure, never a
+ * hand-written Hono route). Calls through @teamscala/cache/registry — the
+ * platform-singleton cache surface (cache-is-the-only-cache).
+ */
+import * as v from "valibot";
+export declare const cacheAdminRouter: {
+    enable: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("./auth-router.ts").Context & Record<never, never>, import("./auth-router.ts").Context, import("./auth-router.ts").Context>, import("@orpc/server").MergedCurrentContext<import("./auth-router.ts").Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, v.ObjectSchema<{
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        ok: boolean;
+        name: string;
+    }, {
+        ok: boolean;
+        name: string;
+    }>, Record<never, never>, Record<never, never>>;
+    disable: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("./auth-router.ts").Context & Record<never, never>, import("./auth-router.ts").Context, import("./auth-router.ts").Context>, import("@orpc/server").MergedCurrentContext<import("./auth-router.ts").Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, v.ObjectSchema<{
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        ok: boolean;
+        name: string;
+    }, {
+        ok: boolean;
+        name: string;
+    }>, Record<never, never>, Record<never, never>>;
+    flush: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("./auth-router.ts").Context & Record<never, never>, import("./auth-router.ts").Context, import("./auth-router.ts").Context>, import("@orpc/server").MergedCurrentContext<import("./auth-router.ts").Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, v.ObjectSchema<{
+        readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        flushed: any;
+    }, {
+        flushed: any;
+    }>, Record<never, never>, Record<never, never>>;
+};

package/src/fn-routers/chat-session-router.d.ts

@@ -0,0 +1,219 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * ORPC procedures for the AUTHENTICATED AI-chat conversation lifecycle —
+ * the org+user-keyed sibling of publicGptSessionRouter (which is contact-
+ * linked for anonymous public GPT visitors). One signed-in user chatting
+ * with one agent in one org owns a thread of `conversations` rows; this
+ * router createOrRestore-s the active one, saves turns, archives+news on
+ * clear, lists past threads, and loads a specific thread.
+ *
+ * Identity: the USER is resolved from the ORPC session context (`authed`
+ * middleware → `context.user.id`); the ORGANISATION is supplied by the
+ * client (it is the URL :orgId for org-scoped apps like scala-projects —
+ * the session does not carry it) and VERIFIED — the caller must be a
+ * member of that organisation, else FORBIDDEN. A caller cannot read or
+ * write another user's threads (ownership is user_id) or another org's
+ * (createOrRestore/list are membership-scoped to the supplied org).
+ *
+ * This restores the capability the portal AI chat lost when the June
+ * chat-engine migration severed `usePortalConversationId` + the
+ * `portalConversation` router (capability-named `chatSession` here per
+ * name-by-capability; the host-named orphan was deleted in the same change).
+ *
+ * Persistence model: the chat client owns writes via onMessagesPersist →
+ * saveMessages, and sends clientPersists:true so handle-chat-stream skips its
+ * own persistChatRun (single writer, no double-persist). Verbatim UIMessage
+ * parts are stored in messages.channel_data.parts so multi-step (tool-using)
+ * turns round-trip losslessly (apps/chat.md messages-stored-as-uimessage-verbatim).
+ */
+import * as v from "valibot";
+import { type Context } from "./auth-router.ts";
+export declare const chatSessionRouter: {
+    createOrRestore: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, v.ObjectSchema<{
+        readonly agentId: v.StringSchema<undefined>;
+        readonly organisationId: v.StringSchema<undefined>;
+        /**
+         * SSR-only: the real user's id, passed by the AiChat serverLoader. The
+         * in-process server client is system-authed (context.user.id === "system"),
+         * so without this the conversation is created under user_id="system" and
+         * the real user's saveMessages hits assertOwns → FORBIDDEN. Only honoured
+         * when the caller is the system user (server-side SSR), never from a
+         * client-side ORPC call.
+         */
+        readonly userId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        conversationId: any;
+        model: any;
+        messages: {
+            id: any;
+            role: any;
+            content: any;
+            parts: unknown[] | undefined;
+            metadata: Record<string, unknown> | undefined;
+            created_at: any;
+            occurred_at: any;
+        }[];
+        tokenTotals: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+        hasMore: boolean;
+    }, {
+        conversationId: any;
+        model: any;
+        messages: {
+            id: any;
+            role: any;
+            content: any;
+            parts: unknown[] | undefined;
+            metadata: Record<string, unknown> | undefined;
+            created_at: any;
+            occurred_at: any;
+        }[];
+        tokenTotals: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+        hasMore: boolean;
+    }>, Record<never, never>, Record<never, never>>;
+    loadEarlier: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, v.ObjectSchema<{
+        readonly conversationId: v.StringSchema<undefined>;
+        /** Cursor: the occurred_at (ISO) of the oldest currently-loaded message. */
+        readonly before: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        /** Cap; defaults to RECENT_MESSAGE_LIMIT, clamped to it. */
+        readonly limit: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        messages: {
+            id: any;
+            role: any;
+            content: any;
+            parts: unknown[] | undefined;
+            metadata: Record<string, unknown> | undefined;
+            created_at: any;
+            occurred_at: any;
+        }[];
+        hasMore: boolean;
+    }, {
+        messages: {
+            id: any;
+            role: any;
+            content: any;
+            parts: unknown[] | undefined;
+            metadata: Record<string, unknown> | undefined;
+            created_at: any;
+            occurred_at: any;
+        }[];
+        hasMore: boolean;
+    }>, Record<never, never>, Record<never, never>>;
+    saveMessages: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, v.ObjectSchema<{
+        readonly conversationId: v.StringSchema<undefined>;
+        readonly messages: v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly role: v.StringSchema<undefined>;
+            readonly content: v.StringSchema<undefined>;
+            readonly parts: v.OptionalSchema<v.ArraySchema<v.AnySchema, undefined>, undefined>;
+            readonly metadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        success: boolean;
+    }, {
+        success: boolean;
+    }>, Record<never, never>, Record<never, never>>;
+    clear: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, v.ObjectSchema<{
+        readonly conversationId: v.StringSchema<undefined>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        conversationId: any;
+        messages: never[];
+        tokenTotals: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+    }, {
+        conversationId: any;
+        messages: never[];
+        tokenTotals: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+    }>, Record<never, never>, Record<never, never>>;
+    list: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, v.ObjectSchema<{
+        readonly agentId: v.StringSchema<undefined>;
+        readonly organisationId: v.StringSchema<undefined>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        conversations: any;
+    }, {
+        conversations: any;
+    }>, Record<never, never>, Record<never, never>>;
+    load: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, v.ObjectSchema<{
+        readonly conversationId: v.StringSchema<undefined>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        conversationId: any;
+        messages: {
+            id: any;
+            role: any;
+            content: any;
+            parts: unknown[] | undefined;
+            metadata: Record<string, unknown> | undefined;
+            created_at: any;
+            occurred_at: any;
+        }[];
+        tokenTotals: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+    }, {
+        conversationId: any;
+        messages: {
+            id: any;
+            role: any;
+            content: any;
+            parts: unknown[] | undefined;
+            metadata: Record<string, unknown> | undefined;
+            created_at: any;
+            occurred_at: any;
+        }[];
+        tokenTotals: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+    }>, Record<never, never>, Record<never, never>>;
+};

package/src/fn-routers/email-defaults.d.ts

@@ -0,0 +1 @@
+export declare function getDefaultEmailSender(): Promise<string>;

package/src/fn-routers/email-link-ttl.d.ts

@@ -0,0 +1 @@
+export declare function getEmailLinkTtlMs(): Promise<number>;

package/src/fn-routers/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Composes auth, tasks, work-items, plans, chat-session, public-gpt-session,
+ * public-agreement, and user-preferences routers into the `fn` namespace and
+ * registers it via registerCustomRouter.
+ * Called at boot by registerFnRouters() — invoked before any ORPC dispatch.
+ *
+ * Also exposes the `regions` namespace on the client /api/rpc mount: a single
+ * `loadPage` procedure (reusing puckPagesRouter.loadFromWebsite) so a client
+ * RegionPageSwap can fetch a region's Puck page on demand and render it into a
+ * slot — the no-reload half of `region-views-are-pages` (every region is a Puck
+ * page; switching a view loads a different page's content). loadById is NOT
+ * exposed (website+path is the client-facing contract, not raw page ids).
+ */
+export declare function registerFnRouters(): void;

package/src/fn-routers/panel-data-router.d.ts

@@ -0,0 +1,19 @@
+import * as v from "valibot";
+interface Context {
+    prisma: {
+        builda_websites: {
+            findFirst: (args: unknown) => Promise<{
+                organisation_id?: string | null;
+            } | null>;
+        };
+    };
+}
+export declare const resolvePanelDataHandler: import("@orpc/server").DecoratedProcedure<Context & Record<never, never>, Context, v.ObjectSchema<{
+    readonly panelSlug: v.StringSchema<undefined>;
+    readonly websiteSlug: v.StringSchema<undefined>;
+    /** Tenant orgId (preferred over the website's organisation_id, which is
+     * the platform org on a multi-tenant portal — not the tenant). The
+     * caller (RegionPageSwap) threads this from __PAGE_DATA__.orgId. */
+    readonly orgId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, import("@orpc/contract").Schema<Record<string, unknown> | null, Record<string, unknown> | null>, Record<never, never>, Record<never, never>>;
+export {};

package/src/fn-routers/persist-chat-messages.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * The ONE chat-message write surface for the session routers. Both the authed
+ * (chatSession) and public (publicGptSession) saveMessages procedures persist
+ * turns through here — they differ only in IDENTITY/ownership (user_id vs
+ * contact_email, resolved in the router before calling this), never in the
+ * write itself. Keeping the write in two routers was literal duplication
+ * (no-duplicate-canonical-units) and is why the stable-id fix had to be applied
+ * twice.
+ *
+ * Upserts each message on its SDK UIMessage id so a re-save of a turn (a retry,
+ * a reconnect after a network drop, or a stray dual-write) updates the one row
+ * in place instead of inserting a duplicate (chat-message-ids-server-stable);
+ * falls back to create only for legacy id-less callers. occurred_at is stamped
+ * with a 1ms step preserving array order so same-second saves restore in order.
+ */
+export interface ChatMessageInput {
+    id?: string;
+    role: string;
+    content: string;
+    parts?: unknown[];
+    /** The SDK UIMessage `metadata` — carries per-message token usage
+     * (`inputTokens`/`outputTokens`/`contextWindow`/`model`) the stream attaches
+     * via `messageMetadata`. Persisted so the context-usage gauge can rehydrate
+     * on reload and budget-enforcement can read per-message token counts; without
+     * it the save dropped the usage and the gauge came back blank on refresh. */
+    metadata?: Record<string, unknown> | null;
+}
+export declare function persistChatMessages(prisma: any, opts: {
+    conversationId: string;
+    organisationId: string | null;
+    messages: ChatMessageInput[];
+}): Promise<void>;

package/src/fn-routers/plans-router.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * ORPC procedures for plan creation with tasks and subtasks.
+ * Extracted from @teamscala/orpc/fn-router — primitives tier must not
+ * contain application-specific work_items logic.
+ */
+import { type Context } from "./auth-router.ts";
+export declare const plansRouter: {
+    save: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<{
+        success: boolean;
+        data: any;
+    }, {
+        success: boolean;
+        data: any;
+    }>, Record<never, never>, Record<never, never>>;
+};