@canonmsg/agent-sdk 11.2.1 → 12.0.0

package/dist/internal/endpoint/mls-dev-groups.d.ts

@@ -0,0 +1,114 @@
+import { type MlsDevEnrollmentPrincipal, type MlsDevDeviceContext, type MlsDevGroupContext, type MlsDevGroupCommand, type MlsDevGroupPreparation, type MlsDevGroupHead, type MlsDevGroupRosterEntry, type MlsDevGroupQuery, type MlsDevGroupQueryResult, MLS_DEV_TEXT_PROTOCOL, type MlsDevGroupFeedQuery, type MlsDevGroupFeedResult, type EndpointOperationReceipt } from '../backend-contracts/index.js';
+import type { EndpointOperation } from './engine.js';
+import type { MlsDevDeviceClientContext, MlsDevDeviceClientOptions } from './mls-dev-client.js';
+import { type MlsDevKeyPackageClient } from './mls-dev-key-packages.js';
+import { type EndpointStoreTransaction } from './store.js';
+import { EndpointError } from './transport.js';
+import type { EndpointSyncPage, EndpointSyncOptions } from './sync.js';
+export type MlsDevProtectedGroupPreparer = (identityContext: MlsDevDeviceContext, groupContext: MlsDevGroupContext, command: MlsDevGroupCommand, wrappedIdentity: string, wrappedGroup: string | null, wrappedKeyPackage: string | null) => Promise<MlsDevGroupPreparation>;
+export interface MlsDevGroupView {
+    readonly status: 'pending' | 'active' | 'removed';
+    readonly conversationId: string;
+    readonly groupId: string;
+    readonly head: MlsDevGroupHead | null;
+    readonly roster: readonly MlsDevGroupRosterEntry[];
+    readonly pendingOperationId: string | null;
+}
+declare const roomRecoveryCodes: readonly ["MLS_DEV_GROUP_PREPARATION_FAILED", "MLS_DEV_GROUP_CREDENTIAL_EXPIRED", "MLS_DEV_CREDENTIAL_EXPIRED"];
+export interface MlsDevGroupRecoveryFailure {
+    readonly version: 1;
+    readonly conversationId: string;
+    readonly code: typeof roomRecoveryCodes[number];
+    readonly lastAppliedSequence: number;
+    readonly observedAtMs: number;
+}
+/** Only these fixed room-local failures may let the shared stream continue. */
+export declare function isMlsDevGroupRoomRecoveryFailure(error: unknown): error is EndpointError;
+/** Derived exclusively from an atomically committed, native-verified application. */
+export interface MlsDevVerifiedMessageBinding {
+    readonly version: 1;
+    readonly protocol: typeof MLS_DEV_TEXT_PROTOCOL;
+    readonly conversationId: string;
+    readonly messageId: string;
+    readonly groupId: string;
+    readonly operationId: string;
+    readonly feedOrdinal: number;
+    readonly envelopeHash: string;
+    readonly senderDeviceId: string;
+    readonly senderPrincipal: MlsDevEnrollmentPrincipal;
+    readonly head: MlsDevGroupHead;
+    readonly acceptedAtMs: number;
+}
+/** An online, fully caught-up audience snapshot for a model turn and its delivery guard. */
+export interface MlsDevCurrentAudience {
+    readonly version: 1;
+    readonly protocol: typeof MLS_DEV_TEXT_PROTOCOL;
+    readonly conversationId: string;
+    readonly groupId: string;
+    readonly ownDeviceId: string;
+    readonly head: MlsDevGroupHead;
+    readonly membershipRevision: number;
+    readonly admissionId: string;
+    readonly roster: readonly MlsDevGroupRosterEntry[];
+    readonly feedOrdinal: number;
+}
+export interface MlsDevGroupClient {
+    createRoom(input: {
+        conversationId: string;
+        name: string;
+        memberIds: string[];
+        operationId?: string;
+        protocol?: typeof MLS_DEV_TEXT_PROTOCOL;
+    }): Promise<EndpointOperation>;
+    create(input: {
+        conversationId: string;
+        operationId?: string;
+    }): Promise<EndpointOperation>;
+    add(input: {
+        conversationId: string;
+        claimRequestId: string;
+        operationId?: string;
+    }): Promise<EndpointOperation>;
+    remove(input: {
+        conversationId: string;
+        removedDeviceId: string;
+        operationId?: string;
+    }): Promise<EndpointOperation>;
+    refresh(conversationId: string): Promise<MlsDevGroupView | undefined>;
+    read(conversationId: string): Promise<MlsDevGroupView | undefined>;
+    readVerifiedMessageBinding(input: {
+        conversationId: string;
+        messageId: string;
+    }): Promise<MlsDevVerifiedMessageBinding | undefined>;
+    readCurrentAudience(conversationId: string): Promise<MlsDevCurrentAudience>;
+    assertCurrentAudience(expected: MlsDevCurrentAudience): Promise<void>;
+    readRecoveryFailure(conversationId: string): Promise<MlsDevGroupRecoveryFailure | undefined>;
+}
+export interface MlsDevGroupBridge {
+    hash(value: string): Promise<string>;
+    hashBytes?(value: Uint8Array): Promise<string>;
+    resolveProtocol?(conversationId: string): Promise<typeof MLS_DEV_TEXT_PROTOCOL | undefined>;
+    queryFeed?(request: MlsDevGroupFeedQuery): Promise<MlsDevGroupFeedResult>;
+    query(request: MlsDevGroupQuery): Promise<MlsDevGroupQueryResult>;
+    queue(tx: EndpointStoreTransaction, operation: EndpointOperation): Promise<EndpointOperation>;
+    settle(tx: EndpointStoreTransaction, operation: EndpointOperation, receipt: EndpointOperationReceipt, acceptedEcho: boolean): Promise<EndpointOperation>;
+    afterReceipt(operation: EndpointOperation): Promise<void>;
+    submitted(operation: EndpointOperation): void;
+    lookup(operationId: string, installationId: string): Promise<EndpointOperationReceipt | null>;
+}
+/** Internal attachment: the engine supplies its existing queue, receipt reducer,
+ * event/recovery intake, store and lifetime. Native work never runs inside tx. */
+export declare function createMlsDevGroups(options: MlsDevDeviceClientOptions, context: MlsDevDeviceClientContext, keyPackages: MlsDevKeyPackageClient | undefined, bridge: MlsDevGroupBridge): {
+    client: MlsDevGroupClient;
+    sendText(value: unknown, operationId: string, guardId?: string): Promise<EndpointOperation>;
+    queryTextHistory(conversationId: string, name: string, parameters: Record<string, unknown>): Promise<{
+        messages: Record<string, unknown>[];
+        nextBefore?: string | null;
+        missingMessageIds?: string[];
+    }>;
+    syncText(conversationId: string, options?: EndpointSyncOptions): Promise<EndpointSyncPage>;
+    isTextReady(conversationId: string): Promise<boolean>;
+    readAcceptedReceipt(operation: EndpointOperation): Promise<EndpointOperationReceipt | undefined>;
+    settleReceipt(operation: EndpointOperation, receipt: EndpointOperationReceipt): Promise<boolean>;
+};
+export {};

