@nextera.one/axis-server-sdk 2.1.6 → 2.1.8

package/dist/index.d.mts

@@ -1,11 +1,15 @@
+import * as _nextera_one_axis_protocol from '@nextera.one/axis-protocol';
+import { AxisFrame as AxisFrame$2, PROOF_LOOM, TLV_LOOM_PRESENCE_ID, TLV_LOOM_THREAD_HASH, TLV_LOOM_WRIT } from '@nextera.one/axis-protocol';
+export { AXIS_MAGIC, AXIS_VERSION, AxisBinaryFrame, AxisFrame, TLV as AxisTlvType, BodyProfile, ERR_BAD_SIGNATURE, ERR_CONTRACT_VIOLATION, ERR_INVALID_PACKET, ERR_REPLAY_DETECTED, FLAG_BODY_TLV, FLAG_CHAIN_REQ, FLAG_HAS_WITNESS, MAX_BODY_LEN, MAX_FRAME_LEN, MAX_HDR_LEN, MAX_SIG_LEN, NCERT_ALG, NCERT_EXP, NCERT_ISSUER_KID, NCERT_KID, NCERT_NBF, NCERT_NODE_ID, NCERT_PAYLOAD, NCERT_PUB, NCERT_SCOPE, NCERT_SIG, PROOF_CAPSULE, PROOF_JWT, PROOF_LOOM, PROOF_MTLS, PROOF_NONE, PROOF_WITNESS, ProofType, TLV, TLV_ACTOR_ID, TLV_AUD, TLV_BODY_ARR, TLV_BODY_OBJ, TLV_CAPSULE, TLV_EFFECT, TLV_ERROR_CODE, TLV_ERROR_MSG, TLV_INDEX, TLV_INTENT, TLV_KID, TLV_LOOM_PRESENCE_ID, TLV_LOOM_THREAD_HASH, TLV_LOOM_WRIT, TLV_NODE, TLV_NODE_CERT_HASH, TLV_NODE_KID, TLV_NONCE, TLV_OFFSET, TLV_OK, TLV_PID, TLV_LOOM_PRESENCE_ID as TLV_PRESENCE_ID, TLV_PREV_HASH, TLV_PROOF_REF, TLV_PROOF_TYPE, TLV_REALM, TLV_RECEIPT_HASH, TLV_RID, TLV_SHA256_CHUNK, TLV_LOOM_THREAD_HASH as TLV_THREAD_HASH, TLV_TRACE_ID, TLV_TS, TLV_UPLOAD_ID, TLV_LOOM_WRIT as TLV_WRIT, decodeArray, decodeFrame, decodeObject, decodeTLVs, decodeTLVsList, decodeVarint, encodeFrame, encodeTLVs, encodeVarint, getSignTarget, varintLength } from '@nextera.one/axis-protocol';
 import * as z from 'zod';
-import { A as AxisFrame$2 } from './index-DXHfWxLG.mjs';
-export { a as AxisBinaryFrame, b as AxisError, c as AxisFrameZ, d as AxisMediaTypes, e as computeReceiptHash, f as computeSignaturePayload, i as core, g as decodeFrame, h as encodeFrame, j as generateEd25519KeyPair, k as getSignTarget, s as sha256, l as signFrame, v as verifyFrameSignature } from './index-DXHfWxLG.mjs';
 import { ModuleRef, DiscoveryService, Reflector, MetadataScanner } from '@nestjs/core';
-import { PROOF_LOOM, TLV_LOOM_PRESENCE_ID, TLV_LOOM_THREAD_HASH, TLV_LOOM_WRIT } from '@nextera.one/axis-protocol';
-export { AXIS_MAGIC, AXIS_VERSION, TLV as AxisTlvType, BodyProfile, ERR_BAD_SIGNATURE, ERR_CONTRACT_VIOLATION, ERR_INVALID_PACKET, ERR_REPLAY_DETECTED, FLAG_BODY_TLV, FLAG_CHAIN_REQ, FLAG_HAS_WITNESS, MAX_BODY_LEN, MAX_FRAME_LEN, MAX_HDR_LEN, MAX_SIG_LEN, NCERT_ALG, NCERT_EXP, NCERT_ISSUER_KID, NCERT_KID, NCERT_NBF, NCERT_NODE_ID, NCERT_PAYLOAD, NCERT_PUB, NCERT_SCOPE, NCERT_SIG, PROOF_CAPSULE, PROOF_JWT, PROOF_LOOM, PROOF_MTLS, PROOF_NONE, PROOF_WITNESS, ProofType, TLV, TLV_ACTOR_ID, TLV_AUD, TLV_BODY_ARR, TLV_BODY_OBJ, TLV_CAPSULE, TLV_EFFECT, TLV_ERROR_CODE, TLV_ERROR_MSG, TLV_INDEX, TLV_INTENT, TLV_KID, TLV_LOOM_PRESENCE_ID, TLV_LOOM_THREAD_HASH, TLV_LOOM_WRIT, TLV_NODE, TLV_NODE_CERT_HASH, TLV_NODE_KID, TLV_NONCE, TLV_OFFSET, TLV_OK, TLV_PID, TLV_LOOM_PRESENCE_ID as TLV_PRESENCE_ID, TLV_PREV_HASH, TLV_PROOF_REF, TLV_PROOF_TYPE, TLV_REALM, TLV_RECEIPT_HASH, TLV_RID, TLV_SHA256_CHUNK, TLV_LOOM_THREAD_HASH as TLV_THREAD_HASH, TLV_TRACE_ID, TLV_TS, TLV_UPLOAD_ID, TLV_LOOM_WRIT as TLV_WRIT, decodeArray, decodeObject, decodeTLVs, decodeTLVsList, decodeVarint, encodeTLVs, encodeVarint, varintLength } from '@nextera.one/axis-protocol';
-import { OnApplicationBootstrap, OnModuleInit } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
+export { A as AxisError, a as AxisFrameZ, c as computeReceiptHash, b as computeSignaturePayload, i as core, g as generateEd25519KeyPair, s as sha256, d as signFrame, v as verifyFrameSignature } from './index-VxXqZPuH.mjs';
+export { Axis1FrameToEncode, encodeAxis1Frame } from './codec/axis1.encode.mjs';
+export { axis1SigningBytes } from './codec/axis1.signing.mjs';
+import { Axis1DecodedFrame } from './types/frame.mjs';
+export { decodeAxis1Frame } from './types/frame.mjs';
+import { OnApplicationBootstrap, OnModuleInit } from '@nestjs/common';
 
 type AxisExecutionMode = 'strict' | 'parallel' | 'best_effort' | 'atomic';
 type AxisObserverEvent = 'intent.received' | 'intent.completed' | 'intent.failed' | 'chain.received' | 'chain.admitted' | 'chain.completed' | 'chain.failed' | 'chain.partial' | 'step.started' | 'step.completed' | 'step.failed' | 'step.blocked' | 'step.skipped' | 'signature.verified' | 'decryption.succeeded' | 'sensor.passed' | 'sensor.failed' | 'handler.completed' | 'proof.recorded';
@@ -265,12 +269,7 @@ declare const IntentPolicyZ: z.ZodObject<{
 }, z.z.core.$strip>;
 type IntentPolicy = z.infer<typeof IntentPolicyZ>;
 declare const IntentPolicySensorInputZ: z.ZodObject<{
-    frame: z.ZodObject<{
-        flags: z.ZodNumber;
-        headers: z.ZodMap<z.ZodNumber, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
-        body: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
-        sig: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
-    }, z.z.core.$strip>;
+    frame: z.ZodType<_nextera_one_axis_protocol.AxisFrame, unknown, z.z.core.$ZodTypeInternals<_nextera_one_axis_protocol.AxisFrame, unknown>>;
     intent: z.ZodString;
     rawFrameSize: z.ZodNumber;
 }, z.z.core.$strip>;
@@ -529,7 +528,7 @@ declare const IntentSchemaZ: z.ZodObject<{
         }>>;
     }, z.z.core.$strip>>;
 }, z.z.core.$strip>;
