@wenathlan/devthink 2.0.13 → 2.0.15

package/tests/stepmeter.test.ts

@@ -0,0 +1,200 @@
+import { describe, expect, it } from "vitest";
+import {
+  coldstartverdict,
+  durationsampleof,
+  durationsampletoperf,
+  selectorprofileof,
+  selectorstatsupdate,
+  slomopause,
+  slomoresume,
+  slomosessionof,
+  slomostepdelay,
+  spanchildren,
+  startupsampleof,
+  steptracefile,
+  steptracespanof,
+} from "../perf.js";
+import { slowmofactorvalid } from "../policy.js";
+import { sessionmemory } from "../memory.js";
+
+const now = 1_800_000_000_000;
+
+class fakeadapter {
+  private readonly data = new Map<string, unknown>();
+  async get<T>(key: string): Promise<T | undefined> {
+    return this.data.get(key) as T | undefined;
+  }
+  async set<T>(key: string, value: T): Promise<void> {
+    this.data.set(key, value);
+  }
+}
+
+describe("durationmeter", () => {
+  it("measures every step with monotonic clocks and writes the samples into the perf records", () => {
+    const sample = durationsampleof({ stepid: "s1", start: 100.5, end: 220.75 });
+    expect(sample).toEqual({ stepid: "s1", start: 100.5, end: 220.75, duration: 120.25, monotonic: true });
+    expect(durationsampleof({ stepid: "s1", start: 300, end: 100 }).duration).toBe(0);
+    expect(durationsampleof({ stepid: "s1", start: 1, end: 2, monotonic: false }).monotonic).toBe(false);
+    expect(() => durationsampleof({ stepid: " ", start: 0, end: 1 })).toThrow(/step id/i);
+    const record = durationsampletoperf({
+      runid: "run1",
+      sample,
+      queries: 2,
+      cachehits: 1,
+      delta: false,
+      now,
+      provenance: { origin: "https://example.com", environment: "pagecontext", task: "durationmeter" },
+    });
+    expect(record.duration).toBe(120.25);
+    expect(record.provenance.task).toBe("durationmeter");
+  });
+});
+
+describe("selectorprofile", () => {
+  it("counts the resolution time and the failure rate per selector and flags the selectors above the user latency threshold", () => {
+    const stats = selectorprofileof({
+      selector: "#button",
+      samples: [
+        { duration: 80, ok: true },
+        { duration: 120, ok: true },
+        { duration: 100, ok: false },
+      ],
+      threshold: 90,
+    });
+    expect(stats).toEqual({
+      selector: "#button",
+      count: 3,
+      totalduration: 300,
+      average: 100,
+      failures: 1,
+      failurerate: 1 / 3,
+      flagged: true,
+    });
+    expect(
+      selectorprofileof({ selector: "#button", samples: [{ duration: 50, ok: true }], threshold: 90 }).flagged,
+    ).toBe(false);
+    expect(selectorprofileof({ selector: "#button", samples: [] }).count).toBe(0);
+    expect(() => selectorprofileof({ selector: " ", samples: [] })).toThrow(/selector/i);
+    const updated = selectorstatsupdate(stats, { selector: "#button", duration: 100, ok: true, threshold: 90 });
+    expect(updated.count).toBe(4);
+    expect(updated.average).toBe(100);
+    expect(selectorstatsupdate(undefined, { selector: "#fresh", duration: 40, ok: true }).count).toBe(1);
+  });
+
+  it("stores the selectorprofile stats of the profile workspace", async () => {
+    const store = new sessionmemory(new fakeadapter());
+    await store.setselectorprofile(
+      selectorprofileof({ selector: "#button", samples: [{ duration: 100, ok: true }], threshold: 90 }),
+    );
+    expect(await store.getselectorprofiles()).toHaveLength(1);
+    await store.setselectorprofile(
+      selectorprofileof({ selector: "#button", samples: [{ duration: 300, ok: false }], threshold: 90 }),
+    );
+    const latest = (await store.getselectorprofiles()).find((stats) => stats.selector === "#button");
+    expect(latest?.count).toBe(1);
+    expect(latest?.failures).toBe(1);
+  });
+});
+
+describe("steptrace", () => {
+  it("nests spans per step and per worker task through their parent refs", () => {
+    const parent = steptracespanof({ runid: "run1", stepid: "s1", start: 1, end: 5, cause: "navigate dispatch" });
+    const child = steptracespanof({
+      runid: "run1",
+      task: "htmlsnapshot",
+      start: 2,
+      end: 4,
+      cause: "worker parse",
+      parent: parent.id,
+    });
+    expect(spanchildren([parent, child], parent.id)).toEqual([child]);
+    expect(spanchildren([parent, child], child.id)).toEqual([]);
+    expect(() => steptracespanof({ runid: " ", start: 1, end: 2, cause: "x" })).toThrow(/run id/i);
+  });
+
+  it("exports a trace file for the timeline view with its spans in start order", () => {
+    const late = steptracespanof({ runid: "run1", stepid: "s2", start: 10, end: 20, cause: "click dispatch" });
+    const early = steptracespanof({ runid: "run1", stepid: "s1", start: 1, end: 9, cause: "navigate dispatch" });
+    const file = steptracefile({ runid: "run1", spans: [late, early] });
+    expect(file.format).toBe("devthink-steptrace");
+    expect(file.events).toBe(2);
+    expect(file.spans.map((span) => span.stepid)).toEqual(["s1", "s2"]);
+    expect(() => steptracefile({ runid: " ", spans: [] })).toThrow(/run id/i);
+  });
+
+  it("stores the steptrace spans of one run through the memory store", async () => {
+    const store = new sessionmemory(new fakeadapter());
+    await store.addsteptracespan(
+      steptracespanof({ runid: "run1", stepid: "s1", start: 1, end: 2, cause: "navigate dispatch" }),
+    );
+    await store.addsteptracespan(
+      steptracespanof({ runid: "run1", stepid: "s2", start: 3, end: 4, cause: "click dispatch" }),
+    );
+    expect(await store.getsteptrace("run1")).toHaveLength(2);
+    await store.clearsteptrace("run1");
+    expect(await store.getsteptrace("run1")).toHaveLength(0);
+  });
+});
+
+describe("startupmeter and coldstart", () => {
+  it("measures the cold start from the startup event to ready with the lazymods budget spent", () => {
+    const sample = startupsampleof({ startedat: now, readyat: now + 400, spent: 3, target: 500 });
+    expect(sample).toEqual({ startedat: now, readyat: now + 400, duration: 400, spent: 3, target: 500 });
+    expect(startupsampleof({ startedat: now, readyat: now, spent: 0 }).target).toBeUndefined();
+    const verdict = coldstartverdict({ sample, heavy: ["capture", "compare"], firstpaint: ["capture"] });
+    expect(verdict.withintarget).toBe(true);
+    expect(verdict.heavyinfirstpaint).toEqual(["capture"]);
+    const late = coldstartverdict({
+      sample: startupsampleof({ startedat: now, readyat: now + 900, spent: 2, target: 500 }),
+      heavy: [],
+      firstpaint: [],
+    });
+    expect(late.withintarget).toBe(false);
+    const untargeted = coldstartverdict({
+      sample: startupsampleof({ startedat: now, readyat: now + 900, spent: 2 }),
+      heavy: [],
+      firstpaint: [],
+    });
+    expect(untargeted.withintarget).toBe(true);
+    expect(untargeted.reason).toMatch(/no cold start target/i);
+  });
+
+  it("records the startupmeter samples of the profile workspace", async () => {
+    const store = new sessionmemory(new fakeadapter());
+    await store.addstartupsample(startupsampleof({ startedat: now, readyat: now + 400, spent: 3 }));
+    await store.addstartupsample(startupsampleof({ startedat: now, readyat: now + 300, spent: 2 }));
+    const samples = await store.getstartupsamples();
+    expect(samples).toHaveLength(2);
+    expect(samples[0]?.duration).toBe(300);
+  });
+});
+
+describe("slowmo replay", () => {
+  it("replays a recorded run at the chosen speed factor with pauses between steps for inspection", () => {
+    const session = slomosessionof({ runid: "run1", factor: 0.5, now });
+    expect(session.factor).toBe(0.5);
+    expect(slomosessionof({ runid: "run1", now }).factor).toBe(1);
+    expect(() => slomosessionof({ runid: " ", now })).toThrow(/run id/i);
+    expect(slomostepdelay({ factor: 0.5, duration: 1000 })).toBe(2000);
+    expect(slomostepdelay({ factor: 2, duration: 1000 })).toBe(500);
+    const paused = slomopause({ session, stepid: "s2", spanid: "span9" });
+    expect(paused.paused).toBe(true);
+    expect(paused.stepid).toBe("s2");
+    expect(paused.spanid).toBe("span9");
+    expect(slomoresume(paused).paused).toBe(false);
+    expect(slowmofactorvalid({ factor: 0.5 }).allowed).toBe(true);
+    expect(slowmofactorvalid({}).reason).toMatch(/recorded speed/i);
+    expect(slowmofactorvalid({ factor: 0 }).allowed).toBe(false);
+  });
+
+  it("stores the slowmo replay sessions of the profile workspace", async () => {
+    const store = new sessionmemory(new fakeadapter());
+    await store.setslomosession(slomosessionof({ runid: "run1", factor: 0.5, now }));
+    await store.setslomosession(
+      slomopause({ session: slomosessionof({ runid: "run1", factor: 0.5, now }), stepid: "s1", spanid: "span1" }),
+    );
+    const sessions = await store.getslomosessions();
+    expect(sessions).toHaveLength(1);
+    expect(sessions[0]?.paused).toBe(true);
+  });
+});