package/dist/internal/endpoint/mls-dev-key-package-service.d.ts

@@ -0,0 +1,33 @@
+import { type MlsDevDeviceBinding, type MlsDevKeyPackagePayload, type MlsDevKeyPackagePublicationReceipt, type MlsDevKeyPackageClaimReceipt, type MlsDevKeyPackageClaimPreconditions } from '../backend-contracts/index.js';
+import type { createMlsDevDeviceCoordinator, MlsDevKeyPackagePrerequisite } from './mls-dev-device.js';
+import type { MlsDevDeviceClientContext, MlsDevDeviceClientOptions } from './mls-dev-client.js';
+import { type EndpointStore, type EndpointStoreTransaction } from './store.js';
+/** Historical authenticated receipt; neither view grants current room authority. */
+export interface MlsDevKeyPackagePublicationView {
+    readonly status: 'published';
+    readonly receipt: MlsDevKeyPackagePublicationReceipt;
+}
+export interface MlsDevKeyPackageClaimView {
+    readonly status: 'claimed';
+    readonly receipt: MlsDevKeyPackageClaimReceipt;
+}
+export interface MlsDevKeyPackageClaimInput {
+    readonly requestId: string;
+    readonly recipientDeviceId: string;
+    readonly preconditions: MlsDevKeyPackageClaimPreconditions;
+}
+export interface MlsDevKeyPackageServiceClient {
+    /** Revalidates online, including when a historical receipt exists. */
+    publish(input: {
+        keyPackageId: string;
+    }): Promise<MlsDevKeyPackagePublicationView>;
+    claim(input: MlsDevKeyPackageClaimInput): Promise<MlsDevKeyPackageClaimView>;
+    readPublication(keyPackageId: string): Promise<MlsDevKeyPackagePublicationView | undefined>;
+    readClaim(requestId: string): Promise<MlsDevKeyPackageClaimView | undefined>;
+}
+/** Uses the same device lifetime/store. Explicit calls only; no second drain loop.
+ * Publication reads public committed TLS; no provider ciphertext enters a request. */
+export declare function createMlsDevKeyPackageService(options: MlsDevDeviceClientOptions, context: MlsDevDeviceClientContext, store: EndpointStore, initialized: () => Promise<{
+    binding: MlsDevDeviceBinding;
+    device: ReturnType<typeof createMlsDevDeviceCoordinator>;
+}>, readPrepared: (tx: EndpointStoreTransaction, binding: MlsDevDeviceBinding, id: string, current: MlsDevKeyPackagePrerequisite, historical?: boolean) => Promise<MlsDevKeyPackagePayload | undefined>): MlsDevKeyPackageServiceClient;

