codetrellis 0.0.0-stage → 0.2.0

package/src/shared/lib/proposal-words.js

@@ -0,0 +1,61 @@
+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 proposal_words_exports = {};
+__export(proposal_words_exports, {
+  evidenceWords: () => evidenceWords,
+  impactLabel: () => impactLabel,
+  impactWho: () => impactWho,
+  proposalHeadline: () => proposalHeadline,
+  proposalWhere: () => proposalWhere,
+  repliesLine: () => repliesLine
+});
+module.exports = __toCommonJS(proposal_words_exports);
+var import_breakpoint_words = require("./breakpoint-words");
+function proposalWhere(p) {
+  return `${p.section ? `\xA7 ${p.sectionTitle ?? p.section} of ` : ""}\u201C${p.pageTitle}\u201D`;
+}
+function proposalHeadline(p) {
+  return `\u270E ${(0, import_breakpoint_words.agentName)(p.author)} proposes a change to ${proposalWhere(p)}`;
+}
+function evidenceWords(e) {
+  return [
+    e.tests?.length ? `tests ${e.tests.join(", ")}` : null,
+    e.files?.length ? `files ${e.files.join(", ")}` : null,
+    e.commits?.length ? `commits ${e.commits.join(", ")}` : null,
+    e.note ?? null
+  ].filter(Boolean).join("; ");
+}
+function repliesLine(p) {
+  return p.affected.length ? `${p.affectedWords}. ${p.impacts.length} of ${p.affected.length} replied.` : "Nothing relies on this page yet.";
+}
+function impactLabel(i) {
+  if (i.impact !== "changes") return "No impact";
+  return `Changes${i.tasks !== null ? ` ${i.tasks} ${i.tasks === 1 ? "task" : "tasks"}` : ""}`;
+}
+function impactWho(i) {
+  return i.itemTitle ? `${i.itemTitle}${i.planTitle ? ` (${i.planTitle})` : ""}` : i.author;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  evidenceWords,
+  impactLabel,
+  impactWho,
+  proposalHeadline,
+  proposalWhere,
+  repliesLine
+});

package/src/shared/lib/recurrence.js