-type IntentSchema$1 = z.infer<typeof IntentSchemaZ>;
+type IntentSchema$2 = z.infer<typeof IntentSchemaZ>;
 declare const WsHandshakeInputZ: z.ZodObject<{
     clientId: z.ZodString;
     isWs: z.ZodBoolean;
@@ -683,6 +682,10 @@ declare function Handler(intent?: string): ClassDecorator;
 declare const INTENT_METADATA_KEY = "axis:intent";
 declare const INTENT_ROUTES_KEY = "axis:intent_routes";
 type IntentKind = 'create' | 'read' | 'update' | 'delete' | 'action';
+type AxisIntentSensorRef = string | Function;
+interface AxisIntentSensorOptions {
+    is?: AxisIntentSensorRef[];
+}
 interface IntentTlvField {
     name: string;
     tag: number;
@@ -692,19 +695,21 @@ interface IntentTlvField {
     max?: string;
     scope?: 'header' | 'body';
 }
-interface IntentRoute {
+interface IntentRoute extends AxisIntentSensorOptions {
     action: string;
     methodName: string | symbol;
     absolute?: boolean;
     frame?: boolean;
     kind?: IntentKind;
+    sensitivity?: SensitivityLevel;
     chain?: boolean | ChainOptions;
     bodyProfile?: 'TLV_MAP' | 'RAW' | 'TLV_OBJ' | 'TLV_ARR';
     tlv?: IntentTlvField[];
     dto?: Function;
 }
-interface IntentOptions {
+interface IntentOptions extends AxisIntentSensorOptions {
     kind?: IntentKind;
+    sensitivity?: SensitivityLevel;
     absolute?: boolean;
     frame?: boolean;
     chain?: boolean | ChainOptions;
@@ -718,7 +723,7 @@ declare const INTENT_BODY_KEY = "axis:intent:body";
 declare function IntentBody(decoder: (buf: Buffer) => any): MethodDecorator;
 
 declare const INTENT_SENSORS_KEY = "axis:intent:sensors";
-declare function IntentSensors(sensors: Function[]): MethodDecorator;
+declare function IntentSensors(sensors: AxisIntentSensorRef[]): MethodDecorator;
 
 declare const OBSERVER_METADATA_KEY = "axis:observer";
 declare const OBSERVER_BINDINGS_KEY = "axis:observer:bindings";
@@ -743,7 +748,7 @@ interface AxisObserverBindingOptions {
 declare function Observer(input?: AxisObserverDefinition | AxisObserverBindingOptions | AxisObserverRef | AxisObserverRef[]): ClassDecorator & MethodDecorator;
 
 declare const HANDLER_SENSORS_KEY = "axis:handler:sensors";
-declare function HandlerSensors(sensors: Function[]): ClassDecorator;
+declare function HandlerSensors(sensors: AxisIntentSensorRef[]): ClassDecorator;
 
 declare const SENSOR_METADATA_KEY = "axis:sensor";
 type SensorPhase = 'PRE_DECODE' | 'POST_DECODE';
@@ -1404,7 +1409,30 @@ type CcePipelineResult = {
 };
 declare function executeCcePipeline(envelope: CceRequestEnvelope, config: CcePipelineConfig): Promise<CcePipelineResult>;
 
-interface IntentSchema {
+declare class SensorRegistry {
+    private readonly configService;
+    private sensors;
+    private sensorsByName;
+    private sensorsByType;
+    private readonly logger;
+    constructor(configService: ConfigService);
+    register(sensor: AxisSensor): void;
+    list(): AxisSensor[];
+    resolve(ref: AxisIntentSensorRef): AxisSensor | undefined;
+    getByName(name: string): AxisSensor | undefined;
+    getPreDecodeSensors(): AxisPreSensor[];
+    getPostDecodeSensors(): AxisPostSensor[];
+    private isPreDecodeSensor;
+    private isPostDecodeSensor;
+    getSensorCountByPhase(): {
+        preDecodeCount: number;
+        postDecodeCount: number;
+    };
+    clear(): void;
+    private indexSensor;
+}
+
+interface IntentSchema$1 {
     intent: string;
     version: number;
     bodyProfile: "TLV_MAP" | "RAW" | "TLV_OBJ" | "TLV_ARR";
@@ -1428,6 +1456,7 @@ interface AxisEffect {
 declare class IntentRouter {
     private readonly moduleRef?;
     private readonly observerDispatcher?;
+    private readonly sensorRegistry?;
     private readonly logger;
     private readonly decoder;
     private readonly encoder;
@@ -1449,13 +1478,13 @@ declare class IntentRouter {
     private intentRateLimits;
     private cceHandlers;
     private ccePipelineConfig;
-    constructor(moduleRef?: ModuleRef | undefined, observerDispatcher?: ObserverDispatcherService | undefined);
-    getSchema(intent: string): IntentSchema | undefined;
+    constructor(moduleRef?: ModuleRef | undefined, observerDispatcher?: ObserverDispatcherService | undefined, sensorRegistry?: SensorRegistry | undefined);
+    getSchema(intent: string): IntentSchema$1 | undefined;
     getValidators(intent: string): Map<number, TlvValidatorFn[]> | undefined;
     has(intent: string): boolean;
     getRegisteredIntents(): string[];
     getIntentEntry(intent: string): {
-        schema?: IntentSchema;
+        schema?: IntentSchema$1;
         validators?: Map<number, TlvValidatorFn[]>;
         hasSensors: boolean;
         builtin: boolean;
@@ -1470,8 +1499,8 @@ declare class IntentRouter {
     registerHandler(instance: any): void;
     route(frame: AxisFrame$2): Promise<AxisEffect>;
     private logIntent;
-    registerIntentMeta(intent: string, proto: object, methodName: string, handlerSensors?: Function[], handlerObservers?: AxisObserverBinding[]): void;
-    getSensitivity(intent: string): string | undefined;
+    registerIntentMeta(intent: string, proto: object, methodName: string, handlerSensors?: AxisIntentSensorRef[], handlerObservers?: AxisObserverBinding[]): void;
+    getSensitivity(intent: string): SensitivityLevel | undefined;
     getContract(intent: string): Record<string, any> | undefined;
     getRequiredProof(intent: string): RequiredProofKind[] | undefined;
     isPublic(intent: string): boolean;
@@ -1479,6 +1508,7 @@ declare class IntentRouter {
     getRateLimit(intent: string): AxisRateLimitConfig | undefined;
     private emitIntentObservers;
     private runIntentSensors;
+    private resolveIntentSensor;
     private getEffectiveCapsulePolicy;
     private enforceCapsulePolicy;
     private executeChainRequest;
@@ -1700,6 +1730,42 @@ declare function canonicalizeObservation(obs: AxisObservation): string;
 declare function hashObservation(obs: AxisObservation): string;
 declare function buildUnsignedWitness(obs: AxisObservation): UnsignedObservationWitness | null;
 
+type TruthStatus = 'confirmed' | 'partial' | 'uncertain' | 'failed' | 'disputed';
+interface ExpectedOutcome {
+    decision?: 'ALLOW' | 'DENY';
+    effect?: string;
+    statusCode?: number;
+    ok?: boolean;
+    stateChanges?: Record<string, unknown>;
+    maxDurationMs?: number;
+    minSensorsPassed?: number;
+    assertions?: Record<string, unknown>;
+}
+type AnomalyLevel = 'info' | 'warning' | 'critical';
+interface Anomaly {
+    code: string;
+    level: AnomalyLevel;
+    message: string;
+    field?: string;
+    expected?: unknown;
+    actual?: unknown;
+}
+interface TruthVerdict {
+    status: TruthStatus;
+    confidence: number;
+    anomalies: Anomaly[];
+    passedChecks: number;
+    totalChecks: number;
+    verifiedAt: number;
+    isDeed: boolean;
+}
+declare function scoreTruth(obs: AxisObservation, expected?: ExpectedOutcome): TruthVerdict;
+interface ObservedDeed {
+    observation: AxisObservation;
+    verdict: TruthVerdict;
+}
+declare function verifyObservation(obs: AxisObservation, expected?: ExpectedOutcome): ObservedDeed;
+
 interface ResponseObserverContext {
     actorId: string;
     intent: string;
@@ -1719,6 +1785,15 @@ declare function verifyResponse(ctx: ResponseObserverContext, response: Response
 type ResponseObserver = (ctx: ResponseObserverContext, response: ResponseContract) => ObserverVerdict;
 declare const ResponseObserver: ResponseObserver;
 
+declare abstract class AxisMediaTypes {
+    static readonly BINARY = "application/axis-bin";
+    static readonly OCTET_STREAM = "application/octet-stream";
+    static readonly LEGACY_BINARY = "application/x-axis";
+    static readonly VALID_AXIS_CONTENT_TYPES: readonly ["application/axis-bin", "application/octet-stream", "application/x-axis"];
+    static normalize(value?: string | null): string | undefined;
+    static isAxisContentType(value?: string | null): boolean;
+}
+
 declare const ATS1_HDR: {
     readonly INTENT_ID: 1;
     readonly ACTOR_KEY_ID: 2;
@@ -1955,22 +2030,6 @@ declare function packPasskeyLoginVerifyRes(params: {
     expiresAt: bigint;
 }): Buffer;
 
-type Axis1FrameToEncode = {
-    ver: number;
-    flags: number;
-    hdr: Buffer;
-    body: Buffer;
-    sig: Buffer;
-};
-declare function encodeAxis1Frame(f: Axis1FrameToEncode): Buffer;
-
-declare function axis1SigningBytes(params: {
-    ver: number;
-    flags: number;
-    hdr: Buffer;
-    body: Buffer;
-}): Buffer;
-
 declare function encVarint(x: bigint): Buffer;
 declare function varintU(x: number | bigint): Buffer;
 declare function u64be(x: bigint): Buffer;
@@ -2019,16 +2078,6 @@ declare class ExecutionMeter {
     getContract(): any;
 }
 
-type Axis1DecodedFrame = {
-    ver: number;
-    flags: number;
-    hdr: Buffer;
-    body: Buffer;
-    sig: Buffer;
-    frameSize: number;
-};
-declare function decodeAxis1Frame(buf: Buffer): Axis1DecodedFrame;
-
 declare const T: {
     INTENT: number;
     PID: number;
@@ -2094,6 +2143,46 @@ type Capability = keyof typeof CAPABILITIES;
 declare const PROOF_CAPABILITIES: Record<number, Capability[]>;
 declare const INTENT_REQUIREMENTS: Record<string, Capability[]>;
 
+type AxisLawDecision = "allow" | "deny" | "conditional";
+interface AxisLawArticleSummary {
+    article_id: string;
+    article_type?: string;
+    decision?: string;
+    reason?: string;
+}
+interface AxisLawEvaluationContext {
+    actorId?: string;
+    intent?: string;
+    audience?: string;
+    tps?: string | number;
+    country?: string;
+    ip?: string;
+    path?: string;
+    clientId?: string;
+    deviceId?: string;
+    sessionId?: string;
+    capsuleId?: string;
+    metadata: Record<string, unknown>;
+    packet?: Record<string, unknown>;
+    frameBody?: unknown;
+}
+interface AxisLawEvaluationResult {
+    decision: AxisLawDecision;
+    reason: string;
+    explanation?: string;
+    denied?: AxisLawArticleSummary[];
+    permitted?: AxisLawArticleSummary[];
+    required?: AxisLawArticleSummary[];
+    applicable?: AxisLawArticleSummary[];
+    metadata?: Record<string, unknown>;
+}
+type AxisLawEvaluator = ((context: AxisLawEvaluationContext) => AxisLawEvaluationResult | Promise<AxisLawEvaluationResult>);
+interface LawEvaluationSensorOptions {
+    evaluator?: AxisLawEvaluator;
+    conditionalDecision?: "deny" | "flag" | "allow";
+}
+declare function buildAxisLawEvaluationContext(input: SensorInput): AxisLawEvaluationContext;
+
 interface RiskSignal {
     type: string;
     severity: 'low' | 'medium' | 'high' | 'critical';
@@ -2263,24 +2352,6 @@ declare class HandlerDiscoveryService implements OnModuleInit {
     onModuleInit(): void;
 }
 
-declare class SensorRegistry {
-    private readonly configService;
-    private sensors;
-    private readonly logger;
-    constructor(configService: ConfigService);
-    register(sensor: AxisSensor): void;
-    list(): AxisSensor[];
-    getPreDecodeSensors(): AxisPreSensor[];
-    getPostDecodeSensors(): AxisPostSensor[];
-    private isPreDecodeSensor;
-    private isPostDecodeSensor;
-    getSensorCountByPhase(): {
-        preDecodeCount: number;
-        postDecodeCount: number;
-    };
-    clear(): void;
-}
-
 declare class SensorDiscoveryService implements OnApplicationBootstrap {
     private readonly discovery;
     private readonly reflector;
@@ -2320,6 +2391,180 @@ declare class AxisSensorChainService {
     private evaluateSensors;
 }
 
+type TimelineDomain = 'prime' | 'fork' | 'shadow' | 'training' | 'audit';
+type TimelineEventStatus = 'executed' | 'replayed' | 'forked' | 'simulated' | 'failed';
+interface TimelineEvent {
+    event_id: string;
+    timeline_id: string;
+    branch_id: string;
+    parent_event_id: string | null;
+    intent: string;
+    actor_id: string;
+    capsule_id?: string;
+    tps_coordinate?: string;
+    payload_hash: string;
+    result_hash?: string;
+    status: TimelineEventStatus;
+    domain: TimelineDomain;
+    determinism: 'deterministic' | 'bounded_nondeterministic' | 'open_nondeterministic';
+    witness_id?: string;
+    created_at: number;
+    metadata?: Record<string, unknown>;
+}
+interface TimelineBranch {
+    branch_id: string;
+    timeline_id: string;
+    origin_timeline_id: string;
+    origin_event_id: string;
+    branch_type: 'fork' | 'simulation' | 'replay' | 'training';
+    created_at_tps?: string;
+    creator_subject_id: string;
+    purpose: string;
+    status: 'active' | 'completed' | 'abandoned';
+}
+interface StateSnapshot {
+    snapshot_id: string;
+    timeline_id: string;
+    event_id: string;
+    tps_coordinate?: string;
+    state_hash: string;
+    state_data: Record<string, unknown>;
+    created_at: number;
+}
+type ReplayMode = 'strict' | 'analytical';
+interface ReplayRequest {
+    source_event_id: string;
+    mode: ReplayMode;
+    override_payload?: Record<string, unknown>;
+}
+interface ReplayResult {
+    original_event: TimelineEvent;
+    replayed_event: TimelineEvent;
+    mode: ReplayMode;
+    deterministic_match: boolean;
+    differences: ReplayDifference[];
+    duration_ms: number;
+}
+interface ReplayDifference {
+    field: string;
+    original: unknown;
+    replayed: unknown;
+}
+interface ForkRequest {
+    source_event_id: string;
+    new_payload: Record<string, unknown>;
+    purpose: string;
+    actor_id: string;
+}
+interface ForkResult {
+    branch: TimelineBranch;
+    forked_event: TimelineEvent;
+    snapshot?: StateSnapshot;
+}
+interface SimulationRequest {
+    intent: string;
+    payload: Record<string, unknown>;
+    actor_id: string;
+    at_tps?: string;
+    from_snapshot_id?: string;
+    purpose: string;
+}
+interface SimulationResult {
+    branch: TimelineBranch;
+    simulated_event: TimelineEvent;
+    predicted_outcome: Record<string, unknown>;
+    side_effects: SimulatedSideEffect[];
+    duration_ms: number;
+}
+interface SimulatedSideEffect {
+    type: string;
+    target: string;
+    action: string;
+    predicted_result: unknown;
+}
+interface TimelineComparison {
+    timeline_a: string;
+    timeline_b: string;
+    event_pairs: Array<{
+        event_a: TimelineEvent;
+        event_b: TimelineEvent;
+        match: boolean;
+        differences: ReplayDifference[];
+    }>;
+    divergence_point?: string;
+}
+interface TimelineHandler {
+    intent: string;
+    execute(payload: Record<string, unknown>, context: TimelineHandlerContext): Promise<TimelineHandlerResult>;
+}
+interface TimelineHandlerContext {
+    event_id: string;
+    timeline_id: string;
+    branch_id: string;
+    domain: TimelineDomain;
+    actor_id: string;
+    tps_coordinate?: string;
+    snapshot?: StateSnapshot;
+    is_replay: boolean;
+    is_simulation: boolean;
+}
+interface TimelineHandlerResult {
+    ok: boolean;
+    effect: string;
+    result_data: Record<string, unknown>;
+    side_effects?: SimulatedSideEffect[];
+}
+
+interface TimelineStore {
+    saveEvent(event: TimelineEvent): Promise<void>;
+    getEvent(eventId: string): Promise<TimelineEvent | null>;
+    getEventsByTimeline(timelineId: string): Promise<TimelineEvent[]>;
+    getEventsByBranch(branchId: string): Promise<TimelineEvent[]>;
+    saveBranch(branch: TimelineBranch): Promise<void>;
+    getBranch(branchId: string): Promise<TimelineBranch | null>;
+    getBranchesByTimeline(timelineId: string): Promise<TimelineBranch[]>;
+    saveSnapshot(snapshot: StateSnapshot): Promise<void>;
+    getSnapshot(snapshotId: string): Promise<StateSnapshot | null>;
+    getSnapshotByEvent(eventId: string): Promise<StateSnapshot | null>;
+}
+declare class InMemoryTimelineStore implements TimelineStore {
+    private events;
+    private branches;
+    private snapshots;
+    saveEvent(event: TimelineEvent): Promise<void>;
+    getEvent(eventId: string): Promise<TimelineEvent | null>;
+    getEventsByTimeline(timelineId: string): Promise<TimelineEvent[]>;
+    getEventsByBranch(branchId: string): Promise<TimelineEvent[]>;
+    saveBranch(branch: TimelineBranch): Promise<void>;
+    getBranch(branchId: string): Promise<TimelineBranch | null>;
+    getBranchesByTimeline(timelineId: string): Promise<TimelineBranch[]>;
+    saveSnapshot(snapshot: StateSnapshot): Promise<void>;
+    getSnapshot(snapshotId: string): Promise<StateSnapshot | null>;
+    getSnapshotByEvent(eventId: string): Promise<StateSnapshot | null>;
+}
+
+declare class TimelineEngine {
+    private readonly store;
+    private handlers;
+    constructor(store: TimelineStore);
+    registerHandler(handler: TimelineHandler): void;
+    recordEvent(intent: string, actorId: string, payload: Record<string, unknown>, result: Record<string, unknown>, options?: {
+        timelineId?: string;
+        branchId?: string;
+        capsuleId?: string;
+        tpsCoordinate?: string;
+        witnessId?: string;
+        determinism?: TimelineEvent['determinism'];
+        parentEventId?: string;
+    }): Promise<TimelineEvent>;
+    replay(request: ReplayRequest): Promise<ReplayResult>;
+    fork(request: ForkRequest): Promise<ForkResult>;
+    simulate(request: SimulationRequest): Promise<SimulationResult>;
+    compare(timelineIdA: string, timelineIdB: string): Promise<TimelineComparison>;
+    createSnapshot(eventId: string, stateData: Record<string, unknown>): Promise<StateSnapshot>;
+    restoreSnapshot(snapshotId: string): Promise<StateSnapshot>;
+}
+
 type AxisTlvDtoCtor<T = object> = new (...args: never[]) => T;
 declare function encodeAxisTlvDto<T extends object>(dtoClass: AxisTlvDtoCtor<T>, data: Partial<Record<keyof T, unknown>>): Uint8Array;
 
@@ -2458,6 +2703,489 @@ declare function deriveAnchorReflection(softid: string, context?: string, scope?
 declare function canonicalizeWrit(writ: Omit<Writ, 'sig'>): string;
 declare function canonicalizeGrant(grant: Omit<Grant, 'sig'>): string;
 
+declare function createPresenceChallenge(declaration: PresenceDeclaration, ttlMs?: number): PresenceChallenge;
+declare function signPresenceChallenge(challenge: PresenceChallenge, privateKeyHex: string, publicKeyHex: string, declaration: PresenceDeclaration, kid?: string): PresenceProof;
+declare function verifyPresenceProof(challenge: PresenceChallenge, proof: PresenceProof, declaration: PresenceDeclaration, durationMs?: number): PresenceVerifyResult;
+declare function getPresenceStatus(receipt: PresenceReceipt): PresenceStatus;
+declare function renewPresence(receipt: PresenceReceipt, extensionMs?: number): PresenceReceipt;
+declare function createWrit(body: WritBody, meta: Omit<WritMeta, 'prev'>, thread: {
+    tid: string;
+    seq: number;
+    prevHash: string;
+}, privateKeyHex: string, kid?: string): Writ;
+declare function validateWrit(writ: Writ, publicKeyHex: string, threadState: ThreadState | null, grants: Grant[]): WritValidationResult;
+declare function grantCoversAction(grant: Grant, action: string, resource: string, nowUnix: number): boolean;
+declare function getGrantStatus(grant: Grant, revocations: Revocation[]): GrantStatus;
+declare function validateGrant(grant: Grant, issuerPublicKeyHex: string): GrantValidationResult;
+declare function createGrant(grantId: string, issuer: string, subject: string, grantType: Grant['grant_type'], caps: GrantCapability[], meta: Grant['meta'], privateKeyHex: string, kid?: string): Grant;
+declare function createReceipt(writ: Writ, effect: string, prevReceipt: LoomReceipt | null, metadata?: Record<string, unknown>): LoomReceipt;
+declare function verifyReceiptChain(receipts: LoomReceipt[]): {
+    valid: boolean;
+    brokenAt?: number;
+    error?: string;
+};
+declare function updateThreadState(receipt: LoomReceipt, softid: string): ThreadState;
+declare function createRevocation(targetType: Revocation['target_type'], targetId: string, issuerSoftid: string, privateKeyHex: string, reason?: string): Revocation;
+declare function isRevoked(targetType: Revocation['target_type'], targetId: string, revocations: Revocation[]): boolean;
+interface LoomExecutionResult {
+    receipt: LoomReceipt;
+    threadState: ThreadState;
+    writValidation: WritValidationResult;
+}
+declare function executeLoomPipeline(writ: Writ, publicKeyHex: string, presence: PresenceReceipt, threadState: ThreadState | null, grants: Grant[], revocations: Revocation[], prevReceipt: LoomReceipt | null): LoomExecutionResult | {
+    valid: false;
+    error: string;
+    code: string;
+};
+
+interface IntentProposal {
+    raw: string;
+    actor_id: string;
+    target?: string;
+    params?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+}
+interface CompiledIntent {
+    intent: string;
+    actor_id: string;
+    target?: string;
+    params: Record<string, unknown>;
+    constraints: IntentConstraint[];
+    confidence: number;
+    alternatives: AlternativeIntent[];
+    needs_clarification: boolean;
+    clarifications: ClarificationQuestion[];
+    expected_outcome?: string;
+    fallback?: string;
+    risk: IntentRisk;
+    metadata: Record<string, unknown>;
+}
+type ConstraintKind = 'required_param' | 'type_check' | 'range' | 'pattern' | 'temporal' | 'spatial' | 'authority' | 'safety' | 'custom';
+interface IntentConstraint {
+    kind: ConstraintKind;
+    field: string;
+    description: string;
+    satisfied: boolean;
+    value?: unknown;
+    expected?: unknown;
+}
+interface AlternativeIntent {
+    intent: string;
+    confidence: number;
+    reason: string;
+}
+interface ClarificationQuestion {
+    id: string;
+    question: string;
+    field: string;
+    options?: string[];
+    required: boolean;
+}
+type RiskLevel = 'none' | 'low' | 'medium' | 'high' | 'critical';
+interface IntentRisk {
+    level: RiskLevel;
+    score: number;
+    factors: string[];
+}
+interface IntentParamSchema {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    required: boolean;
+    description?: string;
+    default?: unknown;
+    pattern?: string;
+    min?: number;
+    max?: number;
+    enum?: unknown[];
+}
+interface IntentSchema {
+    intent: string;
+    description: string;
+    params: IntentParamSchema[];
+    required_scopes?: string[];
+    risk_level: RiskLevel;
+    has_side_effects: boolean;
+    reversible: boolean;
+    related?: string[];
+    tags?: string[];
+}
+interface CompilationResult {
+    ok: boolean;
+    compiled?: CompiledIntent;
+    errors: CompilationError[];
+}
+interface CompilationError {
+    code: string;
+    message: string;
+    field?: string;
+}
+
+declare class IdelSchemaRegistry {
+    private schemas;
+    private aliases;
+    register(schema: IntentSchema): void;
+    registerAlias(alias: string, intent: string): void;
+    get(intent: string): IntentSchema | undefined;
+    resolve(raw: string): IntentSchema | undefined;
+    findCandidates(raw: string): Array<{
+        schema: IntentSchema;
+        score: number;
+    }>;
+    list(): IntentSchema[];
+}
+declare class IdelCompiler {
+    private readonly registry;
+    constructor(registry: IdelSchemaRegistry);
+    compile(proposal: IntentProposal): CompilationResult;
+    applyClarifications(compiled: CompiledIntent, answers: Record<string, unknown>): CompilationResult;
+}
+
+type NeedlePhase = 'created' | 'validated' | 'executing' | 'observed' | 'stitched' | 'failed';
+interface Needle {
+    needle_id: string;
+    phase: NeedlePhase;
+    tps_coordinate?: string;
+    intent: CompiledIntent;
+    presence: PresenceReceipt;
+    writ: Writ;
+    grants: Grant[];
+    observation?: AxisObservation;
+    receipt?: LoomReceipt;
+    verdict?: TruthVerdict;
+    created_at: number;
+    completed_at?: number;
+    error?: NeedleError;
+}
+interface NeedleError {
+    phase: NeedlePhase;
+    code: string;
+    message: string;
+}
+type StitchKind = 'deed' | 'silent' | 'torn';
+interface Stitch {
+    stitch_id: string;
+    kind: StitchKind;
+    intent: string;
+    actor_id: string;
+    tps_coordinate?: string;
+    observation: AxisObservation;
+    verdict: TruthVerdict;
+    receipt: LoomReceipt;
+    thread_id: string;
+    sequence: number;
+    timeline_event_id?: string;
+    stitched_at: number;
+}
+interface Thread {
+    state: ThreadState;
+    length: number;
+    started_at_tps?: string;
+    last_stitch_tps?: string;
+    has_branches: boolean;
+    branch_ids: string[];
+}
+
+type NeedleHandler = (intent: CompiledIntent, context: NeedleHandlerContext) => Promise<NeedleHandlerResult>;
+interface NeedleHandlerContext {
+    needle_id: string;
+    actor_id: string;
+    presence_id: string;
+    writ: Writ;
+    grants: Grant[];
+    tps_coordinate?: string;
+}
+interface NeedleHandlerResult {
+    ok: boolean;
+    effect: string;
+    data?: Record<string, unknown>;
+    status_code?: number;
+}
+interface NeedlePipelineConfig {
+    handlers: Map<string, NeedleHandler>;
+    private_key: string;
+    public_key: string;
+    sensors?: AxisSensor[];
+    record_timeline?: boolean;
+    tps_provider?: () => string;
+}
+interface NeedlePipelineResult {
+    ok: boolean;
+    needle: Needle;
+    stitch?: Stitch;
+    thread_state?: ThreadState;
+    timeline_event?: TimelineEvent;
+}
+
+declare function assembleNeedle(params: {
+    intent: CompiledIntent;
+    presence: PresenceReceipt;
+    writ: Writ;
+    grants: Grant[];
+    tps_coordinate?: string;
+}): Needle;
+declare function formStitch(needle: Needle, observation: AxisObservation, verdict: TruthVerdict, receipt: LoomReceipt): Stitch;
+declare function runNeedlePipeline(needle: Needle, config: NeedlePipelineConfig, threadState: ThreadState | null, prevReceipt: LoomReceipt | null, expectedOutcome?: ExpectedOutcome): Promise<NeedlePipelineResult>;
+
+type KnotType = 'authority' | 'law' | 'causal' | 'decision' | 'irreversible';
+type KnotStatus = 'open' | 'tied' | 'broken' | 'forked';
+interface Knot {
+    knot_id: string;
+    type: KnotType;
+    status: KnotStatus;
+    stitch_ids: string[];
+    thread_id: string;
+    tps_anchor?: string;
+    irreversible: boolean;
+    capsule_id?: string;
+    law_ref?: string;
+    decision_stitch_id?: string;
+    branch_ids: string[];
+    required_count?: number;
+    all_or_nothing: boolean;
+    actor_id: string;
+    created_at: number;
+    tied_at?: number;
+    broken_at?: number;
+    break_reason?: string;
+    witness_hash?: string;
+}
+interface KnotValidationResult {
+    valid: boolean;
+    passed_stitch_ids: string[];
+    failed_stitch_ids: string[];
+    can_tie: boolean;
+    errors: KnotError[];
+}
+interface KnotError {
+    code: string;
+    message: string;
+    stitch_id?: string;
+}
+interface KnotBreakRequest {
+    knot_id: string;
+    actor_id: string;
+    reason: string;
+    override_grant_id?: string;
+    signature?: string;
+}
+
+interface OpenKnotParams {
+    type: KnotType;
+    thread_id: string;
+    actor_id: string;
+    tps_anchor?: string;
+    capsule_id?: string;
+    law_ref?: string;
+    required_count?: number;
+    all_or_nothing?: boolean;
+}
+declare function openKnot(params: OpenKnotParams): Knot;
+declare function addStitchToKnot(knot: Knot, stitch: Stitch): string | null;
+declare function validateKnot(knot: Knot, stitches: Stitch[]): KnotValidationResult;
+declare function tieKnot(knot: Knot, stitches: Stitch[]): KnotValidationResult & {
+    knot: Knot;
+};
+declare function breakKnot(knot: Knot, request: KnotBreakRequest): {
+    ok: boolean;
+    error?: string;
+};
+declare function forkFromKnot(knot: Knot, branchId: string, decisionStitchId?: string): {
+    ok: boolean;
+    error?: string;
+};
+declare function isKnotOpen(knot: Knot): boolean;
+declare function isPointOfNoReturn(knot: Knot): boolean;
+declare function findKnotsForStitch(stitchId: string, knots: Knot[]): Knot[];
+declare function getIrreversibleKnots(knots: Knot[]): Knot[];
+declare function getDecisionPoints(knots: Knot[]): Knot[];
+
+interface FabricCell {
+    key: string;
+    value: unknown;
+    last_stitch_id: string;
+    last_tps?: string;
+    write_count: number;
+    locked: boolean;
+    locked_by_knot?: string;
+}
+interface Fabric {
+    fabric_id: string;
+    state_hash: string;
+    cells: Map<string, FabricCell>;
+    thread_ids: string[];
+    stitch_count: number;
+    knot_count: number;
+    projected_at_tps?: string;
+    computed_at: number;
+    version: number;
+}
+interface FabricEffect {
+    mutations: Record<string, unknown | null>;
+    reads?: string[];
+}
+type FabricEffectResolver = (stitch: Stitch) => FabricEffect;
+type FabricDiffKind = 'added' | 'modified' | 'deleted';
+interface FabricDiffEntry {
+    key: string;
+    kind: FabricDiffKind;
+    before?: unknown;
+    after?: unknown;
+    caused_by_stitch?: string;
+}
+interface FabricDiff {
+    from_fabric_id: string;
+    to_fabric_id: string;
+    entries: FabricDiffEntry[];
+    added_count: number;
+    modified_count: number;
+    deleted_count: number;
+}
+interface FabricQuery {
+    prefix?: string;
+    keys?: string[];
+    actor_id?: string;
+    thread_id?: string;
+    locked_only?: boolean;
+}
+
+declare function createFabric(): Fabric;
+declare function applyStitch(fabric: Fabric, stitch: Stitch, effect: FabricEffect): void;
+declare function weave(stitches: Stitch[], resolver: FabricEffectResolver, knots?: Knot[]): Fabric;
+declare function projectAt(stitches: Stitch[], resolver: FabricEffectResolver, tpsFilter: (tps: string | undefined) => boolean, knots?: Knot[]): Fabric;
+declare function lockCells(fabric: Fabric, keys: string[], knotId: string): void;
+declare function queryFabric(fabric: Fabric, query: FabricQuery): FabricCell[];
+declare function getFabricValue(fabric: Fabric, key: string): unknown | undefined;
+declare function diffFabrics(a: Fabric, b: Fabric): FabricDiff;
+
+type PatternKind = 'sequence' | 'knot' | 'state' | 'decision' | 'anomaly';
+type PatternConfidence = number;
+interface Pattern {
+    pattern_id: string;
+    kind: PatternKind;
+    name: string;
+    description?: string;
+    signature: PatternSignature;
+    confidence: PatternConfidence;
+    occurrence_count: number;
+    first_seen_at: number;
+    last_seen_at: number;
+    seen_in_threads: string[];
+    classification: 'normal' | 'anomalous' | 'unclassified';
+    predicted_next?: PatternPrediction;
+}
+interface PatternSignature {
+    intent_sequence?: string[];
+    stitch_kinds?: StitchKind[];
+    knot_type?: KnotType;
+    knot_size?: number;
+    state_keys?: string[];
+    state_mutations?: Record<string, 'created' | 'updated' | 'deleted'>;
+    decision_outcome?: string;
+    actor?: string;
+    min_length?: number;
+    max_length?: number;
+}
+interface PatternMatch {
+    pattern_id: string;
+    matched_stitch_ids: string[];
+    matched_knot_ids?: string[];
+    match_score: number;
+    thread_id: string;
+    detected_at: number;
+}
+interface PatternPrediction {
+    next_intent: string;
+    confidence: PatternConfidence;
+    alternatives: Array<{
+        intent: string;
+        confidence: PatternConfidence;
+    }>;
+    predicted_outcome?: string;
+    risk_note?: string;
+}
+interface PatternStore {
+    save(pattern: Pattern): void;
+    get(patternId: string): Pattern | undefined;
+    findByKind(kind: PatternKind): Pattern[];
+    findByIntent(intent: string): Pattern[];
+    all(): Pattern[];
+}
+
+declare class InMemoryPatternStore implements PatternStore {
+    private patterns;
+    save(pattern: Pattern): void;
+    get(patternId: string): Pattern | undefined;
+    findByKind(kind: PatternKind): Pattern[];
+    findByIntent(intent: string): Pattern[];
+    all(): Pattern[];
+}
+declare function detectSequencePatterns(stitches: Stitch[], windowSize: number, minOccurrences: number): Pattern[];
+declare function detectKnotPatterns(knots: Knot[], minOccurrences: number): Pattern[];
+declare function matchPatterns(stitches: Stitch[], patterns: Pattern[]): PatternMatch[];
+declare function recordOccurrence(pattern: Pattern, threadId: string): void;
+declare function detectAnomalies(recentStitches: Stitch[], knownPatterns: Pattern[], threshold?: number): Pattern[];
+
+interface TpsSensorOptions {
+    maxDriftMs?: number;
+    resolver?: (tps: string) => number | null;
+}
+declare class TpsSensor implements AxisSensor {
+    readonly name = "TpsSensor";
+    readonly order: number;
+    private readonly maxDriftMs;
+    private readonly resolver;
+    constructor(options?: TpsSensorOptions);
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+}
+
+type RiskSignalCollector = (input: SensorInput) => Promise<RiskSignal[]> | RiskSignal[];
+interface RiskGateSensorOptions {
+    collectors: RiskSignalCollector[];
+    denyThreshold?: number;
+    flagThreshold?: number;
+}
+declare class RiskGateSensor implements AxisSensor {
+    readonly name = "RiskGateSensor";
+    readonly order: number;
+    private readonly collectors;
+    private readonly denyThreshold;
+    private readonly flagThreshold;
+    constructor(options: RiskGateSensorOptions);
+    run(input: SensorInput): Promise<SensorDecision>;
+    private evaluate;
+}
+
+interface TickAuthCapsuleRef {
+    capsule_id: string;
+    capsule_type?: string;
+    intent?: string;
+    mode?: string;
+    verification?: {
+        status: 'approved' | 'denied' | 'expired' | 'replay_rejected' | 'consumed' | 'revoked';
+        reason?: string;
+    };
+    scope?: string[];
+    single_use?: boolean;
+    tick_index?: number;
+}
+type TickAuthVerifier = (capsule: TickAuthCapsuleRef, input: SensorInput) => Promise<string | null> | (string | null);
+interface TickAuthSensorOptions {
+    verifier?: TickAuthVerifier;
+    matchIntent?: boolean;
+    acceptTypes?: string[];
+}
+declare class TickAuthSensor implements AxisSensor {
+    readonly name = "TickAuthSensor";
+    readonly order: number;
+    private readonly verifier?;
+    private readonly matchIntent;
+    private readonly acceptTypes;
+    constructor(options?: TickAuthSensorOptions);
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+}
+
 interface CceDerivationInput {
     axisLocalSecret: string;
     capsule: CceCapsuleClaims;
@@ -2615,91 +3343,91 @@ declare class CceReplayProtectionSensor implements AxisSensor {
     run(input: SensorInput): Promise<SensorDecision>;
 }
 
-declare const index$9_CCE_AES_KEY_BYTES: typeof CCE_AES_KEY_BYTES;
-declare const index$9_CCE_DERIVATION: typeof CCE_DERIVATION;
-declare const index$9_CCE_ERROR: typeof CCE_ERROR;
-declare const index$9_CCE_IV_BYTES: typeof CCE_IV_BYTES;
-declare const index$9_CCE_NONCE_BYTES: typeof CCE_NONCE_BYTES;
-declare const index$9_CCE_PROTOCOL_VERSION: typeof CCE_PROTOCOL_VERSION;
-declare const index$9_CCE_TAG_BYTES: typeof CCE_TAG_BYTES;
-type index$9_CceAesGcmProvider = CceAesGcmProvider;
-type index$9_CceAlgorithm = CceAlgorithm;
-type index$9_CceAlgorithmDescriptor = CceAlgorithmDescriptor;
-type index$9_CceAudienceIntentBindingSensor = CceAudienceIntentBindingSensor;
-declare const index$9_CceAudienceIntentBindingSensor: typeof CceAudienceIntentBindingSensor;
-type index$9_CceAxisKeyProvider = CceAxisKeyProvider;
-type index$9_CceAxisSigner = CceAxisSigner;
-type index$9_CceCapsuleClaims = CceCapsuleClaims;
-type index$9_CceCapsuleSignatureVerifier = CceCapsuleSignatureVerifier;
-type index$9_CceCapsuleVerificationSensor = CceCapsuleVerificationSensor;
-declare const index$9_CceCapsuleVerificationSensor: typeof CceCapsuleVerificationSensor;
-type index$9_CceClientKeyEncryptor = CceClientKeyEncryptor;
-type index$9_CceClientKeyResolver = CceClientKeyResolver;
-type index$9_CceClientSignatureSensor = CceClientSignatureSensor;
-declare const index$9_CceClientSignatureSensor: typeof CceClientSignatureSensor;
-type index$9_CceConstraints = CceConstraints;
-type index$9_CceDerivationInput = CceDerivationInput;
-type index$9_CceEncryptedKey = CceEncryptedKey;
-type index$9_CceEncryptedPayload = CceEncryptedPayload;
-type index$9_CceEnvelopeValidationSensor = CceEnvelopeValidationSensor;
-declare const index$9_CceEnvelopeValidationSensor: typeof CceEnvelopeValidationSensor;
-type index$9_CceError = CceError;
-declare const index$9_CceError: typeof CceError;
-type index$9_CceErrorCode = CceErrorCode;
-type index$9_CceExecutionContext = CceExecutionContext;
-type index$9_CceHandler = CceHandler;
-type index$9_CceHandlerContext = CceHandlerContext;
-type index$9_CceHandlerResult = CceHandlerResult;
-type index$9_CceIssuerKeyResolver = CceIssuerKeyResolver;
-type index$9_CceKdfAlgorithm = CceKdfAlgorithm;
-type index$9_CceKemAlgorithm = CceKemAlgorithm;
-type index$9_CcePayloadDecryptionSensor = CcePayloadDecryptionSensor;
-declare const index$9_CcePayloadDecryptionSensor: typeof CcePayloadDecryptionSensor;
-type index$9_CcePayloadValidator = CcePayloadValidator;
-type index$9_CcePayloadValidatorResult = CcePayloadValidatorResult;
-type index$9_CcePipelineConfig = CcePipelineConfig;
-type index$9_CcePipelineResult = CcePipelineResult;
-type index$9_CcePolicyContext = CcePolicyContext;
-type index$9_CcePolicyDecision = CcePolicyDecision;
-type index$9_CcePolicyEvaluator = CcePolicyEvaluator;
-type index$9_CceReplayProtectionSensor = CceReplayProtectionSensor;
-declare const index$9_CceReplayProtectionSensor: typeof CceReplayProtectionSensor;
-type index$9_CceReplayStore = CceReplayStore;
-type index$9_CceRequestEnvelope = CceRequestEnvelope;
-type index$9_CceResponseEnvelope = CceResponseEnvelope;
-type index$9_CceResponseOptions = CceResponseOptions;
-type index$9_CceResponseStatus = CceResponseStatus;
-type index$9_CceSignature = CceSignature;
-type index$9_CceSignatureVerifier = CceSignatureVerifier;
-type index$9_CceTpsWindowSensor = CceTpsWindowSensor;
-declare const index$9_CceTpsWindowSensor: typeof CceTpsWindowSensor;
-type index$9_CceVerificationState = CceVerificationState;
-type index$9_CceWitnessRecord = CceWitnessRecord;
-type index$9_CceWitnessStore = CceWitnessStore;
-type index$9_InMemoryCceReplayStore = InMemoryCceReplayStore;
-declare const index$9_InMemoryCceReplayStore: typeof InMemoryCceReplayStore;
-type index$9_InMemoryCceWitnessStore = InMemoryCceWitnessStore;
-declare const index$9_InMemoryCceWitnessStore: typeof InMemoryCceWitnessStore;
-declare const index$9_aesGcmDecrypt: typeof aesGcmDecrypt;
-declare const index$9_aesGcmEncrypt: typeof aesGcmEncrypt;
-declare const index$9_base64UrlDecode: typeof base64UrlDecode;
-declare const index$9_base64UrlEncode: typeof base64UrlEncode;
-declare const index$9_buildCceErrorResponse: typeof buildCceErrorResponse;
-declare const index$9_buildCceResponse: typeof buildCceResponse;
-declare const index$9_buildExecutionContext: typeof buildExecutionContext;
-declare const index$9_buildWitnessRecord: typeof buildWitnessRecord;
-declare const index$9_deriveRequestExecutionKey: typeof deriveRequestExecutionKey;
-declare const index$9_deriveResponseExecutionKey: typeof deriveResponseExecutionKey;
-declare const index$9_deriveWitnessKey: typeof deriveWitnessKey;
-declare const index$9_executeCcePipeline: typeof executeCcePipeline;
-declare const index$9_extractVerificationState: typeof extractVerificationState;
-declare const index$9_generateAesKey: typeof generateAesKey;
-declare const index$9_generateCceNonce: typeof generateCceNonce;
-declare const index$9_generateIv: typeof generateIv;
-declare const index$9_hashPayload: typeof hashPayload;
-declare const index$9_nodeAesGcmProvider: typeof nodeAesGcmProvider;
-declare namespace index$9 {
-  export { index$9_CCE_AES_KEY_BYTES as CCE_AES_KEY_BYTES, index$9_CCE_DERIVATION as CCE_DERIVATION, index$9_CCE_ERROR as CCE_ERROR, index$9_CCE_IV_BYTES as CCE_IV_BYTES, index$9_CCE_NONCE_BYTES as CCE_NONCE_BYTES, index$9_CCE_PROTOCOL_VERSION as CCE_PROTOCOL_VERSION, index$9_CCE_TAG_BYTES as CCE_TAG_BYTES, type index$9_CceAesGcmProvider as CceAesGcmProvider, type index$9_CceAlgorithm as CceAlgorithm, type index$9_CceAlgorithmDescriptor as CceAlgorithmDescriptor, index$9_CceAudienceIntentBindingSensor as CceAudienceIntentBindingSensor, type index$9_CceAxisKeyProvider as CceAxisKeyProvider, type index$9_CceAxisSigner as CceAxisSigner, type index$9_CceCapsuleClaims as CceCapsuleClaims, type index$9_CceCapsuleSignatureVerifier as CceCapsuleSignatureVerifier, index$9_CceCapsuleVerificationSensor as CceCapsuleVerificationSensor, type index$9_CceClientKeyEncryptor as CceClientKeyEncryptor, type index$9_CceClientKeyResolver as CceClientKeyResolver, index$9_CceClientSignatureSensor as CceClientSignatureSensor, type index$9_CceConstraints as CceConstraints, type index$9_CceDerivationInput as CceDerivationInput, type index$9_CceEncryptedKey as CceEncryptedKey, type index$9_CceEncryptedPayload as CceEncryptedPayload, index$9_CceEnvelopeValidationSensor as CceEnvelopeValidationSensor, index$9_CceError as CceError, type index$9_CceErrorCode as CceErrorCode, type index$9_CceExecutionContext as CceExecutionContext, type index$9_CceHandler as CceHandler, type index$9_CceHandlerContext as CceHandlerContext, type index$9_CceHandlerResult as CceHandlerResult, type index$9_CceIssuerKeyResolver as CceIssuerKeyResolver, type index$9_CceKdfAlgorithm as CceKdfAlgorithm, type index$9_CceKemAlgorithm as CceKemAlgorithm, index$9_CcePayloadDecryptionSensor as CcePayloadDecryptionSensor, type index$9_CcePayloadValidator as CcePayloadValidator, type index$9_CcePayloadValidatorResult as CcePayloadValidatorResult, type index$9_CcePipelineConfig as CcePipelineConfig, type index$9_CcePipelineResult as CcePipelineResult, type index$9_CcePolicyContext as CcePolicyContext, type index$9_CcePolicyDecision as CcePolicyDecision, type index$9_CcePolicyEvaluator as CcePolicyEvaluator, index$9_CceReplayProtectionSensor as CceReplayProtectionSensor, type index$9_CceReplayStore as CceReplayStore, type index$9_CceRequestEnvelope as CceRequestEnvelope, type index$9_CceResponseEnvelope as CceResponseEnvelope, type index$9_CceResponseOptions as CceResponseOptions, type index$9_CceResponseStatus as CceResponseStatus, type index$9_CceSignature as CceSignature, type index$9_CceSignatureVerifier as CceSignatureVerifier, index$9_CceTpsWindowSensor as CceTpsWindowSensor, type index$9_CceVerificationState as CceVerificationState, type index$9_CceWitnessRecord as CceWitnessRecord, type index$9_CceWitnessStore as CceWitnessStore, index$9_InMemoryCceReplayStore as InMemoryCceReplayStore, index$9_InMemoryCceWitnessStore as InMemoryCceWitnessStore, index$9_aesGcmDecrypt as aesGcmDecrypt, index$9_aesGcmEncrypt as aesGcmEncrypt, index$9_base64UrlDecode as base64UrlDecode, index$9_base64UrlEncode as base64UrlEncode, index$9_buildCceErrorResponse as buildCceErrorResponse, index$9_buildCceResponse as buildCceResponse, index$9_buildExecutionContext as buildExecutionContext, index$9_buildWitnessRecord as buildWitnessRecord, index$9_deriveRequestExecutionKey as deriveRequestExecutionKey, index$9_deriveResponseExecutionKey as deriveResponseExecutionKey, index$9_deriveWitnessKey as deriveWitnessKey, index$9_executeCcePipeline as executeCcePipeline, index$9_extractVerificationState as extractVerificationState, index$9_generateAesKey as generateAesKey, index$9_generateCceNonce as generateCceNonce, index$9_generateIv as generateIv, index$9_hashPayload as hashPayload, index$9_nodeAesGcmProvider as nodeAesGcmProvider };
+declare const index$c_CCE_AES_KEY_BYTES: typeof CCE_AES_KEY_BYTES;
+declare const index$c_CCE_DERIVATION: typeof CCE_DERIVATION;
+declare const index$c_CCE_ERROR: typeof CCE_ERROR;
+declare const index$c_CCE_IV_BYTES: typeof CCE_IV_BYTES;
+declare const index$c_CCE_NONCE_BYTES: typeof CCE_NONCE_BYTES;
+declare const index$c_CCE_PROTOCOL_VERSION: typeof CCE_PROTOCOL_VERSION;
+declare const index$c_CCE_TAG_BYTES: typeof CCE_TAG_BYTES;
+type index$c_CceAesGcmProvider = CceAesGcmProvider;
+type index$c_CceAlgorithm = CceAlgorithm;
+type index$c_CceAlgorithmDescriptor = CceAlgorithmDescriptor;
+type index$c_CceAudienceIntentBindingSensor = CceAudienceIntentBindingSensor;
+declare const index$c_CceAudienceIntentBindingSensor: typeof CceAudienceIntentBindingSensor;
+type index$c_CceAxisKeyProvider = CceAxisKeyProvider;
+type index$c_CceAxisSigner = CceAxisSigner;
+type index$c_CceCapsuleClaims = CceCapsuleClaims;
+type index$c_CceCapsuleSignatureVerifier = CceCapsuleSignatureVerifier;
+type index$c_CceCapsuleVerificationSensor = CceCapsuleVerificationSensor;
+declare const index$c_CceCapsuleVerificationSensor: typeof CceCapsuleVerificationSensor;
+type index$c_CceClientKeyEncryptor = CceClientKeyEncryptor;
+type index$c_CceClientKeyResolver = CceClientKeyResolver;
+type index$c_CceClientSignatureSensor = CceClientSignatureSensor;
+declare const index$c_CceClientSignatureSensor: typeof CceClientSignatureSensor;
+type index$c_CceConstraints = CceConstraints;
+type index$c_CceDerivationInput = CceDerivationInput;
+type index$c_CceEncryptedKey = CceEncryptedKey;
+type index$c_CceEncryptedPayload = CceEncryptedPayload;
+type index$c_CceEnvelopeValidationSensor = CceEnvelopeValidationSensor;
+declare const index$c_CceEnvelopeValidationSensor: typeof CceEnvelopeValidationSensor;
+type index$c_CceError = CceError;
+declare const index$c_CceError: typeof CceError;
+type index$c_CceErrorCode = CceErrorCode;
+type index$c_CceExecutionContext = CceExecutionContext;
+type index$c_CceHandler = CceHandler;
+type index$c_CceHandlerContext = CceHandlerContext;
+type index$c_CceHandlerResult = CceHandlerResult;
+type index$c_CceIssuerKeyResolver = CceIssuerKeyResolver;
+type index$c_CceKdfAlgorithm = CceKdfAlgorithm;
+type index$c_CceKemAlgorithm = CceKemAlgorithm;
+type index$c_CcePayloadDecryptionSensor = CcePayloadDecryptionSensor;
+declare const index$c_CcePayloadDecryptionSensor: typeof CcePayloadDecryptionSensor;
+type index$c_CcePayloadValidator = CcePayloadValidator;
+type index$c_CcePayloadValidatorResult = CcePayloadValidatorResult;
+type index$c_CcePipelineConfig = CcePipelineConfig;
+type index$c_CcePipelineResult = CcePipelineResult;
+type index$c_CcePolicyContext = CcePolicyContext;
+type index$c_CcePolicyDecision = CcePolicyDecision;
+type index$c_CcePolicyEvaluator = CcePolicyEvaluator;
+type index$c_CceReplayProtectionSensor = CceReplayProtectionSensor;
+declare const index$c_CceReplayProtectionSensor: typeof CceReplayProtectionSensor;
+type index$c_CceReplayStore = CceReplayStore;
+type index$c_CceRequestEnvelope = CceRequestEnvelope;
+type index$c_CceResponseEnvelope = CceResponseEnvelope;
+type index$c_CceResponseOptions = CceResponseOptions;
+type index$c_CceResponseStatus = CceResponseStatus;
+type index$c_CceSignature = CceSignature;
+type index$c_CceSignatureVerifier = CceSignatureVerifier;
+type index$c_CceTpsWindowSensor = CceTpsWindowSensor;
+declare const index$c_CceTpsWindowSensor: typeof CceTpsWindowSensor;
+type index$c_CceVerificationState = CceVerificationState;
+type index$c_CceWitnessRecord = CceWitnessRecord;
+type index$c_CceWitnessStore = CceWitnessStore;
+type index$c_InMemoryCceReplayStore = InMemoryCceReplayStore;
+declare const index$c_InMemoryCceReplayStore: typeof InMemoryCceReplayStore;
+type index$c_InMemoryCceWitnessStore = InMemoryCceWitnessStore;
+declare const index$c_InMemoryCceWitnessStore: typeof InMemoryCceWitnessStore;
+declare const index$c_aesGcmDecrypt: typeof aesGcmDecrypt;
+declare const index$c_aesGcmEncrypt: typeof aesGcmEncrypt;
+declare const index$c_base64UrlDecode: typeof base64UrlDecode;
+declare const index$c_base64UrlEncode: typeof base64UrlEncode;
+declare const index$c_buildCceErrorResponse: typeof buildCceErrorResponse;
+declare const index$c_buildCceResponse: typeof buildCceResponse;
+declare const index$c_buildExecutionContext: typeof buildExecutionContext;
+declare const index$c_buildWitnessRecord: typeof buildWitnessRecord;
+declare const index$c_deriveRequestExecutionKey: typeof deriveRequestExecutionKey;
+declare const index$c_deriveResponseExecutionKey: typeof deriveResponseExecutionKey;
+declare const index$c_deriveWitnessKey: typeof deriveWitnessKey;
+declare const index$c_executeCcePipeline: typeof executeCcePipeline;
+declare const index$c_extractVerificationState: typeof extractVerificationState;
+declare const index$c_generateAesKey: typeof generateAesKey;
+declare const index$c_generateCceNonce: typeof generateCceNonce;
+declare const index$c_generateIv: typeof generateIv;
+declare const index$c_hashPayload: typeof hashPayload;
+declare const index$c_nodeAesGcmProvider: typeof nodeAesGcmProvider;
+declare namespace index$c {
+  export { index$c_CCE_AES_KEY_BYTES as CCE_AES_KEY_BYTES, index$c_CCE_DERIVATION as CCE_DERIVATION, index$c_CCE_ERROR as CCE_ERROR, index$c_CCE_IV_BYTES as CCE_IV_BYTES, index$c_CCE_NONCE_BYTES as CCE_NONCE_BYTES, index$c_CCE_PROTOCOL_VERSION as CCE_PROTOCOL_VERSION, index$c_CCE_TAG_BYTES as CCE_TAG_BYTES, type index$c_CceAesGcmProvider as CceAesGcmProvider, type index$c_CceAlgorithm as CceAlgorithm, type index$c_CceAlgorithmDescriptor as CceAlgorithmDescriptor, index$c_CceAudienceIntentBindingSensor as CceAudienceIntentBindingSensor, type index$c_CceAxisKeyProvider as CceAxisKeyProvider, type index$c_CceAxisSigner as CceAxisSigner, type index$c_CceCapsuleClaims as CceCapsuleClaims, type index$c_CceCapsuleSignatureVerifier as CceCapsuleSignatureVerifier, index$c_CceCapsuleVerificationSensor as CceCapsuleVerificationSensor, type index$c_CceClientKeyEncryptor as CceClientKeyEncryptor, type index$c_CceClientKeyResolver as CceClientKeyResolver, index$c_CceClientSignatureSensor as CceClientSignatureSensor, type index$c_CceConstraints as CceConstraints, type index$c_CceDerivationInput as CceDerivationInput, type index$c_CceEncryptedKey as CceEncryptedKey, type index$c_CceEncryptedPayload as CceEncryptedPayload, index$c_CceEnvelopeValidationSensor as CceEnvelopeValidationSensor, index$c_CceError as CceError, type index$c_CceErrorCode as CceErrorCode, type index$c_CceExecutionContext as CceExecutionContext, type index$c_CceHandler as CceHandler, type index$c_CceHandlerContext as CceHandlerContext, type index$c_CceHandlerResult as CceHandlerResult, type index$c_CceIssuerKeyResolver as CceIssuerKeyResolver, type index$c_CceKdfAlgorithm as CceKdfAlgorithm, type index$c_CceKemAlgorithm as CceKemAlgorithm, index$c_CcePayloadDecryptionSensor as CcePayloadDecryptionSensor, type index$c_CcePayloadValidator as CcePayloadValidator, type index$c_CcePayloadValidatorResult as CcePayloadValidatorResult, type index$c_CcePipelineConfig as CcePipelineConfig, type index$c_CcePipelineResult as CcePipelineResult, type index$c_CcePolicyContext as CcePolicyContext, type index$c_CcePolicyDecision as CcePolicyDecision, type index$c_CcePolicyEvaluator as CcePolicyEvaluator, index$c_CceReplayProtectionSensor as CceReplayProtectionSensor, type index$c_CceReplayStore as CceReplayStore, type index$c_CceRequestEnvelope as CceRequestEnvelope, type index$c_CceResponseEnvelope as CceResponseEnvelope, type index$c_CceResponseOptions as CceResponseOptions, type index$c_CceResponseStatus as CceResponseStatus, type index$c_CceSignature as CceSignature, type index$c_CceSignatureVerifier as CceSignatureVerifier, index$c_CceTpsWindowSensor as CceTpsWindowSensor, type index$c_CceVerificationState as CceVerificationState, type index$c_CceWitnessRecord as CceWitnessRecord, type index$c_CceWitnessStore as CceWitnessStore, index$c_InMemoryCceReplayStore as InMemoryCceReplayStore, index$c_InMemoryCceWitnessStore as InMemoryCceWitnessStore, index$c_aesGcmDecrypt as aesGcmDecrypt, index$c_aesGcmEncrypt as aesGcmEncrypt, index$c_base64UrlDecode as base64UrlDecode, index$c_base64UrlEncode as base64UrlEncode, index$c_buildCceErrorResponse as buildCceErrorResponse, index$c_buildCceResponse as buildCceResponse, index$c_buildExecutionContext as buildExecutionContext, index$c_buildWitnessRecord as buildWitnessRecord, index$c_deriveRequestExecutionKey as deriveRequestExecutionKey, index$c_deriveResponseExecutionKey as deriveResponseExecutionKey, index$c_deriveWitnessKey as deriveWitnessKey, index$c_executeCcePipeline as executeCcePipeline, index$c_extractVerificationState as extractVerificationState, index$c_generateAesKey as generateAesKey, index$c_generateCceNonce as generateCceNonce, index$c_generateIv as generateIv, index$c_hashPayload as hashPayload, index$c_nodeAesGcmProvider as nodeAesGcmProvider };
 }
 
 type ProofType = 1 | 2 | 3 | 4;
@@ -2743,243 +3471,348 @@ declare class ProofVerificationService {
     static calculateFingerprint(certPem: string): string;
 }
 
-type index$8_ActorKeyRecord = ActorKeyRecord;
-type index$8_AxisCapsule = AxisCapsule;
-type index$8_AxisCapsuleConstraints = AxisCapsuleConstraints;
-type index$8_AxisCapsulePayload = AxisCapsulePayload;
-type index$8_CapsuleBatchBody = CapsuleBatchBody;
-type index$8_CapsuleBatchResult = CapsuleBatchResult;
-type index$8_CapsuleIssueBody = CapsuleIssueBody;
-type index$8_CapsuleIssueResult = CapsuleIssueResult;
-type index$8_CapsuleMode = CapsuleMode;
-type index$8_CapsuleRecord = CapsuleRecord;
-type index$8_CapsuleRevokeBody = CapsuleRevokeBody;
-type index$8_CapsuleStatus = CapsuleStatus;
-type index$8_DeviceSEContext = DeviceSEContext;
-type index$8_IntentExecBody = IntentExecBody;
-type index$8_IssuerKeyRecord = IssuerKeyRecord;
-type index$8_KeyStatus = KeyStatus;
-type index$8_MTLSContext = MTLSContext;
-type index$8_ProofType = ProofType;
-type index$8_ProofVerificationResult = ProofVerificationResult;
-type index$8_ProofVerificationService = ProofVerificationService;
-declare const index$8_ProofVerificationService: typeof ProofVerificationService;
-type index$8_TickWindow = TickWindow;
-declare const index$8_b64urlDecode: typeof b64urlDecode;
-declare const index$8_b64urlDecodeString: typeof b64urlDecodeString;
-declare const index$8_b64urlEncode: typeof b64urlEncode;
-declare const index$8_b64urlEncodeString: typeof b64urlEncodeString;
-declare const index$8_canonicalJson: typeof canonicalJson;
-declare const index$8_canonicalJsonExcluding: typeof canonicalJsonExcluding;
+type index$b_ActorKeyRecord = ActorKeyRecord;
+type index$b_AxisCapsule = AxisCapsule;
+type index$b_AxisCapsuleConstraints = AxisCapsuleConstraints;
+type index$b_AxisCapsulePayload = AxisCapsulePayload;
+type index$b_CapsuleBatchBody = CapsuleBatchBody;
+type index$b_CapsuleBatchResult = CapsuleBatchResult;
+type index$b_CapsuleIssueBody = CapsuleIssueBody;
+type index$b_CapsuleIssueResult = CapsuleIssueResult;
+type index$b_CapsuleMode = CapsuleMode;
+type index$b_CapsuleRecord = CapsuleRecord;
+type index$b_CapsuleRevokeBody = CapsuleRevokeBody;
+type index$b_CapsuleStatus = CapsuleStatus;
+type index$b_DeviceSEContext = DeviceSEContext;
+type index$b_IntentExecBody = IntentExecBody;
+type index$b_IssuerKeyRecord = IssuerKeyRecord;
+type index$b_KeyStatus = KeyStatus;
+type index$b_MTLSContext = MTLSContext;
+type index$b_ProofType = ProofType;
+type index$b_ProofVerificationResult = ProofVerificationResult;
+type index$b_ProofVerificationService = ProofVerificationService;
+declare const index$b_ProofVerificationService: typeof ProofVerificationService;
+type index$b_TickWindow = TickWindow;
+declare const index$b_b64urlDecode: typeof b64urlDecode;
+declare const index$b_b64urlDecodeString: typeof b64urlDecodeString;
+declare const index$b_b64urlEncode: typeof b64urlEncode;
+declare const index$b_b64urlEncodeString: typeof b64urlEncodeString;
+declare const index$b_canonicalJson: typeof canonicalJson;
+declare const index$b_canonicalJsonExcluding: typeof canonicalJsonExcluding;
+declare namespace index$b {
+  export { type index$b_ActorKeyRecord as ActorKeyRecord, type AxisAlg$1 as AxisAlg, type index$b_AxisCapsule as AxisCapsule, type index$b_AxisCapsuleConstraints as AxisCapsuleConstraints, type index$b_AxisCapsulePayload as AxisCapsulePayload, type AxisPacket$1 as AxisPacket, type AxisResponse$1 as AxisResponse, type AxisSig$1 as AxisSig, type index$b_CapsuleBatchBody as CapsuleBatchBody, type index$b_CapsuleBatchResult as CapsuleBatchResult, type index$b_CapsuleIssueBody as CapsuleIssueBody, type index$b_CapsuleIssueResult as CapsuleIssueResult, type index$b_CapsuleMode as CapsuleMode, type index$b_CapsuleRecord as CapsuleRecord, type index$b_CapsuleRevokeBody as CapsuleRevokeBody, type index$b_CapsuleStatus as CapsuleStatus, type index$b_DeviceSEContext as DeviceSEContext, type index$b_IntentExecBody as IntentExecBody, type index$b_IssuerKeyRecord as IssuerKeyRecord, type index$b_KeyStatus as KeyStatus, type index$b_MTLSContext as MTLSContext, type index$b_ProofType as ProofType, type index$b_ProofVerificationResult as ProofVerificationResult, index$b_ProofVerificationService as ProofVerificationService, type index$b_TickWindow as TickWindow, index$b_b64urlDecode as b64urlDecode, index$b_b64urlDecodeString as b64urlDecodeString, index$b_b64urlEncode as b64urlEncode, index$b_b64urlEncodeString as b64urlEncodeString, index$b_canonicalJson as canonicalJson, index$b_canonicalJsonExcluding as canonicalJsonExcluding };
+}
+
+declare const index$a_AXIS_ANONYMOUS_KEY: typeof AXIS_ANONYMOUS_KEY;
+declare const index$a_AXIS_META_KEY: typeof AXIS_META_KEY;
+declare const index$a_AXIS_PUBLIC_KEY: typeof AXIS_PUBLIC_KEY;
+declare const index$a_AXIS_RATE_LIMIT_KEY: typeof AXIS_RATE_LIMIT_KEY;
+declare const index$a_Axis: typeof Axis;
+declare const index$a_AxisAnonymous: typeof AxisAnonymous;
+declare const index$a_AxisContext: typeof AxisContext;
+declare const index$a_AxisDemoPubkey: typeof AxisDemoPubkey;
+declare const index$a_AxisFrame: typeof AxisFrame;
+type index$a_AxisIntentSensorOptions = AxisIntentSensorOptions;
+type index$a_AxisIntentSensorRef = AxisIntentSensorRef;
+declare const index$a_AxisIp: typeof AxisIp;
+type index$a_AxisObserverBinding = AxisObserverBinding;
+type index$a_AxisObserverBindingOptions = AxisObserverBindingOptions;
+type index$a_AxisObserverDefinition = AxisObserverDefinition;
+type index$a_AxisObserverRef = AxisObserverRef;
+declare const index$a_AxisPublic: typeof AxisPublic;
+declare const index$a_AxisRateLimit: typeof AxisRateLimit;
+type index$a_AxisRateLimitConfig = AxisRateLimitConfig;
+declare const index$a_AxisRaw: typeof AxisRaw;
+type index$a_AxisRequestData = AxisRequestData;
+declare const index$a_CAPSULE_POLICY_METADATA_KEY: typeof CAPSULE_POLICY_METADATA_KEY;
+declare const index$a_CHAIN_METADATA_KEY: typeof CHAIN_METADATA_KEY;
+declare const index$a_CONTRACT_METADATA_KEY: typeof CONTRACT_METADATA_KEY;
+declare const index$a_Capsule: typeof Capsule;
+declare const index$a_CapsulePolicy: typeof CapsulePolicy;
+type index$a_CapsulePolicyOptions = CapsulePolicyOptions;
+type index$a_CapsuleScopeMode = CapsuleScopeMode;
+declare const index$a_Chain: typeof Chain;
+declare const index$a_Contract: typeof Contract;
+type index$a_DtoSchema = DtoSchema;
+declare const index$a_HANDLER_METADATA_KEY: typeof HANDLER_METADATA_KEY;
+declare const index$a_Handler: typeof Handler;
+declare const index$a_INTENT_BODY_KEY: typeof INTENT_BODY_KEY;
+declare const index$a_INTENT_METADATA_KEY: typeof INTENT_METADATA_KEY;
+declare const index$a_INTENT_ROUTES_KEY: typeof INTENT_ROUTES_KEY;
+declare const index$a_INTENT_SENSORS_KEY: typeof INTENT_SENSORS_KEY;
+declare const index$a_Intent: typeof Intent;
+declare const index$a_IntentBody: typeof IntentBody;
+type index$a_IntentKind = IntentKind;
+type index$a_IntentOptions = IntentOptions;
+type index$a_IntentRoute = IntentRoute;
+declare const index$a_IntentSensors: typeof IntentSensors;
+type index$a_IntentTlvField = IntentTlvField;
+declare const index$a_OBSERVER_BINDINGS_KEY: typeof OBSERVER_BINDINGS_KEY;
+declare const index$a_OBSERVER_METADATA_KEY: typeof OBSERVER_METADATA_KEY;
+declare const index$a_Observer: typeof Observer;
+declare const index$a_REQUIRED_PROOF_METADATA_KEY: typeof REQUIRED_PROOF_METADATA_KEY;
+declare const index$a_RequiredProof: typeof RequiredProof;
+type index$a_RequiredProofKind = RequiredProofKind;
+declare const index$a_SENSITIVITY_METADATA_KEY: typeof SENSITIVITY_METADATA_KEY;
+declare const index$a_SENSOR_METADATA_KEY: typeof SENSOR_METADATA_KEY;
+declare const index$a_Sensitivity: typeof Sensitivity;
+declare const index$a_Sensor: typeof Sensor;
+type index$a_SensorOptions = SensorOptions;
+type index$a_SensorPhase = SensorPhase;
+declare const index$a_TLV_FIELDS_KEY: typeof TLV_FIELDS_KEY;
+declare const index$a_TLV_VALIDATORS_KEY: typeof TLV_VALIDATORS_KEY;
+declare const index$a_TlvEnum: typeof TlvEnum;
+declare const index$a_TlvField: typeof TlvField;
+type index$a_TlvFieldKind = TlvFieldKind;
+type index$a_TlvFieldMeta = TlvFieldMeta;
+type index$a_TlvFieldOptions = TlvFieldOptions;
+declare const index$a_TlvMinLen: typeof TlvMinLen;
+declare const index$a_TlvRange: typeof TlvRange;
+declare const index$a_TlvUtf8Pattern: typeof TlvUtf8Pattern;
+declare const index$a_TlvValidate: typeof TlvValidate;
+type index$a_TlvValidatorFn = TlvValidatorFn;
+type index$a_TlvValidatorMeta = TlvValidatorMeta;
+declare const index$a_Witness: typeof Witness;
+declare const index$a_buildDtoDecoder: typeof buildDtoDecoder;
+declare const index$a_extractDtoSchema: typeof extractDtoSchema;
+declare const index$a_mergeCapsulePolicyOptions: typeof mergeCapsulePolicyOptions;
+declare const index$a_normalizeCapsulePolicyOptions: typeof normalizeCapsulePolicyOptions;
+declare namespace index$a {
+  export { index$a_AXIS_ANONYMOUS_KEY as AXIS_ANONYMOUS_KEY, index$a_AXIS_META_KEY as AXIS_META_KEY, index$a_AXIS_PUBLIC_KEY as AXIS_PUBLIC_KEY, index$a_AXIS_RATE_LIMIT_KEY as AXIS_RATE_LIMIT_KEY, index$a_Axis as Axis, index$a_AxisAnonymous as AxisAnonymous, index$a_AxisContext as AxisContext, index$a_AxisDemoPubkey as AxisDemoPubkey, index$a_AxisFrame as AxisFrame, type index$a_AxisIntentSensorOptions as AxisIntentSensorOptions, type index$a_AxisIntentSensorRef as AxisIntentSensorRef, index$a_AxisIp as AxisIp, type index$a_AxisObserverBinding as AxisObserverBinding, type index$a_AxisObserverBindingOptions as AxisObserverBindingOptions, type index$a_AxisObserverDefinition as AxisObserverDefinition, type index$a_AxisObserverRef as AxisObserverRef, index$a_AxisPublic as AxisPublic, index$a_AxisRateLimit as AxisRateLimit, type index$a_AxisRateLimitConfig as AxisRateLimitConfig, index$a_AxisRaw as AxisRaw, type index$a_AxisRequestData as AxisRequestData, index$a_CAPSULE_POLICY_METADATA_KEY as CAPSULE_POLICY_METADATA_KEY, index$a_CHAIN_METADATA_KEY as CHAIN_METADATA_KEY, index$a_CONTRACT_METADATA_KEY as CONTRACT_METADATA_KEY, index$a_Capsule as Capsule, index$a_CapsulePolicy as CapsulePolicy, type index$a_CapsulePolicyOptions as CapsulePolicyOptions, type index$a_CapsuleScopeMode as CapsuleScopeMode, index$a_Chain as Chain, index$a_Contract as Contract, type index$a_DtoSchema as DtoSchema, index$a_HANDLER_METADATA_KEY as HANDLER_METADATA_KEY, index$a_Handler as Handler, index$a_INTENT_BODY_KEY as INTENT_BODY_KEY, index$a_INTENT_METADATA_KEY as INTENT_METADATA_KEY, index$a_INTENT_ROUTES_KEY as INTENT_ROUTES_KEY, index$a_INTENT_SENSORS_KEY as INTENT_SENSORS_KEY, index$a_Intent as Intent, index$a_IntentBody as IntentBody, type index$a_IntentKind as IntentKind, type index$a_IntentOptions as IntentOptions, type index$a_IntentRoute as IntentRoute, index$a_IntentSensors as IntentSensors, type index$a_IntentTlvField as IntentTlvField, index$a_OBSERVER_BINDINGS_KEY as OBSERVER_BINDINGS_KEY, index$a_OBSERVER_METADATA_KEY as OBSERVER_METADATA_KEY, index$a_Observer as Observer, index$a_REQUIRED_PROOF_METADATA_KEY as REQUIRED_PROOF_METADATA_KEY, index$a_RequiredProof as RequiredProof, type index$a_RequiredProofKind as RequiredProofKind, index$a_SENSITIVITY_METADATA_KEY as SENSITIVITY_METADATA_KEY, index$a_SENSOR_METADATA_KEY as SENSOR_METADATA_KEY, index$a_Sensitivity as Sensitivity, index$a_Sensor as Sensor, type index$a_SensorOptions as SensorOptions, type index$a_SensorPhase as SensorPhase, index$a_TLV_FIELDS_KEY as TLV_FIELDS_KEY, index$a_TLV_VALIDATORS_KEY as TLV_VALIDATORS_KEY, index$a_TlvEnum as TlvEnum, index$a_TlvField as TlvField, type index$a_TlvFieldKind as TlvFieldKind, type index$a_TlvFieldMeta as TlvFieldMeta, type index$a_TlvFieldOptions as TlvFieldOptions, index$a_TlvMinLen as TlvMinLen, index$a_TlvRange as TlvRange, index$a_TlvUtf8Pattern as TlvUtf8Pattern, index$a_TlvValidate as TlvValidate, type index$a_TlvValidatorFn as TlvValidatorFn, type index$a_TlvValidatorMeta as TlvValidatorMeta, index$a_Witness as Witness, index$a_buildDtoDecoder as buildDtoDecoder, index$a_extractDtoSchema as extractDtoSchema, index$a_mergeCapsulePolicyOptions as mergeCapsulePolicyOptions, index$a_normalizeCapsulePolicyOptions as normalizeCapsulePolicyOptions };
+}
+
+type index$9_ObservationQueueConfig = ObservationQueueConfig;
+type index$9_ObservationQueueMessage = ObservationQueueMessage;
+type index$9_ObservationStreamEntry = ObservationStreamEntry;
+type index$9_ObservationWitnessSummary = ObservationWitnessSummary;
+type index$9_ObserverVerdict = ObserverVerdict;
+type index$9_ResponseContract = ResponseContract;
+declare const index$9_ResponseObserver: typeof ResponseObserver;
+type index$9_ResponseObserverContext = ResponseObserverContext;
+type index$9_UnsignedObservationWitness = UnsignedObservationWitness;
+declare const index$9_buildQueueMessage: typeof buildQueueMessage;
+declare const index$9_buildUnsignedWitness: typeof buildUnsignedWitness;
+declare const index$9_canonicalizeObservation: typeof canonicalizeObservation;
+declare const index$9_decodeQueueMessage: typeof decodeQueueMessage;
+declare const index$9_encodeQueueMessage: typeof encodeQueueMessage;
+declare const index$9_hashObservation: typeof hashObservation;
+declare const index$9_parseAutoClaimEntries: typeof parseAutoClaimEntries;
+declare const index$9_parseStreamEntries: typeof parseStreamEntries;
+declare const index$9_stableJsonStringify: typeof stableJsonStringify;
+declare const index$9_verifyResponse: typeof verifyResponse;
+declare namespace index$9 {
+  export { type index$9_ObservationQueueConfig as ObservationQueueConfig, type index$9_ObservationQueueMessage as ObservationQueueMessage, type index$9_ObservationStreamEntry as ObservationStreamEntry, type index$9_ObservationWitnessSummary as ObservationWitnessSummary, type index$9_ObserverVerdict as ObserverVerdict, type index$9_ResponseContract as ResponseContract, index$9_ResponseObserver as ResponseObserver, type index$9_ResponseObserverContext as ResponseObserverContext, type index$9_UnsignedObservationWitness as UnsignedObservationWitness, index$9_buildQueueMessage as buildQueueMessage, index$9_buildUnsignedWitness as buildUnsignedWitness, index$9_canonicalizeObservation as canonicalizeObservation, index$9_decodeQueueMessage as decodeQueueMessage, index$9_encodeQueueMessage as encodeQueueMessage, index$9_hashObservation as hashObservation, index$9_parseAutoClaimEntries as parseAutoClaimEntries, index$9_parseStreamEntries as parseStreamEntries, index$9_stableJsonStringify as stableJsonStringify, index$9_verifyResponse as verifyResponse };
+}
+
+declare const index$8_AXIS_EXECUTION_CONTEXT_KEY: typeof AXIS_EXECUTION_CONTEXT_KEY;
+type index$8_AxisCapsuleRef = AxisCapsuleRef;
+type index$8_AxisChainEncryption = AxisChainEncryption;
+type index$8_AxisChainEnvelope<TInput = unknown> = AxisChainEnvelope<TInput>;
+type index$8_AxisChainExecutionOptions = AxisChainExecutionOptions;
+type index$8_AxisChainExecutor = AxisChainExecutor;
+declare const index$8_AxisChainExecutor: typeof AxisChainExecutor;
+type index$8_AxisChainRequest<TInput = unknown, TCapsule = Record<string, unknown>> = AxisChainRequest<TInput, TCapsule>;
+type index$8_AxisChainResult<TOutput = unknown> = AxisChainResult<TOutput>;
+type index$8_AxisChainStatus = AxisChainStatus;
+type index$8_AxisChainStep<TInput = unknown> = AxisChainStep<TInput>;
+type index$8_AxisChainStepResult<TOutput = unknown> = AxisChainStepResult<TOutput>;
+type index$8_AxisChainStepStatus = AxisChainStepStatus;
+type index$8_AxisDecoded = AxisDecoded;
+type index$8_AxisEffect = AxisEffect;
+type index$8_AxisExecutionContext = AxisExecutionContext;
+type index$8_AxisExecutionMode = AxisExecutionMode;
+type index$8_AxisIntentEnvelope<TPayload = unknown> = AxisIntentEnvelope<TPayload>;
+type index$8_AxisIntentObserver = AxisIntentObserver;
+type index$8_AxisKeyExchangeRef = AxisKeyExchangeRef;
+type index$8_AxisObservation = AxisObservation;
+type index$8_AxisObserverContext = AxisObserverContext;
+type index$8_AxisObserverEvent = AxisObserverEvent;
+type index$8_AxisObserverRegistration = AxisObserverRegistration;
+declare const index$8_BAND: typeof BAND;
+type index$8_ChainOptions = ChainOptions;
+type index$8_HandlerDiscoveryService = HandlerDiscoveryService;
+declare const index$8_HandlerDiscoveryService: typeof HandlerDiscoveryService;
+type index$8_IntentRouter = IntentRouter;
+declare const index$8_IntentRouter: typeof IntentRouter;
+type index$8_ObservationQueueConfig = ObservationQueueConfig;
+type index$8_ObservationQueueMessage = ObservationQueueMessage;
+type index$8_ObservationSensor = ObservationSensor;
+type index$8_ObservationStage = ObservationStage;
+type index$8_ObservationStreamEntry = ObservationStreamEntry;
+type index$8_ObservationWitnessSummary = ObservationWitnessSummary;
+type index$8_ObserverDiscoveryService = ObserverDiscoveryService;
+declare const index$8_ObserverDiscoveryService: typeof ObserverDiscoveryService;
+type index$8_ObserverDispatcherService = ObserverDispatcherService;
+declare const index$8_ObserverDispatcherService: typeof ObserverDispatcherService;
+type index$8_ObserverRegistry = ObserverRegistry;
+declare const index$8_ObserverRegistry: typeof ObserverRegistry;
+type index$8_ObserverVerdict = ObserverVerdict;
+declare const index$8_PRE_DECODE_BOUNDARY: typeof PRE_DECODE_BOUNDARY;
+type index$8_RegisteredChainConfig = RegisteredChainConfig;
+type index$8_ResponseContract = ResponseContract;
+declare const index$8_ResponseObserver: typeof ResponseObserver;
+type index$8_ResponseObserverContext = ResponseObserverContext;
+type index$8_SensorBand = SensorBand;
+type index$8_SensorDiscoveryService = SensorDiscoveryService;
+declare const index$8_SensorDiscoveryService: typeof SensorDiscoveryService;
+type index$8_SensorRegistry = SensorRegistry;
+declare const index$8_SensorRegistry: typeof SensorRegistry;
+type index$8_UnsignedObservationWitness = UnsignedObservationWitness;
+declare const index$8_buildQueueMessage: typeof buildQueueMessage;
+declare const index$8_buildUnsignedWitness: typeof buildUnsignedWitness;
+declare const index$8_canonicalizeObservation: typeof canonicalizeObservation;
+declare const index$8_createObservation: typeof createObservation;
+declare const index$8_decodeQueueMessage: typeof decodeQueueMessage;
+declare const index$8_encodeQueueMessage: typeof encodeQueueMessage;
+declare const index$8_endStage: typeof endStage;
+declare const index$8_finalizeObservation: typeof finalizeObservation;
+declare const index$8_getAxisExecutionContext: typeof getAxisExecutionContext;
+declare const index$8_hashObservation: typeof hashObservation;
+declare const index$8_mergeAxisExecutionContext: typeof mergeAxisExecutionContext;
+declare const index$8_parseAutoClaimEntries: typeof parseAutoClaimEntries;
+declare const index$8_parseStreamEntries: typeof parseStreamEntries;
+declare const index$8_recordSensor: typeof recordSensor;
+declare const index$8_stableJsonStringify: typeof stableJsonStringify;
+declare const index$8_startStage: typeof startStage;
+declare const index$8_verifyResponse: typeof verifyResponse;
+declare const index$8_withAxisExecutionContext: typeof withAxisExecutionContext;
 declare namespace index$8 {
-  export { type index$8_ActorKeyRecord as ActorKeyRecord, type AxisAlg$1 as AxisAlg, type index$8_AxisCapsule as AxisCapsule, type index$8_AxisCapsuleConstraints as AxisCapsuleConstraints, type index$8_AxisCapsulePayload as AxisCapsulePayload, type AxisPacket$1 as AxisPacket, type AxisResponse$1 as AxisResponse, type AxisSig$1 as AxisSig, type index$8_CapsuleBatchBody as CapsuleBatchBody, type index$8_CapsuleBatchResult as CapsuleBatchResult, type index$8_CapsuleIssueBody as CapsuleIssueBody, type index$8_CapsuleIssueResult as CapsuleIssueResult, type index$8_CapsuleMode as CapsuleMode, type index$8_CapsuleRecord as CapsuleRecord, type index$8_CapsuleRevokeBody as CapsuleRevokeBody, type index$8_CapsuleStatus as CapsuleStatus, type index$8_DeviceSEContext as DeviceSEContext, type index$8_IntentExecBody as IntentExecBody, type index$8_IssuerKeyRecord as IssuerKeyRecord, type index$8_KeyStatus as KeyStatus, type index$8_MTLSContext as MTLSContext, type index$8_ProofType as ProofType, type index$8_ProofVerificationResult as ProofVerificationResult, index$8_ProofVerificationService as ProofVerificationService, type index$8_TickWindow as TickWindow, index$8_b64urlDecode as b64urlDecode, index$8_b64urlDecodeString as b64urlDecodeString, index$8_b64urlEncode as b64urlEncode, index$8_b64urlEncodeString as b64urlEncodeString, index$8_canonicalJson as canonicalJson, index$8_canonicalJsonExcluding as canonicalJsonExcluding };
-}
-
-declare const index$7_AXIS_ANONYMOUS_KEY: typeof AXIS_ANONYMOUS_KEY;
-declare const index$7_AXIS_META_KEY: typeof AXIS_META_KEY;
-declare const index$7_AXIS_PUBLIC_KEY: typeof AXIS_PUBLIC_KEY;
-declare const index$7_AXIS_RATE_LIMIT_KEY: typeof AXIS_RATE_LIMIT_KEY;
-declare const index$7_Axis: typeof Axis;
-declare const index$7_AxisAnonymous: typeof AxisAnonymous;
-declare const index$7_AxisContext: typeof AxisContext;
-declare const index$7_AxisDemoPubkey: typeof AxisDemoPubkey;
-declare const index$7_AxisFrame: typeof AxisFrame;
-declare const index$7_AxisIp: typeof AxisIp;
-type index$7_AxisObserverBinding = AxisObserverBinding;
-type index$7_AxisObserverBindingOptions = AxisObserverBindingOptions;
-type index$7_AxisObserverDefinition = AxisObserverDefinition;
-type index$7_AxisObserverRef = AxisObserverRef;
-declare const index$7_AxisPublic: typeof AxisPublic;
-declare const index$7_AxisRateLimit: typeof AxisRateLimit;
-type index$7_AxisRateLimitConfig = AxisRateLimitConfig;
-declare const index$7_AxisRaw: typeof AxisRaw;
-type index$7_AxisRequestData = AxisRequestData;
-declare const index$7_CAPSULE_POLICY_METADATA_KEY: typeof CAPSULE_POLICY_METADATA_KEY;
-declare const index$7_CHAIN_METADATA_KEY: typeof CHAIN_METADATA_KEY;
-declare const index$7_CONTRACT_METADATA_KEY: typeof CONTRACT_METADATA_KEY;
-declare const index$7_Capsule: typeof Capsule;
-declare const index$7_CapsulePolicy: typeof CapsulePolicy;
-type index$7_CapsulePolicyOptions = CapsulePolicyOptions;
-type index$7_CapsuleScopeMode = CapsuleScopeMode;
-declare const index$7_Chain: typeof Chain;
-declare const index$7_Contract: typeof Contract;
-type index$7_DtoSchema = DtoSchema;
-declare const index$7_HANDLER_METADATA_KEY: typeof HANDLER_METADATA_KEY;
-declare const index$7_Handler: typeof Handler;
-declare const index$7_INTENT_BODY_KEY: typeof INTENT_BODY_KEY;
-declare const index$7_INTENT_METADATA_KEY: typeof INTENT_METADATA_KEY;
-declare const index$7_INTENT_ROUTES_KEY: typeof INTENT_ROUTES_KEY;
-declare const index$7_INTENT_SENSORS_KEY: typeof INTENT_SENSORS_KEY;
-declare const index$7_Intent: typeof Intent;
-declare const index$7_IntentBody: typeof IntentBody;
-type index$7_IntentKind = IntentKind;
-type index$7_IntentOptions = IntentOptions;
-type index$7_IntentRoute = IntentRoute;
-declare const index$7_IntentSensors: typeof IntentSensors;
-type index$7_IntentTlvField = IntentTlvField;
-declare const index$7_OBSERVER_BINDINGS_KEY: typeof OBSERVER_BINDINGS_KEY;
-declare const index$7_OBSERVER_METADATA_KEY: typeof OBSERVER_METADATA_KEY;
-declare const index$7_Observer: typeof Observer;
-declare const index$7_REQUIRED_PROOF_METADATA_KEY: typeof REQUIRED_PROOF_METADATA_KEY;
-declare const index$7_RequiredProof: typeof RequiredProof;
-type index$7_RequiredProofKind = RequiredProofKind;
-declare const index$7_SENSITIVITY_METADATA_KEY: typeof SENSITIVITY_METADATA_KEY;
-declare const index$7_SENSOR_METADATA_KEY: typeof SENSOR_METADATA_KEY;
-declare const index$7_Sensitivity: typeof Sensitivity;
-declare const index$7_Sensor: typeof Sensor;
-type index$7_SensorOptions = SensorOptions;
-type index$7_SensorPhase = SensorPhase;
-declare const index$7_TLV_FIELDS_KEY: typeof TLV_FIELDS_KEY;
-declare const index$7_TLV_VALIDATORS_KEY: typeof TLV_VALIDATORS_KEY;
-declare const index$7_TlvEnum: typeof TlvEnum;
-declare const index$7_TlvField: typeof TlvField;
-type index$7_TlvFieldKind = TlvFieldKind;
-type index$7_TlvFieldMeta = TlvFieldMeta;
-type index$7_TlvFieldOptions = TlvFieldOptions;
-declare const index$7_TlvMinLen: typeof TlvMinLen;
-declare const index$7_TlvRange: typeof TlvRange;
-declare const index$7_TlvUtf8Pattern: typeof TlvUtf8Pattern;
-declare const index$7_TlvValidate: typeof TlvValidate;
-type index$7_TlvValidatorFn = TlvValidatorFn;
-type index$7_TlvValidatorMeta = TlvValidatorMeta;
-declare const index$7_Witness: typeof Witness;
-declare const index$7_buildDtoDecoder: typeof buildDtoDecoder;
-declare const index$7_extractDtoSchema: typeof extractDtoSchema;
-declare const index$7_mergeCapsulePolicyOptions: typeof mergeCapsulePolicyOptions;
-declare const index$7_normalizeCapsulePolicyOptions: typeof normalizeCapsulePolicyOptions;
+  export { index$8_AXIS_EXECUTION_CONTEXT_KEY as AXIS_EXECUTION_CONTEXT_KEY, type index$8_AxisCapsuleRef as AxisCapsuleRef, type index$8_AxisChainEncryption as AxisChainEncryption, type index$8_AxisChainEnvelope as AxisChainEnvelope, type index$8_AxisChainExecutionOptions as AxisChainExecutionOptions, index$8_AxisChainExecutor as AxisChainExecutor, type index$8_AxisChainRequest as AxisChainRequest, type index$8_AxisChainResult as AxisChainResult, type index$8_AxisChainStatus as AxisChainStatus, type index$8_AxisChainStep as AxisChainStep, type index$8_AxisChainStepResult as AxisChainStepResult, type index$8_AxisChainStepStatus as AxisChainStepStatus, type index$8_AxisDecoded as AxisDecoded, type index$8_AxisEffect as AxisEffect, type index$8_AxisExecutionContext as AxisExecutionContext, type index$8_AxisExecutionMode as AxisExecutionMode, type index$8_AxisIntentEnvelope as AxisIntentEnvelope, type index$8_AxisIntentObserver as AxisIntentObserver, type index$8_AxisKeyExchangeRef as AxisKeyExchangeRef, type index$8_AxisObservation as AxisObservation, type index$8_AxisObserverContext as AxisObserverContext, type index$8_AxisObserverEvent as AxisObserverEvent, type index$8_AxisObserverRegistration as AxisObserverRegistration, index$8_BAND as BAND, type index$8_ChainOptions as ChainOptions, index$8_HandlerDiscoveryService as HandlerDiscoveryService, index$8_IntentRouter as IntentRouter, type IntentSchema$1 as IntentSchema, type index$8_ObservationQueueConfig as ObservationQueueConfig, type index$8_ObservationQueueMessage as ObservationQueueMessage, type index$8_ObservationSensor as ObservationSensor, type index$8_ObservationStage as ObservationStage, type index$8_ObservationStreamEntry as ObservationStreamEntry, type index$8_ObservationWitnessSummary as ObservationWitnessSummary, index$8_ObserverDiscoveryService as ObserverDiscoveryService, index$8_ObserverDispatcherService as ObserverDispatcherService, index$8_ObserverRegistry as ObserverRegistry, type index$8_ObserverVerdict as ObserverVerdict, index$8_PRE_DECODE_BOUNDARY as PRE_DECODE_BOUNDARY, type index$8_RegisteredChainConfig as RegisteredChainConfig, type index$8_ResponseContract as ResponseContract, index$8_ResponseObserver as ResponseObserver, type index$8_ResponseObserverContext as ResponseObserverContext, type index$8_SensorBand as SensorBand, index$8_SensorDiscoveryService as SensorDiscoveryService, index$8_SensorRegistry as SensorRegistry, type index$8_UnsignedObservationWitness as UnsignedObservationWitness, index$8_buildQueueMessage as buildQueueMessage, index$8_buildUnsignedWitness as buildUnsignedWitness, index$8_canonicalizeObservation as canonicalizeObservation, index$8_createObservation as createObservation, index$8_decodeQueueMessage as decodeQueueMessage, index$8_encodeQueueMessage as encodeQueueMessage, index$8_endStage as endStage, index$8_finalizeObservation as finalizeObservation, index$8_getAxisExecutionContext as getAxisExecutionContext, index$8_hashObservation as hashObservation, index$8_mergeAxisExecutionContext as mergeAxisExecutionContext, index$9 as observation, index$8_parseAutoClaimEntries as parseAutoClaimEntries, index$8_parseStreamEntries as parseStreamEntries, index$8_recordSensor as recordSensor, index$8_stableJsonStringify as stableJsonStringify, index$8_startStage as startStage, index$8_verifyResponse as verifyResponse, index$8_withAxisExecutionContext as withAxisExecutionContext };
+}
+
+type index$7_AlternativeIntent = AlternativeIntent;
+type index$7_ClarificationQuestion = ClarificationQuestion;
+type index$7_CompilationError = CompilationError;
+type index$7_CompilationResult = CompilationResult;
+type index$7_CompiledIntent = CompiledIntent;
+type index$7_ConstraintKind = ConstraintKind;
+type index$7_IdelCompiler = IdelCompiler;
+declare const index$7_IdelCompiler: typeof IdelCompiler;
+type index$7_IdelSchemaRegistry = IdelSchemaRegistry;
+declare const index$7_IdelSchemaRegistry: typeof IdelSchemaRegistry;
+type index$7_IntentConstraint = IntentConstraint;
+type index$7_IntentParamSchema = IntentParamSchema;
+type index$7_IntentProposal = IntentProposal;
+type index$7_IntentRisk = IntentRisk;
+type index$7_IntentSchema = IntentSchema;
+type index$7_RiskLevel = RiskLevel;
 declare namespace index$7 {
-  export { index$7_AXIS_ANONYMOUS_KEY as AXIS_ANONYMOUS_KEY, index$7_AXIS_META_KEY as AXIS_META_KEY, index$7_AXIS_PUBLIC_KEY as AXIS_PUBLIC_KEY, index$7_AXIS_RATE_LIMIT_KEY as AXIS_RATE_LIMIT_KEY, index$7_Axis as Axis, index$7_AxisAnonymous as AxisAnonymous, index$7_AxisContext as AxisContext, index$7_AxisDemoPubkey as AxisDemoPubkey, index$7_AxisFrame as AxisFrame, index$7_AxisIp as AxisIp, type index$7_AxisObserverBinding as AxisObserverBinding, type index$7_AxisObserverBindingOptions as AxisObserverBindingOptions, type index$7_AxisObserverDefinition as AxisObserverDefinition, type index$7_AxisObserverRef as AxisObserverRef, index$7_AxisPublic as AxisPublic, index$7_AxisRateLimit as AxisRateLimit, type index$7_AxisRateLimitConfig as AxisRateLimitConfig, index$7_AxisRaw as AxisRaw, type index$7_AxisRequestData as AxisRequestData, index$7_CAPSULE_POLICY_METADATA_KEY as CAPSULE_POLICY_METADATA_KEY, index$7_CHAIN_METADATA_KEY as CHAIN_METADATA_KEY, index$7_CONTRACT_METADATA_KEY as CONTRACT_METADATA_KEY, index$7_Capsule as Capsule, index$7_CapsulePolicy as CapsulePolicy, type index$7_CapsulePolicyOptions as CapsulePolicyOptions, type index$7_CapsuleScopeMode as CapsuleScopeMode, index$7_Chain as Chain, index$7_Contract as Contract, type index$7_DtoSchema as DtoSchema, index$7_HANDLER_METADATA_KEY as HANDLER_METADATA_KEY, index$7_Handler as Handler, index$7_INTENT_BODY_KEY as INTENT_BODY_KEY, index$7_INTENT_METADATA_KEY as INTENT_METADATA_KEY, index$7_INTENT_ROUTES_KEY as INTENT_ROUTES_KEY, index$7_INTENT_SENSORS_KEY as INTENT_SENSORS_KEY, index$7_Intent as Intent, index$7_IntentBody as IntentBody, type index$7_IntentKind as IntentKind, type index$7_IntentOptions as IntentOptions, type index$7_IntentRoute as IntentRoute, index$7_IntentSensors as IntentSensors, type index$7_IntentTlvField as IntentTlvField, index$7_OBSERVER_BINDINGS_KEY as OBSERVER_BINDINGS_KEY, index$7_OBSERVER_METADATA_KEY as OBSERVER_METADATA_KEY, index$7_Observer as Observer, index$7_REQUIRED_PROOF_METADATA_KEY as REQUIRED_PROOF_METADATA_KEY, index$7_RequiredProof as RequiredProof, type index$7_RequiredProofKind as RequiredProofKind, index$7_SENSITIVITY_METADATA_KEY as SENSITIVITY_METADATA_KEY, index$7_SENSOR_METADATA_KEY as SENSOR_METADATA_KEY, index$7_Sensitivity as Sensitivity, index$7_Sensor as Sensor, type index$7_SensorOptions as SensorOptions, type index$7_SensorPhase as SensorPhase, index$7_TLV_FIELDS_KEY as TLV_FIELDS_KEY, index$7_TLV_VALIDATORS_KEY as TLV_VALIDATORS_KEY, index$7_TlvEnum as TlvEnum, index$7_TlvField as TlvField, type index$7_TlvFieldKind as TlvFieldKind, type index$7_TlvFieldMeta as TlvFieldMeta, type index$7_TlvFieldOptions as TlvFieldOptions, index$7_TlvMinLen as TlvMinLen, index$7_TlvRange as TlvRange, index$7_TlvUtf8Pattern as TlvUtf8Pattern, index$7_TlvValidate as TlvValidate, type index$7_TlvValidatorFn as TlvValidatorFn, type index$7_TlvValidatorMeta as TlvValidatorMeta, index$7_Witness as Witness, index$7_buildDtoDecoder as buildDtoDecoder, index$7_extractDtoSchema as extractDtoSchema, index$7_mergeCapsulePolicyOptions as mergeCapsulePolicyOptions, index$7_normalizeCapsulePolicyOptions as normalizeCapsulePolicyOptions };
-}
-
-type index$6_ObservationQueueConfig = ObservationQueueConfig;
-type index$6_ObservationQueueMessage = ObservationQueueMessage;
-type index$6_ObservationStreamEntry = ObservationStreamEntry;
-type index$6_ObservationWitnessSummary = ObservationWitnessSummary;
-type index$6_ObserverVerdict = ObserverVerdict;
-type index$6_ResponseContract = ResponseContract;
-declare const index$6_ResponseObserver: typeof ResponseObserver;
-type index$6_ResponseObserverContext = ResponseObserverContext;
-type index$6_UnsignedObservationWitness = UnsignedObservationWitness;
-declare const index$6_buildQueueMessage: typeof buildQueueMessage;
-declare const index$6_buildUnsignedWitness: typeof buildUnsignedWitness;
-declare const index$6_canonicalizeObservation: typeof canonicalizeObservation;
-declare const index$6_decodeQueueMessage: typeof decodeQueueMessage;
-declare const index$6_encodeQueueMessage: typeof encodeQueueMessage;
-declare const index$6_hashObservation: typeof hashObservation;
-declare const index$6_parseAutoClaimEntries: typeof parseAutoClaimEntries;
-declare const index$6_parseStreamEntries: typeof parseStreamEntries;
-declare const index$6_stableJsonStringify: typeof stableJsonStringify;
-declare const index$6_verifyResponse: typeof verifyResponse;
+  export { type index$7_AlternativeIntent as AlternativeIntent, type index$7_ClarificationQuestion as ClarificationQuestion, type index$7_CompilationError as CompilationError, type index$7_CompilationResult as CompilationResult, type index$7_CompiledIntent as CompiledIntent, type index$7_ConstraintKind as ConstraintKind, index$7_IdelCompiler as IdelCompiler, index$7_IdelSchemaRegistry as IdelSchemaRegistry, type index$7_IntentConstraint as IntentConstraint, type index$7_IntentParamSchema as IntentParamSchema, type index$7_IntentProposal as IntentProposal, type index$7_IntentRisk as IntentRisk, type index$7_IntentSchema as IntentSchema, type index$7_RiskLevel as RiskLevel };
+}
+
+type index$6_Grant = Grant;
+type index$6_GrantCapability = GrantCapability;
+type index$6_GrantMeta = GrantMeta;
+type index$6_GrantStatus = GrantStatus;
+type index$6_GrantType = GrantType;
+type index$6_GrantValidationResult = GrantValidationResult;
+type index$6_LoomExecutionResult = LoomExecutionResult;
+type index$6_LoomReceipt = LoomReceipt;
+type index$6_LoomValidationResult = LoomValidationResult;
+declare const index$6_PROOF_LOOM: typeof PROOF_LOOM;
+type index$6_PresenceChallenge = PresenceChallenge;
+type index$6_PresenceDeclaration = PresenceDeclaration;
+type index$6_PresenceProof = PresenceProof;
+type index$6_PresenceReceipt = PresenceReceipt;
+type index$6_PresenceStatus = PresenceStatus;
+type index$6_PresenceVerifyResult = PresenceVerifyResult;
+type index$6_Revocation = Revocation;
+type index$6_RevocationTargetType = RevocationTargetType;
+type index$6_ThreadState = ThreadState;
+type index$6_Writ = Writ;
+type index$6_WritBody = WritBody;
+type index$6_WritHead = WritHead;
+type index$6_WritMeta = WritMeta;
+type index$6_WritSignature = WritSignature;
+type index$6_WritValidationResult = WritValidationResult;
+declare const index$6_canonicalizeGrant: typeof canonicalizeGrant;
+declare const index$6_canonicalizeWrit: typeof canonicalizeWrit;
+declare const index$6_createGrant: typeof createGrant;
+declare const index$6_createPresenceChallenge: typeof createPresenceChallenge;
+declare const index$6_createReceipt: typeof createReceipt;
+declare const index$6_createRevocation: typeof createRevocation;
+declare const index$6_createWrit: typeof createWrit;
+declare const index$6_deriveAnchorReflection: typeof deriveAnchorReflection;
+declare const index$6_executeLoomPipeline: typeof executeLoomPipeline;
+declare const index$6_getGrantStatus: typeof getGrantStatus;
+declare const index$6_getPresenceStatus: typeof getPresenceStatus;
+declare const index$6_grantCoversAction: typeof grantCoversAction;
+declare const index$6_isRevoked: typeof isRevoked;
+declare const index$6_renewPresence: typeof renewPresence;
+declare const index$6_signPresenceChallenge: typeof signPresenceChallenge;
+declare const index$6_updateThreadState: typeof updateThreadState;
+declare const index$6_validateGrant: typeof validateGrant;
+declare const index$6_validateWrit: typeof validateWrit;
+declare const index$6_verifyPresenceProof: typeof verifyPresenceProof;
+declare const index$6_verifyReceiptChain: typeof verifyReceiptChain;
 declare namespace index$6 {
-  export { type index$6_ObservationQueueConfig as ObservationQueueConfig, type index$6_ObservationQueueMessage as ObservationQueueMessage, type index$6_ObservationStreamEntry as ObservationStreamEntry, type index$6_ObservationWitnessSummary as ObservationWitnessSummary, type index$6_ObserverVerdict as ObserverVerdict, type index$6_ResponseContract as ResponseContract, index$6_ResponseObserver as ResponseObserver, type index$6_ResponseObserverContext as ResponseObserverContext, type index$6_UnsignedObservationWitness as UnsignedObservationWitness, index$6_buildQueueMessage as buildQueueMessage, index$6_buildUnsignedWitness as buildUnsignedWitness, index$6_canonicalizeObservation as canonicalizeObservation, index$6_decodeQueueMessage as decodeQueueMessage, index$6_encodeQueueMessage as encodeQueueMessage, index$6_hashObservation as hashObservation, index$6_parseAutoClaimEntries as parseAutoClaimEntries, index$6_parseStreamEntries as parseStreamEntries, index$6_stableJsonStringify as stableJsonStringify, index$6_verifyResponse as verifyResponse };
-}
-
-declare const index$5_AXIS_EXECUTION_CONTEXT_KEY: typeof AXIS_EXECUTION_CONTEXT_KEY;
-type index$5_AxisCapsuleRef = AxisCapsuleRef;
-type index$5_AxisChainEncryption = AxisChainEncryption;
-type index$5_AxisChainEnvelope<TInput = unknown> = AxisChainEnvelope<TInput>;
-type index$5_AxisChainExecutionOptions = AxisChainExecutionOptions;
-type index$5_AxisChainExecutor = AxisChainExecutor;
-declare const index$5_AxisChainExecutor: typeof AxisChainExecutor;
-type index$5_AxisChainRequest<TInput = unknown, TCapsule = Record<string, unknown>> = AxisChainRequest<TInput, TCapsule>;
-type index$5_AxisChainResult<TOutput = unknown> = AxisChainResult<TOutput>;
-type index$5_AxisChainStatus = AxisChainStatus;
-type index$5_AxisChainStep<TInput = unknown> = AxisChainStep<TInput>;
-type index$5_AxisChainStepResult<TOutput = unknown> = AxisChainStepResult<TOutput>;
-type index$5_AxisChainStepStatus = AxisChainStepStatus;
-type index$5_AxisDecoded = AxisDecoded;
-type index$5_AxisEffect = AxisEffect;
-type index$5_AxisExecutionContext = AxisExecutionContext;
-type index$5_AxisExecutionMode = AxisExecutionMode;
-type index$5_AxisIntentEnvelope<TPayload = unknown> = AxisIntentEnvelope<TPayload>;
-type index$5_AxisIntentObserver = AxisIntentObserver;
-type index$5_AxisKeyExchangeRef = AxisKeyExchangeRef;
-type index$5_AxisObservation = AxisObservation;
-type index$5_AxisObserverContext = AxisObserverContext;
-type index$5_AxisObserverEvent = AxisObserverEvent;
-type index$5_AxisObserverRegistration = AxisObserverRegistration;
-declare const index$5_BAND: typeof BAND;
-type index$5_ChainOptions = ChainOptions;
-type index$5_HandlerDiscoveryService = HandlerDiscoveryService;
-declare const index$5_HandlerDiscoveryService: typeof HandlerDiscoveryService;
-type index$5_IntentRouter = IntentRouter;
-declare const index$5_IntentRouter: typeof IntentRouter;
-type index$5_IntentSchema = IntentSchema;
-type index$5_ObservationQueueConfig = ObservationQueueConfig;
-type index$5_ObservationQueueMessage = ObservationQueueMessage;
-type index$5_ObservationSensor = ObservationSensor;
-type index$5_ObservationStage = ObservationStage;
-type index$5_ObservationStreamEntry = ObservationStreamEntry;
-type index$5_ObservationWitnessSummary = ObservationWitnessSummary;
-type index$5_ObserverDiscoveryService = ObserverDiscoveryService;
-declare const index$5_ObserverDiscoveryService: typeof ObserverDiscoveryService;
-type index$5_ObserverDispatcherService = ObserverDispatcherService;
-declare const index$5_ObserverDispatcherService: typeof ObserverDispatcherService;
-type index$5_ObserverRegistry = ObserverRegistry;
-declare const index$5_ObserverRegistry: typeof ObserverRegistry;
-type index$5_ObserverVerdict = ObserverVerdict;
-declare const index$5_PRE_DECODE_BOUNDARY: typeof PRE_DECODE_BOUNDARY;
-type index$5_RegisteredChainConfig = RegisteredChainConfig;
-type index$5_ResponseContract = ResponseContract;
-declare const index$5_ResponseObserver: typeof ResponseObserver;
-type index$5_ResponseObserverContext = ResponseObserverContext;
-type index$5_SensorBand = SensorBand;
-type index$5_SensorDiscoveryService = SensorDiscoveryService;
-declare const index$5_SensorDiscoveryService: typeof SensorDiscoveryService;
-type index$5_SensorRegistry = SensorRegistry;
-declare const index$5_SensorRegistry: typeof SensorRegistry;
-type index$5_UnsignedObservationWitness = UnsignedObservationWitness;
-declare const index$5_buildQueueMessage: typeof buildQueueMessage;
-declare const index$5_buildUnsignedWitness: typeof buildUnsignedWitness;
-declare const index$5_canonicalizeObservation: typeof canonicalizeObservation;
-declare const index$5_createObservation: typeof createObservation;
-declare const index$5_decodeQueueMessage: typeof decodeQueueMessage;
-declare const index$5_encodeQueueMessage: typeof encodeQueueMessage;
-declare const index$5_endStage: typeof endStage;
-declare const index$5_finalizeObservation: typeof finalizeObservation;
-declare const index$5_getAxisExecutionContext: typeof getAxisExecutionContext;
-declare const index$5_hashObservation: typeof hashObservation;
-declare const index$5_mergeAxisExecutionContext: typeof mergeAxisExecutionContext;
-declare const index$5_parseAutoClaimEntries: typeof parseAutoClaimEntries;
-declare const index$5_parseStreamEntries: typeof parseStreamEntries;
-declare const index$5_recordSensor: typeof recordSensor;
-declare const index$5_stableJsonStringify: typeof stableJsonStringify;
-declare const index$5_startStage: typeof startStage;
-declare const index$5_verifyResponse: typeof verifyResponse;
-declare const index$5_withAxisExecutionContext: typeof withAxisExecutionContext;
+  export { type index$6_Grant as Grant, type index$6_GrantCapability as GrantCapability, type index$6_GrantMeta as GrantMeta, type index$6_GrantStatus as GrantStatus, type index$6_GrantType as GrantType, type index$6_GrantValidationResult as GrantValidationResult, type index$6_LoomExecutionResult as LoomExecutionResult, type index$6_LoomReceipt as LoomReceipt, type index$6_LoomValidationResult as LoomValidationResult, index$6_PROOF_LOOM as PROOF_LOOM, type index$6_PresenceChallenge as PresenceChallenge, type index$6_PresenceDeclaration as PresenceDeclaration, type index$6_PresenceProof as PresenceProof, type index$6_PresenceReceipt as PresenceReceipt, type index$6_PresenceStatus as PresenceStatus, type index$6_PresenceVerifyResult as PresenceVerifyResult, type index$6_Revocation as Revocation, type index$6_RevocationTargetType as RevocationTargetType, TLV_LOOM_PRESENCE_ID as TLV_PRESENCE_ID, TLV_LOOM_THREAD_HASH as TLV_THREAD_HASH, TLV_LOOM_WRIT as TLV_WRIT, type index$6_ThreadState as ThreadState, type index$6_Writ as Writ, type index$6_WritBody as WritBody, type index$6_WritHead as WritHead, type index$6_WritMeta as WritMeta, type index$6_WritSignature as WritSignature, type index$6_WritValidationResult as WritValidationResult, index$6_canonicalizeGrant as canonicalizeGrant, index$6_canonicalizeWrit as canonicalizeWrit, index$6_createGrant as createGrant, index$6_createPresenceChallenge as createPresenceChallenge, index$6_createReceipt as createReceipt, index$6_createRevocation as createRevocation, index$6_createWrit as createWrit, index$6_deriveAnchorReflection as deriveAnchorReflection, index$6_executeLoomPipeline as executeLoomPipeline, index$6_getGrantStatus as getGrantStatus, index$6_getPresenceStatus as getPresenceStatus, index$6_grantCoversAction as grantCoversAction, index$6_isRevoked as isRevoked, index$6_renewPresence as renewPresence, index$6_signPresenceChallenge as signPresenceChallenge, index$6_updateThreadState as updateThreadState, index$6_validateGrant as validateGrant, index$6_validateWrit as validateWrit, index$6_verifyPresenceProof as verifyPresenceProof, index$6_verifyReceiptChain as verifyReceiptChain };
+}
+
+type index$5_Fabric = Fabric;
+type index$5_FabricCell = FabricCell;
+type index$5_FabricDiff = FabricDiff;
+type index$5_FabricDiffEntry = FabricDiffEntry;
+type index$5_FabricDiffKind = FabricDiffKind;
+type index$5_FabricEffect = FabricEffect;
+type index$5_FabricEffectResolver = FabricEffectResolver;
+type index$5_FabricQuery = FabricQuery;
+type index$5_InMemoryPatternStore = InMemoryPatternStore;
+declare const index$5_InMemoryPatternStore: typeof InMemoryPatternStore;
+type index$5_Knot = Knot;
+type index$5_KnotBreakRequest = KnotBreakRequest;
+type index$5_KnotError = KnotError;
+type index$5_KnotStatus = KnotStatus;
+type index$5_KnotType = KnotType;
+type index$5_KnotValidationResult = KnotValidationResult;
+type index$5_Needle = Needle;
+type index$5_NeedleError = NeedleError;
+type index$5_NeedleHandler = NeedleHandler;
+type index$5_NeedleHandlerContext = NeedleHandlerContext;
+type index$5_NeedleHandlerResult = NeedleHandlerResult;
+type index$5_NeedlePhase = NeedlePhase;
+type index$5_NeedlePipelineConfig = NeedlePipelineConfig;
+type index$5_NeedlePipelineResult = NeedlePipelineResult;
+type index$5_OpenKnotParams = OpenKnotParams;
+type index$5_Pattern = Pattern;
+type index$5_PatternConfidence = PatternConfidence;
+type index$5_PatternKind = PatternKind;
+type index$5_PatternMatch = PatternMatch;
+type index$5_PatternPrediction = PatternPrediction;
+type index$5_PatternSignature = PatternSignature;
+type index$5_PatternStore = PatternStore;
+type index$5_Stitch = Stitch;
+type index$5_StitchKind = StitchKind;
+type index$5_Thread = Thread;
+declare const index$5_addStitchToKnot: typeof addStitchToKnot;
+declare const index$5_applyStitch: typeof applyStitch;
+declare const index$5_assembleNeedle: typeof assembleNeedle;
+declare const index$5_breakKnot: typeof breakKnot;
+declare const index$5_createFabric: typeof createFabric;
+declare const index$5_detectAnomalies: typeof detectAnomalies;
+declare const index$5_detectKnotPatterns: typeof detectKnotPatterns;
+declare const index$5_detectSequencePatterns: typeof detectSequencePatterns;
+declare const index$5_diffFabrics: typeof diffFabrics;
+declare const index$5_findKnotsForStitch: typeof findKnotsForStitch;
+declare const index$5_forkFromKnot: typeof forkFromKnot;
+declare const index$5_formStitch: typeof formStitch;
+declare const index$5_getDecisionPoints: typeof getDecisionPoints;
+declare const index$5_getFabricValue: typeof getFabricValue;
+declare const index$5_getIrreversibleKnots: typeof getIrreversibleKnots;
+declare const index$5_isKnotOpen: typeof isKnotOpen;
+declare const index$5_isPointOfNoReturn: typeof isPointOfNoReturn;
+declare const index$5_lockCells: typeof lockCells;
+declare const index$5_matchPatterns: typeof matchPatterns;
+declare const index$5_openKnot: typeof openKnot;
+declare const index$5_projectAt: typeof projectAt;
+declare const index$5_queryFabric: typeof queryFabric;
+declare const index$5_recordOccurrence: typeof recordOccurrence;
+declare const index$5_runNeedlePipeline: typeof runNeedlePipeline;
+declare const index$5_tieKnot: typeof tieKnot;
+declare const index$5_validateKnot: typeof validateKnot;
+declare const index$5_weave: typeof weave;
 declare namespace index$5 {
-  export { index$5_AXIS_EXECUTION_CONTEXT_KEY as AXIS_EXECUTION_CONTEXT_KEY, type index$5_AxisCapsuleRef as AxisCapsuleRef, type index$5_AxisChainEncryption as AxisChainEncryption, type index$5_AxisChainEnvelope as AxisChainEnvelope, type index$5_AxisChainExecutionOptions as AxisChainExecutionOptions, index$5_AxisChainExecutor as AxisChainExecutor, type index$5_AxisChainRequest as AxisChainRequest, type index$5_AxisChainResult as AxisChainResult, type index$5_AxisChainStatus as AxisChainStatus, type index$5_AxisChainStep as AxisChainStep, type index$5_AxisChainStepResult as AxisChainStepResult, type index$5_AxisChainStepStatus as AxisChainStepStatus, type index$5_AxisDecoded as AxisDecoded, type index$5_AxisEffect as AxisEffect, type index$5_AxisExecutionContext as AxisExecutionContext, type index$5_AxisExecutionMode as AxisExecutionMode, type index$5_AxisIntentEnvelope as AxisIntentEnvelope, type index$5_AxisIntentObserver as AxisIntentObserver, type index$5_AxisKeyExchangeRef as AxisKeyExchangeRef, type index$5_AxisObservation as AxisObservation, type index$5_AxisObserverContext as AxisObserverContext, type index$5_AxisObserverEvent as AxisObserverEvent, type index$5_AxisObserverRegistration as AxisObserverRegistration, index$5_BAND as BAND, type index$5_ChainOptions as ChainOptions, index$5_HandlerDiscoveryService as HandlerDiscoveryService, index$5_IntentRouter as IntentRouter, type index$5_IntentSchema as IntentSchema, type index$5_ObservationQueueConfig as ObservationQueueConfig, type index$5_ObservationQueueMessage as ObservationQueueMessage, type index$5_ObservationSensor as ObservationSensor, type index$5_ObservationStage as ObservationStage, type index$5_ObservationStreamEntry as ObservationStreamEntry, type index$5_ObservationWitnessSummary as ObservationWitnessSummary, index$5_ObserverDiscoveryService as ObserverDiscoveryService, index$5_ObserverDispatcherService as ObserverDispatcherService, index$5_ObserverRegistry as ObserverRegistry, type index$5_ObserverVerdict as ObserverVerdict, index$5_PRE_DECODE_BOUNDARY as PRE_DECODE_BOUNDARY, type index$5_RegisteredChainConfig as RegisteredChainConfig, type index$5_ResponseContract as ResponseContract, index$5_ResponseObserver as ResponseObserver, type index$5_ResponseObserverContext as ResponseObserverContext, type index$5_SensorBand as SensorBand, index$5_SensorDiscoveryService as SensorDiscoveryService, index$5_SensorRegistry as SensorRegistry, type index$5_UnsignedObservationWitness as UnsignedObservationWitness, index$5_buildQueueMessage as buildQueueMessage, index$5_buildUnsignedWitness as buildUnsignedWitness, index$5_canonicalizeObservation as canonicalizeObservation, index$5_createObservation as createObservation, index$5_decodeQueueMessage as decodeQueueMessage, index$5_encodeQueueMessage as encodeQueueMessage, index$5_endStage as endStage, index$5_finalizeObservation as finalizeObservation, index$5_getAxisExecutionContext as getAxisExecutionContext, index$5_hashObservation as hashObservation, index$5_mergeAxisExecutionContext as mergeAxisExecutionContext, index$6 as observation, index$5_parseAutoClaimEntries as parseAutoClaimEntries, index$5_parseStreamEntries as parseStreamEntries, index$5_recordSensor as recordSensor, index$5_stableJsonStringify as stableJsonStringify, index$5_startStage as startStage, index$5_verifyResponse as verifyResponse, index$5_withAxisExecutionContext as withAxisExecutionContext };
-}
-
-type index$4_Grant = Grant;
-type index$4_GrantCapability = GrantCapability;
-type index$4_GrantMeta = GrantMeta;
-type index$4_GrantStatus = GrantStatus;
-type index$4_GrantType = GrantType;
-type index$4_GrantValidationResult = GrantValidationResult;
-type index$4_LoomReceipt = LoomReceipt;
-type index$4_LoomValidationResult = LoomValidationResult;
-declare const index$4_PROOF_LOOM: typeof PROOF_LOOM;
-type index$4_PresenceChallenge = PresenceChallenge;
-type index$4_PresenceDeclaration = PresenceDeclaration;
-type index$4_PresenceProof = PresenceProof;
-type index$4_PresenceReceipt = PresenceReceipt;
-type index$4_PresenceStatus = PresenceStatus;
-type index$4_PresenceVerifyResult = PresenceVerifyResult;
-type index$4_Revocation = Revocation;
-type index$4_RevocationTargetType = RevocationTargetType;
-type index$4_ThreadState = ThreadState;
-type index$4_Writ = Writ;
-type index$4_WritBody = WritBody;
-type index$4_WritHead = WritHead;
-type index$4_WritMeta = WritMeta;
-type index$4_WritSignature = WritSignature;
-type index$4_WritValidationResult = WritValidationResult;
-declare const index$4_canonicalizeGrant: typeof canonicalizeGrant;
-declare const index$4_canonicalizeWrit: typeof canonicalizeWrit;
-declare const index$4_deriveAnchorReflection: typeof deriveAnchorReflection;
-declare namespace index$4 {
-  export { type index$4_Grant as Grant, type index$4_GrantCapability as GrantCapability, type index$4_GrantMeta as GrantMeta, type index$4_GrantStatus as GrantStatus, type index$4_GrantType as GrantType, type index$4_GrantValidationResult as GrantValidationResult, type index$4_LoomReceipt as LoomReceipt, type index$4_LoomValidationResult as LoomValidationResult, index$4_PROOF_LOOM as PROOF_LOOM, type index$4_PresenceChallenge as PresenceChallenge, type index$4_PresenceDeclaration as PresenceDeclaration, type index$4_PresenceProof as PresenceProof, type index$4_PresenceReceipt as PresenceReceipt, type index$4_PresenceStatus as PresenceStatus, type index$4_PresenceVerifyResult as PresenceVerifyResult, type index$4_Revocation as Revocation, type index$4_RevocationTargetType as RevocationTargetType, TLV_LOOM_PRESENCE_ID as TLV_PRESENCE_ID, TLV_LOOM_THREAD_HASH as TLV_THREAD_HASH, TLV_LOOM_WRIT as TLV_WRIT, type index$4_ThreadState as ThreadState, type index$4_Writ as Writ, type index$4_WritBody as WritBody, type index$4_WritHead as WritHead, type index$4_WritMeta as WritMeta, type index$4_WritSignature as WritSignature, type index$4_WritValidationResult as WritValidationResult, index$4_canonicalizeGrant as canonicalizeGrant, index$4_canonicalizeWrit as canonicalizeWrit, index$4_deriveAnchorReflection as deriveAnchorReflection };
+  export { type index$5_Fabric as Fabric, type index$5_FabricCell as FabricCell, type index$5_FabricDiff as FabricDiff, type index$5_FabricDiffEntry as FabricDiffEntry, type index$5_FabricDiffKind as FabricDiffKind, type index$5_FabricEffect as FabricEffect, type index$5_FabricEffectResolver as FabricEffectResolver, type index$5_FabricQuery as FabricQuery, index$5_InMemoryPatternStore as InMemoryPatternStore, type index$5_Knot as Knot, type index$5_KnotBreakRequest as KnotBreakRequest, type index$5_KnotError as KnotError, type index$5_KnotStatus as KnotStatus, type index$5_KnotType as KnotType, type index$5_KnotValidationResult as KnotValidationResult, type index$5_Needle as Needle, type index$5_NeedleError as NeedleError, type index$5_NeedleHandler as NeedleHandler, type index$5_NeedleHandlerContext as NeedleHandlerContext, type index$5_NeedleHandlerResult as NeedleHandlerResult, type index$5_NeedlePhase as NeedlePhase, type index$5_NeedlePipelineConfig as NeedlePipelineConfig, type index$5_NeedlePipelineResult as NeedlePipelineResult, type index$5_OpenKnotParams as OpenKnotParams, type index$5_Pattern as Pattern, type index$5_PatternConfidence as PatternConfidence, type index$5_PatternKind as PatternKind, type index$5_PatternMatch as PatternMatch, type index$5_PatternPrediction as PatternPrediction, type index$5_PatternSignature as PatternSignature, type index$5_PatternStore as PatternStore, type index$5_Stitch as Stitch, type index$5_StitchKind as StitchKind, type index$5_Thread as Thread, index$5_addStitchToKnot as addStitchToKnot, index$5_applyStitch as applyStitch, index$5_assembleNeedle as assembleNeedle, index$5_breakKnot as breakKnot, index$5_createFabric as createFabric, index$5_detectAnomalies as detectAnomalies, index$5_detectKnotPatterns as detectKnotPatterns, index$5_detectSequencePatterns as detectSequencePatterns, index$5_diffFabrics as diffFabrics, index$5_findKnotsForStitch as findKnotsForStitch, index$5_forkFromKnot as forkFromKnot, index$5_formStitch as formStitch, index$5_getDecisionPoints as getDecisionPoints, index$5_getFabricValue as getFabricValue, index$5_getIrreversibleKnots as getIrreversibleKnots, index$5_isKnotOpen as isKnotOpen, index$5_isPointOfNoReturn as isPointOfNoReturn, index$5_lockCells as lockCells, index$5_matchPatterns as matchPatterns, index$5_openKnot as openKnot, index$5_projectAt as projectAt, index$5_queryFabric as queryFabric, index$5_recordOccurrence as recordOccurrence, index$5_runNeedlePipeline as runNeedlePipeline, index$5_tieKnot as tieKnot, index$5_validateKnot as validateKnot, index$5_weave as weave };
 }
 
 declare enum BodyProfile {
@@ -3002,108 +3835,108 @@ declare class BodyProfileValidator {
     private validateArr;
 }
 
-type index$3_AccessProfile = AccessProfile;
-declare const index$3_AccessProfileZ: typeof AccessProfileZ;
-declare const index$3_AxisContextZ: typeof AxisContextZ;
-type index$3_AxisError = AxisError;
-declare const index$3_AxisErrorZ: typeof AxisErrorZ;
-type index$3_BodyBudgetInput = BodyBudgetInput;
-declare const index$3_BodyBudgetInputZ: typeof BodyBudgetInputZ;
-type index$3_BodyBudgetPolicy = BodyBudgetPolicy;
-declare const index$3_BodyBudgetPolicyZ: typeof BodyBudgetPolicyZ;
-type index$3_BodyProfile = BodyProfile;
-declare const index$3_BodyProfile: typeof BodyProfile;
-type index$3_BodyProfileValidation = BodyProfileValidation;
-type index$3_BodyProfileValidator = BodyProfileValidator;
-declare const index$3_BodyProfileValidator: typeof BodyProfileValidator;
-declare const index$3_BodyProfileZ: typeof BodyProfileZ;
-type index$3_CapsuleClaims = CapsuleClaims;
-declare const index$3_CapsuleClaimsZ: typeof CapsuleClaimsZ;
-type index$3_CapsuleValidationResult = CapsuleValidationResult;
-declare const index$3_CapsuleValidationResultZ: typeof CapsuleValidationResultZ;
-type index$3_CapsuleVerifyResult = CapsuleVerifyResult;
-declare const index$3_CapsuleVerifyResultZ: typeof CapsuleVerifyResultZ;
-type index$3_CapsuleVerifySensorInput = CapsuleVerifySensorInput;
-declare const index$3_CapsuleVerifySensorInputZ: typeof CapsuleVerifySensorInputZ;
-declare const index$3_CapsuleZ: typeof CapsuleZ;
-type index$3_ChunkHashInput = ChunkHashInput;
-declare const index$3_ChunkHashInputZ: typeof ChunkHashInputZ;
-type index$3_CountryBlockDecision = CountryBlockDecision;
-declare const index$3_CountryBlockDecisionZ: typeof CountryBlockDecisionZ;
-type index$3_CountryBlockSensorInput = CountryBlockSensorInput;
-declare const index$3_CountryBlockSensorInputZ: typeof CountryBlockSensorInputZ;
-type index$3_EntropySensorInput = EntropySensorInput;
-declare const index$3_EntropySensorInputZ: typeof EntropySensorInputZ;
-declare const index$3_ExecutionMetricsZ: typeof ExecutionMetricsZ;
-type index$3_IPReputation = IPReputation;
-type index$3_IPReputationInput = IPReputationInput;
-declare const index$3_IPReputationInputZ: typeof IPReputationInputZ;
-declare const index$3_IPReputationZ: typeof IPReputationZ;
-type index$3_IntentPolicy = IntentPolicy;
-type index$3_IntentPolicyDecision = IntentPolicyDecision;
-declare const index$3_IntentPolicyDecisionZ: typeof IntentPolicyDecisionZ;
-type index$3_IntentPolicySensorInput = IntentPolicySensorInput;
-declare const index$3_IntentPolicySensorInputZ: typeof IntentPolicySensorInputZ;
-declare const index$3_IntentPolicyZ: typeof IntentPolicyZ;
-declare const index$3_IntentSchemaZ: typeof IntentSchemaZ;
-type index$3_Passport = Passport;
-declare const index$3_PassportZ: typeof PassportZ;
-type index$3_ProofKind = ProofKind;
-declare const index$3_ProofKindZ: typeof ProofKindZ;
-type index$3_ProofPresenceInput = ProofPresenceInput;
-declare const index$3_ProofPresenceInputZ: typeof ProofPresenceInputZ;
-type index$3_ProtocolStrictInput = ProtocolStrictInput;
-declare const index$3_ProtocolStrictInputZ: typeof ProtocolStrictInputZ;
-type index$3_RateLimitConfig = RateLimitConfig;
-declare const index$3_RateLimitConfigZ: typeof RateLimitConfigZ;
-type index$3_RateLimitInput = RateLimitInput;
-declare const index$3_RateLimitInputZ: typeof RateLimitInputZ;
-type index$3_RateLimitProfile = RateLimitProfile;
-declare const index$3_RateLimitProfileZ: typeof RateLimitProfileZ;
-type index$3_ScanBurstDecision = ScanBurstDecision;
-declare const index$3_ScanBurstDecisionZ: typeof ScanBurstDecisionZ;
-type index$3_ScanBurstSensorInput = ScanBurstSensorInput;
-declare const index$3_ScanBurstSensorInputZ: typeof ScanBurstSensorInputZ;
-type index$3_SchemaField = SchemaField;
-type index$3_SchemaFieldKind = SchemaFieldKind;
-declare const index$3_SchemaFieldKindZ: typeof SchemaFieldKindZ;
-declare const index$3_SchemaFieldZ: typeof SchemaFieldZ;
-type index$3_Scope = Scope;
-declare const index$3_ScopeZ: typeof ScopeZ;
-type index$3_SensitivityLevel = SensitivityLevel;
-declare const index$3_SensitivityLevelZ: typeof SensitivityLevelZ;
-type index$3_SensorChainInput = SensorChainInput;
-declare const index$3_SensorChainInputZ: typeof SensorChainInputZ;
-declare const index$3_SensorDecisionWithMetadataZ: typeof SensorDecisionWithMetadataZ;
-declare const index$3_SensorDecisionZ: typeof SensorDecisionZ;
-type index$3_SensorResult = SensorResult;
-declare const index$3_SensorResultZ: typeof SensorResultZ;
-type index$3_UploadSession = UploadSession;
-declare const index$3_UploadSessionZ: typeof UploadSessionZ;
-type index$3_UploadStatus = UploadStatus;
-declare const index$3_UploadStatusZ: typeof UploadStatusZ;
-type index$3_WsHandshakeDecision = WsHandshakeDecision;
-declare const index$3_WsHandshakeDecisionZ: typeof WsHandshakeDecisionZ;
-type index$3_WsHandshakeInput = WsHandshakeInput;
-declare const index$3_WsHandshakeInputZ: typeof WsHandshakeInputZ;
+type index$4_AccessProfile = AccessProfile;
+declare const index$4_AccessProfileZ: typeof AccessProfileZ;
+declare const index$4_AxisContextZ: typeof AxisContextZ;
+type index$4_AxisError = AxisError;
+declare const index$4_AxisErrorZ: typeof AxisErrorZ;
+type index$4_BodyBudgetInput = BodyBudgetInput;
+declare const index$4_BodyBudgetInputZ: typeof BodyBudgetInputZ;
+type index$4_BodyBudgetPolicy = BodyBudgetPolicy;
+declare const index$4_BodyBudgetPolicyZ: typeof BodyBudgetPolicyZ;
+type index$4_BodyProfile = BodyProfile;
+declare const index$4_BodyProfile: typeof BodyProfile;
+type index$4_BodyProfileValidation = BodyProfileValidation;
+type index$4_BodyProfileValidator = BodyProfileValidator;
+declare const index$4_BodyProfileValidator: typeof BodyProfileValidator;
+declare const index$4_BodyProfileZ: typeof BodyProfileZ;
+type index$4_CapsuleClaims = CapsuleClaims;
+declare const index$4_CapsuleClaimsZ: typeof CapsuleClaimsZ;
+type index$4_CapsuleValidationResult = CapsuleValidationResult;
+declare const index$4_CapsuleValidationResultZ: typeof CapsuleValidationResultZ;
+type index$4_CapsuleVerifyResult = CapsuleVerifyResult;
+declare const index$4_CapsuleVerifyResultZ: typeof CapsuleVerifyResultZ;
+type index$4_CapsuleVerifySensorInput = CapsuleVerifySensorInput;
+declare const index$4_CapsuleVerifySensorInputZ: typeof CapsuleVerifySensorInputZ;
+declare const index$4_CapsuleZ: typeof CapsuleZ;
+type index$4_ChunkHashInput = ChunkHashInput;
+declare const index$4_ChunkHashInputZ: typeof ChunkHashInputZ;
+type index$4_CountryBlockDecision = CountryBlockDecision;
+declare const index$4_CountryBlockDecisionZ: typeof CountryBlockDecisionZ;
+type index$4_CountryBlockSensorInput = CountryBlockSensorInput;
+declare const index$4_CountryBlockSensorInputZ: typeof CountryBlockSensorInputZ;
+type index$4_EntropySensorInput = EntropySensorInput;
+declare const index$4_EntropySensorInputZ: typeof EntropySensorInputZ;
+declare const index$4_ExecutionMetricsZ: typeof ExecutionMetricsZ;
+type index$4_IPReputation = IPReputation;
+type index$4_IPReputationInput = IPReputationInput;
+declare const index$4_IPReputationInputZ: typeof IPReputationInputZ;
+declare const index$4_IPReputationZ: typeof IPReputationZ;
+type index$4_IntentPolicy = IntentPolicy;
+type index$4_IntentPolicyDecision = IntentPolicyDecision;
+declare const index$4_IntentPolicyDecisionZ: typeof IntentPolicyDecisionZ;
+type index$4_IntentPolicySensorInput = IntentPolicySensorInput;
+declare const index$4_IntentPolicySensorInputZ: typeof IntentPolicySensorInputZ;
+declare const index$4_IntentPolicyZ: typeof IntentPolicyZ;
+declare const index$4_IntentSchemaZ: typeof IntentSchemaZ;
+type index$4_Passport = Passport;
+declare const index$4_PassportZ: typeof PassportZ;
+type index$4_ProofKind = ProofKind;
+declare const index$4_ProofKindZ: typeof ProofKindZ;
+type index$4_ProofPresenceInput = ProofPresenceInput;
+declare const index$4_ProofPresenceInputZ: typeof ProofPresenceInputZ;
+type index$4_ProtocolStrictInput = ProtocolStrictInput;
+declare const index$4_ProtocolStrictInputZ: typeof ProtocolStrictInputZ;
+type index$4_RateLimitConfig = RateLimitConfig;
+declare const index$4_RateLimitConfigZ: typeof RateLimitConfigZ;
+type index$4_RateLimitInput = RateLimitInput;
+declare const index$4_RateLimitInputZ: typeof RateLimitInputZ;
+type index$4_RateLimitProfile = RateLimitProfile;
+declare const index$4_RateLimitProfileZ: typeof RateLimitProfileZ;
+type index$4_ScanBurstDecision = ScanBurstDecision;
+declare const index$4_ScanBurstDecisionZ: typeof ScanBurstDecisionZ;
+type index$4_ScanBurstSensorInput = ScanBurstSensorInput;
+declare const index$4_ScanBurstSensorInputZ: typeof ScanBurstSensorInputZ;
+type index$4_SchemaField = SchemaField;
+type index$4_SchemaFieldKind = SchemaFieldKind;
+declare const index$4_SchemaFieldKindZ: typeof SchemaFieldKindZ;
+declare const index$4_SchemaFieldZ: typeof SchemaFieldZ;
+type index$4_Scope = Scope;
+declare const index$4_ScopeZ: typeof ScopeZ;
+type index$4_SensitivityLevel = SensitivityLevel;
+declare const index$4_SensitivityLevelZ: typeof SensitivityLevelZ;
+type index$4_SensorChainInput = SensorChainInput;
+declare const index$4_SensorChainInputZ: typeof SensorChainInputZ;
+declare const index$4_SensorDecisionWithMetadataZ: typeof SensorDecisionWithMetadataZ;
+declare const index$4_SensorDecisionZ: typeof SensorDecisionZ;
+type index$4_SensorResult = SensorResult;
+declare const index$4_SensorResultZ: typeof SensorResultZ;
+type index$4_UploadSession = UploadSession;
+declare const index$4_UploadSessionZ: typeof UploadSessionZ;
+type index$4_UploadStatus = UploadStatus;
+declare const index$4_UploadStatusZ: typeof UploadStatusZ;
+type index$4_WsHandshakeDecision = WsHandshakeDecision;
+declare const index$4_WsHandshakeDecisionZ: typeof WsHandshakeDecisionZ;
+type index$4_WsHandshakeInput = WsHandshakeInput;
+declare const index$4_WsHandshakeInputZ: typeof WsHandshakeInputZ;
+declare namespace index$4 {
+  export { type index$4_AccessProfile as AccessProfile, index$4_AccessProfileZ as AccessProfileZ, type AxisContext$1 as AxisContext, index$4_AxisContextZ as AxisContextZ, type index$4_AxisError as AxisError, index$4_AxisErrorZ as AxisErrorZ, type index$4_BodyBudgetInput as BodyBudgetInput, index$4_BodyBudgetInputZ as BodyBudgetInputZ, type index$4_BodyBudgetPolicy as BodyBudgetPolicy, index$4_BodyBudgetPolicyZ as BodyBudgetPolicyZ, index$4_BodyProfile as BodyProfile, type index$4_BodyProfileValidation as BodyProfileValidation, index$4_BodyProfileValidator as BodyProfileValidator, index$4_BodyProfileZ as BodyProfileZ, type Capsule$1 as Capsule, type index$4_CapsuleClaims as CapsuleClaims, index$4_CapsuleClaimsZ as CapsuleClaimsZ, type index$4_CapsuleValidationResult as CapsuleValidationResult, index$4_CapsuleValidationResultZ as CapsuleValidationResultZ, type index$4_CapsuleVerifyResult as CapsuleVerifyResult, index$4_CapsuleVerifyResultZ as CapsuleVerifyResultZ, type index$4_CapsuleVerifySensorInput as CapsuleVerifySensorInput, index$4_CapsuleVerifySensorInputZ as CapsuleVerifySensorInputZ, index$4_CapsuleZ as CapsuleZ, type index$4_ChunkHashInput as ChunkHashInput, index$4_ChunkHashInputZ as ChunkHashInputZ, type index$4_CountryBlockDecision as CountryBlockDecision, index$4_CountryBlockDecisionZ as CountryBlockDecisionZ, type index$4_CountryBlockSensorInput as CountryBlockSensorInput, index$4_CountryBlockSensorInputZ as CountryBlockSensorInputZ, type index$4_EntropySensorInput as EntropySensorInput, index$4_EntropySensorInputZ as EntropySensorInputZ, index$4_ExecutionMetricsZ as ExecutionMetricsZ, type index$4_IPReputation as IPReputation, type index$4_IPReputationInput as IPReputationInput, index$4_IPReputationInputZ as IPReputationInputZ, index$4_IPReputationZ as IPReputationZ, type index$4_IntentPolicy as IntentPolicy, type index$4_IntentPolicyDecision as IntentPolicyDecision, index$4_IntentPolicyDecisionZ as IntentPolicyDecisionZ, type index$4_IntentPolicySensorInput as IntentPolicySensorInput, index$4_IntentPolicySensorInputZ as IntentPolicySensorInputZ, index$4_IntentPolicyZ as IntentPolicyZ, type IntentSchema$2 as IntentSchema, index$4_IntentSchemaZ as IntentSchemaZ, type index$4_Passport as Passport, index$4_PassportZ as PassportZ, type index$4_ProofKind as ProofKind, index$4_ProofKindZ as ProofKindZ, type index$4_ProofPresenceInput as ProofPresenceInput, index$4_ProofPresenceInputZ as ProofPresenceInputZ, ProofType$1 as ProofType, type index$4_ProtocolStrictInput as ProtocolStrictInput, index$4_ProtocolStrictInputZ as ProtocolStrictInputZ, type index$4_RateLimitConfig as RateLimitConfig, index$4_RateLimitConfigZ as RateLimitConfigZ, type index$4_RateLimitInput as RateLimitInput, index$4_RateLimitInputZ as RateLimitInputZ, type index$4_RateLimitProfile as RateLimitProfile, index$4_RateLimitProfileZ as RateLimitProfileZ, type index$4_ScanBurstDecision as ScanBurstDecision, index$4_ScanBurstDecisionZ as ScanBurstDecisionZ, type index$4_ScanBurstSensorInput as ScanBurstSensorInput, index$4_ScanBurstSensorInputZ as ScanBurstSensorInputZ, type index$4_SchemaField as SchemaField, type index$4_SchemaFieldKind as SchemaFieldKind, index$4_SchemaFieldKindZ as SchemaFieldKindZ, index$4_SchemaFieldZ as SchemaFieldZ, type index$4_Scope as Scope, index$4_ScopeZ as ScopeZ, type index$4_SensitivityLevel as SensitivityLevel, index$4_SensitivityLevelZ as SensitivityLevelZ, type index$4_SensorChainInput as SensorChainInput, index$4_SensorChainInputZ as SensorChainInputZ, index$4_SensorDecisionWithMetadataZ as SensorDecisionWithMetadataZ, index$4_SensorDecisionZ as SensorDecisionZ, type index$4_SensorResult as SensorResult, index$4_SensorResultZ as SensorResultZ, type index$4_UploadSession as UploadSession, index$4_UploadSessionZ as UploadSessionZ, type index$4_UploadStatus as UploadStatus, index$4_UploadStatusZ as UploadStatusZ, type index$4_WsHandshakeDecision as WsHandshakeDecision, index$4_WsHandshakeDecisionZ as WsHandshakeDecisionZ, type index$4_WsHandshakeInput as WsHandshakeInput, index$4_WsHandshakeInputZ as WsHandshakeInputZ };
+}
+
+type index$3_AxisSensorChainService = AxisSensorChainService;
+declare const index$3_AxisSensorChainService: typeof AxisSensorChainService;
+declare const index$3_CAPABILITIES: typeof CAPABILITIES;
+type index$3_Capability = Capability;
+type index$3_ChainResult = ChainResult;
+declare const index$3_INTENT_REQUIREMENTS: typeof INTENT_REQUIREMENTS;
+declare const index$3_PROOF_CAPABILITIES: typeof PROOF_CAPABILITIES;
+type index$3_SensorDecision = SensorDecision;
+type index$3_SensorInput = SensorInput;
+declare const index$3_canAccessResource: typeof canAccessResource;
+declare const index$3_hasScope: typeof hasScope;
+declare const index$3_parseScope: typeof parseScope;
 declare namespace index$3 {
-  export { type index$3_AccessProfile as AccessProfile, index$3_AccessProfileZ as AccessProfileZ, type AxisContext$1 as AxisContext, index$3_AxisContextZ as AxisContextZ, type index$3_AxisError as AxisError, index$3_AxisErrorZ as AxisErrorZ, type index$3_BodyBudgetInput as BodyBudgetInput, index$3_BodyBudgetInputZ as BodyBudgetInputZ, type index$3_BodyBudgetPolicy as BodyBudgetPolicy, index$3_BodyBudgetPolicyZ as BodyBudgetPolicyZ, index$3_BodyProfile as BodyProfile, type index$3_BodyProfileValidation as BodyProfileValidation, index$3_BodyProfileValidator as BodyProfileValidator, index$3_BodyProfileZ as BodyProfileZ, type Capsule$1 as Capsule, type index$3_CapsuleClaims as CapsuleClaims, index$3_CapsuleClaimsZ as CapsuleClaimsZ, type index$3_CapsuleValidationResult as CapsuleValidationResult, index$3_CapsuleValidationResultZ as CapsuleValidationResultZ, type index$3_CapsuleVerifyResult as CapsuleVerifyResult, index$3_CapsuleVerifyResultZ as CapsuleVerifyResultZ, type index$3_CapsuleVerifySensorInput as CapsuleVerifySensorInput, index$3_CapsuleVerifySensorInputZ as CapsuleVerifySensorInputZ, index$3_CapsuleZ as CapsuleZ, type index$3_ChunkHashInput as ChunkHashInput, index$3_ChunkHashInputZ as ChunkHashInputZ, type index$3_CountryBlockDecision as CountryBlockDecision, index$3_CountryBlockDecisionZ as CountryBlockDecisionZ, type index$3_CountryBlockSensorInput as CountryBlockSensorInput, index$3_CountryBlockSensorInputZ as CountryBlockSensorInputZ, type index$3_EntropySensorInput as EntropySensorInput, index$3_EntropySensorInputZ as EntropySensorInputZ, index$3_ExecutionMetricsZ as ExecutionMetricsZ, type index$3_IPReputation as IPReputation, type index$3_IPReputationInput as IPReputationInput, index$3_IPReputationInputZ as IPReputationInputZ, index$3_IPReputationZ as IPReputationZ, type index$3_IntentPolicy as IntentPolicy, type index$3_IntentPolicyDecision as IntentPolicyDecision, index$3_IntentPolicyDecisionZ as IntentPolicyDecisionZ, type index$3_IntentPolicySensorInput as IntentPolicySensorInput, index$3_IntentPolicySensorInputZ as IntentPolicySensorInputZ, index$3_IntentPolicyZ as IntentPolicyZ, type IntentSchema$1 as IntentSchema, index$3_IntentSchemaZ as IntentSchemaZ, type index$3_Passport as Passport, index$3_PassportZ as PassportZ, type index$3_ProofKind as ProofKind, index$3_ProofKindZ as ProofKindZ, type index$3_ProofPresenceInput as ProofPresenceInput, index$3_ProofPresenceInputZ as ProofPresenceInputZ, ProofType$1 as ProofType, type index$3_ProtocolStrictInput as ProtocolStrictInput, index$3_ProtocolStrictInputZ as ProtocolStrictInputZ, type index$3_RateLimitConfig as RateLimitConfig, index$3_RateLimitConfigZ as RateLimitConfigZ, type index$3_RateLimitInput as RateLimitInput, index$3_RateLimitInputZ as RateLimitInputZ, type index$3_RateLimitProfile as RateLimitProfile, index$3_RateLimitProfileZ as RateLimitProfileZ, type index$3_ScanBurstDecision as ScanBurstDecision, index$3_ScanBurstDecisionZ as ScanBurstDecisionZ, type index$3_ScanBurstSensorInput as ScanBurstSensorInput, index$3_ScanBurstSensorInputZ as ScanBurstSensorInputZ, type index$3_SchemaField as SchemaField, type index$3_SchemaFieldKind as SchemaFieldKind, index$3_SchemaFieldKindZ as SchemaFieldKindZ, index$3_SchemaFieldZ as SchemaFieldZ, type index$3_Scope as Scope, index$3_ScopeZ as ScopeZ, type index$3_SensitivityLevel as SensitivityLevel, index$3_SensitivityLevelZ as SensitivityLevelZ, type index$3_SensorChainInput as SensorChainInput, index$3_SensorChainInputZ as SensorChainInputZ, index$3_SensorDecisionWithMetadataZ as SensorDecisionWithMetadataZ, index$3_SensorDecisionZ as SensorDecisionZ, type index$3_SensorResult as SensorResult, index$3_SensorResultZ as SensorResultZ, type index$3_UploadSession as UploadSession, index$3_UploadSessionZ as UploadSessionZ, type index$3_UploadStatus as UploadStatus, index$3_UploadStatusZ as UploadStatusZ, type index$3_WsHandshakeDecision as WsHandshakeDecision, index$3_WsHandshakeDecisionZ as WsHandshakeDecisionZ, type index$3_WsHandshakeInput as WsHandshakeInput, index$3_WsHandshakeInputZ as WsHandshakeInputZ };
-}
-
-type index$2_AxisSensorChainService = AxisSensorChainService;
-declare const index$2_AxisSensorChainService: typeof AxisSensorChainService;
-declare const index$2_CAPABILITIES: typeof CAPABILITIES;
-type index$2_Capability = Capability;
-type index$2_ChainResult = ChainResult;
-declare const index$2_INTENT_REQUIREMENTS: typeof INTENT_REQUIREMENTS;
-declare const index$2_PROOF_CAPABILITIES: typeof PROOF_CAPABILITIES;
-type index$2_SensorDecision = SensorDecision;
-type index$2_SensorInput = SensorInput;
-declare const index$2_canAccessResource: typeof canAccessResource;
-declare const index$2_hasScope: typeof hasScope;
-declare const index$2_parseScope: typeof parseScope;
-declare namespace index$2 {
-  export { index$2_AxisSensorChainService as AxisSensorChainService, index$2_CAPABILITIES as CAPABILITIES, type index$2_Capability as Capability, type index$2_ChainResult as ChainResult, index$2_INTENT_REQUIREMENTS as INTENT_REQUIREMENTS, index$2_PROOF_CAPABILITIES as PROOF_CAPABILITIES, type index$2_SensorDecision as SensorDecision, type index$2_SensorInput as SensorInput, index$2_canAccessResource as canAccessResource, index$2_hasScope as hasScope, index$2_parseScope as parseScope };
+  export { index$3_AxisSensorChainService as AxisSensorChainService, index$3_CAPABILITIES as CAPABILITIES, type index$3_Capability as Capability, type index$3_ChainResult as ChainResult, index$3_INTENT_REQUIREMENTS as INTENT_REQUIREMENTS, index$3_PROOF_CAPABILITIES as PROOF_CAPABILITIES, type index$3_SensorDecision as SensorDecision, type index$3_SensorInput as SensorInput, index$3_canAccessResource as canAccessResource, index$3_hasScope as hasScope, index$3_parseScope as parseScope };
 }
 
 declare class AccessProfileResolverSensor implements AxisSensor {
@@ -3203,6 +4036,16 @@ declare class IntentRegistrySensor implements AxisSensor {
     run(input: SensorInput): Promise<SensorDecision>;
 }
 
+declare class LawEvaluationSensor implements AxisSensor {
+    private readonly options;
+    private readonly logger;
+    readonly name = "LawEvaluationSensor";
+    readonly order: number;
+    constructor(options?: LawEvaluationSensorOptions);
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+}
+
 declare class ProofPresenceSensor implements AxisSensor {
     readonly name = "ProofPresenceSensor";
     readonly order: number;
@@ -3276,44 +4119,85 @@ declare class VarintHardeningSensor implements AxisSensor {
     run(input: SensorInput): Promise<SensorDecision>;
 }
 
-type index$1_AccessProfileResolverSensor = AccessProfileResolverSensor;
-declare const index$1_AccessProfileResolverSensor: typeof AccessProfileResolverSensor;
-type index$1_BodyBudgetSensor = BodyBudgetSensor;
-declare const index$1_BodyBudgetSensor: typeof BodyBudgetSensor;
-type index$1_CapabilityEnforcementSensor = CapabilityEnforcementSensor;
-declare const index$1_CapabilityEnforcementSensor: typeof CapabilityEnforcementSensor;
-type index$1_ChunkHashSensor = ChunkHashSensor;
-declare const index$1_ChunkHashSensor: typeof ChunkHashSensor;
-type index$1_EntropySensor = EntropySensor;
-declare const index$1_EntropySensor: typeof EntropySensor;
-type index$1_ExecutionTimeoutSensor = ExecutionTimeoutSensor;
-declare const index$1_ExecutionTimeoutSensor: typeof ExecutionTimeoutSensor;
-type index$1_FrameBudgetSensor = FrameBudgetSensor;
-declare const index$1_FrameBudgetSensor: typeof FrameBudgetSensor;
-type index$1_FrameHeaderSanitySensor = FrameHeaderSanitySensor;
-declare const index$1_FrameHeaderSanitySensor: typeof FrameHeaderSanitySensor;
-type index$1_HeaderTLVLimitSensor = HeaderTLVLimitSensor;
-declare const index$1_HeaderTLVLimitSensor: typeof HeaderTLVLimitSensor;
-type index$1_IntentAllowlistSensor = IntentAllowlistSensor;
-declare const index$1_IntentAllowlistSensor: typeof IntentAllowlistSensor;
-type index$1_IntentRegistrySensor = IntentRegistrySensor;
-declare const index$1_IntentRegistrySensor: typeof IntentRegistrySensor;
-type index$1_ProofPresenceSensor = ProofPresenceSensor;
-declare const index$1_ProofPresenceSensor: typeof ProofPresenceSensor;
-type index$1_ProtocolStrictSensor = ProtocolStrictSensor;
-declare const index$1_ProtocolStrictSensor: typeof ProtocolStrictSensor;
-type index$1_ReceiptPolicySensor = ReceiptPolicySensor;
-declare const index$1_ReceiptPolicySensor: typeof ReceiptPolicySensor;
-type index$1_SchemaValidationSensor = SchemaValidationSensor;
-declare const index$1_SchemaValidationSensor: typeof SchemaValidationSensor;
-type index$1_StreamScopeSensor = StreamScopeSensor;
-declare const index$1_StreamScopeSensor: typeof StreamScopeSensor;
-type index$1_TLVParseSensor = TLVParseSensor;
-declare const index$1_TLVParseSensor: typeof TLVParseSensor;
-type index$1_VarintHardeningSensor = VarintHardeningSensor;
-declare const index$1_VarintHardeningSensor: typeof VarintHardeningSensor;
+type index$2_AccessProfileResolverSensor = AccessProfileResolverSensor;
+declare const index$2_AccessProfileResolverSensor: typeof AccessProfileResolverSensor;
+type index$2_BodyBudgetSensor = BodyBudgetSensor;
+declare const index$2_BodyBudgetSensor: typeof BodyBudgetSensor;
+type index$2_CapabilityEnforcementSensor = CapabilityEnforcementSensor;
+declare const index$2_CapabilityEnforcementSensor: typeof CapabilityEnforcementSensor;
+type index$2_ChunkHashSensor = ChunkHashSensor;
+declare const index$2_ChunkHashSensor: typeof ChunkHashSensor;
+type index$2_EntropySensor = EntropySensor;
+declare const index$2_EntropySensor: typeof EntropySensor;
+type index$2_ExecutionTimeoutSensor = ExecutionTimeoutSensor;
+declare const index$2_ExecutionTimeoutSensor: typeof ExecutionTimeoutSensor;
+type index$2_FrameBudgetSensor = FrameBudgetSensor;
+declare const index$2_FrameBudgetSensor: typeof FrameBudgetSensor;
+type index$2_FrameHeaderSanitySensor = FrameHeaderSanitySensor;
+declare const index$2_FrameHeaderSanitySensor: typeof FrameHeaderSanitySensor;
+type index$2_HeaderTLVLimitSensor = HeaderTLVLimitSensor;
+declare const index$2_HeaderTLVLimitSensor: typeof HeaderTLVLimitSensor;
+type index$2_IntentAllowlistSensor = IntentAllowlistSensor;
+declare const index$2_IntentAllowlistSensor: typeof IntentAllowlistSensor;
+type index$2_IntentRegistrySensor = IntentRegistrySensor;
+declare const index$2_IntentRegistrySensor: typeof IntentRegistrySensor;
+type index$2_LawEvaluationSensor = LawEvaluationSensor;
+declare const index$2_LawEvaluationSensor: typeof LawEvaluationSensor;
+type index$2_ProofPresenceSensor = ProofPresenceSensor;
+declare const index$2_ProofPresenceSensor: typeof ProofPresenceSensor;
+type index$2_ProtocolStrictSensor = ProtocolStrictSensor;
+declare const index$2_ProtocolStrictSensor: typeof ProtocolStrictSensor;
+type index$2_ReceiptPolicySensor = ReceiptPolicySensor;
+declare const index$2_ReceiptPolicySensor: typeof ReceiptPolicySensor;
+type index$2_RiskGateSensor = RiskGateSensor;
+declare const index$2_RiskGateSensor: typeof RiskGateSensor;
+type index$2_RiskGateSensorOptions = RiskGateSensorOptions;
+type index$2_RiskSignalCollector = RiskSignalCollector;
+type index$2_SchemaValidationSensor = SchemaValidationSensor;
+declare const index$2_SchemaValidationSensor: typeof SchemaValidationSensor;
+type index$2_StreamScopeSensor = StreamScopeSensor;
+declare const index$2_StreamScopeSensor: typeof StreamScopeSensor;
+type index$2_TLVParseSensor = TLVParseSensor;
+declare const index$2_TLVParseSensor: typeof TLVParseSensor;
+type index$2_TickAuthCapsuleRef = TickAuthCapsuleRef;
+type index$2_TickAuthSensor = TickAuthSensor;
+declare const index$2_TickAuthSensor: typeof TickAuthSensor;
+type index$2_TickAuthSensorOptions = TickAuthSensorOptions;
+type index$2_TickAuthVerifier = TickAuthVerifier;
+type index$2_TpsSensor = TpsSensor;
+declare const index$2_TpsSensor: typeof TpsSensor;
+type index$2_TpsSensorOptions = TpsSensorOptions;
+type index$2_VarintHardeningSensor = VarintHardeningSensor;
+declare const index$2_VarintHardeningSensor: typeof VarintHardeningSensor;
+declare namespace index$2 {
+  export { index$2_AccessProfileResolverSensor as AccessProfileResolverSensor, index$2_BodyBudgetSensor as BodyBudgetSensor, index$2_CapabilityEnforcementSensor as CapabilityEnforcementSensor, index$2_ChunkHashSensor as ChunkHashSensor, index$2_EntropySensor as EntropySensor, index$2_ExecutionTimeoutSensor as ExecutionTimeoutSensor, index$2_FrameBudgetSensor as FrameBudgetSensor, index$2_FrameHeaderSanitySensor as FrameHeaderSanitySensor, index$2_HeaderTLVLimitSensor as HeaderTLVLimitSensor, index$2_IntentAllowlistSensor as IntentAllowlistSensor, index$2_IntentRegistrySensor as IntentRegistrySensor, index$2_LawEvaluationSensor as LawEvaluationSensor, index$2_ProofPresenceSensor as ProofPresenceSensor, index$2_ProtocolStrictSensor as ProtocolStrictSensor, index$2_ReceiptPolicySensor as ReceiptPolicySensor, index$2_RiskGateSensor as RiskGateSensor, type index$2_RiskGateSensorOptions as RiskGateSensorOptions, type index$2_RiskSignalCollector as RiskSignalCollector, index$2_SchemaValidationSensor as SchemaValidationSensor, index$2_StreamScopeSensor as StreamScopeSensor, index$2_TLVParseSensor as TLVParseSensor, type index$2_TickAuthCapsuleRef as TickAuthCapsuleRef, index$2_TickAuthSensor as TickAuthSensor, type index$2_TickAuthSensorOptions as TickAuthSensorOptions, type index$2_TickAuthVerifier as TickAuthVerifier, index$2_TpsSensor as TpsSensor, type index$2_TpsSensorOptions as TpsSensorOptions, index$2_VarintHardeningSensor as VarintHardeningSensor };
+}
+
+type index$1_ForkRequest = ForkRequest;
+type index$1_ForkResult = ForkResult;
+type index$1_InMemoryTimelineStore = InMemoryTimelineStore;
+declare const index$1_InMemoryTimelineStore: typeof InMemoryTimelineStore;
+type index$1_ReplayDifference = ReplayDifference;
+type index$1_ReplayMode = ReplayMode;
+type index$1_ReplayRequest = ReplayRequest;
+type index$1_ReplayResult = ReplayResult;
+type index$1_SimulatedSideEffect = SimulatedSideEffect;
+type index$1_SimulationRequest = SimulationRequest;
+type index$1_SimulationResult = SimulationResult;
+type index$1_StateSnapshot = StateSnapshot;
+type index$1_TimelineBranch = TimelineBranch;
+type index$1_TimelineComparison = TimelineComparison;
+type index$1_TimelineDomain = TimelineDomain;
+type index$1_TimelineEngine = TimelineEngine;
+declare const index$1_TimelineEngine: typeof TimelineEngine;
+type index$1_TimelineEvent = TimelineEvent;
+type index$1_TimelineEventStatus = TimelineEventStatus;
+type index$1_TimelineHandler = TimelineHandler;
+type index$1_TimelineHandlerContext = TimelineHandlerContext;
+type index$1_TimelineHandlerResult = TimelineHandlerResult;
+type index$1_TimelineStore = TimelineStore;
 declare namespace index$1 {
-  export { index$1_AccessProfileResolverSensor as AccessProfileResolverSensor, index$1_BodyBudgetSensor as BodyBudgetSensor, index$1_CapabilityEnforcementSensor as CapabilityEnforcementSensor, index$1_ChunkHashSensor as ChunkHashSensor, index$1_EntropySensor as EntropySensor, index$1_ExecutionTimeoutSensor as ExecutionTimeoutSensor, index$1_FrameBudgetSensor as FrameBudgetSensor, index$1_FrameHeaderSanitySensor as FrameHeaderSanitySensor, index$1_HeaderTLVLimitSensor as HeaderTLVLimitSensor, index$1_IntentAllowlistSensor as IntentAllowlistSensor, index$1_IntentRegistrySensor as IntentRegistrySensor, index$1_ProofPresenceSensor as ProofPresenceSensor, index$1_ProtocolStrictSensor as ProtocolStrictSensor, index$1_ReceiptPolicySensor as ReceiptPolicySensor, index$1_SchemaValidationSensor as SchemaValidationSensor, index$1_StreamScopeSensor as StreamScopeSensor, index$1_TLVParseSensor as TLVParseSensor, index$1_VarintHardeningSensor as VarintHardeningSensor };
+  export { type index$1_ForkRequest as ForkRequest, type index$1_ForkResult as ForkResult, index$1_InMemoryTimelineStore as InMemoryTimelineStore, type index$1_ReplayDifference as ReplayDifference, type index$1_ReplayMode as ReplayMode, type index$1_ReplayRequest as ReplayRequest, type index$1_ReplayResult as ReplayResult, type index$1_SimulatedSideEffect as SimulatedSideEffect, type index$1_SimulationRequest as SimulationRequest, type index$1_SimulationResult as SimulationResult, type index$1_StateSnapshot as StateSnapshot, type index$1_TimelineBranch as TimelineBranch, type index$1_TimelineComparison as TimelineComparison, type index$1_TimelineDomain as TimelineDomain, index$1_TimelineEngine as TimelineEngine, type index$1_TimelineEvent as TimelineEvent, type index$1_TimelineEventStatus as TimelineEventStatus, type index$1_TimelineHandler as TimelineHandler, type index$1_TimelineHandlerContext as TimelineHandlerContext, type index$1_TimelineHandlerResult as TimelineHandlerResult, type index$1_TimelineStore as TimelineStore };
 }
 
 declare const index_encodeAxisTlvDto: typeof encodeAxisTlvDto;
@@ -3321,4 +4205,4 @@ declare namespace index {
   export { index_encodeAxisTlvDto as encodeAxisTlvDto };
 }
 
-export { ATS1_HDR, ATS1_SCHEMA, AXIS_ANONYMOUS_KEY, AXIS_EXECUTION_CONTEXT_KEY, AXIS_META_KEY, AXIS_OPCODES, AXIS_PUBLIC_KEY, AXIS_RATE_LIMIT_KEY, AXIS_UPLOAD_FILE_STORE, AXIS_UPLOAD_RECEIPT_SIGNER, AXIS_UPLOAD_SESSION_STORE, ats1 as Ats1Codec, Axis, type Axis1DecodedFrame, type Axis1FrameToEncode, type AxisAlg$1 as AxisAlg, AxisAnonymous, type AxisPacket as AxisBinaryPacket, type AxisCapsule, type AxisCapsuleConstraints, type AxisCapsulePayload, type AxisCapsuleRef, type AxisChainEncryption, type AxisChainEnvelope, AxisChainExecutor, type AxisChainRequest, type AxisChainResult, type AxisChainStatus, type AxisChainStep, type AxisChainStepResult, type AxisChainStepStatus, AxisContext, type AxisCrudHandler, type AxisDecoded, AxisDemoPubkey, type AxisEffect, type AxisExecutionContext, type AxisExecutionMode, AxisFilesDownloadHandler, AxisFilesFinalizeHandler, AxisFrame$2 as AxisFrame, type AxisHandler, type AxisHandlerInit, AxisIdDto, type AxisIntentEnvelope, type AxisIntentObserver, AxisIp, type AxisAlg as AxisJsonAlg, type AxisFrame$1 as AxisJsonFrame, type AxisResponse as AxisJsonResponse, type AxisSig as AxisJsonSig, type AxisKeyExchangeRef, type AxisObservation, type AxisObservedContext, type AxisObserverBinding, type AxisObserverBindingOptions, type AxisObserverContext, type AxisObserverDefinition, type AxisObserverEvent, type AxisObserverRef, type AxisObserverRegistration, type AxisPacket$1 as AxisPacket, T as AxisPacketTags, AxisPartialType, type AxisPostSensor, type AxisPreSensor, AxisPublic, AxisRateLimit, type AxisRateLimitConfig, AxisRaw, type AxisRequestContext, type AxisRequestData, AxisResponseDto, type AxisSensor, AxisSensorChainService, type AxisSensorInit, type AxisSig$1 as AxisSig, AxisTlvDto, BAND, CAPABILITIES, CAPSULE_POLICY_METADATA_KEY, CCE_ERROR, CCE_PROTOCOL_VERSION, CHAIN_METADATA_KEY, CONTRACT_METADATA_KEY, type Capability, Capsule, type CapsuleMode, CapsulePolicy, type CapsulePolicyOptions, type CapsuleScopeMode, type CceCapsuleClaims as CceCapsuleClaimsType, CceError, type CceExecutionContext as CceExecutionContextType, type CceHandler, type CceHandlerContext, type CceHandlerResult, type CcePipelineConfig, type CcePipelineResult, type CcePolicyContext, type CcePolicyDecision, type CcePolicyEvaluator, type CceRequestEnvelope as CceRequestEnvelopeType, type CceResponseEnvelope as CceResponseEnvelopeType, type CceWitnessRecord as CceWitnessRecordType, Chain, type ChainOptions, type ChainResult, Contract, ContractViolationError, DEFAULT_CONTRACTS, DEFAULT_TIMEOUT, Decision, DiskUploadFileStore, type DtoSchema, type ExecutionContract, ExecutionMeter, type ExecutionMetrics, FALLBACK_CONTRACT, type Grant, type GrantCapability, type GrantMeta, type GrantStatus, type GrantType, type GrantValidationResult, HANDLER_METADATA_KEY, HANDLER_SENSORS_KEY, Handler, HandlerDiscoveryService, HandlerSensors, INTENT_BODY_KEY, INTENT_METADATA_KEY, INTENT_REQUIREMENTS, INTENT_ROUTES_KEY, INTENT_SENSITIVITY_MAP, INTENT_SENSORS_KEY, INTENT_TIMEOUTS, Intent, IntentBody, type IntentDefinition, type IntentKind, type IntentOptions, type IntentRoute, IntentRouter, IntentSensitivity, IntentSensors, type IntentTlvField, type KeyStatus, type LoomReceipt, type LoomValidationResult, OBSERVER_BINDINGS_KEY, OBSERVER_METADATA_KEY, type ObservationQueueConfig, type ObservationQueueMessage, type ObservationSensor, type ObservationStage, type ObservationStreamEntry, type ObservationWitnessSummary, Observer, ObserverDiscoveryService, ObserverDispatcherService, ObserverRegistry, type ObserverVerdict, PRE_DECODE_BOUNDARY, PROOF_CAPABILITIES, type PresenceChallenge, type PresenceDeclaration, type PresenceProof, type PresenceReceipt, type PresenceStatus, type PresenceVerifyResult, REQUIRED_PROOF_METADATA_KEY, RESPONSE_TAG_CREATED_AT, RESPONSE_TAG_CREATED_BY, RESPONSE_TAG_ID, RESPONSE_TAG_UPDATED_AT, RESPONSE_TAG_UPDATED_BY, type ReceiptEffect, type RegisteredChainConfig, RequiredProof, type RequiredProofKind, type ResponseContract, ResponseObserver, type ResponseObserverContext, type Revocation, type RevocationTargetType, RiskDecision, type RiskEvaluation, type RiskSignal, SENSITIVITY_METADATA_KEY, SENSOR_METADATA_KEY, Schema2002_PasskeyLoginOptionsRes, Schema2011_PasskeyLoginVerifyReq, Schema2012_PasskeyLoginVerifyRes, Schema2021_PasskeyRegisterOptionsReq, Sensitivity, Sensor, type SensorBand, type SensorDecision, SensorDecisions, SensorDiscoveryService, type SensorInput, type SensorMinifiedDecision, type SensorOptions, type SensorPhase, type SensorPhaseMetadata, SensorRegistry, TLV_FIELDS_KEY, TLV_VALIDATORS_KEY, type ThreadState, TlvEnum, TlvField, type TlvFieldKind, type TlvFieldMeta, type TlvFieldOptions, TlvMinLen, TlvRange, TlvUtf8Pattern, TlvValidate, type TlvValidatorFn, type TlvValidatorMeta, type UnsignedObservationWitness, type UploadFileStat, type UploadFileStore, type UploadReceiptSigner, type UploadSessionRecord, type UploadSessionStatus, type UploadSessionStore, Witness, type Writ, type WritBody, type WritHead, type WritMeta, type WritSignature, type WritValidationResult, axis1SigningBytes, b64urlDecode, b64urlDecodeString, b64urlEncode, b64urlEncodeString, buildAts1Hdr, buildDtoDecoder, buildPacket, buildQueueMessage, buildReceiptHash, buildTLVs, buildUnsignedWitness, bytes, canAccessResource, canonicalJson, canonicalJsonExcluding, canonicalizeGrant, canonicalizeObservation, canonicalizeWrit, index$9 as cce, classifyIntent, createObservation, index$8 as crypto, decodeAxis1Frame, decodeQueueMessage, index$7 as decorators, deriveAnchorReflection, encVarint, encodeAxis1Frame, encodeAxisTlvDto, encodeQueueMessage, endStage, index$5 as engine, executeCcePipeline, extractDtoSchema, finalizeObservation, getAxisExecutionContext, hasScope, hashObservation, isAdminOpcode, isKnownOpcode, isTimestampValid, index$4 as loom, mergeAxisExecutionContext, nonce16, normalizeSensorDecision, packPasskeyLoginOptionsReq, packPasskeyLoginOptionsRes, packPasskeyLoginVerifyReq, packPasskeyLoginVerifyRes, packPasskeyRegisterOptionsReq, parseAutoClaimEntries, parseScope, parseStreamEntries, recordSensor, resolveTimeout, index$3 as schemas, index$2 as security, sensitivityName, index$1 as sensors, stableJsonStringify, startStage, tlv, u64be, unpackPasskeyLoginOptionsReq, unpackPasskeyLoginVerifyReq, unpackPasskeyRegisterOptionsReq, utf8, index as utils, validateFrameShape, varintU, verifyResponse, withAxisExecutionContext };
+export { ATS1_HDR, ATS1_SCHEMA, AXIS_ANONYMOUS_KEY, AXIS_EXECUTION_CONTEXT_KEY, AXIS_META_KEY, AXIS_OPCODES, AXIS_PUBLIC_KEY, AXIS_RATE_LIMIT_KEY, AXIS_UPLOAD_FILE_STORE, AXIS_UPLOAD_RECEIPT_SIGNER, AXIS_UPLOAD_SESSION_STORE, type AlternativeIntent, type Anomaly, type AnomalyLevel, ats1 as Ats1Codec, Axis, Axis1DecodedFrame, type AxisAlg$1 as AxisAlg, AxisAnonymous, type AxisPacket as AxisBinaryPacket, type AxisCapsule, type AxisCapsuleConstraints, type AxisCapsulePayload, type AxisCapsuleRef, type AxisChainEncryption, type AxisChainEnvelope, AxisChainExecutor, type AxisChainRequest, type AxisChainResult, type AxisChainStatus, type AxisChainStep, type AxisChainStepResult, type AxisChainStepStatus, AxisContext, type AxisCrudHandler, type AxisDecoded, AxisDemoPubkey, type AxisEffect, type AxisExecutionContext, type AxisExecutionMode, AxisFilesDownloadHandler, AxisFilesFinalizeHandler, type AxisHandler, type AxisHandlerInit, AxisIdDto, type AxisIntentEnvelope, type AxisIntentObserver, type AxisIntentSensorOptions, type AxisIntentSensorRef, AxisIp, type AxisAlg as AxisJsonAlg, type AxisFrame$1 as AxisJsonFrame, type AxisResponse as AxisJsonResponse, type AxisSig as AxisJsonSig, type AxisKeyExchangeRef, type AxisLawArticleSummary, type AxisLawDecision, type AxisLawEvaluationContext, type AxisLawEvaluationResult, type AxisLawEvaluator, AxisMediaTypes, type AxisObservation, type AxisObservedContext, type AxisObserverBinding, type AxisObserverBindingOptions, type AxisObserverContext, type AxisObserverDefinition, type AxisObserverEvent, type AxisObserverRef, type AxisObserverRegistration, type AxisPacket$1 as AxisPacket, T as AxisPacketTags, AxisPartialType, type AxisPostSensor, type AxisPreSensor, AxisPublic, AxisRateLimit, type AxisRateLimitConfig, AxisRaw, type AxisRequestContext, type AxisRequestData, AxisResponseDto, type AxisSensor, AxisSensorChainService, type AxisSensorInit, type AxisSig$1 as AxisSig, AxisTlvDto, BAND, CAPABILITIES, CAPSULE_POLICY_METADATA_KEY, CCE_ERROR, CCE_PROTOCOL_VERSION, CHAIN_METADATA_KEY, CONTRACT_METADATA_KEY, type Capability, Capsule, type CapsuleMode, CapsulePolicy, type CapsulePolicyOptions, type CapsuleScopeMode, type CceCapsuleClaims as CceCapsuleClaimsType, CceError, type CceExecutionContext as CceExecutionContextType, type CceHandler, type CceHandlerContext, type CceHandlerResult, type CcePipelineConfig, type CcePipelineResult, type CcePolicyContext, type CcePolicyDecision, type CcePolicyEvaluator, type CceRequestEnvelope as CceRequestEnvelopeType, type CceResponseEnvelope as CceResponseEnvelopeType, type CceWitnessRecord as CceWitnessRecordType, Chain, type ChainOptions, type ChainResult, type ClarificationQuestion, type CompilationError, type CompilationResult, type CompiledIntent, type ConstraintKind, Contract, ContractViolationError, DEFAULT_CONTRACTS, DEFAULT_TIMEOUT, Decision, DiskUploadFileStore, type DtoSchema, type ExecutionContract, ExecutionMeter, type ExecutionMetrics, type ExpectedOutcome, FALLBACK_CONTRACT, type Fabric, type FabricCell, type FabricDiff, type FabricDiffEntry, type FabricDiffKind, type FabricEffect, type FabricEffectResolver, type FabricQuery, type ForkRequest, type ForkResult, type Grant, type GrantCapability, type GrantMeta, type GrantStatus, type GrantType, type GrantValidationResult, HANDLER_METADATA_KEY, HANDLER_SENSORS_KEY, Handler, HandlerDiscoveryService, HandlerSensors, INTENT_BODY_KEY, INTENT_METADATA_KEY, INTENT_REQUIREMENTS, INTENT_ROUTES_KEY, INTENT_SENSITIVITY_MAP, INTENT_SENSORS_KEY, INTENT_TIMEOUTS, IdelCompiler, IdelSchemaRegistry, InMemoryPatternStore, InMemoryTimelineStore, Intent, IntentBody, type IntentConstraint, type IntentDefinition, type IntentKind, type IntentOptions, type IntentParamSchema, type IntentProposal, type IntentRisk, type IntentRoute, IntentRouter, type IntentSchema, IntentSensitivity, IntentSensors, type IntentTlvField, type KeyStatus, type Knot, type KnotBreakRequest, type KnotError, type KnotStatus, type KnotType, type KnotValidationResult, type LawEvaluationSensorOptions, type LoomExecutionResult, type LoomReceipt, type LoomValidationResult, type Needle, type NeedleError, type NeedleHandler, type NeedleHandlerContext, type NeedleHandlerResult, type NeedlePhase, type NeedlePipelineConfig, type NeedlePipelineResult, OBSERVER_BINDINGS_KEY, OBSERVER_METADATA_KEY, type ObservationQueueConfig, type ObservationQueueMessage, type ObservationSensor, type ObservationStage, type ObservationStreamEntry, type ObservationWitnessSummary, type ObservedDeed, Observer, ObserverDiscoveryService, ObserverDispatcherService, ObserverRegistry, type ObserverVerdict, PRE_DECODE_BOUNDARY, PROOF_CAPABILITIES, type Pattern, type PatternConfidence, type PatternKind, type PatternMatch, type PatternPrediction, type PatternSignature, type PatternStore, type PresenceChallenge, type PresenceDeclaration, type PresenceProof, type PresenceReceipt, type PresenceStatus, type PresenceVerifyResult, REQUIRED_PROOF_METADATA_KEY, RESPONSE_TAG_CREATED_AT, RESPONSE_TAG_CREATED_BY, RESPONSE_TAG_ID, RESPONSE_TAG_UPDATED_AT, RESPONSE_TAG_UPDATED_BY, type ReceiptEffect, type RegisteredChainConfig, type ReplayDifference, type ReplayRequest, type ReplayResult, RequiredProof, type RequiredProofKind, type ResponseContract, ResponseObserver, type ResponseObserverContext, type Revocation, type RevocationTargetType, RiskDecision, type RiskEvaluation, RiskGateSensor, type RiskGateSensorOptions, type RiskLevel, type RiskSignal, type RiskSignalCollector, SENSITIVITY_METADATA_KEY, SENSOR_METADATA_KEY, Schema2002_PasskeyLoginOptionsRes, Schema2011_PasskeyLoginVerifyReq, Schema2012_PasskeyLoginVerifyRes, Schema2021_PasskeyRegisterOptionsReq, Sensitivity, Sensor, type SensorBand, type SensorDecision, SensorDecisions, SensorDiscoveryService, type SensorInput, type SensorMinifiedDecision, type SensorOptions, type SensorPhase, type SensorPhaseMetadata, SensorRegistry, type SimulatedSideEffect, type SimulationRequest, type SimulationResult, type StateSnapshot, type Stitch, type StitchKind, TLV_FIELDS_KEY, TLV_VALIDATORS_KEY, type Thread, type ThreadState, type TickAuthCapsuleRef, TickAuthSensor, type TickAuthSensorOptions, type TickAuthVerifier, type TimelineBranch, type TimelineComparison, type TimelineDomain, TimelineEngine, type TimelineEvent, type TimelineEventStatus, type TimelineHandler, type TimelineHandlerContext, type TimelineHandlerResult, type TimelineStore, TlvEnum, TlvField, type TlvFieldKind, type TlvFieldMeta, type TlvFieldOptions, TlvMinLen, TlvRange, TlvUtf8Pattern, TlvValidate, type TlvValidatorFn, type TlvValidatorMeta, TpsSensor, type TpsSensorOptions, type TruthStatus, type TruthVerdict, type UnsignedObservationWitness, type UploadFileStat, type UploadFileStore, type UploadReceiptSigner, type UploadSessionRecord, type UploadSessionStatus, type UploadSessionStore, Witness, type Writ, type WritBody, type WritHead, type WritMeta, type WritSignature, type WritValidationResult, addStitchToKnot, applyStitch, assembleNeedle, b64urlDecode, b64urlDecodeString, b64urlEncode, b64urlEncodeString, breakKnot, buildAts1Hdr, buildAxisLawEvaluationContext, buildDtoDecoder, buildPacket, buildQueueMessage, buildReceiptHash, buildTLVs, buildUnsignedWitness, bytes, canAccessResource, canonicalJson, canonicalJsonExcluding, canonicalizeGrant, canonicalizeObservation, canonicalizeWrit, index$c as cce, classifyIntent, createFabric, createGrant, createObservation, createPresenceChallenge, createReceipt, createRevocation, createWrit, index$b as crypto, decodeQueueMessage, index$a as decorators, deriveAnchorReflection, detectAnomalies, detectKnotPatterns, detectSequencePatterns, diffFabrics, encVarint, encodeAxisTlvDto, encodeQueueMessage, endStage, index$8 as engine, executeCcePipeline, executeLoomPipeline, extractDtoSchema, finalizeObservation, findKnotsForStitch, forkFromKnot, formStitch, getAxisExecutionContext, getDecisionPoints, getFabricValue, getGrantStatus, getIrreversibleKnots, getPresenceStatus, grantCoversAction, hasScope, hashObservation, index$7 as idel, isAdminOpcode, isKnotOpen, isKnownOpcode, isPointOfNoReturn, isRevoked, isTimestampValid, lockCells, index$6 as loom, matchPatterns, mergeAxisExecutionContext, index$5 as needle, nonce16, normalizeSensorDecision, openKnot, packPasskeyLoginOptionsReq, packPasskeyLoginOptionsRes, packPasskeyLoginVerifyReq, packPasskeyLoginVerifyRes, packPasskeyRegisterOptionsReq, parseAutoClaimEntries, parseScope, parseStreamEntries, projectAt, queryFabric, recordOccurrence, recordSensor, renewPresence, resolveTimeout, runNeedlePipeline, index$4 as schemas, scoreTruth, index$3 as security, sensitivityName, index$2 as sensors, signPresenceChallenge, stableJsonStringify, startStage, tieKnot, index$1 as timeline, tlv, u64be, unpackPasskeyLoginOptionsReq, unpackPasskeyLoginVerifyReq, unpackPasskeyRegisterOptionsReq, updateThreadState, utf8, index as utils, validateFrameShape, validateGrant, validateKnot, validateWrit, varintU, verifyObservation, verifyPresenceProof, verifyReceiptChain, verifyResponse, weave, withAxisExecutionContext };