@7h3/protocol 0.1.2 → 0.4.0

package/keyRotation.d.ts

@@ -1,20 +0,0 @@
-import type { ProtocolEnvelope, SignatureVerificationMaterial } from './protocol';
-export type KeyStatus = 'active' | 'verify-only' | 'revoked';
-export interface KeyRecord {
-    sender: string;
-    keyId: string;
-    alg: SignatureVerificationMaterial['alg'];
-    status: KeyStatus;
-    notBeforeMs: number;
-    notAfterMs: number;
-    material: SignatureVerificationMaterial;
-}
-export declare class RollingKeyring {
-    private readonly records;
-    constructor(records?: KeyRecord[]);
-    add(record: KeyRecord): void;
-    revoke(sender: string, keyId: string, revokedAtMs?: number): boolean;
-    selectSigningKey(sender: string, alg: SignatureVerificationMaterial['alg'], nowMs?: number): KeyRecord | null;
-    resolveVerificationMaterial(signature: NonNullable<ProtocolEnvelope['signature']>, sender: string, nowMs?: number): SignatureVerificationMaterial | undefined;
-}
-export declare function createKeyringSignatureResolver(keyring: RollingKeyring, nowMsProvider?: () => number): (signature: NonNullable<ProtocolEnvelope["signature"]>, sender: string) => Promise<SignatureVerificationMaterial | undefined>;

package/mcpGateway.d.ts

@@ -1,37 +0,0 @@
-import { type BootstrapRuntimePolicyEnforcerOptions } from './policyEnforcer';
-import { type JsonRpcPolicyEvent, type JsonRpcBridgeOptions } from './frameworkAdapters';
-export interface AipMcpGatewayOptions {
-    sharedSecret: string;
-    gatewayAgentId?: string;
-    workerAgentId?: string;
-    allowedMethods?: readonly string[];
-    workerCapabilityPrefix?: string;
-    methodToCapability?: JsonRpcBridgeOptions['methodToCapability'];
-    authorizeMethod?: JsonRpcBridgeOptions['authorizeMethod'];
-    rateLimitKey?: JsonRpcBridgeOptions['rateLimitKey'];
-    rateLimiter?: JsonRpcBridgeOptions['rateLimiter'];
-    onAuditEvent?: (event: AipMcpGatewayAuditEvent) => void | Promise<void>;
-    gatewayWireFormat?: 'json' | 'compact' | 'binary';
-    workerWireFormat?: 'json' | 'compact' | 'binary';
-    runtimePolicy?: {
-        enabled?: boolean;
-        options?: BootstrapRuntimePolicyEnforcerOptions;
-        concurrencyHint?: number;
-        latencySensitive?: boolean;
-        compatibilityFirst?: boolean;
-    };
-}
-export interface AipMcpGatewayRuntime {
-    handleLine: (line: string) => Promise<string | null>;
-}
-export interface AipMcpGatewayAuditEvent {
-    phase: 'request_received' | 'policy' | 'verification_failed' | 'request_success' | 'request_error';
-    id?: string | number | null;
-    method?: string;
-    code?: number;
-    message?: string;
-    policy?: JsonRpcPolicyEvent;
-    timestampMs: number;
-}
-export declare function createAipMcpGatewayRuntime(options: AipMcpGatewayOptions): AipMcpGatewayRuntime;
-export declare function createAipMcpGatewayRuntimeWithPolicy(options: AipMcpGatewayOptions): Promise<AipMcpGatewayRuntime>;

package/mcpTransports.d.ts

