agent-passport-system 7.0.0 → 7.2.0

package/dist/src/v2/activation/types.d.ts

@@ -0,0 +1,268 @@
+import type { EstablishmentGap, LifecycleStateResult } from '../lifecycle-state/types.js';
+/** Record type of the activation condition this module owns. The `proposed:` prefix is
+ *  deliberate: the conformance suite's CONTRIBUTING.md reserves record fields, failure-class
+ *  names and verifier semantics to the schema owner, so nothing here is minted APS
+ *  vocabulary and nothing downstream should treat it as stable. */
+export declare const ACTIVATION_CONDITION_TYPE: 'proposed:aps:activation-condition:v0';
+/** Record type of the activation attestation this module owns. Same caveat as above.
+ *  A model may accept condition evidence in a shape this module does not own; see
+ *  `ActivationVerificationInput.attestationPreimage`. */
+export declare const ACTIVATION_ATTESTATION_TYPE: 'proposed:aps:activation-attestation:v0';
+/** The two kinds of activation condition the concept text names in one sentence: "A grant can
+ *  be validly issued and still wait on a date or a recorded event." They are answered by
+ *  different deciders, which is why they are separate members here rather than one shape with
+ *  optional fields. A date condition needs no evidence at all: the verifier reads the date. A
+ *  recorded-event condition needs evidence from a source the model accepts for it. */
+export declare const ACTIVATION_CONDITION_KINDS: readonly ['date', 'recorded_event'];
+export type ActivationConditionKind = (typeof ACTIVATION_CONDITION_KINDS)[number];
+/** Which instant a `condition_occurred` attestation is measured against.
+ *
+ *  - `condition_occurrence`  the instant the condition itself is asserted to have occurred,
+ *                            from the record's `occurred_at`. This is CAND-04 v2's reading:
+ *                            "A condition that first occurred after an action does not make
+ *                            that action exercisable", which is a statement about the
+ *                            condition's own instant. Under it, a record written after an
+ *                            action can establish a condition that obtained before it, which
+ *                            is the normal case for any model built around an
+ *                            after-the-fact determination.
+ *  - `attestation_written`   the instant the record was written, from `attested_at`. A model
+ *                            that keys activation on when someone wrote the determination
+ *                            down rather than on when the condition occurred can say so
+ *                            here.
+ *
+ *  THERE IS NO DEFAULT. The concept text groups a date and a recorded event in one sentence
+ *  and says nothing about which instant either is measured from, and a default in an SDK is a
+ *  ruling made by whoever wrote the SDK. Both readings give opposite verdicts on a
+ *  deployment-relevant case (an occurrence before an action, attested after it), so the
+ *  condition has to state which one governs.
+ *
+ *  `instant_basis` does not apply to a `condition_not_occurred_through` record. That
+ *  assertion states the interval it covers, and the interval is what the coverage check
+ *  reads. Concept source: BROAD-L7's coverage limb. */
+export declare const ACTIVATION_INSTANT_BASES: readonly ['condition_occurrence', 'attestation_written'];
+export type ActivationInstantBasis = (typeof ACTIVATION_INSTANT_BASES)[number];
+/** The two assertions an activation attestation can carry.
+ *
+ *  - `condition_occurred`             the event occurred, at `occurred_at`.
+ *  - `condition_not_occurred_through` the event had not occurred through
+ *                                     `not_occurred_through`. A NEGATIVE that is evidence,
+ *                                     not an absence of evidence, which is the distinction
+ *                                     between `not_yet_effective` and `not_established`.
+ *
+ *  An absence-triggered condition, where the trigger is that something did NOT happen within
+ *  a declared window, is NOT modelled here. CAND-04's own counterexample analysis names it as
+ *  the shape most likely to be implemented wrongly in the fail-closed direction, and this
+ *  module has no vocabulary for it. `resolveAttestorRole` returning `unknown` is what keeps
+ *  that case reachable for a later surface rather than silently answered here. */
+export declare const ACTIVATION_ASSERTIONS: readonly ['condition_occurred', 'condition_not_occurred_through'];
+export type ActivationAssertion = (typeof ACTIVATION_ASSERTIONS)[number];
+/** Members every activation condition carries. */
+export interface ActivationConditionCommonV0 {
+    readonly record_type: typeof ACTIVATION_CONDITION_TYPE;
+    /** Opaque. This module never derives, parses or interprets a condition identifier. */
+    readonly condition_id: string;
+    /** The grant this condition gates. A REFERENCE, never a facet: draft-03 section 3.2 closes
+     *  `authority` at seven facets, so a condition cannot ride inside a signed
+     *  `AuthorityDelegationV1` at all. */
+    readonly delegation_id: string;
+}
+/** A condition that waits on a date. The verifier reads the date and compares it with the
+ *  action instant, so an unreached date is always a known negative and never an unknown one.
+ *  No attestation is involved and none is consulted. */
+export interface DateActivationConditionV0 extends ActivationConditionCommonV0 {
+    readonly condition_type: 'date';
+    /** RFC 3339, offset required. */
+    readonly activation_date: string;
+}
+/** A condition that waits on a recorded event, attested by a party holding a declared role. */
+export interface RecordedEventActivationConditionV0 extends ActivationConditionCommonV0 {
+    readonly condition_type: 'recorded_event';
+    /** Opaque to this module. Compared for equality against an attestation's own member. */
+    readonly event_type: string;
+    /** Opaque to this module. Compared for equality against an attestation's own member. */
+    readonly event_id: string;
+    /** ROLE identifiers, never principals. Who holds a role is the resolver's answer, not the
+     *  condition's and never the attestation's. At least one member is required: a condition
+     *  that names no accepted source has not stated what it accepts, and this module refuses it
+     *  rather than accepting anything. A record from a party holding ANY member is acceptable,
+     *  which is a union and not a conjunction; a model needing every named role to attest needs
+     *  a rule this module does not express. */
+    readonly required_attestor_roles: readonly string[];
+    /** How many acceptable attestations establish a finding. At least 1, and there is NO
+     *  DEFAULT for what it should be: how many determinations a model requires is a model
+     *  decision. The same threshold applies in both directions, so a model wanting one record
+     *  to establish an occurrence and two to establish a non-occurrence is not expressible
+     *  here. That asymmetry is an open question, not a settled no. */
+    readonly threshold: number;
+    readonly instant_basis: ActivationInstantBasis;
+}
+export type ActivationConditionV0 = DateActivationConditionV0 | RecordedEventActivationConditionV0;
+/** An activation attestation, as presented.
+ *
+ *  `record_type` is typed as `string` rather than as this module's own constant because a
+ *  model can accept condition evidence in a shape this module does not own. What it accepts
+ *  is a model declaration, supplied through
+ *  `ActivationVerificationInput.acceptedAttestationRecordTypes`.
+ *
+ *  `attestor_role` is the attestor's CLAIM ABOUT ITSELF and is never authority for anything.
+ *  It is checked against the resolver, and a claim the resolver contradicts is its own
+ *  rejection reason rather than being folded into a plain role mismatch, because the two are
+ *  different findings: one party is in the wrong place, the other says it is somewhere it is
+ *  not. An attestation that makes no role claim is not rejected for that; the required-role
+ *  check still runs.
+ *
+ *  The index signature is deliberate. Extra members ride along, are inside the signed
+ *  preimage, and are never interpreted here. */
+export interface ActivationAttestationV0 {
+    readonly record_type: string;
+    readonly assertion: string;
+    readonly attestor: string;
+    readonly attestor_role?: string;
+    readonly condition_id: string;
+    readonly event_type?: string;
+    readonly event_id?: string;
+    /** RFC 3339. Present on `condition_occurred`. */
+    readonly occurred_at?: string;
+    /** RFC 3339. Present on `condition_not_occurred_through`. */
+    readonly not_occurred_through?: string;
+    /** RFC 3339. When the record itself was written. Used to select the signing key version
+     *  authorized at that instant, per draft-03 section 2.4, and used as the occurrence instant
+     *  only under `instant_basis: 'attestation_written'`. */
+    readonly attested_at: string;
+    readonly verification_method: string;
+    readonly attestation_id: string;
+    readonly signature: string;
+    readonly [key: string]: unknown;
+}
+/** What a resolver can say about whether an attestor holds a role at an instant.
+ *
+ *  THREE VALUES, NOT A BOOLEAN. "This registry does not know" is a distinct answer from "this
+ *  party does not hold that role", and collapsing the first into the second turns ignorance
+ *  into a denial. That collapse is the failure BROAD-L7 exists to name, and it is the reason
+ *  an absence-triggered condition needs `unknown` to stay reachable. */
+export declare const ATTESTOR_ROLE_STANDINGS: readonly ['holds', 'does_not_hold', 'unknown'];
+export type AttestorRoleStanding = (typeof ATTESTOR_ROLE_STANDINGS)[number];
+/** Resolves whether `attestor` held `role` at `atInstant`.
+ *
+ *  Role standing is resolved OUTSIDE the record, always. This module never reads standing
+ *  from the artifact asserting it, which is the single control that separates a real
+ *  attestor-role check from a self-declared one. `atInstant` is passed so a registry with its
+ *  own history can answer for the right moment; a resolver that ignores it is answering for
+ *  "now", which is a choice the resolver makes and not one this module makes for it.
+ *
+ *  Where role standing comes from, who publishes it and what a verifier consults are not
+ *  settled by any published or proposed text. That is why this is a callback and not a
+ *  registry type. */
+export type AttestorRoleResolver = (attestor: string, role: string, atInstant: string) => AttestorRoleStanding;
+/** What one accepted attestation establishes about the condition at the action instant.
+ *
+ *  - `occurred_by_action`          the condition's instant is at or before the action instant.
+ *  - `occurred_after_action`       the condition's instant is after it. The SAME record
+ *                                  establishes the condition for any later action, which is
+ *                                  what makes this a wait rather than a failure.
+ *  - `not_occurred_through_action` an accepted record states the condition had not occurred
+ *                                  through an instant that reaches the action instant. */
+export declare const ACTIVATION_FINDINGS: readonly ['occurred_by_action', 'occurred_after_action', 'not_occurred_through_action'];
+export type ActivationFindingKind = (typeof ACTIVATION_FINDINGS)[number];
+/** One accepted attestation and what it established. */
+export interface ActivationFinding {
+    readonly attestation_id: string;
+    readonly attestor: string;
+    readonly finding: ActivationFindingKind;
+}
+/** One rejected attestation and why. A rejected attestation is NOT evidence in either
+ *  direction: it cannot establish the condition and it equally cannot establish that the
+ *  condition was unmet. That is the whole of the difference between `not_established` and
+ *  `not_yet_effective` for a record from a source the model does not accept. */
+export interface ActivationRejection {
+    readonly attestation_id: string;
+    readonly attestor: string;
+    readonly reason_code: ActivationReasonCode;
+}
+/** Every reason code this module emits, verdict-level and rejection-level.
+ *
+ *  Module-local and SCREAMING_SNAKE_CASE, per the lifecycle-state vocabulary's rule that two
+ *  findings sharing a verdict name must be told apart by their codes. Not minted APS
+ *  vocabulary. */
+export declare const ACTIVATION_REASON_CODES: readonly [
+/** valid: an accepted record establishes the condition at or before the action instant, or
+ *  a date condition's date has been reached. */
+'ACTIVATION_ESTABLISHED', 
+/** not_yet_effective: a date condition's activation date is after the action instant. */
+'CONDITION_DATE_NOT_REACHED', 
+/** not_yet_effective: an accepted record states the condition had not occurred through an
+ *  instant reaching the action instant. */
+'CONDITION_ESTABLISHED_NOT_YET_OCCURRED', 
+/** not_yet_effective: an accepted record puts the condition's first occurrence after the
+ *  action instant. No retroactive activation: the same record establishes the condition for
+ *  a later action, and never for this one. */
+'CONDITION_FIRST_OCCURRED_AFTER_ACTION', 
+/** not_established, source: two accepted records disagree about the action instant. Neither
+ *  defeats the other and this module has no precedence rule. */
+'CONDITION_EVIDENCE_CONFLICT', 
+/** not_established, source: accepted records exist but fewer than `threshold` of them
+ *  support the finding. */
+'ACTIVATION_THRESHOLD_NOT_MET', 
+/** not_established, source: nothing was presented. */
+'NO_ATTESTATION_PRESENTED', 
+/** not_established, coverage: the condition presented gates a different delegation. The
+ *  claim does not state that it covers what the verdict needed. */
+'CONDITION_DELEGATION_MISMATCH', 
+/** source: the record's type is not one the model declared it accepts for this condition. */
+'ATTESTATION_RECORD_TYPE_NOT_ACCEPTED', 
+/** source: no key resolved for the record's verification method at its own `attested_at`,
+ *  or the signature does not verify over the record's canonical bytes. */
+'ATTESTATION_SIGNATURE_UNVERIFIED', 
+/** source: the verification method does not belong to the attestor the body names, so a
+ *  valid signature says nothing about who attested. */
+'ATTESTATION_ATTESTOR_BINDING_MISMATCH', 
+/** source: the resolver does not know whether the attestor holds the role. Ignorance, and
+ *  deliberately not folded into a mismatch. */
+'ATTESTATION_ATTESTOR_ROLE_UNKNOWN', 
+/** source: the record claims a role the resolver says the attestor does not hold. */
+'ATTESTATION_ROLE_CLAIM_CONFLICT', 
+/** source: the attestor holds no role the condition requires. */
+'ATTESTATION_ATTESTOR_ROLE_MISMATCH', 
+/** source: the record's condition, event type or event id is not the condition's. */
+'ATTESTATION_CONDITION_MISMATCH', 
+/** source: the assertion is not one of the two this module defines, or the member that
+ *  assertion needs is absent. */
+'ATTESTATION_UNKNOWN_ASSERTION', 
+/** source: an instant on the record is not an RFC 3339 instant this module will compare. */
+'ATTESTATION_INSTANT_MALFORMED', 
+/** coverage: a `condition_not_occurred_through` record stops before the action instant, so
+ *  it says nothing about the interval between where it stops and the action. */
+'ATTESTATION_DOES_NOT_REACH_ACTION'];
+export type ActivationReasonCode = (typeof ACTIVATION_REASON_CODES)[number];
+/** Which establishment limb is missing when a reason code produces `not_established`.
+ *
+ *  `freshness` never appears. A freshness bound is model declared, this module is given none,
+ *  and the surface that owns multi-source status observation owns freshness. A mapping that
+ *  invented a freshness finding would be claiming something the verifier never measured. */
+export declare const ACTIVATION_GAPS_BY_REASON: Readonly<Partial<Record<ActivationReasonCode, readonly EstablishmentGap[]>>>;
+/** What `verifyActivation` concludes.
+ *
+ *  `state` is a `LifecycleStateResult` in the lifecycle-state vocabulary, so activation shares
+ *  one verdict set with every other proposed lifecycle surface instead of spelling a seventh
+ *  local copy of the same missing values. Only three of the six verdicts are reachable here:
+ *  `valid`, `not_yet_effective` and `not_established`. `invalid` is NEVER one of them. An
+ *  unmet activation condition does not make a grant invalid, and whether the grant is valid at
+ *  all is chain verification's answer, not this module's.
+ *
+ *  `findings` and `rejections` are the working, one entry per presented attestation across the
+ *  two, so a caller can report which record did what rather than only the verdict. */
+export interface ActivationResult {
+    readonly state: LifecycleStateResult;
+    readonly condition_id: string;
+    readonly condition_type: ActivationConditionKind;
+    readonly findings: readonly ActivationFinding[];
+    readonly rejections: readonly ActivationRejection[];
+}
+/** Thrown when a condition or a call is malformed. A shape rule broken at the call site is a
+ *  programming error, not a verdict, which is the same split `lifecycleState` makes. Evidence
+ *  problems are never thrown: they are verdicts. */
+export declare class ActivationError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/v2/activation/types.d.ts.map

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

