# Protected sources, learner records, biometrics, and unreleased assets

Why two of the four categories this item names could not be STATED on the field
type that decides whether a value leaves the product, and what a class that
cannot be stated permits by default; why redaction is an allowlist whose default
for an unknown field is to withhold it; why disclosure is a four-rung ladder
rather than a boolean, and which institutional rule a boolean cannot express;
why presence-disclosure belongs to the FIELD rather than to the category; why
the audience ladder measures breadth and not entitlement, and which pair proves
the substitute map is not sorted by it; why a pseudonym is assigned rather than
derived and why one codename across two stories is a leak that is in neither
document; what a role summary needs before it is a redaction at all; why an
artefact computed from a biometric IS the biometric and which artefacts a
withdrawal reliably fails to reach; which three purposes may never be inferred
from another consent; why an embargo with no lift instant is not an embargo; why
the projection happens once upstream of all eight boundaries and what each
boundary has to say about which one it consumed; the ten ways a notice discloses
while carrying no field at all, including why a small count is suppressed rather
than rounded; and the six encodings a planted value has to be followed through
before a clean sweep means anything.

Generated from `libs/oshun/workbench-kit/src/redaction.ts` by
`node scripts/v1-workbenches/generate-workbench-kit-api-reference.mjs`. Ledger:
S8.12. Do not edit by hand.

## Summary

- `src/redaction.ts`

| Entry point                      | Runtime class | Authorized by |
| -------------------------------- | ------------- | ------------- |
| `@oshun/workbench-kit/redaction` | `contract`    | S8.12         |

## Exports

