codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/mobile-api-server.js

@@ -0,0 +1,281 @@
+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 mobile_api_server_exports = {};
+__export(mobile_api_server_exports, {
+  getMobileApiPort: () => getMobileApiPort,
+  isMobileApiRunning: () => isMobileApiRunning,
+  resetMobileApiRateLimit: () => resetMobileApiRateLimit,
+  startMobileApiServer: () => startMobileApiServer,
+  stopMobileApiServer: () => stopMobileApiServer
+});
+module.exports = __toCommonJS(mobile_api_server_exports);
+var import_node_http = __toESM(require("node:http"));
+var import_settings_service = require("./settings-service");
+var import_peer_connection_service = require("./peer-connection-service");
+const MAX_BODY_BYTES = 256 * 1024;
+const SOCKET_TIMEOUT_MS = 15e3;
+const RATE_WINDOW_MS = 6e4;
+const RATE_MAX_REQUESTS = 60;
+const RATE_MAX_SOURCES = 1024;
+let server = null;
+let boundPort = 0;
+async function startMobileApiServer() {
+  if (server) {
+    return boundPort;
+  }
+  const settings = (0, import_settings_service.getSettings)();
+  const requestedPort = settings.device.mobileApiPort || 19480;
+  return new Promise((resolve, reject) => {
+    const tryPort = (candidate, attemptsLeft) => {
+      const srv = import_node_http.default.createServer(handleRequest);
+      srv.on("error", (err) => {
+        if (err.code === "EADDRINUSE" && attemptsLeft > 0) {
+          console.log(`[MobileAPI] Port ${candidate} in use, trying ${candidate + 1}\u2026`);
+          tryPort(candidate + 1, attemptsLeft - 1);
+        } else {
+          reject(err);
+        }
+      });
+      srv.setTimeout(SOCKET_TIMEOUT_MS, (socket) => socket.destroy());
+      srv.headersTimeout = SOCKET_TIMEOUT_MS;
+      srv.requestTimeout = SOCKET_TIMEOUT_MS;
+      srv.listen(candidate, "0.0.0.0", () => {
+        server = srv;
+        boundPort = candidate;
+        console.log(`[MobileAPI] Listening on 0.0.0.0:${candidate}`);
+        resolve(candidate);
+      });
+    };
+    tryPort(requestedPort, 10);
+  });
+}
+function stopMobileApiServer() {
+  if (server) {
+    try {
+      server.closeAllConnections?.();
+      server.close();
+    } catch {
+    }
+    server = null;
+    boundPort = 0;
+    hits.clear();
+    console.log("[MobileAPI] Stopped");
+  }
+}
+function getMobileApiPort() {
+  return boundPort;
+}
+function isMobileApiRunning() {
+  return server !== null;
+}
+function handleRequest(req, res) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+  if (rateLimited(req)) {
+    sendJson(res, 429, { error: "Too many requests" });
+    return;
+  }
+  const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+  if (req.method === "POST" && url.pathname === "/api/mobile/auth/challenge") {
+    handleChallenge(req, res);
+    return;
+  }
+  if (req.method === "POST" && url.pathname === "/api/mobile/reconnect") {
+    handleReconnect(req, res);
+    return;
+  }
+  if (req.method === "POST" && url.pathname === "/api/mobile/reconnect/answer") {
+    handleReconnectAnswer(req, res);
+    return;
+  }
+  if (req.method === "GET" && url.pathname === "/api/mobile/status") {
+    handleStatus(res);
+    return;
+  }
+  res.writeHead(404, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ error: "Not found" }));
+}
+function handleChallenge(req, res) {
+  readJsonBody(req).then((data) => {
+    const pairingId = typeof data.pairingId === "string" ? data.pairingId : "";
+    if (!pairingId) {
+      sendJson(res, 400, { error: "Missing pairingId" });
+      return;
+    }
+    sendJson(res, 200, (0, import_peer_connection_service.issueReconnectChallenge)(pairingId));
+  }).catch((err) => failBody(res, err));
+}
+function handleReconnect(req, res) {
+  readJsonBody(req).then(async (data) => {
+    const pairingId = typeof data.pairingId === "string" ? data.pairingId : "";
+    const nonce = typeof data.nonce === "string" ? data.nonce : "";
+    const mac = typeof data.mac === "string" ? data.mac : "";
+    const expiresAt = typeof data.expiresAt === "number" ? data.expiresAt : 0;
+    if (!pairingId || !nonce || !mac || !expiresAt) {
+      sendJson(res, 400, { error: "Missing pairingId or challenge response" });
+      return;
+    }
+    const result = await (0, import_peer_connection_service.startReconnection)(pairingId, { nonce, expiresAt, mac });
+    if (!result) {
+      sendJson(res, 403, { error: "Reconnection refused" });
+      return;
+    }
+    sendJson(res, 200, {
+      offer: result.offer,
+      ice: result.iceCandidates,
+      fingerprint: result.fingerprint,
+      pairingId: result.pairingId,
+      // Consumed with the answer, so a captured proof is worth one use.
+      answerNonce: result.answerNonce,
+      // Lets the phone verify it is talking to the desktop it paired with,
+      // without depending on a certificate that changes every restart.
+      offerMac: result.offerMac
+    });
+  }).catch((err) => failBody(res, err));
+}
+function handleReconnectAnswer(req, res) {
+  readJsonBody(req).then(async (data) => {
+    const pairingId = typeof data.pairingId === "string" ? data.pairingId : "";
+    const answer = typeof data.answer === "string" ? data.answer : "";
+    const fingerprint = typeof data.fingerprint === "string" ? data.fingerprint : "";
+    const ice = Array.isArray(data.ice) ? data.ice : [];
+    const mac = typeof data.mac === "string" ? data.mac : "";
+    if (!pairingId || !answer) {
+      sendJson(res, 400, { error: "Missing pairingId or answer" });
+      return;
+    }
+    const success = await (0, import_peer_connection_service.completeReconnection)(pairingId, answer, ice, fingerprint, mac);
+    if (!success) {
+      sendJson(res, 403, { error: "Reconnection refused" });
+      return;
+    }
+    sendJson(res, 200, { connected: true });
+  }).catch((err) => failBody(res, err));
+}
+function handleStatus(res) {
+  try {
+    const status = (0, import_peer_connection_service.getPeerManagerStatus)();
+    const settings = (0, import_settings_service.getSettings)();
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({
+      ok: true,
+      deviceName: settings.device.deviceName || require("node:os").hostname(),
+      port: boundPort,
+      ...status
+    }));
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: String(err) }));
+  }
+}
+function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += Buffer.byteLength(chunk);
+      if (size > MAX_BODY_BYTES) {
+        reject(new BodyTooLarge());
+        req.destroy();
+        return;
+      }
+      body += chunk;
+    });
+    req.on("end", () => {
+      try {
+        const parsed = JSON.parse(body || "{}");
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+          reject(new BadJson());
+          return;
+        }
+        resolve(parsed);
+      } catch {
+        reject(new BadJson());
+      }
+    });
+    req.on("error", reject);
+  });
+}
+class BodyTooLarge extends Error {
+  status = 413;
+}
+class BadJson extends Error {
+  status = 400;
+}
+function sendJson(res, status, payload) {
+  if (res.headersSent) return;
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(payload));
+}
+function failBody(res, err) {
+  if (err instanceof BodyTooLarge) return sendJson(res, 413, { error: "Request body too large" });
+  if (err instanceof BadJson) return sendJson(res, 400, { error: "Invalid JSON" });
+  console.warn("[MobileAPI] Request failed:", err);
+  sendJson(res, 500, { error: "Request failed" });
+}
+const hits = /* @__PURE__ */ new Map();
+function rateLimited(req, now = Date.now()) {
+  const source = req.socket.remoteAddress ?? "unknown";
+  const entry = hits.get(source);
+  if (!entry || entry.resetAt <= now) {
+    if (hits.size >= RATE_MAX_SOURCES) {
+      for (const [key, value] of hits) if (value.resetAt <= now) hits.delete(key);
+      if (hits.size >= RATE_MAX_SOURCES) {
+        const oldest = hits.keys().next();
+        if (!oldest.done) hits.delete(oldest.value);
+      }
+    }
+    hits.set(source, { count: 1, resetAt: now + RATE_WINDOW_MS });
+    return false;
+  }
+  entry.count += 1;
+  if (entry.count > RATE_MAX_REQUESTS) {
+    if (entry.count === RATE_MAX_REQUESTS + 1) {
+      console.warn(`[MobileAPI] Rate limiting ${source} \u2014 ${entry.count} requests in the window`);
+    }
+    return true;
+  }
+  return false;
+}
+function resetMobileApiRateLimit() {
+  hits.clear();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMobileApiPort,
+  isMobileApiRunning,
+  resetMobileApiRateLimit,
+  startMobileApiServer,
+  stopMobileApiServer
+});

