@alloy-js/core 0.23.0-dev.15 → 0.23.0-dev.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alloy-js/core",
-  "version": "0.23.0-dev.15",
+  "version": "0.23.0-dev.17",
   "description": "",
   "repository": {
     "type": "git",
@@ -66,7 +66,7 @@
     "ws": "^8.19.0"
   },
   "devDependencies": {
-    "@alloy-js/cli": "~0.22.0 || >= 0.23.0-dev.5",
+    "@alloy-js/cli": "~0.22.0 || >= 0.23.0-dev.6",
     "@alloy-js/rollup-plugin": "~0.1.0 || >= 0.1.1-dev.2",
     "@microsoft/api-extractor": "~7.52.8",
     "@rollup/plugin-typescript": "^12.1.2",

package/src/debug/diagnostics-broadcast.test.tsx

@@ -0,0 +1,98 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, expect, it } from "vitest";
+import { DiagnosticsCollector } from "../diagnostics.js";
+import { closeTrace, initTrace, setChangeListener } from "./trace-writer.js";
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = mkdtempSync(join(tmpdir(), "alloy-diag-test-"));
+});
+
+afterEach(async () => {
+  setChangeListener(null);
+  closeTrace();
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+it("does not call insertDiagnostic when tracing is disabled", () => {
+  let events = 0;
+  setChangeListener(() => {
+    events++;
+  });
+
+  const collector = new DiagnosticsCollector();
+  for (let i = 0; i < 100; i++) {
+    collector.emit({ message: `diag ${i}`, severity: "warning" });
+  }
+
+  // No trace DB => no change events should fire.
+  expect(events).toBe(0);
+  expect(collector.getDiagnostics()).toHaveLength(100);
+});
+
+it("emits one added event per diagnostic (linear, not quadratic)", async () => {
+  await initTrace(join(tmpDir, "trace.db"));
+  const events: Array<{ channel: string; action: string }> = [];
+  setChangeListener((event) => {
+    events.push({ channel: event.channel, action: event.action });
+  });
+
+  const collector = new DiagnosticsCollector();
+  const N = 50;
+  for (let i = 0; i < N; i++) {
+    collector.emit({ message: `diag ${i}`, severity: "warning" });
+  }
+
+  const added = events.filter(
+    (e) => e.channel === "diagnostics" && e.action === "added",
+  );
+  expect(added).toHaveLength(N); // was previously N*(N+1)/2 due to re-broadcast
+});
+
+it("emits one removed event per dismissal", async () => {
+  await initTrace(join(tmpDir, "trace.db"));
+  const events: Array<{ channel: string; action: string }> = [];
+  setChangeListener((event) => {
+    events.push({ channel: event.channel, action: event.action });
+  });
+
+  const collector = new DiagnosticsCollector();
+  const handles = [];
+  for (let i = 0; i < 10; i++) {
+    handles.push(collector.emit({ message: `diag ${i}`, severity: "warning" }));
+  }
+
+  for (const h of handles) h.dismiss();
+
+  const added = events.filter(
+    (e) => e.channel === "diagnostics" && e.action === "added",
+  );
+  const removed = events.filter(
+    (e) => e.channel === "diagnostics" && e.action === "removed",
+  );
+  expect(added).toHaveLength(10);
+  expect(removed).toHaveLength(10);
+  expect(collector.getDiagnostics()).toHaveLength(0);
+});
+
+it("dismiss is idempotent and only fires one removal", async () => {
+  await initTrace(join(tmpDir, "trace.db"));
+  const events: Array<{ channel: string; action: string }> = [];
+  setChangeListener((event) => {
+    events.push({ channel: event.channel, action: event.action });
+  });
+
+  const collector = new DiagnosticsCollector();
+  const h = collector.emit({ message: "once", severity: "warning" });
+  h.dismiss();
+  h.dismiss();
+  h.dismiss();
+
+  const removed = events.filter(
+    (e) => e.channel === "diagnostics" && e.action === "removed",
+  );
+  expect(removed).toHaveLength(1);
+});

package/src/debug/trace-writer.ts

@@ -801,6 +801,8 @@ export function insertRenderError(
   });
 }
 
