velocious 1.0.674 → 1.0.676

package/build/src/database/query/order-base.d.ts

@@ -17,6 +17,12 @@ export default class VelociousDatabaseQueryOrderBase {
      * @returns {void} - No return value.
      */
     setReverseOrder(_reverseOrder: boolean): void;
+    /**
+     * Runs reversed copy.
+     * @abstract
+     * @returns {import("./order-base.js").default} - A new independent order with the direction reversed.
+     */
+    reversedCopy(): import("./order-base.js").default;
     toSql(): void;
 }
 //# sourceMappingURL=order-base.d.ts.map

package/build/src/database/query/order-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"order-base.d.ts","sourceRoot":"","sources":["../../../../src/database/query/order-base.js"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,OAAO,+BAA+B;IAM3C,KAAK;IALZ;;;OAGG;IACH,YAAY,KAAK,EAFN,OAAO,YAAY,EAAE,OAEf,EAEhB;IAED;;;OAGG;IACH,UAAU,IAFG,OAAO,4BAA4B,EAAE,OAAO,CAIxD;IAED;;;;;OAKG;IACH,eAAe,CAAC,aAAa,EAHlB,OAGkB,GAFhB,IAAI,CAIhB;IAED,KAAK,SAEJ;CACF"}
+{"version":3,"file":"order-base.d.ts","sourceRoot":"","sources":["../../../../src/database/query/order-base.js"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,OAAO,+BAA+B;IAM3C,KAAK;IALZ;;;OAGG;IACH,YAAY,KAAK,EAFN,OAAO,YAAY,EAAE,OAEf,EAEhB;IAED;;;OAGG;IACH,UAAU,IAFG,OAAO,4BAA4B,EAAE,OAAO,CAIxD;IAED;;;;;OAKG;IACH,eAAe,CAAC,aAAa,EAHlB,OAGkB,GAFhB,IAAI,CAIhB;IAED;;;;OAIG;IACH,YAAY,IAFC,OAAO,iBAAiB,EAAE,OAAO,CAI7C;IAED,KAAK,SAEJ;CACF"}

package/build/src/database/query/order-base.js

@@ -23,8 +23,16 @@ export default class VelociousDatabaseQueryOrderBase {
     setReverseOrder(_reverseOrder) {
         throw new Error("setReverseOrder not implemented");
     }
+    /**
+     * Runs reversed copy.
+     * @abstract
+     * @returns {import("./order-base.js").default} - A new independent order with the direction reversed.
+     */
+    reversedCopy() {
+        throw new Error("reversedCopy not implemented");
+    }
     toSql() {
         throw new Error("'toSql' wasn't implemented");
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JkZXItYmFzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kYXRhYmFzZS9xdWVyeS9vcmRlci1iYXNlLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVk7QUFFWixNQUFNLENBQUMsT0FBTyxPQUFPLCtCQUErQjtJQUNsRDs7O09BR0c7SUFDSCxZQUFZLEtBQUs7UUFDZixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQTtJQUNwQixDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsVUFBVTtRQUNSLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsT0FBTyxFQUFFLENBQUE7SUFDcEMsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0gsZUFBZSxDQUFDLGFBQWE7UUFDM0IsTUFBTSxJQUFJLEtBQUssQ0FBQyxpQ0FBaUMsQ0FBQyxDQUFBO0lBQ3BELENBQUM7SUFFRCxLQUFLO1FBQ0gsTUFBTSxJQUFJLEtBQUssQ0FBQyw0QkFBNEIsQ0FBQyxDQUFBO0lBQy9DLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBWZWxvY2lvdXNEYXRhYmFzZVF1ZXJ5T3JkZXJCYXNlIHtcbiAgLyoqXG4gICAqIFJ1bnMgY29uc3RydWN0b3IuXG4gICAqIEBwYXJhbSB7aW1wb3J0KFwiLi9pbmRleC5qc1wiKS5kZWZhdWx0fSBxdWVyeSAtIFF1ZXJ5IGluc3RhbmNlLlxuICAgKi9cbiAgY29uc3RydWN0b3IocXVlcnkpIHtcbiAgICB0aGlzLnF1ZXJ5ID0gcXVlcnlcbiAgfVxuXG4gIC8qKlxuICAgKiBSdW5zIGdldCBvcHRpb25zLlxuICAgKiBAcmV0dXJucyB7aW1wb3J0KFwiLi4vcXVlcnktcGFyc2VyL29wdGlvbnMuanNcIikuZGVmYXVsdH0gLSBUaGUgb3B0aW9ucyBvcHRpb25zLlxuICAgKi9cbiAgZ2V0T3B0aW9ucygpIHtcbiAgICByZXR1cm4gdGhpcy5xdWVyeS5kcml2ZXIub3B0aW9ucygpXG4gIH1cblxuICAvKipcbiAgICogUnVucyBzZXQgcmV2ZXJzZSBvcmRlci5cbiAgICogQGFic3RyYWN0XG4gICAqIEBwYXJhbSB7Ym9vbGVhbn0gX3JldmVyc2VPcmRlciAtIFdoZXRoZXIgcmV2ZXJzZSBvcmRlci5cbiAgICogQHJldHVybnMge3ZvaWR9IC0gTm8gcmV0dXJuIHZhbHVlLlxuICAgKi9cbiAgc2V0UmV2ZXJzZU9yZGVyKF9yZXZlcnNlT3JkZXIpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoXCJzZXRSZXZlcnNlT3JkZXIgbm90IGltcGxlbWVudGVkXCIpXG4gIH1cblxuICB0b1NxbCgpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoXCIndG9TcWwnIHdhc24ndCBpbXBsZW1lbnRlZFwiKVxuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/database/query/order-column.d.ts

@@ -30,6 +30,11 @@ export default class VelociousDatabaseQueryOrderColumn extends OrderBase {
      * @returns {void}
      */
     setReverseOrder(reverseOrder?: boolean): void;
+    /**
+     * Runs reversed copy.
+     * @returns {VelociousDatabaseQueryOrderColumn} - A new independent order reversing the effective (rendered) direction.
+     */
+    reversedCopy(): VelociousDatabaseQueryOrderColumn;
     /**
      * Runs to sql.
      * @returns {string} - SQL string.

package/build/src/database/query/order-column.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"order-column.d.ts","sourceRoot":"","sources":["../../../../src/database/query/order-column.js"],"names":[],"mappings":"AAEA,OAAO,SAAS,MAAM,iBAAiB,CAAA;AAIpC,YAAkB,gBAAgB,GAClC;;;;IAAmB,MAAM,EAAd,MAAM,CACjB;;;;IAA6C,SAAS,AAAtD,CACA,EADW,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,CAC1C;;;;IAAoB,SAAS,AAA7B,CACF,EADa,MAAM,CACnB;CAAA,CAAA;AAyBD,MAAM,CAAC,OAAO,OAAO,iCAAkC,SAAQ,SAAS;IAW/D,MAAM;IACN,SAAS;IACT,YAAY;IACZ,SAAS;IAbhB;;;;OAIG;IACH,YAAY,KAAK,EAHN,OAAO,YAAY,EAAE,OAGf,EAAE,KAAK,EAFb,gBAEa,EASvB;IAED;;;;OAIG;IACH,eAAe,CAAC,YAAY,AAHzB,CACA,EADQ,OAGwB,GAFtB,IAAI,CAIhB;IAED;;;OAGG;IACH,KAAK,IAFQ,MAAM,CAYlB;CACF"}
+{"version":3,"file":"order-column.d.ts","sourceRoot":"","sources":["../../../../src/database/query/order-column.js"],"names":[],"mappings":"AAEA,OAAO,SAAS,MAAM,iBAAiB,CAAA;AAIpC,YAAkB,gBAAgB,GAClC;;;;IAAmB,MAAM,EAAd,MAAM,CACjB;;;;IAA6C,SAAS,AAAtD,CACA,EADW,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,CAC1C;;;;IAAoB,SAAS,AAA7B,CACF,EADa,MAAM,CACnB;CAAA,CAAA;AAyBD,MAAM,CAAC,OAAO,OAAO,iCAAkC,SAAQ,SAAS;IAW/D,MAAM;IACN,SAAS;IACT,YAAY;IACZ,SAAS;IAbhB;;;;OAIG;IACH,YAAY,KAAK,EAHN,OAAO,YAAY,EAAE,OAGf,EAAE,KAAK,EAFb,gBAEa,EASvB;IAED;;;;OAIG;IACH,eAAe,CAAC,YAAY,AAHzB,CACA,EADQ,OAGwB,GAFtB,IAAI,CAIhB;IAED;;;OAGG;IACH,YAAY,IAFC,iCAAiC,CAM7C;IAED;;;OAGG;IACH,KAAK,IAFQ,MAAM,CAYlB;CACF"}

package/build/src/database/query/order-column.js

@@ -51,6 +51,14 @@ export default class VelociousDatabaseQueryOrderColumn extends OrderBase {
     setReverseOrder(reverseOrder = true) {
         this.reverseOrder = reverseOrder;
     }
+    /**
+     * Runs reversed copy.
+     * @returns {VelociousDatabaseQueryOrderColumn} - A new independent order reversing the effective (rendered) direction.
+     */
+    reversedCopy() {
+        const direction = this.reverseOrder ? this.direction : reverseDirection(this.direction);
+        return new VelociousDatabaseQueryOrderColumn(this.query, { column: this.column, direction, tableName: this.tableName });
+    }
     /**
      * Runs to sql.
      * @returns {string} - SQL string.
@@ -65,4 +73,4 @@ export default class VelociousDatabaseQueryOrderColumn extends OrderBase {
         return sql;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/database/query/order-plain.d.ts

@@ -9,6 +9,11 @@ export default class VelociousDatabaseQueryOrderPlain extends OrderBase {
      */
     constructor(query: import("./index.js").default, plain: string);
     setReverseOrder(): void;
+    /**
+     * Runs reversed copy.
+     * @returns {VelociousDatabaseQueryOrderPlain} - A new independent order reversing the effective (rendered) direction; a directionless plain order renders DESC.
+     */
+    reversedCopy(): VelociousDatabaseQueryOrderPlain;
     toSql(): string;
 }
 //# sourceMappingURL=order-plain.d.ts.map

package/build/src/database/query/order-plain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"order-plain.d.ts","sourceRoot":"","sources":["../../../../src/database/query/order-plain.js"],"names":[],"mappings":"AAEA,OAAO,SAAS,MAAM,iBAAiB,CAAA;AAEvC,MAAM,CAAC,OAAO,OAAO,gCAAiC,SAAQ,SAAS;IAQ9D,KAAK;IACL,YAAY;IARnB;;;;OAIG;IACH,YAAY,KAAK,EAHN,OAAO,YAAY,EAAE,OAGf,EAAE,KAAK,EAFb,MAEa,EAIvB;IAED,eAAe,SAEd;IAED,KAAK,WAMJ;CACF"}
+{"version":3,"file":"order-plain.d.ts","sourceRoot":"","sources":["../../../../src/database/query/order-plain.js"],"names":[],"mappings":"AAEA,OAAO,SAAS,MAAM,iBAAiB,CAAA;AAEvC,MAAM,CAAC,OAAO,OAAO,gCAAiC,SAAQ,SAAS;IAQ9D,KAAK;IACL,YAAY;IARnB;;;;OAIG;IACH,YAAY,KAAK,EAHN,OAAO,YAAY,EAAE,OAGf,EAAE,KAAK,EAFb,MAEa,EAIvB;IAED,eAAe,SAEd;IAED;;;OAGG;IACH,YAAY,IAFC,gCAAgC,CAY5C;IAED,KAAK,WAMJ;CACF"}

package/build/src/database/query/order-plain.js

@@ -14,6 +14,19 @@ export default class VelociousDatabaseQueryOrderPlain extends OrderBase {
     setReverseOrder() {
         this.reverseOrder = true;
     }
+    /**
+     * Runs reversed copy.
+     * @returns {VelociousDatabaseQueryOrderPlain} - A new independent order reversing the effective (rendered) direction; a directionless plain order renders DESC.
+     */
+    reversedCopy() {
+        const effective = this.reverseOrder ? `${this.plain} DESC` : this.plain;
+        const match = effective.match(/^(.*\S)\s+(ASC|DESC)$/i);
+        if (match) {
+            const direction = match[2].toUpperCase() == "ASC" ? "DESC" : "ASC";
+            return new VelociousDatabaseQueryOrderPlain(this.query, `${match[1]} ${direction}`);
+        }
+        return new VelociousDatabaseQueryOrderPlain(this.query, `${effective} DESC`);
+    }
     toSql() {
         if (this.reverseOrder) {
             return `${this.plain} DESC`;
@@ -21,4 +34,4 @@ export default class VelociousDatabaseQueryOrderPlain extends OrderBase {
         return this.plain;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JkZXItcGxhaW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGF0YWJhc2UvcXVlcnkvb3JkZXItcGxhaW4uanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaLE9BQU8sU0FBUyxNQUFNLGlCQUFpQixDQUFBO0FBRXZDLE1BQU0sQ0FBQyxPQUFPLE9BQU8sZ0NBQWlDLFNBQVEsU0FBUztJQUNyRTs7OztPQUlHO0lBQ0gsWUFBWSxLQUFLLEVBQUUsS0FBSztRQUN0QixLQUFLLENBQUMsS0FBSyxDQUFDLENBQUE7UUFDWixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQTtRQUNsQixJQUFJLENBQUMsWUFBWSxHQUFHLEtBQUssQ0FBQTtJQUMzQixDQUFDO0lBRUQsZUFBZTtRQUNiLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFBO0lBQzFCLENBQUM7SUFFRCxLQUFLO1FBQ0gsSUFBSSxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7WUFDdEIsT0FBTyxHQUFHLElBQUksQ0FBQyxLQUFLLE9BQU8sQ0FBQTtRQUM3QixDQUFDO1FBRUQsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFBO0lBQ25CLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuXG5pbXBvcnQgT3JkZXJCYXNlIGZyb20gXCIuL29yZGVyLWJhc2UuanNcIlxuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBWZWxvY2lvdXNEYXRhYmFzZVF1ZXJ5T3JkZXJQbGFpbiBleHRlbmRzIE9yZGVyQmFzZSB7XG4gIC8qKlxuICAgKiBSdW5zIGNvbnN0cnVjdG9yLlxuICAgKiBAcGFyYW0ge2ltcG9ydChcIi4vaW5kZXguanNcIikuZGVmYXVsdH0gcXVlcnkgLSBRdWVyeSBpbnN0YW5jZS5cbiAgICogQHBhcmFtIHtzdHJpbmd9IHBsYWluIC0gUGxhaW4uXG4gICAqL1xuICBjb25zdHJ1Y3RvcihxdWVyeSwgcGxhaW4pIHtcbiAgICBzdXBlcihxdWVyeSlcbiAgICB0aGlzLnBsYWluID0gcGxhaW5cbiAgICB0aGlzLnJldmVyc2VPcmRlciA9IGZhbHNlXG4gIH1cblxuICBzZXRSZXZlcnNlT3JkZXIoKSB7XG4gICAgdGhpcy5yZXZlcnNlT3JkZXIgPSB0cnVlXG4gIH1cblxuICB0b1NxbCgpIHtcbiAgICBpZiAodGhpcy5yZXZlcnNlT3JkZXIpIHtcbiAgICAgIHJldHVybiBgJHt0aGlzLnBsYWlufSBERVNDYFxuICAgIH1cblxuICAgIHJldHVybiB0aGlzLnBsYWluXG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/testing/browser-frontend-tenant-database-scenarios.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Exercises two durable physical tenant databases inside the real browser.
+ * @returns {Promise<{alphaNames: ReturnType<typeof JSON.parse>[], betaNames: ReturnType<typeof JSON.parse>[], identitiesAreDistinct: boolean, openCount: number}>} Serializable proof result.
+ */
+export default function runFrontendTenantDatabasePersistenceScenario(): Promise<{
+    alphaNames: ReturnType<typeof JSON.parse>[];
+    betaNames: ReturnType<typeof JSON.parse>[];
+    identitiesAreDistinct: boolean;
+    openCount: number;
+}>;
+//# sourceMappingURL=browser-frontend-tenant-database-scenarios.d.ts.map

package/build/src/testing/browser-frontend-tenant-database-scenarios.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-frontend-tenant-database-scenarios.d.ts","sourceRoot":"","sources":["../../../src/testing/browser-frontend-tenant-database-scenarios.js"],"names":[],"mappings":"AAiEA;;;GAGG;AACH,wBAA8B,4CAA4C,IAF7D,OAAO,CAAC;IAAC,UAAU,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;IAAC,SAAS,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;IAAC,qBAAqB,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,CAAC,CA0FjK"}

package/build/src/testing/browser-frontend-tenant-database-scenarios.js

@@ -0,0 +1,147 @@
+// @ts-check
+import Configuration, { CurrentConfigurationNotSetError } from "../configuration.js";
+import DatabaseRecord from "../database/record/index.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 Tenant from "../tenants/tenant.js";
+const DATABASE_IDENTIFIER = "projectTenant";
+const SCHEMA_GENERATION = "frontend-tenant-browser-persistence-1";
+/**
+ * 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 real browser-backed two-project configuration.
+ * @returns {Configuration} Browser tenant configuration.
+ */
+function buildConfiguration() {
+    return new Configuration({
+        database: {
+            test: {
+                projectTenant: {
+                    driver: SqliteWebDriver,
+                    locateFile: () => "/sql-wasm.wasm",
+                    migrations: true,
+                    name: "velocious-browser-project-proof-template",
+                    poolType: SingleMultiUsePool,
+                    tenantOnly: true,
+                    type: "sqlite"
+                }
+            }
+        },
+        directory: "/frontend-tenant-browser-persistence-scenario",
+        environment: "test",
+        environmentHandler: new BrowserEnvironmentHandler(),
+        frontendTenantSqlite: { maxOpenHandles: 2 },
+        initializeModels: async () => { },
+        locale: "en",
+        localeFallbacks: { en: ["en"] },
+        locales: ["en"],
+        tenantDatabaseResolver: ({ identifier, tenant }) => {
+            if (identifier !== DATABASE_IDENTIFIER || !tenant || typeof tenant !== "object")
+                return;
+            const projectSlug = /** @type {{projectSlug?: string}} */ (tenant).projectSlug;
+            if (projectSlug !== "alpha" && projectSlug !== "beta")
+                return;
+            return { name: `velocious-browser-project-proof-${projectSlug}` };
+        }
+    });
+}
+/**
+ * Exercises two durable physical tenant databases inside the real browser.
+ * @returns {Promise<{alphaNames: ReturnType<typeof JSON.parse>[], betaNames: ReturnType<typeof JSON.parse>[], identitiesAreDistinct: boolean, openCount: number}>} Serializable proof result.
+ */
+export default async function runFrontendTenantDatabasePersistenceScenario() {
+    const previousConfiguration = currentConfigurationOrUndefined();
+    const configuration = buildConfiguration();
+    class BrowserProjectRecord extends DatabaseRecord {
+    }
+    class CreateBrowserProjectRecords extends Migration {
+        async up() {
+            await this.execute("CREATE TABLE browser_project_records(id integer PRIMARY KEY AUTOINCREMENT, name varchar(255) NOT NULL)");
+        }
+    }
+    BrowserProjectRecord.setTableName("browser_project_records");
+    BrowserProjectRecord.switchesTenantDatabase(DATABASE_IDENTIFIER);
+    BrowserProjectRecord.registerRecordClass({ configuration });
+    CreateBrowserProjectRecords.onDatabases([DATABASE_IDENTIFIER]);
+    const migrationFile = "20260919090000-create-browser-project-records.js";
+    /**
+     * Loads the one migration bundled into this browser proof.
+     * @type {import("../database/migrator/types.js").RequireMigrationContextType}
+     */
+    const migrations = (fileName) => {
+        if (fileName !== migrationFile)
+            throw new Error(`Unknown browser tenant proof migration: ${fileName}`);
+        return { default: CreateBrowserProjectRecords };
+    };
+    migrations.keys = () => [migrationFile];
+    migrations.id = "frontend-tenant-browser-persistence-scenario";
+    const alpha = Tenant.handle({ projectSlug: "alpha" }, configuration);
+    const beta = Tenant.handle({ projectSlug: "beta" }, configuration);
+    configuration.setCurrent();
+    try {
+        await Promise.all([
+            alpha.delete({ databaseIdentifier: DATABASE_IDENTIFIER }),
+            beta.delete({ databaseIdentifier: DATABASE_IDENTIFIER })
+        ]);
+        await Promise.all([
+            alpha.initialize({ databaseIdentifier: DATABASE_IDENTIFIER, migrations, schemaGeneration: SCHEMA_GENERATION }),
+            beta.initialize({ databaseIdentifier: DATABASE_IDENTIFIER, migrations, schemaGeneration: SCHEMA_GENERATION })
+        ]);
+        for (let index = 0; index < 12; index++) {
+            await Promise.all([
+                alpha.databaseOperation({ databaseIdentifier: DATABASE_IDENTIFIER }, async (operation) => {
+                    await operation.forModel(BrowserProjectRecord).create({ name: `alpha-${index}` });
+                }),
+                beta.databaseOperation({ databaseIdentifier: DATABASE_IDENTIFIER }, async (operation) => {
+                    await operation.forModel(BrowserProjectRecord).create({ name: `beta-${index}` });
+                })
+            ]);
+        }
+        await Promise.all([
+            alpha.close({ databaseIdentifier: DATABASE_IDENTIFIER, flush: true }),
+            beta.close({ databaseIdentifier: DATABASE_IDENTIFIER, flush: true })
+        ]);
+        await Promise.all([
+            alpha.initialize({ databaseIdentifier: DATABASE_IDENTIFIER, migrations, schemaGeneration: SCHEMA_GENERATION }),
+            beta.initialize({ databaseIdentifier: DATABASE_IDENTIFIER, migrations, schemaGeneration: SCHEMA_GENERATION })
+        ]);
+        const [alphaNames, betaNames] = await Promise.all([
+            alpha.databaseOperation({ databaseIdentifier: DATABASE_IDENTIFIER }, async (operation) => {
+                return await operation.forModel(BrowserProjectRecord).order("id").pluck("name");
+            }),
+            beta.databaseOperation({ databaseIdentifier: DATABASE_IDENTIFIER }, async (operation) => {
+                return await operation.forModel(BrowserProjectRecord).order("id").pluck("name");
+            })
+        ]);
+        return {
+            alphaNames,
+            betaNames,
+            identitiesAreDistinct: alpha.databaseIdentity(DATABASE_IDENTIFIER) !== beta.databaseIdentity(DATABASE_IDENTIFIER),
+            openCount: configuration.inspectFrontendTenantSqliteHandles().openCount
+        };
+    }
+    finally {
+        await Promise.all([
+            alpha.delete({ databaseIdentifier: DATABASE_IDENTIFIER }),
+            beta.delete({ databaseIdentifier: DATABASE_IDENTIFIER })
+        ]);
+        if (previousConfiguration)
+            previousConfiguration.setCurrent();
+        await configuration.closeDatabaseConnections();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browser-frontend-tenant-database-scenarios.js","sourceRoot":"","sources":["../../../src/testing/browser-frontend-tenant-database-scenarios.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Configuration, { CurrentConfigurationNotSetError } from \"../configuration.js\"\nimport DatabaseRecord from \"../database/record/index.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 Tenant from \"../tenants/tenant.js\"\n\nconst DATABASE_IDENTIFIER = \"projectTenant\"\nconst SCHEMA_GENERATION = \"frontend-tenant-browser-persistence-1\"\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 real browser-backed two-project configuration.\n * @returns {Configuration} Browser tenant configuration.\n */\nfunction buildConfiguration() {\n  return new Configuration({\n    database: {\n      test: {\n        projectTenant: {\n          driver: SqliteWebDriver,\n          locateFile: () => \"/sql-wasm.wasm\",\n          migrations: true,\n          name: \"velocious-browser-project-proof-template\",\n          poolType: SingleMultiUsePool,\n          tenantOnly: true,\n          type: \"sqlite\"\n        }\n      }\n    },\n    directory: \"/frontend-tenant-browser-persistence-scenario\",\n    environment: \"test\",\n    environmentHandler: new BrowserEnvironmentHandler(),\n    frontendTenantSqlite: {maxOpenHandles: 2},\n    initializeModels: async () => {},\n    locale: \"en\",\n    localeFallbacks: {en: [\"en\"]},\n    locales: [\"en\"],\n    tenantDatabaseResolver: ({identifier, tenant}) => {\n      if (identifier !== DATABASE_IDENTIFIER || !tenant || typeof tenant !== \"object\") return\n      const projectSlug = /** @type {{projectSlug?: string}} */ (tenant).projectSlug\n\n      if (projectSlug !== \"alpha\" && projectSlug !== \"beta\") return\n\n      return {name: `velocious-browser-project-proof-${projectSlug}`}\n    }\n  })\n}\n\n/**\n * Exercises two durable physical tenant databases inside the real browser.\n * @returns {Promise<{alphaNames: ReturnType<typeof JSON.parse>[], betaNames: ReturnType<typeof JSON.parse>[], identitiesAreDistinct: boolean, openCount: number}>} Serializable proof result.\n */\nexport default async function runFrontendTenantDatabasePersistenceScenario() {\n  const previousConfiguration = currentConfigurationOrUndefined()\n  const configuration = buildConfiguration()\n\n  class BrowserProjectRecord extends DatabaseRecord {}\n  class CreateBrowserProjectRecords extends Migration {\n    async up() {\n      await this.execute(\"CREATE TABLE browser_project_records(id integer PRIMARY KEY AUTOINCREMENT, name varchar(255) NOT NULL)\")\n    }\n  }\n\n  BrowserProjectRecord.setTableName(\"browser_project_records\")\n  BrowserProjectRecord.switchesTenantDatabase(DATABASE_IDENTIFIER)\n  BrowserProjectRecord.registerRecordClass({configuration})\n  CreateBrowserProjectRecords.onDatabases([DATABASE_IDENTIFIER])\n\n  const migrationFile = \"20260919090000-create-browser-project-records.js\"\n  /**\n   * Loads the one migration bundled into this browser proof.\n   * @type {import(\"../database/migrator/types.js\").RequireMigrationContextType}\n   */\n  const migrations = (fileName) => {\n    if (fileName !== migrationFile) throw new Error(`Unknown browser tenant proof migration: ${fileName}`)\n\n    return {default: CreateBrowserProjectRecords}\n  }\n\n  migrations.keys = () => [migrationFile]\n  migrations.id = \"frontend-tenant-browser-persistence-scenario\"\n\n  const alpha = Tenant.handle({projectSlug: \"alpha\"}, configuration)\n  const beta = Tenant.handle({projectSlug: \"beta\"}, configuration)\n\n  configuration.setCurrent()\n\n  try {\n    await Promise.all([\n      alpha.delete({databaseIdentifier: DATABASE_IDENTIFIER}),\n      beta.delete({databaseIdentifier: DATABASE_IDENTIFIER})\n    ])\n    await Promise.all([\n      alpha.initialize({databaseIdentifier: DATABASE_IDENTIFIER, migrations, schemaGeneration: SCHEMA_GENERATION}),\n      beta.initialize({databaseIdentifier: DATABASE_IDENTIFIER, migrations, schemaGeneration: SCHEMA_GENERATION})\n    ])\n\n    for (let index = 0; index < 12; index++) {\n      await Promise.all([\n        alpha.databaseOperation({databaseIdentifier: DATABASE_IDENTIFIER}, async (operation) => {\n          await operation.forModel(BrowserProjectRecord).create({name: `alpha-${index}`})\n        }),\n        beta.databaseOperation({databaseIdentifier: DATABASE_IDENTIFIER}, async (operation) => {\n          await operation.forModel(BrowserProjectRecord).create({name: `beta-${index}`})\n        })\n      ])\n    }\n\n    await Promise.all([\n      alpha.close({databaseIdentifier: DATABASE_IDENTIFIER, flush: true}),\n      beta.close({databaseIdentifier: DATABASE_IDENTIFIER, flush: true})\n    ])\n    await Promise.all([\n      alpha.initialize({databaseIdentifier: DATABASE_IDENTIFIER, migrations, schemaGeneration: SCHEMA_GENERATION}),\n      beta.initialize({databaseIdentifier: DATABASE_IDENTIFIER, migrations, schemaGeneration: SCHEMA_GENERATION})\n    ])\n\n    const [alphaNames, betaNames] = await Promise.all([\n      alpha.databaseOperation({databaseIdentifier: DATABASE_IDENTIFIER}, async (operation) => {\n        return await operation.forModel(BrowserProjectRecord).order(\"id\").pluck(\"name\")\n      }),\n      beta.databaseOperation({databaseIdentifier: DATABASE_IDENTIFIER}, async (operation) => {\n        return await operation.forModel(BrowserProjectRecord).order(\"id\").pluck(\"name\")\n      })\n    ])\n\n    return {\n      alphaNames,\n      betaNames,\n      identitiesAreDistinct: alpha.databaseIdentity(DATABASE_IDENTIFIER) !== beta.databaseIdentity(DATABASE_IDENTIFIER),\n      openCount: configuration.inspectFrontendTenantSqliteHandles().openCount\n    }\n  } finally {\n    await Promise.all([\n      alpha.delete({databaseIdentifier: DATABASE_IDENTIFIER}),\n      beta.delete({databaseIdentifier: DATABASE_IDENTIFIER})\n    ])\n    if (previousConfiguration) previousConfiguration.setCurrent()\n    await configuration.closeDatabaseConnections()\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 runFrontendTenantDatabasePersistenceScenario from "./browser-frontend-tenant-database-scenarios.js";
 import runUseDatabaseSelectionTransitionScenario from "./browser-use-database-hook-scenarios.js";
 const root = document.getElementById("root") || (() => {
     const element = document.createElement("div");
@@ -22,7 +23,8 @@ systemTestBrowserHelper.enableOnBrowser();
 Object.assign(globalThis, { velociousBrowserTest: {
         BrowserEnvironmentHandler,
         runFrontendModelEventHookScenario,
+        runFrontendTenantDatabasePersistenceScenario,
         runUseDatabaseSelectionTransitionScenario,
         systemTestBrowserHelper
     } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJvd3Nlci10ZXN0LWFwcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90ZXN0aW5nL2Jyb3dzZXItdGVzdC1hcHAuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaLE9BQU8sdUJBQXVCLE1BQU0sb0RBQW9ELENBQUE7QUFDeEYsT0FBTyx5QkFBeUIsTUFBTSxvQ0FBb0MsQ0FBQTtBQUMxRSxPQUFPLGlDQUFpQyxNQUFNLGtEQUFrRCxDQUFBO0FBQ2hHLE9BQU8seUNBQXlDLE1BQU0sMENBQTBDLENBQUE7QUFFaEcsTUFBTSxJQUFJLEdBQUcsUUFBUSxDQUFDLGNBQWMsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRTtJQUNwRCxNQUFNLE9BQU8sR0FBRyxRQUFRLENBQUMsYUFBYSxDQUFDLEtBQUssQ0FBQyxDQUFBO0lBQzdDLE9BQU8sQ0FBQyxFQUFFLEdBQUcsTUFBTSxDQUFBO0lBQ25CLFFBQVEsQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxDQUFBO0lBQ2xDLE9BQU8sT0FBTyxDQUFBO0FBQ2hCLENBQUMsQ0FBQyxFQUFFLENBQUE7QUFFSixNQUFNLHNCQUFzQixHQUFHLFFBQVEsQ0FBQyxhQUFhLENBQUMsS0FBSyxDQUFDLENBQUE7QUFDNUQsc0JBQXNCLENBQUMsWUFBWSxDQUFDLGFBQWEsRUFBRSx3QkFBd0IsQ0FBQyxDQUFBO0FBQzVFLHNCQUFzQixDQUFDLFlBQVksQ0FBQyxlQUFlLEVBQUUsTUFBTSxDQUFDLENBQUE7QUFFNUQsTUFBTSxTQUFTLEdBQUcsUUFBUSxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUMsQ0FBQTtBQUMvQyxTQUFTLENBQUMsWUFBWSxDQUFDLGFBQWEsRUFBRSxXQUFXLENBQUMsQ0FBQTtBQUNsRCxTQUFTLENBQUMsV0FBVyxHQUFHLE9BQU8sQ0FBQTtBQUUvQixzQkFBc0IsQ0FBQyxXQUFXLENBQUMsU0FBUyxDQUFDLENBQUE7QUFDN0MsSUFBSSxDQUFDLFdBQVcsQ0FBQyxzQkFBc0IsQ0FBQyxDQUFBO0FBRXhDLE1BQU0sdUJBQXVCLEdBQUcsSUFBSSx1QkFBdUIsRUFBRSxDQUFBO0FBQzdELHVCQUF1QixDQUFDLGVBQWUsRUFBRSxDQUFBO0FBRXpDLE1BQU0sQ0FBQyxNQUFNLENBQUMsVUFBVSxFQUFFLEVBQUMsb0JBQW9CLEVBQUU7UUFDL0MseUJBQXlCO1FBQ3pCLGlDQUFpQztRQUNqQyx5Q0FBeUM7UUFDekMsdUJBQXVCO0tBQ3hCLEVBQUMsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbmltcG9ydCBTeXN0ZW1UZXN0QnJvd3NlckhlbHBlciBmcm9tIFwic3lzdGVtLXRlc3RpbmcvYnVpbGQvc3lzdGVtLXRlc3QtYnJvd3Nlci1oZWxwZXIuanNcIlxuaW1wb3J0IEJyb3dzZXJFbnZpcm9ubWVudEhhbmRsZXIgZnJvbSBcIi4uL2Vudmlyb25tZW50LWhhbmRsZXJzL2Jyb3dzZXIuanNcIlxuaW1wb3J0IHJ1bkZyb250ZW5kTW9kZWxFdmVudEhvb2tTY2VuYXJpbyBmcm9tIFwiLi9icm93c2VyLWZyb250ZW5kLW1vZGVsLWV2ZW50LWhvb2stc2NlbmFyaW9zLmpzXCJcbmltcG9ydCBydW5Vc2VEYXRhYmFzZVNlbGVjdGlvblRyYW5zaXRpb25TY2VuYXJpbyBmcm9tIFwiLi9icm93c2VyLXVzZS1kYXRhYmFzZS1ob29rLXNjZW5hcmlvcy5qc1wiXG5cbmNvbnN0IHJvb3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZChcInJvb3RcIikgfHwgKCgpID0+IHtcbiAgY29uc3QgZWxlbWVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoXCJkaXZcIilcbiAgZWxlbWVudC5pZCA9IFwicm9vdFwiXG4gIGRvY3VtZW50LmJvZHkuYXBwZW5kQ2hpbGQoZWxlbWVudClcbiAgcmV0dXJuIGVsZW1lbnRcbn0pKClcblxuY29uc3Qgc3lzdGVtVGVzdGluZ0NvbXBvbmVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoXCJkaXZcIilcbnN5c3RlbVRlc3RpbmdDb21wb25lbnQuc2V0QXR0cmlidXRlKFwiZGF0YS10ZXN0aWRcIiwgXCJzeXN0ZW1UZXN0aW5nQ29tcG9uZW50XCIpXG5zeXN0ZW1UZXN0aW5nQ29tcG9uZW50LnNldEF0dHJpYnV0ZShcImRhdGEtZm9jdXNzZWRcIiwgXCJ0cnVlXCIpXG5cbmNvbnN0IGJsYW5rVGV4dCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoXCJkaXZcIilcbmJsYW5rVGV4dC5zZXRBdHRyaWJ1dGUoXCJkYXRhLXRlc3RpZFwiLCBcImJsYW5rVGV4dFwiKVxuYmxhbmtUZXh0LnRleHRDb250ZW50ID0gXCJibGFua1wiXG5cbnN5c3RlbVRlc3RpbmdDb21wb25lbnQuYXBwZW5kQ2hpbGQoYmxhbmtUZXh0KVxucm9vdC5hcHBlbmRDaGlsZChzeXN0ZW1UZXN0aW5nQ29tcG9uZW50KVxuXG5jb25zdCBzeXN0ZW1UZXN0QnJvd3NlckhlbHBlciA9IG5ldyBTeXN0ZW1UZXN0QnJvd3NlckhlbHBlcigpXG5zeXN0ZW1UZXN0QnJvd3NlckhlbHBlci5lbmFibGVPbkJyb3dzZXIoKVxuXG5PYmplY3QuYXNzaWduKGdsb2JhbFRoaXMsIHt2ZWxvY2lvdXNCcm93c2VyVGVzdDoge1xuICBCcm93c2VyRW52aXJvbm1lbnRIYW5kbGVyLFxuICBydW5Gcm9udGVuZE1vZGVsRXZlbnRIb29rU2NlbmFyaW8sXG4gIHJ1blVzZURhdGFiYXNlU2VsZWN0aW9uVHJhbnNpdGlvblNjZW5hcmlvLFxuICBzeXN0ZW1UZXN0QnJvd3NlckhlbHBlclxufX0pXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/build/testing/browser-frontend-tenant-database-scenarios.js

@@ -0,0 +1,158 @@
+// @ts-check
+
+import Configuration, { CurrentConfigurationNotSetError } from "../configuration.js"
+import DatabaseRecord from "../database/record/index.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 Tenant from "../tenants/tenant.js"
+
+const DATABASE_IDENTIFIER = "projectTenant"
+const SCHEMA_GENERATION = "frontend-tenant-browser-persistence-1"
+
+/**
+ * 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 real browser-backed two-project configuration.
+ * @returns {Configuration} Browser tenant configuration.
+ */
+function buildConfiguration() {
+  return new Configuration({
+    database: {
+      test: {
+        projectTenant: {
+          driver: SqliteWebDriver,
+          locateFile: () => "/sql-wasm.wasm",
+          migrations: true,
+          name: "velocious-browser-project-proof-template",
+          poolType: SingleMultiUsePool,
+          tenantOnly: true,
+          type: "sqlite"
+        }
+      }
+    },
+    directory: "/frontend-tenant-browser-persistence-scenario",
+    environment: "test",
+    environmentHandler: new BrowserEnvironmentHandler(),
+    frontendTenantSqlite: {maxOpenHandles: 2},
+    initializeModels: async () => {},
+    locale: "en",
+    localeFallbacks: {en: ["en"]},
+    locales: ["en"],
+    tenantDatabaseResolver: ({identifier, tenant}) => {
+      if (identifier !== DATABASE_IDENTIFIER || !tenant || typeof tenant !== "object") return
+      const projectSlug = /** @type {{projectSlug?: string}} */ (tenant).projectSlug
+
+      if (projectSlug !== "alpha" && projectSlug !== "beta") return
+
+      return {name: `velocious-browser-project-proof-${projectSlug}`}
+    }
+  })
+}
+
+/**
+ * Exercises two durable physical tenant databases inside the real browser.
+ * @returns {Promise<{alphaNames: ReturnType<typeof JSON.parse>[], betaNames: ReturnType<typeof JSON.parse>[], identitiesAreDistinct: boolean, openCount: number}>} Serializable proof result.
+ */
+export default async function runFrontendTenantDatabasePersistenceScenario() {
+  const previousConfiguration = currentConfigurationOrUndefined()
+  const configuration = buildConfiguration()
+
+  class BrowserProjectRecord extends DatabaseRecord {}
+  class CreateBrowserProjectRecords extends Migration {
+    async up() {
+      await this.execute("CREATE TABLE browser_project_records(id integer PRIMARY KEY AUTOINCREMENT, name varchar(255) NOT NULL)")
+    }
+  }
+
+  BrowserProjectRecord.setTableName("browser_project_records")
+  BrowserProjectRecord.switchesTenantDatabase(DATABASE_IDENTIFIER)
+  BrowserProjectRecord.registerRecordClass({configuration})
+  CreateBrowserProjectRecords.onDatabases([DATABASE_IDENTIFIER])
+
+  const migrationFile = "20260919090000-create-browser-project-records.js"
+  /**
+   * Loads the one migration bundled into this browser proof.
+   * @type {import("../database/migrator/types.js").RequireMigrationContextType}
+   */
+  const migrations = (fileName) => {
+    if (fileName !== migrationFile) throw new Error(`Unknown browser tenant proof migration: ${fileName}`)
+
+    return {default: CreateBrowserProjectRecords}
+  }
+
+  migrations.keys = () => [migrationFile]
+  migrations.id = "frontend-tenant-browser-persistence-scenario"
+
+  const alpha = Tenant.handle({projectSlug: "alpha"}, configuration)
+  const beta = Tenant.handle({projectSlug: "beta"}, configuration)
+
+  configuration.setCurrent()
+
+  try {
+    await Promise.all([
+      alpha.delete({databaseIdentifier: DATABASE_IDENTIFIER}),
+      beta.delete({databaseIdentifier: DATABASE_IDENTIFIER})
+    ])
+    await Promise.all([
+      alpha.initialize({databaseIdentifier: DATABASE_IDENTIFIER, migrations, schemaGeneration: SCHEMA_GENERATION}),
+      beta.initialize({databaseIdentifier: DATABASE_IDENTIFIER, migrations, schemaGeneration: SCHEMA_GENERATION})
+    ])
+
+    for (let index = 0; index < 12; index++) {
+      await Promise.all([
+        alpha.databaseOperation({databaseIdentifier: DATABASE_IDENTIFIER}, async (operation) => {
+          await operation.forModel(BrowserProjectRecord).create({name: `alpha-${index}`})
+        }),
+        beta.databaseOperation({databaseIdentifier: DATABASE_IDENTIFIER}, async (operation) => {
+          await operation.forModel(BrowserProjectRecord).create({name: `beta-${index}`})
+        })
+      ])
+    }
+
+    await Promise.all([
+      alpha.close({databaseIdentifier: DATABASE_IDENTIFIER, flush: true}),
+      beta.close({databaseIdentifier: DATABASE_IDENTIFIER, flush: true})
+    ])
+    await Promise.all([
+      alpha.initialize({databaseIdentifier: DATABASE_IDENTIFIER, migrations, schemaGeneration: SCHEMA_GENERATION}),
+      beta.initialize({databaseIdentifier: DATABASE_IDENTIFIER, migrations, schemaGeneration: SCHEMA_GENERATION})
+    ])
+
+    const [alphaNames, betaNames] = await Promise.all([
+      alpha.databaseOperation({databaseIdentifier: DATABASE_IDENTIFIER}, async (operation) => {
+        return await operation.forModel(BrowserProjectRecord).order("id").pluck("name")
+      }),
+      beta.databaseOperation({databaseIdentifier: DATABASE_IDENTIFIER}, async (operation) => {
+        return await operation.forModel(BrowserProjectRecord).order("id").pluck("name")
+      })
+    ])
+
+    return {
+      alphaNames,
+      betaNames,
+      identitiesAreDistinct: alpha.databaseIdentity(DATABASE_IDENTIFIER) !== beta.databaseIdentity(DATABASE_IDENTIFIER),
+      openCount: configuration.inspectFrontendTenantSqliteHandles().openCount
+    }
+  } finally {
+    await Promise.all([
+      alpha.delete({databaseIdentifier: DATABASE_IDENTIFIER}),
+      beta.delete({databaseIdentifier: DATABASE_IDENTIFIER})
+    ])
+    if (previousConfiguration) previousConfiguration.setCurrent()
+    await configuration.closeDatabaseConnections()
+  }
+}

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

@@ -3,6 +3,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 runFrontendTenantDatabasePersistenceScenario from "./browser-frontend-tenant-database-scenarios.js"
 import runUseDatabaseSelectionTransitionScenario from "./browser-use-database-hook-scenarios.js"
 
 const root = document.getElementById("root") || (() => {
@@ -29,6 +30,7 @@ systemTestBrowserHelper.enableOnBrowser()
 Object.assign(globalThis, {velociousBrowserTest: {
   BrowserEnvironmentHandler,
   runFrontendModelEventHookScenario,
+  runFrontendTenantDatabasePersistenceScenario,
   runUseDatabaseSelectionTransitionScenario,
   systemTestBrowserHelper
 }})

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.674",
+  "version": "1.0.676",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

package/scripts/test-browser.js

@@ -95,6 +95,11 @@ async function buildBrowserTestApp() {
     sourcemap: true
   })
 
+  await fs.copyFile(
+    path.join(rootDir, "node_modules", "sql.js", "dist", "sql-wasm.wasm"),
+    path.join(distDir, "sql-wasm.wasm")
+  )
+
   const html = `<!doctype html>
 <html lang="en">
   <head>

package/src/database/query/model-class-query.js

@@ -940,10 +940,17 @@ export default class VelociousDatabaseQueryModelClassQuery extends DatabaseQuery
 
   /**
    * Runs first.
+   *
+   * An explicitly set order is preserved; the deterministic identity order is
+   * only applied as a fallback when no order was set, so `LIMIT 1` never
+   * returns an arbitrary row.
    * @returns {Promise<InstanceType<MC> | null>} - Resolves with the first.
    */
   async first() {
-    const newQuery = this.clone().limit(1).reorder(this._defaultIdentityOrder("ASC"))
+    const newQuery = this.clone().limit(1)
+
+    if (newQuery.getOrders().length == 0) newQuery.reorder(this._defaultIdentityOrder("ASC"))
+
     const results = await newQuery.toArray()
 
     return results[0] || null
@@ -951,10 +958,26 @@ export default class VelociousDatabaseQueryModelClassQuery extends DatabaseQuery
 
   /**
    * Runs last.
+   *
+   * An explicitly set order is preserved and read from its end; the
+   * deterministic identity order is only applied as a fallback when no order
+   * was set. The clone shares its order instances with the source query, so
+   * the explicit orders are replaced by independent reversed copies instead
+   * of mutating the shared ones.
    * @returns {Promise<InstanceType<MC> | null>} - Resolves with the last.
    */
   async last() {
-    const results = await this.clone().reorder(this._defaultIdentityOrder("DESC")).limit(1).toArray()
+    const newQuery = this.clone().limit(1)
+
+    if (newQuery.getOrders().length == 0) {
+      newQuery.reorder(this._defaultIdentityOrder("DESC"))
+    } else {
+      const orders = newQuery.getOrders()
+
+      for (let i = 0; i < orders.length; i += 1) orders[i] = orders[i].reversedCopy()
+    }
+
+    const results = await newQuery.toArray()
 
     return results[0] || null
   }