@interncom/diplomatic 0.0.74 → 0.1.0

package/dist/lib.d.ts

@@ -0,0 +1,2 @@
+export declare function min(x: number, y: number): number;
+export declare function max(x: number, y: number): number;

package/dist/react/useClient.d.ts

@@ -1,5 +1,6 @@
+import type { SyncClient } from "../client";
+import { HostHandle } from "../shared/types";
 import type { IDiplomaticClientState, IDiplomaticClientXferState } from "../types";
-import type DiplomaticClient from "../client";
-export declare function useClientState(client: DiplomaticClient): IDiplomaticClientState | undefined;
-export declare function useClientXferState(client: DiplomaticClient): IDiplomaticClientXferState | undefined;
-export declare function useSyncOnResume(client: DiplomaticClient): void;
+export declare function useClientState<Handle extends HostHandle>(client: SyncClient<Handle>): IDiplomaticClientState | undefined;
+export declare function useClientXferState<Handle extends HostHandle>(client: SyncClient<Handle>): IDiplomaticClientXferState | undefined;
+export declare function useSyncOnResume<Handle extends HostHandle>(client: SyncClient<Handle>): void;

package/dist/react/useStateWatcher.d.ts

@@ -1,3 +1,3 @@
-import type { StateManager } from "../state";
-export default function useStateWatcher<T>(mgr: StateManager, opType: string, callback: () => Promise<T>): T | undefined;
-export declare function useStateWatcherSuspense<T>(mgr: StateManager, opType: string, callback: () => Promise<T>): T;
+import { IStateManager } from "../types";
+export default function useStateWatcher<T>(mgr: IStateManager, opType: string, callback: () => Promise<T>): T | undefined;
+export declare function useStateWatcherSuspense<T>(mgr: IStateManager, opType: string, callback: () => Promise<T>): T;

package/dist/shared/api/peek.d.ts

@@ -0,0 +1,3 @@
+import { IAuthenticatedEndpoint } from "../endpoint.ts";
+import { IBagPeekItem } from "../codecs/peekItem.ts";
+export declare const peekEnd: IAuthenticatedEndpoint<number, IBagPeekItem[]>;

package/dist/shared/api/pull.d.ts

@@ -0,0 +1,3 @@
+import { type IBagPullItem } from "../codecs/pullItem.ts";
+import { IAuthenticatedEndpoint } from "../endpoint.ts";
+export declare const pullEnd: IAuthenticatedEndpoint<number, IBagPullItem[]>;

package/dist/shared/api/push.d.ts

@@ -0,0 +1,4 @@
+import { type IBagPushItem } from "../codecs/pushItem.ts";
+import { IAuthenticatedEndpoint } from "../endpoint.ts";
+import { IBag } from "../types.ts";
+export declare const pushEnd: IAuthenticatedEndpoint<IBag, IBagPushItem[]>;

package/dist/shared/api/user.d.ts

@@ -0,0 +1,2 @@
+import { IAuthenticatedEndpoint } from "../endpoint.ts";
+export declare const userEnd: IAuthenticatedEndpoint<never, void>;

package/dist/shared/auth.d.ts

@@ -0,0 +1,8 @@
+import { IClock } from "./clock.ts";
+import { type IAuthTimestamp } from "./codecs/authTimestamp.ts";
+import { Status } from "./consts.ts";
+import type { ICrypto, IHostCrypto, KeyPair } from "./types.ts";
+import { ValStat } from "./valstat.ts";
+export type EncodedAuthTimestamp = Uint8Array;
+export declare function makeAuthTimestamp(keys: KeyPair, ts: Date, crypto: ICrypto): Promise<ValStat<IAuthTimestamp>>;
+export declare function validateAuthTimestamp(authTS: IAuthTimestamp, crypto: IHostCrypto, clock: IClock): Promise<Status>;

package/dist/shared/bag.d.ts