| Symbol                                                                      | Kind        | Summary                                                                                                                                                                                                   |
| --------------------------------------------------------------------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [AggregateRelease](#aggregaterelease)                                       | interface   | —                                                                                                                                                                                                         |
| [audienceCeilingFor](#audienceceilingfor)                                   | function    | The widest audience an event in this category may reach.                                                                                                                                                  |
| [BIOMETRIC_DERIVED_KINDS](#biometric_derived_kinds)                         | enumeration | The artefacts computed FROM a modality, which are the modality (decision 7).                                                                                                                              |
| [BIOMETRIC_FAULTS](#biometric_faults)                                       | enumeration | —                                                                                                                                                                                                         |
| [BIOMETRIC_FIELD_KINDS](#biometric_field_kinds)                             | enumeration | S8.12.c — the modalities and the artefacts computed from them.                                                                                                                                            |
| [BIOMETRIC_PURPOSES](#biometric_purposes)                                   | enumeration | —                                                                                                                                                                                                         |
| [BIOMETRIC_SOURCE_MODALITIES](#biometric_source_modalities)                 | enumeration | The modalities a biometric is captured IN.                                                                                                                                                                |
| [BiometricConsent](#biometricconsent)                                       | interface   | —                                                                                                                                                                                                         |
| [BiometricFault](#biometricfault)                                           | type        | —                                                                                                                                                                                                         |
| [BiometricFieldKind](#biometricfieldkind)                                   | type        | —                                                                                                                                                                                                         |
| [BiometricPurpose](#biometricpurpose)                                       | type        | —                                                                                                                                                                                                         |
| [biometricReadFaults](#biometricreadfaults)                                 | function    | Whether a biometric read is permitted, and why not (S8.12.c).                                                                                                                                             |
| [BiometricReadRequest](#biometricreadrequest)                               | interface   | —                                                                                                                                                                                                         |
| [BOUNDARY_FAULTS](#boundary_faults)                                         | enumeration | —                                                                                                                                                                                                         |
| [boundaryCoverageFaults](#boundarycoveragefaults)                           | function    | Whether the eight boundaries consumed the projection rather than the record (S8.12.e).                                                                                                                    |
| [BoundaryFault](#boundaryfault)                                             | type        | —                                                                                                                                                                                                         |
| [BoundaryObservation](#boundaryobservation)                                 | interface   | —                                                                                                                                                                                                         |
| [canaryEncodings](#canaryencodings)                                         | function    | Every form a channel might have written the canary in (decision 12).                                                                                                                                      |
| [CanaryPlant](#canaryplant)                                                 | interface   | —                                                                                                                                                                                                         |
| [canaryPlantFaults](#canaryplantfaults)                                     | function    | The plants themselves, before anything is scanned (S8.12.g).                                                                                                                                              |
| [CLASSIFICATION_FOR_CATEGORY](#classification_for_category)                 | constant    | The activity classification each category projects as.                                                                                                                                                    |
| [DISCLOSURE_LEVELS](#disclosure_levels)                                     | enumeration | How much of a field is being disclosed, as a ladder.                                                                                                                                                      |
| [DisclosureLevel](#disclosurelevel)                                         | type        | —                                                                                                                                                                                                         |
| [disclosurePermits](#disclosurepermits)                                     | function    | True when `granted` reaches at least as far as `required`.                                                                                                                                                |
| [disclosureRank](#disclosurerank)                                           | function    | —                                                                                                                                                                                                         |
| [DisclosureRequest](#disclosurerequest)                                     | interface   | —                                                                                                                                                                                                         |
| [DISTINGUISHING_ERROR_CLASSIFIERS](#distinguishing_error_classifiers)       | enumeration | The classifiers that answer "which of the two is it" (S8.12.f).                                                                                                                                           |
| [EDUCATIONAL_ROLES](#educational_roles)                                     | enumeration | Who reads a learner's record.                                                                                                                                                                             |
| [EducationalRole](#educationalrole)                                         | type        | —                                                                                                                                                                                                         |
| [Embargo](#embargo)                                                         | interface   | —                                                                                                                                                                                                         |
| [EMBARGO_STANDINGS](#embargo_standings)                                     | enumeration | —                                                                                                                                                                                                         |
| [embargoStanding](#embargostanding)                                         | function    | Where an embargo stands against a server clock (S8.12.d).                                                                                                                                                 |
| [EmbargoStanding](#embargostanding)                                         | type        | —                                                                                                                                                                                                         |
| [ENCODING_FORMS](#encoding_forms)                                           | enumeration | —                                                                                                                                                                                                         |
| [EncodingForm](#encodingform)                                               | type        | —                                                                                                                                                                                                         |
| [exposureCeilingFor](#exposureceilingfor)                                   | function    | The most exposing transport a value in this category may travel on.                                                                                                                                       |
| [FIELD_KINDS_BY_CATEGORY](#field_kinds_by_category)                         | constant    | Which kinds belong to which category.                                                                                                                                                                     |
| [fieldKindBelongs](#fieldkindbelongs)                                       | function    | Whether a kind is one this category actually has.                                                                                                                                                         |
| [fieldReleaseFaults](#fieldreleasefaults)                                   | function    | Whether one registered field may be released to this request, with reasons (S8.12.a-d applied through one seam).                                                                                          |
| [GRANT_GATED_ROLES](#grant_gated_roles)                                     | enumeration | The roles that read a learner's record only through a live support grant.                                                                                                                                 |
| [INDISTINGUISHABLE_ERROR_CLASSIFIER](#indistinguishable_error_classifier)   | constant    | The one classifier a presence-disclosing refusal may carry.                                                                                                                                               |
| [LEAKAGE_FAULTS](#leakage_faults)                                           | enumeration | —                                                                                                                                                                                                         |
| [LEAKAGE_SURFACES](#leakage_surfaces)                                       | enumeration | The eight surfaces a planted value is followed to.                                                                                                                                                        |
| [LeakageFault](#leakagefault)                                               | type        | —                                                                                                                                                                                                         |
| [leakageFaults](#leakagefaults)                                             | function    | Follow every plant onto every capture (S8.12.g).                                                                                                                                                          |
| [LeakageSurface](#leakagesurface)                                           | type        | —                                                                                                                                                                                                         |
| [LEARNER_ACCESS](#learner_access)                                           | constant    | The educational-role access matrix (S8.12.b).                                                                                                                                                             |
| [LEARNER_FAULTS](#learner_faults)                                           | enumeration | —                                                                                                                                                                                                         |
| [LEARNER_FIELD_KINDS](#learner_field_kinds)                                 | enumeration | S8.12.b — what a learner's record holds.                                                                                                                                                                  |
| [LearnerFault](#learnerfault)                                               | type        | —                                                                                                                                                                                                         |
| [LearnerFieldKind](#learnerfieldkind)                                       | type        | —                                                                                                                                                                                                         |
| [learnerReadFaults](#learnerreadfaults)                                     | function    | Whether one educational-role read is permitted, and why not (S8.12.b).                                                                                                                                    |
| [LearnerReadRequest](#learnerreadrequest)                                   | interface   | —                                                                                                                                                                                                         |
| [MINIMUM_CANARY_LENGTH](#minimum_canary_length)                             | constant    | Under this length a canary can occur in ordinary text, and a hit means nothing.                                                                                                                           |
| [NoticeObservation](#noticeobservation)                                     | interface   | —                                                                                                                                                                                                         |
| [PRESENCE_DISCLOSING_FIELDS](#presence_disclosing_fields)                   | constant    | The (category, kind) pairs where the EXISTENCE of the field is already the disclosure (decision 3).                                                                                                       |
| [presenceDiscloses](#presencediscloses)                                     | function    | —                                                                                                                                                                                                         |
| [projectAllowed](#projectallowed)                                           | function    | The allowlist projection (S8.12.e, decision 1).                                                                                                                                                           |
| [PROJECTION_FAULTS](#projection_faults)                                     | enumeration | The kinds the projection raises that no category policy owns.                                                                                                                                             |
| [ProjectionFault](#projectionfault)                                         | type        | —                                                                                                                                                                                                         |
| [PROTECTED_CATEGORIES](#protected_categories)                               | enumeration | The four categories the parent phase names.                                                                                                                                                               |
| [ProtectedCategory](#protectedcategory)                                     | type        | —                                                                                                                                                                                                         |
| [ProtectedFieldKind](#protectedfieldkind)                                   | type        | —                                                                                                                                                                                                         |
| [ProtectedFieldRef](#protectedfieldref)                                     | interface   | —                                                                                                                                                                                                         |
| [PURPOSES_REQUIRING_SEPARATE_CONSENT](#purposes_requiring_separate_consent) | enumeration | The purposes that may never be inferred from another (decision 8).                                                                                                                                        |
| [RedactedProjection](#redactedprojection)                                   | interface   | —                                                                                                                                                                                                         |
| [REDACTION_BOUNDARIES](#redaction_boundaries)                               | enumeration | The eight places a projection has to have happened before.                                                                                                                                                |
| [REDACTION_FAULTS](#redaction_faults)                                       | enumeration | Every kind this module can report.                                                                                                                                                                        |
| [RedactionBoundary](#redactionboundary)                                     | type        | —                                                                                                                                                                                                         |
| [RedactionFault](#redactionfault)                                           | type        | —                                                                                                                                                                                                         |
| [RedactionFinding](#redactionfinding)                                       | interface   | —                                                                                                                                                                                                         |
| [RedactionRegister](#redactionregister)                                     | interface   | —                                                                                                                                                                                                         |
| [REGISTER_FAULTS](#register_faults)                                         | enumeration | —                                                                                                                                                                                                         |
| [RegisteredField](#registeredfield)                                         | interface   | —                                                                                                                                                                                                         |
| [RegisterFault](#registerfault)                                             | type        | —                                                                                                                                                                                                         |
| [registerFaults](#registerfaults)                                           | function    | Check the register itself (S8.12.e).                                                                                                                                                                      |
| [researcherAggregateFaults](#researcheraggregatefaults)                     | function    | The researcher's rule (S8.12.b).                                                                                                                                                                          |
| [SECTION_SCOPED_ROLES](#section_scoped_roles)                               | enumeration | The roles whose reach is limited to the sections they hold.                                                                                                                                               |
| [SENSITIVITY_CLASS_FOR_CATEGORY](#sensitivity_class_for_category)           | constant    | The storage/transport class each category belongs to.                                                                                                                                                     |
| [SIDE_CHANNEL_FAULTS](#side_channel_faults)                                 | enumeration | —                                                                                                                                                                                                         |
| [SIDE_CHANNELS](#side_channels)                                             | enumeration | The ten ways a notice discloses while carrying no field at all.                                                                                                                                           |
| [SideChannel](#sidechannel)                                                 | type        | —                                                                                                                                                                                                         |
| [SideChannelFault](#sidechannelfault)                                       | type        | —                                                                                                                                                                                                         |
| [sideChannelFaults](#sidechannelfaults)                                     | function    | Everything a notice discloses without carrying a field (S8.12.f).                                                                                                                                         |
| [SOURCE_FAULTS](#source_faults)                                             | enumeration | —                                                                                                                                                                                                         |
| [SOURCE_FIELD_KINDS](#source_field_kinds)                                   | enumeration | S8.12.a — what a protected source's record holds.                                                                                                                                                         |
| [SOURCE_SUBSTITUTE_BY_AUDIENCE](#source_substitute_by_audience)             | constant    | The most a source's record may become, per audience (decision 4).                                                                                                                                         |
| [SOURCE_SUBSTITUTES](#source_substitutes)                                   | enumeration | What stands in for a source, most specific last.                                                                                                                                                          |
| [sourceDisclosureFaults](#sourcedisclosurefaults)                           | function    | The most a source disclosure may be for an audience, and whether a proposed one exceeds it (S8.12.a).                                                                                                     |
| [SourceFault](#sourcefault)                                                 | type        | —                                                                                                                                                                                                         |
| [SourceFieldKind](#sourcefieldkind)                                         | type        | —                                                                                                                                                                                                         |
| [sourcePolicyFaults](#sourcepolicyfaults)                                   | function    | Check the pseudonym register against decisions 5 and 6 (S8.12.a).                                                                                                                                         |
| [SourcePseudonym](#sourcepseudonym)                                         | interface   | —                                                                                                                                                                                                         |
| [SourceSubstitute](#sourcesubstitute)                                       | type        | —                                                                                                                                                                                                         |
| [SurfaceCapture](#surfacecapture)                                           | interface   | —                                                                                                                                                                                                         |
| [surfaceLeaks](#surfaceleaks)                                               | function    | S1.10's shape detectors over a capture, so a credential or an address pasted into an unclassified field is caught by the check that already argues about it rather than by a second set of patterns here. |
| [uncoveredBoundaries](#uncoveredboundaries)                                 | function    | The boundaries nothing observed. A coverage claim is a claim about what was looked at.                                                                                                                    |
| [UNRELEASED_FAULTS](#unreleased_faults)                                     | enumeration | —                                                                                                                                                                                                         |
| [UNRELEASED_FIELD_KINDS](#unreleased_field_kinds)                           | enumeration | S8.12.d — what an unreleased asset's record holds.                                                                                                                                                        |
| [UnreleasedFault](#unreleasedfault)                                         | type        | —                                                                                                                                                                                                         |
| [UnreleasedFieldKind](#unreleasedfieldkind)                                 | type        | —                                                                                                                                                                                                         |
| [unreleasedReleaseFaults](#unreleasedreleasefaults)                         | function    | Whether an unreleased asset's field may be released (S8.12.d).                                                                                                                                            |
| [UnreleasedReleaseRequest](#unreleasedreleaserequest)                       | interface   | —                                                                                                                                                                                                         |
| [unsweptSurfaces](#unsweptsurfaces)                                         | function    | The surfaces nothing captured. A leakage suite is a claim about where it looked.                                                                                                                          |
| [WithheldField](#withheldfield)                                             | interface   | —                                                                                                                                                                                                         |

## Shapes

#### AggregateRelease

| Field        | Type      | Required | Notes                                                                    |
| ------------ | --------- | -------- | ------------------------------------------------------------------------ |
| `at`         | `string`  | required | —                                                                        |
| `cohortSize` | `number`  | required | —                                                                        |
| `rounded`    | `boolean` | required | True when a small cohort was rounded to a bucket rather than suppressed. |

#### audienceCeilingFor

The widest audience an event in this category may reach.

```ts
audienceCeilingFor(category: ProtectedCategory): ActivityAudience
```

#### BIOMETRIC_DERIVED_KINDS

The artefacts computed FROM a modality, which are the modality (decision 7).

Values: `embedding`, `template`, `derived`

#### BIOMETRIC_FAULTS

Values: `derived-biometric-with-no-source-modality`,
`derived-biometric-from-a-derived-kind`, `modality-not-consented`,
`purpose-not-consented`, `purpose-inferred-from-another-consent`,
`consent-expired`, `consent-withdrawn`,
`withdrawal-did-not-reach-the-derivatives`, `consent-expiry-before-its-grant`,
`consent-with-no-purposes`, `biometric-released-beyond-the-subject`,
`biometric-decided-on-a-nonserver-clock`

#### BIOMETRIC_FIELD_KINDS

S8.12.c — the modalities and the artefacts computed from them.

Values: `face`, `voice`, `body`, `motion`, `health`, `embedding`, `template`,
`derived`

#### BIOMETRIC_PURPOSES

Values: `identity-verification`, `liveness`, `performance-capture`,
`accessibility-captioning`, `safety-moderation`, `voice-synthesis`,
`model-training`, `research`

#### BIOMETRIC_SOURCE_MODALITIES

The modalities a biometric is captured IN.

Values: `face`, `voice`, `body`, `motion`, `health`

#### BiometricConsent

| Field                  | Type                                                                        | Required | Notes                                                                   |
| ---------------------- | --------------------------------------------------------------------------- | -------- | ----------------------------------------------------------------------- |
| `subjectId`            | `string`                                                                    | required | —                                                                       |
| `modalities`           | `readonly BiometricFieldKind[]` — [BiometricFieldKind](#biometricfieldkind) | required | —                                                                       |
| `purposes`             | `readonly BiometricPurpose[]` — [BiometricPurpose](#biometricpurpose)       | required | —                                                                       |
| `grantedAt`            | [Instant](./identity.md#instant)                                            | required | —                                                                       |
| `expiresAt`            | `Instant \| null` — [Instant](./identity.md#instant)                        | required | —                                                                       |
| `withdrawnAt`          | `Instant \| null` — [Instant](./identity.md#instant)                        | required | —                                                                       |
| `derivativesWithdrawn` | `boolean`                                                                   | required | Whether the withdrawal reached the artefacts computed from the capture. |

#### BiometricFault

```ts
(typeof BIOMETRIC_FAULTS)[number];
```

#### BiometricFieldKind

```ts
(typeof BIOMETRIC_FIELD_KINDS)[number];
```

#### BiometricPurpose

```ts
(typeof BIOMETRIC_PURPOSES)[number];
```

#### biometricReadFaults

Whether a biometric read is permitted, and why not (S8.12.c).

```ts
biometricReadFaults(request: BiometricReadRequest): readonly RedactionFinding[]
```

#### BiometricReadRequest

| Field         | Type                                                                     | Required | Notes                                                  |
| ------------- | ------------------------------------------------------------------------ | -------- | ------------------------------------------------------ |
| `at`          | `string`                                                                 | required | —                                                      |
| `kind`        | [BiometricFieldKind](#biometricfieldkind)                                | required | —                                                      |
| `derivedFrom` | `BiometricFieldKind \| null` — [BiometricFieldKind](#biometricfieldkind) | required | For a derived kind, the modality it was computed from. |
| `purpose`     | [BiometricPurpose](#biometricpurpose)                                    | required | —                                                      |
| `audience`    | [ActivityAudience](./activity-feed.md#activityaudience)                  | required | —                                                      |
| `consent`     | `BiometricConsent \| null` — [BiometricConsent](#biometricconsent)       | required | —                                                      |
| `clock`       | [ServerClock](./reviewer-handoff.md#serverclock)                         | required | —                                                      |

#### BOUNDARY_FAULTS

Values: `boundary-received-the-unredacted-record`,
`boundary-consumed-a-different-projection`,
`boundary-re-read-the-record-after-the-projection`,
`boundary-emitted-a-withheld-path`, `boundary-emitted-an-unregistered-path`,
`boundary-emitted-a-key-that-must-be-absent`

#### boundaryCoverageFaults

Whether the eight boundaries consumed the projection rather than the record
(S8.12.e).

```ts
boundaryCoverageFaults(projection: RedactedProjection, observations: readonly BoundaryObservation[]): readonly RedactionFinding[]
```

#### BoundaryFault

```ts
(typeof BOUNDARY_FAULTS)[number];
```

#### BoundaryObservation

| Field                  | Type                                    | Required | Notes                                                                           |
| ---------------------- | --------------------------------------- | -------- | ------------------------------------------------------------------------------- |
| `boundary`             | [RedactionBoundary](#redactionboundary) | required | —                                                                               |
| `at`                   | `string`                                | required | —                                                                               |
| `consumedProjectionId` | `string \| null`                        | required | The projection this boundary consumed, or `null` when it was handed the record. |
| `reReadTheRecord`      | `boolean`                               | required | True when the boundary went back to the record after receiving a projection.    |
| `emittedPaths`         | `readonly string[]`                     | required | The record paths this boundary actually emitted.                                |

#### canaryEncodings

Every form a channel might have written the canary in (decision 12).

```ts
canaryEncodings(canary: string): readonly { readonly form: EncodingForm; readonly value: string }[]
```

#### CanaryPlant

| Field             | Type                                      | Required | Notes                                                             |
| ----------------- | ----------------------------------------- | -------- | ----------------------------------------------------------------- |
| `canary`          | `string`                                  | required | —                                                                 |
| `category`        | [ProtectedCategory](#protectedcategory)   | required | —                                                                 |
| `kind`            | [ProtectedFieldKind](#protectedfieldkind) | required | —                                                                 |
| `plantedAt`       | [Instant](./identity.md#instant)          | required | —                                                                 |
| `reachedTheStore` | `boolean`                                 | required | Whether the plant actually landed in the store it was written to. |

#### canaryPlantFaults

The plants themselves, before anything is scanned (S8.12.g).

```ts
canaryPlantFaults(plants: readonly CanaryPlant[]): readonly RedactionFinding[]
```

#### CLASSIFICATION_FOR_CATEGORY

The activity classification each category projects as.

#### DISCLOSURE_LEVELS

How much of a field is being disclosed, as a ladder.

Values: `none`, `existence`, `value`, `basis`

#### DisclosureLevel

```ts
(typeof DISCLOSURE_LEVELS)[number];
```

#### disclosurePermits

True when `granted` reaches at least as far as `required`.

```ts
disclosurePermits(granted: DisclosureLevel, required: DisclosureLevel): boolean
```

#### disclosureRank

```ts
disclosureRank(level: DisclosureLevel): number
```

#### DisclosureRequest

| Field                     | Type                                                               | Required | Notes                                                                                         |
| ------------------------- | ------------------------------------------------------------------ | -------- | --------------------------------------------------------------------------------------------- |
| `audience`                | [ActivityAudience](./activity-feed.md#activityaudience)            | required | —                                                                                             |
| `educationalRole`         | `EducationalRole \| null` — [EducationalRole](#educationalrole)    | required | —                                                                                             |
| `heldSectionIds`          | `readonly string[]`                                                | required | —                                                                                             |
| `recordSectionId`         | `string \| null`                                                   | required | —                                                                                             |
| `rightsTransferred`       | `boolean`                                                          | required | —                                                                                             |
| `supportGrantLive`        | `boolean`                                                          | required | —                                                                                             |
| `consent`                 | `BiometricConsent \| null` — [BiometricConsent](#biometricconsent) | required | —                                                                                             |
| `biometricPurpose`        | `BiometricPurpose \| null` — [BiometricPurpose](#biometricpurpose) | required | —                                                                                             |
| `embargo`                 | `Embargo \| null` — [Embargo](#embargo)                            | required | —                                                                                             |
| `clock`                   | [ServerClock](./reviewer-handoff.md#serverclock)                   | required | —                                                                                             |
| `sourceSubstitute`        | [SourceSubstitute](#sourcesubstitute)                              | required | The substitute actually offered for a source field, if any.                                   |
| `withinAnIntegrityRecord` | `boolean`                                                          | required | Whether this projection is of an integrity case file rather than of the learner's own record. |

#### DISTINGUISHING_ERROR_CLASSIFIERS

The classifiers that answer "which of the two is it" (S8.12.f).

Values: `not-found`, `no-such-record`, `forbidden`, `not-permitted`,
`unauthorized`

#### EDUCATIONAL_ROLES

Who reads a learner's record.

Values: `learner`, `guardian`, `instructor-of-record`, `teaching-assistant`,
`academic-advisor`, `registrar`, `accessibility-coordinator`,
`integrity-officer`, `institutional-researcher`, `platform-operator`

#### EducationalRole

```ts
(typeof EDUCATIONAL_ROLES)[number];
```

#### Embargo

| Field                 | Type                                                                                    | Required | Notes                                                   |
| --------------------- | --------------------------------------------------------------------------------------- | -------- | ------------------------------------------------------- |
| `assetId`             | `string`                                                                                | required | —                                                       |
| `liftsAt`             | `Instant \| null` — [Instant](./identity.md#instant)                                    | required | When the embargo ends. `null` is refused by decision 9. |
| `audiencesBeforeLift` | `readonly ActivityAudience[]` — [ActivityAudience](./activity-feed.md#activityaudience) | required | —                                                       |
| `justification`       | `string`                                                                                | required | —                                                       |

#### EMBARGO_STANDINGS

Values: `held`, `lifted`, `indeterminate`, `unbounded`

#### embargoStanding

Where an embargo stands against a server clock (S8.12.d).

```ts
embargoStanding(embargo: Embargo, clock: ServerClock): EmbargoStanding
```

#### EmbargoStanding

```ts
(typeof EMBARGO_STANDINGS)[number];
```

#### ENCODING_FORMS

Values: `literal`, `percent`, `base64`, `json-escaped`, `html-entity`,
`unicode-escape`

#### EncodingForm

```ts
(typeof ENCODING_FORMS)[number];
```

#### exposureCeilingFor

The most exposing transport a value in this category may travel on.

```ts
exposureCeilingFor(category: ProtectedCategory): ChannelExposure
```

#### FIELD_KINDS_BY_CATEGORY

Which kinds belong to which category.

#### fieldKindBelongs

Whether a kind is one this category actually has.

```ts
fieldKindBelongs(category: ProtectedCategory, kind: string): boolean
```

#### fieldReleaseFaults

Whether one registered field may be released to this request, with reasons
(S8.12.a-d applied through one seam).

```ts
fieldReleaseFaults(field: RegisteredField, request: DisclosureRequest): readonly RedactionFinding[]
```

#### GRANT_GATED_ROLES

The roles that read a learner's record only through a live support grant.

Values: `platform-operator`

#### INDISTINGUISHABLE_ERROR_CLASSIFIER

The one classifier a presence-disclosing refusal may carry.

Value: `'unavailable'`

#### LEAKAGE_FAULTS

Values: `canary-survived-to-a-surface`, `canary-survived-in-an-encoded-form`,
`canary-named-a-structured-key`, `canary-never-reached-the-store`,
`canary-too-weak-to-be-distinctive`, `canary-duplicated-across-plants`,
`surface-emitted-a-shape-leak`

#### LEAKAGE_SURFACES

The eight surfaces a planted value is followed to.

Values: `notification`, `activity`, `digest`, `email`, `push`, `webhook`,
`export`, `snapshot`

#### LeakageFault

```ts
(typeof LEAKAGE_FAULTS)[number];
```

#### leakageFaults

Follow every plant onto every capture (S8.12.g).

```ts
leakageFaults(plants: readonly CanaryPlant[], captures: readonly SurfaceCapture[]): readonly RedactionFinding[]
```

#### LeakageSurface

```ts
(typeof LEAKAGE_SURFACES)[number];
```

#### LEARNER_ACCESS

The educational-role access matrix (S8.12.b).

#### LEARNER_FAULTS

Values: `role-read-above-its-ceiling`, `guardian-read-after-rights-transferred`,
`section-scoped-role-read-outside-its-sections`,
`section-scoped-role-with-no-sections`,
`grant-gated-role-read-with-no-live-grant`, `researcher-read-at-row-level`,
`aggregate-below-the-cohort-floor`, `aggregate-rounded-rather-than-suppressed`,
`accommodation-basis-attached-to-an-integrity-record`

#### LEARNER_FIELD_KINDS

S8.12.b — what a learner's record holds.

Values: `identity`, `enrollment`, `activity`, `assessment`, `accommodation`,
`integrity`, `credential`

#### LearnerFault

```ts
(typeof LEARNER_FAULTS)[number];
```

#### LearnerFieldKind

```ts
(typeof LEARNER_FIELD_KINDS)[number];
```

#### learnerReadFaults

Whether one educational-role read is permitted, and why not (S8.12.b).

```ts
learnerReadFaults(request: LearnerReadRequest): readonly RedactionFinding[]
```

#### LearnerReadRequest

| Field                     | Type                                  | Required | Notes                                                                                             |
| ------------------------- | ------------------------------------- | -------- | ------------------------------------------------------------------------------------------------- |
| `at`                      | `string`                              | required | —                                                                                                 |
| `role`                    | [EducationalRole](#educationalrole)   | required | —                                                                                                 |
| `kind`                    | [LearnerFieldKind](#learnerfieldkind) | required | —                                                                                                 |
| `level`                   | [DisclosureLevel](#disclosurelevel)   | required | —                                                                                                 |
| `rightsTransferred`       | `boolean`                             | required | Whether the learner holds their own record rights (age of majority, or postsecondary enrollment). |
| `heldSectionIds`          | `readonly string[]`                   | required | —                                                                                                 |
| `recordSectionId`         | `string \| null`                      | required | —                                                                                                 |
| `supportGrantLive`        | `boolean`                             | required | —                                                                                                 |
| `withinAnIntegrityRecord` | `boolean`                             | required | True when this read is of an integrity case rather than of the learner's file.                    |

#### MINIMUM_CANARY_LENGTH

Under this length a canary can occur in ordinary text, and a hit means nothing.

Value: `12`

#### NoticeObservation

| Field                     | Type                                                         | Required | Notes                                                                           |
| ------------------------- | ------------------------------------------------------------ | -------- | ------------------------------------------------------------------------------- |
| `at`                      | `string`                                                     | required | —                                                                               |
| `category`                | [ProtectedCategory](#protectedcategory)                      | required | —                                                                               |
| `audience`                | [ActivityAudience](./activity-feed.md#activityaudience)      | required | —                                                                               |
| `exposure`                | [ChannelExposure](./notification-routing.md#channelexposure) | required | —                                                                               |
| `count`                   | `number \| null`                                             | required | A count over a set this reader may not enumerate, or `null` when none is shown. |
| `countRounded`            | `boolean`                                                    | required | —                                                                               |
| `actorName`               | `string \| null`                                             | required | —                                                                               |
| `actorSubstituteRequired` | `boolean`                                                    | required | —                                                                               |
| `avatarUrl`               | `string \| null`                                             | required | —                                                                               |
| `targetTitle`             | `string \| null`                                             | required | —                                                                               |
| `targetUrl`               | `string \| null`                                             | required | —                                                                               |
| `snippet`                 | `string \| null`                                             | required | —                                                                               |
| `groupingKeyPaths`        | `readonly string[]`                                          | required | The record paths the surface grouped rows by.                                   |
| `occurredAt`              | `Instant \| null` — [Instant](./identity.md#instant)         | required | —                                                                               |
| `emittedAt`               | `Instant \| null` — [Instant](./identity.md#instant)         | required | —                                                                               |
| `errorClassifier`         | `string \| null`                                             | required | —                                                                               |
| `deepLinkPath`            | `string \| null`                                             | required | —                                                                               |
| `deepLinkTargetPermitted` | `boolean`                                                    | required | —                                                                               |
| `protectedIdentifiers`    | `readonly string[]`                                          | required | Identifiers that must not appear in a link or a path for this reader.           |

#### PRESENCE_DISCLOSING_FIELDS

The (category, kind) pairs where the EXISTENCE of the field is already the
disclosure (decision 3).

#### presenceDiscloses

```ts
presenceDiscloses(category: ProtectedCategory, kind: ProtectedFieldKind): boolean
```

#### projectAllowed

The allowlist projection (S8.12.e, decision 1).

```ts
projectAllowed(record: Readonly<Record<string, string>>, register: RedactionRegister, request: DisclosureRequest, projectionId: string): RedactedProjection
```

#### PROJECTION_FAULTS

The kinds the projection raises that no category policy owns.

Values: `audience-above-the-category-ceiling`,
`learner-read-with-no-educational-role`, `biometric-read-with-no-purpose`

#### ProjectionFault

```ts
(typeof PROJECTION_FAULTS)[number];
```

#### PROTECTED_CATEGORIES

The four categories the parent phase names.

Values: `protected-source`, `learner-record`, `biometric`, `unreleased-asset`

#### ProtectedCategory

```ts
(typeof PROTECTED_CATEGORIES)[number];
```

#### ProtectedFieldKind

```ts
| SourceFieldKind
| LearnerFieldKind
| BiometricFieldKind
| UnreleasedFieldKind
```

#### ProtectedFieldRef

| Field      | Type                                      | Required | Notes |
| ---------- | ----------------------------------------- | -------- | ----- |
| `category` | [ProtectedCategory](#protectedcategory)   | required | —     |
| `kind`     | [ProtectedFieldKind](#protectedfieldkind) | required | —     |

#### PURPOSES_REQUIRING_SEPARATE_CONSENT

The purposes that may never be inferred from another (decision 8).

Values: `voice-synthesis`, `model-training`, `research`

#### RedactedProjection

| Field          | Type                                                         | Required | Notes                                                             |
| -------------- | ------------------------------------------------------------ | -------- | ----------------------------------------------------------------- |
| `projectionId` | `string`                                                     | required | —                                                                 |
| `registerId`   | `string`                                                     | required | —                                                                 |
| `released`     | `Readonly<Record<string, string>>`                           | required | Paths and values that survived.                                   |
| `withheld`     | `readonly WithheldField[]` — [WithheldField](#withheldfield) | required | —                                                                 |
| `unregistered` | `readonly string[]`                                          | required | Record paths the register does not cover. Withheld, and reported. |

#### REDACTION_BOUNDARIES

The eight places a projection has to have happened before.

Values: `summary-generation`, `template-render`, `channel-routing`,
`activity-projection`, `search-index`, `export`, `application-log`,
`support-tool`

#### REDACTION_FAULTS

Every kind this module can report.

Values: `pseudonym-derived-from-the-identity`, `codename-carries-the-identity`,
`codename-reused-across-stories`, `codename-blank`,
`two-codenames-for-one-source-in-one-story`,
`role-summary-with-no-cohort-measurement`,
`role-summary-below-the-cohort-floor`, `role-summary-carries-the-identity`,
`substitute-above-what-the-audience-permits`,
`identity-released-where-a-substitute-was-required`,
`role-read-above-its-ceiling`, `guardian-read-after-rights-transferred`,
`section-scoped-role-read-outside-its-sections`,
`section-scoped-role-with-no-sections`,
`grant-gated-role-read-with-no-live-grant`, `researcher-read-at-row-level`,
`aggregate-below-the-cohort-floor`, `aggregate-rounded-rather-than-suppressed`,
`accommodation-basis-attached-to-an-integrity-record`,
`derived-biometric-with-no-source-modality`,
`derived-biometric-from-a-derived-kind`, `modality-not-consented`,
`purpose-not-consented`, `purpose-inferred-from-another-consent`,
`consent-expired`, `consent-withdrawn`,
`withdrawal-did-not-reach-the-derivatives`, `consent-expiry-before-its-grant`,
`consent-with-no-purposes`, `biometric-released-beyond-the-subject`,
`biometric-decided-on-a-nonserver-clock`, `embargo-with-no-lift-instant`,
`embargo-with-no-justification`, `embargo-decided-on-a-nonserver-clock`,
`embargo-audience-above-the-classification-ceiling`, `embargo-audience-empty`,
`unreleased-asset-with-no-embargo-record`,
`released-to-an-audience-outside-the-embargo`,
`released-while-the-standing-is-indeterminate`,
`title-released-before-the-lift`, `field-kind-not-in-its-category`,
`duplicate-field-id`, `duplicate-path`, `blank-path`,
`derived-biometric-without-a-modality`,
`modality-declared-on-a-field-that-is-not-derived`,
`category-with-no-registered-field`, `audience-above-the-category-ceiling`,
`learner-read-with-no-educational-role`, `biometric-read-with-no-purpose`,
`boundary-received-the-unredacted-record`,
`boundary-consumed-a-different-projection`,
`boundary-re-read-the-record-after-the-projection`,
`boundary-emitted-a-withheld-path`, `boundary-emitted-an-unregistered-path`,
`boundary-emitted-a-key-that-must-be-absent`, `count-below-the-cohort-floor`,
`count-rounded-rather-than-suppressed`,
`actor-named-where-a-substitute-was-required`,
`avatar-derived-from-a-contact-detail`,
`authored-title-on-a-presence-disclosing-category`,
`url-path-carries-a-protected-identifier`, `snippet-carries-record-text`,
`grouping-key-the-reader-may-not-see`, `emission-time-equals-the-event-time`,
`error-classifier-separates-absence-from-refusal`,
`deep-link-to-a-target-the-reader-may-not-open`,
`carried-above-the-category-exposure-ceiling`, `canary-survived-to-a-surface`,
`canary-survived-in-an-encoded-form`, `canary-named-a-structured-key`,
`canary-never-reached-the-store`, `canary-too-weak-to-be-distinctive`,
`canary-duplicated-across-plants`, `surface-emitted-a-shape-leak`

#### RedactionBoundary

```ts
(typeof REDACTION_BOUNDARIES)[number];
```

#### RedactionFault

```ts
(typeof REDACTION_FAULTS)[number];
```

#### RedactionFinding

| Field     | Type                              | Required | Notes                                                               |
| --------- | --------------------------------- | -------- | ------------------------------------------------------------------- |
| `kind`    | [RedactionFault](#redactionfault) | required | —                                                                   |
| `subject` | `string`                          | required | The field, boundary, notice, plant or surface the finding is about. |
| `detail`  | `string`                          | required | —                                                                   |

#### RedactionRegister

| Field        | Type                                                               | Required | Notes |
| ------------ | ------------------------------------------------------------------ | -------- | ----- |
| `registerId` | `string`                                                           | required | —     |
| `fields`     | `readonly RegisteredField[]` — [RegisteredField](#registeredfield) | required | —     |

#### REGISTER_FAULTS

Values: `field-kind-not-in-its-category`, `duplicate-field-id`,
`duplicate-path`, `blank-path`, `derived-biometric-without-a-modality`,
`modality-declared-on-a-field-that-is-not-derived`,
`category-with-no-registered-field`

#### RegisteredField

| Field         | Type                                                                     | Required | Notes                                                                       |
| ------------- | ------------------------------------------------------------------------ | -------- | --------------------------------------------------------------------------- |
| `fieldId`     | `string`                                                                 | required | Stable identity for the rule. Survives a rename of the path.                |
| `category`    | [ProtectedCategory](#protectedcategory)                                  | required | —                                                                           |
| `kind`        | [ProtectedFieldKind](#protectedfieldkind)                                | required | —                                                                           |
| `detail`      | `Exclude<DisclosureLevel, 'none'>` — [DisclosureLevel](#disclosurelevel) | required | What this field IS: its existence, its value, or the reasoning behind it.   |
| `path`        | `string`                                                                 | required | Where it lives on the record. The key the projection releases or withholds. |
| `derivedFrom` | `BiometricFieldKind \| null` — [BiometricFieldKind](#biometricfieldkind) | required | For a derived biometric, the modality it was computed from.                 |

#### RegisterFault

```ts
(typeof REGISTER_FAULTS)[number];
```

#### registerFaults

Check the register itself (S8.12.e).

```ts
registerFaults(register: RedactionRegister): readonly RedactionFinding[]
```

#### researcherAggregateFaults

The researcher's rule (S8.12.b).

```ts
researcherAggregateFaults(release: AggregateRelease, cohortFloor: number): readonly RedactionFinding[]
```

#### SECTION_SCOPED_ROLES

The roles whose reach is limited to the sections they hold.

Values: `instructor-of-record`, `teaching-assistant`

#### SENSITIVITY_CLASS_FOR_CATEGORY

The storage/transport class each category belongs to.

#### SIDE_CHANNEL_FAULTS

Values: `count-below-the-cohort-floor`, `count-rounded-rather-than-suppressed`,
`actor-named-where-a-substitute-was-required`,
`avatar-derived-from-a-contact-detail`,
`authored-title-on-a-presence-disclosing-category`,
`url-path-carries-a-protected-identifier`, `snippet-carries-record-text`,
`grouping-key-the-reader-may-not-see`, `emission-time-equals-the-event-time`,
`error-classifier-separates-absence-from-refusal`,
`deep-link-to-a-target-the-reader-may-not-open`,
`carried-above-the-category-exposure-ceiling`

#### SIDE_CHANNELS

The ten ways a notice discloses while carrying no field at all.

Values: `count`, `actor-name`, `actor-avatar`, `target-title`, `target-url`,
`snippet`, `grouping`, `timing`, `error`, `deep-link`

#### SideChannel

```ts
(typeof SIDE_CHANNELS)[number];
```

#### SideChannelFault

```ts
(typeof SIDE_CHANNEL_FAULTS)[number];
```

#### sideChannelFaults

Everything a notice discloses without carrying a field (S8.12.f).

```ts
sideChannelFaults(observation: NoticeObservation, projection: RedactedProjection, cohortFloor: number, batchingWindowSeconds: number): readonly RedactionFinding[]
```

#### SOURCE_FAULTS

Values: `pseudonym-derived-from-the-identity`, `codename-carries-the-identity`,
`codename-reused-across-stories`, `codename-blank`,
`two-codenames-for-one-source-in-one-story`,
`role-summary-with-no-cohort-measurement`,
`role-summary-below-the-cohort-floor`, `role-summary-carries-the-identity`,
`substitute-above-what-the-audience-permits`,
`identity-released-where-a-substitute-was-required`

#### SOURCE_FIELD_KINDS

S8.12.a — what a protected source's record holds.

Values: `identity`, `contact`, `document`, `relationship`, `location`

#### SOURCE_SUBSTITUTE_BY_AUDIENCE

The most a source's record may become, per audience (decision 4).

#### SOURCE_SUBSTITUTES

What stands in for a source, most specific last.

Values: `none`, `role-summary`, `pseudonym`

#### sourceDisclosureFaults

The most a source disclosure may be for an audience, and whether a proposed one
exceeds it (S8.12.a).

```ts
sourceDisclosureFaults(disclosure: { readonly at: string; readonly audience: ActivityAudience; readonly offered: SourceSubstitute; readonly releasedKind: SourceFieldKind | null; }): readonly RedactionFinding[]
```

#### SourceFault

```ts
(typeof SOURCE_FAULTS)[number];
```

#### SourceFieldKind

```ts
(typeof SOURCE_FIELD_KINDS)[number];
```

#### sourcePolicyFaults

Check the pseudonym register against decisions 5 and 6 (S8.12.a).

```ts
sourcePolicyFaults(pseudonyms: readonly SourcePseudonym[], cohortFloor: number): readonly RedactionFinding[]
```

#### SourcePseudonym

| Field                   | Type                                    | Required | Notes                                                                               |
| ----------------------- | --------------------------------------- | -------- | ----------------------------------------------------------------------------------- |
| `sourceId`              | `string`                                | required | —                                                                                   |
| `storyId`               | `string`                                | required | The story the codename was cut for. One codename per source per story.              |
| `codename`              | `string`                                | required | —                                                                                   |
| `assignedFrom`          | `'register' \| 'derived-from-identity'` | required | Where the codename came from. `derived` is refused by decision 5.                   |
| `identity`              | `string`                                | required | The identity the codename stands in for, so the codename can be checked against it. |
| `roleSummary`           | `string \| null`                        | required | —                                                                                   |
| `roleSummaryCohortSize` | `number \| null`                        | required | How many people in the relevant population share this role summary.                 |

#### SourceSubstitute

```ts
(typeof SOURCE_SUBSTITUTES)[number];
```

#### SurfaceCapture

| Field     | Type                              | Required | Notes                                                                  |
| --------- | --------------------------------- | -------- | ---------------------------------------------------------------------- |
| `surface` | [LeakageSurface](#leakagesurface) | required | —                                                                      |
| `at`      | `string`                          | required | —                                                                      |
| `payload` | `string`                          | required | The payload exactly as the surface emitted it.                         |
| `keys`    | `readonly string[]`               | required | Structured keys on the surface, e.g. push data keys or export columns. |

#### surfaceLeaks

S1.10's shape detectors over a capture, so a credential or an address pasted
into an unclassified field is caught by the check that already argues about it
rather than by a second set of patterns here.

```ts
surfaceLeaks(capture: SurfaceCapture): readonly Leak[]
```

#### uncoveredBoundaries

The boundaries nothing observed. A coverage claim is a claim about what was
looked at.

```ts
uncoveredBoundaries(observations: readonly BoundaryObservation[]): readonly RedactionBoundary[]
```

#### UNRELEASED_FAULTS

Values: `embargo-with-no-lift-instant`, `embargo-with-no-justification`,
`embargo-decided-on-a-nonserver-clock`,
`embargo-audience-above-the-classification-ceiling`, `embargo-audience-empty`,
`unreleased-asset-with-no-embargo-record`,
`released-to-an-audience-outside-the-embargo`,
`released-while-the-standing-is-indeterminate`, `title-released-before-the-lift`

#### UNRELEASED_FIELD_KINDS

S8.12.d — what an unreleased asset's record holds.

Values: `content`, `title`, `media`, `script`, `build`, `research`, `model`,
`product`, `embargo-metadata`

#### UnreleasedFault

```ts
(typeof UNRELEASED_FAULTS)[number];
```

#### UnreleasedFieldKind

```ts
(typeof UNRELEASED_FIELD_KINDS)[number];
```

#### unreleasedReleaseFaults

Whether an unreleased asset's field may be released (S8.12.d).

```ts
unreleasedReleaseFaults(request: UnreleasedReleaseRequest): readonly RedactionFinding[]
```

#### UnreleasedReleaseRequest

| Field      | Type                                                    | Required | Notes |
| ---------- | ------------------------------------------------------- | -------- | ----- |
| `at`       | `string`                                                | required | —     |
| `kind`     | [UnreleasedFieldKind](#unreleasedfieldkind)             | required | —     |
| `audience` | [ActivityAudience](./activity-feed.md#activityaudience) | required | —     |
| `embargo`  | `Embargo \| null` — [Embargo](#embargo)                 | required | —     |
| `clock`    | [ServerClock](./reviewer-handoff.md#serverclock)        | required | —     |

#### unsweptSurfaces

The surfaces nothing captured. A leakage suite is a claim about where it looked.

```ts
unsweptSurfaces(captures: readonly SurfaceCapture[]): readonly LeakageSurface[]
```

#### WithheldField

| Field             | Type                                                                  | Required | Notes                                                                |
| ----------------- | --------------------------------------------------------------------- | -------- | -------------------------------------------------------------------- |
| `fieldId`         | `string`                                                              | required | —                                                                    |
| `path`            | `string`                                                              | required | —                                                                    |
| `category`        | [ProtectedCategory](#protectedcategory)                               | required | —                                                                    |
| `kind`            | [ProtectedFieldKind](#protectedfieldkind)                             | required | —                                                                    |
| `because`         | `readonly RedactionFinding[]` — [RedactionFinding](#redactionfinding) | required | Why it did not come out, as findings from the category's own policy. |
| `keyMustBeAbsent` | `boolean`                                                             | required | Whether even the KEY must be absent.                                 |

## Valid examples

No committed fixture corpus covers this page's accepted cases; they are
unit-level and live in the module's own spec.

## Invalid examples

No committed fixture corpus covers this page's refused cases; they are
unit-level and live in the module's own spec.

## Authorization and scope

| Symbol                                      | Type              | Notes                                                                     |
| ------------------------------------------- | ----------------- | ------------------------------------------------------------------------- | --- |
| `BiometricConsent.grantedAt`                | `Instant`         | —                                                                         |
| `BiometricReadRequest.consent`              | `BiometricConsent | null`                                                                     | —   |
| `DisclosureRequest.consent`                 | `BiometricConsent | null`                                                                     | —   |
| `DisclosureRequest.supportGrantLive`        | `boolean`         | —                                                                         |
| `GRANT_GATED_ROLES`                         | `enumeration`     | The roles that read a learner's record only through a live support grant. |
| `LearnerReadRequest.supportGrantLive`       | `boolean`         | —                                                                         |
| `NoticeObservation.actorName`               | `string           | null`                                                                     | —   |
| `NoticeObservation.actorSubstituteRequired` | `boolean`         | —                                                                         |
| `PURPOSES_REQUIRING_SEPARATE_CONSENT`       | `enumeration`     | The purposes that may never be inferred from another (decision 8).        |
| `SECTION_SCOPED_ROLES`                      | `enumeration`     | The roles whose reach is limited to the sections they hold.               |

## Idempotency and concurrency

Not applicable: nothing on this page is retried or applied twice: these are
declarations, not operations.

## Pagination

| Symbol                                     | Type          | Notes                                                         |
| ------------------------------------------ | ------------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| `BoundaryObservation.consumedProjectionId` | `string       | null`                                                         | The projection this boundary consumed, or `null` when it was handed the record. |
| `PROJECTION_FAULTS`                        | `enumeration` | The kinds the projection raises that no category policy owns. |
| `ProjectionFault`                          | `type`        | —                                                             |
| `RedactedProjection.projectionId`          | `string`      | —                                                             |

## State and failure

| Symbol                               | Type          | Notes                                                           |
| ------------------------------------ | ------------- | --------------------------------------------------------------- | --- |
| `DISTINGUISHING_ERROR_CLASSIFIERS`   | `enumeration` | The classifiers that answer "which of the two is it" (S8.12.f). |
| `INDISTINGUISHABLE_ERROR_CLASSIFIER` | `constant`    | The one classifier a presence-disclosing refusal may carry.     |
| `NoticeObservation.errorClassifier`  | `string       | null`                                                           | —   |

## Compatibility

Not applicable: nothing on this page is versioned independently of the package.

## Deprecation

Not applicable: nothing on this page can be deprecated on its own; the package
version is its lifecycle.

## Evidence

- `evidence/v1-workbenches/workbench-kit-export-map.json`
- `libs/oshun/workbench-kit/src/redaction.ts`