package/dist/internal/endpoint/mls-dev-key-packages.d.ts

@@ -0,0 +1,42 @@
+import { type MlsDevDeviceBinding, type MlsDevDeviceContext, type MlsDevKeyPackageCommand, type MlsDevKeyPackagePayload, type MlsDevKeyPackagePreparation } from '../backend-contracts/index.js';
+import { type MlsDevKeyPackagePrerequisite } from './mls-dev-device.js';
+import type { MlsDevDeviceClientContext, MlsDevDeviceClientOptions } from './mls-dev-client.js';
+import { type MlsDevKeyPackageServiceClient } from './mls-dev-key-package-service.js';
+export type { MlsDevKeyPackagePublicationView, MlsDevKeyPackageClaimView, MlsDevKeyPackageClaimInput } from './mls-dev-key-package-service.js';
+import { type EndpointStoreTransaction } from './store.js';
+export type MlsDevProtectedKeyPackagePreparer = (context: MlsDevDeviceContext, command: MlsDevKeyPackageCommand, wrappedIdentityState: string) => Promise<MlsDevKeyPackagePreparation>;
+/** A committed local preparation, never a current publication authorization. */
+export interface MlsDevKeyPackageView {
+    readonly status: 'prepared';
+    readonly payload: MlsDevKeyPackagePayload;
+}
+export interface MlsDevKeyPackageClient extends MlsDevKeyPackageServiceClient {
+    prepare(input: {
+        keyPackageId: string;
+    }): Promise<MlsDevKeyPackageView>;
+    /** Returns exact committed bytes, including after credential expiry/renewal.
+     * Requires a committed registration/credential and no local revocation. */
+    read(keyPackageId: string): Promise<MlsDevKeyPackageView | undefined>;
+}
+/** Consumed identities survive active-inventory removal until logout resets the
+ * installation. A regenerated RefHash must never resurrect a used private key. */
+export declare function assertMlsDevKeyPackageUnconsumed(tx: EndpointStoreTransaction, id: string, ref?: string): Promise<void>;
+export interface MlsDevPreparedKeyPackageSnapshot {
+    readonly binding: MlsDevDeviceBinding;
+    readonly command: MlsDevKeyPackageCommand;
+    readonly payload: MlsDevKeyPackagePayload;
+    readonly wrappedState: string;
+    readonly fingerprint: string;
+}
+/** Internal private-provider capture for Welcome, never exported on Endpoint. */
+export declare function captureMlsDevPreparedKeyPackage(tx: EndpointStoreTransaction, binding: MlsDevDeviceBinding, id: string, current: MlsDevKeyPackagePrerequisite): Promise<MlsDevPreparedKeyPackageSnapshot | undefined>;
+/** The caller has already verified the accepted Welcome and group snapshot.
+ * Consumption shares that transaction; failure rolls back private state erasure. */
+export declare function consumeMlsDevPreparedKeyPackage(tx: EndpointStoreTransaction, captured: MlsDevPreparedKeyPackageSnapshot, current: MlsDevKeyPackagePrerequisite, control: {
+    conversationId: string;
+    groupId: string;
+    controlSequence: number;
+}): Promise<void>;
+/** Internal endpoint attachment. Uses the device's existing store/lifetime and
+ * has no timer, signer generation or automatic inventory replenishment. */
+export declare function createMlsDevKeyPackageClient(options: MlsDevDeviceClientOptions, context: MlsDevDeviceClientContext): MlsDevKeyPackageClient;

