velocious 1.0.601 → 1.0.602

package/README.md

@@ -15,8 +15,8 @@
 * Controllers and views for HTTP endpoints
 * Frontend-model transport for creating, updating, querying, and subscribing to query-filtered lifecycle events over HTTP/WebSocket, with structured per-attribute validation error responses and one-budget WebSocket startup controls (see [docs/frontend-models.md](docs/frontend-models.md) and [docs/websocket-channels.md](docs/websocket-channels.md))
 * Client-side offline sync mutation logs and frontend-model optimistic queueing primitives (see the [shared-resource sync developer guide](docs/shared-resource-sync-guide.md) and [offline sync architecture](docs/offline-sync.md))
-* Declarative client sync scopes with per-scope cursors, automatic mutation tracking, opt-in durable base-version conflict replay, realtime delivery whose per-recipient authorization hook receives the complete persisted sync envelope, and `sync`/`pull` progress reporting for "X of Y" import screens (see [docs/sync-client.md](docs/sync-client.md) and [docs/offline-sync.md](docs/offline-sync.md))
-* Reactive `useLiveQuery(Model.where(...))` queries that stay current from committed local model changes across local writes, pulls, and realtime (see [docs/live-queries.md](docs/live-queries.md))
+* Declarative client sync scopes with per-scope cursors, automatic mutation tracking, opt-in durable base-version conflict replay, realtime delivery, and immutable-handle project clients whose queues, scopes, cursors, receipts, conflicts, pulls, and reconnect catch-up stay in one physical tenant database (see [docs/sync-client.md](docs/sync-client.md) and [docs/offline-sync.md](docs/offline-sync.md))
+* Reactive `useLiveQuery(Model.where(...))` queries for default databases plus immutable-handle tenant live-query sources whose committed events and refreshes stay on the captured physical tenant (see [docs/live-queries.md](docs/live-queries.md))
 * Server-side sync envelope replay orchestration for app-owned sync receivers, including allowlisted authoritative values for conflict resolution (see [docs/sync-envelope-replay-service.md](docs/sync-envelope-replay-service.md))
 * Self-sustaining sync feeds: upstream imports triggered by the changes pull itself, with framework-owned coalescing and throttling (see [docs/sync-upstream-imports.md](docs/sync-upstream-imports.md))
 * AwesomeTasks-shaped offline sync proof using routed resources, domain commands, signed offline grants, and peer-forwarded mutations (see the [developer guide](docs/shared-resource-sync-guide.md) and [proof](docs/awesome-tasks-offline-sync-proof.md))
@@ -2687,7 +2687,7 @@ Tenant lifecycle commands print start and final counts, report each completed te
 
 `afterMigrateTenant` hooks run inside the active default and tenant database connection scope for the tenant being migrated.
 
-At runtime, the apartment-style `Tenant` façade (`velocious/build/src/tenants/tenant.js`) is the single entry point: `Tenant.with(tenant, callback)` / `Tenant.current()` to switch into and read a Node async context, `Tenant.handle(tenant)` to deeply capture immutable application and physical database identity for overlapping browser/native work, `Tenant.each({identifier, callback, parallel?, filter?})` to run a callback within every provider-listed tenant, and `Tenant.drop({identifier, tenant})` (plus the `db:tenants:drop` CLI command) to drop a tenant's database through the provider's `dropDatabase` hook. SQLite handles additionally expose framework-owned `open`, `flush`, `close`, `delete`, `inspect`, and `withPin` lifecycle methods; `frontendTenantSqlite.maxOpenHandles` bounds resident identities and clean, idle, unpinned handles are evicted least-recently-used. `Tenant.handle(...).databaseOperation(...)` and `.transaction(...)` use bounded pool-owned checkouts and pin model/query/write/association/preload/audit/attachment/raw work to the captured database even if a later UI project switch changes ambient tenant state. `Model.usingTenant(tenant)` uses the same safe core and adds eager helpers plus general `databaseOperation`/`transaction` model callbacks; eager records preserve legacy ambient Node follow-up semantics, while browser/native follow-up database work belongs inside the callback APIs. Inactive identifiers, mixed physical tenants, unsupported/cyclic descriptors, and expired operations fail closed. `Tenant.with` and `Tenant.each` retain their connection-establishing and model-initializing ambient behavior for Node request/job flows. `Tenant.aggregateAcross({identifier, aggregates, keyColumns, subquery, tenants?, filter?})` runs one aggregate over the same table across many tenant databases and returns the merged result — grouping tenants by server and using a single cross-database `UNION ALL` where the driver supports two-part `` `database`.`table` `` references (MySQL/MariaDB) or one query per tenant otherwise (PostgreSQL/SQLite/MSSQL).
+At runtime, the apartment-style `Tenant` façade (`velocious/build/src/tenants/tenant.js`) is the single entry point: `Tenant.with(tenant, callback)` / `Tenant.current()` to switch into and read a Node async context, `Tenant.handle(tenant)` to deeply capture immutable application and physical database identity for overlapping browser/native work, `Tenant.each({identifier, callback, parallel?, filter?})` to run a callback within every provider-listed tenant, and `Tenant.drop({identifier, tenant})` (plus the `db:tenants:drop` CLI command) to drop a tenant's database through the provider's `dropDatabase` hook. SQLite handles additionally expose framework-owned `open`, `flush`, `close`, `delete`, `inspect`, and `withPin` lifecycle methods; `frontendTenantSqlite.maxOpenHandles` bounds resident identities and clean, idle, unpinned handles are evicted least-recently-used. `Tenant.handle(...).databaseOperation(...)` and `.transaction(...)` use bounded pool-owned checkouts and pin model/query/write/association/preload/audit/attachment/raw work to the captured database even if a later UI project switch changes ambient tenant state. The handle also builds tenant-bound live-query sources, exposes an opaque physical identity for filtered record-change subscriptions, and binds project `SyncClient` instances. `Model.usingTenant(tenant)` uses the same safe core and adds eager helpers plus general `databaseOperation`/`transaction` model callbacks; eager records preserve legacy ambient Node follow-up semantics, while browser/native follow-up database work belongs inside the callback APIs. Inactive identifiers, mixed physical tenants, unsupported/cyclic descriptors, expired operations, unscoped tenant event subscriptions, and stale/cross-tenant sync state fail closed. `Tenant.with` and `Tenant.each` retain their connection-establishing and model-initializing ambient behavior for Node request/job flows. `Tenant.aggregateAcross({identifier, aggregates, keyColumns, subquery, tenants?, filter?})` runs one aggregate over the same table across many tenant databases and returns the merged result — grouping tenants by server and using a single cross-database `UNION ALL` where the driver supports two-part `` `database`.`table` `` references (MySQL/MariaDB) or one query per tenant otherwise (PostgreSQL/SQLite/MSSQL).
 
 `SchemaCloner` adds a missing auto-increment column and its separate source unique index in one schema alteration, including on MySQL/MariaDB where an auto-increment column must be keyed when it is created.
 

package/build/database/live-query.js

@@ -16,6 +16,7 @@ import restArgsError from "../utils/rest-args-error.js"
  * @template T
  * @typedef {object} LiveQuerySource
  * @property {() => RecordModelClass} getModelClass - Root model class the query reads.
+ * @property {(modelClass: RecordModelClass) => string} [databaseIdentityForModel] - Captured physical identity for an observed model.
  * @property {() => Promise<T[]>} toArray - Runs the query and resolves the current rows.
  */
 