@@ -0,0 +1,183 @@
+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 recurrence_exports = {};
+__export(recurrence_exports, {
+  currentPeriod: () => currentPeriod,
+  dueAt: () => dueAt,
+  isTimeZone: () => isTimeZone,
+  isoWeek: () => isoWeek,
+  momentWords: () => momentWords,
+  nextPeriod: () => nextPeriod,
+  periodId: () => periodId,
+  periodLabel: () => periodLabel,
+  periodOf: () => periodOf,
+  previousPeriod: () => previousPeriod,
+  scheduleWords: () => scheduleWords,
+  seriesWords: () => seriesWords,
+  sinceWords: () => sinceWords,
+  wallClock: () => wallClock,
+  zonedMoment: () => zonedMoment
+});
+module.exports = __toCommonJS(recurrence_exports);
+const DAY = 864e5;
+const WEEKDAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+const WEEKDAY_NAMES = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+const fmtCache = /* @__PURE__ */ new Map();
+function fmt(timeZone) {
+  let f = fmtCache.get(timeZone);
+  if (!f) {
+    f = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      hourCycle: "h23",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit"
+    });
+    fmtCache.set(timeZone, f);
+  }
+  return f;
+}
+function isTimeZone(tz) {
+  try {
+    fmt(tz);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function wallClock(timeZone, ms) {
+  const parts = {};
+  for (const p of fmt(timeZone).formatToParts(new Date(ms))) if (p.type !== "literal") parts[p.type] = Number(p.value);
+  return { y: parts.year, m: parts.month, d: parts.day, H: parts.hour === 24 ? 0 : parts.hour, M: parts.minute };
+}
+function zonedMoment(timeZone, date, H, M) {
+  const want = Date.UTC(date.y, date.m - 1, date.d, H, M);
+  let guess = want;
+  for (let i = 0; i < 3; i++) {
+    const w = wallClock(timeZone, guess);
+    const diff = want - Date.UTC(w.y, w.m - 1, w.d, w.H, w.M);
+    if (diff === 0) break;
+    guess += diff;
+  }
+  return guess;
+}
+function utcOf(d) {
+  return Date.UTC(d.y, d.m - 1, d.d);
+}
+function dateOf(ms) {
+  const t = new Date(ms);
+  return { y: t.getUTCFullYear(), m: t.getUTCMonth() + 1, d: t.getUTCDate() };
+}
+function addDays(d, n) {
+  return dateOf(utcOf(d) + n * DAY);
+}
+function isoWeekday(d) {
+  return (new Date(utcOf(d)).getUTCDay() + 6) % 7 + 1;
+}
+function isoWeek(d) {
+  const thursday = addDays(d, 4 - isoWeekday(d));
+  const jan1 = utcOf({ y: thursday.y, m: 1, d: 1 });
+  return { year: thursday.y, week: Math.floor((utcOf(thursday) - jan1) / DAY / 7) + 1 };
+}
+function periodOf(every, d) {
+  if (every === "day") return { every, anchor: d };
+  if (every === "week") return { every, anchor: addDays(d, 1 - isoWeekday(d)) };
+  return { every, anchor: { y: d.y, m: d.m, d: 1 } };
+}
+function nextPeriod(p) {
+  if (p.every === "day") return { every: "day", anchor: addDays(p.anchor, 1) };
+  if (p.every === "week") return { every: "week", anchor: addDays(p.anchor, 7) };
+  return { every: "month", anchor: p.anchor.m === 12 ? { y: p.anchor.y + 1, m: 1, d: 1 } : { y: p.anchor.y, m: p.anchor.m + 1, d: 1 } };
+}
+function previousPeriod(p) {
+  if (p.every === "day") return { every: "day", anchor: addDays(p.anchor, -1) };
+  if (p.every === "week") return { every: "week", anchor: addDays(p.anchor, -7) };
+  return { every: "month", anchor: p.anchor.m === 1 ? { y: p.anchor.y - 1, m: 12, d: 1 } : { y: p.anchor.y, m: p.anchor.m - 1, d: 1 } };
+}
+const pad = (n, w = 2) => String(n).padStart(w, "0");
+function periodId(p) {
+  if (p.every === "day") return `${p.anchor.y}-${pad(p.anchor.m)}-${pad(p.anchor.d)}`;
+  if (p.every === "week") {
+    const w = isoWeek(p.anchor);
+    return `${w.year}-W${pad(w.week)}`;
+  }
+  return `${p.anchor.y}-${pad(p.anchor.m)}`;
+}
+function periodLabel(p) {
+  if (p.every === "day") return `${p.anchor.d} ${MONTHS[p.anchor.m - 1]}`;
+  if (p.every === "week") return `W${pad(isoWeek(p.anchor).week)}`;
+  return `${MONTHS[p.anchor.m - 1]} ${p.anchor.y}`;
+}
+function hhmm(at) {
+  const m = /^(\d{2}):(\d{2})$/.exec(at);
+  return m ? { H: Number(m[1]), M: Number(m[2]) } : { H: 9, M: 0 };
+}
+function dueAt(rule, p) {
+  const { H, M } = hhmm(rule.at);
+  const day = p.every === "day" ? p.anchor : p.every === "week" ? addDays(p.anchor, Math.min(7, Math.max(1, rule.on)) - 1) : { ...p.anchor, d: Math.min(28, Math.max(1, rule.on)) };
+  return zonedMoment(rule.timeZone, day, H, M);
+}
+function currentPeriod(rule, now) {
+  const w = wallClock(rule.timeZone, now);
+  let p = periodOf(rule.every, { y: w.y, m: w.m, d: w.d });
+  if (dueAt(rule, p) > now) p = previousPeriod(p);
+  return p;
+}
+function scheduleWords(rule) {
+  if (rule.every === "day") return `every day ${rule.at}`;
+  if (rule.every === "week") return `every ${WEEKDAYS[Math.min(7, Math.max(1, rule.on)) - 1]} ${rule.at}`;
+  const n = rule.on;
+  const suffix = n % 10 === 1 && n !== 11 ? "st" : n % 10 === 2 && n !== 12 ? "nd" : n % 10 === 3 && n !== 13 ? "rd" : "th";
+  return `every month on the ${n}${suffix}, ${rule.at}`;
+}
+function seriesWords(rule) {
+  const skills = rule.skills.map((s) => s.name);
+  return [scheduleWords(rule), skills.length ? `${skills.length === 1 ? "skill" : "skills"}: ${skills.join(", ")}` : null].filter(Boolean).join(" \xB7 ");
+}
+function sinceWords(rule, due) {
+  const w = wallClock(rule.timeZone, due);
+  const time = `${pad(w.H)}:${pad(w.M)}`;
+  if (rule.every === "day") return `since ${time}`;
+  if (rule.every === "week") return `since ${WEEKDAY_NAMES[isoWeekday(w) - 1]} ${time}`;
+  return `since ${w.d} ${MONTHS[w.m - 1]} ${time}`;
+}
+function momentWords(timeZone, ms) {
+  const w = wallClock(timeZone, ms);
+  return `${WEEKDAYS[isoWeekday(w) - 1]} ${w.d} ${MONTHS[w.m - 1]} ${pad(w.H)}:${pad(w.M)}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  currentPeriod,
+  dueAt,
+  isTimeZone,
+  isoWeek,
+  momentWords,
+  nextPeriod,
+  periodId,
+  periodLabel,
+  periodOf,
+  previousPeriod,
+  scheduleWords,
+  seriesWords,
+  sinceWords,
+  wallClock,
+  zonedMoment
+});

package/src/shared/lib/references.js

@@ -0,0 +1,72 @@
+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 references_exports = {};
+__export(references_exports, {
+  REFERENCE_KINDS: () => REFERENCE_KINDS,
+  SHORT_ID_LENGTH: () => SHORT_ID_LENGTH,
+  formatReference: () => formatReference,
+  formatReferenceLine: () => formatReferenceLine,
+  parseReference: () => parseReference,
+  shortId: () => shortId
+});
+module.exports = __toCommonJS(references_exports);
+const REFERENCE_KINDS = ["plan", "task", "page", "comment", "attachment"];
+const SHORT_ID_LENGTH = 8;
+const FULL_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function shortId(uid) {
+  return uid.replace(/-/g, "").slice(0, SHORT_ID_LENGTH).toLowerCase();
+}
+function formatReference(kind, uid) {
+  return `${kind} ${shortId(uid)}`;
+}
+function formatReferenceLine(input) {
+  const quote = (t) => `"${t.replace(/\s+/g, " ").trim().slice(0, 80)}"`;
+  let line = formatReference(input.kind, input.uid);
+  if (input.title && input.title.trim()) line += ` ${quote(input.title)}`;
+  if (input.within) {
+    const w = input.within;
+    if (input.kind === "comment" || input.kind === "attachment") {
+      line += ` on ${formatReference(w.kind, w.uid)}`;
+      if (w.title && w.title.trim()) line += ` ${quote(w.title)}`;
+    } else if (w.title && w.title.trim()) {
+      line += ` (${w.kind} ${quote(w.title)})`;
+    } else {
+      line += ` (${formatReference(w.kind, w.uid)})`;
+    }
+  }
+  return line;
+}
+function parseReference(raw) {
+  if (typeof raw !== "string") return null;
+  const text = raw.trim();
+  if (FULL_UUID.test(text)) return null;
+  const m = /^(?:(plan|task|page|comment|attachment)\s*[:\s]\s*|#)?([0-9a-f-]+)$/i.exec(text);
+  if (!m) return null;
+  const prefix = m[2].replace(/-/g, "").toLowerCase();
+  if (prefix.length < SHORT_ID_LENGTH || prefix.length >= 32) return null;
+  return { kind: m[1]?.toLowerCase() ?? null, prefix };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REFERENCE_KINDS,
+  SHORT_ID_LENGTH,
+  formatReference,
+  formatReferenceLine,
+  parseReference,
+  shortId
+});

package/src/shared/lib/rule-pattern.js

@@ -0,0 +1,56 @@
+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 rule_pattern_exports = {};
+__export(rule_pattern_exports, {
+  inRulePattern: () => inRulePattern,
+  ruleCovers: () => ruleCovers
+});
+module.exports = __toCommonJS(rule_pattern_exports);
+var import_matcher = require("./matcher");
+var import_package_entry = require("./package-entry");
+var import_symbol_entry = require("./symbol-entry");
+function inRulePattern(pattern, relPath) {
+  const p = relPath.replace(/^\.\//, "");
+  if (pattern.includes("*")) {
+    const re = new RegExp(`^${(0, import_matcher.globSource)(pattern)}$`);
+    return re.test(p);
+  }
+  if (pattern.endsWith("/")) return p.startsWith(pattern);
+  return p === pattern || p.startsWith(pattern + "/");
+}
+function ruleCovers(rule, file) {
+  if (rule.kind === "grep" || rule.kind === "agent") return (rule.in ?? []).some((p) => inRulePattern(p, file)) && !(rule.except ?? []).some((e) => inRulePattern(e, file));
+  if (rule.kind === "package") return inRulePattern(rule.from, file) && (0, import_package_entry.packageApplies)(rule.mayNotImport, file) || (rule.only ?? []).some((o) => inRulePattern(o, file));
+  if (rule.kind === "folder") return inRulePattern(rule.from, file);
+  if (rule.kind === "calls") {
+    return (rule.only ?? []).some((o) => inRulePattern(o, file)) || inRulePattern(rule.from, file) && (0, import_package_entry.ecosystemOfPath)(file) !== null;
+  }
+  if (rule.kind === "symbol") {
+    const sym = (0, import_symbol_entry.splitSymbol)(rule.mayNotImport);
+    if (!sym) return false;
+    if (file === sym.file || (rule.only ?? []).some((o) => inRulePattern(o, file))) return true;
+    const eco = (0, import_package_entry.ecosystemOfPath)(file);
+    return inRulePattern(rule.from, file) && eco !== null && eco === (0, import_package_entry.ecosystemOfPath)(sym.file);
+  }
+  return inRulePattern(rule.from, file) || inRulePattern(rule.mayNotImport, file);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inRulePattern,
+  ruleCovers
+});

package/src/shared/lib/sdp-fingerprint.js

@@ -0,0 +1,115 @@
+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 sdp_fingerprint_exports = {};
+__export(sdp_fingerprint_exports, {
+  SdpFingerprintError: () => SdpFingerprintError,
+  collectFingerprints: () => collectFingerprints,
+  extractSingleFingerprint: () => extractSingleFingerprint,
+  fingerprintsEqual: () => fingerprintsEqual,
+  normaliseFingerprint: () => normaliseFingerprint
+});
+module.exports = __toCommonJS(sdp_fingerprint_exports);
+class SdpFingerprintError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SdpFingerprintError";
+  }
+}
+const SHA256_FINGERPRINT = /^(?:[0-9A-F]{2}:){31}[0-9A-F]{2}$/;
+function collectFingerprints(sdp) {
+  if (typeof sdp !== "string" || sdp.length === 0) {
+    throw new SdpFingerprintError("SDP is empty");
+  }
+  const out = [];
+  let section = "session";
+  let mediaIndex = -1;
+  for (const rawLine of sdp.split(/\r\n|\r|\n/)) {
+    const line = rawLine.trim();
+    if (line.length === 0) continue;
+    if (line.startsWith("m=")) {
+      mediaIndex += 1;
+      section = mediaIndex;
+      continue;
+    }
+    if (!line.startsWith("a=fingerprint:")) continue;
+    const rest = line.slice("a=fingerprint:".length).trim();
+    const sp = rest.search(/\s/);
+    if (sp <= 0) {
+      throw new SdpFingerprintError(`Malformed fingerprint attribute: "${line.slice(0, 80)}"`);
+    }
+    const algorithm = rest.slice(0, sp).toLowerCase();
+    const value = rest.slice(sp + 1).trim().toUpperCase();
+    out.push({ section, algorithm, value });
+  }
+  return out;
+}
+function extractSingleFingerprint(sdp) {
+  const all = collectFingerprints(sdp);
+  if (all.length === 0) {
+    throw new SdpFingerprintError("SDP contains no DTLS fingerprint");
+  }
+  const nonSha256 = all.filter((f) => f.algorithm !== "sha-256");
+  if (nonSha256.length > 0) {
+    throw new SdpFingerprintError(
+      `SDP offers a non-sha-256 fingerprint (${nonSha256.map((f) => f.algorithm).join(", ")}); refusing`
+    );
+  }
+  for (const f of all) {
+    if (!SHA256_FINGERPRINT.test(f.value)) {
+      throw new SdpFingerprintError(
+        `Malformed sha-256 fingerprint "${f.value.slice(0, 40)}"`
+      );
+    }
+  }
+  const distinct = new Set(all.map((f) => f.value));
+  if (distinct.size > 1) {
+    throw new SdpFingerprintError(
+      `SDP contains ${distinct.size} conflicting DTLS fingerprints; refusing to guess which is authoritative`
+    );
+  }
+  const sessionCount = all.filter((f) => f.section === "session").length;
+  if (sessionCount > 1) {
+    throw new SdpFingerprintError(
+      `SDP repeats the session-level fingerprint attribute ${sessionCount} times`
+    );
+  }
+  return all[0].value;
+}
+function normaliseFingerprint(fp) {
+  if (typeof fp !== "string") return "";
+  const hex = fp.replace(/[^0-9A-Fa-f]/g, "").toUpperCase();
+  if (hex.length !== 64) return fp.trim().toUpperCase();
+  return (hex.match(/.{2}/g) ?? []).join(":");
+}
+function fingerprintsEqual(a, b) {
+  const na = normaliseFingerprint(a);
+  const nb = normaliseFingerprint(b);
+  if (na.length === 0 || nb.length === 0) return false;
+  if (na.length !== nb.length) return false;
+  let diff = 0;
+  for (let i = 0; i < na.length; i++) diff |= na.charCodeAt(i) ^ nb.charCodeAt(i);
+  return diff === 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SdpFingerprintError,
+  collectFingerprints,
+  extractSingleFingerprint,
+  fingerprintsEqual,
+  normaliseFingerprint
+});

package/src/shared/lib/sdp-minimal.js

@@ -0,0 +1,123 @@
+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 sdp_minimal_exports = {};
+__export(sdp_minimal_exports, {
+  ensureColonFingerprint: () => ensureColonFingerprint,
+  extractSdpParams: () => extractSdpParams,
+  reconstructAnswerSdp: () => reconstructAnswerSdp,
+  reconstructOfferSdp: () => reconstructOfferSdp,
+  stripColonFingerprint: () => stripColonFingerprint
+});
+module.exports = __toCommonJS(sdp_minimal_exports);
+var import_sdp_fingerprint = require("./sdp-fingerprint");
+function candidateLine(raw) {
+  if (typeof raw === "string") {
+    try {
+      const parsed = JSON.parse(raw);
+      return parsed?.candidate ?? raw;
+    } catch {
+      return raw;
+    }
+  }
+  return raw?.candidate ?? String(raw);
+}
+const CANDIDATE_RE = /candidate:\S+\s+\d+\s+udp\s+\d+\s+([\d.]+)\s+(\d+)\s+typ\s+(host|srflx)/i;
+function extractSdpParams(sdp, iceCandidates = []) {
+  const iu = sdp.match(/a=ice-ufrag:(\S+)/)?.[1];
+  const ip = sdp.match(/a=ice-pwd:(\S+)/)?.[1];
+  const fp = (0, import_sdp_fingerprint.extractSingleFingerprint)(sdp);
+  if (!iu) throw new Error("SDP missing ice-ufrag");
+  if (!ip) throw new Error("SDP missing ice-pwd");
+  const hosts = /* @__PURE__ */ new Map();
+  const reflexive = /* @__PURE__ */ new Map();
+  const consider = (line) => {
+    const m = CANDIDATE_RE.exec(line);
+    if (!m) return;
+    const [, addr, port, typ] = m;
+    (typ.toLowerCase() === "host" ? hosts : reflexive).set(addr, Number(port));
+  };
+  for (const raw of iceCandidates) consider(candidateLine(raw));
+  for (const m of sdp.matchAll(/^a=candidate:.*$/gm)) consider(m[0]);
+  const chosen = hosts.size > 0 ? hosts : reflexive;
+  if (chosen.size === 0) throw new Error("No usable ICE candidate found");
+  const ports = new Set(chosen.values());
+  if (ports.size > 1) {
+    throw new Error(
+      `ICE candidates span ${ports.size} ports (${[...ports].join(", ")}); the compact payload assumes one`
+    );
+  }
+  const maxMessageSize = Number(sdp.match(/a=max-message-size:(\d+)/)?.[1] ?? 65536);
+  return {
+    iu,
+    ip,
+    fp,
+    candidateAddrs: [...chosen.keys()],
+    candidatePort: [...ports][0],
+    maxMessageSize
+  };
+}
+function buildSdp(params, setup) {
+  const fp = ensureColonFingerprint(params.fp);
+  return [
+    "v=0",
+    "o=- 0 0 IN IP4 0.0.0.0",
+    "s=-",
+    "t=0 0",
+    "a=group:BUNDLE 0",
+    "m=application 9 UDP/DTLS/SCTP webrtc-datachannel",
+    "c=IN IP4 0.0.0.0",
+    `a=ice-ufrag:${params.iu}`,
+    `a=ice-pwd:${params.ip}`,
+    "a=ice-options:trickle",
+    `a=fingerprint:sha-256 ${fp}`,
+    `a=setup:${setup}`,
+    "a=mid:0",
+    "a=sctp-port:5000",
+    `a=max-message-size:${params.maxMessageSize}`,
+    // One line per interface, so a pairing made at a desk still connects over
+    // a VPN. Priority descends with index purely so the order is stable.
+    ...params.candidateAddrs.map(
+      (addr, i) => `a=candidate:${i + 1} 1 udp ${2113937151 - i} ${addr} ${params.candidatePort} typ host generation 0`
+    ),
+    // Without this the peer waits for candidates that will never arrive and
+    // pays a gathering timeout before it gives up.
+    "a=end-of-candidates",
+    ""
+  ].join("\r\n");
+}
+function reconstructOfferSdp(params) {
+  return buildSdp(params, "actpass");
+}
+function reconstructAnswerSdp(params) {
+  return buildSdp(params, "active");
+}
+function stripColonFingerprint(fp) {
+  return fp.replace(/:/g, "");
+}
+function ensureColonFingerprint(fp) {
+  if (fp.includes(":")) return fp;
+  return fp.match(/.{1,2}/g)?.join(":") ?? fp;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ensureColonFingerprint,
+  extractSdpParams,
+  reconstructAnswerSdp,
+  reconstructOfferSdp,
+  stripColonFingerprint
+});

package/src/shared/lib/secret-paths.js

@@ -0,0 +1,34 @@
+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 secret_paths_exports = {};
+__export(secret_paths_exports, {
+  looksSecret: () => looksSecret
+});
+module.exports = __toCommonJS(secret_paths_exports);
+const TEMPLATE = /\.(example|sample|template|dist)$/i;
+const NAMES = /^(\.env(\..+)?|\.npmrc|\.pypirc|\.netrc|\.pgpass|\.htpasswd|credentials(\.json)?|secrets?\.(json|ya?ml|toml)|service-account.*\.json|id_(rsa|dsa|ecdsa|ed25519))$/i;
+const EXTENSIONS = /\.(pem|key|p12|pfx|jks|keystore|ppk|tfvars|kdbx)$/i;
+function looksSecret(p) {
+  const name = p.split(/[\\/]/).pop() ?? p;
+  if (TEMPLATE.test(name)) return false;
+  return NAMES.test(name) || EXTENSIONS.test(name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  looksSecret
+});