package/dist/internal/endpoint/mls-dev-transport.d.ts

@@ -0,0 +1,37 @@
+import { type MlsDevKeyPackagePublishRequest, type MlsDevKeyPackagePublicationReceipt, type MlsDevKeyPackageClaimRequest, type MlsDevKeyPackageClaimReceipt, type MlsDevEnrollmentBeginRequest, type MlsDevEnrollmentCompleteRequest, type MlsDevEnrollmentChallenge, type MlsDevEnrollmentResult, type MlsDevCredentialBeginRequest, type MlsDevCredentialCompleteRequest, type MlsDevCredentialChallenge, type MlsDevCredentialReceipt, type MlsDevCredentialRevokeRequest, type MlsDevCredentialRevocationReceipt, type MlsDevCredentialReconciliationBeginRequest, type MlsDevCredentialReconciliationCompleteRequest, type MlsDevCredentialReconciliationChallenge, type MlsDevCredentialReconciliationReceipt } from '../backend-contracts/index.js';
+import { type EndpointCredentials } from './transport.js';
+export interface MlsDevKeyPackageTransport {
+    publish(request: MlsDevKeyPackagePublishRequest, signal?: AbortSignal): Promise<MlsDevKeyPackagePublicationReceipt>;
+    claim(request: MlsDevKeyPackageClaimRequest, signal?: AbortSignal): Promise<MlsDevKeyPackageClaimReceipt>;
+}
+/** Authenticated Dev registration/issuance only; no room or history authority. */
+export interface MlsDevDeviceTransport {
+    readonly keyPackages?: MlsDevKeyPackageTransport;
+    beginEnrollment(request: MlsDevEnrollmentBeginRequest, signal?: AbortSignal): Promise<MlsDevEnrollmentChallenge>;
+    completeEnrollment(request: MlsDevEnrollmentCompleteRequest, signal?: AbortSignal): Promise<MlsDevEnrollmentResult>;
+    beginCredential(request: MlsDevCredentialBeginRequest, signal?: AbortSignal): Promise<MlsDevCredentialChallenge>;
+    completeCredential(request: MlsDevCredentialCompleteRequest, signal?: AbortSignal): Promise<MlsDevCredentialReceipt>;
+    beginReconciliation(request: MlsDevCredentialReconciliationBeginRequest, signal?: AbortSignal): Promise<MlsDevCredentialReconciliationChallenge>;
+    completeReconciliation(request: MlsDevCredentialReconciliationCompleteRequest, signal?: AbortSignal): Promise<MlsDevCredentialReconciliationReceipt>;
+    revokeCredential(request: MlsDevCredentialRevokeRequest, signal?: AbortSignal): Promise<MlsDevCredentialRevocationReceipt>;
+    verifyGenerationObservation(receipt: MlsDevCredentialReconciliationReceipt): boolean;
+}
+export interface MlsDevDeviceHttpOptions {
+    enrollmentUrl: string;
+    credentialUrl: string;
+    reconciliationUrl: string;
+    keyPackagesUrl?: string;
+    /** Explicit origins trusted to receive the endpoint's login/API-key bearer. */
+    trustedOrigins: readonly string[];
+    /** Synthetic tests only: literal 127.0.0.1 or [::1], never DNS/remote HTTP. */
+    allowSyntheticLoopbackHttp?: boolean;
+}
+/** Internal constructor. The ordinary endpoint and Dev capability share credentials,
+ * fetch and ownership settings; the Dev deadline also covers auth and body reads. */
+export declare function createMlsDevDeviceHttpTransport(config: MlsDevDeviceHttpOptions, dependencies: {
+    environmentId: string;
+    credentials: EndpointCredentials;
+    fetch: typeof globalThis.fetch;
+    timeoutMs?: number;
+    ownershipHeaders(): Record<string, string>;
+}): MlsDevDeviceTransport;

