diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..903ec6b
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,17 @@
+# TeamPlay Agent Notes
+
+TeamPlay is a full-stack signal ORM built on top of ShareDB. The main user-facing API is the object-tree signal model: `$`, `$.collection[id]`, `sub()`, `useSub()`, and `Signal<SchemaType>`.
+
+Before making nontrivial changes, read:
+
+- [architecture.md](./architecture.md) for the monorepo layout and runtime architecture.
+- [typing-architecture.md](./typing-architecture.md) for the TypeScript and generated type architecture.
+- [tasks.md](./tasks.md) for the current backlog, known priorities, and verification guidance. Treat it as context unless the user explicitly asks you to work through backlog items.
+
+Basic working rules:
+
+- Preserve public runtime APIs and the object-tree UX unless the user explicitly asks for a product change.
+- Prefer small, focused changes with nearby tests. Run focused tests while iterating and broader tests before commits.
+- Keep runtime behavior and TypeScript behavior aligned; update the architecture docs when the direction changes.
+- Do not invest in broad Compat rewrites. Compat is temporary; touch it only when needed to preserve behavior.
+- Work only in this project. Neighboring folders mentioned in old notes are not available in this environment.
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..43c994c
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+@AGENTS.md
diff --git a/architecture.md b/architecture.md
new file mode 100644
index 0000000..e1fa35c
--- /dev/null
+++ b/architecture.md
@@ -0,0 +1,553 @@
+# TeamPlay Architecture
+
+This document explains how the TeamPlay monorepo works at runtime and how the main packages fit together. Read it before changing runtime behavior, public APIs, package exports, backend integration, subscriptions, or React integration.
+
+For TypeScript-specific details, read [typing-architecture.md](./typing-architecture.md) after this document. Together, these two files should give a fresh human or agent enough context to navigate the repo without prior project knowledge.
+
+## High-Level Model
+
+TeamPlay is a full-stack signal ORM built on top of ShareDB.
+
+The user-facing mental model is:
+
+```ts
+import $, { sub } from 'teamplay'
+
+const $user = await sub($.users[userId])
+$user.name.set('Ada')
+```
+
+At runtime:
+
+- `$` is a root signal.
+- `$.users[userId]` is not a predeclared property. It is a proxy-created signal path.
+- Public collection/document paths are backed by ShareDB documents and queries.
+- Local/private paths are stored in root-scoped private state.
+- `sub()` and `useSub()` attach ShareDB documents, queries, or aggregations and return signals with the same object-tree UX.
+- Model classes attach methods to signal paths, so document and collection behavior lives beside the schema concepts users already work with.
+
+The most important design constraint is that the object-tree API stays stable:
+
+```ts
+$              // root signal
+$.users        // collection signal
+$.users[id]    // document signal
+$.users[id].x  // nested field signal
+```
+
+Avoid changes that make users think in terms of low-level ShareDB objects, raw paths, manual query stores, or separate document accessor APIs unless there is an explicit product decision.
+
+## Runtime Shape
+
+The runtime is easiest to understand as six cooperating layers:
+
+```txt
+Application code
+  |
+  | imports teamplay, teamplay/connect, teamplay/server, generated models
+  v
+Public TeamPlay API
+  |
+  | $, Signal, sub(), useSub(), observer(), initModels(), createBackend()
+  v
+Signal ORM runtime
+  |
+  | proxy signals, model lookup, data tree, private root state, subscriptions
+  v
+ShareDB connection
+  |
+  | docs, fetch/subscribe queries, JSON0 ops
+  v
+Transport and backend
+  |
+  | websocket channel, ShareDB backend, db, pubsub, hooks
+  v
+Database and server features
+     schema validation, access control, server aggregations
+```
+
+The package boundaries mostly follow this layering, but `packages/teamplay` is intentionally the facade that end users import.
+
+## Package Map
+
+| Package | Role | Main files |
+| --- | --- | --- |
+| `teamplay` | Public runtime package: signals, ORM, React hooks, server/connect facades, model registration, schema/cache re-exports. | [packages/teamplay/index.ts](./packages/teamplay/index.ts), [packages/teamplay/orm](./packages/teamplay/orm), [packages/teamplay/react](./packages/teamplay/react), [packages/teamplay/server.js](./packages/teamplay/server.js), [packages/teamplay/connect/index.js](./packages/teamplay/connect/index.js) |
+| `babel-plugin-teamplay` | File-based model discovery and code generation for app model folders. Produces model manifests and generated type env files. | [packages/babel-plugin-teamplay](./packages/babel-plugin-teamplay) |
+| `@teamplay/backend` | ShareDB backend factory with database, pubsub, hooks, access control, schema validation, and server aggregation integration. | [packages/backend/index.js](./packages/backend/index.js) |
+| `@teamplay/channel` | WebSocket/SockJS-compatible client/server channel used by the ShareDB connection. | [packages/channel](./packages/channel) |
+| `@teamplay/schema` | JSON Schema helpers and TeamPlay schema wrapping. | [packages/schema](./packages/schema) |
+| `@teamplay/server-aggregate` | ShareDB middleware for server-defined aggregation queries. | [packages/server-aggregate](./packages/server-aggregate) |
+| `@teamplay/sharedb-access` | ShareDB access-control middleware. | [packages/sharedb-access](./packages/sharedb-access) |
+| `@teamplay/sharedb-schema` | ShareDB schema validation middleware. | [packages/sharedb-schema](./packages/sharedb-schema) |
+| `@teamplay/utils` | Shared internal utilities, including aggregation and access-control helpers/types. | [packages/utils](./packages/utils) |
+| `@teamplay/cache` | Cache helpers used by runtime code. | [packages/cache](./packages/cache) |
+| `@teamplay/debug` | Debug helper package. | [packages/debug](./packages/debug) |
+| `example` | Example application workspace. | [example](./example) |
+
+Root [package.json](./package.json) defines the workspace layout and the standard test flow. The root `npm test` runs Babel plugin tests first, then the `teamplay` package test suite.
+
+## Public Entry Points
+
+The public `teamplay` package exports multiple surfaces from [packages/teamplay/package.json](./packages/teamplay/package.json):
+
+- `teamplay`: main public API, including `$`, `Signal`, `sub`, React hooks, model helpers, schema helpers, aggregation/access-control helpers, and compatibility exports.
+- `teamplay/orm`: lower-level ORM exports for runtime internals and advanced usage.
+- `teamplay/connect`: browser/client connection setup.
+- `teamplay/server`: server-side backend and channel setup.
+- `teamplay/file-based-models`: generated model loading support.
+- `teamplay/babel` and `teamplay/babel/loader`: build-time model transforms.
+- `teamplay/connect-test` and `teamplay/connect-offline`: test/offline connection variants.
+- `teamplay/cache` and `teamplay/schema`: convenience re-exports.
+
+The main public entry is [packages/teamplay/index.ts](./packages/teamplay/index.ts). It creates the global root signal:
+
+```ts
+export const $ = getRootSignal({
+  rootId: GLOBAL_ROOT_ID,
+  rootFunction: universal$
+})
+```
+
+It also deliberately separates the public `Signal<T>` type facade from the runtime `Signal` constructor:
+
+```ts
+export type Signal<TValue = unknown> = PublicSignal<TValue>
+export const Signal = RuntimeSignal
+```
+
+That separation is covered in [typing-architecture.md](./typing-architecture.md). Runtime readers should still know it exists because changing runtime exports can affect public type UX.
+
+## Application Startup
+
+### Server Startup
+
+Typical server setup flows through `teamplay/server`:
+
+```ts
+import { createBackend, initConnection } from 'teamplay/server'
+import models from './model'
+import { initModels } from 'teamplay'
+
+initModels(models)
+const backend = createBackend({ secure: true })
+const channel = initConnection(backend)
+```
+
+Important files:
+
+- [packages/teamplay/server.js](./packages/teamplay/server.js)
+- [packages/backend/index.js](./packages/backend/index.js)
+- [packages/teamplay/orm/initModels.ts](./packages/teamplay/orm/initModels.ts)
+
+`teamplay/server` wraps `@teamplay/backend`. If `initModels()` has already registered models and `createBackend()` is called without an explicit `models` option, the wrapper passes the initialized model manifest into the backend.
+
+`initConnection(backend, options)` creates a server-side ShareDB connection through `backend.connect()`, stores it in the ORM singleton connection, sets default transport flags, and returns the server channel.
+
+The backend factory creates a ShareDB backend with:
+
+- database adapter from `packages/backend/db`,
+- pubsub from `packages/backend/redis`,
+- `sharedb-hooks`,
+- optional custom hooks,
+- access control,
+- server aggregation,
+- schema validation outside production,
+- connection logging and client lifecycle tracking.
+
+### Client Startup
+
+Typical browser/client setup flows through `teamplay/connect`:
+
+```ts
+import connect from 'teamplay/connect'
+
+connect({ base: '/channel' })
+```
+
+Important files:
+
+- [packages/teamplay/connect/index.js](./packages/teamplay/connect/index.js)
+- [packages/teamplay/connect/sharedbConnection.cjs](./packages/teamplay/connect/sharedbConnection.cjs)
+- [packages/channel](./packages/channel)
+- [packages/teamplay/orm/connection.ts](./packages/teamplay/orm/connection.ts)
+
+`connect()` creates a channel socket, wraps it in a ShareDB-compatible connection adapter, and stores it in the ORM singleton connection. If a connection already exists, it returns without replacing it.
+
+The singleton connection is a current architectural constraint. [packages/teamplay/orm/Root.ts](./packages/teamplay/orm/Root.ts) has TODOs for spawnable/per-root connections, but the current implementation assumes one active connection per runtime environment.
+
+## Models And Manifests
+
+TeamPlay supports file-based models. A model folder is transformed into a manifest where path patterns map to classes and metadata:
+
+```ts
+{
+  users: {
+    default: Users,
+    schema,
+    access,
+    _active
+  },
+  'users.*': {
+    default: User
+  }
+}
+```
+
+The Babel plugin and loader own discovery/generation. Runtime registration flows through [packages/teamplay/orm/initModels.ts](./packages/teamplay/orm/initModels.ts):
+
+- `initModels(models)` stores the manifest and registers every `default` class.
+- `defineModels(models)` is a typed identity helper for explicit manifests.
+- `getModels()` returns the current manifest for server features.
+- `resetModelsForTests()` clears global model registration.
+
+Signal class lookup is handled by [packages/teamplay/orm/addModel.ts](./packages/teamplay/orm/addModel.ts) and [packages/teamplay/orm/getSignal.ts](./packages/teamplay/orm/getSignal.ts). Patterns are path-based:
+
+- `users` matches the collection signal.
+- `users.*` matches document signals.
+- `users.*.profile` matches nested field signals.
+- `[id]` file segments are normalized to `*` by the model tooling.
+
+The model manifest is also important for backend features:
+
+- schemas feed validation,
+- access rules feed access-control middleware,
+- aggregation definitions feed server aggregation middleware,
+- generated declarations feed editor and TypeScript UX.
+
+## Signal Runtime
+
+Signals are proxy-wrapped instances. Most user code never sees raw signal instances.
+
+Main files:
+
+- [packages/teamplay/orm/getSignal.ts](./packages/teamplay/orm/getSignal.ts)
+- [packages/teamplay/orm/SignalBase.ts](./packages/teamplay/orm/SignalBase.ts)
+- [packages/teamplay/orm/Signal.ts](./packages/teamplay/orm/Signal.ts)
+- [packages/teamplay/orm/Root.ts](./packages/teamplay/orm/Root.ts)
+- [packages/teamplay/orm/rootContext.ts](./packages/teamplay/orm/rootContext.ts)
+
+`getSignal(root, segments, options)` is the signal factory. It:
+
+- requires a root id for root signals,
+- chooses a signal class with `getSignalClass(segments)`,
+- creates a raw signal instance,
+- wraps it in a `Proxy`,
+- stores root ownership metadata,
+- caches proxies by signal identity hash,
+- keeps parent dependencies alive for child signals that need them.
+
+The proxy is what makes this possible:
+
+```ts
+$.users[userId].profile.name
+```
+
+Every path segment creates another signal. No concrete `users`, `profile`, or `name` property has to exist on the base object.
+
+### Method Binding
+
+TeamPlay currently uses "extremely late bindings" in [packages/teamplay/orm/SignalBase.ts](./packages/teamplay/orm/SignalBase.ts). A property access always prefers creating a child signal. If that child signal is called like a function, the proxy `apply` trap can route the call back to a method on the parent signal model.
+
+This allows field names and method names to collide without losing object-tree access:
+
+```ts
+$user.displayName       // child signal
+$user.displayName()     // parent model method call
+```
+
+Aggregation rows have additional fallback behavior: when an aggregation row contains `_id` or `id`, model method calls can be routed back to the source document signal.
+
+This boundary is intentionally treated as high risk. Add focused behavior tests before changing proxy `apply` logic.
+
+## Storage Model
+
+TeamPlay has two runtime storage domains.
+
+### Public Data Tree
+
+The public data tree lives in [packages/teamplay/orm/dataTree.js](./packages/teamplay/orm/dataTree.js):
+
+- `dataTreeRaw` is the raw shared object tree.
+- `dataTree` is the observable wrapper.
+- public ShareDB docs are mirrored into this tree.
+
+Document signals read from this tree once docs are fetched/subscribed. Writes to public document paths flow back to ShareDB through `setPublicDoc()` / related helpers. Those helpers:
+
+- validate public document paths,
+- normalize id fields,
+- prevent accidental partial creation of missing docs,
+- clone and strip full-document identity fields where needed,
+- submit JSON0 diffs through ShareDB,
+- preserve local observable state in sync with ShareDB events.
+
+Public document ids are strings. Numeric segments are array indices, not document ids.
+
+### Root-Scoped Private Data
+
+Private/local data is root-owned and lives in [packages/teamplay/orm/rootContext.ts](./packages/teamplay/orm/rootContext.ts) plus [packages/teamplay/orm/privateData.js](./packages/teamplay/orm/privateData.js).
+
+Private storage is used for:
+
+- local/session/page state,
+- query materialization under `$queries`,
+- aggregation materialization under `$aggregations`,
+- root-owned runtime bookkeeping.
+
+Each root context tracks:
+
+- root id and fetch-only default,
+- private observable data and raw private data,
+- model listeners,
+- refs,
+- query and aggregation runtime hashes,
+- signal hashes,
+- direct document subscription counts.
+
+This is why root identity matters. A query result under one root should not leak into another root's private state, even when the public collection data is shared.
+
+`getLogicalRootSnapshot(rootId)` merges public data with root-private data for tools that need a root-shaped snapshot.
+
+## Subscriptions
+
+`sub()` is the plain JS subscription entry point. React's `useSub()` builds on the same runtime concepts.
+
+Main files:
+
+- [packages/teamplay/orm/sub.ts](./packages/teamplay/orm/sub.ts)
+- [packages/teamplay/orm/Doc.js](./packages/teamplay/orm/Doc.js)
+- [packages/teamplay/orm/Query.js](./packages/teamplay/orm/Query.js)
+- [packages/teamplay/orm/Aggregation.js](./packages/teamplay/orm/Aggregation.js)
+- [packages/teamplay/react/useSub.ts](./packages/teamplay/react/useSub.ts)
+
+### Document Subscription Flow
+
+```txt
+sub($.users[id])
+  -> detect public document signal
+  -> docSubscriptions.subscribe($doc)
+  -> ShareDB doc.fetch() or doc.subscribe()
+  -> Doc mirrors doc.data into dataTree
+  -> resolve with the same $doc signal
+```
+
+[packages/teamplay/orm/Doc.js](./packages/teamplay/orm/Doc.js) manages the ShareDB doc lifecycle. It tracks subscription/fetch mode, mirrors load/create/delete/op events into observable state, injects id fields into plain objects, and delays cleanup so short-lived UI ownership changes do not churn transport state.
+
+### Query Subscription Flow
+
+```txt
+sub($.users, params)
+  -> detect public collection signal
+  -> getQuerySignal(collectionName, params)
+  -> querySubscriptions.subscribe($query)
+  -> ShareDB createFetchQuery/createSubscribeQuery
+  -> query docs materialize into public dataTree
+  -> query ids/docs/extra materialize under root private $queries.<hash>
+  -> resolve with query signal
+```
+
+[packages/teamplay/orm/Query.js](./packages/teamplay/orm/Query.js) owns query lifecycle. The query signal itself is path-shaped like the collection, but its data is read through private query materialization:
+
+```txt
+$queries.<hash>.docs
+$queries.<hash>.ids
+$queries.<hash>.extra
+```
+
+Array readers on query signals map query ids back to document signals. This keeps query items behaving like document model signals instead of anonymous plain objects.
+
+### Aggregation Subscription Flow
+
+Aggregations reuse the query transport layer but materialize data under `$aggregations`:
+
+```txt
+sub(aggregationHeader, params)
+  -> normalize aggregation params
+  -> getAggregationSignal(collectionName, params)
+  -> aggregationSubscriptions.subscribe($aggregation)
+  -> ShareDB aggregation query
+  -> aggregation extra materializes under root private $aggregations.<hash>
+  -> resolve with aggregation signal
+```
+
+[packages/teamplay/orm/Aggregation.js](./packages/teamplay/orm/Aggregation.js) extends query behavior. Aggregation output comes from query `extra`, not from normal query `results`. If aggregation rows include `_id` or `id`, the runtime can inject configured id fields and route model method calls back to source documents.
+
+## Writes And Mutations
+
+Signal write methods are defined on the runtime signal base and delegated into smaller helper modules.
+
+Important files:
+
+- [packages/teamplay/orm/SignalBase.ts](./packages/teamplay/orm/SignalBase.ts)
+- [packages/teamplay/orm/signalReads.ts](./packages/teamplay/orm/signalReads.ts)
+- [packages/teamplay/orm/signalValueMutations.ts](./packages/teamplay/orm/signalValueMutations.ts)
+- [packages/teamplay/orm/signalStorageMutations.ts](./packages/teamplay/orm/signalStorageMutations.ts)
+- [packages/teamplay/orm/signalMutationGuards.ts](./packages/teamplay/orm/signalMutationGuards.ts)
+- [packages/teamplay/orm/dataTree.js](./packages/teamplay/orm/dataTree.js)
+- [packages/teamplay/orm/privateData.js](./packages/teamplay/orm/privateData.js)
+
+The mutation layer decides whether a signal path is:
+
+- a public document path,
+- a private/local path,
+- a generated query or aggregation path,
+- an id-field path,
+- a path that should be rejected.
+
+The UX goal is that users call normal signal methods:
+
+```ts
+$user.name.set('Ada')
+$draft.tags.push('typescript')
+$counter.increment(1)
+```
+
+The runtime should route the operation correctly and produce clear errors when a path cannot be mutated, such as top-level query arrays or aggregation rows.
+
+## React Integration
+
+React integration lives in [packages/teamplay/react](./packages/teamplay/react). The main public exports are:
+
+- `observer()`
+- `useSub()`
+- `useAsyncSub()`
+- `useSuspendMemo()`
+- local/session/page/document/query hooks, including compatibility hooks.
+
+`$` and `sub()` are intentionally universal: the root export in [packages/teamplay/index.ts](./packages/teamplay/index.ts) uses `universal$` so the same public API works in plain JS and React environments.
+
+React subscriptions must preserve the same runtime signal shapes as `sub()`:
+
+- document subscriptions return document signals,
+- collection queries return query signals that are assignable to collection array signals,
+- aggregations return aggregation signals,
+- query `ids` and `extra` remain explicit metadata signals.
+
+When changing React behavior, check both runtime correctness and end-user ergonomics: suspense timing, stable signal identity, cleanup, and editor-visible result types.
+
+## Backend Features
+
+The backend layer starts in [packages/backend/index.js](./packages/backend/index.js). It composes ShareDB with TeamPlay-specific server features.
+
+### Access Control
+
+Access control is initialized by `@teamplay/backend` through `features/accessControl`. It uses model manifests and the `@teamplay/sharedb-access` package to control create, read, update, and delete operations.
+
+Access rules should be treated as server authority. Client typing and generated declarations can make access functions pleasant to write, but runtime security must live on the backend.
+
+### Schema Validation
+
+Schema validation is initialized by `@teamplay/backend` through `features/validateSchema` when enabled and outside production. It uses model schemas plus the `@teamplay/sharedb-schema` package.
+
+Schema definitions also feed type generation. Keep runtime schema behavior and generated type behavior aligned when changing schema helpers.
+
+### Server Aggregations
+
+Server aggregation is initialized by `@teamplay/backend` through `features/serverAggregate`. It uses model aggregation definitions and the `@teamplay/server-aggregate` package to allow only server-defined aggregate queries.
+
+Client-side aggregation helpers ultimately produce query params that the server aggregation middleware understands.
+
+## File-Based Model Tooling
+
+The model tooling package is [packages/babel-plugin-teamplay](./packages/babel-plugin-teamplay). It owns build-time behavior such as:
+
+- discovering model files,
+- converting file paths into model patterns,
+- ignoring private `-` files,
+- grouping schema/access/aggregation files,
+- generating model manifests,
+- generating `teamplay-env.d.ts`,
+- supporting loader/plugin variants.
+
+Changes here often affect both runtime and typing:
+
+- Runtime: model manifests passed to `initModels()` and `createBackend()`.
+- Typing: generated module augmentation for collections, models, fields, schemas, access rules, and aggregations.
+
+Run Babel plugin tests and TeamPlay type tests for changes in this area.
+
+## Compatibility Layer
+
+Compatibility code lives under [packages/teamplay/orm/Compat](./packages/teamplay/orm/Compat) and related compat entry points.
+
+Compat exists to preserve old Racer/StartupJS-style behavior while TeamPlay moves toward the current object-tree signal API. It is temporary and should not be a target for broad TypeScript conversion or large new abstractions.
+
+The practical rule:
+
+- preserve compat behavior when shared runtime changes touch it,
+- add compat tests when shared behavior can regress,
+- avoid investing in compat-only rewrites unless required to unblock current behavior.
+
+## Testing Architecture
+
+Standard verification starts from root [package.json](./package.json):
+
+```sh
+npm test
+```
+
+That runs:
+
+```txt
+yarn workspace babel-plugin-teamplay test
+cd packages/teamplay && npm run test
+```
+
+The `teamplay` package test script runs:
+
+- `npm run test-types`
+- `npm run test-types:external`
+- `npm run test-server`
+- `npm run test-client`
+- `npm run test-compat`
+
+Compat tests are part of the standard `teamplay` package test flow and therefore part of the root `npm test` flow.
+
+Focused commands:
+
+```sh
+cd packages/teamplay && npm run test-types
+cd packages/teamplay && npm run test-types:external
+cd packages/teamplay && npm run test-server
+cd packages/teamplay && npm run test-client
+cd packages/teamplay && npm run test-compat
+yarn workspace babel-plugin-teamplay test
+```
+
+Client tests live in [packages/teamplay/test_client](./packages/teamplay/test_client). Numeric filenames define coarse execution order and [packages/teamplay/test_client/testSequencer.cjs](./packages/teamplay/test_client/testSequencer.cjs) preserves path order without maintaining an explicit file list.
+
+Server/runtime tests live in [packages/teamplay/test](./packages/teamplay/test). Type tests live in [packages/teamplay/test_types](./packages/teamplay/test_types) and the strict external consumer setup.
+
+The pre-commit hook runs lint-staged and root `npm test`, so changes should pass the same broad suite before commit.
+
+## Common Change Paths
+
+Use these entry points when deciding where a change belongs.
+
+| Change | Start here | Also check |
+| --- | --- | --- |
+| Public API export | [packages/teamplay/index.ts](./packages/teamplay/index.ts), [packages/teamplay/package.json](./packages/teamplay/package.json) | Type tests, external consumer tests |
+| Signal property access or method binding | [packages/teamplay/orm/SignalBase.ts](./packages/teamplay/orm/SignalBase.ts), [packages/teamplay/orm/getSignal.ts](./packages/teamplay/orm/getSignal.ts) | Proxy/apply tests, compat tests if shared |
+| Signal read behavior | [packages/teamplay/orm/signalReads.ts](./packages/teamplay/orm/signalReads.ts), [packages/teamplay/orm/signalArrayReaders.ts](./packages/teamplay/orm/signalArrayReaders.ts) | Query/aggregation/doc read tests |
+| Signal write behavior | [packages/teamplay/orm/signalValueMutations.ts](./packages/teamplay/orm/signalValueMutations.ts), [packages/teamplay/orm/signalStorageMutations.ts](./packages/teamplay/orm/signalStorageMutations.ts), [packages/teamplay/orm/dataTree.js](./packages/teamplay/orm/dataTree.js) | Public/private mutation tests |
+| Document subscription lifecycle | [packages/teamplay/orm/Doc.js](./packages/teamplay/orm/Doc.js) | Server tests, GC/cleanup tests |
+| Query lifecycle or metadata | [packages/teamplay/orm/Query.js](./packages/teamplay/orm/Query.js), [packages/teamplay/orm/sub.ts](./packages/teamplay/orm/sub.ts) | Query metadata type/runtime tests |
+| Aggregation behavior | [packages/teamplay/orm/Aggregation.js](./packages/teamplay/orm/Aggregation.js), backend server aggregation features | Aggregation row method tests |
+| Root ownership or private data | [packages/teamplay/orm/Root.ts](./packages/teamplay/orm/Root.ts), [packages/teamplay/orm/rootContext.ts](./packages/teamplay/orm/rootContext.ts), [packages/teamplay/orm/privateData.js](./packages/teamplay/orm/privateData.js) | Root cleanup and isolation tests |
+| Model discovery/generation | [packages/babel-plugin-teamplay](./packages/babel-plugin-teamplay) | Babel tests, generated-env snapshots, type tests |
+| Backend access/schema/aggregation | [packages/backend](./packages/backend), [packages/sharedb-access](./packages/sharedb-access), [packages/sharedb-schema](./packages/sharedb-schema), [packages/server-aggregate](./packages/server-aggregate) | Server tests and model manifest tests |
+| React subscription UX | [packages/teamplay/react](./packages/teamplay/react) | Client tests, suspense/cleanup tests, type tests |
+
+## Design Principles
+
+When changing this codebase:
+
+- Preserve the `$` object-tree UX unless a product decision says otherwise.
+- Keep public APIs stable and make runtime errors clear.
+- Put runtime facts in checked runtime helpers when practical.
+- Keep generated typing code mechanical and covered by snapshots/type tests.
+- Avoid broad rewrites of high-risk proxy behavior without focused tests first.
+- Treat root ownership as part of correctness; query/private state should not leak across roots.
+- Treat backend access control and schema validation as server-authoritative, not client hints.
+- Avoid large investments in Compat implementation files; keep them working until the compatibility layer is removed.
+- Update [architecture.md](./architecture.md), [typing-architecture.md](./typing-architecture.md), and [tasks.md](./tasks.md) when architectural direction changes.
diff --git a/docs-theme/index.tsx b/docs-theme/index.tsx
index 884473a..dde831c 100644
--- a/docs-theme/index.tsx
+++ b/docs-theme/index.tsx
@@ -7,9 +7,9 @@ export * from '@rspress/core/theme-original'
 
 export function Layout () {
   return (
-    <div className="project-layout">
-      <ProjectSidebar activeProject="teamplay" />
-      <div className="project-layout-content">
+    <div className='project-layout'>
+      <ProjectSidebar activeProject='teamplay' />
+      <div className='project-layout-content'>
         <DefaultLayout />
       </div>
     </div>
@@ -58,7 +58,7 @@ interface ProjectSidebarProps {
 
 function ProjectSidebar ({ activeProject }: ProjectSidebarProps) {
   return (
-    <nav className="project-sidebar">
+    <nav className='project-sidebar'>
       {PROJECTS.map((project) => (
         <a
           key={project.id}
@@ -66,8 +66,8 @@ function ProjectSidebar ({ activeProject }: ProjectSidebarProps) {
           className={`project-sidebar-button project-sidebar-button--${project.id} ${project.id === activeProject ? 'active' : ''}`}
           aria-label={project.name}
         >
-          <span className="project-sidebar-button__text">{project.label}</span>
-          <span className="project-sidebar-button__tooltip">{project.name}</span>
+          <span className='project-sidebar-button__text'>{project.label}</span>
+          <span className='project-sidebar-button__tooltip'>{project.name}</span>
         </a>
       ))}
     </nav>
diff --git a/docs/api/query-signals.md b/docs/api/query-signals.md
index 259b7a8..4ee5be4 100644
--- a/docs/api/query-signals.md
+++ b/docs/api/query-signals.md
@@ -18,6 +18,14 @@ A signal containing an array of IDs for the documents in the query result.
 const userIds = $activeUsers.ids.get()
 ```
 
+### extra
+
+A signal containing extra query metadata returned by the server, such as count metadata.
+
+```javascript
+const extra = $activeUsers.extra.get()
+```
+
 ### getIds()
 
 Returns an array of ids for the query results.
@@ -64,4 +72,5 @@ for (const $user of $activeUsers) {
 
 - Query signals are reactive. Changes to the underlying data or to the query result will automatically update components using the query signal.
 - The documents within a query signal are themselves signals, allowing for nested reactivity.
- - For public documents in query results, `_id` is available in `get()` results and matches the document id.
+- For public documents in query results, `_id` is available in `get()` results and matches the document id.
+- `ids` and `extra` are reserved metadata properties on query signals. Use the collection path, such as `$.users['ids']`, when you need a document whose id has one of those names.
diff --git a/docs/guide/installation.mdx b/docs/guide/installation.mdx
index bf52fba..7323f4c 100644
--- a/docs/guide/installation.mdx
+++ b/docs/guide/installation.mdx
@@ -8,9 +8,9 @@ TeamPlay can run in three different modes. Pick the one that matches your needs
 
 ## Modes
 
-- **In-memory (default)**: in-memory only, no server, no persistence across reloads.
+- **In-memory Mode (default)**: in-memory only, no server, no persistence across reloads.
 - **Offline Mode**: client-only with local persistence (browser or React Native), no server.
-- **Server Sync**: real-time synchronization with a backend server.
+- **Server Sync Mode**: real-time synchronization with a backend server.
 
 ## In-memory Mode
 
@@ -27,22 +27,17 @@ await connect()
 
 See [Offline Mode](/guide/offline-mode) for details and React Native setup.
 
-## Synchronization with Server
+## Server Sync Mode
 
-To enable synchronization with the server, follow these steps:
-
-### Client Setup
-
-Enable the connection on the client somewhere early in your client app:
+To sync data with a server, connect from the client somewhere early in your app startup:
 
 ```js
 import connect from 'teamplay/connect'
+
 await connect()
 ```
 
-### Server Setup
-
-On the server, you need to create the TeamPlay backend and then create a connection handler for WebSockets:
+On the server, create the TeamPlay backend and attach its WebSocket upgrade handler to your Node HTTP server:
 
 ```js
 import { createBackend, initConnection } from 'teamplay/server'
@@ -52,17 +47,29 @@ const { upgrade } = initConnection(backend)
 server.on('upgrade', upgrade) // Node's 'http' server instance
 ```
 
-## Database Configuration
+## Production Setup
+
+For development, no extra database setup is needed. If `MONGO_URL` is not set, TeamPlay stores server data in an SQLite file named `local.db` in the root of your project.
+
+You can still write MongoDB-style queries and aggregations in this local setup. TeamPlay emulates that query behavior with [`mingo`](https://github.com/kofrasa/mingo).
+
+For production, configure the services your deployment needs:
+
+- `MONGO_URL`: use [MongoDB](https://mongodb.com) instead of the local SQLite file.
+- `REDIS_URL`: required when you run multiple server instances, so real-time updates can be coordinated through [Redis](https://redis.io).
+
+:::note
+TeamPlay's `createBackend()` is a wrapper around creating a [ShareDB backend](https://share.github.io/sharedb/api/backend). If you need lower-level control, you can create a ShareDB backend yourself and pass it to `initConnection()`. `ShareDB` is re-exported from `teamplay/server`, so you can import it as `import { ShareDB } from 'teamplay/server'`.
+:::
 
-By default no extra database setup is needed and the data is gonna be saved into an SQLite file `local.db` in the root of your project.
+## Optional ORM Setup
 
-You can still use the MongoDB query syntax with aggregations which is emulated using [`mingo`](https://github.com/kofrasa/mingo).
+TeamPlay works without an ORM setup: you can use signals, subscriptions, and real-time sync directly. When your app starts to have named collections such as users, games, orders, or events, the ORM gives you a conventional place to define document schemas, model methods, access rules, and server aggregations.
 
-- For production use, it's recommended to use [MongoDB](https://mongodb.com). It will be automatically used if you set the environment variable `MONGO_URL`.
-- When deploying to a cluster with multiple instances, you also have to provide the environment variable `REDIS_URL` ([Redis](https://redis.io)).
+To use the full ORM features, follow the [ORM Quick Start](/orm/index#quick-start). It shows the extra setup for the `models/` folder, the Babel plugin, and the shared `models.setup.ts` file used by both client and server.
 
 :::note
-TeamPlay's `createBackend()` is a wrapper around creating a [ShareDB's backend](https://share.github.io/sharedb/api/backend). You can instead manually create a ShareDB backend yourself and pass it to `initConnection()`. `ShareDB` is re-exported from `teamplay/server`, you can get it as `import { ShareDB } from 'teamplay/server'`.
+StartupJS apps can skip the manual ORM setup. StartupJS configures model loading and initializes TeamPlay models automatically.
 :::
 
 Now that you have TeamPlay installed and configured, you're ready to start using it in your application!
diff --git a/docs/guide/typescript-support.md b/docs/guide/typescript-support.md
new file mode 100644
index 0000000..2ba714a
--- /dev/null
+++ b/docs/guide/typescript-support.md
@@ -0,0 +1,408 @@
+# TypeScript Support
+
+TeamPlay's TypeScript support connects three things:
+
+- schemas define the document shape
+- model classes define custom methods
+- generated module augmentation tells TypeScript which schema and model belong to each path
+
+If you use file-based models, TeamPlay generates the augmentation for you in `teamplay-env.d.ts`.
+
+## The Usual Setup
+
+Add the Babel plugin and put models in `models/`:
+
+```js
+// babel.config.cjs
+module.exports = {
+  plugins: ['teamplay/babel']
+}
+```
+
+```txt
+models/users/schema.ts
+models/users/index.ts
+models/users/[id].ts
+```
+
+The plugin writes `teamplay-env.d.ts` in the project root. Make sure your TypeScript config includes it:
+
+```json
+{
+  "include": ["**/*.ts", "**/*.tsx", "teamplay-env.d.ts"]
+}
+```
+
+Many app configs already include root `.d.ts` files through `**/*.ts` or `**/*.tsx`; add the file only if your editor or checker does not see it.
+
+If your generated imports include explicit `.ts` extensions, enable a modern resolver such as `moduleResolution: "Bundler"` or `moduleResolution: "NodeNext"`. For projects that import schema modules with explicit `.ts` extensions, also enable `allowImportingTsExtensions`.
+
+## Infer Document Types From Schemas
+
+With file-based models, TeamPlay generates a default document type for every collection schema module. Define the schema with `defineSchema()` and export it as default:
+
+```ts
+// models/users/schema.ts
+import { defineSchema } from 'teamplay'
+
+const schema = defineSchema({
+  name: {
+    type: 'string',
+    required: true,
+    label: 'Name',
+    description: 'Displayed in the profile'
+  },
+  email: { type: 'string' },
+  createdAt: { type: 'number', required: true }
+})
+
+export default schema
+```
+
+After `teamplay-env.d.ts` is generated, the schema module's default export is also usable as the document type:
+
+```ts
+import type User from './models/users/schema.ts'
+```
+
+`User` becomes:
+
+```ts
+type User = {
+  name: string
+  email?: string
+  createdAt: number
+}
+```
+
+Plain exported schema objects still work for backward compatibility, but `defineSchema()` is the conventional form and preserves literal inference without `as const`.
+
+## Type Model Classes
+
+Collection models extend `Signal<Document[]>`:
+
+```ts
+// models/users/index.ts
+import { Signal } from 'teamplay'
+import type User from './schema.ts'
+
+export default class UsersModel extends Signal<User[]> {
+  async addNew (user: Omit<User, 'createdAt'>) {
+    return await this.add({
+      ...user,
+      createdAt: Date.now()
+    })
+  }
+}
+```
+
+Document models extend `Signal<Document>`:
+
+```ts
+// models/users/[id].ts
+import { Signal } from 'teamplay'
+import type User from './schema.ts'
+
+export default class UserModel extends Signal<User> {
+  displayName () {
+    return this.name.get()
+  }
+}
+```
+
+Inside model methods, schema fields are typed signals:
+
+```ts
+this.name.get()      // string
+this.email.get()     // string | undefined
+this.createdAt.get() // number
+```
+
+## Use Typed Root Paths
+
+After `teamplay-env.d.ts` is generated, `$` knows your collections:
+
+```ts
+import { $, sub } from 'teamplay'
+
+const userId = await $.users.addNew({ name: 'Ada' })
+
+const $user = await sub($.users[userId])
+$user.displayName()
+$user.name.get()
+$user.email.set('ada@example.com')
+```
+
+`sub()` and `useSub()` preserve the same schema and model type:
+
+```ts
+const $users = await sub($.users, { name: 'Ada' })
+
+for (const $user of $users) {
+  $user.displayName()
+  $user.name.get()
+}
+```
+
+Query params are checked against the schema:
+
+```ts
+await sub($.users, {
+  name: 'Ada',
+  $sort: { createdAt: -1 }
+})
+```
+
+Aggregation output types are output-first:
+
+```ts
+import { aggregation, sub } from 'teamplay'
+import type User from '../models/users/schema.ts'
+
+const _activeUsers = aggregation<User[]>(({ orgId }: { orgId: string }) => [
+  { $match: { orgId, active: true } }
+])
+
+const $activeUsers = await sub(_activeUsers, { orgId })
+```
+
+For grouped or metadata output, pass that full result shape:
+
+```ts
+const _notificationStats = aggregation<{ total: number, unread: number }>(() => [])
+const $stats = await sub(_notificationStats)
+
+$stats.total.get()  // number
+$stats.unread.get() // number
+```
+
+## Type Component Props
+
+Use `Signal<T>` for signal props:
+
+```tsx
+import { observer, type Signal } from 'teamplay'
+import type User from '../models/users/schema.ts'
+
+const UserCard = observer(function UserCard ({ $user }: { $user: Signal<User> }) {
+  $user.displayName()
+  return $user.name.get()
+})
+```
+
+`Signal<User>` also includes the generated document model methods when `User` matches one known collection document type.
+
+For query, collection, or list props, use the array document type. The signal keeps the collection model methods, and item signals keep the document model methods:
+
+```ts
+function UsersList ({ $users }: { $users: Signal<User[]> }) {
+  $users.addNew()
+
+  for (const $user of $users) {
+    $user.displayName()
+  }
+}
+```
+
+This also works for query results from `sub()` and `useSub()`:
+
+```ts
+const $activeUsers = await sub($.users, { active: true })
+$activeUsers.addNew()
+```
+
+Top-level collection, query, and aggregation signals are array-readable with `map`, `reduce`, `find`, and iteration. Array mutators such as `push` and `pop` are only typed on actual array fields like `$user.tags`, because mutating a collection or query result as an array is not a valid runtime operation.
+
+If two collections have exactly the same document type, TeamPlay cannot safely infer which collection model belongs to `Signal<T>`, so it falls back to the plain typed signal shape.
+
+Query signals have typed metadata children:
+
+```ts
+const ids: string[] = $activeUsers.ids.get()
+const extra = $activeUsers.extra.get()
+```
+
+`ids` and `extra` are reserved on query signals. If a document id has the same name, access it from the collection object tree:
+
+```ts
+const $idsDocument = $.users['ids']
+```
+
+## Local Signals
+
+Local signals infer types from their initial value:
+
+```ts
+const $visible = $(false)
+$visible.get() // boolean
+
+const $draft = $({ name: '', email: '' })
+$draft.name.get() // string
+```
+
+You can also provide the type explicitly:
+
+```ts
+const $newUser = $<User>()
+const $showModal = $<boolean>()
+```
+
+This gives TypeScript the signal shape, but the runtime value is still uninitialized until you set or assign it.
+
+## Nested Models
+
+Nested files are generated into `TeamplayModels`:
+
+```txt
+models/games/[id]/players/[playerId].ts -> games.*.players.*
+```
+
+```ts
+// models/games/[id]/players/[playerId].ts
+import { Signal } from 'teamplay'
+import type Game from '../../schema.ts'
+
+type GamePlayer = Game['players'][number]
+
+export default class GamePlayerModel extends Signal<GamePlayer> {
+  displayName () {
+    return this.robot.get() ? `${this.name.get()} (bot)` : this.name.get()
+  }
+}
+```
+
+Then:
+
+```ts
+$.games[gameId].players[0].displayName()
+```
+
+## Field Descriptions In Editor Suggestions
+
+For simple schema files, TeamPlay generates field JSDoc from literal `label` and `description` values:
+
+```ts
+const schema = {
+  name: {
+    type: 'string',
+    label: 'Name',
+    description: 'Displayed in the profile'
+  }
+} as const
+```
+
+Editors can show that text when completing:
+
+```ts
+$.users[userId].name
+$.users[userId].$name
+```
+
+The generator supports common static forms:
+
+```ts
+export default {
+  name: { type: 'string', label: 'Name' }
+}
+```
+
+```ts
+const schema = {
+  name: { type: 'string', label: 'Name' }
+}
+
+export default schema
+```
+
+If the schema is dynamic or cannot be parsed safely, field JSDoc is skipped but the normal schema type can still work through TypeScript.
+
+## How The Generated File Works
+
+`teamplay-env.d.ts` augments the `teamplay` module and each schema module:
+
+```ts
+type UserSchema = typeof import('./models/users/schema').default
+
+declare module './models/users/schema' {
+  export default interface User extends FromJsonSchema<UserSchema> {}
+}
+
+declare module 'teamplay' {
+  interface TeamplayCollections {
+    users: JsonSchemaSpec<typeof schema, typeof UsersModel, typeof UserModel>
+  }
+
+  interface TeamplayModels {
+    'games.*.players.*': typeof GamePlayerModel
+  }
+
+  interface TeamplaySignalFields {
+    'users.*': UsersFields
+  }
+}
+```
+
+- Schema module augmentation makes `import type User from './models/users/schema.ts'` work.
+- `TeamplayCollections` registers collection schemas, collection model classes, and document model classes.
+- `TeamplayModels` registers extra model classes below documents.
+- `TeamplaySignalFields` preserves schema field JSDoc in signal completions.
+
+You normally do not edit this file.
+
+## Manual Augmentation
+
+If you do not use file-based models, or if a framework/plugin provides models that the local filesystem cannot see, add an augmentation file included by your `tsconfig.json`.
+
+```ts
+// types/teamplay.ts
+import type { CollectionSpec, SignalClass } from 'teamplay'
+
+interface FileDoc {
+  url: string
+  mimeType?: string
+}
+
+type FilesModel = SignalClass<FileDoc[]>
+type FileModel = SignalClass<FileDoc>
+
+declare module 'teamplay' {
+  interface TeamplayCollections {
+    files: CollectionSpec<FileDoc, FilesModel, FileModel>
+  }
+}
+```
+
+For schemas, prefer `JsonSchemaSpec`:
+
+```ts
+import type { JsonSchemaSpec } from 'teamplay'
+import schema from '../models/users/schema.ts'
+import UsersModel from '../models/users/index.ts'
+import UserModel from '../models/users/[id].ts'
+
+declare module 'teamplay' {
+  interface TeamplayCollections {
+    users: JsonSchemaSpec<typeof schema, typeof UsersModel, typeof UserModel>
+  }
+}
+```
+
+Manual augmentation should match the runtime registration. If the runtime and type registry disagree, TypeScript may suggest methods that are not present at runtime.
+
+## Known Limits
+
+TeamPlay keeps the object-tree document API as `$.users[id]`. TypeScript models that with broad string indexing, so it cannot perfectly distinguish every dynamic document id from every named collection property or model method. Named query metadata such as `ids` and `extra` stays precise, and bracket access is the clearest form when a document id collides with a named property.
+
+## Schema Type Coverage
+
+The type mapper covers the schema features used most often in TeamPlay apps:
+
+- objects and nested properties
+- arrays and tuple arrays
+- strings, numbers, integers, booleans, and nulls
+- enums and const values
+- `required: [...]`
+- field-level `required: true` in simplified schemas
+- `additionalProperties` and `patternProperties`
+
+Zod-like schemas can be used for type inference with `ZodSchemaSpec`, but TeamPlay does not currently convert Zod schemas to backend JSON Schema automatically. Use JSON Schema for runtime validation.
diff --git a/docs/guide/usage-in-startupjs.md b/docs/guide/usage-in-startupjs.md
new file mode 100644
index 0000000..86fa4b9
--- /dev/null
+++ b/docs/guide/usage-in-startupjs.md
@@ -0,0 +1,175 @@
+# Usage In StartupJS
+
+StartupJS uses TeamPlay as its signal and ORM layer. In StartupJS apps, use the same model conventions as TeamPlay, but import app-facing APIs from `startupjs`.
+
+For the full model convention, read [ORM](/orm/index). For generated types and `Signal<T>` examples, read [TypeScript Support](/guide/typescript-support).
+
+## Imports
+
+Import TeamPlay APIs through StartupJS:
+
+```ts
+import { $, Signal, observer, pug, sub, useSub } from 'startupjs'
+```
+
+Use direct `teamplay` imports only for low-level integration code.
+
+## Models Folder
+
+StartupJS loads file-based models automatically. Use `models/`:
+
+```txt
+models/users/schema.ts
+models/users/index.ts
+models/users/[id].ts
+models/users/access.ts
+models/users/_active.ts
+```
+
+StartupJS still supports the legacy `model/` folder as a fallback. If that fallback is used, TeamPlay prints a warning asking you to migrate to `models/`.
+
+The same loader also generates `teamplay-env.d.ts`. `npx startupjs check` runs that generator before typechecking.
+
+Pure TeamPlay apps use a manual `models.setup.ts` file. StartupJS apps should not create one for the same models because the StartupJS registry already imports file-based models, merges plugin models, and initializes TeamPlay.
+
+## Schema
+
+```ts
+// models/tasks/schema.ts
+import { defineSchema } from 'startupjs'
+
+const schema = defineSchema({
+  title: { type: 'string', required: true },
+  done: { type: 'boolean' },
+  createdAt: { type: 'number', required: true }
+})
+
+export default schema
+```
+
+StartupJS commonly uses TeamPlay's simplified schema format, where the top-level object is the document fields. If you write full JSON Schema, use `type: 'object'` at the root and put fields under `properties`.
+
+## Collection Model
+
+```ts
+// models/tasks/index.ts
+import { Signal } from 'startupjs'
+import type Task from './schema.ts'
+
+export default class TasksModel extends Signal<Task[]> {
+  async addNew (title: string) {
+    return await this.add({
+      title,
+      done: false,
+      createdAt: Date.now()
+    })
+  }
+}
+```
+
+## Document Model
+
+```ts
+// models/tasks/[id].ts
+import { Signal } from 'startupjs'
+import type Task from './schema.ts'
+
+export default class TaskModel extends Signal<Task> {
+  async toggle () {
+    await this.done.set(!this.done.get())
+  }
+}
+```
+
+## React Components
+
+Wrap components in `observer()` and subscribe to database data with `useSub()`:
+
+```tsx
+// app/tasks.tsx
+import { $, observer, pug, useSub } from 'startupjs'
+import { Button, Checkbox, Content, ScrollView, Span } from 'startupjs-ui'
+
+export default observer(function TasksPage () {
+  const $tasks = useSub($.tasks, { $sort: { createdAt: -1 } })
+
+  return pug`
+    ScrollView(full)
+      Content(padding)
+        Button(onPress=() => $.tasks.addNew('New task')) Add task
+        each $task in $tasks
+          Checkbox(
+            key=$task.getId()
+            value=$task.done.get()
+            onChange=() => $task.toggle()
+          )
+          Span= $task.title.get()
+  `
+})
+```
+
+Pass signals to child components instead of raw values:
+
+```tsx
+TaskRow($task=$task)
+```
+
+```tsx
+import { observer, pug, type Signal } from 'startupjs'
+import type Task from '../models/tasks/schema.ts'
+
+const TaskRow = observer(function TaskRow ({ $task }: { $task: Signal<Task> }) {
+  return pug`
+    Span= $task.title.get()
+  `
+})
+```
+
+`Signal<Task>` includes schema fields and document model methods when `Task` maps to one known collection.
+
+## Subscriptions Outside React
+
+Use `sub()` outside React:
+
+```ts
+const $task = await sub($.tasks[taskId])
+await $task.toggle()
+
+const $openTasks = await sub($.tasks, { done: false })
+```
+
+Private client state such as `$._session` is local and does not need subscriptions.
+
+## Access Rules And Aggregations
+
+Enable server features in `startupjs.config.js` when you need them:
+
+```js
+export default {
+  features: {
+    enableServer: true,
+    validateSchema: true,
+    serverAggregate: true,
+    accessControl: true
+  }
+}
+```
+
+Access rules live in `models/<collection>/access.ts`; aggregation files are named `_name.ts`. See [Access Control](/orm/access-control) and [Aggregations](/orm/aggregations) for examples.
+
+## Typechecking
+
+Use StartupJS' checker:
+
+```bash
+npx startupjs check
+```
+
+It runs a pug-aware TypeScript language service and generates `teamplay-env.d.ts` before checking. Plain `tsc --noEmit` does not understand StartupJS pug templates.
+
+For normal validation, run:
+
+```bash
+npx startupjs check
+npx eslint .
+```
diff --git a/docs/orm/access-control.md b/docs/orm/access-control.md
new file mode 100644
index 0000000..2412a48
--- /dev/null
+++ b/docs/orm/access-control.md
@@ -0,0 +1,179 @@
+# Access Control
+
+Access control defines which ShareDB operations are allowed for a collection. Access files are server-only model files and are removed from client bundles by the TeamPlay Babel plugin.
+
+## Define Rules
+
+Access rules live in `access.ts`:
+
+```ts
+// models/users/access.ts
+import { accessControl } from 'teamplay'
+
+export default accessControl({
+  read: ({ session }) => Boolean(session.userId),
+  create: ({ session }) => Boolean(session.userId),
+  update: ({ session, doc }) => session.userId === doc.id,
+  delete: false
+})
+```
+
+The object can contain four keys:
+
+- `create`: controls new document creation.
+- `read`: controls reading existing documents.
+- `update`: controls writes to existing documents.
+- `delete`: controls document deletion.
+
+Each rule can be:
+
+- `true`: always allow the operation.
+- `false`: deny the operation.
+- omitted: deny the operation.
+- a function: decide from the operation context.
+- `{ fn }`: ShareDB access validator object form.
+
+Validator functions can return a boolean or a promise resolving to a boolean.
+
+## Rule Contexts
+
+`create` receives the new document:
+
+```ts
+create: ({ type, newDoc, collection, docId, session }) => {
+  return Boolean(session.userId && newDoc.name)
+}
+```
+
+Shape:
+
+```ts
+{
+  type: 'create'
+  newDoc: User
+  collection: string
+  docId: string
+  session: { userId?: string }
+}
+```
+
+`read` receives the existing document:
+
+```ts
+read: ({ doc, session }) => {
+  return doc.public || doc.ownerId === session.userId
+}
+```
+
+Shape:
+
+```ts
+{
+  type: 'read'
+  doc: User
+  collection: string
+  docId: string
+  session: { userId?: string }
+}
+```
+
+`update` receives the document before and after the operation, plus raw ShareDB ops:
+
+```ts
+update: ({ doc, newDoc, ops, session }) => {
+  return doc.ownerId === session.userId && newDoc.ownerId === doc.ownerId
+}
+```
+
+Shape:
+
+```ts
+{
+  type: 'update'
+  doc: User
+  newDoc: User
+  ops: unknown[]
+  collection: string
+  docId: string
+  session: { userId?: string }
+}
+```
+
+`delete` receives the existing document:
+
+```ts
+delete: ({ doc, session }) => {
+  return doc.ownerId === session.userId
+}
+```
+
+Shape:
+
+```ts
+{
+  type: 'delete'
+  doc: User
+  collection: string
+  docId: string
+  session: { userId?: string }
+}
+```
+
+## Document And Session Types
+
+The first generic is the document shape. The second generic is the session shape.
+
+```ts
+import { accessControl } from 'teamplay'
+import type User from './schema.ts'
+
+interface Session {
+  userId?: string
+  role?: 'admin' | 'member'
+}
+
+export default accessControl<User, Session>({
+  read: ({ doc, session }) => {
+    return doc.public || doc.ownerId === session.userId || session.role === 'admin'
+  },
+  create: ({ newDoc, session }) => {
+    return Boolean(session.userId && newDoc.name)
+  },
+  update: ({ doc, newDoc, session }) => {
+    if (session.role === 'admin') return true
+    return doc.ownerId === session.userId && newDoc.ownerId === doc.ownerId
+  },
+  delete: ({ doc, session }) => {
+    return session.role === 'admin' || doc.ownerId === session.userId
+  }
+})
+```
+
+If you omit the session generic, `session` defaults to:
+
+```ts
+{ userId?: string }
+```
+
+## Custom Rule Values
+
+If your ShareDB access setup uses a custom validator that accepts extra rule values, pass the third generic:
+
+```ts
+export default accessControl<User, Session, 'admin' | 'owner'>({
+  read: 'owner',
+  delete: 'admin'
+})
+```
+
+Only use this when your backend access validator is configured to understand those values.
+
+## Client Security
+
+Access rules should stay server-only. The TeamPlay Babel plugin removes `accessControl()` calls from client bundles:
+
+```ts
+export default undefined
+```
+
+This lets client code import the same file graph without bundling authorization logic.
diff --git a/docs/orm/aggregations.md b/docs/orm/aggregations.md
new file mode 100644
index 0000000..cf981f4
--- /dev/null
+++ b/docs/orm/aggregations.md
@@ -0,0 +1,186 @@
+# Aggregations
+
+Aggregations define server-side query builders for cases that need Mongo aggregation stages such as `$group`, `$project`, `$lookup`, and `$unwind`.
+
+Use regular [Queries](/orm/queries) for simple `$match` and `$sort` cases.
+
+## Define An Aggregation
+
+Aggregation files start with `_` and live under the collection folder:
+
+```ts
+// models/users/_byRole.ts
+import { aggregation } from 'teamplay'
+
+interface ByRoleParams {
+  orgId: string
+}
+
+interface RoleCount {
+  _id: string
+  count: number
+}
+
+export default aggregation<RoleCount[]>(({ orgId }: ByRoleParams, { session }) => {
+  if (!session.userId) return []
+
+  return [
+    { $match: { orgId } },
+    { $group: { _id: '$role', count: { $sum: 1 } } }
+  ]
+})
+```
+
+The file name becomes the aggregation name. `models/users/_byRole.ts` is registered as `_byRole` on the `users` collection.
+
+## Subscribe
+
+Import the aggregation and subscribe to it:
+
+```ts
+import { sub } from 'teamplay'
+import _byRole from '../models/users/_byRole.ts'
+
+const $roles = await sub(_byRole, { orgId })
+```
+
+In React:
+
+```tsx
+import { useSub } from 'teamplay'
+import _byRole from '../models/users/_byRole.ts'
+
+const $roles = useSub(_byRole, { orgId })
+```
+
+## Callback Arguments
+
+The aggregation callback receives two arguments:
+
+```ts
+aggregation<Output>((params, context) => {
+  context.collection
+  context.session
+  context.isServer
+})
+```
+
+`params` is the object passed to `sub(_aggregation, params)` or `useSub(_aggregation, params)`.
+
+`context` contains:
+
+- `collection`: collection name this aggregation runs against.
+- `session`: request session. By default it is typed as `{ userId?: string }`.
+- `isServer`: whether the aggregation is being evaluated from server-side code.
+
+Return either a Mongo aggregation pipeline array:
+
+```ts
+return [
+  { $match: { orgId } },
+  { $group: { _id: '$role', count: { $sum: 1 } } }
+]
+```
+
+Or an aggregation query object:
+
+```ts
+return {
+  $aggregate: [
+    { $match: { orgId } }
+  ]
+}
+```
+
+## Output Types
+
+The first generic is the full subscription result shape.
+
+For row-like results:
+
+```ts
+interface RoleCount {
+  _id: string
+  count: number
+}
+
+export default aggregation<RoleCount[]>(() => [
+  { $group: { _id: '$role', count: { $sum: 1 } } }
+])
+```
+
+For document rows, use the schema type:
+
+```ts
+import type User from './schema.ts'
+
+export default aggregation<User[]>(({ orgId }: { orgId: string }) => [
+  { $match: { orgId, active: true } }
+])
+```
+
+For metadata output, pass the object shape:
+
+```ts
+export default aggregation<{ total: number, unread: number }>(() => [])
+```
+
+Then the subscribed signal follows that shape:
+
+```ts
+const $stats = await sub(_notificationStats)
+
+$stats.total.get()
+$stats.unread.get()
+```
+
+## Session Types
+
+By default, `context.session` is typed as:
+
+```ts
+{ userId?: string }
+```
+
+You can provide a custom session shape as the second generic:
+
+```ts
+interface Session {
+  userId?: string
+  role?: 'admin' | 'member'
+}
+
+export default aggregation<User[], Session>((params, { session }) => {
+  if (session.role !== 'admin') return []
+  return [{ $match: params }]
+})
+```
+
+If you also want to specify the collection type, pass session as the third generic:
+
+```ts
+export default aggregation<User[], 'users', Session>((params, { collection, session }) => {
+  return [{ $match: { collection, userId: session.userId } }]
+})
+```
+
+For one-off code, inline callback annotations also work:
+
+```ts
+export default aggregation<User[]>((params, { session }: { session: Session }) => {
+  return [{ $match: { userId: session.userId } }]
+})
+```
+
+## Client Security
+
+Aggregation files contain server code. The TeamPlay Babel plugin replaces `aggregation()` calls in client builds with aggregation headers:
+
+```ts
+__aggregationHeader<User[], Session>({
+  collection: 'users',
+  name: '_byRole'
+})
+```
+
+The server pipeline implementation is removed from the client bundle. This is why aggregation functions should be defined in `models/<collection>/_name.ts` files and imported from there.
diff --git a/docs/orm/file-based-models.md b/docs/orm/file-based-models.md
new file mode 100644
index 0000000..bb7ab0f
--- /dev/null
+++ b/docs/orm/file-based-models.md
@@ -0,0 +1,116 @@
+# File-Based Models
+
+File-based models are the conventional way to connect TeamPlay paths to schemas, model classes, access rules, and aggregations.
+
+## Prerequisites
+
+This page assumes file-based model loading is already configured.
+
+In a pure TeamPlay app, follow the [ORM Quick Start](/orm/index#quick-start) first. It shows how to enable the Babel plugin and initialize the discovered models from a shared setup file.
+
+In a StartupJS app, no manual setup is needed. StartupJS configures the loader and initializes models through its registry.
+
+## Folder Convention
+
+Use `models/` at the project root:
+
+```txt
+models/
+  users/
+    schema.ts
+    index.ts
+    [id].ts
+    access.ts
+    _active.ts
+    -helpers.ts
+```
+
+The loader maps files to paths:
+
+```txt
+models/users/index.ts       -> users
+models/users/[id].ts        -> users.*
+models/users/schema.ts      -> schema for users
+models/users/access.ts      -> access rules for users
+models/users/_active.ts     -> aggregation for users
+models/users/-helpers.ts    -> ignored
+```
+
+Rules:
+
+- `index.ts` maps to the containing path.
+- `[id]` maps to `*`.
+- `schema.ts`, `access.ts`, and `_name.ts` merge into the collection model object.
+- `_name.ts` is treated as an aggregation only directly inside a public top-level collection. Private collections such as `_session/` are regular model paths.
+- Files or folders starting with `-` are ignored.
+- `*` is not allowed in filenames. Use `[id]` instead.
+
+Legacy `$$name.ts` aggregation files are still loaded, but TeamPlay prints a warning. Rename them to `_name.ts`.
+
+Nested paths work the same way:
+
+```txt
+models/games/[id]/players/[playerId].ts -> games.*.players.*
+```
+
+Dots in filenames are also path separators, so `models/_session.connection.ts` maps to `_session.connection` and `models/users._active.ts` maps to the `_active` aggregation on `users`.
+
+## Generated Types
+
+The Babel plugin also generates `teamplay-env.d.ts` in the project root. It describes your collections, model classes, nested models, and schema field JSDoc for TypeScript.
+
+The file is not rewritten when content is unchanged, so it should not trigger hot reloads unnecessarily.
+
+Include it in `tsconfig.json` if your project does not already include root-level `.d.ts` files:
+
+```json
+{
+  "include": ["**/*.ts", "**/*.tsx", "teamplay-env.d.ts"]
+}
+```
+
+See [TypeScript Support](/guide/typescript-support) for the generated type system.
+
+## Custom Loading Pipelines
+
+The quick start initializes the discovered model object directly. Frameworks or plugin systems can modify or merge that object first, then initialize the final model graph:
+
+```ts
+// models.setup.ts
+import { initModels } from 'teamplay'
+import models from 'teamplay/file-based-models'
+
+const finalModels = {
+  ...models,
+  ...pluginModels
+}
+
+initModels(finalModels)
+```
+
+## Manual Registration
+
+Without file-based loading, pass a model manifest to `initModels()` yourself:
+
+```ts
+import { Signal, initModels } from 'teamplay'
+import userSchema from './models/users/schema.ts'
+import type User from './models/users/schema.ts'
+
+class UsersModel extends Signal<User[]> {}
+class UserModel extends Signal<User> {}
+
+initModels({
+  users: {
+    schema: userSchema,
+    default: UsersModel
+  },
+  'users.*': {
+    default: UserModel
+  }
+})
+```
+
+`initModels()` registers each `default` model class and stores the full manifest for backend features such as schemas, access rules, and aggregations. If you only need to attach custom signal classes and do not use a manifest, you can register classes directly with `addModel()`.
+
+When you skip file-based loading, you also need manual TypeScript augmentation. See [TypeScript Support](/guide/typescript-support#manual-augmentation).
diff --git a/docs/orm/index.md b/docs/orm/index.md
new file mode 100644
index 0000000..7d10139
--- /dev/null
+++ b/docs/orm/index.md
@@ -0,0 +1,208 @@
+# ORM
+
+TeamPlay models are `Signal` subclasses attached to paths in your data tree. The conventional setup is file-based: put schemas, model classes, access rules, and aggregations in `models/`, then initialize that model tree in both client and server entries.
+
+For TypeScript details, see [TypeScript Support](/guide/typescript-support). This section focuses on ORM conventions and runtime behavior.
+
+## Quick Start
+
+:::note
+StartupJS apps can skip this quick start. StartupJS configures the Babel model loader, loads file-based models, merges plugin models, and initializes TeamPlay models automatically through its registry.
+:::
+
+Add the Babel plugin when you want file-based models:
+
+```js
+// babel.config.cjs
+module.exports = {
+  plugins: ['teamplay/babel']
+}
+```
+
+Create a model folder:
+
+```txt
+models/
+  users/
+    schema.ts
+    index.ts
+    [id].ts
+    access.ts
+    _active.ts
+```
+
+Create a shared setup file:
+
+```ts
+// models.setup.ts
+import models from 'teamplay/file-based-models'
+import { initModels } from 'teamplay'
+
+initModels(models)
+```
+
+Import `models.setup.ts` before using TeamPlay model-backed APIs. On the client, put it near the top of your app entry:
+
+```ts
+// client entry
+import './models.setup.ts'
+```
+
+If you need to modify, merge, or filter the model object, do it in `models.setup.ts` so client and server initialize the same model graph.
+
+On the server, import `models.setup.ts` before creating the backend:
+
+```ts
+import './models.setup.ts'
+import { createBackend, initConnection } from 'teamplay/server'
+
+const backend = createBackend({
+  validateSchema: true
+})
+
+const { upgrade } = initConnection(backend)
+server.on('upgrade', upgrade)
+```
+
+`createBackend()` reuses models that were already initialized with `initModels()`.
+
+## Folder Map
+
+The loader maps files to TeamPlay paths:
+
+```txt
+models/users/index.ts       -> users
+models/users/[id].ts        -> users.*
+models/users/schema.ts      -> schema for users
+models/users/access.ts      -> access rules for users
+models/users/_active.ts     -> aggregation for users
+models/users/-helpers.ts    -> ignored
+models/_session/index.ts    -> _session
+```
+
+Use `[id]` for wildcard path segments. Do not use `*` in filenames.
+Private collections such as `_session/` are regular model paths; `_name.ts` becomes an aggregation only directly inside a public top-level collection.
+
+Read more in [File-Based Models](/orm/file-based-models).
+
+## Schema
+
+Create one `schema.ts` per collection:
+
+```ts
+// models/users/schema.ts
+import { defineSchema } from 'teamplay'
+
+export default defineSchema({
+  name: {
+    type: 'string',
+    required: true,
+    label: 'Name'
+  },
+  email: { type: 'string' },
+  createdAt: { type: 'number', required: true }
+})
+```
+
+When `validateSchema: true` is enabled on the backend, writes are validated with this schema. The generated `teamplay-env.d.ts` also makes the schema module's default export usable as the document type.
+
+Read more in [Schemas](/orm/schemas).
+
+## Models
+
+`models/users/index.ts` is the collection model:
+
+```ts
+import { Signal } from 'teamplay'
+import type User from './schema.ts'
+
+export default class UsersModel extends Signal<User[]> {
+  async addNew (user: Omit<User, 'createdAt'>) {
+    return await this.add({
+      ...user,
+      createdAt: Date.now()
+    })
+  }
+}
+```
+
+`models/users/[id].ts` is the document model:
+
+```ts
+import { Signal } from 'teamplay'
+import type User from './schema.ts'
+
+export default class UserModel extends Signal<User> {
+  displayName () {
+    return this.name.get()
+  }
+}
+```
+
+Read more in [Models](/orm/models).
+
+## Queries
+
+Use collection subscriptions for filtered lists:
+
+```ts
+import { $, sub } from 'teamplay'
+
+const $activeUsers = await sub($.users, {
+  active: true,
+  $sort: { createdAt: -1 }
+})
+
+for (const $user of $activeUsers) {
+  $user.displayName()
+}
+```
+
+Read more in [Queries](/orm/queries).
+
+## Aggregations
+
+Aggregation files start with `_` and live under the collection folder:
+
+```ts
+// models/users/_byRole.ts
+import { aggregation } from 'teamplay'
+
+interface RoleCount {
+  _id: string
+  count: number
+}
+
+export default aggregation<RoleCount[]>(({ orgId }: { orgId: string }, { session }) => {
+  if (!session.userId) return []
+
+  return [
+    { $match: { orgId } },
+    { $group: { _id: '$role', count: { $sum: 1 } } }
+  ]
+})
+```
+
+Client builds replace server aggregation implementations with safe aggregation headers.
+
+Read more in [Aggregations](/orm/aggregations).
+
+## Access Control
+
+Access rules live in `access.ts`:
+
+```ts
+// models/users/access.ts
+import { accessControl } from 'teamplay'
+
+export default accessControl({
+  read: ({ session }) => Boolean(session.userId),
+  create: ({ session }) => Boolean(session.userId),
+  update: ({ session, doc }) => session.userId === doc.id,
+  delete: false
+})
+```
+
+Client builds remove access rules from the bundle automatically.
+
+Read more in [Access Control](/orm/access-control).
diff --git a/docs/orm/models.md b/docs/orm/models.md
new file mode 100644
index 0000000..9ea8464
--- /dev/null
+++ b/docs/orm/models.md
@@ -0,0 +1,116 @@
+# Models
+
+Model files attach methods to paths in the TeamPlay data tree. A model is a `Signal` subclass.
+
+## Collection Models
+
+`models/users/index.ts` is the collection model. It receives the collection signal, so it should extend `Signal<User[]>`.
+
+```ts
+// models/users/index.ts
+import { Signal } from 'teamplay'
+import type User from './schema.ts'
+
+export default class UsersModel extends Signal<User[]> {
+  async addNew (user: Omit<User, 'createdAt'>) {
+    return await this.add({
+      ...user,
+      createdAt: Date.now()
+    })
+  }
+}
+```
+
+Collection methods are a good place for create helpers, default fields, and collection-level workflows.
+
+After initialization, collection methods are available from `$`:
+
+```ts
+const userId = await $.users.addNew({ name: 'Ada' })
+```
+
+## Document Models
+
+`models/users/[id].ts` is the document model. It receives one document signal, so it should extend `Signal<User>`.
+
+```ts
+// models/users/[id].ts
+import { Signal } from 'teamplay'
+import type User from './schema.ts'
+
+export default class UserModel extends Signal<User> {
+  displayName () {
+    return this.name.get()
+  }
+
+  async rename (name: string) {
+    await this.name.set(name)
+  }
+}
+```
+
+Document methods are useful for business operations that belong to one document:
+
+```ts
+const $user = await sub($.users[userId])
+
+$user.displayName()
+await $user.rename('Ada Lovelace')
+```
+
+For simple updates, use signal methods directly:
+
+```ts
+await $.users[userId].name.set('Ada')
+await $.users[userId].assign({ email: 'ada@example.com' })
+```
+
+## Nested Models
+
+Nested model files attach methods below a document:
+
+```txt
+models/games/[id]/players/[playerId].ts -> games.*.players.*
+```
+
+```ts
+// models/games/[id]/players/[playerId].ts
+import { Signal } from 'teamplay'
+import type Game from '../../schema.ts'
+
+type GamePlayer = Game['players'][number]
+
+export default class GamePlayerModel extends Signal<GamePlayer> {
+  displayName () {
+    return this.robot.get() ? `${this.name.get()} (bot)` : this.name.get()
+  }
+}
+```
+
+Now nested methods are available on matching paths:
+
+```ts
+$.games[gameId].players[0].displayName()
+```
+
+## Subscribe Before Reading
+
+Always subscribe to database data before reading it:
+
+```ts
+const $user = await sub($.users[userId])
+$user.displayName()
+```
+
+In React, use `useSub()`:
+
+```tsx
+import { $, observer, useSub } from 'teamplay'
+
+export default observer(function UserName ({ userId }: { userId: string }) {
+  const $user = useSub($.users[userId])
+  return $user.displayName()
+})
+```
+
+Local/private signals such as `$._session` do not need subscriptions.
diff --git a/docs/orm/queries.md b/docs/orm/queries.md
new file mode 100644
index 0000000..44b2f04
--- /dev/null
+++ b/docs/orm/queries.md
@@ -0,0 +1,93 @@
+# Queries
+
+Queries subscribe to filtered lists from a collection. Query signals are array-like and contain document signals for the collection.
+
+## Basic Query
+
+```ts
+import { $, sub } from 'teamplay'
+
+const $activeUsers = await sub($.users, {
+  active: true,
+  $sort: { createdAt: -1 }
+})
+
+for (const $user of $activeUsers) {
+  $user.displayName()
+}
+```
+
+In React:
+
+```tsx
+import { $, observer, useSub } from 'teamplay'
+
+export default observer(function ActiveUsers () {
+  const $users = useSub($.users, {
+    active: true,
+    $sort: { createdAt: -1 }
+  })
+
+  return $users.map($user => $user.displayName()).join(', ')
+})
+```
+
+## Query Params
+
+Query params use Mongo-style syntax:
+
+```ts
+await sub($.users, {
+  name: 'Ada',
+  age: { $gte: 18 },
+  role: { $in: ['admin', 'member'] },
+  $sort: { createdAt: -1 }
+})
+```
+
+When schemas are generated, TypeScript checks query fields and values against the collection schema.
+
+## Result Signals
+
+Query results behave like collection arrays for reading:
+
+```ts
+const names = $activeUsers.map($user => $user.displayName())
+
+for (const $user of $activeUsers) {
+  await $user.rename('Ada Lovelace')
+}
+```
+
+Collection model methods are also available on query result signals when the result points to the same collection:
+
+```ts
+const userId = await $activeUsers.addNew({
+  name: 'Grace',
+  createdAt: Date.now()
+})
+```
+
+Top-level query results are array-readable. Array mutators such as `push` and `pop` are only typed on actual array fields, because mutating a query result as an array is not a valid database operation.
+
+## Query Metadata
+
+Query signals expose metadata as named child signals:
+
+```ts
+const ids = $activeUsers.ids.get()
+const extra = $activeUsers.extra.get()
+```
+
+`ids` contains the ordered document ids for the current query result. `extra` contains server-provided metadata such as count results when the query returns it.
+
+These names are reserved on query signals. If a real document id is `ids` or `extra`, access that document through the collection object tree:
+
+```ts
+const $idsDocument = $.users['ids']
+const $extraDocument = $.users['extra']
+```
+
+## Queries vs Aggregations
+
+Use queries for simple filtering and sorting. Use [Aggregations](/orm/aggregations) for `$group`, `$project`, `$lookup`, `$unwind`, and other pipeline stages.
diff --git a/docs/orm/schemas.md b/docs/orm/schemas.md
new file mode 100644
index 0000000..c46b81f
--- /dev/null
+++ b/docs/orm/schemas.md
@@ -0,0 +1,118 @@
+# Schemas
+
+Schemas describe collection document shape. TeamPlay uses them for backend validation and TypeScript inference.
+
+## Define A Schema
+
+Create one `schema.ts` per collection:
+
+```ts
+// models/users/schema.ts
+import { defineSchema } from 'teamplay'
+
+export default defineSchema({
+  name: {
+    type: 'string',
+    required: true,
+    label: 'Name',
+    description: 'Public display name'
+  },
+  email: { type: 'string' },
+  active: { type: 'boolean' },
+  createdAt: { type: 'number', required: true }
+})
+```
+
+`defineSchema()` currently returns the schema unchanged at runtime. It marks the schema as intentionally defined and gives TypeScript the best literal inference without needing `as const`.
+
+Plain exported schema objects still work for backward compatibility, but `defineSchema()` is the conventional form.
+
+## Document Type
+
+The generated `teamplay-env.d.ts` makes the schema module's default export usable as the document type:
+
+```ts
+import type User from './models/users/schema.ts'
+import { Signal } from 'teamplay'
+
+class UserModel extends Signal<User> {
+  displayName () {
+    return this.name.get()
+  }
+}
+```
+
+You can still use `FromJsonSchema` manually when needed:
+
+```ts
+import { type FromJsonSchema } from 'teamplay'
+import schema from './models/users/schema.ts'
+
+type User = FromJsonSchema<typeof schema>
+```
+
+## Validation
+
+Enable schema validation on the backend:
+
+```ts
+import { createBackend } from 'teamplay/server'
+
+const backend = createBackend({
+  validateSchema: true
+})
+```
+
+Stored documents should be JSON-compatible: strings, numbers, booleans, nulls, arrays, and plain objects. Prefer `Date.now()` numbers over `Date` instances.
+
+## Simplified Schema
+
+Most TeamPlay apps use simplified schemas. If the root schema does not have `type: 'object'`, TeamPlay treats the top-level object as the collection document's properties:
+
+```ts
+export default defineSchema({
+  title: { type: 'string', required: true },
+  description: { type: 'string' },
+  properties: {
+    type: 'object',
+    properties: {
+      color: { type: 'string' }
+    }
+  }
+})
+```
+
+That means fields can be named `title`, `description`, `type`, `required`, `properties`, and other JSON Schema keywords.
+
+## Full JSON Schema
+
+Use full JSON Schema when you need root-level JSON Schema keywords:
+
+```ts
+export default defineSchema({
+  type: 'object',
+  required: ['title'],
+  properties: {
+    title: { type: 'string' },
+    description: { type: 'string' }
+  }
+})
+```
+
+## Labels And Descriptions
+
+The type generator reads simple schema files and adds JSDoc for signal fields when it can statically find literal `label` and `description` values:
+
+```ts
+export default defineSchema({
+  name: {
+    type: 'string',
+    label: 'Name',
+    description: 'Public display name'
+  }
+})
+```
+
+Then editor suggestions for `$user.name` and `$user.$name` can show the schema text.
+
+This is best-effort. If the schema is built dynamically, TeamPlay still infers the document shape from TypeScript, but field JSDoc may be skipped.
diff --git a/eslint.config.mjs b/eslint.config.mjs
new file mode 100644
index 0000000..b10dd52
--- /dev/null
+++ b/eslint.config.mjs
@@ -0,0 +1,30 @@
+import neostandard, { resolveIgnoresFromGitignore } from 'neostandard'
+import reactHooks from 'eslint-plugin-react-hooks'
+
+export default [
+  ...neostandard({
+    ts: true,
+    env: ['browser', 'node', 'mocha', 'jest'],
+    ignores: [
+      ...resolveIgnoresFromGitignore(),
+      'coverage*/**',
+      'doc_build/**'
+    ]
+  }),
+  {
+    plugins: {
+      'react-hooks': reactHooks
+    },
+    rules: {
+      'react-hooks/rules-of-hooks': 'error',
+      'react-hooks/exhaustive-deps': 'warn'
+    }
+  },
+  {
+    files: ['packages/teamplay/test_types/**/*.ts'],
+    rules: {
+      '@typescript-eslint/no-unused-vars': 'off',
+      'no-void': 'off'
+    }
+  }
+]
diff --git a/example/_serveClient.js b/example/_serveClient.js
index dcd04c7..0bbdfbe 100644
--- a/example/_serveClient.js
+++ b/example/_serveClient.js
@@ -1,4 +1,4 @@
-// simple bundler for client.js with live reload
+// simple bundler for client.jsx with live reload
 import esbuild from 'esbuild'
 import { watch } from 'fs'
 
@@ -26,7 +26,7 @@ export default function serveClient (server) {
 
 async function bundleClientJs () {
   cache ??= esbuild.build({
-    entryPoints: ['./client.js'],
+    entryPoints: ['./client.jsx'],
     bundle: true,
     write: false,
     format: 'esm',
@@ -42,7 +42,7 @@ async function bundleClientJs () {
   return (await cache).outputFiles[0].text
 }
 
-watch('./client.js', () => {
+watch('./client.jsx', () => {
   cache = undefined
   for (const reload of reloadClients) reload()
 })
diff --git a/example/client.js b/example/client.jsx
similarity index 72%
rename from example/client.js
rename to example/client.jsx
index 5c8811e..2b61b56 100644
--- a/example/client.js
+++ b/example/client.jsx
@@ -19,11 +19,13 @@ const App = observer(({ userId }) => {
   const { $points } = $user
   const increment = () => $points.set($points.get() + 1)
   const reset = () => $points.set(0)
-  return <div style={{ display: 'flex', gap: '10px' }}>
-    <button onClick={increment}>Points: {$points.get()}</button>
-    <button onClick={reset}>Reset</button>
-    <button onClick={() => $counter.increment()}>Local counter: {$counter.get()}</button>
-  </div>
+  return (
+    <div style={{ display: 'flex', gap: '10px' }}>
+      <button onClick={increment}>Points: {$points.get()}</button>
+      <button onClick={reset}>Reset</button>
+      <button onClick={() => $counter.increment()}>Local counter: {$counter.get()}</button>
+    </div>
+  )
 })
 
 const container = document.body.appendChild(document.createElement('div'))
diff --git a/package.json b/package.json
index 6f1d906..fda5ecf 100644
--- a/package.json
+++ b/package.json
@@ -9,7 +9,8 @@
   ],
   "scripts": {
     "start": "cd example && npm run start",
-    "test": "cd packages/teamplay && npm run test",
+    "lint": "eslint .",
+    "test": "yarn workspace babel-plugin-teamplay test && cd packages/teamplay && npm run test",
     "test-client": "cd packages/teamplay && npm run test-client",
     "test-server": "cd packages/teamplay && npm run test-server",
     "test-server-only": "cd packages/teamplay && npm run test-server-only",
@@ -24,22 +25,20 @@
   },
   "devDependencies": {
     "@rspress/core": "^2.0.0",
-    "@types/react": "~18.2.45",
+    "@types/node": "^25.6.0",
+    "@types/react": "^18.3.28",
+    "@types/react-dom": "^18.3.7",
     "dotenv-cli": "^11.0.0",
-    "eslint": "^8.56.0",
-    "eslint-config-startupjs": "^0.56.0-alpha.29",
+    "eslint": "^9.39.4",
+    "eslint-plugin-react-hooks": "^7.1.1",
     "husky": "^4.3.0",
     "lerna": "^9.0.3",
     "lint-staged": "^15.2.2",
-    "react": "^18.0.0",
-    "react-dom": "^18.0.0",
+    "neostandard": "^0.13.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
     "ts-node": "^10.9.2",
-    "typescript": "^5.1.3"
-  },
-  "eslintConfig": {
-    "extends": [
-      "startupjs"
-    ]
+    "typescript": "^6.0.3"
   },
   "lint-staged": {
     "*.{js,jsx,ts,tsx,mjs,cjs}": [
diff --git a/packages/babel-plugin-teamplay/file-based-models.js b/packages/babel-plugin-teamplay/file-based-models.js
new file mode 100644
index 0000000..a4149fb
--- /dev/null
+++ b/packages/babel-plugin-teamplay/file-based-models.js
@@ -0,0 +1 @@
+module.exports = require('./teamplay.models.virtual.js')
diff --git a/packages/babel-plugin-teamplay/file-based-models.node.js b/packages/babel-plugin-teamplay/file-based-models.node.js
new file mode 100644
index 0000000..14310cb
--- /dev/null
+++ b/packages/babel-plugin-teamplay/file-based-models.node.js
@@ -0,0 +1,3 @@
+const { loadFileBasedModelsSync } = require('./loader')
+
+module.exports = loadFileBasedModelsSync()
diff --git a/packages/babel-plugin-teamplay/index.js b/packages/babel-plugin-teamplay/index.js
new file mode 100644
index 0000000..ebc7216
--- /dev/null
+++ b/packages/babel-plugin-teamplay/index.js
@@ -0,0 +1,172 @@
+const { addDefault, addNamespace } = require('@babel/helper-module-imports')
+const eliminatorPlugin = require('@startupjs/babel-plugin-eliminator')
+const {
+  discoverModelImports,
+  generateTeamplayEnv,
+  getModelEliminationTransformFunctionCalls,
+  getModelsFolderInfo,
+  getRelativeModelPath,
+  normalizeOptions
+} = require('./loader')
+const {
+  getRequireContextModelPatternHelperSource
+} = require('./modelPatternRules')
+
+const VIRTUAL_MODELS_IMPORT_REGEX = /(?:^|\/)teamplay\.models\.virtual\.js$|(?:^|\/)startupjs\.models\.virtual\.js$/
+const VIRTUAL_AUTO_INIT_IMPORT_REGEX = /(?:^|\/)teamplay\.models\.auto-init\.virtual\.js$/
+const FILE_BASED_MODELS_IMPORT_REGEX = /^(?:teamplay|babel-plugin-teamplay)\/file-based-models$/
+
+module.exports = function teamplayBabelPlugin (api, rawOptions = {}) {
+  const { types: t, template } = api
+  const options = normalizeOptions(rawOptions)
+  const modelEliminator = options.clientOnly
+    ? eliminatorPlugin(api, {
+      shouldTransformFileChecker: options.shouldTransformFileChecker,
+      transformFunctionCalls: getModelEliminationTransformFunctionCalls()
+    })
+    : null
+
+  return {
+    name: 'babel-plugin-teamplay',
+    visitor: {
+      Program: {
+        enter ($program, state) {
+          modelEliminator?.visitor?.Program?.enter?.($program, state)
+
+          const filename = state.file.opts.filename
+          let triggered = false
+
+          for (const $import of $program.get('body')) {
+            if (!$import.isImportDeclaration()) continue
+            if (
+              isVirtualImport($import, VIRTUAL_MODELS_IMPORT_REGEX) ||
+              isVirtualImport($import, FILE_BASED_MODELS_IMPORT_REGEX)
+            ) {
+              if (options.types) generateTeamplayEnv(options)
+              if (options.useRequireContext) {
+                loadVirtualModelsRequireContext($import, { $program, filename, t, template, options })
+              } else {
+                loadVirtualModels($import, { $program, filename, t, template, options })
+              }
+              triggered = true
+              continue
+            }
+            if (isVirtualImport($import, VIRTUAL_AUTO_INIT_IMPORT_REGEX)) {
+              loadVirtualAutoInit($import, { $program, t, template, options })
+              triggered = true
+            }
+          }
+
+          if (triggered) $program.scope.crawl()
+        }
+      }
+    }
+  }
+}
+
+function loadVirtualModels ($import, { $program, filename, t, template, options }) {
+  validateDefaultImport($import, 'Virtual models import')
+  const buildModelsConst = template('const %%name%% = %%models%%')
+  const modelPatterns = discoverModelImports(filename, options)
+  const models = t.objectExpression([])
+
+  for (const modelPattern in modelPatterns) {
+    const parts = modelPatterns[modelPattern]
+    const fileParts = parts.map(part => {
+      if (part.type === 'model') return addNamespaceImport($program, part.value)
+      const partImport = addDefaultImport($program, part.value)
+      return t.objectExpression([t.objectProperty(t.stringLiteral(part.name), partImport)])
+    })
+    const objectAssign = t.callExpression(t.memberExpression(t.identifier('Object'), t.identifier('assign')), [
+      t.objectExpression([]),
+      ...fileParts
+    ])
+    models.properties.push(t.objectProperty(t.stringLiteral(modelPattern), objectAssign))
+  }
+
+  const name = $import.get('specifiers.0.local').node.name
+  $import.remove()
+  insertAfterLastImport($program, buildModelsConst({ name, models }))
+}
+
+function loadVirtualModelsRequireContext ($import, { $program, filename, t, template, options }) {
+  validateDefaultImport($import, 'Virtual models import')
+  const info = getModelsFolderInfo(options)
+  const name = $import.get('specifiers.0.local').node.name
+  $import.remove()
+
+  if (!info.exists) {
+    const buildEmptyModelsConst = template('const %%name%% = {}')
+    insertAfterLastImport($program, buildEmptyModelsConst({ name }))
+    return
+  }
+
+  const buildModelsConst = template(/* js */`
+    const __teamplayModelsContext = require.context(%%folder%%, true, /\\.[mc]?[jt]sx?$/)
+    const %%name%% = (() => {
+      let modelPatterns = __teamplayModelsContext.keys().reduce(
+        (res, filePath) => {
+          const pattern = __teamplayGetModelPattern(filePath)
+          if (pattern === null) return res
+          return { ...res, [pattern]: filePath }
+        },
+        {}
+      )
+      modelPatterns = __teamplaySanitizeAndMergeModelPatterns(modelPatterns)
+      const res = {}
+      for (const [modelPattern, parts] of Object.entries(modelPatterns)) {
+        const fileParts = parts.map(part => {
+          if (part.type === 'model') return __teamplayModelsContext(part.value)
+          return { [part.name]: __teamplayModelsContext(part.value).default }
+        })
+        res[modelPattern] = Object.assign({}, ...fileParts)
+      }
+      return res
+    })()
+    ${getRequireContextModelPatternHelperSource()}
+  `)
+
+  insertAfterLastImport($program, buildModelsConst({
+    name,
+    folder: t.stringLiteral(getRelativeModelPath(filename, options))
+  }))
+}
+
+function loadVirtualAutoInit ($import, { $program, template, options }) {
+  validateDefaultImport($import, 'Virtual auto-init import')
+  const name = $import.get('specifiers.0.local').node.name
+  const buildConst = template(`const %%name%% = ${options.autoInit ? 'true' : 'false'}`)
+  $import.remove()
+  insertAfterLastImport($program, buildConst({ name }))
+}
+
+function isVirtualImport ($import, regex) {
+  return regex.test($import.get('source').node.value)
+}
+
+function validateDefaultImport ($import, label) {
+  const $specifiers = $import.get('specifiers')
+  if ($specifiers.length === 0 || $specifiers.length > 1 || !$specifiers[0].isImportDefaultSpecifier()) {
+    throw $import.buildCodeFrameError(`${label} must have a single default import`)
+  }
+}
+
+function addDefaultImport ($program, sourceName) {
+  return addDefault($program, sourceName, {
+    importedType: 'es6',
+    importPosition: 'after'
+  })
+}
+
+function addNamespaceImport ($program, sourceName) {
+  return addNamespace($program, sourceName, {
+    importedType: 'es6',
+    importPosition: 'after'
+  })
+}
+
+function insertAfterLastImport ($program, node) {
+  const $lastImport = $program.get('body').filter($i => $i.isImportDeclaration()).pop()
+  if ($lastImport) $lastImport.insertAfter(node)
+  else $program.unshiftContainer('body', node)
+}
diff --git a/packages/babel-plugin-teamplay/loader.js b/packages/babel-plugin-teamplay/loader.js
new file mode 100644
index 0000000..8bd92f4
--- /dev/null
+++ b/packages/babel-plugin-teamplay/loader.js
@@ -0,0 +1,670 @@
+const { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, writeFileSync } = require('fs')
+const { dirname, join, relative, resolve: pathResolve } = require('path')
+const parser = require('@babel/parser')
+const JSON_SCHEMA_KEYWORDS = require('@teamplay/schema/json-schema-keywords')
+const pluralize = require('pluralize')
+const {
+  JS_EXT_REGEX,
+  getModelPatternFromRelativePath,
+  isAggregationPattern,
+  isCollectionPattern,
+  isLegacyAggregationName,
+  sanitizeAndMergeModelPatterns,
+  toImportPath
+} = require('./modelPatternRules')
+
+const MODEL_MAGIC_IMPORT_REGEX = /['"](?:teamplay|startupjs)['"]/
+const MODEL_ELIMINATION_FUNCTION_REGEX = /\b(?:aggregation|serverOnly|accessControl)\b/
+const warnedFallbackFolders = new Set()
+const warnedLegacyAggregationFiles = new Set()
+
+function normalizeOptions (options = {}) {
+  return {
+    root: options.root || process.cwd(),
+    modelsFolder: options.modelsFolder || 'models',
+    fallbackModelsFolders: options.fallbackModelsFolders || ['model'],
+    types: options.types !== false,
+    typesFile: options.typesFile || 'teamplay-env.d.ts',
+    autoInit: options.autoInit !== false,
+    clientOnly: options.clientOnly !== false,
+    useRequireContext: Boolean(options.useRequireContext),
+    shouldTransformFileChecker: options.shouldTransformFileChecker || shouldTransformClientCode,
+    warn: options.warn || console.warn
+  }
+}
+
+function getModelsFolderInfo (options = {}) {
+  options = normalizeOptions(options)
+  const mainFolder = join(options.root, options.modelsFolder)
+  if (existsSync(mainFolder) && lstatSync(mainFolder).isDirectory()) {
+    return {
+      folder: mainFolder,
+      folderName: options.modelsFolder,
+      usedFallback: false,
+      exists: true
+    }
+  }
+
+  for (const fallbackFolderName of options.fallbackModelsFolders) {
+    const fallbackFolder = join(options.root, fallbackFolderName)
+    if (!existsSync(fallbackFolder) || !lstatSync(fallbackFolder).isDirectory()) continue
+    const warningKey = `${options.root}:${options.modelsFolder}:${fallbackFolderName}`
+    if (!warnedFallbackFolders.has(warningKey)) {
+      warnedFallbackFolders.add(warningKey)
+      options.warn(
+        `[teamplay] Using legacy "${fallbackFolderName}/" models folder. ` +
+        `Please migrate to "${options.modelsFolder}/".`
+      )
+    }
+    return {
+      folder: fallbackFolder,
+      folderName: fallbackFolderName,
+      usedFallback: true,
+      exists: true
+    }
+  }
+
+  return {
+    folder: mainFolder,
+    folderName: options.modelsFolder,
+    usedFallback: false,
+    exists: false
+  }
+}
+
+function getRelativeModelPath (sourceFilePath, options = {}) {
+  const { folder } = getModelsFolderInfo(options)
+  return toImportPath(relative(dirname(pathResolve(options.root || process.cwd(), sourceFilePath)), folder))
+}
+
+function getModelFiles (options = {}) {
+  const info = getModelsFolderInfo(options)
+  if (!info.exists) return []
+  return getFilesRecursive(info.folder).sort()
+}
+
+function isModelFile (filename, code, options = {}) {
+  if (!filename || !JS_EXT_REGEX.test(filename)) return false
+  options = normalizeOptions(options)
+  const modelFolders = [options.modelsFolder, ...options.fallbackModelsFolders]
+  if (!hasModelFolderInPath(pathResolve(options.root, filename), modelFolders)) return false
+  if (code != null && !MODEL_MAGIC_IMPORT_REGEX.test(code)) return false
+  return true
+}
+
+function shouldTransformClientCode (_filename, code) {
+  return Boolean(
+    code &&
+    MODEL_MAGIC_IMPORT_REGEX.test(code) &&
+    MODEL_ELIMINATION_FUNCTION_REGEX.test(code)
+  )
+}
+
+function hasModelFolderInPath (filename, modelFolders) {
+  const pathSections = toImportPath(filename).split('/').filter(Boolean)
+  return modelFolders
+    .map(folder => toImportPath(folder).split('/').filter(Boolean))
+    .some(folderSections => containsSubsequence(pathSections, folderSections))
+}
+
+function containsSubsequence (sections, subsequence) {
+  if (subsequence.length === 0) return false
+  for (let i = 0; i <= sections.length - subsequence.length; i++) {
+    let matches = true
+    for (let j = 0; j < subsequence.length; j++) {
+      if (sections[i + j] !== subsequence[j]) {
+        matches = false
+        break
+      }
+    }
+    if (matches) return true
+  }
+  return false
+}
+
+function getModelEliminationTransformFunctionCalls () {
+  const magicImports = ['teamplay', 'startupjs']
+  return [{
+    functionName: 'aggregation',
+    magicImports,
+    requirements: {
+      argumentsAmount: 1,
+      directNamedExportedAsConst: true
+    },
+    replaceWith: {
+      newFunctionNameFromSameImport: '__aggregationHeader',
+      newCallArgumentsTemplate: `[
+        {
+          collection: %%filenameWithoutExtension%%,
+          name: %%directNamedExportConstName%%
+        }
+      ]`
+    }
+  }, {
+    functionName: 'aggregation',
+    magicImports,
+    requirements: {
+      argumentsAmount: 1,
+      directDefaultExported: true
+    },
+    replaceWith: {
+      newFunctionNameFromSameImport: '__aggregationHeader',
+      newCallArgumentsTemplate: `[
+        {
+          collection: %%folderAndFilenameWithoutExtension%%.split(/[\\\\/\\.]/).at(-2),
+          name: %%folderAndFilenameWithoutExtension%%.split(/[\\\\/\\.]/).at(-1)
+        }
+      ]`
+    }
+  }, {
+    functionName: 'aggregation',
+    magicImports,
+    requirements: {
+      argumentsAmount: 2
+    },
+    throwIfRequirementsNotMet: true,
+    replaceWith: {
+      newFunctionNameFromSameImport: '__aggregationHeader',
+      newCallArgumentsTemplate: '[%%argument1%%]'
+    }
+  }, {
+    functionName: 'accessControl',
+    magicImports,
+    replaceWith: {
+      remove: true
+    }
+  }, {
+    functionName: 'serverOnly',
+    magicImports,
+    replaceWith: {
+      remove: true
+    }
+  }]
+}
+
+function getRelativeModelImports (sourceFilePath, options = {}) {
+  const root = options.root || process.cwd()
+  return getModelFiles(options).map(filePath => {
+    const relativePath = toImportPath(relative(dirname(pathResolve(root, sourceFilePath)), filePath))
+    return relativePath.startsWith('.') ? relativePath : './' + relativePath
+  })
+}
+
+function getFilesRecursive (folder) {
+  const files = []
+  for (const filename of readdirSync(folder).sort()) {
+    const filePath = join(folder, filename)
+    const stat = lstatSync(filePath)
+    if (stat.isDirectory()) {
+      files.push(...getFilesRecursive(filePath))
+    } else if (JS_EXT_REGEX.test(filename)) {
+      files.push(filePath)
+    }
+  }
+  return files
+}
+
+function getModelPattern (filePath, options = {}) {
+  options = normalizeOptions(options)
+  const info = getModelsFolderInfo(options)
+  const relativePath = toImportPath(relative(info.folder, filePath))
+  const pattern = getModelPatternFromRelativePath(relativePath)
+  if (pattern == null) return null
+  warnIfLegacyAggregationFile(pattern, filePath, options)
+  return pattern
+}
+
+function warnIfLegacyAggregationFile (pattern, filePath, options) {
+  const sections = pattern.split('.')
+  const lastSection = sections.pop()
+  if (!isAggregationPattern(sections, lastSection) || !isLegacyAggregationName(lastSection)) return
+  const warningKey = pathResolve(filePath)
+  if (warnedLegacyAggregationFiles.has(warningKey)) return
+  warnedLegacyAggregationFiles.add(warningKey)
+  const oldPath = toImportPath(relative(options.root, filePath))
+  const newPath = oldPath.replace(/(^|\/)\$\$/, '$1_')
+  options.warn(
+    `[teamplay] Legacy aggregation filename "${oldPath}" is deprecated. ` +
+    `Rename it to "${newPath}". Aggregation files should use "_" prefix.`
+  )
+}
+
+function discoverModels (options = {}) {
+  const files = getModelFiles(options)
+  const modelPatterns = {}
+  for (const filePath of files) {
+    const modelPattern = getModelPattern(filePath, options)
+    if (modelPattern == null) continue
+    modelPatterns[modelPattern] = filePath
+  }
+  return sanitizeAndMergeModelPatterns(modelPatterns)
+}
+
+function discoverModelImports (sourceFilePath, options = {}) {
+  const root = options.root || process.cwd()
+  const modelPatterns = {}
+  for (const filePath of getModelFiles(options)) {
+    const modelPattern = getModelPattern(filePath, options)
+    if (modelPattern == null) continue
+    let importPath = toImportPath(relative(dirname(pathResolve(root, sourceFilePath)), filePath))
+    if (!importPath.startsWith('.')) importPath = './' + importPath
+    modelPatterns[modelPattern] = importPath
+  }
+  return sanitizeAndMergeModelPatterns(modelPatterns)
+}
+
+function loadFileBasedModels (options = {}) {
+  return loadFileBasedModelsSync(options)
+}
+
+function loadFileBasedModelsSync (options = {}) {
+  const modelPatterns = discoverModels(options)
+  const res = {}
+  for (const [modelPattern, parts] of Object.entries(modelPatterns)) {
+    const fileParts = []
+    for (const part of parts) {
+      const mod = requireModelFile(part.value)
+      if (part.type === 'model') fileParts.push(normalizeModelModule(mod))
+      else fileParts.push({ [part.name]: getDefaultExport(mod) })
+    }
+    res[modelPattern] = Object.assign({}, ...fileParts)
+  }
+  return res
+}
+
+function requireModelFile (filePath) {
+  try {
+    return require(filePath)
+  } catch (err) {
+    if (err?.code === 'ERR_REQUIRE_ASYNC_MODULE') {
+      throw Error(
+        `[teamplay] Cannot synchronously load file-based model "${filePath}" because it or one of its imports uses top-level await.\n` +
+        'Move top-level await out of model files or pass models explicitly to createBackend({ models }).'
+      )
+    }
+    throw err
+  }
+}
+
+function normalizeModelModule (mod) {
+  if (mod && typeof mod === 'object' && ('default' in mod || mod.__esModule)) return mod
+  return { default: mod }
+}
+
+function getDefaultExport (mod) {
+  if (mod && typeof mod === 'object' && 'default' in mod) return mod.default
+  return mod
+}
+
+function generateTeamplayEnv (options = {}) {
+  options = normalizeOptions(options)
+  if (!options.types) return
+  const models = discoverModels(options)
+  const content = buildTeamplayEnvContent(models, options)
+  const filePath = pathResolve(options.root, options.typesFile)
+  writeGeneratedFile(filePath, content)
+  return filePath
+}
+
+function buildTeamplayEnvContent (models, options = {}) {
+  options = normalizeOptions(options)
+  const root = options.root || process.cwd()
+  const typesFile = pathResolve(root, options.typesFile || 'teamplay-env.d.ts')
+  const typesDir = dirname(typesFile)
+  const imports = new Map()
+  const declarations = []
+  const helperTypes = []
+  const manifestLines = []
+  const fieldLines = []
+  const schemaModuleLines = []
+  let counter = 0
+
+  function addImport (filePath, prefix) {
+    const id = `__${prefix}${counter++}`
+    let importPath = toImportPath(relative(typesDir, filePath))
+    if (!importPath.startsWith('.')) importPath = './' + importPath
+    imports.set(id, importPath)
+    return id
+  }
+
+  for (const [pattern, parts] of Object.entries(models)) {
+    if (!pattern) continue
+    const modelPart = parts.find(part => part.type === 'model')
+    const schemaPart = parts.find(part => part.type === 'schema')
+    const entryLines = []
+    let schemaImport
+
+    if (modelPart) {
+      const modelImport = addImport(modelPart.value, isCollectionPattern(pattern) ? 'CollectionModel' : 'PathModel')
+      entryLines.push(`    default: typeof ${modelImport}`)
+    }
+
+    if (schemaPart) {
+      schemaImport = addImport(schemaPart.value, 'Schema')
+      entryLines.push(`    schema: typeof ${schemaImport}`)
+    }
+
+    if (entryLines.length) {
+      manifestLines.push(`  ${JSON.stringify(pattern)}: {\n${entryLines.join('\n')}\n  }`)
+    }
+
+    if (isCollectionPattern(pattern) && schemaPart) {
+      const collectionName = pattern
+      const docPattern = `${collectionName}.*`
+      const docType = `__${toTypeName(collectionName)}Doc`
+      const fieldsType = `__${toTypeName(collectionName)}Fields`
+      helperTypes.push(`type ${docType} = FromJsonSchema<typeof ${schemaImport}>`)
+      schemaModuleLines.push(buildSchemaDefaultInterface(
+        getRelativeModuleSpecifier(typesDir, schemaPart.value),
+        toDocumentTypeName(collectionName),
+        docType
+      ))
+
+      const schemaDocs = extractSchemaDocs(schemaPart.value)
+      if (schemaDocs.fields.length) {
+        helperTypes.push(buildFieldsInterface(fieldsType, docType, [collectionName, '*'], schemaDocs.fields))
+        fieldLines.push(`    ${JSON.stringify(docPattern)}: ${fieldsType}`)
+      }
+    }
+  }
+
+  if (!manifestLines.length && !fieldLines.length) {
+    return [
+      '// This file is generated by TeamPlay. Do not edit manually.',
+      '/* eslint-disable */',
+      "import 'teamplay'",
+      ''
+    ].join('\n')
+  }
+
+  for (const [id, importPath] of imports.entries()) {
+    declarations.push(`import type ${id} from ${JSON.stringify(importPath)}`)
+  }
+
+  return [
+    '// This file is generated by TeamPlay. Do not edit manually.',
+    '/* eslint-disable */',
+    "import { type CollectionsFromManifest, type FromJsonSchema, type PathModelsFromManifest, type SignalChild } from 'teamplay'",
+    ...declarations,
+    '',
+    manifestLines.length ? 'interface __TeamplayModelManifest {' : null,
+    ...manifestLines,
+    manifestLines.length ? '}' : null,
+    manifestLines.length ? '' : null,
+    ...helperTypes,
+    helperTypes.length ? '' : null,
+    ...schemaModuleLines,
+    schemaModuleLines.length ? '' : null,
+    "declare module 'teamplay' {",
+    manifestLines.length ? '  interface TeamplayCollections extends CollectionsFromManifest<__TeamplayModelManifest> {}' : null,
+    manifestLines.length ? '  interface TeamplayModels extends PathModelsFromManifest<__TeamplayModelManifest> {}' : null,
+    fieldLines.length ? '  interface TeamplaySignalFields {' : null,
+    ...fieldLines,
+    fieldLines.length ? '  }' : null,
+    '}',
+    ''
+  ].filter(line => line != null).join('\n')
+}
+
+function writeGeneratedFile (filePath, content) {
+  mkdirSync(dirname(filePath), { recursive: true })
+  if (existsSync(filePath) && readFileSync(filePath, 'utf8') === content) return
+  writeFileSync(filePath, content)
+}
+
+function getRelativeModuleSpecifier (fromDir, filePath) {
+  let importPath = toImportPath(relative(fromDir, filePath))
+  if (!importPath.startsWith('.')) importPath = './' + importPath
+  return stripJsExtension(importPath)
+}
+
+function stripJsExtension (filePath) {
+  return filePath.replace(JS_EXT_REGEX, '')
+}
+
+function buildSchemaDefaultInterface (moduleSpecifier, interfaceName, docType) {
+  return [
+    `declare module ${JSON.stringify(moduleSpecifier)} {`,
+    `  export default interface ${interfaceName} extends ${docType} {}`,
+    '}'
+  ].join('\n')
+}
+
+function buildFieldsInterface (name, docType, signalPath, fields, typePath = []) {
+  const lines = [`interface ${name} {`]
+  const nested = []
+  for (const field of fields) {
+    const childTypePath = [...typePath, field.name]
+    const childSignalPath = [...signalPath, field.name]
+    const valueType = buildTypeAtPath(docType, childTypePath)
+    let signalType = `SignalChild<${valueType}, readonly [${childSignalPath.map(JSON.stringify).join(', ')}]>`
+    if (field.fields?.length) {
+      const nestedName = `${name}_${toTypeName(field.name)}`
+      nested.push(buildFieldsInterface(nestedName, docType, childSignalPath, field.fields, childTypePath))
+      signalType = `${signalType} & ${nestedName}`
+    }
+    const jsdoc = buildJsdoc(field)
+    if (jsdoc) lines.push(jsdoc)
+    lines.push(`  readonly ${JSON.stringify(field.name)}: ${signalType}`)
+    if (jsdoc) lines.push(jsdoc)
+    lines.push(`  readonly ${JSON.stringify(`$${field.name}`)}: ${signalType}`)
+  }
+  lines.push('}')
+  return [lines.join('\n'), ...nested].join('\n\n')
+}
+
+function buildTypeAtPath (rootType, path) {
+  return path.reduce((res, segment) => `NonNullable<${res}>[${JSON.stringify(segment)}]`, rootType)
+}
+
+function buildJsdoc (field) {
+  const text = [field.label, field.description].filter(Boolean).join('\n\n')
+  if (!text) return ''
+  return [
+    '  /**',
+    ...text.replace(/\*\//g, '*\\/').split('\n').map(line => line ? `   * ${line}` : '   *'),
+    '   */'
+  ].join('\n')
+}
+
+function extractSchemaDocs (filePath) {
+  try {
+    const code = readFileSync(filePath, 'utf8')
+    const ast = parser.parse(code, {
+      sourceType: 'module',
+      plugins: ['typescript', 'jsx']
+    })
+    const objectExpression = findSchemaObject(ast)
+    if (!objectExpression) return { fields: [] }
+    return { fields: extractFields(objectExpression) }
+  } catch {
+    return { fields: [] }
+  }
+}
+
+function findSchemaObject (ast) {
+  let schemaObject
+  for (const node of ast.program.body) {
+    if (node.type === 'ExportDefaultDeclaration') {
+      const declaration = getSchemaObjectExpression(node.declaration)
+      if (declaration) return declaration
+    }
+    if (node.type === 'VariableDeclaration') {
+      for (const declaration of node.declarations) {
+        const init = getSchemaObjectExpression(declaration.init)
+        if (declaration.id.type === 'Identifier' && declaration.id.name === 'schema' && init) {
+          schemaObject = init
+        }
+      }
+    }
+  }
+  return schemaObject
+}
+
+function getSchemaObjectExpression (node) {
+  node = unwrapExpression(node)
+  if (node?.type === 'ObjectExpression') return node
+  if (node?.type !== 'CallExpression') return null
+  if (!isDefineSchemaCallee(node.callee)) return null
+  const schemaArg = unwrapExpression(node.arguments?.[0])
+  return schemaArg?.type === 'ObjectExpression' ? schemaArg : null
+}
+
+function isDefineSchemaCallee (callee) {
+  if (callee.type === 'Identifier') return callee.name === 'defineSchema'
+  if (callee.type !== 'MemberExpression') return false
+  const property = callee.property
+  return !callee.computed && property.type === 'Identifier' && property.name === 'defineSchema'
+}
+
+function extractFields (objectExpression, options = {}) {
+  const explicitProperties = Boolean(options.explicitProperties)
+  const propertiesObject = !explicitProperties && isFullObjectSchema(objectExpression)
+    ? getObjectProperty(objectExpression, 'properties')
+    : null
+  if (propertiesObject) {
+    return extractFields(propertiesObject, { explicitProperties: true })
+  }
+  return extractFieldsFromPropertiesObject(objectExpression, { explicitProperties })
+}
+
+function extractFieldsFromPropertiesObject (objectExpression, { explicitProperties }) {
+  const fields = []
+  for (const property of objectExpression.properties || []) {
+    if (property.type !== 'ObjectProperty' && property.type !== 'Property') continue
+    const name = getPropertyName(property.key)
+    if (!name) continue
+    const value = unwrapExpression(property.value)
+    if (value.type !== 'ObjectExpression') continue
+    if (!explicitProperties && isJsonSchemaKeyword(name) && !isSimplifiedKeywordField(value)) continue
+    const field = {
+      name,
+      label: getStringProperty(value, 'label'),
+      description: getStringProperty(value, 'description'),
+      fields: []
+    }
+    const nestedProperties = getObjectProperty(value, 'properties')
+    if (nestedProperties) field.fields = extractFields(nestedProperties, { explicitProperties: true })
+    fields.push(field)
+  }
+  return fields
+}
+
+function isSimplifiedKeywordField (value) {
+  return value?.type === 'ObjectExpression' && hasSchemaFieldIndicators(value)
+}
+
+function isFullObjectSchema (value) {
+  return getStringProperty(value, 'type') === 'object'
+}
+
+function isSchemaPropertiesMap (value) {
+  return value?.type === 'ObjectExpression' && !hasSchemaFieldIndicators(value)
+}
+
+function hasSchemaFieldIndicators (objectExpression) {
+  if (hasStringOrArrayProperty(objectExpression, 'type')) return true
+  if (hasStringProperty(objectExpression, 'label')) return true
+  if (hasStringProperty(objectExpression, 'description')) return true
+  if (hasStringProperty(objectExpression, 'input')) return true
+  if (hasBooleanOrArrayProperty(objectExpression, 'required')) return true
+  if (hasArrayProperty(objectExpression, 'enum')) return true
+  const propertiesObject = getObjectProperty(objectExpression, 'properties')
+  return propertiesObject ? isSchemaPropertiesMap(propertiesObject) : false
+}
+
+function hasStringProperty (objectExpression, name) {
+  const property = findProperty(objectExpression, name)
+  const value = unwrapExpression(property?.value)
+  return value?.type === 'StringLiteral'
+}
+
+function hasStringOrArrayProperty (objectExpression, name) {
+  const property = findProperty(objectExpression, name)
+  const value = unwrapExpression(property?.value)
+  return value?.type === 'StringLiteral' || value?.type === 'ArrayExpression'
+}
+
+function hasBooleanOrArrayProperty (objectExpression, name) {
+  const property = findProperty(objectExpression, name)
+  const value = unwrapExpression(property?.value)
+  return value?.type === 'BooleanLiteral' || value?.type === 'ArrayExpression'
+}
+
+function hasArrayProperty (objectExpression, name) {
+  const property = findProperty(objectExpression, name)
+  const value = unwrapExpression(property?.value)
+  return value?.type === 'ArrayExpression'
+}
+
+function getObjectProperty (objectExpression, name) {
+  const property = findProperty(objectExpression, name)
+  const value = unwrapExpression(property?.value)
+  return value?.type === 'ObjectExpression' ? value : undefined
+}
+
+function getStringProperty (objectExpression, name) {
+  const property = findProperty(objectExpression, name)
+  const value = unwrapExpression(property?.value)
+  return value?.type === 'StringLiteral' ? value.value : undefined
+}
+
+function findProperty (objectExpression, name) {
+  return (objectExpression.properties || []).find(property => {
+    if (property.type !== 'ObjectProperty' && property.type !== 'Property') return false
+    return getPropertyName(property.key) === name
+  })
+}
+
+function getPropertyName (key) {
+  if (key.type === 'Identifier') return key.name
+  if (key.type === 'StringLiteral') return key.value
+  return undefined
+}
+
+function unwrapExpression (node) {
+  while (
+    node?.type === 'TSAsExpression' ||
+    node?.type === 'TSSatisfiesExpression' ||
+    node?.type === 'TypeCastExpression'
+  ) {
+    node = node.expression
+  }
+  return node
+}
+
+function isJsonSchemaKeyword (key) {
+  return JSON_SCHEMA_KEYWORDS.includes(key)
+}
+
+function toTypeName (value) {
+  const res = String(value)
+    .replace(/^[^a-zA-Z_$]+/, '')
+    .replace(/[^a-zA-Z0-9_$]+(.)?/g, (_, char = '') => char.toUpperCase())
+  return res ? res[0].toUpperCase() + res.slice(1) : 'Model'
+}
+
+function toDocumentTypeName (collectionName) {
+  return toTypeName(pluralize.singular(collectionName))
+}
+
+module.exports = {
+  buildTeamplayEnvContent,
+  discoverModelImports,
+  discoverModels,
+  generateTeamplayEnv,
+  getModelEliminationTransformFunctionCalls,
+  getModelFiles,
+  getModelPattern,
+  getModelPatternFromRelativePath,
+  getModelsFolderInfo,
+  getRelativeModelImports,
+  getRelativeModelPath,
+  isModelFile,
+  loadFileBasedModels,
+  loadFileBasedModelsSync,
+  normalizeOptions,
+  sanitizeAndMergeModelPatterns,
+  shouldTransformClientCode,
+  toImportPath
+}
diff --git a/packages/babel-plugin-teamplay/modelPatternRules.js b/packages/babel-plugin-teamplay/modelPatternRules.js
new file mode 100644
index 0000000..578711e
--- /dev/null
+++ b/packages/babel-plugin-teamplay/modelPatternRules.js
@@ -0,0 +1,140 @@
+const JS_EXT_REGEX = /\.[mc]?[jt]sx?$/
+const MODEL_PATTERN_REGEX = /^[a-zA-Z0-9$_*.]+$/
+
+function toImportPath (filePath) {
+  return filePath.replace(/\\/g, '/')
+}
+
+function getModelPatternFromRelativePath (relativeFilePath) {
+  const normalizedPath = toImportPath(relativeFilePath).replace(/^\.\//, '')
+  if (normalizedPath.includes('*')) {
+    throw Error(`[models] Instead of '*' in model filename use '[id]'. Got: ${relativeFilePath}`)
+  }
+  let pattern = normalizedPath
+    .replace(/\[[^\]]+\]/g, '*')
+    .replace(JS_EXT_REGEX, '')
+    .replace(/[\\/]/g, '.')
+
+  if (pattern.split('.').some(section => section.startsWith('-'))) return null
+  if (!MODEL_PATTERN_REGEX.test(pattern)) {
+    throw Error(
+      `[models] Invalid model filename pattern: ${pattern}\n` +
+      `It has to comply with the following regex: ${MODEL_PATTERN_REGEX.toString()} with '[id]' instead of '*'`
+    )
+  }
+  if (pattern === 'index') pattern = ''
+  if (/\.index$/.test(pattern)) pattern = pattern.replace(/\.index$/, '')
+  return pattern
+}
+
+function sanitizeAndMergeModelPatterns (modelPatterns) {
+  const res = {}
+  for (const [modelPattern, value] of Object.entries(modelPatterns)) {
+    const sections = modelPattern.split('.')
+    const lastSection = sections.pop()
+    let pattern = sections.join('.')
+    let type
+    let method = 'push'
+    if (isAggregationPattern(sections, lastSection)) type = 'aggregation'
+    else if (lastSection === 'schema') type = 'schema'
+    else if (lastSection === 'access') type = 'access'
+    else {
+      type = 'model'
+      pattern = modelPattern
+      method = 'unshift'
+    }
+    res[pattern] ??= []
+    res[pattern][method]({ type, name: lastSection, value })
+  }
+  return res
+}
+
+function isCollectionPattern (pattern) {
+  return pattern && !pattern.includes('*') && !pattern.includes('.')
+}
+
+function isAggregationName (name) {
+  return /^_/.test(name) || isLegacyAggregationName(name)
+}
+
+function isAggregationPattern (parentSections, name) {
+  return (
+    isAggregationName(name) &&
+    parentSections.length === 1 &&
+    parentSections[0] &&
+    !parentSections[0].startsWith('_')
+  )
+}
+
+function isLegacyAggregationName (name) {
+  return /^\$\$/.test(name)
+}
+
+function getRequireContextModelPatternHelperSource () {
+  return /* js */`
+    function __teamplayGetModelPattern (modelFilename) {
+      const MODEL_PATTERN_REGEX = ${MODEL_PATTERN_REGEX.toString()}
+      let pattern = modelFilename
+      if (/\\*/.test(pattern)) throw Error("[models] Instead of '*' in model filename use '[id]'. Got: " + modelFilename)
+      pattern = pattern.replace(/\\[[^\\]]+\\]/g, '*')
+      pattern = pattern.replace(/^\\.\\//, '')
+      pattern = pattern.replace(/\\.[^.]+$/, '')
+      pattern = pattern.replace(/[\\\\/]/g, '.')
+      if (pattern.split('.').some(section => section.startsWith('-'))) return null
+      if (!MODEL_PATTERN_REGEX.test(pattern)) {
+        throw Error("[models] Invalid model filename pattern: " + modelFilename + "\\n" +
+          "It has to comply with the following regex: " + MODEL_PATTERN_REGEX.toString() + " with '[id]' instead of '*'")
+      }
+      if (pattern === 'index') pattern = ''
+      if (/\\.index$/.test(pattern)) pattern = pattern.replace(/\\.index$/, '')
+      return pattern
+    }
+    function __teamplaySanitizeAndMergeModelPatterns (modelPatterns) {
+      const res = {}
+      for (const [modelPattern, value] of Object.entries(modelPatterns)) {
+        const sections = modelPattern.split('.')
+        const lastSection = sections.pop()
+        let pattern = sections.join('.')
+        let type
+        let method = 'push'
+        if (
+          (/^_/.test(lastSection) || /^\\$\\$/.test(lastSection)) &&
+          sections.length === 1 &&
+          sections[0] &&
+          !sections[0].startsWith('_')
+        ) {
+          type = 'aggregation'
+          if (/^\\$\\$/.test(lastSection)) {
+            console.warn(
+              '[teamplay] Legacy aggregation filename "' + value + '" is deprecated. ' +
+              'Rename it to "' + value.replace(/(^|[\\\\/])\\$\\$/, '$1_') + '". ' +
+              'Aggregation files should use "_" prefix.'
+            )
+          }
+        } else if (lastSection === 'schema') type = 'schema'
+        else if (lastSection === 'access') type = 'access'
+        else {
+          type = 'model'
+          pattern = modelPattern
+          method = 'unshift'
+        }
+        res[pattern] ??= []
+        res[pattern][method]({ type, name: lastSection, value })
+      }
+      return res
+    }
+  `
+}
+
+module.exports = {
+  JS_EXT_REGEX,
+  MODEL_PATTERN_REGEX,
+  getRequireContextModelPatternHelperSource,
+  getModelPatternFromRelativePath,
+  isAggregationName,
+  isAggregationPattern,
+  isCollectionPattern,
+  isLegacyAggregationName,
+  sanitizeAndMergeModelPatterns,
+  toImportPath
+}
diff --git a/packages/babel-plugin-teamplay/package.json b/packages/babel-plugin-teamplay/package.json
new file mode 100644
index 0000000..a40f3e8
--- /dev/null
+++ b/packages/babel-plugin-teamplay/package.json
@@ -0,0 +1,33 @@
+{
+  "name": "babel-plugin-teamplay",
+  "version": "0.4.0-alpha.100",
+  "description": "Babel plugin for TeamPlay file-based models",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./loader": "./loader.js",
+    "./file-based-models": {
+      "node": "./file-based-models.node.js",
+      "default": "./file-based-models.js"
+    }
+  },
+  "scripts": {
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@babel/helper-module-imports": "^7.0.0",
+    "@babel/parser": "^7.0.0",
+    "@babel/traverse": "^7.0.0",
+    "@startupjs/babel-plugin-eliminator": "^0.62.0-alpha.0",
+    "@teamplay/schema": "^0.4.0-alpha.9",
+    "pluralize": "^8.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.9.0",
+    "vitest": "^4.1.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}
diff --git a/packages/babel-plugin-teamplay/teamplay.models.virtual.js b/packages/babel-plugin-teamplay/teamplay.models.virtual.js
new file mode 100644
index 0000000..4ba52ba
--- /dev/null
+++ b/packages/babel-plugin-teamplay/teamplay.models.virtual.js
@@ -0,0 +1 @@
+module.exports = {}
diff --git a/packages/babel-plugin-teamplay/test/__snapshots__/index.test.mjs.snap b/packages/babel-plugin-teamplay/test/__snapshots__/index.test.mjs.snap
new file mode 100644
index 0000000..d6dcdf5
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/__snapshots__/index.test.mjs.snap
@@ -0,0 +1,649 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`babel-plugin-teamplay > eliminates default aggregation files for client builds 1`] = `
+"import { __aggregationHeader } from 'startupjs';
+type User = {
+  active: boolean;
+};
+export default __aggregationHeader<User[]>({
+  collection: "users/_active".split(/[\\\\/\\.]/).at(-2),
+  name: "users/_active".split(/[\\\\/\\.]/).at(-1)
+});"
+`;
+
+exports[`babel-plugin-teamplay > eliminates server-only model code for client builds 1`] = `
+"import { __aggregationHeader } from 'teamplay';
+type User = {
+  active: boolean;
+};
+export const _active = __aggregationHeader<User[]>({
+  collection: "users",
+  name: "_active"
+});
+export const access = undefined;
+export const secret = undefined;"
+`;
+
+exports[`babel-plugin-teamplay > eliminates server-only model code from nested plugin model folders 1`] = `
+"export const access = undefined;
+export const secret = undefined;"
+`;
+
+exports[`babel-plugin-teamplay > eliminates serverOnly code outside model folders based on source usage 1`] = `
+"import { Signal } from 'startupjs';
+export default class FileModel extends Signal {
+  getBlob = undefined;
+}"
+`;
+
+exports[`babel-plugin-teamplay > exports synchronous Node file-based models 1`] = `
+{
+  "users": {
+    "__esModule": true,
+    "_active": {
+      "name": "activeUsers",
+      "type": "function",
+    },
+    "access": {
+      "create": true,
+      "delete": false,
+      "read": true,
+      "update": {
+        "name": "update",
+        "type": "function",
+      },
+    },
+    "default": {
+      "name": "UsersModel",
+      "type": "function",
+    },
+    "schema": {
+      "name": {
+        "description": "Public display name",
+        "label": "User name",
+        "type": "string",
+      },
+      "profile": {
+        "properties": {
+          "bio": {
+            "label": "Bio",
+            "type": "string",
+          },
+        },
+        "type": "object",
+      },
+    },
+  },
+  "users.*": {
+    "__esModule": true,
+    "default": {
+      "name": "User",
+      "type": "function",
+    },
+  },
+}
+`;
+
+exports[`babel-plugin-teamplay > generates require.context loading code 1`] = `
+"const autoInit = true;
+const __teamplayModelsContext = require.context("../models", true, /\\.[mc]?[jt]sx?$/);
+const models = (() => {
+  let modelPatterns = __teamplayModelsContext.keys().reduce((res, filePath) => {
+    const pattern = __teamplayGetModelPattern(filePath);
+    if (pattern === null) return res;
+    return {
+      ...res,
+      [pattern]: filePath
+    };
+  }, {});
+  modelPatterns = __teamplaySanitizeAndMergeModelPatterns(modelPatterns);
+  const res = {};
+  for (const [modelPattern, parts] of Object.entries(modelPatterns)) {
+    const fileParts = parts.map(part => {
+      if (part.type === 'model') return __teamplayModelsContext(part.value);
+      return {
+        [part.name]: __teamplayModelsContext(part.value).default
+      };
+    });
+    res[modelPattern] = Object.assign({}, ...fileParts);
+  }
+  return res;
+})();
+function __teamplayGetModelPattern(modelFilename) {
+  const MODEL_PATTERN_REGEX = /^[a-zA-Z0-9$_*.]+$/;
+  let pattern = modelFilename;
+  if (/\\*/.test(pattern)) throw Error("[models] Instead of '*' in model filename use '[id]'. Got: " + modelFilename);
+  pattern = pattern.replace(/\\[[^\\]]+\\]/g, '*');
+  pattern = pattern.replace(/^\\.\\//, '');
+  pattern = pattern.replace(/\\.[^.]+$/, '');
+  pattern = pattern.replace(/[\\\\/]/g, '.');
+  if (pattern.split('.').some(section => section.startsWith('-'))) return null;
+  if (!MODEL_PATTERN_REGEX.test(pattern)) {
+    throw Error("[models] Invalid model filename pattern: " + modelFilename + "\\n" + "It has to comply with the following regex: " + MODEL_PATTERN_REGEX.toString() + " with '[id]' instead of '*'");
+  }
+  if (pattern === 'index') pattern = '';
+  if (/\\.index$/.test(pattern)) pattern = pattern.replace(/\\.index$/, '');
+  return pattern;
+}
+function __teamplaySanitizeAndMergeModelPatterns(modelPatterns) {
+  const res = {};
+  for (const [modelPattern, value] of Object.entries(modelPatterns)) {
+    const sections = modelPattern.split('.');
+    const lastSection = sections.pop();
+    let pattern = sections.join('.');
+    let type;
+    let method = 'push';
+    if ((/^_/.test(lastSection) || /^\\$\\$/.test(lastSection)) && sections.length === 1 && sections[0] && !sections[0].startsWith('_')) {
+      type = 'aggregation';
+      if (/^\\$\\$/.test(lastSection)) {
+        console.warn('[teamplay] Legacy aggregation filename "' + value + '" is deprecated. ' + 'Rename it to "' + value.replace(/(^|[\\\\/])\\$\\$/, '$1_') + '". ' + 'Aggregation files should use "_" prefix.');
+      }
+    } else if (lastSection === 'schema') type = 'schema';else if (lastSection === 'access') type = 'access';else {
+      type = 'model';
+      pattern = modelPattern;
+      method = 'unshift';
+    }
+    res[pattern] ??= [];
+    res[pattern][method]({
+      type,
+      name: lastSection,
+      value
+    });
+  }
+  return res;
+}
+export { models, autoInit };"
+`;
+
+exports[`babel-plugin-teamplay > generates static imports for file-based models 1`] = `
+"import * as _models_sessionConnectionTs from "../models/_session/connection.ts";
+import * as _models_sessionIndexTs from "../models/_session/index.ts";
+import * as _modelsEventsIdTs from "../models/events/[id].ts";
+import * as _modelsEventsIdCommentsCommentIdTs from "../models/events/[id]/comments/[commentId].ts";
+import * as _modelsEventsIndexTs from "../models/events/index.ts";
+import _default from "../models/events/_active.ts";
+import _default2 from "../models/events/access.ts";
+import _default3 from "../models/events/schema.ts";
+const autoInit = false;
+const models = {
+  "_session.connection": Object.assign({}, _models_sessionConnectionTs),
+  "_session": Object.assign({}, _models_sessionIndexTs),
+  "events.*": Object.assign({}, _modelsEventsIdTs),
+  "events.*.comments.*": Object.assign({}, _modelsEventsIdCommentsCommentIdTs),
+  "events": Object.assign({}, _modelsEventsIndexTs, {
+    "_active": _default
+  }, {
+    "access": _default2
+  }, {
+    "schema": _default3
+  })
+};
+export { models, autoInit };"
+`;
+
+exports[`babel-plugin-teamplay > generates teamplay-env.d.ts with schema field jsdoc 1`] = `
+"// This file is generated by TeamPlay. Do not edit manually.
+/* eslint-disable */
+import { type CollectionsFromManifest, type FromJsonSchema, type PathModelsFromManifest, type SignalChild } from 'teamplay'
+import type __PathModel0 from "./models/_session/connection.ts"
+import type __CollectionModel1 from "./models/_session/index.ts"
+import type __PathModel2 from "./models/events/[id].ts"
+import type __PathModel3 from "./models/events/[id]/comments/[commentId].ts"
+import type __CollectionModel4 from "./models/events/index.ts"
+import type __Schema5 from "./models/events/schema.ts"
+
+interface __TeamplayModelManifest {
+  "_session.connection": {
+    default: typeof __PathModel0
+  }
+  "_session": {
+    default: typeof __CollectionModel1
+  }
+  "events.*": {
+    default: typeof __PathModel2
+  }
+  "events.*.comments.*": {
+    default: typeof __PathModel3
+  }
+  "events": {
+    default: typeof __CollectionModel4
+    schema: typeof __Schema5
+  }
+}
+
+type __EventsDoc = FromJsonSchema<typeof __Schema5>
+interface __EventsFields {
+  /**
+   * Event title
+   *
+   * Visible public event name
+   */
+  readonly "title": SignalChild<NonNullable<__EventsDoc>["title"], readonly ["events", "*", "title"]>
+  /**
+   * Event title
+   *
+   * Visible public event name
+   */
+  readonly "$title": SignalChild<NonNullable<__EventsDoc>["title"], readonly ["events", "*", "title"]>
+  /**
+   * Event description
+   */
+  readonly "description": SignalChild<NonNullable<__EventsDoc>["description"], readonly ["events", "*", "description"]>
+  /**
+   * Event description
+   */
+  readonly "$description": SignalChild<NonNullable<__EventsDoc>["description"], readonly ["events", "*", "description"]>
+  /**
+   * Event type
+   */
+  readonly "type": SignalChild<NonNullable<__EventsDoc>["type"], readonly ["events", "*", "type"]>
+  /**
+   * Event type
+   */
+  readonly "$type": SignalChild<NonNullable<__EventsDoc>["type"], readonly ["events", "*", "type"]>
+  /**
+   * Requires approval
+   */
+  readonly "required": SignalChild<NonNullable<__EventsDoc>["required"], readonly ["events", "*", "required"]>
+  /**
+   * Requires approval
+   */
+  readonly "$required": SignalChild<NonNullable<__EventsDoc>["required"], readonly ["events", "*", "required"]>
+  /**
+   * Enum named field
+   */
+  readonly "enum": SignalChild<NonNullable<__EventsDoc>["enum"], readonly ["events", "*", "enum"]>
+  /**
+   * Enum named field
+   */
+  readonly "$enum": SignalChild<NonNullable<__EventsDoc>["enum"], readonly ["events", "*", "enum"]>
+  /**
+   * Const named field
+   */
+  readonly "const": SignalChild<NonNullable<__EventsDoc>["const"], readonly ["events", "*", "const"]>
+  /**
+   * Const named field
+   */
+  readonly "$const": SignalChild<NonNullable<__EventsDoc>["const"], readonly ["events", "*", "const"]>
+  /**
+   * Event properties
+   */
+  readonly "properties": SignalChild<NonNullable<__EventsDoc>["properties"], readonly ["events", "*", "properties"]> & __EventsFields_Properties
+  /**
+   * Event properties
+   */
+  readonly "$properties": SignalChild<NonNullable<__EventsDoc>["properties"], readonly ["events", "*", "properties"]> & __EventsFields_Properties
+  readonly "active": SignalChild<NonNullable<__EventsDoc>["active"], readonly ["events", "*", "active"]>
+  readonly "$active": SignalChild<NonNullable<__EventsDoc>["active"], readonly ["events", "*", "active"]>
+  readonly "details": SignalChild<NonNullable<__EventsDoc>["details"], readonly ["events", "*", "details"]> & __EventsFields_Details
+  readonly "$details": SignalChild<NonNullable<__EventsDoc>["details"], readonly ["events", "*", "details"]> & __EventsFields_Details
+  readonly "createdAt": SignalChild<NonNullable<__EventsDoc>["createdAt"], readonly ["events", "*", "createdAt"]>
+  readonly "$createdAt": SignalChild<NonNullable<__EventsDoc>["createdAt"], readonly ["events", "*", "createdAt"]>
+}
+
+interface __EventsFields_Properties {
+  /**
+   * Color
+   */
+  readonly "color": SignalChild<NonNullable<NonNullable<__EventsDoc>["properties"]>["color"], readonly ["events", "*", "properties", "color"]>
+  /**
+   * Color
+   */
+  readonly "$color": SignalChild<NonNullable<NonNullable<__EventsDoc>["properties"]>["color"], readonly ["events", "*", "properties", "color"]>
+}
+
+interface __EventsFields_Details {
+  /**
+   * Summary
+   */
+  readonly "summary": SignalChild<NonNullable<NonNullable<__EventsDoc>["details"]>["summary"], readonly ["events", "*", "details", "summary"]>
+  /**
+   * Summary
+   */
+  readonly "$summary": SignalChild<NonNullable<NonNullable<__EventsDoc>["details"]>["summary"], readonly ["events", "*", "details", "summary"]>
+}
+
+declare module "./models/events/schema" {
+  export default interface Event extends __EventsDoc {}
+}
+
+declare module 'teamplay' {
+  interface TeamplayCollections extends CollectionsFromManifest<__TeamplayModelManifest> {}
+  interface TeamplayModels extends PathModelsFromManifest<__TeamplayModelManifest> {}
+  interface TeamplaySignalFields {
+    "events.*": __EventsFields
+  }
+}
+"
+`;
+
+exports[`babel-plugin-teamplay > keeps model server code when clientOnly is false 1`] = `
+"import { accessControl } from 'teamplay';
+export const access = accessControl({
+  create: () => true
+});"
+`;
+
+exports[`babel-plugin-teamplay > loads file-based models directly in Node 1`] = `
+{
+  "users": {
+    "__esModule": true,
+    "_active": {
+      "name": "activeUsers",
+      "type": "function",
+    },
+    "access": {
+      "create": true,
+      "delete": false,
+      "read": true,
+      "update": {
+        "name": "update",
+        "type": "function",
+      },
+    },
+    "default": {
+      "name": "UsersModel",
+      "type": "function",
+    },
+    "schema": {
+      "name": {
+        "description": "Public display name",
+        "label": "User name",
+        "type": "string",
+      },
+      "profile": {
+        "properties": {
+          "bio": {
+            "label": "Bio",
+            "type": "string",
+          },
+        },
+        "type": "object",
+      },
+    },
+  },
+  "users.*": {
+    "__esModule": true,
+    "default": {
+      "name": "User",
+      "type": "function",
+    },
+  },
+}
+`;
+
+exports[`babel-plugin-teamplay > loads file-based models synchronously in Node 1`] = `
+{
+  "users": {
+    "__esModule": true,
+    "_active": {
+      "name": "activeUsers",
+      "type": "function",
+    },
+    "access": {
+      "create": true,
+      "delete": false,
+      "read": true,
+      "update": {
+        "name": "update",
+        "type": "function",
+      },
+    },
+    "default": {
+      "name": "UsersModel",
+      "type": "function",
+    },
+    "schema": {
+      "name": {
+        "description": "Public display name",
+        "label": "User name",
+        "type": "string",
+      },
+      "profile": {
+        "properties": {
+          "bio": {
+            "label": "Bio",
+            "type": "string",
+          },
+        },
+        "type": "object",
+      },
+    },
+  },
+  "users.*": {
+    "__esModule": true,
+    "default": {
+      "name": "User",
+      "type": "function",
+    },
+  },
+}
+`;
+
+exports[`babel-plugin-teamplay > snapshots client-transformed complex TypeScript model fixtures 1`] = `
+{
+  "models/-helpers/format.ts": "
+export default function formatTitle(title: string) {
+  return title.trim();
+}
+",
+  "models/_session/connection.ts": "
+import { Signal } from 'teamplay';
+interface ConnectionState {
+  token?: string;
+}
+export default class SessionConnectionModel extends Signal<ConnectionState> {
+  isConnected() {
+    return Boolean(this.token.get());
+  }
+}
+",
+  "models/_session/index.ts": "
+import { Signal } from 'teamplay';
+interface SessionState {
+  currentConnection?: string;
+}
+export default class SessionModel extends Signal<SessionState> {
+  hasConnection() {
+    return Boolean(this.currentConnection.get());
+  }
+}
+",
+  "models/events/[id].ts": "
+import { Signal } from 'teamplay';
+import type Event from './schema.ts';
+export default class EventModel extends Signal<Event> {
+  titleUpper() {
+    return this.title.get().toUpperCase();
+  }
+}
+",
+  "models/events/[id]/comments/[commentId].ts": "
+import { Signal } from 'teamplay';
+export interface EventComment {
+  message: string;
+}
+export default class EventCommentModel extends Signal<EventComment> {
+  preview() {
+    return this.message.get().slice(0, 10);
+  }
+}
+",
+  "models/events/_active.ts": "
+import { __aggregationHeader } from 'teamplay';
+import type Event from './schema.ts';
+interface EventSession {
+  userId?: string;
+  role?: 'admin' | 'member';
+}
+export default __aggregationHeader<Event[], EventSession>({
+  collection: "events/_active".split(/[\\\\/\\.]/).at(-2),
+  name: "events/_active".split(/[\\\\/\\.]/).at(-1)
+});
+",
+  "models/events/access.ts": "
+export default undefined;
+",
+  "models/events/index.ts": "
+import { Signal } from 'teamplay';
+import type Event from './schema.ts';
+export default class EventsModel extends Signal<Event[]> {
+  async addNew(event: Omit<Event, 'createdAt'>) {
+    return await this.add({
+      ...event,
+      createdAt: Date.now()
+    });
+  }
+}
+",
+  "models/events/schema.ts": "
+import { defineSchema, type FromJsonSchema } from 'teamplay';
+const schema = defineSchema({
+  title: {
+    type: 'string',
+    required: true,
+    label: 'Event title',
+    description: 'Visible public event name'
+  },
+  description: {
+    type: 'string',
+    label: 'Event description'
+  },
+  type: {
+    type: 'string',
+    label: 'Event type'
+  },
+  required: {
+    type: 'boolean',
+    label: 'Requires approval'
+  },
+  enum: {
+    type: 'string',
+    label: 'Enum named field'
+  },
+  const: {
+    type: 'number',
+    label: 'Const named field'
+  },
+  properties: {
+    type: 'object',
+    label: 'Event properties',
+    properties: {
+      color: {
+        type: 'string',
+        label: 'Color'
+      }
+    }
+  },
+  active: {
+    type: 'boolean'
+  },
+  details: {
+    type: 'object',
+    properties: {
+      summary: {
+        type: 'string',
+        label: 'Summary'
+      }
+    }
+  },
+  createdAt: {
+    type: 'number',
+    required: true
+  }
+});
+export default schema;
+export default interface Event extends FromJsonSchema<typeof schema> {}
+",
+}
+`;
+
+exports[`babel-plugin-teamplay > snapshots client-transformed simple JavaScript model fixtures 1`] = `
+{
+  "models/-helpers/format.js": "
+export default function format() {}
+",
+  "models/users/[id].js": "
+export default class User {}
+",
+  "models/users/_active.js": "
+import { __aggregationHeader } from 'teamplay';
+export default __aggregationHeader({
+  collection: "users/_active".split(/[\\\\/\\.]/).at(-2),
+  name: "users/_active".split(/[\\\\/\\.]/).at(-1)
+});
+",
+  "models/users/access.js": "
+export default undefined;
+",
+  "models/users/index.js": "
+export default class UsersModel {}
+",
+  "models/users/schema.js": "
+const schema = {
+  name: {
+    type: 'string',
+    label: 'User name',
+    description: 'Public display name'
+  },
+  profile: {
+    type: 'object',
+    properties: {
+      bio: {
+        type: 'string',
+        label: 'Bio'
+      }
+    }
+  }
+};
+export default schema;
+",
+}
+`;
+
+exports[`babel-plugin-teamplay > supports legacy $$ aggregation files with a warning 1`] = `
+[
+  "[teamplay] Legacy aggregation filename "models/users/$$active.js" is deprecated. Rename it to "models/users/_active.js". Aggregation files should use "_" prefix.",
+]
+`;
+
+exports[`babel-plugin-teamplay > transforms direct file-based models imports 1`] = `
+"import * as _models_sessionConnectionTs from "../models/_session/connection.ts";
+import * as _models_sessionIndexTs from "../models/_session/index.ts";
+import * as _modelsEventsIdTs from "../models/events/[id].ts";
+import * as _modelsEventsIdCommentsCommentIdTs from "../models/events/[id]/comments/[commentId].ts";
+import * as _modelsEventsIndexTs from "../models/events/index.ts";
+import _default from "../models/events/_active.ts";
+import _default2 from "../models/events/access.ts";
+import _default3 from "../models/events/schema.ts";
+const models = {
+  "_session.connection": Object.assign({}, _models_sessionConnectionTs),
+  "_session": Object.assign({}, _models_sessionIndexTs),
+  "events.*": Object.assign({}, _modelsEventsIdTs),
+  "events.*.comments.*": Object.assign({}, _modelsEventsIdCommentsCommentIdTs),
+  "events": Object.assign({}, _modelsEventsIndexTs, {
+    "_active": _default
+  }, {
+    "access": _default2
+  }, {
+    "schema": _default3
+  })
+};
+export default models;"
+`;
+
+exports[`babel-plugin-teamplay > transforms direct file-based models imports with fallback folders 1`] = `
+"import * as _modelUsersIdJs from "../model/users/[id].js";
+import * as _modelUsersIndexJs from "../model/users/index.js";
+const models = {
+  "users.*": Object.assign({}, _modelUsersIdJs),
+  "users": Object.assign({}, _modelUsersIndexJs)
+};
+export default models;"
+`;
+
+exports[`babel-plugin-teamplay > uses the legacy fallback folder with a warning 1`] = `
+[
+  "[teamplay] Using legacy "model/" models folder. Please migrate to "models/".",
+]
+`;
diff --git a/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/-helpers/format.ts b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/-helpers/format.ts
new file mode 100644
index 0000000..d76dcf0
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/-helpers/format.ts
@@ -0,0 +1,3 @@
+export default function formatTitle (title: string) {
+  return title.trim()
+}
diff --git a/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/_session/connection.ts b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/_session/connection.ts
new file mode 100644
index 0000000..ac853b0
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/_session/connection.ts
@@ -0,0 +1,11 @@
+import { Signal } from 'teamplay'
+
+interface ConnectionState {
+  token?: string
+}
+
+export default class SessionConnectionModel extends Signal<ConnectionState> {
+  isConnected () {
+    return Boolean(this.token.get())
+  }
+}
diff --git a/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/_session/index.ts b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/_session/index.ts
new file mode 100644
index 0000000..e4a09c8
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/_session/index.ts
@@ -0,0 +1,11 @@
+import { Signal } from 'teamplay'
+
+interface SessionState {
+  currentConnection?: string
+}
+
+export default class SessionModel extends Signal<SessionState> {
+  hasConnection () {
+    return Boolean(this.currentConnection.get())
+  }
+}
diff --git a/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/[id].ts b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/[id].ts
new file mode 100644
index 0000000..1528623
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/[id].ts
@@ -0,0 +1,8 @@
+import { Signal } from 'teamplay'
+import type Event from './schema.ts'
+
+export default class EventModel extends Signal<Event> {
+  titleUpper () {
+    return this.title.get().toUpperCase()
+  }
+}
diff --git a/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/[id]/comments/[commentId].ts b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/[id]/comments/[commentId].ts
new file mode 100644
index 0000000..dd8640a
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/[id]/comments/[commentId].ts
@@ -0,0 +1,11 @@
+import { Signal } from 'teamplay'
+
+export interface EventComment {
+  message: string
+}
+
+export default class EventCommentModel extends Signal<EventComment> {
+  preview () {
+    return this.message.get().slice(0, 10)
+  }
+}
diff --git a/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/_active.ts b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/_active.ts
new file mode 100644
index 0000000..2694573
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/_active.ts
@@ -0,0 +1,16 @@
+import { aggregation } from 'teamplay'
+import type Event from './schema.ts'
+
+interface EventSession {
+  userId?: string
+  role?: 'admin' | 'member'
+}
+
+export default aggregation<Event[], EventSession>(function activeEvents ({ active = true }: { active?: boolean }, { session }) {
+  return [{
+    $match: {
+      active,
+      ...(session.role === 'admin' ? {} : { createdBy: session.userId })
+    }
+  }]
+})
diff --git a/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/access.ts b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/access.ts
new file mode 100644
index 0000000..e03e9ca
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/access.ts
@@ -0,0 +1,13 @@
+import { accessControl } from 'teamplay'
+import type Event from './schema.ts'
+
+export default accessControl<Event, { userId?: string }>({
+  create ({ newDoc, session }) {
+    return Boolean(session?.userId && newDoc.title)
+  },
+  read: true,
+  update ({ doc, newDoc }) {
+    return doc.title !== newDoc.title
+  },
+  delete: false
+})
diff --git a/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/index.ts b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/index.ts
new file mode 100644
index 0000000..7e1bab6
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/index.ts
@@ -0,0 +1,11 @@
+import { Signal } from 'teamplay'
+import type Event from './schema.ts'
+
+export default class EventsModel extends Signal<Event[]> {
+  async addNew (event: Omit<Event, 'createdAt'>) {
+    return await this.add({
+      ...event,
+      createdAt: Date.now()
+    })
+  }
+}
diff --git a/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/schema.ts b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/schema.ts
new file mode 100644
index 0000000..a8b9720
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/models/events/schema.ts
@@ -0,0 +1,54 @@
+import { defineSchema, type FromJsonSchema } from 'teamplay'
+
+const schema = defineSchema({
+  title: {
+    type: 'string',
+    required: true,
+    label: 'Event title',
+    description: 'Visible public event name'
+  },
+  description: {
+    type: 'string',
+    label: 'Event description'
+  },
+  type: {
+    type: 'string',
+    label: 'Event type'
+  },
+  required: {
+    type: 'boolean',
+    label: 'Requires approval'
+  },
+  enum: {
+    type: 'string',
+    label: 'Enum named field'
+  },
+  const: {
+    type: 'number',
+    label: 'Const named field'
+  },
+  properties: {
+    type: 'object',
+    label: 'Event properties',
+    properties: {
+      color: {
+        type: 'string',
+        label: 'Color'
+      }
+    }
+  },
+  active: { type: 'boolean' },
+  details: {
+    type: 'object',
+    properties: {
+      summary: {
+        type: 'string',
+        label: 'Summary'
+      }
+    }
+  },
+  createdAt: { type: 'number', required: true }
+})
+
+export default schema
+export default interface Event extends FromJsonSchema<typeof schema> {}
diff --git a/packages/babel-plugin-teamplay/test/fixtures/complex-ts/package.json b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/package.json
new file mode 100644
index 0000000..089153b
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/complex-ts/package.json
@@ -0,0 +1 @@
+{"type":"module"}
diff --git a/packages/babel-plugin-teamplay/test/fixtures/dot-notation-ts/models/_session.connection.ts b/packages/babel-plugin-teamplay/test/fixtures/dot-notation-ts/models/_session.connection.ts
new file mode 100644
index 0000000..83209e2
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/dot-notation-ts/models/_session.connection.ts
@@ -0,0 +1,11 @@
+import { Signal } from 'teamplay'
+
+interface SessionConnectionState {
+  token?: string
+}
+
+export default class SessionConnectionModel extends Signal<SessionConnectionState> {
+  isConnected () {
+    return Boolean(this.token.get())
+  }
+}
diff --git a/packages/babel-plugin-teamplay/test/fixtures/dot-notation-ts/models/events._active.ts b/packages/babel-plugin-teamplay/test/fixtures/dot-notation-ts/models/events._active.ts
new file mode 100644
index 0000000..eea7c55
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/dot-notation-ts/models/events._active.ts
@@ -0,0 +1,5 @@
+import { aggregation } from 'teamplay'
+
+export default aggregation(function activeEvents () {
+  return [{ $match: { active: true } }]
+})
diff --git a/packages/babel-plugin-teamplay/test/fixtures/legacy-aggregation-js/models/users/$$active.js b/packages/babel-plugin-teamplay/test/fixtures/legacy-aggregation-js/models/users/$$active.js
new file mode 100644
index 0000000..0fd0901
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/legacy-aggregation-js/models/users/$$active.js
@@ -0,0 +1,5 @@
+import { aggregation } from 'teamplay'
+
+export default aggregation(function activeUsers () {
+  return [{ $match: { active: true } }]
+})
diff --git a/packages/babel-plugin-teamplay/test/fixtures/legacy-js/model/users/[id].js b/packages/babel-plugin-teamplay/test/fixtures/legacy-js/model/users/[id].js
new file mode 100644
index 0000000..fd7db7e
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/legacy-js/model/users/[id].js
@@ -0,0 +1 @@
+export default class User {}
diff --git a/packages/babel-plugin-teamplay/test/fixtures/legacy-js/model/users/index.js b/packages/babel-plugin-teamplay/test/fixtures/legacy-js/model/users/index.js
new file mode 100644
index 0000000..7ca6538
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/legacy-js/model/users/index.js
@@ -0,0 +1 @@
+export default class UsersModel {}
diff --git a/packages/babel-plugin-teamplay/test/fixtures/legacy-js/package.json b/packages/babel-plugin-teamplay/test/fixtures/legacy-js/package.json
new file mode 100644
index 0000000..089153b
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/legacy-js/package.json
@@ -0,0 +1 @@
+{"type":"module"}
diff --git a/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/-helpers/format.js b/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/-helpers/format.js
new file mode 100644
index 0000000..686d248
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/-helpers/format.js
@@ -0,0 +1 @@
+export default function format () {}
diff --git a/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/users/[id].js b/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/users/[id].js
new file mode 100644
index 0000000..fd7db7e
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/users/[id].js
@@ -0,0 +1 @@
+export default class User {}
diff --git a/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/users/_active.js b/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/users/_active.js
new file mode 100644
index 0000000..0fd0901
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/users/_active.js
@@ -0,0 +1,5 @@
+import { aggregation } from 'teamplay'
+
+export default aggregation(function activeUsers () {
+  return [{ $match: { active: true } }]
+})
diff --git a/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/users/access.js b/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/users/access.js
new file mode 100644
index 0000000..91fd2f6
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/users/access.js
@@ -0,0 +1,10 @@
+import { accessControl } from 'teamplay'
+
+export default accessControl({
+  create: true,
+  read: true,
+  update ({ session }) {
+    return Boolean(session?.userId)
+  },
+  delete: false
+})
diff --git a/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/users/index.js b/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/users/index.js
new file mode 100644
index 0000000..7ca6538
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/users/index.js
@@ -0,0 +1 @@
+export default class UsersModel {}
diff --git a/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/users/schema.js b/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/users/schema.js
new file mode 100644
index 0000000..1be30ea
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/simple-js/models/users/schema.js
@@ -0,0 +1,18 @@
+const schema = {
+  name: {
+    type: 'string',
+    label: 'User name',
+    description: 'Public display name'
+  },
+  profile: {
+    type: 'object',
+    properties: {
+      bio: {
+        type: 'string',
+        label: 'Bio'
+      }
+    }
+  }
+}
+
+export default schema
diff --git a/packages/babel-plugin-teamplay/test/fixtures/simple-js/package.json b/packages/babel-plugin-teamplay/test/fixtures/simple-js/package.json
new file mode 100644
index 0000000..089153b
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/simple-js/package.json
@@ -0,0 +1 @@
+{"type":"module"}
diff --git a/packages/babel-plugin-teamplay/test/fixtures/top-level-await-js/models/users/index.js b/packages/babel-plugin-teamplay/test/fixtures/top-level-await-js/models/users/index.js
new file mode 100644
index 0000000..4f8f55b
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/top-level-await-js/models/users/index.js
@@ -0,0 +1 @@
+export default await Promise.resolve(class UsersModel {})
diff --git a/packages/babel-plugin-teamplay/test/fixtures/top-level-await-js/package.json b/packages/babel-plugin-teamplay/test/fixtures/top-level-await-js/package.json
new file mode 100644
index 0000000..089153b
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/fixtures/top-level-await-js/package.json
@@ -0,0 +1 @@
+{"type":"module"}
diff --git a/packages/babel-plugin-teamplay/test/index.test.mjs b/packages/babel-plugin-teamplay/test/index.test.mjs
new file mode 100644
index 0000000..8e7c7f1
--- /dev/null
+++ b/packages/babel-plugin-teamplay/test/index.test.mjs
@@ -0,0 +1,626 @@
+import babel from '@babel/core'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { execFileSync } from 'node:child_process'
+import { cpSync, lstatSync, mkdtempSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, symlinkSync, utimesSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join, relative } from 'node:path'
+import { createRequire } from 'node:module'
+import { fileURLToPath } from 'node:url'
+import { runInNewContext } from 'node:vm'
+import plugin from '../index.js'
+import loader from '../loader.js'
+import modelPatternRules from '../modelPatternRules.js'
+import { schemaRuntimeFixtureMatrix } from '../../teamplay/test/schemaFixtureMatrix.ts'
+
+const {
+  discoverModels,
+  generateTeamplayEnv,
+  loadFileBasedModels,
+  loadFileBasedModelsSync
+} = loader
+const {
+  getModelPatternFromRelativePath,
+  getRequireContextModelPatternHelperSource,
+  sanitizeAndMergeModelPatterns: sanitizeModelPatterns
+} = modelPatternRules
+
+const TEST_DIR = dirname(fileURLToPath(import.meta.url))
+const REPO_ROOT = join(TEST_DIR, '../../..')
+const TSC_BIN = join(REPO_ROOT, 'node_modules/typescript/bin/tsc')
+const FIXTURES_DIR = join(TEST_DIR, 'fixtures')
+const SOURCE_FILE_REGEX = /\.[mc]?[jt]sx?$/
+const require = createRequire(import.meta.url)
+
+describe('babel-plugin-teamplay', () => {
+  let root
+
+  beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), 'teamplay-models-'))
+    mkdirSync(join(root, 'src'), { recursive: true })
+  })
+
+  afterEach(() => {
+    rmSync(root, { recursive: true, force: true })
+  })
+
+  it('generates static imports for file-based models', () => {
+    useFixture(root, 'complex-ts')
+
+    expect(transformVirtualImports({
+      root,
+      autoInit: false,
+      types: false
+    })).toMatchSnapshot()
+  })
+
+  it('generates require.context loading code', () => {
+    useFixture(root, 'complex-ts')
+
+    expect(transformVirtualImports({
+      root,
+      autoInit: true,
+      types: false,
+      useRequireContext: true
+    })).toMatchSnapshot()
+  })
+
+  it('uses the legacy fallback folder with a warning', () => {
+    const warnings = []
+    useFixture(root, 'legacy-js')
+
+    const models = discoverModels({ root, warn: message => warnings.push(message) })
+
+    expect(Object.keys(models).sort()).toEqual(['users', 'users.*'])
+    expect(warnings).toMatchSnapshot()
+  })
+
+  it('normalizes file model paths with shared pattern rules', () => {
+    expect(getModelPatternFromRelativePath('index.ts')).toBe('')
+    expect(getModelPatternFromRelativePath('users/index.ts')).toBe('users')
+    expect(getModelPatternFromRelativePath('users/[id].ts')).toBe('users.*')
+    expect(getModelPatternFromRelativePath('events/[id]/comments/[commentId].ts')).toBe('events.*.comments.*')
+    expect(getModelPatternFromRelativePath('./_session/connection.ts')).toBe('_session.connection')
+    expect(getModelPatternFromRelativePath('events/[id]/index.ts')).toBe('events.*')
+    expect(getModelPatternFromRelativePath('users/-helpers/format.ts')).toBeNull()
+    expect(getModelPatternFromRelativePath('users/-format.ts')).toBeNull()
+  })
+
+  it('rejects invalid file model path patterns with shared errors', () => {
+    expect(() => getModelPatternFromRelativePath('users/*.ts')).toThrow(/Instead of '\*' in model filename use '\[id\]'/)
+    expect(() => getModelPatternFromRelativePath('users/bad-name.ts')).toThrow(/Invalid model filename pattern: users\.bad-name/)
+  })
+
+  it('merges model, schema, access, and aggregation files through shared pattern rules', () => {
+    const models = sanitizeModelPatterns({
+      users: '/models/users/index.ts',
+      'users.*': '/models/users/[id].ts',
+      'users.schema': '/models/users/schema.ts',
+      'users.access': '/models/users/access.ts',
+      'users._active': '/models/users/_active.ts',
+      '_session.connection': '/models/_session/connection.ts',
+      'events.*.comments.*': '/models/events/[id]/comments/[commentId].ts'
+    })
+
+    expect(models.users.map(part => `${part.type}:${part.name}`)).toEqual([
+      'model:users',
+      'schema:schema',
+      'access:access',
+      'aggregation:_active'
+    ])
+    expect(models['users.*'].map(part => `${part.type}:${part.name}`)).toEqual(['model:*'])
+    expect(models['_session.connection'].map(part => `${part.type}:${part.name}`)).toEqual(['model:connection'])
+    expect(models['events.*.comments.*'].map(part => `${part.type}:${part.name}`)).toEqual(['model:*'])
+  })
+
+  it('keeps generated require.context model-pattern helpers aligned with shared rules', () => {
+    const generatedHelpers = getGeneratedRequireContextHelpers()
+    const paths = [
+      'index.ts',
+      'users/index.ts',
+      'users/[id].ts',
+      'events/[id]/comments/[commentId].ts',
+      './_session/connection.ts',
+      'events/[id]/index.ts',
+      'users/-helpers/format.ts'
+    ]
+
+    for (const path of paths) {
+      expect(generatedHelpers.getPattern(path)).toEqual(getModelPatternFromRelativePath(path))
+    }
+
+    expect(() => generatedHelpers.getPattern('users/*.ts')).toThrow(/Instead of '\*' in model filename use '\[id\]'/)
+    expect(() => generatedHelpers.getPattern('users/bad-name.ts')).toThrow(/Invalid model filename pattern/)
+
+    const modelPatterns = {
+      users: './users/index.ts',
+      'users.*': './users/[id].ts',
+      'users.schema': './users/schema.ts',
+      'users.access': './users/access.ts',
+      'users._active': './users/_active.ts',
+      '_session.connection': './_session/connection.ts'
+    }
+    expect(summarizeModelPatternParts(generatedHelpers.sanitizeAndMerge(modelPatterns)))
+      .toEqual(summarizeModelPatternParts(sanitizeModelPatterns(modelPatterns)))
+  })
+
+  it('supports legacy $$ aggregation files with a warning', () => {
+    const warnings = []
+    useFixture(root, 'legacy-aggregation-js')
+
+    const models = discoverModels({ root, warn: message => warnings.push(message) })
+
+    expect(Object.keys(models)).toEqual(['users'])
+    expect(models.users.map(part => `${part.type}:${part.name}`)).toEqual(['aggregation:$$active'])
+    expect(warnings).toMatchSnapshot()
+  })
+
+  it('treats private collections starting with _ as model paths', () => {
+    useFixture(root, 'complex-ts')
+
+    const models = discoverModels({ root })
+
+    expect(models._session.map(part => `${part.type}:${part.name}`)).toEqual(['model:_session'])
+    expect(models['_session.connection'].map(part => `${part.type}:${part.name}`)).toEqual(['model:connection'])
+    expect(models.events.map(part => `${part.type}:${part.name}`)).toContain('aggregation:_active')
+  })
+
+  it('supports dot notation without confusing private collections and aggregations', () => {
+    useFixture(root, 'dot-notation-ts')
+
+    const models = discoverModels({ root })
+
+    expect(models['_session.connection'].map(part => `${part.type}:${part.name}`)).toEqual(['model:connection'])
+    expect(models.events.map(part => `${part.type}:${part.name}`)).toEqual(['aggregation:_active'])
+  })
+
+  it('generates teamplay-env.d.ts with schema field jsdoc', () => {
+    useFixture(root, 'complex-ts')
+    const filePath = generateTeamplayEnv({ root })
+
+    expect(readFileSync(filePath, 'utf8')).toMatchSnapshot()
+  })
+
+  it('generates env field metadata from the shared schema fixture matrix', () => {
+    writeSchemaMatrixModels(root)
+    const filePath = generateTeamplayEnv({ root })
+    const content = readFileSync(filePath, 'utf8')
+
+    for (const fixture of schemaRuntimeFixtureMatrix) {
+      const generatedEnv = fixture.generatedEnv
+      if (!generatedEnv) continue
+      expect(content).toContain(JSON.stringify(generatedEnv.collectionName))
+      for (const fieldName of generatedEnv.expectedFieldNames) {
+        expect(content).toContain(`readonly ${JSON.stringify(fieldName)}:`)
+        expect(content).toContain(`readonly ${JSON.stringify(`$${fieldName}`)}:`)
+      }
+      for (const snippet of generatedEnv.expectedJsdocSnippets || []) {
+        expect(content).toContain(snippet)
+      }
+    }
+  })
+
+  it('generates schema default interfaces which work through resolved module identity', () => {
+    useFixture(root, 'complex-ts')
+    generateTeamplayEnv({ root })
+    linkNodeModules(root)
+    mkdirSync(join(root, 'app', 'nested'), { recursive: true })
+    writeFileSync(join(root, 'app-relative.ts'), `
+      import { Signal } from 'teamplay'
+      import Event from './models/events/schema'
+      import AliasEvent from '@/models/events/schema'
+      import _active from '@/models/events/_active.ts'
+
+      const schemaType: 'string' = Event.title.type
+      const aliasSchemaType: 'string' = AliasEvent.title.type
+      const event: Event = { title: 'Launch', createdAt: 1 }
+      const aliasEvent: AliasEvent = event
+      const activeRows: NonNullable<typeof _active.__teamplayAggregationOutput> = [event]
+      const $event = null as unknown as Signal<Event>
+      const title: string = $event.title.get()
+
+      class EventModel extends Signal<Event> {
+        getTitle () {
+          return this.title.get()
+        }
+      }
+
+      const model = null as unknown as EventModel
+      const modelTitle: string = model.getTitle()
+
+      // @ts-expect-error generated default interface should reject wrong field types
+      const badEvent: Event = { title: 123, createdAt: 1 }
+      // @ts-expect-error generated aggregation alias should keep the aggregation output type
+      const badActiveRows: NonNullable<typeof _active.__teamplayAggregationOutput> = [{ title: 123, createdAt: 1 }]
+
+      void schemaType
+      void aliasSchemaType
+      void aliasEvent
+      void activeRows
+      void title
+      void modelTitle
+      void badEvent
+      void badActiveRows
+    `)
+    writeFileSync(join(root, 'app', 'nested', 'nested-relative.ts'), `
+      import Event from '../../models/events/schema.ts'
+
+      const event: Event = { title: 'Nested', createdAt: 2 }
+      // @ts-expect-error resolved relative imports with extensions should use the same default interface
+      const badEvent: Event = { title: 'Nested', createdAt: 'today' }
+
+      void event
+      void badEvent
+    `)
+    writeFileSync(join(root, 'tsconfig.json'), JSON.stringify({
+      compilerOptions: {
+        strict: true,
+        target: 'ES2022',
+        module: 'ESNext',
+        moduleResolution: 'Bundler',
+        allowImportingTsExtensions: true,
+        baseUrl: '.',
+        paths: { '@/*': ['./*'] },
+        skipLibCheck: true,
+        ignoreDeprecations: '6.0'
+      },
+      include: ['**/*.ts', 'teamplay-env.d.ts']
+    }, null, 2))
+
+    expect(() => runTsc(root)).not.toThrow()
+  })
+
+  it('does not rewrite teamplay-env.d.ts when generated content is unchanged', () => {
+    useFixture(root, 'complex-ts')
+    const filePath = generateTeamplayEnv({ root })
+    const oldTime = new Date('2000-01-01T00:00:00.000Z')
+    utimesSync(filePath, oldTime, oldTime)
+
+    generateTeamplayEnv({ root })
+
+    expect(statSync(filePath).mtime.getTime()).toBe(oldTime.getTime())
+  })
+
+  it('generates env imports relative to a custom typesFile location', () => {
+    useFixture(root, 'complex-ts')
+    const filePath = generateTeamplayEnv({
+      root,
+      typesFile: 'types/generated/teamplay-env.d.ts'
+    })
+    const content = readFileSync(filePath, 'utf8')
+
+    expect(toSnapshotPath(root, filePath)).toBe('types/generated/teamplay-env.d.ts')
+    expect(content).toContain('from "../../models/events/schema.ts"')
+    expect(content).toContain('declare module "../../models/events/schema"')
+  })
+
+  it('loads file-based models directly in Node', async () => {
+    useFixture(root, 'simple-js')
+    linkNodeModules(root)
+
+    expect(summarizeLoadedModels(await loadFileBasedModels({ root }))).toMatchSnapshot()
+  })
+
+  it('loads file-based models synchronously in Node', () => {
+    useFixture(root, 'simple-js')
+    linkNodeModules(root)
+
+    expect(summarizeLoadedModels(loadFileBasedModelsSync({ root }))).toMatchSnapshot()
+  })
+
+  it('exports synchronous Node file-based models', () => {
+    useFixture(root, 'simple-js')
+    linkNodeModules(root)
+    const previousCwd = process.cwd()
+    process.chdir(root)
+    try {
+      const moduleId = require.resolve('babel-plugin-teamplay/file-based-models')
+      delete require.cache[moduleId]
+      expect(summarizeLoadedModels(require('babel-plugin-teamplay/file-based-models'))).toMatchSnapshot()
+    } finally {
+      process.chdir(previousCwd)
+    }
+  })
+
+  it('throws a friendly error when a model uses top-level await', () => {
+    useFixture(root, 'top-level-await-js')
+
+    expect(() => loadFileBasedModelsSync({ root })).toThrow(
+      /Cannot synchronously load file-based model.*top-level await/s
+    )
+  })
+
+  it('eliminates server-only model code for client builds', () => {
+    expect(transformModelCode(`
+      import { aggregation, accessControl, serverOnly } from 'teamplay'
+      type User = { active: boolean }
+
+      export const _active = aggregation<User[]>(({ active }: { active: boolean }) => [{ $match: { active } }])
+      export const access = accessControl({ create: () => true })
+      export const secret = serverOnly(() => 'secret')
+    `, {
+      root,
+      filename: join(root, 'models', 'users.ts')
+    })).toMatchSnapshot()
+  })
+
+  it('eliminates default aggregation files for client builds', () => {
+    expect(transformModelCode(`
+      import { aggregation } from 'startupjs'
+      type User = { active: boolean }
+
+      export default aggregation<User[]>(({ active }: { active: boolean }) => [{ $match: { active } }])
+    `, {
+      root,
+      filename: join(root, 'model', 'users', '_active.ts'),
+      fallbackModelsFolders: ['model']
+    })).toMatchSnapshot()
+  })
+
+  it('eliminates server-only model code from nested plugin model folders', () => {
+    expect(transformModelCode(`
+      import { accessControl, serverOnly } from 'startupjs'
+
+      export const access = accessControl({ create: () => true })
+      export const secret = serverOnly(() => 'secret')
+    `, {
+      root,
+      filename: join(root, 'node_modules', '@startupjs', 'plugin-example', 'model', 'users.js'),
+      fallbackModelsFolders: ['model']
+    })).toMatchSnapshot()
+  })
+
+  it('eliminates serverOnly code outside model folders based on source usage', () => {
+    expect(transformModelCode(`
+      import { serverOnly, Signal } from 'startupjs'
+      import { getFileBlob } from './providers/index.js'
+
+      export default class FileModel extends Signal {
+        getBlob = serverOnly(function () {
+          return getFileBlob(this.storageType.get(), this.getId())
+        })
+      }
+    `, {
+      root,
+      filename: join(root, 'node_modules', '@startupjs-ui', 'file-input', 'files.plugin.js')
+    })).toMatchSnapshot()
+  })
+
+  it('snapshots client-transformed complex TypeScript model fixtures', () => {
+    useFixture(root, 'complex-ts')
+
+    const output = transformFixtureModelFiles(root)
+
+    expect(output['models/events/_active.ts']).toContain('__aggregationHeader<Event[], EventSession>')
+    expect(output['models/events/_active.ts']).not.toContain('$match')
+    expect(output['models/events/access.ts']).not.toContain('accessControl')
+    expect(output['models/events/access.ts']).not.toContain('session')
+    expect(output).toMatchSnapshot()
+  })
+
+  it('snapshots client-transformed simple JavaScript model fixtures', () => {
+    useFixture(root, 'simple-js')
+
+    const output = transformFixtureModelFiles(root)
+
+    expect(output['models/users/_active.js']).toContain('__aggregationHeader')
+    expect(output['models/users/_active.js']).not.toContain('$match')
+    expect(output['models/users/access.js']).not.toContain('accessControl')
+    expect(output['models/users/access.js']).not.toContain('session')
+    expect(output).toMatchSnapshot()
+  })
+
+  it('keeps model server code when clientOnly is false', () => {
+    expect(transformModelCode(`
+      import { accessControl } from 'teamplay'
+
+      export const access = accessControl({ create: () => true })
+    `, {
+      root,
+      filename: join(root, 'models', 'users.js'),
+      clientOnly: false
+    })).toMatchSnapshot()
+  })
+
+  it('transforms direct file-based models imports', () => {
+    useFixture(root, 'complex-ts')
+
+    const result = babel.transformSync(`
+      import models from 'teamplay/file-based-models'
+      export default models
+    `, {
+      filename: join(root, 'src', 'entry.js'),
+      babelrc: false,
+      configFile: false,
+      plugins: [[plugin, {
+        root,
+        autoInit: false,
+        types: false
+      }]]
+    })
+
+    expect(result.code).toMatchSnapshot()
+  })
+
+  it('transforms direct file-based models imports with fallback folders', () => {
+    useFixture(root, 'legacy-js')
+
+    const result = babel.transformSync(`
+      import models from 'teamplay/file-based-models'
+      export default models
+    `, {
+      filename: join(root, 'src', 'entry.js'),
+      babelrc: false,
+      configFile: false,
+      plugins: [[plugin, {
+        root,
+        fallbackModelsFolders: ['model'],
+        autoInit: false,
+        types: false,
+        warn: () => {}
+      }]]
+    })
+
+    expect(result.code).toMatchSnapshot()
+  })
+})
+
+function transformVirtualImports (options) {
+  const result = babel.transformSync(`
+    import models from './teamplay.models.virtual.js'
+    import autoInit from './teamplay.models.auto-init.virtual.js'
+    export { models, autoInit }
+  `, {
+    filename: join(options.root, 'src', 'entry.js'),
+    babelrc: false,
+    configFile: false,
+    plugins: [[plugin, options]]
+  })
+  return result.code
+}
+
+function transformModelCode (code, options) {
+  const result = babel.transformSync(code, {
+    filename: options.filename,
+    babelrc: false,
+    configFile: false,
+    parserOpts: {
+      plugins: ['typescript']
+    },
+    plugins: [[plugin, options]]
+  })
+  return result.code
+}
+
+function transformFixtureModelFiles (root) {
+  const files = getSourceFiles(join(root, 'models'))
+  return Object.fromEntries(
+    files.map(filePath => [
+      toSnapshotPath(root, filePath),
+      `\n${transformModelCode(readFileSync(filePath, 'utf8'), {
+        root,
+        filename: filePath,
+        types: false
+      })}\n`
+    ])
+  )
+}
+
+function getSourceFiles (folder) {
+  const files = []
+  for (const filename of readdirSync(folder).sort()) {
+    const filePath = join(folder, filename)
+    const stat = lstatSync(filePath)
+    if (stat.isDirectory()) {
+      files.push(...getSourceFiles(filePath))
+    } else if (SOURCE_FILE_REGEX.test(filename)) {
+      files.push(filePath)
+    }
+  }
+  return files
+}
+
+function toSnapshotPath (root, filePath) {
+  return relative(root, filePath).replace(/\\/g, '/')
+}
+
+function summarizeLoadedModels (models) {
+  return Object.fromEntries(
+    Object.entries(models)
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([pattern, parts]) => [
+        pattern,
+        Object.fromEntries(
+          Object.entries(parts)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([name, value]) => [name, summarizeLoadedValue(value)])
+        )
+      ])
+  )
+}
+
+function getGeneratedRequireContextHelpers () {
+  return runInNewContext(`${getRequireContextModelPatternHelperSource()}
+    ({
+      getPattern: __teamplayGetModelPattern,
+      sanitizeAndMerge: __teamplaySanitizeAndMergeModelPatterns
+    })
+  `, { console })
+}
+
+function summarizeModelPatternParts (models) {
+  return Object.fromEntries(
+    Object.entries(models)
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([pattern, parts]) => [
+        pattern,
+        parts.map(part => ({
+          type: part.type,
+          name: part.name,
+          value: part.value
+        }))
+      ])
+  )
+}
+
+function summarizeLoadedValue (value) {
+  if (typeof value === 'function') {
+    return { type: 'function', name: value.name }
+  }
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, child]) => [key, summarizeLoadedValue(child)])
+    )
+  }
+  return value
+}
+
+function useFixture (root, name) {
+  cpSync(join(FIXTURES_DIR, name), root, { recursive: true })
+  mkdirSync(join(root, 'src'), { recursive: true })
+}
+
+function writeSchemaMatrixModels (root) {
+  for (const fixture of schemaRuntimeFixtureMatrix) {
+    const generatedEnv = fixture.generatedEnv
+    if (!generatedEnv) continue
+    const folder = join(root, 'models', generatedEnv.collectionName)
+    mkdirSync(folder, { recursive: true })
+    writeFileSync(join(folder, 'index.ts'), [
+      "import { Signal } from 'teamplay'",
+      '',
+      `export default class ${toClassName(generatedEnv.collectionName)} extends Signal {}`,
+      ''
+    ].join('\n'))
+    writeFileSync(join(folder, 'schema.ts'), generatedEnv.source || buildStaticSchemaSource(fixture.schema))
+  }
+}
+
+function buildStaticSchemaSource (schema) {
+  return [
+    "import { defineSchema } from 'teamplay'",
+    '',
+    `export default defineSchema(${JSON.stringify(schema, null, 2)} as const)`,
+    ''
+  ].join('\n')
+}
+
+function toClassName (value) {
+  const name = value
+    .replace(/^[^a-zA-Z_$]+/, '')
+    .replace(/[^a-zA-Z0-9_$]+(.)?/g, (_, char = '') => char.toUpperCase())
+  return name ? name[0].toUpperCase() + name.slice(1) : 'Model'
+}
+
+function linkNodeModules (root) {
+  symlinkSync(join(REPO_ROOT, 'node_modules'), join(root, 'node_modules'), 'dir')
+}
+
+function runTsc (root) {
+  execFileSync(process.execPath, [TSC_BIN, '--noEmit', '--project', join(root, 'tsconfig.json')], {
+    cwd: root,
+    encoding: 'utf8',
+    stdio: 'pipe'
+  })
+}
diff --git a/packages/schema/index.js b/packages/schema/index.js
deleted file mode 100644
index 0c38212..0000000
--- a/packages/schema/index.js
+++ /dev/null
@@ -1,6 +0,0 @@
-export { default as ajv } from './lib/ajv.js'
-export { default as transformSchema } from './lib/transformSchema.js'
-export { onTransformSchema, setOnTransformSchema } from './lib/onTransformSchema.js'
-export * from './lib/associations.js'
-export { default as GUID_PATTERN } from './lib/GUID_PATTERN.js'
-export { default as pickFormFields } from './lib/pickFormFields.js'
diff --git a/packages/schema/index.ts b/packages/schema/index.ts
new file mode 100644
index 0000000..4c1f970
--- /dev/null
+++ b/packages/schema/index.ts
@@ -0,0 +1,14 @@
+export { default as ajv } from './lib/ajv.ts'
+export { default as transformSchema } from './lib/transformSchema.ts'
+export { onTransformSchema, setOnTransformSchema } from './lib/onTransformSchema.ts'
+export * from './lib/associations.ts'
+export { default as GUID_PATTERN } from './lib/GUID_PATTERN.ts'
+export { default as pickFormFields } from './lib/pickFormFields.ts'
+export { defineSchema, isDefinedSchema } from './lib/defineSchema.ts'
+export {
+  JSON_SCHEMA_KEYWORDS,
+  getSchemaPropertiesObject,
+  getSimplifiedSchemaRequiredFields,
+  isFullObjectSchema,
+  isJsonSchemaKeyword
+} from './lib/schemaIntrospection.ts'
diff --git a/packages/schema/lib/GUID_PATTERN.js b/packages/schema/lib/GUID_PATTERN.ts
similarity index 100%
rename from packages/schema/lib/GUID_PATTERN.js
rename to packages/schema/lib/GUID_PATTERN.ts
diff --git a/packages/schema/lib/ajv.js b/packages/schema/lib/ajv.ts
similarity index 100%
rename from packages/schema/lib/ajv.js
rename to packages/schema/lib/ajv.ts
diff --git a/packages/schema/lib/associations.js b/packages/schema/lib/associations.js
deleted file mode 100644
index 704699a..0000000
--- a/packages/schema/lib/associations.js
+++ /dev/null
@@ -1,51 +0,0 @@
-import GUID_PATTERN from './GUID_PATTERN.js'
-
-export function belongsTo (collectionName) {
-  return {
-    type: 'string',
-    pattern: GUID_PATTERN,
-    $association: {
-      type: 'belongsTo',
-      collection: collectionName
-    }
-  }
-}
-
-export function hasMany (collectionName) {
-  return {
-    type: 'array',
-    items: {
-      type: 'string',
-      pattern: GUID_PATTERN
-    },
-    $association: {
-      type: 'hasMany',
-      collection: collectionName
-    }
-  }
-}
-
-export function hasManyFlags (collectionName) {
-  return {
-    type: 'object',
-    patternProperties: {
-      [GUID_PATTERN]: { type: 'boolean' }
-    },
-    additionalProperties: false,
-    $association: {
-      type: 'hasManyFlags',
-      collection: collectionName
-    }
-  }
-}
-
-export function hasOne (collectionName) {
-  return {
-    type: 'string',
-    pattern: GUID_PATTERN,
-    $association: {
-      type: 'hasOne',
-      collection: collectionName
-    }
-  }
-}
diff --git a/packages/schema/lib/associations.ts b/packages/schema/lib/associations.ts
new file mode 100644
index 0000000..7c5cb46
--- /dev/null
+++ b/packages/schema/lib/associations.ts
@@ -0,0 +1,78 @@
+import GUID_PATTERN from './GUID_PATTERN.ts'
+
+export interface AssociationSchema {
+  readonly type: string
+  readonly $association: {
+    readonly type: string
+    readonly collection: string
+  }
+}
+
+export interface StringAssociationSchema extends AssociationSchema {
+  readonly type: 'string'
+  readonly pattern: string
+}
+
+export interface HasManyAssociationSchema extends AssociationSchema {
+  readonly type: 'array'
+  readonly items: {
+    readonly type: 'string'
+    readonly pattern: string
+  }
+}
+
+export interface HasManyFlagsAssociationSchema extends AssociationSchema {
+  readonly type: 'object'
+  readonly patternProperties: Record<string, { readonly type: 'boolean' }>
+  readonly additionalProperties: false
+}
+
+export function belongsTo (collectionName: string): StringAssociationSchema {
+  return {
+    type: 'string',
+    pattern: GUID_PATTERN,
+    $association: {
+      type: 'belongsTo',
+      collection: collectionName
+    }
+  }
+}
+
+export function hasMany (collectionName: string): HasManyAssociationSchema {
+  return {
+    type: 'array',
+    items: {
+      type: 'string',
+      pattern: GUID_PATTERN
+    },
+    $association: {
+      type: 'hasMany',
+      collection: collectionName
+    }
+  }
+}
+
+export function hasManyFlags (collectionName: string): HasManyFlagsAssociationSchema {
+  return {
+    type: 'object',
+    patternProperties: {
+      [GUID_PATTERN]: { type: 'boolean' }
+    },
+    additionalProperties: false,
+    $association: {
+      type: 'hasManyFlags',
+      collection: collectionName
+    }
+  }
+}
+
+export function hasOne (collectionName: string): StringAssociationSchema {
+  return {
+    type: 'string',
+    pattern: GUID_PATTERN,
+    $association: {
+      type: 'hasOne',
+      collection: collectionName
+    }
+  }
+}
diff --git a/packages/schema/lib/defineSchema.ts b/packages/schema/lib/defineSchema.ts
new file mode 100644
index 0000000..316b918
--- /dev/null
+++ b/packages/schema/lib/defineSchema.ts
@@ -0,0 +1,20 @@
+const definedObjectSchemas = new WeakSet<object>()
+const definedPrimitiveSchemas = new Set<unknown>()
+
+function isObjectLike (value: unknown): value is object {
+  return (typeof value === 'object' && value !== null) || typeof value === 'function'
+}
+
+export function defineSchema<const TSchema> (schema: TSchema): TSchema {
+  if (isObjectLike(schema)) {
+    definedObjectSchemas.add(schema)
+  } else {
+    definedPrimitiveSchemas.add(schema)
+  }
+  return schema
+}
+
+export function isDefinedSchema (schema: unknown): boolean {
+  if (isObjectLike(schema)) return definedObjectSchemas.has(schema)
+  return definedPrimitiveSchemas.has(schema)
+}
diff --git a/packages/schema/lib/jsonSchemaKeywords.cjs b/packages/schema/lib/jsonSchemaKeywords.cjs
new file mode 100644
index 0000000..2fc914e
--- /dev/null
+++ b/packages/schema/lib/jsonSchemaKeywords.cjs
@@ -0,0 +1,36 @@
+module.exports = [
+  '$id',
+  '$schema',
+  '$comment',
+  'type',
+  'properties',
+  'items',
+  'required',
+  'enum',
+  'const',
+  'additionalProperties',
+  'patternProperties',
+  'description',
+  'title',
+  'default',
+  'errorMessage',
+  'validators',
+  'collection',
+  'format',
+  'minimum',
+  'maximum',
+  'minLength',
+  'maxLength',
+  'minItems',
+  'maxItems',
+  'uniqueItems',
+  'input',
+  'label',
+  'options',
+  'placeholder',
+  'disabled',
+  'mimeTypes',
+  'pattern',
+  'min',
+  'max'
+]
diff --git a/packages/schema/lib/jsonSchemaKeywords.ts b/packages/schema/lib/jsonSchemaKeywords.ts
new file mode 100644
index 0000000..90075ab
--- /dev/null
+++ b/packages/schema/lib/jsonSchemaKeywords.ts
@@ -0,0 +1,38 @@
+const JSON_SCHEMA_KEYWORDS = [
+  '$id',
+  '$schema',
+  '$comment',
+  'type',
+  'properties',
+  'items',
+  'required',
+  'enum',
+  'const',
+  'additionalProperties',
+  'patternProperties',
+  'description',
+  'title',
+  'default',
+  'errorMessage',
+  'validators',
+  'collection',
+  'format',
+  'minimum',
+  'maximum',
+  'minLength',
+  'maxLength',
+  'minItems',
+  'maxItems',
+  'uniqueItems',
+  'input',
+  'label',
+  'options',
+  'placeholder',
+  'disabled',
+  'mimeTypes',
+  'pattern',
+  'min',
+  'max'
+] as const
+
+export default JSON_SCHEMA_KEYWORDS
diff --git a/packages/schema/lib/onTransformSchema.js b/packages/schema/lib/onTransformSchema.js
deleted file mode 100644
index 294b698..0000000
--- a/packages/schema/lib/onTransformSchema.js
+++ /dev/null
@@ -1,5 +0,0 @@
-export let onTransformSchema
-
-export function setOnTransformSchema (fn) {
-  onTransformSchema = fn
-}
diff --git a/packages/schema/lib/onTransformSchema.ts b/packages/schema/lib/onTransformSchema.ts
new file mode 100644
index 0000000..92d2a81
--- /dev/null
+++ b/packages/schema/lib/onTransformSchema.ts
@@ -0,0 +1,7 @@
+export type SchemaTransformHook = (schema: unknown) => unknown
+
+export let onTransformSchema: SchemaTransformHook | undefined
+
+export function setOnTransformSchema (fn: SchemaTransformHook | undefined): void {
+  onTransformSchema = fn
+}
diff --git a/packages/schema/lib/pickFormFields.js b/packages/schema/lib/pickFormFields.ts
similarity index 63%
rename from packages/schema/lib/pickFormFields.js
rename to packages/schema/lib/pickFormFields.ts
index 3a2e190..5548960 100644
--- a/packages/schema/lib/pickFormFields.js
+++ b/packages/schema/lib/pickFormFields.ts
@@ -9,9 +9,23 @@
  * @param {Array} options.exclude - list of fields to exclude (default: none)
  * @param {Boolean} options.freeze - whether to deep freeze the result (default: true)
  */
-export default function pickFormFields (schema, options) {
+import {
+  getSchemaPropertiesObject,
+  isSchemaObject,
+  type JsonSchemaObject
+} from './schemaIntrospection.ts'
+
+type PickFormFieldsOptions = {
+  include?: string[]
+  exclude?: string[]
+  freeze?: boolean
+} | string[]
+
+export default function pickFormFields (schema: unknown, options?: PickFormFieldsOptions): JsonSchemaObject {
   try {
-    let include, exclude, freeze
+    let include: string[] | undefined
+    let exclude: string[] | undefined
+    let freeze: boolean | undefined
     if (Array.isArray(options)) {
       include = options
     } else {
@@ -19,23 +33,22 @@ export default function pickFormFields (schema, options) {
     }
     exclude ??= []
     if (!schema) throw Error('pickFormFields: schema is required')
-    schema = JSON.parse(JSON.stringify(schema))
-    if (schema.type === 'object') {
-      schema = schema.properties
-    }
-    for (const key in schema) {
-      if (shouldIncludeField(key, schema[key], { include, exclude })) {
-        const field = schema[key]
-        if (!field.label) field.label = camelCaseToLabel(key)
+    const clonedSchema = JSON.parse(JSON.stringify(schema))
+    const fields = getSchemaPropertiesObject(clonedSchema)
+    for (const key in fields) {
+      if (shouldIncludeField(key, fields[key], { include, exclude })) {
+        const field = fields[key]
+        if (isSchemaObject(field) && !field.label) field.label = camelCaseToLabel(key)
       } else {
-        delete schema[key]
+        delete fields[key]
       }
     }
-    if (freeze) return new Proxy(schema, deepFreezeHandler)
-    return schema
+    if (freeze) return new Proxy(fields as Record<PropertyKey, unknown>, deepFreezeHandler) as JsonSchemaObject
+    return fields
   } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
     throw Error(`
-      pickFormFields: ${err.message}
+      pickFormFields: ${message}
       schema:\n${JSON.stringify(schema, null, 2)}
     `)
   }
@@ -43,11 +56,11 @@ export default function pickFormFields (schema, options) {
 
 // Proxy handlers to deep freeze schema to prevent accidental mutations.
 // For this, when we .get() a property, we also return the same recursive Proxy handler if it's an object.
-const deepFreezeHandler = {
+const deepFreezeHandler: ProxyHandler<Record<PropertyKey, unknown>> = {
   get (target, prop) {
     const value = target[prop]
     if (typeof value === 'object' && value !== null) {
-      return new Proxy(value, deepFreezeHandler)
+      return new Proxy(value as Record<PropertyKey, unknown>, deepFreezeHandler)
     }
     return value
   },
@@ -56,18 +69,22 @@ const deepFreezeHandler = {
   }
 }
 
-function shouldIncludeField (key, field, { include, exclude = [] } = {}) {
+function shouldIncludeField (
+  key: string,
+  field: JsonSchemaObject | unknown,
+  { include, exclude = [] }: { include?: string[], exclude?: string[] } = {}
+): boolean {
   if (!field) throw Error(`field "${key}" does not have a schema definition`)
   if (include?.includes(key)) return true
   if (exclude.includes(key)) return false
   // if field has 'input' specified then it's an explicit indicator that it can be used in forms,
   // so the default exclusion rules don't apply
-  if (!field.input) {
+  if (!_hasTruthyProperty(field, 'input')) {
     // exclude some meta fields by default
     if (DEFAULT_EXCLUDE_FORM_FIELDS.includes(key)) return false
     // exclude foreign keys by default
     // Foreign keys have a custom `$association` property set by belongsTo/hasMany/hasOne helpers
-    if (field.$association) return false
+    if (_hasTruthyProperty(field, '$association')) return false
   }
   // if include array is not explicitly set, include all fields by default
   if (!include) return true
@@ -77,7 +94,11 @@ function shouldIncludeField (key, field, { include, exclude = [] } = {}) {
 const DEFAULT_EXCLUDE_FORM_FIELDS = ['id', '_id', 'createdAt', 'updatedAt']
 
 // split into words, capitalize first word, make others lowercase
-function camelCaseToLabel (str) {
+function _hasTruthyProperty (value: unknown, key: string): boolean {
+  return isSchemaObject(value) && Boolean(value[key])
+}
+
+function camelCaseToLabel (str: string): string {
   return str
     .replace(/([A-Z])/g, ' $1')
     .toLowerCase()
diff --git a/packages/schema/lib/schemaIntrospection.ts b/packages/schema/lib/schemaIntrospection.ts
new file mode 100644
index 0000000..75bb78d
--- /dev/null
+++ b/packages/schema/lib/schemaIntrospection.ts
@@ -0,0 +1,31 @@
+import JSON_SCHEMA_KEYWORDS from './jsonSchemaKeywords.ts'
+
+export { JSON_SCHEMA_KEYWORDS }
+
+export type JsonSchemaObject = Record<string, unknown>
+
+export function isSchemaObject (value: unknown): value is JsonSchemaObject {
+  return Object.prototype.toString.call(value) === '[object Object]'
+}
+
+export function isJsonSchemaKeyword (key: string): boolean {
+  return (JSON_SCHEMA_KEYWORDS as readonly string[]).includes(key)
+}
+
+export function isFullObjectSchema (schema: unknown): schema is JsonSchemaObject & { type: 'object' } {
+  return isSchemaObject(schema) && schema.type === 'object'
+}
+
+export function getSchemaPropertiesObject (schema: unknown): JsonSchemaObject {
+  if (!schema) return {}
+  if (isFullObjectSchema(schema)) {
+    return isSchemaObject(schema.properties) ? schema.properties : {}
+  }
+  return isSchemaObject(schema) ? schema : {}
+}
+
+export function getSimplifiedSchemaRequiredFields (properties: JsonSchemaObject): string[] {
+  return Object.keys(properties).filter(
+    key => isSchemaObject(properties[key]) && properties[key].required === true
+  )
+}
diff --git a/packages/schema/lib/transformSchema.js b/packages/schema/lib/transformSchema.js
deleted file mode 100644
index 72e2f1c..0000000
--- a/packages/schema/lib/transformSchema.js
+++ /dev/null
@@ -1,64 +0,0 @@
-import _isPlainObject from 'lodash/isPlainObject.js'
-import { onTransformSchema } from './onTransformSchema.js'
-
-// allow schema to be specified in a simplified format - as "properties" themselves
-// and also with 'required' being part of each property
-export default function transformSchema (schema, { additionalProperties = false } = {}) {
-  schema = JSON.parse(JSON.stringify(schema))
-  // if schema is not an object, assume it's in a simplified format
-  if (schema.type !== 'object') {
-    schema = {
-      type: 'object',
-      properties: schema,
-      required: Object.keys(schema).filter(
-        // gather all required fields
-        // (only if explicitly set to a boolean `true` to not interfere with object's 'required' array)
-        key => schema[key] && schema[key].required === true
-      ),
-      errorMessage: getErrorMessage(schema),
-      additionalProperties
-    }
-  }
-  stripExtraUiKeywords(schema)
-  if (onTransformSchema) schema = onTransformSchema(schema)
-  // schema = MODULE.reduceHook('transformSchema', schema)
-  return schema
-}
-
-// traverse type 'object' and type 'array' recursively
-// and remove extra keywords (like a boolean 'require') from all objects in schema
-// WARNING: this is self-mutating
-function stripExtraUiKeywords (schema) {
-  if (schema.type === 'object') {
-    for (const key in schema.properties) {
-      const property = schema.properties[key]
-      if (_isPlainObject(property)) {
-        if (typeof property.required === 'boolean') delete property.required
-        if (property.errorMessage?.required) delete property.errorMessage.required
-        stripExtraUiKeywords(property)
-      }
-    }
-  } else if (schema.type === 'array') {
-    stripExtraUiKeywords(schema.items)
-  }
-}
-
-function getErrorMessage (schema) {
-  if (schema.errorMessage && !_isPlainObject(schema.errorMessage)) {
-    return schema.errorMessage
-  }
-
-  const requiredErrorMessage = {}
-
-  for (const [key, property] of Object.entries(schema)) {
-    if (!_isPlainObject(property.errorMessage)) continue
-    if (!property.errorMessage.required) continue
-    requiredErrorMessage[key] = property.errorMessage.required
-  }
-
-  return Object.assign(
-    {},
-    schema.errorMessage,
-    { required: requiredErrorMessage }
-  )
-}
diff --git a/packages/schema/lib/transformSchema.ts b/packages/schema/lib/transformSchema.ts
new file mode 100644
index 0000000..4c59359
--- /dev/null
+++ b/packages/schema/lib/transformSchema.ts
@@ -0,0 +1,78 @@
+import { onTransformSchema } from './onTransformSchema.ts'
+import {
+  type JsonSchemaObject,
+  getSimplifiedSchemaRequiredFields,
+  getSchemaPropertiesObject,
+  isFullObjectSchema,
+  isSchemaObject
+} from './schemaIntrospection.ts'
+
+type TransformSchemaOptions = {
+  additionalProperties?: boolean
+}
+
+// allow schema to be specified in a simplified format - as "properties" themselves
+// and also with 'required' being part of each property
+export default function transformSchema (
+  schema: unknown,
+  { additionalProperties = false }: TransformSchemaOptions = {}
+): JsonSchemaObject {
+  schema = JSON.parse(JSON.stringify(schema))
+  // if schema is not an object, assume it's in a simplified format
+  if (!isFullObjectSchema(schema)) {
+    const properties = getSchemaPropertiesObject(schema)
+    schema = {
+      type: 'object',
+      properties,
+      required: getSimplifiedSchemaRequiredFields(properties),
+      errorMessage: getErrorMessage(properties),
+      additionalProperties
+    }
+  }
+  stripExtraUiKeywords(schema as JsonSchemaObject)
+  if (onTransformSchema) schema = onTransformSchema(schema)
+  // schema = MODULE.reduceHook('transformSchema', schema)
+  return schema as JsonSchemaObject
+}
+
+// traverse type 'object' and type 'array' recursively
+// and remove extra keywords (like a boolean 'require') from all objects in schema
+// WARNING: this is self-mutating
+function stripExtraUiKeywords (schema: JsonSchemaObject): void {
+  if (schema.type === 'object') {
+    const properties = isSchemaObject(schema.properties) ? schema.properties : {}
+    for (const key in properties) {
+      const property = properties[key]
+      if (isSchemaObject(property)) {
+        if (typeof property.required === 'boolean') delete property.required
+        if (isSchemaObject(property.errorMessage) && property.errorMessage.required) {
+          delete property.errorMessage.required
+        }
+        stripExtraUiKeywords(property)
+      }
+    }
+  } else if (schema.type === 'array') {
+    if (isSchemaObject(schema.items)) stripExtraUiKeywords(schema.items)
+  }
+}
+
+function getErrorMessage (schema: JsonSchemaObject): unknown {
+  if (schema.errorMessage && !isSchemaObject(schema.errorMessage)) {
+    return schema.errorMessage
+  }
+
+  const requiredErrorMessage: Record<string, unknown> = {}
+
+  for (const [key, property] of Object.entries(schema)) {
+    if (!isSchemaObject(property)) continue
+    if (!isSchemaObject(property.errorMessage)) continue
+    if (!property.errorMessage.required) continue
+    requiredErrorMessage[key] = property.errorMessage.required
+  }
+
+  return Object.assign(
+    {},
+    schema.errorMessage,
+    { required: requiredErrorMessage }
+  )
+}
diff --git a/packages/schema/package.json b/packages/schema/package.json
index ba59b8b..aea36d7 100644
--- a/packages/schema/package.json
+++ b/packages/schema/package.json
@@ -3,9 +3,14 @@
   "type": "module",
   "version": "0.4.0-alpha.9",
   "description": "Utils to work with json-schema",
-  "main": "index.js",
+  "main": "index.ts",
+  "types": "index.ts",
   "exports": {
-    ".": "./index.js"
+    ".": {
+      "types": "./index.ts",
+      "default": "./index.ts"
+    },
+    "./json-schema-keywords": "./lib/jsonSchemaKeywords.cjs"
   },
   "dependencies": {
     "ajv": "^8.12.0",
diff --git a/packages/sharedb-access/package.json b/packages/sharedb-access/package.json
index 4dcec26..80370b5 100644
--- a/packages/sharedb-access/package.json
+++ b/packages/sharedb-access/package.json
@@ -22,7 +22,7 @@
     "lodash": "^4.17.20"
   },
   "devDependencies": {
-    "mocha": "^8.1.3",
+    "mocha": "^11.7.5",
     "racer": "1.0.1",
     "sharedb": "^5.0.0"
   }
diff --git a/packages/sharedb-schema/package.json b/packages/sharedb-schema/package.json
index 9ce87a0..7c152c2 100644
--- a/packages/sharedb-schema/package.json
+++ b/packages/sharedb-schema/package.json
@@ -19,7 +19,7 @@
     "z-schema": "^4.2.3"
   },
   "devDependencies": {
-    "mocha": "^8.1.3",
+    "mocha": "^11.7.5",
     "racer": "1.0.1",
     "sharedb": "^5.0.0"
   }
diff --git a/packages/teamplay/babel-loader.cjs b/packages/teamplay/babel-loader.cjs
new file mode 100644
index 0000000..daebc82
--- /dev/null
+++ b/packages/teamplay/babel-loader.cjs
@@ -0,0 +1 @@
+module.exports = require('babel-plugin-teamplay/loader')
diff --git a/packages/teamplay/babel.cjs b/packages/teamplay/babel.cjs
new file mode 100644
index 0000000..b651dba
--- /dev/null
+++ b/packages/teamplay/babel.cjs
@@ -0,0 +1 @@
+module.exports = require('babel-plugin-teamplay')
diff --git a/packages/teamplay/connect/index.js b/packages/teamplay/connect/index.js
index 15f3752..1096327 100644
--- a/packages/teamplay/connect/index.js
+++ b/packages/teamplay/connect/index.js
@@ -1,6 +1,6 @@
 import Socket from '@teamplay/channel'
 import Connection from './sharedbConnection.cjs'
-import { connection, setConnection } from '../orm/connection.js'
+import { connection, setConnection } from '../orm/connection.ts'
 
 export default function connect (options) {
   if (connection) return
diff --git a/packages/teamplay/connect/offline/index.js b/packages/teamplay/connect/offline/index.js
index 22c4b35..821f455 100644
--- a/packages/teamplay/connect/offline/index.js
+++ b/packages/teamplay/connect/offline/index.js
@@ -2,7 +2,7 @@
 // This creates a full sharedb server with mingo database in the browser or react-native app.
 import ShareDbMingo from '@startupjs/sharedb-mingo-memory'
 import ShareBackend from 'sharedb'
-import { connection, setConnection } from '../../orm/connection.js'
+import { connection, setConnection } from '../../orm/connection.ts'
 
 const STORAGE_NAMESPACE = 'teamplay-offline'
 const DOCS_PREFIX = `${STORAGE_NAMESPACE}:docs:`
diff --git a/packages/teamplay/connect/test.js b/packages/teamplay/connect/test.js
index ae46471..5b3e27e 100644
--- a/packages/teamplay/connect/test.js
+++ b/packages/teamplay/connect/test.js
@@ -3,7 +3,7 @@
 // and creates a server connection to it.
 import ShareDbMingo from '@startupjs/sharedb-mingo-memory'
 import ShareBackend from 'sharedb'
-import { connection, setConnection } from '../orm/connection.js'
+import { connection, setConnection } from '../orm/connection.ts'
 
 export default function connect () {
   if (connection) return
diff --git a/packages/teamplay/file-based-models.js b/packages/teamplay/file-based-models.js
new file mode 100644
index 0000000..03599a6
--- /dev/null
+++ b/packages/teamplay/file-based-models.js
@@ -0,0 +1,3 @@
+import models from 'babel-plugin-teamplay/file-based-models'
+
+export default models
diff --git a/packages/teamplay/file-based-models.node.js b/packages/teamplay/file-based-models.node.js
new file mode 100644
index 0000000..9ad33cd
--- /dev/null
+++ b/packages/teamplay/file-based-models.node.js
@@ -0,0 +1,6 @@
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url)
+const models = require('babel-plugin-teamplay/file-based-models')
+
+export default models
diff --git a/packages/teamplay/index.d.ts b/packages/teamplay/index.d.ts
deleted file mode 100644
index 84069cb..0000000
--- a/packages/teamplay/index.d.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-// teamplay/index.d.ts
-import type * as React from 'react'
-
-export interface ObserverOptions {
-  /** Wrap the resulting component with forwardRef */
-  forwardRef?: boolean
-  /** Enable/disable the internal cache (default: true) */
-  cache?: boolean
-  /** Milliseconds or boolean to throttle reactive updates */
-  throttle?: number | boolean
-  /** Pass-through flag consumed by wrapIntoSuspense */
-  defer?: boolean | number
-  /** Props forwarded to React.Suspense (fallback required internally) */
-  suspenseProps?: React.ComponentProps<typeof React.Suspense>
-}
-
-/**
- * Makes any React component reactive and Suspense-aware.
- * Props are passed through unchanged; the returned component
- * preserves the original type so consumers keep full typings.
- */
-export function observer<
-  P extends Record<string, unknown> = Record<string, unknown>
-> (
-  component: React.ComponentType<P>,
-  options?: ObserverOptions
-): React.ComponentType<P>
-
-// Keep existing public surface available even if typed loosely for now.
-export const $: any
-export const $root: any
-export const model: any
-export { default as Signal, SEGMENTS } from './orm/Signal.js'
-export { __DEBUG_SIGNALS_CACHE__, rawSignal, getSignalClass } from './orm/getSignal.js'
-export { default as addModel } from './orm/addModel.js'
-export { default as signal } from './orm/getSignal.js'
-export { GLOBAL_ROOT_ID } from './orm/Root.js'
-export { default as sub } from './orm/sub.js'
-export {
-  default as useSub,
-  useAsyncSub,
-  setUseDeferredValue as __setUseDeferredValue,
-  setDefaultDefer as __setDefaultDefer
-} from './react/useSub.js'
-export function useSuspendMemo<T = any> (factory: () => T, deps?: any[]): T
-export function useSuspendMemoByKey<T = any> (key: any, factory: () => T, deps?: any[]): T
-export function useValue (defaultValue?: any): [any, any]
-export function useValue$ (defaultValue?: any): any
-export function useModel (path?: any): any
-export function useLocal (path?: any): [any, any]
-export function useLocal$ (path?: any): any
-export function useSession (path?: any): [any, any]
-export function useSession$ (path?: any): any
-export function usePage (path?: any): [any, any]
-export function usePage$ (path?: any): any
-export function useBatch (): void
-export function useDoc (collection: string, id: any, options?: any): [any, any]
-export function useDoc$ (collection: string, id: any, options?: any): any
-export function useBatchDoc (collection: string, id: any, options?: any): [any, any]
-export function useBatchDoc$ (collection: string, id: any, options?: any): any
-export function useAsyncDoc (collection: string, id: any, options?: any): [any, any]
-export function useAsyncDoc$ (collection: string, id: any, options?: any): any
-export function useQuery (collection: string, query: any, options?: any): [any, any]
-export function useQuery$ (collection: string, query: any, options?: any): any
-export function useAsyncQuery (collection: string, query: any, options?: any): [any, any]
-export function useAsyncQuery$ (collection: string, query: any, options?: any): any
-export function useBatchQuery (collection: string, query: any, options?: any): [any, any]
-export function useBatchQuery$ (collection: string, query: any, options?: any): any
-export function useQueryIds (collection: string, ids?: any[], options?: any): [any, any]
-export function useBatchQueryIds (collection: string, ids?: any[], options?: any): [any, any]
-export function useAsyncQueryIds (collection: string, ids?: any[], options?: any): [any, any]
-export function useQueryDoc (collection: string, query: any, options?: any): [any, any]
-export function useQueryDoc$ (collection: string, query: any, options?: any): any
-export function useBatchQueryDoc (collection: string, query: any, options?: any): [any, any]
-export function useBatchQueryDoc$ (collection: string, query: any, options?: any): any
-export function useAsyncQueryDoc (collection: string, query: any, options?: any): [any, any]
-export function useAsyncQueryDoc$ (collection: string, query: any, options?: any): any
-export function useLocalDoc (collection: string, id: any): [any, any]
-export function useLocalDoc$ (collection: string, id: any): any
-export function emit (eventName: string, ...args: any[]): void
-export function useOn (
-  eventName: 'change' | 'all',
-  pattern: string | { path: () => string },
-  handler: (...args: any[]) => void,
-  deps?: any[]
-): void
-export function useOn (eventName: string, handler: (...args: any[]) => void, deps?: any[]): void
-export function useEmit (): (eventName: string, ...args: any[]) => void
-export function batch<T = any> (fn?: () => T): T | undefined
-export function batchModel<T = any> (fn?: () => T): T | undefined
-export function clone<T = any> (value: T): T
-export function initLocalCollection (name: string): any
-export function useApi (api: (...args: any[]) => any, args?: any[], options?: { debounce?: number }): [any, boolean, any]
-type EffectCleanup = (() => void) | undefined
-export function useDidUpdate (fn: () => EffectCleanup, deps?: any[]): void
-export function useOnce (condition: any, fn: () => EffectCleanup): void
-export function useSyncEffect (fn: () => EffectCleanup, deps?: any[]): void
-export { connection, setConnection, getConnection, fetchOnly, setFetchOnly, publicOnly, setPublicOnly } from './orm/connection.js'
-export function getSubscriptionGcDelay (): number
-export function setSubscriptionGcDelay (ms?: number | null): number
-export { useId, useNow, useScheduleUpdate, useTriggerUpdate } from './react/helpers.js'
-export { GUID_PATTERN, hasMany, hasOne, hasManyFlags, belongsTo, pickFormFields } from '@teamplay/schema'
-export { aggregation, aggregationHeader as __aggregationHeader } from '@teamplay/utils/aggregation'
-export { accessControl } from '@teamplay/utils/accessControl'
-export function getRootSignal (options?: Record<string, any>): any
-export default $
diff --git a/packages/teamplay/index.js b/packages/teamplay/index.js
deleted file mode 100644
index 40bddf0..0000000
--- a/packages/teamplay/index.js
+++ /dev/null
@@ -1,125 +0,0 @@
-// NOTE:
-//   $() and sub() are currently set to be universal ones which work in both
-//   plain JS and React environments. In React they are tied to the observer() HOC.
-//   This is done to simplify the API.
-//   In future, we might want to separate the plain JS and React APIs
-import { getRootSignal as _getRootSignal, GLOBAL_ROOT_ID } from './orm/Root.js'
-import universal$ from './react/universal$.js'
-import useApi from './react/useApi.js'
-
-export { default as Signal, SEGMENTS } from './orm/Signal.js'
-export { __DEBUG_SIGNALS_CACHE__, rawSignal, getSignalClass } from './orm/getSignal.js'
-export { default as addModel } from './orm/addModel.js'
-export { default as signal } from './orm/getSignal.js'
-export { GLOBAL_ROOT_ID } from './orm/Root.js'
-export const $ = _getRootSignal({ rootId: GLOBAL_ROOT_ID, rootFunction: universal$ })
-export const $root = $
-export const model = $
-export default $
-export { default as sub } from './orm/sub.js'
-export {
-  default as useSub,
-  useAsyncSub,
-  setUseDeferredValue as __setUseDeferredValue,
-  setDefaultDefer as __setDefaultDefer
-} from './react/useSub.js'
-export {
-  default as useSuspendMemo,
-  useSuspendMemoByKey
-} from './react/useSuspendMemo.js'
-export { default as observer } from './react/observer.js'
-export {
-  useValue,
-  useValue$,
-  useModel,
-  useLocal,
-  useLocal$,
-  useLocalDoc,
-  useLocalDoc$,
-  useSession,
-  useSession$,
-  usePage,
-  usePage$,
-  useBatch,
-  useDoc,
-  useDoc$,
-  useBatchDoc,
-  useBatchDoc$,
-  useAsyncDoc,
-  useAsyncDoc$,
-  useQuery,
-  useQuery$,
-  useAsyncQuery,
-  useAsyncQuery$,
-  useBatchQuery,
-  useBatchQuery$,
-  useQueryIds,
-  useBatchQueryIds,
-  useAsyncQueryIds,
-  useQueryDoc,
-  useQueryDoc$,
-  useBatchQueryDoc,
-  useBatchQueryDoc$,
-  useAsyncQueryDoc,
-  useAsyncQueryDoc$
-} from './orm/Compat/hooksCompat.js'
-export { emit, useOn, useEmit } from './orm/Compat/eventsCompat.js'
-export {
-  useDidUpdate,
-  useOnce,
-  useSyncEffect
-} from './react/helpers.js'
-export {
-  connection,
-  setConnection,
-  getConnection,
-  getDefaultFetchOnly,
-  setDefaultFetchOnly,
-  publicOnly,
-  setPublicOnly
-} from './orm/connection.js'
-export { getSubscriptionGcDelay, setSubscriptionGcDelay } from './orm/subscriptionGcDelay.js'
-export { useId, useNow, useScheduleUpdate, useTriggerUpdate } from './react/helpers.js'
-export { GUID_PATTERN, hasMany, hasOne, hasManyFlags, belongsTo, pickFormFields } from '@teamplay/schema'
-export { aggregation, aggregationHeader as __aggregationHeader } from '@teamplay/utils/aggregation'
-export { accessControl } from '@teamplay/utils/accessControl'
-
-export function batch (fn) {
-  return $.batch(fn)
-}
-
-export function batchModel (fn) {
-  return $.batch(fn)
-}
-
-export function clone (value) {
-  if (typeof globalThis.structuredClone === 'function') {
-    try {
-      return globalThis.structuredClone(value)
-    } catch {}
-  }
-  if (value == null) return value
-  return JSON.parse(JSON.stringify(value))
-}
-
-export function initLocalCollection (name) {
-  if (typeof name !== 'string') throw Error('initLocalCollection() expects a collection name')
-  if (!name) return
-  const segments = name.split('.').filter(Boolean)
-  if (!segments.length) return
-  let $cursor = $
-  for (const segment of segments) {
-    $cursor = $cursor[segment]
-  }
-  if ($cursor.get() == null) $cursor.set({})
-  return $cursor
-}
-
-export { useApi }
-
-export function getRootSignal (options) {
-  return _getRootSignal({
-    rootFunction: universal$,
-    ...options
-  })
-}
diff --git a/packages/teamplay/index.ts b/packages/teamplay/index.ts
new file mode 100644
index 0000000..2aac96d
--- /dev/null
+++ b/packages/teamplay/index.ts
@@ -0,0 +1,315 @@
+// NOTE:
+//   $() and sub() are currently set to be universal ones which work in both
+//   plain JS and React environments. In React they are tied to the observer() HOC.
+//   This is done to simplify the API.
+//   In future, we might want to separate the plain JS and React APIs
+import type * as React from 'react'
+import RuntimeSignal, { SEGMENTS } from './orm/Signal.ts'
+import { getRootSignal as _getRootSignal, GLOBAL_ROOT_ID } from './orm/Root.ts'
+import universal$ from './react/universal$.ts'
+import useApi from './react/useApi.ts'
+import runtimeObserver from './react/observer.ts'
+import type {
+  AnySignal,
+  ArraySignal,
+  CollectionDocument,
+  CollectionDocumentModel,
+  CollectionSignal,
+  CollectionSignalFromSpec,
+  CollectionAggregationSignal,
+  CollectionQuerySignal,
+  CollectionSpec,
+  CollectionsFromManifest,
+  DocumentSignal,
+  FromJsonSchema,
+  JsonSchema,
+  JsonSchemaSpec,
+  MaybePromise,
+  MaybePromiseSubResult,
+  ModelEntry,
+  ModelManifest,
+  PathModelsFromManifest,
+  PublicSignal,
+  LocalSignalFactory,
+  RuntimeSignalConstructor,
+  RuntimeSignalInstance,
+  RootCollections,
+  RootSignal,
+  WildcardPathSegment,
+  WildcardSignalPath,
+  AppendPath,
+  JoinPath,
+  QueryParams,
+  QuerySignal,
+  RegisteredAggregationInput,
+  SignalChild,
+  SignalBaseInstance,
+  SignalArrayMutatorMethods,
+  SignalArrayReaderMethods,
+  SignalClass,
+  SignalCollectionMethods,
+  SignalConstructor,
+  SignalForKind,
+  SignalKind,
+  SignalMetadataMethods,
+  SignalModelConstructor,
+  SignalStringMutatorMethods,
+  SignalValueMethods,
+  SubResult,
+  TypedAggregationInput,
+  TypedAggregationSignal,
+  TypedSignal,
+  ZodLikeSchema,
+  ZodSchemaSpec
+} from './orm/Signal.ts'
+
+export interface TeamplayCollections {}
+export interface TeamplayModels {}
+export interface TeamplaySignalFields {}
+
+export type Signal<TValue = unknown> = PublicSignal<TValue>
+
+export type {
+  AnySignal,
+  ArraySignal,
+  CollectionDocument,
+  CollectionDocumentModel,
+  CollectionSignal,
+  CollectionSpec,
+  CollectionSignalFromSpec,
+  CollectionAggregationSignal,
+  CollectionQuerySignal,
+  DocumentSignal,
+  FromJsonSchema,
+  JsonSchema,
+  JsonSchemaSpec,
+  MaybePromise,
+  MaybePromiseSubResult,
+  ModelEntry,
+  ModelManifest,
+  CollectionsFromManifest,
+  LocalSignalFactory,
+  PathModelsFromManifest,
+  PublicSignal,
+  RuntimeSignalConstructor,
+  RuntimeSignalInstance,
+  RootCollections,
+  RootSignal,
+  WildcardPathSegment,
+  WildcardSignalPath,
+  AppendPath,
+  JoinPath,
+  QueryParams,
+  QuerySignal,
+  RegisteredAggregationInput,
+  SignalArrayMutatorMethods,
+  SignalArrayReaderMethods,
+  SignalBaseInstance,
+  SignalClass,
+  SignalChild,
+  SignalConstructor,
+  SignalCollectionMethods,
+  SignalForKind,
+  SignalKind,
+  SignalMetadataMethods,
+  SignalModelConstructor,
+  SignalStringMutatorMethods,
+  SignalValueMethods,
+  SubResult,
+  TypedAggregationInput,
+  TypedAggregationSignal,
+  TypedSignal,
+  ZodLikeSchema,
+  ZodSchemaSpec
+}
+
+export interface ObserverOptions {
+  forwardRef?: boolean
+  cache?: boolean
+  throttle?: number | boolean
+  defer?: boolean | number
+  suspenseProps?: React.ComponentProps<typeof React.Suspense>
+}
+
+export type ObserverComponent<TProps extends object> =
+  (props: TProps) => React.ReactNode
+
+export type ObserverForwardRefComponent<TProps extends object, TRef> =
+  (props: TProps, ref: React.ForwardedRef<TRef>) => React.ReactNode
+
+export type ObserverForwardRefOptions =
+  Omit<ObserverOptions, 'forwardRef'> & { forwardRef: true }
+
+export interface ObserverFunction {
+  <TProps extends object, TRef = unknown>(
+    Component: ObserverForwardRefComponent<TProps, TRef>,
+    options: ObserverForwardRefOptions
+  ): React.NamedExoticComponent<React.PropsWithoutRef<TProps> & React.RefAttributes<TRef>>
+
+  <TProps extends object>(
+    Component: ObserverComponent<TProps>,
+    options?: ObserverOptions
+  ): React.NamedExoticComponent<TProps>
+
+  __wrapObserverMeta: unknown
+  __makeObserver: unknown
+}
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const Signal = RuntimeSignal
+export { SEGMENTS }
+export { __DEBUG_SIGNALS_CACHE__, rawSignal, getSignalClass } from './orm/getSignal.ts'
+export { default as addModel } from './orm/addModel.ts'
+export {
+  defineModels,
+  default as initModels,
+  getModels,
+  resetModelsForTests
+} from './orm/initModels.ts'
+export { default as signal } from './orm/getSignal.ts'
+export { GLOBAL_ROOT_ID } from './orm/Root.ts'
+const getRuntimeRootSignal = _getRootSignal as (options: Record<string, any>) => unknown
+export const $: RootSignal = getRuntimeRootSignal({ rootId: GLOBAL_ROOT_ID, rootFunction: universal$ }) as RootSignal
+export const $root: RootSignal = $
+export const model: RootSignal = $
+export default $
+export { default as sub } from './orm/sub.ts'
+export {
+  default as useSub,
+  useAsyncSub,
+  setUseDeferredValue as __setUseDeferredValue,
+  setDefaultDefer as __setDefaultDefer
+} from './react/useSub.ts'
+export {
+  default as useSuspendMemo,
+  useSuspendMemoByKey
+} from './react/useSuspendMemo.ts'
+export const observer = runtimeObserver as unknown as ObserverFunction
+export {
+  useValue,
+  useValue$,
+  useModel,
+  useLocal,
+  useLocal$,
+  useLocalDoc,
+  useLocalDoc$,
+  useSession,
+  useSession$,
+  usePage,
+  usePage$,
+  useBatch,
+  useDoc,
+  useDoc$,
+  useBatchDoc,
+  useBatchDoc$,
+  useAsyncDoc,
+  useAsyncDoc$,
+  useQuery,
+  useQuery$,
+  useAsyncQuery,
+  useAsyncQuery$,
+  useBatchQuery,
+  useBatchQuery$,
+  useQueryIds,
+  useBatchQueryIds,
+  useAsyncQueryIds,
+  useQueryDoc,
+  useQueryDoc$,
+  useBatchQueryDoc,
+  useBatchQueryDoc$,
+  useAsyncQueryDoc,
+  useAsyncQueryDoc$
+} from './orm/Compat/hooksCompat.js'
+export { emit, useOn, useEmit } from './orm/Compat/eventsCompat.js'
+export {
+  useDidUpdate,
+  useOnce,
+  useSyncEffect
+} from './react/helpers.ts'
+export {
+  connection,
+  setConnection,
+  getConnection,
+  getDefaultFetchOnly,
+  setDefaultFetchOnly,
+  publicOnly,
+  setPublicOnly
+} from './orm/connection.ts'
+export type { TeamplayConnection, TeamplayShareDoc } from './orm/connection.ts'
+export { getSubscriptionGcDelay, setSubscriptionGcDelay } from './orm/subscriptionGcDelay.ts'
+export { useId, useNow, useScheduleUpdate, useTriggerUpdate } from './react/helpers.ts'
+export { GUID_PATTERN, defineSchema, hasMany, hasOne, hasManyFlags, belongsTo, pickFormFields } from '@teamplay/schema'
+export { aggregation, aggregationHeader as __aggregationHeader } from '@teamplay/utils/aggregation'
+export { accessControl } from '@teamplay/utils/accessControl'
+export type {
+  AggregationCallback,
+  AggregationContext,
+  AggregationFunction,
+  AggregationMeta,
+  AggregationParams,
+  AggregationQuery,
+  ClientAggregationFunction,
+  DefaultAggregationSession
+} from '@teamplay/utils/aggregation'
+export type {
+  AccessControl,
+  AccessControlRules,
+  AccessCreateContext,
+  AccessDecision,
+  AccessDeleteContext,
+  AccessOperation,
+  AccessReadContext,
+  AccessRule,
+  AccessUpdateContext,
+  AccessValidator,
+  AccessValidatorObject,
+  DefaultAccessSession
+} from '@teamplay/utils/accessControl'
+
+export function batch (): undefined
+export function batch<TResult> (fn: () => TResult): TResult
+export function batch<TResult> (fn?: () => TResult): TResult | undefined {
+  return fn == null ? $.batch() : $.batch(fn)
+}
+
+export function batchModel (): undefined
+export function batchModel<TResult> (fn: () => TResult): TResult
+export function batchModel<TResult> (fn?: () => TResult): TResult | undefined {
+  return fn == null ? $.batch() : $.batch(fn)
+}
+
+export function serverOnly<TValue> (value: TValue): TValue {
+  return value
+}
+
+export function clone<TValue> (value: TValue): TValue {
+  if (typeof globalThis.structuredClone === 'function') {
+    try {
+      return globalThis.structuredClone(value)
+    } catch {}
+  }
+  if (value == null) return value
+  return JSON.parse(JSON.stringify(value))
+}
+
+export function initLocalCollection (name: string): any {
+  if (typeof name !== 'string') throw Error('initLocalCollection() expects a collection name')
+  if (!name) return
+  const segments = name.split('.').filter(Boolean)
+  if (!segments.length) return
+  let $cursor: any = $
+  for (const segment of segments) {
+    $cursor = $cursor[segment]
+  }
+  if ($cursor.get() == null) $cursor.set({})
+  return $cursor
+}
+
+export { useApi }
+
+export function getRootSignal<TCollections extends Record<string, any> = TeamplayCollections> (options?: Record<string, any>): RootSignal<TCollections> {
+  return getRuntimeRootSignal({
+    rootFunction: universal$,
+    ...options
+  }) as RootSignal<TCollections>
+}
diff --git a/packages/teamplay/orm/$.d.ts b/packages/teamplay/orm/$.d.ts
new file mode 100644
index 0000000..b14864d
--- /dev/null
+++ b/packages/teamplay/orm/$.d.ts
@@ -0,0 +1,9 @@
+import type Signal from './Signal.ts'
+
+export const LOCAL: string
+
+export default function $ (
+  $root: Signal,
+  value?: unknown,
+  id?: string
+): Signal
diff --git a/packages/teamplay/orm/$.js b/packages/teamplay/orm/$.js
index fae53dd..ba61fbe 100644
--- a/packages/teamplay/orm/$.js
+++ b/packages/teamplay/orm/$.js
@@ -1,8 +1,8 @@
 // this is just the $() function implementation.
 // The actual $ exported from this package is a Proxy targeting the dataTree root,
 // and this function is an implementation of the `apply` handler for that Proxy.
-import getSignal from './getSignal.js'
-import Signal from './Signal.js'
+import getSignal from './getSignal.ts'
+import Signal from './Signal.ts'
 import { LOCAL, valueSubscriptions } from './Value.js'
 import { reactionSubscriptions } from './Reaction.js'
 
diff --git a/packages/teamplay/orm/Aggregation.d.ts b/packages/teamplay/orm/Aggregation.d.ts
new file mode 100644
index 0000000..a399cca
--- /dev/null
+++ b/packages/teamplay/orm/Aggregation.d.ts
@@ -0,0 +1,17 @@
+import type Signal from './Signal.ts'
+import type {
+  QuerySubscriptions,
+  QuerySignalOptions
+} from './Query.js'
+
+export const IS_AGGREGATION: unique symbol
+export const AGGREGATIONS: '$aggregations'
+export const aggregationSubscriptions: QuerySubscriptions
+export function getAggregationSignal (collectionName: string, params: unknown, options?: QuerySignalOptions): Signal
+export function isAggregationSignal ($signal: unknown): boolean | undefined
+export function getAggregationDocId (
+  segments: readonly unknown[],
+  rootId?: string,
+  method?: (path: unknown[]) => unknown
+): string | number | undefined
+export function getAggregationCollectionName (segments: readonly unknown[]): string | undefined
diff --git a/packages/teamplay/orm/Aggregation.js b/packages/teamplay/orm/Aggregation.js
index cc0deea..d313918 100644
--- a/packages/teamplay/orm/Aggregation.js
+++ b/packages/teamplay/orm/Aggregation.js
@@ -1,6 +1,6 @@
 import { raw } from '@nx-js/observer-util'
 import { getRaw } from './dataTree.js'
-import getSignal from './getSignal.js'
+import getSignal from './getSignal.ts'
 import {
   QuerySubscriptions,
   hashQuery,
@@ -10,9 +10,10 @@ import {
   COLLECTION_NAME,
   parseQueryHash
 } from './Query.js'
-import Signal, { SEGMENTS } from './Signal.js'
-import { getIdFieldsForSegments, isPlainObject } from './idFields.js'
+import Signal, { SEGMENTS } from './Signal.ts'
+import { getIdFieldsForSegments, isPlainObject } from './idFields.ts'
 import { delPrivateData, getPrivateData, setPrivateData } from './privateData.js'
+import { setSignalRuntimeDescriptor } from './signalRuntimeDescriptor.ts'
 
 export const IS_AGGREGATION = Symbol('is aggregation signal')
 export const AGGREGATIONS = '$aggregations'
@@ -72,6 +73,11 @@ export function getAggregationSignal (collectionName, params, options) {
   $aggregation[COLLECTION_NAME] ??= collectionName
   $aggregation[PARAMS] ??= params
   $aggregation[HASH] ??= transportHash
+  setSignalRuntimeDescriptor($aggregation, {
+    kind: 'aggregation',
+    collectionName,
+    itemPattern: [collectionName, '*']
+  })
   return $aggregation
 }
 
diff --git a/packages/teamplay/orm/Cache.js b/packages/teamplay/orm/Cache.js
deleted file mode 100644
index 32a7fec..0000000
--- a/packages/teamplay/orm/Cache.js
+++ /dev/null
@@ -1,46 +0,0 @@
-import FinalizationRegistry from '../utils/MockFinalizationRegistry.js'
-import WeakRef, { destroyMockWeakRef } from '../utils/MockWeakRef.js'
-
-export default class Cache {
-  constructor () {
-    this.cache = new Map()
-    this.fr = new FinalizationRegistry(([key]) => {
-      // handle situation when FinalizationRegistry triggers
-      // way later after the WeakRef is already garbage collected.
-      // In this case we might already have a new value in the cache
-      // and we don't want to delete it.
-      if (this.get(key)) return
-      this.delete(key)
-    })
-  }
-
-  // for testing purposes
-  _getKeys () {
-    return Array.from(this.cache.keys()).sort()
-  }
-
-  get (key) {
-    return this.cache.get(key)?.deref()
-  }
-
-  /**
-   * @param {string} key
-   * @param {*} value
-   * @param {Array} inputs - extra inputs to register with the finalization registry
-   *                         to hold strong references to them until the value is garbage collected
-   */
-  set (key, value, inputs = []) {
-    if (typeof key !== 'string') throw Error('Cache key should be a string')
-    this.cache.set(key, new WeakRef(value))
-    this.fr.register(value, [key, ...inputs])
-  }
-
-  delete (key) {
-    destroyMockWeakRef(this.cache.get(key)) // TODO: remove this when WeakRef is available in RN
-    this.cache.delete(key)
-  }
-
-  get size () {
-    return this.cache.size
-  }
-}
diff --git a/packages/teamplay/orm/Cache.ts b/packages/teamplay/orm/Cache.ts
new file mode 100644
index 0000000..241dff4
--- /dev/null
+++ b/packages/teamplay/orm/Cache.ts
@@ -0,0 +1,38 @@
+import FinalizationRegistry from '../utils/MockFinalizationRegistry.ts'
+import WeakRef, { destroyMockWeakRef, type WeakRefLike } from '../utils/MockWeakRef.ts'
+
+type FinalizationValue = readonly [string, ...object[]]
+
+export default class Cache<TValue extends object = object> {
+  private readonly cache = new Map<string, WeakRefLike<TValue>>()
+  private readonly fr = new FinalizationRegistry<FinalizationValue>(([key]) => {
+    // FinalizationRegistry can trigger long after the WeakRef was already
+    // collected and a fresh value was stored for the same key.
+    if (this.get(key)) return
+    this.delete(key)
+  })
+
+  // For testing purposes.
+  _getKeys (): string[] {
+    return Array.from(this.cache.keys()).sort()
+  }
+
+  get (key: string): TValue | undefined {
+    return this.cache.get(key)?.deref()
+  }
+
+  set (key: string, value: TValue, inputs: readonly object[] = []): void {
+    if (typeof key !== 'string') throw Error('Cache key should be a string')
+    this.cache.set(key, new WeakRef(value))
+    this.fr.register(value, [key, ...inputs])
+  }
+
+  delete (key: string): void {
+    destroyMockWeakRef(this.cache.get(key))
+    this.cache.delete(key)
+  }
+
+  get size (): number {
+    return this.cache.size
+  }
+}
diff --git a/packages/teamplay/orm/Compat/SignalCompat.d.ts b/packages/teamplay/orm/Compat/SignalCompat.d.ts
new file mode 100644
index 0000000..7f7287a
--- /dev/null
+++ b/packages/teamplay/orm/Compat/SignalCompat.d.ts
@@ -0,0 +1,3 @@
+import { Signal } from '../SignalBase.ts'
+
+export default class SignalCompat<TValue = unknown> extends Signal<TValue> {}
diff --git a/packages/teamplay/orm/Compat/SignalCompat.js b/packages/teamplay/orm/Compat/SignalCompat.js
index fffc715..d4ee5f7 100644
--- a/packages/teamplay/orm/Compat/SignalCompat.js
+++ b/packages/teamplay/orm/Compat/SignalCompat.js
@@ -8,13 +8,13 @@ import {
   isPublicCollection,
   isPublicCollectionSignal,
   isPublicDocumentSignal
-} from '../SignalBase.js'
-import { getRoot, ROOT, ROOT_ID, getRootSignal, GLOBAL_ROOT_ID, unregisterRootFinalizer } from '../Root.js'
-import { isPrivateMutationForbidden } from '../connection.js'
+} from '../SignalBase.ts'
+import { getRoot, ROOT, ROOT_ID, getRootSignal, GLOBAL_ROOT_ID, unregisterRootFinalizer } from '../Root.ts'
+import { isPrivateMutationForbidden } from '../connection.ts'
 import { docSubscriptions } from '../Doc.js'
 import { IS_QUERY, getQuerySignal, querySubscriptions } from '../Query.js'
 import { IS_AGGREGATION, aggregationSubscriptions, getAggregationSignal } from '../Aggregation.js'
-import { getIdFieldsForSegments, isIdFieldPath, isPublicDocPath, normalizeIdFields, isPlainObject } from '../idFields.js'
+import { getIdFieldsForSegments, isIdFieldPath, isPublicDocPath, normalizeIdFields, isPlainObject } from '../idFields.ts'
 import {
   incrementPublic as _incrementPublic,
   arrayPushPublic as _arrayPushPublic,
@@ -35,9 +35,9 @@ import { setRefLink, removeRefLink, getAllRefLinks } from './refRegistry.js'
 import { REF_TARGET, resolveRefSignalSafe, resolveRefSegmentsSafe } from './refFallback.js'
 import { runInBatch } from '../batchScheduler.js'
 import { runInSilentContext, runInModelEventsSilentContext, isSilentContextActive } from './silentContext.js'
-import universal$ from '../../react/universal$.js'
-import { getRootContext } from '../rootContext.js'
-import disposeRootContext from '../disposeRootContext.js'
+import universal$ from '../../react/universal$.ts'
+import { getRootContext } from '../rootContext.ts'
+import disposeRootContext from '../disposeRootContext.ts'
 import {
   arrayInsertPrivateData,
   arrayMovePrivateData,
diff --git a/packages/teamplay/orm/Compat/eventsCompat.d.ts b/packages/teamplay/orm/Compat/eventsCompat.d.ts
new file mode 100644
index 0000000..971f6f2
--- /dev/null
+++ b/packages/teamplay/orm/Compat/eventsCompat.d.ts
@@ -0,0 +1,3 @@
+export const emit: any
+export const useOn: any
+export const useEmit: any
diff --git a/packages/teamplay/orm/Compat/hooksCompat.d.ts b/packages/teamplay/orm/Compat/hooksCompat.d.ts
new file mode 100644
index 0000000..04bba4e
--- /dev/null
+++ b/packages/teamplay/orm/Compat/hooksCompat.d.ts
@@ -0,0 +1,33 @@
+export const useValue: any
+export const useValue$: any
+export const useModel: any
+export const useLocal: any
+export const useLocal$: any
+export const useLocalDoc: any
+export const useLocalDoc$: any
+export const useSession: any
+export const useSession$: any
+export const usePage: any
+export const usePage$: any
+export const useBatch: any
+export const useDoc: any
+export const useDoc$: any
+export const useBatchDoc: any
+export const useBatchDoc$: any
+export const useAsyncDoc: any
+export const useAsyncDoc$: any
+export const useQuery: any
+export const useQuery$: any
+export const useAsyncQuery: any
+export const useAsyncQuery$: any
+export const useBatchQuery: any
+export const useBatchQuery$: any
+export const useQueryIds: any
+export const useBatchQueryIds: any
+export const useAsyncQueryIds: any
+export const useQueryDoc: any
+export const useQueryDoc$: any
+export const useBatchQueryDoc: any
+export const useBatchQueryDoc$: any
+export const useAsyncQueryDoc: any
+export const useAsyncQueryDoc$: any
diff --git a/packages/teamplay/orm/Compat/hooksCompat.js b/packages/teamplay/orm/Compat/hooksCompat.js
index 2cdd8d6..9f8bbc7 100644
--- a/packages/teamplay/orm/Compat/hooksCompat.js
+++ b/packages/teamplay/orm/Compat/hooksCompat.js
@@ -1,7 +1,7 @@
-import { getRootSignal, GLOBAL_ROOT_ID } from '../Root.js'
-import useSub, { useAsyncSub } from '../../react/useSub.js'
-import universal$ from '../../react/universal$.js'
-import * as promiseBatcher from '../../react/promiseBatcher.js'
+import { getRootSignal, GLOBAL_ROOT_ID } from '../Root.ts'
+import useSub, { useAsyncSub } from '../../react/useSub.ts'
+import universal$ from '../../react/universal$.ts'
+import * as promiseBatcher from '../../react/promiseBatcher.ts'
 import { isCompatEnv } from '../compatEnv.js'
 import { isQueryReady } from './queryReadiness.js'
 
diff --git a/packages/teamplay/orm/Compat/modelEvents.js b/packages/teamplay/orm/Compat/modelEvents.js
index c40e5fd..219fbfe 100644
--- a/packages/teamplay/orm/Compat/modelEvents.js
+++ b/packages/teamplay/orm/Compat/modelEvents.js
@@ -1,8 +1,8 @@
 import { getRefLinks, getRefRootIds } from './refRegistry.js'
 import { isCompatEnv } from '../compatEnv.js'
 import { isSilentContextActive, isModelEventsSilentContextActive, runInModelEventsSilentContext } from './silentContext.js'
-import { normalizeRootId } from '../rootScope.js'
-import { getRootContext, getRootContexts } from '../rootContext.js'
+import { normalizeRootId } from '../rootScope.ts'
+import { getRootContext, getRootContexts } from '../rootContext.ts'
 import { setReplace as setReplaceInDataTree, del as delFromDataTree } from '../dataTree.js'
 import { setReplacePrivateData, delPrivateData } from '../privateData.js'
 
diff --git a/packages/teamplay/orm/Compat/queryReadiness.js b/packages/teamplay/orm/Compat/queryReadiness.js
index 5ccf983..fdeca21 100644
--- a/packages/teamplay/orm/Compat/queryReadiness.js
+++ b/packages/teamplay/orm/Compat/queryReadiness.js
@@ -1,12 +1,12 @@
 import { getRaw } from '../dataTree.js'
-import { getConnection } from '../connection.js'
+import { getConnection } from '../connection.ts'
 import { isMissingShareDoc } from '../missingDoc.js'
 import { QUERIES, HASH, PARAMS, COLLECTION_NAME, querySubscriptions } from '../Query.js'
 import { AGGREGATIONS, IS_AGGREGATION, aggregationSubscriptions } from '../Aggregation.js'
 import { getPrivateData, setPrivateData } from '../privateData.js'
-import { getRoot, ROOT_ID } from '../Root.js'
-import { isRootContextClosed } from '../rootContext.js'
-import { getScopedSignalHash, normalizeRootId } from '../rootScope.js'
+import { getRoot, ROOT_ID } from '../Root.ts'
+import { isRootContextClosed } from '../rootContext.ts'
+import { getScopedSignalHash, normalizeRootId } from '../rootScope.ts'
 
 let imperativeQueryReadyTimeoutMs = 1000
 
diff --git a/packages/teamplay/orm/Compat/refFallback.d.ts b/packages/teamplay/orm/Compat/refFallback.d.ts
new file mode 100644
index 0000000..ee04f18
--- /dev/null
+++ b/packages/teamplay/orm/Compat/refFallback.d.ts
@@ -0,0 +1,13 @@
+import type { PathSegment } from '../types/path.ts'
+import type { SignalBaseInstance } from '../Signal.ts'
+
+export const REF_TARGET: unique symbol
+export function resolveRefSignalSafe<TSignal extends SignalBaseInstance> (
+  $signal: TSignal | undefined,
+  maxDepth?: number
+): TSignal | undefined
+export function resolveRefSegmentsSafe (
+  segments: readonly PathSegment[],
+  rootId?: string,
+  maxDepth?: number
+): PathSegment[] | undefined
diff --git a/packages/teamplay/orm/Compat/refFallback.js b/packages/teamplay/orm/Compat/refFallback.js
index 492c2e4..3e928a8 100644
--- a/packages/teamplay/orm/Compat/refFallback.js
+++ b/packages/teamplay/orm/Compat/refFallback.js
@@ -1,5 +1,5 @@
 import { getRefLinks } from './refRegistry.js'
-import { GLOBAL_ROOT_ID } from '../Root.js'
+import { GLOBAL_ROOT_ID } from '../Root.ts'
 
 export const REF_TARGET = Symbol.for('teamplay.compat.refTarget')
 
diff --git a/packages/teamplay/orm/Compat/refRegistry.js b/packages/teamplay/orm/Compat/refRegistry.js
index 97b2af7..2e797e2 100644
--- a/packages/teamplay/orm/Compat/refRegistry.js
+++ b/packages/teamplay/orm/Compat/refRegistry.js
@@ -1,6 +1,6 @@
-import { GLOBAL_ROOT_ID } from '../Root.js'
-import { normalizeRootId } from '../rootScope.js'
-import { getRootContext, getRootContexts } from '../rootContext.js'
+import { GLOBAL_ROOT_ID } from '../Root.ts'
+import { normalizeRootId } from '../rootScope.ts'
+import { getRootContext, getRootContexts } from '../rootContext.ts'
 
 const EMPTY_MAP = new Map()
 
diff --git a/packages/teamplay/orm/Compat/startStopCompat.js b/packages/teamplay/orm/Compat/startStopCompat.js
index 1641544..4f71225 100644
--- a/packages/teamplay/orm/Compat/startStopCompat.js
+++ b/packages/teamplay/orm/Compat/startStopCompat.js
@@ -1,5 +1,5 @@
 import { observe, raw, unobserve } from '@nx-js/observer-util'
-import { getRoot } from '../Root.js'
+import { getRoot } from '../Root.ts'
 import { scheduleReaction } from '../batchScheduler.js'
 
 const START_REACTIONS = Symbol('compat start reactions')
diff --git a/packages/teamplay/orm/Doc.d.ts b/packages/teamplay/orm/Doc.d.ts
new file mode 100644
index 0000000..f9c38cf
--- /dev/null
+++ b/packages/teamplay/orm/Doc.d.ts
@@ -0,0 +1,96 @@
+import type Signal from './Signal.ts'
+
+export type SubscriptionIntent = 'fetch' | 'subscribe'
+export type TransportMode = 'idle' | 'fetch' | 'subscribe'
+export type TransportPhase = 'stable' | 'transition'
+export type SignalPathSegments = Array<string | number>
+
+export interface ReadonlyMapView<TKey, TValue> extends Iterable<[TKey, TValue | undefined]> {
+  get (key: TKey): TValue | undefined
+  has (key: TKey): boolean
+  readonly size: number
+  keys (): IterableIterator<TKey>
+  values (): IterableIterator<TValue | undefined>
+  entries (): IterableIterator<[TKey, TValue | undefined]>
+}
+
+export interface PendingDestroyEntry {
+  timer?: ReturnType<typeof setTimeout>
+  force: boolean
+  promise: Promise<unknown>
+  resolve: () => void
+  reject: (error?: unknown) => void
+}
+
+export interface DocOwnerMeta {
+  hash: string
+  segments: SignalPathSegments
+  rootId?: string
+}
+
+export interface DocOwnerRecord extends DocOwnerMeta {
+  ownerKey: string
+  fetchCount: number
+  subscribeCount: number
+}
+
+export interface DocRuntimeEntry {
+  hash: string
+  segments: SignalPathSegments
+  mode: TransportMode
+  targetMode: TransportMode
+  phase: TransportPhase
+  runtime: Doc | null
+  owners: Set<string>
+  retainCount: number
+  pendingDestroy: PendingDestroyEntry | null
+  reconcilePromise: Promise<void> | null
+}
+
+export class Doc {
+  initialized?: boolean
+  collection: string
+  docId: string | number
+  requestedTransportMode: TransportMode
+  activeTransportMode: TransportMode
+  readonly subscribed: boolean
+  constructor (collection: string, docId: string | number)
+  init (): void
+  subscribe (options?: { mode?: Exclude<TransportMode, 'idle'> }): Promise<void>
+  unsubscribe (): Promise<void>
+  hasPending (): boolean
+  whenNothingPending (fn: () => void): void
+  destroy (): Promise<void>
+  dispose (): void
+}
+
+export type DocConstructor = new (collection: string, docId: string | number) => Doc
+
+export class DocSubscriptions {
+  DocClass: DocConstructor
+  ownerRecords: Map<string, DocOwnerRecord>
+  entries: Map<string, DocRuntimeEntry>
+  subCount: ReadonlyMapView<string, number>
+  ownerFetchCount: ReadonlyMapView<string, number>
+  ownerSubscribeCount: ReadonlyMapView<string, number>
+  ownerMeta: ReadonlyMapView<string, DocOwnerMeta>
+  ownerKeysByHash: ReadonlyMapView<string, Set<string>>
+  docs: ReadonlyMapView<string, Doc>
+  pendingDestroyTimers: ReadonlyMapView<string, PendingDestroyEntry>
+  constructor (DocClass?: DocConstructor)
+  init ($doc: Signal): void
+  subscribe ($doc: Signal, options?: { intent?: SubscriptionIntent }): Promise<void> | void
+  unsubscribe ($doc: Signal, options?: { intent?: SubscriptionIntent }): Promise<void>
+  retain ($doc: Signal): void
+  release ($doc: Signal): Promise<void>
+  destroy (segments: SignalPathSegments): Promise<void>
+  clear (): Promise<void>
+  releaseRootOwnedSubscriptions (rootId: string): Promise<void>
+  flushPendingDestroys (): Promise<void>
+  scheduleDestroy (segments: SignalPathSegments, options?: { force?: boolean }): Promise<void> | void
+  cancelDestroy (hash: string): void
+  getOwnerMeta (ownerKey: string): DocOwnerMeta | undefined
+  getOwnerKeys (hash: string): Set<string> | undefined
+}
+
+export const docSubscriptions: DocSubscriptions
diff --git a/packages/teamplay/orm/Doc.js b/packages/teamplay/orm/Doc.js
index a7a7b9e..577b829 100644
--- a/packages/teamplay/orm/Doc.js
+++ b/packages/teamplay/orm/Doc.js
@@ -1,20 +1,20 @@
 import { isObservable, observable, raw } from '@nx-js/observer-util'
 import { set as _set, del as _del, getRaw as _getRaw } from './dataTree.js'
-import { SEGMENTS } from './Signal.js'
-import { getConnection } from './connection.js'
-import FinalizationRegistry from '../utils/MockFinalizationRegistry.js'
+import { SEGMENTS } from './Signal.ts'
+import { getConnection } from './connection.ts'
+import FinalizationRegistry from '../utils/MockFinalizationRegistry.ts'
 import SubscriptionState from './SubscriptionState.js'
-import { getIdFieldsForSegments, injectIdFields, isPlainObject } from './idFields.js'
+import { getIdFieldsForSegments, injectIdFields, isPlainObject } from './idFields.ts'
 import { emitModelChange, isModelEventsEnabled } from './Compat/modelEvents.js'
-import { getSubscriptionGcDelay } from './subscriptionGcDelay.js'
+import { getSubscriptionGcDelay } from './subscriptionGcDelay.ts'
 import { isMissingShareDoc } from './missingDoc.js'
-import { getRoot, ROOT_ID, GLOBAL_ROOT_ID, getRootTransportMode } from './Root.js'
+import { getRoot, ROOT_ID, GLOBAL_ROOT_ID, getRootTransportMode } from './Root.ts'
 import {
   registerRootOwnedDirectDocSubscription,
   unregisterRootOwnedDirectDocSubscription,
   getRootOwnedDirectDocSubscriptions,
   clearRootOwnedDirectDocSubscriptions
-} from './rootContext.js'
+} from './rootContext.ts'
 
 const ERROR_ON_EXCESSIVE_UNSUBSCRIBES = false
 const DOC_FINALIZATION_TOKENS = new WeakMap()
diff --git a/packages/teamplay/orm/Query.d.ts b/packages/teamplay/orm/Query.d.ts
new file mode 100644
index 0000000..df51ca2
--- /dev/null
+++ b/packages/teamplay/orm/Query.d.ts
@@ -0,0 +1,117 @@
+import type Signal from './Signal.ts'
+import type {
+  PendingDestroyEntry,
+  ReadonlyMapView,
+  SubscriptionIntent,
+  TransportMode,
+  TransportPhase
+} from './Doc.js'
+
+export const COLLECTION_NAME: unique symbol
+export const PARAMS: unique symbol
+export const HASH: unique symbol
+export const IS_QUERY: unique symbol
+export const QUERIES: '$queries'
+
+export interface QueryHashParts {
+  collectionName?: string
+  params?: unknown
+}
+
+export interface QuerySignalOptions {
+  root?: Signal
+  rootId?: string
+  [option: string]: unknown
+}
+
+export interface QueryOwnerMeta {
+  collectionName: string
+  params: unknown
+  transportHash: string
+  rootId?: string
+}
+
+export interface QueryOwnerRecord extends QueryOwnerMeta {
+  ownerKey: string
+  fetchCount: number
+  subscribeCount: number
+}
+
+export interface QueryRuntimeEntry {
+  transportHash: string
+  mode: TransportMode
+  targetMode: TransportMode
+  phase: TransportPhase
+  runtime: Query | null
+  owners: Set<string>
+  pendingDestroyByOwner: Map<string, PendingQueryDestroyEntry>
+  reconcilePromise: Promise<void> | null
+}
+
+export interface PendingQueryDestroyEntry extends PendingDestroyEntry {
+  collectionName?: string
+  params?: unknown
+  transportHash?: string
+}
+
+export class Query {
+  initialized?: boolean
+  collectionName: string
+  params: unknown
+  hash: string
+  rootIds: Set<string>
+  docSignals: Set<Signal>
+  requestedTransportMode: TransportMode
+  activeTransportMode: TransportMode
+  readonly subscribed: boolean
+  constructor (collectionName: string, params: unknown, options?: { hash?: string })
+  init (): void
+  subscribe (options?: { mode?: Exclude<TransportMode, 'idle'> }): Promise<void>
+  unsubscribe (): Promise<void>
+  attachRoot (rootId?: string): void
+  detachRoot (rootId?: string): void
+}
+
+export type QueryConstructor = new (
+  collectionName: string,
+  params: unknown,
+  options?: { hash?: string }
+) => Query
+
+export class QuerySubscriptions {
+  QueryClass: QueryConstructor
+  runtimeKind: 'query' | 'aggregation'
+  ownerRecords: Map<string, QueryOwnerRecord>
+  entries: Map<string, QueryRuntimeEntry>
+  subCount: ReadonlyMapView<string, number>
+  transportSubCount: ReadonlyMapView<string, number>
+  ownerFetchCount: ReadonlyMapView<string, number>
+  ownerSubscribeCount: ReadonlyMapView<string, number>
+  queries: ReadonlyMapView<string, Query>
+  ownerToTransport: ReadonlyMapView<string, string>
+  ownerMeta: ReadonlyMapView<string, QueryOwnerMeta>
+  ownerKeysByTransport: ReadonlyMapView<string, Set<string>>
+  pendingDestroyTimers: ReadonlyMapView<string, PendingQueryDestroyEntry>
+  constructor (QueryClass?: QueryConstructor)
+  subscribe ($query: Signal, options?: { intent?: SubscriptionIntent }): Promise<void> | void
+  unsubscribe ($query: Signal, options?: { intent?: SubscriptionIntent }): Promise<void>
+  destroy (collectionName: string, params: unknown, options?: { force?: boolean }): Promise<void>
+  clear (): Promise<void>
+  flushPendingDestroys (): Promise<void>
+  scheduleDestroy (
+    collectionName: string,
+    params: unknown,
+    ownerKey?: string,
+    options?: { transportHash?: string, force?: boolean }
+  ): Promise<void> | void
+  cancelDestroy (ownerKey: string, transportHash?: string): void
+  destroyByRuntimeHash (runtimeHash: string, options?: { rootId?: string, force?: boolean }): Promise<void>
+  getOwnerMeta (ownerKey: string): QueryOwnerMeta | undefined
+  getOwnerKeys (transportHash: string): Set<string> | undefined
+  getPendingDestroyOwnerKeys (): IterableIterator<string>
+}
+
+export const querySubscriptions: QuerySubscriptions
+export function getQuerySignal (collectionName: string, params: unknown, options?: QuerySignalOptions): Signal
+export function hashQuery (collectionName: string, params: unknown): string
+export function parseQueryHash (hash: string): QueryHashParts
diff --git a/packages/teamplay/orm/Query.js b/packages/teamplay/orm/Query.js
index 3b6bd9f..1b3a746 100644
--- a/packages/teamplay/orm/Query.js
+++ b/packages/teamplay/orm/Query.js
@@ -1,17 +1,18 @@
 import { raw } from '@nx-js/observer-util'
 import { set as _set, getRaw } from './dataTree.js'
-import getSignal from './getSignal.js'
-import { getConnection } from './connection.js'
+import getSignal from './getSignal.ts'
+import { getConnection } from './connection.ts'
 import { emitModelChange, isModelEventsEnabled } from './Compat/modelEvents.js'
 import { isCompatEnv } from './compatEnv.js'
 import { docSubscriptions } from './Doc.js'
-import FinalizationRegistry from '../utils/MockFinalizationRegistry.js'
+import FinalizationRegistry from '../utils/MockFinalizationRegistry.ts'
 import SubscriptionState from './SubscriptionState.js'
-import { getIdFieldsForSegments, injectIdFields, isPlainObject } from './idFields.js'
-import { getSubscriptionGcDelay } from './subscriptionGcDelay.js'
-import { getScopedSignalHash, normalizeRootId } from './rootScope.js'
-import { getRoot, ROOT_ID, getRootTransportMode } from './Root.js'
-import { registerRootOwnedRuntime, unregisterRootOwnedRuntime } from './rootContext.js'
+import { getIdFieldsForSegments, injectIdFields, isPlainObject } from './idFields.ts'
+import { getSubscriptionGcDelay } from './subscriptionGcDelay.ts'
+import { getScopedSignalHash, normalizeRootId } from './rootScope.ts'
+import { getRoot, ROOT_ID, getRootTransportMode } from './Root.ts'
+import { registerRootOwnedRuntime, unregisterRootOwnedRuntime } from './rootContext.ts'
+import { setSignalRuntimeDescriptor } from './signalRuntimeDescriptor.ts'
 import {
   delPrivateData,
   getPrivateData,
@@ -948,6 +949,11 @@ export function getQuerySignal (collectionName, params, options) {
   $query[COLLECTION_NAME] ??= collectionName
   $query[PARAMS] ??= params
   $query[HASH] ??= transportHash
+  setSignalRuntimeDescriptor($query, {
+    kind: 'query',
+    collectionName,
+    itemPattern: [collectionName, '*']
+  })
   return $query
 }
 
diff --git a/packages/teamplay/orm/Reaction.js b/packages/teamplay/orm/Reaction.js
index 5405062..e262a65 100644
--- a/packages/teamplay/orm/Reaction.js
+++ b/packages/teamplay/orm/Reaction.js
@@ -1,13 +1,13 @@
 import { observe, unobserve } from '@nx-js/observer-util'
-import { SEGMENTS } from './Signal.js'
+import { SEGMENTS } from './Signal.ts'
 import { LOCAL } from './Value.js'
-import FinalizationRegistry from '../utils/MockFinalizationRegistry.js'
+import FinalizationRegistry from '../utils/MockFinalizationRegistry.ts'
 import { scheduleReaction } from './batchScheduler.js'
-import { getRoot, ROOT_ID } from './Root.js'
+import { getRoot, ROOT_ID } from './Root.ts'
 import { delPrivateData, setPrivateData } from './privateData.js'
 
 // this is `let` to be able to directly change it if needed in tests or in the app
-export let DELETION_DELAY = 0 // eslint-disable-line prefer-const
+export let DELETION_DELAY = 0
 
 class ReactionSubscriptions {
   constructor () {
diff --git a/packages/teamplay/orm/Root.js b/packages/teamplay/orm/Root.ts
similarity index 50%
rename from packages/teamplay/orm/Root.js
rename to packages/teamplay/orm/Root.ts
index 1b82090..935b4d3 100644
--- a/packages/teamplay/orm/Root.js
+++ b/packages/teamplay/orm/Root.ts
@@ -1,8 +1,9 @@
-import getSignal from './getSignal.js'
-import disposeRootContext from './disposeRootContext.js'
-import { getRootContext, reviveRootContext } from './rootContext.js'
-import { isGlobalRootId, normalizeRootId } from './rootScope.js'
-import FinalizationRegistry from '../utils/MockFinalizationRegistry.js'
+import getSignal from './getSignal.ts'
+import disposeRootContext from './disposeRootContext.ts'
+import { getRootContext, reviveRootContext } from './rootContext.ts'
+import { isGlobalRootId, normalizeRootId } from './rootScope.ts'
+import ExportedFinalizationRegistry from '../utils/MockFinalizationRegistry.ts'
+import type { SignalBaseInstance } from './Signal.ts'
 
 export const ROOT_FUNCTION = Symbol('root function')
 // TODO: in future make a connection spawnable instead of a singleton
@@ -12,12 +13,42 @@ export const ROOT_ID = Symbol('root signal id. Used for caching')
 
 export const GLOBAL_ROOT_ID = '__global__'
 
-const ROOT_FINALIZATION_REGISTRY = new FinalizationRegistry(rootId => {
+export interface RootSignalOptions extends Record<string, unknown> {
+  rootFunction?: unknown
+  fetchOnly?: boolean
+  rootId?: string
+}
+
+export type RootTransportIntent = 'fetch' | 'subscribe'
+
+export type RootSignalRuntime = SignalBaseInstance & {
+  [ROOT_FUNCTION]?: unknown
+  [ROOT]?: RootSignalRuntime
+  [ROOT_ID]?: string
+}
+
+type FinalizationRegistryConstructor = new (
+  cleanupCallback: (heldValue: string) => void
+) => {
+  register: (target: RootSignalRuntime, value: string, token?: RootSignalRuntime) => void
+  unregister: (token: RootSignalRuntime) => void
+}
+
+type RuntimeGetSignal = (
+  root: unknown,
+  segments: readonly [],
+  options: Record<string, unknown>
+) => unknown
+
+const getRuntimeSignal = getSignal as unknown as RuntimeGetSignal
+const RootFinalizationRegistry = ExportedFinalizationRegistry as unknown as FinalizationRegistryConstructor
+
+const ROOT_FINALIZATION_REGISTRY = new RootFinalizationRegistry((rootId: string) => {
   disposeRootContext(rootId).catch(err => {
     console.error(err)
   })
 })
-const REGISTERED_ROOT_SIGNALS = new WeakSet()
+const REGISTERED_ROOT_SIGNALS = new WeakSet<RootSignalRuntime>()
 
 // TODO: create a separate local root for private collections
 export function getRootSignal ({
@@ -26,13 +57,13 @@ export function getRootSignal ({
   // connection,
   rootId = '_' + createRandomString(8),
   ...options
-}) {
+}: RootSignalOptions = {}): RootSignalRuntime {
   reviveRootContext(rootId)
   getRootContext(rootId, true, { fetchOnly })
-  const $root = getSignal(undefined, [], {
+  const $root = getRuntimeSignal(undefined, [], {
     rootId,
     ...options
-  })
+  }) as RootSignalRuntime
   $root[ROOT_FUNCTION] ??= rootFunction
   // $root[CONNECTION] ??= connection
   $root[ROOT_ID] ??= rootId
@@ -40,14 +71,14 @@ export function getRootSignal ({
   return $root
 }
 
-export function getRoot (signal) {
+export function getRoot (signal: RootSignalRuntime | undefined): RootSignalRuntime | undefined {
   if (!signal) return undefined
   if (signal[ROOT]) return signal[ROOT]
   else if (signal[ROOT_ID]) return signal
   else return undefined
 }
 
-export function getRootFetchOnly (rootOrRootId) {
+export function getRootFetchOnly (rootOrRootId: RootSignalRuntime | string | undefined): boolean {
   const $root = typeof rootOrRootId === 'string'
     ? undefined
     : (getRoot(rootOrRootId) || rootOrRootId)
@@ -58,12 +89,15 @@ export function getRootFetchOnly (rootOrRootId) {
   return context?.getFetchOnly() ?? false
 }
 
-export function getRootTransportMode (rootOrRootId, intent = 'subscribe') {
+export function getRootTransportMode (
+  rootOrRootId: RootSignalRuntime | string | undefined,
+  intent: RootTransportIntent = 'subscribe'
+): RootTransportIntent {
   if (intent === 'fetch') return 'fetch'
   return getRootFetchOnly(rootOrRootId) ? 'fetch' : 'subscribe'
 }
 
-export function registerRootFinalizer ($root) {
+export function registerRootFinalizer ($root: RootSignalRuntime | undefined): void {
   if (!$root?.[ROOT_ID]) return
   if (REGISTERED_ROOT_SIGNALS.has($root)) return
   const rootId = normalizeRootId($root[ROOT_ID])
@@ -72,13 +106,13 @@ export function registerRootFinalizer ($root) {
   REGISTERED_ROOT_SIGNALS.add($root)
 }
 
-export function unregisterRootFinalizer ($root) {
+export function unregisterRootFinalizer ($root: RootSignalRuntime | undefined): void {
   if (!$root) return
   ROOT_FINALIZATION_REGISTRY.unregister($root)
   REGISTERED_ROOT_SIGNALS.delete($root)
 }
 
-function createRandomString (length) {
+function createRandomString (length: number): string {
   const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
   let result = ''
   for (let i = 0; i < length; i++) {
diff --git a/packages/teamplay/orm/Signal.js b/packages/teamplay/orm/Signal.js
deleted file mode 100644
index 04ae043..0000000
--- a/packages/teamplay/orm/Signal.js
+++ /dev/null
@@ -1,22 +0,0 @@
-import { Signal } from './SignalBase.js'
-import SignalCompat from './Compat/SignalCompat.js'
-import { isCompatEnv } from './compatEnv.js'
-
-export {
-  Signal,
-  SEGMENTS,
-  ARRAY_METHOD,
-  GET,
-  GETTERS,
-  DEFAULT_GETTERS,
-  regularBindings,
-  extremelyLateBindings,
-  isPublicCollectionSignal,
-  isPublicDocumentSignal,
-  isPublicCollection,
-  isPrivateCollection
-} from './SignalBase.js'
-
-export { SignalCompat }
-
-export default isCompatEnv() ? SignalCompat : Signal
diff --git a/packages/teamplay/orm/Signal.ts b/packages/teamplay/orm/Signal.ts
new file mode 100644
index 0000000..6a77e7b
--- /dev/null
+++ b/packages/teamplay/orm/Signal.ts
@@ -0,0 +1,94 @@
+import { Signal } from './SignalBase.ts'
+import SignalCompat from './Compat/SignalCompat.js'
+import { isCompatEnv } from './compatEnv.js'
+import type { SignalConstructor } from './types/signal.ts'
+
+export type {
+  FromJsonSchema,
+  InferZodSchema,
+  JsonSchema,
+  JsonSchemaObject,
+  ZodLikeSchema
+} from './types/jsonSchema.ts'
+export type { QueryParams } from './types/query.ts'
+export type {
+  SignalArrayMutatorMethods,
+  SignalArrayReaderMethods,
+  SignalCollectionMethods,
+  SignalMetadataMethods,
+  SignalStringMutatorMethods,
+  SignalValueMethods
+} from './types/baseMethods.ts'
+export type {
+  AppendPath,
+  JoinPath,
+  PathSegment,
+  SignalPath,
+  WildcardPathSegment,
+  WildcardSignalPath
+} from './types/path.ts'
+export type {
+  AggregationSignal,
+  AnySignal,
+  ArraySignal,
+  CollectionAggregationSignal,
+  CollectionDocument,
+  CollectionDocumentModel,
+  CollectionQuerySignal,
+  CollectionSignal,
+  CollectionSignalFromSpec,
+  CollectionSpec,
+  DocumentSignal,
+  JsonSchemaSpec,
+  MaybePromise,
+  MaybePromiseSubResult,
+  PublicSignal,
+  LocalSignalFactory,
+  RegisteredAggregationInput,
+  RuntimeSignalConstructor,
+  RuntimeSignalInstance,
+  QuerySignal,
+  RootCollections,
+  RootSignal,
+  SignalBaseInstance,
+  SignalChild,
+  SignalChildren,
+  SignalClass,
+  SignalConstructor,
+  SignalForKind,
+  SignalKind,
+  SignalInstance,
+  SignalModelConstructor,
+  SubResult,
+  TypedAggregationInput,
+  TypedAggregationSignal,
+  TypedSignal,
+  ZodSchemaSpec
+} from './types/signal.ts'
+export type {
+  CollectionsFromManifest,
+  ModelEntry,
+  ModelManifest,
+  PathModelsFromManifest
+} from './types/modelManifest.ts'
+
+export {
+  Signal,
+  SEGMENTS,
+  ARRAY_METHOD,
+  GET,
+  GETTERS,
+  DEFAULT_GETTERS,
+  regularBindings,
+  extremelyLateBindings,
+  isPublicCollectionSignal,
+  isPublicDocumentSignal,
+  isPublicCollection,
+  isPrivateCollection
+} from './SignalBase.ts'
+
+export { SignalCompat }
+
+const DefaultSignal = (isCompatEnv() ? SignalCompat : Signal) as unknown as SignalConstructor
+
+export default DefaultSignal
diff --git a/packages/teamplay/orm/SignalBase.js b/packages/teamplay/orm/SignalBase.js
deleted file mode 100644
index 7c70d1e..0000000
--- a/packages/teamplay/orm/SignalBase.js
+++ /dev/null
@@ -1,696 +0,0 @@
-/**
- * Implementation of the BaseSignal class which is used as a base class for all signals
- * and can be extended to create custom models for a particular path pattern of the data tree.
- *
- * All signals in the app should be created using getSignal() function which automatically
- * determines the correct model for the given path pattern and wraps the signal object in a Proxy.
- *
- * Proxy is used for the following reasons:
- * 1. To allow accessing child signals using dot syntax
- * 2. To be able to call the top-level signal as a `$()` function
- * 3. If extremely late bindings are enabled, to prevent name collisions when accessing fields
- *    in the raw data tree which have the same name as signal's methods
- */
-import uuid from '@teamplay/utils/uuid'
-import {
-  get as _get,
-  setPublicDoc as _setPublicDoc,
-  dataTreeRaw,
-  getRaw,
-  getLogicalRootSnapshot,
-  incrementPublic as _incrementPublic,
-  arrayPushPublic as _arrayPushPublic,
-  arrayUnshiftPublic as _arrayUnshiftPublic,
-  arrayInsertPublic as _arrayInsertPublic,
-  arrayPopPublic as _arrayPopPublic,
-  arrayShiftPublic as _arrayShiftPublic,
-  arrayRemovePublic as _arrayRemovePublic,
-  arrayMovePublic as _arrayMovePublic,
-  stringInsertPublic as _stringInsertPublic,
-  stringRemovePublic as _stringRemovePublic
-} from './dataTree.js'
-import getSignal, { rawSignal } from './getSignal.js'
-import { docSubscriptions } from './Doc.js'
-import { IS_QUERY, HASH, QUERIES } from './Query.js'
-import { AGGREGATIONS, IS_AGGREGATION, getAggregationCollectionName, getAggregationDocId } from './Aggregation.js'
-import { ROOT_FUNCTION, ROOT_ID, getRoot } from './Root.js'
-import { isPrivateMutationForbidden } from './connection.js'
-import {
-  DEFAULT_ID_FIELDS,
-  getIdFieldsForSegments,
-  isIdFieldPath,
-  isPublicDocPath,
-  normalizeIdFields,
-  prepareAddPayload,
-  resolveAddDocId
-} from './idFields.js'
-import { isCompatEnv } from './compatEnv.js'
-import { resolveRefSegmentsSafe, resolveRefSignalSafe } from './Compat/refFallback.js'
-import { compatStartOnRoot, compatStopOnRoot, joinScopePath } from './Compat/startStopCompat.js'
-import { runInBatch } from './batchScheduler.js'
-import { isPrivateCollectionSegments } from './rootScope.js'
-import {
-  arrayInsertPrivateData,
-  arrayMovePrivateData,
-  arrayPopPrivateData,
-  arrayPushPrivateData,
-  arrayRemovePrivateData,
-  arrayShiftPrivateData,
-  arrayUnshiftPrivateData,
-  delPrivateData,
-  getPrivateData,
-  setPrivateData,
-  setReplacePrivateData,
-  stringInsertPrivateData,
-  stringRemovePrivateData
-} from './privateData.js'
-
-export const SEGMENTS = Symbol('path segments targeting the particular node in the data tree')
-export const ARRAY_METHOD = Symbol('run array method on the signal')
-export const GET = Symbol('get the value of the signal - either observed or raw')
-export const GETTERS = Symbol('get the list of this signal\'s getters')
-export const DEFAULT_GETTERS = ['path', 'id', 'get', 'peek', 'getId', 'map', 'reduce', 'find', 'getIds', 'getExtra', 'getCollection']
-
-export class Signal extends Function {
-  static ID_FIELDS = DEFAULT_ID_FIELDS
-  static [GETTERS] = DEFAULT_GETTERS
-  static associations = []
-
-  static addAssociation (association) {
-    if (!association || typeof association !== 'object') {
-      throw Error('Signal.addAssociation() expects an association object')
-    }
-    const inherited = this.associations || []
-    const own = Object.prototype.hasOwnProperty.call(this, 'associations')
-      ? this.associations
-      : inherited.slice()
-    this.associations = own.concat(association)
-  }
-
-  constructor (segments) {
-    if (!Array.isArray(segments)) throw Error('Signal constructor expects an array of segments')
-    super()
-    this[SEGMENTS] = segments
-  }
-
-  path () {
-    if (arguments.length > 0) throw Error('Signal.path() does not accept any arguments')
-    return this[SEGMENTS].join('.')
-  }
-
-  leaf () {
-    if (arguments.length > 0) throw Error('Signal.leaf() does not accept any arguments')
-    const segments = this[SEGMENTS]
-    if (segments.length === 0) return ''
-    return String(segments[segments.length - 1])
-  }
-
-  parent (levels = 1) {
-    if (arguments.length > 1) throw Error('Signal.parent() expects a single argument')
-    if (arguments.length === 0) levels = 1
-    if (typeof levels !== 'number' || !Number.isFinite(levels) || !Number.isInteger(levels)) {
-      throw Error('Signal.parent() expects an integer argument')
-    }
-    if (levels < 1) throw Error('Signal.parent() expects a positive integer')
-    const $root = getRoot(this) || this
-    const segments = this[SEGMENTS]
-    if (segments.length === 0) return $root
-    const targetLength = Math.max(0, segments.length - levels)
-    if (targetLength === 0) return $root
-    let $cursor = $root
-    for (let i = 0; i < targetLength; i++) {
-      $cursor = $cursor[segments[i]]
-    }
-    return $cursor
-  }
-
-  id () {
-    return uuid()
-  }
-
-  batch (fn) {
-    if (arguments.length > 1) throw Error('Signal.batch() expects a single argument')
-    if (fn == null) return
-    if (typeof fn !== 'function') throw Error('Signal.batch() expects a function argument')
-    return runInBatch(fn)
-  }
-
-  [GET] (method) {
-    if (arguments.length > 1) throw Error('Signal[GET]() only accepts method as an argument')
-    if (this[SEGMENTS].length === 0) {
-      const $root = getRoot(this) || this
-      return getLogicalRootSnapshot($root?.[ROOT_ID], method === getRaw ? dataTreeRaw : undefined)
-    }
-    if (this[IS_QUERY]) {
-      const $root = getRoot(this) || this
-      return getPrivateData($root?.[ROOT_ID], [QUERIES, this[HASH], 'docs'], method === getRaw)
-    }
-    if (isPrivateSignalSegments(this[SEGMENTS])) {
-      const $root = getRoot(this) || this
-      return getPrivateData($root?.[ROOT_ID], this[SEGMENTS], method === getRaw)
-    }
-    return method(getStorageSegmentsForSignal(this))
-  }
-
-  get () {
-    if (arguments.length > 0) throw Error('Signal.get() does not accept any arguments')
-    if (this[SEGMENTS].length === 3 && this[SEGMENTS][0] === QUERIES && this[SEGMENTS][2] === 'ids') {
-      // TODO: This should never happen, but in reality it happens sometimes
-      // Patch getting query ids because sometimes for some reason we are not getting them
-      const ids = this[GET](_get)
-      if (!Array.isArray(ids)) {
-        console.warn('Signal.get() on Query didn\'t find ids', this[SEGMENTS])
-        return []
-      }
-      return ids
-    }
-    if (this[SEGMENTS].length === 3 && this[SEGMENTS][0] === QUERIES && this[SEGMENTS][2] === 'extra') {
-      return this[GET](_get)
-    }
-    return this[GET](_get)
-  }
-
-  getIds () {
-    if (arguments.length > 0) throw Error('Signal.getIds() does not accept any arguments')
-    if (this[IS_QUERY]) {
-      const $root = getRoot(this) || this
-      const ids = getPrivateData($root?.[ROOT_ID], [QUERIES, this[HASH], 'ids'])
-      if (!Array.isArray(ids)) {
-        // TODO: This should never happen, but in reality it happens sometimes
-        console.warn('Signal.getIds() on Query didn\'t find ids', [QUERIES, this[HASH], 'ids'])
-        return []
-      }
-      return ids
-    } else if (this[IS_AGGREGATION]) {
-      const $root = getRoot(this) || this
-      const docs = getPrivateData($root?.[ROOT_ID], this[SEGMENTS])
-      if (!Array.isArray(docs)) return []
-      return docs.map(doc => doc._id || doc.id)
-    } else {
-      // TODO: this should throw an error in the future
-      console.error(
-        'Signal.getIds() can only be used on query signals or aggregation signals. ' +
-        'Received a regular signal: ' + JSON.stringify(this[SEGMENTS])
-      )
-      return []
-    }
-  }
-
-  peek () {
-    if (arguments.length > 0) throw Error('Signal.peek() does not accept any arguments')
-    return this[GET](getRaw)
-  }
-
-  getId () {
-    if (this[SEGMENTS].length === 0) throw Error('Can\'t get the id of the root signal')
-    if (this[SEGMENTS].length === 1) throw Error('Can\'t get the id of a collection')
-    if (this[SEGMENTS][0] === AGGREGATIONS && this[SEGMENTS].length === 3) {
-      // use get() instead of the default getRaw() to trigger observability on changes
-      // This is required since within aggregation array results docs can change their position
-      const $root = getRoot(this) || this
-      return getAggregationDocId(this[SEGMENTS], $root?.[ROOT_ID])
-    }
-    return this[SEGMENTS][this[SEGMENTS].length - 1]
-  }
-
-  getCollection () {
-    if (this[SEGMENTS].length === 0) throw Error('Can\'t get the collection of the root signal')
-    if (this[SEGMENTS][0] === AGGREGATIONS) {
-      return getAggregationCollectionName(this[SEGMENTS])
-    }
-    // Racer compatibility:
-    // prefer static model collection (when model is mounted on alternative paths,
-    // e.g. `_virtualFields.*` -> model with `static collection = 'fields'`).
-    const collectionFromModel = this.constructor?.collection
-    if (typeof collectionFromModel === 'string' && collectionFromModel) {
-      return collectionFromModel
-    }
-    return this[SEGMENTS][0]
-  }
-
-  getAssociations () {
-    const $raw = rawSignal(this) || this
-    return $raw.constructor.associations || []
-  }
-
-  * [Symbol.iterator] () {
-    if (this[IS_QUERY]) {
-      const $root = getRoot(this) || this
-      const ids = getPrivateData($root?.[ROOT_ID], [QUERIES, this[HASH], 'ids'])
-      if (!Array.isArray(ids)) {
-        // TODO: This should never happen, but in reality it happens sometimes
-        console.warn('Signal iterator on Query didn\'t find ids', [QUERIES, this[HASH], 'ids'])
-        return
-      }
-      for (const id of ids) yield getSignal(getRoot(this), [this[SEGMENTS][0], id])
-    } else {
-      const $root = getRoot(this) || this
-      const items = isPrivateSignalSegments(this[SEGMENTS])
-        ? getPrivateData($root?.[ROOT_ID], this[SEGMENTS])
-        : _get(getStorageSegmentsForSignal(this))
-      if (!Array.isArray(items)) return
-      for (let i = 0; i < items.length; i++) yield getSignal(getRoot(this), [...this[SEGMENTS], i])
-    }
-  }
-
-  [ARRAY_METHOD] (method, nonArrayReturnValue, ...args) {
-    if (this[IS_QUERY]) {
-      const collection = this[SEGMENTS][0]
-      const $root = getRoot(this) || this
-      const ids = getPrivateData($root?.[ROOT_ID], [QUERIES, this[HASH], 'ids'])
-      if (!Array.isArray(ids)) {
-        // TODO: This should never happen, but in reality it happens sometimes
-        console.warn('Signal array method on Query didn\'t find ids', [QUERIES, this[HASH], 'ids'], method)
-        return nonArrayReturnValue
-      }
-      return ids.map(
-        id => getSignal(getRoot(this), [collection, id])
-      )[method](...args)
-    }
-    const $root = getRoot(this) || this
-    const items = isPrivateSignalSegments(this[SEGMENTS])
-      ? getPrivateData($root?.[ROOT_ID], this[SEGMENTS])
-      : _get(getStorageSegmentsForSignal(this))
-    if (!Array.isArray(items)) return nonArrayReturnValue
-    return Array(items.length).fill().map(
-      (_, index) => getSignal(getRoot(this), [...this[SEGMENTS], index])
-    )[method](...args)
-  }
-
-  map (...args) {
-    return this[ARRAY_METHOD]('map', [], ...args)
-  }
-
-  reduce (...args) {
-    return this[ARRAY_METHOD]('reduce', undefined, ...args)
-  }
-
-  find (...args) {
-    return this[ARRAY_METHOD]('find', undefined, ...args)
-  }
-
-  async set (value) {
-    if (arguments.length > 1) throw Error('Signal.set() expects a single argument')
-    if (this[SEGMENTS].length === 0) throw Error('Can\'t set the root signal data')
-    const idFields = getIdFieldsForSegments(this[SEGMENTS])
-    if (isIdFieldPath(this[SEGMENTS], idFields)) return
-    if (isPublicDocPath(this[SEGMENTS])) {
-      value = normalizeIdFields(value, idFields, this[SEGMENTS][1])
-    }
-    if (isPublicCollection(this[SEGMENTS][0])) {
-      await _setPublicDoc(this[SEGMENTS], value)
-    } else {
-      if (isPrivateMutationForbidden()) throw Error(ERRORS.publicOnly)
-      setPrivateData(getOwningRootId(this), this[SEGMENTS], value)
-    }
-  }
-
-  async assign (value) {
-    if (arguments.length > 1) throw Error('Signal.assign() expects a single argument')
-    if (this[SEGMENTS].length === 0) throw Error('Can\'t assign to the root signal data')
-    if (!value) return
-    if (typeof value !== 'object') throw Error('Signal.assign() expects an object argument, got: ' + typeof value)
-    const promises = []
-    // use Object.keys() to avoid setting inherited properties
-    for (const key of Object.keys(value)) {
-      let promise
-      if (value[key] != null) {
-        promise = this[key].set(value[key])
-      } else {
-        promise = this[key].del()
-      }
-      promises.push(promise)
-    }
-    await Promise.all(promises)
-  }
-
-  async push (value) {
-    if (arguments.length > 1) throw Error('Signal.push() expects a single argument')
-    const segments = ensureArrayTarget(this)
-    const idFields = getIdFieldsForSegments(segments)
-    if (isIdFieldPath(segments, idFields)) return
-    if (isPublicCollection(segments[0])) return _arrayPushPublic(segments, value)
-    if (isPrivateMutationForbidden()) throw Error(ERRORS.publicOnly)
-    return arrayPushPrivateData(getOwningRootId(this), segments, value)
-  }
-
-  async pop () {
-    if (arguments.length > 0) throw Error('Signal.pop() does not accept any arguments')
-    const segments = ensureArrayTarget(this)
-    const idFields = getIdFieldsForSegments(segments)
-    if (isIdFieldPath(segments, idFields)) return
-    if (isPublicCollection(segments[0])) return _arrayPopPublic(segments)
-    if (isPrivateMutationForbidden()) throw Error(ERRORS.publicOnly)
-    return arrayPopPrivateData(getOwningRootId(this), segments)
-  }
-
-  async unshift (value) {
-    if (arguments.length > 1) throw Error('Signal.unshift() expects a single argument')
-    const segments = ensureArrayTarget(this)
-    const idFields = getIdFieldsForSegments(segments)
-    if (isIdFieldPath(segments, idFields)) return
-    if (isPublicCollection(segments[0])) return _arrayUnshiftPublic(segments, value)
-    if (isPrivateMutationForbidden()) throw Error(ERRORS.publicOnly)
-    return arrayUnshiftPrivateData(getOwningRootId(this), segments, value)
-  }
-
-  async shift () {
-    if (arguments.length > 0) throw Error('Signal.shift() does not accept any arguments')
-    const segments = ensureArrayTarget(this)
-    const idFields = getIdFieldsForSegments(segments)
-    if (isIdFieldPath(segments, idFields)) return
-    if (isPublicCollection(segments[0])) return _arrayShiftPublic(segments)
-    if (isPrivateMutationForbidden()) throw Error(ERRORS.publicOnly)
-    return arrayShiftPrivateData(getOwningRootId(this), segments)
-  }
-
-  async insert (index, values) {
-    if (arguments.length < 2) throw Error('Not enough arguments for insert')
-    if (arguments.length > 2) throw Error('Signal.insert() expects two arguments')
-    if (typeof index !== 'number' || !Number.isFinite(index)) {
-      throw Error('Signal.insert() expects a numeric index')
-    }
-    const segments = ensureArrayTarget(this)
-    const idFields = getIdFieldsForSegments(segments)
-    if (isIdFieldPath(segments, idFields)) return
-    if (isPublicCollection(segments[0])) return _arrayInsertPublic(segments, index, values)
-    if (isPrivateMutationForbidden()) throw Error(ERRORS.publicOnly)
-    return arrayInsertPrivateData(getOwningRootId(this), segments, index, values)
-  }
-
-  async remove (index, howMany = 1) {
-    if (arguments.length < 1) throw Error('Not enough arguments for remove')
-    if (arguments.length > 2) throw Error('Signal.remove() expects one or two arguments')
-    if (typeof index !== 'number' || !Number.isFinite(index)) {
-      throw Error('Signal.remove() expects a numeric index')
-    }
-    const segments = ensureArrayTarget(this)
-    const idFields = getIdFieldsForSegments(segments)
-    if (isIdFieldPath(segments, idFields)) return
-    if (isPublicCollection(segments[0])) return _arrayRemovePublic(segments, index, howMany)
-    if (isPrivateMutationForbidden()) throw Error(ERRORS.publicOnly)
-    return arrayRemovePrivateData(getOwningRootId(this), segments, index, howMany)
-  }
-
-  async move (from, to, howMany = 1) {
-    if (arguments.length < 2) throw Error('Not enough arguments for move')
-    if (arguments.length > 3) throw Error('Signal.move() expects two or three arguments')
-    if (typeof from !== 'number' || !Number.isFinite(from) || typeof to !== 'number' || !Number.isFinite(to)) {
-      throw Error('Signal.move() expects numeric from/to')
-    }
-    const segments = ensureArrayTarget(this)
-    const idFields = getIdFieldsForSegments(segments)
-    if (isIdFieldPath(segments, idFields)) return
-    if (isPublicCollection(segments[0])) return _arrayMovePublic(segments, from, to, howMany)
-    if (isPrivateMutationForbidden()) throw Error(ERRORS.publicOnly)
-    return arrayMovePrivateData(getOwningRootId(this), segments, from, to, howMany)
-  }
-
-  async stringInsert (index, text) {
-    if (arguments.length < 2) throw Error('Not enough arguments for stringInsert')
-    if (arguments.length > 2) throw Error('Signal.stringInsert() expects two arguments')
-    if (typeof index !== 'number' || !Number.isFinite(index)) {
-      throw Error('Signal.stringInsert() expects a numeric index')
-    }
-    const segments = ensureValueTarget(this)
-    const idFields = getIdFieldsForSegments(segments)
-    if (isIdFieldPath(segments, idFields)) return
-    if (isPublicCollection(segments[0])) return _stringInsertPublic(segments, index, text)
-    if (isPrivateMutationForbidden()) throw Error(ERRORS.publicOnly)
-    return stringInsertPrivateData(getOwningRootId(this), segments, index, text)
-  }
-
-  async stringRemove (index, howMany = 1) {
-    if (arguments.length < 2) throw Error('Not enough arguments for stringRemove')
-    if (arguments.length > 2) throw Error('Signal.stringRemove() expects two arguments')
-    if (typeof index !== 'number' || !Number.isFinite(index)) {
-      throw Error('Signal.stringRemove() expects a numeric index')
-    }
-    const segments = ensureValueTarget(this)
-    const idFields = getIdFieldsForSegments(segments)
-    if (isIdFieldPath(segments, idFields)) return
-    if (isPublicCollection(segments[0])) return _stringRemovePublic(segments, index, howMany)
-    if (isPrivateMutationForbidden()) throw Error(ERRORS.publicOnly)
-    return stringRemovePrivateData(getOwningRootId(this), segments, index, howMany)
-  }
-
-  async increment (value) {
-    if (arguments.length > 1) throw Error('Signal.increment() expects a single argument')
-    if (value === undefined) value = 1
-    if (typeof value !== 'number') throw Error('Signal.increment() expects a number argument')
-    let currentValue = this.get()
-    if (currentValue === undefined) currentValue = 0
-    if (typeof currentValue !== 'number') throw Error('Signal.increment() tried to increment a non-number value')
-    const segments = this[SEGMENTS]
-    if (segments.length === 0) throw Error('Can\'t increment the root signal data')
-    const idFields = getIdFieldsForSegments(segments)
-    if (isIdFieldPath(segments, idFields)) return currentValue
-    if (isPublicCollection(segments[0])) {
-      await _incrementPublic(segments, value)
-      return currentValue + value
-    }
-    if (isPrivateMutationForbidden()) throw Error(ERRORS.publicOnly)
-    setReplacePrivateData(getOwningRootId(this), segments, currentValue + value)
-    return currentValue + value
-  }
-
-  async add (value) {
-    if (arguments.length > 1) throw Error('Signal.add() expects a single argument')
-    const id = resolveAddDocId(value, uuid)
-    const idFields = getIdFieldsForSegments([this[SEGMENTS][0], id])
-    await this[id].set(prepareAddPayload(value, idFields, id))
-    return id
-  }
-
-  async del () {
-    if (arguments.length > 0) throw Error('Signal.del() does not accept any arguments')
-    if (this[SEGMENTS].length === 0) throw Error('Can\'t delete the root signal data')
-    const idFields = getIdFieldsForSegments(this[SEGMENTS])
-    if (isIdFieldPath(this[SEGMENTS], idFields)) return
-    if (isPublicCollection(this[SEGMENTS][0])) {
-      if (this[SEGMENTS].length === 1) throw Error('Can\'t delete the whole collection')
-      await _setPublicDoc(this[SEGMENTS], undefined, true)
-    } else {
-      if (isPrivateMutationForbidden()) throw Error(ERRORS.publicOnly)
-      delPrivateData(getOwningRootId(this), this[SEGMENTS])
-    }
-  }
-
-  // clone () {}
-  // async assign () {}
-  // async splice () {}
-}
-
-function ensureArrayTarget ($signal) {
-  if ($signal[SEGMENTS].length < 2) throw Error('Can\'t mutate array on a collection or root signal')
-  if ($signal[IS_QUERY]) throw Error('Array mutators can\'t be used on a query signal')
-  return $signal[SEGMENTS]
-}
-
-function ensureValueTarget ($signal) {
-  if ($signal[SEGMENTS].length < 2) throw Error('Can\'t mutate on a collection or root signal')
-  if ($signal[IS_QUERY]) throw Error('Mutators can\'t be used on a query signal')
-  return $signal[SEGMENTS]
-}
-
-function getStorageSegmentsForSignal ($signal, segments = $signal[SEGMENTS]) {
-  return segments
-}
-
-function getOwningRootId ($signal) {
-  const $root = getRoot($signal) || $signal
-  return $root?.[ROOT_ID]
-}
-
-function isPrivateSignalSegments (segments) {
-  return isPrivateCollectionSegments(segments)
-}
-
-// dot syntax returns a child signal only if no such method or property exists
-export const regularBindings = {
-  apply (signal, thisArg, argumentsList) {
-    if (signal[SEGMENTS].length === 0) {
-      if (!signal[ROOT_FUNCTION]) throw Error(ERRORS.noRootFunction)
-      return signal[ROOT_FUNCTION].call(thisArg, signal, ...argumentsList)
-    }
-    throw Error('Signal can\'t be called as a function since extremely late bindings are disabled')
-  },
-  get (signal, key, receiver) {
-    if (key in signal) return Reflect.get(signal, key, receiver)
-    return Reflect.apply(extremelyLateBindings.get, this, arguments)
-  }
-}
-
-const QUERY_METHODS = ['map', 'reduce', 'find', 'get', 'getIds', 'getExtra', 'subscribe', 'unsubscribe', 'fetch', 'unfetch']
-const AGGREGATION_ALLOWED_METHODS = ['subscribe', 'unsubscribe', 'fetch', 'unfetch', 'ref', 'removeRef', 'refExtra', 'refIds']
-
-// dot syntax always returns a child signal even if such method or property exists.
-// The method is only called when the signal is explicitly called as a function,
-// in which case we get the original method from the raw (non-proxied) parent signal
-export const extremelyLateBindings = {
-  apply (signal, thisArg, argumentsList) {
-    if (signal[SEGMENTS].length === 0) {
-      if (!signal[ROOT_FUNCTION]) throw Error(ERRORS.noRootFunction)
-      return signal[ROOT_FUNCTION].call(thisArg, signal, ...argumentsList)
-    }
-    const key = signal[SEGMENTS][signal[SEGMENTS].length - 1]
-    const segments = signal[SEGMENTS].slice(0, -1)
-    if (segments[0] === AGGREGATIONS) {
-      const aggregationDocId = getAggregationDocId(segments, getRoot(signal)?.[ROOT_ID])
-      if (aggregationDocId) {
-        if (segments.length === 3 && key === 'set') throw Error(ERRORS.setAggregationDoc(segments, key))
-        const collectionName = getAggregationCollectionName(segments)
-        const subDocSegments = segments.slice(3)
-        const $original = getSignal(getRoot(signal), [collectionName, aggregationDocId, ...subDocSegments])
-        const rawOriginal = rawSignal($original)
-        if (!(key in rawOriginal)) throw Error(ERRORS.noSignalKey($original, key))
-        const fn = rawOriginal[key]
-        const getters = rawOriginal.constructor[GETTERS]
-        // for getters run the method on the aggregation data itself
-        if (getters.includes(key)) {
-          const $parent = getSignal(getRoot(signal), segments)
-          return Reflect.apply(fn, $parent, argumentsList)
-        // for async methods (setters) subscribe to the original doc and run the method on its relative signal
-        } else {
-          const $doc = getSignal(getRoot(signal), [collectionName, aggregationDocId])
-          const promise = docSubscriptions.subscribe($doc)
-          if (!promise) return Reflect.apply(fn, $original, argumentsList)
-          return new Promise(resolve => {
-            promise.then(() => {
-              resolve(Reflect.apply(fn, $original, argumentsList))
-            })
-          })
-        }
-      } else if (!DEFAULT_GETTERS.includes(key) && !AGGREGATION_ALLOWED_METHODS.includes(key)) {
-        throw Error(ERRORS.aggregationSetter(segments, key))
-      }
-    }
-    const $parent = getSignal(getRoot(signal), segments)
-    const rawParent = rawSignal($parent)
-    if (key in rawParent) return Reflect.apply(rawParent[key], $parent, argumentsList)
-
-    if (isCompatEnv()) {
-      const $resolvedParent = resolveRefSignalSafe($parent)
-      if ($resolvedParent && $resolvedParent !== $parent) {
-        const rawResolvedParent = rawSignal($resolvedParent)
-        if (rawResolvedParent && key in rawResolvedParent) {
-          return Reflect.apply(rawResolvedParent[key], $resolvedParent, argumentsList)
-        }
-      } else {
-        const resolvedSegments = resolveRefSegmentsSafe(
-          segments,
-          (getRoot(signal) || signal)?.[ROOT_ID]
-        )
-        if (resolvedSegments) {
-          const $resolvedByPath = getSignal(getRoot(signal), resolvedSegments)
-          const rawResolvedByPath = rawSignal($resolvedByPath)
-          if (rawResolvedByPath && key in rawResolvedByPath) {
-            return Reflect.apply(rawResolvedByPath[key], $resolvedByPath, argumentsList)
-          }
-        }
-      }
-
-      if (key === 'start') {
-        const [relativePath, ...depsAndGetter] = argumentsList
-        if (typeof relativePath !== 'string') throw Error('Signal.start() expects targetPath to be a string')
-        const absolutePath = joinScopePath($parent.path(), relativePath)
-        return compatStartOnRoot(getRoot($parent) || $parent, absolutePath, ...depsAndGetter)
-      }
-      if (key === 'stop') {
-        if (argumentsList.length > 1) throw Error('Signal.stop() expects zero or one argument')
-        const relativePath = argumentsList.length === 0 ? '' : argumentsList[0]
-        if (relativePath != null && typeof relativePath !== 'string') {
-          throw Error('Signal.stop() expects targetPath to be a string')
-        }
-        const absolutePath = joinScopePath($parent.path(), relativePath || '')
-        return compatStopOnRoot(getRoot($parent) || $parent, absolutePath)
-      }
-    }
-
-    throw Error(ERRORS.noSignalKey($parent, key))
-  },
-  get (signal, key, receiver) {
-    if (typeof key === 'symbol') return Reflect.get(signal, key, receiver)
-    if (key === 'then') return undefined // handle checks for whether the symbol is a Promise
-    if (key === 'constructor') return signal.constructor
-    key = transformAlias(signal[SEGMENTS], key)
-    key = maybeTransformToArrayIndex(key)
-    if (signal[IS_QUERY]) {
-      if (key === 'ids') return getSignal(getRoot(signal), [QUERIES, signal[HASH], 'ids'])
-      if (key === 'extra') return getSignal(getRoot(signal), [QUERIES, signal[HASH], 'extra'])
-      if (QUERY_METHODS.includes(key)) return Reflect.get(signal, key, receiver)
-    }
-    return getSignal(getRoot(signal), [...signal[SEGMENTS], key])
-  }
-}
-
-const REGEX_POSITIVE_INTEGER = /^(?:0|[1-9]\d*)$/
-// Transform the key to a number if it's a positive integer.
-// Otherwise the key must be a string.
-function maybeTransformToArrayIndex (key) {
-  if (typeof key === 'string' && REGEX_POSITIVE_INTEGER.test(key)) return +key
-  return key
-}
-
-const transformAlias = (({
-  collectionsMapping = {
-    session: '_session',
-    page: '_page',
-    render: '$render',
-    system: '$system'
-  },
-  regex$ = /^\$/
-} = {}) => (segments, key) => {
-  if (regex$.test(key)) key = key.slice(1)
-  if (segments.length === 0) key = collectionsMapping[key] || key
-  return key
-})()
-
-export function isPublicCollectionSignal ($signal) {
-  return $signal instanceof Signal && $signal[SEGMENTS].length === 1 && isPublicCollection($signal[SEGMENTS][0])
-}
-
-export function isPublicDocumentSignal ($signal) {
-  return $signal instanceof Signal && $signal[SEGMENTS].length === 2 && isPublicCollection($signal[SEGMENTS][0])
-}
-
-export function isPublicCollection (collectionName) {
-  if (!collectionName) return false
-  return !isPrivateCollection(collectionName)
-}
-
-export function isPrivateCollection (collectionName) {
-  if (!collectionName) return false
-  return /^[_$]/.test(collectionName)
-}
-
-const ERRORS = {
-  noRootFunction: `
-    Root signal does not have a root function set.
-    You must use getRootSignal({ rootId, rootFunction }) to create a root signal.
-  `,
-  publicOnly: `
-    Can't modify private collections data when 'publicOnly' is enabled.
-    On the server you can only work with public collections.
-  `,
-  noSignalKey: ($signal, key) => `Method "${key}" does not exist on signal "${$signal[SEGMENTS].join('.')}"`,
-  aggregationSetter: (segments, key) => `
-    You can not use setters on aggregation signals.
-    It's only allowed when the aggregation result is an array of documents
-    with either '_id' or 'id' field present in them.
-
-    Path: ${segments}
-    Method: ${key}
-  `,
-  setAggregationDoc: (segments, key) => `
-    Changing a whole document using .set() from an aggregation signal is prohibited.
-    This is to prevent accidental overwriting of the whole document with incorrect aggregation results.
-    You can only change the particular fields within the document using the aggregation signal.
-
-    If you want to change the whole document, use the actual document signal explicitly
-    (and make sure to subscribe to it).
-
-    Path: ${segments}
-    Method: ${key}
-  `
-}
diff --git a/packages/teamplay/orm/SignalBase.ts b/packages/teamplay/orm/SignalBase.ts
new file mode 100644
index 0000000..5a7342d
--- /dev/null
+++ b/packages/teamplay/orm/SignalBase.ts
@@ -0,0 +1,725 @@
+// @ts-nocheck
+/**
+ * Implementation of the BaseSignal class which is used as a base class for all signals
+ * and can be extended to create custom models for a particular path pattern of the data tree.
+ *
+ * All signals in the app should be created using getSignal() function which automatically
+ * determines the correct model for the given path pattern and wraps the signal object in a Proxy.
+ *
+ * Proxy is used for the following reasons:
+ * 1. To allow accessing child signals using dot syntax
+ * 2. To be able to call the top-level signal as a `$()` function
+ * 3. If extremely late bindings are enabled, to prevent name collisions when accessing fields
+ *    in the raw data tree which have the same name as signal's methods
+ */
+import uuid from '@teamplay/utils/uuid'
+import {
+  get as _get,
+  setPublicDoc as _setPublicDoc,
+  dataTreeRaw,
+  getRaw,
+  getLogicalRootSnapshot,
+  incrementPublic as _incrementPublic,
+  arrayPushPublic as _arrayPushPublic,
+  arrayUnshiftPublic as _arrayUnshiftPublic,
+  arrayInsertPublic as _arrayInsertPublic,
+  arrayPopPublic as _arrayPopPublic,
+  arrayShiftPublic as _arrayShiftPublic,
+  arrayRemovePublic as _arrayRemovePublic,
+  arrayMovePublic as _arrayMovePublic,
+  stringInsertPublic as _stringInsertPublic,
+  stringRemovePublic as _stringRemovePublic
+} from './dataTree.js'
+import getSignal, { rawSignal } from './getSignal.ts'
+import { docSubscriptions } from './Doc.js'
+import { IS_QUERY, HASH, QUERIES } from './Query.js'
+import { AGGREGATIONS, getAggregationCollectionName, getAggregationDocId } from './Aggregation.js'
+import { ROOT_FUNCTION, ROOT_ID, getRoot } from './Root.ts'
+import { isPrivateMutationForbidden } from './connection.ts'
+import {
+  DEFAULT_ID_FIELDS,
+  getIdFieldsForSegments,
+  prepareAddPayload,
+  resolveAddDocId
+} from './idFields.ts'
+import { isCompatEnv } from './compatEnv.js'
+import { resolveRefSegmentsSafe, resolveRefSignalSafe } from './Compat/refFallback.js'
+import { compatStartOnRoot, compatStopOnRoot, joinScopePath } from './Compat/startStopCompat.js'
+import { runInBatch } from './batchScheduler.js'
+import { isPublicCollection } from './signalPathKind.ts'
+import {
+  ARRAY_METHOD,
+  DEFAULT_GETTERS,
+  GET,
+  GETTERS,
+  SEGMENTS
+} from './signalSymbols.ts'
+import { normalizeSignalPropertyKey } from './signalPathRules.ts'
+import {
+  ensureArraySignalTarget,
+  ensureValueSignalTarget,
+  getSignalOwningRootId,
+  getSignalStorageSegments,
+  isPrivateSignalSegments
+} from './signalRuntimeAccess.ts'
+import {
+  getSignalAssociations,
+  getSignalCollection,
+  getSignalId,
+  getSignalLeaf,
+  getSignalParentSegments,
+  getSignalPath
+} from './signalMetadata.ts'
+import {
+  iterateSignalArrayChildren,
+  runSignalArrayMethod
+} from './signalArrayReaders.ts'
+import {
+  getSignalIds,
+  getSignalValue,
+  readSignalValue
+} from './signalReads.ts'
+import { runSignalStorageMutation } from './signalStorageMutations.ts'
+import {
+  deleteSignalValue,
+  setSignalValue
+} from './signalValueMutations.ts'
+import {
+  arrayInsertPrivateData,
+  arrayMovePrivateData,
+  arrayPopPrivateData,
+  arrayPushPrivateData,
+  arrayRemovePrivateData,
+  arrayShiftPrivateData,
+  arrayUnshiftPrivateData,
+  delPrivateData,
+  getPrivateData,
+  setPrivateData,
+  setReplacePrivateData,
+  stringInsertPrivateData,
+  stringRemovePrivateData
+} from './privateData.js'
+
+export { SEGMENTS, ARRAY_METHOD, GET, GETTERS, DEFAULT_GETTERS }
+
+const SIGNAL_ARRAY_READER_CONTEXT = {
+  getRoot ($signal) {
+    return getRoot($signal)
+  },
+  readQueryIds ($signal) {
+    const $root = getRoot($signal) || $signal
+    return getPrivateData($root?.[ROOT_ID], [QUERIES, $signal[HASH], 'ids'])
+  },
+  readArrayValue ($signal) {
+    const $root = getRoot($signal) || $signal
+    return isPrivateSignalSegments($signal[SEGMENTS])
+      ? getPrivateData($root?.[ROOT_ID], $signal[SEGMENTS])
+      : _get(getSignalStorageSegments($signal))
+  },
+  createSignal: getSignal,
+  warn (message, ...args) {
+    console.warn(message, ...args)
+  }
+}
+
+const SIGNAL_READ_CONTEXT = {
+  getOwningRootId ($signal) {
+    const $root = getRoot($signal) || $signal
+    return $root?.[ROOT_ID]
+  },
+  getStorageSegments: getSignalStorageSegments,
+  isPrivateSegments: isPrivateSignalSegments,
+  readLogicalRootSnapshot (rootId, raw) {
+    return getLogicalRootSnapshot(rootId, raw ? dataTreeRaw : undefined)
+  },
+  readPrivateData (rootId, segments, raw) {
+    return getPrivateData(rootId, segments, raw)
+  },
+  readPublicData (segments, method) {
+    return method(segments)
+  },
+  warn (message, ...args) {
+    console.warn(message, ...args)
+  },
+  error (message) {
+    console.error(message)
+  }
+}
+
+const SIGNAL_VALUE_MUTATION_CONTEXT = {
+  getOwningRootId: getSignalOwningRootId,
+  isPublicCollection,
+  isPrivateMutationForbidden,
+  setPublicDoc: _setPublicDoc,
+  setPrivateData,
+  deletePublicDoc (segments) {
+    return _setPublicDoc(segments, undefined, true)
+  },
+  deletePrivateData: delPrivateData
+}
+
+export class Signal<TValue = unknown> extends Function {
+  /** Fields that are treated as document ids and mirror the document id segment. */
+  static ID_FIELDS = DEFAULT_ID_FIELDS
+  /** Method names that keep method binding priority over child signal dot access. */
+  static [GETTERS] = DEFAULT_GETTERS
+  /** Association metadata registered for this model class. */
+  static associations = []
+  /** Path segments from the root signal to this signal. */
+  readonly [SEGMENTS]: Array<string | number>
+
+  /**
+   * Add association metadata to this model class.
+   * @param association Association metadata object to register on the model class.
+   */
+  static addAssociation (association: object): void {
+    if (!association || typeof association !== 'object') {
+      throw Error('Signal.addAssociation() expects an association object')
+    }
+    const inherited = this.associations || []
+    const own = Object.prototype.hasOwnProperty.call(this, 'associations')
+      ? this.associations
+      : inherited.slice()
+    this.associations = own.concat(association)
+  }
+
+  /**
+   * Create a signal for the given root-relative path segments.
+   * @param segments Root-relative path segments this signal points to.
+   */
+  constructor (segments: Array<string | number>) {
+    if (!Array.isArray(segments)) throw Error('Signal constructor expects an array of segments')
+    super()
+    this[SEGMENTS] = segments
+  }
+
+  /** Return the dot-separated path of this signal from the root data tree. */
+  path (): string {
+    if (arguments.length > 0) throw Error('Signal.path() does not accept any arguments')
+    return getSignalPath(this)
+  }
+
+  /** Return the last segment of this signal path, or an empty string for the root signal. */
+  leaf (): string {
+    if (arguments.length > 0) throw Error('Signal.leaf() does not accept any arguments')
+    return getSignalLeaf(this)
+  }
+
+  /**
+   * Return the parent signal `levels` above this signal.
+   * @param levels Number of parent levels to walk upward. Defaults to `1`.
+   */
+  parent (levels = 1): Signal {
+    const targetSegments = getSignalParentSegments(this, levels, arguments.length)
+    const $root = getRoot(this) || this
+    if (targetSegments.length === 0) return $root
+    let $cursor = $root
+    for (const segment of targetSegments) {
+      $cursor = $cursor[segment]
+    }
+    return $cursor
+  }
+
+  /** Generate a new unique id suitable for a new document. */
+  id (): string {
+    return uuid()
+  }
+
+  /** Run multiple signal reads and writes in a single reactive batch. */
+  batch (): undefined
+  /**
+   * Run multiple signal reads and writes in a single reactive batch.
+   * @param fn Function to execute inside the batch.
+   */
+  batch<TResult>(fn: () => TResult): TResult
+  batch<TResult>(fn?: () => TResult): TResult | undefined {
+    if (arguments.length > 1) throw Error('Signal.batch() expects a single argument')
+    if (fn == null) return
+    if (typeof fn !== 'function') throw Error('Signal.batch() expects a function argument')
+    return runInBatch(fn)
+  }
+
+  /**
+   * Internal read hook used by `.get()` and `.peek()`.
+   * @param method Storage read function to use for the current signal path.
+   */
+  [GET] (method: (segments: Array<string | number>) => TValue): TValue {
+    if (arguments.length > 1) throw Error('Signal[GET]() only accepts method as an argument')
+    return readSignalValue(this, SIGNAL_READ_CONTEXT, method, getRaw)
+  }
+
+  /** Read the current value and track it for reactive rendering. */
+  get (): TValue {
+    if (arguments.length > 0) throw Error('Signal.get() does not accept any arguments')
+    return getSignalValue(this, SIGNAL_READ_CONTEXT, _get, getRaw)
+  }
+
+  /** Return document ids for a query or aggregation signal. */
+  getIds (): Array<string | number> {
+    if (arguments.length > 0) throw Error('Signal.getIds() does not accept any arguments')
+    return getSignalIds(this, SIGNAL_READ_CONTEXT)
+  }
+
+  /** Read the current value without tracking it for reactive rendering. */
+  peek (): TValue {
+    if (arguments.length > 0) throw Error('Signal.peek() does not accept any arguments')
+    return this[GET](getRaw)
+  }
+
+  /** Return the document id represented by this document signal. */
+  getId (): string | number {
+    const $root = getRoot(this) || this
+    return getSignalId(this, $root?.[ROOT_ID])
+  }
+
+  /** Return the public collection name this signal belongs to. */
+  getCollection (): string {
+    return getSignalCollection(this)
+  }
+
+  /** Return association metadata registered on this signal's model class. */
+  getAssociations (): readonly unknown[] {
+    const $raw = rawSignal(this) || this
+    return getSignalAssociations($raw)
+  }
+
+  /** Iterate child document signals for query signals, or item signals for array signals. */
+  * [Symbol.iterator] (): IterableIterator<Signal> {
+    yield * iterateSignalArrayChildren(this, SIGNAL_ARRAY_READER_CONTEXT, {
+      message: 'Signal iterator on Query didn\'t find ids'
+    })
+  }
+
+  /** Internal helper used to run array-style methods on query and array signals. */
+  [ARRAY_METHOD] (method: string, nonArrayReturnValue: unknown, ...args: unknown[]): unknown {
+    return runSignalArrayMethod(this, SIGNAL_ARRAY_READER_CONTEXT, method, nonArrayReturnValue, args, {
+      message: 'Signal array method on Query didn\'t find ids',
+      method
+    })
+  }
+
+  /**
+   * Run `Array.prototype.map()` over query document signals or array item signals.
+   * @param callback Function called for each child signal.
+   * @param thisArg Optional `this` value for the callback.
+   */
+  map<TResult>(callback: (value: Signal, index: number, array: Signal[]) => TResult, thisArg?: any): TResult[]
+  map<TResult>(...args): TResult[] {
+    return this[ARRAY_METHOD]('map', [], ...args)
+  }
+
+  /**
+   * Run `Array.prototype.reduce()` over query document signals or array item signals.
+   * @param callback Function called for each child signal and accumulated value.
+   */
+  reduce (callback: (previousValue: Signal, currentValue: Signal, currentIndex: number, array: Signal[]) => Signal): Signal
+  /**
+   * Run `Array.prototype.reduce()` over query document signals or array item signals.
+   * @param callback Function called for each child signal and accumulated value.
+   * @param initialValue Initial accumulator value.
+   */
+  reduce (callback: (previousValue: Signal, currentValue: Signal, currentIndex: number, array: Signal[]) => Signal, initialValue: Signal): Signal
+  /**
+   * Run `Array.prototype.reduce()` over query document signals or array item signals.
+   * @param callback Function called for each child signal and accumulated value.
+   * @param initialValue Initial accumulator value.
+   */
+  reduce<TResult>(
+    callback: (previousValue: TResult, currentValue: Signal, currentIndex: number, array: Signal[]) => TResult,
+    initialValue: TResult
+  ): TResult
+  reduce<TResult>(...args): TResult {
+    return this[ARRAY_METHOD]('reduce', undefined, ...args)
+  }
+
+  /**
+   * Find the first query document signal or array item signal matching a predicate.
+   * @param predicate Function called for each child signal.
+   * @param thisArg Optional `this` value for the predicate.
+   */
+  find (predicate: (value: Signal, index: number, obj: Signal[]) => unknown, thisArg?: any): Signal | undefined
+  find (...args): Signal | undefined {
+    return this[ARRAY_METHOD]('find', undefined, ...args)
+  }
+
+  /**
+   * Replace this signal's value. Database writes are async and sync through ShareDB.
+   * @param value New value to store at this signal path.
+   */
+  async set (value: TValue): Promise<void> {
+    if (arguments.length > 1) throw Error('Signal.set() expects a single argument')
+    await setSignalValue(this, SIGNAL_VALUE_MUTATION_CONTEXT, value)
+  }
+
+  /**
+   * Set multiple object fields at once. Fields set to `null` or `undefined` are deleted.
+   * @param value Object containing fields to set or delete.
+   */
+  async assign (value: NonNullable<TValue> extends object ? Partial<NonNullable<TValue>> : never): Promise<void> {
+    if (arguments.length > 1) throw Error('Signal.assign() expects a single argument')
+    if (this[SEGMENTS].length === 0) throw Error('Can\'t assign to the root signal data')
+    if (!value) return
+    if (typeof value !== 'object') throw Error('Signal.assign() expects an object argument, got: ' + typeof value)
+    const promises = []
+    // use Object.keys() to avoid setting inherited properties
+    for (const key of Object.keys(value)) {
+      let promise
+      if (value[key] != null) {
+        promise = this[key].set(value[key])
+      } else {
+        promise = this[key].del()
+      }
+      promises.push(promise)
+    }
+    await Promise.all(promises)
+  }
+
+  /**
+   * Append one item to an array signal.
+   * @param value Item to append.
+   */
+  async push (value: NonNullable<TValue> extends ReadonlyArray<infer Item> ? Item : unknown): Promise<unknown> {
+    if (arguments.length > 1) throw Error('Signal.push() expects a single argument')
+    const segments = ensureArraySignalTarget(this)
+    const result = await runSignalStorageMutation(this, SIGNAL_VALUE_MUTATION_CONTEXT, segments, {
+      public: segments => _arrayPushPublic(segments, value),
+      private: (rootId, segments) => arrayPushPrivateData(rootId, segments, value)
+    })
+    return result.value
+  }
+
+  /** Remove and return the last item from an array signal. */
+  async pop (): Promise<NonNullable<TValue> extends ReadonlyArray<infer Item> ? Item | undefined : unknown> {
+    if (arguments.length > 0) throw Error('Signal.pop() does not accept any arguments')
+    const segments = ensureArraySignalTarget(this)
+    const result = await runSignalStorageMutation(this, SIGNAL_VALUE_MUTATION_CONTEXT, segments, {
+      public: segments => _arrayPopPublic(segments),
+      private: (rootId, segments) => arrayPopPrivateData(rootId, segments)
+    })
+    return result.value
+  }
+
+  /**
+   * Insert one item at the beginning of an array signal.
+   * @param value Item to insert.
+   */
+  async unshift (value: NonNullable<TValue> extends ReadonlyArray<infer Item> ? Item : unknown): Promise<unknown> {
+    if (arguments.length > 1) throw Error('Signal.unshift() expects a single argument')
+    const segments = ensureArraySignalTarget(this)
+    const result = await runSignalStorageMutation(this, SIGNAL_VALUE_MUTATION_CONTEXT, segments, {
+      public: segments => _arrayUnshiftPublic(segments, value),
+      private: (rootId, segments) => arrayUnshiftPrivateData(rootId, segments, value)
+    })
+    return result.value
+  }
+
+  /** Remove and return the first item from an array signal. */
+  async shift (): Promise<NonNullable<TValue> extends ReadonlyArray<infer Item> ? Item | undefined : unknown> {
+    if (arguments.length > 0) throw Error('Signal.shift() does not accept any arguments')
+    const segments = ensureArraySignalTarget(this)
+    const result = await runSignalStorageMutation(this, SIGNAL_VALUE_MUTATION_CONTEXT, segments, {
+      public: segments => _arrayShiftPublic(segments),
+      private: (rootId, segments) => arrayShiftPrivateData(rootId, segments)
+    })
+    return result.value
+  }
+
+  /**
+   * Insert one or more items into an array signal at the given index.
+   * @param index Array index where the new item or items should be inserted.
+   * @param values Item or items to insert.
+   */
+  async insert (index: number, values: NonNullable<TValue> extends ReadonlyArray<infer Item> ? Item | Item[] : unknown): Promise<unknown> {
+    if (arguments.length < 2) throw Error('Not enough arguments for insert')
+    if (arguments.length > 2) throw Error('Signal.insert() expects two arguments')
+    if (typeof index !== 'number' || !Number.isFinite(index)) {
+      throw Error('Signal.insert() expects a numeric index')
+    }
+    const segments = ensureArraySignalTarget(this)
+    const result = await runSignalStorageMutation(this, SIGNAL_VALUE_MUTATION_CONTEXT, segments, {
+      public: segments => _arrayInsertPublic(segments, index, values),
+      private: (rootId, segments) => arrayInsertPrivateData(rootId, segments, index, values)
+    })
+    return result.value
+  }
+
+  /**
+   * Remove `howMany` items from an array signal starting at `index`.
+   * @param index Array index to start removing from.
+   * @param howMany Number of items to remove. Defaults to `1`.
+   */
+  async remove (index: number, howMany = 1): Promise<unknown> {
+    if (arguments.length < 1) throw Error('Not enough arguments for remove')
+    if (arguments.length > 2) throw Error('Signal.remove() expects one or two arguments')
+    if (typeof index !== 'number' || !Number.isFinite(index)) {
+      throw Error('Signal.remove() expects a numeric index')
+    }
+    const segments = ensureArraySignalTarget(this)
+    const result = await runSignalStorageMutation(this, SIGNAL_VALUE_MUTATION_CONTEXT, segments, {
+      public: segments => _arrayRemovePublic(segments, index, howMany),
+      private: (rootId, segments) => arrayRemovePrivateData(rootId, segments, index, howMany)
+    })
+    return result.value
+  }
+
+  /**
+   * Move `howMany` array items from one index to another.
+   * @param from Source array index.
+   * @param to Destination array index.
+   * @param howMany Number of items to move. Defaults to `1`.
+   */
+  async move (from: number, to: number, howMany = 1): Promise<unknown> {
+    if (arguments.length < 2) throw Error('Not enough arguments for move')
+    if (arguments.length > 3) throw Error('Signal.move() expects two or three arguments')
+    if (typeof from !== 'number' || !Number.isFinite(from) || typeof to !== 'number' || !Number.isFinite(to)) {
+      throw Error('Signal.move() expects numeric from/to')
+    }
+    const segments = ensureArraySignalTarget(this)
+    const result = await runSignalStorageMutation(this, SIGNAL_VALUE_MUTATION_CONTEXT, segments, {
+      public: segments => _arrayMovePublic(segments, from, to, howMany),
+      private: (rootId, segments) => arrayMovePrivateData(rootId, segments, from, to, howMany)
+    })
+    return result.value
+  }
+
+  /**
+   * Insert text into a string signal at the given character index.
+   * @param index Character index where text should be inserted.
+   * @param text Text to insert.
+   */
+  async stringInsert (index: number, text: string): Promise<unknown> {
+    if (arguments.length < 2) throw Error('Not enough arguments for stringInsert')
+    if (arguments.length > 2) throw Error('Signal.stringInsert() expects two arguments')
+    if (typeof index !== 'number' || !Number.isFinite(index)) {
+      throw Error('Signal.stringInsert() expects a numeric index')
+    }
+    const segments = ensureValueSignalTarget(this)
+    const result = await runSignalStorageMutation(this, SIGNAL_VALUE_MUTATION_CONTEXT, segments, {
+      public: segments => _stringInsertPublic(segments, index, text),
+      private: (rootId, segments) => stringInsertPrivateData(rootId, segments, index, text)
+    })
+    return result.value
+  }
+
+  /**
+   * Remove `howMany` characters from a string signal starting at `index`.
+   * @param index Character index to start removing from.
+   * @param howMany Number of characters to remove. Defaults to `1`.
+   */
+  async stringRemove (index: number, howMany = 1): Promise<unknown> {
+    if (arguments.length < 2) throw Error('Not enough arguments for stringRemove')
+    if (arguments.length > 2) throw Error('Signal.stringRemove() expects two arguments')
+    if (typeof index !== 'number' || !Number.isFinite(index)) {
+      throw Error('Signal.stringRemove() expects a numeric index')
+    }
+    const segments = ensureValueSignalTarget(this)
+    const result = await runSignalStorageMutation(this, SIGNAL_VALUE_MUTATION_CONTEXT, segments, {
+      public: segments => _stringRemovePublic(segments, index, howMany),
+      private: (rootId, segments) => stringRemovePrivateData(rootId, segments, index, howMany)
+    })
+    return result.value
+  }
+
+  /**
+   * Add `value` to a number signal and return the new number. Defaults to `1`.
+   * @param value Amount to add to the current number. Defaults to `1`.
+   */
+  async increment (value?: number): Promise<number> {
+    if (arguments.length > 1) throw Error('Signal.increment() expects a single argument')
+    if (value === undefined) value = 1
+    if (typeof value !== 'number') throw Error('Signal.increment() expects a number argument')
+    let currentValue = this.get()
+    if (currentValue === undefined) currentValue = 0
+    if (typeof currentValue !== 'number') throw Error('Signal.increment() tried to increment a non-number value')
+    const segments = this[SEGMENTS]
+    if (segments.length === 0) throw Error('Can\'t increment the root signal data')
+    const result = await runSignalStorageMutation(this, SIGNAL_VALUE_MUTATION_CONTEXT, segments, {
+      public: async segments => {
+        await _incrementPublic(segments, value)
+        return currentValue + value
+      },
+      private: (rootId, segments) => {
+        setReplacePrivateData(rootId, segments, currentValue + value)
+        return currentValue + value
+      }
+    })
+    if (result.skipped) return currentValue
+    return result.value
+  }
+
+  /**
+   * Add a document to a collection signal and return the new document id.
+   * @param value Document value to create. May include an explicit `id` field.
+   */
+  async add (value: unknown): Promise<string> {
+    if (arguments.length > 1) throw Error('Signal.add() expects a single argument')
+    const id = resolveAddDocId(value, uuid)
+    const idFields = getIdFieldsForSegments([this[SEGMENTS][0], id])
+    await this[id].set(prepareAddPayload(value, idFields, id))
+    return id
+  }
+
+  /** Delete this document or field. Whole collections and the root signal cannot be deleted. */
+  async del (): Promise<void> {
+    if (arguments.length > 0) throw Error('Signal.del() does not accept any arguments')
+    await deleteSignalValue(this, SIGNAL_VALUE_MUTATION_CONTEXT)
+  }
+
+  // clone () {}
+  // async assign () {}
+  // async splice () {}
+}
+
+// dot syntax returns a child signal only if no such method or property exists
+export const regularBindings = {
+  apply (signal, thisArg, argumentsList) {
+    if (signal[SEGMENTS].length === 0) {
+      if (!signal[ROOT_FUNCTION]) throw Error(ERRORS.noRootFunction)
+      return signal[ROOT_FUNCTION].call(thisArg, signal, ...argumentsList)
+    }
+    throw Error('Signal can\'t be called as a function since extremely late bindings are disabled')
+  },
+  get (signal, key, receiver) {
+    if (key in signal) return Reflect.get(signal, key, receiver)
+    return Reflect.apply(extremelyLateBindings.get, this, arguments)
+  }
+}
+
+const QUERY_METHODS = ['map', 'reduce', 'find', 'get', 'getIds', 'getExtra', 'subscribe', 'unsubscribe', 'fetch', 'unfetch']
+const AGGREGATION_ALLOWED_METHODS = ['subscribe', 'unsubscribe', 'fetch', 'unfetch', 'ref', 'removeRef', 'refExtra', 'refIds']
+
+// dot syntax always returns a child signal even if such method or property exists.
+// The method is only called when the signal is explicitly called as a function,
+// in which case we get the original method from the raw (non-proxied) parent signal
+export const extremelyLateBindings = {
+  apply (signal, thisArg, argumentsList) {
+    if (signal[SEGMENTS].length === 0) {
+      if (!signal[ROOT_FUNCTION]) throw Error(ERRORS.noRootFunction)
+      return signal[ROOT_FUNCTION].call(thisArg, signal, ...argumentsList)
+    }
+    const key = signal[SEGMENTS][signal[SEGMENTS].length - 1]
+    const segments = signal[SEGMENTS].slice(0, -1)
+    if (segments[0] === AGGREGATIONS) {
+      const aggregationDocId = getAggregationDocId(segments, getRoot(signal)?.[ROOT_ID])
+      if (aggregationDocId) {
+        if (segments.length === 3 && key === 'set') throw Error(ERRORS.setAggregationDoc(segments, key))
+        const collectionName = getAggregationCollectionName(segments)
+        const subDocSegments = segments.slice(3)
+        const $original = getSignal(getRoot(signal), [collectionName, aggregationDocId, ...subDocSegments])
+        const rawOriginal = rawSignal($original)
+        if (!(key in rawOriginal)) throw Error(ERRORS.noSignalKey($original, key))
+        const fn = rawOriginal[key]
+        const getters = rawOriginal.constructor[GETTERS]
+        // for getters run the method on the aggregation data itself
+        if (getters.includes(key)) {
+          const $parent = getSignal(getRoot(signal), segments)
+          return Reflect.apply(fn, $parent, argumentsList)
+        // for async methods (setters) subscribe to the original doc and run the method on its relative signal
+        } else {
+          const $doc = getSignal(getRoot(signal), [collectionName, aggregationDocId])
+          const promise = docSubscriptions.subscribe($doc)
+          if (!promise) return Reflect.apply(fn, $original, argumentsList)
+          return new Promise(resolve => {
+            promise.then(() => {
+              resolve(Reflect.apply(fn, $original, argumentsList))
+            })
+          })
+        }
+      } else if (!DEFAULT_GETTERS.includes(key) && !AGGREGATION_ALLOWED_METHODS.includes(key)) {
+        throw Error(ERRORS.aggregationSetter(segments, key))
+      }
+    }
+    const $parent = getSignal(getRoot(signal), segments)
+    const rawParent = rawSignal($parent)
+    if (key in rawParent) return Reflect.apply(rawParent[key], $parent, argumentsList)
+
+    if (isCompatEnv()) {
+      const $resolvedParent = resolveRefSignalSafe($parent)
+      if ($resolvedParent && $resolvedParent !== $parent) {
+        const rawResolvedParent = rawSignal($resolvedParent)
+        if (rawResolvedParent && key in rawResolvedParent) {
+          return Reflect.apply(rawResolvedParent[key], $resolvedParent, argumentsList)
+        }
+      } else {
+        const resolvedSegments = resolveRefSegmentsSafe(
+          segments,
+          (getRoot(signal) || signal)?.[ROOT_ID]
+        )
+        if (resolvedSegments) {
+          const $resolvedByPath = getSignal(getRoot(signal), resolvedSegments)
+          const rawResolvedByPath = rawSignal($resolvedByPath)
+          if (rawResolvedByPath && key in rawResolvedByPath) {
+            return Reflect.apply(rawResolvedByPath[key], $resolvedByPath, argumentsList)
+          }
+        }
+      }
+
+      if (key === 'start') {
+        const [relativePath, ...depsAndGetter] = argumentsList
+        if (typeof relativePath !== 'string') throw Error('Signal.start() expects targetPath to be a string')
+        const absolutePath = joinScopePath($parent.path(), relativePath)
+        return compatStartOnRoot(getRoot($parent) || $parent, absolutePath, ...depsAndGetter)
+      }
+      if (key === 'stop') {
+        if (argumentsList.length > 1) throw Error('Signal.stop() expects zero or one argument')
+        const relativePath = argumentsList.length === 0 ? '' : argumentsList[0]
+        if (relativePath != null && typeof relativePath !== 'string') {
+          throw Error('Signal.stop() expects targetPath to be a string')
+        }
+        const absolutePath = joinScopePath($parent.path(), relativePath || '')
+        return compatStopOnRoot(getRoot($parent) || $parent, absolutePath)
+      }
+    }
+
+    throw Error(ERRORS.noSignalKey($parent, key))
+  },
+  get (signal, key, receiver) {
+    if (typeof key === 'symbol') return Reflect.get(signal, key, receiver)
+    if (key === 'then') return undefined // handle checks for whether the symbol is a Promise
+    if (key === 'constructor') return signal.constructor
+    key = normalizeSignalPropertyKey(signal[SEGMENTS], key)
+    if (signal[IS_QUERY]) {
+      if (key === 'ids') return getSignal(getRoot(signal), [QUERIES, signal[HASH], 'ids'])
+      if (key === 'extra') return getSignal(getRoot(signal), [QUERIES, signal[HASH], 'extra'])
+      if (QUERY_METHODS.includes(key)) return Reflect.get(signal, key, receiver)
+    }
+    return getSignal(getRoot(signal), [...signal[SEGMENTS], key])
+  }
+}
+
+export function isPublicCollectionSignal ($signal) {
+  return $signal instanceof Signal && $signal[SEGMENTS].length === 1 && isPublicCollection($signal[SEGMENTS][0])
+}
+
+export function isPublicDocumentSignal ($signal) {
+  return $signal instanceof Signal && $signal[SEGMENTS].length === 2 && isPublicCollection($signal[SEGMENTS][0])
+}
+
+export { isPrivateCollection, isPublicCollection } from './signalPathKind.ts'
+
+const ERRORS = {
+  noRootFunction: `
+    Root signal does not have a root function set.
+    You must use getRootSignal({ rootId, rootFunction }) to create a root signal.
+  `,
+  noSignalKey: ($signal, key) => `Method "${key}" does not exist on signal "${$signal[SEGMENTS].join('.')}"`,
+  aggregationSetter: (segments, key) => `
+    You can not use setters on aggregation signals.
+    It's only allowed when the aggregation result is an array of documents
+    with either '_id' or 'id' field present in them.
+
+    Path: ${segments}
+    Method: ${key}
+  `,
+  setAggregationDoc: (segments, key) => `
+    Changing a whole document using .set() from an aggregation signal is prohibited.
+    This is to prevent accidental overwriting of the whole document with incorrect aggregation results.
+    You can only change the particular fields within the document using the aggregation signal.
+
+    If you want to change the whole document, use the actual document signal explicitly
+    (and make sure to subscribe to it).
+
+    Path: ${segments}
+    Method: ${key}
+  `
+}
diff --git a/packages/teamplay/orm/Value.js b/packages/teamplay/orm/Value.js
index 6520c75..09c6c93 100644
--- a/packages/teamplay/orm/Value.js
+++ b/packages/teamplay/orm/Value.js
@@ -1,7 +1,7 @@
-import { SEGMENTS } from './Signal.js'
-import { getRoot, ROOT_ID } from './Root.js'
+import { SEGMENTS } from './Signal.ts'
+import { getRoot, ROOT_ID } from './Root.ts'
 import { delPrivateData, setPrivateData } from './privateData.js'
-import FinalizationRegistry from '../utils/MockFinalizationRegistry.js'
+import FinalizationRegistry from '../utils/MockFinalizationRegistry.ts'
 
 export const LOCAL = '$local'
 
diff --git a/packages/teamplay/orm/addModel.js b/packages/teamplay/orm/addModel.ts
similarity index 50%
rename from packages/teamplay/orm/addModel.js
rename to packages/teamplay/orm/addModel.ts
index d892b82..1fa3c40 100644
--- a/packages/teamplay/orm/addModel.js
+++ b/packages/teamplay/orm/addModel.ts
@@ -1,18 +1,28 @@
-export const MODELS = {}
+import type { SignalClass } from './Signal.ts'
+import type { TeamplayModels } from '../index.ts'
+import type { PathSegment } from './types/path.ts'
 
-export default function addModel (pattern, Model) {
+export const MODELS: Record<string, SignalClass<any>> = {}
+
+export default function addModel<TPattern extends string> (
+  pattern: TPattern,
+  Model: TPattern extends keyof TeamplayModels ? TeamplayModels[TPattern] : SignalClass<any>
+): void {
   if (typeof pattern !== 'string') throw Error('Model pattern must be a string, e.g. "users.*"')
   if (/\s/.test(pattern)) throw Error('Model pattern can not have spaces')
   if (typeof Model !== 'function') throw Error('Model must be a class')
-  pattern = pattern.replace(/\[[^\]]+\]/g, '*') // replace `[id]` with `*`
-  if (pattern !== '' && pattern.split('.').some(segment => segment === '')) {
+  const normalizedPattern = pattern.replace(/\[[^\]]+\]/g, '*') // replace `[id]` with `*`
+  if (normalizedPattern !== '' && normalizedPattern.split('.').some(segment => segment === '')) {
     throw Error('Model pattern can not have empty segments')
   }
-  if (MODELS[pattern]) throw Error(`Model for pattern "${pattern}" already exists`)
-  MODELS[pattern] = Model
+  if (MODELS[normalizedPattern]) {
+    if (MODELS[normalizedPattern] === Model) return
+    throw Error(`Model for pattern "${normalizedPattern}" already exists`)
+  }
+  MODELS[normalizedPattern] = Model
 }
 
-export function findModel (segments) {
+export function findModel (segments: PathSegment[]): SignalClass<any> | undefined {
   // if segments is an empty array, treat it as a top-level signal.
   // Top-level signal class is the one that has an empty string as a pattern.
   if (segments.length === 0) segments = ['']
diff --git a/packages/teamplay/orm/associations.js b/packages/teamplay/orm/associations.js
deleted file mode 100644
index e2ba8be..0000000
--- a/packages/teamplay/orm/associations.js
+++ /dev/null
@@ -1,97 +0,0 @@
-import pluralize from 'pluralize'
-
-function getCollectionName (OrmEntity, options = {}, helperName = 'association') {
-  if (options.key) return undefined
-  const collection = OrmEntity?.collection
-  if (typeof collection === 'string' && collection) return collection
-  throw new Error(
-    `teamplay/${helperName}: Associated model must define static "collection" ` +
-    'or pass options.key explicitly'
-  )
-}
-
-function toSingular (name) {
-  if (typeof name !== 'string' || !name) return name
-  return pluralize.singular(name)
-}
-
-export function belongsTo (AssociatedOrmEntity, options = {}) {
-  return function decorateBelongsTo (OrmEntity) {
-    const key = options.key || (toSingular(
-      getCollectionName(AssociatedOrmEntity, options, 'belongsTo')
-    ) + 'Id')
-
-    OrmEntity.addAssociation(
-      Object.assign({
-        type: 'belongsTo',
-        orm: AssociatedOrmEntity,
-        key
-      }, options)
-    )
-
-    AssociatedOrmEntity.addAssociation(
-      Object.assign({
-        type: 'oppositeBelongsTo',
-        orm: OrmEntity,
-        key,
-        opposite: true
-      }, options)
-    )
-
-    return OrmEntity
-  }
-}
-
-export function hasMany (AssociatedOrmEntity, options = {}) {
-  return function decorateHasMany (OrmEntity) {
-    const key = options.key || (toSingular(
-      getCollectionName(AssociatedOrmEntity, options, 'hasMany')
-    ) + 'Ids')
-
-    OrmEntity.addAssociation(
-      Object.assign({
-        type: 'hasMany',
-        orm: AssociatedOrmEntity,
-        key
-      }, options)
-    )
-
-    AssociatedOrmEntity.addAssociation(
-      Object.assign({
-        type: 'oppositeHasMany',
-        orm: OrmEntity,
-        key,
-        opposite: true
-      }, options)
-    )
-
-    return OrmEntity
-  }
-}
-
-export function hasOne (AssociatedOrmEntity, options = {}) {
-  return function decorateHasOne (OrmEntity) {
-    const key = options.key || (toSingular(
-      getCollectionName(AssociatedOrmEntity, options, 'hasOne')
-    ) + 'Id')
-
-    OrmEntity.addAssociation(
-      Object.assign({
-        type: 'hasOne',
-        orm: AssociatedOrmEntity,
-        key
-      }, options)
-    )
-
-    AssociatedOrmEntity.addAssociation(
-      Object.assign({
-        type: 'oppositeHasOne',
-        orm: OrmEntity,
-        key,
-        opposite: true
-      }, options)
-    )
-
-    return OrmEntity
-  }
-}
diff --git a/packages/teamplay/orm/associations.ts b/packages/teamplay/orm/associations.ts
new file mode 100644
index 0000000..14c3f75
--- /dev/null
+++ b/packages/teamplay/orm/associations.ts
@@ -0,0 +1,150 @@
+/// <reference path="./pluralize.d.ts" />
+import pluralize from 'pluralize'
+
+export interface AssociationOptions extends Readonly<Record<string, unknown>> {
+  readonly key?: string
+}
+
+export interface AssociationModelConstructor {
+  readonly collection?: string
+  addAssociation: (association: AssociationRecord) => void
+}
+
+export interface AssociationRecord<
+  TAssociatedModel extends AssociationModelConstructor = AssociationModelConstructor
+> extends Record<string, unknown> {
+  readonly type: string
+  readonly orm: TAssociatedModel
+  readonly key: string
+  readonly opposite?: true
+}
+
+type AssociationDefaults<
+  TAssociatedModel extends AssociationModelConstructor
+> = AssociationRecord<TAssociatedModel>
+
+type AssociationDecorator = <TModel extends AssociationModelConstructor>(OrmEntity: TModel) => TModel
+
+function getCollectionName (
+  OrmEntity: AssociationModelConstructor,
+  options: AssociationOptions = {},
+  helperName = 'association'
+): string | undefined {
+  if (options.key) return undefined
+  const collection = OrmEntity?.collection
+  if (typeof collection === 'string' && collection) return collection
+  throw new Error(
+    `teamplay/${helperName}: Associated model must define static "collection" ` +
+    'or pass options.key explicitly'
+  )
+}
+
+function toSingular (name: string | undefined): string | undefined {
+  if (typeof name !== 'string' || !name) return name
+  return pluralize.singular(name)
+}
+
+function withOptions<
+  TAssociatedModel extends AssociationModelConstructor
+> (
+  defaults: AssociationDefaults<TAssociatedModel>,
+  options: AssociationOptions
+): AssociationRecord<TAssociatedModel> {
+  return Object.assign({}, defaults, options)
+}
+
+export function belongsTo<
+  TAssociatedModel extends AssociationModelConstructor
+> (
+  AssociatedOrmEntity: TAssociatedModel,
+  options: AssociationOptions = {}
+): AssociationDecorator {
+  return function decorateBelongsTo<TModel extends AssociationModelConstructor> (OrmEntity: TModel): TModel {
+    const key = options.key || (toSingular(
+      getCollectionName(AssociatedOrmEntity, options, 'belongsTo')
+    ) + 'Id')
+
+    OrmEntity.addAssociation(
+      withOptions({
+        type: 'belongsTo',
+        orm: AssociatedOrmEntity,
+        key
+      }, options)
+    )
+
+    AssociatedOrmEntity.addAssociation(
+      withOptions({
+        type: 'oppositeBelongsTo',
+        orm: OrmEntity,
+        key,
+        opposite: true
+      }, options)
+    )
+
+    return OrmEntity
+  }
+}
+
+export function hasMany<
+  TAssociatedModel extends AssociationModelConstructor
+> (
+  AssociatedOrmEntity: TAssociatedModel,
+  options: AssociationOptions = {}
+): AssociationDecorator {
+  return function decorateHasMany<TModel extends AssociationModelConstructor> (OrmEntity: TModel): TModel {
+    const key = options.key || (toSingular(
+      getCollectionName(AssociatedOrmEntity, options, 'hasMany')
+    ) + 'Ids')
+
+    OrmEntity.addAssociation(
+      withOptions({
+        type: 'hasMany',
+        orm: AssociatedOrmEntity,
+        key
+      }, options)
+    )
+
+    AssociatedOrmEntity.addAssociation(
+      withOptions({
+        type: 'oppositeHasMany',
+        orm: OrmEntity,
+        key,
+        opposite: true
+      }, options)
+    )
+
+    return OrmEntity
+  }
+}
+
+export function hasOne<
+  TAssociatedModel extends AssociationModelConstructor
+> (
+  AssociatedOrmEntity: TAssociatedModel,
+  options: AssociationOptions = {}
+): AssociationDecorator {
+  return function decorateHasOne<TModel extends AssociationModelConstructor> (OrmEntity: TModel): TModel {
+    const key = options.key || (toSingular(
+      getCollectionName(AssociatedOrmEntity, options, 'hasOne')
+    ) + 'Id')
+
+    OrmEntity.addAssociation(
+      withOptions({
+        type: 'hasOne',
+        orm: AssociatedOrmEntity,
+        key
+      }, options)
+    )
+
+    AssociatedOrmEntity.addAssociation(
+      withOptions({
+        type: 'oppositeHasOne',
+        orm: OrmEntity,
+        key,
+        opposite: true
+      }, options)
+    )
+
+    return OrmEntity
+  }
+}
diff --git a/packages/teamplay/orm/compatEnv.d.ts b/packages/teamplay/orm/compatEnv.d.ts
new file mode 100644
index 0000000..70127de
--- /dev/null
+++ b/packages/teamplay/orm/compatEnv.d.ts
@@ -0,0 +1 @@
+export function isCompatEnv (): boolean
diff --git a/packages/teamplay/orm/connection.js b/packages/teamplay/orm/connection.js
deleted file mode 100644
index 4611f26..0000000
--- a/packages/teamplay/orm/connection.js
+++ /dev/null
@@ -1,46 +0,0 @@
-import { isCompatEnv } from './compatEnv.js'
-
-export let connection
-let defaultFetchOnly
-export let publicOnly
-
-export function setConnection (_connection) {
-  connection = _connection
-}
-
-export function getConnection () {
-  if (!connection) throw Error(ERRORS.notSet)
-  return connection
-}
-
-export function setDefaultFetchOnly (_fetchOnly) {
-  defaultFetchOnly = !!_fetchOnly
-}
-
-export function getDefaultFetchOnly () {
-  return !!defaultFetchOnly
-}
-
-// Deprecated alias kept for internal transition.
-export function setFetchOnly (_fetchOnly) {
-  setDefaultFetchOnly(_fetchOnly)
-}
-
-export function setPublicOnly (_publicOnly) {
-  publicOnly = _publicOnly
-}
-
-export function isPrivateMutationForbidden () {
-  return !!publicOnly && !isCompatEnv()
-}
-
-const ERRORS = {
-  notSet: `
-    Connection is not set.
-    You must set the initialized ShareDB connection before using subscriptions.
-    You've probably forgotten to call connect() in your app:
-
-    import connect from 'teamplay/connect'
-    connect({ baseUrl: 'http://localhost:3000' })
-  `
-}
diff --git a/packages/teamplay/orm/connection.ts b/packages/teamplay/orm/connection.ts
new file mode 100644
index 0000000..e81c4f8
--- /dev/null
+++ b/packages/teamplay/orm/connection.ts
@@ -0,0 +1,65 @@
+import { isCompatEnv } from './compatEnv.js'
+
+export interface TeamplayShareDoc {
+  data?: unknown
+  fetch?: (callback?: (error?: unknown) => void) => void
+  subscribe?: (callback?: (error?: unknown) => void) => void
+  unsubscribe?: (callback?: (error?: unknown) => void) => void
+  destroy?: () => void
+  create?: (...args: unknown[]) => unknown
+  del?: (...args: unknown[]) => unknown
+  submitOp?: (...args: unknown[]) => unknown
+}
+
+export interface TeamplayConnection {
+  collections?: Record<string, Record<string, TeamplayShareDoc>>
+  get: (collection: string, docId: string) => TeamplayShareDoc
+  createFetchQuery?: (...args: unknown[]) => unknown
+  createSubscribeQuery?: (...args: unknown[]) => unknown
+  [key: string]: unknown
+}
+
+export let connection: TeamplayConnection | undefined
+let defaultFetchOnly: boolean | undefined
+export let publicOnly: boolean | undefined
+
+export function setConnection (_connection: TeamplayConnection | undefined): void {
+  connection = _connection
+}
+
+export function getConnection (): TeamplayConnection {
+  if (!connection) throw Error(ERRORS.notSet)
+  return connection
+}
+
+export function setDefaultFetchOnly (_fetchOnly: boolean): void {
+  defaultFetchOnly = !!_fetchOnly
+}
+
+export function getDefaultFetchOnly (): boolean {
+  return !!defaultFetchOnly
+}
+
+// Deprecated alias kept for internal transition.
+export function setFetchOnly (_fetchOnly: boolean): void {
+  setDefaultFetchOnly(_fetchOnly)
+}
+
+export function setPublicOnly (_publicOnly: boolean): void {
+  publicOnly = _publicOnly
+}
+
+export function isPrivateMutationForbidden (): boolean {
+  return !!publicOnly && !isCompatEnv()
+}
+
+const ERRORS = {
+  notSet: `
+    Connection is not set.
+    You must set the initialized ShareDB connection before using subscriptions.
+    You've probably forgotten to call connect() in your app:
+
+    import connect from 'teamplay/connect'
+    connect({ baseUrl: 'http://localhost:3000' })
+  `
+}
diff --git a/packages/teamplay/orm/dataTree.js b/packages/teamplay/orm/dataTree.js
index 55bff82..d9c3131 100644
--- a/packages/teamplay/orm/dataTree.js
+++ b/packages/teamplay/orm/dataTree.js
@@ -1,18 +1,18 @@
 import { observable, raw } from '@nx-js/observer-util'
 import jsonDiff from 'json0-ot-diff'
 import diffMatchPatch from 'diff-match-patch'
-import { getConnection } from './connection.js'
+import { getConnection } from './connection.ts'
 import setDiffDeep from '../utils/setDiffDeep.js'
-import { getIdFieldsForSegments, injectIdFields, stripIdFields, isPlainObject, isIdFieldPath } from './idFields.js'
+import { getIdFieldsForSegments, injectIdFields, stripIdFields, isPlainObject, isIdFieldPath } from './idFields.ts'
 import { emitModelChange, isModelEventsEnabled } from './Compat/modelEvents.js'
 import { isSilentContextActive } from './Compat/silentContext.js'
 import { isCompatEnv } from './compatEnv.js'
 import { isMissingShareDoc } from './missingDoc.js'
 import {
   getLogicalRootSnapshot as getLogicalRootSnapshotFromTree
-} from './rootScope.js'
-import { getRootContext } from './rootContext.js'
-export { isPrivateCollectionSegments } from './rootScope.js'
+} from './rootScope.ts'
+import { getRootContext } from './rootContext.ts'
+export { isPrivateCollectionSegments } from './rootScope.ts'
 
 const ALLOW_PARTIAL_DOC_CREATION = false
 
diff --git a/packages/teamplay/orm/disposeRootContext.js b/packages/teamplay/orm/disposeRootContext.ts
similarity index 74%
rename from packages/teamplay/orm/disposeRootContext.js
rename to packages/teamplay/orm/disposeRootContext.ts
index 2d72889..1a27294 100644
--- a/packages/teamplay/orm/disposeRootContext.js
+++ b/packages/teamplay/orm/disposeRootContext.ts
@@ -1,16 +1,19 @@
 import { aggregationSubscriptions } from './Aggregation.js'
 import { docSubscriptions } from './Doc.js'
-import { purgeSignalHashes } from './getSignal.js'
+import { purgeSignalHashes } from './getSignal.ts'
 import { querySubscriptions } from './Query.js'
 import {
   deleteRootContext,
   getRootContext
-} from './rootContext.js'
-import { isGlobalRootId, normalizeRootId } from './rootScope.js'
+} from './rootContext.ts'
+import { isGlobalRootId, normalizeRootId } from './rootScope.ts'
+import type RootContext from './rootContext.ts'
 
-const PENDING_DISPOSES = new Map()
+type RootId = string | null | undefined
 
-export default async function disposeRootContext (rootId) {
+const PENDING_DISPOSES = new Map<string, Promise<void>>()
+
+export default async function disposeRootContext (rootId: RootId): Promise<void> {
   const normalizedRootId = normalizeRootId(rootId)
   if (isGlobalRootId(normalizedRootId)) return
   const existing = PENDING_DISPOSES.get(normalizedRootId)
@@ -27,7 +30,7 @@ export default async function disposeRootContext (rootId) {
   }
 }
 
-async function runDispose (rootId) {
+async function runDispose (rootId: string): Promise<void> {
   const context = getRootContext(rootId, false)
   if (!context) return
 
@@ -52,7 +55,7 @@ async function runDispose (rootId) {
   deleteRootContext(rootId)
 }
 
-function stopActiveRefs (context) {
+function stopActiveRefs (context: RootContext): void {
   for (const entry of context.activeRefs.values()) {
     try {
       entry?.stop?.()
@@ -63,6 +66,6 @@ function stopActiveRefs (context) {
   context.resetActiveRefs()
 }
 
-export function __resetPendingRootDisposesForTests () {
+export function __resetPendingRootDisposesForTests (): void {
   PENDING_DISPOSES.clear()
 }
diff --git a/packages/teamplay/orm/getSignal.js b/packages/teamplay/orm/getSignal.ts
similarity index 65%
rename from packages/teamplay/orm/getSignal.js
rename to packages/teamplay/orm/getSignal.ts
index 666be52..3dac3ea 100644
--- a/packages/teamplay/orm/getSignal.js
+++ b/packages/teamplay/orm/getSignal.ts
@@ -1,30 +1,44 @@
-import Cache from './Cache.js'
-import Signal, { SEGMENTS, regularBindings, extremelyLateBindings, isPublicCollection, isPrivateCollection } from './Signal.js'
-import { findModel } from './addModel.js'
+import Cache from './Cache.ts'
+import Signal, { SEGMENTS, regularBindings, extremelyLateBindings, isPublicCollection, isPrivateCollection } from './Signal.ts'
+import { findModel } from './addModel.ts'
 import { LOCAL } from './$.js'
-import { ROOT, ROOT_ID, GLOBAL_ROOT_ID } from './Root.js'
+import { ROOT, ROOT_ID, GLOBAL_ROOT_ID } from './Root.ts'
 import { QUERIES } from './Query.js'
 import { AGGREGATIONS } from './Aggregation.js'
 import { isCompatEnv } from './compatEnv.js'
-import { getConnection } from './connection.js'
+import { getConnection } from './connection.ts'
 import { resolveRefSegmentsSafe } from './Compat/refFallback.js'
-import { getSignalIdentityHash } from './rootScope.js'
-import { isRootContextClosed, registerRootOwnedSignalHash } from './rootContext.js'
+import { getSignalIdentityHash } from './rootScope.ts'
+import { isRootContextClosed, registerRootOwnedSignalHash } from './rootContext.ts'
+import type { PathSegment } from './types/path.ts'
+import type { RootSignalRuntime } from './Root.ts'
+import type { SignalModelConstructor } from './Signal.ts'
 
-const PROXIES_CACHE = new Cache()
-const PROXY_TO_SIGNAL = new WeakMap()
+export interface GetSignalOptions {
+  useExtremelyLateBindings?: boolean
+  rootId?: string
+  signalHash?: string
+  proxyHandlers?: ProxyHandler<RootSignalRuntime>
+}
+
+interface ProxyHandlerOptions {
+  useExtremelyLateBindings?: boolean
+}
+
+const PROXIES_CACHE = new Cache<RootSignalRuntime>()
+const PROXY_TO_SIGNAL = new WeakMap<RootSignalRuntime, RootSignalRuntime>()
 
 // extremely late bindings let you use fields in your raw data which have the same name as signal's methods
 const USE_EXTREMELY_LATE_BINDINGS = true
 
 // get proxy-wrapped signal from cache or create a new one
 // TODO: move Private, Public, Local signals out of this file, same as Query has its own signal
-export default function getSignal ($root, segments = [], {
+export default function getSignal ($root?: RootSignalRuntime, segments: PathSegment[] = [], {
   useExtremelyLateBindings = USE_EXTREMELY_LATE_BINDINGS,
   rootId,
   signalHash,
   proxyHandlers = getDefaultProxyHandlers({ useExtremelyLateBindings })
-} = {}) {
+}: GetSignalOptions = {}): RootSignalRuntime {
   if (!($root instanceof Signal)) {
     if (segments.length === 0 && !rootId) throw Error(ERRORS.rootIdRequired)
     if (segments.length >= 1 && isPrivateCollection(segments[0])) {
@@ -45,7 +59,7 @@ export default function getSignal ($root, segments = [], {
   if (proxy) return proxy
 
   const SignalClass = getSignalClass(segments, $root?.[ROOT_ID] || rootId)
-  const signal = new SignalClass(segments)
+  const signal = new SignalClass(segments) as RootSignalRuntime
   proxy = new Proxy(signal, proxyHandlers)
   if (segments.length >= 1) {
     if (isPrivateCollection(segments[0])) {
@@ -63,7 +77,7 @@ export default function getSignal ($root, segments = [], {
   if (!rootClosed && owningRootId != null && owningRootId !== GLOBAL_ROOT_ID) {
     registerRootOwnedSignalHash(owningRootId, signalHash)
   }
-  const dependencies = []
+  const dependencies: RootSignalRuntime[] = []
 
   // if the signal is a child of the local value created through the $() function,
   // we need to add the parent signal ('$local.id') to the dependencies so that it doesn't get garbage collected
@@ -83,12 +97,16 @@ export default function getSignal ($root, segments = [], {
   return proxy
 }
 
-function getDefaultProxyHandlers ({ useExtremelyLateBindings } = {}) {
-  const baseHandlers = useExtremelyLateBindings ? extremelyLateBindings : regularBindings
+function getDefaultProxyHandlers ({
+  useExtremelyLateBindings
+}: ProxyHandlerOptions = {}): ProxyHandler<RootSignalRuntime> {
+  const baseHandlers = (
+    useExtremelyLateBindings ? extremelyLateBindings : regularBindings
+  ) as ProxyHandler<RootSignalRuntime>
   if (!isCompatEnv() || baseHandlers !== extremelyLateBindings) return baseHandlers
   return {
     ...baseHandlers,
-    get (signal, key, receiver) {
+    get (signal: RootSignalRuntime, key: string | symbol, receiver: unknown): unknown {
       if (key === 'connection' && signal[SEGMENTS].length === 0) {
         try {
           return getConnection()
@@ -97,34 +115,40 @@ function getDefaultProxyHandlers ({ useExtremelyLateBindings } = {}) {
         }
       }
       if (key === 'root') return Reflect.get(signal, key, receiver)
-      return baseHandlers.get(signal, key, receiver)
+      return baseHandlers.get
+        ? baseHandlers.get(signal, key, receiver)
+        : Reflect.get(signal, key, receiver)
     }
   }
 }
 
-export function getSignalClass (segments, rootId = GLOBAL_ROOT_ID) {
+export function getSignalClass (
+  segments: PathSegment[],
+  rootId = GLOBAL_ROOT_ID
+): SignalModelConstructor {
   let Model = findModel(segments)
   if (Model) return Model
-  if (!isCompatEnv()) return Signal
+  if (!isCompatEnv()) return Signal as unknown as SignalModelConstructor
   const dereferencedSegments = resolveRefSegmentsSafe(segments, rootId)
   if (dereferencedSegments) {
     Model = findModel(dereferencedSegments)
     if (Model) return Model
   }
-  return Signal
+  return Signal as unknown as SignalModelConstructor
 }
 
-export function rawSignal (proxy) {
-  return PROXY_TO_SIGNAL.get(proxy)
+export function rawSignal (proxy: unknown): RootSignalRuntime | undefined {
+  if (!proxy || (typeof proxy !== 'object' && typeof proxy !== 'function')) return undefined
+  return PROXY_TO_SIGNAL.get(proxy as RootSignalRuntime)
 }
 
 export { PROXIES_CACHE as __DEBUG_SIGNALS_CACHE__ }
-export function purgeSignalHashes (hashes) {
+export function purgeSignalHashes (hashes: Iterable<string>): void {
   for (const hash of hashes) PROXIES_CACHE.delete(hash)
 }
 
 const ERRORS = {
   rootIdRequired: 'Root signal must have a rootId specified',
-  privateCollectionRootIdRequired: segments => `Private collection signal must have a rootId specified. Segments: ${segments}`,
+  privateCollectionRootIdRequired: (segments: readonly PathSegment[]) => `Private collection signal must have a rootId specified. Segments: ${segments}`,
   rootSignalRequired: 'First argument of getSignal() for private collections must be a Root Signal'
 }
diff --git a/packages/teamplay/orm/idFields.js b/packages/teamplay/orm/idFields.js
deleted file mode 100644
index f1621bc..0000000
--- a/packages/teamplay/orm/idFields.js
+++ /dev/null
@@ -1,88 +0,0 @@
-import { findModel } from './addModel.js'
-
-export const DEFAULT_ID_FIELDS = ['_id']
-
-export function getIdFieldsForSegments (segments) {
-  const Model = findModel(segments)
-  return Model?.ID_FIELDS || DEFAULT_ID_FIELDS
-}
-
-export function isPlainObject (value) {
-  if (!value || typeof value !== 'object') return false
-  const proto = Object.getPrototypeOf(value)
-  return proto === Object.prototype || proto === null
-}
-
-export function injectIdFields (value, idFields, docId) {
-  if (!isPlainObject(value)) return value
-  for (const field of idFields) value[field] = docId
-  return value
-}
-
-export function normalizeIdFields (value, idFields, docId) {
-  if (!isPlainObject(value)) return value
-  let next = value
-  let changed = false
-  for (const field of idFields) {
-    if (!(field in next)) continue
-    if (next[field] === docId) continue
-    if (!changed) {
-      next = { ...next }
-      changed = true
-    }
-    next[field] = docId
-  }
-  return next
-}
-
-export function stripIdFields (value, idFields) {
-  if (!isPlainObject(value)) return value
-  let next = value
-  let changed = false
-  for (const field of idFields) {
-    if (!(field in next)) continue
-    if (!changed) {
-      next = { ...next }
-      changed = true
-    }
-    delete next[field]
-  }
-  return next
-}
-
-export function resolveAddDocId (value, getDefaultId) {
-  if (!value || typeof value !== 'object') throw Error('Signal.add() expects an object argument')
-  const hasId = value.id != null
-  const hasUnderscoreId = value._id != null
-  if (hasId && hasUnderscoreId && value.id !== value._id) {
-    throw Error(
-      `Signal.add() got conflicting "id" (${JSON.stringify(value.id)}) and "_id" (${JSON.stringify(value._id)})`
-    )
-  }
-  return value.id ?? value._id ?? getDefaultId()
-}
-
-export function prepareAddPayload (value, idFields, docId) {
-  if (idFields.includes('_id')) value._id = docId
-  if (idFields.includes('id')) {
-    value.id = docId
-  } else if (value.id === docId) {
-    delete value.id
-  }
-  return value
-}
-
-export function isPublicDocPath (segments) {
-  if (!Array.isArray(segments) || segments.length !== 2) return false
-  const [collection, docId] = segments
-  if (typeof collection !== 'string' || !collection) return false
-  if (collection[0] === '_' || collection[0] === '$') return false
-  return docId != null
-}
-
-export function isIdFieldPath (segments, idFields) {
-  if (!Array.isArray(segments) || segments.length !== 3) return false
-  if (!isPublicDocPath(segments.slice(0, 2))) return false
-  const last = segments[2]
-  return idFields.includes(last)
-}
diff --git a/packages/teamplay/orm/idFields.ts b/packages/teamplay/orm/idFields.ts
new file mode 100644
index 0000000..22479d1
--- /dev/null
+++ b/packages/teamplay/orm/idFields.ts
@@ -0,0 +1,126 @@
+import { findModel } from './addModel.ts'
+import type { PathSegment } from './types/path.ts'
+
+export type IdField = string
+export type IdFields = readonly IdField[]
+export type PlainObject = Record<string, unknown>
+
+export const DEFAULT_ID_FIELDS = ['_id'] as const
+
+interface IdPayload extends PlainObject {
+  id?: PathSegment | null
+  _id?: PathSegment | null
+}
+
+interface IdFieldModel {
+  ID_FIELDS?: IdFields
+}
+
+export function getIdFieldsForSegments (segments: PathSegment[]): IdFields {
+  const Model = findModel(segments) as IdFieldModel | undefined
+  return Model?.ID_FIELDS || DEFAULT_ID_FIELDS
+}
+
+export function isPlainObject (value: unknown): value is PlainObject {
+  if (!value || typeof value !== 'object') return false
+  const proto = Object.getPrototypeOf(value)
+  return proto === Object.prototype || proto === null
+}
+
+export function injectIdFields<TValue> (
+  value: TValue,
+  idFields: IdFields,
+  docId: PathSegment
+): TValue {
+  if (!isPlainObject(value)) return value
+  const object = value as PlainObject
+  for (const field of idFields) object[field] = docId
+  return value
+}
+
+export function normalizeIdFields<TValue> (
+  value: TValue,
+  idFields: IdFields,
+  docId: PathSegment
+): TValue {
+  if (!isPlainObject(value)) return value
+  let next: PlainObject = value
+  let changed = false
+  for (const field of idFields) {
+    if (!(field in next)) continue
+    if (next[field] === docId) continue
+    if (!changed) {
+      next = { ...next }
+      changed = true
+    }
+    next[field] = docId
+  }
+  return next as TValue
+}
+
+export function stripIdFields<TValue> (
+  value: TValue,
+  idFields: IdFields
+): TValue {
+  if (!isPlainObject(value)) return value
+  let next: PlainObject = value
+  let changed = false
+  for (const field of idFields) {
+    if (!(field in next)) continue
+    if (!changed) {
+      next = { ...next }
+      changed = true
+    }
+    delete next[field]
+  }
+  return next as TValue
+}
+
+export function resolveAddDocId (
+  value: unknown,
+  getDefaultId: () => string
+): PathSegment {
+  if (!value || typeof value !== 'object') throw Error('Signal.add() expects an object argument')
+  const payload = value as IdPayload
+  const hasId = payload.id != null
+  const hasUnderscoreId = payload._id != null
+  if (hasId && hasUnderscoreId && payload.id !== payload._id) {
+    throw Error(
+      `Signal.add() got conflicting "id" (${JSON.stringify(payload.id)}) and "_id" (${JSON.stringify(payload._id)})`
+    )
+  }
+  return payload.id ?? payload._id ?? getDefaultId()
+}
+
+export function prepareAddPayload<TValue extends object> (
+  value: TValue,
+  idFields: IdFields,
+  docId: PathSegment
+): TValue {
+  const payload = value as IdPayload
+  if (idFields.includes('_id')) payload._id = docId
+  if (idFields.includes('id')) {
+    payload.id = docId
+  } else if (payload.id === docId) {
+    delete payload.id
+  }
+  return value
+}
+
+export function isPublicDocPath (segments: unknown): segments is [string, PathSegment] {
+  if (!Array.isArray(segments) || segments.length !== 2) return false
+  const [collection, docId] = segments
+  if (typeof collection !== 'string' || !collection) return false
+  if (collection[0] === '_' || collection[0] === '$') return false
+  return docId != null
+}
+
+export function isIdFieldPath (
+  segments: unknown,
+  idFields: IdFields
+): segments is [string, PathSegment, string] {
+  if (!Array.isArray(segments) || segments.length !== 3) return false
+  if (!isPublicDocPath(segments.slice(0, 2))) return false
+  const last = segments[2]
+  return typeof last === 'string' && idFields.includes(last)
+}
diff --git a/packages/teamplay/orm/index.d.ts b/packages/teamplay/orm/index.d.ts
deleted file mode 100644
index af3d355..0000000
--- a/packages/teamplay/orm/index.d.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-export const BaseModel: any
-export default BaseModel
-
-export function belongsTo (AssociatedOrmEntity: any, options?: Record<string, any>): (OrmEntity: any) => any
-export function hasMany (AssociatedOrmEntity: any, options?: Record<string, any>): (OrmEntity: any) => any
-export function hasOne (AssociatedOrmEntity: any, options?: Record<string, any>): (OrmEntity: any) => any
diff --git a/packages/teamplay/orm/index.js b/packages/teamplay/orm/index.js
deleted file mode 100644
index 0c6d568..0000000
--- a/packages/teamplay/orm/index.js
+++ /dev/null
@@ -1,5 +0,0 @@
-import Signal from './Signal.js'
-export { belongsTo, hasMany, hasOne } from './associations.js'
-
-export const BaseModel = Signal
-export default BaseModel
diff --git a/packages/teamplay/orm/index.ts b/packages/teamplay/orm/index.ts
new file mode 100644
index 0000000..d46d534
--- /dev/null
+++ b/packages/teamplay/orm/index.ts
@@ -0,0 +1,52 @@
+import Signal from './Signal.ts'
+export { belongsTo, hasMany, hasOne } from './associations.ts'
+export type {
+  AggregationSignal,
+  ArraySignal,
+  CollectionAggregationSignal,
+  CollectionQuerySignal,
+  CollectionSignal,
+  CollectionSignalFromSpec,
+  CollectionSpec,
+  CollectionsFromManifest,
+  DocumentSignal,
+  FromJsonSchema,
+  JsonSchema,
+  JsonSchemaSpec,
+  ModelEntry,
+  ModelManifest,
+  PathModelsFromManifest,
+  PublicSignal,
+  RuntimeSignalConstructor,
+  RuntimeSignalInstance,
+  WildcardPathSegment,
+  WildcardSignalPath,
+  AppendPath,
+  JoinPath,
+  QueryParams,
+  QuerySignal,
+  RegisteredAggregationInput,
+  SignalBaseInstance,
+  SignalClass,
+  SignalChild,
+  SignalConstructor,
+  SignalForKind,
+  SignalKind,
+  SignalModelConstructor,
+  TypedAggregationInput,
+  TypedAggregationSignal,
+  TypedSignal,
+  ZodLikeSchema,
+  ZodSchemaSpec
+} from './Signal.ts'
+export type { RootSignal, TeamplayCollections, TeamplayModels, TeamplaySignalFields } from '../index.ts'
+
+export const BaseModel = Signal
+export default BaseModel
+export {
+  defineModels,
+  default as initModels,
+  getModels,
+  resetModelsForTests
+} from './initModels.ts'
+export { defineSchema } from '@teamplay/schema'
diff --git a/packages/teamplay/orm/initModels.ts b/packages/teamplay/orm/initModels.ts
new file mode 100644
index 0000000..e90c901
--- /dev/null
+++ b/packages/teamplay/orm/initModels.ts
@@ -0,0 +1,85 @@
+import addModel, { MODELS } from './addModel.ts'
+import type { ModelManifest } from './Signal.ts'
+import { isDefinedSchema } from '@teamplay/schema'
+
+let models: ModelManifest = {}
+const warnedUnwrappedSchemaPatterns = new Set<string>()
+
+export default function initModels<TModels extends ModelManifest = ModelManifest> (
+  nextModels?: TModels | null
+): TModels | ModelManifest {
+  const resolvedModels: ModelManifest = nextModels || {}
+
+  for (const [pattern, model] of Object.entries(resolvedModels)) {
+    warnIfSchemaWasNotDefined(pattern, model?.schema)
+    if (model?.default) addModel(pattern, model.default)
+  }
+
+  models = resolvedModels
+  return resolvedModels
+}
+
+export function defineModels<TModels extends ModelManifest> (nextModels: TModels): TModels {
+  return nextModels
+}
+
+export function getModels (): ModelManifest {
+  return models
+}
+
+export function resetModelsForTests (): void {
+  models = {}
+  warnedUnwrappedSchemaPatterns.clear()
+  for (const pattern of Object.keys(MODELS)) delete MODELS[pattern]
+}
+
+function warnIfSchemaWasNotDefined (pattern: string, schema: unknown): void {
+  if (!schema) return
+  if (isDefinedSchema(schema)) return
+  if (!shouldWarnAboutUnwrappedSchemas()) return
+  if (warnedUnwrappedSchemaPatterns.has(pattern)) return
+  warnedUnwrappedSchemaPatterns.add(pattern)
+  console.warn(
+    `[teamplay] Schema for model "${pattern}" was loaded as a plain object. ` +
+    'Wrap it with defineSchema(schema) to enable the conventional schema setup. ' +
+    'Plain schemas still work for backward compatibility.'
+  )
+}
+
+function shouldWarnAboutUnwrappedSchemas (): boolean {
+  const env = getProcessEnv()
+  if (!env) return false
+  if (env.TEAMPLAY_WARN_UNWRAPPED_SCHEMAS === '1') return true
+  if (env.TEAMPLAY_WARN_UNWRAPPED_SCHEMAS === '0') return false
+  if (env.NODE_ENV === 'production' || env.NODE_ENV === 'test') return false
+  if (isTestProcess()) return false
+  return true
+}
+
+function getProcessEnv (): Record<string, string | undefined> | undefined {
+  return getProcessLike()?.env
+}
+
+function isTestProcess (): boolean {
+  const processLike = getProcessLike()
+  if (!processLike) return false
+  if (processLike.env.JEST_WORKER_ID || processLike.env.VITEST) return true
+  return processLike.argv.some((arg: string) => /(?:^|[/\\])(mocha|jest|vitest)(?:$|\.)/.test(arg))
+}
+
+function getProcessLike (): {
+  env: Record<string, string | undefined>
+  argv: string[]
+} | undefined {
+  const processLike = (globalThis as unknown as {
+    process?: {
+      env?: Record<string, string | undefined>
+      argv?: string[]
+    }
+  }).process
+  if (!processLike?.env || !processLike?.argv) return undefined
+  return {
+    env: processLike.env,
+    argv: processLike.argv
+  }
+}
diff --git a/packages/teamplay/orm/pluralize.d.ts b/packages/teamplay/orm/pluralize.d.ts
new file mode 100644
index 0000000..18c2d71
--- /dev/null
+++ b/packages/teamplay/orm/pluralize.d.ts
@@ -0,0 +1,12 @@
+declare module 'pluralize' {
+  interface Pluralize {
+    (word: string, count?: number, inclusive?: boolean): string
+    singular: (word: string) => string
+    plural: (word: string) => string
+    isSingular: (word: string) => boolean
+    isPlural: (word: string) => boolean
+  }
+
+  const pluralize: Pluralize
+  export default pluralize
+}
diff --git a/packages/teamplay/orm/privateData.js b/packages/teamplay/orm/privateData.js
index 9f23f38..d81063b 100644
--- a/packages/teamplay/orm/privateData.js
+++ b/packages/teamplay/orm/privateData.js
@@ -1,5 +1,5 @@
-import { getRootContext } from './rootContext.js'
-import { getPrivateDataSegments, isPrivateCollectionSegments } from './rootScope.js'
+import { getRootContext } from './rootContext.ts'
+import { getPrivateDataSegments, isPrivateCollectionSegments } from './rootScope.ts'
 import {
   arrayInsert as _arrayInsert,
   arrayMove as _arrayMove,
diff --git a/packages/teamplay/orm/rootContext.js b/packages/teamplay/orm/rootContext.js
deleted file mode 100644
index 336e738..0000000
--- a/packages/teamplay/orm/rootContext.js
+++ /dev/null
@@ -1,313 +0,0 @@
-import { observable } from '@nx-js/observer-util'
-import { normalizeRootId } from './rootScope.js'
-import { getDefaultFetchOnly } from './connection.js'
-
-const ROOT_CONTEXTS = new Map()
-const CLOSED_ROOT_CONTEXTS = new Set()
-const EMPTY_SET = new Set()
-const EMPTY_MAP = new Map()
-const RUNTIME_KIND_QUERY = 'query'
-const RUNTIME_KIND_AGGREGATION = 'aggregation'
-
-export default class RootContext {
-  constructor (rootId, { fetchOnly } = {}) {
-    this.rootId = normalizeRootId(rootId)
-    this.fetchOnly = fetchOnly == null ? getDefaultFetchOnly() : !!fetchOnly
-    this.privateDataRaw = {}
-    this.privateData = observable(this.privateDataRaw)
-    this.refLinks = new Map()
-    this.activeRefs = new Map()
-    this.modelListeners = {
-      change: new Map(),
-      all: new Map()
-    }
-    this.queryRuntimeHashes = new Set()
-    this.aggregationRuntimeHashes = new Set()
-    this.signalHashes = new Set()
-    this.directDocSubscriptions = new Map()
-  }
-
-  getModelEventStore (eventName, create = false) {
-    let store = this.modelListeners[eventName]
-    if (!store && create) {
-      store = new Map()
-      this.modelListeners[eventName] = store
-    }
-    return store
-  }
-
-  getFetchOnly () {
-    return !!this.fetchOnly
-  }
-
-  setFetchOnly (value) {
-    this.fetchOnly = !!value
-  }
-
-  getPrivateDataRoot () {
-    return this.privateData
-  }
-
-  getPrivateDataRawRoot () {
-    return this.privateDataRaw
-  }
-
-  getPrivateDataAt (segments) {
-    return getPath(segments, this.privateData)
-  }
-
-  getPrivateDataRawAt (segments) {
-    return getPath(segments, this.privateDataRaw)
-  }
-
-  setPrivateDataAt (segments, value) {
-    setPath(segments, value, this.privateData)
-  }
-
-  delPrivateDataAt (segments) {
-    delPath(segments, this.privateData)
-  }
-
-  getRuntimeHashes (kind) {
-    switch (kind) {
-      case RUNTIME_KIND_QUERY:
-        return this.queryRuntimeHashes
-      case RUNTIME_KIND_AGGREGATION:
-        return this.aggregationRuntimeHashes
-      default:
-        throw Error(`Unsupported root-owned runtime kind: ${kind}`)
-    }
-  }
-
-  registerRuntime (kind, runtimeHash) {
-    if (runtimeHash == null) return
-    this.getRuntimeHashes(kind).add(runtimeHash)
-  }
-
-  unregisterRuntime (kind, runtimeHash) {
-    if (runtimeHash == null) return
-    this.getRuntimeHashes(kind).delete(runtimeHash)
-  }
-
-  registerSignalHash (signalHash) {
-    if (signalHash == null) return
-    this.signalHashes.add(signalHash)
-  }
-
-  unregisterSignalHash (signalHash) {
-    if (signalHash == null) return
-    this.signalHashes.delete(signalHash)
-  }
-
-  registerDirectDocSubscription (hash, segments, token) {
-    if (hash == null) return
-    let entry = this.directDocSubscriptions.get(hash)
-    if (!entry) {
-      entry = {
-        segments: [...segments],
-        count: 0,
-        tokenCounts: new Map()
-      }
-      this.directDocSubscriptions.set(hash, entry)
-    }
-    entry.count += 1
-    if (token != null) {
-      entry.tokenCounts.set(token, (entry.tokenCounts.get(token) || 0) + 1)
-    }
-  }
-
-  unregisterDirectDocSubscription (hash, token) {
-    const entry = this.directDocSubscriptions.get(hash)
-    if (!entry) return
-    entry.count = Math.max(entry.count - 1, 0)
-    if (token != null) {
-      const nextTokenCount = (entry.tokenCounts.get(token) || 0) - 1
-      if (nextTokenCount > 0) entry.tokenCounts.set(token, nextTokenCount)
-      else entry.tokenCounts.delete(token)
-    }
-    if (entry.count === 0) this.directDocSubscriptions.delete(hash)
-  }
-
-  resetRefs () {
-    this.refLinks.clear()
-  }
-
-  resetActiveRefs () {
-    this.activeRefs.clear()
-  }
-
-  resetModelListeners () {
-    for (const store of Object.values(this.modelListeners)) {
-      store.clear()
-    }
-  }
-
-  resetRuntimeHashes () {
-    this.queryRuntimeHashes.clear()
-    this.aggregationRuntimeHashes.clear()
-  }
-
-  resetPrivateData () {
-    this.privateDataRaw = {}
-    this.privateData = observable(this.privateDataRaw)
-  }
-
-  resetSignalHashes () {
-    this.signalHashes.clear()
-  }
-
-  resetDirectDocSubscriptions () {
-    this.directDocSubscriptions.clear()
-  }
-
-  isRuntimeEmpty () {
-    return (
-      isPlainObjectEmpty(this.privateData) &&
-      this.refLinks.size === 0 &&
-      this.activeRefs.size === 0 &&
-      Object.values(this.modelListeners).every(store => store.size === 0) &&
-      this.queryRuntimeHashes.size === 0 &&
-      this.aggregationRuntimeHashes.size === 0 &&
-      this.signalHashes.size === 0 &&
-      this.directDocSubscriptions.size === 0
-    )
-  }
-}
-
-export function getRootContext (rootId, create = true, options = {}) {
-  const normalizedRootId = normalizeRootId(rootId)
-  if (create && CLOSED_ROOT_CONTEXTS.has(normalizedRootId)) return undefined
-  let context = ROOT_CONTEXTS.get(normalizedRootId)
-  if (!context && create) {
-    context = new RootContext(normalizedRootId, options)
-    ROOT_CONTEXTS.set(normalizedRootId, context)
-  }
-  return context
-}
-
-export function getRootContexts () {
-  return ROOT_CONTEXTS.values()
-}
-
-export function registerRootOwnedRuntime (rootId, kind, runtimeHash) {
-  getRootContext(rootId, true).registerRuntime(kind, runtimeHash)
-}
-
-export function unregisterRootOwnedRuntime (rootId, kind, runtimeHash) {
-  const context = getRootContext(rootId, false)
-  if (!context) return
-  context.unregisterRuntime(kind, runtimeHash)
-}
-
-export function getRootOwnedRuntimeHashes (rootId, kind) {
-  const context = getRootContext(rootId, false)
-  if (!context) return EMPTY_SET
-  return context.getRuntimeHashes(kind)
-}
-
-export function registerRootOwnedSignalHash (rootId, signalHash) {
-  getRootContext(rootId, true).registerSignalHash(signalHash)
-}
-
-export function getRootOwnedSignalHashes (rootId) {
-  const context = getRootContext(rootId, false)
-  if (!context) return EMPTY_SET
-  return context.signalHashes
-}
-
-export function clearRootOwnedSignalHashes (rootId) {
-  const context = getRootContext(rootId, false)
-  if (!context) return
-  context.resetSignalHashes()
-}
-
-export function registerRootOwnedDirectDocSubscription (rootId, hash, segments, token) {
-  getRootContext(rootId, true).registerDirectDocSubscription(hash, segments, token)
-}
-
-export function unregisterRootOwnedDirectDocSubscription (rootId, hash, token) {
-  const context = getRootContext(rootId, false)
-  if (!context) return
-  context.unregisterDirectDocSubscription(hash, token)
-}
-
-export function getRootOwnedDirectDocSubscriptions (rootId) {
-  const context = getRootContext(rootId, false)
-  if (!context) return EMPTY_MAP
-  return context.directDocSubscriptions
-}
-
-export function clearRootOwnedDirectDocSubscriptions (rootId) {
-  const context = getRootContext(rootId, false)
-  if (!context) return
-  context.resetDirectDocSubscriptions()
-}
-
-export function deleteRootContext (rootId) {
-  const normalizedRootId = normalizeRootId(rootId)
-  ROOT_CONTEXTS.delete(normalizedRootId)
-  CLOSED_ROOT_CONTEXTS.add(normalizedRootId)
-}
-
-export function reviveRootContext (rootId) {
-  CLOSED_ROOT_CONTEXTS.delete(normalizeRootId(rootId))
-}
-
-export function isRootContextClosed (rootId) {
-  return CLOSED_ROOT_CONTEXTS.has(normalizeRootId(rootId))
-}
-
-export function __getRootContextForTests (rootId) {
-  return getRootContext(rootId, false)
-}
-
-export function __resetRootContextsForTests () {
-  ROOT_CONTEXTS.clear()
-  CLOSED_ROOT_CONTEXTS.clear()
-}
-
-function getPath (segments, dataNode) {
-  for (const segment of segments) {
-    if (dataNode == null) return dataNode
-    dataNode = dataNode[segment]
-  }
-  return dataNode
-}
-
-function setPath (segments, value, tree) {
-  if (!Array.isArray(segments) || segments.length === 0) {
-    throw Error('setPrivateDataAt requires a non-empty segments array')
-  }
-  let dataNode = tree
-  for (let i = 0; i < segments.length - 1; i++) {
-    const segment = segments[i]
-    const next = dataNode[segment]
-    if (next == null || typeof next !== 'object') {
-      dataNode[segment] = {}
-    }
-    dataNode = dataNode[segment]
-  }
-  dataNode[segments[segments.length - 1]] = value
-}
-
-function delPath (segments, tree) {
-  if (!Array.isArray(segments) || segments.length === 0) return
-  const parents = []
-  let dataNode = tree
-  for (let i = 0; i < segments.length - 1; i++) {
-    if (dataNode == null) return
-    parents.push([dataNode, segments[i]])
-    dataNode = dataNode[segments[i]]
-  }
-  if (dataNode == null) return
-  delete dataNode[segments[segments.length - 1]]
-  for (let i = parents.length - 1; i >= 0; i--) {
-    const [parent, segment] = parents[i]
-    if (!isPlainObjectEmpty(parent[segment])) break
-    delete parent[segment]
-  }
-}
-
-function isPlainObjectEmpty (value) {
-  return value != null && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0
-}
diff --git a/packages/teamplay/orm/rootContext.ts b/packages/teamplay/orm/rootContext.ts
new file mode 100644
index 0000000..92569e1
--- /dev/null
+++ b/packages/teamplay/orm/rootContext.ts
@@ -0,0 +1,391 @@
+import { observable } from '@nx-js/observer-util'
+import { normalizeRootId } from './rootScope.ts'
+import { getDefaultFetchOnly } from './connection.ts'
+import type { PathSegment } from './types/path.ts'
+
+type RootId = string | null | undefined
+type DataTree = Record<string | number, unknown>
+type RuntimeKind = 'query' | 'aggregation'
+type ModelEventStore = Map<string, unknown>
+type ActiveRefEntry = { stop?: () => void }
+
+interface RootContextOptions {
+  fetchOnly?: boolean
+}
+
+interface ModelListeners {
+  change: ModelEventStore
+  all: ModelEventStore
+  [eventName: string]: ModelEventStore
+}
+
+export interface DirectDocSubscriptionEntry {
+  segments: PathSegment[]
+  count: number
+  tokenCounts: Map<unknown, number>
+}
+
+const ROOT_CONTEXTS = new Map<string, RootContext>()
+const CLOSED_ROOT_CONTEXTS = new Set<string>()
+const EMPTY_SET = new Set<string>()
+const EMPTY_MAP = new Map<string, DirectDocSubscriptionEntry>()
+const RUNTIME_KIND_QUERY = 'query'
+const RUNTIME_KIND_AGGREGATION = 'aggregation'
+
+export default class RootContext {
+  readonly rootId: string
+  fetchOnly: boolean
+  privateDataRaw: DataTree
+  privateData: DataTree
+  readonly refLinks = new Map<string, unknown>()
+  readonly activeRefs = new Map<string, ActiveRefEntry>()
+  readonly modelListeners: ModelListeners = {
+    change: new Map(),
+    all: new Map()
+  }
+
+  readonly queryRuntimeHashes = new Set<string>()
+  readonly aggregationRuntimeHashes = new Set<string>()
+  readonly signalHashes = new Set<string>()
+  readonly directDocSubscriptions = new Map<string, DirectDocSubscriptionEntry>()
+
+  constructor (rootId: RootId, { fetchOnly }: RootContextOptions = {}) {
+    this.rootId = normalizeRootId(rootId)
+    this.fetchOnly = fetchOnly == null ? getDefaultFetchOnly() : !!fetchOnly
+    this.privateDataRaw = {}
+    this.privateData = observable(this.privateDataRaw) as DataTree
+  }
+
+  getModelEventStore (eventName: string, create = false): ModelEventStore {
+    let store = this.modelListeners[eventName]
+    if (!store && create) {
+      store = new Map()
+      this.modelListeners[eventName] = store
+    }
+    return store
+  }
+
+  getFetchOnly (): boolean {
+    return !!this.fetchOnly
+  }
+
+  setFetchOnly (value: boolean): void {
+    this.fetchOnly = !!value
+  }
+
+  getPrivateDataRoot (): DataTree {
+    return this.privateData
+  }
+
+  getPrivateDataRawRoot (): DataTree {
+    return this.privateDataRaw
+  }
+
+  getPrivateDataAt (segments: readonly PathSegment[]): unknown {
+    return getPath(segments, this.privateData)
+  }
+
+  getPrivateDataRawAt (segments: readonly PathSegment[]): unknown {
+    return getPath(segments, this.privateDataRaw)
+  }
+
+  setPrivateDataAt (segments: readonly PathSegment[], value: unknown): void {
+    setPath(segments, value, this.privateData)
+  }
+
+  delPrivateDataAt (segments: readonly PathSegment[]): void {
+    delPath(segments, this.privateData)
+  }
+
+  getRuntimeHashes (kind: RuntimeKind): Set<string> {
+    switch (kind) {
+      case RUNTIME_KIND_QUERY:
+        return this.queryRuntimeHashes
+      case RUNTIME_KIND_AGGREGATION:
+        return this.aggregationRuntimeHashes
+      default:
+        throw Error(`Unsupported root-owned runtime kind: ${kind}`)
+    }
+  }
+
+  registerRuntime (kind: RuntimeKind, runtimeHash: string | null | undefined): void {
+    if (runtimeHash == null) return
+    this.getRuntimeHashes(kind).add(runtimeHash)
+  }
+
+  unregisterRuntime (kind: RuntimeKind, runtimeHash: string | null | undefined): void {
+    if (runtimeHash == null) return
+    this.getRuntimeHashes(kind).delete(runtimeHash)
+  }
+
+  registerSignalHash (signalHash: string | null | undefined): void {
+    if (signalHash == null) return
+    this.signalHashes.add(signalHash)
+  }
+
+  unregisterSignalHash (signalHash: string | null | undefined): void {
+    if (signalHash == null) return
+    this.signalHashes.delete(signalHash)
+  }
+
+  registerDirectDocSubscription (
+    hash: string | null | undefined,
+    segments: readonly PathSegment[],
+    token?: unknown
+  ): void {
+    if (hash == null) return
+    let entry = this.directDocSubscriptions.get(hash)
+    if (!entry) {
+      entry = {
+        segments: [...segments],
+        count: 0,
+        tokenCounts: new Map()
+      }
+      this.directDocSubscriptions.set(hash, entry)
+    }
+    entry.count += 1
+    if (token != null) {
+      entry.tokenCounts.set(token, (entry.tokenCounts.get(token) || 0) + 1)
+    }
+  }
+
+  unregisterDirectDocSubscription (hash: string | null | undefined, token?: unknown): void {
+    if (hash == null) return
+    const entry = this.directDocSubscriptions.get(hash)
+    if (!entry) return
+    entry.count = Math.max(entry.count - 1, 0)
+    if (token != null) {
+      const nextTokenCount = (entry.tokenCounts.get(token) || 0) - 1
+      if (nextTokenCount > 0) entry.tokenCounts.set(token, nextTokenCount)
+      else entry.tokenCounts.delete(token)
+    }
+    if (entry.count === 0) this.directDocSubscriptions.delete(hash)
+  }
+
+  resetRefs (): void {
+    this.refLinks.clear()
+  }
+
+  resetActiveRefs (): void {
+    this.activeRefs.clear()
+  }
+
+  resetModelListeners (): void {
+    for (const store of Object.values(this.modelListeners)) {
+      store.clear()
+    }
+  }
+
+  resetRuntimeHashes (): void {
+    this.queryRuntimeHashes.clear()
+    this.aggregationRuntimeHashes.clear()
+  }
+
+  resetPrivateData (): void {
+    this.privateDataRaw = {}
+    this.privateData = observable(this.privateDataRaw) as DataTree
+  }
+
+  resetSignalHashes (): void {
+    this.signalHashes.clear()
+  }
+
+  resetDirectDocSubscriptions (): void {
+    this.directDocSubscriptions.clear()
+  }
+
+  isRuntimeEmpty (): boolean {
+    return (
+      isPlainObjectEmpty(this.privateData) &&
+      this.refLinks.size === 0 &&
+      this.activeRefs.size === 0 &&
+      Object.values(this.modelListeners).every(store => store.size === 0) &&
+      this.queryRuntimeHashes.size === 0 &&
+      this.aggregationRuntimeHashes.size === 0 &&
+      this.signalHashes.size === 0 &&
+      this.directDocSubscriptions.size === 0
+    )
+  }
+}
+
+export function getRootContext (
+  rootId: RootId,
+  create: false,
+  options?: RootContextOptions
+): RootContext | undefined
+export function getRootContext (
+  rootId: RootId,
+  create?: true,
+  options?: RootContextOptions
+): RootContext
+export function getRootContext (
+  rootId: RootId,
+  create = true,
+  options: RootContextOptions = {}
+): RootContext | undefined {
+  const normalizedRootId = normalizeRootId(rootId)
+  if (create && CLOSED_ROOT_CONTEXTS.has(normalizedRootId)) return undefined
+  let context = ROOT_CONTEXTS.get(normalizedRootId)
+  if (!context && create) {
+    context = new RootContext(normalizedRootId, options)
+    ROOT_CONTEXTS.set(normalizedRootId, context)
+  }
+  return context
+}
+
+export function getRootContexts (): IterableIterator<RootContext> {
+  return ROOT_CONTEXTS.values()
+}
+
+export function registerRootOwnedRuntime (
+  rootId: RootId,
+  kind: RuntimeKind,
+  runtimeHash: string | null | undefined
+): void {
+  getRootContext(rootId, true).registerRuntime(kind, runtimeHash)
+}
+
+export function unregisterRootOwnedRuntime (
+  rootId: RootId,
+  kind: RuntimeKind,
+  runtimeHash: string | null | undefined
+): void {
+  const context = getRootContext(rootId, false)
+  if (!context) return
+  context.unregisterRuntime(kind, runtimeHash)
+}
+
+export function getRootOwnedRuntimeHashes (
+  rootId: RootId,
+  kind: RuntimeKind
+): ReadonlySet<string> {
+  const context = getRootContext(rootId, false)
+  if (!context) return EMPTY_SET
+  return context.getRuntimeHashes(kind)
+}
+
+export function registerRootOwnedSignalHash (
+  rootId: RootId,
+  signalHash: string | null | undefined
+): void {
+  getRootContext(rootId, true).registerSignalHash(signalHash)
+}
+
+export function getRootOwnedSignalHashes (rootId: RootId): ReadonlySet<string> {
+  const context = getRootContext(rootId, false)
+  if (!context) return EMPTY_SET
+  return context.signalHashes
+}
+
+export function clearRootOwnedSignalHashes (rootId: RootId): void {
+  const context = getRootContext(rootId, false)
+  if (!context) return
+  context.resetSignalHashes()
+}
+
+export function registerRootOwnedDirectDocSubscription (
+  rootId: RootId,
+  hash: string | null | undefined,
+  segments: readonly PathSegment[],
+  token?: unknown
+): void {
+  getRootContext(rootId, true).registerDirectDocSubscription(hash, segments, token)
+}
+
+export function unregisterRootOwnedDirectDocSubscription (
+  rootId: RootId,
+  hash: string | null | undefined,
+  token?: unknown
+): void {
+  const context = getRootContext(rootId, false)
+  if (!context) return
+  context.unregisterDirectDocSubscription(hash, token)
+}
+
+export function getRootOwnedDirectDocSubscriptions (
+  rootId: RootId
+): ReadonlyMap<string, DirectDocSubscriptionEntry> {
+  const context = getRootContext(rootId, false)
+  if (!context) return EMPTY_MAP
+  return context.directDocSubscriptions
+}
+
+export function clearRootOwnedDirectDocSubscriptions (rootId: RootId): void {
+  const context = getRootContext(rootId, false)
+  if (!context) return
+  context.resetDirectDocSubscriptions()
+}
+
+export function deleteRootContext (rootId: RootId): void {
+  const normalizedRootId = normalizeRootId(rootId)
+  ROOT_CONTEXTS.delete(normalizedRootId)
+  CLOSED_ROOT_CONTEXTS.add(normalizedRootId)
+}
+
+export function reviveRootContext (rootId: RootId): void {
+  CLOSED_ROOT_CONTEXTS.delete(normalizeRootId(rootId))
+}
+
+export function isRootContextClosed (rootId: RootId): boolean {
+  return CLOSED_ROOT_CONTEXTS.has(normalizeRootId(rootId))
+}
+
+export function __getRootContextForTests (rootId: RootId): RootContext | undefined {
+  return getRootContext(rootId, false)
+}
+
+export function __resetRootContextsForTests (): void {
+  ROOT_CONTEXTS.clear()
+  CLOSED_ROOT_CONTEXTS.clear()
+}
+
+function getPath (segments: readonly PathSegment[], dataNode: unknown): unknown {
+  let current = dataNode
+  for (const segment of segments) {
+    if (current == null) return current
+    current = (current as DataTree)[segment]
+  }
+  return current
+}
+
+function setPath (segments: readonly PathSegment[], value: unknown, tree: DataTree): void {
+  if (!Array.isArray(segments) || segments.length === 0) {
+    throw Error('setPrivateDataAt requires a non-empty segments array')
+  }
+  let dataNode = tree
+  for (let i = 0; i < segments.length - 1; i++) {
+    const segment = segments[i]
+    const next = dataNode[segment]
+    if (next == null || typeof next !== 'object') {
+      dataNode[segment] = {}
+    }
+    dataNode = dataNode[segment] as DataTree
+  }
+  dataNode[segments[segments.length - 1]] = value
+}
+
+function delPath (segments: readonly PathSegment[], tree: DataTree): void {
+  if (!Array.isArray(segments) || segments.length === 0) return
+  const parents: Array<[DataTree, PathSegment]> = []
+  let dataNode: unknown = tree
+  for (let i = 0; i < segments.length - 1; i++) {
+    if (dataNode == null) return
+    const parent = dataNode as DataTree
+    parents.push([parent, segments[i]])
+    dataNode = parent[segments[i]]
+  }
+  if (dataNode == null) return
+  delete (dataNode as DataTree)[segments[segments.length - 1]]
+  for (let i = parents.length - 1; i >= 0; i--) {
+    const [parent, segment] = parents[i]
+    if (!isPlainObjectEmpty(parent[segment])) break
+    delete parent[segment]
+  }
+}
+
+function isPlainObjectEmpty (value: unknown): boolean {
+  return value != null &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    Object.keys(value).length === 0
+}
diff --git a/packages/teamplay/orm/rootScope.js b/packages/teamplay/orm/rootScope.js
deleted file mode 100644
index bc02182..0000000
--- a/packages/teamplay/orm/rootScope.js
+++ /dev/null
@@ -1,51 +0,0 @@
-import { GLOBAL_ROOT_ID } from './Root.js'
-
-const REGEX_PRIVATE_COLLECTION = /^[_$]/
-
-export function normalizeRootId (rootId) {
-  return rootId ?? GLOBAL_ROOT_ID
-}
-
-export function isGlobalRootId (rootId) {
-  return normalizeRootId(rootId) === GLOBAL_ROOT_ID
-}
-
-export function isPrivateCollectionSegments (segments) {
-  return Array.isArray(segments) &&
-    segments.length > 0 &&
-    REGEX_PRIVATE_COLLECTION.test(String(segments[0]))
-}
-
-export function getPrivateDataSegments (logicalSegments) {
-  if (!isPrivateCollectionSegments(logicalSegments)) return logicalSegments
-  return [...logicalSegments]
-}
-
-export function getLogicalRootSnapshot (rootId, tree, privateDataRoot) {
-  const snapshot = {}
-  for (const key of Object.keys(tree)) {
-    snapshot[key] = tree[key]
-  }
-  if (!privateDataRoot || typeof privateDataRoot !== 'object') return snapshot
-  for (const key of Object.keys(privateDataRoot)) {
-    snapshot[key] = privateDataRoot[key]
-  }
-  return snapshot
-}
-
-export function getSignalIdentityHash (rootId, segments) {
-  const normalizedRootId = normalizeRootId(rootId)
-  if (segments.length === 0) return JSON.stringify({ root: normalizedRootId })
-  if (isPrivateCollectionSegments(segments)) {
-    return JSON.stringify({ private: [normalizedRootId, segments] })
-  }
-  return JSON.stringify({ public: [normalizedRootId, segments] })
-}
-
-export function getScopedSignalHash (rootId, transportHash, kind = 'querySignal') {
-  return JSON.stringify({ [kind]: [normalizeRootId(rootId), transportHash] })
-}
-
-export function getRootScopedRegistryKey (rootId, key) {
-  return JSON.stringify([normalizeRootId(rootId), key])
-}
diff --git a/packages/teamplay/orm/rootScope.ts b/packages/teamplay/orm/rootScope.ts
new file mode 100644
index 0000000..5639a7c
--- /dev/null
+++ b/packages/teamplay/orm/rootScope.ts
@@ -0,0 +1,67 @@
+import { GLOBAL_ROOT_ID } from './Root.ts'
+import type { PathSegment } from './types/path.ts'
+
+const REGEX_PRIVATE_COLLECTION = /^[_$]/
+
+type RootId = string | null | undefined
+type DataTree = Record<string, unknown>
+
+export function normalizeRootId (rootId: RootId): string {
+  return rootId ?? GLOBAL_ROOT_ID
+}
+
+export function isGlobalRootId (rootId: RootId): boolean {
+  return normalizeRootId(rootId) === GLOBAL_ROOT_ID
+}
+
+export function isPrivateCollectionSegments (segments: unknown): segments is readonly [PathSegment, ...PathSegment[]] {
+  return Array.isArray(segments) &&
+    segments.length > 0 &&
+    REGEX_PRIVATE_COLLECTION.test(String(segments[0]))
+}
+
+export function getPrivateDataSegments (logicalSegments: readonly PathSegment[]): readonly PathSegment[] {
+  if (!isPrivateCollectionSegments(logicalSegments)) return logicalSegments
+  return [...logicalSegments]
+}
+
+export function getLogicalRootSnapshot (
+  _rootId: RootId,
+  tree: DataTree,
+  privateDataRoot: unknown
+): DataTree {
+  const snapshot: DataTree = {}
+  for (const key of Object.keys(tree)) {
+    snapshot[key] = tree[key]
+  }
+  if (!privateDataRoot || typeof privateDataRoot !== 'object') return snapshot
+  const privateData = privateDataRoot as DataTree
+  for (const key of Object.keys(privateData)) {
+    snapshot[key] = privateData[key]
+  }
+  return snapshot
+}
+
+export function getSignalIdentityHash (
+  rootId: RootId,
+  segments: readonly PathSegment[]
+): string {
+  const normalizedRootId = normalizeRootId(rootId)
+  if (segments.length === 0) return JSON.stringify({ root: normalizedRootId })
+  if (isPrivateCollectionSegments(segments)) {
+    return JSON.stringify({ private: [normalizedRootId, segments] })
+  }
+  return JSON.stringify({ public: [normalizedRootId, segments] })
+}
+
+export function getScopedSignalHash (
+  rootId: RootId,
+  transportHash: unknown,
+  kind = 'querySignal'
+): string {
+  return JSON.stringify({ [kind]: [normalizeRootId(rootId), transportHash] })
+}
+
+export function getRootScopedRegistryKey (rootId: RootId, key: unknown): string {
+  return JSON.stringify([normalizeRootId(rootId), key])
+}
diff --git a/packages/teamplay/orm/signalArrayReaders.ts b/packages/teamplay/orm/signalArrayReaders.ts
new file mode 100644
index 0000000..0762f5d
--- /dev/null
+++ b/packages/teamplay/orm/signalArrayReaders.ts
@@ -0,0 +1,84 @@
+import { HASH, IS_QUERY, QUERIES } from './Query.js'
+import { SEGMENTS } from './signalSymbols.ts'
+import type { PathSegment } from './types/path.ts'
+
+export interface SignalArrayReaderOwner {
+  readonly [SEGMENTS]: PathSegment[]
+  readonly [HASH]?: string
+  readonly [IS_QUERY]?: unknown
+}
+
+export interface SignalArrayReaderContext<TSignal extends SignalArrayReaderOwner> {
+  getRoot: ($signal: TSignal) => TSignal | undefined
+  readQueryIds: ($signal: TSignal) => unknown
+  readArrayValue: ($signal: TSignal) => unknown
+  createSignal: ($root: TSignal | undefined, segments: PathSegment[]) => TSignal
+  warn: (message: string, ...args: unknown[]) => void
+}
+
+export interface QueryIdsWarningOptions {
+  message: string
+  method?: string
+}
+
+export function getSignalArrayChildren<TSignal extends SignalArrayReaderOwner> (
+  $signal: TSignal,
+  context: SignalArrayReaderContext<TSignal>,
+  queryIdsWarning?: QueryIdsWarningOptions
+): TSignal[] | undefined {
+  if ($signal[IS_QUERY]) {
+    const ids = context.readQueryIds($signal)
+    if (!Array.isArray(ids)) {
+      warnMissingQueryIds($signal, context, queryIdsWarning)
+      return
+    }
+    const collection = $signal[SEGMENTS][0]
+    const $root = context.getRoot($signal)
+    return ids.map(id => context.createSignal($root, [collection, id]))
+  }
+
+  const items = context.readArrayValue($signal)
+  if (!Array.isArray(items)) return
+  const $root = context.getRoot($signal)
+  return Array.from({ length: items.length }, (_, index) => (
+    context.createSignal($root, [...$signal[SEGMENTS], index])
+  ))
+}
+
+export function * iterateSignalArrayChildren<TSignal extends SignalArrayReaderOwner> (
+  $signal: TSignal,
+  context: SignalArrayReaderContext<TSignal>,
+  queryIdsWarning?: QueryIdsWarningOptions
+): IterableIterator<TSignal> {
+  const children = getSignalArrayChildren($signal, context, queryIdsWarning)
+  if (!children) return
+  yield * children
+}
+
+export function runSignalArrayMethod<TSignal extends SignalArrayReaderOwner> (
+  $signal: TSignal,
+  context: SignalArrayReaderContext<TSignal>,
+  method: string,
+  nonArrayReturnValue: unknown,
+  args: unknown[],
+  queryIdsWarning?: QueryIdsWarningOptions
+): unknown {
+  const children = getSignalArrayChildren($signal, context, queryIdsWarning)
+  if (!children) return nonArrayReturnValue
+  const arrayReaders = children as unknown as Record<string, (...args: unknown[]) => unknown>
+  return arrayReaders[method](...args)
+}
+
+function warnMissingQueryIds<TSignal extends SignalArrayReaderOwner> (
+  $signal: TSignal,
+  context: SignalArrayReaderContext<TSignal>,
+  queryIdsWarning?: QueryIdsWarningOptions
+): void {
+  if (!queryIdsWarning) return
+  const warningPath = [QUERIES, $signal[HASH], 'ids']
+  if (queryIdsWarning.method) {
+    context.warn(queryIdsWarning.message, warningPath, queryIdsWarning.method)
+    return
+  }
+  context.warn(queryIdsWarning.message, warningPath)
+}
diff --git a/packages/teamplay/orm/signalMetadata.ts b/packages/teamplay/orm/signalMetadata.ts
new file mode 100644
index 0000000..6ec0a55
--- /dev/null
+++ b/packages/teamplay/orm/signalMetadata.ts
@@ -0,0 +1,74 @@
+import { AGGREGATIONS, getAggregationCollectionName, getAggregationDocId } from './Aggregation.js'
+import { SEGMENTS } from './signalSymbols.ts'
+import type { PathSegment } from './types/path.ts'
+
+export interface SignalMetadataOwner {
+  readonly [SEGMENTS]: PathSegment[]
+  readonly constructor: SignalMetadataConstructor
+}
+
+export interface SignalMetadataConstructor {
+  readonly collection?: unknown
+  readonly associations?: readonly unknown[]
+}
+
+export function getSignalPath ($signal: Pick<SignalMetadataOwner, typeof SEGMENTS>): string {
+  return $signal[SEGMENTS].join('.')
+}
+
+export function getSignalLeaf ($signal: Pick<SignalMetadataOwner, typeof SEGMENTS>): string {
+  const segments = $signal[SEGMENTS]
+  if (segments.length === 0) return ''
+  return String(segments[segments.length - 1])
+}
+
+export function getSignalParentSegments (
+  $signal: Pick<SignalMetadataOwner, typeof SEGMENTS>,
+  levels: unknown,
+  argumentCount: number
+): PathSegment[] {
+  const normalizedLevels = normalizeParentLevels(levels, argumentCount)
+  const segments = $signal[SEGMENTS]
+  const targetLength = Math.max(0, segments.length - normalizedLevels)
+  return segments.slice(0, targetLength)
+}
+
+export function normalizeParentLevels (levels: unknown, argumentCount: number): number {
+  if (argumentCount > 1) throw Error('Signal.parent() expects a single argument')
+  if (argumentCount === 0) return 1
+  if (typeof levels !== 'number' || !Number.isFinite(levels) || !Number.isInteger(levels)) {
+    throw Error('Signal.parent() expects an integer argument')
+  }
+  if (levels < 1) throw Error('Signal.parent() expects a positive integer')
+  return levels
+}
+
+export function getSignalId (
+  $signal: Pick<SignalMetadataOwner, typeof SEGMENTS>,
+  rootId?: string
+): string | number | undefined {
+  const segments = $signal[SEGMENTS]
+  if (segments.length === 0) throw Error('Can\'t get the id of the root signal')
+  if (segments.length === 1) throw Error('Can\'t get the id of a collection')
+  if (segments[0] === AGGREGATIONS && segments.length === 3) {
+    return getAggregationDocId(segments, rootId)
+  }
+  return segments[segments.length - 1]
+}
+
+export function getSignalCollection ($signal: SignalMetadataOwner): PathSegment | undefined {
+  const segments = $signal[SEGMENTS]
+  if (segments.length === 0) throw Error('Can\'t get the collection of the root signal')
+  if (segments[0] === AGGREGATIONS) {
+    return getAggregationCollectionName(segments)
+  }
+  const collectionFromModel = $signal.constructor?.collection
+  if (typeof collectionFromModel === 'string' && collectionFromModel) {
+    return collectionFromModel
+  }
+  return segments[0]
+}
+
+export function getSignalAssociations ($rawSignal: Pick<SignalMetadataOwner, 'constructor'>): readonly unknown[] {
+  return $rawSignal.constructor.associations || []
+}
diff --git a/packages/teamplay/orm/signalMutationGuards.ts b/packages/teamplay/orm/signalMutationGuards.ts
new file mode 100644
index 0000000..ba90d58
--- /dev/null
+++ b/packages/teamplay/orm/signalMutationGuards.ts
@@ -0,0 +1,21 @@
+import type { PathSegment } from './types/path.ts'
+
+export type MutationTargetSegments = PathSegment[]
+
+export function ensureArrayTargetSegments (
+  segments: MutationTargetSegments,
+  isQuerySignal: boolean
+): MutationTargetSegments {
+  if (segments.length < 2) throw Error('Can\'t mutate array on a collection or root signal')
+  if (isQuerySignal) throw Error('Array mutators can\'t be used on a query signal')
+  return segments
+}
+
+export function ensureValueTargetSegments (
+  segments: MutationTargetSegments,
+  isQuerySignal: boolean
+): MutationTargetSegments {
+  if (segments.length < 2) throw Error('Can\'t mutate on a collection or root signal')
+  if (isQuerySignal) throw Error('Mutators can\'t be used on a query signal')
+  return segments
+}
diff --git a/packages/teamplay/orm/signalPathKind.ts b/packages/teamplay/orm/signalPathKind.ts
new file mode 100644
index 0000000..fc70bb8
--- /dev/null
+++ b/packages/teamplay/orm/signalPathKind.ts
@@ -0,0 +1,9 @@
+export function isPublicCollection (collectionName: unknown): collectionName is string {
+  if (!collectionName) return false
+  return typeof collectionName === 'string' && !isPrivateCollection(collectionName)
+}
+
+export function isPrivateCollection (collectionName: unknown): collectionName is string {
+  if (!collectionName) return false
+  return typeof collectionName === 'string' && /^[_$]/.test(collectionName)
+}
diff --git a/packages/teamplay/orm/signalPathRules.ts b/packages/teamplay/orm/signalPathRules.ts
new file mode 100644
index 0000000..7bb691a
--- /dev/null
+++ b/packages/teamplay/orm/signalPathRules.ts
@@ -0,0 +1,39 @@
+import type { PathSegment } from './types/path.ts'
+
+export const ROOT_DOLLAR_ALIASES: Readonly<Record<string, string>> = {
+  session: '_session',
+  page: '_page',
+  render: '$render',
+  system: '$system'
+}
+
+const REGEX_POSITIVE_INTEGER = /^(?:0|[1-9]\d*)$/
+const REGEX_LEADING_DOLLAR = /^\$/
+
+export function transformRootDollarAlias (
+  segments: readonly PathSegment[],
+  key: string,
+  aliases: Readonly<Record<string, string>> = ROOT_DOLLAR_ALIASES
+): string {
+  if (REGEX_LEADING_DOLLAR.test(key)) key = key.slice(1)
+  if (segments.length === 0) return aliases[key] || key
+  return key
+}
+
+export function maybeTransformToArrayIndex (key: string): string | number {
+  if (REGEX_POSITIVE_INTEGER.test(key)) return +key
+  return key
+}
+
+export function normalizeSignalPropertyKey (
+  segments: readonly PathSegment[],
+  key: string
+): string | number {
+  return maybeTransformToArrayIndex(transformRootDollarAlias(segments, key))
+}
+
+export function pathSegmentsToPattern (segments: readonly PathSegment[]): string {
+  return segments
+    .map(segment => typeof segment === 'number' ? '*' : String(segment))
+    .join('.')
+}
diff --git a/packages/teamplay/orm/signalReads.ts b/packages/teamplay/orm/signalReads.ts
new file mode 100644
index 0000000..f967cd1
--- /dev/null
+++ b/packages/teamplay/orm/signalReads.ts
@@ -0,0 +1,119 @@
+import { AGGREGATIONS, IS_AGGREGATION } from './Aggregation.js'
+import { HASH, IS_QUERY, QUERIES } from './Query.js'
+import { SEGMENTS } from './signalSymbols.ts'
+import type { PathSegment } from './types/path.ts'
+
+export type SignalReadMethod<TValue = unknown> = (segments: PathSegment[]) => TValue
+
+export interface SignalReadOwner {
+  readonly [SEGMENTS]: PathSegment[]
+  readonly [HASH]?: string
+  readonly [IS_QUERY]?: unknown
+  readonly [IS_AGGREGATION]?: unknown
+}
+
+export interface SignalReadContext<TSignal extends SignalReadOwner> {
+  getOwningRootId: ($signal: TSignal) => string | undefined
+  getStorageSegments: ($signal: TSignal) => PathSegment[]
+  isPrivateSegments: (segments: readonly PathSegment[]) => boolean
+  readLogicalRootSnapshot: (rootId: string | undefined, raw: boolean) => unknown
+  readPrivateData: (
+    rootId: string | undefined,
+    segments: readonly PathSegment[],
+    raw: boolean
+  ) => unknown
+  readPublicData: <TValue>(
+    segments: PathSegment[],
+    method: SignalReadMethod<TValue>
+  ) => TValue
+  warn: (message: string, ...args: unknown[]) => void
+  error: (message: string) => void
+}
+
+export function readSignalValue<TSignal extends SignalReadOwner, TValue> (
+  $signal: TSignal,
+  context: SignalReadContext<TSignal>,
+  method: SignalReadMethod<TValue>,
+  rawMethod: SignalReadMethod
+): TValue {
+  const raw = method === rawMethod
+  const segments = $signal[SEGMENTS]
+  const rootId = context.getOwningRootId($signal)
+
+  if (segments.length === 0) {
+    return context.readLogicalRootSnapshot(rootId, raw) as TValue
+  }
+  if ($signal[IS_QUERY]) {
+    return context.readPrivateData(rootId, [QUERIES, getQueryHashSegment($signal), 'docs'], raw) as TValue
+  }
+  if (context.isPrivateSegments(segments)) {
+    return context.readPrivateData(rootId, segments, raw) as TValue
+  }
+  return context.readPublicData(context.getStorageSegments($signal), method)
+}
+
+export function getSignalValue<TSignal extends SignalReadOwner, TValue> (
+  $signal: TSignal,
+  context: SignalReadContext<TSignal>,
+  method: SignalReadMethod<TValue>,
+  rawMethod: SignalReadMethod
+): TValue {
+  if (isQueryIdsValueSignal($signal)) {
+    const ids = readSignalValue($signal, context, method, rawMethod)
+    if (!Array.isArray(ids)) {
+      context.warn('Signal.get() on Query didn\'t find ids', $signal[SEGMENTS])
+      return [] as TValue
+    }
+    return ids
+  }
+  return readSignalValue($signal, context, method, rawMethod)
+}
+
+export function getSignalIds<TSignal extends SignalReadOwner> (
+  $signal: TSignal,
+  context: SignalReadContext<TSignal>
+): Array<string | number> {
+  const rootId = context.getOwningRootId($signal)
+  if ($signal[IS_QUERY]) {
+    const ids = context.readPrivateData(rootId, [QUERIES, getQueryHashSegment($signal), 'ids'], false)
+    if (!Array.isArray(ids)) {
+      context.warn('Signal.getIds() on Query didn\'t find ids', [QUERIES, getQueryHashSegment($signal), 'ids'])
+      return []
+    }
+    return ids as Array<string | number>
+  }
+  if ($signal[IS_AGGREGATION]) {
+    const docs = context.readPrivateData(rootId, $signal[SEGMENTS], false)
+    if (!Array.isArray(docs)) return []
+    return docs.map(getAggregationRowId) as Array<string | number>
+  }
+
+  context.error(
+    'Signal.getIds() can only be used on query signals or aggregation signals. ' +
+    'Received a regular signal: ' + JSON.stringify($signal[SEGMENTS])
+  )
+  return []
+}
+
+export function isQueryIdsValueSignal<TSignal extends SignalReadOwner> (
+  $signal: TSignal
+): boolean {
+  const segments = $signal[SEGMENTS]
+  return segments.length === 3 && segments[0] === QUERIES && segments[2] === 'ids'
+}
+
+export function isAggregationValueSignal<TSignal extends SignalReadOwner> (
+  $signal: TSignal
+): boolean {
+  const segments = $signal[SEGMENTS]
+  return segments.length >= 2 && segments[0] === AGGREGATIONS
+}
+
+function getAggregationRowId (doc: unknown): string | number | undefined {
+  const row = doc as { _id?: string | number, id?: string | number }
+  return row._id || row.id
+}
+
+function getQueryHashSegment<TSignal extends SignalReadOwner> ($signal: TSignal): PathSegment {
+  return $signal[HASH] as PathSegment
+}
diff --git a/packages/teamplay/orm/signalRuntimeAccess.ts b/packages/teamplay/orm/signalRuntimeAccess.ts
new file mode 100644
index 0000000..a1a95b2
--- /dev/null
+++ b/packages/teamplay/orm/signalRuntimeAccess.ts
@@ -0,0 +1,53 @@
+import { IS_QUERY } from './Query.js'
+import { ROOT_ID, getRoot } from './Root.ts'
+import { isPrivateCollectionSegments } from './rootScope.ts'
+import {
+  ensureArrayTargetSegments,
+  ensureValueTargetSegments
+} from './signalMutationGuards.ts'
+import { SEGMENTS } from './signalSymbols.ts'
+import type { PathSegment } from './types/path.ts'
+
+export interface SignalSegmentsOwner {
+  readonly [SEGMENTS]: PathSegment[]
+}
+
+export interface SignalQueryState {
+  readonly [IS_QUERY]?: unknown
+}
+
+export type SignalRuntimeState = SignalSegmentsOwner & SignalQueryState
+
+interface RootIdOwner {
+  readonly [ROOT_ID]?: string
+}
+
+export function getSignalSegments ($signal: SignalSegmentsOwner): PathSegment[] {
+  return $signal[SEGMENTS]
+}
+
+export function getSignalStorageSegments (
+  $signal: SignalSegmentsOwner,
+  segments: PathSegment[] = getSignalSegments($signal)
+): PathSegment[] {
+  return segments
+}
+
+export function getSignalOwningRootId ($signal: SignalSegmentsOwner): string | undefined {
+  const $root = getRoot($signal as never) as RootIdOwner | undefined
+  return ($root || ($signal as RootIdOwner))?.[ROOT_ID]
+}
+
+export function isPrivateSignalSegments (
+  segments: unknown
+): segments is readonly [PathSegment, ...PathSegment[]] {
+  return isPrivateCollectionSegments(segments)
+}
+
+export function ensureArraySignalTarget ($signal: SignalRuntimeState): PathSegment[] {
+  return ensureArrayTargetSegments(getSignalSegments($signal), !!$signal[IS_QUERY])
+}
+
+export function ensureValueSignalTarget ($signal: SignalRuntimeState): PathSegment[] {
+  return ensureValueTargetSegments(getSignalSegments($signal), !!$signal[IS_QUERY])
+}
diff --git a/packages/teamplay/orm/signalRuntimeDescriptor.ts b/packages/teamplay/orm/signalRuntimeDescriptor.ts
new file mode 100644
index 0000000..874cf72
--- /dev/null
+++ b/packages/teamplay/orm/signalRuntimeDescriptor.ts
@@ -0,0 +1,152 @@
+import { SEGMENTS } from './Signal.ts'
+import { isPrivateCollection, isPublicCollection } from './signalPathKind.ts'
+
+const LOCAL_COLLECTION = '$local'
+
+export type SignalRuntimeKind =
+  | 'root'
+  | 'collection'
+  | 'document'
+  | 'nestedValue'
+  | 'localArray'
+  | 'query'
+  | 'aggregation'
+
+export interface SignalRuntimeDescriptor {
+  readonly kind: SignalRuntimeKind
+  readonly segments: ReadonlyArray<string | number>
+  readonly collectionName?: string
+  readonly documentId?: string | number
+  readonly itemPattern?: ReadonlyArray<string | number>
+}
+
+export interface SignalRuntimeDescriptorOptions {
+  readonly kind?: SignalRuntimeKind
+  readonly collectionName?: string
+  readonly documentId?: string | number
+  readonly itemPattern?: ReadonlyArray<string | number>
+  readonly value?: unknown
+}
+
+export const SIGNAL_RUNTIME_DESCRIPTOR = Symbol('teamplay signal runtime descriptor')
+
+export function setSignalRuntimeDescriptor (
+  $signal: unknown,
+  options: SignalRuntimeDescriptorOptions = {}
+): SignalRuntimeDescriptor {
+  const descriptor = describeSignalRuntime($signal, options)
+  Object.defineProperty($signal, SIGNAL_RUNTIME_DESCRIPTOR, {
+    configurable: true,
+    value: descriptor
+  })
+  return descriptor
+}
+
+export function getSignalRuntimeDescriptor (
+  $signal: unknown,
+  options: SignalRuntimeDescriptorOptions = {}
+): SignalRuntimeDescriptor {
+  return getStoredSignalRuntimeDescriptor($signal) ?? describeSignalRuntime($signal, options)
+}
+
+export function describeSignalRuntime (
+  signalOrSegments: unknown,
+  options: SignalRuntimeDescriptorOptions = {}
+): SignalRuntimeDescriptor {
+  const segments = getDescriptorSegments(signalOrSegments)
+  const kind = options.kind ?? inferSignalRuntimeKind(segments, options.value)
+  const collectionName = options.collectionName ?? inferCollectionName(kind, segments)
+  const documentId = options.documentId ?? inferDocumentId(kind, segments)
+  const itemPattern = options.itemPattern ?? inferItemPattern(kind, segments, collectionName, options.value)
+
+  return compactDescriptor({
+    kind,
+    segments,
+    collectionName,
+    documentId,
+    itemPattern
+  })
+}
+
+function getStoredSignalRuntimeDescriptor ($signal: unknown): SignalRuntimeDescriptor | undefined {
+  if (!$signal || (typeof $signal !== 'object' && typeof $signal !== 'function')) return undefined
+  return ($signal as { [SIGNAL_RUNTIME_DESCRIPTOR]?: SignalRuntimeDescriptor })[SIGNAL_RUNTIME_DESCRIPTOR]
+}
+
+function getDescriptorSegments (signalOrSegments: unknown): ReadonlyArray<string | number> {
+  if (Array.isArray(signalOrSegments)) return signalOrSegments.slice()
+  if (!signalOrSegments || (typeof signalOrSegments !== 'object' && typeof signalOrSegments !== 'function')) return []
+  const segments = (signalOrSegments as { [SEGMENTS]?: Array<string | number> })[SEGMENTS]
+  return Array.isArray(segments) ? segments.slice() : []
+}
+
+function inferSignalRuntimeKind (
+  segments: ReadonlyArray<string | number>,
+  value: unknown
+): SignalRuntimeKind {
+  if (segments.length === 0) return 'root'
+  if (segments[0] === LOCAL_COLLECTION && Array.isArray(value)) return 'localArray'
+  if (typeof segments[0] === 'string' && isPublicCollection(segments[0])) {
+    if (segments.length === 1) return 'collection'
+    if (segments.length === 2) return 'document'
+  }
+  return 'nestedValue'
+}
+
+function inferCollectionName (
+  kind: SignalRuntimeKind,
+  segments: ReadonlyArray<string | number>
+): string | undefined {
+  if (kind === 'query' || kind === 'aggregation') return undefined
+  const firstSegment = segments[0]
+  if (typeof firstSegment !== 'string') return undefined
+  if (isPrivateCollection(firstSegment)) return undefined
+  return firstSegment
+}
+
+function inferDocumentId (
+  kind: SignalRuntimeKind,
+  segments: ReadonlyArray<string | number>
+): string | number | undefined {
+  if (kind !== 'document' && kind !== 'nestedValue') return undefined
+  if (typeof segments[0] !== 'string' || !isPublicCollection(segments[0])) return undefined
+  return segments.length >= 2 ? segments[1] : undefined
+}
+
+function inferItemPattern (
+  kind: SignalRuntimeKind,
+  segments: ReadonlyArray<string | number>,
+  collectionName: string | undefined,
+  value: unknown
+): ReadonlyArray<string | number> | undefined {
+  if (kind === 'collection' || kind === 'query' || kind === 'aggregation') {
+    if (!collectionName) return undefined
+    return [collectionName, '*']
+  }
+  if (kind === 'localArray') return [...segments, '*']
+  if (kind === 'nestedValue' && Array.isArray(value)) return [...segments, '*']
+  return undefined
+}
+
+function compactDescriptor (descriptor: {
+  kind: SignalRuntimeKind
+  segments: ReadonlyArray<string | number>
+  collectionName?: string
+  documentId?: string | number
+  itemPattern?: ReadonlyArray<string | number>
+}): SignalRuntimeDescriptor {
+  const result: {
+    kind: SignalRuntimeKind
+    segments: ReadonlyArray<string | number>
+    collectionName?: string
+    documentId?: string | number
+    itemPattern?: ReadonlyArray<string | number>
+  } = {
+    kind: descriptor.kind,
+    segments: Object.freeze(descriptor.segments.slice())
+  }
+  if (descriptor.collectionName !== undefined) result.collectionName = descriptor.collectionName
+  if (descriptor.documentId !== undefined) result.documentId = descriptor.documentId
+  if (descriptor.itemPattern !== undefined) result.itemPattern = Object.freeze(descriptor.itemPattern.slice())
+  return Object.freeze(result)
+}
diff --git a/packages/teamplay/orm/signalStorageMutations.ts b/packages/teamplay/orm/signalStorageMutations.ts
new file mode 100644
index 0000000..e8f4e67
--- /dev/null
+++ b/packages/teamplay/orm/signalStorageMutations.ts
@@ -0,0 +1,58 @@
+import {
+  getIdFieldsForSegments,
+  isIdFieldPath
+} from './idFields.ts'
+import type { PathSegment } from './types/path.ts'
+
+type MaybePromise<TValue> = TValue | Promise<TValue>
+
+export interface SignalStorageMutationContext<TSignal> {
+  getOwningRootId: ($signal: TSignal) => string | undefined
+  isPublicCollection: (segment: PathSegment | undefined) => boolean
+  isPrivateMutationForbidden: () => boolean
+}
+
+export interface SignalStorageMutationHandlers<TResult> {
+  public: (segments: PathSegment[]) => MaybePromise<TResult>
+  private: (rootId: string | undefined, segments: PathSegment[]) => MaybePromise<TResult>
+}
+
+export interface SignalStorageMutationResult<TResult> {
+  skipped: boolean
+  value: TResult | undefined
+}
+
+export async function runSignalStorageMutation<TSignal, TResult> (
+  $signal: TSignal,
+  context: SignalStorageMutationContext<TSignal>,
+  segments: PathSegment[],
+  handlers: SignalStorageMutationHandlers<TResult>
+): Promise<SignalStorageMutationResult<TResult>> {
+  const idFields = getIdFieldsForSegments(segments)
+  if (isIdFieldPath(segments, idFields)) {
+    return { skipped: true, value: undefined }
+  }
+
+  if (context.isPublicCollection(segments[0])) {
+    return {
+      skipped: false,
+      value: await handlers.public(segments)
+    }
+  }
+
+  ensurePrivateMutationAllowed(context)
+  return {
+    skipped: false,
+    value: await handlers.private(context.getOwningRootId($signal), segments)
+  }
+}
+
+export function ensurePrivateMutationAllowed<TSignal> (
+  context: Pick<SignalStorageMutationContext<TSignal>, 'isPrivateMutationForbidden'>
+): void {
+  if (!context.isPrivateMutationForbidden()) return
+  throw Error(`
+    Can't modify private collections data when 'publicOnly' is enabled.
+    On the server you can only work with public collections.
+  `)
+}
diff --git a/packages/teamplay/orm/signalSymbols.ts b/packages/teamplay/orm/signalSymbols.ts
new file mode 100644
index 0000000..f833347
--- /dev/null
+++ b/packages/teamplay/orm/signalSymbols.ts
@@ -0,0 +1,5 @@
+export const SEGMENTS = Symbol('path segments targeting the particular node in the data tree')
+export const ARRAY_METHOD = Symbol('run array method on the signal')
+export const GET = Symbol('get the value of the signal - either observed or raw')
+export const GETTERS = Symbol('get the list of this signal\'s getters')
+export const DEFAULT_GETTERS = ['path', 'id', 'get', 'peek', 'getId', 'map', 'reduce', 'find', 'getIds', 'getExtra', 'getCollection']
diff --git a/packages/teamplay/orm/signalValueMutations.ts b/packages/teamplay/orm/signalValueMutations.ts
new file mode 100644
index 0000000..6221080
--- /dev/null
+++ b/packages/teamplay/orm/signalValueMutations.ts
@@ -0,0 +1,72 @@
+import {
+  getIdFieldsForSegments,
+  isIdFieldPath,
+  isPublicDocPath,
+  normalizeIdFields
+} from './idFields.ts'
+import {
+  ensurePrivateMutationAllowed,
+  type SignalStorageMutationContext
+} from './signalStorageMutations.ts'
+import { SEGMENTS } from './signalSymbols.ts'
+import type { PathSegment } from './types/path.ts'
+
+export interface SignalValueMutationOwner {
+  readonly [SEGMENTS]: PathSegment[]
+}
+
+export interface SignalValueMutationContext<TSignal extends SignalValueMutationOwner>
+  extends SignalStorageMutationContext<TSignal> {
+  setPublicDoc: (segments: PathSegment[], value: unknown) => Promise<unknown> | unknown
+  setPrivateData: (
+    rootId: string | undefined,
+    segments: PathSegment[],
+    value: unknown
+  ) => void
+  deletePublicDoc: (segments: PathSegment[]) => Promise<unknown> | unknown
+  deletePrivateData: (rootId: string | undefined, segments: PathSegment[]) => void
+}
+
+export async function setSignalValue<TSignal extends SignalValueMutationOwner> (
+  $signal: TSignal,
+  context: SignalValueMutationContext<TSignal>,
+  value: unknown
+): Promise<void> {
+  const segments = $signal[SEGMENTS]
+  if (segments.length === 0) throw Error('Can\'t set the root signal data')
+
+  const idFields = getIdFieldsForSegments(segments)
+  if (isIdFieldPath(segments, idFields)) return
+
+  const nextValue = isPublicDocPath(segments)
+    ? normalizeIdFields(value, idFields, segments[1])
+    : value
+
+  if (context.isPublicCollection(segments[0])) {
+    await context.setPublicDoc(segments, nextValue)
+    return
+  }
+
+  ensurePrivateMutationAllowed(context)
+  context.setPrivateData(context.getOwningRootId($signal), segments, nextValue)
+}
+
+export async function deleteSignalValue<TSignal extends SignalValueMutationOwner> (
+  $signal: TSignal,
+  context: SignalValueMutationContext<TSignal>
+): Promise<void> {
+  const segments = $signal[SEGMENTS]
+  if (segments.length === 0) throw Error('Can\'t delete the root signal data')
+
+  const idFields = getIdFieldsForSegments(segments)
+  if (isIdFieldPath(segments, idFields)) return
+
+  if (context.isPublicCollection(segments[0])) {
+    if (segments.length === 1) throw Error('Can\'t delete the whole collection')
+    await context.deletePublicDoc(segments)
+    return
+  }
+
+  ensurePrivateMutationAllowed(context)
+  context.deletePrivateData(context.getOwningRootId($signal), segments)
+}
diff --git a/packages/teamplay/orm/sub.js b/packages/teamplay/orm/sub.js
deleted file mode 100644
index d83485c..0000000
--- a/packages/teamplay/orm/sub.js
+++ /dev/null
@@ -1,151 +0,0 @@
-import { isAggregationHeader, isAggregationFunction, isClientAggregationFunction } from '@teamplay/utils/aggregation'
-import Signal, { SEGMENTS, isPublicCollectionSignal, isPublicDocumentSignal } from './Signal.js'
-import { docSubscriptions } from './Doc.js'
-import { querySubscriptions, getQuerySignal } from './Query.js'
-import { aggregationSubscriptions, getAggregationSignal } from './Aggregation.js'
-import { getRoot } from './Root.js'
-import isServer from '../utils/isServer.js'
-
-export default function sub ($signal, params) {
-  // TODO: temporarily disable support for multiple subscriptions
-  //       since this has to be properly cached using useDeferredSignal() in useSub()
-  // if (Array.isArray($signal)) {
-  //   const res = $signal.map(args => Array.isArray(args) ? sub(...args) : sub(args))
-  //   if (res.some($s => $s.then)) return Promise.all(res)
-  //   return res
-  // }
-  if (Array.isArray($signal)) throw Error('sub() does not support multiple subscriptions yet')
-  if (isPublicDocumentSignal($signal)) {
-    if (arguments.length > 1) throw Error(ERRORS.subDocArguments(...arguments))
-    return doc$($signal)
-  } else if (isPublicCollectionSignal($signal)) {
-    if (arguments.length !== 2) throw Error(ERRORS.subQueryArguments(...arguments))
-    return query$($signal, params)
-  } else if (isClientAggregationFunction($signal)) {
-    return getAggregationFromFunction($signal, $signal.collection, params)
-  } else if (isAggregationHeader($signal)) {
-    params = {
-      $aggregationName: $signal.name,
-      $params: sanitizeAggregationParams(params)
-    }
-    return aggregation$($signal.collection, params)
-  } else if (isAggregationFunction($signal)) {
-    if (isServer) {
-      if (!params?.$collection) throw Error(ERRORS.subServerAggregationCollection($signal, params))
-      params = { ...params }
-      const collection = params.$collection
-      delete params.$collection
-      return getAggregationFromFunction($signal, collection, params)
-    } else {
-      throw Error(ERRORS.gotAggregationFunction($signal))
-    }
-  } else if (typeof $signal === 'function' && !($signal instanceof Signal)) {
-    return api$($signal, params)
-  } else {
-    throw Error('Invalid args passed for sub()')
-  }
-}
-
-function getAggregationFromFunction (fn, collection, params) {
-  params = sanitizeAggregationParams(params) // clones it, so mutation becomes safe
-  let session
-  if (params.$session) {
-    session = params.$session
-    delete params.$session
-  }
-  session ??= {}
-  // should match the context in @teamplay/backend/features/serverAggregate.js
-  const context = { collection, session, isServer }
-  params = fn(params, context)
-  if (Array.isArray(params)) params = { $aggregate: params }
-  return aggregation$(collection, params)
-}
-
-function doc$ ($doc) {
-  const promise = docSubscriptions.subscribe($doc)
-  if (!promise) return $doc
-  return new Promise(resolve => promise.then(() => resolve($doc)))
-}
-
-function query$ ($collection, params) {
-  const collectionName = $collection[SEGMENTS][0]
-  if (typeof params !== 'object') throw Error(ERRORS.queryParamsObject(collectionName, params))
-  const signalOptions = getQuerySignalOptions($collection)
-  if (params?.$aggregate || params?.$aggregationName) return aggregation$(collectionName, params, signalOptions)
-  const $query = getQuerySignal(collectionName, params, signalOptions)
-  const promise = querySubscriptions.subscribe($query)
-  if (!promise) return $query
-  return new Promise(resolve => promise.then(() => resolve($query)))
-}
-
-function aggregation$ (collectionName, params, signalOptions) {
-  const $aggregationQuery = getAggregationSignal(collectionName, params, signalOptions)
-  const promise = aggregationSubscriptions.subscribe($aggregationQuery)
-  if (!promise) return $aggregationQuery
-  return new Promise(resolve => promise.then(() => resolve($aggregationQuery)))
-}
-
-function api$ (fn, args) {
-  throw Error('sub() for async functions is not implemented yet')
-}
-
-// aggregation params get transferred to the server
-// and while doing so if some value is 'undefined', it actually gets transferred as 'null'
-// which breaks logic of setting default values in the aggregation function.
-// That's why we have to explicitly remove 'undefined' values from the aggregation params.
-// This can be easily done by serializing and deserializing it to JSON.
-function sanitizeAggregationParams (params) {
-  return JSON.parse(JSON.stringify(params))
-}
-
-function getQuerySignalOptions ($collection) {
-  const $root = getRoot($collection)
-  if (!$root) return undefined
-  return { root: $root }
-}
-
-const ERRORS = {
-  subDocArguments: ($signal, ...args) => `
-    sub($doc) accepts only 1 argument - the document signal to subscribe to
-    Doc: ${$signal[SEGMENTS]}
-    Got args: ${[$signal, ...args]}
-  `,
-  subQueryArguments: ($signal, params, ...args) => `
-    sub($collection, params) accepts 2 arguments - the collection signal and an object with query params.
-    If you want to subscribe to all documents in a collection, pass an empty object: sub($collection, {}).
-    Collection: ${$signal[SEGMENTS]}
-    Params: ${params}
-    Got args: ${[$signal, params, ...args]}
-  `,
-  queryParamsObject: (collectionName, params) => `
-    sub($collection, params):
-      Params must be an object.
-      If you want to subscribe to all documents in a collection, pass an empty object: sub($collection, {}).
-
-      Got:
-        collectionName: ${collectionName}
-        params: ${params}
-  `,
-  gotAggregationFunction: aggregationFn => `
-    sub($$aggregation, params):
-      Got aggregation function itself instead of the aggregation header.
-      Looks like client-side code transformation did not work properly and your
-      aggregation() function was not transformed into an __aggregationHeader().
-      Make sure you only use aggregation() function inside project's 'model' folder using
-      import { aggregation } from 'startupjs'
-
-      Got:
-        ${aggregationFn.toString()}
-  `,
-  subServerAggregationCollection: ($signal, params) => `
-    sub($$aggregation, params):
-      Server-side aggregation function must receive the collection name from the params.
-      Make sure you pass the collection name as $collection in the params object
-      when running aggregation from the server code:
-      sub($$aggregation, { $collection: 'collectionName', ...actualParams })
-
-      Got:
-        Aggregation: ${$signal}
-        Params: ${params}
-  `
-}
diff --git a/packages/teamplay/orm/sub.ts b/packages/teamplay/orm/sub.ts
new file mode 100644
index 0000000..037158f
--- /dev/null
+++ b/packages/teamplay/orm/sub.ts
@@ -0,0 +1,276 @@
+import { isAggregationHeader, isAggregationFunction, isClientAggregationFunction } from '@teamplay/utils/aggregation'
+import type { AggregationFunction, AggregationParams, ClientAggregationFunction } from '@teamplay/utils/aggregation'
+import Signal, { SEGMENTS, isPublicCollectionSignal, isPublicDocumentSignal } from './Signal.ts'
+import { docSubscriptions } from './Doc.js'
+import { querySubscriptions, getQuerySignal } from './Query.js'
+import type { QuerySignalOptions } from './Query.js'
+import { aggregationSubscriptions, getAggregationSignal } from './Aggregation.js'
+import { getRoot } from './Root.ts'
+import isServer from '../utils/isServer.ts'
+import type {
+  CollectionSignal,
+  DocumentSignal,
+  MaybePromise,
+  MaybePromiseSubResult,
+  QueryParams,
+  RegisteredAggregationInput,
+  SignalBaseInstance,
+  SignalModelConstructor,
+  SubResult,
+  TypedAggregationInput,
+  TypedAggregationSignal,
+  WildcardSignalPath
+} from './Signal.ts'
+
+/**
+ * Subscribe to an aggregation with explicit output typing outside React.
+ * @param $aggregation Typed aggregation input.
+ * @param params Parameters passed to the aggregation.
+ */
+export default function sub<
+  TDocument,
+  TDocumentModel extends SignalModelConstructor<TDocument>
+> (
+  $aggregation: TypedAggregationInput<TDocument, TDocumentModel>,
+  params?: AggregationParams
+): MaybePromise<TypedAggregationSignal<TDocument, TDocumentModel>>
+
+/**
+ * Subscribe to a registered collection aggregation outside React.
+ * @param $aggregation Aggregation header generated by StartupJS model loading.
+ * @param params Parameters passed to the aggregation.
+ */
+export default function sub<TCollection extends string, TOutput = unknown> (
+  $aggregation: RegisteredAggregationInput<TCollection, TOutput>,
+  params?: AggregationParams
+): MaybePromise<SubResult<RegisteredAggregationInput<TCollection, TOutput>>>
+
+/**
+ * Subscribe to a client aggregation outside React.
+ * @param $aggregation Aggregation function created with `aggregation(collection, fn)`.
+ * @param params Parameters passed to the aggregation.
+ */
+export default function sub<TOutput, TCollection extends string> (
+  $aggregation: ClientAggregationFunction<TOutput, TCollection>,
+  params?: AggregationParams
+): MaybePromise<SubResult<ClientAggregationFunction<TOutput, TCollection>>>
+
+/**
+ * Subscribe to an unregistered aggregation outside React.
+ * @param $aggregation Aggregation function.
+ * @param params Parameters passed to the aggregation.
+ */
+export default function sub<TOutput = unknown, TCollection extends string = string> (
+  $aggregation: AggregationFunction<TOutput, TCollection>,
+  params?: AggregationParams
+): MaybePromise<SubResult<AggregationFunction<TOutput, TCollection>>>
+
+/**
+ * Subscribe to a document signal outside React and return it when ready.
+ * @param $signal Document signal to subscribe to.
+ */
+export default function sub<TSignal extends DocumentSignal<any, any, any>> (
+  $signal: TSignal
+): MaybePromiseSubResult<TSignal>
+
+/**
+ * Subscribe to a collection query outside React and return a query signal when ready.
+ * @param $collection Collection signal to query.
+ * @param params Mongo-style query params, including filters and `$sort`.
+ */
+export default function sub<
+  TDocument,
+  TCollectionModel extends SignalModelConstructor<TDocument[]>,
+  TDocumentModel extends SignalModelConstructor<TDocument>,
+  TCollectionPath extends WildcardSignalPath
+> (
+  $collection: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>,
+  params: QueryParams<TDocument>
+): MaybePromiseSubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, QueryParams<TDocument>>
+
+export default function sub ($signal: unknown, params?: unknown): unknown {
+  // TODO: temporarily disable support for multiple subscriptions
+  //       since this has to be properly cached using useDeferredSignal() in useSub()
+  // if (Array.isArray($signal)) {
+  //   const res = $signal.map(args => Array.isArray(args) ? sub(...args) : sub(args))
+  //   if (res.some($s => $s.then)) return Promise.all(res)
+  //   return res
+  // }
+  if (Array.isArray($signal)) throw Error('sub() does not support multiple subscriptions yet')
+  if (isRuntimePublicDocumentSignal($signal)) {
+    if (arguments.length > 1) {
+      throw Error(ERRORS.subDocArguments($signal, ...Array.from(arguments).slice(1)))
+    }
+    return doc$($signal)
+  } else if (isRuntimePublicCollectionSignal($signal)) {
+    if (arguments.length !== 2) {
+      throw Error(ERRORS.subQueryArguments($signal, params, ...Array.from(arguments).slice(2)))
+    }
+    return query$($signal, params)
+  } else if (isClientAggregationFunction($signal)) {
+    return getAggregationFromFunction($signal, $signal.collection, params)
+  } else if (isAggregationHeader($signal)) {
+    const aggregationParams = {
+      $aggregationName: $signal.name,
+      $params: sanitizeAggregationParams(params)
+    }
+    return aggregation$($signal.collection, aggregationParams)
+  } else if (isAggregationFunction($signal)) {
+    if (isServer) {
+      const serverParams = asRecord(params)
+      const collection = serverParams?.$collection
+      if (typeof collection !== 'string' || !collection) {
+        throw Error(ERRORS.subServerAggregationCollection($signal, params))
+      }
+      const aggregationParams = { ...serverParams }
+      delete aggregationParams.$collection
+      return getAggregationFromFunction($signal, collection, aggregationParams)
+    } else {
+      throw Error(ERRORS.gotAggregationFunction($signal))
+    }
+  } else if (isApiFunction($signal)) {
+    return api$($signal, params)
+  } else {
+    throw Error('Invalid args passed for sub()')
+  }
+}
+
+function getAggregationFromFunction (
+  fn: AggregationFunction<unknown, string> | ClientAggregationFunction<unknown, string>,
+  collection: string,
+  params?: unknown
+): SignalBaseInstance | Promise<SignalBaseInstance> {
+  const aggregationParams = sanitizeAggregationParams(params) as AggregationParams
+  let session: unknown
+  if (isRecord(aggregationParams) && aggregationParams.$session) {
+    session = aggregationParams.$session
+    delete aggregationParams.$session
+  }
+  session ??= {}
+  // should match the context in @teamplay/backend/features/serverAggregate.js
+  const context = { collection, session, isServer }
+  const result = fn(aggregationParams, context)
+  return aggregation$(collection, Array.isArray(result) ? { $aggregate: result } : result)
+}
+
+function doc$ ($doc: SignalBaseInstance): SignalBaseInstance | Promise<SignalBaseInstance> {
+  const promise = docSubscriptions.subscribe($doc)
+  if (!promise) return $doc
+  return new Promise(resolve => promise.then(() => resolve($doc)))
+}
+
+function query$ ($collection: SignalBaseInstance, params: unknown): SignalBaseInstance | Promise<SignalBaseInstance> {
+  const collectionName = $collection[SEGMENTS][0]
+  if (typeof collectionName !== 'string') throw Error(ERRORS.queryCollectionName($collection))
+  if (typeof params !== 'object') throw Error(ERRORS.queryParamsObject(collectionName, params))
+  const signalOptions = getQuerySignalOptions($collection)
+  const queryParams = params as Record<string, unknown> | null
+  if (queryParams?.$aggregate || queryParams?.$aggregationName) return aggregation$(collectionName, params, signalOptions)
+  const $query = getQuerySignal(collectionName, params, signalOptions)
+  const promise = querySubscriptions.subscribe($query)
+  if (!promise) return $query
+  return new Promise(resolve => promise.then(() => resolve($query)))
+}
+
+function aggregation$ (
+  collectionName: string,
+  params: unknown,
+  signalOptions?: QuerySignalOptions
+): SignalBaseInstance | Promise<SignalBaseInstance> {
+  const $aggregationQuery = getAggregationSignal(collectionName, params, signalOptions)
+  const promise = aggregationSubscriptions.subscribe($aggregationQuery)
+  if (!promise) return $aggregationQuery
+  return new Promise(resolve => promise.then(() => resolve($aggregationQuery)))
+}
+
+function api$ (_fn: (...args: unknown[]) => unknown, _args: unknown): never {
+  throw Error('sub() for async functions is not implemented yet')
+}
+
+// aggregation params get transferred to the server
+// and while doing so if some value is 'undefined', it actually gets transferred as 'null'
+// which breaks logic of setting default values in the aggregation function.
+// That's why we have to explicitly remove 'undefined' values from the aggregation params.
+// This can be easily done by serializing and deserializing it to JSON.
+function sanitizeAggregationParams<TParams> (params: TParams): TParams {
+  return JSON.parse(JSON.stringify(params) as string)
+}
+
+function getQuerySignalOptions ($collection: SignalBaseInstance): QuerySignalOptions | undefined {
+  const $root = getRoot($collection)
+  if (!$root) return undefined
+  return { root: $root }
+}
+
+function isRecord (value: unknown): value is Record<string, unknown> {
+  return value != null && typeof value === 'object' && !Array.isArray(value)
+}
+
+function asRecord (value: unknown): Record<string, unknown> | undefined {
+  return isRecord(value) ? value : undefined
+}
+
+function isRuntimePublicDocumentSignal (value: unknown): value is SignalBaseInstance {
+  return isPublicDocumentSignal(value)
+}
+
+function isRuntimePublicCollectionSignal (value: unknown): value is SignalBaseInstance {
+  return isPublicCollectionSignal(value)
+}
+
+function isApiFunction (value: unknown): value is (...args: unknown[]) => unknown {
+  return typeof value === 'function' && !(value instanceof Signal)
+}
+
+const ERRORS = {
+  subDocArguments: ($signal: SignalBaseInstance, ...args: unknown[]) => `
+    sub($doc) accepts only 1 argument - the document signal to subscribe to
+    Doc: ${$signal[SEGMENTS]}
+    Got args: ${[$signal, ...args]}
+  `,
+  subQueryArguments: ($signal: SignalBaseInstance, params: unknown, ...args: unknown[]) => `
+    sub($collection, params) accepts 2 arguments - the collection signal and an object with query params.
+    If you want to subscribe to all documents in a collection, pass an empty object: sub($collection, {}).
+    Collection: ${$signal[SEGMENTS]}
+    Params: ${params}
+    Got args: ${[$signal, params, ...args]}
+  `,
+  queryCollectionName: ($signal: SignalBaseInstance) => `
+    sub($collection, params):
+      Collection signal must have a string collection name.
+
+      Got:
+        path: ${$signal[SEGMENTS]}
+  `,
+  queryParamsObject: (collectionName: string, params: unknown) => `
+    sub($collection, params):
+      Params must be an object.
+      If you want to subscribe to all documents in a collection, pass an empty object: sub($collection, {}).
+
+      Got:
+        collectionName: ${collectionName}
+        params: ${params}
+  `,
+  gotAggregationFunction: (aggregationFn: AggregationFunction) => `
+    sub(_aggregation, params):
+      Got aggregation function itself instead of the aggregation header.
+      Looks like client-side code transformation did not work properly and your
+      aggregation() function was not transformed into an __aggregationHeader().
+      Make sure you only use aggregation() function inside project's 'model' folder using
+      import { aggregation } from 'startupjs'
+
+      Got:
+        ${aggregationFn.toString()}
+  `,
+  subServerAggregationCollection: ($signal: AggregationFunction, params: unknown) => `
+    sub(_aggregation, params):
+      Server-side aggregation function must receive the collection name from the params.
+      Make sure you pass the collection name as $collection in the params object
+      when running aggregation from the server code:
+      sub(_aggregation, { $collection: 'collectionName', ...actualParams })
+
+      Got:
+        Aggregation: ${$signal}
+        Params: ${params}
+  `
+}
diff --git a/packages/teamplay/orm/subscriptionGcDelay.js b/packages/teamplay/orm/subscriptionGcDelay.ts
similarity index 74%
rename from packages/teamplay/orm/subscriptionGcDelay.js
rename to packages/teamplay/orm/subscriptionGcDelay.ts
index 649d038..3f485c1 100644
--- a/packages/teamplay/orm/subscriptionGcDelay.js
+++ b/packages/teamplay/orm/subscriptionGcDelay.ts
@@ -5,11 +5,11 @@ const DEFAULT_SUBSCRIPTION_GC_DELAY = 0
 
 let subscriptionGcDelay = getDefaultSubscriptionGcDelay()
 
-export function getSubscriptionGcDelay () {
+export function getSubscriptionGcDelay (): number {
   return subscriptionGcDelay
 }
 
-export function setSubscriptionGcDelay (ms) {
+export function setSubscriptionGcDelay (ms?: number | null): number {
   if (ms == null) {
     subscriptionGcDelay = getDefaultSubscriptionGcDelay()
     return subscriptionGcDelay
@@ -21,12 +21,12 @@ export function setSubscriptionGcDelay (ms) {
   return subscriptionGcDelay
 }
 
-export function getDefaultSubscriptionGcDelay () {
+export function getDefaultSubscriptionGcDelay (): number {
   return isCompatEnv()
     ? DEFAULT_COMPAT_SUBSCRIPTION_GC_DELAY
     : DEFAULT_SUBSCRIPTION_GC_DELAY
 }
 
-export function __resetSubscriptionGcDelayForTests () {
+export function __resetSubscriptionGcDelayForTests (): void {
   subscriptionGcDelay = getDefaultSubscriptionGcDelay()
 }
diff --git a/packages/teamplay/orm/types/baseMethods.ts b/packages/teamplay/orm/types/baseMethods.ts
new file mode 100644
index 0000000..00d1457
--- /dev/null
+++ b/packages/teamplay/orm/types/baseMethods.ts
@@ -0,0 +1,51 @@
+export interface SignalMetadataMethods {
+  path: () => string
+  leaf: () => string
+  parent: (levels?: number) => unknown
+  id: () => string
+  getId: () => string | number
+  getCollection: () => string
+  getAssociations: () => readonly unknown[]
+}
+
+export interface SignalValueMethods<TValue> {
+  get: () => TValue
+  peek: () => TValue
+  set: (value: TValue) => Promise<void>
+  assign: (value: NonNullable<TValue> extends object ? Partial<NonNullable<TValue>> : never) => Promise<void>
+  del: () => Promise<void>
+  increment: (value?: number) => Promise<number>
+}
+
+export interface SignalArrayReaderMethods<TItem> {
+  readonly [Symbol.iterator]: () => IterableIterator<TItem>
+  map: <TResult>(callback: (value: TItem, index: number, array: TItem[]) => TResult, thisArg?: any) => TResult[]
+  reduce: {
+    (callback: (previousValue: TItem, currentValue: TItem, currentIndex: number, array: TItem[]) => TItem): TItem
+    (callback: (previousValue: TItem, currentValue: TItem, currentIndex: number, array: TItem[]) => TItem, initialValue: TItem): TItem
+    <TResult>(
+      callback: (previousValue: TResult, currentValue: TItem, currentIndex: number, array: TItem[]) => TResult,
+      initialValue: TResult
+    ): TResult
+  }
+  find: (predicate: (value: TItem, index: number, obj: TItem[]) => unknown, thisArg?: any) => TItem | undefined
+}
+
+export interface SignalArrayMutatorMethods<TItem> {
+  push: (value: TItem) => Promise<unknown>
+  pop: () => Promise<TItem | undefined>
+  unshift: (value: TItem) => Promise<unknown>
+  shift: () => Promise<TItem | undefined>
+  insert: (index: number, values: TItem | TItem[]) => Promise<unknown>
+  remove: (index: number, howMany?: number) => Promise<unknown>
+  move: (from: number, to: number, howMany?: number) => Promise<unknown>
+}
+
+export interface SignalStringMutatorMethods {
+  stringInsert: (index: number, text: string) => Promise<unknown>
+  stringRemove: (index: number, howMany?: number) => Promise<unknown>
+}
+
+export interface SignalCollectionMethods<TDocument> extends SignalArrayReaderMethods<TDocument>, SignalArrayMutatorMethods<TDocument> {
+  add: (value: TDocument) => Promise<string>
+}
diff --git a/packages/teamplay/orm/types/jsonSchema.ts b/packages/teamplay/orm/types/jsonSchema.ts
new file mode 100644
index 0000000..325c3b3
--- /dev/null
+++ b/packages/teamplay/orm/types/jsonSchema.ts
@@ -0,0 +1,154 @@
+export interface JsonSchemaObject {
+  readonly type?: string | readonly string[]
+  readonly properties?: Record<string, JsonSchema>
+  readonly items?: JsonSchema | readonly JsonSchema[]
+  readonly required?: readonly string[] | boolean
+  readonly enum?: readonly unknown[]
+  readonly const?: unknown
+  readonly additionalProperties?: boolean | JsonSchema
+  readonly patternProperties?: Record<string, JsonSchema>
+  readonly [keyword: string]: unknown
+}
+
+export type JsonSchema = boolean | JsonSchemaObject
+
+export interface ZodLikeSchema {
+  readonly _output?: unknown
+  readonly _zod?: {
+    readonly output?: unknown
+  }
+}
+
+export type InferZodSchema<TSchema> =
+  TSchema extends { readonly _output?: infer Output }
+    ? NonNullable<Output>
+    : TSchema extends { readonly _zod?: { readonly output?: infer Output } }
+      ? NonNullable<Output>
+      : unknown
+
+type Prettify<TValue> = {
+  [K in keyof TValue]: TValue[K]
+}
+
+type PrimitiveFromJsonType<TType> =
+  TType extends readonly unknown[] ? PrimitiveFromJsonType<TType[number]>
+    : TType extends 'string' ? string
+      : TType extends 'number' ? number
+        : TType extends 'integer' ? number
+          : TType extends 'boolean' ? boolean
+            : TType extends 'null' ? null
+              : TType extends 'object' | 'array' ? never
+                : unknown
+
+type JsonTypeIncludes<TType, TExpected extends string> =
+  TType extends TExpected
+    ? true
+    : TType extends readonly unknown[]
+      ? TExpected extends TType[number] ? true : false
+      : false
+
+type IsJsonTypeValue<TValue> =
+  TValue extends string ? true
+    : TValue extends readonly string[] ? true
+      : false
+
+type IsFullObjectSchema<TSchema> =
+  TSchema extends { readonly type: infer Type }
+    ? Type extends 'object'
+      ? true
+      : Type extends readonly unknown[]
+        ? 'object' extends Type[number] ? true : false
+        : false
+    : false
+
+type SimplifiedProperties<TSchema> = {
+  [K in keyof TSchema as K extends string ? K : never]: TSchema[K]
+}
+
+type HasSimplifiedProperties<TSchema> =
+  keyof SimplifiedProperties<TSchema> extends never ? false : true
+
+type SchemaProperties<TSchema> =
+  TSchema extends { readonly properties: infer Properties }
+    ? IsFullObjectSchema<TSchema> extends true
+      ? Properties
+      : HasSimplifiedProperties<TSchema> extends true
+        ? SimplifiedProperties<TSchema>
+        : Record<string, never>
+    : HasSimplifiedProperties<TSchema> extends true
+      ? SimplifiedProperties<TSchema>
+      : Record<string, never>
+
+type ExplicitRequiredKeys<TSchema, TProperties> =
+  TSchema extends { readonly required?: infer Required }
+    ? Required extends readonly string[]
+      ? Extract<Required[number], keyof TProperties & string>
+      : never
+    : never
+
+type SimplifiedRequiredKeys<TProperties> = {
+  [K in keyof TProperties & string]: TProperties[K] extends { readonly required?: true } ? K : never
+}[keyof TProperties & string]
+
+type RequiredKeys<TSchema, TProperties> =
+  ExplicitRequiredKeys<TSchema, TProperties> | SimplifiedRequiredKeys<TProperties>
+
+type PatternPropertiesFromJsonSchema<TSchema> =
+  TSchema extends { readonly patternProperties?: infer PatternProperties }
+    ? PatternProperties extends Record<string, infer PatternSchema>
+      ? Record<string, FromJsonSchema<PatternSchema>>
+      : {}
+    : {}
+
+type AdditionalPropertiesFromJsonSchema<TSchema> =
+  TSchema extends { readonly additionalProperties?: infer AdditionalProperties }
+    ? AdditionalProperties extends JsonSchema
+      ? Record<string, FromJsonSchema<AdditionalProperties>>
+      : {}
+    : {}
+
+type ObjectFromJsonSchema<TSchema> =
+  SchemaProperties<TSchema> extends infer Properties
+    ? Properties extends Record<string, unknown>
+      ? Prettify<{
+        [K in RequiredKeys<TSchema, Properties>]-?: FromJsonSchema<Properties[K]>
+      } & {
+        [K in Exclude<keyof Properties & string, RequiredKeys<TSchema, Properties>>]?: FromJsonSchema<Properties[K]>
+      } & PatternPropertiesFromJsonSchema<TSchema> & AdditionalPropertiesFromJsonSchema<TSchema>>
+      : Record<string, unknown>
+    : Record<string, unknown>
+
+type ArrayFromJsonSchema<TSchema> =
+  TSchema extends { readonly items?: infer Items }
+    ? Items extends readonly [infer First, ...infer Rest]
+      ? readonly [FromJsonSchema<First>, ...{ [K in keyof Rest]: FromJsonSchema<Rest[K]> }]
+      : Items extends JsonSchema
+        ? Array<FromJsonSchema<Items>>
+        : unknown[]
+    : unknown[]
+
+type TypeValueFromJsonSchema<TSchema, TType> =
+  PrimitiveFromJsonType<TType> |
+  (JsonTypeIncludes<TType, 'object'> extends true ? ObjectFromJsonSchema<TSchema> : never) |
+  (JsonTypeIncludes<TType, 'array'> extends true ? ArrayFromJsonSchema<TSchema> : never)
+
+export type FromJsonSchema<TSchema> =
+  TSchema extends false
+    ? never
+    : TSchema extends true
+      ? unknown
+      : TSchema extends { readonly const: infer Const }
+        ? Const extends JsonSchemaObject
+          ? ObjectFromJsonSchema<TSchema>
+          : Const
+        : TSchema extends { readonly enum: infer Enum }
+          ? Enum extends ReadonlyArray<infer EnumValue>
+            ? EnumValue
+            : ObjectFromJsonSchema<TSchema>
+          : TSchema extends { readonly type: infer Type }
+            ? IsJsonTypeValue<Type> extends true
+              ? TypeValueFromJsonSchema<TSchema, Type>
+              : ObjectFromJsonSchema<TSchema>
+            : HasSimplifiedProperties<TSchema> extends true
+              ? ObjectFromJsonSchema<TSchema>
+              : unknown
diff --git a/packages/teamplay/orm/types/modelManifest.ts b/packages/teamplay/orm/types/modelManifest.ts
new file mode 100644
index 0000000..a82c9c1
--- /dev/null
+++ b/packages/teamplay/orm/types/modelManifest.ts
@@ -0,0 +1,81 @@
+import type { Signal as BaseSignal } from '../SignalBase.ts'
+import type {
+  CollectionSpec,
+  JsonSchemaSpec,
+  SignalClass
+} from './signal.ts'
+
+export interface ModelEntry<
+  TModel extends SignalClass<any> = SignalClass<any>,
+  TSchema = unknown
+> {
+  default?: TModel
+  schema?: TSchema
+  access?: unknown
+  [key: string]: unknown
+}
+
+export type ModelManifest = Record<string, ModelEntry>
+
+type StringKey<TValue> = Extract<keyof TValue, string>
+
+type CollectionManifestKey<TKey extends string> =
+  TKey extends ''
+    ? never
+    : TKey extends `${string}.${string}`
+      ? never
+      : TKey extends `${string}*${string}`
+        ? never
+        : TKey
+
+type CollectionManifestKeys<TModels> = {
+  [K in StringKey<TModels>]: CollectionManifestKey<K>
+}[StringKey<TModels>]
+
+type ModelPathManifestKey<TKey extends string> =
+  TKey extends ''
+    ? never
+    : TKey extends `${string}*${string}`
+      ? TKey
+      : never
+
+type ModelPathManifestKeys<TModels> = {
+  [K in StringKey<TModels>]: ModelPathManifestKey<K>
+}[StringKey<TModels>]
+
+type ManifestEntry<TModels, TKey extends string> =
+  TKey extends keyof TModels ? TModels[TKey] : {}
+
+type ModelFromEntry<
+  TEntry,
+  TFallback extends SignalClass<any> = typeof BaseSignal
+> =
+  TEntry extends { default: infer TModel }
+    ? TModel extends SignalClass<any>
+      ? TModel
+      : TFallback
+    : TFallback
+
+type SchemaFromEntry<TEntry> =
+  TEntry extends { schema: infer TSchema } ? TSchema : never
+
+type CollectionSpecFromManifestEntry<TModels, TCollection extends string> =
+  [SchemaFromEntry<ManifestEntry<TModels, TCollection>>] extends [never]
+    ? CollectionSpec<
+        unknown,
+        ModelFromEntry<ManifestEntry<TModels, TCollection>>,
+        ModelFromEntry<ManifestEntry<TModels, `${TCollection}.*`>>
+      >
+    : JsonSchemaSpec<
+        SchemaFromEntry<ManifestEntry<TModels, TCollection>>,
+        ModelFromEntry<ManifestEntry<TModels, TCollection>>,
+        ModelFromEntry<ManifestEntry<TModels, `${TCollection}.*`>>
+      >
+
+export type CollectionsFromManifest<TModels extends Record<string, any>> = {
+  [K in CollectionManifestKeys<TModels>]: CollectionSpecFromManifestEntry<TModels, K>
+}
+
+export type PathModelsFromManifest<TModels extends Record<string, any>> = {
+  [K in ModelPathManifestKeys<TModels> as ManifestEntry<TModels, K> extends { default: any } ? K : never]: ModelFromEntry<ManifestEntry<TModels, K>>
+}
diff --git a/packages/teamplay/orm/types/path.ts b/packages/teamplay/orm/types/path.ts
new file mode 100644
index 0000000..b519b4c
--- /dev/null
+++ b/packages/teamplay/orm/types/path.ts
@@ -0,0 +1,24 @@
+export type PathSegment = string | number
+export type SignalPath = readonly PathSegment[]
+export type WildcardPathSegment = PathSegment | '*'
+export type WildcardSignalPath = readonly WildcardPathSegment[]
+
+export type AppendPath<TPath extends WildcardSignalPath, TSegment extends WildcardPathSegment> =
+  readonly [...TPath, TSegment]
+
+type SegmentPattern<TSegment> =
+  TSegment extends '*' ? '*'
+    : TSegment extends number ? '*'
+      : TSegment extends string ? TSegment
+        : never
+
+export type JoinPath<TPath extends WildcardSignalPath> =
+  TPath extends readonly []
+    ? ''
+    : TPath extends readonly [infer Head]
+      ? SegmentPattern<Head>
+      : TPath extends readonly [infer Head, ...infer Rest]
+        ? Rest extends WildcardSignalPath
+          ? `${SegmentPattern<Head>}.${JoinPath<Rest>}`
+          : never
+        : string
diff --git a/packages/teamplay/orm/types/query.ts b/packages/teamplay/orm/types/query.ts
new file mode 100644
index 0000000..45cfc59
--- /dev/null
+++ b/packages/teamplay/orm/types/query.ts
@@ -0,0 +1,54 @@
+type IsPlainObject<TValue> =
+  NonNullable<TValue> extends readonly unknown[] ? false
+    : NonNullable<TValue> extends object ? true
+      : false
+
+type QueryPath<TValue> =
+  NonNullable<TValue> extends object
+    ? {
+        [K in keyof NonNullable<TValue> & string]:
+        IsPlainObject<NonNullable<TValue>[K]> extends true
+          ? K | `${K}.${QueryPath<NonNullable<TValue>[K]>}`
+          : K
+      }[keyof NonNullable<TValue> & string]
+    : never
+
+type QueryPathValue<TValue, TPath extends string> =
+  TPath extends `${infer Head}.${infer Tail}`
+    ? Head extends keyof NonNullable<TValue>
+      ? QueryPathValue<NonNullable<TValue>[Head], Tail>
+      : never
+    : TPath extends keyof NonNullable<TValue>
+      ? NonNullable<TValue>[TPath]
+      : never
+
+type QueryComparable<TValue> =
+  NonNullable<TValue> extends ReadonlyArray<infer Item>
+    ? Item | NonNullable<TValue>
+    : NonNullable<TValue>
+
+type QueryValue<TValue> =
+  | QueryComparable<TValue>
+  | {
+    $eq?: QueryComparable<TValue>
+    $ne?: QueryComparable<TValue>
+    $in?: Array<QueryComparable<TValue>>
+    $nin?: Array<QueryComparable<TValue>>
+    $gt?: QueryComparable<TValue>
+    $gte?: QueryComparable<TValue>
+    $lt?: QueryComparable<TValue>
+    $lte?: QueryComparable<TValue>
+    $exists?: boolean
+    $regex?: TValue extends string ? string | RegExp : never
+  }
+
+export type QueryParams<TDocument> = {
+  [K in QueryPath<TDocument>]?: QueryValue<QueryPathValue<TDocument, K>>
+} & {
+  _id?: QueryValue<string | number>
+  id?: QueryValue<string | number>
+} & {
+  [K in `${string}.${string}`]?: unknown
+} & {
+  [K in `$${string}`]?: unknown
+}
diff --git a/packages/teamplay/orm/types/signal.ts b/packages/teamplay/orm/types/signal.ts
new file mode 100644
index 0000000..7107859
--- /dev/null
+++ b/packages/teamplay/orm/types/signal.ts
@@ -0,0 +1,456 @@
+import type { TeamplayCollections, TeamplayModels, TeamplaySignalFields } from '../../index.ts'
+import type { Signal, GETTERS } from '../SignalBase.ts'
+import type {
+  FromJsonSchema,
+  InferZodSchema,
+  JsonSchema,
+  ZodLikeSchema
+} from './jsonSchema.ts'
+import type {
+  AppendPath,
+  JoinPath,
+  PathSegment,
+  WildcardSignalPath
+} from './path.ts'
+import type { AggregationFunction, ClientAggregationFunction } from '@teamplay/utils/aggregation'
+import type {
+  SignalArrayMutatorMethods,
+  SignalArrayReaderMethods,
+  SignalCollectionMethods
+} from './baseMethods.ts'
+
+export type RuntimeSignalInstance<TValue = unknown> = Signal<TValue>
+
+export type SignalBaseInstance<TValue = unknown> = RuntimeSignalInstance<TValue>
+
+export type SignalModelConstructor<
+  TValue = unknown,
+  TInstance extends RuntimeSignalInstance<TValue> = RuntimeSignalInstance<TValue>
+> = new (segments: PathSegment[]) => TInstance
+
+export type SignalClass<TValue = unknown> = SignalModelConstructor<TValue>
+
+export type SignalInstance<TModel> =
+  TModel extends SignalModelConstructor<any, infer Instance> ? Instance : RuntimeSignalInstance
+
+type IsExactlyBaseSignalClass<TModel> =
+  [TModel] extends [typeof Signal]
+    ? [typeof Signal] extends [TModel]
+        ? true
+        : false
+    : false
+
+type SignalModelInstance<TValue, TModel> =
+  IsExactlyBaseSignalClass<TModel> extends true
+    ? Signal<TValue>
+    : Signal<TValue> & SignalInstance<TModel>
+
+type SignalArrayReaderMethodKeys = keyof SignalArrayReaderMethods<any>
+type SignalArrayMutatorMethodKeys = keyof SignalArrayMutatorMethods<any>
+type SignalCollectionMethodKeys = keyof SignalCollectionMethods<any>
+type SignalQueryMethodKeys = SignalArrayReaderMethodKeys | SignalArrayMutatorMethodKeys
+
+type BlockedArrayMutators = {
+  readonly [K in SignalArrayMutatorMethodKeys]?: never
+}
+
+type SignalArrayLike<TItem> = SignalArrayReaderMethods<TItem>
+
+type PathModel<
+  TValue,
+  TDefaultModel extends SignalClass<any>,
+  TPath extends WildcardSignalPath
+> =
+  JoinPath<TPath> extends keyof TeamplayModels
+    ? TeamplayModels[JoinPath<TPath>] extends SignalClass<TValue>
+      ? TeamplayModels[JoinPath<TPath>]
+      : TeamplayModels[JoinPath<TPath>] extends SignalClass<any>
+        ? TeamplayModels[JoinPath<TPath>]
+        : TDefaultModel
+    : TDefaultModel
+
+type ArrayItemSignal<Item, TPath extends WildcardSignalPath> =
+  DocumentSignal<Item, typeof Signal, AppendPath<TPath, '*'>>
+
+type SignalArrayMethods<TValue, TPath extends WildcardSignalPath> =
+  NonNullable<TValue> extends ReadonlyArray<infer Item>
+    ? SignalArrayLike<ArrayItemSignal<Item, TPath>>
+    : Pick<Signal<TValue>, SignalArrayReaderMethodKeys>
+
+type SignalFieldsForPath<TPath extends WildcardSignalPath> =
+  JoinPath<TPath> extends keyof TeamplaySignalFields
+    ? TeamplaySignalFields[JoinPath<TPath>]
+    : {}
+
+export type AnySignal = Signal<any>
+
+type IsAny<TValue> = 0 extends (1 & TValue) ? true : false
+
+type IsUnknown<TValue> =
+  IsAny<TValue> extends true
+    ? false
+    : unknown extends TValue
+      ? true
+      : false
+
+type IsEqual<TValue, TOther> =
+  (<T>() => T extends TValue ? 1 : 2) extends
+  (<T>() => T extends TOther ? 1 : 2)
+    ? (<T>() => T extends TOther ? 1 : 2) extends
+      (<T>() => T extends TValue ? 1 : 2)
+        ? true
+        : false
+    : false
+
+type IsUnion<TValue, TUnion = TValue> =
+  [TValue] extends [never]
+    ? false
+    : TValue extends unknown
+      ? [TUnion] extends [TValue] ? false : true
+      : false
+
+type SingleKey<TKey> = IsUnion<TKey> extends true ? never : TKey
+
+export type SignalKind =
+  | 'root'
+  | 'document'
+  | 'collection'
+  | 'nestedValue'
+  | 'localArray'
+  | 'array'
+  | 'query'
+  | 'aggregation'
+  | 'collectionQuery'
+
+type DocumentSignalForKind<
+  TValue,
+  TModel extends SignalClass<any>,
+  TPath extends WildcardSignalPath
+> =
+  Omit<SignalModelInstance<TValue, PathModel<TValue, TModel, TPath>>, SignalArrayReaderMethodKeys> &
+  SignalArrayMethods<TValue, TPath> &
+  SignalChildren<TValue, TPath> &
+  SignalFieldsForPath<TPath>
+
+type CollectionSignalForKind<
+  TDocument,
+  TCollectionModel extends SignalClass<any>,
+  TDocumentModel extends SignalClass<any>,
+  TPath extends WildcardSignalPath
+> =
+  Omit<
+    SignalModelInstance<TDocument[], PathModel<TDocument[], TCollectionModel, TPath>>,
+    SignalCollectionMethodKeys
+  > &
+  SignalArrayLike<CollectionDocumentSignal<TDocument, TDocumentModel, TPath>> &
+  BlockedArrayMutators &
+  { add: (value: TDocument) => Promise<string> } &
+  CollectionDocumentIndex<CollectionDocumentSignal<TDocument, TDocumentModel, TPath>>
+
+type CollectionDocumentIndex<TDocumentSignal> =
+  Readonly<Record<string, TDocumentSignal>> &
+  Readonly<Record<number, TDocumentSignal>>
+
+type ArraySignalForKind<
+  TDocument,
+  TDocumentModel extends SignalClass<any>,
+  TDocumentPath extends WildcardSignalPath
+> = Omit<Signal<TDocument[]>, SignalQueryMethodKeys> &
+SignalArrayLike<DocumentSignal<TDocument, TDocumentModel, TDocumentPath>> & {
+  readonly [index: number]: DocumentSignal<TDocument, TDocumentModel, TDocumentPath>
+} &
+BlockedArrayMutators
+
+type QueryMetadataSignals = {
+  readonly ids: Signal<Array<string | number>>
+  readonly extra: Signal<unknown>
+}
+
+type QuerySignalForKind<
+  TDocument,
+  TDocumentModel extends SignalClass<any>,
+  TDocumentPath extends WildcardSignalPath
+> = ArraySignalForKind<TDocument, TDocumentModel, TDocumentPath> & QueryMetadataSignals
+
+export type SignalForKind<
+  TKind extends SignalKind,
+  TValue = unknown,
+  TCollectionModel extends SignalClass<any> = typeof Signal,
+  TDocumentModel extends SignalClass<any> = typeof Signal,
+  TPath extends WildcardSignalPath = readonly []
+> =
+  TKind extends 'root'
+    ? Signal<Record<string, unknown>>
+    : TKind extends 'document' | 'nestedValue' | 'localArray'
+      ? DocumentSignalForKind<TValue, TDocumentModel, TPath>
+      : TKind extends 'collection'
+        ? CollectionSignalForKind<TValue, TCollectionModel, TDocumentModel, TPath>
+        : TKind extends 'array'
+          ? ArraySignalForKind<TValue, TDocumentModel, TPath>
+          : TKind extends 'query' | 'aggregation'
+            ? QuerySignalForKind<TValue, TDocumentModel, TPath>
+            : TKind extends 'collectionQuery'
+              ? CollectionSignalForKind<TValue, TCollectionModel, TDocumentModel, TPath> & QueryMetadataSignals
+              : never
+
+export type TypedSignal<
+  TValue = unknown,
+  TModel extends SignalClass<any> = typeof Signal,
+  TPath extends WildcardSignalPath = readonly []
+> = DocumentSignalForKind<TValue, TModel, TPath>
+
+export type DocumentSignal<
+  TValue = unknown,
+  TModel extends SignalClass<any> = typeof Signal,
+  TPath extends WildcardSignalPath = readonly []
+> = TypedSignal<TValue, TModel, TPath>
+
+type CollectionDocumentSignal<
+  TDocument,
+  TDocumentModel extends SignalClass<any>,
+  TPath extends WildcardSignalPath
+> = DocumentSignal<TDocument, TDocumentModel, AppendPath<TPath, '*'>>
+
+export type CollectionSignal<
+  TDocument = unknown,
+  TCollectionModel extends SignalClass<any> = typeof Signal,
+  TDocumentModel extends SignalClass<any> = typeof Signal,
+  TPath extends WildcardSignalPath = readonly []
+> =
+  CollectionSignalForKind<TDocument, TCollectionModel, TDocumentModel, TPath>
+
+export type ArraySignal<
+  TDocument = unknown,
+  TDocumentModel extends SignalClass<any> = typeof Signal,
+  TDocumentPath extends WildcardSignalPath = readonly []
+> = ArraySignalForKind<TDocument, TDocumentModel, TDocumentPath>
+
+export type QuerySignal<
+  TDocument = unknown,
+  TDocumentModel extends SignalClass<any> = typeof Signal,
+  TDocumentPath extends WildcardSignalPath = readonly []
+> = QuerySignalForKind<TDocument, TDocumentModel, TDocumentPath>
+
+export type AggregationSignal<
+  TDocument = unknown,
+  TDocumentModel extends SignalClass<any> = typeof Signal,
+  TDocumentPath extends WildcardSignalPath = readonly []
+> = QuerySignalForKind<TDocument, TDocumentModel, TDocumentPath>
+
+export type CollectionDocument<TSpec> =
+  TSpec extends CollectionSpec<infer Document, any, any> ? Document
+    : TSpec extends JsonSchema ? FromJsonSchema<TSpec>
+      : unknown
+
+export type CollectionDocumentModel<TSpec> =
+  TSpec extends CollectionSpec<any, any, infer DocumentModel> ? DocumentModel
+    : typeof Signal
+
+export type CollectionQuerySignal<
+  TDocument,
+  TCollectionModel extends SignalClass<any>,
+  TDocumentModel extends SignalClass<any>,
+  TCollectionPath extends WildcardSignalPath
+> = CollectionSignalForKind<TDocument, TCollectionModel, TDocumentModel, TCollectionPath> & QueryMetadataSignals
+
+type MatchingDocumentCollectionKeys<TValue> =
+  IsAny<TValue> extends true
+    ? never
+    : {
+        [K in keyof TeamplayCollections & string]:
+        IsEqual<
+          NonNullable<TValue>,
+          NonNullable<CollectionDocument<TeamplayCollections[K]>>
+        > extends true ? K : never
+      }[keyof TeamplayCollections & string]
+
+type MatchingCollectionKeys<TValue> =
+  IsAny<TValue> extends true
+    ? never
+    : NonNullable<TValue> extends ReadonlyArray<infer TDocument>
+      ? MatchingDocumentCollectionKeys<TDocument>
+      : never
+
+type SingleDocumentCollectionKey<TValue> = SingleKey<MatchingDocumentCollectionKeys<TValue>>
+type SingleCollectionKey<TValue> = SingleKey<MatchingCollectionKeys<TValue>>
+
+type DocumentSignalModelForValue<TValue> =
+  [SingleDocumentCollectionKey<TValue>] extends [never]
+    ? typeof Signal
+    : SingleDocumentCollectionKey<TValue> extends keyof TeamplayCollections & string
+      ? CollectionDocumentModel<TeamplayCollections[SingleDocumentCollectionKey<TValue>]>
+      : typeof Signal
+
+type DocumentSignalPathForValue<TValue> =
+  [SingleDocumentCollectionKey<TValue>] extends [never]
+    ? readonly []
+    : SingleDocumentCollectionKey<TValue> extends keyof TeamplayCollections & string
+      ? readonly [SingleDocumentCollectionKey<TValue>, '*']
+      : readonly []
+
+type SignalForDocumentValue<TValue> =
+  TypedSignal<TValue, DocumentSignalModelForValue<TValue>, DocumentSignalPathForValue<TValue>>
+
+type SignalForCollectionArrayValue<TCollection extends keyof TeamplayCollections & string> =
+  CollectionSignal<
+    CollectionDocument<TeamplayCollections[TCollection]>,
+    TeamplayCollections[TCollection] extends CollectionSpec<any, infer CollectionModel, any>
+      ? CollectionModel
+      : typeof Signal,
+    CollectionDocumentModel<TeamplayCollections[TCollection]>,
+    readonly [TCollection]
+  >
+
+type SignalForArrayValue<TValue> =
+  [SingleCollectionKey<TValue>] extends [never]
+    ? SignalForDocumentValue<TValue>
+    : SingleCollectionKey<TValue> extends keyof TeamplayCollections & string
+      ? SignalForCollectionArrayValue<SingleCollectionKey<TValue>>
+      : SignalForDocumentValue<TValue>
+
+export type PublicSignal<TValue = unknown> =
+  IsAny<TValue> extends true
+    ? TypedSignal<TValue>
+    : NonNullable<TValue> extends ReadonlyArray<any>
+      ? SignalForArrayValue<TValue>
+      : SignalForDocumentValue<TValue>
+
+export interface LocalSignalFactory {
+  (): any
+  <TValue>(): TypedSignal<TValue>
+  <TValue>(factory: () => TValue): TypedSignal<TValue>
+  <TValue>(value: TValue): TypedSignal<TValue>
+}
+
+export type RootCollections<TCollections extends Record<string, any> = TeamplayCollections> = {
+  readonly [K in keyof TCollections & string]: CollectionSignalFromSpec<TCollections[K], readonly [K]>
+} & {
+  readonly [K in keyof TCollections & string as `$${K}`]: CollectionSignalFromSpec<TCollections[K], readonly [K]>
+}
+
+export type RootSignal<TCollections extends Record<string, any> = TeamplayCollections> =
+  Signal<Record<string, unknown>> & LocalSignalFactory & RootCollections<TCollections>
+
+export interface RegisteredAggregationInput<
+  TCollection extends string = string,
+  TOutput = unknown
+> {
+  readonly __isAggregation: true
+  readonly collection: TCollection
+  readonly __teamplayAggregationOutput?: TOutput
+}
+
+export interface TypedAggregationInput<
+  TDocument = unknown,
+  TDocumentModel extends SignalClass<any> = typeof Signal
+> extends RegisteredAggregationInput {
+  readonly __teamplayTypedAggregationInput: true
+  readonly __teamplayDocument?: TDocument
+  readonly __teamplayDocumentModel?: TDocumentModel
+}
+
+export type CollectionAggregationSignal<TCollection extends keyof TeamplayCollections & string> =
+  AggregationSignal<
+  CollectionDocument<TeamplayCollections[TCollection]>,
+  CollectionDocumentModel<TeamplayCollections[TCollection]>,
+  readonly [TCollection, '*']
+  >
+
+export type TypedAggregationSignal<TDocument, TDocumentModel extends SignalClass<any>> =
+  AggregationSignal<TDocument, TDocumentModel>
+
+export type AggregationOutputSignal<TOutput> =
+  IsAny<TOutput> extends true
+    ? QuerySignal
+    : NonNullable<TOutput> extends ReadonlyArray<infer TDocument>
+      ? AggregationSignal<TDocument, DocumentSignalModelForValue<TDocument>, DocumentSignalPathForValue<TDocument>>
+      : SignalForDocumentValue<TOutput>
+
+type RegisteredAggregationSignal<TCollection extends string, TOutput> =
+  IsUnknown<TOutput> extends true
+    ? TCollection extends keyof TeamplayCollections & string
+      ? CollectionAggregationSignal<TCollection>
+      : QuerySignal
+    : AggregationOutputSignal<TOutput>
+
+export type MaybePromise<TValue> = TValue | Promise<TValue>
+
+export type SubResult<TSignal, TParams = undefined> =
+  TSignal extends ClientAggregationFunction<infer TOutput, infer TCollection>
+    ? RegisteredAggregationSignal<TCollection, TOutput>
+    : TSignal extends AggregationFunction<infer TOutput, any>
+      ? IsUnknown<TOutput> extends true ? QuerySignal : AggregationOutputSignal<TOutput>
+      : TSignal extends TypedAggregationInput<infer TDocument, infer TDocumentModel>
+        ? TypedAggregationSignal<TDocument, TDocumentModel>
+        : TSignal extends RegisteredAggregationInput<infer TCollection, infer TOutput>
+          ? RegisteredAggregationSignal<TCollection, TOutput>
+          : [TParams] extends [undefined]
+              ? TSignal extends DocumentSignal<any, any, any>
+                ? TSignal
+                : QuerySignal
+              : TSignal extends CollectionSignal<infer TDocument, infer TCollectionModel, infer TDocumentModel, infer TCollectionPath>
+                ? CollectionQuerySignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>
+                : QuerySignal
+
+export type MaybePromiseSubResult<TSignal, TParams = undefined> =
+  MaybePromise<SubResult<TSignal, TParams>>
+
+export type SignalChild<TValue, TPath extends WildcardSignalPath> =
+  DocumentSignal<TValue, typeof Signal, TPath>
+
+type ObjectSignalChildren<TValue, TPath extends WildcardSignalPath> = {
+  readonly [K in keyof NonNullable<TValue> & string]-?: SignalChild<NonNullable<TValue>[K], AppendPath<TPath, K>>
+}
+
+type DollarObjectSignalChildren<TValue, TPath extends WildcardSignalPath> = {
+  readonly [K in keyof NonNullable<TValue> & string as `$${K}`]-?: SignalChild<NonNullable<TValue>[K], AppendPath<TPath, K>>
+}
+
+export type SignalChildren<TValue, TPath extends WildcardSignalPath = readonly []> =
+  NonNullable<TValue> extends ReadonlyArray<infer Item>
+    ? Readonly<Record<number, DocumentSignal<Item, typeof Signal, AppendPath<TPath, '*'>>>>
+    : NonNullable<TValue> extends object
+      ? ObjectSignalChildren<TValue, TPath> & DollarObjectSignalChildren<TValue, TPath>
+      : {}
+
+export interface CollectionSpec<
+  TDocument = unknown,
+  TCollectionModel extends SignalClass<any> = typeof Signal,
+  TDocumentModel extends SignalClass<any> = typeof Signal
+> {
+  readonly document: TDocument
+  readonly collectionModel: TCollectionModel
+  readonly documentModel: TDocumentModel
+}
+
+export type JsonSchemaSpec<
+  TSchema,
+  TCollectionModel extends SignalClass<any> = typeof Signal,
+  TDocumentModel extends SignalClass<any> = typeof Signal
+> = CollectionSpec<FromJsonSchema<TSchema>, TCollectionModel, TDocumentModel>
+
+export type ZodSchemaSpec<
+  TSchema extends ZodLikeSchema,
+  TCollectionModel extends SignalClass<any> = typeof Signal,
+  TDocumentModel extends SignalClass<any> = typeof Signal
+> = CollectionSpec<InferZodSchema<TSchema>, TCollectionModel, TDocumentModel>
+
+export type CollectionSignalFromSpec<
+  TSpec,
+  TPath extends WildcardSignalPath = readonly []
+> =
+  TSpec extends CollectionSpec<infer Document, infer CollectionModel, infer DocumentModel>
+    ? CollectionSignal<Document, CollectionModel, DocumentModel, TPath>
+    : TSpec extends JsonSchema
+      ? CollectionSignal<FromJsonSchema<TSpec>, typeof Signal, typeof Signal, TPath>
+      : CollectionSignal
+
+export interface SignalConstructor {
+  new <TValue = unknown>(segments: PathSegment[]): TypedSignal<TValue>
+  readonly ID_FIELDS: typeof Signal.ID_FIELDS
+  readonly associations: typeof Signal.associations
+  readonly [GETTERS]: typeof Signal[typeof GETTERS]
+  addAssociation: typeof Signal.addAssociation
+}
+
+export type RuntimeSignalConstructor = SignalConstructor
diff --git a/packages/teamplay/package.json b/packages/teamplay/package.json
index fb1a456..b2853a3 100644
--- a/packages/teamplay/package.json
+++ b/packages/teamplay/package.json
@@ -3,10 +3,23 @@
   "version": "0.4.0-alpha.100",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
-  "main": "index.js",
+  "main": "index.ts",
+  "types": "index.ts",
   "exports": {
-    ".": "./index.js",
-    "./orm": "./orm/index.js",
+    ".": {
+      "types": "./index.ts",
+      "default": "./index.ts"
+    },
+    "./orm": {
+      "types": "./orm/index.ts",
+      "default": "./orm/index.ts"
+    },
+    "./babel": "./babel.cjs",
+    "./babel/loader": "./babel-loader.cjs",
+    "./file-based-models": {
+      "node": "./file-based-models.node.js",
+      "default": "./file-based-models.js"
+    },
     "./connect": "./connect/index.js",
     "./server": "./server.js",
     "./connect-test": "./connect/test.js",
@@ -21,13 +34,15 @@
     "access": "public"
   },
   "scripts": {
-    "test": "npm run test-server && npm run test-client",
+    "test": "npm run test-types && npm run test-types:external && npm run test-server && npm run test-client && npm run test-compat",
+    "test-types": "tsc -p tsconfig.type-tests.json",
+    "test-types:external": "tsc -p tsconfig.external-consumer.json",
     "test-server": "NODE_OPTIONS=\"--expose-gc\" mocha 'test/[!_]*.js'",
     "test-server-only": "NODE_OPTIONS=\"--expose-gc\" mocha --grep '@only' 'test/[!_]*.js'",
-    "test-client": "NODE_OPTIONS=\"$NODE_OPTIONS --expose-gc --experimental-vm-modules\" jest",
+    "test-client": "NODE_OPTIONS=\"$NODE_OPTIONS --expose-gc --experimental-vm-modules\" jest --runInBand",
     "test-compat": "npm run test-server-compat && npm run test-client-compat",
     "test-server-compat": "TEAMPLAY_COMPAT=1 NODE_OPTIONS=\"--expose-gc\" mocha 'test/[!_]*.js'",
-    "test-client-compat": "TEAMPLAY_COMPAT=1 NODE_OPTIONS=\"$NODE_OPTIONS --expose-gc --experimental-vm-modules\" jest",
+    "test-client-compat": "TEAMPLAY_COMPAT=1 NODE_OPTIONS=\"$NODE_OPTIONS --expose-gc --experimental-vm-modules\" jest --runInBand",
     "coverage-server": "NODE_OPTIONS=\"--expose-gc\" c8 --include 'orm/**' --include 'react/**' --include 'utils/**' mocha 'test/[!_]*.js'",
     "coverage-client": "NODE_OPTIONS=\"$NODE_OPTIONS --expose-gc --experimental-vm-modules\" jest --coverage --coverageDirectory=coverage-client",
     "coverage": "npm run coverage-server && npm run coverage-client"
@@ -41,6 +56,7 @@
     "@teamplay/debug": "^0.4.0-alpha.9",
     "@teamplay/schema": "^0.4.0-alpha.9",
     "@teamplay/utils": "^0.4.0-alpha.9",
+    "babel-plugin-teamplay": "^0.4.0-alpha.100",
     "diff-match-patch": "^1.0.5",
     "events": "^3.3.0",
     "json0-ot-diff": "^1.1.2",
@@ -51,12 +67,13 @@
     "stream": "npm:readable-stream@^4.7.0"
   },
   "devDependencies": {
-    "@jest/globals": "^29.7.0",
-    "@testing-library/react": "^15.0.7",
-    "c8": "^10.1.3",
-    "jest": "^29.7.0",
-    "jest-environment-jsdom": "^29.7.0",
-    "mocha": "^11.0.1",
+    "@jest/globals": "^30.3.0",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "c8": "^11.0.0",
+    "jest": "^30.3.0",
+    "jest-environment-jsdom": "^30.3.0",
+    "mocha": "^11.7.5",
     "react": "^18.3.1",
     "react-dom": "^18.3.1"
   },
@@ -74,9 +91,15 @@
     }
   },
   "jest": {
-    "transform": {},
+    "transform": {
+      "^.+\\.ts$": "./test/ts-transform.cjs"
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
     "testEnvironment": "jsdom",
     "testRegex": "test_client/.*\\.jsx?$",
+    "testSequencer": "./test_client/testSequencer.cjs",
     "testPathIgnorePatterns": [
       "node_modules",
       "<rootDir>/test_client/helpers"
diff --git a/packages/teamplay/react/compatComponentRegistry.js b/packages/teamplay/react/compatComponentRegistry.js
deleted file mode 100644
index 0b6c89a..0000000
--- a/packages/teamplay/react/compatComponentRegistry.js
+++ /dev/null
@@ -1,20 +0,0 @@
-const compatComponentIds = new Set()
-
-export function markCompatComponent (componentId) {
-  if (!componentId) return
-  compatComponentIds.add(componentId)
-}
-
-export function unmarkCompatComponent (componentId) {
-  if (!componentId) return
-  compatComponentIds.delete(componentId)
-}
-
-export function isCompatComponent (componentId) {
-  if (!componentId) return false
-  return compatComponentIds.has(componentId)
-}
-
-export function __resetCompatComponentRegistryForTests () {
-  compatComponentIds.clear()
-}
diff --git a/packages/teamplay/react/compatComponentRegistry.ts b/packages/teamplay/react/compatComponentRegistry.ts
new file mode 100644
index 0000000..12512f5
--- /dev/null
+++ b/packages/teamplay/react/compatComponentRegistry.ts
@@ -0,0 +1,20 @@
+const compatComponentIds = new Set<string>()
+
+export function markCompatComponent (componentId: string | undefined): void {
+  if (!componentId) return
+  compatComponentIds.add(componentId)
+}
+
+export function unmarkCompatComponent (componentId: string | undefined): void {
+  if (!componentId) return
+  compatComponentIds.delete(componentId)
+}
+
+export function isCompatComponent (componentId: string | undefined): boolean {
+  if (!componentId) return false
+  return compatComponentIds.has(componentId)
+}
+
+export function __resetCompatComponentRegistryForTests (): void {
+  compatComponentIds.clear()
+}
diff --git a/packages/teamplay/react/convertToObserver.d.ts b/packages/teamplay/react/convertToObserver.d.ts
new file mode 100644
index 0000000..c6ff302
--- /dev/null
+++ b/packages/teamplay/react/convertToObserver.d.ts
@@ -0,0 +1,26 @@
+import type * as React from 'react'
+
+export interface ConvertToObserverOptions {
+  forwardRef?: boolean
+  cache?: boolean
+  throttle?: number | boolean
+  defer?: boolean | number
+  suspenseProps?: React.ComponentProps<typeof React.Suspense>
+}
+
+export interface ConvertedObserver<TProps extends object = Record<string, unknown>, TRef = unknown> {
+  Component:
+    | ((props: TProps) => React.ReactNode)
+    | ((props: TProps, ref: React.ForwardedRef<TRef>) => React.ReactNode)
+  forwardRef?: boolean
+  defer?: boolean | number
+  suspenseProps?: React.ComponentProps<typeof React.Suspense>
+  [option: string]: unknown
+}
+
+export default function convertToObserver<TProps extends object, TRef = unknown> (
+  Component:
+    | ((props: TProps) => React.ReactNode)
+    | ((props: TProps, ref: React.ForwardedRef<TRef>) => React.ReactNode),
+  options?: ConvertToObserverOptions
+): ConvertedObserver<TProps, TRef>
diff --git a/packages/teamplay/react/convertToObserver.js b/packages/teamplay/react/convertToObserver.js
index e0319f9..49db7cf 100644
--- a/packages/teamplay/react/convertToObserver.js
+++ b/packages/teamplay/react/convertToObserver.js
@@ -3,11 +3,11 @@ import { observe, unobserve } from '@nx-js/observer-util'
 import _throttle from 'lodash/throttle.js'
 import { createCaches, getDummyCache } from '@teamplay/cache'
 import { __increment, __decrement } from '@teamplay/debug'
-import executionContextTracker from './executionContextTracker.js'
-import { pipeComponentMeta, useUnmount, useId, useTriggerUpdate } from './helpers.js'
+import executionContextTracker from './executionContextTracker.ts'
+import { pipeComponentMeta, useUnmount, useId, useTriggerUpdate } from './helpers.ts'
 import trapRender from './trapRender.js'
 import { scheduleReaction } from '../orm/batchScheduler.js'
-import { isCompatComponent, unmarkCompatComponent } from './compatComponentRegistry.js'
+import { isCompatComponent, unmarkCompatComponent } from './compatComponentRegistry.ts'
 
 const DEFAULT_THROTTLE_TIMEOUT = 100
 
diff --git a/packages/teamplay/react/executionContextTracker.js b/packages/teamplay/react/executionContextTracker.ts
similarity index 52%
rename from packages/teamplay/react/executionContextTracker.js
rename to packages/teamplay/react/executionContextTracker.ts
index e5806c1..c53ca94 100644
--- a/packages/teamplay/react/executionContextTracker.js
+++ b/packages/teamplay/react/executionContextTracker.ts
@@ -1,32 +1,34 @@
-export default new class ExecutionContextTracker {
-  #contextId
-  #hooksCounter
+class ExecutionContextTracker {
+  #contextId: string | undefined
+  #hooksCounter = -1
 
-  isActive () {
+  isActive (): boolean {
     return this.#contextId !== undefined
   }
 
-  getComponentId () {
+  getComponentId (): string | undefined {
     return this.#contextId
   }
 
-  newHookId () {
+  newHookId (): string {
     this.incrementHooksCounter()
     const id = `_${this.#contextId}_${this.#hooksCounter}`
     return id
   }
 
-  incrementHooksCounter () {
+  incrementHooksCounter (): void {
     if (!this.#contextId) return
     this.#hooksCounter++
   }
 
-  _start (contextId) {
+  _start (contextId: string): void {
     this.#contextId = contextId
     this.#hooksCounter = -1
   }
 
-  _clear () {
+  _clear (): void {
     this.#contextId = undefined
   }
-}()
+}
+
+export default new ExecutionContextTracker()
diff --git a/packages/teamplay/react/helpers.js b/packages/teamplay/react/helpers.ts
similarity index 58%
rename from packages/teamplay/react/helpers.js
rename to packages/teamplay/react/helpers.ts
index 707441b..5b2a647 100644
--- a/packages/teamplay/react/helpers.js
+++ b/packages/teamplay/react/helpers.ts
@@ -1,8 +1,36 @@
+import type * as React from 'react'
 import { useContext, createContext, useRef, useEffect, useLayoutEffect } from 'react'
 
-export const ComponentMetaContext = createContext({})
+export interface ComponentMetaCache {
+  get: (key: unknown) => unknown
+  set: (key: unknown, value: unknown) => unknown
+  has: (key: unknown) => boolean
+}
+
+export interface ComponentMeta {
+  readonly componentId: string
+  readonly createdAt: number
+  readonly defer?: boolean | number
+  readonly triggerUpdate: () => void
+  readonly scheduleUpdate: (promise: PromiseLike<unknown>) => void
+  readonly cache: ComponentMetaCache
+}
 
-export function pipeComponentDisplayName (SourceComponent, TargetComponent, suffix = '', defaultName = 'StartupjsWrapper') {
+interface ComponentWithMeta {
+  displayName?: string
+  readonly name?: string
+  propTypes?: unknown
+  defaultProps?: unknown
+}
+
+export const ComponentMetaContext = createContext<Partial<ComponentMeta>>({})
+
+export function pipeComponentDisplayName (
+  SourceComponent: ComponentWithMeta,
+  TargetComponent: ComponentWithMeta,
+  suffix = '',
+  defaultName = 'StartupjsWrapper'
+): void {
   const displayName = SourceComponent.displayName || SourceComponent.name
 
   if (!TargetComponent.displayName) {
@@ -10,7 +38,12 @@ export function pipeComponentDisplayName (SourceComponent, TargetComponent, suff
   }
 }
 
-export function pipeComponentMeta (SourceComponent, TargetComponent, suffix = '', defaultName = 'StartupjsWrapper') {
+export function pipeComponentMeta<TTargetComponent extends ComponentWithMeta> (
+  SourceComponent: ComponentWithMeta,
+  TargetComponent: TTargetComponent,
+  suffix = '',
+  defaultName = 'StartupjsWrapper'
+): TTargetComponent {
   pipeComponentDisplayName(SourceComponent, TargetComponent, suffix, defaultName)
 
   if (!TargetComponent.propTypes && SourceComponent.propTypes) {
@@ -22,44 +55,44 @@ export function pipeComponentMeta (SourceComponent, TargetComponent, suffix = ''
   return TargetComponent
 }
 
-export function useNow () {
+export function useNow (): number {
   const context = useContext(ComponentMetaContext)
   if (!context) throw Error(ERRORS.useNow)
-  return context.createdAt
+  return context.createdAt as number
 }
 
-export function useId () {
+export function useId (): string {
   const context = useContext(ComponentMetaContext)
   if (!context) throw Error(ERRORS.useId)
-  return context.componentId
+  return context.componentId as string
 }
 
-export function useTriggerUpdate () {
+export function useTriggerUpdate (): () => void {
   const context = useContext(ComponentMetaContext)
   if (!context) throw Error(ERRORS.useTriggerUpdate)
-  return context.triggerUpdate
+  return context.triggerUpdate as () => void
 }
 
-export function useScheduleUpdate () {
+export function useScheduleUpdate (): (promise: PromiseLike<unknown>) => void {
   const context = useContext(ComponentMetaContext)
   if (!context) throw Error(ERRORS.useScheduleUpdate)
-  return context.scheduleUpdate
+  return context.scheduleUpdate as (promise: PromiseLike<unknown>) => void
 }
 
-export function useDefer () {
+export function useDefer (): boolean | number | undefined {
   const context = useContext(ComponentMetaContext)
   if (!context) throw Error(ERRORS.useScheduleUpdate)
   return context.defer
 }
 
-export function useCache (key) {
+export function useCache (_key?: unknown): ComponentMetaCache {
   const context = useContext(ComponentMetaContext)
   if (!context) throw Error(ERRORS.useCache)
-  return context.cache
+  return context.cache as ComponentMetaCache
 }
 
-export function useUnmount (fn) {
-  const fnRef = useRef()
+export function useUnmount (fn: () => void): void {
+  const fnRef = useRef(fn)
   if (fnRef.current !== fn) fnRef.current = fn
   useEffect(
     () => () => {
@@ -69,7 +102,10 @@ export function useUnmount (fn) {
   )
 }
 
-export function useDidUpdate (fn, deps) {
+export function useDidUpdate (
+  fn: React.EffectCallback,
+  deps?: React.DependencyList
+): void {
   const isFirst = useRef(true)
   const fnRef = useRef(fn)
   if (fnRef.current !== fn) fnRef.current = fn
@@ -80,10 +116,10 @@ export function useDidUpdate (fn, deps) {
       return
     }
     return fnRef.current()
-  }, stableDeps)
+  }, stableDeps) // eslint-disable-line react-hooks/exhaustive-deps
 }
 
-export function useOnce (condition, fn) {
+export function useOnce (condition: unknown, fn: React.EffectCallback): void {
   const fired = useRef(false)
   useEffect(() => {
     if (fired.current) return
@@ -93,13 +129,16 @@ export function useOnce (condition, fn) {
   }, [condition, fn])
 }
 
-export function useSyncEffect (fn, deps) {
+export function useSyncEffect (
+  fn: React.EffectCallback,
+  deps?: React.DependencyList
+): void {
   const stableDeps = useStableDeps(deps)
   useLayoutEffect(fn, [fn, stableDeps])
 }
 
-function useStableDeps (deps) {
-  const depsRef = useRef([])
+function useStableDeps (deps: React.DependencyList | undefined): React.DependencyList {
+  const depsRef = useRef<React.DependencyList>([])
   const nextDeps = Array.isArray(deps) ? deps : []
   if (!shallowEqualArrays(depsRef.current, nextDeps)) {
     depsRef.current = nextDeps
@@ -107,7 +146,10 @@ function useStableDeps (deps) {
   return depsRef.current
 }
 
-function shallowEqualArrays (a, b) {
+function shallowEqualArrays (
+  a: React.DependencyList | undefined,
+  b: React.DependencyList
+): boolean {
   if (a === b) return true
   if (!Array.isArray(a) || !Array.isArray(b)) return false
   if (a.length !== b.length) return false
diff --git a/packages/teamplay/react/observer.js b/packages/teamplay/react/observer.js
deleted file mode 100644
index 21433b9..0000000
--- a/packages/teamplay/react/observer.js
+++ /dev/null
@@ -1,9 +0,0 @@
-import convertToObserver from './convertToObserver.js'
-import wrapIntoSuspense from './wrapIntoSuspense.js'
-
-function observer (Component, options) {
-  return wrapIntoSuspense(convertToObserver(Component, options))
-}
-observer.__wrapObserverMeta = wrapIntoSuspense
-observer.__makeObserver = convertToObserver
-export default observer
diff --git a/packages/teamplay/react/observer.ts b/packages/teamplay/react/observer.ts
new file mode 100644
index 0000000..fab3f43
--- /dev/null
+++ b/packages/teamplay/react/observer.ts
@@ -0,0 +1,39 @@
+import type * as React from 'react'
+import convertToObserver from './convertToObserver.js'
+import wrapIntoSuspense from './wrapIntoSuspense.js'
+
+export interface RuntimeObserverOptions {
+  forwardRef?: boolean
+  cache?: boolean
+  throttle?: number | boolean
+  defer?: boolean | number
+  suspenseProps?: React.ComponentProps<typeof React.Suspense>
+}
+
+type ObserverComponent<TProps extends object> = (props: TProps) => React.ReactNode
+type ObserverForwardRefComponent<TProps extends object, TRef> =
+  (props: TProps, ref: React.ForwardedRef<TRef>) => React.ReactNode
+
+interface RuntimeObserver {
+  <TProps extends object, TRef = unknown>(
+    Component: ObserverForwardRefComponent<TProps, TRef>,
+    options: RuntimeObserverOptions & { forwardRef: true }
+  ): React.NamedExoticComponent<React.PropsWithoutRef<TProps> & React.RefAttributes<TRef>>
+  <TProps extends object>(
+    Component: ObserverComponent<TProps>,
+    options?: RuntimeObserverOptions
+  ): React.NamedExoticComponent<TProps>
+  __wrapObserverMeta: typeof wrapIntoSuspense
+  __makeObserver: typeof convertToObserver
+}
+
+const observer = function observer<TProps extends object> (
+  Component: ObserverComponent<TProps>,
+  options?: RuntimeObserverOptions
+): React.NamedExoticComponent<TProps> {
+  return wrapIntoSuspense(convertToObserver(Component, options) as never) as unknown as React.NamedExoticComponent<TProps>
+} as RuntimeObserver
+
+observer.__wrapObserverMeta = wrapIntoSuspense
+observer.__makeObserver = convertToObserver
+export default observer
diff --git a/packages/teamplay/react/promiseBatcher.js b/packages/teamplay/react/promiseBatcher.ts
similarity index 55%
rename from packages/teamplay/react/promiseBatcher.js
rename to packages/teamplay/react/promiseBatcher.ts
index 52d32f7..b3832b7 100644
--- a/packages/teamplay/react/promiseBatcher.js
+++ b/packages/teamplay/react/promiseBatcher.ts
@@ -1,26 +1,34 @@
 let active = false
-let promises = []
-let checks = new Map()
+let promises: Array<PromiseLike<unknown>> = []
+let checks = new Map<unknown, BatchReadinessCheck>()
 
 const READINESS_POLL_INTERVAL_MS = 16
 const READINESS_WARN_AFTER_MS = 1000
 
-export function activate () {
+export interface BatchReadinessCheck {
+  key?: unknown
+  type?: string
+  details?: unknown
+  isReady: () => boolean
+  getState?: () => unknown
+}
+
+export function activate (): void {
   active = true
 }
 
-export function add (promise) {
+export function add (promise: PromiseLike<unknown> | null | undefined): void {
   if (!promise || typeof promise.then !== 'function') return
   promises.push(promise)
 }
 
-export function addCheck (check) {
+export function addCheck (check: BatchReadinessCheck | null | undefined): void {
   if (!check || typeof check.isReady !== 'function') return
   const key = check.key ?? Symbol('batch-check')
   checks.set(key, { ...check, key })
 }
 
-export function getPromiseAll () {
+export function getPromiseAll (): Promise<void> | null {
   const pendingPromises = promises
   const pendingChecks = Array.from(checks.values())
   const hasPromises = pendingPromises.length > 0
@@ -34,24 +42,27 @@ export function getPromiseAll () {
   return result
 }
 
-export function isActive () {
+export function isActive (): boolean {
   return active
 }
 
-export function reset () {
+export function reset (): void {
   active = false
   promises = []
   checks = new Map()
 }
 
-async function waitForBatchReady (pendingPromises, pendingChecks) {
+async function waitForBatchReady (
+  pendingPromises: Array<PromiseLike<unknown>>,
+  pendingChecks: BatchReadinessCheck[]
+): Promise<void> {
   if (pendingPromises.length > 0) await Promise.all(pendingPromises)
   // Let microtasks flush after subscription promises resolve so tree writes become visible.
   await Promise.resolve()
   await waitForChecksReady(pendingChecks)
 }
 
-async function waitForChecksReady (pendingChecks) {
+async function waitForChecksReady (pendingChecks: BatchReadinessCheck[]): Promise<void> {
   if (pendingChecks.length === 0) return
   let warned = false
   const startedAt = Date.now()
@@ -66,15 +77,15 @@ async function waitForChecksReady (pendingChecks) {
   }
 }
 
-function getNotReadyChecks (pendingChecks) {
-  const notReady = []
+function getNotReadyChecks (pendingChecks: BatchReadinessCheck[]): BatchReadinessCheck[] {
+  const notReady: BatchReadinessCheck[] = []
   for (const check of pendingChecks) {
     if (!isCheckReady(check)) notReady.push(check)
   }
   return notReady
 }
 
-function isCheckReady (check) {
+function isCheckReady (check: BatchReadinessCheck): boolean {
   try {
     return !!check.isReady()
   } catch (err) {
@@ -83,13 +94,13 @@ function isCheckReady (check) {
   }
 }
 
-function warnAboutChecksDelay (checks) {
+function warnAboutChecksDelay (checks: BatchReadinessCheck[]): void {
   const details = checks.map(check => {
-    let state
+    let state: unknown
     try {
       state = typeof check.getState === 'function' ? check.getState() : undefined
     } catch (err) {
-      state = isThenable(err) ? 'suspended' : `state-error: ${err?.message || err}`
+      state = isThenable(err) ? 'suspended' : `state-error: ${getErrorMessage(err)}`
     }
     return {
       type: check.type || 'unknown',
@@ -101,15 +112,23 @@ function warnAboutChecksDelay (checks) {
   console.warn('[teamplay] useBatch() is waiting for data materialization checks.', details)
 }
 
-function isDevMode () {
-  if (typeof process === 'undefined' || !process?.env) return true
-  return process.env.NODE_ENV !== 'production'
+function isDevMode (): boolean {
+  const processLike = (globalThis as { process?: { env?: { NODE_ENV?: string } } }).process
+  if (!processLike?.env) return true
+  return processLike.env.NODE_ENV !== 'production'
+}
+
+function isThenable (value: unknown): value is PromiseLike<unknown> {
+  return !!value &&
+    (typeof value === 'object' || typeof value === 'function') &&
+    typeof (value as { then?: unknown }).then === 'function'
 }
 
-function isThenable (value) {
-  return !!value && typeof value.then === 'function'
+function getErrorMessage (err: unknown): string {
+  if (err instanceof Error) return err.message
+  return String(err)
 }
 
-function delay (ms) {
+function delay (ms: number): Promise<void> {
   return new Promise(resolve => setTimeout(resolve, ms))
 }
diff --git a/packages/teamplay/react/renderAttemptDestroyer.js b/packages/teamplay/react/renderAttemptDestroyer.ts
similarity index 66%
rename from packages/teamplay/react/renderAttemptDestroyer.js
rename to packages/teamplay/react/renderAttemptDestroyer.ts
index 07d5dbc..4256326 100644
--- a/packages/teamplay/react/renderAttemptDestroyer.js
+++ b/packages/teamplay/react/renderAttemptDestroyer.ts
@@ -1,28 +1,37 @@
+type DestroyAttempt = () => unknown | Promise<unknown>
+
 class RenderAttemptDestroyer {
+  fns: DestroyAttempt[]
+  compatAttemptCleanupArmed: boolean
+  suspenseGateArmed: boolean
+
   constructor () {
     this.fns = []
     this.compatAttemptCleanupArmed = false
     this.suspenseGateArmed = false
   }
 
-  add (fn, { compat = false } = {}) {
+  add (fn: DestroyAttempt | undefined, { compat = false }: { compat?: boolean } = {}): void {
     if (typeof fn !== 'function') return
     this.fns.push(fn)
     if (compat) this.compatAttemptCleanupArmed = true
   }
 
-  armCompatAttemptCleanup () {
+  armCompatAttemptCleanup (): void {
     this.compatAttemptCleanupArmed = true
   }
 
-  armSuspenseGate () {
+  armSuspenseGate (): void {
     this.suspenseGateArmed = true
   }
 
-  consumeThenableHandling () {
+  consumeThenableHandling (): {
+    shouldKeepShellAlive: boolean
+    destroyAttempt?: () => Promise<void>
+  } {
     const shouldRunAttemptCleanup = this.compatAttemptCleanupArmed && this.fns.length > 0
     const shouldKeepShellAlive = this.suspenseGateArmed || shouldRunAttemptCleanup
-    let destroyAttempt
+    let destroyAttempt: (() => Promise<void>) | undefined
     if (shouldRunAttemptCleanup) {
       const fns = [...this.fns]
       destroyAttempt = async () => {
@@ -37,7 +46,7 @@ class RenderAttemptDestroyer {
     }
   }
 
-  reset () {
+  reset (): void {
     this.fns.length = 0
     this.compatAttemptCleanupArmed = false
     this.suspenseGateArmed = false
diff --git a/packages/teamplay/react/trapRender.js b/packages/teamplay/react/trapRender.js
index 5287e03..64b0a17 100644
--- a/packages/teamplay/react/trapRender.js
+++ b/packages/teamplay/react/trapRender.js
@@ -1,8 +1,8 @@
 // trap render function (functional component) to block observer updates and activate cache
 // during synchronous rendering
-import executionContextTracker from './executionContextTracker.js'
-import * as promiseBatcher from './promiseBatcher.js'
-import renderAttemptDestroyer from './renderAttemptDestroyer.js'
+import executionContextTracker from './executionContextTracker.ts'
+import * as promiseBatcher from './promiseBatcher.ts'
+import renderAttemptDestroyer from './renderAttemptDestroyer.ts'
 
 export default function trapRender ({ render, cache, destroy, componentId }) {
   return (...args) => {
diff --git a/packages/teamplay/react/universal$.js b/packages/teamplay/react/universal$.ts
similarity index 62%
rename from packages/teamplay/react/universal$.js
rename to packages/teamplay/react/universal$.ts
index 7df0a5a..8eb60e1 100644
--- a/packages/teamplay/react/universal$.js
+++ b/packages/teamplay/react/universal$.ts
@@ -1,13 +1,13 @@
 import $ from '../orm/$.js'
-import { useCache } from './helpers.js'
-import executionContextTracker from './executionContextTracker.js'
+import { useCache } from './helpers.ts'
+import executionContextTracker from './executionContextTracker.ts'
 
 // universal versions of $() which work as a plain function or as a react hook
-export default function universal$ ($root, value) {
+export default function universal$ ($root?: unknown, value?: unknown): unknown {
   if (executionContextTracker.isActive()) {
     // within react component
     const id = executionContextTracker.newHookId()
-    const cache = useCache() // eslint-disable-line react-hooks/rules-of-hooks
+    const cache = useCache(undefined) // eslint-disable-line react-hooks/rules-of-hooks
     const $signal = $($root, value, id)
     cache.set(id, $signal)
     // save signal into ref to make sure it's not garbage collected while component exists
diff --git a/packages/teamplay/react/universalSub.js b/packages/teamplay/react/universalSub.js
index 7301b53..45c372d 100644
--- a/packages/teamplay/react/universalSub.js
+++ b/packages/teamplay/react/universalSub.js
@@ -3,8 +3,8 @@
 //       Having the same sub() function working with either await or without it
 //       is confusing. It's better to have a separate function for the hook.
 import { useRef } from 'react'
-import sub from '../orm/sub.js'
-import executionContextTracker from './executionContextTracker.js'
+import sub from '../orm/sub.ts'
+import executionContextTracker from './executionContextTracker.ts'
 
 // universal versions of sub() which work as a plain function or as a react hook
 export default function universalSub (...args) {
diff --git a/packages/teamplay/react/useApi.js b/packages/teamplay/react/useApi.js
deleted file mode 100644
index c360c38..0000000
--- a/packages/teamplay/react/useApi.js
+++ /dev/null
@@ -1,63 +0,0 @@
-import { useEffect, useRef, useState } from 'react'
-
-export default function useApi (api, args = [], options = {}) {
-  const { debounce = 0 } = options || {}
-  const [data, setData] = useState()
-  const [error, setError] = useState()
-  const [loading, setLoading] = useState(false)
-  const requestIdRef = useRef(0)
-  const stableArgs = useStableDeps(Array.isArray(args) ? args : [args])
-
-  useEffect(() => {
-    if (typeof api !== 'function') return
-    let cancelled = false
-    const requestId = ++requestIdRef.current
-    let timer
-
-    const run = async () => {
-      try {
-        setLoading(true)
-        const result = await api(...stableArgs)
-        if (cancelled || requestId !== requestIdRef.current) return
-        setData(result)
-        setError(undefined)
-      } catch (err) {
-        if (cancelled || requestId !== requestIdRef.current) return
-        setError(err)
-      } finally {
-        if (!cancelled && requestId === requestIdRef.current) setLoading(false)
-      }
-    }
-
-    if (debounce > 0) {
-      timer = setTimeout(run, debounce)
-    } else {
-      run()
-    }
-
-    return () => {
-      cancelled = true
-      if (timer) clearTimeout(timer)
-    }
-  }, [api, debounce, stableArgs])
-
-  return [data, loading, error]
-}
-
-function useStableDeps (deps) {
-  const depsRef = useRef([])
-  if (!shallowEqualArrays(depsRef.current, deps)) {
-    depsRef.current = deps
-  }
-  return depsRef.current
-}
-
-function shallowEqualArrays (a, b) {
-  if (a === b) return true
-  if (!Array.isArray(a) || !Array.isArray(b)) return false
-  if (a.length !== b.length) return false
-  for (let i = 0; i < a.length; i++) {
-    if (!Object.is(a[i], b[i])) return false
-  }
-  return true
-}
diff --git a/packages/teamplay/react/useApi.ts b/packages/teamplay/react/useApi.ts
new file mode 100644
index 0000000..9e93a09
--- /dev/null
+++ b/packages/teamplay/react/useApi.ts
@@ -0,0 +1,95 @@
+import { useEffect, useRef, useState } from 'react'
+
+export interface UseApiOptions {
+  debounce?: number
+}
+
+export type UseApiResult<TResult> = [
+  data: TResult | undefined,
+  loading: boolean,
+  error: unknown
+]
+
+type ApiFunction<TArgs extends readonly unknown[], TResult> =
+  (...args: TArgs) => TResult | Promise<TResult>
+
+export default function useApi<TResult> (
+  api: ApiFunction<[], TResult> | undefined,
+  args?: [],
+  options?: UseApiOptions
+): UseApiResult<Awaited<TResult>>
+export default function useApi<TArg, TResult> (
+  api: ApiFunction<[TArg], TResult> | undefined,
+  args: TArg,
+  options?: UseApiOptions
+): UseApiResult<Awaited<TResult>>
+export default function useApi<TArgs extends readonly unknown[], TResult> (
+  api: ApiFunction<TArgs, TResult> | undefined,
+  args: TArgs,
+  options?: UseApiOptions
+): UseApiResult<Awaited<TResult>>
+export default function useApi<TResult> (
+  api: ((...args: unknown[]) => TResult | Promise<TResult>) | undefined,
+  args: unknown | readonly unknown[] = [],
+  options: UseApiOptions = {}
+): UseApiResult<Awaited<TResult>> {
+  const { debounce = 0 } = options || {}
+  const [data, setData] = useState<Awaited<TResult> | undefined>()
+  const [error, setError] = useState<unknown>()
+  const [loading, setLoading] = useState(false)
+  const requestIdRef = useRef(0)
+  const stableArgs = useStableDeps(Array.isArray(args) ? args : [args])
+
+  useEffect(() => {
+    if (typeof api !== 'function') return
+    let cancelled = false
+    const requestId = ++requestIdRef.current
+    let timer: ReturnType<typeof setTimeout> | undefined
+
+    const run = async () => {
+      try {
+        setLoading(true)
+        const result = await api(...stableArgs)
+        if (cancelled || requestId !== requestIdRef.current) return
+        setData(result as Awaited<TResult>)
+        setError(undefined)
+      } catch (err) {
+        if (cancelled || requestId !== requestIdRef.current) return
+        setError(err)
+      } finally {
+        if (!cancelled && requestId === requestIdRef.current) setLoading(false)
+      }
+    }
+
+    if (debounce > 0) {
+      timer = setTimeout(run, debounce)
+    } else {
+      run()
+    }
+
+    return () => {
+      cancelled = true
+      if (timer) clearTimeout(timer)
+    }
+  }, [api, debounce, stableArgs])
+
+  return [data, loading, error]
+}
+
+function useStableDeps (deps: readonly unknown[]): readonly unknown[] {
+  const depsRef = useRef<readonly unknown[]>([])
+  if (!shallowEqualArrays(depsRef.current, deps)) {
+    depsRef.current = deps
+  }
+  return depsRef.current
+}
+
+function shallowEqualArrays (a: readonly unknown[], b: readonly unknown[]): boolean {
+  if (a === b) return true
+  if (!Array.isArray(a) || !Array.isArray(b)) return false
+  if (a.length !== b.length) return false
+  for (let i = 0; i < a.length; i++) {
+    if (!Object.is(a[i], b[i])) return false
+  }
+  return true
+}
diff --git a/packages/teamplay/react/useSub.js b/packages/teamplay/react/useSub.js
deleted file mode 100644
index 71d4d7d..0000000
--- a/packages/teamplay/react/useSub.js
+++ /dev/null
@@ -1,169 +0,0 @@
-import { useRef, useDeferredValue } from 'react'
-import sub from '../orm/sub.js'
-import { useScheduleUpdate, useCache, useDefer, useId } from './helpers.js'
-import executionContextTracker from './executionContextTracker.js'
-import * as promiseBatcher from './promiseBatcher.js'
-import renderAttemptDestroyer from './renderAttemptDestroyer.js'
-import { markCompatComponent } from './compatComponentRegistry.js'
-
-let TEST_THROTTLING = false
-
-// experimental feature to leverage useDeferredValue() to handle re-subscriptions.
-// Currently it does lead to issues with extra rerenders and requires further investigation
-let USE_DEFERRED_VALUE = true
-// by default we want to defer stuff if possible instead of throwing promises
-let DEFAULT_DEFER = true
-
-export function useAsyncSub (signal, params, options) {
-  return useSub(signal, params, { ...options, async: true })
-}
-
-export default function useSub (signal, params, options) {
-  if (USE_DEFERRED_VALUE) {
-    return useSubDeferred(signal, params, options) // eslint-disable-line react-hooks/rules-of-hooks
-  } else {
-    return useSubClassic(signal, params, options) // eslint-disable-line react-hooks/rules-of-hooks
-  }
-}
-
-// version of sub() which works as a react hook and throws promise for Suspense
-export function useSubDeferred (signal, params, { async = false, defer, batch = false, compatAttemptCleanup = false } = {}) {
-  const $signalRef = useRef() // eslint-disable-line react-hooks/rules-of-hooks
-  const componentId = useId()
-  const scheduleUpdate = useScheduleUpdate()
-  const observerDefer = useDefer()
-  if (compatAttemptCleanup) markCompatComponent(componentId)
-  if (batch) promiseBatcher.activate()
-  defer ??= observerDefer ?? DEFAULT_DEFER
-  if (defer) {
-    signal = useDeferredValue(signal) // eslint-disable-line react-hooks/rules-of-hooks
-    params = useDeferredValue(params ? JSON.stringify(params) : undefined) // eslint-disable-line react-hooks/rules-of-hooks
-    params = params != null ? JSON.parse(params) : undefined
-  }
-  const promiseOrSignal = params != null ? sub(signal, params) : sub(signal)
-  // 1. if it's a promise, throw it so that Suspense can catch it and wait for subscription to finish
-  if (promiseOrSignal.then) {
-    const promise = maybeThrottle(promiseOrSignal)
-    const hasPreviousSignal = !!$signalRef.current
-    if (batch) {
-      // Batch suspense must block only on initial load.
-      // On resubscribe we keep rendering previous signal and refresh in background.
-      if (!hasPreviousSignal) {
-        promiseBatcher.add(promise)
-        if (compatAttemptCleanup) registerCompatAttemptCleanup(signal, params)
-      } else {
-        scheduleUpdate(promise)
-      }
-      if (async) scheduleUpdate(promise)
-      return $signalRef.current
-    }
-    if (async) {
-      scheduleUpdate(promise)
-      return
-    }
-    // Keep previous snapshot during update re-subscribe and refresh in background.
-    if (hasPreviousSignal) {
-      scheduleUpdate(promise)
-      return $signalRef.current
-    }
-    if (compatAttemptCleanup) registerCompatAttemptCleanup(signal, params)
-    throw promise
-  // 2. if it's a signal, we save it into ref to make sure it's not garbage collected while component exists
-  } else {
-    const $signal = promiseOrSignal
-    if ($signalRef.current !== $signal) $signalRef.current = $signal
-    return $signal
-  }
-}
-
-// classic version which initially throws promise for Suspense
-// but if we get a promise second time, we return the last signal and wait for promise to resolve
-export function useSubClassic (signal, params, { async = false, batch = false, compatAttemptCleanup = false } = {}) {
-  const id = executionContextTracker.newHookId()
-  const componentId = useId()
-  const cache = useCache()
-  const activePromiseRef = useRef()
-  const scheduleUpdate = useScheduleUpdate()
-  if (compatAttemptCleanup) markCompatComponent(componentId)
-  if (batch) promiseBatcher.activate()
-  const promiseOrSignal = params != null ? sub(signal, params) : sub(signal)
-  // 1. if it's a promise, throw it so that Suspense can catch it and wait for subscription to finish
-  if (promiseOrSignal.then) {
-    const promise = maybeThrottle(promiseOrSignal)
-    if (batch) {
-      const hasPreviousSignal = cache.has(id)
-      // Batch suspense must block only on initial load.
-      // On resubscribe we keep rendering previous signal and refresh in background.
-      if (!hasPreviousSignal) {
-        promiseBatcher.add(promise)
-        if (compatAttemptCleanup) registerCompatAttemptCleanup(signal, params)
-      } else {
-        scheduleUpdate(promise)
-      }
-      if (async) scheduleUpdate(promise)
-      if (hasPreviousSignal) return cache.get(id)
-      return
-    }
-    // first time we just throw the promise to be caught by Suspense
-    if (!cache.has(id)) {
-      // if we are in async mode, we just return nothing and let the user
-      // handle appearance of signal on their own.
-      // We manually schedule an update when promise resolves since we can't
-      // rely on Suspense in this case to automatically trigger component's re-render
-      if (async) {
-        scheduleUpdate(promise)
-        return
-      }
-      if (compatAttemptCleanup) registerCompatAttemptCleanup(signal, params)
-      // in regular mode we throw the promise to be caught by Suspense
-      // this way we guarantee that the signal with all the data
-      // will always be there when component is rendered
-      throw promise
-    }
-    // if we already have a previous signal, we return it and wait for new promise to resolve
-    scheduleUpdate(promise)
-    return cache.get(id)
-  // 2. if it's a signal, we save it into ref to make sure it's not garbage collected while component exists
-  } else {
-    const $signal = promiseOrSignal
-    if (cache.get(id) !== $signal) {
-      activePromiseRef.current = undefined
-      cache.set(id, $signal)
-    }
-    return $signal
-  }
-}
-
-export function setTestThrottling (ms) {
-  if (typeof ms !== 'number') throw Error('setTestThrottling() accepts only a number in ms')
-  if (ms === 0) throw Error('setTestThrottling(0) is not allowed, use resetTestThrottling() instead')
-  if (ms < 0) throw Error('setTestThrottling() accepts only a positive number in ms')
-  TEST_THROTTLING = ms
-}
-export function resetTestThrottling () {
-  TEST_THROTTLING = false
-}
-export function setUseDeferredValue (value) {
-  USE_DEFERRED_VALUE = value
-}
-export function setDefaultDefer (value) {
-  DEFAULT_DEFER = value
-}
-
-// throttle to simulate slow network
-function maybeThrottle (promise) {
-  if (!TEST_THROTTLING) return promise
-  return new Promise((resolve, reject) => {
-    setTimeout(() => {
-      promise.then(resolve, reject)
-    }, TEST_THROTTLING)
-  })
-}
-
-function registerCompatAttemptCleanup (signal, params) {
-  // Compat hooks don't build per-hook init objects like Racer.
-  // We still need a marker so trapRender can defer observer-shell cleanup
-  // only when a real attempt cleanup exists.
-  // This path must not arm suspense-gate keep-alive by itself.
-  renderAttemptDestroyer.armCompatAttemptCleanup()
-}
diff --git a/packages/teamplay/react/useSub.ts b/packages/teamplay/react/useSub.ts
new file mode 100644
index 0000000..75910ea
--- /dev/null
+++ b/packages/teamplay/react/useSub.ts
@@ -0,0 +1,372 @@
+import { useRef, useDeferredValue } from 'react'
+import type { AggregationFunction, AggregationParams, ClientAggregationFunction } from '@teamplay/utils/aggregation'
+import sub from '../orm/sub.ts'
+import { useScheduleUpdate, useCache, useDefer, useId } from './helpers.ts'
+import executionContextTracker from './executionContextTracker.ts'
+import * as promiseBatcher from './promiseBatcher.ts'
+import renderAttemptDestroyer from './renderAttemptDestroyer.ts'
+import { markCompatComponent } from './compatComponentRegistry.ts'
+import type {
+  CollectionSignal,
+  DocumentSignal,
+  QueryParams,
+  RegisteredAggregationInput,
+  SignalModelConstructor,
+  SubResult,
+  TypedAggregationInput,
+  TypedAggregationSignal,
+  WildcardSignalPath
+} from '../orm/Signal.ts'
+
+type RuntimeSub = (signal: unknown, params?: unknown) => unknown
+const runtimeSub = sub as RuntimeSub
+
+export interface UseSubOptions {
+  /** Return `undefined` while loading instead of throwing a Suspense promise. */
+  async?: boolean
+  /** Defer re-subscriptions. Pass a number to use a custom delay. */
+  defer?: boolean | number
+  /** Batch Suspense promises across multiple subscriptions in one render attempt. */
+  batch?: boolean
+  /** Enable compatibility cleanup for legacy observer render attempts. */
+  compatAttemptCleanup?: boolean
+}
+
+let TEST_THROTTLING: false | number = false
+
+// experimental feature to leverage useDeferredValue() to handle re-subscriptions.
+// Currently it does lead to issues with extra rerenders and requires further investigation
+let USE_DEFERRED_VALUE: boolean = true
+// by default we want to defer stuff if possible instead of throwing promises
+let DEFAULT_DEFER: boolean = true
+
+/**
+ * Subscribe to a document signal in React async mode.
+ * @param signal Document signal to subscribe to.
+ * @param params Must be omitted for document subscriptions.
+ * @param options Subscription behavior options.
+ */
+export function useAsyncSub<TSignal extends DocumentSignal<any, any, any>> (
+  signal: TSignal,
+  params?: undefined,
+  options?: UseSubOptions
+): SubResult<TSignal>
+
+/**
+ * Subscribe to a collection query in React async mode.
+ * @param signal Collection signal to query.
+ * @param params Mongo-style query params, including filters and `$sort`.
+ * @param options Subscription behavior options.
+ */
+export function useAsyncSub<
+  TDocument,
+  TCollectionModel extends SignalModelConstructor<TDocument[]>,
+  TDocumentModel extends SignalModelConstructor<TDocument>,
+  TCollectionPath extends WildcardSignalPath
+> (
+  signal: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>,
+  params: QueryParams<TDocument>,
+  options?: UseSubOptions
+): SubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, QueryParams<TDocument>>
+
+/**
+ * Subscribe to a registered collection aggregation in React async mode.
+ * @param signal Aggregation header generated by StartupJS model loading.
+ * @param params Parameters passed to the aggregation.
+ * @param options Subscription behavior options.
+ */
+export function useAsyncSub<TCollection extends string, TOutput = unknown> (
+  signal: RegisteredAggregationInput<TCollection, TOutput>,
+  params?: AggregationParams,
+  options?: UseSubOptions
+): SubResult<RegisteredAggregationInput<TCollection, TOutput>>
+
+/**
+ * Subscribe to a client aggregation in React async mode.
+ * @param signal Aggregation function created with `aggregation(collection, fn)`.
+ * @param params Parameters passed to the aggregation.
+ * @param options Subscription behavior options.
+ */
+export function useAsyncSub<TOutput, TCollection extends string> (
+  signal: ClientAggregationFunction<TOutput, TCollection>,
+  params?: AggregationParams,
+  options?: UseSubOptions
+): SubResult<ClientAggregationFunction<TOutput, TCollection>>
+
+/**
+ * Subscribe to an aggregation with explicit output typing in React async mode.
+ * @param signal Typed aggregation input.
+ * @param params Parameters passed to the aggregation.
+ * @param options Subscription behavior options.
+ */
+export function useAsyncSub<
+  TDocument,
+  TDocumentModel extends SignalModelConstructor<TDocument>
+> (
+  signal: TypedAggregationInput<TDocument, TDocumentModel>,
+  params?: AggregationParams,
+  options?: UseSubOptions
+): TypedAggregationSignal<TDocument, TDocumentModel>
+
+/**
+ * Subscribe to an unregistered aggregation in React async mode.
+ * @param signal Aggregation function.
+ * @param params Parameters passed to the aggregation.
+ * @param options Subscription behavior options.
+ */
+export function useAsyncSub<TOutput = unknown, TCollection extends string = string> (
+  signal: AggregationFunction<TOutput, TCollection>,
+  params?: AggregationParams,
+  options?: UseSubOptions
+): SubResult<AggregationFunction<TOutput, TCollection>, AggregationParams | undefined>
+
+export function useAsyncSub (signal: unknown, params?: unknown, options?: UseSubOptions): unknown {
+  return runUseSub(signal, params, { ...options, async: true })
+}
+
+/**
+ * Subscribe to a document signal in React.
+ * @param signal Document signal to subscribe to.
+ * @param params Must be omitted for document subscriptions.
+ * @param options Subscription behavior options.
+ */
+export default function useSub<TSignal extends DocumentSignal<any, any, any>> (
+  signal: TSignal,
+  params?: undefined,
+  options?: UseSubOptions
+): SubResult<TSignal>
+
+/**
+ * Subscribe to a collection query in React.
+ * @param signal Collection signal to query.
+ * @param params Mongo-style query params, including filters and `$sort`.
+ * @param options Subscription behavior options.
+ */
+export default function useSub<
+  TDocument,
+  TCollectionModel extends SignalModelConstructor<TDocument[]>,
+  TDocumentModel extends SignalModelConstructor<TDocument>,
+  TCollectionPath extends WildcardSignalPath
+> (
+  signal: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>,
+  params: QueryParams<TDocument>,
+  options?: UseSubOptions
+): SubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, QueryParams<TDocument>>
+
+/**
+ * Subscribe to a registered collection aggregation in React.
+ * @param signal Aggregation header generated by StartupJS model loading.
+ * @param params Parameters passed to the aggregation.
+ * @param options Subscription behavior options.
+ */
+export default function useSub<TCollection extends string, TOutput = unknown> (
+  signal: RegisteredAggregationInput<TCollection, TOutput>,
+  params?: AggregationParams,
+  options?: UseSubOptions
+): SubResult<RegisteredAggregationInput<TCollection, TOutput>>
+
+/**
+ * Subscribe to a client aggregation in React.
+ * @param signal Aggregation function created with `aggregation(collection, fn)`.
+ * @param params Parameters passed to the aggregation.
+ * @param options Subscription behavior options.
+ */
+export default function useSub<TOutput, TCollection extends string> (
+  signal: ClientAggregationFunction<TOutput, TCollection>,
+  params?: AggregationParams,
+  options?: UseSubOptions
+): SubResult<ClientAggregationFunction<TOutput, TCollection>>
+
+/**
+ * Subscribe to an aggregation with explicit output typing in React.
+ * @param signal Typed aggregation input.
+ * @param params Parameters passed to the aggregation.
+ * @param options Subscription behavior options.
+ */
+export default function useSub<
+  TDocument,
+  TDocumentModel extends SignalModelConstructor<TDocument>
+> (
+  signal: TypedAggregationInput<TDocument, TDocumentModel>,
+  params?: AggregationParams,
+  options?: UseSubOptions
+): TypedAggregationSignal<TDocument, TDocumentModel>
+
+/**
+ * Subscribe to an unregistered aggregation in React.
+ * @param signal Aggregation function.
+ * @param params Parameters passed to the aggregation.
+ * @param options Subscription behavior options.
+ */
+export default function useSub<TOutput = unknown, TCollection extends string = string> (
+  signal: AggregationFunction<TOutput, TCollection>,
+  params?: AggregationParams,
+  options?: UseSubOptions
+): SubResult<AggregationFunction<TOutput, TCollection>, AggregationParams | undefined>
+
+export default function useSub (signal: unknown, params?: unknown, options?: UseSubOptions): unknown {
+  return runUseSub(signal, params, options)
+}
+
+function runUseSub (signal: unknown, params?: unknown, options?: UseSubOptions): unknown {
+  if (USE_DEFERRED_VALUE) {
+    return useSubDeferred(signal, params, options) // eslint-disable-line react-hooks/rules-of-hooks
+  } else {
+    return useSubClassic(signal, params, options) // eslint-disable-line react-hooks/rules-of-hooks
+  }
+}
+
+// version of sub() which works as a react hook and throws promise for Suspense
+export function useSubDeferred (
+  signal: unknown,
+  params?: unknown,
+  { async = false, defer, batch = false, compatAttemptCleanup = false }: UseSubOptions = {}
+): unknown {
+  const $signalRef = useRef<unknown>()
+  const componentId = useId()
+  const scheduleUpdate = useScheduleUpdate()
+  const observerDefer = useDefer()
+  if (compatAttemptCleanup) markCompatComponent(componentId)
+  if (batch) promiseBatcher.activate()
+  defer ??= observerDefer ?? DEFAULT_DEFER
+  if (defer) {
+    signal = useDeferredValue(signal) // eslint-disable-line react-hooks/rules-of-hooks
+    const serializedParams = useDeferredValue(params ? JSON.stringify(params) : undefined) // eslint-disable-line react-hooks/rules-of-hooks
+    params = serializedParams != null ? JSON.parse(serializedParams) : undefined
+  }
+  const promiseOrSignal = params != null ? runtimeSub(signal, params) : runtimeSub(signal)
+  // 1. if it's a promise, throw it so that Suspense can catch it and wait for subscription to finish
+  if (isThenable(promiseOrSignal)) {
+    const promise = maybeThrottle(promiseOrSignal)
+    const hasPreviousSignal = !!$signalRef.current
+    if (batch) {
+      // Batch suspense must block only on initial load.
+      // On resubscribe we keep rendering previous signal and refresh in background.
+      if (!hasPreviousSignal) {
+        promiseBatcher.add(promise)
+        if (compatAttemptCleanup) registerCompatAttemptCleanup(signal, params)
+      } else {
+        scheduleUpdate(promise)
+      }
+      if (async) scheduleUpdate(promise)
+      return $signalRef.current
+    }
+    if (async) {
+      scheduleUpdate(promise)
+      return
+    }
+    // Keep previous snapshot during update re-subscribe and refresh in background.
+    if (hasPreviousSignal) {
+      scheduleUpdate(promise)
+      return $signalRef.current
+    }
+    if (compatAttemptCleanup) registerCompatAttemptCleanup(signal, params)
+    throw promise
+  // 2. if it's a signal, we save it into ref to make sure it's not garbage collected while component exists
+  } else {
+    const $signal = promiseOrSignal
+    if ($signalRef.current !== $signal) $signalRef.current = $signal
+    return $signal
+  }
+}
+
+// classic version which initially throws promise for Suspense
+// but if we get a promise second time, we return the last signal and wait for promise to resolve
+export function useSubClassic (
+  signal: unknown,
+  params?: unknown,
+  { async = false, batch = false, compatAttemptCleanup = false }: UseSubOptions = {}
+): unknown {
+  const id = executionContextTracker.newHookId()
+  const componentId = useId()
+  const cache = useCache(undefined)
+  const scheduleUpdate = useScheduleUpdate()
+  if (compatAttemptCleanup) markCompatComponent(componentId)
+  if (batch) promiseBatcher.activate()
+  const promiseOrSignal = params != null ? runtimeSub(signal, params) : runtimeSub(signal)
+  // 1. if it's a promise, throw it so that Suspense can catch it and wait for subscription to finish
+  if (isThenable(promiseOrSignal)) {
+    const promise = maybeThrottle(promiseOrSignal)
+    if (batch) {
+      const hasPreviousSignal = cache.has(id)
+      // Batch suspense must block only on initial load.
+      // On resubscribe we keep rendering previous signal and refresh in background.
+      if (!hasPreviousSignal) {
+        promiseBatcher.add(promise)
+        if (compatAttemptCleanup) registerCompatAttemptCleanup(signal, params)
+      } else {
+        scheduleUpdate(promise)
+      }
+      if (async) scheduleUpdate(promise)
+      if (hasPreviousSignal) return cache.get(id)
+      return
+    }
+    // first time we just throw the promise to be caught by Suspense
+    if (!cache.has(id)) {
+      // if we are in async mode, we just return nothing and let the user
+      // handle appearance of signal on their own.
+      // We manually schedule an update when promise resolves since we can't
+      // rely on Suspense in this case to automatically trigger component's re-render
+      if (async) {
+        scheduleUpdate(promise)
+        return
+      }
+      if (compatAttemptCleanup) registerCompatAttemptCleanup(signal, params)
+      // in regular mode we throw the promise to be caught by Suspense
+      // this way we guarantee that the signal with all the data
+      // will always be there when component is rendered
+      throw promise
+    }
+    // if we already have a previous signal, we return it and wait for new promise to resolve
+    scheduleUpdate(promise)
+    return cache.get(id)
+  // 2. if it's a signal, we save it into ref to make sure it's not garbage collected while component exists
+  } else {
+    const $signal = promiseOrSignal
+    if (cache.get(id) !== $signal) {
+      cache.set(id, $signal)
+    }
+    return $signal
+  }
+}
+
+export function setTestThrottling (ms: number): void {
+  if (typeof ms !== 'number') throw Error('setTestThrottling() accepts only a number in ms')
+  if (ms === 0) throw Error('setTestThrottling(0) is not allowed, use resetTestThrottling() instead')
+  if (ms < 0) throw Error('setTestThrottling() accepts only a positive number in ms')
+  TEST_THROTTLING = ms
+}
+export function resetTestThrottling (): void {
+  TEST_THROTTLING = false
+}
+export function setUseDeferredValue (value: boolean): void {
+  USE_DEFERRED_VALUE = value
+}
+export function setDefaultDefer (value: boolean): void {
+  DEFAULT_DEFER = value
+}
+
+// throttle to simulate slow network
+function maybeThrottle<TValue> (promise: Promise<TValue>): Promise<TValue> {
+  const delay = TEST_THROTTLING
+  if (delay === false) return promise
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      promise.then(resolve, reject)
+    }, delay)
+  })
+}
+
+function isThenable<TValue = unknown> (value: unknown): value is Promise<TValue> {
+  return !!value &&
+    (typeof value === 'object' || typeof value === 'function') &&
+    typeof (value as { then?: unknown }).then === 'function'
+}
+
+function registerCompatAttemptCleanup (_signal: unknown, _params: unknown): void {
+  // Compat hooks don't build per-hook init objects like Racer.
+  // We still need a marker so trapRender can defer observer-shell cleanup
+  // only when a real attempt cleanup exists.
+  // This path must not arm suspense-gate keep-alive by itself.
+  renderAttemptDestroyer.armCompatAttemptCleanup()
+}
diff --git a/packages/teamplay/react/useSuspendMemo.js b/packages/teamplay/react/useSuspendMemo.ts
similarity index 61%
rename from packages/teamplay/react/useSuspendMemo.js
rename to packages/teamplay/react/useSuspendMemo.ts
index 934f7ff..98dad8a 100644
--- a/packages/teamplay/react/useSuspendMemo.js
+++ b/packages/teamplay/react/useSuspendMemo.ts
@@ -1,20 +1,30 @@
-import executionContextTracker from './executionContextTracker.js'
-import { useCache, useId } from './helpers.js'
-import { markCompatComponent } from './compatComponentRegistry.js'
-import renderAttemptDestroyer from './renderAttemptDestroyer.js'
+import executionContextTracker from './executionContextTracker.ts'
+import { useCache, useId } from './helpers.ts'
+import { markCompatComponent } from './compatComponentRegistry.ts'
+import renderAttemptDestroyer from './renderAttemptDestroyer.ts'
 
-const IN_FLIGHT_BY_KEY = new Map()
+const IN_FLIGHT_BY_KEY = new Map<unknown, Promise<unknown>>()
 
-export default function useSuspendMemo (factory, deps) {
+type CacheEntry<TValue> = {
+  deps: unknown[]
+  status: 'cold' | 'pending' | 'done'
+  value?: TValue
+  promise?: Promise<unknown>
+}
+
+export default function useSuspendMemo<TValue> (
+  factory: () => TValue,
+  deps?: readonly unknown[]
+): TValue {
   if (typeof factory !== 'function') throw Error('useSuspendMemo() expects a factory function')
   deps = normalizeDeps(deps)
 
   const componentId = useId()
-  const cache = useCache()
+  const cache = useCache(undefined)
   const hookId = executionContextTracker.newHookId()
   const cacheKey = `suspendMemo:${hookId}`
 
-  let entry = cache.get(cacheKey)
+  let entry = cache.get(cacheKey) as CacheEntry<TValue> | undefined
   if (!entry || !shallowEqualArrays(entry.deps, deps)) {
     entry = {
       deps: [...deps],
@@ -25,7 +35,7 @@ export default function useSuspendMemo (factory, deps) {
     cache.set(cacheKey, entry)
   }
 
-  if (entry.status === 'done') return entry.value
+  if (entry.status === 'done') return entry.value as TValue
   if (entry.status === 'pending') {
     markCompatComponent(componentId)
     renderAttemptDestroyer.armSuspenseGate()
@@ -52,7 +62,11 @@ export default function useSuspendMemo (factory, deps) {
   }
 }
 
-export function useSuspendMemoByKey (key, factory, deps) {
+export function useSuspendMemoByKey<TValue> (
+  key: unknown,
+  factory: () => TValue,
+  deps?: readonly unknown[]
+): TValue {
   if (key == null) throw Error('useSuspendMemoByKey() expects a non-null key')
   return useSuspendMemo(() => {
     const inFlight = IN_FLIGHT_BY_KEY.get(key)
@@ -71,17 +85,17 @@ export function useSuspendMemoByKey (key, factory, deps) {
   }, [key, ...normalizeDeps(deps)])
 }
 
-export function __resetSuspendMemoForTests () {
+export function __resetSuspendMemoForTests (): void {
   IN_FLIGHT_BY_KEY.clear()
 }
 
-function normalizeDeps (deps) {
+function normalizeDeps (deps: readonly unknown[] | undefined): readonly unknown[] {
   if (deps == null) return []
   if (!Array.isArray(deps)) throw Error('useSuspendMemo() expects deps to be an array')
   return deps
 }
 
-function shallowEqualArrays (a, b) {
+function shallowEqualArrays (a: readonly unknown[], b: readonly unknown[]): boolean {
   if (a === b) return true
   if (!Array.isArray(a) || !Array.isArray(b)) return false
   if (a.length !== b.length) return false
@@ -91,6 +105,8 @@ function shallowEqualArrays (a, b) {
   return true
 }
 
-function isThenable (value) {
-  return !!value && typeof value.then === 'function'
+function isThenable (value: unknown): value is PromiseLike<unknown> {
+  return !!value &&
+    (typeof value === 'object' || typeof value === 'function') &&
+    typeof (value as { then?: unknown }).then === 'function'
 }
diff --git a/packages/teamplay/react/wrapIntoSuspense.d.ts b/packages/teamplay/react/wrapIntoSuspense.d.ts
new file mode 100644
index 0000000..6d8b91e
--- /dev/null
+++ b/packages/teamplay/react/wrapIntoSuspense.d.ts
@@ -0,0 +1,9 @@
+import type * as React from 'react'
+import type { ConvertedObserver } from './convertToObserver.js'
+
+export interface WrapIntoSuspenseOptions<TProps extends object = Record<string, unknown>, TRef = unknown>
+  extends ConvertedObserver<TProps, TRef> {}
+
+export default function wrapIntoSuspense<TProps extends object, TRef = unknown> (
+  options?: WrapIntoSuspenseOptions<TProps, TRef>
+): React.NamedExoticComponent<TProps>
diff --git a/packages/teamplay/react/wrapIntoSuspense.js b/packages/teamplay/react/wrapIntoSuspense.js
index 42c66b8..7653696 100644
--- a/packages/teamplay/react/wrapIntoSuspense.js
+++ b/packages/teamplay/react/wrapIntoSuspense.js
@@ -1,7 +1,7 @@
 // useSyncExternalStore is used to trigger an update same as in MobX
 // ref: https://github.com/mobxjs/mobx/blob/94bc4997c14152ff5aefcaac64d982d5c21ba51a/packages/mobx-react-lite/src/useObserver.ts
 import { useSyncExternalStore, forwardRef as _forwardRef, memo, createElement as el, Suspense, useId, useRef } from 'react'
-import { pipeComponentMeta, pipeComponentDisplayName, ComponentMetaContext } from './helpers.js'
+import { pipeComponentMeta, pipeComponentDisplayName, ComponentMetaContext } from './helpers.ts'
 
 // TODO: probably add FinalizationRegistry to handle destruction of observer() before it ever mounted.
 //       In such case we might have a memory leak because subscribe() would never fire and would never
diff --git a/packages/teamplay/server.js b/packages/teamplay/server.js
index 463dc32..bd333c1 100644
--- a/packages/teamplay/server.js
+++ b/packages/teamplay/server.js
@@ -1,9 +1,10 @@
 import createChannel from '@teamplay/channel/server'
-import { connection, setConnection, setDefaultFetchOnly, setPublicOnly } from './orm/connection.js'
+import backendCreateBackend from '@teamplay/backend'
+import { getModels } from './orm/initModels.ts'
+import { connection, setConnection, setDefaultFetchOnly, setPublicOnly } from './orm/connection.ts'
 
 export { default as ShareDB } from 'sharedb'
 export {
-  default as createBackend,
   mongo,
   mongoClient,
   createMongoIndex,
@@ -17,6 +18,22 @@ export {
   generateRedisPrefix
 } from '@teamplay/backend'
 
+export function createBackend (options = {}) {
+  let nextOptions = options
+  const initializedModels = getModels()
+
+  if (!('models' in nextOptions) && Object.keys(initializedModels).length > 0) {
+    nextOptions = {
+      ...nextOptions,
+      models: initializedModels
+    }
+  }
+
+  return backendCreateBackend(nextOptions)
+}
+
+export default createBackend
+
 export function initConnection (backend, {
   fetchOnly = true,
   publicOnly = true,
diff --git a/packages/teamplay/teamplay.models.auto-init.virtual.js b/packages/teamplay/teamplay.models.auto-init.virtual.js
new file mode 100644
index 0000000..186b120
--- /dev/null
+++ b/packages/teamplay/teamplay.models.auto-init.virtual.js
@@ -0,0 +1 @@
+export default true
diff --git a/packages/teamplay/teamplay.models.virtual.js b/packages/teamplay/teamplay.models.virtual.js
new file mode 100644
index 0000000..b1c6ea4
--- /dev/null
+++ b/packages/teamplay/teamplay.models.virtual.js
@@ -0,0 +1 @@
+export default {}
diff --git a/packages/teamplay/test/$.js b/packages/teamplay/test/$.js
index ba5513a..19270ea 100644
--- a/packages/teamplay/test/$.js
+++ b/packages/teamplay/test/$.js
@@ -2,8 +2,8 @@ import React from 'react'
 import { it, describe, afterEach, before } from 'mocha'
 import { strict as assert } from 'node:assert'
 import { afterEachTestGc, runGc } from './_helpers.js'
-import { $, batch, batchModel, clone, initLocalCollection, __DEBUG_SIGNALS_CACHE__ as signalsCache } from '../index.js'
-import { GLOBAL_ROOT_ID } from '../orm/Root.js'
+import { $, batch, batchModel, clone, initLocalCollection, __DEBUG_SIGNALS_CACHE__ as signalsCache } from '../index.ts'
+import { GLOBAL_ROOT_ID } from '../orm/Root.ts'
 import { LOCAL } from '../orm/$.js'
 import { delPrivateData, getPrivateData } from '../orm/privateData.js'
 import { del as _del, set as _set } from '../orm/dataTree.js'
@@ -185,6 +185,23 @@ describe('Signal array mutators (local)', () => {
     assert.equal($text.get(), 'Xc')
   })
 
+  it('forwards optional array method arguments on local signals', () => {
+    const $players = $([{ name: 'A', score: 1 }, { name: 'B', score: 2 }])
+    const labels = $players.map(function ($player) {
+      return `${this.prefix}${$player.name.get()}`
+    }, { prefix: '#' })
+    const total = $players.reduce(($firstPlayer, $secondPlayer) => {
+      return $firstPlayer.score.get() + $secondPlayer.score.get()
+    })
+    const found = $players.find(function ($player) {
+      return $player.score.get() === this.score
+    }, { score: 2 })
+
+    assert.deepEqual(labels, ['#A', '#B'])
+    assert.equal(total, 3)
+    assert.equal(found.name.get(), 'B')
+  })
+
   it('initializes missing nested array paths for local signals', async () => {
     const $state = $({})
 
diff --git a/packages/teamplay/test/_helpers.js b/packages/teamplay/test/_helpers.js
index 87ce29d..8061943 100644
--- a/packages/teamplay/test/_helpers.js
+++ b/packages/teamplay/test/_helpers.js
@@ -1,9 +1,9 @@
 import { before, beforeEach, afterEach } from 'mocha'
 import { strict as assert } from 'node:assert'
-import { __DEBUG_SIGNALS_CACHE__ as signalsCache } from '../index.js'
+import { __DEBUG_SIGNALS_CACHE__ as signalsCache } from '../index.ts'
 import { docSubscriptions } from '../orm/Doc.js'
 import { querySubscriptions } from '../orm/Query.js'
-import { getSubscriptionGcDelay, setSubscriptionGcDelay } from '../orm/subscriptionGcDelay.js'
+import { getSubscriptionGcDelay, setSubscriptionGcDelay } from '../orm/subscriptionGcDelay.ts'
 
 // the cache is not getting cleared if we just call global.gc()
 // so we need to wait for the next tick before and after calling it.
diff --git a/packages/teamplay/test/aggregationEvents.js b/packages/teamplay/test/aggregationEvents.js
index e572826..2b55c1c 100644
--- a/packages/teamplay/test/aggregationEvents.js
+++ b/packages/teamplay/test/aggregationEvents.js
@@ -1,7 +1,7 @@
 import { it, describe, before } from 'mocha'
 import { strict as assert } from 'node:assert'
 import { afterEachTestGc, runGc } from './_helpers.js'
-import { $, sub, aggregation } from '../index.js'
+import { $, sub, aggregation } from '../index.ts'
 import { aggregationSubscriptions } from '../orm/Aggregation.js'
 import connect from '../connect/test.js'
 
@@ -40,10 +40,10 @@ describe('Aggregation Subscriptions - Server-side Tests', () => {
   afterEachTestGc()
 
   it('basic aggregation subscribe with server-side function', async () => {
-    const $$items = aggregation(({ active }) => {
+    const _items = aggregation(({ active }) => {
       return [{ $match: { active } }]
     })
-    const $items = await sub($$items, { $collection: itemsCollection, active: true })
+    const $items = await sub(_items, { $collection: itemsCollection, active: true })
 
     assert.equal($items.get().length, 3, 'should have 3 active items')
 
@@ -60,10 +60,10 @@ describe('Aggregation Subscriptions - Server-side Tests', () => {
 
   it('aggregation parameter changes', async () => {
     // Subscribe with active: true
-    const $$items = aggregation(({ active }) => {
+    const _items = aggregation(({ active }) => {
       return [{ $match: { active } }]
     })
-    let $items = await sub($$items, { $collection: itemsCollection, active: true })
+    let $items = await sub(_items, { $collection: itemsCollection, active: true })
 
     assert.equal($items.get().length, 3, 'should have 3 active items')
     assert.equal(aggregationSubscriptions.queries.size, 1, 'one aggregation query tracked')
@@ -76,7 +76,7 @@ describe('Aggregation Subscriptions - Server-side Tests', () => {
     assert.equal(aggregationSubscriptions.queries.size, 0, 'aggregation query cleaned up after GC')
 
     // Resubscribe with different params (active: false)
-    $items = await sub($$items, { $collection: itemsCollection, active: false })
+    $items = await sub(_items, { $collection: itemsCollection, active: false })
 
     assert.equal($items.get().length, 1, 'should have 1 inactive item')
     const results = sanitizeAggregationResult($items.get())
@@ -86,12 +86,12 @@ describe('Aggregation Subscriptions - Server-side Tests', () => {
   })
 
   it('aggregation reference counting', async () => {
-    const $$items = aggregation(({ active }) => {
+    const _items = aggregation(({ active }) => {
       return [{ $match: { active } }]
     })
 
     // Subscribe first time
-    let $items1 = await sub($$items, { $collection: itemsCollection, active: true })
+    let $items1 = await sub(_items, { $collection: itemsCollection, active: true })
     assert.equal($items1.get().length, 3)
 
     // Get the hash to check subscription count
@@ -99,7 +99,7 @@ describe('Aggregation Subscriptions - Server-side Tests', () => {
     assert.equal(aggregationSubscriptions.subCount.get(hash), 1, 'subscription count is 1')
 
     // Subscribe second time with same params
-    let $items2 = await sub($$items, { $collection: itemsCollection, active: true })
+    let $items2 = await sub(_items, { $collection: itemsCollection, active: true })
     assert.equal($items2.get().length, 3)
 
     // Check if both signals are the same object (due to signal caching)
@@ -152,10 +152,10 @@ describe('Aggregation Subscriptions - Server-side Tests', () => {
   })
 
   it('aggregation result updates when underlying data changes', async () => {
-    const $$items = aggregation(({ active }) => {
+    const _items = aggregation(({ active }) => {
       return [{ $match: { active } }]
     })
-    const $items = await sub($$items, { $collection: itemsCollection, active: true })
+    const $items = await sub(_items, { $collection: itemsCollection, active: true })
 
     assert.equal($items.get().length, 3, 'initially 3 active items')
 
@@ -175,13 +175,13 @@ describe('Aggregation Subscriptions - Server-side Tests', () => {
   })
 
   it('aggregation with $sort', async () => {
-    const $$items = aggregation(({ active }) => {
+    const _items = aggregation(({ active }) => {
       return [
         { $match: { active } },
         { $sort: { price: 1 } } // ascending by price
       ]
     })
-    const $items = await sub($$items, { $collection: itemsCollection, active: true })
+    const $items = await sub(_items, { $collection: itemsCollection, active: true })
 
     assert.equal($items.get().length, 3, 'should have 3 active items')
 
@@ -202,11 +202,11 @@ describe('Aggregation Subscriptions - Server-side Tests', () => {
   })
 
   it('GC cleanup for aggregation signals', async () => {
-    const $$items = aggregation(({ category }) => {
+    const _items = aggregation(({ category }) => {
       return [{ $match: { category } }]
     })
 
-    let $items = await sub($$items, { $collection: itemsCollection, category: 'A' })
+    let $items = await sub(_items, { $collection: itemsCollection, category: 'A' })
 
     assert.equal($items.get().length, 2, 'should have 2 items in category A')
     assert.equal(aggregationSubscriptions.queries.size, 1, 'one aggregation query tracked')
@@ -225,16 +225,16 @@ describe('Aggregation Subscriptions - Server-side Tests', () => {
 
   it('multiple aggregations on same collection', async () => {
     // First aggregation: active items
-    const $$activeItems = aggregation(({ active }) => {
+    const _activeItems = aggregation(({ active }) => {
       return [{ $match: { active } }]
     })
-    const $activeItems = await sub($$activeItems, { $collection: itemsCollection, active: true })
+    const $activeItems = await sub(_activeItems, { $collection: itemsCollection, active: true })
 
     // Second aggregation: category A items
-    const $$categoryAItems = aggregation(({ category }) => {
+    const _categoryAItems = aggregation(({ category }) => {
       return [{ $match: { category } }]
     })
-    const $categoryAItems = await sub($$categoryAItems, { $collection: itemsCollection, category: 'A' })
+    const $categoryAItems = await sub(_categoryAItems, { $collection: itemsCollection, category: 'A' })
 
     // Verify both aggregations work independently
     assert.equal($activeItems.get().length, 3, 'active items aggregation has 3 items')
@@ -271,13 +271,13 @@ describe('Aggregation Subscriptions - Server-side Tests', () => {
   })
 
   it('aggregation with $group and $project', async () => {
-    const $$itemsByCategory = aggregation(() => {
+    const _itemsByCategory = aggregation(() => {
       return [
         { $group: { _id: '$category', count: { $sum: 1 }, totalPrice: { $sum: '$price' } } },
         { $sort: { _id: 1 } }
       ]
     })
-    const $itemsByCategory = await sub($$itemsByCategory, { $collection: itemsCollection })
+    const $itemsByCategory = await sub(_itemsByCategory, { $collection: itemsCollection })
 
     const results = sanitizeAggregationResult($itemsByCategory.get())
 
@@ -297,14 +297,14 @@ describe('Aggregation Subscriptions - Server-side Tests', () => {
   })
 
   it('aggregation with $limit', async () => {
-    const $$limitedItems = aggregation(({ active }) => {
+    const _limitedItems = aggregation(({ active }) => {
       return [
         { $match: { active } },
         { $sort: { price: -1 } }, // descending by price
         { $limit: 2 }
       ]
     })
-    const $limitedItems = await sub($$limitedItems, { $collection: itemsCollection, active: true })
+    const $limitedItems = await sub(_limitedItems, { $collection: itemsCollection, active: true })
 
     const results = sanitizeAggregationResult($limitedItems.get())
 
@@ -316,10 +316,10 @@ describe('Aggregation Subscriptions - Server-side Tests', () => {
   })
 
   it('aggregation result updates when document changes matching criteria', async () => {
-    const $$activeItems = aggregation(({ active }) => {
+    const _activeItems = aggregation(({ active }) => {
       return [{ $match: { active } }]
     })
-    const $activeItems = await sub($$activeItems, { $collection: itemsCollection, active: true })
+    const $activeItems = await sub(_activeItems, { $collection: itemsCollection, active: true })
 
     assert.equal($activeItems.get().length, 3, 'initially 3 active items')
 
@@ -346,13 +346,13 @@ describe('Aggregation Subscriptions - Server-side Tests', () => {
   })
 
   it('aggregation getIds() returns array of document IDs', async () => {
-    const $$items = aggregation(({ active }) => {
+    const _items = aggregation(({ active }) => {
       return [
         { $match: { active } },
         { $sort: { price: 1 } }
       ]
     })
-    const $items = await sub($$items, { $collection: itemsCollection, active: true })
+    const $items = await sub(_items, { $collection: itemsCollection, active: true })
 
     const ids = $items.getIds()
 
@@ -362,10 +362,10 @@ describe('Aggregation Subscriptions - Server-side Tests', () => {
   })
 
   it('aggregation is iterable', async () => {
-    const $$items = aggregation(({ active }) => {
+    const _items = aggregation(({ active }) => {
       return [{ $match: { active } }]
     })
-    const $items = await sub($$items, { $collection: itemsCollection, active: true })
+    const $items = await sub(_items, { $collection: itemsCollection, active: true })
 
     const itemsArray = [...$items]
     assert.equal(itemsArray.length, 3, 'can spread aggregation into array')
@@ -378,10 +378,10 @@ describe('Aggregation Subscriptions - Server-side Tests', () => {
   })
 
   it('aggregation supports .map()', async () => {
-    const $$items = aggregation(({ active }) => {
+    const _items = aggregation(({ active }) => {
       return [{ $match: { active } }]
     })
-    const $items = await sub($$items, { $collection: itemsCollection, active: true })
+    const $items = await sub(_items, { $collection: itemsCollection, active: true })
 
     const names = $items.map($item => $item.name.get()).sort()
 
diff --git a/packages/teamplay/test/constructorStaticAccess.js b/packages/teamplay/test/constructorStaticAccess.js
index 662d4ee..9ebd90a 100644
--- a/packages/teamplay/test/constructorStaticAccess.js
+++ b/packages/teamplay/test/constructorStaticAccess.js
@@ -1,7 +1,7 @@
 import { describe, it } from 'mocha'
 import { strict as assert } from 'node:assert'
-import { $, addModel } from '../index.js'
-import Signal from '../orm/Signal.js'
+import { $, addModel } from '../index.ts'
+import Signal from '../orm/Signal.ts'
 
 describe('Signal method this.constructor static access', () => {
   it('resolves constructor to model class inside method body', () => {
diff --git a/packages/teamplay/test/dotSyntax.js b/packages/teamplay/test/dotSyntax.js
index 4265b1e..c92f39c 100644
--- a/packages/teamplay/test/dotSyntax.js
+++ b/packages/teamplay/test/dotSyntax.js
@@ -1,7 +1,7 @@
 import { it, describe, before } from 'mocha'
 import { strict as assert } from 'node:assert'
 import { runGc } from './_helpers.js'
-import { $, signal, __DEBUG_SIGNALS_CACHE__ as signalsCache, GLOBAL_ROOT_ID } from '../index.js'
+import { $, signal, __DEBUG_SIGNALS_CACHE__ as signalsCache, GLOBAL_ROOT_ID } from '../index.ts'
 import connect from '../connect/test.js'
 
 before(connect)
diff --git a/packages/teamplay/test/fileBasedModelOrder.js b/packages/teamplay/test/fileBasedModelOrder.js
new file mode 100644
index 0000000..8455ae3
--- /dev/null
+++ b/packages/teamplay/test/fileBasedModelOrder.js
@@ -0,0 +1,165 @@
+import assert from 'node:assert/strict'
+import { cpSync, mkdirSync, mkdtempSync, rmSync, symlinkSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+const TEST_DIR = dirname(fileURLToPath(import.meta.url))
+const TEAMPLAY_DIR = join(TEST_DIR, '..')
+const PACKAGES_DIR = join(TEAMPLAY_DIR, '..')
+const COMPLEX_MODELS_FIXTURE = join(PACKAGES_DIR, 'babel-plugin-teamplay', 'test', 'fixtures', 'complex-ts')
+const EXPECTED_COMPLEX_KEYS = ['_session', '_session.connection', 'events', 'events.*', 'events.*.comments.*']
+
+describe('file-based model initialization order', function () {
+  this.timeout(10000)
+
+  it('does not load file-based models from the root teamplay import on Node', () => {
+    const result = runInFixture(`
+      const teamplay = await import('teamplay')
+      console.log(JSON.stringify(Object.keys(teamplay.getModels()).sort()))
+    `)
+
+    assert.deepEqual(result, [])
+  })
+
+  it('does not load or initialize file-based models from createBackend()', () => {
+    const result = runInFixture(`
+      const { createBackend } = await import('teamplay/server')
+      createBackend({
+        flushRedis: false,
+        accessControl: false,
+        serverAggregate: false,
+        validateSchema: false
+      })
+      const teamplay = await import('teamplay')
+      console.log(JSON.stringify(Object.keys(teamplay.getModels()).sort()))
+      setTimeout(() => process.exit(0), 50)
+    `)
+
+    assert.deepEqual(result, [])
+  })
+
+  it('supports explicit file-based model initialization before importing root teamplay', () => {
+    const result = runInFixture(`
+      const models = (await import('teamplay/file-based-models')).default
+      const teamplay = await import('teamplay')
+      teamplay.initModels(models)
+
+      console.log(JSON.stringify({
+        keys: Object.keys(teamplay.getModels()).sort(),
+        collectionClassName: teamplay.getSignalClass(['events']).name,
+        documentClassName: teamplay.getSignalClass(['events', '123']).name
+      }))
+    `)
+
+    assert.deepEqual(result, {
+      keys: EXPECTED_COMPLEX_KEYS,
+      collectionClassName: 'EventsModel',
+      documentClassName: 'EventModel'
+    })
+  })
+
+  it('lets createBackend() reuse explicitly initialized models without owning initialization', () => {
+    const result = runInFixture(`
+      const teamplay = await import('teamplay')
+      const models = (await import('teamplay/file-based-models')).default
+      teamplay.initModels(models)
+
+      const { createBackend } = await import('teamplay/server')
+      createBackend({
+        flushRedis: false,
+        accessControl: false,
+        serverAggregate: false,
+        validateSchema: false
+      })
+
+      console.log(JSON.stringify(Object.keys(teamplay.getModels()).sort()))
+      setTimeout(() => process.exit(0), 50)
+    `)
+
+    assert.deepEqual(result, EXPECTED_COMPLEX_KEYS)
+  })
+
+  it('uses explicitly passed registry models without loading file-based models', () => {
+    const result = runInFixture(`
+      const teamplay = await import('teamplay')
+      const { initModels: initRegistryModels } = await import('teamplay/orm')
+      class RegistryEvents extends teamplay.Signal {}
+      const registryModels = { events: { default: RegistryEvents } }
+
+      initRegistryModels(registryModels)
+
+      const { createBackend } = await import('teamplay/server')
+      createBackend({
+        models: registryModels,
+        flushRedis: false,
+        accessControl: false,
+        serverAggregate: false,
+        validateSchema: false
+      })
+
+      console.log(JSON.stringify({
+        keys: Object.keys(teamplay.getModels()).sort(),
+        registeredDefaultName: teamplay.getSignalClass(['events']).name
+      }))
+      setTimeout(() => process.exit(0), 50)
+    `)
+
+    assert.deepEqual(result, {
+      keys: ['events'],
+      registeredDefaultName: 'RegistryEvents'
+    })
+  })
+})
+
+function runInFixture (source) {
+  const root = mkdtempSync(join(tmpdir(), 'teamplay-order-'))
+
+  try {
+    cpSync(COMPLEX_MODELS_FIXTURE, root, { recursive: true })
+    mkdirSync(join(root, 'node_modules'), { recursive: true })
+    symlinkSync(TEAMPLAY_DIR, join(root, 'node_modules', 'teamplay'), 'dir')
+    symlinkSync(join(PACKAGES_DIR, 'babel-plugin-teamplay'), join(root, 'node_modules', 'babel-plugin-teamplay'), 'dir')
+
+    const result = spawnSync(process.execPath, ['--input-type=module', '--eval', withErrorHandling(source)], {
+      cwd: root,
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        NO_REDIS: '1',
+        NO_MONGO: '1',
+        DB_READONLY: '1'
+      }
+    })
+
+    assert.equal(result.status, 0, result.stderr)
+    return JSON.parse(getLastStdoutLine(result.stdout))
+  } finally {
+    rmSync(root, { recursive: true, force: true })
+  }
+}
+
+function withErrorHandling (source) {
+  return `
+    process.on('uncaughtException', err => {
+      if (/Redis is already connecting/.test(err.message)) {
+        return setTimeout(() => process.exit(0), 20)
+      }
+      console.error(err)
+      process.exit(1)
+    })
+
+    ${source}
+  `
+}
+
+function getLastStdoutLine (stdout) {
+  const line = stdout
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .filter(Boolean)
+    .pop()
+  assert.ok(line, 'Expected child process to print a JSON result')
+  return line
+}
diff --git a/packages/teamplay/test/gcCleanup.js b/packages/teamplay/test/gcCleanup.js
index 4a9210b..cb4e4fc 100644
--- a/packages/teamplay/test/gcCleanup.js
+++ b/packages/teamplay/test/gcCleanup.js
@@ -1,13 +1,13 @@
 import { it, describe, before } from 'mocha'
 import { strict as assert } from 'node:assert'
 import { runGc } from './_helpers.js'
-import { $, sub, aggregation, __DEBUG_SIGNALS_CACHE__ as signalsCache } from '../index.js'
-import { getConnection } from '../orm/connection.js'
+import { $, sub, aggregation, __DEBUG_SIGNALS_CACHE__ as signalsCache } from '../index.ts'
+import { getConnection } from '../orm/connection.ts'
 import { docSubscriptions } from '../orm/Doc.js'
 import { querySubscriptions } from '../orm/Query.js'
 import { aggregationSubscriptions } from '../orm/Aggregation.js'
-import { getRoot, ROOT_ID } from '../orm/Root.js'
-import { getScopedSignalHash } from '../orm/rootScope.js'
+import { getRoot, ROOT_ID } from '../orm/Root.ts'
+import { getScopedSignalHash } from '../orm/rootScope.ts'
 import connect from '../connect/test.js'
 
 before(connect)
@@ -223,10 +223,10 @@ describe('GC Cleanup Tests', () => {
 
       // Create aggregation in a scope
       await (async () => {
-        const $$activeGames = aggregation(({ active }) => {
+        const _activeGames = aggregation(({ active }) => {
           return [{ $match: { active } }]
         })
-        const $activeGames = await sub($$activeGames, { $collection: collection, active: true })
+        const $activeGames = await sub(_activeGames, { $collection: collection, active: true })
         ownerKey = getScopedSignalHash(getRoot($activeGames)?.[ROOT_ID], transportHash, 'queryOwner')
         assert.equal($activeGames.get().length, 2, 'aggregation returns 2 docs')
 
@@ -370,10 +370,10 @@ describe('GC Cleanup Tests', () => {
       // Create and destroy aggregation subscriptions in a loop
       for (let minScore = 0; minScore < 3; minScore++) {
         await (async () => {
-          const $$games = aggregation(({ minScore }) => {
+          const _games = aggregation(({ minScore }) => {
             return [{ $match: { score: { $gte: minScore } } }]
           })
-          const $games = await sub($$games, { $collection: collection, minScore: minScore * 10 })
+          const $games = await sub(_games, { $collection: collection, minScore: minScore * 10 })
           assert.ok($games.get().length >= 1, `aggregation for minScore ${minScore * 10} returns docs`)
         })()
         // Signal goes out of scope
diff --git a/packages/teamplay/test/getCollectionCompat.js b/packages/teamplay/test/getCollectionCompat.js
index 9d9a796..487af87 100644
--- a/packages/teamplay/test/getCollectionCompat.js
+++ b/packages/teamplay/test/getCollectionCompat.js
@@ -1,7 +1,7 @@
 import { describe, it } from 'mocha'
 import { strict as assert } from 'node:assert'
-import { $, addModel } from '../index.js'
-import Signal from '../orm/Signal.js'
+import { $, addModel } from '../index.ts'
+import Signal from '../orm/Signal.ts'
 
 describe('Signal.getCollection() compatibility', () => {
   it('prefers static collection over path collection for compat-mounted model', () => {
diff --git a/packages/teamplay/test/idFields.js b/packages/teamplay/test/idFields.js
index edbbef5..0d28861 100644
--- a/packages/teamplay/test/idFields.js
+++ b/packages/teamplay/test/idFields.js
@@ -1,7 +1,7 @@
 import { it, describe, before, afterEach } from 'mocha'
 import { strict as assert } from 'node:assert'
-import { $, sub, aggregation } from '../index.js'
-import { getConnection } from '../orm/connection.js'
+import { $, sub, aggregation } from '../index.ts'
+import { getConnection } from '../orm/connection.ts'
 import { afterEachTestGc } from './_helpers.js'
 import connect from '../connect/test.js'
 import { isMissingShareDoc } from '../orm/missingDoc.js'
@@ -76,17 +76,17 @@ describe('Id fields in docs, queries, aggregations', () => {
     await $doc1.set({ name: 'A', active: true })
     await $doc2.set({ name: 'B', active: true })
 
-    const $$withId = aggregation(({ active }) => [{ $match: { active } }])
-    const $withId = await sub($$withId, { $collection: collection, active: true })
+    const _withId = aggregation(({ active }) => [{ $match: { active } }])
+    const $withId = await sub(_withId, { $collection: collection, active: true })
     const withId = $withId.get()
     assert.ok(withId.length >= 2)
     assert.ok(withId.every(doc => ('_id' in doc) || ('id' in doc)))
 
-    const $$noId = aggregation(() => [
+    const _noId = aggregation(() => [
       { $match: { active: true } },
       { $project: { _id: 0, name: 1 } }
     ])
-    const $noId = await sub($$noId, { $collection: collection })
+    const $noId = await sub(_noId, { $collection: collection })
     const noId = $noId.get()
     assert.ok(noId.length >= 2)
     assert.ok(noId.every(doc => !('_id' in doc) && !('id' in doc)))
@@ -106,8 +106,8 @@ describe('Id fields in docs, queries, aggregations', () => {
     await $doc1.set({ name: 'A', active: true })
     await $doc2.set({ name: 'B', active: true })
 
-    const $$withId = aggregation(({ active }) => [{ $match: { active } }])
-    const $withId = await sub($$withId, { $collection: collection, active: true })
+    const _withId = aggregation(({ active }) => [{ $match: { active } }])
+    const $withId = await sub(_withId, { $collection: collection, active: true })
     const withId = $withId.get()
     assert.ok(withId.length >= 2)
     assert.ok(withId.every(doc => doc._id))
diff --git a/packages/teamplay/test/initModels.js b/packages/teamplay/test/initModels.js
new file mode 100644
index 0000000..049f9c1
--- /dev/null
+++ b/packages/teamplay/test/initModels.js
@@ -0,0 +1,87 @@
+import assert from 'node:assert/strict'
+import Signal from '../orm/Signal.ts'
+import initModels, { getModels, resetModelsForTests } from '../orm/initModels.ts'
+import { findModel } from '../orm/addModel.ts'
+import { defineSchema } from '@teamplay/schema'
+
+describe('initModels', () => {
+  let originalWarn
+  let originalWarningEnv
+
+  beforeEach(() => {
+    originalWarn = console.warn
+    originalWarningEnv = process.env.TEAMPLAY_WARN_UNWRAPPED_SCHEMAS
+  })
+
+  afterEach(() => {
+    console.warn = originalWarn
+    if (originalWarningEnv == null) {
+      delete process.env.TEAMPLAY_WARN_UNWRAPPED_SCHEMAS
+    } else {
+      process.env.TEAMPLAY_WARN_UNWRAPPED_SCHEMAS = originalWarningEnv
+    }
+    resetModelsForTests()
+  })
+
+  it('registers model classes and stores the full models object', () => {
+    class UsersModel extends Signal {}
+    const models = { users: { default: UsersModel, schema: {} } }
+
+    initModels(models)
+
+    assert.equal(getModels(), models)
+    assert.equal(findModel(['users']), UsersModel)
+  })
+
+  it('allows repeated registration of the same class', () => {
+    class UsersModel extends Signal {}
+    const models = { users: { default: UsersModel } }
+
+    initModels(models)
+    assert.doesNotThrow(() => initModels(models))
+  })
+
+  it('throws when the same pattern is registered with a different class', () => {
+    class UsersModel extends Signal {}
+    class OtherUsersModel extends Signal {}
+
+    initModels({ users: { default: UsersModel } })
+
+    assert.throws(
+      () => initModels({ users: { default: OtherUsersModel } }),
+      /Model for pattern "users" already exists/
+    )
+    assert.equal(getModels().users.default, UsersModel)
+  })
+
+  it('warns once for plain schemas when schema warnings are enabled', () => {
+    const warnings = []
+    process.env.TEAMPLAY_WARN_UNWRAPPED_SCHEMAS = '1'
+    console.warn = message => warnings.push(message)
+    class UsersModel extends Signal {}
+    const models = { users: { default: UsersModel, schema: { name: { type: 'string' } } } }
+
+    initModels(models)
+    initModels(models)
+
+    assert.equal(warnings.length, 1)
+    assert.match(warnings[0], /Schema for model "users" was loaded as a plain object/)
+  })
+
+  it('does not warn for schemas wrapped with defineSchema()', () => {
+    const warnings = []
+    process.env.TEAMPLAY_WARN_UNWRAPPED_SCHEMAS = '1'
+    console.warn = message => warnings.push(message)
+    class UsersModel extends Signal {}
+    const models = {
+      users: {
+        default: UsersModel,
+        schema: defineSchema({ name: { type: 'string' } })
+      }
+    }
+
+    initModels(models)
+
+    assert.deepEqual(warnings, [])
+  })
+})
diff --git a/packages/teamplay/test/missingDocPlaceholder.js b/packages/teamplay/test/missingDocPlaceholder.js
index 7e4b447..9208fd5 100644
--- a/packages/teamplay/test/missingDocPlaceholder.js
+++ b/packages/teamplay/test/missingDocPlaceholder.js
@@ -1,6 +1,6 @@
 import { describe, it, before, afterEach } from 'mocha'
 import { strict as assert } from 'node:assert'
-import { $, getConnection, sub } from '../index.js'
+import { $, getConnection, sub } from '../index.ts'
 import connect from '../connect/test.js'
 import { docSubscriptions } from '../orm/Doc.js'
 
diff --git a/packages/teamplay/test/ormAssociations.js b/packages/teamplay/test/ormAssociations.js
index 398c246..12973bb 100644
--- a/packages/teamplay/test/ormAssociations.js
+++ b/packages/teamplay/test/ormAssociations.js
@@ -1,7 +1,7 @@
 import { describe, it } from 'mocha'
 import { strict as assert } from 'node:assert'
-import { addModel, getRootSignal } from '../index.js'
-import BaseModel, { belongsTo, hasMany, hasOne } from '../orm/index.js'
+import { addModel, getRootSignal } from '../index.ts'
+import BaseModel, { belongsTo, hasMany, hasOne } from '../orm/index.ts'
 
 describe('ORM associations', () => {
   it('exposes getAssociations() on model signals', () => {
diff --git a/packages/teamplay/test/privateData.js b/packages/teamplay/test/privateData.js
index 57f656a..b3c97d2 100644
--- a/packages/teamplay/test/privateData.js
+++ b/packages/teamplay/test/privateData.js
@@ -4,7 +4,7 @@ import {
   deleteRootContext,
   getRootContext,
   __resetRootContextsForTests
-} from '../orm/rootContext.js'
+} from '../orm/rootContext.ts'
 import {
   arrayPushPrivateData,
   getPrivateData,
diff --git a/packages/teamplay/test/promiseBatcher.js b/packages/teamplay/test/promiseBatcher.js
index 78c3f43..8bb3537 100644
--- a/packages/teamplay/test/promiseBatcher.js
+++ b/packages/teamplay/test/promiseBatcher.js
@@ -1,6 +1,6 @@
 import { describe, it, beforeEach } from 'mocha'
 import { strict as assert } from 'node:assert'
-import * as promiseBatcher from '../react/promiseBatcher.js'
+import * as promiseBatcher from '../react/promiseBatcher.ts'
 
 describe('promiseBatcher', () => {
   beforeEach(() => {
diff --git a/packages/teamplay/test/publicDocCreateConsistency.js b/packages/teamplay/test/publicDocCreateConsistency.js
index 979283b..617966a 100644
--- a/packages/teamplay/test/publicDocCreateConsistency.js
+++ b/packages/teamplay/test/publicDocCreateConsistency.js
@@ -1,6 +1,6 @@
 import { describe, it, before, afterEach } from 'mocha'
 import { strict as assert } from 'node:assert'
-import { $, getConnection, sub } from '../index.js'
+import { $, getConnection, sub } from '../index.ts'
 import connect from '../connect/test.js'
 import { docSubscriptions } from '../orm/Doc.js'
 
diff --git a/packages/teamplay/test/publicOnlyCompat.js b/packages/teamplay/test/publicOnlyCompat.js
index 4b7d034..8256bf9 100644
--- a/packages/teamplay/test/publicOnlyCompat.js
+++ b/packages/teamplay/test/publicOnlyCompat.js
@@ -1,7 +1,7 @@
 import { afterEach, describe, it } from 'mocha'
 import { strict as assert } from 'node:assert'
-import { getRootSignal, setPublicOnly } from '../index.js'
-import { __resetRootContextsForTests } from '../orm/rootContext.js'
+import { getRootSignal, setPublicOnly } from '../index.ts'
+import { __resetRootContextsForTests } from '../orm/rootContext.ts'
 
 describe('publicOnly', () => {
   const initialCompatFlag = globalThis.teamplayCompatibilityMode
diff --git a/packages/teamplay/test/queryEvents.js b/packages/teamplay/test/queryEvents.js
index f232828..2781966 100644
--- a/packages/teamplay/test/queryEvents.js
+++ b/packages/teamplay/test/queryEvents.js
@@ -1,8 +1,8 @@
 import { it, describe, before } from 'mocha'
 import { strict as assert } from 'node:assert'
 import { afterEachTestGc, runGc } from './_helpers.js'
-import { $, sub } from '../index.js'
-import { getConnection } from '../orm/connection.js'
+import { $, sub } from '../index.ts'
+import { getConnection } from '../orm/connection.ts'
 import { querySubscriptions } from '../orm/Query.js'
 import { docSubscriptions } from '../orm/Doc.js'
 import connect from '../connect/test.js'
diff --git a/packages/teamplay/test/rootClose.js b/packages/teamplay/test/rootClose.js
index 4d32b51..dcf648a 100644
--- a/packages/teamplay/test/rootClose.js
+++ b/packages/teamplay/test/rootClose.js
@@ -3,26 +3,26 @@ import { strict as assert } from 'node:assert'
 import {
   __DEBUG_SIGNALS_CACHE__ as signalsCache,
   getRootSignal
-} from '../index.js'
+} from '../index.ts'
 import { assertDocSubscriptionsConsistent, assertQuerySubscriptionsConsistent } from './_subscriptionAssertions.js'
 import connect from '../connect/test.js'
 import { aggregationSubscriptions } from '../orm/Aggregation.js'
 import { docSubscriptions } from '../orm/Doc.js'
-import { getConnection } from '../orm/connection.js'
+import { getConnection } from '../orm/connection.ts'
 import { del as _del } from '../orm/dataTree.js'
 import { __resetModelEventsForTests } from '../orm/Compat/modelEvents.js'
 import { __resetRefLinksForTests } from '../orm/Compat/refRegistry.js'
 import { getPrivateData, getPrivateDataRawRoot } from '../orm/privateData.js'
 import { HASH as QUERY_HASH, QUERIES, querySubscriptions } from '../orm/Query.js'
-import { __resetPendingRootDisposesForTests } from '../orm/disposeRootContext.js'
+import { __resetPendingRootDisposesForTests } from '../orm/disposeRootContext.ts'
 import {
   __getRootContextForTests,
   __resetRootContextsForTests,
   getRootOwnedSignalHashes,
   getRootOwnedRuntimeHashes
-} from '../orm/rootContext.js'
-import { getScopedSignalHash } from '../orm/rootScope.js'
-import { getSubscriptionGcDelay, setSubscriptionGcDelay } from '../orm/subscriptionGcDelay.js'
+} from '../orm/rootContext.ts'
+import { getScopedSignalHash } from '../orm/rootScope.ts'
+import { getSubscriptionGcDelay, setSubscriptionGcDelay } from '../orm/subscriptionGcDelay.ts'
 
 before(connect)
 
diff --git a/packages/teamplay/test/rootContext.js b/packages/teamplay/test/rootContext.js
index a62340c..0048ff3 100644
--- a/packages/teamplay/test/rootContext.js
+++ b/packages/teamplay/test/rootContext.js
@@ -7,7 +7,7 @@ import RootContext, {
   getRootOwnedRuntimeHashes,
   __getRootContextForTests,
   __resetRootContextsForTests
-} from '../orm/rootContext.js'
+} from '../orm/rootContext.ts'
 
 describe('RootContext runtime owner', () => {
   afterEach(() => {
diff --git a/packages/teamplay/test/rootFetchOnly.js b/packages/teamplay/test/rootFetchOnly.js
index 813eb0b..5f845b4 100644
--- a/packages/teamplay/test/rootFetchOnly.js
+++ b/packages/teamplay/test/rootFetchOnly.js
@@ -1,8 +1,8 @@
 import { afterEach, beforeEach, describe, it } from 'mocha'
 import { strict as assert } from 'node:assert'
-import { setDefaultFetchOnly, getDefaultFetchOnly } from '../orm/connection.js'
-import { getRootFetchOnly, getRootSignal } from '../orm/Root.js'
-import { __getRootContextForTests, __resetRootContextsForTests } from '../orm/rootContext.js'
+import { setDefaultFetchOnly, getDefaultFetchOnly } from '../orm/connection.ts'
+import { getRootFetchOnly, getRootSignal } from '../orm/Root.ts'
+import { __getRootContextForTests, __resetRootContextsForTests } from '../orm/rootContext.ts'
 
 let previousDefaultFetchOnly
 
diff --git a/packages/teamplay/test/rootFinalization.js b/packages/teamplay/test/rootFinalization.js
index 2c246bc..7a323cb 100644
--- a/packages/teamplay/test/rootFinalization.js
+++ b/packages/teamplay/test/rootFinalization.js
@@ -1,22 +1,22 @@
 import { before, beforeEach, afterEach, describe, it } from 'mocha'
 import { strict as assert } from 'node:assert'
-import { getRootSignal } from '../index.js'
+import { getRootSignal } from '../index.ts'
 import { assertDocSubscriptionsConsistent, assertQuerySubscriptionsConsistent } from './_subscriptionAssertions.js'
 import connect from '../connect/test.js'
 import { aggregationSubscriptions } from '../orm/Aggregation.js'
 import { docSubscriptions } from '../orm/Doc.js'
-import { getConnection } from '../orm/connection.js'
+import { getConnection } from '../orm/connection.ts'
 import { del as _del } from '../orm/dataTree.js'
 import { __resetModelEventsForTests } from '../orm/Compat/modelEvents.js'
 import { __resetRefLinksForTests } from '../orm/Compat/refRegistry.js'
 import { getPrivateDataRawRoot } from '../orm/privateData.js'
 import { HASH as QUERY_HASH, querySubscriptions } from '../orm/Query.js'
-import { __resetPendingRootDisposesForTests } from '../orm/disposeRootContext.js'
+import { __resetPendingRootDisposesForTests } from '../orm/disposeRootContext.ts'
 import {
   __getRootContextForTests,
   __resetRootContextsForTests
-} from '../orm/rootContext.js'
-import { getSubscriptionGcDelay, setSubscriptionGcDelay } from '../orm/subscriptionGcDelay.js'
+} from '../orm/rootContext.ts'
+import { getSubscriptionGcDelay, setSubscriptionGcDelay } from '../orm/subscriptionGcDelay.ts'
 import { runGc } from './_helpers.js'
 
 before(connect)
diff --git a/packages/teamplay/test/rootScopeHelpers.js b/packages/teamplay/test/rootScopeHelpers.js
index 8c27203..45759e7 100644
--- a/packages/teamplay/test/rootScopeHelpers.js
+++ b/packages/teamplay/test/rootScopeHelpers.js
@@ -1,6 +1,6 @@
 import { describe, it } from 'mocha'
 import { strict as assert } from 'node:assert'
-import { GLOBAL_ROOT_ID } from '../orm/Root.js'
+import { GLOBAL_ROOT_ID } from '../orm/Root.ts'
 import {
   normalizeRootId,
   isGlobalRootId,
@@ -10,7 +10,7 @@ import {
   getSignalIdentityHash,
   getScopedSignalHash,
   getRootScopedRegistryKey
-} from '../orm/rootScope.js'
+} from '../orm/rootScope.ts'
 
 describe('rootScope helpers', () => {
   it('normalizes and classifies root ids consistently', () => {
diff --git a/packages/teamplay/test/rootScopedPrivateStorage.js b/packages/teamplay/test/rootScopedPrivateStorage.js
index b393a62..7b7b5eb 100644
--- a/packages/teamplay/test/rootScopedPrivateStorage.js
+++ b/packages/teamplay/test/rootScopedPrivateStorage.js
@@ -1,9 +1,9 @@
 import { describe, it, afterEach } from 'mocha'
 import { strict as assert } from 'node:assert'
-import { getRootSignal } from '../index.js'
+import { getRootSignal } from '../index.ts'
 import { del as _del, set as _set } from '../orm/dataTree.js'
 import { getPrivateData, getPrivateDataRawRoot } from '../orm/privateData.js'
-import { __resetRootContextsForTests } from '../orm/rootContext.js'
+import { __resetRootContextsForTests } from '../orm/rootContext.ts'
 
 describe('root-scoped private storage', () => {
   afterEach(() => {
diff --git a/packages/teamplay/test/rootScopedPublicSignals.js b/packages/teamplay/test/rootScopedPublicSignals.js
index ca3990f..f1bfa6e 100644
--- a/packages/teamplay/test/rootScopedPublicSignals.js
+++ b/packages/teamplay/test/rootScopedPublicSignals.js
@@ -1,15 +1,15 @@
 import assert from 'assert'
 import { before, beforeEach, afterEach, describe, it } from 'mocha'
-import { addModel, getRootSignal } from '../index.js'
+import { addModel, getRootSignal } from '../index.ts'
 import { docSubscriptions } from '../orm/Doc.js'
-import { getConnection } from '../orm/connection.js'
+import { getConnection } from '../orm/connection.ts'
 import { del as _del, set as _set } from '../orm/dataTree.js'
 import { __resetRefLinksForTests } from '../orm/Compat/refRegistry.js'
 import { __resetModelEventsForTests } from '../orm/Compat/modelEvents.js'
 import { getPrivateData } from '../orm/privateData.js'
 import { querySubscriptions, QUERIES, HASH as QUERY_HASH } from '../orm/Query.js'
-import { setSubscriptionGcDelay, getSubscriptionGcDelay } from '../orm/subscriptionGcDelay.js'
-import { getRootOwnedRuntimeHashes } from '../orm/rootContext.js'
+import { setSubscriptionGcDelay, getSubscriptionGcDelay } from '../orm/subscriptionGcDelay.ts'
+import { getRootOwnedRuntimeHashes } from '../orm/rootContext.ts'
 import connect from '../connect/test.js'
 
 before(connect)
diff --git a/packages/teamplay/test/rootScopedRefsAndEvents.js b/packages/teamplay/test/rootScopedRefsAndEvents.js
index 5eb2593..76199e3 100644
--- a/packages/teamplay/test/rootScopedRefsAndEvents.js
+++ b/packages/teamplay/test/rootScopedRefsAndEvents.js
@@ -1,11 +1,11 @@
 import { describe, it, afterEach } from 'mocha'
 import { strict as assert } from 'node:assert'
-import { getRootSignal } from '../index.js'
+import { getRootSignal } from '../index.ts'
 import { del as _del, set as _set } from '../orm/dataTree.js'
 import { __resetModelEventsForTests } from '../orm/Compat/modelEvents.js'
 import { __resetRefLinksForTests } from '../orm/Compat/refRegistry.js'
 import { __resetSilentContextForTests } from '../orm/Compat/silentContext.js'
-import { __resetRootContextsForTests } from '../orm/rootContext.js'
+import { __resetRootContextsForTests } from '../orm/rootContext.ts'
 
 const describeCompat = process.env.TEAMPLAY_COMPAT === '1' ? describe : describe.skip
 
diff --git a/packages/teamplay/test/schemaFixtureMatrix.ts b/packages/teamplay/test/schemaFixtureMatrix.ts
new file mode 100644
index 0000000..775d3b1
--- /dev/null
+++ b/packages/teamplay/test/schemaFixtureMatrix.ts
@@ -0,0 +1,175 @@
+import { defineSchema } from '@teamplay/schema'
+
+export const fullObjectSchema = defineSchema({
+  type: 'object',
+  required: ['title', 'meta'],
+  properties: {
+    title: {
+      type: 'string',
+      label: 'Full object title',
+      description: 'Title text shown in generated field docs.'
+    },
+    score: { type: 'integer' },
+    meta: {
+      type: 'object',
+      required: ['createdAt'],
+      properties: {
+        createdAt: { type: 'number' },
+        flags: {
+          type: 'array',
+          items: { type: 'string' }
+        }
+      }
+    }
+  }
+} as const)
+
+export const shorthandSchema = defineSchema({
+  title: {
+    type: 'string',
+    required: true,
+    label: 'Shorthand title'
+  },
+  score: { type: 'integer' }
+})
+
+export const keywordNamedFieldsSchema = defineSchema({
+  title: {
+    type: 'string',
+    required: true,
+    description: 'Keyword fixture title.'
+  },
+  description: { type: 'string' },
+  type: { type: 'string' },
+  required: { type: 'boolean' },
+  properties: {
+    type: 'object',
+    properties: {
+      color: { type: 'string', required: true }
+    }
+  }
+})
+
+export const nestedObjectsAndArraysSchema = defineSchema({
+  team: {
+    type: 'object',
+    required: true,
+    properties: {
+      name: {
+        type: 'string',
+        required: true,
+        label: 'Team name'
+      },
+      players: {
+        type: 'array',
+        items: {
+          type: 'object',
+          required: ['id'],
+          properties: {
+            id: { type: 'string' },
+            active: { type: 'boolean' }
+          }
+        }
+      }
+    }
+  }
+})
+
+export const tupleSchema = defineSchema({
+  type: 'array',
+  items: [
+    { type: 'string' },
+    { type: 'integer' },
+    { type: 'boolean' }
+  ]
+} as const)
+
+export const nullableSchema = defineSchema({
+  type: ['object', 'null'],
+  required: ['name'],
+  properties: {
+    name: { type: 'string' },
+    score: { type: ['integer', 'null'] }
+  }
+} as const)
+
+export const enumSchema = defineSchema({
+  type: 'string',
+  enum: ['draft', 'published'] as const
+})
+
+export const constSchema = defineSchema({
+  const: 'system' as const
+})
+
+export const unsupportedDynamicSchema: unknown = undefined
+
+export const schemaRuntimeFixtureMatrix = [
+  {
+    name: 'full object schema',
+    schema: fullObjectSchema,
+    transform: true,
+    expectedPropertyKeys: ['title', 'score', 'meta'],
+    expectedRequired: ['title', 'meta'],
+    generatedEnv: {
+      collectionName: 'schemaFullObjects',
+      expectedFieldNames: ['title', 'score', 'meta'],
+      expectedJsdocSnippets: ['Full object title', 'Title text shown in generated field docs.']
+    }
+  },
+  {
+    name: 'shorthand schema',
+    schema: shorthandSchema,
+    transform: true,
+    expectedPropertyKeys: ['title', 'score'],
+    expectedRequired: ['title'],
+    generatedEnv: {
+      collectionName: 'schemaShorthands',
+      expectedFieldNames: ['title', 'score'],
+      expectedJsdocSnippets: ['Shorthand title']
+    }
+  },
+  {
+    name: 'keyword-named fields schema',
+    schema: keywordNamedFieldsSchema,
+    transform: true,
+    expectedPropertyKeys: ['title', 'description', 'type', 'required', 'properties'],
+    expectedRequired: ['title'],
+    generatedEnv: {
+      collectionName: 'schemaKeywordFields',
+      expectedFieldNames: ['title', 'description', 'type', 'required', 'properties'],
+      expectedJsdocSnippets: ['Keyword fixture title.']
+    }
+  },
+  {
+    name: 'nested object and array schema',
+    schema: nestedObjectsAndArraysSchema,
+    transform: true,
+    expectedPropertyKeys: ['team'],
+    expectedRequired: ['team'],
+    generatedEnv: {
+      collectionName: 'schemaNestedObjects',
+      expectedFieldNames: ['team', 'name', 'players'],
+      expectedJsdocSnippets: ['Team name']
+    }
+  },
+  {
+    name: 'unsupported dynamic schema',
+    schema: unsupportedDynamicSchema,
+    transform: false,
+    expectedPropertyKeys: [],
+    expectedRequired: [],
+    generatedEnv: {
+      collectionName: 'schemaDynamic',
+      source: [
+        "import { defineSchema } from 'teamplay'",
+        '',
+        "const buildSchema = () => ({ title: { type: 'string' } })",
+        '',
+        'export default defineSchema(buildSchema())',
+        ''
+      ].join('\n'),
+      expectedFieldNames: []
+    }
+  }
+] as const
diff --git a/packages/teamplay/test/schemaIntrospection.js b/packages/teamplay/test/schemaIntrospection.js
new file mode 100644
index 0000000..8f43421
--- /dev/null
+++ b/packages/teamplay/test/schemaIntrospection.js
@@ -0,0 +1,99 @@
+import { strict as assert } from 'assert'
+import {
+  getSchemaPropertiesObject,
+  isJsonSchemaKeyword,
+  transformSchema
+} from '@teamplay/schema'
+import {
+  fullObjectSchema,
+  keywordNamedFieldsSchema,
+  nestedObjectsAndArraysSchema,
+  schemaRuntimeFixtureMatrix,
+  shorthandSchema
+} from './schemaFixtureMatrix.ts'
+
+describe('schema introspection helpers', () => {
+  it('matches the shared schema runtime fixture matrix', () => {
+    for (const fixture of schemaRuntimeFixtureMatrix) {
+      const schema = fixture.transform
+        ? transformSchema(fixture.schema)
+        : fixture.schema
+      assert.deepEqual(
+        Object.keys(getSchemaPropertiesObject(schema)),
+        fixture.expectedPropertyKeys,
+        fixture.name
+      )
+      if (fixture.transform) {
+        assert.deepEqual(schema.required || [], fixture.expectedRequired, fixture.name)
+      }
+    }
+  })
+
+  it('normalizes full object and shorthand object schemas consistently', () => {
+    const transformedFull = transformSchema(fullObjectSchema)
+    const transformedShorthand = transformSchema(shorthandSchema)
+
+    assert.deepEqual(transformedFull.required, ['title', 'meta'])
+    assert.deepEqual(Object.keys(getSchemaPropertiesObject(transformedFull)), ['title', 'score', 'meta'])
+    assert.deepEqual(transformedFull.properties.meta.required, ['createdAt'])
+    assert.equal(transformedFull.properties.meta.properties.flags.type, 'array')
+    assert.deepEqual(transformedShorthand.required, ['title'])
+    assert.deepEqual(Object.keys(getSchemaPropertiesObject(transformedShorthand)), ['title', 'score'])
+    assert.equal(transformedShorthand.properties.title.required, undefined)
+  })
+
+  it('matches simplified keyword-field schema rules used by type inference', () => {
+    const transformed = transformSchema(keywordNamedFieldsSchema)
+
+    assert.equal(isJsonSchemaKeyword('properties'), true)
+    assert.equal(transformed.type, 'object')
+    assert.deepEqual(transformed.required, ['title'])
+    assert.deepEqual(Object.keys(getSchemaPropertiesObject(transformed)), [
+      'title',
+      'description',
+      'type',
+      'required',
+      'properties'
+    ])
+    assert.equal(transformed.properties.title.required, undefined)
+    assert.equal(transformed.properties.properties.properties.color.required, undefined)
+  })
+
+  it('keeps nested objects, arrays, tuples, nullable values, enum, and const schema metadata intact', () => {
+    const transformed = transformSchema({
+      team: {
+        ...nestedObjectsAndArraysSchema.team,
+        properties: {
+          ...nestedObjectsAndArraysSchema.team.properties,
+          tuple: {
+            type: 'array',
+            items: [
+              { type: 'string' },
+              { type: 'integer' },
+              { type: 'boolean' }
+            ]
+          },
+          nullableScore: { type: ['integer', 'null'] },
+          status: { type: 'string', enum: ['draft', 'published'] },
+          source: { const: 'system' }
+        }
+      }
+    })
+    const team = transformed.properties.team
+
+    assert.deepEqual(transformed.required, ['team'])
+    assert.equal(team.required, undefined)
+    assert.equal(team.properties.name.required, undefined)
+    assert.deepEqual(team.properties.players.items.required, ['id'])
+    assert.equal(team.properties.players.items.properties.id.type, 'string')
+    assert.equal(Array.isArray(team.properties.tuple.items), true)
+    assert.deepEqual(team.properties.nullableScore.type, ['integer', 'null'])
+    assert.deepEqual(team.properties.status.enum, ['draft', 'published'])
+    assert.equal(team.properties.source.const, 'system')
+  })
+
+  it('returns no static properties for unsupported dynamic schemas', () => {
+    assert.deepEqual(getSchemaPropertiesObject(undefined), {})
+    assert.deepEqual(Object.keys(getSchemaPropertiesObject(() => ({ title: { type: 'string' } }))), [])
+  })
+})
diff --git a/packages/teamplay/test/signalArrayReaders.js b/packages/teamplay/test/signalArrayReaders.js
new file mode 100644
index 0000000..175e623
--- /dev/null
+++ b/packages/teamplay/test/signalArrayReaders.js
@@ -0,0 +1,133 @@
+import { strict as assert } from 'node:assert'
+import { afterEach, describe, it } from 'mocha'
+import { getRootSignal } from '../index.ts'
+import { HASH, IS_QUERY, QUERIES, getQuerySignal } from '../orm/Query.js'
+import { delPrivateData, setPrivateData } from '../orm/privateData.js'
+import { SEGMENTS } from '../orm/Signal.ts'
+import {
+  getSignalArrayChildren,
+  iterateSignalArrayChildren,
+  runSignalArrayMethod
+} from '../orm/signalArrayReaders.ts'
+
+describe('signal array reader helpers', () => {
+  const cleanupRootIds = []
+
+  afterEach(() => {
+    for (const rootId of cleanupRootIds.splice(0)) {
+      delPrivateData(rootId, ['_session'])
+      delPrivateData(rootId, [QUERIES])
+    }
+  })
+
+  it('maps query ids to document child signals', () => {
+    const $query = structuralSignal(['games'], { query: true, hash: 'query-hash' })
+    const { context, root } = structuralContext({ queryIds: ['game-1', 'game-2'] })
+
+    const children = getSignalArrayChildren($query, context)
+
+    assert.deepEqual(children.map($child => $child[SEGMENTS]), [
+      ['games', 'game-1'],
+      ['games', 'game-2']
+    ])
+    assert.ok(children.every($child => $child.rootArg === root))
+  })
+
+  it('maps array indexes to item child signals and array method callbacks', () => {
+    const $items = structuralSignal(['_session', 'items'])
+    const { context } = structuralContext({ arrayValue: ['a', 'b'] })
+
+    assert.deepEqual([...iterateSignalArrayChildren($items, context)].map($item => $item[SEGMENTS]), [
+      ['_session', 'items', 0],
+      ['_session', 'items', 1]
+    ])
+
+    const paths = runSignalArrayMethod($items, context, 'map', [], [
+      ($item, index) => `${$item[SEGMENTS].join('.')}:${index}`
+    ])
+
+    assert.deepEqual(paths, ['_session.items.0:0', '_session.items.1:1'])
+  })
+
+  it('warns and returns the fallback value when query ids are missing', () => {
+    const warnings = []
+    const $query = structuralSignal(['games'], { query: true, hash: 'query-hash' })
+    const { context } = structuralContext({ queryIds: undefined, warnings })
+
+    const result = runSignalArrayMethod($query, context, 'find', undefined, [], {
+      message: 'Signal array method on Query didn\'t find ids',
+      method: 'find'
+    })
+
+    assert.equal(result, undefined)
+    assert.deepEqual(warnings, [
+      ['Signal array method on Query didn\'t find ids', [QUERIES, 'query-hash', 'ids'], 'find']
+    ])
+  })
+
+  it('preserves runtime reader behavior for private arrays and query signals', () => {
+    const rootId = 'signal-array-readers-runtime-root'
+    cleanupRootIds.push(rootId)
+    const $root = getRootSignal({ rootId })
+
+    setPrivateData(rootId, ['_session', 'players'], [
+      { name: 'A' },
+      { name: 'B' }
+    ])
+    const $players = $root._session.players
+
+    assert.deepEqual([...$players].map($player => $player.path()), [
+      '_session.players.0',
+      '_session.players.1'
+    ])
+    assert.deepEqual($players.map($player => $player.name.get()), ['A', 'B'])
+    assert.equal($players.find($player => $player.name.get() === 'B').path(), '_session.players.1')
+    assert.equal($players.reduce((count) => count + 1, 0), 2)
+
+    const $query = getQuerySignal('arrayReaderGames', { active: true }, { root: $root })
+    setPrivateData(rootId, [QUERIES, $query[HASH], 'ids'], ['game-1', 'game-2'])
+
+    assert.deepEqual([...$query].map($game => $game.path()), [
+      'arrayReaderGames.game-1',
+      'arrayReaderGames.game-2'
+    ])
+    assert.deepEqual($query.map($game => $game.getId()), ['game-1', 'game-2'])
+    assert.equal($query.find($game => $game.getId() === 'game-2').path(), 'arrayReaderGames.game-2')
+    assert.equal($query.reduce((count) => count + 1, 0), 2)
+  })
+})
+
+function structuralContext ({
+  queryIds,
+  arrayValue,
+  warnings = []
+} = {}) {
+  const root = structuralSignal([])
+  return {
+    root,
+    context: {
+      getRoot: () => root,
+      readQueryIds: () => queryIds,
+      readArrayValue: () => arrayValue,
+      createSignal ($root, segments) {
+        return {
+          ...structuralSignal(segments),
+          rootArg: $root
+        }
+      },
+      warn (message, ...args) {
+        warnings.push([message, ...args])
+      }
+    }
+  }
+}
+
+function structuralSignal (segments, {
+  query = false,
+  hash
+} = {}) {
+  const $signal = { [SEGMENTS]: segments }
+  if (query) $signal[IS_QUERY] = true
+  if (hash) $signal[HASH] = hash
+  return $signal
+}
diff --git a/packages/teamplay/test/signalCompat.js b/packages/teamplay/test/signalCompat.js
index 47e15dc..dff5500 100644
--- a/packages/teamplay/test/signalCompat.js
+++ b/packages/teamplay/test/signalCompat.js
@@ -1,24 +1,24 @@
 import { it, describe, afterEach, before, after } from 'mocha'
 import { strict as assert } from 'node:assert'
 import { raw, observe, unobserve } from '@nx-js/observer-util'
-import { $, sub, addModel, aggregation, getRootSignal } from '../index.js'
+import { $, sub, addModel, aggregation, getRootSignal } from '../index.ts'
 import { get as _get, set as _set, del as _del } from '../orm/dataTree.js'
-import { getConnection, setConnection, getDefaultFetchOnly, setDefaultFetchOnly } from '../orm/connection.js'
-import getSignal from '../orm/getSignal.js'
+import { getConnection, setConnection, getDefaultFetchOnly, setDefaultFetchOnly } from '../orm/connection.ts'
+import getSignal from '../orm/getSignal.ts'
 import connect from '../connect/test.js'
 import SignalCompat from '../orm/Compat/SignalCompat.js'
-import { Signal as BaseSignal } from '../orm/SignalBase.js'
+import { Signal as BaseSignal } from '../orm/SignalBase.ts'
 import { scheduleReaction } from '../orm/batchScheduler.js'
 import { __resetModelEventsForTests } from '../orm/Compat/modelEvents.js'
 import { __resetRefLinksForTests } from '../orm/Compat/refRegistry.js'
 import { __resetSilentContextForTests, isSilentContextActive } from '../orm/Compat/silentContext.js'
 import { isMissingShareDoc } from '../orm/missingDoc.js'
-import { ROOT, ROOT_ID } from '../orm/Root.js'
+import { ROOT, ROOT_ID } from '../orm/Root.ts'
 import { PARAMS, HASH as QUERY_HASH, QUERIES, querySubscriptions } from '../orm/Query.js'
 import { AGGREGATIONS, aggregationSubscriptions } from '../orm/Aggregation.js'
 import { delPrivateData, setPrivateData } from '../orm/privateData.js'
-import { getSubscriptionGcDelay, setSubscriptionGcDelay } from '../orm/subscriptionGcDelay.js'
-import { __resetRootContextsForTests, getRootContext } from '../orm/rootContext.js'
+import { getSubscriptionGcDelay, setSubscriptionGcDelay } from '../orm/subscriptionGcDelay.ts'
+import { __resetRootContextsForTests, getRootContext } from '../orm/rootContext.ts'
 import {
   __setImperativeQueryReadyTimeoutForTests,
   __resetImperativeQueryReadyTimeoutForTests
@@ -1867,8 +1867,8 @@ describe('SignalCompat public mutators', () => {
     await $game1.set({ name: 'Agg One', active: true })
     await $game2.set({ name: 'Agg Two', active: true })
 
-    const $$agg = aggregation(({ active }) => [{ $match: { active } }])
-    const $agg = await sub($$agg, { $collection: 'compatGames', active: true })
+    const _agg = aggregation(({ active }) => [{ $match: { active } }])
+    const $agg = await sub(_agg, { $collection: 'compatGames', active: true })
     const results = $agg.get()
     assert.ok(results.length >= 2)
     assert.ok(results.every(doc => doc._id))
diff --git a/packages/teamplay/test/signalMetadata.js b/packages/teamplay/test/signalMetadata.js
new file mode 100644
index 0000000..d3c3338
--- /dev/null
+++ b/packages/teamplay/test/signalMetadata.js
@@ -0,0 +1,83 @@
+import { strict as assert } from 'node:assert'
+import { describe, it } from 'mocha'
+import { addModel, getRootSignal, Signal } from '../index.ts'
+import { getAggregationSignal } from '../orm/Aggregation.js'
+import { setPrivateData } from '../orm/privateData.js'
+import { SEGMENTS } from '../orm/Signal.ts'
+import {
+  getSignalCollection,
+  getSignalId,
+  getSignalLeaf,
+  getSignalParentSegments,
+  getSignalPath
+} from '../orm/signalMetadata.ts'
+
+describe('signal metadata helpers', () => {
+  it('reads path and leaf metadata from signal segments', () => {
+    const $signal = metadataSignal(['games', 'game-1', 'rounds', 0])
+
+    assert.equal(getSignalPath($signal), 'games.game-1.rounds.0')
+    assert.equal(getSignalLeaf($signal), '0')
+    assert.equal(getSignalPath(metadataSignal([])), '')
+    assert.equal(getSignalLeaf(metadataSignal([])), '')
+  })
+
+  it('calculates parent segments and validates levels', () => {
+    const $signal = metadataSignal(['games', 'game-1', 'rounds', 0])
+
+    assert.deepEqual(getSignalParentSegments($signal, 1, 0), ['games', 'game-1', 'rounds'])
+    assert.deepEqual(getSignalParentSegments($signal, 2, 1), ['games', 'game-1'])
+    assert.deepEqual(getSignalParentSegments($signal, 10, 1), [])
+    assert.throws(() => getSignalParentSegments($signal, 1, 2), /expects a single argument/)
+    assert.throws(() => getSignalParentSegments($signal, 1.5, 1), /expects an integer argument/)
+    assert.throws(() => getSignalParentSegments($signal, 0, 1), /expects a positive integer/)
+  })
+
+  it('returns ids and collection names from structural metadata', () => {
+    assert.equal(getSignalId(metadataSignal(['games', 'game-1'])), 'game-1')
+    assert.equal(getSignalId(metadataSignal(['games', 'game-1', 'title'])), 'title')
+    assert.equal(getSignalCollection(metadataSignal(['games', 'game-1'])), 'games')
+    assert.equal(getSignalCollection(metadataSignal(['_virtualFields', 'field-1'], 'fields')), 'fields')
+    assert.throws(() => getSignalId(metadataSignal([])), /Can't get the id of the root signal/)
+    assert.throws(() => getSignalId(metadataSignal(['games'])), /Can't get the id of a collection/)
+    assert.throws(() => getSignalCollection(metadataSignal([])), /Can't get the collection of the root signal/)
+  })
+
+  it('preserves public metadata method behavior on real signals', () => {
+    class MetadataModel extends Signal {
+      static collection = 'metadataDocs'
+      static associations = [{ type: 'metadata' }]
+    }
+
+    addModel('_metadataVirtual.*', MetadataModel)
+
+    const $root = getRootSignal({ rootId: 'signal-metadata-root' })
+    const $field = $root._metadataVirtual.field1.title
+
+    assert.equal($field.path(), '_metadataVirtual.field1.title')
+    assert.equal($field.leaf(), 'title')
+    assert.equal($field.parent().path(), '_metadataVirtual.field1')
+    assert.equal($field.parent(2).path(), '_metadataVirtual')
+    assert.equal($field.parent(10), $root)
+    assert.equal($root._metadataVirtual.field1.getId(), 'field1')
+    assert.equal($root._metadataVirtual.field1.getCollection(), 'metadataDocs')
+    assert.deepEqual($root._metadataVirtual.field1.getAssociations(), [{ type: 'metadata' }])
+  })
+
+  it('keeps aggregation row metadata routed to the source collection', () => {
+    const rootId = 'signal-metadata-aggregation-root'
+    const $root = getRootSignal({ rootId })
+    const $aggregation = getAggregationSignal('metadataAggDocs', { $aggregate: [] }, { root: $root })
+    setPrivateData(rootId, [...$aggregation[SEGMENTS], 0], { _id: 'agg-doc-1' })
+
+    assert.equal($aggregation[0].getId(), 'agg-doc-1')
+    assert.equal($aggregation[0].getCollection(), 'metadataAggDocs')
+  })
+})
+
+function metadataSignal (segments, collection) {
+  return {
+    [SEGMENTS]: segments,
+    constructor: { collection }
+  }
+}
diff --git a/packages/teamplay/test/signalMutationGuards.js b/packages/teamplay/test/signalMutationGuards.js
new file mode 100644
index 0000000..efd4dec
--- /dev/null
+++ b/packages/teamplay/test/signalMutationGuards.js
@@ -0,0 +1,41 @@
+import { strict as assert } from 'node:assert'
+import { describe, it } from 'mocha'
+import {
+  ensureArrayTargetSegments,
+  ensureValueTargetSegments
+} from '../orm/signalMutationGuards.ts'
+
+describe('signal mutation guards', () => {
+  it('allows nested value and array paths', () => {
+    const segments = ['games', 'game-1', 'tags']
+
+    assert.equal(ensureArrayTargetSegments(segments, false), segments)
+    assert.equal(ensureValueTargetSegments(segments, false), segments)
+  })
+
+  it('rejects root and collection paths', () => {
+    assert.throws(
+      () => ensureArrayTargetSegments([], false),
+      /Can't mutate array on a collection or root signal/
+    )
+    assert.throws(
+      () => ensureArrayTargetSegments(['games'], false),
+      /Can't mutate array on a collection or root signal/
+    )
+    assert.throws(
+      () => ensureValueTargetSegments(['games'], false),
+      /Can't mutate on a collection or root signal/
+    )
+  })
+
+  it('rejects query signals before mutating', () => {
+    assert.throws(
+      () => ensureArrayTargetSegments(['games', 'game-1'], true),
+      /Array mutators can't be used on a query signal/
+    )
+    assert.throws(
+      () => ensureValueTargetSegments(['games', 'game-1'], true),
+      /Mutators can't be used on a query signal/
+    )
+  })
+})
diff --git a/packages/teamplay/test/signalPathRules.js b/packages/teamplay/test/signalPathRules.js
new file mode 100644
index 0000000..f5f627e
--- /dev/null
+++ b/packages/teamplay/test/signalPathRules.js
@@ -0,0 +1,36 @@
+import { strict as assert } from 'node:assert'
+import { describe, it } from 'mocha'
+import {
+  maybeTransformToArrayIndex,
+  normalizeSignalPropertyKey,
+  pathSegmentsToPattern,
+  transformRootDollarAlias
+} from '../orm/signalPathRules.ts'
+
+describe('signal path rules', () => {
+  it('maps root dollar aliases to private collection names', () => {
+    assert.equal(transformRootDollarAlias([], '$session'), '_session')
+    assert.equal(transformRootDollarAlias([], '$page'), '_page')
+    assert.equal(transformRootDollarAlias([], '$render'), '$render')
+    assert.equal(transformRootDollarAlias([], '$system'), '$system')
+  })
+
+  it('only applies dollar aliases at the root', () => {
+    assert.equal(transformRootDollarAlias(['games', 'game-1'], '$session'), 'session')
+    assert.equal(normalizeSignalPropertyKey(['games', 'game-1'], '$page'), 'page')
+  })
+
+  it('normalizes positive integer property keys to array indexes', () => {
+    assert.equal(maybeTransformToArrayIndex('0'), 0)
+    assert.equal(maybeTransformToArrayIndex('12'), 12)
+    assert.equal(maybeTransformToArrayIndex('01'), '01')
+    assert.equal(maybeTransformToArrayIndex('-1'), '-1')
+  })
+
+  it('joins runtime path tuples into model pattern strings', () => {
+    assert.equal(pathSegmentsToPattern([]), '')
+    assert.equal(pathSegmentsToPattern(['games']), 'games')
+    assert.equal(pathSegmentsToPattern(['games', '*', 'players', '*']), 'games.*.players.*')
+    assert.equal(pathSegmentsToPattern(['games', 'game-1', 'players', 0]), 'games.game-1.players.*')
+  })
+})
diff --git a/packages/teamplay/test/signalReads.js b/packages/teamplay/test/signalReads.js
new file mode 100644
index 0000000..2f4644b
--- /dev/null
+++ b/packages/teamplay/test/signalReads.js
@@ -0,0 +1,200 @@
+import { strict as assert } from 'node:assert'
+import { afterEach, describe, it } from 'mocha'
+import { getRootSignal } from '../index.ts'
+import { getAggregationSignal, AGGREGATIONS, IS_AGGREGATION } from '../orm/Aggregation.js'
+import { del as delPublicData, set as setPublicData } from '../orm/dataTree.js'
+import { HASH, IS_QUERY, QUERIES, getQuerySignal } from '../orm/Query.js'
+import { delPrivateData, setPrivateData } from '../orm/privateData.js'
+import { __resetRootContextsForTests } from '../orm/rootContext.ts'
+import { SEGMENTS } from '../orm/Signal.ts'
+import {
+  getSignalIds,
+  getSignalValue,
+  readSignalValue
+} from '../orm/signalReads.ts'
+
+describe('signal read helpers', () => {
+  afterEach(() => {
+    delPublicData(['signalReadGames'])
+    __resetRootContextsForTests()
+  })
+
+  it('routes root, query, private, and public reads through explicit read context', () => {
+    const reads = []
+    const warnings = []
+    const { context, observedRead, rawRead } = structuralReadContext({ reads, warnings })
+
+    assert.deepEqual(
+      readSignalValue(structuralSignal([]), context, observedRead, rawRead),
+      { root: 'observed' }
+    )
+    assert.deepEqual(reads.pop(), { type: 'root', rootId: 'structural-root', raw: false })
+
+    const $query = structuralSignal(['games'], { query: true, hash: 'query-hash' })
+    assert.deepEqual(readSignalValue($query, context, rawRead, rawRead), [{ id: 'raw-doc' }])
+    assert.deepEqual(reads.pop(), {
+      type: 'private',
+      rootId: 'structural-root',
+      segments: [QUERIES, 'query-hash', 'docs'],
+      raw: true
+    })
+
+    assert.equal(readSignalValue(structuralSignal(['_session', 'flag']), context, observedRead, rawRead), true)
+    assert.deepEqual(reads.pop(), {
+      type: 'private',
+      rootId: 'structural-root',
+      segments: ['_session', 'flag'],
+      raw: false
+    })
+
+    assert.equal(readSignalValue(structuralSignal(['games', 'game-1', 'title']), context, observedRead, rawRead), 'One')
+    assert.deepEqual(reads.pop(), {
+      type: 'public',
+      segments: ['games', 'game-1', 'title']
+    })
+
+    assert.deepEqual(getSignalValue(structuralSignal([QUERIES, 'missing-hash', 'ids']), context, observedRead, rawRead), [])
+    assert.deepEqual(warnings, [
+      ['Signal.get() on Query didn\'t find ids', [QUERIES, 'missing-hash', 'ids']]
+    ])
+  })
+
+  it('reads query ids, aggregation ids, and non-query fallback behavior', () => {
+    const warnings = []
+    const errors = []
+    const { context } = structuralReadContext({ warnings, errors })
+
+    const $query = structuralSignal(['games'], { query: true, hash: 'query-hash' })
+    assert.deepEqual(getSignalIds($query, context), ['game-1'])
+
+    const $missingQuery = structuralSignal(['games'], { query: true, hash: 'missing-hash' })
+    assert.deepEqual(getSignalIds($missingQuery, context), [])
+    assert.deepEqual(warnings, [
+      ['Signal.getIds() on Query didn\'t find ids', [QUERIES, 'missing-hash', 'ids']]
+    ])
+
+    const $aggregation = structuralSignal([AGGREGATIONS, 'agg-hash'], { aggregation: true })
+    assert.deepEqual(getSignalIds($aggregation, context), ['game-1', 'game-2'])
+
+    assert.deepEqual(getSignalIds(structuralSignal(['games']), context), [])
+    assert.equal(errors.length, 1)
+    assert.match(errors[0], /Signal\.getIds\(\) can only be used on query signals or aggregation signals/)
+    assert.match(errors[0], /\["games"\]/)
+  })
+
+  it('preserves runtime read behavior across root snapshots, query docs, private storage, and aggregation ids', () => {
+    const rootId = 'signal-read-runtime-root'
+    const $root = getRootSignal({ rootId })
+
+    setPublicData(['signalReadGames', 'game-1'], { title: 'One' })
+    setPrivateData(rootId, ['_session', 'selectedGameId'], 'game-1')
+
+    const snapshot = $root.get()
+    const rawSnapshot = $root.peek()
+    assert.equal(snapshot.signalReadGames['game-1'].title, 'One')
+    assert.equal(rawSnapshot.signalReadGames['game-1'].title, 'One')
+    assert.equal(snapshot._session.selectedGameId, 'game-1')
+    assert.equal(rawSnapshot._session.selectedGameId, 'game-1')
+    assert.equal($root.signalReadGames['game-1'].title.get(), 'One')
+    assert.equal($root._session.selectedGameId.peek(), 'game-1')
+
+    const $query = getQuerySignal('signalReadGames', { active: true }, { root: $root })
+    setPrivateData(rootId, [QUERIES, $query[HASH], 'docs'], [{ _id: 'game-1', title: 'One' }])
+    setPrivateData(rootId, [QUERIES, $query[HASH], 'ids'], ['game-1'])
+    assert.deepEqual($query.get(), [{ _id: 'game-1', title: 'One' }])
+    assert.deepEqual($query.getIds(), ['game-1'])
+    assert.deepEqual($query.ids.get(), ['game-1'])
+
+    const $aggregation = getAggregationSignal('signalReadGames', { $aggregate: [] }, { root: $root })
+    setPrivateData(rootId, $aggregation[SEGMENTS], [{ _id: 'game-1' }, { id: 'game-2' }])
+    assert.deepEqual($aggregation.getIds(), ['game-1', 'game-2'])
+
+    const errors = captureConsoleErrors(() => {
+      assert.deepEqual($root.signalReadGames.getIds(), [])
+    })
+    assert.equal(errors.length, 1)
+    assert.match(errors[0][0], /Signal\.getIds\(\) can only be used on query signals or aggregation signals/)
+
+    delPrivateData(rootId, ['_session'])
+    delPrivateData(rootId, [QUERIES])
+    delPrivateData(rootId, [AGGREGATIONS])
+  })
+})
+
+function structuralReadContext ({
+  reads = [],
+  warnings = [],
+  errors = []
+} = {}) {
+  const values = new Map([
+    [pathKey([QUERIES, 'query-hash', 'docs'], true), [{ id: 'raw-doc' }]],
+    [pathKey([QUERIES, 'query-hash', 'ids'], false), ['game-1']],
+    [pathKey(['_session', 'flag'], false), true],
+    [pathKey([AGGREGATIONS, 'agg-hash'], false), [{ _id: 'game-1' }, { id: 'game-2' }]]
+  ])
+
+  const observedRead = segments => {
+    if (pathKey(segments, false) === pathKey(['games', 'game-1', 'title'], false)) return 'One'
+  }
+  const rawRead = segments => {
+    if (pathKey(segments, true) === pathKey(['games', 'game-1', 'title'], true)) return 'Raw One'
+  }
+
+  return {
+    observedRead,
+    rawRead,
+    context: {
+      getOwningRootId: () => 'structural-root',
+      getStorageSegments: $signal => $signal[SEGMENTS],
+      isPrivateSegments: segments => /^[_$]/.test(String(segments[0])),
+      readLogicalRootSnapshot (rootId, raw) {
+        reads.push({ type: 'root', rootId, raw })
+        return raw ? { root: 'raw' } : { root: 'observed' }
+      },
+      readPrivateData (rootId, segments, raw) {
+        reads.push({ type: 'private', rootId, segments: [...segments], raw })
+        return values.get(pathKey(segments, raw))
+      },
+      readPublicData (segments, method) {
+        reads.push({ type: 'public', segments: [...segments] })
+        return method(segments)
+      },
+      warn (message, ...args) {
+        warnings.push([message, ...args])
+      },
+      error (message) {
+        errors.push(message)
+      }
+    }
+  }
+}
+
+function structuralSignal (segments, {
+  query = false,
+  aggregation = false,
+  hash
+} = {}) {
+  const $signal = { [SEGMENTS]: segments }
+  if (query) $signal[IS_QUERY] = true
+  if (aggregation) $signal[IS_AGGREGATION] = true
+  if (hash) $signal[HASH] = hash
+  return $signal
+}
+
+function captureConsoleErrors (fn) {
+  const originalError = console.error
+  const errors = []
+  console.error = (...args) => {
+    errors.push(args)
+  }
+  try {
+    fn()
+  } finally {
+    console.error = originalError
+  }
+  return errors
+}
+
+function pathKey (segments, raw) {
+  return JSON.stringify({ segments, raw })
+}
diff --git a/packages/teamplay/test/signalRuntimeAccess.js b/packages/teamplay/test/signalRuntimeAccess.js
new file mode 100644
index 0000000..cb20c3a
--- /dev/null
+++ b/packages/teamplay/test/signalRuntimeAccess.js
@@ -0,0 +1,61 @@
+import { strict as assert } from 'node:assert'
+import { describe, it } from 'mocha'
+import { getRootSignal, ROOT_ID } from '../orm/Root.ts'
+import { IS_QUERY } from '../orm/Query.js'
+import { SEGMENTS } from '../orm/Signal.ts'
+import {
+  ensureArraySignalTarget,
+  ensureValueSignalTarget,
+  getSignalOwningRootId,
+  getSignalSegments,
+  getSignalStorageSegments,
+  isPrivateSignalSegments
+} from '../orm/signalRuntimeAccess.ts'
+
+describe('signal runtime access helpers', () => {
+  it('reads signal segments and storage overrides through the shared symbol', () => {
+    const segments = ['games', 'game-1', 'tags']
+    const override = ['games', 'game-2', 'tags']
+    const $signal = { [SEGMENTS]: segments }
+
+    assert.equal(getSignalSegments($signal), segments)
+    assert.equal(getSignalStorageSegments($signal), segments)
+    assert.equal(getSignalStorageSegments($signal, override), override)
+  })
+
+  it('resolves owning root ids from roots and child signals', () => {
+    const $root = getRootSignal({ rootId: 'runtime-access-root' })
+
+    assert.equal(getSignalOwningRootId($root), 'runtime-access-root')
+    assert.equal(getSignalOwningRootId($root._session.userId), 'runtime-access-root')
+    assert.equal(getSignalOwningRootId({ [SEGMENTS]: [], [ROOT_ID]: 'direct-root' }), 'direct-root')
+  })
+
+  it('keeps private path detection centralized', () => {
+    assert.equal(isPrivateSignalSegments(['_session', 'userId']), true)
+    assert.equal(isPrivateSignalSegments(['$queries', 'hash', 'ids']), true)
+    assert.equal(isPrivateSignalSegments(['games', 'game-1']), false)
+    assert.equal(isPrivateSignalSegments([]), false)
+  })
+
+  it('wraps mutation target checks with signal query state', () => {
+    const $array = { [SEGMENTS]: ['games', 'game-1', 'tags'] }
+    const $value = { [SEGMENTS]: ['games', 'game-1', 'title'] }
+    const $query = { [SEGMENTS]: ['games', 'game-1', 'tags'], [IS_QUERY]: true }
+
+    assert.equal(ensureArraySignalTarget($array), $array[SEGMENTS])
+    assert.equal(ensureValueSignalTarget($value), $value[SEGMENTS])
+    assert.throws(
+      () => ensureArraySignalTarget({ [SEGMENTS]: ['games'] }),
+      /Can't mutate array on a collection or root signal/
+    )
+    assert.throws(
+      () => ensureValueSignalTarget({ [SEGMENTS]: [] }),
+      /Can't mutate on a collection or root signal/
+    )
+    assert.throws(
+      () => ensureArraySignalTarget($query),
+      /Array mutators can't be used on a query signal/
+    )
+  })
+})
diff --git a/packages/teamplay/test/signalRuntimeDescriptor.js b/packages/teamplay/test/signalRuntimeDescriptor.js
new file mode 100644
index 0000000..c6b75c9
--- /dev/null
+++ b/packages/teamplay/test/signalRuntimeDescriptor.js
@@ -0,0 +1,105 @@
+import { it, describe } from 'mocha'
+import { strict as assert } from 'node:assert'
+import { $, Signal, addModel } from '../index.ts'
+import { getQuerySignal, HASH, QUERIES } from '../orm/Query.js'
+import { SEGMENTS } from '../orm/Signal.ts'
+import { getAggregationSignal } from '../orm/Aggregation.js'
+import {
+  SIGNAL_RUNTIME_DESCRIPTOR,
+  describeSignalRuntime,
+  getSignalRuntimeDescriptor
+} from '../orm/signalRuntimeDescriptor.ts'
+
+describe('signal runtime descriptors', () => {
+  it('describes root, collection, document, and nested value signals', async () => {
+    assert.deepEqual(getSignalRuntimeDescriptor($), {
+      kind: 'root',
+      segments: []
+    })
+
+    assert.deepEqual(getSignalRuntimeDescriptor($.games), {
+      kind: 'collection',
+      segments: ['games'],
+      collectionName: 'games',
+      itemPattern: ['games', '*']
+    })
+
+    assert.deepEqual(getSignalRuntimeDescriptor($.games._descriptorGame), {
+      kind: 'document',
+      segments: ['games', '_descriptorGame'],
+      collectionName: 'games',
+      documentId: '_descriptorGame'
+    })
+
+    try {
+      await $._session.descriptor.tags.set(['board', 'turn'])
+      assert.deepEqual(describeSignalRuntime($._session.descriptor.tags, {
+        value: $._session.descriptor.tags.peek()
+      }), {
+        kind: 'nestedValue',
+        segments: ['_session', 'descriptor', 'tags'],
+        itemPattern: ['_session', 'descriptor', 'tags', '*']
+      })
+    } finally {
+      await $._session.descriptor.del()
+    }
+  })
+
+  it('describes local array signals', () => {
+    const $numbers = $([1, 2, 3])
+
+    assert.deepEqual(describeSignalRuntime($numbers, { value: $numbers.peek() }), {
+      kind: 'localArray',
+      segments: $numbers.path().split('.'),
+      itemPattern: [...$numbers.path().split('.'), '*']
+    })
+  })
+
+  it('stores explicit descriptors on query and aggregation signals', () => {
+    const $query = getQuerySignal('games', { active: true })
+    const queryDescriptor = getSignalRuntimeDescriptor($query)
+
+    assert.equal($query[SIGNAL_RUNTIME_DESCRIPTOR], queryDescriptor)
+    assert.deepEqual(queryDescriptor, {
+      kind: 'query',
+      segments: ['games'],
+      collectionName: 'games',
+      itemPattern: ['games', '*']
+    })
+
+    const $aggregation = getAggregationSignal('games', { $aggregate: [{ $match: { active: true } }] })
+    const aggregationDescriptor = getSignalRuntimeDescriptor($aggregation)
+
+    assert.equal($aggregation[SIGNAL_RUNTIME_DESCRIPTOR], aggregationDescriptor)
+    assert.deepEqual(aggregationDescriptor, {
+      kind: 'aggregation',
+      segments: $aggregation.path().split('.'),
+      collectionName: 'games',
+      itemPattern: ['games', '*']
+    })
+  })
+
+  it('keeps document ids distinct from special query fields and collection model methods', () => {
+    class DescriptorCollisionCollection extends Signal {
+      ids () {
+        return `ids method on ${this.path()}`
+      }
+
+      extra () {
+        return `extra method on ${this.path()}`
+      }
+    }
+
+    addModel('descriptorCollisions', DescriptorCollisionCollection)
+
+    assert.equal($.descriptorCollisions.ids.path(), 'descriptorCollisions.ids')
+    assert.equal($.descriptorCollisions.extra.path(), 'descriptorCollisions.extra')
+    assert.equal($.descriptorCollisions.ids(), 'ids method on descriptorCollisions')
+    assert.equal($.descriptorCollisions.extra(), 'extra method on descriptorCollisions')
+
+    const $query = getQuerySignal('descriptorCollisions', {})
+
+    assert.deepEqual($query.ids[SEGMENTS], [QUERIES, $query[HASH], 'ids'])
+    assert.deepEqual($query.extra[SEGMENTS], [QUERIES, $query[HASH], 'extra'])
+  })
+})
diff --git a/packages/teamplay/test/signalStorageMutations.js b/packages/teamplay/test/signalStorageMutations.js
new file mode 100644
index 0000000..d728e8d
--- /dev/null
+++ b/packages/teamplay/test/signalStorageMutations.js
@@ -0,0 +1,89 @@
+import { strict as assert } from 'node:assert'
+import { describe, it } from 'mocha'
+import { SEGMENTS } from '../orm/Signal.ts'
+import { runSignalStorageMutation } from '../orm/signalStorageMutations.ts'
+
+describe('signal storage mutation helpers', () => {
+  it('skips protected public id-field paths before running handlers', async () => {
+    const calls = []
+    const result = await runSignalStorageMutation(
+      mutationSignal(['storageMutationDocs', 'doc-1', '_id']),
+      structuralStorageContext({ calls }),
+      ['storageMutationDocs', 'doc-1', '_id'],
+      storageHandlers(calls)
+    )
+
+    assert.deepEqual(result, { skipped: true, value: undefined })
+    assert.deepEqual(calls, [])
+  })
+
+  it('routes public mutations to public handlers', async () => {
+    const calls = []
+    const result = await runSignalStorageMutation(
+      mutationSignal(['storageMutationDocs', 'doc-1', 'tags']),
+      structuralStorageContext({ calls }),
+      ['storageMutationDocs', 'doc-1', 'tags'],
+      storageHandlers(calls)
+    )
+
+    assert.deepEqual(result, { skipped: false, value: 'public-result' })
+    assert.deepEqual(calls, [
+      { type: 'public', segments: ['storageMutationDocs', 'doc-1', 'tags'] }
+    ])
+  })
+
+  it('routes private mutations through the owning root', async () => {
+    const calls = []
+    const result = await runSignalStorageMutation(
+      mutationSignal(['_session', 'tags']),
+      structuralStorageContext({ calls, rootId: 'storage-root' }),
+      ['_session', 'tags'],
+      storageHandlers(calls)
+    )
+
+    assert.deepEqual(result, { skipped: false, value: 'private-result' })
+    assert.deepEqual(calls, [
+      { type: 'private', rootId: 'storage-root', segments: ['_session', 'tags'] }
+    ])
+  })
+
+  it('rejects private mutations when publicOnly is active', async () => {
+    await assert.rejects(
+      () => runSignalStorageMutation(
+        mutationSignal(['_session', 'tags']),
+        structuralStorageContext({ privateMutationForbidden: true }),
+        ['_session', 'tags'],
+        storageHandlers([])
+      ),
+      /Can't modify private collections data when 'publicOnly' is enabled/
+    )
+  })
+})
+
+function structuralStorageContext ({
+  rootId = 'storage-mutation-root',
+  privateMutationForbidden = false
+} = {}) {
+  return {
+    getOwningRootId: () => rootId,
+    isPublicCollection: segment => typeof segment === 'string' && segment[0] !== '_' && segment[0] !== '$',
+    isPrivateMutationForbidden: () => privateMutationForbidden
+  }
+}
+
+function storageHandlers (calls) {
+  return {
+    public (segments) {
+      calls.push({ type: 'public', segments: [...segments] })
+      return 'public-result'
+    },
+    private (rootId, segments) {
+      calls.push({ type: 'private', rootId, segments: [...segments] })
+      return 'private-result'
+    }
+  }
+}
+
+function mutationSignal (segments) {
+  return { [SEGMENTS]: segments }
+}
diff --git a/packages/teamplay/test/signalValueMutations.js b/packages/teamplay/test/signalValueMutations.js
new file mode 100644
index 0000000..6cd5107
--- /dev/null
+++ b/packages/teamplay/test/signalValueMutations.js
@@ -0,0 +1,146 @@
+import { strict as assert } from 'node:assert'
+import { afterEach, describe, it } from 'mocha'
+import { getRootSignal } from '../index.ts'
+import { del as delPublicData, get as getPublicData } from '../orm/dataTree.js'
+import { delPrivateData, getPrivateData } from '../orm/privateData.js'
+import { __resetRootContextsForTests } from '../orm/rootContext.ts'
+import { SEGMENTS } from '../orm/Signal.ts'
+import {
+  deleteSignalValue,
+  setSignalValue
+} from '../orm/signalValueMutations.ts'
+
+describe('signal value mutation helpers', () => {
+  afterEach(() => {
+    delPublicData(['mutationDocs'])
+    delPublicData(['signalValueMutationDocs'])
+    __resetRootContextsForTests()
+  })
+
+  it('routes public set/delete writes and normalizes protected id fields', async () => {
+    const calls = []
+    const context = structuralMutationContext({ calls })
+
+    await setSignalValue(mutationSignal(['mutationDocs', 'doc-1']), context, {
+      _id: 'wrong',
+      title: 'One'
+    })
+    assert.deepEqual(calls, [
+      {
+        type: 'setPublicDoc',
+        segments: ['mutationDocs', 'doc-1'],
+        value: { _id: 'doc-1', title: 'One' }
+      }
+    ])
+
+    await deleteSignalValue(mutationSignal(['mutationDocs', 'doc-1', 'title']), context)
+    assert.deepEqual(calls[1], {
+      type: 'deletePublicDoc',
+      segments: ['mutationDocs', 'doc-1', 'title']
+    })
+  })
+
+  it('skips direct id-field mutations', async () => {
+    const calls = []
+    const context = structuralMutationContext({ calls })
+
+    await setSignalValue(mutationSignal(['mutationDocs', 'doc-1', '_id']), context, 'wrong')
+    await deleteSignalValue(mutationSignal(['mutationDocs', 'doc-1', '_id']), context)
+
+    assert.deepEqual(calls, [])
+  })
+
+  it('routes private set/delete writes through the owning root', async () => {
+    const calls = []
+    const context = structuralMutationContext({ calls, rootId: 'mutation-root' })
+
+    await setSignalValue(mutationSignal(['_session', 'flag']), context, true)
+    await deleteSignalValue(mutationSignal(['_session', 'flag']), context)
+
+    assert.deepEqual(calls, [
+      {
+        type: 'setPrivateData',
+        rootId: 'mutation-root',
+        segments: ['_session', 'flag'],
+        value: true
+      },
+      {
+        type: 'deletePrivateData',
+        rootId: 'mutation-root',
+        segments: ['_session', 'flag']
+      }
+    ])
+  })
+
+  it('protects root, whole public collections, and publicOnly private writes', async () => {
+    const forbiddenContext = structuralMutationContext({ privateMutationForbidden: true })
+
+    await assert.rejects(
+      () => setSignalValue(mutationSignal([]), forbiddenContext, true),
+      /Can't set the root signal data/
+    )
+    await assert.rejects(
+      () => deleteSignalValue(mutationSignal([]), forbiddenContext),
+      /Can't delete the root signal data/
+    )
+    await assert.rejects(
+      () => deleteSignalValue(mutationSignal(['mutationDocs']), forbiddenContext),
+      /Can't delete the whole collection/
+    )
+    await assert.rejects(
+      () => setSignalValue(mutationSignal(['_session', 'flag']), forbiddenContext, true),
+      /Can't modify private collections data when 'publicOnly' is enabled/
+    )
+    await assert.rejects(
+      () => deleteSignalValue(mutationSignal(['_session', 'flag']), forbiddenContext),
+      /Can't modify private collections data when 'publicOnly' is enabled/
+    )
+  })
+
+  it('preserves runtime set/delete behavior for private data and id-field no-ops', async () => {
+    const rootId = 'signal-value-mutation-runtime-root'
+    const $root = getRootSignal({ rootId })
+
+    await $root._session.flag.set(true)
+    assert.equal(getPrivateData(rootId, ['_session', 'flag'], true), true)
+    await $root._session.flag.del()
+    assert.equal(getPrivateData(rootId, ['_session', 'flag'], true), undefined)
+
+    await $root.signalValueMutationDocs['doc-1'].set({ _id: 'doc-1', title: 'One' })
+    await $root.signalValueMutationDocs['doc-1']._id.set('wrong')
+    assert.equal(getPublicData(['signalValueMutationDocs', 'doc-1', '_id']), 'doc-1')
+
+    await $root.signalValueMutationDocs['doc-1']._id.del()
+    assert.equal(getPublicData(['signalValueMutationDocs', 'doc-1', '_id']), 'doc-1')
+
+    delPrivateData(rootId, ['_session'])
+  })
+})
+
+function structuralMutationContext ({
+  calls = [],
+  rootId = 'structural-mutation-root',
+  privateMutationForbidden = false
+} = {}) {
+  return {
+    getOwningRootId: () => rootId,
+    isPublicCollection: segment => typeof segment === 'string' && segment[0] !== '_' && segment[0] !== '$',
+    isPrivateMutationForbidden: () => privateMutationForbidden,
+    setPublicDoc (segments, value) {
+      calls.push({ type: 'setPublicDoc', segments: [...segments], value })
+    },
+    setPrivateData (rootId, segments, value) {
+      calls.push({ type: 'setPrivateData', rootId, segments: [...segments], value })
+    },
+    deletePublicDoc (segments) {
+      calls.push({ type: 'deletePublicDoc', segments: [...segments] })
+    },
+    deletePrivateData (rootId, segments) {
+      calls.push({ type: 'deletePrivateData', rootId, segments: [...segments] })
+    }
+  }
+}
+
+function mutationSignal (segments) {
+  return { [SEGMENTS]: segments }
+}
diff --git a/packages/teamplay/test/sub$.js b/packages/teamplay/test/sub$.js
index cbe8b2b..1e0c892 100644
--- a/packages/teamplay/test/sub$.js
+++ b/packages/teamplay/test/sub$.js
@@ -1,12 +1,12 @@
 import { it, describe, afterEach, before } from 'mocha'
 import { strict as assert } from 'node:assert'
 import { afterEachTestGc, runGc } from './_helpers.js'
-import { $, sub, aggregation } from '../index.js'
+import { $, sub, aggregation } from '../index.ts'
 import { get as _get, del as _del } from '../orm/dataTree.js'
-import { getConnection } from '../orm/connection.js'
+import { getConnection } from '../orm/connection.ts'
 import { hashQuery } from '../orm/Query.js'
 import { getPrivateData } from '../orm/privateData.js'
-import { getRoot, ROOT_ID } from '../orm/Root.js'
+import { getRoot, ROOT_ID } from '../orm/Root.ts'
 import connect from '../connect/test.js'
 
 before(connect)
@@ -402,6 +402,21 @@ describe('$sub() function. Queries', () => {
     assert.deepEqual($activeGames.map($game => $game.name.get()).sort(), ['Game 1', 'Game 2'])
   })
 
+  it('query forwards optional array method arguments', async () => {
+    const $activeGames = await sub($.games, { active: true })
+    const labels = $activeGames.map(function ($game) {
+      return `${this.prefix}${$game.name.get()}`
+    }, { prefix: '#' })
+    const $firstGame = $activeGames.reduce(($firstGame, $secondGame) => $firstGame)
+    const found = $activeGames.find(function ($game) {
+      return $game.name.get() === this.name
+    }, { name: 'Game 2' })
+
+    assert.deepEqual(labels.sort(), ['#Game 1', '#Game 2'])
+    assert.equal($firstGame.name.get(), 'Game 1')
+    assert.equal(found.name.get(), 'Game 2')
+  })
+
   it('query ids should support .map()', async () => {
     const $activeGames = await sub($.games, { active: true })
     assert.deepEqual($activeGames.ids.map($id => $id.get()).sort(), ['_1', '_2'])
@@ -425,10 +440,10 @@ describe('$sub() function. Aggregations', () => {
   afterEachTestGc()
 
   it('subscribe to aggregation, modify it', async () => {
-    const $$activeGames = aggregation(({ active }) => {
+    const _activeGames = aggregation(({ active }) => {
       return [{ $match: { active } }]
     })
-    const $activeGames = await sub($$activeGames, { $collection: gamesCollection, active: true })
+    const $activeGames = await sub(_activeGames, { $collection: gamesCollection, active: true })
     const rootId = getRoot($activeGames)?.[ROOT_ID]
     assert.equal($activeGames.get().length, 2)
     assert.deepEqual(
@@ -454,29 +469,47 @@ describe('$sub() function. Aggregations', () => {
   })
 
   it('.getId() on a signal from aggregation should return the id of the document', async () => {
-    const $$activeGames = aggregation(gamesCollection, ({ active }) => {
+    const _activeGames = aggregation(gamesCollection, ({ active }) => {
       return [{ $match: { active } }]
     })
-    const $activeGames = await sub($$activeGames, { active: true })
+    const $activeGames = await sub(_activeGames, { active: true })
     assert.equal($activeGames[0].getId(), '_1')
     assert.equal($activeGames[1].getId(), '_2')
   })
 
   it('aggregation should be iterable', async () => {
-    const $$activeGames = aggregation(gamesCollection, ({ active }) => {
+    const _activeGames = aggregation(gamesCollection, ({ active }) => {
       return [{ $match: { active } }]
     })
-    const $activeGames = await sub($$activeGames, { active: true })
+    const $activeGames = await sub(_activeGames, { active: true })
     assert.equal([...$activeGames].length, 2)
   })
 
   it('aggregation should support .map()', async () => {
-    const $$activeGames = aggregation(gamesCollection, ({ active }) => {
+    const _activeGames = aggregation(gamesCollection, ({ active }) => {
       return [{ $match: { active } }]
     })
-    const $activeGames = await sub($$activeGames, { active: true })
+    const $activeGames = await sub(_activeGames, { active: true })
     assert.deepEqual($activeGames.map($game => $game.name.get()).sort(), ['Game 1', 'Game 2'])
   })
+
+  it('aggregation forwards optional array method arguments', async () => {
+    const _activeGames = aggregation(gamesCollection, ({ active }) => {
+      return [{ $match: { active } }]
+    })
+    const $activeGames = await sub(_activeGames, { active: true })
+    const labels = $activeGames.map(function ($game) {
+      return `${this.prefix}${$game.name.get()}`
+    }, { prefix: '#' })
+    const $firstGame = $activeGames.reduce(($firstGame, $secondGame) => $firstGame)
+    const found = $activeGames.find(function ($game) {
+      return $game.name.get() === this.name
+    }, { name: 'Game 2' })
+
+    assert.deepEqual(labels.sort(), ['#Game 1', '#Game 2'])
+    assert.equal($firstGame.name.get(), 'Game 1')
+    assert.equal(found.name.get(), 'Game 2')
+  })
 })
 
 describe.skip('$sub() function. Async api functions', () => {
diff --git a/packages/teamplay/test/subscriptionManagers.js b/packages/teamplay/test/subscriptionManagers.js
index 0aa6e4e..99c6290 100644
--- a/packages/teamplay/test/subscriptionManagers.js
+++ b/packages/teamplay/test/subscriptionManagers.js
@@ -14,7 +14,7 @@ import { it, describe, before, beforeEach, afterEach } from 'mocha'
 import { strict as assert } from 'node:assert'
 import { afterEachTestGc, runGc } from './_helpers.js'
 import { assertDocSubscriptionsConsistent, assertQuerySubscriptionsConsistent } from './_subscriptionAssertions.js'
-import { $, sub } from '../index.js'
+import { $, sub } from '../index.ts'
 import { docSubscriptions, DocSubscriptions } from '../orm/Doc.js'
 import { isMissingShareDoc } from '../orm/missingDoc.js'
 import {
@@ -29,18 +29,18 @@ import {
   hashQuery
 } from '../orm/Query.js'
 import { getAggregationSignal, AGGREGATIONS, aggregationSubscriptions } from '../orm/Aggregation.js'
-import { SEGMENTS } from '../orm/Signal.js'
-import { getConnection } from '../orm/connection.js'
+import { SEGMENTS } from '../orm/Signal.ts'
+import { getConnection } from '../orm/connection.ts'
 import { get as _get } from '../orm/dataTree.js'
-import { getRootSignal, ROOT_ID } from '../orm/Root.js'
+import { getRootSignal, ROOT_ID } from '../orm/Root.ts'
 import { getPrivateData } from '../orm/privateData.js'
-import { getScopedSignalHash } from '../orm/rootScope.js'
+import { getScopedSignalHash } from '../orm/rootScope.ts'
 import connect from '../connect/test.js'
 import {
   getSubscriptionGcDelay,
   setSubscriptionGcDelay,
   __resetSubscriptionGcDelayForTests
-} from '../orm/subscriptionGcDelay.js'
+} from '../orm/subscriptionGcDelay.ts'
 
 before(connect)
 
diff --git a/packages/teamplay/test/ts-transform.cjs b/packages/teamplay/test/ts-transform.cjs
new file mode 100644
index 0000000..525047c
--- /dev/null
+++ b/packages/teamplay/test/ts-transform.cjs
@@ -0,0 +1,17 @@
+const ts = require('typescript')
+
+module.exports = {
+  process (sourceText, sourcePath) {
+    const result = ts.transpileModule(sourceText, {
+      fileName: sourcePath,
+      compilerOptions: {
+        target: ts.ScriptTarget.ES2022,
+        module: ts.ModuleKind.ESNext,
+        sourceMap: false,
+        inlineSourceMap: false,
+        importsNotUsedAsValues: ts.ImportsNotUsedAsValues.Remove
+      }
+    })
+    return { code: result.outputText }
+  }
+}
diff --git a/packages/teamplay/test_client/react.js b/packages/teamplay/test_client/10_react.js
similarity index 99%
rename from packages/teamplay/test_client/react.js
rename to packages/teamplay/test_client/10_react.js
index 91b37e2..8f1aa86 100644
--- a/packages/teamplay/test_client/react.js
+++ b/packages/teamplay/test_client/10_react.js
@@ -1,8 +1,8 @@
 import { createElement as el, Fragment, useEffect, useLayoutEffect } from 'react'
 import { describe, it, afterEach, beforeEach, expect, beforeAll as before } from '@jest/globals'
 import { act, cleanup, fireEvent, render } from '@testing-library/react'
-import { $, useSub, useAsyncSub, observer, sub } from '../index.js'
-import { setTestThrottling, resetTestThrottling } from '../react/useSub.js'
+import { $, useSub, useAsyncSub, observer, sub } from '../index.ts'
+import { setTestThrottling, resetTestThrottling } from '../react/useSub.ts'
 import { runGc, cache } from '../test/_helpers.js'
 import connect from '../connect/test.js'
 
diff --git a/packages/teamplay/test_client/react-subscriptions.js b/packages/teamplay/test_client/20_react-subscriptions.js
similarity index 97%
rename from packages/teamplay/test_client/react-subscriptions.js
rename to packages/teamplay/test_client/20_react-subscriptions.js
index 0217190..7a49a25 100644
--- a/packages/teamplay/test_client/react-subscriptions.js
+++ b/packages/teamplay/test_client/20_react-subscriptions.js
@@ -1,7 +1,7 @@
 import { createElement as el, Fragment } from 'react'
 import { describe, it, afterEach, beforeEach, expect, beforeAll as before } from '@jest/globals'
 import { act, cleanup, fireEvent, render } from '@testing-library/react'
-import { $, useSub, useAsyncSub, observer, sub, aggregation } from '../index.js'
+import { $, useSub, useAsyncSub, observer, sub, aggregation } from '../index.ts'
 import { runGc, cache } from '../test/_helpers.js'
 import connect from '../connect/test.js'
 
@@ -123,12 +123,12 @@ describe('Aggregation in React', () => {
     $item2.set({ name: 'Gadget', active: true, price: 200 })
     await wait()
 
-    const $$activeItems = aggregation(({ active }) => {
+    const _activeItems = aggregation(({ active }) => {
       return [{ $match: { active } }]
     })
 
     const Component = observer(() => {
-      const $items = useSub($$activeItems, { $collection: 'aggReact1', active: true })
+      const $items = useSub(_activeItems, { $collection: 'aggReact1', active: true })
       return el('span', {}, $items.map($i => $i.name.get()).sort().join(','))
     }, { suspenseProps: { fallback: el('span', {}, 'Loading...') } })
 
@@ -156,13 +156,13 @@ describe('Aggregation parameter changes', () => {
     $b.set({ name: 'Beta', category: 'y' })
     await wait()
 
-    const $$byCat = aggregation(({ category }) => {
+    const _byCat = aggregation(({ category }) => {
       return [{ $match: { category } }]
     })
 
     const Component = observer(() => {
       const $cat = $('x')
-      const $items = useSub($$byCat, { $collection: 'aggParam1', category: $cat.get() })
+      const $items = useSub(_byCat, { $collection: 'aggParam1', category: $cat.get() })
       return fr(
         el('span', { id: 'out' }, $items.map($i => $i.name.get()).join(',')),
         el('button', { id: 'switchY', onClick: () => $cat.set('y') }),
@@ -466,14 +466,14 @@ describe('useAsyncSub with aggregation', () => {
     $x2.set({ name: 'X2', active: true })
     await wait()
 
-    const $$active = aggregation(({ active }) => {
+    const _active = aggregation(({ active }) => {
       return [{ $match: { active } }]
     })
 
     let renders = 0
     const Component = observer(() => {
       renders++
-      const $items = useAsyncSub($$active, { $collection: 'asyncAgg1', active: true })
+      const $items = useAsyncSub(_active, { $collection: 'asyncAgg1', active: true })
       if (!$items) return el('span', {}, 'Waiting...')
       return el('span', {}, $items.map($i => $i.name.get()).sort().join(','))
     })
diff --git a/packages/teamplay/test_client/react-extended.js b/packages/teamplay/test_client/30_react-extended.js
similarity index 99%
rename from packages/teamplay/test_client/react-extended.js
rename to packages/teamplay/test_client/30_react-extended.js
index ea472e9..05cbbac 100644
--- a/packages/teamplay/test_client/react-extended.js
+++ b/packages/teamplay/test_client/30_react-extended.js
@@ -44,20 +44,20 @@ import {
   useDidUpdate,
   useOnce,
   useSyncEffect
-} from '../index.js'
-import { setTestThrottling, resetTestThrottling, useSubClassic } from '../react/useSub.js'
-import { __resetSuspendMemoForTests } from '../react/useSuspendMemo.js'
-import { useId, useNow, useTriggerUpdate, useUnmount } from '../react/helpers.js'
+} from '../index.ts'
+import { setTestThrottling, resetTestThrottling, useSubClassic } from '../react/useSub.ts'
+import { __resetSuspendMemoForTests } from '../react/useSuspendMemo.ts'
+import { useId, useNow, useTriggerUpdate, useUnmount } from '../react/helpers.ts'
 import trapRender from '../react/trapRender.js'
-import renderAttemptDestroyer from '../react/renderAttemptDestroyer.js'
+import renderAttemptDestroyer from '../react/renderAttemptDestroyer.ts'
 import {
   __resetCompatComponentRegistryForTests,
   markCompatComponent
-} from '../react/compatComponentRegistry.js'
+} from '../react/compatComponentRegistry.ts'
 import { runGc, cache } from '../test/_helpers.js'
 import { get as _get, set as _set, del as _del } from '../orm/dataTree.js'
 import connect from '../connect/test.js'
-import { SEGMENTS } from '../orm/Signal.js'
+import { SEGMENTS } from '../orm/Signal.ts'
 import { docSubscriptions } from '../orm/Doc.js'
 import { PARAMS as QUERY_PARAMS, querySubscriptions } from '../orm/Query.js'
 import { aggregationSubscriptions, AGGREGATIONS } from '../orm/Aggregation.js'
diff --git a/packages/teamplay/test_client/session-ref-compat.js b/packages/teamplay/test_client/40_session-ref-compat.js
similarity index 99%
rename from packages/teamplay/test_client/session-ref-compat.js
rename to packages/teamplay/test_client/40_session-ref-compat.js
index 03f0338..ecfb1bb 100644
--- a/packages/teamplay/test_client/session-ref-compat.js
+++ b/packages/teamplay/test_client/40_session-ref-compat.js
@@ -1,9 +1,9 @@
 import { createElement as el, Fragment } from 'react'
 import { describe, it, beforeAll as before, afterEach, expect } from '@jest/globals'
 import { act, cleanup, fireEvent, render, waitFor } from '@testing-library/react'
-import { $, observer, useSession } from '../index.js'
+import { $, observer, useSession } from '../index.ts'
 import connect from '../connect/test.js'
-import { getConnection } from '../orm/connection.js'
+import { getConnection } from '../orm/connection.ts'
 import { del as _del } from '../orm/dataTree.js'
 
 const isCompatMode = process.env.TEAMPLAY_COMPAT === '1'
diff --git a/packages/teamplay/test_client/react-gc.js b/packages/teamplay/test_client/99_react-gc.js
similarity index 96%
rename from packages/teamplay/test_client/react-gc.js
rename to packages/teamplay/test_client/99_react-gc.js
index 34748ff..4f37ecd 100644
--- a/packages/teamplay/test_client/react-gc.js
+++ b/packages/teamplay/test_client/99_react-gc.js
@@ -1,11 +1,11 @@
 import { createElement as el, Fragment } from 'react'
 import { describe, it, afterEach, beforeEach, expect, beforeAll as before } from '@jest/globals'
 import { act, cleanup, render } from '@testing-library/react'
-import { $, useSub, observer, sub, aggregation } from '../index.js'
+import { $, useSub, observer, sub, aggregation } from '../index.ts'
 import { docSubscriptions } from '../orm/Doc.js'
 import { querySubscriptions } from '../orm/Query.js'
 import { aggregationSubscriptions } from '../orm/Aggregation.js'
-import { getSubscriptionGcDelay, setSubscriptionGcDelay } from '../orm/subscriptionGcDelay.js'
+import { getSubscriptionGcDelay, setSubscriptionGcDelay } from '../orm/subscriptionGcDelay.ts'
 import { runGc, cache } from '../test/_helpers.js'
 import connect from '../connect/test.js'
 
@@ -29,7 +29,7 @@ async function wait (ms = 30) {
   })
 }
 
-async function waitForCondition (predicate, timeoutMs = 500, stepMs = 20) {
+async function waitForCondition (predicate, timeoutMs = 3000, stepMs = 20) {
   const startedAt = Date.now()
   while (Date.now() - startedAt < timeoutMs) {
     if (predicate()) return
@@ -102,9 +102,9 @@ describe('GC cleanup: aggregation subscriptions', () => {
     $item.set({ name: 'Item1', active: true })
     await wait()
 
-    const $$agg = aggregation(({ active }) => [{ $match: { active } }])
+    const _agg = aggregation(({ active }) => [{ $match: { active } }])
     const Component = observer(() => {
-      const $items = useSub($$agg, { $collection: collection, active: true })
+      const $items = useSub(_agg, { $collection: collection, active: true })
       return el('span', {}, $items.get()?.length ?? 'loading')
     }, { suspenseProps: { fallback: el('span', {}, 'Loading...') } })
 
@@ -276,9 +276,9 @@ describe('GC cleanup: repeated mount/unmount cycles', () => {
 
     for (let i = 0; i < 3; i++) {
       const minScore = i * 10
-      const $$agg = aggregation(({ minScore }) => [{ $match: { score: { $gte: minScore } } }])
+      const _agg = aggregation(({ minScore }) => [{ $match: { score: { $gte: minScore } } }])
       const Component = observer(() => {
-        const $items = useSub($$agg, { $collection: collection, minScore })
+        const $items = useSub(_agg, { $collection: collection, minScore })
         return el('span', {}, String($items.get()?.length ?? 'loading'))
       }, { suspenseProps: { fallback: el('span', {}, 'Loading...') } })
       const { unmount } = render(el(Component))
@@ -364,7 +364,7 @@ describe('GC cleanup: switching subscription targets', () => {
 describe('GC cleanup: mixed subscription types in one component', () => {
   it('all subscription types clean up on unmount', async () => {
     const collection = 'gcMixed1'
-    const $$agg = aggregation(({ active }) => [{ $match: { active } }])
+    const _agg = aggregation(({ active }) => [{ $match: { active } }])
 
     // Record baseline before any subscriptions
     const initialDocs = docSubscriptions.docs.size
@@ -375,7 +375,7 @@ describe('GC cleanup: mixed subscription types in one component', () => {
     const Component = observer(() => {
       const $doc = useSub($[collection].m1)
       const $query = useSub($[collection], { active: true })
-      const $agg = useSub($$agg, { $collection: collection, active: true })
+      const $agg = useSub(_agg, { $collection: collection, active: true })
       return fr(
         el('span', { id: 'doc' }, $doc.name.get() || 'empty'),
         el('span', { id: 'query' }, String($query.map($u => $u.name.get()).join(','))),
diff --git a/packages/teamplay/test_client/testSequencer.cjs b/packages/teamplay/test_client/testSequencer.cjs
new file mode 100644
index 0000000..d6dce42
--- /dev/null
+++ b/packages/teamplay/test_client/testSequencer.cjs
@@ -0,0 +1,9 @@
+const Sequencer = require('@jest/test-sequencer').default
+
+class PathOrderSequencer extends Sequencer {
+  sort (tests) {
+    return Array.from(tests).sort((left, right) => left.path.localeCompare(right.path))
+  }
+}
+
+module.exports = PathOrderSequencer
diff --git a/packages/teamplay/test_types/external-consumer.ts b/packages/teamplay/test_types/external-consumer.ts
new file mode 100644
index 0000000..350c671
--- /dev/null
+++ b/packages/teamplay/test_types/external-consumer.ts
@@ -0,0 +1,127 @@
+import * as React from 'react'
+import $, {
+  Signal,
+  aggregation,
+  defineSchema,
+  getConnection,
+  getRootSignal,
+  getSubscriptionGcDelay,
+  observer,
+  setSubscriptionGcDelay,
+  sub,
+  useApi,
+  useDidUpdate,
+  useId,
+  useNow,
+  useOnce,
+  useScheduleUpdate,
+  useSub,
+  useSyncEffect,
+  useSuspendMemo,
+  useTriggerUpdate,
+  type FromJsonSchema,
+  type JsonSchemaSpec,
+  type JoinPath,
+  type RuntimeSignalInstance,
+  type SignalBaseInstance,
+  type SignalModelConstructor,
+  type TeamplayConnection,
+  type TeamplayShareDoc,
+  type RootSignal
+} from 'teamplay'
+import BaseModel, { defineModels, initModels, type ModelManifest } from 'teamplay/orm'
+
+type Assert<T extends true> = T
+type IsEqual<TActual, TExpected> =
+  (<T>() => T extends TActual ? 1 : 2) extends
+  (<T>() => T extends TExpected ? 1 : 2) ? true : false
+
+const userSchema = defineSchema({
+  name: { type: 'string', required: true },
+  age: { type: 'number' }
+})
+
+type UserDoc = FromJsonSchema<typeof userSchema>
+type _schemaInference = Assert<IsEqual<UserDoc, { name: string, age?: number }>>
+type _pathPatternJoin = Assert<IsEqual<JoinPath<readonly ['users', '*', 'tags', number]>, 'users.*.tags.*'>>
+
+class Users extends BaseModel<UserDoc[]> {}
+class User extends Signal<UserDoc> {}
+const userModelConstructor: SignalModelConstructor<UserDoc> = User
+
+declare module 'teamplay' {
+  interface TeamplayCollections {
+    users: JsonSchemaSpec<typeof userSchema, typeof Users, typeof User>
+  }
+}
+
+const models = defineModels({
+  users: { default: Users, schema: userSchema },
+  'users.*': { default: User }
+})
+
+const manifest: ModelManifest = models
+initModels(manifest)
+
+const root: RootSignal = $
+const scopedRoot = getRootSignal()
+const $user = scopedRoot.users.user1
+const typedUserSignal: Signal<UserDoc> = $user
+const runtimeSignal: RuntimeSignalInstance<UserDoc> = typedUserSignal
+const baseSignal: SignalBaseInstance<UserDoc> = runtimeSignal
+
+const maybeSubscribedUser = sub(typedUserSignal)
+type _subResult = Assert<IsEqual<typeof maybeSubscribedUser, Signal<UserDoc> | Promise<Signal<UserDoc>>>>
+
+const userStats = aggregation<{ total: number }>(() => [])
+const $stats = sub(userStats)
+type _aggregationResult = Assert<IsEqual<typeof $stats, Signal<{ total: number }> | Promise<Signal<{ total: number }>>>>
+
+const ObservedUser = observer(({ name }: { name: string }) => React.createElement('span', null, name))
+React.createElement(ObservedUser, { name: 'Ada' })
+// @ts-expect-error name is required by the observed component props.
+React.createElement(ObservedUser, {})
+
+const gcDelay: number = getSubscriptionGcDelay()
+const nextGcDelay: number = setSubscriptionGcDelay(gcDelay)
+const activeConnection: TeamplayConnection = getConnection()
+const maybeDoc: TeamplayShareDoc | undefined = activeConnection.collections?.users?.user1
+const fetchedDoc: TeamplayShareDoc = activeConnection.get('users', 'user1')
+
+function ExternalConsumerComponent () {
+  const maybeHookUser = useSub(typedUserSignal)
+  type _useSubResult = Assert<IsEqual<typeof maybeHookUser, Signal<UserDoc>>>
+
+  const [apiCount, apiLoading, apiError] = useApi(async (userId: string) => userId.length, 'user1', { debounce: 5 })
+  const countValue: number | undefined = apiCount
+  const loadingValue: boolean = apiLoading
+  const errorValue: unknown = apiError
+
+  const memoValue = useSuspendMemo(() => ({ id: 'memo-id' }), [])
+  const memoId: string = memoValue.id
+  const componentId: string = useId()
+  const createdAt: number = useNow()
+  const triggerUpdate: () => void = useTriggerUpdate()
+  const scheduleUpdate: (promise: PromiseLike<unknown>) => void = useScheduleUpdate()
+  useDidUpdate(() => undefined, [])
+  useOnce(true, () => undefined)
+  useSyncEffect(() => undefined, [])
+
+  root.batch(() => [
+    countValue,
+    loadingValue,
+    errorValue,
+    memoId,
+    componentId,
+    createdAt,
+    triggerUpdate,
+    scheduleUpdate(Promise.resolve()),
+    maybeDoc,
+    fetchedDoc,
+    nextGcDelay
+  ])
+
+  return React.createElement(ObservedUser, { name: 'Ada' })
+}
+
+React.createElement(ExternalConsumerComponent)
diff --git a/packages/teamplay/test_types/observer.ts b/packages/teamplay/test_types/observer.ts
new file mode 100644
index 0000000..e44a811
--- /dev/null
+++ b/packages/teamplay/test_types/observer.ts
@@ -0,0 +1,84 @@
+import * as React from 'react'
+import { $, observer, type Signal } from 'teamplay'
+
+type Equal<A, B> =
+  (<T>() => T extends A ? 1 : 2) extends
+  (<T>() => T extends B ? 1 : 2)
+    ? true
+    : false
+
+type Expect<T extends true> = T
+
+interface EventDoc {
+  name: string
+  createdAt: number
+}
+
+interface CreateModalProps {
+  $show: Signal<boolean>
+  $new: Signal<EventDoc>
+  title: string
+  optionalCount?: number
+}
+
+const CreateModal = observer(function CreateModal ({
+  $show,
+  $new,
+  title,
+  optionalCount
+}: CreateModalProps) {
+  const show: boolean = $show.get()
+  const name: string = $new.name.get()
+
+  $show.set(true)
+  $new.assign({ name: title, createdAt: Date.now() })
+
+  void show
+  void name
+  void optionalCount
+
+  return React.createElement('div')
+})
+
+type CreateModalPropsFromObserver = React.ComponentProps<typeof CreateModal>
+type ObserverKeepsComponentProps = Expect<Equal<CreateModalPropsFromObserver, CreateModalProps>>
+
+React.createElement(CreateModal, {
+  $show: $<boolean>(),
+  $new: $<EventDoc>(),
+  title: 'Create event'
+})
+
+// @ts-expect-error observer result should require props from the wrapped component
+const missingRequiredProp: CreateModalPropsFromObserver = {
+  $show: $<boolean>(),
+  $new: $<EventDoc>()
+}
+
+const wrongSignalProp: CreateModalPropsFromObserver = {
+  // @ts-expect-error observer result should preserve signal prop types
+  $show: $<string>(),
+  $new: $<EventDoc>(),
+  title: 'Create event'
+}
+
+const Input = observer(function Input (
+  { label }: { label: string },
+  ref: React.ForwardedRef<HTMLInputElement>
+) {
+  return React.createElement('input', { ref, 'aria-label': label })
+}, { forwardRef: true })
+
+React.createElement(Input, {
+  label: 'Name',
+  ref: React.createRef<HTMLInputElement>()
+})
+
+React.createElement(Input, {
+  label: 'Name',
+  // @ts-expect-error forwardRef observer result should preserve ref type
+  ref: React.createRef<HTMLTextAreaElement>()
+})
+
+void missingRequiredProp
+void wrongSignalProp
diff --git a/packages/teamplay/test_types/schema-fixtures.ts b/packages/teamplay/test_types/schema-fixtures.ts
new file mode 100644
index 0000000..fa07284
--- /dev/null
+++ b/packages/teamplay/test_types/schema-fixtures.ts
@@ -0,0 +1,64 @@
+import type { FromJsonSchema } from 'teamplay'
+import {
+  constSchema,
+  enumSchema,
+  fullObjectSchema,
+  keywordNamedFieldsSchema,
+  nestedObjectsAndArraysSchema,
+  nullableSchema,
+  shorthandSchema,
+  tupleSchema,
+  unsupportedDynamicSchema
+} from '../test/schemaFixtureMatrix.ts'
+
+type Equal<A, B> =
+  (<T>() => T extends A ? 1 : 2) extends
+  (<T>() => T extends B ? 1 : 2)
+    ? true
+    : false
+
+type Expect<T extends true> = T
+
+type SchemaFixtureAssertions = [
+  Expect<Equal<FromJsonSchema<typeof fullObjectSchema>, {
+    title: string
+    meta: {
+      createdAt: number
+      flags?: string[]
+    }
+    score?: number
+  }>>,
+  Expect<Equal<FromJsonSchema<typeof shorthandSchema>, {
+    title: string
+    score?: number
+  }>>,
+  Expect<Equal<FromJsonSchema<typeof keywordNamedFieldsSchema>, {
+    title: string
+    description?: string
+    type?: string
+    required?: boolean
+    properties?: {
+      color: string
+    }
+  }>>,
+  Expect<Equal<FromJsonSchema<typeof nestedObjectsAndArraysSchema>, {
+    team: {
+      name: string
+      players?: Array<{
+        id: string
+        active?: boolean
+      }>
+    }
+  }>>,
+  Expect<Equal<FromJsonSchema<typeof tupleSchema>, readonly [string, number, boolean]>>,
+  Expect<Equal<FromJsonSchema<typeof nullableSchema>, {
+    name: string
+    score?: number | null
+  } | null>>,
+  Expect<Equal<FromJsonSchema<typeof enumSchema>, 'draft' | 'published'>>,
+  Expect<Equal<FromJsonSchema<typeof constSchema>, 'system'>>,
+  Expect<Equal<FromJsonSchema<typeof unsupportedDynamicSchema>, unknown>>
+]
+
+declare const schemaFixtureAssertions: SchemaFixtureAssertions
+void schemaFixtureAssertions
diff --git a/packages/teamplay/test_types/signal-inference.ts b/packages/teamplay/test_types/signal-inference.ts
new file mode 100644
index 0000000..e3e86e3
--- /dev/null
+++ b/packages/teamplay/test_types/signal-inference.ts
@@ -0,0 +1,968 @@
+import {
+  $,
+  Signal,
+  addModel,
+  accessControl,
+  __aggregationHeader,
+  aggregation,
+  defineModels,
+  defineSchema,
+  sub,
+  useSub,
+  type AccessCreateContext as ExportedAccessCreateContext,
+  type CollectionsFromManifest,
+  type FromJsonSchema,
+  type JsonSchemaSpec,
+  type CollectionQuerySignal,
+  type DefaultAggregationSession,
+  type JoinPath,
+  type PathModelsFromManifest,
+  type QuerySignal,
+  type TypedAggregationInput,
+  type TypedSignal,
+  type ZodSchemaSpec
+} from 'teamplay'
+
+type Equal<A, B> =
+  (<T>() => T extends A ? 1 : 2) extends
+  (<T>() => T extends B ? 1 : 2)
+    ? true
+    : false
+
+type Expect<T extends true> = T
+type Extends<A, B> = A extends B ? true : false
+type AwaitedSub<T> = T extends Promise<infer Value> ? Value : T
+type PromiseValue<T> = T extends Promise<infer Value> ? Value : never
+type HasFindOpenGames<T> = T extends { findOpenGames: (...args: unknown[]) => unknown } ? true : false
+type PathPatternJoin = Expect<Equal<JoinPath<readonly ['games', '*', 'players', number]>, 'games.*.players.*'>>
+
+// Public Signal<T> is intentionally a registry-based facade. When T maps to
+// exactly one generated collection document type it exposes that model; when
+// multiple collections share the same document type it falls back to plain
+// signal fields to avoid guessing the wrong model.
+type TypeAssertions = [
+  GameSchemaInference,
+  PathPatternJoin,
+  TitleValue,
+  MaxPlayersValue,
+  StatusValue,
+  RootDollarCollectionAlias,
+  DocDollarDestructureTitle,
+  DocDollarDestructureStatus,
+  DocDollarDestructureNestedModel,
+  NestedDollarDestructureTagModel,
+  SubKeepsDocumentModel,
+  UseSubKeepsDocumentModel,
+  ZodStructuralInference,
+  NestedPathModelMethod,
+  NestedArrayPathModelMethod,
+  ModelThisNestedString,
+  ModelThisNestedPathMethod,
+  QueryNestedPathModelMethod,
+  AggregationNestedPathModelMethod,
+  QuerySignalType,
+  QueryIndexDocumentModel,
+  QueryIteratorDocumentModel,
+  HookQueryIndexDocumentModel,
+  AggregationIndexDocumentModel,
+  AggregationDocumentMethods,
+  HookAggregationIndexDocumentModel,
+  ExplicitAggregationIndexDocumentModel,
+  ExplicitAggregationDocumentMethods,
+  HeaderAggregationIndexDocumentModel,
+  AggregationSecondGenericSession,
+  AggregationThirdGenericSession,
+  HeaderAggregationSecondGenericSession,
+  ClientAggregationSecondGenericSession,
+  DefaultAggregationSessionUserId,
+  AggregationStatsTotal,
+  AggregationStatsUnread,
+  ExplicitAggregationRowsField,
+  LocalPrimitive,
+  LocalExplicitBoolean,
+  LocalExplicitBooleanSignal,
+  LocalExplicitEventTitle,
+  LocalSignalAliasBoolean,
+  LocalSignalAliasEventTitle,
+  SignalAliasDocumentModelMethod,
+  SignalAliasArrayMapDocumentModel,
+  SignalAliasArrayIteratorDocumentModel,
+  SignalAliasArrayCollectionModelMethod,
+  SignalAliasArrayCollectionAdd,
+  QueryResultAcceptedAsSignalArray,
+  QueryCollectionModelMethod,
+  QueryCollectionAdd,
+  QueryIdsSignal,
+  QueryExtraSignal,
+  CollectionQueryIdsSignal,
+  CollectionQueryExtraSignal,
+  QueryArrayMutatorBlocked,
+  AggregationArrayMutatorBlocked,
+  HookQueryCollectionModelMethod,
+  CollectionSignalArrayMapDocumentModel,
+  SignalAliasNestedPathModelMethod,
+  LocalNestedString,
+  LocalNestedBoolean,
+  LocalArrayMapItem,
+  LocalArrayMapThisArg,
+  LocalArrayReduceNoInitial,
+  LocalArrayIteratorItem,
+  LocalArrayFindItem,
+  LocalArrayFindThisArg,
+  QueryArrayReduceNoInitial,
+  CollectionAddReturnsId,
+  CollectionMethodChainAddReturnsId,
+  DocSetReturnsVoidPromise,
+  DocAssignReturnsVoidPromise,
+  NestedAssignReturnsVoidPromise,
+  NestedPopReturnsItem,
+  NestedShiftReturnsItem,
+  NestedArrayPushParameter,
+  NestedArrayPopReturn,
+  CollectionArrayMutatorBlocked,
+  NestedArrayMapLabels,
+  NestedArrayReduceItem,
+  QueryLoopTitle,
+  QueryLoopDollarDestructureTitle,
+  QueryLoopPoppedTag,
+  QueryLoopAssignResult,
+  QueryLoopTagLabels,
+  QueryLoopMaxPlayersTotal,
+  QueryLoopFoundTitle,
+  AggregationLoopTitle,
+  AggregationLoopDollarDestructureTitle,
+  AggregationLoopPoppedTag,
+  AggregationLoopTagLabels,
+  HookQueryMapTitle,
+  HookAggregationReduceTitle,
+  LocalComplexPopPlayer,
+  LocalDollarPrimitive,
+  LocalDollarString,
+  LocalComplexShiftPlayer,
+  LocalComplexInventoryPop,
+  LocalComplexMappedInventory,
+  LocalComplexFoundInventory,
+  ComputedNestedPlayerName,
+  ComputedDollarDestructure,
+  BatchKeepsCallbackReturn,
+  SignalMetadataMethods,
+  ComputedNumber,
+  ComputedString,
+  NullableSchemaInference,
+  NullableObjectSchemaInference,
+  SimplifiedKeywordFieldSchemaInference,
+  TupleSchemaInference,
+  DefinedSchemaInference,
+  AmbiguousDocumentFallbackField,
+  AmbiguousArrayFallbackItem,
+  TypedAggregationOutputField,
+  TypedAggregationOutputMethod,
+  AccessCreateDoc,
+  AccessCreateSession,
+  AccessReadDoc,
+  AccessUpdateOps,
+  AccessDeleteDoc,
+  ExportedAccessContextDoc,
+  AccessDefaultSessionUserId,
+  DefinedManifestCollection,
+  DefinedManifestDocPathModel,
+  DefinedManifestNestedPathModel
+]
+
+const gameSchema = {
+  info: {
+    type: 'object',
+    required: true,
+    properties: {
+      title: { type: 'string', required: true },
+      maxPlayers: { type: 'integer', required: true },
+      tags: {
+        type: 'array',
+        items: { type: 'string' }
+      }
+    }
+  },
+  status: {
+    type: 'string',
+    enum: ['draft', 'started'] as const
+  }
+} as const
+
+const nullableSchema = {
+  type: ['string', 'null']
+} as const
+
+const nullableObjectSchema = {
+  type: ['object', 'null'],
+  required: ['name'],
+  properties: {
+    name: { type: 'string' },
+    score: { type: ['integer', 'null'] }
+  }
+} as const
+
+const simplifiedKeywordFieldSchema = {
+  title: { type: 'string', required: true },
+  description: { type: 'string' },
+  type: { type: 'string' },
+  required: { type: 'boolean' },
+  enum: { type: 'string' },
+  const: { type: 'number' },
+  properties: {
+    type: 'object',
+    properties: {
+      color: { type: 'string', required: true }
+    }
+  },
+  name: { type: 'string' }
+} as const
+
+const tupleSchema = {
+  type: 'array',
+  items: [
+    { type: 'string' },
+    { type: 'integer' },
+    { type: 'boolean' }
+  ]
+} as const
+
+const definedSchema = defineSchema({
+  status: {
+    type: 'string',
+    enum: ['draft', 'published']
+  },
+  score: { type: 'integer', required: true }
+})
+
+interface Game {
+  info: {
+    title: string
+    maxPlayers: number
+    tags?: string[]
+  }
+  status?: 'draft' | 'started'
+}
+
+class GamesModel extends Signal<Game[]> {
+  findOpenGames () {
+    return this
+  }
+}
+
+class GameModel extends Signal<Game> {
+  titleFromThis () {
+    return this.info.title.get()
+  }
+
+  async start () {
+    await this.set({
+      info: {
+        title: 'Untitled',
+        maxPlayers: 4
+      },
+      status: 'started'
+    })
+  }
+}
+
+class GameInfoModel extends Signal<Game['info']> {
+  titleCase () {
+    return this.title.get().toUpperCase()
+  }
+}
+
+class GameTagModel extends Signal<string> {
+  label () {
+    return `#${this.get()}`
+  }
+}
+
+addModel('games', GamesModel)
+addModel('games.*', GameModel)
+addModel('games.*.info', GameInfoModel)
+addModel('games.*.info.tags.*', GameTagModel)
+// @ts-expect-error registered model patterns require the matching model class
+addModel('games.*.info', GameTagModel)
+
+interface ZodLikeGame {
+  _output?: {
+    info: {
+      title: string
+      maxPlayers: number
+    }
+  }
+}
+
+interface SharedDocShape {
+  name: string
+}
+
+const ambiguousSharedSchema = {
+  name: { type: 'string', required: true }
+} as const
+
+class SharedDocsAModel extends Signal<SharedDocShape[]> {
+  onlyOnSharedA () {
+    return this
+  }
+}
+
+class SharedDocAModel extends Signal<SharedDocShape> {
+  onlyOnSharedDocA () {
+    return this.name.get()
+  }
+}
+
+class SharedDocsBModel extends Signal<SharedDocShape[]> {
+  onlyOnSharedB () {
+    return this
+  }
+}
+
+class SharedDocBModel extends Signal<SharedDocShape> {
+  onlyOnSharedDocB () {
+    return this.name.get()
+  }
+}
+
+interface RoleCount {
+  role: string
+  count: number
+}
+
+class RoleCountModel extends Signal<RoleCount> {
+  label () {
+    return `${this.role.get()}: ${this.count.get()}`
+  }
+}
+
+const definedModels = defineModels({
+  games: {
+    default: GamesModel,
+    schema: gameSchema
+  },
+  'games.*': {
+    default: GameModel
+  },
+  'games.*.info': {
+    default: GameInfoModel
+  }
+})
+
+type DefinedManifestCollections = CollectionsFromManifest<typeof definedModels>
+type DefinedManifestPathModels = PathModelsFromManifest<typeof definedModels>
+type DefinedManifestCollection = Expect<Equal<
+  DefinedManifestCollections['games'],
+  JsonSchemaSpec<typeof gameSchema, typeof GamesModel, typeof GameModel>
+>>
+type DefinedManifestDocPathModel = Expect<Equal<DefinedManifestPathModels['games.*'], typeof GameModel>>
+type DefinedManifestNestedPathModel = Expect<Equal<DefinedManifestPathModels['games.*.info'], typeof GameInfoModel>>
+
+declare module 'teamplay' {
+  interface TeamplayCollections {
+    games: JsonSchemaSpec<typeof gameSchema, typeof GamesModel, typeof GameModel>
+    zodGames: ZodSchemaSpec<ZodLikeGame, typeof GamesModel, typeof GameModel>
+    sharedAs: JsonSchemaSpec<typeof ambiguousSharedSchema, typeof SharedDocsAModel, typeof SharedDocAModel>
+    sharedBs: JsonSchemaSpec<typeof ambiguousSharedSchema, typeof SharedDocsBModel, typeof SharedDocBModel>
+  }
+
+  interface TeamplayModels {
+    'games.*.info': typeof GameInfoModel
+    'games.*.info.tags.*': typeof GameTagModel
+  }
+}
+
+declare const gameId: string
+
+const $games = $.games
+const { $games: $gamesFromRootDestructure } = $
+$games.findOpenGames()
+$gamesFromRootDestructure.findOpenGames()
+const rootAliasAddId = $gamesFromRootDestructure.add({
+  info: {
+    title: 'Root Alias Game',
+    maxPlayers: 4
+  }
+})
+const collectionAddId = $games.add({
+  info: {
+    title: 'Chess',
+    maxPlayers: 2
+  },
+  status: 'draft'
+})
+const collectionMethodChainAddId = $games.findOpenGames().add({
+  info: {
+    title: 'Go',
+    maxPlayers: 2
+  }
+})
+// @ts-expect-error top-level collection signals use add(), not array mutators
+$games.push({
+  info: {
+    title: 'Mutator Chess',
+    maxPlayers: 2
+  }
+})
+// @ts-expect-error collection add should require schema-compatible documents
+$games.add({ status: 'draft' })
+
+const $game = $.games[gameId]
+const { $info: $destructuredInfo, $status: $destructuredStatus } = $game
+const {
+  $title: $destructuredTitle,
+  $maxPlayers: $destructuredMaxPlayers,
+  $tags: $destructuredTags
+} = $destructuredInfo
+const $subGame = sub($game)
+function useHookGame () {
+  return useSub($game)
+}
+const $zodGame = $.zodGames[gameId]
+$game.start()
+$game.info.title.set('Chess')
+$game.info.maxPlayers.increment()
+$game.info.tags[0].set('board')
+$game.info.titleCase()
+$game.info.tags[0].label()
+$destructuredTitle.set('Destructured Chess')
+$destructuredMaxPlayers.increment()
+$destructuredInfo.titleCase()
+$destructuredTags[0].label()
+const docSetResult = $game.set({
+  info: {
+    title: 'Checkers',
+    maxPlayers: 2
+  },
+  status: 'draft'
+})
+const docAssignResult = $game.assign({ status: 'started' })
+const nestedAssignResult = $game.info.assign({ maxPlayers: 4 })
+const poppedTag = $game.info.tags.pop()
+const shiftedTag = $game.info.tags.shift()
+$game.info.tags.push('classic')
+$game.info.tags.unshift('strategy')
+$game.info.tags.insert(0, ['board', 'turn-based'])
+$game.info.tags.remove(0)
+$game.info.tags.move(0, 1)
+$game.info.title.stringInsert(0, 'The ')
+$game.info.title.stringRemove(0, 4)
+const nestedTagLabels = $game.info.tags.map($tag => $tag.get())
+const nestedReducedTag = $game.info.tags.reduce(($firstTag, $secondTag) => $firstTag)
+const batchTitle = $game.batch(() => $game.info.title.get())
+const signalPath = $game.info.title.path()
+const signalLeaf = $game.info.title.leaf()
+const signalId = $game.getId()
+const signalCollection = $game.getCollection()
+const signalAssociations = $game.getAssociations()
+// @ts-expect-error unknown schema fields should not be suggested or accepted
+void $game.info.typo
+// @ts-expect-error setter values should follow schema inference
+$game.info.maxPlayers.set('two')
+// @ts-expect-error assign should reject fields which are not in the schema
+$game.assign({ typo: true })
+// @ts-expect-error assign should reject invalid nested field values
+$game.info.assign({ maxPlayers: 'many' })
+// @ts-expect-error array mutators should use the array item type
+$game.info.tags.push(123)
+// @ts-expect-error insert should use the array item type for individual values and arrays
+$game.info.tags.insert(0, [123])
+
+type GameSchemaInference = Expect<Equal<FromJsonSchema<typeof gameSchema>, Game>>
+type TitleValue = Expect<Equal<ReturnType<typeof $game.info.title.get>, string>>
+type MaxPlayersValue = Expect<Equal<ReturnType<typeof $game.info.maxPlayers.get>, number>>
+type StatusValue = Expect<Equal<ReturnType<typeof $game.status.get>, 'draft' | 'started' | undefined>>
+type RootDollarCollectionAlias = Expect<Equal<typeof rootAliasAddId, Promise<string>>>
+type DocDollarDestructureTitle = Expect<Equal<ReturnType<typeof $destructuredTitle.get>, string>>
+type DocDollarDestructureStatus = Expect<Equal<ReturnType<typeof $destructuredStatus.get>, 'draft' | 'started' | undefined>>
+type DocDollarDestructureNestedModel = Expect<Equal<ReturnType<typeof $destructuredInfo.titleCase>, string>>
+type NestedDollarDestructureTagModel = Expect<Equal<ReturnType<typeof $destructuredTags[0]['label']>, string>>
+type SubKeepsDocumentModel = Expect<Equal<AwaitedSub<typeof $subGame>, typeof $game>>
+type UseSubKeepsDocumentModel = Expect<Equal<ReturnType<typeof useHookGame>, typeof $game>>
+type ZodStructuralInference = Expect<Equal<ReturnType<typeof $zodGame.info.title.get>, string>>
+type NestedPathModelMethod = Expect<Equal<ReturnType<typeof $game.info.titleCase>, string>>
+type NestedArrayPathModelMethod = Expect<Equal<ReturnType<typeof $game.info.tags[0]['label']>, string>>
+type ModelThisNestedString = Expect<Equal<ReturnType<GameModel['titleFromThis']>, string>>
+type ModelThisNestedPathMethod = Expect<Equal<ReturnType<GameInfoModel['titleCase']>, string>>
+type CollectionAddReturnsId = Expect<Equal<typeof collectionAddId, Promise<string>>>
+type CollectionMethodChainAddReturnsId = Expect<Equal<typeof collectionMethodChainAddId, Promise<string>>>
+type DocSetReturnsVoidPromise = Expect<Equal<typeof docSetResult, Promise<void>>>
+type DocAssignReturnsVoidPromise = Expect<Equal<typeof docAssignResult, Promise<void>>>
+type NestedAssignReturnsVoidPromise = Expect<Equal<typeof nestedAssignResult, Promise<void>>>
+type NestedPopReturnsItem = Expect<Equal<PromiseValue<typeof poppedTag>, string | undefined>>
+type NestedShiftReturnsItem = Expect<Equal<PromiseValue<typeof shiftedTag>, string | undefined>>
+type NestedArrayPushParameter = Expect<Equal<Parameters<typeof $game.info.tags.push>[0], string>>
+type NestedArrayPopReturn = Expect<Equal<PromiseValue<ReturnType<typeof $game.info.tags.pop>>, string | undefined>>
+type CollectionArrayMutatorBlocked = Expect<Equal<NonNullable<typeof $games.push>, never>>
+type NestedArrayMapLabels = Expect<Equal<typeof nestedTagLabels[number], string>>
+type NestedArrayReduceItem = Expect<Equal<ReturnType<typeof nestedReducedTag.get>, string>>
+type BatchKeepsCallbackReturn = Expect<Equal<typeof batchTitle, string>>
+type SignalMetadataMethods = Expect<Equal<
+[
+  typeof signalPath,
+  typeof signalLeaf,
+  typeof signalId,
+  typeof signalCollection,
+  typeof signalAssociations
+],
+[
+  string,
+  string,
+  string | number,
+  string,
+  readonly unknown[]
+]
+>>
+type NullableSchemaInference = Expect<Equal<FromJsonSchema<typeof nullableSchema>, string | null>>
+type NullableObjectSchemaInference = Expect<Equal<FromJsonSchema<typeof nullableObjectSchema>, { name: string, score?: number | null } | null>>
+type SimplifiedKeywordFieldSchemaInference = Expect<Equal<FromJsonSchema<typeof simplifiedKeywordFieldSchema>, {
+  title: string
+  description?: string
+  type?: string
+  required?: boolean
+  enum?: string
+  const?: number
+  properties?: {
+    color: string
+  }
+  name?: string
+}>>
+type TupleSchemaInference = Expect<Equal<FromJsonSchema<typeof tupleSchema>, readonly [string, number, boolean]>>
+type DefinedSchemaInference = Expect<Equal<FromJsonSchema<typeof definedSchema>, {
+  status?: 'draft' | 'published'
+  score: number
+}>>
+
+const $queryGames = sub($.games, { status: 'draft' })
+sub($.games, { 'info.maxPlayers': { $gte: 2 }, 'info.title': { $regex: /chess/i } })
+sub($.games, { $sort: { 'info.maxPlayers': -1 } })
+function useHookQueryGames () {
+  return useSub($.games, { status: 'draft' })
+}
+function useHookQueryByTitle () {
+  return useSub($.games, { 'info.title': 'Chess' })
+}
+// @ts-expect-error collection query params must be an object
+sub($.games, 'draft')
+// @ts-expect-error query params should reject misspelled schema fields
+sub($.games, { stauts: 'draft' })
+// @ts-expect-error query params should reject wrong schema value types
+sub($.games, { 'info.maxPlayers': 'two' })
+// @ts-expect-error query operators should follow the field value type
+sub($.games, { status: { $in: ['draft', 'archived'] } })
+const _activeGames = aggregation('games', ({ active }: { active: boolean }) => [{ $match: { active } }])
+const $aggregationGames = sub(_activeGames, { active: true })
+const _typedActiveGames = aggregation<Game[]>(({ active }: { active: boolean }) => [{ $match: { active } }])
+const $typedAggregationGames = sub(_typedActiveGames, { active: true })
+const _headerActiveGames = __aggregationHeader<Game[]>({ collection: 'games', name: '_active' })
+const $headerAggregationGames = sub(_headerActiveGames, { active: true })
+interface AggregationSessionShape {
+  userId?: string
+  role: 'admin' | 'member'
+}
+const _secondGenericSessionGames = aggregation<Game[], AggregationSessionShape>((_params, { session }) => {
+  const role = session.role
+  return [{ $match: { role } }]
+})
+const _thirdGenericSessionGames = aggregation<Game[], 'games', AggregationSessionShape>((_params, { collection, session }) => {
+  const gamesCollection = collection
+  const role = session.role
+  return [{ $match: { collection: gamesCollection, role } }]
+})
+const _headerSessionGames = __aggregationHeader<Game[], AggregationSessionShape>({ collection: 'games', name: '_active' })
+const _clientSecondGenericSessionGames = aggregation<Game[], AggregationSessionShape>('games', (_params, { session }) => {
+  const role = session.role
+  return [{ $match: { role } }]
+})
+const _notificationStats = aggregation<{ total: number, currentDay: number, unread: number }>('games', () => [])
+const $notificationStats = sub(_notificationStats, {})
+const _roleCountRows = aggregation<RoleCount[]>('games', () => [])
+const $roleCountRows = sub(_roleCountRows, {})
+const _roleCounts = null as unknown as TypedAggregationInput<RoleCount, typeof RoleCountModel>
+const $roleCounts = sub(_roleCounts, { active: true })
+function useHookAggregationGames () {
+  return useSub(_activeGames, { active: true })
+}
+const $hookQueryGame = (null as unknown as ReturnType<typeof useHookQueryGames>)[0]
+const $aggregationGame = (null as unknown as AggregationGames)[0]
+const $typedAggregationGame = (null as unknown as TypedAggregationGames)[0]
+const $hookAggregationGame = (null as unknown as ReturnType<typeof useHookAggregationGames>)[0]
+
+type QueryGames = AwaitedSub<typeof $queryGames>
+type AggregationGames = AwaitedSub<typeof $aggregationGames>
+type TypedAggregationGames = AwaitedSub<typeof $typedAggregationGames>
+type HeaderAggregationGames = AwaitedSub<typeof $headerAggregationGames>
+type NotificationStats = AwaitedSub<typeof $notificationStats>
+type RoleCountRows = AwaitedSub<typeof $roleCountRows>
+type RoleCounts = AwaitedSub<typeof $roleCounts>
+type QueryGameItem = QueryGames extends Iterable<infer Item> ? Item : never
+const $roleCount = (null as unknown as RoleCounts)[0]
+const $roleCountRow = (null as unknown as RoleCountRows)[0]
+type QuerySignalType = Expect<Equal<QueryGames, CollectionQuerySignal<Game, typeof GamesModel, typeof GameModel, readonly ['games']>>>
+type QueryIndexDocumentModel = Expect<Equal<ReturnType<QueryGames[0]['info']['title']['get']>, string>>
+type QueryIteratorDocumentModel = Expect<Equal<ReturnType<QueryGameItem['info']['title']['get']>, string>>
+type HookQueryIndexDocumentModel = Expect<Equal<ReturnType<typeof $hookQueryGame.info.maxPlayers.get>, number>>
+type AggregationIndexDocumentModel = Expect<Equal<ReturnType<typeof $aggregationGame.info.title.get>, string>>
+type AggregationDocumentMethods = Expect<Equal<ReturnType<typeof $aggregationGame.start>, Promise<void>>>
+type HookAggregationIndexDocumentModel = Expect<Equal<ReturnType<typeof $hookAggregationGame.info.maxPlayers.get>, number>>
+type ExplicitAggregationIndexDocumentModel = Expect<Equal<ReturnType<typeof $typedAggregationGame.info.title.get>, string>>
+type ExplicitAggregationDocumentMethods = Expect<Equal<ReturnType<typeof $typedAggregationGame.start>, Promise<void>>>
+type HeaderAggregationIndexDocumentModel = Expect<Equal<ReturnType<HeaderAggregationGames[0]['info']['title']['get']>, string>>
+type AggregationSecondGenericSession = Expect<Equal<typeof _secondGenericSessionGames['__teamplayAggregationSession'], AggregationSessionShape | undefined>>
+type AggregationThirdGenericSession = Expect<Equal<typeof _thirdGenericSessionGames['__teamplayAggregationSession'], AggregationSessionShape | undefined>>
+type HeaderAggregationSecondGenericSession = Expect<Equal<typeof _headerSessionGames['__teamplayAggregationSession'], AggregationSessionShape | undefined>>
+type ClientAggregationSecondGenericSession = Expect<Equal<typeof _clientSecondGenericSessionGames['__teamplayAggregationSession'], AggregationSessionShape | undefined>>
+type DefaultAggregationSessionUserId = Expect<Equal<DefaultAggregationSession['userId'], string | undefined>>
+type AggregationStatsTotal = Expect<Equal<ReturnType<NotificationStats['total']['get']>, number>>
+type AggregationStatsUnread = Expect<Equal<ReturnType<NotificationStats['unread']['get']>, number>>
+type ExplicitAggregationRowsField = Expect<Equal<ReturnType<typeof $roleCountRow.count.get>, number>>
+type QueryNestedPathModelMethod = Expect<Equal<ReturnType<typeof $hookQueryGame.info.titleCase>, string>>
+type AggregationNestedPathModelMethod = Expect<Equal<ReturnType<typeof $aggregationGame.info.tags[0]['label']>, string>>
+type TypedAggregationOutputField = Expect<Equal<ReturnType<typeof $roleCount.count.get>, number>>
+type TypedAggregationOutputMethod = Expect<Equal<ReturnType<typeof $roleCount.label>, string>>
+const gameAccess = accessControl<Game, { userId?: string }>({
+  create ({ newDoc, session, type }) {
+    const operation: 'create' = type
+    void operation
+    return Boolean(session.userId && newDoc.info.title)
+  },
+  read ({ doc }) {
+    return doc.info.maxPlayers > 0
+  },
+  update: {
+    fn ({ doc, newDoc, ops }) {
+      return ops.length > 0 && doc.info.title !== newDoc.info.title
+    }
+  },
+  delete ({ doc }) {
+    return doc.status !== 'started'
+  }
+})
+accessControl<Game, { userId?: string }, string>({
+  read: 'admin'
+})
+accessControl<Game>({
+  read ({ session }) {
+    const userId = session.userId
+    return Boolean(userId)
+  },
+  create ({ newDoc }) {
+    // @ts-expect-error create access receives newDoc, not doc
+    return Boolean(newDoc.info.title && newDoc.doc)
+  }
+})
+accessControl<Game>({
+  // @ts-expect-error accessControl only accepts create/read/update/delete rules
+  publish: true
+})
+type AccessCreateRule = Extract<Exclude<typeof gameAccess.create, boolean | undefined>, (context: any) => any>
+type AccessCreateContext = AccessCreateRule extends (context: infer Context) => any ? Context : never
+type AccessReadRule = Extract<Exclude<typeof gameAccess.read, boolean | undefined>, (context: any) => any>
+type AccessReadContext = AccessReadRule extends (context: infer Context) => any ? Context : never
+type AccessUpdateRule = Extract<Exclude<typeof gameAccess.update, boolean | undefined>, { fn: (context: any) => any }>
+type AccessUpdateContext = AccessUpdateRule extends { fn: (context: infer Context) => any } ? Context : never
+type AccessDeleteRule = Extract<Exclude<typeof gameAccess.delete, boolean | undefined>, (context: any) => any>
+type AccessDeleteContext = AccessDeleteRule extends (context: infer Context) => any ? Context : never
+type AccessCreateDoc = Expect<Equal<AccessCreateContext['newDoc'], Game>>
+type AccessCreateSession = Expect<Equal<AccessCreateContext['session'], { userId?: string }>>
+type AccessReadDoc = Expect<Equal<AccessReadContext['doc'], Game>>
+type AccessUpdateOps = Expect<Equal<AccessUpdateContext['ops'], unknown[]>>
+type AccessDeleteDoc = Expect<Equal<AccessDeleteContext['doc'], Game>>
+type ExportedAccessContextDoc = Expect<Equal<ExportedAccessCreateContext<Game>['newDoc'], Game>>
+type AccessDefaultSessionUserId = Expect<Equal<ExportedAccessCreateContext<Game>['session']['userId'], string | undefined>>
+declare const $resolvedQueryGames: QueryGames
+declare const $plainQuerySignal: QuerySignal
+const $firstQueryGame = $resolvedQueryGames.reduce(($firstGame, $secondGame) => $firstGame)
+const $resolvedOpenQueryGames = $resolvedQueryGames.findOpenGames()
+const $plainQueryIds = $plainQuerySignal.ids
+const $plainQueryExtra = $plainQuerySignal.extra
+const $resolvedQueryIds = $resolvedQueryGames.ids
+const $resolvedQueryExtra = $resolvedQueryGames.extra
+// @ts-expect-error query signals are array-readable but not array-mutable at the top level
+$resolvedQueryGames.push({
+  info: {
+    title: 'Queried Mutator Go',
+    maxPlayers: 2
+  }
+})
+// @ts-expect-error aggregation signals are array-readable but not array-mutable at the top level
+$aggregationGames.push({
+  info: {
+    title: 'Aggregated Mutator Go',
+    maxPlayers: 2
+  }
+})
+const $hookOpenQueryGames = (null as unknown as ReturnType<typeof useHookQueryGames>).findOpenGames()
+const resolvedOpenQueryAddId = $resolvedOpenQueryGames.add({
+  info: {
+    title: 'Queried Go',
+    maxPlayers: 2
+  }
+})
+const hookOpenQueryAddId = $hookOpenQueryGames.add({
+  info: {
+    title: 'Hook Queried Go',
+    maxPlayers: 2
+  }
+})
+type QueryArrayReduceNoInitial = Expect<Equal<ReturnType<typeof $firstQueryGame.info.title.get>, string>>
+type QueryCollectionModelMethod = Expect<Equal<HasFindOpenGames<QueryGames>, true>>
+type QueryCollectionAdd = Expect<Equal<typeof resolvedOpenQueryAddId, Promise<string>>>
+type QueryIdsSignal = Expect<Equal<ReturnType<typeof $plainQueryIds.get>, Array<string | number>>>
+type QueryExtraSignal = Expect<Equal<ReturnType<typeof $plainQueryExtra.get>, unknown>>
+type CollectionQueryIdsSignal = Expect<Equal<ReturnType<typeof $resolvedQueryIds.get>, Array<string | number>>>
+type CollectionQueryExtraSignal = Expect<Extends<typeof $resolvedQueryExtra, { get: () => unknown }>>
+type QueryArrayMutatorBlocked = Expect<Equal<NonNullable<QueryGames['push']>, never>>
+type AggregationArrayMutatorBlocked = Expect<Equal<NonNullable<AggregationGames['push']>, never>>
+type HookQueryCollectionModelMethod = Expect<Equal<typeof hookOpenQueryAddId, Promise<string>>>
+
+async function queryLoopAssertions () {
+  const $draftGames = await sub($.games, { status: 'draft' })
+  const titles = $draftGames.map($draftGame => $draftGame.info.title.get())
+  const destructuredTitles = $draftGames.map(({ $info }) => $info.$title.get())
+  const maxPlayersTotal = $draftGames.reduce((total, $draftGame) => {
+    $draftGame.info.maxPlayers.increment()
+    return total + $draftGame.info.maxPlayers.get()
+  }, 0)
+  const $foundGame = $draftGames.find($draftGame => $draftGame.info.maxPlayers.get() > 1)
+  let loopTitle = ''
+  let poppedTag: string | undefined
+  let assignResult: void | undefined
+
+  for (const $draftGame of $draftGames) {
+    await $draftGame.start()
+    assignResult = await $draftGame.assign({ status: 'started' })
+    await $draftGame.info.assign({ title: $draftGame.titleFromThis() })
+    await $draftGame.info.tags.push('ranked')
+    poppedTag = await $draftGame.info.tags.pop()
+    loopTitle = $draftGame.info.title.get()
+    $draftGame.info.tags[0].label()
+  }
+
+  return {
+    loopTitle,
+    destructuredTitle: destructuredTitles[0],
+    poppedTag,
+    assignResult,
+    tagLabels: $draftGames.map($draftGame => $draftGame.info.tags[0].label()),
+    maxPlayersTotal,
+    foundTitle: $foundGame?.info.title.get()
+  }
+}
+
+async function aggregationLoopAssertions () {
+  const $activeGames = await sub(_activeGames, { active: true })
+  let loopTitle = ''
+  let destructuredTitle = ''
+  let poppedTag: string | undefined
+
+  for (const $activeGame of $activeGames) {
+    const { $info } = $activeGame
+    await $activeGame.start()
+    await $activeGame.info.tags.unshift('featured')
+    poppedTag = await $activeGame.info.tags.shift()
+    loopTitle = $activeGame.titleFromThis()
+    destructuredTitle = $info.$title.get()
+  }
+
+  return {
+    loopTitle,
+    destructuredTitle,
+    poppedTag,
+    tagLabels: $activeGames.map($activeGame => $activeGame.info.tags[0].label())
+  }
+}
+
+function useHookSignalChainAssertions () {
+  const $hookDraftGames = useSub($.games, { status: 'draft' })
+  const hookQueryTitles = $hookDraftGames.map($hookDraftGame => $hookDraftGame.info.title.get())
+  const $hookActiveGames = useSub(_activeGames, { active: true })
+  const hookAggregationTitle = $hookActiveGames.reduce(($firstGame, $secondGame) => $firstGame).titleFromThis()
+
+  return {
+    hookQueryTitles,
+    hookAggregationTitle
+  }
+}
+
+type QueryLoopResult = Awaited<ReturnType<typeof queryLoopAssertions>>
+type AggregationLoopResult = Awaited<ReturnType<typeof aggregationLoopAssertions>>
+type HookSignalChainResult = ReturnType<typeof useHookSignalChainAssertions>
+type QueryLoopTitle = Expect<Equal<QueryLoopResult['loopTitle'], string>>
+type QueryLoopDollarDestructureTitle = Expect<Equal<QueryLoopResult['destructuredTitle'], string>>
+type QueryLoopPoppedTag = Expect<Equal<QueryLoopResult['poppedTag'], string | undefined>>
+type QueryLoopAssignResult = Expect<Equal<QueryLoopResult['assignResult'], void | undefined>>
+type QueryLoopTagLabels = Expect<Equal<QueryLoopResult['tagLabels'][number], string>>
+type QueryLoopMaxPlayersTotal = Expect<Equal<QueryLoopResult['maxPlayersTotal'], number>>
+type QueryLoopFoundTitle = Expect<Equal<QueryLoopResult['foundTitle'], string | undefined>>
+type AggregationLoopTitle = Expect<Equal<AggregationLoopResult['loopTitle'], string>>
+type AggregationLoopDollarDestructureTitle = Expect<Equal<AggregationLoopResult['destructuredTitle'], string>>
+type AggregationLoopPoppedTag = Expect<Equal<AggregationLoopResult['poppedTag'], string | undefined>>
+type AggregationLoopTagLabels = Expect<Equal<AggregationLoopResult['tagLabels'][number], string>>
+type HookQueryMapTitle = Expect<Equal<HookSignalChainResult['hookQueryTitles'][number], string>>
+type HookAggregationReduceTitle = Expect<Equal<HookSignalChainResult['hookAggregationTitle'], string>>
+
+const $score = $(0)
+$score.increment()
+// @ts-expect-error primitive local signals should not expose arbitrary child paths
+void $score.nope
+
+interface NewEventDoc {
+  title: string
+  active?: boolean
+}
+
+const $explicitBoolean = $<boolean>()
+const $explicitEvent = $<NewEventDoc>()
+const $signalAliasBoolean: Signal<boolean> = $<boolean>()
+const $signalAliasEvent: Signal<NewEventDoc> = $<NewEventDoc>()
+const $signalAliasGame: Signal<Game> = $.games[gameId]
+const $signalAliasGames: Signal<Game[]> = $.games
+const $ambiguousSharedDoc = null as unknown as Signal<SharedDocShape>
+const $ambiguousSharedDocs = null as unknown as Signal<SharedDocShape[]>
+const signalAliasGameTitles = $signalAliasGames.map($game => $game.titleFromThis())
+const collectionSignalGameTitles = $.games.map($game => $game.titleFromThis())
+const ambiguousSharedNames = $ambiguousSharedDocs.map($doc => $doc.name.get())
+const $signalAliasOpenGames = $signalAliasGames.findOpenGames()
+const signalAliasOpenGameAddId = $signalAliasOpenGames.add({
+  info: {
+    title: 'Signal Alias Go',
+    maxPlayers: 2
+  }
+})
+$explicitBoolean.set(true)
+$explicitEvent.assign({ title: 'Launch' })
+// @ts-expect-error ambiguous document shapes should not guess a document model
+$ambiguousSharedDoc.onlyOnSharedDocA()
+// @ts-expect-error ambiguous document arrays should not guess a collection model
+$ambiguousSharedDocs.onlyOnSharedA()
+// @ts-expect-error explicit generic no-arg local signals should keep the requested primitive type
+$explicitBoolean.set('true')
+// @ts-expect-error explicit generic no-arg local signals should keep object field types
+$explicitEvent.assign({ title: 1 })
+
+const $scoreboard = $({
+  players: [{ name: 'Robot 1', robot: true }],
+  totalPlayers: 0,
+  round: 0
+})
+$scoreboard.players[0].name.set('Robot 2')
+$scoreboard.players[0].robot.set(false)
+$scoreboard.totalPlayers.increment()
+const localPlayerNames = $scoreboard.players.map($player => $player.name.get())
+const localPlayerNamesWithThisArg = $scoreboard.players.map($player => $player.name.get(), { prefix: '#' })
+const localFirstPlayerFromReduce = $scoreboard.players.reduce(($firstPlayer, $secondPlayer) => $firstPlayer)
+const foundLocalPlayer = $scoreboard.players.find($player => $player.robot.get())
+const foundLocalPlayerWithThisArg = $scoreboard.players.find($player => $player.robot.get(), { robot: true })
+const {
+  $score: $destructuredLocalScore,
+  $title: $destructuredLocalTitle
+} = $({ score: 0, title: 'New Game' })
+$destructuredLocalScore.increment()
+$destructuredLocalTitle.stringInsert(0, 'Draft: ')
+
+const $localTournament = $({
+  teams: [{
+    name: 'Blue',
+    players: [{
+      name: 'Ada',
+      score: 0,
+      inventory: ['map']
+    }]
+  }],
+  meta: {
+    round: 1,
+    started: false
+  }
+})
+const localComplexPopPlayer = $localTournament.teams[0].players.pop()
+const localComplexShiftPlayer = $localTournament.teams[0].players.shift()
+$localTournament.teams[0].players.push({
+  name: 'Grace',
+  score: 1,
+  inventory: ['shield']
+})
+$localTournament.teams[0].players[0].score.increment(2)
+$localTournament.teams[0].players[0].assign({ score: 3 })
+const localComplexInventoryPop = $localTournament.teams[0].players[0].inventory.pop()
+const localComplexMappedInventory = $localTournament.teams[0].players[0].inventory.map($item => $item.get().toUpperCase())
+const localComplexFoundPlayer = $localTournament.teams[0].players.find($player => $player.inventory[0].get() === 'map')
+// @ts-expect-error local array item pushes should follow the inferred item shape
+$localTournament.teams[0].players.push({ name: 'Bad', inventory: ['missing score'] })
+// @ts-expect-error local nested assign should follow the inferred field types
+$localTournament.teams[0].players[0].assign({ score: 'high' })
+
+const $computedScoreboard = $(() => ({
+  nextRound: $scoreboard.round.get() + 1,
+  firstPlayerName: $scoreboard.players[0].name.get(),
+  tournament: {
+    leaderName: $localTournament.teams[0].players[0].name.get(),
+    nextRound: $localTournament.meta.round.get() + 1
+  }
+}))
+
+type LocalPrimitive = Expect<Equal<ReturnType<typeof $score.get>, number>>
+type LocalExplicitBoolean = Expect<Equal<ReturnType<typeof $explicitBoolean.get>, boolean>>
+type LocalExplicitBooleanSignal = Expect<Equal<typeof $explicitBoolean, TypedSignal<boolean>>>
+type LocalExplicitEventTitle = Expect<Equal<ReturnType<typeof $explicitEvent.title.get>, string>>
+type LocalSignalAliasBoolean = Expect<Equal<ReturnType<typeof $signalAliasBoolean.get>, boolean>>
+type LocalSignalAliasEventTitle = Expect<Equal<ReturnType<typeof $signalAliasEvent.title.get>, string>>
+type SignalAliasDocumentModelMethod = Expect<Equal<ReturnType<typeof $signalAliasGame.titleFromThis>, string>>
+type SignalAliasArrayMapDocumentModel = Expect<Equal<typeof signalAliasGameTitles[number], string>>
+type CollectionSignalArrayMapDocumentModel = Expect<Equal<typeof collectionSignalGameTitles[number], string>>
+type SignalAliasArrayCollectionModelMethod = Expect<Equal<HasFindOpenGames<typeof $signalAliasGames>, true>>
+type SignalAliasArrayCollectionAdd = Expect<Equal<typeof signalAliasOpenGameAddId, Promise<string>>>
+type SignalAliasNestedPathModelMethod = Expect<Equal<ReturnType<typeof $signalAliasGame.info.titleCase>, string>>
+type AmbiguousDocumentFallbackField = Expect<Equal<ReturnType<typeof $ambiguousSharedDoc.name.get>, string>>
+type AmbiguousArrayFallbackItem = Expect<Equal<typeof ambiguousSharedNames[number], string>>
+type LocalDollarPrimitive = Expect<Equal<ReturnType<typeof $destructuredLocalScore.get>, number>>
+type LocalDollarString = Expect<Equal<ReturnType<typeof $destructuredLocalTitle.get>, string>>
+const $localPlayer = $scoreboard.players[0]
+type LocalNestedString = Expect<Equal<ReturnType<typeof $localPlayer.name.get>, string>>
+type LocalNestedBoolean = Expect<Equal<ReturnType<typeof $localPlayer.robot.get>, boolean>>
+type LocalPlayerIteratorItem = typeof $scoreboard.players extends Iterable<infer Item> ? Item : never
+type LocalArrayMapItem = Expect<Equal<typeof localPlayerNames[number], string>>
+type LocalArrayMapThisArg = Expect<Equal<typeof localPlayerNamesWithThisArg[number], string>>
+type LocalArrayReduceNoInitial = Expect<Equal<ReturnType<typeof localFirstPlayerFromReduce.name.get>, string>>
+type LocalArrayIteratorItem = Expect<Equal<ReturnType<LocalPlayerIteratorItem['name']['get']>, string>>
+type LocalArrayFindItem = Expect<Equal<ReturnType<NonNullable<typeof foundLocalPlayer>['robot']['get']>, boolean>>
+type LocalArrayFindThisArg = Expect<Equal<ReturnType<NonNullable<typeof foundLocalPlayerWithThisArg>['robot']['get']>, boolean>>
+type LocalComplexPopPlayer = Expect<Equal<PromiseValue<typeof localComplexPopPlayer>, { name: string, score: number, inventory: string[] } | undefined>>
+type LocalComplexShiftPlayer = Expect<Equal<PromiseValue<typeof localComplexShiftPlayer>, { name: string, score: number, inventory: string[] } | undefined>>
+type LocalComplexInventoryPop = Expect<Equal<PromiseValue<typeof localComplexInventoryPop>, string | undefined>>
+type LocalComplexMappedInventory = Expect<Equal<typeof localComplexMappedInventory[number], string>>
+type LocalComplexFoundInventory = Expect<Equal<ReturnType<NonNullable<typeof localComplexFoundPlayer>['inventory'][0]['get']>, string>>
+type ComputedNumber = Expect<Equal<ReturnType<typeof $computedScoreboard.nextRound.get>, number>>
+type ComputedString = Expect<Equal<ReturnType<typeof $computedScoreboard.firstPlayerName.get>, string>>
+type ComputedNestedPlayerName = Expect<Equal<ReturnType<typeof $computedScoreboard.tournament.leaderName.get>, string>>
+const { $tournament: $computedTournament } = $computedScoreboard
+type ComputedDollarDestructure = Expect<Equal<ReturnType<typeof $computedTournament.$leaderName.get>, string>>
+
+function printGameTitles ($games: Signal<Game[]>) {
+  const titles = $games.map($game => $game.titleFromThis())
+  let loopTitle = ''
+
+  for (const $game of $games) {
+    $game.start()
+    loopTitle = $game.titleFromThis()
+  }
+
+  return {
+    titles,
+    loopTitle,
+    firstTitle: $games[0].titleFromThis()
+  }
+}
+
+async function printQueriedGameTitles () {
+  const $draftGames = await sub($.games, { status: 'draft' })
+  return printGameTitles($draftGames)
+}
+
+type PrintGameTitlesResult = ReturnType<typeof printGameTitles>
+type PrintQueriedGameTitlesResult = Awaited<ReturnType<typeof printQueriedGameTitles>>
+type SignalAliasArrayIteratorDocumentModel = Expect<Equal<PrintGameTitlesResult['loopTitle'], string>>
+type QueryResultAcceptedAsSignalArray = Expect<Equal<PrintQueriedGameTitlesResult['firstTitle'], string>>
+
+declare const typeAssertions: TypeAssertions
+void typeAssertions
diff --git a/packages/teamplay/tsconfig.external-consumer.json b/packages/teamplay/tsconfig.external-consumer.json
new file mode 100644
index 0000000..1f8c0ab
--- /dev/null
+++ b/packages/teamplay/tsconfig.external-consumer.json
@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "allowJs": false,
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "jsx": "react-jsx",
+    "types": [
+      "react"
+    ]
+  },
+  "include": [
+    "test_types/external-consumer.ts"
+  ]
+}
diff --git a/packages/teamplay/tsconfig.type-tests.json b/packages/teamplay/tsconfig.type-tests.json
new file mode 100644
index 0000000..c0b9a78
--- /dev/null
+++ b/packages/teamplay/tsconfig.type-tests.json
@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "allowJs": true,
+    "checkJs": false,
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "jsx": "react-jsx",
+    "types": [
+      "react"
+    ]
+  },
+  "include": [
+    "index.ts",
+    "orm/**/*.ts",
+    "react/**/*.ts",
+    "../schema/index.ts",
+    "../utils/aggregation.ts",
+    "../utils/accessControl.ts",
+    "test_types/**/*.ts"
+  ]
+}
diff --git a/packages/teamplay/utils/MockFinalizationRegistry.js b/packages/teamplay/utils/MockFinalizationRegistry.js
deleted file mode 100644
index 2879a9c..0000000
--- a/packages/teamplay/utils/MockFinalizationRegistry.js
+++ /dev/null
@@ -1,94 +0,0 @@
-export const REGISTRY_SWEEP_INTERVAL = 10000
-
-// This is a mock implementation of FinalizationRegistry which doesn't actually
-// finalize anything. It's used in environments where FinalizationRegistry is not
-// available and it can not be simulated using WeakRef (e.g. React Native <0.75 or Old Architecture).
-export class PermanentFinalizationRegistry {
-  registrations = new Map()
-  sweepTimeout
-
-  constructor (finalize) {
-    this.finalize = finalize
-  }
-
-  // Token is actually required with this impl
-  register (target, value, token) {
-    this.registrations.set(token, {
-      value,
-      registeredAt: Date.now()
-    })
-  }
-
-  unregister (token) {
-    this.registrations.delete(token)
-  }
-}
-
-// This is a mock implementation of FinalizationRegistry which uses WeakRef to
-// track the target objects. It's used in environments where FinalizationRegistry
-// is not available but WeakRef is (e.g. React Native >=0.75 on New Architecture).
-export class WeakRefBasedFinalizationRegistry {
-  counter = 0
-  registrations = new Map()
-  sweepTimeout
-
-  constructor (finalize) {
-    this.finalize = finalize
-  }
-
-  // Token is actually required with this impl
-  register (target, value, token) {
-    this.registrations.set(this.counter, {
-      targetRef: new WeakRef(target),
-      tokenRef: token != null ? new WeakRef(token) : undefined,
-      value
-    })
-    this.counter++
-    this.scheduleSweep()
-  }
-
-  unregister (token) {
-    if (token == null) return
-    this.registrations.forEach((registration, key) => {
-      if (registration.tokenRef?.deref() === token) {
-        this.registrations.delete(key)
-      }
-    })
-  }
-
-  // Bound so it can be used directly as setTimeout callback.
-  sweep = () => {
-    clearTimeout(this.sweepTimeout)
-    this.sweepTimeout = undefined
-
-    this.registrations.forEach((registration, key) => {
-      if (registration.targetRef.deref() !== undefined) return
-      const value = registration.value
-      this.registrations.delete(key)
-      this.finalize(value)
-    })
-
-    if (this.registrations.size > 0) this.scheduleSweep()
-  }
-
-  scheduleSweep () {
-    if (this.sweepTimeout) return
-    this.sweepTimeout = setTimeout(this.sweep, REGISTRY_SWEEP_INTERVAL)
-  }
-}
-
-let ExportedFinalizationRegistry
-
-if (typeof FinalizationRegistry !== 'undefined') {
-  ExportedFinalizationRegistry = FinalizationRegistry
-} else if (typeof WeakRef !== 'undefined') {
-  console.warn('FinalizationRegistry is not available in this environment. ' +
-      'Using a mock implementation: WeakRefBasedFinalizationRegistry')
-  ExportedFinalizationRegistry = WeakRefBasedFinalizationRegistry
-} else {
-  console.warn('Neither FinalizationRegistry nor WeakRef are available in this environment. ' +
-      'Using a mock implementation: PermanentFinalizationRegistry')
-  ExportedFinalizationRegistry = PermanentFinalizationRegistry
-}
-
-export default ExportedFinalizationRegistry
diff --git a/packages/teamplay/utils/MockFinalizationRegistry.ts b/packages/teamplay/utils/MockFinalizationRegistry.ts
new file mode 100644
index 0000000..d18adb9
--- /dev/null
+++ b/packages/teamplay/utils/MockFinalizationRegistry.ts
@@ -0,0 +1,115 @@
+export const REGISTRY_SWEEP_INTERVAL = 10000
+
+type TimeoutId = ReturnType<typeof setTimeout>
+
+interface PermanentRegistration<TValue> {
+  readonly value: TValue
+  readonly registeredAt: number
+}
+
+interface WeakRefRegistration<TValue> {
+  readonly targetRef: WeakRef<object>
+  readonly tokenRef?: WeakRef<object>
+  readonly value: TValue
+}
+
+export interface FinalizationRegistryLike<TValue = unknown> {
+  register: (target: object, value: TValue, token?: object) => void
+  unregister: (token: object) => void
+}
+
+export type FinalizationRegistryLikeConstructor = new <TValue = unknown>(
+  finalize: (value: TValue) => void
+) => FinalizationRegistryLike<TValue>
+
+// This implementation never finalizes. It is used where neither native
+// FinalizationRegistry nor WeakRef-based polling can be simulated.
+export class PermanentFinalizationRegistry<TValue = unknown> {
+  readonly registrations = new Map<object, PermanentRegistration<TValue>>()
+  sweepTimeout: TimeoutId | undefined
+  private readonly finalize: (value: TValue) => void
+
+  constructor (finalize: (value: TValue) => void) {
+    this.finalize = finalize
+  }
+
+  // Token is required for this implementation because it is the map key.
+  register (_target: object, value: TValue, token?: object): void {
+    if (token == null) return
+    this.registrations.set(token, {
+      value,
+      registeredAt: Date.now()
+    })
+  }
+
+  unregister (token: object): void {
+    this.registrations.delete(token)
+  }
+}
+
+// This implementation polls WeakRefs when native FinalizationRegistry is missing.
+export class WeakRefBasedFinalizationRegistry<TValue = unknown> {
+  counter = 0
+  readonly registrations = new Map<number, WeakRefRegistration<TValue>>()
+  sweepTimeout: TimeoutId | undefined
+  private readonly finalize: (value: TValue) => void
+
+  constructor (finalize: (value: TValue) => void) {
+    this.finalize = finalize
+  }
+
+  register (target: object, value: TValue, token?: object): void {
+    this.registrations.set(this.counter, {
+      targetRef: new WeakRef(target),
+      tokenRef: token != null ? new WeakRef(token) : undefined,
+      value
+    })
+    this.counter++
+    this.scheduleSweep()
+  }
+
+  unregister (token?: object): void {
+    if (token == null) return
+    this.registrations.forEach((registration, key) => {
+      if (registration.tokenRef?.deref() === token) {
+        this.registrations.delete(key)
+      }
+    })
+  }
+
+  // Bound so it can be used directly as setTimeout callback.
+  sweep = (): void => {
+    clearTimeout(this.sweepTimeout)
+    this.sweepTimeout = undefined
+
+    this.registrations.forEach((registration, key) => {
+      if (registration.targetRef.deref() !== undefined) return
+      const value = registration.value
+      this.registrations.delete(key)
+      this.finalize(value)
+    })
+
+    if (this.registrations.size > 0) this.scheduleSweep()
+  }
+
+  scheduleSweep (): void {
+    if (this.sweepTimeout) return
+    this.sweepTimeout = setTimeout(this.sweep, REGISTRY_SWEEP_INTERVAL)
+  }
+}
+
+let ExportedFinalizationRegistry: FinalizationRegistryLikeConstructor
+
+if (typeof FinalizationRegistry !== 'undefined') {
+  ExportedFinalizationRegistry = FinalizationRegistry as FinalizationRegistryLikeConstructor
+} else if (typeof WeakRef !== 'undefined') {
+  console.warn('FinalizationRegistry is not available in this environment. ' +
+      'Using a mock implementation: WeakRefBasedFinalizationRegistry')
+  ExportedFinalizationRegistry = WeakRefBasedFinalizationRegistry
+} else {
+  console.warn('Neither FinalizationRegistry nor WeakRef are available in this environment. ' +
+      'Using a mock implementation: PermanentFinalizationRegistry')
+  ExportedFinalizationRegistry = PermanentFinalizationRegistry
+}
+
+export default ExportedFinalizationRegistry
diff --git a/packages/teamplay/utils/MockWeakRef.js b/packages/teamplay/utils/MockWeakRef.js
deleted file mode 100644
index 9ab5924..0000000
--- a/packages/teamplay/utils/MockWeakRef.js
+++ /dev/null
@@ -1,25 +0,0 @@
-export class MockWeakRef {
-  constructor (value) {
-    this.value = value
-  }
-
-  deref () {
-    return this.value
-  }
-}
-
-export function destroyMockWeakRef (weakRef) {
-  if (!(weakRef instanceof MockWeakRef)) return
-  weakRef.value = undefined
-}
-
-let ExportedWeakRef
-
-if (typeof WeakRef !== 'undefined') {
-  ExportedWeakRef = WeakRef
-} else {
-  console.warn('WeakRef is not available in this environment. Using a mock implementation: MockWeakRef')
-  ExportedWeakRef = MockWeakRef
-}
-
-export default ExportedWeakRef
diff --git a/packages/teamplay/utils/MockWeakRef.ts b/packages/teamplay/utils/MockWeakRef.ts
new file mode 100644
index 0000000..880ac0a
--- /dev/null
+++ b/packages/teamplay/utils/MockWeakRef.ts
@@ -0,0 +1,35 @@
+export interface WeakRefLike<TValue extends object = object> {
+  deref: () => TValue | undefined
+}
+
+export type WeakRefLikeConstructor = new <TValue extends object>(
+  value: TValue
+) => WeakRefLike<TValue>
+
+export class MockWeakRef<TValue extends object = object> implements WeakRefLike<TValue> {
+  value: TValue | undefined
+
+  constructor (value: TValue) {
+    this.value = value
+  }
+
+  deref (): TValue | undefined {
+    return this.value
+  }
+}
+
+export function destroyMockWeakRef (weakRef: unknown): void {
+  if (!(weakRef instanceof MockWeakRef)) return
+  weakRef.value = undefined
+}
+
+let ExportedWeakRef: WeakRefLikeConstructor
+
+if (typeof WeakRef !== 'undefined') {
+  ExportedWeakRef = WeakRef as WeakRefLikeConstructor
+} else {
+  console.warn('WeakRef is not available in this environment. Using a mock implementation: MockWeakRef')
+  ExportedWeakRef = MockWeakRef
+}
+
+export default ExportedWeakRef
diff --git a/packages/teamplay/utils/isServer.js b/packages/teamplay/utils/isServer.js
deleted file mode 100644
index 2537f48..0000000
--- a/packages/teamplay/utils/isServer.js
+++ /dev/null
@@ -1,17 +0,0 @@
-let isServer = checkIsServer()
-
-function checkIsServer () {
-  if (typeof process === 'object' && process.__mockBrowser) {
-    return false
-  } else if (typeof Deno !== 'undefined' && Deno?.version?.deno) { // eslint-disable-line no-undef
-    return true
-  } else if (typeof process === 'object' && process.versions && process.versions.node) {
-    return true
-  }
-}
-
-export function setIsServer (value) {
-  isServer = value
-}
-
-export default isServer
diff --git a/packages/teamplay/utils/isServer.ts b/packages/teamplay/utils/isServer.ts
new file mode 100644
index 0000000..1bba7f5
--- /dev/null
+++ b/packages/teamplay/utils/isServer.ts
@@ -0,0 +1,28 @@
+let isServer = checkIsServer()
+
+interface ProcessLike {
+  __mockBrowser?: boolean
+  versions?: { node?: string }
+}
+
+interface DenoLike {
+  version?: { deno?: string }
+}
+
+function checkIsServer (): boolean | undefined {
+  const processLike = (globalThis as { process?: ProcessLike }).process
+  const denoLike = (globalThis as { Deno?: DenoLike }).Deno
+  if (typeof processLike === 'object' && processLike.__mockBrowser) {
+    return false
+  } else if (denoLike?.version?.deno) {
+    return true
+  } else if (typeof processLike === 'object' && processLike.versions?.node) {
+    return true
+  }
+}
+
+export function setIsServer (value: boolean | undefined): void {
+  isServer = value
+}
+
+export default isServer
diff --git a/packages/teamplay/utils/useIsomorphicLayoutEffect.js b/packages/teamplay/utils/useIsomorphicLayoutEffect.js
index cd4ea42..4c3918b 100644
--- a/packages/teamplay/utils/useIsomorphicLayoutEffect.js
+++ b/packages/teamplay/utils/useIsomorphicLayoutEffect.js
@@ -1,4 +1,4 @@
 import { useEffect, useLayoutEffect } from 'react'
-import isServer from './isServer.js'
+import isServer from './isServer.ts'
 
 export default isServer ? useEffect : useLayoutEffect
diff --git a/packages/utils/accessControl.js b/packages/utils/accessControl.js
deleted file mode 100644
index 7a9983c..0000000
--- a/packages/utils/accessControl.js
+++ /dev/null
@@ -1,33 +0,0 @@
-export const isAccessControlSymbol = Symbol('is access control object')
-export const OPERATIONS = [
-  'create',
-  'read',
-  'update',
-  'delete'
-]
-
-export function isAccessControl (something) {
-  if (something?.[isAccessControlSymbol]) return true
-  return false
-}
-
-export function accessControl (props) {
-  if (typeof props !== 'object') throw Error(ERRORS.mustBeObject(props))
-  for (const key in props) {
-    if (!OPERATIONS.includes(key)) throw Error(ERRORS.unknownOperation(key))
-  }
-  props[isAccessControlSymbol] ??= true
-  return props
-}
-
-const ERRORS = {
-  mustBeObject: props => `
-    accessControl: must be an object.
-    Got: ${JSON.stringify(props)}
-  `,
-  unknownOperation: (op) => `
-    accessControl: unknown operation is specified.
-    Got: '${op}'
-    Available: ${JSON.stringify(OPERATIONS)}
-  `
-}
diff --git a/packages/utils/accessControl.ts b/packages/utils/accessControl.ts
new file mode 100644
index 0000000..a93a298
--- /dev/null
+++ b/packages/utils/accessControl.ts
@@ -0,0 +1,213 @@
+export const isAccessControlSymbol: unique symbol = Symbol('is access control object')
+
+export const OPERATIONS = [
+  'create',
+  'read',
+  'update',
+  'delete'
+] as const
+
+export type AccessOperation = typeof OPERATIONS[number]
+
+export type AccessDecision = boolean | Promise<boolean>
+
+/** Default TeamPlay session shape available in access-control validators. */
+export interface DefaultAccessSession {
+  userId?: string
+}
+
+/** Shared fields passed to every access-control validator. */
+export interface AccessBaseContext<TSession = DefaultAccessSession> {
+  /** Operation being checked. */
+  type: AccessOperation
+  /** ShareDB collection name. */
+  collection: string
+  /** ShareDB document id. */
+  docId: string
+  /** Connect session object attached to the ShareDB request. */
+  session: TSession
+}
+
+/** Context passed to the `create` access rule. */
+export interface AccessCreateContext<TDoc = unknown, TSession = DefaultAccessSession>
+  extends AccessBaseContext<TSession> {
+  type: 'create'
+  /** Document data being created. */
+  newDoc: TDoc
+}
+
+/** Context passed to the `read` access rule. */
+export interface AccessReadContext<TDoc = unknown, TSession = DefaultAccessSession>
+  extends AccessBaseContext<TSession> {
+  type: 'read'
+  /** Existing document data being read. */
+  doc: TDoc
+}
+
+/** Context passed to the `update` access rule. */
+export interface AccessUpdateContext<TDoc = unknown, TSession = DefaultAccessSession>
+  extends AccessBaseContext<TSession> {
+  type: 'update'
+  /** Document data before the operation. */
+  doc: TDoc
+  /** Document data after the operation. */
+  newDoc: TDoc
+  /** Raw ShareDB operations being applied. */
+  ops: unknown[]
+}
+
+/** Context passed to the `delete` access rule. */
+export interface AccessDeleteContext<TDoc = unknown, TSession = DefaultAccessSession>
+  extends AccessBaseContext<TSession> {
+  type: 'delete'
+  /** Existing document data being deleted. */
+  doc: TDoc
+}
+
+/**
+ * Function access rule.
+ *
+ * @param context Operation-specific context. For example, `create` receives
+ * `{ type: 'create', newDoc, collection, docId, session }`, while `update`
+ * receives `{ type: 'update', doc, newDoc, ops, collection, docId, session }`.
+ * @returns `true` to allow the operation, `false` to deny it.
+ */
+export type AccessValidator<TContext> = (context: TContext) => AccessDecision
+
+/** Object access rule shape supported by ShareDB access validators. */
+export interface AccessValidatorObject<TContext> {
+  /**
+   * Function access rule.
+   * @param context Operation-specific access context.
+   * @returns `true` to allow the operation, `false` to deny it.
+   */
+  fn: AccessValidator<TContext>
+}
+
+/**
+ * Access rule for one operation.
+ *
+ * Use `true` to always allow, `false` or omission to deny, a function to decide
+ * from the operation context, or `{ fn }` when integrating with ShareDB access
+ * validator objects. `TCustomRule` can be used for custom ShareDB validators.
+ */
+export type AccessRule<TContext, TCustomRule = never> =
+  | boolean
+  | AccessValidator<TContext>
+  | AccessValidatorObject<TContext>
+  | TCustomRule
+
+/** Access rules for a collection document. */
+export interface AccessControlRules<
+  TDoc = unknown,
+  TSession = DefaultAccessSession,
+  TCustomRule = never
+> {
+  /**
+   * Controls document creation.
+   *
+   * Use `true` to allow all creates, `false` or omission to deny creates, or a
+   * function to decide per request. When this rule is a function, it receives
+   * `{ type: 'create', newDoc, collection, docId, session }`.
+   */
+  create?: AccessRule<AccessCreateContext<TDoc, TSession>, TCustomRule>
+
+  /**
+   * Controls document reads.
+   *
+   * Use `true` to allow all reads, `false` or omission to deny reads, or a
+   * function to decide per request. When this rule is a function, it receives
+   * `{ type: 'read', doc, collection, docId, session }`.
+   */
+  read?: AccessRule<AccessReadContext<TDoc, TSession>, TCustomRule>
+
+  /**
+   * Controls document updates.
+   *
+   * Use `true` to allow all updates, `false` or omission to deny updates, or a
+   * function to decide per request. When this rule is a function, it receives
+   * `{ type: 'update', doc, newDoc, ops, collection, docId, session }`.
+   */
+  update?: AccessRule<AccessUpdateContext<TDoc, TSession>, TCustomRule>
+
+  /**
+   * Controls document deletion.
+   *
+   * Use `true` to allow all deletes, `false` or omission to deny deletes, or a
+   * function to decide per request. When this rule is a function, it receives
+   * `{ type: 'delete', doc, collection, docId, session }`.
+   */
+  delete?: AccessRule<AccessDeleteContext<TDoc, TSession>, TCustomRule>
+}
+
+export type AccessControl<
+  TDoc = unknown,
+  TSession = DefaultAccessSession,
+  TCustomRule = never
+> = AccessControlRules<TDoc, TSession, TCustomRule> & {
+  readonly [isAccessControlSymbol]: true
+}
+
+type MutableAccessControl<
+  TDoc = unknown,
+  TSession = DefaultAccessSession,
+  TCustomRule = never
+> = AccessControlRules<TDoc, TSession, TCustomRule> & {
+  [isAccessControlSymbol]?: true
+}
+
+/** Check whether a value was created with `accessControl()`. */
+export function isAccessControl (something: unknown): something is AccessControl {
+  return Boolean((something as Partial<AccessControl> | undefined)?.[isAccessControlSymbol])
+}
+
+/**
+ * Mark collection access rules for backend registration.
+ *
+ * The object can contain `create`, `read`, `update`, and `delete` keys:
+ * `create` controls new document creation, `read` controls reading existing
+ * documents, `update` controls writes to existing documents, and `delete`
+ * controls document deletion.
+ *
+ * Each rule can be `true`, `false`, a validator function, or `{ fn }`. Omitted
+ * rules deny the operation. Validator functions may return a boolean or a
+ * promise resolving to a boolean.
+ *
+ * Function rules receive operation-specific context:
+ * `create` receives `{ type: 'create', newDoc, collection, docId, session }`;
+ * `read` receives `{ type: 'read', doc, collection, docId, session }`;
+ * `update` receives `{ type: 'update', doc, newDoc, ops, collection, docId, session }`;
+ * `delete` receives `{ type: 'delete', doc, collection, docId, session }`.
+ *
+ * @typeParam TDoc Document shape for the collection this access object belongs to.
+ * @typeParam TSession Session shape attached to ShareDB requests.
+ * @typeParam TCustomRule Extra rule value accepted by a custom ShareDB access validator.
+ * @param props Access rules keyed by `create`, `read`, `update`, and `delete`.
+ */
+export function accessControl<
+  TDoc = unknown,
+  TSession = DefaultAccessSession,
+  TCustomRule = never
+> (
+  props: AccessControlRules<TDoc, TSession, TCustomRule>
+): AccessControl<TDoc, TSession, TCustomRule> {
+  if (!props || typeof props !== 'object') throw Error(ERRORS.mustBeObject(props))
+  for (const key in props) {
+    if (!(OPERATIONS as readonly string[]).includes(key)) throw Error(ERRORS.unknownOperation(key))
+  }
+  const access = props as MutableAccessControl<TDoc, TSession, TCustomRule>
+  access[isAccessControlSymbol] ??= true
+  return access as AccessControl<TDoc, TSession, TCustomRule>
+}
+
+const ERRORS = {
+  mustBeObject: (props: unknown) => `
+    accessControl: must be an object.
+    Got: ${JSON.stringify(props)}
+  `,
+  unknownOperation: (op: string) => `
+    accessControl: unknown operation is specified.
+    Got: '${op}'
+    Available: ${JSON.stringify(OPERATIONS)}
+  `
+}
diff --git a/packages/utils/aggregation.js b/packages/utils/aggregation.js
deleted file mode 100644
index 1af6164..0000000
--- a/packages/utils/aggregation.js
+++ /dev/null
@@ -1,63 +0,0 @@
-export const isAggregationFlag = '__isAggregation'
-export const isClientAggregationFlag = '__isClientAggregation'
-
-export function isAggregation (something) {
-  return isAggregationFunction(something) || isAggregationHeader(something)
-}
-
-export function isAggregationFunction (fn) {
-  return typeof fn === 'function' && fn[isAggregationFlag]
-}
-
-export function isClientAggregationFunction (fn) {
-  return isAggregationFunction(fn) && fn[isClientAggregationFlag]
-}
-
-export function isAggregationHeader (aggregationMeta) {
-  return validateAggregationMeta(aggregationMeta) && aggregationMeta[isAggregationFlag]
-}
-
-// this is a universal aggregation function which can be either used on client side or on server
-// On the client it has arguments like clientAggregation('collectionName', aggregationFn)
-export function aggregation (aggregationFn) {
-  if (typeof aggregationFn === 'string') return clientAggregation(...arguments)
-  if (typeof aggregationFn !== 'function') throw Error('aggregation: argument must be a function')
-  aggregationFn[isAggregationFlag] = true
-  return aggregationFn
-}
-
-export function clientAggregation (collection, aggregationFn) {
-  if (typeof collection !== 'string') throw Error('clientAggregation: collection must be a string')
-  if (typeof aggregationFn !== 'function') throw Error('clientAggregation: aggregationFn must be a function')
-  aggregationFn[isAggregationFlag] = true
-  aggregationFn[isClientAggregationFlag] = true
-  aggregationFn.collection = collection
-  return aggregationFn
-}
-
-// during compilation, calls to aggregation() are replaced with:
-// aggregationHeader({ collection: 'collectionName', name: 'aggregationName' })
-export function aggregationHeader (aggregationMeta) {
-  if (!validateAggregationMeta(aggregationMeta)) {
-    throw Error(ERRORS.wrongAggregationMeta(aggregationMeta))
-  }
-  aggregationMeta[isAggregationFlag] = true
-  return aggregationMeta
-}
-
-function validateAggregationMeta (aggregationMeta) {
-  if (
-    typeof aggregationMeta === 'object' &&
-    typeof aggregationMeta.collection === 'string' &&
-    typeof aggregationMeta.name === 'string'
-  ) return true
-  return false
-}
-
-const ERRORS = {
-  wrongAggregationMeta: (aggregationMeta) => `
-    aggregationHeader: invalid aggregationMeta
-      Expected: { collection: 'collectionName', name: 'aggregationName' }
-      Received: ${JSON.stringify(aggregationMeta)}
-  `
-}
diff --git a/packages/utils/aggregation.ts b/packages/utils/aggregation.ts
new file mode 100644
index 0000000..da05ca3
--- /dev/null
+++ b/packages/utils/aggregation.ts
@@ -0,0 +1,298 @@
+export const isAggregationFlag = '__isAggregation' as const
+export const isClientAggregationFlag = '__isClientAggregation' as const
+
+/** Parameters passed by `sub(_aggregation, params)` or `useSub(_aggregation, params)`. */
+export type AggregationParams = Record<string, any>
+
+/** Query object returned by an aggregation callback. */
+export type AggregationQuery = Record<string, any> | readonly Record<string, any>[]
+
+/** Default TeamPlay session shape available in aggregation callbacks. */
+export interface DefaultAggregationSession {
+  userId?: string
+}
+
+/** Context passed as the second argument to an aggregation callback. */
+export interface AggregationContext<
+  TCollection extends string = string,
+  TSession = DefaultAggregationSession
+> {
+  /** Collection this aggregation runs against. */
+  collection: TCollection
+  /** Connect session object attached to the request. */
+  session: TSession
+  /** Whether the aggregation is being evaluated from server-side code. */
+  isServer?: boolean
+}
+
+/**
+ * Function passed to `aggregation()`.
+ *
+ * @param params Parameters from `sub(_aggregation, params)` or `useSub(_aggregation, params)`.
+ * @param context Runtime context with `{ collection, session, isServer }`.
+ * @returns A Mongo aggregation pipeline array, or an aggregation query object such as `{ $aggregate: [...] }`.
+ */
+export type AggregationCallback<
+  TCollection extends string = string,
+  TSession = DefaultAggregationSession
+> = (params: any, context: AggregationContext<TCollection, TSession>) => any
+
+type AggregationCollection<TCollectionOrSession, TFallback extends string = string> =
+  TCollectionOrSession extends string ? TCollectionOrSession : TFallback
+
+type AggregationSession<TCollectionOrSession, TSession> =
+  TCollectionOrSession extends string ? TSession : TCollectionOrSession
+
+export interface AggregationMeta<
+  TCollection extends string = string,
+  TOutput = unknown,
+  TSession = DefaultAggregationSession
+> {
+  /** Marker used by TeamPlay to identify aggregation headers. */
+  readonly [isAggregationFlag]: true
+  /** Collection this aggregation runs against. */
+  readonly collection: TCollection
+  /** Aggregation name registered by the StartupJS model loader. */
+  readonly name: string
+  /** Type-only metadata for the value returned by aggregation subscriptions. */
+  readonly __teamplayAggregationOutput?: TOutput
+  /** Type-only metadata for the session shape passed to the aggregation callback. */
+  readonly __teamplayAggregationSession?: TSession
+}
+
+export interface AggregationFunction<
+  TOutput = unknown,
+  TCollection extends string = string,
+  TSession = DefaultAggregationSession
+> {
+  /**
+   * Execute the server aggregation pipeline builder.
+   * @param params Subscription params passed to the aggregation.
+   * @param context Runtime context with `{ collection, session, isServer }`.
+   */
+  (...args: any[]): any
+  /** Marker used by TeamPlay to identify aggregation functions. */
+  readonly [isAggregationFlag]: true
+  /** Collection this aggregation runs against when known on the client. */
+  readonly collection?: TCollection
+  /** Type-only metadata for the value returned by aggregation subscriptions. */
+  readonly __teamplayAggregationOutput?: TOutput
+  /** Type-only metadata for the session shape passed to the aggregation callback. */
+  readonly __teamplayAggregationSession?: TSession
+}
+
+export interface ClientAggregationFunction<
+  TOutput = unknown,
+  TCollection extends string = string,
+  TSession = DefaultAggregationSession
+> extends AggregationFunction<TOutput, TCollection, TSession> {
+  /** Marker used by TeamPlay to identify client aggregations with a known collection. */
+  readonly [isClientAggregationFlag]: true
+  /** Collection this aggregation runs against. */
+  readonly collection: TCollection
+}
+
+type MutableAggregationFunction<
+  TOutput = unknown,
+  TCollection extends string = string,
+  TSession = DefaultAggregationSession
+> =
+  ((...args: any[]) => any) & {
+    [isAggregationFlag]?: true
+    [isClientAggregationFlag]?: true
+    collection?: TCollection
+    __teamplayAggregationOutput?: TOutput
+    __teamplayAggregationSession?: TSession
+  }
+
+export function isAggregation (something: unknown): something is AggregationFunction | AggregationMeta {
+  return isAggregationFunction(something) || isAggregationHeader(something)
+}
+
+export function isAggregationFunction (fn: unknown): fn is AggregationFunction {
+  return typeof fn === 'function' && Boolean((fn as Partial<AggregationFunction>)[isAggregationFlag])
+}
+
+export function isClientAggregationFunction (fn: unknown): fn is ClientAggregationFunction {
+  return isAggregationFunction(fn) && Boolean((fn as Partial<ClientAggregationFunction>)[isClientAggregationFlag])
+}
+
+export function isAggregationHeader (aggregationMeta: unknown): aggregationMeta is AggregationMeta {
+  return validateAggregationMeta(aggregationMeta) && aggregationMeta[isAggregationFlag]
+}
+
+/**
+ * Create a client aggregation for a specific collection.
+ *
+ * Use `aggregation<User[]>('users', fn)` for row-like results and
+ * `aggregation<{ total: number }>('users', fn)` for custom result objects.
+ *
+ * @typeParam TOutput Full value returned by aggregation subscriptions.
+ * @typeParam TCollectionOrSession Collection name when it is a string, otherwise session shape.
+ * @typeParam TSession Session shape when the second generic is used for collection name.
+ * @param collection Collection name this aggregation runs against.
+ * @param fn Aggregation callback. It receives `(params, context)`, where `params`
+ * are the subscription params and `context` has `{ collection, session, isServer }`.
+ * Return a Mongo aggregation pipeline array, or an aggregation query object such
+ * as `{ $aggregate: [...] }`.
+ */
+export function aggregation<
+  TOutput = unknown,
+  TCollectionOrSession = string,
+  TSession = DefaultAggregationSession,
+  TCollection extends string = AggregationCollection<TCollectionOrSession>
+> (
+  collection: TCollection,
+  fn: AggregationCallback<TCollection, AggregationSession<TCollectionOrSession, TSession>>
+): ClientAggregationFunction<TOutput, TCollection, AggregationSession<TCollectionOrSession, TSession>>
+/**
+ * Mark a model-file aggregation function for server aggregation loading.
+ *
+ * Use `aggregation<User[]>(fn)` for row-like results and
+ * `aggregation<{ total: number }>(fn)` for custom result objects.
+ * Use `aggregation<User[], Session>(fn)` to type `context.session`, or
+ * `aggregation<User[], 'users', Session>(fn)` when the collection type is
+ * part of the call site.
+ * The TeamPlay Babel plugin replaces this call with an aggregation header in
+ * client bundles, including when the call uses a TypeScript generic.
+ *
+ * @typeParam TOutput Full value returned by aggregation subscriptions.
+ * @typeParam TCollectionOrSession Collection name when it is a string, otherwise session shape.
+ * @typeParam TSession Session shape when the second generic is used for collection name.
+ * @param fn Aggregation callback. It receives `(params, context)`, where `params`
+ * are the subscription params and `context` has `{ collection, session, isServer }`.
+ * Return a Mongo aggregation pipeline array, or an aggregation query object such
+ * as `{ $aggregate: [...] }`.
+ */
+export function aggregation<
+  TOutput = unknown,
+  TCollectionOrSession = string,
+  TSession = DefaultAggregationSession
+> (
+  fn: AggregationCallback<
+    AggregationCollection<TCollectionOrSession>,
+    AggregationSession<TCollectionOrSession, TSession>
+  >
+): AggregationFunction<
+  TOutput,
+  AggregationCollection<TCollectionOrSession>,
+  AggregationSession<TCollectionOrSession, TSession>
+>
+/**
+ * Mark a model-file aggregation function for server aggregation loading.
+ * @param fn Aggregation callback. It receives `(params, context)`, where `params`
+ * are the subscription params and `context` has `{ collection, session, isServer }`.
+ */
+export function aggregation (fn: AggregationCallback): AggregationFunction
+export function aggregation<
+  TOutput = unknown,
+  TCollectionOrSession = string,
+  TSession = DefaultAggregationSession,
+  TCollection extends string = AggregationCollection<TCollectionOrSession>
+> (
+  collectionOrFn: TCollection | AggregationCallback<TCollection, AggregationSession<TCollectionOrSession, TSession>>,
+  aggregationFn?: AggregationCallback<TCollection, AggregationSession<TCollectionOrSession, TSession>>
+): AggregationFunction<TOutput, TCollection, AggregationSession<TCollectionOrSession, TSession>> | ClientAggregationFunction<TOutput, TCollection, AggregationSession<TCollectionOrSession, TSession>> {
+  if (typeof collectionOrFn === 'string') return clientAggregation(collectionOrFn, aggregationFn)
+  if (typeof collectionOrFn !== 'function') throw Error('aggregation: argument must be a function')
+  const fn = collectionOrFn as MutableAggregationFunction<TOutput, TCollection, AggregationSession<TCollectionOrSession, TSession>>
+  fn[isAggregationFlag] = true
+  return fn as AggregationFunction<TOutput, TCollection, AggregationSession<TCollectionOrSession, TSession>>
+}
+
+/**
+ * Create a client aggregation for a specific collection.
+ *
+ * Prefer `aggregation(collection, fn)` in application code; this lower-level
+ * helper is exposed for internal integrations that need the explicit client marker.
+ *
+ * @typeParam TOutput Full value returned by aggregation subscriptions.
+ * @typeParam TCollectionOrSession Collection name when it is a string, otherwise session shape.
+ * @typeParam TSession Session shape when the second generic is used for collection name.
+ * @param collection Collection name this aggregation runs against.
+ * @param aggregationFn Aggregation callback. It receives `(params, context)`,
+ * where `params` are the subscription params and `context` has
+ * `{ collection, session, isServer }`. Return a Mongo aggregation pipeline array,
+ * or an aggregation query object such as `{ $aggregate: [...] }`.
+ */
+export function clientAggregation<
+  TOutput = unknown,
+  TCollectionOrSession = string,
+  TSession = DefaultAggregationSession,
+  TCollection extends string = AggregationCollection<TCollectionOrSession>
+> (
+  collection: TCollection,
+  aggregationFn?: AggregationCallback<TCollection, AggregationSession<TCollectionOrSession, TSession>>
+): ClientAggregationFunction<TOutput, TCollection, AggregationSession<TCollectionOrSession, TSession>> {
+  if (typeof collection !== 'string') throw Error('clientAggregation: collection must be a string')
+  if (typeof aggregationFn !== 'function') throw Error('clientAggregation: aggregationFn must be a function')
+  const fn = aggregationFn as MutableAggregationFunction<TOutput, TCollection, AggregationSession<TCollectionOrSession, TSession>>
+  fn[isAggregationFlag] = true
+  fn[isClientAggregationFlag] = true
+  fn.collection = collection
+  return fn as ClientAggregationFunction<TOutput, TCollection, AggregationSession<TCollectionOrSession, TSession>>
+}
+
+/**
+ * Create an aggregation header for client bundles.
+ *
+ * TeamPlay's Babel plugin usually generates this while eliminating server-only
+ * model code. Runtime code can subscribe to the header without bundling the
+ * server aggregation implementation.
+ *
+ * @typeParam TOutput Full value returned by aggregation subscriptions.
+ * @typeParam TCollectionOrSession Collection name when it is a string, otherwise session shape.
+ * @typeParam TSession Session shape when the second generic is used for collection name.
+ * @param aggregationMeta Collection and model-file aggregation name.
+ */
+export function aggregationHeader<
+  TOutput = unknown,
+  TCollectionOrSession = string,
+  TSession = DefaultAggregationSession
+> (
+  aggregationMeta: { collection: AggregationCollection<TCollectionOrSession>, name: string }
+): AggregationMeta<
+  AggregationCollection<TCollectionOrSession>,
+  TOutput,
+  AggregationSession<TCollectionOrSession, TSession>
+>
+export function aggregationHeader<
+  TOutput = unknown,
+  TCollectionOrSession = string,
+  TSession = DefaultAggregationSession
+> (
+  aggregationMeta: { collection: AggregationCollection<TCollectionOrSession>, name: string }
+): AggregationMeta<
+  AggregationCollection<TCollectionOrSession>,
+  TOutput,
+  AggregationSession<TCollectionOrSession, TSession>
+> {
+  if (!validateAggregationMeta(aggregationMeta)) {
+    throw Error(ERRORS.wrongAggregationMeta(aggregationMeta))
+  }
+  const meta = aggregationMeta as AggregationMeta<
+    AggregationCollection<TCollectionOrSession>,
+    TOutput,
+    AggregationSession<TCollectionOrSession, TSession>
+  >
+  ;(meta as { [isAggregationFlag]?: true })[isAggregationFlag] = true
+  return meta
+}
+
+function validateAggregationMeta (aggregationMeta: unknown): aggregationMeta is AggregationMeta {
+  if (
+    aggregationMeta &&
+    typeof aggregationMeta === 'object' &&
+    typeof (aggregationMeta as Partial<AggregationMeta>).collection === 'string' &&
+    typeof (aggregationMeta as Partial<AggregationMeta>).name === 'string'
+  ) return true
+  return false
+}
+
+const ERRORS = {
+  wrongAggregationMeta: (aggregationMeta: unknown) => `
+    aggregationHeader: invalid aggregationMeta
+      Expected: { collection: 'collectionName', name: 'aggregationName' }
+      Received: ${JSON.stringify(aggregationMeta)}
+  `
+}
diff --git a/packages/utils/package.json b/packages/utils/package.json
index 213a2c4..5776c44 100644
--- a/packages/utils/package.json
+++ b/packages/utils/package.json
@@ -5,8 +5,14 @@
   "description": "Isomorphic utils for internal cross-package usage",
   "main": "index.js",
   "exports": {
-    "./aggregation": "./aggregation.js",
-    "./accessControl": "./accessControl.js",
+    "./aggregation": {
+      "types": "./aggregation.ts",
+      "default": "./aggregation.ts"
+    },
+    "./accessControl": {
+      "types": "./accessControl.ts",
+      "default": "./accessControl.ts"
+    },
     "./uuid": "./uuid.cjs"
   },
   "dependencies": {
diff --git a/plan.md b/plan.md
new file mode 100644
index 0000000..1ea222a
--- /dev/null
+++ b/plan.md
@@ -0,0 +1,99 @@
+# TypeScript Signal Migration Plan
+
+## Current State
+
+- The default Signal implementation has been moved to TypeScript source and is distributed as `.ts` directly. Converted runtime imports use explicit `.ts` extensions so Node and Metro can load the source without a build step.
+- `packages/teamplay/orm/SignalBase.ts` contains the runtime class implementation and its directly maintained method typings. We removed the duplicate ambient `interface Signal` shape so method signatures are no longer maintained in two places.
+- `packages/teamplay/orm/Signal.ts` is now a small runtime facade that selects `Signal` or `SignalCompat` and re-exports the public type surface.
+- Compatibility mode remains JS-backed and intentionally unchanged except for import paths needed to coexist with the converted TS files.
+- Type-only logic has been split out of implementation files:
+  - `packages/teamplay/orm/types/signal.ts` defines the high-level signal graph: `TypedSignal`, `DocumentSignal`, `CollectionSignal`, `QuerySignal`, `AggregationSignal`, model binding, and collection specs.
+  - `packages/teamplay/orm/types/jsonSchema.ts` maps the supported JSON Schema subset into TypeScript values.
+  - `packages/teamplay/orm/types/query.ts` maps document schemas into typed Mongo-style query params.
+  - `packages/teamplay/orm/types/path.ts` contains reusable path tuple/string helpers.
+- Public root typing is registry-based. End projects augment `TeamplayCollections` and `TeamplayModels`, and `$`, `sub()`, `useSub()`, query signals, aggregation signals, local signals, and computed local signals derive from those registries.
+- Runtime model binding still uses `addModel(pattern, Model)`. Type binding is separate because TypeScript cannot infer global root signal types from runtime calls in unrelated modules.
+- Runtime collection schema validation still comes from backend `models[collection].schema`. `createBackend({ models, validateSchema: true })` wires this into ShareDB schema validation outside production.
+
+## Supported Developer UX
+
+The intended developer experience now works through module augmentation:
+
+```ts
+import { $, Signal, addModel, sub, type JsonSchemaSpec } from 'teamplay'
+
+const gameSchema = {
+  info: {
+    type: 'object',
+    required: true,
+    properties: {
+      title: { type: 'string', required: true },
+      maxPlayers: { type: 'integer', required: true }
+    }
+  },
+  status: { type: 'string', enum: ['draft', 'started'] as const }
+} as const
+
+class GamesModel extends Signal<Array<Game>> {
+  collectionLabel () {
+    return this.path()
+  }
+}
+
+class GameModel extends Signal<Game> {
+  start () {
+    return this.status.set('started')
+  }
+}
+
+type Game = import('teamplay').FromJsonSchema<typeof gameSchema>
+
+addModel('games', GamesModel)
+addModel('games.*', GameModel)
+
+declare module 'teamplay' {
+  interface TeamplayCollections {
+    games: JsonSchemaSpec<typeof gameSchema, typeof GamesModel, typeof GameModel>
+  }
+}
+
+$.games.collectionLabel()
+$.games[gameId].info.title.get()
+
+const $game = await sub($.games[gameId])
+await $game.start()
+```
+
+Expected VS Code behavior:
+
+- `$.games.` suggests collection model methods, standard Signal methods, and document id access.
+- `$.games[gameId].` suggests document model methods, standard Signal methods, and fields inferred from the collection schema.
+- `$.games[gameId].info.` suggests `title`, `maxPlayers`, and standard Signal methods.
+- `sub($.games[gameId])`, `useSub($.games[gameId])`, `sub($.games, query)`, and `useSub($.games, query)` preserve the same document schema and document model methods.
+- Query and aggregation results behave like typed arrays of document signals. Iteration, numeric indexes, `map`, `reduce`, and `find` expose document signals with schema fields and custom document model methods.
+- Local `$({ ... })` and computed `$(() => ...)` infer their value shape from the initial value or return value and expose nested child signals.
+
+## Schema Typing
+
+- JSON Schema typing is built in for the subset Teamplay uses most: object, array, tuple arrays, string, number/integer, boolean, null, enum, const, required arrays, field-level `required: true`, and the existing simplified `{ field: schema }` form.
+- Query params are schema-aware. Known document paths are suggested, nested paths such as `'info.maxPlayers'` are supported, and common operators such as `$in`, `$gte`, and `$regex` are value-type checked.
+- Zod typing is supported structurally through `ZodSchemaSpec` by reading `_output` or `_zod.output`, but runtime Zod-to-JSON-Schema conversion is not yet exposed as a first-class Teamplay helper.
+- If a project uses Zod today, it can use `ZodSchemaSpec` for editor typing and still provide JSON Schema to backend `models` for runtime validation.
+
+## Completed Work
+
+- Converted the default Signal path to TypeScript source without adding a compile step.
+- Replaced loose declaration files with implementation-backed types and focused type helper modules.
+- Added type tests for schema inference, custom collection/document/nested models, query params, query signals, aggregation signals, `sub()`, `useSub()`, local signals, computed signals, and array-like signal forwarding.
+- Fixed runtime regressions found during the TS migration in `sub()` and array-like forwarding, then added behavioral tests so those paths stay covered.
+- Added the type test command to the main test command and precommit flow.
+
+## Remaining Work
+
+- Generate a project-level `teamplay-env.d.ts` automatically in the future, similar to Expo Router, so end projects do not have to hand-write module augmentation.
+- Add a runtime schema helper if we want Zod to be a first-class schema source:
+  - accept a Zod schema for developer typing,
+  - convert it to JSON Schema for backend validation,
+  - register the generated JSON Schema in the backend `models` object.
+- Continue migrating non-Signal source files from JS to TS in small slices, keeping compatibility mode green.
+- Expand docs/API references as more of the type surface stabilizes.
diff --git a/rspress.config.ts b/rspress.config.ts
index c5b8612..2f078d9 100644
--- a/rspress.config.ts
+++ b/rspress.config.ts
@@ -33,9 +33,23 @@ export default defineConfig({
             { text: 'Usage', link: '/guide/usage' },
             { text: 'React Integration', link: '/guide/react-integration' },
             { text: 'Async Setters', link: '/guide/async-setters' },
+            { text: 'TypeScript Support', link: '/guide/typescript-support' },
+            { text: 'Usage in StartupJS', link: '/guide/usage-in-startupjs' },
             { text: 'Offline Mode', link: '/guide/offline-mode' }
           ]
         },
+        {
+          text: 'ORM',
+          items: [
+            { text: 'Overview', link: '/orm/index' },
+            { text: 'File-Based Models', link: '/orm/file-based-models' },
+            { text: 'Schemas', link: '/orm/schemas' },
+            { text: 'Models', link: '/orm/models' },
+            { text: 'Queries', link: '/orm/queries' },
+            { text: 'Aggregations', link: '/orm/aggregations' },
+            { text: 'Access Control', link: '/orm/access-control' }
+          ]
+        },
         {
           text: 'API',
           items: [
@@ -58,7 +72,7 @@ export default defineConfig({
       ]
     },
     nav: [
-      { text: 'Docs', link: '/guide/index', activeMatch: '/guide/.*' },
+      { text: 'Docs', link: '/guide/index', activeMatch: '/(guide|orm)/.*' },
       { text: 'API', link: '/api/root-signal', activeMatch: '/api/.*' }
     ]
   }
diff --git a/tasks.md b/tasks.md
new file mode 100644
index 0000000..60240ce
--- /dev/null
+++ b/tasks.md
@@ -0,0 +1,135 @@
+# TeamPlay Architecture Tasks
+
+This file is the active task list for [architecture.md](./architecture.md) and [typing-architecture.md](./typing-architecture.md). It is intentionally current-state focused, not a historical checklist. Completed work is summarized by area so the remaining tasks stay visible.
+
+## Execution Rules
+
+- Keep public runtime APIs stable unless there is an explicit product decision to change them.
+- Preserve the object-tree UX: `$`, `$.collection[id]`, `sub()`, `useSub()`, and `Signal<SchemaType>`.
+- Prefer checked runtime helpers over detached facade types.
+- Keep changes small, add focused tests before moving behavior, and verify frequently.
+- Do not invest in converting Compat implementation files to TypeScript; Compat is temporary. Touch Compat only when needed to preserve behavior or declarations.
+- Keep generated `teamplay-env.d.ts` refactors readable in editors and preserve useful field JSDoc.
+- Update this file, `architecture.md`, and `typing-architecture.md` when the direction changes.
+
+## Completed Summary
+
+- Public entry and subscription surfaces are checked: `index.ts`, `sub.ts`, and `useSub.ts`.
+- Shared subscription result helpers are in place for `sub()`, `useSub()`, and `useAsyncSub()`.
+- Runtime/public signal contracts are separated from the public `Signal<T>` facade.
+- Central signal kind types drive document, collection, query, aggregation, local array, and nested value shapes.
+- Collection/query/aggregation top-level mutators are blocked in public types where runtime rejects them.
+- Aggregation generics are output-first and support arbitrary explicit output shapes.
+- Query `ids` and `extra` metadata are modeled and documented.
+- Runtime descriptors, path rules, model-pattern rules, root aliases, and generated `require.context` helper parity are covered.
+- `defineSchema()` and schema-module default-interface augmentation support the `Signal<Game>` schema UX.
+- A shared schema fixture matrix covers runtime, type, Babel/JSDoc, and generated-env behavior.
+- Strict external consumer type tests validate package exports without `allowJs`.
+- Small non-Compat runtime modules have been converted to TypeScript where useful.
+- `idFields` is checked TypeScript.
+- `SignalBase.ts` delegates the following checked slices:
+  - symbols and getter names,
+  - path and alias rules,
+  - runtime segment/root/private-path access,
+  - mutation target guards,
+  - metadata methods,
+  - array readers,
+  - read dispatch,
+  - `set()` / `del()` value mutation routing,
+  - shared storage routing for array/string/increment mutators.
+- Standard `npm test` and the pre-commit hook run normal and compat suites.
+- Client tests use numeric filename ordering plus a path-order Jest sequencer instead of an explicit file list.
+
+## Active Tasks
+
+### 1. Manual Editor Display Pass
+
+This cannot be verified reliably through automated tests.
+
+- [ ] Check hover and completion quality for `Signal<T>` document props.
+- [ ] Check hover and completion quality for `Signal<T[]>` collection props.
+- [ ] Check `sub()` result display for documents, collections, queries, and aggregations.
+- [ ] Check `useSub()` result display for the same cases.
+- [ ] Check query `ids` and `extra` hovers.
+- [ ] Check generated schema default-interface hovers.
+- [ ] Record any display regressions before changing overloads or generated type shape.
+
+### 2. Proxy `apply` Boundary
+
+Do not extract proxy method binding until tests pin the tricky behavior.
+
+- [ ] Add focused tests for normal model method lookup through extremely late bindings.
+- [ ] Add focused tests for data-field/model-method name collisions.
+- [ ] Add focused tests for aggregation row method binding back to source documents.
+- [ ] Add focused tests for aggregation setter restrictions.
+- [ ] Add focused tests for non-Compat missing-method behavior.
+- [ ] Add focused tests for Compat fallback method lookup if touching shared proxy code.
+- [ ] After tests exist, consider moving small pieces of `extremelyLateBindings.apply()` into checked helpers.
+
+### 3. Generated Env Cleanup
+
+The generated file is correct enough, but it still owns more interpretation than ideal.
+
+- [ ] Inspect generated `teamplay-env.d.ts` for repeated policy that helper types could own.
+- [ ] Identify one safe reduction that does not hurt hover readability or field JSDoc.
+- [ ] Add/update generated-env snapshots for the change.
+- [ ] Run Babel plugin tests and TeamPlay type tests.
+- [ ] Keep schema-module augmentation behavior covered for relative imports, aliases, explicit extensions, and monorepo-style output paths.
+
+### 4. Query Metadata And Broad Index UX
+
+The object-tree API stays as `$.collection[id]`.
+
+- [ ] Re-check whether special-property typing can improve without adding `doc(id)` or weakening broad document indexing.
+- [ ] Keep `$query.ids` precise.
+- [ ] Keep `$query.extra` explicit.
+- [ ] Preserve query-as-`Signal<T[]>` assignability.
+- [ ] Add type tests for any new special-property behavior.
+- [ ] Keep runtime collision tests for document ids named `ids`, `extra`, and model method names.
+
+### 5. Remaining JavaScript Boundaries
+
+Prefer conversion for non-Compat modules when it removes useful declaration shims or tightens a shared rule.
+
+- [ ] Review remaining non-Compat `.d.ts` shims for broad `any`.
+- [ ] Convert small non-Compat `.js` modules to `.ts` only when the boundary is stable and tests are nearby.
+- [ ] Keep `Doc.d.ts`, `Query.d.ts`, and `Aggregation.d.ts` aligned with actual JS exports while those modules remain JavaScript.
+- [ ] Avoid Compat implementation conversion.
+
+### 6. User-Facing Docs
+
+Docs should reinforce the intended object-tree mental model.
+
+- [ ] Review remaining docs for stale alternatives to `$.collection[id]`.
+- [ ] Keep examples centered on `$`, `$.collection[id]`, `sub()`, `useSub()`, and `Signal<SchemaType>`.
+- [ ] Keep query metadata docs clear about `ids`, `extra`, and document-id collisions.
+- [ ] Keep TypeScript support docs clear about generated env setup, schema default interfaces, and known module-resolution requirements.
+
+## Verification Checklist
+
+Use the smallest useful verification while iterating, then broaden before committing runtime changes.
+
+- Type-only/public typing change:
+  - [ ] `npm run test-types` from `packages/teamplay`
+  - [ ] `npm run test-types:external` from `packages/teamplay`
+- Babel/generator change:
+  - [ ] `yarn workspace babel-plugin-teamplay test`
+  - [ ] `npm run test-types` from `packages/teamplay`
+- `SignalBase.ts` or runtime helper change:
+  - [ ] Focused server tests for the touched behavior
+  - [ ] `npm run test-types` from `packages/teamplay`
+  - [ ] `npm run test-types:external` from `packages/teamplay`
+  - [ ] `npm run lint`
+  - [ ] Full root `npm test` before commit
+- Client/runtime React change:
+  - [ ] Focused or full `npm run test-client` from `packages/teamplay`
+  - [ ] Compat client/server tests if behavior is shared
+
+## Parking Lot
+
+These are known but not active until there is a concrete product or maintenance reason:
+
+- Full `SignalBase.ts` conversion. Continue slices instead.
+- New document accessor APIs such as `$.users.doc(id)`. Do not add solely for TypeScript.
+- Full JSON Schema support. Keep the TeamPlay-supported subset explicit.
+- Compat implementation conversion. Compat is temporary.
diff --git a/typing-architecture.md b/typing-architecture.md
new file mode 100644
index 0000000..ec22e77
--- /dev/null
+++ b/typing-architecture.md
@@ -0,0 +1,320 @@
+# TeamPlay Typing Architecture
+
+This document describes the current TeamPlay typing architecture and the direction for keeping runtime behavior and TypeScript behavior aligned. Read [architecture.md](./architecture.md) first for the runtime and monorepo overview. This document intentionally avoids a chronological changelog; completed refactor history belongs in Git.
+
+## Goals
+
+TeamPlay uses proxies, file-system model conventions, runtime model registration, and generated module augmentation. Some static bridge code is unavoidable. The goal is to keep that bridge small, mechanical, and covered by tests.
+
+The desired end-user experience is:
+
+- `Signal<UserDoc>` exposes schema fields and document model methods.
+- `Signal<UserDoc[]>` exposes collection model methods and item document methods when `UserDoc` maps to one known collection.
+- `$` exposes generated collection paths from `TeamplayCollections`.
+- `$.collection[id]` remains the conventional document access API.
+- `sub()` and `useSub()` preserve document, collection, query, and aggregation signal shapes.
+- `teamplay-env.d.ts` can be generated from file-based models, schemas, access rules, and aggregations.
+
+The main implementation goal is to move runtime facts closer to checked runtime modules, then have generated declarations and public helper types reference those facts where TypeScript allows it.
+
+## Current Status
+
+The public typing surface is now mostly in the desired shape:
+
+- `packages/teamplay/index.ts`, `packages/teamplay/orm/sub.ts`, and `packages/teamplay/react/useSub.ts` are checked.
+- Public `Signal<T>` is a registry-based facade over runtime signals, model methods, schema fields, and generated path facts.
+- Runtime/public contracts are separated through names such as `RuntimeSignalInstance`, `SignalBaseInstance`, and `SignalModelConstructor`.
+- Collection, query, and aggregation signal types share central `SignalKind` / `SignalForKind` helpers.
+- Query `ids` and `extra` are explicit metadata signals while query results remain assignable to `Signal<T[]>`.
+- Aggregation typing is output-first and supports both document-row-like results and arbitrary explicit output shapes.
+- Schema support has a shared fixture matrix across runtime schema tests, type tests, Babel/JSDoc tests, and generated-env tests.
+- Strict external consumer tests validate the package surface without `allowJs`.
+
+The main remaining implementation boundary is `SignalBase.ts`. It is still `@ts-nocheck`, but much of its behavior has been carved into checked helpers:
+
+- `signalSymbols.ts`: shared signal symbols and default getter names.
+- `signalPathRules.ts`: root alias and numeric property-key normalization, plus runtime path joining.
+- `signalRuntimeAccess.ts`: segment access, owning root id lookup, private path detection, and mutation target checks.
+- `signalMutationGuards.ts`: value/array mutation target validation.
+- `signalMetadata.ts`: `path()`, `leaf()`, `parent()`, `getId()`, `getCollection()`, and `getAssociations()` behavior.
+- `signalArrayReaders.ts`: query-id and array-index child-signal selection for iteration, `map`, `reduce`, and `find`.
+- `signalReads.ts`: `get()`, `peek()`, `[GET]`, and `getIds()` storage-routing behavior.
+- `signalValueMutations.ts`: `set()` and `del()` routing.
+- `signalStorageMutations.ts`: shared public/private/id-field/publicOnly routing for array mutators, string mutators, and `increment()`.
+- `idFields.ts`: checked id-field, public document path, add payload, and id normalization rules.
+
+This is the right direction for maintainability: public UX remains stable, while high-risk runtime decisions become smaller, named, and independently testable.
+
+## Runtime Architecture
+
+### Signal Construction
+
+Runtime signal creation flows through:
+
+- `packages/teamplay/orm/getSignal.ts`
+- `packages/teamplay/orm/SignalBase.ts`
+- `packages/teamplay/orm/addModel.ts`
+
+`getSignal($root, segments, options)` chooses the runtime class with `getSignalClass(segments)`. `getSignalClass()` calls `findModel(segments)`, which matches patterns registered by `addModel(pattern, Model)`.
+
+Runtime model pattern rules:
+
+- `users` matches a collection signal.
+- `users.*` matches a document signal.
+- `users.*.profile` matches a nested document field signal.
+- `[id]` in file-based model names is normalized to `*`.
+- Matching is length-sensitive and each wildcard matches one segment.
+
+After the class is chosen, the instance is wrapped in a `Proxy`. The proxy is what enables object-tree access:
+
+```ts
+$.users[userId].profile.name.get()
+```
+
+There is no real `name` property on the base class. The proxy creates child signals on demand.
+
+### Method Lookup
+
+With extremely late bindings enabled, dot access creates a child signal even when the segment name collides with a method. A call like `$user.displayName()` works like this:
+
+1. The proxy `get` trap returns a child signal at `users.<id>.displayName`.
+2. The proxy `apply` trap sees the last segment is `displayName`.
+3. It looks up `displayName` on the raw parent signal at `users.<id>`.
+4. It calls that method with `this` bound to the parent signal.
+
+Aggregation row method binding is more complex: if a row under `$aggregations.<hash>.<index>` has `_id` or `id`, method calls can be routed back to the original source document. This behavior still lives in `extremelyLateBindings.apply()` and needs focused tests before extraction.
+
+### Query Signals
+
+`getQuerySignal(collectionName, params, options)` creates a signal at:
+
+```ts
+[collectionName]
+```
+
+and marks it with query symbols such as `IS_QUERY`, `COLLECTION_NAME`, and `HASH`.
+
+Query data is stored separately under `$queries.<hash>`. Array readers map query ids back to document signals:
+
+```ts
+for (const id of ids) yield getSignal(root, [collectionName, id])
+```
+
+Runtime consequences:
+
+- The top-level query signal behaves like the collection model.
+- Query items behave like document model signals.
+- Query array readers pass document model signals.
+- Query top-level array mutators are rejected.
+- Query `ids` and `extra` are special metadata properties.
+
+### Aggregation Signals
+
+`getAggregationSignal(collectionName, params, options)` creates a signal at:
+
+```ts
+['$aggregations', hash]
+```
+
+Aggregation rows can redirect method calls to source documents when the row has `_id` or `id`. TypeScript treats registered collection aggregations as document-row-like by default, while `aggregation<TOutput>()` allows arbitrary explicit output.
+
+### File-Based Models
+
+The Babel plugin and Node loader discover model folders and produce a model manifest shaped like:
+
+```ts
+{
+  users: {
+    default: Users,
+    schema,
+    access,
+    _active
+  },
+  'users.*': {
+    default: User
+  }
+}
+```
+
+`initModels(models)` registers every `default` class with `addModel()` and stores the full manifest for backend features.
+
+Shared model-pattern utilities now cover:
+
+- `[id] -> *`
+- `index` files mapping to the containing path
+- ignored `-` files
+- invalid wildcard filenames
+- schema/access/aggregation grouping
+- collection-pattern checks
+- generated `require.context` helper parity
+
+## Type Architecture
+
+### Module Augmentation
+
+`packages/teamplay/index.ts` exposes three augmentation interfaces:
+
+```ts
+export interface TeamplayCollections {}
+export interface TeamplayModels {}
+export interface TeamplaySignalFields {}
+```
+
+Generated or manual augmentation fills these interfaces:
+
+```ts
+declare module 'teamplay' {
+  interface TeamplayCollections {
+    users: JsonSchemaSpec<typeof schema, typeof Users, typeof User>
+  }
+
+  interface TeamplayModels {
+    'users.*.profile': typeof UserProfile
+  }
+
+  interface TeamplaySignalFields {
+    'users.*': UsersFields
+  }
+}
+```
+
+This static bridge is necessary because TypeScript cannot infer global root paths from runtime calls like `addModel('users.*', User)`.
+
+### Public `Signal<T>`
+
+The exported `Signal<T>` type is intentionally a UX facade, not just the runtime base-class instance:
+
+1. `Signal<any>` returns a loose typed signal.
+2. `Signal<T>` returns a registered document signal when `T` maps to exactly one known collection document type.
+3. `Signal<T[]>` returns a collection-shaped signal when `T` maps to exactly one known collection document type.
+4. Ambiguous duplicate document shapes fall back to the plain typed signal shape.
+
+This preserves the target usage:
+
+```ts
+class User extends Signal<UserDoc> {}
+
+function UserCard ({ $user }: { $user: Signal<UserDoc> }) {
+  $user.displayName()
+}
+```
+
+### Core Signal Types
+
+`packages/teamplay/orm/types/signal.ts` defines the core signal graph:
+
+- `TypedSignal<TValue, TModel, TPath>`
+- `DocumentSignal`
+- `CollectionSignal`
+- `CollectionQuerySignal`
+- `AggregationSignal`
+- `SignalForKind`
+- `RootSignal`
+
+`TypedSignal` intersects:
+
+- the base signal instance,
+- the selected model instance,
+- array reader/mutator groups when valid,
+- object child signals,
+- generated field mixins from `TeamplaySignalFields`.
+
+`PathModel<TValue, TDefaultModel, TPath>` joins runtime-like path tuples with `JoinPath<TPath>` and looks up `TeamplayModels`.
+
+### Collections, Queries, And Aggregations
+
+`CollectionSignal` models:
+
+- collection model methods,
+- document indexing by id or number,
+- `add(value): Promise<string>`,
+- array readers that pass document model signals,
+- blocked top-level array mutators.
+
+`CollectionQuerySignal` adds query metadata and preserves collection model methods. It matches runtime query construction at `[collectionName]`.
+
+`AggregationSignal` is array-like. Registered collection aggregations default to document-row-like output; arbitrary output should use explicit output generics.
+
+### Schema Types
+
+`FromJsonSchema<TSchema>` covers the TeamPlay-supported JSON Schema subset:
+
+- simplified object schemas,
+- full object schemas with `properties`,
+- field-level `required: true`,
+- object-level `required: [...]`,
+- arrays and tuple arrays,
+- primitive JSON Schema types,
+- nullable type arrays,
+- `enum`,
+- `const`.
+
+Unsupported dynamic schema expressions intentionally degrade to safer fallback shapes. The shared schema fixture matrix is the source of truth for what is supported.
+
+### Generated `teamplay-env.d.ts`
+
+The Babel plugin generates:
+
+- `TeamplayCollections`
+- `TeamplayModels`
+- `TeamplaySignalFields`
+- schema-module default-interface augmentation for the `Signal<Game>` UX
+
+The generated file still contains more concrete policy than ideal. Future work should continue moving interpretation into helper types as long as hover readability and field JSDoc quality do not regress.
+
+## Intentional TypeScript Limitations
+
+### Broad Collection Indexing
+
+The object-tree API depends on broad document indexing:
+
+```ts
+$.users[userId]
+```
+
+That means TypeScript cannot perfectly distinguish every possible document id from every named collection property, query metadata property, or model method. The current decision is:
+
+- keep `$.collection[id]`,
+- keep named query metadata like `ids` and `extra` precise,
+- cover collisions at runtime,
+- document the limitation,
+- do not add `$.users.doc(id)` solely for TypeScript convenience.
+
+### Proxy Behavior Cannot Be Fully Inferred
+
+Proxy child access and extremely late method binding must remain manually modeled with mapped types and runtime tests. The type system cannot derive this behavior from the JavaScript proxy implementation.
+
+### Some Runtime/Type Duplication Is Unavoidable
+
+Type-level schema inference, AST-based Babel parsing, runtime schema normalization, generated module augmentation, and proxy runtime behavior are different execution domains. The practical target is shared fixtures, shared naming, and small checked helpers, not one universal implementation.
+
+## Risk Areas
+
+| Area | Current risk | Direction |
+| --- | --- | --- |
+| `SignalBase.ts` proxy `apply` | High | Add tests for aggregation row method binding, model-method collisions, and Compat fallback before extraction. |
+| Generated `teamplay-env.d.ts` policy | Medium | Move interpretation into helper types where editor display stays readable. |
+| Query metadata vs document ids | Medium | Keep special properties precise and preserve object-tree access; investigate only type improvements that do not change UX. |
+| Remaining `.d.ts` shims | Medium | Narrow declarations or convert non-Compat modules to `.ts` when useful. Avoid investing in Compat conversion because Compat is temporary. |
+| Subscription overloads | Medium | Keep shared result helpers authoritative; retain direct overloads where editor display benefits. |
+| Schema parity | Medium | Maintain the shared fixture matrix across runtime, type, Babel/JSDoc, and generated-env tests. |
+
+## Verification Strategy
+
+For every typing/runtime alignment change:
+
+- add focused runtime tests for the touched behavior,
+- add or update type tests when public TypeScript behavior changes,
+- run `npm run test-types` and `npm run test-types:external`,
+- run focused server/client tests for the touched path,
+- run full `npm test` before commits that affect runtime behavior.
+
+Standard `npm test` now runs:
+
+1. Babel plugin tests,
+2. TeamPlay internal type tests,
+3. strict external consumer type tests,
+4. normal server tests,
+5. normal client tests,
+6. compat server tests,
+7. compat client tests.
diff --git a/yarn.lock b/yarn.lock
index 5a78cfe..34786a4 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -15,7 +15,20 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/code-frame@npm:^7.0.0, @babel/code-frame@npm:^7.10.4, @babel/code-frame@npm:^7.12.13, @babel/code-frame@npm:^7.23.5, @babel/code-frame@npm:^7.24.2":
+"@asamuzakjp/css-color@npm:^3.2.0":
+  version: 3.2.0
+  resolution: "@asamuzakjp/css-color@npm:3.2.0"
+  dependencies:
+    "@csstools/css-calc": "npm:^2.1.3"
+    "@csstools/css-color-parser": "npm:^3.0.9"
+    "@csstools/css-parser-algorithms": "npm:^3.0.4"
+    "@csstools/css-tokenizer": "npm:^3.0.3"
+    lru-cache: "npm:^10.4.3"
+  checksum: 10c0/a4bf1c831751b1fae46b437e37e8a38c0b5bd58d23230157ae210bd1e905fe509b89b7c243e63d1522d852668a6292ed730a160e21342772b4e5b7b8ea14c092
+  languageName: node
+  linkType: hard
+
+"@babel/code-frame@npm:^7.0.0, @babel/code-frame@npm:^7.10.4, @babel/code-frame@npm:^7.23.5, @babel/code-frame@npm:^7.24.2":
   version: 7.24.2
   resolution: "@babel/code-frame@npm:7.24.2"
   dependencies:
@@ -25,6 +38,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/code-frame@npm:^7.27.1, @babel/code-frame@npm:^7.28.6, @babel/code-frame@npm:^7.29.0":
+  version: 7.29.0
+  resolution: "@babel/code-frame@npm:7.29.0"
+  dependencies:
+    "@babel/helper-validator-identifier": "npm:^7.28.5"
+    js-tokens: "npm:^4.0.0"
+    picocolors: "npm:^1.1.1"
+  checksum: 10c0/d34cc504e7765dfb576a663d97067afb614525806b5cad1a5cc1a7183b916fec8ff57fa233585e3926fd5a9e6b31aae6df91aa81ae9775fb7a28f658d3346f0d
+  languageName: node
+  linkType: hard
+
 "@babel/compat-data@npm:^7.23.5":
   version: 7.24.4
   resolution: "@babel/compat-data@npm:7.24.4"
@@ -32,7 +56,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/core@npm:^7.11.6, @babel/core@npm:^7.12.3, @babel/core@npm:^7.23.9":
+"@babel/compat-data@npm:^7.28.6":
+  version: 7.29.0
+  resolution: "@babel/compat-data@npm:7.29.0"
+  checksum: 10c0/08f348554989d23aa801bf1405aa34b15e841c0d52d79da7e524285c77a5f9d298e70e11d91cc578d8e2c9542efc586d50c5f5cf8e1915b254a9dcf786913a94
+  languageName: node
+  linkType: hard
+
+"@babel/core@npm:^7.23.9":
   version: 7.24.5
   resolution: "@babel/core@npm:7.24.5"
   dependencies:
@@ -55,7 +86,30 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/generator@npm:^7.24.5, @babel/generator@npm:^7.7.2":
+"@babel/core@npm:^7.24.4, @babel/core@npm:^7.27.4, @babel/core@npm:^7.9.0":
+  version: 7.29.0
+  resolution: "@babel/core@npm:7.29.0"
+  dependencies:
+    "@babel/code-frame": "npm:^7.29.0"
+    "@babel/generator": "npm:^7.29.0"
+    "@babel/helper-compilation-targets": "npm:^7.28.6"
+    "@babel/helper-module-transforms": "npm:^7.28.6"
+    "@babel/helpers": "npm:^7.28.6"
+    "@babel/parser": "npm:^7.29.0"
+    "@babel/template": "npm:^7.28.6"
+    "@babel/traverse": "npm:^7.29.0"
+    "@babel/types": "npm:^7.29.0"
+    "@jridgewell/remapping": "npm:^2.3.5"
+    convert-source-map: "npm:^2.0.0"
+    debug: "npm:^4.1.0"
+    gensync: "npm:^1.0.0-beta.2"
+    json5: "npm:^2.2.3"
+    semver: "npm:^6.3.1"
+  checksum: 10c0/5127d2e8e842ae409e11bcbb5c2dff9874abf5415e8026925af7308e903f4f43397341467a130490d1a39884f461bc2b67f3063bce0be44340db89687fd852aa
+  languageName: node
+  linkType: hard
+
+"@babel/generator@npm:^7.24.5":
   version: 7.24.5
   resolution: "@babel/generator@npm:7.24.5"
   dependencies:
@@ -67,6 +121,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/generator@npm:^7.27.5, @babel/generator@npm:^7.29.0":
+  version: 7.29.1
+  resolution: "@babel/generator@npm:7.29.1"
+  dependencies:
+    "@babel/parser": "npm:^7.29.0"
+    "@babel/types": "npm:^7.29.0"
+    "@jridgewell/gen-mapping": "npm:^0.3.12"
+    "@jridgewell/trace-mapping": "npm:^0.3.28"
+    jsesc: "npm:^3.0.2"
+  checksum: 10c0/349086e6876258ef3fb2823030fee0f6c0eb9c3ebe35fc572e16997f8c030d765f636ddc6299edae63e760ea6658f8ee9a2edfa6d6b24c9a80c917916b973551
+  languageName: node
+  linkType: hard
+
 "@babel/helper-compilation-targets@npm:^7.23.6":
   version: 7.23.6
   resolution: "@babel/helper-compilation-targets@npm:7.23.6"
@@ -80,6 +147,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-compilation-targets@npm:^7.28.6":
+  version: 7.28.6
+  resolution: "@babel/helper-compilation-targets@npm:7.28.6"
+  dependencies:
+    "@babel/compat-data": "npm:^7.28.6"
+    "@babel/helper-validator-option": "npm:^7.27.1"
+    browserslist: "npm:^4.24.0"
+    lru-cache: "npm:^5.1.1"
+    semver: "npm:^6.3.1"
+  checksum: 10c0/3fcdf3b1b857a1578e99d20508859dbd3f22f3c87b8a0f3dc540627b4be539bae7f6e61e49d931542fe5b557545347272bbdacd7f58a5c77025a18b745593a50
+  languageName: node
+  linkType: hard
+
 "@babel/helper-environment-visitor@npm:^7.22.20":
   version: 7.22.20
   resolution: "@babel/helper-environment-visitor@npm:7.22.20"
@@ -97,6 +177,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-globals@npm:^7.28.0":
+  version: 7.28.0
+  resolution: "@babel/helper-globals@npm:7.28.0"
+  checksum: 10c0/5a0cd0c0e8c764b5f27f2095e4243e8af6fa145daea2b41b53c0c1414fe6ff139e3640f4e2207ae2b3d2153a1abd346f901c26c290ee7cb3881dd922d4ee9232
+  languageName: node
+  linkType: hard
+
 "@babel/helper-hoist-variables@npm:^7.22.5":
   version: 7.22.5
   resolution: "@babel/helper-hoist-variables@npm:7.22.5"
@@ -106,6 +193,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-module-imports@npm:^7.0.0, @babel/helper-module-imports@npm:^7.28.6":
+  version: 7.28.6
+  resolution: "@babel/helper-module-imports@npm:7.28.6"
+  dependencies:
+    "@babel/traverse": "npm:^7.28.6"
+    "@babel/types": "npm:^7.28.6"
+  checksum: 10c0/b49d8d8f204d9dbfd5ac70c54e533e5269afb3cea966a9d976722b13e9922cc773a653405f53c89acb247d5aebdae4681d631a3ae3df77ec046b58da76eda2ac
+  languageName: node
+  linkType: hard
+
 "@babel/helper-module-imports@npm:^7.24.3":
   version: 7.24.3
   resolution: "@babel/helper-module-imports@npm:7.24.3"
@@ -130,13 +227,33 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/helper-plugin-utils@npm:^7.0.0, @babel/helper-plugin-utils@npm:^7.10.4, @babel/helper-plugin-utils@npm:^7.12.13, @babel/helper-plugin-utils@npm:^7.14.5, @babel/helper-plugin-utils@npm:^7.24.0, @babel/helper-plugin-utils@npm:^7.8.0":
+"@babel/helper-module-transforms@npm:^7.28.6":
+  version: 7.28.6
+  resolution: "@babel/helper-module-transforms@npm:7.28.6"
+  dependencies:
+    "@babel/helper-module-imports": "npm:^7.28.6"
+    "@babel/helper-validator-identifier": "npm:^7.28.5"
+    "@babel/traverse": "npm:^7.28.6"
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 10c0/6f03e14fc30b287ce0b839474b5f271e72837d0cafe6b172d759184d998fbee3903a035e81e07c2c596449e504f453463d58baa65b6f40a37ded5bec74620b2b
+  languageName: node
+  linkType: hard
+
+"@babel/helper-plugin-utils@npm:^7.0.0, @babel/helper-plugin-utils@npm:^7.10.4, @babel/helper-plugin-utils@npm:^7.12.13, @babel/helper-plugin-utils@npm:^7.14.5, @babel/helper-plugin-utils@npm:^7.8.0":
   version: 7.24.5
   resolution: "@babel/helper-plugin-utils@npm:7.24.5"
   checksum: 10c0/4ae40094e6a2f183281213344f4df60c66b16b19a2bc38d2bb11810a6dc0a0e7ec638957d0e433ff8b615775b8f3cd1b7edbf59440d1b50e73c389fc22913377
   languageName: node
   linkType: hard
 
+"@babel/helper-plugin-utils@npm:^7.28.6":
+  version: 7.28.6
+  resolution: "@babel/helper-plugin-utils@npm:7.28.6"
+  checksum: 10c0/3f5f8acc152fdbb69a84b8624145ff4f9b9f6e776cb989f9f968f8606eb7185c5c3cfcf3ba08534e37e1e0e1c118ac67080610333f56baa4f7376c99b5f1143d
+  languageName: node
+  linkType: hard
+
 "@babel/helper-simple-access@npm:^7.24.5":
   version: 7.24.5
   resolution: "@babel/helper-simple-access@npm:7.24.5"
@@ -162,6 +279,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-string-parser@npm:^7.27.1":
+  version: 7.27.1
+  resolution: "@babel/helper-string-parser@npm:7.27.1"
+  checksum: 10c0/8bda3448e07b5583727c103560bcf9c4c24b3c1051a4c516d4050ef69df37bb9a4734a585fe12725b8c2763de0a265aa1e909b485a4e3270b7cfd3e4dbe4b602
+  languageName: node
+  linkType: hard
+
 "@babel/helper-validator-identifier@npm:^7.24.5":
   version: 7.24.5
   resolution: "@babel/helper-validator-identifier@npm:7.24.5"
@@ -169,6 +293,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-validator-identifier@npm:^7.28.5":
+  version: 7.28.5
+  resolution: "@babel/helper-validator-identifier@npm:7.28.5"
+  checksum: 10c0/42aaebed91f739a41f3d80b72752d1f95fd7c72394e8e4bd7cdd88817e0774d80a432451bcba17c2c642c257c483bf1d409dd4548883429ea9493a3bc4ab0847
+  languageName: node
+  linkType: hard
+
 "@babel/helper-validator-option@npm:^7.23.5":
   version: 7.23.5
   resolution: "@babel/helper-validator-option@npm:7.23.5"
@@ -176,6 +307,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-validator-option@npm:^7.27.1":
+  version: 7.27.1
+  resolution: "@babel/helper-validator-option@npm:7.27.1"
+  checksum: 10c0/6fec5f006eba40001a20f26b1ef5dbbda377b7b68c8ad518c05baa9af3f396e780bdfded24c4eef95d14bb7b8fd56192a6ed38d5d439b97d10efc5f1a191d148
+  languageName: node
+  linkType: hard
+
 "@babel/helpers@npm:^7.24.5":
   version: 7.24.5
   resolution: "@babel/helpers@npm:7.24.5"
@@ -187,6 +325,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helpers@npm:^7.28.6":
+  version: 7.29.2
+  resolution: "@babel/helpers@npm:7.29.2"
+  dependencies:
+    "@babel/template": "npm:^7.28.6"
+    "@babel/types": "npm:^7.29.0"
+  checksum: 10c0/dab0e65b9318b2502a62c58bc0913572318595eec0482c31f0ad416b72636e6698a1d7c57cd2791d4528eb8c548bca88d338dc4d2a55a108dc1f6702f9bc5512
+  languageName: node
+  linkType: hard
+
 "@babel/highlight@npm:^7.24.2":
   version: 7.24.5
   resolution: "@babel/highlight@npm:7.24.5"
@@ -199,7 +347,18 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/parser@npm:^7.1.0, @babel/parser@npm:^7.14.7, @babel/parser@npm:^7.20.7, @babel/parser@npm:^7.23.9, @babel/parser@npm:^7.24.0, @babel/parser@npm:^7.24.5, @babel/parser@npm:^7.3.2, @babel/parser@npm:^7.4.5":
+"@babel/parser@npm:^7.0.0, @babel/parser@npm:^7.24.4, @babel/parser@npm:^7.28.6, @babel/parser@npm:^7.29.0":
+  version: 7.29.2
+  resolution: "@babel/parser@npm:7.29.2"
+  dependencies:
+    "@babel/types": "npm:^7.29.0"
+  bin:
+    parser: ./bin/babel-parser.js
+  checksum: 10c0/e5a4e69e3ac7acdde995f37cf299a68458cfe7009dff66bd0962fd04920bef287201169006af365af479c08ff216bfefbb595e331f87f6ae7283858aebbc3317
+  languageName: node
+  linkType: hard
+
+"@babel/parser@npm:^7.1.0, @babel/parser@npm:^7.20.7, @babel/parser@npm:^7.23.9, @babel/parser@npm:^7.24.0, @babel/parser@npm:^7.24.5":
   version: 7.24.5
   resolution: "@babel/parser@npm:7.24.5"
   bin:
@@ -230,7 +389,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-syntax-class-properties@npm:^7.8.3":
+"@babel/plugin-syntax-class-properties@npm:^7.12.13":
   version: 7.12.13
   resolution: "@babel/plugin-syntax-class-properties@npm:7.12.13"
   dependencies:
@@ -241,7 +400,29 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-syntax-import-meta@npm:^7.8.3":
+"@babel/plugin-syntax-class-static-block@npm:^7.14.5":
+  version: 7.14.5
+  resolution: "@babel/plugin-syntax-class-static-block@npm:7.14.5"
+  dependencies:
+    "@babel/helper-plugin-utils": "npm:^7.14.5"
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 10c0/4464bf9115f4a2d02ce1454411baf9cfb665af1da53709c5c56953e5e2913745b0fcce82982a00463d6facbdd93445c691024e310b91431a1e2f024b158f6371
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-import-attributes@npm:^7.24.7":
+  version: 7.28.6
+  resolution: "@babel/plugin-syntax-import-attributes@npm:7.28.6"
+  dependencies:
+    "@babel/helper-plugin-utils": "npm:^7.28.6"
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 10c0/1be160e2c426faa74e5be2e30e39e8d0d8c543063bd5d06cd804f8751b8fbcb82ce824ca7f9ce4b09c003693f6c06a11ce503b7e34d85e1a259631e4c3f72ad2
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-import-meta@npm:^7.10.4":
   version: 7.10.4
   resolution: "@babel/plugin-syntax-import-meta@npm:7.10.4"
   dependencies:
@@ -263,18 +444,18 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-syntax-jsx@npm:^7.7.2":
-  version: 7.24.1
-  resolution: "@babel/plugin-syntax-jsx@npm:7.24.1"
+"@babel/plugin-syntax-jsx@npm:^7.27.1":
+  version: 7.28.6
+  resolution: "@babel/plugin-syntax-jsx@npm:7.28.6"
   dependencies:
-    "@babel/helper-plugin-utils": "npm:^7.24.0"
+    "@babel/helper-plugin-utils": "npm:^7.28.6"
   peerDependencies:
     "@babel/core": ^7.0.0-0
-  checksum: 10c0/6cec76fbfe6ca81c9345c2904d8d9a8a0df222f9269f0962ed6eb2eb8f3f10c2f15e993d1ef09dbaf97726bf1792b5851cf5bd9a769f966a19448df6be95d19a
+  checksum: 10c0/b98fc3cd75e4ca3d5ca1162f610c286e14ede1486e0d297c13a5eb0ac85680ac9656d17d348bddd9160a54d797a08cea5eaac02b9330ddebb7b26732b7b99fb5
   languageName: node
   linkType: hard
 
-"@babel/plugin-syntax-logical-assignment-operators@npm:^7.8.3":
+"@babel/plugin-syntax-logical-assignment-operators@npm:^7.10.4":
   version: 7.10.4
   resolution: "@babel/plugin-syntax-logical-assignment-operators@npm:7.10.4"
   dependencies:
@@ -296,7 +477,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-syntax-numeric-separator@npm:^7.8.3":
+"@babel/plugin-syntax-numeric-separator@npm:^7.10.4":
   version: 7.10.4
   resolution: "@babel/plugin-syntax-numeric-separator@npm:7.10.4"
   dependencies:
@@ -340,7 +521,18 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-syntax-top-level-await@npm:^7.8.3":
+"@babel/plugin-syntax-private-property-in-object@npm:^7.14.5":
+  version: 7.14.5
+  resolution: "@babel/plugin-syntax-private-property-in-object@npm:7.14.5"
+  dependencies:
+    "@babel/helper-plugin-utils": "npm:^7.14.5"
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 10c0/69822772561706c87f0a65bc92d0772cea74d6bc0911537904a676d5ff496a6d3ac4e05a166d8125fce4a16605bace141afc3611074e170a994e66e5397787f3
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-top-level-await@npm:^7.14.5":
   version: 7.14.5
   resolution: "@babel/plugin-syntax-top-level-await@npm:7.14.5"
   dependencies:
@@ -351,14 +543,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-syntax-typescript@npm:^7.7.2":
-  version: 7.24.1
-  resolution: "@babel/plugin-syntax-typescript@npm:7.24.1"
+"@babel/plugin-syntax-typescript@npm:^7.27.1":
+  version: 7.28.6
+  resolution: "@babel/plugin-syntax-typescript@npm:7.28.6"
   dependencies:
-    "@babel/helper-plugin-utils": "npm:^7.24.0"
+    "@babel/helper-plugin-utils": "npm:^7.28.6"
   peerDependencies:
     "@babel/core": ^7.0.0-0
-  checksum: 10c0/7a81e277dcfe3138847e8e5944e02a42ff3c2e864aea6f33fd9b70d1556d12b0e70f0d56cc1985d353c91bcbf8fe163e6cc17418da21129b7f7f1d8b9ac00c93
+  checksum: 10c0/b0c392a35624883ac480277401ac7d92d8646b66e33639f5d350de7a6723924265985ae11ab9ebd551740ded261c443eaa9a87ea19def9763ca1e0d78c97dea8
   languageName: node
   linkType: hard
 
@@ -371,7 +563,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/template@npm:^7.22.15, @babel/template@npm:^7.24.0, @babel/template@npm:^7.3.3":
+"@babel/template@npm:^7.22.15, @babel/template@npm:^7.24.0":
   version: 7.24.0
   resolution: "@babel/template@npm:7.24.0"
   dependencies:
@@ -382,7 +574,33 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/traverse@npm:^7.2.3, @babel/traverse@npm:^7.24.5, @babel/traverse@npm:^7.4.5":
+"@babel/template@npm:^7.28.6":
+  version: 7.28.6
+  resolution: "@babel/template@npm:7.28.6"
+  dependencies:
+    "@babel/code-frame": "npm:^7.28.6"
+    "@babel/parser": "npm:^7.28.6"
+    "@babel/types": "npm:^7.28.6"
+  checksum: 10c0/66d87225ed0bc77f888181ae2d97845021838c619944877f7c4398c6748bcf611f216dfd6be74d39016af502bca876e6ce6873db3c49e4ac354c56d34d57e9f5
+  languageName: node
+  linkType: hard
+
+"@babel/traverse@npm:^7.0.0, @babel/traverse@npm:^7.28.6, @babel/traverse@npm:^7.29.0":
+  version: 7.29.0
+  resolution: "@babel/traverse@npm:7.29.0"
+  dependencies:
+    "@babel/code-frame": "npm:^7.29.0"
+    "@babel/generator": "npm:^7.29.0"
+    "@babel/helper-globals": "npm:^7.28.0"
+    "@babel/parser": "npm:^7.29.0"
+    "@babel/template": "npm:^7.28.6"
+    "@babel/types": "npm:^7.29.0"
+    debug: "npm:^4.3.1"
+  checksum: 10c0/f63ef6e58d02a9fbf3c0e2e5f1c877da3e0bc57f91a19d2223d53e356a76859cbaf51171c9211c71816d94a0e69efa2732fd27ffc0e1bbc84b636e60932333eb
+  languageName: node
+  linkType: hard
+
+"@babel/traverse@npm:^7.24.5":
   version: 7.24.5
   resolution: "@babel/traverse@npm:7.24.5"
   dependencies:
@@ -400,7 +618,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/types@npm:^7.0.0, @babel/types@npm:^7.20.7, @babel/types@npm:^7.22.5, @babel/types@npm:^7.23.0, @babel/types@npm:^7.24.0, @babel/types@npm:^7.24.5, @babel/types@npm:^7.3.3, @babel/types@npm:^7.8.3":
+"@babel/types@npm:^7.0.0, @babel/types@npm:^7.20.7, @babel/types@npm:^7.22.5, @babel/types@npm:^7.23.0, @babel/types@npm:^7.24.0, @babel/types@npm:^7.24.5, @babel/types@npm:^7.8.3":
   version: 7.24.5
   resolution: "@babel/types@npm:7.24.5"
   dependencies:
@@ -411,6 +629,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/types@npm:^7.27.3, @babel/types@npm:^7.28.6, @babel/types@npm:^7.29.0":
+  version: 7.29.0
+  resolution: "@babel/types@npm:7.29.0"
+  dependencies:
+    "@babel/helper-string-parser": "npm:^7.27.1"
+    "@babel/helper-validator-identifier": "npm:^7.28.5"
+  checksum: 10c0/23cc3466e83bcbfab8b9bd0edaafdb5d4efdb88b82b3be6728bbade5ba2f0996f84f63b1c5f7a8c0d67efded28300898a5f930b171bb40b311bca2029c4e9b4f
+  languageName: node
+  linkType: hard
+
 "@bcoe/v8-coverage@npm:^0.2.3":
   version: 0.2.3
   resolution: "@bcoe/v8-coverage@npm:0.2.3"
@@ -434,6 +662,62 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@csstools/color-helpers@npm:^5.1.0":
+  version: 5.1.0
+  resolution: "@csstools/color-helpers@npm:5.1.0"
+  checksum: 10c0/b7f99d2e455cf1c9b41a67a5327d5d02888cd5c8802a68b1887dffef537d9d4bc66b3c10c1e62b40bbed638b6c1d60b85a232f904ed7b39809c4029cb36567db
+  languageName: node
+  linkType: hard
+
+"@csstools/css-calc@npm:^2.1.3, @csstools/css-calc@npm:^2.1.4":
+  version: 2.1.4
+  resolution: "@csstools/css-calc@npm:2.1.4"
+  peerDependencies:
+    "@csstools/css-parser-algorithms": ^3.0.5
+    "@csstools/css-tokenizer": ^3.0.4
+  checksum: 10c0/42ce5793e55ec4d772083808a11e9fb2dfe36db3ec168713069a276b4c3882205b3507c4680224c28a5d35fe0bc2d308c77f8f2c39c7c09aad8747708eb8ddd8
+  languageName: node
+  linkType: hard
+
+"@csstools/css-color-parser@npm:^3.0.9":
+  version: 3.1.0
+  resolution: "@csstools/css-color-parser@npm:3.1.0"
+  dependencies:
+    "@csstools/color-helpers": "npm:^5.1.0"
+    "@csstools/css-calc": "npm:^2.1.4"
+  peerDependencies:
+    "@csstools/css-parser-algorithms": ^3.0.5
+    "@csstools/css-tokenizer": ^3.0.4
+  checksum: 10c0/0e0c670ad54ec8ec4d9b07568b80defd83b9482191f5e8ca84ab546b7be6db5d7cc2ba7ac9fae54488b129a4be235d6183d3aab4416fec5e89351f73af4222c5
+  languageName: node
+  linkType: hard
+
+"@csstools/css-parser-algorithms@npm:^3.0.4":
+  version: 3.0.5
+  resolution: "@csstools/css-parser-algorithms@npm:3.0.5"
+  peerDependencies:
+    "@csstools/css-tokenizer": ^3.0.4
+  checksum: 10c0/d9a1c888bd43849ae3437ca39251d5c95d2c8fd6b5ccdb7c45491dfd2c1cbdc3075645e80901d120e4d2c1993db9a5b2d83793b779dbbabcfb132adb142eb7f7
+  languageName: node
+  linkType: hard
+
+"@csstools/css-tokenizer@npm:^3.0.3":
+  version: 3.0.4
+  resolution: "@csstools/css-tokenizer@npm:3.0.4"
+  checksum: 10c0/3b589f8e9942075a642213b389bab75a2d50d05d203727fcdac6827648a5572674caff07907eff3f9a2389d86a4ee47308fafe4f8588f4a77b7167c588d2559f
+  languageName: node
+  linkType: hard
+
+"@emnapi/core@npm:1.10.0, @emnapi/core@npm:^1.4.3":
+  version: 1.10.0
+  resolution: "@emnapi/core@npm:1.10.0"
+  dependencies:
+    "@emnapi/wasi-threads": "npm:1.2.1"
+    tslib: "npm:^2.4.0"
+  checksum: 10c0/f51d08227857b60632de7714d708124f0e100a1462dde6df8221760939aa3204a73193830371830fac0716f3ccd2129f2cac1b17cd7d7958bc4da9018a296edb
+  languageName: node
+  linkType: hard
+
 "@emnapi/core@npm:^1.1.0":
   version: 1.7.1
   resolution: "@emnapi/core@npm:1.7.1"
@@ -454,6 +738,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@emnapi/runtime@npm:1.10.0, @emnapi/runtime@npm:^1.4.3":
+  version: 1.10.0
+  resolution: "@emnapi/runtime@npm:1.10.0"
+  dependencies:
+    tslib: "npm:^2.4.0"
+  checksum: 10c0/953f14991d1aefb92ee6f8eb27dea725e484791a53a0cb5f47d9e0087b9a2c929ff2e92adf95af15d6ad456db6300c6b761ebf72b50a875b874a83520b3ba093
+  languageName: node
+  linkType: hard
+
 "@emnapi/runtime@npm:^1.1.0":
   version: 1.7.1
   resolution: "@emnapi/runtime@npm:1.7.1"
@@ -481,6 +774,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@emnapi/wasi-threads@npm:1.2.1":
+  version: 1.2.1
+  resolution: "@emnapi/wasi-threads@npm:1.2.1"
+  dependencies:
+    tslib: "npm:^2.4.0"
+  checksum: 10c0/32fcfa81ab396533b2ec1f4082b1ff779a05d9c836bbbd3f4398405b0e6814c0d9503b7993130e37bc6941dbc1ded49f55e9700ae9ca4e803bab2b5bc5deb331
+  languageName: node
+  linkType: hard
+
 "@esbuild/aix-ppc64@npm:0.21.4":
   version: 0.21.4
   resolution: "@esbuild/aix-ppc64@npm:0.21.4"
@@ -642,7 +944,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@eslint-community/eslint-utils@npm:^4.1.2, @eslint-community/eslint-utils@npm:^4.2.0, @eslint-community/eslint-utils@npm:^4.4.0":
+"@eslint-community/eslint-utils@npm:^4.1.2, @eslint-community/eslint-utils@npm:^4.4.0":
   version: 4.4.0
   resolution: "@eslint-community/eslint-utils@npm:4.4.0"
   dependencies:
@@ -653,34 +955,91 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@eslint-community/regexpp@npm:^4.5.1, @eslint-community/regexpp@npm:^4.6.0, @eslint-community/regexpp@npm:^4.6.1":
-  version: 4.10.0
-  resolution: "@eslint-community/regexpp@npm:4.10.0"
-  checksum: 10c0/c5f60ef1f1ea7649fa7af0e80a5a79f64b55a8a8fa5086de4727eb4c86c652aedee407a9c143b8995d2c0b2d75c1222bec9ba5d73dbfc1f314550554f0979ef4
+"@eslint-community/eslint-utils@npm:^4.5.0, @eslint-community/eslint-utils@npm:^4.8.0, @eslint-community/eslint-utils@npm:^4.9.1":
+  version: 4.9.1
+  resolution: "@eslint-community/eslint-utils@npm:4.9.1"
+  dependencies:
+    eslint-visitor-keys: "npm:^3.4.3"
+  peerDependencies:
+    eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
+  checksum: 10c0/dc4ab5e3e364ef27e33666b11f4b86e1a6c1d7cbf16f0c6ff87b1619b3562335e9201a3d6ce806221887ff780ec9d828962a290bb910759fd40a674686503f02
   languageName: node
   linkType: hard
 
-"@eslint/eslintrc@npm:^2.1.4":
-  version: 2.1.4
-  resolution: "@eslint/eslintrc@npm:2.1.4"
+"@eslint-community/regexpp@npm:^4.11.0, @eslint-community/regexpp@npm:^4.12.1, @eslint-community/regexpp@npm:^4.12.2":
+  version: 4.12.2
+  resolution: "@eslint-community/regexpp@npm:4.12.2"
+  checksum: 10c0/fddcbc66851b308478d04e302a4d771d6917a0b3740dc351513c0da9ca2eab8a1adf99f5e0aa7ab8b13fa0df005c81adeee7e63a92f3effd7d367a163b721c2d
+  languageName: node
+  linkType: hard
+
+"@eslint/config-array@npm:^0.21.2":
+  version: 0.21.2
+  resolution: "@eslint/config-array@npm:0.21.2"
+  dependencies:
+    "@eslint/object-schema": "npm:^2.1.7"
+    debug: "npm:^4.3.1"
+    minimatch: "npm:^3.1.5"
+  checksum: 10c0/89dfe815d18456177c0a1f238daf4593107fd20298b3598e0103054360d3b8d09d967defd8318f031185d68df1f95cfa68becf1390a9c5c6887665f1475142e3
+  languageName: node
+  linkType: hard
+
+"@eslint/config-helpers@npm:^0.4.2":
+  version: 0.4.2
+  resolution: "@eslint/config-helpers@npm:0.4.2"
   dependencies:
-    ajv: "npm:^6.12.4"
+    "@eslint/core": "npm:^0.17.0"
+  checksum: 10c0/92efd7a527b2d17eb1a148409d71d80f9ac160b565ac73ee092252e8bf08ecd08670699f46b306b94f13d22e88ac88a612120e7847570dd7cdc72f234d50dcb4
+  languageName: node
+  linkType: hard
+
+"@eslint/core@npm:^0.17.0":
+  version: 0.17.0
+  resolution: "@eslint/core@npm:0.17.0"
+  dependencies:
+    "@types/json-schema": "npm:^7.0.15"
+  checksum: 10c0/9a580f2246633bc752298e7440dd942ec421860d1946d0801f0423830e67887e4aeba10ab9a23d281727a978eb93d053d1922a587d502942a713607f40ed704e
+  languageName: node
+  linkType: hard
+
+"@eslint/eslintrc@npm:^3.3.5":
+  version: 3.3.5
+  resolution: "@eslint/eslintrc@npm:3.3.5"
+  dependencies:
+    ajv: "npm:^6.14.0"
     debug: "npm:^4.3.2"
-    espree: "npm:^9.6.0"
-    globals: "npm:^13.19.0"
+    espree: "npm:^10.0.1"
+    globals: "npm:^14.0.0"
     ignore: "npm:^5.2.0"
     import-fresh: "npm:^3.2.1"
-    js-yaml: "npm:^4.1.0"
-    minimatch: "npm:^3.1.2"
+    js-yaml: "npm:^4.1.1"
+    minimatch: "npm:^3.1.5"
     strip-json-comments: "npm:^3.1.1"
-  checksum: 10c0/32f67052b81768ae876c84569ffd562491ec5a5091b0c1e1ca1e0f3c24fb42f804952fdd0a137873bc64303ba368a71ba079a6f691cee25beee9722d94cc8573
+  checksum: 10c0/9fb9f1ca65e46d6173966e3aaa5bd353e3a65d7f1f582bebf77f578fab7d7960a399fac1ecfb1e7d52bd61f5cefd6531087ca52a3a3c388f2e1b4f1ebd3da8b7
+  languageName: node
+  linkType: hard
+
+"@eslint/js@npm:9.39.4":
+  version: 9.39.4
+  resolution: "@eslint/js@npm:9.39.4"
+  checksum: 10c0/5aa7dea2cbc5decf7f5e3b0c6f86a084ccee0f792d288ca8e839f8bc1b64e03e227068968e49b26096e6f71fd857ab6e42691d1b993826b9a3883f1bdd7a0e46
+  languageName: node
+  linkType: hard
+
+"@eslint/object-schema@npm:^2.1.7":
+  version: 2.1.7
+  resolution: "@eslint/object-schema@npm:2.1.7"
+  checksum: 10c0/936b6e499853d1335803f556d526c86f5fe2259ed241bc665000e1d6353828edd913feed43120d150adb75570cae162cf000b5b0dfc9596726761c36b82f4e87
   languageName: node
   linkType: hard
 
-"@eslint/js@npm:8.57.0":
-  version: 8.57.0
-  resolution: "@eslint/js@npm:8.57.0"
-  checksum: 10c0/9a518bb8625ba3350613903a6d8c622352ab0c6557a59fe6ff6178bf882bf57123f9d92aa826ee8ac3ee74b9c6203fe630e9ee00efb03d753962dcf65ee4bd94
+"@eslint/plugin-kit@npm:^0.4.1":
+  version: 0.4.1
+  resolution: "@eslint/plugin-kit@npm:0.4.1"
+  dependencies:
+    "@eslint/core": "npm:^0.17.0"
+    levn: "npm:^0.4.1"
+  checksum: 10c0/51600f78b798f172a9915dffb295e2ffb44840d583427bc732baf12ecb963eb841b253300e657da91d890f4b323d10a1bd12934bf293e3018d8bb66fdce5217b
   languageName: node
   linkType: hard
 
@@ -691,14 +1050,37 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@humanwhocodes/config-array@npm:^0.11.14":
-  version: 0.11.14
-  resolution: "@humanwhocodes/config-array@npm:0.11.14"
+"@humanfs/core@npm:^0.19.2":
+  version: 0.19.2
+  resolution: "@humanfs/core@npm:0.19.2"
   dependencies:
-    "@humanwhocodes/object-schema": "npm:^2.0.2"
-    debug: "npm:^4.3.1"
-    minimatch: "npm:^3.0.5"
-  checksum: 10c0/66f725b4ee5fdd8322c737cb5013e19fac72d4d69c8bf4b7feb192fcb83442b035b92186f8e9497c220e58b2d51a080f28a73f7899bc1ab288c3be172c467541
+    "@humanfs/types": "npm:^0.15.0"
+  checksum: 10c0/d0a1d52d7b30c27d49475a53072d1510b81c5803e44b342fb8faf3887f1aa27593a1e6dc76a45268e7892d3f4e198146659281f6b6d55eacf3fd5a38bac30c5c
+  languageName: node
+  linkType: hard
+
+"@humanfs/node@npm:^0.16.6":
+  version: 0.16.8
+  resolution: "@humanfs/node@npm:0.16.8"
+  dependencies:
+    "@humanfs/core": "npm:^0.19.2"
+    "@humanfs/types": "npm:^0.15.0"
+    "@humanwhocodes/retry": "npm:^0.4.0"
+  checksum: 10c0/56140579db811af4e160b195d45d0f29acf644d192c93fe24c9e594ebf06f19dfc157494a07c84540b8a071c0e4b37209c2362765d31734f4d0be869c2422e25
+  languageName: node
+  linkType: hard
+
+"@humanfs/types@npm:^0.15.0":
+  version: 0.15.0
+  resolution: "@humanfs/types@npm:0.15.0"
+  checksum: 10c0/fc26b9a024b0e55f7eaf64036df94345bf5d36d6a41ef80ef38e78f1f7430ce26cf435af736adae58913baae18eac3f38c18739054a3d379102015978eae862e
+  languageName: node
+  linkType: hard
+
+"@humanwhocodes/gitignore-to-minimatch@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "@humanwhocodes/gitignore-to-minimatch@npm:1.0.2"
+  checksum: 10c0/f2d3325e506c9467b719ce4f0a5abf8ba0eae21e20ea504aa28702eb89e7a95d5bc77f897197ef5706d0b98362da896e1cf3b922c414fe684a5fb66f1ec50b27
   languageName: node
   linkType: hard
 
@@ -709,10 +1091,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@humanwhocodes/object-schema@npm:^2.0.2":
-  version: 2.0.3
-  resolution: "@humanwhocodes/object-schema@npm:2.0.3"
-  checksum: 10c0/80520eabbfc2d32fe195a93557cef50dfe8c8905de447f022675aaf66abc33ae54098f5ea78548d925aa671cd4ab7c7daa5ad704fe42358c9b5e7db60f80696c
+"@humanwhocodes/retry@npm:^0.4.0, @humanwhocodes/retry@npm:^0.4.2":
+  version: 0.4.3
+  resolution: "@humanwhocodes/retry@npm:0.4.3"
+  checksum: 10c0/3775bb30087d4440b3f7406d5a057777d90e4b9f435af488a4923ef249e93615fb78565a85f173a186a076c7706a81d0d57d563a2624e4de2c5c9c66c486ce42
   languageName: node
   linkType: hard
 
@@ -1050,58 +1432,57 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@jest/console@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/console@npm:29.7.0"
+"@jest/console@npm:30.3.0":
+  version: 30.3.0
+  resolution: "@jest/console@npm:30.3.0"
   dependencies:
-    "@jest/types": "npm:^29.6.3"
+    "@jest/types": "npm:30.3.0"
     "@types/node": "npm:*"
-    chalk: "npm:^4.0.0"
-    jest-message-util: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
+    chalk: "npm:^4.1.2"
+    jest-message-util: "npm:30.3.0"
+    jest-util: "npm:30.3.0"
     slash: "npm:^3.0.0"
-  checksum: 10c0/7be408781d0a6f657e969cbec13b540c329671819c2f57acfad0dae9dbfe2c9be859f38fe99b35dba9ff1536937dc6ddc69fdcd2794812fa3c647a1619797f6c
+  checksum: 10c0/5458f26b0591b847b719a707cbd1d6b2b99960784a1480a28d19200a807b6092f066c1bd1810df8c6adebf934a64de7b6022dc35082cd7c8f09f35940da104d9
   languageName: node
   linkType: hard
 
-"@jest/core@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/core@npm:29.7.0"
+"@jest/core@npm:30.3.0":
+  version: 30.3.0
+  resolution: "@jest/core@npm:30.3.0"
   dependencies:
-    "@jest/console": "npm:^29.7.0"
-    "@jest/reporters": "npm:^29.7.0"
-    "@jest/test-result": "npm:^29.7.0"
-    "@jest/transform": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
+    "@jest/console": "npm:30.3.0"
+    "@jest/pattern": "npm:30.0.1"
+    "@jest/reporters": "npm:30.3.0"
+    "@jest/test-result": "npm:30.3.0"
+    "@jest/transform": "npm:30.3.0"
+    "@jest/types": "npm:30.3.0"
     "@types/node": "npm:*"
-    ansi-escapes: "npm:^4.2.1"
-    chalk: "npm:^4.0.0"
-    ci-info: "npm:^3.2.0"
-    exit: "npm:^0.1.2"
-    graceful-fs: "npm:^4.2.9"
-    jest-changed-files: "npm:^29.7.0"
-    jest-config: "npm:^29.7.0"
-    jest-haste-map: "npm:^29.7.0"
-    jest-message-util: "npm:^29.7.0"
-    jest-regex-util: "npm:^29.6.3"
-    jest-resolve: "npm:^29.7.0"
-    jest-resolve-dependencies: "npm:^29.7.0"
-    jest-runner: "npm:^29.7.0"
-    jest-runtime: "npm:^29.7.0"
-    jest-snapshot: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-    jest-validate: "npm:^29.7.0"
-    jest-watcher: "npm:^29.7.0"
-    micromatch: "npm:^4.0.4"
-    pretty-format: "npm:^29.7.0"
+    ansi-escapes: "npm:^4.3.2"
+    chalk: "npm:^4.1.2"
+    ci-info: "npm:^4.2.0"
+    exit-x: "npm:^0.2.2"
+    graceful-fs: "npm:^4.2.11"
+    jest-changed-files: "npm:30.3.0"
+    jest-config: "npm:30.3.0"
+    jest-haste-map: "npm:30.3.0"
+    jest-message-util: "npm:30.3.0"
+    jest-regex-util: "npm:30.0.1"
+    jest-resolve: "npm:30.3.0"
+    jest-resolve-dependencies: "npm:30.3.0"
+    jest-runner: "npm:30.3.0"
+    jest-runtime: "npm:30.3.0"
+    jest-snapshot: "npm:30.3.0"
+    jest-util: "npm:30.3.0"
+    jest-validate: "npm:30.3.0"
+    jest-watcher: "npm:30.3.0"
+    pretty-format: "npm:30.3.0"
     slash: "npm:^3.0.0"
-    strip-ansi: "npm:^6.0.0"
   peerDependencies:
     node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
   peerDependenciesMeta:
     node-notifier:
       optional: true
-  checksum: 10c0/934f7bf73190f029ac0f96662c85cd276ec460d407baf6b0dbaec2872e157db4d55a7ee0b1c43b18874602f662b37cb973dda469a4e6d88b4e4845b521adeeb2
+  checksum: 10c0/1735f2263cca10c6cae4e1dbde9c3ccb36e2cbd1cc10bac6fc45e187b06c4e33a6a029f9a6444a3cd43a2a44ffaec3b686d94f70965cebf2b885b198c8615322
   languageName: node
   linkType: hard
 
@@ -1112,48 +1493,76 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@jest/environment@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/environment@npm:29.7.0"
+"@jest/diff-sequences@npm:30.3.0":
+  version: 30.3.0
+  resolution: "@jest/diff-sequences@npm:30.3.0"
+  checksum: 10c0/8922c16a869b839b6c05f677023b3e5a9aa1610ad78a9c5ec8bd6654e35e8136ea1c7b60ad561910e2ad964bfdb0b09b0254ff8dcfacd4562095766f60c63d76
+  languageName: node
+  linkType: hard
+
+"@jest/environment-jsdom-abstract@npm:30.3.0":
+  version: 30.3.0
+  resolution: "@jest/environment-jsdom-abstract@npm:30.3.0"
+  dependencies:
+    "@jest/environment": "npm:30.3.0"
+    "@jest/fake-timers": "npm:30.3.0"
+    "@jest/types": "npm:30.3.0"
+    "@types/jsdom": "npm:^21.1.7"
+    "@types/node": "npm:*"
+    jest-mock: "npm:30.3.0"
+    jest-util: "npm:30.3.0"
+  peerDependencies:
+    canvas: ^3.0.0
+    jsdom: "*"
+  peerDependenciesMeta:
+    canvas:
+      optional: true
+  checksum: 10c0/95ec44bc3cc4cf91660acd4bf7da547414a1d797a32442dd6c4f6d47c82bb4b6eb2ee6b7a5d177d0827378793433a743462d24f5e445075b69edfbc28ab5ca40
+  languageName: node
+  linkType: hard
+
+"@jest/environment@npm:30.3.0":
+  version: 30.3.0
+  resolution: "@jest/environment@npm:30.3.0"
   dependencies:
-    "@jest/fake-timers": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
+    "@jest/fake-timers": "npm:30.3.0"
+    "@jest/types": "npm:30.3.0"
     "@types/node": "npm:*"
-    jest-mock: "npm:^29.7.0"
-  checksum: 10c0/c7b1b40c618f8baf4d00609022d2afa086d9c6acc706f303a70bb4b67275868f620ad2e1a9efc5edd418906157337cce50589a627a6400bbdf117d351b91ef86
+    jest-mock: "npm:30.3.0"
+  checksum: 10c0/4068ccc2e4761e52909239c21e71f73b57ad087bd120b75d3232c68d911686d68fd0fb20e19725517a624b0aa9d45431b00503bd1d5ab2f4958e1a18d265d8d5
   languageName: node
   linkType: hard
 
-"@jest/expect-utils@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/expect-utils@npm:29.7.0"
+"@jest/expect-utils@npm:30.3.0":
+  version: 30.3.0
+  resolution: "@jest/expect-utils@npm:30.3.0"
   dependencies:
-    jest-get-type: "npm:^29.6.3"
-  checksum: 10c0/60b79d23a5358dc50d9510d726443316253ecda3a7fb8072e1526b3e0d3b14f066ee112db95699b7a43ad3f0b61b750c72e28a5a1cac361d7a2bb34747fa938a
+    "@jest/get-type": "npm:30.1.0"
+  checksum: 10c0/4bb60fb434cb8ed325735bd39171b61621e110502ecc502089805d203ecb17b9fc5a400aeffb83b41fabcc819628a9c38c955f90a716d6aaff193d10926fc854
   languageName: node
   linkType: hard
 
-"@jest/expect@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/expect@npm:29.7.0"
+"@jest/expect@npm:30.3.0":
+  version: 30.3.0
+  resolution: "@jest/expect@npm:30.3.0"
   dependencies:
-    expect: "npm:^29.7.0"
-    jest-snapshot: "npm:^29.7.0"
-  checksum: 10c0/b41f193fb697d3ced134349250aed6ccea075e48c4f803159db102b826a4e473397c68c31118259868fd69a5cba70e97e1c26d2c2ff716ca39dc73a2ccec037e
+    expect: "npm:30.3.0"
+    jest-snapshot: "npm:30.3.0"
+  checksum: 10c0/1e052975fdf2b977a63dc9f3db1de56be9dce8e5cd660d9c72cc25093324b990b3e93318cd0c1ff9df7cb30ec7eef71331bc7e19d39700eb3f4498e17ee4c9e0
   languageName: node
   linkType: hard
 
-"@jest/fake-timers@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/fake-timers@npm:29.7.0"
+"@jest/fake-timers@npm:30.3.0":
+  version: 30.3.0
+  resolution: "@jest/fake-timers@npm:30.3.0"
   dependencies:
-    "@jest/types": "npm:^29.6.3"
-    "@sinonjs/fake-timers": "npm:^10.0.2"
+    "@jest/types": "npm:30.3.0"
+    "@sinonjs/fake-timers": "npm:^15.0.0"
     "@types/node": "npm:*"
-    jest-message-util: "npm:^29.7.0"
-    jest-mock: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-  checksum: 10c0/cf0a8bcda801b28dc2e2b2ba36302200ee8104a45ad7a21e6c234148932f826cb3bc57c8df3b7b815aeea0861d7b6ca6f0d4778f93b9219398ef28749e03595c
+    jest-message-util: "npm:30.3.0"
+    jest-mock: "npm:30.3.0"
+    jest-util: "npm:30.3.0"
+  checksum: 10c0/114855ca14d6b34c886855445852a5b960bc3df0ef97c4b971b375747fe0206b3111ec60efc6e658565677022f0d790acd7e232e478f3390ea854d04dea0c4d8
   languageName: node
   linkType: hard
 
@@ -1164,52 +1573,61 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@jest/globals@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/globals@npm:29.7.0"
+"@jest/globals@npm:30.3.0, @jest/globals@npm:^30.3.0":
+  version: 30.3.0
+  resolution: "@jest/globals@npm:30.3.0"
+  dependencies:
+    "@jest/environment": "npm:30.3.0"
+    "@jest/expect": "npm:30.3.0"
+    "@jest/types": "npm:30.3.0"
+    jest-mock: "npm:30.3.0"
+  checksum: 10c0/013554dcbf75867e715801e98a5c6eefbea67cb388efd019be9e0d83979d7354874c4b33bbabc95de698215f5b891e921c26a284841504f9825fd789432b1cd0
+  languageName: node
+  linkType: hard
+
+"@jest/pattern@npm:30.0.1":
+  version: 30.0.1
+  resolution: "@jest/pattern@npm:30.0.1"
   dependencies:
-    "@jest/environment": "npm:^29.7.0"
-    "@jest/expect": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    jest-mock: "npm:^29.7.0"
-  checksum: 10c0/a385c99396878fe6e4460c43bd7bb0a5cc52befb462cc6e7f2a3810f9e7bcce7cdeb51908fd530391ee452dc856c98baa2c5f5fa8a5b30b071d31ef7f6955cea
+    "@types/node": "npm:*"
+    jest-regex-util: "npm:30.0.1"
+  checksum: 10c0/32c5a7bfb6c591f004dac0ed36d645002ed168971e4c89bd915d1577031672870032594767557b855c5bc330aa1e39a2f54bf150d2ee88a7a0886e9cb65318bc
   languageName: node
   linkType: hard
 
-"@jest/reporters@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/reporters@npm:29.7.0"
+"@jest/reporters@npm:30.3.0":
+  version: 30.3.0
+  resolution: "@jest/reporters@npm:30.3.0"
   dependencies:
     "@bcoe/v8-coverage": "npm:^0.2.3"
-    "@jest/console": "npm:^29.7.0"
-    "@jest/test-result": "npm:^29.7.0"
-    "@jest/transform": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    "@jridgewell/trace-mapping": "npm:^0.3.18"
+    "@jest/console": "npm:30.3.0"
+    "@jest/test-result": "npm:30.3.0"
+    "@jest/transform": "npm:30.3.0"
+    "@jest/types": "npm:30.3.0"
+    "@jridgewell/trace-mapping": "npm:^0.3.25"
     "@types/node": "npm:*"
-    chalk: "npm:^4.0.0"
-    collect-v8-coverage: "npm:^1.0.0"
-    exit: "npm:^0.1.2"
-    glob: "npm:^7.1.3"
-    graceful-fs: "npm:^4.2.9"
+    chalk: "npm:^4.1.2"
+    collect-v8-coverage: "npm:^1.0.2"
+    exit-x: "npm:^0.2.2"
+    glob: "npm:^10.5.0"
+    graceful-fs: "npm:^4.2.11"
     istanbul-lib-coverage: "npm:^3.0.0"
     istanbul-lib-instrument: "npm:^6.0.0"
     istanbul-lib-report: "npm:^3.0.0"
-    istanbul-lib-source-maps: "npm:^4.0.0"
+    istanbul-lib-source-maps: "npm:^5.0.0"
     istanbul-reports: "npm:^3.1.3"
-    jest-message-util: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-    jest-worker: "npm:^29.7.0"
+    jest-message-util: "npm:30.3.0"
+    jest-util: "npm:30.3.0"
+    jest-worker: "npm:30.3.0"
     slash: "npm:^3.0.0"
-    string-length: "npm:^4.0.1"
-    strip-ansi: "npm:^6.0.0"
+    string-length: "npm:^4.0.2"
     v8-to-istanbul: "npm:^9.0.1"
   peerDependencies:
     node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
   peerDependenciesMeta:
     node-notifier:
       optional: true
-  checksum: 10c0/a754402a799541c6e5aff2c8160562525e2a47e7d568f01ebfc4da66522de39cbb809bbb0a841c7052e4270d79214e70aec3c169e4eae42a03bc1a8a20cb9fa2
+  checksum: 10c0/e1b6fb13df94435d4b8e6f4d4bd1c27dfc572ca7393b0a95d14c98013abe3c962aa28e2c56864f3ddd0894834d21c9a67485d11e6c31532aaaeea66ca6a2a026
   languageName: node
   linkType: hard
 
@@ -1222,84 +1640,97 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@jest/schemas@npm:^29.6.3":
-  version: 29.6.3
-  resolution: "@jest/schemas@npm:29.6.3"
+"@jest/snapshot-utils@npm:30.3.0":
+  version: 30.3.0
+  resolution: "@jest/snapshot-utils@npm:30.3.0"
   dependencies:
-    "@sinclair/typebox": "npm:^0.27.8"
-  checksum: 10c0/b329e89cd5f20b9278ae1233df74016ebf7b385e0d14b9f4c1ad18d096c4c19d1e687aa113a9c976b16ec07f021ae53dea811fb8c1248a50ac34fbe009fdf6be
+    "@jest/types": "npm:30.3.0"
+    chalk: "npm:^4.1.2"
+    graceful-fs: "npm:^4.2.11"
+    natural-compare: "npm:^1.4.0"
+  checksum: 10c0/ba4fea05a418b257d128d8f9eb7672a9004952563a45ad577bed80e5b2ea2ec6e6d3a24535781cc6530d9904d8fda7b27d15952d079ccdbe88f87a5e71112df0
   languageName: node
   linkType: hard
 
-"@jest/source-map@npm:^29.6.3":
-  version: 29.6.3
-  resolution: "@jest/source-map@npm:29.6.3"
+"@jest/source-map@npm:30.0.1":
+  version: 30.0.1
+  resolution: "@jest/source-map@npm:30.0.1"
   dependencies:
-    "@jridgewell/trace-mapping": "npm:^0.3.18"
-    callsites: "npm:^3.0.0"
-    graceful-fs: "npm:^4.2.9"
-  checksum: 10c0/a2f177081830a2e8ad3f2e29e20b63bd40bade294880b595acf2fc09ec74b6a9dd98f126a2baa2bf4941acd89b13a4ade5351b3885c224107083a0059b60a219
+    "@jridgewell/trace-mapping": "npm:^0.3.25"
+    callsites: "npm:^3.1.0"
+    graceful-fs: "npm:^4.2.11"
+  checksum: 10c0/e7bda2786fc9f483d9dd7566c58c4bd948830997be862dfe80a3ae5550ff3f84753abb52e705d02ebe9db9f34ba7ebec4c2db11882048cdeef7a66f6332b3897
   languageName: node
   linkType: hard
 
-"@jest/test-result@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/test-result@npm:29.7.0"
+"@jest/test-result@npm:30.3.0":
+  version: 30.3.0
+  resolution: "@jest/test-result@npm:30.3.0"
   dependencies:
-    "@jest/console": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    "@types/istanbul-lib-coverage": "npm:^2.0.0"
-    collect-v8-coverage: "npm:^1.0.0"
-  checksum: 10c0/7de54090e54a674ca173470b55dc1afdee994f2d70d185c80236003efd3fa2b753fff51ffcdda8e2890244c411fd2267529d42c4a50a8303755041ee493e6a04
+    "@jest/console": "npm:30.3.0"
+    "@jest/types": "npm:30.3.0"
+    "@types/istanbul-lib-coverage": "npm:^2.0.6"
+    collect-v8-coverage: "npm:^1.0.2"
+  checksum: 10c0/67bcd405d0a1ac85b55afabf26e0ee0f184f9cfe0e659a44e0e4a4456c1c7fed9d2288f0116b017eaddfa49ded8c44426b8694c44f9a8a2af35be9202b8a9165
   languageName: node
   linkType: hard
 
-"@jest/test-sequencer@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/test-sequencer@npm:29.7.0"
+"@jest/test-sequencer@npm:30.3.0":
+  version: 30.3.0
+  resolution: "@jest/test-sequencer@npm:30.3.0"
   dependencies:
-    "@jest/test-result": "npm:^29.7.0"
-    graceful-fs: "npm:^4.2.9"
-    jest-haste-map: "npm:^29.7.0"
+    "@jest/test-result": "npm:30.3.0"
+    graceful-fs: "npm:^4.2.11"
+    jest-haste-map: "npm:30.3.0"
     slash: "npm:^3.0.0"
-  checksum: 10c0/593a8c4272797bb5628984486080cbf57aed09c7cfdc0a634e8c06c38c6bef329c46c0016e84555ee55d1cd1f381518cf1890990ff845524c1123720c8c1481b
+  checksum: 10c0/698be35e7145e79ea9d66071d4ec255f6cef4b5972b5142d299f3edbcbc0428cadf8ddecc6d21e938c98ed72b73b15a6d5f81e7b8b370aaa130d2f6b26fd017c
   languageName: node
   linkType: hard
 
-"@jest/transform@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/transform@npm:29.7.0"
+"@jest/transform@npm:30.3.0":
+  version: 30.3.0
+  resolution: "@jest/transform@npm:30.3.0"
   dependencies:
-    "@babel/core": "npm:^7.11.6"
-    "@jest/types": "npm:^29.6.3"
-    "@jridgewell/trace-mapping": "npm:^0.3.18"
-    babel-plugin-istanbul: "npm:^6.1.1"
-    chalk: "npm:^4.0.0"
+    "@babel/core": "npm:^7.27.4"
+    "@jest/types": "npm:30.3.0"
+    "@jridgewell/trace-mapping": "npm:^0.3.25"
+    babel-plugin-istanbul: "npm:^7.0.1"
+    chalk: "npm:^4.1.2"
     convert-source-map: "npm:^2.0.0"
     fast-json-stable-stringify: "npm:^2.1.0"
-    graceful-fs: "npm:^4.2.9"
-    jest-haste-map: "npm:^29.7.0"
-    jest-regex-util: "npm:^29.6.3"
-    jest-util: "npm:^29.7.0"
-    micromatch: "npm:^4.0.4"
-    pirates: "npm:^4.0.4"
+    graceful-fs: "npm:^4.2.11"
+    jest-haste-map: "npm:30.3.0"
+    jest-regex-util: "npm:30.0.1"
+    jest-util: "npm:30.3.0"
+    pirates: "npm:^4.0.7"
     slash: "npm:^3.0.0"
-    write-file-atomic: "npm:^4.0.2"
-  checksum: 10c0/7f4a7f73dcf45dfdf280c7aa283cbac7b6e5a904813c3a93ead7e55873761fc20d5c4f0191d2019004fac6f55f061c82eb3249c2901164ad80e362e7a7ede5a6
+    write-file-atomic: "npm:^5.0.1"
+  checksum: 10c0/5ad0b5361910680b5160e3dc347c0beb75b4edc35a165ef4fc55837d01365179c276dd6f9cc80f7db94048c641b0c188757e1c98c6d4e9b55577956efbc00574
   languageName: node
   linkType: hard
 
-"@jest/types@npm:^29.6.3":
-  version: 29.6.3
-  resolution: "@jest/types@npm:29.6.3"
+"@jest/types@npm:30.3.0":
+  version: 30.3.0
+  resolution: "@jest/types@npm:30.3.0"
   dependencies:
-    "@jest/schemas": "npm:^29.6.3"
-    "@types/istanbul-lib-coverage": "npm:^2.0.0"
-    "@types/istanbul-reports": "npm:^3.0.0"
+    "@jest/pattern": "npm:30.0.1"
+    "@jest/schemas": "npm:30.0.5"
+    "@types/istanbul-lib-coverage": "npm:^2.0.6"
+    "@types/istanbul-reports": "npm:^3.0.4"
     "@types/node": "npm:*"
-    "@types/yargs": "npm:^17.0.8"
-    chalk: "npm:^4.0.0"
-  checksum: 10c0/ea4e493dd3fb47933b8ccab201ae573dcc451f951dc44ed2a86123cd8541b82aa9d2b1031caf9b1080d6673c517e2dcc25a44b2dc4f3fbc37bfc965d444888c0
+    "@types/yargs": "npm:^17.0.33"
+    chalk: "npm:^4.1.2"
+  checksum: 10c0/c3e3f4de0b77a7ced345f47d3687b1094c1b6c1521529a7ca66a76f9a80194f79179a1dbc32d6761a5b67914a8f78be1e65d1408107efcb1f252c4a63b5ddd92
+  languageName: node
+  linkType: hard
+
+"@jridgewell/gen-mapping@npm:^0.3.12":
+  version: 0.3.13
+  resolution: "@jridgewell/gen-mapping@npm:0.3.13"
+  dependencies:
+    "@jridgewell/sourcemap-codec": "npm:^1.5.0"
+    "@jridgewell/trace-mapping": "npm:^0.3.24"
+  checksum: 10c0/9a7d65fb13bd9aec1fbab74cda08496839b7e2ceb31f5ab922b323e94d7c481ce0fc4fd7e12e2610915ed8af51178bdc61e168e92a8c8b8303b030b03489b13b
   languageName: node
   linkType: hard
 
@@ -1314,6 +1745,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@jridgewell/remapping@npm:^2.3.5":
+  version: 2.3.5
+  resolution: "@jridgewell/remapping@npm:2.3.5"
+  dependencies:
+    "@jridgewell/gen-mapping": "npm:^0.3.5"
+    "@jridgewell/trace-mapping": "npm:^0.3.24"
+  checksum: 10c0/3de494219ffeb2c5c38711d0d7bb128097edf91893090a2dbc8ee0b55d092bb7347b1fd0f478486c5eab010e855c73927b1666f2107516d472d24a73017d1194
+  languageName: node
+  linkType: hard
+
 "@jridgewell/resolve-uri@npm:^3.0.3, @jridgewell/resolve-uri@npm:^3.1.0":
   version: 3.1.2
   resolution: "@jridgewell/resolve-uri@npm:3.1.2"
@@ -1335,6 +1776,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@jridgewell/sourcemap-codec@npm:^1.5.0, @jridgewell/sourcemap-codec@npm:^1.5.5":
+  version: 1.5.5
+  resolution: "@jridgewell/sourcemap-codec@npm:1.5.5"
+  checksum: 10c0/f9e538f302b63c0ebc06eecb1dd9918dd4289ed36147a0ddce35d6ea4d7ebbda243cda7b2213b6a5e1d8087a298d5cf630fb2bd39329cdecb82017023f6081a0
+  languageName: node
+  linkType: hard
+
 "@jridgewell/trace-mapping@npm:0.3.9":
   version: 0.3.9
   resolution: "@jridgewell/trace-mapping@npm:0.3.9"
@@ -1345,7 +1793,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@jridgewell/trace-mapping@npm:^0.3.12, @jridgewell/trace-mapping@npm:^0.3.18, @jridgewell/trace-mapping@npm:^0.3.24, @jridgewell/trace-mapping@npm:^0.3.25":
+"@jridgewell/trace-mapping@npm:^0.3.12, @jridgewell/trace-mapping@npm:^0.3.24, @jridgewell/trace-mapping@npm:^0.3.25":
   version: 0.3.25
   resolution: "@jridgewell/trace-mapping@npm:0.3.25"
   dependencies:
@@ -1355,6 +1803,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@jridgewell/trace-mapping@npm:^0.3.23, @jridgewell/trace-mapping@npm:^0.3.28":
+  version: 0.3.31
+  resolution: "@jridgewell/trace-mapping@npm:0.3.31"
+  dependencies:
+    "@jridgewell/resolve-uri": "npm:^3.1.0"
+    "@jridgewell/sourcemap-codec": "npm:^1.4.14"
+  checksum: 10c0/4b30ec8cd56c5fd9a661f088230af01e0c1a3888d11ffb6b47639700f71225be21d1f7e168048d6d4f9449207b978a235c07c8f15c07705685d16dc06280e9d9
+  languageName: node
+  linkType: hard
+
 "@lerna/create@npm:9.0.3":
   version: 9.0.3
   resolution: "@lerna/create@npm:9.0.3"
@@ -1506,30 +1964,26 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@nodelib/fs.scandir@npm:2.1.5":
-  version: 2.1.5
-  resolution: "@nodelib/fs.scandir@npm:2.1.5"
+"@napi-rs/wasm-runtime@npm:^0.2.11":
+  version: 0.2.12
+  resolution: "@napi-rs/wasm-runtime@npm:0.2.12"
   dependencies:
-    "@nodelib/fs.stat": "npm:2.0.5"
-    run-parallel: "npm:^1.1.9"
-  checksum: 10c0/732c3b6d1b1e967440e65f284bd06e5821fedf10a1bea9ed2bb75956ea1f30e08c44d3def9d6a230666574edbaf136f8cfd319c14fd1f87c66e6a44449afb2eb
+    "@emnapi/core": "npm:^1.4.3"
+    "@emnapi/runtime": "npm:^1.4.3"
+    "@tybys/wasm-util": "npm:^0.10.0"
+  checksum: 10c0/6d07922c0613aab30c6a497f4df297ca7c54e5b480e00035e0209b872d5c6aab7162fc49477267556109c2c7ed1eb9c65a174e27e9b87568106a87b0a6e3ca7d
   languageName: node
   linkType: hard
 
-"@nodelib/fs.stat@npm:2.0.5, @nodelib/fs.stat@npm:^2.0.2":
-  version: 2.0.5
-  resolution: "@nodelib/fs.stat@npm:2.0.5"
-  checksum: 10c0/88dafe5e3e29a388b07264680dc996c17f4bda48d163a9d4f5c1112979f0ce8ec72aa7116122c350b4e7976bc5566dc3ddb579be1ceaacc727872eb4ed93926d
-  languageName: node
-  linkType: hard
-
-"@nodelib/fs.walk@npm:^1.2.3, @nodelib/fs.walk@npm:^1.2.8":
-  version: 1.2.8
-  resolution: "@nodelib/fs.walk@npm:1.2.8"
+"@napi-rs/wasm-runtime@npm:^1.1.4":
+  version: 1.1.4
+  resolution: "@napi-rs/wasm-runtime@npm:1.1.4"
   dependencies:
-    "@nodelib/fs.scandir": "npm:2.1.5"
-    fastq: "npm:^1.6.0"
-  checksum: 10c0/db9de047c3bb9b51f9335a7bb46f4fcfb6829fb628318c12115fbaf7d369bfce71c15b103d1fc3b464812d936220ee9bc1c8f762d032c9f6be9acc99249095b1
+    "@tybys/wasm-util": "npm:^0.10.1"
+  peerDependencies:
+    "@emnapi/core": ^1.7.1
+    "@emnapi/runtime": ^1.7.1
+  checksum: 10c0/2e88e1955258949ccf2d18c79975821ad38071b465ef126a5e14110977b97868867b016c1ad046e963cccc42c0bd9db6c8ff5fd1ebb61b87bb3487f339041658
   languageName: node
   linkType: hard
 
@@ -2096,6 +2550,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@oxc-project/types@npm:=0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-project/types@npm:0.127.0"
+  checksum: 10c0/52c0947ac64a9ca119fe971f947e784a35ecd14a072fa3f542a58a5f6c42010b53f2bf92731e39b9899b83c990a9517bbd29d1e5a5b7b489e52616685c6a9278
+  languageName: node
+  linkType: hard
+
 "@pkgjs/parseargs@npm:^0.11.0":
   version: 0.11.0
   resolution: "@pkgjs/parseargs@npm:0.11.0"
@@ -2103,6 +2564,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@pkgr/core@npm:^0.2.9":
+  version: 0.2.9
+  resolution: "@pkgr/core@npm:0.2.9"
+  checksum: 10c0/ac8e4e8138b1a7a4ac6282873aef7389c352f1f8b577b4850778f5182e4a39a5241facbe48361fec817f56d02b51691b383010843fb08b34a8e8ea3614688fd5
+  languageName: node
+  linkType: hard
+
 "@redis/bloom@npm:5.10.0":
   version: 5.10.0
   resolution: "@redis/bloom@npm:5.10.0"
@@ -2148,6 +2616,122 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@rolldown/binding-android-arm64@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "@rolldown/binding-android-arm64@npm:1.0.0-rc.17"
+  conditions: os=android & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@rolldown/binding-darwin-arm64@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "@rolldown/binding-darwin-arm64@npm:1.0.0-rc.17"
+  conditions: os=darwin & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@rolldown/binding-darwin-x64@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "@rolldown/binding-darwin-x64@npm:1.0.0-rc.17"
+  conditions: os=darwin & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@rolldown/binding-freebsd-x64@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "@rolldown/binding-freebsd-x64@npm:1.0.0-rc.17"
+  conditions: os=freebsd & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@rolldown/binding-linux-arm-gnueabihf@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "@rolldown/binding-linux-arm-gnueabihf@npm:1.0.0-rc.17"
+  conditions: os=linux & cpu=arm
+  languageName: node
+  linkType: hard
+
+"@rolldown/binding-linux-arm64-gnu@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "@rolldown/binding-linux-arm64-gnu@npm:1.0.0-rc.17"
+  conditions: os=linux & cpu=arm64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@rolldown/binding-linux-arm64-musl@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "@rolldown/binding-linux-arm64-musl@npm:1.0.0-rc.17"
+  conditions: os=linux & cpu=arm64 & libc=musl
+  languageName: node
+  linkType: hard
+
+"@rolldown/binding-linux-ppc64-gnu@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "@rolldown/binding-linux-ppc64-gnu@npm:1.0.0-rc.17"
+  conditions: os=linux & cpu=ppc64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@rolldown/binding-linux-s390x-gnu@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "@rolldown/binding-linux-s390x-gnu@npm:1.0.0-rc.17"
+  conditions: os=linux & cpu=s390x & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@rolldown/binding-linux-x64-gnu@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "@rolldown/binding-linux-x64-gnu@npm:1.0.0-rc.17"
+  conditions: os=linux & cpu=x64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@rolldown/binding-linux-x64-musl@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "@rolldown/binding-linux-x64-musl@npm:1.0.0-rc.17"
+  conditions: os=linux & cpu=x64 & libc=musl
+  languageName: node
+  linkType: hard
+
+"@rolldown/binding-openharmony-arm64@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "@rolldown/binding-openharmony-arm64@npm:1.0.0-rc.17"
+  conditions: os=openharmony & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@rolldown/binding-wasm32-wasi@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "@rolldown/binding-wasm32-wasi@npm:1.0.0-rc.17"
+  dependencies:
+    "@emnapi/core": "npm:1.10.0"
+    "@emnapi/runtime": "npm:1.10.0"
+    "@napi-rs/wasm-runtime": "npm:^1.1.4"
+  conditions: cpu=wasm32
+  languageName: node
+  linkType: hard
+
+"@rolldown/binding-win32-arm64-msvc@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "@rolldown/binding-win32-arm64-msvc@npm:1.0.0-rc.17"
+  conditions: os=win32 & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@rolldown/binding-win32-x64-msvc@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "@rolldown/binding-win32-x64-msvc@npm:1.0.0-rc.17"
+  conditions: os=win32 & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@rolldown/pluginutils@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "@rolldown/pluginutils@npm:1.0.0-rc.17"
+  checksum: 10c0/5e840b20cc531910c093c1ca36e550952cf4936465a50d89f0a98fc9d0dfd7d319d06a10a5f4376209d89e9bf4d60af6cc8363ebf0dcc5e60842f7fef438b2f0
+  languageName: node
+  linkType: hard
+
 "@rsbuild/core@npm:2.0.0-beta.0":
   version: 2.0.0-beta.0
   resolution: "@rsbuild/core@npm:2.0.0-beta.0"
@@ -2536,13 +3120,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@sinclair/typebox@npm:^0.27.8":
-  version: 0.27.8
-  resolution: "@sinclair/typebox@npm:0.27.8"
-  checksum: 10c0/ef6351ae073c45c2ac89494dbb3e1f87cc60a93ce4cde797b782812b6f97da0d620ae81973f104b43c9b7eaa789ad20ba4f6a1359f1cc62f63729a55a7d22d4e
-  languageName: node
-  linkType: hard
-
 "@sinclair/typebox@npm:^0.34.0":
   version: 0.34.41
   resolution: "@sinclair/typebox@npm:0.34.41"
@@ -2550,7 +3127,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@sinonjs/commons@npm:^3.0.0":
+"@sinonjs/commons@npm:^3.0.1":
   version: 3.0.1
   resolution: "@sinonjs/commons@npm:3.0.1"
   dependencies:
@@ -2559,85 +3136,26 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@sinonjs/fake-timers@npm:^10.0.2":
-  version: 10.3.0
-  resolution: "@sinonjs/fake-timers@npm:10.3.0"
-  dependencies:
-    "@sinonjs/commons": "npm:^3.0.0"
-  checksum: 10c0/2e2fb6cc57f227912814085b7b01fede050cd4746ea8d49a1e44d5a0e56a804663b0340ae2f11af7559ea9bf4d087a11f2f646197a660ea3cb04e19efc04aa63
-  languageName: node
-  linkType: hard
-
-"@startupjs/eslint-plugin-react-pug@npm:^0.8.3-3":
-  version: 0.8.3-3
-  resolution: "@startupjs/eslint-plugin-react-pug@npm:0.8.3-3"
-  dependencies:
-    "@babel/parser": "npm:^7.4.5"
-    "@babel/traverse": "npm:^7.4.5"
-    "@startupjs/pug-lexer": "npm:^4.1.0-1"
-    "@startupjs/pug-lint": "npm:^2.7.0-0"
-    "@startupjs/pug-uses-variables": "npm:^3.0.1-0"
-    common-prefix: "npm:^1.1.0"
-    eslint-plugin-react: "npm:*"
-  peerDependencies:
-    eslint-plugin-react: ">= 7"
-  checksum: 10c0/d71b5329bfe95632c0393a984c700241d8b7279e2bc45ec1cc862057be64b9678261b7fe849338512e8d774ce9f6ab8eccbf163f960884d054ff248f2326e60a
-  languageName: node
-  linkType: hard
-
-"@startupjs/is-expression@npm:^4.0.0-0":
-  version: 4.0.0-0
-  resolution: "@startupjs/is-expression@npm:4.0.0-0"
-  dependencies:
-    acorn: "npm:^8.8.2"
-    object-assign: "npm:^4.1.1"
-  checksum: 10c0/e14c477b2799db5e6522e1941ab1684b91020ba8d9ebed524922bbca4f6f5bf067344335ea7f77cb611732310ab5f13bc698a7cf7fa177f026487d0aba7c151d
-  languageName: node
-  linkType: hard
-
-"@startupjs/pug-lexer@npm:^4.1.0-1":
-  version: 4.1.0-1
-  resolution: "@startupjs/pug-lexer@npm:4.1.0-1"
+"@sinonjs/fake-timers@npm:^15.0.0":
+  version: 15.3.2
+  resolution: "@sinonjs/fake-timers@npm:15.3.2"
   dependencies:
-    "@startupjs/is-expression": "npm:^4.0.0-0"
-    character-parser: "npm:^4.0.0"
-    pug-error: "npm:^1.3.3"
-  checksum: 10c0/3d50f08b44b7d17dd8b4ffc566ef661c006826850a7366da369e25515a39448f92f2e8b853ab45257f5c07a8430eb17334f4ce3599c0bd035d9796dc7526ebd1
+    "@sinonjs/commons": "npm:^3.0.1"
+  checksum: 10c0/fea39af47e70acf7f6b431b857dc5b50886e1a19d48189bc7f9cf90806a9fdfd4931c04343558724772d429c47fb53df640fc8c8d6ddf6ad66164bd7cbd3220a
   languageName: node
   linkType: hard
 
-"@startupjs/pug-lint@npm:^2.7.0-0":
-  version: 2.7.0-0
-  resolution: "@startupjs/pug-lint@npm:2.7.0-0"
-  dependencies:
-    "@startupjs/pug-lexer": "npm:^4.1.0-1"
-    acorn: "npm:^8.8.2"
-    acorn-walk: "npm:^8.3.2"
-    commander: "npm:^2.9.0"
-    css-selector-parser: "npm:^1.1.0"
-    find-line-column: "npm:^0.5.2"
-    glob: "npm:^7.0.3"
-    minimatch: "npm:^3.0.3"
-    path-is-absolute: "npm:^1.0.0"
-    pug-attrs: "npm:^2.0.4"
-    pug-error: "npm:^1.3.3"
-    resolve: "npm:^1.1.7"
-    strip-json-comments: "npm:^2.0.1"
-    void-elements: "npm:^2.0.1"
-  bin:
-    pug-lint: bin/pug-lint
-  checksum: 10c0/680ceae8e28dbdf95dd625db00ee605119562d51d0b5e6e325e2d2a9295a9004354701f0bd2e96d6c2c5ad01d689e53aebd1ef4fe1fc30ac2a5485bd5eea1fbf
+"@standard-schema/spec@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "@standard-schema/spec@npm:1.1.0"
+  checksum: 10c0/d90f55acde4b2deb983529c87e8025fa693de1a5e8b49ecc6eb84d1fd96328add0e03d7d551442156c7432fd78165b2c26ff561b970a9a881f046abb78d6a526
   languageName: node
   linkType: hard
 
-"@startupjs/pug-uses-variables@npm:^3.0.1-0":
-  version: 3.0.1-0
-  resolution: "@startupjs/pug-uses-variables@npm:3.0.1-0"
-  dependencies:
-    "@babel/parser": "npm:^7.3.2"
-    "@babel/traverse": "npm:^7.2.3"
-    "@startupjs/pug-lexer": "npm:^4.1.0-1"
-  checksum: 10c0/2e50f0526e1c48d7d937e4a3ece0c491fc291b8a2d9923cfcf5ff7b654ec038d45eeae92a3d1680b9683ed602f23b17259237c9ed9790ff47801bae2d032e294
+"@startupjs/babel-plugin-eliminator@npm:^0.62.0-alpha.0":
+  version: 0.62.0-alpha.0
+  resolution: "@startupjs/babel-plugin-eliminator@npm:0.62.0-alpha.0"
+  checksum: 10c0/90a6244fa853f7fc35468ea019920ec58f1c305de3da8a3054b66d4529b4ccf3d09b646ec2b2d3525c1754823fd99d76e654e4e076e3839e8b442884e052f600
   languageName: node
   linkType: hard
 
@@ -2654,6 +3172,21 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@stylistic/eslint-plugin@npm:2.11.0":
+  version: 2.11.0
+  resolution: "@stylistic/eslint-plugin@npm:2.11.0"
+  dependencies:
+    "@typescript-eslint/utils": "npm:^8.13.0"
+    eslint-visitor-keys: "npm:^4.2.0"
+    espree: "npm:^10.3.0"
+    estraverse: "npm:^5.3.0"
+    picomatch: "npm:^4.0.2"
+  peerDependencies:
+    eslint: ">=8.40.0"
+  checksum: 10c0/6ca19b6656be5ed657cf4d1920602fb27144dc5d51ba188e0bdcb2a4e0b740d4fdb27052fc268d164fa1269c972aeab15541c9e15b3ff4b7884ecae47f18ff67
+  languageName: node
+  linkType: hard
+
 "@swc/helpers@npm:^0.5.18":
   version: 0.5.18
   resolution: "@swc/helpers@npm:0.5.18"
@@ -2732,7 +3265,7 @@ __metadata:
   dependencies:
     debug: "npm:*"
     lodash: "npm:^4.17.20"
-    mocha: "npm:^8.1.3"
+    mocha: "npm:^11.7.5"
     racer: "npm:1.0.1"
     sharedb: "npm:^5.0.0"
   languageName: unknown
@@ -2742,7 +3275,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@teamplay/sharedb-schema@workspace:packages/sharedb-schema"
   dependencies:
-    mocha: "npm:^8.1.3"
+    mocha: "npm:^11.7.5"
     racer: "npm:1.0.1"
     sharedb: "npm:^5.0.0"
     z-schema: "npm:^4.2.3"
@@ -2757,37 +3290,39 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@testing-library/dom@npm:^10.0.0":
-  version: 10.1.0
-  resolution: "@testing-library/dom@npm:10.1.0"
+"@testing-library/dom@npm:^10.4.1":
+  version: 10.4.1
+  resolution: "@testing-library/dom@npm:10.4.1"
   dependencies:
     "@babel/code-frame": "npm:^7.10.4"
     "@babel/runtime": "npm:^7.12.5"
     "@types/aria-query": "npm:^5.0.1"
     aria-query: "npm:5.3.0"
-    chalk: "npm:^4.1.0"
     dom-accessibility-api: "npm:^0.5.9"
     lz-string: "npm:^1.5.0"
+    picocolors: "npm:1.1.1"
     pretty-format: "npm:^27.0.2"
-  checksum: 10c0/81f0e0a510d24e458c3af17777960ed678fb4fe464903ef8ec9ed816c9794fc69a673ea94f87b9e054b181383c51814605451dbf4fd9df93d0d8f24b4859990d
+  checksum: 10c0/19ce048012d395ad0468b0dbcc4d0911f6f9e39464d7a8464a587b29707eed5482000dad728f5acc4ed314d2f4d54f34982999a114d2404f36d048278db815b1
   languageName: node
   linkType: hard
 
-"@testing-library/react@npm:^15.0.7":
-  version: 15.0.7
-  resolution: "@testing-library/react@npm:15.0.7"
+"@testing-library/react@npm:^16.3.2":
+  version: 16.3.2
+  resolution: "@testing-library/react@npm:16.3.2"
   dependencies:
     "@babel/runtime": "npm:^7.12.5"
-    "@testing-library/dom": "npm:^10.0.0"
-    "@types/react-dom": "npm:^18.0.0"
   peerDependencies:
-    "@types/react": ^18.0.0
-    react: ^18.0.0
-    react-dom: ^18.0.0
+    "@testing-library/dom": ^10.0.0
+    "@types/react": ^18.0.0 || ^19.0.0
+    "@types/react-dom": ^18.0.0 || ^19.0.0
+    react: ^18.0.0 || ^19.0.0
+    react-dom: ^18.0.0 || ^19.0.0
   peerDependenciesMeta:
     "@types/react":
       optional: true
-  checksum: 10c0/ac8ee8968e81949ecb35f7ee34741c2c043f73dd7fee2247d56f6de6a30de4742af94f25264356863974e54387485b46c9448ecf3f6ca41cf4339011c369f2d4
+    "@types/react-dom":
+      optional: true
+  checksum: 10c0/f9c7f0915e1b5f7b750e6c7d8b51f091b8ae7ea99bacb761d7b8505ba25de9cfcb749a0f779f1650fb268b499dd79165dc7e1ee0b8b4cb63430d3ddc81ffe044
   languageName: node
   linkType: hard
 
@@ -2798,13 +3333,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@tootallnate/once@npm:2":
-  version: 2.0.0
-  resolution: "@tootallnate/once@npm:2.0.0"
-  checksum: 10c0/073bfa548026b1ebaf1659eb8961e526be22fa77139b10d60e712f46d2f0f05f4e6c8bec62a087d41088ee9e29faa7f54838568e475ab2f776171003c3920858
-  languageName: node
-  linkType: hard
-
 "@tsconfig/node10@npm:^1.0.7":
   version: 1.0.11
   resolution: "@tsconfig/node10@npm:1.0.11"
@@ -2850,7 +3378,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@tybys/wasm-util@npm:^0.10.1":
+"@tybys/wasm-util@npm:^0.10.0, @tybys/wasm-util@npm:^0.10.1":
   version: 0.10.1
   resolution: "@tybys/wasm-util@npm:0.10.1"
   dependencies:
@@ -2875,14 +3403,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/babel-types@npm:*, @types/babel-types@npm:^7.0.0":
-  version: 7.0.15
-  resolution: "@types/babel-types@npm:7.0.15"
-  checksum: 10c0/d4ff6f0c177aee27526e306ee8621dc0c6e6315b684885736cbed719477a5e6afd0d76e5425ce41a2c0fc2fefe9f6c85d641c7504f048e3fc0aa810692a19f31
-  languageName: node
-  linkType: hard
-
-"@types/babel__core@npm:^7.1.14":
+"@types/babel__core@npm:^7.20.5":
   version: 7.20.5
   resolution: "@types/babel__core@npm:7.20.5"
   dependencies:
@@ -2914,7 +3435,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/babel__traverse@npm:*, @types/babel__traverse@npm:^7.0.6":
+"@types/babel__traverse@npm:*":
   version: 7.20.6
   resolution: "@types/babel__traverse@npm:7.20.6"
   dependencies:
@@ -2923,12 +3444,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/babylon@npm:^6.16.2":
-  version: 6.16.9
-  resolution: "@types/babylon@npm:6.16.9"
+"@types/chai@npm:^5.2.2":
+  version: 5.2.3
+  resolution: "@types/chai@npm:5.2.3"
   dependencies:
-    "@types/babel-types": "npm:*"
-  checksum: 10c0/3dbe33a158b39d00e11ca4f53cad7ea02ed69c1c266221cabcc81596a03084706be007db698b254ad9689d040d77b9fd32b4b9956cf96dbb631572ea12e53b3a
+    "@types/deep-eql": "npm:*"
+    assertion-error: "npm:^2.0.1"
+  checksum: 10c0/e0ef1de3b6f8045a5e473e867c8565788c444271409d155588504840ad1a53611011f85072188c2833941189400228c1745d78323dac13fcede9c2b28bacfb2f
   languageName: node
   linkType: hard
 
@@ -2941,6 +3463,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/deep-eql@npm:*":
+  version: 4.0.2
+  resolution: "@types/deep-eql@npm:4.0.2"
+  checksum: 10c0/bf3f811843117900d7084b9d0c852da9a044d12eb40e6de73b552598a6843c21291a8a381b0532644574beecd5e3491c5ff3a0365ab86b15d59862c025384844
+  languageName: node
+  linkType: hard
+
 "@types/estree-jsx@npm:^1.0.0":
   version: 1.0.5
   resolution: "@types/estree-jsx@npm:1.0.5"
@@ -2957,12 +3486,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/graceful-fs@npm:^4.1.3":
-  version: 4.1.9
-  resolution: "@types/graceful-fs@npm:4.1.9"
-  dependencies:
-    "@types/node": "npm:*"
-  checksum: 10c0/235d2fc69741448e853333b7c3d1180a966dd2b8972c8cbcd6b2a0c6cd7f8d582ab2b8e58219dbc62cce8f1b40aa317ff78ea2201cdd8249da5025adebed6f0b
+"@types/estree@npm:^1.0.6":
+  version: 1.0.8
+  resolution: "@types/estree@npm:1.0.8"
+  checksum: 10c0/39d34d1afaa338ab9763f37ad6066e3f349444f9052b9676a7cc0252ef9485a41c6d81c9c4e0d26e9077993354edf25efc853f3224dd4b447175ef62bdcc86a5
   languageName: node
   linkType: hard
 
@@ -2985,7 +3512,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/istanbul-lib-coverage@npm:*, @types/istanbul-lib-coverage@npm:^2.0.0, @types/istanbul-lib-coverage@npm:^2.0.1":
+"@types/istanbul-lib-coverage@npm:*, @types/istanbul-lib-coverage@npm:^2.0.1, @types/istanbul-lib-coverage@npm:^2.0.6":
   version: 2.0.6
   resolution: "@types/istanbul-lib-coverage@npm:2.0.6"
   checksum: 10c0/3948088654f3eeb45363f1db158354fb013b362dba2a5c2c18c559484d5eb9f6fd85b23d66c0a7c2fcfab7308d0a585b14dadaca6cc8bf89ebfdc7f8f5102fb7
@@ -3001,7 +3528,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/istanbul-reports@npm:^3.0.0":
+"@types/istanbul-reports@npm:^3.0.4":
   version: 3.0.4
   resolution: "@types/istanbul-reports@npm:3.0.4"
   dependencies:
@@ -3010,31 +3537,24 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/jsdom@npm:^20.0.0":
-  version: 20.0.1
-  resolution: "@types/jsdom@npm:20.0.1"
+"@types/jsdom@npm:^21.1.7":
+  version: 21.1.7
+  resolution: "@types/jsdom@npm:21.1.7"
   dependencies:
     "@types/node": "npm:*"
     "@types/tough-cookie": "npm:*"
     parse5: "npm:^7.0.0"
-  checksum: 10c0/3d4b2a3eab145674ee6da482607c5e48977869109f0f62560bf91ae1a792c9e847ac7c6aaf243ed2e97333cb3c51aef314ffa54a19ef174b8f9592dfcb836b25
+  checksum: 10c0/c0c0025adc2b193e85453eeeea168bb909f0ebad08d6552be7474a407e9c163db8f696dcf1e3cbe8cb9c9d970ba45f4386171794509c1a0fe5d1fed72c91679d
   languageName: node
   linkType: hard
 
-"@types/json-schema@npm:^7.0.12":
+"@types/json-schema@npm:^7.0.15":
   version: 7.0.15
   resolution: "@types/json-schema@npm:7.0.15"
   checksum: 10c0/a996a745e6c5d60292f36731dd41341339d4eeed8180bb09226e5c8d23759067692b1d88e5d91d72ee83dfc00d3aca8e7bd43ea120516c17922cbcb7c3e252db
   languageName: node
   linkType: hard
 
-"@types/json5@npm:^0.0.29":
-  version: 0.0.29
-  resolution: "@types/json5@npm:0.0.29"
-  checksum: 10c0/6bf5337bc447b706bb5b4431d37686aa2ea6d07cfd6f79cc31de80170d6ff9b1c7384a9c0ccbc45b3f512bae9e9f75c2e12109806a15331dc94e8a8db6dbb4ac
-  languageName: node
-  linkType: hard
-
 "@types/mdast@npm:^4.0.0":
   version: 4.0.4
   resolution: "@types/mdast@npm:4.0.4"
@@ -3081,6 +3601,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/node@npm:^25.6.0":
+  version: 25.6.0
+  resolution: "@types/node@npm:25.6.0"
+  dependencies:
+    undici-types: "npm:~7.19.0"
+  checksum: 10c0/d2d2015630ff098a201407f55f5077a20270ae4f465c739b40865cd9933b91b9c5d2b85568eadaf3db0801b91e267333ca7eb39f007428b173d1cdab4b339ac5
+  languageName: node
+  linkType: hard
+
 "@types/normalize-package-data@npm:^2.4.0":
   version: 2.4.4
   resolution: "@types/normalize-package-data@npm:2.4.4"
@@ -3096,49 +3625,32 @@ __metadata:
   linkType: hard
 
 "@types/prop-types@npm:*":
-  version: 15.7.12
-  resolution: "@types/prop-types@npm:15.7.12"
-  checksum: 10c0/1babcc7db6a1177779f8fde0ccc78d64d459906e6ef69a4ed4dd6339c920c2e05b074ee5a92120fe4e9d9f1a01c952f843ebd550bee2332fc2ef81d1706878f8
-  languageName: node
-  linkType: hard
-
-"@types/react-dom@npm:^18.0.0":
-  version: 18.3.0
-  resolution: "@types/react-dom@npm:18.3.0"
-  dependencies:
-    "@types/react": "npm:*"
-  checksum: 10c0/6c90d2ed72c5a0e440d2c75d99287e4b5df3e7b011838cdc03ae5cd518ab52164d86990e73246b9d812eaf02ec351d74e3b4f5bd325bf341e13bf980392fd53b
+  version: 15.7.15
+  resolution: "@types/prop-types@npm:15.7.15"
+  checksum: 10c0/b59aad1ad19bf1733cf524fd4e618196c6c7690f48ee70a327eb450a42aab8e8a063fbe59ca0a5701aebe2d92d582292c0fb845ea57474f6a15f6994b0e260b2
   languageName: node
   linkType: hard
 
-"@types/react@npm:*":
-  version: 18.3.2
-  resolution: "@types/react@npm:18.3.2"
-  dependencies:
-    "@types/prop-types": "npm:*"
-    csstype: "npm:^3.0.2"
-  checksum: 10c0/9fb2f1fcf7e889ee4ea7c3c5978df595c66e770e5fd3a245dbdd2589b9b911524c11dab25a6275d8af4e336e4cb5fa850d447884b84c335a187a338c89df99ba
+"@types/react-dom@npm:^18.3.7":
+  version: 18.3.7
+  resolution: "@types/react-dom@npm:18.3.7"
+  peerDependencies:
+    "@types/react": ^18.0.0
+  checksum: 10c0/8bd309e2c3d1604a28a736a24f96cbadf6c05d5288cfef8883b74f4054c961b6b3a5e997fd5686e492be903c8f3380dba5ec017eff3906b1256529cd2d39603e
   languageName: node
   linkType: hard
 
-"@types/react@npm:~18.2.45":
-  version: 18.2.79
-  resolution: "@types/react@npm:18.2.79"
+"@types/react@npm:^18.3.28":
+  version: 18.3.28
+  resolution: "@types/react@npm:18.3.28"
   dependencies:
     "@types/prop-types": "npm:*"
-    csstype: "npm:^3.0.2"
-  checksum: 10c0/c8a8a005d8830a48cc1ef93c3510c4935a2a03e5557dbecaa8f1038450cbfcb18eb206fa7fba7077d54b8da21faeb25577e897a333392770a7797f625b62c78a
-  languageName: node
-  linkType: hard
-
-"@types/semver@npm:^7.5.0":
-  version: 7.5.8
-  resolution: "@types/semver@npm:7.5.8"
-  checksum: 10c0/8663ff927234d1c5fcc04b33062cb2b9fcfbe0f5f351ed26c4d1e1581657deebd506b41ff7fdf89e787e3d33ce05854bc01686379b89e9c49b564c4cfa988efa
+    csstype: "npm:^3.2.2"
+  checksum: 10c0/683e19cd12b5c691215529af2e32b5ffbaccae3bf0ba93bfafa0e460e8dfee18423afed568be2b8eadf4b837c3749dd296a4f64e2d79f68fa66962c05f5af661
   languageName: node
   linkType: hard
 
-"@types/stack-utils@npm:^2.0.0":
+"@types/stack-utils@npm:^2.0.3":
   version: 2.0.3
   resolution: "@types/stack-utils@npm:2.0.3"
   checksum: 10c0/1f4658385ae936330581bcb8aa3a066df03867d90281cdf89cc356d404bd6579be0f11902304e1f775d92df22c6dd761d4451c804b0a4fba973e06211e9bd77c
@@ -3196,159 +3708,157 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/yargs@npm:^17.0.8":
-  version: 17.0.32
-  resolution: "@types/yargs@npm:17.0.32"
+"@types/yargs@npm:^17.0.33":
+  version: 17.0.35
+  resolution: "@types/yargs@npm:17.0.35"
   dependencies:
     "@types/yargs-parser": "npm:*"
-  checksum: 10c0/2095e8aad8a4e66b86147415364266b8d607a3b95b4239623423efd7e29df93ba81bb862784a6e08664f645cc1981b25fd598f532019174cd3e5e1e689e1cccf
+  checksum: 10c0/609557826a6b85e73ccf587923f6429850d6dc70e420b455bab4601b670bfadf684b09ae288bccedab042c48ba65f1666133cf375814204b544009f57d6eef63
   languageName: node
   linkType: hard
 
-"@typescript-eslint/eslint-plugin@npm:^6.20.0":
-  version: 6.21.0
-  resolution: "@typescript-eslint/eslint-plugin@npm:6.21.0"
+"@typescript-eslint/eslint-plugin@npm:8.59.0":
+  version: 8.59.0
+  resolution: "@typescript-eslint/eslint-plugin@npm:8.59.0"
   dependencies:
-    "@eslint-community/regexpp": "npm:^4.5.1"
-    "@typescript-eslint/scope-manager": "npm:6.21.0"
-    "@typescript-eslint/type-utils": "npm:6.21.0"
-    "@typescript-eslint/utils": "npm:6.21.0"
-    "@typescript-eslint/visitor-keys": "npm:6.21.0"
-    debug: "npm:^4.3.4"
-    graphemer: "npm:^1.4.0"
-    ignore: "npm:^5.2.4"
+    "@eslint-community/regexpp": "npm:^4.12.2"
+    "@typescript-eslint/scope-manager": "npm:8.59.0"
+    "@typescript-eslint/type-utils": "npm:8.59.0"
+    "@typescript-eslint/utils": "npm:8.59.0"
+    "@typescript-eslint/visitor-keys": "npm:8.59.0"
+    ignore: "npm:^7.0.5"
     natural-compare: "npm:^1.4.0"
-    semver: "npm:^7.5.4"
-    ts-api-utils: "npm:^1.0.1"
+    ts-api-utils: "npm:^2.5.0"
   peerDependencies:
-    "@typescript-eslint/parser": ^6.0.0 || ^6.0.0-alpha
-    eslint: ^7.0.0 || ^8.0.0
-  peerDependenciesMeta:
-    typescript:
-      optional: true
-  checksum: 10c0/f911a79ee64d642f814a3b6cdb0d324b5f45d9ef955c5033e78903f626b7239b4aa773e464a38c3e667519066169d983538f2bf8e5d00228af587c9d438fb344
+    "@typescript-eslint/parser": ^8.59.0
+    eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+    typescript: ">=4.8.4 <6.1.0"
+  checksum: 10c0/f98171ecad6a5106fe978df155f4b65a72dfdadfcd663651b633b61480b543e74796baa224a1393e323f9514901604fe6302323c4b80b79f7a98512a01bc6461
   languageName: node
   linkType: hard
 
-"@typescript-eslint/parser@npm:^6.4.0":
-  version: 6.21.0
-  resolution: "@typescript-eslint/parser@npm:6.21.0"
+"@typescript-eslint/parser@npm:8.59.0":
+  version: 8.59.0
+  resolution: "@typescript-eslint/parser@npm:8.59.0"
   dependencies:
-    "@typescript-eslint/scope-manager": "npm:6.21.0"
-    "@typescript-eslint/types": "npm:6.21.0"
-    "@typescript-eslint/typescript-estree": "npm:6.21.0"
-    "@typescript-eslint/visitor-keys": "npm:6.21.0"
-    debug: "npm:^4.3.4"
+    "@typescript-eslint/scope-manager": "npm:8.59.0"
+    "@typescript-eslint/types": "npm:8.59.0"
+    "@typescript-eslint/typescript-estree": "npm:8.59.0"
+    "@typescript-eslint/visitor-keys": "npm:8.59.0"
+    debug: "npm:^4.4.3"
   peerDependencies:
-    eslint: ^7.0.0 || ^8.0.0
-  peerDependenciesMeta:
-    typescript:
-      optional: true
-  checksum: 10c0/a8f99820679decd0d115c0af61903fb1de3b1b5bec412dc72b67670bf636de77ab07f2a68ee65d6da7976039bbf636907f9d5ca546db3f0b98a31ffbc225bc7d
+    eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+    typescript: ">=4.8.4 <6.1.0"
+  checksum: 10c0/996a7b43f8a515ebbd06455c9f53065c561c8519bc4f634d6783b92832aa69e47945478d1601a87582f9f7b303becc172d5d7f776e201b2a2d375bc762ad4015
   languageName: node
   linkType: hard
 
-"@typescript-eslint/scope-manager@npm:6.21.0":
-  version: 6.21.0
-  resolution: "@typescript-eslint/scope-manager@npm:6.21.0"
+"@typescript-eslint/project-service@npm:8.59.0":
+  version: 8.59.0
+  resolution: "@typescript-eslint/project-service@npm:8.59.0"
   dependencies:
-    "@typescript-eslint/types": "npm:6.21.0"
-    "@typescript-eslint/visitor-keys": "npm:6.21.0"
-  checksum: 10c0/eaf868938d811cbbea33e97e44ba7050d2b6892202cea6a9622c486b85ab1cf801979edf78036179a8ba4ac26f1dfdf7fcc83a68c1ff66be0b3a8e9a9989b526
+    "@typescript-eslint/tsconfig-utils": "npm:^8.59.0"
+    "@typescript-eslint/types": "npm:^8.59.0"
+    debug: "npm:^4.4.3"
+  peerDependencies:
+    typescript: ">=4.8.4 <6.1.0"
+  checksum: 10c0/ffba9595a427235bbeb0e5c7db3486f8d01dd8f8686964b4f82084e82008c49b897d01c4d331f33a9ce29edae70a9286f6fdedec4bf9037d732d9c9e86ebc7ea
   languageName: node
   linkType: hard
 
-"@typescript-eslint/type-utils@npm:6.21.0":
-  version: 6.21.0
-  resolution: "@typescript-eslint/type-utils@npm:6.21.0"
+"@typescript-eslint/scope-manager@npm:8.59.0":
+  version: 8.59.0
+  resolution: "@typescript-eslint/scope-manager@npm:8.59.0"
   dependencies:
-    "@typescript-eslint/typescript-estree": "npm:6.21.0"
-    "@typescript-eslint/utils": "npm:6.21.0"
-    debug: "npm:^4.3.4"
-    ts-api-utils: "npm:^1.0.1"
-  peerDependencies:
-    eslint: ^7.0.0 || ^8.0.0
-  peerDependenciesMeta:
-    typescript:
-      optional: true
-  checksum: 10c0/7409c97d1c4a4386b488962739c4f1b5b04dc60cf51f8cd88e6b12541f84d84c6b8b67e491a147a2c95f9ec486539bf4519fb9d418411aef6537b9c156468117
+    "@typescript-eslint/types": "npm:8.59.0"
+    "@typescript-eslint/visitor-keys": "npm:8.59.0"
+  checksum: 10c0/d372f08be190d01e6d237932dc0d77808a9dc0a34fe8f690a3eac496d6e2f93c030c6ccb5000b35e825a6cfc4d9ca69a00f2ccda334115a9865a9d02cd603e52
   languageName: node
   linkType: hard
 
-"@typescript-eslint/types@npm:6.21.0":
-  version: 6.21.0
-  resolution: "@typescript-eslint/types@npm:6.21.0"
-  checksum: 10c0/020631d3223bbcff8a0da3efbdf058220a8f48a3de221563996ad1dcc30d6c08dadc3f7608cc08830d21c0d565efd2db19b557b9528921c78aabb605eef2d74d
+"@typescript-eslint/tsconfig-utils@npm:8.59.0, @typescript-eslint/tsconfig-utils@npm:^8.59.0":
+  version: 8.59.0
+  resolution: "@typescript-eslint/tsconfig-utils@npm:8.59.0"
+  peerDependencies:
+    typescript: ">=4.8.4 <6.1.0"
+  checksum: 10c0/ab482c22f23774d24b3048c9fcdc5e0b94137064b3af901f4b0327da2270c2b2961c19165ccf8bdeaedfa83138be98c5cd8edcdc89deb6187baf6438cd8584b0
   languageName: node
   linkType: hard
 
-"@typescript-eslint/typescript-estree@npm:6.21.0":
-  version: 6.21.0
-  resolution: "@typescript-eslint/typescript-estree@npm:6.21.0"
+"@typescript-eslint/type-utils@npm:8.59.0":
+  version: 8.59.0
+  resolution: "@typescript-eslint/type-utils@npm:8.59.0"
   dependencies:
-    "@typescript-eslint/types": "npm:6.21.0"
-    "@typescript-eslint/visitor-keys": "npm:6.21.0"
-    debug: "npm:^4.3.4"
-    globby: "npm:^11.1.0"
-    is-glob: "npm:^4.0.3"
-    minimatch: "npm:9.0.3"
-    semver: "npm:^7.5.4"
-    ts-api-utils: "npm:^1.0.1"
-  peerDependenciesMeta:
-    typescript:
-      optional: true
-  checksum: 10c0/af1438c60f080045ebb330155a8c9bb90db345d5069cdd5d01b67de502abb7449d6c75500519df829f913a6b3f490ade3e8215279b6bdc63d0fb0ae61034df5f
+    "@typescript-eslint/types": "npm:8.59.0"
+    "@typescript-eslint/typescript-estree": "npm:8.59.0"
+    "@typescript-eslint/utils": "npm:8.59.0"
+    debug: "npm:^4.4.3"
+    ts-api-utils: "npm:^2.5.0"
+  peerDependencies:
+    eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+    typescript: ">=4.8.4 <6.1.0"
+  checksum: 10c0/e2f2176a9bce81c19b53accf4e9189c60b1b84717cf129a6d003a2271019e30d410d2ccdc0fc6a37cbb8274a1b297d7d30a116189110f9d24a86391ee24a9fef
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/types@npm:8.59.0, @typescript-eslint/types@npm:^8.59.0":
+  version: 8.59.0
+  resolution: "@typescript-eslint/types@npm:8.59.0"
+  checksum: 10c0/2750b1e21290dffe90a424fe05c2bab701f60a7b51b5e0921ed14bb1a5fc29ff3fe8f286817d2287e93ff78e33e6626f6ce26d0bc79a729bd608deda77a9bdde
   languageName: node
   linkType: hard
 
-"@typescript-eslint/utils@npm:6.21.0":
-  version: 6.21.0
-  resolution: "@typescript-eslint/utils@npm:6.21.0"
+"@typescript-eslint/typescript-estree@npm:8.59.0":
+  version: 8.59.0
+  resolution: "@typescript-eslint/typescript-estree@npm:8.59.0"
   dependencies:
-    "@eslint-community/eslint-utils": "npm:^4.4.0"
-    "@types/json-schema": "npm:^7.0.12"
-    "@types/semver": "npm:^7.5.0"
-    "@typescript-eslint/scope-manager": "npm:6.21.0"
-    "@typescript-eslint/types": "npm:6.21.0"
-    "@typescript-eslint/typescript-estree": "npm:6.21.0"
-    semver: "npm:^7.5.4"
+    "@typescript-eslint/project-service": "npm:8.59.0"
+    "@typescript-eslint/tsconfig-utils": "npm:8.59.0"
+    "@typescript-eslint/types": "npm:8.59.0"
+    "@typescript-eslint/visitor-keys": "npm:8.59.0"
+    debug: "npm:^4.4.3"
+    minimatch: "npm:^10.2.2"
+    semver: "npm:^7.7.3"
+    tinyglobby: "npm:^0.2.15"
+    ts-api-utils: "npm:^2.5.0"
   peerDependencies:
-    eslint: ^7.0.0 || ^8.0.0
-  checksum: 10c0/ab2df3833b2582d4e5467a484d08942b4f2f7208f8e09d67de510008eb8001a9b7460f2f9ba11c12086fd3cdcac0c626761c7995c2c6b5657d5fa6b82030a32d
+    typescript: ">=4.8.4 <6.1.0"
+  checksum: 10c0/82d3dfb4de591d9a39d2c4dafc13f14b4940f5b116fb3db311935137aa7e34c9dce3209aaeace118070847b2355df7c185ff1e0f2a36232c3aea9b5fa2652f98
   languageName: node
   linkType: hard
 
-"@typescript-eslint/visitor-keys@npm:6.21.0":
-  version: 6.21.0
-  resolution: "@typescript-eslint/visitor-keys@npm:6.21.0"
+"@typescript-eslint/utils@npm:8.59.0, @typescript-eslint/utils@npm:^8.13.0":
+  version: 8.59.0
+  resolution: "@typescript-eslint/utils@npm:8.59.0"
   dependencies:
-    "@typescript-eslint/types": "npm:6.21.0"
-    eslint-visitor-keys: "npm:^3.4.1"
-  checksum: 10c0/7395f69739cfa1cb83c1fb2fad30afa2a814756367302fb4facd5893eff66abc807e8d8f63eba94ed3b0fe0c1c996ac9a1680bcbf0f83717acedc3f2bb724fbf
+    "@eslint-community/eslint-utils": "npm:^4.9.1"
+    "@typescript-eslint/scope-manager": "npm:8.59.0"
+    "@typescript-eslint/types": "npm:8.59.0"
+    "@typescript-eslint/typescript-estree": "npm:8.59.0"
+  peerDependencies:
+    eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+    typescript: ">=4.8.4 <6.1.0"
+  checksum: 10c0/eca4e5a18ae8e8c4360b05758fa142465daef3a9dffe4d78b15607b4680698eece96f899bce1e8d83427da74ddfbca80a95456727b8b9239816528978180b047
   languageName: node
   linkType: hard
 
-"@ungap/promise-all-settled@npm:1.1.2":
-  version: 1.1.2
-  resolution: "@ungap/promise-all-settled@npm:1.1.2"
-  checksum: 10c0/7f9862bae3b6ce30675783428933be1738dca278901a6bcb55c29b8f54c08863ec8e6a7c884119877d90336501c33b7cfda36355ec7af4d703f65f54cb768913
+"@typescript-eslint/visitor-keys@npm:8.59.0":
+  version: 8.59.0
+  resolution: "@typescript-eslint/visitor-keys@npm:8.59.0"
+  dependencies:
+    "@typescript-eslint/types": "npm:8.59.0"
+    eslint-visitor-keys: "npm:^5.0.0"
+  checksum: 10c0/09ec24c9c9d0a3ccb57bb2ab3dfd8deca124339aba6621503285c22765a4dfc89bf3d31e337dd647b1cdf89bac384e3a62e0f5b8c1d5a93d16d1f417144e3226
   languageName: node
   linkType: hard
 
-"@ungap/structured-clone@npm:^1.0.0":
+"@ungap/structured-clone@npm:^1.0.0, @ungap/structured-clone@npm:^1.3.0":
   version: 1.3.0
   resolution: "@ungap/structured-clone@npm:1.3.0"
   checksum: 10c0/0fc3097c2540ada1fc340ee56d58d96b5b536a2a0dab6e3ec17d4bfc8c4c86db345f61a375a8185f9da96f01c69678f836a2b57eeaa9e4b8eeafd26428e57b0a
   languageName: node
   linkType: hard
 
-"@ungap/structured-clone@npm:^1.2.0":
-  version: 1.2.0
-  resolution: "@ungap/structured-clone@npm:1.2.0"
-  checksum: 10c0/8209c937cb39119f44eb63cf90c0b73e7c754209a6411c707be08e50e29ee81356dca1a848a405c8bdeebfe2f5e4f831ad310ae1689eeef65e7445c090c6657d
-  languageName: node
-  linkType: hard
-
 "@unhead/react@npm:^2.1.2":
   version: 2.1.2
   resolution: "@unhead/react@npm:2.1.2"
@@ -3360,110 +3870,310 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@yarnpkg/lockfile@npm:^1.1.0":
-  version: 1.1.0
-  resolution: "@yarnpkg/lockfile@npm:1.1.0"
-  checksum: 10c0/0bfa50a3d756623d1f3409bc23f225a1d069424dbc77c6fd2f14fb377390cd57ec703dc70286e081c564be9051ead9ba85d81d66a3e68eeb6eb506d4e0c0fbda
+"@unrs/resolver-binding-android-arm-eabi@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-android-arm-eabi@npm:1.11.1"
+  conditions: os=android & cpu=arm
   languageName: node
   linkType: hard
 
-"@yarnpkg/parsers@npm:3.0.2":
-  version: 3.0.2
-  resolution: "@yarnpkg/parsers@npm:3.0.2"
-  dependencies:
-    js-yaml: "npm:^3.10.0"
-    tslib: "npm:^2.4.0"
-  checksum: 10c0/a0c340e13129643162423d7e666061c0b39b143bfad3fc5a74c7d92a30fd740f6665d41cd4e61832c20375889d793eea1d1d103cacb39ed68f7acd168add8c53
+"@unrs/resolver-binding-android-arm64@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-android-arm64@npm:1.11.1"
+  conditions: os=android & cpu=arm64
   languageName: node
   linkType: hard
 
-"@zkochan/js-yaml@npm:0.0.7":
-  version: 0.0.7
-  resolution: "@zkochan/js-yaml@npm:0.0.7"
-  dependencies:
-    argparse: "npm:^2.0.1"
-  bin:
-    js-yaml: bin/js-yaml.js
-  checksum: 10c0/c8b3525717912811f9422ed50e94c5751ed6f771eb1b7e5cde097f14835654931e2bdaecb1e5fc37b51cf8d822410a307f16dd1581d46149398c30215f3f9bac
+"@unrs/resolver-binding-darwin-arm64@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-darwin-arm64@npm:1.11.1"
+  conditions: os=darwin & cpu=arm64
   languageName: node
   linkType: hard
 
-"JSONStream@npm:^1.3.5":
-  version: 1.3.5
-  resolution: "JSONStream@npm:1.3.5"
-  dependencies:
-    jsonparse: "npm:^1.2.0"
-    through: "npm:>=2.2.7 <3"
-  bin:
-    JSONStream: ./bin.js
-  checksum: 10c0/0f54694da32224d57b715385d4a6b668d2117379d1f3223dc758459246cca58fdc4c628b83e8a8883334e454a0a30aa198ede77c788b55537c1844f686a751f2
+"@unrs/resolver-binding-darwin-x64@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-darwin-x64@npm:1.11.1"
+  conditions: os=darwin & cpu=x64
   languageName: node
   linkType: hard
 
-"abab@npm:^2.0.6":
-  version: 2.0.6
-  resolution: "abab@npm:2.0.6"
-  checksum: 10c0/0b245c3c3ea2598fe0025abf7cc7bb507b06949d51e8edae5d12c1b847a0a0c09639abcb94788332b4e2044ac4491c1e8f571b51c7826fd4b0bda1685ad4a278
+"@unrs/resolver-binding-freebsd-x64@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-freebsd-x64@npm:1.11.1"
+  conditions: os=freebsd & cpu=x64
   languageName: node
   linkType: hard
 
-"abbrev@npm:1":
-  version: 1.1.1
-  resolution: "abbrev@npm:1.1.1"
-  checksum: 10c0/3f762677702acb24f65e813070e306c61fafe25d4b2583f9dfc935131f774863f3addd5741572ed576bd69cabe473c5af18e1e108b829cb7b6b4747884f726e6
+"@unrs/resolver-binding-linux-arm-gnueabihf@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-linux-arm-gnueabihf@npm:1.11.1"
+  conditions: os=linux & cpu=arm
   languageName: node
   linkType: hard
 
-"abbrev@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "abbrev@npm:2.0.0"
-  checksum: 10c0/f742a5a107473946f426c691c08daba61a1d15942616f300b5d32fd735be88fef5cba24201757b6c407fd564555fb48c751cfa33519b2605c8a7aadd22baf372
+"@unrs/resolver-binding-linux-arm-musleabihf@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-linux-arm-musleabihf@npm:1.11.1"
+  conditions: os=linux & cpu=arm
   languageName: node
   linkType: hard
 
-"abbrev@npm:^3.0.0":
-  version: 3.0.1
-  resolution: "abbrev@npm:3.0.1"
-  checksum: 10c0/21ba8f574ea57a3106d6d35623f2c4a9111d9ee3e9a5be47baed46ec2457d2eac46e07a5c4a60186f88cb98abbe3e24f2d4cca70bc2b12f1692523e2209a9ccf
+"@unrs/resolver-binding-linux-arm64-gnu@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-linux-arm64-gnu@npm:1.11.1"
+  conditions: os=linux & cpu=arm64 & libc=glibc
   languageName: node
   linkType: hard
 
-"abbrev@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "abbrev@npm:4.0.0"
-  checksum: 10c0/b4cc16935235e80702fc90192e349e32f8ef0ed151ef506aa78c81a7c455ec18375c4125414b99f84b2e055199d66383e787675f0bcd87da7a4dbd59f9eac1d5
+"@unrs/resolver-binding-linux-arm64-musl@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-linux-arm64-musl@npm:1.11.1"
+  conditions: os=linux & cpu=arm64 & libc=musl
   languageName: node
   linkType: hard
 
-"abort-controller@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "abort-controller@npm:3.0.0"
-  dependencies:
-    event-target-shim: "npm:^5.0.0"
-  checksum: 10c0/90ccc50f010250152509a344eb2e71977fbf8db0ab8f1061197e3275ddf6c61a41a6edfd7b9409c664513131dd96e962065415325ef23efa5db931b382d24ca5
+"@unrs/resolver-binding-linux-ppc64-gnu@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-linux-ppc64-gnu@npm:1.11.1"
+  conditions: os=linux & cpu=ppc64 & libc=glibc
   languageName: node
   linkType: hard
 
-"acorn-globals@npm:^7.0.0":
-  version: 7.0.1
-  resolution: "acorn-globals@npm:7.0.1"
-  dependencies:
-    acorn: "npm:^8.1.0"
-    acorn-walk: "npm:^8.0.2"
-  checksum: 10c0/7437f58e92d99292dbebd0e79531af27d706c9f272f31c675d793da6c82d897e75302a8744af13c7f7978a8399840f14a353b60cf21014647f71012982456d2b
+"@unrs/resolver-binding-linux-riscv64-gnu@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-linux-riscv64-gnu@npm:1.11.1"
+  conditions: os=linux & cpu=riscv64 & libc=glibc
   languageName: node
   linkType: hard
 
-"acorn-jsx@npm:^5.0.0, acorn-jsx@npm:^5.3.2":
-  version: 5.3.2
-  resolution: "acorn-jsx@npm:5.3.2"
-  peerDependencies:
+"@unrs/resolver-binding-linux-riscv64-musl@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-linux-riscv64-musl@npm:1.11.1"
+  conditions: os=linux & cpu=riscv64 & libc=musl
+  languageName: node
+  linkType: hard
+
+"@unrs/resolver-binding-linux-s390x-gnu@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-linux-s390x-gnu@npm:1.11.1"
+  conditions: os=linux & cpu=s390x & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@unrs/resolver-binding-linux-x64-gnu@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-linux-x64-gnu@npm:1.11.1"
+  conditions: os=linux & cpu=x64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@unrs/resolver-binding-linux-x64-musl@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-linux-x64-musl@npm:1.11.1"
+  conditions: os=linux & cpu=x64 & libc=musl
+  languageName: node
+  linkType: hard
+
+"@unrs/resolver-binding-wasm32-wasi@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-wasm32-wasi@npm:1.11.1"
+  dependencies:
+    "@napi-rs/wasm-runtime": "npm:^0.2.11"
+  conditions: cpu=wasm32
+  languageName: node
+  linkType: hard
+
+"@unrs/resolver-binding-win32-arm64-msvc@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-win32-arm64-msvc@npm:1.11.1"
+  conditions: os=win32 & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@unrs/resolver-binding-win32-ia32-msvc@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-win32-ia32-msvc@npm:1.11.1"
+  conditions: os=win32 & cpu=ia32
+  languageName: node
+  linkType: hard
+
+"@unrs/resolver-binding-win32-x64-msvc@npm:1.11.1":
+  version: 1.11.1
+  resolution: "@unrs/resolver-binding-win32-x64-msvc@npm:1.11.1"
+  conditions: os=win32 & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@vitest/expect@npm:4.1.5":
+  version: 4.1.5
+  resolution: "@vitest/expect@npm:4.1.5"
+  dependencies:
+    "@standard-schema/spec": "npm:^1.1.0"
+    "@types/chai": "npm:^5.2.2"
+    "@vitest/spy": "npm:4.1.5"
+    "@vitest/utils": "npm:4.1.5"
+    chai: "npm:^6.2.2"
+    tinyrainbow: "npm:^3.1.0"
+  checksum: 10c0/5184682304db471aa20024c1154210ad3d6d590afb61646201ce1a15297259f9a35f92f8fad4435bc8a82135e307ddd27c8495f72417d72d9aa139eb281d9e06
+  languageName: node
+  linkType: hard
+
+"@vitest/mocker@npm:4.1.5":
+  version: 4.1.5
+  resolution: "@vitest/mocker@npm:4.1.5"
+  dependencies:
+    "@vitest/spy": "npm:4.1.5"
+    estree-walker: "npm:^3.0.3"
+    magic-string: "npm:^0.30.21"
+  peerDependencies:
+    msw: ^2.4.9
+    vite: ^6.0.0 || ^7.0.0 || ^8.0.0
+  peerDependenciesMeta:
+    msw:
+      optional: true
+    vite:
+      optional: true
+  checksum: 10c0/bcfe97700476130933c7ea33fa670c8d2768a81de5325ce407f901e55c2f66cabbb88a7b6cffb46ddf33dff7d8fc209d769fb298f568e310fbeead9b36f6fdb9
+  languageName: node
+  linkType: hard
+
+"@vitest/pretty-format@npm:4.1.5":
+  version: 4.1.5
+  resolution: "@vitest/pretty-format@npm:4.1.5"
+  dependencies:
+    tinyrainbow: "npm:^3.1.0"
+  checksum: 10c0/42b5e9b75e87c0a884d36bee364e2d07ee45e96f413377737a74993e077d90c3a12aa36743855aee5e4e28b78fae20e3e6de5eef8d5344b9aba2bc1e1d5537a1
+  languageName: node
+  linkType: hard
+
+"@vitest/runner@npm:4.1.5":
+  version: 4.1.5
+  resolution: "@vitest/runner@npm:4.1.5"
+  dependencies:
+    "@vitest/utils": "npm:4.1.5"
+    pathe: "npm:^2.0.3"
+  checksum: 10c0/6a03b313a121155f6dd9e32eeb103c0e12440f586bc4ba1f0d77444e44c6df4652a44443718552037463115635b8378e11f35902d90ce1326f77743219fca056
+  languageName: node
+  linkType: hard
+
+"@vitest/snapshot@npm:4.1.5":
+  version: 4.1.5
+  resolution: "@vitest/snapshot@npm:4.1.5"
+  dependencies:
+    "@vitest/pretty-format": "npm:4.1.5"
+    "@vitest/utils": "npm:4.1.5"
+    magic-string: "npm:^0.30.21"
+    pathe: "npm:^2.0.3"
+  checksum: 10c0/e11bf50d06702331290750a40eaef86078c108df3cd9a52bb1be7b84250048790163f36827525be6a383a4bb1994fc35e6d0c24239a41688b0bb68a1d15d172f
+  languageName: node
+  linkType: hard
+
+"@vitest/spy@npm:4.1.5":
+  version: 4.1.5
+  resolution: "@vitest/spy@npm:4.1.5"
+  checksum: 10c0/fda6b1ee0a2fec1a152d8041aba7a79744c3876863b244d1ed406d02b36e8ccc997edb2e3963d1027d728d3dc5a33813e11bef53a0a14fc7de4de5e721d0f591
+  languageName: node
+  linkType: hard
+
+"@vitest/utils@npm:4.1.5":
+  version: 4.1.5
+  resolution: "@vitest/utils@npm:4.1.5"
+  dependencies:
+    "@vitest/pretty-format": "npm:4.1.5"
+    convert-source-map: "npm:^2.0.0"
+    tinyrainbow: "npm:^3.1.0"
+  checksum: 10c0/72409717e68018e5fe42fa173cc4eff6def8c35bd52013f86ddb414cd28d73fcc425ac62968e01a52371b3fd5a7a775536283d2f1d64432753f628712a6a4908
+  languageName: node
+  linkType: hard
+
+"@yarnpkg/lockfile@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "@yarnpkg/lockfile@npm:1.1.0"
+  checksum: 10c0/0bfa50a3d756623d1f3409bc23f225a1d069424dbc77c6fd2f14fb377390cd57ec703dc70286e081c564be9051ead9ba85d81d66a3e68eeb6eb506d4e0c0fbda
+  languageName: node
+  linkType: hard
+
+"@yarnpkg/parsers@npm:3.0.2":
+  version: 3.0.2
+  resolution: "@yarnpkg/parsers@npm:3.0.2"
+  dependencies:
+    js-yaml: "npm:^3.10.0"
+    tslib: "npm:^2.4.0"
+  checksum: 10c0/a0c340e13129643162423d7e666061c0b39b143bfad3fc5a74c7d92a30fd740f6665d41cd4e61832c20375889d793eea1d1d103cacb39ed68f7acd168add8c53
+  languageName: node
+  linkType: hard
+
+"@zkochan/js-yaml@npm:0.0.7":
+  version: 0.0.7
+  resolution: "@zkochan/js-yaml@npm:0.0.7"
+  dependencies:
+    argparse: "npm:^2.0.1"
+  bin:
+    js-yaml: bin/js-yaml.js
+  checksum: 10c0/c8b3525717912811f9422ed50e94c5751ed6f771eb1b7e5cde097f14835654931e2bdaecb1e5fc37b51cf8d822410a307f16dd1581d46149398c30215f3f9bac
+  languageName: node
+  linkType: hard
+
+"JSONStream@npm:^1.3.5":
+  version: 1.3.5
+  resolution: "JSONStream@npm:1.3.5"
+  dependencies:
+    jsonparse: "npm:^1.2.0"
+    through: "npm:>=2.2.7 <3"
+  bin:
+    JSONStream: ./bin.js
+  checksum: 10c0/0f54694da32224d57b715385d4a6b668d2117379d1f3223dc758459246cca58fdc4c628b83e8a8883334e454a0a30aa198ede77c788b55537c1844f686a751f2
+  languageName: node
+  linkType: hard
+
+"abbrev@npm:1":
+  version: 1.1.1
+  resolution: "abbrev@npm:1.1.1"
+  checksum: 10c0/3f762677702acb24f65e813070e306c61fafe25d4b2583f9dfc935131f774863f3addd5741572ed576bd69cabe473c5af18e1e108b829cb7b6b4747884f726e6
+  languageName: node
+  linkType: hard
+
+"abbrev@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "abbrev@npm:2.0.0"
+  checksum: 10c0/f742a5a107473946f426c691c08daba61a1d15942616f300b5d32fd735be88fef5cba24201757b6c407fd564555fb48c751cfa33519b2605c8a7aadd22baf372
+  languageName: node
+  linkType: hard
+
+"abbrev@npm:^3.0.0":
+  version: 3.0.1
+  resolution: "abbrev@npm:3.0.1"
+  checksum: 10c0/21ba8f574ea57a3106d6d35623f2c4a9111d9ee3e9a5be47baed46ec2457d2eac46e07a5c4a60186f88cb98abbe3e24f2d4cca70bc2b12f1692523e2209a9ccf
+  languageName: node
+  linkType: hard
+
+"abbrev@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "abbrev@npm:4.0.0"
+  checksum: 10c0/b4cc16935235e80702fc90192e349e32f8ef0ed151ef506aa78c81a7c455ec18375c4125414b99f84b2e055199d66383e787675f0bcd87da7a4dbd59f9eac1d5
+  languageName: node
+  linkType: hard
+
+"abort-controller@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "abort-controller@npm:3.0.0"
+  dependencies:
+    event-target-shim: "npm:^5.0.0"
+  checksum: 10c0/90ccc50f010250152509a344eb2e71977fbf8db0ab8f1061197e3275ddf6c61a41a6edfd7b9409c664513131dd96e962065415325ef23efa5db931b382d24ca5
+  languageName: node
+  linkType: hard
+
+"acorn-jsx@npm:^5.0.0, acorn-jsx@npm:^5.3.2":
+  version: 5.3.2
+  resolution: "acorn-jsx@npm:5.3.2"
+  peerDependencies:
     acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
   checksum: 10c0/4c54868fbef3b8d58927d5e33f0a4de35f59012fe7b12cf9dfbb345fb8f46607709e1c4431be869a23fb63c151033d84c4198fa9f79385cec34fcb1dd53974c1
   languageName: node
   linkType: hard
 
-"acorn-walk@npm:^8.0.2, acorn-walk@npm:^8.1.1, acorn-walk@npm:^8.3.2":
+"acorn-walk@npm:^8.1.1":
   version: 8.3.2
   resolution: "acorn-walk@npm:8.3.2"
   checksum: 10c0/7e2a8dad5480df7f872569b9dccff2f3da7e65f5353686b1d6032ab9f4ddf6e3a2cb83a9b52cf50b1497fd522154dda92f0abf7153290cc79cd14721ff121e52
@@ -3479,7 +4189,16 @@ __metadata:
   languageName: node
   linkType: hard
 
-"acorn@npm:^8.1.0, acorn@npm:^8.4.1, acorn@npm:^8.8.1, acorn@npm:^8.8.2, acorn@npm:^8.9.0":
+"acorn@npm:^8.15.0":
+  version: 8.16.0
+  resolution: "acorn@npm:8.16.0"
+  bin:
+    acorn: bin/acorn
+  checksum: 10c0/c9c52697227661b68d0debaf972222d4f622aa06b185824164e153438afa7b08273432ca43ea792cadb24dada1d46f6f6bb1ef8de9956979288cc1b96bf9914e
+  languageName: node
+  linkType: hard
+
+"acorn@npm:^8.4.1":
   version: 8.11.3
   resolution: "acorn@npm:8.11.3"
   bin:
@@ -3513,6 +4232,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"agent-base@npm:^7.1.2":
+  version: 7.1.4
+  resolution: "agent-base@npm:7.1.4"
+  checksum: 10c0/c2c9ab7599692d594b6a161559ada307b7a624fa4c7b03e3afdb5a5e31cd0e53269115b620fcab024c5ac6a6f37fa5eb2e004f076ad30f5f7e6b8b671f7b35fe
+  languageName: node
+  linkType: hard
+
 "agentkeepalive@npm:^4.1.3":
   version: 4.5.0
   resolution: "agentkeepalive@npm:4.5.0"
@@ -3541,15 +4267,15 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ajv@npm:^6.12.4":
-  version: 6.12.6
-  resolution: "ajv@npm:6.12.6"
+"ajv@npm:^6.14.0":
+  version: 6.15.0
+  resolution: "ajv@npm:6.15.0"
   dependencies:
     fast-deep-equal: "npm:^3.1.1"
     fast-json-stable-stringify: "npm:^2.0.0"
     json-schema-traverse: "npm:^0.4.1"
     uri-js: "npm:^4.2.2"
-  checksum: 10c0/41e23642cbe545889245b9d2a45854ebba51cda6c778ebced9649420d9205f2efb39cb43dbc41e358409223b1ea43303ae4839db682c848b891e4811da1a5a71
+  checksum: 10c0/67966499dd272ecde1c2e467084411132891523d057487587879d39ac04207f4351b7b2324c83198013967fbfa632c1612adc960114a30770fbe07a0773b32c2
   languageName: node
   linkType: hard
 
@@ -3565,13 +4291,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ansi-colors@npm:4.1.1":
-  version: 4.1.1
-  resolution: "ansi-colors@npm:4.1.1"
-  checksum: 10c0/6086ade4336b4250b6b25e144b83e5623bcaf654d3df0c3546ce09c9c5ff999cb6a6f00c87e802d05cf98aef79d92dc76ade2670a2493b8dcb80220bec457838
-  languageName: node
-  linkType: hard
-
 "ansi-colors@npm:^4.1.1":
   version: 4.1.3
   resolution: "ansi-colors@npm:4.1.3"
@@ -3579,7 +4298,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ansi-escapes@npm:^4.2.1":
+"ansi-escapes@npm:^4.3.2":
   version: 4.3.2
   resolution: "ansi-escapes@npm:4.3.2"
   dependencies:
@@ -3595,13 +4314,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ansi-regex@npm:^3.0.0":
-  version: 3.0.1
-  resolution: "ansi-regex@npm:3.0.1"
-  checksum: 10c0/d108a7498b8568caf4a46eea4f1784ab4e0dfb2e3f3938c697dee21443d622d765c958f2b7e2b9f6b9e55e2e2af0584eaa9915d51782b89a841c28e744e7a167
-  languageName: node
-  linkType: hard
-
 "ansi-regex@npm:^5.0.1":
   version: 5.0.1
   resolution: "ansi-regex@npm:5.0.1"
@@ -3648,7 +4360,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"anymatch@npm:^3.0.3, anymatch@npm:~3.1.1, anymatch@npm:~3.1.2":
+"anymatch@npm:^3.1.3, anymatch@npm:~3.1.2":
   version: 3.1.3
   resolution: "anymatch@npm:3.1.3"
   dependencies:
@@ -3717,6 +4429,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"array-buffer-byte-length@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "array-buffer-byte-length@npm:1.0.2"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    is-array-buffer: "npm:^3.0.5"
+  checksum: 10c0/74e1d2d996941c7a1badda9cabb7caab8c449db9086407cad8a1b71d2604cc8abf105db8ca4e02c04579ec58b7be40279ddb09aea4784832984485499f48432d
+  languageName: node
+  linkType: hard
+
 "array-differ@npm:^3.0.0":
   version: 3.0.0
   resolution: "array-differ@npm:3.0.0"
@@ -3731,7 +4453,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"array-includes@npm:^3.1.6, array-includes@npm:^3.1.7":
+"array-includes@npm:^3.1.6":
   version: 3.1.8
   resolution: "array-includes@npm:3.1.8"
   dependencies:
@@ -3745,6 +4467,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"array-includes@npm:^3.1.8":
+  version: 3.1.9
+  resolution: "array-includes@npm:3.1.9"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.4"
+    define-properties: "npm:^1.2.1"
+    es-abstract: "npm:^1.24.0"
+    es-object-atoms: "npm:^1.1.1"
+    get-intrinsic: "npm:^1.3.0"
+    is-string: "npm:^1.1.1"
+    math-intrinsics: "npm:^1.1.0"
+  checksum: 10c0/0235fa69078abeac05ac4250699c44996bc6f774a9cbe45db48674ce6bd142f09b327d31482ff75cf03344db4ea03eae23edb862d59378b484b47ed842574856
+  languageName: node
+  linkType: hard
+
 "array-union@npm:^2.1.0":
   version: 2.1.0
   resolution: "array-union@npm:2.1.0"
@@ -3752,7 +4490,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"array.prototype.findlast@npm:^1.2.4":
+"array.prototype.findlast@npm:^1.2.5":
   version: 1.2.5
   resolution: "array.prototype.findlast@npm:1.2.5"
   dependencies:
@@ -3766,21 +4504,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"array.prototype.findlastindex@npm:^1.2.3":
-  version: 1.2.5
-  resolution: "array.prototype.findlastindex@npm:1.2.5"
-  dependencies:
-    call-bind: "npm:^1.0.7"
-    define-properties: "npm:^1.2.1"
-    es-abstract: "npm:^1.23.2"
-    es-errors: "npm:^1.3.0"
-    es-object-atoms: "npm:^1.0.0"
-    es-shim-unscopables: "npm:^1.0.2"
-  checksum: 10c0/962189487728b034f3134802b421b5f39e42ee2356d13b42d2ddb0e52057ffdcc170b9524867f4f0611a6f638f4c19b31e14606e8bcbda67799e26685b195aa3
-  languageName: node
-  linkType: hard
-
-"array.prototype.flat@npm:^1.3.1, array.prototype.flat@npm:^1.3.2":
+"array.prototype.flat@npm:^1.3.1":
   version: 1.3.2
   resolution: "array.prototype.flat@npm:1.3.2"
   dependencies:
@@ -3792,40 +4516,28 @@ __metadata:
   languageName: node
   linkType: hard
 
-"array.prototype.flatmap@npm:^1.3.2":
-  version: 1.3.2
-  resolution: "array.prototype.flatmap@npm:1.3.2"
-  dependencies:
-    call-bind: "npm:^1.0.2"
-    define-properties: "npm:^1.2.0"
-    es-abstract: "npm:^1.22.1"
-    es-shim-unscopables: "npm:^1.0.0"
-  checksum: 10c0/67b3f1d602bb73713265145853128b1ad77cc0f9b833c7e1e056b323fbeac41a4ff1c9c99c7b9445903caea924d9ca2450578d9011913191aa88cc3c3a4b54f4
-  languageName: node
-  linkType: hard
-
-"array.prototype.toreversed@npm:^1.1.2":
-  version: 1.1.2
-  resolution: "array.prototype.toreversed@npm:1.1.2"
+"array.prototype.flatmap@npm:^1.3.3":
+  version: 1.3.3
+  resolution: "array.prototype.flatmap@npm:1.3.3"
   dependencies:
-    call-bind: "npm:^1.0.2"
-    define-properties: "npm:^1.2.0"
-    es-abstract: "npm:^1.22.1"
-    es-shim-unscopables: "npm:^1.0.0"
-  checksum: 10c0/2b7627ea85eae1e80ecce665a500cc0f3355ac83ee4a1a727562c7c2a1d5f1c0b4dd7b65c468ec6867207e452ba01256910a2c0b41486bfdd11acf875a7a3435
+    call-bind: "npm:^1.0.8"
+    define-properties: "npm:^1.2.1"
+    es-abstract: "npm:^1.23.5"
+    es-shim-unscopables: "npm:^1.0.2"
+  checksum: 10c0/ba899ea22b9dc9bf276e773e98ac84638ed5e0236de06f13d63a90b18ca9e0ec7c97d622d899796e3773930b946cd2413d098656c0c5d8cc58c6f25c21e6bd54
   languageName: node
   linkType: hard
 
-"array.prototype.tosorted@npm:^1.1.3":
-  version: 1.1.3
-  resolution: "array.prototype.tosorted@npm:1.1.3"
+"array.prototype.tosorted@npm:^1.1.4":
+  version: 1.1.4
+  resolution: "array.prototype.tosorted@npm:1.1.4"
   dependencies:
-    call-bind: "npm:^1.0.5"
+    call-bind: "npm:^1.0.7"
     define-properties: "npm:^1.2.1"
-    es-abstract: "npm:^1.22.3"
-    es-errors: "npm:^1.1.0"
+    es-abstract: "npm:^1.23.3"
+    es-errors: "npm:^1.3.0"
     es-shim-unscopables: "npm:^1.0.2"
-  checksum: 10c0/a27e1ca51168ecacf6042901f5ef021e43c8fa04b6c6b6f2a30bac3645cd2b519cecbe0bc45db1b85b843f64dc3207f0268f700b4b9fbdec076d12d432cf0865
+  checksum: 10c0/eb3c4c4fc0381b0bf6dba2ea4d48d367c2827a0d4236a5718d97caaccc6b78f11f4cadf090736e86301d295a6aa4967ed45568f92ced51be8cbbacd9ca410943
   languageName: node
   linkType: hard
 
@@ -3845,6 +4557,21 @@ __metadata:
   languageName: node
   linkType: hard
 
+"arraybuffer.prototype.slice@npm:^1.0.4":
+  version: 1.0.4
+  resolution: "arraybuffer.prototype.slice@npm:1.0.4"
+  dependencies:
+    array-buffer-byte-length: "npm:^1.0.1"
+    call-bind: "npm:^1.0.8"
+    define-properties: "npm:^1.2.1"
+    es-abstract: "npm:^1.23.5"
+    es-errors: "npm:^1.3.0"
+    get-intrinsic: "npm:^1.2.6"
+    is-array-buffer: "npm:^3.0.4"
+  checksum: 10c0/2f2459caa06ae0f7f615003f9104b01f6435cc803e11bd2a655107d52a1781dc040532dc44d93026b694cc18793993246237423e13a5337e86b43ed604932c06
+  languageName: node
+  linkType: hard
+
 "arraydiff@npm:^0.1.1, arraydiff@npm:^0.1.3":
   version: 0.1.3
   resolution: "arraydiff@npm:0.1.3"
@@ -3866,6 +4593,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"assertion-error@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "assertion-error@npm:2.0.1"
+  checksum: 10c0/bbbcb117ac6480138f8c93cf7f535614282dea9dc828f540cdece85e3c665e8f78958b96afac52f29ff883c72638e6a87d469ecc9fe5bc902df03ed24a55dba8
+  languageName: node
+  linkType: hard
+
 "astring@npm:^1.8.0":
   version: 1.8.6
   resolution: "astring@npm:1.8.6"
@@ -3932,110 +4666,94 @@ __metadata:
   languageName: node
   linkType: hard
 
-"babel-jest@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "babel-jest@npm:29.7.0"
+"babel-jest@npm:30.3.0":
+  version: 30.3.0
+  resolution: "babel-jest@npm:30.3.0"
   dependencies:
-    "@jest/transform": "npm:^29.7.0"
-    "@types/babel__core": "npm:^7.1.14"
-    babel-plugin-istanbul: "npm:^6.1.1"
-    babel-preset-jest: "npm:^29.6.3"
-    chalk: "npm:^4.0.0"
-    graceful-fs: "npm:^4.2.9"
+    "@jest/transform": "npm:30.3.0"
+    "@types/babel__core": "npm:^7.20.5"
+    babel-plugin-istanbul: "npm:^7.0.1"
+    babel-preset-jest: "npm:30.3.0"
+    chalk: "npm:^4.1.2"
+    graceful-fs: "npm:^4.2.11"
     slash: "npm:^3.0.0"
   peerDependencies:
-    "@babel/core": ^7.8.0
-  checksum: 10c0/2eda9c1391e51936ca573dd1aedfee07b14c59b33dbe16ef347873ddd777bcf6e2fc739681e9e9661ab54ef84a3109a03725be2ac32cd2124c07ea4401cbe8c1
+    "@babel/core": ^7.11.0 || ^8.0.0-0
+  checksum: 10c0/5e41e124a404ddb78aa37a20336d7c883feab5ad9c4f4c72ae26db71be2fcca345874b9a7fef97d9c5f64f144a264b247ebde8acfe493578320f314ca581bac3
   languageName: node
   linkType: hard
 
-"babel-plugin-istanbul@npm:^6.1.1":
-  version: 6.1.1
-  resolution: "babel-plugin-istanbul@npm:6.1.1"
+"babel-plugin-istanbul@npm:^7.0.1":
+  version: 7.0.1
+  resolution: "babel-plugin-istanbul@npm:7.0.1"
   dependencies:
     "@babel/helper-plugin-utils": "npm:^7.0.0"
     "@istanbuljs/load-nyc-config": "npm:^1.0.0"
-    "@istanbuljs/schema": "npm:^0.1.2"
-    istanbul-lib-instrument: "npm:^5.0.4"
+    "@istanbuljs/schema": "npm:^0.1.3"
+    istanbul-lib-instrument: "npm:^6.0.2"
     test-exclude: "npm:^6.0.0"
-  checksum: 10c0/1075657feb705e00fd9463b329921856d3775d9867c5054b449317d39153f8fbcebd3e02ebf00432824e647faff3683a9ca0a941325ef1afe9b3c4dd51b24beb
+  checksum: 10c0/92975e3df12503b168695463b451468da0c20e117807221652eb8e33a26c160f3b9d4c5c4e65495657420e871c6a54e5e31f539e2e1da37ef2261d7ddd4b1dfd
   languageName: node
   linkType: hard
 
-"babel-plugin-jest-hoist@npm:^29.6.3":
-  version: 29.6.3
-  resolution: "babel-plugin-jest-hoist@npm:29.6.3"
+"babel-plugin-jest-hoist@npm:30.3.0":
+  version: 30.3.0
+  resolution: "babel-plugin-jest-hoist@npm:30.3.0"
   dependencies:
-    "@babel/template": "npm:^7.3.3"
-    "@babel/types": "npm:^7.3.3"
-    "@types/babel__core": "npm:^7.1.14"
-    "@types/babel__traverse": "npm:^7.0.6"
-  checksum: 10c0/7e6451caaf7dce33d010b8aafb970e62f1b0c0b57f4978c37b0d457bbcf0874d75a395a102daf0bae0bd14eafb9f6e9a165ee5e899c0a4f1f3bb2e07b304ed2e
+    "@types/babel__core": "npm:^7.20.5"
+  checksum: 10c0/5e15900a6487356131e084970f4a9ebe24b702d74930f786e897d4fab90b0987054f66661a3570ea692f429dcd158c2214c97ecf08f7356cbc60029d7b277c74
   languageName: node
   linkType: hard
 
-"babel-preset-current-node-syntax@npm:^1.0.0":
-  version: 1.0.1
-  resolution: "babel-preset-current-node-syntax@npm:1.0.1"
+"babel-plugin-teamplay@npm:^0.4.0-alpha.100, babel-plugin-teamplay@workspace:packages/babel-plugin-teamplay":
+  version: 0.0.0-use.local
+  resolution: "babel-plugin-teamplay@workspace:packages/babel-plugin-teamplay"
+  dependencies:
+    "@babel/core": "npm:^7.9.0"
+    "@babel/helper-module-imports": "npm:^7.0.0"
+    "@babel/parser": "npm:^7.0.0"
+    "@babel/traverse": "npm:^7.0.0"
+    "@startupjs/babel-plugin-eliminator": "npm:^0.62.0-alpha.0"
+    "@teamplay/schema": "npm:^0.4.0-alpha.9"
+    pluralize: "npm:^8.0.0"
+    vitest: "npm:^4.1.5"
+  languageName: unknown
+  linkType: soft
+
+"babel-preset-current-node-syntax@npm:^1.2.0":
+  version: 1.2.0
+  resolution: "babel-preset-current-node-syntax@npm:1.2.0"
   dependencies:
     "@babel/plugin-syntax-async-generators": "npm:^7.8.4"
     "@babel/plugin-syntax-bigint": "npm:^7.8.3"
-    "@babel/plugin-syntax-class-properties": "npm:^7.8.3"
-    "@babel/plugin-syntax-import-meta": "npm:^7.8.3"
+    "@babel/plugin-syntax-class-properties": "npm:^7.12.13"
+    "@babel/plugin-syntax-class-static-block": "npm:^7.14.5"
+    "@babel/plugin-syntax-import-attributes": "npm:^7.24.7"
+    "@babel/plugin-syntax-import-meta": "npm:^7.10.4"
     "@babel/plugin-syntax-json-strings": "npm:^7.8.3"
-    "@babel/plugin-syntax-logical-assignment-operators": "npm:^7.8.3"
+    "@babel/plugin-syntax-logical-assignment-operators": "npm:^7.10.4"
     "@babel/plugin-syntax-nullish-coalescing-operator": "npm:^7.8.3"
-    "@babel/plugin-syntax-numeric-separator": "npm:^7.8.3"
+    "@babel/plugin-syntax-numeric-separator": "npm:^7.10.4"
     "@babel/plugin-syntax-object-rest-spread": "npm:^7.8.3"
     "@babel/plugin-syntax-optional-catch-binding": "npm:^7.8.3"
     "@babel/plugin-syntax-optional-chaining": "npm:^7.8.3"
-    "@babel/plugin-syntax-top-level-await": "npm:^7.8.3"
+    "@babel/plugin-syntax-private-property-in-object": "npm:^7.14.5"
+    "@babel/plugin-syntax-top-level-await": "npm:^7.14.5"
   peerDependencies:
-    "@babel/core": ^7.0.0
-  checksum: 10c0/5ba39a3a0e6c37d25e56a4fb843be632dac98d54706d8a0933f9bcb1a07987a96d55c2b5a6c11788a74063fb2534fe68c1f1dbb6c93626850c785e0938495627
+    "@babel/core": ^7.0.0 || ^8.0.0-0
+  checksum: 10c0/94a4f81cddf9b051045d08489e4fff7336292016301664c138cfa3d9ffe3fe2ba10a24ad6ae589fd95af1ac72ba0216e1653555c187e694d7b17be0c002bea10
   languageName: node
   linkType: hard
 
-"babel-preset-jest@npm:^29.6.3":
-  version: 29.6.3
-  resolution: "babel-preset-jest@npm:29.6.3"
+"babel-preset-jest@npm:30.3.0":
+  version: 30.3.0
+  resolution: "babel-preset-jest@npm:30.3.0"
   dependencies:
-    babel-plugin-jest-hoist: "npm:^29.6.3"
-    babel-preset-current-node-syntax: "npm:^1.0.0"
+    babel-plugin-jest-hoist: "npm:30.3.0"
+    babel-preset-current-node-syntax: "npm:^1.2.0"
   peerDependencies:
-    "@babel/core": ^7.0.0
-  checksum: 10c0/ec5fd0276b5630b05f0c14bb97cc3815c6b31600c683ebb51372e54dcb776cff790bdeeabd5b8d01ede375a040337ccbf6a3ccd68d3a34219125945e167ad943
-  languageName: node
-  linkType: hard
-
-"babel-runtime@npm:^6.26.0":
-  version: 6.26.0
-  resolution: "babel-runtime@npm:6.26.0"
-  dependencies:
-    core-js: "npm:^2.4.0"
-    regenerator-runtime: "npm:^0.11.0"
-  checksum: 10c0/caa752004936b1463765ed3199c52f6a55d0613b9bed108743d6f13ca532b821d4ea9decc4be1b583193164462b1e3e7eefdfa36b15c72e7daac58dd72c1772f
-  languageName: node
-  linkType: hard
-
-"babel-types@npm:^6.26.0":
-  version: 6.26.0
-  resolution: "babel-types@npm:6.26.0"
-  dependencies:
-    babel-runtime: "npm:^6.26.0"
-    esutils: "npm:^2.0.2"
-    lodash: "npm:^4.17.4"
-    to-fast-properties: "npm:^1.0.3"
-  checksum: 10c0/cabe371de1b32c4bbb1fd4ed0fe8a8726d42e5ad7d5cefb83cdae6de0f0a152dce591e4026719743fdf3aa45f84fea2c8851fb822fbe29b0c78a1f0094b67418
-  languageName: node
-  linkType: hard
-
-"babylon@npm:^6.18.0":
-  version: 6.18.0
-  resolution: "babylon@npm:6.18.0"
-  bin:
-    babylon: ./bin/babylon.js
-  checksum: 10c0/9b1bf946e16782deadb1f5414c1269efa6044eb1e97a3de2051f09a3f2a54e97be3542d4242b28d23de0ef67816f519d38ce1ec3ddb7be306131c39a60e5a667
+    "@babel/core": ^7.11.0 || ^8.0.0-beta.1
+  checksum: 10c0/a6839a1527d254bf04e82c0cf61a6a2aa283123a74f0a552e6fce462cb990abebab75a13ec3e9c58b09a865d4d2dfbac710c2d3975ae3ce6f2707cb314915c66
   languageName: node
   linkType: hard
 
@@ -4053,6 +4771,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"balanced-match@npm:^4.0.2":
+  version: 4.0.4
+  resolution: "balanced-match@npm:4.0.4"
+  checksum: 10c0/07e86102a3eb2ee2a6a1a89164f29d0dbaebd28f2ca3f5ca786f36b8b23d9e417eb3be45a4acf754f837be5ac0a2317de90d3fcb7f4f4dc95720a1f36b26a17b
+  languageName: node
+  linkType: hard
+
 "base64-js@npm:^1.3.1":
   version: 1.5.1
   resolution: "base64-js@npm:1.5.1"
@@ -4060,6 +4785,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"baseline-browser-mapping@npm:^2.10.12":
+  version: 2.10.21
+  resolution: "baseline-browser-mapping@npm:2.10.21"
+  bin:
+    baseline-browser-mapping: dist/cli.cjs
+  checksum: 10c0/065d90f98099dd0d7b6e1c284f7133d0eaebf571a7ee3e9e0740862dbd64cf040f4447404269bc8b1fd4015dead68c3a026e541a214050375df6bde20706ec8b
+  languageName: node
+  linkType: hard
+
 "before-after-hook@npm:^2.2.0":
   version: 2.2.3
   resolution: "before-after-hook@npm:2.2.3"
@@ -4140,6 +4874,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"brace-expansion@npm:^5.0.5":
+  version: 5.0.5
+  resolution: "brace-expansion@npm:5.0.5"
+  dependencies:
+    balanced-match: "npm:^4.0.2"
+  checksum: 10c0/4d238e14ed4f5cc9c07285550a41cef23121ca08ba99fa9eb5b55b580dcb6bf868b8210aa10526bdc9f8dc97f33ca2a7259039c4cc131a93042beddb424c48e3
+  languageName: node
+  linkType: hard
+
 "braces@npm:^3.0.3, braces@npm:~3.0.2":
   version: 3.0.3
   resolution: "braces@npm:3.0.3"
@@ -4149,7 +4892,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"browser-stdout@npm:1.3.1, browser-stdout@npm:^1.3.1":
+"browser-stdout@npm:^1.3.1":
   version: 1.3.1
   resolution: "browser-stdout@npm:1.3.1"
   checksum: 10c0/c40e482fd82be872b6ea7b9f7591beafbf6f5ba522fe3dade98ba1573a1c29a11101564993e4eb44e5488be8f44510af072df9a9637c739217eb155ceb639205
@@ -4170,6 +4913,21 @@ __metadata:
   languageName: node
   linkType: hard
 
+"browserslist@npm:^4.24.0":
+  version: 4.28.2
+  resolution: "browserslist@npm:4.28.2"
+  dependencies:
+    baseline-browser-mapping: "npm:^2.10.12"
+    caniuse-lite: "npm:^1.0.30001782"
+    electron-to-chromium: "npm:^1.5.328"
+    node-releases: "npm:^2.0.36"
+    update-browserslist-db: "npm:^1.2.3"
+  bin:
+    browserslist: cli.js
+  checksum: 10c0/c0228b6330f785b7fa59d2d360124ec6d9322f96ed9f3ee1f873e33ecc9503a6f0ffc3b71191a28c4ff6e930b753b30043da1c33844a9548f3018d491f09ce60
+  languageName: node
+  linkType: hard
+
 "bser@npm:2.1.1":
   version: 2.1.1
   resolution: "bser@npm:2.1.1"
@@ -4213,22 +4971,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"builtin-modules@npm:^3.3.0":
-  version: 3.3.0
-  resolution: "builtin-modules@npm:3.3.0"
-  checksum: 10c0/2cb3448b4f7306dc853632a4fcddc95e8d4e4b9868c139400027b71938fc6806d4ff44007deffb362ac85724bd40c2c6452fb6a0aa4531650eeddb98d8e5ee8a
-  languageName: node
-  linkType: hard
-
-"builtins@npm:^5.0.1":
-  version: 5.1.0
-  resolution: "builtins@npm:5.1.0"
-  dependencies:
-    semver: "npm:^7.0.0"
-  checksum: 10c0/3c32fe5bd7ed4ff7dbd6fb14bcb9d7eaa7e967327f1899cd336f8625d3f46fceead0a53528f1e332aeaee757034ebb307cb2f1a37af2b86a3c5ad4845d01c0c8
-  languageName: node
-  linkType: hard
-
 "byte-size@npm:8.1.1":
   version: 8.1.1
   resolution: "byte-size@npm:8.1.1"
@@ -4236,9 +4978,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"c8@npm:^10.1.3":
-  version: 10.1.3
-  resolution: "c8@npm:10.1.3"
+"c8@npm:^11.0.0":
+  version: 11.0.0
+  resolution: "c8@npm:11.0.0"
   dependencies:
     "@bcoe/v8-coverage": "npm:^1.0.1"
     "@istanbuljs/schema": "npm:^0.1.3"
@@ -4247,7 +4989,7 @@ __metadata:
     istanbul-lib-coverage: "npm:^3.2.0"
     istanbul-lib-report: "npm:^3.0.1"
     istanbul-reports: "npm:^3.1.6"
-    test-exclude: "npm:^7.0.1"
+    test-exclude: "npm:^8.0.0"
     v8-to-istanbul: "npm:^9.0.0"
     yargs: "npm:^17.7.2"
     yargs-parser: "npm:^21.1.1"
@@ -4258,7 +5000,7 @@ __metadata:
       optional: true
   bin:
     c8: bin/c8.js
-  checksum: 10c0/1265ddbcb0e624fe200978e9263faf948cb9694ce8e6b858adbb14f1186de2e6c451aa4aabb821e9eb7f1972859e14691eaf2ff12ad96be7a3fc0e39946fc569
+  checksum: 10c0/94b0cf8756715ca8fedb9331c61ebda0c5bbd63c5eeea523d18904af790f6f197a02f547c066fa2d8d0544bb9f9547a6a67d653f3575953139c74ca915771963
   languageName: node
   linkType: hard
 
@@ -4377,7 +5119,29 @@ __metadata:
   languageName: node
   linkType: hard
 
-"callsites@npm:^3.0.0":
+"call-bind@npm:^1.0.8, call-bind@npm:^1.0.9":
+  version: 1.0.9
+  resolution: "call-bind@npm:1.0.9"
+  dependencies:
+    call-bind-apply-helpers: "npm:^1.0.2"
+    es-define-property: "npm:^1.0.1"
+    get-intrinsic: "npm:^1.3.0"
+    set-function-length: "npm:^1.2.2"
+  checksum: 10c0/a6621f6da1444481919ce3b4983dff725691e0754d3507ae483ce56e54985f2da7d6f1df512c56dbf28660745cf1ca52553f1fc9aef5557f3ce353ef14fab714
+  languageName: node
+  linkType: hard
+
+"call-bound@npm:^1.0.2, call-bound@npm:^1.0.3, call-bound@npm:^1.0.4":
+  version: 1.0.4
+  resolution: "call-bound@npm:1.0.4"
+  dependencies:
+    call-bind-apply-helpers: "npm:^1.0.2"
+    get-intrinsic: "npm:^1.3.0"
+  checksum: 10c0/f4796a6a0941e71c766aea672f63b72bc61234c4f4964dc6d7606e3664c307e7d77845328a8f3359ce39ddb377fed67318f9ee203dea1d47e46165dcf2917644
+  languageName: node
+  linkType: hard
+
+"callsites@npm:^3.0.0, callsites@npm:^3.1.0":
   version: 3.1.0
   resolution: "callsites@npm:3.1.0"
   checksum: 10c0/fff92277400eb06c3079f9e74f3af120db9f8ea03bad0e84d9aede54bbe2d44a56cccb5f6cf12211f93f52306df87077ecec5b712794c5a9b5dac6d615a3f301
@@ -4402,7 +5166,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"camelcase@npm:^6.0.0, camelcase@npm:^6.2.0":
+"camelcase@npm:^6.0.0, camelcase@npm:^6.3.0":
   version: 6.3.0
   resolution: "camelcase@npm:6.3.0"
   checksum: 10c0/0d701658219bd3116d12da3eab31acddb3f9440790c0792e0d398f0a520a6a4058018e546862b6fba89d7ae990efaeb97da71e1913e9ebf5a8b5621a3d55c710
@@ -4416,6 +5180,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"caniuse-lite@npm:^1.0.30001782":
+  version: 1.0.30001790
+  resolution: "caniuse-lite@npm:1.0.30001790"
+  checksum: 10c0/eec0adc1dcb35d51e57bcfa0657493cb57ef43f0ceb03c1edcfee34d43e7a938e6beed2781118c7a5ee99d4f71d443977f08ca5a549005cf89260733af9ad3f8
+  languageName: node
+  linkType: hard
+
 "ccount@npm:^2.0.0":
   version: 2.0.1
   resolution: "ccount@npm:2.0.1"
@@ -4423,6 +5194,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"chai@npm:^6.2.2":
+  version: 6.2.2
+  resolution: "chai@npm:6.2.2"
+  checksum: 10c0/e6c69e5f0c11dffe6ea13d0290936ebb68fcc1ad688b8e952e131df6a6d5797d5e860bc55cef1aca2e950c3e1f96daf79e9d5a70fb7dbaab4e46355e2635ed53
+  languageName: node
+  linkType: hard
+
 "chalk@npm:4.1.0":
   version: 4.1.0
   resolution: "chalk@npm:4.1.0"
@@ -4489,13 +5267,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"character-parser@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "character-parser@npm:4.0.0"
-  checksum: 10c0/e76030b083960effc3e52829c47539deae1a7654ddafc032df988828d63015778a32af48902c43aa41089867ba1fe76abad2097b1b4399f28cef420f45d50395
-  languageName: node
-  linkType: hard
-
 "character-reference-invalid@npm:^2.0.0":
   version: 2.0.1
   resolution: "character-reference-invalid@npm:2.0.1"
@@ -4510,25 +5281,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"chokidar@npm:3.5.1":
-  version: 3.5.1
-  resolution: "chokidar@npm:3.5.1"
-  dependencies:
-    anymatch: "npm:~3.1.1"
-    braces: "npm:~3.0.2"
-    fsevents: "npm:~2.3.1"
-    glob-parent: "npm:~5.1.0"
-    is-binary-path: "npm:~2.1.0"
-    is-glob: "npm:~4.0.1"
-    normalize-path: "npm:~3.0.0"
-    readdirp: "npm:~3.5.0"
-  dependenciesMeta:
-    fsevents:
-      optional: true
-  checksum: 10c0/894d2fdeeef6a0bc61993a20b864e29e9296f2308628b8b2edf1bef2d59ab11f21938eebbbcbf581f15d16d3e030c08860d2fb035f7b9f3baebac57049a37959
-  languageName: node
-  linkType: hard
-
 "chokidar@npm:^3.6.0":
   version: 3.6.0
   resolution: "chokidar@npm:3.6.0"
@@ -4599,10 +5351,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cjs-module-lexer@npm:^1.0.0":
-  version: 1.3.1
-  resolution: "cjs-module-lexer@npm:1.3.1"
-  checksum: 10c0/cd98fbf3c7f4272fb0ebf71d08d0c54bc75ce0e30b9d186114e15b4ba791f3d310af65a339eea2a0318599af2818cdd8886d353b43dfab94468f72987397ad16
+"ci-info@npm:^4.2.0":
+  version: 4.4.0
+  resolution: "ci-info@npm:4.4.0"
+  checksum: 10c0/44156201545b8dde01aa8a09ee2fe9fc7a73b1bef9adbd4606c9f61c8caeeb73fb7a575c88b0443f7b4edb5ee45debaa59ed54ba5f99698339393ca01349eb3a
+  languageName: node
+  linkType: hard
+
+"cjs-module-lexer@npm:^2.1.0":
+  version: 2.2.0
+  resolution: "cjs-module-lexer@npm:2.2.0"
+  checksum: 10c0/aec4ca58f87145fac221386790ecaae8b012f2e2359a45acb61d8c75ea4fa84f6ea869f17abc1a7e91a808eff0fed581209632f03540de16f72f0a28f5fd35ac
   languageName: node
   linkType: hard
 
@@ -4733,10 +5492,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"collect-v8-coverage@npm:^1.0.0":
-  version: 1.0.2
-  resolution: "collect-v8-coverage@npm:1.0.2"
-  checksum: 10c0/ed7008e2e8b6852c5483b444a3ae6e976e088d4335a85aa0a9db2861c5f1d31bd2d7ff97a60469b3388deeba661a619753afbe201279fb159b4b9548ab8269a1
+"collect-v8-coverage@npm:^1.0.2":
+  version: 1.0.3
+  resolution: "collect-v8-coverage@npm:1.0.3"
+  checksum: 10c0/bc62ba251bcce5e3354a8f88fa6442bee56e3e612fec08d4dfcf66179b41ea0bf544b0f78c4ebc0f8050871220af95bb5c5578a6aef346feea155640582f09dc
   languageName: node
   linkType: hard
 
@@ -4821,7 +5580,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"commander@npm:^2.7.1, commander@npm:^2.9.0":
+"commander@npm:^2.7.1":
   version: 2.20.3
   resolution: "commander@npm:2.20.3"
   checksum: 10c0/74c781a5248c2402a0a3e966a0a2bba3c054aad144f5c023364be83265e796b20565aa9feff624132ff629aa64e16999fa40a743c10c12f7c61e96a794b99288
@@ -4835,13 +5594,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"common-prefix@npm:^1.1.0":
-  version: 1.1.0
-  resolution: "common-prefix@npm:1.1.0"
-  checksum: 10c0/6a34eb98af28b21a90ac891b7f981ff55628da6bc2bfb44b06e34befed4e681c21faf388e9e6af65d7b7af5a8efd28ece8ba6d390e1dd4ea28a6b07d073106cf
-  languageName: node
-  linkType: hard
-
 "compare-func@npm:^2.0.0":
   version: 2.0.0
   resolution: "compare-func@npm:2.0.0"
@@ -4892,18 +5644,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"constantinople@npm:^3.0.1":
-  version: 3.1.2
-  resolution: "constantinople@npm:3.1.2"
-  dependencies:
-    "@types/babel-types": "npm:^7.0.0"
-    "@types/babylon": "npm:^6.16.2"
-    babel-types: "npm:^6.26.0"
-    babylon: "npm:^6.18.0"
-  checksum: 10c0/5fea24b1a1a00369a0eeb22077acc6cc3b044b54820ee903feafc6b5e5b21e57a130d636cbd2e7d400d7a22cbd4df79091d6eab7f1211a5fbb3ba866f2bb5b68
-  languageName: node
-  linkType: hard
-
 "conventional-changelog-angular@npm:7.0.0":
   version: 7.0.0
   resolution: "conventional-changelog-angular@npm:7.0.0"
@@ -5020,13 +5760,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"core-js@npm:^2.4.0":
-  version: 2.6.12
-  resolution: "core-js@npm:2.6.12"
-  checksum: 10c0/00128efe427789120a06b819adc94cc72b96955acb331cb71d09287baf9bd37bebd191d91f1ee4939c893a050307ead4faea08876f09115112612b6a05684b63
-  languageName: node
-  linkType: hard
-
 "core-util-is@npm:~1.0.0":
   version: 1.0.3
   resolution: "core-util-is@npm:1.0.3"
@@ -5064,23 +5797,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"create-jest@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "create-jest@npm:29.7.0"
-  dependencies:
-    "@jest/types": "npm:^29.6.3"
-    chalk: "npm:^4.0.0"
-    exit: "npm:^0.1.2"
-    graceful-fs: "npm:^4.2.9"
-    jest-config: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-    prompts: "npm:^2.0.1"
-  bin:
-    create-jest: bin/create-jest.js
-  checksum: 10c0/e7e54c280692470d3398f62a6238fd396327e01c6a0757002833f06d00afc62dd7bfe04ff2b9cd145264460e6b4d1eb8386f2925b7e567f97939843b7b0e812f
-  languageName: node
-  linkType: hard
-
 "create-require@npm:^1.1.0":
   version: 1.1.1
   resolution: "create-require@npm:1.1.1"
@@ -5088,7 +5804,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cross-spawn@npm:^7.0.0, cross-spawn@npm:^7.0.2, cross-spawn@npm:^7.0.3":
+"cross-spawn@npm:^7.0.0, cross-spawn@npm:^7.0.3":
   version: 7.0.3
   resolution: "cross-spawn@npm:7.0.3"
   dependencies:
@@ -5110,13 +5826,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"css-selector-parser@npm:^1.1.0":
-  version: 1.4.1
-  resolution: "css-selector-parser@npm:1.4.1"
-  checksum: 10c0/4a89a7b61072cf0e4d09e8abbb9a77bc661232b6fe6a6fe51ba775757bae0e3fc462b0db4c9a857da55afb89a1c1746a7b2ec1200f639c539556ebdc758b0101
-  languageName: node
-  linkType: hard
-
 "cssesc@npm:^3.0.0":
   version: 3.0.0
   resolution: "cssesc@npm:3.0.0"
@@ -5126,33 +5835,20 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cssom@npm:^0.5.0":
-  version: 0.5.0
-  resolution: "cssom@npm:0.5.0"
-  checksum: 10c0/8c4121c243baf0678c65dcac29b201ff0067dfecf978de9d5c83b2ff127a8fdefd2bfd54577f5ad8c80ed7d2c8b489ae01c82023545d010c4ecb87683fb403dd
-  languageName: node
-  linkType: hard
-
-"cssom@npm:~0.3.6":
-  version: 0.3.8
-  resolution: "cssom@npm:0.3.8"
-  checksum: 10c0/d74017b209440822f9e24d8782d6d2e808a8fdd58fa626a783337222fe1c87a518ba944d4c88499031b4786e68772c99dfae616638d71906fe9f203aeaf14411
-  languageName: node
-  linkType: hard
-
-"cssstyle@npm:^2.3.0":
-  version: 2.3.0
-  resolution: "cssstyle@npm:2.3.0"
+"cssstyle@npm:^4.2.1":
+  version: 4.6.0
+  resolution: "cssstyle@npm:4.6.0"
   dependencies:
-    cssom: "npm:~0.3.6"
-  checksum: 10c0/863400da2a458f73272b9a55ba7ff05de40d850f22eb4f37311abebd7eff801cf1cd2fb04c4c92b8c3daed83fe766e52e4112afb7bc88d86c63a9c2256a7d178
+    "@asamuzakjp/css-color": "npm:^3.2.0"
+    rrweb-cssom: "npm:^0.8.0"
+  checksum: 10c0/71add1b0ffafa1bedbef6855db6189b9523d3320e015a0bf3fbd504760efb9a81e1f1a225228d5fa892ee58e56d06994ca372e7f4e461cda7c4c9985fe075f65
   languageName: node
   linkType: hard
 
-"csstype@npm:^3.0.2":
-  version: 3.1.3
-  resolution: "csstype@npm:3.1.3"
-  checksum: 10c0/80c089d6f7e0c5b2bd83cf0539ab41474198579584fa10d86d0cafe0642202343cbc119e076a0b1aece191989477081415d66c9fefbf3c957fc2fc4b7009f248
+"csstype@npm:^3.2.2":
+  version: 3.2.3
+  resolution: "csstype@npm:3.2.3"
+  checksum: 10c0/cd29c51e70fa822f1cecd8641a1445bed7063697469d35633b516e60fe8c1bde04b08f6c5b6022136bb669b64c63d4173af54864510fbb4ee23281801841a3ce
   languageName: node
   linkType: hard
 
@@ -5163,14 +5859,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"data-urls@npm:^3.0.2":
-  version: 3.0.2
-  resolution: "data-urls@npm:3.0.2"
+"data-urls@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "data-urls@npm:5.0.0"
   dependencies:
-    abab: "npm:^2.0.6"
-    whatwg-mimetype: "npm:^3.0.0"
-    whatwg-url: "npm:^11.0.0"
-  checksum: 10c0/051c3aaaf3e961904f136aab095fcf6dff4db23a7fc759dd8ba7b3e6ba03fc07ef608086caad8ab910d864bd3b5e57d0d2f544725653d77c96a2c971567045f4
+    whatwg-mimetype: "npm:^4.0.0"
+    whatwg-url: "npm:^14.0.0"
+  checksum: 10c0/1b894d7d41c861f3a4ed2ae9b1c3f0909d4575ada02e36d3d3bc584bdd84278e20709070c79c3b3bff7ac98598cb191eb3e86a89a79ea4ee1ef360e1694f92ad
   languageName: node
   linkType: hard
 
@@ -5185,6 +5880,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"data-view-buffer@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "data-view-buffer@npm:1.0.2"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    es-errors: "npm:^1.3.0"
+    is-data-view: "npm:^1.0.2"
+  checksum: 10c0/7986d40fc7979e9e6241f85db8d17060dd9a71bd53c894fa29d126061715e322a4cd47a00b0b8c710394854183d4120462b980b8554012acc1c0fa49df7ad38c
+  languageName: node
+  linkType: hard
+
 "data-view-byte-length@npm:^1.0.1":
   version: 1.0.1
   resolution: "data-view-byte-length@npm:1.0.1"
@@ -5196,6 +5902,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"data-view-byte-length@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "data-view-byte-length@npm:1.0.2"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    es-errors: "npm:^1.3.0"
+    is-data-view: "npm:^1.0.2"
+  checksum: 10c0/f8a4534b5c69384d95ac18137d381f18a5cfae1f0fc1df0ef6feef51ef0d568606d970b69e02ea186c6c0f0eac77fe4e6ad96fec2569cc86c3afcc7475068c55
+  languageName: node
+  linkType: hard
+
 "data-view-byte-offset@npm:^1.0.0":
   version: 1.0.0
   resolution: "data-view-byte-offset@npm:1.0.0"
@@ -5207,6 +5924,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"data-view-byte-offset@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "data-view-byte-offset@npm:1.0.1"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    es-errors: "npm:^1.3.0"
+    is-data-view: "npm:^1.0.1"
+  checksum: 10c0/fa7aa40078025b7810dcffc16df02c480573b7b53ef1205aa6a61533011005c1890e5ba17018c692ce7c900212b547262d33279fde801ad9843edc0863bf78c4
+  languageName: node
+  linkType: hard
+
 "dateformat@npm:^3.0.3":
   version: 3.0.3
   resolution: "dateformat@npm:3.0.3"
@@ -5226,18 +5954,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"debug@npm:4.3.1":
-  version: 4.3.1
-  resolution: "debug@npm:4.3.1"
-  dependencies:
-    ms: "npm:2.1.2"
-  peerDependenciesMeta:
-    supports-color:
-      optional: true
-  checksum: 10c0/610bcc2eb07c533d6a9964478422f7d741095d67301888ee0b77b8f2ad0a15d115c93fb2adb13d10a9eda3d81f2d4d335405540b09596fb23aca070e77497d95
-  languageName: node
-  linkType: hard
-
 "debug@npm:^3.2.7":
   version: 3.2.7
   resolution: "debug@npm:3.2.7"
@@ -5259,7 +5975,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"debug@npm:^4.3.5, debug@npm:^4.4.1":
+"debug@npm:^4.3.5, debug@npm:^4.4.1, debug@npm:^4.4.3":
   version: 4.4.3
   resolution: "debug@npm:4.4.3"
   dependencies:
@@ -5295,10 +6011,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"decimal.js@npm:^10.4.2":
-  version: 10.4.3
-  resolution: "decimal.js@npm:10.4.3"
-  checksum: 10c0/6d60206689ff0911f0ce968d40f163304a6c1bc739927758e6efc7921cfa630130388966f16bf6ef6b838cb33679fbe8e7a78a2f3c478afce841fd55ac8fb8ee
+"decimal.js@npm:^10.5.0":
+  version: 10.6.0
+  resolution: "decimal.js@npm:10.6.0"
+  checksum: 10c0/07d69fbcc54167a340d2d97de95f546f9ff1f69d2b45a02fd7a5292412df3cd9eb7e23065e532a318f5474a2e1bccf8392fdf0443ef467f97f3bf8cb0477e5aa
   languageName: node
   linkType: hard
 
@@ -5320,7 +6036,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"dedent@npm:1.5.3, dedent@npm:^1.0.0":
+"dedent@npm:1.5.3":
   version: 1.5.3
   resolution: "dedent@npm:1.5.3"
   peerDependencies:
@@ -5332,6 +6048,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"dedent@npm:^1.6.0":
+  version: 1.7.2
+  resolution: "dedent@npm:1.7.2"
+  peerDependencies:
+    babel-plugin-macros: ^3.1.0
+  peerDependenciesMeta:
+    babel-plugin-macros:
+      optional: true
+  checksum: 10c0/acaff07cac355b93f17b1b17ebbb84d3cc55af6ab4b7814c3f505e061903e168bc6bf9ddce331552d64dee1525f0b4c549c9ade46aebfac6f69caaed74e90751
+  languageName: node
+  linkType: hard
+
 "deep-equal@npm:^1.0.1":
   version: 1.1.2
   resolution: "deep-equal@npm:1.1.2"
@@ -5360,7 +6088,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"deepmerge@npm:^4.2.2":
+"deepmerge@npm:^4.3.1":
   version: 4.3.1
   resolution: "deepmerge@npm:4.3.1"
   checksum: 10c0/e53481aaf1aa2c4082b5342be6b6d8ad9dfe387bc92ce197a66dea08bd4265904a087e75e464f14d1347cf2ac8afe1e4c16b266e0561cc5df29382d3c5f80044
@@ -5394,7 +6122,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"define-properties@npm:^1.2.0, define-properties@npm:^1.2.1":
+"define-properties@npm:^1.1.3, define-properties@npm:^1.2.0, define-properties@npm:^1.2.1":
   version: 1.2.1
   resolution: "define-properties@npm:1.2.1"
   dependencies:
@@ -5454,7 +6182,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"detect-newline@npm:^3.0.0":
+"detect-libc@npm:^2.0.3":
+  version: 2.1.2
+  resolution: "detect-libc@npm:2.1.2"
+  checksum: 10c0/acc675c29a5649fa1fb6e255f993b8ee829e510b6b56b0910666949c80c364738833417d0edb5f90e4e46be17228b0f2b66a010513984e18b15deeeac49369c4
+  languageName: node
+  linkType: hard
+
+"detect-newline@npm:^3.1.0":
   version: 3.1.0
   resolution: "detect-newline@npm:3.1.0"
   checksum: 10c0/c38cfc8eeb9fda09febb44bcd85e467c970d4e3bf526095394e5a4f18bc26dd0cf6b22c69c1fa9969261521c593836db335c2795218f6d781a512aea2fb8209d
@@ -5477,20 +6212,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"diff-sequences@npm:^29.6.3":
-  version: 29.6.3
-  resolution: "diff-sequences@npm:29.6.3"
-  checksum: 10c0/32e27ac7dbffdf2fb0eb5a84efd98a9ad084fbabd5ac9abb8757c6770d5320d2acd172830b28c4add29bb873d59420601dfc805ac4064330ce59b1adfd0593b2
-  languageName: node
-  linkType: hard
-
-"diff@npm:5.0.0":
-  version: 5.0.0
-  resolution: "diff@npm:5.0.0"
-  checksum: 10c0/08c5904779bbababcd31f1707657b1ad57f8a9b65e6f88d3fb501d09a965d5f8d73066898a7d3f35981f9e4101892c61d99175d421f3b759533213c253d91134
-  languageName: node
-  linkType: hard
-
 "diff@npm:^4.0.1":
   version: 4.0.2
   resolution: "diff@npm:4.0.2"
@@ -5505,15 +6226,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"dir-glob@npm:^3.0.1":
-  version: 3.0.1
-  resolution: "dir-glob@npm:3.0.1"
-  dependencies:
-    path-type: "npm:^4.0.0"
-  checksum: 10c0/dcac00920a4d503e38bb64001acb19df4efc14536ada475725e12f52c16777afdee4db827f55f13a908ee7efc0cb282e2e3dbaeeb98c0993dd93d1802d3bf00c
-  languageName: node
-  linkType: hard
-
 "doctrine@npm:^2.1.0":
   version: 2.1.0
   resolution: "doctrine@npm:2.1.0"
@@ -5523,15 +6235,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"doctrine@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "doctrine@npm:3.0.0"
-  dependencies:
-    esutils: "npm:^2.0.2"
-  checksum: 10c0/c96bdccabe9d62ab6fea9399fdff04a66e6563c1d6fb3a3a063e8d53c3bb136ba63e84250bbf63d00086a769ad53aef92d2bd483f03f837fc97b71cbee6b2520
-  languageName: node
-  linkType: hard
-
 "dom-accessibility-api@npm:^0.5.9":
   version: 0.5.16
   resolution: "dom-accessibility-api@npm:0.5.16"
@@ -5539,15 +6242,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"domexception@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "domexception@npm:4.0.0"
-  dependencies:
-    webidl-conversions: "npm:^7.0.0"
-  checksum: 10c0/774277cd9d4df033f852196e3c0077a34dbd15a96baa4d166e0e47138a80f4c0bdf0d94e4703e6ff5883cec56bb821a6fff84402d8a498e31de7c87eb932a294
-  languageName: node
-  linkType: hard
-
 "dot-prop@npm:^5.1.0":
   version: 5.3.0
   resolution: "dot-prop@npm:5.3.0"
@@ -5610,7 +6304,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"dunder-proto@npm:^1.0.1":
+"dunder-proto@npm:^1.0.0, dunder-proto@npm:^1.0.1":
   version: 1.0.1
   resolution: "dunder-proto@npm:1.0.1"
   dependencies:
@@ -5646,6 +6340,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"electron-to-chromium@npm:^1.5.328":
+  version: 1.5.344
+  resolution: "electron-to-chromium@npm:1.5.344"
+  checksum: 10c0/36624a59b2da4cb2bdee3085f5fc814bc0ba5830162a26f45c4b189177455869fd9d9c2e05fa28e69a45fb95c04d3e995962ff0e1658f552dcbe147a731c4f1d
+  languageName: node
+  linkType: hard
+
 "emittery@npm:^0.13.1":
   version: 0.13.1
   resolution: "emittery@npm:0.13.1"
@@ -5701,6 +6402,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"enhanced-resolve@npm:^5.17.1":
+  version: 5.21.0
+  resolution: "enhanced-resolve@npm:5.21.0"
+  dependencies:
+    graceful-fs: "npm:^4.2.4"
+    tapable: "npm:^2.3.3"
+  checksum: 10c0/8d25b9eb7cbaaf6bac7ca52cefb6aa8a723a3cea754aa3c52f269bdae3b6d5f3219fadbaf4362ed7d53f027e0b83bfbeb4c646640123cf62e6dbe52f28604c77
+  languageName: node
+  linkType: hard
+
 "enquirer@npm:~2.3.6":
   version: 2.3.6
   resolution: "enquirer@npm:2.3.6"
@@ -5717,6 +6428,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"entities@npm:^6.0.0":
+  version: 6.0.1
+  resolution: "entities@npm:6.0.1"
+  checksum: 10c0/ed836ddac5acb34341094eb495185d527bd70e8632b6c0d59548cbfa23defdbae70b96f9a405c82904efa421230b5b3fd2283752447d737beffd3f3e6ee74414
+  languageName: node
+  linkType: hard
+
 "env-paths@npm:^2.2.0, env-paths@npm:^2.2.1":
   version: 2.2.1
   resolution: "env-paths@npm:2.2.1"
@@ -5758,7 +6476,69 @@ __metadata:
   languageName: node
   linkType: hard
 
-"es-abstract@npm:^1.22.1, es-abstract@npm:^1.22.3, es-abstract@npm:^1.23.0, es-abstract@npm:^1.23.1, es-abstract@npm:^1.23.2, es-abstract@npm:^1.23.3":
+"es-abstract@npm:^1.17.5, es-abstract@npm:^1.23.5, es-abstract@npm:^1.23.6, es-abstract@npm:^1.23.9, es-abstract@npm:^1.24.0, es-abstract@npm:^1.24.2":
+  version: 1.24.2
+  resolution: "es-abstract@npm:1.24.2"
+  dependencies:
+    array-buffer-byte-length: "npm:^1.0.2"
+    arraybuffer.prototype.slice: "npm:^1.0.4"
+    available-typed-arrays: "npm:^1.0.7"
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.4"
+    data-view-buffer: "npm:^1.0.2"
+    data-view-byte-length: "npm:^1.0.2"
+    data-view-byte-offset: "npm:^1.0.1"
+    es-define-property: "npm:^1.0.1"
+    es-errors: "npm:^1.3.0"
+    es-object-atoms: "npm:^1.1.1"
+    es-set-tostringtag: "npm:^2.1.0"
+    es-to-primitive: "npm:^1.3.0"
+    function.prototype.name: "npm:^1.1.8"
+    get-intrinsic: "npm:^1.3.0"
+    get-proto: "npm:^1.0.1"
+    get-symbol-description: "npm:^1.1.0"
+    globalthis: "npm:^1.0.4"
+    gopd: "npm:^1.2.0"
+    has-property-descriptors: "npm:^1.0.2"
+    has-proto: "npm:^1.2.0"
+    has-symbols: "npm:^1.1.0"
+    hasown: "npm:^2.0.2"
+    internal-slot: "npm:^1.1.0"
+    is-array-buffer: "npm:^3.0.5"
+    is-callable: "npm:^1.2.7"
+    is-data-view: "npm:^1.0.2"
+    is-negative-zero: "npm:^2.0.3"
+    is-regex: "npm:^1.2.1"
+    is-set: "npm:^2.0.3"
+    is-shared-array-buffer: "npm:^1.0.4"
+    is-string: "npm:^1.1.1"
+    is-typed-array: "npm:^1.1.15"
+    is-weakref: "npm:^1.1.1"
+    math-intrinsics: "npm:^1.1.0"
+    object-inspect: "npm:^1.13.4"
+    object-keys: "npm:^1.1.1"
+    object.assign: "npm:^4.1.7"
+    own-keys: "npm:^1.0.1"
+    regexp.prototype.flags: "npm:^1.5.4"
+    safe-array-concat: "npm:^1.1.3"
+    safe-push-apply: "npm:^1.0.0"
+    safe-regex-test: "npm:^1.1.0"
+    set-proto: "npm:^1.0.0"
+    stop-iteration-iterator: "npm:^1.1.0"
+    string.prototype.trim: "npm:^1.2.10"
+    string.prototype.trimend: "npm:^1.0.9"
+    string.prototype.trimstart: "npm:^1.0.8"
+    typed-array-buffer: "npm:^1.0.3"
+    typed-array-byte-length: "npm:^1.0.3"
+    typed-array-byte-offset: "npm:^1.0.4"
+    typed-array-length: "npm:^1.0.7"
+    unbox-primitive: "npm:^1.1.0"
+    which-typed-array: "npm:^1.1.19"
+  checksum: 10c0/67a5bf21ef5c7d775e6f6131a836323900b4d87194cf544394ac68fe31c57fa53828b978af4a4f551ef307f83a2f910a16b6b982760ad3ddc3dc471f98d5fd1b
+  languageName: node
+  linkType: hard
+
+"es-abstract@npm:^1.22.1, es-abstract@npm:^1.22.3, es-abstract@npm:^1.23.0, es-abstract@npm:^1.23.2, es-abstract@npm:^1.23.3":
   version: 1.23.3
   resolution: "es-abstract@npm:1.23.3"
   dependencies:
@@ -5828,32 +6608,41 @@ __metadata:
   languageName: node
   linkType: hard
 
-"es-errors@npm:^1.1.0, es-errors@npm:^1.2.1, es-errors@npm:^1.3.0":
+"es-errors@npm:^1.2.1, es-errors@npm:^1.3.0":
   version: 1.3.0
   resolution: "es-errors@npm:1.3.0"
   checksum: 10c0/0a61325670072f98d8ae3b914edab3559b6caa980f08054a3b872052640d91da01d38df55df797fcc916389d77fc92b8d5906cf028f4db46d7e3003abecbca85
   languageName: node
   linkType: hard
 
-"es-iterator-helpers@npm:^1.0.17":
-  version: 1.0.19
-  resolution: "es-iterator-helpers@npm:1.0.19"
+"es-iterator-helpers@npm:^1.2.1":
+  version: 1.3.2
+  resolution: "es-iterator-helpers@npm:1.3.2"
   dependencies:
-    call-bind: "npm:^1.0.7"
+    call-bind: "npm:^1.0.9"
+    call-bound: "npm:^1.0.4"
     define-properties: "npm:^1.2.1"
-    es-abstract: "npm:^1.23.3"
+    es-abstract: "npm:^1.24.2"
     es-errors: "npm:^1.3.0"
-    es-set-tostringtag: "npm:^2.0.3"
+    es-set-tostringtag: "npm:^2.1.0"
     function-bind: "npm:^1.1.2"
-    get-intrinsic: "npm:^1.2.4"
-    globalthis: "npm:^1.0.3"
+    get-intrinsic: "npm:^1.3.0"
+    globalthis: "npm:^1.0.4"
+    gopd: "npm:^1.2.0"
     has-property-descriptors: "npm:^1.0.2"
-    has-proto: "npm:^1.0.3"
-    has-symbols: "npm:^1.0.3"
-    internal-slot: "npm:^1.0.7"
-    iterator.prototype: "npm:^1.1.2"
-    safe-array-concat: "npm:^1.1.2"
-  checksum: 10c0/ae8f0241e383b3d197383b9842c48def7fce0255fb6ed049311b686ce295595d9e389b466f6a1b7d4e7bb92d82f5e716d6fae55e20c1040249bf976743b038c5
+    has-proto: "npm:^1.2.0"
+    has-symbols: "npm:^1.1.0"
+    internal-slot: "npm:^1.1.0"
+    iterator.prototype: "npm:^1.1.5"
+    math-intrinsics: "npm:^1.1.0"
+  checksum: 10c0/5ddf9e7a7c5052d02cd8eb18f75e160c628eea66862ccd22f0fee7a7b1d2d17565c7ccf183f8b52aa88470d55394d1022012bc4eb8f8ae65a22b36e0b3bef83a
+  languageName: node
+  linkType: hard
+
+"es-module-lexer@npm:^2.0.0":
+  version: 2.1.0
+  resolution: "es-module-lexer@npm:2.1.0"
+  checksum: 10c0/93bcf2454fa72d67fe3ccd0abef8ce7933f5840a319513418a643dd8e9c6aa8f49709cecfae02ded722805dd327232d30723a807cc52e6809d6ac697c62c29fb
   languageName: node
   linkType: hard
 
@@ -5918,6 +6707,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"es-to-primitive@npm:^1.3.0":
+  version: 1.3.0
+  resolution: "es-to-primitive@npm:1.3.0"
+  dependencies:
+    is-callable: "npm:^1.2.7"
+    is-date-object: "npm:^1.0.5"
+    is-symbol: "npm:^1.0.4"
+  checksum: 10c0/c7e87467abb0b438639baa8139f701a06537d2b9bc758f23e8622c3b42fd0fdb5bde0f535686119e446dd9d5e4c0f238af4e14960f4771877cf818d023f6730b
+  languageName: node
+  linkType: hard
+
 "esast-util-from-estree@npm:^2.0.0":
   version: 2.0.0
   resolution: "esast-util-from-estree@npm:2.0.0"
@@ -6029,10 +6829,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"escape-string-regexp@npm:4.0.0, escape-string-regexp@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "escape-string-regexp@npm:4.0.0"
-  checksum: 10c0/9497d4dd307d845bd7f75180d8188bb17ea8c151c1edbf6b6717c100e104d629dc2dfb687686181b0f4b7d732c7dfdc4d5e7a8ff72de1b0ca283a75bbb3a9cd9
+"escalade@npm:^3.2.0":
+  version: 3.2.0
+  resolution: "escalade@npm:3.2.0"
+  checksum: 10c0/ced4dd3a78e15897ed3be74e635110bbf3b08877b0a41be50dcb325ee0e0b5f65fc2d50e9845194d7c4633f327e2e1c6cce00a71b617c5673df0374201d67f65
   languageName: node
   linkType: hard
 
@@ -6050,6 +6850,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"escape-string-regexp@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "escape-string-regexp@npm:4.0.0"
+  checksum: 10c0/9497d4dd307d845bd7f75180d8188bb17ea8c151c1edbf6b6717c100e104d629dc2dfb687686181b0f4b7d732c7dfdc4d5e7a8ff72de1b0ca283a75bbb3a9cd9
+  languageName: node
+  linkType: hard
+
 "escape-string-regexp@npm:^5.0.0":
   version: 5.0.0
   resolution: "escape-string-regexp@npm:5.0.0"
@@ -6057,317 +6864,195 @@ __metadata:
   languageName: node
   linkType: hard
 
-"escodegen@npm:^2.0.0":
-  version: 2.1.0
-  resolution: "escodegen@npm:2.1.0"
-  dependencies:
-    esprima: "npm:^4.0.1"
-    estraverse: "npm:^5.2.0"
-    esutils: "npm:^2.0.2"
-    source-map: "npm:~0.6.1"
-  dependenciesMeta:
-    source-map:
-      optional: true
-  bin:
-    escodegen: bin/escodegen.js
-    esgenerate: bin/esgenerate.js
-  checksum: 10c0/e1450a1f75f67d35c061bf0d60888b15f62ab63aef9df1901cffc81cffbbb9e8b3de237c5502cf8613a017c1df3a3003881307c78835a1ab54d8c8d2206e01d3
-  languageName: node
-  linkType: hard
-
-"eslint-compat-utils@npm:^0.5.0":
-  version: 0.5.0
-  resolution: "eslint-compat-utils@npm:0.5.0"
+"eslint-compat-utils@npm:^0.5.1":
+  version: 0.5.1
+  resolution: "eslint-compat-utils@npm:0.5.1"
   dependencies:
     semver: "npm:^7.5.4"
   peerDependencies:
     eslint: ">=6.0.0"
-  checksum: 10c0/aea9ff05df3f4d5db95361c13cb89baf3669fe34ad73e5771843dbb5cafdc7a9636c6f93814a29d0e0b87f147846ddef6672b71e28c4e73f889b5ea8d1d454d2
-  languageName: node
-  linkType: hard
-
-"eslint-config-standard-with-typescript@npm:^43.0.1":
-  version: 43.0.1
-  resolution: "eslint-config-standard-with-typescript@npm:43.0.1"
-  dependencies:
-    "@typescript-eslint/parser": "npm:^6.4.0"
-    eslint-config-standard: "npm:17.1.0"
-  peerDependencies:
-    "@typescript-eslint/eslint-plugin": ^6.4.0
-    eslint: ^8.0.1
-    eslint-plugin-import: ^2.25.2
-    eslint-plugin-n: "^15.0.0 || ^16.0.0 "
-    eslint-plugin-promise: ^6.0.0
-    typescript: "*"
-  checksum: 10c0/e01d9fb0ee5b3a435417926f9356a572f9ba0393a2db4892421c383830aa29308fbe52ecc8395a2e5fc005acfba4465f470d23fcdf4f9c2060238e9907da0d28
-  languageName: node
-  linkType: hard
-
-"eslint-config-standard@npm:17.1.0, eslint-config-standard@npm:^17.1.0":
-  version: 17.1.0
-  resolution: "eslint-config-standard@npm:17.1.0"
-  peerDependencies:
-    eslint: ^8.0.1
-    eslint-plugin-import: ^2.25.2
-    eslint-plugin-n: "^15.0.0 || ^16.0.0 "
-    eslint-plugin-promise: ^6.0.0
-  checksum: 10c0/d32f37ec4bea541debd3a8c9e05227673a9b1a9977da078195ee55fb371813ddf1349c75f2c33d76699fe3412f1e303181795f146e8d0e546b94fa0dce2bfbf9
-  languageName: node
-  linkType: hard
-
-"eslint-config-startupjs@npm:^0.56.0-alpha.29":
-  version: 0.56.0-alpha.29
-  resolution: "eslint-config-startupjs@npm:0.56.0-alpha.29"
-  dependencies:
-    "@startupjs/eslint-plugin-react-pug": "npm:^0.8.3-3"
-    "@typescript-eslint/eslint-plugin": "npm:^6.20.0"
-    eslint-config-standard: "npm:^17.1.0"
-    eslint-config-standard-with-typescript: "npm:^43.0.1"
-    eslint-plugin-import: "npm:^2.29.1"
-    eslint-plugin-import-helpers: "npm:^1.3.1"
-    eslint-plugin-n: "npm:^16.6.2"
-    eslint-plugin-promise: "npm:^6.1.1"
-    eslint-plugin-react: "npm:^7.33.2"
-    eslint-plugin-react-hooks: "npm:^4.6.0"
-    eslint-plugin-startupjs: "npm:^0.56.0-alpha.29"
-  peerDependencies:
-    eslint: "*"
-    react: "*"
-    typescript: "*"
-  peerDependenciesMeta:
-    react:
-      optional: true
-    typescript:
-      optional: true
-  checksum: 10c0/6806150a739f0e226bad7c35a4c2faf6f7f88a902dc18160ccdfdcfc86e34c3f1e0d12a3a2e6ec2fabcc7499662475cbfb65204c3d88e7ea2638eae05864a59a
-  languageName: node
-  linkType: hard
-
-"eslint-import-resolver-node@npm:^0.3.9":
-  version: 0.3.9
-  resolution: "eslint-import-resolver-node@npm:0.3.9"
-  dependencies:
-    debug: "npm:^3.2.7"
-    is-core-module: "npm:^2.13.0"
-    resolve: "npm:^1.22.4"
-  checksum: 10c0/0ea8a24a72328a51fd95aa8f660dcca74c1429806737cf10261ab90cfcaaf62fd1eff664b76a44270868e0a932711a81b250053942595bcd00a93b1c1575dd61
-  languageName: node
-  linkType: hard
-
-"eslint-module-utils@npm:^2.8.0":
-  version: 2.8.1
-  resolution: "eslint-module-utils@npm:2.8.1"
-  dependencies:
-    debug: "npm:^3.2.7"
-  peerDependenciesMeta:
-    eslint:
-      optional: true
-  checksum: 10c0/1aeeb97bf4b688d28de136ee57c824480c37691b40fa825c711a4caf85954e94b99c06ac639d7f1f6c1d69223bd21bcb991155b3e589488e958d5b83dfd0f882
+  checksum: 10c0/325e815205fab70ebcd379f6d4b5d44c7d791bb8dfe0c9888233f30ebabd9418422595b53a781b946c768d9244d858540e5e6129a6b3dd6d606f467d599edc6c
   languageName: node
   linkType: hard
 
-"eslint-plugin-es-x@npm:^7.5.0":
-  version: 7.6.0
-  resolution: "eslint-plugin-es-x@npm:7.6.0"
+"eslint-plugin-es-x@npm:^7.8.0":
+  version: 7.8.0
+  resolution: "eslint-plugin-es-x@npm:7.8.0"
   dependencies:
     "@eslint-community/eslint-utils": "npm:^4.1.2"
-    "@eslint-community/regexpp": "npm:^4.6.0"
-    eslint-compat-utils: "npm:^0.5.0"
+    "@eslint-community/regexpp": "npm:^4.11.0"
+    eslint-compat-utils: "npm:^0.5.1"
   peerDependencies:
     eslint: ">=8"
-  checksum: 10c0/cb88c0a94dacdb65311563928c6ed0072939fff70e25f02e810329be388859ff60bf77b82096b639464293f49f98f83f7b5611b3331d0435d3bfca0c0ded5901
-  languageName: node
-  linkType: hard
-
-"eslint-plugin-import-helpers@npm:^1.3.1":
-  version: 1.3.1
-  resolution: "eslint-plugin-import-helpers@npm:1.3.1"
-  peerDependencies:
-    eslint: 5.x - 8.x
-  checksum: 10c0/35859fae44ca3505d108992a630ecd717458e2fc827f2a59e92554ed2263efb0c3eb65b985c98060b8efd60344d8c6749b68d5ccb3b632a07df2020a753ce94f
+  checksum: 10c0/002fda8c029bc5da41e24e7ac11654062831d675fc4f5f20d0de460e24bf1e05cd559000678ef3e46c48641190f4fc07ae3d57aa5e8b085ef5f67e5f63742614
   languageName: node
   linkType: hard
 
-"eslint-plugin-import@npm:^2.29.1":
-  version: 2.29.1
-  resolution: "eslint-plugin-import@npm:2.29.1"
+"eslint-plugin-n@npm:^17.23.2":
+  version: 17.24.0
+  resolution: "eslint-plugin-n@npm:17.24.0"
   dependencies:
-    array-includes: "npm:^3.1.7"
-    array.prototype.findlastindex: "npm:^1.2.3"
-    array.prototype.flat: "npm:^1.3.2"
-    array.prototype.flatmap: "npm:^1.3.2"
-    debug: "npm:^3.2.7"
-    doctrine: "npm:^2.1.0"
-    eslint-import-resolver-node: "npm:^0.3.9"
-    eslint-module-utils: "npm:^2.8.0"
-    hasown: "npm:^2.0.0"
-    is-core-module: "npm:^2.13.1"
-    is-glob: "npm:^4.0.3"
-    minimatch: "npm:^3.1.2"
-    object.fromentries: "npm:^2.0.7"
-    object.groupby: "npm:^1.0.1"
-    object.values: "npm:^1.1.7"
-    semver: "npm:^6.3.1"
-    tsconfig-paths: "npm:^3.15.0"
+    "@eslint-community/eslint-utils": "npm:^4.5.0"
+    enhanced-resolve: "npm:^5.17.1"
+    eslint-plugin-es-x: "npm:^7.8.0"
+    get-tsconfig: "npm:^4.8.1"
+    globals: "npm:^15.11.0"
+    globrex: "npm:^0.1.2"
+    ignore: "npm:^5.3.2"
+    semver: "npm:^7.6.3"
+    ts-declaration-location: "npm:^1.0.6"
   peerDependencies:
-    eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8
-  checksum: 10c0/5f35dfbf4e8e67f741f396987de9504ad125c49f4144508a93282b4ea0127e052bde65ab6def1f31b6ace6d5d430be698333f75bdd7dca3bc14226c92a083196
+    eslint: ">=8.23.0"
+  checksum: 10c0/65b6c9ccd4d69296df9bdc0517bdbbc71e5f1ec065e80623c49148ff7813829bd3568154a016fefc06749476f3fdadc0e1afa61a15695893a3ca3da161c9fe86
   languageName: node
   linkType: hard
 
-"eslint-plugin-n@npm:^16.6.2":
-  version: 16.6.2
-  resolution: "eslint-plugin-n@npm:16.6.2"
+"eslint-plugin-promise@npm:^7.2.1":
+  version: 7.2.1
+  resolution: "eslint-plugin-promise@npm:7.2.1"
   dependencies:
     "@eslint-community/eslint-utils": "npm:^4.4.0"
-    builtins: "npm:^5.0.1"
-    eslint-plugin-es-x: "npm:^7.5.0"
-    get-tsconfig: "npm:^4.7.0"
-    globals: "npm:^13.24.0"
-    ignore: "npm:^5.2.4"
-    is-builtin-module: "npm:^3.2.1"
-    is-core-module: "npm:^2.12.1"
-    minimatch: "npm:^3.1.2"
-    resolve: "npm:^1.22.2"
-    semver: "npm:^7.5.3"
-  peerDependencies:
-    eslint: ">=7.0.0"
-  checksum: 10c0/6008493754b51c6b9ce18c17e7c3d455b69444d2c454dd399a5c2f1b833bb5a649992052f141a5dd695d22e3946a518063b2dd01e872c67dc0294eb143b80633
-  languageName: node
-  linkType: hard
-
-"eslint-plugin-promise@npm:^6.1.1":
-  version: 6.1.1
-  resolution: "eslint-plugin-promise@npm:6.1.1"
   peerDependencies:
-    eslint: ^7.0.0 || ^8.0.0
-  checksum: 10c0/ec705741c110cd1cb4d702776e1c7f7fe60b671b71f706c88054ab443cf2767aae5a663928fb426373ba1095eaeda312a740a4f880546631f0e0727f298b3393
+    eslint: ^7.0.0 || ^8.0.0 || ^9.0.0
+  checksum: 10c0/d494982faeeafbd2aa5fae9cbceca546169a8399000f72d5d940fa5c4ba554612903bcafbb8033647179e5d21ccf1d621b433d089695f7f47ce3d9fcf4cd0abf
   languageName: node
   linkType: hard
 
-"eslint-plugin-react-hooks@npm:^4.6.0":
-  version: 4.6.2
-  resolution: "eslint-plugin-react-hooks@npm:4.6.2"
+"eslint-plugin-react-hooks@npm:^7.1.1":
+  version: 7.1.1
+  resolution: "eslint-plugin-react-hooks@npm:7.1.1"
+  dependencies:
+    "@babel/core": "npm:^7.24.4"
+    "@babel/parser": "npm:^7.24.4"
+    hermes-parser: "npm:^0.25.1"
+    zod: "npm:^3.25.0 || ^4.0.0"
+    zod-validation-error: "npm:^3.5.0 || ^4.0.0"
   peerDependencies:
-    eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0
-  checksum: 10c0/4844e58c929bc05157fb70ba1e462e34f1f4abcbc8dd5bbe5b04513d33e2699effb8bca668297976ceea8e7ebee4e8fc29b9af9d131bcef52886feaa2308b2cc
+    eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0 || ^10.0.0
+  checksum: 10c0/cee8454915d71ac5d70a0d8f4f260e76eaf45fcd4162747dd4282b792ee5616d187351dabe6cdcff9040c79d0cec625635c4fd0777276be119efa88ebe058525
   languageName: node
   linkType: hard
 
-"eslint-plugin-react@npm:*, eslint-plugin-react@npm:^7.33.2":
-  version: 7.34.1
-  resolution: "eslint-plugin-react@npm:7.34.1"
+"eslint-plugin-react@npm:^7.37.5":
+  version: 7.37.5
+  resolution: "eslint-plugin-react@npm:7.37.5"
   dependencies:
-    array-includes: "npm:^3.1.7"
-    array.prototype.findlast: "npm:^1.2.4"
-    array.prototype.flatmap: "npm:^1.3.2"
-    array.prototype.toreversed: "npm:^1.1.2"
-    array.prototype.tosorted: "npm:^1.1.3"
+    array-includes: "npm:^3.1.8"
+    array.prototype.findlast: "npm:^1.2.5"
+    array.prototype.flatmap: "npm:^1.3.3"
+    array.prototype.tosorted: "npm:^1.1.4"
     doctrine: "npm:^2.1.0"
-    es-iterator-helpers: "npm:^1.0.17"
+    es-iterator-helpers: "npm:^1.2.1"
     estraverse: "npm:^5.3.0"
+    hasown: "npm:^2.0.2"
     jsx-ast-utils: "npm:^2.4.1 || ^3.0.0"
     minimatch: "npm:^3.1.2"
-    object.entries: "npm:^1.1.7"
-    object.fromentries: "npm:^2.0.7"
-    object.hasown: "npm:^1.1.3"
-    object.values: "npm:^1.1.7"
+    object.entries: "npm:^1.1.9"
+    object.fromentries: "npm:^2.0.8"
+    object.values: "npm:^1.2.1"
     prop-types: "npm:^15.8.1"
     resolve: "npm:^2.0.0-next.5"
     semver: "npm:^6.3.1"
-    string.prototype.matchall: "npm:^4.0.10"
-  peerDependencies:
-    eslint: ^3 || ^4 || ^5 || ^6 || ^7 || ^8
-  checksum: 10c0/7c61b1314d37a4ac2f2474f9571f801f1a1a5d81dcd4abbb5d07145406518722fb792367267757ee116bde254be9753242d6b93c9619110398b3fe1746e4848c
-  languageName: node
-  linkType: hard
-
-"eslint-plugin-startupjs@npm:^0.56.0-alpha.29":
-  version: 0.56.0-alpha.29
-  resolution: "eslint-plugin-startupjs@npm:0.56.0-alpha.29"
+    string.prototype.matchall: "npm:^4.0.12"
+    string.prototype.repeat: "npm:^1.0.0"
   peerDependencies:
-    eslint: "*"
-  checksum: 10c0/02fd5ebbb1cb03a979e14b14903d327184f5a2f0ba50534f9b6f70366ad354228ba4433e82c6b226be408732152162d93ccfdc242d12424bcda3cc55443f13c8
+    eslint: ^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9.7
+  checksum: 10c0/c850bfd556291d4d9234f5ca38db1436924a1013627c8ab1853f77cac73ec19b020e861e6c7b783436a48b6ffcdfba4547598235a37ad4611b6739f65fd8ad57
   languageName: node
   linkType: hard
 
-"eslint-scope@npm:^7.2.2":
-  version: 7.2.2
-  resolution: "eslint-scope@npm:7.2.2"
+"eslint-scope@npm:^8.4.0":
+  version: 8.4.0
+  resolution: "eslint-scope@npm:8.4.0"
   dependencies:
     esrecurse: "npm:^4.3.0"
     estraverse: "npm:^5.2.0"
-  checksum: 10c0/613c267aea34b5a6d6c00514e8545ef1f1433108097e857225fed40d397dd6b1809dffd11c2fde23b37ca53d7bf935fe04d2a18e6fc932b31837b6ad67e1c116
+  checksum: 10c0/407f6c600204d0f3705bd557f81bd0189e69cd7996f408f8971ab5779c0af733d1af2f1412066b40ee1588b085874fc37a2333986c6521669cdbdd36ca5058e0
   languageName: node
   linkType: hard
 
-"eslint-visitor-keys@npm:^3.3.0, eslint-visitor-keys@npm:^3.4.1, eslint-visitor-keys@npm:^3.4.3":
+"eslint-visitor-keys@npm:^3.3.0, eslint-visitor-keys@npm:^3.4.3":
   version: 3.4.3
   resolution: "eslint-visitor-keys@npm:3.4.3"
   checksum: 10c0/92708e882c0a5ffd88c23c0b404ac1628cf20104a108c745f240a13c332a11aac54f49a22d5762efbffc18ecbc9a580d1b7ad034bf5f3cc3307e5cbff2ec9820
   languageName: node
   linkType: hard
 
-"eslint@npm:^8.56.0":
-  version: 8.57.0
-  resolution: "eslint@npm:8.57.0"
+"eslint-visitor-keys@npm:^4.2.0, eslint-visitor-keys@npm:^4.2.1":
+  version: 4.2.1
+  resolution: "eslint-visitor-keys@npm:4.2.1"
+  checksum: 10c0/fcd43999199d6740db26c58dbe0c2594623e31ca307e616ac05153c9272f12f1364f5a0b1917a8e962268fdecc6f3622c1c2908b4fcc2e047a106fe6de69dc43
+  languageName: node
+  linkType: hard
+
+"eslint-visitor-keys@npm:^5.0.0":
+  version: 5.0.1
+  resolution: "eslint-visitor-keys@npm:5.0.1"
+  checksum: 10c0/16190bdf2cbae40a1109384c94450c526a79b0b9c3cb21e544256ed85ac48a4b84db66b74a6561d20fe6ab77447f150d711c2ad5ad74df4fcc133736bce99678
+  languageName: node
+  linkType: hard
+
+"eslint@npm:^9.39.4":
+  version: 9.39.4
+  resolution: "eslint@npm:9.39.4"
   dependencies:
-    "@eslint-community/eslint-utils": "npm:^4.2.0"
-    "@eslint-community/regexpp": "npm:^4.6.1"
-    "@eslint/eslintrc": "npm:^2.1.4"
-    "@eslint/js": "npm:8.57.0"
-    "@humanwhocodes/config-array": "npm:^0.11.14"
+    "@eslint-community/eslint-utils": "npm:^4.8.0"
+    "@eslint-community/regexpp": "npm:^4.12.1"
+    "@eslint/config-array": "npm:^0.21.2"
+    "@eslint/config-helpers": "npm:^0.4.2"
+    "@eslint/core": "npm:^0.17.0"
+    "@eslint/eslintrc": "npm:^3.3.5"
+    "@eslint/js": "npm:9.39.4"
+    "@eslint/plugin-kit": "npm:^0.4.1"
+    "@humanfs/node": "npm:^0.16.6"
     "@humanwhocodes/module-importer": "npm:^1.0.1"
-    "@nodelib/fs.walk": "npm:^1.2.8"
-    "@ungap/structured-clone": "npm:^1.2.0"
-    ajv: "npm:^6.12.4"
+    "@humanwhocodes/retry": "npm:^0.4.2"
+    "@types/estree": "npm:^1.0.6"
+    ajv: "npm:^6.14.0"
     chalk: "npm:^4.0.0"
-    cross-spawn: "npm:^7.0.2"
+    cross-spawn: "npm:^7.0.6"
     debug: "npm:^4.3.2"
-    doctrine: "npm:^3.0.0"
     escape-string-regexp: "npm:^4.0.0"
-    eslint-scope: "npm:^7.2.2"
-    eslint-visitor-keys: "npm:^3.4.3"
-    espree: "npm:^9.6.1"
-    esquery: "npm:^1.4.2"
+    eslint-scope: "npm:^8.4.0"
+    eslint-visitor-keys: "npm:^4.2.1"
+    espree: "npm:^10.4.0"
+    esquery: "npm:^1.5.0"
     esutils: "npm:^2.0.2"
     fast-deep-equal: "npm:^3.1.3"
-    file-entry-cache: "npm:^6.0.1"
+    file-entry-cache: "npm:^8.0.0"
     find-up: "npm:^5.0.0"
     glob-parent: "npm:^6.0.2"
-    globals: "npm:^13.19.0"
-    graphemer: "npm:^1.4.0"
     ignore: "npm:^5.2.0"
     imurmurhash: "npm:^0.1.4"
     is-glob: "npm:^4.0.0"
-    is-path-inside: "npm:^3.0.3"
-    js-yaml: "npm:^4.1.0"
     json-stable-stringify-without-jsonify: "npm:^1.0.1"
-    levn: "npm:^0.4.1"
     lodash.merge: "npm:^4.6.2"
-    minimatch: "npm:^3.1.2"
+    minimatch: "npm:^3.1.5"
     natural-compare: "npm:^1.4.0"
     optionator: "npm:^0.9.3"
-    strip-ansi: "npm:^6.0.1"
-    text-table: "npm:^0.2.0"
+  peerDependencies:
+    jiti: "*"
+  peerDependenciesMeta:
+    jiti:
+      optional: true
   bin:
     eslint: bin/eslint.js
-  checksum: 10c0/00bb96fd2471039a312435a6776fe1fd557c056755eaa2b96093ef3a8508c92c8775d5f754768be6b1dddd09fdd3379ddb231eeb9b6c579ee17ea7d68000a529
+  checksum: 10c0/1955067c2d991f0c84f4c4abfafe31bb47fa3b717a7fd3e43fe1e511c6f859d7700cbca969f85661dc4c130f7aeced5e5444884314198a54428f5e5141db9337
   languageName: node
   linkType: hard
 
-"espree@npm:^9.6.0, espree@npm:^9.6.1":
-  version: 9.6.1
-  resolution: "espree@npm:9.6.1"
+"espree@npm:^10.0.1, espree@npm:^10.3.0, espree@npm:^10.4.0":
+  version: 10.4.0
+  resolution: "espree@npm:10.4.0"
   dependencies:
-    acorn: "npm:^8.9.0"
+    acorn: "npm:^8.15.0"
     acorn-jsx: "npm:^5.3.2"
-    eslint-visitor-keys: "npm:^3.4.1"
-  checksum: 10c0/1a2e9b4699b715347f62330bcc76aee224390c28bb02b31a3752e9d07549c473f5f986720483c6469cf3cfb3c9d05df612ffc69eb1ee94b54b739e67de9bb460
+    eslint-visitor-keys: "npm:^4.2.1"
+  checksum: 10c0/c63fe06131c26c8157b4083313cb02a9a54720a08e21543300e55288c40e06c3fc284bdecf108d3a1372c5934a0a88644c98714f38b6ae8ed272b40d9ea08d6b
   languageName: node
   linkType: hard
 
-"esprima@npm:^4.0.0, esprima@npm:^4.0.1":
+"esprima@npm:^4.0.0":
   version: 4.0.1
   resolution: "esprima@npm:4.0.1"
   bin:
@@ -6377,12 +7062,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"esquery@npm:^1.4.2":
-  version: 1.5.0
-  resolution: "esquery@npm:1.5.0"
+"esquery@npm:^1.5.0":
+  version: 1.7.0
+  resolution: "esquery@npm:1.7.0"
   dependencies:
     estraverse: "npm:^5.1.0"
-  checksum: 10c0/a084bd049d954cc88ac69df30534043fb2aee5555b56246493f42f27d1e168f00d9e5d4192e46f10290d312dc30dc7d58994d61a609c579c1219d636996f9213
+  checksum: 10c0/77d5173db450b66f3bc685d11af4c90cffeedb340f34a39af96d43509a335ce39c894fd79233df32d38f5e4e219fa0f7076f6ec90bae8320170ba082c0db4793
   languageName: node
   linkType: hard
 
@@ -6461,7 +7146,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"estree-walker@npm:^3.0.0":
+"estree-walker@npm:^3.0.0, estree-walker@npm:^3.0.3":
   version: 3.0.3
   resolution: "estree-walker@npm:3.0.3"
   dependencies:
@@ -6557,7 +7242,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"execa@npm:^5.0.0":
+"execa@npm:^5.1.1":
   version: 5.1.1
   resolution: "execa@npm:5.1.1"
   dependencies:
@@ -6574,10 +7259,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"exit@npm:^0.1.2":
-  version: 0.1.2
-  resolution: "exit@npm:0.1.2"
-  checksum: 10c0/71d2ad9b36bc25bb8b104b17e830b40a08989be7f7d100b13269aaae7c3784c3e6e1e88a797e9e87523993a25ba27c8958959a554535370672cfb4d824af8989
+"exit-x@npm:^0.2.2":
+  version: 0.2.2
+  resolution: "exit-x@npm:0.2.2"
+  checksum: 10c0/212a7a095ca5540e9581f1ef2d1d6a40df7a6027c8cc96e78ce1d16b86d1a88326d4a0eff8dff2b5ec1e68bb0c1edd5d0dfdde87df1869bf7514d4bc6a5cbd72
   languageName: node
   linkType: hard
 
@@ -6588,16 +7273,24 @@ __metadata:
   languageName: node
   linkType: hard
 
-"expect@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "expect@npm:29.7.0"
+"expect-type@npm:^1.3.0":
+  version: 1.3.0
+  resolution: "expect-type@npm:1.3.0"
+  checksum: 10c0/8412b3fe4f392c420ab41dae220b09700e4e47c639a29ba7ba2e83cc6cffd2b4926f7ac9e47d7e277e8f4f02acda76fd6931cb81fd2b382fa9477ef9ada953fd
+  languageName: node
+  linkType: hard
+
+"expect@npm:30.3.0":
+  version: 30.3.0
+  resolution: "expect@npm:30.3.0"
   dependencies:
-    "@jest/expect-utils": "npm:^29.7.0"
-    jest-get-type: "npm:^29.6.3"
-    jest-matcher-utils: "npm:^29.7.0"
-    jest-message-util: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-  checksum: 10c0/2eddeace66e68b8d8ee5f7be57f3014b19770caaf6815c7a08d131821da527fb8c8cb7b3dcd7c883d2d3d8d184206a4268984618032d1e4b16dc8d6596475d41
+    "@jest/expect-utils": "npm:30.3.0"
+    "@jest/get-type": "npm:30.1.0"
+    jest-matcher-utils: "npm:30.3.0"
+    jest-message-util: "npm:30.3.0"
+    jest-mock: "npm:30.3.0"
+    jest-util: "npm:30.3.0"
+  checksum: 10c0/a07a157a0c8b3f1e29bfe5ccbf03a3add2c69fe60d1af8a0980053bb6403d721d5f5e4616f1ea5833b747913f8c880c79ce4d98c23a71a2f0c27cf7273892576
   languageName: node
   linkType: hard
 
@@ -6638,19 +7331,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fast-glob@npm:^3.2.9":
-  version: 3.3.2
-  resolution: "fast-glob@npm:3.3.2"
-  dependencies:
-    "@nodelib/fs.stat": "npm:^2.0.2"
-    "@nodelib/fs.walk": "npm:^1.2.3"
-    glob-parent: "npm:^5.1.2"
-    merge2: "npm:^1.3.0"
-    micromatch: "npm:^4.0.4"
-  checksum: 10c0/42baad7b9cd40b63e42039132bde27ca2cb3a4950d0a0f9abe4639ea1aa9d3e3b40f98b1fe31cbc0cc17b664c9ea7447d911a152fa34ec5b72977b125a6fc845
-  languageName: node
-  linkType: hard
-
 "fast-json-stable-stringify@npm:^2.0.0, fast-json-stable-stringify@npm:^2.1.0":
   version: 2.1.0
   resolution: "fast-json-stable-stringify@npm:2.1.0"
@@ -6665,15 +7345,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fastq@npm:^1.6.0":
-  version: 1.17.1
-  resolution: "fastq@npm:1.17.1"
-  dependencies:
-    reusify: "npm:^1.0.4"
-  checksum: 10c0/1095f16cea45fb3beff558bb3afa74ca7a9250f5a670b65db7ed585f92b4b48381445cd328b3d87323da81e43232b5d5978a8201bde84e0cd514310f1ea6da34
-  languageName: node
-  linkType: hard
-
 "faye-websocket@npm:^0.11.3, faye-websocket@npm:^0.11.4":
   version: 0.11.4
   resolution: "faye-websocket@npm:0.11.4"
@@ -6683,7 +7354,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fb-watchman@npm:^2.0.0":
+"fb-watchman@npm:^2.0.2":
   version: 2.0.2
   resolution: "fb-watchman@npm:2.0.2"
   dependencies:
@@ -6733,12 +7404,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"file-entry-cache@npm:^6.0.1":
-  version: 6.0.1
-  resolution: "file-entry-cache@npm:6.0.1"
+"file-entry-cache@npm:^8.0.0":
+  version: 8.0.0
+  resolution: "file-entry-cache@npm:8.0.0"
   dependencies:
-    flat-cache: "npm:^3.0.4"
-  checksum: 10c0/58473e8a82794d01b38e5e435f6feaf648e3f36fdb3a56e98f417f4efae71ad1c0d4ebd8a9a7c50c3ad085820a93fc7494ad721e0e4ebc1da3573f4e1c3c7cdd
+    flat-cache: "npm:^4.0.0"
+  checksum: 10c0/9e2b5938b1cd9b6d7e3612bdc533afd4ac17b2fc646569e9a8abbf2eb48e5eb8e316bc38815a3ef6a1b456f4107f0d0f055a614ca613e75db6bf9ff4d72c1638
   languageName: node
   linkType: hard
 
@@ -6767,23 +7438,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"find-line-column@npm:^0.5.2":
-  version: 0.5.2
-  resolution: "find-line-column@npm:0.5.2"
-  checksum: 10c0/c8461cedfc3bf6af5ee506632dd35e03356af44bbadde532611ed7d119badee64db67dfe2ecf1b116801c891760c09062cf7cea17352706624768ada0706e84a
-  languageName: node
-  linkType: hard
-
-"find-up@npm:5.0.0, find-up@npm:^5.0.0":
-  version: 5.0.0
-  resolution: "find-up@npm:5.0.0"
-  dependencies:
-    locate-path: "npm:^6.0.0"
-    path-exists: "npm:^4.0.0"
-  checksum: 10c0/062c5a83a9c02f53cdd6d175a37ecf8f87ea5bbff1fdfb828f04bfa021441bc7583e8ebc0872a4c1baab96221fb8a8a275a19809fb93fbc40bd69ec35634069a
-  languageName: node
-  linkType: hard
-
 "find-up@npm:^2.0.0":
   version: 2.1.0
   resolution: "find-up@npm:2.1.0"
@@ -6803,6 +7457,26 @@ __metadata:
   languageName: node
   linkType: hard
 
+"find-up@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "find-up@npm:5.0.0"
+  dependencies:
+    locate-path: "npm:^6.0.0"
+    path-exists: "npm:^4.0.0"
+  checksum: 10c0/062c5a83a9c02f53cdd6d175a37ecf8f87ea5bbff1fdfb828f04bfa021441bc7583e8ebc0872a4c1baab96221fb8a8a275a19809fb93fbc40bd69ec35634069a
+  languageName: node
+  linkType: hard
+
+"find-up@npm:^8.0.0":
+  version: 8.0.0
+  resolution: "find-up@npm:8.0.0"
+  dependencies:
+    locate-path: "npm:^8.0.0"
+    unicorn-magic: "npm:^0.3.0"
+  checksum: 10c0/4c6d2cb92f74bd42ec7344c881a46f6455010d3993f8f55b09bb64298c0a13e11e10200147624db8938590890a15ade69c40f0172698388d0999899f0f2a70a5
+  languageName: node
+  linkType: hard
+
 "find-versions@npm:^4.0.0":
   version: 4.0.0
   resolution: "find-versions@npm:4.0.0"
@@ -6812,14 +7486,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"flat-cache@npm:^3.0.4":
-  version: 3.2.0
-  resolution: "flat-cache@npm:3.2.0"
+"flat-cache@npm:^4.0.0":
+  version: 4.0.1
+  resolution: "flat-cache@npm:4.0.1"
   dependencies:
     flatted: "npm:^3.2.9"
-    keyv: "npm:^4.5.3"
-    rimraf: "npm:^3.0.2"
-  checksum: 10c0/b76f611bd5f5d68f7ae632e3ae503e678d205cf97a17c6ab5b12f6ca61188b5f1f7464503efae6dc18683ed8f0b41460beb48ac4b9ac63fe6201296a91ba2f75
+    keyv: "npm:^4.5.4"
+  checksum: 10c0/2c59d93e9faa2523e4fda6b4ada749bed432cfa28c8e251f33b25795e426a1c6dbada777afb1f74fcfff33934fdbdea921ee738fcc33e71adc9d6eca984a1cfc
   languageName: node
   linkType: hard
 
@@ -6865,6 +7538,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"for-each@npm:^0.3.5":
+  version: 0.3.5
+  resolution: "for-each@npm:0.3.5"
+  dependencies:
+    is-callable: "npm:^1.2.7"
+  checksum: 10c0/0e0b50f6a843a282637d43674d1fb278dda1dd85f4f99b640024cfb10b85058aac0cc781bf689d5fe50b4b7f638e91e548560723a4e76e04fe96ae35ef039cee
+  languageName: node
+  linkType: hard
+
 "foreground-child@npm:^3.1.0":
   version: 3.1.1
   resolution: "foreground-child@npm:3.1.1"
@@ -6885,17 +7567,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"form-data@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "form-data@npm:4.0.0"
-  dependencies:
-    asynckit: "npm:^0.4.0"
-    combined-stream: "npm:^1.0.8"
-    mime-types: "npm:^2.1.12"
-  checksum: 10c0/cb6f3ac49180be03ff07ba3ff125f9eba2ff0b277fb33c7fc47569fc5e616882c5b1c69b9904c4c4187e97dd0419dd03b134174756f296dec62041e6527e2c6e
-  languageName: node
-  linkType: hard
-
 "form-data@npm:^4.0.4":
   version: 4.0.5
   resolution: "form-data@npm:4.0.5"
@@ -6961,7 +7632,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fsevents@npm:^2.3.2, fsevents@npm:~2.3.1, fsevents@npm:~2.3.2":
+"fsevents@npm:^2.3.3, fsevents@npm:~2.3.2, fsevents@npm:~2.3.3":
   version: 2.3.3
   resolution: "fsevents@npm:2.3.3"
   dependencies:
@@ -6971,7 +7642,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fsevents@patch:fsevents@npm%3A^2.3.2#optional!builtin<compat/fsevents>, fsevents@patch:fsevents@npm%3A~2.3.1#optional!builtin<compat/fsevents>, fsevents@patch:fsevents@npm%3A~2.3.2#optional!builtin<compat/fsevents>":
+"fsevents@patch:fsevents@npm%3A^2.3.3#optional!builtin<compat/fsevents>, fsevents@patch:fsevents@npm%3A~2.3.2#optional!builtin<compat/fsevents>, fsevents@patch:fsevents@npm%3A~2.3.3#optional!builtin<compat/fsevents>":
   version: 2.3.3
   resolution: "fsevents@patch:fsevents@npm%3A2.3.3#optional!builtin<compat/fsevents>::version=2.3.3&hash=df0bf1"
   dependencies:
@@ -6987,7 +7658,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"function.prototype.name@npm:^1.1.5, function.prototype.name@npm:^1.1.6":
+"function.prototype.name@npm:^1.1.6":
   version: 1.1.6
   resolution: "function.prototype.name@npm:1.1.6"
   dependencies:
@@ -6999,6 +7670,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"function.prototype.name@npm:^1.1.8":
+  version: 1.1.8
+  resolution: "function.prototype.name@npm:1.1.8"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.3"
+    define-properties: "npm:^1.2.1"
+    functions-have-names: "npm:^1.2.3"
+    hasown: "npm:^2.0.2"
+    is-callable: "npm:^1.2.7"
+  checksum: 10c0/e920a2ab52663005f3cbe7ee3373e3c71c1fb5558b0b0548648cdf3e51961085032458e26c71ff1a8c8c20e7ee7caeb03d43a5d1fa8610c459333323a2e71253
+  languageName: node
+  linkType: hard
+
 "functions-have-names@npm:^1.2.3":
   version: 1.2.3
   resolution: "functions-have-names@npm:1.2.3"
@@ -7063,7 +7748,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"get-intrinsic@npm:^1.2.6":
+"get-intrinsic@npm:^1.2.5, get-intrinsic@npm:^1.2.6, get-intrinsic@npm:^1.2.7, get-intrinsic@npm:^1.3.0":
   version: 1.3.1
   resolution: "get-intrinsic@npm:1.3.1"
   dependencies:
@@ -7112,7 +7797,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"get-proto@npm:^1.0.1":
+"get-proto@npm:^1.0.0, get-proto@npm:^1.0.1":
   version: 1.0.1
   resolution: "get-proto@npm:1.0.1"
   dependencies:
@@ -7154,12 +7839,23 @@ __metadata:
   languageName: node
   linkType: hard
 
-"get-tsconfig@npm:^4.7.0":
-  version: 4.7.5
-  resolution: "get-tsconfig@npm:4.7.5"
+"get-symbol-description@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "get-symbol-description@npm:1.1.0"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    es-errors: "npm:^1.3.0"
+    get-intrinsic: "npm:^1.2.6"
+  checksum: 10c0/d6a7d6afca375779a4b307738c9e80dbf7afc0bdbe5948768d54ab9653c865523d8920e670991a925936eb524b7cb6a6361d199a760b21d0ca7620194455aa4b
+  languageName: node
+  linkType: hard
+
+"get-tsconfig@npm:^4.8.1":
+  version: 4.14.0
+  resolution: "get-tsconfig@npm:4.14.0"
   dependencies:
     resolve-pkg-maps: "npm:^1.0.0"
-  checksum: 10c0/a917dff2ba9ee187c41945736bf9bbab65de31ce5bc1effd76267be483a7340915cff232199406379f26517d2d0a4edcdbcda8cca599c2480a0f2cf1e1de3efa
+  checksum: 10c0/abc2b9275468eb589079a0b7a95eb5107c14fdd0ca6dda1bff116fe774ea1f79975421dcb22a0c86b4f820fcc69a7655dddf9b6d6a8a2c06fcb59e19794c0724
   languageName: node
   linkType: hard
 
@@ -7249,7 +7945,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"glob-parent@npm:^5.1.2, glob-parent@npm:~5.1.0, glob-parent@npm:~5.1.2":
+"glob-parent@npm:~5.1.2":
   version: 5.1.2
   resolution: "glob-parent@npm:5.1.2"
   dependencies:
@@ -7258,20 +7954,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"glob@npm:7.1.6":
-  version: 7.1.6
-  resolution: "glob@npm:7.1.6"
-  dependencies:
-    fs.realpath: "npm:^1.0.0"
-    inflight: "npm:^1.0.4"
-    inherits: "npm:2"
-    minimatch: "npm:^3.0.4"
-    once: "npm:^1.3.0"
-    path-is-absolute: "npm:^1.0.0"
-  checksum: 10c0/2575cce9306ac534388db751f0aa3e78afedb6af8f3b529ac6b2354f66765545145dba8530abf7bff49fb399a047d3f9b6901c38ee4c9503f592960d9af67763
-  languageName: node
-  linkType: hard
-
 "glob@npm:^10.2.2, glob@npm:^10.3.10":
   version: 10.3.16
   resolution: "glob@npm:10.3.16"
@@ -7287,9 +7969,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"glob@npm:^10.4.1":
-  version: 10.5.0
-  resolution: "glob@npm:10.5.0"
+"glob@npm:^10.4.5":
+  version: 10.4.5
+  resolution: "glob@npm:10.4.5"
   dependencies:
     foreground-child: "npm:^3.1.0"
     jackspeak: "npm:^3.1.2"
@@ -7299,13 +7981,13 @@ __metadata:
     path-scurry: "npm:^1.11.1"
   bin:
     glob: dist/esm/bin.mjs
-  checksum: 10c0/100705eddbde6323e7b35e1d1ac28bcb58322095bd8e63a7d0bef1a2cdafe0d0f7922a981b2b48369a4f8c1b077be5c171804534c3509dfe950dde15fbe6d828
+  checksum: 10c0/19a9759ea77b8e3ca0a43c2f07ecddc2ad46216b786bb8f993c445aee80d345925a21e5280c7b7c6c59e860a0154b84e4b2b60321fea92cd3c56b4a7489f160e
   languageName: node
   linkType: hard
 
-"glob@npm:^10.4.5":
-  version: 10.4.5
-  resolution: "glob@npm:10.4.5"
+"glob@npm:^10.5.0":
+  version: 10.5.0
+  resolution: "glob@npm:10.5.0"
   dependencies:
     foreground-child: "npm:^3.1.0"
     jackspeak: "npm:^3.1.2"
@@ -7315,7 +7997,7 @@ __metadata:
     path-scurry: "npm:^1.11.1"
   bin:
     glob: dist/esm/bin.mjs
-  checksum: 10c0/19a9759ea77b8e3ca0a43c2f07ecddc2ad46216b786bb8f993c445aee80d345925a21e5280c7b7c6c59e860a0154b84e4b2b60321fea92cd3c56b4a7489f160e
+  checksum: 10c0/100705eddbde6323e7b35e1d1ac28bcb58322095bd8e63a7d0bef1a2cdafe0d0f7922a981b2b48369a4f8c1b077be5c171804534c3509dfe950dde15fbe6d828
   languageName: node
   linkType: hard
 
@@ -7346,7 +8028,18 @@ __metadata:
   languageName: node
   linkType: hard
 
-"glob@npm:^7.0.3, glob@npm:^7.1.3, glob@npm:^7.1.4":
+"glob@npm:^13.0.6":
+  version: 13.0.6
+  resolution: "glob@npm:13.0.6"
+  dependencies:
+    minimatch: "npm:^10.2.2"
+    minipass: "npm:^7.1.3"
+    path-scurry: "npm:^2.0.2"
+  checksum: 10c0/269c236f11a9b50357fe7a8c6aadac667e01deb5242b19c84975628f05f4438d8ee1354bb62c5d6c10f37fd59911b54d7799730633a2786660d8c69f1d18120a
+  languageName: node
+  linkType: hard
+
+"glob@npm:^7.1.3, glob@npm:^7.1.4":
   version: 7.2.3
   resolution: "glob@npm:7.2.3"
   dependencies:
@@ -7379,16 +8072,28 @@ __metadata:
   languageName: node
   linkType: hard
 
-"globals@npm:^13.19.0, globals@npm:^13.24.0":
-  version: 13.24.0
-  resolution: "globals@npm:13.24.0"
-  dependencies:
-    type-fest: "npm:^0.20.2"
-  checksum: 10c0/d3c11aeea898eb83d5ec7a99508600fbe8f83d2cf00cbb77f873dbf2bcb39428eff1b538e4915c993d8a3b3473fa71eeebfe22c9bb3a3003d1e26b1f2c8a42cd
+"globals@npm:^14.0.0":
+  version: 14.0.0
+  resolution: "globals@npm:14.0.0"
+  checksum: 10c0/b96ff42620c9231ad468d4c58ff42afee7777ee1c963013ff8aabe095a451d0ceeb8dcd8ef4cbd64d2538cef45f787a78ba3a9574f4a634438963e334471302d
+  languageName: node
+  linkType: hard
+
+"globals@npm:^15.11.0":
+  version: 15.15.0
+  resolution: "globals@npm:15.15.0"
+  checksum: 10c0/f9ae80996392ca71316495a39bec88ac43ae3525a438b5626cd9d5ce9d5500d0a98a266409605f8cd7241c7acf57c354a48111ea02a767ba4f374b806d6861fe
+  languageName: node
+  linkType: hard
+
+"globals@npm:^17.3.0":
+  version: 17.5.0
+  resolution: "globals@npm:17.5.0"
+  checksum: 10c0/92828102ed2f5637907725f0478038bed02fc83e9fc89300bb753639ba7c022b6c02576fc772117302b431b204591db1f2fa909d26f3f0a9852cc856a941df3f
   languageName: node
   linkType: hard
 
-"globalthis@npm:^1.0.3":
+"globalthis@npm:^1.0.3, globalthis@npm:^1.0.4":
   version: 1.0.4
   resolution: "globalthis@npm:1.0.4"
   dependencies:
@@ -7396,19 +8101,12 @@ __metadata:
     gopd: "npm:^1.0.1"
   checksum: 10c0/9d156f313af79d80b1566b93e19285f481c591ad6d0d319b4be5e03750d004dde40a39a0f26f7e635f9007a3600802f53ecd85a759b86f109e80a5f705e01846
   languageName: node
-  linkType: hard
-
-"globby@npm:^11.1.0":
-  version: 11.1.0
-  resolution: "globby@npm:11.1.0"
-  dependencies:
-    array-union: "npm:^2.1.0"
-    dir-glob: "npm:^3.0.1"
-    fast-glob: "npm:^3.2.9"
-    ignore: "npm:^5.2.0"
-    merge2: "npm:^1.4.1"
-    slash: "npm:^3.0.0"
-  checksum: 10c0/b39511b4afe4bd8a7aead3a27c4ade2b9968649abab0a6c28b1a90141b96ca68ca5db1302f7c7bd29eab66bf51e13916b8e0a3d0ac08f75e1e84a39b35691189
+  linkType: hard
+
+"globrex@npm:^0.1.2":
+  version: 0.1.2
+  resolution: "globrex@npm:0.1.2"
+  checksum: 10c0/a54c029520cf58bda1d8884f72bd49b4cd74e977883268d931fd83bcbd1a9eb96d57c7dbd4ad80148fb9247467ebfb9b215630b2ed7563b2a8de02e1ff7f89d1
   languageName: node
   linkType: hard
 
@@ -7428,20 +8126,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"graceful-fs@npm:^4.1.11, graceful-fs@npm:^4.1.15, graceful-fs@npm:^4.1.2, graceful-fs@npm:^4.1.6, graceful-fs@npm:^4.2.0, graceful-fs@npm:^4.2.6, graceful-fs@npm:^4.2.9":
+"graceful-fs@npm:^4.1.11, graceful-fs@npm:^4.1.15, graceful-fs@npm:^4.1.2, graceful-fs@npm:^4.1.6, graceful-fs@npm:^4.2.0, graceful-fs@npm:^4.2.11, graceful-fs@npm:^4.2.4, graceful-fs@npm:^4.2.6":
   version: 4.2.11
   resolution: "graceful-fs@npm:4.2.11"
   checksum: 10c0/386d011a553e02bc594ac2ca0bd6d9e4c22d7fa8cfbfc448a6d148c59ea881b092db9dbe3547ae4b88e55f1b01f7c4a2ecc53b310c042793e63aa44cf6c257f2
   languageName: node
   linkType: hard
 
-"graphemer@npm:^1.4.0":
-  version: 1.4.0
-  resolution: "graphemer@npm:1.4.0"
-  checksum: 10c0/e951259d8cd2e0d196c72ec711add7115d42eb9a8146c8eeda5b8d3ac91e5dd816b9cd68920726d9fd4490368e7ed86e9c423f40db87e2d8dfafa00fa17c3a31
-  languageName: node
-  linkType: hard
-
 "gray-matter@npm:4.0.3":
   version: 4.0.3
   resolution: "gray-matter@npm:4.0.3"
@@ -7454,13 +8145,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"growl@npm:1.10.5":
-  version: 1.10.5
-  resolution: "growl@npm:1.10.5"
-  checksum: 10c0/a6a8f4df1269ac321f9e41c310552f3568768160942b6c9a7c116fcff1e3921f6a48fb7520689660412f7d1e5d46f76214e05406b23eee9e213830fdc2f772fe
-  languageName: node
-  linkType: hard
-
 "handlebars@npm:^4.7.7":
   version: 4.7.8
   resolution: "handlebars@npm:4.7.8"
@@ -7523,6 +8207,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"has-proto@npm:^1.2.0":
+  version: 1.2.0
+  resolution: "has-proto@npm:1.2.0"
+  dependencies:
+    dunder-proto: "npm:^1.0.0"
+  checksum: 10c0/46538dddab297ec2f43923c3d35237df45d8c55a6fc1067031e04c13ed8a9a8f94954460632fd4da84c31a1721eefee16d901cbb1ae9602bab93bb6e08f93b95
+  languageName: node
+  linkType: hard
+
 "has-symbols@npm:^1.0.2, has-symbols@npm:^1.0.3":
   version: 1.0.3
   resolution: "has-symbols@npm:1.0.3"
@@ -7745,7 +8438,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"he@npm:1.2.0, he@npm:^1.2.0":
+"he@npm:^1.2.0":
   version: 1.2.0
   resolution: "he@npm:1.2.0"
   bin:
@@ -7754,6 +8447,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"hermes-estree@npm:0.25.1":
+  version: 0.25.1
+  resolution: "hermes-estree@npm:0.25.1"
+  checksum: 10c0/48be3b2fa37a0cbc77a112a89096fa212f25d06de92781b163d67853d210a8a5c3784fac23d7d48335058f7ed283115c87b4332c2a2abaaccc76d0ead1a282ac
+  languageName: node
+  linkType: hard
+
+"hermes-parser@npm:^0.25.1":
+  version: 0.25.1
+  resolution: "hermes-parser@npm:0.25.1"
+  dependencies:
+    hermes-estree: "npm:0.25.1"
+  checksum: 10c0/3abaa4c6f1bcc25273f267297a89a4904963ea29af19b8e4f6eabe04f1c2c7e9abd7bfc4730ddb1d58f2ea04b6fee74053d8bddb5656ec6ebf6c79cc8d14202c
+  languageName: node
+  linkType: hard
+
 "hookable@npm:^6.0.1":
   version: 6.0.1
   resolution: "hookable@npm:6.0.1"
@@ -7795,12 +8504,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"html-encoding-sniffer@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "html-encoding-sniffer@npm:3.0.0"
+"html-encoding-sniffer@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "html-encoding-sniffer@npm:4.0.0"
   dependencies:
-    whatwg-encoding: "npm:^2.0.0"
-  checksum: 10c0/b17b3b0fb5d061d8eb15121c3b0b536376c3e295ecaf09ba48dd69c6b6c957839db124fe1e2b3f11329753a4ee01aa7dedf63b7677999e86da17fbbdd82c5386
+    whatwg-encoding: "npm:^3.1.1"
+  checksum: 10c0/523398055dc61ac9b34718a719cb4aa691e4166f29187e211e1607de63dc25ac7af52ca7c9aead0c4b3c0415ffecb17326396e1202e2e86ff4bca4c0ee4c6140
   languageName: node
   linkType: hard
 
@@ -7850,18 +8559,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"http-proxy-agent@npm:^5.0.0":
-  version: 5.0.0
-  resolution: "http-proxy-agent@npm:5.0.0"
-  dependencies:
-    "@tootallnate/once": "npm:2"
-    agent-base: "npm:6"
-    debug: "npm:4"
-  checksum: 10c0/32a05e413430b2c1e542e5c74b38a9f14865301dd69dff2e53ddb684989440e3d2ce0c4b64d25eb63cf6283e6265ff979a61cf93e3ca3d23047ddfdc8df34a32
-  languageName: node
-  linkType: hard
-
-"http-proxy-agent@npm:^7.0.0":
+"http-proxy-agent@npm:^7.0.0, http-proxy-agent@npm:^7.0.2":
   version: 7.0.2
   resolution: "http-proxy-agent@npm:7.0.2"
   dependencies:
@@ -7871,7 +8569,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"https-proxy-agent@npm:^5.0.0, https-proxy-agent@npm:^5.0.1":
+"https-proxy-agent@npm:^5.0.0":
   version: 5.0.1
   resolution: "https-proxy-agent@npm:5.0.1"
   dependencies:
@@ -7891,6 +8589,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"https-proxy-agent@npm:^7.0.6":
+  version: 7.0.6
+  resolution: "https-proxy-agent@npm:7.0.6"
+  dependencies:
+    agent-base: "npm:^7.1.2"
+    debug: "npm:4"
+  checksum: 10c0/f729219bc735edb621fa30e6e84e60ee5d00802b8247aac0d7b79b0bd6d4b3294737a337b93b86a0bd9e68099d031858a39260c976dc14cdbba238ba1f8779ac
+  languageName: node
+  linkType: hard
+
 "human-signals@npm:^2.1.0":
   version: 2.1.0
   resolution: "human-signals@npm:2.1.0"
@@ -7969,13 +8677,20 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ignore@npm:^5.2.0, ignore@npm:^5.2.4":
+"ignore@npm:^5.2.0":
   version: 5.3.1
   resolution: "ignore@npm:5.3.1"
   checksum: 10c0/703f7f45ffb2a27fb2c5a8db0c32e7dee66b33a225d28e8db4e1be6474795f606686a6e3bcc50e1aa12f2042db4c9d4a7d60af3250511de74620fbed052ea4cd
   languageName: node
   linkType: hard
 
+"ignore@npm:^5.3.2":
+  version: 5.3.2
+  resolution: "ignore@npm:5.3.2"
+  checksum: 10c0/f9f652c957983634ded1e7f02da3b559a0d4cc210fca3792cb67f1b153623c9c42efdc1c4121af171e295444459fc4a9201101fb041b1104a3c000bccb188337
+  languageName: node
+  linkType: hard
+
 "ignore@npm:^7.0.5":
   version: 7.0.5
   resolution: "ignore@npm:7.0.5"
@@ -8000,7 +8715,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"import-local@npm:3.1.0, import-local@npm:^3.0.2":
+"import-local@npm:3.1.0":
   version: 3.1.0
   resolution: "import-local@npm:3.1.0"
   dependencies:
@@ -8012,6 +8727,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"import-local@npm:^3.2.0":
+  version: 3.2.0
+  resolution: "import-local@npm:3.2.0"
+  dependencies:
+    pkg-dir: "npm:^4.2.0"
+    resolve-cwd: "npm:^3.0.0"
+  bin:
+    import-local-fixture: fixtures/cli.js
+  checksum: 10c0/94cd6367a672b7e0cb026970c85b76902d2710a64896fa6de93bd5c571dd03b228c5759308959de205083e3b1c61e799f019c9e36ee8e9c523b993e1057f0433
+  languageName: node
+  linkType: hard
+
 "imurmurhash@npm:^0.1.4":
   version: 0.1.4
   resolution: "imurmurhash@npm:0.1.4"
@@ -8124,6 +8851,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"internal-slot@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "internal-slot@npm:1.1.0"
+  dependencies:
+    es-errors: "npm:^1.3.0"
+    hasown: "npm:^2.0.2"
+    side-channel: "npm:^1.1.0"
+  checksum: 10c0/03966f5e259b009a9bf1a78d60da920df198af4318ec004f57b8aef1dd3fe377fbc8cce63a96e8c810010302654de89f9e19de1cd8ad0061d15be28a695465c7
+  languageName: node
+  linkType: hard
+
 "ioredis-mock@npm:^8.9.0":
   version: 8.9.0
   resolution: "ioredis-mock@npm:8.9.0"
@@ -8211,6 +8949,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-array-buffer@npm:^3.0.5":
+  version: 3.0.5
+  resolution: "is-array-buffer@npm:3.0.5"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.3"
+    get-intrinsic: "npm:^1.2.6"
+  checksum: 10c0/c5c9f25606e86dbb12e756694afbbff64bc8b348d1bc989324c037e1068695131930199d6ad381952715dad3a9569333817f0b1a72ce5af7f883ce802e49c83d
+  languageName: node
+  linkType: hard
+
 "is-arrayish@npm:^0.2.1":
   version: 0.2.1
   resolution: "is-arrayish@npm:0.2.1"
@@ -8236,6 +8985,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-bigint@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "is-bigint@npm:1.1.0"
+  dependencies:
+    has-bigints: "npm:^1.0.2"
+  checksum: 10c0/f4f4b905ceb195be90a6ea7f34323bf1c18e3793f18922e3e9a73c684c29eeeeff5175605c3a3a74cc38185fe27758f07efba3dbae812e5c5afbc0d2316b40e4
+  languageName: node
+  linkType: hard
+
 "is-binary-path@npm:~2.1.0":
   version: 2.1.0
   resolution: "is-binary-path@npm:2.1.0"
@@ -8255,12 +9013,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-builtin-module@npm:^3.2.1":
-  version: 3.2.1
-  resolution: "is-builtin-module@npm:3.2.1"
+"is-boolean-object@npm:^1.2.1":
+  version: 1.2.2
+  resolution: "is-boolean-object@npm:1.2.2"
   dependencies:
-    builtin-modules: "npm:^3.3.0"
-  checksum: 10c0/5a66937a03f3b18803381518f0ef679752ac18cdb7dd53b5e23ee8df8d440558737bd8dcc04d2aae555909d2ecb4a81b5c0d334d119402584b61e6a003e31af1
+    call-bound: "npm:^1.0.3"
+    has-tostringtag: "npm:^1.0.2"
+  checksum: 10c0/36ff6baf6bd18b3130186990026f5a95c709345c39cd368468e6c1b6ab52201e9fd26d8e1f4c066357b4938b0f0401e1a5000e08257787c1a02f3a719457001e
   languageName: node
   linkType: hard
 
@@ -8282,7 +9041,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-core-module@npm:^2.12.1, is-core-module@npm:^2.13.0, is-core-module@npm:^2.13.1, is-core-module@npm:^2.5.0":
+"is-core-module@npm:^2.13.0, is-core-module@npm:^2.5.0":
   version: 2.13.1
   resolution: "is-core-module@npm:2.13.1"
   dependencies:
@@ -8300,6 +9059,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-data-view@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "is-data-view@npm:1.0.2"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    get-intrinsic: "npm:^1.2.6"
+    is-typed-array: "npm:^1.1.13"
+  checksum: 10c0/ef3548a99d7e7f1370ce21006baca6d40c73e9f15c941f89f0049c79714c873d03b02dae1c64b3f861f55163ecc16da06506c5b8a1d4f16650b3d9351c380153
+  languageName: node
+  linkType: hard
+
 "is-date-object@npm:^1.0.1, is-date-object@npm:^1.0.5":
   version: 1.0.5
   resolution: "is-date-object@npm:1.0.5"
@@ -8309,6 +9079,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-date-object@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "is-date-object@npm:1.1.0"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    has-tostringtag: "npm:^1.0.2"
+  checksum: 10c0/1a4d199c8e9e9cac5128d32e6626fa7805175af9df015620ac0d5d45854ccf348ba494679d872d37301032e35a54fc7978fba1687e8721b2139aea7870cafa2f
+  languageName: node
+  linkType: hard
+
 "is-decimal@npm:^2.0.0":
   version: 2.0.1
   resolution: "is-decimal@npm:2.0.1"
@@ -8339,19 +9119,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-finalizationregistry@npm:^1.0.2":
-  version: 1.0.2
-  resolution: "is-finalizationregistry@npm:1.0.2"
+"is-finalizationregistry@npm:^1.1.0":
+  version: 1.1.1
+  resolution: "is-finalizationregistry@npm:1.1.1"
   dependencies:
-    call-bind: "npm:^1.0.2"
-  checksum: 10c0/81caecc984d27b1a35c68741156fc651fb1fa5e3e6710d21410abc527eb226d400c0943a167922b2e920f6b3e58b0dede9aa795882b038b85f50b3a4b877db86
-  languageName: node
-  linkType: hard
-
-"is-fullwidth-code-point@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "is-fullwidth-code-point@npm:2.0.0"
-  checksum: 10c0/e58f3e4a601fc0500d8b2677e26e9fe0cd450980e66adb29d85b6addf7969731e38f8e43ed2ec868a09c101a55ac3d8b78902209269f38c5286bc98f5bc1b4d9
+    call-bound: "npm:^1.0.3"
+  checksum: 10c0/818dff679b64f19e228a8205a1e2d09989a98e98def3a817f889208cfcbf918d321b251aadf2c05918194803ebd2eb01b14fc9d0b2bea53d984f4137bfca5e97
   languageName: node
   linkType: hard
 
@@ -8378,7 +9151,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-generator-fn@npm:^2.0.0":
+"is-generator-fn@npm:^2.1.0":
   version: 2.1.0
   resolution: "is-generator-fn@npm:2.1.0"
   checksum: 10c0/2957cab387997a466cd0bf5c1b6047bd21ecb32bdcfd8996b15747aa01002c1c88731802f1b3d34ac99f4f6874b626418bd118658cf39380fe5fff32a3af9c4d
@@ -8447,6 +9220,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-number-object@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "is-number-object@npm:1.1.1"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    has-tostringtag: "npm:^1.0.2"
+  checksum: 10c0/97b451b41f25135ff021d85c436ff0100d84a039bb87ffd799cbcdbea81ef30c464ced38258cdd34f080be08fc3b076ca1f472086286d2aa43521d6ec6a79f53
+  languageName: node
+  linkType: hard
+
 "is-number@npm:^7.0.0":
   version: 7.0.0
   resolution: "is-number@npm:7.0.0"
@@ -8506,6 +9289,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-regex@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "is-regex@npm:1.2.1"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    gopd: "npm:^1.2.0"
+    has-tostringtag: "npm:^1.0.2"
+    hasown: "npm:^2.0.2"
+  checksum: 10c0/1d3715d2b7889932349241680032e85d0b492cfcb045acb75ffc2c3085e8d561184f1f7e84b6f8321935b4aea39bc9c6ba74ed595b57ce4881a51dfdbc214e04
+  languageName: node
+  linkType: hard
+
 "is-set@npm:^2.0.3":
   version: 2.0.3
   resolution: "is-set@npm:2.0.3"
@@ -8522,6 +9317,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-shared-array-buffer@npm:^1.0.4":
+  version: 1.0.4
+  resolution: "is-shared-array-buffer@npm:1.0.4"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+  checksum: 10c0/65158c2feb41ff1edd6bbd6fd8403a69861cf273ff36077982b5d4d68e1d59278c71691216a4a64632bd76d4792d4d1d2553901b6666d84ade13bba5ea7bc7db
+  languageName: node
+  linkType: hard
+
 "is-ssh@npm:^1.4.0":
   version: 1.4.0
   resolution: "is-ssh@npm:1.4.0"
@@ -8561,6 +9365,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-string@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "is-string@npm:1.1.1"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    has-tostringtag: "npm:^1.0.2"
+  checksum: 10c0/2f518b4e47886bb81567faba6ffd0d8a8333cf84336e2e78bf160693972e32ad00fe84b0926491cc598dee576fdc55642c92e62d0cbe96bf36f643b6f956f94d
+  languageName: node
+  linkType: hard
+
 "is-symbol@npm:^1.0.2, is-symbol@npm:^1.0.3":
   version: 1.0.4
   resolution: "is-symbol@npm:1.0.4"
@@ -8570,6 +9384,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-symbol@npm:^1.0.4, is-symbol@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "is-symbol@npm:1.1.1"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    has-symbols: "npm:^1.1.0"
+    safe-regex-test: "npm:^1.1.0"
+  checksum: 10c0/f08f3e255c12442e833f75a9e2b84b2d4882fdfd920513cf2a4a2324f0a5b076c8fd913778e3ea5d258d5183e9d92c0cd20e04b03ab3df05316b049b2670af1e
+  languageName: node
+  linkType: hard
+
 "is-text-path@npm:^1.0.1":
   version: 1.0.1
   resolution: "is-text-path@npm:1.0.1"
@@ -8588,6 +9413,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-typed-array@npm:^1.1.14, is-typed-array@npm:^1.1.15":
+  version: 1.1.15
+  resolution: "is-typed-array@npm:1.1.15"
+  dependencies:
+    which-typed-array: "npm:^1.1.16"
+  checksum: 10c0/415511da3669e36e002820584e264997ffe277ff136643a3126cc949197e6ca3334d0f12d084e83b1994af2e9c8141275c741cf2b7da5a2ff62dd0cac26f76c4
+  languageName: node
+  linkType: hard
+
 "is-unicode-supported@npm:^0.1.0":
   version: 0.1.0
   resolution: "is-unicode-supported@npm:0.1.0"
@@ -8611,6 +9445,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-weakref@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "is-weakref@npm:1.1.1"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+  checksum: 10c0/8e0a9c07b0c780949a100e2cab2b5560a48ecd4c61726923c1a9b77b6ab0aa0046c9e7fb2206042296817045376dee2c8ab1dabe08c7c3dfbf195b01275a085b
+  languageName: node
+  linkType: hard
+
 "is-weakset@npm:^2.0.3":
   version: 2.0.3
   resolution: "is-weakset@npm:2.0.3"
@@ -8665,29 +9508,29 @@ __metadata:
   languageName: node
   linkType: hard
 
-"istanbul-lib-instrument@npm:^5.0.4":
-  version: 5.2.1
-  resolution: "istanbul-lib-instrument@npm:5.2.1"
+"istanbul-lib-instrument@npm:^6.0.0":
+  version: 6.0.2
+  resolution: "istanbul-lib-instrument@npm:6.0.2"
   dependencies:
-    "@babel/core": "npm:^7.12.3"
-    "@babel/parser": "npm:^7.14.7"
-    "@istanbuljs/schema": "npm:^0.1.2"
+    "@babel/core": "npm:^7.23.9"
+    "@babel/parser": "npm:^7.23.9"
+    "@istanbuljs/schema": "npm:^0.1.3"
     istanbul-lib-coverage: "npm:^3.2.0"
-    semver: "npm:^6.3.0"
-  checksum: 10c0/8a1bdf3e377dcc0d33ec32fe2b6ecacdb1e4358fd0eb923d4326bb11c67622c0ceb99600a680f3dad5d29c66fc1991306081e339b4d43d0b8a2ab2e1d910a6ee
+    semver: "npm:^7.5.4"
+  checksum: 10c0/405c6ac037bf8c7ee7495980b0cd5544b2c53078c10534d0c9ceeb92a9ea7dcf8510f58ccfce31336458a8fa6ccef27b570bbb602abaa8c1650f5496a807477c
   languageName: node
   linkType: hard
 
-"istanbul-lib-instrument@npm:^6.0.0":
-  version: 6.0.2
-  resolution: "istanbul-lib-instrument@npm:6.0.2"
+"istanbul-lib-instrument@npm:^6.0.2":
+  version: 6.0.3
+  resolution: "istanbul-lib-instrument@npm:6.0.3"
   dependencies:
     "@babel/core": "npm:^7.23.9"
     "@babel/parser": "npm:^7.23.9"
     "@istanbuljs/schema": "npm:^0.1.3"
     istanbul-lib-coverage: "npm:^3.2.0"
     semver: "npm:^7.5.4"
-  checksum: 10c0/405c6ac037bf8c7ee7495980b0cd5544b2c53078c10534d0c9ceeb92a9ea7dcf8510f58ccfce31336458a8fa6ccef27b570bbb602abaa8c1650f5496a807477c
+  checksum: 10c0/a1894e060dd2a3b9f046ffdc87b44c00a35516f5e6b7baf4910369acca79e506fc5323a816f811ae23d82334b38e3ddeb8b3b331bd2c860540793b59a8689128
   languageName: node
   linkType: hard
 
@@ -8702,14 +9545,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"istanbul-lib-source-maps@npm:^4.0.0":
-  version: 4.0.1
-  resolution: "istanbul-lib-source-maps@npm:4.0.1"
+"istanbul-lib-source-maps@npm:^5.0.0":
+  version: 5.0.6
+  resolution: "istanbul-lib-source-maps@npm:5.0.6"
   dependencies:
+    "@jridgewell/trace-mapping": "npm:^0.3.23"
     debug: "npm:^4.1.1"
     istanbul-lib-coverage: "npm:^3.0.0"
-    source-map: "npm:^0.6.1"
-  checksum: 10c0/19e4cc405016f2c906dff271a76715b3e881fa9faeb3f09a86cb99b8512b3a5ed19cadfe0b54c17ca0e54c1142c9c6de9330d65506e35873994e06634eebeb66
+  checksum: 10c0/ffe75d70b303a3621ee4671554f306e0831b16f39ab7f4ab52e54d356a5d33e534d97563e318f1333a6aae1d42f91ec49c76b6cd3f3fb378addcb5c81da0255f
   languageName: node
   linkType: hard
 
@@ -8733,16 +9576,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"iterator.prototype@npm:^1.1.2":
-  version: 1.1.2
-  resolution: "iterator.prototype@npm:1.1.2"
+"iterator.prototype@npm:^1.1.5":
+  version: 1.1.5
+  resolution: "iterator.prototype@npm:1.1.5"
   dependencies:
-    define-properties: "npm:^1.2.1"
-    get-intrinsic: "npm:^1.2.1"
-    has-symbols: "npm:^1.0.3"
-    reflect.getprototypeof: "npm:^1.0.4"
-    set-function-name: "npm:^2.0.1"
-  checksum: 10c0/a32151326095e916f306990d909f6bbf23e3221999a18ba686419535dcd1749b10ded505e89334b77dc4c7a58a8508978f0eb16c2c8573e6d412eb7eb894ea79
+    define-data-property: "npm:^1.1.4"
+    es-object-atoms: "npm:^1.0.0"
+    get-intrinsic: "npm:^1.2.6"
+    get-proto: "npm:^1.0.0"
+    has-symbols: "npm:^1.1.0"
+    set-function-name: "npm:^2.0.2"
+  checksum: 10c0/f7a262808e1b41049ab55f1e9c29af7ec1025a000d243b83edf34ce2416eedd56079b117fa59376bb4a724110690f13aa8427f2ee29a09eec63a7e72367626d0
   languageName: node
   linkType: hard
 
@@ -8782,106 +9626,121 @@ __metadata:
   languageName: node
   linkType: hard
 
-"jest-changed-files@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-changed-files@npm:29.7.0"
+"jest-changed-files@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-changed-files@npm:30.3.0"
   dependencies:
-    execa: "npm:^5.0.0"
-    jest-util: "npm:^29.7.0"
+    execa: "npm:^5.1.1"
+    jest-util: "npm:30.3.0"
     p-limit: "npm:^3.1.0"
-  checksum: 10c0/e071384d9e2f6bb462231ac53f29bff86f0e12394c1b49ccafbad225ce2ab7da226279a8a94f421949920bef9be7ef574fd86aee22e8adfa149be73554ab828b
+  checksum: 10c0/5a2f9790f8ab7f5804ebbf0fcdd908c40286d602d76abbecc6bea72e7f3c60b77dc8a3d3f5acdddd11653b2574f471a5c126ceda0734bc6a7d607cf145843525
   languageName: node
   linkType: hard
 
-"jest-circus@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-circus@npm:29.7.0"
+"jest-circus@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-circus@npm:30.3.0"
   dependencies:
-    "@jest/environment": "npm:^29.7.0"
-    "@jest/expect": "npm:^29.7.0"
-    "@jest/test-result": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
+    "@jest/environment": "npm:30.3.0"
+    "@jest/expect": "npm:30.3.0"
+    "@jest/test-result": "npm:30.3.0"
+    "@jest/types": "npm:30.3.0"
     "@types/node": "npm:*"
-    chalk: "npm:^4.0.0"
+    chalk: "npm:^4.1.2"
     co: "npm:^4.6.0"
-    dedent: "npm:^1.0.0"
-    is-generator-fn: "npm:^2.0.0"
-    jest-each: "npm:^29.7.0"
-    jest-matcher-utils: "npm:^29.7.0"
-    jest-message-util: "npm:^29.7.0"
-    jest-runtime: "npm:^29.7.0"
-    jest-snapshot: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
+    dedent: "npm:^1.6.0"
+    is-generator-fn: "npm:^2.1.0"
+    jest-each: "npm:30.3.0"
+    jest-matcher-utils: "npm:30.3.0"
+    jest-message-util: "npm:30.3.0"
+    jest-runtime: "npm:30.3.0"
+    jest-snapshot: "npm:30.3.0"
+    jest-util: "npm:30.3.0"
     p-limit: "npm:^3.1.0"
-    pretty-format: "npm:^29.7.0"
-    pure-rand: "npm:^6.0.0"
+    pretty-format: "npm:30.3.0"
+    pure-rand: "npm:^7.0.0"
     slash: "npm:^3.0.0"
-    stack-utils: "npm:^2.0.3"
-  checksum: 10c0/8d15344cf7a9f14e926f0deed64ed190c7a4fa1ed1acfcd81e4cc094d3cc5bf7902ebb7b874edc98ada4185688f90c91e1747e0dfd7ac12463b097968ae74b5e
+    stack-utils: "npm:^2.0.6"
+  checksum: 10c0/a3a0eb973699b400fb6de4207a7fbc5b33f51523e5e94f954d0e6e60418ea95099883614495fce54d805a321cb65e883592048b73203a59b8f4e53d1bb975a07
   languageName: node
   linkType: hard
 
-"jest-cli@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-cli@npm:29.7.0"
+"jest-cli@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-cli@npm:30.3.0"
   dependencies:
-    "@jest/core": "npm:^29.7.0"
-    "@jest/test-result": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    chalk: "npm:^4.0.0"
-    create-jest: "npm:^29.7.0"
-    exit: "npm:^0.1.2"
-    import-local: "npm:^3.0.2"
-    jest-config: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-    jest-validate: "npm:^29.7.0"
-    yargs: "npm:^17.3.1"
+    "@jest/core": "npm:30.3.0"
+    "@jest/test-result": "npm:30.3.0"
+    "@jest/types": "npm:30.3.0"
+    chalk: "npm:^4.1.2"
+    exit-x: "npm:^0.2.2"
+    import-local: "npm:^3.2.0"
+    jest-config: "npm:30.3.0"
+    jest-util: "npm:30.3.0"
+    jest-validate: "npm:30.3.0"
+    yargs: "npm:^17.7.2"
   peerDependencies:
     node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
   peerDependenciesMeta:
     node-notifier:
       optional: true
   bin:
-    jest: bin/jest.js
-  checksum: 10c0/a658fd55050d4075d65c1066364595962ead7661711495cfa1dfeecf3d6d0a8ffec532f3dbd8afbb3e172dd5fd2fb2e813c5e10256e7cf2fea766314942fb43a
+    jest: ./bin/jest.js
+  checksum: 10c0/764d77551e0fb6d666212e89d01be6f7bb1a2b3adb918bba7c5c37593a11b01cf2af645506c2b6438335cfc79bfcf41bfd4680958d8ca751851752a7c66269d3
   languageName: node
   linkType: hard
 
-"jest-config@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-config@npm:29.7.0"
+"jest-config@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-config@npm:30.3.0"
   dependencies:
-    "@babel/core": "npm:^7.11.6"
-    "@jest/test-sequencer": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    babel-jest: "npm:^29.7.0"
-    chalk: "npm:^4.0.0"
-    ci-info: "npm:^3.2.0"
-    deepmerge: "npm:^4.2.2"
-    glob: "npm:^7.1.3"
-    graceful-fs: "npm:^4.2.9"
-    jest-circus: "npm:^29.7.0"
-    jest-environment-node: "npm:^29.7.0"
-    jest-get-type: "npm:^29.6.3"
-    jest-regex-util: "npm:^29.6.3"
-    jest-resolve: "npm:^29.7.0"
-    jest-runner: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-    jest-validate: "npm:^29.7.0"
-    micromatch: "npm:^4.0.4"
+    "@babel/core": "npm:^7.27.4"
+    "@jest/get-type": "npm:30.1.0"
+    "@jest/pattern": "npm:30.0.1"
+    "@jest/test-sequencer": "npm:30.3.0"
+    "@jest/types": "npm:30.3.0"
+    babel-jest: "npm:30.3.0"
+    chalk: "npm:^4.1.2"
+    ci-info: "npm:^4.2.0"
+    deepmerge: "npm:^4.3.1"
+    glob: "npm:^10.5.0"
+    graceful-fs: "npm:^4.2.11"
+    jest-circus: "npm:30.3.0"
+    jest-docblock: "npm:30.2.0"
+    jest-environment-node: "npm:30.3.0"
+    jest-regex-util: "npm:30.0.1"
+    jest-resolve: "npm:30.3.0"
+    jest-runner: "npm:30.3.0"
+    jest-util: "npm:30.3.0"
+    jest-validate: "npm:30.3.0"
     parse-json: "npm:^5.2.0"
-    pretty-format: "npm:^29.7.0"
+    pretty-format: "npm:30.3.0"
     slash: "npm:^3.0.0"
     strip-json-comments: "npm:^3.1.1"
   peerDependencies:
     "@types/node": "*"
+    esbuild-register: ">=3.4.0"
     ts-node: ">=9.0.0"
   peerDependenciesMeta:
     "@types/node":
       optional: true
+    esbuild-register:
+      optional: true
     ts-node:
       optional: true
-  checksum: 10c0/bab23c2eda1fff06e0d104b00d6adfb1d1aabb7128441899c9bff2247bd26710b050a5364281ce8d52b46b499153bf7e3ee88b19831a8f3451f1477a0246a0f1
+  checksum: 10c0/157607e5ac5e83924df97d992fbd40a1540af07c5a7be296fae49455b3729687847304f3b4a9112e7da17593b76cec3453cd55c1ecd4334f7318f2489d7d10a1
+  languageName: node
+  linkType: hard
+
+"jest-diff@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-diff@npm:30.3.0"
+  dependencies:
+    "@jest/diff-sequences": "npm:30.3.0"
+    "@jest/get-type": "npm:30.1.0"
+    chalk: "npm:^4.1.2"
+    pretty-format: "npm:30.3.0"
+  checksum: 10c0/573a2a1a155b95fbde547d8ee33a5375179a8d03d4586025478dac16d695e4614aef075c3afa57e0f3a96cea8f638fa68a55c1e625f6e86b4f5b9e5850311ffb
   languageName: node
   linkType: hard
 
@@ -8897,156 +9756,132 @@ __metadata:
   languageName: node
   linkType: hard
 
-"jest-diff@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-diff@npm:29.7.0"
-  dependencies:
-    chalk: "npm:^4.0.0"
-    diff-sequences: "npm:^29.6.3"
-    jest-get-type: "npm:^29.6.3"
-    pretty-format: "npm:^29.7.0"
-  checksum: 10c0/89a4a7f182590f56f526443dde69acefb1f2f0c9e59253c61d319569856c4931eae66b8a3790c443f529267a0ddba5ba80431c585deed81827032b2b2a1fc999
-  languageName: node
-  linkType: hard
-
-"jest-docblock@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-docblock@npm:29.7.0"
+"jest-docblock@npm:30.2.0":
+  version: 30.2.0
+  resolution: "jest-docblock@npm:30.2.0"
   dependencies:
-    detect-newline: "npm:^3.0.0"
-  checksum: 10c0/d932a8272345cf6b6142bb70a2bb63e0856cc0093f082821577ea5bdf4643916a98744dfc992189d2b1417c38a11fa42466f6111526bc1fb81366f56410f3be9
+    detect-newline: "npm:^3.1.0"
+  checksum: 10c0/2578366604eef1b36d59ffe1fc52a710995571535d437f83d94ff94756a83f78e699c1ba004c38a34c01859d669fd6c64e865c23c5a7d5bf4837cfca4bef3dda
   languageName: node
   linkType: hard
 
-"jest-each@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-each@npm:29.7.0"
+"jest-each@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-each@npm:30.3.0"
   dependencies:
-    "@jest/types": "npm:^29.6.3"
-    chalk: "npm:^4.0.0"
-    jest-get-type: "npm:^29.6.3"
-    jest-util: "npm:^29.7.0"
-    pretty-format: "npm:^29.7.0"
-  checksum: 10c0/f7f9a90ebee80cc688e825feceb2613627826ac41ea76a366fa58e669c3b2403d364c7c0a74d862d469b103c843154f8456d3b1c02b487509a12afa8b59edbb4
+    "@jest/get-type": "npm:30.1.0"
+    "@jest/types": "npm:30.3.0"
+    chalk: "npm:^4.1.2"
+    jest-util: "npm:30.3.0"
+    pretty-format: "npm:30.3.0"
+  checksum: 10c0/d23d2b43b3ea42beaf99648e2cf1c74b8a13c3e45c7c882979171471c225f7d666cb4a0d5f1ff9031b4504866fa3badc7266ffd885d3d8035420c559a31501e1
   languageName: node
   linkType: hard
 
-"jest-environment-jsdom@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-environment-jsdom@npm:29.7.0"
+"jest-environment-jsdom@npm:^30.3.0":
+  version: 30.3.0
+  resolution: "jest-environment-jsdom@npm:30.3.0"
   dependencies:
-    "@jest/environment": "npm:^29.7.0"
-    "@jest/fake-timers": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    "@types/jsdom": "npm:^20.0.0"
-    "@types/node": "npm:*"
-    jest-mock: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-    jsdom: "npm:^20.0.0"
+    "@jest/environment": "npm:30.3.0"
+    "@jest/environment-jsdom-abstract": "npm:30.3.0"
+    jsdom: "npm:^26.1.0"
   peerDependencies:
-    canvas: ^2.5.0
+    canvas: ^3.0.0
   peerDependenciesMeta:
     canvas:
       optional: true
-  checksum: 10c0/139b94e2c8ec1bb5a46ce17df5211da65ce867354b3fd4e00fa6a0d1da95902df4cf7881273fc6ea937e5c325d39d6773f0d41b6c469363334de9d489d2c321f
+  checksum: 10c0/1d9a288c847dc7d3fe0ac4bd494fa5f78581d5f7f1f28fd1f58073634f139b6e4d13d1ea1bbed8e68693f45b74279fb7ea002dd453faa98ab6ab657c443cc0ce
   languageName: node
   linkType: hard
 
-"jest-environment-node@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-environment-node@npm:29.7.0"
+"jest-environment-node@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-environment-node@npm:30.3.0"
   dependencies:
-    "@jest/environment": "npm:^29.7.0"
-    "@jest/fake-timers": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
+    "@jest/environment": "npm:30.3.0"
+    "@jest/fake-timers": "npm:30.3.0"
+    "@jest/types": "npm:30.3.0"
     "@types/node": "npm:*"
-    jest-mock: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-  checksum: 10c0/61f04fec077f8b1b5c1a633e3612fc0c9aa79a0ab7b05600683428f1e01a4d35346c474bde6f439f9fcc1a4aa9a2861ff852d079a43ab64b02105d1004b2592b
+    jest-mock: "npm:30.3.0"
+    jest-util: "npm:30.3.0"
+    jest-validate: "npm:30.3.0"
+  checksum: 10c0/2a4be80861e569fa11456d89ff2aaedd71726ae02ade8f2cc6fbc86ba8749e24c37864676c4718fc08a40f6e6d2b2b51bc48d715b09b1e93e15e42e4a10f7b5b
   languageName: node
   linkType: hard
 
-"jest-get-type@npm:^29.6.3":
-  version: 29.6.3
-  resolution: "jest-get-type@npm:29.6.3"
-  checksum: 10c0/552e7a97a983d3c2d4e412a44eb7de0430ff773dd99f7500962c268d6dfbfa431d7d08f919c9d960530e5f7f78eb47f267ad9b318265e5092b3ff9ede0db7c2b
-  languageName: node
-  linkType: hard
-
-"jest-haste-map@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-haste-map@npm:29.7.0"
+"jest-haste-map@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-haste-map@npm:30.3.0"
   dependencies:
-    "@jest/types": "npm:^29.6.3"
-    "@types/graceful-fs": "npm:^4.1.3"
+    "@jest/types": "npm:30.3.0"
     "@types/node": "npm:*"
-    anymatch: "npm:^3.0.3"
-    fb-watchman: "npm:^2.0.0"
-    fsevents: "npm:^2.3.2"
-    graceful-fs: "npm:^4.2.9"
-    jest-regex-util: "npm:^29.6.3"
-    jest-util: "npm:^29.7.0"
-    jest-worker: "npm:^29.7.0"
-    micromatch: "npm:^4.0.4"
+    anymatch: "npm:^3.1.3"
+    fb-watchman: "npm:^2.0.2"
+    fsevents: "npm:^2.3.3"
+    graceful-fs: "npm:^4.2.11"
+    jest-regex-util: "npm:30.0.1"
+    jest-util: "npm:30.3.0"
+    jest-worker: "npm:30.3.0"
+    picomatch: "npm:^4.0.3"
     walker: "npm:^1.0.8"
   dependenciesMeta:
     fsevents:
       optional: true
-  checksum: 10c0/2683a8f29793c75a4728787662972fedd9267704c8f7ef9d84f2beed9a977f1cf5e998c07b6f36ba5603f53cb010c911fe8cd0ac9886e073fe28ca66beefd30c
+  checksum: 10c0/b9ef350082b15d4c119d6188f781024d859d6cfb17ae25d15c90c3a373234e16109afbeffdcf1af4baf6a85eb0cbbab00439c981ad43037c0f05d89ff98bd1af
   languageName: node
   linkType: hard
 
-"jest-leak-detector@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-leak-detector@npm:29.7.0"
+"jest-leak-detector@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-leak-detector@npm:30.3.0"
   dependencies:
-    jest-get-type: "npm:^29.6.3"
-    pretty-format: "npm:^29.7.0"
-  checksum: 10c0/71bb9f77fc489acb842a5c7be030f2b9acb18574dc9fb98b3100fc57d422b1abc55f08040884bd6e6dbf455047a62f7eaff12aa4058f7cbdc11558718ca6a395
+    "@jest/get-type": "npm:30.1.0"
+    pretty-format: "npm:30.3.0"
+  checksum: 10c0/a648c082b74e6c7d0c2e890002094ba97b108398fa3d0316958fc74321aa7b0824507a685d261a463856f219a724b86a6073bac86d351cf0675ecf962c1ee0ca
   languageName: node
   linkType: hard
 
-"jest-matcher-utils@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-matcher-utils@npm:29.7.0"
+"jest-matcher-utils@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-matcher-utils@npm:30.3.0"
   dependencies:
-    chalk: "npm:^4.0.0"
-    jest-diff: "npm:^29.7.0"
-    jest-get-type: "npm:^29.6.3"
-    pretty-format: "npm:^29.7.0"
-  checksum: 10c0/0d0e70b28fa5c7d4dce701dc1f46ae0922102aadc24ed45d594dd9b7ae0a8a6ef8b216718d1ab79e451291217e05d4d49a82666e1a3cc2b428b75cd9c933244e
+    "@jest/get-type": "npm:30.1.0"
+    chalk: "npm:^4.1.2"
+    jest-diff: "npm:30.3.0"
+    pretty-format: "npm:30.3.0"
+  checksum: 10c0/4c5f4b6435964110e64c4b5b42e3553fffe303ecdd68021147a7bcc72914aec3a899867c50db22b250c72aded53e3f7a9f64d83c9dca2e65ce27f36d23c6ca78
   languageName: node
   linkType: hard
 
-"jest-message-util@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-message-util@npm:29.7.0"
+"jest-message-util@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-message-util@npm:30.3.0"
   dependencies:
-    "@babel/code-frame": "npm:^7.12.13"
-    "@jest/types": "npm:^29.6.3"
-    "@types/stack-utils": "npm:^2.0.0"
-    chalk: "npm:^4.0.0"
-    graceful-fs: "npm:^4.2.9"
-    micromatch: "npm:^4.0.4"
-    pretty-format: "npm:^29.7.0"
+    "@babel/code-frame": "npm:^7.27.1"
+    "@jest/types": "npm:30.3.0"
+    "@types/stack-utils": "npm:^2.0.3"
+    chalk: "npm:^4.1.2"
+    graceful-fs: "npm:^4.2.11"
+    picomatch: "npm:^4.0.3"
+    pretty-format: "npm:30.3.0"
     slash: "npm:^3.0.0"
-    stack-utils: "npm:^2.0.3"
-  checksum: 10c0/850ae35477f59f3e6f27efac5215f706296e2104af39232bb14e5403e067992afb5c015e87a9243ec4d9df38525ef1ca663af9f2f4766aa116f127247008bd22
+    stack-utils: "npm:^2.0.6"
+  checksum: 10c0/6ce611caef76394872b23a111286b48e56f42655d14a5fbd0629d9b7437ed892e85ad96b15864bc22185c24ef670afb6665c57b9729458a36d50ffe8310f0926
   languageName: node
   linkType: hard
 
-"jest-mock@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-mock@npm:29.7.0"
+"jest-mock@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-mock@npm:30.3.0"
   dependencies:
-    "@jest/types": "npm:^29.6.3"
+    "@jest/types": "npm:30.3.0"
     "@types/node": "npm:*"
-    jest-util: "npm:^29.7.0"
-  checksum: 10c0/7b9f8349ee87695a309fe15c46a74ab04c853369e5c40952d68061d9dc3159a0f0ed73e215f81b07ee97a9faaf10aebe5877a9d6255068a0977eae6a9ff1d5ac
+    jest-util: "npm:30.3.0"
+  checksum: 10c0/9d95d550c6c998a85887c48ff5ee26de4bca18be91462ea8a8135d6023d591132465756f74981ca39b60f8708dfe38213a55bd4b619798a7b9438ca10d718099
   languageName: node
   linkType: hard
 
-"jest-pnp-resolver@npm:^1.2.2":
+"jest-pnp-resolver@npm:^1.2.3":
   version: 1.2.3
   resolution: "jest-pnp-resolver@npm:1.2.3"
   peerDependencies:
@@ -9058,199 +9893,201 @@ __metadata:
   languageName: node
   linkType: hard
 
-"jest-regex-util@npm:^29.6.3":
-  version: 29.6.3
-  resolution: "jest-regex-util@npm:29.6.3"
-  checksum: 10c0/4e33fb16c4f42111159cafe26397118dcfc4cf08bc178a67149fb05f45546a91928b820894572679d62559839d0992e21080a1527faad65daaae8743a5705a3b
+"jest-regex-util@npm:30.0.1":
+  version: 30.0.1
+  resolution: "jest-regex-util@npm:30.0.1"
+  checksum: 10c0/f30c70524ebde2d1012afe5ffa5691d5d00f7d5ba9e43d588f6460ac6fe96f9e620f2f9b36a02d0d3e7e77bc8efb8b3450ae3b80ac53c8be5099e01bf54f6728
   languageName: node
   linkType: hard
 
-"jest-resolve-dependencies@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-resolve-dependencies@npm:29.7.0"
+"jest-resolve-dependencies@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-resolve-dependencies@npm:30.3.0"
   dependencies:
-    jest-regex-util: "npm:^29.6.3"
-    jest-snapshot: "npm:^29.7.0"
-  checksum: 10c0/b6e9ad8ae5b6049474118ea6441dfddd385b6d1fc471db0136f7c8fbcfe97137a9665e4f837a9f49f15a29a1deb95a14439b7aec812f3f99d08f228464930f0d
+    jest-regex-util: "npm:30.0.1"
+    jest-snapshot: "npm:30.3.0"
+  checksum: 10c0/25dde0c8c050bc3437332f37ab87484f597596b80ece77a93e4da2b466b42e45cc5ad748270c1477587536de15eea1ffe83a32638e824b120830c3a87c9a5b71
   languageName: node
   linkType: hard
 
-"jest-resolve@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-resolve@npm:29.7.0"
+"jest-resolve@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-resolve@npm:30.3.0"
   dependencies:
-    chalk: "npm:^4.0.0"
-    graceful-fs: "npm:^4.2.9"
-    jest-haste-map: "npm:^29.7.0"
-    jest-pnp-resolver: "npm:^1.2.2"
-    jest-util: "npm:^29.7.0"
-    jest-validate: "npm:^29.7.0"
-    resolve: "npm:^1.20.0"
-    resolve.exports: "npm:^2.0.0"
+    chalk: "npm:^4.1.2"
+    graceful-fs: "npm:^4.2.11"
+    jest-haste-map: "npm:30.3.0"
+    jest-pnp-resolver: "npm:^1.2.3"
+    jest-util: "npm:30.3.0"
+    jest-validate: "npm:30.3.0"
     slash: "npm:^3.0.0"
-  checksum: 10c0/59da5c9c5b50563e959a45e09e2eace783d7f9ac0b5dcc6375dea4c0db938d2ebda97124c8161310082760e8ebbeff9f6b177c15ca2f57fb424f637a5d2adb47
+    unrs-resolver: "npm:^1.7.11"
+  checksum: 10c0/540f59f160c232c1b922b111a93f24ef5202d75e00f2e994de976badf6e88879893b474320ff363a6b97259a7a208b6a4f5eeabede787eea9b7912a12ac64b1b
   languageName: node
   linkType: hard
 
-"jest-runner@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-runner@npm:29.7.0"
+"jest-runner@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-runner@npm:30.3.0"
   dependencies:
-    "@jest/console": "npm:^29.7.0"
-    "@jest/environment": "npm:^29.7.0"
-    "@jest/test-result": "npm:^29.7.0"
-    "@jest/transform": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
+    "@jest/console": "npm:30.3.0"
+    "@jest/environment": "npm:30.3.0"
+    "@jest/test-result": "npm:30.3.0"
+    "@jest/transform": "npm:30.3.0"
+    "@jest/types": "npm:30.3.0"
     "@types/node": "npm:*"
-    chalk: "npm:^4.0.0"
+    chalk: "npm:^4.1.2"
     emittery: "npm:^0.13.1"
-    graceful-fs: "npm:^4.2.9"
-    jest-docblock: "npm:^29.7.0"
-    jest-environment-node: "npm:^29.7.0"
-    jest-haste-map: "npm:^29.7.0"
-    jest-leak-detector: "npm:^29.7.0"
-    jest-message-util: "npm:^29.7.0"
-    jest-resolve: "npm:^29.7.0"
-    jest-runtime: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-    jest-watcher: "npm:^29.7.0"
-    jest-worker: "npm:^29.7.0"
+    exit-x: "npm:^0.2.2"
+    graceful-fs: "npm:^4.2.11"
+    jest-docblock: "npm:30.2.0"
+    jest-environment-node: "npm:30.3.0"
+    jest-haste-map: "npm:30.3.0"
+    jest-leak-detector: "npm:30.3.0"
+    jest-message-util: "npm:30.3.0"
+    jest-resolve: "npm:30.3.0"
+    jest-runtime: "npm:30.3.0"
+    jest-util: "npm:30.3.0"
+    jest-watcher: "npm:30.3.0"
+    jest-worker: "npm:30.3.0"
     p-limit: "npm:^3.1.0"
     source-map-support: "npm:0.5.13"
-  checksum: 10c0/2194b4531068d939f14c8d3274fe5938b77fa73126aedf9c09ec9dec57d13f22c72a3b5af01ac04f5c1cf2e28d0ac0b4a54212a61b05f10b5d6b47f2a1097bb4
+  checksum: 10c0/6fb205f48541658f0b23b6c9a6730f0133f07c994a22ef506ebfcded5bbb444b655ac828074157e6579e664609a46f6a5bf3d366b694c6c8b523b5207a70499c
   languageName: node
   linkType: hard
 
-"jest-runtime@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-runtime@npm:29.7.0"
+"jest-runtime@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-runtime@npm:30.3.0"
   dependencies:
-    "@jest/environment": "npm:^29.7.0"
-    "@jest/fake-timers": "npm:^29.7.0"
-    "@jest/globals": "npm:^29.7.0"
-    "@jest/source-map": "npm:^29.6.3"
-    "@jest/test-result": "npm:^29.7.0"
-    "@jest/transform": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
+    "@jest/environment": "npm:30.3.0"
+    "@jest/fake-timers": "npm:30.3.0"
+    "@jest/globals": "npm:30.3.0"
+    "@jest/source-map": "npm:30.0.1"
+    "@jest/test-result": "npm:30.3.0"
+    "@jest/transform": "npm:30.3.0"
+    "@jest/types": "npm:30.3.0"
     "@types/node": "npm:*"
-    chalk: "npm:^4.0.0"
-    cjs-module-lexer: "npm:^1.0.0"
-    collect-v8-coverage: "npm:^1.0.0"
-    glob: "npm:^7.1.3"
-    graceful-fs: "npm:^4.2.9"
-    jest-haste-map: "npm:^29.7.0"
-    jest-message-util: "npm:^29.7.0"
-    jest-mock: "npm:^29.7.0"
-    jest-regex-util: "npm:^29.6.3"
-    jest-resolve: "npm:^29.7.0"
-    jest-snapshot: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
+    chalk: "npm:^4.1.2"
+    cjs-module-lexer: "npm:^2.1.0"
+    collect-v8-coverage: "npm:^1.0.2"
+    glob: "npm:^10.5.0"
+    graceful-fs: "npm:^4.2.11"
+    jest-haste-map: "npm:30.3.0"
+    jest-message-util: "npm:30.3.0"
+    jest-mock: "npm:30.3.0"
+    jest-regex-util: "npm:30.0.1"
+    jest-resolve: "npm:30.3.0"
+    jest-snapshot: "npm:30.3.0"
+    jest-util: "npm:30.3.0"
     slash: "npm:^3.0.0"
     strip-bom: "npm:^4.0.0"
-  checksum: 10c0/7cd89a1deda0bda7d0941835434e44f9d6b7bd50b5c5d9b0fc9a6c990b2d4d2cab59685ab3cb2850ed4cc37059f6de903af5a50565d7f7f1192a77d3fd6dd2a6
+  checksum: 10c0/79c486157a926d5be5c66356ad26cc3792cca1afb1490e255a550f52784b6c92eea42f1cb3b2c7565650ea777cf17ffc3f8e305d6b97888e7d273f6d7f282686
   languageName: node
   linkType: hard
 
-"jest-snapshot@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-snapshot@npm:29.7.0"
+"jest-snapshot@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-snapshot@npm:30.3.0"
   dependencies:
-    "@babel/core": "npm:^7.11.6"
-    "@babel/generator": "npm:^7.7.2"
-    "@babel/plugin-syntax-jsx": "npm:^7.7.2"
-    "@babel/plugin-syntax-typescript": "npm:^7.7.2"
-    "@babel/types": "npm:^7.3.3"
-    "@jest/expect-utils": "npm:^29.7.0"
-    "@jest/transform": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    babel-preset-current-node-syntax: "npm:^1.0.0"
-    chalk: "npm:^4.0.0"
-    expect: "npm:^29.7.0"
-    graceful-fs: "npm:^4.2.9"
-    jest-diff: "npm:^29.7.0"
-    jest-get-type: "npm:^29.6.3"
-    jest-matcher-utils: "npm:^29.7.0"
-    jest-message-util: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-    natural-compare: "npm:^1.4.0"
-    pretty-format: "npm:^29.7.0"
-    semver: "npm:^7.5.3"
-  checksum: 10c0/6e9003c94ec58172b4a62864a91c0146513207bedf4e0a06e1e2ac70a4484088a2683e3a0538d8ea913bcfd53dc54a9b98a98cdfa562e7fe1d1339aeae1da570
+    "@babel/core": "npm:^7.27.4"
+    "@babel/generator": "npm:^7.27.5"
+    "@babel/plugin-syntax-jsx": "npm:^7.27.1"
+    "@babel/plugin-syntax-typescript": "npm:^7.27.1"
+    "@babel/types": "npm:^7.27.3"
+    "@jest/expect-utils": "npm:30.3.0"
+    "@jest/get-type": "npm:30.1.0"
+    "@jest/snapshot-utils": "npm:30.3.0"
+    "@jest/transform": "npm:30.3.0"
+    "@jest/types": "npm:30.3.0"
+    babel-preset-current-node-syntax: "npm:^1.2.0"
+    chalk: "npm:^4.1.2"
+    expect: "npm:30.3.0"
+    graceful-fs: "npm:^4.2.11"
+    jest-diff: "npm:30.3.0"
+    jest-matcher-utils: "npm:30.3.0"
+    jest-message-util: "npm:30.3.0"
+    jest-util: "npm:30.3.0"
+    pretty-format: "npm:30.3.0"
+    semver: "npm:^7.7.2"
+    synckit: "npm:^0.11.8"
+  checksum: 10c0/c1dd295d9d4962f2504c965575212fc62a358a849c66ab96b2f6e608ebdf6a6029ca505bb0693664a54a534e581883665d404a59976a5b46b1a1f88b537e96c5
   languageName: node
   linkType: hard
 
-"jest-util@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-util@npm:29.7.0"
+"jest-util@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-util@npm:30.3.0"
   dependencies:
-    "@jest/types": "npm:^29.6.3"
+    "@jest/types": "npm:30.3.0"
     "@types/node": "npm:*"
-    chalk: "npm:^4.0.0"
-    ci-info: "npm:^3.2.0"
-    graceful-fs: "npm:^4.2.9"
-    picomatch: "npm:^2.2.3"
-  checksum: 10c0/bc55a8f49fdbb8f51baf31d2a4f312fb66c9db1483b82f602c9c990e659cdd7ec529c8e916d5a89452ecbcfae4949b21b40a7a59d4ffc0cd813a973ab08c8150
+    chalk: "npm:^4.1.2"
+    ci-info: "npm:^4.2.0"
+    graceful-fs: "npm:^4.2.11"
+    picomatch: "npm:^4.0.3"
+  checksum: 10c0/eea6f39e52a8cb2b1a28bb315a90dc6a8e450fffed73bb5ef4489d02d86f7d91be600d83f1dcba22956b8ac5fefa8f1b250e636c8402d3e8b50a5eec8b5963b2
   languageName: node
   linkType: hard
 
-"jest-validate@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-validate@npm:29.7.0"
+"jest-validate@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-validate@npm:30.3.0"
   dependencies:
-    "@jest/types": "npm:^29.6.3"
-    camelcase: "npm:^6.2.0"
-    chalk: "npm:^4.0.0"
-    jest-get-type: "npm:^29.6.3"
+    "@jest/get-type": "npm:30.1.0"
+    "@jest/types": "npm:30.3.0"
+    camelcase: "npm:^6.3.0"
+    chalk: "npm:^4.1.2"
     leven: "npm:^3.1.0"
-    pretty-format: "npm:^29.7.0"
-  checksum: 10c0/a20b930480c1ed68778c739f4739dce39423131bc070cd2505ddede762a5570a256212e9c2401b7ae9ba4d7b7c0803f03c5b8f1561c62348213aba18d9dbece2
+    pretty-format: "npm:30.3.0"
+  checksum: 10c0/645629e9ae0926252dee26b0ad71b9f0392daa896328393479c63b1b13d2a70df4dac8b5053227c64e0120e930db1242897898c40706f135f20f73ef77fcf4f5
   languageName: node
   linkType: hard
 
-"jest-watcher@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-watcher@npm:29.7.0"
+"jest-watcher@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-watcher@npm:30.3.0"
   dependencies:
-    "@jest/test-result": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
+    "@jest/test-result": "npm:30.3.0"
+    "@jest/types": "npm:30.3.0"
     "@types/node": "npm:*"
-    ansi-escapes: "npm:^4.2.1"
-    chalk: "npm:^4.0.0"
+    ansi-escapes: "npm:^4.3.2"
+    chalk: "npm:^4.1.2"
     emittery: "npm:^0.13.1"
-    jest-util: "npm:^29.7.0"
-    string-length: "npm:^4.0.1"
-  checksum: 10c0/ec6c75030562fc8f8c727cb8f3b94e75d831fc718785abfc196e1f2a2ebc9a2e38744a15147170039628a853d77a3b695561ce850375ede3a4ee6037a2574567
+    jest-util: "npm:30.3.0"
+    string-length: "npm:^4.0.2"
+  checksum: 10c0/2631be5cc122fbf14cb0bb7566cdea6d6c432b984d8ef3c6385254bb6c378342e0754cbd2dfe094d80762d44bd1c7015de2ec2100eb6f192906619d8b229e1a5
   languageName: node
   linkType: hard
 
-"jest-worker@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-worker@npm:29.7.0"
+"jest-worker@npm:30.3.0":
+  version: 30.3.0
+  resolution: "jest-worker@npm:30.3.0"
   dependencies:
     "@types/node": "npm:*"
-    jest-util: "npm:^29.7.0"
+    "@ungap/structured-clone": "npm:^1.3.0"
+    jest-util: "npm:30.3.0"
     merge-stream: "npm:^2.0.0"
-    supports-color: "npm:^8.0.0"
-  checksum: 10c0/5570a3a005b16f46c131968b8a5b56d291f9bbb85ff4217e31c80bd8a02e7de799e59a54b95ca28d5c302f248b54cbffde2d177c2f0f52ffcee7504c6eabf660
+    supports-color: "npm:^8.1.1"
+  checksum: 10c0/25dfb1bc43d389e1daf8baad0ef7964249f001a7da7d92c61e398840424ca13fb1fb6242f6e021f0cbb37952f90371fb8be1ef0183b5d04ef161fdb8f09ee78e
   languageName: node
   linkType: hard
 
-"jest@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest@npm:29.7.0"
+"jest@npm:^30.3.0":
+  version: 30.3.0
+  resolution: "jest@npm:30.3.0"
   dependencies:
-    "@jest/core": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    import-local: "npm:^3.0.2"
-    jest-cli: "npm:^29.7.0"
+    "@jest/core": "npm:30.3.0"
+    "@jest/types": "npm:30.3.0"
+    import-local: "npm:^3.2.0"
+    jest-cli: "npm:30.3.0"
   peerDependencies:
     node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
   peerDependenciesMeta:
     node-notifier:
       optional: true
   bin:
-    jest: bin/jest.js
-  checksum: 10c0/f40eb8171cf147c617cc6ada49d062fbb03b4da666cb8d39cdbfb739a7d75eea4c3ca150fb072d0d273dce0c753db4d0467d54906ad0293f59c54f9db4a09d8b
+    jest: ./bin/jest.js
+  checksum: 10c0/1f940424b741d1541c3d71e311f77c3cfaf31cff9ab2d53180333f00a31f157790a8d3d413b72b8dd2bb191aa75769fa741d9bc9085df779cd59689559a65815
   languageName: node
   linkType: hard
 
@@ -9263,13 +10100,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"js-stringify@npm:^1.0.1":
-  version: 1.0.2
-  resolution: "js-stringify@npm:1.0.2"
-  checksum: 10c0/a450c04fde3a7e1c27f1c3c4300433f8d79322f9e3c2e76266843cef8c0b5a69b5f11b5f173212b2f15f2df09e068ef7ddf46ef775e2486f3006a6f4e912578d
-  languageName: node
-  linkType: hard
-
 "js-tokens@npm:^3.0.0 || ^4.0.0, js-tokens@npm:^4.0.0":
   version: 4.0.0
   resolution: "js-tokens@npm:4.0.0"
@@ -9277,18 +10107,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"js-yaml@npm:4.0.0":
-  version: 4.0.0
-  resolution: "js-yaml@npm:4.0.0"
-  dependencies:
-    argparse: "npm:^2.0.1"
-  bin:
-    js-yaml: bin/js-yaml.js
-  checksum: 10c0/ef8489b87d9796b45df9f0bf3eefbb343b5063e39a9911d7b8ddbd4518cafaf73b49150d1f5865f54ee68719642ff0ab86110b9a332ff88bb05cd3bcf3039de1
-  languageName: node
-  linkType: hard
-
-"js-yaml@npm:4.1.1":
+"js-yaml@npm:4.1.1, js-yaml@npm:^4.1.1":
   version: 4.1.1
   resolution: "js-yaml@npm:4.1.1"
   dependencies:
@@ -9329,42 +10148,36 @@ __metadata:
   languageName: node
   linkType: hard
 
-"jsdom@npm:^20.0.0":
-  version: 20.0.3
-  resolution: "jsdom@npm:20.0.3"
-  dependencies:
-    abab: "npm:^2.0.6"
-    acorn: "npm:^8.8.1"
-    acorn-globals: "npm:^7.0.0"
-    cssom: "npm:^0.5.0"
-    cssstyle: "npm:^2.3.0"
-    data-urls: "npm:^3.0.2"
-    decimal.js: "npm:^10.4.2"
-    domexception: "npm:^4.0.0"
-    escodegen: "npm:^2.0.0"
-    form-data: "npm:^4.0.0"
-    html-encoding-sniffer: "npm:^3.0.0"
-    http-proxy-agent: "npm:^5.0.0"
-    https-proxy-agent: "npm:^5.0.1"
+"jsdom@npm:^26.1.0":
+  version: 26.1.0
+  resolution: "jsdom@npm:26.1.0"
+  dependencies:
+    cssstyle: "npm:^4.2.1"
+    data-urls: "npm:^5.0.0"
+    decimal.js: "npm:^10.5.0"
+    html-encoding-sniffer: "npm:^4.0.0"
+    http-proxy-agent: "npm:^7.0.2"
+    https-proxy-agent: "npm:^7.0.6"
     is-potential-custom-element-name: "npm:^1.0.1"
-    nwsapi: "npm:^2.2.2"
-    parse5: "npm:^7.1.1"
+    nwsapi: "npm:^2.2.16"
+    parse5: "npm:^7.2.1"
+    rrweb-cssom: "npm:^0.8.0"
     saxes: "npm:^6.0.0"
     symbol-tree: "npm:^3.2.4"
-    tough-cookie: "npm:^4.1.2"
-    w3c-xmlserializer: "npm:^4.0.0"
+    tough-cookie: "npm:^5.1.1"
+    w3c-xmlserializer: "npm:^5.0.0"
     webidl-conversions: "npm:^7.0.0"
-    whatwg-encoding: "npm:^2.0.0"
-    whatwg-mimetype: "npm:^3.0.0"
-    whatwg-url: "npm:^11.0.0"
-    ws: "npm:^8.11.0"
-    xml-name-validator: "npm:^4.0.0"
+    whatwg-encoding: "npm:^3.1.1"
+    whatwg-mimetype: "npm:^4.0.0"
+    whatwg-url: "npm:^14.1.1"
+    ws: "npm:^8.18.0"
+    xml-name-validator: "npm:^5.0.0"
   peerDependencies:
-    canvas: ^2.5.0
+    canvas: ^3.0.0
   peerDependenciesMeta:
     canvas:
       optional: true
-  checksum: 10c0/b109073bb826a966db7828f46cb1d7371abecd30f182b143c52be5fe1ed84513bbbe995eb3d157241681fcd18331381e61e3dc004d4949f3a63bca02f6214902
+  checksum: 10c0/5b14a5bc32ce077a06fb42d1ab95b1191afa5cbbce8859e3b96831c5143becbbcbf0511d4d4934e922d2901443ced2cdc3b734c1cf30b5f73b3e067ce457d0f4
   languageName: node
   linkType: hard
 
@@ -9377,6 +10190,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"jsesc@npm:^3.0.2":
+  version: 3.1.0
+  resolution: "jsesc@npm:3.1.0"
+  bin:
+    jsesc: bin/jsesc
+  checksum: 10c0/531779df5ec94f47e462da26b4cbf05eb88a83d9f08aac2ba04206508fc598527a153d08bd462bae82fc78b3eaa1a908e1a4a79f886e9238641c4cdefaf118b1
+  languageName: node
+  linkType: hard
+
 "json-buffer@npm:3.0.1":
   version: 3.0.1
   resolution: "json-buffer@npm:3.0.1"
@@ -9456,17 +10278,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"json5@npm:^1.0.2":
-  version: 1.0.2
-  resolution: "json5@npm:1.0.2"
-  dependencies:
-    minimist: "npm:^1.2.0"
-  bin:
-    json5: lib/cli.js
-  checksum: 10c0/9ee316bf21f000b00752e6c2a3b79ecf5324515a5c60ee88983a1910a45426b643a4f3461657586e8aeca87aaf96f0a519b0516d2ae527a6c3e7eed80f68717f
-  languageName: node
-  linkType: hard
-
 "json5@npm:^2.2.2, json5@npm:^2.2.3":
   version: 2.2.3
   resolution: "json5@npm:2.2.3"
@@ -9529,7 +10340,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"keyv@npm:^4.5.3":
+"keyv@npm:^4.5.4":
   version: 4.5.4
   resolution: "keyv@npm:4.5.4"
   dependencies:
@@ -9541,14 +10352,7 @@ __metadata:
 "kind-of@npm:^6.0.0, kind-of@npm:^6.0.2, kind-of@npm:^6.0.3":
   version: 6.0.3
   resolution: "kind-of@npm:6.0.3"
-  checksum: 10c0/61cdff9623dabf3568b6445e93e31376bee1cdb93f8ba7033d86022c2a9b1791a1d9510e026e6465ebd701a6dd2f7b0808483ad8838341ac52f003f512e0b4c4
-  languageName: node
-  linkType: hard
-
-"kleur@npm:^3.0.3":
-  version: 3.0.3
-  resolution: "kleur@npm:3.0.3"
-  checksum: 10c0/cd3a0b8878e7d6d3799e54340efe3591ca787d9f95f109f28129bdd2915e37807bf8918bb295ab86afb8c82196beec5a1adcaf29042ce3f2bd932b038fe3aa4b
+  checksum: 10c0/61cdff9623dabf3568b6445e93e31376bee1cdb93f8ba7033d86022c2a9b1791a1d9510e026e6465ebd701a6dd2f7b0808483ad8838341ac52f003f512e0b4c4
   languageName: node
   linkType: hard
 
@@ -9691,6 +10495,126 @@ __metadata:
   languageName: node
   linkType: hard
 
+"lightningcss-android-arm64@npm:1.32.0":
+  version: 1.32.0
+  resolution: "lightningcss-android-arm64@npm:1.32.0"
+  conditions: os=android & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"lightningcss-darwin-arm64@npm:1.32.0":
+  version: 1.32.0
+  resolution: "lightningcss-darwin-arm64@npm:1.32.0"
+  conditions: os=darwin & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"lightningcss-darwin-x64@npm:1.32.0":
+  version: 1.32.0
+  resolution: "lightningcss-darwin-x64@npm:1.32.0"
+  conditions: os=darwin & cpu=x64
+  languageName: node
+  linkType: hard
+
+"lightningcss-freebsd-x64@npm:1.32.0":
+  version: 1.32.0
+  resolution: "lightningcss-freebsd-x64@npm:1.32.0"
+  conditions: os=freebsd & cpu=x64
+  languageName: node
+  linkType: hard
+
+"lightningcss-linux-arm-gnueabihf@npm:1.32.0":
+  version: 1.32.0
+  resolution: "lightningcss-linux-arm-gnueabihf@npm:1.32.0"
+  conditions: os=linux & cpu=arm
+  languageName: node
+  linkType: hard
+
+"lightningcss-linux-arm64-gnu@npm:1.32.0":
+  version: 1.32.0
+  resolution: "lightningcss-linux-arm64-gnu@npm:1.32.0"
+  conditions: os=linux & cpu=arm64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"lightningcss-linux-arm64-musl@npm:1.32.0":
+  version: 1.32.0
+  resolution: "lightningcss-linux-arm64-musl@npm:1.32.0"
+  conditions: os=linux & cpu=arm64 & libc=musl
+  languageName: node
+  linkType: hard
+
+"lightningcss-linux-x64-gnu@npm:1.32.0":
+  version: 1.32.0
+  resolution: "lightningcss-linux-x64-gnu@npm:1.32.0"
+  conditions: os=linux & cpu=x64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"lightningcss-linux-x64-musl@npm:1.32.0":
+  version: 1.32.0
+  resolution: "lightningcss-linux-x64-musl@npm:1.32.0"
+  conditions: os=linux & cpu=x64 & libc=musl
+  languageName: node
+  linkType: hard
+
+"lightningcss-win32-arm64-msvc@npm:1.32.0":
+  version: 1.32.0
+  resolution: "lightningcss-win32-arm64-msvc@npm:1.32.0"
+  conditions: os=win32 & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"lightningcss-win32-x64-msvc@npm:1.32.0":
+  version: 1.32.0
+  resolution: "lightningcss-win32-x64-msvc@npm:1.32.0"
+  conditions: os=win32 & cpu=x64
+  languageName: node
+  linkType: hard
+
+"lightningcss@npm:^1.32.0":
+  version: 1.32.0
+  resolution: "lightningcss@npm:1.32.0"
+  dependencies:
+    detect-libc: "npm:^2.0.3"
+    lightningcss-android-arm64: "npm:1.32.0"
+    lightningcss-darwin-arm64: "npm:1.32.0"
+    lightningcss-darwin-x64: "npm:1.32.0"
+    lightningcss-freebsd-x64: "npm:1.32.0"
+    lightningcss-linux-arm-gnueabihf: "npm:1.32.0"
+    lightningcss-linux-arm64-gnu: "npm:1.32.0"
+    lightningcss-linux-arm64-musl: "npm:1.32.0"
+    lightningcss-linux-x64-gnu: "npm:1.32.0"
+    lightningcss-linux-x64-musl: "npm:1.32.0"
+    lightningcss-win32-arm64-msvc: "npm:1.32.0"
+    lightningcss-win32-x64-msvc: "npm:1.32.0"
+  dependenciesMeta:
+    lightningcss-android-arm64:
+      optional: true
+    lightningcss-darwin-arm64:
+      optional: true
+    lightningcss-darwin-x64:
+      optional: true
+    lightningcss-freebsd-x64:
+      optional: true
+    lightningcss-linux-arm-gnueabihf:
+      optional: true
+    lightningcss-linux-arm64-gnu:
+      optional: true
+    lightningcss-linux-arm64-musl:
+      optional: true
+    lightningcss-linux-x64-gnu:
+      optional: true
+    lightningcss-linux-x64-musl:
+      optional: true
+    lightningcss-win32-arm64-msvc:
+      optional: true
+    lightningcss-win32-x64-msvc:
+      optional: true
+  checksum: 10c0/70945bd55097af46fc9fab7f5ed09cd5869d85940a2acab7ee06d0117004a1d68155708a2d462531cea2fc3c67aefc9333a7068c80b0b78dd404c16838809e03
+  languageName: node
+  linkType: hard
+
 "lilconfig@npm:3.1.1":
   version: 3.1.1
   resolution: "lilconfig@npm:3.1.1"
@@ -9807,6 +10731,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"locate-path@npm:^8.0.0":
+  version: 8.0.0
+  resolution: "locate-path@npm:8.0.0"
+  dependencies:
+    p-locate: "npm:^6.0.0"
+  checksum: 10c0/4c837878b6d1b8557c5d1c624d11d6721d77f4627c14bd84182c85cbb9ec8fc01b5b5f089e21fab17b30fc5ecc14216a3d31f754dfcc5299f1fe9f4c83482fee
+  languageName: node
+  linkType: hard
+
 "lodash-es@npm:^4.17.23":
   version: 4.17.23
   resolution: "lodash-es@npm:4.17.23"
@@ -9870,22 +10803,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"lodash@npm:^4.17.10, lodash@npm:^4.17.14, lodash@npm:^4.17.20, lodash@npm:^4.17.4":
+"lodash@npm:^4.17.10, lodash@npm:^4.17.14, lodash@npm:^4.17.20":
   version: 4.17.21
   resolution: "lodash@npm:4.17.21"
   checksum: 10c0/d8cbea072bb08655bb4c989da418994b073a608dffa608b09ac04b43a791b12aeae7cd7ad919aa4c925f33b48490b5cfe6c1f71d827956071dae2e7bb3a6b74c
   languageName: node
   linkType: hard
 
-"log-symbols@npm:4.0.0":
-  version: 4.0.0
-  resolution: "log-symbols@npm:4.0.0"
-  dependencies:
-    chalk: "npm:^4.0.0"
-  checksum: 10c0/d744042ccca6404350fb809f6d98293a18b840e2323e72c45f6a47932d418f0af6e05a2434ab6558b607a132f895e3bb53c8483a7ceeb554d82a3c83438db493
-  languageName: node
-  linkType: hard
-
 "log-symbols@npm:^4.0.0, log-symbols@npm:^4.1.0":
   version: 4.1.0
   resolution: "log-symbols@npm:4.1.0"
@@ -9934,6 +10858,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"lru-cache@npm:^10.4.3":
+  version: 10.4.3
+  resolution: "lru-cache@npm:10.4.3"
+  checksum: 10c0/ebd04fbca961e6c1d6c0af3799adcc966a1babe798f685bb84e6599266599cd95d94630b10262f5424539bc4640107e8a33aa28585374abf561d30d16f4b39fb
+  languageName: node
+  linkType: hard
+
 "lru-cache@npm:^11.0.0, lru-cache@npm:^11.1.0, lru-cache@npm:^11.2.1":
   version: 11.2.4
   resolution: "lru-cache@npm:11.2.4"
@@ -9968,6 +10899,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"magic-string@npm:^0.30.21":
+  version: 0.30.21
+  resolution: "magic-string@npm:0.30.21"
+  dependencies:
+    "@jridgewell/sourcemap-codec": "npm:^1.5.5"
+  checksum: 10c0/299378e38f9a270069fc62358522ddfb44e94244baa0d6a8980ab2a9b2490a1d03b236b447eee309e17eb3bddfa482c61259d47960eb018a904f0ded52780c4a
+  languageName: node
+  linkType: hard
+
 "make-dir@npm:4.0.0, make-dir@npm:^4.0.0":
   version: 4.0.0
   resolution: "make-dir@npm:4.0.0"
@@ -10402,13 +11342,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"merge2@npm:^1.3.0, merge2@npm:^1.4.1":
-  version: 1.4.1
-  resolution: "merge2@npm:1.4.1"
-  checksum: 10c0/254a8a4605b58f450308fc474c82ac9a094848081bf4c06778200207820e5193726dc563a0d2c16468810516a5c97d9d3ea0ca6585d23c58ccfff2403e8dbbeb
-  languageName: node
-  linkType: hard
-
 "micromark-core-commonmark@npm:^2.0.0":
   version: 2.0.3
   resolution: "micromark-core-commonmark@npm:2.0.3"
@@ -10856,16 +11789,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"micromatch@npm:^4.0.4":
-  version: 4.0.7
-  resolution: "micromatch@npm:4.0.7"
-  dependencies:
-    braces: "npm:^3.0.3"
-    picomatch: "npm:^2.3.1"
-  checksum: 10c0/58fa99bc5265edec206e9163a1d2cec5fabc46a5b473c45f4a700adce88c2520456ae35f2b301e4410fb3afb27e9521fb2813f6fc96be0a48a89430e0916a772
-  languageName: node
-  linkType: hard
-
 "mime-db@npm:1.52.0":
   version: 1.52.0
   resolution: "mime-db@npm:1.52.0"
@@ -10917,15 +11840,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"minimatch@npm:3.0.4":
-  version: 3.0.4
-  resolution: "minimatch@npm:3.0.4"
-  dependencies:
-    brace-expansion: "npm:^1.1.7"
-  checksum: 10c0/d0a2bcd93ebec08a9eef3ca83ba33c9fb6feb93932e0b4dc6aa46c5f37a9404bea7ad9ff7cafe23ce6634f1fe3b206f5315ecbb05812da6e692c21d8ecfd3dae
-  languageName: node
-  linkType: hard
-
 "minimatch@npm:3.0.5":
   version: 3.0.5
   resolution: "minimatch@npm:3.0.5"
@@ -10953,7 +11867,16 @@ __metadata:
   languageName: node
   linkType: hard
 
-"minimatch@npm:^3.0.3, minimatch@npm:^3.0.4, minimatch@npm:^3.0.5, minimatch@npm:^3.1.1, minimatch@npm:^3.1.2":
+"minimatch@npm:^10.2.2":
+  version: 10.2.5
+  resolution: "minimatch@npm:10.2.5"
+  dependencies:
+    brace-expansion: "npm:^5.0.5"
+  checksum: 10c0/6bb058bd6324104b9ec2f763476a35386d05079c1f5fe4fbf1f324a25237cd4534d6813ecd71f48208f4e635c1221899bef94c3c89f7df55698fe373aaae20fd
+  languageName: node
+  linkType: hard
+
+"minimatch@npm:^3.0.4, minimatch@npm:^3.1.1, minimatch@npm:^3.1.2":
   version: 3.1.2
   resolution: "minimatch@npm:3.1.2"
   dependencies:
@@ -10962,6 +11885,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"minimatch@npm:^3.1.5":
+  version: 3.1.5
+  resolution: "minimatch@npm:3.1.5"
+  dependencies:
+    brace-expansion: "npm:^1.1.7"
+  checksum: 10c0/2ecbdc0d33f07bddb0315a8b5afbcb761307a8778b48f0b312418ccbced99f104a2d17d8aca7573433c70e8ccd1c56823a441897a45e384ea76ef401a26ace70
+  languageName: node
+  linkType: hard
+
 "minimatch@npm:^5.0.1":
   version: 5.1.6
   resolution: "minimatch@npm:5.1.6"
@@ -11158,6 +12090,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"minipass@npm:^7.1.3":
+  version: 7.1.3
+  resolution: "minipass@npm:7.1.3"
+  checksum: 10c0/539da88daca16533211ea5a9ee98dc62ff5742f531f54640dd34429e621955e91cc280a91a776026264b7f9f6735947629f920944e9c1558369e8bf22eb33fbb
+  languageName: node
+  linkType: hard
+
 "minizlib@npm:^2.0.0, minizlib@npm:^2.1.1, minizlib@npm:^2.1.2":
   version: 2.1.2
   resolution: "minizlib@npm:2.1.2"
@@ -11193,9 +12132,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"mocha@npm:^11.0.1":
-  version: 11.7.4
-  resolution: "mocha@npm:11.7.4"
+"mocha@npm:^11.7.5":
+  version: 11.7.5
+  resolution: "mocha@npm:11.7.5"
   dependencies:
     browser-stdout: "npm:^1.3.1"
     chokidar: "npm:^4.0.1"
@@ -11221,43 +12160,7 @@ __metadata:
   bin:
     _mocha: bin/_mocha
     mocha: bin/mocha.js
-  checksum: 10c0/f84252dd93b7d67e20e3ca09c6be0da77d43795d502132a976450c5c19025de632bbaab6751dd1d8fd6311a3063d2f3647e61db84feb17900995d52e01cfb3b8
-  languageName: node
-  linkType: hard
-
-"mocha@npm:^8.1.3":
-  version: 8.4.0
-  resolution: "mocha@npm:8.4.0"
-  dependencies:
-    "@ungap/promise-all-settled": "npm:1.1.2"
-    ansi-colors: "npm:4.1.1"
-    browser-stdout: "npm:1.3.1"
-    chokidar: "npm:3.5.1"
-    debug: "npm:4.3.1"
-    diff: "npm:5.0.0"
-    escape-string-regexp: "npm:4.0.0"
-    find-up: "npm:5.0.0"
-    glob: "npm:7.1.6"
-    growl: "npm:1.10.5"
-    he: "npm:1.2.0"
-    js-yaml: "npm:4.0.0"
-    log-symbols: "npm:4.0.0"
-    minimatch: "npm:3.0.4"
-    ms: "npm:2.1.3"
-    nanoid: "npm:3.1.20"
-    serialize-javascript: "npm:5.0.1"
-    strip-json-comments: "npm:3.1.1"
-    supports-color: "npm:8.1.1"
-    which: "npm:2.0.2"
-    wide-align: "npm:1.1.3"
-    workerpool: "npm:6.1.0"
-    yargs: "npm:16.2.0"
-    yargs-parser: "npm:20.2.4"
-    yargs-unparser: "npm:2.0.0"
-  bin:
-    _mocha: bin/_mocha
-    mocha: bin/mocha
-  checksum: 10c0/9b4d31e1f3fdbc4efad38a2a98b4990ce823f6241f62ca31a7489d811628ccf68317a2b0caf50b235eb04738b41bf539c5ee9d4f456bc0596a58d2e46f7eee99
+  checksum: 10c0/e6150cba85345aaabbc5b2e7341b1e6706b878f5a9782960cad57fd4cc458730a76d08c5f1a3e05d3ebb49cad93b455764bb00727bd148dcaf0c6dd4fa665b3d
   languageName: node
   linkType: hard
 
@@ -11319,7 +12222,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ms@npm:2.1.3, ms@npm:^2.0.0, ms@npm:^2.1.1, ms@npm:^2.1.3":
+"ms@npm:^2.0.0, ms@npm:^2.1.1, ms@npm:^2.1.3":
   version: 2.1.3
   resolution: "ms@npm:2.1.3"
   checksum: 10c0/d924b57e7312b3b63ad21fc5b3dc0af5e78d61a1fc7cfb5457edaf26326bf62be5307cc87ffb6862ef1c2b33b0233cdb5d4f01c4c958cc0d660948b65a287a48
@@ -11346,12 +12249,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"nanoid@npm:3.1.20":
-  version: 3.1.20
-  resolution: "nanoid@npm:3.1.20"
+"nanoid@npm:^3.3.11":
+  version: 3.3.11
+  resolution: "nanoid@npm:3.3.11"
   bin:
     nanoid: bin/nanoid.cjs
-  checksum: 10c0/aac1e0b6bc8fb96a83a32a652df88385ccd66df6adaed257202f086d9d6e4ab3b3fb6bf9ea0e81a0e2996ae80da465760a8049105a499331ba57344868edac04
+  checksum: 10c0/40e7f70b3d15f725ca072dfc4f74e81fcf1fbb02e491cf58ac0c79093adc9b0a73b152bcde57df4b79cd097e13023d7504acb38404a4da7bc1cd8e887b82fe0b
   languageName: node
   linkType: hard
 
@@ -11362,6 +12265,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"napi-postinstall@npm:^0.3.0":
+  version: 0.3.4
+  resolution: "napi-postinstall@npm:0.3.4"
+  bin:
+    napi-postinstall: lib/cli.js
+  checksum: 10c0/b33d64150828bdade3a5d07368a8b30da22ee393f8dd8432f1b9e5486867be21c84ec443dd875dd3ef3c7401a079a7ab7e2aa9d3538a889abbcd96495d5104fe
+  languageName: node
+  linkType: hard
+
 "natural-compare@npm:^1.4.0":
   version: 1.4.0
   resolution: "natural-compare@npm:1.4.0"
@@ -11390,6 +12302,27 @@ __metadata:
   languageName: node
   linkType: hard
 
+"neostandard@npm:^0.13.0":
+  version: 0.13.0
+  resolution: "neostandard@npm:0.13.0"
+  dependencies:
+    "@humanwhocodes/gitignore-to-minimatch": "npm:^1.0.2"
+    "@stylistic/eslint-plugin": "npm:2.11.0"
+    eslint-plugin-n: "npm:^17.23.2"
+    eslint-plugin-promise: "npm:^7.2.1"
+    eslint-plugin-react: "npm:^7.37.5"
+    find-up: "npm:^8.0.0"
+    globals: "npm:^17.3.0"
+    peowly: "npm:^1.3.3"
+    typescript-eslint: "npm:^8.56.0"
+  peerDependencies:
+    eslint: ^9.0.0
+  bin:
+    neostandard: cli.mjs
+  checksum: 10c0/8fc50c3d42b7bae6ae8dce419fb2905f475e16342fb8b39eeec9a27e774d7057b5d7cc544f7f2364d00a10dda292ac8a5e27d9bd35c3fecbbab86d98c610682c
+  languageName: node
+  linkType: hard
+
 "node-abi@npm:^3.3.0":
   version: 3.85.0
   resolution: "node-abi@npm:3.85.0"
@@ -11509,6 +12442,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"node-releases@npm:^2.0.36":
+  version: 2.0.38
+  resolution: "node-releases@npm:2.0.38"
+  checksum: 10c0/db9909234ed750c5b9d0075f83214cd16b76370b54eab50e3554f3ba939ba7ac39f3aca2ddf93471ae8553dbde2ea9354b0ae380c9cff1f8e53b55e414903413
+  languageName: node
+  linkType: hard
+
 "nopt@npm:^5.0.0":
   version: 5.0.0
   resolution: "nopt@npm:5.0.0"
@@ -11773,10 +12713,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"nwsapi@npm:^2.2.2":
-  version: 2.2.10
-  resolution: "nwsapi@npm:2.2.10"
-  checksum: 10c0/43dfa150387bd2a578e37556d0ae3330d5617f99e5a7b64e3400d4c2785620762aa6169caf8f5fbce17b7ef29c372060b602594320c374fba0a39da4163d77ed
+"nwsapi@npm:^2.2.16":
+  version: 2.2.23
+  resolution: "nwsapi@npm:2.2.23"
+  checksum: 10c0/e44bfc9246baf659581206ed716d291a1905185247795fb8a302cb09315c943a31023b4ac4d026a5eaf32b2def51d77b3d0f9ebf4f3d35f70e105fcb6447c76e
   languageName: node
   linkType: hard
 
@@ -11879,6 +12819,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"object-inspect@npm:^1.13.3, object-inspect@npm:^1.13.4":
+  version: 1.13.4
+  resolution: "object-inspect@npm:1.13.4"
+  checksum: 10c0/d7f8711e803b96ea3191c745d6f8056ce1f2496e530e6a19a0e92d89b0fa3c76d910c31f0aa270432db6bd3b2f85500a376a83aaba849a8d518c8845b3211692
+  languageName: node
+  linkType: hard
+
 "object-is@npm:^1.1.5":
   version: 1.1.6
   resolution: "object-is@npm:1.1.6"
@@ -11908,18 +12855,33 @@ __metadata:
   languageName: node
   linkType: hard
 
-"object.entries@npm:^1.1.7":
-  version: 1.1.8
-  resolution: "object.entries@npm:1.1.8"
+"object.assign@npm:^4.1.7":
+  version: 4.1.7
+  resolution: "object.assign@npm:4.1.7"
   dependencies:
-    call-bind: "npm:^1.0.7"
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.3"
     define-properties: "npm:^1.2.1"
     es-object-atoms: "npm:^1.0.0"
-  checksum: 10c0/db9ea979d2956a3bc26c262da4a4d212d36f374652cc4c13efdd069c1a519c16571c137e2893d1c46e1cb0e15c88fd6419eaf410c945f329f09835487d7e65d3
+    has-symbols: "npm:^1.1.0"
+    object-keys: "npm:^1.1.1"
+  checksum: 10c0/3b2732bd860567ea2579d1567525168de925a8d852638612846bd8082b3a1602b7b89b67b09913cbb5b9bd6e95923b2ae73580baa9d99cb4e990564e8cbf5ddc
+  languageName: node
+  linkType: hard
+
+"object.entries@npm:^1.1.9":
+  version: 1.1.9
+  resolution: "object.entries@npm:1.1.9"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.4"
+    define-properties: "npm:^1.2.1"
+    es-object-atoms: "npm:^1.1.1"
+  checksum: 10c0/d4b8c1e586650407da03370845f029aa14076caca4e4d4afadbc69cfb5b78035fd3ee7be417141abdb0258fa142e59b11923b4c44d8b1255b28f5ffcc50da7db
   languageName: node
   linkType: hard
 
-"object.fromentries@npm:^2.0.7":
+"object.fromentries@npm:^2.0.8":
   version: 2.0.8
   resolution: "object.fromentries@npm:2.0.8"
   dependencies:
@@ -11931,36 +12893,33 @@ __metadata:
   languageName: node
   linkType: hard
 
-"object.groupby@npm:^1.0.1":
-  version: 1.0.3
-  resolution: "object.groupby@npm:1.0.3"
+"object.values@npm:^1.1.6":
+  version: 1.2.0
+  resolution: "object.values@npm:1.2.0"
   dependencies:
     call-bind: "npm:^1.0.7"
     define-properties: "npm:^1.2.1"
-    es-abstract: "npm:^1.23.2"
-  checksum: 10c0/60d0455c85c736fbfeda0217d1a77525956f76f7b2495edeca9e9bbf8168a45783199e77b894d30638837c654d0cc410e0e02cbfcf445bc8de71c3da1ede6a9c
+    es-object-atoms: "npm:^1.0.0"
+  checksum: 10c0/15809dc40fd6c5529501324fec5ff08570b7d70fb5ebbe8e2b3901afec35cf2b3dc484d1210c6c642cd3e7e0a5e18dd1d6850115337fef46bdae14ab0cb18ac3
   languageName: node
   linkType: hard
 
-"object.hasown@npm:^1.1.3":
-  version: 1.1.4
-  resolution: "object.hasown@npm:1.1.4"
+"object.values@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "object.values@npm:1.2.1"
   dependencies:
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.3"
     define-properties: "npm:^1.2.1"
-    es-abstract: "npm:^1.23.2"
     es-object-atoms: "npm:^1.0.0"
-  checksum: 10c0/f23187b08d874ef1aea060118c8259eb7f99f93c15a50771d710569534119062b90e087b92952b2d0fb1bb8914d61fb0b43c57fb06f622aaad538fe6868ab987
+  checksum: 10c0/3c47814fdc64842ae3d5a74bc9d06bdd8d21563c04d9939bf6716a9c00596a4ebc342552f8934013d1ec991c74e3671b26710a0c51815f0b603795605ab6b2c9
   languageName: node
   linkType: hard
 
-"object.values@npm:^1.1.6, object.values@npm:^1.1.7":
-  version: 1.2.0
-  resolution: "object.values@npm:1.2.0"
-  dependencies:
-    call-bind: "npm:^1.0.7"
-    define-properties: "npm:^1.2.1"
-    es-object-atoms: "npm:^1.0.0"
-  checksum: 10c0/15809dc40fd6c5529501324fec5ff08570b7d70fb5ebbe8e2b3901afec35cf2b3dc484d1210c6c642cd3e7e0a5e18dd1d6850115337fef46bdae14ab0cb18ac3
+"obug@npm:^2.1.1":
+  version: 2.1.1
+  resolution: "obug@npm:2.1.1"
+  checksum: 10c0/59dccd7de72a047e08f8649e94c1015ec72f94eefb6ddb57fb4812c4b425a813bc7e7cd30c9aca20db3c59abc3c85cc7a62bb656a968741d770f4e8e02bc2e78
   languageName: node
   linkType: hard
 
@@ -12080,6 +13039,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"own-keys@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "own-keys@npm:1.0.1"
+  dependencies:
+    get-intrinsic: "npm:^1.2.6"
+    object-keys: "npm:^1.1.1"
+    safe-push-apply: "npm:^1.0.0"
+  checksum: 10c0/6dfeb3455bff92ec3f16a982d4e3e65676345f6902d9f5ded1d8265a6318d0200ce461956d6d1c70053c7fe9f9fe65e552faac03f8140d37ef0fdd108e67013a
+  languageName: node
+  linkType: hard
+
 "p-finally@npm:^1.0.0":
   version: 1.0.0
   resolution: "p-finally@npm:1.0.0"
@@ -12114,6 +13084,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"p-limit@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "p-limit@npm:4.0.0"
+  dependencies:
+    yocto-queue: "npm:^1.0.0"
+  checksum: 10c0/a56af34a77f8df2ff61ddfb29431044557fcbcb7642d5a3233143ebba805fc7306ac1d448de724352861cb99de934bc9ab74f0d16fe6a5460bdbdf938de875ad
+  languageName: node
+  linkType: hard
+
 "p-locate@npm:^2.0.0":
   version: 2.0.0
   resolution: "p-locate@npm:2.0.0"
@@ -12141,6 +13120,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"p-locate@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "p-locate@npm:6.0.0"
+  dependencies:
+    p-limit: "npm:^4.0.0"
+  checksum: 10c0/d72fa2f41adce59c198270aa4d3c832536c87a1806e0f69dffb7c1a7ca998fb053915ca833d90f166a8c082d3859eabfed95f01698a3214c20df6bb8de046312
+  languageName: node
+  linkType: hard
+
 "p-map-series@npm:2.1.0":
   version: 2.1.0
   resolution: "p-map-series@npm:2.1.0"
@@ -12357,7 +13345,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"parse5@npm:^7.0.0, parse5@npm:^7.1.1":
+"parse5@npm:^7.0.0":
   version: 7.1.2
   resolution: "parse5@npm:7.1.2"
   dependencies:
@@ -12366,6 +13354,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"parse5@npm:^7.2.1":
+  version: 7.3.0
+  resolution: "parse5@npm:7.3.0"
+  dependencies:
+    entities: "npm:^6.0.0"
+  checksum: 10c0/7fd2e4e247e85241d6f2a464d0085eed599a26d7b0a5233790c49f53473232eb85350e8133344d9b3fd58b89339e7ad7270fe1f89d28abe50674ec97b87f80b5
+  languageName: node
+  linkType: hard
+
 "path-exists@npm:^3.0.0":
   version: 3.0.0
   resolution: "path-exists@npm:3.0.0"
@@ -12428,6 +13425,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"path-scurry@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "path-scurry@npm:2.0.2"
+  dependencies:
+    lru-cache: "npm:^11.0.0"
+    minipass: "npm:^7.1.2"
+  checksum: 10c0/b35ad37cf6557a87fd057121ce2be7695380c9138d93e87ae928609da259ea0a170fac6f3ef1eb3ece8a068e8b7f2f3adf5bb2374cf4d4a57fe484954fcc9482
+  languageName: node
+  linkType: hard
+
 "path-type@npm:^3.0.0":
   version: 3.0.0
   resolution: "path-type@npm:3.0.0"
@@ -12444,21 +13451,35 @@ __metadata:
   languageName: node
   linkType: hard
 
-"picocolors@npm:^1.0.0, picocolors@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "picocolors@npm:1.0.1"
-  checksum: 10c0/c63cdad2bf812ef0d66c8db29583802355d4ca67b9285d846f390cc15c2f6ccb94e8cb7eb6a6e97fc5990a6d3ad4ae42d86c84d3146e667c739a4234ed50d400
+"pathe@npm:^2.0.3":
+  version: 2.0.3
+  resolution: "pathe@npm:2.0.3"
+  checksum: 10c0/c118dc5a8b5c4166011b2b70608762e260085180bb9e33e80a50dcdb1e78c010b1624f4280c492c92b05fc276715a4c357d1f9edc570f8f1b3d90b6839ebaca1
+  languageName: node
+  linkType: hard
+
+"peowly@npm:^1.3.3":
+  version: 1.3.3
+  resolution: "peowly@npm:1.3.3"
+  checksum: 10c0/64297310c8815137d5f1a2e404121797707b130bd06b72568a4612af7f4504bc217864b5eb5db03ba7514eee61f7a6af164fbee2ce5f99c48167d5dd818e4bfd
   languageName: node
   linkType: hard
 
-"picocolors@npm:^1.1.1":
+"picocolors@npm:1.1.1, picocolors@npm:^1.1.1":
   version: 1.1.1
   resolution: "picocolors@npm:1.1.1"
   checksum: 10c0/e2e3e8170ab9d7c7421969adaa7e1b31434f789afb9b3f115f6b96d91945041ac3ceb02e9ec6fe6510ff036bcc0bf91e69a1772edc0b707e12b19c0f2d6bcf58
   languageName: node
   linkType: hard
 
-"picomatch@npm:^2.0.4, picomatch@npm:^2.2.1, picomatch@npm:^2.2.3, picomatch@npm:^2.3.1":
+"picocolors@npm:^1.0.0, picocolors@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "picocolors@npm:1.0.1"
+  checksum: 10c0/c63cdad2bf812ef0d66c8db29583802355d4ca67b9285d846f390cc15c2f6ccb94e8cb7eb6a6e97fc5990a6d3ad4ae42d86c84d3146e667c739a4234ed50d400
+  languageName: node
+  linkType: hard
+
+"picomatch@npm:^2.0.4, picomatch@npm:^2.2.1":
   version: 2.3.1
   resolution: "picomatch@npm:2.3.1"
   checksum: 10c0/26c02b8d06f03206fc2ab8d16f19960f2ff9e81a658f831ecb656d8f17d9edc799e8364b1f4a7873e89d9702dff96204be0fa26fe4181f6843f040f819dac4be
@@ -12479,6 +13500,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"picomatch@npm:^4.0.4":
+  version: 4.0.4
+  resolution: "picomatch@npm:4.0.4"
+  checksum: 10c0/e2c6023372cc7b5764719a5ffb9da0f8e781212fa7ca4bd0562db929df8e117460f00dff3cb7509dacfc06b86de924b247f504d0ce1806a37fac4633081466b0
+  languageName: node
+  linkType: hard
+
 "pidtree@npm:0.6.0":
   version: 0.6.0
   resolution: "pidtree@npm:0.6.0"
@@ -12516,10 +13544,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"pirates@npm:^4.0.4":
-  version: 4.0.6
-  resolution: "pirates@npm:4.0.6"
-  checksum: 10c0/00d5fa51f8dded94d7429700fb91a0c1ead00ae2c7fd27089f0c5b63e6eca36197fe46384631872690a66f390c5e27198e99006ab77ae472692ab9c2ca903f36
+"pirates@npm:^4.0.7":
+  version: 4.0.7
+  resolution: "pirates@npm:4.0.7"
+  checksum: 10c0/a51f108dd811beb779d58a76864bbd49e239fa40c7984cd11596c75a121a8cc789f1c8971d8bb15f0dbf9d48b76c05bb62fcbce840f89b688c0fa64b37e8478a
   languageName: node
   linkType: hard
 
@@ -12574,6 +13602,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss@npm:^8.5.10":
+  version: 8.5.12
+  resolution: "postcss@npm:8.5.12"
+  dependencies:
+    nanoid: "npm:^3.3.11"
+    picocolors: "npm:^1.1.1"
+    source-map-js: "npm:^1.2.1"
+  checksum: 10c0/5baebaf574c567bc1b3d61197f38af4ce5920b8f611c887fb6bc3dcc14af00253c169dbf19897bc889cce0b0d9818ab5eb4ea0caedf02b0bab10da8a43ce8c12
+  languageName: node
+  linkType: hard
+
 "prebuild-install@npm:^7.1.1":
   version: 7.1.3
   resolution: "prebuild-install@npm:7.1.3"
@@ -12614,6 +13653,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"pretty-format@npm:30.3.0":
+  version: 30.3.0
+  resolution: "pretty-format@npm:30.3.0"
+  dependencies:
+    "@jest/schemas": "npm:30.0.5"
+    ansi-styles: "npm:^5.2.0"
+    react-is: "npm:^18.3.1"
+  checksum: 10c0/719b27d70cd8b01013485054c5d094e1fe85e093b09ee73553e3b19302da3cf54fbd6a7ea9577d6471aeff8d372200e56979ffc4c831e2133520bd18060895fb
+  languageName: node
+  linkType: hard
+
 "pretty-format@npm:^27.0.2":
   version: 27.5.1
   resolution: "pretty-format@npm:27.5.1"
@@ -12625,17 +13675,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"pretty-format@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "pretty-format@npm:29.7.0"
-  dependencies:
-    "@jest/schemas": "npm:^29.6.3"
-    ansi-styles: "npm:^5.0.0"
-    react-is: "npm:^18.0.0"
-  checksum: 10c0/edc5ff89f51916f036c62ed433506b55446ff739358de77207e63e88a28ca2894caac6e73dcb68166a606e51c8087d32d400473e6a9fdd2dbe743f46c9c0276f
-  languageName: node
-  linkType: hard
-
 "proc-log@npm:^3.0.0":
   version: 3.0.0
   resolution: "proc-log@npm:3.0.0"
@@ -12716,16 +13755,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"prompts@npm:^2.0.1":
-  version: 2.4.2
-  resolution: "prompts@npm:2.4.2"
-  dependencies:
-    kleur: "npm:^3.0.3"
-    sisteransi: "npm:^1.0.5"
-  checksum: 10c0/16f1ac2977b19fe2cf53f8411cc98db7a3c8b115c479b2ca5c82b5527cd937aa405fa04f9a5960abeb9daef53191b53b4d13e35c1f5d50e8718c76917c5f1ea4
-  languageName: node
-  linkType: hard
-
 "promzard@npm:^2.0.0":
   version: 2.0.0
   resolution: "promzard@npm:2.0.0"
@@ -12767,38 +13796,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"psl@npm:^1.1.33":
-  version: 1.9.0
-  resolution: "psl@npm:1.9.0"
-  checksum: 10c0/6a3f805fdab9442f44de4ba23880c4eba26b20c8e8e0830eff1cb31007f6825dace61d17203c58bfe36946842140c97a1ba7f67bc63ca2d88a7ee052b65d97ab
-  languageName: node
-  linkType: hard
-
-"pug-attrs@npm:^2.0.4":
-  version: 2.0.4
-  resolution: "pug-attrs@npm:2.0.4"
-  dependencies:
-    constantinople: "npm:^3.0.1"
-    js-stringify: "npm:^1.0.1"
-    pug-runtime: "npm:^2.0.5"
-  checksum: 10c0/f88c5ad83224bb3c717f601b655e0c75401036f561bccf710e9c5e7d33479dfc69c73144c6369658d670c2c53c21f974736c63d2944b4b085feb4facdde20be1
-  languageName: node
-  linkType: hard
-
-"pug-error@npm:^1.3.3":
-  version: 1.3.3
-  resolution: "pug-error@npm:1.3.3"
-  checksum: 10c0/b879864bbddc43c1e1a850c103b6140f928dd7b494faaa414266dbfa3a005fc65ddba5ad6ec83ee821066a66a59038cc6579dffada92aca35e52974babea7f01
-  languageName: node
-  linkType: hard
-
-"pug-runtime@npm:^2.0.5":
-  version: 2.0.5
-  resolution: "pug-runtime@npm:2.0.5"
-  checksum: 10c0/cb8d472536d1923798c95905cda187f0c9abb87fa111704974e2f7f84101b1e4bb11d1e0dfb4dc1290f3d712924f1c5a7a73a2801c5fb5c0e8e4f5dd1be620ea
-  languageName: node
-  linkType: hard
-
 "pump@npm:^3.0.0":
   version: 3.0.3
   resolution: "pump@npm:3.0.3"
@@ -12809,31 +13806,24 @@ __metadata:
   languageName: node
   linkType: hard
 
-"punycode@npm:^2.1.0, punycode@npm:^2.1.1, punycode@npm:^2.3.0":
+"punycode@npm:^2.1.0, punycode@npm:^2.3.0, punycode@npm:^2.3.1":
   version: 2.3.1
   resolution: "punycode@npm:2.3.1"
   checksum: 10c0/14f76a8206bc3464f794fb2e3d3cc665ae416c01893ad7a02b23766eb07159144ee612ad67af5e84fa4479ccfe67678c4feb126b0485651b302babf66f04f9e9
   languageName: node
   linkType: hard
 
-"pure-rand@npm:^6.0.0":
-  version: 6.1.0
-  resolution: "pure-rand@npm:6.1.0"
-  checksum: 10c0/1abe217897bf74dcb3a0c9aba3555fe975023147b48db540aa2faf507aee91c03bf54f6aef0eb2bf59cc259a16d06b28eca37f0dc426d94f4692aeff02fb0e65
+"pure-rand@npm:^7.0.0":
+  version: 7.0.1
+  resolution: "pure-rand@npm:7.0.1"
+  checksum: 10c0/9cade41030f5ec95f5d55a11a71404cd6f46b69becaad892097cd7f58e2c6248cd0a933349ca7d21336ab629f1da42ffe899699b671bc4651600eaf6e57f837e
   languageName: node
   linkType: hard
 
 "querystringify@npm:^2.1.1":
-  version: 2.2.0
-  resolution: "querystringify@npm:2.2.0"
-  checksum: 10c0/3258bc3dbdf322ff2663619afe5947c7926a6ef5fb78ad7d384602974c467fadfc8272af44f5eb8cddd0d011aae8fabf3a929a8eee4b86edcc0a21e6bd10f9aa
-  languageName: node
-  linkType: hard
-
-"queue-microtask@npm:^1.2.2":
-  version: 1.2.3
-  resolution: "queue-microtask@npm:1.2.3"
-  checksum: 10c0/900a93d3cdae3acd7d16f642c29a642aea32c2026446151f0778c62ac089d4b8e6c986811076e1ae180a694cedf077d453a11b58ff0a865629a4f82ab558e102
+  version: 2.2.0
+  resolution: "querystringify@npm:2.2.0"
+  checksum: 10c0/3258bc3dbdf322ff2663619afe5947c7926a6ef5fb78ad7d384602974c467fadfc8272af44f5eb8cddd0d011aae8fabf3a929a8eee4b86edcc0a21e6bd10f9aa
   languageName: node
   linkType: hard
 
@@ -12879,7 +13869,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"react-dom@npm:^18.0.0, react-dom@npm:^18.3.1":
+"react-dom@npm:^18.3.1":
   version: 18.3.1
   resolution: "react-dom@npm:18.3.1"
   dependencies:
@@ -12916,7 +13906,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"react-is@npm:^18.0.0, react-is@npm:^18.3.1":
+"react-is@npm:^18.3.1":
   version: 18.3.1
   resolution: "react-is@npm:18.3.1"
   checksum: 10c0/f2f1e60010c683479e74c63f96b09fb41603527cd131a9959e2aee1e5a8b0caf270b365e5ca77d4a6b18aae659b60a86150bb3979073528877029b35aecd2072
@@ -12976,7 +13966,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"react@npm:^18.0.0, react@npm:^18.3.1":
+"react@npm:^18.3.1":
   version: 18.3.1
   resolution: "react@npm:18.3.1"
   dependencies:
@@ -13092,15 +14082,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"readdirp@npm:~3.5.0":
-  version: 3.5.0
-  resolution: "readdirp@npm:3.5.0"
-  dependencies:
-    picomatch: "npm:^2.2.1"
-  checksum: 10c0/293de2ed981884a09e76fbf90bddc7e1a87667e57e0284ddc8c177e3151b0d179a9a56441d9f2f3654423924ec100af57ba9e507086527f98fd1d21bdd041c3e
-  languageName: node
-  linkType: hard
-
 "readdirp@npm:~3.6.0":
   version: 3.6.0
   resolution: "readdirp@npm:3.6.0"
@@ -13215,25 +14196,19 @@ __metadata:
   languageName: node
   linkType: hard
 
-"reflect.getprototypeof@npm:^1.0.4":
-  version: 1.0.6
-  resolution: "reflect.getprototypeof@npm:1.0.6"
+"reflect.getprototypeof@npm:^1.0.6, reflect.getprototypeof@npm:^1.0.9":
+  version: 1.0.10
+  resolution: "reflect.getprototypeof@npm:1.0.10"
   dependencies:
-    call-bind: "npm:^1.0.7"
+    call-bind: "npm:^1.0.8"
     define-properties: "npm:^1.2.1"
-    es-abstract: "npm:^1.23.1"
+    es-abstract: "npm:^1.23.9"
     es-errors: "npm:^1.3.0"
-    get-intrinsic: "npm:^1.2.4"
-    globalthis: "npm:^1.0.3"
-    which-builtin-type: "npm:^1.1.3"
-  checksum: 10c0/baf4ef8ee6ff341600f4720b251cf5a6cb552d6a6ab0fdc036988c451bf16f920e5feb0d46bd4f530a5cce568f1f7aca2d77447ca798920749cfc52783c39b55
-  languageName: node
-  linkType: hard
-
-"regenerator-runtime@npm:^0.11.0":
-  version: 0.11.1
-  resolution: "regenerator-runtime@npm:0.11.1"
-  checksum: 10c0/69cfa839efcf2d627fe358bf302ab8b24e5f182cb69f13e66f0612d3640d7838aad1e55662135e3ef2c1cc4322315b757626094fab13a48f9a64ab4bdeb8795b
+    es-object-atoms: "npm:^1.0.0"
+    get-intrinsic: "npm:^1.2.7"
+    get-proto: "npm:^1.0.1"
+    which-builtin-type: "npm:^1.2.1"
+  checksum: 10c0/7facec28c8008876f8ab98e80b7b9cb4b1e9224353fd4756dda5f2a4ab0d30fa0a5074777c6df24e1e0af463a2697513b0a11e548d99cf52f21f7bc6ba48d3ac
   languageName: node
   linkType: hard
 
@@ -13281,6 +14256,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"regexp.prototype.flags@npm:^1.5.3, regexp.prototype.flags@npm:^1.5.4":
+  version: 1.5.4
+  resolution: "regexp.prototype.flags@npm:1.5.4"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    define-properties: "npm:^1.2.1"
+    es-errors: "npm:^1.3.0"
+    get-proto: "npm:^1.0.1"
+    gopd: "npm:^1.2.0"
+    set-function-name: "npm:^2.0.2"
+  checksum: 10c0/83b88e6115b4af1c537f8dabf5c3744032cb875d63bc05c288b1b8c0ef37cbe55353f95d8ca817e8843806e3e150b118bc624e4279b24b4776b4198232735a77
+  languageName: node
+  linkType: hard
+
 "rehype-external-links@npm:^3.0.0":
   version: 3.0.0
   resolution: "rehype-external-links@npm:3.0.0"
@@ -13435,14 +14424,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"resolve.exports@npm:^2.0.0":
-  version: 2.0.2
-  resolution: "resolve.exports@npm:2.0.2"
-  checksum: 10c0/cc4cffdc25447cf34730f388dca5021156ba9302a3bad3d7f168e790dc74b2827dff603f1bc6ad3d299bac269828dca96dd77e036dc9fba6a2a1807c47ab5c98
-  languageName: node
-  linkType: hard
-
-"resolve@npm:^1.1.7, resolve@npm:^1.10.0, resolve@npm:^1.20.0, resolve@npm:^1.22.2, resolve@npm:^1.22.4":
+"resolve@npm:^1.10.0":
   version: 1.22.8
   resolution: "resolve@npm:1.22.8"
   dependencies:
@@ -13468,7 +14450,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"resolve@patch:resolve@npm%3A^1.1.7#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A^1.10.0#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A^1.20.0#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A^1.22.2#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A^1.22.4#optional!builtin<compat/resolve>":
+"resolve@patch:resolve@npm%3A^1.10.0#optional!builtin<compat/resolve>":
   version: 1.22.8
   resolution: "resolve@patch:resolve@npm%3A1.22.8#optional!builtin<compat/resolve>::version=1.22.8&hash=c3c19d"
   dependencies:
@@ -13521,13 +14503,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"reusify@npm:^1.0.4":
-  version: 1.0.4
-  resolution: "reusify@npm:1.0.4"
-  checksum: 10c0/c19ef26e4e188f408922c46f7ff480d38e8dfc55d448310dfb518736b23ed2c4f547fb64a6ed5bdba92cd7e7ddc889d36ff78f794816d5e71498d645ef476107
-  languageName: node
-  linkType: hard
-
 "rfdc@npm:^1.3.1":
   version: 1.3.1
   resolution: "rfdc@npm:1.3.1"
@@ -13557,25 +14532,93 @@ __metadata:
   languageName: node
   linkType: hard
 
+"rolldown@npm:1.0.0-rc.17":
+  version: 1.0.0-rc.17
+  resolution: "rolldown@npm:1.0.0-rc.17"
+  dependencies:
+    "@oxc-project/types": "npm:=0.127.0"
+    "@rolldown/binding-android-arm64": "npm:1.0.0-rc.17"
+    "@rolldown/binding-darwin-arm64": "npm:1.0.0-rc.17"
+    "@rolldown/binding-darwin-x64": "npm:1.0.0-rc.17"
+    "@rolldown/binding-freebsd-x64": "npm:1.0.0-rc.17"
+    "@rolldown/binding-linux-arm-gnueabihf": "npm:1.0.0-rc.17"
+    "@rolldown/binding-linux-arm64-gnu": "npm:1.0.0-rc.17"
+    "@rolldown/binding-linux-arm64-musl": "npm:1.0.0-rc.17"
+    "@rolldown/binding-linux-ppc64-gnu": "npm:1.0.0-rc.17"
+    "@rolldown/binding-linux-s390x-gnu": "npm:1.0.0-rc.17"
+    "@rolldown/binding-linux-x64-gnu": "npm:1.0.0-rc.17"
+    "@rolldown/binding-linux-x64-musl": "npm:1.0.0-rc.17"
+    "@rolldown/binding-openharmony-arm64": "npm:1.0.0-rc.17"
+    "@rolldown/binding-wasm32-wasi": "npm:1.0.0-rc.17"
+    "@rolldown/binding-win32-arm64-msvc": "npm:1.0.0-rc.17"
+    "@rolldown/binding-win32-x64-msvc": "npm:1.0.0-rc.17"
+    "@rolldown/pluginutils": "npm:1.0.0-rc.17"
+  dependenciesMeta:
+    "@rolldown/binding-android-arm64":
+      optional: true
+    "@rolldown/binding-darwin-arm64":
+      optional: true
+    "@rolldown/binding-darwin-x64":
+      optional: true
+    "@rolldown/binding-freebsd-x64":
+      optional: true
+    "@rolldown/binding-linux-arm-gnueabihf":
+      optional: true
+    "@rolldown/binding-linux-arm64-gnu":
+      optional: true
+    "@rolldown/binding-linux-arm64-musl":
+      optional: true
+    "@rolldown/binding-linux-ppc64-gnu":
+      optional: true
+    "@rolldown/binding-linux-s390x-gnu":
+      optional: true
+    "@rolldown/binding-linux-x64-gnu":
+      optional: true
+    "@rolldown/binding-linux-x64-musl":
+      optional: true
+    "@rolldown/binding-openharmony-arm64":
+      optional: true
+    "@rolldown/binding-wasm32-wasi":
+      optional: true
+    "@rolldown/binding-win32-arm64-msvc":
+      optional: true
+    "@rolldown/binding-win32-x64-msvc":
+      optional: true
+  bin:
+    rolldown: bin/cli.mjs
+  checksum: 10c0/bb99abc62ece4e34edd06d2b8eb9ffb7194dc2f0465a4329bb106cbde3006a10f1575e3580b198b793341109a2109581aed623c537c12b0c3a4ba0d72169b2fb
+  languageName: node
+  linkType: hard
+
 "root-workspace-0b6124@workspace:.":
   version: 0.0.0-use.local
   resolution: "root-workspace-0b6124@workspace:."
   dependencies:
     "@rspress/core": "npm:^2.0.0"
-    "@types/react": "npm:~18.2.45"
+    "@types/node": "npm:^25.6.0"
+    "@types/react": "npm:^18.3.28"
+    "@types/react-dom": "npm:^18.3.7"
     dotenv-cli: "npm:^11.0.0"
-    eslint: "npm:^8.56.0"
-    eslint-config-startupjs: "npm:^0.56.0-alpha.29"
+    eslint: "npm:^9.39.4"
+    eslint-plugin-react-hooks: "npm:^7.1.1"
     husky: "npm:^4.3.0"
     lerna: "npm:^9.0.3"
     lint-staged: "npm:^15.2.2"
-    react: "npm:^18.0.0"
-    react-dom: "npm:^18.0.0"
+    neostandard: "npm:^0.13.0"
+    react: "npm:^18.3.1"
+    react-dom: "npm:^18.3.1"
     ts-node: "npm:^10.9.2"
-    typescript: "npm:^5.1.3"
+    typescript: "npm:^6.0.3"
   languageName: unknown
   linkType: soft
 
+"rrweb-cssom@npm:^0.8.0":
+  version: 0.8.0
+  resolution: "rrweb-cssom@npm:0.8.0"
+  checksum: 10c0/56f2bfd56733adb92c0b56e274c43f864b8dd48784d6fe946ef5ff8d438234015e59ad837fc2ad54714b6421384141c1add4eb569e72054e350d1f8a50b8ac7b
+  languageName: node
+  linkType: hard
+
 "run-async@npm:^4.0.5":
   version: 4.0.6
   resolution: "run-async@npm:4.0.6"
@@ -13583,15 +14626,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"run-parallel@npm:^1.1.9":
-  version: 1.2.0
-  resolution: "run-parallel@npm:1.2.0"
-  dependencies:
-    queue-microtask: "npm:^1.2.2"
-  checksum: 10c0/200b5ab25b5b8b7113f9901bfe3afc347e19bb7475b267d55ad0eb86a62a46d77510cb0f232507c9e5d497ebda569a08a9867d0d14f57a82ad5564d991588b39
-  languageName: node
-  linkType: hard
-
 "rxjs@npm:^7.8.2":
   version: 7.8.2
   resolution: "rxjs@npm:7.8.2"
@@ -13613,6 +14647,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"safe-array-concat@npm:^1.1.3":
+  version: 1.1.4
+  resolution: "safe-array-concat@npm:1.1.4"
+  dependencies:
+    call-bind: "npm:^1.0.9"
+    call-bound: "npm:^1.0.4"
+    get-intrinsic: "npm:^1.3.0"
+    has-symbols: "npm:^1.1.0"
+    isarray: "npm:^2.0.5"
+  checksum: 10c0/95fb4904ab1d9360a666fe5ba6d88f1c4a3a39682739e4512cff809fc6b5722a94bd95189211015bfb45859a7ffbc3340ea303ae22721c91c59e8946d310975a
+  languageName: node
+  linkType: hard
+
 "safe-buffer@npm:>=5.1.0, safe-buffer@npm:^5.0.1, safe-buffer@npm:^5.1.0, safe-buffer@npm:~5.2.0":
   version: 5.2.1
   resolution: "safe-buffer@npm:5.2.1"
@@ -13627,6 +14674,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"safe-push-apply@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "safe-push-apply@npm:1.0.0"
+  dependencies:
+    es-errors: "npm:^1.3.0"
+    isarray: "npm:^2.0.5"
+  checksum: 10c0/831f1c9aae7436429e7862c7e46f847dfe490afac20d0ee61bae06108dbf5c745a0de3568ada30ccdd3eeb0864ca8331b2eef703abd69bfea0745b21fd320750
+  languageName: node
+  linkType: hard
+
 "safe-regex-test@npm:^1.0.3":
   version: 1.0.3
   resolution: "safe-regex-test@npm:1.0.3"
@@ -13638,6 +14695,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"safe-regex-test@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "safe-regex-test@npm:1.1.0"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    es-errors: "npm:^1.3.0"
+    is-regex: "npm:^1.2.1"
+  checksum: 10c0/f2c25281bbe5d39cddbbce7f86fca5ea9b3ce3354ea6cd7c81c31b006a5a9fff4286acc5450a3b9122c56c33eba69c56b9131ad751457b2b4a585825e6a10665
+  languageName: node
+  linkType: hard
+
 "safer-buffer@npm:>= 2.1.2 < 3.0.0":
   version: 2.1.2
   resolution: "safer-buffer@npm:2.1.2"
@@ -13721,7 +14789,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"semver@npm:^6.3.0, semver@npm:^6.3.1":
+"semver@npm:^6.3.1":
   version: 6.3.1
   resolution: "semver@npm:6.3.1"
   bin:
@@ -13748,12 +14816,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"serialize-javascript@npm:5.0.1":
-  version: 5.0.1
-  resolution: "serialize-javascript@npm:5.0.1"
-  dependencies:
-    randombytes: "npm:^2.1.0"
-  checksum: 10c0/646bd92a8298d764d38316f3006bce0b0def6d0e254791396ac34403847654d9346b0b6ed7865efd799d93d4c47d900e08a8fa7a6f7f8d2dbaebab5444c3b431
+"semver@npm:^7.7.3":
+  version: 7.7.4
+  resolution: "semver@npm:7.7.4"
+  bin:
+    semver: bin/semver.js
+  checksum: 10c0/5215ad0234e2845d4ea5bb9d836d42b03499546ddafb12075566899fc617f68794bb6f146076b6881d755de17d6c6cc73372555879ec7dce2c2feee947866ad2
   languageName: node
   linkType: hard
 
@@ -13780,7 +14848,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"set-function-length@npm:^1.2.1":
+"set-function-length@npm:^1.2.1, set-function-length@npm:^1.2.2":
   version: 1.2.2
   resolution: "set-function-length@npm:1.2.2"
   dependencies:
@@ -13806,6 +14874,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"set-proto@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "set-proto@npm:1.0.0"
+  dependencies:
+    dunder-proto: "npm:^1.0.1"
+    es-errors: "npm:^1.3.0"
+    es-object-atoms: "npm:^1.0.0"
+  checksum: 10c0/ca5c3ccbba479d07c30460e367e66337cec825560b11e8ba9c5ebe13a2a0d6021ae34eddf94ff3dfe17a3104dc1f191519cb6c48378b503e5c3f36393938776a
+  languageName: node
+  linkType: hard
+
 "sharedb-hooks@npm:~4.0.0":
   version: 4.0.0
   resolution: "sharedb-hooks@npm:4.0.0"
@@ -13906,7 +14985,42 @@ __metadata:
   languageName: node
   linkType: hard
 
-"side-channel@npm:^1.0.4, side-channel@npm:^1.0.6":
+"side-channel-list@npm:^1.0.0":
+  version: 1.0.1
+  resolution: "side-channel-list@npm:1.0.1"
+  dependencies:
+    es-errors: "npm:^1.3.0"
+    object-inspect: "npm:^1.13.4"
+  checksum: 10c0/d346c787fd2f9f1c2fdea14f00e8250118db0e7596d85a6cb9faa75f105d31a73a8f7a341c93d7df2a2429098c3d37a77bd3be9e88c37094b8c01807bc77c7a2
+  languageName: node
+  linkType: hard
+
+"side-channel-map@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "side-channel-map@npm:1.0.1"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    es-errors: "npm:^1.3.0"
+    get-intrinsic: "npm:^1.2.5"
+    object-inspect: "npm:^1.13.3"
+  checksum: 10c0/010584e6444dd8a20b85bc926d934424bd809e1a3af941cace229f7fdcb751aada0fb7164f60c2e22292b7fa3c0ff0bce237081fd4cdbc80de1dc68e95430672
+  languageName: node
+  linkType: hard
+
+"side-channel-weakmap@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "side-channel-weakmap@npm:1.0.2"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    es-errors: "npm:^1.3.0"
+    get-intrinsic: "npm:^1.2.5"
+    object-inspect: "npm:^1.13.3"
+    side-channel-map: "npm:^1.0.1"
+  checksum: 10c0/71362709ac233e08807ccd980101c3e2d7efe849edc51455030327b059f6c4d292c237f94dc0685031dd11c07dd17a68afde235d6cf2102d949567f98ab58185
+  languageName: node
+  linkType: hard
+
+"side-channel@npm:^1.0.4":
   version: 1.0.6
   resolution: "side-channel@npm:1.0.6"
   dependencies:
@@ -13918,6 +15032,26 @@ __metadata:
   languageName: node
   linkType: hard
 
+"side-channel@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "side-channel@npm:1.1.0"
+  dependencies:
+    es-errors: "npm:^1.3.0"
+    object-inspect: "npm:^1.13.3"
+    side-channel-list: "npm:^1.0.0"
+    side-channel-map: "npm:^1.0.1"
+    side-channel-weakmap: "npm:^1.0.2"
+  checksum: 10c0/cb20dad41eb032e6c24c0982e1e5a24963a28aa6122b4f05b3f3d6bf8ae7fd5474ef382c8f54a6a3ab86e0cac4d41a23bd64ede3970e5bfb50326ba02a7996e6
+  languageName: node
+  linkType: hard
+
+"siginfo@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "siginfo@npm:2.0.0"
+  checksum: 10c0/3def8f8e516fbb34cb6ae415b07ccc5d9c018d85b4b8611e3dc6f8be6d1899f693a4382913c9ed51a06babb5201639d76453ab297d1c54a456544acf5c892e34
+  languageName: node
+  linkType: hard
+
 "signal-exit@npm:3.0.7, signal-exit@npm:^3.0.2, signal-exit@npm:^3.0.3, signal-exit@npm:^3.0.7":
   version: 3.0.7
   resolution: "signal-exit@npm:3.0.7"
@@ -13964,13 +15098,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"sisteransi@npm:^1.0.5":
-  version: 1.0.5
-  resolution: "sisteransi@npm:1.0.5"
-  checksum: 10c0/230ac975cca485b7f6fe2b96a711aa62a6a26ead3e6fb8ba17c5a00d61b8bed0d7adc21f5626b70d7c33c62ff4e63933017a6462942c719d1980bb0b1207ad46
-  languageName: node
-  linkType: hard
-
 "slash@npm:3.0.0, slash@npm:^3.0.0":
   version: 3.0.0
   resolution: "slash@npm:3.0.0"
@@ -14070,6 +15197,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"source-map-js@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "source-map-js@npm:1.2.1"
+  checksum: 10c0/7bda1fc4c197e3c6ff17de1b8b2c20e60af81b63a52cb32ec5a5d67a20a7d42651e2cb34ebe93833c5a2a084377e17455854fee3e21e7925c64a51b6a52b0faf
+  languageName: node
+  linkType: hard
+
 "source-map-support@npm:0.5.13":
   version: 0.5.13
   resolution: "source-map-support@npm:0.5.13"
@@ -14080,7 +15214,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"source-map@npm:^0.6.0, source-map@npm:^0.6.1, source-map@npm:~0.6.1":
+"source-map@npm:^0.6.0, source-map@npm:^0.6.1":
   version: 0.6.1
   resolution: "source-map@npm:0.6.1"
   checksum: 10c0/ab55398007c5e5532957cb0beee2368529618ac0ab372d789806f5718123cc4367d57de3904b4e6a4170eb5a0b0f41373066d02ca0735a0c4d75c7d328d3e011
@@ -14233,7 +15367,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"stack-utils@npm:^2.0.3":
+"stack-utils@npm:^2.0.6":
   version: 2.0.6
   resolution: "stack-utils@npm:2.0.6"
   dependencies:
@@ -14242,6 +15376,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"stackback@npm:0.0.2":
+  version: 0.0.2
+  resolution: "stackback@npm:0.0.2"
+  checksum: 10c0/89a1416668f950236dd5ac9f9a6b2588e1b9b62b1b6ad8dff1bfc5d1a15dbf0aafc9b52d2226d00c28dffff212da464eaeebfc6b7578b9d180cef3e3782c5983
+  languageName: node
+  linkType: hard
+
 "stackframe@npm:^1.3.4":
   version: 1.3.4
   resolution: "stackframe@npm:1.3.4"
@@ -14256,6 +15397,23 @@ __metadata:
   languageName: node
   linkType: hard
 
+"std-env@npm:^4.0.0-rc.1":
+  version: 4.1.0
+  resolution: "std-env@npm:4.1.0"
+  checksum: 10c0/2e14b6b490db34cb969a48d9cf7c35bca4a47653914aac2814221baae7b867a5b15940d133625c391621971f98cd2266a5dc7036669960e883f1081db2a56558
+  languageName: node
+  linkType: hard
+
+"stop-iteration-iterator@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "stop-iteration-iterator@npm:1.1.0"
+  dependencies:
+    es-errors: "npm:^1.3.0"
+    internal-slot: "npm:^1.1.0"
+  checksum: 10c0/de4e45706bb4c0354a4b1122a2b8cc45a639e86206807ce0baf390ee9218d3ef181923fa4d2b67443367c491aa255c5fbaa64bb74648e3c5b48299928af86c09
+  languageName: node
+  linkType: hard
+
 "stream@npm:readable-stream@^4.7.0":
   version: 4.7.0
   resolution: "readable-stream@npm:4.7.0"
@@ -14276,7 +15434,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"string-length@npm:^4.0.1":
+"string-length@npm:^4.0.2":
   version: 4.0.2
   resolution: "string-length@npm:4.0.2"
   dependencies:
@@ -14297,16 +15455,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"string-width@npm:^1.0.2 || 2":
-  version: 2.1.1
-  resolution: "string-width@npm:2.1.1"
-  dependencies:
-    is-fullwidth-code-point: "npm:^2.0.0"
-    strip-ansi: "npm:^4.0.0"
-  checksum: 10c0/e5f2b169fcf8a4257a399f95d069522f056e92ec97dbdcb9b0cdf14d688b7ca0b1b1439a1c7b9773cd79446cbafd582727279d6bfdd9f8edd306ea5e90e5b610
-  languageName: node
-  linkType: hard
-
 "string-width@npm:^5.0.1, string-width@npm:^5.1.2":
   version: 5.1.2
   resolution: "string-width@npm:5.1.2"
@@ -14329,23 +15477,49 @@ __metadata:
   languageName: node
   linkType: hard
 
-"string.prototype.matchall@npm:^4.0.10":
-  version: 4.0.11
-  resolution: "string.prototype.matchall@npm:4.0.11"
+"string.prototype.matchall@npm:^4.0.12":
+  version: 4.0.12
+  resolution: "string.prototype.matchall@npm:4.0.12"
   dependencies:
-    call-bind: "npm:^1.0.7"
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.3"
     define-properties: "npm:^1.2.1"
-    es-abstract: "npm:^1.23.2"
+    es-abstract: "npm:^1.23.6"
     es-errors: "npm:^1.3.0"
     es-object-atoms: "npm:^1.0.0"
-    get-intrinsic: "npm:^1.2.4"
-    gopd: "npm:^1.0.1"
-    has-symbols: "npm:^1.0.3"
-    internal-slot: "npm:^1.0.7"
-    regexp.prototype.flags: "npm:^1.5.2"
+    get-intrinsic: "npm:^1.2.6"
+    gopd: "npm:^1.2.0"
+    has-symbols: "npm:^1.1.0"
+    internal-slot: "npm:^1.1.0"
+    regexp.prototype.flags: "npm:^1.5.3"
     set-function-name: "npm:^2.0.2"
-    side-channel: "npm:^1.0.6"
-  checksum: 10c0/915a2562ac9ab5e01b7be6fd8baa0b2b233a0a9aa975fcb2ec13cc26f08fb9a3e85d5abdaa533c99c6fc4c5b65b914eba3d80c4aff9792a4c9fed403f28f7d9d
+    side-channel: "npm:^1.1.0"
+  checksum: 10c0/1a53328ada73f4a77f1fdf1c79414700cf718d0a8ef6672af5603e709d26a24f2181208144aed7e858b1bcc1a0d08567a570abfb45567db4ae47637ed2c2f85c
+  languageName: node
+  linkType: hard
+
+"string.prototype.repeat@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "string.prototype.repeat@npm:1.0.0"
+  dependencies:
+    define-properties: "npm:^1.1.3"
+    es-abstract: "npm:^1.17.5"
+  checksum: 10c0/94c7978566cffa1327d470fd924366438af9b04b497c43a9805e476e2e908aa37a1fd34cc0911156c17556dab62159d12c7b92b3cc304c3e1281fe4c8e668f40
+  languageName: node
+  linkType: hard
+
+"string.prototype.trim@npm:^1.2.10":
+  version: 1.2.10
+  resolution: "string.prototype.trim@npm:1.2.10"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.2"
+    define-data-property: "npm:^1.1.4"
+    define-properties: "npm:^1.2.1"
+    es-abstract: "npm:^1.23.5"
+    es-object-atoms: "npm:^1.0.0"
+    has-property-descriptors: "npm:^1.0.2"
+  checksum: 10c0/8a8854241c4b54a948e992eb7dd6b8b3a97185112deb0037a134f5ba57541d8248dd610c966311887b6c2fd1181a3877bffb14d873ce937a344535dabcc648f8
   languageName: node
   linkType: hard
 
@@ -14372,6 +15546,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"string.prototype.trimend@npm:^1.0.9":
+  version: 1.0.9
+  resolution: "string.prototype.trimend@npm:1.0.9"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.2"
+    define-properties: "npm:^1.2.1"
+    es-object-atoms: "npm:^1.0.0"
+  checksum: 10c0/59e1a70bf9414cb4c536a6e31bef5553c8ceb0cf44d8b4d0ed65c9653358d1c64dd0ec203b100df83d0413bbcde38b8c5d49e14bc4b86737d74adc593a0d35b6
+  languageName: node
+  linkType: hard
+
 "string.prototype.trimstart@npm:^1.0.8":
   version: 1.0.8
   resolution: "string.prototype.trimstart@npm:1.0.8"
@@ -14420,15 +15606,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"strip-ansi@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "strip-ansi@npm:4.0.0"
-  dependencies:
-    ansi-regex: "npm:^3.0.0"
-  checksum: 10c0/d75d9681e0637ea316ddbd7d4d3be010b1895a17e885155e0ed6a39755ae0fd7ef46e14b22162e66a62db122d3a98ab7917794e255532ab461bb0a04feb03e7d
-  languageName: node
-  linkType: hard
-
 "strip-ansi@npm:^7.0.1, strip-ansi@npm:^7.1.0":
   version: 7.1.0
   resolution: "strip-ansi@npm:7.1.0"
@@ -14482,14 +15659,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"strip-json-comments@npm:3.1.1, strip-json-comments@npm:^3.1.1":
+"strip-json-comments@npm:^3.1.1":
   version: 3.1.1
   resolution: "strip-json-comments@npm:3.1.1"
   checksum: 10c0/9681a6257b925a7fa0f285851c0e613cc934a50661fa7bb41ca9cbbff89686bb4a0ee366e6ecedc4daafd01e83eee0720111ab294366fe7c185e935475ebcecd
   languageName: node
   linkType: hard
 
-"strip-json-comments@npm:^2.0.1, strip-json-comments@npm:~2.0.1":
+"strip-json-comments@npm:~2.0.1":
   version: 2.0.1
   resolution: "strip-json-comments@npm:2.0.1"
   checksum: 10c0/b509231cbdee45064ff4f9fd73609e2bcc4e84a4d508e9dd0f31f70356473fde18abfb5838c17d56fb236f5a06b102ef115438de0600b749e818a35fbbc48c43
@@ -14514,15 +15691,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"supports-color@npm:8.1.1, supports-color@npm:^8.0.0, supports-color@npm:^8.1.1":
-  version: 8.1.1
-  resolution: "supports-color@npm:8.1.1"
-  dependencies:
-    has-flag: "npm:^4.0.0"
-  checksum: 10c0/ea1d3c275dd604c974670f63943ed9bd83623edc102430c05adb8efc56ba492746b6e95386e7831b872ec3807fd89dd8eb43f735195f37b5ec343e4234cc7e89
-  languageName: node
-  linkType: hard
-
 "supports-color@npm:^5.3.0":
   version: 5.5.0
   resolution: "supports-color@npm:5.5.0"
@@ -14541,6 +15709,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"supports-color@npm:^8.1.1":
+  version: 8.1.1
+  resolution: "supports-color@npm:8.1.1"
+  dependencies:
+    has-flag: "npm:^4.0.0"
+  checksum: 10c0/ea1d3c275dd604c974670f63943ed9bd83623edc102430c05adb8efc56ba492746b6e95386e7831b872ec3807fd89dd8eb43f735195f37b5ec343e4234cc7e89
+  languageName: node
+  linkType: hard
+
 "supports-preserve-symlinks-flag@npm:^1.0.0":
   version: 1.0.0
   resolution: "supports-preserve-symlinks-flag@npm:1.0.0"
@@ -14555,6 +15732,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"synckit@npm:^0.11.8":
+  version: 0.11.12
+  resolution: "synckit@npm:0.11.12"
+  dependencies:
+    "@pkgr/core": "npm:^0.2.9"
+  checksum: 10c0/cc4d446806688ae0d728ae7bb3f53176d065cf9536647fb85bdd721dcefbd7bf94874df6799ff61580f2b03a392659219b778a9254ad499f9a1f56c34787c235
+  languageName: node
+  linkType: hard
+
+"tapable@npm:^2.3.3":
+  version: 2.3.3
+  resolution: "tapable@npm:2.3.3"
+  checksum: 10c0/47992e861053f861154e92fb4a98ac4ab47b6463717e60792dd1e8c755da0c4964cd8bb68c308a9066d6da89000b6310457b4d5d985c30de4ccc29066068cc17
+  languageName: node
+  linkType: hard
+
 "tar-fs@npm:^2.0.0":
   version: 2.1.4
   resolution: "tar-fs@npm:2.1.4"
@@ -14611,7 +15804,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "teamplay@workspace:packages/teamplay"
   dependencies:
-    "@jest/globals": "npm:^29.7.0"
+    "@jest/globals": "npm:^30.3.0"
     "@nx-js/observer-util": "npm:^4.1.3"
     "@startupjs/sharedb-mingo-memory": "npm:^4.0.0-2"
     "@teamplay/backend": "npm:^0.4.0-alpha.9"
@@ -14620,16 +15813,18 @@ __metadata:
     "@teamplay/debug": "npm:^0.4.0-alpha.9"
     "@teamplay/schema": "npm:^0.4.0-alpha.9"
     "@teamplay/utils": "npm:^0.4.0-alpha.9"
-    "@testing-library/react": "npm:^15.0.7"
-    c8: "npm:^10.1.3"
+    "@testing-library/dom": "npm:^10.4.1"
+    "@testing-library/react": "npm:^16.3.2"
+    babel-plugin-teamplay: "npm:^0.4.0-alpha.100"
+    c8: "npm:^11.0.0"
     diff-match-patch: "npm:^1.0.5"
     events: "npm:^3.3.0"
-    jest: "npm:^29.7.0"
-    jest-environment-jsdom: "npm:^29.7.0"
+    jest: "npm:^30.3.0"
+    jest-environment-jsdom: "npm:^30.3.0"
     json0-ot-diff: "npm:^1.1.2"
     localforage: "npm:^1.10.0"
     lodash: "npm:^4.17.20"
-    mocha: "npm:^11.0.1"
+    mocha: "npm:^11.7.5"
     pluralize: "npm:^8.0.0"
     react: "npm:^18.3.1"
     react-dom: "npm:^18.3.1"
@@ -14665,14 +15860,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"test-exclude@npm:^7.0.1":
-  version: 7.0.1
-  resolution: "test-exclude@npm:7.0.1"
+"test-exclude@npm:^8.0.0":
+  version: 8.0.0
+  resolution: "test-exclude@npm:8.0.0"
   dependencies:
     "@istanbuljs/schema": "npm:^0.1.2"
-    glob: "npm:^10.4.1"
-    minimatch: "npm:^9.0.4"
-  checksum: 10c0/6d67b9af4336a2e12b26a68c83308c7863534c65f27ed4ff7068a56f5a58f7ac703e8fc80f698a19bb154fd8f705cdf7ec347d9512b2c522c737269507e7b263
+    glob: "npm:^13.0.6"
+    minimatch: "npm:^10.2.2"
+  checksum: 10c0/f2b613cb5ddc05d1357892f5da965a6f7af42b19a6b2fc30c9b93cb74adf5059a3a9f29818adb75c96c1747b3934caac90a9058f73ce0640ea101de828a11600
   languageName: node
   linkType: hard
 
@@ -14683,13 +15878,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"text-table@npm:^0.2.0":
-  version: 0.2.0
-  resolution: "text-table@npm:0.2.0"
-  checksum: 10c0/02805740c12851ea5982686810702e2f14369a5f4c5c40a836821e3eefc65ffeec3131ba324692a37608294b0fd8c1e55a2dd571ffed4909822787668ddbee5c
-  languageName: node
-  linkType: hard
-
 "through2@npm:^2.0.0":
   version: 2.0.5
   resolution: "through2@npm:2.0.5"
@@ -14707,6 +15895,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"tinybench@npm:^2.9.0":
+  version: 2.9.0
+  resolution: "tinybench@npm:2.9.0"
+  checksum: 10c0/c3500b0f60d2eb8db65250afe750b66d51623057ee88720b7f064894a6cb7eb93360ca824a60a31ab16dab30c7b1f06efe0795b352e37914a9d4bad86386a20c
+  languageName: node
+  linkType: hard
+
+"tinyexec@npm:^1.0.2":
+  version: 1.1.1
+  resolution: "tinyexec@npm:1.1.1"
+  checksum: 10c0/48433cb32573a767e2b63bb92343cbbae4240d05a19a63f7869f9447491305e7bd82d11daccb79b2628b596ad703a25798226c50bfd1d8e63477fb42af6a5b35
+  languageName: node
+  linkType: hard
+
 "tinyglobby@npm:0.2.12":
   version: 0.2.12
   resolution: "tinyglobby@npm:0.2.12"
@@ -14727,6 +15929,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"tinyglobby@npm:^0.2.16":
+  version: 0.2.16
+  resolution: "tinyglobby@npm:0.2.16"
+  dependencies:
+    fdir: "npm:^6.5.0"
+    picomatch: "npm:^4.0.4"
+  checksum: 10c0/f2e09fd93dd95c41e522113b686ff6f7c13020962f8698a864a257f3d7737599afc47722b7ab726e12f8a813f779906187911ff8ee6701ede65072671a7e934b
+  languageName: node
+  linkType: hard
+
 "tinypool@npm:^1.1.1":
   version: 1.1.1
   resolution: "tinypool@npm:1.1.1"
@@ -14734,6 +15946,31 @@ __metadata:
   languageName: node
   linkType: hard
 
+"tinyrainbow@npm:^3.1.0":
+  version: 3.1.0
+  resolution: "tinyrainbow@npm:3.1.0"
+  checksum: 10c0/f11cf387a26c5c9255bec141a90ac511b26172981b10c3e50053bc6700ea7d2336edcc4a3a21dbb8412fe7c013477d2ba4d7e4877800f3f8107be5105aad6511
+  languageName: node
+  linkType: hard
+
+"tldts-core@npm:^6.1.86":
+  version: 6.1.86
+  resolution: "tldts-core@npm:6.1.86"
+  checksum: 10c0/8133c29375f3f99f88fce5f4d62f6ecb9532b106f31e5423b27c1eb1b6e711bd41875184a456819ceaed5c8b94f43911b1ad57e25c6eb86e1fc201228ff7e2af
+  languageName: node
+  linkType: hard
+
+"tldts@npm:^6.1.32":
+  version: 6.1.86
+  resolution: "tldts@npm:6.1.86"
+  dependencies:
+    tldts-core: "npm:^6.1.86"
+  bin:
+    tldts: bin/cli.js
+  checksum: 10c0/27ae7526d9d78cb97b2de3f4d102e0b4321d1ccff0648a7bb0e039ed54acbce86bacdcd9cd3c14310e519b457854e7bafbef1f529f58a1e217a737ced63f0940
+  languageName: node
+  linkType: hard
+
 "tmp@npm:^0.0.33":
   version: 0.0.33
   resolution: "tmp@npm:0.0.33"
@@ -14757,13 +15994,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"to-fast-properties@npm:^1.0.3":
-  version: 1.0.3
-  resolution: "to-fast-properties@npm:1.0.3"
-  checksum: 10c0/78974a4f4528700d18e4c2bbf0b1fb1b19862dcc20a18dc5ed659843dea2dff4f933d167a11d3819865c1191042003aea65f7f035791af9e65d070f2e05af787
-  languageName: node
-  linkType: hard
-
 "to-fast-properties@npm:^2.0.0":
   version: 2.0.0
   resolution: "to-fast-properties@npm:2.0.0"
@@ -14787,33 +16017,30 @@ __metadata:
   languageName: node
   linkType: hard
 
-"tough-cookie@npm:^4.1.2":
-  version: 4.1.4
-  resolution: "tough-cookie@npm:4.1.4"
+"tough-cookie@npm:^5.1.1":
+  version: 5.1.2
+  resolution: "tough-cookie@npm:5.1.2"
   dependencies:
-    psl: "npm:^1.1.33"
-    punycode: "npm:^2.1.1"
-    universalify: "npm:^0.2.0"
-    url-parse: "npm:^1.5.3"
-  checksum: 10c0/aca7ff96054f367d53d1e813e62ceb7dd2eda25d7752058a74d64b7266fd07be75908f3753a32ccf866a2f997604b414cfb1916d6e7f69bc64d9d9939b0d6c45
+    tldts: "npm:^6.1.32"
+  checksum: 10c0/5f95023a47de0f30a902bba951664b359725597d8adeabc66a0b93a931c3af801e1e697dae4b8c21a012056c0ea88bd2bf4dfe66b2adcf8e2f42cd9796fe0626
   languageName: node
   linkType: hard
 
-"tr46@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "tr46@npm:3.0.0"
+"tr46@npm:^4.1.1":
+  version: 4.1.1
+  resolution: "tr46@npm:4.1.1"
   dependencies:
-    punycode: "npm:^2.1.1"
-  checksum: 10c0/cdc47cad3a9d0b6cb293e39ccb1066695ae6fdd39b9e4f351b010835a1f8b4f3a6dc3a55e896b421371187f22b48d7dac1b693de4f6551bdef7b6ab6735dfe3b
+    punycode: "npm:^2.3.0"
+  checksum: 10c0/92085dcf186f56a49ba4124a581d9ae6a5d0cd4878107c34e2e670b9ddc49da85e4950084bb3e75015195cc23f37ae1c02d45064e94dd6018f5e789aa51d93a8
   languageName: node
   linkType: hard
 
-"tr46@npm:^4.1.1":
-  version: 4.1.1
-  resolution: "tr46@npm:4.1.1"
+"tr46@npm:^5.1.0":
+  version: 5.1.1
+  resolution: "tr46@npm:5.1.1"
   dependencies:
-    punycode: "npm:^2.3.0"
-  checksum: 10c0/92085dcf186f56a49ba4124a581d9ae6a5d0cd4878107c34e2e670b9ddc49da85e4950084bb3e75015195cc23f37ae1c02d45064e94dd6018f5e789aa51d93a8
+    punycode: "npm:^2.3.1"
+  checksum: 10c0/ae270e194d52ec67ebd695c1a42876e0f19b96e4aca2ab464ab1d9d17dc3acd3e18764f5034c93897db73421563be27c70c98359c4501136a497e46deda5d5ec
   languageName: node
   linkType: hard
 
@@ -14854,12 +16081,23 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ts-api-utils@npm:^1.0.1":
-  version: 1.3.0
-  resolution: "ts-api-utils@npm:1.3.0"
+"ts-api-utils@npm:^2.5.0":
+  version: 2.5.0
+  resolution: "ts-api-utils@npm:2.5.0"
+  peerDependencies:
+    typescript: ">=4.8.4"
+  checksum: 10c0/767849383c114e7f1971fa976b20e73ac28fd0c70d8d65c0004790bf4d8f89888c7e4cf6d5949f9c1beae9bc3c64835bef77bbe27fddf45a3c7b60cebcf85c8c
+  languageName: node
+  linkType: hard
+
+"ts-declaration-location@npm:^1.0.6":
+  version: 1.0.7
+  resolution: "ts-declaration-location@npm:1.0.7"
+  dependencies:
+    picomatch: "npm:^4.0.2"
   peerDependencies:
-    typescript: ">=4.2.0"
-  checksum: 10c0/f54a0ba9ed56ce66baea90a3fa087a484002e807f28a8ccb2d070c75e76bde64bd0f6dce98b3802834156306050871b67eec325cb4e918015a360a3f0868c77c
+    typescript: ">=4.0.0"
+  checksum: 10c0/b579b7630907052cc174b051dffdb169424824d887d8fb5abdc61e7ab0eede348c2b71c998727b9e4b314c0436f5003a15bb7eedb1c851afe96e12499f159630
   languageName: node
   linkType: hard
 
@@ -14901,18 +16139,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"tsconfig-paths@npm:^3.15.0":
-  version: 3.15.0
-  resolution: "tsconfig-paths@npm:3.15.0"
-  dependencies:
-    "@types/json5": "npm:^0.0.29"
-    json5: "npm:^1.0.2"
-    minimist: "npm:^1.2.6"
-    strip-bom: "npm:^3.0.0"
-  checksum: 10c0/5b4f301a2b7a3766a986baf8fc0e177eb80bdba6e396792ff92dc23b5bca8bb279fc96517dcaaef63a3b49bebc6c4c833653ec58155780bc906bdbcf7dda0ef5
-  languageName: node
-  linkType: hard
-
 "tsconfig-paths@npm:^4.1.2":
   version: 4.2.0
   resolution: "tsconfig-paths@npm:4.2.0"
@@ -14981,13 +16207,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"type-fest@npm:^0.20.2":
-  version: 0.20.2
-  resolution: "type-fest@npm:0.20.2"
-  checksum: 10c0/dea9df45ea1f0aaa4e2d3bed3f9a0bfe9e5b2592bddb92eb1bf06e50bcf98dbb78189668cd8bc31a0511d3fc25539b4cd5c704497e53e93e2d40ca764b10bfc3
-  languageName: node
-  linkType: hard
-
 "type-fest@npm:^0.21.3":
   version: 0.21.3
   resolution: "type-fest@npm:0.21.3"
@@ -15027,6 +16246,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"typed-array-buffer@npm:^1.0.3":
+  version: 1.0.3
+  resolution: "typed-array-buffer@npm:1.0.3"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    es-errors: "npm:^1.3.0"
+    is-typed-array: "npm:^1.1.14"
+  checksum: 10c0/1105071756eb248774bc71646bfe45b682efcad93b55532c6ffa4518969fb6241354e4aa62af679ae83899ec296d69ef88f1f3763657cdb3a4d29321f7b83079
+  languageName: node
+  linkType: hard
+
 "typed-array-byte-length@npm:^1.0.1":
   version: 1.0.1
   resolution: "typed-array-byte-length@npm:1.0.1"
@@ -15040,6 +16270,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"typed-array-byte-length@npm:^1.0.3":
+  version: 1.0.3
+  resolution: "typed-array-byte-length@npm:1.0.3"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    for-each: "npm:^0.3.3"
+    gopd: "npm:^1.2.0"
+    has-proto: "npm:^1.2.0"
+    is-typed-array: "npm:^1.1.14"
+  checksum: 10c0/6ae083c6f0354f1fce18b90b243343b9982affd8d839c57bbd2c174a5d5dc71be9eb7019ffd12628a96a4815e7afa85d718d6f1e758615151d5f35df841ffb3e
+  languageName: node
+  linkType: hard
+
 "typed-array-byte-offset@npm:^1.0.2":
   version: 1.0.2
   resolution: "typed-array-byte-offset@npm:1.0.2"
@@ -15054,6 +16297,21 @@ __metadata:
   languageName: node
   linkType: hard
 
+"typed-array-byte-offset@npm:^1.0.4":
+  version: 1.0.4
+  resolution: "typed-array-byte-offset@npm:1.0.4"
+  dependencies:
+    available-typed-arrays: "npm:^1.0.7"
+    call-bind: "npm:^1.0.8"
+    for-each: "npm:^0.3.3"
+    gopd: "npm:^1.2.0"
+    has-proto: "npm:^1.2.0"
+    is-typed-array: "npm:^1.1.15"
+    reflect.getprototypeof: "npm:^1.0.9"
+  checksum: 10c0/3d805b050c0c33b51719ee52de17c1cd8e6a571abdf0fffb110e45e8dd87a657e8b56eee94b776b13006d3d347a0c18a730b903cf05293ab6d92e99ff8f77e53
+  languageName: node
+  linkType: hard
+
 "typed-array-length@npm:^1.0.6":
   version: 1.0.6
   resolution: "typed-array-length@npm:1.0.6"
@@ -15068,6 +16326,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"typed-array-length@npm:^1.0.7":
+  version: 1.0.7
+  resolution: "typed-array-length@npm:1.0.7"
+  dependencies:
+    call-bind: "npm:^1.0.7"
+    for-each: "npm:^0.3.3"
+    gopd: "npm:^1.0.1"
+    is-typed-array: "npm:^1.1.13"
+    possible-typed-array-names: "npm:^1.0.0"
+    reflect.getprototypeof: "npm:^1.0.6"
+  checksum: 10c0/e38f2ae3779584c138a2d8adfa8ecf749f494af3cd3cdafe4e688ce51418c7d2c5c88df1bd6be2bbea099c3f7cea58c02ca02ed438119e91f162a9de23f61295
+  languageName: node
+  linkType: hard
+
 "typedarray@npm:^0.0.6":
   version: 0.0.6
   resolution: "typedarray@npm:0.0.6"
@@ -15075,7 +16347,22 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@npm:>=3 < 6, typescript@npm:^5.1.3":
+"typescript-eslint@npm:^8.56.0":
+  version: 8.59.0
+  resolution: "typescript-eslint@npm:8.59.0"
+  dependencies:
+    "@typescript-eslint/eslint-plugin": "npm:8.59.0"
+    "@typescript-eslint/parser": "npm:8.59.0"
+    "@typescript-eslint/typescript-estree": "npm:8.59.0"
+    "@typescript-eslint/utils": "npm:8.59.0"
+  peerDependencies:
+    eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+    typescript: ">=4.8.4 <6.1.0"
+  checksum: 10c0/b14b4bf6878e9745d92c0bc2b3c68ea29e8e524037a10e05873ad58b0dd1961313c05f406273b99c4128fd49bde2d9b3233bcec636896e9a70ed8167a3d0a9c5
+  languageName: node
+  linkType: hard
+
+"typescript@npm:>=3 < 6":
   version: 5.4.5
   resolution: "typescript@npm:5.4.5"
   bin:
@@ -15085,7 +16372,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@patch:typescript@npm%3A>=3 < 6#optional!builtin<compat/typescript>, typescript@patch:typescript@npm%3A^5.1.3#optional!builtin<compat/typescript>":
+"typescript@npm:^6.0.3":
+  version: 6.0.3
+  resolution: "typescript@npm:6.0.3"
+  bin:
+    tsc: bin/tsc
+    tsserver: bin/tsserver
+  checksum: 10c0/4a25ff5045b984370f48f196b3a0120779b1b343d40b9a68d114ea5e5fff099809b2bb777576991a63a5cd59cf7bffd96ff6fe10afcefbcb8bd6fb96ad4b6606
+  languageName: node
+  linkType: hard
+
+"typescript@patch:typescript@npm%3A>=3 < 6#optional!builtin<compat/typescript>":
   version: 5.4.5
   resolution: "typescript@patch:typescript@npm%3A5.4.5#optional!builtin<compat/typescript>::version=5.4.5&hash=5adc0c"
   bin:
@@ -15095,6 +16392,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"typescript@patch:typescript@npm%3A^6.0.3#optional!builtin<compat/typescript>":
+  version: 6.0.3
+  resolution: "typescript@patch:typescript@npm%3A6.0.3#optional!builtin<compat/typescript>::version=6.0.3&hash=5786d5"
+  bin:
+    tsc: bin/tsc
+    tsserver: bin/tsserver
+  checksum: 10c0/2f25c74e65663c248fa1ade2b8459d9ce5372ff9dad07067310f132966ebec1d93f6c42f0baf77a6b6a7a91460463f708e6887013aaade22111037457c6b25df
+  languageName: node
+  linkType: hard
+
 "uglify-js@npm:^3.1.4":
   version: 3.17.4
   resolution: "uglify-js@npm:3.17.4"
@@ -15123,6 +16430,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"unbox-primitive@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "unbox-primitive@npm:1.1.0"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    has-bigints: "npm:^1.0.2"
+    has-symbols: "npm:^1.1.0"
+    which-boxed-primitive: "npm:^1.1.1"
+  checksum: 10c0/7dbd35ab02b0e05fe07136c72cb9355091242455473ec15057c11430129bab38b7b3624019b8778d02a881c13de44d63cd02d122ee782fb519e1de7775b5b982
+  languageName: node
+  linkType: hard
+
 "undici-types@npm:~5.26.4":
   version: 5.26.5
   resolution: "undici-types@npm:5.26.5"
@@ -15130,6 +16449,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"undici-types@npm:~7.19.0":
+  version: 7.19.2
+  resolution: "undici-types@npm:7.19.2"
+  checksum: 10c0/7159f10546f9f6c47d36776bb1bbf8671e87c1e587a6fee84ae1f111ae8de4f914efa8ca0dfcd224f4f4a9dfc3f6028f627ccb5ddaccf82d7fd54671b89fac3e
+  languageName: node
+  linkType: hard
+
 "unhead@npm:2.1.2":
   version: 2.1.2
   resolution: "unhead@npm:2.1.2"
@@ -15139,6 +16465,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"unicorn-magic@npm:^0.3.0":
+  version: 0.3.0
+  resolution: "unicorn-magic@npm:0.3.0"
+  checksum: 10c0/0a32a997d6c15f1c2a077a15b1c4ca6f268d574cf5b8975e778bb98e6f8db4ef4e86dfcae4e158cd4c7e38fb4dd383b93b13eefddc7f178dea13d3ac8a603271
+  languageName: node
+  linkType: hard
+
 "unified@npm:^11.0.0, unified@npm:^11.0.5":
   version: 11.0.5
   resolution: "unified@npm:11.0.5"
@@ -15310,13 +16643,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"universalify@npm:^0.2.0":
-  version: 0.2.0
-  resolution: "universalify@npm:0.2.0"
-  checksum: 10c0/cedbe4d4ca3967edf24c0800cfc161c5a15e240dac28e3ce575c689abc11f2c81ccc6532c8752af3b40f9120fb5e454abecd359e164f4f6aa44c29cd37e194fe
-  languageName: node
-  linkType: hard
-
 "universalify@npm:^2.0.0":
   version: 2.0.1
   resolution: "universalify@npm:2.0.1"
@@ -15324,6 +16650,73 @@ __metadata:
   languageName: node
   linkType: hard
 
+"unrs-resolver@npm:^1.7.11":
+  version: 1.11.1
+  resolution: "unrs-resolver@npm:1.11.1"
+  dependencies:
+    "@unrs/resolver-binding-android-arm-eabi": "npm:1.11.1"
+    "@unrs/resolver-binding-android-arm64": "npm:1.11.1"
+    "@unrs/resolver-binding-darwin-arm64": "npm:1.11.1"
+    "@unrs/resolver-binding-darwin-x64": "npm:1.11.1"
+    "@unrs/resolver-binding-freebsd-x64": "npm:1.11.1"
+    "@unrs/resolver-binding-linux-arm-gnueabihf": "npm:1.11.1"
+    "@unrs/resolver-binding-linux-arm-musleabihf": "npm:1.11.1"
+    "@unrs/resolver-binding-linux-arm64-gnu": "npm:1.11.1"
+    "@unrs/resolver-binding-linux-arm64-musl": "npm:1.11.1"
+    "@unrs/resolver-binding-linux-ppc64-gnu": "npm:1.11.1"
+    "@unrs/resolver-binding-linux-riscv64-gnu": "npm:1.11.1"
+    "@unrs/resolver-binding-linux-riscv64-musl": "npm:1.11.1"
+    "@unrs/resolver-binding-linux-s390x-gnu": "npm:1.11.1"
+    "@unrs/resolver-binding-linux-x64-gnu": "npm:1.11.1"
+    "@unrs/resolver-binding-linux-x64-musl": "npm:1.11.1"
+    "@unrs/resolver-binding-wasm32-wasi": "npm:1.11.1"
+    "@unrs/resolver-binding-win32-arm64-msvc": "npm:1.11.1"
+    "@unrs/resolver-binding-win32-ia32-msvc": "npm:1.11.1"
+    "@unrs/resolver-binding-win32-x64-msvc": "npm:1.11.1"
+    napi-postinstall: "npm:^0.3.0"
+  dependenciesMeta:
+    "@unrs/resolver-binding-android-arm-eabi":
+      optional: true
+    "@unrs/resolver-binding-android-arm64":
+      optional: true
+    "@unrs/resolver-binding-darwin-arm64":
+      optional: true
+    "@unrs/resolver-binding-darwin-x64":
+      optional: true
+    "@unrs/resolver-binding-freebsd-x64":
+      optional: true
+    "@unrs/resolver-binding-linux-arm-gnueabihf":
+      optional: true
+    "@unrs/resolver-binding-linux-arm-musleabihf":
+      optional: true
+    "@unrs/resolver-binding-linux-arm64-gnu":
+      optional: true
+    "@unrs/resolver-binding-linux-arm64-musl":
+      optional: true
+    "@unrs/resolver-binding-linux-ppc64-gnu":
+      optional: true
+    "@unrs/resolver-binding-linux-riscv64-gnu":
+      optional: true
+    "@unrs/resolver-binding-linux-riscv64-musl":
+      optional: true
+    "@unrs/resolver-binding-linux-s390x-gnu":
+      optional: true
+    "@unrs/resolver-binding-linux-x64-gnu":
+      optional: true
+    "@unrs/resolver-binding-linux-x64-musl":
+      optional: true
+    "@unrs/resolver-binding-wasm32-wasi":
+      optional: true
+    "@unrs/resolver-binding-win32-arm64-msvc":
+      optional: true
+    "@unrs/resolver-binding-win32-ia32-msvc":
+      optional: true
+    "@unrs/resolver-binding-win32-x64-msvc":
+      optional: true
+  checksum: 10c0/c91b112c71a33d6b24e5c708dab43ab80911f2df8ee65b87cd7a18fb5af446708e98c4b415ca262026ad8df326debcc7ca6a801b2935504d87fd6f0b9d70dce1
+  languageName: node
+  linkType: hard
+
 "upath@npm:2.0.1":
   version: 2.0.1
   resolution: "upath@npm:2.0.1"
@@ -15345,6 +16738,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"update-browserslist-db@npm:^1.2.3":
+  version: 1.2.3
+  resolution: "update-browserslist-db@npm:1.2.3"
+  dependencies:
+    escalade: "npm:^3.2.0"
+    picocolors: "npm:^1.1.1"
+  peerDependencies:
+    browserslist: ">= 4.21.0"
+  bin:
+    update-browserslist-db: cli.js
+  checksum: 10c0/13a00355ea822388f68af57410ce3255941d5fb9b7c49342c4709a07c9f230bbef7f7499ae0ca7e0de532e79a82cc0c4edbd125f1a323a1845bf914efddf8bec
+  languageName: node
+  linkType: hard
+
 "uri-js@npm:^4.2.2, uri-js@npm:^4.4.1":
   version: 4.4.1
   resolution: "uri-js@npm:4.4.1"
@@ -15354,7 +16761,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"url-parse@npm:^1.5.10, url-parse@npm:^1.5.3":
+"url-parse@npm:^1.5.10":
   version: 1.5.10
   resolution: "url-parse@npm:1.5.10"
   dependencies:
@@ -15495,19 +16902,137 @@ __metadata:
   languageName: node
   linkType: hard
 
-"void-elements@npm:^2.0.1":
-  version: 2.0.1
-  resolution: "void-elements@npm:2.0.1"
-  checksum: 10c0/23b4f35bbeabcaa5c87a9f638ae80862a9313dccbaa8973b0eada81dbe97488ae11baf4d8aa2846bc397d31456afdfd8d791bb44c542f83735e6d04af6996f4d
+"vite@npm:^6.0.0 || ^7.0.0 || ^8.0.0":
+  version: 8.0.10
+  resolution: "vite@npm:8.0.10"
+  dependencies:
+    fsevents: "npm:~2.3.3"
+    lightningcss: "npm:^1.32.0"
+    picomatch: "npm:^4.0.4"
+    postcss: "npm:^8.5.10"
+    rolldown: "npm:1.0.0-rc.17"
+    tinyglobby: "npm:^0.2.16"
+  peerDependencies:
+    "@types/node": ^20.19.0 || >=22.12.0
+    "@vitejs/devtools": ^0.1.0
+    esbuild: ^0.27.0 || ^0.28.0
+    jiti: ">=1.21.0"
+    less: ^4.0.0
+    sass: ^1.70.0
+    sass-embedded: ^1.70.0
+    stylus: ">=0.54.8"
+    sugarss: ^5.0.0
+    terser: ^5.16.0
+    tsx: ^4.8.1
+    yaml: ^2.4.2
+  dependenciesMeta:
+    fsevents:
+      optional: true
+  peerDependenciesMeta:
+    "@types/node":
+      optional: true
+    "@vitejs/devtools":
+      optional: true
+    esbuild:
+      optional: true
+    jiti:
+      optional: true
+    less:
+      optional: true
+    sass:
+      optional: true
+    sass-embedded:
+      optional: true
+    stylus:
+      optional: true
+    sugarss:
+      optional: true
+    terser:
+      optional: true
+    tsx:
+      optional: true
+    yaml:
+      optional: true
+  bin:
+    vite: bin/vite.js
+  checksum: 10c0/92188b82654f856dbe562a1b679de695bb6ca18c0f43c4c276f84a869fb78e22dedb7c2df83b5617d6afdca979c059d654b5f61a0936a45f49917f352b9325ca
   languageName: node
   linkType: hard
 
-"w3c-xmlserializer@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "w3c-xmlserializer@npm:4.0.0"
+"vitest@npm:^4.1.5":
+  version: 4.1.5
+  resolution: "vitest@npm:4.1.5"
+  dependencies:
+    "@vitest/expect": "npm:4.1.5"
+    "@vitest/mocker": "npm:4.1.5"
+    "@vitest/pretty-format": "npm:4.1.5"
+    "@vitest/runner": "npm:4.1.5"
+    "@vitest/snapshot": "npm:4.1.5"
+    "@vitest/spy": "npm:4.1.5"
+    "@vitest/utils": "npm:4.1.5"
+    es-module-lexer: "npm:^2.0.0"
+    expect-type: "npm:^1.3.0"
+    magic-string: "npm:^0.30.21"
+    obug: "npm:^2.1.1"
+    pathe: "npm:^2.0.3"
+    picomatch: "npm:^4.0.3"
+    std-env: "npm:^4.0.0-rc.1"
+    tinybench: "npm:^2.9.0"
+    tinyexec: "npm:^1.0.2"
+    tinyglobby: "npm:^0.2.15"
+    tinyrainbow: "npm:^3.1.0"
+    vite: "npm:^6.0.0 || ^7.0.0 || ^8.0.0"
+    why-is-node-running: "npm:^2.3.0"
+  peerDependencies:
+    "@edge-runtime/vm": "*"
+    "@opentelemetry/api": ^1.9.0
+    "@types/node": ^20.0.0 || ^22.0.0 || >=24.0.0
+    "@vitest/browser-playwright": 4.1.5
+    "@vitest/browser-preview": 4.1.5
+    "@vitest/browser-webdriverio": 4.1.5
+    "@vitest/coverage-istanbul": 4.1.5
+    "@vitest/coverage-v8": 4.1.5
+    "@vitest/ui": 4.1.5
+    happy-dom: "*"
+    jsdom: "*"
+    vite: ^6.0.0 || ^7.0.0 || ^8.0.0
+  peerDependenciesMeta:
+    "@edge-runtime/vm":
+      optional: true
+    "@opentelemetry/api":
+      optional: true
+    "@types/node":
+      optional: true
+    "@vitest/browser-playwright":
+      optional: true
+    "@vitest/browser-preview":
+      optional: true
+    "@vitest/browser-webdriverio":
+      optional: true
+    "@vitest/coverage-istanbul":
+      optional: true
+    "@vitest/coverage-v8":
+      optional: true
+    "@vitest/ui":
+      optional: true
+    happy-dom:
+      optional: true
+    jsdom:
+      optional: true
+    vite:
+      optional: false
+  bin:
+    vitest: vitest.mjs
+  checksum: 10c0/196eaf5e95b45a3f6d3001a2408d7dc6f146c29c873ed4e42e1ad4c9327122934fb3793a12b6ce3b7c25d355e738b20123acc0894ce30358c3370b15f4bd0865
+  languageName: node
+  linkType: hard
+
+"w3c-xmlserializer@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "w3c-xmlserializer@npm:5.0.0"
   dependencies:
-    xml-name-validator: "npm:^4.0.0"
-  checksum: 10c0/02cc66d6efc590bd630086cd88252444120f5feec5c4043932b0d0f74f8b060512f79dc77eb093a7ad04b4f02f39da79ce4af47ceb600f2bf9eacdc83204b1a8
+    xml-name-validator: "npm:^5.0.0"
+  checksum: 10c0/8712774c1aeb62dec22928bf1cdfd11426c2c9383a1a63f2bcae18db87ca574165a0fbe96b312b73652149167ac6c7f4cf5409f2eb101d9c805efe0e4bae798b
   languageName: node
   linkType: hard
 
@@ -15568,29 +17093,19 @@ __metadata:
   languageName: node
   linkType: hard
 
-"whatwg-encoding@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "whatwg-encoding@npm:2.0.0"
+"whatwg-encoding@npm:^3.1.1":
+  version: 3.1.1
+  resolution: "whatwg-encoding@npm:3.1.1"
   dependencies:
     iconv-lite: "npm:0.6.3"
-  checksum: 10c0/91b90a49f312dc751496fd23a7e68981e62f33afe938b97281ad766235c4872fc4e66319f925c5e9001502b3040dd25a33b02a9c693b73a4cbbfdc4ad10c3e3e
-  languageName: node
-  linkType: hard
-
-"whatwg-mimetype@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "whatwg-mimetype@npm:3.0.0"
-  checksum: 10c0/323895a1cda29a5fb0b9ca82831d2c316309fede0365047c4c323073e3239067a304a09a1f4b123b9532641ab604203f33a1403b5ca6a62ef405bcd7a204080f
+  checksum: 10c0/273b5f441c2f7fda3368a496c3009edbaa5e43b71b09728f90425e7f487e5cef9eb2b846a31bd760dd8077739c26faf6b5ca43a5f24033172b003b72cf61a93e
   languageName: node
   linkType: hard
 
-"whatwg-url@npm:^11.0.0":
-  version: 11.0.0
-  resolution: "whatwg-url@npm:11.0.0"
-  dependencies:
-    tr46: "npm:^3.0.0"
-    webidl-conversions: "npm:^7.0.0"
-  checksum: 10c0/f7ec264976d7c725e0696fcaf9ebe056e14422eacbf92fdbb4462034609cba7d0c85ffa1aab05e9309d42969bcf04632ba5ed3f3882c516d7b093053315bf4c1
+"whatwg-mimetype@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "whatwg-mimetype@npm:4.0.0"
+  checksum: 10c0/a773cdc8126b514d790bdae7052e8bf242970cebd84af62fb2f35a33411e78e981f6c0ab9ed1fe6ec5071b09d5340ac9178e05b52d35a9c4bcf558ba1b1551df
   languageName: node
   linkType: hard
 
@@ -15604,6 +17119,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"whatwg-url@npm:^14.0.0, whatwg-url@npm:^14.1.1":
+  version: 14.2.0
+  resolution: "whatwg-url@npm:14.2.0"
+  dependencies:
+    tr46: "npm:^5.1.0"
+    webidl-conversions: "npm:^7.0.0"
+  checksum: 10c0/f746fc2f4c906607d09537de1227b13f9494c171141e5427ed7d2c0dd0b6a48b43d8e71abaae57d368d0c06b673fd8ec63550b32ad5ed64990c7b0266c2b4272
+  languageName: node
+  linkType: hard
+
 "which-boxed-primitive@npm:^1.0.2":
   version: 1.0.2
   resolution: "which-boxed-primitive@npm:1.0.2"
@@ -15617,27 +17142,41 @@ __metadata:
   languageName: node
   linkType: hard
 
-"which-builtin-type@npm:^1.1.3":
-  version: 1.1.3
-  resolution: "which-builtin-type@npm:1.1.3"
+"which-boxed-primitive@npm:^1.1.0, which-boxed-primitive@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "which-boxed-primitive@npm:1.1.1"
   dependencies:
-    function.prototype.name: "npm:^1.1.5"
-    has-tostringtag: "npm:^1.0.0"
+    is-bigint: "npm:^1.1.0"
+    is-boolean-object: "npm:^1.2.1"
+    is-number-object: "npm:^1.1.1"
+    is-string: "npm:^1.1.1"
+    is-symbol: "npm:^1.1.1"
+  checksum: 10c0/aceea8ede3b08dede7dce168f3883323f7c62272b49801716e8332ff750e7ae59a511ae088840bc6874f16c1b7fd296c05c949b0e5b357bfe3c431b98c417abe
+  languageName: node
+  linkType: hard
+
+"which-builtin-type@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "which-builtin-type@npm:1.2.1"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    function.prototype.name: "npm:^1.1.6"
+    has-tostringtag: "npm:^1.0.2"
     is-async-function: "npm:^2.0.0"
-    is-date-object: "npm:^1.0.5"
-    is-finalizationregistry: "npm:^1.0.2"
+    is-date-object: "npm:^1.1.0"
+    is-finalizationregistry: "npm:^1.1.0"
     is-generator-function: "npm:^1.0.10"
-    is-regex: "npm:^1.1.4"
+    is-regex: "npm:^1.2.1"
     is-weakref: "npm:^1.0.2"
     isarray: "npm:^2.0.5"
-    which-boxed-primitive: "npm:^1.0.2"
-    which-collection: "npm:^1.0.1"
-    which-typed-array: "npm:^1.1.9"
-  checksum: 10c0/2b7b234df3443b52f4fbd2b65b731804de8d30bcc4210ec84107ef377a81923cea7f2763b7fb78b394175cea59118bf3c41b9ffd2d643cb1d748ef93b33b6bd4
+    which-boxed-primitive: "npm:^1.1.0"
+    which-collection: "npm:^1.0.2"
+    which-typed-array: "npm:^1.1.16"
+  checksum: 10c0/8dcf323c45e5c27887800df42fbe0431d0b66b1163849bb7d46b5a730ad6a96ee8bfe827d078303f825537844ebf20c02459de41239a0a9805e2fcb3cae0d471
   languageName: node
   linkType: hard
 
-"which-collection@npm:^1.0.1":
+"which-collection@npm:^1.0.2":
   version: 1.0.2
   resolution: "which-collection@npm:1.0.2"
   dependencies:
@@ -15656,7 +17195,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"which-typed-array@npm:^1.1.14, which-typed-array@npm:^1.1.15, which-typed-array@npm:^1.1.9":
+"which-typed-array@npm:^1.1.14, which-typed-array@npm:^1.1.15":
   version: 1.1.15
   resolution: "which-typed-array@npm:1.1.15"
   dependencies:
@@ -15669,7 +17208,22 @@ __metadata:
   languageName: node
   linkType: hard
 
-"which@npm:2.0.2, which@npm:^2.0.1, which@npm:^2.0.2":
+"which-typed-array@npm:^1.1.16, which-typed-array@npm:^1.1.19":
+  version: 1.1.20
+  resolution: "which-typed-array@npm:1.1.20"
+  dependencies:
+    available-typed-arrays: "npm:^1.0.7"
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.4"
+    for-each: "npm:^0.3.5"
+    get-proto: "npm:^1.0.1"
+    gopd: "npm:^1.2.0"
+    has-tostringtag: "npm:^1.0.2"
+  checksum: 10c0/16fcdada95c8afb821cd1117f0ab50b4d8551677ac08187f21d4e444530913c9ffd2dac634f0c1183345f96344b69280f40f9a8bc52164ef409e555567c2604b
+  languageName: node
+  linkType: hard
+
+"which@npm:^2.0.1, which@npm:^2.0.2":
   version: 2.0.2
   resolution: "which@npm:2.0.2"
   dependencies:
@@ -15713,12 +17267,15 @@ __metadata:
   languageName: node
   linkType: hard
 
-"wide-align@npm:1.1.3":
-  version: 1.1.3
-  resolution: "wide-align@npm:1.1.3"
+"why-is-node-running@npm:^2.3.0":
+  version: 2.3.0
+  resolution: "why-is-node-running@npm:2.3.0"
   dependencies:
-    string-width: "npm:^1.0.2 || 2"
-  checksum: 10c0/9bf69ad55f7bcccd5a7af2ebbb8115aebf1b17e6d4f0a2a40a84f5676e099153b9adeab331e306661bf2a8419361bacba83057a62163947507473ce7ac4116b7
+    siginfo: "npm:^2.0.0"
+    stackback: "npm:0.0.2"
+  bin:
+    why-is-node-running: cli.js
+  checksum: 10c0/1cde0b01b827d2cf4cb11db962f3958b9175d5d9e7ac7361d1a7b0e2dc6069a263e69118bd974c4f6d0a890ef4eedfe34cf3d5167ec14203dbc9a18620537054
   languageName: node
   linkType: hard
 
@@ -15745,13 +17302,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"workerpool@npm:6.1.0":
-  version: 6.1.0
-  resolution: "workerpool@npm:6.1.0"
-  checksum: 10c0/b3bf34014f4323e8fbe0d2a9aaabb047c444de757c781668480098a1e89efb1a1e9624df0046b5f18ef0db3d02d1f0341a462655c5b28dafc0e826c5d6a9d356
-  languageName: node
-  linkType: hard
-
 "workerpool@npm:^9.2.0":
   version: 9.3.4
   resolution: "workerpool@npm:9.3.4"
@@ -15810,7 +17360,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"write-file-atomic@npm:5.0.1":
+"write-file-atomic@npm:5.0.1, write-file-atomic@npm:^5.0.1":
   version: 5.0.1
   resolution: "write-file-atomic@npm:5.0.1"
   dependencies:
@@ -15831,16 +17381,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"write-file-atomic@npm:^4.0.2":
-  version: 4.0.2
-  resolution: "write-file-atomic@npm:4.0.2"
-  dependencies:
-    imurmurhash: "npm:^0.1.4"
-    signal-exit: "npm:^3.0.7"
-  checksum: 10c0/a2c282c95ef5d8e1c27b335ae897b5eca00e85590d92a3fd69a437919b7b93ff36a69ea04145da55829d2164e724bc62202cdb5f4b208b425aba0807889375c7
-  languageName: node
-  linkType: hard
-
 "write-file-atomic@npm:^6.0.0":
   version: 6.0.0
   resolution: "write-file-atomic@npm:6.0.0"
@@ -15886,9 +17426,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ws@npm:^8.11.0":
-  version: 8.17.0
-  resolution: "ws@npm:8.17.0"
+"ws@npm:^8.18.0":
+  version: 8.20.0
+  resolution: "ws@npm:8.20.0"
   peerDependencies:
     bufferutil: ^4.0.1
     utf-8-validate: ">=5.0.2"
@@ -15897,14 +17437,14 @@ __metadata:
       optional: true
     utf-8-validate:
       optional: true
-  checksum: 10c0/55241ec93a66fdfc4bf4f8bc66c8eb038fda2c7a4ee8f6f157f2ca7dc7aa76aea0c0da0bf3adb2af390074a70a0e45456a2eaf80e581e630b75df10a64b0a990
+  checksum: 10c0/956ac5f11738c914089b65878b9223692ace77337ba55379ae68e1ecbeae9b47a0c6eb9403688f609999a58c80d83d99865fe0029b229d308b08c1ef93d4ea14
   languageName: node
   linkType: hard
 
-"xml-name-validator@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "xml-name-validator@npm:4.0.0"
-  checksum: 10c0/c1bfa219d64e56fee265b2bd31b2fcecefc063ee802da1e73bad1f21d7afd89b943c9e2c97af2942f60b1ad46f915a4c81e00039c7d398b53cf410e29d3c30bd
+"xml-name-validator@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "xml-name-validator@npm:5.0.0"
+  checksum: 10c0/3fcf44e7b73fb18be917fdd4ccffff3639373c7cb83f8fc35df6001fecba7942f1dbead29d91ebb8315e2f2ff786b508f0c9dc0215b6353f9983c6b7d62cb1f5
   languageName: node
   linkType: hard
 
@@ -15975,13 +17515,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"yargs-parser@npm:20.2.4":
-  version: 20.2.4
-  resolution: "yargs-parser@npm:20.2.4"
-  checksum: 10c0/08dc341f0b9f940c2fffc1d1decf3be00e28cabd2b578a694901eccc7dcd10577f10c6aa1b040fdd9a68b2042515a60f18476543bccacf9f3ce2c8534cd87435
-  languageName: node
-  linkType: hard
-
 "yargs-parser@npm:21.1.1, yargs-parser@npm:^21.1.1":
   version: 21.1.1
   resolution: "yargs-parser@npm:21.1.1"
@@ -15996,7 +17529,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"yargs-unparser@npm:2.0.0, yargs-unparser@npm:^2.0.0":
+"yargs-unparser@npm:^2.0.0":
   version: 2.0.0
   resolution: "yargs-unparser@npm:2.0.0"
   dependencies:
@@ -16008,33 +17541,33 @@ __metadata:
   languageName: node
   linkType: hard
 
-"yargs@npm:16.2.0, yargs@npm:^16.2.0":
-  version: 16.2.0
-  resolution: "yargs@npm:16.2.0"
+"yargs@npm:17.7.2, yargs@npm:^17.6.2, yargs@npm:^17.7.2":
+  version: 17.7.2
+  resolution: "yargs@npm:17.7.2"
   dependencies:
-    cliui: "npm:^7.0.2"
+    cliui: "npm:^8.0.1"
     escalade: "npm:^3.1.1"
     get-caller-file: "npm:^2.0.5"
     require-directory: "npm:^2.1.1"
-    string-width: "npm:^4.2.0"
+    string-width: "npm:^4.2.3"
     y18n: "npm:^5.0.5"
-    yargs-parser: "npm:^20.2.2"
-  checksum: 10c0/b1dbfefa679848442454b60053a6c95d62f2d2e21dd28def92b647587f415969173c6e99a0f3bab4f1b67ee8283bf735ebe3544013f09491186ba9e8a9a2b651
+    yargs-parser: "npm:^21.1.1"
+  checksum: 10c0/ccd7e723e61ad5965fffbb791366db689572b80cca80e0f96aad968dfff4156cd7cd1ad18607afe1046d8241e6fb2d6c08bf7fa7bfb5eaec818735d8feac8f05
   languageName: node
   linkType: hard
 
-"yargs@npm:17.7.2, yargs@npm:^17.3.1, yargs@npm:^17.6.2, yargs@npm:^17.7.2":
-  version: 17.7.2
-  resolution: "yargs@npm:17.7.2"
+"yargs@npm:^16.2.0":
+  version: 16.2.0
+  resolution: "yargs@npm:16.2.0"
   dependencies:
-    cliui: "npm:^8.0.1"
+    cliui: "npm:^7.0.2"
     escalade: "npm:^3.1.1"
     get-caller-file: "npm:^2.0.5"
     require-directory: "npm:^2.1.1"
-    string-width: "npm:^4.2.3"
+    string-width: "npm:^4.2.0"
     y18n: "npm:^5.0.5"
-    yargs-parser: "npm:^21.1.1"
-  checksum: 10c0/ccd7e723e61ad5965fffbb791366db689572b80cca80e0f96aad968dfff4156cd7cd1ad18607afe1046d8241e6fb2d6c08bf7fa7bfb5eaec818735d8feac8f05
+    yargs-parser: "npm:^20.2.2"
+  checksum: 10c0/b1dbfefa679848442454b60053a6c95d62f2d2e21dd28def92b647587f415969173c6e99a0f3bab4f1b67ee8283bf735ebe3544013f09491186ba9e8a9a2b651
   languageName: node
   linkType: hard
 
@@ -16052,6 +17585,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"yocto-queue@npm:^1.0.0":
+  version: 1.2.2
+  resolution: "yocto-queue@npm:1.2.2"
+  checksum: 10c0/36d4793e9cf7060f9da543baf67c55e354f4862c8d3d34de1a1b1d7c382d44171315cc54abf84d8900b8113d742b830108a1434f4898fb244f9b7e8426d4b8f5
+  languageName: node
+  linkType: hard
+
 "yoctocolors-cjs@npm:^2.1.3":
   version: 2.1.3
   resolution: "yoctocolors-cjs@npm:2.1.3"
@@ -16076,6 +17616,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"zod-validation-error@npm:^3.5.0 || ^4.0.0":
+  version: 4.0.2
+  resolution: "zod-validation-error@npm:4.0.2"
+  peerDependencies:
+    zod: ^3.25.0 || ^4.0.0
+  checksum: 10c0/0ccfec48c46de1be440b719cd02044d4abb89ed0e14c13e637cd55bf29102f67ccdba373f25def0fc7130e5f15025be4d557a7edcc95d5a3811599aade689e1b
+  languageName: node
+  linkType: hard
+
+"zod@npm:^3.25.0 || ^4.0.0":
+  version: 4.3.6
+  resolution: "zod@npm:4.3.6"
+  checksum: 10c0/860d25a81ab41d33aa25f8d0d07b091a04acb426e605f396227a796e9e800c44723ed96d0f53a512b57be3d1520f45bf69c0cb3b378a232a00787a2609625307
+  languageName: node
+  linkType: hard
+
 "zwitch@npm:^2.0.0, zwitch@npm:^2.0.4":
   version: 2.0.4
   resolution: "zwitch@npm:2.0.4"