+let stmtDeleteDiagnostic: StatementSync | undefined;
+
 export function insertDiagnostic(
   message: string,
   severity: string | undefined,
@@ -808,10 +810,10 @@ export function insertDiagnostic(
   sourceLine: number | undefined,
   sourceCol: number | undefined,
   componentStack: string | undefined,
-): void {
-  if (!db) return;
+): number | undefined {
+  if (!db) return undefined;
   const s = nextSeq();
-  stmtInsertDiagnostic.run(
+  const info = stmtInsertDiagnostic.run(
     message,
     severity ?? null,
     sourceFile ?? null,
@@ -820,7 +822,9 @@ export function insertDiagnostic(
     componentStack ?? null,
     s,
   );
+  const id = Number(info.lastInsertRowid);
   notifyChange("diagnostics", "added", {
+    id,
     message,
     severity: severity ?? null,
     source_file: sourceFile ?? null,
@@ -829,6 +833,16 @@ export function insertDiagnostic(
     component_stack: componentStack ?? null,
     seq: s,
   });
+  return id;
+}
+
+export function deleteDiagnostic(id: number): void {
+  if (!db) return;
+  if (!stmtDeleteDiagnostic) {
+    stmtDeleteDiagnostic = db.prepare(`DELETE FROM diagnostics WHERE id = ?`);
+  }
+  stmtDeleteDiagnostic.run(id);
+  notifyChange("diagnostics", "removed", { id, seq: nextSeq() });
 }
 
 /**
@@ -946,6 +960,7 @@ export function commitTransaction(): void {
 export function closeTrace(): void {
   db?.close();
   db = null;
+  stmtDeleteDiagnostic = undefined;
 }
 
 export function resetTrace(): void {

package/src/diagnostics.ts

@@ -1,5 +1,9 @@
 import { getRenderNodeId } from "./debug/index.js";
-import { insertDiagnostic } from "./debug/trace-writer.js";
+import {
+  deleteDiagnostic,
+  insertDiagnostic,
+  isTraceEnabled,
+} from "./debug/trace-writer.js";
 import { getContext } from "./reactivity.js";
 import { getRenderStackSnapshot } from "./render-stack.js";
 import type { SourceLocation } from "./runtime/component.js";
@@ -31,22 +35,31 @@ export interface DiagnosticHandle {
   dismiss(): void;
 }
 
+function buildComponentStack(): DiagnosticStackEntry[] {
+  return getRenderStackSnapshot().map((entry) => ({
+    name: entry.displayName,
+    renderNodeId:
+      entry.context?.meta?.renderNode ?
+        getRenderNodeId(entry.context.meta.renderNode)
+      : undefined,
+    source: entry.source,
+  }));
+}
+
 export class DiagnosticsCollector {
   private entries = new Map<string, Diagnostic>();
   private order: string[] = [];
+  private traceRowIds = new Map<string, number>();
 
   emit(input: DiagnosticInput): DiagnosticHandle {
+    const traceEnabled = isTraceEnabled();
+    // Component stack is only required when a trace consumer will read it,
+    // or when the caller explicitly provided one. Building it walks the full
+    // render stack, which is expensive on hot paths.
     const componentStack =
       input.componentStack ??
-      getRenderStackSnapshot().map((entry) => ({
-        name: entry.displayName,
-        renderNodeId:
-          entry.context?.meta?.renderNode ?
-            getRenderNodeId(entry.context.meta.renderNode)
-          : undefined,
-        source: entry.source,
-      }));
-    const source = input.source ?? componentStack.at(-1)?.source ?? undefined;
+      (traceEnabled ? buildComponentStack() : undefined);
+    const source = input.source ?? componentStack?.at(-1)?.source ?? undefined;
     const id = `diag-${this.order.length + 1}-${Date.now()}`;
     const diagnostic: Diagnostic = {
       id,
@@ -58,14 +71,30 @@ export class DiagnosticsCollector {
     this.entries.set(id, diagnostic);
     this.order.push(id);
 
-    // Broadcast updated diagnostics
-    this.broadcast();
+    if (traceEnabled) {
+      const rowId = insertDiagnostic(
+        diagnostic.message,
+        diagnostic.severity,
+        diagnostic.source?.fileName,
+        diagnostic.source?.lineNumber,
+        diagnostic.source?.columnNumber,
+        diagnostic.componentStack ?
+          JSON.stringify(diagnostic.componentStack)
+        : undefined,
+      );
+      if (rowId !== undefined) {
+        this.traceRowIds.set(id, rowId);
+      }
+    }
 
     return {
       dismiss: () => {
-        this.entries.delete(id);
-        // Broadcast updated diagnostics after dismissal
-        this.broadcast();
+        if (!this.entries.delete(id)) return;
+        const rowId = this.traceRowIds.get(id);
+        if (rowId !== undefined) {
+          this.traceRowIds.delete(id);
+          if (isTraceEnabled()) deleteDiagnostic(rowId);
+        }
       },
     };
   }
@@ -75,22 +104,6 @@ export class DiagnosticsCollector {
       .map((id) => this.entries.get(id))
       .filter((entry): entry is Diagnostic => Boolean(entry));
   }
-
-  private broadcast() {
-    const diagnostics = this.getDiagnostics();
-    for (const diagnostic of diagnostics) {
-      insertDiagnostic(
-        diagnostic.message,
-        diagnostic.severity,
-        diagnostic.source?.fileName,
-        diagnostic.source?.lineNumber,
-        diagnostic.source?.columnNumber,
-        diagnostic.componentStack ?
-          JSON.stringify(diagnostic.componentStack)
-        : undefined,
-      );
-    }
-  }
 }
 
 const DIAGNOSTICS_META_KEY = "diagnostics";

package/testing/vitest.d.ts

@@ -1,5 +1,25 @@
+/**
+ * Vitest matcher type augmentations for alloy testing.
+ *
+ * Consumers load these types via `"types": ["@alloy-js/core/testing/matchers"]`
+ * in their tsconfig.json. This file is resolved directly from the source tree
+ * (not from dist/), so it **must remain self-contained** — do NOT add imports
+ * that resolve to .ts source files (e.g. `./extend-expect.js`). Doing so pulls
+ * the entire src/ tree into the consumer's compilation, creating a dual-module
+ * identity conflict between src/ types and dist/ types that produces TS errors.
+ *
+ * If matcher signatures change, update the inlined types here to match.
+ */
 import "vitest";
-import type { ToRenderToOptions } from "./extend-expect.js";
+
+interface ToRenderToOptions {
+  /** Maximum line width before the formatter wraps output. */
+  printWidth?: number;
+  /** Number of spaces per indentation level. */
+  tabWidth?: number;
+  /** Use tab characters instead of spaces. */
+  useTabs?: boolean;
+}
 
 interface ExpectedDiagnostic {
   message: string | RegExp;