@tailrace/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1924 @@
+// src/errors-docs.ts
+var DOCS_ERRORS_BASE = "https://tailrace.dev/docs/reference/errors";
+function withDocsUrl(code, message) {
+  const suffix = `\u2192 ${DOCS_ERRORS_BASE}/${code}`;
+  if (message.includes(suffix) || message.includes(`${DOCS_ERRORS_BASE}/${code}`)) {
+    return message;
+  }
+  return `${message} ${suffix}`;
+}
+
+// src/errors.ts
+var TailraceError = class extends Error {
+  /** Stable, machine-readable error code. */
+  code;
+  constructor(code, message) {
+    super(withDocsUrl(code, message));
+    this.name = new.target.name;
+    this.code = code;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var PolicyViolationError = class extends TailraceError {
+  decisions;
+  constructor(message, decisions) {
+    super("POLICY_VIOLATION", message);
+    this.decisions = decisions;
+  }
+};
+var PolicyValidationError = class extends TailraceError {
+  path;
+  constructor(message, path) {
+    super("POLICY_INVALID", message);
+    this.path = path;
+  }
+};
+var InvariantViolationError = class extends TailraceError {
+  constructor(message) {
+    super("INVARIANT", message);
+  }
+};
+var VaultError = class extends TailraceError {
+  constructor(message) {
+    super("VAULT", message);
+  }
+};
+var RecognizerError = class extends TailraceError {
+  constructor(message) {
+    super("RECOGNIZER", message);
+  }
+};
+var NotImplementedError = class extends TailraceError {
+  constructor(message) {
+    super("NOT_IMPLEMENTED", message);
+  }
+};
+
+// src/types.ts
+var SECRET_ENTITY_CLASSES = [
+  "api_key",
+  "jwt",
+  "private_key",
+  "high_entropy_secret",
+  "connection_string"
+];
+var PII_ENTITY_CLASSES = [
+  "email",
+  "phone",
+  "credit_card",
+  "iban",
+  "ssn",
+  "ip_address",
+  "url_credentials"
+];
+var NER_ENTITY_CLASSES = ["person", "location", "organization"];
+
+// src/policy/boundary.ts
+function boundaryKey(boundary) {
+  switch (boundary.kind) {
+    case "model":
+      return boundary.provider;
+    case "tool":
+      return `tool:${boundary.name}:${boundary.direction}`;
+    case "mcp":
+      return `mcp:${boundary.server}/${boundary.tool}`;
+    case "telemetry":
+      return "telemetry";
+    case "egress":
+      return `egress:${boundary.sink}`;
+  }
+}
+function isEgressBoundaryKey(key) {
+  return key === "egress" || key.startsWith("egress:");
+}
+function boundaryKindOf(keyOrPattern) {
+  if (keyOrPattern === "telemetry") return "telemetry";
+  if (isEgressBoundaryKey(keyOrPattern)) return "egress";
+  if (keyOrPattern.startsWith("tool:")) return "tool";
+  if (keyOrPattern.startsWith("mcp:")) return "mcp";
+  return "model";
+}
+function globMatch(pattern, key) {
+  if (!pattern.includes("*")) return pattern === key;
+  const parts = pattern.split("*");
+  if (parts.length === 1) return pattern === key;
+  let pos = 0;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part.length === 0) {
+      if (i === 0) continue;
+      if (i === parts.length - 1) return true;
+      continue;
+    }
+    if (i === 0) {
+      if (!key.startsWith(part)) return false;
+      pos = part.length;
+      continue;
+    }
+    if (i === parts.length - 1) {
+      return key.endsWith(part) && key.length - part.length >= pos;
+    }
+    const idx = key.indexOf(part, pos);
+    if (idx === -1) return false;
+    pos = idx + part.length;
+  }
+  return true;
+}
+function matchBoundaryPatterns(key, patterns) {
+  const kind = boundaryKindOf(key);
+  const matched = patterns.filter((p) => boundaryKindOf(p) === kind && globMatch(p, key));
+  matched.sort((a, b) => {
+    const aGlob = a.includes("*") ? 1 : 0;
+    const bGlob = b.includes("*") ? 1 : 0;
+    if (aGlob !== bGlob) return aGlob - bGlob;
+    return b.length - a.length;
+  });
+  return matched;
+}
+
+// src/policy/resolve.ts
+var ACTION_RANK = {
+  block: 5,
+  review: 4,
+  tokenize: 3,
+  detokenize: 3,
+  mask: 2,
+  allow: 1
+};
+var SECRET_SET = new Set(SECRET_ENTITY_CLASSES);
+var BLOCK_PII_SET = /* @__PURE__ */ new Set([...PII_ENTITY_CLASSES, ...NER_ENTITY_CLASSES]);
+function moreRestrictive(a, b) {
+  return ACTION_RANK[a] >= ACTION_RANK[b] ? a : b;
+}
+function lookupEntity(entities, entity, pathPrefix) {
+  const exact = entities.get(entity);
+  if (exact !== void 0) return { rule: exact, path: `${pathPrefix}.${entity}` };
+  if (BLOCK_PII_SET.has(entity)) {
+    const blockPii = entities.get("block-pii");
+    if (blockPii !== void 0) return { rule: blockPii, path: `${pathPrefix}.block-pii` };
+  }
+  const star = entities.get("*");
+  if (star !== void 0) return { rule: star, path: `${pathPrefix}.*` };
+  return null;
+}
+function findBoundaryCandidate(boundaries, patterns, key, entity, pathPrefix) {
+  const matched = matchBoundaryPatterns(key, patterns);
+  for (const pattern of matched) {
+    const compiled = boundaries.find((b) => b.pattern === pattern);
+    if (compiled === void 0) continue;
+    const hit = lookupEntity(compiled.entities, entity, `${pathPrefix}.${pattern}.entities`);
+    if (hit !== null) return hit;
+  }
+  return null;
+}
+function collectCandidates(policy, entity, boundary, identity) {
+  const key = boundaryKey(boundary);
+  const agent = identity.agent || "default";
+  const out = [];
+  const push = (c) => {
+    if (c !== null) out.push(c);
+  };
+  const ident = policy.identities.get(agent);
+  if (ident !== void 0) {
+    push(
+      findBoundaryCandidate(
+        ident.boundaries,
+        ident.boundaryPatterns,
+        key,
+        entity,
+        `identities.${agent}.boundaries`
+      )
+    );
+    push(lookupEntity(ident.entities, entity, `identities.${agent}.entities`));
+  }
+  push(
+    findBoundaryCandidate(policy.boundaries, policy.boundaryPatterns, key, entity, "boundaries")
+  );
+  push(lookupEntity(policy.entities, entity, "entities"));
+  out.push({
+    rule: { action: policy.defaultsAction },
+    path: "defaults.action"
+  });
+  return out;
+}
+function resolve(policy, entity, boundary, identity) {
+  const candidates = collectCandidates(policy, entity, boundary, identity);
+  const winning = candidates[0];
+  let action = winning.rule.action;
+  let path = winning.path;
+  let format = winning.rule.format;
+  let dangerouslyAllowSecrets = winning.rule.dangerouslyAllowSecrets === true;
+  if (SECRET_SET.has(entity) && action === "allow" && !dangerouslyAllowSecrets && !policy.dangerouslyAllowSecrets) {
+    for (const c of candidates) {
+      if (c.rule.action === "block") {
+        action = "block";
+        path = c.path;
+        format = c.rule.format;
+        dangerouslyAllowSecrets = c.rule.dangerouslyAllowSecrets === true;
+        break;
+      }
+    }
+  }
+  return {
+    action,
+    rule: path.replace(/^\./, ""),
+    ...format !== void 0 ? { format } : {},
+    ...dangerouslyAllowSecrets ? { dangerouslyAllowSecrets: true } : {}
+  };
+}
+
+// src/console.ts
+function getConsole() {
+  const c = globalThis.console;
+  return c;
+}
+
+// src/vault/alphabet.ts
+var TOKEN_ID_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+var TOKEN_ID_LENGTH = 8;
+var TOKEN_ID_CHAR_CLASS = "[a-z0-9]";
+function assertAlphabetMatchesCharClass() {
+  if (TOKEN_ID_ALPHABET.length !== 36) {
+    throw new Error("TOKEN_ID_ALPHABET must have 36 characters (a-z0-9)");
+  }
+  const re = new RegExp(`^${TOKEN_ID_CHAR_CLASS}$`);
+  for (const ch of TOKEN_ID_ALPHABET) {
+    if (!re.test(ch)) {
+      throw new Error(
+        `TOKEN_ID_ALPHABET char "${ch}" is not matched by TOKEN_ID_CHAR_CLASS ${TOKEN_ID_CHAR_CLASS}`
+      );
+    }
+  }
+  for (const ch of "abcdefghijklmnopqrstuvwxyz0123456789") {
+    if (!TOKEN_ID_ALPHABET.includes(ch)) {
+      throw new Error(`TOKEN_ID_ALPHABET missing char-class member "${ch}"`);
+    }
+  }
+}
+assertAlphabetMatchesCharClass();
+function bytesToTokenId(bytes) {
+  let n = 0n;
+  const take = Math.min(bytes.length, 8);
+  for (let i = 0; i < take; i++) {
+    n = n << 8n | BigInt(bytes[i]);
+  }
+  const base = BigInt(TOKEN_ID_ALPHABET.length);
+  let out = "";
+  for (let i = 0; i < TOKEN_ID_LENGTH; i++) {
+    out = TOKEN_ID_ALPHABET[Number(n % base)] + out;
+    n = n / base;
+  }
+  return out;
+}
+var FORMAT_PRESERVE_ENTITIES = /* @__PURE__ */ new Set([
+  "email",
+  "phone",
+  "credit_card"
+]);
+
+// src/vault/crypto.ts
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function bytesToHex(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) {
+    out += bytes[i].toString(16).padStart(2, "0");
+  }
+  return out;
+}
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64ToBytes(b64) {
+  const binary = atob(b64);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    out[i] = binary.charCodeAt(i);
+  }
+  return out;
+}
+async function importHmacKey(raw) {
+  return crypto.subtle.importKey("raw", raw.slice(), { name: "HMAC", hash: "SHA-256" }, false, [
+    "sign"
+  ]);
+}
+async function hmacSha256(key, message) {
+  const cryptoKey = await importHmacKey(key);
+  const sig = await crypto.subtle.sign("HMAC", cryptoKey, message.slice());
+  return new Uint8Array(sig);
+}
+async function sha256Hex(value) {
+  const digest = await crypto.subtle.digest("SHA-256", textEncoder.encode(value));
+  return bytesToHex(new Uint8Array(digest));
+}
+function randomBytes(length) {
+  const out = new Uint8Array(length);
+  crypto.getRandomValues(out);
+  return out;
+}
+async function storageKeyMaterial(masterKey) {
+  const derived = await hmacSha256(masterKey, textEncoder.encode("storage"));
+  return crypto.subtle.importKey("raw", derived.slice(), { name: "AES-GCM" }, false, [
+    "encrypt",
+    "decrypt"
+  ]);
+}
+async function encryptAtRest(masterKey, plaintext) {
+  const key = await storageKeyMaterial(masterKey);
+  const iv = randomBytes(12);
+  const ct = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv: iv.slice() },
+    key,
+    textEncoder.encode(plaintext)
+  );
+  const packed = new Uint8Array(iv.length + ct.byteLength);
+  packed.set(iv, 0);
+  packed.set(new Uint8Array(ct), iv.length);
+  return bytesToBase64(packed);
+}
+async function decryptAtRest(masterKey, packedB64) {
+  const packed = base64ToBytes(packedB64);
+  if (packed.length < 13) {
+    throw new Error("ciphertext too short");
+  }
+  const iv = packed.subarray(0, 12);
+  const ct = packed.subarray(12);
+  const key = await storageKeyMaterial(masterKey);
+  const pt = await crypto.subtle.decrypt({ name: "AES-GCM", iv: iv.slice() }, key, ct.slice());
+  return textDecoder.decode(pt);
+}
+var ephemeralMasterKey;
+var warnedEphemeral = false;
+function envVaultKey() {
+  const g = globalThis;
+  return g.process?.env?.["TAILRACE_VAULT_KEY"];
+}
+function resolveMasterKey(explicit) {
+  if (explicit !== void 0 && explicit.length > 0) {
+    return textEncoder.encode(explicit);
+  }
+  const fromEnv = envVaultKey();
+  if (fromEnv !== void 0 && fromEnv.length > 0) {
+    return textEncoder.encode(fromEnv);
+  }
+  if (ephemeralMasterKey === void 0) {
+    ephemeralMasterKey = randomBytes(32);
+    if (!warnedEphemeral) {
+      warnedEphemeral = true;
+      getConsole()?.warn(
+        "[tailrace] No vault key configured; using ephemeral per-process key. Tokens will not survive restarts."
+      );
+    }
+  }
+  return ephemeralMasterKey;
+}
+
+// src/vault/token.ts
+var textEncoder2 = new TextEncoder();
+var LABEL_RE = new RegExp(
+  `<([A-Z][A-Z0-9_]*)_(${TOKEN_ID_CHAR_CLASS}{${TOKEN_ID_LENGTH}})>`,
+  "g"
+);
+var FPE_EMAIL_RE = new RegExp(
+  `\\b(${TOKEN_ID_CHAR_CLASS}{${TOKEN_ID_LENGTH}})@redacted\\.example\\b`,
+  "g"
+);
+var FPE_PHONE_RE = /\+1555(\d{7})\b/g;
+var FPE_CARD_RE = /\b(9(?:[\d][\s-]?){12,18}\d)\b/g;
+function normalizeValue(entity, value) {
+  const trimmed = value.trim();
+  if (entity === "email") return trimmed.toLowerCase();
+  if (entity === "phone" || entity === "credit_card") return trimmed.replace(/\D/g, "");
+  return trimmed;
+}
+function entityLabel(entity) {
+  return entity.toUpperCase();
+}
+function labelToken(entity, tokenId) {
+  return `<${entityLabel(entity)}_${tokenId}>`;
+}
+async function deriveWorkflowKey(masterKey, workflowId) {
+  return hmacSha256(masterKey, textEncoder2.encode(workflowId));
+}
+async function deriveTokenId(workflowKey, entity, normalizedValue) {
+  const entityBytes = textEncoder2.encode(entity);
+  const valueBytes = textEncoder2.encode(normalizedValue);
+  const msg = new Uint8Array(entityBytes.length + 1 + valueBytes.length);
+  msg.set(entityBytes, 0);
+  msg[entityBytes.length] = 0;
+  msg.set(valueBytes, entityBytes.length + 1);
+  const mac = await hmacSha256(workflowKey, msg);
+  return bytesToTokenId(mac);
+}
+function tokenIdToDigits(tokenId, count) {
+  let out = "";
+  let acc = 0;
+  for (let i = 0; out.length < count; i++) {
+    const c = tokenId.charCodeAt(i % tokenId.length);
+    acc = acc * 33 + c + i >>> 0;
+    out += String(acc % 10);
+  }
+  return out.slice(0, count);
+}
+function luhnCheckDigit(payloadWithoutCheck) {
+  let sum = 0;
+  let alt = true;
+  for (let i = payloadWithoutCheck.length - 1; i >= 0; i--) {
+    let n = Number(payloadWithoutCheck[i]);
+    if (alt) {
+      n *= 2;
+      if (n > 9) n -= 9;
+    }
+    sum += n;
+    alt = !alt;
+  }
+  return (10 - sum % 10) % 10;
+}
+function formatPreserveCard(original, tokenId) {
+  const digits = original.replace(/\D/g, "");
+  const len = Math.max(digits.length, 13);
+  const bodyLen = len - 1;
+  let body = tokenIdToDigits(tokenId, bodyLen);
+  body = "9" + body.slice(1);
+  const check = luhnCheckDigit(body);
+  const fake = body + String(check);
+  let di = 0;
+  let out = "";
+  for (let i = 0; i < original.length; i++) {
+    const ch = original[i];
+    if (/\d/.test(ch)) {
+      out += fake[di] ?? "0";
+      di++;
+    } else {
+      out += ch;
+    }
+  }
+  while (di < fake.length) {
+    out += fake[di];
+    di++;
+  }
+  return out;
+}
+function formatToken(entity, tokenId, format, originalValue) {
+  if (format === "preserve") {
+    if (entity === "email") return `${tokenId}@redacted.example`;
+    if (entity === "phone") return `+1555${tokenIdToDigits(tokenId, 7)}`;
+    if (entity === "credit_card") return formatPreserveCard(originalValue, tokenId);
+    getConsole()?.warn(
+      `[tailrace] format: "preserve" is not supported for entity "${entity}"; falling back to label token`
+    );
+  }
+  return labelToken(entity, tokenId);
+}
+function maskLabel(entity) {
+  return `[${entityLabel(entity)}]`;
+}
+
+// src/actions/pointer.ts
+function unescapePointer(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function cloneJson(value) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function getStringAtPointer(root, pointer) {
+  if (pointer === "" || pointer === "/") {
+    return null;
+  }
+  const parts = pointer.startsWith("/") ? pointer.slice(1).split("/") : pointer.split("/");
+  let cur = root;
+  for (const raw of parts) {
+    const key = unescapePointer(raw);
+    if (cur === null || typeof cur !== "object") return null;
+    if (Array.isArray(cur)) {
+      const idx = Number(key);
+      if (!Number.isInteger(idx) || idx < 0 || idx >= cur.length) return null;
+      cur = cur[idx];
+    } else {
+      if (!(key in cur)) return null;
+      cur = cur[key];
+    }
+  }
+  return typeof cur === "string" ? cur : null;
+}
+function setStringAtPointer(root, pointer, value) {
+  if (pointer === "" || pointer === "/") return;
+  const parts = pointer.startsWith("/") ? pointer.slice(1).split("/") : pointer.split("/");
+  let cur = root;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = unescapePointer(parts[i]);
+    if (cur === null || typeof cur !== "object") return;
+    if (Array.isArray(cur)) {
+      const idx = Number(key);
+      cur = cur[idx];
+    } else {
+      cur = cur[key];
+    }
+  }
+  const last = unescapePointer(parts[parts.length - 1]);
+  if (cur === null || typeof cur !== "object") return;
+  if (Array.isArray(cur)) {
+    const idx = Number(last);
+    if (Number.isInteger(idx) && idx >= 0 && idx < cur.length && typeof cur[idx] === "string") {
+      cur[idx] = value;
+    }
+  } else if (typeof cur[last] === "string") {
+    cur[last] = value;
+  }
+}
+
+// src/actions/apply.ts
+function collapseOverlaps(items) {
+  if (items.length === 0) return [];
+  const byPath = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const path = item.span.path ?? "";
+    const list = byPath.get(path) ?? [];
+    list.push(item);
+    byPath.set(path, list);
+  }
+  const out = [];
+  for (const group of byPath.values()) {
+    const sorted = [...group].sort(
+      (a, b) => a.span.start - b.span.start || b.span.end - a.span.end
+    );
+    const kept = [];
+    for (const item of sorted) {
+      const action = item.decision.action;
+      if (action === "restore_miss") continue;
+      const asAction = action;
+      let overlaps = false;
+      for (let i = 0; i < kept.length; i++) {
+        const other = kept[i];
+        if (item.span.start < other.span.end && item.span.end > other.span.start) {
+          overlaps = true;
+          const winner = moreRestrictive(asAction, other.action);
+          if (winner === asAction && asAction !== other.action) {
+            kept[i] = { ...item, action: asAction };
+          } else if (winner !== other.action) {
+            kept[i] = { ...other, action: winner };
+          }
+          break;
+        }
+      }
+      if (!overlaps) kept.push({ ...item, action: asAction });
+    }
+    out.push(...kept);
+  }
+  return out;
+}
+function extractValue(input, span) {
+  if (typeof input === "string") {
+    return input.slice(span.start, span.end);
+  }
+  const path = span.path ?? "";
+  const leaf = getStringAtPointer(input, path);
+  if (leaf === null) return "";
+  return leaf.slice(span.start, span.end);
+}
+function replaceInString(text, start, end, replacement) {
+  return text.slice(0, start) + replacement + text.slice(end);
+}
+async function applyActions(input, items, ctx) {
+  const collapsed = collapseOverlaps(items);
+  const blocks = collapsed.filter((i) => i.action === "block");
+  if (blocks.length > 0 && ctx.applyBlockAs !== "mask") {
+    const decisions2 = blocks.map((b) => ({ ...b.decision, action: "block" }));
+    const first = decisions2[0];
+    throw new PolicyViolationError(
+      `policy blocked entity "${first.entity}" via rule "${first.rule}"`,
+      decisions2
+    );
+  }
+  const reviews = collapsed.filter((i) => i.action === "review");
+  if (reviews.length > 0) {
+    throw new PolicyViolationError(
+      `policy review is not implemented (rule "${reviews[0].decision.rule}")`,
+      reviews.map((r) => r.decision)
+    );
+  }
+  const workflowKey = await deriveWorkflowKey(ctx.masterKey, ctx.workflowId);
+  let output = typeof input === "string" ? input : cloneJson(input);
+  const byPath = /* @__PURE__ */ new Map();
+  for (const item of collapsed) {
+    const path = item.span.path ?? "";
+    const list = byPath.get(path) ?? [];
+    list.push(item);
+    byPath.set(path, list);
+  }
+  const decisions = [];
+  for (const [path, group] of byPath) {
+    group.sort((a, b) => b.span.start - a.span.start);
+    let leaf;
+    if (typeof output === "string") {
+      leaf = output;
+    } else {
+      leaf = getStringAtPointer(output, path) ?? "";
+    }
+    for (const item of group) {
+      const resolvedAction = item.action;
+      const action = resolvedAction === "block" && ctx.applyBlockAs === "mask" ? "mask" : resolvedAction;
+      const value = item.value || extractValue(input, item.span);
+      let replacement = value;
+      if (action === "mask") {
+        replacement = maskLabel(item.span.entity);
+      } else if (action === "tokenize") {
+        const normalized = normalizeValue(item.span.entity, value);
+        const tokenId = await deriveTokenId(workflowKey, item.span.entity, normalized);
+        const token = formatToken(item.span.entity, tokenId, item.format, value);
+        await ctx.vault.put({
+          workflowId: ctx.workflowId,
+          token,
+          entity: item.span.entity,
+          value
+        });
+        replacement = token;
+      } else if (action === "allow" || action === "detokenize") {
+        replacement = value;
+      }
+      leaf = replaceInString(leaf, item.span.start, item.span.end, replacement);
+      const decision = resolvedAction === "block" && ctx.applyBlockAs === "mask" ? { ...item.decision, action: "block", appliedAs: "mask" } : item.decision;
+      decisions.push(decision);
+    }
+    if (typeof output === "string") {
+      output = leaf;
+    } else {
+      setStringAtPointer(output, path, leaf);
+    }
+  }
+  decisions.sort((a, b) => a.span.start - b.span.start || a.span.path.localeCompare(b.span.path));
+  return { output, decisions };
+}
+
+// src/actions/restore.ts
+function findTokensInLeaf(leaf, path) {
+  const hits = [];
+  LABEL_RE.lastIndex = 0;
+  for (const m of leaf.matchAll(LABEL_RE)) {
+    const full = m[0];
+    const label = m[1];
+    const idx = m.index ?? 0;
+    hits.push({
+      start: idx,
+      end: idx + full.length,
+      token: full,
+      entity: label.toLowerCase(),
+      path
+    });
+  }
+  FPE_EMAIL_RE.lastIndex = 0;
+  for (const m of leaf.matchAll(FPE_EMAIL_RE)) {
+    const full = m[0];
+    const idx = m.index ?? 0;
+    hits.push({
+      start: idx,
+      end: idx + full.length,
+      token: full,
+      entity: "email",
+      path
+    });
+  }
+  FPE_PHONE_RE.lastIndex = 0;
+  for (const m of leaf.matchAll(FPE_PHONE_RE)) {
+    const full = m[0];
+    const idx = m.index ?? 0;
+    hits.push({
+      start: idx,
+      end: idx + full.length,
+      token: full,
+      entity: "phone",
+      path
+    });
+  }
+  FPE_CARD_RE.lastIndex = 0;
+  for (const m of leaf.matchAll(FPE_CARD_RE)) {
+    const full = m[0];
+    const idx = m.index ?? 0;
+    hits.push({
+      start: idx,
+      end: idx + full.length,
+      token: full,
+      entity: "credit_card",
+      path
+    });
+  }
+  hits.sort((a, b) => a.start - b.start || b.end - a.end);
+  const deduped = [];
+  for (const hit of hits) {
+    const overlap = deduped.some((d) => hit.start < d.end && hit.end > d.start);
+    if (!overlap) deduped.push(hit);
+  }
+  return deduped;
+}
+function collectLeaves(input) {
+  if (typeof input === "string") {
+    return [{ path: "", text: input }];
+  }
+  const out = [];
+  const walk = (value, path) => {
+    if (typeof value === "string") {
+      out.push({ path, text: value });
+      return;
+    }
+    if (value === null || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) walk(value[i], `${path}/${i}`);
+      return;
+    }
+    for (const [k, v] of Object.entries(value)) {
+      const esc = k.replace(/~/g, "~0").replace(/\//g, "~1");
+      walk(v, `${path}/${esc}`);
+    }
+  };
+  walk(input, "");
+  return out;
+}
+async function restoreInput(input, ctx) {
+  const key = boundaryKey(ctx.boundary);
+  if (!isEgressBoundaryKey(key) || ctx.boundary.kind !== "egress") {
+    throw new InvariantViolationError("restore is only allowed at egress boundaries");
+  }
+  let output = typeof input === "string" ? input : cloneJson(input);
+  const decisions = [];
+  const leaves = collectLeaves(input);
+  for (const leaf of leaves) {
+    const hits = findTokensInLeaf(leaf.text, leaf.path);
+    hits.sort((a, b) => b.start - a.start);
+    let text = typeof output === "string" ? output : getStringAtPointer(output, leaf.path) ?? leaf.text;
+    for (const hit of hits) {
+      const record = await ctx.vault.get(ctx.workflowId, hit.token);
+      const contentHash = await sha256Hex(hit.token);
+      if (record === null) {
+        decisions.push({
+          action: "restore_miss",
+          entity: hit.entity,
+          boundary: ctx.boundary,
+          identity: ctx.identity,
+          rule: "restore",
+          span: { path: hit.path, start: hit.start, end: hit.end },
+          contentHash
+        });
+        continue;
+      }
+      text = text.slice(0, hit.start) + record.value + text.slice(hit.end);
+      decisions.push({
+        action: "detokenize",
+        entity: record.entity,
+        boundary: ctx.boundary,
+        identity: ctx.identity,
+        rule: "restore",
+        span: { path: hit.path, start: hit.start, end: hit.end },
+        contentHash
+      });
+    }
+    if (typeof output === "string") {
+      output = text;
+    } else {
+      setStringAtPointer(output, leaf.path, text);
+    }
+  }
+  decisions.sort((a, b) => a.span.start - b.span.start || a.span.path.localeCompare(b.span.path));
+  return { output, decisions };
+}
+
+// src/actions/stream-cut.ts
+function computeStreamEmitEnd(length, spans, holdback, final) {
+  if (final) return length;
+  if (length <= holdback) return 0;
+  let cut = length - holdback;
+  for (const span of spans) {
+    if (span.start < cut && span.end > cut) {
+      cut = Math.min(cut, span.start);
+    }
+  }
+  return Math.max(0, cut);
+}
+
+// src/audit/emitter.ts
+function warnSinkFailure(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  getConsole()?.warn(`[tailrace] audit sink failed (swallowed): ${message}`);
+}
+function createAuditEmitter(sinks = [], onDecision) {
+  return {
+    emit(type, workflowId, decisions) {
+      if (onDecision !== void 0) {
+        try {
+          onDecision(decisions);
+        } catch (err) {
+          warnSinkFailure(err);
+        }
+      }
+      if (sinks.length === 0) return;
+      const event = {
+        type,
+        workflowId,
+        timestamp: Date.now(),
+        decisions
+      };
+      for (const sink of sinks) {
+        try {
+          const result = sink.emit(event);
+          if (result !== void 0 && typeof result.then === "function") {
+            void result.catch((err) => {
+              warnSinkFailure(err);
+            });
+          }
+        } catch (err) {
+          warnSinkFailure(err);
+        }
+      }
+    }
+  };
+}
+
+// src/detect/merge.ts
+var DEFAULT_THRESHOLD = 0.6;
+function mergeSpans(spans, opts = {}) {
+  const defaultThreshold = opts.defaultThreshold ?? DEFAULT_THRESHOLD;
+  const thresholds = opts.thresholds ?? {};
+  const thresholdFor = (entity) => thresholds[entity] ?? defaultThreshold;
+  const byEntity = /* @__PURE__ */ new Map();
+  for (const span of spans) {
+    if (span.confidence < thresholdFor(span.entity)) continue;
+    const group = byEntity.get(span.entity);
+    if (group) group.push(span);
+    else byEntity.set(span.entity, [span]);
+  }
+  const out = [];
+  for (const group of byEntity.values()) {
+    group.sort((a, b) => a.start - b.start || a.end - b.end);
+    let current = group[0];
+    for (let i = 1; i < group.length; i++) {
+      const span = group[i];
+      if (span.start < current.end) {
+        current = {
+          ...current,
+          end: Math.max(current.end, span.end),
+          confidence: Math.max(current.confidence, span.confidence)
+        };
+      } else {
+        out.push(current);
+        current = span;
+      }
+    }
+    out.push(current);
+  }
+  out.sort((a, b) => a.start - b.start || a.end - b.end);
+  return out;
+}
+
+// src/detect/object-scan.ts
+var DEFAULT_MAX_DEPTH = 32;
+function escapePointer(key) {
+  return key.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function scanObject(input, scanLeaf, maxDepth = DEFAULT_MAX_DEPTH) {
+  const out = [];
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (value, path, depth) => {
+    if (typeof value === "string") {
+      for (const span of scanLeaf(value)) out.push({ ...span, path });
+      return;
+    }
+    if (value === null || typeof value !== "object") return;
+    if (seen.has(value)) return;
+    if (depth >= maxDepth) return;
+    seen.add(value);
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        walk(value[i], `${path}/${i}`, depth + 1);
+      }
+    } else {
+      for (const [key, child] of Object.entries(value)) {
+        const childPath = `${path}/${escapePointer(key)}`;
+        for (const span of scanLeaf(key)) out.push({ ...span, path: childPath });
+        walk(child, childPath, depth + 1);
+      }
+    }
+  };
+  walk(input, "", 0);
+  return out;
+}
+
+// src/detect/primitives.ts
+function shannonEntropy(s) {
+  if (s.length === 0) return 0;
+  const counts = /* @__PURE__ */ new Map();
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    counts.set(ch, (counts.get(ch) ?? 0) + 1);
+  }
+  let entropy = 0;
+  for (const c of counts.values()) {
+    const p = c / s.length;
+    entropy -= p * Math.log2(p);
+  }
+  return entropy;
+}
+function hasBase62Charset(s) {
+  let lower = false;
+  let upper = false;
+  let digit = false;
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    if (code >= 97 && code <= 122) lower = true;
+    else if (code >= 65 && code <= 90) upper = true;
+    else if (code >= 48 && code <= 57) digit = true;
+  }
+  return lower && upper && digit;
+}
+function luhnValid(digits) {
+  if (digits.length === 0) return false;
+  let sum = 0;
+  let double = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let d = digits.charCodeAt(i) - 48;
+    if (d < 0 || d > 9) return false;
+    if (double) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+    double = !double;
+  }
+  return sum % 10 === 0;
+}
+function ibanValid(iban) {
+  const compact = iban.replace(/\s+/g, "").toUpperCase();
+  if (!/^[A-Z]{2}[0-9]{2}[A-Z0-9]{10,30}$/.test(compact)) return false;
+  const rearranged = compact.slice(4) + compact.slice(0, 4);
+  let remainder = 0;
+  for (let i = 0; i < rearranged.length; i++) {
+    const code = rearranged.charCodeAt(i);
+    const chunk = code >= 65 ? (code - 55).toString() : String.fromCharCode(code);
+    for (let j = 0; j < chunk.length; j++) {
+      remainder = (remainder * 10 + (chunk.charCodeAt(j) - 48)) % 97;
+    }
+  }
+  return remainder === 1;
+}
+function decodeBase64UrlJson(segment) {
+  try {
+    const b64 = segment.replace(/-/g, "+").replace(/_/g, "/");
+    const pad = b64.length % 4 === 0 ? "" : "=".repeat(4 - b64.length % 4);
+    const json = atob(b64 + pad);
+    const parsed = JSON.parse(json);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function isJwtHeader(header) {
+  const alg = header["alg"];
+  if (typeof alg !== "string" || alg.length === 0) return false;
+  const typ = header["typ"];
+  if (typ !== void 0 && typeof typ === "string" && typ.toUpperCase() !== "JWT") return false;
+  return true;
+}
+function parseIpv4(s) {
+  const parts = s.split(".");
+  if (parts.length !== 4) return null;
+  const octets = [];
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part)) return null;
+    const n = Number(part);
+    if (n > 255) return null;
+    if (part.length > 1 && part[0] === "0") return null;
+    octets.push(n);
+  }
+  return [octets[0], octets[1], octets[2], octets[3]];
+}
+function isPrivateOrReservedIpv4(octets) {
+  const [a, b] = octets;
+  if (a === 10) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a === 0) return true;
+  if (a === 192 && b === 0 && octets[2] === 2) return true;
+  if (a === 198 && (b === 18 || b === 19)) return true;
+  if (a === 198 && b === 51 && octets[2] === 100) return true;
+  if (a === 203 && b === 0 && octets[2] === 113) return true;
+  if (a >= 224) return true;
+  return false;
+}
+function isPrivateOrReservedIpv6(address) {
+  const addr = address.toLowerCase();
+  if (addr === "::1" || addr === "::") return true;
+  if (addr.startsWith("fe8") || addr.startsWith("fe9") || addr.startsWith("fea") || addr.startsWith("feb"))
+    return true;
+  if (addr.startsWith("fc") || addr.startsWith("fd")) return true;
+  if (addr.startsWith("2001:db8")) return true;
+  if (addr.startsWith("ff")) return true;
+  return false;
+}
+
+// src/detect/recognizers/shared.ts
+function scanPatterns(text, patterns, entity, recognizer) {
+  const spans = [];
+  for (const { re, confidence } of patterns) {
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      spans.push({ entity, start: m.index, end: m.index + m[0].length, confidence, recognizer });
+      if (m[0].length === 0) re.lastIndex++;
+    }
+  }
+  return spans;
+}
+
+// src/detect/recognizers/pii.ts
+var EMAIL_PATTERNS = [
+  // TLD length >= 2 is enforced by the `{2,}` (docs/detection.md §2).
+  { re: /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g, confidence: 1 }
+];
+var emailRecognizer = {
+  id: "email",
+  entities: ["email"],
+  tier: 0,
+  scan: (text) => scanPatterns(text, EMAIL_PATTERNS, "email", "email")
+};
+var PHONE_PATTERNS = [
+  // E.164 / international with a `+` country prefix -> confidence 1.0.
+  {
+    re: /(?<![\w+])\+\d{1,3}[\s.-]?\(?\d{1,4}\)?(?:[\s.-]?\d{2,4}){1,4}(?![\w])/g,
+    confidence: 1
+  },
+  // Grouped national format with separators -> confidence 0.8. Requires separators so we
+  // don't match bare digit runs like order numbers.
+  {
+    re: /(?<![\w+])\(?\d{2,4}\)?[\s.-]\d{2,4}[\s.-]\d{2,4}(?:[\s.-]\d{2,4})?(?![\w])/g,
+    confidence: 0.8
+  }
+];
+function digitCount(s) {
+  let n = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c >= 48 && c <= 57) n++;
+  }
+  return n;
+}
+var phoneRecognizer = {
+  id: "phone",
+  entities: ["phone"],
+  tier: 0,
+  scan: (text) => {
+    const spans = scanPatterns(text, PHONE_PATTERNS, "phone", "phone");
+    return spans.filter((s) => {
+      const digits = digitCount(text.slice(s.start, s.end));
+      return digits >= 7 && digits <= 15;
+    });
+  }
+};
+var CREDIT_CARD_RE = /(?<![\d.])\d(?:[ -]?\d){12,18}(?![\d.])/g;
+var creditCardRecognizer = {
+  id: "credit_card",
+  entities: ["credit_card"],
+  tier: 0,
+  scan: (text) => {
+    const spans = [];
+    CREDIT_CARD_RE.lastIndex = 0;
+    let m;
+    while ((m = CREDIT_CARD_RE.exec(text)) !== null) {
+      const digits = m[0].replace(/[^\d]/g, "");
+      if (digits.length < 13 || digits.length > 19) continue;
+      if (!luhnValid(digits)) continue;
+      spans.push({
+        entity: "credit_card",
+        start: m.index,
+        end: m.index + m[0].length,
+        confidence: 1,
+        recognizer: "credit_card"
+      });
+    }
+    return spans;
+  }
+};
+var IBAN_RE = /(?<![A-Za-z0-9])[A-Z]{2}\d{2}(?:\s?[A-Z0-9]){10,30}(?![A-Za-z0-9])/g;
+var ibanRecognizer = {
+  id: "iban",
+  entities: ["iban"],
+  tier: 0,
+  scan: (text) => {
+    const spans = [];
+    IBAN_RE.lastIndex = 0;
+    let m;
+    while ((m = IBAN_RE.exec(text)) !== null) {
+      const raw = m[0].trimEnd();
+      if (!ibanValid(raw)) continue;
+      spans.push({
+        entity: "iban",
+        start: m.index,
+        end: m.index + raw.length,
+        confidence: 1,
+        recognizer: "iban"
+      });
+    }
+    return spans;
+  }
+};
+var SSN_FORMATTED_RE = /(?<!\d)(\d{3})-(\d{2})-(\d{4})(?!\d)/g;
+var SSN_UNFORMATTED_RE = /(?<!\d)(\d{3})(\d{2})(\d{4})(?!\d)/g;
+var SSN_CONTEXT_RE = /ssn|social/gi;
+var SSN_CONTEXT_WINDOW = 30;
+function ssnPartsValid(area, group, serial) {
+  const a = Number(area);
+  if (a === 0 || a === 666 || a >= 900) return false;
+  if (Number(group) === 0) return false;
+  if (Number(serial) === 0) return false;
+  return true;
+}
+var ssnRecognizer = {
+  id: "ssn",
+  entities: ["ssn"],
+  tier: 0,
+  scan: (text) => {
+    const spans = [];
+    SSN_FORMATTED_RE.lastIndex = 0;
+    let m;
+    while ((m = SSN_FORMATTED_RE.exec(text)) !== null) {
+      if (!ssnPartsValid(m[1], m[2], m[3])) continue;
+      spans.push({
+        entity: "ssn",
+        start: m.index,
+        end: m.index + m[0].length,
+        confidence: 1,
+        recognizer: "ssn"
+      });
+    }
+    const contextEnds = [];
+    SSN_CONTEXT_RE.lastIndex = 0;
+    let c;
+    while ((c = SSN_CONTEXT_RE.exec(text)) !== null) contextEnds.push(c.index + c[0].length);
+    if (contextEnds.length > 0) {
+      SSN_UNFORMATTED_RE.lastIndex = 0;
+      while ((m = SSN_UNFORMATTED_RE.exec(text)) !== null) {
+        if (!ssnPartsValid(m[1], m[2], m[3])) continue;
+        const start = m.index;
+        const near = contextEnds.some((end) => start >= end && start - end <= SSN_CONTEXT_WINDOW);
+        if (!near) continue;
+        spans.push({
+          entity: "ssn",
+          start,
+          end: start + m[0].length,
+          confidence: 0.8,
+          recognizer: "ssn"
+        });
+      }
+    }
+    return spans;
+  }
+};
+var IPV4_RE = /(?<![\d.])\d{1,3}(?:\.\d{1,3}){3}(?![\d.])/g;
+var IPV6_RE = /(?<![:.\w])(?:(?:[A-Fa-f0-9]{1,4}:){7}[A-Fa-f0-9]{1,4}|(?:[A-Fa-f0-9]{1,4}:){1,7}:|(?:[A-Fa-f0-9]{1,4}:){1,6}:[A-Fa-f0-9]{1,4}|(?:[A-Fa-f0-9]{1,4}:){1,5}(?::[A-Fa-f0-9]{1,4}){1,2}|(?:[A-Fa-f0-9]{1,4}:){1,4}(?::[A-Fa-f0-9]{1,4}){1,3}|(?:[A-Fa-f0-9]{1,4}:){1,3}(?::[A-Fa-f0-9]{1,4}){1,4}|(?:[A-Fa-f0-9]{1,4}:){1,2}(?::[A-Fa-f0-9]{1,4}){1,5}|[A-Fa-f0-9]{1,4}:(?::[A-Fa-f0-9]{1,4}){1,6}|:(?:(?::[A-Fa-f0-9]{1,4}){1,7}|:)|::(?:ffff(?::0{1,4})?:)?(?:(?:25[0-5]|(?:2[0-4]|1?[0-9])?[0-9])\.){3}(?:25[0-5]|(?:2[0-4]|1?[0-9])?[0-9]))(?![:.\w])/g;
+function ipAddressRecognizer(includePrivateIps = false) {
+  return {
+    id: "ip_address",
+    entities: ["ip_address"],
+    tier: 0,
+    scan: (text) => {
+      const spans = [];
+      IPV4_RE.lastIndex = 0;
+      let m;
+      while ((m = IPV4_RE.exec(text)) !== null) {
+        const octets = parseIpv4(m[0]);
+        if (octets === null) continue;
+        if (!includePrivateIps && isPrivateOrReservedIpv4(octets)) continue;
+        spans.push({
+          entity: "ip_address",
+          start: m.index,
+          end: m.index + m[0].length,
+          confidence: 1,
+          recognizer: "ip_address"
+        });
+      }
+      IPV6_RE.lastIndex = 0;
+      while ((m = IPV6_RE.exec(text)) !== null) {
+        if (!includePrivateIps && isPrivateOrReservedIpv6(m[0])) continue;
+        spans.push({
+          entity: "ip_address",
+          start: m.index,
+          end: m.index + m[0].length,
+          confidence: 1,
+          recognizer: "ip_address"
+        });
+      }
+      return spans;
+    }
+  };
+}
+var URL_CREDENTIALS_PATTERNS = [
+  { re: /[a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^\s/:@]+:[^\s/@]+@[^\s"'<>]+/g, confidence: 1 }
+];
+var urlCredentialsRecognizer = {
+  id: "url_credentials",
+  entities: ["url_credentials"],
+  tier: 0,
+  scan: (text) => scanPatterns(text, URL_CREDENTIALS_PATTERNS, "url_credentials", "url_credentials")
+};
+var STATIC_PII_RECOGNIZERS = [
+  emailRecognizer,
+  phoneRecognizer,
+  creditCardRecognizer,
+  ibanRecognizer,
+  ssnRecognizer,
+  urlCredentialsRecognizer
+];
+
+// src/detect/recognizers/secrets.ts
+var API_KEY_PATTERNS = [
+  { re: /sk-ant-[A-Za-z0-9_-]{20,}/g, confidence: 1 },
+  // Anthropic
+  { re: /sk-[A-Za-z0-9]{20,}/g, confidence: 1 },
+  // OpenAI (legacy)
+  { re: /sk_(?:live|test)_[0-9A-Za-z]{16,}/g, confidence: 1 },
+  // Stripe secret
+  { re: /pk_(?:live|test)_[0-9A-Za-z]{16,}/g, confidence: 0.8 },
+  // Stripe publishable (low-confidence)
+  { re: /gh[opsur]_[A-Za-z0-9]{36,}/g, confidence: 1 },
+  // GitHub token
+  { re: /github_pat_[A-Za-z0-9_]{22,}/g, confidence: 1 },
+  // GitHub fine-grained PAT
+  { re: /AKIA[0-9A-Z]{16}/g, confidence: 1 },
+  // AWS access key id
+  { re: /xox[bpars]-[A-Za-z0-9-]{10,}/g, confidence: 1 },
+  // Slack
+  { re: /AIza[0-9A-Za-z_-]{35}/g, confidence: 1 },
+  // Google
+  { re: /SG\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}/g, confidence: 1 },
+  // SendGrid
+  { re: /key-[0-9a-zA-Z]{32}/g, confidence: 0.8 },
+  // Mailgun
+  { re: /glpat-[A-Za-z0-9_-]{20}/g, confidence: 1 },
+  // GitLab
+  { re: /npm_[A-Za-z0-9]{36}/g, confidence: 1 },
+  // npm
+  { re: /dop_v1_[0-9a-f]{64}/g, confidence: 1 }
+  // DigitalOcean
+];
+var apiKeyRecognizer = {
+  id: "api_key",
+  entities: ["api_key"],
+  tier: 0,
+  scan: (text) => scanPatterns(text, API_KEY_PATTERNS, "api_key", "api_key")
+};
+var JWT_RE = /eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
+var jwtRecognizer = {
+  id: "jwt",
+  entities: ["jwt"],
+  tier: 0,
+  scan: (text) => {
+    const spans = [];
+    JWT_RE.lastIndex = 0;
+    let m;
+    while ((m = JWT_RE.exec(text)) !== null) {
+      const header = decodeBase64UrlJson(m[0].slice(0, m[0].indexOf(".")));
+      if (header !== null && isJwtHeader(header)) {
+        spans.push({
+          entity: "jwt",
+          start: m.index,
+          end: m.index + m[0].length,
+          confidence: 1,
+          recognizer: "jwt"
+        });
+      }
+    }
+    return spans;
+  }
+};
+var PEM_PATTERNS = [
+  {
+    re: /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----(?:[\s\S]*?-----END (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----)?/g,
+    confidence: 1
+  }
+];
+var privateKeyRecognizer = {
+  id: "private_key",
+  entities: ["private_key"],
+  tier: 0,
+  scan: (text) => scanPatterns(text, PEM_PATTERNS, "private_key", "private_key")
+};
+var TOKEN_RE = /[A-Za-z0-9+/_-]{20,64}/g;
+var KEYWORD_RE = /(?:secret|token|password|passwd|pwd|api[_-]?key|apikey|auth|credential|bearer)/gi;
+var ASSIGN_QUOTED_RE = /[=:]\s*["'`]([A-Za-z0-9+/=_-]{20,64})["'`]/g;
+var ENTROPY_THRESHOLD = 4;
+var KEYWORD_WINDOW = 40;
+var highEntropySecretRecognizer = {
+  id: "high_entropy_secret",
+  entities: ["high_entropy_secret"],
+  tier: 0,
+  scan: (text) => {
+    const spans = [];
+    const keywordEnds = [];
+    KEYWORD_RE.lastIndex = 0;
+    let k;
+    while ((k = KEYWORD_RE.exec(text)) !== null) keywordEnds.push(k.index + k[0].length);
+    const quotedStarts = /* @__PURE__ */ new Set();
+    ASSIGN_QUOTED_RE.lastIndex = 0;
+    let q;
+    while ((q = ASSIGN_QUOTED_RE.exec(text)) !== null) {
+      quotedStarts.add(q.index + q[0].indexOf(q[1]));
+    }
+    TOKEN_RE.lastIndex = 0;
+    let m;
+    while ((m = TOKEN_RE.exec(text)) !== null) {
+      const tok = m[0];
+      if (!hasBase62Charset(tok)) continue;
+      if (shannonEntropy(tok) <= ENTROPY_THRESHOLD) continue;
+      const start = m.index;
+      const nearKeyword = keywordEnds.some((end) => start >= end && start - end <= KEYWORD_WINDOW);
+      if (!nearKeyword && !quotedStarts.has(start)) continue;
+      spans.push({
+        entity: "high_entropy_secret",
+        start,
+        end: start + tok.length,
+        confidence: 0.8,
+        recognizer: "high_entropy_secret"
+      });
+    }
+    return spans;
+  }
+};
+var CONNECTION_STRING_PATTERNS = [
+  {
+    // URI schemes with user:pass@ userinfo.
+    re: /(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|rediss?|amqp):\/\/[^\s:@/]+:[^\s@/]+@[^\s"'<>]+/gi,
+    confidence: 1
+  },
+  {
+    // ADO-style "Server=...;Password=...;".
+    re: /(?:Server|Data Source)=[^;]+;(?:[^;]*;)*?\s*Password=[^;\s"']+/gi,
+    confidence: 1
+  }
+];
+var connectionStringRecognizer = {
+  id: "connection_string",
+  entities: ["connection_string"],
+  tier: 0,
+  scan: (text) => scanPatterns(text, CONNECTION_STRING_PATTERNS, "connection_string", "connection_string")
+};
+var SECRET_RECOGNIZERS = [
+  apiKeyRecognizer,
+  jwtRecognizer,
+  privateKeyRecognizer,
+  highEntropySecretRecognizer,
+  connectionStringRecognizer
+];
+
+// src/detect/recognizers/index.ts
+function builtinRecognizers(opts = {}) {
+  return [
+    ...SECRET_RECOGNIZERS,
+    ...STATIC_PII_RECOGNIZERS,
+    ipAddressRecognizer(opts.includePrivateIps ?? false)
+  ];
+}
+
+// src/detect/engine.ts
+function createDetectionEngine(opts = {}) {
+  const recognizers = [
+    ...opts.useBuiltins === false ? [] : builtinRecognizers({ includePrivateIps: opts.includePrivateIps ?? false }),
+    ...opts.recognizers ?? []
+  ];
+  const mergeOpts = {
+    ...opts.thresholds !== void 0 ? { thresholds: opts.thresholds } : {},
+    ...opts.defaultThreshold !== void 0 ? { defaultThreshold: opts.defaultThreshold } : {}
+  };
+  const runRecognizers = (text) => {
+    const spans = [];
+    for (const recognizer of recognizers) {
+      const result = recognizer.scan(text);
+      if (result instanceof Promise) {
+        throw new NotImplementedError(
+          "async (Tier 1) recognizers are wired in a later milestone; Tier 0 detection is synchronous"
+        );
+      }
+      for (const span of result) spans.push(span);
+    }
+    return spans;
+  };
+  const scanLeaf = (text) => mergeSpans(runRecognizers(text), mergeOpts);
+  const detect = (input) => typeof input === "string" ? scanLeaf(input) : scanObject(input, scanLeaf);
+  return { recognizers, detect };
+}
+
+// src/policy/normalize.ts
+function normalizeRule(value) {
+  if (typeof value === "string") {
+    return { action: value };
+  }
+  return {
+    action: value.action,
+    ...value.format !== void 0 ? { format: value.format } : {},
+    ...value.dangerouslyAllowSecrets !== void 0 ? { dangerouslyAllowSecrets: value.dangerouslyAllowSecrets } : {}
+  };
+}
+
+// src/policy/validate.ts
+var VALID_ACTIONS = /* @__PURE__ */ new Set([
+  "allow",
+  "mask",
+  "tokenize",
+  "block",
+  "review",
+  "detokenize"
+]);
+function assertAction(action, path, underEgress) {
+  if (!VALID_ACTIONS.has(action)) {
+    throw new PolicyValidationError(`unknown action "${String(action)}"`, path);
+  }
+  if (action === "review") {
+    throw new NotImplementedError("review action ships in v0.2");
+  }
+  if (action === "detokenize" && !underEgress) {
+    throw new PolicyValidationError("detokenize is only valid under egress boundary keys", path);
+  }
+}
+function validateRuleValue(value, path, underEgress) {
+  const rule = normalizeRule(value);
+  assertAction(rule.action, `${path}.action`, underEgress);
+  if (rule.format !== void 0 && rule.format !== "preserve" && rule.format !== "label") {
+    throw new PolicyValidationError(`unknown format "${String(rule.format)}"`, `${path}.format`);
+  }
+}
+function validateEntities(entities, path, underEgress) {
+  if (entities === void 0) return;
+  for (const [entity, value] of Object.entries(entities)) {
+    if (value === void 0) continue;
+    validateRuleValue(value, `${path}.${entity}`, underEgress);
+  }
+}
+function validateScope(scope, path) {
+  validateEntities(scope.entities, `${path}.entities`, false);
+  if (scope.boundaries === void 0) return;
+  for (const [key, body] of Object.entries(scope.boundaries)) {
+    const underEgress = isEgressBoundaryKey(key);
+    validateEntities(body?.entities, `${path}.boundaries.${key}.entities`, underEgress);
+  }
+}
+function validatePolicy(doc) {
+  if (doc.defaults?.action !== void 0) {
+    assertAction(doc.defaults.action, "defaults.action", false);
+  }
+  validateScope(doc, "");
+  if (doc.identities === void 0) return;
+  for (const [agent, scope] of Object.entries(doc.identities)) {
+    validateScope(scope, `identities.${agent}`);
+  }
+}
+
+// src/policy/compile.ts
+function compileEntities(entities) {
+  const map = /* @__PURE__ */ new Map();
+  if (entities === void 0) return map;
+  for (const [key, value] of Object.entries(entities)) {
+    if (value === void 0) continue;
+    map.set(key, normalizeRule(value));
+  }
+  return map;
+}
+function compileBoundaries(boundaries) {
+  const compiled = [];
+  if (boundaries === void 0) {
+    return { boundaries: compiled, boundaryPatterns: [] };
+  }
+  for (const [pattern, body] of Object.entries(boundaries)) {
+    compiled.push({
+      pattern,
+      entities: compileEntities(body?.entities)
+    });
+  }
+  compiled.sort((a, b) => {
+    const aGlob = a.pattern.includes("*") ? 1 : 0;
+    const bGlob = b.pattern.includes("*") ? 1 : 0;
+    if (aGlob !== bGlob) return aGlob - bGlob;
+    return b.pattern.length - a.pattern.length;
+  });
+  return {
+    boundaries: compiled,
+    boundaryPatterns: compiled.map((b) => b.pattern)
+  };
+}
+function compileScope(scope) {
+  const entities = compileEntities(scope.entities);
+  const { boundaries, boundaryPatterns } = compileBoundaries(scope.boundaries);
+  return { entities, boundaries, boundaryPatterns };
+}
+function warnUnsupportedPreserve(entities, path) {
+  for (const [entity, rule] of entities) {
+    if (rule.format !== "preserve") continue;
+    if (FORMAT_PRESERVE_ENTITIES.has(entity)) continue;
+    getConsole()?.warn(
+      `[tailrace] format: "preserve" is not supported for entity "${entity}" at ${path}.${entity}; falling back to label token`
+    );
+  }
+}
+function warnPreserveFallbacks(compiled) {
+  warnUnsupportedPreserve(compiled.entities, "entities");
+  for (const boundary of compiled.boundaries) {
+    warnUnsupportedPreserve(boundary.entities, `boundaries.${boundary.pattern}.entities`);
+  }
+  for (const [agent, ident] of compiled.identities) {
+    warnUnsupportedPreserve(ident.entities, `identities.${agent}.entities`);
+    for (const boundary of ident.boundaries) {
+      warnUnsupportedPreserve(
+        boundary.entities,
+        `identities.${agent}.boundaries.${boundary.pattern}.entities`
+      );
+    }
+  }
+}
+function compilePolicy(doc) {
+  validatePolicy(doc);
+  const { boundaries, boundaryPatterns } = compileBoundaries(doc.boundaries);
+  const identities = /* @__PURE__ */ new Map();
+  if (doc.identities !== void 0) {
+    for (const [agent, scope] of Object.entries(doc.identities)) {
+      identities.set(agent, compileScope(scope));
+    }
+  }
+  const compiled = {
+    defaultsAction: doc.defaults?.action ?? "allow",
+    dangerouslyAllowSecrets: doc.dangerouslyAllowSecrets === true,
+    entities: compileEntities(doc.entities),
+    boundaries,
+    boundaryPatterns,
+    identities
+  };
+  warnPreserveFallbacks(compiled);
+  return compiled;
+}
+
+// src/policy/default.ts
+var DEFAULT_TOKENIZE_PII = [
+  "email",
+  "phone",
+  "credit_card",
+  "iban",
+  "ssn"
+];
+function defaultPolicy() {
+  const entities = {};
+  for (const entity of SECRET_ENTITY_CLASSES) {
+    entities[entity] = "block";
+  }
+  for (const entity of DEFAULT_TOKENIZE_PII) {
+    entities[entity] = "tokenize";
+  }
+  entities.url_credentials = "block";
+  return {
+    defaults: { action: "allow" },
+    entities,
+    boundaries: {
+      "egress:*": { entities: { "*": "detokenize" } }
+    }
+  };
+}
+
+// src/vault/keys.ts
+var vaultKeys = /* @__PURE__ */ new WeakMap();
+function registerVaultKey(vault, masterKey) {
+  vaultKeys.set(vault, masterKey);
+}
+function getVaultKey(vault) {
+  return vaultKeys.get(vault);
+}
+
+// src/vault/shared.ts
+function storageKey(workflowId, token) {
+  return `tailrace:v1:${workflowId}:${token}`;
+}
+async function encodeRecord(masterKey, record, expiresAt) {
+  const ciphertext = await encryptAtRest(masterKey, record.value);
+  const encoded = {
+    entity: record.entity,
+    ciphertext,
+    ...expiresAt !== void 0 ? { expiresAt } : {}
+  };
+  return JSON.stringify(encoded);
+}
+async function decodeRecord(masterKey, raw, now = Date.now()) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new VaultError("corrupt vault record");
+  }
+  if (parsed.expiresAt !== void 0 && parsed.expiresAt <= now) {
+    return null;
+  }
+  const value = await decryptAtRest(masterKey, parsed.ciphertext);
+  return {
+    value,
+    entity: parsed.entity,
+    ...parsed.expiresAt !== void 0 ? { expiresAt: parsed.expiresAt } : {}
+  };
+}
+function assertNoCollision(existing, value, token) {
+  if (existing !== null && existing.value !== value) {
+    throw new VaultError(`token collision for ${token}`);
+  }
+}
+
+// src/vault/memory.ts
+var DEFAULT_TTL_SECONDS = 86400;
+function memoryVault(opts) {
+  const masterKey = resolveMasterKey(opts?.key);
+  const ttlSeconds = opts?.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+  const store = /* @__PURE__ */ new Map();
+  const sweep = (now) => {
+    for (const [key, entry] of store) {
+      if (entry.expiresAt !== void 0 && entry.expiresAt <= now) {
+        store.delete(key);
+      }
+    }
+  };
+  const vault = {
+    async put(input) {
+      const now = Date.now();
+      sweep(now);
+      const key = storageKey(input.workflowId, input.token);
+      const existingRaw = store.get(key);
+      if (existingRaw !== void 0) {
+        const existing = await decodeRecord(masterKey, existingRaw.raw, now);
+        assertNoCollision(existing, input.value, input.token);
+        if (existing !== null) return;
+      }
+      const expiresAt = input.expiresAt ?? (ttlSeconds > 0 ? now + ttlSeconds * 1e3 : void 0);
+      const raw = await encodeRecord(
+        masterKey,
+        { value: input.value, entity: input.entity },
+        expiresAt
+      );
+      store.set(key, {
+        raw,
+        ...expiresAt !== void 0 ? { expiresAt } : {}
+      });
+    },
+    async get(workflowId, token) {
+      const now = Date.now();
+      sweep(now);
+      const entry = store.get(storageKey(workflowId, token));
+      if (entry === void 0) return null;
+      const decoded = await decodeRecord(masterKey, entry.raw, now);
+      if (decoded === null) {
+        store.delete(storageKey(workflowId, token));
+        return null;
+      }
+      return { value: decoded.value, entity: decoded.entity };
+    },
+    async purge(workflowId) {
+      const prefix = `tailrace:v1:${workflowId}:`;
+      for (const key of store.keys()) {
+        if (key.startsWith(prefix)) store.delete(key);
+      }
+    }
+  };
+  registerVaultKey(vault, masterKey);
+  return vault;
+}
+
+// src/audit/sinks.ts
+function consoleSink() {
+  return {
+    emit(event) {
+      getConsole()?.log(JSON.stringify(event));
+    }
+  };
+}
+function jsonlSink(writer) {
+  return {
+    async emit(event) {
+      await writer.write(JSON.stringify(event) + "\n");
+    }
+  };
+}
+
+// src/vault/kv.ts
+var DEFAULT_TTL_SECONDS2 = 86400;
+function kvVault(kv, opts) {
+  const masterKey = resolveMasterKey(opts?.key);
+  const ttlSeconds = opts?.ttlSeconds ?? DEFAULT_TTL_SECONDS2;
+  const vault = {
+    async put(input) {
+      const key = storageKey(input.workflowId, input.token);
+      const existingRaw = await kv.get(key);
+      if (existingRaw !== null) {
+        const existing = await decodeRecord(masterKey, existingRaw);
+        assertNoCollision(existing, input.value, input.token);
+        if (existing !== null) return;
+      }
+      const now = Date.now();
+      const expiresAt = input.expiresAt ?? (ttlSeconds > 0 ? now + ttlSeconds * 1e3 : void 0);
+      const raw = await encodeRecord(
+        masterKey,
+        { value: input.value, entity: input.entity },
+        expiresAt
+      );
+      const putOpts = expiresAt !== void 0 ? { expirationTtl: Math.max(1, Math.ceil((expiresAt - now) / 1e3)) } : ttlSeconds > 0 ? { expirationTtl: ttlSeconds } : void 0;
+      if (putOpts !== void 0) {
+        await kv.put(key, raw, putOpts);
+      } else {
+        await kv.put(key, raw);
+      }
+    },
+    async get(workflowId, token) {
+      const raw = await kv.get(storageKey(workflowId, token));
+      if (raw === null) return null;
+      const decoded = await decodeRecord(masterKey, raw);
+      if (decoded === null) {
+        await kv.delete(storageKey(workflowId, token));
+        return null;
+      }
+      return { value: decoded.value, entity: decoded.entity };
+    },
+    async purge(workflowId) {
+    }
+  };
+  registerVaultKey(vault, masterKey);
+  return vault;
+}
+
+// src/index.ts
+function isVault(value) {
+  return typeof value.put === "function";
+}
+function isPolicySource(value) {
+  return typeof value.load === "function";
+}
+function extractSpanValue(input, span) {
+  if (typeof input === "string") {
+    return input.slice(span.start, span.end);
+  }
+  const path = span.path ?? "";
+  const leaf = getStringAtPointer(input, path);
+  if (leaf === null) return "";
+  return leaf.slice(span.start, span.end);
+}
+function resolveVault(options) {
+  if (options.vault === void 0) {
+    const vault2 = memoryVault();
+    return { vault: vault2, masterKey: getVaultKey(vault2) ?? resolveMasterKey() };
+  }
+  if (isVault(options.vault)) {
+    const vault2 = options.vault;
+    return { vault: vault2, masterKey: getVaultKey(vault2) ?? resolveMasterKey() };
+  }
+  const vault = memoryVault(options.vault);
+  return { vault, masterKey: getVaultKey(vault) ?? resolveMasterKey(options.vault.key) };
+}
+function createTailrace(options = {}) {
+  const engine = createDetectionEngine({
+    ...options.recognizers !== void 0 ? { recognizers: options.recognizers } : {},
+    ...options.includePrivateIps !== void 0 ? { includePrivateIps: options.includePrivateIps } : {}
+  });
+  const { vault, masterKey } = resolveVault(options);
+  const audit = createAuditEmitter(options.audit?.sinks ?? [], options.onDecision);
+  let compiled = null;
+  let unsubscribe;
+  const loadAndCompile = async () => {
+    if (compiled !== null) return compiled;
+    let doc;
+    if (options.policy === void 0) {
+      doc = defaultPolicy();
+    } else if (isPolicySource(options.policy)) {
+      doc = await options.policy.load();
+      if (options.policy.subscribe !== void 0 && unsubscribe === void 0) {
+        unsubscribe = options.policy.subscribe((next) => {
+          compiled = compilePolicy(next);
+        });
+      }
+    } else {
+      doc = options.policy;
+    }
+    compiled = compilePolicy(doc);
+    return compiled;
+  };
+  const check = async (input, ctx, options2) => {
+    const workflowId = ctx.workflowId ?? "default";
+    const identity = {
+      agent: ctx.identity.agent || "default",
+      ...ctx.identity.claims !== void 0 ? { claims: ctx.identity.claims } : {}
+    };
+    const policy = await loadAndCompile();
+    const spans = engine.detect(input);
+    const items = [];
+    for (const span of spans) {
+      const value = extractSpanValue(input, span);
+      const resolved = resolve(policy, span.entity, ctx.boundary, identity);
+      const contentHash = await sha256Hex(value);
+      const decision = {
+        action: resolved.action,
+        entity: span.entity,
+        boundary: ctx.boundary,
+        identity,
+        rule: resolved.rule,
+        span: {
+          path: span.path ?? "",
+          start: span.start,
+          end: span.end
+        },
+        contentHash
+      };
+      items.push({
+        span,
+        decision,
+        value,
+        ...resolved.format !== void 0 ? { format: resolved.format } : {}
+      });
+    }
+    const stream = options2?.stream;
+    const streamString = stream !== void 0 && typeof input === "string";
+    try {
+      if (streamString) {
+        const text = input;
+        const emitEnd = computeStreamEmitEnd(
+          text.length,
+          items.map((i) => i.span),
+          stream.holdback,
+          stream.final === true
+        );
+        if (options2?.applyBlockAs !== "mask") {
+          const blocks = items.filter((i) => i.decision.action === "block");
+          if (blocks.length > 0) {
+            const decisions3 = blocks.map((b) => ({ ...b.decision, action: "block" }));
+            const first = decisions3[0];
+            throw new PolicyViolationError(
+              `policy blocked entity "${first.entity}" via rule "${first.rule}"`,
+              decisions3
+            );
+          }
+        }
+        const toApply = items.filter((i) => i.span.end <= emitEnd);
+        const prefix = text.slice(0, emitEnd);
+        const remainder = text.slice(emitEnd);
+        if (prefix.length === 0) {
+          return { output: "", decisions: [], blocked: false, remainder };
+        }
+        const { output: output2, decisions: decisions2 } = await applyActions(prefix, toApply, {
+          vault,
+          masterKey,
+          workflowId,
+          ...options2?.applyBlockAs !== void 0 ? { applyBlockAs: options2.applyBlockAs } : {}
+        });
+        audit.emit("check", workflowId, decisions2);
+        return { output: output2, decisions: decisions2, blocked: false, remainder };
+      }
+      const { output, decisions } = await applyActions(input, items, {
+        vault,
+        masterKey,
+        workflowId,
+        ...options2?.applyBlockAs !== void 0 ? { applyBlockAs: options2.applyBlockAs } : {}
+      });
+      audit.emit("check", workflowId, decisions);
+      return { output, decisions, blocked: false };
+    } catch (err) {
+      if (err instanceof PolicyViolationError) {
+        audit.emit("check", workflowId, err.decisions);
+      }
+      throw err;
+    }
+  };
+  const restore = async (input, ctx) => {
+    const workflowId = ctx.workflowId ?? "default";
+    const identity = {
+      agent: ctx.identity.agent || "default",
+      ...ctx.identity.claims !== void 0 ? { claims: ctx.identity.claims } : {}
+    };
+    const { output, decisions } = await restoreInput(input, {
+      vault,
+      workflowId,
+      boundary: ctx.boundary,
+      identity
+    });
+    audit.emit("restore", workflowId, decisions);
+    return { output, decisions, blocked: false };
+  };
+  return { check, restore };
+}
+function definePolicy(doc) {
+  validatePolicy(doc);
+  return doc;
+}
+function defineRecognizer(recognizer) {
+  return recognizer;
+}
+function staticPolicy(doc) {
+  return { load: () => Promise.resolve(doc) };
+}
+
+export { InvariantViolationError, NER_ENTITY_CLASSES, NotImplementedError, PII_ENTITY_CLASSES, PolicyValidationError, PolicyViolationError, RecognizerError, SECRET_ENTITY_CLASSES, TailraceError, VaultError, consoleSink, createTailrace, definePolicy, defineRecognizer, jsonlSink, kvVault, memoryVault, staticPolicy };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map