orpc-fn 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hans Kristoffer Hansen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,250 @@
+# orpc-fn
+
+Define a backend function once. You get a typed [oRPC](https://orpc.dev) procedure with tracing, structured logging, guards, handler extras from your app, nested calls that keep the context, and optional live queries over Redis. Adapters expose the same procedure as a Mastra tool, an MCP tool, or a route on Hono, and the client helpers call it from Vue, React or Expo.
+
+Your app keeps everything app-specific: auth and session, context shape, database, queues, i18n, feature flags and permissions. You inject them once with `createFn`.
+
+```sh
+bun add orpc-fn @orpc/server @orpc/contract @orpc/client zod
+```
+
+ESM only, Node 20+ or Bun, TypeScript 5.7+, oRPC 1.14+ (`@orpc/client` is already a dependency of `@orpc/server`), Zod 4. Optional peers per subpath are listed below.
+
+## 30 seconds
+
+```ts
+// lib/fn.ts — once per app
+import { ORPCError, os } from '@orpc/server'
+import * as otel from '@opentelemetry/api'
+import { createFn } from 'orpc-fn'
+
+const publicProcedure = os.$context<{ headers: Headers; user?: User }>()
+const protectedProcedure = publicProcedure.use(({ context, next }) => {
+  if (!context.user) throw new ORPCError('UNAUTHORIZED')
+  return next({ context: { user: context.user } })
+})
+
+export const { fn, fnLive, createPubSub, createRouter } = createFn({
+  procedures: { public: publicProcedure, protected: protectedProcedure },
+  default: 'protected',
+  extras: () => ({ db }),
+  guards: {
+    permission: (required: Permission, { context }) => context.user?.can(required)
+  },
+  otel
+})
+```
+
+```ts
+// features/orders/get-order.ts
+export const getOrder = fn({
+  name: 'order.get',
+  method: 'GET',
+  path: '/orders/{id}',
+  permission: 'orders:read',
+  input: z.object({ id: z.string() }),
+  handler: async ({ input, context, db, call, logger }) => {
+    logger.info('loading order', { id: input.id }) // context.user is typed: protected
+    const order = await db.order.find(input.id)
+    const customer = await call(getCustomer, { id: order.customerId }) // child span, same context
+    return { ...order, customer }
+  }
+})
+```
+
+Every call runs in an OpenTelemetry span named `order.get` (for a streaming handler, until the stream ends), runs the `permission` guard, writes `handler_ms` back to `context.timing`, and logs one `fn.completed` line at `info`, `warn` (4xx) or `error` (defects).
+
+## `orpc-fn`: `createFn`
+
+```ts
+createFn({
+  procedures,      // named oRPC builders; the handler context is the builder's context
+  default,         // builder used when a route omits `procedure`; leave out to require `procedure` on every route
+  extras,          // ({ context, span, signal, name, procedure }) => values (or a promise) merged into handler params
+  guards,          // { key: (value, { context, input, name, meta, signal }) => void } — each key is a typed fn() option
+  meta,            // `{} as { readOnly?: boolean }` — typed fn() options stored on the procedure
+  tags,            // ['internal', 'external'] — allowed route tags
+  otel,            // `import * as otel from '@opentelemetry/api'`; omit for no tracing
+  logger,          // (scope, span) => your logger (debug/info/warn/error)
+  spanAttributes,  // ({ context, name, procedure, meta }) => extra span attributes
+  onCompleted,     // (event) => extra attributes for the fn.completed log
+  isExpectedError, // default: 4xx ORPCError or AbortError
+  pubsub           // { transport, onDrop?, maxQueueSize? } for fnLive / createPubSub
+})
+```
+
+It returns `fn`, `fnLive`, `createPubSub`, `createPublisher`, `createRouter`, `readMeta`, `createCall`, `drainPubSubSubscribers` and `activePubSubSubscriberCount`.
+
+Procedure builders must not set an input or output schema (`os.input(...)`); put schemas on routes. Guard and meta keys must not reuse a route option name (`name`, `tags`, `input`, …), and guards and meta must not share a key. Both are type errors, and a reserved guard name also throws at startup.
+
+**`fn(options)`** has four overloads (input and output schema, each given or inferred). Route options: `name` (required; operationId and span name), `procedure`, `path`, `method`, `summary`, `description`, `tags`, `deprecated`, `successStatus`, `successDescription`, `inputStructure`, `outputStructure`, every guard key and every meta key. The handler receives `input`, `context`, `call`, `signal`, `span`, `logger` and your extras. With an output schema, the handler returns the schema's input type and callers receive its output type, so `output: z.string().transform(Number)` means the handler returns a string and callers get a number.
+
+**Guards** run inside the span, before the handler, and only on routes that set their option. Throw (usually an `ORPCError`) to refuse.
+
+**`call(procedure, input)`** calls another procedure with the caller's context and abort signal, inside a `call: <name>` child span. Input and output are typed from the callee. Calling a procedure whose context the caller's context does not satisfy is a type error. Outside a handler (seeders, scripts, tests), use `createCall(context, signal?)` from `createFn`.
+
+**Meta** is stored in oRPC's own procedure meta. It survives `os.router()`, prefixes and lazy routers. Read it with `readMeta(procedure)` (typed) or `readFnMeta(procedure)`.
+
+Also exported: `isExpectedClientError`, `createBoundedEventQueue`, `createRouter`, `createBoundCall`, and the types `HandlerParams`, `RouteConfig`, `BoundCall`, `FnMeta`, `FnContext`, `FnCompletedEvent`, `ProcedureInput`, `ProcedureOutput`, `ProcedureContext`, `InitialContextOf`, `CurrentContextOf` and `GuardOptions`.
+
+## `orpc-fn/live`: pub/sub and live queries
+
+```ts
+import { createFn } from 'orpc-fn'
+import { bunRedisTransport } from 'orpc-fn/live/redis-bun' // or ioredis / memory
+
+const transport = bunRedisTransport(new RedisClient(process.env.REDIS_URL))
+export const { fnLive, createPubSub, drainPubSubSubscribers } = createFn({
+  /* … */,
+  pubsub: { transport, onDrop: (count) => dropCounter.add(count) }
+})
+
+export const listOrders = fnLive({
+  name: 'order.list',
+  input: z.object({ organizationId: z.string() }),
+  handler: ({ input, db }) => db.order.list(input.organizationId),
+  live: {
+    eventSchema: z.object({ organizationId: z.string(), orderId: z.string() }),
+    channel: ({ organizationId }) => `orders:${organizationId}`,
+    coalesceMs: 50
+  }
+})
+// router: { list: listOrders.procedure, subscribe: listOrders.subscribe }
+await listOrders.publish({ organizationId, orderId }) // after a write
+```
+
+The `subscribe` route first runs `authFn` and subscribes to the channel, then streams the initial snapshot, then a new one per event. A refused subscriber receives nothing, and events published while the snapshot loads are not lost. Snapshots go through the output schema, like the route's own result. Options:
+
+- `shouldUpdate` skips an event.
+- `transformerFn` folds an event into `previous` instead of re-running the handler. It may return `fnLivePatch(state, emit)` to send a small payload and keep the full state.
+- `coalesceMs` batches events that arrive close together.
+- `authFn` and `useBacklog`/`backlogSize`/`backlogTtl` work as on `createPubSub`.
+- `overflowMarker` is enqueued when a slow subscriber's queue overflows, once per overflow episode, so the client can resync.
+- `safePublish` logs publish errors instead of throwing them.
+
+**`createPubSub`** returns a typed `subscribe` route plus `publish`, `publishMany` (one atomic round-trip across channels) and `getChannelName`. Publishers pass the event schema's input type; subscribers, filters and channel resolvers get its output type. The raw event travels in oRPC's JSON format, so `Date`, `Map`, `Set` and `BigInt` survive, and each receiver parses it once. Options: `filterFn`, `authFn`, `mirrorChannel`, `overflowMarker`, `procedure`. Each pub/sub definition subscribes to each channel once and parses each payload once for all local subscribers. Each subscriber then runs its filter in arrival order as it reads; its bounded queue holds events before filtering, so `onDrop` counts unfiltered events. Abort and drain release a subscription at once, even one that is not being read. A lost subscription is retried with exponential backoff and jitter. **`createPublisher`** is the publish-only half.
+
+**Graceful shutdown:** call `drainPubSubSubscribers()` on SIGTERM. Open streams end cleanly and clients reconnect to the new deployment. Draining is per `createFn` instance.
+
+**Transports** implement `PubSubTransport` (`publish(messages, backlog?)`, `readBacklog(channel)`, `subscribe(channel, listener, onLost)`):
+
+| Subpath | Client | Notes |
+|---|---|---|
+| `orpc-fn/live/redis-bun` | Bun `RedisClient` | Dedicated subscriber via `duplicate()`; re-subscribes after Bun's reconnects |
+| `orpc-fn/live/ioredis` | ioredis 5 | Dedicated subscriber via `duplicate()`; ioredis re-subscribes itself |
+| `orpc-fn/live/memory` | none | Tests and single-process dev |
+
+A subscriber connection that is lost, or cannot restore its channels after a reconnect, is closed and replaced; nothing it still emits is delivered. The Redis transports publish and maintain backlogs with one Lua script, sent by SHA, with a fallback to `EVAL` when Redis returns `NOSCRIPT`. Call `transport.close()` on shutdown.
+
+`streamLiveSnapshots`, `fnLivePatch` and `throwInitialSnapshotError` are exported for custom streams.
+
+## `orpc-fn/mastra`
+
+Optional peers: `@mastra/core` ^1.51, `@orpc/zod`, `@orpc/json-schema`.
+
+```ts
+import { createMastraTool } from 'orpc-fn/mastra'
+
+const tool = createMastraTool(getOrder, { requireApproval: true })
+// at run time: requestContext.set('orpcContext', context)
+```
+
+Options: `id`, `description`, `requireApproval`, `allowMissingInputSchema`, `onExecuteFinish`, `contextKey` (default `'orpcContext'`). Execution goes through oRPC `call`, so middleware and guards apply.
+
+The tool takes the procedure's raw input and returns its parsed output, and `InferToolInput`/`InferToolOutput`/`InferUITools` see exactly those types. Mastra validates the input (coercing date strings) but passes the raw value on, and the procedure parses that raw value: a transform may run twice, but never on its own output. Agent tools need an object input: any other input is a type error and throws.
+
+## `orpc-fn/mcp`
+
+Optional peers: `@orpc/zod`, `@orpc/json-schema`.
+
+```ts
+import { hasTag, listTools } from 'orpc-fn/mcp'
+
+for (const { name, procedure, config } of listTools(router, { filter: hasTag('external') })) {
+  server.registerTool(name, config, (args) => call(procedure, args, { context }))
+}
+```
+
+Tool names are the sanitized `fn` names (`user.me` becomes `user-me`). Input schemas carry the same JSON Schema as your OpenAPI docs (dates become `string`/`date-time`), and validation turns them back into `Date`s. Validation returns the raw arguments, and `call(procedure, args, { context })` parses those: a transform may run twice, but never on its own output. `readOnlyHint` defaults to GET routes; pass `readOnly` to change it. `hasTag(tag)` also works as an oRPC `OpenAPIHandler` filter.
+
+## `orpc-fn/hono`
+
+Optional peers: `hono`, `@orpc/openapi`, `@orpc/zod`, `@orpc/json-schema`.
+
+```ts
+import { mountOrpc, normalizeExpoOrigin } from 'orpc-fn/hono'
+
+mountOrpc(app, {
+  router,
+  rpcPrefix: '/rpc',
+  openapi: { prefix: '/api', info: { title: 'API', version: '1.0.0' } },
+  context: async (c, { headers, timing }) => ({ headers, timing, session: await getSession(headers) }),
+  normalizeHeaders: normalizeExpoOrigin,
+  onError: (error, request) => errorTracker.capture(error, request)
+})
+```
+
+Behaviour:
+
+- The response gets a `Server-Timing` header built from `context.timing`: queue, auth and context if you record them, and handler from `fn`.
+- SSE responses get keep-alive comments (15 s) and anti-buffering headers.
+- RPC calls are batched (`BatchHandlerPlugin`).
+- Scalar docs are served at the OpenAPI prefix.
+- `onError` sees only unexpected errors.
+- `openapi.filter`, `openapi.smartCoercion` and `openapi.spec` (for security schemes) cover an external API with its own auth.
+- `context` builds the router's context and is checked against it: it is required when `{ headers, timing }` alone does not satisfy the router. It may return a `Response`, for example a 401.
+
+## `orpc-fn/client`
+
+Has no server code, so it is safe in frontends (Vue, React, Expo).
+
+```ts
+import { createORPCClient } from '@orpc/client'
+import { createTanstackQueryUtils } from '@orpc/tanstack-query'
+import { createRpcLink, hasOrpcErrorCode } from 'orpc-fn/client'
+import type { RouterClient } from '@orpc/server'
+import type { router } from '@app/backend' // type-only import
+
+const link = createRpcLink({
+  url: `${apiOrigin}/rpc`,
+  fetch: (request, init) => fetch(request, { ...init, credentials: 'include', cache: 'no-store' })
+})
+export const client: RouterClient<typeof router> = createORPCClient(link)
+export const orpc = createTanstackQueryUtils(client) // Vue Query or React Query
+
+if (hasOrpcErrorCode(error, 'NOT_FOUND')) { /* … */ }
+```
+
+`createRpcLink` takes every `RPCLink` option. It also batches parallel calls into one request, matching `mountOrpc`'s server-side batching (`batch: { maxSize, exclude, groups }`, or `false` to turn it off). A batch is one request with one client context, so by default only calls without a client context are batched; pass `groups` to batch calls that share one. A streaming response cannot be batched, and the request doesn't say whether the response will stream, so streaming routes are recognised by name: any path segment containing `subscribe` is sent on its own (`isSubscriptionPath`).
+
+## `orpc-fn/expo`
+
+Expo itself is passed in, not imported. The fetch must resolve to a response with the members oRPC reads (`expo/fetch` does).
+
+```ts
+import { fetch } from 'expo/fetch'
+import { Platform } from 'react-native'
+import { createExpoLink } from 'orpc-fn/expo'
+
+const link = createExpoLink({
+  url: `${baseUrl}/api/rpc`,
+  fetch,
+  native: Platform.OS !== 'web',
+  getCookie: () => authClient.getCookie(), // Better Auth Expo
+  getExpoOrigin,
+  headers: () => ({ 'x-orpc-source': 'expo-react' })
+})
+```
+
+On native, calls go through `expo/fetch`, the only fetch that streams there. The bridge forwards the request body and the abort signal. Without the signal, cancelled subscriptions keep their sockets open, the device's HTTP pool runs out, and later requests hang. Cookies are sent in a header (`credentials: 'omit'`), together with `expo-origin` and `x-skip-oauth-proxy`, the same headers `@better-auth/expo` sends. On the server, `mountOrpc({ normalizeHeaders: normalizeExpoOrigin })` copies `expo-origin` to `origin`. On web, the link uses the platform fetch with cookies. `createExpoFetch` is exported for a custom link.
+
+## Docs
+
+- [Migrating an app from an in-repo `lib/fn`](docs/migration.md)
+- [Decisions: what oRPC already ships and why this exists](docs/decisions.md)
+- [Releasing](docs/releasing.md)
+- [Example: Hono, in-memory pub/sub, two routes and a live query](examples/basic/server.ts)
+
+## License
+
+MIT

package/dist/bound-call.d.ts

@@ -0,0 +1,23 @@
+import { type AnyProcedure } from '@orpc/server';
+import { type Tracing } from './otel.js';
+import type { ProcedureContext, ProcedureInput, ProcedureOutput } from './types.js';
+/** Rejects a procedure whose context the caller's context does not satisfy. */
+type ContextCheck<TContext, T> = [TContext] extends [ProcedureContext<T>] ? unknown : {
+    'orpc-fn: the calling context does not satisfy this procedure': ProcedureContext<T>;
+};
+/**
+ * Calls another procedure with the caller's context and signal. `TContext` is
+ * the caller's context; the callee must accept it.
+ */
+export type BoundCall<TContext = any> = <T extends AnyProcedure>(procedure: T & ContextCheck<TContext, T>, input: ProcedureInput<T>) => Promise<ProcedureOutput<T>>;
+/**
+ * Creates a bound call: nested calls keep the caller's context and abort
+ * signal and run inside a `call: <name>` child span, so the trace shows the
+ * whole call tree. oRPC's `call` runs the callee's own middleware and guards.
+ *
+ * Handlers get one as `call`. Outside a handler (seeders, tests) use
+ * `createCall` from `createFn`, which traces with the instance's OpenTelemetry.
+ */
+export declare function createBoundCall<TContext>(context: TContext, signal?: AbortSignal, tracing?: Tracing): BoundCall<TContext>;
+export {};
+//# sourceMappingURL=bound-call.d.ts.map

package/dist/bound-call.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bound-call.d.ts","sourceRoot":"","sources":["../src/bound-call.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAQ,MAAM,cAAc,CAAA;AAEtD,OAAO,EAAiB,KAAK,OAAO,EAAE,MAAM,WAAW,CAAA;AACvD,OAAO,KAAK,EACX,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,MAAM,YAAY,CAAA;AAEnB,+EAA+E;AAC/E,KAAK,YAAY,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,GACtE,OAAO,GACP;IACA,8DAA8D,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAA;CACnF,CAAA;AAEH;;;GAGG;AAEH,MAAM,MAAM,SAAS,CAAC,QAAQ,GAAG,GAAG,IAAI,CAAC,CAAC,SAAS,YAAY,EAC9D,SAAS,EAAE,CAAC,GAAG,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC,EACxC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,KACpB,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAA;AAIhC;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EACvC,OAAO,EAAE,QAAQ,EACjB,MAAM,CAAC,EAAE,WAAW,EACpB,OAAO,GAAE,OAAmB,GAC1B,SAAS,CAAC,QAAQ,CAAC,CASrB"}

package/dist/bound-call.js

@@ -0,0 +1,23 @@
+import { call } from '@orpc/server';
+import { readFnMeta } from './meta.js';
+import { createTracing } from './otel.js';
+const noTracing = createTracing(undefined);
+/**
+ * Creates a bound call: nested calls keep the caller's context and abort
+ * signal and run inside a `call: <name>` child span, so the trace shows the
+ * whole call tree. oRPC's `call` runs the callee's own middleware and guards.
+ *
+ * Handlers get one as `call`. Outside a handler (seeders, tests) use
+ * `createCall` from `createFn`, which traces with the instance's OpenTelemetry.
+ */
+export function createBoundCall(context, signal, tracing = noTracing) {
+    return ((procedure, input) => {
+        const name = readFnMeta(procedure).name ?? 'unknown_procedure';
+        return tracing.inSpan(`call: ${name}`, 'INTERNAL', async (span) => {
+            signal?.throwIfAborted();
+            span?.setAttribute('rpc.method', name);
+            return call(procedure, input, signal ? { context, signal } : { context });
+        });
+    });
+}
+//# sourceMappingURL=bound-call.js.map

package/dist/bound-call.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bound-call.js","sourceRoot":"","sources":["../src/bound-call.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,IAAI,EAAE,MAAM,cAAc,CAAA;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACtC,OAAO,EAAE,aAAa,EAAgB,MAAM,WAAW,CAAA;AAwBvD,MAAM,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC,CAAA;AAE1C;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAC9B,OAAiB,EACjB,MAAoB,EACpB,OAAO,GAAY,SAAS;IAE5B,OAAO,CAAC,CAAC,SAAuB,EAAE,KAAc,EAAE,EAAE;QACnD,MAAM,IAAI,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,IAAI,IAAI,mBAAmB,CAAA;QAC9D,OAAO,OAAO,CAAC,MAAM,CAAC,SAAS,IAAI,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;YACjE,MAAM,EAAE,cAAc,EAAE,CAAA;YACxB,IAAI,EAAE,YAAY,CAAC,YAAY,EAAE,IAAI,CAAC,CAAA;YACtC,OAAO,IAAI,CAAC,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAA;QAC1E,CAAC,CAAC,CAAA;IACH,CAAC,CAAwB,CAAA;AAC1B,CAAC","sourcesContent":["import { type AnyProcedure, call } from '@orpc/server'\nimport { readFnMeta } from './meta.js'\nimport { createTracing, type Tracing } from './otel.js'\nimport type {\n\tProcedureContext,\n\tProcedureInput,\n\tProcedureOutput\n} from './types.js'\n\n/** Rejects a procedure whose context the caller's context does not satisfy. */\ntype ContextCheck<TContext, T> = [TContext] extends [ProcedureContext<T>]\n\t? unknown\n\t: {\n\t\t\t'orpc-fn: the calling context does not satisfy this procedure': ProcedureContext<T>\n\t\t}\n\n/**\n * Calls another procedure with the caller's context and signal. `TContext` is\n * the caller's context; the callee must accept it.\n */\n// biome-ignore lint/suspicious/noExplicitAny: an unbound call accepts any procedure\nexport type BoundCall<TContext = any> = <T extends AnyProcedure>(\n\tprocedure: T & ContextCheck<TContext, T>,\n\tinput: ProcedureInput<T>\n) => Promise<ProcedureOutput<T>>\n\nconst noTracing = createTracing(undefined)\n\n/**\n * Creates a bound call: nested calls keep the caller's context and abort\n * signal and run inside a `call: <name>` child span, so the trace shows the\n * whole call tree. oRPC's `call` runs the callee's own middleware and guards.\n *\n * Handlers get one as `call`. Outside a handler (seeders, tests) use\n * `createCall` from `createFn`, which traces with the instance's OpenTelemetry.\n */\nexport function createBoundCall<TContext>(\n\tcontext: TContext,\n\tsignal?: AbortSignal,\n\ttracing: Tracing = noTracing\n): BoundCall<TContext> {\n\treturn ((procedure: AnyProcedure, input: unknown) => {\n\t\tconst name = readFnMeta(procedure).name ?? 'unknown_procedure'\n\t\treturn tracing.inSpan(`call: ${name}`, 'INTERNAL', async (span) => {\n\t\t\tsignal?.throwIfAborted()\n\t\t\tspan?.setAttribute('rpc.method', name)\n\t\t\treturn call(procedure, input, signal ? { context, signal } : { context })\n\t\t})\n\t}) as BoundCall<TContext>\n}\n"]}

package/dist/client.d.ts

@@ -0,0 +1,44 @@
+import { type ClientContext, type ORPCErrorCode } from '@orpc/client';
+import { RPCLink, type RPCLinkOptions } from '@orpc/client/fetch';
+import { BatchLinkPlugin } from '@orpc/client/plugins';
+type BatchOptions<T extends ClientContext> = ConstructorParameters<typeof BatchLinkPlugin<T>>[0];
+export type CreateRpcLinkOptions<T extends ClientContext> = RPCLinkOptions<T> & {
+    /**
+     * Collapse parallel calls into one HTTP request, matching `mountOrpc`'s
+     * server-side batching. Default: true (25 calls). Pass false to turn off.
+     *
+     * A batch is one HTTP request, so it carries one client context. By
+     * default only calls without a client context are batched; pass
+     * `groups` to batch calls that share a context (e.g. a token).
+     */
+    batch?: boolean | {
+        maxSize?: number;
+        /** Calls that must not be batched. Default: {@link isSubscriptionPath}. */
+        exclude?: (path: readonly string[]) => boolean;
+        groups?: BatchOptions<T>['groups'];
+    };
+};
+/**
+ * Streaming responses cannot be batched, and the request does not say a
+ * response will stream - so streaming routes are recognised by name. The
+ * default treats any path segment containing `subscribe` as one (the
+ * convention `fnLive` routers use: `{ list, subscribe }`).
+ */
+export declare const isSubscriptionPath: (path: readonly string[]) => boolean;
+/**
+ * `RPCLink` with request batching: a page-load burst becomes one request
+ * instead of many queued on the server's event loop.
+ *
+ * ```ts
+ * const client: RouterClient<typeof router> = createORPCClient(createRpcLink({ url }))
+ * export const orpc = createTanstackQueryUtils(client)
+ * ```
+ */
+export declare function createRpcLink<T extends ClientContext = ClientContext>(options: CreateRpcLinkOptions<T>): RPCLink<T>;
+/**
+ * Typed check for a route error on the client. The RPC link rebuilds thrown
+ * route errors as `ORPCError`, so `instanceof` plus `code` is the contract.
+ */
+export declare function hasOrpcErrorCode(error: unknown, code: ORPCErrorCode): boolean;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAa,KAAK,aAAa,EAAE,MAAM,cAAc,CAAA;AAChF,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACjE,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAEtD,KAAK,YAAY,CAAC,CAAC,SAAS,aAAa,IAAI,qBAAqB,CACjE,OAAO,eAAe,CAAC,CAAC,CAAC,CACzB,CAAC,CAAC,CAAC,CAAA;AAEJ,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,aAAa,IACvD,cAAc,CAAC,CAAC,CAAC,GAAG;IACnB;;;;;;;OAOG;IACH,KAAK,CAAC,EACH,OAAO,GACP;QACA,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,2EAA2E;QAC3E,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,KAAK,OAAO,CAAA;QAC9C,MAAM,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAA;KACjC,CAAA;CACJ,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,SAAU,SAAS,MAAM,EAAE,YACU,CAAA;AAEpE;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,EACpE,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,CAAC,CAAC,CAyBZ;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAE7E"}

package/dist/client.js

@@ -0,0 +1,49 @@
+import { ORPCError } from '@orpc/client';
+import { RPCLink } from '@orpc/client/fetch';
+import { BatchLinkPlugin } from '@orpc/client/plugins';
+/**
+ * Streaming responses cannot be batched, and the request does not say a
+ * response will stream - so streaming routes are recognised by name. The
+ * default treats any path segment containing `subscribe` as one (the
+ * convention `fnLive` routers use: `{ list, subscribe }`).
+ */
+export const isSubscriptionPath = (path) => path.some((segment) => segment.toLowerCase().includes('subscribe'));
+/**
+ * `RPCLink` with request batching: a page-load burst becomes one request
+ * instead of many queued on the server's event loop.
+ *
+ * ```ts
+ * const client: RouterClient<typeof router> = createORPCClient(createRpcLink({ url }))
+ * export const orpc = createTanstackQueryUtils(client)
+ * ```
+ */
+export function createRpcLink(options) {
+    const { batch = true, plugins = [], ...rest } = options;
+    if (batch === false)
+        return new RPCLink({ ...rest, plugins });
+    const { maxSize = 25, exclude = isSubscriptionPath, groups } = batch === true ? {} : batch;
+    return new RPCLink({
+        ...rest,
+        plugins: [
+            new BatchLinkPlugin({
+                maxSize,
+                groups: groups ?? [
+                    // Only context-free calls reach this group (see `exclude` below),
+                    // so the batch's empty context is exactly theirs.
+                    { condition: () => true, context: {} }
+                ],
+                exclude: ({ path, context }) => exclude(path) ||
+                    (groups === undefined && Object.keys(context).length > 0)
+            }),
+            ...plugins
+        ]
+    });
+}
+/**
+ * Typed check for a route error on the client. The RPC link rebuilds thrown
+ * route errors as `ORPCError`, so `instanceof` plus `code` is the contract.
+ */
+export function hasOrpcErrorCode(error, code) {
+    return error instanceof ORPCError && error.code === code;
+}
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,SAAS,EAAsB,MAAM,cAAc,CAAA;AAChF,OAAO,EAAE,OAAO,EAAuB,MAAM,oBAAoB,CAAA;AACjE,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AA0BtD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,IAAuB,EAAE,EAAE,CAC7D,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAA;AAEpE;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAC5B,OAAgC;IAEhC,MAAM,EAAE,KAAK,GAAG,IAAI,EAAE,OAAO,GAAG,EAAE,EAAE,GAAG,IAAI,EAAE,GAAG,OAAO,CAAA;IACvD,IAAI,KAAK,KAAK,KAAK;QAAE,OAAO,IAAI,OAAO,CAAI,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,CAAC,CAAA;IAChE,MAAM,EACL,OAAO,GAAG,EAAE,EACZ,OAAO,GAAG,kBAAkB,EAC5B,MAAM,EACN,GAAG,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAA;IAC/B,OAAO,IAAI,OAAO,CAAI;QACrB,GAAG,IAAI;QACP,OAAO,EAAE;YACR,IAAI,eAAe,CAAI;gBACtB,OAAO;gBACP,MAAM,EAAE,MAAM,IAAI;oBACjB,kEAAkE;oBAClE,kDAAkD;oBAClD,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAO,EAAE;iBAC3C;gBACD,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,CAC9B,OAAO,CAAC,IAAI,CAAC;oBACb,CAAC,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;aAC1D,CAAC;YACF,GAAG,OAAO;SACV;KACD,CAAC,CAAA;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc,EAAE,IAAmB;IACnE,OAAO,KAAK,YAAY,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,CAAA;AACzD,CAAC","sourcesContent":["import { type ClientContext, ORPCError, type ORPCErrorCode } from '@orpc/client'\nimport { RPCLink, type RPCLinkOptions } from '@orpc/client/fetch'\nimport { BatchLinkPlugin } from '@orpc/client/plugins'\n\ntype BatchOptions<T extends ClientContext> = ConstructorParameters<\n\ttypeof BatchLinkPlugin<T>\n>[0]\n\nexport type CreateRpcLinkOptions<T extends ClientContext> =\n\tRPCLinkOptions<T> & {\n\t\t/**\n\t\t * Collapse parallel calls into one HTTP request, matching `mountOrpc`'s\n\t\t * server-side batching. Default: true (25 calls). Pass false to turn off.\n\t\t *\n\t\t * A batch is one HTTP request, so it carries one client context. By\n\t\t * default only calls without a client context are batched; pass\n\t\t * `groups` to batch calls that share a context (e.g. a token).\n\t\t */\n\t\tbatch?:\n\t\t\t| boolean\n\t\t\t| {\n\t\t\t\t\tmaxSize?: number\n\t\t\t\t\t/** Calls that must not be batched. Default: {@link isSubscriptionPath}. */\n\t\t\t\t\texclude?: (path: readonly string[]) => boolean\n\t\t\t\t\tgroups?: BatchOptions<T>['groups']\n\t\t\t  }\n\t}\n\n/**\n * Streaming responses cannot be batched, and the request does not say a\n * response will stream - so streaming routes are recognised by name. The\n * default treats any path segment containing `subscribe` as one (the\n * convention `fnLive` routers use: `{ list, subscribe }`).\n */\nexport const isSubscriptionPath = (path: readonly string[]) =>\n\tpath.some((segment) => segment.toLowerCase().includes('subscribe'))\n\n/**\n * `RPCLink` with request batching: a page-load burst becomes one request\n * instead of many queued on the server's event loop.\n *\n * ```ts\n * const client: RouterClient<typeof router> = createORPCClient(createRpcLink({ url }))\n * export const orpc = createTanstackQueryUtils(client)\n * ```\n */\nexport function createRpcLink<T extends ClientContext = ClientContext>(\n\toptions: CreateRpcLinkOptions<T>\n): RPCLink<T> {\n\tconst { batch = true, plugins = [], ...rest } = options\n\tif (batch === false) return new RPCLink<T>({ ...rest, plugins })\n\tconst {\n\t\tmaxSize = 25,\n\t\texclude = isSubscriptionPath,\n\t\tgroups\n\t} = batch === true ? {} : batch\n\treturn new RPCLink<T>({\n\t\t...rest,\n\t\tplugins: [\n\t\t\tnew BatchLinkPlugin<T>({\n\t\t\t\tmaxSize,\n\t\t\t\tgroups: groups ?? [\n\t\t\t\t\t// Only context-free calls reach this group (see `exclude` below),\n\t\t\t\t\t// so the batch's empty context is exactly theirs.\n\t\t\t\t\t{ condition: () => true, context: {} as T }\n\t\t\t\t],\n\t\t\t\texclude: ({ path, context }) =>\n\t\t\t\t\texclude(path) ||\n\t\t\t\t\t(groups === undefined && Object.keys(context).length > 0)\n\t\t\t}),\n\t\t\t...plugins\n\t\t]\n\t})\n}\n\n/**\n * Typed check for a route error on the client. The RPC link rebuilds thrown\n * route errors as `ORPCError`, so `instanceof` plus `code` is the contract.\n */\nexport function hasOrpcErrorCode(error: unknown, code: ORPCErrorCode): boolean {\n\treturn error instanceof ORPCError && error.code === code\n}\n"]}

package/dist/create-fn.d.ts

@@ -0,0 +1,97 @@
+import type { AnyProcedure } from '@orpc/server';
+import { type BoundCall } from './bound-call.js';
+import { type FnLive } from './live/fn-live.js';
+import { type CreatePublisher, type CreatePubSub, type PubSubRuntimeOptions } from './live/pub-sub.js';
+import { type FnLogger, type LogAttributes } from './logger.js';
+import { type FnMeta } from './meta.js';
+import { type AttributeValue, type OtelApiLike, type SpanLike, type SpanOf } from './otel.js';
+import { createRouter } from './router.js';
+import { type AnyFnContext, type BuilderLike, type FiniteExtras, type Fn, type FnCompletedEvent, type FnDefinition, type Guard, type GuardParams, type MaybePromise, type RejectKeys, type ReservedOptionKey } from './types.js';
+type UnionContext<TProcedures extends Record<string, BuilderLike>> = AnyFnContext<{
+    procedures: TProcedures;
+    default: string;
+    extras: object;
+    guards: object;
+    meta: object;
+    tag: string;
+    span: SpanLike;
+    logger: FnLogger;
+}>;
+export type CreateFnOptions<TProcedures extends Record<string, BuilderLike>, TDefault extends keyof TProcedures & string, TExtras extends object, TGuards, TMeta extends object, TTag extends string, TOtel extends OtelApiLike | undefined, TLogger extends FnLogger> = {
+    /** Named oRPC builders, e.g. `{ public: os.$context<Ctx>(), protected: authed }`. */
+    procedures: TProcedures;
+    /**
+     * Builder used when a route omits `procedure`. Leave it out to make every
+     * route name its procedure, so none gets one by accident.
+     */
+    default?: TDefault;
+    /** Per-call values merged into every handler's params; may be async. */
+    extras?: (params: {
+        context: UnionContext<TProcedures>;
+        span: SpanOf<TOtel> | undefined;
+        signal: AbortSignal | undefined;
+        name: string;
+        procedure: string;
+    }) => MaybePromise<TExtras>;
+    /**
+     * Checks run before the handler; each key becomes a typed `fn()` option.
+     * Keys must not reuse route options or meta keys.
+     */
+    guards?: TGuards & Record<string, Guard<never, GuardParams<UnionContext<TProcedures>, TMeta>>> & RejectKeys<NoInfer<TGuards>, ReservedOptionKey | keyof NoInfer<TMeta>, 'orpc-fn: this guard name is a route option or meta key'>;
+    /**
+     * Typed route metadata: `meta: {} as { readOnly?: boolean }`. Keys become
+     * `fn()` options and must not reuse route options.
+     */
+    meta?: TMeta & RejectKeys<NoInfer<TMeta>, ReservedOptionKey, 'orpc-fn: this meta key is a route option'>;
+    /** Allowed route tags: `tags: ['internal', 'external']`. */
+    tags?: readonly TTag[];
+    /** `import * as otel from '@opentelemetry/api'`. Omit for no tracing. */
+    otel?: TOtel;
+    logger?: (scope: string, span: SpanOf<TOtel> | undefined) => TLogger;
+    /** Extra span attributes per call; undefined values are skipped. */
+    spanAttributes?: (params: {
+        context: UnionContext<TProcedures>;
+        name: string;
+        procedure: string;
+        meta: Partial<TMeta>;
+    }) => Record<string, AttributeValue | undefined>;
+    /** Called after every handler; returned attributes join the `fn.completed` log. */
+    onCompleted?: (event: FnCompletedEvent<UnionContext<TProcedures>, SpanOf<TOtel>>) => LogAttributes | undefined | void;
+    /** Errors that are the caller's fault, logged at `warn`. Default: 4xx `ORPCError` or `AbortError`. */
+    isExpectedError?: (error: unknown) => boolean;
+    /** Needed for `fnLive` and `createPubSub`. */
+    pubsub?: PubSubRuntimeOptions;
+};
+type Definition<TProcedures extends Record<string, BuilderLike>, TDefault extends string, TExtras extends object, TGuards, TMeta extends object, TTag extends string, TOtel, TLogger extends FnLogger> = {
+    procedures: TProcedures;
+    default: TDefault;
+    extras: TExtras;
+    guards: TGuards;
+    meta: TMeta;
+    tag: TTag;
+    span: SpanOf<TOtel>;
+    logger: TLogger;
+};
+export type FnFactory<TDef extends FnDefinition> = {
+    fn: Fn<TDef>;
+    fnLive: FnLive<TDef>;
+    createPubSub: CreatePubSub<TDef>;
+    createPublisher: CreatePublisher;
+    createRouter: typeof createRouter;
+    readMeta: (procedure: AnyProcedure) => FnMeta<TDef['meta']>;
+    /**
+     * A `call` outside any handler (seeders, scripts, tests), traced with this
+     * instance's OpenTelemetry.
+     */
+    createCall: <TContext>(context: TContext, signal?: AbortSignal) => BoundCall<TContext>;
+    /** End every open subscription of this instance; returns how many closed. */
+    drainPubSubSubscribers: () => number;
+    activePubSubSubscriberCount: () => number;
+};
+/**
+ * Builds the app's `fn` and friends once. Everything app-specific (auth,
+ * context, database, queues, i18n, permissions) is injected here.
+ */
+export declare function createFn<const TProcedures extends Record<string, BuilderLike>, TDefault extends keyof TProcedures & string = never, TExtras extends object = Record<never, never>, TGuards extends object = Record<never, never>, TMeta extends object = Record<never, never>, const TTag extends string = string, TOtel extends OtelApiLike | undefined = undefined, TLogger extends FnLogger = FnLogger>(options: CreateFnOptions<TProcedures, TDefault, TExtras, TGuards, TMeta, TTag, TOtel, TLogger> & FiniteExtras<NoInfer<TExtras>>): FnFactory<Definition<TProcedures, TDefault, TExtras, TGuards, TMeta, TTag, TOtel, TLogger>>;
+export {};
+//# sourceMappingURL=create-fn.d.ts.map

package/dist/create-fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fn.d.ts","sourceRoot":"","sources":["../src/create-fn.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,KAAK,SAAS,EAAmB,MAAM,iBAAiB,CAAA;AAEjE,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC7D,OAAO,EACN,KAAK,eAAe,EACpB,KAAK,YAAY,EAEjB,KAAK,oBAAoB,EACzB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAEN,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,MAAM,aAAa,CAAA;AACpB,OAAO,EAEN,KAAK,MAAM,EAGX,MAAM,WAAW,CAAA;AAClB,OAAO,EACN,KAAK,cAAc,EAGnB,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,EACN,KAAK,YAAY,EACjB,KAAK,WAAW,EAEhB,KAAK,YAAY,EACjB,KAAK,EAAE,EACP,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,UAAU,EAGf,KAAK,iBAAiB,EACtB,MAAM,YAAY,CAAA;AAiCnB,KAAK,YAAY,CAAC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,IAChE,YAAY,CAAC;IACZ,UAAU,EAAE,WAAW,CAAA;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,QAAQ,CAAA;IACd,MAAM,EAAE,QAAQ,CAAA;CAChB,CAAC,CAAA;AAEH,MAAM,MAAM,eAAe,CAC1B,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EAC/C,QAAQ,SAAS,MAAM,WAAW,GAAG,MAAM,EAC3C,OAAO,SAAS,MAAM,EACtB,OAAO,EACP,KAAK,SAAS,MAAM,EACpB,IAAI,SAAS,MAAM,EACnB,KAAK,SAAS,WAAW,GAAG,SAAS,EACrC,OAAO,SAAS,QAAQ,IACrB;IACH,qFAAqF;IACrF,UAAU,EAAE,WAAW,CAAA;IACvB;;;OAGG;IACH,OAAO,CAAC,EAAE,QAAQ,CAAA;IAClB,wEAAwE;IACxE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE;QACjB,OAAO,EAAE,YAAY,CAAC,WAAW,CAAC,CAAA;QAClC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,SAAS,CAAA;QAC/B,MAAM,EAAE,WAAW,GAAG,SAAS,CAAA;QAC/B,IAAI,EAAE,MAAM,CAAA;QACZ,SAAS,EAAE,MAAM,CAAA;KACjB,KAAK,YAAY,CAAC,OAAO,CAAC,CAAA;IAC3B;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,GACf,MAAM,CACL,MAAM,EACN,KAAK,CAAC,KAAK,EAAE,WAAW,CAAC,YAAY,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,CAAC,CAC3D,GACD,UAAU,CACT,OAAO,CAAC,OAAO,CAAC,EAChB,iBAAiB,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,EACxC,wDAAwD,CACxD,CAAA;IACF;;;OAGG;IACH,IAAI,CAAC,EAAE,KAAK,GACX,UAAU,CACT,OAAO,CAAC,KAAK,CAAC,EACd,iBAAiB,EACjB,0CAA0C,CAC1C,CAAA;IACF,4DAA4D;IAC5D,IAAI,CAAC,EAAE,SAAS,IAAI,EAAE,CAAA;IACtB,yEAAyE;IACzE,IAAI,CAAC,EAAE,KAAK,CAAA;IACZ,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,SAAS,KAAK,OAAO,CAAA;IACpE,oEAAoE;IACpE,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE;QACzB,OAAO,EAAE,YAAY,CAAC,WAAW,CAAC,CAAA;QAClC,IAAI,EAAE,MAAM,CAAA;QACZ,SAAS,EAAE,MAAM,CAAA;QACjB,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,CAAA;KACpB,KAAK,MAAM,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,CAAC,CAAA;IAChD,mFAAmF;IACnF,WAAW,CAAC,EAAE,CACb,KAAK,EAAE,gBAAgB,CAAC,YAAY,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,KAE7D,aAAa,GAAG,SAAS,GAAG,IAAI,CAAA;IACrC,sGAAsG;IACtG,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAA;IAC7C,8CAA8C;IAC9C,MAAM,CAAC,EAAE,oBAAoB,CAAA;CAC7B,CAAA;AAED,KAAK,UAAU,CACd,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EAC/C,QAAQ,SAAS,MAAM,EACvB,OAAO,SAAS,MAAM,EACtB,OAAO,EACP,KAAK,SAAS,MAAM,EACpB,IAAI,SAAS,MAAM,EACnB,KAAK,EACL,OAAO,SAAS,QAAQ,IACrB;IACH,UAAU,EAAE,WAAW,CAAA;IACvB,OAAO,EAAE,QAAQ,CAAA;IACjB,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,KAAK,CAAA;IACX,GAAG,EAAE,IAAI,CAAA;IACT,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAA;IACnB,MAAM,EAAE,OAAO,CAAA;CACf,CAAA;AAED,MAAM,MAAM,SAAS,CAAC,IAAI,SAAS,YAAY,IAAI;IAClD,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAA;IACZ,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;IACpB,YAAY,EAAE,YAAY,CAAC,IAAI,CAAC,CAAA;IAChC,eAAe,EAAE,eAAe,CAAA;IAChC,YAAY,EAAE,OAAO,YAAY,CAAA;IACjC,QAAQ,EAAE,CAAC,SAAS,EAAE,YAAY,KAAK,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAA;IAC3D;;;OAGG;IACH,UAAU,EAAE,CAAC,QAAQ,EACpB,OAAO,EAAE,QAAQ,EACjB,MAAM,CAAC,EAAE,WAAW,KAChB,SAAS,CAAC,QAAQ,CAAC,CAAA;IACxB,6EAA6E;IAC7E,sBAAsB,EAAE,MAAM,MAAM,CAAA;IACpC,2BAA2B,EAAE,MAAM,MAAM,CAAA;CACzC,CAAA;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CACvB,KAAK,CAAC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EACrD,QAAQ,SAAS,MAAM,WAAW,GAAG,MAAM,GAAG,KAAK,EACnD,OAAO,SAAS,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAC7C,OAAO,SAAS,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAC7C,KAAK,SAAS,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAC3C,KAAK,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,EAClC,KAAK,SAAS,WAAW,GAAG,SAAS,GAAG,SAAS,EACjD,OAAO,SAAS,QAAQ,GAAG,QAAQ,EAEnC,OAAO,EAAE,eAAe,CACvB,WAAW,EACX,QAAQ,EACR,OAAO,EACP,OAAO,EACP,KAAK,EACL,IAAI,EACJ,KAAK,EACL,OAAO,CACP,GACA,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAC7B,SAAS,CACX,UAAU,CACT,WAAW,EACX,QAAQ,EACR,OAAO,EACP,OAAO,EACP,KAAK,EACL,IAAI,EACJ,KAAK,EACL,OAAO,CACP,CACD,CA6NA"}