package/tests/streamparse.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it } from "vitest";
+import {
+  chunkextractprogress,
+  chunkextracttaskof,
+  chunkextractwindow,
+  mergechunkwindows,
+  openchunkextractcursor,
+  resumechunkextract,
+  streamparsechunkof,
+  streamparseobservations,
+  streamparsewindows,
+  validatesetreamparsechunk,
+} from "../data.js";
+import { chunkextractgate, streamparsegate } from "../policy.js";
+
+describe("streamparse progressive observations", () => {
+  it("splits a large page into chunk windows without ever holding the full text", () => {
+    const windows = streamparsewindows({ bytes: 2500, chunkbytes: 1000 });
+    expect(windows.chunks).toBe(3);
+    expect(windows.windows).toEqual([
+      { index: 0, start: 0, end: 1000 },
+      { index: 1, start: 1000, end: 2000 },
+      { index: 2, start: 2000, end: 2500 },
+    ]);
+    expect(() => streamparsewindows({ bytes: 10, chunkbytes: 0 })).toThrow(/positive number of bytes/i);
+  });
+
+  it("tokenizes one chunk into text, element and attribute tokens and refuses chunks over the byte bound", () => {
+    const chunk = streamparsechunkof({
+      index: 0,
+      text: '<h1 class="title">Hello</h1> world',
+      chunkbytes: 100,
+      last: true,
+    });
+    expect(chunk.index).toBe(0);
+    expect(chunk.complete).toBe(true);
+    expect(chunk.tokens.map((token) => token.kind)).toContain("element");
+    expect(chunk.tokens.map((token) => token.kind)).toContain("attribute");
+    expect(chunk.observations.join(" ")).toMatch(/Hello/i);
+    expect(() => streamparsechunkof({ index: 0, text: "a".repeat(50), chunkbytes: 10, last: true })).toThrow(
+      /byte bound/i,
+    );
+  });
+
+  it("validates every chunk through the same schemastrict shape before any observation yields", () => {
+    const chunk = streamparsechunkof({ index: 1, text: "plain text", chunkbytes: 100, last: false });
+    expect(validatesetreamparsechunk(chunk, 1).valid).toBe(true);
+    expect(validatesetreamparsechunk(chunk, 0).valid).toBe(false);
+    expect(validatesetreamparsechunk({}, 0).valid).toBe(false);
+    expect(validatesetreamparsechunk({ index: 0, tokens: [], bytes: 0, complete: true }, 0).valid).toBe(true);
+    expect(streamparsegate({ chunk, expectedindex: 1 }).allowed).toBe(true);
+    expect(streamparsegate({ chunk, expectedindex: 2 }).allowed).toBe(false);
+    expect(streamparsegate({ chunk, expectedindex: 2 }).reason).toMatch(/out of order/i);
+  });
+
+  it("yields observations progressively as chunks complete", () => {
+    const chunks = [
+      streamparsechunkof({ index: 0, text: "first part", chunkbytes: 100, last: false }),
+      streamparsechunkof({ index: 1, text: "second part", chunkbytes: 100, last: true }),
+    ];
+    const yield1 = streamparseobservations([chunks[0] as never]);
+    const yield2 = streamparseobservations(chunks);
+    expect(yield1.progressive).toHaveLength(1);
+    expect(yield2.total).toBeGreaterThan(yield1.total);
+    expect(yield2.progressive[0]).toEqual(yield1.progressive[0]);
+  });
+});
+
+describe("chunkextract windowing, resume and merge", () => {
+  const rows = Array.from({ length: 25 }, (_, index) => ({ id: String(index), name: `row${index}` }));
+
+  it("opens a cursor with its table fingerprint and slices the table into row windows", () => {
+    const cursor = openchunkextractcursor({
+      tableid: "table1",
+      fingerprint: "abc12345",
+      rows: rows.length,
+      window: 10,
+    });
+    expect(cursor.rowindex).toBe(0);
+    expect(cursor.window).toBe(10);
+    expect(cursor.complete).toBe(false);
+    const first = chunkextractwindow({ cursor, rows });
+    expect(first.rows).toHaveLength(10);
+    expect(first.cursor.rowindex).toBe(10);
+    expect(first.complete).toBe(false);
+    const second = chunkextractwindow({ cursor: first.cursor, rows });
+    expect(second.rows).toHaveLength(10);
+    const third = chunkextractwindow({ cursor: second.cursor, rows });
+    expect(third.rows).toHaveLength(5);
+    expect(third.cursor.complete).toBe(true);
+    expect(third.complete).toBe(true);
+    expect(() => openchunkextractcursor({ tableid: " ", fingerprint: "f", rows: 5 })).toThrow(/table id/i);
+    expect(() => openchunkextractcursor({ tableid: "t", fingerprint: " ", rows: 5 })).toThrow(/fingerprint/i);
+    expect(() => openchunkextractcursor({ tableid: "t", fingerprint: "f", rows: 5, window: 0 })).toThrow(
+      /positive row count/i,
+    );
+  });
+
+  it("resumes from its cursor after an interruption and refuses changed fingerprints", () => {
+    const cursor = openchunkextractcursor({ tableid: "table1", fingerprint: "abc12345", rows: 25, window: 10 });
+    const advanced = chunkextractwindow({ cursor, rows }).cursor;
+    expect(resumechunkextract({ cursor: advanced, tableid: "table1", fingerprint: "abc12345" }).resumed).toBe(true);
+    const wrongtable = resumechunkextract({ cursor: advanced, tableid: "table2", fingerprint: "abc12345" });
+    expect(wrongtable.resumed).toBe(false);
+    expect(wrongtable.reason).toMatch(/belongs to the table table1/i);
+    const changed = resumechunkextract({ cursor: advanced, tableid: "table1", fingerprint: "changed" });
+    expect(changed.resumed).toBe(false);
+    expect(changed.reason).toMatch(/fingerprint changed/i);
+    const completed = resumechunkextract({
+      cursor: { ...advanced, complete: true },
+      tableid: "table1",
+      fingerprint: "abc12345",
+    });
+    expect(completed.resumed).toBe(false);
+    expect(chunkextractgate({ cursor: advanced, tableid: "table1", fingerprint: "abc12345" }).allowed).toBe(true);
+    expect(chunkextractgate({ cursor: advanced, tableid: "table1", fingerprint: "nope" }).allowed).toBe(false);
+  });
+
+  it("merges the windows into the datagrid incrementally without duplicating rows", () => {
+    const cursor = openchunkextractcursor({
+      tableid: "table1",
+      fingerprint: "abc12345",
+      rows: rows.length,
+      window: 10,
+    });
+    const first = chunkextractwindow({ cursor, rows });
+    const second = chunkextractwindow({ cursor: first.cursor, rows });
+    const third = chunkextractwindow({ cursor: second.cursor, rows });
+    const merged = mergechunkwindows([first, second, third]);
+    expect(merged.rows).toHaveLength(25);
+    expect(merged.duplicates).toBe(0);
+    const repeated = mergechunkwindows([first, first]);
+    expect(repeated.duplicates).toBe(10);
+    expect(repeated.rows).toHaveLength(10);
+  });
+
+  it("reads the cursor progress line and shapes the worker task payloads", () => {
+    const cursor = openchunkextractcursor({ tableid: "table1", fingerprint: "abc12345", rows: 25, window: 10 });
+    const advanced = chunkextractwindow({ cursor, rows }).cursor;
+    const progress = chunkextractprogress(advanced, 25);
+    expect(progress).toEqual({ extracted: 10, total: 25, share: 0.4, complete: false });
+    const task = chunkextracttaskof({
+      runid: "run1",
+      stepid: "s1",
+      tableid: "table1",
+      fingerprint: "abc12345",
+      rowindex: 10,
+      window: 10,
+    });
+    expect(task).toEqual({
+      task: "chunkextract",
+      runid: "run1",
+      stepid: "s1",
+      tableid: "table1",
+      fingerprint: "abc12345",
+      rowindex: 10,
+      window: 10,
+    });
+    expect(() =>
+      chunkextracttaskof({ runid: "run1", stepid: "s1", tableid: "t", fingerprint: "f", rowindex: 0, window: 0 }),
+    ).toThrow(/positive row window/i);
+  });
+});

