velocious 1.0.675 → 1.0.677

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,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
+//# 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.675",
+  "version": "1.0.677",
   "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/background-jobs/pooled-runner-child.js

@@ -1,13 +1,17 @@
 // @ts-check
 
 import { randomUUID } from "node:crypto"
+import timeout from "awaitery/build/timeout.js"
 import runJobPayload, { BackgroundJobPerformedFailure } from "./job-runner.js"
+import { boundedPooledRunnerInflightJobIds, isPooledChildShutdownReason, isPooledChildShutdownSignal } from "./pooled-runner-shutdown.js"
 import { closeRunnerConnections, closeRunnerFrameworkConnections, currentConfigurationOrNull } from "./runner-graceful-shutdown.js"
 import setRunnerProcessTitle from "./runner-process-title.js"
 import PooledRunnerBrokerIdentity from "./pooled-runner-broker-identity.js"
 import { runWithSharedTransactionBrokerConfig } from "../testing/shared-transaction-proxy-driver.js"
 
 const BASE_PROCESS_TITLE = "velocious background-jobs-runner"
+/** A shutdown observation may delay resource teardown only for this bounded IPC send. */
+const SHUTDOWN_OBSERVATION_SEND_TIMEOUT_MS = 100
 /** Stable identity of this pooled child process for the life of the process. */
 const childInstanceId = randomUUID()
 
@@ -20,13 +24,18 @@ let shutdownPromise
  * Closes the runner's connections — releasing any advisory lock a killed-mid-pass
  * job still holds — before exiting, instead of leaving a half-open session that
  * keeps the lock until the DB server's `wait_timeout`.
- * @param {number} exitCode - Process exit code.
+ * @param {object} args - Shutdown observation.
+ * @param {number} args.exitCode - Process exit code.
+ * @param {import("./types.js").PooledChildShutdownReason} args.reason - Exact shutdown reason observed by the child.
+ * @param {number | null} [args.shutdownRequestedAtMs] - Parent request timestamp when supplied over IPC.
+ * @param {import("node:child_process").ChildProcess["signalCode"]} [args.signal] - Requested or observed signal.
  * @returns {Promise<void>}
  */
