rwsdk 1.2.11 → 1.2.12-test.20260615101652

package/dist/lib/e2e/release.d.mts

@@ -38,8 +38,10 @@ export declare function runRelease(cwd: string, projectDir: string, resourceUniq
 }>;
 /**
  * Run a local production preview server (build + preview) and return the URL.
+ * Uses port 0 so concurrent tests in the same playground do not collide on
+ * the fixed 4173 port.
  */
-export declare function runPreviewServer(packageManager?: string, cwd?: string): Promise<{
+export declare function runPreviewServer(packageManager?: string, cwd?: string, port?: string | number): Promise<{
     url: string;
     stopPreview: () => Promise<void>;
 }>;

package/dist/lib/e2e/release.mjs

@@ -7,8 +7,8 @@ import { parse as parseJsonc } from "jsonc-parser";
 import { setTimeout } from "node:timers/promises";
 import { basename, dirname, join, relative, resolve } from "path";
 import { $ } from "../../lib/$.mjs";
-import { checkServerUp } from "./browser.mjs";
 import { extractLastJson, parseJson } from "../../lib/jsonUtils.mjs";
+import { checkServerUp } from "./browser.mjs";
 import { IS_DEBUG_MODE, PREVIEW_SERVER_TIMEOUT } from "./constants.mjs";
 const log = debug("rwsdk:e2e:release");
 /**
@@ -403,8 +403,10 @@ export async function runRelease(cwd, projectDir, resourceUniqueKey) {
 }
 /**
  * Run a local production preview server (build + preview) and return the URL.
+ * Uses port 0 so concurrent tests in the same playground do not collide on
+ * the fixed 4173 port.
  */
-export async function runPreviewServer(packageManager = "pnpm", cwd) {
+export async function runPreviewServer(packageManager = "pnpm", cwd, port = "0") {
     console.log("🚀 Building for production preview...");
     const pm = packageManager === "yarn-classic" ? "yarn" : packageManager;
     await $(pm, ["run", "build"], {
@@ -430,7 +432,11 @@ export async function runPreviewServer(packageManager = "pnpm", cwd) {
         await previewProcess.catch(() => { });
         console.log("Preview server stopped");
     };
-    previewProcess = $(pm, ["run", "preview", "--", "--port", "4173", "--strictPort"], {
+    let serverUrlResolver;
+    const serverUrlPromise = new Promise((resolve) => {
+        serverUrlResolver = resolve;
+    });
+    previewProcess = $(pm, ["run", "preview", "--port", String(port), "--strictPort"], {
         all: true,
         detached: process.platform !== "win32",
         cleanup: true,
@@ -439,6 +445,24 @@ export async function runPreviewServer(packageManager = "pnpm", cwd) {
         env: { ...process.env, NODE_ENV: "production" },
         stdio: "pipe",
     });
+    // Vite prints the local URL once it has bound to a port, e.g.
+    // "  ➜  Local:   http://localhost:55271/"
+    // Strip ANSI escape codes first: when color output is enabled the port can
+    // be wrapped in its own color sequence (e.g. "http://localhost:\u001b[1m52829"),
+    // which breaks a naive regex.
+    const urlPattern = /Local:\s+(http:\/\/localhost:\d+)/i;
+    const ansiEscapePattern = /\u001b\[[0-9;]*m/g;
+    previewProcess.all?.on("data", (data) => {
+        const chunk = data.toString();
+        if (IS_DEBUG_MODE) {
+            process.stdout.write(chunk);
+        }
+        const strippedChunk = chunk.replace(ansiEscapePattern, "");
+        const match = strippedChunk.match(urlPattern);
+        if (match && match[1]) {
+            serverUrlResolver(match[1]);
+        }
+    });
     previewProcess.catch((error) => {
         if (!isErrorExpected) {
             log("Preview server process exited unexpectedly: %O", error);
@@ -468,13 +492,10 @@ export async function runPreviewServer(packageManager = "pnpm", cwd) {
         await fs.writeFile(deployConfigPath, JSON.stringify(deployConfig, null, 2));
     };
     await ensurePreviewDeployConfig();
-    // context(justinvdm, 2026-05-13): Give the CI preview path the same
-    // readiness budget as the dev server so local agent-ci runs can absorb build
-    // and startup latency without falling back to Cloudflare.
-    const reachableDebugUrl = await checkServerUp("http://localhost:4173", "/__debug", Math.max(1, Math.ceil(PREVIEW_SERVER_TIMEOUT / 2000)), false);
-    const serverUrl = new URL(reachableDebugUrl).origin;
-    console.log(`✅ Preview server started at ${serverUrl}`);
-    return { url: serverUrl, stopPreview };
+    const serverUrl = await serverUrlPromise;
+    const reachableDebugUrl = await checkServerUp(serverUrl, "/__debug", Math.max(1, Math.ceil(PREVIEW_SERVER_TIMEOUT / 2000)), false);
+    console.log(`✅ Preview server started at ${new URL(reachableDebugUrl).origin}`);
+    return { url: new URL(reachableDebugUrl).origin, stopPreview };
 }
 /**
  * Check if a resource name includes a specific resource unique key

package/dist/lib/e2e/testHarness.d.mts

@@ -44,6 +44,14 @@ export interface SetupPlaygroundEnvironmentOptions {
      * @default true
      */
     autoStartDevServer?: boolean;
+    /**
+     * Whether to automatically start the deployment after provisioning it.
+     * Set to false when the test manages its own deployment lifecycle (e.g.
+     * redeploys). The deploy playground environment is still set up so
+     * `createDeployment()` can be called from the test.
+     * @default true
+     */
+    autoStartDeployment?: boolean;
 }
 /**
  * A Vitest hook that sets up a playground environment for a test file.
@@ -67,6 +75,7 @@ export declare function createDevServer(): {
 export declare function createDeployment(): {
     projectDir: string;
     start: () => Promise<DeploymentInstance>;
+    redeploy: () => Promise<DeploymentInstance>;
 };
 /**
  * Executes a test function with a retry mechanism for specific error codes.

package/dist/lib/e2e/testHarness.mjs

@@ -98,8 +98,8 @@ function getPlaygroundDirFromImportMeta(importMetaUrl) {
  * This ensures that tests run in a clean, isolated environment.
  */
 export function setupPlaygroundEnvironment(options) {
-    const { sourceProjectDir, monorepoRoot, dev = true, deploy = true, autoStartDevServer = true, } = typeof options === "string"
-        ? { sourceProjectDir: options, autoStartDevServer: true }
+    const { sourceProjectDir, monorepoRoot, dev = true, deploy = true, autoStartDevServer = true, autoStartDeployment = true, } = typeof options === "string"
+        ? { sourceProjectDir: options, autoStartDevServer: true, autoStartDeployment: true }
         : options;
     ensureHooksRegistered();
     beforeAll(async () => {
@@ -150,15 +150,17 @@ export function setupPlaygroundEnvironment(options) {
                 projectDir: deployEnv.targetDir,
                 cleanup: deployEnv.cleanup,
             };
-            const deployControl = createDeployment();
-            globalDeploymentInstancePromise = deployControl
-                .start()
-                .then((instance) => {
-                globalDeploymentInstance = instance;
-                return instance;
-            });
-            // Prevent unhandled promise rejections
-            globalDeploymentInstancePromise.catch(() => { });
+            if (autoStartDeployment) {
+                const deployControl = createDeployment();
+                globalDeploymentInstancePromise = deployControl
+                    .start()
+                    .then((instance) => {
+                    globalDeploymentInstance = instance;
+                    return instance;
+                });
+                // Prevent unhandled promise rejections
+                globalDeploymentInstancePromise.catch(() => { });
+            }
         }
         else {
             globalDeployPlaygroundEnv = null;
@@ -213,88 +215,120 @@ export function createDeployment() {
     }
     const { projectDir } = globalDeployPlaygroundEnv;
     let instance = null;
+    const dirName = basename(projectDir);
+    // Match formats: {projectName}-t-{hash}, {projectName}-test-{hash}, or {projectName}-e2e-test-{hash}
+    const match = dirName.match(/-t-([a-f0-9]+)$/) ||
+        dirName.match(/-test-([a-f0-9]+)$/) ||
+        dirName.match(/-e2e-test-([a-f0-9]+)$/);
+    const resourceUniqueKey = match
+        ? match[1]
+        : Math.random().toString(36).substring(2, 15);
+    if (SKIP_DEPLOYMENT_TESTS) {
+        return {
+            projectDir,
+            start: async () => {
+                throw new Error("Deployment tests are skipped via RWSDK_SKIP_DEPLOY=1");
+            },
+            redeploy: async () => {
+                throw new Error("Deployment tests are skipped via RWSDK_SKIP_DEPLOY=1");
+            },
+        };
+    }
+    const deployToCloudflare = async () => {
+        const newInstance = await pollValue(async () => {
+            const deployResult = await runRelease(projectDir, projectDir, resourceUniqueKey);
+            // A fresh *.workers.dev subdomain can return 200 with Cloudflare's
+            // "There is nothing here yet" placeholder before the worker code
+            // propagates globally. Wait until the response body contains the
+            // rwsdk-rendered marker so tests don't run against the placeholder.
+            await poll(async () => {
+                try {
+                    const response = await fetch(deployResult.url);
+                    const body = await response.text();
+                    return body.includes("__RWSDK_CONTEXT");
+                }
+                catch (e) {
+                    return false;
+                }
+            }, {
+                timeout: DEPLOYMENT_CHECK_TIMEOUT,
+            });
+            const cleanup = async () => {
+                const performCleanup = async () => {
+                    if (isRelatedToTest(deployResult.workerName, resourceUniqueKey)) {
+                        await deleteWorker(deployResult.workerName, projectDir, resourceUniqueKey);
+                    }
+                    await deleteD1Database(resourceUniqueKey, projectDir, resourceUniqueKey);
+                };
+                performCleanup().catch((error) => {
+                    console.warn(`Warning: Background deployment cleanup failed: ${error.message}`);
+                });
+                return Promise.resolve();
+            };
+            return {
+                url: deployResult.url,
+                workerName: deployResult.workerName,
+                resourceUniqueKey,
+                projectDir: projectDir,
+                cleanup,
+            };
+        }, {
+            timeout: DEPLOYMENT_TIMEOUT,
+            minTries: DEPLOYMENT_MIN_TRIES,
+            onRetry: (error, tries) => {
+                console.log(`Retrying deployment creation (attempt ${tries})... Error: ${error.message}`);
+            },
+        });
+        return newInstance;
+    };
+    const startPreview = async (port = "0") => {
+        console.log("PR mode detected — using local preview instead of deploy");
+        const previewResult = await runPreviewServer(process.env.PACKAGE_MANAGER || "pnpm", projectDir, port);
+        return {
+            url: previewResult.url,
+            workerName: `preview-${resourceUniqueKey}`,
+            resourceUniqueKey,
+            projectDir,
+            cleanup: async () => {
+                await previewResult.stopPreview().catch((error) => {
+                    console.warn(`Warning: Background preview cleanup failed: ${error.message}`);
+                });
+                return Promise.resolve();
+            },
+        };
+    };
     return {
         projectDir,
         start: async () => {
             if (instance)
                 return instance;
-            if (SKIP_DEPLOYMENT_TESTS) {
-                throw new Error("Deployment tests are skipped via RWSDK_SKIP_DEPLOY=1");
-            }
-            const dirName = basename(projectDir);
-            // Match formats: {projectName}-t-{hash}, {projectName}-test-{hash}, or {projectName}-e2e-test-{hash}
-            const match = dirName.match(/-t-([a-f0-9]+)$/) ||
-                dirName.match(/-test-([a-f0-9]+)$/) ||
-                dirName.match(/-e2e-test-([a-f0-9]+)$/);
-            const resourceUniqueKey = match
-                ? match[1]
-                : Math.random().toString(36).substring(2, 15);
-            if (IS_PULL_REQUEST) {
-                console.log("PR mode detected — using local preview instead of deploy");
-                const previewResult = await runPreviewServer(process.env.PACKAGE_MANAGER ||
-                    "pnpm", projectDir);
-                instance = {
-                    url: previewResult.url,
-                    workerName: `preview-${resourceUniqueKey}`,
-                    resourceUniqueKey,
-                    projectDir,
-                    cleanup: async () => {
-                        await previewResult.stopPreview().catch((error) => {
-                            console.warn(`Warning: Background preview cleanup failed: ${error.message}`);
-                        });
-                        return Promise.resolve();
-                    },
-                };
-                deploymentInstances.push(instance);
-                return instance;
+            instance = IS_PULL_REQUEST
+                ? await startPreview()
+                : await deployToCloudflare();
+            deploymentInstances.push(instance);
+            return instance;
+        },
+        redeploy: async () => {
+            // Stop/clean up the previous preview instance so the new one can bind
+            // to the same port. For real Cloudflare deploys the worker is updated
+            // in place, so no intermediate cleanup is needed.
+            let redeployPort = "0";
+            if (instance) {
+                const oldInstance = instance;
+                const index = deploymentInstances.indexOf(oldInstance);
+                if (index !== -1) {
+                    deploymentInstances.splice(index, 1);
+                }
+                if (IS_PULL_REQUEST) {
+                    redeployPort = new URL(oldInstance.url).port;
+                    await oldInstance.cleanup();
+                }
             }
-            const newInstance = await pollValue(async () => {
-                const deployResult = await runRelease(projectDir, projectDir, resourceUniqueKey);
-                // A fresh *.workers.dev subdomain can return 200 with Cloudflare's
-                // "There is nothing here yet" placeholder before the worker code
-                // propagates globally. Wait until the response body contains the
-                // rwsdk-rendered marker so tests don't run against the placeholder.
-                await poll(async () => {
-                    try {
-                        const response = await fetch(deployResult.url);
-                        const body = await response.text();
-                        return body.includes("__RWSDK_CONTEXT");
-                    }
-                    catch (e) {
-                        return false;
-                    }
-                }, {
-                    timeout: DEPLOYMENT_CHECK_TIMEOUT,
-                });
-                const cleanup = async () => {
-                    const performCleanup = async () => {
-                        if (isRelatedToTest(deployResult.workerName, resourceUniqueKey)) {
-                            await deleteWorker(deployResult.workerName, projectDir, resourceUniqueKey);
-                        }
-                        await deleteD1Database(resourceUniqueKey, projectDir, resourceUniqueKey);
-                    };
-                    performCleanup().catch((error) => {
-                        console.warn(`Warning: Background deployment cleanup failed: ${error.message}`);
-                    });
-                    return Promise.resolve();
-                };
-                return {
-                    url: deployResult.url,
-                    workerName: deployResult.workerName,
-                    resourceUniqueKey,
-                    projectDir: projectDir,
-                    cleanup,
-                };
-            }, {
-                timeout: DEPLOYMENT_TIMEOUT,
-                minTries: DEPLOYMENT_MIN_TRIES,
-                onRetry: (error, tries) => {
-                    console.log(`Retrying deployment creation (attempt ${tries})... Error: ${error.message}`);
-                },
-            });
-            instance = newInstance;
-            deploymentInstances.push(newInstance);
-            return newInstance;
+            instance = IS_PULL_REQUEST
+                ? await startPreview(redeployPort)
+                : await deployToCloudflare();
+            deploymentInstances.push(instance);
+            return instance;
         },
     };
 }

package/dist/runtime/client/client.js

@@ -14,6 +14,7 @@ export { default as React } from "react";
 export { ClientOnly } from "./ClientOnly.js";
 export { initClientNavigation, navigate } from "./navigation.js";
 import { getCachedNavigationResponse } from "./navigationCache.js";
+import { createClientVersionHeaders, isStaleReloadResponse, } from "./stale.js";
 import { isActionResponse } from "./types";
 export const fetchTransport = (transportContext) => {
     const fetchCallServer = async (id, args, source = "action", method = "POST") => {
@@ -38,27 +39,27 @@ export const fetchTransport = (transportContext) => {
                 // Fall back to network fetch on cache miss
                 fetchPromise = fetch(url, {
                     method: "GET",
+                    headers: createClientVersionHeaders(),
                     redirect: "manual",
                 });
             }
         }
         else {
-            const headers = new Headers();
-            // Add x-rsc-data-only header if we want to skip the React tree render on the server
+            const extraHeaders = {};
             if (source === "query") {
-                headers.set("x-rsc-data-only", "true");
+                extraHeaders["x-rsc-data-only"] = "true";
             }
             if (method === "GET") {
                 fetchPromise = fetch(url, {
                     method: "GET",
-                    headers,
+                    headers: createClientVersionHeaders(extraHeaders),
                     redirect: "manual",
                 });
             }
             else {
                 fetchPromise = fetch(url, {
                     method: "POST",
-                    headers,
+                    headers: createClientVersionHeaders(extraHeaders),
                     redirect: "manual",
                     body: args != null ? await encodeReply(args) : null,
                 });
@@ -83,9 +84,14 @@ export const fetchTransport = (transportContext) => {
             }
             return rawActionResult;
         };
+        const response = await fetchPromise;
+        // Single place where stale reload happens
+        if (isStaleReloadResponse(response)) {
+            window.location.reload();
+            return undefined;
+        }
         // If there's a response handler, check the response first
         if (transportContext.handleResponse) {
-            const response = await fetchPromise;
             const shouldContinue = transportContext.handleResponse(response);
             if (!shouldContinue) {
                 return undefined;
@@ -100,8 +106,7 @@ export const fetchTransport = (transportContext) => {
             const result = await streamData;
             return processActionResponse(result.actionResult);
         }
-        // Original behavior when no handler is present
-        const response = await fetchPromise;
+        // Fallback when no handler is present
         const location = response.headers.get("Location");
         if (response.status >= 300 && response.status < 400 && location) {
             window.location.href = location;

package/dist/runtime/client/navigationCache.js

@@ -1,5 +1,6 @@
+import { createClientVersionHeaders, getClientBuildVersion, } from "./stale.js";
 const TAB_ID_STORAGE_KEY = "rwsdk-navigation-tab-id";
-const BUILD_ID = "rwsdk"; // Stable build identifier
+const DEFAULT_BUILD_ID = "rwsdk";
 let cacheState = null;
 function getOrInitializeCacheState() {
     if (cacheState) {
@@ -22,7 +23,7 @@ function getOrInitializeCacheState() {
     cacheState = {
         tabId: tabId || "1",
         generation: 0,
-        buildId: BUILD_ID,
+        buildId: getClientBuildVersion() ?? DEFAULT_BUILD_ID,
     };
     return cacheState;
 }
@@ -127,9 +128,7 @@ export async function preloadNavigationUrl(rawUrl, env, cacheStorage) {
         const request = new Request(url.toString(), {
             method: "GET",
             redirect: "manual",
-            headers: {
-                "x-prefetch": "true",
-            },
+            headers: createClientVersionHeaders({ "x-prefetch": "true" }),
         });
         const cacheName = getCurrentCacheName();
         const cache = await storage.open(cacheName);

package/dist/runtime/client/stale.d.ts

@@ -0,0 +1,5 @@
+import { CLIENT_VERSION_HEADER, isStaleClientError } from "../lib/stale.js";
+export declare function getClientBuildVersion(): string | undefined;
+export declare function isStaleReloadResponse(response: Response): boolean;
+export declare function createClientVersionHeaders(extraHeaders?: Record<string, string>): Headers;
+export { CLIENT_VERSION_HEADER, isStaleClientError };

package/dist/runtime/client/stale.js

@@ -0,0 +1,21 @@
+import { CLIENT_VERSION_HEADER, STALE_RESPONSE_HEADER, STALE_RESPONSE_VALUE_RELOAD, isStaleClientError, } from "../lib/stale.js";
+export function getClientBuildVersion() {
+    return import.meta.env.VITE_RWSDK_BUILD_ID;
+}
+export function isStaleReloadResponse(response) {
+    return (response.headers?.get(STALE_RESPONSE_HEADER) === STALE_RESPONSE_VALUE_RELOAD);
+}
+export function createClientVersionHeaders(extraHeaders) {
+    const headers = new Headers();
+    const clientBuildVersion = getClientBuildVersion();
+    if (clientBuildVersion) {
+        headers.set(CLIENT_VERSION_HEADER, clientBuildVersion);
+    }
+    if (extraHeaders) {
+        for (const [key, value] of Object.entries(extraHeaders)) {
+            headers.set(key, value);
+        }
+    }
+    return headers;
+}
+export { CLIENT_VERSION_HEADER, isStaleClientError };

package/dist/runtime/entries/types/shared.d.ts

@@ -4,5 +4,7 @@ interface ImportMeta {
 interface ImportMetaEnv {
     readonly DEV: boolean;
     readonly VITE_IS_DEV_SERVER: string;
+    readonly VITE_RWSDK_BUILD_ID: string;
+    readonly VITE_RWSDK_SYNCED_STATE_TEST_FAST_RECONNECT?: string;
     readonly BASE_URL: string;
 }

package/dist/runtime/lib/db/DOSqliteIntrospector.d.ts

@@ -0,0 +1,8 @@
+import { type DatabaseMetadata, type DatabaseMetadataOptions, type Kysely, type SchemaMetadata, type TableMetadata } from "kysely";
+export declare class DOSqliteIntrospector {
+    #private;
+    constructor(db: Kysely<any>);
+    getSchemas(): Promise<SchemaMetadata[]>;
+    getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
+    getMetadata(options: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
+}

package/dist/runtime/lib/db/DOSqliteIntrospector.js

@@ -0,0 +1,129 @@
+// NOTE(justinvdm, 9 Jun 2026): This file copies Kysely's SqliteIntrospector.
+// Before trying to simplify it, read this comment.
+//
+// Problem: Cloudflare's DO SQLite adds internal tables (_cf_KV, _cf_METADATA)
+// when storage.put/setAlarm is used. Kysely's SqliteIntrospector discovers
+// these via sqlite_master, then runs PRAGMA table_info on each. Cloudflare's
+// authorizer rejects PRAGMA on _cf_* tables with SQLITE_AUTH, breaking
+// migrations and rendering the DO unusable.
+//
+// Why we copied instead of composed:
+// - Kysely's SqliteIntrospector uses JS private fields (#db, #tablesQuery,
+//   #getTableMetadata). Private fields are truly private — subclasses cannot
+//   override them, and wrappers cannot intercept internal calls.
+// - We considered a lighter approach: query sqlite_master with Kysely's
+//   builder, then run PRAGMA table_info per-table. This is lighter but
+//   requires inlining the table name into raw SQL. Even with escaping,
+//   any injection risk is unacceptable. The CTE approach below uses
+//   `pragma_table_info(tl.name)` where `tl.name` is a column reference,
+//   not an inlined value — zero injection surface.
+// - We also considered Kysely plugins (AST rewriting, SQL string rewriting)
+//   but these are fragile: they depend on Kysely's internal AST shape and
+//   SQL formatting, both of which can change between releases.
+//
+// This is a copy of Kysely's SqliteIntrospector (MIT licensed) with one
+// change: `.where('name', 'not like', '_cf_%')` to exclude Cloudflare tables.
+//
+// See: https://github.com/redwoodjs/sdk/issues/1219
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _DOSqliteIntrospector_instances, _DOSqliteIntrospector_db, _DOSqliteIntrospector_tablesQuery, _DOSqliteIntrospector_getTableMetadata;
+import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, sql, } from "kysely";
+export class DOSqliteIntrospector {
+    constructor(db) {
+        _DOSqliteIntrospector_instances.add(this);
+        _DOSqliteIntrospector_db.set(this, void 0);
+        __classPrivateFieldSet(this, _DOSqliteIntrospector_db, db, "f");
+    }
+    async getSchemas() {
+        // Sqlite doesn't support schemas.
+        return [];
+    }
+    async getTables(options = { withInternalKyselyTables: false }) {
+        return await __classPrivateFieldGet(this, _DOSqliteIntrospector_instances, "m", _DOSqliteIntrospector_getTableMetadata).call(this, options);
+    }
+    async getMetadata(options) {
+        return {
+            tables: await this.getTables(options),
+        };
+    }
+}
+_DOSqliteIntrospector_db = new WeakMap(), _DOSqliteIntrospector_instances = new WeakSet(), _DOSqliteIntrospector_tablesQuery = function _DOSqliteIntrospector_tablesQuery(qb, options) {
+    let tablesQuery = qb
+        .selectFrom("sqlite_master")
+        .where("type", "in", ["table", "view"])
+        .where("name", "not like", "sqlite_%")
+        // context(justinvdm, 9 Jun 2026): Exclude Cloudflare internal tables.
+        // These are added by the DO runtime and cannot be introspected.
+        .where("name", "not like", "_cf_%")
+        .select(["name", "sql", "type"])
+        .orderBy("name");
+    if (!options.withInternalKyselyTables) {
+        tablesQuery = tablesQuery
+            .where("name", "!=", DEFAULT_MIGRATION_TABLE)
+            .where("name", "!=", DEFAULT_MIGRATION_LOCK_TABLE);
+    }
+    return tablesQuery;
+}, _DOSqliteIntrospector_getTableMetadata = async function _DOSqliteIntrospector_getTableMetadata(options) {
+    const tablesResult = await __classPrivateFieldGet(this, _DOSqliteIntrospector_instances, "m", _DOSqliteIntrospector_tablesQuery).call(this, __classPrivateFieldGet(this, _DOSqliteIntrospector_db, "f"), options).execute();
+    const tableMetadata = await __classPrivateFieldGet(this, _DOSqliteIntrospector_db, "f")
+        .with("table_list", (qb) => __classPrivateFieldGet(this, _DOSqliteIntrospector_instances, "m", _DOSqliteIntrospector_tablesQuery).call(this, qb, options))
+        .selectFrom([
+        "table_list as tl",
+        sql `pragma_table_info(tl.name)`.as("p"),
+    ])
+        .select([
+        "tl.name as table",
+        "p.cid",
+        "p.name",
+        "p.type",
+        "p.notnull",
+        "p.dflt_value",
+        "p.pk",
+    ])
+        .orderBy("tl.name")
+        .orderBy("p.cid")
+        .execute();
+    const columnsByTable = {};
+    for (const row of tableMetadata) {
+        columnsByTable[row.table] ??= [];
+        columnsByTable[row.table].push(row);
+    }
+    return tablesResult.map(({ name, sql: tableSql, type }) => {
+        let autoIncrementCol = tableSql
+            ?.split(/[\(\),]/)
+            ?.find((it) => it.toLowerCase().includes("autoincrement"))
+            ?.trimStart()
+            ?.split(/\s+/)?.[0]
+            ?.replace(/["`]/g, "");
+        const columns = columnsByTable[name] ?? [];
+        if (!autoIncrementCol) {
+            const pkCols = columns.filter((r) => r.pk > 0);
+            if (pkCols.length === 1 &&
+                pkCols[0].type.toLowerCase() === "integer") {
+                autoIncrementCol = pkCols[0].name;
+            }
+        }
+        return {
+            name: name,
+            isView: type === "view",
+            columns: columns.map((col) => ({
+                name: col.name,
+                dataType: col.type,
+                isNullable: !col.notnull,
+                isAutoIncrementing: col.name === autoIncrementCol,
+                hasDefaultValue: col.dflt_value != null,
+                comment: undefined,
+            })),
+        };
+    });
+};

package/dist/runtime/lib/db/DOWorkerDialect.d.ts

@@ -1,4 +1,5 @@
-import { DatabaseConnection, Driver, QueryResult, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler } from "kysely";
+import { DatabaseConnection, Driver, QueryResult, SqliteAdapter, SqliteQueryCompiler } from "kysely";
+import { DOSqliteIntrospector } from "./DOSqliteIntrospector.js";
 type DOWorkerDialectConfig = {
     kyselyExecuteQuery: (compiledQuery: {
         sql: string;
@@ -11,7 +12,7 @@ export declare class DOWorkerDialect {
     createAdapter(): SqliteAdapter;
     createDriver(): DOWorkerDriver;
     createQueryCompiler(): SqliteQueryCompiler;
-    createIntrospector(db: any): SqliteIntrospector;
+    createIntrospector(db: any): DOSqliteIntrospector;
 }
 declare class DOWorkerDriver implements Driver {
     config: DOWorkerDialectConfig;

package/dist/runtime/lib/db/DOWorkerDialect.js

@@ -1,5 +1,6 @@
-import { SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, } from "kysely";
+import { SqliteAdapter, SqliteQueryCompiler, } from "kysely";
 import debug from "../debug";
+import { DOSqliteIntrospector } from "./DOSqliteIntrospector.js";
 const log = debug("sdk:db:do-worker-dialect");
 export class DOWorkerDialect {
     constructor(config) {
@@ -15,7 +16,7 @@ export class DOWorkerDialect {
         return new SqliteQueryCompiler();
     }
     createIntrospector(db) {
-        return new SqliteIntrospector(db);
+        return new DOSqliteIntrospector(db);
     }
 }
 class DOWorkerDriver {