@@ -0,0 +1,16 @@
+import { IMessageHead } from "./codecs/messageHead.ts";
+import { Enclave } from "./enclave.ts";
+import { EncodedMessage } from "./message.ts";
+import { type ValStat } from "./valstat.ts";
+import type { Hash, HostSpecificKeyPair, IBag, ICrypto, IHostCrypto, IMessage, IMessageWithHash, PublicKey } from "./types.ts";
+export declare function bagSigValid(bag: IBag, pubKey: PublicKey, crypto: IHostCrypto): Promise<boolean>;
+export declare function kdmFor(msgHeadEnc: Uint8Array, keys: HostSpecificKeyPair, crypto: ICrypto): Promise<Uint8Array>;
+export declare function sealBag(msg: IMessage, keys: HostSpecificKeyPair, crypto: ICrypto, enclave: Enclave): Promise<ValStat<IBag>>;
+interface IOpenBag {
+    msgHead: IMessageHead;
+    bod?: EncodedMessage;
+    headHash: Hash;
+}
+export declare function openBagBody(headEnc: Uint8Array, bodyCph: Uint8Array | undefined, key: Uint8Array, crypto: ICrypto): Promise<ValStat<IOpenBag>>;
+export declare function openBag(bag: IBag, pubKey: PublicKey, crypto: ICrypto, enclave: Enclave): Promise<ValStat<IMessageWithHash>>;
+export {};

package/dist/shared/binary.d.ts

@@ -0,0 +1,8 @@
+export declare function btoh(bytes: Uint8Array): string;
+export declare function htob(hex: string): Uint8Array;
+export declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;
+export declare let btob64: (bytes: Uint8Array) => string;
+export declare let b64tob: (b64: string) => Uint8Array;
+export declare function concat(a: Uint8Array, b: Uint8Array): Uint8Array;
+export declare function btob128(bytes: Uint8Array): string;
+export declare function b128tob(str: string): Uint8Array;

package/dist/shared/client.d.ts