package/dist/src/v2/activation/types.js

@@ -0,0 +1,198 @@
+// Copyright (c) 2026 Tymofii Pidlisnyi
+// SPDX-License-Identifier: Apache-2.0
+//
+// PROPOSED, OPT-IN. Activation conditions and condition attestation.
+//
+// NOT REQUIRED BY draft-pidlisnyi-aps-03. The published text states no activation-condition
+// rule, no attestor role and no attestation-acceptance rule: a case-insensitive search of
+// draft-pidlisnyi-aps-03 for `activation`, `attestor` and `contingen` returns nothing.
+// Draft-03 section 3.2 also states, verbatim: "authority contains exactly seven required
+// facets: scope, spend, depth, time, reputation, values, and reversibility. A missing facet
+// is invalid rather than an implicit unconstrained value." That closes the authority vector,
+// so an activation condition can never be a facet. It is a SEPARATE artifact that references
+// a `delegation_id`, which is what this module models.
+//
+// Concept source: the aeoess/agent-authority-lifecycle concept document
+// (AUTHORITY-LIFECYCLE.md, "Activation condition" under "Authority and dependencies", marked
+// proposed with no public case testing it) and invariant candidates CAND-04 (activation is
+// established, not yet effective, or not established), CAND-13 (replacement authority may be
+// pre-committed) and BROAD-L7 (any current lifecycle state claim is established only from an
+// accepted source, within a declared freshness bound, over the coverage the claim states).
+// All three are proposed. Nothing here claims otherwise.
+//
+// Additive and opt-in. `AuthorityValidationState`, `AuthorityValidationResult`,
+// `AuthorityVectorV1` and everything `verifyAuthorityDelegationChain` returns are unchanged.
+// A caller that never imports this module sees exactly today's behaviour.
+//
+// THREE THINGS THE CONCEPT TEXT DOES NOT DECIDE, and how this module refuses to decide them:
+//
+//   1. WHICH INSTANT an occurrence is measured from. A recorded-event condition carries
+//      `instant_basis` and there is no default. CAND-04 v2 reads it as the condition's own
+//      occurrence instant, and `attestation_written` exists so a model that reads it the
+//      other way has to say so in the record rather than inherit a choice this SDK made.
+//   2. HOW MANY acceptable attestations establish a condition. `threshold` is required and
+//      there is no default.
+//   3. WHO decides a condition. Role standing is resolved through a caller-supplied
+//      resolver and is never read off the attestation asserting it. An attestation's
+//      `attestor_role` member is the attestor's claim about itself, and this module checks
+//      that claim AGAINST the resolver rather than believing it.
+//
+// A fourth thing it does not decide is whether a waiting grant is `invalid` or
+// `not_yet_effective` when the wait is carried by the time facet rather than by an activation
+// condition. This module does not touch the time facet and `composeActivation` keeps the
+// chain verifier's own answer unless the caller opts out. See ./verify.ts.
+/** Record type of the activation condition this module owns. The `proposed:` prefix is
+ *  deliberate: the conformance suite's CONTRIBUTING.md reserves record fields, failure-class
+ *  names and verifier semantics to the schema owner, so nothing here is minted APS
+ *  vocabulary and nothing downstream should treat it as stable. */
+export const ACTIVATION_CONDITION_TYPE = 'proposed:aps:activation-condition:v0';
+/** Record type of the activation attestation this module owns. Same caveat as above.
+ *  A model may accept condition evidence in a shape this module does not own; see
+ *  `ActivationVerificationInput.attestationPreimage`. */
+export const ACTIVATION_ATTESTATION_TYPE = 'proposed:aps:activation-attestation:v0';
+/** The two kinds of activation condition the concept text names in one sentence: "A grant can
+ *  be validly issued and still wait on a date or a recorded event." They are answered by
+ *  different deciders, which is why they are separate members here rather than one shape with
+ *  optional fields. A date condition needs no evidence at all: the verifier reads the date. A
+ *  recorded-event condition needs evidence from a source the model accepts for it. */
+export const ACTIVATION_CONDITION_KINDS = ['date', 'recorded_event'];
+/** Which instant a `condition_occurred` attestation is measured against.
+ *
+ *  - `condition_occurrence`  the instant the condition itself is asserted to have occurred,
+ *                            from the record's `occurred_at`. This is CAND-04 v2's reading:
+ *                            "A condition that first occurred after an action does not make
+ *                            that action exercisable", which is a statement about the
+ *                            condition's own instant. Under it, a record written after an
+ *                            action can establish a condition that obtained before it, which
+ *                            is the normal case for any model built around an
+ *                            after-the-fact determination.
+ *  - `attestation_written`   the instant the record was written, from `attested_at`. A model
+ *                            that keys activation on when someone wrote the determination
+ *                            down rather than on when the condition occurred can say so
+ *                            here.
+ *
+ *  THERE IS NO DEFAULT. The concept text groups a date and a recorded event in one sentence
+ *  and says nothing about which instant either is measured from, and a default in an SDK is a
+ *  ruling made by whoever wrote the SDK. Both readings give opposite verdicts on a
+ *  deployment-relevant case (an occurrence before an action, attested after it), so the
+ *  condition has to state which one governs.
+ *
+ *  `instant_basis` does not apply to a `condition_not_occurred_through` record. That
+ *  assertion states the interval it covers, and the interval is what the coverage check
+ *  reads. Concept source: BROAD-L7's coverage limb. */
+export const ACTIVATION_INSTANT_BASES = ['condition_occurrence', 'attestation_written'];
+/** The two assertions an activation attestation can carry.
+ *
+ *  - `condition_occurred`             the event occurred, at `occurred_at`.
+ *  - `condition_not_occurred_through` the event had not occurred through
+ *                                     `not_occurred_through`. A NEGATIVE that is evidence,
+ *                                     not an absence of evidence, which is the distinction
+ *                                     between `not_yet_effective` and `not_established`.
+ *
+ *  An absence-triggered condition, where the trigger is that something did NOT happen within
+ *  a declared window, is NOT modelled here. CAND-04's own counterexample analysis names it as
+ *  the shape most likely to be implemented wrongly in the fail-closed direction, and this
+ *  module has no vocabulary for it. `resolveAttestorRole` returning `unknown` is what keeps
+ *  that case reachable for a later surface rather than silently answered here. */
+export const ACTIVATION_ASSERTIONS = [
+    'condition_occurred',
+    'condition_not_occurred_through',
+];
+/** What a resolver can say about whether an attestor holds a role at an instant.
+ *
+ *  THREE VALUES, NOT A BOOLEAN. "This registry does not know" is a distinct answer from "this
+ *  party does not hold that role", and collapsing the first into the second turns ignorance
+ *  into a denial. That collapse is the failure BROAD-L7 exists to name, and it is the reason
+ *  an absence-triggered condition needs `unknown` to stay reachable. */
+export const ATTESTOR_ROLE_STANDINGS = ['holds', 'does_not_hold', 'unknown'];
+/** What one accepted attestation establishes about the condition at the action instant.
+ *
+ *  - `occurred_by_action`          the condition's instant is at or before the action instant.
+ *  - `occurred_after_action`       the condition's instant is after it. The SAME record
+ *                                  establishes the condition for any later action, which is
+ *                                  what makes this a wait rather than a failure.
+ *  - `not_occurred_through_action` an accepted record states the condition had not occurred
+ *                                  through an instant that reaches the action instant. */
+export const ACTIVATION_FINDINGS = [
+    'occurred_by_action',
+    'occurred_after_action',
+    'not_occurred_through_action',
+];
+/** Every reason code this module emits, verdict-level and rejection-level.
+ *
+ *  Module-local and SCREAMING_SNAKE_CASE, per the lifecycle-state vocabulary's rule that two
+ *  findings sharing a verdict name must be told apart by their codes. Not minted APS
+ *  vocabulary. */
+export const ACTIVATION_REASON_CODES = [
+    // ── verdict-level ──
+    /** valid: an accepted record establishes the condition at or before the action instant, or
+     *  a date condition's date has been reached. */
+    'ACTIVATION_ESTABLISHED',
+    /** not_yet_effective: a date condition's activation date is after the action instant. */
+    'CONDITION_DATE_NOT_REACHED',
+    /** not_yet_effective: an accepted record states the condition had not occurred through an
+     *  instant reaching the action instant. */
+    'CONDITION_ESTABLISHED_NOT_YET_OCCURRED',
+    /** not_yet_effective: an accepted record puts the condition's first occurrence after the
+     *  action instant. No retroactive activation: the same record establishes the condition for
+     *  a later action, and never for this one. */
+    'CONDITION_FIRST_OCCURRED_AFTER_ACTION',
+    /** not_established, source: two accepted records disagree about the action instant. Neither
+     *  defeats the other and this module has no precedence rule. */
+    'CONDITION_EVIDENCE_CONFLICT',
+    /** not_established, source: accepted records exist but fewer than `threshold` of them
+     *  support the finding. */
+    'ACTIVATION_THRESHOLD_NOT_MET',
+    /** not_established, source: nothing was presented. */
+    'NO_ATTESTATION_PRESENTED',
+    /** not_established, coverage: the condition presented gates a different delegation. The
+     *  claim does not state that it covers what the verdict needed. */
+    'CONDITION_DELEGATION_MISMATCH',
+    // ── rejection-level, in check order ──
+    /** source: the record's type is not one the model declared it accepts for this condition. */
+    'ATTESTATION_RECORD_TYPE_NOT_ACCEPTED',
+    /** source: no key resolved for the record's verification method at its own `attested_at`,
+     *  or the signature does not verify over the record's canonical bytes. */
+    'ATTESTATION_SIGNATURE_UNVERIFIED',
+    /** source: the verification method does not belong to the attestor the body names, so a
+     *  valid signature says nothing about who attested. */
+    'ATTESTATION_ATTESTOR_BINDING_MISMATCH',
+    /** source: the resolver does not know whether the attestor holds the role. Ignorance, and
+     *  deliberately not folded into a mismatch. */
+    'ATTESTATION_ATTESTOR_ROLE_UNKNOWN',
+    /** source: the record claims a role the resolver says the attestor does not hold. */
+    'ATTESTATION_ROLE_CLAIM_CONFLICT',
+    /** source: the attestor holds no role the condition requires. */
+    'ATTESTATION_ATTESTOR_ROLE_MISMATCH',
+    /** source: the record's condition, event type or event id is not the condition's. */
+    'ATTESTATION_CONDITION_MISMATCH',
+    /** source: the assertion is not one of the two this module defines, or the member that
+     *  assertion needs is absent. */
+    'ATTESTATION_UNKNOWN_ASSERTION',
+    /** source: an instant on the record is not an RFC 3339 instant this module will compare. */
+    'ATTESTATION_INSTANT_MALFORMED',
+    /** coverage: a `condition_not_occurred_through` record stops before the action instant, so
+     *  it says nothing about the interval between where it stops and the action. */
+    'ATTESTATION_DOES_NOT_REACH_ACTION',
+];
+/** Which establishment limb is missing when a reason code produces `not_established`.
+ *
+ *  `freshness` never appears. A freshness bound is model declared, this module is given none,
+ *  and the surface that owns multi-source status observation owns freshness. A mapping that
+ *  invented a freshness finding would be claiming something the verifier never measured. */
+export const ACTIVATION_GAPS_BY_REASON = Object.freeze({
+    CONDITION_DELEGATION_MISMATCH: Object.freeze(['coverage']),
+    ATTESTATION_DOES_NOT_REACH_ACTION: Object.freeze(['coverage']),
+});
+/** Thrown when a condition or a call is malformed. A shape rule broken at the call site is a
+ *  programming error, not a verdict, which is the same split `lifecycleState` makes. Evidence
+ *  problems are never thrown: they are verdicts. */
+export class ActivationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'ActivationError';
+        this.code = code;
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/src/v2/activation/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/v2/activation/types.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,sCAAsC;AACtC,EAAE;AACF,qEAAqE;AACrE,EAAE;AACF,4FAA4F;AAC5F,0FAA0F;AAC1F,uFAAuF;AACvF,yFAAyF;AACzF,4FAA4F;AAC5F,6FAA6F;AAC7F,6FAA6F;AAC7F,uDAAuD;AACvD,EAAE;AACF,wEAAwE;AACxE,6FAA6F;AAC7F,2FAA2F;AAC3F,6FAA6F;AAC7F,6FAA6F;AAC7F,2FAA2F;AAC3F,yDAAyD;AACzD,EAAE;AACF,gFAAgF;AAChF,6FAA6F;AAC7F,0EAA0E;AAC1E,EAAE;AACF,6FAA6F;AAC7F,EAAE;AACF,wFAAwF;AACxF,2FAA2F;AAC3F,yFAAyF;AACzF,yFAAyF;AACzF,2FAA2F;AAC3F,4BAA4B;AAC5B,oFAAoF;AACpF,qFAAqF;AACrF,2FAA2F;AAC3F,iEAAiE;AACjE,EAAE;AACF,+EAA+E;AAC/E,8FAA8F;AAC9F,yFAAyF;AACzF,2EAA2E;AAI3E;;;mEAGmE;AACnE,MAAM,CAAC,MAAM,yBAAyB,GAAG,sCAA+C,CAAA;AAExF;;yDAEyD;AACzD,MAAM,CAAC,MAAM,2BAA2B,GAAG,wCAAiD,CAAA;AAE5F;;;;sFAIsF;AACtF,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAU,CAAA;AAI7E;;;;;;;;;;;;;;;;;;;;;;;uDAuBuD;AACvD,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,sBAAsB,EAAE,qBAAqB,CAAU,CAAA;AAIhG;;;;;;;;;;;;kFAYkF;AAClF,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,oBAAoB;IACpB,gCAAgC;CACxB,CAAA;AAuFV;;;;;wEAKwE;AACxE,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,OAAO,EAAE,eAAe,EAAE,SAAS,CAAU,CAAA;AAqBrF;;;;;;;0FAO0F;AAC1F,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,oBAAoB;IACpB,uBAAuB;IACvB,6BAA6B;CACrB,CAAA;AAqBV;;;;kBAIkB;AAClB,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,sBAAsB;IACtB;oDACgD;IAChD,wBAAwB;IACxB,yFAAyF;IACzF,4BAA4B;IAC5B;+CAC2C;IAC3C,wCAAwC;IACxC;;kDAE8C;IAC9C,uCAAuC;IACvC;oEACgE;IAChE,6BAA6B;IAC7B;+BAC2B;IAC3B,8BAA8B;IAC9B,sDAAsD;IACtD,0BAA0B;IAC1B;uEACmE;IACnE,+BAA+B;IAC/B,wCAAwC;IACxC,6FAA6F;IAC7F,sCAAsC;IACtC;8EAC0E;IAC1E,kCAAkC;IAClC;2DACuD;IACvD,uCAAuC;IACvC;mDAC+C;IAC/C,mCAAmC;IACnC,qFAAqF;IACrF,iCAAiC;IACjC,iEAAiE;IACjE,oCAAoC;IACpC,qFAAqF;IACrF,gCAAgC;IAChC;qCACiC;IACjC,+BAA+B;IAC/B,4FAA4F;IAC5F,+BAA+B;IAC/B;oFACgF;IAChF,mCAAmC;CAC3B,CAAA;AAIV;;;;4FAI4F;AAC5F,MAAM,CAAC,MAAM,yBAAyB,GAElC,MAAM,CAAC,MAAM,CAAC;IAChB,6BAA6B,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,UAAU,CAAU,CAAC;IACnE,iCAAiC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,UAAU,CAAU,CAAC;CACxE,CAAC,CAAA;AAqBF;;oDAEoD;AACpD,MAAM,OAAO,eAAgB,SAAQ,KAAK;IAC/B,IAAI,CAAQ;IAErB,YAAY,IAAY,EAAE,OAAe;QACvC,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAA;QAC7B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;CACF"}

