velocious 1.0.593 → 1.0.595

package/build/src/tenants/tenant-handle.js

@@ -1,10 +1,11 @@
 // @ts-check
+import Migrator from "../database/migrator.js";
 /**
  * TenantDescriptorValue type.
  * @typedef {null | boolean | number | string | TenantDescriptorValue[] | {[key: string]: TenantDescriptorValue}} TenantDescriptorValue
  */
 /** @typedef {{[key: string]: TenantDescriptorValue}} TenantDescriptor */
-/** @typedef {{databaseIdentifier: string, dirty: boolean, lastUsed: number, pinCount: number, state: "closed" | "closing" | "deleting" | "open" | "opening"}} TenantSqliteLifecycleSnapshot */
+/** @typedef {{databaseIdentifier: string, dirty: boolean, lastUsed: number, pinCount: number, ready: boolean, schemaGeneration: string | undefined, state: "closed" | "closing" | "deleting" | "open" | "opening"}} TenantSqliteLifecycleSnapshot */
 /**
  * Returns a readable path for a captured descriptor/configuration value.
  * @param {string} path - Parent path.
@@ -176,6 +177,16 @@ export default class TenantHandle {
     tenant() {
         return this._tenant;
     }
+    /**
+     * Rejects using this handle with a different Configuration instance.
+     * @param {import("../configuration.js").default} configuration - Expected owner.
+     * @returns {void}
+     */
+    assertConfiguration(configuration) {
+        if (configuration !== this._configuration) {
+            throw new Error("Tenant handle belongs to a different Velocious configuration");
+        }
+    }
     /**
      * Returns the captured physical configuration for an active identifier.
      * @param {string} databaseIdentifier - Logical database identifier.
@@ -197,6 +208,53 @@ export default class TenantHandle {
         const { databaseIdentifier } = options;
         return await this._configuration.getFrontendTenantSqliteLifecycle().open(databaseIdentifier, this.databaseConfiguration(databaseIdentifier));
     }
+    /**
+     * Opens, migrates, and initializes record metadata for one captured physical
+     * tenant SQLite database and application schema generation.
+     * @param {object} options - Initialization options.
+     * @param {string} options.databaseIdentifier - Tenant-only logical database identifier.
+     * @param {import("../database/migrator/types.js").RequireMigrationContextType} options.migrations - Frontend migration require context.
+     * @param {string} options.schemaGeneration - Stable application schema generation.
+     * @returns {Promise<Readonly<TenantSqliteLifecycleSnapshot>>} - Ready lifecycle snapshot.
+     */
+    async initialize({ databaseIdentifier, migrations, schemaGeneration }) {
+        if (!migrations || typeof migrations !== "function" || typeof migrations.keys !== "function") {
+            throw new TypeError("TenantHandle.initialize requires a migrations require context");
+        }
+        const databaseConfiguration = this.databaseConfiguration(databaseIdentifier);
+        const lifecycle = this._configuration.getFrontendTenantSqliteLifecycle();
+        return await lifecycle.initialize(databaseIdentifier, databaseConfiguration, schemaGeneration, async () => {
+            await this._databaseOperation({
+                databaseIdentifier,
+                name: `Initialize frontend tenant database: ${databaseIdentifier}`,
+                requireReady: false,
+                schemaGeneration
+            }, async (operation) => {
+                const migrator = new Migrator({ configuration: this._configuration, databaseIdentifiers: [databaseIdentifier] });
+                operation.connection().clearSchemaCache();
+                await migrator.migrateRequireContextForDatabase({
+                    databaseConfiguration,
+                    databaseIdentifier,
+                    db: operation.connection(),
+                    requireContext: migrations
+                });
+                await this._configuration.initializeModels({ type: "frontend-tenant" });
+                for (const modelClass of Object.values(this._configuration.getModelClasses())) {
+                    if (modelClass.getDatabaseIdentifier({ tenant: this._tenant }) !== databaseIdentifier)
+                        continue;
+                    const table = await operation.connection().getTableByName(modelClass.tableName(), { throwError: false });
+                    if (!table && !modelClass.getEagerLoadRecordMetadata())
+                        continue;
+                    if (Object.keys(modelClass.getTranslationsMap()).length > 0) {
+                        const translationsTable = await operation.connection().getTableByName(modelClass.getTranslationsTableName(), { throwError: false });
+                        if (!translationsTable && !modelClass.getEagerLoadRecordMetadata())
+                            continue;
+                    }
+                    await operation.ensureModelInitialized(modelClass);
+                }
+            });
+        });
+    }
     /**
      * Flushes this captured SQLite identity.
      * @param {{databaseIdentifier: string}} options - Lifecycle options.
@@ -253,11 +311,23 @@ export default class TenantHandle {
      * @returns {Promise<T>} - Callback result.
      */
     async databaseOperation({ databaseIdentifier, name = "TenantHandle.databaseOperation" }, callback) {
+        return await this._databaseOperation({ databaseIdentifier, name, requireReady: true }, callback);
+    }
+    /**
+     * Runs a captured operation with explicit readiness policy. Initialization is
+     * the only caller allowed to enter an unready schema generation.
+     * @template T
+     * @param {{databaseIdentifier: string, name: string, requireReady: boolean, schemaGeneration?: string}} options - Internal operation options.
+     * @param {(operation: import("../database/operation.js").default) => Promise<T>} callback - Operation callback.
+     * @returns {Promise<T>} - Callback result.
+     */
+    async _databaseOperation({ databaseIdentifier, name, requireReady, schemaGeneration }, callback) {
         const databaseConfiguration = this.databaseConfiguration(databaseIdentifier);
-        return await this._configuration.getFrontendTenantSqliteLifecycle().databaseOperation(databaseIdentifier, databaseConfiguration, async () => await this._configuration.withDatabaseOperation({
+        return await this._configuration.getFrontendTenantSqliteLifecycle().databaseOperation(databaseIdentifier, databaseConfiguration, { requireReady, schemaGeneration }, async (operationSchemaGeneration) => await this._configuration.withDatabaseOperation({
             databaseConfiguration,
             databaseIdentifier,
             name,
+            schemaGeneration: operationSchemaGeneration,
             tenant: this._tenant
         }, callback));
     }
@@ -275,4 +345,4 @@ export default class TenantHandle {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenant-handle.js","sourceRoot":"","sources":["../../../src/tenants/tenant-handle.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * TenantDescriptorValue type.\n * @typedef {null | boolean | number | string | TenantDescriptorValue[] | {[key: string]: TenantDescriptorValue}} TenantDescriptorValue\n */\n/** @typedef {{[key: string]: TenantDescriptorValue}} TenantDescriptor */\n/** @typedef {{databaseIdentifier: string, dirty: boolean, lastUsed: number, pinCount: number, state: \"closed\" | \"closing\" | \"deleting\" | \"open\" | \"opening\"}} TenantSqliteLifecycleSnapshot */\n\n/**\n * Returns a readable path for a captured descriptor/configuration value.\n * @param {string} path - Parent path.\n * @param {string | number} key - Child key.\n * @returns {string} - Child path.\n */\nfunction childPath(path, key) {\n  if (typeof key === \"number\") return `${path}[${key}]`\n\n  return path ? `${path}.${key}` : key\n}\n\n/**\n * Returns the runtime class label for an unsupported capture value.\n * @param {object} value - Unsupported value.\n * @returns {string} - Runtime class label.\n */\nfunction valueClassName(value) {\n  return value.constructor?.name || \"object\"\n}\n\n/**\n * Defines one captured key without invoking inherited setters such as\n * `Object.prototype.__proto__`.\n * @param {Record<string, ReturnType<typeof JSON.parse>>} target - Captured object.\n * @param {string} key - Own key to define.\n * @param {ReturnType<typeof JSON.parse>} value - Captured value.\n */\nfunction defineCapturedDataProperty(target, key, value) {\n  Object.defineProperty(target, key, {\n    configurable: true,\n    enumerable: true,\n    value,\n    writable: true\n  })\n}\n\n/**\n * Deeply copies and freezes a JSON-compatible tenant descriptor value.\n * @param {ReturnType<typeof JSON.parse>} value - Value to capture.\n * @param {string} path - Descriptor path.\n * @param {Set<object>} ancestors - Active ancestor objects used for cycle detection.\n * @returns {TenantDescriptorValue} - Immutable captured value.\n */\nfunction captureTenantValue(value, path, ancestors) {\n  if (value === null || typeof value === \"string\" || typeof value === \"boolean\") return value\n  if (typeof value === \"number\" && Number.isFinite(value)) return value\n\n  if (!value || typeof value !== \"object\") {\n    throw new TypeError(`Tenant descriptor contains an unsupported value at ${path}: ${typeof value}`)\n  }\n  if (ancestors.has(value)) throw new TypeError(`Tenant descriptor contains a cycle at ${path}`)\n\n  ancestors.add(value)\n\n  try {\n    if (Array.isArray(value)) {\n      const capturedEntries = value.map((entry, index) => captureTenantValue(entry, childPath(path, index), ancestors))\n\n      Object.freeze(capturedEntries)\n\n      return capturedEntries\n    }\n\n    const prototype = Object.getPrototypeOf(value)\n\n    if (prototype !== Object.prototype && prototype !== null) {\n      throw new TypeError(`Tenant descriptor contains an unsupported value at ${path}: ${valueClassName(value)}`)\n    }\n\n    /** @type {TenantDescriptor} */\n    const captured = {}\n\n    for (const [key, entry] of Object.entries(value)) {\n      defineCapturedDataProperty(captured, key, captureTenantValue(entry, childPath(path, key), ancestors))\n    }\n\n    return Object.freeze(captured)\n  } finally {\n    ancestors.delete(value)\n  }\n}\n\n/**\n * Captures a root application tenant descriptor.\n * @param {object} tenant - Ordinary or null-prototype JSON-compatible tenant descriptor.\n * @returns {TenantDescriptor} - Immutable descriptor snapshot.\n */\nfunction captureTenant(tenant) {\n  return /** @type {TenantDescriptor} */ (captureTenantValue(tenant, \"\", new Set()))\n}\n\n/**\n * Deeply captures configuration values while retaining function/class identities.\n * Mutable non-plain runtime objects are rejected because retaining them would let\n * callers redirect a handle after construction.\n * @param {ReturnType<typeof JSON.parse>} value - Configuration value.\n * @param {string} path - Configuration path.\n * @param {Set<object>} ancestors - Active ancestor objects.\n * @returns {ReturnType<typeof JSON.parse>} - Immutable captured value.\n */\nfunction captureConfigurationValue(value, path, ancestors) {\n  if (value === null || value === undefined || typeof value === \"string\" || typeof value === \"boolean\" || typeof value === \"number\" || typeof value === \"function\") {\n    return value\n  }\n  if (typeof value !== \"object\") {\n    throw new TypeError(`Tenant database configuration contains an unsupported value at ${path}: ${typeof value}`)\n  }\n  if (ancestors.has(value)) throw new TypeError(`Tenant database configuration contains a cycle at ${path}`)\n\n  const prototype = Object.getPrototypeOf(value)\n\n  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {\n    if (Object.isFrozen(value)) return value\n\n    throw new TypeError(`Tenant database configuration contains an unsupported mutable value at ${path}: ${valueClassName(value)}`)\n  }\n\n  ancestors.add(value)\n\n  try {\n    if (Array.isArray(value)) {\n      return Object.freeze(value.map((entry, index) => captureConfigurationValue(entry, childPath(path, index), ancestors)))\n    }\n\n    /** @type {Record<string, ReturnType<typeof JSON.parse>>} */\n    const captured = {}\n\n    for (const [key, entry] of Object.entries(value)) {\n      defineCapturedDataProperty(captured, key, captureConfigurationValue(entry, childPath(path, key), ancestors))\n    }\n\n    return Object.freeze(captured)\n  } finally {\n    ancestors.delete(value)\n  }\n}\n\n/**\n * Copies and deeply freezes a resolved physical database configuration.\n * @param {import(\"../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Resolved database configuration.\n * @returns {import(\"../configuration-types.js\").DatabaseConfigurationType} - Captured configuration.\n */\nfunction captureDatabaseConfiguration(databaseConfiguration) {\n  return /** @type {import(\"../configuration-types.js\").DatabaseConfigurationType} */ (\n    captureConfigurationValue(databaseConfiguration, \"databaseConfiguration\", new Set())\n  )\n}\n\n/**\n * Immutable tenant/database handle. Physical database configurations are\n * resolved and captured at construction, so later ambient tenant changes\n * cannot redirect work performed through this handle.\n */\nexport default class TenantHandle {\n  /**\n   * Runs constructor.\n   * @param {object} args - Handle arguments.\n   * @param {import(\"../configuration.js\").default} args.configuration - Owning configuration.\n   * @param {object} args.tenant - Ordinary or null-prototype JSON-compatible application tenant descriptor.\n   */\n  constructor({configuration, tenant}) {\n    if (!configuration) throw new Error(\"TenantHandle requires a configuration\")\n    if (!tenant || typeof tenant !== \"object\" || Array.isArray(tenant)) {\n      throw new TypeError(\"TenantHandle requires a tenant object\")\n    }\n\n    const capturedTenant = captureTenant(tenant)\n    /** @type {Record<string, import(\"../configuration-types.js\").DatabaseConfigurationType>} */\n    const databaseConfigurations = Object.create(null)\n    const disabledIdentifiers = configuration.getDisabledDatabaseIdentifiers()\n\n    for (const identifier of Object.keys(configuration.getDatabaseConfiguration())) {\n      if (disabledIdentifiers.has(identifier)) continue\n      if (!configuration.isDatabaseIdentifierActive(identifier, capturedTenant)) continue\n\n      databaseConfigurations[identifier] = captureDatabaseConfiguration(\n        configuration.resolveDatabaseConfiguration(identifier, capturedTenant)\n      )\n    }\n\n    this._configuration = configuration\n    this._databaseConfigurations = Object.freeze(databaseConfigurations)\n    this._tenant = capturedTenant\n\n    Object.freeze(this)\n  }\n\n  /**\n   * Returns the captured tenant descriptor. Routing never re-resolves physical\n   * identity from this value after handle construction.\n   * @returns {TenantDescriptor} - Tenant descriptor.\n   */\n  tenant() {\n    return this._tenant\n  }\n\n  /**\n   * Returns the captured physical configuration for an active identifier.\n   * @param {string} databaseIdentifier - Logical database identifier.\n   * @returns {import(\"../configuration-types.js\").DatabaseConfigurationType} - Captured resolved configuration.\n   */\n  databaseConfiguration(databaseIdentifier) {\n    const databaseConfiguration = this._databaseConfigurations[databaseIdentifier]\n\n    if (!databaseConfiguration) {\n      throw new Error(`Unknown or inactive database identifier for tenant handle: ${databaseIdentifier}`)\n    }\n\n    return databaseConfiguration\n  }\n\n  /**\n   * Opens this captured SQLite identity.\n   * @param {{databaseIdentifier: string}} options - Lifecycle options.\n   * @returns {Promise<Readonly<TenantSqliteLifecycleSnapshot>>} - Safe lifecycle snapshot.\n   */\n  async open(options) {\n    const {databaseIdentifier} = options\n    return await this._configuration.getFrontendTenantSqliteLifecycle().open(databaseIdentifier, this.databaseConfiguration(databaseIdentifier))\n  }\n\n  /**\n   * Flushes this captured SQLite identity.\n   * @param {{databaseIdentifier: string}} options - Lifecycle options.\n   * @returns {Promise<Readonly<TenantSqliteLifecycleSnapshot>>} - Safe lifecycle snapshot.\n   */\n  async flush(options) {\n    const {databaseIdentifier} = options\n    return await this._configuration.getFrontendTenantSqliteLifecycle().flush(databaseIdentifier, this.databaseConfiguration(databaseIdentifier))\n  }\n\n  /**\n   * Closes this captured SQLite identity.\n   * @param {{databaseIdentifier: string, flush?: boolean}} options - Lifecycle options.\n   * @returns {Promise<Readonly<TenantSqliteLifecycleSnapshot>>} - Safe lifecycle snapshot.\n   */\n  async close(options) {\n    const {databaseIdentifier, flush = false} = options\n    return await this._configuration.getFrontendTenantSqliteLifecycle().close(databaseIdentifier, this.databaseConfiguration(databaseIdentifier), {flush})\n  }\n\n  /**\n   * Deletes this captured SQLite identity.\n   * @param {{databaseIdentifier: string}} options - Lifecycle options.\n   * @returns {Promise<Readonly<TenantSqliteLifecycleSnapshot>>} - Closed lifecycle snapshot.\n   */\n  async delete(options) {\n    const {databaseIdentifier} = options\n    return await this._configuration.getFrontendTenantSqliteLifecycle().delete(databaseIdentifier, this.databaseConfiguration(databaseIdentifier))\n  }\n\n  /**\n   * Inspects this captured SQLite identity.\n   * @param {{databaseIdentifier: string}} options - Lifecycle options.\n   * @returns {Readonly<TenantSqliteLifecycleSnapshot>} - Safe lifecycle snapshot.\n   */\n  inspect(options) {\n    const {databaseIdentifier} = options\n    return this._configuration.getFrontendTenantSqliteLifecycle().inspect(databaseIdentifier, this.databaseConfiguration(databaseIdentifier))\n  }\n\n  /**\n   * Runs work while this captured SQLite identity is protected from eviction.\n   * @template T\n   * @param {{databaseIdentifier: string}} options - Lifecycle options.\n   * @param {() => Promise<T>} callback - Pinned work.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async withPin({databaseIdentifier}, callback) {\n    return await this._configuration.getFrontendTenantSqliteLifecycle().withPin(databaseIdentifier, this.databaseConfiguration(databaseIdentifier), callback)\n  }\n\n  /**\n   * Runs explicit ORM work on one pinned connection for this handle's captured\n   * physical database. Use `operation.forModel(ModelClass)` for queries and\n   * writes; loaded records and association/preload work retain that operation.\n   * @template T\n   * @param {{databaseIdentifier: string, name?: string}} options - Logical database and checkout name.\n   * @param {(operation: import(\"../database/operation.js\").default) => Promise<T>} callback - Owned work callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async databaseOperation({databaseIdentifier, name = \"TenantHandle.databaseOperation\"}, callback) {\n    const databaseConfiguration = this.databaseConfiguration(databaseIdentifier)\n    return await this._configuration.getFrontendTenantSqliteLifecycle().databaseOperation(databaseIdentifier, databaseConfiguration, async () => await this._configuration.withDatabaseOperation({\n      databaseConfiguration,\n      databaseIdentifier,\n      name,\n      tenant: this._tenant\n    }, callback))\n  }\n\n  /**\n   * Runs explicit ORM work in a transaction pinned to this handle's captured\n   * physical database.\n   * @template T\n   * @param {{databaseIdentifier: string, name?: string}} options - Logical database and checkout name.\n   * @param {(operation: import(\"../database/operation.js\").default) => Promise<T>} callback - Transaction callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async transaction({databaseIdentifier, name = \"TenantHandle.transaction\"}, callback) {\n    return await this.databaseOperation({databaseIdentifier, name}, async (operation) => {\n      return await operation.transaction(async () => await callback(operation))\n    })\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenant-handle.js","sourceRoot":"","sources":["../../../src/tenants/tenant-handle.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Migrator from \"../database/migrator.js\"\n\n/**\n * TenantDescriptorValue type.\n * @typedef {null | boolean | number | string | TenantDescriptorValue[] | {[key: string]: TenantDescriptorValue}} TenantDescriptorValue\n */\n/** @typedef {{[key: string]: TenantDescriptorValue}} TenantDescriptor */\n/** @typedef {{databaseIdentifier: string, dirty: boolean, lastUsed: number, pinCount: number, ready: boolean, schemaGeneration: string | undefined, state: \"closed\" | \"closing\" | \"deleting\" | \"open\" | \"opening\"}} TenantSqliteLifecycleSnapshot */\n\n/**\n * Returns a readable path for a captured descriptor/configuration value.\n * @param {string} path - Parent path.\n * @param {string | number} key - Child key.\n * @returns {string} - Child path.\n */\nfunction childPath(path, key) {\n  if (typeof key === \"number\") return `${path}[${key}]`\n\n  return path ? `${path}.${key}` : key\n}\n\n/**\n * Returns the runtime class label for an unsupported capture value.\n * @param {object} value - Unsupported value.\n * @returns {string} - Runtime class label.\n */\nfunction valueClassName(value) {\n  return value.constructor?.name || \"object\"\n}\n\n/**\n * Defines one captured key without invoking inherited setters such as\n * `Object.prototype.__proto__`.\n * @param {Record<string, ReturnType<typeof JSON.parse>>} target - Captured object.\n * @param {string} key - Own key to define.\n * @param {ReturnType<typeof JSON.parse>} value - Captured value.\n */\nfunction defineCapturedDataProperty(target, key, value) {\n  Object.defineProperty(target, key, {\n    configurable: true,\n    enumerable: true,\n    value,\n    writable: true\n  })\n}\n\n/**\n * Deeply copies and freezes a JSON-compatible tenant descriptor value.\n * @param {ReturnType<typeof JSON.parse>} value - Value to capture.\n * @param {string} path - Descriptor path.\n * @param {Set<object>} ancestors - Active ancestor objects used for cycle detection.\n * @returns {TenantDescriptorValue} - Immutable captured value.\n */\nfunction captureTenantValue(value, path, ancestors) {\n  if (value === null || typeof value === \"string\" || typeof value === \"boolean\") return value\n  if (typeof value === \"number\" && Number.isFinite(value)) return value\n\n  if (!value || typeof value !== \"object\") {\n    throw new TypeError(`Tenant descriptor contains an unsupported value at ${path}: ${typeof value}`)\n  }\n  if (ancestors.has(value)) throw new TypeError(`Tenant descriptor contains a cycle at ${path}`)\n\n  ancestors.add(value)\n\n  try {\n    if (Array.isArray(value)) {\n      const capturedEntries = value.map((entry, index) => captureTenantValue(entry, childPath(path, index), ancestors))\n\n      Object.freeze(capturedEntries)\n\n      return capturedEntries\n    }\n\n    const prototype = Object.getPrototypeOf(value)\n\n    if (prototype !== Object.prototype && prototype !== null) {\n      throw new TypeError(`Tenant descriptor contains an unsupported value at ${path}: ${valueClassName(value)}`)\n    }\n\n    /** @type {TenantDescriptor} */\n    const captured = {}\n\n    for (const [key, entry] of Object.entries(value)) {\n      defineCapturedDataProperty(captured, key, captureTenantValue(entry, childPath(path, key), ancestors))\n    }\n\n    return Object.freeze(captured)\n  } finally {\n    ancestors.delete(value)\n  }\n}\n\n/**\n * Captures a root application tenant descriptor.\n * @param {object} tenant - Ordinary or null-prototype JSON-compatible tenant descriptor.\n * @returns {TenantDescriptor} - Immutable descriptor snapshot.\n */\nfunction captureTenant(tenant) {\n  return /** @type {TenantDescriptor} */ (captureTenantValue(tenant, \"\", new Set()))\n}\n\n/**\n * Deeply captures configuration values while retaining function/class identities.\n * Mutable non-plain runtime objects are rejected because retaining them would let\n * callers redirect a handle after construction.\n * @param {ReturnType<typeof JSON.parse>} value - Configuration value.\n * @param {string} path - Configuration path.\n * @param {Set<object>} ancestors - Active ancestor objects.\n * @returns {ReturnType<typeof JSON.parse>} - Immutable captured value.\n */\nfunction captureConfigurationValue(value, path, ancestors) {\n  if (value === null || value === undefined || typeof value === \"string\" || typeof value === \"boolean\" || typeof value === \"number\" || typeof value === \"function\") {\n    return value\n  }\n  if (typeof value !== \"object\") {\n    throw new TypeError(`Tenant database configuration contains an unsupported value at ${path}: ${typeof value}`)\n  }\n  if (ancestors.has(value)) throw new TypeError(`Tenant database configuration contains a cycle at ${path}`)\n\n  const prototype = Object.getPrototypeOf(value)\n\n  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {\n    if (Object.isFrozen(value)) return value\n\n    throw new TypeError(`Tenant database configuration contains an unsupported mutable value at ${path}: ${valueClassName(value)}`)\n  }\n\n  ancestors.add(value)\n\n  try {\n    if (Array.isArray(value)) {\n      return Object.freeze(value.map((entry, index) => captureConfigurationValue(entry, childPath(path, index), ancestors)))\n    }\n\n    /** @type {Record<string, ReturnType<typeof JSON.parse>>} */\n    const captured = {}\n\n    for (const [key, entry] of Object.entries(value)) {\n      defineCapturedDataProperty(captured, key, captureConfigurationValue(entry, childPath(path, key), ancestors))\n    }\n\n    return Object.freeze(captured)\n  } finally {\n    ancestors.delete(value)\n  }\n}\n\n/**\n * Copies and deeply freezes a resolved physical database configuration.\n * @param {import(\"../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Resolved database configuration.\n * @returns {import(\"../configuration-types.js\").DatabaseConfigurationType} - Captured configuration.\n */\nfunction captureDatabaseConfiguration(databaseConfiguration) {\n  return /** @type {import(\"../configuration-types.js\").DatabaseConfigurationType} */ (\n    captureConfigurationValue(databaseConfiguration, \"databaseConfiguration\", new Set())\n  )\n}\n\n/**\n * Immutable tenant/database handle. Physical database configurations are\n * resolved and captured at construction, so later ambient tenant changes\n * cannot redirect work performed through this handle.\n */\nexport default class TenantHandle {\n  /**\n   * Runs constructor.\n   * @param {object} args - Handle arguments.\n   * @param {import(\"../configuration.js\").default} args.configuration - Owning configuration.\n   * @param {object} args.tenant - Ordinary or null-prototype JSON-compatible application tenant descriptor.\n   */\n  constructor({configuration, tenant}) {\n    if (!configuration) throw new Error(\"TenantHandle requires a configuration\")\n    if (!tenant || typeof tenant !== \"object\" || Array.isArray(tenant)) {\n      throw new TypeError(\"TenantHandle requires a tenant object\")\n    }\n\n    const capturedTenant = captureTenant(tenant)\n    /** @type {Record<string, import(\"../configuration-types.js\").DatabaseConfigurationType>} */\n    const databaseConfigurations = Object.create(null)\n    const disabledIdentifiers = configuration.getDisabledDatabaseIdentifiers()\n\n    for (const identifier of Object.keys(configuration.getDatabaseConfiguration())) {\n      if (disabledIdentifiers.has(identifier)) continue\n      if (!configuration.isDatabaseIdentifierActive(identifier, capturedTenant)) continue\n\n      databaseConfigurations[identifier] = captureDatabaseConfiguration(\n        configuration.resolveDatabaseConfiguration(identifier, capturedTenant)\n      )\n    }\n\n    this._configuration = configuration\n    this._databaseConfigurations = Object.freeze(databaseConfigurations)\n    this._tenant = capturedTenant\n\n    Object.freeze(this)\n  }\n\n  /**\n   * Returns the captured tenant descriptor. Routing never re-resolves physical\n   * identity from this value after handle construction.\n   * @returns {TenantDescriptor} - Tenant descriptor.\n   */\n  tenant() {\n    return this._tenant\n  }\n\n  /**\n   * Rejects using this handle with a different Configuration instance.\n   * @param {import(\"../configuration.js\").default} configuration - Expected owner.\n   * @returns {void}\n   */\n  assertConfiguration(configuration) {\n    if (configuration !== this._configuration) {\n      throw new Error(\"Tenant handle belongs to a different Velocious configuration\")\n    }\n  }\n\n  /**\n   * Returns the captured physical configuration for an active identifier.\n   * @param {string} databaseIdentifier - Logical database identifier.\n   * @returns {import(\"../configuration-types.js\").DatabaseConfigurationType} - Captured resolved configuration.\n   */\n  databaseConfiguration(databaseIdentifier) {\n    const databaseConfiguration = this._databaseConfigurations[databaseIdentifier]\n\n    if (!databaseConfiguration) {\n      throw new Error(`Unknown or inactive database identifier for tenant handle: ${databaseIdentifier}`)\n    }\n\n    return databaseConfiguration\n  }\n\n  /**\n   * Opens this captured SQLite identity.\n   * @param {{databaseIdentifier: string}} options - Lifecycle options.\n   * @returns {Promise<Readonly<TenantSqliteLifecycleSnapshot>>} - Safe lifecycle snapshot.\n   */\n  async open(options) {\n    const {databaseIdentifier} = options\n    return await this._configuration.getFrontendTenantSqliteLifecycle().open(databaseIdentifier, this.databaseConfiguration(databaseIdentifier))\n  }\n\n  /**\n   * Opens, migrates, and initializes record metadata for one captured physical\n   * tenant SQLite database and application schema generation.\n   * @param {object} options - Initialization options.\n   * @param {string} options.databaseIdentifier - Tenant-only logical database identifier.\n   * @param {import(\"../database/migrator/types.js\").RequireMigrationContextType} options.migrations - Frontend migration require context.\n   * @param {string} options.schemaGeneration - Stable application schema generation.\n   * @returns {Promise<Readonly<TenantSqliteLifecycleSnapshot>>} - Ready lifecycle snapshot.\n   */\n  async initialize({databaseIdentifier, migrations, schemaGeneration}) {\n    if (!migrations || typeof migrations !== \"function\" || typeof migrations.keys !== \"function\") {\n      throw new TypeError(\"TenantHandle.initialize requires a migrations require context\")\n    }\n\n    const databaseConfiguration = this.databaseConfiguration(databaseIdentifier)\n    const lifecycle = this._configuration.getFrontendTenantSqliteLifecycle()\n\n    return await lifecycle.initialize(databaseIdentifier, databaseConfiguration, schemaGeneration, async () => {\n      await this._databaseOperation({\n        databaseIdentifier,\n        name: `Initialize frontend tenant database: ${databaseIdentifier}`,\n        requireReady: false,\n        schemaGeneration\n      }, async (operation) => {\n        const migrator = new Migrator({configuration: this._configuration, databaseIdentifiers: [databaseIdentifier]})\n\n        operation.connection().clearSchemaCache()\n        await migrator.migrateRequireContextForDatabase({\n          databaseConfiguration,\n          databaseIdentifier,\n          db: operation.connection(),\n          requireContext: migrations\n        })\n        await this._configuration.initializeModels({type: \"frontend-tenant\"})\n\n        for (const modelClass of Object.values(this._configuration.getModelClasses())) {\n          if (modelClass.getDatabaseIdentifier({tenant: this._tenant}) !== databaseIdentifier) continue\n          const table = await operation.connection().getTableByName(modelClass.tableName(), {throwError: false})\n\n          if (!table && !modelClass.getEagerLoadRecordMetadata()) continue\n          if (Object.keys(modelClass.getTranslationsMap()).length > 0) {\n            const translationsTable = await operation.connection().getTableByName(modelClass.getTranslationsTableName(), {throwError: false})\n\n            if (!translationsTable && !modelClass.getEagerLoadRecordMetadata()) continue\n          }\n\n          await operation.ensureModelInitialized(modelClass)\n        }\n      })\n    })\n  }\n\n  /**\n   * Flushes this captured SQLite identity.\n   * @param {{databaseIdentifier: string}} options - Lifecycle options.\n   * @returns {Promise<Readonly<TenantSqliteLifecycleSnapshot>>} - Safe lifecycle snapshot.\n   */\n  async flush(options) {\n    const {databaseIdentifier} = options\n    return await this._configuration.getFrontendTenantSqliteLifecycle().flush(databaseIdentifier, this.databaseConfiguration(databaseIdentifier))\n  }\n\n  /**\n   * Closes this captured SQLite identity.\n   * @param {{databaseIdentifier: string, flush?: boolean}} options - Lifecycle options.\n   * @returns {Promise<Readonly<TenantSqliteLifecycleSnapshot>>} - Safe lifecycle snapshot.\n   */\n  async close(options) {\n    const {databaseIdentifier, flush = false} = options\n    return await this._configuration.getFrontendTenantSqliteLifecycle().close(databaseIdentifier, this.databaseConfiguration(databaseIdentifier), {flush})\n  }\n\n  /**\n   * Deletes this captured SQLite identity.\n   * @param {{databaseIdentifier: string}} options - Lifecycle options.\n   * @returns {Promise<Readonly<TenantSqliteLifecycleSnapshot>>} - Closed lifecycle snapshot.\n   */\n  async delete(options) {\n    const {databaseIdentifier} = options\n    return await this._configuration.getFrontendTenantSqliteLifecycle().delete(databaseIdentifier, this.databaseConfiguration(databaseIdentifier))\n  }\n\n  /**\n   * Inspects this captured SQLite identity.\n   * @param {{databaseIdentifier: string}} options - Lifecycle options.\n   * @returns {Readonly<TenantSqliteLifecycleSnapshot>} - Safe lifecycle snapshot.\n   */\n  inspect(options) {\n    const {databaseIdentifier} = options\n    return this._configuration.getFrontendTenantSqliteLifecycle().inspect(databaseIdentifier, this.databaseConfiguration(databaseIdentifier))\n  }\n\n  /**\n   * Runs work while this captured SQLite identity is protected from eviction.\n   * @template T\n   * @param {{databaseIdentifier: string}} options - Lifecycle options.\n   * @param {() => Promise<T>} callback - Pinned work.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async withPin({databaseIdentifier}, callback) {\n    return await this._configuration.getFrontendTenantSqliteLifecycle().withPin(databaseIdentifier, this.databaseConfiguration(databaseIdentifier), callback)\n  }\n\n  /**\n   * Runs explicit ORM work on one pinned connection for this handle's captured\n   * physical database. Use `operation.forModel(ModelClass)` for queries and\n   * writes; loaded records and association/preload work retain that operation.\n   * @template T\n   * @param {{databaseIdentifier: string, name?: string}} options - Logical database and checkout name.\n   * @param {(operation: import(\"../database/operation.js\").default) => Promise<T>} callback - Owned work callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async databaseOperation({databaseIdentifier, name = \"TenantHandle.databaseOperation\"}, callback) {\n    return await this._databaseOperation({databaseIdentifier, name, requireReady: true}, callback)\n  }\n\n  /**\n   * Runs a captured operation with explicit readiness policy. Initialization is\n   * the only caller allowed to enter an unready schema generation.\n   * @template T\n   * @param {{databaseIdentifier: string, name: string, requireReady: boolean, schemaGeneration?: string}} options - Internal operation options.\n   * @param {(operation: import(\"../database/operation.js\").default) => Promise<T>} callback - Operation callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async _databaseOperation({databaseIdentifier, name, requireReady, schemaGeneration}, callback) {\n    const databaseConfiguration = this.databaseConfiguration(databaseIdentifier)\n\n    return await this._configuration.getFrontendTenantSqliteLifecycle().databaseOperation(\n      databaseIdentifier,\n      databaseConfiguration,\n      {requireReady, schemaGeneration},\n      async (operationSchemaGeneration) => await this._configuration.withDatabaseOperation({\n        databaseConfiguration,\n        databaseIdentifier,\n        name,\n        schemaGeneration: operationSchemaGeneration,\n        tenant: this._tenant\n      }, callback)\n    )\n  }\n\n  /**\n   * Runs explicit ORM work in a transaction pinned to this handle's captured\n   * physical database.\n   * @template T\n   * @param {{databaseIdentifier: string, name?: string}} options - Logical database and checkout name.\n   * @param {(operation: import(\"../database/operation.js\").default) => Promise<T>} callback - Transaction callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async transaction({databaseIdentifier, name = \"TenantHandle.transaction\"}, callback) {\n    return await this.databaseOperation({databaseIdentifier, name}, async (operation) => {\n      return await operation.transaction(async () => await callback(operation))\n    })\n  }\n}\n"]}

package/build/src/testing/browser-test-app.js

@@ -2,6 +2,7 @@
 import SystemTestBrowserHelper from "system-testing/build/system-test-browser-helper.js";
 import BrowserEnvironmentHandler from "../environment-handlers/browser.js";
 import runFrontendModelEventHookScenario from "./browser-frontend-model-event-hook-scenarios.js";
+import runUseDatabaseSelectionTransitionScenario from "./browser-use-database-hook-scenarios.js";
 const root = document.getElementById("root") || (() => {
     const element = document.createElement("div");
     element.id = "root";
@@ -21,6 +22,7 @@ systemTestBrowserHelper.enableOnBrowser();
 Object.assign(globalThis, { velociousBrowserTest: {
         BrowserEnvironmentHandler,
         runFrontendModelEventHookScenario,
+        runUseDatabaseSelectionTransitionScenario,
         systemTestBrowserHelper
     } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/testing/browser-use-database-hook-scenarios.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Flushes real React hook transitions and reports synchronous selection state,
+ * inline loader stability, and stale completion suppression.
+ * @returns {Promise<{firstChangedLoaded: boolean, initialLoaded: boolean, loaderCalls: string[], loadedAfterInlineLoaderRerender: boolean, thirdAfterStaleCompletion: {error: string | null, loaded: boolean}}>} - Render observations.
+ */
+export default function runUseDatabaseSelectionTransitionScenario(): Promise<{
+    firstChangedLoaded: boolean;
+    initialLoaded: boolean;
+    loaderCalls: string[];
+    loadedAfterInlineLoaderRerender: boolean;
+    thirdAfterStaleCompletion: {
+        error: string | null;
+        loaded: boolean;
+    };
+}>;
+//# sourceMappingURL=browser-use-database-hook-scenarios.d.ts.map

package/build/src/testing/browser-use-database-hook-scenarios.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-use-database-hook-scenarios.d.ts","sourceRoot":"","sources":["../../../src/testing/browser-use-database-hook-scenarios.js"],"names":[],"mappings":"AA6DA;;;;GAIG;AACH,wBAA8B,yCAAyC,IAF1D,OAAO,CAAC;IAAC,kBAAkB,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAC;IAAC,+BAA+B,EAAE,OAAO,CAAC;IAAC,yBAAyB,EAAE;QAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAC,CAAA;CAAC,CAAC,CA2I/M"}

package/build/src/testing/browser-use-database-hook-scenarios.js

@@ -0,0 +1,182 @@
+// @ts-check
+import React, { act } from "react";
+import { createRoot } from "react-dom/client";
+import Configuration, { CurrentConfigurationNotSetError } from "../configuration.js";
+import BrowserEnvironmentHandler from "../environment-handlers/browser.js";
+import Migration from "../database/migration/index.js";
+import SingleMultiUsePool from "../database/pool/single-multi-use.js";
+import SqliteWebDriver from "../database/drivers/sqlite/index.web.js";
+import TenantHandle from "../tenants/tenant-handle.js";
+import useDatabase from "../database/use-database.js";
+/**
+ * Returns the current configuration without requiring one to exist.
+ * @returns {Configuration | undefined} - Current configuration when installed.
+ */
+function currentConfigurationOrUndefined() {
+    try {
+        return Configuration.current();
+    }
+    catch (error) {
+        if (!(error instanceof CurrentConfigurationNotSetError))
+            throw error;
+        return undefined;
+    }
+}
+/**
+ * Builds the scoped browser configuration used by the real hook scenario.
+ * @returns {Configuration} - Browser test configuration.
+ */
+function buildHookConfiguration() {
+    return new Configuration({
+        database: {
+            test: {
+                projectTenant: {
+                    driver: SqliteWebDriver,
+                    getConnection: async () => { throw new Error("Hook scenario must not open a physical database"); },
+                    migrations: true,
+                    name: "use-database-hook-template",
+                    poolType: SingleMultiUsePool,
+                    tenantOnly: true,
+                    type: "sqlite"
+                }
+            }
+        },
+        directory: "/use-database-hook-scenario",
+        environment: "test",
+        environmentHandler: new BrowserEnvironmentHandler(),
+        initializeModels: async () => { },
+        locale: "en",
+        localeFallbacks: { en: ["en"] },
+        locales: ["en"],
+        tenantDatabaseResolver: ({ identifier, tenant }) => {
+            if (identifier !== "projectTenant" || !tenant || typeof tenant !== "object")
+                return;
+            return { name: `use-database-hook-${String(/** @type {{slug?: string}} */ (tenant).slug)}` };
+        }
+    });
+}
+/**
+ * Flushes real React hook transitions and reports synchronous selection state,
+ * inline loader stability, and stale completion suppression.
+ * @returns {Promise<{firstChangedLoaded: boolean, initialLoaded: boolean, loaderCalls: string[], loadedAfterInlineLoaderRerender: boolean, thirdAfterStaleCompletion: {error: string | null, loaded: boolean}}>} - Render observations.
+ */
+export default async function runUseDatabaseSelectionTransitionScenario() {
+    const container = document.createElement("div");
+    document.body.appendChild(container);
+    const root = createRoot(container);
+    /** @type {{error: string | null, loaded: boolean, selection: "first" | "second" | "third"}[]} */
+    const renders = [];
+    /** @type {string[]} */
+    const loaderCalls = [];
+    /**
+     * Releases the deliberately stale second initialization.
+     * @type {() => void}
+     */
+    let releaseSecondInitialization = () => { };
+    const secondInitializationRelease = new Promise((resolve) => { releaseSecondInitialization = () => resolve(undefined); });
+    /**
+     * Signals that the deliberately stale second initialization started.
+     * @type {() => void}
+     */
+    let signalSecondInitialization = () => { };
+    const secondInitializationStarted = new Promise((resolve) => { signalSecondInitialization = () => resolve(undefined); });
+    class HookTenantHandle extends TenantHandle {
+        /**
+         * Runs test initialization without touching a physical database.
+         * @param {{migrations: import("../database/migrator/types.js").RequireMigrationContextType}} args - Hook initialization arguments.
+         * @returns {Promise<Readonly<ReturnType<TenantHandle["inspect"]>>>} - Ready test snapshot.
+         */
+        async initialize({ migrations }) {
+            loaderCalls.push(migrations.id);
+            if (this.tenant().slug === "second") {
+                signalSecondInitialization();
+                await secondInitializationRelease;
+                throw new Error("SECOND_SELECTION_FAILED");
+            }
+            return Object.freeze({ databaseIdentifier: "projectTenant", dirty: false, lastUsed: 0, pinCount: 0, ready: true, schemaGeneration: "generation-1", state: "open" });
+        }
+    }
+    const previousConfiguration = currentConfigurationOrUndefined();
+    const restorationConfiguration = previousConfiguration || buildHookConfiguration();
+    const configuration = buildHookConfiguration();
+    configuration.setCurrent();
+    const firstHandle = new HookTenantHandle({ configuration, tenant: { slug: "first" } });
+    const secondHandle = new HookTenantHandle({ configuration, tenant: { slug: "second" } });
+    const thirdHandle = new HookTenantHandle({ configuration, tenant: { slug: "third" } });
+    const renderCounts = { first: 0, second: 0, third: 0 };
+    /**
+     * Runs hook probe.
+     * @param {{selection: "first" | "second" | "third", tenantHandle: HookTenantHandle}} props - Probe props.
+     * @returns {React.ReactElement} - Empty host element.
+     */
+    function HookProbe({ selection, tenantHandle }) {
+        const state = useDatabase({
+            databaseIdentifier: "projectTenant",
+            migrationsRequireContextCallback: async () => {
+                /**
+                 * Looks up an empty migration context entry recreated by every probe render.
+                 * @param {string} fileName - Requested migration file.
+                 * @returns {{default: typeof Migration}} - Placeholder migration module.
+                 * @type {import("../database/migrator/types.js").RequireMigrationContextType}
+                 */
+                const emptyMigrations = (fileName) => {
+                    if (!fileName)
+                        throw new Error("Migration context lookup requires a file name");
+                    return { default: Migration };
+                };
+                emptyMigrations.keys = () => [];
+                emptyMigrations.id = selection;
+                return emptyMigrations;
+            },
+            schemaGeneration: "generation-1",
+            tenantHandle
+        });
+        renderCounts[selection]++;
+        if (renderCounts[selection] > 20)
+            throw new Error(`useDatabase render loop for ${selection}`);
+        renders.push({ error: state.error?.message || null, loaded: state.loaded, selection });
+        return React.createElement("div");
+    }
+    try {
+        await act(async () => {
+            root.render(React.createElement(HookProbe, { selection: "first", tenantHandle: firstHandle }));
+        });
+        const initialRender = renders.at(-1);
+        await act(async () => {
+            root.render(React.createElement(HookProbe, { selection: "first", tenantHandle: firstHandle }));
+        });
+        const loadedAfterInlineLoaderRerender = renders.at(-1)?.loaded;
+        act(() => {
+            root.render(React.createElement(HookProbe, { selection: "second", tenantHandle: secondHandle }));
+        });
+        const firstChangedRender = renders.find((render) => render.selection === "second");
+        await secondInitializationStarted;
+        await act(async () => {
+            root.render(React.createElement(HookProbe, { selection: "third", tenantHandle: thirdHandle }));
+        });
+        releaseSecondInitialization();
+        await act(async () => { await secondInitializationRelease; });
+        const thirdAfterStaleCompletion = renders.at(-1);
+        if (!initialRender || !firstChangedRender || !thirdAfterStaleCompletion || loadedAfterInlineLoaderRerender === undefined) {
+            throw new Error("useDatabase hook scenario did not render every selection");
+        }
+        return {
+            firstChangedLoaded: firstChangedRender.loaded,
+            initialLoaded: initialRender.loaded,
+            loaderCalls,
+            loadedAfterInlineLoaderRerender,
+            thirdAfterStaleCompletion: {
+                error: thirdAfterStaleCompletion.error,
+                loaded: thirdAfterStaleCompletion.loaded
+            }
+        };
+    }
+    finally {
+        releaseSecondInitialization();
+        await act(async () => { root.unmount(); });
+        container.remove();
+        restorationConfiguration.setCurrent();
+        await configuration.closeDatabaseConnections();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browser-use-database-hook-scenarios.js","sourceRoot":"","sources":["../../../src/testing/browser-use-database-hook-scenarios.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport React, { act } from \"react\"\nimport {createRoot} from \"react-dom/client\"\n\nimport Configuration, {CurrentConfigurationNotSetError} from \"../configuration.js\"\nimport BrowserEnvironmentHandler from \"../environment-handlers/browser.js\"\nimport Migration from \"../database/migration/index.js\"\nimport SingleMultiUsePool from \"../database/pool/single-multi-use.js\"\nimport SqliteWebDriver from \"../database/drivers/sqlite/index.web.js\"\nimport TenantHandle from \"../tenants/tenant-handle.js\"\nimport useDatabase from \"../database/use-database.js\"\n\n/**\n * Returns the current configuration without requiring one to exist.\n * @returns {Configuration | undefined} - Current configuration when installed.\n */\nfunction currentConfigurationOrUndefined() {\n  try {\n    return Configuration.current()\n  } catch (error) {\n    if (!(error instanceof CurrentConfigurationNotSetError)) throw error\n\n    return undefined\n  }\n}\n\n/**\n * Builds the scoped browser configuration used by the real hook scenario.\n * @returns {Configuration} - Browser test configuration.\n */\nfunction buildHookConfiguration() {\n  return new Configuration({\n    database: {\n      test: {\n        projectTenant: {\n          driver: SqliteWebDriver,\n          getConnection: async () => { throw new Error(\"Hook scenario must not open a physical database\") },\n          migrations: true,\n          name: \"use-database-hook-template\",\n          poolType: SingleMultiUsePool,\n          tenantOnly: true,\n          type: \"sqlite\"\n        }\n      }\n    },\n    directory: \"/use-database-hook-scenario\",\n    environment: \"test\",\n    environmentHandler: new BrowserEnvironmentHandler(),\n    initializeModels: async () => {},\n    locale: \"en\",\n    localeFallbacks: {en: [\"en\"]},\n    locales: [\"en\"],\n    tenantDatabaseResolver: ({identifier, tenant}) => {\n      if (identifier !== \"projectTenant\" || !tenant || typeof tenant !== \"object\") return\n\n      return {name: `use-database-hook-${String(/** @type {{slug?: string}} */ (tenant).slug)}`}\n    }\n  })\n}\n\n/**\n * Flushes real React hook transitions and reports synchronous selection state,\n * inline loader stability, and stale completion suppression.\n * @returns {Promise<{firstChangedLoaded: boolean, initialLoaded: boolean, loaderCalls: string[], loadedAfterInlineLoaderRerender: boolean, thirdAfterStaleCompletion: {error: string | null, loaded: boolean}}>} - Render observations.\n */\nexport default async function runUseDatabaseSelectionTransitionScenario() {\n  const container = document.createElement(\"div\")\n  document.body.appendChild(container)\n  const root = createRoot(container)\n  /** @type {{error: string | null, loaded: boolean, selection: \"first\" | \"second\" | \"third\"}[]} */\n  const renders = []\n  /** @type {string[]} */\n  const loaderCalls = []\n  /**\n   * Releases the deliberately stale second initialization.\n   * @type {() => void}\n   */\n  let releaseSecondInitialization = () => {}\n  const secondInitializationRelease = new Promise((resolve) => { releaseSecondInitialization = () => resolve(undefined) })\n  /**\n   * Signals that the deliberately stale second initialization started.\n   * @type {() => void}\n   */\n  let signalSecondInitialization = () => {}\n  const secondInitializationStarted = new Promise((resolve) => { signalSecondInitialization = () => resolve(undefined) })\n\n  class HookTenantHandle extends TenantHandle {\n    /**\n     * Runs test initialization without touching a physical database.\n     * @param {{migrations: import(\"../database/migrator/types.js\").RequireMigrationContextType}} args - Hook initialization arguments.\n     * @returns {Promise<Readonly<ReturnType<TenantHandle[\"inspect\"]>>>} - Ready test snapshot.\n     */\n    async initialize({migrations}) {\n      loaderCalls.push(migrations.id)\n\n      if (this.tenant().slug === \"second\") {\n        signalSecondInitialization()\n        await secondInitializationRelease\n        throw new Error(\"SECOND_SELECTION_FAILED\")\n      }\n\n      return Object.freeze({databaseIdentifier: \"projectTenant\", dirty: false, lastUsed: 0, pinCount: 0, ready: true, schemaGeneration: \"generation-1\", state: \"open\"})\n    }\n  }\n  const previousConfiguration = currentConfigurationOrUndefined()\n  const restorationConfiguration = previousConfiguration || buildHookConfiguration()\n  const configuration = buildHookConfiguration()\n\n  configuration.setCurrent()\n\n  const firstHandle = new HookTenantHandle({configuration, tenant: {slug: \"first\"}})\n  const secondHandle = new HookTenantHandle({configuration, tenant: {slug: \"second\"}})\n  const thirdHandle = new HookTenantHandle({configuration, tenant: {slug: \"third\"}})\n  const renderCounts = {first: 0, second: 0, third: 0}\n\n  /**\n   * Runs hook probe.\n   * @param {{selection: \"first\" | \"second\" | \"third\", tenantHandle: HookTenantHandle}} props - Probe props.\n   * @returns {React.ReactElement} - Empty host element.\n   */\n  function HookProbe({selection, tenantHandle}) {\n    const state = useDatabase({\n      databaseIdentifier: \"projectTenant\",\n      migrationsRequireContextCallback: async () => {\n        /**\n         * Looks up an empty migration context entry recreated by every probe render.\n         * @param {string} fileName - Requested migration file.\n         * @returns {{default: typeof Migration}} - Placeholder migration module.\n         * @type {import(\"../database/migrator/types.js\").RequireMigrationContextType}\n         */\n        const emptyMigrations = (fileName) => {\n          if (!fileName) throw new Error(\"Migration context lookup requires a file name\")\n\n          return {default: Migration}\n        }\n\n        emptyMigrations.keys = () => []\n        emptyMigrations.id = selection\n\n        return emptyMigrations\n      },\n      schemaGeneration: \"generation-1\",\n      tenantHandle\n    })\n\n    renderCounts[selection]++\n    if (renderCounts[selection] > 20) throw new Error(`useDatabase render loop for ${selection}`)\n    renders.push({error: state.error?.message || null, loaded: state.loaded, selection})\n\n    return React.createElement(\"div\")\n  }\n\n  try {\n    await act(async () => {\n      root.render(React.createElement(HookProbe, {selection: \"first\", tenantHandle: firstHandle}))\n    })\n\n    const initialRender = renders.at(-1)\n\n    await act(async () => {\n      root.render(React.createElement(HookProbe, {selection: \"first\", tenantHandle: firstHandle}))\n    })\n\n    const loadedAfterInlineLoaderRerender = renders.at(-1)?.loaded\n\n    act(() => {\n      root.render(React.createElement(HookProbe, {selection: \"second\", tenantHandle: secondHandle}))\n    })\n\n    const firstChangedRender = renders.find((render) => render.selection === \"second\")\n    await secondInitializationStarted\n\n    await act(async () => {\n      root.render(React.createElement(HookProbe, {selection: \"third\", tenantHandle: thirdHandle}))\n    })\n\n    releaseSecondInitialization()\n    await act(async () => { await secondInitializationRelease })\n\n    const thirdAfterStaleCompletion = renders.at(-1)\n\n    if (!initialRender || !firstChangedRender || !thirdAfterStaleCompletion || loadedAfterInlineLoaderRerender === undefined) {\n      throw new Error(\"useDatabase hook scenario did not render every selection\")\n    }\n\n    return {\n      firstChangedLoaded: firstChangedRender.loaded,\n      initialLoaded: initialRender.loaded,\n      loaderCalls,\n      loadedAfterInlineLoaderRerender,\n      thirdAfterStaleCompletion: {\n        error: thirdAfterStaleCompletion.error,\n        loaded: thirdAfterStaleCompletion.loaded\n      }\n    }\n  } finally {\n    releaseSecondInitialization()\n    await act(async () => { root.unmount() })\n    container.remove()\n    restorationConfiguration.setCurrent()\n    await configuration.closeDatabaseConnections()\n  }\n}\n"]}

package/build/src/testing/test-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-runner.d.ts","sourceRoot":"","sources":["../../../src/testing/test-runner.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"test-runner.d.ts","sourceRoot":"","sources":["../../../src/testing/test-runner.js"],"names":[],"mappings":"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"}