@@ -1,11 +1,22 @@
-import type { ICrypto, IListDeltasResponse, IMsgpackCodec, KeyPair } from "./types.ts";
-export default class DiplomaticClientAPI {
-    codec: IMsgpackCodec;
+import { IClock } from "./clock.ts";
+import { Status } from "./consts.ts";
+import { Enclave } from "./enclave.ts";
+import type { HostHandle, HostSpecificKeyPair, IBag, ICrypto, IHostConnectionInfo, IHostMetadata, IMessage, ITransport, PushReceiver } from "./types.ts";
+import { ValStat } from "./valstat.ts";
+export default class DiplomaticClientAPI<Handle extends HostHandle> {
+    enclave: Enclave;
     crypto: ICrypto;
-    constructor(codec: IMsgpackCodec, crypto: ICrypto);
-    getHostID(hostURL: URL): Promise<string>;
-    register(hostURL: URL, pubKey: Uint8Array, token: string): Promise<void>;
-    putDelta(hostURL: URL, cipherOp: Uint8Array, keyPair: KeyPair): Promise<string>;
-    getDelta(hostURL: URL, sha256: Uint8Array, keyPair: KeyPair): Promise<Uint8Array>;
-    listDeltas(hostURL: URL, begin: Date, keyPair: KeyPair): Promise<IListDeltasResponse>;
+    private host;
+    clock: IClock;
+    private transport;
+    private updateHostMeta;
+    constructor(enclave: Enclave, crypto: ICrypto, host: IHostConnectionInfo<Handle>, clock: IClock, transport: ITransport, updateHostMeta: (meta: IHostMetadata) => Promise<Status>);
+    private call;
+    keys: () => Promise<HostSpecificKeyPair>;
+    seal: (msg: IMessage) => Promise<ValStat<IBag>>;
+    register: () => Promise<ValStat<void>>;
+    peek: (lastSeq: number) => Promise<ValStat<import("./codecs/peekItem.ts").IBagPeekItem[]>>;
+    push: (bags: IBag[]) => Promise<ValStat<import("./codecs/pushItem.ts").IBagPushItem[]>>;
+    pull: (seqs: number[]) => Promise<ValStat<import("./codecs/pullItem.ts").IBagPullItem[]>>;
+    listen: (recv: PushReceiver) => Promise<Status>;
 }

package/dist/shared/clock.d.ts

@@ -0,0 +1,13 @@
+export interface IClock {
+    now(): Date;
+}
+export declare class Clock implements IClock {
+    now(): Date;
+}
+export declare class MockClock implements IClock {
+    private _now;
+    constructor(_now: Date);
+    set(_now: Date): void;
+    now(): Date;
+}
+export declare function offset(timeSentClient: Date, timeRcvdHost: Date, timeSentHost: Date, timeRcvdClient: Date): number;

package/dist/shared/codec.d.ts

@@ -0,0 +1,43 @@
+import { ValStat } from "./valstat.ts";
+import { Status } from "./consts.ts";
+export declare function encodeVarInt(n: number | bigint): ValStat<Uint8Array>;
+export declare function decodeVarInt(bytes: Uint8Array, offset?: number): ValStat<{
+    value: number | bigint;
+    bytesRead: number;
+}>;
+export declare class Decoder {
+    private data;
+    private pos;
+    constructor(data: Uint8Array);
+    static fromResponse(resp: Response): Promise<Decoder>;
+    readBigInt(): ValStat<bigint>;
+    readDate(): ValStat<Date>;
+    readVarInt(): ValStat<number>;
+    readVarString(): ValStat<string>;
+    readBytes(num: number): ValStat<Uint8Array>;
+    readVarBytes(): ValStat<Uint8Array>;
+    readStruct<T>(codec: ICodecStruct<T>): ValStat<T>;
+    readStructs<T>(codec: ICodecStruct<T>): ValStat<T[]>;
+    readBytesSeq(len: number): ValStat<Uint8Array[]>;
+    done(): boolean;
+    consumed(): number;
+}
+export declare class Encoder {
+    private parts;
+    writeBigInt(b: bigint): void;
+    writeDate(ts: Date): Status;
+    writeVarInt(n: number): Status;
+    writeVarString(s: string): Status;
+    prependBytes(bytes: Uint8Array): void;
+    writeBytes(bytes: Uint8Array): void;
+    writeVarBytes(bytes: Uint8Array): Status;
+    writeStruct<T>(codec: ICodecStruct<T>, str: T): Status;
+    writeStructs<T>(codec: ICodecStruct<T>, structs: Iterable<T>): Status;
+    writeBytesSeq(bytesSeq: Iterable<Uint8Array>): void;
+    result(): Uint8Array;
+    scan(): Generator<Uint8Array>;
+}
+export interface ICodecStruct<T> {
+    encode: (enc: Encoder, struct: T) => Status;
+    decode: (dec: Decoder) => ValStat<T>;
+}

package/dist/shared/codecs/authTimestamp.d.ts

@@ -0,0 +1,8 @@
+import { ICodecStruct } from "../codec.ts";
+import type { PublicKey } from "../types.ts";
+export interface IAuthTimestamp {
+    pubKey: PublicKey;
+    sig: Uint8Array;
+    timestamp: Date;
+}
+export declare const authTimestampCodec: ICodecStruct<IAuthTimestamp>;

package/dist/shared/codecs/bag.d.ts

@@ -0,0 +1,3 @@
+import { ICodecStruct } from "../codec.ts";
+import type { IBag } from "../types.ts";
+export declare const bagCodec: ICodecStruct<IBag>;

package/dist/shared/codecs/eid.d.ts

@@ -0,0 +1,10 @@
+import { ICodecStruct } from "../codec.ts";
+import { ValStat } from "../valstat.ts";
+import { EntityID } from "../types.ts";
+export interface IEntityID {
+    id: Uint8Array;
+    ts: Date;
+}
+export declare const eidCodec: ICodecStruct<IEntityID>;
+export declare function makeEID(eidObj: IEntityID): ValStat<EntityID>;
+export declare function genSingletonEID(id: Uint8Array): Promise<ValStat<EntityID>>;

package/dist/shared/codecs/file.d.ts

@@ -0,0 +1,8 @@
+import { ICodecStruct } from "../codec.ts";
+import { IFileHead } from "./fileHead.ts";
+export interface IFile {
+    head: IFileHead;
+    indexEnc: Uint8Array;
+    bodyEnc: Uint8Array;
+}
+export declare const fileCodec: ICodecStruct<IFile>;

package/dist/shared/codecs/fileHead.d.ts

@@ -0,0 +1,10 @@
+import { ICodecStruct } from "../codec.ts";
+import { Hash } from "../types.ts";
+export interface IFileHead {
+    lbl: string;
+    idx: number;
+    num: number;
+    hsh: Hash;
+    sig: Uint8Array;
+}
+export declare const fileHeadCodec: ICodecStruct<IFileHead>;

package/dist/shared/codecs/fileIndexItem.d.ts

@@ -0,0 +1,8 @@
+import { ICodecStruct } from "../codec.ts";
+export interface IFileIndexItem {
+    kdm: Uint8Array;
+    headCph: Uint8Array;
+    lenBody: number;
+    offBody?: number;
+}
+export declare const fileIndexItemCodec: ICodecStruct<IFileIndexItem>;

package/dist/shared/codecs/messageHead.d.ts

@@ -0,0 +1,16 @@
+import { ICodecStruct } from "../codec.ts";
+import { EntityID } from "../types.ts";
+export interface IMessageHead {
+    eid: EntityID;
+    off: number;
+    ctr: number;
+    len: number;
+    hsh?: Uint8Array;
+}
+export declare const messageHeadCodec: ICodecStruct<IMessageHead>;
+export interface IMinimalMessageHead {
+    eid: EntityID;
+    off: number;
+    ctr: number;
+}
+export declare const minimalMessageHeadCodec: ICodecStruct<IMinimalMessageHead>;

package/dist/shared/codecs/notifItem.d.ts

@@ -0,0 +1,7 @@
+import { ICodecStruct } from "../codec.ts";
+export interface IBagNotifItem {
+    seq: number;
+    headCph: Uint8Array;
+    bodyCph?: Uint8Array;
+}
+export declare const notifItemCodec: ICodecStruct<IBagNotifItem>;

package/dist/shared/codecs/peekItem.d.ts

@@ -0,0 +1,6 @@
+import { ICodecStruct } from "../codec.ts";
+export interface IBagPeekItem {
+    seq: number;
+    headCph: Uint8Array;
+}
+export declare const peekItemCodec: ICodecStruct<IBagPeekItem>;

package/dist/shared/codecs/peekItemHead.d.ts

@@ -0,0 +1,7 @@
+import { ICodecStruct } from "../codec.ts";
+export interface IBagPeekItemHead {
+    sig: Uint8Array;
+    kdm: Uint8Array;
+    headCph: Uint8Array;
+}
+export declare const peekItemHeadCodec: ICodecStruct<IBagPeekItemHead>;

package/dist/shared/codecs/pullItem.d.ts

@@ -0,0 +1,6 @@
+import { ICodecStruct } from "../codec.ts";
+export interface IBagPullItem {
+    seq: number;
+    bodyCph: Uint8Array;
+}
+export declare const pullItemCodec: ICodecStruct<IBagPullItem>;

package/dist/shared/codecs/pushItem.d.ts

@@ -0,0 +1,11 @@
+import { ICodecStruct } from "../codec.ts";
+import { Status } from "../consts.ts";
+export type IBagPushItem = {
+    idx: number;
+    status: Status.Success;
+    seq: number;
+} | {
+    idx: number;
+    status: Exclude<Status, Status.Success>;
+};
+export declare const pushItemCodec: ICodecStruct<IBagPushItem>;

package/dist/shared/codecs/respHead.d.ts

@@ -0,0 +1,10 @@
+import { ICodecStruct } from "../codec.ts";
+import { Status } from "../consts.ts";
+import { ISubscriptionMetadata } from "../types.ts";
+export interface IRespHead {
+    status: Status;
+    timeRcvd: Date;
+    timeSent: Date;
+    subscription: ISubscriptionMetadata;
+}
+export declare const respHeadCodec: ICodecStruct<IRespHead>;

package/dist/shared/codecs/usageQuota.d.ts

@@ -0,0 +1,6 @@
+import { ICodecStruct } from "../codec.ts";
+export interface IUsageQuota {
+    quota: number;
+    usage?: number;
+}
+export declare const usageQuotaCodec: ICodecStruct<IUsageQuota>;

package/dist/shared/consts.d.ts

@@ -0,0 +1,50 @@
+export declare const sigBytes = 64;
+export declare const hashBytes = 32;
+export declare const idxBytes = 8;
+export declare const lenBytes = 8;
+export declare const pubKeyBytes = 32;
+export declare const kdmBytes = 8;
+export declare const eidBytes = 16;
+export declare const clkBytes = 8;
+export declare const hshBytes = 32;
+export declare const tsAuthSize: number;
+export declare const bagHeaderSize: number;
+export declare const responseItemSize = 33;
+export declare const clockToleranceMs = 30000;
+export declare const notifInlineBodyBytesThreshold = 512;
+export declare enum Status {
+    Success = 0,
+    InvalidSignature = 3,
+    ClockOutOfSync = 4,
+    UserNotRegistered = 5,
+    ServerMisconfigured = 6,
+    MissingBody = 7,
+    ExtraBodyContent = 8,
+    MissingParam = 9,
+    InvalidParam = 10,
+    InvalidRequest = 11,
+    InternalError = 12,
+    NotFound = 13,
+    InvalidMessage = 14,
+    NoChange = 15,
+    DatabaseClosed = 16,
+    StorageError = 17,
+    DatabaseError = 18,
+    HashMismatch = 19,
+    DecryptionError = 20,
+    NotImplemented = 21,
+    MissingSeed = 22,
+    OutOfBounds = 23,
+    HostError = 24,
+    CommunicationError = 25,
+    VarLimitExceeded = 26,
+    InvalidResponse = 27,
+    ConnectionClosed = 28
+}
+export declare enum APICallName {
+    User = 0,
+    Peek = 1,
+    Push = 2,
+    Pull = 3
+}
+export declare const notifierTSAuthURLParam = "t";

package/dist/shared/crypto/libsodium.d.ts

@@ -1,16 +1,16 @@
-import type { ICrypto, KeyPair } from "../types.ts";
+import type { DerivationSeed, Hash, ICrypto, KeyPair } from "../types.ts";
 type Libsodium = any;
 export declare class LibsodiumCrypto implements ICrypto {
     sodium: Libsodium;
     constructor(sodium: Libsodium);
-    gen128BitRandomID(): Promise<Uint8Array>;
+    genRandomBytes(bytes: number): Promise<Uint8Array>;
     gen256BitSecureRandomSeed(): Promise<Uint8Array>;
-    deriveXSalsa20Poly1305Key(seed: Uint8Array): Promise<Uint8Array>;
+    deriveXSalsa20Poly1305Key(seed: Uint8Array, derivationIndex?: number): Promise<Uint8Array>;
     encryptXSalsa20Poly1305Combined(data: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
     decryptXSalsa20Poly1305Combined(data: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
-    deriveEd25519KeyPair(seed: Uint8Array, hostID: string, derivationIndex?: number): Promise<KeyPair>;
+    deriveEd25519KeyPair(derivationSeed: DerivationSeed): Promise<KeyPair>;
     signEd25519(message: Uint8Array | string, secKey: Uint8Array): Promise<Uint8Array>;
     checkSigEd25519(sig: Uint8Array, message: Uint8Array | string, pubKey: Uint8Array): Promise<boolean>;
-    sha256Hash(data: Uint8Array): Promise<Uint8Array>;
+    blake3(data: Uint8Array): Promise<Hash>;
 }
 export {};

package/dist/shared/enclave.d.ts

@@ -0,0 +1,8 @@
+import type { DerivationSeed, ICrypto, MasterSeed } from "./types.ts";
+export declare class Enclave {
+    private seed;
+    private crypto;
+    constructor(seed: MasterSeed, crypto: ICrypto);
+    deriveFromKDM(kdm: Uint8Array): Promise<DerivationSeed>;
+    derive(keyPath: string, idx?: number): Promise<DerivationSeed>;
+}

package/dist/shared/endpoint.d.ts

@@ -0,0 +1,23 @@
+import { IClock } from "./clock.ts";
+import { Decoder, Encoder } from "./codec.ts";
+import { IAuthTimestamp } from "./codecs/authTimestamp.ts";
+import { Status } from "./consts.ts";
+import { Enclave } from "./enclave.ts";
+import { HostSpecificKeyPair, ICrypto, IProtoHost } from "./types.ts";
+import { ValStat } from "./valstat.ts";
+interface IProtoClient {
+    crypto: ICrypto;
+    enclave: Enclave;
+    clock: IClock;
+}
+export interface IAuthenticatedEndpoint<ReqItem, Resp> {
+    encodeReq(client: IProtoClient, keys: HostSpecificKeyPair, authTS: IAuthTimestamp, body: Iterable<ReqItem>, reqEnc: Encoder): Promise<Status>;
+    handleReq(host: IProtoHost, reqDec: Decoder, respEnc: Encoder): Promise<Status>;
+    decodeResp(respDec: Decoder): ValStat<Resp>;
+}
+export interface IAuthData {
+    keys: HostSpecificKeyPair;
+    authTS: IAuthTimestamp;
+}
+export declare function hostKeys(host: IProtoClient, keyPath: string, idx: number): Promise<HostSpecificKeyPair>;
+export {};

package/dist/shared/exim.d.ts

@@ -0,0 +1,12 @@
+import { Enclave } from "./enclave.ts";
+import { ICrypto, IMessageHead } from "./types.ts";
+import { ValStat } from "./valstat.ts";
+export declare const defaultFileExtension = "dpl";
+export declare function encodeFile(keyLbl: string, keyIdx: number, msgs: Iterable<{
+    head: IMessageHead;
+    body?: Uint8Array;
+}>, crypto: ICrypto, enclave: Enclave): Promise<ValStat<Uint8Array>>;
+export declare function decodeFile(file: Uint8Array, crypto: ICrypto, enclave: Enclave): Promise<ValStat<{
+    head: IMessageHead;
+    body?: Uint8Array;
+}[]>>;

package/dist/shared/http/listener.d.ts

@@ -0,0 +1,11 @@
+import { IAuthTimestamp } from "../codecs/authTimestamp.ts";
+import { Status } from "../consts.ts";
+import { IPushListener, PushReceiver } from "../types.ts";
+export declare class WebsocketListener implements IPushListener {
+    private url;
+    private websocket?;
+    constructor(url: URL);
+    connected(): boolean;
+    connect(authTS: IAuthTimestamp, recv: PushReceiver, onDisconnect: () => void): Promise<Status>;
+    disconnect(): void;
+}

package/dist/shared/http/server.d.ts

@@ -0,0 +1,11 @@
+import { IClock } from "../clock.ts";
+import { type IHostCrypto, type IProtoHost, type IStorage, type IWebSocketPushNotifier } from "../types.ts";
+export declare class DiplomaticHTTPServer implements IProtoHost {
+    storage: IStorage;
+    crypto: IHostCrypto;
+    notifier: IWebSocketPushNotifier;
+    clock: IClock;
+    constructor(storage: IStorage, crypto: IHostCrypto, notifier: IWebSocketPushNotifier, clock: IClock);
+    corsHandler: (request: Request) => Promise<Response>;
+    handler: (request: Request) => Promise<Response>;
+}

package/dist/shared/http.d.ts

@@ -0,0 +1,81 @@
+import { Decoder, Encoder } from "./codec.ts";
+import { APICallName } from "./consts.ts";
+import { IPushListener, ITransport } from "./types.ts";
+import { IRespHead } from "./codecs/respHead.ts";
+import { ValStat } from "./valstat.ts";
+export declare const api: {
+    readonly user: {
+        readonly path: "/user";
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<never, void>;
+        readonly name: APICallName.User;
+    };
+    readonly push: {
+        readonly path: "/push";
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<import("./types.ts").IBag, import("./codecs/pushItem.ts").IBagPushItem[]>;
+        readonly name: APICallName.Push;
+    };
+    readonly peek: {
+        readonly path: "/peek";
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<number, import("./codecs/peekItem.ts").IBagPeekItem[]>;
+        readonly name: APICallName.Peek;
+    };
+    readonly pull: {
+        readonly path: "/pull";
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<number, import("./codecs/pullItem.ts").IBagPullItem[]>;
+        readonly name: APICallName.Pull;
+    };
+};
+export declare const apiCalls: {
+    readonly 0: {
+        readonly path: "/user";
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<never, void>;
+        readonly name: APICallName.User;
+    };
+    readonly 2: {
+        readonly path: "/push";
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<import("./types.ts").IBag, import("./codecs/pushItem.ts").IBagPushItem[]>;
+        readonly name: APICallName.Push;
+    };
+    readonly 1: {
+        readonly path: "/peek";
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<number, import("./codecs/peekItem.ts").IBagPeekItem[]>;
+        readonly name: APICallName.Peek;
+    };
+    readonly 3: {
+        readonly path: "/pull";
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<number, import("./codecs/pullItem.ts").IBagPullItem[]>;
+        readonly name: APICallName.Pull;
+    };
+};
+export declare const callPaths: {
+    readonly "/user": {
+        readonly path: "/user";
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<never, void>;
+        readonly name: APICallName.User;
+    };
+    readonly "/push": {
+        readonly path: "/push";
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<import("./types.ts").IBag, import("./codecs/pushItem.ts").IBagPushItem[]>;
+        readonly name: APICallName.Push;
+    };
+    readonly "/peek": {
+        readonly path: "/peek";
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<number, import("./codecs/peekItem.ts").IBagPeekItem[]>;
+        readonly name: APICallName.Peek;
+    };
+    readonly "/pull": {
+        readonly path: "/pull";
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<number, import("./codecs/pullItem.ts").IBagPullItem[]>;
+        readonly name: APICallName.Pull;
+    };
+};
+export declare class HTTPTransport implements ITransport {
+    private url;
+    listener: IPushListener;
+    constructor(url: URL);
+    call(name: APICallName, enc: Encoder): Promise<ValStat<Decoder>>;
+}
+export declare function errResp(head: IRespHead): Response;
+export declare function binResp(encoder: Encoder): Response;
+export declare function cors(resp: Response): Response;
+export declare function post(url: URL, enc: Encoder): Promise<ValStat<Decoder>>;

package/dist/shared/lpc/listener.d.ts

@@ -0,0 +1,16 @@
+import { IAuthTimestamp } from "../codecs/authTimestamp.ts";
+import { Status } from "../consts.ts";
+import { IPushListener, IPushNotifier, PushReceiver } from "../types.ts";
+import type { IHostCrypto } from "../types.ts";
+import type { IClock } from "../clock.ts";
+export declare class CallbackListener implements IPushListener {
+    private notifier;
+    private crypto;
+    private clock;
+    private _connected;
+    private _shut?;
+    constructor(notifier: IPushNotifier, crypto: IHostCrypto, clock: IClock);
+    connected(): boolean;
+    connect(authTS: IAuthTimestamp, recv: PushReceiver, _onDisconnect: () => void): Promise<Status>;
+    disconnect(): void;
+}

package/dist/shared/lpc/pusher.d.ts

@@ -0,0 +1,9 @@
+import type { IPushNotifier, IPushOpenResponse, PublicKey, PushReceiver } from "../types.ts";
+import { IAuthTimestamp } from "../codecs/authTimestamp.ts";
+import type { IHostCrypto } from "../types.ts";
+import type { IClock } from "../clock.ts";
+export declare class CallbackNotifier implements IPushNotifier {
+    private recvs;
+    open(authTS: IAuthTimestamp, recv: PushReceiver, crypto: IHostCrypto, clock: IClock): Promise<IPushOpenResponse>;
+    push(pubKey: PublicKey, data: Uint8Array): void;
+}

package/dist/shared/lpc/server.d.ts

@@ -0,0 +1,19 @@
+import { IClock } from "../clock.ts";
+import { Decoder, Encoder } from "../codec.ts";
+import { APICallName, Status } from "../consts.ts";
+import { type IHostCrypto, type IProtoHost, type IPushListener, type IPushNotifier, type IStorage, type ITransport } from "../types.ts";
+import { ValStat } from "../valstat.ts";
+export declare class DiplomaticLPCServer implements IProtoHost {
+    storage: IStorage;
+    crypto: IHostCrypto;
+    notifier: IPushNotifier;
+    clock: IClock;
+    constructor(storage: IStorage, crypto: IHostCrypto, notifier: IPushNotifier, clock: IClock);
+    handler: (callName: APICallName, dec: Decoder, enc: Encoder) => Promise<Status>;
+}
+export declare class LPCTransport implements ITransport {
+    private host;
+    listener: IPushListener;
+    constructor(host: DiplomaticLPCServer);
+    call: (name: APICallName, enc: Encoder) => Promise<ValStat<Decoder>>;
+}

package/dist/shared/message.d.ts

@@ -0,0 +1,30 @@
+import { IClock } from "./clock.ts";
+import type { ICrypto, IMessage, IMessageHead, SerializedContent } from "./types.ts";
+import { ValStat } from "./valstat.ts";
+interface IUpsertMessage extends IMessage {
+    bod: SerializedContent;
+}
+interface IDeleteMessage extends Omit<IMessage, "bod"> {
+    len: 0;
+}
+export type EncodedMessage = Uint8Array;
+interface IInsertParams {
+    now: Date;
+    bod: SerializedContent;
+    crypto: ICrypto;
+}
+export declare function genInsertHead({ now, bod, crypto }: IInsertParams): Promise<ValStat<IMessageHead>>;
+interface IUpsertParams extends Omit<IMessage, "off" | "len" | "hsh"> {
+    now: Date;
+    crypto: ICrypto;
+}
+export declare function genUpsertHead({ now, eid, ctr, bod, crypto }: IUpsertParams): Promise<ValStat<IMessageHead>>;
+interface IDeleteParams extends Omit<IMessage, "off" | "len" | "hsh" | "bod"> {
+    now: Date;
+    crypto: ICrypto;
+}
+export declare function genDeleteHead({ now, eid, ctr, crypto }: IDeleteParams): Promise<ValStat<IMessageHead>>;
+export declare function genInsert({ now, bod, crypto }: IInsertParams): Promise<ValStat<IUpsertMessage>>;
+export declare function genDelete(params: IDeleteParams): Promise<ValStat<IDeleteMessage>>;
+export declare function genSingletonUpsert(type: string, clk: IClock, content: Uint8Array, ctr?: number): Promise<ValStat<IUpsertMessage>>;
+export {};

package/dist/shared/storage/memory.d.ts

@@ -0,0 +1,10 @@
+import { type IStorage } from "../types.ts";
+interface IMemoryStorage extends IStorage {
+    users: Set<string>;
+    bag: Map<string, Map<number, {
+        headCph: Uint8Array;
+        bodyCph: Uint8Array;
+    }>>;
+}
+declare const memStorage: IMemoryStorage;
+export default memStorage;