@interncom/diplomatic 0.1.3 → 0.2.0-rc1

package/dist/web/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/web/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/web/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/web/shared/api/user.d.ts

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

package/dist/web/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/web/shared/bag.d.ts

@@ -0,0 +1,15 @@
+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>>;
+export 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>>;

package/dist/web/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/web/shared/client.d.ts

@@ -0,0 +1,22 @@
+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;
+    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/web/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/web/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/web/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/web/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/web/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/web/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/web/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/web/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/web/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/web/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/web/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/web/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/web/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/web/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/web/shared/crypto/noble.d.ts

@@ -0,0 +1,11 @@
+import type { DerivationSeed, Hash, ICrypto, KeyPair } from "../types.ts";
+export declare class NobleCrypto implements ICrypto {
+    genRandomBytes(bytes: number): Promise<Uint8Array>;
+    gen256BitSecureRandomSeed(): Promise<Uint8Array>;
+    encryptXSalsa20Poly1305Combined(data: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
+    decryptXSalsa20Poly1305Combined(data: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
+    deriveEd25519KeyPair(derivationSeed: DerivationSeed): Promise<KeyPair>;
+    signEd25519(message: Uint8Array | string, secKey: Uint8Array): Promise<Uint8Array>;
+    checkSigEd25519(sig: Uint8Array, message: Uint8Array | string, pubKey: Uint8Array): Promise<boolean>;
+    blake3(data: Uint8Array): Promise<Hash>;
+}

package/dist/web/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/web/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/web/shared/events.d.ts

@@ -0,0 +1,8 @@
+type TypedListener<T> = (data: T) => void;
+export declare class TypedEventEmitter<T> {
+    private listeners;
+    addEventListener(eventType: string, listener: TypedListener<T>): () => void;
+    removeEventListener(eventType: string, listener: TypedListener<T>): void;
+    emit(eventType: string, data: T): void;
+}
+export {};

package/dist/web/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/web/shared/http/server.d.ts

@@ -0,0 +1,14 @@
+import { IClock } from "../clock.ts";
+import { IAuthTimestamp } from "../codecs/authTimestamp.ts";
+import { type IHostCrypto, type IProtoHost, type IPushNotifier, type IStorage } from "../types.ts";
+import { ValStat } from "../valstat.ts";
+export declare class DiplomaticHTTPServer implements IProtoHost {
+    storage: IStorage;
+    crypto: IHostCrypto;
+    notifier: IPushNotifier;
+    clock: IClock;
+    constructor(storage: IStorage, crypto: IHostCrypto, notifier: IPushNotifier, clock: IClock);
+    corsHandler: (request: Request) => Promise<Response>;
+    handler: (request: Request) => Promise<Response>;
+}
+export declare function validateWebSocketAuth(request: Request, host: IProtoHost): Promise<ValStat<IAuthTimestamp>>;

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

@@ -0,0 +1,82 @@
+import { Decoder, Encoder } from "./codec.ts";
+import { APICallName } from "./consts.ts";
+import { IHostConnectionInfo, 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 const hostHTTPTransport: (host: IHostConnectionInfo<URL>) => HTTPTransport;
+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/web/shared/message.d.ts

@@ -0,0 +1,22 @@
+import type { ICrypto, IDeleteMessage, IMessage, IMessageHead, IUpsertMessage, SerializedContent } from "./types.ts";
+import { ValStat } from "./valstat.ts";
+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 {};

package/dist/web/shared/singleton.d.ts

@@ -0,0 +1,15 @@
+import { IClock } from "./clock.ts";
+import { Status } from "./consts.ts";
+import { IMessage, IStateManager, IUpsertMessage, SerializedContent } from "./types.ts";
+import { ValStat } from "./valstat.ts";
+export declare function genSingletonUpsert(type: string, clk: IClock, content: Uint8Array, ctr?: number): Promise<ValStat<IUpsertMessage>>;
+export declare class SingletonStateManager implements IStateManager {
+    private singletonType;
+    latest: SerializedContent | undefined;
+    private latestOff;
+    private emitter;
+    constructor(singletonType: string);
+    apply(messages: IMessage[]): Promise<Status[]>;
+    on: (event: string, listener: () => void) => void;
+    off: (event: string, listener: () => void) => void;
+}

package/dist/web/shared/sync.d.ts

@@ -0,0 +1,9 @@
+import { IBagPeekItem } from "./codecs/peekItem.ts";
+import { Enclave } from "./enclave.ts";
+import { HostSpecificKeyPair, ICrypto } from "./types.ts";
+import { ValStat } from "./valstat.ts";
+export interface IDecryptedBagPeekItem {
+    kdm: Uint8Array;
+    headEnc: Uint8Array;
+}
+export declare function decryptPeekItem(item: IBagPeekItem, hostKeys: HostSpecificKeyPair, enclave: Enclave, crypto: ICrypto): Promise<ValStat<IDecryptedBagPeekItem>>;