package/dist/internal/endpoint/node-mls-custody-protocol.d.ts

@@ -0,0 +1,24 @@
+import type { MlsDevProtectedPreparer } from './mls-dev-device.js';
+import type { MlsDevProtectedKeyPackagePreparer } from './mls-dev-key-packages.js';
+import type { MlsDevProtectedGroupPreparer } from './mls-dev-groups.js';
+export interface NodeMlsDevCustody {
+    readonly prepareProtected: MlsDevProtectedPreparer;
+    readonly prepareProtectedKeyPackage: MlsDevProtectedKeyPackagePreparer;
+    readonly prepareProtectedGroup: MlsDevProtectedGroupPreparer;
+    /** Cancels owned processes; never destroys custody or committed wrapped state. */
+    close(): Promise<void>;
+}
+export declare class NodeMlsDevCustodyError extends Error {
+    readonly code = "MLS_NODE_CUSTODY_REJECTED";
+    constructor();
+}
+export declare const MAX_INPUT: number, MAX_OUTPUT: number;
+export declare function rejected(): never;
+export declare function requireValue(value: unknown): asserts value;
+export declare function record(value: unknown, fields: string[]): Record<string, unknown>;
+export declare function sealed(value: unknown, maximum: number, nullable?: boolean): string | null;
+export declare function frame(operation: number, values: readonly (string | null)[]): Buffer;
+/** JSON.parse supplies grammar validation; this pass rejects duplicate object
+ * names (including escaped aliases) before the closed contract parsers run. */
+export declare function parseJson(bytes: Buffer): unknown;
+export declare function typedNodeMlsDevCustody(job: <T>(work: (signal: AbortSignal) => Promise<T>) => Promise<T>, invoke: (operation: number, values: readonly (string | null)[], signal: AbortSignal) => Promise<unknown>, close: () => Promise<void>): NodeMlsDevCustody;

package/dist/internal/endpoint/node-mls-custody.d.ts