@@ -1,62 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Readable, Writable } from 'node:stream';
-import type { WireEnvelope } from './protocolTransport';
-/**
- * Transport adapters for the MCP hardening wrapper.
- *
- * The wrapper (`wrapMcpServer` / `wrapMcpClient`) is transport-agnostic: it
- * operates on `WireEnvelope`s. These adapters connect it to real transports —
- * newline-delimited stdio and HTTP — so a secured server is deployable as-is.
- *
- * Note: the stdio adapter frames one envelope per line and therefore supports
- * the string wire formats (`json`, `compact`). For `binary`, use HTTP.
- */
-type WireHandler = (raw: WireEnvelope) => Promise<WireEnvelope>;
-export interface StdioServerHandle {
-    close(): void;
-}
-/**
- * Serves a wrapped MCP handler over newline-delimited streams (default
- * `process.stdin` / `process.stdout`). Lines are processed sequentially so
- * responses are emitted in request order.
- */
-export declare function serveMcpOverStdio(handle: WireHandler, options?: {
-    input?: Readable;
-    output?: Writable;
-    onError?: (error: unknown) => void;
-}): StdioServerHandle;
-export interface StdioClientHandle {
-    send: WireHandler;
-    close(): void;
-}
-/**
- * Creates a stdio client `send` function for `wrapMcpClient`. Requests and
- * responses are correlated by order over the single pipe (one envelope per line).
- */
-export declare function createStdioMcpClient(options: {
-    input: Readable;
-    output: Writable;
-}): StdioClientHandle;
-/**
- * Creates a `node:http`-compatible request handler that runs the wrapped MCP
- * handler. The request body is the wire envelope; the response body is the
- * signed reply envelope.
- */
-export declare function createHttpMcpHandler(handle: WireHandler, options?: {
-    binary?: boolean;
-}): (req: IncomingMessage, res: ServerResponse) => void;
-export interface HttpClientHandle {
-    send: WireHandler;
-}
-/**
- * Creates an HTTP client `send` function for `wrapMcpClient`. POSTs the request
- * envelope to `url` and returns the response envelope. Uses the global `fetch`
- * by default; inject `fetchImpl` for tests or custom agents.
- */
-export declare function createHttpMcpClient(options: {
-    url: string;
-    fetchImpl?: typeof fetch;
-    binary?: boolean;
-    headers?: Record<string, string>;
-}): HttpClientHandle;
-export {};

package/mcpWrapper.d.ts

@@ -1,83 +0,0 @@
-import { type ProtocolEnvelope } from './protocol';
-import { type ReceiveEnvelopeOptions, type WireEnvelope, type WireFormat } from './protocolTransport';
-/**
- * MCP hardening middleware.
- *
- * MCP messages are plain JSON-RPC 2.0 and, as shipped, carry no signature or
- * replay protection. These wrappers put an AIP envelope around each message on
- * the wire — signing, TTL-bounding, and replay-checking every request and
- * response — while the underlying MCP handler still receives plain JSON-RPC.
- * "Zero app changes": your handler signature does not change.
- *
- * The wrappers enforce four bindings beyond signature verification:
- *   - recipient binding: the server only runs the handler when the envelope is
- *     addressed to it (`recipient === selfAgentId`) — defeats cross-server relay.
- *   - sender binding: the client only accepts responses from its expected peer
- *     (`sender === peerAgentId`) — defeats response spoofing.
- *   - correlation binding: the client only accepts a response whose
- *     `correlationId` matches the request it sent — defeats response substitution.
- *   - replay protection on by default (an `InMemoryReplayCache` if none supplied).
- *
- * Verification reuses the transport pipeline (`receiveEnvelope`), so it composes
- * directly with a Redis-backed replay cache (`createRedisReplayStore`) and
- * fleet-wide revocation (`withRevocationCheck`) via the `receive` options.
- */
-export type JsonRpcId = string | number | null;
-export interface JsonRpcRequest {
-    jsonrpc: '2.0';
-    id: JsonRpcId;
-    method: string;
-    params?: unknown;
-}
-export interface JsonRpcResponse {
-    jsonrpc: '2.0';
-    id: JsonRpcId;
-    result?: unknown;
-    error?: {
-        code: number;
-        message: string;
-        data?: unknown;
-    };
-}
-export type McpJsonRpcHandler = (request: JsonRpcRequest) => JsonRpcResponse | Promise<JsonRpcResponse>;
-export interface McpSecurityOptions {
-    /** This peer's agent id, used as the envelope `sender` and enforced as the inbound `recipient`. */
-    selfAgentId: string;
-    /** The peer's agent id: set as the envelope `recipient` (client) and enforced as the response `sender`. */
-    peerAgentId?: string;
-    /** Signs an unsigned envelope, e.g. `(e) => signEnvelopeHmac(e, secret, keyId)`. */
-    sign: (envelope: Omit<ProtocolEnvelope, 'signature'>) => Promise<ProtocolEnvelope>;
-    /** Inbound verification options: signature material resolver, replay cache, clock skew, etc. */
-    receive?: ReceiveEnvelopeOptions;
-    /** Wire format for the envelope on the wire. Default `compact`. */
-    wireFormat?: WireFormat;
-    /** Envelope TTL in ms. Default 60_000. */
-    ttlMs?: number;
-}
-export interface EncodedRequest {
-    raw: WireEnvelope;
-    /** The envelope `messageId` generated for this request; bind the response's `correlationId` to it. */
-    messageId: string;
-}
-export interface DecodeResponseOptions {
-    /** When set, require the response `correlationId` to equal this value (the request's messageId). */
-    expectCorrelationId?: string;
-}
-/**
- * Wraps an existing MCP JSON-RPC handler so every inbound message is verified
- * (signature + replay + TTL + recipient binding) before the handler runs, and
- * every response is signed. Returns a function over the AIP wire envelope.
- */
-export declare function wrapMcpServer(handler: McpJsonRpcHandler, options: McpSecurityOptions): (raw: WireEnvelope) => Promise<WireEnvelope>;
-export interface McpClientCodec {
-    encodeRequest(request: JsonRpcRequest): Promise<EncodedRequest>;
-    decodeResponse(raw: WireEnvelope, options?: DecodeResponseOptions): Promise<JsonRpcResponse>;
-}
-/** Signs outbound requests and verifies inbound responses (with sender + correlation binding). */
-export declare function createMcpClientCodec(options: McpSecurityOptions): McpClientCodec;
-/**
- * Wraps a transport send function (`stdio`, HTTP, ...) so callers issue and
- * receive plain JSON-RPC while AIP signing, verification, and request/response
- * correlation happen on the wire.
- */
-export declare function wrapMcpClient(send: (raw: WireEnvelope) => Promise<WireEnvelope>, options: McpSecurityOptions): (request: JsonRpcRequest) => Promise<JsonRpcResponse>;

