codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/material-reader/fixtures.test-helper.js

@@ -0,0 +1,169 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fixtures_test_helper_exports = {};
+__export(fixtures_test_helper_exports, {
+  makeDeck: () => makeDeck,
+  makeDocx: () => makeDocx,
+  makePdf: () => makePdf,
+  makeWorkbook: () => makeWorkbook,
+  makeZip: () => makeZip
+});
+module.exports = __toCommonJS(fixtures_test_helper_exports);
+var import_node_zlib = __toESM(require("node:zlib"));
+function makeZip(entries) {
+  const locals = [];
+  const centrals = [];
+  let offset = 0;
+  Object.entries(entries).forEach(([name, content], i) => {
+    const raw = Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8");
+    const method = i === 0 ? 0 : 8;
+    const data = method === 0 ? raw : import_node_zlib.default.deflateRawSync(raw);
+    const nameBuf = Buffer.from(name, "utf8");
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(67324752, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(method, 8);
+    local.writeUInt32LE(import_node_zlib.default.crc32(raw), 14);
+    local.writeUInt32LE(data.length, 18);
+    local.writeUInt32LE(raw.length, 22);
+    local.writeUInt16LE(nameBuf.length, 26);
+    const central = Buffer.alloc(46);
+    central.writeUInt32LE(33639248, 0);
+    central.writeUInt16LE(20, 4);
+    central.writeUInt16LE(20, 6);
+    central.writeUInt16LE(method, 10);
+    central.writeUInt32LE(import_node_zlib.default.crc32(raw), 16);
+    central.writeUInt32LE(data.length, 20);
+    central.writeUInt32LE(raw.length, 24);
+    central.writeUInt16LE(nameBuf.length, 28);
+    central.writeUInt32LE(offset, 42);
+    locals.push(local, nameBuf, data);
+    centrals.push(central, nameBuf);
+    offset += 30 + nameBuf.length + data.length;
+  });
+  const cd = Buffer.concat(centrals);
+  const eocd = Buffer.alloc(22);
+  eocd.writeUInt32LE(101010256, 0);
+  eocd.writeUInt16LE(Object.keys(entries).length, 8);
+  eocd.writeUInt16LE(Object.keys(entries).length, 10);
+  eocd.writeUInt32LE(cd.length, 12);
+  eocd.writeUInt32LE(offset, 16);
+  return Buffer.concat([...locals, cd, eocd]);
+}
+const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function makeWorkbook(sheets, opts = {}) {
+  const shared = [];
+  const names = Object.keys(sheets);
+  const col = (n) => {
+    let s = "";
+    for (let x = n; x > 0; x = Math.floor((x - 1) / 26)) s = String.fromCharCode(65 + (x - 1) % 26) + s;
+    return s;
+  };
+  const parts = {
+    "xl/workbook.xml": `<workbook xmlns:r="r"><sheets>${names.map((n, i) => `<sheet name="${esc(n)}" sheetId="${i + 1}" r:id="rId${i + 1}"/>`).join("")}</sheets></workbook>`,
+    "xl/_rels/workbook.xml.rels": `<Relationships>${names.map((_, i) => `<Relationship Id="rId${i + 1}" Target="worksheets/sheet${i + 1}.xml"/>`).join("")}</Relationships>`
+  };
+  names.forEach((name, i) => {
+    const rows = sheets[name];
+    const width = Math.max(1, ...rows.map((r) => r.length));
+    const cells = rows.map((r, ri) => `<row r="${ri + 1}">${r.map((v, ci) => {
+      const ref = `${col(ci + 1)}${ri + 1}`;
+      if (typeof v === "number") return `<c r="${ref}"><v>${v}</v></c>`;
+      shared.push(v);
+      return `<c r="${ref}" t="s"><v>${shared.length - 1}</v></c>`;
+    }).join("")}</row>`).join("");
+    parts[`xl/worksheets/sheet${i + 1}.xml`] = `<worksheet><dimension ref="A1:${col(width)}${Math.max(1, rows.length)}"/><sheetData>${cells}</sheetData></worksheet>`;
+  });
+  parts["xl/sharedStrings.xml"] = `<sst>${shared.map((s) => `<si><t>${esc(s)}</t></si>`).join("")}</sst>`;
+  if (opts.macros) parts["xl/vbaProject.bin"] = Buffer.from("not really a macro");
+  return makeZip(parts);
+}
+function makeDocx(paragraphs, table) {
+  const p = (t) => t.startsWith("# ") ? `<w:p><w:pPr><w:pStyle w:val="Heading1"/></w:pPr><w:r><w:t>${esc(t.slice(2))}</w:t></w:r></w:p>` : `<w:p><w:r><w:t xml:space="preserve">${esc(t)}</w:t></w:r></w:p>`;
+  const tbl = table ? `<w:tbl>${table.map((r) => `<w:tr>${r.map((c) => `<w:tc><w:p><w:r><w:t>${esc(c)}</w:t></w:r></w:p></w:tc>`).join("")}</w:tr>`).join("")}</w:tbl>` : "";
+  return makeZip({
+    "[Content_Types].xml": '<?xml version="1.0"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="xml" ContentType="application/xml"/><Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/></Types>',
+    "_rels/.rels": '<?xml version="1.0"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/></Relationships>',
+    "word/document.xml": `<?xml version="1.0"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body>${paragraphs.map(p).join("")}${tbl}</w:body></w:document>`
+  });
+}
+function makeDeck(slides) {
+  const parts = {
+    "ppt/presentation.xml": `<p:presentation><p:sldIdLst>${slides.map((_, i) => `<p:sldId id="${256 + i}" r:id="rId${i + 1}"/>`).join("")}</p:sldIdLst></p:presentation>`,
+    "ppt/_rels/presentation.xml.rels": `<Relationships>${slides.map((_, i) => `<Relationship Id="rId${i + 1}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide" Target="slides/slide${i + 1}.xml"/>`).join("")}</Relationships>`
+  };
+  slides.forEach(([title, ...lines], i) => {
+    parts[`ppt/slides/slide${i + 1}.xml`] = `<p:sld><p:cSld><p:spTree><p:sp><p:nvSpPr><p:nvPr><p:ph type="title"/></p:nvPr></p:nvSpPr><p:txBody><a:p><a:r><a:t>${esc(title)}</a:t></a:r></a:p></p:txBody></p:sp><p:sp><p:txBody>${lines.map((l) => `<a:p><a:r><a:t>${esc(l)}</a:t></a:r></a:p>`).join("")}</p:txBody></p:sp></p:spTree></p:cSld></p:sld>`;
+  });
+  return makeZip(parts);
+}
+function makePdf(pages) {
+  const objects = [];
+  const kids = pages.map((_, i) => `${4 + i * 2} 0 R`).join(" ");
+  objects.push("<< /Type /Catalog /Pages 2 0 R >>");
+  objects.push(`<< /Type /Pages /Kids [${kids}] /Count ${pages.length} >>`);
+  objects.push("<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>");
+  pages.forEach((text, i) => {
+    const stream = `BT /F1 18 Tf 72 720 Td (${text.replace(/[\\()]/g, (c) => `\\${c}`)}) Tj ET`;
+    objects.push(`<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << /F1 3 0 R >> >> /Contents ${5 + i * 2} 0 R >>`);
+    objects.push(`<< /Length ${stream.length} >>
+stream
+${stream}
+endstream`);
+  });
+  let out = "%PDF-1.4\n";
+  const offsets = [];
+  objects.forEach((o, i) => {
+    offsets.push(out.length);
+    out += `${i + 1} 0 obj
+${o}
+endobj
+`;
+  });
+  const xref = out.length;
+  out += `xref
+0 ${objects.length + 1}
+0000000000 65535 f 
+${offsets.map((o) => `${String(o).padStart(10, "0")} 00000 n 
+`).join("")}`;
+  out += `trailer
+<< /Size ${objects.length + 1} /Root 1 0 R >>
+startxref
+${xref}
+%%EOF
+`;
+  return Buffer.from(out, "latin1");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  makeDeck,
+  makeDocx,
+  makePdf,
+  makeWorkbook,
+  makeZip
+});