package/tests/stylepruning.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from "vitest";
+import { readFile } from "node:fs/promises";
+
+/** The surface sources whose generated markup the pruning scan reads beside the one design file. */
+const surfacesources = [
+  "views.ts",
+  "web/sidepanel.ts",
+  "web/dashboardpage.ts",
+  "web/popup.ts",
+  "web/optionspage.ts",
+  "web/transparencypage.ts",
+];
+
+/**
+ * The style pruning enforcement of the 2.0.2 final polish (roadmap rc.2 item 43): the scan re-runs over web/index.html and the surface sources exactly the way the pruning pass did — every class selector of the embedded extension stylesheet must resolve to a class some surface renders through a class attribute, a className assignment (literal, ternary or template), an object literal property, a classList call or a setAttribute write.
+ * The diffrow kind suffixes stay the one documented dynamic composition: the snapshot and console diffs render `diffrow ${entry.kind}` and `diffrow ${line.kind}` (sidepanel.ts) whose kind unions of types.ts carry added, removed and changed, so those three classes stay kept and noted rather than pruned.
+ */
+
+/** Collects every class token the given text renders: class attributes, className expressions with their ternaries and template literals, object literal className properties, classList calls and setAttribute writes. */
+async function usedclassesof(text: string): Promise<{ used: Set<string>; composed: string[] }> {
+  const used = new Set<string>();
+  const composed: string[] = [];
+  for (const match of text.matchAll(/class="([^"]*)"/g))
+    for (const token of (match[1] ?? "").split(/\s+/)) if (token) used.add(token);
+  for (const match of text.matchAll(/className\s*=\s*([^;\n]+);?/g)) {
+    for (const literal of (match[1] ?? "").matchAll(/"([^"]*)"|`([^`]*)`/g)) {
+      const value = literal[1] ?? literal[2] ?? "";
+      for (const token of value.split(/[\s${}]+/)) if (token) used.add(token);
+      if (value.includes("${")) composed.push(value.trim());
+    }
+  }
+  for (const match of text.matchAll(/className:\s*"([^"]*)"/g))
+    for (const token of (match[1] ?? "").split(/\s+/)) if (token) used.add(token);
+  for (const match of text.matchAll(/classList\.(?:add|toggle|remove)\(([^;\n]+)\)/g)) {
+    for (const literal of (match[1] ?? "").matchAll(/"([^"]*)"|`([^`]*)`/g)) {
+      const value = literal[1] ?? literal[2] ?? "";
+      for (const token of value.split(/[\s${}]+/)) if (token) used.add(token);
+      if (value.includes("${")) composed.push(value.trim());
+    }
+  }
+  for (const match of text.matchAll(/setAttribute\("class",\s*"([^"]*)"\)/g))
+    for (const token of (match[1] ?? "").split(/\s+/)) if (token) used.add(token);
+  return { used, composed };
+}
+
+describe("the style pruning of the extension pages", () => {
+  it("keeps zero unused class selectors in the embedded extension stylesheet", async () => {
+    const design = await readFile("web/design.html", "utf8");
+    const stylesheet = /<style data-source="extension">([\s\S]*?)<\/style>/.exec(design)?.[1] ?? "";
+    expect(stylesheet).not.toBe("");
+    const styleclasses = new Set([...stylesheet.matchAll(/\.[a-z][a-z0-9-]*/g)].map((match) => match[0]!.slice(1)));
+    expect(styleclasses.size).toBeGreaterThan(50);
+    const { used, composed } = await usedclassesof(design);
+    for (const source of surfacesources) {
+      const scanned = await usedclassesof(await readFile(source, "utf8"));
+      for (const token of scanned.used) used.add(token);
+      composed.push(...scanned.composed);
+    }
+    /* the diffrow kind suffixes ride the kind unions the diff and console renders interpolate (sidepanel.ts `diffrow ${entry.kind}` and `diffrow ${line.kind}`), so the scan keeps them instead of pruning them: the classes the composition may produce stay documented here. */
+    const dynamiccomposed = new Set(["added", "removed", "changed"]);
+    const unused = [...styleclasses].filter((token) => !used.has(token) && !dynamiccomposed.has(token)).sort();
+    expect(unused).toEqual([]);
+    /* the noted dynamic compositions really ride a template literal over the diffrow rules the stylesheet keeps */
+    expect(composed.filter((value) => value.startsWith("diffrow ")).length).toBeGreaterThanOrEqual(2);
+    for (const token of dynamiccomposed) expect([...styleclasses].some((cls) => cls === token)).toBe(true);
+  });
+
+  it("keeps the pruned selector families out of the stylesheet while the classes the surfaces render stay declared", async () => {
+    const design = await readFile("web/design.html", "utf8");
+    const stylesheet = /<style data-source="extension">([\s\S]*?)<\/style>/.exec(design)?.[1] ?? "";
+    /* the families the 2.0.2 pruning removed: no surface template and no generated markup literal ever rendered them — the run lifecycle rows render plain list items beside runbadge, the memory marks render nothing since the statedepth pass writes plain text, the vision word boxes never render beside the wordoverlay caption, the editor library list carries no class of its own and the idem key never rendered — so the rules stay pruned and the assertion holds the pruning in place */
+    for (const pruned of [".runrow", ".idemkey", ".memorymark", "span.wordbox", ".editorlibrary"])
+      expect(stylesheet.includes(pruned)).toBe(false);
+    /* every class the surface templates render still resolves to a rule: the pruning removed rules only, never a class any surface uses */
+    const styleclasses = new Set([...stylesheet.matchAll(/\.[a-z][a-z0-9-]*/g)].map((match) => match[0]!.slice(1)));
+    for (const template of design.matchAll(/<template data-surface="([^"]+)">([\s\S]*?)<\/template>/g)) {
+      for (const match of (template[2] ?? "").matchAll(/class="([^"]*)"/g)) {
+        for (const token of (match[1] ?? "").split(/\s+/)) {
+          if (token) expect(styleclasses.has(token)).toBe(true);
+        }
+      }
+    }
+    /* the classes the state machines toggle stay declared exactly like the wcag sweep demands */
+    for (const source of surfacesources) {
+      const text = await readFile(source, "utf8");
+      for (const match of text.matchAll(/classList\.(?:add|toggle|remove)\("([^"]+)"\)/g))
+        expect(styleclasses.has(match[1]!)).toBe(true);
+    }
+  });
+});