@xnetjs/abuse 0.0.1

package/dist/index.js

@@ -0,0 +1,3201 @@
+import {
+  activeLabels,
+  bucketAbusePeerScore,
+  createAbuseDecisionAdapter,
+  createAbuseFactAdapter,
+  createRemoteAdmissionPipeline,
+  createRemoteMutationRejectionTelemetry,
+  decideAbuse,
+  decidePublicInteraction,
+  decideReach,
+  decideRemoteMutation,
+  decideTransport,
+  decideWithAdapter,
+  hashAbusePeerIdentifier,
+  isRejected,
+  isVisible,
+  normalizeAbuseFacts,
+  qualityRiskScore,
+  reportRemoteMutationRejection,
+  shouldThrottle,
+  weightedLabelScore
+} from "./chunk-O3JDSAJP.js";
+
+// src/explain.ts
+var REASON_DETAILS = {
+  accepted: {
+    severity: "low",
+    message: "No abuse or quality policy required a restriction."
+  },
+  "blocked-by-policy": {
+    severity: "high",
+    message: "A user, workspace, hub, or app-view policy block matched this actor or subject."
+  },
+  "budget-required": {
+    severity: "medium",
+    message: "The request exceeded the configured resource budget for this surface."
+  },
+  "failed-admission": {
+    severity: "critical",
+    message: "The input failed one or more hard admission checks."
+  },
+  "first-contact": {
+    severity: "medium",
+    message: "First-contact interactions are quarantined by policy."
+  },
+  "invalid-doc-binding": {
+    severity: "high",
+    message: "The envelope was not bound to the expected document or resource."
+  },
+  "invalid-freshness": {
+    severity: "high",
+    message: "The envelope freshness or replay window check failed."
+  },
+  "invalid-hash": {
+    severity: "critical",
+    message: "The content hash did not match the signed payload."
+  },
+  "invalid-signature": {
+    severity: "critical",
+    message: "The signature did not verify against the claimed author."
+  },
+  "low-confidence-quality-signal": {
+    severity: "low",
+    message: "Quality signals suggest caution but not review."
+  },
+  "over-rate-limit": {
+    severity: "medium",
+    message: "The actor or peer exceeded the configured rate limit."
+  },
+  "over-size-limit": {
+    severity: "high",
+    message: "The payload exceeded the configured size limit."
+  },
+  "peer-score-block": {
+    severity: "high",
+    message: "The peer score crossed the block threshold."
+  },
+  "peer-score-throttle": {
+    severity: "medium",
+    message: "The peer score crossed the throttle threshold."
+  },
+  "quality-risk": {
+    severity: "medium",
+    message: "Quality signals crossed the review threshold."
+  },
+  "trusted-abuse-label": {
+    severity: "high",
+    message: "Trusted labels indicate abuse such as spam, scam, malware, or impersonation."
+  },
+  "trusted-warning-label": {
+    severity: "medium",
+    message: "Trusted labels indicate a warning or demotion is appropriate."
+  },
+  unauthorized: {
+    severity: "critical",
+    message: "The claimed actor is not authorized to perform this action."
+  },
+  "unsigned-update": {
+    severity: "high",
+    message: "The remote mutation was unsigned on a surface that requires signed replication."
+  },
+  "policy-override": {
+    severity: "low",
+    message: "A workspace or reviewer policy override changed the display or reach decision."
+  },
+  "user-override": {
+    severity: "low",
+    message: "A local override changed the display or reach decision."
+  }
+};
+function explainDecision(decision) {
+  const reasons = decision.reasons.map(toExplanationReason);
+  return {
+    summary: summarizeDecision(decision),
+    reasons
+  };
+}
+function getReasonDetail(code) {
+  return toExplanationReason(code);
+}
+function summarizeDecision(decision) {
+  if (decision.admission === "reject") {
+    return "Rejected before acceptance or mutation.";
+  }
+  if (decision.admission === "quarantine") {
+    return "Accepted into quarantine pending review or budget.";
+  }
+  if (decision.visibility === "hide") {
+    return "Accepted but hidden by policy.";
+  }
+  if (decision.visibility === "warn" || decision.reach === "demote") {
+    return "Accepted with warning or reduced reach.";
+  }
+  return "Accepted normally.";
+}
+function toExplanationReason(code) {
+  const detail = REASON_DETAILS[code];
+  return {
+    code,
+    severity: detail.severity,
+    message: detail.message
+  };
+}
+
+// src/fixtures.ts
+var TRUSTED_SPAM_LABEL = {
+  value: "spam",
+  sourceDID: "did:key:zTrustedLabeler",
+  sourceWeight: 2,
+  confidence: 1,
+  evidenceRefs: ["label:evidence:spam"]
+};
+var WARNING_SLOP_LABEL = {
+  value: "slop",
+  sourceDID: "did:key:zTrustedQualityLabeler",
+  sourceWeight: 1,
+  confidence: 0.75,
+  evidenceRefs: ["label:evidence:slop"]
+};
+function createBaseFacts(overrides = {}) {
+  return {
+    surface: overrides.surface ?? "remoteMutation",
+    crypto: {
+      hashValid: true,
+      signatureValid: true,
+      authorized: true,
+      freshnessValid: true,
+      docBindingValid: true,
+      ...overrides.crypto
+    },
+    resource: {
+      overSizeLimit: false,
+      overRateLimit: false,
+      estimatedCost: 0,
+      budgetRemaining: null,
+      ...overrides.resource
+    },
+    actor: {
+      did: "did:key:zActor",
+      peerId: "peer-1",
+      firstContact: false,
+      peerScore: 100,
+      localBlocked: false,
+      workspaceBlocked: false,
+      hubBlocked: false,
+      appViewBlocked: false,
+      ...overrides.actor
+    },
+    labels: overrides.labels ?? [],
+    quality: {
+      duplicateScore: 0,
+      slopScore: 0,
+      citationCoverage: 1,
+      provenanceScore: 1,
+      ...overrides.quality
+    },
+    policy: overrides.policy,
+    override: overrides.override,
+    now: overrides.now ?? 17e11
+  };
+}
+var abuseFixtures = {
+  validRemoteMutation: createBaseFacts(),
+  invalidSignatureRemoteMutation: createBaseFacts({
+    crypto: { signatureValid: false }
+  }),
+  oversizedRemoteMutation: createBaseFacts({
+    resource: { overSizeLimit: true }
+  }),
+  firstContactComment: createBaseFacts({
+    surface: "commentThread",
+    actor: { firstContact: true }
+  }),
+  trustedSpamComment: createBaseFacts({
+    surface: "commentThread",
+    labels: [TRUSTED_SPAM_LABEL]
+  }),
+  lowQualitySearchCandidate: createBaseFacts({
+    surface: "searchIndex",
+    quality: {
+      duplicateScore: 0.8,
+      slopScore: 0.8,
+      citationCoverage: 0.1,
+      provenanceScore: 0.2
+    }
+  }),
+  expiredSpamLabel: createBaseFacts({
+    surface: "commentThread",
+    labels: [{ ...TRUSTED_SPAM_LABEL, expiresAt: 1 }],
+    now: 2
+  }),
+  throttledPeer: createBaseFacts({
+    surface: "transport",
+    actor: { peerScore: 20 }
+  })
+};
+
+// src/ai-provenance.ts
+function isAISignalSourceType(sourceType) {
+  return sourceType === "local-ai" || sourceType === "cloud-ai";
+}
+function validateAISignalProvenance(input) {
+  if (!isAISignalSourceType(input.sourceType)) {
+    return {
+      required: false,
+      valid: true,
+      errors: [],
+      provenance: null
+    };
+  }
+  const modelProvider = normalizeRequired(input.modelProvider);
+  const modelName = normalizeRequired(input.modelName);
+  const errors = [
+    modelProvider ? null : "missing-model-provider",
+    modelName ? null : "missing-model-name"
+  ].filter((error) => error !== null);
+  return {
+    required: true,
+    valid: errors.length === 0,
+    errors,
+    provenance: errors.length === 0 ? {
+      sourceType: input.sourceType,
+      modelProvider: modelProvider ?? "",
+      modelName: modelName ?? "",
+      modelVersion: normalizeOptional(input.modelVersion),
+      adapterId: normalizeOptional(input.adapterId),
+      adapterVersion: normalizeOptional(input.adapterVersion),
+      policyId: normalizeOptional(input.policyId)
+    } : null
+  };
+}
+function createAISignalProvenanceEvidenceRef(input) {
+  const validation = validateAISignalProvenance(input);
+  if (!validation.provenance) return null;
+  const version = validation.provenance.modelVersion ?? "unversioned";
+  return [
+    "ai-provenance",
+    validation.provenance.sourceType,
+    validation.provenance.modelProvider,
+    validation.provenance.modelName,
+    version
+  ].map(normalizeEvidenceRefPart).join(":");
+}
+function normalizeRequired(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : null;
+}
+function normalizeOptional(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function normalizeEvidenceRefPart(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-");
+}
+
+// src/cloud-classifier.ts
+async function classifyWithCloudAdapter(input, adapter, privacy, budget, _options = {}) {
+  const skipped = getCloudClassificationSkipReason(input, adapter, privacy, budget);
+  if (skipped) {
+    if (skipped !== "over-budget") {
+      return createSkippedCloudClassificationResult(input, adapter, privacy, budget, skipped);
+    }
+    const requestBase2 = createCloudClassifierRequestBase(input, adapter, privacy);
+    return createSkippedCloudClassificationResult(input, adapter, privacy, budget, skipped, {
+      estimatedCostMicroUsd: estimateCloudClassifierCost(adapter, requestBase2),
+      sentBodyChars: requestBase2.body?.length ?? 0
+    });
+  }
+  const requestBase = createCloudClassifierRequestBase(input, adapter, privacy);
+  const estimatedCostMicroUsd = estimateCloudClassifierCost(adapter, requestBase);
+  const budgetSkipReason = getBudgetSkipReason(estimatedCostMicroUsd, budget);
+  if (budgetSkipReason) {
+    return createSkippedCloudClassificationResult(
+      input,
+      adapter,
+      privacy,
+      budget,
+      budgetSkipReason,
+      {
+        estimatedCostMicroUsd,
+        sentBodyChars: requestBase.body?.length ?? 0
+      }
+    );
+  }
+  const request = {
+    ...requestBase,
+    estimatedCostMicroUsd
+  };
+  const startedAt = Date.now();
+  try {
+    const result = await adapter.classify(request);
+    const chargedCostMicroUsd = result.chargedCostMicroUsd ?? estimatedCostMicroUsd;
+    const provenance = createCloudClassifierProvenance(adapter, request.privacyMode);
+    return {
+      labels: result.labels ? result.labels.map(copyLabel) : [],
+      quality: result.quality ?? {},
+      signals: normalizeCloudClassifierSignals(result.signals ?? [], provenance),
+      provenance,
+      usage: {
+        estimatedCostMicroUsd,
+        chargedCostMicroUsd,
+        remainingBudgetMicroUsd: Math.max(0, budget.remainingMicroUsd - chargedCostMicroUsd),
+        privacyMode: request.privacyMode,
+        sentBodyChars: request.body?.length ?? 0
+      },
+      skipped: null,
+      elapsedMs: Date.now() - startedAt,
+      errors: [...result.errors ?? []]
+    };
+  } catch (error) {
+    const provenance = createCloudClassifierProvenance(adapter, request.privacyMode);
+    return {
+      labels: [],
+      quality: {},
+      signals: [],
+      provenance,
+      usage: {
+        estimatedCostMicroUsd,
+        chargedCostMicroUsd: 0,
+        remainingBudgetMicroUsd: budget.remainingMicroUsd,
+        privacyMode: request.privacyMode,
+        sentBodyChars: request.body?.length ?? 0
+      },
+      skipped: null,
+      elapsedMs: Date.now() - startedAt,
+      errors: [error instanceof Error ? error.message : String(error)]
+    };
+  }
+}
+function createCloudClassifierAdapter(adapter) {
+  return adapter;
+}
+function createCloudClassifierRequestBase(input, adapter, privacy) {
+  const privacyMode = assertEnabledPrivacyMode(privacy.mode);
+  const body = prepareCloudBody(input.body, privacy);
+  const title = input.title ? prepareCloudBody(input.title, privacy) : void 0;
+  return {
+    provider: adapter.provider,
+    model: adapter.model,
+    adapterId: adapter.id,
+    adapterVersion: adapter.version,
+    surface: input.surface,
+    subjectId: privacy.sendSubjectId ? input.subjectId : void 0,
+    title: privacyMode === "metadata-only" ? void 0 : title,
+    body: privacyMode === "metadata-only" ? void 0 : body,
+    language: input.language,
+    metadata: privacy.sendMetadata ? input.metadata : void 0,
+    contentFingerprint: privacy.sendContentFingerprint ? input.contentFingerprint : void 0,
+    privacyMode
+  };
+}
+function estimateCloudClassifierCost(adapter, request) {
+  return Math.max(
+    0,
+    Math.ceil(adapter.estimateCostMicroUsd?.(request) ?? adapter.defaultEstimatedCostMicroUsd)
+  );
+}
+function getCloudClassificationSkipReason(input, adapter, privacy, budget) {
+  if (privacy.mode === "disabled") return "cloud-disabled";
+  if (!(adapter.supports?.(input) ?? true)) return "unsupported-surface";
+  if (privacy.allowedSurfaces && !privacy.allowedSurfaces.includes(input.surface)) {
+    return "unsupported-surface";
+  }
+  if (privacy.allowedProviders && !privacy.allowedProviders.includes(adapter.provider)) {
+    return "provider-not-allowed";
+  }
+  if (privacy.mode === "raw-content" && privacy.requireExplicitRawContentApproval !== false && !privacy.rawContentApproved) {
+    return "privacy-policy-blocked";
+  }
+  const requestBase = createCloudClassifierRequestBase(input, adapter, privacy);
+  return getBudgetSkipReason(estimateCloudClassifierCost(adapter, requestBase), budget);
+}
+function redactCloudClassifierText(text, patterns = defaultCloudRedactionPatterns, replacement = "[redacted]") {
+  return patterns.reduce((redacted, pattern) => redacted.replace(pattern, replacement), text);
+}
+var defaultCloudRedactionPatterns = [
+  /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi,
+  /(?:\+?1[-.\s]?)?(?:\(?\d{3}\)?[-.\s]?)\d{3}[-.\s]?\d{4}\b/g,
+  /\bhttps?:\/\/[^\s]+/gi
+];
+function getBudgetSkipReason(estimatedCostMicroUsd, budget) {
+  const minRemaining = budget.minRemainingMicroUsd ?? 0;
+  if (estimatedCostMicroUsd > budget.maxPerRequestMicroUsd) return "over-budget";
+  if (budget.remainingMicroUsd - estimatedCostMicroUsd < minRemaining) return "over-budget";
+  return null;
+}
+function createSkippedCloudClassificationResult(input, adapter, privacy, budget, skipped, usage) {
+  const privacyMode = privacy.mode === "disabled" ? "metadata-only" : privacy.mode;
+  return {
+    labels: [],
+    quality: {},
+    signals: [],
+    provenance: createCloudClassifierProvenance(adapter, privacyMode),
+    usage: {
+      estimatedCostMicroUsd: usage?.estimatedCostMicroUsd ?? 0,
+      chargedCostMicroUsd: 0,
+      remainingBudgetMicroUsd: budget.remainingMicroUsd,
+      privacyMode: privacy.mode,
+      sentBodyChars: usage?.sentBodyChars ?? (privacy.mode === "raw-content" ? input.body.length : 0)
+    },
+    skipped,
+    errors: []
+  };
+}
+function createCloudClassifierProvenance(adapter, privacyMode) {
+  return {
+    provider: "cloud",
+    cloudProvider: adapter.provider,
+    adapterId: adapter.id,
+    adapterVersion: adapter.version,
+    model: adapter.model,
+    policyId: adapter.policyId,
+    privacyMode
+  };
+}
+function normalizeCloudClassifierSignals(signals, provenance) {
+  return signals.map((signal) => ({
+    kind: signal.kind,
+    value: signal.value,
+    confidence: signal.confidence,
+    reason: signal.reason,
+    evidenceRefs: [...signal.evidenceRefs ?? []],
+    provenance
+  }));
+}
+function prepareCloudBody(body, privacy) {
+  const bounded = privacy.maxInputChars ? body.slice(0, privacy.maxInputChars) : body;
+  if (privacy.mode !== "redacted-content") return bounded;
+  return redactCloudClassifierText(
+    bounded,
+    privacy.redactPatterns ?? defaultCloudRedactionPatterns,
+    privacy.redactionReplacement
+  );
+}
+function assertEnabledPrivacyMode(mode) {
+  if (mode === "disabled") return "metadata-only";
+  return mode;
+}
+function copyLabel(label) {
+  return {
+    ...label,
+    evidenceRefs: label.evidenceRefs ? [...label.evidenceRefs] : void 0
+  };
+}
+
+// src/content-fingerprint.ts
+import { hash, hashHex } from "@xnetjs/crypto";
+var DEFAULT_MIN_TOKEN_LENGTH = 2;
+var DEFAULT_SHINGLE_SIZE = 5;
+var DEFAULT_MAX_SHINGLES = 512;
+var DEFAULT_NEAR_DUPLICATE_THRESHOLD = 0.75;
+var DEFAULT_WEAK_DUPLICATE_THRESHOLD = 0.55;
+var SIMHASH_BITS = 64;
+var encoder = new TextEncoder();
+function createContentFingerprint(input, options = {}) {
+  const shingleSize = options.shingleSize ?? DEFAULT_SHINGLE_SIZE;
+  const canonicalText = canonicalizeContentText(input);
+  const tokens = tokenizeContent(canonicalText, options);
+  const uniqueTokens = new Set(tokens);
+  return {
+    kind: "xnet.content-fingerprint.v1",
+    textHash: hashHex(encoder.encode(canonicalText), "blake3"),
+    simHash64: createSimHash64(tokens),
+    tokenCount: tokens.length,
+    uniqueTokenCount: uniqueTokens.size,
+    shingleSize,
+    shingles: createShingles(tokens, {
+      shingleSize,
+      maxShingles: options.maxShingles ?? DEFAULT_MAX_SHINGLES
+    })
+  };
+}
+function assessDuplicateContent(candidate, references, options = {}) {
+  const candidateFingerprint = toFingerprint(candidate, options);
+  const initial = createDuplicateAssessment({
+    duplicateScore: 0,
+    matchType: "none",
+    matchedIndex: null,
+    matchedTextHash: null,
+    shingleJaccard: 0,
+    simHashSimilarity: 0,
+    reasons: []
+  });
+  if (candidateFingerprint.tokenCount === 0 || references.length === 0) return initial;
+  return references.map(
+    (reference, index) => compareContentFingerprints(candidateFingerprint, toFingerprint(reference, options), {
+      ...options,
+      matchedIndex: index
+    })
+  ).reduce(
+    (best, current) => current.duplicateScore > best.duplicateScore ? current : best,
+    initial
+  );
+}
+function compareContentFingerprints(candidate, reference, options = {}) {
+  if (candidate.tokenCount === 0 || reference.tokenCount === 0) {
+    return createDuplicateAssessment({
+      duplicateScore: 0,
+      matchType: "none",
+      matchedIndex: options.matchedIndex ?? null,
+      matchedTextHash: reference.textHash,
+      shingleJaccard: 0,
+      simHashSimilarity: 0,
+      reasons: []
+    });
+  }
+  const exact = candidate.textHash === reference.textHash;
+  const shingleJaccard = jaccard(candidate.shingles, reference.shingles);
+  const simHashSimilarity = compareSimHash64(candidate.simHash64, reference.simHash64);
+  const duplicateScore = exact ? 1 : clamp01(
+    Math.max(
+      shingleJaccard,
+      simHashSimilarity >= 0.92 ? simHashSimilarity : simHashSimilarity * 0.75
+    )
+  );
+  const nearThreshold = options.nearDuplicateThreshold ?? DEFAULT_NEAR_DUPLICATE_THRESHOLD;
+  const weakThreshold = options.weakDuplicateThreshold ?? DEFAULT_WEAK_DUPLICATE_THRESHOLD;
+  const matchType = exact ? "exact" : duplicateScore >= nearThreshold ? "near" : duplicateScore >= weakThreshold ? "weak" : "none";
+  const reasons = [
+    exact ? "exact-content-hash" : null,
+    !exact && shingleJaccard >= nearThreshold ? "near-duplicate-shingles" : null,
+    !exact && simHashSimilarity >= 0.92 ? "near-duplicate-simhash" : null,
+    !exact && matchType === "weak" ? "weak-duplicate-signal" : null
+  ].filter((reason) => reason !== null);
+  return createDuplicateAssessment({
+    duplicateScore,
+    matchType,
+    exact,
+    matchedIndex: options.matchedIndex ?? null,
+    matchedTextHash: reference.textHash,
+    shingleJaccard,
+    simHashSimilarity,
+    reasons
+  });
+}
+function canonicalizeContentText(input) {
+  const text = typeof input === "string" ? input : [input.title, input.body].filter(Boolean).join("\n\n");
+  return text.normalize("NFKC").toLowerCase().replace(/https?:\/\/\S+/g, " url ").replace(/['']/g, "").replace(/[^\p{L}\p{N}]+/gu, " ").replace(/\s+/g, " ").trim();
+}
+function tokenizeContent(canonicalText, options = {}) {
+  const minTokenLength = options.minTokenLength ?? DEFAULT_MIN_TOKEN_LENGTH;
+  if (!canonicalText) return [];
+  return canonicalText.split(" ").filter((token) => token.length >= minTokenLength);
+}
+function compareSimHash64(left, right) {
+  const leftValue = BigInt(`0x${left}`);
+  const rightValue = BigInt(`0x${right}`);
+  let diff = leftValue ^ rightValue;
+  let distance = 0;
+  while (diff > 0n) {
+    distance += Number(diff & 1n);
+    diff >>= 1n;
+  }
+  return 1 - distance / SIMHASH_BITS;
+}
+function createShingles(tokens, options) {
+  if (tokens.length === 0) return [];
+  const width = Math.max(1, Math.min(options.shingleSize, tokens.length));
+  const shingles = [];
+  for (let i = 0; i <= tokens.length - width; i++) {
+    shingles.push(hashHex(encoder.encode(tokens.slice(i, i + width).join(" ")), "blake3"));
+  }
+  return Array.from(new Set(shingles)).slice(0, options.maxShingles);
+}
+function createSimHash64(tokens) {
+  if (tokens.length === 0) return "0000000000000000";
+  const weights = Array.from({ length: SIMHASH_BITS }, () => 0);
+  for (const token of tokens) {
+    const value = hashToken64(token);
+    for (let bit = 0; bit < SIMHASH_BITS; bit++) {
+      const mask = 1n << BigInt(bit);
+      weights[bit] += (value & mask) === 0n ? -1 : 1;
+    }
+  }
+  let result = 0n;
+  for (let bit = 0; bit < SIMHASH_BITS; bit++) {
+    if (weights[bit] >= 0) {
+      result |= 1n << BigInt(bit);
+    }
+  }
+  return result.toString(16).padStart(16, "0");
+}
+function hashToken64(token) {
+  const digest = hash(encoder.encode(token), "blake3");
+  return digest.slice(0, 8).reduce((value, byte) => value << 8n | BigInt(byte), 0n);
+}
+function jaccard(left, right) {
+  if (left.length === 0 || right.length === 0) return 0;
+  const leftSet = new Set(left);
+  const rightSet = new Set(right);
+  const intersection = Array.from(leftSet).filter((value) => rightSet.has(value)).length;
+  const union = (/* @__PURE__ */ new Set([...leftSet, ...rightSet])).size;
+  return union === 0 ? 0 : intersection / union;
+}
+function toFingerprint(value, options) {
+  return isContentFingerprint(value) ? value : createContentFingerprint(value, options);
+}
+function isContentFingerprint(value) {
+  return typeof value === "object" && value !== null && "kind" in value && value.kind === "xnet.content-fingerprint.v1";
+}
+function createDuplicateAssessment(input) {
+  return {
+    duplicateScore: input.duplicateScore,
+    matchType: input.matchType,
+    exact: input.exact ?? input.matchType === "exact",
+    matchedIndex: input.matchedIndex ?? null,
+    matchedTextHash: input.matchedTextHash ?? null,
+    shingleJaccard: input.shingleJaccard ?? 0,
+    simHashSimilarity: input.simHashSimilarity ?? 0,
+    reasons: input.reasons ? [...input.reasons] : []
+  };
+}
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+
+// src/local-classifier.ts
+async function classifyWithLocalAdapters(input, adapters, options = {}) {
+  const boundedInput = boundClassifierInput(input, options.maxInputChars);
+  const supported = adapters.filter((adapter) => adapter.supports?.(boundedInput) ?? true);
+  const results = await Promise.all(
+    supported.map(async (adapter) => {
+      const startedAt = Date.now();
+      try {
+        const result = await adapter.classify(boundedInput, options);
+        return {
+          ...result,
+          elapsedMs: result.elapsedMs ?? Date.now() - startedAt
+        };
+      } catch (error) {
+        return createLocalClassificationResult({
+          provenance: {
+            provider: "local",
+            adapterId: adapter.id,
+            adapterVersion: adapter.version,
+            model: adapter.model
+          },
+          errors: [error instanceof Error ? error.message : String(error)]
+        });
+      }
+    })
+  );
+  return mergeLocalClassificationResults(results, options);
+}
+function createKeywordLocalClassifier(options) {
+  const adapterId = options.id ?? "local.keyword";
+  const adapterVersion = options.version ?? "1";
+  const provenance = {
+    provider: "local",
+    adapterId,
+    adapterVersion,
+    model: options.model
+  };
+  return {
+    id: adapterId,
+    version: adapterVersion,
+    model: options.model,
+    classify(input, classifierOptions = {}) {
+      const now = classifierOptions.now ?? Date.now();
+      const text = canonicalizeContentText({ title: input.title, body: input.body });
+      const labels = options.rules.map((rule) => matchKeywordRule(rule, text, options.sourceDid, now)).filter((label) => label !== null).filter((label) => label.confidence >= (classifierOptions.minConfidence ?? 0));
+      const signals = labels.map((label) => ({
+        kind: "label",
+        value: label.value,
+        confidence: label.confidence,
+        evidenceRefs: [...label.evidenceRefs ?? []],
+        provenance
+      }));
+      return createLocalClassificationResult({
+        labels,
+        signals,
+        provenance
+      });
+    }
+  };
+}
+function mergeLocalClassificationResults(results, options = {}) {
+  const minConfidence = options.minConfidence ?? 0;
+  const labels = mergeLabels(
+    results.flatMap((result) => result.labels).filter((label) => label.confidence >= minConfidence)
+  );
+  const signals = results.flatMap((result) => result.signals);
+  const errors = results.flatMap((result) => result.errors);
+  const elapsedMs = results.reduce((total, result) => total + (result.elapsedMs ?? 0), 0);
+  return createLocalClassificationResult({
+    labels,
+    quality: mergeQualitySignals(results.map((result) => result.quality)),
+    signals,
+    provenance: {
+      provider: "local",
+      adapterId: "local.aggregate",
+      adapterVersion: "1"
+    },
+    elapsedMs,
+    errors
+  });
+}
+function createLocalClassificationResult(input) {
+  return {
+    labels: input.labels ?? [],
+    quality: input.quality ?? {},
+    signals: input.signals ?? [],
+    provenance: input.provenance,
+    elapsedMs: input.elapsedMs,
+    errors: input.errors ?? []
+  };
+}
+function boundClassifierInput(input, maxInputChars) {
+  if (!maxInputChars || input.body.length <= maxInputChars) return input;
+  return {
+    ...input,
+    body: input.body.slice(0, maxInputChars)
+  };
+}
+function matchKeywordRule(rule, canonicalText, sourceDid, now) {
+  const matched = rule.keywords.map((keyword) => canonicalizeContentText(keyword)).find((keyword) => keyword.length > 0 && canonicalText.includes(keyword));
+  if (!matched) return null;
+  return {
+    value: rule.label,
+    confidence: rule.confidence,
+    sourceDID: sourceDid,
+    sourceWeight: rule.sourceWeight ?? 1,
+    expiresAt: rule.expiresInMs ? now + rule.expiresInMs : void 0,
+    evidenceRefs: [`keyword:${matched}`]
+  };
+}
+function mergeLabels(labels) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const label of labels) {
+    const key = `${label.value}:${label.sourceDID ?? "local"}`;
+    const existing = merged.get(key);
+    if (!existing) {
+      merged.set(key, { ...label, evidenceRefs: [...label.evidenceRefs ?? []] });
+      continue;
+    }
+    merged.set(key, {
+      ...existing,
+      confidence: Math.max(existing.confidence, label.confidence),
+      sourceWeight: Math.max(existing.sourceWeight, label.sourceWeight),
+      expiresAt: minDefined(existing.expiresAt, label.expiresAt),
+      evidenceRefs: Array.from(
+        /* @__PURE__ */ new Set([...existing.evidenceRefs ?? [], ...label.evidenceRefs ?? []])
+      )
+    });
+  }
+  return Array.from(merged.values());
+}
+function mergeQualitySignals(qualities) {
+  return qualities.reduce(
+    (merged, quality) => ({
+      duplicateScore: maxDefined(merged.duplicateScore, quality.duplicateScore),
+      slopScore: maxDefined(merged.slopScore, quality.slopScore),
+      citationCoverage: minDefined(merged.citationCoverage, quality.citationCoverage),
+      provenanceScore: minDefined(merged.provenanceScore, quality.provenanceScore)
+    }),
+    {}
+  );
+}
+function maxDefined(left, right) {
+  if (left === void 0) return right;
+  if (right === void 0) return left;
+  return Math.max(left, right);
+}
+function minDefined(left, right) {
+  if (left === void 0) return right;
+  if (right === void 0) return left;
+  return Math.min(left, right);
+}
+
+// src/classifier-cascade.ts
+async function classifyWithModerationCascade(input, options = {}) {
+  const local = await classifyWithLocalAdapters(
+    input,
+    options.localAdapters ?? [],
+    options.localOptions
+  );
+  const route = decideCloudReviewRoute(input, local, options.cloud?.callPolicy);
+  if (!options.cloud) {
+    return createCascadeResult(local, void 0, {
+      callCloud: false,
+      reasons: route.reasons,
+      skipped: "cloud-not-configured"
+    });
+  }
+  if (!route.callCloud) {
+    return createCascadeResult(local, void 0, route);
+  }
+  const cloud = await classifyWithCloudAdapter(
+    input,
+    options.cloud.adapter,
+    options.cloud.privacy,
+    options.cloud.budget,
+    options.cloud.options
+  );
+  return createCascadeResult(local, cloud, route);
+}
+function decideCloudReviewRoute(input, local, policy = {}) {
+  if (policy.enabled === false) {
+    return { callCloud: false, reasons: [], skipped: "cloud-disabled" };
+  }
+  if (policy.allowedSurfaces && !policy.allowedSurfaces.includes(input.surface)) {
+    return { callCloud: false, reasons: [], skipped: "unsupported-surface" };
+  }
+  const labelRisk = maxLocalLabelConfidence(local);
+  const qualityRisk = localQualityRisk(local.quality);
+  const minLabelRisk = policy.minLocalLabelConfidence ?? 0.85;
+  const minQualityRisk = policy.minLocalQualityRisk ?? 0.65;
+  const reasons = [
+    labelRisk >= minLabelRisk ? "local-label-risk" : null,
+    qualityRisk >= minQualityRisk ? "local-quality-risk" : null,
+    policy.forceWhenNoLocalSignals === true && hasNoLocalSignals(local) ? "no-local-signals" : null
+  ].filter((reason) => reason !== null);
+  if (reasons.length > 0) {
+    return { callCloud: true, reasons, skipped: null };
+  }
+  return { callCloud: false, reasons: [], skipped: "low-risk-local-signals" };
+}
+function createCascadeResult(local, cloud, route) {
+  return {
+    labels: mergeLabels2([...local.labels ?? [], ...cloud?.labels ?? []]),
+    quality: mergeQuality(local.quality, cloud?.quality ?? {}),
+    local,
+    cloud,
+    cloudCalled: cloud !== void 0,
+    cloudReasons: route.reasons,
+    cloudSkippedReason: cloud?.skipped ?? route.skipped,
+    errors: [...local.errors, ...cloud?.errors ?? []]
+  };
+}
+function maxLocalLabelConfidence(local) {
+  return local.labels.reduce((confidence, label) => Math.max(confidence, label.confidence), 0);
+}
+function localQualityRisk(quality) {
+  return Math.max(
+    quality.duplicateScore ?? 0,
+    quality.slopScore ?? 0,
+    quality.citationCoverage === void 0 ? 0 : 1 - quality.citationCoverage,
+    quality.provenanceScore === void 0 ? 0 : 1 - quality.provenanceScore
+  );
+}
+function hasNoLocalSignals(local) {
+  return local.labels.length === 0 && local.signals.length === 0 && Object.keys(local.quality).length === 0;
+}
+function mergeLabels2(labels) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const label of labels) {
+    const key = `${label.value}:${label.sourceDID ?? label.evidenceRefs?.join("|") ?? "unknown"}`;
+    const existing = merged.get(key);
+    if (!existing) {
+      merged.set(key, { ...label, evidenceRefs: [...label.evidenceRefs ?? []] });
+      continue;
+    }
+    merged.set(key, {
+      ...existing,
+      confidence: Math.max(existing.confidence, label.confidence),
+      sourceWeight: Math.max(existing.sourceWeight, label.sourceWeight),
+      expiresAt: minDefined2(existing.expiresAt, label.expiresAt),
+      evidenceRefs: Array.from(
+        /* @__PURE__ */ new Set([...existing.evidenceRefs ?? [], ...label.evidenceRefs ?? []])
+      )
+    });
+  }
+  return Array.from(merged.values());
+}
+function mergeQuality(local, cloud) {
+  return {
+    duplicateScore: maxDefined2(local.duplicateScore, cloud.duplicateScore),
+    slopScore: maxDefined2(local.slopScore, cloud.slopScore),
+    citationCoverage: minDefined2(local.citationCoverage, cloud.citationCoverage),
+    provenanceScore: minDefined2(local.provenanceScore, cloud.provenanceScore)
+  };
+}
+function maxDefined2(left, right) {
+  if (left === void 0) return right;
+  if (right === void 0) return left;
+  return Math.max(left, right);
+}
+function minDefined2(left, right) {
+  if (left === void 0) return right;
+  if (right === void 0) return left;
+  return Math.min(left, right);
+}
+
+// src/deployment-profile.ts
+var DEFAULT_WINDOW_MS = 6e4;
+var DEFAULT_DAY_MS = 864e5;
+function createSmallSelfHostedAbuseProfile(input = {}) {
+  const windowMs = input.windowMs ?? DEFAULT_WINDOW_MS;
+  const publicWriteBudget = {
+    defaultCostUnits: 1,
+    limits: [
+      { scope: "did", unitsPerWindow: 12, windowMs },
+      { scope: "did-surface", unitsPerWindow: 4, windowMs },
+      { scope: "workspace", unitsPerWindow: 120, windowMs },
+      { scope: "hub", unitsPerWindow: 360, windowMs },
+      { scope: "surface", unitsPerWindow: 180, windowMs }
+    ]
+  };
+  const queryCostBudget = {
+    defaultCostUnits: 1,
+    limits: [
+      { scope: "domain-work-type", unitsPerWindow: 18, windowMs },
+      { scope: "remote-peer-route", unitsPerWindow: 24, windowMs },
+      { scope: "hub-work-type", unitsPerWindow: 240, windowMs },
+      { scope: "work-type", unitsPerWindow: 480, windowMs }
+    ]
+  };
+  return {
+    id: input.hubId ? `xnet.abuse.profile.small-self-hosted.v1:${input.hubId}` : "xnet.abuse.profile.small-self-hosted.v1",
+    kind: "small-self-hosted-hub",
+    title: "Small self-hosted hub abuse profile",
+    moderation: {
+      mode: "local-deterministic",
+      requireSignedWrites: true,
+      rejectUnsignedFederation: true,
+      quarantineFirstContact: true,
+      allowLocalOverride: true,
+      publishLabelExplanations: true,
+      aiReview: {
+        localModelsEnabled: true,
+        cloudModelsEnabled: false,
+        rawContentToCloudAllowed: false,
+        defaultReviewQueue: "safety"
+      }
+    },
+    cloudReview: { enabled: false },
+    publicWriteBudget,
+    queryCostBudget,
+    budgetHints: createDeploymentBudgetHints(
+      "small-self-hosted",
+      publicWriteBudget,
+      queryCostBudget
+    )
+  };
+}
+function createPublicSearchHubAbuseProfile(input = {}) {
+  const windowMs = input.windowMs ?? 36e5;
+  const cloudReviewDailyMicroUsd = input.cloudReviewDailyMicroUsd ?? 25e4;
+  const moderationReviewUnitsPerWindow = input.moderationReviewUnitsPerWindow ?? 600;
+  const searchIndexUnitsPerWindow = input.searchIndexUnitsPerWindow ?? 1e4;
+  const publicWriteBudget = {
+    defaultCostUnits: 1,
+    limits: [
+      { scope: "did", unitsPerWindow: 60, windowMs },
+      { scope: "did-surface", unitsPerWindow: 20, windowMs },
+      { scope: "workspace", unitsPerWindow: 1e3, windowMs },
+      { scope: "hub", unitsPerWindow: 2e4, windowMs },
+      { scope: "surface", unitsPerWindow: 5e3, windowMs }
+    ]
+  };
+  const queryCostBudget = {
+    defaultCostUnits: 1,
+    limits: [
+      { scope: "domain-work-type", unitsPerWindow: 120, windowMs },
+      { scope: "remote-peer-route", unitsPerWindow: 300, windowMs },
+      { scope: "hub-work-type", unitsPerWindow: 5e3, windowMs },
+      { scope: "work-type", unitsPerWindow: 1e4, windowMs }
+    ]
+  };
+  return {
+    id: input.hubId ? `xnet.abuse.profile.public-search.v1:${input.hubId}` : "xnet.abuse.profile.public-search.v1",
+    kind: "public-search-hub",
+    title: "Public search hub abuse profile",
+    moderation: {
+      mode: "hybrid",
+      requireSignedWrites: true,
+      rejectUnsignedFederation: true,
+      quarantineFirstContact: true,
+      allowLocalOverride: true,
+      publishLabelExplanations: true,
+      aiReview: {
+        localModelsEnabled: true,
+        cloudModelsEnabled: true,
+        rawContentToCloudAllowed: false,
+        maxCloudReviewMicroUsdPerDay: cloudReviewDailyMicroUsd,
+        defaultReviewQueue: "quality"
+      }
+    },
+    cloudReview: {
+      enabled: true,
+      allowedSurfaces: ["crawl", "searchIndex"],
+      minLocalLabelConfidence: 0.7,
+      minLocalQualityRisk: 0.55
+    },
+    publicWriteBudget,
+    queryCostBudget,
+    budgetHints: [
+      ...createDeploymentBudgetHints("public-search", publicWriteBudget, queryCostBudget),
+      {
+        name: "public-search:search-index:domain",
+        workType: "search-index",
+        scope: "domain",
+        unitsPerWindow: searchIndexUnitsPerWindow,
+        windowMs
+      },
+      {
+        name: "public-search:search-index:hub",
+        workType: "search-index",
+        scope: "hub",
+        unitsPerWindow: searchIndexUnitsPerWindow * 10,
+        windowMs
+      },
+      {
+        name: "public-search:moderation-review:safety",
+        workType: "moderation-review",
+        scope: "review-queue:safety",
+        unitsPerWindow: moderationReviewUnitsPerWindow,
+        windowMs
+      },
+      {
+        name: "public-search:cloud-review:daily",
+        workType: "cloud-review",
+        scope: "hub",
+        unitsPerWindow: cloudReviewDailyMicroUsd,
+        windowMs: DEFAULT_DAY_MS
+      }
+    ]
+  };
+}
+function createDeploymentBudgetHints(prefix, publicWriteBudget, queryCostBudget) {
+  return [
+    ...publicWriteBudget.limits.map((limit) => ({
+      name: `${prefix}:${limit.scope}`,
+      workType: "public-write",
+      scope: limit.scope,
+      unitsPerWindow: limit.unitsPerWindow,
+      windowMs: limit.windowMs
+    })),
+    ...queryCostBudget.limits.flatMap(
+      (limit) => budgetHintWorkTypes(limit.scope).map((workType) => ({
+        name: `${prefix}:${limit.scope}:${workType}`,
+        workType,
+        scope: limit.scope,
+        unitsPerWindow: limit.unitsPerWindow,
+        windowMs: limit.windowMs
+      }))
+    )
+  ];
+}
+function budgetHintWorkTypes(scope) {
+  if (scope.includes("domain")) return ["crawl"];
+  if (scope.includes("remote-peer") || scope.includes("route")) return ["federation-query"];
+  return ["crawl", "federation-query"];
+}
+
+// src/citation-coverage.ts
+function extractCitationReferences(input) {
+  const referenceTargets = extractReferenceTargets(input.body);
+  const citationCandidates = [
+    ...extractMarkdownLinkCitations(input.body),
+    ...extractReferenceUsageCitations(input.body, referenceTargets),
+    ...extractBareUrlCitations(input.body),
+    ...extractDoiCitations(input.body)
+  ];
+  return dedupeCitations(citationCandidates);
+}
+function extractKnowledgeClaims(input, options = {}) {
+  const citations = extractCitationReferences(input);
+  return extractKnowledgeClaimsWithCitations(input, citations, options);
+}
+function scoreClaimCitationCoverage(input, options = {}) {
+  const citations = extractCitationReferences(input);
+  const claims = extractKnowledgeClaimsWithCitations(input, citations, options);
+  const citedClaimCount = claims.filter((claim) => claim.citationRefs.length > 0).length;
+  const unsupportedClaimCount = Math.max(0, claims.length - citedClaimCount);
+  const citationCoverage = claims.length === 0 ? 1 : citedClaimCount / claims.length;
+  const unsupportedEvidence = claims.filter((claim) => claim.citationRefs.length === 0).map((claim) => `claim:${claim.id}:unsupported`);
+  return {
+    claims,
+    citations,
+    citationCoverage,
+    citedClaimCount,
+    unsupportedClaimCount,
+    claimCount: claims.length,
+    quality: {
+      citationCoverage
+    },
+    evidenceRefs: unsupportedEvidence,
+    reviewEvidenceRefs: unsupportedEvidence,
+    treatment: "review-evidence"
+  };
+}
+var DEFAULT_MIN_CLAIM_CHARS = 28;
+var DEFAULT_CITATION_WINDOW_CHARS = 80;
+var DEFAULT_MAX_CLAIMS = 100;
+var factualVerbPattern = /\b(is|are|was|were|has|have|had|will|would|can|could|causes?|caused|increases?|increased|decreases?|decreased|reduces?|reduced|shows?|showed|found|finds|reports?|reported|announced|confirmed|banned|requires?|required|grew|fell|rose|reached|hit)\b/i;
+var numberOrDatePattern = /\b(\d+(?:[.,]\d+)?%?|\d{4}|jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:tember)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\b/i;
+var capitalizedPhrasePattern = /\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+){0,3}\b/;
+var citationNeededPattern = /\[(citation needed|source needed|needs source)\]/i;
+function extractKnowledgeClaimsWithCitations(input, citations, options) {
+  const minClaimChars = options.minClaimChars ?? DEFAULT_MIN_CLAIM_CHARS;
+  const maxClaims = options.maxClaims ?? DEFAULT_MAX_CLAIMS;
+  const citationWindowChars = options.citationWindowChars ?? DEFAULT_CITATION_WINDOW_CHARS;
+  const bodyWithoutReferenceDefinitions = removeReferenceDefinitions(input.body);
+  return splitSentences(bodyWithoutReferenceDefinitions).map((sentence) => scoreSentenceAsClaim(sentence, minClaimChars)).filter(
+    (claim) => claim !== null
+  ).slice(0, maxClaims).map((claim, index) => {
+    const citationRefs = findClaimCitationRefs(claim, citations, citationWindowChars);
+    const id = `claim-${index + 1}`;
+    return {
+      ...claim,
+      id,
+      citationRefs,
+      evidenceRefs: citationRefs.length > 0 ? citationRefs.map((citationId) => `citation:${citationId}`) : [`claim:${id}:unsupported`]
+    };
+  });
+}
+function scoreSentenceAsClaim(sentence, minClaimChars) {
+  const text = normalizeClaimText(sentence.text);
+  if (text.length < minClaimChars) return null;
+  if (isStructuralMarkdownLine(text)) return null;
+  const featureCount = [
+    factualVerbPattern.test(text),
+    numberOrDatePattern.test(text),
+    capitalizedPhrasePattern.test(text),
+    citationNeededPattern.test(text)
+  ].filter(Boolean).length;
+  if (featureCount < 2) return null;
+  return {
+    text,
+    startIndex: sentence.startIndex,
+    endIndex: sentence.endIndex,
+    confidence: clamp(0.35 + featureCount * 0.15, 0, 0.95)
+  };
+}
+function findClaimCitationRefs(claim, citations, citationWindowChars) {
+  return citations.filter((citation) => {
+    const insideClaim = citation.startIndex >= claim.startIndex && citation.endIndex <= claim.endIndex;
+    const nearbyAfterClaim = citation.startIndex > claim.endIndex && citation.startIndex - claim.endIndex <= citationWindowChars;
+    return insideClaim || nearbyAfterClaim;
+  }).map((citation) => citation.id);
+}
+function splitSentences(text) {
+  const sentences = [];
+  let startIndex = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    const isBoundary = char === "." || char === "!" || char === "?";
+    if (!isBoundary || next !== void 0 && !/\s/.test(next)) continue;
+    sentences.push({
+      text: text.slice(startIndex, index + 1),
+      startIndex,
+      endIndex: index + 1
+    });
+    startIndex = skipWhitespace(text, index + 1);
+    index = startIndex - 1;
+  }
+  if (startIndex < text.length) {
+    sentences.push({
+      text: text.slice(startIndex),
+      startIndex,
+      endIndex: text.length
+    });
+  }
+  return sentences.filter((sentence) => sentence.text.trim().length > 0);
+}
+function extractReferenceTargets(body) {
+  return Array.from(body.matchAll(/^\s*\[([^\]]+)\]:\s*(\S+)/gm)).reduce((targets, match) => {
+    const label = normalizeReferenceLabel(match[1]);
+    const target = match[2]?.trim();
+    if (label && target) targets.set(label, target);
+    return targets;
+  }, /* @__PURE__ */ new Map());
+}
+function extractMarkdownLinkCitations(body) {
+  return Array.from(body.matchAll(/\[([^\]]+)\]\((https?:\/\/[^)\s]+|doi:[^)]+)\)/gi)).map(
+    (match, index) => createCitation({
+      id: `md-${index + 1}`,
+      kind: "markdown-link",
+      label: match[1] ?? "",
+      target: match[2] ?? "",
+      startIndex: match.index ?? 0,
+      endIndex: (match.index ?? 0) + match[0].length
+    })
+  );
+}
+function extractReferenceUsageCitations(body, referenceTargets) {
+  return Array.from(body.matchAll(/\[([^\]\n]+)\]/g)).filter((match) => !isInsideReferenceDefinition(body, match.index ?? 0)).filter((match) => !citationNeededPattern.test(match[0])).map((match) => ({
+    match,
+    label: normalizeReferenceLabel(match[1])
+  })).filter(({ label }) => referenceTargets.has(label)).map(
+    ({ match, label }, index) => createCitation({
+      id: `ref-${index + 1}`,
+      kind: label.startsWith("^") ? "footnote-link" : "reference-link",
+      label,
+      target: referenceTargets.get(label) ?? "",
+      startIndex: match.index ?? 0,
+      endIndex: (match.index ?? 0) + match[0].length
+    })
+  );
+}
+function extractBareUrlCitations(body) {
+  return Array.from(body.matchAll(/\bhttps?:\/\/[^\s)\]]+/gi)).filter((match) => !isInsideReferenceDefinition(body, match.index ?? 0)).map(
+    (match, index) => createCitation({
+      id: `url-${index + 1}`,
+      kind: "bare-url",
+      label: match[0],
+      target: match[0],
+      startIndex: match.index ?? 0,
+      endIndex: (match.index ?? 0) + match[0].length
+    })
+  );
+}
+function extractDoiCitations(body) {
+  return Array.from(body.matchAll(/\b10\.\d{4,9}\/[-._;()/:A-Z0-9]+\b/gi)).filter((match) => !isInsideReferenceDefinition(body, match.index ?? 0)).map(
+    (match, index) => createCitation({
+      id: `doi-${index + 1}`,
+      kind: "doi",
+      label: match[0],
+      target: `doi:${match[0]}`,
+      startIndex: match.index ?? 0,
+      endIndex: (match.index ?? 0) + match[0].length
+    })
+  );
+}
+function createCitation(input) {
+  return {
+    ...input,
+    domain: getCitationDomain(input.target)
+  };
+}
+function dedupeCitations(citations) {
+  const seen = /* @__PURE__ */ new Set();
+  return [...citations].sort(compareCitationPriority).reduce((deduped, citation) => {
+    const overlapsStructuredCitation = deduped.some(
+      (existing) => existing.target === citation.target && rangesOverlap(existing, citation) && citationKindPriority(existing.kind) <= citationKindPriority(citation.kind)
+    );
+    if (overlapsStructuredCitation) return deduped;
+    const key = `${citation.startIndex}:${citation.endIndex}:${citation.target}`;
+    if (seen.has(key)) return deduped;
+    seen.add(key);
+    return [...deduped, citation];
+  }, []).sort((left, right) => left.startIndex - right.startIndex);
+}
+function compareCitationPriority(left, right) {
+  return citationKindPriority(left.kind) - citationKindPriority(right.kind) || left.startIndex - right.startIndex;
+}
+function citationKindPriority(kind) {
+  if (kind === "markdown-link") return 0;
+  if (kind === "reference-link") return 1;
+  if (kind === "footnote-link") return 1;
+  if (kind === "doi") return 2;
+  return 3;
+}
+function rangesOverlap(left, right) {
+  return left.startIndex < right.endIndex && right.startIndex < left.endIndex;
+}
+function removeReferenceDefinitions(body) {
+  return body.replace(/^\s*\[[^\]]+\]:\s*\S+.*$/gm, "");
+}
+function isInsideReferenceDefinition(body, index) {
+  const lineStart = body.lastIndexOf("\n", Math.max(0, index - 1)) + 1;
+  const lineEndIndex = body.indexOf("\n", index);
+  const lineEnd = lineEndIndex === -1 ? body.length : lineEndIndex;
+  return /^\s*\[[^\]]+\]:\s*\S+/.test(body.slice(lineStart, lineEnd));
+}
+function skipWhitespace(text, startIndex) {
+  let index = startIndex;
+  while (index < text.length && /\s/.test(text[index] ?? "")) {
+    index += 1;
+  }
+  return index;
+}
+function normalizeClaimText(text) {
+  return text.replace(/\s+/g, " ").replace(/^[#>*\-\d.\s]+/, "").trim();
+}
+function isStructuralMarkdownLine(text) {
+  return /^(#{1,6}\s+|[-*]\s*$|```|:::)/.test(text);
+}
+function normalizeReferenceLabel(label) {
+  return (label ?? "").trim().toLowerCase();
+}
+function getCitationDomain(target) {
+  if (target.startsWith("doi:")) return "doi.org";
+  try {
+    return new URL(target).hostname.toLowerCase().replace(/^www\./, "");
+  } catch {
+    return void 0;
+  }
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+// src/labeler-trust.ts
+var TRUST_LEVEL_PRIORITY = {
+  blocked: 4,
+  trusted: 3,
+  review: 2,
+  observe: 1
+};
+function evaluateLabelerTrust(input, settings) {
+  const now = input.now ?? Date.now();
+  const setting = selectLabelerTrustSetting(input, settings, now);
+  if (!setting) {
+    return {
+      accepted: false,
+      action: "ignore",
+      reasons: ["labeler:unconfigured"],
+      level: "unconfigured",
+      effectiveWeight: 0,
+      minConfidence: 1
+    };
+  }
+  if (setting.level === "blocked" || includesLabel(setting.deniedLabels, input.labelValue)) {
+    return createTrustDecision(setting, "reject", ["labeler:blocked"]);
+  }
+  if (setting.allowedLabels && !includesLabel(setting.allowedLabels, input.labelValue)) {
+    return createTrustDecision(setting, "ignore", ["labeler:label-not-allowed"]);
+  }
+  if (input.confidence < setting.minConfidence) {
+    return createTrustDecision(setting, "review", ["labeler:confidence-too-low"]);
+  }
+  if (setting.level === "observe") {
+    return createTrustDecision(setting, "observe", ["labeler:observe-only"]);
+  }
+  if (setting.level === "review") {
+    return createTrustDecision(setting, "review", ["labeler:review-required"]);
+  }
+  return createTrustDecision(setting, "accept", ["labeler:trusted"]);
+}
+function createTrustedLabelFromSetting(input, settings) {
+  const decision = evaluateLabelerTrust(input, settings);
+  if (!decision.accepted) return null;
+  return {
+    value: input.labelValue,
+    sourceDID: input.labelerDID,
+    sourceWeight: decision.effectiveWeight,
+    confidence: clamp012(input.confidence),
+    expiresAt: input.labelExpiresAt,
+    evidenceRefs: input.evidenceRefs
+  };
+}
+function evaluateReportEscalation(input, settings) {
+  const evidenceRefs = createReportEvidenceRefs(input);
+  const trustInput = {
+    scope: input.scope,
+    scopeId: input.scopeId,
+    labelerDID: input.reporterDID,
+    labelValue: input.labelValue,
+    confidence: input.confidence,
+    evidenceRefs,
+    labelExpiresAt: input.labelExpiresAt,
+    now: input.now
+  };
+  const trustDecision = evaluateLabelerTrust(trustInput, settings);
+  if (!trustDecision.accepted) {
+    return {
+      canAffectVisibility: false,
+      trustDecision,
+      trustedLabel: null,
+      evidenceRefs
+    };
+  }
+  return {
+    canAffectVisibility: true,
+    trustDecision,
+    trustedLabel: {
+      value: input.labelValue,
+      sourceDID: input.reporterDID,
+      sourceWeight: trustDecision.effectiveWeight,
+      confidence: clamp012(input.confidence),
+      expiresAt: input.labelExpiresAt,
+      evidenceRefs
+    },
+    evidenceRefs
+  };
+}
+function createLabelerSubscription(input) {
+  return {
+    id: input.id,
+    labelerDID: input.labelerDID,
+    workspaceId: input.workspaceId,
+    hubId: input.hubId,
+    status: input.status ?? "active",
+    createdAt: input.createdAt ?? Date.now(),
+    expiresAt: input.expiresAt
+  };
+}
+function evaluateLabelerSubscriptionLimit(input, policy, subscriptions = []) {
+  const now = input.now ?? Date.now();
+  const active = subscriptions.filter(
+    (subscription) => subscription.status === "active" && subscription.id !== input.id && (subscription.expiresAt === void 0 || subscription.expiresAt > now)
+  );
+  const activeCounts = {
+    workspace: countSubscriptions(active, { workspaceId: input.workspaceId }),
+    hub: countSubscriptions(active, { hubId: input.hubId }),
+    workspaceLabeler: countSubscriptions(active, {
+      workspaceId: input.workspaceId,
+      labelerDID: input.labelerDID
+    }),
+    hubLabeler: countSubscriptions(active, {
+      hubId: input.hubId,
+      labelerDID: input.labelerDID
+    })
+  };
+  const reasons = [
+    exceeds(policy.maxWorkspaceSubscriptions, activeCounts.workspace) ? "labeler-subscription:workspace-limit-exceeded" : null,
+    exceeds(policy.maxHubSubscriptions, activeCounts.hub) ? "labeler-subscription:hub-limit-exceeded" : null,
+    exceeds(policy.maxWorkspaceSubscriptionsPerLabeler, activeCounts.workspaceLabeler) ? "labeler-subscription:workspace-labeler-limit-exceeded" : null,
+    exceeds(policy.maxHubSubscriptionsPerLabeler, activeCounts.hubLabeler) ? "labeler-subscription:hub-labeler-limit-exceeded" : null
+  ].filter((reason) => reason !== null);
+  return {
+    allowed: reasons.length === 0,
+    reasons: reasons.length > 0 ? reasons : ["labeler-subscription:accepted"],
+    activeCounts,
+    nextSubscription: reasons.length === 0 ? createLabelerSubscription({
+      id: input.id,
+      labelerDID: input.labelerDID,
+      workspaceId: input.workspaceId,
+      hubId: input.hubId,
+      createdAt: now
+    }) : void 0
+  };
+}
+function trustLevelFromWeight(weight, enabled) {
+  if (!enabled || weight <= 0) return "blocked";
+  if (weight >= 0.75) return "trusted";
+  if (weight >= 0.4) return "review";
+  return "observe";
+}
+function runtimeScope(scope) {
+  return scope === "hub" ? "hub" : "workspace";
+}
+function subscriptionToTrustSetting(sub, scopeId) {
+  const enabled = sub.enabled !== false;
+  const weight = clamp012(sub.trust);
+  return {
+    scope: runtimeScope(sub.scope),
+    scopeId,
+    labelerDID: sub.labelerDID,
+    level: trustLevelFromWeight(weight, enabled),
+    weight,
+    minConfidence: sub.minConfidence ?? 0.5,
+    allowedLabels: sub.allowedLabels,
+    deniedLabels: sub.deniedLabels,
+    maxLabelsPerSubject: sub.maxLabelsPerSubject,
+    expiresAt: sub.expiresAt
+  };
+}
+function subscriptionsToTrustSettings(subs, scopeId, now = Date.now()) {
+  return subs.filter((sub) => sub.expiresAt === void 0 || sub.expiresAt > now).map((sub) => subscriptionToTrustSetting(sub, scopeId));
+}
+function selectLabelerTrustSetting(input, settings, now) {
+  return settings.filter(
+    (setting) => setting.scope === input.scope && setting.scopeId === input.scopeId && setting.labelerDID === input.labelerDID && (setting.expiresAt === void 0 || setting.expiresAt > now)
+  ).sort(
+    (left, right) => TRUST_LEVEL_PRIORITY[right.level] - TRUST_LEVEL_PRIORITY[left.level] || right.weight - left.weight
+  )[0] ?? null;
+}
+function createTrustDecision(setting, action, reasons) {
+  return {
+    accepted: action === "accept",
+    action,
+    reasons,
+    level: setting.level,
+    effectiveWeight: action === "accept" ? clamp012(setting.weight) : 0,
+    minConfidence: setting.minConfidence,
+    setting
+  };
+}
+function includesLabel(labels, label) {
+  return Boolean(labels?.includes(label));
+}
+function createReportEvidenceRefs(input) {
+  return [`abuse-report:${input.reportId}`, ...input.evidenceRefs ?? []];
+}
+function countSubscriptions(subscriptions, filter) {
+  if (!filter.workspaceId && !filter.hubId) return 0;
+  return subscriptions.filter(
+    (subscription) => (filter.workspaceId === void 0 || subscription.workspaceId === filter.workspaceId) && (filter.hubId === void 0 || subscription.hubId === filter.hubId) && (filter.labelerDID === void 0 || subscription.labelerDID === filter.labelerDID)
+  ).length;
+}
+function exceeds(limit, currentCount) {
+  return typeof limit === "number" && currentCount >= limit;
+}
+function clamp012(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(1, Math.max(0, value));
+}
+
+// src/community-notes.ts
+function summarizeCommunityNoteAgreement(ratings, options = {}) {
+  const normalized = ratings.map(normalizeRating);
+  const perspectives = summarizePerspectives(normalized);
+  const effectiveWeight = normalized.reduce((total, rating) => total + rating.weight, 0);
+  const helpfulWeight = sumHelpfulness(normalized, "helpful");
+  const notHelpfulWeight = sumHelpfulness(normalized, "not-helpful") + sumHelpfulness(normalized, "irrelevant");
+  const needsSourceWeight = sumHelpfulness(normalized, "needs-source");
+  const irrelevantWeight = sumHelpfulness(normalized, "irrelevant");
+  const helpfulScore = ratio(helpfulWeight, effectiveWeight);
+  const notHelpfulScore = ratio(notHelpfulWeight, effectiveWeight);
+  const needsSourceScore = ratio(needsSourceWeight, effectiveWeight);
+  const irrelevantScore = ratio(irrelevantWeight, effectiveWeight);
+  const supportingPerspectives = perspectives.filter(
+    (perspective) => perspective.helpfulWeight > 0 && perspective.helpfulWeight >= perspective.notHelpfulWeight + perspective.needsSourceWeight + perspective.irrelevantWeight
+  );
+  const diversityScore = scorePerspectiveDiversity(
+    supportingPerspectives.map((perspective) => perspective.helpfulWeight)
+  );
+  const agreementScore = helpfulScore * diversityScore;
+  const status = resolveCommunityNoteAgreementStatus({
+    ratingCount: normalized.length,
+    helpfulRatings: normalized.filter((rating) => rating.helpfulness === "helpful").length,
+    supportingPerspectiveCount: supportingPerspectives.length,
+    helpfulScore,
+    notHelpfulScore,
+    diversityScore,
+    options
+  });
+  return {
+    status,
+    ratingCount: normalized.length,
+    effectiveWeight,
+    helpfulScore,
+    notHelpfulScore,
+    needsSourceScore,
+    irrelevantScore,
+    diversityScore,
+    agreementScore,
+    supportingPerspectiveCount: supportingPerspectives.length,
+    perspectiveCount: perspectives.length,
+    perspectives,
+    reasons: createCommunityNoteAgreementReasons(status, {
+      ratingCount: normalized.length,
+      helpfulRatings: normalized.filter((rating) => rating.helpfulness === "helpful").length,
+      supportingPerspectiveCount: supportingPerspectives.length,
+      diversityScore,
+      options
+    })
+  };
+}
+function groupCommunityNoteRatingsByPerspective(ratings) {
+  return ratings.reduce((groups, rating) => {
+    const perspective = normalizePerspective(rating);
+    const existing = groups.get(perspective) ?? [];
+    groups.set(perspective, [...existing, rating]);
+    return groups;
+  }, /* @__PURE__ */ new Map());
+}
+function scoreCommunityNotePerspectiveDiversity(ratings) {
+  return scorePerspectiveDiversity(
+    summarizePerspectives(ratings.map(normalizeRating)).map(
+      (perspective) => perspective.helpfulWeight
+    )
+  );
+}
+function isCommunityNoteAgreementVisible(summary) {
+  return summary.status === "helpful";
+}
+var DEFAULT_MIN_RATINGS = 5;
+var DEFAULT_MIN_HELPFUL_RATINGS = 3;
+var DEFAULT_MIN_PERSPECTIVE_GROUPS = 2;
+var DEFAULT_MIN_DIVERSITY_SCORE = 0.45;
+var DEFAULT_HELPFUL_THRESHOLD = 0.68;
+var DEFAULT_NOT_HELPFUL_THRESHOLD = 0.62;
+var DEFAULT_CONTESTED_THRESHOLD = 0.3;
+function normalizeRating(rating) {
+  return {
+    ...rating,
+    confidence: clamp2(rating.confidence, 0, 1),
+    sourceWeight: clamp2(rating.sourceWeight ?? 1, 0.25, 4),
+    weight: clamp2(rating.confidence, 0, 1) * clamp2(rating.sourceWeight ?? 1, 0.25, 4),
+    perspectiveKey: normalizePerspective(rating)
+  };
+}
+function summarizePerspectives(ratings) {
+  return Array.from(
+    ratings.reduce((groups, rating) => {
+      const existing = groups.get(rating.perspectiveKey) ?? {
+        perspective: rating.perspectiveKey,
+        ratingCount: 0,
+        helpfulWeight: 0,
+        notHelpfulWeight: 0,
+        needsSourceWeight: 0,
+        irrelevantWeight: 0
+      };
+      groups.set(rating.perspectiveKey, addRatingToPerspective(existing, rating));
+      return groups;
+    }, /* @__PURE__ */ new Map()).values()
+  ).sort((left, right) => left.perspective.localeCompare(right.perspective));
+}
+function addRatingToPerspective(perspective, rating) {
+  return {
+    ...perspective,
+    ratingCount: perspective.ratingCount + 1,
+    helpfulWeight: perspective.helpfulWeight + (rating.helpfulness === "helpful" ? rating.weight : 0),
+    notHelpfulWeight: perspective.notHelpfulWeight + (rating.helpfulness === "not-helpful" ? rating.weight : 0),
+    needsSourceWeight: perspective.needsSourceWeight + (rating.helpfulness === "needs-source" ? rating.weight : 0),
+    irrelevantWeight: perspective.irrelevantWeight + (rating.helpfulness === "irrelevant" ? rating.weight : 0)
+  };
+}
+function resolveCommunityNoteAgreementStatus(input) {
+  const minRatings = input.options.minRatings ?? DEFAULT_MIN_RATINGS;
+  const minHelpfulRatings = input.options.minHelpfulRatings ?? DEFAULT_MIN_HELPFUL_RATINGS;
+  const minPerspectiveGroups = input.options.minPerspectiveGroups ?? DEFAULT_MIN_PERSPECTIVE_GROUPS;
+  const minDiversityScore = input.options.minDiversityScore ?? DEFAULT_MIN_DIVERSITY_SCORE;
+  const helpfulThreshold = input.options.helpfulThreshold ?? DEFAULT_HELPFUL_THRESHOLD;
+  const notHelpfulThreshold = input.options.notHelpfulThreshold ?? DEFAULT_NOT_HELPFUL_THRESHOLD;
+  const contestedThreshold = input.options.contestedThreshold ?? DEFAULT_CONTESTED_THRESHOLD;
+  if (input.ratingCount < minRatings) return "insufficient";
+  if (input.notHelpfulScore >= notHelpfulThreshold && input.helpfulScore < helpfulThreshold) {
+    return "not-helpful";
+  }
+  if (input.helpfulScore >= helpfulThreshold && input.notHelpfulScore >= contestedThreshold) {
+    return "contested";
+  }
+  if (input.helpfulScore < helpfulThreshold || input.helpfulRatings < minHelpfulRatings) {
+    return "insufficient";
+  }
+  if (input.supportingPerspectiveCount < minPerspectiveGroups || input.diversityScore < minDiversityScore) {
+    return "needs-more-diversity";
+  }
+  return "helpful";
+}
+function createCommunityNoteAgreementReasons(status, input) {
+  if (status === "helpful") return ["diverse-helpful-agreement"];
+  if (status === "not-helpful") return ["not-helpful-consensus"];
+  if (status === "contested") return ["contested-ratings"];
+  if (status === "needs-more-diversity") return ["helpful-but-not-diverse"];
+  return [
+    input.ratingCount < (input.options.minRatings ?? DEFAULT_MIN_RATINGS) ? "below-min-ratings" : null,
+    input.helpfulRatings < (input.options.minHelpfulRatings ?? DEFAULT_MIN_HELPFUL_RATINGS) ? "below-min-helpful-ratings" : null,
+    input.supportingPerspectiveCount < (input.options.minPerspectiveGroups ?? DEFAULT_MIN_PERSPECTIVE_GROUPS) ? "below-min-perspective-groups" : null,
+    input.diversityScore < (input.options.minDiversityScore ?? DEFAULT_MIN_DIVERSITY_SCORE) ? "below-min-diversity-score" : null
+  ].filter((reason) => reason !== null);
+}
+function scorePerspectiveDiversity(weights) {
+  const positiveWeights = weights.filter((weight) => weight > 0);
+  const total = positiveWeights.reduce((sum, weight) => sum + weight, 0);
+  if (positiveWeights.length <= 1 || total <= 0) return 0;
+  const entropy = positiveWeights.reduce((sum, weight) => {
+    const probability = weight / total;
+    return sum - probability * Math.log2(probability);
+  }, 0);
+  return clamp2(entropy / Math.log2(positiveWeights.length), 0, 1);
+}
+function sumHelpfulness(ratings, helpfulness) {
+  return ratings.filter((rating) => rating.helpfulness === helpfulness).reduce((total, rating) => total + rating.weight, 0);
+}
+function ratio(numerator, denominator) {
+  if (denominator <= 0) return 0;
+  return numerator / denominator;
+}
+function normalizePerspective(rating) {
+  return rating.perspective?.trim().toLowerCase().replace(/\s+/g, "-") || rating.raterDID || "unknown";
+}
+function clamp2(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+// src/staged-writes.ts
+function planStagedModerationWrites(candidates, policy = {}, options = {}) {
+  const now = options.now ?? Date.now();
+  const writes = candidates.map(
+    (candidate, index) => createStagedModerationWrite(candidate, policy, now, index)
+  );
+  const staged = boundReviewQueue(
+    writes.filter((write) => write.status === "staged"),
+    policy,
+    now
+  );
+  const committed = writes.filter((write) => write.status === "committed");
+  const rejected = writes.filter((write) => write.status === "rejected");
+  return {
+    staged: staged.staged,
+    committed,
+    rejected: [...rejected, ...staged.rejected],
+    materialized: committed.flatMap((write) => materializeStagedModerationWrite(write) ?? []),
+    reviewTasks: staged.staged.map((write) => createReviewTaskForStagedWrite(write, now))
+  };
+}
+function approveStagedModerationWrite(write, reviewerDID, options = {}) {
+  const now = options.now ?? Date.now();
+  return {
+    ...write,
+    status: "committed",
+    reviewRequired: false,
+    committedAt: now,
+    committedBy: reviewerDID
+  };
+}
+function rejectStagedModerationWrite(write, reviewerDID, reason, options = {}) {
+  const now = options.now ?? Date.now();
+  return {
+    ...write,
+    status: "rejected",
+    reviewRequired: false,
+    rejectedAt: now,
+    rejectedBy: reviewerDID,
+    rejectionReason: reason
+  };
+}
+function materializeStagedModerationWrite(write) {
+  if (write.status !== "committed") return null;
+  return {
+    targetId: write.targetId,
+    targetSchema: write.targetSchema,
+    kind: write.kind,
+    value: write.value,
+    score: write.score,
+    confidence: clamp3(write.confidence, 0, 1),
+    sourceType: write.sourceType,
+    sourceDID: write.sourceDID,
+    sourceWeight: clamp3(write.sourceWeight ?? 1, 0, 10),
+    evidenceRefs: [...write.evidenceRefs ?? []],
+    modelProvider: write.modelProvider,
+    modelName: write.modelName,
+    modelVersion: write.modelVersion,
+    expiresAt: write.expiresAt
+  };
+}
+var DEFAULT_MIN_STAGE_CONFIDENCE = 0.15;
+var DEFAULT_AUTO_COMMIT_CONFIDENCE = 0.9;
+var DEFAULT_AUTO_COMMIT_SOURCES = ["deterministic", "human", "policy-list"];
+var DEFAULT_REVIEW_SOURCES = ["local-ai", "cloud-ai", "report"];
+function boundReviewQueue(staged, policy, now) {
+  if (policy.maxReviewTasks === void 0 && policy.maxReviewTasksBySource === void 0) {
+    return { staged: [...staged], rejected: [] };
+  }
+  const maxReviewTasks = Math.max(0, policy.maxReviewTasks ?? Number.POSITIVE_INFINITY);
+  const sourceCounts = /* @__PURE__ */ new Map();
+  const acceptedIds = /* @__PURE__ */ new Set();
+  const ranked = [...staged].sort(
+    (left, right) => reviewPriority(right, now) - reviewPriority(left, now) || left.createdAt - right.createdAt || left.id.localeCompare(right.id)
+  );
+  for (const write of ranked) {
+    const sourceLimit = policy.maxReviewTasksBySource?.[write.sourceType];
+    const currentSourceCount = sourceCounts.get(write.sourceType) ?? 0;
+    if (acceptedIds.size >= maxReviewTasks) continue;
+    if (sourceLimit !== void 0 && currentSourceCount >= Math.max(0, sourceLimit)) continue;
+    acceptedIds.add(write.id);
+    sourceCounts.set(write.sourceType, currentSourceCount + 1);
+  }
+  return {
+    staged: staged.filter((write) => acceptedIds.has(write.id)),
+    rejected: staged.filter((write) => !acceptedIds.has(write.id)).map((write) => rejectReviewOverflow(write, now))
+  };
+}
+function rejectReviewOverflow(write, now) {
+  return {
+    ...write,
+    status: "rejected",
+    reviewRequired: false,
+    rejectedAt: now,
+    rejectionReason: `review-queue-overflow:${write.sourceType}`
+  };
+}
+function createStagedModerationWrite(candidate, policy, now, index) {
+  const confidence = clamp3(candidate.confidence, 0, 1);
+  const minStageConfidence = policy.minStageConfidence ?? DEFAULT_MIN_STAGE_CONFIDENCE;
+  const provenanceValidation = validateAISignalProvenance(candidate);
+  const reviewRequired = requiresReview(candidate, policy);
+  const status = resolveInitialStatus(candidate, confidence, reviewRequired, policy);
+  const finalStatus = confidence < minStageConfidence || !provenanceValidation.valid ? "rejected" : status;
+  const id = candidate.id ?? `staged-write-${index + 1}`;
+  return {
+    ...candidate,
+    id,
+    confidence,
+    evidenceRefs: createEvidenceRefsWithProvenance(candidate),
+    sourceWeight: candidate.sourceWeight ?? policy.defaultSourceWeight ?? 1,
+    status: finalStatus,
+    createdAt: now,
+    stagedAt: finalStatus === "staged" ? now : void 0,
+    committedAt: finalStatus === "committed" ? now : void 0,
+    reviewRequired: finalStatus === "staged" && reviewRequired,
+    reviewQueue: finalStatus === "staged" ? policy.reviewQueueByKind?.[candidate.kind] ?? defaultQueue(candidate) : void 0,
+    rejectedAt: finalStatus === "rejected" ? now : void 0,
+    rejectionReason: createRejectionReason(
+      confidence,
+      minStageConfidence,
+      provenanceValidation.errors
+    ),
+    expiresAt: candidate.expiresAt ?? (finalStatus === "staged" && policy.stagedExpiresInMs ? now + policy.stagedExpiresInMs : void 0)
+  };
+}
+function createEvidenceRefsWithProvenance(candidate) {
+  const provenanceRef = createAISignalProvenanceEvidenceRef(candidate);
+  return provenanceRef ? [.../* @__PURE__ */ new Set([...candidate.evidenceRefs ?? [], provenanceRef])] : [...candidate.evidenceRefs ?? []];
+}
+function createRejectionReason(confidence, minStageConfidence, provenanceErrors) {
+  if (provenanceErrors.length > 0) return `missing-ai-provenance:${provenanceErrors.join(",")}`;
+  if (confidence < minStageConfidence) return "below-min-stage-confidence";
+  return void 0;
+}
+function resolveInitialStatus(candidate, confidence, reviewRequired, policy) {
+  if (reviewRequired) return "staged";
+  const autoCommitSources = new Set(policy.autoCommitSources ?? DEFAULT_AUTO_COMMIT_SOURCES);
+  const autoCommitConfidence = policy.autoCommitConfidence ?? DEFAULT_AUTO_COMMIT_CONFIDENCE;
+  return autoCommitSources.has(candidate.sourceType) && confidence >= autoCommitConfidence ? "committed" : "staged";
+}
+function requiresReview(candidate, policy) {
+  if (candidate.sourceType === "crawler" && policy.allowCrawlerAutoCommit !== true) {
+    return true;
+  }
+  const reviewSources = new Set(policy.requireReviewSources ?? DEFAULT_REVIEW_SOURCES);
+  return reviewSources.has(candidate.sourceType);
+}
+function createReviewTaskForStagedWrite(write, now) {
+  const queue = write.reviewQueue ?? defaultQueue(write);
+  return {
+    id: `review-${write.id}`,
+    stagedWriteId: write.id,
+    targetId: write.targetId,
+    queue,
+    priority: reviewPriority(write, now),
+    reasons: reviewReasons(write)
+  };
+}
+function defaultQueue(write) {
+  return write.kind === "quality-signal" ? "quality" : "safety";
+}
+function reviewPriority(write, now) {
+  const confidencePriority = Math.round(clamp3(write.confidence, 0, 1) * 70);
+  const expiryPriority = write.expiresAt && write.expiresAt < now + 24 * 60 * 60 * 1e3 ? 20 : 0;
+  const cloudPriority = write.sourceType === "cloud-ai" ? 10 : 0;
+  return clamp3(confidencePriority + expiryPriority + cloudPriority, 0, 100);
+}
+function reviewReasons(write) {
+  return [
+    write.sourceType === "local-ai" || write.sourceType === "cloud-ai" ? "ai-generated" : null,
+    write.sourceType === "crawler" ? "untrusted-crawl" : null,
+    write.kind === "quality-signal" ? "quality-signal" : "moderation-label",
+    `source:${write.sourceType}`,
+    `confidence:${write.confidence.toFixed(2)}`
+  ].filter((reason) => reason !== null);
+}
+function clamp3(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+// src/appeals.ts
+function createAppealEffect(input) {
+  const evidenceRefs = createAppealEvidenceRefs(input);
+  const baseAnnotation = {
+    appealId: input.appealId,
+    targetId: input.targetId,
+    status: input.status,
+    action: resolveAppealEffectAction(input),
+    appellantDID: input.appellantDID,
+    reviewerDID: input.reviewerDID,
+    decisionId: input.decisionId,
+    appealedLabelId: input.appealedLabelId,
+    resolution: input.resolution,
+    evidenceRefs
+  };
+  if (baseAnnotation.action !== "reverse") {
+    return {
+      action: baseAnnotation.action,
+      annotation: baseAnnotation,
+      labelsToApply: [],
+      reasons: createAppealReasons(baseAnnotation)
+    };
+  }
+  return {
+    action: "reverse",
+    annotation: baseAnnotation,
+    labelsToApply: [
+      {
+        id: `appeal-reversal:${input.appealId}`,
+        value: "safe",
+        sourceDID: input.reviewerDID,
+        sourceWeight: clamp4(input.sourceWeight ?? 1, 0, 10),
+        confidence: clamp4(input.confidence ?? 1, 0, 1),
+        expiresAt: input.expiresAt,
+        evidenceRefs,
+        negates: input.appealedLabelId
+      }
+    ],
+    reasons: createAppealReasons(baseAnnotation)
+  };
+}
+function resolveAppealEffectAction(input) {
+  if (input.status !== "accepted") {
+    return input.status === "rejected" ? "annotate" : "none";
+  }
+  if (input.action !== "reverse") return "annotate";
+  if (!input.reviewerDID || !input.appealedLabelId) return "annotate";
+  return "reverse";
+}
+function createAppealEvidenceRefs(input) {
+  return [
+    `appeal:${input.appealId}`,
+    input.decisionId ? `decision:${input.decisionId}` : null,
+    input.appealedLabelId ? `label:${input.appealedLabelId}` : null,
+    ...input.evidenceRefs ?? []
+  ].filter((ref) => ref !== null);
+}
+function createAppealReasons(annotation) {
+  return [
+    `appeal:${annotation.status}`,
+    annotation.action === "reverse" ? "appeal:reversal-label" : null,
+    annotation.action === "annotate" ? "appeal:annotation-only" : null,
+    annotation.action === "none" ? "appeal:no-effect" : null
+  ].filter((reason) => reason !== null);
+}
+function clamp4(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+// src/policy-blocks.ts
+import { base64ToBytes, bytesToBase64, sign, verify } from "@xnetjs/crypto";
+import { parseDID } from "@xnetjs/identity";
+var encoder2 = new TextEncoder();
+var isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+var toJsonValue = (value) => {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(toJsonValue);
+  }
+  if (isRecord(value)) {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, entryValue]) => typeof entryValue !== "undefined").sort(([a], [b]) => a.localeCompare(b)).map(([key, entryValue]) => [key, toJsonValue(entryValue)])
+    );
+  }
+  return String(value);
+};
+var canonicalizePolicyBlockList = (list) => JSON.stringify(toJsonValue(list));
+var policyBlockListSigningBytes = (list) => encoder2.encode(canonicalizePolicyBlockList(list));
+var isSignedPolicyBlockList = (list) => isRecord(list) && list.v === 1 && list.kind === "xnet.policy.block-list" && isRecord(list.signature) && list.signature.alg === "Ed25519" && typeof list.signature.value === "string";
+var createPolicyBlockList = (input) => {
+  const now = Date.now();
+  return {
+    v: 1,
+    kind: "xnet.policy.block-list",
+    createdAt: input.createdAt ?? now,
+    updatedAt: input.updatedAt ?? input.createdAt ?? now,
+    id: input.id,
+    title: input.title,
+    scope: input.scope,
+    issuerDID: input.issuerDID,
+    entries: input.entries
+  };
+};
+var signPolicyBlockList = (list, signingKey) => ({
+  ...list,
+  signature: {
+    alg: "Ed25519",
+    value: bytesToBase64(sign(policyBlockListSigningBytes(list), signingKey))
+  }
+});
+var unsignedPolicyBlockList = (list) => ({
+  v: list.v,
+  kind: list.kind,
+  id: list.id,
+  title: list.title,
+  scope: list.scope,
+  issuerDID: list.issuerDID,
+  createdAt: list.createdAt,
+  updatedAt: list.updatedAt,
+  entries: list.entries
+});
+var verifySignedPolicyBlockList = (list) => {
+  const errors = [];
+  try {
+    const publicKey = parseDID(list.issuerDID);
+    const signature = base64ToBytes(list.signature.value);
+    const valid = verify(
+      policyBlockListSigningBytes(unsignedPolicyBlockList(list)),
+      signature,
+      publicKey
+    );
+    if (!valid) {
+      errors.push("invalid-signature");
+    }
+  } catch (err) {
+    errors.push(err instanceof Error ? err.message : String(err));
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+};
+var policyBlockEntryIsActive = (entry, now = Date.now()) => typeof entry.expiresAt !== "number" || entry.expiresAt > now;
+var auditPolicyBlockEntries = (list, now = Date.now()) => list.entries.map((entry) => {
+  const active = policyBlockEntryIsActive(entry, now);
+  return {
+    ...entry,
+    active,
+    expired: !active
+  };
+});
+var findPolicyBlockAuditEntry = (list, subject, subjectType, now = Date.now()) => auditPolicyBlockEntries(list, now).find(
+  (entry) => entry.subject === subject && entry.subjectType === subjectType
+) ?? null;
+var activePolicyBlockEntries = (list, now = Date.now()) => list.entries.filter((entry) => policyBlockEntryIsActive(entry, now));
+var findPolicyBlockEntry = (list, subject, subjectType, now = Date.now()) => activePolicyBlockEntries(list, now).find(
+  (entry) => entry.subject === subject && entry.subjectType === subjectType
+) ?? null;
+var policyBlockOverrideEntryIsActive = (entry, now = Date.now()) => typeof entry.expiresAt !== "number" || entry.expiresAt > now;
+var resolveSubscribedPolicyBlockLists = (input) => {
+  const now = input.now ?? Date.now();
+  const activeOverrides = (input.localOverrides ?? []).filter(
+    (entry) => policyBlockOverrideEntryIsActive(entry, now)
+  );
+  const resolvedEntries = input.lists.flatMap(
+    (list) => activePolicyBlockEntries(list, now).map(
+      (entry) => resolvePolicyBlockEntry(list, entry, activeOverrides)
+    )
+  );
+  return {
+    enforcedEntries: resolvedEntries.filter((entry) => !entry.overridden),
+    overriddenEntries: resolvedEntries.filter((entry) => entry.overridden),
+    activeOverrides
+  };
+};
+function resolvePolicyBlockEntry(list, entry, overrides) {
+  const matchingOverrides = overrides.filter(
+    (override) => override.subject === entry.subject && override.subjectType === entry.subjectType
+  );
+  return {
+    ...entry,
+    listId: list.id,
+    listScope: list.scope,
+    issuerDID: list.issuerDID,
+    overridden: matchingOverrides.length > 0,
+    overrideRefs: matchingOverrides.map(policyBlockOverrideRef)
+  };
+}
+function policyBlockOverrideRef(entry) {
+  return entry.id ? `policy-override:${entry.scope}:${entry.id}` : `policy-override:${entry.scope}:${entry.subjectType}:${entry.subject}`;
+}
+
+// src/hub-policy-offer.ts
+import { base64ToBytes as base64ToBytes2, bytesToBase64 as bytesToBase642, sign as sign2, verify as verify2 } from "@xnetjs/crypto";
+import { parseDID as parseDID2 } from "@xnetjs/identity";
+var encoder3 = new TextEncoder();
+var DEFAULT_AI_REVIEW_SETTINGS = {
+  localModelsEnabled: true,
+  cloudModelsEnabled: false,
+  rawContentToCloudAllowed: false
+};
+var DEFAULT_LABEL_SETTINGS = {
+  trustedLabelerDIDs: [],
+  subscribedPolicyListIds: [],
+  allowLabelNegation: true
+};
+var DEFAULT_MODERATION_SETTINGS = {
+  mode: "local-deterministic",
+  requireSignedWrites: true,
+  rejectUnsignedFederation: true,
+  quarantineFirstContact: true,
+  allowLocalOverride: true,
+  publishLabelExplanations: true,
+  defaultVisibility: "warn",
+  defaultReach: "demote",
+  aiReview: DEFAULT_AI_REVIEW_SETTINGS,
+  labels: DEFAULT_LABEL_SETTINGS
+};
+var createHubPolicyServiceOffer = (input) => {
+  const now = Date.now();
+  const createdAt = input.createdAt ?? now;
+  const moderation = mergeModerationSettings(input.moderation);
+  return {
+    v: 1,
+    kind: "xnet.hub.policy-service-offer",
+    id: input.id,
+    hubDID: input.hubDID,
+    issuerDID: input.issuerDID,
+    title: input.title,
+    createdAt,
+    updatedAt: input.updatedAt ?? createdAt,
+    expiresAt: input.expiresAt,
+    moderation,
+    services: input.services,
+    budgetHints: input.budgetHints ?? [],
+    policyRefs: input.policyRefs ?? [],
+    operatorContact: input.operatorContact,
+    appealChannels: input.appealChannels ?? []
+  };
+};
+var canonicalizeHubPolicyServiceOffer = (offer) => JSON.stringify(toJsonValue2(offer));
+var hubPolicyServiceOfferSigningBytes = (offer) => encoder3.encode(canonicalizeHubPolicyServiceOffer(offer));
+var signHubPolicyServiceOffer = (offer, signingKey) => ({
+  ...offer,
+  signature: {
+    alg: "Ed25519",
+    value: bytesToBase642(sign2(hubPolicyServiceOfferSigningBytes(offer), signingKey))
+  }
+});
+var unsignedHubPolicyServiceOffer = (offer) => ({
+  v: offer.v,
+  kind: offer.kind,
+  id: offer.id,
+  hubDID: offer.hubDID,
+  issuerDID: offer.issuerDID,
+  title: offer.title,
+  createdAt: offer.createdAt,
+  updatedAt: offer.updatedAt,
+  expiresAt: offer.expiresAt,
+  moderation: offer.moderation,
+  services: offer.services,
+  budgetHints: offer.budgetHints,
+  policyRefs: offer.policyRefs,
+  operatorContact: offer.operatorContact,
+  appealChannels: offer.appealChannels
+});
+var isSignedHubPolicyServiceOffer = (offer) => isRecord2(offer) && offer.v === 1 && offer.kind === "xnet.hub.policy-service-offer" && isRecord2(offer.signature) && offer.signature.alg === "Ed25519" && typeof offer.signature.value === "string";
+var validateHubPolicyServiceOffer = (offer, now = Date.now()) => {
+  const errors = [
+    ...requiredString("id", offer.id),
+    ...requiredString("hubDID", offer.hubDID),
+    ...requiredString("issuerDID", offer.issuerDID),
+    ...validateTimestamps(offer, now),
+    ...validateModerationSettings(offer.moderation),
+    ...offer.services.length === 0 ? ["services-required"] : [],
+    ...offer.budgetHints.flatMap(validateBudgetHint),
+    ...validateOperatorContact(offer.operatorContact),
+    ...validateAppealChannels(offer)
+  ];
+  return { valid: errors.length === 0, errors };
+};
+var verifySignedHubPolicyServiceOffer = (offer, now = Date.now()) => {
+  const unsigned = unsignedHubPolicyServiceOffer(offer);
+  const errors = [...validateHubPolicyServiceOffer(unsigned, now).errors];
+  try {
+    const publicKey = parseDID2(offer.issuerDID);
+    const signature = base64ToBytes2(offer.signature.value);
+    const valid = verify2(hubPolicyServiceOfferSigningBytes(unsigned), signature, publicKey);
+    if (!valid) {
+      errors.push("invalid-signature");
+    }
+  } catch (err) {
+    errors.push(err instanceof Error ? err.message : String(err));
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+};
+var activeHubPolicyServices = (offer) => offer.services.filter((service) => service.enabled);
+var publicAppealChannels = (offer) => offer.appealChannels.filter(
+  (channel) => ["email", "web-form", "xnet-message", "external-ticket"].includes(channel.kind)
+);
+function mergeModerationSettings(settings) {
+  return {
+    ...DEFAULT_MODERATION_SETTINGS,
+    ...settings,
+    aiReview: {
+      ...DEFAULT_AI_REVIEW_SETTINGS,
+      ...settings?.aiReview
+    },
+    labels: {
+      ...DEFAULT_LABEL_SETTINGS,
+      ...settings?.labels
+    }
+  };
+}
+var isRecord2 = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+var toJsonValue2 = (value) => {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(toJsonValue2);
+  }
+  if (isRecord2(value)) {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, entryValue]) => typeof entryValue !== "undefined").sort(([a], [b]) => a.localeCompare(b)).map(([key, entryValue]) => [key, toJsonValue2(entryValue)])
+    );
+  }
+  return String(value);
+};
+function requiredString(field, value) {
+  return value.trim().length === 0 ? [`${field}-required`] : [];
+}
+function validateTimestamps(offer, now) {
+  return [
+    offer.updatedAt < offer.createdAt ? "updated-before-created" : null,
+    typeof offer.expiresAt === "number" && offer.expiresAt <= now ? "expired" : null,
+    typeof offer.expiresAt === "number" && offer.expiresAt <= offer.createdAt ? "expires-before-created" : null
+  ].filter((error) => error !== null);
+}
+function validateModerationSettings(settings) {
+  return [
+    settings.aiReview.rawContentToCloudAllowed && !settings.aiReview.cloudModelsEnabled ? "raw-cloud-review-without-cloud-models" : null,
+    settings.labels.maxLabelsPerSubject !== void 0 && settings.labels.maxLabelsPerSubject <= 0 ? "max-labels-per-subject-invalid" : null
+  ].filter((error) => error !== null);
+}
+function validateBudgetHint(hint) {
+  return [
+    hint.name.trim().length === 0 ? "budget-name-required" : null,
+    hint.scope.trim().length === 0 ? "budget-scope-required" : null,
+    hint.unitsPerWindow <= 0 ? "budget-units-invalid" : null,
+    hint.windowMs <= 0 ? "budget-window-invalid" : null
+  ].filter((error) => error !== null);
+}
+function validateOperatorContact(contact) {
+  if (!contact) return [];
+  return [
+    contact.responseTimeHours !== void 0 && contact.responseTimeHours <= 0 ? "operator-response-time-invalid" : null,
+    contact.email !== void 0 && !contact.email.includes("@") ? "operator-email-invalid" : null
+  ].filter((error) => error !== null);
+}
+function validateAppealChannels(offer) {
+  const appealServiceEnabled = offer.services.some(
+    (service) => service.service === "appeal" && service.enabled
+  );
+  return [
+    appealServiceEnabled && offer.appealChannels.length === 0 ? "appeal-channel-required" : null,
+    ...offer.appealChannels.flatMap(validateAppealChannel)
+  ].filter((error) => error !== null);
+}
+function validateAppealChannel(channel) {
+  return [
+    channel.kind === "web-form" && !channel.url ? "appeal-web-form-url-required" : null,
+    channel.kind === "external-ticket" && !channel.url ? "appeal-ticket-url-required" : null,
+    channel.kind === "email" && !channel.email ? "appeal-email-required" : null,
+    channel.kind === "xnet-message" && !channel.recipientDID ? "appeal-recipient-did-required" : null,
+    channel.email !== void 0 && !channel.email.includes("@") ? "appeal-email-invalid" : null,
+    channel.maxResponseTimeHours !== void 0 && channel.maxResponseTimeHours <= 0 ? "appeal-response-time-invalid" : null,
+    channel.minResponseTimeHours !== void 0 && channel.maxResponseTimeHours !== void 0 && channel.minResponseTimeHours > channel.maxResponseTimeHours ? "appeal-response-window-invalid" : null
+  ].filter((error) => error !== null);
+}
+
+// src/sensitivity.ts
+var sensitivityLabels = [
+  { id: "sexual", name: "Sexually suggestive", defaultVisibility: "warn" },
+  { id: "nudity", name: "Non-sexual nudity", defaultVisibility: "show" },
+  { id: "porn", name: "Explicit / pornographic", defaultVisibility: "hide" },
+  { id: "graphic-media", name: "Graphic / violent", defaultVisibility: "warn" }
+];
+var SENSITIVITY_LABEL_VALUES = sensitivityLabels.map(
+  (label) => label.id
+);
+var SENSITIVITY_LABEL_SET = new Set(SENSITIVITY_LABEL_VALUES);
+function isSensitivityLabelValue(value) {
+  return SENSITIVITY_LABEL_SET.has(value);
+}
+var SENSITIVITY_SOURCE_WEIGHT = {
+  self: 0.5,
+  ml: 0.3,
+  report: 0.15,
+  labeler: 0.05
+};
+var SENSITIVITY_PRESENCE_FLOOR = 0.15;
+var DEFAULT_SENSITIVITY_PREFERENCES = {
+  adultContentEnabled: false,
+  ageConfirmed: false,
+  labels: {},
+  blurUnsolicitedMedia: true
+};
+function buildSensitivityLabel(input) {
+  return {
+    id: input.id,
+    value: input.value,
+    sourceDID: input.sourceDID,
+    sourceWeight: SENSITIVITY_SOURCE_WEIGHT[input.source],
+    confidence: clamp013(input.confidence),
+    expiresAt: input.expiresAt,
+    evidenceRefs: input.evidenceRefs
+  };
+}
+function activeSensitivityLabels(labels, now) {
+  const active = labels.filter(
+    (label) => isSensitivityLabelValue(label.value) && (label.expiresAt === void 0 || label.expiresAt > now)
+  );
+  const negated = new Set(
+    labels.flatMap((label) => label.negates !== void 0 ? [label.negates] : [])
+  );
+  return active.filter((label) => label.id === void 0 || !negated.has(label.id));
+}
+function assessSensitivity(labels, options = {}) {
+  const now = options.now ?? Date.now();
+  const floor = options.presenceFloor ?? SENSITIVITY_PRESENCE_FLOOR;
+  const scores = /* @__PURE__ */ new Map();
+  for (const label of activeSensitivityLabels(labels, now)) {
+    const value = label.value;
+    scores.set(value, (scores.get(value) ?? 0) + label.confidence * label.sourceWeight);
+  }
+  const present = /* @__PURE__ */ new Map();
+  for (const [value, score] of scores) {
+    if (score >= floor) {
+      present.set(value, score);
+    }
+  }
+  return { present, values: [...present.keys()] };
+}
+var VISIBILITY_RANK = {
+  show: 0,
+  warn: 1,
+  blur: 2,
+  hide: 3
+};
+function strictestVisibility(a, b) {
+  return VISIBILITY_RANK[a] >= VISIBILITY_RANK[b] ? a : b;
+}
+var ADULT_LABELS = /* @__PURE__ */ new Set(["sexual", "nudity", "porn"]);
+function defaultVisibilityFor(value) {
+  return sensitivityLabels.find((label) => label.id === value).defaultVisibility;
+}
+function decideSensitivityVisibility(labels, preferences = DEFAULT_SENSITIVITY_PREFERENCES, options = {}) {
+  const assessment = assessSensitivity(labels, options);
+  const adultEnabled = preferences.adultContentEnabled && preferences.ageConfirmed;
+  let visibility = "show";
+  for (const value of assessment.values) {
+    if (!adultEnabled && ADULT_LABELS.has(value)) {
+      visibility = strictestVisibility(visibility, "hide");
+      continue;
+    }
+    const pref = preferences.labels[value] ?? defaultVisibilityFor(value);
+    visibility = strictestVisibility(visibility, pref);
+  }
+  if (visibility === "show" && options.unsolicitedMedia === true && (preferences.blurUnsolicitedMedia ?? true)) {
+    return "blur";
+  }
+  return visibility;
+}
+function explainSensitivityVisibility(labels, preferences = DEFAULT_SENSITIVITY_PREFERENCES, options = {}) {
+  const assessment = assessSensitivity(labels, options);
+  const adultEnabled = preferences.adultContentEnabled && preferences.ageConfirmed;
+  const reasons = [];
+  let visibility = "show";
+  for (const value of assessment.values) {
+    if (!adultEnabled && ADULT_LABELS.has(value)) {
+      visibility = strictestVisibility(visibility, "hide");
+      reasons.push({ label: value, effect: "hide", cause: "adult-disabled" });
+      continue;
+    }
+    const pref = preferences.labels[value] ?? defaultVisibilityFor(value);
+    visibility = strictestVisibility(visibility, pref);
+    reasons.push({ label: value, effect: pref, cause: "dial" });
+  }
+  if (visibility === "show" && options.unsolicitedMedia === true && (preferences.blurUnsolicitedMedia ?? true)) {
+    visibility = "blur";
+    reasons.push({ effect: "blur", cause: "unsolicited-media" });
+  }
+  return { visibility, reasons };
+}
+function sensitivityOverride(labels, preferences = DEFAULT_SENSITIVITY_PREFERENCES, options = {}) {
+  const visibility = decideSensitivityVisibility(labels, preferences, options);
+  if (visibility === "show") {
+    return void 0;
+  }
+  return { scope: "user", visibility, reason: "sensitivity-preference" };
+}
+function resolveContentVisibility(decision, labels, preferences = DEFAULT_SENSITIVITY_PREFERENCES, options = {}) {
+  const sensitivity = decideSensitivityVisibility(labels, preferences, options);
+  return strictestVisibility(decision.visibility, sensitivity);
+}
+function clamp013(value) {
+  return Math.min(1, Math.max(0, value));
+}
+
+// src/image-fingerprint.ts
+function resample(image, size) {
+  const out = new Array(size * size).fill(0);
+  if (image.width === 0 || image.height === 0) return out;
+  for (let oy = 0; oy < size; oy++) {
+    const y0 = Math.floor(oy * image.height / size);
+    const y1 = Math.max(y0 + 1, Math.floor((oy + 1) * image.height / size));
+    for (let ox = 0; ox < size; ox++) {
+      const x0 = Math.floor(ox * image.width / size);
+      const x1 = Math.max(x0 + 1, Math.floor((ox + 1) * image.width / size));
+      let sum = 0;
+      let count = 0;
+      for (let y = y0; y < y1 && y < image.height; y++) {
+        for (let x = x0; x < x1 && x < image.width; x++) {
+          sum += image.luma[y * image.width + x] ?? 0;
+          count++;
+        }
+      }
+      out[oy * size + ox] = count > 0 ? sum / count : 0;
+    }
+  }
+  return out;
+}
+function bitsToHex(bits) {
+  let hex = "";
+  for (let i = 0; i < bits.length; i += 4) {
+    let nibble = 0;
+    for (let b = 0; b < 4; b++) {
+      if (bits[i + b]) nibble |= 1 << 3 - b;
+    }
+    hex += nibble.toString(16);
+  }
+  return hex;
+}
+function averageHash(image) {
+  const px = resample(image, 8);
+  const mean = px.reduce((sum, value) => sum + value, 0) / px.length;
+  return bitsToHex(px.map((value) => value >= mean));
+}
+function differenceHash(image) {
+  const w = 9;
+  const h = 8;
+  const px = resample(image, Math.max(w, h));
+  const grid = resampleGrid(image, w, h);
+  void px;
+  const bits = [];
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w - 1; x++) {
+      bits.push(grid[y * w + x] > grid[y * w + x + 1]);
+    }
+  }
+  return bitsToHex(bits);
+}
+function resampleGrid(image, w, h) {
+  const out = new Array(w * h).fill(0);
+  if (image.width === 0 || image.height === 0) return out;
+  for (let oy = 0; oy < h; oy++) {
+    const y = Math.min(image.height - 1, Math.floor(oy * image.height / h));
+    for (let ox = 0; ox < w; ox++) {
+      const x = Math.min(image.width - 1, Math.floor(ox * image.width / w));
+      out[oy * w + ox] = image.luma[y * image.width + x] ?? 0;
+    }
+  }
+  return out;
+}
+function perceptualHash(image) {
+  const N = 32;
+  const px = resample(image, N);
+  const dct = dct2d(px, N);
+  const coeffs = [];
+  for (let y = 0; y < 8; y++) {
+    for (let x = 0; x < 8; x++) {
+      if (x === 0 && y === 0) continue;
+      coeffs.push(dct[y * N + x]);
+    }
+  }
+  const median = medianOf(coeffs);
+  return bitsToHex(coeffs.map((value) => value > median));
+}
+function dct2d(input, n) {
+  const cos = [];
+  for (let u = 0; u < n; u++) {
+    cos[u] = [];
+    for (let x = 0; x < n; x++) {
+      cos[u][x] = Math.cos((2 * x + 1) * u * Math.PI / (2 * n));
+    }
+  }
+  const temp = new Array(n * n).fill(0);
+  for (let y = 0; y < n; y++) {
+    for (let u = 0; u < n; u++) {
+      let sum = 0;
+      for (let x = 0; x < n; x++) sum += input[y * n + x] * cos[u][x];
+      temp[y * n + u] = sum;
+    }
+  }
+  const out = new Array(n * n).fill(0);
+  for (let u = 0; u < n; u++) {
+    for (let v = 0; v < n; v++) {
+      let sum = 0;
+      for (let y = 0; y < n; y++) sum += temp[y * n + v] * cos[u][y];
+      out[u * n + v] = sum;
+    }
+  }
+  return out;
+}
+function medianOf(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+var HEX_BITS = (() => {
+  const map = {};
+  for (let i = 0; i < 16; i++) {
+    map[i.toString(16)] = (i & 1) + (i >> 1 & 1) + (i >> 2 & 1) + (i >> 3 & 1);
+  }
+  return map;
+})();
+function hammingDistanceHex(a, b) {
+  const len = Math.min(a.length, b.length);
+  let distance = Math.abs(a.length - b.length) * 4;
+  for (let i = 0; i < len; i++) {
+    distance += HEX_BITS[(parseInt(a[i], 16) ^ parseInt(b[i], 16)).toString(16)] ?? 0;
+  }
+  return distance;
+}
+function imageHashSimilarity(a, b) {
+  const bits = Math.max(a.length, b.length) * 4;
+  if (bits === 0) return 1;
+  return 1 - hammingDistanceHex(a, b) / bits;
+}
+function matchKnownImageHash(hash2, known, maxHammingBits = 8) {
+  let best = null;
+  for (const entry of known) {
+    const distance = hammingDistanceHex(hash2, entry.hash);
+    if (distance <= maxHammingBits && (best === null || distance < best.distance)) {
+      best = { label: entry.label, source: entry.source, distance };
+    }
+  }
+  return best;
+}
+
+// src/local-image-classifier.ts
+function mapNsfwLabelToSensitivity(label) {
+  const normalized = label.trim().toLowerCase();
+  switch (normalized) {
+    case "porn":
+    case "explicit":
+    case "hentai":
+      return "porn";
+    case "sexy":
+    case "suggestive":
+    case "sexual":
+      return "sexual";
+    case "nudity":
+    case "nude":
+      return "nudity";
+    case "gore":
+    case "graphic":
+    case "graphic-media":
+    case "violence":
+      return "graphic-media";
+    case "neutral":
+    case "normal":
+    case "drawing":
+    case "safe":
+      return null;
+    default:
+      return isSensitivityLabelValue(normalized) ? normalized : null;
+  }
+}
+var DEFAULT_THRESHOLD = 0.5;
+function createNsfwImageClassifier(options) {
+  const id = options.id ?? "local.image.nsfw";
+  const version = options.version ?? "1";
+  const threshold = options.threshold ?? DEFAULT_THRESHOLD;
+  const provenance = {
+    provider: "local",
+    adapterId: id,
+    adapterVersion: version,
+    model: options.model
+  };
+  return {
+    id,
+    version,
+    model: options.model,
+    supports(input) {
+      const mediaKind = input.metadata?.mediaKind;
+      return typeof mediaKind === "string" && mediaKind.startsWith("image") || input.metadata?.image !== void 0;
+    },
+    async classify(input) {
+      const detections = await options.detect({ metadata: input.metadata });
+      const byValue = /* @__PURE__ */ new Map();
+      for (const detection of detections) {
+        const value = mapNsfwLabelToSensitivity(detection.label);
+        if (value === null || detection.score < threshold) continue;
+        const existing = byValue.get(value);
+        if (!existing || detection.score > existing.score) {
+          byValue.set(value, detection);
+        }
+      }
+      const labels = [...byValue.entries()].map(
+        ([value, detection]) => buildSensitivityLabel({
+          value,
+          source: "ml",
+          confidence: detection.score,
+          sourceDID: options.sourceDid,
+          evidenceRefs: [`nsfw-model:${detection.label}:${detection.score.toFixed(2)}`]
+        })
+      );
+      const signals = labels.map((label) => ({
+        kind: "label",
+        value: label.value,
+        confidence: label.confidence,
+        evidenceRefs: [...label.evidenceRefs ?? []],
+        provenance
+      }));
+      return createLocalClassificationResult({ labels, signals, provenance });
+    }
+  };
+}
+
+// src/image-prescreen.ts
+var DEFAULT_EXPLICIT_WARN_THRESHOLD = 0.7;
+var DEFAULT_SUGGEST_THRESHOLD = 0.4;
+var CLEAN_RESULT = {
+  recommendation: "allow",
+  suggestedLabel: null,
+  confidence: 0,
+  labels: []
+};
+function strongestSensitivityLabel(labels) {
+  let strongest = null;
+  for (const label of labels) {
+    if (!isSensitivityLabelValue(label.value)) continue;
+    if (!strongest || label.confidence > strongest.confidence) strongest = label;
+  }
+  return strongest;
+}
+function prescreenImageLabels(labels, options = {}) {
+  const explicitWarn = options.explicitWarnThreshold ?? DEFAULT_EXPLICIT_WARN_THRESHOLD;
+  const suggest = options.suggestThreshold ?? DEFAULT_SUGGEST_THRESHOLD;
+  const strongest = strongestSensitivityLabel(labels);
+  if (!strongest) return CLEAN_RESULT;
+  const value = strongest.value;
+  const confidence = strongest.confidence;
+  if (value === "porn" && confidence >= explicitWarn) {
+    return { recommendation: "warn-explicit", suggestedLabel: value, confidence, labels };
+  }
+  if (confidence >= suggest) {
+    return { recommendation: "suggest-label", suggestedLabel: value, confidence, labels };
+  }
+  return { recommendation: "allow", suggestedLabel: null, confidence, labels };
+}
+async function prescreenImage(classifier, input, options = {}) {
+  if (classifier.supports && !classifier.supports(input)) return CLEAN_RESULT;
+  const result = await classifier.classify(input);
+  return prescreenImageLabels(result.labels, options);
+}
+
+// src/public-write-budget.ts
+function evaluatePublicWriteBudget(input, policy, usage = []) {
+  const now = input.now ?? Date.now();
+  const costUnits = Math.max(0, input.costUnits ?? policy.defaultCostUnits ?? 1);
+  const activeUsage = usage.filter((entry) => entry.resetAt > now);
+  const charges = policy.limits.flatMap(
+    (limit) => createPublicWriteBudgetCharge(input, limit, activeUsage, costUnits, now) ?? []
+  );
+  const exceeded = charges.filter((charge) => charge.usedUnits + costUnits > charge.limitUnits);
+  if (exceeded.length > 0) {
+    return {
+      allowed: false,
+      resource: "require-budget",
+      reasons: exceeded.map((charge) => `budget:${charge.scope}:exceeded`),
+      charges,
+      nextUsage: activeUsage
+    };
+  }
+  return {
+    allowed: true,
+    resource: "normal",
+    reasons: ["budget:accepted"],
+    charges,
+    nextUsage: mergePublicWriteBudgetCharges(activeUsage, charges, costUnits)
+  };
+}
+function createPublicWriteBudgetKey(input, scope) {
+  if (scope === "did") return input.did ? `did:${input.did}` : null;
+  if (scope === "hub") return input.hubId ? `hub:${input.hubId}` : null;
+  if (scope === "workspace") {
+    return input.workspaceId ? `workspace:${input.workspaceId}` : null;
+  }
+  if (scope === "surface") return `surface:${input.surface}`;
+  if (scope === "did-surface") {
+    return input.did ? `did:${input.did}:surface:${input.surface}` : null;
+  }
+  if (scope === "hub-surface") {
+    return input.hubId ? `hub:${input.hubId}:surface:${input.surface}` : null;
+  }
+  return input.workspaceId ? `workspace:${input.workspaceId}:surface:${input.surface}` : null;
+}
+function createPublicWriteBudgetCharge(input, limit, usage, costUnits, now) {
+  const key = createPublicWriteBudgetKey(input, limit.scope);
+  if (!key) return null;
+  const existing = usage.find((entry) => entry.key === key && entry.scope === limit.scope);
+  return {
+    key,
+    scope: limit.scope,
+    costUnits,
+    usedUnits: existing?.usedUnits ?? 0,
+    limitUnits: limit.unitsPerWindow,
+    resetAt: existing?.resetAt ?? now + limit.windowMs
+  };
+}
+function mergePublicWriteBudgetCharges(usage, charges, costUnits) {
+  const chargedKeys = new Set(charges.map((charge) => `${charge.scope}:${charge.key}`));
+  return [
+    ...usage.filter((entry) => !chargedKeys.has(`${entry.scope}:${entry.key}`)),
+    ...charges.map((charge) => ({
+      key: charge.key,
+      scope: charge.scope,
+      usedUnits: charge.usedUnits + costUnits,
+      resetAt: charge.resetAt
+    }))
+  ].sort(
+    (left, right) => left.key.localeCompare(right.key) || left.scope.localeCompare(right.scope)
+  );
+}
+
+// src/query-cost-budget.ts
+function evaluateQueryCostBudget(input, policy, usage = []) {
+  const now = input.now ?? Date.now();
+  const costUnits = Math.max(0, input.costUnits ?? policy.defaultCostUnits ?? 1);
+  const activeUsage = usage.filter((entry) => entry.resetAt > now);
+  const charges = policy.limits.flatMap(
+    (limit) => createQueryCostBudgetCharge(input, limit, activeUsage, costUnits, now) ?? []
+  );
+  const exceeded = charges.filter((charge) => charge.usedUnits + costUnits > charge.limitUnits);
+  if (exceeded.length > 0) {
+    return {
+      allowed: false,
+      resource: "require-budget",
+      reasons: exceeded.map((charge) => `budget:${charge.scope}:exceeded`),
+      charges,
+      nextUsage: activeUsage
+    };
+  }
+  return {
+    allowed: true,
+    resource: "normal",
+    reasons: ["budget:accepted"],
+    charges,
+    nextUsage: mergeQueryCostBudgetCharges(activeUsage, charges, costUnits)
+  };
+}
+function createQueryCostBudgetKey(input, scope) {
+  const domain = normalizeDomain(input.domain);
+  const route = normalizeRoute(input.route);
+  if (scope === "actor") return input.actorDID ? `actor:${input.actorDID}` : null;
+  if (scope === "hub") return input.hubId ? `hub:${input.hubId}` : null;
+  if (scope === "workspace") return input.workspaceId ? `workspace:${input.workspaceId}` : null;
+  if (scope === "remote-peer") {
+    return input.remotePeerId ? `remote-peer:${input.remotePeerId}` : null;
+  }
+  if (scope === "domain") return domain ? `domain:${domain}` : null;
+  if (scope === "route") return route ? `route:${route}` : null;
+  if (scope === "work-type") return `work-type:${input.workType}`;
+  if (scope === "hub-work-type") {
+    return input.hubId ? `hub:${input.hubId}:work-type:${input.workType}` : null;
+  }
+  if (scope === "domain-work-type") {
+    return domain ? `domain:${domain}:work-type:${input.workType}` : null;
+  }
+  return input.remotePeerId && route ? `remote-peer:${input.remotePeerId}:route:${route}` : null;
+}
+function createQueryCostBudgetCharge(input, limit, usage, costUnits, now) {
+  const key = createQueryCostBudgetKey(input, limit.scope);
+  if (!key) return null;
+  const existing = usage.find((entry) => entry.key === key && entry.scope === limit.scope);
+  return {
+    key,
+    scope: limit.scope,
+    costUnits,
+    usedUnits: existing?.usedUnits ?? 0,
+    limitUnits: limit.unitsPerWindow,
+    resetAt: existing?.resetAt ?? now + limit.windowMs
+  };
+}
+function mergeQueryCostBudgetCharges(usage, charges, costUnits) {
+  const chargedKeys = new Set(charges.map((charge) => `${charge.scope}:${charge.key}`));
+  return [
+    ...usage.filter((entry) => !chargedKeys.has(`${entry.scope}:${entry.key}`)),
+    ...charges.map((charge) => ({
+      key: charge.key,
+      scope: charge.scope,
+      usedUnits: charge.usedUnits + costUnits,
+      resetAt: charge.resetAt
+    }))
+  ].sort(
+    (left, right) => left.key.localeCompare(right.key) || left.scope.localeCompare(right.scope)
+  );
+}
+function normalizeDomain(domain) {
+  const normalized = domain?.trim().toLowerCase().replace(/^www\./, "");
+  return normalized && normalized.length > 0 ? normalized : null;
+}
+function normalizeRoute(route) {
+  const normalized = route?.trim().replace(/\s+/g, "-").toLowerCase();
+  return normalized && normalized.length > 0 ? normalized : null;
+}
+
+// src/usage-events.ts
+import { hashBase64 } from "@xnetjs/crypto";
+var ABUSE_USAGE_EVENT_KINDS = [
+  "blocked",
+  "throttled",
+  "reviewed",
+  "billable",
+  "sponsored",
+  "reciprocal"
+];
+var ABUSE_USAGE_SETTLEMENTS = [
+  "free",
+  "paid",
+  "sponsored",
+  "reciprocal",
+  "abuse-blocked"
+];
+var DEFAULT_USAGE_EVENT_HASH_SALT = "xnet.abuse.usage.event.v1";
+function createAbuseUsageEvent(input) {
+  const settlement = input.settlement ?? settlementForKind(input.kind);
+  const units = nonNegative(input.units ?? 1);
+  const costMicroUsd = nonNegative(input.costMicroUsd ?? 0);
+  const sponsoredMicroUsd = sponsoredAmount(input.sponsoredMicroUsd, costMicroUsd, settlement);
+  const reciprocalCreditUnits = reciprocalUnits(input.reciprocalCreditUnits, units, settlement);
+  const eventWithoutId = {
+    kind: input.kind,
+    settlement,
+    surface: input.surface,
+    workType: input.workType,
+    actorHash: hashAbusePeerIdentifier(input.peerId ?? input.actorDID, input.identityHashSalt),
+    remotePeerHash: input.remotePeerId ? hashAbusePeerIdentifier(input.remotePeerId, input.identityHashSalt) : void 0,
+    labelerHash: input.labelerDID ? hashAbusePeerIdentifier(input.labelerDID, input.identityHashSalt) : void 0,
+    hubId: normalizedString(input.hubId),
+    workspaceId: normalizedString(input.workspaceId),
+    domain: normalizeDomain2(input.domain),
+    route: normalizeRoute2(input.route),
+    units,
+    costMicroUsd,
+    billableMicroUsd: settlement === "paid" ? Math.max(0, costMicroUsd - sponsoredMicroUsd) : 0,
+    sponsoredMicroUsd,
+    reciprocalCreditUnits,
+    resource: input.resource,
+    reviewQueue: input.reviewQueue,
+    reasonCodes: dedupe(input.reasonCodes ?? []),
+    policyId: normalizedString(input.policyId),
+    tags: normalizeTags(input.tags ?? []),
+    occurredAt: input.occurredAt ?? Date.now()
+  };
+  return {
+    ...eventWithoutId,
+    id: input.eventId ?? createAbuseUsageEventId(eventWithoutId, input.eventHashSalt)
+  };
+}
+function createAbuseUsageEventsFromDecision(input) {
+  const reasonCodes = input.decision.reasons.filter(
+    (reason) => reason !== "accepted"
+  );
+  const baseInput = {
+    surface: input.surface,
+    workType: input.workType,
+    actorDID: input.actorDID,
+    peerId: input.peerId,
+    remotePeerId: input.remotePeerId,
+    labelerDID: input.labelerDID,
+    hubId: input.hubId,
+    workspaceId: input.workspaceId,
+    domain: input.domain,
+    route: input.route,
+    units: input.units,
+    costMicroUsd: input.costMicroUsd,
+    sponsoredMicroUsd: input.sponsoredMicroUsd,
+    reciprocalCreditUnits: input.reciprocalCreditUnits,
+    policyId: input.policyId,
+    tags: input.tags,
+    occurredAt: input.occurredAt,
+    identityHashSalt: input.identityHashSalt,
+    eventHashSalt: input.eventHashSalt,
+    reasonCodes,
+    resource: input.decision.resource
+  };
+  const moderationEvents = [
+    isBlockedDecision(input.decision) ? createAbuseUsageEvent({ ...baseInput, kind: "blocked" }) : null,
+    input.decision.resource === "throttle" ? createAbuseUsageEvent({ ...baseInput, kind: "throttled" }) : null,
+    input.decision.review.required ? createAbuseUsageEvent({
+      ...baseInput,
+      kind: "reviewed",
+      reviewQueue: input.decision.review.queue
+    }) : null
+  ].filter((event) => event !== null);
+  const economicKind = economicKindForDecision(input);
+  const economicEvent = economicKind ? [createAbuseUsageEvent({ ...baseInput, kind: economicKind })] : [];
+  return [...moderationEvents, ...economicEvent];
+}
+function createAbuseUsageEventId(event, salt = DEFAULT_USAGE_EVENT_HASH_SALT) {
+  const payload = stableStringify(toStableEventPayload(event));
+  const encoded = new TextEncoder().encode(`${salt}:${payload}`);
+  return `usage_${hashBase64(encoded, "blake3").slice(0, 24)}`;
+}
+function summarizeAbuseUsageEvents(events) {
+  const totalUnits = sumEvents(events, "units");
+  const blockedUnits = sumUnitsForKind(events, "blocked");
+  const throttledUnits = sumUnitsForKind(events, "throttled");
+  const reviewedUnits = sumUnitsForKind(events, "reviewed");
+  const automationSavedUnits = blockedUnits + throttledUnits;
+  const appealUnits = sumUnitsForWorkType(events, "appeal");
+  return {
+    totalEvents: events.length,
+    totalUnits,
+    kindCounts: countBy(
+      ABUSE_USAGE_EVENT_KINDS,
+      events.map((event) => event.kind)
+    ),
+    settlementCounts: countBy(
+      ABUSE_USAGE_SETTLEMENTS,
+      events.map((event) => event.settlement)
+    ),
+    unitsByKind: sumByKey(ABUSE_USAGE_EVENT_KINDS, events, (event) => event.kind, "units"),
+    unitsBySettlement: sumByKey(
+      ABUSE_USAGE_SETTLEMENTS,
+      events,
+      (event) => event.settlement,
+      "units"
+    ),
+    eventsBySurface: countEventValues(events.map((event) => event.surface)),
+    eventsByWorkType: countEventValues(events.map((event) => event.workType)),
+    costMicroUsd: sumEvents(events, "costMicroUsd"),
+    billableMicroUsd: sumEvents(events, "billableMicroUsd"),
+    sponsoredMicroUsd: sumEvents(events, "sponsoredMicroUsd"),
+    reciprocalCreditUnits: sumEvents(events, "reciprocalCreditUnits"),
+    blockedUnits,
+    throttledUnits,
+    reviewedUnits,
+    automationSavedUnits,
+    automationSavedCostMicroUsd: sumCostForKinds(events, ["blocked", "throttled"]),
+    appealUnits,
+    appealCostMicroUsd: sumCostForWorkType(events, "appeal"),
+    automationSavingsRatio: ratio2(automationSavedUnits, totalUnits),
+    reviewLoadRatio: ratio2(reviewedUnits, totalUnits),
+    appealLoadRatio: ratio2(appealUnits, totalUnits)
+  };
+}
+function settlementForKind(kind) {
+  if (kind === "blocked") return "abuse-blocked";
+  if (kind === "billable") return "paid";
+  if (kind === "sponsored") return "sponsored";
+  if (kind === "reciprocal") return "reciprocal";
+  return "free";
+}
+function isBlockedDecision(decision) {
+  return decision.admission === "reject" || decision.resource === "block-peer";
+}
+function economicKindForDecision(input) {
+  if (input.decision.admission !== "accept") return null;
+  if (nonNegative(input.reciprocalCreditUnits ?? 0) > 0) return "reciprocal";
+  if (nonNegative(input.sponsoredMicroUsd ?? 0) > 0) return "sponsored";
+  if (nonNegative(input.costMicroUsd ?? 0) > 0) return "billable";
+  return null;
+}
+function sponsoredAmount(amount, costMicroUsd, settlement) {
+  if (settlement === "sponsored") return nonNegative(amount ?? costMicroUsd);
+  return nonNegative(amount ?? 0);
+}
+function reciprocalUnits(units, fallbackUnits, settlement) {
+  if (settlement === "reciprocal") return nonNegative(units ?? fallbackUnits);
+  return nonNegative(units ?? 0);
+}
+function nonNegative(value) {
+  return Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+function dedupe(values) {
+  return [...new Set(values)];
+}
+function normalizedString(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function normalizeDomain2(domain) {
+  return normalizedString(domain)?.toLowerCase().replace(/^www\./, "");
+}
+function normalizeRoute2(route) {
+  return normalizedString(route)?.replace(/\s+/g, "-").toLowerCase();
+}
+function normalizeTags(tags) {
+  return [...new Set(tags.map((tag) => tag.trim().toLowerCase()).filter(Boolean))].sort();
+}
+function countBy(keys, values) {
+  const initial = createNumberRecord(keys);
+  return values.reduce(
+    (counts, value) => ({
+      ...counts,
+      [value]: counts[value] + 1
+    }),
+    initial
+  );
+}
+function countEventValues(values) {
+  return values.reduce(
+    (counts, value) => ({
+      ...counts,
+      [value]: (counts[value] ?? 0) + 1
+    }),
+    {}
+  );
+}
+function createNumberRecord(keys) {
+  return keys.reduce(
+    (counts, key) => ({
+      ...counts,
+      [key]: 0
+    }),
+    {}
+  );
+}
+function sumByKey(keys, events, getKey, valueKey) {
+  const initial = createNumberRecord(keys);
+  return events.reduce(
+    (totals, event) => ({
+      ...totals,
+      [getKey(event)]: totals[getKey(event)] + event[valueKey]
+    }),
+    initial
+  );
+}
+function sumEvents(events, key) {
+  return events.reduce((total, event) => total + event[key], 0);
+}
+function sumUnitsForKind(events, kind) {
+  return events.filter((event) => event.kind === kind).reduce((total, event) => total + event.units, 0);
+}
+function sumUnitsForWorkType(events, workType) {
+  return events.filter((event) => event.workType === workType).reduce((total, event) => total + event.units, 0);
+}
+function sumCostForWorkType(events, workType) {
+  return events.filter((event) => event.workType === workType).reduce((total, event) => total + event.costMicroUsd, 0);
+}
+function sumCostForKinds(events, kinds) {
+  return events.filter((event) => kinds.includes(event.kind)).reduce((total, event) => total + event.costMicroUsd, 0);
+}
+function ratio2(numerator, denominator) {
+  return denominator > 0 ? numerator / denominator : 0;
+}
+function toStableEventPayload(event) {
+  return {
+    kind: event.kind,
+    settlement: event.settlement,
+    surface: event.surface,
+    workType: event.workType,
+    actorHash: event.actorHash,
+    remotePeerHash: event.remotePeerHash ?? null,
+    labelerHash: event.labelerHash ?? null,
+    hubId: event.hubId ?? null,
+    workspaceId: event.workspaceId ?? null,
+    domain: event.domain ?? null,
+    route: event.route ?? null,
+    units: event.units,
+    costMicroUsd: event.costMicroUsd,
+    billableMicroUsd: event.billableMicroUsd,
+    sponsoredMicroUsd: event.sponsoredMicroUsd,
+    reciprocalCreditUnits: event.reciprocalCreditUnits,
+    resource: event.resource ?? null,
+    reviewQueue: event.reviewQueue ?? null,
+    reasonCodes: event.reasonCodes,
+    policyId: event.policyId ?? null,
+    tags: event.tags,
+    occurredAt: event.occurredAt
+  };
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+  }
+  if (value !== null && typeof value === "object") {
+    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+export {
+  ABUSE_USAGE_EVENT_KINDS,
+  ABUSE_USAGE_SETTLEMENTS,
+  DEFAULT_SENSITIVITY_PREFERENCES,
+  SENSITIVITY_LABEL_VALUES,
+  SENSITIVITY_PRESENCE_FLOOR,
+  SENSITIVITY_SOURCE_WEIGHT,
+  TRUSTED_SPAM_LABEL,
+  WARNING_SLOP_LABEL,
+  abuseFixtures,
+  activeHubPolicyServices,
+  activeLabels,
+  activePolicyBlockEntries,
+  approveStagedModerationWrite,
+  assessDuplicateContent,
+  assessSensitivity,
+  auditPolicyBlockEntries,
+  averageHash,
+  bucketAbusePeerScore,
+  buildSensitivityLabel,
+  canonicalizeContentText,
+  canonicalizeHubPolicyServiceOffer,
+  canonicalizePolicyBlockList,
+  classifyWithCloudAdapter,
+  classifyWithLocalAdapters,
+  classifyWithModerationCascade,
+  compareContentFingerprints,
+  compareSimHash64,
+  createAISignalProvenanceEvidenceRef,
+  createAbuseDecisionAdapter,
+  createAbuseFactAdapter,
+  createAbuseUsageEvent,
+  createAbuseUsageEventId,
+  createAbuseUsageEventsFromDecision,
+  createAppealEffect,
+  createBaseFacts,
+  createCloudClassifierAdapter,
+  createCloudClassifierRequestBase,
+  createContentFingerprint,
+  createHubPolicyServiceOffer,
+  createKeywordLocalClassifier,
+  createLabelerSubscription,
+  createLocalClassificationResult,
+  createNsfwImageClassifier,
+  createPolicyBlockList,
+  createPublicSearchHubAbuseProfile,
+  createPublicWriteBudgetKey,
+  createQueryCostBudgetKey,
+  createRemoteAdmissionPipeline,
+  createRemoteMutationRejectionTelemetry,
+  createSmallSelfHostedAbuseProfile,
+  createTrustedLabelFromSetting,
+  decideAbuse,
+  decideCloudReviewRoute,
+  decidePublicInteraction,
+  decideReach,
+  decideRemoteMutation,
+  decideSensitivityVisibility,
+  decideTransport,
+  decideWithAdapter,
+  differenceHash,
+  estimateCloudClassifierCost,
+  evaluateLabelerSubscriptionLimit,
+  evaluateLabelerTrust,
+  evaluatePublicWriteBudget,
+  evaluateQueryCostBudget,
+  evaluateReportEscalation,
+  explainDecision,
+  explainSensitivityVisibility,
+  extractCitationReferences,
+  extractKnowledgeClaims,
+  findPolicyBlockAuditEntry,
+  findPolicyBlockEntry,
+  getCloudClassificationSkipReason,
+  getReasonDetail,
+  groupCommunityNoteRatingsByPerspective,
+  hammingDistanceHex,
+  hashAbusePeerIdentifier,
+  hubPolicyServiceOfferSigningBytes,
+  imageHashSimilarity,
+  isAISignalSourceType,
+  isCommunityNoteAgreementVisible,
+  isRejected,
+  isSensitivityLabelValue,
+  isSignedHubPolicyServiceOffer,
+  isSignedPolicyBlockList,
+  isVisible,
+  mapNsfwLabelToSensitivity,
+  matchKnownImageHash,
+  materializeStagedModerationWrite,
+  mergeLocalClassificationResults,
+  normalizeAbuseFacts,
+  perceptualHash,
+  planStagedModerationWrites,
+  policyBlockEntryIsActive,
+  policyBlockListSigningBytes,
+  policyBlockOverrideEntryIsActive,
+  prescreenImage,
+  prescreenImageLabels,
+  publicAppealChannels,
+  qualityRiskScore,
+  redactCloudClassifierText,
+  rejectStagedModerationWrite,
+  reportRemoteMutationRejection,
+  resolveContentVisibility,
+  resolveSubscribedPolicyBlockLists,
+  scoreClaimCitationCoverage,
+  scoreCommunityNotePerspectiveDiversity,
+  sensitivityLabels,
+  sensitivityOverride,
+  shouldThrottle,
+  signHubPolicyServiceOffer,
+  signPolicyBlockList,
+  strictestVisibility,
+  subscriptionToTrustSetting,
+  subscriptionsToTrustSettings,
+  summarizeAbuseUsageEvents,
+  summarizeCommunityNoteAgreement,
+  tokenizeContent,
+  unsignedHubPolicyServiceOffer,
+  unsignedPolicyBlockList,
+  validateAISignalProvenance,
+  validateHubPolicyServiceOffer,
+  verifySignedHubPolicyServiceOffer,
+  verifySignedPolicyBlockList,
+  weightedLabelScore
+};