agent-passport-system 7.1.0 → 7.2.0

package/dist/src/v2/authority-state/types.d.ts

@@ -0,0 +1,198 @@
+import type { AuthorityRevocationV1 } from '../authority-revocation/types.js';
+/** What a marker is counted within. Comparing two markers from different scopes orders
+ *  nothing, so the comparison reports `unplaceable` rather than inventing an order.
+ *
+ *  The proposed text names none of these. They exist because the fixture that forced this
+ *  module had to pick one (it picked a global integer on a state view) and recorded that
+ *  the choice was not read from the text. Carrying the scope makes that choice visible in
+ *  the record instead of implicit in the deployment. Proposed. */
+export declare const STATE_MARKER_SCOPES: readonly ['global', 'per_delegation', 'per_principal', 'per_store'];
+export type StateMarkerScope = (typeof STATE_MARKER_SCOPES)[number];
+/** A monotonic generation marker on authority state.
+ *
+ *  `value` is a canonical unsigned decimal integer, the same convention the seven-facet
+ *  authority vector already uses for spend quantities: no sign, no leading zero, no
+ *  separators, arbitrary width. It is a string rather than a number so a marker past
+ *  2^53 - 1 stays exact, and it is compared as an integer, never lexically.
+ *
+ *  Nothing here is signed and nothing here is a wire field. No delegation, revocation or
+ *  store in this SDK carries a marker, and none is being given one: a marker is state the
+ *  caller has about a state source, handed in at comparison time. Proposed. */
+export interface StateMarker {
+    readonly value: string;
+    readonly scope: StateMarkerScope;
+    /** Which delegation, principal or store this marker is counted within. Required on every
+     *  scope except `global`, where it is absent. */
+    readonly scope_ref?: string;
+}
+/** The result of placing a presented marker against what a verifier has established.
+ *
+ *  - `forward`      the presented marker advanced, or held equal. Read the view normally.
+ *  - `regressed`    the presented marker went backwards against an established high-water
+ *                   mark. CAND-08's refusal case.
+ *  - `unplaceable`  there is nothing to compare against, or the two markers are counted in
+ *                   different scopes. **Deliberately not a verdict.** A high-water mark has
+ *                   to start somewhere and neither the proposed text nor draft-03 says
+ *                   whether a first read is trusted or refused. Both are defensible and the
+ *                   outcomes differ, so this module reports the fact and the caller
+ *                   decides. See `UnplaceableDisposition`. */
+export declare const MONOTONICITY_OUTCOMES: readonly ['forward', 'regressed', 'unplaceable'];
+export type MonotonicityOutcome = (typeof MONOTONICITY_OUTCOMES)[number];
+/** What a caller wants done with an `unplaceable` presented view. Required, with no
+ *  default, because the SDK picking one would be the SDK deciding a question its own
+ *  concept source records as undecided. */
+export declare const UNPLACEABLE_DISPOSITIONS: readonly ['read_presented', 'refuse'];
+export type UnplaceableDisposition = (typeof UNPLACEABLE_DISPOSITIONS)[number];
+/** What a verifier has established about authority state, as TWO separate inputs.
+ *
+ *  Splitting them is the whole point of this type. Two verifiers can hold the same
+ *  high-water mark and give different answers about the same restored view: the one that
+ *  retained the revocation records it observed can establish a revocation from records and
+ *  answers `revoked`, and the one that retained only the number cannot, and answers
+ *  `unknown`, which draft-03 section 3.3 makes indeterminate. The proposed text does not
+ *  distinguish those two verifiers at all, and the distinction turns out to be the
+ *  substance of the rollback question. An API taking "the epoch" as one value cannot
+ *  express it.
+ *
+ *  `records` is not a store and does not behave like one. It can answer `revoked` and it
+ *  can answer `unknown`. It can never answer `active`: a retained record set says nothing
+ *  about the delegations it does not mention, which is the same reason absence from an
+ *  `AuthorityRevocationStore` is `unknown` rather than `active`. */
+export interface RetainedAuthorityState {
+    /** Revocation records the verifier retained at its high-water mark. Each is re-verified
+     *  against the delegation in front of it before it can produce a `revoked` answer, so a
+     *  record that reached this array by some other route still cannot assert one. */
+    readonly records: readonly AuthorityRevocationV1[];
+    /** The newest marker this verifier has established, or `null` if it has established
+     *  none. */
+    readonly highWaterMark: StateMarker | null;
+}
+/** Why a fenced write was refused.
+ *
+ *  - `stale_fencing_token`     the token went backwards against the highest already seen.
+ *                              The only one of the three the source states.
+ *  - `fencing_scope_mismatch`  the token is counted in a different scope from the log's, so
+ *                              it cannot be ordered against what the log holds.
+ *  - `fencing_token_unreadable` the token is absent or not a well-formed `StateMarker`.
+ *
+ *  A write path that cannot order a token is not fenced, so the second and third refuse
+ *  rather than guess. Neither is in any source; both are this module's choice. */
+export declare const FENCED_WRITE_REFUSAL_CODES: readonly ['stale_fencing_token', 'fencing_scope_mismatch', 'fencing_token_unreadable'];
+export type FencedWriteRefusalCode = (typeof FENCED_WRITE_REFUSAL_CODES)[number];
+/** An authority-state write carrying the token of whoever claims to be the current
+ *  publisher. */
+export interface FencedWrite<T> {
+    readonly token: StateMarker;
+    readonly payload: T;
+}
+/** What a fenced log reports about one write.
+ *
+ *  An EQUAL token is accepted, and that is not an oversight. The rule the source states is
+ *  about tokens going backwards, and an equal token has not gone backwards: it is the same
+ *  holder retrying, which makes a retry idempotent. */
+export type FencedWriteOutcome<T> = {
+    readonly accepted: true;
+    readonly published: StateMarker;
+    readonly payload: T;
+} | {
+    readonly accepted: false;
+    readonly code: FencedWriteRefusalCode;
+    readonly published: StateMarker | null;
+};
+/** The record type a withdrawal carries.
+ *
+ *  `proposed:` is load-bearing. Record fields, failure-class names and verifier semantics
+ *  are conformance vocabulary reserved to the maintainer, and neither draft-03 nor the
+ *  proposed text defines a record for withdrawing a recorded revocation or says what a
+ *  verifier should do with one. This is a placeholder to argue about, not APS vocabulary. */
+export declare const REVOCATION_WITHDRAWAL_RECORD_TYPE: 'proposed:aps:revocation-withdrawal:v0';
+export declare const REVOCATION_WITHDRAWAL_VERSION: '0';
+/** A record stating that a recorded revocation was published in error.
+ *
+ *  It REFERENCES the revocation and never removes it. Inside an `AuthorityRevocationStore`
+ *  irreversibility is already structural: the store exposes `track`, `tracks`, `get` and
+ *  `insertVerifiedRevocation`, there is no removal method, and this module does not add
+ *  one. Draft-03 section 3.5 states "Revocation is irreversible", and a removal method
+ *  would be one call away from breaking it.
+ *
+ *  NOT AUTHENTICATED BY THIS MODULE. There is no canonical preimage here, no signature
+ *  field, and no verification function, deliberately: minting the signed form of a record
+ *  type is the vocabulary decision this module is not entitled to make. A caller hands in a
+ *  withdrawal it has already authenticated, exactly as `insertVerifiedRevocation` takes a
+ *  revocation `recordAuthorityRevocation` has already verified. Whoever reaches
+ *  `evaluateRevocationWithdrawal` is the party asserting the record is genuine. */
+export interface RevocationWithdrawalV0 {
+    readonly record_type: typeof REVOCATION_WITHDRAWAL_RECORD_TYPE;
+    readonly version: typeof REVOCATION_WITHDRAWAL_VERSION;
+    /** The revocation this record withdraws: `sha256:<64 lowercase hex>`. */
+    readonly revocation_id: string;
+    /** The delegation that revocation named. Carried so a withdrawal that names a revocation
+     *  of a different delegation is refusable without a second lookup. */
+    readonly delegation_id: string;
+    /** Who states the withdrawal. Whether this party may is NOT decided here. */
+    readonly withdrawn_by: string;
+    /** Canonical UTC-millisecond time, supplied by the caller, never read from a clock. */
+    readonly withdrawn_at: string;
+    /** Machine-readable ground. No grammar is fixed for one and none is invented here. */
+    readonly reason_code: string;
+    /** OPTIONAL free-text detail. Absent means the key is not present at all. */
+    readonly detail?: string;
+}
+/** What an injected standing resolver may answer.
+ *
+ *  `unknown` is a first-class answer and is not `no_standing`. A verifier that cannot
+ *  establish whether the withdrawer had standing has not established that they lacked it,
+ *  and the refusal reason says which of the two happened. */
+export declare const WITHDRAWAL_STANDINGS: readonly ['has_standing', 'no_standing', 'unknown'];
+export type WithdrawalStanding = (typeof WITHDRAWAL_STANDINGS)[number];
+/** Decides whether a withdrawal's author may withdraw this revocation.
+ *
+ *  Injected, never hardcoded, and never read from the withdrawal record itself. Draft-03
+ *  section 3.5 states "Any delegation MAY be revoked by its issuer" and the SDK enforces
+ *  `revoker === issuer` for a revocation. Nothing anywhere states who may WITHDRAW one.
+ *  `withdrawalSignerIsRevoker` is supplied as one resolver, is what the forcing fixture
+ *  chose, and is a choice rather than a rule read from any text. */
+export type WithdrawalStandingResolver = (withdrawal: RevocationWithdrawalV0, revocation: AuthorityRevocationV1) => WithdrawalStanding;
+/** Why a withdrawal was accepted or refused. Stable, module-local codes. */
+export declare const WITHDRAWAL_OUTCOME_CODES: readonly [
+/** Accepted as a record. Accepted never means the revocation is gone. */
+'WITHDRAWAL_ACCEPTED', 
+/** The record is not a well-formed `RevocationWithdrawalV0`. */
+'WITHDRAWAL_SCHEMA_INVALID', 
+/** No revocation in the held set carries the `revocation_id` this record names. */
+'WITHDRAWAL_NAMES_NO_HELD_REVOCATION', 
+/** The named revocation exists but is a revocation of a different delegation. */
+'WITHDRAWAL_TARGET_MISMATCH', 
+/** The resolver established that this party may not withdraw this revocation. */
+'WITHDRAWAL_SIGNER_WITHOUT_STANDING', 
+/** The resolver could not establish standing either way. Not the same finding as the
+ *  one above, and reported as `not_established` rather than as a denial. */
+'WITHDRAWAL_STANDING_NOT_ESTABLISHED'];
+export type WithdrawalOutcomeCode = (typeof WITHDRAWAL_OUTCOME_CODES)[number];
+/** What `evaluateRevocationWithdrawal` concludes about one withdrawal record. */
+export interface WithdrawalEvaluation {
+    readonly accepted: boolean;
+    readonly reason_code: WithdrawalOutcomeCode;
+    /** What the resolver answered, or `null` when evaluation refused before asking it. */
+    readonly standing: WithdrawalStanding | null;
+    /** The record evaluated, unchanged. */
+    readonly withdrawal: RevocationWithdrawalV0;
+}
+/** The current position of one revocation together with every withdrawal referencing it.
+ *
+ *  This is CAND-02 made into a shape. The revocation is present, unchanged, whether or not
+ *  a withdrawal was accepted. A later finding is a new record that references the earlier
+ *  one and states its own effect; it is never an edit of the earlier one and never its
+ *  removal. A verifier that must report "revoked, and the revoker later said this was
+ *  recorded in error" reports exactly this. */
+export interface CorrectedRevocationView {
+    /** The revocation record, byte for byte what it was. */
+    readonly revocation: AuthorityRevocationV1;
+    /** Accepted withdrawals, in the order supplied. Non-empty does NOT make the revocation
+     *  ineffective and does NOT change any chain verdict. */
+    readonly accepted: readonly WithdrawalEvaluation[];
+    /** Refused withdrawals, each with the code saying why. A withdrawal that changes nothing
+     *  in silence is indistinguishable from one that was never submitted. */
+    readonly refused: readonly WithdrawalEvaluation[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/v2/authority-state/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/v2/authority-state/types.ts"],"names":[],"mappings":"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"}

package/dist/src/v2/authority-state/types.js

@@ -0,0 +1,103 @@
+// Copyright (c) 2026 Tymofii Pidlisnyi
+// SPDX-License-Identifier: Apache-2.0
+//
+// PROPOSED, OPT-IN. Authority state markers, write fencing, and withdrawal of a recorded
+// revocation.
+//
+// NOT REQUIRED BY draft-pidlisnyi-aps-03. The published text contains no occurrence of
+// `epoch`, `fencing`, `snapshot`, `replica` or `restore`, and defines no record for
+// withdrawing a revocation. What it does fix, and what this module is careful not to
+// disturb, is section 3.3: "Verification returns one of valid, invalid, indeterminate, or
+// unsupported with a stable failure code", and section 3.5: "Revocation is irreversible."
+// `AuthorityValidationState`, `AuthorityValidationResult`, `AuthorityRevocationStore` and
+// everything `verifyAuthorityDelegationChain` returns are unchanged, and a caller that does
+// not import this module sees exactly today's behaviour.
+//
+// Concept source: the aeoess/agent-authority-lifecycle concept document
+// (AUTHORITY-LIFECYCLE.md, the `Authority epoch` concept and invariants L3, L7 and L11;
+// OPEN-QUESTIONS.md, `Authority rollback`) and its invariant candidates CAND-08 (no silent
+// restoration from rollback or stale state) and CAND-02 (later evidence does not rewrite
+// earlier evidence). Every one of those is proposed, not specified. Nothing here claims
+// otherwise, and `OPEN-QUESTIONS.md` keeps open both the mechanism and what a verifier
+// should return after a restore.
+//
+// Three deliberate non-decisions are encoded as types rather than as behaviour:
+//
+//  1. The proposed text says an authority epoch is "where a system uses generations" and
+//     stops. It does not say who advances one, whether it is global or per delegation,
+//     whether it is signed, or what evidence carries it. `StateMarker` is therefore an
+//     opaque comparable supplied by the caller, and this module defines only the comparison.
+//  2. A verifier with no prior observation has nothing to compare against. That is
+//     `unplaceable`, and it is not a verdict. The caller says what to do with it.
+//  3. Who may withdraw a revocation is not stated anywhere. Standing is resolved through an
+//     injected callback and never read from the record asserting it.
+/** What a marker is counted within. Comparing two markers from different scopes orders
+ *  nothing, so the comparison reports `unplaceable` rather than inventing an order.
+ *
+ *  The proposed text names none of these. They exist because the fixture that forced this
+ *  module had to pick one (it picked a global integer on a state view) and recorded that
+ *  the choice was not read from the text. Carrying the scope makes that choice visible in
+ *  the record instead of implicit in the deployment. Proposed. */
+export const STATE_MARKER_SCOPES = ['global', 'per_delegation', 'per_principal', 'per_store'];
+/** The result of placing a presented marker against what a verifier has established.
+ *
+ *  - `forward`      the presented marker advanced, or held equal. Read the view normally.
+ *  - `regressed`    the presented marker went backwards against an established high-water
+ *                   mark. CAND-08's refusal case.
+ *  - `unplaceable`  there is nothing to compare against, or the two markers are counted in
+ *                   different scopes. **Deliberately not a verdict.** A high-water mark has
+ *                   to start somewhere and neither the proposed text nor draft-03 says
+ *                   whether a first read is trusted or refused. Both are defensible and the
+ *                   outcomes differ, so this module reports the fact and the caller
+ *                   decides. See `UnplaceableDisposition`. */
+export const MONOTONICITY_OUTCOMES = ['forward', 'regressed', 'unplaceable'];
+/** What a caller wants done with an `unplaceable` presented view. Required, with no
+ *  default, because the SDK picking one would be the SDK deciding a question its own
+ *  concept source records as undecided. */
+export const UNPLACEABLE_DISPOSITIONS = ['read_presented', 'refuse'];
+/** Why a fenced write was refused.
+ *
+ *  - `stale_fencing_token`     the token went backwards against the highest already seen.
+ *                              The only one of the three the source states.
+ *  - `fencing_scope_mismatch`  the token is counted in a different scope from the log's, so
+ *                              it cannot be ordered against what the log holds.
+ *  - `fencing_token_unreadable` the token is absent or not a well-formed `StateMarker`.
+ *
+ *  A write path that cannot order a token is not fenced, so the second and third refuse
+ *  rather than guess. Neither is in any source; both are this module's choice. */
+export const FENCED_WRITE_REFUSAL_CODES = [
+    'stale_fencing_token',
+    'fencing_scope_mismatch',
+    'fencing_token_unreadable',
+];
+/** The record type a withdrawal carries.
+ *
+ *  `proposed:` is load-bearing. Record fields, failure-class names and verifier semantics
+ *  are conformance vocabulary reserved to the maintainer, and neither draft-03 nor the
+ *  proposed text defines a record for withdrawing a recorded revocation or says what a
+ *  verifier should do with one. This is a placeholder to argue about, not APS vocabulary. */
+export const REVOCATION_WITHDRAWAL_RECORD_TYPE = 'proposed:aps:revocation-withdrawal:v0';
+export const REVOCATION_WITHDRAWAL_VERSION = '0';
+/** What an injected standing resolver may answer.
+ *
+ *  `unknown` is a first-class answer and is not `no_standing`. A verifier that cannot
+ *  establish whether the withdrawer had standing has not established that they lacked it,
+ *  and the refusal reason says which of the two happened. */
+export const WITHDRAWAL_STANDINGS = ['has_standing', 'no_standing', 'unknown'];
+/** Why a withdrawal was accepted or refused. Stable, module-local codes. */
+export const WITHDRAWAL_OUTCOME_CODES = [
+    /** Accepted as a record. Accepted never means the revocation is gone. */
+    'WITHDRAWAL_ACCEPTED',
+    /** The record is not a well-formed `RevocationWithdrawalV0`. */
+    'WITHDRAWAL_SCHEMA_INVALID',
+    /** No revocation in the held set carries the `revocation_id` this record names. */
+    'WITHDRAWAL_NAMES_NO_HELD_REVOCATION',
+    /** The named revocation exists but is a revocation of a different delegation. */
+    'WITHDRAWAL_TARGET_MISMATCH',
+    /** The resolver established that this party may not withdraw this revocation. */
+    'WITHDRAWAL_SIGNER_WITHOUT_STANDING',
+    /** The resolver could not establish standing either way. Not the same finding as the
+     *  one above, and reported as `not_established` rather than as a denial. */
+    'WITHDRAWAL_STANDING_NOT_ESTABLISHED',
+];
+//# sourceMappingURL=types.js.map

package/dist/src/v2/authority-state/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/v2/authority-state/types.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,sCAAsC;AACtC,EAAE;AACF,yFAAyF;AACzF,cAAc;AACd,EAAE;AACF,uFAAuF;AACvF,oFAAoF;AACpF,qFAAqF;AACrF,0FAA0F;AAC1F,0FAA0F;AAC1F,0FAA0F;AAC1F,4FAA4F;AAC5F,yDAAyD;AACzD,EAAE;AACF,wEAAwE;AACxE,wFAAwF;AACxF,2FAA2F;AAC3F,yFAAyF;AACzF,wFAAwF;AACxF,uFAAuF;AACvF,iCAAiC;AACjC,EAAE;AACF,gFAAgF;AAChF,EAAE;AACF,yFAAyF;AACzF,uFAAuF;AACvF,uFAAuF;AACvF,6FAA6F;AAC7F,mFAAmF;AACnF,kFAAkF;AAClF,4FAA4F;AAC5F,qEAAqE;AAIrE;;;;;;kEAMkE;AAClE,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,QAAQ,EAAE,gBAAgB,EAAE,eAAe,EAAE,WAAW,CAAU,CAAA;AAsBtG;;;;;;;;;;8DAU8D;AAC9D,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,SAAS,EAAE,WAAW,EAAE,aAAa,CAAU,CAAA;AAIrF;;2CAE2C;AAC3C,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,gBAAgB,EAAE,QAAQ,CAAU,CAAA;AA6B7E;;;;;;;;;kFASkF;AAClF,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACxC,qBAAqB;IACrB,wBAAwB;IACxB,0BAA0B;CAClB,CAAA;AAoBV;;;;;6FAK6F;AAC7F,MAAM,CAAC,MAAM,iCAAiC,GAAG,uCAAgD,CAAA;AACjG,MAAM,CAAC,MAAM,6BAA6B,GAAG,GAAY,CAAA;AAkCzD;;;;6DAI6D;AAC7D,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,cAAc,EAAE,aAAa,EAAE,SAAS,CAAU,CAAA;AAgBvF,4EAA4E;AAC5E,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,yEAAyE;IACzE,qBAAqB;IACrB,gEAAgE;IAChE,2BAA2B;IAC3B,mFAAmF;IACnF,qCAAqC;IACrC,iFAAiF;IACjF,4BAA4B;IAC5B,iFAAiF;IACjF,oCAAoC;IACpC;gFAC4E;IAC5E,qCAAqC;CAC7B,CAAA"}

package/dist/src/v2/authority-state/withdrawal.d.ts

@@ -0,0 +1,80 @@
+import type { AuthorityRevocationV1 } from '../authority-revocation/types.js';
+import { type CorrectedRevocationView, type RevocationWithdrawalV0, type WithdrawalEvaluation, type WithdrawalStanding, type WithdrawalStandingResolver } from './types.js';
+export declare function isWithdrawalStanding(value: unknown): value is WithdrawalStanding;
+export interface RevocationWithdrawalInput {
+    readonly revocation_id: string;
+    readonly delegation_id: string;
+    readonly withdrawn_by: string;
+    readonly withdrawn_at: string;
+    readonly reason_code: string;
+    readonly detail?: string;
+}
+/**
+ * Build a `RevocationWithdrawalV0`.
+ *
+ * A shape constructor and nothing more. It does not sign, does not canonicalize, and does
+ * not compute an identifier, because minting the signed form of a record type is a
+ * conformance-vocabulary decision reserved to the maintainer and this module is not making
+ * it. `record_type` carries the `proposed:` namespace for the same reason.
+ *
+ * An absent `detail` is absent, never `null`: the key is not present at all, matching how
+ * the revocation record treats its own optional detail.
+ */
+export declare function revocationWithdrawal(input: RevocationWithdrawalInput): RevocationWithdrawalV0;
+/** A standing resolver that accepts a withdrawal only from the party the revocation itself
+ *  names as revoker.
+ *
+ *  Supplied because it is the rule the forcing fixture chose and it needs to be runnable.
+ *  IT IS A CHOICE, NOT A RULE READ FROM ANY TEXT. Draft-03 section 3.5 names the issuer as
+ *  the party who may revoke; nothing in draft-03 or in the proposed text says who may
+ *  withdraw a revocation, and the concept document's own `Lifecycle standing` entry says
+ *  the party who may change an artifact "is not always the issuer". A deployment whose
+ *  authority model gives a security function, a successor or a quorum standing to correct a
+ *  publication error should pass its own resolver instead of this one. */
+export declare const withdrawalSignerIsRevoker: WithdrawalStandingResolver;
+/**
+ * Decide whether one withdrawal record is accepted against a set of held revocations.
+ *
+ * Four questions, kept separate on purpose, each with its own code:
+ *
+ *  1. Is the record a well-formed withdrawal? `WITHDRAWAL_SCHEMA_INVALID`.
+ *  2. Does it name a revocation the held set actually contains?
+ *     `WITHDRAWAL_NAMES_NO_HELD_REVOCATION`.
+ *  3. Does that revocation revoke the delegation this record names?
+ *     `WITHDRAWAL_TARGET_MISMATCH`.
+ *  4. May this party withdraw it? Asked of the injected resolver, never of the record.
+ *     `WITHDRAWAL_SIGNER_WITHOUT_STANDING` when the resolver establishes they may not, and
+ *     `WITHDRAWAL_STANDING_NOT_ESTABLISHED` when it cannot establish either way.
+ *
+ * The last split is the wording rule, executable: a standing question the verifier could
+ * not answer is not established, and that is not the same finding as a party established to
+ * lack standing. Both refuse the withdrawal, and a caller reporting the refusal has to be
+ * able to say which one happened.
+ *
+ * AUTHENTICATION IS THE CALLER'S. This function never checks a signature, because a
+ * withdrawal has no signed form in this SDK, on purpose; see `RevocationWithdrawalV0`.
+ * Whoever calls it is the party asserting the record is genuine, exactly as whoever calls
+ * `insertVerifiedRevocation` asserts the revocation was verified.
+ *
+ * NOTHING HERE REMOVES A REVOCATION, on any path. An accepted withdrawal is a record about
+ * a record. The held set handed in is not mutated and no store is touched.
+ */
+export declare function evaluateRevocationWithdrawal(withdrawal: RevocationWithdrawalV0, heldRevocations: readonly AuthorityRevocationV1[], resolveStanding: WithdrawalStandingResolver): WithdrawalEvaluation;
+/**
+ * The current position of one revocation together with every withdrawal referencing it.
+ *
+ * This is the field that did not exist. A verifier that must report "revoked, and the
+ * revoker later said this was recorded in error" had nowhere to put the second half, in
+ * either reference SDK or in the proposed text, so it could only report the first half and
+ * drop the rest.
+ *
+ * `revocation` is present and unchanged whether or not anything was accepted. Accepted
+ * withdrawals are listed, refused ones are listed with their codes, and neither list makes
+ * the revocation ineffective: a later finding is a new record that references the earlier
+ * one and states its own effect, never an edit of it and never its removal.
+ *
+ * Withdrawals naming a different revocation are not silently dropped. They are evaluated,
+ * refused `WITHDRAWAL_NAMES_NO_HELD_REVOCATION`, and appear in `refused`.
+ */
+export declare function correctedRevocationView(revocation: AuthorityRevocationV1, withdrawals: readonly RevocationWithdrawalV0[], resolveStanding: WithdrawalStandingResolver): CorrectedRevocationView;
+//# sourceMappingURL=withdrawal.d.ts.map

package/dist/src/v2/authority-state/withdrawal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withdrawal.d.ts","sourceRoot":"","sources":["../../../../src/v2/authority-state/withdrawal.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAA;AAE7E,OAAO,EAIL,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,0BAA0B,EAChC,MAAM,YAAY,CAAA;AAInB,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAEhF;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CACzB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,yBAAyB,GAAG,sBAAsB,CA8C7F;AAED;;;;;;;;;0EAS0E;AAC1E,eAAO,MAAM,yBAAyB,EAAE,0BACyC,CAAA;AAgBjF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,sBAAsB,EAClC,eAAe,EAAE,SAAS,qBAAqB,EAAE,EACjD,eAAe,EAAE,0BAA0B,GAC1C,oBAAoB,CAqDtB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,qBAAqB,EACjC,WAAW,EAAE,SAAS,sBAAsB,EAAE,EAC9C,eAAe,EAAE,0BAA0B,GAC1C,uBAAuB,CAUzB"}

package/dist/src/v2/authority-state/withdrawal.js

@@ -0,0 +1,199 @@
+// Copyright (c) 2026 Tymofii Pidlisnyi
+// SPDX-License-Identifier: Apache-2.0
+//
+// PROPOSED, OPT-IN. Withdrawal, or correction, of a recorded revocation.
+// See ./types.ts for the specification position. Concept source:
+// aeoess/agent-authority-lifecycle, invariant candidate CAND-02 (later evidence does not
+// rewrite earlier evidence) and invariant L3 (reauthorization creates new authority).
+// Proposed.
+//
+// THE ONE SENTENCE THIS FILE EXISTS FOR. A corrected false revocation is a separate record,
+// not a resurrection. Draft-03 section 3.5 states "Revocation is irreversible", and nothing
+// below relaxes that: an accepted withdrawal leaves the revocation held, leaves it
+// verifying byte for byte, and leaves every chain verdict exactly where it was. What the
+// withdrawal changes is what a verifier can REPORT, which had no representation at all.
+//
+// Continuity after a correction still needs a fresh grant from a principal who currently
+// holds authority. This module mints no grant and no authority of any kind.
+import { AuthorityStateError } from './marker.js';
+import { REVOCATION_WITHDRAWAL_RECORD_TYPE, REVOCATION_WITHDRAWAL_VERSION, WITHDRAWAL_STANDINGS, } from './types.js';
+const ID = /^sha256:[0-9a-f]{64}$/;
+export function isWithdrawalStanding(value) {
+    return typeof value === 'string' && WITHDRAWAL_STANDINGS.includes(value);
+}
+/**
+ * Build a `RevocationWithdrawalV0`.
+ *
+ * A shape constructor and nothing more. It does not sign, does not canonicalize, and does
+ * not compute an identifier, because minting the signed form of a record type is a
+ * conformance-vocabulary decision reserved to the maintainer and this module is not making
+ * it. `record_type` carries the `proposed:` namespace for the same reason.
+ *
+ * An absent `detail` is absent, never `null`: the key is not present at all, matching how
+ * the revocation record treats its own optional detail.
+ */
+export function revocationWithdrawal(input) {
+    if (input === null || typeof input !== 'object') {
+        throw new AuthorityStateError('WITHDRAWAL_MALFORMED', 'a withdrawal input must be an object');
+    }
+    for (const field of ['revocation_id', 'delegation_id']) {
+        if (typeof input[field] !== 'string' || !ID.test(input[field])) {
+            throw new AuthorityStateError('WITHDRAWAL_ID_NONCANONICAL', `${field} must be sha256:<64 lowercase hex>`);
+        }
+    }
+    for (const field of ['withdrawn_by', 'withdrawn_at', 'reason_code']) {
+        if (typeof input[field] !== 'string' || input[field].length === 0) {
+            throw new AuthorityStateError('WITHDRAWAL_FIELD_REQUIRED', `${field} must be a non-empty string`);
+        }
+    }
+    if (input.detail !== undefined && (typeof input.detail !== 'string' || input.detail.length === 0)) {
+        throw new AuthorityStateError('WITHDRAWAL_DETAIL_INVALID', 'detail must be a non-empty string when present');
+    }
+    const record = {
+        record_type: REVOCATION_WITHDRAWAL_RECORD_TYPE,
+        version: REVOCATION_WITHDRAWAL_VERSION,
+        revocation_id: input.revocation_id,
+        delegation_id: input.delegation_id,
+        withdrawn_by: input.withdrawn_by,
+        withdrawn_at: input.withdrawn_at,
+        reason_code: input.reason_code,
+    };
+    if (input.detail !== undefined)
+        record.detail = input.detail;
+    return Object.freeze(record);
+}
+/** A standing resolver that accepts a withdrawal only from the party the revocation itself
+ *  names as revoker.
+ *
+ *  Supplied because it is the rule the forcing fixture chose and it needs to be runnable.
+ *  IT IS A CHOICE, NOT A RULE READ FROM ANY TEXT. Draft-03 section 3.5 names the issuer as
+ *  the party who may revoke; nothing in draft-03 or in the proposed text says who may
+ *  withdraw a revocation, and the concept document's own `Lifecycle standing` entry says
+ *  the party who may change an artifact "is not always the issuer". A deployment whose
+ *  authority model gives a security function, a successor or a quorum standing to correct a
+ *  publication error should pass its own resolver instead of this one. */
+export const withdrawalSignerIsRevoker = (withdrawal, revocation) => withdrawal.withdrawn_by === revocation.revoker ? 'has_standing' : 'no_standing';
+function malformed(withdrawal) {
+    const w = withdrawal;
+    if (w === null || typeof w !== 'object')
+        return true;
+    if (w.record_type !== REVOCATION_WITHDRAWAL_RECORD_TYPE)
+        return true;
+    if (w.version !== REVOCATION_WITHDRAWAL_VERSION)
+        return true;
+    if (typeof w.revocation_id !== 'string' || !ID.test(w.revocation_id))
+        return true;
+    if (typeof w.delegation_id !== 'string' || !ID.test(w.delegation_id))
+        return true;
+    for (const field of ['withdrawn_by', 'withdrawn_at', 'reason_code']) {
+        const value = w[field];
+        if (typeof value !== 'string' || value.length === 0)
+            return true;
+    }
+    return false;
+}
+/**
+ * Decide whether one withdrawal record is accepted against a set of held revocations.
+ *
+ * Four questions, kept separate on purpose, each with its own code:
+ *
+ *  1. Is the record a well-formed withdrawal? `WITHDRAWAL_SCHEMA_INVALID`.
+ *  2. Does it name a revocation the held set actually contains?
+ *     `WITHDRAWAL_NAMES_NO_HELD_REVOCATION`.
+ *  3. Does that revocation revoke the delegation this record names?
+ *     `WITHDRAWAL_TARGET_MISMATCH`.
+ *  4. May this party withdraw it? Asked of the injected resolver, never of the record.
+ *     `WITHDRAWAL_SIGNER_WITHOUT_STANDING` when the resolver establishes they may not, and
+ *     `WITHDRAWAL_STANDING_NOT_ESTABLISHED` when it cannot establish either way.
+ *
+ * The last split is the wording rule, executable: a standing question the verifier could
+ * not answer is not established, and that is not the same finding as a party established to
+ * lack standing. Both refuse the withdrawal, and a caller reporting the refusal has to be
+ * able to say which one happened.
+ *
+ * AUTHENTICATION IS THE CALLER'S. This function never checks a signature, because a
+ * withdrawal has no signed form in this SDK, on purpose; see `RevocationWithdrawalV0`.
+ * Whoever calls it is the party asserting the record is genuine, exactly as whoever calls
+ * `insertVerifiedRevocation` asserts the revocation was verified.
+ *
+ * NOTHING HERE REMOVES A REVOCATION, on any path. An accepted withdrawal is a record about
+ * a record. The held set handed in is not mutated and no store is touched.
+ */
+export function evaluateRevocationWithdrawal(withdrawal, heldRevocations, resolveStanding) {
+    if (malformed(withdrawal)) {
+        return Object.freeze({
+            accepted: false,
+            reason_code: 'WITHDRAWAL_SCHEMA_INVALID',
+            standing: null,
+            withdrawal,
+        });
+    }
+    const target = (heldRevocations ?? []).find(r => r?.revocation_id === withdrawal.revocation_id);
+    if (target === undefined) {
+        return Object.freeze({
+            accepted: false,
+            reason_code: 'WITHDRAWAL_NAMES_NO_HELD_REVOCATION',
+            standing: null,
+            withdrawal,
+        });
+    }
+    if (target.delegation_id !== withdrawal.delegation_id) {
+        return Object.freeze({
+            accepted: false,
+            reason_code: 'WITHDRAWAL_TARGET_MISMATCH',
+            standing: null,
+            withdrawal,
+        });
+    }
+    let standing;
+    try {
+        standing = resolveStanding(withdrawal, target);
+    }
+    catch {
+        standing = 'unknown';
+    }
+    if (!isWithdrawalStanding(standing))
+        standing = 'unknown';
+    if (standing === 'has_standing') {
+        return Object.freeze({
+            accepted: true,
+            reason_code: 'WITHDRAWAL_ACCEPTED',
+            standing,
+            withdrawal,
+        });
+    }
+    return Object.freeze({
+        accepted: false,
+        reason_code: standing === 'no_standing'
+            ? 'WITHDRAWAL_SIGNER_WITHOUT_STANDING'
+            : 'WITHDRAWAL_STANDING_NOT_ESTABLISHED',
+        standing,
+        withdrawal,
+    });
+}
+/**
+ * The current position of one revocation together with every withdrawal referencing it.
+ *
+ * This is the field that did not exist. A verifier that must report "revoked, and the
+ * revoker later said this was recorded in error" had nowhere to put the second half, in
+ * either reference SDK or in the proposed text, so it could only report the first half and
+ * drop the rest.
+ *
+ * `revocation` is present and unchanged whether or not anything was accepted. Accepted
+ * withdrawals are listed, refused ones are listed with their codes, and neither list makes
+ * the revocation ineffective: a later finding is a new record that references the earlier
+ * one and states its own effect, never an edit of it and never its removal.
+ *
+ * Withdrawals naming a different revocation are not silently dropped. They are evaluated,
+ * refused `WITHDRAWAL_NAMES_NO_HELD_REVOCATION`, and appear in `refused`.
+ */
+export function correctedRevocationView(revocation, withdrawals, resolveStanding) {
+    const held = [revocation];
+    const evaluations = (withdrawals ?? []).map(w => evaluateRevocationWithdrawal(w, held, resolveStanding));
+    return Object.freeze({
+        revocation,
+        accepted: Object.freeze(evaluations.filter(e => e.accepted)),
+        refused: Object.freeze(evaluations.filter(e => !e.accepted)),
+    });
+}
+//# sourceMappingURL=withdrawal.js.map

package/dist/src/v2/authority-state/withdrawal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withdrawal.js","sourceRoot":"","sources":["../../../../src/v2/authority-state/withdrawal.ts"],"names":[],"mappings":"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"}

package/dist/src/v2/bounds/canonical.d.ts

@@ -0,0 +1,30 @@
+import type { AuthorityBoundFulfilment, AuthorityBoundFulfilmentBody, AuthorityExhaustion, AuthorityExhaustionBody } from './types.js';
+/** Domain tags. Each is a distinct tag followed by one zero byte, the same discipline
+ *  `AuthorityDelegationV1` and `AuthorityRevocationV1` follow, so bytes minted for one
+ *  construction can never be read as bytes minted for another. The `PROPOSED-` prefix is
+ *  part of the tag: if any of this is ever specified, the specified construction will use a
+ *  different tag and records minted under this one will not verify under it. That is the
+ *  intended behaviour, not a migration problem to solve later. */
+export declare const AUTHORITY_BOUND_FULFILMENT_SIGNATURE_DOMAIN = "PROPOSED-APS-AUTHORITY-BOUND-FULFILMENT-SIGNATURE-V0\0";
+export declare const AUTHORITY_EXHAUSTION_ID_DOMAIN = "PROPOSED-APS-AUTHORITY-EXHAUSTION-ID-V0\0";
+export declare const AUTHORITY_EXHAUSTION_SIGNATURE_DOMAIN = "PROPOSED-APS-AUTHORITY-EXHAUSTION-SIGNATURE-V0\0";
+/** Exact Ed25519 preimage for a fulfilment attestation: the domain tag plus RFC 8785 JCS of
+ *  the record with `signature` absent. */
+export declare function authorityBoundFulfilmentSignatureInput(body: AuthorityBoundFulfilmentBody): string;
+/** Write-boundary twin. Use when ISSUING. The verification path keeps calling the
+ *  unrestricted form, so a record minted before the write rule still verifies. */
+export declare function authorityBoundFulfilmentSignatureInputForWrite(body: AuthorityBoundFulfilmentBody): string;
+export declare function signAuthorityBoundFulfilment(body: AuthorityBoundFulfilmentBody, privateKeyHex: string): string;
+export declare function verifyAuthorityBoundFulfilmentSignature(record: AuthorityBoundFulfilment, publicKeyHex: string): boolean;
+/** Exact preimage for `exhaustion_id`: the ID domain tag plus JCS of the body. */
+export declare function authorityExhaustionIdInput(body: AuthorityExhaustionBody): string;
+export declare function computeAuthorityExhaustionId(body: AuthorityExhaustionBody): string;
+export declare function computeAuthorityExhaustionIdForWrite(body: AuthorityExhaustionBody): string;
+/** Exact Ed25519 preimage for the exhaustion record: the signature domain tag plus JCS of
+ *  the record with `signature` absent. `exhaustion_id` IS inside this preimage, so the
+ *  identifier is signed rather than being an unauthenticated label beside the signature. */
+export declare function authorityExhaustionSignatureInput(record: Omit<AuthorityExhaustion, 'signature'>): string;
+export declare function authorityExhaustionSignatureInputForWrite(record: Omit<AuthorityExhaustion, 'signature'>): string;
+export declare function signAuthorityExhaustion(record: Omit<AuthorityExhaustion, 'signature'>, privateKeyHex: string): string;
+export declare function verifyAuthorityExhaustionSignature(record: AuthorityExhaustion, publicKeyHex: string): boolean;
+//# sourceMappingURL=canonical.d.ts.map