-function shutdownRunner(exitCode) {
+function shutdownRunner({exitCode, reason, shutdownRequestedAtMs = null, signal = null}) {
   if (shutdownPromise) return shutdownPromise
 
   shutdownPromise = (async () => {
+    await sendShutdownObservation({reason, shutdownRequestedAtMs, signal})
     await closeRunnerConnections(currentConfigurationOrNull())
     process.exit(exitCode)
   })()
@@ -60,6 +69,52 @@ function updateProcessTitle() {
   process.title = count > 0 ? `${BASE_PROCESS_TITLE}: ${count} ${count === 1 ? "job" : "jobs"}` : BASE_PROCESS_TITLE
 }
 
+/**
+ * Sends one bounded lifecycle observation before application/framework teardown.
+ * A closed IPC channel is expected for `ipc_disconnect`; other send failures are
+ * surfaced on stderr but never hold connection cleanup past the fixed bound.
+ * @param {object} args - Shutdown observation.
+ * @param {import("./types.js").PooledChildShutdownReason} args.reason - Shutdown reason.
+ * @param {number | null} args.shutdownRequestedAtMs - Parent request timestamp.
+ * @param {import("node:child_process").ChildProcess["signalCode"]} args.signal - Requested or observed signal.
+ * @returns {Promise<void>} - Resolves after IPC accepts the observation or the bound expires.
+ */
+async function sendShutdownObservation({reason, shutdownRequestedAtMs, signal}) {
+  if (!process.send || !process.connected) return
+
+  const boundedInflight = boundedPooledRunnerInflightJobIds(runningJobIds)
+  /** @type {import("./types.js").PooledChildShutdownObservation & {type: "shutdown-observation"}} */
+  const message = {
+    childInstanceId,
+    ...boundedInflight,
+    reason,
+    shutdownObservedAtMs: Date.now(),
+    shutdownRequestedAtMs,
+    signal,
+    type: "shutdown-observation"
+  }
+
+  try {
+    await timeout({timeout: SHUTDOWN_OBSERVATION_SEND_TIMEOUT_MS}, async () => {
+      await new Promise((resolve, reject) => {
+        try {
+          process.send?.(message, (error) => {
+            if (error) {
+              reject(error)
+            } else {
+              resolve(undefined)
+            }
+          })
+        } catch (error) {
+          reject(error)
+        }
+      })
+    })
+  } catch (error) {
+    console.error("Pooled background job runner could not send its shutdown observation:", error)
+  }
+}
+
 /**
  * Reports one acceptance observation (job received / perform started) to the
  * worker over IPC. The message carries the job's exact handoff lease so the
@@ -105,6 +160,22 @@ function isJobMessage(message) {
   return record.type === "job" && !!record.payload && typeof record.payload === "object" && typeof record.payload.id === "string"
 }
 
+/**
+ * Checks whether an IPC value requests a typed pooled-child shutdown.
+ * @param {ReturnType<typeof JSON.parse>} message - IPC message.
+ * @returns {message is {type: "shutdown-request", reason: import("./types.js").PooledChildShutdownReason, shutdownRequestedAtMs: number, signal: import("node:child_process").ChildProcess["signalCode"]}} - Whether this is a valid parent shutdown request.
+ */
+function isShutdownRequestMessage(message) {
+  if (!message || typeof message !== "object") return false
+  const record = /** @type {{type?: ReturnType<typeof JSON.parse>, reason?: ReturnType<typeof JSON.parse>, shutdownRequestedAtMs?: ReturnType<typeof JSON.parse>, signal?: ReturnType<typeof JSON.parse>}} */ (message)
+
+  return record.type === "shutdown-request"
+    && isPooledChildShutdownReason(record.reason)
+    && typeof record.shutdownRequestedAtMs === "number"
+    && Number.isFinite(record.shutdownRequestedAtMs)
+    && isPooledChildShutdownSignal(record.signal)
+}
+
 /**
  * Sends the terminal outcome after the main/DB report has been acknowledged or rejected.
  * @param {object} args - Outcome.
@@ -176,6 +247,16 @@ async function runJob(payload, sharedTransactionBroker) {
  * @returns {void}
  */
 function handleMessage(message) {
+  if (isShutdownRequestMessage(message)) {
+    void shutdownRunner({
+      exitCode: message.reason === "parent_retire_drained" ? 0 : 1,
+      reason: message.reason,
+      shutdownRequestedAtMs: message.shutdownRequestedAtMs,
+      signal: message.signal
+    })
+    return
+  }
+
   if (!isJobMessage(message) || runningJobIds.has(message.payload.id)) return
 
   runningJobIds.add(message.payload.id)
@@ -185,6 +266,7 @@ function handleMessage(message) {
 }
 
 process.on("message", (message) => handleMessage(message))
-process.once("disconnect", () => void shutdownRunner(0))
-for (const signal of ["SIGTERM", "SIGINT"]) process.once(signal, () => void shutdownRunner(1))
-if (process.send) process.send({type: "ready"})
+process.once("disconnect", () => void shutdownRunner({exitCode: 0, reason: "ipc_disconnect"}))
+process.once("SIGTERM", () => void shutdownRunner({exitCode: 1, reason: "signal_sigterm", signal: "SIGTERM"}))
+process.once("SIGINT", () => void shutdownRunner({exitCode: 1, reason: "signal_sigint", signal: "SIGINT"}))
+if (process.send) process.send({childInstanceId, childPid: process.pid, type: "ready"})

package/src/background-jobs/pooled-runner-shutdown.js

@@ -0,0 +1,55 @@
+// @ts-check
+
+import { constants } from "node:os"
+
+/** Maximum job ids copied into a pooled-child shutdown observation or failure snapshot. */
+export const POOLED_RUNNER_INFLIGHT_JOB_ID_LIMIT = 100
+
+/** @type {readonly import("./types.js").PooledChildShutdownReason[]} */
+export const POOLED_CHILD_SHUTDOWN_REASONS = Object.freeze([
+  "parent_retire_drained",
+  "job_timeout",
+  "worker_stop",
+  "signal_sigterm",
+  "signal_sigint",
+  "signal_sigkill",
+  "signal_other",
+  "ipc_disconnect",
+  "process_error",
+  "unexpected_exit"
+])
+
+/**
+ * Checks one dynamic IPC reason against the complete shutdown contract.
+ * @param {ReturnType<typeof JSON.parse>} value - Candidate shutdown reason.
+ * @returns {value is import("./types.js").PooledChildShutdownReason} - Whether the value is a known reason.
+ */
+export function isPooledChildShutdownReason(value) {
+  if (typeof value !== "string") return false
+
+  return POOLED_CHILD_SHUTDOWN_REASONS.some((reason) => reason === value)
+}
+
+/**
+ * Checks one dynamic IPC value against Node's named process signals.
+ * @param {ReturnType<typeof JSON.parse>} value - Candidate signal.
+ * @returns {value is import("node:child_process").ChildProcess["signalCode"]} - Whether the value is null or a named signal.
+ */
+export function isPooledChildShutdownSignal(value) {
+  return value === null || (typeof value === "string" && Object.hasOwn(constants.signals, value))
+}
+
+/**
+ * Sorts, deduplicates, and bounds job ids before they cross IPC/report boundaries.
+ * @param {Iterable<string>} jobIds - In-flight durable job ids.
+ * @returns {{inflightJobIds: string[], inflightJobIdsTruncatedCount: number}} - Bounded snapshot.
+ */
+export function boundedPooledRunnerInflightJobIds(jobIds) {
+  const sortedJobIds = [...new Set(jobIds)].sort((left, right) => left.localeCompare(right))
+  const inflightJobIds = sortedJobIds.slice(0, POOLED_RUNNER_INFLIGHT_JOB_ID_LIMIT)
+
+  return {
+    inflightJobIds,
+    inflightJobIdsTruncatedCount: sortedJobIds.length - inflightJobIds.length
+  }
+}