@@ -0,0 +1,15 @@
+import { type NodeMlsDevCustody } from './node-mls-custody-protocol.js';
+export interface NodeMlsDevCustodyOptions {
+    /** Canonical absolute path to the installed, signed .app (no symlink components). */
+    readonly bundlePath: string;
+    /** SHA-256 of the adjacent <bundlePath>.manifest.json; provision independently. */
+    readonly manifestSha256: string;
+    readonly executableSha256: string;
+    readonly bundleIdentifier: string;
+    readonly teamIdentifier: string;
+    /** Whole preparation, including signature checks and initialization. Default 30s. */
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
+export { NodeMlsDevCustodyError, type NodeMlsDevCustody } from './node-mls-custody-protocol.js';
+export declare function createNodeMlsDevCustody(options: NodeMlsDevCustodyOptions): NodeMlsDevCustody;

package/dist/internal/endpoint/node.d.ts

@@ -0,0 +1,7 @@
+import type { EndpointStore } from './store.js';
+export declare function createNodeEndpointStore(options: {
+    directory: string;
+    namespace: string;
+}): Promise<EndpointStore>;
+export { createNodeMlsDevCustody, NodeMlsDevCustodyError, type NodeMlsDevCustody, type NodeMlsDevCustodyOptions } from './node-mls-custody.js';
+export { createPortableNodeMlsDevCustody, type PortableNodeMlsDevCustody, type PortableNodeMlsDevCustodyOptions } from './portable-node-mls-custody.js';

package/dist/internal/endpoint/observe-query.d.ts

@@ -0,0 +1,17 @@
+export interface EndpointQueryObserver {
+    observe<T>(query: string, parameters: Record<string, unknown>, listener: (value: T) => void, onError?: (error: unknown) => void): () => void;
+    invalidate(affected?: (query: string, parameters: Record<string, unknown>) => boolean): void;
+    /** Re-arm idle subscriptions when the connection changes their polling cadence. */
+    reschedule(): void;
+    close(): void;
+}
+/**
+ * One temporary polling subscription per query per endpoint. UI components only
+ * subscribe; the endpoint owns fetching, coalescing, retry and lifecycle. A
+ * durable change-feed can call invalidate without changing any consumers.
+ */
+export declare function createEndpointQueryObserver(options: {
+    query: <T>(query: string, parameters: Record<string, unknown>) => Promise<T>;
+    intervalMs?: number;
+    getPollInterval?: () => number;
+}): EndpointQueryObserver;

package/dist/internal/endpoint/portable-node-mls-custody.d.ts

@@ -0,0 +1,23 @@
+import { type MlsDevDeviceContext } from '../backend-contracts/index.js';
+import { type NodeMlsDevCustody } from './node-mls-custody-protocol.js';
+export interface PortableNodeMlsDevCustodyOptions {
+    readonly executablePath: string;
+    readonly executableSha256: string;
+    /** Independently provisioned public identity, vault location and issuer pins. */
+    readonly configurationPath: string;
+    readonly configurationSha256: string;
+    /** An operator-managed credential mount, separate from the vault. JS opens but never reads it. */
+    readonly secretSource: {
+        readonly kind: 'managed-file';
+        readonly path: string;
+    };
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
+export interface PortableNodeMlsDevCustody extends NodeMlsDevCustody {
+    /** Deliberate first provisioning only. An existing or missing-on-restart vault is never replaced. */
+    provision(context: MlsDevDeviceContext): Promise<void>;
+}
+/** Portable software custody. Qualification currently covers Unix descriptor
+ * inheritance only; Windows must get its own ACL/handle acceptance before use. */
+export declare function createPortableNodeMlsDevCustody(options: PortableNodeMlsDevCustodyOptions): PortableNodeMlsDevCustody;

package/dist/internal/endpoint/queue.d.ts

@@ -0,0 +1,22 @@
+import type { EndpointInboundRecord, EndpointIntent, EndpointOperation } from './engine.js';
+import type { EndpointStoreTransaction } from './store.js';
+/** `provider`: a job the server runs inline for as long as its provider takes; unordered, and never awaited by a drain. */
+export type EndpointOrdering = 'conversation' | 'message' | 'signal' | 'artifact' | 'independent' | 'provider';
+/** Derived here, never an adapter override. Unknown/state-changing actions stay ordered. */
+export declare function endpointIntentOrdering(intent: EndpointIntent): EndpointOrdering;
+/** Transaction sequence is ordering metadata, never an idempotency identity. */
+export declare function nextQueueSequence(tx: EndpointStoreTransaction, name: string): Promise<number>;
+export declare function orderOperation(tx: EndpointStoreTransaction, operation: EndpointOperation): Promise<EndpointOperation>;
+export declare const outboxKey: (operation: EndpointOperation) => string;
+/** Per-work lane of non-terminal shared-work operations, in authoring order. */
+export declare const artifactOrderingPrefix: (conversationId: string, artifactId: string) => string;
+export declare const operationOrderingKey: (operation: EndpointOperation) => string | undefined;
+export declare function trackOperationOrder(tx: EndpointStoreTransaction, operation: EndpointOperation): Promise<void>;
+export declare function enqueueOperation(tx: EndpointStoreTransaction, operation: EndpointOperation): Promise<void>;
+export declare function removeOperationOutbox(tx: EndpointStoreTransaction, operation: EndpointOperation): Promise<void>;
+export declare function settleOperationOrder(tx: EndpointStoreTransaction, operation: EndpointOperation): Promise<void>;
+export declare function isFirstOrderedOperation(tx: EndpointStoreTransaction, operation: EndpointOperation): Promise<boolean>;
+export declare const inboundReadyKey: (record: EndpointInboundRecord) => string;
+export declare function orderInbound(tx: EndpointStoreTransaction, record: EndpointInboundRecord): Promise<EndpointInboundRecord>;
+export declare function enqueueInbound(tx: EndpointStoreTransaction, record: EndpointInboundRecord): Promise<void>;
+export declare function removeInboundReady(tx: EndpointStoreTransaction, record: EndpointInboundRecord): Promise<void>;

package/dist/internal/endpoint/recovery.d.ts

@@ -0,0 +1,27 @@
+import type { EndpointEventObserver, EndpointTransportEvent } from './events.js';
+import type { EndpointSyncOptions, EndpointSyncPage } from './sync.js';
+import type { EndpointStore } from './store.js';
+export interface EndpointRecoveryOptions {
+    intervalMs?: number;
+    onError?(error: unknown, conversationId?: string): void;
+}
+export interface EndpointRecoveryBaseline {
+    cutoverAt: string;
+    migrationId: string;
+}
+/** One account scan and recovery queue, independent of runtime/session count. */
+export declare function createEndpointRecovery(input: {
+    store: EndpointStore;
+    ready(): Promise<unknown>;
+    query<T>(name: string, parameters: Record<string, unknown>): Promise<T>;
+    sync(conversationId: string, options?: EndpointSyncOptions): Promise<EndpointSyncPage>;
+    isProtocolReady?(conversationId: string): Promise<boolean | undefined>;
+    observe(listener: (event: EndpointTransportEvent) => void, hooks: EndpointEventObserver): () => void;
+}): {
+    getBaseline(): Promise<EndpointRecoveryBaseline | undefined>;
+    configureBaseline(config: EndpointRecoveryBaseline): Promise<void>;
+    start(options?: EndpointRecoveryOptions): () => void;
+    refresh: () => Promise<void>;
+    assertReady(conversationId: string): Promise<void>;
+    close(): Promise<void>;
+};

package/dist/internal/endpoint/retention.d.ts

@@ -0,0 +1,7 @@
+import type { EndpointOperation } from './engine.js';
+import type { EndpointStore } from './store.js';
+export declare function compactOperation(operation: EndpointOperation): EndpointOperation;
+/** Age out duplicate plaintext, retaining small idempotency tombstones. */
+export declare function compactExpiredPayloads(store: EndpointStore, clock: number): Promise<void>;
+/** Logout erases local plaintext without turning uncertain external work into new work. */
+export declare function eraseEndpointPlaintext(store: EndpointStore): Promise<void>;

package/dist/internal/endpoint/store.d.ts

@@ -0,0 +1,22 @@
+/** Transaction callbacks may be retried. They must perform only store operations. */
+export interface EndpointStoreTransaction {
+    get<T>(key: string): Promise<T | undefined>;
+    put<T>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+    scan<T>(prefix: string, options?: {
+        after?: string;
+        limit?: number;
+    }): Promise<Array<{
+        key: string;
+        value: T;
+    }>>;
+}
+export interface EndpointStore {
+    transaction<T>(work: (transaction: EndpointStoreTransaction) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+export declare function copyJson<T>(value: T): T;
+/** Tests and explicitly ephemeral callers only. Production endpoints supply durable storage. */
+export declare function createMemoryEndpointStore(): EndpointStore;
+/** Shared canonical serialization for prepared payloads and legacy fingerprints. */
+export { canonicalEndpointJson as canonicalJson } from '../backend-contracts/index.js';

package/dist/internal/endpoint/sync.d.ts

@@ -0,0 +1,33 @@
+import type { EndpointEvent } from '../backend-contracts/index.js';
+import { type EndpointStore } from './store.js';
+export interface EndpointSyncPage {
+    changes: EndpointEvent[];
+    cursor: string | null;
+    hasMore: boolean;
+    admissionId: string | null;
+    bootstrap: boolean;
+    reset?: boolean;
+}
+export interface EndpointSyncOptions {
+    /** Required on first use. Checkpoint is only for history proven not to be new work. */
+    bootstrap?: 'receive' | 'checkpoint';
+    limit?: number;
+    /** Preserve a sticky pause instead of silently creating a new admission baseline. */
+    pauseOnAdmissionChange?: boolean;
+    /** Explicitly choose a fresh boundary after a sticky pause. Ignored otherwise. */
+    resumeAdmissionChange?: 'checkpoint';
+}
+export declare function createConversationSynchronizer(input: {
+    store: EndpointStore;
+    query<T>(query: string, parameters: Record<string, unknown>): Promise<T>;
+    ready(): Promise<unknown>;
+    clock(): number;
+    invalidate(conversationId: string): void;
+    admitRecoveredMessages?: boolean;
+    preparationGeneration?(): number;
+    /** Apply ordered MLS controls through the same lifecycle before app recovery. */
+    prepareProtocol?(conversationId: string): Promise<boolean>;
+    syncProtocol?(conversationId: string, options: EndpointSyncOptions): Promise<EndpointSyncPage | undefined>;
+}): ((conversationId: string, options?: EndpointSyncOptions) => Promise<EndpointSyncPage>) & {
+    close(): Promise<void>;
+};

package/dist/internal/endpoint/transient-publisher.d.ts

@@ -0,0 +1,8 @@
+import type { Endpoint } from './engine.js';
+/** Transient writes are coalesced here; they never enter the durable outbox. */
+export declare function createEndpointTransientPublisher(endpoint: Pick<Endpoint, 'publish'>, clock?: () => number): {
+    pulseTyping(conversationId: string): void;
+    stopTyping: (conversationId: string) => void;
+    setPresence(state: "online" | "offline" | "hidden"): void;
+    close(): void;
+};

package/dist/internal/endpoint/transport.d.ts

@@ -0,0 +1,58 @@
+import { type EndpointContentLane, type EndpointOperationRequest, type EndpointOperationReceipt, type EndpointCapabilities } from '../backend-contracts/index.js';
+import { type EndpointTransportEvent, type EndpointEventFamily } from './events.js';
+import { type MlsDevDeviceHttpOptions, type MlsDevDeviceTransport } from './mls-dev-transport.js';
+export declare class EndpointError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly operationId?: string;
+    readonly retryAfterMs?: number;
+    constructor(message: string, options?: {
+        status?: number;
+        code?: string;
+        retryable?: boolean;
+        operationId?: string;
+        retryAfterMs?: number;
+    });
+}
+/** HTTP failures and SSE close frames carry the same error details. A changed
+ * authorization reconnects through authentication; a rejected handshake stops. */
+export declare function decodeEndpointError(value: unknown, options?: {
+    status?: number;
+    retryAfter?: string | null;
+    stream?: boolean;
+}): EndpointError;
+export interface EndpointCredentials {
+    getToken(forceRefresh?: boolean): Promise<string>;
+}
+/** Shared transport enforces the reviewed lane inventory in both directions.
+ * Content remains JSON; field classification never grants authorization. */
+export declare function validateEndpointContentBoundary(lane: EndpointContentLane, name: string, payload: unknown): void;
+export interface EndpointTransport {
+    mlsDevDevice?: MlsDevDeviceTransport;
+    capabilities?(): Promise<EndpointCapabilities>;
+    execute(request: EndpointOperationRequest, signal?: AbortSignal): Promise<EndpointOperationReceipt>;
+    getOperation(operationId: string, installationId: string, signal?: AbortSignal): Promise<EndpointOperationReceipt | null>;
+    query<T>(query: string, parameters: Record<string, unknown>, signal?: AbortSignal): Promise<T>;
+    publish<T>(action: string, body: Record<string, unknown>, signal?: AbortSignal): Promise<T>;
+    events?(options: {
+        lastEventId?: string;
+        signal: AbortSignal;
+        families?: EndpointEventFamily[];
+        principalScopes?: string[];
+        onConnected?(): void;
+    }): AsyncIterable<EndpointTransportEvent>;
+}
+export declare function createHttpEndpointTransport(options: {
+    baseUrl: string;
+    environmentId: string;
+    credentials: EndpointCredentials;
+    fetch?: typeof globalThis.fetch;
+    timeoutMs?: number;
+    streamUrl?: string;
+    /** Identifies one logical subscriber within its authenticated principal.
+     * Resolve once per transport; independent tabs/devices must use distinct IDs. */
+    streamId?: string | (() => string | Promise<string>);
+    ownershipVersion?: number | (() => number | undefined);
+    mlsDevDevice?: MlsDevDeviceHttpOptions;
+}): EndpointTransport;

package/dist/media.d.ts

@@ -1,4 +1,4 @@
-import { CanonClient, type CanonReplyContext, type CanonMessage, type MediaAttachment, type ResumableMediaUploadResult, type SendMessageOptions } from '@canonmsg/core';
+import { CanonClient, type CanonReplyContext, type CanonMessage, type MediaAttachment, type ResumableMediaUploadResult, type SendMessageOptions } from './internal/core/index.js';
 export interface MaterializeMediaOptions {
     agentId: string;
     conversationId: string;