package/policyEnforcer.d.ts

@@ -1,50 +0,0 @@
-import { type LoadRuntimePolicyOptions, type RuntimePolicy } from './runtimePolicy';
-export type RuntimeMode = 'http' | 'ws' | 'http-binary' | 'http-batch' | 'http-binary-batch' | 'ws-batch' | 'ws-binary' | 'ws-binary-batch';
-export interface ModeSelectionInput {
-    concurrency: number;
-    latencySensitive?: boolean;
-    compatibilityFirst?: boolean;
-}
-export interface TuningInput {
-    trafficClass: 'low' | 'medium' | 'high';
-    p99Ms?: number;
-    dropPct?: number;
-}
-export interface TuningDecision {
-    batchSizeRange: [number, number];
-    inflightCapRange: [number, number];
-    retryBackoffMsRange: [number, number];
-    actions: string[];
-}
-export interface RetryInput {
-    error: unknown;
-    attempt: number;
-}
-export interface InvariantConfig {
-    signatureVerification: boolean;
-    canonicalization: boolean;
-    replayDefense: boolean;
-    ttlClockSkewEnforcement: boolean;
-}
-export declare function createPolicyEnforcer(policy: RuntimePolicy): {
-    selectMode: (input: ModeSelectionInput) => RuntimeMode;
-    tune: (input: TuningInput) => TuningDecision;
-    shouldRetry: (input: RetryInput) => boolean;
-    assertInvariant: (config: InvariantConfig) => void;
-    metadata: {
-        policyName: string;
-        policyVersion: string;
-        policyStatus: string;
-        enforcedSlo: {
-            dropPctMax: number;
-            p99MsMax: number;
-        };
-    };
-};
-export type PolicyEnforcer = ReturnType<typeof createPolicyEnforcer>;
-export type BootstrapRuntimePolicyEnforcerOptions = LoadRuntimePolicyOptions;
-export declare function bootstrapRuntimePolicyEnforcer(options?: BootstrapRuntimePolicyEnforcerOptions): Promise<{
-    policy: RuntimePolicy;
-    enforcer: PolicyEnforcer;
-}>;
-export declare function isRuntimeMode(value: string): value is RuntimeMode;

package/policyTelemetryFeedback.d.ts

@@ -1,11 +0,0 @@
-export interface TelemetryFeedbackInput {
-    mode: string;
-    p99Ms: number;
-    dropPct: number;
-    concurrency: number;
-}
-export interface TelemetryFeedbackRecommendation {
-    severity: 'normal' | 'warn' | 'critical';
-    actions: string[];
-}
-export declare function recommendPolicyAdjustments(input: TelemetryFeedbackInput): TelemetryFeedbackRecommendation;

package/protocol.d.ts