package/src/backend/services/material-reader/quote.js

@@ -0,0 +1,44 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var quote_exports = {};
+__export(quote_exports, {
+  fenceFor: () => fenceFor,
+  quoteMaterial: () => quoteMaterial
+});
+module.exports = __toCommonJS(quote_exports);
+const LANG = { csv: "csv", markdown: "markdown", text: "text" };
+function fenceFor(body) {
+  let longest = 0;
+  for (const m of body.matchAll(/`+/g)) longest = Math.max(longest, m[0].length);
+  return "`".repeat(Math.max(3, longest + 1));
+}
+function quoteMaterial(name, format, sections) {
+  if (sections.length === 0) return `Quoted from ${name}: (nothing in the part asked for)`;
+  return sections.map((s) => {
+    const fence = fenceFor(s.body);
+    return `Quoted from ${name} \u2014 ${s.heading}:
+${fence}${LANG[format] ?? "text"}
+${s.body}
+${fence}`;
+  }).join("\n\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fenceFor,
+  quoteMaterial
+});

package/src/backend/services/material-reader/reader-host.js

@@ -0,0 +1,202 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reader_host_exports = {};
+__export(reader_host_exports, {
+  READER_HEAP_MB: () => READER_HEAP_MB,
+  READ_TIMEOUT_MS: () => READ_TIMEOUT_MS,
+  readMaterial: () => readMaterial,
+  readerLaunch: () => readerLaunch,
+  readerScript: () => readerScript,
+  runReader: () => runReader
+});
+module.exports = __toCommonJS(reader_host_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_child_process = require("node:child_process");
+var import_artefact_content_service = require("../artefact-content-service");
+var import_rendition_service = require("../rendition/rendition-service");
+var import_command = require("../../mcp/connector/command");
+var import_confined_fs = require("../confined-fs");
+var import_locator = require("../../../shared/lib/locator");
+var import_cloud_files = require("../cloud-files");
+const READ_CAPS = {
+  pdf: 100 * 1024 * 1024,
+  pptx: 100 * 1024 * 1024,
+  xlsx: 25 * 1024 * 1024,
+  xlsm: 25 * 1024 * 1024,
+  docx: 25 * 1024 * 1024
+};
+const TEXT_CAP = 20 * 1024 * 1024;
+const IMAGE_CAP = 5 * 1024 * 1024;
+const IMAGE_TYPES = {
+  png: { mimeType: "image/png", magic: (b) => b.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])) },
+  jpg: { mimeType: "image/jpeg", magic: (b) => b[0] === 255 && b[1] === 216 && b[2] === 255 },
+  jpeg: { mimeType: "image/jpeg", magic: (b) => b[0] === 255 && b[1] === 216 && b[2] === 255 },
+  gif: { mimeType: "image/gif", magic: (b) => b.subarray(0, 4).toString("latin1") === "GIF8" },
+  webp: { mimeType: "image/webp", magic: (b) => b.subarray(0, 4).toString("latin1") === "RIFF" && b.subarray(8, 12).toString("latin1") === "WEBP" }
+};
+const VIDEO_EXTS = /* @__PURE__ */ new Set(["mp4", "webm", "mov"]);
+const READ_TIMEOUT_MS = 3e4;
+const READER_HEAP_MB = 768;
+function readerScript() {
+  const resourcesPath = process.resourcesPath;
+  if ((0, import_command.isPackagedElectron)({ execPath: process.execPath, electronVersion: process.versions.electron }) && resourcesPath) {
+    return import_node_path.default.join(resourcesPath, "reader", "material-reader.mjs");
+  }
+  const source = import_node_path.default.join(__dirname, "child.ts");
+  if (__filename.endsWith(".ts") && import_node_fs.default.existsSync(source)) return source;
+  const inPackage = import_node_path.default.resolve(__dirname, "..", "..", "..", "..", "reader", "material-reader.mjs");
+  if (import_node_fs.default.existsSync(inPackage)) return inPackage;
+  return import_node_path.default.join(process.cwd(), "out", "reader", "material-reader.mjs");
+}
+function readerLaunch(script, opts = {}) {
+  const heap = `--max-old-space-size=${opts.heapMb ?? READER_HEAP_MB}`;
+  const env = process.versions.electron ? { ELECTRON_RUN_AS_NODE: "1" } : {};
+  if (script.endsWith(".ts")) {
+    return { execArgv: [heap, "--import", "tsx"], cwd: import_node_path.default.resolve(__dirname, "..", "..", "..", ".."), env };
+  }
+  return { execArgv: [heap, "--permission", `--allow-fs-read=${script}`], cwd: import_node_path.default.dirname(script), env };
+}
+function runReader(req, opts = {}) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let stderr = "";
+    let outOfMemory = false;
+    let child;
+    try {
+      const script = (0, import_confined_fs.canonicalRoot)(opts.script ?? readerScript());
+      const launch = readerLaunch(script, opts);
+      child = (0, import_node_child_process.fork)(script, [], {
+        execPath: process.execPath,
+        execArgv: launch.execArgv,
+        cwd: launch.cwd,
+        env: launch.env,
+        // pdf.js warns on every load that it cannot draw, which a reader never
+        // asks it to: stdout is dropped, and stderr kept only to tell a heap
+        // limit from any other death.
+        stdio: ["ignore", "ignore", "pipe", "ipc"],
+        serialization: "advanced"
+      });
+    } catch (err) {
+      resolve({ ok: false, reason: `The reader could not start (${err.message})` });
+      return;
+    }
+    child.stderr?.on("data", (d) => {
+      const joined = stderr + d.toString();
+      if (/heap limit|out of memory/i.test(joined)) outOfMemory = true;
+      stderr = joined.slice(-4e3);
+    });
+    const timeoutMs = opts.timeoutMs ?? READ_TIMEOUT_MS;
+    const done = (r) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+      resolve(r);
+    };
+    const timer = setTimeout(() => done({
+      ok: false,
+      timedOut: true,
+      reason: `Reading ${req.name} took longer than ${Math.round(timeoutMs / 1e3)}s and was stopped. Ask for a smaller part of it.`
+    }), timeoutMs);
+    child.once("message", (reply) => done(reply));
+    child.once("error", (err) => done({ ok: false, reason: `${req.name} could not be read (${err.message})` }));
+    child.once("exit", (code, signal) => {
+      const judge = () => setImmediate(() => {
+        if (settled) return;
+        if (!outOfMemory) {
+          console.warn(`[reader] stopped without answering (code ${code}, signal ${signal}): ${stderr.trim().split("\n").slice(-5).join(" | ") || "no output"}`);
+        }
+        done({
+          ok: false,
+          reason: outOfMemory ? `${req.name} needs more memory to read than CodeTrellis allows. Ask for a smaller part of it.` : `${req.name} could not be read (the reader stopped)`
+        });
+      });
+      if (!child.connected) {
+        judge();
+        return;
+      }
+      const cap = setTimeout(judge, 2e3);
+      child.once("disconnect", () => {
+        clearTimeout(cap);
+        judge();
+      });
+    });
+    child.send({ ...req, bytes: req.bytes });
+  });
+}
+async function readBytes(file, cap) {
+  try {
+    return await (0, import_artefact_content_service.readServableCapped)(file, cap);
+  } catch (err) {
+    return err instanceof import_cloud_files.NotOnDeviceError ? "cloud" : "missing";
+  }
+}
+async function readMaterial(attachmentUid, locator, opts = {}) {
+  const file = await (0, import_artefact_content_service.resolveServable)(attachmentUid);
+  if (!file) return { ok: false, status: 404, reason: "No material with that uid is a file CodeTrellis can read" };
+  const name = import_node_path.default.basename(file.rel);
+  const ext = import_node_path.default.extname(file.rel).slice(1).toLowerCase();
+  const base = { name, itemUid: file.itemUid };
+  const hasLocator = !!locator && Object.values(locator).some((v) => v !== void 0);
+  if (VIDEO_EXTS.has(ext)) {
+    return { ok: false, status: 415, reason: `${name} is a video; it can be watched in CodeTrellis but not read as text`, ...base };
+  }
+  if (ext === "xls") {
+    return { ok: false, status: 415, reason: `${name} is an old-format Excel workbook, which is not read as text; saved as .xlsx it can be`, ...base };
+  }
+  const image = IMAGE_TYPES[ext];
+  if (image) {
+    if (hasLocator) return { ok: false, status: 422, reason: `${name} is an image; it is read whole, without a locator`, ...base };
+    const bytes2 = await readBytes(file, IMAGE_CAP);
+    if (bytes2 === "cloud") return { ok: false, status: 409, reason: `${name} is not on this device yet: it is still only in the cloud`, ...base };
+    if (bytes2 === "missing") return { ok: false, status: 404, reason: `${name} is not there, or is not a regular file in the project`, ...base };
+    if (!bytes2) return { ok: false, status: 413, reason: `${name} is larger than the ${IMAGE_CAP / 1024 / 1024} MB an image read returns`, ...base };
+    if (!image.magic(bytes2)) return { ok: false, status: 422, reason: `${name} is named .${ext} but is not that kind of image`, ...base };
+    return { ok: true, kind: "image", ...base, mimeType: image.mimeType, base64: bytes2.toString("base64"), bytes: bytes2.length };
+  }
+  const cap = READ_CAPS[ext] ?? (import_locator.TEXT_EXTS.has(ext) ? TEXT_CAP : 0);
+  if (!cap) return { ok: false, status: 415, reason: `.${ext} files are not read as text`, ...base };
+  const bytes = await readBytes(file, cap);
+  if (bytes === "cloud") return { ok: false, status: 409, reason: `${name} is not on this device yet: it is still only in the cloud`, ...base };
+  if (bytes === "missing") return { ok: false, status: 404, reason: `${name} is not there, or is not a regular file in the project`, ...base };
+  if (!bytes) return { ok: false, status: 413, reason: `${name} is larger than the ${Math.round(cap / 1024 / 1024)} MB CodeTrellis reads of a .${ext} file`, ...base };
+  const rendition = ext === "docx" || ext === "pptx" ? await (0, import_rendition_service.existingRendition)(bytes, ext, opts.engine) : null;
+  const reply = await runReader({ name, ext, bytes, locator, rendition }, opts);
+  if (!reply.ok) return { ok: false, status: "timedOut" in reply ? 504 : 422, reason: reply.reason, ...base };
+  return { ok: true, kind: "text", ...base, reply };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  READER_HEAP_MB,
+  READ_TIMEOUT_MS,
+  readMaterial,
+  readerLaunch,
+  readerScript,
+  runReader
+});

