@event4u/agent-config 16.5.0 → 17.0.0

package/dist/hooks/egress_engine.chunk.cjs

@@ -0,0 +1,915 @@
+const __acChunkMetaUrl = require('node:url').pathToFileURL(__filename).href; const __acChunkMeta = { url: __acChunkMetaUrl, dirname: __dirname, filename: __filename };
+"use strict";
+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);
+
+// src/scripts/_lib/egress_engine.ts
+var egress_engine_exports = {};
+__export(egress_engine_exports, {
+  EGRESS_RULES: () => EGRESS_RULES,
+  ENGINE_SCHEMA: () => ENGINE_SCHEMA,
+  EgressRefusedError: () => EgressRefusedError,
+  TokenScope: () => TokenScope,
+  detect: () => detect,
+  injectText: () => injectText,
+  replaceJson: () => replaceJson,
+  replaceValues: () => replaceValues,
+  scanText: () => scanText,
+  tallyText: () => tallyText
+});
+module.exports = __toCommonJS(egress_engine_exports);
+
+// src/scripts/_lib/egress_rules.ts
+function shannonEntropy(value) {
+  const freq = /* @__PURE__ */ new Map();
+  for (const ch of value) {
+    freq.set(ch, (freq.get(ch) ?? 0) + 1);
+  }
+  const n = value.length;
+  let entropy = 0;
+  for (const count of freq.values()) {
+    const p = count / n;
+    entropy -= p * Math.log2(p);
+  }
+  return entropy;
+}
+var GENERIC_MIN_LENGTH = 16;
+var GENERIC_MIN_ENTROPY = 3.3;
+var CODE_EXPR = /[()$`{}<>[\];,]|->|=>|\.\w/;
+function looksLikeSecretValue(value) {
+  if (value.length < GENERIC_MIN_LENGTH || CODE_EXPR.test(value)) {
+    return false;
+  }
+  const hasDigit = /[0-9]/.test(value);
+  const mixedCase = /[a-z]/.test(value) && /[A-Z]/.test(value);
+  if (!hasDigit && !mixedCase) {
+    return false;
+  }
+  return shannonEntropy(value) >= GENERIC_MIN_ENTROPY;
+}
+var ASSIGNMENT_KEYWORDS = {
+  password: "password",
+  passwd: "passwd",
+  pwd: "pwd",
+  secret: "secret",
+  apiKey: "api[_-]?key",
+  apikey: "apikey",
+  accessToken: "access[_-]?token",
+  authToken: "auth[_-]?token",
+  clientSecret: "client[_-]?secret",
+  privateKey: "private[_-]?key",
+  token: "token",
+  bearer: "bearer"
+};
+function assignmentSource(shape) {
+  const alt = shape.keywords.map((k) => ASSIGNMENT_KEYWORDS[k]).join("|");
+  const group = shape.capture === true ? `(${alt})` : `(?:${alt})`;
+  const gap = shape.gap ?? "\\s*";
+  const head = `${shape.before ?? ""}${group}${shape.after ?? ""}${gap}[:=]`;
+  return shape.value === void 0 ? head : `${head}${gap}${shape.value}`;
+}
+function assignmentPattern(shape, flags) {
+  return new RegExp(assignmentSource(shape), flags);
+}
+var AUTHORIZATION_HEADER = "authorization";
+var KEY_MARKER = /-----(BEGIN|END) ([A-Z ]*)PRIVATE KEY-----/g;
+var BEGIN_LABEL = /^-----BEGIN ([A-Z ]*)PRIVATE KEY-----/;
+function pemBlockEnd(text, span) {
+  const label = BEGIN_LABEL.exec(text.slice(span.start, span.end))?.[1];
+  if (label === void 0) return null;
+  KEY_MARKER.lastIndex = span.end;
+  const m = KEY_MARKER.exec(text);
+  if (m === null || m[1] !== "END" || m[2] !== label) return null;
+  return m.index + m[0].length;
+}
+var IBAN_LENGTHS = "AD24AE23AL28AT20AZ28BA20BE16BG22BH22BI27BR29BY28CH21CR22CY28CZ24DE22DJ27DK18DO28EE20EG29ES24FI18FK18FO18FR27GB22GE22GI23GL18GR27GT28HN28HR21HU28IE22IL23IQ23IS26IT27JO30KW30KZ20LB28LC32LI21LT20LU20LV21LY25MC27MD24ME22MK19MN20MR27MT31MU30NI28NL18NO15OM23PK24PL28PS29PT25QA29RO24RS22RU33SA24SC31SD18SE24SI19SK24SM27SO23ST25SV28TL23TN24TR26UA29VA22VG24XK20YE30";
+function isValidIban(value) {
+  const iban = value.replace(/ /g, "").toUpperCase();
+  const at = IBAN_LENGTHS.indexOf(iban.slice(0, 2));
+  if (at === -1 || at % 4 !== 0 || Number(IBAN_LENGTHS.slice(at + 2, at + 4)) !== iban.length) return false;
+  if (!/^[A-Z]{2}[0-9]{2}[A-Z0-9]+$/.test(iban)) return false;
+  let rest = 0;
+  for (const ch of iban.slice(4) + iban.slice(0, 4)) {
+    const n = ch <= "9" ? ch.charCodeAt(0) - 48 : ch.charCodeAt(0) - 55;
+    rest = n > 9 ? (rest * 100 + n) % 97 : (rest * 10 + n) % 97;
+  }
+  return rest === 1;
+}
+function passesLuhn(value) {
+  const digits = value.replace(/[ -]/g, "");
+  if (!/^[0-9]{13,19}$/.test(digits) || /^(.)\1+$/.test(digits)) return false;
+  let sum = 0;
+  for (let i = 0; i < digits.length; i += 1) {
+    let d = digits.charCodeAt(digits.length - 1 - i) - 48;
+    if (i % 2 === 1) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+  }
+  return sum % 10 === 0;
+}
+function phoneDigits(min, max) {
+  return (value) => {
+    if (/^\+?[0-9]{4}-[0-9]{2}-[0-9]{2}/.test(value)) return false;
+    const n = value.replace(/[^0-9]/g, "").length;
+    return n >= min && n <= max;
+  };
+}
+function isValidGermanTaxId(value) {
+  const d = value.replace(/ /g, "");
+  if (!/^[1-9][0-9]{10}$/.test(d)) return false;
+  const counts = /* @__PURE__ */ new Map();
+  for (const ch of d.slice(0, 10)) counts.set(ch, (counts.get(ch) ?? 0) + 1);
+  const repeated = [...counts.values()].filter((c) => c > 1);
+  if (repeated.length !== 1 || repeated[0] > 3) return false;
+  let product = 10;
+  for (let i = 0; i < 10; i += 1) {
+    let sum = (d.charCodeAt(i) - 48 + product) % 10;
+    if (sum === 0) sum = 10;
+    product = sum * 2 % 11;
+  }
+  const check = (11 - product) % 10;
+  return check === d.charCodeAt(10) - 48;
+}
+function isValidUsSsn(value) {
+  const m = /^([0-9]{3})-([0-9]{2})-([0-9]{4})$/.exec(value);
+  if (m === null) return false;
+  const [area, group, serial] = [m[1], m[2], m[3]];
+  return area !== "000" && area !== "666" && !area.startsWith("9") && group !== "00" && serial !== "0000";
+}
+var EMAIL_EXCLUSIONS = [
+  /^git@/i,
+  /@(?:[a-z0-9-]+\.)*(?:example\.(?:com|net|org)|example|test|invalid|localhost|local)$/i,
+  /^(?:no-?reply|do-?not-?reply|noreply\+[^@]*)@/i,
+  /@users\.noreply\.github\.com$/i,
+  /@[0-9]x\.[a-z]+$/i,
+  /\.(?:png|jpe?g|gif|svg|webp|ico|js|mjs|cjs|ts|tsx|css|json|ya?ml|lock)$/i
+];
+var EMAIL_ALLOWLIST_DIGESTS = /* @__PURE__ */ new Set(["924acfa874365f8a", "8066a43fc18158bf"]);
+function emailAllowlistDigest(address) {
+  let h = 0xcbf29ce484222325n;
+  for (const ch of `egress-email-allowlist-v1\0${address.toLowerCase()}`) {
+    h ^= BigInt(ch.codePointAt(0));
+    h = h * 0x100000001b3n & 0xffffffffffffffffn;
+  }
+  return h.toString(16).padStart(16, "0");
+}
+function isReportableEmail(value) {
+  return !EMAIL_ALLOWLIST_DIGESTS.has(emailAllowlistDigest(value));
+}
+var EGRESS_RULES = [
+  {
+    rule: "anthropic-api-key",
+    type: "APIKEY",
+    prefixes: ["sk-ant-"],
+    class: "credential",
+    replacement: "detection",
+    kind: "anthropic-api-key",
+    pattern: /sk-ant-[A-Za-z0-9_-]{20,}/g
+  },
+  {
+    rule: "anthropic-project-key",
+    type: "APIKEY",
+    prefixes: ["sk-proj-"],
+    class: "credential",
+    replacement: "detection",
+    kind: "anthropic-api-key",
+    pattern: /sk-proj-[A-Za-z0-9_-]{20,}/g
+  },
+  {
+    rule: "aws-access-key",
+    type: "APIKEY",
+    prefixes: ["AKIA"],
+    class: "credential",
+    replacement: "detection",
+    pattern: /AKIA[0-9A-Z]{16}/g
+  },
+  {
+    rule: "google-api-key",
+    type: "APIKEY",
+    prefixes: ["AIza"],
+    class: "credential",
+    replacement: "detection",
+    pattern: /AIza[0-9A-Za-z_-]{35}/g
+  },
+  {
+    rule: "github-pat",
+    type: "TOKEN",
+    prefixes: ["ghp_"],
+    class: "credential",
+    replacement: "detection",
+    pattern: /ghp_[0-9A-Za-z]{36}/g
+  },
+  {
+    rule: "github-fine-grained-pat",
+    type: "TOKEN",
+    prefixes: ["github_pat_"],
+    class: "credential",
+    replacement: "detection",
+    kind: "github-pat",
+    pattern: /github_pat_[0-9A-Za-z_]{22,}/g
+  },
+  {
+    rule: "openai-api-key",
+    type: "APIKEY",
+    prefixes: ["sk-"],
+    class: "credential",
+    replacement: "detection",
+    tokenStart: true,
+    pattern: /(?<![A-Za-z0-9])sk-[A-Za-z0-9]{20,}/g
+  },
+  {
+    rule: "google-oauth-token",
+    type: "TOKEN",
+    prefixes: ["ya29."],
+    class: "credential",
+    replacement: "detection",
+    tokenStart: true,
+    pattern: /(?<![A-Za-z0-9])ya29\.[0-9A-Za-z_-]{20,}/g
+  },
+  {
+    rule: "github-app-token",
+    type: "TOKEN",
+    prefixes: ["gho_", "ghu_", "ghs_", "ghr_"],
+    class: "credential",
+    replacement: "detection",
+    pattern: /gh[ousr]_[A-Za-z0-9]{36,}/g
+  },
+  {
+    rule: "xai-api-key",
+    type: "APIKEY",
+    prefixes: ["xai-"],
+    class: "credential",
+    replacement: "detection",
+    tokenStart: true,
+    pattern: /(?<![A-Za-z0-9])xai-[A-Za-z0-9]{20,}/g
+  },
+  {
+    rule: "perplexity-api-key",
+    type: "APIKEY",
+    prefixes: ["pplx-"],
+    class: "credential",
+    replacement: "detection",
+    pattern: /pplx-[A-Za-z0-9]{20,}/g
+  },
+  {
+    rule: "groq-api-key",
+    type: "APIKEY",
+    prefixes: ["gsk_"],
+    class: "credential",
+    replacement: "detection",
+    tokenStart: true,
+    pattern: /(?<![A-Za-z0-9])gsk_[A-Za-z0-9]{20,}/g
+  },
+  {
+    rule: "huggingface-token",
+    type: "TOKEN",
+    prefixes: ["hf_"],
+    class: "credential",
+    replacement: "detection",
+    tokenStart: true,
+    pattern: /(?<![A-Za-z0-9])hf_[A-Za-z0-9]{30,}/g
+  },
+  {
+    rule: "nvidia-api-key",
+    type: "APIKEY",
+    prefixes: ["nvapi-"],
+    class: "credential",
+    replacement: "detection",
+    tokenStart: true,
+    pattern: /(?<![A-Za-z0-9])nvapi-[A-Za-z0-9_-]{40,}/g
+  },
+  {
+    rule: "replicate-api-token",
+    type: "TOKEN",
+    prefixes: ["r8_"],
+    class: "credential",
+    replacement: "detection",
+    tokenStart: true,
+    pattern: /(?<![A-Za-z0-9])r8_[A-Za-z0-9]{30,}/g
+  },
+  {
+    rule: "jwt",
+    type: "TOKEN",
+    class: "credential",
+    replacement: "detection",
+    pattern: /(?<![A-Za-z0-9_-])(?=((?:(?!eyJ)[A-Za-z0-9_-])*))\1(eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,})/dg,
+    valueGroup: 2
+  },
+  {
+    rule: "stripe-secret-key",
+    type: "APIKEY",
+    prefixes: ["sk_live_", "sk_test_"],
+    class: "credential",
+    replacement: "detection",
+    pattern: /sk_(?:live|test)_[0-9A-Za-z]{16,}/g
+  },
+  {
+    rule: "slack-token",
+    type: "TOKEN",
+    prefixes: ["xoxb-", "xoxp-", "xoxa-", "xoxr-", "xoxs-"],
+    class: "credential",
+    replacement: "detection",
+    pattern: /xox[baprs]-[0-9A-Za-z-]{10,}/g
+  },
+  {
+    rule: "pem-private-key",
+    type: "PRIVATEKEY",
+    class: "credential",
+    pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----/g,
+    replacement: { through: pemBlockEnd }
+  },
+  {
+    rule: "db-connection-uri",
+    type: "DBURI",
+    class: "credential",
+    replacement: "detection",
+    pattern: /(?<![a-z0-9+.-])(?=((?:(?!\b[a-z])[a-z0-9+.-])*))\1(\b[a-z][a-z0-9+.-]*:\/\/[^\s:/@]+:[^\s:/@]+@)/dg,
+    valueGroup: 2
+  },
+  {
+    rule: "generic-assignment",
+    type: "SECRET",
+    class: "credential",
+    replacement: "detection",
+    pattern: assignmentPattern(
+      {
+        keywords: ["password", "passwd", "pwd", "secret", "apiKey", "accessToken", "authToken"],
+        value: `['"]?([^'"\\s]{8,})['"]?`
+      },
+      "dgi"
+    ),
+    valueGroup: 1,
+    validator: looksLikeSecretValue
+  },
+  {
+    rule: "iban",
+    type: "IBAN",
+    class: "identifier",
+    replacement: "detection",
+    pattern: /(?<![A-Za-z0-9])[A-Z]{2}[0-9]{2}(?: ?[A-Z0-9]{4}){2,7}(?: ?[A-Z0-9]{1,3})?(?![A-Za-z0-9])/g,
+    validator: isValidIban
+  },
+  {
+    rule: "payment-card",
+    type: "CARD",
+    class: "identifier",
+    replacement: "detection",
+    pattern: /(?<![0-9])[0-9](?:[ -]?[0-9]){12,18}(?![0-9])/g,
+    validator: passesLuhn,
+    context: {
+      words: /\b(?:card|credit|debit|visa|mastercard|amex|maestro|kreditkarte|karte|kartennummer|payment|zahlung)\b/i,
+      window: 48
+    }
+  },
+  {
+    rule: "email",
+    type: "EMAIL",
+    class: "identifier",
+    replacement: "detection",
+    pattern: /(?<![A-Za-z0-9._%+\\-])[A-Za-z0-9][A-Za-z0-9._%+-]{0,63}@(?:[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?\.){1,8}[A-Za-z]{2,24}(?![A-Za-z0-9-])/g,
+    exclusions: EMAIL_EXCLUSIONS,
+    validator: isReportableEmail
+  },
+  {
+    rule: "phone-international",
+    type: "PHONE",
+    class: "identifier",
+    replacement: "detection",
+    pattern: /(?<![A-Za-z0-9+])\+[1-9][0-9]{0,2}(?:[ ./-]?(?:\([0-9]{1,6}\)|(?=([0-9]{1,6}))\1)){1,5}(?![0-9])/g,
+    validator: phoneDigits(8, 15)
+  },
+  {
+    rule: "phone-national",
+    type: "PHONE",
+    class: "identifier",
+    replacement: "detection",
+    pattern: /(?<![A-Za-z0-9+(])(?:\(0[1-9][0-9]{1,4}\)|0[1-9][0-9]{1,4})(?:[ ./-]?(?=([0-9]{2,8}))\1){1,3}(?![0-9])/g,
+    validator: phoneDigits(7, 13),
+    context: { words: /\b(?:tel|telefon|telephone|phone|mobil|mobile|cell|fax|handy|call|ruf)\b/i, window: 32 }
+  },
+  {
+    rule: "phone-nanp",
+    type: "PHONE",
+    class: "identifier",
+    replacement: "detection",
+    pattern: /(?<![A-Za-z0-9+(-])(?:\+?1[ .-]?)?(?:\([2-9][0-9]{2}\) ?|[2-9][0-9]{2}[ .-]?)[2-9][0-9]{2}[ .-]?[0-9]{4}(?![0-9-])/g,
+    context: { words: /\b(?:tel|telephone|phone|mobile|cell|fax|call)\b/i, window: 32 }
+  },
+  {
+    rule: "de-tax-id",
+    type: "TAXID",
+    class: "identifier",
+    replacement: "detection",
+    pattern: /(?<![0-9])[1-9](?: ?[0-9]){10}(?![0-9])/g,
+    validator: isValidGermanTaxId,
+    context: {
+      words: /\b(?:steuer-?id|steuer-?identifikationsnummer|identifikationsnummer|idnr|tax[ -]?id|tin)\b/i,
+      window: 48
+    }
+  },
+  {
+    rule: "us-ssn",
+    type: "SSN",
+    class: "identifier",
+    replacement: "detection",
+    pattern: /(?<![0-9-])[0-9]{3}-[0-9]{2}-[0-9]{4}(?![0-9-])/g,
+    validator: isValidUsSsn
+  }
+];
+var TYPE_WORD = /^(?:string|number|boolean|bigint|unknown|any|never|void|undefined|null|true|false|none|nil|new|typeof|keyof|await|async|function|const|let|var|return|this|self|class|import|require|readonly|export|default|yield|password|passwd|pwd|secret|token|bearer|api[_-]?key|apikey)$/i;
+var KEY_START = "(?<![A-Za-z0-9])";
+var QUOTED_OR_BARE_VALUE = `(?:"([^"\\n]*)"|'([^'\\n]*)'|["']([^\\n]+)|([^\\s'"]+))`;
+var REVIEW_CREDENTIAL_ROWS = [
+  {
+    rule: "review-assignment",
+    type: "SECRET",
+    class: "credential",
+    replacement: "detection",
+    pattern: assignmentPattern(
+      {
+        keywords: ["apiKey", "secret", "token", "password"],
+        before: KEY_START,
+        capture: true,
+        gap: "[ \\t]*",
+        value: QUOTED_OR_BARE_VALUE
+      },
+      "dgi"
+    ),
+    valueGroup: [2, 3, 4, 5],
+    // Group 5 is the bare value. A quoted one is a literal, where `,` `$`
+    // or `.` is password punctuation rather than code, so only a bare value
+    // is read as a code expression.
+    validator: (v, g) => (g !== 5 || !CODE_EXPR.test(v)) && !TYPE_WORD.test(v)
+  },
+  {
+    rule: "review-authorization-header",
+    type: "TOKEN",
+    class: "credential",
+    replacement: "detection",
+    pattern: new RegExp(`^[ \\t]*${AUTHORIZATION_HEADER}:[ \\t]*(\\S[^\\n]*)`, "dgim"),
+    valueGroup: 1
+  }
+];
+var CREDENTIAL_RULES = EGRESS_RULES.filter((r) => r.class === "credential");
+var IDENTIFIER_RULES = EGRESS_RULES.filter((r) => r.class === "identifier");
+var CREDENTIAL_PREFIXES = EGRESS_RULES.flatMap((r) => r.prefixes ?? []).sort(
+  (a, b) => b.length - a.length
+);
+var TOKEN_START_PREFIXES = new Set(
+  EGRESS_RULES.filter((r) => r.tokenStart === true).flatMap((r) => r.prefixes ?? [])
+);
+var CLASS_RANK = {
+  credential: 1,
+  identifier: 0
+};
+function testWholeValue(re, value) {
+  re.lastIndex = 0;
+  return re.test(value);
+}
+function valueGroupOf(r, m) {
+  if (r.valueGroup === void 0) return "whole-match";
+  if (typeof r.valueGroup === "number") return r.valueGroup;
+  return r.valueGroup.find((g) => m[g] !== void 0) ?? null;
+}
+function evaluateMatch(r, text, m) {
+  const group = valueGroupOf(r, m);
+  if (group === null) return null;
+  const value = group === "whole-match" ? m[0] : m[group];
+  if (value === void 0 || value.length === 0) return null;
+  const start = group === "whole-match" ? m.index : m.indices?.[group]?.[0] ?? -1;
+  if (start < 0) {
+    throw new Error(`egress rule ${r.rule}: a valueGroup rule needs the d flag for capture offsets`);
+  }
+  const end = start + value.length;
+  if (r.exclusions?.some((x) => testWholeValue(x, value))) return null;
+  if (r.context) {
+    const lo = Math.max(0, start - r.context.window);
+    const hi = Math.min(text.length, end + r.context.window);
+    const around = text.slice(lo, start) + " " + text.slice(end, hi);
+    r.context.words.lastIndex = 0;
+    if (!r.context.words.test(around)) return null;
+  }
+  if (r.validator) {
+    return r.validator(value, group) ? { start, end, validated: true } : null;
+  }
+  return { start, end, validated: false };
+}
+function findSpans(text, rules = EGRESS_RULES) {
+  const out = [];
+  for (const r of rules) {
+    r.pattern.lastIndex = 0;
+    let m;
+    while ((m = r.pattern.exec(text)) !== null) {
+      if (m[0].length === 0) {
+        r.pattern.lastIndex += 1;
+        continue;
+      }
+      const c = evaluateMatch(r, text, m);
+      if (c === null) continue;
+      const { start, end, validated } = c;
+      out.push({
+        rule: r.rule,
+        type: r.type,
+        class: r.class,
+        start,
+        end,
+        validated
+      });
+    }
+  }
+  return out;
+}
+function resolveOverlaps(spans) {
+  const ranked = [...spans].sort(
+    (a, b) => CLASS_RANK[b.class] - CLASS_RANK[a.class] || Number(b.validated) - Number(a.validated) || b.end - b.start - (a.end - a.start) || a.start - b.start
+  );
+  const kept = [];
+  for (const s of ranked) {
+    if (!kept.some((k) => s.start < k.end && k.start < s.end)) kept.push(s);
+  }
+  return kept.sort((a, b) => a.start - b.start);
+}
+function detect(text, rules = EGRESS_RULES) {
+  return resolveOverlaps(findSpans(text, rules));
+}
+function replaceSpans(text, spans, replacement) {
+  const ordered = [...spans].sort((a, b) => a.start - b.start);
+  for (let i = 1; i < ordered.length; i++) {
+    if (ordered[i].start < ordered[i - 1].end) {
+      throw new Error("replaceSpans: spans overlap; resolve them first");
+    }
+  }
+  let out = text;
+  for (let i = ordered.length - 1; i >= 0; i--) {
+    const s = ordered[i];
+    out = out.slice(0, s.start) + replacement(s, i) + out.slice(s.end);
+  }
+  return out;
+}
+
+// src/scripts/_lib/egress_token.ts
+var import_node_crypto = require("node:crypto");
+var TOKEN_FP_LENGTH = 6;
+var TOKEN_PATTERN = /__([A-Z][A-Z0-9]{1,15})_([1-9][0-9]{0,5})_([0-9a-f]{6})(?:_v([2-9]|[1-9][0-9]))?__/g;
+var TOKEN_TYPE = /^[A-Z][A-Z0-9]{1,15}$/;
+var MAX_TOKEN_NUMBER = 999999;
+var MAX_TOKEN_VARIANT = 99;
+var MAX_FAILED_RESOLUTIONS = 64;
+var TOKEN_FP = /^[0-9a-f]{6}$/;
+function formatToken(p) {
+  if (!TOKEN_TYPE.test(p.type) || !Number.isInteger(p.number) || p.number < 1 || p.number > MAX_TOKEN_NUMBER || !TOKEN_FP.test(p.fingerprint) || p.variant !== void 0 && (!Number.isInteger(p.variant) || p.variant < 1 || p.variant > MAX_TOKEN_VARIANT)) {
+    throw new Error("formatToken: parts outside the token grammar");
+  }
+  const suffix = p.variant === void 0 || p.variant === 1 ? "" : `_v${p.variant}`;
+  return `__${p.type}_${p.number}_${p.fingerprint}${suffix}__`;
+}
+function parseTokens(text) {
+  const out = [];
+  TOKEN_PATTERN.lastIndex = 0;
+  let m;
+  while ((m = TOKEN_PATTERN.exec(text)) !== null) {
+    out.push({
+      type: m[1],
+      number: Number(m[2]),
+      fingerprint: m[3],
+      variant: m[4] === void 0 ? 1 : Number(m[4]),
+      start: m.index,
+      end: m.index + m[0].length
+    });
+  }
+  return out;
+}
+var CANONICAL_FORMS = {
+  IBAN: (raw) => raw.replace(/\s+/g, "").toUpperCase(),
+  CARD: (raw) => raw.replace(/[\s-]+/g, ""),
+  PHONE: (raw) => raw.replace(/[\s().\-/]+/g, "")
+};
+function canonicalValue(type, raw) {
+  return CANONICAL_FORMS[type]?.(raw) ?? raw;
+}
+var TokenScope = class {
+  key;
+  byDigest = /* @__PURE__ */ new Map();
+  byToken = /* @__PURE__ */ new Map();
+  counters = /* @__PURE__ */ new Map();
+  failedResolutions = 0;
+  /** Keyed digest of the canonical value alone → its class, whatever type it was minted under. */
+  classByValue = /* @__PURE__ */ new Map();
+  constructor() {
+    this.key = (0, import_node_crypto.randomBytes)(32);
+  }
+  /**
+   * The token for one spelling. Spellings with one canonical form share number
+   * and fingerprint and differ in the variant suffix, so each restores to its
+   * own bytes.
+   */
+  mint(type, cls, spelling) {
+    const canonical = canonicalValue(type, spelling);
+    if (!TOKEN_TYPE.test(type)) {
+      throw new Error(`TokenScope: type ${JSON.stringify(type)} is outside the token grammar`);
+    }
+    const valueDigest = (0, import_node_crypto.createHmac)("sha256", this.key).update(`value\0${canonical}`).digest("hex");
+    const seenClass = this.classByValue.get(valueDigest);
+    if (seenClass !== void 0 && seenClass !== cls) {
+      throw new Error(`TokenScope: this value was minted under class ${seenClass}, refusing class ${cls}`);
+    }
+    const digest = (0, import_node_crypto.createHmac)("sha256", this.key).update(`${type}\0${canonical}`).digest("hex");
+    const spellingDigest = (0, import_node_crypto.createHmac)("sha256", this.key).update(`spelling\0${type}\0${spelling}`).digest("hex");
+    const known = this.byDigest.get(digest);
+    if (known !== void 0) {
+      const at = known.spellings.indexOf(spellingDigest);
+      if (at !== -1) return formatToken({ ...known, variant: at + 1 });
+      if (known.spellings.length >= MAX_TOKEN_VARIANT) {
+        throw new Error(`TokenScope: this ${type} has used every variant the grammar can carry`);
+      }
+      known.spellings.push(spellingDigest);
+      return this.issue(known, known.spellings.length, cls, spelling);
+    }
+    const number = (this.counters.get(type) ?? 0) + 1;
+    if (number > MAX_TOKEN_NUMBER) {
+      throw new Error(`TokenScope: ${type} has used every number the grammar can carry`);
+    }
+    this.counters.set(type, number);
+    const entry = {
+      type,
+      class: cls,
+      number,
+      fingerprint: digest.slice(0, TOKEN_FP_LENGTH),
+      spellings: [spellingDigest]
+    };
+    this.classByValue.set(valueDigest, cls);
+    this.byDigest.set(digest, entry);
+    return this.issue(entry, 1, cls, spelling);
+  }
+  issue(entry, variant, cls, spelling) {
+    const token = formatToken({ ...entry, variant });
+    this.byToken.set(token, { entry, value: cls === "identifier" ? spelling : null });
+    return token;
+  }
+  /** True only for a token this scope minted; token syntax alone proves nothing. */
+  owns(token) {
+    return this.byToken.has(token);
+  }
+  /** The identifier value a token stands for, or null: unknown, forged, foreign or credential. */
+  resolve(token) {
+    if (this.failedResolutions >= MAX_FAILED_RESOLUTIONS) return null;
+    const issued = this.byToken.get(token);
+    if (issued === void 0) {
+      this.failedResolutions += 1;
+      return null;
+    }
+    return issued.value;
+  }
+  /** What the scope holds, without any value or spelling digest. */
+  snapshot() {
+    return [...this.byDigest.values()].map(({ spellings, ...rest }) => ({ ...rest, variants: spellings.length }));
+  }
+};
+var EgressRefusedError = class extends Error {
+  constructor(rule) {
+    super(`egress refused: rule ${rule} could not prove the extent of a detected secret`);
+    this.rule = rule;
+    this.name = "EgressRefusedError";
+  }
+  rule;
+};
+var RULE_BY_ID = new Map(EGRESS_RULES.map((r) => [r.rule, r]));
+var CLASS_RANK2 = { credential: 1, identifier: 0 };
+function replacementSpans(text, detected) {
+  const extents = detected.map((s) => {
+    const policy = RULE_BY_ID.get(s.rule)?.replacement;
+    if (policy === void 0) throw new EgressRefusedError(s.rule);
+    if (policy === "detection") return s;
+    const end = policy.through(text, s);
+    if (end === null || end < s.end) throw new EgressRefusedError(s.rule);
+    return { ...s, end };
+  });
+  extents.sort((a, b) => a.start - b.start);
+  const merged = [];
+  for (const s of extents) {
+    const last = merged[merged.length - 1];
+    if (last !== void 0 && s.start < last.end) {
+      const keep = CLASS_RANK2[s.class] > CLASS_RANK2[last.class] ? s : last;
+      merged[merged.length - 1] = { ...keep, start: last.start, end: Math.max(last.end, s.end) };
+    } else {
+      merged.push(s);
+    }
+  }
+  return merged;
+}
+function replaceValues(text, scope) {
+  const owned = parseTokens(text).filter((t) => scope.owns(text.slice(t.start, t.end)));
+  const detected = detect(text).filter((s) => !owned.some((t) => t.start <= s.start && s.end <= t.end));
+  const spans = replacementSpans(text, detected);
+  const tokens = spans.map((s) => scope.mint(s.type, s.class, text.slice(s.start, s.end)));
+  return replaceSpans(text, spans, (_s, i) => tokens[i]);
+}
+
+// src/scripts/_lib/egress_text.ts
+var RULE_BY_ID2 = new Map(EGRESS_RULES.map((r) => [r.rule, r]));
+function tallyText(text) {
+  const found = [];
+  const refused = [];
+  for (const span of detect(text)) {
+    const policy = RULE_BY_ID2.get(span.rule)?.replacement;
+    if (policy !== void 0 && policy !== "detection") {
+      const end = policy.through(text, span);
+      if (end === null || end < span.end) {
+        refused.push(span.rule);
+        continue;
+      }
+    }
+    found.push({ class: span.class, type: span.type });
+  }
+  return { found, refused };
+}
+function replaceJson(v, scope) {
+  if (typeof v === "string") return replaceValues(v, scope);
+  if (Array.isArray(v)) return v.map((x) => replaceJson(x, scope));
+  if (v !== null && typeof v === "object") {
+    const out = {};
+    for (const [k, x] of Object.entries(v)) out[k] = replaceJson(x, scope);
+    return out;
+  }
+  return v;
+}
+function injectText(text, scope) {
+  try {
+    return replaceValues(text, scope);
+  } catch (exc) {
+    return `[egress: injected text withheld (${exc instanceof EgressRefusedError ? exc.rule : "stage-error"})]`;
+  }
+}
+
+// src/scripts/_lib/secret_detector.ts
+var ENTROPY_MIN_TOKEN_LENGTH = 20;
+var BASE64_ENTROPY_THRESHOLD = 4.5;
+var HEX_ENTROPY_THRESHOLD = 3;
+var RULES = EGRESS_RULES.filter((r) => r.class === "credential");
+var SECRET_ALLOW = /secret-allow/;
+var PLACEHOLDER_PATTERNS = [
+  /x{4,}/i,
+  /example/i,
+  /changeme/i,
+  /your[_-].*here/i,
+  /<[^>]+>/,
+  /\.\.\./,
+  /^your[_-]/i,
+  /placeholder/i
+];
+var DATA_URI = /data:[\w.+-]+\/[\w.+-]+;base64,/i;
+var UUID = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+var KEYWORD_CONTEXT = /password|secret|token|api[_-]?key|credential/i;
+var ENTROPY_TOKEN = /[A-Za-z0-9+=_-]{20,}/g;
+var IS_HEX = /^[0-9a-fA-F]+$/;
+var HASH_HEX_LENGTHS = /* @__PURE__ */ new Set([32, 40, 64]);
+function isAllSameChar(value) {
+  return value.length > 0 && /^(.)\1*$/.test(value);
+}
+function isPlaceholderValue(value, pathHint) {
+  if (pathHint !== void 0) {
+    if (pathHint.endsWith(".example") || pathHint.endsWith(".sample") || pathHint.includes(".env.example")) {
+      return true;
+    }
+  }
+  if (isAllSameChar(value)) {
+    return true;
+  }
+  return PLACEHOLDER_PATTERNS.some((p) => p.test(value));
+}
+function maskSecret(value) {
+  const front = value.slice(0, 4);
+  const back = value.length > 6 ? value.slice(-2) : "";
+  if (front.length + back.length >= value.length) {
+    return `${value.slice(0, 1)}\u2026`;
+  }
+  return `${front}\u2026${back}`;
+}
+function overlaps(spans, start, end) {
+  return spans.some(([s, e]) => start < e && s < end);
+}
+function scanText(text, opts = {}) {
+  const pathHint = opts.path;
+  const findings = [];
+  const lines = text.split(/\r\n|\r|\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNo = i + 1;
+    if (SECRET_ALLOW.test(line)) {
+      continue;
+    }
+    const covered = [];
+    for (const rule of opts.rules ?? RULES) {
+      const pattern = rule.pattern.global ? rule.pattern : new RegExp(rule.pattern.source, `${rule.pattern.flags}g`);
+      pattern.lastIndex = 0;
+      let m;
+      while ((m = pattern.exec(line)) !== null) {
+        const c = evaluateMatch(rule, line, m);
+        if (c === null) {
+          if (m.index === pattern.lastIndex) {
+            pattern.lastIndex += 1;
+          }
+          continue;
+        }
+        const valueStart = c.start;
+        const value = line.slice(c.start, c.end);
+        const confidence = isPlaceholderValue(value, pathHint) ? "low" : "high";
+        findings.push({
+          rule: rule.rule,
+          kind: rule.kind ?? rule.rule,
+          line: lineNo,
+          column: valueStart + 1,
+          masked: maskSecret(value),
+          confidence
+        });
+        covered.push([valueStart, valueStart + value.length]);
+        if (m.index === pattern.lastIndex) {
+          pattern.lastIndex += 1;
+        }
+      }
+    }
+    if (!DATA_URI.test(line)) {
+      const hasKeyword = KEYWORD_CONTEXT.test(line);
+      ENTROPY_TOKEN.lastIndex = 0;
+      let tm;
+      while ((tm = ENTROPY_TOKEN.exec(line)) !== null) {
+        const token = tm[0];
+        const start = tm.index;
+        const end = start + token.length;
+        if (token.length < ENTROPY_MIN_TOKEN_LENGTH) {
+          continue;
+        }
+        if (overlaps(covered, start, end)) {
+          continue;
+        }
+        if (UUID.test(token)) {
+          continue;
+        }
+        if (/^sha(?:256|384|512)-/.test(token)) {
+          continue;
+        }
+        const entropy = shannonEntropy(token);
+        const isHex = IS_HEX.test(token);
+        if (isHex && HASH_HEX_LENGTHS.has(token.length)) {
+          continue;
+        }
+        let confidence = null;
+        if (isHex) {
+          if (entropy >= HEX_ENTROPY_THRESHOLD && hasKeyword) {
+            confidence = "high";
+          }
+        } else if (entropy >= BASE64_ENTROPY_THRESHOLD) {
+          confidence = hasKeyword ? "high" : "medium";
+        }
+        if (confidence === null) {
+          continue;
+        }
+        if (isPlaceholderValue(token, pathHint)) {
+          confidence = "low";
+        }
+        findings.push({
+          rule: "entropy",
+          kind: "high-entropy-string",
+          line: lineNo,
+          column: start + 1,
+          masked: maskSecret(token),
+          confidence
+        });
+      }
+    }
+  }
+  return findings;
+}
+
+// src/scripts/_lib/egress_engine.ts
+var ENGINE_SCHEMA = 2;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EGRESS_RULES,
+  ENGINE_SCHEMA,
+  EgressRefusedError,
+  TokenScope,
+  detect,
+  injectText,
+  replaceJson,
+  replaceValues,
+  scanText,
+  tallyText
+});