@@ -1,66 +0,0 @@
-export type ProtocolVersion = 'aip/0.1';
-export type IntentKind = 'PING' | 'PONG' | 'CAPS' | 'TASK' | 'RESULT' | 'ERROR';
-export interface ProtocolHeader {
-    version: ProtocolVersion;
-    messageId: string;
-    timestampMs: number;
-    ttlMs: number;
-    sender: string;
-    recipient?: string;
-    nonce: string;
-}
-export interface ProtocolBody {
-    intent: IntentKind;
-    content: string;
-    capability?: string;
-    correlationId?: string;
-}
-export interface ProtocolSignature {
-    alg: 'HS256' | 'ED25519';
-    keyId: string;
-    value: string;
-}
-export interface ProtocolEnvelope {
-    header: ProtocolHeader;
-    body: ProtocolBody;
-    signature?: ProtocolSignature;
-}
-export interface ProtocolDiagnostic {
-    level: 'error' | 'warning';
-    message: string;
-}
-export type SignatureVerificationMaterial = {
-    alg: 'HS256';
-    secret: string;
-} | {
-    alg: 'ED25519';
-    publicKey: string;
-};
-export declare function canonicalizeEnvelope(envelope: Omit<ProtocolEnvelope, 'signature'>): string;
-export declare function signCanonicalPayloadHmac(payload: string, secret: string): Promise<string>;
-export declare function verifyCanonicalPayloadHmac(payload: string, signature: string, secret: string): Promise<boolean>;
-export declare function generateEd25519KeypairBase64Url(): Promise<{
-    publicKey: string;
-    privateKey: string;
-}>;
-export declare function signCanonicalPayloadEd25519(payload: string, privateKeyPkcs8Base64Url: string): Promise<string>;
-export declare function verifyCanonicalPayloadEd25519(payload: string, signature: string, publicKeySpkiBase64Url: string): Promise<boolean>;
-export declare function signEnvelopeHmac(envelope: Omit<ProtocolEnvelope, 'signature'>, secret: string, keyId?: string): Promise<ProtocolEnvelope>;
-export declare function verifyEnvelopeHmac(envelope: ProtocolEnvelope, secret: string): Promise<boolean>;
-export declare function signEnvelopeEd25519(envelope: Omit<ProtocolEnvelope, 'signature'>, privateKeyPkcs8Base64Url: string, keyId?: string): Promise<ProtocolEnvelope>;
-export declare function verifyEnvelopeEd25519(envelope: ProtocolEnvelope, publicKeySpkiBase64Url: string): Promise<boolean>;
-export declare function verifyEnvelopeSignature(envelope: ProtocolEnvelope, material: SignatureVerificationMaterial): Promise<boolean>;
-export declare function verifyCanonicalPayloadSignature(payload: string, signature: ProtocolSignature | undefined, material: SignatureVerificationMaterial): Promise<boolean>;
-export declare function validateEnvelope(envelope: ProtocolEnvelope, nowMs?: number): ProtocolDiagnostic[];
-export declare function createEnvelope(input: {
-    sender: string;
-    recipient?: string;
-    intent: IntentKind;
-    content: string;
-    capability?: string;
-    correlationId?: string;
-    ttlMs?: number;
-    messageId?: string;
-    nonce?: string;
-    nowMs?: number;
-}): Omit<ProtocolEnvelope, 'signature'>;

package/protocolAgent.d.ts

