@@ -449,6 +449,7 @@ describe('the OS_DATABASE_URL door: both hosts, one verdict per URL, dev and pro
     ['https://my-db.turso.io', 'turso'],
     ['wasm-sqlite://data.db', 'sqlite-wasm'],
     ['./local.wasm.db', 'sqlite-wasm'],
+    ['file:./data/app.wasm.db', 'sqlite-wasm'],
     ['file:./data/app.db', 'sqlite'],
     ['sqlite:./data/app.db', 'sqlite'],
     [':memory:', 'sqlite'],
@@ -487,16 +488,18 @@ describe('the OS_DATABASE_URL door: both hosts, one verdict per URL, dev and pro
   });
 
   // An OPAQUE scheme — two or more characters and a `:`, no `//`
-  // (`jdbc:postgresql://…`, `redis:h`). The CLI host refuses it, typed, in dev
-  // and prod. The runtime host's answer is deliberately NOT pinned here: today
-  // its scheme-less arm opens these as a SQLite file at a path made of the URL,
-  // an implementation gap against its own "unknown schemes throw" rule that is
-  // #23765's to close, so asserting either agreement or its current answer
-  // would pin that gap.
+  // (`jdbc:postgresql://…`, `redis:h`) — and any scheme a `*.wasm.db` file name
+  // used to rescue. The CLI host refuses them, typed, in dev and prod. The
+  // runtime host's answer is deliberately NOT pinned here: today it opens these
+  // as a SQLite file at a path made of the URL, an implementation gap against
+  // its own "unknown schemes throw" rule that is #23765's to close, so asserting
+  // either agreement or its current answer would pin that gap.
   it.each([
     ['jdbc:postgresql://localhost:5432/db', 'jdbc:'],
     ['redis:cache', 'redis:'],
-  ])('the CLI host REFUSES the opaque scheme of %s, in dev AND in prod', (url, scheme) => {
+    ['redis://h/app.wasm.db', 'redis://'],
+    ['jdbc:x/app.wasm.db', 'jdbc:'],
+  ])('the CLI host REFUSES %s (scheme %s), in dev AND in prod', (url, scheme) => {
     for (const isDev of [false, true]) {
       const cli = cliUrlVerdict(url, isDev);
       expect(cli.accepted, `the CLI host (isDev=${isDev}) accepted ${url}`).toBe(false);
@@ -513,17 +516,18 @@ describe('the OS_DATABASE_URL door: both hosts, one verdict per URL, dev and pro
   // hosts must name the same FILE: `sqlite://x.db` used to open `//x.db` (the
   // filesystem root) on the CLI host while the runtime host opened `x.db`.
   it.each([
-    ['sqlite://x.db', 'x.db'],
-    ['sqlite:x.db', 'x.db'],
-    ['sqlite:///var/lib/objectstack/x.db', '/var/lib/objectstack/x.db'],
-  ])('both hosts open %s as the sqlite file %s, in dev and prod', (url, file) => {
+    ['sqlite://x.db', 'x.db', 'sqlite'],
+    ['sqlite:x.db', 'x.db', 'sqlite'],
+    ['sqlite:///var/lib/objectstack/x.db', '/var/lib/objectstack/x.db', 'sqlite'],
+    ['sqlite://x.wasm.db', 'x.wasm.db', 'sqlite-wasm'],
+  ])('both hosts open %s as the file %s (%s), in dev and prod', (url, file, kind) => {
     process.env.OS_DATABASE_URL = url;
     const runtime = resolveStandaloneDatabase({ artifactPath: '/nonexistent/objectstack.json' });
-    expect(runtime.driver).toBe('sqlite');
+    expect(runtime.driver).toBe(kind);
     expect(runtime.sqliteFile, `the runtime host's file for ${url}`).toBe(file);
     for (const isDev of [false, true]) {
       const definition = resolveStorageDefinition(resolveDriverType(undefined, url), { databaseUrl: url, isDev });
-      expect(definition!.driverId).toBe('sqlite');
+      expect(definition!.driverId).toBe(kind);
       expect(definition!.config.filename, `the CLI host's file for ${url} (isDev=${isDev})`).toBe(runtime.sqliteFile);
     }
   });
 
@@ -52,6 +52,8 @@ describe('inferDriverTypeFromUrl', () => {
     expect(inferDriverTypeFromUrl('https://x.turso.io')).toBe('turso');
     expect(inferDriverTypeFromUrl('wasm-sqlite://data.db')).toBe('sqlite-wasm');
     expect(inferDriverTypeFromUrl('./local.wasm.db')).toBe('sqlite-wasm');
+    expect(inferDriverTypeFromUrl('file:./local.wasm.db')).toBe('sqlite-wasm');
+    expect(inferDriverTypeFromUrl('sqlite:./local.wasm.db')).toBe('sqlite-wasm');
     expect(inferDriverTypeFromUrl('file:./app.db')).toBe('sqlite');
     expect(inferDriverTypeFromUrl('sqlite:./app.db')).toBe('sqlite');
     expect(inferDriverTypeFromUrl('./app.sqlite')).toBe('sqlite');
@@ -117,6 +119,9 @@ describe('inferDriverTypeFromUrl', () => {
     // too, rather than opened as a file at a path made of the URL.
     ['jdbc:postgresql://localhost:5432/db', 'jdbc:'],
     ['redis:cache', 'redis:'],
+    // Nor does a `.wasm.db` name: it selects the WASM engine for a FILE only.
+    ['redis://h/app.wasm.db', 'redis://'],
+    ['jdbc:x/app.wasm.db', 'jdbc:'],
   ])('refuses %s at inference, naming the scheme and the recognised ones', (url, scheme) => {
     let err: unknown;
     try {
@@ -278,6 +283,13 @@ describe('resolveStorageDefinition (#3826 — a definition, not a driver)', () =
     expect(r!.displayUrl).toBe(url);
   });
 
+  it('reads sqlite://x.wasm.db as the WASM engine on the file x.wasm.db, by the same alias rule', () => {
+    const url = 'sqlite://x.wasm.db';
+    const r = resolveStorageDefinition(resolveDriverType(undefined, url), { databaseUrl: url, isDev: false });
+    expect(r!.driverId).toBe('sqlite-wasm');
+    expect(r!.config.filename).toBe('x.wasm.db');
+  });
+
   it('dev default (no driver) declares sqlite :memory: with NO telemetry sibling', () => {
     const r = resolveStorageDefinition('', { isDev: true });
     expect(r!.driverId).toBe('sqlite');
 
@@ -317,7 +317,12 @@ export function inferDriverTypeFromUrl(url: string | undefined): string {
   // MissingDriverPackageError).
   if (/^libsql:\/\//i.test(u)) return 'turso';
   if (/^https?:\/\//i.test(u) && /\.turso\./i.test(u)) return 'turso';
-  if (/^wasm-sqlite:\/\//i.test(u) || /\.wasm\.db$/i.test(u)) return 'sqlite-wasm';
+  if (/^wasm-sqlite:\/\//i.test(u)) return 'sqlite-wasm';
+  // A `*.wasm.db` file name selects the WASM engine only for a FILE: a `file:` /
+  // `sqlite:` URL or a value with no scheme (both returns below). Tested here,
+  // ahead of every scheme check, it let the name rescue a scheme nothing
+  // recognises (`redis://h/x.wasm.db`, `jdbc:x/x.wasm.db`) into a SQLite file.
+  const wasmFile = /\.wasm\.db$/i.test(u);
   // The retired in-memory engine's two schemes — character-for-character the
   // runtime's `detectDriverFromUrl` arm, so the two hosts recognise and refuse
   // the same URLs. Kept ABOVE the sqlite test so it is not shadowed, and
@@ -332,7 +337,7 @@ export function inferDriverTypeFromUrl(url: string | undefined): string {
       { recognized: false },
     );
   }
-  if (/^file:/i.test(u) || /^sqlite:/i.test(u)) return 'sqlite';
+  if (/^file:/i.test(u) || /^sqlite:/i.test(u)) return wasmFile ? 'sqlite-wasm' : 'sqlite';
   // What is left with a scheme is refused, naming the scheme and never the URL:
   //  - an unrecognised `<scheme>://` (`redis://…`). Refusing it here, rather
   //    than letting a name that ends `.db` reach SQLite, is what keeps
@@ -355,7 +360,7 @@ export function inferDriverTypeFromUrl(url: string | undefined): string {
     );
   }
   // No scheme at all: a SQLite file path — `:memory:`, `./app.db`, `data/app`.
-  return 'sqlite';
+  return wasmFile ? 'sqlite-wasm' : 'sqlite';
 }
 
 /**
@@ -533,10 +538,10 @@ export function resolveStorageDefinition(
   }
 
   if (kind === 'sqlite-wasm') {
-    const filePath = (databaseUrl ?? ':memory:')
+    // The same alias rule as the sqlite arm: `sqlite://x.wasm.db` is `x.wasm.db`.
+    const filePath = normalizeDatabaseUrl(databaseUrl ?? ':memory:')
       .replace(/^file:/, '')
-      .replace(/^wasm-sqlite:\/\//, '')
-      .replace(/^sqlite:/, '');
+      .replace(/^wasm-sqlite:\/\//, '');
     return {
       driverId: 'sqlite-wasm',
       // `persist` passthrough: the CLI kept `on-disconnect` semantics here