package/dist/src/v2/activation/verify.d.ts

@@ -0,0 +1,132 @@
+import type { AuthorityValidationResult, VerificationKeyResolver } from '../authority-delegation/types.js';
+import type { LifecycleMappingOptions } from '../lifecycle-state/map.js';
+import type { CompositeAuthorityResult } from '../lifecycle-state/types.js';
+import { type ActivationAttestationV0, type ActivationConditionV0, type ActivationResult, type AttestorRoleResolver } from './types.js';
+export interface ActivationVerificationInput {
+    /** The condition gating the grant. Shape-checked; a malformed condition throws. */
+    readonly condition: ActivationConditionV0;
+    /** The `delegation_id` of the grant being evaluated. Checked against the condition's own
+     *  `delegation_id`, so a condition for another grant produces a verdict rather than being
+     *  silently applied to this one. */
+    readonly delegationId: string;
+    /** The instant the action is being authorized at. RFC 3339, offset required. */
+    readonly actionInstant: string;
+    /** Presented attestations, in presentation order. Absent or empty is the "nothing
+     *  presented" case, which is `not_established` and never `not_yet_effective`. */
+    readonly attestations?: readonly ActivationAttestationV0[];
+    /** Resolves whether an attestor held a role. Required even for a date condition, so a
+     *  caller cannot get a date answer and then discover the event path needs plumbing it does
+     *  not have. */
+    readonly resolveAttestorRole: AttestorRoleResolver;
+    /** Resolves the key that signed an attestation, selected at the attestation's own
+     *  `attested_at` rather than at verification time. Same resolver shape and the same
+     *  historical-key discipline draft-03 section 2.4 states for delegations: the key current at
+     *  verification time is not necessarily the one that signed this record. The `issuer`
+     *  argument receives the attestation's `attestor`. */
+    readonly resolveVerificationKey: VerificationKeyResolver;
+    /** Exact bytes a presented attestation's signature covers.
+     *
+     *  Absent is the normal case: the module uses its own domain-tagged preimage
+     *  (`activationAttestationSignatureInput`) and, because that preimage belongs to a record
+     *  type it owns, REQUIRES `record_type` to be `ACTIVATION_ATTESTATION_TYPE`.
+     *
+     *  Supplied is the escape hatch for a model that accepts condition evidence in a shape this
+     *  module does not own. Which bytes a signature covers is a property of a record type, and
+     *  an SDK cannot dictate the signing convention of a record type it did not define. A caller
+     *  using it must also declare `acceptedAttestationRecordTypes`, or the module has no stated
+     *  basis for accepting the record at all. */
+    readonly attestationPreimage?: (attestation: ActivationAttestationV0) => string;
+    /** Which attestation record types the model accepts as evidence for this condition.
+     *  Required when `attestationPreimage` is supplied. Membership is exact string equality. */
+    readonly acceptedAttestationRecordTypes?: readonly string[];
+}
+/** Shape rules, each with the reason it exists. A condition that breaks one is a programming
+ *  error at the caller, not a verdict about evidence, so this throws.
+ *
+ *  Exported so a caller can validate a condition it received before reaching a boundary. */
+export declare function validateActivationCondition(condition: ActivationConditionV0): ActivationConditionV0;
+/**
+ * Decide whether an activation condition is established for one action at one instant.
+ *
+ * Three verdicts are reachable and `invalid` is not one of them:
+ *
+ * | situation                                                    | verdict             |
+ * |--------------------------------------------------------------|---------------------|
+ * | condition established at or before the action instant         | `valid`             |
+ * | established as not met at that instant, or first met after it | `not_yet_effective` |
+ * | the verifier cannot tell                                      | `not_established`   |
+ *
+ * NOT ESTABLISHED IS NOT THE NEGATION OF THE CLAIM. It says the verifier could not reach a
+ * conclusion and names which establishment limb was missing. `not_yet_effective` says the
+ * verifier DID reach a conclusion and it was negative; its remedy is to wait, where
+ * `not_established`'s remedy is a better source. Collapsing the two throws away a decidable
+ * answer the verifier already had.
+ *
+ * NO RETROACTIVE ACTIVATION, KEYED ON THE CONDITION'S OWN INSTANT. A record putting the
+ * condition's first occurrence after the action instant leaves that action
+ * `not_yet_effective`, and the SAME record establishes the condition for any later action.
+ * What the rule keys on is the condition's instant, not the instant someone wrote the record:
+ * learning on Thursday that a condition was met on Monday is the normal case for any model
+ * built around an after-the-fact determination, and under
+ * `instant_basis: 'condition_occurrence'` such a record establishes the condition. A model
+ * that reads it the other way says so with `instant_basis: 'attestation_written'`.
+ *
+ * ORDER OF RESOLUTION, and why contradiction sits above acceptance:
+ *
+ *   1. two accepted records that disagree      `not_established`, `CONDITION_EVIDENCE_CONFLICT`
+ *   2. `threshold` records say occurred by it  `valid`
+ *   3. `threshold` records say not occurred    `not_yet_effective`
+ *   4. `threshold` records say occurred after  `not_yet_effective`
+ *   5. some accepted, fewer than `threshold`   `not_established`, `ACTIVATION_THRESHOLD_NOT_MET`
+ *   6. none accepted                           `not_established`, furthest rejection reason
+ *
+ * Contradiction is evaluated on PRESENCE, not on counts. Two acceptable records that disagree
+ * leave the verifier unable to tell which holds, and neither is discarded in favour of the
+ * other: preferring the later record, or the negative one, or a majority, would each be a
+ * precedence rule the concept text does not state.
+ *
+ * This function reads no clock and makes no network call. `actionInstant` is a parameter.
+ *
+ * Proposed. Concept source: aeoess/agent-authority-lifecycle, invariant candidates CAND-04
+ * and CAND-13 (activation half) and BROAD-L7. Not required by draft-pidlisnyi-aps-03.
+ */
+export declare function verifyActivation(input: ActivationVerificationInput): ActivationResult;
+export interface ActivationCompositionOptions {
+    /** Passed through to `mapAuthorityValidationToLifecycle` when the chain result is reported
+     *  in the lifecycle vocabulary.
+     *
+     *  The contested reading lives here and stays the CALLER's. Both reference SDKs answer
+     *  `invalid` with `NOT_YET_VALID` for a grant whose time facet `not_before` has not been
+     *  reached, and that is what the chain result says. An activation-condition date at the same
+     *  instant answers `not_yet_effective` here. One instant, two mechanisms carrying the wait,
+     *  two answers, and the concept text does not say whether a waiting grant should be
+     *  `invalid`, `not_yet_effective` or something else. This module does not settle it by
+     *  default: the default keeps the chain verifier's own answer, and
+     *  `notYetValidAsNotYetEffective: true` takes the other reading. */
+    readonly mapping?: LifecycleMappingOptions;
+}
+/**
+ * Report an activation result ALONGSIDE a chain result, never merged into it.
+ *
+ * Two stages, in order, and the order is the point:
+ *
+ *   1. Chain verification decides whether the grant is valid at the action instant. Its
+ *      four-value result is returned untouched in `chain`.
+ *   2. Activation is asked ONLY when the chain is valid. A grant that does not verify is not a
+ *      grant that is waiting on a condition, and reporting `not_yet_effective` for a revoked
+ *      or unparented grant would say the remedy is to wait when it is not.
+ *
+ * This is also where CAND-13's activation half lands. A pre-committed replacement grant is an
+ * ordinary grant with an ordinary condition, so it needs no separate machinery here, and the
+ * ordering is what keeps L1 intact: if the pre-committing instrument is revoked, the
+ * replacement's chain is invalid and no activation evidence can make it exercisable. Nothing
+ * in this module can turn an invalid chain into a `valid` lifecycle verdict.
+ *
+ * `activation` may be `null`, which is how a caller says no activation module ran. The
+ * composite then carries only the chain's own reading.
+ *
+ * Proposed. Concept source: aeoess/agent-authority-lifecycle, invariant L1 and invariant
+ * candidates CAND-04 and CAND-13.
+ */
+export declare function composeActivation(chain: AuthorityValidationResult, activation: ActivationResult | null, options?: ActivationCompositionOptions): CompositeAuthorityResult<AuthorityValidationResult>;
+//# sourceMappingURL=verify.d.ts.map

