@alloy-js/core 0.24.0-dev.1 → 0.24.0-dev.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alloy-js/core",
-  "version": "0.24.0-dev.1",
+  "version": "0.24.0-dev.2",
   "description": "",
   "repository": {
     "type": "git",
@@ -50,7 +50,11 @@
     "./dist/src/debug/source-map.js": "./dist/src/debug/source-map.browser.js",
     "./src/debug/source-map.ts": "./src/debug/source-map.browser.ts",
     "./dist/src/devtools/devtools-server.js": "./dist/src/devtools/devtools-server.browser.js",
-    "./src/devtools/devtools-server.ts": "./src/devtools/devtools-server.browser.ts"
+    "./src/devtools/devtools-server.ts": "./src/devtools/devtools-server.browser.ts",
+    "./dist/src/debug/trace-db.js": "./dist/src/debug/trace-db.browser.js",
+    "./src/debug/trace-db.ts": "./src/debug/trace-db.browser.ts",
+    "./dist/src/debug/cli.js": "./dist/src/debug/cli.browser.js",
+    "./src/debug/cli.ts": "./src/debug/cli.browser.ts"
   },
   "keywords": [],
   "author": "brian.terlson@microsoft.com",

package/src/debug/cli.browser.ts

@@ -0,0 +1,17 @@
+/**
+ * Browser stub for CLI debug utilities.
+ *
+ * Replaces `cli.ts` in browser builds so that `cli-table3` and
+ * `picocolors` (Node-only packages) are never imported.
+ * All functions are no-ops since CLI debugging is not relevant in browsers.
+ */
+
+export function debugStack(): void {}
+
+export function debugContext(): void {}
+
+export function debugTree(): void {}
+
+export function debugWatch(): void {}
+
+export function debugRender(): void {}

package/src/debug/trace-db.browser.ts

@@ -0,0 +1,12 @@
+/**
+ * Browser stub for trace database initialization.
+ *
+ * Replaces `trace-db.ts` in browser builds. Returns null so that
+ * all trace-writer functions (which guard on `if (!db) return`) become no-ops.
+ */
+
+export type DatabaseSync = null;
+
+export async function openTraceDatabase(_path: string): Promise<null> {
+  return null;
+}

package/src/debug/trace-db.ts

@@ -0,0 +1,42 @@
+/**
+ * Database initialization for the trace writer.
+ *
+ * Isolates the `node:sqlite` and `node:fs` dependencies so that
+ * `trace-writer.ts` itself remains browser-safe (all functions no-op
+ * when db is null). In browser builds this module is replaced by
+ * `trace-db.browser.ts` which always returns null.
+ */
+import type { DatabaseSync as DatabaseSyncType } from "node:sqlite";
+
+export type { DatabaseSyncType as DatabaseSync };
+
+/**
+ * Opens a fresh SQLite database at the given path, removing any existing file.
+ * Returns the opened database instance.
+ */
+export async function openTraceDatabase(
+  path: string,
+): Promise<DatabaseSyncType> {
+  const { DatabaseSync } = await import("node:sqlite");
+  const fs = await import("node:fs");
+  // Remove existing trace file so each run starts fresh
+  try {
+    fs.unlinkSync(path);
+  } catch {
+    /* ignore missing */
+  }
+  try {
+    fs.unlinkSync(path + "-wal");
+  } catch {
+    /* ignore missing */
+  }
+  try {
+    fs.unlinkSync(path + "-shm");
+  } catch {
+    /* ignore missing */
+  }
+  const db = new DatabaseSync(path);
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec("PRAGMA synchronous=NORMAL");
+  return db;
+}

package/src/debug/trace-writer.ts

@@ -5,12 +5,10 @@
  * built-in `node:sqlite` module. The database can be queried by the
  * `alloy-trace` CLI or the devtools WebSocket server.
  */
-import type {
-  DatabaseSync as DatabaseSyncType,
-  StatementSync,
-} from "node:sqlite";
+import type { StatementSync } from "node:sqlite";
+import { type DatabaseSync, openTraceDatabase } from "./trace-db.js";
 
-let db: DatabaseSyncType | null = null;
+let db: DatabaseSync | null = null;
 let seq = 0;
 
 // Prepared statements (initialized in initTrace)
@@ -133,28 +131,8 @@ export function queryChannel(
 }
 
 export async function initTrace(path: string): Promise<void> {
-  // Dynamic import to avoid failing in environments without node:sqlite
-  const { DatabaseSync } = await import("node:sqlite");
-  const fs = await import("node:fs");
-  // Remove existing trace file so each run starts fresh
-  try {
-    fs.unlinkSync(path);
-  } catch {
-    /* ignore missing */
-  }
-  try {
-    fs.unlinkSync(path + "-wal");
-  } catch {
-    /* ignore missing */
-  }
-  try {
-    fs.unlinkSync(path + "-shm");
-  } catch {
-    /* ignore missing */
-  }
-  db = new DatabaseSync(path);
-  db.exec("PRAGMA journal_mode=WAL");
-  db.exec("PRAGMA synchronous=NORMAL");
+  db = await openTraceDatabase(path);
+  if (!db) return;
   createSchema();
   prepareStatements();
 }