@@ -1,58 +0,0 @@
-import { type IntentKind, type ProtocolDiagnostic, type ProtocolEnvelope } from './protocol';
-import { type AckMode } from './protocolCapabilities';
-import { InMemoryReplayCache } from './protocolReplay';
-import { type WireEnvelope, type WireFormat } from './protocolTransport';
-export interface TaskHandlerResult {
-    intent?: 'RESULT' | 'ERROR';
-    content: string;
-    capability?: string;
-}
-export interface AgentSessionConfig {
-    agentId: string;
-    outboundSecret: string;
-    keyId?: string;
-    capabilities?: string[];
-    supportedWireFormats?: WireFormat[];
-    maxBatchSize?: number;
-    ackModes?: AckMode[];
-    requireSignature?: boolean;
-    replayCache?: InMemoryReplayCache;
-    sharedSecrets?: Record<string, string>;
-    resolveInboundSecret?: (keyId: string, sender: string) => string | undefined | Promise<string | undefined>;
-    onTask?: (envelope: ProtocolEnvelope) => TaskHandlerResult | Promise<TaskHandlerResult>;
-}
-export interface AgentReceiveResult {
-    ok: boolean;
-    diagnostics: ProtocolDiagnostic[];
-    received: ProtocolEnvelope | null;
-    response: ProtocolEnvelope | null;
-}
-export declare class AgentSession {
-    private readonly agentId;
-    private readonly outboundSecret;
-    private readonly keyId;
-    private readonly capabilities;
-    private readonly supportedWireFormats;
-    private readonly maxBatchSize;
-    private readonly ackModes;
-    private readonly requireSignature;
-    private readonly replayCache;
-    private readonly sharedSecrets;
-    private readonly resolveInboundSecret?;
-    private readonly onTask?;
-    constructor(config: AgentSessionConfig);
-    private inboundSecretResolver;
-    createSignedIntent(input: {
-        recipient?: string;
-        intent: IntentKind;
-        content: string;
-        capability?: string;
-        correlationId?: string;
-        ttlMs?: number;
-        messageId?: string;
-        nonce?: string;
-        nowMs?: number;
-    }): Promise<ProtocolEnvelope>;
-    receiveAndRespond(input: WireEnvelope | ProtocolEnvelope, nowMs?: number): Promise<AgentReceiveResult>;
-    private buildAutoResponse;
-}

package/protocolBinary.d.ts

@@ -1,8 +0,0 @@
-import type { ProtocolEnvelope } from './protocol';
-import type { ReceiveEnvelopeResult } from './protocolTransport';
-export declare const DEFAULT_MAX_BINARY_ENVELOPE_BYTES: number;
-export interface BinaryDecodeOptions {
-    maxFrameBytes?: number;
-}
-export declare function encodeEnvelopeBinary(envelope: ProtocolEnvelope): Uint8Array;
-export declare function decodeEnvelopeBinary(payload: Uint8Array, options?: BinaryDecodeOptions): ReceiveEnvelopeResult;

package/protocolCapabilities.d.ts

@@ -1,24 +0,0 @@
-import type { WireFormat } from './protocolTransport';
-export type AckMode = 'fast' | 'receipt';
-export interface AipCapabilities {
-    agent: string;
-    capabilities: string[];
-    wireFormats: WireFormat[];
-    batchMax: number;
-    ackModes: AckMode[];
-}
-export interface NegotiatedAipCapabilities {
-    wireFormat: WireFormat;
-    batchMax: number;
-    ackMode: AckMode;
-}
-export declare function createAipCapabilities(input: {
-    agent: string;
-    capabilities?: string[];
-    wireFormats?: WireFormat[];
-    batchMax?: number;
-    ackModes?: AckMode[];
-}): AipCapabilities;
-export declare function encodeAipCapabilities(capabilities: AipCapabilities): string;
-export declare function parseAipCapabilities(raw: string): AipCapabilities | null;
-export declare function negotiateAipCapabilities(local: AipCapabilities, remote: AipCapabilities): NegotiatedAipCapabilities;

package/protocolReplay.d.ts

@@ -1,35 +0,0 @@
-import type { ProtocolEnvelope } from './protocol';
-export interface ReplayCheckResult {
-    ok: boolean;
-    reason?: string;
-}
-export interface ReplayCache {
-    consume(envelope: ProtocolEnvelope, nowMs?: number): ReplayCheckResult | Promise<ReplayCheckResult>;
-    consumeMany?(envelopes: ProtocolEnvelope[], nowMs?: number): ReplayCheckResult[] | Promise<ReplayCheckResult[]>;
-}
-export interface DistributedReplayStore {
-    reserve(key: string, expiresAtMs: number, nowMs: number): boolean | Promise<boolean>;
-    /** Optional batch reserve; enables single round-trip checks for batched envelopes. */
-    reserveMany?(entries: Array<{
-        key: string;
-        expiresAtMs: number;
-    }>, nowMs: number): boolean[] | Promise<boolean[]>;
-}
-export declare class InMemoryReplayCache implements ReplayCache {
-    private readonly entries;
-    private readonly maxEntries;
-    private readonly expiries;
-    constructor(maxEntries?: number);
-    private makeKey;
-    prune(nowMs?: number): void;
-    private evictOne;
-    consume(envelope: ProtocolEnvelope, nowMs?: number): ReplayCheckResult;
-    consumeMany(envelopes: ProtocolEnvelope[], nowMs?: number): ReplayCheckResult[];
-}
-export declare class DistributedReplayCache implements ReplayCache {
-    private readonly store;
-    constructor(store: DistributedReplayStore);
-    private makeKey;
-    consume(envelope: ProtocolEnvelope, nowMs?: number): Promise<ReplayCheckResult>;
-    consumeMany(envelopes: ProtocolEnvelope[], nowMs?: number): Promise<ReplayCheckResult[]>;
-}

