@inerrata-corporation/errata 2.0.19 → 2.0.20-dev.3682

package/resources/context-plugin/dist/server.mjs

@@ -0,0 +1,521 @@
+// src/server.ts
+import { createServer } from "node:http";
+import { randomBytes } from "node:crypto";
+import { readFile as readFile2, mkdir, writeFile } from "node:fs/promises";
+import { join as join2, resolve as resolve2 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+
+// src/source.ts
+import { createHash } from "node:crypto";
+import { readFile, readdir, stat as stat2 } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { homedir } from "node:os";
+
+// src/context.ts
+function parsePriors(body, handles) {
+  const nodes = /* @__PURE__ */ new Map();
+  let section = "";
+  let fenced = false;
+  for (const line of body.split(/\r?\n/)) {
+    if (/^\s*```/.test(line)) {
+      fenced = !fenced;
+      continue;
+    }
+    if (fenced) continue;
+    if (/^###? /.test(line)) {
+      section = line.replace(/^#+\s*/, "");
+      continue;
+    }
+    if (!/^(Active workspace profile|Recently observed problems|Prior knowledge|From the Errata Network|Priors for|Current intent|Relevant priors)/i.test(
+      section
+    ))
+      continue;
+    const references = [...line.matchAll(/`\[([\w@:/.-]+)\]`/g)];
+    for (const match of references) {
+      const handle = match[1];
+      const mapped = handles[handle];
+      const prefix = line.slice(0, match.index);
+      const explicitId = /`([^`\s]+)`\s*$/.exec(prefix)?.[1];
+      const id = explicitId ?? mapped?.id ?? handle;
+      const label = /^- \*\*([A-Za-z]+):\*\*/.exec(line)?.[1] ?? mapped?.label ?? (/observed problems/i.test(section) ? "Problem" : "Prior");
+      let text = prefix.replace(/^\s*-\s*/, "").replace(/^\*\*[A-Za-z]+:\*\*\s*/, "").replace(/\s*[—–]\s*`[^`]+`\s*$/, "").replace(/\*\*/g, "").trim();
+      if (/Active workspace profile/.test(section)) {
+        text = prefix.split(/,\s*/).at(-1).replace(/^.*?:\s*/, "").replace(/`|\*\*/g, "").trim();
+      }
+      nodes.set(id, {
+        id,
+        label,
+        handle,
+        text: text || handle,
+        role: "prior",
+        provenance: /Errata Network/.test(section) ? "collective" : "local"
+      });
+    }
+  }
+  return [...nodes.values()].slice(0, 100);
+}
+
+// src/graph.ts
+import { DatabaseSync } from "node:sqlite";
+
+// src/types.ts
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+// src/graph.ts
+var SEMANTIC_EDGES = [
+  "CAUSED_BY",
+  "FIXED_BY",
+  "SOLVED_BY",
+  "INSTANCE_OF",
+  "GENERALIZES",
+  "CONTRADICTS",
+  "SUPPORTS",
+  "CONFIRMS",
+  "REFUTES",
+  "ANCHORED_AT",
+  "CONCERNS"
+];
+var PreviewGraph = class {
+  db;
+  constructor(path) {
+    this.db = new DatabaseSync(path, { readOnly: true });
+    this.db.exec("PRAGMA query_only = ON; PRAGMA busy_timeout = 250;");
+  }
+  close() {
+    this.db.close();
+  }
+  slice(priors, bursts) {
+    const nodes = /* @__PURE__ */ new Map();
+    const edges = /* @__PURE__ */ new Map();
+    const getNode = this.db.prepare(
+      "SELECT id, label, description, extraction_confidence, attrs_json FROM nodes WHERE id = ? AND valid_to IS NULL"
+    );
+    const enrich = (n) => {
+      const row = getNode.get(n.id);
+      if (!row) return n;
+      let attrs = {};
+      try {
+        attrs = record(JSON.parse(String(row.attrs_json)));
+      } catch {
+      }
+      return {
+        ...n,
+        label: String(row.label),
+        // Primed prose is the text the agent actually received; keep it intact.
+        text: n.role === "prior" ? n.text : String(row.description),
+        confidence: Number(row.extraction_confidence),
+        ...typeof attrs.relPath === "string" ? { path: attrs.relPath } : {}
+      };
+    };
+    for (const n of priors) nodes.set(n.id, enrich(n));
+    for (const burst of [...bursts].reverse()) {
+      for (const n of burst.nodes)
+        if (!nodes.has(n.id) && nodes.size < 220) nodes.set(n.id, enrich(n));
+      for (const e of burst.edges) edges.set(`${e.source}|${e.type}|${e.target}`, e);
+    }
+    const seedIds = [...nodes.keys()];
+    const neighbors = (direction, index) => this.db.prepare(`
+      SELECT e.from_id, e.to_id, e.type FROM edges e
+      INDEXED BY ${index}
+      WHERE e.valid_to IS NULL AND e.type IN (${SEMANTIC_EDGES.map(() => "?").join(",")})
+      AND e.${direction} = ?
+      ORDER BY e.confidence DESC, e.id LIMIT 5`);
+    const outgoingNeighbors = neighbors("from_id", "edges_from");
+    const incomingNeighbors = neighbors("to_id", "edges_to");
+    let added = 0;
+    for (const id of priors.map((n) => n.id)) {
+      for (const e of [
+        ...outgoingNeighbors.all(...SEMANTIC_EDGES, id),
+        ...incomingNeighbors.all(...SEMANTIC_EDGES, id)
+      ]) {
+        const other = String(e.from_id === id ? e.to_id : e.from_id);
+        if (!nodes.has(other) && added < 36 && nodes.size < 256) {
+          const row = getNode.get(other);
+          if (row) {
+            nodes.set(
+              other,
+              enrich({
+                id: other,
+                label: String(row.label),
+                text: String(row.description),
+                provenance: "local",
+                role: "neighbor"
+              })
+            );
+            added++;
+          }
+        }
+      }
+    }
+    const outgoing = this.db.prepare(
+      "SELECT from_id, to_id, type FROM edges INDEXED BY edges_from WHERE from_id = ? AND valid_to IS NULL LIMIT 300"
+    );
+    for (const id of [.../* @__PURE__ */ new Set([...seedIds, ...nodes.keys()])]) {
+      for (const e of outgoing.all(id)) {
+        const edge = { source: String(e.from_id), target: String(e.to_id), type: String(e.type) };
+        if (nodes.has(edge.target)) edges.set(`${edge.source}|${edge.type}|${edge.target}`, edge);
+      }
+    }
+    return {
+      nodes: [...nodes.values()],
+      edges: [...edges.values()].filter((e) => nodes.has(e.source) && nodes.has(e.target)).slice(0, 600)
+    };
+  }
+};
+function snapshotOnly(priors, bursts) {
+  const nodes = new Map(priors.map((n) => [n.id, n]));
+  for (const burst of [...bursts].reverse())
+    for (const n of burst.nodes) {
+      if (!nodes.has(n.id) && nodes.size < 220) nodes.set(n.id, n);
+    }
+  const edges = /* @__PURE__ */ new Map();
+  for (const burst of bursts)
+    for (const e of burst.edges) {
+      if (nodes.has(e.source) && nodes.has(e.target))
+        edges.set(`${e.source}|${e.type}|${e.target}`, e);
+    }
+  return { nodes: [...nodes.values()], edges: [...edges.values()] };
+}
+
+// src/transcript.ts
+import { open, stat } from "node:fs/promises";
+import { StringDecoder } from "node:string_decoder";
+function textContent(value) {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return "";
+  return value.map((v) => typeof record(v).text === "string" ? record(v).text : "").join("\n");
+}
+function parseBurst(value, id, at) {
+  const result = record(value);
+  if (result.isError === true) return null;
+  let data = record(result.structuredContent);
+  if (!Array.isArray(data.results)) {
+    try {
+      data = record(JSON.parse(textContent(result.content ?? value)));
+    } catch {
+      data = result;
+    }
+  }
+  if (!Array.isArray(data.results) || typeof data.seed !== "string") return null;
+  const nodes = [];
+  const edges = [];
+  for (const raw of data.results.slice(0, 100)) {
+    const n = record(raw);
+    if (typeof n.id !== "string") continue;
+    const via = record(n.via);
+    const traversal = typeof via.parentId === "string" && typeof via.edgeType === "string" && typeof via.forward === "boolean" ? { parentId: via.parentId, edgeType: via.edgeType, forward: via.forward } : void 0;
+    nodes.push({
+      id: n.id,
+      label: typeof n.label === "string" ? n.label : "Prior",
+      text: typeof n.name === "string" ? n.name : n.id,
+      provenance: typeof n.provenance === "string" ? n.provenance : "unknown",
+      role: "burst",
+      ...typeof n.score === "number" && Number.isFinite(n.score) ? { score: n.score } : {},
+      ...typeof n.hops === "number" && Number.isInteger(n.hops) && n.hops >= 0 ? { hops: n.hops } : {},
+      ...traversal ? { via: traversal } : {}
+    });
+    if (traversal) {
+      edges.push({
+        source: traversal.forward ? traversal.parentId : n.id,
+        target: traversal.forward ? n.id : traversal.parentId,
+        type: traversal.edgeType
+      });
+    }
+  }
+  if (!nodes.length) return null;
+  for (const raw of Array.isArray(data.edges) ? data.edges.slice(0, 300) : []) {
+    const e = record(raw);
+    const source2 = e.from ?? e.source;
+    const target = e.to ?? e.target;
+    const type = e.type ?? e.edgeType;
+    if (typeof source2 === "string" && typeof target === "string" && typeof type === "string")
+      edges.push({ source: source2, target, type });
+  }
+  const seed = nodes.find((n) => n.id === data.seed);
+  if (!seed)
+    nodes.unshift({
+      id: data.seed,
+      text: data.seed,
+      label: "Seed",
+      role: "burst",
+      provenance: typeof data.seedProvenance === "string" ? data.seedProvenance : "unknown"
+    });
+  return { id, at, seed: data.seed, title: seed?.text ?? data.seed, nodes, edges };
+}
+var TranscriptState = class {
+  context = null;
+  bursts = [];
+  seen = /* @__PURE__ */ new Set();
+  calls = /* @__PURE__ */ new Set();
+  accept(value) {
+    const row = record(value);
+    const p = record(row.payload);
+    const at = typeof row.timestamp === "string" ? row.timestamp : "";
+    if (row.type === "response_item" && p.type === "message" && p.role === "developer") {
+      const body = textContent(p.content);
+      if (body.includes("## Errata context") && /Errata loaded the maintained|errata daemon has updated your live/i.test(body)) {
+        this.context = { body: body.slice(body.indexOf("## Errata context")), at, source: "task" };
+      }
+    }
+    if (row.type === "event_msg" && p.type === "item_completed") {
+      const item = record(p.item);
+      if (item.type === "McpToolCall" && item.server === "errata" && /^errata[._]burst$/.test(String(item.tool)) && item.status === "completed") {
+        this.addBurst(item.result, String(item.id), at);
+      }
+    }
+    if (row.type !== "response_item") return;
+    if (p.type === "function_call" && /^(?:mcp__errata__)?errata[._]burst$/.test(String(p.name))) {
+      this.calls.add(String(p.call_id));
+      if (this.calls.size > 128) this.calls.delete(this.calls.values().next().value);
+    }
+    if (p.type === "function_call_output" && this.calls.delete(String(p.call_id))) {
+      this.addBurst(p.output, String(p.call_id), at);
+    }
+  }
+  addBurst(value, id, at) {
+    if (this.seen.has(id)) return;
+    const burst = parseBurst(value, id, at);
+    if (!burst) return;
+    this.seen.add(id);
+    if (this.seen.size > 256) this.seen.delete(this.seen.values().next().value);
+    this.bursts = [...this.bursts, burst].slice(-6);
+  }
+};
+var TranscriptTail = class {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+  state = new TranscriptState();
+  offset = 0;
+  pending = "";
+  decoder = new StringDecoder("utf8");
+  inode = null;
+  async update() {
+    const info = await stat(this.path);
+    if (info.size < this.offset || this.inode !== null && info.ino !== this.inode) {
+      this.offset = 0;
+      this.pending = "";
+      this.decoder = new StringDecoder("utf8");
+      this.state = new TranscriptState();
+    }
+    this.inode = info.ino;
+    if (info.size === this.offset) return;
+    const file = await open(this.path, "r");
+    try {
+      const buffer = Buffer.alloc(Math.min(info.size - this.offset, 16 * 1024 * 1024));
+      const { bytesRead } = await file.read(buffer, 0, buffer.length, this.offset);
+      this.offset += bytesRead;
+      const lines = (this.pending + this.decoder.write(buffer.subarray(0, bytesRead))).split("\n");
+      this.pending = lines.pop() ?? "";
+      for (const line of lines) {
+        try {
+          this.state.accept(JSON.parse(line));
+        } catch {
+        }
+      }
+      if (this.pending.length > 4 * 1024 * 1024) this.pending = "";
+    } finally {
+      await file.close();
+    }
+  }
+};
+
+// src/source.ts
+function createSource(workspace, sessionId2, transcript) {
+  const root2 = resolve(workspace);
+  if (sessionId2 && !/^[\w-]{1,100}$/.test(sessionId2)) throw new Error("Invalid task id");
+  let transcriptPath = transcript ? resolve(transcript) : null;
+  let tail = null;
+  let graph = null;
+  let nextDiscovery = 0;
+  let updating = null;
+  async function findTranscript(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return null;
+    }
+    for (const e of entries.sort((a, b) => b.name.localeCompare(a.name))) {
+      if (e.isFile() && e.name.endsWith(`-${sessionId2}.jsonl`)) return join(dir, e.name);
+      if (e.isDirectory()) {
+        const found = await findTranscript(join(dir, e.name));
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  async function refresh() {
+    const warnings = [];
+    if (!transcriptPath && sessionId2 && Date.now() > nextDiscovery) {
+      nextDiscovery = Date.now() + 15e3;
+      transcriptPath = await findTranscript(
+        join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "sessions")
+      );
+    }
+    if (transcriptPath) {
+      tail ??= new TranscriptTail(transcriptPath);
+      try {
+        await tail.update();
+      } catch {
+        warnings.push("Task transcript is temporarily unavailable.");
+      }
+    }
+    let context = tail?.state.context ?? null;
+    if (!context) {
+      try {
+        const path = join(root2, ".errata", "context.md");
+        context = {
+          body: await readFile(path, "utf8"),
+          at: (await stat2(path)).mtime.toISOString(),
+          source: "workspace"
+        };
+      } catch {
+      }
+    }
+    let handles = {};
+    try {
+      const raw = record(
+        JSON.parse(await readFile(join(root2, ".errata", "priming-handles.json"), "utf8"))
+      );
+      for (const [key, value] of Object.entries(raw)) {
+        const entry = record(value);
+        if (typeof entry.id === "string" && typeof entry.label === "string")
+          handles[key] = { id: entry.id, label: entry.label };
+      }
+    } catch {
+    }
+    const priors = parsePriors(context?.body ?? "", handles);
+    const bursts = tail?.state.bursts ?? [];
+    let slice = snapshotOnly(priors, bursts);
+    try {
+      graph ??= new PreviewGraph(join(root2, ".errata", "castalia.db"));
+      slice = graph.slice(priors, bursts);
+    } catch {
+      warnings.push("Local graph unavailable; showing recorded priors and burst results.");
+    }
+    if (sessionId2 && !transcriptPath)
+      warnings.push("Waiting for this task\u2019s transcript; showing the workspace snapshot.");
+    const byId = new Map(slice.nodes.map((n) => [n.id, n]));
+    const displayBursts = bursts.map((b) => ({ ...b, title: byId.get(b.seed)?.text ?? b.title }));
+    const content = {
+      workspace: basename(root2),
+      sessionId: sessionId2,
+      context: {
+        at: context?.at ?? "",
+        source: context?.source ?? "waiting",
+        priorIds: priors.map((n) => n.id)
+      },
+      ...slice,
+      bursts: displayBursts,
+      warnings
+    };
+    return {
+      revision: createHash("sha256").update(JSON.stringify(content)).digest("hex").slice(0, 16),
+      ...content
+    };
+  }
+  return {
+    read() {
+      updating ??= refresh().finally(() => {
+        updating = null;
+      });
+      return updating;
+    },
+    close() {
+      graph?.close();
+    }
+  };
+}
+
+// src/server.ts
+var { values } = parseArgs({
+  options: {
+    root: { type: "string" },
+    session: { type: "string" },
+    transcript: { type: "string" },
+    port: { type: "string", default: "0" }
+  }
+});
+var root = resolve2(values.root ?? process.cwd());
+var sessionId = values.session ?? process.env.CODEX_THREAD_ID ?? null;
+if (sessionId && !/^[\w-]{1,100}$/.test(sessionId)) throw new Error("Invalid task id");
+var port = Number(values.port);
+if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error("Invalid port");
+var dist = fileURLToPath(new URL(".", import.meta.url));
+var token = randomBytes(24).toString("hex");
+var source = createSource(root, sessionId, values.transcript);
+await source.read();
+var server = createServer(async (req, res) => {
+  const address = server.address();
+  const authority = `127.0.0.1:${typeof address === "object" && address ? address.port : port}`;
+  if (req.headers.host !== authority || req.headers.origin && req.headers.origin !== `http://${authority}`) {
+    res.writeHead(403).end();
+    return;
+  }
+  if (req.method !== "GET") {
+    res.writeHead(405).end();
+    return;
+  }
+  const url = new URL(req.url ?? "/", `http://${authority}`);
+  const prefix = `/${token}/`;
+  if (!url.pathname.startsWith(prefix)) {
+    res.writeHead(404).end();
+    return;
+  }
+  const name = url.pathname.slice(prefix.length);
+  res.setHeader("Cache-Control", "no-store");
+  res.setHeader("X-Content-Type-Options", "nosniff");
+  res.setHeader("Referrer-Policy", "no-referrer");
+  res.setHeader(
+    "Content-Security-Policy",
+    "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self'; object-src 'none'; frame-ancestors 'none'"
+  );
+  try {
+    if (name === "api/state") {
+      const state = await source.read();
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify(state));
+      return;
+    }
+    if (name === "health") {
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify({ ok: true, root, sessionId, pid: process.pid }));
+      return;
+    }
+    const asset = name === "" ? "index.html" : name;
+    const mime = {
+      "index.html": "text/html; charset=utf-8",
+      "client.js": "text/javascript",
+      "style.css": "text/css"
+    };
+    if (!mime[asset]) {
+      res.writeHead(404).end();
+      return;
+    }
+    res.setHeader("Content-Type", mime[asset]);
+    res.end(await readFile2(join2(dist, asset)));
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : "Preview read failed");
+    res.writeHead(503).end("Preview temporarily unavailable");
+  }
+});
+server.listen(port, "127.0.0.1", async () => {
+  const address = server.address();
+  if (!address || typeof address === "string") return;
+  const url = `http://127.0.0.1:${address.port}/${token}/`;
+  const info = { url, root, sessionId, pid: process.pid };
+  const output = join2(root, ".errata", "context-preview");
+  await mkdir(output, { recursive: true });
+  await writeFile(join2(output, `${sessionId ?? "workspace"}.json`), JSON.stringify(info, null, 2));
+  console.log(JSON.stringify(info));
+});
+for (const signal of ["SIGINT", "SIGTERM"])
+  process.on(signal, () => {
+    source.close();
+    server.close(() => process.exit(0));
+  });

