0xray 4.0.39 → 4.0.41

package/dist/integrations/hooks/session-note-index.cjs

@@ -0,0 +1,298 @@
+/**
+ * Session notes beside repertoire laws.
+ * Laws stay in curated_signals.json. This file is the index.
+ * Cleanup drops a lone note only after STALE_AFTER_MS without another sighting.
+ * A replaced note stays on disk and is left out of the short index.
+ * The short index is a view of current notes. It does not delete history.
+ */
+const { createHash } = require("crypto");
+const { existsSync, mkdirSync, readFileSync, writeFileSync } = require("fs");
+const { join } = require("path");
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const STALE_AFTER_MS = 90 * DAY_MS;
+const SHORT_INDEX_LIMIT = 12;
+const LINE_MAX = 240;
+
+function sessionNotesPath(root) {
+  return join(root, ".xray", "state", "repertoire", "session-notes.json");
+}
+
+function lawsPath(root) {
+  return join(root, ".xray", "state", "repertoire", "curated_signals.json");
+}
+
+function clipLine(raw) {
+  if (raw == null) return null;
+  const text = String(raw).replace(/\s+/g, " ").trim();
+  if (!text) return null;
+  if (text.length <= LINE_MAX) return text;
+  return `${text.slice(0, LINE_MAX - 1)}…`;
+}
+
+function noteId(text) {
+  return createHash("sha256").update(text).digest("hex").slice(0, 12);
+}
+
+function loadIndex(root) {
+  const dest = sessionNotesPath(root);
+  if (!existsSync(dest)) return { notes: [], corrupt: false };
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(dest, "utf8"));
+  } catch {
+    return { notes: [], corrupt: true };
+  }
+  if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.notes)) {
+    return { notes: [], corrupt: true };
+  }
+  const notes = [];
+  for (const row of parsed.notes) {
+    if (!row || typeof row.text !== "string" || !row.text.trim()) continue;
+    const text = clipLine(row.text);
+    if (!text) continue;
+    const added = typeof row.added === "string" ? row.added : "";
+    const lastSeen = typeof row.last_seen === "string" && row.last_seen ? row.last_seen : added;
+    if (!added || !lastSeen) continue;
+    const note = {
+      id: typeof row.id === "string" && row.id ? row.id : noteId(text),
+      text,
+      added,
+      last_seen: lastSeen,
+    };
+    if (typeof row.source === "string") note.source = row.source;
+    if (typeof row.slot === "string" && row.slot) note.slot = row.slot;
+    if (typeof row.superseded_by === "string" && row.superseded_by) note.superseded_by = row.superseded_by;
+    if (typeof row.superseded_at === "string" && row.superseded_at) note.superseded_at = row.superseded_at;
+    notes.push(note);
+  }
+  return { notes, corrupt: false };
+}
+
+function writeIndex(root, notes) {
+  const dest = sessionNotesPath(root);
+  try {
+    mkdirSync(join(root, ".xray", "state", "repertoire"), { recursive: true });
+    const body = notes.map((note) => {
+      const row = {
+        id: note.id,
+        text: note.text,
+        added: note.added,
+        last_seen: note.last_seen,
+      };
+      if (note.source) row.source = note.source;
+      if (note.slot) row.slot = note.slot;
+      if (note.superseded_by) row.superseded_by = note.superseded_by;
+      if (note.superseded_at) row.superseded_at = note.superseded_at;
+      return row;
+    });
+    writeFileSync(dest, `${JSON.stringify({ notes: body }, null, 2)}\n`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function nowStamp(opts) {
+  return typeof opts.now === "string" && opts.now ? opts.now : new Date().toISOString();
+}
+
+function isCurrent(note) {
+  return !note.superseded_by;
+}
+
+/** The new line becomes current. The previous holder of the same slot stays on disk. */
+function closeSlot(notes, slot, keeperId, now) {
+  if (!slot) return 0;
+  let closed = 0;
+  for (const note of notes) {
+    if (note.id === keeperId) continue;
+    if (note.slot !== slot) continue;
+    if (note.superseded_by) continue;
+    note.superseded_by = keeperId;
+    note.superseded_at = now;
+    closed += 1;
+  }
+  return closed;
+}
+
+function rememberSessionNote(root, text, opts = {}) {
+  const line = clipLine(text);
+  if (!line) return { kept: false };
+  const loaded = loadIndex(root);
+  if (loaded.corrupt) return { kept: false, corrupt: true };
+  const now = nowStamp(opts);
+  const source = typeof opts.source === "string" ? opts.source : undefined;
+  const slot = typeof opts.slot === "string" && opts.slot ? opts.slot : undefined;
+  const existing = loaded.notes.find((note) => note.text === line);
+  if (existing) {
+    existing.last_seen = now;
+    if (source) existing.source = source;
+    // A notes page can still show the old line. That sighting must not
+    // revive it or demote the line that replaced it.
+    if (slot && !existing.superseded_by) {
+      existing.slot = slot;
+      closeSlot(loaded.notes, slot, existing.id, now);
+    }
+    const wrote = writeIndex(root, loaded.notes);
+    return { kept: wrote, bumped: true, id: existing.id, corrupt: false };
+  }
+  const created = {
+    id: noteId(line),
+    text: line,
+    added: now,
+    last_seen: now,
+  };
+  if (source) created.source = source;
+  if (slot) created.slot = slot;
+  loaded.notes.push(created);
+  if (slot) closeSlot(loaded.notes, slot, created.id, now);
+  const wrote = writeIndex(root, loaded.notes);
+  return { kept: wrote, bumped: false, id: created.id, corrupt: false };
+}
+
+function supersedeSessionNote(root, previousText, nextText, opts = {}) {
+  const previousLine = clipLine(previousText);
+  const nextLine = clipLine(nextText);
+  if (!previousLine || !nextLine || previousLine === nextLine) return { kept: false };
+  const loaded = loadIndex(root);
+  if (loaded.corrupt) return { kept: false, corrupt: true };
+  const previous = loaded.notes.find((note) => note.text === previousLine || note.id === previousLine);
+  if (!previous) return { kept: false, missing: true };
+  const now = nowStamp(opts);
+  const source = typeof opts.source === "string" ? opts.source : previous.source;
+  let next = loaded.notes.find((note) => note.text === nextLine);
+  if (!next) {
+    next = {
+      id: noteId(nextLine),
+      text: nextLine,
+      added: now,
+      last_seen: now,
+    };
+    if (source) next.source = source;
+    if (previous.slot) next.slot = previous.slot;
+    loaded.notes.push(next);
+  } else {
+    next.last_seen = now;
+    delete next.superseded_by;
+    delete next.superseded_at;
+    if (previous.slot) next.slot = previous.slot;
+  }
+  if (next.id === previous.id) return { kept: false };
+  previous.superseded_by = next.id;
+  previous.superseded_at = now;
+  if (next.slot) closeSlot(loaded.notes, next.slot, next.id, now);
+  const wrote = writeIndex(root, loaded.notes);
+  return { kept: wrote, id: next.id, supersededId: previous.id, corrupt: false };
+}
+
+function sessionNoteHistory(root, textOrId) {
+  const loaded = loadIndex(root);
+  const key = clipLine(textOrId) || String(textOrId || "");
+  const start = loaded.notes.find((note) => note.text === key || note.id === textOrId);
+  if (!start) return [];
+  const seen = new Set([start.id]);
+  const older = [];
+  let cursor = start.id;
+  while (cursor && seen.size < loaded.notes.length + 1) {
+    const prev = loaded.notes.find((note) => note.superseded_by === cursor && !seen.has(note.id));
+    if (!prev) break;
+    seen.add(prev.id);
+    older.push(prev);
+    cursor = prev.id;
+  }
+  return older;
+}
+
+function shortSessionIndex(root, limit = SHORT_INDEX_LIMIT) {
+  const loaded = loadIndex(root);
+  const cap = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : SHORT_INDEX_LIMIT;
+  const ordered = loaded.notes.filter(isCurrent).sort((a, b) => {
+    if (a.last_seen === b.last_seen) return a.added < b.added ? 1 : -1;
+    return a.last_seen < b.last_seen ? 1 : -1;
+  });
+  return ordered.slice(0, cap);
+}
+
+function dropStaleSessionNotes(root, opts = {}) {
+  const loaded = loadIndex(root);
+  if (loaded.corrupt) return { kept: 0, dropped: 0, corrupt: true };
+  const nowMs = typeof opts.now === "string" ? Date.parse(opts.now) : Date.now();
+  const windowMs = Number.isFinite(opts.staleAfterMs) ? opts.staleAfterMs : STALE_AFTER_MS;
+  if (!Number.isFinite(nowMs)) return { kept: loaded.notes.length, dropped: 0, corrupt: false };
+  const protectedIds = new Set();
+  for (const note of loaded.notes) {
+    if (!note.superseded_by) continue;
+    protectedIds.add(note.id);
+    protectedIds.add(note.superseded_by);
+  }
+  const kept = [];
+  let dropped = 0;
+  for (const note of loaded.notes) {
+    const seen = Date.parse(note.last_seen);
+    const stale = Number.isFinite(seen) && nowMs - seen > windowMs;
+    if (stale && !protectedIds.has(note.id)) {
+      dropped += 1;
+      continue;
+    }
+    kept.push(note);
+  }
+  if (dropped > 0) writeIndex(root, kept);
+  return { kept: kept.length, dropped, corrupt: false };
+}
+
+function linesFromNotes(text) {
+  const lines = [];
+  for (const raw of String(text || "").split("\n")) {
+    const trimmed = raw.trim();
+    if (!trimmed) continue;
+    if (/^#{1,6}\s/.test(trimmed)) continue;
+    const pickup = trimmed.match(/^\*\*Pickup line:\*\*\s*(.*)$/);
+    if (pickup) {
+      if (pickup[1].trim()) lines.push({ text: pickup[1].trim(), slot: "pickup" });
+      continue;
+    }
+    const bullet = trimmed.replace(/^[-*]\s+/, "");
+    if (bullet) lines.push({ text: bullet });
+  }
+  return lines;
+}
+
+function retainProjectNotes(root, opts = {}) {
+  const dest = join(root, ".xray", "state", "NOTES.md");
+  let remembered = 0;
+  if (existsSync(dest)) {
+    let text = "";
+    try {
+      text = readFileSync(dest, "utf8");
+    } catch {
+      text = "";
+    }
+    for (const line of linesFromNotes(text)) {
+      const saved = rememberSessionNote(root, line.text, {
+        ...opts,
+        source: opts.source || "NOTES.md",
+        slot: line.slot,
+      });
+      if (saved.corrupt) return { remembered, dropped: 0, kept: 0, corrupt: true };
+      if (saved.kept) remembered += 1;
+    }
+  }
+  const cleaned = dropStaleSessionNotes(root, opts);
+  return { remembered, ...cleaned };
+}
+
+module.exports = {
+  DAY_MS,
+  STALE_AFTER_MS,
+  SHORT_INDEX_LIMIT,
+  LINE_MAX,
+  sessionNotesPath,
+  lawsPath,
+  rememberSessionNote,
+  supersedeSessionNote,
+  sessionNoteHistory,
+  shortSessionIndex,
+  dropStaleSessionNotes,
+  retainProjectNotes,
+};

package/dist/integrations/hooks/session-note-index.mjs

@@ -0,0 +1,22 @@
+/**
+ * ESM face for session-note-index.cjs.
+ */
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const require = createRequire(import.meta.url);
+const impl = require(join(dirname(fileURLToPath(import.meta.url)), "session-note-index.cjs"));
+
+export const DAY_MS = impl.DAY_MS;
+export const STALE_AFTER_MS = impl.STALE_AFTER_MS;
+export const SHORT_INDEX_LIMIT = impl.SHORT_INDEX_LIMIT;
+export const LINE_MAX = impl.LINE_MAX;
+export const sessionNotesPath = impl.sessionNotesPath;
+export const lawsPath = impl.lawsPath;
+export const rememberSessionNote = impl.rememberSessionNote;
+export const supersedeSessionNote = impl.supersedeSessionNote;
+export const sessionNoteHistory = impl.sessionNoteHistory;
+export const shortSessionIndex = impl.shortSessionIndex;
+export const dropStaleSessionNotes = impl.dropStaleSessionNotes;
+export const retainProjectNotes = impl.retainProjectNotes;

package/dist/integrations/hooks/sleeve.cjs

@@ -0,0 +1,335 @@
+/**
+ * Sleeve: on means the previous ticket came back, the worn plate already
+ * matched the package, that ticket already matched the working record,
+ * and inspect has passed for the skills on disk.
+ * Session start and compact run the mill. A later prompt reads the report.
+ */
+const { execFileSync } = require("child_process");
+const { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } = require("fs");
+const { dirname, join } = require("path");
+
+const STITCHES = ["loop", "domain", "state", "foundry"];
+const SLEEVE_PLANES = [
+  "record-map",
+  "station-card",
+  "notes-page",
+  "memory-recall",
+  "suit-wear",
+  "suit-organs",
+  "suit-settings",
+  "trail-state",
+];
+const FOUNDRY_FILES = ["cli.mjs", "mill-root.mjs", "inspect.mjs", "reconcile-version.mjs"];
+
+function isSleevePlane(id) {
+  return SLEEVE_PLANES.includes(String(id || ""));
+}
+
+function stitch(name, on, at) {
+  return {
+    name,
+    on: Boolean(on),
+    at: Array.isArray(at) ? at.filter((item) => typeof item === "string" && item) : [],
+  };
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function stationText(root) {
+  const file = join(root, ".xray", "state", "STATION.md");
+  if (!existsSync(file)) return "";
+  try {
+    return readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function fieldValue(text, label) {
+  const line = String(text || "").split(/\r?\n/).find((row) => row.startsWith(`${label}: `));
+  return line ? line.slice(label.length + 2).trim() : "";
+}
+
+function ticketIntent(root) {
+  return fieldValue(stationText(root), "Intent");
+}
+
+function ticketHost(root) {
+  const line = fieldValue(stationText(root), "Host");
+  return line.split(/\s+/)[0] || "";
+}
+
+function workingFile(root) {
+  return readJson(join(root, ".xray", "state", "repertoire-working.json"));
+}
+
+function oneLine(value) {
+  return String(value || "").replace(/\s+/g, " ").trim().slice(0, 80);
+}
+
+function loopStitch(root) {
+  const card = ticketIntent(root);
+  const working = workingFile(root);
+  const prior = working && typeof working.priorIntent === "string" ? working.priorIntent : "";
+  const kept = working && typeof working.intent === "string" ? working.intent : "";
+  const returned = Boolean(prior && kept && card && prior === kept && card === kept);
+  return stitch("loop", returned, returned ? [oneLine(kept)] : []);
+}
+
+function plateBody(raw) {
+  return String(raw || "").replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, "").trim();
+}
+
+function domainStitch(root) {
+  const intent = ticketIntent(root);
+  if (!intent) return stitch("domain", false, []);
+  let plates = null;
+  try {
+    plates = require("./plates.cjs");
+  } catch {
+    return stitch("domain", false, []);
+  }
+  let plate = null;
+  try {
+    plate = plates.recallPlate(intent);
+  } catch {
+    plate = null;
+  }
+  if (!plate || !plate.id || !plate.body) return stitch("domain", false, []);
+  const worn = join(root, ".xray", "state", "plates", `${plate.id}.md`);
+  if (!existsSync(worn)) return stitch("domain", false, []);
+  let raw = "";
+  try {
+    raw = readFileSync(worn, "utf8");
+  } catch {
+    return stitch("domain", false, []);
+  }
+  if (plateBody(raw) !== plate.body) return stitch("domain", false, []);
+  return stitch("domain", true, [plate.id]);
+}
+
+function stateStitch(root) {
+  const card = ticketIntent(root);
+  const host = ticketHost(root);
+  const working = workingFile(root);
+  const priorCard = working && typeof working.priorIntent === "string" ? working.priorIntent : "";
+  const priorHost = working && typeof working.priorHost === "string" ? working.priorHost : "";
+  const priorKept = working && typeof working.priorWorkingIntent === "string" ? working.priorWorkingIntent : "";
+  const priorHeld = working && typeof working.priorWorkingHost === "string" ? working.priorWorkingHost : "";
+  const agreed = Boolean(
+    priorCard && priorHost && priorKept && priorHeld
+    && priorCard === priorKept
+    && priorHost === priorHeld
+    && card === priorCard
+    && host === priorHost,
+  );
+  return stitch("state", agreed, agreed ? [".xray/state/STATION.md"] : []);
+}
+
+function foundryDir(root) {
+  const candidates = [
+    join(root, "scripts", "foundry"),
+    join(root, "node_modules", "0xray", "scripts", "foundry"),
+  ];
+  for (const dir of candidates) {
+    if (FOUNDRY_FILES.every((name) => existsSync(join(dir, name)))) return dir;
+  }
+  return "";
+}
+
+function millPath(root) {
+  return join(root, ".xray", "state", "sleeve-mill.json");
+}
+
+function packageVersion(dir) {
+  let current = dir;
+  for (let depth = 0; depth < 6; depth += 1) {
+    const pkg = readJson(join(current, "package.json"));
+    if (pkg && typeof pkg.version === "string" && pkg.version) return pkg.version;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return "";
+}
+
+function gitHead(root) {
+  try {
+    return execFileSync("git", ["rev-parse", "--short", "HEAD"], {
+      cwd: root,
+      encoding: "utf8",
+      timeout: 2000,
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+
+function wornSkillFingerprint(root) {
+  const homes = [
+    ".opencode/skills",
+    ".grok/plugins/0xray/skills",
+    ".hermes/plugins/xray-hermes/skills",
+    ".openclaw/skills",
+  ];
+  const names = [];
+  for (const rel of homes) {
+    const dir = join(root, rel);
+    if (!existsSync(dir)) continue;
+    let entries = [];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (!existsSync(join(dir, entry.name, "SKILL.md"))) continue;
+      names.push(`${rel}/${entry.name}`);
+    }
+  }
+  names.sort();
+  return names.join(",");
+}
+
+function millStamp(root, dir) {
+  return `${packageVersion(dir)}|${gitHead(root)}|${wornSkillFingerprint(root)}`;
+}
+
+function runInspect(root, cli) {
+  let out = "";
+  try {
+    out = execFileSync(process.execPath, [cli, "inspect", "--skip-live"], {
+      cwd: root,
+      env: {
+        ...process.env,
+        FOUNDRY_ROOT: root,
+      },
+      encoding: "utf8",
+      timeout: 20000,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+  } catch (err) {
+    if (err && (err.killed || err.signal === "SIGTERM")) {
+      return stitch("foundry", false, ["inspect-timeout"]);
+    }
+    out = err && err.stdout ? String(err.stdout) : "";
+  }
+  try {
+    return inspectStitch(JSON.parse(out));
+  } catch {
+    return stitch("foundry", false, ["inspect"]);
+  }
+}
+
+function inspectStitch(report) {
+  if (report && report.ok === true) return stitch("foundry", true, ["inspect --skip-live"]);
+  const failed = report && Array.isArray(report.failed) ? report.failed.map(String) : [];
+  const blocking = failed.filter((id) => id !== "machinePlugin");
+  if (failed.length > 0 && blocking.length === 0) {
+    return stitch("foundry", true, ["inspect --skip-live"]);
+  }
+  if (!blocking.length) return stitch("foundry", false, ["inspect"]);
+  return stitch("foundry", false, blocking);
+}
+
+function writeMill(root, result, stamp) {
+  const dest = millPath(root);
+  mkdirSync(dirname(dest), { recursive: true });
+  writeFileSync(dest, `${JSON.stringify({
+    ok: result.on,
+    failed: result.on ? [] : result.at,
+    stamp,
+    ranAt: new Date().toISOString(),
+  })}\n`);
+}
+
+function runFoundryMill(root) {
+  const dir = foundryDir(root);
+  if (!dir) {
+    const missing = stitch("foundry", false, []);
+    writeMill(root, missing, "");
+    return missing;
+  }
+  const stamp = millStamp(root, dir);
+  const result = runInspect(root, join(dir, "cli.mjs"));
+  writeMill(root, result, stamp);
+  return result;
+}
+
+function foundryStitch(root) {
+  const saved = readJson(millPath(root));
+  if (!saved || typeof saved !== "object") return stitch("foundry", false, []);
+  const dir = foundryDir(root);
+  const stamp = dir ? millStamp(root, dir) : "";
+  if (!stamp || saved.stamp !== stamp) return stitch("foundry", false, saved.stamp ? ["stale"] : []);
+  if (saved.ok === true) return stitch("foundry", true, ["inspect --skip-live"]);
+  const failed = Array.isArray(saved.failed) ? saved.failed.map(String) : [];
+  // The wear leaves ~/.grok/plugins/0xray in place and scrubs it. That check is not the mill.
+  const blocking = failed.filter((id) => id !== "machinePlugin");
+  if (failed.length > 0 && blocking.length === 0) {
+    return stitch("foundry", true, ["inspect --skip-live"]);
+  }
+  return stitch("foundry", false, blocking.length ? blocking : failed);
+}
+
+function readSleeve(root) {
+  const stitches = [
+    loopStitch(root),
+    domainStitch(root),
+    stateStitch(root),
+    foundryStitch(root),
+  ];
+  const missing = stitches.filter((row) => !row.on).map((row) => row.name);
+  return { on: missing.length === 0, missing, stitches };
+}
+
+function rowsOf(sleeve) {
+  const listed = sleeve && Array.isArray(sleeve.stitches) ? sleeve.stitches : [];
+  return STITCHES.map((name) => {
+    const found = listed.find((row) => row && row.name === name);
+    return found ? stitch(name, found.on, found.at) : stitch(name, false, []);
+  });
+}
+
+function formatSleevePointer(sleeve) {
+  if (sleeve && sleeve.on) return "Sleeve: on";
+  const missing = sleeve && Array.isArray(sleeve.missing) && sleeve.missing.length
+    ? STITCHES.filter((name) => sleeve.missing.includes(name))
+    : rowsOf(sleeve).filter((row) => !row.on).map((row) => row.name);
+  const names = missing.length ? missing : STITCHES.slice();
+  return `Sleeve: off ${names.join(", ")}`;
+}
+
+function stitchText(row) {
+  if (row.at.length) return row.at.join(", ");
+  return row.on ? "on" : "off";
+}
+
+function labelOf(name) {
+  return name ? name.charAt(0).toUpperCase() + name.slice(1) : "";
+}
+
+function formatSleeveReading(sleeve) {
+  const lines = [formatSleevePointer(sleeve)];
+  for (const row of rowsOf(sleeve)) lines.push(`${labelOf(row.name)}: ${stitchText(row)}`);
+  return lines.join("\n");
+}
+
+module.exports = {
+  STITCHES,
+  SLEEVE_PLANES,
+  isSleevePlane,
+  readSleeve,
+  runFoundryMill,
+  inspectStitch,
+  formatSleevePointer,
+  formatSleeveReading,
+};

package/dist/integrations/hooks/sleeve.mjs

@@ -0,0 +1,18 @@
+/**
+ * ESM face for sleeve.cjs.
+ */
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const require = createRequire(import.meta.url);
+const impl = require(join(dirname(fileURLToPath(import.meta.url)), "sleeve.cjs"));
+
+export const STITCHES = impl.STITCHES;
+export const SLEEVE_PLANES = impl.SLEEVE_PLANES;
+export const isSleevePlane = impl.isSleevePlane;
+export const readSleeve = impl.readSleeve;
+export const runFoundryMill = impl.runFoundryMill;
+export const inspectStitch = impl.inspectStitch;
+export const formatSleevePointer = impl.formatSleevePointer;
+export const formatSleeveReading = impl.formatSleeveReading;