codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/task-records/heads.js

@@ -0,0 +1,88 @@
+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 heads_exports = {};
+__export(heads_exports, {
+  allHeadChecks: () => allHeadChecks,
+  allSplits: () => allSplits,
+  headOf: () => headOf,
+  headsBy: () => headsBy,
+  setHead: () => setHead,
+  setHeadCheck: () => setHeadCheck,
+  splitOf: () => splitOf
+});
+module.exports = __toCommonJS(heads_exports);
+var import_database = require("../database");
+var import_persistence = require("../persistence");
+function headOf(itemUid) {
+  const v = (0, import_database.getDb)().exec("SELECT writer, counter, split FROM task_record_heads WHERE item_uid = ?", [itemUid])[0]?.values[0];
+  return v ? { writer: String(v[0]), counter: Number(v[1]), split: v[2] ?? null } : null;
+}
+function setHead(itemUid, writer, counter, split, check = null) {
+  (0, import_database.getDb)().run(
+    `INSERT INTO task_record_heads (item_uid, writer, counter, split, verdict) VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(item_uid) DO UPDATE SET writer = excluded.writer, counter = excluded.counter, split = excluded.split, verdict = excluded.verdict`,
+    [itemUid, writer, counter, split, check ? JSON.stringify(check) : null]
+  );
+  (0, import_persistence.markDirty)();
+}
+function setHeadCheck(itemUid, check) {
+  (0, import_database.getDb)().run("UPDATE task_record_heads SET verdict = ? WHERE item_uid = ?", [JSON.stringify(check), itemUid]);
+  (0, import_persistence.markDirty)();
+}
+function allHeadChecks() {
+  const out = /* @__PURE__ */ new Map();
+  for (const r of (0, import_database.getDb)().exec("SELECT item_uid, verdict FROM task_record_heads WHERE verdict IS NOT NULL")[0]?.values ?? []) {
+    try {
+      out.set(String(r[0]), JSON.parse(String(r[1])));
+    } catch {
+    }
+  }
+  return out;
+}
+function headsBy(writer) {
+  return ((0, import_database.getDb)().exec("SELECT item_uid, counter FROM task_record_heads WHERE writer = ? AND split IS NULL AND verdict IS NOT NULL", [writer])[0]?.values ?? []).map((r) => ({ itemUid: String(r[0]), counter: Number(r[1]) }));
+}
+function splitOf(itemUid) {
+  const s = headOf(itemUid)?.split;
+  if (!s) return null;
+  try {
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+}
+function allSplits() {
+  const out = /* @__PURE__ */ new Map();
+  for (const r of (0, import_database.getDb)().exec("SELECT item_uid, split FROM task_record_heads WHERE split IS NOT NULL")[0]?.values ?? []) {
+    try {
+      out.set(String(r[0]), JSON.parse(String(r[1])));
+    } catch {
+    }
+  }
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  allHeadChecks,
+  allSplits,
+  headOf,
+  headsBy,
+  setHead,
+  setHeadCheck,
+  splitOf
+});

package/src/backend/services/task-records/material-reads.js

