Eve library

Plugin and stage machine

Evidence

Revision 1

On this page

The seven extension points a domain contributes to, the engine that decides whether a transition may happen, the guards it decides with, the decision record whose own lifecycle is an instance of that engine, the gate catalogue the running gates are made to agree with, the fold from recorded runs to a release decision, the authorized exception that lets one through, the one gate automation cannot answer for itself, the audit projection every one of them writes into, the ownership rules that say which tenant may see any of it, the one lifecycle that ends irreversibly, the constraints that make a retry of any of it safe, and the query workload every one of those rows is read back by — with the index declared for each read and the gate that judges the plan — and the durable half those rows are moved by: the transaction-bound outbox, the inbox that makes at-least-once survivable, the quarantine for what neither of them can apply, and the job whose worker may stop existing mid-stage — with the graph that same job becomes when it fans out, and the partial outcome it needs so a lost optional child is neither a failure nor invisible — and, underneath all of them, the reference to bytes nobody in this system produced — and the sweep that reclaims the ones nothing points at, which is the only operation here with no compensating action — and, beside all of it, the columns that cannot be stored as they arrive: what a field may be USED for rather than how secret it feels, the associated data that binds a ciphertext to the row rather than to the query that finds it, the lease a resolved secret comes back as, the redaction the matrix drives and the shape scan only calibrates, the plaintext a DROP COLUMN leaves on disk, and the seven failure modes whose only useful property is being told apart.

Generated from libs/oshun/workbench-kit/src/audit.ts, libs/oshun/workbench-kit/src/blobs.ts, libs/oshun/workbench-kit/src/decisions.ts, libs/oshun/workbench-kit/src/deletion.ts, libs/oshun/workbench-kit/src/gate-definitions.ts, libs/oshun/workbench-kit/src/gate-runs.ts, libs/oshun/workbench-kit/src/gate-waivers.ts, libs/oshun/workbench-kit/src/guards.ts, libs/oshun/workbench-kit/src/idempotency.ts, libs/oshun/workbench-kit/src/inbox.ts, libs/oshun/workbench-kit/src/indexes.ts, libs/oshun/workbench-kit/src/job-graphs.ts, libs/oshun/workbench-kit/src/jobs.ts, libs/oshun/workbench-kit/src/outbox.ts, libs/oshun/workbench-kit/src/plugins.ts, libs/oshun/workbench-kit/src/probes.ts, libs/oshun/workbench-kit/src/protection.ts, libs/oshun/workbench-kit/src/quarantine.ts, libs/oshun/workbench-kit/src/reclamation.ts, libs/oshun/workbench-kit/src/signoff.ts, libs/oshun/workbench-kit/src/stages.ts, libs/oshun/workbench-kit/src/tenancy.ts by node scripts/v1-workbenches/generate-workbench-kit-api-reference.mjs. Ledger: S1.9 / S2.1 / S2.2 / S2.7 / S2.9 / S2.10 / S2.11 / S2.13 / S2.14 / S3.2 / S3.3 / S3.4 / S3.5 / S3.6 / S3.7 / S3.8 / S3.9 / S3.10 / S3.11 / S3.12. Do not edit by hand.

Summary#

  • src/audit.ts
  • src/blobs.ts
  • src/decisions.ts
  • src/deletion.ts
  • src/gate-definitions.ts
  • src/gate-runs.ts
  • src/gate-waivers.ts
  • src/guards.ts
  • src/idempotency.ts
  • src/inbox.ts
  • src/indexes.ts
  • src/job-graphs.ts
  • src/jobs.ts
  • src/outbox.ts
  • src/plugins.ts
  • src/probes.ts
  • src/protection.ts
  • src/quarantine.ts
  • src/reclamation.ts
  • src/signoff.ts
  • src/stages.ts
  • src/tenancy.ts
Entry point Runtime class Authorized by
@oshun/workbench-kit/audit contract S2.14
@oshun/workbench-kit/blobs contract S3.11
@oshun/workbench-kit/decisions contract S2.7
@oshun/workbench-kit/deletion contract S3.3
@oshun/workbench-kit/gate-definitions contract S2.9
@oshun/workbench-kit/gate-runs contract S2.10
@oshun/workbench-kit/gate-waivers contract S2.11
@oshun/workbench-kit/guards contract S2.2
@oshun/workbench-kit/idempotency contract S3.4
@oshun/workbench-kit/inbox contract S3.7
@oshun/workbench-kit/indexes contract S3.5
@oshun/workbench-kit/job-graphs contract S3.10
@oshun/workbench-kit/jobs contract S3.9
@oshun/workbench-kit/outbox contract S3.6
@oshun/workbench-kit/plugins contract S1.9
@oshun/workbench-kit/probes contract S3.14
@oshun/workbench-kit/protection contract S3.13
@oshun/workbench-kit/quarantine contract S3.8
@oshun/workbench-kit/reclamation contract S3.12
@oshun/workbench-kit/signoff contract S2.13
@oshun/workbench-kit/stages contract S2.1
@oshun/workbench-kit/tenancy contract S3.2

Exports#

Symbol Kind Summary
ACCESS_DENIALS enumeration —
AccessDecision type —
AccessDenial type —
AccessDimension interface One dimension a workbench is filtered or sorted by, and where it is answered.
AccessRequest interface —
ACTION_REFUSALS enumeration —
ActionDecision type —
ActionRefusal type —
ActionRequest interface —
ActivatedPlugin interface —
ActivationContext interface —
ActivationOutcome type —
ADAPTER_FAULT_KINDS enumeration —
AdapterFault interface —
AdapterFaultKind type —
adapterFaults function Compare what two adapters did with the same bytes (S3.11.g).
Admission type —
ADMISSION_CHECKS enumeration —
AdmissionCheck type —
AdmissionDecision interface —
AdmissionPolicy interface —
admitBlob function Decide whether a blob becomes real (S3.11.e).
admitPlugin function Runtime admission for one plugin (S1.9.g).
admitSigner function Decide whether this claim may sign (S2.13.b/c).
advanceMigration function Decide whether a migration may advance to a phase (S3.13.f).
AEAD_ALGORITHMS enumeration The AEAD algorithms a field may be sealed with.
AeadAlgorithm type —
AGGREGATE_FAULT_KINDS enumeration —
AGGREGATE_POLICY_VIOLATION_KINDS enumeration —
AggregateContext interface —
AggregateFault interface —
AggregateFaultKind type —
aggregateGateRun function Fold a set of runs into a release decision (S2.10.c/d/e).
AggregatePolicy interface —
AggregatePolicyViolation interface —
AggregatePolicyViolationKind type —
aggregateProgress function Fold weighted child progress into the parent's (S3.10.d).
AggregateProgress interface —
AGGREGATION_STRATEGY_KINDS enumeration —
AggregationStrategy type —
AggregationStrategyPlugin interface A domain's own way of folding the members.
ALERT_KINDS enumeration —
ALERT_VERDICTS enumeration —
alertDecision function Decide whether sustained incompatibility should page somebody (S3.14.g).
AlertDecision interface —
AlertThresholds interface —
AlertVerdict type —
AllowedTransition interface —
allowedTransitions function What may be attempted from a stage, and exactly what each one demands.
AppealPath interface —
applicationEnforced function Constraints the application must hold, named so the gap is not a silence.
AppliedEffect interface —
AppliedWaiver interface —
appliesTo function Whether the gate runs at all for this stage and audience.
APPROVED_DIGEST_ALGORITHMS enumeration Digest algorithms this kit will record.
ApprovedDigestAlgorithm type —
asEdgeSet function Lift a job graph into the stage engine's edge set (S2.1).
associatedData function The canonical associated data for a context (S3.13.c).
AUDIT_CAPABILITIES enumeration —
AUDIT_EVENT_KINDS enumeration Every decision the stage and gate machinery makes, as a recorded fact.
AuditActor interface Who did it, in the two halves an audit row needs.
AuditCapability type —
AuditEvent interface —
AuditEventKind type —
AuditLeak type Re-exported so a caller need not reach into S1.10 to type a scan result.
AuditProjection interface —
AuditViewer interface —
authorizeAction function Authorize one operator action (S3.8.d).
authorizeBreakGlass function Decide a break-glass key access (S3.13.b).
authorizeDeadLetterAction function Authorize one action on a dead letter (S3.9.h).
authorizeDecrypt function Authorize a decrypt (S3.11.d).
authorizeResolution function Authorize a vault resolution (S3.13.d).
authorizeShred function Decide whether a key may be destroyed (S3.13.b).
BACKFILL_FAULT_KINDS enumeration —
BackfillCheckpoint interface —
BackfillFault interface —
BackfillFaultKind type —
backfillFaults function Check a backfill (S3.13.f).
backoffSeconds function Exponential backoff with a deterministic, seeded jitter.
BATCH_FAULT_KINDS enumeration —
BatchDeletionOutcome type —
BatchFault interface —
BatchFaultKind type —
batchFaults function Check how a batch was run (S3.12.f).
BatchItemResult interface —
BatchReport interface —
BehaviourFault interface —
behaviourFaults function Check observed behaviour against the expectations (S3.13.g).
Binding interface —
BINDING_FAULT_KINDS enumeration —
BINDING_STRATEGIES enumeration How a consumer binds the receipt to the effect it records.
BindingFault interface —
BindingFaultKind type —
BindingStrategy type —
BLAST_RADII enumeration How far a revocation reaches.
BlastRadius type —
BLOB_FAULT_KINDS enumeration —
BLOB_STATES enumeration Where a blob is in its own admission lifecycle.
BlobFault interface —
BlobFaultKind type —
blobFaults function Check a blob reference (S3.11.a).
BlobReference interface —
BlobState type —
BlobStore interface The contract every storage adapter satisfies.
BlockAccessibility interface —
BlockChange interface —
BlockContribution interface —
BlockedChild interface —
BlockedPartition interface —
BlockInterchange interface —
BlockMetadata interface —
BlockMigrationStep interface —
BOUNDARY_TRANSITIONS enumeration —
BoundaryTransition type —
BREAK_GLASS_REFUSALS enumeration —
BreakGlassDecision type —
BreakGlassRefusal type —
BreakGlassRequest interface —
BrokerAck interface —
buildStageGraph function Build and validate the graph.
byCorrelation function Everything one flow produced, for the question an incident actually asks.
BypassCommand interface A bypass command may name any target stage, which is the whole point of it.
canBlock function Whether a result from this gate may stop anything, at this stage.
CANCEL_OUTCOMES enumeration —
CANCEL_SOURCES enumeration —
CancelDecision type —
CANCELLATION_POINT_ACTIONS enumeration —
CANCELLATION_PROPAGATIONS enumeration What happens to the children when the parent is cancelled.
CancellationPlan interface —
cancellationPoint function What a worker does when it reaches a cancellation point (S3.9.f).
CancellationPointAction type —
CancellationPointDecision interface —
CancellationPropagation type —
CancelOutcome type —
CancelRequest interface —
CancelSource type —
CapabilityDeclaration type What a plugin says about one capability.
CapabilityProbe interface —
CapabilityVerdict interface —
CauseLink interface One link in the chain that produced the failure, newest first.
ChainResolution type Walk a supersession chain from any record to the one in force.
CHECK_RESULTS enumeration —
CHECKPOINT_ORDERINGS enumeration The orderings a stage may commit in.
CheckpointOrdering type —
CheckResult type —
ChildOutcomeRecord interface —
ChildProgress interface —
ChildRetryPlan interface —
ChildState interface —
CIPHER_FAILURES enumeration What the key service and the AEAD can say when a value will not open.
CipherFailure type —
CipherOpenResult type —
CipherSealResult type —
circuitFor function —
CircuitPolicy interface Whether a destination's circuit is open.
CircuitState type —
CLAIM_FAULT_KINDS enumeration —
CLAIM_OUTCOMES enumeration —
CLAIM_RESULTS enumeration —
CLAIMABLE_STATES enumeration States from which a dispatcher may claim.
ClaimDecision type —
ClaimFault interface —
ClaimFaultKind type —
claimFaults function —
claimOrder function The order a dispatcher must claim in, as a comparator over rows.
ClaimOutcome type —
ClaimPolicy interface How a dispatcher takes work.
ClaimRequest interface —
ClaimRequest interface —
ClaimResult type —
Classification interface —
classifyJobFailure function Classify a failed attempt (S3.9.g).
classifyOrphan function Classify one observation (S3.12.b).
classifyPoison function Decide what kind of poison this is (S3.8.a).
Collation type —
COLLATIONS enumeration The collation an index column is built with, which for text is the difference between an index that works and one that is merely present.
ColumnCensus interface Every column the storage layer knows about.
ColumnFacts interface What is known about one column's values, per tenant.
CommitRequest interface —
commitWithEvents function The only way to write, and it takes the events with it (S3.6.b).
compareSchema function Compare the schema the database has with the schema the build expects (S3.14.c).
COMPATIBILITY_FINDING_KINDS enumeration —
CompatibilityFinding interface —
CompatibilityFindingKind type —
compatibilityFindings function Compare what has to be there with what was found (S3.14.d).
CompatibilityReading interface —
CompensationOutcome interface —
compensationPlan function Plan the undo for a cancelled job (S3.9.f).
CompensationPlan interface —
CompensationStep interface —
COMPLETION_FAULT_KINDS enumeration —
CompletionFault interface —
CompletionFaultKind type —
completionFaults function Check progress against the job's state (S3.9.d).
Component interface One gate's row in the aggregate. Every applicable gate has exactly one.
COMPONENT_EFFECTS enumeration What this component DOES to the release, which is not what it found.
ComponentEffect type —
ComponentState type What one gate came out as, in the three vocabularies the kit already has.
composeGuards function Fold guard results into one decision, deterministically.
COMPOSITION_RULES enumeration How this gate combines with others. The AGGREGATION itself is S2.10.
CompositionPolicy interface —
CompositionRule type —
Confidence type —
CONFIDENCE_LEVELS enumeration —
confidenceOf function Decide how much a candidate is to be trusted (S3.12.d).
ConflictDeclaration interface A conflict the signer declared, and what they did about it.
CONFORMANCE_FAULTS enumeration —
ConformanceFault interface —
ConformanceFaultKind type —
conformsToDefinition function Make the catalogue and the running code agree (S2.9).
ConsideredOption interface —
CONSTRAINT_PLACEMENT constant Where each revision constraint belongs, and the two that cannot go in the database at all.
ConstraintPlacement interface —
CONTEXT_FAULT_KINDS enumeration —
contextDrift function Which parts of the stored context differ from where the row actually is.
ContextFault interface —
ContextFaultKind type —
contextFaults function Check a context before it becomes associated data (S3.13.c).
CONTRACT_FAULT_KINDS enumeration —
ContractFault interface —
ContractFaultKind type —
contractFaults function Check a probe contract (S3.14.a).
ContributedGate interface What a plugin actually shipped, in the fields the catalogue also states.
ContributionAuthorization interface —
ContributionMetadata type —
Coverage interface —
COVERAGE_OUTCOMES enumeration How well an index serves a query, worst outcome last.
coverageFor function The best any declared index can do for one query.
CoverageOutcome type —
CRASH_WINDOW_OUTCOMES constant What a crash between publish and mark leaves behind, per order.
Criticality type —
CRITICALITY enumeration Who is waiting for the answer.
criticalPath function The longest chain of declared dependencies (S3.10.g).
CriticalPath interface —
CurrentState interface The world as it is now, in the same terms the reviewer saw it.
cyclesIn function Strongly-connected components of size > 1, plus self-loops: the cycles.
DATABASE_CHECKS enumeration Checks that reach the database. Derived from the permitted set by exclusion.
DATABASE_PROBE_KINDS enumeration The three probes, which answer three different questions.
databaseEnforceable function Constraints an engine can hold on its own.
DatabaseProbeKind type —
DEAD_LETTER_ACTIONS enumeration —
DEAD_LETTER_FAULT_KINDS enumeration —
DEAD_LETTER_REFUSALS enumeration —
DEAD_LETTER_RESOLUTIONS enumeration —
deadEnds function Every stage with no way out, whatever their terminal flag claims.
DeadLetter interface —
DeadLetterAction type —
DeadLetterActionRequest interface —
DeadLetterDecision type —
DeadLetterFault interface —
DeadLetterFaultKind type —
deadLetterFaults function Check a dead-letter record (S3.9.h).
DeadLetterRefusal type —
DeadLetterReplay interface —
DeadLetterResolution type —
decideAccess function Decide one access (S3.2.c).
decideClaim function Decide what a request should get, given whatever record already exists (S3.4.d/e).
decideClaim function Decide what a delivery should do given what is already recorded (S3.7.c).
decideDelivery function Decide what happens after a failed delivery (S3.6.e).
decideIntake function Decide whether an event may be processed at all (S3.7.b).
decideJobClaim function Decide one claim (S3.9.b).
decideJobRetry function Decide what happens after a failed attempt (S3.9.g).
decideOrdering function Decide what to do with an event given where the subject has got to (S3.7.d).
decideReplay function Decide whether a row may be replayed (S3.6.f).
decideResume function Decide how a claimed job continues (S3.9.e).
decideRetry function Whether a failed processing attempt should be tried again (S3.7.f).
decideTransition function Decide whether a boundary transition may happen (S3.2.e).
DECISION_GUARDS enumeration The guards a host registers. Named here so the graph can require them.
DECISION_SCOPES enumeration —
DECISION_TYPES enumeration What KIND of decision this is, which decides who has to be involved.
DECISION_VIOLATION_KINDS enumeration —
DecisionAuthorship interface —
DecisionCommand interface —
DecisionEvidence interface Something the decision rested on, pinned.
decisionFingerprint function A stable fingerprint of everything a decision rested on (S2.2.e / S2.2.f).
decisionGraph function The decision lifecycle as a validated stage graph.
DecisionPolicy interface —
DecisionRecord interface —
DecisionReview type When this decision is looked at again.
DecisionScope type —
DecisionStage type —
DecisionTarget interface Something a decision binds. Typed so an audit can find every decision on it.
DecisionType type —
DecisionViolation interface —
DecisionViolationKind type —
DECLARED_SCOPE_WIDENINGS constant —
DeclaredMetadata interface What the uploader said. Evidence about the uploader.
DECLINED_INDEXES constant The indexes this plan deliberately does not create (S3.5.h).
DeclinedIndex interface An index this plan deliberately does not create, and what pays for it.
DECRYPT_REFUSALS enumeration —
DecryptDecision type —
DecryptRefusal type —
DEFAULT_DECISION_POLICY constant —
defineStages function Register a domain's stages.
DELETION_OUTCOMES enumeration —
DELETION_REFUSALS enumeration —
DELETION_STATES enumeration —
DELETION_TRANSITIONS constant The transitions that exist, and nothing else.
deletionConflict function What to tell somebody whose erasure request cannot be actioned (S3.3.d).
DeletionConflict interface —
DeletionDecision type —
DeletionPlan interface —
DeletionRefusal type —
DeletionState type —
deletionStateFor function Where a blob sits in the S3.3 deletion lifecycle (S3.11.e).
Delivery interface Fold a delivery stream — duplicates, gaps and all — into what a correct consumer would hold.
DELIVERY_DECISIONS enumeration —
DELIVERY_FAILURE_CLASSES enumeration What a delivery failure means for the next attempt.
DELIVERY_FAULT_KINDS enumeration —
DeliveryContext interface —
DeliveryDecision type —
DeliveryFailure interface —
DeliveryFailureClass type —
DeliveryFault interface —
DeliveryFaultKind type —
deliveryIsBlocked function Whether a delivery may proceed given what is currently isolated.
DeliveryOutcome interface —
DeliveryReceipt interface —
DeliverySample interface —
DERIVATIVE_KINDS enumeration —
DerivativeKind type —
Diagnostic interface —
DIGEST_VERIFICATION_SOURCES enumeration What a verification looked at.
DigestVerificationSource type —
Disclosure interface —
DISCLOSURE_FAULT_KINDS enumeration —
DISCLOSURE_FAULT_KINDS enumeration —
DISCLOSURE_KINDS enumeration —
DisclosureFault interface —
DisclosureFault interface —
DisclosureFaultKind type —
DisclosureFaultKind type —
disclosureFaults function Check what a viewer actually received (S2.14.f).
DisclosureKind type —
disclosures function Check that the public body gives nothing away (S3.14.e).
DISTRIBUTION_FAULT_KINDS enumeration —
DistributionFault interface —
DistributionFaultKind type —
distributionFaults function Check the declared distributions against themselves and against the workload.
dryRunManifest function Build the operator preview (S3.12.d).
DryRunManifest interface —
earliestExpiry function The earliest a record may be archived or dropped.
EdgeSet interface The minimum a graph analysis needs, with no domain vocabulary in it.
EDITOR_SURFACES enumeration —
EditorCommand interface One edit a block type supports, in the domain's own vocabulary.
EditorMetadata interface The editor contract, minus the component.
EditorSurface type —
EFFECT_DELIVERIES enumeration How an effect reaches the world outside this system.
EFFECT_KINDS enumeration What a transition will cause OUTSIDE the object's own row.
EffectDelivery type —
EffectInput interface Everything the table needs about one gate, with nothing derived yet.
EffectKind type —
eligibility function Run every eligibility gate (S3.12.c).
ELIGIBILITY_GATES enumeration —
ELIGIBILITY_STRICTNESS constant How alarming each headline is, as a total order.
EligibilityGate type —
EligibilityInput interface —
EMISSION_FAULT_KINDS enumeration —
EmissionFault interface —
EmissionFaultKind type —
emissionFaults function Check that the events a commit carries belong to the mutation it performs.
EMPTY_PROJECTION function —
ENCRYPTION_FAULT_KINDS enumeration —
ENCRYPTION_MODES enumeration —
EncryptionFault interface —
EncryptionFaultKind type —
encryptionFaults function Check the encryption description (S3.11.d).
EncryptionMetadata interface —
EncryptionMode type —
ENFORCEMENT_LAYERS enumeration Where a constraint can actually be enforced.
EnforcementLayer type —
ENTITY_KINDS enumeration The kinds of shared entity the cell asks to be inventoried.
EntityKind type —
EntityRegistration interface —
evaluateGuard function Run a guard with the ambient world taken away.
evaluateQuorum function Whether a set of signatures actually satisfies the requirement (S2.13.a).
EVENT_VIOLATION_KINDS enumeration —
EventContext interface The trace context an event carries.
EventKindOrdering interface Whether an event kind may be applied out of order.
EventSubject interface The aggregate an event is about. Ordering is per subject and nowhere else.
EventViolation interface —
EventViolationKind type —
evidenceFreshness function Whether the evidence behind a result still holds, at an instant (S2.10.a).
EvidenceFreshness type Why a result no longer answers the question.
EvidenceRecord interface One piece of evidence, as the run actually read it.
EvidenceRef interface A piece of evidence a guard consulted, pinned to the version it read.
EvidenceVersionConstraint type An exact version, or a half-open range, for a piece of required evidence.
EXECUTABLE_MEDIA_TYPES enumeration Formats that execute.
ExecutionContext interface —
executionMayProceed function Refuse an execution whose approval does not belong to it.
explainPolicyChange function What a new release policy would have decided about releases already made (S2.10.f).
EXTENSION_POINTS enumeration The seven places a domain plugin may contribute code.
ExtensionPoint type —
EXTERNAL_OUTCOMES enumeration —
ExternalOutcome type —
failedGuards function The guards that did not pass.
FAILURE_EXPECTATIONS constant What each mode must do, and the axis that matters.
FAILURE_MODES enumeration —
FAILURE_POLICIES enumeration What a child's failure does to its parent.
FailureClassification interface —
FailureExpectation interface —
FailureMode type —
failureModeFor function The failure mode an open-failure is an instance of.
FailurePolicy type —
FailureSignals interface What the delivery attempt observed, as facts rather than as a conclusion.
FALSE_POSITIVE_SIGNALS enumeration —
FalsePositive interface —
FalsePositiveSignal type —
FENCE_REFUSALS enumeration —
FencedWrite interface Proof that a write was checked against the store's fence.
FenceInput interface —
FenceOutcome type —
FenceRefusal type —
fenceWrite function Check a lease at the moment of writing (S3.9.c).
FENCING_SOURCES enumeration Where a fencing token may come from.
FencingSource type —
FIELD_OPERATIONS enumeration What somebody has declared they need to DO with the field.
FieldCipher interface The adapter this module is written against.
FieldDerivative interface —
FieldOperation type —
FieldProtection interface —
FINDING_STATES enumeration —
FindingState type —
flattenPlan function Every node of the plan, root first.
foldBatch function Fold one bounded batch (S3.12.f).
foldDeliveries function —
FORBIDDEN_CAPABILITIES enumeration The ambient capabilities a guard may not reach for while it runs.
FORBIDDEN_METRIC_LABELS enumeration Label names that make a probe metric a schema dump, a cardinality bomb, or both.
ForbiddenCapability type —
GATE_AUDIENCES enumeration Who the checked output is FOR, which is not the same as who runs the check.
GATE_DEFINITION_VIOLATION_KINDS enumeration —
GATE_DIMENSIONS constant S3.5.f — the seven things a release console asks about a gate.
GATE_INDEXES constant S3.5.f — gates: triage, the fold’s read, freshness, and comparability.
GATE_REGISTRY_VIOLATION_KINDS enumeration —
GATE_RUN_VIOLATION_KINDS enumeration —
GATE_SEVERITIES enumeration What a non-passing result MEANS for the workflow.
GATE_TYPES enumeration —
GATE_VERDICTS constant The verdict vocabulary, re-exported so a caller need not reach into S1.9.
GateApplicability interface —
GateAudience type —
GateComposition interface —
GateContribution interface —
GateDefinition interface —
GateDefinitionViolation interface —
GateDefinitionViolationKind type —
GateEvaluator interface —
GateFailure interface —
GateFinding interface —
GateInput interface —
GateLifecycle type Whether the gate is on, watching, or gone.
GateMeasurement interface —
GateMetadata interface —
GateObservation type What the evaluator SAW, which is not what it concluded.
GateOutcome type —
GateOwnership interface Five roles, because in practice they are five different teams.
GatePolicy interface —
GatePolicyReference interface —
GatePresentation interface —
GateProvenance interface Where a measurement came from, in enough detail to reproduce or distrust it.
GateRegistryViolation interface —
GateRegistryViolationKind type —
GateResult interface —
GateRunAggregate interface —
GateRunProvenance interface —
GateRunResult interface —
GateRunViolation interface —
GateRunViolationKind type —
GateSeverity type —
GateStatusRow interface —
GateType type —
gateVerdict function Turn an evaluator outcome into a verdict, applying the kit's own rules first.
GateVerdict interface —
GRAPH_FAULT_KINDS enumeration —
graphDepth function Longest path from the root over parent/child edges. 1 for the root alone.
graphFanOut function The most children any one parent has.
GraphFault interface —
GraphFaultKind type —
graphFaults function Check a graph (S3.10.b).
GraphOptions interface —
GraphRetryPlan interface —
graphView function Build the screen an operator opens during an incident (S3.10.g).
GraphView interface —
GraphViewNode interface —
Guard interface —
GUARD_REMEDIATIONS enumeration What a caller should do about it.
GUARD_STATUSES enumeration The seven answers, and why there are seven rather than two.
GuardAnswer interface What a guard hands back; the harness adds the provenance around it.
GuardDecision interface —
GuardInput interface Everything a guard is allowed to know.
GuardOutcome type A guard's answer.
GuardPurityError class —
GuardRemediation type —
GuardResult interface —
GuardStatus type —
GuardVerdict type A guard's answer about one attempted transition.
HEARTBEAT_FAULT_KINDS enumeration —
HeartbeatFault interface —
HeartbeatFaultKind type —
heartbeatFaults function Check the cadence itself (S3.9.c).
HeartbeatPolicy interface —
HOLD_VIOLATION_KINDS enumeration —
holdApplies function Whether a hold covers this subject, at this instant.
HoldViolation interface —
HoldViolationKind type —
HostIsolation interface —
HumanGateRequirement interface —
HumanPresence interface A presence that survived every check. Only produces one.
IDEMPOTENCY_STATES enumeration —
IdempotencyRecord interface —
IdempotencyScope interface Everything the uniqueness constraint is over.
IdempotencyState type —
IDENTIFIER_INDEXES constant S3.5.g — identifiers: exact, unique, and scoped by the system that issued them.
identifierFaults function Identifier lookups, checked apart from everything else (S3.5.g).
IdentifierLookup interface An identifier and what it is unique with respect to.
Importer interface —
ImporterContribution interface —
ImporterMetadata interface —
ImportExecution interface —
ImportPlan interface —
ImportValidation interface —
InboxClaim type —
inboxKey function The receipt's key as a single string.
InboxKey interface What one consumer's receipt is unique over.
InboxParityFault interface —
InboxParityFaultKind type —
InboxReceipt interface —
InboxRetryDecision interface —
INDEPENDENCE_DIMENSIONS enumeration What the reviewers must be independent OF.
IndependenceDimension type —
INDEX_BUDGET constant —
INDEX_FAULT_KINDS enumeration —
IndexColumn interface —
IndexDeclaration interface —
IndexFault interface —
IndexFaultKind type —
indexFaults function Every static complaint the index plan admits, in one pass.
IndexPlanInput interface —
Ingredient interface An input this blob was made from — by reference and digest, never a copy.
INHERITANCE_FAULT_KINDS enumeration —
InheritanceFault interface —
InheritanceFaultKind type —
inheritanceFaults function Check that every child row sits where its parent does (S3.2.d).
InspectorField interface —
INTAKE_REFUSALS enumeration —
IntakeDecision type —
IntakeRefusal type —
IntakeRequest interface —
INTROSPECTION_CHECKS enumeration Checks that read the catalogue.
isEligible function —
isLabelKey function —
isLegalTransition function Whether an edge exists at all, for a caller deciding whether it needs a bypass.
ISOLATION_SCOPES enumeration —
ISOLATION_SURFACES enumeration —
IsolationDecision interface —
isolationFor function How much of the stream one poisoned event stops (S3.8.c).
IsolationRequest interface —
IsolationScope type —
IsolationSurface type —
isRequired function Whether the parent's success depends on this child's.
isSealedField function Whether a value is a sealed envelope, structurally. Never a guess at a string.
isTerminalJobState function —
JOB_CLAIM_REFUSALS enumeration —
JOB_CREATION_FAULT_KINDS enumeration —
JOB_FAILURE_KINDS enumeration Why an attempt ended.
JOB_RETRY_DECISIONS enumeration —
JOB_STATES enumeration The states a job row may be in.
jobBackoffSeconds function Exponential backoff with proportional jitter (S3.9.g).
JobBudget interface What a job is allowed to spend, in a unit it names.
JobCheckpoint interface —
JobClaimDecision type —
JobClaimRefusal type —
JobClaimRequest interface —
JobCreationFault interface —
JobCreationFaultKind type —
jobCreationFaults function Check a job at creation (S3.9.a).
JobEdge interface —
JobFailure interface —
JobFailureKind type —
JobGraph interface —
JobGraphNode interface —
JobLease interface —
jobProgress function Fold the stages into one number (S3.9.d).
JobProgress interface —
JobRecord interface —
JobRetryContext interface —
JobRetryDecision interface —
JobRetryDecisionKind type —
JobRetryPolicy interface —
JobState type —
judgePlan function Judge one captured plan against the query it was captured for.
KEY_DESIGN_FAULT_KINDS enumeration —
KEY_FAULT_KINDS enumeration —
KEY_MATERIAL_LOCATIONS enumeration Where the key material lives.
KEY_TIERS enumeration The three tiers, ordered.
KeyDescriptor interface —
KeyDesignFault interface —
KeyDesignFaultKind type —
keyDesignFaults function Check the key hierarchy (S3.13.b).
KeyFault interface —
KeyFaultKind type —
KeyMaterialLocation type —
KeyTier type —
KIT_VERSION constant The kit version this module belongs to.
KNOWN_WORKLOAD_LIMITATIONS constant —
KnownLimitation interface The static faults this plan is known to produce, with the reason each one cannot be indexed away.
lease function The row as it looks once claimed.
leaseReclaimableAt function The earliest a reconciler may take the lease away. Later than the worker gives it up.
LEDGER_OUTCOME_TO_VERDICT constant The cell's wording, mapped onto the verdicts the kit already has.
LegalHoldRecord interface —
LIFECYCLE_INDEXES constant S3.5.b — the stage and status access paths.
LINEAGE_HARM_KINDS enumeration —
LineageHarm interface —
LineageHarmKind type —
LIVENESS_PERMITTED_CHECKS enumeration What liveness is allowed to look at. Two things, neither of them remote.
locatorKey function —
MARK_REFUSALS enumeration —
markCandidate function Mark a candidate for reclamation (S3.12.e).
MarkOutcome type —
markPublished function Mark a row published. Unreachable without a receipt, by construction.
MarkRefusal type —
MATRIX_BEHAVIOUR_FAULTS enumeration —
MATRIX_FAULT_KINDS enumeration —
MatrixBehaviourFault type —
MatrixFault interface —
MatrixFaultKind type —
matrixFaults function Check the field protection matrix (S3.13.a).
MAX_INLINE_PAYLOAD_BYTES constant The largest body that may travel in the row itself.
measurementIsFresh function Whether a measurement is still inside its own freshness window.
METRIC_FAULT_KINDS enumeration —
MetricFault interface —
MetricFaultKind type —
metricFaults function Check a probe metric (S3.14.g).
MIGRATION_PHASES enumeration The phases, in the only order that keeps a rollback possible.
MIGRATION_REFUSALS enumeration —
MigrationDecision type —
MigrationPhase type —
MigrationRefusal type —
MigrationState interface —
missingRetention function A record with no retention at all, which the type cannot prevent.
NON_PASSING_VERDICTS enumeration The verdicts a MISSING or STALE measurement may become.
NON_VERDICT_STATUSES enumeration The statuses that are NOT a decision about the subject.
NoncancellableRegion interface —
NonPassingVerdict type —
NonvisualAlternative interface The non-visual path, which is REQUIRED rather than a courtesy.
ObjectObservation interface —
ObjectRequirement interface —
OBSERVATION_RESULTS enumeration —
ObservationResult type —
ObservedFailure interface —
ObservedMetadata interface What the server measured. Evidence about the bytes.
ObservedSchema interface —
OPEN_FAILURES enumeration —
OpenFailure type —
openField function Open a sealed field (S3.13.c).
OpenRequest interface —
OpenResult type There is no successful result that carries nothing.
Operation type —
OPERATIONS enumeration —
OPERATOR_ACTIONS enumeration —
OperatorAction type —
OPTION_STATUSES enumeration —
OptionStatus type —
ORDERING_DISPOSITIONS enumeration —
OrderingDecision interface —
OrderingDisposition type —
OrderingRequest interface —
ORPHAN_ACTIONS enumeration What may be done about an orphan.
ORPHAN_CLASSES enumeration —
ORPHAN_REPAIRS enumeration —
OrphanAction type —
OrphanClass type —
OrphanDecision interface —
OrphanInput interface —
OrphanObservation interface —
OrphanRepair type —
orphanSweep function Reconcile a set of jobs, newest lease last. Deterministic order for a repair log.
OrphanVerdict interface —
OUTBOX_RETENTION_ACTIONS enumeration —
OUTBOX_RETENTION_FAULT_KINDS enumeration —
OUTBOX_STATES enumeration Where an outbox row is in its life.
OutboxIntent interface What a producer declares it is about to do.
OutboxLease interface —
outboxRetentionAction function What to do with one row now.
OutboxRetentionAction type —
OutboxRetentionFault interface —
OutboxRetentionFaultKind type —
outboxRetentionFaults function —
OutboxRetentionRule interface How long a dispatched row and its body are kept.
OutboxRow interface —
OutboxState type —
OWNERSHIP_CLASSES enumeration Six classes, and each one answers a different question about a query.
OWNERSHIP_DIMENSIONS constant S3.5.c — the six ways a workbench asks "whose is this?".
OWNERSHIP_INDEXES constant S3.5.c — ownership: assignee, team, and the queue defined by having neither.
OwnershipClass type —
PAGINATION_MODES enumeration How the query walks a result set.
PaginationMode type —
PARENT_OUTCOMES enumeration What a parent may be.
parentOutcome function Fold the children into the parent (S3.10.e).
ParentOutcome type —
ParentVerdict interface —
PARITY_FAULT_KINDS enumeration —
PARITY_FAULT_KINDS enumeration —
ParityFault interface —
ParityFaultKind type —
parityFaults function Compare a rebuilt projection against the one that was maintained (S2.14.e).
parseExplainPlan function Read a Postgres EXPLAIN (FORMAT JSON) tree into the shape the gate judges.
parsePluginDescriptor function —
parseSchemaRange function —
parseSemanticRange function —
partitionKeyFor function The partition an event is published on.
PAYLOAD_ACCESS enumeration —
PayloadAccess type —
PayloadRef type How the event body is carried.
PLAINTEXT_RESIDUES enumeration Where the plaintext still is after DROP COLUMN.
PlaintextResidue type —
plan function Decide whether a declared transition may be applied, and return the write.
PLAN_FAULT_KINDS enumeration —
planBypass function Move an object across an edge the graph does not have (S2.1.f).
planDeadLetterReplay function Requeue a dead-lettered job (S3.9.h).
planDecisionTransition function Move a decision to its next stage.
planDeletion function Decide whether a marked candidate may still be deleted (S3.12.e).
PlanFault interface —
PlanFaultKind type —
planGraphRetry function Decide what a graph retry re-runs and what it reuses (S3.10.f).
PlanJudgement interface —
PlanJudgementInput interface —
PlannedOperation interface —
PlannedTransition interface The write the caller's persistence layer performs, under this revision.
PlanNode interface One node of a query plan, normalized out of whatever the engine emitted.
planRenewal function Ask for a signoff to carry forward, and be told no (S2.13.f).
planReplay function Build the replay (S3.8.f).
planStageCommit function Pair an effect with its checkpoint (S3.9.e).
planTransition function Decide one transition (S3.3.a/b).
PLUGIN_VIOLATION_KINDS enumeration —
PluginDescriptor interface —
PluginValidationOptions interface —
PluginViolation interface —
PluginViolationKind type —
POISON_CONDITIONS enumeration —
PoisonCondition type —
PolicyChangeCase interface —
PolicyChangeReport interface —
PolicyChangeRow interface —
PolicyDecision type What a domain policy returns when it is given a fresh measurement.
PREDICATE_KINDS enumeration How a predicate constrains a column, which decides what a b-tree can do with it.
PredicateKind type —
PRESENCE_DISCLOSING_CLASSES enumeration Classes where the fact that a row EXISTS is itself the disclosure.
PresenceClaim interface Evidence that a person was present, as the identity layer reported it.
PresentedAggregate interface —
PresentedComponent interface How one gate was actually shown to a person.
PresentedWaiver interface One waiver, as a surface actually rendered it. Null means the field is absent.
Principal type —
PRINCIPALS enumeration —
PRIORITY_BAND constant The declared priority band.
PrivilegedBypass interface The explicit way around the graph (S2.1.f).
PROBE_CHECKS enumeration —
PROBE_CODES constant —
PROBE_METHOD_FAULT_KINDS enumeration —
ProbeCheck type —
ProbeContract interface —
ProbeMethodFault interface —
ProbeMethodFaultKind type —
probeMethodFaults function Check how a capability probe proves what it claims (S3.14.b).
ProbeMetric interface —
ProbeReport interface —
ProcessingFailure interface —
ProcessingOutcome interface —
PROGRESS_FAULT_KINDS enumeration —
ProgressFault interface —
ProgressFaultKind type —
progressFaults function Check one progress report against the last one (S3.9.d).
ProjectionContribution interface —
ProjectionMetadata interface —
ProjectionSnapshot interface —
ProjectionState type The state a projection is in.
propagateCancellation function Plan a graph cancellation (S3.10.f).
ProtectedQuery interface —
PROTECTION_STRATEGIES enumeration —
ProtectionContext interface Everything a sealed value is bound to.
ProtectionStrategy type —
PROVENANCE_FAULT_KINDS enumeration —
ProvenanceFault interface —
ProvenanceFaultKind type —
provenanceFaults function Check a provenance manifest (S3.11.f).
ProvenanceManifest interface —
ProvenanceSource interface —
publicProbeView function Build the public body (S3.14.e).
PublicProbeView interface The body an unauthenticated caller receives.
PublisherContribution type —
PublisherMetadata type Reversibility, as a discriminated pair rather than two loose fields.
PublisherRuntime interface —
PublishPlan interface —
PublishReceipt interface —
PublishVerification interface —
PURGE_REFUSAL_KINDS enumeration —
PURGE_STEPS enumeration The order a purge runs in, leaves first.
PurgeExecutor type What a purge is handed. Each step reports for itself; none of them is trusted.
PurgeRefusal interface —
PurgeRefusalKind type —
purgeRefusals function Blob-specific reasons a purge is refused (S3.11.e).
PurgeRun interface —
PurgeStep type —
PurgeTombstone interface The proof that a thing existed and was deleted, carrying none of it.
QuarantineAlert interface —
QuarantineAlertKind type —
quarantineAlerts function —
quarantineHealth function Measure the quarantine (S3.8.g).
QuarantineHealth interface —
QuarantineRecord interface —
QUERY_FAULT_KINDS enumeration —
QUERY_OPERATORS enumeration —
QueryFault interface —
QueryFaultKind type —
queryFaults function Check a query against the matrix (S3.13.c).
QueryOperator type —
QueryPredicate interface —
QueryShape interface A query as the checker sees it: what it reads and what it filtered on.
queueHealth function Measure the queue (S3.6.f).
QueueHealth interface —
QUORUM_FAULT_KINDS enumeration —
QuorumFault interface —
QuorumFaultKind type —
QuorumOutcome interface —
REACHABLE_DELETION_STATES enumeration Every deletion state this module can produce, for the S3.3 machine to accept.
readinessDecision function Decide readiness per capability (S3.14.f).
readinessState function The readiness answer as a S1.6 capability state (S3.14.f).
readyChildren function Decide which children may start (S3.10.c).
REBINDABLE_DIMENSIONS enumeration The dimensions an approver may declare a change to as survivable.
RebindableDimension type —
RECEIPT_STATES enumeration —
ReceiptState type —
receiveAck function Turn a broker acknowledgement into the receipt markPublished requires.
reclaimable function Rows whose holder is gone.
ReclamationCandidate interface —
ReclamationFinding interface —
ReclamationToken interface Permission to delete one blob, valid only while nothing has referenced it.
RECOMPUTE_TRIGGERS enumeration —
RecomputeTrigger type —
reconcileOrphan function Decide the repair for a job whose worker is gone (S3.9.i).
reconcileSweep function Reconcile a sweep against what happened afterwards (S3.12.g).
Reconciliation interface —
ReconciliationDrift interface —
ReconciliationReport interface —
RECORD_FAULT_KINDS enumeration —
RECORD_VIOLATION_KINDS enumeration —
RecordFault interface —
RecordFaultKind type —
recordFaults function Check a quarantine record (S3.8.b).
RecordViolation interface —
RecordViolationKind type —
RedactedView type Nothing at all, for a viewer who may not know the object exists.
redactFor function Narrow a projection to what this viewer may see (S2.14.f).
REDACTION_FAULT_KINDS enumeration —
REDACTION_SURFACES enumeration The nine places a protected value gets out.
REDACTION_TOKEN constant The one permitted replacement (S3.13.e).
RedactionFault interface —
RedactionFaultKind type —
redactionFaults function Scan every surface for values that should not be on it (S3.13.e).
RedactionSurface type —
redundantIndexes function Indexes made redundant by a wider one.
REFERENCE_FAULT_KINDS enumeration —
REFERENCE_SOURCES enumeration The places a reference to a blob can live.
referencedBlobIds function Every blob id any source refers to. The union, never an intersection.
ReferenceFault interface —
ReferenceFaultKind type —
referenceFaults function Check a vault reference (S3.13.d).
ReferenceRegister interface —
ReferenceSource type —
ReferenceSourceScan interface —
REFUSAL_REASONS enumeration —
RefusalReason type —
REGION_FAULT_KINDS enumeration —
RegionFault interface —
RegionFaultKind type —
regionFaults function Check a noncancellable region (S3.9.f).
REGISTER_FAULT_KINDS enumeration —
REGISTER_VIOLATION_KINDS enumeration —
RegisteredPlugin interface —
RegisterFault interface —
RegisterFaultKind type —
registerFaults function Check that the register can be relied on (S3.12.a).
RegisterViolation interface —
RegisterViolationKind type —
releasable function Sequences that can now be applied, in order, after appliedThrough moved.
RELEASE_ELIGIBILITIES enumeration The headline, and the reason there are six of them.
ReleaseEligibility type —
RemovalEvidence interface —
renderIndexDdl function The CREATE INDEX statement for a declaration.
RENEWAL_FINDING_KINDS enumeration —
RENEWAL_REFUSALS enumeration —
renewalChain function Walk a renewal chain and add the instalments up (S2.11.c).
RenewalChain interface —
renewalDueAt function When the holder should send the next beat.
RenewalFinding interface —
RenewalFindingKind type —
RenewalOutcome type —
RenewalRefusal type —
replay function Fold an event stream into a projection (S2.14.c/d).
REPLAY_GUARDS enumeration —
REPLAY_REFUSALS enumeration —
ReplayDecision type —
ReplayGuard type —
ReplayGuardInput interface —
ReplayGuardResult interface —
replayGuards function Run every pre-replay guard (S3.8.e).
ReplayOutcome interface —
replayParityFaults function Compare a replayed projection with the stored one, FIELD BY FIELD (S3.7.g).
ReplayPlan interface —
ReplayRefusal type —
ReplayRequest interface —
ReplayRequestInput interface —
requestCancel function Answer a cancel request (S3.9.f).
RequiredEvidence interface What a gate cannot answer without.
requiredIndexPrefix function The columns an index on this entity must start with, derived from the ownership class S3.2 assigned.
REQUIREMENT_FAULT_KINDS enumeration —
REQUIREMENT_KINDS enumeration —
REQUIREMENT_VIOLATION_KINDS enumeration —
RequirementFault interface —
RequirementFaultKind type —
requirementFaults function Check what the build is asking for (S3.14.c).
RequirementKind type —
RequirementViolation interface —
RequirementViolationKind type —
residualPlaintext function The residues that are still holding plaintext, given what has been done.
Residue interface —
RESIDUE_KINDS enumeration —
residueIn function Look for content that survived a purge (S3.3.g).
ResidueKind type —
RESOLUTION_CAPABILITY constant —
RESOLUTION_REFUSALS enumeration —
ResolutionDecision type —
ResolutionRefusal type —
ResolutionRequest interface —
resolveEffect function The whole truth table, as one function (S2.10.c).
resolveInForce function —
resolveRetention function Combine every retention rule that applies (S3.3.c).
RESTORE_FAULT_KINDS enumeration —
RestoreFault interface —
RestoreFaultKind type —
restoreFaults function Check a restore (S3.13.g).
RestorePlan interface —
RESUME_DECISIONS enumeration —
ResumeDecision interface —
ResumeDecisionKind type —
ResumeInput interface —
RETENTION_FAULT_KINDS enumeration —
RETENTION_SOURCES enumeration —
RetentionFault interface —
RetentionFaultKind type —
retentionFaults function Check that a record lives long enough to do its job (S3.4.f).
RetentionPolicy interface —
RetentionResolution type —
RetentionRule interface —
RetentionSource type —
RetryPolicy interface —
RetryTarget interface —
REUSE_DECISIONS enumeration —
ReuseDecision type —
Reversal type —
REVERSIBLE_STRATEGIES enumeration Strategies that leave the value recoverable by whoever holds the key.
ReviewedState interface Exactly what the person looked at.
REVISION_CONSTRAINTS enumeration The constraints a revision table must carry, as a declared list.
RevisionConstraint type —
revisionHoldMarker function The marker S2.4 puts on a revision, derived from the record here.
REVOCATION_EFFECTS enumeration What has to happen when a key at a given tier is replaced or withdrawn.
RevocationEffect type —
revocationPlan function —
RevocationPlan interface —
rootBlockers function The children actually holding the graph up (S3.10.g).
ROW_FAULT_KINDS enumeration —
RowFault interface —
RowFaultKind type —
rowFaults function Check one row against the shape S3.6.a requires.
runPurge function Run a purge (S3.3.e/f).
RunTrigger type Who or what caused the run.
SAFE_WRITE_PROBE_METHODS enumeration —
safeDetailIsUsable function Whether a report's own free text is safe to render. Borrowed from S1.6.
SchedulingDecision interface —
SchedulingRequest interface —
SCHEMA_STATE_POLICY constant What each schema state means for each capability.
SCHEMA_STATES enumeration —
SchemaRange interface The wire schema range, which is an INTEGER range and not a semantic one.
schemaRangeAdmits function —
SchemaRequirement interface —
SchemaState type —
SchemaVerdict interface —
SCOPE_FAULT_KINDS enumeration —
SCOPE_VIOLATION_KINDS enumeration —
ScopedRow interface A row as the checker sees it: an identity plus the scope it claims.
ScopeFault interface —
ScopeFaultKind type —
scopeFaults function Check that a query carries the predicates its entity requires (S3.2.f).
scopeKey function The value a unique index is built over. Stable, ordered, total, and injective.
ScopeViolation interface —
ScopeViolationKind type —
scopeWidening function What the proposal now covers that the reviewer was not shown.
ScopeWidening interface Queries whose scope predicates are narrower than the entity's ownership class implies, and what authorizes each one.
SEAL_REFUSALS enumeration —
SEALED_FIELD_SCHEMA_VERSION constant —
SealedField interface A sealed field, as it sits in a column.
sealField function Seal a value before it is persisted (S3.13.c).
SealRefusal type —
SealRequest interface —
SealResult type —
SecretLease interface —
SecretUsage interface —
selectBatch function Select a batch, as the query would.
SelectionContract interface What a projection can be handed.
SEMANTIC_NODE_KINDS enumeration The semantic vocabulary a block renders into.
SemanticNode interface —
SemanticNodeKind type —
SemanticRange interface A half-open version range: >= minimum, < below.
semanticRangeAdmits function —
SENSITIVITY_CLASSES enumeration Why a field is protected.
SensitivityClass type —
SERVE_DECISIONS enumeration —
SERVED_CAPABILITIES enumeration What a process may be asked to do.
ServedCapability type —
ServeDecision type —
severityAt function The severity that applies at one stage.
SHARED_ENTITY_REGISTER constant The shared entity register this kit ships (S3.2.a).
SHARED_IDENTIFIER_LOOKUPS constant The identifier lookups whose uniqueness identifierFaults checks (S3.5.g).
SHARED_INDEX_PLAN constant Every index the shared platform declares.
SHARED_VOLUME_PROFILES constant The distributions the shared workload is measured against (S3.5.a).
SHARED_WORKLOAD constant Every access path the shared platform's own entities carry.
SHRED_REFUSALS enumeration —
ShredDecision type —
ShredRefusal type —
SIGNOFF_DECISIONS enumeration —
SIGNOFF_ORDERS enumeration Whether the signatures may be collected at once or have to be ordered.
SIGNOFF_STANDINGS enumeration —
SignoffDecision type —
SignoffOrder type —
SignoffRecord interface —
SignoffRow interface —
SignoffScope type Who may sign: a named person, or anyone from a declared pool.
SignoffStanding type —
signoffStatus function Whether a signature still covers what is in front of you (S2.13.e).
SignoffStatus interface —
SILENT_WHEN_ABSENT enumeration The kinds whose ABSENCE is silent.
sniffMediaType function Decide what the bytes are (S3.11.b).
SniffResult interface —
SORT_DIRECTIONS enumeration —
SortDirection type —
sortIsTotal function Whether the query's ordering is total — that is, whether two runs of it must return the same rows in the same order.
SortKey interface —
SPOOF_FAULT_KINDS enumeration —
SpoofFault interface —
SpoofFaultKind type —
spoofFaults function Compare what was claimed against what was found (S3.11.b).
STAGE_VIOLATION_KINDS enumeration —
StageCommit interface —
StageDefinition interface One stage in a domain's own workflow.
StageEffect interface —
StageGraph interface —
StageModel interface —
StageModelContribution interface —
StageModelMetadata interface —
StageProgress interface —
StageResult type —
StageSeverity interface —
StageSpec interface One stage, as its owning domain defines it.
StageTransition interface —
StageUniverse interface —
StageViolation interface —
StageViolationKind type —
Staleness type —
STALENESS enumeration —
stalenessOf function Whether a derived blob still describes its ancestors (S3.11.f).
StalenessVerdict interface —
STEP_UP_METHODS enumeration —
STEP_UP_WINDOW_MINUTES constant How long a step-up stands for the decision it was performed for.
StepOutcome interface —
StepUpMethod type —
StorageLocator interface Where the bytes are.
strategiesFor function The strategies that could serve a declared set of operations, strongest first.
STRATEGY_CAPABILITIES constant What each strategy can actually support.
STRATEGY_FAULT_KINDS enumeration —
StrategyFaultKind type —
StrategyMember interface What a plugin strategy is handed. Frozen; see .
subjectKey function —
supersede function Produce the two records a supersession consists of.
supersedes function The link a NEW signature carries to say what it replaces.
supersessionHarms function Check that a supersession replaced rather than rewrote (S2.7.f).
SupersessionOutcome type —
SUPPORT_LEVELS enumeration —
SupportLevel type —
supportsKit function —
supportsSchema function —
SURFACE_EVENTS constant A decision surface the platform has, and the event kind that records it.
SurfaceSample interface —
SWEEPABLE_BLOB_STATES enumeration Blob states a sweep may act on at all. Anything else needs a person.
TargetPredicate interface A condition over facts the RUN recorded, not a closure.
TAXONOMY_DIMENSIONS constant S3.5.e — the taxonomy queries a workbench supports.
TAXONOMY_INDEXES constant S3.5.e — taxonomy: both directions of the join, the path, and the alias.
TEMPORAL_DIMENSIONS constant S3.5.d — the eight kinds of time, and which of them the kit owns a column for.
TEMPORAL_INDEXES constant S3.5.d — time, each one ending in the identifier that makes the order total.
TERMINAL_JOB_STATES enumeration —
TERMINAL_OUTBOX_STATES enumeration States a row never leaves.
TERMINAL_STATES enumeration Once here, there is nothing to transition to.
TimelineEntry interface —
toSnakeCase function camelCase to snake_case, which is the column spelling in DDL.
toWaiverRecord function The record S2.10's fold reads, for an authorizing waiver only.
TransactionalStore interface —
TransactionHandle interface —
Transformation interface —
TRANSFORMATION_KINDS enumeration —
TransformationKind type —
Transition interface —
TRANSITION_REFUSALS enumeration —
TRANSITION_REFUSALS enumeration —
TransitionCommand interface The only shape that can move an object along a declared edge.
transitionDecision function Fold guard answers into one decision, fail-closed and in a stable order.
TransitionDecision type —
TransitionGuard interface —
TransitionInput interface What a guard was asked about.
TransitionOutcome type —
TransitionOutcome type —
TransitionRefusal type —
TransitionRefusal type —
TransitionRequest interface —
TransitionRequest interface —
Trigger type —
TRIGGERS enumeration What causes a transition to be attempted.
Trivalent type —
trivalentOf function The trivalent a state contributes.
TRIVALENTS enumeration Kleene's third value, and the reason any-of over a gap is not a refusal.
UNAUTHORIZED_READER_SURFACES enumeration The surfaces a reader outside the row's own authorization can see.
UNAVAILABLE_BEHAVIOURS enumeration What happens when the evidence is not there.
UnavailableBehaviour type —
uncoveredSurfaces function Decision surfaces with no event kind behind them (S2.14.a).
unexpectedFaults function The faults that are not declared limitations.
unintendedCycles function Cycles nobody declared.
unreachableFrom function Stages no sequence of edges reaches from the initial one.
UNREADABLE_BLOB_STATES enumeration A blob nothing may read yet.
unscannedSurfaces function Surfaces no sample covered. A scan is a claim about what it looked at.
unservedDimensions function Dimensions naming an index that is not in the plan.
UNSUPPORTABLE_OPERATIONS enumeration The operations no protection strategy supports, at all.
USAGE_FAULT_KINDS enumeration —
UsageFault interface —
UsageFaultKind type —
usageFaults function Check what a caller did with a lease (S3.13.d).
validateAggregatePolicy function Check a release policy (S2.10.d/f).
validateAuditEvent function Check one recorded event (S2.14.b).
validateBinding function —
validateBlockContribution function S1.9.d — the migration chain, which is where an old document goes to die.
validateDecision function Check a decision record against everything it claims to be (S2.7.a–d).
validateGateDefinition function Check a gate definition (S2.9.a–f).
validateGateRegistry function Check a whole catalogue, which is where the cross-gate faults live.
validateGateRunResult function Check a recorded run against the definition it claims to answer (S2.10.a/b).
validateHold function Check a hold (S3.3.d).
validateHumanGate function Check what a human gate asks for (S2.13.a).
validateKey function —
validatePlugins function The set-level check.
validateProjectionContribution function S1.9.e — isolation, authorization and the required non-visual path.
validateRegister function Check an entity register (S3.2.a/b).
validateScope function Check the scope a record is keyed by (S3.4.c).
validateSignoff function Check one signature (S2.13.d).
validateStageModel function S1.9.b — the stage model, checked without any opinion about stage NAMES.
validateWaiverGrant function Check a grant against the request it answers and the gate it waives (S2.11.a–c).
VaultReference interface —
VerdictName type —
VERDICTS enumeration —
VERIFICATION_OUTCOMES enumeration —
VERIFICATION_SOURCES enumeration —
VerificationInput interface —
verificationIsIndependent function Refuse a verification that could not have observed anything.
verificationIsStale function Whether a recorded verification is old enough to be worth repeating.
VerificationOutcome interface —
VerificationOutcomeKind type —
VerificationSource type How a publish was confirmed.
verifyDigest function Judge one verification (S3.11.c).
VISIBILITY_FAULT_KINDS enumeration —
VisibilityFault interface —
VisibilityFaultKind type —
visibilityFaults function Catch a surface that lost a component on the way to the screen (S2.10.e).
VOLUME_CEILINGS constant The upper bound of each class, in rows.
VOLUME_CLASSES enumeration How big a table gets, as four named classes rather than a number.
VolumeClass type —
VolumeProfile interface The row distribution a query will actually meet.
WAIVER_RISK_LEVELS enumeration How bad it is if the waived failure turns out to be real.
WAIVER_STATUSES enumeration —
WAIVER_VIOLATION_KINDS enumeration —
WaiverBinding interface —
waiverDisclosureFaults function Check that a surface said what a person needs in order to disagree (S2.11.e).
WaiverEvidence interface —
WaiverGrant interface —
WaiverPolicy interface —
WaiverRecord interface A grant, as the aggregate reads it.
WaiverRequest interface —
WaiverRevocation interface —
WaiverRiskLevel type —
WaiverScope interface Where the exception applies.
WaiverSituation interface The run and the world, as they are when the waiver is being read.
waiverStanding function Read a grant against the moment and the situation (S2.11.c/d/f).
WaiverStanding interface What the waiver is, right now, and everything it still carries.
WaiverStatus type —
WaiverValidity type How long it lasts, and whether it lasts at all after being used.
WaiverViolation interface —
WaiverViolationKind type —
WEAK_STEP_UP_METHODS enumeration Methods that do not count as a step-up however a policy is written.
WorkbenchPlugin interface What a plugin is, from the host's side.
workerHoldsLease function Whether the WORKER may still consider itself the holder.
WorkloadQuery interface —
WRITE_BLOCKING_STATES enumeration States a SELECT 1 succeeds straight through.
WRITE_CLASSES enumeration How hard the table is written, which is what an index costs.
WRITE_PROBE_METHODS enumeration How a write probe proves the database will accept a write.
WriteBlockingState type —
WriteClass type —
WriteProbeMethod type —

Shapes#

ACCESS_DENIALS#

Values: different-tenant, different-workspace, support-may-not-write, support-without-a-live-grant, operator-may-not-read-tenant-content, service-without-a-capability, reviewer-may-not-write-content, contributor-may-not-administer, immutable-stage-rows-are-not-editable, append-only-rows-are-not-editable

AccessDecision#

ts
| { readonly allowed: true }
| { readonly allowed: false; readonly denial: AccessDenial; readonly detail: string }

AccessDenial#

ts
(typeof ACCESS_DENIALS)[number];

AccessDimension#

One dimension a workbench is filtered or sorted by, and where it is answered.

Field Type Required Notes
dimension string required The ledger's word for it.
column string | null required The column it is, or null when it is not a column on any shared entity.
servedBy string | null required —
note string required —

AccessRequest#

Field Type Required Notes
principal Principal required —
operation Operation required —
entity EntityRegistration required —
stageIsImmutable boolean required Whether the DOMAIN declared the row's current stage one that may not be edited in place.
sameTenant boolean required —
sameWorkspace boolean required —
capability string | null required Only meaningful for service: the capability its token names.
supportGrantLive boolean required Only meaningful for support: whether a time-boxed grant is live.

ACTION_REFUSALS#

Values: not-authorized, raw-payload-needs-a-named-reader, already-resolved, transform-without-a-recorded-original, skip-without-a-reason, suppress-is-not-a-skip, replay-not-revalidated

ActionDecision#

ts
| { readonly allowed: true; readonly note: string }
| { readonly allowed: false; readonly refusal: ActionRefusal; readonly detail: string }

ActionRefusal#

ts
(typeof ACTION_REFUSALS)[number];

ActionRequest#

Field Type Required Notes
action OperatorAction required —
record QuarantineRecord required —
capabilities readonly string[] required Capabilities the acting principal holds.
reason string | null required For skip: why this event is being abandoned.
suppressionScope 'event' | 'kind' | 'producer' | null required For suppress: the class it applies to. A suppression of one event is a skip.
originalRetained boolean required For transform: whether the untouched original is retained beside the new body.
revalidated boolean required For replay: whether the S3.8.e guards have been run and passed.

ActivatedPlugin#

Field Type Required Notes
contributionIds readonly string[] required —
deactivate () => void required —

ActivationContext#

Field Type Required Notes
kitVersion SemanticVersion required —
schemaVersion number required —
tenant TenantId | null — TenantId required —
configuration TConfig required Settings the deployment actually provides, by name.
providedSettings readonly string[] required —
loadedPlugins readonly string[] required Plugin ids the host has already loaded.
knownCapabilities readonly CapabilityId[] — CapabilityId required Capabilities the host's registry knows about.

ActivationOutcome#

ts
| { readonly outcome: 'activated'; readonly activated: ActivatedPlugin }
| { readonly outcome: 'refused'; readonly violations: readonly PluginViolation[] }
| { readonly outcome: 'not-configured'; readonly missingSettings: readonly string[]; readonly reason: string; }

ADAPTER_FAULT_KINDS#

Values: size-disagrees-with-read, digest-differs-across-adapters, locator-not-returned, version-not-recorded

AdapterFault#

Field Type Required Notes
kind AdapterFaultKind required —
subject string required —
detail string required —

AdapterFaultKind#

ts
(typeof ADAPTER_FAULT_KINDS)[number];

adapterFaults#

Compare what two adapters did with the same bytes (S3.11.g).

ts
adapterFaults(subject: string, results: readonly { readonly adapter: string; readonly locator: StorageLocator; readonly digest: Sha256Hex; readonly bytesRead: number; readonly statedByteSize: number; readonly storeSupportsVersioning: boolean; }[]): readonly AdapterFault[]

Admission#

ts
| { readonly admitted: true; readonly presence: HumanPresence }
| { readonly admitted: false; readonly reason: RefusalReason; readonly detail: string }

ADMISSION_CHECKS#

Values: bytes-observed, digest-verified, type-permitted, size-within-limit, malware-scanned

AdmissionCheck#

ts
(typeof ADMISSION_CHECKS)[number];

AdmissionDecision#

Field Type Required Notes
state BlobState required —
results readonly { readonly check: AdmissionCheck; readonly result: CheckResult }[] — AdmissionCheck, CheckResult required Every check and what it said. unavailable is not passed.
detail string required —

AdmissionPolicy#

Field Type Required Notes
maxByteSize number required —
permittedMediaTypes readonly string[] required —
executablesPermitted boolean required A deployment that genuinely stores binaries says so here.
polyglotsPermitted boolean required —

admitBlob#

Decide whether a blob becomes real (S3.11.e).

ts
admitBlob(input: { readonly sniff: SniffResult; readonly storedByteSize: number; readonly verification: VerificationOutcome; readonly scan: CheckResult; readonly policy: AdmissionPolicy; }): AdmissionDecision

admitPlugin#

Runtime admission for one plugin (S1.9.g).

ts
admitPlugin(plugin: WorkbenchPlugin<TConfig>, context: ActivationContext<TConfig>): ActivationOutcome

admitSigner#

Decide whether this claim may sign (S2.13.b/c).

ts
admitSigner(claim: PresenceClaim, requirement: HumanGateRequirement, reviewOpenedAt: Instant, now: Instant): Admission

advanceMigration#

Decide whether a migration may advance to a phase (S3.13.f).

ts
advanceMigration(state: MigrationState, target: MigrationPhase, soakSeconds: number, now: Instant): MigrationDecision

AEAD_ALGORITHMS#

The AEAD algorithms a field may be sealed with.

Values: aes-256-gcm, chacha20-poly1305

AeadAlgorithm#

ts
(typeof AEAD_ALGORITHMS)[number];

AGGREGATE_FAULT_KINDS#

Values: result-for-an-unknown-gate, result-for-a-gate-that-does-not-apply-here, duplicate-result-for-one-gate, result-for-another-revision, result-for-a-superseded-gate-version, waiver-for-an-unwaivable-gate, waiver-for-a-gate-with-no-result, waiver-granted-by-the-accountable-owner, unknown-plugin-strategy, plugin-strategy-is-order-dependent, plugin-strategy-threw, plugin-strategy-returned-a-non-trivalent

AGGREGATE_POLICY_VIOLATION_KINDS#

Values: policy-version-not-a-positive-integer, waivers-honoured-for-the-regulator-audience, unknown-audience, duplicate-audience, quorum-need-not-a-positive-integer, conditional-branches-are-identical, target-specific-with-no-object-kinds, plugin-strategy-without-an-id

AggregateContext#

Field Type Required Notes
subjectRevision RevisionId required —
domain string required —
objectKind string required —
lifecycleStage string required —
audience GateAudience required —
at Instant required —
facts Readonly<Record<string, string>> required Facts a conditional strategy dispatches on. Recorded, never computed here.
dependencyVersions Readonly<Record<string, number>> required Current versions of everything a gate's evidence may be invalidated by.
waivers readonly WaiverRecord[] — WaiverRecord required —
plugins readonly AggregationStrategyPlugin[] — AggregationStrategyPlugin required —

AggregateFault#

Field Type Required Notes
kind AggregateFaultKind required —
subject string required —
detail string required —

AggregateFaultKind#

ts
(typeof AGGREGATE_FAULT_KINDS)[number];

aggregateGateRun#

Fold a set of runs into a release decision (S2.10.c/d/e).

ts
aggregateGateRun(definitions: readonly GateDefinition[], results: readonly GateRunResult[], context: AggregateContext, policy: AggregatePolicy): GateRunAggregate

AggregatePolicy#

Field Type Required Notes
policyId string required —
policyVersion number required Integer >= 1. Bumped when the fold's MEANING changes.
strategy AggregationStrategy required —
waiversHonouredFor readonly GateAudience[] — GateAudience required The audiences where a waiver still permits a release.
gapsBlockFor readonly GateAudience[] — GateAudience required The audiences where a recorded gap blocks instead of being recorded.

AggregatePolicyViolation#

Field Type Required Notes
kind AggregatePolicyViolationKind required —
subject string required —
detail string required —

AggregatePolicyViolationKind#

ts
(typeof AGGREGATE_POLICY_VIOLATION_KINDS)[number];

aggregateProgress#

Fold weighted child progress into the parent's (S3.10.d).

ts
aggregateProgress(graph: JobGraph, parentId: string, progress: readonly ChildProgress[]): AggregateProgress

AggregateProgress#

Field Type Required Notes
unit string required —
totalWeight number required —
knownWeight number required Weight belonging to children that can say how far along they are.
unknownWeight number required —
lowerBound number required Assuming every unknown child has done nothing.
upperBound number required Assuming every unknown child is finished.
fraction number | null required A single number ONLY when the bounds meet. Otherwise there isn't one.

AGGREGATION_STRATEGY_KINDS#

Values: all-of, any-of, quorum, conditional, target-specific, plugin

AggregationStrategy#

ts
| { readonly kind: 'all-of' }
| { readonly kind: 'any-of' }
| { readonly kind: 'quorum'; readonly need: number }
| { readonly kind: 'conditional'; readonly when: TargetPredicate; readonly then: AggregationStrategy; readonly otherwise: AggregationStrategy; }
| { readonly kind: 'target-specific'; readonly byObjectKind: Readonly<Record<string, AggregationStrategy>>; readonly fallback: AggregationStrategy; }
| { readonly kind: 'plugin'; readonly strategyId: string }

AggregationStrategyPlugin#

A domain's own way of folding the members.

Field Type Required Notes
strategyId string required —

ALERT_KINDS#

Values: quarantine-growing, partition-blocked, owner-stale, unresolved-too-long, taxonomy-drifting

ALERT_VERDICTS#

Values: no-alert, alert, cannot-conclude, threshold-is-inside-the-deploy-window

alertDecision#

Decide whether sustained incompatibility should page somebody (S3.14.g).

ts
alertDecision(readings: readonly CompatibilityReading[], sustainedSeconds: number, deployWindowSeconds: number, maximumGapSeconds: number): AlertDecision

AlertDecision#

Field Type Required Notes
verdict AlertVerdict required —
sustainedSeconds number required —
detail string required —

AlertThresholds#

Field Type Required Notes
openCeiling number required —
blockSecondsCeiling number required —
unresolvedSecondsCeiling number required —
unclassifiedFraction number required Fraction of open records that may be unclassified before the taxonomy is the problem.

AlertVerdict#

ts
(typeof ALERT_VERDICTS)[number];

AllowedTransition#

Field Type Required Notes
transitionId string required —
to TStage required —
trigger Trigger required —
requiresScope string | null required —
requiredGuards readonly string[] required The EXACT guard ids that must pass. Not "some guards apply".
effects readonly EffectKind[] — EffectKind required —
reversible boolean required —

allowedTransitions#

What may be attempted from a stage, and exactly what each one demands.

ts
allowedTransitions(graph: StageGraph<TStage>, from: NoInfer<TStage>): readonly AllowedTransition<TStage>[]

AppealPath#

Field Type Required Notes
to string required Who hears it. Never the same as the person whose work was blocked.
respondWithinHours number required How long they have to answer, in hours. An appeal with no clock is a no.
howKey string required —

applicationEnforced#

Constraints the application must hold, named so the gap is not a silence.

ts
applicationEnforced(): readonly RevisionConstraint[]

AppliedEffect#

Field Type Required Notes
stage string required —
at Instant required —
compensable boolean required —
compensationRef string | null required —

AppliedWaiver#

Field Type Required Notes
waiverId string required —
grantedBy string required —
expiresAt Instant required —
reason string required —

appliesTo#

Whether the gate runs at all for this stage and audience.

ts
appliesTo(definition: GateDefinition, lifecycleStage: string, audience: GateAudience): boolean

APPROVED_DIGEST_ALGORITHMS#

Digest algorithms this kit will record.

Values: sha256

ApprovedDigestAlgorithm#

ts
(typeof APPROVED_DIGEST_ALGORITHMS)[number];

asEdgeSet#

Lift a job graph into the stage engine's edge set (S2.1).

ts
asEdgeSet(graph: JobGraph): EdgeSet

associatedData#

The canonical associated data for a context (S3.13.c).

ts
associatedData(context: ProtectionContext): string

AUDIT_CAPABILITIES#

Values: read-timeline, read-actors, read-details

AUDIT_EVENT_KINDS#

Every decision the stage and gate machinery makes, as a recorded fact.

Values: transition-requested, transition-refused, transition-completed, transition-bypassed, gate-defined, gate-retired, gate-run-recorded, gate-marked-stale, recompute-queued, recompute-refused, waiver-granted, waiver-revoked, waiver-expired, signoff-recorded, signoff-invalidated

AuditActor#

Who did it, in the two halves an audit row needs.

Field Type Required Notes
actorId string required —
kind 'human' | 'delegated' | 'service' | 'system' required —
onBehalfOf string | null required —

AuditCapability#

ts
(typeof AUDIT_CAPABILITIES)[number];

AuditEvent#

Field Type Required Notes
eventId string required —
kind AuditEventKind required —
objectId string required One object, one stream. The sequence is per stream and gapless.
sequence number required —
tenantId string required —
targetRevision string required —
priorState string | null required Null for an event that does not move a stage.
newState string | null required —
subjectId string required What the event is ABOUT, when that is narrower than the object.
actor AuditActor required —
reasonKey string required A translation key, never the sentence.
detail string required Free text. Scanned before it is ever shown; see .
evidenceVersions Readonly<Record<string, number>> required —
policyVersion number required —
correlationId string required —
traceId string | null required —
errorRef string | null required A support reference, never a message or a stack.
at Instant required —
schemaVersion number required The schema this event was written under.

AuditEventKind#

ts
(typeof AUDIT_EVENT_KINDS)[number];

AuditLeak#

Re-exported so a caller need not reach into S1.10 to type a scan result.

ts
Leak;

AuditProjection#

Field Type Required Notes
objectId string required —
tenantId string | null required —
currentStage string | null required —
timeline readonly TimelineEntry[] — TimelineEntry required —
gates readonly GateStatusRow[] — GateStatusRow required —
signoffs readonly SignoffRow[] — SignoffRow required —
refusedTransitions readonly { readonly to: string; readonly reasonKey: string }[] required Transitions the trail shows as attempted and refused.
bypasses number required —
throughSequence number required Sequence of the last event folded. Zero for an empty projection.
complete boolean required False when a gap, a duplicate position or a poison event stopped the fold.
stalledAt number | null required —
stalledBecause string | null required —

AuditViewer#

Field Type Required Notes
tenantId string required —
capabilities readonly AuditCapability[] — AuditCapability required —

authorizeAction#

Authorize one operator action (S3.8.d).

ts
authorizeAction(request: ActionRequest): ActionDecision

authorizeBreakGlass#

Decide a break-glass key access (S3.13.b).

ts
authorizeBreakGlass(request: BreakGlassRequest, maximumWindowSeconds: number): BreakGlassDecision

authorizeDeadLetterAction#

Authorize one action on a dead letter (S3.9.h).

ts
authorizeDeadLetterAction(request: DeadLetterActionRequest): DeadLetterDecision

authorizeDecrypt#

Authorize a decrypt (S3.11.d).

ts
authorizeDecrypt(input: { readonly blob: BlobReference; readonly encryption: EncryptionMetadata; readonly capabilities: readonly string[]; readonly permittedRegions: readonly string[]; readonly knownKeyVersions: readonly string[]; }): DecryptDecision

authorizeResolution#

Authorize a vault resolution (S3.13.d).

ts
authorizeResolution(request: ResolutionRequest, maximumLeaseSeconds: number): ResolutionDecision

authorizeShred#

Decide whether a key may be destroyed (S3.13.b).

ts
authorizeShred(input: { readonly key: KeyDescriptor; readonly wrappedKeyIds: readonly string[]; readonly holds: readonly LegalHoldRecord[]; readonly heldFieldIds: readonly string[]; readonly tenantIdsAffected: readonly string[]; }): ShredDecision

BACKFILL_FAULT_KINDS#

Values: cursor-over-a-mutable-column, unbounded-batch, no-checkpoint, backfill-without-dual-write, no-quarantine-for-rows-that-fail, quarantined-rows-not-reconciled

BackfillCheckpoint#

Field Type Required Notes
cursorColumn string required The column the batch cursor walks. Must not change under the backfill.
cursorColumnIsImmutable boolean required —
batchSize number | null required —
lastCursor string | null required —
rowsSealed number required —
rowsAlreadySealed number required —
rowsQuarantined number required —
dualWriteActive boolean required —
quarantineConfigured boolean required —

BackfillFault#

Field Type Required Notes
kind BackfillFaultKind required —
subject string required —
detail string required —

BackfillFaultKind#

ts
(typeof BACKFILL_FAULT_KINDS)[number];

backfillFaults#

Check a backfill (S3.13.f).

ts
backfillFaults(checkpoint: BackfillCheckpoint): readonly BackfillFault[]

backoffSeconds#

Exponential backoff with a deterministic, seeded jitter.

ts
backoffSeconds(attempt: number, policy: RetryPolicy, jitter = 0): number

BATCH_FAULT_KINDS#

Values: batch-unbounded, unknown-recorded-as-deleted, tombstone-dropped-where-required

BatchDeletionOutcome#

ts
(typeof DELETION_OUTCOMES)[number];

BatchFault#

Field Type Required Notes
kind BatchFaultKind required —
subject string required —
detail string required —

BatchFaultKind#

ts
(typeof BATCH_FAULT_KINDS)[number];

batchFaults#

Check how a batch was run (S3.12.f).

ts
batchFaults(input: { readonly batchSize: number; readonly maxBatchSize: number; readonly report: BatchReport; readonly recordedAsDeleted: readonly string[]; readonly tombstonesWritten: readonly string[]; readonly tombstoneRequiredFor: readonly string[]; }): readonly BatchFault[]

BatchItemResult#

Field Type Required Notes
blobId string required —
outcome BatchDeletionOutcome required —
detail string required —

BatchReport#

Field Type Required Notes
attempted number required —
deleted readonly string[] required —
alreadyAbsent readonly string[] required —
refused readonly string[] required —
failed readonly string[] required —
unknown readonly string[] required Neither deleted nor safe to call failed. Decision 4.
notAttempted readonly string[] required Left for the next batch. Decision 5: not implied, stated.
detail string required —

BehaviourFault#

Field Type Required Notes
kind MatrixBehaviourFault required —
subject string required —
detail string required —

behaviourFaults#

Check observed behaviour against the expectations (S3.13.g).

ts
behaviourFaults(observed: readonly ObservedFailure[]): readonly BehaviourFault[]

Binding#

Field Type Required Notes
strategy BindingStrategy required —
compensation string | null required Required for a saga: what undoes the effect if the receipt never lands.
reconciliation string | null required Required for a saga: how the gap between the two is detected.

BINDING_FAULT_KINDS#

Values: saga-without-a-compensation, saga-without-a-reconciliation, transaction-with-a-compensation

BINDING_STRATEGIES#

How a consumer binds the receipt to the effect it records.

Values: one-transaction, saga

BindingFault#

Field Type Required Notes
kind BindingFaultKind required —
subject string required —
detail string required —

BindingFaultKind#

ts
(typeof BINDING_FAULT_KINDS)[number];

BindingStrategy#

ts
(typeof BINDING_STRATEGIES)[number];

BLAST_RADII#

How far a revocation reaches.

Values: the-keys-below-this-one, the-rows-this-key-sealed, every-key-beneath-it-and-everything-they-sealed

BlastRadius#

ts
(typeof BLAST_RADII)[number];

BLOB_FAULT_KINDS#

Values: no-locator-key, active-without-an-observation, active-without-a-verified-digest, active-without-an-owner, digest-without-a-verification-time, verified-before-created, observed-size-of-zero-on-an-active-blob, rejected-with-owners, declared-size-trusted-as-observed

BLOB_STATES#

Where a blob is in its own admission lifecycle.

Values: pending-upload, quarantined, active, rejected

BlobFault#

Field Type Required Notes
kind BlobFaultKind required —
subject string required —
detail string required —

BlobFaultKind#

ts
(typeof BLOB_FAULT_KINDS)[number];

blobFaults#

Check a blob reference (S3.11.a).

ts
blobFaults(blob: BlobReference): readonly BlobFault[]

BlobReference#

Field Type Required Notes
blobId string required —
tenantId string required —
scope string required The workbench or entity this blob belongs to. Scope is not the same as tenant.
locator StorageLocator required —
state BlobState required —
createdBy string required —
createdAt Instant required —
declared DeclaredMetadata required Never merged. See decision 1.
observed ObservedMetadata | null — ObservedMetadata required Null until the bytes have been looked at.
digest ByteDigest | null — ByteDigest required Null until the STORED bytes have been read back and hashed. See decision 2.
verifiedAt Instant | null — Instant required —
owners readonly string[] required What refers to this blob. A blob with no owner is the S3.12 problem.

BlobState#

ts
(typeof BLOB_STATES)[number];

BlobStore#

The contract every storage adapter satisfies.

BlockAccessibility#

Field Type Required Notes
landmarkRole string | null required The role a host should expose the block as.
summary (block: TBlock) => string required A one-line description for a non-visual reader. Never empty.
hasNonTextualMeaning boolean required True when the block conveys meaning through colour, motion or position.

BlockChange#

Field Type Required Notes
anchor StableAnchor required —
change 'inserted' | 'removed' | 'changed' required —
fieldPath readonly string[] required —

BlockContribution#

Field Type Required Notes
validate (candidate: unknown) => ParseResult<TBlock> — ParseResult required —
toSemanticNodes (block: TBlock) => readonly SemanticNode[] — SemanticNode required —
migrationSteps readonly BlockMigrationStep[] — BlockMigrationStep required —
diff (before: TBlock, after: TBlock, takenAt: RevisionRef) => readonly BlockChange[] — BlockChange, RevisionRef required Both take the revision the anchors are TAKEN AT, rather than manufacturing one. An anchor without it is an offset into a document nobody can date, which is the one thing exists not to be.
anchors (block: TBlock, takenAt: RevisionRef) => readonly StableAnchor[] — RevisionRef, StableAnchor required —
interchange BlockInterchange<TBlock, TSerialized> — BlockInterchange required —
accessibility BlockAccessibility<TBlock> — BlockAccessibility required —
applyEdit | ((block: TBlock, commandId: string, input: unknown) => ParseResult<TBlock>) | null — ParseResult required Apply one editor command. PURE: it returns the next block or a refusal and never mutates the one it was given — an editor that edited in place would make the diff, the undo stack and the optimistic-concurrency check all read the same object.

BlockedChild#

Field Type Required Notes
childId string required —
by readonly string[] required —

BlockedPartition#

Field Type Required Notes
partition string required —
since Instant required —

BlockInterchange#

Field Type Required Notes
mediaTypes readonly string[] required —
export (block: TBlock) => TSerialized required —
import (input: unknown) => ParseResult<TBlock> — ParseResult required —

BlockMetadata#

Field Type Required Notes
extensionPoint 'block' required —
blockType string required —
schemaVersion number required —
migrations readonly { readonly from: number; readonly to: number }[] required The migration chain, as version pairs.
mediaTypes readonly string[] required —
hasNonTextualMeaning boolean required —
landmarkRole string | null required —
editor EditorMetadata | null — EditorMetadata required Null when the block type is read-only in every host.

BlockMigrationStep#

Field Type Required Notes
from number required —
to number required —
migrate (input: unknown) => ParseResult<unknown> — ParseResult required —

BOUNDARY_TRANSITIONS#

Values: share, transfer, fork, export, import, support-grant, tenant-migration

BoundaryTransition#

ts
(typeof BOUNDARY_TRANSITIONS)[number];

BREAK_GLASS_REFUSALS#

Values: audit-record-not-written-first, same-identity-as-the-routine-path, no-expiry, window-longer-than-the-maximum, human-gate-is-not-valid, scope-is-every-key, no-step-up, step-up-is-weak

BreakGlassDecision#

ts
| { readonly allowed: true; readonly expiresAt: Instant; readonly detail: string }
| { readonly allowed: false; readonly refusals: readonly BreakGlassRefusal[]; readonly detail: string; }

BreakGlassRefusal#

ts
(typeof BREAK_GLASS_REFUSALS)[number];

BreakGlassRequest#

Field Type Required Notes
requestId string required —
actorId string required The identity performing the emergency access.
routineActorId string required The identity the normal application path runs as.
gate HumanGateRequirement required —
keyIds readonly string[] required —
allKeyIds readonly string[] required —
grantedAt Instant required —
expiresAt Instant | null — Instant required —
auditRecordWrittenAt Instant | null — Instant required Whether the audit record exists BEFORE the access. Not after: an audit written afterwards is prevented by the same failure that made the emergency access necessary, and the one access nobody has a record of is the one taken during the incident.
stepUpPerformed boolean required —

BrokerAck#

Field Type Required Notes
destination string required —
brokerOffset string required —
acknowledgedAt Instant required —

buildStageGraph#

Build and validate the graph.

ts
buildStageGraph(universe: StageUniverse<TStage>, transitions: readonly NoInfer<Transition<TStage>>[], options: GraphOptions = { registeredGuards: [] }): StageResult<StageGraph<TStage>>

byCorrelation#

Everything one flow produced, for the question an incident actually asks.

ts
byCorrelation(rows: readonly OutboxRow[], correlationId: string): readonly OutboxRow[]

BypassCommand#

A bypass command may name any target stage, which is the whole point of it.

Field Type Required Notes
to TStage required —
bypass PrivilegedBypass required —

canBlock#

Whether a result from this gate may stop anything, at this stage.

ts
canBlock(definition: GateDefinition, lifecycleStage: string): boolean

CANCEL_OUTCOMES#

Values: cancelled-immediately, cancelling, already-terminal, refused

CANCEL_SOURCES#

Values: actor, operator, deadline, budget, parent

CancelDecision#

ts
| { readonly outcome: 'cancelled-immediately' | 'cancelling' | 'already-terminal'; readonly detail: string; }
| { readonly outcome: 'refused'; readonly detail: string }

CANCELLATION_POINT_ACTIONS#

Values: stop, continue, escalate-and-fence

CANCELLATION_PROPAGATIONS#

What happens to the children when the parent is cancelled.

Values: cancel-children, let-children-finish

CancellationPlan#

Field Type Required Notes
cancel readonly string[] required Children to cancel, in reverse ordinal order: the newest work stops first.
letFinish readonly string[] required Children whose edge says to let them finish. The parent waits for these.
alreadyTerminal readonly string[] required Already terminal. Cancelling a finished child would rewrite what happened.
note string required —

cancellationPoint#

What a worker does when it reaches a cancellation point (S3.9.f).

ts
cancellationPoint(input: { readonly cancelling: boolean; readonly region: NoncancellableRegion | null; readonly now: Instant; }): CancellationPointDecision

CancellationPointAction#

ts
(typeof CANCELLATION_POINT_ACTIONS)[number];

CancellationPointDecision#

Field Type Required Notes
action CancellationPointAction required —
detail string required —

CancellationPropagation#

ts
(typeof CANCELLATION_PROPAGATIONS)[number];

CancelOutcome#

ts
(typeof CANCEL_OUTCOMES)[number];

CancelRequest#

Field Type Required Notes
jobId string required —
source CancelSource required —
requestedBy string required —
reason string required —
at Instant required —

CancelSource#

ts
(typeof CANCEL_SOURCES)[number];

CapabilityDeclaration#

What a plugin says about one capability.

ts
| { readonly capability: CapabilityId; readonly support: 'implemented' }
| { readonly capability: CapabilityId; readonly support: 'degraded'; readonly reason: string; readonly retains: readonly string[]; }
| { readonly capability: CapabilityId; readonly support: 'unsupported'; readonly reason: string; }

CapabilityProbe#

Field Type Required Notes
capability 'read' | 'write' required —
method WriteProbeMethod required —
rollsBack boolean required —
touchesUserTables boolean required —
consults readonly WriteBlockingState[] — WriteBlockingState required The states this probe actually asks the engine about.

CapabilityVerdict#

Field Type Required Notes
capability ServedCapability required —
decision ServeDecision required —
reason string required —

One link in the chain that produced the failure, newest first.

Field Type Required Notes
code string required —
message string required —
at Instant required —

ChainResolution#

Walk a supersession chain from any record to the one in force.

ts
| { readonly resolved: true; readonly inForce: DecisionRecord; readonly through: readonly string[]; }
| { readonly resolved: false; readonly reason: string; readonly through: readonly string[] }

CHECK_RESULTS#

Values: passed, failed, unavailable

CHECKPOINT_ORDERINGS#

The orderings a stage may commit in.

Values: effect-and-checkpoint-in-one-transaction, effect-then-checkpoint-with-idempotent-replay

CheckpointOrdering#

ts
(typeof CHECKPOINT_ORDERINGS)[number];

CheckResult#

ts
(typeof CHECK_RESULTS)[number];

ChildOutcomeRecord#

Field Type Required Notes
childId string required —
failureCode string | null required A stable code, or null. Never a free-text message.
spent number required —

ChildProgress#

Field Type Required Notes
childId string required —
fraction number | null required 0..1, or null when the child genuinely cannot say (S3.9.d's rule).

ChildRetryPlan#

Field Type Required Notes
childId string required —
decision ReuseDecision required —
reason string required —

ChildState#

Field Type Required Notes
childId string required —
state JobState required —
onFailure FailurePolicy required —

CIPHER_FAILURES#

What the key service and the AEAD can say when a value will not open.

Values: authentication-failed, key-unavailable, key-destroyed, key-version-unknown, algorithm-unsupported

CipherFailure#

ts
(typeof CIPHER_FAILURES)[number];

CipherOpenResult#

ts
| { readonly ok: true; readonly plaintext: string }
| { readonly ok: false; readonly failure: CipherFailure }

CipherSealResult#

ts
| { readonly ok: true; readonly nonce: string; readonly ciphertext: string }
| { readonly ok: false; readonly failure: CipherFailure }

circuitFor#

ts
circuitFor(destination: string, samples: readonly DeliverySample[], policy: CircuitPolicy, now: Instant): CircuitState

CircuitPolicy#

Whether a destination's circuit is open.

Field Type Required Notes
windowSeconds number required —
failureThreshold number required —
minimumSamples number required —
openSeconds number required —

CircuitState#

ts
| { readonly open: false; readonly reason: string }
| { readonly open: true; readonly until: Instant; readonly reason: string }

CLAIM_FAULT_KINDS#

Values: unbounded-batch, lease-shorter-than-the-publish-timeout, not-subject-partitioned, no-skip-locked, no-per-tenant-cap, per-tenant-cap-above-the-batch

CLAIM_OUTCOMES#

Values: claimed, already-running, already-completed, retry-after-failure, conflicting-request, expired-and-irreversible

CLAIM_RESULTS#

Values: process, already-processed, in-flight, conflicting-body, stale-processing-version, held

CLAIMABLE_STATES#

States from which a dispatcher may claim.

Values: pending

ClaimDecision#

ts
| { readonly outcome: 'claimed' }
| { readonly outcome: 'already-running'; readonly detail: string }
| { readonly outcome: 'already-completed'; readonly resultRef: string | null }
| { readonly outcome: 'retry-after-failure'; readonly detail: string }
| { readonly outcome: 'conflicting-request'; readonly detail: string }
| { readonly outcome: 'expired-and-irreversible'; readonly detail: string }

ClaimFault#

Field Type Required Notes
kind ClaimFaultKind required —
subject string required —
detail string required —

ClaimFaultKind#

ts
(typeof CLAIM_FAULT_KINDS)[number];

claimFaults#

ts
claimFaults(policy: ClaimPolicy): readonly ClaimFault[]

claimOrder#

The order a dispatcher must claim in, as a comparator over rows.

ts
claimOrder(a: OutboxRow, b: OutboxRow): number

ClaimOutcome#

ts
(typeof CLAIM_OUTCOMES)[number];

ClaimPolicy#

How a dispatcher takes work.

Field Type Required Notes
batchSize number required —
leaseSeconds number required —
publishTimeoutSeconds number required The publish timeout the dispatcher enforces. The lease has to outlast it.
subjectPartitioned boolean required —
skipLocked boolean required Skip rows another transaction holds instead of waiting behind them.
perTenantCap number required Rows one tenant may hold in a single batch. Without a cap, one tenant's backlog is every dispatcher's whole batch and the others wait behind it.

ClaimRequest#

Field Type Required Notes
rows readonly OutboxRow[] — OutboxRow required —
now Instant required —
holder string required —
policy ClaimPolicy required —
heldSubjects readonly string[] required Subjects another dispatcher already holds. Skipped, never waited on.

ClaimRequest#

Field Type Required Notes
key InboxKey required —
payloadHash Sha256Hex required —
processingVersion number required —
existing InboxReceipt | null — InboxReceipt required The receipt already stored under this key, if any.

ClaimResult#

ts
(typeof CLAIM_RESULTS)[number];

Classification#

Field Type Required Notes
condition PoisonCondition required —
detail string required —
unclassified boolean required True only for unknown: this needs a person to extend the taxonomy.

classifyJobFailure#

Classify a failed attempt (S3.9.g).

ts
classifyJobFailure(failure: JobFailure, delivery: EffectDelivery): FailureClassification

classifyOrphan#

Classify one observation (S3.12.b).

ts
classifyOrphan(observation: OrphanObservation): OrphanVerdict

classifyPoison#

Decide what kind of poison this is (S3.8.a).

ts
classifyPoison(signals: FailureSignals): Classification

Collation#

ts
(typeof COLLATIONS)[number];

COLLATIONS#

The collation an index column is built with, which for text is the difference between an index that works and one that is merely present.

Values: database, c

ColumnCensus#

Every column the storage layer knows about.

Field Type Required Notes
entity string required —
column string required —
sensitive boolean required Whether the storage owner marked this column as carrying sensitive data. Declared by the schema owner, never inferred from the name — notes holds a diagnosis often enough, and patient_notes is the version that gets caught by a name rule.

ColumnFacts#

What is known about one column's values, per tenant.

Field Type Required Notes
column string required —
distinctValues number required Distinct values within one tenant. A column with two of them cannot lead an index usefully.
nullFraction number required Fraction of rows where the column is null, 0..1.
sensitive boolean required Whether the column holds personal data. An index on one is a second copy of it, reachable by an index-only scan and dumped by a base backup, which is what makes an erasure request harder than deleting the row.

CommitRequest#

Field Type Required Notes
mutationSubject EventSubject required —
mutate (handle: TransactionHandle) => Promise<T> — TransactionHandle required The authoritative write. It receives the same handle the events are appended on.
events readonly OutboxIntent[] — OutboxIntent required —
declaresEvents boolean required Whether this mutation is one that must emit. A silent false is checked.

commitWithEvents#

The only way to write, and it takes the events with it (S3.6.b).

ts
commitWithEvents(store: TransactionalStore, request: CommitRequest<T>): Promise<T>

compareSchema#

Compare the schema the database has with the schema the build expects (S3.14.c).

ts
compareSchema(requirement: SchemaRequirement, observed: ObservedSchema): SchemaVerdict

COMPATIBILITY_FINDING_KINDS#

Values: required-object-absent, required-object-not-checkable, silent-control-absent, requirement-never-observed, observation-for-an-undeclared-object

CompatibilityFinding#

Field Type Required Notes
kind CompatibilityFindingKind required —
subject string required —
detail string required —
blocking boolean required Whether this alone is enough to refuse the write path.

CompatibilityFindingKind#

ts
(typeof COMPATIBILITY_FINDING_KINDS)[number];

compatibilityFindings#

Compare what has to be there with what was found (S3.14.d).

ts
compatibilityFindings(required: readonly ObjectRequirement[], observed: readonly ObjectObservation[]): readonly CompatibilityFinding[]

CompatibilityReading#

Field Type Required Notes
at Instant required —
compatible boolean required —

CompensationOutcome#

Field Type Required Notes
compensated boolean required —
reason string required —

compensationPlan#

Plan the undo for a cancelled job (S3.9.f).

ts
compensationPlan(effects: readonly AppliedEffect[]): CompensationPlan

CompensationPlan#

Field Type Required Notes
steps readonly CompensationStep[] — CompensationStep required Reverse order of application: the last thing done is the first thing undone.
uncompensated readonly string[] required Effects that cannot be undone. The cancel is not clean and the record must say so.
partiallyApplied boolean required —
note string required —

CompensationStep#

Field Type Required Notes
stage string required —
compensationRef string required —

COMPLETION_FAULT_KINDS#

Values: succeeded-with-an-unfinished-stage, succeeded-with-an-indeterminate-stage, progress-after-a-terminal-state

CompletionFault#

Field Type Required Notes
kind CompletionFaultKind required —
subject string required —
detail string required —

CompletionFaultKind#

ts
(typeof COMPLETION_FAULT_KINDS)[number];

completionFaults#

Check progress against the job's state (S3.9.d).

ts
completionFaults(state: JobState, stages: readonly StageProgress[], lastProgressAt: Instant | null, terminalAt: Instant | null): readonly CompletionFault[]

Component#

One gate's row in the aggregate. Every applicable gate has exactly one.

Field Type Required Notes
gateId string required —
gateVersion number required —
state ComponentState required —
effect ComponentEffect required —
severity GateSeverity required —
couldBlock boolean required —
trivalent Trivalent | null — Trivalent required The trivalent of what was FOUND. Null when nothing applies here.
folded Trivalent | null — Trivalent required What this component contributed to the fold. Null when it did not enter it.
reasonKey string required —
detail string required —
waiver AppliedWaiver | null — AppliedWaiver required —
runId string | null required —

COMPONENT_EFFECTS#

What this component DOES to the release, which is not what it found.

Values: satisfied, noted, skipped, waived, blocks, not-applicable

ComponentEffect#

ts
(typeof COMPONENT_EFFECTS)[number];

ComponentState#

What one gate came out as, in the three vocabularies the kit already has.

ts
| { readonly kind: 'evaluated'; readonly verdict: VerdictName }
| { readonly kind: 'not-evaluated'; readonly state: NonValueState }
| { readonly kind: 'not-applicable' }

composeGuards#

Fold guard results into one decision, deterministically.

ts
composeGuards(guards: readonly { readonly guardId: string; readonly blocking: boolean }[], results: readonly GuardResult[], policy: CompositionPolicy = {}): GuardDecision

COMPOSITION_RULES#

How this gate combines with others. The AGGREGATION itself is S2.10.

Values: standalone, all-of, any-of, quorum

CompositionPolicy#

Field Type Required Notes
shortCircuit boolean optional Stop at the first blocking refusal.

CompositionRule#

ts
(typeof COMPOSITION_RULES)[number];

Confidence#

ts
(typeof CONFIDENCE_LEVELS)[number];

CONFIDENCE_LEVELS#

Values: high, medium, low

confidenceOf#

Decide how much a candidate is to be trusted (S3.12.d).

ts
confidenceOf(input: { readonly searchedSources: readonly ReferenceSource[]; readonly gates: readonly GateResult[]; readonly orphanClass: OrphanClass; }): Confidence

ConflictDeclaration#

A conflict the signer declared, and what they did about it.

Field Type Required Notes
conflictId string required —
summary string required —
recused boolean required —

CONFORMANCE_FAULTS#

Values: no-contribution-for-the-definition, stale-fallback-disagrees, not-configured-fallback-disagrees, failed-fallback-disagrees, determinism-claim-disagrees, contribution-for-a-retired-gate

ConformanceFault#

Field Type Required Notes
kind ConformanceFaultKind required —
gateId string required —
detail string required —

ConformanceFaultKind#

ts
(typeof CONFORMANCE_FAULTS)[number];

conformsToDefinition#

Make the catalogue and the running code agree (S2.9).

ts
conformsToDefinition(definition: GateDefinition, contribution: ContributedGate | null): readonly ConformanceFault[]

ConsideredOption#

Field Type Required Notes
optionId string required —
description string required —
status OptionStatus required —
benefits readonly string[] required —
costs readonly string[] required —
dependencies readonly string[] required What this option would have required. Often the real reason it lost.
risks readonly string[] required —
rejectionReason string | null required Required for rejected and deferred; must be null for chosen.

CONSTRAINT_PLACEMENT#

Where each revision constraint belongs, and the two that cannot go in the database at all.

ConstraintPlacement#

Field Type Required Notes
constraint RevisionConstraint required —
layer EnforcementLayer required —
why string required —

CONTEXT_FAULT_KINDS#

Values: context-part-is-empty, context-part-carries-a-value

contextDrift#

Which parts of the stored context differ from where the row actually is.

ts
contextDrift(expected: ProtectionContext, stored: ProtectionContext): readonly (typeof CONTEXT_PARTS)[number][]

ContextFault#

Field Type Required Notes
kind ContextFaultKind required —
subject string required —
detail string required —

ContextFaultKind#

ts
(typeof CONTEXT_FAULT_KINDS)[number];

contextFaults#

Check a context before it becomes associated data (S3.13.c).

ts
contextFaults(context: ProtectionContext): readonly ContextFault[]

CONTRACT_FAULT_KINDS#

Values: liveness-reaches-the-database, liveness-checks-nothing, readiness-never-checks-the-database, probe-timeout-leaves-no-headroom, probe-shares-the-request-pool, probe-has-no-connection-budget, introspection-on-every-poll, startup-probe-skips-the-introspection, cached-readiness-longer-than-the-poll-it-replaces

ContractFault#

Field Type Required Notes
kind ContractFaultKind required —
subject string required —
detail string required —

ContractFaultKind#

ts
(typeof CONTRACT_FAULT_KINDS)[number];

contractFaults#

Check a probe contract (S3.14.a).

ts
contractFaults(contract: ProbeContract, headroomFactor: number): readonly ContractFault[]

ContributedGate#

What a plugin actually shipped, in the fields the catalogue also states.

Field Type Required Notes
gateId string required —
onStale NonPassingVerdict required —
onNotConfigured NonPassingVerdict required —
onFailed NonPassingVerdict required —
deterministic boolean required —

ContributionAuthorization#

Field Type Required Notes
requiredScopes readonly string[] required —
dataClassification DataClassification required —
requiresElevation boolean required —

ContributionMetadata#

ts
| StageModelMetadata
| GateMetadata
| BlockMetadata
| ProjectionMetadata
| ImporterMetadata
| PublisherMetadata

Coverage#

Field Type Required Notes
queryId string required —
outcome CoverageOutcome required —
index string | null required The index that produced this outcome, or null when nothing on the entity applies.
filtered readonly string[] required Predicates the index could not apply, which the engine must apply as a filter.
detail string required —

COVERAGE_OUTCOMES#

How well an index serves a query, worst outcome last.

Values: covered, covered-with-a-sort, filtered-after-the-index, uncovered

coverageFor#

The best any declared index can do for one query.

ts
coverageFor(query: WorkloadQuery, indexes: readonly IndexDeclaration[]): Coverage

CoverageOutcome#

ts
(typeof COVERAGE_OUTCOMES)[number];

CRASH_WINDOW_OUTCOMES#

What a crash between publish and mark leaves behind, per order.

Criticality#

ts
(typeof CRITICALITY)[number];

CRITICALITY#

Who is waiting for the answer.

Values: interactive, operator, background

criticalPath#

The longest chain of declared dependencies (S3.10.g).

ts
criticalPath(graph: JobGraph, parentId: string): CriticalPath

CriticalPath#

Field Type Required Notes
path readonly string[] required —
seconds number required —

CurrentState#

The world as it is now, in the same terms the reviewer saw it.

Field Type Required Notes
at Instant required —

cyclesIn#

Strongly-connected components of size > 1, plus self-loops: the cycles.

ts
cyclesIn(edgeSet: EdgeSet): readonly (readonly string[])[]

DATABASE_CHECKS#

Checks that reach the database. Derived from the permitted set by exclusion.

Values: connection-acquire, read-query, write-transaction, migration-state, schema-version, schema-objects, extensions, permissions

DATABASE_PROBE_KINDS#

The three probes, which answer three different questions.

Values: liveness, readiness, startup

databaseEnforceable#

Constraints an engine can hold on its own.

ts
databaseEnforceable(): readonly RevisionConstraint[]

DatabaseProbeKind#

ts
(typeof DATABASE_PROBE_KINDS)[number];

DEAD_LETTER_ACTIONS#

Values: inspect, assign, annotate, replay, abandon, purge-inputs

DEAD_LETTER_FAULT_KINDS#

Values: no-owner, diagnostic-code-is-not-a-code, diagnostic-is-a-serialized-payload, diagnostic-detail-unbounded, inputs-not-retained, resolved-without-a-resolution, resolved-without-a-review, reviewed-without-a-remediation, inputs-purged-while-open

DEAD_LETTER_REFUSALS#

Values: not-authorized, already-resolved, inputs-purged, inputs-moved, nothing-has-changed, abandon-without-a-reason, purge-would-strand-an-open-record

DEAD_LETTER_RESOLUTIONS#

Values: replayed, abandoned, fixed-elsewhere

deadEnds#

Every stage with no way out, whatever their terminal flag claims.

ts
deadEnds(graph: StageGraph<TStage>): readonly TStage[]

DeadLetter#

Field Type Required Notes
deadLetterId string required —
jobId string required —
tenantId string required —
type string required —
typeVersion number required —
finalAttempt number required —
failureKind JobFailureKind required —
retryability Retryability required —
diagnostics readonly Diagnostic[] — Diagnostic required —
inputRef string required RETAINED by reference, with the hash that makes a later replay checkable.
inputHash Sha256Hex required —
owner string | null required —
remediationKey string | null required —
deadLetteredAt Instant required —
reviewedAt Instant | null — Instant required —
resolvedAt Instant | null — Instant required —
resolution DeadLetterResolution | null — DeadLetterResolution required —
inputsPurgedAt Instant | null — Instant required —

DeadLetterAction#

ts
(typeof DEAD_LETTER_ACTIONS)[number];

DeadLetterActionRequest#

Field Type Required Notes
action DeadLetterAction required —
record DeadLetter required —
capabilities readonly string[] required —
currentInputHash Sha256Hex | null — Sha256Hex required What the input reference resolves to NOW.
currentTypeVersion number required The handler version deployed now.
causeWasEnvironmental boolean required Whether the original cause was outside the handler (a dead dependency, a bad deploy).
reason string | null required For abandon: why the work is not going to be done.

DeadLetterDecision#

ts
| { readonly allowed: true; readonly action: DeadLetterAction; readonly note: string }
| { readonly allowed: false; readonly refusal: DeadLetterRefusal; readonly detail: string }

DeadLetterFault#

Field Type Required Notes
kind DeadLetterFaultKind required —
subject string required —
detail string required —

DeadLetterFaultKind#

ts
(typeof DEAD_LETTER_FAULT_KINDS)[number];

deadLetterFaults#

Check a dead-letter record (S3.9.h).

ts
deadLetterFaults(record: DeadLetter): readonly DeadLetterFault[]

DeadLetterRefusal#

ts
(typeof DEAD_LETTER_REFUSALS)[number];

DeadLetterReplay#

Field Type Required Notes
jobId string required UNCHANGED. A dead-letter replay is this job continued, not a new one.
idempotencyKey string required UNCHANGED, for the same reason.
attempt number required UNCHANGED: the next claim increments it, so the history stays one sequence.
maxAttempts number required —
state 'queued' required —
runnableAt Instant required —
replayOf string required —
authorizedBy string required —
note string required —

DeadLetterResolution#

ts
(typeof DEAD_LETTER_RESOLUTIONS)[number];

decideAccess#

Decide one access (S3.2.c).

ts
decideAccess(request: AccessRequest): AccessDecision

decideClaim#

Decide what a request should get, given whatever record already exists (S3.4.d/e).

ts
decideClaim(existing: IdempotencyRecord | null, requestDigest: Sha256Hex, at: Instant): ClaimDecision

decideClaim#

Decide what a delivery should do given what is already recorded (S3.7.c).

ts
decideClaim(request: ClaimRequest): InboxClaim

decideDelivery#

Decide what happens after a failed delivery (S3.6.e).

ts
decideDelivery(context: DeliveryContext): DeliveryOutcome

decideIntake#

Decide whether an event may be processed at all (S3.7.b).

ts
decideIntake(request: IntakeRequest): IntakeDecision

decideJobClaim#

Decide one claim (S3.9.b).

ts
decideJobClaim(request: JobClaimRequest): JobClaimDecision

decideJobRetry#

Decide what happens after a failed attempt (S3.9.g).

ts
decideJobRetry(context: JobRetryContext): JobRetryDecision

decideOrdering#

Decide what to do with an event given where the subject has got to (S3.7.d).

ts
decideOrdering(request: OrderingRequest): OrderingDecision

decideReplay#

Decide whether a row may be replayed (S3.6.f).

ts
decideReplay(request: ReplayRequest): ReplayDecision

decideResume#

Decide how a claimed job continues (S3.9.e).

ts
decideResume(input: ResumeInput): ResumeDecision

decideRetry#

Whether a failed processing attempt should be tried again (S3.7.f).

ts
decideRetry(receipt: InboxReceipt, failure: ProcessingFailure, maxAttempts: number): InboxRetryDecision

decideTransition#

Decide whether a boundary transition may happen (S3.2.e).

ts
decideTransition(request: TransitionRequest): TransitionDecision

DECISION_GUARDS#

The guards a host registers. Named here so the graph can require them.

Values: decider-is-not-the-proposer, every-rejected-option-has-a-reason, evidence-is-pinned, replacement-exists

DECISION_SCOPES#

Values: platform, tenant, workbench, capability, entity

DECISION_TYPES#

What KIND of decision this is, which decides who has to be involved.

Values: architecture, policy, editorial, rights, operational, exception

DECISION_VIOLATION_KINDS#

Values: no-title, no-rationale, no-owner, no-options, single-option-without-a-reason, no-chosen-option, more-than-one-chosen-option, chosen-option-carries-a-rejection-reason, rejected-option-without-a-reason, duplicate-option-id, effective-version-not-a-positive-integer, standing-review-without-a-reason, review-date-in-the-past-at-record-time, no-affected-target, decided-without-a-decider, decider-without-a-timestamp, delegated-authority-without-a-decider, decider-is-the-proposer, no-reviewers-on-a-reviewed-decision, evidence-without-a-digest, duplicate-evidence-id, evidence-summary-leaks, superseded-without-a-successor, successor-without-the-superseded-stage

DecisionAuthorship#

Field Type Required Notes
proposer ActorRef required —
decider ActorRef | null — ActorRef required —
reviewers readonly ActorRef[] — ActorRef required —
delegatedAuthority string | null required Set when the decider acted on somebody else's authority.
decidedAt Instant | null — Instant required —

DecisionCommand#

Field Type Required Notes
transitionId string required —
record DecisionRecord required —
actor ActorDecision required —
actorRef ActorRef required —
at Instant required —
idempotencyKey string required —
expectedRevision string required —
verdicts readonly GuardVerdict[] — GuardVerdict required —

DecisionEvidence#

Something the decision rested on, pinned.

Field Type Required Notes
evidenceId string required —
version number required —
digest Sha256Hex required —
retrievedAt Instant required —
source string required —
safeSummary string required —

decisionFingerprint#

A stable fingerprint of everything a decision rested on (S2.2.e / S2.2.f).

ts
decisionFingerprint(decision: GuardDecision): string

decisionGraph#

The decision lifecycle as a validated stage graph.

ts
decisionGraph(): StageGraph<DecisionStage>

DecisionPolicy#

Field Type Required Notes
separationOfDutyTypes readonly DecisionType[] — DecisionType required Types where the decider may not be the proposer.
reviewRequiredTypes readonly DecisionType[] — DecisionType required Types that must name at least one reviewer once they leave proposed.

DecisionRecord#

Field Type Required Notes
decisionId string required —
type DecisionType required —
scope DecisionScope required —
owner string required —
stage DecisionStage required —
effectiveVersion number required The version of the thing it takes effect for. Integer, >= 1.
review DecisionReview required —
affects readonly DecisionTarget[] — DecisionTarget required —
title string required —
rationale string required —
consequences readonly string[] required What follows from it, including the parts nobody likes.
residualRisk readonly string[] required What is still wrong after the decision. Empty means "we say nothing is".
options readonly ConsideredOption[] — ConsideredOption required —
onlyOptionReason string | null required Required when options has one entry: why nothing else was considered.
evidence readonly DecisionEvidence[] — DecisionEvidence required —
authorship DecisionAuthorship required —
recordedAt Instant required —
supersedes string | null required Set when this record replaced another. Never edited afterwards.
supersededBy string | null required Set when a later record replaced this one. The ONE field a link may write.

DecisionReview#

When this decision is looked at again.

ts
| { readonly kind: 'scheduled'; readonly on: Instant }
| { readonly kind: 'standing'; readonly why: string }

DecisionScope#

ts
(typeof DECISION_SCOPES)[number];

DecisionStage#

ts
| 'proposed'
| 'in-review'
| 'approved'
| 'rejected'
| 'effective'
| 'superseded'
| 'reversed'

DecisionTarget#

Something a decision binds. Typed so an audit can find every decision on it.

Field Type Required Notes
scope DecisionScope required —
ref string required —

DecisionType#

ts
(typeof DECISION_TYPES)[number];

DecisionViolation#

Field Type Required Notes
kind DecisionViolationKind required —
subject string required —
detail string required —

DecisionViolationKind#

ts
(typeof DECISION_VIOLATION_KINDS)[number];

DECLARED_SCOPE_WIDENINGS#

DeclaredMetadata#

What the uploader said. Evidence about the uploader.

Field Type Required Notes
filename string | null required —
mediaType string | null required —
byteSize number | null required —

DECLINED_INDEXES#

The indexes this plan deliberately does not create (S3.5.h).

DeclinedIndex#

An index this plan deliberately does not create, and what pays for it.

Field Type Required Notes
forQuery string required —
candidate string required The index that would have been created, described.
why string required —

DECRYPT_REFUSALS#

Values: not-authorized, blob-not-readable, key-version-unknown-to-this-caller, region-not-permitted

DecryptDecision#

ts
| { readonly allowed: true; readonly keyRef: string; readonly keyVersion: string }
| { readonly allowed: false; readonly refusal: DecryptRefusal; readonly detail: string }

DecryptRefusal#

ts
(typeof DECRYPT_REFUSALS)[number];

DEFAULT_DECISION_POLICY#

defineStages#

Register a domain's stages.

ts
defineStages(specs: readonly StageSpec<TStage>[]): StageResult<StageUniverse<TStage>>

DELETION_OUTCOMES#

Values: deleted, already-absent, refused, failed, unknown

DELETION_REFUSALS#

Values: token-expired, token-cleared-by-a-new-reference, reference-appeared, register-version-moved, wrong-blob

DELETION_STATES#

Values: active, deletion-requested, soft-deleted, retained, legal-held, purge-eligible, purging, purged, restored, failed

DELETION_TRANSITIONS#

The transitions that exist, and nothing else.

deletionConflict#

What to tell somebody whose erasure request cannot be actioned (S3.3.d).

ts
deletionConflict(holds: readonly LegalHoldRecord[], at: Instant, subject: { readonly tenantId: string; readonly workspaceId: string; readonly entityId: string }): DeletionConflict

DeletionConflict#

Field Type Required Notes
suspended boolean required —
reasonKey string required —
messageKey string required The sentence the subject is entitled to, which differs by disclosability.
reviewBy Instant | null — Instant required —
holdId string | null required —

DeletionDecision#

ts
| { readonly proceed: true; readonly plan: DeletionPlan }
| { readonly proceed: false; readonly refusal: DeletionRefusal; readonly detail: string }

DeletionPlan#

Field Type Required Notes
blobId string required —
action OrphanAction required —
token string required —
conditionalOn readonly string[] required The predicate the delete statement must carry. Returned as a description rather than executed, because the point is that it travels WITH the delete: evaluating it separately is the race this whole section is about.
note string required —

DeletionRefusal#

ts
(typeof DELETION_REFUSALS)[number];

DeletionState#

ts
(typeof DELETION_STATES)[number];

deletionStateFor#

Where a blob sits in the S3.3 deletion lifecycle (S3.11.e).

ts
deletionStateFor(blob: BlobReference): DeletionState

Delivery#

Fold a delivery stream — duplicates, gaps and all — into what a correct consumer would hold.

Field Type Required Notes
sequence number required —
eventId string required —
apply (fields: Record<string, unknown>) => void required —

DELIVERY_DECISIONS#

Values: retry, quarantine, give-up

DELIVERY_FAILURE_CLASSES#

What a delivery failure means for the next attempt.

Values: retryable, permanent, unknown

DELIVERY_FAULT_KINDS#

Values: duplicate-event-id, duplicate-sequence, sequence-gap, event-for-another-object, event-for-another-tenant, unknown-event-kind, invalid-event-quarantined

DeliveryContext#

Field Type Required Notes
row OutboxRow required —
failure DeliveryFailure required —
policy RetryPolicy required —
now Instant required —
jitter number optional 0..1, from the dispatcher; a seeded value keeps a run reproducible.

DeliveryDecision#

ts
(typeof DELIVERY_DECISIONS)[number];

DeliveryFailure#

Field Type Required Notes
class DeliveryFailureClass required —
code string required —
at Instant required —
detail string required —

DeliveryFailureClass#

ts
(typeof DELIVERY_FAILURE_CLASSES)[number];

DeliveryFault#

Field Type Required Notes
kind DeliveryFaultKind required —
eventId string required —
detail string required —

DeliveryFaultKind#

ts
(typeof DELIVERY_FAULT_KINDS)[number];

deliveryIsBlocked#

Whether a delivery may proceed given what is currently isolated.

ts
deliveryIsBlocked(isolation: { readonly scope: IsolationScope; readonly subject: string; readonly partition: string; readonly consumer: string; }, delivery: { readonly subject: string; readonly partition: string; readonly consumer: string }): boolean

DeliveryOutcome#

Field Type Required Notes
decision DeliveryDecision required —
nextAttemptAt Instant | null — Instant required —
reason string required —

DeliveryReceipt#

Field Type Required Notes
outboxId string required —
destination string required —
partitionKey string required —
brokerOffset string required —
acknowledgedAt Instant required —
[deliveryReceiptBrand] true required Type-only, following identity.ts: a declare const emits nothing, so the brand costs no import-time work — which "sideEffects": false promises and the S1.2.f emitted-module scan enforces — while still making the interface unconstructable outside this module.

DeliverySample#

Field Type Required Notes
destination string required —
at Instant required —
ok boolean required —

DERIVATIVE_KINDS#

Values: index, search-vector, display-surrogate, export-column, cache-entry, log-field, metric-label, foreign-copy

DerivativeKind#

ts
(typeof DERIVATIVE_KINDS)[number];

Diagnostic#

Field Type Required Notes
code string required —
detail string required —

DIGEST_VERIFICATION_SOURCES#

What a verification looked at.

Values: stored-bytes, inbound-stream, metadata

DigestVerificationSource#

ts
(typeof DIGEST_VERIFICATION_SOURCES)[number];

Disclosure#

Field Type Required Notes
kind DisclosureKind required —
subject string required —
detail string required —

DISCLOSURE_FAULT_KINDS#

Values: active-waiver-not-disclosed, nonauthorizing-waiver-shown-as-active, scope-not-shown, reason-not-shown, approver-not-named, expiry-not-shown, residual-risk-not-shown, expiry-shown-as-something-else, waiver-shown-that-nothing-granted

DISCLOSURE_FAULT_KINDS#

Values: actor-survived-redaction, principal-survived-redaction, detail-survived-redaction, cross-tenant-projection-returned, leak-in-a-disclosed-detail

DISCLOSURE_KINDS#

Values: names-a-database-object, carries-a-connection-string, carries-sql, carries-a-credential, code-is-a-sentence

DisclosureFault#

Field Type Required Notes
kind DisclosureFaultKind required —
subject string required —
detail string required —

DisclosureFault#

Field Type Required Notes
kind DisclosureFaultKind required —
subject string required —
detail string required —

DisclosureFaultKind#

ts
(typeof DISCLOSURE_FAULT_KINDS)[number];

DisclosureFaultKind#

ts
(typeof DISCLOSURE_FAULT_KINDS)[number];

disclosureFaults#

Check what a viewer actually received (S2.14.f).

ts
disclosureFaults(view: RedactedView, viewer: AuditViewer): readonly DisclosureFault[]

DisclosureKind#

ts
(typeof DISCLOSURE_KINDS)[number];

disclosures#

Check that the public body gives nothing away (S3.14.e).

ts
disclosures(view: PublicProbeView, objectNames: readonly string[]): readonly Disclosure[]

DISTRIBUTION_FAULT_KINDS#

Values: share-out-of-range, p99-below-p50, row-count-contradicts-volume-class, column-facts-missing, distinct-values-exceed-rows, null-fraction-out-of-range, no-uniqueness-declared

DistributionFault#

Field Type Required Notes
kind DistributionFaultKind required —
subject string required —
detail string required —

DistributionFaultKind#

ts
(typeof DISTRIBUTION_FAULT_KINDS)[number];

distributionFaults#

Check the declared distributions against themselves and against the workload.

ts
distributionFaults(profiles: readonly VolumeProfile[], workload: readonly WorkloadQuery[]): readonly DistributionFault[]

dryRunManifest#

Build the operator preview (S3.12.d).

ts
dryRunManifest(candidates: readonly ReclamationCandidate[], notExamined: number): DryRunManifest

DryRunManifest#

Field Type Required Notes
candidates readonly ReclamationCandidate[] — ReclamationCandidate required —
totalBytes number required —
byClass Readonly<Record<string, number>> required —
needsReview readonly string[] required Candidates the sweep will NOT act on without a person, and why.
notExamined number required Blobs the sweep did not examine at all. Decision 5.
detail string required —

earliestExpiry#

The earliest a record may be archived or dropped.

ts
earliestExpiry(claimedAt: Instant, irreversible: boolean, policy: RetentionPolicy): Instant

EdgeSet#

The minimum a graph analysis needs, with no domain vocabulary in it.

Field Type Required Notes
stages readonly string[] required —
initial string required —
edges readonly { readonly from: string; readonly to: string; readonly declaredRevisit: boolean; }[] required —

EDITOR_SURFACES#

Values: inline, side-panel, dialog, full-page

EditorCommand#

One edit a block type supports, in the domain's own vocabulary.

Field Type Required Notes
commandId string required —
labelKey string required —
requiresScope string | null required Null when any actor who may edit the block may run it.
reversible boolean required —

EditorMetadata#

The editor contract, minus the component.

Field Type Required Notes
labelKey string required —
surface EditorSurface required —
commands readonly EditorCommand[] — EditorCommand required —
readOnlyFallbackKey string required What a host renders for an actor who may not edit. Required, because the alternative a missing one invites is showing the editor and refusing on save, which teaches people their work can vanish.

EditorSurface#

ts
(typeof EDITOR_SURFACES)[number];

EFFECT_DELIVERIES#

How an effect reaches the world outside this system.

Values: none, idempotent, at-most-once

EFFECT_KINDS#

What a transition will cause OUTSIDE the object's own row.

Values: none, internal-write, notification, external-publish, payment, irreversible-external

EffectDelivery#

ts
(typeof EFFECT_DELIVERIES)[number];

EffectInput#

Everything the table needs about one gate, with nothing derived yet.

Field Type Required Notes
state ComponentState required —
couldBlock boolean required From canBlock: severity at this stage AND an enabled lifecycle.
whenUnavailable 'block' | 'warn' | 'skip-with-record' required The definition's behaviour when it cannot answer.
waived boolean required A live, in-scope, honoured waiver. Narrowed elsewhere; here it is a boolean.
gapsBlock boolean required The release policy refuses to accept a recorded gap for this audience.
ambiguous boolean required Two results for one gate: an ambiguous ledger, which is fail-closed.

EffectKind#

ts
(typeof EFFECT_KINDS)[number];

eligibility#

Run every eligibility gate (S3.12.c).

ts
eligibility(input: EligibilityInput): readonly GateResult[]

ELIGIBILITY_GATES#

Values: age-and-grace, upload-lease-settled, retention-elapsed, no-legal-hold, no-open-incident, not-in-a-release, provider-reconciled

ELIGIBILITY_STRICTNESS#

How alarming each headline is, as a total order.

EligibilityGate#

ts
(typeof ELIGIBILITY_GATES)[number];

EligibilityInput#

Field Type Required Notes
blobId string required —
createdAt Instant required —
now Instant required —
graceSeconds number required —
uploadLeaseExpiresAt Instant | null — Instant required An upload lease that has not expired means bytes may still arrive.
deletionState DeletionState required —
retentionEndsAt Instant | null — Instant required —
underLegalHold boolean required —
openIncidentRefs readonly string[] required —
releaseRefs readonly string[] required —
providerReconciledAt Instant | null — Instant required Whether the storage provider's own listing has been reconciled against the metadata recently. Null when it never has.
providerReconcileMaxAgeSeconds number required —

EMISSION_FAULT_KINDS#

Values: no-events-for-a-mutation-that-declares-them, event-subject-differs-from-the-mutation-subject, duplicate-event-in-one-commit, causation-outside-this-commit

EmissionFault#

Field Type Required Notes
kind EmissionFaultKind required —
subject string required —
detail string required —

EmissionFaultKind#

ts
(typeof EMISSION_FAULT_KINDS)[number];

emissionFaults#

Check that the events a commit carries belong to the mutation it performs.

ts
emissionFaults(mutationSubject: EventSubject, intents: readonly OutboxIntent[], declaresEvents: boolean): readonly EmissionFault[]

EMPTY_PROJECTION#

ts
EMPTY_PROJECTION(objectId: string): AuditProjection

ENCRYPTION_FAULT_KINDS#

Values: no-key-reference, no-key-version, rotation-overdue, rotation-without-a-due-date, customer-key-in-store-internal-location, client-side-without-transport-encryption, key-region-differs-from-blob-region

ENCRYPTION_MODES#

Values: store-managed, customer-managed-key, client-side

EncryptionFault#

Field Type Required Notes
kind EncryptionFaultKind required —
subject string required —
detail string required —

EncryptionFaultKind#

ts
(typeof ENCRYPTION_FAULT_KINDS)[number];

encryptionFaults#

Check the encryption description (S3.11.d).

ts
encryptionFaults(subject: string, encryption: EncryptionMetadata, blobRegion: string, now: Instant): readonly EncryptionFault[]

EncryptionMetadata#

Field Type Required Notes
mode EncryptionMode required —
keyLocation KeyMaterialLocation required —
keyRef string required A NAME, never material.
keyVersion string required —
region string required Where the key may be used. A key that crosses a region crosses a jurisdiction.
transportEncrypted boolean required Whether the bytes were encrypted in transit as well as at rest.
rotatedAt Instant | null — Instant required —
rotationDueAt Instant | null — Instant required —

EncryptionMode#

ts
(typeof ENCRYPTION_MODES)[number];

ENFORCEMENT_LAYERS#

Where a constraint can actually be enforced.

Values: column, table, index, trigger, application

EnforcementLayer#

ts
(typeof ENFORCEMENT_LAYERS)[number];

ENTITY_KINDS#

The kinds of shared entity the cell asks to be inventoried.

Values: authoritative, revision, evidence, job, event, audit, blob, review, taxonomy, calendar, catalog, projection

EntityKind#

ts
(typeof ENTITY_KINDS)[number];

EntityRegistration#

Field Type Required Notes
entity string required —
kind EntityKind required —
ownership OwnershipClass required —
columns readonly string[] required Columns the table actually declares.
unscopedBecause string | null required Required when the class carries no scope column: why it may not.
parent string | null required The entity this one hangs off, if any.
secondParent string | null required For a join row: the second parent. Both ends are checked.
appendOnly boolean required —

evaluateGuard#

Run a guard with the ambient world taken away.

ts
evaluateGuard(guard: Guard<TStage, TSubject>, input: GuardInput<TStage, TSubject>): GuardResult

evaluateQuorum#

Whether a set of signatures actually satisfies the requirement (S2.13.a).

ts
evaluateQuorum(requirement: HumanGateRequirement, records: readonly SignoffRecord[], authorId: string): QuorumOutcome

EVENT_VIOLATION_KINDS#

Values: sequence-not-a-positive-integer, schema-version-not-a-positive-integer, transition-without-states, non-transition-with-states, refusal-without-a-reason, bypass-without-a-reason, reason-is-not-a-key, delegated-actor-without-a-principal, principal-on-a-non-delegated-actor, no-correlation-id, subject-missing-on-a-subject-scoped-event, error-ref-is-not-a-reference, detail-carries-a-leak

EventContext#

The trace context an event carries.

Field Type Required Notes
correlationId string required —
causationId string | null required —
traceParent string | null required W3C traceparent, or null when the mutation had no trace.

EventKindOrdering#

Whether an event kind may be applied out of order.

Field Type Required Notes
eventKind string required —
commutes boolean required —
why string required Why. An unexplained true is what somebody set to stop the queue filling up.

EventSubject#

The aggregate an event is about. Ordering is per subject and nowhere else.

Field Type Required Notes
kind string required —
id string required —

EventViolation#

Field Type Required Notes
kind EventViolationKind required —
subject string required —
detail string required —

EventViolationKind#

ts
(typeof EVENT_VIOLATION_KINDS)[number];

evidenceFreshness#

Whether the evidence behind a result still holds, at an instant (S2.10.a).

ts
evidenceFreshness(result: GateRunResult, definition: GateDefinition, at: Instant, dependencyVersions: Readonly<Record<string, number>>): EvidenceFreshness

EvidenceFreshness#

Why a result no longer answers the question.

ts
| { readonly state: 'fresh' }
| { readonly state: 'stale'; readonly evidenceType: string; readonly why: 'age' | 'dependency-moved'; readonly detail: string; }
| { readonly state: 'missing'; readonly evidenceType: string }

EvidenceRecord#

One piece of evidence, as the run actually read it.

Field Type Required Notes
evidenceType string required —
version number required —
recordedAt Instant required —
digest Sha256Hex required —
dependencyVersions Readonly<Record<string, number>> required The versions of the things this evidence was derived from.

EvidenceRef#

A piece of evidence a guard consulted, pinned to the version it read.

Field Type Required Notes
evidenceId string required —
version number required Monotonic per evidenceId. A guard may not compare versions across ids.
producedAt Instant required When the evidence was produced, for the staleness budget below.
source string required What produced it: a gate, an importer, a reviewer, an external service.

EvidenceVersionConstraint#

An exact version, or a half-open range, for a piece of required evidence.

ts
| { readonly kind: 'exact'; readonly version: number }
| { readonly kind: 'range'; readonly minimum: number; readonly below: number }

EXECUTABLE_MEDIA_TYPES#

Formats that execute.

Values: application/x-elf, application/x-mach-binary, application/vnd.microsoft.portable-executable, text/x-shellscript

ExecutionContext#

Field Type Required Notes
tenant TenantId | null — TenantId required —
actor ActorRef required —
idempotencyKey string required —
startedAt Instant required —

executionMayProceed#

Refuse an execution whose approval does not belong to it.

ts
executionMayProceed(plan: ImportPlan<TPlan>, validation: ImportValidation): ParseResult<null>

explainPolicyChange#

What a new release policy would have decided about releases already made (S2.10.f).

ts
explainPolicyChange(before: AggregatePolicy, after: AggregatePolicy, cases: readonly PolicyChangeCase[]): PolicyChangeReport

EXTENSION_POINTS#

The seven places a domain plugin may contribute code.

Values: stage-model, gate, block, preview, inspector, importer, publisher

ExtensionPoint#

ts
(typeof EXTENSION_POINTS)[number];

EXTERNAL_OUTCOMES#

Values: not-started, committed, failed, unknown

ExternalOutcome#

ts
(typeof EXTERNAL_OUTCOMES)[number];

failedGuards#

The guards that did not pass.

ts
failedGuards(results: readonly ReplayGuardResult[]): readonly ReplayGuardResult[]

FAILURE_EXPECTATIONS#

What each mode must do, and the axis that matters.

FAILURE_MODES#

Values: backup-restored, key-rotated, kms-unavailable, vault-unavailable, ciphertext-corrupted, key-destroyed, unauthorized-access

FAILURE_POLICIES#

What a child's failure does to its parent.

Values: fail-parent, degrade-to-partial

FailureClassification#

Field Type Required Notes
retryability Retryability required —
unknownOutcome boolean required True when nobody knows whether the effect happened. Carries its own lower ceiling.
detail string required —

FailureExpectation#

Field Type Required Notes
retryable boolean required Whether retrying the same operation can ever succeed.
disclosable boolean required Whether the refusal may say what actually happened to the caller.
why string required —

FailureMode#

ts
(typeof FAILURE_MODES)[number];

failureModeFor#

The failure mode an open-failure is an instance of.

ts
failureModeFor(failure: OpenFailure): FailureMode

FailurePolicy#

ts
(typeof FAILURE_POLICIES)[number];

FailureSignals#

What the delivery attempt observed, as facts rather than as a conclusion.

Field Type Required Notes
parsed boolean required —
versionSupported boolean required —
authorized boolean required —
invariantViolated boolean required A domain invariant the handler refused on.
dependencyMissing boolean required A referenced entity the handler needs and cannot find.
deterministic boolean required The same failure with the same code on every attempt.
transient boolean required —
attempts number required —
transientAttemptCeiling number required Attempts past which "transient" stops being a description.

FALSE_POSITIVE_SIGNALS#

Values: restore-requested, reference-created-for-a-deleted-blob, broken-render-reported, derivative-regenerated

FalsePositive#

Field Type Required Notes
blobId string required —
signal FalsePositiveSignal required —
at Instant required —

FalsePositiveSignal#

ts
(typeof FALSE_POSITIVE_SIGNALS)[number];

FENCE_REFUSALS#

Values: wrong-job, lease-expired, fencing-token-superseded

FencedWrite#

Proof that a write was checked against the store's fence.

Field Type Required Notes
jobId string required —
workerId string required —
fencingToken number required —
checkedAt Instant required —
[fencedWrite] true required Type-only, following identity.ts and S3.6's delivery receipt: a declare const emits nothing, so the brand costs no import-time work — which "sideEffects": false promises and the S1.2.f emitted-module scan enforces — while making the interface unconstructable outside this module.

FenceInput#

Field Type Required Notes
lease JobLease required —
jobId string required —
now Instant required —
policy HeartbeatPolicy required —
storeFencingToken number required The highest fencing token the STORE has handed out for this job.

FenceOutcome#

ts
| { readonly ok: true; readonly write: FencedWrite }
| { readonly ok: false; readonly refusal: FenceRefusal; readonly detail: string }

FenceRefusal#

ts
(typeof FENCE_REFUSALS)[number];

fenceWrite#

Check a lease at the moment of writing (S3.9.c).

ts
fenceWrite(input: FenceInput): FenceOutcome

FENCING_SOURCES#

Where a fencing token may come from.

Values: store-sequence, attempt-counter

FencingSource#

ts
(typeof FENCING_SOURCES)[number];

FIELD_OPERATIONS#

What somebody has declared they need to DO with the field.

Values: read-back, equality-match, range-or-sort, prefix-search, full-text-search, aggregate-count, display-partial, verify-only, join-key

FieldCipher#

The adapter this module is written against.

FieldDerivative#

Field Type Required Notes
name string required —
kind DerivativeKind required —
storedAs ProtectionStrategy | 'plaintext' — ProtectionStrategy required How the derivative itself is stored. plaintext is the honest spelling.

FieldOperation#

ts
(typeof FIELD_OPERATIONS)[number];

FieldProtection#

Field Type Required Notes
fieldId string required —
entity string required —
column string required —
sensitivity SensitivityClass required —
strategy ProtectionStrategy required —
operations readonly FieldOperation[] — FieldOperation required What this field is used for. The matrix is derived from this.
derivatives readonly FieldDerivative[] — FieldDerivative required —
estimatedCardinality number | null required Roughly how many distinct values the field takes, or null when unknown. Only meaningful for deterministic-token, and null there is its own fault.
resolutionPurposes readonly string[] required Purposes a vault reference may be resolved for. Empty for other strategies.

FINDING_STATES#

Values: open, reconciling, closed, reopened

FindingState#

ts
(typeof FINDING_STATES)[number];

flattenPlan#

Every node of the plan, root first.

ts
flattenPlan(plan: PlanNode): readonly PlanNode[]

foldBatch#

Fold one bounded batch (S3.12.f).

ts
foldBatch(results: readonly BatchItemResult[], queued: readonly string[], batchSize: number): BatchReport

foldDeliveries#

ts
foldDeliveries(deliveries: readonly Delivery[], ordering: EventKindOrdering): ProjectionSnapshot

FORBIDDEN_CAPABILITIES#

The ambient capabilities a guard may not reach for while it runs.

Values: Date.now, new Date, Math.random, fetch, crypto.getRandomValues

FORBIDDEN_METRIC_LABELS#

Label names that make a probe metric a schema dump, a cardinality bomb, or both.

Values: table, column, constraint, index, object, schema_version, version, migration, dsn, database_url, host, query, sql, tenant

ForbiddenCapability#

ts
(typeof FORBIDDEN_CAPABILITIES)[number];

GATE_AUDIENCES#

Who the checked output is FOR, which is not the same as who runs the check.

Values: internal, customer, public, regulator

GATE_DEFINITION_VIOLATION_KINDS#

Values: no-lifecycle-stage, no-audience, version-not-a-positive-integer, shadow-without-a-reason, retired-without-a-reason, retired-replaced-by-itself, severity-override-for-a-stage-the-gate-does-not-run-at, duplicate-severity-override, owner-role-unassigned, override-authority-is-the-accountable-owner, escalation-is-the-accountable-owner, evidence-with-no-freshness-budget, evidence-range-inverted, duplicate-evidence-type, blocking-gate-with-no-required-evidence, quorum-without-a-number, quorum-larger-than-the-references, composition-references-itself, standalone-with-references, composition-without-references, reason-is-not-a-key, blocker-without-a-remediation, blocker-without-an-appeal, waiver-granted-by-the-accountable-owner, waiver-with-no-duration, appeal-with-no-clock, fallback-verdict-is-passing

GATE_DIMENSIONS#

S3.5.f — the seven things a release console asks about a gate.

GATE_INDEXES#

S3.5.f — gates: triage, the fold’s read, freshness, and comparability.

GATE_REGISTRY_VIOLATION_KINDS#

Values: duplicate-gate-id, composition-names-an-unknown-gate, composition-cycle, retired-gate-still-composed, replacement-does-not-exist

GATE_RUN_VIOLATION_KINDS#

Values: run-without-an-id, result-for-another-gate, gate-version-not-a-positive-integer, finished-before-it-started, passed-without-evaluating, required-evidence-missing, evidence-version-outside-the-constraint, duplicate-evidence-record, evidence-recorded-after-the-run-finished, ran-under-another-policy-version, reason-is-not-a-key, not-evaluated-with-readings

GATE_SEVERITIES#

What a non-passing result MEANS for the workflow.

Values: blocker, warning, informational

GATE_TYPES#

Values: quality, safety, rights, compliance, technical, editorial, operational

GATE_VERDICTS#

The verdict vocabulary, re-exported so a caller need not reach into S1.9.

GateApplicability#

Field Type Required Notes
domains readonly string[] required Empty means every domain in the deployment.
objectKinds readonly string[] required —
lifecycleStages readonly string[] required The lifecycle stages this gate runs at. Never empty.
audiences readonly GateAudience[] — GateAudience required —

GateAudience#

ts
(typeof GATE_AUDIENCES)[number];

GateComposition#

Field Type Required Notes
rule CompositionRule required —
references readonly string[] required The gate ids this one composes. Empty for standalone.
quorum number | null required Required for quorum; null otherwise.

GateContribution#

Field Type Required Notes
evaluator GateEvaluator<TSubject, TRaw> — GateEvaluator required —
policy GatePolicy<TRaw> — GatePolicy required —

GateDefinition#

Field Type Required Notes
gateId string required —
type GateType required —
version number required Integer, >= 1. Bumped when the gate's MEANING changes, not its code.
applicability GateApplicability required —
lifecycle GateLifecycle required —
defaultSeverity GateSeverity required —
severityByStage readonly StageSeverity[] — StageSeverity required Per-stage overrides. Every stage named must be one the gate applies at.
ownership GateOwnership required —
requiredEvidence readonly RequiredEvidence[] — RequiredEvidence required —
whenEvidenceUnavailable UnavailableBehaviour required —
policy GatePolicyReference required —
composition GateComposition required —
presentation GatePresentation required —
describe string required —

GateDefinitionViolation#

Field Type Required Notes
kind GateDefinitionViolationKind required —
subject string required —
detail string required —

GateDefinitionViolationKind#

ts
(typeof GATE_DEFINITION_VIOLATION_KINDS)[number];

GateEvaluator#

Field Type Required Notes
gateId string required —
evaluate (input: GateInput<TSubject>) => GateOutcome<TRaw> | Promise<GateOutcome<TRaw>> — GateInput, GateOutcome required —

GateFailure#

Field Type Required Notes
failureClass FailureClass required —
message string required —
retryable boolean required —
remediation Remediation required —

GateFinding#

Field Type Required Notes
code string required —
severity 'info' | 'warning' | 'error' required —
messageKey string required —
anchor StableAnchor | null — StableAnchor required Where in the subject the finding is, or null when it is about the whole.

GateInput#

Field Type Required Notes
subject TSubject required —
tenant TenantId | null — TenantId required —
actor ActorRef required —
requestedAt Instant required —
deadlineMs number required The deadline the evaluator must answer by.

GateLifecycle#

Whether the gate is on, watching, or gone.

ts
| { readonly state: 'enabled' }
| { readonly state: 'shadow'; readonly since: string; readonly why: string }
| { readonly state: 'retired'; readonly retiredIn: number; readonly replacedBy: string | null; readonly reason: string; }

GateMeasurement#

Field Type Required Notes
value TRaw required The domain's own measurement. The kit never interprets it.
measuredAt Instant required —
freshnessSeconds number required How long the measurement may be trusted, in seconds.
provenance GateProvenance required —

GateMetadata#

Field Type Required Notes
extensionPoint 'gate' required —
gateId string required —
onStale NonPassingVerdict required —
onNotConfigured NonPassingVerdict required —
onFailed NonPassingVerdict required —
deterministic boolean required —

GateObservation#

What the evaluator SAW, which is not what it concluded.

ts
| { readonly kind: 'evaluated'; readonly readings: readonly ScoredDimension[] }
| { readonly kind: 'not-evaluated'; readonly state: NonValueState; readonly detail: string }

GateOutcome#

ts
| { readonly outcome: 'evaluated'; readonly measurement: GateMeasurement<TRaw> }
| { readonly outcome: 'not-configured'; readonly capability: CapabilityId; readonly reason: string; }
| { readonly outcome: 'failed'; readonly failure: GateFailure }

GateOwnership#

Five roles, because in practice they are five different teams.

Field Type Required Notes
accountable string required —
evaluator string required —
remediation string required —
overrideAuthority string required —
escalation string required —

GatePolicy#

Field Type Required Notes
policyId string required —
version SemanticVersion required —
decide (measurement: GateMeasurement<TRaw>) => PolicyDecision — GateMeasurement, PolicyDecision required Only ever called with a fresh, successfully evaluated measurement.
onStale NonPassingVerdict required —
onNotConfigured NonPassingVerdict required —
onFailed NonPassingVerdict required —

GatePolicyReference#

Field Type Required Notes
policyId string required —
policyVersion number required —
onStale NonPassingVerdict required The verdict each fallback produces, in the kit's vocabulary.
onNotConfigured NonPassingVerdict required —
onFailed NonPassingVerdict required —
deterministic boolean required —

GatePresentation#

Field Type Required Notes
reasonKey string required A translation key. A sentence here is text no translator receives.
affects readonly StableAnchor[] — StableAnchor required Where in the subject the failure is, when the gate can say.
affectedFields readonly (readonly string[])[] required Field paths, for a gate that can name them without an anchor.
remediation Remediation required —
docsUrl string | null required —
recompute RecomputeTrigger required —
appeal AppealPath | null — AppealPath required —
waiver WaiverPolicy | null — WaiverPolicy required —

GateProvenance#

Where a measurement came from, in enough detail to reproduce or distrust it.

Field Type Required Notes
evaluatorId string required —
evaluatorVersion SemanticVersion required —
inputDigest Sha256Hex required Digest of exactly what was measured, not of the whole entity.
ruleset string | null required The named ruleset or model, or null when the rule is the code itself.
deterministic boolean required —
sources readonly ProvenanceSource[] — ProvenanceSource required —

GateRegistryViolation#

Field Type Required Notes
kind GateRegistryViolationKind required —
subject string required —
detail string required —

GateRegistryViolationKind#

ts
(typeof GATE_REGISTRY_VIOLATION_KINDS)[number];

GateResult#

Field Type Required Notes
gate EligibilityGate required —
passed boolean required —
detail string required —

GateRunAggregate#

Field Type Required Notes
subjectRevision RevisionId required —
lifecycleStage string required —
audience GateAudience required —
policyId string required —
policyVersion number required —
at Instant required —
eligibility ReleaseEligibility required —
satisfaction Trivalent required —
components readonly Component[] — Component required Every applicable gate, in gate id order. Never filtered.
counts Readonly<Record<ComponentEffect, number>> — ComponentEffect required —
tolerated readonly string[] required Blocking components the strategy permitted. Empty under all-of.
faults readonly AggregateFault[] — AggregateFault required —

GateRunProvenance#

Field Type Required Notes
runId string required —
gateId string required —
gateVersion number required The gate version this answers. A result for v1 does not answer v2.
targetRevision RevisionId required —
targetHash Sha256Hex required —
evaluatorId string required —
evaluatorVersion number required —
policyId string required —
policyVersion number required —
trigger RunTrigger required —
startedAt Instant required —
finishedAt Instant required —
evidence readonly EvidenceRecord[] — EvidenceRecord required —

GateRunResult#

Field Type Required Notes
provenance GateRunProvenance required —
observation GateObservation required —
verdict VerdictName required The evaluator's conclusion, in S1.9's vocabulary.
reasonKey string required A translation key. The sentence a blocked person reads is not written here.
detail string required —

GateRunViolation#

Field Type Required Notes
kind GateRunViolationKind required —
subject string required —
detail string required —

GateRunViolationKind#

ts
(typeof GATE_RUN_VIOLATION_KINDS)[number];

GateSeverity#

ts
(typeof GATE_SEVERITIES)[number];

GateStatusRow#

Field Type Required Notes
gateId string required —
lastRunSequence number required —
stale boolean required —
staleSince Instant | null — Instant required —
waived boolean required —
waiverId string | null required —

GateType#

ts
(typeof GATE_TYPES)[number];

gateVerdict#

Turn an evaluator outcome into a verdict, applying the kit's own rules first.

ts
gateVerdict(outcome: GateOutcome<TRaw>, policy: GatePolicy<TRaw>, now: Instant): GateVerdict

GateVerdict#

Field Type Required Notes
gateId string required —
verdict VerdictName required —
decidedBy 'policy' | 'kit-staleness' | 'kit-absence' | 'kit-failure' required Whether the DOMAIN decided or the KIT decided for it.
reason string required —
findings readonly GateFinding[] — GateFinding required —
remediation Remediation | null — Remediation required —
provenance GateProvenance | null — GateProvenance required —
measuredAt Instant | null — Instant required —
stale boolean required —

GRAPH_FAULT_KINDS#

Values: edge-names-an-unknown-job, cross-tenant-edge, cross-workbench-edge, self-edge, duplicate-edge, cycle, orphan-node, depth-exceeded, fan-out-exceeded, dependency-outside-the-sibling-set, mixed-weight-units, zero-weight-child, parent-with-no-children, edges-changed-after-execution-began

graphDepth#

Longest path from the root over parent/child edges. 1 for the root alone.

ts
graphDepth(graph: JobGraph): number

graphFanOut#

The most children any one parent has.

ts
graphFanOut(graph: JobGraph): number

GraphFault#

Field Type Required Notes
kind GraphFaultKind required —
subject string required —
detail string required —

GraphFaultKind#

ts
(typeof GRAPH_FAULT_KINDS)[number];

graphFaults#

Check a graph (S3.10.b).

ts
graphFaults(graph: JobGraph, options: { readonly previousEdges: readonly JobEdge[] | null } = { previousEdges: null }): readonly GraphFault[]

GraphOptions#

Field Type Required Notes
registeredGuards readonly string[] required Guard ids the host has registered. A transition may name only these.

GraphRetryPlan#

Field Type Required Notes
children readonly ChildRetryPlan[] — ChildRetryPlan required —
rerun readonly string[] required —
reused readonly string[] required —
note string required —

graphView#

Build the screen an operator opens during an incident (S3.10.g).

ts
graphView(input: { readonly graph: JobGraph; readonly parentId: string; readonly progress: readonly ChildProgress[]; readonly outcomes: readonly ChildOutcomeRecord[]; readonly spendUnit: string; }): GraphView

GraphView#

Field Type Required Notes
parentId string required —
nodes readonly GraphViewNode[] — GraphViewNode required —
outcome ParentOutcome required —
progress AggregateProgress required —
rootBlockers readonly string[] required —
criticalPathSeconds number required —
criticalPath readonly string[] required —
totalSpent number required —
spendUnit string required —

GraphViewNode#

Field Type Required Notes
childId string required —
ordinal number required —
state JobState required —
required boolean required —
weight number required —
dependsOn readonly string[] required —
failureCode string | null required A stable code, never a message. A message is where a payload rides in (S3.9.h).
spent number required —

Guard#

Field Type Required Notes
guardId string required —
describe string required What it checks, in one clause, for the reader of a blocked transition.
blocking boolean required Blocking guards refuse a transition; advisory ones only warn.
maxEvidenceAgeSeconds number | null required How old consulted evidence may be. Null when the guard reads none.
evaluate (input: GuardInput<TStage, TSubject>) => GuardAnswer — GuardAnswer, GuardInput required —

GUARD_REMEDIATIONS#

What a caller should do about it.

Values: none, revise-subject, produce-evidence, refresh-evidence, retry-later, contact-owner, not-applicable

GUARD_STATUSES#

The seven answers, and why there are seven rather than two.

Values: pass, fail, stale, missing, unavailable, unsupported, evaluator-error

GuardAnswer#

What a guard hands back; the harness adds the provenance around it.

Field Type Required Notes
status GuardStatus required —
reasonKey string required —
remediation GuardRemediation optional —
consulted readonly EvidenceRef[] — EvidenceRef optional The subset of the input evidence this answer actually rests on.

GuardDecision#

Field Type Required Notes
allowed boolean required True only when every blocking guard passed.
blockers readonly GuardResult[] — GuardResult required Results that refuse the transition, in guard-id order.
warnings readonly GuardResult[] — GuardResult required Results worth showing that do not refuse it.
results readonly GuardResult[] — GuardResult required Every result, always, so a caller can record what was consulted.
consultedEvidence readonly EvidenceRef[] — EvidenceRef required Union of every evidence ref any guard read, deduplicated by id+version.
indeterminate boolean required True when at least one guard could not answer.
skipped readonly string[] required Guards not evaluated because a blocker short-circuited the run.

GuardInput#

Everything a guard is allowed to know.

Field Type Required Notes
subject TSubject required —
subjectId string required —
revision string required The revision the decision is about. A decision without one is unpinnable.
from TStage required —
to TStage required —
transitionId string required —
actor ActorRef required —
scopes readonly string[] required —
evidence readonly EvidenceRef[] — EvidenceRef required —
policyId string required The policy in force, by version, so two policies are two decisions.
policyVersion number required —
now Instant required A VALUE, not a source: the instant the host observed before evaluating.

GuardOutcome#

A guard's answer.

ts
| { readonly decision: 'allow' }
| { readonly decision: 'block'; readonly reasonKey: string; readonly remediation: Remediation }
| { readonly decision: 'indeterminate'; readonly reason: string }

GuardPurityError#

GuardRemediation#

ts
(typeof GUARD_REMEDIATIONS)[number];

GuardResult#

Field Type Required Notes
guardId string required —
status GuardStatus required —
reasonKey string required A translation key, never a sentence: this reaches a user interface.
remediation GuardRemediation required —
consultedEvidence readonly EvidenceRef[] — EvidenceRef required S2.2.e — every evidence ref the guard actually read, with its version.
policyId string required —
policyVersion number required —

GuardStatus#

ts
(typeof GUARD_STATUSES)[number];

GuardVerdict#

A guard's answer about one attempted transition.

ts
| { readonly guardId: string; readonly verdict: 'pass' }
| { readonly guardId: string; readonly verdict: 'block'; readonly reasonKey: string }
| { readonly guardId: string; readonly verdict: 'indeterminate'; readonly reason: string }

HEARTBEAT_FAULT_KINDS#

Values: heartbeat-not-faster-than-lease, one-missed-beat-loses-the-lease, lease-not-longer-than-the-skew, lease-shorter-than-the-work-between-checkpoints

HeartbeatFault#

Field Type Required Notes
kind HeartbeatFaultKind required —
subject string required —
detail string required —

HeartbeatFaultKind#

ts
(typeof HEARTBEAT_FAULT_KINDS)[number];

heartbeatFaults#

Check the cadence itself (S3.9.c).

ts
heartbeatFaults(policy: HeartbeatPolicy): readonly HeartbeatFault[]

HeartbeatPolicy#

Field Type Required Notes
leaseSeconds number required —
heartbeatSeconds number required —
clockSkewSeconds number required How far apart two clocks in this system may be.
maxWorkBetweenCheckpointsSeconds number required The longest a stage may run between two checkpoints.

HOLD_VIOLATION_KINDS#

Values: no-authority, no-matter-reference, released-with-no-releaser, released-before-it-started, no-review-date-on-an-open-hold, review-after-the-hold-ends, ends-before-it-starts

holdApplies#

Whether a hold covers this subject, at this instant.

ts
holdApplies(hold: LegalHoldRecord, at: Instant, subject: { readonly tenantId: string; readonly workspaceId: string; readonly entityId: string }): boolean

HoldViolation#

Field Type Required Notes
kind HoldViolationKind required —
subject string required —
detail string required —

HoldViolationKind#

ts
(typeof HOLD_VIOLATION_KINDS)[number];

HostIsolation#

Field Type Required Notes
surface IsolationSurface required —
allowsNetwork boolean required —
allowsStorage boolean required —
permittedOrigins readonly string[] required Origins permitted to frame or be framed. Empty is refused for iframe, and * is refused everywhere: a frame that any origin may embed can be embedded by one that then reads whatever the frame posts back.

HumanGateRequirement#

Field Type Required Notes
gateId string required —
role string required —
scope SignoffScope required —
quorum number required How many independent signatures. One is legitimate and common.
order SignoffOrder required —
independence readonly IndependenceDimension[] — IndependenceDimension required —
validForHours number required How long a completed signoff stands before it has to be taken again.
requiresStepUp boolean required Risk high enough to require a step-up performed for this decision.
acceptedStepUpMethods readonly StepUpMethod[] — StepUpMethod required The strongest authentication method accepted when a step-up is required.

HumanPresence#

A presence that survived every check. Only produces one.

Field Type Required Notes
actorId string required —
tenantId string required —
roles readonly string[] required —
authenticatedAt Instant required —
steppedUpAt Instant | null — Instant required —
stepUpMethod StepUpMethod | null — StepUpMethod required —

IDEMPOTENCY_STATES#

Values: claimed, running, completed, failed

IdempotencyRecord#

Field Type Required Notes
scope IdempotencyScope required —
requestDigest Sha256Hex required The canonical digest of the request body, headers that matter, and target.
state IdempotencyState required —
claimedAt Instant required —
completedAt Instant | null — Instant required —
resultRef string | null required Present only when completed.
irreversible boolean required Whether re-running this operation would cause a second real-world effect.
expiresAt Instant required —

IdempotencyScope#

Everything the uniqueness constraint is over.

Field Type Required Notes
tenantId string required —
clientId string required —
operation string required —
operationVersion number required —
key string required —
targetId string | null required Null for operations that name no target. Part of the constraint when present.

IdempotencyState#

ts
(typeof IDEMPOTENCY_STATES)[number];

IDENTIFIER_INDEXES#

S3.5.g — identifiers: exact, unique, and scoped by the system that issued them.

identifierFaults#

Identifier lookups, checked apart from everything else (S3.5.g).

ts
identifierFaults(lookups: readonly IdentifierLookup[], indexes: readonly IndexDeclaration[]): readonly IndexFault[]

IdentifierLookup#

An identifier and what it is unique with respect to.

Field Type Required Notes
entity string required —
columns readonly string[] required The columns the caller supplies.
scopedBy readonly string[] required The columns the uniqueness must additionally be over.
why string required —

Importer#

Field Type Required Notes
plan (source: TSource, context: ExecutionContext) => Promise<ImportPlan<TPlan>> — ExecutionContext, ImportPlan required Side-effect free: it reads the source and computes what WOULD happen.
validate (plan: ImportPlan<TPlan>) => Promise<ImportValidation> — ImportPlan, ImportValidation, plan required —
execute ( plan: ImportPlan<TPlan>, validation: ImportValidation, context: ExecutionContext ) => Promise<ImportExecution<TResult>> — ExecutionContext, ImportExecution, ImportPlan, ImportValidation, plan required —
reconcile (execution: ImportExecution<TResult>) => Promise<Reconciliation> — ImportExecution, Reconciliation required —

ImporterContribution#

Field Type Required Notes
importer Importer<TSource, TPlan, TResult> — Importer required —

ImporterMetadata#

Field Type Required Notes
extensionPoint 'importer' required —
formats readonly string[] required —

ImportExecution#

Field Type Required Notes
planDigest Sha256Hex required —
idempotencyKey string required —
attempted number required —
applied number required —
skipped number required —
failed number required —
result TResult required —

ImportPlan#

Field Type Required Notes
planId string required —
plannedAt Instant required —
sourceDigest Sha256Hex required Digest of the SOURCE the plan was computed from.
planDigest Sha256Hex required Digest of the plan itself, which is what approval is bound to.
operations readonly PlannedOperation[] — PlannedOperation required —
detail TPlan required —

ImportValidation#

Field Type Required Notes
planDigest Sha256Hex required —
verdict 'approved' | 'rejected' required —
findings readonly GateFinding[] — GateFinding required —

InboxClaim#

ts
| { readonly result: 'process'; readonly detail: string }
| { readonly result: 'already-processed'; readonly outcome: ProcessingOutcome; readonly detail: string; }
| { readonly result: 'in-flight'; readonly detail: string }
| { readonly result: 'conflicting-body'; readonly detail: string }
| { readonly result: 'stale-processing-version'; readonly detail: string }
| { readonly result: 'held'; readonly detail: string }

inboxKey#

The receipt's key as a single string.

ts
inboxKey(key: InboxKey): string

InboxKey#

What one consumer's receipt is unique over.

Field Type Required Notes
tenantId string required —
consumer string required The projection or handler doing the processing.
producer string required —
eventId string required —
eventVersion number required —
subject string required The ordering partition, which is the producer's subject.

InboxParityFault#

Field Type Required Notes
kind InboxParityFaultKind required —
subject string required —
detail string required —

InboxParityFaultKind#

ts
(typeof PARITY_FAULT_KINDS)[number];

InboxReceipt#

Field Type Required Notes
key InboxKey required —
payloadHash Sha256Hex required The body's hash, compared before the state (decision 2).
sequence number required The producer's position for this subject.
state ReceiptState required —
processingVersion number required The version of the projection logic that wrote this receipt (decision 5).
attempt number required —
firstSeenAt Instant required —
completedAt Instant | null — Instant required —
outcome ProcessingOutcome | null — ProcessingOutcome required What the processing produced, for a duplicate to be answered with.
lastError string | null required —

InboxRetryDecision#

Field Type Required Notes
retry boolean required —
quarantine boolean required —
detail string required —

INDEPENDENCE_DIMENSIONS#

What the reviewers must be independent OF.

Values: author, previous-signer, declared-conflict, same-team

IndependenceDimension#

ts
(typeof INDEPENDENCE_DIMENSIONS)[number];

INDEX_BUDGET#

INDEX_FAULT_KINDS#

Values: unregistered-entity, index-serves-no-query, index-claims-a-query-it-cannot-serve, critical-query-uncovered, critical-query-sorted-outside-the-index, critical-query-filtered-after-the-index, scope-column-not-leading, scope-column-on-an-unscoped-entity, sort-is-not-total, redundant-left-prefix, text-prefix-without-a-c-collation, identifier-lookup-not-unique, identifier-uniqueness-not-scoped, sensitive-column-indexed, index-budget-exceeded, declined-index-for-an-interactive-query, no-profile-declared

IndexColumn#

Field Type Required Notes
column string required —
direction SortDirection required —
collation Collation required —

IndexDeclaration#

Field Type Required Notes
name string required —
entity string required —
columns readonly IndexColumn[] — IndexColumn required —
include readonly string[] required Payload columns carried for an index-only scan; they cannot be filtered or sorted on.
unique boolean required —
where readonly QueryPredicate[] | null — QueryPredicate required The partial predicate, as predicates rather than SQL text, so that whether a query implies it is decidable instead of a matter of reading two strings.
serves readonly string[] required The workload query ids this index exists for. Never empty.
why string required —

IndexFault#

Field Type Required Notes
kind IndexFaultKind required —
subject string required —
detail string required —

IndexFaultKind#

ts
(typeof INDEX_FAULT_KINDS)[number];

indexFaults#

Every static complaint the index plan admits, in one pass.

ts
indexFaults(input: IndexPlanInput): readonly IndexFault[]

IndexPlanInput#

Field Type Required Notes
workload readonly WorkloadQuery[] — WorkloadQuery required —
indexes readonly IndexDeclaration[] — IndexDeclaration required —
profiles readonly VolumeProfile[] — VolumeProfile required —
register readonly EntityRegistration[] — EntityRegistration required —
declined readonly DeclinedIndex[] — DeclinedIndex optional —

Ingredient#

An input this blob was made from — by reference and digest, never a copy.

Field Type Required Notes
blobId string required —
digest ByteDigest required —
role string required —

INHERITANCE_FAULT_KINDS#

Values: child-in-another-tenant, child-in-another-workspace, parent-row-missing, join-row-spans-two-tenants, scope-column-null-on-a-scoped-entity

InheritanceFault#

Field Type Required Notes
kind InheritanceFaultKind required —
subject string required —
detail string required —

InheritanceFaultKind#

ts
(typeof INHERITANCE_FAULT_KINDS)[number];

inheritanceFaults#

Check that every child row sits where its parent does (S3.2.d).

ts
inheritanceFaults(rows: readonly ScopedRow[], register: readonly EntityRegistration[]): readonly InheritanceFault[]

InspectorField#

Field Type Required Notes
fieldId string required —
labelKey string required —
editable boolean required —
editScope string | null required Required when editable; a field editable by everyone is not a field.

INTAKE_REFUSALS#

Values: malformed-envelope, unknown-event-kind, unsupported-event-version, cross-tenant-event, unauthorized-producer, payload-hash-mismatch

IntakeDecision#

ts
| { readonly accepted: true; readonly note: string }
| { readonly accepted: false; readonly refusal: IntakeRefusal; readonly detail: string }

IntakeRefusal#

ts
(typeof INTAKE_REFUSALS)[number];

IntakeRequest#

Field Type Required Notes
key InboxKey required —
eventKind string required —
payloadHash Sha256Hex required —
computedHash Sha256Hex required The hash the consumer computed over the body it actually received.
supported Readonly<Record<string, readonly number[]>> required Event kinds and the versions of each this consumer understands.
trustedProducers readonly string[] required Producers this consumer accepts events from.
consumerTenantId string required The tenant the consumer is running for.
envelopeIsWellFormed boolean required —

INTROSPECTION_CHECKS#

Checks that read the catalogue.

Values: schema-objects, extensions, permissions

isEligible#

ts
isEligible(results: readonly GateResult[]): boolean

isLabelKey#

ts
isLabelKey(value: unknown): value is string

isLegalTransition#

Whether an edge exists at all, for a caller deciding whether it needs a bypass.

ts
isLegalTransition(graph: StageGraph<TStage>, from: NoInfer<TStage>, transitionId: string): boolean

ISOLATION_SCOPES#

Values: event, subject, partition, consumer

ISOLATION_SURFACES#

Values: in-process, iframe, worker

IsolationDecision#

Field Type Required Notes
scope IsolationScope required —
detail string required —

isolationFor#

How much of the stream one poisoned event stops (S3.8.c).

ts
isolationFor(request: IsolationRequest): IsolationDecision

IsolationRequest#

Field Type Required Notes
condition PoisonCondition required —
commutes boolean required Whether the event kind may be applied out of order (S3.7.d).
affectsEveryEvent boolean required Whether the failure is a property of the consumer rather than the event.

IsolationScope#

ts
(typeof ISOLATION_SCOPES)[number];

IsolationSurface#

ts
(typeof ISOLATION_SURFACES)[number];

isRequired#

Whether the parent's success depends on this child's.

ts
isRequired(edge: JobEdge): boolean

isSealedField#

Whether a value is a sealed envelope, structurally. Never a guess at a string.

ts
isSealedField(value: unknown): value is SealedField

isTerminalJobState#

ts
isTerminalJobState(state: JobState): boolean

JOB_CLAIM_REFUSALS#

Values: not-queued, not-yet-runnable, queue-not-served, tenant-not-permitted, attempts-exhausted, deadline-passed, deadline-inside-this-attempt, budget-would-be-exceeded, fencing-token-not-monotonic, fencing-token-not-from-the-declared-source

JOB_CREATION_FAULT_KINDS#

Values: not-queued-at-creation, attempt-already-started, no-idempotency-key, idempotency-key-not-tenant-scoped, no-input-reference, no-input-hash, runnable-before-enqueued, deadline-before-enqueued, deadline-inside-one-attempt, budget-ceiling-not-positive, budget-already-spent, attempt-cost-exceeds-ceiling, priority-outside-the-band, max-attempts-not-positive

JOB_FAILURE_KINDS#

Why an attempt ended.

Values: input-invalid, dependency-unavailable, rate-limited, lease-lost, budget-exhausted, deadline-passed, handler-defect, unknown-outcome

JOB_RETRY_DECISIONS#

Values: retry, defer, dead-letter

JOB_STATES#

The states a job row may be in.

Values: queued, running, cancelling, cancelled, succeeded, dead-lettered

jobBackoffSeconds#

Exponential backoff with proportional jitter (S3.9.g).

ts
jobBackoffSeconds(attempt: number, policy: JobRetryPolicy, jitter = 0): number

JobBudget#

What a job is allowed to spend, in a unit it names.

Field Type Required Notes
unit string required Named, because a "cost" with no unit is a number somebody will compare to another number.
ceiling number required —
spent number required —

JobCheckpoint#

Field Type Required Notes
jobId string required —
stage string required —
checkpointVersion number required The SHAPE version of the cursor. A v2 worker reading a v1 cursor is not resuming.
producedByTypeVersion number required —
fencingToken number required Which lease wrote it. A checkpoint above your token means YOU are the zombie.
cursor string required Opaque to the kit. Where the stage got to, in whatever terms the stage uses.
at Instant required —

JobClaimDecision#

ts
| { readonly claimed: true; readonly lease: JobLease; readonly note: string }
| { readonly claimed: false; readonly refusal: JobClaimRefusal; readonly detail: string }

JobClaimRefusal#

ts
(typeof JOB_CLAIM_REFUSALS)[number];

JobClaimRequest#

Field Type Required Notes
job JobRecord required —
workerId string required —
now Instant required —
leaseSeconds number required —
fencingSource FencingSource required Where the token came from. Declared, so the monotonicity claim is checkable.
fencingToken number required The token the store minted for THIS claim, from one of FENCING_SOURCES.
previousFencingToken number required The highest token ever handed out for this job. 0 if it has never been claimed.
servedQueues readonly string[] required —
permittedTenants readonly string[] required —

JobCreationFault#

Field Type Required Notes
kind JobCreationFaultKind required —
subject string required —
detail string required —

JobCreationFaultKind#

ts
(typeof JOB_CREATION_FAULT_KINDS)[number];

jobCreationFaults#

Check a job at creation (S3.9.a).

ts
jobCreationFaults(job: JobRecord): readonly JobCreationFault[]

JobEdge#

Field Type Required Notes
parentId string required —
childId string required —
ordinal number required Position among siblings. Declared, so the order does not depend on insertion.
dependsOn readonly string[] required Sibling children that must be terminal before this one may start.
weight number required How much of the parent this child is, in weightUnit.
weightUnit string required —
onChildFailure FailurePolicy required —
cancellation CancellationPropagation required —

JobFailure#

Field Type Required Notes
kind JobFailureKind required —
code string required —
message string required —

JobFailureKind#

ts
(typeof JOB_FAILURE_KINDS)[number];

JobGraph#

Field Type Required Notes
graphId string required —
tenantId string required —
workbenchId string required —
rootId string required —
nodes readonly JobGraphNode[] — JobGraphNode required —
edges readonly JobEdge[] — JobEdge required —
maxDepth number required —
maxFanOut number required —

JobGraphNode#

Field Type Required Notes
jobId string required —
tenantId string required —
workbenchId string required —
state JobState required —
inputHash Sha256Hex required What this node would run over. S3.10.f decides reuse by comparing it.
typeVersion number required —
expectedSeconds number required What one run of this node is expected to take. Used for the critical path.

JobLease#

Field Type Required Notes
jobId string required —
workerId string required —
attempt number required —
fencingToken number required Strictly increasing across claims of THIS job. Compared at every write.
grantedAt Instant required —
expiresAt Instant required —

jobProgress#

Fold the stages into one number (S3.9.d).

ts
jobProgress(stages: readonly StageProgress[]): JobProgress

JobProgress#

Field Type Required Notes
completed number required —
total number | null required null as soon as any stage's total is unknown.
determinate boolean required False when a denominator is missing. A sum with a hole in it is an invented number.
fraction number | null required 0..1 or null — exactly the wire envelope's field (S1.5).

JobRecord#

Field Type Required Notes
jobId string required —
tenantId string required —
type string required —
typeVersion number required The handler contract version this job was ENQUEUED against; S3.9.e reads it on resume.
requestedBy string required —
queue string required —
priority number required —
inputRef string required A reference to the immutable inputs — never a copy, for S3.8.b's reason.
inputHash Sha256Hex required What those inputs hashed to. "Immutable" is a promise until something checks it.
idempotencyKey string required —
budget JobBudget required —
estimatedAttemptCost number required What one attempt is expected to cost, in the budget's unit. Charged before it runs.
expectedAttemptSeconds number required —
deadline Instant | null — Instant required —
enqueuedAt Instant required —
runnableAt Instant required —
state JobState required —
attempt number required Attempts STARTED — 0 until something claims it. The wire envelope (S1.5) is 1-based for the mirror-image reason: attempt 0 would describe a job that never ran, which is not an update.
maxAttempts number required —

JobRetryContext#

Field Type Required Notes
job JobRecord required —
failure JobFailure required —
delivery EffectDelivery required —
now Instant required —
policy JobRetryPolicy required —
jitter number required —
queueRunning number required How many jobs of this queue are running right now.
queueConcurrency number required —

JobRetryDecision#

Field Type Required Notes
decision JobRetryDecisionKind required —
runnableAt Instant | null — Instant required —
reason string required —

JobRetryDecisionKind#

ts
(typeof JOB_RETRY_DECISIONS)[number];

JobRetryPolicy#

Field Type Required Notes
baseSeconds number required —
maxSeconds number required —
jitterFraction number required Fraction of the computed delay to spread over. A constant stops spreading at the cap.
maxAgeSeconds number required How long a job may go on existing, however many attempts are left.
unknownOutcomeMaxAttempts number required A lower ceiling for unknown outcomes: each attempt may be a second effect.

JobState#

ts
(typeof JOB_STATES)[number];

judgePlan#

Judge one captured plan against the query it was captured for.

ts
judgePlan(input: PlanJudgementInput): PlanJudgement

KEY_DESIGN_FAULT_KINDS#

Values: wrapping-key-is-exportable, root-key-outside-a-key-service, key-below-the-root-is-unwrapped, key-wrapped-by-an-unknown-key, key-wrapped-by-its-own-tier-or-lower, wrapping-cycle, tenant-key-without-a-tenant, root-key-bound-to-a-tenant, field-key-shared-across-tenants, algorithm-without-a-version, no-rotation-period, rotation-overdue, rotation-slower-than-the-data-it-protects-is-retained, retired-key-still-wrapping-live-keys, data-key-that-seals-nothing

KEY_FAULT_KINDS#

Values: no-tenant, no-consumer, no-producer, no-event-id, no-subject, event-version-not-a-positive-integer, consumer-is-the-producer

KEY_MATERIAL_LOCATIONS#

Where the key material lives.

Values: kms, external-hsm, store-internal

KEY_TIERS#

The three tiers, ordered.

Values: root, tenant-kek, field-dek

KeyDescriptor#

Field Type Required Notes
keyId string required —
tier KeyTier required —
algorithm AeadAlgorithm required —
version string required Never blank. An unversioned key reference resolves to whatever is current.
location KeyMaterialLocation required —
wrappedByKeyId string | null required The key that wraps this one. Null only for a root.
tenantId string | null required The tenant this key may be used for. Null only for a root.
sealsFieldIds readonly string[] required The field ids this key seals. Empty for anything above a DEK.
exportable boolean required Whether the key service will hand out the material.
rotationPeriodDays number | null required —
createdAt Instant required —
retiredAt Instant | null — Instant required —

KeyDesignFault#

Field Type Required Notes
kind KeyDesignFaultKind required —
subject string required —
detail string required —

KeyDesignFaultKind#

ts
(typeof KEY_DESIGN_FAULT_KINDS)[number];

keyDesignFaults#

Check the key hierarchy (S3.13.b).

ts
keyDesignFaults(keys: readonly KeyDescriptor[], retentionDaysByFieldId: Readonly<Record<string, number>>, now: Instant): readonly KeyDesignFault[]

KeyFault#

Field Type Required Notes
kind KeyFaultKind required —
subject string required —
detail string required —

KeyFaultKind#

ts
(typeof KEY_FAULT_KINDS)[number];

KeyMaterialLocation#

ts
(typeof KEY_MATERIAL_LOCATIONS)[number];

KeyTier#

ts
(typeof KEY_TIERS)[number];

KIT_VERSION#

The kit version this module belongs to.

KNOWN_WORKLOAD_LIMITATIONS#

KnownLimitation#

The static faults this plan is known to produce, with the reason each one cannot be indexed away.

Field Type Required Notes
queryId string required —
kind IndexFaultKind required —
planFault PlanFaultKind required The fault the ENGINE is expected to produce for the same limitation. Naming it turns the allowance into an assertion: the plan harness fails both when the fault is missing from the declaration and when it is missing from the plan, so a declaration that has stopped describing anything cannot go on quietly excusing something else.
why string required —
remedy string required —

lease#

The row as it looks once claimed.

ts
lease(row: OutboxRow, holder: string, expiresAt: Instant): OutboxRow

leaseReclaimableAt#

The earliest a reconciler may take the lease away. Later than the worker gives it up.

ts
leaseReclaimableAt(lease: JobLease, policy: HeartbeatPolicy): Instant

LEDGER_OUTCOME_TO_VERDICT#

The cell's wording, mapped onto the verdicts the kit already has.

LegalHoldRecord#

Field Type Required Notes
holdId string required —
scope 'tenant' | 'workspace' | 'entity' required —
scopeId string required —
authority string required —
reason string required —
matterRef string required —
startsAt Instant required —
endsAt Instant | null — Instant required Null while open. A hold with no end is normal and is reviewed, not expired.
disclosable boolean required Whether the SUBJECT may be told the hold exists.
reviewBy Instant required —
releasedBy string | null required —
releasedAt Instant | null — Instant required —

LIFECYCLE_INDEXES#

S3.5.b — the stage and status access paths.

LINEAGE_HARM_KINDS#

Values: original-content-changed, original-not-marked-superseded, original-links-nowhere, replacement-does-not-link-back, replacement-is-the-original, replacement-supersedes-something-else

LineageHarm#

Field Type Required Notes
kind LineageHarmKind required —
detail string required —

LineageHarmKind#

ts
(typeof LINEAGE_HARM_KINDS)[number];

LIVENESS_PERMITTED_CHECKS#

What liveness is allowed to look at. Two things, neither of them remote.

Values: process-alive, event-loop-responsive

locatorKey#

ts
locatorKey(locator: StorageLocator): string

MARK_REFUSALS#

Values: not-eligible, confidence-too-low, action-is-not-a-deletion, register-version-moved

markCandidate#

Mark a candidate for reclamation (S3.12.e).

ts
markCandidate(input: { readonly candidate: ReclamationCandidate; readonly currentRegisterVersion: number; readonly token: string; readonly now: Instant; readonly leaseSeconds: number; }): MarkOutcome

MarkOutcome#

ts
| { readonly marked: true; readonly token: ReclamationToken }
| { readonly marked: false; readonly refusal: MarkRefusal; readonly detail: string }

markPublished#

Mark a row published. Unreachable without a receipt, by construction.

ts
markPublished(row: OutboxRow, receipt: DeliveryReceipt): OutboxRow

MarkRefusal#

ts
(typeof MARK_REFUSALS)[number];

MATRIX_BEHAVIOUR_FAULTS#

Values: failed-open, retried-a-permanent-failure, did-not-retry-a-transient-failure, disclosed-to-an-unauthorized-caller, modes-share-one-code, mode-not-exercised

MATRIX_FAULT_KINDS#

Values: sensitive-column-missing-from-the-matrix, matrix-entry-for-an-unknown-column, strategy-cannot-support-a-declared-operation, operation-no-strategy-supports, prohibited-field-with-a-declared-operation, credential-is-reversible, derivative-stored-in-plaintext, derivative-weaker-than-its-source, token-over-a-low-cardinality-field, token-with-no-cardinality-estimate, vault-reference-with-no-declared-purpose, resolution-purposes-on-a-non-vault-field

MatrixBehaviourFault#

ts
(typeof MATRIX_BEHAVIOUR_FAULTS)[number];

MatrixFault#

Field Type Required Notes
kind MatrixFaultKind required —
subject string required —
detail string required —

MatrixFaultKind#

ts
(typeof MATRIX_FAULT_KINDS)[number];

matrixFaults#

Check the field protection matrix (S3.13.a).

ts
matrixFaults(matrix: readonly FieldProtection[], census: readonly ColumnCensus[], minimumTokenCardinality: number): readonly MatrixFault[]

MAX_INLINE_PAYLOAD_BYTES#

The largest body that may travel in the row itself.

Value: 8_192

measurementIsFresh#

Whether a measurement is still inside its own freshness window.

ts
measurementIsFresh(measurement: GateMeasurement<TRaw>, now: Instant): boolean

METRIC_FAULT_KINDS#

Values: label-names-the-database, label-is-unbounded, no-outcome-label

MetricFault#

Field Type Required Notes
kind MetricFaultKind required —
subject string required —
detail string required —

MetricFaultKind#

ts
(typeof METRIC_FAULT_KINDS)[number];

metricFaults#

Check a probe metric (S3.14.g).

ts
metricFaults(metric: ProbeMetric): readonly MetricFault[]

MIGRATION_PHASES#

The phases, in the only order that keeps a rollback possible.

Values: expand, dual-write, backfill, verify, read-switch, contract

MIGRATION_REFUSALS#

Values: phase-out-of-order, contract-before-the-read-switch-soaked, contract-with-a-failing-verification, contract-with-plaintext-still-reachable, rollback-past-the-contract-phase

MigrationDecision#

ts
| { readonly allowed: true; readonly detail: string }
| { readonly allowed: false; readonly refusals: readonly MigrationRefusal[]; readonly detail: string; }

MigrationPhase#

ts
(typeof MIGRATION_PHASES)[number];

MigrationRefusal#

ts
(typeof MIGRATION_REFUSALS)[number];

MigrationState#

Field Type Required Notes
phase MigrationPhase required —
readSwitchedAt Instant | null — Instant required —
verificationPassed boolean required —
removal RemovalEvidence required —

missingRetention#

A record with no retention at all, which the type cannot prevent.

ts
missingRetention(record: IdempotencyRecord): RetentionFault | null

NON_PASSING_VERDICTS#

The verdicts a MISSING or STALE measurement may become.

Values: block, needs-human, indeterminate

NON_VERDICT_STATUSES#

The statuses that are NOT a decision about the subject.

Values: stale, missing, unavailable, unsupported, evaluator-error

NoncancellableRegion#

Field Type Required Notes
stage string required —
reason string required Why this region cannot be interrupted. A region with no reason is a region nobody can review.
maxSeconds number required The bound. An unbounded noncancellable region is a cancel that never lands.
enteredAt Instant required —

NonPassingVerdict#

ts
(typeof NON_PASSING_VERDICTS)[number];

NonvisualAlternative#

The non-visual path, which is REQUIRED rather than a courtesy.

Field Type Required Notes
labelKey string required —
summarize (model: TModel) => string required —
toSemanticNodes (model: TModel) => readonly SemanticNode[] — SemanticNode required —

ObjectObservation#

Field Type Required Notes
kind RequirementKind required —
name string required —
result ObservationResult required —
reason string required Why it could not be checked. Empty unless not-checkable.

ObjectRequirement#

Field Type Required Notes
kind RequirementKind required —
name string required —
required boolean required False for something this build can run without.

OBSERVATION_RESULTS#

Values: present, absent, not-checkable

ObservationResult#

ts
(typeof OBSERVATION_RESULTS)[number];

ObservedFailure#

Field Type Required Notes
mode FailureMode required —
code string required The stable code the caller actually saw.
retried boolean required —
disclosedReason boolean required —
returnedAValue boolean required True when the operation returned a value (empty, null, default) rather than failing.

ObservedMetadata#

What the server measured. Evidence about the bytes.

Field Type Required Notes
byteSize number required —
media MediaProfile required —
signatures readonly string[] required Every signature the bytes matched. More than one is decision 1's whole point.
observedAt Instant required —

ObservedSchema#

Field Type Required Notes
version number | null required The applied version, or null when there is no migration table at all.
dirty boolean required A migration failed part way and nothing rolled it back.
inProgress boolean required A migration is running right now.
observedAt Instant required —

OPEN_FAILURES#

Values: context-mismatch, algorithm-changed, schema-version-unknown, authentication-failed, key-unavailable, key-destroyed, key-version-unknown, algorithm-unsupported

OpenFailure#

ts
(typeof OPEN_FAILURES)[number];

openField#

Open a sealed field (S3.13.c).

ts
openField(cipher: FieldCipher, expected: ProtectionContext, sealed: SealedField, knownAlgorithm: AeadAlgorithm): OpenResult

OpenRequest#

Field Type Required Notes
keyId string required —
keyVersion string required —
algorithm AeadAlgorithm required —
nonce string required —
ciphertext string required —
aad string required —

OpenResult#

There is no successful result that carries nothing.

ts
| { readonly ok: true; readonly plaintext: string }
| { readonly ok: false; readonly failure: OpenFailure; readonly retryable: boolean; readonly detail: string; }

Operation#

ts
(typeof OPERATIONS)[number];

OPERATIONS#

Values: read, create, update, delete, export, administer

OPERATOR_ACTIONS#

Values: inspect, assign, comment, link-incident, suppress, transform, replay, skip, archive

OperatorAction#

ts
(typeof OPERATOR_ACTIONS)[number];

OPTION_STATUSES#

Values: chosen, rejected, deferred

OptionStatus#

ts
(typeof OPTION_STATUSES)[number];

ORDERING_DISPOSITIONS#

Values: apply, hold-for-gap, apply-out-of-order, ignore-superseded, gap-is-a-loss

OrderingDecision#

Field Type Required Notes
disposition OrderingDisposition required —
detail string required —

OrderingDisposition#

ts
(typeof ORDERING_DISPOSITIONS)[number];

OrderingRequest#

Field Type Required Notes
appliedThrough number required Highest contiguous sequence this consumer has applied for the subject.
held readonly number[] required Sequences seen but held because of a gap.
sequence number required —
ordering EventKindOrdering required —
now Instant required —
gapFirstSeenAt Instant | null — Instant required When the gap ahead of this event was first noticed.
gapToleranceSeconds number required How long a gap may stay open before it is treated as a loss.

ORPHAN_ACTIONS#

What may be done about an orphan.

Values: delete-bytes, delete-metadata-row, repair-reference, leave

ORPHAN_CLASSES#

Values: metadata-without-bytes, bytes-without-metadata, unreferenced-active, abandoned-upload, abandoned-quarantine, failed-derivative, dangling-reference, not-an-orphan

ORPHAN_REPAIRS#

Values: leave-alone, requeue, resume-from-checkpoint, mark-succeeded, probe-the-external-system, dead-letter-unknown-outcome

OrphanAction#

ts
(typeof ORPHAN_ACTIONS)[number];

OrphanClass#

ts
(typeof ORPHAN_CLASSES)[number];

OrphanDecision#

Field Type Required Notes
repair OrphanRepair required —
fenceOut boolean required Whether the store must advance the fence before anything else happens. True whenever the lease is being taken away, because the previous holder may be alive and about to write.
detail string required —

OrphanInput#

Field Type Required Notes
job JobRecord required —
lease JobLease | null — JobLease required —
checkpoint JobCheckpoint | null — JobCheckpoint required —
now Instant required —
policy HeartbeatPolicy required —
delivery EffectDelivery required —
probe ExternalOutcome | null — ExternalOutcome required What a probe of the external system reported, or null if none has been run.
probeAvailable boolean required —

OrphanObservation#

Field Type Required Notes
blobId string required —
record BlobReference | null — BlobReference required The metadata row, or null when only an object was found in the store.
bytesPresent boolean required Whether an object exists at the locator.
referenced boolean required Whether ANY source in the register refers to it.
danglingReferences readonly string[] required References naming this blob that resolve to no row at all.
generatingJobFailed boolean required Whether a job that was meant to produce this derivative failed.

OrphanRepair#

ts
(typeof ORPHAN_REPAIRS)[number];

orphanSweep#

Reconcile a set of jobs, newest lease last. Deterministic order for a repair log.

ts
orphanSweep(inputs: readonly OrphanInput[]): readonly { readonly jobId: string; readonly decision: OrphanDecision }[]

OrphanVerdict#

Field Type Required Notes
class OrphanClass required —
action OrphanAction required —
detail string required —

OUTBOX_RETENTION_ACTIONS#

Values: keep, redact-payload, archive, delete

OUTBOX_RETENTION_FAULT_KINDS#

Values: payload-outlives-the-row, personal-data-kept-as-long-as-the-row, row-shorter-than-the-replay-window, no-rule-for-an-emitted-kind

OUTBOX_STATES#

Where an outbox row is in its life.

Values: pending, leased, published, quarantined, redacted, archived

OutboxIntent#

What a producer declares it is about to do.

Field Type Required Notes
subject EventSubject required —
eventKind string required —
eventVersion number required —
payload PayloadRef required —
context EventContext required —

OutboxLease#

Field Type Required Notes
holder string required —
expiresAt Instant required —

outboxRetentionAction#

What to do with one row now.

ts
outboxRetentionAction(row: OutboxRow, rule: OutboxRetentionRule, now: Instant): { readonly action: OutboxRetentionAction; readonly why: string }

OutboxRetentionAction#

ts
(typeof OUTBOX_RETENTION_ACTIONS)[number];

OutboxRetentionFault#

Field Type Required Notes
kind OutboxRetentionFaultKind required —
subject string required —
detail string required —

OutboxRetentionFaultKind#

ts
(typeof OUTBOX_RETENTION_FAULT_KINDS)[number];

outboxRetentionFaults#

ts
outboxRetentionFaults(rules: readonly OutboxRetentionRule[], emittedKinds: readonly string[], replayWindowSeconds: number): readonly OutboxRetentionFault[]

OutboxRetentionRule#

How long a dispatched row and its body are kept.

Field Type Required Notes
eventKind string required —
rowSeconds number required —
payloadSeconds number required —
carriesPersonalData boolean required —
why string required —

OutboxRow#

Field Type Required Notes
outboxId string required Stable, and THE ID THE EVENT IS PUBLISHED UNDER. Never re-minted.
tenantId string required —
producer string required Which service wrote it — the first thing an incident needs and the easiest to omit.
subject EventSubject required —
eventKind string required —
eventVersion number required —
sequence number required Position within the subject. Gapless per subject; the only ordering that exists.
context EventContext required —
payload PayloadRef required —
occurredAt Instant required —
availableAt Instant required The earliest instant a dispatcher may claim this row. Backoff moves it.
attempt number required —
state OutboxState required —
lease OutboxLease | null — OutboxLease required —
lastFailure DeliveryFailure | null — DeliveryFailure required —
publishedAt Instant | null — Instant required —

OutboxState#

ts
(typeof OUTBOX_STATES)[number];

OWNERSHIP_CLASSES#

Six classes, and each one answers a different question about a query.

Values: tenant-owned, workspace-owned, cross-workspace-tenant, global-reference, public-immutable, operational-system-state

OWNERSHIP_DIMENSIONS#

S3.5.c — the six ways a workbench asks "whose is this?".

OWNERSHIP_INDEXES#

S3.5.c — ownership: assignee, team, and the queue defined by having neither.

OwnershipClass#

ts
(typeof OWNERSHIP_CLASSES)[number];

PAGINATION_MODES#

How the query walks a result set.

Values: keyset, single-row, bounded-aggregate, full-scan-batch

PaginationMode#

ts
(typeof PAGINATION_MODES)[number];

PARENT_OUTCOMES#

What a parent may be.

Values: queued, running, waiting, partial, failed, cancelled, succeeded

parentOutcome#

Fold the children into the parent (S3.10.e).

ts
parentOutcome(children: readonly ChildState[], ready: readonly string[] = []): ParentVerdict

ParentOutcome#

ts
(typeof PARENT_OUTCOMES)[number];

ParentVerdict#

Field Type Required Notes
outcome ParentOutcome required —
lostOptional readonly string[] required Children the parent finished without. Empty unless the outcome is partial.
waitingOn readonly string[] required Non-terminal children the parent is waiting on.
detail string required —

PARITY_FAULT_KINDS#

Values: stage-disagrees, timeline-length-disagrees, timeline-entry-disagrees, gate-row-missing, gate-row-disagrees, signoff-row-missing, signoff-row-disagrees, bypass-count-disagrees, completeness-disagrees

PARITY_FAULT_KINDS#

Values: field-disagrees, field-missing-from-replay, field-missing-from-stored, applied-through-disagrees

ParityFault#

Field Type Required Notes
kind ParityFaultKind required —
subject string required —
detail string required —

ParityFaultKind#

ts
(typeof PARITY_FAULT_KINDS)[number];

parityFaults#

Compare a rebuilt projection against the one that was maintained (S2.14.e).

ts
parityFaults(rebuilt: AuditProjection, stored: AuditProjection): readonly ParityFault[]

parseExplainPlan#

Read a Postgres EXPLAIN (FORMAT JSON) tree into the shape the gate judges.

ts
parseExplainPlan(raw: unknown): PlanNode

parsePluginDescriptor#

ts
parsePluginDescriptor(input: unknown): ParseResult<PluginDescriptor>

parseSchemaRange#

ts
parseSchemaRange(input: unknown, field: string): ParseResult<SchemaRange>

parseSemanticRange#

ts
parseSemanticRange(input: unknown, field: string): ParseResult<SemanticRange>

partitionKeyFor#

The partition an event is published on.

ts
partitionKeyFor(row: OutboxRow): string

PAYLOAD_ACCESS#

Values: redacted, authorized-raw, unavailable

PayloadAccess#

ts
(typeof PAYLOAD_ACCESS)[number];

PayloadRef#

How the event body is carried.

ts
| { readonly kind: 'inline'; readonly body: unknown; readonly bytes: number }
| { readonly kind: 'blob'; readonly digest: Sha256Hex; readonly bytes: number }

PLAINTEXT_RESIDUES#

Where the plaintext still is after DROP COLUMN.

Values: dead-tuples, write-ahead-log, physical-replica, logical-replication-slot, backup-snapshot, index-leaf-pages, search-index, warehouse-copy, application-cache, support-export

PlaintextResidue#

ts
(typeof PLAINTEXT_RESIDUES)[number];

plan#

Decide whether a declared transition may be applied, and return the write.

ts
plan(graph: StageGraph<TStage>, command: NoInfer<TransitionCommand<TStage>>): TransitionOutcome<TStage>

PLAN_FAULT_KINDS#

Values: sequential-scan-at-volume, sort-above-a-paginated-query, sort-spilled-to-disk, filter-discarded-most-of-what-it-read, estimate-off-by-an-order-of-magnitude, planned-index-not-used, no-plan-captured

planBypass#

Move an object across an edge the graph does not have (S2.1.f).

ts
planBypass(graph: StageGraph<TStage>, command: NoInfer<BypassCommand<TStage>>): TransitionOutcome<TStage>

planDeadLetterReplay#

Requeue a dead-lettered job (S3.9.h).

ts
planDeadLetterReplay(input: { readonly record: DeadLetter; readonly job: JobRecord; readonly decision: DeadLetterDecision; readonly grantedAttempts: number; readonly authorizedBy: string; readonly at: Instant; }): DeadLetterReplay

planDecisionTransition#

Move a decision to its next stage.

ts
planDecisionTransition(command: DecisionCommand): TransitionOutcome<DecisionStage>

planDeletion#

Decide whether a marked candidate may still be deleted (S3.12.e).

ts
planDeletion(input: { readonly token: ReclamationToken; readonly blobId: string; readonly now: Instant; readonly tokenStillHeld: boolean; readonly referencedSince: boolean; readonly currentRegisterVersion: number; }): DeletionDecision

PlanFault#

Field Type Required Notes
kind PlanFaultKind required —
subject string required —
detail string required —
verdict VerdictName required —

PlanFaultKind#

ts
(typeof PLAN_FAULT_KINDS)[number];

planGraphRetry#

Decide what a graph retry re-runs and what it reuses (S3.10.f).

ts
planGraphRetry(input: { readonly graph: JobGraph; readonly parentId: string; readonly targets: readonly RetryTarget[]; }): GraphRetryPlan

PlanJudgement#

Field Type Required Notes
queryId string required —
verdict VerdictName required —
faults readonly PlanFault[] — PlanFault required —

PlanJudgementInput#

Field Type Required Notes
query WorkloadQuery required —
profile VolumeProfile required —
plan PlanNode | null — PlanNode required Null when the run captured no plan — which is indeterminate, never a pass.
expectedIndex string | null optional The index the plan was expected to use, from the declaration that serves this query.

PlannedOperation#

Field Type Required Notes
operationId string required —
kind 'create' | 'update' | 'link' | 'skip' required —
targetRef string required —

PlannedTransition#

The write the caller's persistence layer performs, under this revision.

Field Type Required Notes
subjectId string required —
from TStage required —
to TStage required —
transitionId string | null required —
expectedRevision string required —
idempotencyKey string required —
at Instant required —
effects readonly EffectKind[] — EffectKind required —
bypass PrivilegedBypass | null — PrivilegedBypass required —

PlanNode#

One node of a query plan, normalized out of whatever the engine emitted.

Field Type Required Notes
nodeType string required —
relation string | null required —
indexName string | null required —
planRows number required —
actualRows number | null required —
rowsRemovedByFilter number required —
sortMethod string | null required —
sortKeys readonly string[] required —
children readonly PlanNode[] — PlanNode required —

planRenewal#

Ask for a signoff to carry forward, and be told no (S2.13.f).

ts
planRenewal(previous: SignoffRecord, current: CurrentState, intent: 'renew' | 'reverse' | 'rescope'): RenewalOutcome

planReplay#

Build the replay (S3.8.f).

ts
planReplay(input: ReplayRequestInput): ReplayPlan

planStageCommit#

Pair an effect with its checkpoint (S3.9.e).

ts
planStageCommit(input: { readonly write: FencedWrite; readonly effect: StageEffect; readonly checkpoint: JobCheckpoint; readonly ordering: CheckpointOrdering; }): StageCommit

planTransition#

Decide one transition (S3.3.a/b).

ts
planTransition(request: TransitionRequest): TransitionOutcome

PLUGIN_VIOLATION_KINDS#

Values: duplicate-plugin-id, duplicate-contribution-id, unknown-required-plugin, plugin-dependency-cycle, retired-plugin-required, unknown-successor, undeclared-capability-contribution, declared-capability-without-contribution, unsupported-capability-contributed, unknown-capability, claimed-extension-point-without-contribution, contribution-at-unclaimed-extension-point, kit-version-unsupported, schema-version-unsupported, missing-required-configuration, unknown-stage, duplicate-stage, duplicate-transition-id, unknown-initial-stage, terminal-stage-has-exit, self-transition-not-reentrant, unreachable-stage, unknown-guard, no-terminal-stage, stage-label-not-a-key, passing-verdict-for-absent-measurement, migration-chain-gap, migration-chain-duplicate, migration-not-forward, migration-above-current-schema, missing-migration-chain, invalid-media-type, editor-label-not-a-key, duplicate-editor-command, editor-without-read-only-fallback, iframe-without-permitted-origin, wildcard-permitted-origin, in-process-network-over-protected-data, nonvisual-label-not-a-key, inspector-field-editable-without-scope, preview-with-inspector-fields, importer-without-formats, duplicate-format-claim, irreversible-publisher-without-reason, reversible-publisher-declaring-reason

PluginDescriptor#

Field Type Required Notes
pluginId string required <domain>.<plugin>. The domain segment must equal .
version SemanticVersion required —
owner string required —
domain string required —
description string required —
lifecycle Lifecycle required —
supersededBy string | null required Required when the lifecycle is deprecated or retired, null otherwise.
kitVersions SemanticRange required Which kit versions this plugin was written against.
contractVersions SchemaRange required Which envelope schema versions it can read and emit.
declares readonly CapabilityDeclaration[] — CapabilityDeclaration required —
requiresPlugins readonly string[] required —
optionalPlugins readonly string[] required —
configuration readonly ConfigurationReference[] — ConfigurationReference required —
extensionPoints readonly ExtensionPoint[] — ExtensionPoint required The extension points the plugin CLAIMS to contribute to.

PluginValidationOptions#

Field Type Required Notes
kitVersion SemanticVersion optional The kit the host is running. Defaults to .
schemaVersion number optional The envelope schema version the host speaks.
knownCapabilities readonly CapabilityId[] — CapabilityId optional Capabilities the registry knows. When empty the capability check is SKIPPED rather than failing everything: an empty register means the host has not been given one, and a check that fails every plugin on that basis is one somebody disables.
providedSettings readonly string[] optional Settings the deployment provides, by name. Empty skips the check.
protectedClassifications readonly DataClassification[] — DataClassification optional Data classifications treated as protected by the isolation rule.

PluginViolation#

Field Type Required Notes
kind PluginViolationKind required —
subject string required —
detail string required —

PluginViolationKind#

ts
(typeof PLUGIN_VIOLATION_KINDS)[number];

POISON_CONDITIONS#

Values: malformed, unsupported-version, unauthorized, invariant-violated, dependency-missing, deterministic-handler-failure, repeated-transient, unknown

PoisonCondition#

ts
(typeof POISON_CONDITIONS)[number];

PolicyChangeCase#

Field Type Required Notes
label string required —
definitions readonly GateDefinition[] — GateDefinition required —
results readonly GateRunResult[] — GateRunResult required —
context AggregateContext required —

PolicyChangeReport#

Field Type Required Notes
fromVersion number required —
toVersion number required —
rows readonly PolicyChangeRow[] — PolicyChangeRow required —
loosened readonly string[] required —
tightened readonly string[] required —
changedWithoutAVersionBump boolean required The fold changed and the version did not.

PolicyChangeRow#

Field Type Required Notes
label string required —
was ReleaseEligibility required —
now ReleaseEligibility required —
direction 'unchanged' | 'loosened' | 'tightened' required —

PolicyDecision#

What a domain policy returns when it is given a fresh measurement.

ts
| { readonly verdict: 'pass' }
| { readonly verdict: 'warn'; readonly findings: readonly GateFinding[] }
| { readonly verdict: 'block'; readonly findings: readonly GateFinding[]; readonly remediation: Remediation; }
| { readonly verdict: 'needs-human'; readonly reason: string }

PREDICATE_KINDS#

How a predicate constrains a column, which decides what a b-tree can do with it.

Values: equality, membership, range, text-prefix, is-null

PredicateKind#

ts
(typeof PREDICATE_KINDS)[number];

PRESENCE_DISCLOSING_CLASSES#

Classes where the fact that a row EXISTS is itself the disclosure.

Values: protected-source, health, biometric

PresenceClaim#

Evidence that a person was present, as the identity layer reported it.

Field Type Required Notes
actor ActorRef required —
roles readonly string[] required —
authenticatedAt Instant | null — Instant required When the SESSION authenticated. Not the same as a step-up.
steppedUpAt Instant | null — Instant required When a step-up was performed, if one was.
stepUpMethod StepUpMethod | null — StepUpMethod required —
impersonating boolean required True while a support or admin impersonation session is in effect.

PresentedAggregate#

Field Type Required Notes
headline ReleaseEligibility | 'passing' — ReleaseEligibility required —
components readonly PresentedComponent[] — PresentedComponent required —

PresentedComponent#

How one gate was actually shown to a person.

Field Type Required Notes
gateId string required —
shownAs 'passing' | 'warning' | 'blocked' | 'waived' | 'unknown' | 'hidden' required —
reason string | null required —

PresentedWaiver#

One waiver, as a surface actually rendered it. Null means the field is absent.

Field Type Required Notes
waiverId string required —
shownAsActive boolean required —
scope string | null required —
reason string | null required —
approver string | null required —
expiry string | null required —
residualRisk string | null required —

Principal#

ts
(typeof PRINCIPALS)[number];

PRINCIPALS#

Values: creator, owner, contributor, reviewer, delegate, operator, service, support

PRIORITY_BAND#

The declared priority band.

PrivilegedBypass#

The explicit way around the graph (S2.1.f).

Field Type Required Notes
authority string required Who authorized it — a role or a named approver, never the acting user.
reason string required —
scope string required What it is limited to: one object, one tenant, one window.
evidence readonly string[] required References supporting it: an incident, a legal hold, a signed approval.
auditEventId string required The audit event this bypass is recorded as. Without it, it did not happen.

PROBE_CHECKS#

Values: process-alive, event-loop-responsive, connection-acquire, read-query, write-transaction, migration-state, schema-version, schema-objects, extensions, permissions

PROBE_CODES#

PROBE_METHOD_FAULT_KINDS#

Values: write-probe-touches-user-data, write-probe-does-not-roll-back, write-probe-that-only-reads, write-blocking-state-never-consulted, read-probe-that-writes

ProbeCheck#

ts
(typeof PROBE_CHECKS)[number];

ProbeContract#

Field Type Required Notes
kind DatabaseProbeKind required —
checks readonly ProbeCheck[] — ProbeCheck required —
timeoutMs number required The probe's own deadline.
callerTimeoutMs number required The orchestrator's deadline for this probe.
connectionBudget number required Connections reserved for probing. Zero means it borrows.
usesTheRequestPool boolean required —
cacheSeconds number required How long an answer may be reused. Zero means every poll does the work.

ProbeMethodFault#

Field Type Required Notes
kind ProbeMethodFaultKind required —
subject string required —
detail string required —

ProbeMethodFaultKind#

ts
(typeof PROBE_METHOD_FAULT_KINDS)[number];

probeMethodFaults#

Check how a capability probe proves what it claims (S3.14.b).

ts
probeMethodFaults(probe: CapabilityProbe): readonly ProbeMethodFault[]

ProbeMetric#

Field Type Required Notes
name string required —
labels readonly string[] required —
unboundedLabels readonly string[] required Label names whose value set is not closed.

ProbeReport#

Field Type Required Notes
checkedAt Instant required —
schema SchemaVerdict required —
findings readonly CompatibilityFinding[] — CompatibilityFinding required —
capabilityProbes readonly { readonly probe: CapabilityProbe; readonly passed: boolean; }[] — CapabilityProbe required —
correlationId CorrelationId required —
safeDetail string required One sentence, checked.
remediation Remediation required —

ProcessingFailure#

Field Type Required Notes
transient boolean required —
code string required —
detail string required —

ProcessingOutcome#

Field Type Required Notes
status 'applied' | 'ignored' required —
reason string required Why an event was correctly ignored — a filter is a result, not a silence.
effectRef string | null required —

PROGRESS_FAULT_KINDS#

Values: negative-progress, completed-exceeds-total, completed-went-backwards, total-shrank-below-completed, zero-total-reads-as-complete, observation-went-backwards, message-is-a-sentence, outputs-without-progress

ProgressFault#

Field Type Required Notes
kind ProgressFaultKind required —
subject string required —
detail string required —

ProgressFaultKind#

ts
(typeof PROGRESS_FAULT_KINDS)[number];

progressFaults#

Check one progress report against the last one (S3.9.d).

ts
progressFaults(previous: StageProgress | null, next: StageProgress): readonly ProgressFault[]

ProjectionContribution#

Field Type Required Notes
load ( selection: TSelection, context: ExecutionContext ) => Promise<ProjectionState<TModel>> — ExecutionContext, ProjectionState required —
nonvisual NonvisualAlternative<TModel> — NonvisualAlternative required —

ProjectionMetadata#

Field Type Required Notes
extensionPoint 'preview' | 'inspector' required —
selection SelectionContract required —
authorization ContributionAuthorization required —
isolation HostIsolation required —
nonvisualLabelKey string required —
fields readonly InspectorField[] — InspectorField required Inspector fields; always empty for a preview.

ProjectionSnapshot#

Field Type Required Notes
projection string required —
appliedThrough number required —
fields Readonly<Record<string, unknown>> required —

ProjectionState#

The state a projection is in.

ts
| { readonly state: 'loading'; readonly since: Instant }
| { readonly state: 'ready'; readonly model: TModel; readonly asOf: Instant }
| { readonly state: 'empty'; readonly reasonKey: string }
| { readonly state: 'unauthorized'; readonly missingScopes: readonly string[] }
| { readonly state: 'not-configured'; readonly capability: CapabilityId; readonly reason: string; }
| { readonly state: 'failed'; readonly failure: GateFailure }

propagateCancellation#

Plan a graph cancellation (S3.10.f).

ts
propagateCancellation(graph: JobGraph, parentId: string): CancellationPlan

ProtectedQuery#

Field Type Required Notes
queryId string required —
predicates readonly { readonly field: string; readonly operator: QueryOperator }[] — QueryOperator required —
orderBy readonly string[] required —
groupBy readonly string[] required —
indexes readonly { readonly field: string; readonly unique: boolean }[] required —

PROTECTION_STRATEGIES#

Values: prohibited, vault-reference, one-way-hash, encrypt-at-rest, deterministic-token

ProtectionContext#

Everything a sealed value is bound to.

Field Type Required Notes
tenantId string required —
entity string required —
entityId string required —
fieldId string required —
schemaVersion string required Bumped when the meaning of the field changes, so old rows are diagnosable.

ProtectionStrategy#

ts
(typeof PROTECTION_STRATEGIES)[number];

PROVENANCE_FAULT_KINDS#

Values: derived-without-an-ingredient, ingredient-without-a-digest, transformation-without-a-tool-version, transformation-before-its-ingredient, generated-without-a-job, manifest-not-in-a-ledger, self-ingredient

ProvenanceFault#

Field Type Required Notes
kind ProvenanceFaultKind required —
subject string required —
detail string required —

ProvenanceFaultKind#

ts
(typeof PROVENANCE_FAULT_KINDS)[number];

provenanceFaults#

Check a provenance manifest (S3.11.f).

ts
provenanceFaults(manifest: ProvenanceManifest): readonly ProvenanceFault[]

ProvenanceManifest#

Field Type Required Notes
blobId string required —
manifestRef string required —
ledgerRef string | null required The append-only record this manifest is written into.
ingredients readonly Ingredient[] — Ingredient required —
generatedByJobId string | null required The job (S3.9) that produced these bytes.
transformations readonly Transformation[] — Transformation required —
sourceRevisionId string | null required The entity revision this was derived from, pinned.
derivedBlobIds readonly string[] required Blobs derived FROM this one.
recordedAt Instant required —

ProvenanceSource#

Field Type Required Notes
kind 'entity-revision' | 'artifact' | 'external-service' | 'ruleset' | 'model' required —
reference string required —

publicProbeView#

Build the public body (S3.14.e).

ts
publicProbeView(report: ProbeReport, remediationKey: string): PublicProbeView

PublicProbeView#

The body an unauthenticated caller receives.

Field Type Required Notes
status 'ok' | 'degraded' | 'not-ready' required —
code string required A stable code. Never a sentence that changes when somebody improves it.
remediationKey string required A key into the runbook, not the runbook.
checkedAt Instant required —
correlationId CorrelationId required —

PublisherContribution#

ts
| PublisherMetadata & PublisherRuntime<TPlan, TReceipt> & { readonly compensate: | (( receipt: PublishReceipt<TReceipt>, context: ExecutionContext ) => Promise<CompensationOutcome>)
| null; }

PublisherMetadata#

Reversibility, as a discriminated pair rather than two loose fields.

ts
| (PublisherCommon & { readonly reversible: true; readonly irreversibleReason: null })
| (PublisherCommon & { readonly reversible: false; readonly irreversibleReason: string })

PublisherRuntime#

Field Type Required Notes
plan (context: ExecutionContext) => Promise<PublishPlan<TPlan>> — ExecutionContext, PublishPlan required —
execute ( plan: PublishPlan<TPlan>, context: ExecutionContext ) => Promise<PublishReceipt<TReceipt>> — ExecutionContext, PublishPlan, PublishReceipt, plan required —
verify (receipt: PublishReceipt<TReceipt>) => Promise<PublishVerification> — PublishReceipt, PublishVerification required —

PublishPlan#

Field Type Required Notes
planId string required —
plannedAt Instant required —
planDigest Sha256Hex required —
detail TPlan required —

PublishReceipt#

Field Type Required Notes
planDigest Sha256Hex required —
idempotencyKey string required —
publishedAt Instant required —
externalRef string required The identifier the TARGET assigned, which is what a readback needs.
detail TReceipt required —

PublishVerification#

Field Type Required Notes
planDigest Sha256Hex required —
verifiedBy VerificationSource required —
verifiedAt Instant required —
matches boolean required —
evidence string required What was actually read back or attested. Never empty when it matches.

PURGE_REFUSAL_KINDS#

Values: still-referenced, pending-upload-may-still-arrive, not-eligible-in-the-deletion-machine

PURGE_STEPS#

The order a purge runs in, leaves first.

Values: search-index, cache, derivative, export, provider-copy, blob, revision, event, metadata, ledger-redaction

PurgeExecutor#

What a purge is handed. Each step reports for itself; none of them is trusted.

ts
(step: PurgeStep) => 'done' | 'failed' | 'skipped';

PurgeRefusal#

Field Type Required Notes
kind PurgeRefusalKind required —
subject string required —
detail string required —

PurgeRefusalKind#

ts
(typeof PURGE_REFUSAL_KINDS)[number];

purgeRefusals#

Blob-specific reasons a purge is refused (S3.11.e).

ts
purgeRefusals(blob: BlobReference, deletionState: DeletionState): readonly PurgeRefusal[]

PurgeRun#

Field Type Required Notes
state DeletionState required —
completed readonly PurgeStep[] — PurgeStep required —
failedAt PurgeStep | null — PurgeStep required —
outcomes readonly StepOutcome[] — StepOutcome required —
notAttempted readonly PurgeStep[] — PurgeStep required Steps not attempted because an earlier one failed.
detail string required —

PurgeStep#

ts
(typeof PURGE_STEPS)[number];

PurgeTombstone#

The proof that a thing existed and was deleted, carrying none of it.

Field Type Required Notes
tombstoneId string required —
tenantId string required —
entityKind string required —
createdAt Instant required —
deletedAt Instant required —
deletedById string required —
reasonKey string required A key, never the sentence, and never the content it described.
purgeCompletedAt Instant required —
stepsCompleted readonly PurgeStep[] — PurgeStep required The steps that ran, so a partial purge is visible after the fact.
legalHoldIds readonly string[] required —

QuarantineAlert#

Field Type Required Notes
kind QuarantineAlertKind required —
subject string required —
detail string required —

QuarantineAlertKind#

ts
(typeof ALERT_KINDS)[number];

quarantineAlerts#

ts
quarantineAlerts(health: QuarantineHealth, thresholds: AlertThresholds): readonly QuarantineAlert[]

quarantineHealth#

Measure the quarantine (S3.8.g).

ts
quarantineHealth(records: readonly QuarantineRecord[], blocked: readonly BlockedPartition[], now: Instant, reviewBudgetSeconds: number): QuarantineHealth

QuarantineHealth#

Field Type Required Notes
open number required —
unclassified number required —
unassigned number required —
staleOwner number required Assigned and untouched past the review budget.
oldestOpenAgeSeconds number required —
blockedPartitions number required Subjects or partitions currently held by an isolation. THE outage number.
oldestBlockAgeSeconds number required —

QuarantineRecord#

Field Type Required Notes
quarantineId string required —
tenantId string required —
consumer string required —
eventRef string required The event as it lives in the outbox or the broker — a reference, not a copy.
eventHash Sha256Hex required What the original hashed to, so the reference can be shown not to have moved.
eventKind string required —
subject string required —
partition string required —
sequence number required —
handlerVersion number required —
condition PoisonCondition required —
attempts number required —
causeChain readonly CauseLink[] — CauseLink required Newest first. The last error is the symptom; the chain is the cause.
traceParent string | null required —
firstFailedAt Instant required —
quarantinedAt Instant required —
lastReviewedAt Instant | null — Instant required —
assignee string | null required —
incidentRef string | null required —
payloadAccess PayloadAccess required —
resolvedAt Instant | null — Instant required —

QUERY_FAULT_KINDS#

Values: predicate-the-strategy-cannot-answer, order-by-over-a-protected-field, group-by-over-a-protected-field, unique-index-over-a-randomized-ciphertext, index-over-a-protected-field-that-cannot-use-it, presence-check-is-the-disclosure

QUERY_OPERATORS#

Values: equals, in, like-prefix, like-contains, range, is-null, full-text

QueryFault#

Field Type Required Notes
kind QueryFaultKind required —
subject string required —
detail string required —

QueryFaultKind#

ts
(typeof QUERY_FAULT_KINDS)[number];

queryFaults#

Check a query against the matrix (S3.13.c).

ts
queryFaults(query: ProtectedQuery, matrix: readonly FieldProtection[]): readonly QueryFault[]

QueryOperator#

ts
(typeof QUERY_OPERATORS)[number];

QueryPredicate#

Field Type Required Notes
column string required —
kind PredicateKind required —
value string optional The fixed value, for an equality predicate that always uses one. Present so a partial index's predicate can be shown to be implied by the query rather than assumed to be.

QueryShape#

A query as the checker sees it: what it reads and what it filtered on.

Field Type Required Notes
entity string required —
predicates readonly string[] required —
joins readonly string[] required Tables joined in, each of which brings its own scope obligation.
operation Operation required —

queueHealth#

Measure the queue (S3.6.f).

ts
queueHealth(rows: readonly OutboxRow[], now: Instant, windowSeconds: number): QueueHealth

QueueHealth#

Field Type Required Notes
pending number required —
leased number required —
quarantined number required —
oldestPendingAgeSeconds number required Age of the OLDEST claimable row, in seconds. The number that means something.
attemptsAboveOne number required —
expiredLeases number required —
publishedInWindow number required —
throughputPerSecond number required —

QUORUM_FAULT_KINDS#

Values: not-enough-approvals, one-person-signed-twice, the-author-signed, two-signers-share-a-declared-conflict, signed-out-of-the-required-order, a-rejection-stands, independence-not-declarable

QuorumFault#

Field Type Required Notes
kind QuorumFaultKind required —
subject string required —
detail string required —

QuorumFaultKind#

ts
(typeof QUORUM_FAULT_KINDS)[number];

QuorumOutcome#

Field Type Required Notes
satisfied boolean required —
approvals number required —
faults readonly QuorumFault[] — QuorumFault required —

REACHABLE_DELETION_STATES#

Every deletion state this module can produce, for the S3.3 machine to accept.

Values: active, purge-eligible

readinessDecision#

Decide readiness per capability (S3.14.f).

ts
readinessDecision(report: ProbeReport): readonly CapabilityVerdict[]

readinessState#

The readiness answer as a S1.6 capability state (S3.14.f).

ts
readinessState(input: { readonly capability: CapabilityId; readonly capabilityVersion: string; readonly report: ProbeReport; readonly verdicts: readonly CapabilityVerdict[]; readonly owner: CapabilityOwner; readonly freshnessSeconds: number; readonly retryAfterSeconds: number; }): CapabilityState

readyChildren#

Decide which children may start (S3.10.c).

ts
readyChildren(request: SchedulingRequest): SchedulingDecision

REBINDABLE_DIMENSIONS#

The dimensions an approver may declare a change to as survivable.

Values: input, evaluator, policy, dependency

RebindableDimension#

ts
(typeof REBINDABLE_DIMENSIONS)[number];

RECEIPT_STATES#

Values: claimed, processed, failed, quarantined, held

ReceiptState#

ts
(typeof RECEIPT_STATES)[number];

receiveAck#

Turn a broker acknowledgement into the receipt markPublished requires.

ts
receiveAck(row: OutboxRow, ack: BrokerAck): DeliveryReceipt

reclaimable#

Rows whose holder is gone.

ts
reclaimable(rows: readonly OutboxRow[], now: Instant): readonly OutboxRow[]

ReclamationCandidate#

Field Type Required Notes
blobId string required —
orphanClass OrphanClass required —
action OrphanAction required —
byteSize number required —
reasonKey string required —
searchedSources readonly ReferenceSource[] — ReferenceSource required Which sources were searched, and at what register version. Decision 1.
registerVersion number required —
gates readonly GateResult[] — GateResult required —
confidence Confidence required —
sampledVerification boolean | null required Whether a human-sampled check of this candidate was performed and passed.

ReclamationFinding#

Field Type Required Notes
sweepId string required —
reclaimed readonly string[] required —
closedAt Instant | null — Instant required —
state FindingState required —

ReclamationToken#

Permission to delete one blob, valid only while nothing has referenced it.

Field Type Required Notes
blobId string required —
token string required —
action OrphanAction required —
mintedAt Instant required —
expiresAt Instant required —
registerVersion number required —
[reclamationToken] true required —

RECOMPUTE_TRIGGERS#

Values: automatic, on-next-save, manual, scheduled

RecomputeTrigger#

ts
(typeof RECOMPUTE_TRIGGERS)[number];

reconcileOrphan#

Decide the repair for a job whose worker is gone (S3.9.i).

ts
reconcileOrphan(input: OrphanInput): OrphanDecision

reconcileSweep#

Reconcile a sweep against what happened afterwards (S3.12.g).

ts
reconcileSweep(input: { readonly finding: ReclamationFinding; readonly signals: readonly FalsePositive[]; readonly now: Instant; readonly sweptAt: Instant; readonly observationWindowSeconds: number; readonly sourcesAddedSince: readonly ReferenceSource[]; }): ReconciliationReport

Reconciliation#

Field Type Required Notes
planDigest Sha256Hex required —
attempted number required —
applied number required —
skipped number required —
failed number required —
drift readonly ReconciliationDrift[] — ReconciliationDrift required —

ReconciliationDrift#

Field Type Required Notes
targetRef string required —
expected string required —
observed string required —

ReconciliationReport#

Field Type Required Notes
sweepId string required —
state FindingState required —
falsePositives readonly string[] required —
missedSources readonly ReferenceSource[] — ReferenceSource required Which reference source would have caught each one, if it is knowable.
prematurelyClosed boolean required True when the finding was closed before its observation window had elapsed — decision 6 violated, made checkable after the fact. A sweep closed that way is one whose false positives were never going to be found.
detail string required —

RECORD_FAULT_KINDS#

Values: no-event-reference, no-event-hash, empty-cause-chain, cause-chain-out-of-order, quarantined-before-it-failed, raw-payload-by-default, resolved-without-a-review, unclassified-without-a-cause

RECORD_VIOLATION_KINDS#

Values: signed-before-the-review-opened, signed-with-no-attestation, rejected-with-no-comment, abstained-with-no-comment, signed-under-a-declared-conflict-without-recusing, recused-and-still-decided, no-evidence-versions-recorded, role-does-not-match-what-was-held, reviewed-no-audience

RecordFault#

Field Type Required Notes
kind RecordFaultKind required —
subject string required —
detail string required —

RecordFaultKind#

ts
(typeof RECORD_FAULT_KINDS)[number];

recordFaults#

Check a quarantine record (S3.8.b).

ts
recordFaults(record: QuarantineRecord): readonly RecordFault[]

RecordViolation#

Field Type Required Notes
kind RecordViolationKind required —
subject string required —
detail string required —

RecordViolationKind#

ts
(typeof RECORD_VIOLATION_KINDS)[number];

RedactedView#

Nothing at all, for a viewer who may not know the object exists.

ts
| { readonly visible: false; readonly reasonKey: string }
| { readonly visible: true; readonly projection: AuditProjection }

redactFor#

Narrow a projection to what this viewer may see (S2.14.f).

ts
redactFor(projection: AuditProjection, viewer: AuditViewer): RedactedView

REDACTION_FAULT_KINDS#

Values: protected-field-name-carries-a-value, canary-survived-redaction, shape-leak-survived-redaction, mask-is-derived-from-the-value, metric-label-carries-a-field-value, backup-holds-the-key-and-the-ciphertext, presence-disclosed-by-the-key-alone

REDACTION_SURFACES#

The nine places a protected value gets out.

Values: orm-error, sql-parameters, application-log, trace-attribute, metric-label, audit-summary, test-snapshot, support-export, backup

REDACTION_TOKEN#

The one permitted replacement (S3.13.e).

Value: '[protected]'

RedactionFault#

Field Type Required Notes
kind RedactionFaultKind required —
subject string required —
detail string required —
surface RedactionSurface required —

RedactionFaultKind#

ts
(typeof REDACTION_FAULT_KINDS)[number];

redactionFaults#

Scan every surface for values that should not be on it (S3.13.e).

ts
redactionFaults(samples: readonly SurfaceSample[], matrix: readonly FieldProtection[], canaries: readonly string[]): readonly RedactionFault[]

RedactionSurface#

ts
(typeof REDACTION_SURFACES)[number];

redundantIndexes#

Indexes made redundant by a wider one.

ts
redundantIndexes(indexes: readonly IndexDeclaration[]): readonly { readonly index: string; readonly supersededBy: string }[]

REFERENCE_FAULT_KINDS#

Values: reference-has-no-version, reference-path-carries-a-value, reference-path-is-empty, reference-scheme-is-empty

REFERENCE_SOURCES#

The places a reference to a blob can live.

Values: entities, revisions, jobs, outbox, inbox, evidence, provenance, bundles, uploads, releases, audit, legal-holds

referencedBlobIds#

Every blob id any source refers to. The union, never an intersection.

ts
referencedBlobIds(register: ReferenceRegister): ReadonlySet<string>

ReferenceFault#

Field Type Required Notes
kind ReferenceFaultKind required —
subject string required —
detail string required —

ReferenceFaultKind#

ts
(typeof REFERENCE_FAULT_KINDS)[number];

referenceFaults#

Check a vault reference (S3.13.d).

ts
referenceFaults(reference: VaultReference, subject: string): readonly ReferenceFault[]

ReferenceRegister#

Field Type Required Notes
version number required Bumped whenever a source is added or removed. Recorded on every candidate.
scans readonly ReferenceSourceScan[] — ReferenceSourceScan required —
builtAt Instant required —

ReferenceSource#

ts
(typeof REFERENCE_SOURCES)[number];

ReferenceSourceScan#

Field Type Required Notes
source ReferenceSource required —
reachable boolean required False when the source could not be read at all.
scannedAt Instant | null — Instant required —
referencedBlobIds readonly string[] required Blob ids this source refers to.
complete boolean required Whether the scan covered the whole source or a page of it. A partial scan is as dangerous as an unreachable one and is deliberately not the same field.

REFUSAL_REASONS#

Values: not-a-human-actor, acting-on-behalf-of-somebody-else, redacted-actor, unauthenticated, fixture-actor, impersonation-session, not-in-the-eligible-set, missing-the-required-role, step-up-not-performed, step-up-method-not-accepted, step-up-predates-the-review, step-up-too-old

RefusalReason#

ts
(typeof REFUSAL_REASONS)[number];

REGION_FAULT_KINDS#

Values: region-without-a-bound, region-without-a-reason, region-longer-than-the-lease

RegionFault#

Field Type Required Notes
kind RegionFaultKind required —
subject string required —
detail string required —

RegionFaultKind#

ts
(typeof REGION_FAULT_KINDS)[number];

regionFaults#

Check a noncancellable region (S3.9.f).

ts
regionFaults(region: NoncancellableRegion, policy: HeartbeatPolicy): readonly RegionFault[]

REGISTER_FAULT_KINDS#

Values: source-missing-from-the-register, source-unreachable, source-scanned-partially, source-scanned-without-a-time, scan-older-than-the-register

REGISTER_VIOLATION_KINDS#

Values: tenant-column-missing, workspace-column-missing, workspace-column-on-a-cross-workspace-entity, scope-column-on-an-unscoped-class, unscoped-class-with-no-declared-reason, public-immutable-that-is-mutable, duplicate-entity, parent-not-registered, join-row-with-one-parent, projection-declared-append-only

RegisteredPlugin#

Field Type Required Notes
descriptor PluginDescriptor required —
contributions readonly ContributionMetadata[] — ContributionMetadata required —

RegisterFault#

Field Type Required Notes
kind RegisterFaultKind required —
subject string required —
detail string required —

RegisterFaultKind#

ts
(typeof REGISTER_FAULT_KINDS)[number];

registerFaults#

Check that the register can be relied on (S3.12.a).

ts
registerFaults(register: ReferenceRegister, maxScanAgeSeconds: number, now: Instant): readonly RegisterFault[]

RegisterViolation#

Field Type Required Notes
kind RegisterViolationKind required —
subject string required —
detail string required —

RegisterViolationKind#

ts
(typeof REGISTER_VIOLATION_KINDS)[number];

releasable#

Sequences that can now be applied, in order, after appliedThrough moved.

ts
releasable(appliedThrough: number, held: readonly number[]): readonly number[]

RELEASE_ELIGIBILITIES#

The headline, and the reason there are six of them.

Values: eligible, eligible-with-waivers, eligible-with-gaps, eligible-by-composition, undetermined, blocked

ReleaseEligibility#

ts
(typeof RELEASE_ELIGIBILITIES)[number];

RemovalEvidence#

Field Type Required Notes
tableRewritten boolean required —
walRetentionElapsed boolean required —
replicasRebuiltOrCaughtUp boolean required —
replicationSlotsDropped boolean required —
backupsExpired boolean required —
indexesRebuilt boolean required —
searchIndexReindexed boolean required —
warehouseColumnDropped boolean required —
cachesInvalidated boolean required —
supportExportsPurged boolean required —

renderIndexDdl#

The CREATE INDEX statement for a declaration.

ts
renderIndexDdl(index: IndexDeclaration, schema?: string): string

RENEWAL_FINDING_KINDS#

Values: chain-loops, link-missing, renewal-does-not-link-back, renewal-widened-the-scope, renewal-lowered-the-accepted-risk, cumulative-duration-exceeds-a-single-grant-limit

RENEWAL_REFUSALS#

Values: renewal-is-a-new-human-action, reversal-is-a-new-human-action, scope-change-is-a-new-human-action

renewalChain#

Walk a renewal chain and add the instalments up (S2.11.c).

ts
renewalChain(from: WaiverGrant, archive: readonly WaiverGrant[], definition: GateDefinition): RenewalChain

RenewalChain#

Field Type Required Notes
waiverIds readonly string[] required Oldest first.
grants number required —
totalHours number required —
findings readonly RenewalFinding[] — RenewalFinding required —

renewalDueAt#

When the holder should send the next beat.

ts
renewalDueAt(lease: JobLease, policy: HeartbeatPolicy): Instant

RenewalFinding#

Field Type Required Notes
kind RenewalFindingKind required —
subject string required —
detail string required —

RenewalFindingKind#

ts
(typeof RENEWAL_FINDING_KINDS)[number];

RenewalOutcome#

ts
| { readonly outcome: 'refused'; readonly reason: RenewalRefusal; readonly detail: string }
| { readonly outcome: 'planned'; readonly supersedes: string; readonly detail: string }

RenewalRefusal#

ts
(typeof RENEWAL_REFUSALS)[number];

replay#

Fold an event stream into a projection (S2.14.c/d).

ts
replay(objectId: string, tenantId: string, events: readonly AuditEvent[]): ReplayOutcome

REPLAY_GUARDS#

Values: event-still-resolves, event-hash-unchanged, handler-version-moved-or-cause-was-environmental, dependencies-present, authorization-still-holds, sequence-position-still-meaningful, dry-run-impact-reviewed

REPLAY_REFUSALS#

Values: row-was-never-published, quarantine-reason-not-resolved, replay-would-mint-a-new-event-id, outside-the-retention-window, payload-already-redacted

ReplayDecision#

ts
| { readonly allowed: true; readonly eventId: string; readonly note: string }
| { readonly allowed: false; readonly refusal: ReplayRefusal; readonly detail: string }

ReplayGuard#

ts
(typeof REPLAY_GUARDS)[number];

ReplayGuardInput#

Field Type Required Notes
record QuarantineRecord required —
eventStillResolves boolean required —
currentEventHash Sha256Hex required —
currentHandlerVersion number required —
causeWasEnvironmental boolean required Whether the original cause was outside the handler (a dead dependency, a bad deploy).
dependenciesPresent boolean required —
stillAuthorized boolean required —
subjectAppliedThrough number required Highest position the subject has applied since.
dryRunReviewed boolean required —

ReplayGuardResult#

Field Type Required Notes
guard ReplayGuard required —
passed boolean required —
detail string required —

replayGuards#

Run every pre-replay guard (S3.8.e).

ts
replayGuards(input: ReplayGuardInput): readonly ReplayGuardResult[]

ReplayOutcome#

Field Type Required Notes
projection AuditProjection required —
pending readonly string[] required Events held because their position had not been reached.
quarantined readonly DeliveryFault[] — DeliveryFault required —

replayParityFaults#

Compare a replayed projection with the stored one, FIELD BY FIELD (S3.7.g).

ts
replayParityFaults(rebuilt: ProjectionSnapshot, stored: ProjectionSnapshot): readonly InboxParityFault[]

ReplayPlan#

Field Type Required Notes
eventId string required UNCHANGED. The consumer's deduplication has to recognise it.
attemptId string required NEW. The audit has to tell the two runs apart.
replayOf string required —
authorizedBy string required —
at Instant required —
note string required —

ReplayRefusal#

ts
(typeof REPLAY_REFUSALS)[number];

ReplayRequest#

Field Type Required Notes
row OutboxRow required —
quarantineResolved boolean required —
reusesEventId boolean required Whether the replay would publish under the row's own id.
now Instant required —
retentionSeconds number required —

ReplayRequestInput#

Field Type Required Notes
record QuarantineRecord required —
eventId string required —
attemptId string required Minted by the caller; it must not equal the event id.
authorizedBy string required —
at Instant required —
guards readonly ReplayGuardResult[] — ReplayGuardResult required —

requestCancel#

Answer a cancel request (S3.9.f).

ts
requestCancel(job: JobRecord, request: CancelRequest): CancelDecision

RequiredEvidence#

What a gate cannot answer without.

Field Type Required Notes
evidenceType string required —
constraint EvidenceVersionConstraint required —
maxAgeSeconds number required How old the evidence may be. Zero is refused; see the validator.
invalidatedBy readonly string[] required Dependencies whose change invalidates it regardless of age.

requiredIndexPrefix#

The columns an index on this entity must start with, derived from the ownership class S3.2 assigned.

ts
requiredIndexPrefix(ownership: OwnershipClass): readonly string[]

REQUIREMENT_FAULT_KINDS#

Values: maximum-below-minimum, no-room-for-a-migration-deployed-ahead-of-this-build, exact-pin-alongside-a-range

REQUIREMENT_KINDS#

Values: extension, table, column, constraint, index, trigger, row-policy, model-registry-entry, permission

REQUIREMENT_VIOLATION_KINDS#

Values: quorum-not-a-positive-integer, quorum-larger-than-the-eligible-set, named-scope-with-nobody-in-it, pool-scope-with-nobody-in-it, quorum-without-independence, sequential-order-with-a-quorum-of-one, no-validity-window, step-up-with-no-accepted-method, step-up-whose-only-methods-are-weak, role-is-blank

RequirementFault#

Field Type Required Notes
kind RequirementFaultKind required —
subject string required —
detail string required —

RequirementFaultKind#

ts
(typeof REQUIREMENT_FAULT_KINDS)[number];

requirementFaults#

Check what the build is asking for (S3.14.c).

ts
requirementFaults(requirement: SchemaRequirement): readonly RequirementFault[]

RequirementKind#

ts
(typeof REQUIREMENT_KINDS)[number];

RequirementViolation#

Field Type Required Notes
kind RequirementViolationKind required —
subject string required —
detail string required —

RequirementViolationKind#

ts
(typeof REQUIREMENT_VIOLATION_KINDS)[number];

residualPlaintext#

The residues that are still holding plaintext, given what has been done.

ts
residualPlaintext(evidence: RemovalEvidence): readonly { readonly residue: PlaintextResidue; readonly why: string; }[]

Residue#

Field Type Required Notes
kind ResidueKind required —
at string required —
why string required —

RESIDUE_KINDS#

Values: content-digest, free-text-reason, subject-identifier, original-id-reused, step-list-claims-more-than-ran

residueIn#

Look for content that survived a purge (S3.3.g).

ts
residueIn(tombstone: PurgeTombstone, originalEntityId: string, actuallyRan: readonly PurgeStep[]): readonly Residue[]

ResidueKind#

ts
(typeof RESIDUE_KINDS)[number];

RESOLUTION_CAPABILITY#

Value: 'protection.resolve'

RESOLUTION_REFUSALS#

Values: purpose-not-declared-for-this-field, caller-lacks-the-capability, identity-is-a-shared-service-account, audit-sink-unavailable, lease-is-unbounded, lease-longer-than-the-maximum, caller-intends-to-cache, reference-is-not-usable

ResolutionDecision#

ts
| { readonly granted: true; readonly lease: SecretLease }
| { readonly granted: false; readonly refusals: readonly ResolutionRefusal[]; readonly detail: string; }

ResolutionRefusal#

ts
(typeof RESOLUTION_REFUSALS)[number];

ResolutionRequest#

Field Type Required Notes
leaseId string required —
reference VaultReference required —
field FieldProtection required —
actorId string required —
actorIsSharedServiceAccount boolean required True when actorId is an identity many callers share.
capabilities readonly string[] required —
purpose string required —
requestedAt Instant required —
leaseSeconds number | null required —
auditAcknowledged boolean required Whether the audit sink acknowledged the record. Fail-closed on false.
intendsToCache boolean required Whether the caller intends to keep the resolved value beyond the lease.

resolveEffect#

The whole truth table, as one function (S2.10.c).

ts
resolveEffect(input: EffectInput): ComponentEffect

resolveInForce#

ts
resolveInForce(from: DecisionRecord, archive: readonly DecisionRecord[]): ChainResolution

resolveRetention#

Combine every retention rule that applies (S3.3.c).

ts
resolveRetention(rules: readonly RetentionRule[]): RetentionResolution

RESTORE_FAULT_KINDS#

Values: key-state-not-restored, restored-under-a-different-tenant, restore-predates-a-crypto-shred

RestoreFault#

Field Type Required Notes
kind RestoreFaultKind required —
subject string required —
detail string required —

RestoreFaultKind#

ts
(typeof RESTORE_FAULT_KINDS)[number];

restoreFaults#

Check a restore (S3.13.g).

ts
restoreFaults(plan: RestorePlan): readonly RestoreFault[]

RestorePlan#

Field Type Required Notes
backupTakenAt Instant required —
rowsRestored number required —
keyVersionsInBackup readonly string[] required —
keyVersionsAvailable readonly string[] required —
backupTenantId string required —
targetTenantId string required —
shredsSince readonly { readonly keyId: string; readonly at: Instant }[] — Instant required Crypto-shreds performed after the backup was taken.

RESUME_DECISIONS#

Values: resume-from-checkpoint, restart-stage, refuse

ResumeDecision#

Field Type Required Notes
decision ResumeDecisionKind required —
detail string required —

ResumeDecisionKind#

ts
(typeof RESUME_DECISIONS)[number];

ResumeInput#

Field Type Required Notes
checkpoint JobCheckpoint | null — JobCheckpoint required —
stage string required —
readableCheckpointVersions readonly number[] required Cursor shape versions this worker can read.
workerTypeVersion number required —
compatibleTypeVersions readonly number[] required Handler versions whose checkpoints this worker declares itself able to continue.
leaseFencingToken number required —
stageIsIdempotent boolean required —

RETENTION_FAULT_KINDS#

Values: irreversible-record-expires-inside-the-retry-window, irreversible-record-with-no-retention-at-all, reversible-record-kept-longer-than-the-policy, expiry-before-the-claim

RETENTION_SOURCES#

Values: category-default, tenant-policy, contractual-maximum, regulatory-minimum

RetentionFault#

Field Type Required Notes
kind RetentionFaultKind required —
subject string required —
detail string required —

RetentionFaultKind#

ts
(typeof RETENTION_FAULT_KINDS)[number];

retentionFaults#

Check that a record lives long enough to do its job (S3.4.f).

ts
retentionFaults(record: IdempotencyRecord, policy: RetentionPolicy): readonly RetentionFault[]

RetentionPolicy#

Field Type Required Notes
maximumRetryWindowHours number required How long a client may keep retrying. Every record must outlive this.
reversibleMaximumHours number required The cap for a reversible operation, which may be short.

RetentionResolution#

ts
| { readonly resolved: true; readonly minimumDays: number; readonly maximumDays: number | null; readonly minimumFrom: RetentionSource; readonly maximumFrom: RetentionSource | null; }
| { readonly resolved: false; readonly reason: string; readonly conflict: readonly string[] }

RetentionRule#

Field Type Required Notes
source RetentionSource required —
minimumDays number | null required A floor: the data may NOT be deleted before this many days.
maximumDays number | null required A ceiling: the data MUST be deleted by this many days.
category string required —
authority string required —
reviewBy Instant required —

RetentionSource#

ts
(typeof RETENTION_SOURCES)[number];

RetryPolicy#

Field Type Required Notes
baseSeconds number required —
maxSeconds number required —
maxAttempts number required —
maxUnknownAttempts number required Attempts allowed for an UNKNOWN failure before it is quarantined.
maxAgeSeconds number required The age past which a row stops being retried whatever its attempt count. Attempts alone lets a row on a long backoff live for weeks.

RetryTarget#

Field Type Required Notes
childId string required —
inputHash Sha256Hex required What the retry would run this child over.
typeVersion number required —

REUSE_DECISIONS#

Values: reuse, rerun

ReuseDecision#

ts
(typeof REUSE_DECISIONS)[number];

Reversal#

ts
| { readonly reversible: true; readonly byTransitionId: string }
| { readonly reversible: false; readonly reason: string }

REVERSIBLE_STRATEGIES#

Strategies that leave the value recoverable by whoever holds the key.

Values: vault-reference, encrypt-at-rest, deterministic-token

ReviewedState#

Exactly what the person looked at.

Field Type Required Notes
targetRevision RevisionId required —
evidenceVersions Readonly<Record<string, number>> required —
policyVersion number required —
audiences readonly GateAudience[] — GateAudience required —
channels readonly string[] required —

REVISION_CONSTRAINTS#

The constraints a revision table must carry, as a declared list.

Values: unique-revision-id, unique-sequence-per-entity, sequence-starts-at-one, parent-references-a-revision, parent-is-not-itself, parent-is-in-the-same-entity, base-references-a-revision, single-head-per-entity

RevisionConstraint#

ts
(typeof REVISION_CONSTRAINTS)[number];

revisionHoldMarker#

The marker S2.4 puts on a revision, derived from the record here.

ts
revisionHoldMarker(hold: LegalHoldRecord): { readonly holdId: string; readonly authority: string; readonly placedAt: Instant; readonly reason: string; }

REVOCATION_EFFECTS#

What has to happen when a key at a given tier is replaced or withdrawn.

Values: re-wrap, re-encrypt-rows, crypto-shred

RevocationEffect#

ts
(typeof REVOCATION_EFFECTS)[number];

revocationPlan#

ts
revocationPlan(tier: KeyTier, destroyMaterial: boolean): RevocationPlan

RevocationPlan#

Field Type Required Notes
tier KeyTier required —
effect RevocationEffect required —
blastRadius BlastRadius required —
touchesRows boolean required —
reversible boolean required —
detail string required —

rootBlockers#

The children actually holding the graph up (S3.10.g).

ts
rootBlockers(graph: JobGraph, parentId: string): readonly string[]

ROW_FAULT_KINDS#

Values: no-tenant, no-producer, no-subject, no-event-kind, event-version-not-a-positive-integer, sequence-not-a-positive-integer, no-correlation-id, causation-is-itself, payload-too-big-to-be-inline, available-before-it-occurred, leased-without-a-lease, lease-without-the-leased-state, published-without-a-time, attempt-negative

RowFault#

Field Type Required Notes
kind RowFaultKind required —
subject string required —
detail string required —

RowFaultKind#

ts
(typeof ROW_FAULT_KINDS)[number];

rowFaults#

Check one row against the shape S3.6.a requires.

ts
rowFaults(row: OutboxRow): readonly RowFault[]

runPurge#

Run a purge (S3.3.e/f).

ts
runPurge(execute: PurgeExecutor, alreadyDone: readonly PurgeStep[] = []): PurgeRun

RunTrigger#

Who or what caused the run.

ts
| { readonly kind: 'actor'; readonly actorId: string }
| { readonly kind: 'job'; readonly jobId: string }
| { readonly kind: 'schedule'; readonly scheduleId: string }

SAFE_WRITE_PROBE_METHODS#

Values: dedicated-probe-table, temporary-table, advisory-lock

safeDetailIsUsable#

Whether a report's own free text is safe to render. Borrowed from S1.6.

ts
safeDetailIsUsable(report: ProbeReport): boolean

SchedulingDecision#

Field Type Required Notes
ready readonly string[] required Authorized to start now, in declared ordinal order.
blocked readonly BlockedChild[] — BlockedChild required Waiting on a dependency that has not finished.
deferred readonly string[] required Ready, but there is no slot or no budget. Not a refusal — an absence of an offer.
unreachable readonly BlockedChild[] — BlockedChild required Waiting on a dependency that will never finish. Reporting these as blocked is how a graph sits in waiting with nothing left to wait for.
detail string required —

SchedulingRequest#

Field Type Required Notes
graph JobGraph required —
parentId string required —
running number required Slots in flight and the ceiling for this queue.
concurrency number required —
budgetCeiling number required —
budgetSpent number required —
budgetUnit string required —
estimatedCosts Readonly<Record<string, number>> required What each child is expected to cost. Missing entries are treated as unknown and refused.

SCHEMA_STATE_POLICY#

What each schema state means for each capability.

SCHEMA_STATES#

Values: compatible, too-old, too-new, dirty, in-progress, unknown

SchemaRange#

The wire schema range, which is an INTEGER range and not a semantic one.

Field Type Required Notes
minimum number required —
below number required —

schemaRangeAdmits#

ts
schemaRangeAdmits(range: SchemaRange, version: number): boolean

SchemaRequirement#

Field Type Required Notes
minimum number required The oldest schema this build can run against.
maximum number required The newest schema this build has been taught. Must exceed minimum, or the build cannot be deployed alongside a migration that ran ahead of it.
exact number | null required A DECLARATION that the narrowness above is deliberate, for a build that may only run against exactly one schema.

SchemaState#

ts
(typeof SCHEMA_STATES)[number];

SchemaVerdict#

Field Type Required Notes
state SchemaState required —
detail string required —
transient boolean required Whether waiting is the correct response, rather than failing.

SCOPE_FAULT_KINDS#

Values: no-tenant-predicate, workspace-predicate-without-a-tenant-predicate, no-workspace-predicate, joined-entity-unscoped, unregistered-entity

SCOPE_VIOLATION_KINDS#

Values: no-tenant, no-client, no-operation, operation-version-not-a-positive-integer, no-key, key-is-not-opaque

ScopedRow#

A row as the checker sees it: an identity plus the scope it claims.

Field Type Required Notes
entity string required —
rowId string required —
tenantId string | null required —
workspaceId string | null required —
parentRowId string | null required —
secondParentRowId string | null required —

ScopeFault#

Field Type Required Notes
kind ScopeFaultKind required —
subject string required —
detail string required —

ScopeFaultKind#

ts
(typeof SCOPE_FAULT_KINDS)[number];

scopeFaults#

Check that a query carries the predicates its entity requires (S3.2.f).

ts
scopeFaults(query: QueryShape, register: readonly EntityRegistration[]): readonly ScopeFault[]

scopeKey#

The value a unique index is built over. Stable, ordered, total, and injective.

ts
scopeKey(scope: IdempotencyScope): string

ScopeViolation#

Field Type Required Notes
kind ScopeViolationKind required —
subject string required —
detail string required —

ScopeViolationKind#

ts
(typeof SCOPE_VIOLATION_KINDS)[number];

scopeWidening#

What the proposal now covers that the reviewer was not shown.

ts
scopeWidening(reviewed: ReviewedState, current: ReviewedState): string | null

ScopeWidening#

Queries whose scope predicates are narrower than the entity's ownership class implies, and what authorizes each one.

Field Type Required Notes
queryId string required —
omits 'tenantId' | 'workspaceId' required The scope predicate the query does not carry.
why string required —
authorizedBy string required What stands in for the missing predicate. Never "nothing".

SEAL_REFUSALS#

Values: context-is-not-usable, value-is-not-a-string, field-is-not-encrypted-at-rest, value-is-already-sealed, key-is-retired, key-is-not-for-this-tenant, key-does-not-seal-this-field, cipher-refused

SEALED_FIELD_SCHEMA_VERSION#

Value: 1

SealedField#

A sealed field, as it sits in a column.

Field Type Required Notes
schema typeof SEALED_FIELD_SCHEMA_VERSION — SEALED_FIELD_SCHEMA_VERSION required —
algorithm AeadAlgorithm required —
keyId string required —
keyVersion string required —
nonce string required —
ciphertext string required —
context ProtectionContext required —

sealField#

Seal a value before it is persisted (S3.13.c).

ts
sealField(cipher: FieldCipher, key: KeyDescriptor, field: FieldProtection, context: ProtectionContext, plaintext: unknown): SealResult

SealRefusal#

ts
(typeof SEAL_REFUSALS)[number];

SealRequest#

Field Type Required Notes
keyId string required —
keyVersion string required —
algorithm AeadAlgorithm required —
plaintext string required —
aad string required —

SealResult#

ts
| { readonly ok: true; readonly sealed: SealedField }
| { readonly ok: false; readonly refusal: SealRefusal; readonly detail: string }

SecretLease#

Field Type Required Notes
leaseId string required —
purpose string required —
expiresAt Instant required —
mustNotPersist true required Always true. A field on the lease so a usage record can be checked against it.

SecretUsage#

Field Type Required Notes
leaseId string required —
usedAt Instant required —
purpose string required —
persistedTo readonly string[] required Anywhere the resolved value was written. Empty is the only correct answer.
useCount number required How many times this lease was used. One is the contract.

selectBatch#

Select a batch, as the query would.

ts
selectBatch(request: ClaimRequest): readonly OutboxRow[]

SelectionContract#

What a projection can be handed.

Field Type Required Notes
selects 'entity' | 'revision' | 'block' | 'range' | 'job' | 'artifact' required —
multiple boolean required Whether more than one may be selected at once.

SEMANTIC_NODE_KINDS#

The semantic vocabulary a block renders into.

Values: heading, paragraph, list, list-item, table, row, cell, figure, code, quote, term

SemanticNode#

Field Type Required Notes
kind SemanticNodeKind required —
text string | null required Plain text. Never markup, and never a translation key — this is content.
textAlternative string | null required The text alternative for a node whose meaning is not carried by its text.
children readonly SemanticNode[] — SemanticNode required —

SemanticNodeKind#

ts
(typeof SEMANTIC_NODE_KINDS)[number];

SemanticRange#

A half-open version range: >= minimum, < below.

Field Type Required Notes
minimum SemanticVersion required —
below SemanticVersion required —

semanticRangeAdmits#

ts
semanticRangeAdmits(range: SemanticRange, version: SemanticVersion): boolean

SENSITIVITY_CLASSES#

Why a field is protected.

Values: authentication-credential, payment-instrument, government-identifier, health, biometric, protected-source, learner-record, unreleased-asset, precise-location, private-communication, contact-detail

SensitivityClass#

ts
(typeof SENSITIVITY_CLASSES)[number];

SERVE_DECISIONS#

Values: serve, serve-degraded, refuse, wait

SERVED_CAPABILITIES#

What a process may be asked to do.

Values: read, write, job, migration-admin

ServedCapability#

ts
(typeof SERVED_CAPABILITIES)[number];

ServeDecision#

ts
(typeof SERVE_DECISIONS)[number];

severityAt#

The severity that applies at one stage.

ts
severityAt(definition: GateDefinition, lifecycleStage: string): GateSeverity

SHARED_ENTITY_REGISTER#

The shared entity register this kit ships (S3.2.a).

SHARED_IDENTIFIER_LOOKUPS#

The identifier lookups whose uniqueness identifierFaults checks (S3.5.g).

SHARED_INDEX_PLAN#

Every index the shared platform declares.

SHARED_VOLUME_PROFILES#

The distributions the shared workload is measured against (S3.5.a).

SHARED_WORKLOAD#

Every access path the shared platform's own entities carry.

SHRED_REFUSALS#

Values: legal-hold-covers-a-field-under-this-key, no-inventory-of-what-this-key-protects, key-still-wraps-live-keys, shred-would-cross-a-tenant

ShredDecision#

ts
| { readonly allowed: true; readonly fieldIds: readonly string[]; readonly detail: string }
| { readonly allowed: false; readonly refusals: readonly ShredRefusal[]; readonly detail: string; }

ShredRefusal#

ts
(typeof SHRED_REFUSALS)[number];

SIGNOFF_DECISIONS#

Values: approved, rejected, abstained

SIGNOFF_ORDERS#

Whether the signatures may be collected at once or have to be ordered.

Values: parallel, sequential

SIGNOFF_STANDINGS#

Values: standing, expired, target-moved, evidence-moved, policy-moved, scope-widened, superseded

SignoffDecision#

ts
(typeof SIGNOFF_DECISIONS)[number];

SignoffOrder#

ts
(typeof SIGNOFF_ORDERS)[number];

SignoffRecord#

Field Type Required Notes
signoffId string required —
gateId string required —
by HumanPresence required Only admitSigner can produce this, and only for a real, present person.
role string required —
decision SignoffDecision required —
comment string required —
reviewed ReviewedState required —
reviewOpenedAt Instant required —
signedAt Instant required —
conflicts readonly ConflictDeclaration[] — ConflictDeclaration required —
attestation string required Whatever the deployment can produce: a detached signature, an HSM receipt, an audit-log id.
supersedes string | null required —

SignoffRow#

Field Type Required Notes
signoffId string required —
by string | null required —
at Instant required —
standing boolean required —

SignoffScope#

Who may sign: a named person, or anyone from a declared pool.

ts
| { readonly kind: 'named'; readonly actorIds: readonly string[] }
| { readonly kind: 'pool'; readonly poolId: string; readonly members: readonly string[] }

SignoffStanding#

ts
(typeof SIGNOFF_STANDINGS)[number];

signoffStatus#

Whether a signature still covers what is in front of you (S2.13.e).

ts
signoffStatus(record: SignoffRecord, current: CurrentState, requirement: HumanGateRequirement, supersededBy: string | null): SignoffStatus

SignoffStatus#

Field Type Required Notes
signoffId string required —
standing SignoffStanding required —
stillStands boolean required True for exactly one standing.
reasonKey string required —
detail string required —
by string required —
signedAt Instant required —
decision SignoffDecision required —

SILENT_WHEN_ABSENT#

The kinds whose ABSENCE is silent.

Values: row-policy, constraint, permission

sniffMediaType#

Decide what the bytes are (S3.11.b).

ts
sniffMediaType(bytes: Uint8Array): SniffResult

SniffResult#

Field Type Required Notes
matches readonly string[] required Every signature the bytes matched, sorted.
leading string | null required The leading signature, or null when nothing matched at offset 0.
polyglot boolean required True when the bytes are simultaneously two formats.
executable boolean required —

SORT_DIRECTIONS#

Values: asc, desc

SortDirection#

ts
(typeof SORT_DIRECTIONS)[number];

sortIsTotal#

Whether the query's ordering is total — that is, whether two runs of it must return the same rows in the same order.

ts
sortIsTotal(query: WorkloadQuery, profile: VolumeProfile): boolean

SortKey#

Field Type Required Notes
column string required —
direction SortDirection required —
collation Collation optional The collation the ordering is requested in. Defaults to the database's, and has to be stated when the index that serves the query is built in another one — an ordering in a collation the index was not built in is an ordering the index cannot provide, however right the columns look.

SPOOF_FAULT_KINDS#

Values: declared-type-not-observed, declared-type-unrecognisable, polyglot-content, executable-content, filename-extension-disagrees-with-bytes, declared-size-disagrees-with-stored

SpoofFault#

Field Type Required Notes
kind SpoofFaultKind required —
subject string required —
detail string required —

SpoofFaultKind#

ts
(typeof SPOOF_FAULT_KINDS)[number];

spoofFaults#

Compare what was claimed against what was found (S3.11.b).

ts
spoofFaults(blobId: string, declared: DeclaredMetadata, sniff: SniffResult, storedByteSize: number): readonly SpoofFault[]

STAGE_VIOLATION_KINDS#

Values: duplicate-stage, no-initial-stage, multiple-initial-stages, no-terminal-stage, initial-stage-is-terminal, empty-universe, stage-label-not-a-key, stage-has-no-meaning, empty-source-set, unknown-stage, duplicate-transition-id, duplicate-edge, terminal-stage-has-exit, self-transition-not-reentrant, unreachable-stage, unintended-cycle, unknown-guard, reversal-target-missing, reversal-target-not-inverse, effect-without-reversal

StageCommit#

Field Type Required Notes
write FencedWrite required —
effect StageEffect required —
checkpoint JobCheckpoint required —
ordering CheckpointOrdering required —
note string required —

StageDefinition#

One stage in a domain's own workflow.

Field Type Required Notes
stage TStage required —
labelKey string required —
terminal boolean required No transition may leave a terminal stage.
reentrant boolean required Whether a transition may land on the stage it left.

StageEffect#

Field Type Required Notes
stage string required —
description string required —
transactional boolean required Whether the effect can join the job store's own transaction.
idempotent boolean required Whether applying it twice is the same as applying it once.

StageGraph#

Field Type Required Notes
[graphBrand] TStage required —
universe StageUniverse<TStage> — StageUniverse required —
transitions readonly Transition<TStage>[] — Transition required —
byId ReadonlyMap<string, Transition<TStage>> — Transition required —
outgoing ReadonlyMap<TStage, readonly Transition<TStage>[]> — Transition required —

StageModel#

Field Type Required Notes
modelId string required —
stages readonly StageDefinition<TStage>[] — StageDefinition required —
initial TStage required —
transitions readonly StageTransition<TStage>[] — StageTransition required —

StageModelContribution#

Field Type Required Notes
model StageModel<TStage> — StageModel required —
guards readonly TransitionGuard<TStage, TSubject>[] — TransitionGuard required —

StageModelMetadata#

Field Type Required Notes
extensionPoint 'stage-model' required —
model StageModel<string> — StageModel required —
guardIds readonly string[] required The guards registered alongside the model, by id.

StageProgress#

Field Type Required Notes
stage string required —
completed number required —
total number | null required null when the total is not known YET. Not 0: a stage that reports 0 of 0 renders as a full bar in every progress widget ever written, which is the false completion this whole section exists to stop.
messageKey string required An i18n key, never a sentence — this string is rendered to a person (S1.10's rule).
outputRefs readonly string[] required —
observedAt Instant required —

StageResult#

ts
| { readonly ok: true; readonly value: T }
| { readonly ok: false; readonly violations: readonly StageViolation[] }

StageSeverity#

Field Type Required Notes
lifecycleStage string required —
severity GateSeverity required —

StageSpec#

One stage, as its owning domain defines it.

Field Type Required Notes
stage TStage required —
labelKey string required A translation key. A literal here is text no translator will ever see.
initial boolean required Exactly one stage in a universe is where an object starts.
terminal boolean required No transition may leave a terminal stage.
reentrant boolean required Whether a transition may land on the stage it left.
meaning string required What being in this stage MEANS, for the reader deciding where to add one.

StageTransition#

Field Type Required Notes
transitionId string required —
from TStage required —
to TStage required —
guards readonly string[] required Guard ids, resolved against the registered guards at validation time.
requiresAuthorizationScope string | null required Null when any actor who can see the entity may perform it.

StageUniverse#

Field Type Required Notes
[universeBrand] TStage required —
stages readonly StageSpec<TStage>[] — StageSpec required —
initial TStage required —
byStage ReadonlyMap<TStage, StageSpec<TStage>> — StageSpec required —

StageViolation#

Field Type Required Notes
kind StageViolationKind required —
subject string required —
detail string required —

StageViolationKind#

ts
(typeof STAGE_VIOLATION_KINDS)[number];

Staleness#

ts
(typeof STALENESS)[number];

STALENESS#

Values: current, source-moved, ingredient-moved, unknown

stalenessOf#

Whether a derived blob still describes its ancestors (S3.11.f).

ts
stalenessOf(input: { readonly manifest: ProvenanceManifest; readonly currentSourceRevisionId: string | null; readonly currentIngredientDigests: Readonly<Record<string, Sha256Hex>>; }): StalenessVerdict

StalenessVerdict#

Field Type Required Notes
staleness Staleness required —
moved readonly string[] required —
detail string required —

STEP_UP_METHODS#

Values: webauthn, hardware-key, totp, sms, password

STEP_UP_WINDOW_MINUTES#

How long a step-up stands for the decision it was performed for.

Value: 15

StepOutcome#

Field Type Required Notes
step PurgeStep required —
outcome 'done' | 'failed' | 'skipped' required —
detail string required —

StepUpMethod#

ts
(typeof STEP_UP_METHODS)[number];

StorageLocator#

Where the bytes are.

Field Type Required Notes
adapter string required —
bucket string required —
key string required —
version string | null required The store's own version handle, or null on a store with no versioning.

strategiesFor#

The strategies that could serve a declared set of operations, strongest first.

ts
strategiesFor(operations: readonly FieldOperation[]): readonly ProtectionStrategy[]

STRATEGY_CAPABILITIES#

What each strategy can actually support.

STRATEGY_FAULT_KINDS#

Values: unknown-plugin-strategy, plugin-strategy-is-order-dependent, plugin-strategy-threw, plugin-strategy-returned-a-non-trivalent

StrategyFaultKind#

ts
(typeof STRATEGY_FAULT_KINDS)[number];

StrategyMember#

What a plugin strategy is handed. Frozen; see .

Field Type Required Notes
gateId string required —
trivalent Trivalent required —
severity GateSeverity required —

subjectKey#

ts
subjectKey(subject: EventSubject): string

supersede#

Produce the two records a supersession consists of.

ts
supersede(original: DecisionRecord, replacement: DecisionRecord): SupersessionOutcome

supersedes#

The link a NEW signature carries to say what it replaces.

ts
supersedes(previous: SignoffRecord): string

supersessionHarms#

Check that a supersession replaced rather than rewrote (S2.7.f).

ts
supersessionHarms(originalBefore: DecisionRecord, originalAfter: DecisionRecord, replacement: DecisionRecord): readonly LineageHarm[]

SupersessionOutcome#

ts
| { readonly outcome: 'planned'; readonly original: DecisionRecord; readonly replacement: DecisionRecord; }
| { readonly outcome: 'refused'; readonly reason: string }

SUPPORT_LEVELS#

Values: implemented, degraded, unsupported

SupportLevel#

ts
(typeof SUPPORT_LEVELS)[number];

supportsKit#

ts
supportsKit(descriptor: PluginDescriptor, kitVersion: SemanticVersion): boolean

supportsSchema#

ts
supportsSchema(descriptor: PluginDescriptor, schemaVersion: number): boolean

SURFACE_EVENTS#

A decision surface the platform has, and the event kind that records it.

SurfaceSample#

Field Type Required Notes
surface RedactionSurface required —
at string required —
text string required What the surface actually emitted.
keys readonly string[] required Structured keys present on the surface, e.g. metric labels or log fields.
carriesKeyMaterial boolean optional For backup: whether the same artifact also carries key material.

SWEEPABLE_BLOB_STATES#

Blob states a sweep may act on at all. Anything else needs a person.

Values: pending-upload, active, rejected

TargetPredicate#

A condition over facts the RUN recorded, not a closure.

Field Type Required Notes
fact string required —
equals string required —

TAXONOMY_DIMENSIONS#

S3.5.e — the taxonomy queries a workbench supports.

TAXONOMY_INDEXES#

S3.5.e — taxonomy: both directions of the join, the path, and the alias.

TEMPORAL_DIMENSIONS#

S3.5.d — the eight kinds of time, and which of them the kit owns a column for.

TEMPORAL_INDEXES#

S3.5.d — time, each one ending in the identifier that makes the order total.

TERMINAL_JOB_STATES#

Values: cancelled, succeeded, dead-lettered

TERMINAL_OUTBOX_STATES#

States a row never leaves.

Values: archived

TERMINAL_STATES#

Once here, there is nothing to transition to.

Values: purged

TimelineEntry#

Field Type Required Notes
sequence number required —
kind AuditEventKind required —
at Instant required —
actorId string | null required —
onBehalfOf string | null required —
reasonKey string required —
detail string required —
correlationId string required —

toSnakeCase#

camelCase to snake_case, which is the column spelling in DDL.

ts
toSnakeCase(name: string): string

toWaiverRecord#

The record S2.10's fold reads, for an authorizing waiver only.

ts
toWaiverRecord(grant: WaiverGrant, standing: WaiverStanding, reason: string): WaiverRecord | null

TransactionalStore#

TransactionHandle#

Field Type Required Notes
id string required —

Transformation#

Field Type Required Notes
kind TransformationKind required —
tool string required —
toolVersion string required —
parameters string required —
at Instant required —

TRANSFORMATION_KINDS#

Values: transcode, resize, redact, compress, extract, compose, sign

TransformationKind#

ts
(typeof TRANSFORMATION_KINDS)[number];

Transition#

Field Type Required Notes
transitionId string required —
from readonly TStage[] required The stages this may be taken FROM. A set, not one stage: "cancel" is one transition available from three stages, and modelling it as three transitions is three places to add the fourth guard to.
to TStage required —
trigger Trigger required —
requiresScope string | null required Null when any actor who can see the object may take it.
guards readonly string[] required Guard ids, resolved against the registered guards when the graph is built.
effects readonly EffectKind[] — EffectKind required —
reversal Reversal required —
revisits boolean required True when this edge deliberately returns an object to a stage it has already been in — rework, reopen, re-review.

TRANSITION_REFUSALS#

Values: import-preserved-the-source-tenant, transfer-left-part-of-the-subtree-behind, cross-tenant-share-is-not-a-share, fork-that-did-not-copy, public-immutable-cannot-be-transferred, tenant-migration-without-an-approver, export-of-an-entity-nobody-may-export

TRANSITION_REFUSALS#

Values: no-such-transition, purged-is-terminal, legal-hold-blocks-progress, grace-period-has-not-elapsed, retention-has-not-elapsed, no-actor, no-reason

TransitionCommand#

The only shape that can move an object along a declared edge.

Field Type Required Notes
transitionId string required —
subjectId string required —
from TStage required —
expectedRevision string required —
actor ActorDecision required The authorization VERDICT, not a claim — see ./invariants.ts.
actorRef ActorRef required —
at Instant required —
idempotencyKey string required —
verdicts readonly GuardVerdict[] — GuardVerdict required One verdict per guard the transition requires. Missing ones are refused.

transitionDecision#

Fold guard answers into one decision, fail-closed and in a stable order.

ts
transitionDecision(outcomes: readonly GuardOutcome[]): GuardOutcome

TransitionDecision#

ts
| { readonly allowed: true; readonly note: string }
| { readonly allowed: false; readonly refusal: TransitionRefusal; readonly detail: string }

TransitionGuard#

Field Type Required Notes
guardId string required —
describe string required —
evaluate (input: TransitionInput<TStage, TSubject>) => GuardOutcome — GuardOutcome, TransitionInput required —

TransitionInput#

What a guard was asked about.

Field Type Required Notes
subject TSubject required —
from TStage required —
to TStage required —
actor ActorRef required —
at Instant required —

TransitionOutcome#

ts
| { readonly outcome: 'planned'; readonly plan: PlannedTransition<TStage> }
| { readonly outcome: 'not-allowed'; readonly reason: string }
| { readonly outcome: 'unauthorized'; readonly reason: string }
| { readonly outcome: 'blocked'; readonly blocking: readonly GuardVerdict[]; readonly reason: string; }
| { readonly outcome: 'indeterminate'; readonly unanswered: readonly GuardVerdict[]; readonly reason: string; }
| { readonly outcome: 'invalid-bypass'; readonly missing: readonly string[] }

TransitionOutcome#

ts
| { readonly allowed: true; readonly to: DeletionState }
| { readonly allowed: false; readonly refusal: TransitionRefusal; readonly detail: string }

TransitionRefusal#

ts
(typeof TRANSITION_REFUSALS)[number];

TransitionRefusal#

ts
(typeof TRANSITION_REFUSALS)[number];

TransitionRequest#

Field Type Required Notes
transition BoundaryTransition required —
entity EntityRegistration required —
fromTenant string required —
toTenant string required —
fromWorkspace string | null required —
toWorkspace string | null required —
subtreeIncluded boolean required True when the whole dependent subtree moves with it.
rescoped boolean required True when the copy is re-scoped to the destination rather than preserved.
sourceRetained boolean required True when the source keeps its rows (a share or a fork) rather than losing them.
approvedBy string | null required —

TransitionRequest#

Field Type Required Notes
from DeletionState required —
to DeletionState required —
actorId string required —
reason string required —
at Instant required —
underLegalHold boolean required True while any hold covers the subject.
graceEndsAt Instant | null — Instant required When the grace period ends. Null when none applies.
retentionEndsAt Instant | null — Instant required When retention allows a purge. Null when no retention applies.

Trigger#

ts
(typeof TRIGGERS)[number];

TRIGGERS#

What causes a transition to be attempted.

Values: actor, system, schedule, upstream-event

Trivalent#

ts
(typeof TRIVALENTS)[number];

trivalentOf#

The trivalent a state contributes.

ts
trivalentOf(state: ComponentState): Trivalent | null

TRIVALENTS#

Kleene's third value, and the reason any-of over a gap is not a refusal.

Values: true, false, unknown

UNAUTHORIZED_READER_SURFACES#

The surfaces a reader outside the row's own authorization can see.

Values: orm-error, application-log, trace-attribute, metric-label, audit-summary, test-snapshot, support-export

UNAVAILABLE_BEHAVIOURS#

What happens when the evidence is not there.

Values: block, warn, skip-with-record

UnavailableBehaviour#

ts
(typeof UNAVAILABLE_BEHAVIOURS)[number];

uncoveredSurfaces#

Decision surfaces with no event kind behind them (S2.14.a).

ts
uncoveredSurfaces(surfaces: Readonly<Record<string, AuditEventKind>>, available: readonly AuditEventKind[]): readonly string[]

unexpectedFaults#

The faults that are not declared limitations.

ts
unexpectedFaults(faults: readonly IndexFault[], known: readonly KnownLimitation[] = KNOWN_WORKLOAD_LIMITATIONS): readonly IndexFault[]

unintendedCycles#

Cycles nobody declared.

ts
unintendedCycles(universe: StageUniverse<TStage>, transitions: readonly Transition<TStage>[]): readonly StageViolation[]

unreachableFrom#

Stages no sequence of edges reaches from the initial one.

ts
unreachableFrom(edgeSet: EdgeSet): readonly string[]

UNREADABLE_BLOB_STATES#

A blob nothing may read yet.

Values: pending-upload, quarantined, rejected

unscannedSurfaces#

Surfaces no sample covered. A scan is a claim about what it looked at.

ts
unscannedSurfaces(samples: readonly SurfaceSample[]): readonly RedactionSurface[]

unservedDimensions#

Dimensions naming an index that is not in the plan.

ts
unservedDimensions(dimensions: readonly AccessDimension[], indexes: readonly IndexDeclaration[]): readonly AccessDimension[]

UNSUPPORTABLE_OPERATIONS#

The operations no protection strategy supports, at all.

Values: range-or-sort, prefix-search, full-text-search

USAGE_FAULT_KINDS#

Values: used-after-the-lease-expired, used-for-a-different-purpose, value-was-persisted, lease-used-more-than-once

UsageFault#

Field Type Required Notes
kind UsageFaultKind required —
subject string required —
detail string required —

UsageFaultKind#

ts
(typeof USAGE_FAULT_KINDS)[number];

usageFaults#

Check what a caller did with a lease (S3.13.d).

ts
usageFaults(lease: SecretLease, usage: SecretUsage): readonly UsageFault[]

validateAggregatePolicy#

Check a release policy (S2.10.d/f).

ts
validateAggregatePolicy(policy: AggregatePolicy): readonly AggregatePolicyViolation[]

validateAuditEvent#

Check one recorded event (S2.14.b).

ts
validateAuditEvent(event: AuditEvent): readonly EventViolation[]

validateBinding#

ts
validateBinding(consumer: string, binding: Binding): readonly BindingFault[]

validateBlockContribution#

S1.9.d — the migration chain, which is where an old document goes to die.

ts
validateBlockContribution(contribution: BlockMetadata, subjectPrefix: string): readonly PluginViolation[]

validateDecision#

Check a decision record against everything it claims to be (S2.7.a–d).

ts
validateDecision(record: DecisionRecord, policy: DecisionPolicy = DEFAULT_DECISION_POLICY): readonly DecisionViolation[]

validateGateDefinition#

Check a gate definition (S2.9.a–f).

ts
validateGateDefinition(definition: GateDefinition): readonly GateDefinitionViolation[]

validateGateRegistry#

Check a whole catalogue, which is where the cross-gate faults live.

ts
validateGateRegistry(definitions: readonly GateDefinition[]): readonly GateRegistryViolation[]

validateGateRunResult#

Check a recorded run against the definition it claims to answer (S2.10.a/b).

ts
validateGateRunResult(result: GateRunResult, definition: GateDefinition): readonly GateRunViolation[]

validateHold#

Check a hold (S3.3.d).

ts
validateHold(hold: LegalHoldRecord): readonly HoldViolation[]

validateHumanGate#

Check what a human gate asks for (S2.13.a).

ts
validateHumanGate(requirement: HumanGateRequirement): readonly RequirementViolation[]

validateKey#

ts
validateKey(key: InboxKey): readonly KeyFault[]

validatePlugins#

The set-level check.

ts
validatePlugins(plugins: readonly RegisteredPlugin[], options: PluginValidationOptions = {}): readonly PluginViolation[]

validateProjectionContribution#

S1.9.e — isolation, authorization and the required non-visual path.

ts
validateProjectionContribution(contribution: ProjectionMetadata, subjectPrefix: string, protectedClassifications: readonly DataClassification[]): readonly PluginViolation[]

validateRegister#

Check an entity register (S3.2.a/b).

ts
validateRegister(register: readonly EntityRegistration[]): readonly RegisterViolation[]

validateScope#

Check the scope a record is keyed by (S3.4.c).

ts
validateScope(scope: IdempotencyScope): readonly ScopeViolation[]

validateSignoff#

Check one signature (S2.13.d).

ts
validateSignoff(record: SignoffRecord): readonly RecordViolation[]

validateStageModel#

S1.9.b — the stage model, checked without any opinion about stage NAMES.

ts
validateStageModel(contribution: StageModelMetadata, subjectPrefix: string): readonly PluginViolation[]

validateWaiverGrant#

Check a grant against the request it answers and the gate it waives (S2.11.a–c).

ts
validateWaiverGrant(grant: WaiverGrant, request: WaiverRequest, definition: GateDefinition, recomputedRequestDigest: Sha256Hex): readonly WaiverViolation[]

VaultReference#

Field Type Required Notes
scheme string required The vault, e.g. vault or secretsmanager. Never a value.
path string required —
version string | null required Pinned. An unversioned reference resolves to whatever is current.

VerdictName#

ts
(typeof VERDICTS)[number];

VERDICTS#

Values: pass, warn, block, needs-human, indeterminate

VERIFICATION_OUTCOMES#

Values: verified, corrupt, absent, unverifiable-source, partial-read

VERIFICATION_SOURCES#

Values: target-readback, target-receipt-signature, third-party-attestation

VerificationInput#

Field Type Required Notes
expected ByteDigest | null — ByteDigest required What was recorded when the blob was admitted.
actual ByteDigest | null — ByteDigest required What was computed now, or null if the object could not be read.
source DigestVerificationSource required —
bytesRead number required Bytes actually read. Compared to the expected size to catch a short read.
expectedByteSize number required —

verificationIsIndependent#

Refuse a verification that could not have observed anything.

ts
verificationIsIndependent(verification: PublishVerification): ParseResult<PublishVerification>

verificationIsStale#

Whether a recorded verification is old enough to be worth repeating.

ts
verificationIsStale(verifiedAt: Instant | null, now: Instant, maxAgeSeconds: number): boolean

VerificationOutcome#

Field Type Required Notes
outcome VerificationOutcomeKind required —
detail string required —

VerificationOutcomeKind#

ts
(typeof VERIFICATION_OUTCOMES)[number];

VerificationSource#

How a publish was confirmed.

ts
(typeof VERIFICATION_SOURCES)[number];

verifyDigest#

Judge one verification (S3.11.c).

ts
verifyDigest(input: VerificationInput): VerificationOutcome

VISIBILITY_FAULT_KINDS#

Values: component-not-shown, invented-a-component, blocker-shown-as-passing, waived-shown-as-passing, gap-shown-as-passing, reason-dropped, headline-understates-the-aggregate

VisibilityFault#

Field Type Required Notes
kind VisibilityFaultKind required —
subject string required —
detail string required —

VisibilityFaultKind#

ts
(typeof VISIBILITY_FAULT_KINDS)[number];

visibilityFaults#

Catch a surface that lost a component on the way to the screen (S2.10.e).

ts
visibilityFaults(aggregate: GateRunAggregate, presented: PresentedAggregate): readonly VisibilityFault[]

VOLUME_CEILINGS#

The upper bound of each class, in rows.

VOLUME_CLASSES#

How big a table gets, as four named classes rather than a number.

Values: reference, small, large, very-large

VolumeClass#

ts
(typeof VOLUME_CLASSES)[number];

VolumeProfile#

The row distribution a query will actually meet.

Field Type Required Notes
entity string required —
volumeClass VolumeClass required —
writeClass WriteClass required —
rowsAtP50Tenant number required —
rowsAtP99Tenant number required —
largestTenantShare number required The largest single tenant's share of the whole table, 0..1.
columns readonly ColumnFacts[] — ColumnFacts required —
uniqueWithinScope readonly (readonly string[])[] required Column sets that are unique within the entity's scope. This is what makes a sort total, and it is a property of the table rather than of any one query.

WAIVER_RISK_LEVELS#

How bad it is if the waived failure turns out to be real.

Values: low, moderate, high, severe

WAIVER_STATUSES#

Values: active, pending, expired, consumed, revoked, superseded, out-of-scope, unbound

WAIVER_VIOLATION_KINDS#

Values: grant-does-not-match-its-request, request-amended-after-approval, gate-is-not-waivable, approver-is-the-requester, approver-is-the-accountable-owner, approver-role-is-not-the-one-the-gate-names, approved-before-it-was-requested, starts-before-it-was-approved, window-inverted, longer-than-the-gate-permits, no-review-before-expiry, reason-is-not-a-key, no-rationale, accepted-risk-below-the-declared-risk, severe-risk-without-an-escalation-acknowledgement, escalation-acknowledged-by-the-approver, scope-with-no-audience, scope-with-no-environment, duplicate-tolerated-dimension, consumed-with-no-time, consumed-outside-the-window, revoked-before-it-started

WaiverBinding#

Field Type Required Notes
gateVersion number required —
evaluatorId string required —
evaluatorVersion number required —
policyId string required —
policyVersion number required —
inputDigest Sha256Hex required —
dependencyVersions Readonly<Record<string, number>> required —
tolerates readonly RebindableDimension[] — RebindableDimension required Changes the approver said this waiver survives. Empty is strictest.

waiverDisclosureFaults#

Check that a surface said what a person needs in order to disagree (S2.11.e).

ts
waiverDisclosureFaults(standings: readonly WaiverStanding[], presented: readonly PresentedWaiver[]): readonly DisclosureFault[]

WaiverEvidence#

Field Type Required Notes
artifactId string required —
digest Sha256Hex required —
summary string required —

WaiverGrant#

Field Type Required Notes
waiverId string required —
requestId string required —
requestDigest Sha256Hex required A digest of the request as it stood when it was approved.
gateId string required —
runId string required —
targetRevision RevisionId required —
scope WaiverScope required —
binding WaiverBinding required —
validity WaiverValidity required —
reviewBy Instant required When somebody looks at this again. Before expiry, or it is never read.
approvedBy string required —
approverRole string required —
approvedAt Instant required —
acceptedRisk WaiverRiskLevel required —
reassessedFrom WaiverRiskLevel | null — WaiverRiskLevel required Set when the approver deliberately assessed the risk differently.
residualRiskNote string required —
escalationAcknowledgedBy string | null required Required for a severe residual risk; null otherwise.
revocation WaiverRevocation | null — WaiverRevocation required —
supersedes string | null required —
supersededBy string | null required —

WaiverPolicy#

Field Type Required Notes
grantedBy string required Who may grant one. Checked against the accountable owner; see the validator.
maxDurationHours number required —
requiresReason boolean required —
scopedToRevision boolean required Whether a waiver has to name the specific revision it covers.

WaiverRecord#

A grant, as the aggregate reads it.

Field Type Required Notes
waiverId string required —
gateId string required —
targetRevision RevisionId required —
grantedBy string required —
reason string required —
startsAt Instant required —
expiresAt Instant required Exclusive. at >= expiresAt is expired.

WaiverRequest#

Field Type Required Notes
requestId string required —
gateId string required —
runId string required The exact run being waived.
targetRevision RevisionId required —
scope WaiverScope required —
reasonKey string required —
rationale string required The human argument. Not a key — this one is read by the approver, not a user.
declaredRisk WaiverRiskLevel required —
mitigations readonly string[] required —
evidence readonly WaiverEvidence[] — WaiverEvidence required —
requestedBy string required —
requestedAt Instant required —

WaiverRevocation#

Field Type Required Notes
revokedBy string required —
revokedAt Instant required —
reasonKey string required —
detail string required —

WaiverRiskLevel#

ts
(typeof WAIVER_RISK_LEVELS)[number];

WaiverScope#

Where the exception applies.

Field Type Required Notes
tenantId string required —
domain string required —
objectKind string required —
objectId string required —
audiences readonly GateAudience[] — GateAudience required —
channels readonly string[] required —
environments readonly string[] required —

WaiverSituation#

The run and the world, as they are when the waiver is being read.

Field Type Required Notes
at Instant required —
tenantId string required —
objectId string required —
audience GateAudience required —
channel string required —
environment string required —
targetRevision RevisionId required —
runId string required —
releaseId string required —
gateVersion number required —
evaluatorId string required —
evaluatorVersion number required —
policyId string required —
policyVersion number required —
inputDigest Sha256Hex required —
dependencyVersions Readonly<Record<string, number>> required —

waiverStanding#

Read a grant against the moment and the situation (S2.11.c/d/f).

ts
waiverStanding(grant: WaiverGrant, situation: WaiverSituation): WaiverStanding

WaiverStanding#

What the waiver is, right now, and everything it still carries.

Field Type Required Notes
waiverId string required —
gateId string required —
status WaiverStatus required —
authorizes boolean required True for exactly one status. Asserted over the whole vocabulary.
reasonKey string required —
detail string required —
approvedBy string required —
approvedAt Instant required —
expiresAt Instant required —
acceptedRisk WaiverRiskLevel required —
scope WaiverScope required —

WaiverStatus#

ts
(typeof WAIVER_STATUSES)[number];

WaiverValidity#

How long it lasts, and whether it lasts at all after being used.

ts
| { readonly kind: 'window'; readonly startsAt: Instant; readonly expiresAt: Instant }
| { readonly kind: 'one-use'; readonly startsAt: Instant; readonly expiresAt: Instant; readonly consumedBy: string | null; readonly consumedAt: Instant | null; }

WaiverViolation#

Field Type Required Notes
kind WaiverViolationKind required —
subject string required —
detail string required —

WaiverViolationKind#

ts
(typeof WAIVER_VIOLATION_KINDS)[number];

WEAK_STEP_UP_METHODS#

Methods that do not count as a step-up however a policy is written.

Values: password, sms

WorkbenchPlugin#

What a plugin is, from the host's side.

Field Type Required Notes
descriptor PluginDescriptor required —
contributions readonly ContributionMetadata[] — ContributionMetadata required —
activate (context: ActivationContext<TConfig>) => ActivationOutcome — ActivationContext, ActivationOutcome required Honest by return type: a plugin whose configuration is absent reports not configured rather than throwing or activating halfway.

workerHoldsLease#

Whether the WORKER may still consider itself the holder.

ts
workerHoldsLease(lease: JobLease, now: Instant, policy: HeartbeatPolicy): boolean

WorkloadQuery#

Field Type Required Notes
id string required —
entity string required —
purpose string required What a person is doing when this runs. An access path with no purpose is one nobody can retire.
predicates readonly QueryPredicate[] — QueryPredicate required —
sort readonly SortKey[] — SortKey required —
pagination PaginationMode required —
criticality Criticality required —

WRITE_BLOCKING_STATES#

States a SELECT 1 succeeds straight through.

Values: in-recovery, transaction-read-only, disk-full, connection-limit-reached

WRITE_CLASSES#

How hard the table is written, which is what an index costs.

Values: read-mostly, balanced, write-heavy, append-only-hot

WRITE_PROBE_METHODS#

How a write probe proves the database will accept a write.

Values: dedicated-probe-table, temporary-table, advisory-lock, rolled-back-write-to-a-user-table, write-to-a-user-table, read-only-statement

WriteBlockingState#

ts
(typeof WRITE_BLOCKING_STATES)[number];

WriteClass#

ts
(typeof WRITE_CLASSES)[number];

WriteProbeMethod#

ts
(typeof WRITE_PROBE_METHODS)[number];

Valid examples#

clean/one-plugin-at-every-extension-point#

a checker that rejected everything would pass every negative case above; this is the case that fails if one of the rules is too strict

json
[
  {
    "contributions": [
      {
        "contributionId": "demo.stages",
        "extensionPoint": "stage-model",
        "guardIds": ["demo-guard"],
        "model": {
          "initial": "open",
          "modelId": "demo-flow",
          "stages": [
            {
              "labelKey": "stage.demo.open",
              "reentrant": false,
              "stage": "open",
              "terminal": false
            },
            {
              "labelKey": "stage.demo.closed",
              "reentrant": false,
              "stage": "closed",
              "terminal": true
            }
          ],
          "transitions": [
            {
              "from": "open",
              "guards": ["demo-guard"],
              "requiresAuthorizationScope": null,
              "to": "closed",
              "transitionId": "close"
            }
          ]
        },
        "servesCapability": "capability:demo-workbench"
      },
      {
        "contributionId": "demo.gate",
        "deterministic": true,
        "extensionPoint": "gate",
        "gateId": "demo-gate",
        "onFailed": "needs-human",
        "onNotConfigured": "block",
        "onStale": "indeterminate",
        "servesCapability": "capability:demo-workbench"
      },
      {
        "blockType": "demo-block",
        "contributionId": "demo.block",
        "editor": {
          "commands": [
            {
              "commandId": "set-text",
              "labelKey": "editor.demo.setText",
              "requiresScope": "demo:write",
              "reversible": true
            }
          ],
          "labelKey": "editor.demo.block",
          "readOnlyFallbackKey": "editor.demo.readOnly",
          "surface": "inline"
        },
        "extensionPoint": "block",
        "hasNonTextualMeaning": false,
        "landmarkRole": null,
        "mediaTypes": ["application/vnd.demo.block+json"],
        "migrations": [
          {
            "from": 1,
            "to": 2
          }
        ],
        "schemaVersion": 2,
        "servesCapability": "capability:demo-workbench"
      },
      {
        "authorization": {
          "dataClassification": "internal",
          "requiredScopes": ["demo:read"],
          "requiresElevation": false
        },
        "contributionId": "demo.preview",
        "extensionPoint": "preview",
        "fields": [],
        "isolation": {
          "allowsNetwork": false,
          "allowsStorage": false,
          "permittedOrigins": [],
          "surface": "in-process"
        },
        "nonvisualLabelKey": "preview.demo.label",
        "selection": {
          "multiple": false,
          "selects": "entity"
        },
        "servesCapability": "capability:demo-workbench"
      },
      {
        "authorization": {
          "dataClassification": "internal",
          "requiredScopes": ["demo:read"],
          "requiresElevation": false
        },
        "contributionId": "demo.inspector",
        "extensionPoint": "inspector",
        "fields": [
          {
            "editScope": "demo:write",
            "editable": true,
            "fieldId": "title",
            "labelKey": "inspector.demo.title"
          }
        ],
        "isolation": {
          "allowsNetwork": false,
          "allowsStorage": false,
          "permittedOrigins": [],
          "surface": "in-process"
        },
        "nonvisualLabelKey": "inspector.demo.label",
        "selection": {
          "multiple": false,
          "selects": "entity"
        },
        "servesCapability": "capability:demo-workbench"
      },
      {
        "contributionId": "demo.importer",
        "extensionPoint": "importer",
        "formats": ["text/csv"],
        "servesCapability": "capability:demo-workbench"
      },
      {
        "contributionId": "demo.publisher",
        "extensionPoint": "publisher",
        "irreversibleReason": "the target has no delete API",
        "reversible": false,
        "servesCapability": "capability:demo-workbench",
        "verifiedBy": "target-readback"
      },
      {
        "authorization": {
          "dataClassification": "internal",
          "requiredScopes": ["demo:read"],
          "requiresElevation": false
        },
        "contributionId": "demo.archive-preview",
        "extensionPoint": "preview",
        "fields": [],
        "isolation": {
          "allowsNetwork": false,
          "allowsStorage": false,
          "permittedOrigins": [],
          "surface": "in-process"
        },
        "nonvisualLabelKey": "preview.demo.label",
        "selection": {
          "multiple": false,
          "selects": "entity"
        },
        "servesCapability": "capability:demo-archive"
      }
    ],
    "descriptor": {
      "configuration": [
        {
          "category": "credential",
          "required": true,
          "settingName": "demo.apiKey"
        },
        {
          "category": "quota",
          "required": false,
          "settingName": "demo.timeout"
        }
      ],
      "contractVersions": {
        "below": 2,
        "minimum": 1
      },
      "declares": [
        {
          "capability": "capability:demo-workbench",
          "support": "implemented"
        },
        {
          "capability": "capability:demo-archive",
          "reason": "the archive index rebuilds nightly",
          "retains": ["browsing by date"],
          "support": "degraded"
        }
      ],
      "description": "A minimal plugin that exercises exactly one check at a time.",
      "domain": "demo",
      "extensionPoints": [
        "block",
        "gate",
        "importer",
        "inspector",
        "preview",
        "publisher",
        "stage-model"
      ],
      "kitVersions": {
        "below": "1.0.0",
        "minimum": "0.1.0"
      },
      "lifecycle": "general-availability",
      "optionalPlugins": [],
      "owner": "demo-team",
      "pluginId": "demo.workbench",
      "requiresPlugins": [],
      "supersededBy": null,
      "version": "1.0.0"
    }
  }
]
clean/two-plugins-with-disjoint-stage-vocabularies#

the S1.9.b claim, as an executable one: the kit holds no opinion about stage NAMES, so two models sharing not one member both validate

json
[
  {
    "contributions": [
      {
        "contributionId": "demo.stages",
        "extensionPoint": "stage-model",
        "guardIds": ["demo-guard"],
        "model": {
          "initial": "open",
          "modelId": "demo-flow",
          "stages": [
            {
              "labelKey": "stage.demo.open",
              "reentrant": false,
              "stage": "open",
              "terminal": false
            },
            {
              "labelKey": "stage.demo.closed",
              "reentrant": false,
              "stage": "closed",
              "terminal": true
            }
          ],
          "transitions": [
            {
              "from": "open",
              "guards": ["demo-guard"],
              "requiresAuthorizationScope": null,
              "to": "closed",
              "transitionId": "close"
            }
          ]
        },
        "servesCapability": "capability:demo-workbench"
      }
    ],
    "descriptor": {
      "configuration": [],
      "contractVersions": {
        "below": 2,
        "minimum": 1
      },
      "declares": [
        {
          "capability": "capability:demo-workbench",
          "support": "implemented"
        }
      ],
      "description": "A minimal plugin that exercises exactly one check at a time.",
      "domain": "demo",
      "extensionPoints": ["stage-model"],
      "kitVersions": {
        "below": "1.0.0",
        "minimum": "0.1.0"
      },
      "lifecycle": "general-availability",
      "optionalPlugins": [],
      "owner": "demo-team",
      "pluginId": "demo.workbench",
      "requiresPlugins": [],
      "supersededBy": null,
      "version": "1.0.0"
    }
  },
  {
    "contributions": [
      {
        "contributionId": "other.stages",
        "extensionPoint": "stage-model",
        "guardIds": [],
        "model": {
          "initial": "intake",
          "modelId": "other-flow",
          "stages": [
            {
              "labelKey": "stage.other.intake",
              "reentrant": false,
              "stage": "intake",
              "terminal": false
            },
            {
              "labelKey": "stage.other.dispatched",
              "reentrant": false,
              "stage": "dispatched",
              "terminal": true
            }
          ],
          "transitions": [
            {
              "from": "intake",
              "guards": [],
              "requiresAuthorizationScope": null,
              "to": "dispatched",
              "transitionId": "dispatch"
            }
          ]
        },
        "servesCapability": "capability:demo-workbench"
      }
    ],
    "descriptor": {
      "configuration": [],
      "contractVersions": {
        "below": 2,
        "minimum": 1
      },
      "declares": [
        {
          "capability": "capability:demo-workbench",
          "support": "implemented"
        }
      ],
      "description": "A minimal plugin that exercises exactly one check at a time.",
      "domain": "other",
      "extensionPoints": ["stage-model"],
      "kitVersions": {
        "below": "1.0.0",
        "minimum": "0.1.0"
      },
      "lifecycle": "general-availability",
      "optionalPlugins": [],
      "owner": "demo-team",
      "pluginId": "other.workbench",
      "requiresPlugins": [],
      "supersededBy": null,
      "version": "1.0.0"
    }
  }
]

Invalid examples#

block/a-migration-targeting-a-version-that-does-not-exist-yet#

it would write documents the validator refuses

Must produce: migration-above-current-schema

json
[
  {
    "contributions": [
      {
        "blockType": "demo-block",
        "contributionId": "demo.block",
        "editor": null,
        "extensionPoint": "block",
        "hasNonTextualMeaning": false,
        "landmarkRole": null,
        "mediaTypes": ["application/vnd.demo.block+json"],
        "migrations": [
          {
            "from": 1,
            "to": 2
          },
          {
            "from": 2,
            "to": 5
          }
        ],
        "schemaVersion": 2,
        "servesCapability": "capability:demo-workbench"
      }
    ],
    "descriptor": {
      "configuration": [],
      "contractVersions": {
        "below": 2,
        "minimum": 1
      },
      "declares": [
        {
          "capability": "capability:demo-workbench",
          "support": "implemented"
        }
      ],
      "description": "A minimal plugin that exercises exactly one check at a time.",
      "domain": "demo",
      "extensionPoints": ["block"],
      "kitVersions": {
        "below": "1.0.0",
        "minimum": "0.1.0"
      },
      "lifecycle": "general-availability",
      "optionalPlugins": [],
      "owner": "demo-team",
      "pluginId": "demo.workbench",
      "requiresPlugins": [],
      "supersededBy": null,
      "version": "1.0.0"
    }
  }
]
block/a-migration-that-goes-backwards#

a downgrade inside a forward chain loops, and the loop runs once per document read

Must produce: migration-not-forward

json
[
  {
    "contributions": [
      {
        "blockType": "demo-block",
        "contributionId": "demo.block",
        "editor": null,
        "extensionPoint": "block",
        "hasNonTextualMeaning": false,
        "landmarkRole": null,
        "mediaTypes": ["application/vnd.demo.block+json"],
        "migrations": [
          {
            "from": 2,
            "to": 1
          }
        ],
        "schemaVersion": 2,
        "servesCapability": "capability:demo-workbench"
      }
    ],
    "descriptor": {
      "configuration": [],
      "contractVersions": {
        "below": 2,
        "minimum": 1
      },
      "declares": [
        {
          "capability": "capability:demo-workbench",
          "support": "implemented"
        }
      ],
      "description": "A minimal plugin that exercises exactly one check at a time.",
      "domain": "demo",
      "extensionPoints": ["block"],
      "kitVersions": {
        "below": "1.0.0",
        "minimum": "0.1.0"
      },
      "lifecycle": "general-availability",
      "optionalPlugins": [],
      "owner": "demo-team",
      "pluginId": "demo.workbench",
      "requiresPlugins": [],
      "supersededBy": null,
      "version": "1.0.0"
    }
  }
]
block/a-third-schema-version-with-no-history#

every document written before this version is unreadable and nothing says so

Must produce: missing-migration-chain

json
[
  {
    "contributions": [
      {
        "blockType": "demo-block",
        "contributionId": "demo.block",
        "editor": null,
        "extensionPoint": "block",
        "hasNonTextualMeaning": false,
        "landmarkRole": null,
        "mediaTypes": ["application/vnd.demo.block+json"],
        "migrations": [],
        "schemaVersion": 3,
        "servesCapability": "capability:demo-workbench"
      }
    ],
    "descriptor": {
      "configuration": [],
      "contractVersions": {
        "below": 2,
        "minimum": 1
      },
      "declares": [
        {
          "capability": "capability:demo-workbench",
          "support": "implemented"
        }
      ],
      "description": "A minimal plugin that exercises exactly one check at a time.",
      "domain": "demo",
      "extensionPoints": ["block"],
      "kitVersions": {
        "below": "1.0.0",
        "minimum": "0.1.0"
      },
      "lifecycle": "general-availability",
      "optionalPlugins": [],
      "owner": "demo-team",
      "pluginId": "demo.workbench",
      "requiresPlugins": [],
      "supersededBy": null,
      "version": "1.0.0"
    }
  }
]

3 of 46 refused case(s) shown. The full corpus is committed at evidence/v1-workbenches/workbench-kit-plugin-fixtures.json and is what the gate runs.

Authorization and scope#

| Symbol | Type | Notes | | ----------------------------------------------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- | ----- | ------------------------------------------------------------------------------ | | AccessRequest.sameTenant | boolean | — | | AccessRequest.supportGrantLive | boolean | Only meaningful for support: whether a time-boxed grant is live. | | ActionRequest.suppressionScope | 'event' | 'kind' | 'producer' | null | For suppress: the class it applies to. A suppression of one event is a skip. | | ActivationContext.tenant | TenantId | null | — | | AllowedTransition.requiresScope | string | null | — | | AppliedWaiver.grantedBy | string | — | | AuditActor.actorId | string | — | | AuditEvent.actor | AuditActor | — | | AuditEvent.tenantId | string | — | | AuditProjection.tenantId | string | null | — | | AuditViewer.tenantId | string | — | | authorizeAction | function | Authorize one operator action (S3.8.d). | | authorizeBreakGlass | function | Decide a break-glass key access (S3.13.b). | | authorizeDeadLetterAction | function | Authorize one action on a dead letter (S3.9.h). | | authorizeDecrypt | function | Authorize a decrypt (S3.11.d). | | authorizeResolution | function | Authorize a vault resolution (S3.13.d). | | authorizeShred | function | Decide whether a key may be destroyed (S3.13.b). | | BlobReference.scope | string | The workbench or entity this blob belongs to. Scope is not the same as tenant. | | BlobReference.tenantId | string | — | | BreakGlassRequest.actorId | string | The identity performing the emergency access. | | BreakGlassRequest.grantedAt | Instant | — | | BreakGlassRequest.routineActorId | string | The identity the normal application path runs as. | | ClaimPolicy.perTenantCap | number | Rows one tenant may hold in a single batch. Without a cap, one tenant's backlog is every dispatcher's whole batch and the others wait behind it. | | ContributionAuthorization.requiredScopes | readonly string[] | — | | DeadLetter.tenantId | string | — | | DeadLetterReplay.authorizedBy | string | — | | DECISION_SCOPES | enumeration | — | | DecisionCommand.actor | ActorDecision | — | | DecisionCommand.actorRef | ActorRef | — | | DecisionRecord.scope | DecisionScope | — | | DecisionScope | type | — | | DecisionTarget.scope | DecisionScope | — | | DECLARED_SCOPE_WIDENINGS | constant | — | | EditorCommand.requiresScope | string | null | Null when any actor who may edit the block may run it. | | EntityRegistration.unscopedBecause | string | null | Required when the class carries no scope column: why it may not. | | ExecutionContext.actor | ActorRef | — | | ExecutionContext.tenant | TenantId | null | — | | FailureSignals.authorized | boolean | — | | GateInput.actor | ActorRef | — | | GateInput.tenant | TenantId | null | — | | GuardInput.actor | ActorRef | — | | GuardInput.scopes | readonly string[] | — | | HumanGateRequirement.scope | SignoffScope | — | | HumanPresence.actorId | string | — | | HumanPresence.tenantId | string | — | | IdempotencyRecord.scope | IdempotencyScope | — | | IdempotencyScope.tenantId | string | — | | IdentifierLookup.scopedBy | readonly string[] | The columns the uniqueness must additionally be over. | | InboxKey.tenantId | string | — | | InspectorField.editScope | string | null | Required when editable; a field editable by everyone is not a field. | | IntakeRequest.consumerTenantId | string | The tenant the consumer is running for. | | ISOLATION_SCOPES | enumeration | — | | IsolationDecision.scope | IsolationScope | — | | IsolationScope | type | — | | JobClaimRequest.permittedTenants | readonly string[] | — | | JobGraph.tenantId | string | — | | JobGraphNode.tenantId | string | — | | JobLease.grantedAt | Instant | — | | JobRecord.tenantId | string | — | | KeyDescriptor.tenantId | string | null | The tenant this key may be used for. Null only for a root. | | LegalHoldRecord.scope | 'tenant' | 'workspace' | 'entity' | — | | LegalHoldRecord.scopeId | string | — | | OutboxRow.tenantId | string | — | | PresenceClaim.actor | ActorRef | — | | PresentedWaiver.scope | string | null | — | | PrivilegedBypass.scope | string | What it is limited to: one object, one tenant, one window. | | ProjectionMetadata.authorization | ContributionAuthorization | — | | ProtectionContext.tenantId | string | — | | PurgeTombstone.tenantId | string | — | | QuarantineRecord.tenantId | string | — | | RenewalChain.grants | number | — | | ReplayGuardInput.stillAuthorized | boolean | — | | ReplayPlan.authorizedBy | string | — | | ReplayRequestInput.authorizedBy | string | — | | ResolutionRequest.actorId | string | — | | ResolutionRequest.actorIsSharedServiceAccount | boolean | True when actorId is an identity many callers share. | | RestorePlan.backupTenantId | string | — | | RestorePlan.targetTenantId | string | — | | SCOPE_FAULT_KINDS | enumeration | — | | SCOPE_VIOLATION_KINDS | enumeration | — | | ScopedRow.tenantId | string | null | — | | ScopeFaultKind | type | — | | scopeFaults | function | Check that a query carries the predicates its entity requires (S3.2.f). | | scopeKey | function | The value a unique index is built over. Stable, ordered, total, and injective. | | ScopeViolationKind | type | — | | scopeWidening | function | What the proposal now covers that the reviewer was not shown. | | ScopeWidening.authorizedBy | string | What stands in for the missing predicate. Never "nothing". | | SignoffScope | type | Who may sign: a named person, or anyone from a declared pool. | | StageTransition.requiresAuthorizationScope | string | null | Null when any actor who can see the entity may perform it. | | TimelineEntry.actorId | string | null | — | | Transition.requiresScope | string | null | Null when any actor who can see the object may take it. | | TransitionCommand.actor | ActorDecision | The authorization VERDICT, not a claim — see ./invariants.ts. | | TransitionCommand.actorRef | ActorRef | — | | TransitionInput.actor | ActorRef | — | | TransitionRequest.actorId | string | — | | TransitionRequest.fromTenant | string | — | | TransitionRequest.rescoped | boolean | True when the copy is re-scoped to the destination rather than preserved. | | TransitionRequest.toTenant | string | — | | UNAUTHORIZED_READER_SURFACES | enumeration | The surfaces a reader outside the row's own authorization can see. | | validateScope | function | Check the scope a record is keyed by (S3.4.c). | | validateWaiverGrant | function | Check a grant against the request it answers and the gate it waives (S2.11.a–c). | | VolumeProfile.largestTenantShare | number | The largest single tenant's share of the whole table, 0..1. | | VolumeProfile.rowsAtP50Tenant | number | — | | VolumeProfile.rowsAtP99Tenant | number | — | | VolumeProfile.uniqueWithinScope | readonly (readonly string[])[] | Column sets that are unique within the entity's scope. This is what makes a sort total, and it is a property of the table rather than of any one query. | | WaiverGrant.scope | WaiverScope | — | | WaiverPolicy.grantedBy | string | Who may grant one. Checked against the accountable owner; see the validator. | | WaiverPolicy.scopedToRevision | boolean | Whether a waiver has to name the specific revision it covers. | | WaiverRecord.grantedBy | string | — | | WaiverRequest.scope | WaiverScope | — | | WaiverScope.tenantId | string | — | | WaiverSituation.tenantId | string | — | | WaiverStanding.authorizes | boolean | True for exactly one status. Asserted over the whole vocabulary. | | WaiverStanding.scope | WaiverScope | — |

Idempotency and concurrency#

| Symbol | Type | Notes | | ------------------------------------------ | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------- | | AggregateContext.subjectRevision | RevisionId | — | | AuditEvent.sequence | number | — | | AuditEvent.targetRevision | string | — | | AuditProjection.throughSequence | number | Sequence of the last event folded. Zero for an empty projection. | | BatchReport.attempted | number | — | | BatchReport.notAttempted | readonly string[] | Left for the next batch. Decision 5: not implied, stated. | | DeadLetter.finalAttempt | number | — | | DeadLetterReplay.attempt | number | UNCHANGED: the next claim increments it, so the history stays one sequence. | | DeadLetterReplay.idempotencyKey | string | UNCHANGED, for the same reason. | | DeadLetterReplay.maxAttempts | number | — | | DecisionCommand.expectedRevision | string | — | | DecisionCommand.idempotencyKey | string | — | | DecisionRecord.consequences | readonly string[] | What follows from it, including the parts nobody likes. | | Delivery.sequence | number | — | | DeliveryOutcome.nextAttemptAt | Instant | null | — | | EventContext.causationId | string | null | — | | ExecutionContext.idempotencyKey | string | — | | FailureSignals.attempts | number | — | | FailureSignals.transientAttemptCeiling | number | Attempts past which "transient" stops being a description. | | GateRunAggregate.subjectRevision | RevisionId | — | | GateRunProvenance.targetRevision | RevisionId | — | | GateStatusRow.lastRunSequence | number | — | | GuardInput.revision | string | The revision the decision is about. A decision without one is unpinnable. | | IDEMPOTENCY_STATES | enumeration | — | | IdempotencyState | type | — | | ImportExecution.attempted | number | — | | ImportExecution.idempotencyKey | string | — | | InboxReceipt.attempt | number | — | | InboxReceipt.sequence | number | The producer's position for this subject. | | JobLease.attempt | number | — | | JobRecord.attempt | number | Attempts STARTED — 0 until something claims it. The wire envelope (S1.5) is 1-based for the mirror-image reason: attempt 0 would describe a job that never ran, which is not an update. | | JobRecord.estimatedAttemptCost | number | What one attempt is expected to cost, in the budget's unit. Charged before it runs. | | JobRecord.expectedAttemptSeconds | number | — | | JobRecord.idempotencyKey | string | — | | JobRecord.maxAttempts | number | — | | JobRetryContext.queueConcurrency | number | — | | JobRetryPolicy.unknownOutcomeMaxAttempts | number | A lower ceiling for unknown outcomes: each attempt may be a second effect. | | OrderingRequest.sequence | number | — | | OutboxRow.attempt | number | — | | OutboxRow.sequence | number | Position within the subject. Gapless per subject; the only ordering that exists. | | PlannedTransition.expectedRevision | string | — | | PlannedTransition.idempotencyKey | string | — | | ProvenanceManifest.sourceRevisionId | string | null | The entity revision this was derived from, pinned. | | PublishReceipt.idempotencyKey | string | — | | PurgeRun.notAttempted | readonly PurgeStep[] | Steps not attempted because an earlier one failed. | | QuarantineRecord.attempts | number | — | | QuarantineRecord.sequence | number | — | | QueueHealth.attemptsAboveOne | number | — | | Reconciliation.attempted | number | — | | ReplayPlan.attemptId | string | NEW. The audit has to tell the two runs apart. | | ReplayRequestInput.attemptId | string | Minted by the caller; it must not equal the event id. | | ResumeInput.stageIsIdempotent | boolean | — | | RetryPolicy.maxAttempts | number | — | | RetryPolicy.maxUnknownAttempts | number | Attempts allowed for an UNKNOWN failure before it is quarantined. | | ReviewedState.targetRevision | RevisionId | — | | REVISION_CONSTRAINTS | enumeration | The constraints a revision table must carry, as a declared list. | | RevisionConstraint | type | — | | revisionHoldMarker | function | The marker S2.4 puts on a revision, derived from the record here. | | SchedulingRequest.concurrency | number | — | | StageEffect.idempotent | boolean | Whether applying it twice is the same as applying it once. | | TimelineEntry.sequence | number | — | | TransitionCommand.expectedRevision | string | — | | TransitionCommand.idempotencyKey | string | — | | WaiverGrant.targetRevision | RevisionId | — | | WaiverPolicy.scopedToRevision | boolean | Whether a waiver has to name the specific revision it covers. | | WaiverRecord.targetRevision | RevisionId | — | | WaiverRequest.targetRevision | RevisionId | — | | WaiverSituation.targetRevision | RevisionId | — |

Pagination#

| Symbol | Type | Notes | | -------------------------------------------- | ----------------- | ---------------------------------------------------------------------------- | --- | | BackfillCheckpoint.cursorColumn | string | The column the batch cursor walks. Must not change under the backfill. | | BackfillCheckpoint.cursorColumnIsImmutable | boolean | — | | BackfillCheckpoint.lastCursor | string | null | — | | BrokerAck.brokerOffset | string | — | | DeliveryReceipt.brokerOffset | string | — | | EMPTY_PROJECTION | function | — | | JobCheckpoint.cursor | string | Opaque to the kit. Where the stage got to, in whatever terms the stage uses. | | PAGINATION_MODES | enumeration | How the query walks a result set. | | PaginationMode | type | — | | ProjectionSnapshot.projection | string | — | | ProjectionState | type | The state a projection is in. | | ReplayOutcome.projection | AuditProjection | — | | validateProjectionContribution | function | S1.9.e — isolation, authorization and the required non-visual path. | | WorkloadQuery.pagination | PaginationMode | — |

State and failure#

| Symbol | Type | Notes | | ------------------------------------------ | ---------------------------------------------------------------- | ---------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- | ------------------------------------------------- | | ACTION_REFUSALS | enumeration | — | | ActionRefusal | type | — | | ActivationOutcome | type | — | | AdmissionDecision.state | BlobState | — | | AGGREGATE_POLICY_VIOLATION_KINDS | enumeration | — | | AggregatePolicyViolationKind | type | — | | ALERT_VERDICTS | enumeration | — | | AlertDecision.verdict | AlertVerdict | — | | AlertVerdict | type | — | | AuditEvent.errorRef | string | null | A support reference, never a message or a stack. | | AuditEvent.newState | string | null | — | | AuditEvent.priorState | string | null | Null for an event that does not move a stage. | | AuditProjection.refusedTransitions | readonly { readonly to: string; readonly reasonKey: string }[] | Transitions the trail shows as attempted and refused. | | BatchDeletionOutcome | type | — | | BatchItemResult.outcome | BatchDeletionOutcome | — | | BatchReport.refused | readonly string[] | — | | BLOB_STATES | enumeration | Where a blob is in its own admission lifecycle. | | BlobReference.state | BlobState | — | | BlobState | type | — | | BREAK_GLASS_REFUSALS | enumeration | — | | BreakGlassRefusal | type | — | | CANCEL_OUTCOMES | enumeration | — | | CancelOutcome | type | — | | ChildOutcomeRecord.failureCode | string | null | A stable code, or null. Never a free-text message. | | ChildState.onFailure | FailurePolicy | — | | ChildState.state | JobState | — | | CIPHER_FAILURES | enumeration | What the key service and the AEAD can say when a value will not open. | | CipherFailure | type | — | | CircuitPolicy.failureThreshold | number | — | | CircuitState | type | — | | CLAIM_OUTCOMES | enumeration | — | | CLAIMABLE_STATES | enumeration | States from which a dispatcher may claim. | | ClaimOutcome | type | — | | classifyJobFailure | function | Classify a failed attempt (S3.9.g). | | Component.state | ComponentState | — | | ComponentState | type | What one gate came out as, in the three vocabularies the kit already has. | | ConsideredOption.status | OptionStatus | — | | COVERAGE_OUTCOMES | enumeration | How well an index serves a query, worst outcome last. | | Coverage.outcome | CoverageOutcome | — | | CoverageOutcome | type | — | | CRASH_WINDOW_OUTCOMES | constant | What a crash between publish and mark leaves behind, per order. | | DEAD_LETTER_REFUSALS | enumeration | — | | DeadLetter.failureKind | JobFailureKind | — | | DeadLetterRefusal | type | — | | DeadLetterReplay.state | 'queued' | — | | DECISION_VIOLATION_KINDS | enumeration | — | | DecisionCommand.verdicts | readonly GuardVerdict[] | — | | DecisionViolationKind | type | — | | DECRYPT_REFUSALS | enumeration | — | | DecryptRefusal | type | — | | DELETION_OUTCOMES | enumeration | — | | DELETION_REFUSALS | enumeration | — | | DELETION_STATES | enumeration | — | | DeletionRefusal | type | — | | DeletionState | type | — | | deletionStateFor | function | Where a blob sits in the S3.3 deletion lifecycle (S3.11.e). | | DELIVERY_FAILURE_CLASSES | enumeration | What a delivery failure means for the next attempt. | | DeliveryContext.failure | DeliveryFailure | — | | DeliveryFailureClass | type | — | | EffectInput.state | ComponentState | — | | EffectInput.whenUnavailable | 'block' | 'warn' | 'skip-with-record' | The definition's behaviour when it cannot answer. | | EligibilityInput.deletionState | DeletionState | — | | EVENT_VIOLATION_KINDS | enumeration | — | | EventViolationKind | type | — | | EXTERNAL_OUTCOMES | enumeration | — | | ExternalOutcome | type | — | | FAILURE_EXPECTATIONS | constant | What each mode must do, and the axis that matters. | | FAILURE_MODES | enumeration | — | | FAILURE_POLICIES | enumeration | What a child's failure does to its parent. | | FailureClassification.unknownOutcome | boolean | True when nobody knows whether the effect happened. Carries its own lower ceiling. | | FailureMode | type | — | | failureModeFor | function | The failure mode an open-failure is an instance of. | | FailurePolicy | type | — | | FENCE_REFUSALS | enumeration | — | | FenceOutcome | type | — | | FenceRefusal | type | — | | FINDING_STATES | enumeration | — | | FindingState | type | — | | GATE_DEFINITION_VIOLATION_KINDS | enumeration | — | | GATE_REGISTRY_VIOLATION_KINDS | enumeration | — | | GATE_RUN_VIOLATION_KINDS | enumeration | — | | GATE_VERDICTS | constant | The verdict vocabulary, re-exported so a caller need not reach into S1.9. | | GateDefinition.whenEvidenceUnavailable | UnavailableBehaviour | — | | GateDefinitionViolationKind | type | — | | GateFailure.failureClass | FailureClass | — | | GateOutcome | type | — | | GateRegistryViolationKind | type | — | | GateRunResult.verdict | VerdictName | The evaluator's conclusion, in S1.9's vocabulary. | | GateRunViolationKind | type | — | | gateVerdict | function | Turn an evaluator outcome into a verdict, applying the kit's own rules first. | | GateVerdict.verdict | VerdictName | — | | GraphView.outcome | ParentOutcome | — | | GraphViewNode.failureCode | string | null | A stable code, never a message. A message is where a payload rides in (S3.9.h). | | GraphViewNode.state | JobState | — | | GUARD_STATUSES | enumeration | The seven answers, and why there are seven rather than two. | | GuardAnswer.status | GuardStatus | — | | GuardOutcome | type | A guard's answer. | | GuardPurityError | class | — | | GuardResult.status | GuardStatus | — | | GuardStatus | type | — | | GuardVerdict | type | A guard's answer about one attempted transition. | | HOLD_VIOLATION_KINDS | enumeration | — | | HoldViolationKind | type | — | | IDEMPOTENCY_STATES | enumeration | — | | IdempotencyRecord.state | IdempotencyState | — | | IdempotencyState | type | — | | ImportValidation.verdict | 'approved' | 'rejected' | — | | InboxReceipt.lastError | string | null | — | | InboxReceipt.outcome | ProcessingOutcome | null | What the processing produced, for a duplicate to be answered with. | | InboxReceipt.state | ReceiptState | — | | INTAKE_REFUSALS | enumeration | — | | IntakeRefusal | type | — | | isTerminalJobState | function | — | | JOB_CLAIM_REFUSALS | enumeration | — | | JOB_FAILURE_KINDS | enumeration | Why an attempt ended. | | JOB_STATES | enumeration | The states a job row may be in. | | JobClaimRefusal | type | — | | JobEdge.onChildFailure | FailurePolicy | — | | JobFailureKind | type | — | | JobGraphNode.state | JobState | — | | JobRecord.state | JobState | — | | JobRetryContext.failure | JobFailure | — | | JobRetryPolicy.unknownOutcomeMaxAttempts | number | A lower ceiling for unknown outcomes: each attempt may be a second effect. | | JobState | type | — | | LEDGER_OUTCOME_TO_VERDICT | constant | The cell's wording, mapped onto the verdicts the kit already has. | | MARK_REFUSALS | enumeration | — | | MarkOutcome | type | — | | MarkRefusal | type | — | | MIGRATION_REFUSALS | enumeration | — | | MigrationRefusal | type | — | | NON_PASSING_VERDICTS | enumeration | The verdicts a MISSING or STALE measurement may become. | | NON_VERDICT_STATUSES | enumeration | The statuses that are NOT a decision about the subject. | | NonPassingVerdict | type | — | | OPEN_FAILURES | enumeration | — | | OpenFailure | type | — | | OPTION_STATUSES | enumeration | — | | OptionStatus | type | — | | OUTBOX_STATES | enumeration | Where an outbox row is in its life. | | OutboxRow.lastFailure | DeliveryFailure | null | — | | OutboxRow.state | OutboxState | — | | OutboxState | type | — | | PARENT_OUTCOMES | enumeration | What a parent may be. | | parentOutcome | function | Fold the children into the parent (S3.10.e). | | ParentOutcome | type | — | | ParentVerdict.outcome | ParentOutcome | — | | PlanFault.verdict | VerdictName | — | | PlanJudgement.verdict | VerdictName | — | | PLUGIN_VIOLATION_KINDS | enumeration | — | | PluginViolationKind | type | — | | ProcessingOutcome.status | 'applied' | 'ignored' | — | | ProjectionState | type | The state a projection is in. | | PublicProbeView.status | 'ok' | 'degraded' | 'not-ready' | — | | PURGE_REFUSAL_KINDS | enumeration | — | | PurgeRefusalKind | type | — | | purgeRefusals | function | Blob-specific reasons a purge is refused (S3.11.e). | | PurgeRun.outcomes | readonly StepOutcome[] | — | | PurgeRun.state | DeletionState | — | | REACHABLE_DELETION_STATES | enumeration | Every deletion state this module can produce, for the S3.3 machine to accept. | | readinessState | function | The readiness answer as a S1.6 capability state (S3.14.f). | | RECEIPT_STATES | enumeration | — | | ReceiptState | type | — | | ReclamationFinding.state | FindingState | — | | ReconciliationReport.state | FindingState | — | | RECORD_VIOLATION_KINDS | enumeration | — | | RecordViolationKind | type | — | | REFUSAL_REASONS | enumeration | — | | RefusalReason | type | — | | REGISTER_VIOLATION_KINDS | enumeration | — | | RegisterViolationKind | type | — | | RENEWAL_REFUSALS | enumeration | — | | RenewalOutcome | type | — | | RenewalRefusal | type | — | | REPLAY_REFUSALS | enumeration | — | | ReplayRefusal | type | — | | REQUIREMENT_VIOLATION_KINDS | enumeration | — | | RequirementViolationKind | type | — | | RESOLUTION_REFUSALS | enumeration | — | | ResolutionRefusal | type | — | | SCHEMA_STATE_POLICY | constant | What each schema state means for each capability. | | SCHEMA_STATES | enumeration | — | | SchemaState | type | — | | SchemaVerdict.state | SchemaState | — | | SCOPE_VIOLATION_KINDS | enumeration | — | | ScopeViolationKind | type | — | | SEAL_REFUSALS | enumeration | — | | SealRefusal | type | — | | SHRED_REFUSALS | enumeration | — | | ShredRefusal | type | — | | signoffStatus | function | Whether a signature still covers what is in front of you (S2.13.e). | | STAGE_VIOLATION_KINDS | enumeration | — | | StageViolationKind | type | — | | StepOutcome.outcome | 'done' | 'failed' | 'skipped' | — | | SupersessionOutcome | type | — | | SWEEPABLE_BLOB_STATES | enumeration | Blob states a sweep may act on at all. Anything else needs a person. | | TERMINAL_JOB_STATES | enumeration | — | | TERMINAL_OUTBOX_STATES | enumeration | States a row never leaves. | | TERMINAL_STATES | enumeration | Once here, there is nothing to transition to. | | TRANSITION_REFUSALS | enumeration | — | | TRANSITION_REFUSALS | enumeration | — | | TransitionCommand.verdicts | readonly GuardVerdict[] | One verdict per guard the transition requires. Missing ones are refused. | | TransitionOutcome | type | — | | TransitionOutcome | type | — | | TransitionRefusal | type | — | | TransitionRefusal | type | — | | UNAVAILABLE_BEHAVIOURS | enumeration | What happens when the evidence is not there. | | UnavailableBehaviour | type | — | | UNREADABLE_BLOB_STATES | enumeration | A blob nothing may read yet. | | VerdictName | type | — | | VERDICTS | enumeration | — | | VERIFICATION_OUTCOMES | enumeration | — | | VerificationOutcome.outcome | VerificationOutcomeKind | — | | VerificationOutcomeKind | type | — | | WAIVER_STATUSES | enumeration | — | | WAIVER_VIOLATION_KINDS | enumeration | — | | WaiverStanding.status | WaiverStatus | — | | WaiverStatus | type | — | | WaiverViolationKind | type | — | | WRITE_BLOCKING_STATES | enumeration | States a SELECT 1 succeeds straight through. | | WriteBlockingState | type | — |

Compatibility#

| Symbol | Type | Notes | | ----------------------------------------------- | --------------------------------------------- | -------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- | | ActivationContext.kitVersion | SemanticVersion | — | | ActivationContext.schemaVersion | number | — | | AggregateContext.dependencyVersions | Readonly<Record<string, number>> | Current versions of everything a gate's evidence may be invalidated by. | | AggregatePolicy.policyVersion | number | Integer >= 1. Bumped when the fold's MEANING changes. | | AuditEvent.evidenceVersions | Readonly<Record<string, number>> | — | | AuditEvent.policyVersion | number | — | | AuditEvent.schemaVersion | number | The schema this event was written under. | | BlockMetadata.schemaVersion | number | — | | ClaimRequest.processingVersion | number | — | | COMPATIBILITY_FINDING_KINDS | enumeration | — | | CompatibilityFindingKind | type | — | | compatibilityFindings | function | Compare what has to be there with what was found (S3.14.d). | | CompatibilityReading.compatible | boolean | — | | Component.gateVersion | number | — | | DeadLetter.typeVersion | number | — | | DeadLetterActionRequest.currentTypeVersion | number | The handler version deployed now. | | DecisionEvidence.version | number | — | | DecisionRecord.effectiveVersion | number | The version of the thing it takes effect for. Integer, >= 1. | | EncryptionMetadata.keyVersion | string | — | | EvidenceRecord.dependencyVersions | Readonly<Record<string, number>> | The versions of the things this evidence was derived from. | | EvidenceRecord.version | number | — | | EvidenceRef.version | number | Monotonic per evidenceId. A guard may not compare versions across ids. | | EvidenceVersionConstraint | type | An exact version, or a half-open range, for a piece of required evidence. | | FailureSignals.versionSupported | boolean | — | | GateDefinition.version | number | Integer, >= 1. Bumped when the gate's MEANING changes, not its code. | | GatePolicy.version | SemanticVersion | — | | GatePolicyReference.policyVersion | number | — | | GateProvenance.evaluatorVersion | SemanticVersion | — | | GateRunAggregate.policyVersion | number | — | | GateRunProvenance.evaluatorVersion | number | — | | GateRunProvenance.gateVersion | number | The gate version this answers. A result for v1 does not answer v2. | | GateRunProvenance.policyVersion | number | — | | GuardInput.policyVersion | number | — | | GuardResult.policyVersion | number | — | | IdempotencyScope.operationVersion | number | — | | InboxKey.eventVersion | number | — | | InboxReceipt.processingVersion | number | The version of the projection logic that wrote this receipt (decision 5). | | IntakeRequest.supported | Readonly<Record<string, readonly number[]>> | Event kinds and the versions of each this consumer understands. | | JobCheckpoint.checkpointVersion | number | The SHAPE version of the cursor. A v2 worker reading a v1 cursor is not resuming. | | JobCheckpoint.producedByTypeVersion | number | — | | JobGraphNode.typeVersion | number | — | | JobRecord.typeVersion | number | The handler contract version this job was ENQUEUED against; S3.9.e reads it on resume. | | KeyDescriptor.version | string | Never blank. An unversioned key reference resolves to whatever is current. | | KIT_VERSION | constant | The kit version this module belongs to. | | ObservedSchema.version | number | null | The applied version, or null when there is no migration table at all. | | OpenRequest.keyVersion | string | — | | OutboxIntent.eventVersion | number | — | | OutboxRow.eventVersion | number | — | | parseSchemaRange | function | — | | parseSemanticRange | function | — | | PluginDescriptor.contractVersions | SchemaRange | Which envelope schema versions it can read and emit. | | PluginDescriptor.kitVersions | SemanticRange | Which kit versions this plugin was written against. | | PluginDescriptor.version | SemanticVersion | — | | PluginValidationOptions.kitVersion | SemanticVersion | The kit the host is running. Defaults to . | | PluginValidationOptions.schemaVersion | number | The envelope schema version the host speaks. | | PolicyChangeReport.changedWithoutAVersionBump | boolean | The fold changed and the version did not. | | PolicyChangeReport.fromVersion | number | — | | PolicyChangeReport.toVersion | number | — | | ProtectionContext.schemaVersion | string | Bumped when the meaning of the field changes, so old rows are diagnosable. | | QuarantineRecord.handlerVersion | number | — | | ReclamationCandidate.registerVersion | number | — | | ReclamationToken.registerVersion | number | — | | ReferenceRegister.version | number | Bumped whenever a source is added or removed. Recorded on every candidate. | | ReplayGuardInput.currentHandlerVersion | number | — | | RestorePlan.keyVersionsAvailable | readonly string[] | — | | RestorePlan.keyVersionsInBackup | readonly string[] | — | | ResumeInput.compatibleTypeVersions | readonly number[] | Handler versions whose checkpoints this worker declares itself able to continue. | | ResumeInput.readableCheckpointVersions | readonly number[] | Cursor shape versions this worker can read. | | ResumeInput.workerTypeVersion | number | — | | RetryTarget.typeVersion | number | — | | ReviewedState.evidenceVersions | Readonly<Record<string, number>> | — | | ReviewedState.policyVersion | number | — | | schemaRangeAdmits | function | — | | SEALED_FIELD_SCHEMA_VERSION | constant | — | | SealedField.keyVersion | string | — | | SealRequest.keyVersion | string | — | | semanticRangeAdmits | function | — | | StorageLocator.version | string | null | The store's own version handle, or null on a store with no versioning. | | Transformation.toolVersion | string | — | | VaultReference.version | string | null | Pinned. An unversioned reference resolves to whatever is current. | | WaiverBinding.dependencyVersions | Readonly<Record<string, number>> | — | | WaiverBinding.evaluatorVersion | number | — | | WaiverBinding.gateVersion | number | — | | WaiverBinding.policyVersion | number | — | | WaiverSituation.dependencyVersions | Readonly<Record<string, number>> | — | | WaiverSituation.evaluatorVersion | number | — | | WaiverSituation.gateVersion | number | — | | WaiverSituation.policyVersion | number | — |

Deprecation#

| Symbol | Type | Notes | | ----------------------------------- | ------------------- | ---------------------------------------------------- | --- | | AggregateContext.lifecycleStage | string | — | | GateApplicability.lifecycleStages | readonly string[] | The lifecycle stages this gate runs at. Never empty. | | GateDefinition.lifecycle | GateLifecycle | — | | GateLifecycle | type | Whether the gate is on, watching, or gone. | | GateRunAggregate.lifecycleStage | string | — | | KeyDescriptor.retiredAt | Instant | null | — | | LIFECYCLE_INDEXES | constant | S3.5.b — the stage and status access paths. | | MigrationState.removal | RemovalEvidence | — | | PluginDescriptor.lifecycle | Lifecycle | — | | StageSeverity.lifecycleStage | string | — |

Evidence#

  • evidence/v1-workbenches/workbench-kit-export-map.json
  • evidence/v1-workbenches/workbench-kit-plugin-fixtures.json
  • libs/oshun/workbench-kit/src/audit.ts
  • libs/oshun/workbench-kit/src/blobs.ts
  • libs/oshun/workbench-kit/src/decisions.ts
  • libs/oshun/workbench-kit/src/deletion.ts
  • libs/oshun/workbench-kit/src/gate-definitions.ts
  • libs/oshun/workbench-kit/src/gate-runs.ts
  • libs/oshun/workbench-kit/src/gate-waivers.ts
  • libs/oshun/workbench-kit/src/guards.ts
  • libs/oshun/workbench-kit/src/idempotency.ts
  • libs/oshun/workbench-kit/src/inbox.ts
  • libs/oshun/workbench-kit/src/indexes.ts
  • libs/oshun/workbench-kit/src/job-graphs.ts
  • libs/oshun/workbench-kit/src/jobs.ts
  • libs/oshun/workbench-kit/src/outbox.ts
  • libs/oshun/workbench-kit/src/plugins.ts
  • libs/oshun/workbench-kit/src/probes.ts
  • libs/oshun/workbench-kit/src/protection.ts
  • libs/oshun/workbench-kit/src/quarantine.ts
  • libs/oshun/workbench-kit/src/reclamation.ts
  • libs/oshun/workbench-kit/src/signoff.ts
  • libs/oshun/workbench-kit/src/stages.ts
  • libs/oshun/workbench-kit/src/tenancy.ts