package/src/backend/services/material-signals.js

@@ -0,0 +1,141 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var material_signals_exports = {};
+__export(material_signals_exports, {
+  computeMaterialSignals: () => computeMaterialSignals
+});
+module.exports = __toCommonJS(material_signals_exports);
+var import_awareness_signals = require("./awareness-signals");
+const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+const listed = (names, max = 3) => names.length <= max ? names.join(", ") : `${names.slice(0, max).join(", ")} and ${names.length - max} more`;
+function computeMaterialSignals(tasks, current) {
+  const out = [];
+  const ordered = [...tasks].sort((a, b) => a.id.localeCompare(b.id));
+  const title = /* @__PURE__ */ new Map();
+  for (const t of ordered) for (const r of t.reads) title.set(r.owner, r.ownerTitle);
+  for (const t of ordered) title.set(t.id, t.title);
+  const labelsOf = (ids) => Object.fromEntries([...ids].sort().map((id) => [id, title.get(id) ?? id]));
+  const named = (ids) => listed(ids.map((id) => `\u201C${title.get(id) ?? id}\u201D`));
+  const withoutLabels = (subject) => {
+    const { labels: _labels, readBy: _readBy, ...rest } = subject;
+    return rest;
+  };
+  const emit = (kind, severity, key, subject, ids, summary) => out.push((0, import_awareness_signals.draft)(kind, severity, key, { ...subject, labels: labelsOf(ids) }, ids, summary, withoutLabels(subject)));
+  const readByOf = (m, ids) => {
+    const by = Object.fromEntries(ids.flatMap((id) => {
+      const who = ordered.find((t) => t.id === id)?.reads.find((r) => r.path === m)?.by;
+      return who ? [[id, who]] : [];
+    }));
+    return Object.keys(by).length ? { readBy: by } : {};
+  };
+  const materials = /* @__PURE__ */ new Set();
+  for (const t of ordered) {
+    for (const r of t.reads) materials.add(r.path);
+    for (const c of t.cited) materials.add(c.path);
+  }
+  for (const m of [...materials].sort()) {
+    const now = current[m] ?? null;
+    const readers = ordered.filter((t) => t.reads.some((r) => r.path === m));
+    const lastHash = (t) => t.reads.find((r) => r.path === m)?.sha256 ?? null;
+    const readersNamed = (ids) => listed(ids.map((id) => {
+      const by = ordered.find((t) => t.id === id)?.reads.find((r) => r.path === m)?.by;
+      return `\u201C${title.get(id) ?? id}\u201D${by ? ` (${by})` : ""}`;
+    }));
+    const changedCites = now === null ? [] : ordered.flatMap((t) => t.cited.filter((c) => c.path === m && c.sha256 !== null && c.sha256 !== now).map((c) => ({ task: t.id, ...c })));
+    const citers = [...new Set(changedCites.map((c) => c.task))];
+    const involved = [.../* @__PURE__ */ new Set([...citers, ...readers.map((t) => t.id)])].sort();
+    if (citers.length > 0 && involved.length >= 2) {
+      const parts = [...new Set(changedCites.map((c) => c.part))].sort();
+      const signedOff = [...new Set(changedCites.filter((c) => c.signedOff).map((c) => c.task))].sort();
+      const cites = `${citers.length === 1 ? `${named(citers)} cites` : `${plural(citers.length, "task")} cite`} ${listed(parts)}`;
+      const signed = signedOff.length === 0 ? "" : `; ${signedOff.length === citers.length && citers.length > 1 ? "all were" : signedOff.length === 1 && citers.length === 1 ? "it was" : `${signedOff.length} ${signedOff.length === 1 ? "was" : "were"}`} already signed off`;
+      const others = involved.filter((id) => !citers.includes(id));
+      const alsoUses = others.length ? `. ${named(others)} ${others.length === 1 ? "uses" : "use"} it too` : "";
+      emit(
+        "contract",
+        signedOff.length ? "high" : "medium",
+        `material:${m}`,
+        { material: m, parts, citedBy: citers.sort(), ...signedOff.length ? { signedOff } : {} },
+        involved,
+        `\`${m}\` changed. ${cites}${signed}${alsoUses}`
+      );
+      continue;
+    }
+    const hashes = new Set(readers.map(lastHash).filter((h) => h !== null));
+    if (readers.length >= 2 && hashes.size >= 2) {
+      const ids = readers.map((t) => t.id);
+      const readVersions = Object.fromEntries(readers.map((t) => [t.id, lastHash(t) === now ? "current" : "earlier"]));
+      const onCurrent = readers.filter((t) => lastHash(t) === now).map((t) => t.id);
+      const tail = onCurrent.length === 0 ? `; ${readers.length === 2 ? "neither" : "none"} has the current one` : `; ${named(onCurrent)} ${onCurrent.length === 1 ? "has" : "have"} the current one`;
+      emit(
+        "version-split",
+        "medium",
+        `material:${m}`,
+        { material: m, readVersions, ...readByOf(m, ids) },
+        ids,
+        `${readersNamed(ids)} read different versions of \`${m}\`${tail}`
+      );
+      continue;
+    }
+    if (now !== null && readers.length >= 2 && readers.every((t) => lastHash(t) !== null && lastHash(t) !== now)) {
+      const ids = readers.map((t) => t.id);
+      emit(
+        "stale-base",
+        "low",
+        `material:${m}`,
+        { material: m, ...readByOf(m, ids) },
+        ids,
+        `\`${m}\` changed after ${readersNamed(ids)} read it, and ${ids.length === 2 ? "neither" : "none"} has read it since`
+      );
+    }
+  }
+  const writers = /* @__PURE__ */ new Map();
+  for (const t of ordered) for (const o of new Set(t.outputs)) (writers.get(o) ?? writers.set(o, []).get(o)).push(t.id);
+  for (const [file, ids] of [...writers].sort(([a], [b]) => a.localeCompare(b))) {
+    if (ids.length < 2) continue;
+    emit(
+      "collision",
+      "medium",
+      `output:${file}`,
+      { material: file, file },
+      ids,
+      `${named(ids)} ${ids.length === 2 ? "both" : "all"} record \`${file}\` as their output`
+    );
+  }
+  for (const t of ordered) {
+    const brief = new Set(t.brief);
+    const outside = t.reads.filter((r) => !brief.has(r.path) && r.owner !== t.id);
+    if (outside.length === 0) continue;
+    const files = [...new Set(outside.map((r) => r.path))].sort();
+    const owners = [...new Set(outside.map((r) => r.owner))].filter((o) => o !== t.id).sort();
+    const ids = [t.id, ...owners];
+    emit(
+      "drift",
+      "low",
+      `material-drift:${t.id}`,
+      { material: files[0], files, by: t.id },
+      ids,
+      `${named([t.id])} read ${listed(files.map((f) => `\`${f}\``))}, which ${files.length === 1 ? "is" : "are"} not in its brief (given to ${named(owners)})`
+    );
+  }
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  computeMaterialSignals
+});