@holoscript/core 8.0.7 → 8.0.9

package/dist/chunk-ET3AN4W3.js

@@ -0,0 +1,824 @@
+import { init_jsonLogic, matchesRule } from './chunk-JBQXZIWB.js';
+
+// src/policy/index.ts
+init_jsonLogic();
+
+// src/policy/blocklist.ts
+function normalizeText(input) {
+  let s = input.normalize("NFKD").toLowerCase();
+  s = s.replace(/[̀-ͯ]/g, "");
+  const leet = {
+    "0": "o",
+    "1": "i",
+    "3": "e",
+    "4": "a",
+    "5": "s",
+    "7": "t",
+    "@": "a",
+    $: "s"
+  };
+  s = s.replace(/[013457@$]/g, (c) => leet[c] ?? c);
+  s = s.replace(/[.\-_*|/\\]+/g, "");
+  s = s.replace(/\s+/g, " ").trim();
+  return s;
+}
+var PATTERN_CACHE = /* @__PURE__ */ new Map();
+var MAX_PATTERN_LENGTH = 512;
+function compile(pattern) {
+  if (PATTERN_CACHE.has(pattern)) return PATTERN_CACHE.get(pattern) ?? null;
+  let re = null;
+  if (pattern.length <= MAX_PATTERN_LENGTH) {
+    try {
+      re = new RegExp(pattern, "i");
+    } catch {
+      re = null;
+    }
+  }
+  PATTERN_CACHE.set(pattern, re);
+  return re;
+}
+function termHit(normalized, term) {
+  const t = normalizeText(term);
+  if (!t) return false;
+  return normalized === t || normalized.startsWith(t + " ") || normalized.endsWith(" " + t) || normalized.includes(" " + t + " ");
+}
+function matchBlocklist(text, entries) {
+  const normalized = normalizeText(text);
+  let best = null;
+  for (const entry of entries) {
+    let matched = false;
+    if (entry.terms) {
+      for (const term of entry.terms) {
+        if (termHit(normalized, term)) {
+          matched = true;
+          break;
+        }
+      }
+    }
+    if (!matched && entry.patterns) {
+      for (const pat of entry.patterns) {
+        const re = compile(pat);
+        if (re && (re.test(text) || re.test(normalized))) {
+          matched = true;
+          break;
+        }
+      }
+    }
+    if (!matched) continue;
+    const severity = entry.hardStop ? 1 : entry.severity ?? 0.95;
+    if (!best || severity > best.severity) {
+      best = {
+        category: entry.category,
+        severity,
+        source: "blocklist",
+        rationale: `Tier-0 blocklist match: ${entry.id}`,
+        entryId: entry.id,
+        hardStop: Boolean(entry.hardStop)
+      };
+    }
+  }
+  return best;
+}
+
+// src/policy/defaults.ts
+var HARD_STOP_CATEGORIES = ["csam", "sexual_minors", "terrorism"];
+var DEFAULT_BLOCKLIST = [
+  // ── Hard-stop categories — detectors supplied by external hash feeds ──────────
+  { id: "hs-csam", category: "csam", hardStop: true, patterns: [] },
+  { id: "hs-sexual-minors", category: "sexual_minors", hardStop: true, patterns: [] },
+  { id: "hs-terrorism", category: "terrorism", hardStop: true, patterns: [] },
+  // ── Conservative unambiguous instructional-harm patterns (backstop to Tier-2) ─
+  {
+    id: "weapons-build-explosive",
+    category: "weapons",
+    severity: 0.97,
+    patterns: ["\\bhow\\s+to\\s+(make|build|construct|assemble)\\s+(a\\s+)?(bomb|explosive|pipe\\s*bomb|ied)\\b"]
+  },
+  {
+    id: "malware-author",
+    category: "malware",
+    severity: 0.9,
+    patterns: ["\\b(write|generate|create)\\s+(me\\s+)?(a\\s+)?(ransomware|keylogger|computer\\s+virus|trojan)\\b"]
+  },
+  {
+    id: "self-harm-method",
+    category: "self_harm",
+    severity: 0.9,
+    patterns: ["\\bhow\\s+(can|do)\\s+i\\s+(kill\\s+myself|end\\s+my\\s+life|commit\\s+suicide)\\b"]
+  }
+];
+function jurisdictionBundle(region) {
+  const r = (region || "GLOBAL").toUpperCase();
+  switch (r) {
+    case "US":
+      return { region: "US", aiActTier: "minimal", dsaApplies: false, minAge: 13, disclosureRequired: false };
+    case "EU":
+    case "DE":
+    case "FR":
+    case "ES":
+    case "IT":
+    case "NL":
+    case "IE":
+      return { region: r, aiActTier: "limited", dsaApplies: true, minAge: 16, disclosureRequired: true };
+    case "GB":
+    case "UK":
+      return { region: "GB", aiActTier: "limited", dsaApplies: false, minAge: 13, disclosureRequired: true };
+    // ── Asia-Pacific ──────────────────────────────────────────────────────────
+    case "AU":
+      return { region: "AU", aiActTier: "minimal", dsaApplies: false, minAge: 13, disclosureRequired: false };
+    case "JP":
+      return { region: "JP", aiActTier: "minimal", dsaApplies: false, minAge: 13, disclosureRequired: true };
+    case "KR":
+      return { region: "KR", aiActTier: "limited", dsaApplies: false, minAge: 14, disclosureRequired: true };
+    case "SG":
+      return { region: "SG", aiActTier: "minimal", dsaApplies: false, minAge: 13, disclosureRequired: true };
+    case "IN":
+      return { region: "IN", aiActTier: "minimal", dsaApplies: false, minAge: 18, disclosureRequired: false };
+    // ── Americas ──────────────────────────────────────────────────────────────
+    case "CA":
+      return { region: "CA", aiActTier: "limited", dsaApplies: false, minAge: 13, disclosureRequired: true };
+    case "BR":
+      return { region: "BR", aiActTier: "limited", dsaApplies: true, minAge: 13, disclosureRequired: true };
+    case "GLOBAL":
+    default:
+      return { region: "GLOBAL", aiActTier: "limited", dsaApplies: true, minAge: 16, disclosureRequired: true };
+  }
+}
+var HARMFUL_FAMILY_CATEGORIES = [
+  "sexual",
+  "violence",
+  "weapons",
+  "illegal_goods",
+  "hate",
+  "harassment",
+  "malware",
+  "privacy"
+];
+var COMMON_RULES = [
+  {
+    id: "common-self-harm-escalate",
+    description: "Self-harm signals route to human/crisis escalation rather than a silent block.",
+    when: { "==": [{ var: "category" }, "self_harm"] },
+    action: "escalate",
+    category: "self_harm",
+    legalBasis: "duty-of-care / crisis-routing",
+    priority: 10
+  },
+  {
+    id: "common-illegal-high-block",
+    description: "Clearly-illegal, high-severity instructional content is blocked on every tier (including dev).",
+    when: {
+      and: [
+        { in: [{ var: "category" }, ["weapons", "illegal_goods"]] },
+        { ">=": [{ var: "severity" }, 0.85] }
+      ]
+    },
+    action: "block",
+    legalBasis: "illegal-conduct (universal)",
+    priority: 20
+  }
+];
+var FAMILY_RULES = [
+  {
+    id: "family-harmful-category-block",
+    description: "Family tier blocks every harmful content category outright, at any severity.",
+    when: {
+      and: [
+        { "==": [{ var: "tier" }, "family"] },
+        { in: [{ var: "category" }, HARMFUL_FAMILY_CATEGORIES] }
+      ]
+    },
+    action: "block",
+    legalBasis: "HoloLand family-safety policy (D.079)",
+    aiActArticle: "transparency/minors-protection",
+    priority: 5
+  },
+  {
+    id: "family-misinformation-flag",
+    description: "Family tier flags misinformation for review.",
+    when: {
+      and: [{ "==": [{ var: "tier" }, "family"] }, { "==": [{ var: "category" }, "misinformation"] }]
+    },
+    action: "flag",
+    category: "misinformation",
+    priority: 1
+  }
+];
+var TEEN_RULES = [
+  {
+    id: "teen-serious-block",
+    description: "Teen tier blocks serious-harm categories.",
+    when: {
+      and: [
+        { "==": [{ var: "tier" }, "teen"] },
+        { in: [{ var: "category" }, ["sexual", "weapons", "illegal_goods", "malware", "hate"]] }
+      ]
+    },
+    action: "block",
+    legalBasis: "minor-protection policy",
+    priority: 5
+  },
+  {
+    id: "teen-violence-harassment-flag",
+    description: "Teen tier flags violence/harassment above low severity.",
+    when: {
+      and: [
+        { "==": [{ var: "tier" }, "teen"] },
+        { in: [{ var: "category" }, ["violence", "harassment"]] },
+        { ">=": [{ var: "severity" }, 0.4] }
+      ]
+    },
+    action: "flag",
+    priority: 1
+  }
+];
+var GENERAL_RULES = [
+  {
+    id: "general-illegal-block",
+    description: "Block clearly illegal categories at moderate+ severity for general/adult tiers.",
+    when: {
+      and: [
+        { in: [{ var: "tier" }, ["general", "adult"]] },
+        { in: [{ var: "category" }, ["weapons", "illegal_goods", "malware"]] },
+        { ">=": [{ var: "severity" }, 0.5] }
+      ]
+    },
+    action: "block",
+    legalBasis: "prohibited-conduct policy",
+    priority: 5
+  },
+  {
+    id: "general-hate-violence-flag",
+    description: "Flag hate/violence/harassment for general tier above moderate severity.",
+    when: {
+      and: [
+        { "==": [{ var: "tier" }, "general"] },
+        { in: [{ var: "category" }, ["hate", "violence", "harassment"]] },
+        { ">=": [{ var: "severity" }, 0.5] }
+      ]
+    },
+    action: "flag",
+    priority: 1
+  },
+  {
+    id: "general-sexual-flag",
+    description: "General tier flags adult sexual content (allowed on the adult tier).",
+    when: {
+      and: [{ "==": [{ var: "tier" }, "general"] }, { "==": [{ var: "category" }, "sexual"] }]
+    },
+    action: "flag",
+    priority: 1
+  }
+];
+function defaultRulesForTier(tier) {
+  switch (tier) {
+    case "family":
+      return [...COMMON_RULES, ...FAMILY_RULES];
+    case "teen":
+      return [...COMMON_RULES, ...TEEN_RULES];
+    case "general":
+    case "adult":
+      return [...COMMON_RULES, ...GENERAL_RULES];
+    case "dev":
+    default:
+      return [...COMMON_RULES];
+  }
+}
+function buildContentPolicyConfig(opts) {
+  const tier = opts.tier;
+  const strict = tier === "family" || tier === "teen";
+  return {
+    tier,
+    jurisdiction: jurisdictionBundle(opts.region ?? "GLOBAL"),
+    rules: opts.rules ?? defaultRulesForTier(tier),
+    blocklist: opts.blocklist ?? DEFAULT_BLOCKLIST,
+    hardStopCategories: HARD_STOP_CATEGORIES,
+    classifier: opts.classifier,
+    llm: opts.llm,
+    borderlineThreshold: strict ? 0.2 : 0.4,
+    alwaysConsultLlm: strict
+  };
+}
+
+// src/policy/ContentPolicyGate.ts
+init_jsonLogic();
+var ACTION_RANK = { allow: 0, flag: 1, escalate: 2, block: 3 };
+function buildFacts(input, config) {
+  const j = config.jurisdiction;
+  return {
+    text: input.text,
+    textLength: input.text.length,
+    normalizedText: normalizeText(input.text),
+    category: "none",
+    severity: 0,
+    tier: config.tier,
+    region: j.region,
+    aiActTier: j.aiActTier ?? null,
+    minAge: j.minAge ?? null,
+    dsaApplies: Boolean(j.dsaApplies),
+    surface: input.surface,
+    direction: input.direction ?? "output",
+    ...input.facts ?? {}
+  };
+}
+function tierApplies(rule, tier) {
+  return !rule.appliesToTiers || rule.appliesToTiers.length === 0 || rule.appliesToTiers.includes(tier);
+}
+function regionApplies(rule, region) {
+  if (!rule.appliesToRegions || rule.appliesToRegions.length === 0) return true;
+  if (region === "GLOBAL") return true;
+  return rule.appliesToRegions.includes(region) || rule.appliesToRegions.includes("GLOBAL");
+}
+function applyRules(rules, facts) {
+  let block = null;
+  let escalate = null;
+  let flag = null;
+  let allow = null;
+  const higher = (cur, r) => !cur || (r.priority ?? 0) > (cur.priority ?? 0) ? r : cur;
+  for (const r of rules) {
+    if (!tierApplies(r, facts.tier)) continue;
+    if (!regionApplies(r, facts.region)) continue;
+    if (!matchesRule(r.when, facts)) continue;
+    switch (r.action) {
+      case "block":
+        block = higher(block, r);
+        break;
+      case "escalate":
+        escalate = higher(escalate, r);
+        break;
+      case "flag":
+        flag = higher(flag, r);
+        break;
+      case "allow":
+        allow = higher(allow, r);
+        break;
+    }
+  }
+  if (block) return { action: "block", rule: block };
+  if (escalate) return { action: "escalate", rule: escalate };
+  if (flag && !allow) return { action: "flag", rule: flag };
+  if (allow) return { action: "allow", rule: allow };
+  return { action: "allow", rule: null };
+}
+function mergeOutcome(a, b) {
+  return ACTION_RANK[b.action] > ACTION_RANK[a.action] ? b : a;
+}
+function statementOfReasons(action, classification, rule, facts) {
+  if (action === "allow") return null;
+  const parts = [
+    `action=${action}`,
+    `category=${classification.category}`,
+    `severity=${classification.severity.toFixed(2)}`,
+    `tier=${facts.tier}`,
+    `region=${facts.region}`,
+    `surface=${facts.surface}`,
+    `direction=${facts.direction}`
+  ];
+  if (rule) {
+    parts.push(`rule=${rule.id}`);
+    if (rule.legalBasis) parts.push(`basis="${rule.legalBasis}"`);
+    if (rule.aiActArticle) parts.push(`aiActArticle=${rule.aiActArticle}`);
+  } else {
+    parts.push("rule=hard-stop");
+  }
+  return parts.join(" ");
+}
+function finalize(action, classification, rule, facts, config, decidedAtTier, timestampMs) {
+  const j = config.jurisdiction;
+  const disclosureRequired = Boolean(j.disclosureRequired) && facts.direction === "output";
+  const allowed = action === "allow" || action === "flag";
+  let reason;
+  switch (action) {
+    case "block":
+      reason = rule ? `Blocked by policy rule ${rule.id}: ${rule.description}` : `Blocked: hard-stop category "${classification.category}".`;
+      break;
+    case "escalate":
+      reason = `Held for human review${rule ? ` (rule ${rule.id})` : ""}: category "${classification.category}".`;
+      break;
+    case "flag":
+      reason = `Allowed but flagged${rule ? ` (rule ${rule.id})` : ""}: category "${classification.category}".`;
+      break;
+    default:
+      reason = "Allowed: no policy rule matched.";
+  }
+  return {
+    allowed,
+    action,
+    tier: config.tier,
+    category: classification.category,
+    severity: classification.severity,
+    matchedRuleId: rule?.id ?? null,
+    reason,
+    classification,
+    jurisdiction: j,
+    statementOfReasons: statementOfReasons(action, classification, rule, facts),
+    disclosureRequired,
+    decidedAtTier,
+    timestampMs
+  };
+}
+function evaluateContentPolicySync(input, config) {
+  const timestampMs = Date.now();
+  const facts = buildFacts(input, config);
+  const hardStops = config.hardStopCategories ?? HARD_STOP_CATEGORIES;
+  let classification = { category: "none", severity: 0, source: "none" };
+  if (config.blocklist && config.blocklist.length) {
+    const hit = matchBlocklist(input.text, config.blocklist);
+    if (hit) {
+      classification = { category: hit.category, severity: hit.severity, source: "blocklist", rationale: hit.rationale };
+      if (hit.hardStop || hardStops.includes(hit.category)) {
+        const f = { ...facts, category: hit.category, severity: hit.severity };
+        return finalize("block", classification, null, f, config, 0, timestampMs);
+      }
+    }
+  }
+  const facts1 = { ...facts, category: classification.category, severity: classification.severity };
+  const outcome = applyRules(config.rules, facts1);
+  const tier = outcome.action === "escalate" ? 3 : outcome.action === "allow" ? -1 : 1;
+  return finalize(outcome.action, classification, outcome.rule, facts1, config, tier, timestampMs);
+}
+async function evaluateContentPolicy(input, config) {
+  const timestampMs = Date.now();
+  const facts0 = buildFacts(input, config);
+  const hardStops = config.hardStopCategories ?? HARD_STOP_CATEGORIES;
+  let classification = { category: "none", severity: 0, source: "none" };
+  if (config.blocklist && config.blocklist.length) {
+    const hit = matchBlocklist(input.text, config.blocklist);
+    if (hit) {
+      classification = { category: hit.category, severity: hit.severity, source: "blocklist", rationale: hit.rationale };
+      if (hit.hardStop || hardStops.includes(hit.category)) {
+        const f = { ...facts0, category: hit.category, severity: hit.severity };
+        return finalize("block", classification, null, f, config, 0, timestampMs);
+      }
+    }
+  }
+  let facts = { ...facts0, category: classification.category, severity: classification.severity };
+  if (config.classifier) {
+    const c = await config.classifier(input.text, facts);
+    if (c && c.severity >= classification.severity) {
+      classification = c;
+      facts = { ...facts, category: c.category, severity: c.severity };
+      if (hardStops.includes(c.category)) {
+        return finalize("block", classification, null, facts, config, 1, timestampMs);
+      }
+    }
+  }
+  let outcome = applyRules(config.rules, facts);
+  if (outcome.action === "block") {
+    return finalize("block", classification, outcome.rule, facts, config, 1, timestampMs);
+  }
+  const consultLlm = !!config.llm && (config.alwaysConsultLlm === true || classification.category !== "none" || classification.severity >= (config.borderlineThreshold ?? 0.3));
+  if (config.llm && consultLlm) {
+    const verdict = await config.llm(input.text, facts);
+    if (verdict.flagged && verdict.categories.length > 0) {
+      const cat = verdict.categories[0];
+      if (verdict.severity >= classification.severity) {
+        classification = { category: cat, severity: verdict.severity, source: "llm", rationale: verdict.rationale };
+        facts = { ...facts, category: cat, severity: verdict.severity };
+      }
+      if (hardStops.includes(cat)) {
+        return finalize("block", classification, null, facts, config, 2, timestampMs);
+      }
+      const llmOutcome = applyRules(config.rules, facts);
+      outcome = mergeOutcome(outcome, llmOutcome);
+      if (outcome.action === "block") {
+        return finalize("block", classification, outcome.rule, facts, config, 2, timestampMs);
+      }
+    }
+  }
+  const decidedAtTier = outcome.action === "allow" ? -1 : outcome.action === "escalate" ? 3 : classification.source === "llm" ? 2 : 1;
+  return finalize(outcome.action, classification, outcome.rule, facts, config, decidedAtTier, timestampMs);
+}
+function toAuditEventInput(decision, ctx) {
+  const outcome = decision.action === "block" || decision.action === "escalate" ? "denied" : "success";
+  return {
+    tenantId: ctx.tenantId,
+    actorId: ctx.actorId,
+    actorType: ctx.actorType ?? "agent",
+    action: `content_policy:${decision.action}`,
+    resource: "content",
+    resourceId: ctx.resourceId,
+    outcome,
+    clientIp: ctx.clientIp,
+    metadata: {
+      surface: ctx.surface,
+      category: decision.category,
+      severity: decision.severity,
+      tier: decision.tier,
+      region: decision.jurisdiction.region,
+      matchedRuleId: decision.matchedRuleId,
+      decidedAtTier: decision.decidedAtTier,
+      disclosureRequired: decision.disclosureRequired,
+      statementOfReasons: decision.statementOfReasons,
+      _compliance: "dsa-statement-of-reasons"
+    }
+  };
+}
+
+// src/policy/PolicyPack.ts
+var POLICY_PACK_FRAMEWORK_IDS = [
+  "EU_AI_ACT_HIGH_RISK",
+  "NIST_AI_RMF",
+  "ISO_42001",
+  "CFPB_FAIR_LENDING",
+  "NYC_LL144",
+  "EEOC",
+  "COLORADO_SB21_169"
+];
+var POLICY_PACK_COMPILE_TARGETS = [
+  "bias_audit_report",
+  "model_card",
+  "impact_assessment",
+  "declaration_of_conformity"
+];
+var POLICY_PACK_AUDIT_STORES = ["append_only", "immutable_ledger", "external_archive"];
+var POLICY_PACK_MONITORING_INTERVALS = [
+  "per_deploy",
+  "daily",
+  "weekly",
+  "monthly",
+  "quarterly",
+  "annual"
+];
+var PolicyPackDeploymentError = class extends Error {
+  constructor(evaluation) {
+    super(
+      `PolicyPack "${evaluation.policyPack}" refused deploy: ` + evaluation.issues.map((issue) => issue.code).join(", ")
+    );
+    this.evaluation = evaluation;
+    this.name = "PolicyPackDeploymentError";
+  }
+};
+var PolicyPackDefinitionError = class extends Error {
+  constructor(issues) {
+    super(`Invalid PolicyPack: ${issues.map((issue) => issue.message).join("; ")}`);
+    this.issues = issues;
+    this.name = "PolicyPackDefinitionError";
+  }
+};
+function isPolicyPackFrameworkId(value) {
+  return POLICY_PACK_FRAMEWORK_IDS.includes(value);
+}
+function isPolicyPackCompileTarget(value) {
+  return POLICY_PACK_COMPILE_TARGETS.includes(value);
+}
+function isAuditStore(value) {
+  return POLICY_PACK_AUDIT_STORES.includes(value);
+}
+function isMonitoringInterval(value) {
+  return POLICY_PACK_MONITORING_INTERVALS.includes(value);
+}
+function validatePolicyPack(pack) {
+  const issues = [];
+  if (!pack.name.trim()) {
+    issues.push({ code: "invalid_pack", severity: "error", message: "PolicyPack name is required." });
+  }
+  if (!pack.version.trim()) {
+    issues.push({ code: "invalid_pack", severity: "error", message: "PolicyPack version is required." });
+  }
+  if (!isPolicyPackFrameworkId(pack.frameworkId)) {
+    issues.push({
+      code: "invalid_framework",
+      severity: "error",
+      message: `Unknown frameworkId "${pack.frameworkId}".`
+    });
+  }
+  if (pack.requiredTests.length === 0) {
+    issues.push({
+      code: "invalid_pack",
+      severity: "error",
+      message: "PolicyPack requires at least one FairnessSweep test."
+    });
+  }
+  for (const test of pack.requiredTests) {
+    if (!test.id.trim() || !test.protectedAttribute.trim()) {
+      issues.push({
+        code: "invalid_pack",
+        severity: "error",
+        message: "Every required FairnessSweep needs id and protectedAttribute.",
+        testId: test.id
+      });
+    }
+  }
+  for (const target of pack.requiredCompileTargets) {
+    if (!isPolicyPackCompileTarget(target)) {
+      issues.push({
+        code: "invalid_compile_target",
+        severity: "error",
+        message: `Unknown policy-pack compile target "${target}".`,
+        compileTarget: target
+      });
+    }
+  }
+  if (pack.requiredCompileTargets.length === 0) {
+    issues.push({
+      code: "invalid_pack",
+      severity: "error",
+      message: "PolicyPack requires at least one compliance compile target."
+    });
+  }
+  if (!Number.isFinite(pack.auditRetention.minDays) || pack.auditRetention.minDays <= 0) {
+    issues.push({
+      code: "invalid_pack",
+      severity: "error",
+      message: "auditRetention.minDays must be a positive number."
+    });
+  }
+  if (!isAuditStore(pack.auditRetention.storage)) {
+    issues.push({
+      code: "invalid_pack",
+      severity: "error",
+      message: `Unknown audit retention storage "${pack.auditRetention.storage}".`
+    });
+  }
+  if (!isMonitoringInterval(pack.monitoringCadence.interval)) {
+    issues.push({
+      code: "invalid_pack",
+      severity: "error",
+      message: `Unknown monitoring interval "${pack.monitoringCadence.interval}".`
+    });
+  }
+  return issues;
+}
+function definePolicyPack(input) {
+  const pack = { ...input, type: "PolicyPack" };
+  const issues = validatePolicyPack(pack);
+  if (issues.some((issue) => issue.severity === "error")) {
+    throw new PolicyPackDefinitionError(issues);
+  }
+  return pack;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function field(record, ...names) {
+  for (const name of names) {
+    if (record[name] !== void 0) return record[name];
+  }
+  return void 0;
+}
+function stringField(record, fallback, ...names) {
+  const value = field(record, ...names);
+  return typeof value === "string" ? value : fallback;
+}
+function numberField(record, fallback, ...names) {
+  const value = field(record, ...names);
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function booleanField(record, ...names) {
+  const value = field(record, ...names);
+  return typeof value === "boolean" ? value : void 0;
+}
+function arrayField(value) {
+  return Array.isArray(value) ? value : value === void 0 ? [] : [value];
+}
+function normalizeRequiredFairnessSweep(value, index) {
+  const record = asRecord(value);
+  const out = {
+    id: stringField(record, `fairness_sweep_${index + 1}`, "id", "name"),
+    protectedAttribute: stringField(record, "group", "protectedAttribute", "protected_attribute")
+  };
+  const minSampleSize = numberField(record, Number.NaN, "minSampleSize", "min_sample_size");
+  if (Number.isFinite(minSampleSize)) out.minSampleSize = minSampleSize;
+  const adverseImpactRatioMin = numberField(
+    record,
+    Number.NaN,
+    "adverseImpactRatioMin",
+    "adverse_impact_ratio_min"
+  );
+  if (Number.isFinite(adverseImpactRatioMin)) out.adverseImpactRatioMin = adverseImpactRatioMin;
+  const demographicParityDiffMax = numberField(
+    record,
+    Number.NaN,
+    "demographicParityDiffMax",
+    "demographic_parity_diff_max"
+  );
+  if (Number.isFinite(demographicParityDiffMax)) {
+    out.demographicParityDiffMax = demographicParityDiffMax;
+  }
+  const requireRobustnessReceipt = booleanField(
+    record,
+    "requireRobustnessReceipt",
+    "require_robustness_receipt"
+  );
+  if (requireRobustnessReceipt !== void 0) out.requireRobustnessReceipt = requireRobustnessReceipt;
+  out.config = record;
+  return out;
+}
+function normalizeAuditRetention(record) {
+  return {
+    minDays: numberField(record, 0, "minDays", "min_days"),
+    storage: stringField(record, "", "storage"),
+    legalHold: booleanField(record, "legalHold", "legal_hold")
+  };
+}
+function normalizeMonitoringCadence(record) {
+  const cadence = {
+    interval: stringField(record, "", "interval")
+  };
+  const driftSweepRequired = booleanField(record, "driftSweepRequired", "drift_sweep_required");
+  if (driftSweepRequired !== void 0) cadence.driftSweepRequired = driftSweepRequired;
+  const alertThreshold = numberField(record, Number.NaN, "alertThreshold", "alert_threshold");
+  if (Number.isFinite(alertThreshold)) cadence.alertThreshold = alertThreshold;
+  return cadence;
+}
+function policyPackFromSchemaBlock(block) {
+  const properties = block.properties ?? {};
+  const frameworkId = block.frameworkId ?? stringField(properties, "", "framework_id", "frameworkId");
+  const rawTests = block.requiredTests ?? arrayField(field(properties, "required_tests", "requiredTests"));
+  const rawTargets = block.requiredCompileTargets ?? arrayField(field(properties, "required_compile_targets", "requiredCompileTargets"));
+  const auditRetention = block.auditRetention ?? asRecord(field(properties, "audit_retention", "auditRetention"));
+  const monitoringCadence = block.monitoringCadence ?? asRecord(field(properties, "monitoring", "monitoring_cadence", "monitoringCadence"));
+  return definePolicyPack({
+    name: block.name,
+    version: block.version ?? stringField(properties, "1.0.0", "version"),
+    frameworkId,
+    requiredTests: rawTests.map(normalizeRequiredFairnessSweep),
+    requiredCompileTargets: rawTargets.map((target) => String(target)),
+    auditRetention: normalizeAuditRetention(auditRetention),
+    monitoringCadence: normalizeMonitoringCadence(monitoringCadence),
+    metadata: properties
+  });
+}
+function evaluatePolicyPackDeployment(pack, evidence) {
+  const issues = validatePolicyPack(pack);
+  const testEvidence = new Map(evidence.tests.map((test) => [test.id, test]));
+  const artifactTargets = new Set(evidence.compileTargets.map((artifact) => artifact.target));
+  const missingTests = [];
+  const failedTests = [];
+  const missingCompileTargets = [];
+  for (const required of pack.requiredTests) {
+    const observed = testEvidence.get(required.id);
+    if (!observed) {
+      missingTests.push(required.id);
+      issues.push({
+        code: "missing_required_test",
+        severity: "error",
+        message: `Missing required FairnessSweep evidence "${required.id}".`,
+        testId: required.id
+      });
+      continue;
+    }
+    const ratioFloor = required.adverseImpactRatioMin ?? 0.8;
+    const ratio = observed.adverseImpactRatio;
+    const parityDiff = observed.demographicParityDiff;
+    const failed = !observed.passed || required.minSampleSize !== void 0 && (observed.sampleSize ?? 0) < required.minSampleSize || ratio !== void 0 && ratio < ratioFloor || required.demographicParityDiffMax !== void 0 && (parityDiff === void 0 || parityDiff > required.demographicParityDiffMax) || required.requireRobustnessReceipt === true && !observed.robustnessReceiptHash;
+    if (failed) {
+      failedTests.push(required.id);
+      issues.push({
+        code: "failed_required_test",
+        severity: "error",
+        message: `Required FairnessSweep "${required.id}" did not satisfy the policy pack.`,
+        testId: required.id
+      });
+    }
+  }
+  for (const target of pack.requiredCompileTargets) {
+    if (!artifactTargets.has(target)) {
+      missingCompileTargets.push(target);
+      issues.push({
+        code: "missing_compile_target",
+        severity: "error",
+        message: `Missing required compliance artifact "${target}".`,
+        compileTarget: target
+      });
+    }
+  }
+  if (evidence.auditRetentionAccepted !== true) {
+    issues.push({
+      code: "audit_retention_not_armed",
+      severity: "error",
+      message: "Audit retention policy has not been accepted by the deploy gate."
+    });
+  }
+  if (evidence.monitoringScheduled !== true) {
+    issues.push({
+      code: "monitoring_not_scheduled",
+      severity: "error",
+      message: "Monitoring cadence has not been scheduled for the deployment."
+    });
+  }
+  return {
+    allowed: !issues.some((issue) => issue.severity === "error"),
+    policyPack: pack.name,
+    frameworkId: pack.frameworkId,
+    missingTests,
+    failedTests,
+    missingCompileTargets,
+    issues
+  };
+}
+function assertPolicyPackDeploymentReady(pack, evidence) {
+  const evaluation = evaluatePolicyPackDeployment(pack, evidence);
+  if (!evaluation.allowed) {
+    throw new PolicyPackDeploymentError(evaluation);
+  }
+  return evaluation;
+}
+function defaultPolicyPackCompileTargets() {
+  return [...POLICY_PACK_COMPILE_TARGETS];
+}
+
+export { DEFAULT_BLOCKLIST, HARD_STOP_CATEGORIES, POLICY_PACK_COMPILE_TARGETS, POLICY_PACK_FRAMEWORK_IDS, PolicyPackDefinitionError, PolicyPackDeploymentError, assertPolicyPackDeploymentReady, buildContentPolicyConfig, defaultPolicyPackCompileTargets, defaultRulesForTier, definePolicyPack, evaluateContentPolicy, evaluateContentPolicySync, evaluatePolicyPackDeployment, isPolicyPackCompileTarget, isPolicyPackFrameworkId, jurisdictionBundle, matchBlocklist, normalizeText, policyPackFromSchemaBlock, toAuditEventInput, validatePolicyPack };
+//# sourceMappingURL=chunk-ET3AN4W3.js.map
+//# sourceMappingURL=chunk-ET3AN4W3.js.map