@@ -0,0 +1,225 @@
+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 material_reads_exports = {};
+__export(material_reads_exports, {
+  READS_DIR: () => READS_DIR,
+  forgetReadsBy: () => forgetReadsBy,
+  forgetTeammateReads: () => forgetTeammateReads,
+  materialReadsChoice: () => materialReadsChoice,
+  readCounts: () => readCounts,
+  readTeammateReads: () => readTeammateReads,
+  readerWords: () => readerWords,
+  setMaterialReadsChoice: () => setMaterialReadsChoice,
+  writeReadRecord: () => writeReadRecord
+});
+module.exports = __toCommonJS(material_reads_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_database = require("../database");
+var import_persistence = require("../persistence");
+var import_confined_fs = require("../confined-fs");
+var import_cloud_files = require("../cloud-files");
+var import_plan_service = require("../plan-service");
+var import_plan_item_service = require("../plan-item-service");
+var import_record = require("./record");
+var import_read_record = require("./read-record");
+var import_trust = require("./trust");
+const READS_DIR = import_node_path.default.join(".codetrellis", "reads");
+const MAX_FILES_PER_ITEM = 5e3;
+const FILE = /^([a-f0-9]{8,32})-(\d{1,9})\.yaml$/;
+function materialReadsChoice(projectRoot, sharingTaskState) {
+  const v = (0, import_database.getDb)().exec("SELECT enabled, changed_at, changed_by FROM shared_material_reads WHERE project_root = ?", [projectRoot])[0]?.values[0];
+  const chosenOn = v ? Number(v[0]) === 1 : true;
+  return {
+    enabled: sharingTaskState && chosenOn,
+    chosen: !!v,
+    changedAt: v ? Number(v[1]) : null,
+    changedBy: v ? String(v[2]) : null
+  };
+}
+function setMaterialReadsChoice(projectRoot, enabled, by) {
+  (0, import_database.getDb)().run(
+    `INSERT INTO shared_material_reads (project_root, enabled, changed_at, changed_by) VALUES (?, ?, ?, ?)
+     ON CONFLICT(project_root) DO UPDATE SET enabled = excluded.enabled, changed_at = excluded.changed_at, changed_by = excluded.changed_by`,
+    [projectRoot, enabled ? 1 : 0, Date.now(), by]
+  );
+  (0, import_persistence.markDirty)();
+}
+function forgetTeammateReads(projectRoot) {
+  const trimmed = projectRoot.replace(/[\\/]+$/, "");
+  const before = (0, import_database.getDb)().exec("SELECT COUNT(*) FROM teammate_material_reads")[0]?.values[0]?.[0];
+  (0, import_database.getDb)().run(
+    "DELETE FROM teammate_material_reads WHERE plan_uid IN (SELECT uid FROM plans WHERE project_path = ? OR project_path = ?)",
+    [projectRoot, trimmed]
+  );
+  const after = (0, import_database.getDb)().exec("SELECT COUNT(*) FROM teammate_material_reads")[0]?.values[0]?.[0];
+  const gone = Number(before ?? 0) - Number(after ?? 0);
+  if (gone) (0, import_persistence.markDirty)();
+  return gone;
+}
+function forgetReadsBy(writer) {
+  (0, import_database.getDb)().run("DELETE FROM teammate_material_reads WHERE writer = ?", [writer]);
+  (0, import_persistence.markDirty)();
+}
+function filesIn(dir) {
+  try {
+    return import_node_fs.default.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && FILE.test(e.name)).map((e) => e.name).slice(0, MAX_FILES_PER_ITEM);
+  } catch {
+    return [];
+  }
+}
+function readFile(home, dir, name, where) {
+  const file = import_node_path.default.join(dir, name);
+  if ((0, import_cloud_files.isPlaceholder)(file)) return null;
+  let text;
+  try {
+    text = (0, import_confined_fs.readTextWithin)(home, file, "material-read record");
+  } catch {
+    return null;
+  }
+  const parsed = (0, import_read_record.parseReadRecord)(text, where);
+  if (!("record" in parsed)) return null;
+  const m = FILE.exec(name);
+  if (parsed.record.writer !== m[1] || parsed.record.counter !== Number(m[2])) return null;
+  return parsed;
+}
+function writeReadRecord(where, read, now = Date.now()) {
+  if (!(0, import_record.isRecordId)(read.plan) || !(0, import_record.isRecordId)(read.item)) return null;
+  const dir = import_node_path.default.join(where.home, READS_DIR, read.plan, read.item);
+  const mine = filesIn(dir).map((name) => ({ name, counter: Number(FILE.exec(name)[2]), writer: FILE.exec(name)[1] })).filter((f) => f.writer === where.me).sort((a, b) => b.counter - a.counter);
+  for (const f of mine) {
+    const r = readFile(where.home, dir, f.name, read)?.record;
+    if (r?.material !== read.material) continue;
+    if (r.sha256 === read.sha256) return null;
+    break;
+  }
+  let counter = (mine[0]?.counter ?? 0) + 1;
+  while (import_node_fs.default.existsSync(import_node_path.default.join(dir, `${where.me}-${counter}.yaml`))) counter++;
+  const record = {
+    writer: where.me,
+    name: where.name,
+    counter,
+    at: now,
+    plan: read.plan,
+    item: read.item,
+    by: read.by,
+    material: read.material,
+    attachment: read.attachment,
+    sha256: read.sha256
+  };
+  const signature = (0, import_trust.signRecord)(where.projectRoot, where.home, record, (0, import_read_record.readRecordBytes)(record));
+  return (0, import_confined_fs.writeFileWithin)(where.home, import_node_path.default.join(dir, `${where.me}-${counter}.yaml`), (0, import_read_record.serializeReadRecord)(record, signature), "material-read record");
+}
+function readerWords(r, verifiedAs) {
+  const who = verifiedAs ?? r.name;
+  const person = r.by.authorType === "human" || r.by.authorType === "unverified" || r.by.author === r.name;
+  return person ? who : `${r.by.author} for ${who}`;
+}
+function readTeammateReads(projectRoot, home, me, onlyPlan) {
+  const root = import_node_path.default.join(home, READS_DIR);
+  const dirs = (d) => {
+    try {
+      return import_node_fs.default.readdirSync(d, { withFileTypes: true }).filter((e) => e.isDirectory() && (0, import_record.isRecordId)(e.name)).map((e) => e.name);
+    } catch {
+      return [];
+    }
+  };
+  const known = (writer, item, counter) => !!(0, import_database.getDb)().exec("SELECT 1 FROM teammate_material_reads WHERE writer = ? AND item_uid = ? AND counter = ?", [writer, item, counter])[0]?.values[0];
+  let ctx = null;
+  let added = 0;
+  for (const plan of dirs(root)) {
+    if (onlyPlan && plan !== onlyPlan) continue;
+    if ((0, import_plan_service.getPlan)(plan)?.projectPath !== projectRoot) continue;
+    for (const item of dirs(import_node_path.default.join(root, plan))) {
+      const it = (0, import_plan_item_service.getItem)(item);
+      if (!it || it.planUid !== plan) continue;
+      const dir = import_node_path.default.join(root, plan, item);
+      for (const name of filesIn(dir)) {
+        const m = FILE.exec(name);
+        if (m[1] === me || known(m[1], item, Number(m[2]))) continue;
+        const parsed = readFile(home, dir, name, { plan, item });
+        if (!parsed) continue;
+        const r = parsed.record;
+        ctx ??= (0, import_trust.checkContext)(projectRoot);
+        const v = (0, import_trust.verifyTaskRecord)(r, parsed.signed, ctx);
+        (0, import_database.getDb)().run(
+          `INSERT OR IGNORE INTO teammate_material_reads (writer, item_uid, counter, plan_uid, name, reader, attachment_uid, path, sha256, at, verdict)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            r.writer,
+            item,
+            r.counter,
+            plan,
+            v.verified ? v.who : r.name,
+            readerWords(r, v.verified ? v.who : null),
+            r.attachment,
+            r.material,
+            r.sha256,
+            r.at,
+            JSON.stringify(v.verified ? { verified: true, how: v.how, who: v.who } : { verified: false, why: v.why })
+          ]
+        );
+        added++;
+      }
+    }
+  }
+  if (added) (0, import_persistence.markDirty)();
+  return added;
+}
+function readCounts(projectRoot, home, me) {
+  let mine = 0;
+  if (home) {
+    const root = import_node_path.default.join(home, READS_DIR);
+    const dirs = (d) => {
+      try {
+        return import_node_fs.default.readdirSync(d, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+      } catch {
+        return [];
+      }
+    };
+    for (const plan of dirs(root)) for (const item of dirs(import_node_path.default.join(root, plan))) mine += filesIn(import_node_path.default.join(root, plan, item)).filter((n) => n.startsWith(`${me}-`)).length;
+  }
+  const trimmed = projectRoot.replace(/[\\/]+$/, "");
+  const rows = (0, import_database.getDb)().exec(
+    `SELECT name FROM teammate_material_reads WHERE plan_uid IN (SELECT uid FROM plans WHERE project_path = ? OR project_path = ?)`,
+    [projectRoot, trimmed]
+  )[0]?.values ?? [];
+  return { mine, teammates: rows.length, people: [...new Set(rows.map((r) => String(r[0])))].sort() };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  READS_DIR,
+  forgetReadsBy,
+  forgetTeammateReads,
+  materialReadsChoice,
+  readCounts,
+  readTeammateReads,
+  readerWords,
+  setMaterialReadsChoice,
+  writeReadRecord
+});

package/src/backend/services/task-records/read-record.js

@@ -0,0 +1,100 @@
+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 read_record_exports = {};
+__export(read_record_exports, {
+  MAX_READ_RECORD_BYTES: () => MAX_READ_RECORD_BYTES,
+  parseReadRecord: () => parseReadRecord,
+  readRecordBytes: () => readRecordBytes,
+  serializeReadRecord: () => serializeReadRecord
+});
+module.exports = __toCommonJS(read_record_exports);
+var import_yaml = require("yaml");
+var import_signing = require("./signing");
+var import_material_place = require("../material-place");
+const KIND = "material-read";
+const MAX_READ_RECORD_BYTES = 8 * 1024;
+const WRITER = /^[a-f0-9]{8,32}$/;
+const ID = /^[a-z0-9][a-z0-9-]{0,63}$/i;
+const SHA = /^[a-f0-9]{64}$/;
+const text = (v, max) => typeof v === "string" && v.length > 0 ? v.slice(0, max) : null;
+function bodyOf(r) {
+  return {
+    kind: KIND,
+    writer: r.writer,
+    name: r.name,
+    counter: r.counter,
+    at: new Date(r.at).toISOString(),
+    plan: r.plan,
+    item: r.item,
+    by: r.by,
+    material: r.material,
+    attachment: r.attachment,
+    sha256: r.sha256
+  };
+}
+function readRecordBytes(r) {
+  return (0, import_signing.canonicalJson)(bodyOf(r));
+}
+function serializeReadRecord(r, signature) {
+  const body = signature ? { ...bodyOf(r), signature } : bodyOf(r);
+  return `# CodeTrellis: which version of a material a task read, written once by one device.
+${(0, import_yaml.stringify)(body, { lineWidth: 0 })}`;
+}
+function parseReadRecord(source, where) {
+  if (Buffer.byteLength(source, "utf8") > MAX_READ_RECORD_BYTES) return { error: "larger than a read record can be" };
+  let raw;
+  try {
+    raw = (0, import_yaml.parse)(source, { maxAliasCount: 0 });
+  } catch {
+    return { error: "not YAML" };
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { error: "not a record" };
+  const { signature: rawSignature, ...r } = raw;
+  if (r.kind !== KIND) return { error: "not a material-read record" };
+  const writer = typeof r.writer === "string" && WRITER.test(r.writer) ? r.writer : null;
+  if (!writer) return { error: "no writer" };
+  const counter = Number.isSafeInteger(r.counter) && r.counter > 0 ? r.counter : null;
+  if (!counter) return { error: "no counter" };
+  if (r.plan !== where.plan || r.item !== where.item) return { error: "names another task than its folder" };
+  const material = typeof r.material === "string" && r.material.length <= 1024 && (0, import_material_place.isStoredPlace)(r.material) ? r.material : null;
+  if (!material) return { error: "names no material in the project or its plans folder" };
+  const at = typeof r.at === "string" ? Date.parse(r.at) : NaN;
+  const by = r.by && typeof r.by === "object" ? r.by : {};
+  return {
+    signed: { bytes: (0, import_signing.canonicalJson)(r), signature: (0, import_signing.parseSignature)(rawSignature) },
+    record: {
+      writer,
+      name: text(r.name, 120) ?? "someone",
+      counter,
+      at: Number.isFinite(at) ? at : 0,
+      plan: where.plan,
+      item: where.item,
+      by: { author: text(by.author, 120) ?? "someone", authorType: text(by.authorType, 40) ?? "unknown" },
+      material,
+      attachment: typeof r.attachment === "string" && ID.test(r.attachment) ? r.attachment : null,
+      sha256: typeof r.sha256 === "string" && SHA.test(r.sha256) ? r.sha256 : null
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_READ_RECORD_BYTES,
+  parseReadRecord,
+  readRecordBytes,
+  serializeReadRecord
+});

package/src/backend/services/task-records/record.js

@@ -0,0 +1,173 @@
+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 record_exports = {};
+__export(record_exports, {
+  MAX_RECORD_BYTES: () => MAX_RECORD_BYTES,
+  distinctRecords: () => distinctRecords,
+  heads: () => heads,
+  isRecordId: () => isRecordId,
+  parseRecord: () => parseRecord,
+  readItem: () => readItem,
+  recordBytes: () => recordBytes,
+  recordFileName: () => recordFileName,
+  sameState: () => sameState,
+  seenOf: () => seenOf,
+  serializeRecord: () => serializeRecord,
+  supersedes: () => supersedes
+});
+module.exports = __toCommonJS(record_exports);
+var import_yaml = require("yaml");
+var import_signing = require("./signing");
+const MAX_RECORD_BYTES = 16 * 1024;
+const MAX_SEEN = 256;
+const STATUSES = /* @__PURE__ */ new Set(["pending", "assigned", "in_progress", "blocked", "done", "skipped"]);
+const ID = /^[a-z0-9][a-z0-9-]{0,63}$/i;
+const WRITER = /^[a-f0-9]{8,32}$/;
+const text = (v, max) => typeof v === "string" && v.length > 0 ? v.slice(0, max) : null;
+function recordFileName(writer, counter) {
+  return `${writer}-${counter}.yaml`;
+}
+function bodyOf(r) {
+  return {
+    writer: r.writer,
+    name: r.name,
+    counter: r.counter,
+    seen: r.seen,
+    at: new Date(r.at).toISOString(),
+    plan: r.plan,
+    item: r.item,
+    by: r.by,
+    state: r.state
+  };
+}
+function recordBytes(r) {
+  return (0, import_signing.canonicalJson)(bodyOf(r));
+}
+function serializeRecord(r, signature) {
+  const body = signature ? { ...bodyOf(r), signature } : bodyOf(r);
+  return `# CodeTrellis task state, written once by one device and never edited.
+# The state everyone sees is read from all of these; delete none.
+${(0, import_yaml.stringify)(body, { lineWidth: 0 })}`;
+}
+function parseRecord(source, where) {
+  if (Buffer.byteLength(source, "utf8") > MAX_RECORD_BYTES) return { error: "larger than a record can be" };
+  let raw;
+  try {
+    raw = (0, import_yaml.parse)(source, { maxAliasCount: 0 });
+  } catch {
+    return { error: "not YAML" };
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { error: "not a record" };
+  const { signature: rawSignature, ...r } = raw;
+  const writer = typeof r.writer === "string" && WRITER.test(r.writer) ? r.writer : null;
+  if (!writer) return { error: "no writer" };
+  const counter = Number.isSafeInteger(r.counter) && r.counter > 0 ? r.counter : null;
+  if (!counter) return { error: "no counter" };
+  if (r.plan !== where.plan || r.item !== where.item) return { error: "names another task than its folder" };
+  const seen = {};
+  if (r.seen && typeof r.seen === "object" && !Array.isArray(r.seen)) {
+    const entries = Object.entries(r.seen);
+    if (entries.length > MAX_SEEN) return { error: "names too many writers" };
+    for (const [w, c] of entries) {
+      if (WRITER.test(w) && w !== writer && Number.isSafeInteger(c) && c > 0) seen[w] = c;
+    }
+  }
+  const at = typeof r.at === "string" ? Date.parse(r.at) : NaN;
+  const by = r.by && typeof r.by === "object" ? r.by : {};
+  const s = r.state && typeof r.state === "object" && !Array.isArray(r.state) ? r.state : null;
+  if (!s) return { error: "no state" };
+  const status = typeof s.status === "string" && STATUSES.has(s.status) ? s.status : null;
+  const pct = typeof s.progressPercent === "number" && Number.isFinite(s.progressPercent) ? Math.max(0, Math.min(100, Math.round(s.progressPercent))) : null;
+  return {
+    // Everything but the signature, exactly as the file has it: a field
+    // added or changed after signing makes these bytes differ.
+    signed: { bytes: (0, import_signing.canonicalJson)(r), signature: (0, import_signing.parseSignature)(rawSignature) },
+    record: {
+      writer,
+      name: text(r.name, 120) ?? "someone",
+      counter,
+      seen,
+      at: Number.isFinite(at) ? at : 0,
+      plan: where.plan,
+      item: where.item,
+      by: { author: text(by.author, 120) ?? "someone", authorType: text(by.authorType, 40) ?? "unknown" },
+      state: {
+        status,
+        assignee: text(s.assignee, 200),
+        assigneeType: text(s.assigneeType, 40),
+        progressPercent: pct,
+        blockedReason: text(s.blockedReason, 500)
+      }
+    }
+  };
+}
+function isRecordId(id) {
+  return ID.test(id);
+}
+function supersedes(a, b) {
+  if (a.writer === b.writer) return a.counter > b.counter;
+  return (a.seen[b.writer] ?? 0) >= b.counter;
+}
+function distinctRecords(records) {
+  const byKey = /* @__PURE__ */ new Map();
+  const clashing = [];
+  for (const r of records) {
+    const key = `${r.writer}-${r.counter}`;
+    const known = byKey.get(key);
+    if (!known) {
+      byKey.set(key, r);
+      continue;
+    }
+    if (JSON.stringify(known) !== JSON.stringify(r)) clashing.push(r);
+  }
+  return { records: [...byKey.values()], clashing };
+}
+function heads(records) {
+  return records.filter((r) => !records.some((o) => o !== r && supersedes(o, r)));
+}
+function seenOf(records) {
+  const out = {};
+  for (const r of records) out[r.writer] = Math.max(out[r.writer] ?? 0, r.counter);
+  return out;
+}
+function sameState(a, b) {
+  return a.status === b.status && a.assignee === b.assignee && a.progressPercent === b.progressPercent && a.blockedReason === b.blockedReason;
+}
+function readItem(records) {
+  const { records: distinct } = distinctRecords(records);
+  const top = heads(distinct);
+  if (top.length === 0) return { kind: "none" };
+  const newest = [...top].sort((a, b) => b.at - a.at || (a.writer < b.writer ? -1 : 1));
+  if (newest.every((h) => sameState(h.state, newest[0].state))) return { kind: "settled", head: newest[0] };
+  return { kind: "split", heads: newest };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_RECORD_BYTES,
+  distinctRecords,
+  heads,
+  isRecordId,
+  parseRecord,
+  readItem,
+  recordBytes,
+  recordFileName,
+  sameState,
+  seenOf,
+  serializeRecord,
+  supersedes
+});