@nvisy/sdk 0.25.0 → 0.27.0

package/dist/{index-Cijg5CMy.d.ts → index-D7O7ZJNs.d.ts}

@@ -4578,7 +4578,7 @@ interface paths {
          *     here; labels are re-derived from the policy set on each
          *     anonymize call.
          *
-         *     No [`Default`] — a well-formed audit must carry a real
+         *     No [`Default`]: a well-formed audit must carry a real
          *     [`AuditContext`] with a real correlation id. Callers building
          *     an audit outside the analyze path construct it explicitly.
          */
@@ -5226,7 +5226,9 @@ interface paths {
       /**
        * @description Request payload for updating an existing workspace policy.
        *
-       *     Replacing the `definition` replaces the whole policy body.
+       *     Replacing the `definition` replaces the whole policy body. The policy's
+       *     template origin is server-owned and preserved across updates — it is not
+       *     settable here.
        */
       requestBody: {
         content: {
@@ -8113,195 +8115,137 @@ interface components {
       token: string;
     };
     /**
-     * @description Author-supplied rationale for a redaction: a policy name and an optional
-     *     description.
+     * @description Author-supplied rationale for a redaction: *under what authority* it was made.
      *
      *     Where the matched selection rule answers *which rule fired*, an
-     *     `Attribution` answers *under what authority* — a compliance clause, an
+     *     `Attribution` answers *why the policy demanded it* — a compliance clause, an
      *     internal policy, a data-handling rule. A policy author attaches it to a
-     *     selection rule (`Rule::because` in `elide-redaction`); the anonymizer
-     *     records it on the entity's [`Redaction`] event so an audit can trace a
-     *     change back to the policy that demanded it.
+     *     selection rule (`Rule::because` in `elide-redaction`); the anonymizer records
+     *     it on the entity's [`Redaction`] event so an audit can trace a change back to
+     *     the policy that demanded it.
      *
-     *     The `name` is the author's label for that policy (`"gdpr-art-17"`,
-     *     `"hipaa-safe-harbor"`, `"PII removal"`); an optional `description` adds
-     *     human context. Any stable machine identity a policy layer needs (a rule
-     *     UUID, a jurisdiction) is that layer's concern — it can encode it in the
-     *     name or carry it separately.
+     *     The rationale takes one of two [`kind`](Attribution::kind)s, by how much
+     *     structure the author has ([`AttributionKind::Freeform`] /
+     *     [`AttributionKind::Cited`]). Orthogonal to that, an attribution may carry a
+     *     [`source_id`](Attribution::source_id): an opaque, caller-owned [`Uuid`] the
+     *     policy layer uses to link back to a source record (a rule, a request, a
+     *     document). elide-core stores and hashes it verbatim; it never resolves or
+     *     validates it.
      *
-     *     [`Redaction`]: crate::entity::provenance::EventKind::Redaction
+     *     [`Redaction`]: crate::entity::audit::AuditKind::Redaction
      */
     Attribution: {
+      /** @description The shape of the rationale: a freeform label or a formal citation. */
+      kind: components["schemas"]["AttributionKind"];
+      /**
+       * Format: uuid
+       * @description Opaque, caller-owned link to a source record, when given.
+       */
+      source_id?: string;
+    };
+    /** @description The shape of an [`Attribution`]'s rationale. */
+    AttributionKind: {
       /** @description Human-readable description (e.g. `"right to erasure"`), when given. */
       description?: string;
+      /** @constant */
+      kind: "freeform";
       /** @description The policy's name (e.g. `"gdpr-art-17"`, `"hipaa-safe-harbor"`). */
       name: string;
-    };
-    /**
-     * @description Per-call payload a recognizer inspects for the [`Audio`] modality.
-     *
-     *     Carries the encoded audio bytes; an optional filename aids diagnostics
-     *     and encoding inference (the container format a decoder should expect).
-     *     The recognizable text — a timestamped transcript — is *not* held here;
-     *     a speech-to-text [`Enricher`] stamps it onto the call's
-     *     [`artifacts`], keeping
-     *     `AudioData` the codec's payload alone.
-     *
-     *     [`Audio`]: super::Audio
-     *     [`Enricher`]: crate::recognition::Enricher
-     *     [`artifacts`]: crate::recognition::RecognizerContext::artifacts
-     */
-    AudioData: {
-      /** @description Original filename, when known. */
-      filename?: string;
-    };
-    /**
-     * @description Detected piece of sensitive information within some medium.
-     *
-     *     Generic over the [`Modality`] `M`, which is what makes the model
-     *     multimodal: a text pipeline yields `Entity<Text>`, an audio pipeline
-     *     `Entity<Audio>`, and so on. The entity's location is the modality's
-     *     [`Location`] type, `M::Location`.
-     *
-     *     # Birth and fusion
-     *
-     *     A recognizer emits an entity directly, carrying a single recognition
-     *     [`Event`] (its own finding) in the entity's [`provenance`]. When
-     *     several recognizers find the same thing, a fusion step (in
-     *     `elide`) combines their entities into one: the survivor's
-     *     [`location`] and [`confidence`] are the *fused* values, and every
-     *     contributing recognition event, plus a deduplication event, is
-     *     retained in its provenance. The entity therefore carries its full
-     *     audit trail with it.
-     *
-     *     [`Location`]: Modality::Location
-     *     [`Event`]: crate::entity::provenance::Event
-     *     [`provenance`]: Entity::provenance
-     *     [`location`]: Entity::location
-     *     [`confidence`]: Entity::confidence
-     */
-    AudioEntity: {
-      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
-      confidence: components["schemas"]["Confidence"];
-      /**
-       * @description Coreference identifier, if a recognizer resolved this entity as one
-       *     mention of a cluster. Entities sharing an [`EntityCoRef`] denote the
-       *     same real-world thing.
-       */
-      coref?: components["schemas"]["EntityCoRef"];
-      /**
-       * Format: uuid
-       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
-       *     when the entity is assembled.
-       */
-      id: string;
-      /**
-       * @description What kind of sensitive information this is (resolved via a
-       *     [`LabelCatalog`]).
-       */
-      label: components["schemas"]["LabelRef"];
-      /**
-       * @description The language of this entity's surrounding text, when a recognizer
-       *     resolved one. `None` when unknown or language-agnostic.
-       */
-      language?: string;
-      /**
-       * @description Location of the entity within the medium (fused, if it came from more
-       *     than one detection).
-       */
-      location: components["schemas"]["AudioLocation"];
-      /**
-       * @description Detection audit trail: every contributing detection and the fusion
-       *     event, if any.
+    } | {
+      /** @description The authority cited (e.g. `"GDPR"`, `"HIPAA"`, `"internal-policy"`). */
+      authority: string;
+      /** @description The citation within that authority (e.g. `"Art. 17(1)"`, `"§164.514"`). */
+      citation: string;
+      /** @constant */
+      kind: "cited";
+      /** @description Why the citation applies here (e.g. `"data subject requested erasure"`). */
+      rationale: string;
+    };
+    /**
+     * @description One node in an entity's audit DAG: a thing that happened, with its
+     *     effect on confidence and its tamper-evident links.
+     *
+     *     Events are recorded on an entity's [`AuditLog`], forming the full audit
+     *     trail of its life: each recognizer that found it, the deduplication that
+     *     fused them, any score calibration, and the redaction that hid it. The
+     *     uniform spine (who, resulting score, when) is the same for every event; the
+     *     [`kind`] carries the event-specific detail *and* the explanation of why the
+     *     event happened.
+     *
+     *     Each event links to its [`parents`] by their [`hash`]: a birth event (a
+     *     recognizer's first detection) has no parents, a normal step has one, and a
+     *     [fusion](crate::entity::audit::AuditLog::record_fusion) has several. Its own
+     *     [`hash`] folds the
+     *     payload together with the parents' hashes, so altering any event breaks
+     *     every event downstream of it: [`AuditLog::verify`] walks the DAG and
+     *     reports the first break.
+     *
+     *     `entity.confidence` always equals the [`confidence`] of the most recent
+     *     event. The confidence *flowing in* is not stored: it is the parents'
+     *     [`confidence`], recovered from the DAG.
+     *
+     *     [`AuditLog`]: crate::entity::audit::AuditLog
+     *     [`AuditLog::record_fusion`]: crate::entity::audit::AuditLog::record_fusion
+     *     [`AuditLog::verify`]: crate::entity::audit::AuditLog::verify
+     *     [`kind`]: AuditEvent::kind
+     *     [`parents`]: AuditEvent::parents
+     *     [`hash`]: AuditEvent::hash
+     *     [`confidence`]: AuditEvent::confidence
+     */
+    AudioAuditEvent: {
+      /**
+       * @description Confidence after this event: the entity's effective confidence once it
+       *     has happened.
        */
-      provenance: components["schemas"]["AudioProvenance"];
+      confidence: components["schemas"]["Confidence"];
       /**
-       * @description Byte range of the match in the *recognized text* it was found in (the
-       *     OCR layout text, the audio transcript, or the text payload itself) —
-       *     the stable key back into that enrichment artifact, where the rich
-       *     context lives (which OCR block, which speaker) that the geometric
-       *     [`location`] cannot hold. `None` for entities not found via text
-       *     recognition (e.g. a VLM box). Provenance, not a coordinate: redaction
-       *     uses [`location`]; an audit uses this with the artifact.
+       * @description This event's hash, over its payload and its parents' hashes. Assigned by
+       *     [`AuditLog`] when the event is recorded; read it through
+       *     [`hash`](Self::hash). Recomputing it is how the DAG is verified.
        *
-       *     [`location`]: Entity::location
-       */
-      recognized_range?: components["schemas"]["Range_of_uint"];
-    };
-    /**
-     * @description One recognized entity plus the optional reviewer override.
-     *
-     *     The bound mirrors elide's [`Entity<M>`]: serialization needs
-     *     `M::Location` and `M::Data` (de)serializable, and JsonSchema
-     *     derivation needs them schema-able. All four modalities elide
-     *     ships satisfy these under the `serde` + `schema` features.
-     */
-    AudioEntityRecord: {
-      /** @description The elide entity, as recognition produced it. */
-      entity: components["schemas"]["AudioEntity"];
-      /**
-       * @description Reviewer-supplied redaction override.
+       *     Not publicly settable: only [`AuditLog`] assigns it, so a caller cannot
+       *     forge a self-consistent event outside the recording path.
        *
-       *     `None` means "use the matching policy rule's decision";
-       *     `Some(...)` overrides that rule for this specific entity
-       *     at apply time. Reviewer overrides take precedence over
-       *     every policy rule and inherit the authority of the
-       *     [`Review::policy_id`] they name — the audit event's
-       *     attribution stamps that policy so the trail names the
-       *     authority under which the override fired.
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
        */
-      review?: components["schemas"]["Review"];
-    };
-    /**
-     * @description One thing that happened to an entity, with its effect on confidence.
-     *
-     *     Events are recorded in order on an entity's [`Provenance`], forming
-     *     the full audit trail of its life: each recognizer that found it, the
-     *     deduplication that fused them, any score calibration, and the
-     *     redaction that hid it. The uniform spine (who, before/after score,
-     *     when, why) is the same for every event; the [`kind`] carries the
-     *     event-specific detail.
-     *
-     *     `entity.confidence` always equals the [`after`] of the most recent
-     *     event.
-     *
-     *     [`Provenance`]: crate::entity::provenance::Provenance
-     *     [`kind`]: Event::kind
-     *     [`after`]: Event::after
-     */
-    AudioEvent: {
-      /** @description Confidence after this event. */
-      after: components["schemas"]["Confidence"];
-      /** @description When the event happened (UTC). */
-      at: string;
+      hash: components["schemas"]["AuditHash"];
+      /** @description Kind of event, with its event-specific detail and its rationale. */
+      kind: components["schemas"]["AudioAuditKind"];
       /**
-       * @description Confidence before this event, if there was a prior value. `None` on
-       *     the first (birth) event.
+       * @description The events this one follows, by their hash. Empty for a birth event, one
+       *     entry for a normal step, several for a fusion. Assigned by [`AuditLog`]
+       *     when the event is recorded; read it through [`parents`](Self::parents).
+       *
+       *     Not publicly settable: the links are the tamper-evident structure, so
+       *     only [`AuditLog::record`] / [`AuditLog::record_fusion`] assign them.
+       *
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
+       *     [`AuditLog::record`]: crate::entity::audit::AuditLog::record
+       *     [`AuditLog::record_fusion`]: crate::entity::audit::AuditLog::record_fusion
        */
-      before?: components["schemas"]["Confidence"];
-      /** @description Kind of event, with its event-specific detail. */
-      kind: components["schemas"]["AudioEventKind"];
-      /** @description Free-text explanation of what the event did and why. */
-      reason: string;
+      parents: components["schemas"]["AuditHash"][];
       /**
        * @description Who produced this event: a recognizer name, a deduplication strategy,
        *     an operator, or whatever acted.
        */
       source: string;
+      /** @description When the event happened (UTC). */
+      timestamp: string;
     };
     /**
-     * @description Kind of an [`Event`], carrying its event-specific detail.
+     * @description Kind of an [`AuditEvent`], carrying its event-specific detail and the
+     *     rationale for why it happened.
      *
      *     `#[non_exhaustive]`: new event kinds (verification, annotation, …)
      *     can be added compatibly. The recognition kinds ([`Pattern`],
      *     [`Model`]) carry the matched [`Location`]; the rest carry their own
      *     data.
      *
-     *     [`Pattern`]: EventKind::Pattern
-     *     [`Model`]: EventKind::Model
+     *     [`Pattern`]: AuditKind::Pattern
+     *     [`Model`]: AuditKind::Model
      *     [`Location`]: Modality::Location
      */
-    AudioEventKind: {
+    AudioAuditKind: {
       /** @constant */
       kind: "pattern";
       /** @description Where the recognizer matched. */
@@ -8365,7 +8309,7 @@ interface components {
        *     it is the keyword resolved through the modality's [`locate`] (a
        *     pixel box for image, a time span for audio, the byte range for
        *     text/tabular). `None` when the keyword's stream range could not be
-       *     placed — symmetric with a match the recognizer itself drops.
+       *     placed, symmetric with a match the recognizer itself drops.
        *
        *     [`locate`]: crate::modality::TextRecognizable::locate
        */
@@ -8383,12 +8327,176 @@ interface components {
       /** @description How much the output leaks about the original. */
       leak_profile: components["schemas"]["LeakProfile"];
       /**
-       * @description Which selection rule chose this operator — the automatic "why"
+       * @description Which selection rule chose this operator: the automatic "why"
        *     (matched a label, a tag, a predicate, or the fallback).
        */
       matched_by: components["schemas"]["RuleMatch"];
       /** @description Which operator (name + version) ran. */
       operator: components["schemas"]["OperatorId"];
+      /**
+       * @description BLAKE3 digest of the original text the operator hid, when the
+       *     redaction layer recorded it. Proves *what* was redacted without
+       *     storing the plaintext; `None` when the operator did not capture it.
+       */
+      span_hash?: components["schemas"]["AuditHash"];
+      /**
+       * Format: uint32
+       * @description Byte length of the original text the operator hid, paired with
+       *     [`span_hash`](Self::Redaction::span_hash). `None` when not captured.
+       */
+      span_length?: number;
+    };
+    /**
+     * @description Full audit trail of an [`Entity`]: every [`AuditEvent`] in its life, as a
+     *     tamper-evident DAG.
+     *
+     *     Where Presidio keeps a shallow, optional, per-stage explanation that is
+     *     stripped by default, an `AuditLog` is always present and records the
+     *     entity's *entire* life: each recognizer that found it, the deduplication
+     *     that fused them, any confidence calibration, and the redaction that hid it.
+     *     Nothing is collapsed: every recognizer keeps its own recognition event with
+     *     its location and score.
+     *
+     *     The events form a **directed acyclic graph**, not a flat list. A recognizer
+     *     records a birth event (no parents); each later step links to the event it
+     *     follows; and a [fusion](Self::record_fusion) links to *several* parents at
+     *     once: the heads of the trails it combines. This is the true shape of a
+     *     deduplicated entity: two recognizers are siblings, then a fusion joins them.
+     *     The events are stored in the order they were recorded, which is a
+     *     topological order of the DAG (a parent is always recorded before its
+     *     children).
+     *
+     *     Two chains ride the DAG's edges:
+     *
+     *     - a **confidence chain**, where each event's [`confidence`] is the entity's
+     *       effective score after it; the score flowing *in* is its parents'
+     *       confidence, so [`final_confidence`] and the full history are recoverable;
+     *     - a **hash chain**, where each event's [`hash`] folds its payload together
+     *       with its parents' hashes, so any edit, reorder, insertion, or deletion of
+     *       an earlier event breaks every event downstream. [`verify`] walks the DAG
+     *       and reports the first break.
+     *
+     *     [`Entity`]: crate::entity::Entity
+     *     [`confidence`]: AuditEvent::confidence
+     *     [`hash`]: AuditEvent::hash
+     *     [`final_confidence`]: Self::final_confidence
+     *     [`verify`]: Self::verify
+     */
+    AudioAuditLog: components["schemas"]["AudioAuditEvent"][];
+    /**
+     * @description Per-call payload a recognizer inspects for the [`Audio`] modality.
+     *
+     *     Carries the encoded audio bytes; an optional filename aids diagnostics
+     *     and encoding inference (the container format a decoder should expect).
+     *     The recognizable text — a timestamped transcript — is *not* held here;
+     *     a speech-to-text [`Enricher`] stamps it onto the call's
+     *     [`artifacts`], keeping
+     *     `AudioData` the codec's payload alone.
+     *
+     *     [`Audio`]: super::Audio
+     *     [`Enricher`]: crate::recognition::Enricher
+     *     [`artifacts`]: crate::recognition::RecognizerContext::artifacts
+     */
+    AudioData: {
+      /** @description Original filename, when known. */
+      filename?: string;
+    };
+    /**
+     * @description Detected piece of sensitive information within some medium.
+     *
+     *     Generic over the [`Modality`] `M`, which is what makes the model
+     *     multimodal: a text pipeline yields `Entity<Text>`, an audio pipeline
+     *     `Entity<Audio>`, and so on. The entity's location is the modality's
+     *     [`Location`] type, `M::Location`.
+     *
+     *     # Birth and fusion
+     *
+     *     A recognizer emits an entity directly, carrying a single recognition
+     *     [`AuditEvent`] (its own finding) in the entity's [`audit`] trail. When
+     *     several recognizers find the same thing, a fusion step (in
+     *     `elide`) combines their entities into one: the survivor's
+     *     [`location`] and [`confidence`] are the *fused* values, and every
+     *     contributing recognition event, plus a deduplication event, is
+     *     retained in its audit trail. The entity therefore carries its full
+     *     audit trail with it.
+     *
+     *     [`Location`]: Modality::Location
+     *     [`AuditEvent`]: crate::entity::audit::AuditEvent
+     *     [`audit`]: Entity::audit
+     *     [`location`]: Entity::location
+     *     [`confidence`]: Entity::confidence
+     */
+    AudioEntity: {
+      /**
+       * @description Tamper-evident audit trail: every contributing detection, the fusion
+       *     event if any, and the redaction that hid it, as a hash-linked DAG.
+       */
+      audit: components["schemas"]["AudioAuditLog"];
+      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
+      confidence: components["schemas"]["Confidence"];
+      /**
+       * @description Coreference identifier, if a recognizer resolved this entity as one
+       *     mention of a cluster. Entities sharing an [`EntityCoRef`] denote the
+       *     same real-world thing.
+       */
+      coref?: components["schemas"]["EntityCoRef"];
+      /**
+       * Format: uuid
+       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
+       *     when the entity is assembled.
+       */
+      id: string;
+      /**
+       * @description What kind of sensitive information this is (resolved via a
+       *     [`LabelCatalog`]).
+       */
+      label: components["schemas"]["LabelRef"];
+      /**
+       * @description The language of this entity's surrounding text, when a recognizer
+       *     resolved one. `None` when unknown or language-agnostic.
+       */
+      language?: string;
+      /**
+       * @description Location of the entity within the medium (fused, if it came from more
+       *     than one detection).
+       */
+      location: components["schemas"]["AudioLocation"];
+      /**
+       * @description Byte range of the match in the *recognized text* it was found in (the
+       *     OCR layout text, the audio transcript, or the text payload itself) —
+       *     the stable key back into that enrichment artifact, where the rich
+       *     context lives (which OCR block, which speaker) that the geometric
+       *     [`location`] cannot hold. `None` for entities not found via text
+       *     recognition (e.g. a VLM box). An audit key, not a coordinate: redaction
+       *     uses [`location`]; an audit uses this with the artifact.
+       *
+       *     [`location`]: Entity::location
+       */
+      recognized_range?: components["schemas"]["Range_of_uint"];
+    };
+    /**
+     * @description One recognized entity plus the optional reviewer override.
+     *
+     *     The bound mirrors elide's [`Entity<M>`]: serialization needs
+     *     `M::Location` and `M::Data` (de)serializable, and JsonSchema
+     *     derivation needs them schema-able. All four modalities elide
+     *     ships satisfy these under the `serde` + `schema` features.
+     */
+    AudioEntityRecord: {
+      /** @description The elide entity, as recognition produced it. */
+      entity: components["schemas"]["AudioEntity"];
+      /**
+       * @description Reviewer-supplied redaction override.
+       *
+       *     `None` means "use the matching policy rule's decision";
+       *     `Some(...)` overrides that rule for this specific entity
+       *     at apply time. Reviewer overrides take precedence over
+       *     every policy rule and inherit the authority of the
+       *     [`Review::policy_id`] they name: the audit event's
+       *     attribution stamps that policy so the trail names the
+       *     authority under which the override fired.
+       */
+      review?: components["schemas"]["Review"];
     };
     /**
      * @description Located, typed piece of context a recognizer may treat as in-context
@@ -8430,31 +8538,6 @@ interface components {
       /** @description Diarization label of the speaker, when a diarizer assigned one. */
       speaker_id?: string;
     };
-    /**
-     * @description Full audit trail of an [`Entity`]: every [`Event`] in its life, in
-     *     order.
-     *
-     *     This is the model's answer to "full provenance": where Presidio keeps
-     *     a shallow, optional, per-stage explanation that is stripped by
-     *     default, a `Provenance` is always present and records the entity's
-     *     *entire* life as an ordered list of events: each recognizer that
-     *     found it, the deduplication that fused them, any confidence
-     *     calibration, and the redaction that hid it. Nothing is collapsed:
-     *     every recognizer keeps its own recognition event with its location
-     *     and score.
-     *
-     *     The events form a confidence chain (each event's [`after`] is the
-     *     next's [`before`]) so the final confidence and its full history are
-     *     always recoverable.
-     *
-     *     [`Entity`]: crate::entity::Entity
-     *     [`after`]: Event::after
-     *     [`before`]: Event::before
-     */
-    AudioProvenance: {
-      /** @description Events, in the order they happened. */
-      events: components["schemas"]["AudioEvent"][];
-    };
     /** @description Operator spec a `redact` audio rule carries. */
     AudioRedaction: {
       /** @constant */
@@ -8502,7 +8585,7 @@ interface components {
      *     here; labels are re-derived from the policy set on each
      *     anonymize call.
      *
-     *     No [`Default`] — a well-formed audit must carry a real
+     *     No [`Default`]: a well-formed audit must carry a real
      *     [`AuditContext`] with a real correlation id. Callers building
      *     an audit outside the analyze path construct it explicitly.
      */
@@ -8524,7 +8607,7 @@ interface components {
        *     vocabulary analyze used without the caller re-passing an
        *     `AnalyzerParams`.
        *
-       *     Required on the wire — a missing context on an incoming
+       *     Required on the wire: a missing context on an incoming
        *     [`Audit`] rejects at deserialize time so the shape
        *     mismatch surfaces at load, not at apply.
        *
@@ -8549,11 +8632,11 @@ interface components {
      *     for `languages` and `countries` (typed, elide-native), a
      *     [`metadata`] sub-struct for free-form classification strings
      *     (`tags`, `purpose`, `audience`), and the analyze-time
-     *     [`correlation_id`]. The label catalog is not on here —
+     *     [`correlation_id`]. The label catalog is not on here -
      *     labels are policy-owned, and anonymize re-derives them from
      *     the policy set it was handed.
      *
-     *     No [`Default`] — `correlation_id` has no meaningful default
+     *     No [`Default`]: `correlation_id` has no meaningful default
      *     (a nil UUID would silently collapse unrelated audits under
      *     one bucket in downstream trace aggregators), so callers
      *     supply one explicitly. Everything else defaults to empty.
@@ -8571,12 +8654,12 @@ interface components {
        *     carried over so the anonymize path can link its own spans
        *     to the same request. The anonymize call supplies a fresh
        *     id from the passed [`Document`] as the anonymize-side
-       *     correlation id — this one stays as the analyze-side
+       *     correlation id: this one stays as the analyze-side
        *     pointer.
        *
        *     Required on the wire.
        *
-       *     [`Document`]: nvisy_schema::file::Document
+       *     [`Document`]: elide_wire::file::Document
        */
       correlationId: string;
       /**
@@ -8601,16 +8684,31 @@ interface components {
       /**
        * @description OCR mode the analyze call decoded with. Recorded so the
        *     anonymize call re-decodes the same document under the same
-       *     codec configuration — otherwise entity offsets stored in
+       *     codec configuration: otherwise entity offsets stored in
        *     the audit wouldn't line up against a differently-rendered
-       *     second decode. Defaults to [`OcrMode::Auto`] (the codec's
+       *     second decode. Defaults to [`RasterMode::Auto`] (the codec's
        *     built-in behaviour) when omitted.
        * @default {
        *       "kind": "auto"
        *     }
        */
-      ocrMode: components["schemas"]["OcrMode"];
+      rasterMode: components["schemas"]["RasterMode"];
     };
+    /**
+     * @description A 32-byte BLAKE3 digest.
+     *
+     *     The tamper-evident link in an [`AuditLog`] DAG: each [`AuditEvent`] hashes
+     *     its payload together with its parents' hashes, so altering any event breaks
+     *     every event downstream of it. Displays and (with the `serde` feature)
+     *     (de)serializes as lowercase hex.
+     *
+     *     The all-zero hash is [`GENESIS`](AuditHash::GENESIS), the link a birth event
+     *     (one with no parents) chains from.
+     *
+     *     [`AuditLog`]: crate::entity::audit::AuditLog
+     *     [`AuditEvent`]: crate::entity::audit::AuditEvent
+     */
+    AuditHash: string;
     /** @description Response returned after successful authentication (login/signup). */
     AuthToken: {
       /** @description The JWT API token for authentication. */
@@ -8690,17 +8788,35 @@ interface components {
       /** @description Minimum corner (top-left, conventionally). */
       min: components["schemas"]["Point"];
     };
+    /**
+     * @description The coarse group a [`Label`] belongs to, for organizing detected entities
+     *     by kind (`financial`, `health`, `identity`, …).
+     *
+     *     A category answers "what *sort* of information is this" at a display level:
+     *     a consumer groups a redaction audit into sections by category. It is
+     *     distinct from a label's [`tags`], which are cross-cutting sensitivity
+     *     markers (`pii`, `phi`, `pci`) a label may carry several of; a label has at
+     *     most **one** category. Built-in labels ship with a category; a custom
+     *     [`Label`] has none unless one is set.
+     *
+     *     The value is an open, lowercase `snake_case` identifier, so a custom label
+     *     can define its own category rather than being confined to the shipped set.
+     *
+     *     [`Label`]: super::Label
+     *     [`tags`]: super::Label::tags
+     */
+    Category: string;
     /**
      * @description Text a [`TextRedaction::Clamp`] emits for out-of-range values.
      *
      *     Three forms, deserialized untagged so callers can pick the
      *     terser one for the case at hand:
      *
-     *     - **Plain string** (`"90 or older"`) — English-only shorthand.
-     *     - **Localized map** (`{"en": "90 or older", "fr": "90 ou plus"}`)
-     *       — one entry per language the deployment ships; missing
-     *       locales fall back to English at render time.
-     *     - **Format template** (`{"format": "{n} or older"}`) — the
+     *     - **Plain string** (`"90 or older"`): English-only shorthand.
+     *     - **Localized map** (`{"en": "90 or older", "fr": "90 ou plus"}`):
+     *       one entry per language the deployment ships; missing locales
+     *       fall back to English at render time.
+     *     - **Format template** (`{"format": "{n} or older"}`): the
      *       engine substitutes `{n}` for the threshold, so a ceiling of
      *       `90` renders `"90 or older"` without the caller repeating the
      *       number. Same rendering in every language.
@@ -8750,7 +8866,7 @@ interface components {
      * Format: float
      * @description Confidence score in the closed range `0.0..=1.0`.
      *
-     *     Carried by every provenance [`Event`] (the `before`/`after` of a
+     *     Carried by every provenance [`AuditEvent`] (the `before`/`after` of a
      *     recognition, fusion, or calibration) and by the effective confidence
      *     of an [`Entity`]. The newtype enforces the range at construction so
      *     no downstream code has to defend against values outside `[0, 1]`.
@@ -8760,7 +8876,7 @@ interface components {
      *     *cutoff* configured to filter scores. Compare the two with
      *     [`ConfidenceThreshold::passes`].
      *
-     *     [`Event`]: crate::entity::provenance::Event
+     *     [`AuditEvent`]: crate::entity::audit::AuditEvent
      *     [`Entity`]: crate::entity::Entity
      */
     Confidence: number;
@@ -9085,12 +9201,12 @@ interface components {
       template: components["schemas"]["PolicyTemplate"];
     } | {
       /**
-       * @description The structured policy body.
+       * @description The client-authored policy body.
        *
        *     Boxed to keep the enum small: an inline body is much larger than a
        *     template id, and most requests use a template.
        */
-      definition: components["schemas"]["PolicyDefinition"];
+      definition: components["schemas"]["PolicyDraft"];
       /** @constant */
       source: "inline";
     });
@@ -9230,7 +9346,7 @@ interface components {
      *
      *     Tagged by `modality` (snake_case) so deserialization picks the
      *     right variant and the entity vec inside is statically typed
-     *     per modality — apply-time we hand each variant back to elide
+     *     per modality: apply-time we hand each variant back to elide
      *     as a `Vec<Entity<M>>` for the appropriate `M`.
      *
      *     [`Audit`]: crate::Audit
@@ -9387,9 +9503,9 @@ interface components {
     /**
      * @description Which operator to apply to Article 9 special-category entities.
      *
-     *     - [`Erase`](Self::Erase) — the default no-lawful-basis posture.
+     *     - [`Erase`](Self::Erase): the default no-lawful-basis posture.
      *       Every match is removed.
-     *     - [`Pseudonymize`](Self::Pseudonymize) — identity-preserving
+     *     - [`Pseudonymize`](Self::Pseudonymize): identity-preserving
      *       surrogate. Suitable when an Article 9(2) carve-out
      *       (explicit consent, employment law, public-health public
      *       interest, ...) authorizes retention and downstream
@@ -9398,6 +9514,38 @@ interface components {
      *       obligation to establish and document.
      */
     GdprArticle9Treatment: "erase" | "pseudonymize";
+    /**
+     * @description Which sensitive-data labels the template's group covers.
+     *
+     *     Three tiers, each strictly widening the previous one so a
+     *     caller upgrading through the tiers never loses coverage:
+     *
+     *     - [`Article9`](Self::Article9): the nine Article 9(1)
+     *       special categories only. The default.
+     *     - [`Article9WithReidHardening`](Self::Article9WithReidHardening) -
+     *       Article 9 plus the quasi-identifiers that carry the most join
+     *       risk against public datasets: `date_of_birth`, `postal_code`,
+     *       and `gender` (the combination that re-identifies most of a
+     *       population on its own), widened with `age`, `city`,
+     *       `nationality`, `citizenship`, and `occupation`.
+     *
+     *       A product-defined tier, not a complete answer to Recital 26:
+     *       the Recital sets a reasonableness test over "all the means
+     *       reasonably likely to be used" to re-identify, judged against
+     *       the caller's own data and adversary, so no fixed label list
+     *       can satisfy it. Callers whose threat model reaches wider
+     *       extend the policy after building it.
+     *     - [`Article9And10`](Self::Article9And10): Article 9 + Recital
+     *       26 hardening + Article 10's criminal-justice labels
+     *       (`criminal_record`, `criminal_charge`, `judicial_narrative`).
+     *       Article 10 governs "personal data relating to criminal
+     *       convictions and offences", processed only under authorized
+     *       official-authority control or specific Union/Member-State
+     *       law. Callers with criminal-justice adjacency (background-
+     *       check services, court-records handling, HR compliance) pick
+     *       this tier.
+     */
+    GdprSensitiveScope: "article9" | "article9_with_reid_hardening" | "article9_and10";
     /** @description Request to generate a shareable invite code for a workspace. */
     GenerateInviteCode: {
       /** @description When the invite code expires. */
@@ -9418,193 +9566,138 @@ interface components {
     };
     /** @description Operational status of a service component. */
     HealthStatus: "healthy" | "degraded" | "unhealthy";
+    /**
+     * @description Which account-identifier labels §164.514(b)(2)(i)(J) covers.
+     *
+     *     The regulation names "account numbers" without enumerating
+     *     them; HHS OCR's 2012 guidance doesn't narrow it either. In
+     *     practice, covered entities and de-ID vendors treat bank
+     *     accounts, IBANs, and payment cards as the core §(J) set -
+     *     [`Standard`](Self::Standard). Cryptocurrency wallet addresses
+     *     are the newer case: they identify a specific holder's account
+     *     by function, and the §(R) catch-all pulls in "any other unique
+     *     identifying number, characteristic, or code" tied to an
+     *     individual, which arguably captures them. Deployments where
+     *     crypto addresses can appear in patient-facing artifacts pick
+     *     [`Extended`](Self::Extended); deployments where they can't
+     *     stay on `Standard`.
+     *
+     *     The compliant posture for anything account-shaped is
+     *     "remove"; the split is only about how broadly this template
+     *     pre-declares the account label scope. A caller who wants
+     *     broader coverage combines this template's policy with a
+     *     separate PII scope on the same request.
+     */
+    HipaaAccountNumbers: "standard" | "extended";
     /**
      * @description Which HIPAA §164.514 de-identification method to apply.
      *
      *     The tradeoff is analytic yield vs. downstream constraint:
      *
-     *     - [`SafeHarbor`](Self::SafeHarbor) — strips all eighteen
+     *     - [`SafeHarbor`](Self::SafeHarbor): strips all eighteen
      *       identifier categories. No Data Use Agreement or statistician
      *       required, but dates, coarse geography, and ages ≥ 90 all
      *       disappear or collapse.
-     *     - [`LimitedDataSet`](Self::LimitedDataSet) — narrower
+     *     - [`LimitedDataSet`](Self::LimitedDataSet): narrower
      *       subtraction (§164.514(e)(2)) that keeps dates, town/city,
      *       state, ZIP, and ages verbatim. Suitable for research and
      *       public-health handoffs *only when* a Data Use Agreement
      *       governs the recipient's use.
-     *     - [`ExpertDetermination`](Self::ExpertDetermination) —
+     *     - [`ExpertDetermination`](Self::ExpertDetermination) -
      *       starting scaffold for §164.514(b)(1). Same label set as
      *       Safe Harbor with pseudonymization as the default terminal
      *       (identity-preserving across mentions). **Does not certify
-     *       de-identification** — a qualified statistician must
+     *       de-identification**: a qualified statistician must
      *       document that re-identification risk is "very small" under
      *       the applicable methodology before the output can be treated
      *       as de-identified.
      */
     HipaaDeidMethod: "safe_harbor" | "limited_data_set" | "expert_determination";
     /**
-     * @description Per-call payload a recognizer inspects for the [`Image`] modality.
-     *
-     *     Carries the encoded bytes plus the pixel [`Dimensions`], which a
-     *     recognizer that emits unit-square boxes needs to scale them into pixel
-     *     coordinates. An optional filename aids diagnostics and encoding
-     *     inference.
-     *
-     *     [`Image`]: super::Image
-     */
-    ImageData: {
-      /** @description Pixel dimensions of the encoded image. */
-      dimensions: components["schemas"]["Dimensions"];
-      /** @description Original filename, when known. */
-      filename?: string;
-    };
-    /**
-     * @description Detected piece of sensitive information within some medium.
-     *
-     *     Generic over the [`Modality`] `M`, which is what makes the model
-     *     multimodal: a text pipeline yields `Entity<Text>`, an audio pipeline
-     *     `Entity<Audio>`, and so on. The entity's location is the modality's
-     *     [`Location`] type, `M::Location`.
-     *
-     *     # Birth and fusion
-     *
-     *     A recognizer emits an entity directly, carrying a single recognition
-     *     [`Event`] (its own finding) in the entity's [`provenance`]. When
-     *     several recognizers find the same thing, a fusion step (in
-     *     `elide`) combines their entities into one: the survivor's
-     *     [`location`] and [`confidence`] are the *fused* values, and every
-     *     contributing recognition event, plus a deduplication event, is
-     *     retained in its provenance. The entity therefore carries its full
-     *     audit trail with it.
-     *
-     *     [`Location`]: Modality::Location
-     *     [`Event`]: crate::entity::provenance::Event
-     *     [`provenance`]: Entity::provenance
-     *     [`location`]: Entity::location
-     *     [`confidence`]: Entity::confidence
-     */
-    ImageEntity: {
-      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
-      confidence: components["schemas"]["Confidence"];
-      /**
-       * @description Coreference identifier, if a recognizer resolved this entity as one
-       *     mention of a cluster. Entities sharing an [`EntityCoRef`] denote the
-       *     same real-world thing.
-       */
-      coref?: components["schemas"]["EntityCoRef"];
-      /**
-       * Format: uuid
-       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
-       *     when the entity is assembled.
-       */
-      id: string;
-      /**
-       * @description What kind of sensitive information this is (resolved via a
-       *     [`LabelCatalog`]).
-       */
-      label: components["schemas"]["LabelRef"];
-      /**
-       * @description The language of this entity's surrounding text, when a recognizer
-       *     resolved one. `None` when unknown or language-agnostic.
-       */
-      language?: string;
-      /**
-       * @description Location of the entity within the medium (fused, if it came from more
-       *     than one detection).
-       */
-      location: components["schemas"]["ImageLocation"];
-      /**
-       * @description Detection audit trail: every contributing detection and the fusion
-       *     event, if any.
+     * @description One node in an entity's audit DAG: a thing that happened, with its
+     *     effect on confidence and its tamper-evident links.
+     *
+     *     Events are recorded on an entity's [`AuditLog`], forming the full audit
+     *     trail of its life: each recognizer that found it, the deduplication that
+     *     fused them, any score calibration, and the redaction that hid it. The
+     *     uniform spine (who, resulting score, when) is the same for every event; the
+     *     [`kind`] carries the event-specific detail *and* the explanation of why the
+     *     event happened.
+     *
+     *     Each event links to its [`parents`] by their [`hash`]: a birth event (a
+     *     recognizer's first detection) has no parents, a normal step has one, and a
+     *     [fusion](crate::entity::audit::AuditLog::record_fusion) has several. Its own
+     *     [`hash`] folds the
+     *     payload together with the parents' hashes, so altering any event breaks
+     *     every event downstream of it: [`AuditLog::verify`] walks the DAG and
+     *     reports the first break.
+     *
+     *     `entity.confidence` always equals the [`confidence`] of the most recent
+     *     event. The confidence *flowing in* is not stored: it is the parents'
+     *     [`confidence`], recovered from the DAG.
+     *
+     *     [`AuditLog`]: crate::entity::audit::AuditLog
+     *     [`AuditLog::record_fusion`]: crate::entity::audit::AuditLog::record_fusion
+     *     [`AuditLog::verify`]: crate::entity::audit::AuditLog::verify
+     *     [`kind`]: AuditEvent::kind
+     *     [`parents`]: AuditEvent::parents
+     *     [`hash`]: AuditEvent::hash
+     *     [`confidence`]: AuditEvent::confidence
+     */
+    ImageAuditEvent: {
+      /**
+       * @description Confidence after this event: the entity's effective confidence once it
+       *     has happened.
        */
-      provenance: components["schemas"]["ImageProvenance"];
+      confidence: components["schemas"]["Confidence"];
       /**
-       * @description Byte range of the match in the *recognized text* it was found in (the
-       *     OCR layout text, the audio transcript, or the text payload itself) —
-       *     the stable key back into that enrichment artifact, where the rich
-       *     context lives (which OCR block, which speaker) that the geometric
-       *     [`location`] cannot hold. `None` for entities not found via text
-       *     recognition (e.g. a VLM box). Provenance, not a coordinate: redaction
-       *     uses [`location`]; an audit uses this with the artifact.
+       * @description This event's hash, over its payload and its parents' hashes. Assigned by
+       *     [`AuditLog`] when the event is recorded; read it through
+       *     [`hash`](Self::hash). Recomputing it is how the DAG is verified.
        *
-       *     [`location`]: Entity::location
-       */
-      recognized_range?: components["schemas"]["Range_of_uint"];
-    };
-    /**
-     * @description One recognized entity plus the optional reviewer override.
-     *
-     *     The bound mirrors elide's [`Entity<M>`]: serialization needs
-     *     `M::Location` and `M::Data` (de)serializable, and JsonSchema
-     *     derivation needs them schema-able. All four modalities elide
-     *     ships satisfy these under the `serde` + `schema` features.
-     */
-    ImageEntityRecord: {
-      /** @description The elide entity, as recognition produced it. */
-      entity: components["schemas"]["ImageEntity"];
-      /**
-       * @description Reviewer-supplied redaction override.
+       *     Not publicly settable: only [`AuditLog`] assigns it, so a caller cannot
+       *     forge a self-consistent event outside the recording path.
        *
-       *     `None` means "use the matching policy rule's decision";
-       *     `Some(...)` overrides that rule for this specific entity
-       *     at apply time. Reviewer overrides take precedence over
-       *     every policy rule and inherit the authority of the
-       *     [`Review::policy_id`] they name — the audit event's
-       *     attribution stamps that policy so the trail names the
-       *     authority under which the override fired.
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
        */
-      review?: components["schemas"]["Review"];
-    };
-    /**
-     * @description One thing that happened to an entity, with its effect on confidence.
-     *
-     *     Events are recorded in order on an entity's [`Provenance`], forming
-     *     the full audit trail of its life: each recognizer that found it, the
-     *     deduplication that fused them, any score calibration, and the
-     *     redaction that hid it. The uniform spine (who, before/after score,
-     *     when, why) is the same for every event; the [`kind`] carries the
-     *     event-specific detail.
-     *
-     *     `entity.confidence` always equals the [`after`] of the most recent
-     *     event.
-     *
-     *     [`Provenance`]: crate::entity::provenance::Provenance
-     *     [`kind`]: Event::kind
-     *     [`after`]: Event::after
-     */
-    ImageEvent: {
-      /** @description Confidence after this event. */
-      after: components["schemas"]["Confidence"];
-      /** @description When the event happened (UTC). */
-      at: string;
+      hash: components["schemas"]["AuditHash"];
+      /** @description Kind of event, with its event-specific detail and its rationale. */
+      kind: components["schemas"]["ImageAuditKind"];
       /**
-       * @description Confidence before this event, if there was a prior value. `None` on
-       *     the first (birth) event.
+       * @description The events this one follows, by their hash. Empty for a birth event, one
+       *     entry for a normal step, several for a fusion. Assigned by [`AuditLog`]
+       *     when the event is recorded; read it through [`parents`](Self::parents).
+       *
+       *     Not publicly settable: the links are the tamper-evident structure, so
+       *     only [`AuditLog::record`] / [`AuditLog::record_fusion`] assign them.
+       *
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
+       *     [`AuditLog::record`]: crate::entity::audit::AuditLog::record
+       *     [`AuditLog::record_fusion`]: crate::entity::audit::AuditLog::record_fusion
        */
-      before?: components["schemas"]["Confidence"];
-      /** @description Kind of event, with its event-specific detail. */
-      kind: components["schemas"]["ImageEventKind"];
-      /** @description Free-text explanation of what the event did and why. */
-      reason: string;
+      parents: components["schemas"]["AuditHash"][];
       /**
        * @description Who produced this event: a recognizer name, a deduplication strategy,
        *     an operator, or whatever acted.
        */
       source: string;
+      /** @description When the event happened (UTC). */
+      timestamp: string;
     };
     /**
-     * @description Kind of an [`Event`], carrying its event-specific detail.
+     * @description Kind of an [`AuditEvent`], carrying its event-specific detail and the
+     *     rationale for why it happened.
      *
      *     `#[non_exhaustive]`: new event kinds (verification, annotation, …)
      *     can be added compatibly. The recognition kinds ([`Pattern`],
      *     [`Model`]) carry the matched [`Location`]; the rest carry their own
      *     data.
      *
-     *     [`Pattern`]: EventKind::Pattern
-     *     [`Model`]: EventKind::Model
+     *     [`Pattern`]: AuditKind::Pattern
+     *     [`Model`]: AuditKind::Model
      *     [`Location`]: Modality::Location
      */
-    ImageEventKind: {
+    ImageAuditKind: {
       /** @constant */
       kind: "pattern";
       /** @description Where the recognizer matched. */
@@ -9668,7 +9761,7 @@ interface components {
        *     it is the keyword resolved through the modality's [`locate`] (a
        *     pixel box for image, a time span for audio, the byte range for
        *     text/tabular). `None` when the keyword's stream range could not be
-       *     placed — symmetric with a match the recognizer itself drops.
+       *     placed, symmetric with a match the recognizer itself drops.
        *
        *     [`locate`]: crate::modality::TextRecognizable::locate
        */
@@ -9686,12 +9779,174 @@ interface components {
       /** @description How much the output leaks about the original. */
       leak_profile: components["schemas"]["LeakProfile"];
       /**
-       * @description Which selection rule chose this operator — the automatic "why"
+       * @description Which selection rule chose this operator: the automatic "why"
        *     (matched a label, a tag, a predicate, or the fallback).
        */
       matched_by: components["schemas"]["RuleMatch"];
       /** @description Which operator (name + version) ran. */
       operator: components["schemas"]["OperatorId"];
+      /**
+       * @description BLAKE3 digest of the original text the operator hid, when the
+       *     redaction layer recorded it. Proves *what* was redacted without
+       *     storing the plaintext; `None` when the operator did not capture it.
+       */
+      span_hash?: components["schemas"]["AuditHash"];
+      /**
+       * Format: uint32
+       * @description Byte length of the original text the operator hid, paired with
+       *     [`span_hash`](Self::Redaction::span_hash). `None` when not captured.
+       */
+      span_length?: number;
+    };
+    /**
+     * @description Full audit trail of an [`Entity`]: every [`AuditEvent`] in its life, as a
+     *     tamper-evident DAG.
+     *
+     *     Where Presidio keeps a shallow, optional, per-stage explanation that is
+     *     stripped by default, an `AuditLog` is always present and records the
+     *     entity's *entire* life: each recognizer that found it, the deduplication
+     *     that fused them, any confidence calibration, and the redaction that hid it.
+     *     Nothing is collapsed: every recognizer keeps its own recognition event with
+     *     its location and score.
+     *
+     *     The events form a **directed acyclic graph**, not a flat list. A recognizer
+     *     records a birth event (no parents); each later step links to the event it
+     *     follows; and a [fusion](Self::record_fusion) links to *several* parents at
+     *     once: the heads of the trails it combines. This is the true shape of a
+     *     deduplicated entity: two recognizers are siblings, then a fusion joins them.
+     *     The events are stored in the order they were recorded, which is a
+     *     topological order of the DAG (a parent is always recorded before its
+     *     children).
+     *
+     *     Two chains ride the DAG's edges:
+     *
+     *     - a **confidence chain**, where each event's [`confidence`] is the entity's
+     *       effective score after it; the score flowing *in* is its parents'
+     *       confidence, so [`final_confidence`] and the full history are recoverable;
+     *     - a **hash chain**, where each event's [`hash`] folds its payload together
+     *       with its parents' hashes, so any edit, reorder, insertion, or deletion of
+     *       an earlier event breaks every event downstream. [`verify`] walks the DAG
+     *       and reports the first break.
+     *
+     *     [`Entity`]: crate::entity::Entity
+     *     [`confidence`]: AuditEvent::confidence
+     *     [`hash`]: AuditEvent::hash
+     *     [`final_confidence`]: Self::final_confidence
+     *     [`verify`]: Self::verify
+     */
+    ImageAuditLog: components["schemas"]["ImageAuditEvent"][];
+    /**
+     * @description Per-call payload a recognizer inspects for the [`Image`] modality.
+     *
+     *     Carries the encoded bytes plus the pixel [`Dimensions`], which a
+     *     recognizer that emits unit-square boxes needs to scale them into pixel
+     *     coordinates. An optional filename aids diagnostics and encoding
+     *     inference.
+     *
+     *     [`Image`]: super::Image
+     */
+    ImageData: {
+      /** @description Pixel dimensions of the encoded image. */
+      dimensions: components["schemas"]["Dimensions"];
+      /** @description Original filename, when known. */
+      filename?: string;
+    };
+    /**
+     * @description Detected piece of sensitive information within some medium.
+     *
+     *     Generic over the [`Modality`] `M`, which is what makes the model
+     *     multimodal: a text pipeline yields `Entity<Text>`, an audio pipeline
+     *     `Entity<Audio>`, and so on. The entity's location is the modality's
+     *     [`Location`] type, `M::Location`.
+     *
+     *     # Birth and fusion
+     *
+     *     A recognizer emits an entity directly, carrying a single recognition
+     *     [`AuditEvent`] (its own finding) in the entity's [`audit`] trail. When
+     *     several recognizers find the same thing, a fusion step (in
+     *     `elide`) combines their entities into one: the survivor's
+     *     [`location`] and [`confidence`] are the *fused* values, and every
+     *     contributing recognition event, plus a deduplication event, is
+     *     retained in its audit trail. The entity therefore carries its full
+     *     audit trail with it.
+     *
+     *     [`Location`]: Modality::Location
+     *     [`AuditEvent`]: crate::entity::audit::AuditEvent
+     *     [`audit`]: Entity::audit
+     *     [`location`]: Entity::location
+     *     [`confidence`]: Entity::confidence
+     */
+    ImageEntity: {
+      /**
+       * @description Tamper-evident audit trail: every contributing detection, the fusion
+       *     event if any, and the redaction that hid it, as a hash-linked DAG.
+       */
+      audit: components["schemas"]["ImageAuditLog"];
+      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
+      confidence: components["schemas"]["Confidence"];
+      /**
+       * @description Coreference identifier, if a recognizer resolved this entity as one
+       *     mention of a cluster. Entities sharing an [`EntityCoRef`] denote the
+       *     same real-world thing.
+       */
+      coref?: components["schemas"]["EntityCoRef"];
+      /**
+       * Format: uuid
+       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
+       *     when the entity is assembled.
+       */
+      id: string;
+      /**
+       * @description What kind of sensitive information this is (resolved via a
+       *     [`LabelCatalog`]).
+       */
+      label: components["schemas"]["LabelRef"];
+      /**
+       * @description The language of this entity's surrounding text, when a recognizer
+       *     resolved one. `None` when unknown or language-agnostic.
+       */
+      language?: string;
+      /**
+       * @description Location of the entity within the medium (fused, if it came from more
+       *     than one detection).
+       */
+      location: components["schemas"]["ImageLocation"];
+      /**
+       * @description Byte range of the match in the *recognized text* it was found in (the
+       *     OCR layout text, the audio transcript, or the text payload itself) —
+       *     the stable key back into that enrichment artifact, where the rich
+       *     context lives (which OCR block, which speaker) that the geometric
+       *     [`location`] cannot hold. `None` for entities not found via text
+       *     recognition (e.g. a VLM box). An audit key, not a coordinate: redaction
+       *     uses [`location`]; an audit uses this with the artifact.
+       *
+       *     [`location`]: Entity::location
+       */
+      recognized_range?: components["schemas"]["Range_of_uint"];
+    };
+    /**
+     * @description One recognized entity plus the optional reviewer override.
+     *
+     *     The bound mirrors elide's [`Entity<M>`]: serialization needs
+     *     `M::Location` and `M::Data` (de)serializable, and JsonSchema
+     *     derivation needs them schema-able. All four modalities elide
+     *     ships satisfy these under the `serde` + `schema` features.
+     */
+    ImageEntityRecord: {
+      /** @description The elide entity, as recognition produced it. */
+      entity: components["schemas"]["ImageEntity"];
+      /**
+       * @description Reviewer-supplied redaction override.
+       *
+       *     `None` means "use the matching policy rule's decision";
+       *     `Some(...)` overrides that rule for this specific entity
+       *     at apply time. Reviewer overrides take precedence over
+       *     every policy rule and inherit the authority of the
+       *     [`Review::policy_id`] they name: the audit event's
+       *     attribution stamps that policy so the trail names the
+       *     authority under which the override fired.
+       */
+      review?: components["schemas"]["Review"];
     };
     /**
      * @description Located, typed piece of context a recognizer may treat as in-context
@@ -9738,31 +9993,6 @@ interface components {
        */
       polygon?: components["schemas"]["Polygon"];
     };
-    /**
-     * @description Full audit trail of an [`Entity`]: every [`Event`] in its life, in
-     *     order.
-     *
-     *     This is the model's answer to "full provenance": where Presidio keeps
-     *     a shallow, optional, per-stage explanation that is stripped by
-     *     default, a `Provenance` is always present and records the entity's
-     *     *entire* life as an ordered list of events: each recognizer that
-     *     found it, the deduplication that fused them, any confidence
-     *     calibration, and the redaction that hid it. Nothing is collapsed:
-     *     every recognizer keeps its own recognition event with its location
-     *     and score.
-     *
-     *     The events form a confidence chain (each event's [`after`] is the
-     *     next's [`before`]) so the final confidence and its full history are
-     *     always recoverable.
-     *
-     *     [`Entity`]: crate::entity::Entity
-     *     [`after`]: Event::after
-     *     [`before`]: Event::before
-     */
-    ImageProvenance: {
-      /** @description Events, in the order they happened. */
-      events: components["schemas"]["ImageEvent"][];
-    };
     /** @description Operator spec a `redact` image rule carries. */
     ImageRedaction: {
       /** @constant */
@@ -9947,7 +10177,7 @@ interface components {
     InviteStatus: "pending" | "accepted" | "declined" | "canceled" | "expired" | "revoked";
     /**
      * @description Kind of sensitive information: a stable [`id`], per-language
-     *     [`LabelLocale`]s, and zero or more tags.
+     *     [`LabelLocale`]s, an optional [`category`], and zero or more tags.
      *
      *     # Identity
      *
@@ -9965,18 +10195,25 @@ interface components {
      *     text — NER and LLM read the analysis language's name and description to
      *     prompt the model, keyed by the stable id.
      *
-     *     # Tags
+     *     # Category and tags
+     *
+     *     [`category`] is the single coarse group a label belongs to (`financial`,
+     *     `health`, `identity`, …), for organizing detected entities by kind. Built-in
+     *     labels ship with one; a custom label has none unless set.
      *
-     *     [`tags`] is a free-form list of short identifiers policy selectors can
-     *     match against. Built-in labels carry category tags (`personal_identity`,
-     *     `contact_info`, `financial`, …) plus cross-cutting tags where applicable
-     *     (`pii`, `phi`, `pci`). Custom labels can ship with zero tags.
+     *     [`tags`] is a free-form list of *cross-cutting* markers a policy selector
+     *     matches against — sensitivity flags a label may carry several of (`pii`,
+     *     `phi`, `pci`, `sad`, `secret`). Distinct from the category: a label has at
+     *     most one category but any number of tags. Custom labels can ship with zero
+     *     of either.
      *
      *     [`id`]: Label::id
      *     [`localization`]: Label::localization
+     *     [`category`]: Label::category
      *     [`tags`]: Label::tags
      */
     Label: {
+      category?: components["schemas"]["Category"];
       id: string;
       localizations: components["schemas"]["LocalizedText"];
       tags: string[];
@@ -10019,27 +10256,32 @@ interface components {
      *     rule that targets that list references the group by name
      *     instead of respelling the labels. When elide adds a new label
      *     to a category, extending the group covers every rule that
-     *     referenced it — no rule edit.
-     *
-     *     **Compilation**: at request time the engine synthesises a
-     *     `group:<policy_id>:<name>` tag on every label listed in the
-     *     group, then rewrites [`Predicate::LabelInGroup { group }`]
-     *     into [`Predicate::TagOneOf { tags: ["group:<policy_id>:<name>"] }`].
-     *     That routes through the same `Anonymizer::with_tag` fast
-     *     path as any authored tag — no new engine machinery, no
-     *     per-request walk over group membership. Scoping the tag by
-     *     `policy_id` keeps two policies that both declare `hipaa_18`
-     *     with different labelsets from stepping on each other.
+     *     referenced it: no rule edit.
+     *
+     *     **Compilation**: groups stay on the policy. Evaluating a
+     *     [`Predicate::LabelInGroup { group }`] looks the name up in
+     *     the policy's own group table and tests the entity's label for
+     *     membership. Nothing is stamped onto the label catalog, so two
+     *     policies that both declare `hipaa_18` with different labelsets
+     *     cannot step on each other.
      *
      *     **Unknown group names error at request validation**, not at
      *     apply time. A typo doesn't silently underfire.
      *
      *     [`PolicyDefinition`]: super::PolicyDefinition
-     *     [`Predicate::LabelInGroup`]: super::predicate::Predicate::LabelInGroup
-     *     [`Predicate::LabelInGroup { group }`]: super::predicate::Predicate::LabelInGroup
-     *     [`Predicate::TagOneOf { tags: ["group:<policy_id>:<name>"] }`]: super::predicate::Predicate::TagOneOf
+     *     [`Predicate::LabelInGroup`]: crate::Predicate::LabelInGroup
+     *     [`Predicate::LabelInGroup { group }`]: crate::Predicate::LabelInGroup
      */
     LabelGroup: {
+      /**
+       * @description Why this cluster exists: the authority that defines it.
+       *
+       *     A group usually maps to one regulatory category (HIPAA's
+       *     eighteen identifiers, GDPR Article 9(1)'s nine special
+       *     categories), so this is where that mapping is recorded as
+       *     data rather than prose.
+       */
+      attribution?: components["schemas"]["AttributionKind"];
       /** @description Optional description for reviewers. */
       description?: string;
       /**
@@ -10047,7 +10289,7 @@ interface components {
        *
        *     A label that doesn't appear in the request's compiled
        *     [`LabelCatalog`] is silently skipped at tag-synthesis time
-       *     — a group can safely list labels the current build
+       *     : a group can safely list labels the current build
        *     doesn't emit (e.g. modality-gated ones); rules keyed off
        *     the group still fire on whatever labels *are* present.
        *
@@ -10058,11 +10300,10 @@ interface components {
        * @description Stable name a [`Predicate::LabelInGroup`] references.
        *
        *     Free-form; a policy layer picks the vocabulary. Recommend
-       *     snake_case identifiers (`hipaa_18`, `gdpr_article_9`) —
-       *     they compile to `group:hipaa_18` tags on the catalog and
-       *     read cleanly in audit provenance.
+       *     snake_case identifiers (`hipaa_18`, `gdpr_article_9`) -
+       *     they read cleanly in audit provenance.
        *
-       *     [`Predicate::LabelInGroup`]: super::predicate::Predicate::LabelInGroup
+       *     [`Predicate::LabelInGroup`]: crate::Predicate::LabelInGroup
        */
       name: string;
     };
@@ -10109,8 +10350,9 @@ interface components {
       /**
        * @description Builtin label names to enable.
        *
-       *     E.g. `"email_address"`, `"phone_number"`. Unknown names
-       *     log a warning and are skipped.
+       *     E.g. `"email_address"`, `"phone_number"`. An unknown name
+       *     is rejected at request compile time: a typo fails loudly
+       *     rather than quietly dropping the label from the policy.
        */
       builtins?: components["schemas"]["LabelRef"][];
       /** @description Custom labels defined inline by the caller. */
@@ -10527,33 +10769,6 @@ interface components {
       /** @description Whether to send email notifications. */
       notifyViaEmail: boolean;
     };
-    /**
-     * @description Policy for turning a document's pages into images for OCR.
-     *
-     *     A born-digital PDF has a selectable text layer and needs no OCR; a
-     *     scanned one is image-only and must be rendered to images first. [`Auto`]
-     *     is the right default — extract text, render only what lacks it — but the
-     *     text-layer parser that drives that decision is not in place yet, so today
-     *     only [`Force`] actually renders.
-     *
-     *     Serializes with an internal `kind` tag (`{"kind": "auto"}`,
-     *     `{"kind": "force", "dpi": 300}`, `{"kind": "never"}`).
-     *
-     *     [`Auto`]: OcrMode::Auto
-     *     [`Force`]: OcrMode::Force
-     */
-    OcrMode: {
-      /** @constant */
-      kind: "auto";
-    } | {
-      /** @description Resolution to render pages at; [`Dpi::OCR`] (300) is typical. */
-      dpi: components["schemas"]["Dpi"];
-      /** @constant */
-      kind: "force";
-    } | {
-      /** @constant */
-      kind: "never";
-    };
     /**
      * @description How a workspace's documents are turned into images for OCR during detection.
      *
@@ -10601,12 +10816,12 @@ interface components {
     /**
      * @description Which PCI DSS subsection this template addresses.
      *
-     *     - [`PanRender`](Self::PanRender) — §3.5.1 render posture for
+     *     - [`PanRender`](Self::PanRender): §3.5.1 render posture for
      *       stored Primary Account Numbers. Carries a [`PciPanRender`]
      *       picking between the shipped render approaches.
-     *     - [`SavErase`](Self::SavErase) — §3.3.1 prohibition on
+     *     - [`SavErase`](Self::SavErase): §3.3.1 prohibition on
      *       storing Sensitive Authentication Data (CVV/CVC, track data,
-     *       PIN blocks) after authorization. No options — SAV has one
+     *       PIN blocks) after authorization. No options: SAV has one
      *       posture: erase.
      */
     PciDssPart: {
@@ -10643,7 +10858,7 @@ interface components {
      *     Callers wanting more than one dispatched from one policy
      *     compose multiple templates.
      *
-     *     [`Engine::with_key_provider`]: https://docs.rs/nvisy-engine/latest/nvisy_engine/struct.Engine.html
+     *     [`Engine::with_key_provider`]: https://docs.rs/elide-pipeline/latest/elide_pipeline/struct.Engine.html
      */
     PciPanRender: "truncate" | "truncate_last_four" | "hmac_sha256" | "hmac_sha512";
     /** @description Pipeline response. */
@@ -11015,24 +11230,19 @@ interface components {
       /**
        * @description Named clusters of [`LabelRef`]s this policy's rules may
        *     reference by name via [`Predicate::LabelInGroup`]. Scoped
-       *     to this policy — a rule can only name a group its own
+       *     to this policy: a rule can only name a group its own
        *     policy declared; unknown references error at request
        *     validation. Two policies that both declare `hipaa_18` with
        *     different labelsets stay independent.
        *
        *     [`LabelRef`]: elide_core::entity::LabelRef
-       *     [`Predicate::LabelInGroup`]: predicate::Predicate::LabelInGroup
+       *     [`Predicate::LabelInGroup`]: crate::Predicate::LabelInGroup
        */
       groups?: components["schemas"]["LabelGroup"][];
       /**
        * Format: uuid
        * @description Stable identifier. UUIDv7 recommended (time-ordered);
        *     customer-supplied so re-submissions carry the same id.
-       *     Engine stamps this into the redaction event's
-       *     [`Attribution::name`] so reviewers can find this policy
-       *     from any redaction it drove.
-       *
-       *     [`Attribution::name`]: elide_core::entity::provenance::Attribution::name
        */
       id: string;
       /**
@@ -11043,10 +11253,56 @@ interface components {
        *     tag-based [`Predicate::TagOneOf`] matching.
        *
        *     [`LabelCatalog`]: elide_core::entity::LabelCatalog
-       *     [`Predicate::TagOneOf`]: predicate::Predicate::TagOneOf
+       *     [`Predicate::TagOneOf`]: crate::Predicate::TagOneOf
+       */
+      labels?: components["schemas"]["Labels"];
+      /**
+       * @description Human-readable name. Display-only. Does not key anything.
+       *
+       *     Names the policy in a redaction event's [`Attribution`]
+       *     when a rule that fired carried no [`AttributionKind::Cited`]
+       *     attribution to render.
+       *
+       *     [`Attribution`]: elide_core::entity::audit::Attribution
+       *     [`AttributionKind::Cited`]: elide_core::entity::audit::AttributionKind::Cited
+       */
+      name: string;
+      /** @description Ordered rules. First match wins within this policy. */
+      rules?: components["schemas"]["PolicyRule"][];
+      /**
+       * @description The shipped template this policy was built from, when it
+       *     was.
+       *
+       *     Provenance, not fidelity: callers are expected to mutate a
+       *     template's policy before submitting, so this records where
+       *     the policy came from and says nothing about whether it
+       *     still matches. `None` means hand-authored.
+       */
+      template?: components["schemas"]["TemplateOrigin"];
+    };
+    /**
+     * @description A client-authored policy body: the parts of a policy definition a caller may
+     *     set, without the fields the server owns.
+     *
+     *     The engine's `PolicyDefinition` also carries an `id` and a `template` origin.
+     *     Both are server-owned — the `id` is minted at creation and the `template`
+     *     records which built-in a policy was seeded from (provenance). Neither is
+     *     representable here, so a client cannot mint ids or forge provenance; the
+     *     server stamps them in [`into_definition`](PolicyDraft::into_definition).
+     */
+    PolicyDraft: {
+      /** @description Optional description for reviewers. */
+      description?: string;
+      /** @description Per-policy catch-all, fired when no rule matched. */
+      fallback?: components["schemas"]["ModalityRedactions"];
+      /** @description Named clusters of labels this policy's rules may reference by name. */
+      groups?: components["schemas"]["LabelGroup"][];
+      /**
+       * @description Vocabulary the policy operates over: builtins picked by name plus
+       *     caller-authored custom label schemas.
        */
       labels?: components["schemas"]["Labels"];
-      /** @description Human-readable name. Display-only. Does not key anything. */
+      /** @description Human-readable name. Display-only. */
       name: string;
       /** @description Ordered rules. First match wins within this policy. */
       rules?: components["schemas"]["PolicyRule"][];
@@ -11071,16 +11327,30 @@ interface components {
      *     [`PolicyDefinition`]: super::PolicyDefinition
      */
     PolicyRule: {
+      /**
+       * @description Why this rule exists: the authority it answers to.
+       *
+       *     The engine renders it into the redaction event's
+       *     [`Attribution`], so a reviewer sees the provision rather
+       *     than a bare UUID. `None` falls back to recording the
+       *     policy and rule ids alone.
+       *
+       *     Optional so ad-hoc and hand-authored rules stay cheap to
+       *     write; the shipped templates set it on every rule.
+       *
+       *     [`Attribution`]: elide_core::entity::audit::Attribution
+       */
+      attribution?: components["schemas"]["AttributionKind"];
       /** @description Optional description for reviewers. */
       description?: string;
       /**
        * Format: uuid
        * @description Stable identifier. UUIDv7 recommended. Engine stamps it
-       *     into the redaction event's [`Attribution::description`] so
+       *     into the redaction event's [`Attribution::source_id`] so
        *     reviewers can trace which rule fired. Every attachment a
        *     [`RuleDispatch::Table`] expands into shares this UUID.
        *
-       *     [`Attribution::description`]: elide_core::entity::provenance::Attribution::description
+       *     [`Attribution::source_id`]: elide_core::entity::audit::Attribution::source_id
        */
       id: string;
       /** @description Human-readable name. Display-only. */
@@ -11093,7 +11363,7 @@ interface components {
        *     policy in the chain).
        *
        *     Boxed to keep [`RuleDispatch`]'s stack footprint
-       *     small — [`ModalityRedactions`] carries four optional
+       *     small: [`ModalityRedactions`] carries four optional
        *     per-modality operator enums and dominates the variant
        *     size. `Table`'s `Vec<LabelEntry>` already heap-allocates
        *     its entries, so boxing here keeps the two variants
@@ -11173,6 +11443,15 @@ interface components {
      *     `{"kind": "pci_dss_pan", "render": "hmac_sha256"}`.
      */
     PolicyTemplate: {
+      /**
+       * @description Which §(J) account-identifier labels to remove. Defaults
+       *     to [`HipaaAccountNumbers::Standard`] (bank account +
+       *     IBAN + payment card). Pick
+       *     [`HipaaAccountNumbers::Extended`] to add crypto wallet
+       *     addresses under the §(R) catch-all reading.
+       * @default standard
+       */
+      accounts: components["schemas"]["HipaaAccountNumbers"];
       /** @constant */
       kind: "hipaa_deidentification";
       /**
@@ -11184,7 +11463,18 @@ interface components {
       /** @constant */
       kind: "gdpr_article9";
       /**
-       * @description Which operator to apply to Article 9 matches. See
+       * @description Which sensitive-data labels to cover. Defaults to
+       *     [`GdprSensitiveScope::Article9`] (nine Article 9(1)
+       *     categories only). Pick
+       *     [`GdprSensitiveScope::Article9WithReidHardening`] to add
+       *     the quasi-identifier set, or
+       *     [`GdprSensitiveScope::Article9And10`] to also cover
+       *     Article 10 criminal-justice data.
+       * @default article9
+       */
+      scope: components["schemas"]["GdprSensitiveScope"];
+      /**
+       * @description Which operator to apply to matches. See
        *     [`GdprArticle9Treatment`] for the tradeoff.
        */
       treatment: components["schemas"]["GdprArticle9Treatment"];
@@ -11286,6 +11576,33 @@ interface components {
       /** Format: uint */
       start: number;
     };
+    /**
+     * @description Policy for rendering a document's pages to images.
+     *
+     *     [`Auto`] is the default: use the text layer where it exists (redact by
+     *     deleting glyphs) and render only where it is absent. [`Always`] renders
+     *     every page regardless of the text layer, for documents whose text is
+     *     missing, garbled, or a watermark. [`Never`] relies on the text layer only.
+     *
+     *     Serializes with an internal `kind` tag (`{"kind": "auto"}`,
+     *     `{"kind": "always", "dpi": 300}`, `{"kind": "never"}`).
+     *
+     *     [`Auto`]: RasterMode::Auto
+     *     [`Always`]: RasterMode::Always
+     *     [`Never`]: RasterMode::Never
+     */
+    RasterMode: {
+      /** @constant */
+      kind: "auto";
+    } | {
+      /** @description Resolution to render pages at; [`Dpi::OCR`] (300) is typical. */
+      dpi: components["schemas"]["Dpi"];
+      /** @constant */
+      kind: "always";
+    } | {
+      /** @constant */
+      kind: "never";
+    };
     /** @description The engine's registered recognizers, grouped by kind. */
     RecognizerCatalog: {
       /** @description LLM recognizers. */
@@ -11304,20 +11621,28 @@ interface components {
      *
      *     Owned rather than borrowing from the engine so callers can
      *     carry the value past the borrow that produced it. Cloning is
-     *     cheap — [`HipStr`] shares the backing string via an `Arc`
+     *     cheap: [`HipStr`] shares the backing string via an `Arc`
      *     header.
      */
     RegisteredRecognizer: {
       /** @description Optional human-readable description. */
       description?: string;
       /**
-       * @description Recognizer name — the identifier a request's allowlist
+       * @description Recognizer name: the identifier a request's allowlist
        *     picks by.
        */
       name: string;
       /**
        * @description Provider slug. NER: `"bento"`, `"mock"`. LLM: `"openai"`,
        *     `"anthropic"`, `"gemini"`, `"ollama"`, `"mock"`.
+       *
+       *     Owned so the type deserializes from a runtime buffer: a
+       *     `&'static str` field would make the derive emit
+       *     `Deserialize<'static>` only, which compiles against string
+       *     literals but not against an owned `String` or a reader -
+       *     the shapes a host actually decodes from. Borrowing a
+       *     `&'static str` into a [`HipStr`] does not allocate, so
+       *     engine-side construction stays free.
        */
       provider: string;
     };
@@ -11398,7 +11723,7 @@ interface components {
      * @description A reviewer-supplied redaction override with the policy
      *     authority it draws from.
      *
-     *     The `policy_id` isn't just for audit — it also picks which
+     *     The `policy_id` isn't just for audit: it also picks which
      *     per-policy pseudonym vault and per-policy [`KeyProvider`] the
      *     override's operator resolves against, so an override using
      *     [`Pseudonymize`] or [`HmacHash`] stays consistent with the
@@ -11422,7 +11747,7 @@ interface components {
        *     the anonymize request. The audit event stamps this UUID
        *     as the attribution `name`.
        *
-       *     [`PolicyDefinition`]: nvisy_schema::policy::PolicyDefinition
+       *     [`PolicyDefinition`]: elide_governance::PolicyDefinition
        */
       policyId: string;
     };
@@ -11439,7 +11764,7 @@ interface components {
      *     closure into provenance, so [`Predicate`] records only that a predicate
      *     matched, not which one.
      *
-     *     [`Redaction`]: crate::entity::provenance::EventKind::Redaction
+     *     [`Redaction`]: crate::entity::audit::AuditKind::Redaction
      *     [`Predicate`]: RuleMatch::Predicate
      */
     RuleMatch: {
@@ -11781,152 +12106,90 @@ interface components {
       reportId?: string;
     };
     /**
-     * @description Detected piece of sensitive information within some medium.
+     * @description One node in an entity's audit DAG: a thing that happened, with its
+     *     effect on confidence and its tamper-evident links.
      *
-     *     Generic over the [`Modality`] `M`, which is what makes the model
-     *     multimodal: a text pipeline yields `Entity<Text>`, an audio pipeline
-     *     `Entity<Audio>`, and so on. The entity's location is the modality's
-     *     [`Location`] type, `M::Location`.
+     *     Events are recorded on an entity's [`AuditLog`], forming the full audit
+     *     trail of its life: each recognizer that found it, the deduplication that
+     *     fused them, any score calibration, and the redaction that hid it. The
+     *     uniform spine (who, resulting score, when) is the same for every event; the
+     *     [`kind`] carries the event-specific detail *and* the explanation of why the
+     *     event happened.
      *
-     *     # Birth and fusion
+     *     Each event links to its [`parents`] by their [`hash`]: a birth event (a
+     *     recognizer's first detection) has no parents, a normal step has one, and a
+     *     [fusion](crate::entity::audit::AuditLog::record_fusion) has several. Its own
+     *     [`hash`] folds the
+     *     payload together with the parents' hashes, so altering any event breaks
+     *     every event downstream of it: [`AuditLog::verify`] walks the DAG and
+     *     reports the first break.
      *
-     *     A recognizer emits an entity directly, carrying a single recognition
-     *     [`Event`] (its own finding) in the entity's [`provenance`]. When
-     *     several recognizers find the same thing, a fusion step (in
-     *     `elide`) combines their entities into one: the survivor's
-     *     [`location`] and [`confidence`] are the *fused* values, and every
-     *     contributing recognition event, plus a deduplication event, is
-     *     retained in its provenance. The entity therefore carries its full
-     *     audit trail with it.
+     *     `entity.confidence` always equals the [`confidence`] of the most recent
+     *     event. The confidence *flowing in* is not stored: it is the parents'
+     *     [`confidence`], recovered from the DAG.
      *
-     *     [`Location`]: Modality::Location
-     *     [`Event`]: crate::entity::provenance::Event
-     *     [`provenance`]: Entity::provenance
-     *     [`location`]: Entity::location
-     *     [`confidence`]: Entity::confidence
+     *     [`AuditLog`]: crate::entity::audit::AuditLog
+     *     [`AuditLog::record_fusion`]: crate::entity::audit::AuditLog::record_fusion
+     *     [`AuditLog::verify`]: crate::entity::audit::AuditLog::verify
+     *     [`kind`]: AuditEvent::kind
+     *     [`parents`]: AuditEvent::parents
+     *     [`hash`]: AuditEvent::hash
+     *     [`confidence`]: AuditEvent::confidence
      */
-    TabularEntity: {
-      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
-      confidence: components["schemas"]["Confidence"];
-      /**
-       * @description Coreference identifier, if a recognizer resolved this entity as one
-       *     mention of a cluster. Entities sharing an [`EntityCoRef`] denote the
-       *     same real-world thing.
-       */
-      coref?: components["schemas"]["EntityCoRef"];
-      /**
-       * Format: uuid
-       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
-       *     when the entity is assembled.
-       */
-      id: string;
+    TabularAuditEvent: {
       /**
-       * @description What kind of sensitive information this is (resolved via a
-       *     [`LabelCatalog`]).
+       * @description Confidence after this event: the entity's effective confidence once it
+       *     has happened.
        */
-      label: components["schemas"]["LabelRef"];
-      /**
-       * @description The language of this entity's surrounding text, when a recognizer
-       *     resolved one. `None` when unknown or language-agnostic.
-       */
-      language?: string;
-      /**
-       * @description Location of the entity within the medium (fused, if it came from more
-       *     than one detection).
-       */
-      location: components["schemas"]["TabularLocation"];
-      /**
-       * @description Detection audit trail: every contributing detection and the fusion
-       *     event, if any.
-       */
-      provenance: components["schemas"]["TabularProvenance"];
+      confidence: components["schemas"]["Confidence"];
       /**
-       * @description Byte range of the match in the *recognized text* it was found in (the
-       *     OCR layout text, the audio transcript, or the text payload itself) —
-       *     the stable key back into that enrichment artifact, where the rich
-       *     context lives (which OCR block, which speaker) that the geometric
-       *     [`location`] cannot hold. `None` for entities not found via text
-       *     recognition (e.g. a VLM box). Provenance, not a coordinate: redaction
-       *     uses [`location`]; an audit uses this with the artifact.
+       * @description This event's hash, over its payload and its parents' hashes. Assigned by
+       *     [`AuditLog`] when the event is recorded; read it through
+       *     [`hash`](Self::hash). Recomputing it is how the DAG is verified.
        *
-       *     [`location`]: Entity::location
-       */
-      recognized_range?: components["schemas"]["Range_of_uint"];
-    };
-    /**
-     * @description One recognized entity plus the optional reviewer override.
-     *
-     *     The bound mirrors elide's [`Entity<M>`]: serialization needs
-     *     `M::Location` and `M::Data` (de)serializable, and JsonSchema
-     *     derivation needs them schema-able. All four modalities elide
-     *     ships satisfy these under the `serde` + `schema` features.
-     */
-    TabularEntityRecord: {
-      /** @description The elide entity, as recognition produced it. */
-      entity: components["schemas"]["TabularEntity"];
-      /**
-       * @description Reviewer-supplied redaction override.
+       *     Not publicly settable: only [`AuditLog`] assigns it, so a caller cannot
+       *     forge a self-consistent event outside the recording path.
        *
-       *     `None` means "use the matching policy rule's decision";
-       *     `Some(...)` overrides that rule for this specific entity
-       *     at apply time. Reviewer overrides take precedence over
-       *     every policy rule and inherit the authority of the
-       *     [`Review::policy_id`] they name — the audit event's
-       *     attribution stamps that policy so the trail names the
-       *     authority under which the override fired.
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
        */
-      review?: components["schemas"]["Review"];
-    };
-    /**
-     * @description One thing that happened to an entity, with its effect on confidence.
-     *
-     *     Events are recorded in order on an entity's [`Provenance`], forming
-     *     the full audit trail of its life: each recognizer that found it, the
-     *     deduplication that fused them, any score calibration, and the
-     *     redaction that hid it. The uniform spine (who, before/after score,
-     *     when, why) is the same for every event; the [`kind`] carries the
-     *     event-specific detail.
-     *
-     *     `entity.confidence` always equals the [`after`] of the most recent
-     *     event.
-     *
-     *     [`Provenance`]: crate::entity::provenance::Provenance
-     *     [`kind`]: Event::kind
-     *     [`after`]: Event::after
-     */
-    TabularEvent: {
-      /** @description Confidence after this event. */
-      after: components["schemas"]["Confidence"];
-      /** @description When the event happened (UTC). */
-      at: string;
+      hash: components["schemas"]["AuditHash"];
+      /** @description Kind of event, with its event-specific detail and its rationale. */
+      kind: components["schemas"]["TabularAuditKind"];
       /**
-       * @description Confidence before this event, if there was a prior value. `None` on
-       *     the first (birth) event.
+       * @description The events this one follows, by their hash. Empty for a birth event, one
+       *     entry for a normal step, several for a fusion. Assigned by [`AuditLog`]
+       *     when the event is recorded; read it through [`parents`](Self::parents).
+       *
+       *     Not publicly settable: the links are the tamper-evident structure, so
+       *     only [`AuditLog::record`] / [`AuditLog::record_fusion`] assign them.
+       *
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
+       *     [`AuditLog::record`]: crate::entity::audit::AuditLog::record
+       *     [`AuditLog::record_fusion`]: crate::entity::audit::AuditLog::record_fusion
        */
-      before?: components["schemas"]["Confidence"];
-      /** @description Kind of event, with its event-specific detail. */
-      kind: components["schemas"]["TabularEventKind"];
-      /** @description Free-text explanation of what the event did and why. */
-      reason: string;
+      parents: components["schemas"]["AuditHash"][];
       /**
        * @description Who produced this event: a recognizer name, a deduplication strategy,
        *     an operator, or whatever acted.
        */
       source: string;
+      /** @description When the event happened (UTC). */
+      timestamp: string;
     };
     /**
-     * @description Kind of an [`Event`], carrying its event-specific detail.
+     * @description Kind of an [`AuditEvent`], carrying its event-specific detail and the
+     *     rationale for why it happened.
      *
      *     `#[non_exhaustive]`: new event kinds (verification, annotation, …)
      *     can be added compatibly. The recognition kinds ([`Pattern`],
      *     [`Model`]) carry the matched [`Location`]; the rest carry their own
      *     data.
      *
-     *     [`Pattern`]: EventKind::Pattern
-     *     [`Model`]: EventKind::Model
+     *     [`Pattern`]: AuditKind::Pattern
+     *     [`Model`]: AuditKind::Model
      *     [`Location`]: Modality::Location
      */
-    TabularEventKind: {
+    TabularAuditKind: {
       /** @constant */
       kind: "pattern";
       /** @description Where the recognizer matched. */
@@ -11990,7 +12253,7 @@ interface components {
        *     it is the keyword resolved through the modality's [`locate`] (a
        *     pixel box for image, a time span for audio, the byte range for
        *     text/tabular). `None` when the keyword's stream range could not be
-       *     placed — symmetric with a match the recognizer itself drops.
+       *     placed, symmetric with a match the recognizer itself drops.
        *
        *     [`locate`]: crate::modality::TextRecognizable::locate
        */
@@ -12008,12 +12271,158 @@ interface components {
       /** @description How much the output leaks about the original. */
       leak_profile: components["schemas"]["LeakProfile"];
       /**
-       * @description Which selection rule chose this operator — the automatic "why"
+       * @description Which selection rule chose this operator: the automatic "why"
        *     (matched a label, a tag, a predicate, or the fallback).
        */
       matched_by: components["schemas"]["RuleMatch"];
       /** @description Which operator (name + version) ran. */
       operator: components["schemas"]["OperatorId"];
+      /**
+       * @description BLAKE3 digest of the original text the operator hid, when the
+       *     redaction layer recorded it. Proves *what* was redacted without
+       *     storing the plaintext; `None` when the operator did not capture it.
+       */
+      span_hash?: components["schemas"]["AuditHash"];
+      /**
+       * Format: uint32
+       * @description Byte length of the original text the operator hid, paired with
+       *     [`span_hash`](Self::Redaction::span_hash). `None` when not captured.
+       */
+      span_length?: number;
+    };
+    /**
+     * @description Full audit trail of an [`Entity`]: every [`AuditEvent`] in its life, as a
+     *     tamper-evident DAG.
+     *
+     *     Where Presidio keeps a shallow, optional, per-stage explanation that is
+     *     stripped by default, an `AuditLog` is always present and records the
+     *     entity's *entire* life: each recognizer that found it, the deduplication
+     *     that fused them, any confidence calibration, and the redaction that hid it.
+     *     Nothing is collapsed: every recognizer keeps its own recognition event with
+     *     its location and score.
+     *
+     *     The events form a **directed acyclic graph**, not a flat list. A recognizer
+     *     records a birth event (no parents); each later step links to the event it
+     *     follows; and a [fusion](Self::record_fusion) links to *several* parents at
+     *     once: the heads of the trails it combines. This is the true shape of a
+     *     deduplicated entity: two recognizers are siblings, then a fusion joins them.
+     *     The events are stored in the order they were recorded, which is a
+     *     topological order of the DAG (a parent is always recorded before its
+     *     children).
+     *
+     *     Two chains ride the DAG's edges:
+     *
+     *     - a **confidence chain**, where each event's [`confidence`] is the entity's
+     *       effective score after it; the score flowing *in* is its parents'
+     *       confidence, so [`final_confidence`] and the full history are recoverable;
+     *     - a **hash chain**, where each event's [`hash`] folds its payload together
+     *       with its parents' hashes, so any edit, reorder, insertion, or deletion of
+     *       an earlier event breaks every event downstream. [`verify`] walks the DAG
+     *       and reports the first break.
+     *
+     *     [`Entity`]: crate::entity::Entity
+     *     [`confidence`]: AuditEvent::confidence
+     *     [`hash`]: AuditEvent::hash
+     *     [`final_confidence`]: Self::final_confidence
+     *     [`verify`]: Self::verify
+     */
+    TabularAuditLog: components["schemas"]["TabularAuditEvent"][];
+    /**
+     * @description Detected piece of sensitive information within some medium.
+     *
+     *     Generic over the [`Modality`] `M`, which is what makes the model
+     *     multimodal: a text pipeline yields `Entity<Text>`, an audio pipeline
+     *     `Entity<Audio>`, and so on. The entity's location is the modality's
+     *     [`Location`] type, `M::Location`.
+     *
+     *     # Birth and fusion
+     *
+     *     A recognizer emits an entity directly, carrying a single recognition
+     *     [`AuditEvent`] (its own finding) in the entity's [`audit`] trail. When
+     *     several recognizers find the same thing, a fusion step (in
+     *     `elide`) combines their entities into one: the survivor's
+     *     [`location`] and [`confidence`] are the *fused* values, and every
+     *     contributing recognition event, plus a deduplication event, is
+     *     retained in its audit trail. The entity therefore carries its full
+     *     audit trail with it.
+     *
+     *     [`Location`]: Modality::Location
+     *     [`AuditEvent`]: crate::entity::audit::AuditEvent
+     *     [`audit`]: Entity::audit
+     *     [`location`]: Entity::location
+     *     [`confidence`]: Entity::confidence
+     */
+    TabularEntity: {
+      /**
+       * @description Tamper-evident audit trail: every contributing detection, the fusion
+       *     event if any, and the redaction that hid it, as a hash-linked DAG.
+       */
+      audit: components["schemas"]["TabularAuditLog"];
+      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
+      confidence: components["schemas"]["Confidence"];
+      /**
+       * @description Coreference identifier, if a recognizer resolved this entity as one
+       *     mention of a cluster. Entities sharing an [`EntityCoRef`] denote the
+       *     same real-world thing.
+       */
+      coref?: components["schemas"]["EntityCoRef"];
+      /**
+       * Format: uuid
+       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
+       *     when the entity is assembled.
+       */
+      id: string;
+      /**
+       * @description What kind of sensitive information this is (resolved via a
+       *     [`LabelCatalog`]).
+       */
+      label: components["schemas"]["LabelRef"];
+      /**
+       * @description The language of this entity's surrounding text, when a recognizer
+       *     resolved one. `None` when unknown or language-agnostic.
+       */
+      language?: string;
+      /**
+       * @description Location of the entity within the medium (fused, if it came from more
+       *     than one detection).
+       */
+      location: components["schemas"]["TabularLocation"];
+      /**
+       * @description Byte range of the match in the *recognized text* it was found in (the
+       *     OCR layout text, the audio transcript, or the text payload itself) —
+       *     the stable key back into that enrichment artifact, where the rich
+       *     context lives (which OCR block, which speaker) that the geometric
+       *     [`location`] cannot hold. `None` for entities not found via text
+       *     recognition (e.g. a VLM box). An audit key, not a coordinate: redaction
+       *     uses [`location`]; an audit uses this with the artifact.
+       *
+       *     [`location`]: Entity::location
+       */
+      recognized_range?: components["schemas"]["Range_of_uint"];
+    };
+    /**
+     * @description One recognized entity plus the optional reviewer override.
+     *
+     *     The bound mirrors elide's [`Entity<M>`]: serialization needs
+     *     `M::Location` and `M::Data` (de)serializable, and JsonSchema
+     *     derivation needs them schema-able. All four modalities elide
+     *     ships satisfy these under the `serde` + `schema` features.
+     */
+    TabularEntityRecord: {
+      /** @description The elide entity, as recognition produced it. */
+      entity: components["schemas"]["TabularEntity"];
+      /**
+       * @description Reviewer-supplied redaction override.
+       *
+       *     `None` means "use the matching policy rule's decision";
+       *     `Some(...)` overrides that rule for this specific entity
+       *     at apply time. Reviewer overrides take precedence over
+       *     every policy rule and inherit the authority of the
+       *     [`Review::policy_id`] they name: the audit event's
+       *     attribution stamps that policy so the trail names the
+       *     authority under which the override fired.
+       */
+      review?: components["schemas"]["Review"];
     };
     /**
      * @description Located, typed piece of context a recognizer may treat as in-context
@@ -12085,31 +12494,6 @@ interface components {
        */
       start_offset?: number;
     };
-    /**
-     * @description Full audit trail of an [`Entity`]: every [`Event`] in its life, in
-     *     order.
-     *
-     *     This is the model's answer to "full provenance": where Presidio keeps
-     *     a shallow, optional, per-stage explanation that is stripped by
-     *     default, a `Provenance` is always present and records the entity's
-     *     *entire* life as an ordered list of events: each recognizer that
-     *     found it, the deduplication that fused them, any confidence
-     *     calibration, and the redaction that hid it. Nothing is collapsed:
-     *     every recognizer keeps its own recognition event with its location
-     *     and score.
-     *
-     *     The events form a confidence chain (each event's [`after`] is the
-     *     next's [`before`]) so the final confidence and its full history are
-     *     always recoverable.
-     *
-     *     [`Entity`]: crate::entity::Entity
-     *     [`after`]: Event::after
-     *     [`before`]: Event::before
-     */
-    TabularProvenance: {
-      /** @description Events, in the order they happened. */
-      events: components["schemas"]["TabularEvent"][];
-    };
     /** @description Operator spec a `redact` tabular rule carries. */
     TabularRedaction: {
       /** @constant */
@@ -12127,6 +12511,39 @@ interface components {
       /** @constant */
       kind: "drop_column";
     };
+    /**
+     * @description The template a [`PolicyDefinition`] was built from.
+     *
+     *     Records **provenance, not fidelity**. Templates are plain data
+     *     and callers are expected to mutate the returned policy before
+     *     submitting it (swapping an operator, widening a group), so this
+     *     says "built from `hipaa_deid_safe_harbor` v1.0.0" and nothing
+     *     about whether the policy still matches what that template
+     *     ships. A reviewer who needs that rebuilds the template and
+     *     diffs.
+     *
+     *     `None` on a policy means hand-authored, not "unknown template".
+     *
+     *     Both fields are needed: a policy built from v1 of a template
+     *     can differ materially from one built from v2 (a widened label
+     *     set, a changed operator), and an audit that records only the id
+     *     cannot tell the two apart.
+     *
+     *     [`PolicyDefinition`]: super::PolicyDefinition
+     */
+    TemplateOrigin: {
+      /**
+       * @description The template's machine key: `"hipaa_deid_safe_harbor"`,
+       *     `"pci_dss_pan_hmac_sha256"`. Stable across version bumps.
+       */
+      id: string;
+      /**
+       * @description The template's own semver version, distinct from the
+       *     crate's release version. A shipped template bumps this when
+       *     its labelset or operator dispatch changes.
+       */
+      version: string;
+    };
     /**
      * @description Fallback operator that runs when a declinable primary
      *     ([`TextRedaction::Clamp`], [`TextRedaction::GeneralizeDate`])
@@ -12140,7 +12557,7 @@ interface components {
      *     or `→ Mask` / `→ Keep` on the rare occasion those fit.
      *
      *     Absent from the primary's spec, elide's baked-in default is
-     *     [`Erase`] — a bare [`TextRedaction::Clamp`] without a `fallback`
+     *     [`Erase`]: a bare [`TextRedaction::Clamp`] without a `fallback`
      *     erases values that aren't numeric.
      *
      *     [`Erase`]: TerminalFallback::Erase
@@ -12187,163 +12604,90 @@ interface components {
       payload?: unknown;
     };
     /**
-     * @description Run of text.
-     *
-     *     Either the payload a text recognizer inspects, or the value sliced out
-     *     at an entity's location for an operator.
-     *
-     *     Held as a [`HipStr`] so short values inline and longer ones share a
-     *     refcounted buffer, making cheap clones when one payload is passed to
-     *     several recognizers.
-     */
-    TextData: string;
-    /**
-     * @description Detected piece of sensitive information within some medium.
+     * @description One node in an entity's audit DAG: a thing that happened, with its
+     *     effect on confidence and its tamper-evident links.
      *
-     *     Generic over the [`Modality`] `M`, which is what makes the model
-     *     multimodal: a text pipeline yields `Entity<Text>`, an audio pipeline
-     *     `Entity<Audio>`, and so on. The entity's location is the modality's
-     *     [`Location`] type, `M::Location`.
+     *     Events are recorded on an entity's [`AuditLog`], forming the full audit
+     *     trail of its life: each recognizer that found it, the deduplication that
+     *     fused them, any score calibration, and the redaction that hid it. The
+     *     uniform spine (who, resulting score, when) is the same for every event; the
+     *     [`kind`] carries the event-specific detail *and* the explanation of why the
+     *     event happened.
      *
-     *     # Birth and fusion
+     *     Each event links to its [`parents`] by their [`hash`]: a birth event (a
+     *     recognizer's first detection) has no parents, a normal step has one, and a
+     *     [fusion](crate::entity::audit::AuditLog::record_fusion) has several. Its own
+     *     [`hash`] folds the
+     *     payload together with the parents' hashes, so altering any event breaks
+     *     every event downstream of it: [`AuditLog::verify`] walks the DAG and
+     *     reports the first break.
      *
-     *     A recognizer emits an entity directly, carrying a single recognition
-     *     [`Event`] (its own finding) in the entity's [`provenance`]. When
-     *     several recognizers find the same thing, a fusion step (in
-     *     `elide`) combines their entities into one: the survivor's
-     *     [`location`] and [`confidence`] are the *fused* values, and every
-     *     contributing recognition event, plus a deduplication event, is
-     *     retained in its provenance. The entity therefore carries its full
-     *     audit trail with it.
+     *     `entity.confidence` always equals the [`confidence`] of the most recent
+     *     event. The confidence *flowing in* is not stored: it is the parents'
+     *     [`confidence`], recovered from the DAG.
      *
-     *     [`Location`]: Modality::Location
-     *     [`Event`]: crate::entity::provenance::Event
-     *     [`provenance`]: Entity::provenance
-     *     [`location`]: Entity::location
-     *     [`confidence`]: Entity::confidence
+     *     [`AuditLog`]: crate::entity::audit::AuditLog
+     *     [`AuditLog::record_fusion`]: crate::entity::audit::AuditLog::record_fusion
+     *     [`AuditLog::verify`]: crate::entity::audit::AuditLog::verify
+     *     [`kind`]: AuditEvent::kind
+     *     [`parents`]: AuditEvent::parents
+     *     [`hash`]: AuditEvent::hash
+     *     [`confidence`]: AuditEvent::confidence
      */
-    TextEntity: {
-      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
-      confidence: components["schemas"]["Confidence"];
+    TextAuditEvent: {
       /**
-       * @description Coreference identifier, if a recognizer resolved this entity as one
-       *     mention of a cluster. Entities sharing an [`EntityCoRef`] denote the
-       *     same real-world thing.
+       * @description Confidence after this event: the entity's effective confidence once it
+       *     has happened.
        */
-      coref?: components["schemas"]["EntityCoRef"];
-      /**
-       * Format: uuid
-       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
-       *     when the entity is assembled.
-       */
-      id: string;
-      /**
-       * @description What kind of sensitive information this is (resolved via a
-       *     [`LabelCatalog`]).
-       */
-      label: components["schemas"]["LabelRef"];
-      /**
-       * @description The language of this entity's surrounding text, when a recognizer
-       *     resolved one. `None` when unknown or language-agnostic.
-       */
-      language?: string;
-      /**
-       * @description Location of the entity within the medium (fused, if it came from more
-       *     than one detection).
-       */
-      location: components["schemas"]["TextLocation"];
-      /**
-       * @description Detection audit trail: every contributing detection and the fusion
-       *     event, if any.
-       */
-      provenance: components["schemas"]["TextProvenance"];
+      confidence: components["schemas"]["Confidence"];
       /**
-       * @description Byte range of the match in the *recognized text* it was found in (the
-       *     OCR layout text, the audio transcript, or the text payload itself) —
-       *     the stable key back into that enrichment artifact, where the rich
-       *     context lives (which OCR block, which speaker) that the geometric
-       *     [`location`] cannot hold. `None` for entities not found via text
-       *     recognition (e.g. a VLM box). Provenance, not a coordinate: redaction
-       *     uses [`location`]; an audit uses this with the artifact.
+       * @description This event's hash, over its payload and its parents' hashes. Assigned by
+       *     [`AuditLog`] when the event is recorded; read it through
+       *     [`hash`](Self::hash). Recomputing it is how the DAG is verified.
        *
-       *     [`location`]: Entity::location
-       */
-      recognized_range?: components["schemas"]["Range_of_uint"];
-    };
-    /**
-     * @description One recognized entity plus the optional reviewer override.
-     *
-     *     The bound mirrors elide's [`Entity<M>`]: serialization needs
-     *     `M::Location` and `M::Data` (de)serializable, and JsonSchema
-     *     derivation needs them schema-able. All four modalities elide
-     *     ships satisfy these under the `serde` + `schema` features.
-     */
-    TextEntityRecord: {
-      /** @description The elide entity, as recognition produced it. */
-      entity: components["schemas"]["TextEntity"];
-      /**
-       * @description Reviewer-supplied redaction override.
+       *     Not publicly settable: only [`AuditLog`] assigns it, so a caller cannot
+       *     forge a self-consistent event outside the recording path.
        *
-       *     `None` means "use the matching policy rule's decision";
-       *     `Some(...)` overrides that rule for this specific entity
-       *     at apply time. Reviewer overrides take precedence over
-       *     every policy rule and inherit the authority of the
-       *     [`Review::policy_id`] they name — the audit event's
-       *     attribution stamps that policy so the trail names the
-       *     authority under which the override fired.
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
        */
-      review?: components["schemas"]["Review"];
-    };
-    /**
-     * @description One thing that happened to an entity, with its effect on confidence.
-     *
-     *     Events are recorded in order on an entity's [`Provenance`], forming
-     *     the full audit trail of its life: each recognizer that found it, the
-     *     deduplication that fused them, any score calibration, and the
-     *     redaction that hid it. The uniform spine (who, before/after score,
-     *     when, why) is the same for every event; the [`kind`] carries the
-     *     event-specific detail.
-     *
-     *     `entity.confidence` always equals the [`after`] of the most recent
-     *     event.
-     *
-     *     [`Provenance`]: crate::entity::provenance::Provenance
-     *     [`kind`]: Event::kind
-     *     [`after`]: Event::after
-     */
-    TextEvent: {
-      /** @description Confidence after this event. */
-      after: components["schemas"]["Confidence"];
-      /** @description When the event happened (UTC). */
-      at: string;
+      hash: components["schemas"]["AuditHash"];
+      /** @description Kind of event, with its event-specific detail and its rationale. */
+      kind: components["schemas"]["TextAuditKind"];
       /**
-       * @description Confidence before this event, if there was a prior value. `None` on
-       *     the first (birth) event.
+       * @description The events this one follows, by their hash. Empty for a birth event, one
+       *     entry for a normal step, several for a fusion. Assigned by [`AuditLog`]
+       *     when the event is recorded; read it through [`parents`](Self::parents).
+       *
+       *     Not publicly settable: the links are the tamper-evident structure, so
+       *     only [`AuditLog::record`] / [`AuditLog::record_fusion`] assign them.
+       *
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
+       *     [`AuditLog::record`]: crate::entity::audit::AuditLog::record
+       *     [`AuditLog::record_fusion`]: crate::entity::audit::AuditLog::record_fusion
        */
-      before?: components["schemas"]["Confidence"];
-      /** @description Kind of event, with its event-specific detail. */
-      kind: components["schemas"]["TextEventKind"];
-      /** @description Free-text explanation of what the event did and why. */
-      reason: string;
+      parents: components["schemas"]["AuditHash"][];
       /**
        * @description Who produced this event: a recognizer name, a deduplication strategy,
        *     an operator, or whatever acted.
        */
       source: string;
+      /** @description When the event happened (UTC). */
+      timestamp: string;
     };
     /**
-     * @description Kind of an [`Event`], carrying its event-specific detail.
+     * @description Kind of an [`AuditEvent`], carrying its event-specific detail and the
+     *     rationale for why it happened.
      *
      *     `#[non_exhaustive]`: new event kinds (verification, annotation, …)
      *     can be added compatibly. The recognition kinds ([`Pattern`],
      *     [`Model`]) carry the matched [`Location`]; the rest carry their own
      *     data.
      *
-     *     [`Pattern`]: EventKind::Pattern
-     *     [`Model`]: EventKind::Model
+     *     [`Pattern`]: AuditKind::Pattern
+     *     [`Model`]: AuditKind::Model
      *     [`Location`]: Modality::Location
      */
-    TextEventKind: {
+    TextAuditKind: {
       /** @constant */
       kind: "pattern";
       /** @description Where the recognizer matched. */
@@ -12407,7 +12751,7 @@ interface components {
        *     it is the keyword resolved through the modality's [`locate`] (a
        *     pixel box for image, a time span for audio, the byte range for
        *     text/tabular). `None` when the keyword's stream range could not be
-       *     placed — symmetric with a match the recognizer itself drops.
+       *     placed, symmetric with a match the recognizer itself drops.
        *
        *     [`locate`]: crate::modality::TextRecognizable::locate
        */
@@ -12425,12 +12769,169 @@ interface components {
       /** @description How much the output leaks about the original. */
       leak_profile: components["schemas"]["LeakProfile"];
       /**
-       * @description Which selection rule chose this operator — the automatic "why"
+       * @description Which selection rule chose this operator: the automatic "why"
        *     (matched a label, a tag, a predicate, or the fallback).
        */
       matched_by: components["schemas"]["RuleMatch"];
       /** @description Which operator (name + version) ran. */
       operator: components["schemas"]["OperatorId"];
+      /**
+       * @description BLAKE3 digest of the original text the operator hid, when the
+       *     redaction layer recorded it. Proves *what* was redacted without
+       *     storing the plaintext; `None` when the operator did not capture it.
+       */
+      span_hash?: components["schemas"]["AuditHash"];
+      /**
+       * Format: uint32
+       * @description Byte length of the original text the operator hid, paired with
+       *     [`span_hash`](Self::Redaction::span_hash). `None` when not captured.
+       */
+      span_length?: number;
+    };
+    /**
+     * @description Full audit trail of an [`Entity`]: every [`AuditEvent`] in its life, as a
+     *     tamper-evident DAG.
+     *
+     *     Where Presidio keeps a shallow, optional, per-stage explanation that is
+     *     stripped by default, an `AuditLog` is always present and records the
+     *     entity's *entire* life: each recognizer that found it, the deduplication
+     *     that fused them, any confidence calibration, and the redaction that hid it.
+     *     Nothing is collapsed: every recognizer keeps its own recognition event with
+     *     its location and score.
+     *
+     *     The events form a **directed acyclic graph**, not a flat list. A recognizer
+     *     records a birth event (no parents); each later step links to the event it
+     *     follows; and a [fusion](Self::record_fusion) links to *several* parents at
+     *     once: the heads of the trails it combines. This is the true shape of a
+     *     deduplicated entity: two recognizers are siblings, then a fusion joins them.
+     *     The events are stored in the order they were recorded, which is a
+     *     topological order of the DAG (a parent is always recorded before its
+     *     children).
+     *
+     *     Two chains ride the DAG's edges:
+     *
+     *     - a **confidence chain**, where each event's [`confidence`] is the entity's
+     *       effective score after it; the score flowing *in* is its parents'
+     *       confidence, so [`final_confidence`] and the full history are recoverable;
+     *     - a **hash chain**, where each event's [`hash`] folds its payload together
+     *       with its parents' hashes, so any edit, reorder, insertion, or deletion of
+     *       an earlier event breaks every event downstream. [`verify`] walks the DAG
+     *       and reports the first break.
+     *
+     *     [`Entity`]: crate::entity::Entity
+     *     [`confidence`]: AuditEvent::confidence
+     *     [`hash`]: AuditEvent::hash
+     *     [`final_confidence`]: Self::final_confidence
+     *     [`verify`]: Self::verify
+     */
+    TextAuditLog: components["schemas"]["TextAuditEvent"][];
+    /**
+     * @description Run of text.
+     *
+     *     Either the payload a text recognizer inspects, or the value sliced out
+     *     at an entity's location for an operator.
+     *
+     *     Held as a [`HipStr`] so short values inline and longer ones share a
+     *     refcounted buffer, making cheap clones when one payload is passed to
+     *     several recognizers.
+     */
+    TextData: string;
+    /**
+     * @description Detected piece of sensitive information within some medium.
+     *
+     *     Generic over the [`Modality`] `M`, which is what makes the model
+     *     multimodal: a text pipeline yields `Entity<Text>`, an audio pipeline
+     *     `Entity<Audio>`, and so on. The entity's location is the modality's
+     *     [`Location`] type, `M::Location`.
+     *
+     *     # Birth and fusion
+     *
+     *     A recognizer emits an entity directly, carrying a single recognition
+     *     [`AuditEvent`] (its own finding) in the entity's [`audit`] trail. When
+     *     several recognizers find the same thing, a fusion step (in
+     *     `elide`) combines their entities into one: the survivor's
+     *     [`location`] and [`confidence`] are the *fused* values, and every
+     *     contributing recognition event, plus a deduplication event, is
+     *     retained in its audit trail. The entity therefore carries its full
+     *     audit trail with it.
+     *
+     *     [`Location`]: Modality::Location
+     *     [`AuditEvent`]: crate::entity::audit::AuditEvent
+     *     [`audit`]: Entity::audit
+     *     [`location`]: Entity::location
+     *     [`confidence`]: Entity::confidence
+     */
+    TextEntity: {
+      /**
+       * @description Tamper-evident audit trail: every contributing detection, the fusion
+       *     event if any, and the redaction that hid it, as a hash-linked DAG.
+       */
+      audit: components["schemas"]["TextAuditLog"];
+      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
+      confidence: components["schemas"]["Confidence"];
+      /**
+       * @description Coreference identifier, if a recognizer resolved this entity as one
+       *     mention of a cluster. Entities sharing an [`EntityCoRef`] denote the
+       *     same real-world thing.
+       */
+      coref?: components["schemas"]["EntityCoRef"];
+      /**
+       * Format: uuid
+       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
+       *     when the entity is assembled.
+       */
+      id: string;
+      /**
+       * @description What kind of sensitive information this is (resolved via a
+       *     [`LabelCatalog`]).
+       */
+      label: components["schemas"]["LabelRef"];
+      /**
+       * @description The language of this entity's surrounding text, when a recognizer
+       *     resolved one. `None` when unknown or language-agnostic.
+       */
+      language?: string;
+      /**
+       * @description Location of the entity within the medium (fused, if it came from more
+       *     than one detection).
+       */
+      location: components["schemas"]["TextLocation"];
+      /**
+       * @description Byte range of the match in the *recognized text* it was found in (the
+       *     OCR layout text, the audio transcript, or the text payload itself) —
+       *     the stable key back into that enrichment artifact, where the rich
+       *     context lives (which OCR block, which speaker) that the geometric
+       *     [`location`] cannot hold. `None` for entities not found via text
+       *     recognition (e.g. a VLM box). An audit key, not a coordinate: redaction
+       *     uses [`location`]; an audit uses this with the artifact.
+       *
+       *     [`location`]: Entity::location
+       */
+      recognized_range?: components["schemas"]["Range_of_uint"];
+    };
+    /**
+     * @description One recognized entity plus the optional reviewer override.
+     *
+     *     The bound mirrors elide's [`Entity<M>`]: serialization needs
+     *     `M::Location` and `M::Data` (de)serializable, and JsonSchema
+     *     derivation needs them schema-able. All four modalities elide
+     *     ships satisfy these under the `serde` + `schema` features.
+     */
+    TextEntityRecord: {
+      /** @description The elide entity, as recognition produced it. */
+      entity: components["schemas"]["TextEntity"];
+      /**
+       * @description Reviewer-supplied redaction override.
+       *
+       *     `None` means "use the matching policy rule's decision";
+       *     `Some(...)` overrides that rule for this specific entity
+       *     at apply time. Reviewer overrides take precedence over
+       *     every policy rule and inherit the authority of the
+       *     [`Review::policy_id`] they name: the audit event's
+       *     attribution stamps that policy so the trail names the
+       *     authority under which the override fired.
+       */
+      review?: components["schemas"]["Review"];
     };
     /**
      * @description Located, typed piece of context a recognizer may treat as in-context
@@ -12479,31 +12980,6 @@ interface components {
        */
       start: number;
     };
-    /**
-     * @description Full audit trail of an [`Entity`]: every [`Event`] in its life, in
-     *     order.
-     *
-     *     This is the model's answer to "full provenance": where Presidio keeps
-     *     a shallow, optional, per-stage explanation that is stripped by
-     *     default, a `Provenance` is always present and records the entity's
-     *     *entire* life as an ordered list of events: each recognizer that
-     *     found it, the deduplication that fused them, any confidence
-     *     calibration, and the redaction that hid it. Nothing is collapsed:
-     *     every recognizer keeps its own recognition event with its location
-     *     and score.
-     *
-     *     The events form a confidence chain (each event's [`after`] is the
-     *     next's [`before`]) so the final confidence and its full history are
-     *     always recoverable.
-     *
-     *     [`Entity`]: crate::entity::Entity
-     *     [`after`]: Event::after
-     *     [`before`]: Event::before
-     */
-    TextProvenance: {
-      /** @description Events, in the order they happened. */
-      events: components["schemas"]["TextEvent"][];
-    };
     /** @description Operator spec a `redact` text rule carries. */
     TextRedaction: {
       /** @constant */
@@ -12804,11 +13280,13 @@ interface components {
     /**
      * @description Request payload for updating an existing workspace policy.
      *
-     *     Replacing the `definition` replaces the whole policy body.
+     *     Replacing the `definition` replaces the whole policy body. The policy's
+     *     template origin is server-owned and preserved across updates — it is not
+     *     settable here.
      */
     UpdatePolicy: {
       /** @description New policy body (replaces the stored definition). */
-      definition?: components["schemas"]["PolicyDefinition"];
+      definition?: components["schemas"]["PolicyDraft"];
       /** @description Policy description. */
       description?: string;
       /** @description Human-readable policy display name. */
@@ -13220,15 +13698,18 @@ type Schemas$16 = components["schemas"];
 type EntityGroup = Schemas$16["EntityGroup"];
 type AuditContext = Schemas$16["AuditContext"];
 type EntityCoRef = Schemas$16["EntityCoRef"];
-type OcrMode = Schemas$16["OcrMode"];
+type RasterMode = Schemas$16["RasterMode"];
 type Dpi = Schemas$16["Dpi"];
 type Review = Schemas$16["Review"];
 type Attribution = Schemas$16["Attribution"];
+type AttributionKind = Schemas$16["AttributionKind"];
 type LeakProfile = Schemas$16["LeakProfile"];
 type RuleMatch = Schemas$16["RuleMatch"];
 type ModelEvent = Schemas$16["ModelEvent"];
 type PatternEvent = Schemas$16["PatternEvent"];
 type OperatorId = Schemas$16["OperatorId"];
+type AuditHash = Schemas$16["AuditHash"];
+type Category = Schemas$16["Category"];
 /** Half-open `[start, end)` index range. Generated name; a plain uint range. */
 type RangeOfUint = Schemas$16["Range_of_uint"];
 type BoundingBox = Schemas$16["BoundingBox"];
@@ -13238,35 +13719,35 @@ type Dimensions = Schemas$16["Dimensions"];
 type TimeSpan = Schemas$16["TimeSpan"];
 type TextEntity = Schemas$16["TextEntity"];
 type TextEntityRecord = Schemas$16["TextEntityRecord"];
-type TextEvent = Schemas$16["TextEvent"];
-type TextEventKind = Schemas$16["TextEventKind"];
+type TextAuditEvent = Schemas$16["TextAuditEvent"];
+type TextAuditKind = Schemas$16["TextAuditKind"];
 type TextHint = Schemas$16["TextHint"];
 type TextLocation = Schemas$16["TextLocation"];
-type TextProvenance = Schemas$16["TextProvenance"];
+type TextAuditLog = Schemas$16["TextAuditLog"];
 type TextData = Schemas$16["TextData"];
 type ImageEntity = Schemas$16["ImageEntity"];
 type ImageEntityRecord = Schemas$16["ImageEntityRecord"];
-type ImageEvent = Schemas$16["ImageEvent"];
-type ImageEventKind = Schemas$16["ImageEventKind"];
+type ImageAuditEvent = Schemas$16["ImageAuditEvent"];
+type ImageAuditKind = Schemas$16["ImageAuditKind"];
 type ImageHint = Schemas$16["ImageHint"];
 type ImageLocation = Schemas$16["ImageLocation"];
-type ImageProvenance = Schemas$16["ImageProvenance"];
+type ImageAuditLog = Schemas$16["ImageAuditLog"];
 type ImageData = Schemas$16["ImageData"];
 type AudioEntity = Schemas$16["AudioEntity"];
 type AudioEntityRecord = Schemas$16["AudioEntityRecord"];
-type AudioEvent = Schemas$16["AudioEvent"];
-type AudioEventKind = Schemas$16["AudioEventKind"];
+type AudioAuditEvent = Schemas$16["AudioAuditEvent"];
+type AudioAuditKind = Schemas$16["AudioAuditKind"];
 type AudioHint = Schemas$16["AudioHint"];
 type AudioLocation = Schemas$16["AudioLocation"];
-type AudioProvenance = Schemas$16["AudioProvenance"];
+type AudioAuditLog = Schemas$16["AudioAuditLog"];
 type AudioData = Schemas$16["AudioData"];
 type TabularEntity = Schemas$16["TabularEntity"];
 type TabularEntityRecord = Schemas$16["TabularEntityRecord"];
-type TabularEvent = Schemas$16["TabularEvent"];
-type TabularEventKind = Schemas$16["TabularEventKind"];
+type TabularAuditEvent = Schemas$16["TabularAuditEvent"];
+type TabularAuditKind = Schemas$16["TabularAuditKind"];
 type TabularHint = Schemas$16["TabularHint"];
 type TabularLocation = Schemas$16["TabularLocation"];
-type TabularProvenance = Schemas$16["TabularProvenance"];
+type TabularAuditLog = Schemas$16["TabularAuditLog"];
 //#endregion
 //#region src/datatypes/auth.d.ts
 type Schemas$15 = components["schemas"];
@@ -13396,12 +13877,16 @@ type Policy = Schemas$4["Policy"];
 type PolicySummary = Schemas$4["PolicySummary"];
 type PolicySummaryPage = Schemas$4["PolicySummaryPage"];
 type PolicyDefinition = Schemas$4["PolicyDefinition"];
+type PolicyDraft = Schemas$4["PolicyDraft"];
 type CreatePolicy = Schemas$4["CreatePolicy"];
 type UpdatePolicy = Schemas$4["UpdatePolicy"];
 type PolicyRule = Schemas$4["PolicyRule"];
 type PolicyTemplate = Schemas$4["PolicyTemplate"];
+type TemplateOrigin = Schemas$4["TemplateOrigin"];
 type HipaaDeidMethod = Schemas$4["HipaaDeidMethod"];
+type HipaaAccountNumbers = Schemas$4["HipaaAccountNumbers"];
 type GdprArticle9Treatment = Schemas$4["GdprArticle9Treatment"];
+type GdprSensitiveScope = Schemas$4["GdprSensitiveScope"];
 type PciDssPart = Schemas$4["PciDssPart"];
 type PciPanRender = Schemas$4["PciPanRender"];
 type Predicate = Schemas$4["Predicate"];
@@ -13473,5 +13958,5 @@ type Retention = Schemas["Retention"];
 type RetentionSettings = Schemas["RetentionSettings"];
 type RetentionOverride = Schemas["RetentionOverride"];
 //#endregion
-export { ModalityRedactions as $, AudioEventKind as $n, ConnectionActivityParams as $r, InvitePage as $t, PipelineRun as A, LlmConfig as An, TabularEventKind as Ar, Notification as At, CreatePolicy as B, SyncTriggerType as Bn, TextLocation as Br, UnreadCountEvent as Bt, LanguageProvenance as C, ConnectionPage as Cn, Polygon as Cr, UpdatePipeline as Ct, ScopeParams as D, ConnectionsQuery as Dn, TabularEntity as Dr, MarkedReadStatus as Dt, ScopeMetadata as E, ConnectionVerification as En, RuleMatch as Er, ConnectionSyncFailedParams as Et, RunStatusEvent as F, SyncDeletionPolicy as Fn, TextEntity as Fr, PipelineRunAnalyzedParams as Ft, ImageRedaction as G, AuthToken as Gn, ApiTokenType as Gr, MemberPage as Gt, DateStyle as H, LabelCatalog as Hn, TimeSpan as Hr, UpdateNotificationSettings as Ht, AudioRedaction as I, SyncMode as In, TextEntityRecord as Ir, PipelineRunCompletedParams as It, LabelGroup as J, Attribution as Jn, TokenExpiration as Jr, CreateInvite as Jt, Label as K, Login as Kn, ApiTokenWithJWT as Kr, MemberSortField as Kt, ClampBucket as L, SyncSchedule as Ln, TextEvent as Lr, PipelineRunFailedParams as Lt, PipelineRunStatus as M, S3Credentials as Mn, TabularLocation as Mr, NotificationPage as Mt, PipelineRunsQuery as N, StorageConfig as Nn, TabularProvenance as Nr, NotificationPayload as Nt, Audit as O, CreateConnection as On, TabularEntityRecord as Or, MemberInvitedParams as Ot, RunMetadata as P, SyncConnection as Pn, TextData as Pr, NotificationSettings as Pt, LocalizedText as Q, AudioEvent as Qn, ActivityPayload as Qr, InviteExpiration as Qt, Color as R, SyncScheduleInput as Rn, TextEventKind as Rr, SystemAnnouncementParams as Rt, Language as S, ConnectionConfig as Sn, Point as Sr, PipelineTriggerType as St, Languages as T, ConnectionSyncPage as Tn, Review as Tr, ConnectionSyncCompletedParams as Tt, GdprArticle9Treatment as U, RecognizerCatalog as Un, ApiToken as Ur, ListMembers as Ut, DateGranularity as V, UpdateConnection as Vn, TextProvenance as Vr, UnreadStatus as Vt, HipaaDeidMethod as W, RegisteredRecognizer as Wn, ApiTokenPage as Wr, Member as Wt, Labels as X, AudioEntity as Xn, Activity as Xr, Invite as Xt, LabelLocale as Y, AudioData as Yn, UpdateApiToken as Yr, GenerateInviteCode as Yt, LanguageTag as Z, AudioEntityRecord as Zn, ActivityPage as Zr, InviteCode as Zt, WebhookPage as _, ErrorResponse as _n, LeakProfile as _r, PipelineDefinition as _t, RetentionSettings as a, PolicyActivityParams as ai, ReplyInvite as an, Dimensions as ar, PolicySummary as at, Confidence as b, AzureCredentials as bn, OperatorId as br, PipelineSummary as bt, WorkspacePage as c, Account as ci, Health as cn, EntityGroup as cr, Predicate as ct, CreateWebhook as d, UpdateAccount as di, FileKind as dn, ImageEntityRecord as dr, TerminalFallback as dt, FileActivityParams as ei, InvitePreview as en, AudioHint as er, PciDssPart as et, TestWebhook as f, paths as fi, FilePage as fn, ImageEvent as fr, TextRedaction as ft, WebhookEvent as g, UpdateFile as gn, ImageProvenance as gr, Pipeline as gt, WebhookCreated as h, ModalityToken as hn, ImageLocation as hr, CreatePipeline as ht, RetentionOverride as i, PipelineRunActivityParams as ii, ListInvites as in, BoundingBox as ir, PolicyRule as it, PipelineRunPage as j, OpenAiCredentials as jn, TabularHint as jr, NotificationEvent as jt, CreatePipelineRun as k, GcsCredentials as kn, TabularEvent as kr, MemberJoinedParams as kt, WorkspaceRole as l, AccountRef as li, HealthStatus as ln, ImageData as lr, Sha2Algorithm as lt, Webhook as m, ListFiles as mn, ImageHint as mr, Waveform as mt, OcrPolicy as n, MemberActivityParams as ni, InviteSortField as nn, AudioProvenance as nr, Policy as nt, UpdateWorkspace as o, WebhookActivityParams as oi, SortOrder as on, Dpi as or, PolicySummaryPage as ot, UpdateWebhook as p, FormatToken as pn, ImageEventKind as pr, UpdatePolicy as pt, LabelEntry as q, Signup as qn, CreateApiToken as qr, UpdateMember as qt, Retention as r, PipelineActivityParams as ri, InviteStatus as rn, AuditContext as rr, PolicyDefinition as rt, Workspace as s, WorkspaceActivityParams as si, ComponentHealth as sn, EntityCoRef as sr, PolicyTemplate as st, CreateWorkspace as t, InviteActivityParams as ti, InviteSent as tn, AudioLocation as tr, PciPanRender as tt, WorkspaceSettings as u, PublicAccount as ui, File as un, ImageEntity as ur, TabularRedaction as ut, WebhookResult as v, ValidationErrorDetail as vn, ModelEvent as vr, PipelineFilter as vt, LanguageSpan as w, ConnectionSync as wn, RangeOfUint as wr, CursorPagination as wt, CountryCode as x, Connection as xn, PatternEvent as xr, PipelineSummaryPage as xt, WebhookStatus as y, AnthropicCredentials as yn, OcrMode as yr, PipelineStatus as yt, ConfidenceThreshold as z, SyncStatus as zn, TextHint as zr, SystemReportParams as zt };
-//# sourceMappingURL=index-Cijg5CMy.d.ts.map
+export { LanguageTag as $, AttributionKind as $n, ApiTokenWithJWT as $r, GenerateInviteCode as $t, PipelineRun as A, ConnectionVerification as An, RangeOfUint as Ar, ConnectionSyncFailedParams as At, CreatePolicy as B, SyncMode as Bn, TabularLocation as Br, PipelineRunCompletedParams as Bt, LanguageProvenance as C, AnthropicCredentials as Cn, ImageLocation as Cr, PipelineStatus as Ct, ScopeParams as D, ConnectionPage as Dn, PatternEvent as Dr, UpdatePipeline as Dt, ScopeMetadata as E, ConnectionConfig as En, OperatorId as Er, PipelineTriggerType as Et, RunStatusEvent as F, OpenAiCredentials as Fn, TabularAuditKind as Fr, NotificationEvent as Ft, HipaaAccountNumbers as G, UpdateConnection as Gn, TextEntity as Gr, UnreadStatus as Gt, DateStyle as H, SyncScheduleInput as Hn, TextAuditKind as Hr, SystemAnnouncementParams as Ht, AudioRedaction as I, S3Credentials as In, TabularAuditLog as Ir, NotificationPage as It, Label as J, RegisteredRecognizer as Jn, TextLocation as Jr, Member as Jt, HipaaDeidMethod as K, LabelCatalog as Kn, TextEntityRecord as Kr, UpdateNotificationSettings as Kt, ClampBucket as L, StorageConfig as Ln, TabularEntity as Lr, NotificationPayload as Lt, PipelineRunStatus as M, CreateConnection as Mn, Review as Mr, MemberInvitedParams as Mt, PipelineRunsQuery as N, GcsCredentials as Nn, RuleMatch as Nr, MemberJoinedParams as Nt, Audit as O, ConnectionSync as On, Point as Or, CursorPagination as Ot, RunMetadata as P, LlmConfig as Pn, TabularAuditEvent as Pr, Notification as Pt, Labels as Q, Attribution as Qn, ApiTokenType as Qr, CreateInvite as Qt, Color as R, SyncConnection as Rn, TabularEntityRecord as Rr, NotificationSettings as Rt, Language as S, ValidationErrorDetail as Sn, ImageHint as Sr, PipelineFilter as St, Languages as T, Connection as Tn, ModelEvent as Tr, PipelineSummaryPage as Tt, GdprArticle9Treatment as U, SyncStatus as Un, TextAuditLog as Ur, SystemReportParams as Ut, DateGranularity as V, SyncSchedule as Vn, TextAuditEvent as Vr, PipelineRunFailedParams as Vt, GdprSensitiveScope as W, SyncTriggerType as Wn, TextData as Wr, UnreadCountEvent as Wt, LabelGroup as X, Login as Xn, ApiToken as Xr, MemberSortField as Xt, LabelEntry as Y, AuthToken as Yn, TimeSpan as Yr, MemberPage as Yt, LabelLocale as Z, Signup as Zn, ApiTokenPage as Zr, UpdateMember as Zt, WebhookPage as _, PublicAccount as _i, FormatToken as _n, ImageAuditKind as _r, UpdatePolicy as _t, RetentionSettings as a, ActivityPayload as ai, InviteSent as an, AudioEntityRecord as ar, PolicyDefinition as at, Confidence as b, UpdateFile as bn, ImageEntity as br, Pipeline as bt, WorkspacePage as c, InviteActivityParams as ci, ListInvites as cn, AuditContext as cr, PolicySummary as ct, CreateWebhook as d, PipelineRunActivityParams as di, ComponentHealth as dn, Category as dr, Predicate as dt, CreateApiToken as ei, Invite as en, AudioAuditEvent as er, LocalizedText as et, TestWebhook as f, PolicyActivityParams as fi, Health as fn, Dimensions as fr, Sha2Algorithm as ft, WebhookEvent as g, AccountRef as gi, FilePage as gn, ImageAuditEvent as gr, TextRedaction as gt, WebhookCreated as h, Account as hi, FileKind as hn, EntityGroup as hr, TerminalFallback as ht, RetentionOverride as i, ActivityPage as ii, InvitePreview as in, AudioEntity as ir, Policy as it, PipelineRunPage as j, ConnectionsQuery as jn, RasterMode as jr, MarkedReadStatus as jt, CreatePipelineRun as k, ConnectionSyncPage as kn, Polygon as kr, ConnectionSyncCompletedParams as kt, WorkspaceRole as l, MemberActivityParams as li, ReplyInvite as ln, AuditHash as lr, PolicySummaryPage as lt, Webhook as m, WorkspaceActivityParams as mi, File as mn, EntityCoRef as mr, TemplateOrigin as mt, OcrPolicy as n, UpdateApiToken as ni, InviteExpiration as nn, AudioAuditLog as nr, PciDssPart as nt, UpdateWorkspace as o, ConnectionActivityParams as oi, InviteSortField as on, AudioHint as or, PolicyDraft as ot, UpdateWebhook as p, WebhookActivityParams as pi, HealthStatus as pn, Dpi as pr, TabularRedaction as pt, ImageRedaction as q, RecognizerCatalog as qn, TextHint as qr, ListMembers as qt, Retention as r, Activity as ri, InvitePage as rn, AudioData as rr, PciPanRender as rt, Workspace as s, FileActivityParams as si, InviteStatus as sn, AudioLocation as sr, PolicyRule as st, CreateWorkspace as t, TokenExpiration as ti, InviteCode as tn, AudioAuditKind as tr, ModalityRedactions as tt, WorkspaceSettings as u, PipelineActivityParams as ui, SortOrder as un, BoundingBox as ur, PolicyTemplate as ut, WebhookResult as v, UpdateAccount as vi, ListFiles as vn, ImageAuditLog as vr, Waveform as vt, LanguageSpan as w, AzureCredentials as wn, LeakProfile as wr, PipelineSummary as wt, CountryCode as x, ErrorResponse as xn, ImageEntityRecord as xr, PipelineDefinition as xt, WebhookStatus as y, paths as yi, ModalityToken as yn, ImageData as yr, CreatePipeline as yt, ConfidenceThreshold as z, SyncDeletionPolicy as zn, TabularHint as zr, PipelineRunAnalyzedParams as zt };
+//# sourceMappingURL=index-D7O7ZJNs.d.ts.map