@camstack/server 1.2.594 → 1.2.595

package/dist/api/trpc/cap-mount-helpers.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Small helpers for wiring capability routers to the `CapabilityRegistry`
  * in `trpc.router.ts`. These functions don't generate code — they just
@@ -15,16 +16,20 @@
  * provider responsible for a given `streamId`) are NOT covered here —
  * they have app-specific routing logic that belongs in the mount.
  */
-import { TRPCError } from '@trpc/server';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireSingleton = requireSingleton;
+exports.requireDeviceScoped = requireDeviceScoped;
+exports.concatCollection = concatCollection;
+const server_1 = require("@trpc/server");
 /**
  * Fetch the currently active singleton provider for a capability.
  * Returns null if no provider is registered; the downstream codegen'd
  * router surfaces this as `PRECONDITION_FAILED` to the caller.
  */
-export function requireSingleton(registry, capName) {
+function requireSingleton(registry, capName) {
     return registry?.getSingleton(capName) ?? null;
 }
-export function requireDeviceScoped(registry, capName) {
+function requireDeviceScoped(registry, capName) {
     if (!registry)
         return null;
     // The Proxy is the singleton stand-in. Each property access returns
@@ -38,7 +43,7 @@ export function requireDeviceScoped(registry, capName) {
             return async (input) => {
                 const deviceId = input?.deviceId;
                 if (typeof deviceId !== 'number') {
-                    throw new TRPCError({
+                    throw new server_1.TRPCError({
                         code: 'BAD_REQUEST',
                         message: `${String(capName)}.${prop}: input must carry numeric "deviceId"`,
                     });
@@ -61,14 +66,14 @@ export function requireDeviceScoped(registry, capName) {
                     // cap with no provider at all still answered. Wiring was deleted on
                     // 2026-08-08 — a composed device's caps are native to it, so there
                     // is nothing to conjure and the honest answer is the error.
-                    throw new TRPCError({
+                    throw new server_1.TRPCError({
                         code: 'PRECONDITION_FAILED',
                         message: `Capability "${String(capName)}" not registered for device ${deviceId}`,
                     });
                 }
                 const fn = provider[prop];
                 if (typeof fn !== 'function') {
-                    throw new TRPCError({
+                    throw new server_1.TRPCError({
                         code: 'NOT_IMPLEMENTED',
                         message: `Capability "${String(capName)}" provider for device ${deviceId} does not implement "${prop}"`,
                     });
@@ -88,7 +93,7 @@ export function requireDeviceScoped(registry, capName) {
  * and concatenates their array results. Useful for contribution-style
  * caps where each provider adds to a shared pool.
  */
-export function concatCollection(providers, method) {
+function concatCollection(providers, method) {
     const wrapper = async (...args) => {
         const results = await Promise.all(providers.map(async (p) => {
             const member = Reflect.get(p, method);

package/dist/api/trpc/cap-route-error-formatter.js

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTrpcError = formatTrpcError;
 /**
  * tRPC error formatter that serializes CapRouteError diagnostic fields
  * across the server→client boundary.
@@ -13,8 +16,8 @@
  *
  * The formatter is EXPORTED for unit testing (no side-effects, pure function).
  */
-import { CapRouteError, getCatalogRegistry, SERVER_NAMESPACE } from '@camstack/system';
-import { DEFAULT_CATALOG_LANG, interpolate, readErrorI18n, } from '@camstack/types';
+const system_1 = require("@camstack/system");
+const types_1 = require("@camstack/types");
 // ---------------------------------------------------------------------------
 // Type guards
 // ---------------------------------------------------------------------------
@@ -54,7 +57,7 @@ function extractCapRouteError(err) {
     for (let depth = 0; depth < 8; depth++) {
         if (current === null || current === undefined)
             return null;
-        if (current instanceof CapRouteError) {
+        if (current instanceof system_1.CapRouteError) {
             return current;
         }
         // Duck-type fallback: err.name + err.reason field present
@@ -81,7 +84,7 @@ function extractCapRouteError(err) {
                 const rawCapName = Reflect.get(current, 'capName');
                 const capName = typeof rawCapName === 'string' ? rawCapName : '(unknown)';
                 // Build a minimal object with the same shape — enough for the formatter.
-                const synthetic = Object.assign(new CapRouteError(capName, undefined, {
+                const synthetic = Object.assign(new system_1.CapRouteError(capName, undefined, {
                     reason,
                     rejected,
                     ...(typeof nodeId === 'string' ? { nodeId } : {}),
@@ -107,7 +110,7 @@ function extractCapRouteError(err) {
  * when the thrown error (or any error in its `.cause` chain) is a CapRouteError.
  * Returns the shape unchanged for all other errors.
  */
-export function formatTrpcError(opts) {
+function formatTrpcError(opts) {
     return withErrorI18n(opts, withCapRouteData(opts));
 }
 /**
@@ -117,16 +120,16 @@ export function formatTrpcError(opts) {
  * unknown code and English all pass through with the original message.
  */
 function withErrorI18n(opts, shape) {
-    const coded = readErrorI18n(opts.error);
+    const coded = (0, types_1.readErrorI18n)(opts.error);
     if (coded === null)
         return shape;
-    const lang = opts.ctx?.lang ?? DEFAULT_CATALOG_LANG;
-    const text = lang === DEFAULT_CATALOG_LANG
+    const lang = opts.ctx?.lang ?? types_1.DEFAULT_CATALOG_LANG;
+    const text = lang === types_1.DEFAULT_CATALOG_LANG
         ? undefined
-        : getCatalogRegistry().lookup(lang, SERVER_NAMESPACE, coded.code);
+        : (0, system_1.getCatalogRegistry)().lookup(lang, system_1.SERVER_NAMESPACE, coded.code);
     return {
         ...shape,
-        ...(text !== undefined ? { message: interpolate(text, coded.params) } : {}),
+        ...(text !== undefined ? { message: (0, types_1.interpolate)(text, coded.params) } : {}),
         data: { ...shape.data, i18n: coded },
     };
 }

package/dist/api/trpc/cap-router-runtime.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Server-side glue for the runtime cap-router builder (BIG PLAN 2).
  *
@@ -18,33 +19,43 @@
  * supplies `server-provided` provider factories (incl. webrtc-session) via the
  * `serverProviders` map — no hand-written cap-router override remains.
  */
-import { ALL_CAPABILITY_DEFINITIONS, buildCapRouters, isArrayOutputSchema, } from '@camstack/system';
-import { PROVIDER_PIN_FIELD, resolveCapMount, } from '@camstack/types';
-import { TRPCError } from '@trpc/server';
-import { requireDeviceScoped } from './cap-mount-helpers.js';
-import { requireDeviceCollection } from './device-collection-dispatch.js';
-import { adminProcedure, iterableSubscription, protectedProcedure, publicProcedure, trpcRouter, } from './trpc.middleware.js';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COLLECTION_ARRAY_METHODS = void 0;
+exports.aggregateCollectionCall = aggregateCollectionCall;
+exports.devicePinOf = devicePinOf;
+exports.pinnedDeviceCollectionCall = pinnedDeviceCollectionCall;
+exports.addonPinOf = addonPinOf;
+exports.pinnedCollectionCall = pinnedCollectionCall;
+exports.createCapRouterPrimitives = createCapRouterPrimitives;
+exports.createCapRouterServices = createCapRouterServices;
+exports.buildRuntimeCapRouters = buildRuntimeCapRouters;
+const system_1 = require("@camstack/system");
+const types_1 = require("@camstack/types");
+const server_1 = require("@trpc/server");
+const cap_mount_helpers_js_1 = require("./cap-mount-helpers.js");
+const device_collection_dispatch_js_1 = require("./device-collection-dispatch.js");
+const trpc_middleware_js_1 = require("./trpc.middleware.js");
 /**
  * Pre-computed set of capName → array-output method names for collection
  * caps, derived once from the cap defs at module init. Mirrors
  * `generate-cap-mounts.ts` `isArrayOutputSchema` so the runtime collection
  * resolver fans the SAME methods the codegen used to.
  */
-export const COLLECTION_ARRAY_METHODS = computeArrayMethods();
+exports.COLLECTION_ARRAY_METHODS = computeArrayMethods();
 function computeArrayMethods() {
     const out = new Map();
-    for (const def of ALL_CAPABILITY_DEFINITIONS) {
+    for (const def of system_1.ALL_CAPABILITY_DEFINITIONS) {
         // The effective MOUNT, never `mode`: a device-scoped wrapper collection
         // (`videoclips`, D554) fans over ONE DEVICE's sources through the
         // per-device dispatcher, and must never be fanned globally here.
-        if (resolveCapMount(def).kind !== 'collection')
+        if ((0, types_1.resolveCapMount)(def).kind !== 'collection')
             continue;
         const names = [];
         for (const [name, schema] of Object.entries(def.methods)) {
             const m = schema;
             if (m.kind === 'subscription')
                 continue;
-            if (isArrayOutputSchema(m.output))
+            if ((0, system_1.isArrayOutputSchema)(m.output))
                 names.push(name);
         }
         if (names.length > 0)
@@ -66,7 +77,7 @@ function computeArrayMethods() {
  */
 function isGlobalCollection(reg, capName) {
     const def = reg.getDefinition(capName);
-    return def !== undefined && resolveCapMount(def).kind === 'collection';
+    return def !== undefined && (0, types_1.resolveCapMount)(def).kind === 'collection';
 }
 /**
  * Resolve a collection cap's provider exactly as the codegen-emitted
@@ -92,7 +103,7 @@ function resolveCollectionProvider(reg, capName, addonId) {
     const first = providers[0];
     if (first === undefined)
         return null;
-    const arrayMethods = COLLECTION_ARRAY_METHODS.get(capName);
+    const arrayMethods = exports.COLLECTION_ARRAY_METHODS.get(capName);
     if (!arrayMethods || arrayMethods.length === 0)
         return first;
     const aggregate = { ...first };
@@ -117,12 +128,12 @@ function resolveCollectionProvider(reg, capName, addonId) {
  * `null` on zero providers too: that is the empty-collection fast-path's job
  * (it answers `[]` without routing), not this one's.
  */
-export async function aggregateCollectionCall(reg, capName, method, args) {
+async function aggregateCollectionCall(reg, capName, method, args) {
     if (!reg)
         return null;
     if (!isGlobalCollection(reg, capName))
         return null;
-    if (!COLLECTION_ARRAY_METHODS.get(capName)?.includes(method))
+    if (!exports.COLLECTION_ARRAY_METHODS.get(capName)?.includes(method))
         return null;
     if (reg.getCollectionEntries(capName).length === 0)
         return null;
@@ -146,7 +157,7 @@ function isDeviceCollection(reg, capName) {
     const def = reg.getDefinition(capName);
     if (def === undefined)
         return false;
-    return def.mode === 'collection' && resolveCapMount(def).kind === 'device-scoped';
+    return def.mode === 'collection' && (0, types_1.resolveCapMount)(def).kind === 'device-scoped';
 }
 /**
  * The `{ provider }` a DEVICE-collection call pins to, or `null`.
@@ -173,7 +184,7 @@ function isDeviceCollection(reg, capName) {
  * is required on `listClips` too (D554), and the narrowing happens inside
  * `requireDeviceCollection`, which then decides fan-out vs scalar itself.
  */
-export function devicePinOf(reg, capName, args) {
+function devicePinOf(reg, capName, args) {
     if (!reg)
         return null;
     if (!isDeviceCollection(reg, capName))
@@ -183,7 +194,7 @@ export function devicePinOf(reg, capName, args) {
     const rec = args;
     if (typeof rec['deviceId'] !== 'number')
         return null;
-    const pin = rec[PROVIDER_PIN_FIELD];
+    const pin = rec[types_1.PROVIDER_PIN_FIELD];
     return typeof pin === 'string' && pin.length > 0 ? pin : null;
 }
 /**
@@ -199,10 +210,10 @@ export function devicePinOf(reg, capName, args) {
  * legitimately answer `null`, which a bare return could not tell from "not
  * handled".
  */
-export async function pinnedDeviceCollectionCall(reg, capName, method, args) {
+async function pinnedDeviceCollectionCall(reg, capName, method, args) {
     if (devicePinOf(reg, capName, args) === null)
         return null;
-    const dispatcher = requireDeviceCollection(reg, capName);
+    const dispatcher = (0, device_collection_dispatch_js_1.requireDeviceCollection)(reg, capName);
     if (dispatcher === null)
         return null;
     const fn = dispatcher[method];
@@ -228,12 +239,12 @@ export async function pinnedDeviceCollectionCall(reg, capName, method, args) {
  * (there `addonId` is provider DATA: `addons.getLogs({addonId})` names the addon
  * whose logs you want, it does not name a provider).
  */
-export function addonPinOf(reg, capName, method, args) {
+function addonPinOf(reg, capName, method, args) {
     if (!reg)
         return null;
     if (!isGlobalCollection(reg, capName))
         return null;
-    if (COLLECTION_ARRAY_METHODS.get(capName)?.includes(method) === true)
+    if (exports.COLLECTION_ARRAY_METHODS.get(capName)?.includes(method) === true)
         return null;
     if (args === null || typeof args !== 'object' || Array.isArray(args))
         return null;
@@ -279,7 +290,7 @@ export function addonPinOf(reg, capName, method, args) {
  * Returns a `{ value }` box, never the bare result: `getBrokerConfig` answers
  * `null` legitimately, so a bare `null` could not be told from "not handled".
  */
-export async function pinnedCollectionCall(reg, capName, method, args) {
+async function pinnedCollectionCall(reg, capName, method, args) {
     const addonId = addonPinOf(reg, capName, method, args);
     if (addonId === null)
         return null;
@@ -316,11 +327,11 @@ function concatArrayMethod(providers, method) {
     };
 }
 /** Build the `primitives` half of `buildCapRouters(primitives, services)`. */
-export function createCapRouterPrimitives() {
+function createCapRouterPrimitives() {
     const procedures = {
-        public: publicProcedure,
-        protected: protectedProcedure,
-        admin: adminProcedure,
+        public: trpc_middleware_js_1.publicProcedure,
+        protected: trpc_middleware_js_1.protectedProcedure,
+        admin: trpc_middleware_js_1.adminProcedure,
     };
     return {
         // Documented type boundary: the builder hands a record of REAL tRPC
@@ -329,13 +340,13 @@ export function createCapRouterPrimitives() {
         // `CreateRouterOptions`; the runtime values satisfy it. Narrow at this
         // single seam so the rest of the builder stays free of `@trpc/server`
         // internal types — mirrors the existing `remoteCapProxy` cast pattern.
-        router: (procs) => trpcRouter(procs),
+        router: (procs) => (0, trpc_middleware_js_1.trpcRouter)(procs),
         procedures,
-        iterableSubscription,
+        iterableSubscription: trpc_middleware_js_1.iterableSubscription,
     };
 }
 /** Build the `services` half of `buildCapRouters(primitives, services)`. */
-export function createCapRouterServices(deps) {
+function createCapRouterServices(deps) {
     const reg = deps.capabilityRegistry;
     const remoteProxy = (capName, nodeId) => deps.moleculer.createCapabilityProxy(capName, nodeId);
     const getLocalProvider = (capName, mountKind, ctx, addonId) => {
@@ -364,9 +375,9 @@ export function createCapRouterServices(deps) {
                 // collection twin fans the array methods over the device's sources and
                 // routes the scalar ones by the source inside the id.
                 if (reg?.getMode(capName) === 'collection') {
-                    return requireDeviceCollection(reg, capName, deps.logger);
+                    return (0, device_collection_dispatch_js_1.requireDeviceCollection)(reg, capName, deps.logger);
                 }
-                return requireDeviceScoped(reg, capName);
+                return (0, cap_mount_helpers_js_1.requireDeviceScoped)(reg, capName);
             }
             case 'collection':
                 return resolveCollectionProvider(reg, capName, addonId);
@@ -401,7 +412,7 @@ export function createCapRouterServices(deps) {
             tags: { addonId },
             meta: { capability: capName, validAddonIds: [...known] },
         });
-        throw new TRPCError({
+        throw new server_1.TRPCError({
             code: 'BAD_REQUEST',
             message: `Capability "${capName}" has no provider with addonId "${addonId}". ` +
                 `Valid addonId(s): ${known.join(', ')}. ` +
@@ -414,30 +425,30 @@ export function createCapRouterServices(deps) {
         rejectUnresolvedAddonPin,
         noProvider: (capName, nodeId) => {
             if (nodeId !== undefined && nodeId !== 'hub') {
-                throw new TRPCError({
+                throw new server_1.TRPCError({
                     code: 'PRECONDITION_FAILED',
                     message: `Capability "${capName}" not available on node "${nodeId}"`,
                 });
             }
-            throw new TRPCError({
+            throw new server_1.TRPCError({
                 code: 'PRECONDITION_FAILED',
                 message: `Capability "${capName}" provider not available`,
             });
         },
         noNodeRouting: (capName) => {
-            throw new TRPCError({
+            throw new server_1.TRPCError({
                 code: 'BAD_REQUEST',
                 message: `Node routing not available for "${capName}"`,
             });
         },
         badRequest: (message) => {
-            throw new TRPCError({ code: 'BAD_REQUEST', message });
+            throw new server_1.TRPCError({ code: 'BAD_REQUEST', message });
         },
         // D-1 caller-identity injection: a `caller: 'required'` method whose
         // context carries no authenticated user fails closed — the builder
         // never fabricates an identity.
         unauthorized: (message) => {
-            throw new TRPCError({ code: 'UNAUTHORIZED', message });
+            throw new server_1.TRPCError({ code: 'UNAUTHORIZED', message });
         },
         // Task 7.5d: a resolved provider that does not implement `method` must
         // fail, not answer `undefined` (200). NOT_IMPLEMENTED mirrors what
@@ -445,7 +456,7 @@ export function createCapRouterServices(deps) {
         // child plane — the hub previously answered silently where the child
         // already throws.
         methodNotFound: (capName, method) => {
-            throw new TRPCError({
+            throw new server_1.TRPCError({
                 code: 'NOT_IMPLEMENTED',
                 message: `Capability "${capName}" has no method "${method}"`,
             });
@@ -459,6 +470,6 @@ export function createCapRouterServices(deps) {
  * boundary so the AppRouter TYPE stays codegen-derived while the VALUE is
  * built at runtime from `ALL_CAPABILITY_DEFINITIONS`.
  */
-export function buildRuntimeCapRouters(deps) {
-    return buildCapRouters(createCapRouterPrimitives(), createCapRouterServices(deps));
+function buildRuntimeCapRouters(deps) {
+    return (0, system_1.buildCapRouters)(createCapRouterPrimitives(), createCapRouterServices(deps));
 }

package/dist/api/trpc/client-ip.js

@@ -1,3 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractClientIp = extractClientIp;
+exports.extractCfConnectingIp = extractCfConnectingIp;
+exports.extractPeerIp = extractPeerIp;
+exports.extractUserAgent = extractUserAgent;
+exports.ipClass = ipClass;
+exports.classifyClient = classifyClient;
+exports.classifyClientRequest = classifyClientRequest;
+exports.deriveRelayOnly = deriveRelayOnly;
+exports.isRemoteClientIp = isRemoteClientIp;
 /**
  * Best-effort extraction of the originating client IP from a tRPC
  * request. Order of preference:
@@ -11,7 +22,7 @@
  * calls that carry no HTTP request) — the caller treats `null` as "not
  * remote" so the LAN/direct path stays the safe default.
  */
-export function extractClientIp(req) {
+function extractClientIp(req) {
     if (!req)
         return null;
     // 1. X-Forwarded-For — comma-separated list, client is the FIRST entry.
@@ -47,7 +58,7 @@ export function extractClientIp(req) {
  * direct internet client that forges the header still classifies by its own
  * (remote) peer address. Returns `null` when absent.
  */
-export function extractCfConnectingIp(req) {
+function extractCfConnectingIp(req) {
     if (!req)
         return null;
     const raw = req.headers['cf-connecting-ip'];
@@ -63,7 +74,7 @@ export function extractCfConnectingIp(req) {
  * loopback/LAN peer (the local `cloudflared` connector). Returns `null` when
  * no socket is present (mesh-originated calls).
  */
-export function extractPeerIp(req) {
+function extractPeerIp(req) {
     if (!req)
         return null;
     const remote = req.socket?.remoteAddress;
@@ -80,7 +91,7 @@ export function extractPeerIp(req) {
  * subscriber's broker attribution with the viewer's UA — the SERVER reads
  * it from the request context; any client-supplied value is ignored.
  */
-export function extractUserAgent(req) {
+function extractUserAgent(req) {
     if (!req)
         return null;
     const ua = req.headers['user-agent'];
@@ -107,7 +118,7 @@ function normalizeIp(ip) {
  * Classify a single already-normalised IP literal. Null / unparseable →
  * `'lan'` (the safe default that keeps the low-latency direct path).
  */
-export function ipClass(ip) {
+function ipClass(ip) {
     if (!ip)
         return 'lan';
     if (ip.includes(':')) {
@@ -138,7 +149,7 @@ export function ipClass(ip) {
  * header is ignored (a direct internet client could forge it) and we classify
  * by the proxy-resolved `clientIp`.
  */
-export function classifyClient(args) {
+function classifyClient(args) {
     if (args.peerIsLocal && args.cfConnectingIp)
         return ipClass(args.cfConnectingIp);
     return ipClass(args.clientIp);
@@ -149,7 +160,7 @@ export function classifyClient(args) {
  * than forcing a policy. Composes `extractClientIp` (proxy-aware), the
  * `CF-Connecting-IP` header, and the immediate socket peer (CF trust gate).
  */
-export function classifyClientRequest(req) {
+function classifyClientRequest(req) {
     if (!req)
         return null;
     const clientIp = extractClientIp(req);
@@ -167,7 +178,7 @@ export function classifyClientRequest(req) {
  *                        direct overlay host pair; forcing TURN would be worse).
  *   - `lan`    → false (low-latency direct host/srflx path).
  */
-export function deriveRelayOnly(clientClass) {
+function deriveRelayOnly(clientClass) {
     return clientClass === 'remote';
 }
 /**
@@ -177,7 +188,7 @@ export function deriveRelayOnly(clientClass) {
  * (`'vpn'`) is NOT remote (kept on the direct overlay path). Unparseable /
  * null → false (safe LAN default).
  */
-export function isRemoteClientIp(ip) {
+function isRemoteClientIp(ip) {
     return ipClass(ip) === 'remote';
 }
 function isIpv4(ip) {