@nextera.one/axis-server-sdk 2.2.1 → 2.2.2

package/dist/index.d.ts

@@ -1,354 +1,61 @@
-import * as z from 'zod';
-import { AxisFrame as AxisFrame$1 } 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 { ModuleRef, DiscoveryService, Reflector, MetadataScanner } from '@nestjs/core';
-import { ConfigService } from '@nestjs/config';
+import { C as ChainOptions, A as AxisIntentSensorRef, I as IntentTlvField, T as TlvValidatorFn, a as IntentRouter, O as ObserverDispatcherService, b as AxisChainEnvelope, c as AxisChainResult, d as AxisCapsuleRef, e as AxisChainStep, f as AxisContext, S as SensorRegistry } from './index-DbSxdR0f.js';
+export { g as AXIS_ANONYMOUS_KEY, h as AXIS_META_KEY, i as AXIS_PUBLIC_KEY, j as AXIS_RATE_LIMIT_KEY, k as AccessProfileResolverSensor, l as Axis, m as AxisAnonymous, n as AxisChainEncryption, o as AxisChainRequest, p as AxisChainStatus, q as AxisChainStepResult, r as AxisChainStepStatus, s as AxisEffect, t as AxisExecutionMode, u as AxisIntentEnvelope, v as AxisIntentObserver, w as AxisIntentSensorOptions, x as AxisKeyExchangeRef, y as AxisLawArticleSummary, z as AxisLawDecision, B as AxisLawEvaluationContext, D as AxisLawEvaluationResult, E as AxisLawEvaluator, F as AxisObserverBinding, G as AxisObserverBindingOptions, H as AxisObserverContext, J as AxisObserverDefinition, K as AxisObserverEvent, L as AxisObserverRef, M as AxisObserverRegistration, N as AxisPublic, P as AxisRateLimit, Q as AxisRateLimitConfig, R as BodyBudgetSensor, U as CAPSULE_POLICY_METADATA_KEY, V as CONTRACT_METADATA_KEY, W as CapabilityEnforcementSensor, X as Capsule, Y as CapsulePolicy, Z as CapsulePolicyOptions, _ as CapsuleScopeMode, $ as ChunkHashSensor, a0 as Contract, a1 as DEFAULT_CONTRACTS, a2 as EntropySensor, a3 as ExecutionContract, a4 as ExecutionTimeoutSensor, a5 as FALLBACK_CONTRACT, a6 as FrameBudgetSensor, a7 as FrameHeaderSanitySensor, a8 as HeaderTLVLimitSensor, a9 as INTENT_METADATA_KEY, aa as INTENT_ROUTES_KEY, ab as Intent, ac as IntentAllowlistSensor, ad as IntentKind, ae as IntentOptions, af as IntentRegistrySensor, ag as IntentRoute, ah as LawEvaluationSensor, ai as LawEvaluationSensorOptions, aj as OBSERVER_BINDINGS_KEY, ak as OBSERVER_METADATA_KEY, al as Observer, am as ObserverRegistry, an as ProofPresenceSensor, ao as ProtocolStrictSensor, ap as REQUIRED_PROOF_METADATA_KEY, aq as ReceiptPolicySensor, ar as RegisteredChainConfig, as as RequiredProof, at as RequiredProofKind, au as RiskDecision, av as RiskEvaluation, aw as RiskGateSensor, ax as RiskGateSensorOptions, ay as RiskSignal, az as RiskSignalCollector, aA as SENSITIVITY_METADATA_KEY, aB as SchemaValidationSensor, aC as Sensitivity, aD as StreamScopeSensor, aE as TLVParseSensor, aF as TLV_FIELDS_KEY, aG as TLV_VALIDATORS_KEY, aH as TickAuthCapsuleRef, aI as TickAuthSensor, aJ as TickAuthSensorOptions, aK as TickAuthVerifier, aL as TlvEnum, aM as TlvField, aN as TlvFieldKind, aO as TlvFieldMeta, aP as TlvFieldOptions, aQ as TlvMinLen, aR as TlvRange, aS as TlvUtf8Pattern, aT as TlvValidate, aU as TlvValidatorMeta, aV as TpsSensor, aW as TpsSensorOptions, aX as VarintHardeningSensor, aY as Witness, aZ as buildAxisLawEvaluationContext } from './index-DbSxdR0f.js';
+import { AxisFrame } from '@nextera.one/axis-protocol';
+export { AXIS_MAGIC, AXIS_VERSION, AxisBinaryFrame, AxisFrame, TLV as AxisTlvType, 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, 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 { A as AxisObservation, L as LoomReceipt, T as ThreadState, W as WritValidationResult, G as Grant, a as GrantCapability, P as PresenceDeclaration, b as PresenceChallenge, c as Writ, R as Revocation, d as WritBody, e as WritMeta, f as PresenceReceipt, g as GrantStatus, h as PresenceStatus, i as PresenceProof, j as GrantValidationResult, k as PresenceVerifyResult } from './index-l3Hhirqb.js';
+export { l as Anomaly, m as AnomalyLevel, E as ExpectedOutcome, F as Fabric, n as FabricCell, o as FabricDiff, p as FabricDiffEntry, q as FabricDiffKind, r as FabricEffect, s as FabricEffectResolver, t as FabricQuery, u as GrantMeta, v as GrantType, I as InMemoryPatternStore, K as Knot, w as KnotBreakRequest, x as KnotError, y as KnotStatus, z as KnotType, B as KnotValidationResult, C as LoomValidationResult, N as Needle, D as NeedleError, H as NeedleHandler, J as NeedleHandlerContext, M as NeedleHandlerResult, O as NeedlePhase, Q as NeedlePipelineConfig, S as NeedlePipelineResult, U as ObservationSensor, V as ObservationStage, X as ObservedDeed, Y as Pattern, Z as PatternConfidence, _ as PatternKind, $ as PatternMatch, a0 as PatternPrediction, a1 as PatternSignature, a2 as PatternStore, a3 as RevocationTargetType, a4 as Stitch, a5 as StitchKind, a6 as Thread, a7 as TruthStatus, a8 as TruthVerdict, a9 as WritHead, aa as WritSignature, ab as addStitchToKnot, ac as applyStitch, ad as assembleNeedle, ae as breakKnot, af as canonicalizeGrant, ag as canonicalizeWrit, ah as createFabric, ai as createObservation, aj as deriveAnchorReflection, ak as detectAnomalies, al as detectKnotPatterns, am as detectSequencePatterns, an as diffFabrics, ao as endStage, ap as finalizeObservation, aq as findKnotsForStitch, ar as forkFromKnot, as as formStitch, at as getDecisionPoints, au as getFabricValue, av as getIrreversibleKnots, aw as isKnotOpen, ax as isPointOfNoReturn, ay as lockCells, az as matchPatterns, aA as openKnot, aB as projectAt, aC as queryFabric, aD as recordOccurrence, aE as recordSensor, aF as runNeedlePipeline, aG as scoreTruth, aH as startStage, aI as tieKnot, aJ as validateKnot, aK as verifyObservation, aL as weave } from './index-l3Hhirqb.js';
 export { AxisError, AxisFrameZ, computeReceiptHash, computeSignaturePayload, generateEd25519KeyPair, sha256, signFrame, verifyFrameSignature } from './core/index.js';
 export { Axis1FrameToEncode, encodeAxis1Frame } from './codec/axis1.encode.js';
 export { axis1SigningBytes } from './codec/axis1.signing.js';
+import { S as SensorInput, a as SensorDecision } from './axis-sensor-GBEI3Fab.js';
+export { b as AxisAlg, c as AxisCapsule, d as AxisCapsuleConstraints, e as AxisCapsulePayload, f as AxisJsonAlg, g as AxisJsonFrame, h as AxisJsonResponse, i as AxisJsonSig, j as AxisObservedContext, k as AxisPacket, l as AxisPostSensor, m as AxisPreSensor, n as AxisRequestContext, A as AxisSensor, o as AxisSensorInit, p as AxisSig, C as CapsuleMode, D as Decision, K as KeyStatus, q as SensorDecisions, r as SensorMinifiedDecision, s as SensorPhaseMetadata, t as normalizeSensorDecision } from './axis-sensor-GBEI3Fab.js';
 import { Axis1DecodedFrame } from './types/frame.js';
 export { decodeAxis1Frame } from './types/frame.js';
-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';
-interface AxisCapsuleRef {
-    capsuleId?: string;
-    scope?: string | string[];
-    scopeMode?: 'chain' | 'step' | 'chain+step';
-    proofRequired?: boolean;
-    metadata?: Record<string, unknown>;
-}
-interface AxisKeyExchangeRef {
-    profile?: string;
-    sessionId?: string;
-    clientKid?: string;
-    serverKid?: string;
-    algorithm?: string;
-    derivedKeyRef?: string;
-    required?: boolean;
-    metadata?: Record<string, unknown>;
-}
-interface AxisIntentEnvelope<TPayload = unknown> {
-    intent: string;
-    handler?: string;
-    payload: TPayload;
-    capsule?: AxisCapsuleRef;
-    keyExchange?: AxisKeyExchangeRef;
-    observerTags?: string[];
-    proofRequired?: boolean;
-    metadata?: Record<string, unknown>;
-}
-interface AxisChainStep<TInput = unknown> {
-    stepId: string;
-    intent: string;
-    handler?: string;
-    input?: TInput;
-    dependsOn?: string[];
-    onSuccess?: string[];
-    onFailure?: string[];
-    capsuleScope?: string | string[];
-    observerTags?: string[];
-    proofRequired?: boolean;
-    keyExchange?: AxisKeyExchangeRef;
-    metadata?: Record<string, unknown>;
-}
-interface AxisChainEncryption {
-    enabled?: boolean;
-    profile?: string;
-    keyExchange?: AxisKeyExchangeRef;
-}
-interface AxisChainEnvelope<TInput = unknown> {
-    chainId: string;
-    subject?: string;
-    issuer?: string;
-    issuedAtTps?: string | number;
-    expiresAtTps?: string | number;
-    mode: AxisExecutionMode;
-    signature?: string;
-    encryption?: AxisChainEncryption;
-    capsule?: AxisCapsuleRef;
-    keyExchange?: AxisKeyExchangeRef;
-    observerTags?: string[];
-    dynamic?: boolean;
-    metadata?: Record<string, unknown>;
-    steps: Array<AxisChainStep<TInput>>;
-}
-interface AxisChainRequest<TInput = unknown, TCapsule = Record<string, unknown>> {
-    envelope: AxisChainEnvelope<TInput>;
-    capsule?: TCapsule;
-    actorId?: string;
-}
-type AxisChainStepStatus = 'SUCCEEDED' | 'FAILED' | 'BLOCKED' | 'SKIPPED';
-interface AxisChainStepResult<TOutput = unknown> {
-    stepId: string;
-    intent: string;
-    status: AxisChainStepStatus;
-    effect?: string;
-    output?: TOutput;
-    error?: string;
-    dependsOn?: string[];
-    startedAt: number;
-    finishedAt: number;
-    proofHash?: string;
-    observerTags?: string[];
-    metadata?: Record<string, unknown>;
-}
-type AxisChainStatus = 'SUCCEEDED' | 'FAILED' | 'PARTIAL';
-interface AxisChainResult<TOutput = unknown> {
-    chainId: string;
-    mode: AxisExecutionMode;
-    status: AxisChainStatus;
-    completedSteps: number;
-    failedSteps: number;
-    blockedSteps: number;
-    skippedSteps: number;
-    startedAt: number;
-    finishedAt: number;
-    results: Array<AxisChainStepResult<TOutput>>;
-    rollback?: {
-        supported: boolean;
-        attempted: boolean;
-        reason?: string;
-    };
-    metadata?: Record<string, unknown>;
-}
-interface ChainOptions {
-    mode?: AxisExecutionMode;
-    allowPartial?: boolean;
-    dynamic?: boolean;
-    proofRequired?: boolean;
-    capsuleScope?: string | string[];
-    observerTags?: string[];
-    keyExchangeRequired?: boolean;
-}
-interface RegisteredChainConfig extends ChainOptions {
-    enabled: boolean;
-}
+export { InMemoryTimelineStore, TimelineEngine, TimelineStore } from './timeline/index.js';
+export { F as ForkRequest, a as ForkResult, R as ReplayDifference, b as ReplayRequest, c as ReplayResult, S as SimulatedSideEffect, d as SimulationRequest, e as SimulationResult, f as StateSnapshot, T as TimelineBranch, g as TimelineComparison, h as TimelineDomain, i as TimelineEvent, j as TimelineEventStatus, k as TimelineHandler, l as TimelineHandlerContext, m as TimelineHandlerResult } from './timeline.types-Cn0aqbUj.js';
+export { e as CCE_ERROR, h as CCE_PROTOCOL_VERSION, C as CceCapsuleClaimsType, q as CceError, a as CceExecutionContextType, s as CceHandler, t as CceHandlerContext, u as CceHandlerResult, x as CcePipelineConfig, y as CcePipelineResult, z as CcePolicyContext, A as CcePolicyDecision, B as CcePolicyEvaluator, b as CceRequestEnvelopeType, D as CceResponseEnvelopeType, I as CceWitnessRecordType, O as executeCcePipeline } from './cce-pipeline-DbGBSsCG.js';
+export { IdelCompiler, IdelSchemaRegistry } from './idel/index.js';
+export { A as AlternativeIntent, C as ClarificationQuestion, a as CompilationError, b as CompilationResult, c as CompiledIntent, d as ConstraintKind, I as IntentConstraint, e as IntentParamSchema, f as IntentProposal, g as IntentRisk, h as IntentSchema, R as RiskLevel } from './idel.types-DuUAcOnQ.js';
+import 'zod';
 
 declare const CHAIN_METADATA_KEY = "axis:chain";
 declare function Chain(options?: ChainOptions): MethodDecorator;
 
-declare const CAPSULE_POLICY_METADATA_KEY = "axis:capsule:policy";
-type CapsuleScopeMode = "all" | "any";
-interface CapsulePolicyOptions {
-    required?: boolean;
-    scopes?: string | string[];
-    scopeMode?: CapsuleScopeMode;
-    intentBound?: boolean;
-    allowCapsuleRef?: boolean;
-}
-declare function CapsulePolicy(options?: CapsulePolicyOptions): ClassDecorator & MethodDecorator;
-
-interface ExecutionContract {
-    maxDbWrites: number;
-    maxDbReads?: number;
-    maxExternalCalls: number;
-    maxTimeMs: number;
-    allowedEffects: string[];
-    maxMemoryMb?: number;
-}
-declare const DEFAULT_CONTRACTS: Record<string, ExecutionContract>;
-declare const FALLBACK_CONTRACT: ExecutionContract;
-
-declare const ProofKindZ: z.ZodEnum<{
-    NONE: "NONE";
-    CAPSULE: "CAPSULE";
-    PASSPORT: "PASSPORT";
-    MTLS: "MTLS";
-    JWT: "JWT";
-}>;
-type ProofKind = z.infer<typeof ProofKindZ>;
-declare const SensitivityLevelZ: z.ZodEnum<{
-    LOW: "LOW";
-    MEDIUM: "MEDIUM";
-    HIGH: "HIGH";
-    CRITICAL: "CRITICAL";
-}>;
-type SensitivityLevel = z.infer<typeof SensitivityLevelZ>;
-declare enum ProofType {
-    CAPSULE = 1,
-    JWT = 2,
-    MTLS_ID = 3,
-    DEVICE_SE = 4,
-    WITNESS_SIG = 5
-}
-declare const AxisContextZ: z.ZodObject<{
-    pid: z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>;
-    ts: z.ZodBigInt;
-    intent: z.ZodString;
-    actorId: z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>;
-    proofType: z.ZodEnum<typeof ProofType>;
-    proofRef: z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>;
-    nonce: z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>;
-    ip: z.ZodString;
-    nodeCertHash: z.ZodOptional<z.ZodString>;
-    capsule: z.ZodOptional<z.ZodObject<{
-        id: z.ZodString;
-        claims: z.ZodObject<{
-            capsuleId: z.ZodString;
-            allowIntents: z.ZodArray<z.ZodString>;
-            limits: z.ZodOptional<z.ZodObject<{
-                maxBodyBytes: z.ZodOptional<z.ZodNumber>;
-            }, z.z.core.$strip>>;
-            scopes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-        }, z.z.core.$strip>;
-        issuedAt: z.ZodNumber;
-        expiresAt: z.ZodNumber;
-        tier: z.ZodEnum<{
-            FREE: "FREE";
-            STANDARD: "STANDARD";
-            PREMIUM: "PREMIUM";
-        }>;
-    }, z.z.core.$strip>>;
-    passport: z.ZodOptional<z.ZodObject<{
-        id: z.ZodString;
-        public_key: z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>;
-        status: z.ZodEnum<{
-            ACTIVE: "ACTIVE";
-            REVOKED: "REVOKED";
-            EXPIRED: "EXPIRED";
-            PENDING: "PENDING";
-        }>;
-        issuedAt: z.ZodNumber;
-        expiresAt: z.ZodOptional<z.ZodNumber>;
-    }, z.z.core.$strip>>;
-    meter: z.ZodOptional<z.ZodAny>;
-}, z.z.core.$strip>;
-type AxisContext$1 = z.infer<typeof AxisContextZ>;
-
-declare const AXIS_META_KEY = "axis:axis";
-declare const SENSITIVITY_METADATA_KEY = "axis:sensitivity";
-declare const CONTRACT_METADATA_KEY = "axis:contract";
-declare const REQUIRED_PROOF_METADATA_KEY = "axis:required_proof";
-type RequiredProofKind = ProofKind | "WITNESS";
-declare function Sensitivity(level: SensitivityLevel): ClassDecorator & MethodDecorator;
-declare function Contract(options: Partial<ExecutionContract>): ClassDecorator & MethodDecorator;
-declare function RequiredProof(proofs: [RequiredProofKind, ...RequiredProofKind[]]): ClassDecorator & MethodDecorator;
-declare function Capsule(): ClassDecorator & MethodDecorator;
-declare function Witness(): ClassDecorator & MethodDecorator;
-declare function Axis(): ClassDecorator;
-declare const AXIS_PUBLIC_KEY = "axis:public";
-declare function AxisPublic(): ClassDecorator & MethodDecorator;
-declare const AXIS_ANONYMOUS_KEY = "axis:anonymous";
-declare function AxisAnonymous(): ClassDecorator & MethodDecorator;
-declare const AXIS_RATE_LIMIT_KEY = "axis:rateLimit";
-interface AxisRateLimitConfig {
-    max: number;
-    windowSec: number;
-    key?: string;
-}
-declare function AxisRateLimit(config: AxisRateLimitConfig): MethodDecorator;
-
 declare const HANDLER_METADATA_KEY = "axis:handler";
 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;
-    kind: "utf8" | "u64" | "bytes" | "bytes16" | "bool" | "obj" | "arr";
-    required?: boolean;
-    maxLen?: number;
-    max?: string;
-    scope?: "header" | "body";
-}
-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 extends AxisIntentSensorOptions {
-    kind?: IntentKind;
-    sensitivity?: SensitivityLevel;
-    absolute?: boolean;
-    frame?: boolean;
-    chain?: boolean | ChainOptions;
-    bodyProfile?: "TLV_MAP" | "RAW" | "TLV_OBJ" | "TLV_ARR";
-    tlv?: IntentTlvField[];
-    dto?: Function;
-    decoder?: (buf: Buffer) => any;
-}
-declare function Intent(action: string, options?: IntentOptions): MethodDecorator;
-
 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: AxisIntentSensorRef[]): MethodDecorator;
 