package/test/browser-build.test.ts

@@ -1,29 +1,74 @@
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
-import { join } from "path";
+import { join, resolve } from "path";
 import { build, type Rolldown } from "vite";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 
 const tempDir = join(__dirname, ".temp", "browser-build-test");
 const entryFile = join(tempDir, "entry.js");
 
+// Absolute path to the compiled browser entry point.
+const corePkgDir = resolve(__dirname, "..");
+const browserEntry = resolve(corePkgDir, "dist/src/index.browser.js");
+
 /**
  * Bundles `@alloy-js/core` for the browser using Vite and returns
- * the concatenated output code.
+ * the concatenated output code and any warnings emitted during the build.
  *
- * Uses the `browser` export condition from the package exports map,
- * which resolves to the compiled browser entry. This requires the
- * package to be built first (the CI pipeline and `pnpm build` handle
- * this automatically).
+ * Uses a custom resolveId plugin to force the browser entry point,
+ * because vitest's `resolve.conditions: ["source"]` leaks into the
+ * Vite build() call even with `configFile: false`, causing the test
+ * to resolve TypeScript source files instead of compiled dist.
  */
-async function bundleForBrowser(): Promise<string> {
+async function bundleForBrowser(): Promise<{
+  code: string;
+  warnings: string[];
+}> {
+  const warnings: string[] = [];
   const result = await build({
     configFile: false,
     logLevel: "silent",
     resolve: {
       conditions: ["browser", "import"],
+      mainFields: ["browser", "module", "main"],
     },
     // Disable automatic process.env replacement so we can detect leaks
     define: {},
+    plugins: [
+      {
+        name: "force-browser-entry",
+        enforce: "pre",
+        resolveId(source) {
+          // Force @alloy-js/core to resolve to the compiled browser entry,
+          // bypassing vitest's "source" condition that would resolve to TS.
+          if (source === "@alloy-js/core") {
+            return browserEntry;
+          }
+          return null;
+        },
+      },
+      {
+        name: "capture-warnings",
+        enforce: "post",
+        buildStart() {
+          // Hook into Vite's warning channel via rollup options
+        },
+      },
+    ],
+    customLogger: {
+      info() {},
+      error() {},
+      clearScreen() {},
+      hasErrorLogged() {
+        return false;
+      },
+      hasWarned: false,
+      warnOnce(msg: string) {
+        warnings.push(msg);
+      },
+      warn(msg: string) {
+        warnings.push(msg);
+      },
+    },
     build: {
       write: false,
       minify: false,
@@ -41,6 +86,13 @@ async function bundleForBrowser(): Promise<string> {
           // Externalize third-party deps (vue, pathe, picocolors, …)
           return true;
         },
+        onwarn(warning) {
+          warnings.push(
+            typeof warning === "string" ? warning : (
+              (warning.message ?? String(warning))
+            ),
+          );
+        },
       },
     },
   });
@@ -52,7 +104,7 @@ async function bundleForBrowser(): Promise<string> {
   const chunks = output.output.filter(
     (o): o is Rolldown.OutputChunk => o.type === "chunk",
   );
-  return chunks.map((c) => c.code).join("\n");
+  return { code: chunks.map((c) => c.code).join("\n"), warnings };
 }
 
 describe("browser build", () => {
@@ -71,7 +123,10 @@ describe("browser build", () => {
   });
 
   it("should bundle for browser without Node.js polyfills", async () => {
-    const code = await bundleForBrowser();
+    const { code, warnings } = await bundleForBrowser();
+
+    // Sanity check: the bundle should not be empty
+    expect(code.length).toBeGreaterThan(0);
 
     // The browser bundle must not reference the Node.js `process` global.
     // If this fails, a file is using process.env / process.cwd / etc.
@@ -80,5 +135,22 @@ describe("browser build", () => {
 
     // Should not contain static require("node:…") calls
     expect(code).not.toMatch(/require\(\s*["']node:/);
+
+    // Should not contain dynamic import("node:…") calls — these are the
+    // ones esbuild and other browser bundlers reject (e.g. node:sqlite, node:fs).
+    expect(code).not.toMatch(/import\(\s*["']node:/);
+
+    // Vite silently externalizes node:* modules for browser builds via its
+    // built-in rolldown:vite-resolve plugin, which hides the issue from the
+    // code assertions above. Catch those by checking for externalization warnings.
+    const nodeExternalizationWarnings = warnings.filter(
+      (w) =>
+        w.includes("externalized for browser compatibility") ||
+        w.includes("node:"),
+    );
+    expect(
+      nodeExternalizationWarnings,
+      `Node.js modules were externalized for browser compatibility — missing browser shims:\n${nodeExternalizationWarnings.join("\n")}`,
+    ).toEqual([]);
   }, 30_000);
 });