package/protocolTransport.d.ts

@@ -1,73 +0,0 @@
-import { type SignatureVerificationMaterial, type IntentKind, type ProtocolDiagnostic, type ProtocolEnvelope } from './protocol';
-import { type ReplayCache } from './protocolReplay';
-export type WireFormat = 'json' | 'compact' | 'binary';
-export type BatchWireFormat = Exclude<WireFormat, 'binary'>;
-export interface ReceiveEnvelopeOptions {
-    nowMs?: number;
-    requireSignature?: boolean;
-    maxClockSkewMs?: number;
-    replayCache?: ReplayCache;
-    verificationMaterialCache?: VerificationMaterialCache;
-    secretResolver?: (keyId: string, sender: string) => string | undefined | Promise<string | undefined>;
-    signatureResolver?: (signature: NonNullable<ProtocolEnvelope['signature']>, sender: string) => SignatureVerificationMaterial | undefined | Promise<SignatureVerificationMaterial | undefined>;
-    telemetry?: (event: TransportTelemetryEvent) => void | Promise<void>;
-}
-export interface ReceiveEnvelopeBatchOptions extends ReceiveEnvelopeOptions {
-    batchConcurrency?: number;
-}
-export interface TransportTelemetryEvent {
-    phase: 'decoded' | 'rejected_clock_skew' | 'rejected_validation' | 'rejected_replay' | 'rejected_missing_signature' | 'rejected_missing_material' | 'rejected_bad_signature' | 'batch_summary' | 'accepted';
-    nowMs: number;
-    sender?: string;
-    messageId?: string;
-    reason?: string;
-}
-export interface ReceiveEnvelopeResult {
-    ok: boolean;
-    diagnostics: ProtocolDiagnostic[];
-    envelope: ProtocolEnvelope | null;
-}
-export interface VerificationMaterialCache {
-    get(key: string, nowMs?: number): SignatureVerificationMaterial | undefined;
-    set(key: string, material: SignatureVerificationMaterial, expiresAtMs: number): void;
-    delete?(key: string): void;
-}
-export declare class InMemoryVerificationMaterialCache implements VerificationMaterialCache {
-    private readonly entries;
-    private readonly maxEntries;
-    constructor(maxEntries?: number);
-    get(key: string, nowMs?: number): SignatureVerificationMaterial | undefined;
-    set(key: string, material: SignatureVerificationMaterial, expiresAtMs: number): void;
-    delete(key: string): void;
-}
-export type WireEnvelope = string | Uint8Array;
-export declare function decodeEnvelope(raw: WireEnvelope): ReceiveEnvelopeResult;
-export declare function encodeEnvelope(envelope: ProtocolEnvelope, format: 'binary'): Uint8Array;
-export declare function encodeEnvelope(envelope: ProtocolEnvelope, format?: 'json' | 'compact'): string;
-export declare function encodeEnvelope(envelope: ProtocolEnvelope, format: WireFormat): WireEnvelope;
-export declare function encodeEnvelopeBatch(envelopes: ProtocolEnvelope[], format?: BatchWireFormat): string;
-export declare function decodeEnvelopeBatch(raw: string): ReceiveEnvelopeResult[];
-export declare function receiveEnvelope(input: WireEnvelope | ProtocolEnvelope, options?: ReceiveEnvelopeOptions): Promise<ReceiveEnvelopeResult>;
-export declare function receiveEnvelopeBatch(input: string | Array<WireEnvelope | ProtocolEnvelope>, options?: ReceiveEnvelopeBatchOptions): Promise<ReceiveEnvelopeResult[]>;
-export declare class SessionTransport {
-    private readonly options;
-    constructor(options?: Omit<ReceiveEnvelopeOptions, 'replayCache'> & {
-        replayCache?: ReplayCache;
-    });
-    receive(input: WireEnvelope | ProtocolEnvelope, nowMs?: number): Promise<ReceiveEnvelopeResult>;
-    receiveBatch(input: string | Array<WireEnvelope | ProtocolEnvelope>, nowMs?: number): Promise<ReceiveEnvelopeResult[]>;
-}
-export declare function createSignedMessage(input: {
-    sender: string;
-    recipient?: string;
-    intent: IntentKind;
-    content: string;
-    capability?: string;
-    correlationId?: string;
-    ttlMs?: number;
-    messageId?: string;
-    nonce?: string;
-    nowMs?: number;
-    secret: string;
-    keyId?: string;
-}): Promise<ProtocolEnvelope>;