-declare const OBSERVER_METADATA_KEY = "axis:observer";
-declare const OBSERVER_BINDINGS_KEY = "axis:observer:bindings";
-type AxisObserverRef = string | Function;
-interface AxisObserverDefinition {
-    name?: string;
-    tags?: string[];
-    events?: AxisObserverEvent[];
-    intents?: string[];
-    handlers?: string[];
-}
-interface AxisObserverBinding {
-    refs: AxisObserverRef[];
-    tags?: string[];
-    events?: AxisObserverEvent[];
-}
-interface AxisObserverBindingOptions {
-    use: AxisObserverRef | AxisObserverRef[];
-    tags?: string[];
-    events?: AxisObserverEvent[];
-}
-declare function Observer(input?: AxisObserverDefinition | AxisObserverBindingOptions | AxisObserverRef | AxisObserverRef[]): ClassDecorator & MethodDecorator;
-
 declare const HANDLER_SENSORS_KEY = "axis:handler:sensors";
 declare function HandlerSensors(sensors: AxisIntentSensorRef[]): ClassDecorator;
 
 declare const SENSOR_METADATA_KEY = "axis:sensor";
-type SensorPhase = 'PRE_DECODE' | 'POST_DECODE';
+type SensorPhase = "PRE_DECODE" | "POST_DECODE";
 interface SensorOptions {
     phase?: SensorPhase;
 }
 declare function Sensor(options?: SensorOptions): ClassDecorator;
 