@@ -117,7 +118,9 @@ class LiveQuery {
     this._started = true
 
     for (const modelClass of this._modelClasses) {
-      this._unsubscribes.push(recordChanges.subscribe(modelClass, this._onRecordChange))
+      const databaseIdentity = this._query.databaseIdentityForModel?.(modelClass)
+
+      this._unsubscribes.push(recordChanges.subscribe(modelClass, this._onRecordChange, {databaseIdentity}))
     }
 
     this._run()

package/build/database/operation.js

@@ -127,6 +127,7 @@ export default class VelociousDatabaseOperation {
     this.assertActive()
     this.assertModel(record.getModelClass())
     record.bindDatabaseOperation(this)
+    record.captureDatabaseIdentity(this.databaseIdentity())
 
     return record
   }
@@ -203,6 +204,14 @@ export default class VelociousDatabaseOperation {
     return `${this._databaseIdentifier}:${this._configurationReuseKey}`
   }
 
+  /**
+   * Returns the tenant schema generation captured when this operation started.
+   * @returns {string | undefined} - Captured schema generation.
+   */
+  schemaGeneration() {
+    return this._schemaGeneration
+  }
+
   /**
    * Initializes a model through this operation's captured connection.
    * @param {typeof import("./record/index.js").default} ModelClass - Model class.

package/build/database/record/index.js

@@ -3618,6 +3618,29 @@ class VelociousDatabaseRecord {
     return this
   }
 
+  /**
+   * Captures and validates the physical database identity that owns this record.
+   * @param {string} databaseIdentity - Opaque operation/connection identity.
+   * @returns {this} This record.
+   */
+  captureDatabaseIdentity(databaseIdentity) {
+    if (this._databaseIdentity && this._databaseIdentity !== databaseIdentity) {
+      throw new Error("Record belongs to a different physical tenant database")
+    }
+
+    this._databaseIdentity = databaseIdentity
+
+    return this
+  }
+
+  /**
+   * Returns the captured physical database identity.
+   * @returns {string | undefined} Captured physical database identity.
+   */
+  databaseIdentity() {
+    return this._databaseIdentity
+  }
+
   /**
    * Releases this record from a completed eager-helper operation while
    * preserving the legacy ambient follow-up behavior of `usingTenant` finders.
@@ -3742,7 +3765,27 @@ class VelociousDatabaseRecord {
     if (this._databaseOperation) return this._databaseOperation.connection()
     if (this.__connection) return this.__connection
 
-    return this.getModelClass().connection()
+    const connection = this.getModelClass().connection()
+
+    if (this._databaseIdentity) this.captureDatabaseIdentity(this._databaseIdentityForConnection(connection))
+
+    return connection
+  }
+
+  /**
+   * Resolves the identity of an already selected concrete connection.
+   * @param {import("../drivers/base.js").default} connection - Concrete connection.
+   * @returns {string} Physical database identity.
+   */
+  _databaseIdentityForConnection(connection) {
+    const modelClass = this.getModelClass()
+    const databaseIdentifier = modelClass.getDatabaseIdentifier()
+    const reuseKey = modelClass
+      ._getConfiguration()
+      .getDatabasePool(databaseIdentifier)
+      .getConnectionConfigurationReuseKey(connection)
+
+    return `${databaseIdentifier}:${reuseKey}`
   }
 
   /**
@@ -3993,9 +4036,14 @@ class VelociousDatabaseRecord {
     if (!recordChanges.hasListeners(modelClass)) return
 
     const record = this
+    const databaseIdentity = this._databaseOperation
+      ? this._databaseOperation.databaseIdentity()
+      : this._databaseIdentityForConnection(this._connection())
+
+    this.captureDatabaseIdentity(databaseIdentity)
 
     await this._connection().afterCommit(() => {
-      recordChanges.emit({modelClass, operation, record})
+      recordChanges.emit({databaseIdentity, modelClass, operation, record})
     })
   }
 

package/build/database/record-changes.js

@@ -14,6 +14,7 @@ import EventEmitter from "../utils/event-emitter.js"
  * RecordChangeEvent type.
  * @typedef {object} RecordChangeEvent
  * @property {RecordModelClass} modelClass - Model class whose row changed.
+ * @property {string} databaseIdentity - Opaque physical database identity where the commit occurred.
  * @property {RecordChangeOperation} operation - The committed operation.
  * @property {InstanceType<RecordModelClass>} record - The committed record instance.
  */
@@ -49,15 +50,25 @@ class RecordChanges {
    * Subscribes a listener to committed changes of a model class.
    * @param {RecordModelClass} modelClass - Model class to observe.
    * @param {RecordChangeListener} listener - Listener called with each change event.
+   * @param {{databaseIdentity?: string}} [options] - Captured physical identity filter.
    * @returns {() => void} Unsubscribe callback.
    */
-  subscribe(modelClass, listener) {
+  subscribe(modelClass, listener, {databaseIdentity} = {}) {
+    if (modelClass.hasTenantDatabaseIdentifierResolver() && !databaseIdentity) {
+      throw new Error(`Tenant-scoped record-change subscriptions for ${modelClass.getModelName()} require a captured databaseIdentity`)
+    }
+
     const eventName = modelClass.getModelName()
+    const subscribedListener = databaseIdentity
+      ? (/** @type {RecordChangeEvent} */ event) => {
+        if (event.databaseIdentity === databaseIdentity) listener(event)
+      }
+      : listener
 
-    this._emitter.on(eventName, listener)
+    this._emitter.on(eventName, subscribedListener)
 
     return () => {
-      this._emitter.off(eventName, listener)
+      this._emitter.off(eventName, subscribedListener)
     }
   }
 
@@ -81,7 +92,10 @@ class RecordChanges {
    */
   emit(event) {
     if (this._batchDepth > 0) {
-      this._bufferedEvents.set(event.modelClass.getModelName(), event)
+      const modelName = event.modelClass.getModelName()
+      const eventKey = `${modelName.length}:${modelName}:${event.databaseIdentity}`
+
+      this._bufferedEvents.set(eventKey, event)
 
       return
     }

package/build/src/database/live-query.d.ts

@@ -4,6 +4,10 @@ export type LiveQuerySource<T> = {
      * - Root model class the query reads.
      */
     getModelClass: () => RecordModelClass;
+    /**
+     * - Captured physical identity for an observed model.
+     */
+    databaseIdentityForModel?: (modelClass: RecordModelClass) => string;
     /**
      * - Runs the query and resolves the current rows.
      */
@@ -33,6 +37,7 @@ export type LiveQueryState<T> = {
  * @template T
  * @typedef {object} LiveQuerySource
  * @property {() => RecordModelClass} getModelClass - Root model class the query reads.
+ * @property {(modelClass: RecordModelClass) => string} [databaseIdentityForModel] - Captured physical identity for an observed model.
  * @property {() => Promise<T[]>} toArray - Runs the query and resolves the current rows.
  */
 /**

package/build/src/database/live-query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"live-query.d.ts","sourceRoot":"","sources":["../../../src/database/live-query.js"],"names":[],"mappings":"AASG,YAAsD,gBAAgB,GAA5D,cAAc,mBAAmB,EAAE,OAAO,CAAkB;AAOtE,YAAkB,eAAe,CADvB,CAAC,IAEX;;;;IAAmC,aAAa,EAArC,MAAM,gBAAgB,CACjC;;;;IAA+B,OAAO,EAA3B,MAAM,OAAO,CAAC,CAAC,EAAE,CAAC,CAC/B;CAAA,CAAA;AAKE,YAAkB,cAAc,CADtB,CAAC,IAEX;;;;IAAgB,OAAO,EAAZ,CAAC,EAAE,CACd;;;;IAAoB,OAAO,EAAhB,OAAO,CAClB;;;;IAAyB,KAAK,EAAnB,KAAK,GAAG,IAAI,CACzB;CAAA,CAAA;AArBD;;4EAE4E;AAE5E;;;;;;;;GAQG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;GAYG;AACH,cAAM,SAAS,CAFF,CAAC;IAiBV,iCAAiC;IAC5B,MAAM,EADA,eAAe,CAAC,CAAC,CAAC;IAG7B,iCAAiC;IAC5B,aAAa,EADP,gBAAgB,EAAE;IAG7B,gCAAgC;IAC3B,MAAM,EADA,cAAc,CAAC,CAAC,CAAC;IAG5B;;iCAE6B;IACxB,UAAU,EADL,GAAG,CAAC,MAAM,IAAI,CAAC;IAGzB;;mCAE+B;IAC1B,aAAa,EADR,KAAK,CAAC,MAAM,IAAI,CAAC;IAG3B,qBAAqB;IAChB,UAAU,EADJ,MAAM;IAGjB,sBAAsB;IACjB,OAAO,EADD,OAAO;IAGlB,sBAAsB;IACjB,QAAQ,EADF,OAAO;IAGlB,sBAAsB;IACjB,aAAa,EADP,OAAO;IAGlB;;sCAEkC;IAC7B,eAAe,EADV,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAG9B;;qDAEiD;IAC5C,YAAY,EADP,CAAC,MAAM,IAAI,CAAC,GAAG;QAAC,KAAK,CAAC,EAAE,MAAM,IAAI,CAAA;KAAC;IAK7C;;4BAEwB;IACnB,eAAe,EADV,MAAM,IAAI;IA3DtB;;;;;;OAMG;IACH,YAAY,EAAC,KAAK,EAAE,GAAG,QAAQ,EAAC,EAJ7B;QAAiC,KAAK,EAA9B,eAAe,CAAC,CAAC,CAAC,CAC1B;QAAkC,MAAM,AAAxC,CACA,EADQ,gBAAgB,EAAE,CAC1B;QAAsB,QAAQ,AAA9B,CACF,EADU,MAAM,CAChB;KAC+B,EAwD/B;IAED;;;OAGG;IACH,KAAK,IAFQ,IAAI,CAYhB;IAED;;;;OAIG;IACH,QAAQ,IAFK,cAAc,CAAC,CAAC,CAAC,CAI7B;IAED;;;;OAIG;IACH,SAAS,CAAC,QAAQ,EAHP,MAAM,IAGC,GAFL,MAAM,IAAI,CAQtB;IAED;;;OAGG;IACH,KAAK,IAFQ,IAAI,CAehB;IAED;;;;OAIG;IACG,WAAW,IAFJ,OAAO,CAAC,IAAI,CAAC,CAWzB;IAED;;;;OAIG;IACH,qBAAqB,IAFR,IAAI,CAYhB;IAED;;;;;OAKG;IACH,IAAI,IAFS,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAED;;;;OAIG;IACH,SAAS,CAAC,KAAK,EAHJ,cAAc,CAAC,CAAC,CAGZ,GAFF,IAAI,CAQhB;CACF;eAEc,SAAS"}
+{"version":3,"file":"live-query.d.ts","sourceRoot":"","sources":["../../../src/database/live-query.js"],"names":[],"mappings":"AASG,YAAsD,gBAAgB,GAA5D,cAAc,mBAAmB,EAAE,OAAO,CAAkB;AAOtE,YAAkB,eAAe,CADvB,CAAC,IAEX;;;;IAAmC,aAAa,EAArC,MAAM,gBAAgB,CACjC;;;;IAAsD,wBAAwB,AAA9E,CACA,EADW,CAAC,UAAU,EAAE,gBAAgB,KAAK,MAAM,CACnD;;;;IAA+B,OAAO,EAA3B,MAAM,OAAO,CAAC,CAAC,EAAE,CAAC,CAC/B;CAAA,CAAA;AAKE,YAAkB,cAAc,CADtB,CAAC,IAEX;;;;IAAgB,OAAO,EAAZ,CAAC,EAAE,CACd;;;;IAAoB,OAAO,EAAhB,OAAO,CAClB;;;;IAAyB,KAAK,EAAnB,KAAK,GAAG,IAAI,CACzB;CAAA,CAAA;AAtBD;;4EAE4E;AAE5E;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;GAYG;AACH,cAAM,SAAS,CAFF,CAAC;IAiBV,iCAAiC;IAC5B,MAAM,EADA,eAAe,CAAC,CAAC,CAAC;IAG7B,iCAAiC;IAC5B,aAAa,EADP,gBAAgB,EAAE;IAG7B,gCAAgC;IAC3B,MAAM,EADA,cAAc,CAAC,CAAC,CAAC;IAG5B;;iCAE6B;IACxB,UAAU,EADL,GAAG,CAAC,MAAM,IAAI,CAAC;IAGzB;;mCAE+B;IAC1B,aAAa,EADR,KAAK,CAAC,MAAM,IAAI,CAAC;IAG3B,qBAAqB;IAChB,UAAU,EADJ,MAAM;IAGjB,sBAAsB;IACjB,OAAO,EADD,OAAO;IAGlB,sBAAsB;IACjB,QAAQ,EADF,OAAO;IAGlB,sBAAsB;IACjB,aAAa,EADP,OAAO;IAGlB;;sCAEkC;IAC7B,eAAe,EADV,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAG9B;;qDAEiD;IAC5C,YAAY,EADP,CAAC,MAAM,IAAI,CAAC,GAAG;QAAC,KAAK,CAAC,EAAE,MAAM,IAAI,CAAA;KAAC;IAK7C;;4BAEwB;IACnB,eAAe,EADV,MAAM,IAAI;IA3DtB;;;;;;OAMG;IACH,YAAY,EAAC,KAAK,EAAE,GAAG,QAAQ,EAAC,EAJ7B;QAAiC,KAAK,EAA9B,eAAe,CAAC,CAAC,CAAC,CAC1B;QAAkC,MAAM,AAAxC,CACA,EADQ,gBAAgB,EAAE,CAC1B;QAAsB,QAAQ,AAA9B,CACF,EADU,MAAM,CAChB;KAC+B,EAwD/B;IAED;;;OAGG;IACH,KAAK,IAFQ,IAAI,CAchB;IAED;;;;OAIG;IACH,QAAQ,IAFK,cAAc,CAAC,CAAC,CAAC,CAI7B;IAED;;;;OAIG;IACH,SAAS,CAAC,QAAQ,EAHP,MAAM,IAGC,GAFL,MAAM,IAAI,CAQtB;IAED;;;OAGG;IACH,KAAK,IAFQ,IAAI,CAehB;IAED;;;;OAIG;IACG,WAAW,IAFJ,OAAO,CAAC,IAAI,CAAC,CAWzB;IAED;;;;OAIG;IACH,qBAAqB,IAFR,IAAI,CAYhB;IAED;;;;;OAKG;IACH,IAAI,IAFS,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAED;;;;OAIG;IACH,SAAS,CAAC,KAAK,EAHJ,cAAc,CAAC,CAAC,CAGZ,GAFF,IAAI,CAQhB;CACF;eAEc,SAAS"}

package/build/src/database/live-query.js

@@ -12,6 +12,7 @@ import restArgsError from "../utils/rest-args-error.js";
  * @template T
  * @typedef {object} LiveQuerySource
  * @property {() => RecordModelClass} getModelClass - Root model class the query reads.
+ * @property {(modelClass: RecordModelClass) => string} [databaseIdentityForModel] - Captured physical identity for an observed model.
  * @property {() => Promise<T[]>} toArray - Runs the query and resolves the current rows.
  */
 /**
@@ -97,7 +98,8 @@ class LiveQuery {
             return;
         this._started = true;
         for (const modelClass of this._modelClasses) {
-            this._unsubscribes.push(recordChanges.subscribe(modelClass, this._onRecordChange));
+            const databaseIdentity = this._query.databaseIdentityForModel?.(modelClass);
+            this._unsubscribes.push(recordChanges.subscribe(modelClass, this._onRecordChange, { databaseIdentity }));
         }
         this._run();
     }
@@ -208,4 +210,4 @@ class LiveQuery {
     }
 }
 export default LiveQuery;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"live-query.js","sourceRoot":"","sources":["../../../src/database/live-query.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport debounceFunction from \"debounce\"\n\nimport recordChanges from \"./record-changes.js\"\nimport restArgsError from \"../utils/rest-args-error.js\"\n\n/**\n * RecordModelClass type.\n * @typedef {typeof import(\"./record/index.js\").default} RecordModelClass */\n\n/**\n * The minimal query contract a live query needs: a root model class to observe\n * for committed changes and a way to run the query and return the current rows.\n * `Model.where({...})` (a model-class query) satisfies this directly.\n * @template T\n * @typedef {object} LiveQuerySource\n * @property {() => RecordModelClass} getModelClass - Root model class the query reads.\n * @property {() => Promise<T[]>} toArray - Runs the query and resolves the current rows.\n */\n\n/**\n * LiveQueryState type.\n * @template T\n * @typedef {object} LiveQueryState\n * @property {T[]} results - Current query results.\n * @property {boolean} loading - Whether the initial results are still loading.\n * @property {Error | null} error - The last run error, or null when the last run succeeded.\n */\n\n/**\n * A reactive query controller: fetches once, subscribes to committed changes of\n * its model class(es), and re-runs whenever a watched model changes. Re-runs are\n * coalesced (microtask by default, or a trailing debounce) and protected against\n * stale responses by a monotonically increasing request id, so an in-flight run\n * superseded by a newer change never overwrites fresher results. Framework-level\n * and React-free so it can be unit tested and wrapped by `useLiveQuery`.\n *\n * Cost model: invalidation is by model class. A change to model M schedules one\n * re-run of every live query observing M (no per-condition matching); a batch of\n * changes coalesces into a single re-run.\n * @template T\n */\nclass LiveQuery {\n  /**\n   * Builds a live query controller for a query source.\n   * @param {object} args - Options.\n   * @param {LiveQuerySource<T>} args.query - Query source providing model class and `toArray`.\n   * @param {RecordModelClass[]} [args.models] - Model classes to observe. Defaults to `[query.getModelClass()]`; pass this to also react to joined models.\n   * @param {number} [args.debounce] - Trailing debounce in ms for re-runs. Defaults to microtask coalescing.\n   */\n  constructor({query, ...restArgs}) {\n    const {debounce, models, ...unknownArgs} = restArgs\n\n    restArgsError(unknownArgs)\n\n    if (!query) throw new Error(\"No query given to LiveQuery\")\n\n    /** @type {LiveQuerySource<T>} */\n    this._query = query\n\n    /** @type {RecordModelClass[]} */\n    this._modelClasses = models ?? [query.getModelClass()]\n\n    /** @type {LiveQueryState<T>} */\n    this._state = {error: null, loading: true, results: []}\n\n    /**\n     * State-change listeners notified after every state transition.\n     * @type {Set<() => void>} */\n    this._listeners = new Set()\n\n    /**\n     * Record-change unsubscribe callbacks registered on `start`.\n     * @type {Array<() => void>} */\n    this._unsubscribes = []\n\n    /** @type {number} */\n    this._requestId = 0\n\n    /** @type {boolean} */\n    this._closed = false\n\n    /** @type {boolean} */\n    this._started = false\n\n    /** @type {boolean} */\n    this._runScheduled = false\n\n    /**\n     * Promise for the currently in-flight run, or null when idle.\n     * @type {Promise<void> | null} */\n    this._runningPromise = null\n\n    /**\n     * Schedules a coalesced re-run: a trailing debounce when configured, else microtask coalescing.\n     * @type {(() => void) & {clear?: () => void}} */\n    this._scheduleRun = typeof debounce === \"number\"\n      ? debounceFunction(() => this._run(), debounce)\n      : () => this._scheduleMicrotaskRun()\n\n    /**\n     * Record-change listener scheduling a re-run while the controller is open.\n     * @type {() => void} */\n    this._onRecordChange = () => {\n      if (!this._closed) this._scheduleRun()\n    }\n  }\n\n  /**\n   * Subscribes to record changes and runs the initial query. Idempotent.\n   * @returns {void}\n   */\n  start() {\n    if (this._closed || this._started) return\n\n    this._started = true\n\n    for (const modelClass of this._modelClasses) {\n      this._unsubscribes.push(recordChanges.subscribe(modelClass, this._onRecordChange))\n    }\n\n    this._run()\n  }\n\n  /**\n   * Returns the current state. The reference only changes when the state changes,\n   * so it is safe to use as a React external-store snapshot.\n   * @returns {LiveQueryState<T>} Current live-query state.\n   */\n  getState() {\n    return this._state\n  }\n\n  /**\n   * Subscribes a listener notified after every state change.\n   * @param {() => void} listener - State-change listener.\n   * @returns {() => void} Unsubscribe callback.\n   */\n  subscribe(listener) {\n    this._listeners.add(listener)\n\n    return () => {\n      this._listeners.delete(listener)\n    }\n  }\n\n  /**\n   * Unsubscribes from record changes, drops listeners, and prevents further runs.\n   * @returns {void}\n   */\n  close() {\n    if (this._closed) return\n\n    this._closed = true\n\n    for (const unsubscribe of this._unsubscribes) {\n      unsubscribe()\n    }\n\n    this._unsubscribes = []\n    this._listeners.clear()\n\n    if (this._scheduleRun.clear) this._scheduleRun.clear()\n  }\n\n  /**\n   * Awaits any scheduled or in-flight run so callers (tests) can observe settled\n   * results. Bounded so a continuous change stream cannot loop forever.\n   * @returns {Promise<void>}\n   */\n  async whenSettled() {\n    for (let attempt = 0; attempt < 100; attempt++) {\n      if (this._closed) return\n      if (!this._runScheduled && !this._runningPromise) return\n\n      if (this._runningPromise) await this._runningPromise\n\n      await new Promise((resolve) => queueMicrotask(() => resolve(undefined)))\n    }\n  }\n\n  /**\n   * Schedules a microtask-coalesced re-run, collapsing a synchronous burst of\n   * change events into a single run.\n   * @returns {void}\n   */\n  _scheduleMicrotaskRun() {\n    if (this._runScheduled) return\n\n    this._runScheduled = true\n\n    queueMicrotask(() => {\n      this._runScheduled = false\n\n      if (!this._closed) this._run()\n    })\n  }\n\n  /**\n   * Runs the query and applies its results unless a newer run superseded it or the\n   * controller was closed. A run error surfaces in state (with the previous\n   * results kept) rather than rejecting a background promise.\n   * @returns {Promise<void>}\n   */\n  _run() {\n    const requestId = ++this._requestId\n    const runningPromise = (async () => {\n      try {\n        const results = await this._query.toArray()\n\n        if (this._closed || requestId !== this._requestId) return\n\n        this._setState({error: null, loading: false, results})\n      } catch (error) {\n        if (this._closed || requestId !== this._requestId) return\n\n        this._setState({error: /** @type {Error} */ (error), loading: false, results: this._state.results})\n      }\n    })()\n\n    this._runningPromise = runningPromise\n    void runningPromise.then(() => {\n      if (this._runningPromise === runningPromise) this._runningPromise = null\n    })\n\n    return runningPromise\n  }\n\n  /**\n   * Replaces the state and notifies listeners.\n   * @param {LiveQueryState<T>} state - Next state.\n   * @returns {void}\n   */\n  _setState(state) {\n    this._state = state\n\n    for (const listener of Array.from(this._listeners)) {\n      listener()\n    }\n  }\n}\n\nexport default LiveQuery\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"live-query.js","sourceRoot":"","sources":["../../../src/database/live-query.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport debounceFunction from \"debounce\"\n\nimport recordChanges from \"./record-changes.js\"\nimport restArgsError from \"../utils/rest-args-error.js\"\n\n/**\n * RecordModelClass type.\n * @typedef {typeof import(\"./record/index.js\").default} RecordModelClass */\n\n/**\n * The minimal query contract a live query needs: a root model class to observe\n * for committed changes and a way to run the query and return the current rows.\n * `Model.where({...})` (a model-class query) satisfies this directly.\n * @template T\n * @typedef {object} LiveQuerySource\n * @property {() => RecordModelClass} getModelClass - Root model class the query reads.\n * @property {(modelClass: RecordModelClass) => string} [databaseIdentityForModel] - Captured physical identity for an observed model.\n * @property {() => Promise<T[]>} toArray - Runs the query and resolves the current rows.\n */\n\n/**\n * LiveQueryState type.\n * @template T\n * @typedef {object} LiveQueryState\n * @property {T[]} results - Current query results.\n * @property {boolean} loading - Whether the initial results are still loading.\n * @property {Error | null} error - The last run error, or null when the last run succeeded.\n */\n\n/**\n * A reactive query controller: fetches once, subscribes to committed changes of\n * its model class(es), and re-runs whenever a watched model changes. Re-runs are\n * coalesced (microtask by default, or a trailing debounce) and protected against\n * stale responses by a monotonically increasing request id, so an in-flight run\n * superseded by a newer change never overwrites fresher results. Framework-level\n * and React-free so it can be unit tested and wrapped by `useLiveQuery`.\n *\n * Cost model: invalidation is by model class. A change to model M schedules one\n * re-run of every live query observing M (no per-condition matching); a batch of\n * changes coalesces into a single re-run.\n * @template T\n */\nclass LiveQuery {\n  /**\n   * Builds a live query controller for a query source.\n   * @param {object} args - Options.\n   * @param {LiveQuerySource<T>} args.query - Query source providing model class and `toArray`.\n   * @param {RecordModelClass[]} [args.models] - Model classes to observe. Defaults to `[query.getModelClass()]`; pass this to also react to joined models.\n   * @param {number} [args.debounce] - Trailing debounce in ms for re-runs. Defaults to microtask coalescing.\n   */\n  constructor({query, ...restArgs}) {\n    const {debounce, models, ...unknownArgs} = restArgs\n\n    restArgsError(unknownArgs)\n\n    if (!query) throw new Error(\"No query given to LiveQuery\")\n\n    /** @type {LiveQuerySource<T>} */\n    this._query = query\n\n    /** @type {RecordModelClass[]} */\n    this._modelClasses = models ?? [query.getModelClass()]\n\n    /** @type {LiveQueryState<T>} */\n    this._state = {error: null, loading: true, results: []}\n\n    /**\n     * State-change listeners notified after every state transition.\n     * @type {Set<() => void>} */\n    this._listeners = new Set()\n\n    /**\n     * Record-change unsubscribe callbacks registered on `start`.\n     * @type {Array<() => void>} */\n    this._unsubscribes = []\n\n    /** @type {number} */\n    this._requestId = 0\n\n    /** @type {boolean} */\n    this._closed = false\n\n    /** @type {boolean} */\n    this._started = false\n\n    /** @type {boolean} */\n    this._runScheduled = false\n\n    /**\n     * Promise for the currently in-flight run, or null when idle.\n     * @type {Promise<void> | null} */\n    this._runningPromise = null\n\n    /**\n     * Schedules a coalesced re-run: a trailing debounce when configured, else microtask coalescing.\n     * @type {(() => void) & {clear?: () => void}} */\n    this._scheduleRun = typeof debounce === \"number\"\n      ? debounceFunction(() => this._run(), debounce)\n      : () => this._scheduleMicrotaskRun()\n\n    /**\n     * Record-change listener scheduling a re-run while the controller is open.\n     * @type {() => void} */\n    this._onRecordChange = () => {\n      if (!this._closed) this._scheduleRun()\n    }\n  }\n\n  /**\n   * Subscribes to record changes and runs the initial query. Idempotent.\n   * @returns {void}\n   */\n  start() {\n    if (this._closed || this._started) return\n\n    this._started = true\n\n    for (const modelClass of this._modelClasses) {\n      const databaseIdentity = this._query.databaseIdentityForModel?.(modelClass)\n\n      this._unsubscribes.push(recordChanges.subscribe(modelClass, this._onRecordChange, {databaseIdentity}))\n    }\n\n    this._run()\n  }\n\n  /**\n   * Returns the current state. The reference only changes when the state changes,\n   * so it is safe to use as a React external-store snapshot.\n   * @returns {LiveQueryState<T>} Current live-query state.\n   */\n  getState() {\n    return this._state\n  }\n\n  /**\n   * Subscribes a listener notified after every state change.\n   * @param {() => void} listener - State-change listener.\n   * @returns {() => void} Unsubscribe callback.\n   */\n  subscribe(listener) {\n    this._listeners.add(listener)\n\n    return () => {\n      this._listeners.delete(listener)\n    }\n  }\n\n  /**\n   * Unsubscribes from record changes, drops listeners, and prevents further runs.\n   * @returns {void}\n   */\n  close() {\n    if (this._closed) return\n\n    this._closed = true\n\n    for (const unsubscribe of this._unsubscribes) {\n      unsubscribe()\n    }\n\n    this._unsubscribes = []\n    this._listeners.clear()\n\n    if (this._scheduleRun.clear) this._scheduleRun.clear()\n  }\n\n  /**\n   * Awaits any scheduled or in-flight run so callers (tests) can observe settled\n   * results. Bounded so a continuous change stream cannot loop forever.\n   * @returns {Promise<void>}\n   */\n  async whenSettled() {\n    for (let attempt = 0; attempt < 100; attempt++) {\n      if (this._closed) return\n      if (!this._runScheduled && !this._runningPromise) return\n\n      if (this._runningPromise) await this._runningPromise\n\n      await new Promise((resolve) => queueMicrotask(() => resolve(undefined)))\n    }\n  }\n\n  /**\n   * Schedules a microtask-coalesced re-run, collapsing a synchronous burst of\n   * change events into a single run.\n   * @returns {void}\n   */\n  _scheduleMicrotaskRun() {\n    if (this._runScheduled) return\n\n    this._runScheduled = true\n\n    queueMicrotask(() => {\n      this._runScheduled = false\n\n      if (!this._closed) this._run()\n    })\n  }\n\n  /**\n   * Runs the query and applies its results unless a newer run superseded it or the\n   * controller was closed. A run error surfaces in state (with the previous\n   * results kept) rather than rejecting a background promise.\n   * @returns {Promise<void>}\n   */\n  _run() {\n    const requestId = ++this._requestId\n    const runningPromise = (async () => {\n      try {\n        const results = await this._query.toArray()\n\n        if (this._closed || requestId !== this._requestId) return\n\n        this._setState({error: null, loading: false, results})\n      } catch (error) {\n        if (this._closed || requestId !== this._requestId) return\n\n        this._setState({error: /** @type {Error} */ (error), loading: false, results: this._state.results})\n      }\n    })()\n\n    this._runningPromise = runningPromise\n    void runningPromise.then(() => {\n      if (this._runningPromise === runningPromise) this._runningPromise = null\n    })\n\n    return runningPromise\n  }\n\n  /**\n   * Replaces the state and notifies listeners.\n   * @param {LiveQueryState<T>} state - Next state.\n   * @returns {void}\n   */\n  _setState(state) {\n    this._state = state\n\n    for (const listener of Array.from(this._listeners)) {\n      listener()\n    }\n  }\n}\n\nexport default LiveQuery\n"]}

package/build/src/database/operation.d.ts

@@ -110,6 +110,11 @@ export default class VelociousDatabaseOperation {
      * @returns {string} - Physical database identity.
      */
     databaseIdentity(): string;
+    /**
+     * Returns the tenant schema generation captured when this operation started.
+     * @returns {string | undefined} - Captured schema generation.
+     */
+    schemaGeneration(): string | undefined;
     /**
      * Initializes a model through this operation's captured connection.
      * @param {typeof import("./record/index.js").default} ModelClass - Model class.

package/build/src/database/operation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/database/operation.js"],"names":[],"mappings":"AAEA,OAAO,mBAAmB,MAAM,2BAA2B,CAAA;AAE3D;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,0BAA0B;IAetC,OAAO;IACP,cAAc;IACd,sBAAsB;IACtB,sBAAsB;IACtB,mBAAmB;IACnB,6BAA6B;IAC7B,mBAAmB;IACnB,iBAAiB;IACjB,OAAO;IACZ,8GAA8G;IACzG,kBAAkB,EADZ,OAAO,CAAC,cAAc,mBAAmB,EAAE,OAAO,EAAE,cAAc,mBAAmB,EAAE,OAAO,CAAC;IAErG,WAAW;IAzBlB;;;;;;;;;;;;OAYG;IACH,YAAY,EAAC,aAAa,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,UAAU,EAAE,kBAAkB,EAAE,4BAAmC,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAC,EAV5K;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;QAAuB,4BAA4B,AAAnD,CACA,EADQ,OAAO,CACf;QAA6E,qBAAqB,AAAlG,CACA,EADQ,OAAO,2BAA2B,EAAE,yBAAyB,CACrE;QAAqB,qBAAqB,EAAlC,MAAM,CACd;QAAkD,UAAU,EAApD,OAAO,mBAAmB,EAAE,OAAO,CAC3C;QAAqB,kBAAkB,EAA/B,MAAM,CACd;QAAqB,KAAK,EAAlB,MAAM,CACd;QAAsB,gBAAgB,AAAtC,CACA,EADQ,MAAM,CACd;QAAiC,MAAM,EAA/B,MAAM,GAAG,SAAS,CAC5B;KAC8K,EAiB9K;IAED;;;;;OAKG;IACH,QAAQ,CAJkD,EAAE,SAA9C,cAAc,mBAAmB,EAAE,OAAW,EAInD,UAAU,EAHR,EAGQ,GAFN,OAAO,8BAA8B,EAAE,OAAO,CAAC,EAAE,CAAC,CAU9D;IAED;;;;;;;OAOG;IACH,UAAU,CAJgD,EAAE,SAA9C,cAAc,mBAAmB,EAAE,OAAW,EAIjD,UAAU,EAHV,EAGU,GAFR,EAAE,CAqCd;IAED;;;;OAIG;IACH,WAAW,CAAC,UAAU,EAHX,cAAc,mBAAmB,EAAE,OAGxB,GAFT,IAAI,CAYhB;IAED;;;;;OAKG;IACH,UAAU,CAJyC,KAAK,SAA1C,OAAO,mBAAmB,EAAE,OAAc,EAI7C,MAAM,EAHN,KAGM,GAFJ,KAAK,CAQjB;IAED;;;;OAIG;IACG,WAAW,CAAC,QAAQ,EAHf,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAGV,GAFb,OAAO,CAAC,IAAI,CAAC,CAKzB;IAED;;;;OAIG;IACG,YAAY,CAAC,QAAQ,EAHhB,CAAC,OAAO,EAAE;QAAC,SAAS,EAAE,0BAA0B,CAAA;KAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAGzD,GAFd,OAAO,CAAC,IAAI,CAAC,CAKzB;IAED;;;;;OAKG;IACG,WAAW,CAJJ,CAAC,EAII,QAAQ,EAHf,MAAM,OAAO,CAAC,CAAC,CAGA,GAFb,OAAO,CAAC,CAAC,CAAC,CAMtB;IAED;;;OAGG;IACH,UAAU,IAFG,OAAO,mBAAmB,EAAE,OAAO,CAY/C;IAED;;;OAGG;IACH,MAAM,IAFO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAI/C;IAED;;;OAGG;IACH,kBAAkB,IAFL,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAAgB,IAFH,MAAM,CAIlB;IAED;;;;OAIG;IACG,sBAAsB,CAAC,UAAU,EAH5B,cAAc,mBAAmB,EAAE,OAGP,GAF1B,OAAO,CAAC,IAAI,CAAC,CAczB;IAED;;;OAGG;IACH,YAAY,IAFC,IAAI,CAkBhB;IAED;;;OAGG;IACH,QAAQ,IAFK,IAAI,CAIhB;CACF"}
+{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/database/operation.js"],"names":[],"mappings":"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"}

package/build/src/database/operation.js

@@ -116,6 +116,7 @@ export default class VelociousDatabaseOperation {
         this.assertActive();
         this.assertModel(record.getModelClass());
         record.bindDatabaseOperation(this);
+        record.captureDatabaseIdentity(this.databaseIdentity());
         return record;
     }
     /**
@@ -180,6 +181,13 @@ export default class VelociousDatabaseOperation {
     databaseIdentity() {
         return `${this._databaseIdentifier}:${this._configurationReuseKey}`;
     }
+    /**
+     * Returns the tenant schema generation captured when this operation started.
+     * @returns {string | undefined} - Captured schema generation.
+     */
+    schemaGeneration() {
+        return this._schemaGeneration;
+    }
     /**
      * Initializes a model through this operation's captured connection.
      * @param {typeof import("./record/index.js").default} ModelClass - Model class.
@@ -223,4 +231,4 @@ export default class VelociousDatabaseOperation {
         this._active = false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operation.js","sourceRoot":"","sources":["../../../src/database/operation.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport OperationConnection from \"./operation-connection.js\"\n\n/**\n * Explicit owner for model work performed on one pinned transactional\n * connection.\n */\nexport default class VelociousDatabaseOperation {\n  /**\n   * Runs constructor.\n   * @param {object} args - Operation ownership.\n   * @param {import(\"../configuration.js\").default} args.configuration - Owning configuration.\n   * @param {boolean} [args.enforceCurrentTenantReuseKey] - Whether ambient tenant changes invalidate this legacy operation.\n   * @param {import(\"../configuration-types.js\").DatabaseConfigurationType} [args.databaseConfiguration] - Captured resolved physical database configuration.\n   * @param {string} args.configurationReuseKey - Physical database configuration key captured at checkout.\n   * @param {import(\"./drivers/base.js\").default} args.connection - Pinned physical connection.\n   * @param {string} args.databaseIdentifier - Singular database identifier.\n   * @param {symbol} args.owner - Opaque pool lease owner.\n   * @param {string} [args.schemaGeneration] - Tenant schema generation owning record metadata.\n   * @param {object | undefined} args.tenant - Tenant descriptor captured by the owning handle.\n   */\n  constructor({configuration, databaseConfiguration, configurationReuseKey, connection, databaseIdentifier, enforceCurrentTenantReuseKey = true, owner, schemaGeneration, tenant}) {\n    this._active = true\n    this._configuration = configuration\n    this._databaseConfiguration = databaseConfiguration || configuration.resolveDatabaseConfiguration(databaseIdentifier, tenant)\n    this._configurationReuseKey = configurationReuseKey\n    this._databaseIdentifier = databaseIdentifier\n    this._enforceCurrentTenantReuseKey = enforceCurrentTenantReuseKey\n    this._physicalConnection = connection\n    this._schemaGeneration = schemaGeneration\n    this._tenant = tenant\n    /** @type {WeakMap<typeof import(\"./record/index.js\").default, typeof import(\"./record/index.js\").default>} */\n    this._boundModelClasses = new WeakMap()\n    this._connection = new OperationConnection({\n      connection,\n      operation: this,\n      owner\n    })\n  }\n\n  /**\n   * Returns an operation-bound model query/create scope.\n   * @template {typeof import(\"./record/index.js\").default} MC\n   * @param {MC} ModelClass - Model class to bind.\n   * @returns {import(\"./query/model-class-query.js\").default<MC>} - Operation-bound scope.\n   */\n  forModel(ModelClass) {\n    this.assertActive()\n    this.assertModel(ModelClass)\n\n    return this.modelClass(ModelClass)._newQuery({\n      driver: this.connection(),\n      operation: this\n    })\n  }\n\n  /**\n   * Returns a model-class view whose schema metadata is bound to this physical\n   * database generation. Construction still produces the application's original\n   * model class, so lifecycle callbacks and model registries retain class identity.\n   * @template {typeof import(\"./record/index.js\").default} MC\n   * @param {MC} ModelClass - Canonical model class.\n   * @returns {MC} - Operation-bound model class.\n   */\n  modelClass(ModelClass) {\n    if (!this._schemaGeneration) return ModelClass\n\n    const canonicalModelClass = /** @type {MC} */ (ModelClass._recordMetadataModelClass || ModelClass)\n\n    const existing = this._boundModelClasses.get(canonicalModelClass)\n\n    if (existing) return /** @type {MC} */ (existing)\n\n    const databaseIdentity = this.databaseIdentity()\n    const metadataKey = `${databaseIdentity.length}:${databaseIdentity}:${this._schemaGeneration}`\n    const metadataProperties = canonicalModelClass.recordMetadataPropertyNames()\n    const boundModelClass = new Proxy(canonicalModelClass, {\n      construct: (target, args, newTarget) => Reflect.construct(target, args, newTarget),\n      get: (target, property, receiver) => {\n        if (property === \"_recordMetadataModelClass\") return target\n        if (property === \"_recordMetadataBinder\") return (/** @type {typeof import(\"./record/index.js\").default} */ targetModelClass) => this.modelClass(targetModelClass)\n        if (property === \"_recordMetadataOperation\") return this\n        if (typeof property === \"string\" && metadataProperties.has(property)) return target.recordMetadataValue(metadataKey, property)\n\n        return Reflect.get(target, property, receiver)\n      },\n      set: (target, property, value, receiver) => {\n        if (typeof property === \"string\" && metadataProperties.has(property)) {\n          target.setRecordMetadataValue(metadataKey, property, value)\n          return true\n        }\n\n        return Reflect.set(target, property, value, receiver)\n      }\n    })\n\n    this._boundModelClasses.set(canonicalModelClass, boundModelClass)\n\n    return /** @type {MC} */ (boundModelClass)\n  }\n\n  /**\n   * Verifies that a model belongs to this operation's configuration and database.\n   * @param {typeof import(\"./record/index.js\").default} ModelClass - Model class to verify.\n   * @returns {void}\n   */\n  assertModel(ModelClass) {\n    if (ModelClass._getConfiguration() !== this._configuration) {\n      throw new Error(`${ModelClass.getModelName()} belongs to another Velocious configuration`)\n    }\n\n    const modelDatabaseIdentifier = ModelClass.getDatabaseIdentifier({tenant: this._tenant})\n\n    if (modelDatabaseIdentifier !== this._databaseIdentifier) {\n      throw new Error(`${ModelClass.getModelName()} uses database ${JSON.stringify(modelDatabaseIdentifier)}, not operation database ${JSON.stringify(this._databaseIdentifier)}`)\n    }\n  }\n\n  /**\n   * Binds a loaded or built record to this operation.\n   * @template {import(\"./record/index.js\").default} Model\n   * @param {Model} record - Record to bind.\n   * @returns {Model} - Bound record.\n   */\n  bindRecord(record) {\n    this.assertActive()\n    this.assertModel(record.getModelClass())\n    record.bindDatabaseOperation(this)\n\n    return record\n  }\n\n  /**\n   * Registers a callback owned by the current operation transaction frame.\n   * @param {() => void | Promise<void>} callback - Callback.\n   * @returns {Promise<void>} - Resolves after registration or execution.\n   */\n  async afterCommit(callback) {\n    this.assertActive()\n    await this.connection().afterCommit(callback)\n  }\n\n  /**\n   * Registers a guard owned by the current transaction/savepoint frame.\n   * @param {(context: {operation: VelociousDatabaseOperation}) => void | Promise<void>} callback - Guard callback.\n   * @returns {Promise<void>} - Resolves after registration.\n   */\n  async beforeCommit(callback) {\n    this.assertActive()\n    await this.connection().beforeCommit(() => callback({operation: this}))\n  }\n\n  /**\n   * Runs a nested operation transaction/savepoint.\n   * @template T\n   * @param {() => Promise<T>} callback - Callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async transaction(callback) {\n    this.assertActive()\n\n    return await this.connection().transaction(callback)\n  }\n\n  /**\n   * Returns the deliberately exposed operation connection facade for raw SQL.\n   * @returns {import(\"./drivers/base.js\").default} - Operation-bound connection.\n   */\n  connection() {\n    this.assertActive()\n\n    /**\n     * Narrows the Proxy facade to the complete driver surface that it forwards.\n     * @type {import(\"./drivers/base.js\").default}\n     */\n    const connectionFacade = /** @type {ReturnType<typeof JSON.parse>} */ (this._connection)\n\n    return connectionFacade\n  }\n\n  /**\n   * Returns the tenant descriptor captured by the immutable handle.\n   * @returns {Record<string, unknown> | undefined} - Captured tenant descriptor.\n   */\n  tenant() {\n    return /** @type {Record<string, unknown> | undefined} */ (this._tenant)\n  }\n\n  /**\n   * Returns the logical database identifier owned by this operation.\n   * @returns {string} - Database identifier.\n   */\n  databaseIdentifier() {\n    return this._databaseIdentifier\n  }\n\n  /**\n   * Returns a stable physical-database identity suitable for operation-aware caches.\n   * @returns {string} - Physical database identity.\n   */\n  databaseIdentity() {\n    return `${this._databaseIdentifier}:${this._configurationReuseKey}`\n  }\n\n  /**\n   * Initializes a model through this operation's captured connection.\n   * @param {typeof import(\"./record/index.js\").default} ModelClass - Model class.\n   * @returns {Promise<void>} - Resolves when initialized.\n   */\n  async ensureModelInitialized(ModelClass) {\n    this.assertActive()\n\n    const boundModelClass = this.modelClass(ModelClass)\n\n    if (boundModelClass.isInitialized()) this.assertModel(ModelClass)\n\n    await boundModelClass.ensureInitialized({\n      configuration: this._configuration,\n      connection: this.connection()\n    })\n    this.assertModel(ModelClass)\n  }\n\n  /**\n   * Raises when an operation handle has left its callback.\n   * @returns {void}\n   */\n  assertActive() {\n    if (!this._active) throw new Error(\"Database operation has completed\")\n\n    const pool = this\n      ._configuration\n      .getDatabasePool(this._databaseIdentifier)\n    const capturedReuseKey = pool.getConfigurationReuseKey(this._databaseConfiguration)\n    const connectionReuseKey = pool.getConnectionConfigurationReuseKey(this._physicalConnection)\n\n    if (capturedReuseKey !== this._configurationReuseKey || connectionReuseKey !== this._configurationReuseKey) {\n      throw new Error(`Database operation for ${JSON.stringify(this._databaseIdentifier)} belongs to a different physical database than its captured tenant handle`)\n    }\n\n    if (this._enforceCurrentTenantReuseKey && pool.getConfigurationReuseKey() !== this._configurationReuseKey) {\n      throw new Error(`Database operation for ${JSON.stringify(this._databaseIdentifier)} belongs to a different physical database than the current tenant context`)\n    }\n  }\n\n  /**\n   * Expires the operation and all scopes/records bound to it.\n   * @returns {void}\n   */\n  complete() {\n    this._active = false\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operation.js","sourceRoot":"","sources":["../../../src/database/operation.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport OperationConnection from \"./operation-connection.js\"\n\n/**\n * Explicit owner for model work performed on one pinned transactional\n * connection.\n */\nexport default class VelociousDatabaseOperation {\n  /**\n   * Runs constructor.\n   * @param {object} args - Operation ownership.\n   * @param {import(\"../configuration.js\").default} args.configuration - Owning configuration.\n   * @param {boolean} [args.enforceCurrentTenantReuseKey] - Whether ambient tenant changes invalidate this legacy operation.\n   * @param {import(\"../configuration-types.js\").DatabaseConfigurationType} [args.databaseConfiguration] - Captured resolved physical database configuration.\n   * @param {string} args.configurationReuseKey - Physical database configuration key captured at checkout.\n   * @param {import(\"./drivers/base.js\").default} args.connection - Pinned physical connection.\n   * @param {string} args.databaseIdentifier - Singular database identifier.\n   * @param {symbol} args.owner - Opaque pool lease owner.\n   * @param {string} [args.schemaGeneration] - Tenant schema generation owning record metadata.\n   * @param {object | undefined} args.tenant - Tenant descriptor captured by the owning handle.\n   */\n  constructor({configuration, databaseConfiguration, configurationReuseKey, connection, databaseIdentifier, enforceCurrentTenantReuseKey = true, owner, schemaGeneration, tenant}) {\n    this._active = true\n    this._configuration = configuration\n    this._databaseConfiguration = databaseConfiguration || configuration.resolveDatabaseConfiguration(databaseIdentifier, tenant)\n    this._configurationReuseKey = configurationReuseKey\n    this._databaseIdentifier = databaseIdentifier\n    this._enforceCurrentTenantReuseKey = enforceCurrentTenantReuseKey\n    this._physicalConnection = connection\n    this._schemaGeneration = schemaGeneration\n    this._tenant = tenant\n    /** @type {WeakMap<typeof import(\"./record/index.js\").default, typeof import(\"./record/index.js\").default>} */\n    this._boundModelClasses = new WeakMap()\n    this._connection = new OperationConnection({\n      connection,\n      operation: this,\n      owner\n    })\n  }\n\n  /**\n   * Returns an operation-bound model query/create scope.\n   * @template {typeof import(\"./record/index.js\").default} MC\n   * @param {MC} ModelClass - Model class to bind.\n   * @returns {import(\"./query/model-class-query.js\").default<MC>} - Operation-bound scope.\n   */\n  forModel(ModelClass) {\n    this.assertActive()\n    this.assertModel(ModelClass)\n\n    return this.modelClass(ModelClass)._newQuery({\n      driver: this.connection(),\n      operation: this\n    })\n  }\n\n  /**\n   * Returns a model-class view whose schema metadata is bound to this physical\n   * database generation. Construction still produces the application's original\n   * model class, so lifecycle callbacks and model registries retain class identity.\n   * @template {typeof import(\"./record/index.js\").default} MC\n   * @param {MC} ModelClass - Canonical model class.\n   * @returns {MC} - Operation-bound model class.\n   */\n  modelClass(ModelClass) {\n    if (!this._schemaGeneration) return ModelClass\n\n    const canonicalModelClass = /** @type {MC} */ (ModelClass._recordMetadataModelClass || ModelClass)\n\n    const existing = this._boundModelClasses.get(canonicalModelClass)\n\n    if (existing) return /** @type {MC} */ (existing)\n\n    const databaseIdentity = this.databaseIdentity()\n    const metadataKey = `${databaseIdentity.length}:${databaseIdentity}:${this._schemaGeneration}`\n    const metadataProperties = canonicalModelClass.recordMetadataPropertyNames()\n    const boundModelClass = new Proxy(canonicalModelClass, {\n      construct: (target, args, newTarget) => Reflect.construct(target, args, newTarget),\n      get: (target, property, receiver) => {\n        if (property === \"_recordMetadataModelClass\") return target\n        if (property === \"_recordMetadataBinder\") return (/** @type {typeof import(\"./record/index.js\").default} */ targetModelClass) => this.modelClass(targetModelClass)\n        if (property === \"_recordMetadataOperation\") return this\n        if (typeof property === \"string\" && metadataProperties.has(property)) return target.recordMetadataValue(metadataKey, property)\n\n        return Reflect.get(target, property, receiver)\n      },\n      set: (target, property, value, receiver) => {\n        if (typeof property === \"string\" && metadataProperties.has(property)) {\n          target.setRecordMetadataValue(metadataKey, property, value)\n          return true\n        }\n\n        return Reflect.set(target, property, value, receiver)\n      }\n    })\n\n    this._boundModelClasses.set(canonicalModelClass, boundModelClass)\n\n    return /** @type {MC} */ (boundModelClass)\n  }\n\n  /**\n   * Verifies that a model belongs to this operation's configuration and database.\n   * @param {typeof import(\"./record/index.js\").default} ModelClass - Model class to verify.\n   * @returns {void}\n   */\n  assertModel(ModelClass) {\n    if (ModelClass._getConfiguration() !== this._configuration) {\n      throw new Error(`${ModelClass.getModelName()} belongs to another Velocious configuration`)\n    }\n\n    const modelDatabaseIdentifier = ModelClass.getDatabaseIdentifier({tenant: this._tenant})\n\n    if (modelDatabaseIdentifier !== this._databaseIdentifier) {\n      throw new Error(`${ModelClass.getModelName()} uses database ${JSON.stringify(modelDatabaseIdentifier)}, not operation database ${JSON.stringify(this._databaseIdentifier)}`)\n    }\n  }\n\n  /**\n   * Binds a loaded or built record to this operation.\n   * @template {import(\"./record/index.js\").default} Model\n   * @param {Model} record - Record to bind.\n   * @returns {Model} - Bound record.\n   */\n  bindRecord(record) {\n    this.assertActive()\n    this.assertModel(record.getModelClass())\n    record.bindDatabaseOperation(this)\n    record.captureDatabaseIdentity(this.databaseIdentity())\n\n    return record\n  }\n\n  /**\n   * Registers a callback owned by the current operation transaction frame.\n   * @param {() => void | Promise<void>} callback - Callback.\n   * @returns {Promise<void>} - Resolves after registration or execution.\n   */\n  async afterCommit(callback) {\n    this.assertActive()\n    await this.connection().afterCommit(callback)\n  }\n\n  /**\n   * Registers a guard owned by the current transaction/savepoint frame.\n   * @param {(context: {operation: VelociousDatabaseOperation}) => void | Promise<void>} callback - Guard callback.\n   * @returns {Promise<void>} - Resolves after registration.\n   */\n  async beforeCommit(callback) {\n    this.assertActive()\n    await this.connection().beforeCommit(() => callback({operation: this}))\n  }\n\n  /**\n   * Runs a nested operation transaction/savepoint.\n   * @template T\n   * @param {() => Promise<T>} callback - Callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async transaction(callback) {\n    this.assertActive()\n\n    return await this.connection().transaction(callback)\n  }\n\n  /**\n   * Returns the deliberately exposed operation connection facade for raw SQL.\n   * @returns {import(\"./drivers/base.js\").default} - Operation-bound connection.\n   */\n  connection() {\n    this.assertActive()\n\n    /**\n     * Narrows the Proxy facade to the complete driver surface that it forwards.\n     * @type {import(\"./drivers/base.js\").default}\n     */\n    const connectionFacade = /** @type {ReturnType<typeof JSON.parse>} */ (this._connection)\n\n    return connectionFacade\n  }\n\n  /**\n   * Returns the tenant descriptor captured by the immutable handle.\n   * @returns {Record<string, unknown> | undefined} - Captured tenant descriptor.\n   */\n  tenant() {\n    return /** @type {Record<string, unknown> | undefined} */ (this._tenant)\n  }\n\n  /**\n   * Returns the logical database identifier owned by this operation.\n   * @returns {string} - Database identifier.\n   */\n  databaseIdentifier() {\n    return this._databaseIdentifier\n  }\n\n  /**\n   * Returns a stable physical-database identity suitable for operation-aware caches.\n   * @returns {string} - Physical database identity.\n   */\n  databaseIdentity() {\n    return `${this._databaseIdentifier}:${this._configurationReuseKey}`\n  }\n\n  /**\n   * Returns the tenant schema generation captured when this operation started.\n   * @returns {string | undefined} - Captured schema generation.\n   */\n  schemaGeneration() {\n    return this._schemaGeneration\n  }\n\n  /**\n   * Initializes a model through this operation's captured connection.\n   * @param {typeof import(\"./record/index.js\").default} ModelClass - Model class.\n   * @returns {Promise<void>} - Resolves when initialized.\n   */\n  async ensureModelInitialized(ModelClass) {\n    this.assertActive()\n\n    const boundModelClass = this.modelClass(ModelClass)\n\n    if (boundModelClass.isInitialized()) this.assertModel(ModelClass)\n\n    await boundModelClass.ensureInitialized({\n      configuration: this._configuration,\n      connection: this.connection()\n    })\n    this.assertModel(ModelClass)\n  }\n\n  /**\n   * Raises when an operation handle has left its callback.\n   * @returns {void}\n   */\n  assertActive() {\n    if (!this._active) throw new Error(\"Database operation has completed\")\n\n    const pool = this\n      ._configuration\n      .getDatabasePool(this._databaseIdentifier)\n    const capturedReuseKey = pool.getConfigurationReuseKey(this._databaseConfiguration)\n    const connectionReuseKey = pool.getConnectionConfigurationReuseKey(this._physicalConnection)\n\n    if (capturedReuseKey !== this._configurationReuseKey || connectionReuseKey !== this._configurationReuseKey) {\n      throw new Error(`Database operation for ${JSON.stringify(this._databaseIdentifier)} belongs to a different physical database than its captured tenant handle`)\n    }\n\n    if (this._enforceCurrentTenantReuseKey && pool.getConfigurationReuseKey() !== this._configurationReuseKey) {\n      throw new Error(`Database operation for ${JSON.stringify(this._databaseIdentifier)} belongs to a different physical database than the current tenant context`)\n    }\n  }\n\n  /**\n   * Expires the operation and all scopes/records bound to it.\n   * @returns {void}\n   */\n  complete() {\n    this._active = false\n  }\n}\n"]}

package/build/src/database/record/index.d.ts

@@ -415,6 +415,18 @@ declare class VelociousDatabaseRecord<WriteAttributes extends Record<string, Ret
              * @returns {this} - Bound record.
              */
             bindDatabaseOperation(operation: import("../operation.js").default): /*elided*/ any;
+            /**
+             * Captures and validates the physical database identity that owns this record.
+             * @param {string} databaseIdentity - Opaque operation/connection identity.
+             * @returns {this} This record.
+             */
+            captureDatabaseIdentity(databaseIdentity: string): /*elided*/ any;
+            _databaseIdentity: string | undefined;
+            /**
+             * Returns the captured physical database identity.
+             * @returns {string | undefined} Captured physical database identity.
+             */
+            databaseIdentity(): string | undefined;
             /**
              * Releases this record from a completed eager-helper operation while
              * preserving the legacy ambient follow-up behavior of `usingTenant` finders.
@@ -476,6 +488,12 @@ declare class VelociousDatabaseRecord<WriteAttributes extends Record<string, Ret
              * @returns {import("../drivers/base.js").default} - The connection.
              */
             _connection(): import("../drivers/base.js").default;
+            /**
+             * Resolves the identity of an already selected concrete connection.
+             * @param {import("../drivers/base.js").default} connection - Concrete connection.
+             * @returns {string} Physical database identity.
+             */
+            _databaseIdentityForConnection(connection: import("../drivers/base.js").default): string;
             /**
              * Returns the connection that owns this record's database work.
              * @returns {import("../drivers/base.js").default} - Connection.
@@ -2021,6 +2039,7 @@ declare class VelociousDatabaseRecord<WriteAttributes extends Record<string, Ret
         ransack<MC extends typeof VelociousDatabaseRecord>(this: MC, params: Record<string, ReturnType<typeof JSON.parse>>): ModelClassQuery<MC>;
     } | undefined;
     _isNewRecord: boolean;
+    _databaseIdentity: string | undefined;
     /** @type {Record<string, string> | undefined} */
     static _attributeNameToColumnName: Record<string, string> | undefined;
     /** @type {Record<string, string> | undefined} */
@@ -3510,6 +3529,17 @@ declare class VelociousDatabaseRecord<WriteAttributes extends Record<string, Ret
      * @returns {this} - Bound record.
      */
     bindDatabaseOperation(operation: import("../operation.js").default): this;
+    /**
+     * Captures and validates the physical database identity that owns this record.
+     * @param {string} databaseIdentity - Opaque operation/connection identity.
+     * @returns {this} This record.
+     */
+    captureDatabaseIdentity(databaseIdentity: string): this;
+    /**
+     * Returns the captured physical database identity.
+     * @returns {string | undefined} Captured physical database identity.
+     */
+    databaseIdentity(): string | undefined;
     /**
      * Releases this record from a completed eager-helper operation while
      * preserving the legacy ambient follow-up behavior of `usingTenant` finders.
@@ -3571,6 +3601,12 @@ declare class VelociousDatabaseRecord<WriteAttributes extends Record<string, Ret
      * @returns {import("../drivers/base.js").default} - The connection.
      */
     _connection(): import("../drivers/base.js").default;
+    /**
+     * Resolves the identity of an already selected concrete connection.
+     * @param {import("../drivers/base.js").default} connection - Concrete connection.
+     * @returns {string} Physical database identity.
+     */
+    _databaseIdentityForConnection(connection: import("../drivers/base.js").default): string;
     /**
      * Returns the connection that owns this record's database work.
      * @returns {import("../drivers/base.js").default} - Connection.