package/resources/context-plugin/dist/style.css

@@ -0,0 +1,189 @@
+:root {
+  color-scheme: dark;
+  --surface: #181818;
+  --ink: #deddda;
+  --muted: #888784;
+  --causal-ink: #f2c788;
+  font: 11px/1.45
+    var(--font-sans, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif);
+  background: var(--color-background-primary, var(--surface));
+  color: var(--color-text-primary, var(--ink));
+}
+* {
+  box-sizing: border-box;
+}
+html,
+body {
+  margin: 0;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+}
+body {
+  min-height: 240px;
+}
+[hidden] {
+  display: none !important;
+}
+#viewport {
+  position: absolute;
+  inset: 0;
+  outline: none;
+  touch-action: none;
+}
+canvas {
+  display: block;
+  width: 100%;
+  height: 100%;
+}
+#viewport:focus-visible {
+  outline: 1px solid var(--muted);
+  outline-offset: -2px;
+}
+#empty {
+  position: absolute;
+  inset: 0;
+  display: grid;
+  place-items: center;
+  color: var(--color-text-secondary, var(--muted));
+  pointer-events: none;
+}
+#floating-labels {
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+  overflow: hidden;
+}
+.floating-label {
+  position: absolute;
+  left: 0;
+  top: 0;
+  height: 16px;
+  line-height: 16px;
+  font-size: 10px;
+  letter-spacing: 0.01em;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  overflow: hidden;
+  opacity: 0;
+  color: var(--color-text-primary, var(--ink));
+  text-shadow: 0 1px 4px var(--color-background-primary, var(--surface));
+  transition: opacity 180ms ease;
+  will-change: transform;
+}
+.floating-label.focused {
+  font-weight: 500;
+}
+.floating-label[data-causal='true'] {
+  color: var(--causal-ink);
+  font-weight: 600;
+}
+@media (prefers-reduced-motion: reduce) {
+  .floating-label {
+    transition: none;
+  }
+}
+#node-label {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: max-content;
+  max-width: min(270px, calc(100vw - 24px));
+  padding: 8px 10px;
+  border-radius: 7px;
+  background: color-mix(in srgb, var(--color-background-primary, var(--surface)) 93%, transparent);
+  border: 1px solid #8882;
+  font-size: 11px;
+  line-height: 1.5;
+  pointer-events: none;
+  overflow-wrap: anywhere;
+  white-space: pre-line;
+  box-shadow: 0 4px 22px #0002;
+}
+#activity {
+  position: absolute;
+  bottom: 14px;
+  left: 16px;
+  right: 16px;
+  max-width: 430px;
+  pointer-events: none;
+  color: var(--color-text-secondary, var(--muted));
+  font-size: 10px;
+  line-height: 1.6;
+}
+#log {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+#log button {
+  appearance: none;
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  width: 100%;
+  border: 0;
+  background: none;
+  padding: 0;
+  text-align: left;
+  font: inherit;
+  color: inherit;
+  cursor: pointer;
+  pointer-events: auto;
+}
+#log button:hover,
+#log button:focus-visible {
+  color: var(--color-text-primary, var(--ink));
+}
+#log time {
+  font-variant-numeric: tabular-nums;
+  opacity: 0.6;
+  flex: none;
+}
+#log span {
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+#log button:first-child {
+  opacity: 0.5;
+}
+#log button:last-child {
+  opacity: 1;
+}
+#log button.active span::before {
+  content: '·';
+  margin-right: 6px;
+  color: #c8a84e;
+}
+#notice {
+  margin-bottom: 5px;
+  max-width: 38ch;
+  color: var(--color-text-secondary, var(--muted));
+}
+#notice:empty {
+  display: none;
+}
+@media (prefers-color-scheme: light) {
+  :root {
+    color-scheme: light;
+    --surface: #faf9f7;
+    --ink: #292825;
+    --muted: #777570;
+    --causal-ink: #835313;
+  }
+}
+:root[data-theme='dark'] {
+  color-scheme: dark;
+  --surface: #181818;
+  --ink: #deddda;
+  --muted: #888784;
+  --causal-ink: #f2c788;
+}
+:root[data-theme='light'] {
+  color-scheme: light;
+  --surface: #faf9f7;
+  --ink: #292825;
+  --muted: #777570;
+  --causal-ink: #835313;
+}