-declare const TLV_FIELDS_KEY = "axis:tlv:fields";
-declare const TLV_VALIDATORS_KEY = "axis:tlv:validators";
-type TlvFieldKind = 'utf8' | 'u64' | 'bytes' | 'bytes16' | 'bool' | 'obj' | 'arr';
-interface TlvFieldOptions {
-    kind: TlvFieldKind;
-    required?: boolean;
-    maxLen?: number;
-    max?: string;
-    scope?: 'header' | 'body';
+declare const PRIORITY_ORDER_METADATA_KEY = "axis:priority-order";
+type AxisPriorityLevel = "HIGH" | "MEDIUM" | "LOW";
+type AxisPriorityLevelInput = AxisPriorityLevel | "high" | "medium" | "low" | "High" | "Medium" | "Low";
+interface PriorityOrderDefinition {
+    priority: AxisPriorityLevel;
+    order: number;
 }
-interface TlvFieldMeta {
-    property: string;
-    tag: number;
-    options: TlvFieldOptions;
-}
-type TlvValidatorFn = (value: Uint8Array, property: string) => string | null | undefined;
-interface TlvValidatorMeta {
-    property: string;
-    tag: number;
-    validators: TlvValidatorFn[];
+interface PriorityOrderOptions {
+    priority?: AxisPriorityLevelInput;
+    order?: number;
 }
-declare function TlvField(tag: number, options: TlvFieldOptions): PropertyDecorator;
-declare function TlvValidate(validator: TlvValidatorFn): PropertyDecorator;
-declare function TlvUtf8Pattern(pattern: RegExp, message?: string): PropertyDecorator;
-declare function TlvMinLen(min: number, message?: string): PropertyDecorator;
-declare function TlvEnum(allowed: string[], message?: string): PropertyDecorator;
-declare function TlvRange(min: bigint, max: bigint, message?: string): PropertyDecorator;
+declare function getPriorityOrder(target: Function): PriorityOrderDefinition | null;
+declare function comparePriorityOrder(left: PriorityOrderDefinition, right: PriorityOrderDefinition): number;
+declare function getPriorityOrderedTargets(targets?: Iterable<Function>): Function[];
+declare function PriorityOrder(priorityOrOptions?: AxisPriorityLevelInput | PriorityOrderOptions, order?: number): ClassDecorator;
+declare const priorityOrder: typeof PriorityOrder;
 
 interface DtoSchema {
     fields: IntentTlvField[];
@@ -380,622 +87,9 @@ declare abstract class AxisResponseDto extends AxisTlvDto {
     updated_by?: string;
 }
 
-declare const CCE_PROTOCOL_VERSION: "cce-v1";
-type CceAlgorithm = "AES-256-GCM";
-type CceKemAlgorithm = "X25519" | "RSA-OAEP-256";
-type CceKdfAlgorithm = "HKDF-SHA256";
-interface CceCapsuleClaims {
-    capsule_id: string;
-    ver: typeof CCE_PROTOCOL_VERSION;
-    sub: string;
-    kid: string;
-    intent: string;
-    aud: string;
-    tps_from: number;
-    tps_to: number;
-    capsule_nonce: string;
-    challenge_id: string;
-    proof_hash?: string;
-    policy_hash?: string;
-    iat: number;
-    exp: number;
-    mode: "SINGLE_USE" | "SESSION";
-    scope?: string[];
-    constraints?: CceConstraints;
-    issuer_sig: CceSignature;
-}
-interface CceConstraints {
-    max_payload_bytes?: number;
-    ip_allow?: string[];
-    device_allow?: string[];
-    country_allow?: string[];
-}
-interface CceSignature {
-    alg: "EdDSA" | "ES256";
-    kid: string;
-    value: string;
-}
-interface CceRequestEnvelope {
-    ver: typeof CCE_PROTOCOL_VERSION;
-    request_id: string;
-    correlation_id: string;
-    client_kid: string;
-    capsule: CceCapsuleClaims;
-    encrypted_key: CceEncryptedKey;
-    encrypted_payload: CceEncryptedPayload;
-    request_nonce: string;
-    client_sig: CceSignature;
-    content_type: string;
-    algorithms: CceAlgorithmDescriptor;
-    aad_descriptor?: string;
-}
-interface CceEncryptedKey {
-    alg: CceKemAlgorithm;
-    axis_kid: string;
-    ciphertext: string;
-    ephemeral_pk?: string;
-}
-interface CceEncryptedPayload {
-    alg: CceAlgorithm;
-    iv: string;
-    ciphertext: string;
-    tag: string;
-}
-interface CceAlgorithmDescriptor {
-    kem: CceKemAlgorithm;
-    enc: CceAlgorithm;
-    kdf: CceKdfAlgorithm;
-    sig: "EdDSA" | "ES256";
-}
-interface CceResponseEnvelope {
-    ver: typeof CCE_PROTOCOL_VERSION;
-    response_id: string;
-    request_id: string;
-    correlation_id: string;
-    capsule_id: string;
-    encrypted_key: CceEncryptedKey;
-    encrypted_payload: CceEncryptedPayload;
-    response_nonce: string;
-    axis_sig: CceSignature;
-    witness_ref?: string;
-    algorithms: CceAlgorithmDescriptor;
-    status: CceResponseStatus;
-}
-type CceResponseStatus = "SUCCESS" | "DENIED" | "PARTIAL" | "FAILED" | "ERROR";
-interface CceExecutionContext {
-    execution_key_hash: string;
-    request_id: string;
-    capsule_id: string;
-    sub: string;
-    kid: string;
-    intent: string;
-    aud: string;
-    tps_from: number;
-    tps_to: number;
-    policy_hash?: string;
-    derived_at: number;
-    valid: boolean;
-}
-interface CceWitnessRecord {
-    witness_id: string;
-    request_id: string;
-    capsule_id: string;
-    sub: string;
-    intent: string;
-    aud: string;
-    tps_from: number;
-    tps_to: number;
-    timestamp: number;
-    verification: {
-        client_sig: boolean;
-        capsule_sig: boolean;
-        tps_valid: boolean;
-        audience_match: boolean;
-        intent_match: boolean;
-        replay_clean: boolean;
-        nonce_unique: boolean;
-        decryption_ok: boolean;
-    };
-    execution: {
-        status: CceResponseStatus;
-        handler_duration_ms: number;
-        effect?: string;
-    };
-    response_encrypted: boolean;
-    execution_context_hash: string;
-    request_payload_hash?: string;
-    response_payload_hash?: string;
-}
-declare const CCE_ERROR: {
-    readonly INVALID_ENVELOPE: "CCE_INVALID_ENVELOPE";
-    readonly UNSUPPORTED_VERSION: "CCE_UNSUPPORTED_VERSION";
-    readonly MISSING_CAPSULE: "CCE_MISSING_CAPSULE";
-    readonly MISSING_ENCRYPTED_KEY: "CCE_MISSING_ENCRYPTED_KEY";
-    readonly CLIENT_SIG_INVALID: "CCE_CLIENT_SIG_INVALID";
-    readonly CLIENT_KEY_NOT_FOUND: "CCE_CLIENT_KEY_NOT_FOUND";
-    readonly CAPSULE_SIG_INVALID: "CCE_CAPSULE_SIG_INVALID";
-    readonly CAPSULE_EXPIRED: "CCE_CAPSULE_EXPIRED";
-    readonly CAPSULE_NOT_YET_VALID: "CCE_CAPSULE_NOT_YET_VALID";
-    readonly CAPSULE_REVOKED: "CCE_CAPSULE_REVOKED";
-    readonly CAPSULE_CONSUMED: "CCE_CAPSULE_CONSUMED";
-    readonly AUDIENCE_MISMATCH: "CCE_AUDIENCE_MISMATCH";
-    readonly INTENT_MISMATCH: "CCE_INTENT_MISMATCH";
-    readonly TPS_WINDOW_EXPIRED: "CCE_TPS_WINDOW_EXPIRED";
-    readonly TPS_WINDOW_FUTURE: "CCE_TPS_WINDOW_FUTURE";
-    readonly REPLAY_DETECTED: "CCE_REPLAY_DETECTED";
-    readonly NONCE_REUSED: "CCE_NONCE_REUSED";
-    readonly DECRYPTION_FAILED: "CCE_DECRYPTION_FAILED";
-    readonly KEY_UNWRAP_FAILED: "CCE_KEY_UNWRAP_FAILED";
-    readonly AEAD_TAG_MISMATCH: "CCE_AEAD_TAG_MISMATCH";
-    readonly PAYLOAD_TOO_LARGE: "CCE_PAYLOAD_TOO_LARGE";
-    readonly PAYLOAD_SCHEMA_INVALID: "CCE_PAYLOAD_SCHEMA_INVALID";
-    readonly INTENT_SCHEMA_MISMATCH: "CCE_INTENT_SCHEMA_MISMATCH";
-    readonly POLICY_DENIED: "CCE_POLICY_DENIED";
-    readonly CONSTRAINT_VIOLATED: "CCE_CONSTRAINT_VIOLATED";
-    readonly HANDLER_NOT_FOUND: "CCE_HANDLER_NOT_FOUND";
-    readonly HANDLER_EXECUTION_FAILED: "CCE_HANDLER_EXECUTION_FAILED";
-    readonly HANDLER_TIMEOUT: "CCE_HANDLER_TIMEOUT";
-    readonly RESPONSE_ENCRYPTION_FAILED: "CCE_RESPONSE_ENCRYPTION_FAILED";
-};
-type CceErrorCode = (typeof CCE_ERROR)[keyof typeof CCE_ERROR];
-declare class CceError extends Error {
-    readonly code: CceErrorCode;
-    readonly metadata?: Record<string, unknown> | undefined;
-    constructor(code: CceErrorCode, message: string, metadata?: Record<string, unknown> | undefined);
-    get clientSafe(): boolean;
-    toClientError(): {
-        code: CceErrorCode;
-        message: string;
-    };
-}
-
-interface CceClientKeyEncryptor {
-    wrapKey(aesKey: Uint8Array, clientKid: string, clientPublicKeyHex: string): Promise<CceEncryptedKey>;
-}
-interface CceAxisSigner {
-    sign(payload: Uint8Array): Promise<CceSignature>;
-}
-
-interface CceWitnessStore {
-    record(witness: CceWitnessRecord): Promise<void>;
-}
-
-type AxisAlg$1 = 'EdDSA' | 'ES256' | 'RS256';
-type CapsuleMode = 'SINGLE_USE' | 'MULTI_USE';
-type KeyStatus = 'ACTIVE' | 'GRACE' | 'REVOKED' | 'RETIRED';
-interface AxisSig$1 {
-    alg: AxisAlg$1;
-    kid: string;
-    value: string;
-}
-interface AxisPacket$1<T = any> {
-    v: 1;
-    pid: string;
-    nonce: string;
-    ts: number;
-    actorId: string;
-    opcode: string;
-    body: T;
-    sig: AxisSig$1;
-}
-interface AxisCapsuleConstraints {
-    maxAmount?: number;
-    maxCount?: number;
-    ttlSeconds?: number;
-    ipCidrAllow?: string[];
-    countryAllow?: string[];
-    deviceIdAllow?: string[];
-    sessionIdLock?: string;
-    nonceRequired?: boolean;
-}
-interface TickWindow {
-    start: number;
-    end: number;
-}
-interface AxisCapsulePayload {
-    v: 1;
-    capsuleId: string;
-    actorId: string;
-    issuer: string;
-    audience: string;
-    subject?: string;
-    intent: string;
-    scopes: string[];
-    actions?: string[];
-    iat: number;
-    nbf?: number;
-    exp: number;
-    tickWindow?: TickWindow;
-    mode: CapsuleMode;
-    maxUses: number;
-    nonceSeed?: string;
-    policyRefs?: string[];
-    riskScore?: number;
-    constraints?: AxisCapsuleConstraints;
-    meta?: Record<string, unknown>;
-}
-interface AxisCapsule {
-    payload: AxisCapsulePayload;
-    sig: AxisSig$1;
-}
-interface AxisResponse$1<T = any> {
-    ok: boolean;
-    pid: string;
-    decisionId: string;
-    code: string;
-    message?: string;
-    data?: T;
-    meta?: Record<string, unknown>;
-}
-
-type AxisAlg = Extract<AxisAlg$1, 'EdDSA'>;
-type AxisSig = AxisSig$1 & {
-    alg: AxisAlg;
-};
-interface AxisFrame<T = any> {
-    v: 1;
-    pid: string;
-    nonce: string;
-    ts: number;
-    actorId: string;
-    aud?: string;
-    opcode: string;
-    headers: Map<number, Uint8Array>;
-    body: T;
-    sig: AxisSig;
-}
-type AxisResponse<T = any> = AxisResponse$1<T> & {
-    policyRefs?: string[];
-    riskScore?: number;
-};
-interface AxisObservedContext {
-    ip?: string;
-    ua?: string;
-    geo?: string;
-}
-interface AxisRequestContext {
-    observed: AxisObservedContext;
-    actorKeyKid?: string;
-    issuerKeyKid?: string;
-    decisionId: string;
-    actorId: string;
-    aud?: string;
-    opcode: string;
-    deviceId?: string;
-    sessionId?: string;
-}
-
-interface SensorPhaseMetadata {
-    phase: 'PRE_DECODE' | 'POST_DECODE';
-    dependencies?: string[];
-    asyncOk?: boolean;
-    cryptoOk?: boolean;
-    description?: string;
-}
-interface AxisSensor {
-    readonly name: string;
-    readonly order?: number;
-    phase?: SensorPhaseMetadata | 'PRE_DECODE' | 'POST_DECODE';
-    supports?(input: SensorInput): boolean;
-    run(input: SensorInput): Promise<SensorDecision>;
-}
-interface AxisSensorInit extends AxisSensor {
-    onModuleInit?(): void | Promise<void>;
-}
-interface AxisPreSensor extends AxisSensor {
-    phase: 'PRE_DECODE';
-}
-interface AxisPostSensor extends AxisSensor {
-    phase: 'POST_DECODE';
-}
-interface SensorInput {
-    rawBytes?: Buffer | Uint8Array;
-    intent?: string;
-    ip?: string;
-    path?: string;
-    contentLength?: number;
-    peek?: Uint8Array;
-    country?: string;
-    clientId?: string;
-    isWs?: boolean;
-    metadata?: Record<string, any>;
-    actorId?: string;
-    opcode?: string;
-    aud?: string;
-    observed?: AxisObservedContext;
-    frameBody?: any;
-    deviceId?: string;
-    sessionId?: string;
-    packet?: Record<string, any>;
-    [key: string]: any;
-}
-declare enum Decision {
-    ALLOW = "ALLOW",
-    DENY = "DENY",
-    THROTTLE = "THROTTLE",
-    FLAG = "FLAG"
-}
-type SensorDecision = {
-    decision?: Decision;
-    allow: boolean;
-    riskScore: number;
-    reasons: string[];
-    code?: string;
-    retryAfterMs?: number;
-    scoreDelta?: number;
-    tags?: Record<string, any>;
-    meta?: any;
-    tighten?: {
-        expSecondsMax?: number;
-        constraintsPatch?: Record<string, any>;
-    };
-} | {
-    action: 'ALLOW';
-    meta?: any;
-} | {
-    action: 'DENY';
-    code: string;
-    reason?: string;
-    retryAfterMs?: number;
-    meta?: any;
-} | {
-    action: 'THROTTLE';
-    retryAfterMs: number;
-    meta?: any;
-} | {
-    action: 'FLAG';
-    scoreDelta: number;
-    reasons: string[];
-    meta?: any;
-};
-type SensorMinifiedDecision = {
-    allow: boolean;
-    riskScore: number;
-    reasons: string[];
-    tags?: Record<string, any>;
-    meta?: any;
-    tighten?: {
-        expSecondsMax?: number;
-        constraintsPatch?: Record<string, any>;
-    };
-    retryAfterMs?: number;
-};
-declare function normalizeSensorDecision(sensorDecision: SensorDecision): SensorMinifiedDecision;
-declare const SensorDecisions: {
-    allow(meta?: any, tags?: Record<string, any>): SensorDecision;
-    deny(code: string, reason?: string, meta?: any): SensorDecision;
-    throttle(retryAfterMs: number, meta?: any): SensorDecision;
-    flag(scoreDelta: number, reasons: string[], meta?: any): SensorDecision;
-};
-
-type CceHandler = (payload: Uint8Array, context: CceHandlerContext) => Promise<CceHandlerResult>;
-interface CceHandlerContext {
-    capsule: CceCapsuleClaims;
-    executionContext: CceExecutionContext;
-    envelope: CceRequestEnvelope;
-    clientPublicKeyHex: string;
-    intent: string;
-    sub: string;
-}
-interface CceHandlerResult {
-    status: CceResponseStatus;
-    body: Uint8Array;
-    effect?: string;
-}
-interface CcePolicyContext {
-    envelope: CceRequestEnvelope;
-    capsule: CceCapsuleClaims;
-    executionContext: CceExecutionContext;
-    decryptedPayload: Uint8Array;
-    clientPublicKeyHex: string;
-}
-interface CcePolicyDecision {
-    allow: boolean;
-    code?: string;
-    message?: string;
-}
-interface CcePolicyEvaluator {
-    evaluate(context: CcePolicyContext): Promise<CcePolicyDecision>;
-}
-interface CcePipelineConfig {
-    axisLocalSecret: string;
-    axisAudience: string;
-    sensors: AxisSensor[];
-    handlers: Map<string, CceHandler>;
-    witnessStore: CceWitnessStore;
-    clientKeyEncryptor: CceClientKeyEncryptor;
-    axisSigner: CceAxisSigner;
-    policyEvaluator?: CcePolicyEvaluator;
-}
-type CcePipelineResult = {
-    ok: true;
-    response: CceResponseEnvelope;
-    witnessId: string;
-} | {
-    ok: false;
-    error: {
-        code: string;
-        message: string;
-    };
-    status: CceResponseStatus;
-};
-declare function executeCcePipeline(envelope: CceRequestEnvelope, config: CcePipelineConfig): Promise<CcePipelineResult>;
-
-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";
-    fields: Array<{
-        name: string;
-        tlv: number;
-        kind: IntentTlvField["kind"];
-        required?: boolean;
-        maxLen?: number;
-        max?: string;
-        scope?: "header" | "body";
-    }>;
-}
-interface AxisEffect {
-    ok: boolean;
-    effect: string;
-    body?: Uint8Array;
-    headers?: Map<number, Uint8Array>;
-    metadata?: any;
-}
-declare class IntentRouter {
-    private readonly moduleRef?;
-    private readonly observerDispatcher?;
-    private readonly sensorRegistry?;
-    private readonly logger;
-    private readonly decoder;
-    private readonly encoder;
-    private static readonly BUILTIN_INTENTS;
-    private handlers;
-    private intentSensors;
-    private intentDecoders;
-    private intentSchemas;
-    private intentValidators;
-    private intentKinds;
-    private intentChains;
-    private intentObservers;
-    private intentCapsulePolicies;
-    private intentSensitivity;
-    private intentContracts;
-    private intentRequiredProof;
-    private publicIntents;
-    private anonymousIntents;
-    private intentRateLimits;
-    private cceHandlers;
-    private ccePipelineConfig;
-    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$1;
-        validators?: Map<number, TlvValidatorFn[]>;
-        hasSensors: boolean;
-        builtin: boolean;
-        kind?: IntentKind;
-        chain?: RegisteredChainConfig;
-        capsulePolicy?: CapsulePolicyOptions;
-        observerCount: number;
-    } | null;
-    getChainConfig(intent: string): RegisteredChainConfig | undefined;
-    getObservers(intent: string): AxisObserverBinding[];
-    register(intent: string, handler: any): void;
-    registerHandler(instance: any): void;
-    route(frame: AxisFrame$1): Promise<AxisEffect>;
-    private logIntent;
-    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;
-    isAnonymous(intent: string): boolean;
-    getRateLimit(intent: string): AxisRateLimitConfig | undefined;
-    private emitIntentObservers;
-    private runIntentSensors;
-    private resolveIntentSensor;
-    private getEffectiveCapsulePolicy;
-    private enforceCapsulePolicy;
-    private executeChainRequest;
-    private parseIntentExecBody;
-    private parseChainRequestBody;
-    private isChainRequestLike;
-    private isChainEnvelopeLike;
-    private encodeJson;
-    private getActorIdFromFrame;
-    private getProofRefFromFrame;
-    private hasCapsuleReference;
-    private getHeaderValue;
-    private identifiersMatch;
-    private extractInlineCapsuleId;
-    private toInlineCapsuleRecord;
-    private toScopeList;
-    configureCce(config: Omit<CcePipelineConfig, "handlers">): void;
-    registerCceHandler(intent: string, handler: CceHandler): void;
-    hasCceHandler(intent: string): boolean;
-    routeCce(envelope: CceRequestEnvelope): Promise<CcePipelineResult>;
-    private storeSchema;
-}
-
-interface AxisObserverContext {
-    event: AxisObserverEvent;
-    timestamp: number;
-    intent?: string;
-    chainId?: string;
-    stepId?: string;
-    handler?: string;
-    frame?: AxisFrame$1;
-    envelope?: AxisChainEnvelope;
-    step?: AxisChainStep;
-    effect?: AxisEffect;
-    result?: AxisChainStepResult | AxisChainResult;
-    error?: string;
-    observerTags?: string[];
-    capsule?: AxisCapsuleRef;
-    keyExchange?: AxisKeyExchangeRef;
-    metadata?: Record<string, unknown>;
-}
-interface AxisIntentObserver {
-    readonly name: string;
-    supports?(context: AxisObserverContext): boolean;
-    observe(context: AxisObserverContext): Promise<void> | void;
-}
-interface AxisObserverRegistration {
-    name: string;
-    instance: AxisIntentObserver;
-    tags: string[];
-    events?: AxisObserverEvent[];
-    intents?: string[];
-    handlers?: string[];
-}
-
-declare class ObserverRegistry {
-    private readonly logger;
-    private readonly byName;
-    private readonly byType;
-    register(instance: AxisIntentObserver, meta?: AxisObserverDefinition): void;
-    resolve(ref: AxisObserverRef): AxisObserverRegistration | undefined;
-    list(): AxisObserverRegistration[];
-    clear(): void;
-}
-
-declare class ObserverDispatcherService {
-    private readonly registry;
-    private readonly logger;
-    constructor(registry: ObserverRegistry);
-    dispatch(bindings: AxisObserverBinding[] | undefined, context: AxisObserverContext): Promise<void>;
-}
-
 interface AxisChainExecutionOptions {
     actorId?: string;
-    baseFrame?: Partial<AxisFrame$1>;
+    baseFrame?: Partial<AxisFrame>;
 }
 declare class AxisChainExecutor {
     private readonly router;
@@ -1030,7 +124,7 @@ interface AxisExecutionContext {
     chainEnvelope?: AxisChainEnvelope;
     chainStep?: AxisChainStep;
 }
-declare function getAxisExecutionContext(frame?: Partial<AxisFrame$1>): AxisExecutionContext | undefined;
+declare function getAxisExecutionContext(frame?: Partial<AxisFrame>): AxisExecutionContext | undefined;
 declare function withAxisExecutionContext<T extends object>(target: T, context: AxisExecutionContext): T;
 declare function mergeAxisExecutionContext(base?: AxisExecutionContext, override?: AxisExecutionContext): AxisExecutionContext | undefined;
 
@@ -1047,46 +141,6 @@ declare const PRE_DECODE_BOUNDARY = 40;
 
 declare function stableJsonStringify(value: unknown): string;
 
-interface ObservationStage {
-    name: string;
-    status: 'ok' | 'fail' | 'skip';
-    startMs: number;
-    endMs?: number;
-    durationMs?: number;
-    reason?: string;
-    code?: string;
-}
-interface ObservationSensor {
-    name: string;
-    allowed: boolean;
-    riskScore: number;
-    durationMs: number;
-    reasons: string[];
-    code?: string;
-}
-interface AxisObservation {
-    id: string;
-    startMs: number;
-    transport: 'http' | 'ws';
-    ip?: string;
-    intent?: string;
-    actorId?: string;
-    capsuleId?: string;
-    stages: ObservationStage[];
-    sensors: ObservationSensor[];
-    decision?: 'ALLOW' | 'DENY';
-    resultCode?: string;
-    statusCode?: number;
-    endMs?: number;
-    durationMs?: number;
-    facts: Record<string, unknown>;
-}
-declare function createObservation(transport: 'http' | 'ws', ip?: string): AxisObservation;
-declare function startStage(obs: AxisObservation, name: string): ObservationStage;
-declare function endStage(stage: ObservationStage, status?: 'ok' | 'fail' | 'skip', reason?: string, code?: string): void;
-declare function recordSensor(obs: AxisObservation, name: string, allowed: boolean, riskScore: number, durationMs: number, reasons: string[], code?: string): void;
-declare function finalizeObservation(obs: AxisObservation, decision: 'ALLOW' | 'DENY', statusCode: number, resultCode?: string): void;
-
 interface ObservationQueueMessage {
     v: 1;
     observation: AxisObservation;
@@ -1142,42 +196,6 @@ 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;
@@ -1555,65 +573,64 @@ 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 {
+type ProofType = 1 | 2 | 3 | 4;
+interface ProofVerificationResult {
+    valid: boolean;
     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>;
+    error?: string;
+    metadata?: Record<string, any>;
 }
-type AxisLawEvaluator = ((context: AxisLawEvaluationContext) => AxisLawEvaluationResult | Promise<AxisLawEvaluationResult>);
-interface LawEvaluationSensorOptions {
-    evaluator?: AxisLawEvaluator;
-    conditionalDecision?: "deny" | "flag" | "allow";
+interface MTLSContext {
+    clientCertPem?: string;
+    clientCertFingerprint?: string;
+    clientCertSubject?: string;
+    clientCertIssuer?: string;
+    verified?: boolean;
 }
-declare function buildAxisLawEvaluationContext(input: SensorInput): AxisLawEvaluationContext;
-
-interface RiskSignal {
-    type: string;
-    severity: 'low' | 'medium' | 'high' | 'critical';
-    value: any;
-    message: string;
+interface DeviceSEContext {
+    deviceId: string;
+    signature: Uint8Array;
+    publicKey: Uint8Array;
+    challenge?: Uint8Array;
 }
-declare enum RiskDecision {
-    ALLOW = "ALLOW",
-    THROTTLE = "THROTTLE",
-    STEP_UP = "STEP_UP",
-    WITNESS = "WITNESS",
-    DENY = "DENY"
+declare class ProofVerificationService {
+    private readonly logger;
+    private readonly deviceKeys;
+    private readonly trustedCerts;
+    verifyProof(proofType: ProofType, proofRef: Uint8Array, context: {
+        signTarget?: Uint8Array;
+        signature?: Uint8Array;
+        mtls?: MTLSContext;
+        deviceSE?: DeviceSEContext;
+    }): Promise<ProofVerificationResult>;
+    private verifyCapsuleProof;
+    private verifyJWTProof;
+    private verifyMTLSProof;
+    private verifyDeviceSEProof;
+    registerDeviceKey(deviceId: string, publicKey: Uint8Array): void;
+    unregisterDevice(deviceId: string): boolean;
+    registerMTLSCert(fingerprint: string, actorId: string): void;
+    revokeMTLSCert(fingerprint: string): boolean;
+    static calculateFingerprint(certPem: string): string;
+}
+
+declare enum BodyProfile {
+    RAW = 0,
+    TLV_MAP = 1,
+    OBJ = 2,
+    ARR = 3
+}
+interface BodyProfileValidation {
+    valid: boolean;
+    error?: string;
+    profile: BodyProfile;
 }
-interface RiskEvaluation {
-    decision: RiskDecision;
-    reason?: string;
-    retryAfterMs?: number;
-    confidence: number;
-    signals: RiskSignal[];
+declare class BodyProfileValidator {
+    validate(body: Uint8Array, profile: BodyProfile): BodyProfileValidation;
+    private validateRaw;
+    private validateTlvMap;
+    private validateObj;
+    private validateArr;
 }
 
 declare const AXIS_OPCODES: Set<string>;
@@ -1653,6 +670,10 @@ interface IntentDefinition {
 declare function validateFrameShape(frame: any): boolean;
 declare function isTimestampValid(ts: number, skewSeconds?: number): boolean;
 
+declare const AXIS_UPLOAD_SESSION_STORE = "AXIS_UPLOAD_SESSION_STORE";
+declare const AXIS_UPLOAD_FILE_STORE = "AXIS_UPLOAD_FILE_STORE";
+declare const AXIS_UPLOAD_RECEIPT_SIGNER = "AXIS_UPLOAD_RECEIPT_SIGNER";
+
 type UploadSessionStatus = 'ACTIVE' | 'FINALIZING' | 'COMPLETE' | 'ABORTED';
 interface UploadSessionRecord {
     id?: string;
@@ -1691,32 +712,6 @@ interface UploadFileStore {
     createTempReadStream(fileId: string): NodeJS.ReadableStream;
 }
 
-declare class AxisFilesDownloadHandler implements AxisHandler {
-    private readonly sessions;
-    private readonly files;
-    private readonly logger;
-    readonly name = "axis.files.download";
-    readonly open = true;
-    readonly description = "File download handler";
-    constructor(sessions: UploadSessionStore, files: UploadFileStore);
-    execute(body: Uint8Array, headers?: Map<number, Uint8Array>): Promise<any>;
-}
-declare class AxisFilesFinalizeHandler implements AxisHandler {
-    private readonly sessions;
-    private readonly files;
-    private readonly keyring?;
-    private readonly logger;
-    readonly name = "axis.files.finalize";
-    readonly open = false;
-    readonly description = "File upload finalization handler";
-    constructor(sessions: UploadSessionStore, files: UploadFileStore, keyring?: UploadReceiptSigner | undefined);
-    execute(body: Uint8Array, headers?: Map<number, Uint8Array>): Promise<any>;
-}
-
-declare const AXIS_UPLOAD_SESSION_STORE = "AXIS_UPLOAD_SESSION_STORE";
-declare const AXIS_UPLOAD_FILE_STORE = "AXIS_UPLOAD_FILE_STORE";
-declare const AXIS_UPLOAD_RECEIPT_SIGNER = "AXIS_UPLOAD_RECEIPT_SIGNER";
-
 interface DiskUploadFileStoreOptions {
     uploadDir: string;
     chunkDir: string;
@@ -1734,48 +729,10 @@ declare class DiskUploadFileStore implements UploadFileStore {
     createTempReadStream(fileId: string): NodeJS.ReadableStream;
 }
 
-interface AxisRequestData {
-    raw: Buffer;
-    ip: string | undefined;
-    preDecodeInput: any;
-    frameBytesCount: number;
-}
-declare const AxisRaw: (...dataOrPipes: unknown[]) => ParameterDecorator;
-declare const AxisIp: (...dataOrPipes: unknown[]) => ParameterDecorator;
-declare const AxisContext: (...dataOrPipes: unknown[]) => ParameterDecorator;
-declare const AxisDemoPubkey: (...dataOrPipes: unknown[]) => ParameterDecorator;
-
-declare class ObserverDiscoveryService implements OnApplicationBootstrap {
-    private readonly discovery;
-    private readonly reflector;
-    private readonly registry;
-    private readonly logger;
-    constructor(discovery: DiscoveryService, reflector: Reflector, registry: ObserverRegistry);
-    onApplicationBootstrap(): void;
-}
-
-declare class HandlerDiscoveryService implements OnModuleInit {
-    private readonly discovery;
-    private readonly scanner;
-    private readonly router;
-    private readonly logger;
-    constructor(discovery: DiscoveryService, scanner: MetadataScanner, router: IntentRouter);
-    onModuleInit(): void;
-}
-
-declare class SensorDiscoveryService implements OnApplicationBootstrap {
-    private readonly discovery;
-    private readonly reflector;
-    private readonly registry;
-    private readonly logger;
-    constructor(discovery: DiscoveryService, reflector: Reflector, registry: SensorRegistry);
-    onApplicationBootstrap(): void;
-}
-
 interface AxisDecoded {
     frame: Axis1DecodedFrame;
     packet: AxisPacket;
-    axisCtx: AxisContext$1;
+    axisCtx: AxisContext;
     correlationId: Buffer;
     correlationIdHex: string;
     sensorInput: SensorInput;
@@ -1796,324 +753,15 @@ interface ChainResult {
 declare class AxisSensorChainService {
     private readonly registry;
     constructor(registry: SensorRegistry);
-    evaluate(input: SensorInput, phase?: 'PRE_DECODE' | 'POST_DECODE' | 'BOTH', baseDecision?: SensorDecision): Promise<SensorDecision>;
+    evaluate(input: SensorInput, phase?: "PRE_DECODE" | "POST_DECODE" | "BOTH", baseDecision?: SensorDecision): Promise<SensorDecision>;
     evaluatePre(input: SensorInput): Promise<SensorDecision>;
     evaluatePost(input: SensorInput, baseDecision?: SensorDecision): Promise<SensorDecision>;
     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;
 
-interface PresenceDeclaration {
-    softid: string;
-    device_meta?: {
-        fingerprint?: string;
-        platform?: string;
-        user_agent?: string;
-    };
-}
-interface PresenceChallenge {
-    challenge_id: string;
-    nonce: string;
-    temporal_anchor: number;
-    ttl_ms: number;
-    expires_at: number;
-}
-interface PresenceProof {
-    challenge_id: string;
-    signature: string;
-    public_key: string;
-    kid?: string;
-}
-interface PresenceReceipt {
-    presence_id: string;
-    softid: string;
-    anchor_reflection: string;
-    scope: {
-        ip?: string;
-        device_fingerprint?: string;
-    };
-    issued_at: number;
-    expires_at: number;
-    renewed_at?: number;
-}
-type PresenceStatus = 'active' | 'expired' | 'revoked';
-interface WritHead {
-    tid: string;
-    seq: number;
-}
-interface WritBody {
-    who: string;
-    act: string;
-    res: string;
-    law: string;
-}
-interface WritMeta {
-    iat: number;
-    exp: number;
-    prev: string;
-}
-interface WritSignature {
-    alg: 'ed25519';
-    value: string;
-    kid?: string;
-}
-interface Writ {
-    head: WritHead;
-    body: WritBody;
-    meta: WritMeta;
-    sig: WritSignature;
-}
-type GrantType = 'sovereign' | 'delegated' | 'system';
-interface GrantCapability {
-    oec: string;
-    scope: string;
-    limit?: {
-        rate?: string;
-        amount?: number;
-        depth?: string;
-    };
-}
-interface GrantMeta {
-    iat: number;
-    exp: number;
-    revocable: boolean;
-    version: number;
-    contract_ref?: string;
-}
-interface Grant {
-    grant_id: string;
-    issuer: string;
-    subject: string;
-    grant_type: GrantType;
-    caps: GrantCapability[];
-    meta: GrantMeta;
-    sig: WritSignature;
-}
-type GrantStatus = 'active' | 'revoked' | 'expired';
-interface LoomReceipt {
-    receipt_id: string;
-    writ_hash: string;
-    thread_id: string;
-    sequence: number;
-    effect: string;
-    hash: string;
-    prev_hash: string | null;
-    executed_at: number;
-    metadata?: Record<string, unknown>;
-}
-interface ThreadState {
-    thread_id: string;
-    softid: string;
-    last_receipt_hash: string;
-    sequence: number;
-    updated_at: number;
-}
-type RevocationTargetType = 'grant' | 'presence' | 'softid';
-interface Revocation {
-    revocation_id: string;
-    target_type: RevocationTargetType;
-    target_id: string;
-    issuer_softid: string;
-    reason?: string;
-    effective_at: number;
-    sig_value: string;
-}
-interface LoomValidationResult {
-    valid: boolean;
-    error?: string;
-    code?: string;
-}
-interface PresenceVerifyResult extends LoomValidationResult {
-    presence?: PresenceReceipt;
-}
-interface WritValidationResult extends LoomValidationResult {
-    writ?: Writ;
-    gate_failed?: 'temporal' | 'causal' | 'legal' | 'authentic';
-}
-interface GrantValidationResult extends LoomValidationResult {
-    grant?: Grant;
-}
-
-declare function deriveAnchorReflection(softid: string, context?: string, scope?: string): string;
-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;
@@ -2149,452 +797,4 @@ declare function executeLoomPipeline(writ: Writ, publicKeyHex: string, presence:
     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>;
-}
-
-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 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, classifyIntent, createFabric, createGrant, createObservation, createPresenceChallenge, createReceipt, createRevocation, createWrit, decodeQueueMessage, deriveAnchorReflection, detectAnomalies, detectKnotPatterns, detectSequencePatterns, diffFabrics, encVarint, encodeAxisTlvDto, encodeQueueMessage, endStage, executeCcePipeline, executeLoomPipeline, extractDtoSchema, finalizeObservation, findKnotsForStitch, forkFromKnot, formStitch, getAxisExecutionContext, getDecisionPoints, getFabricValue, getGrantStatus, getIrreversibleKnots, getPresenceStatus, grantCoversAction, hasScope, hashObservation, isAdminOpcode, isKnotOpen, isKnownOpcode, isPointOfNoReturn, isRevoked, isTimestampValid, lockCells, matchPatterns, mergeAxisExecutionContext, nonce16, normalizeSensorDecision, openKnot, packPasskeyLoginOptionsReq, packPasskeyLoginOptionsRes, packPasskeyLoginVerifyReq, packPasskeyLoginVerifyRes, packPasskeyRegisterOptionsReq, parseAutoClaimEntries, parseScope, parseStreamEntries, projectAt, queryFabric, recordOccurrence, recordSensor, renewPresence, resolveTimeout, runNeedlePipeline, scoreTruth, sensitivityName, signPresenceChallenge, stableJsonStringify, startStage, tieKnot, tlv, u64be, unpackPasskeyLoginOptionsReq, unpackPasskeyLoginVerifyReq, unpackPasskeyRegisterOptionsReq, updateThreadState, utf8, validateFrameShape, validateGrant, validateKnot, validateWrit, varintU, verifyObservation, verifyPresenceProof, verifyReceiptChain, verifyResponse, weave, withAxisExecutionContext };
+export { ATS1_HDR, ATS1_SCHEMA, AXIS_EXECUTION_CONTEXT_KEY, AXIS_OPCODES, AXIS_UPLOAD_FILE_STORE, AXIS_UPLOAD_RECEIPT_SIGNER, AXIS_UPLOAD_SESSION_STORE, ats1 as Ats1Codec, Axis1DecodedFrame, type AxisPacket as AxisBinaryPacket, AxisCapsuleRef, AxisChainEnvelope, AxisChainExecutor, AxisChainResult, AxisChainStep, type AxisCrudHandler, type AxisDecoded, type AxisExecutionContext, type AxisHandler, type AxisHandlerInit, AxisIdDto, AxisIntentSensorRef, AxisMediaTypes, AxisObservation, T as AxisPacketTags, AxisPartialType, type AxisPriorityLevel, type AxisPriorityLevelInput, AxisResponseDto, AxisSensorChainService, AxisTlvDto, BAND, BodyProfile, type BodyProfileValidation, BodyProfileValidator, CAPABILITIES, CHAIN_METADATA_KEY, type Capability, Chain, ChainOptions, type ChainResult, ContractViolationError, DEFAULT_TIMEOUT, type DeviceSEContext, DiskUploadFileStore, type DtoSchema, ExecutionMeter, type ExecutionMetrics, Grant, GrantCapability, GrantStatus, GrantValidationResult, HANDLER_METADATA_KEY, HANDLER_SENSORS_KEY, Handler, HandlerSensors, INTENT_BODY_KEY, INTENT_REQUIREMENTS, INTENT_SENSITIVITY_MAP, INTENT_SENSORS_KEY, INTENT_TIMEOUTS, IntentBody, type IntentDefinition, IntentRouter, IntentSensitivity, IntentSensors, IntentTlvField, type LoomExecutionResult, LoomReceipt, type MTLSContext, type ObservationQueueConfig, type ObservationQueueMessage, type ObservationStreamEntry, type ObservationWitnessSummary, ObserverDispatcherService, type ObserverVerdict, PRE_DECODE_BOUNDARY, PRIORITY_ORDER_METADATA_KEY, PROOF_CAPABILITIES, PresenceChallenge, PresenceDeclaration, PresenceProof, PresenceReceipt, PresenceStatus, PresenceVerifyResult, PriorityOrder, type PriorityOrderDefinition, type PriorityOrderOptions, type ProofType, type ProofVerificationResult, ProofVerificationService, RESPONSE_TAG_CREATED_AT, RESPONSE_TAG_CREATED_BY, RESPONSE_TAG_ID, RESPONSE_TAG_UPDATED_AT, RESPONSE_TAG_UPDATED_BY, type ReceiptEffect, type ResponseContract, ResponseObserver, type ResponseObserverContext, Revocation, SENSOR_METADATA_KEY, Schema2002_PasskeyLoginOptionsRes, Schema2011_PasskeyLoginVerifyReq, Schema2012_PasskeyLoginVerifyRes, Schema2021_PasskeyRegisterOptionsReq, Sensor, type SensorBand, SensorDecision, SensorInput, type SensorOptions, type SensorPhase, SensorRegistry, ThreadState, TlvValidatorFn, type UnsignedObservationWitness, type UploadFileStat, type UploadFileStore, type UploadReceiptSigner, type UploadSessionRecord, type UploadSessionStatus, type UploadSessionStore, Writ, WritBody, WritMeta, WritValidationResult, b64urlDecode, b64urlDecodeString, b64urlEncode, b64urlEncodeString, buildAts1Hdr, buildDtoDecoder, buildPacket, buildQueueMessage, buildReceiptHash, buildTLVs, buildUnsignedWitness, bytes, canAccessResource, canonicalJson, canonicalJsonExcluding, canonicalizeObservation, classifyIntent, comparePriorityOrder, createGrant, createPresenceChallenge, createReceipt, createRevocation, createWrit, decodeQueueMessage, encVarint, encodeAxisTlvDto, encodeQueueMessage, executeLoomPipeline, extractDtoSchema, getAxisExecutionContext, getGrantStatus, getPresenceStatus, getPriorityOrder, getPriorityOrderedTargets, grantCoversAction, hasScope, hashObservation, isAdminOpcode, isKnownOpcode, isRevoked, isTimestampValid, mergeAxisExecutionContext, nonce16, packPasskeyLoginOptionsReq, packPasskeyLoginOptionsRes, packPasskeyLoginVerifyReq, packPasskeyLoginVerifyRes, packPasskeyRegisterOptionsReq, parseAutoClaimEntries, parseScope, parseStreamEntries, priorityOrder, renewPresence, resolveTimeout, sensitivityName, signPresenceChallenge, stableJsonStringify, tlv, u64be, unpackPasskeyLoginOptionsReq, unpackPasskeyLoginVerifyReq, unpackPasskeyRegisterOptionsReq, updateThreadState, utf8, validateFrameShape, validateGrant, validateWrit, varintU, verifyPresenceProof, verifyReceiptChain, verifyResponse, withAxisExecutionContext };