package/src/backend/services/mobile-approvals.js

@@ -0,0 +1,306 @@
+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 mobile_approvals_exports = {};
+__export(mobile_approvals_exports, {
+  APPROVAL_METHODS: () => APPROVAL_METHODS,
+  PREVIEW_CHUNK_CHARS: () => PREVIEW_CHUNK_CHARS,
+  PREVIEW_IMAGE_BYTES: () => PREVIEW_IMAGE_BYTES,
+  PREVIEW_TEXT_CHARS: () => PREVIEW_TEXT_CHARS,
+  SHEET_CONTEXT: () => SHEET_CONTEXT,
+  buildPreview: () => buildPreview,
+  handleApprovalMethod: () => handleApprovalMethod,
+  sanitiseLocator: () => sanitiseLocator,
+  setPreviewImageScaler: () => setPreviewImageScaler,
+  toPhone: () => toPhone
+});
+module.exports = __toCommonJS(mobile_approvals_exports);
+var import_node_path = __toESM(require("node:path"));
+var criteriaService = __toESM(require("./criteria-service"));
+var import_artefact_service = require("./artefact-service");
+var import_plan_item_service = require("./plan-item-service");
+var import_task_grounding = require("./task-grounding");
+var import_human_decision = require("./human-decision");
+var import_settings_service = require("./settings-service");
+var import_paired_device_service = require("./paired-device-service");
+var import_peer_capabilities = require("./peer-capabilities");
+var import_peer_audit_service = require("./peer-audit-service");
+var import_sensor_bridge_service = require("./sensor-bridge-service");
+var import_reader_host = require("./material-reader/reader-host");
+var import_locator = require("../../shared/lib/locator");
+var import_xlsx_xml = require("../../shared/lib/xlsx-xml");
+const PREVIEW_TEXT_CHARS = 4e4;
+const PREVIEW_IMAGE_BYTES = 3 * 1024 * 1024;
+const PREVIEW_CHUNK_CHARS = 16e3;
+const SHEET_CONTEXT = { rows: 6, cols: 3 };
+const TRANSFER_ID = /^[A-Za-z0-9-]{8,64}$/;
+let scaler = null;
+function setPreviewImageScaler(fn) {
+  scaler = fn;
+}
+const APPROVAL_METHODS = ["criteria.awaiting", "criteria.list", "criterion.decide", "artefact.preview"];
+async function handleApprovalMethod(method, params, peer) {
+  switch (method) {
+    case "criteria.awaiting":
+      return awaiting(params);
+    case "criteria.list":
+      return criteriaForItem(requireUid(params, "itemUid"));
+    case "criterion.decide":
+      return decide(requireUid(params, "criterionUid"), params, peer);
+    case "artefact.preview":
+      return preview(params, peer);
+    default:
+      throw new Error(`Unknown approval method: ${method}`);
+  }
+}
+function awaiting(params) {
+  const limit = typeof params.limit === "number" && params.limit > 0 ? Math.min(params.limit, 200) : 100;
+  return {
+    entries: criteriaService.listAwaitingPerson(limit).map((a) => ({
+      ...toPhone(a.criterion),
+      itemTitle: a.itemTitle,
+      planUid: a.planUid,
+      planTitle: a.planTitle
+    }))
+  };
+}
+async function criteriaForItem(itemUid) {
+  const item = (0, import_plan_item_service.getItem)(itemUid);
+  if (!item) throw new Error("Item not found");
+  await (0, import_artefact_service.refreshArtefactHashes)(itemUid).catch(() => []);
+  const g = await (0, import_task_grounding.taskGrounding)(itemUid);
+  return {
+    item: { uid: item.uid, title: item.title, planUid: item.planUid },
+    criteria: criteriaService.listCriteria(itemUid).map(toPhone),
+    grounding: g && g.total ? { words: g.words, grounded: g.grounded, grades: Object.fromEntries(g.criteria.map((c) => [c.uid, { grade: c.grade, why: c.why }])) } : null
+  };
+}
+async function decide(criterionUid, params, peer) {
+  const device = (0, import_paired_device_service.getPairedDevice)(peer.fingerprint);
+  if (!device?.confirmedAt) {
+    throw new import_peer_capabilities.PeerAuthorizationError("Approving needs a pairing confirmed on the desktop");
+  }
+  const before = criteriaService.getCriterion(criterionUid);
+  if (!before) throw new criteriaService.CriterionError("Criterion not found", 404);
+  await (0, import_artefact_service.refreshArtefactHashes)(before.itemUid).catch(() => []);
+  const criterion = criteriaService.decideCriterion(
+    criterionUid,
+    { decision: params.decision, note: params.note, anchor: params.anchor },
+    (0, import_human_decision.issueHumanDecision)("phone", (0, import_settings_service.getAuthorKey)("human"), device.alias)
+  );
+  (0, import_peer_audit_service.recordPeerAudit)({
+    kind: "decision",
+    fingerprint: peer.fingerprint,
+    alias: device.alias,
+    method: "criterion.decide",
+    detail: `${params.decision === "approved" ? "approved" : "sent back"} criterion ${criterionUid}`
+  });
+  const planUid = (0, import_plan_item_service.getItem)(criterion.itemUid)?.planUid ?? null;
+  if (planUid) (0, import_sensor_bridge_service.resolveCriterionNotices)(planUid, criterionUid);
+  peer.broadcast?.("plan-item-criteria-changed", { planUid, itemUid: criterion.itemUid });
+  return { criterion: toPhone(criterion) };
+}
+async function preview(params, peer) {
+  const transferId = params.transferId;
+  if (typeof transferId !== "string" || !TRANSFER_ID.test(transferId)) {
+    throw new Error("transferId must be 8\u201364 letters, digits or dashes");
+  }
+  const attachmentUid = requireUid(params, "attachmentUid");
+  const artefact = (0, import_artefact_service.getArtefact)(attachmentUid);
+  if (!artefact) throw new Error("No evidence file with that uid");
+  const built = await buildPreview(attachmentUid, sanitiseLocator(params.locator));
+  const body = JSON.stringify(built);
+  const total = Math.max(1, Math.ceil(body.length / PREVIEW_CHUNK_CHARS));
+  for (let seq = 0; seq < total; seq++) {
+    peer.send({
+      mcp: true,
+      cmd: "preview.chunk",
+      id: transferId,
+      seq,
+      total,
+      data: body.slice(seq * PREVIEW_CHUNK_CHARS, (seq + 1) * PREVIEW_CHUNK_CHARS)
+    });
+  }
+  return { transferId, total, chars: body.length, kind: built.kind };
+}
+async function buildPreview(attachmentUid, locator, read = import_reader_host.readMaterial) {
+  const artefact = (0, import_artefact_service.getArtefact)(attachmentUid);
+  const ext = artefact ? import_node_path.default.extname(artefact.path).slice(1).toLowerCase() : "";
+  const isImage = ["png", "jpg", "jpeg", "gif", "webp"].includes(ext);
+  let readAt = isImage ? null : locator;
+  let grid;
+  if ((ext === "xlsx" || ext === "xlsm") && locator) {
+    const cited = locator.range ? (0, import_locator.parseRange)(String(locator.range)) : null;
+    if (cited) {
+      const firstRow = Math.max(1, cited.from.row - SHEET_CONTEXT.rows);
+      const firstCol = Math.max(1, cited.from.col - SHEET_CONTEXT.cols);
+      const lastRow = cited.to.row + SHEET_CONTEXT.rows;
+      const lastCol = cited.to.col + SHEET_CONTEXT.cols;
+      readAt = { ...locator, range: `${(0, import_xlsx_xml.colLetters)(firstCol)}${firstRow}:${(0, import_xlsx_xml.colLetters)(lastCol)}${lastRow}` };
+      grid = { firstRow, firstCol, cited };
+    } else if (!locator.text) {
+      grid = { firstRow: 1, firstCol: 1, cited: null };
+    }
+  }
+  const result = await read(attachmentUid, readAt);
+  if (!result.ok) return { kind: "unavailable", name: result.name ?? null, reason: result.reason };
+  if (result.kind === "image") {
+    const original = Buffer.from(result.base64, "base64");
+    const scaled = scaler ? safeScale(original, result.mimeType) : null;
+    if (scaled) return { kind: "image", name: result.name, mime: scaled.mime, base64: scaled.bytes.toString("base64"), scaled: true };
+    if (original.length > PREVIEW_IMAGE_BYTES) {
+      return {
+        kind: "unavailable",
+        name: result.name,
+        reason: `${result.name} is larger than the ${PREVIEW_IMAGE_BYTES / 1024 / 1024} MB the phone is sent \u2014 open it on the desktop`
+      };
+    }
+    return { kind: "image", name: result.name, mime: result.mimeType, base64: result.base64, scaled: false };
+  }
+  const { reply } = result;
+  const notes = [...reply.notes];
+  let budget = PREVIEW_TEXT_CHARS;
+  const sections = [];
+  for (const s of reply.sections) {
+    if (budget <= 0) break;
+    if (s.body.length > budget) {
+      sections.push({ heading: s.heading, body: s.body.slice(0, budget) });
+      notes.push("Cut short for the phone \u2014 the whole of it is on the desktop.");
+      budget = 0;
+      break;
+    }
+    sections.push(s);
+    budget -= s.body.length;
+  }
+  if (sections.length < reply.sections.length && !notes.some((n) => n.startsWith("Cut short"))) {
+    notes.push("Cut short for the phone \u2014 the whole of it is on the desktop.");
+  }
+  if (grid) {
+    return {
+      kind: "text",
+      name: result.name,
+      format: reply.format,
+      // The place that was cited, not the wider area read around it.
+      where: (0, import_locator.describeLocator)(locator) || reply.where,
+      outline: reply.outline,
+      sections: sections.map((sec) => ({ ...sec, heading: sec.heading.replace(/,\s*[A-Z]+\d+:[A-Z]+\d+$/, "").replace(/ from A1$/, "") })),
+      notes,
+      grid
+    };
+  }
+  return {
+    kind: "text",
+    name: result.name,
+    format: reply.format,
+    where: reply.where,
+    outline: reply.outline,
+    sections,
+    notes
+  };
+}
+function safeScale(bytes, mime) {
+  try {
+    return scaler?.(bytes, mime) ?? null;
+  } catch (err) {
+    console.warn("[Approvals] Could not scale an image for the phone:", err);
+    return null;
+  }
+}
+function requireUid(params, key) {
+  const v = params[key];
+  if (typeof v !== "string" || !/^[A-Za-z0-9-]{8,64}$/.test(v)) throw new Error(`${key} is required`);
+  return v;
+}
+function sanitiseLocator(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const l = raw;
+  const out = {};
+  const str = (v) => typeof v === "string" && v.length > 0 && v.length <= 200 ? v : void 0;
+  const span = (v) => {
+    if (typeof v === "number" && Number.isFinite(v)) return v;
+    if (Array.isArray(v) && v.length === 2 && v.every((n) => typeof n === "number")) return `${v[0]}-${v[1]}`;
+    return str(v);
+  };
+  out.sheet = str(l.sheet);
+  out.range = str(l.range);
+  out.page = span(l.page);
+  out.lines = span(l.lines);
+  out.text = str(l.text);
+  for (const k of Object.keys(out)) if (out[k] === void 0) delete out[k];
+  return Object.keys(out).length > 0 ? out : null;
+}
+function toEvidence(e) {
+  const artefact = e.attachmentUid ? (0, import_artefact_service.getArtefact)(e.attachmentUid) : null;
+  const name = artefact ? import_node_path.default.basename(artefact.path) : null;
+  return {
+    attachmentUid: e.attachmentUid,
+    name,
+    ext: name ? import_node_path.default.extname(name).slice(1).toLowerCase() || null : null,
+    locator: e.locator,
+    where: (0, import_locator.describeLocator)(e.locator),
+    note: e.note,
+    submittedBy: e.submittedBy,
+    submittedAt: e.submittedAt
+  };
+}
+function toPhone(c) {
+  const signoff = c.latestSignoff;
+  let changedFiles = [];
+  if (c.state === "stale" && signoff?.evidenceHashes) {
+    const recorded = signoff.evidenceHashes;
+    changedFiles = Object.keys(recorded).filter((uid) => ((0, import_artefact_service.getArtefact)(uid)?.sha256 ?? null) !== recorded[uid]).map((uid) => (0, import_artefact_service.getArtefact)(uid)?.path ?? uid);
+  }
+  return {
+    uid: c.uid,
+    itemUid: c.itemUid,
+    text: c.text,
+    kind: c.kind,
+    policy: c.policy,
+    state: c.state,
+    evidence: c.latestSubmission.map(toEvidence),
+    lastDecision: signoff ? { decision: signoff.decision, actor: signoff.actor, channel: signoff.channel, note: signoff.note, at: signoff.createdAt } : null,
+    changedFiles,
+    // The desktop's rule, the same here (CriteriaBlock): approve anything
+    // not already met; send back what was submitted, or take back an
+    // approval.
+    canApprove: c.state !== "met",
+    canSendBack: c.state === "submitted" || c.state === "met"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APPROVAL_METHODS,
+  PREVIEW_CHUNK_CHARS,
+  PREVIEW_IMAGE_BYTES,
+  PREVIEW_TEXT_CHARS,
+  SHEET_CONTEXT,
+  buildPreview,
+  handleApprovalMethod,
+  sanitiseLocator,
+  setPreviewImageScaler,
+  toPhone
+});