package/redisClient.d.ts

@@ -1,49 +0,0 @@
-/**
- * Minimal Redis command surface the AIP stores depend on.
- *
- * The library stays client-agnostic: any Redis client (ioredis, node-redis,
- * Upstash, a cluster proxy, ...) can be adapted to this interface, so
- * `@7h3/protocol` ships with no Redis dependency of its own.
- */
-export interface RedisSetOptions {
-    /** Only set when the key does not already exist (Redis `NX`). */
-    nx?: boolean;
-    /** Expire the key after this many milliseconds (Redis `PX`). */
-    pxMs?: number;
-}
-/** A queued, chainable batch of `set` commands flushed in a single round-trip. */
-export interface RedisPipelineLike {
-    set(key: string, value: string, options?: RedisSetOptions): RedisPipelineLike;
-    exec(): Promise<Array<'OK' | null>>;
-}
-export interface RedisLikeClient {
-    /** Returns `'OK'` when the value was written, or `null` when `NX` prevented it. */
-    set(key: string, value: string, options?: RedisSetOptions): Promise<'OK' | null>;
-    /** Truthy when the key exists and has not expired. */
-    get?(key: string): Promise<string | null>;
-    /** Removes a key; returns the number of keys removed. */
-    del?(key: string): Promise<number>;
-    /** Optional batch pipeline; when present, batch reserves use a single round-trip. */
-    pipeline?(): RedisPipelineLike;
-}
-/**
- * In-memory reference implementation of {@link RedisLikeClient}.
- *
- * It is a faithful stand-in for a single Redis node's `SET NX PX` / `GET` /
- * `DEL` semantics — useful for tests, local development, and as the default
- * degraded-mode fallback. It is NOT a distributed store: it provides no
- * cross-process guarantees and must not be used as a production replay store
- * for a horizontally scaled deployment.
- */
-export declare class InMemoryRedisLikeClient implements RedisLikeClient {
-    private readonly entries;
-    private readonly now;
-    constructor(options?: {
-        now?: () => number;
-    });
-    private live;
-    set(key: string, value: string, options?: RedisSetOptions): Promise<'OK' | null>;
-    get(key: string): Promise<string | null>;
-    del(key: string): Promise<number>;
-    pipeline(): RedisPipelineLike;
-}

package/replayStores.d.ts

@@ -1,32 +0,0 @@
-import type { DistributedReplayStore } from './protocolReplay';
-import { type RedisLikeClient } from './redisClient';
-/**
- * What to do when the Redis client throws (network blip, server down).
- *
- * - `fallback` (default): degrade to a local in-memory store so traffic keeps
- *   flowing with single-node replay protection still in force. Quality +
- *   reliability + scalability: Redis is never a fleet-wide kill switch.
- * - `reject`: fail closed — deny the message because uniqueness cannot be confirmed.
- * - `allow`: fail open — accept the message (skip the check) to maximise uptime.
- */
-export type ReplayErrorBehavior = 'fallback' | 'reject' | 'allow';
-export interface RedisReplayStoreOptions {
-    /** Key namespace in Redis. Default `aip:replay:`. */
-    keyPrefix?: string;
-    /** Behavior when the Redis client throws. Default `fallback`. */
-    errorBehavior?: ReplayErrorBehavior;
-    /** Local store used when `errorBehavior` is `fallback`. Defaults to an in-memory-backed store. */
-    fallback?: DistributedReplayStore;
-    /** Observability hook fired whenever a Redis error forces degraded handling. */
-    onDegraded?: (error: unknown, context: {
-        key: string;
-        behavior: ReplayErrorBehavior;
-    }) => void;
-}
-/**
- * Creates a {@link DistributedReplayStore} backed by Redis-style `SET NX PX`.
- *
- * Drop the returned store into `new DistributedReplayCache(store)` (or pass a
- * `DistributedReplayCache` as the transport `replayCache`).
- */
-export declare function createRedisReplayStore(client: RedisLikeClient, options?: RedisReplayStoreOptions): DistributedReplayStore;