package/dist/src/v2/activation/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../../src/v2/activation/verify.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,yBAAyB,EACzB,uBAAuB,EACxB,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAA;AAGxE,OAAO,KAAK,EACV,wBAAwB,EAEzB,MAAM,6BAA6B,CAAA;AAEpC,OAAO,EAML,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAK1B,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EAE1B,MAAM,YAAY,CAAA;AA4BnB,MAAM,WAAW,2BAA2B;IAC1C,mFAAmF;IACnF,QAAQ,CAAC,SAAS,EAAE,qBAAqB,CAAA;IACzC;;wCAEoC;IACpC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,gFAAgF;IAChF,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B;qFACiF;IACjF,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,uBAAuB,EAAE,CAAA;IAC1D;;oBAEgB;IAChB,QAAQ,CAAC,mBAAmB,EAAE,oBAAoB,CAAA;IAClD;;;;0DAIsD;IACtD,QAAQ,CAAC,sBAAsB,EAAE,uBAAuB,CAAA;IACxD;;;;;;;;;;iDAU6C;IAC7C,QAAQ,CAAC,mBAAmB,CAAC,EAAE,CAAC,WAAW,EAAE,uBAAuB,KAAK,MAAM,CAAA;IAC/E;gGAC4F;IAC5F,QAAQ,CAAC,8BAA8B,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC5D;AAaD;;;4FAG4F;AAC5F,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,qBAAqB,GAC/B,qBAAqB,CAsEvB;AAkJD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,2BAA2B,GAAG,gBAAgB,CAgIrF;AAED,MAAM,WAAW,4BAA4B;IAC3C;;;;;;;;;;wEAUoE;IACpE,QAAQ,CAAC,OAAO,CAAC,EAAE,uBAAuB,CAAA;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,yBAAyB,EAChC,UAAU,EAAE,gBAAgB,GAAG,IAAI,EACnC,OAAO,GAAE,4BAAiC,GACzC,wBAAwB,CAAC,yBAAyB,CAAC,CAMrD"}