@interncom/diplomatic 0.1.1 → 0.1.2

package/dist/client.d.ts

@@ -2,9 +2,9 @@ import DiplomaticClientAPI from "./shared/client";
 import { IClock } from "./shared/clock";
 import { Status } from "./shared/consts";
 import { EncodedMessage } from "./shared/message";
-import { EntityID, HostHandle, ICrypto, IHostConnectionInfo, IInsertParams, IMessageHead, ITransport, IUpsertParams, MasterSeed } from "./shared/types";
+import { EntityID, HostHandle, ICrypto, IHostConnectionInfo, IInsertParams, IMessageHead, IStateManager, ITransport, IUpsertParams, MasterSeed } from "./shared/types";
 import { ValStat } from "./shared/valstat";
-import { IClient, IDiplomaticClientState, IDiplomaticClientXferState, IStateEmitter, IStateManager, IStore } from "./types";
+import { IClient, IDiplomaticClientState, IDiplomaticClientXferState, IStateEmitter, IStore } from "./types";
 export declare class SyncClient<Handle extends HostHandle> implements IClient<Handle> {
     private clock;
     private state;

package/dist/events.d.ts

@@ -1,11 +1,5 @@
 import { IStateEmitter } from "./types";
-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;
-}
+import { TypedEventEmitter } from "./shared/events";
 export declare class StateEmitter<T> implements IStateEmitter<T> {
     private getter;
     static eventName: string;
@@ -15,4 +9,3 @@ export declare class StateEmitter<T> implements IStateEmitter<T> {
     emit(): Promise<void>;
     listen(func: (state: T) => void): () => void;
 }
-export {};

package/dist/index.d.ts

@@ -7,17 +7,20 @@ import { useClient, useClientState, useClientXferState, useSyncOnResume } from "
 import useStateWatcher, { useStateWatcherSuspense } from "./react/useStateWatcher";
 import { btoh, htob } from "./shared/binary";
 import { Clock } from "./shared/clock";
-import { genSingletonEID } from "./shared/codecs/eid";
+import { Decoder, Encoder } from "./shared/codec";
+import { eidCodec, genSingletonEID } from "./shared/codecs/eid";
 import { Status } from "./shared/consts";
 import { HTTPTransport } from "./shared/http";
-import { EntityID, GroupID, type IOp, MasterSeed } from "./shared/types";
+import { TypedEventEmitter } from "./shared/events";
+import { EntityID, GroupID, IMessage, IMutateOp, type IOp, IStateManager, MasterSeed } from "./shared/types";
 import { nullStateManager, StateManager } from "./state";
 import { IDBStore, openIDBStore } from "./stores/idb/store";
 import { MemoryStore } from "./stores/memory/store";
-import type { IDiplomaticClientState, IStateManager, IStore } from "./types";
-export declare function genWebClient(stateMgr: StateManager, url: URL): Promise<{
+import { SingletonStateManager } from "./shared/singleton";
+import type { Applier, IDiplomaticClientState, IStore, IStoredMessage, IStoredMessageData } from "./types";
+export declare function genWebClient(stateMgr: IStateManager, url: URL): Promise<{
     client: SyncClient<URL>;
     setSeed: (seedHex: string) => Promise<void>;
 }>;
-export { btoh, Clock, EntDBMemory, EntIDB, EntitiesQuery, EntityID, entStateManager, genSingletonEID, GroupID, htob, HTTPTransport, IDBStore, IEntDB, IEntity, IStateManager, IStore, libsodiumCrypto, MasterSeed, MemoryStore, nullEntDB, nullStateManager, openEntIDB, openIDBStore, StateManager, Status, SyncClient, useClient, useClientState, useClientXferState, useStateWatcher, useStateWatcherSuspense, useSyncOnResume, };
-export type { IDiplomaticClientState, IOp };
+export { btoh, Clock, Decoder, eidCodec, Encoder, EntDBMemory, EntIDB, EntitiesQuery, EntityID, entStateManager, genSingletonEID, GroupID, htob, HTTPTransport, IDBStore, IEntDB, IEntity, IStore, libsodiumCrypto, MasterSeed, MemoryStore, nullEntDB, nullStateManager, openEntIDB, openIDBStore, SingletonStateManager, StateManager, Status, SyncClient, TypedEventEmitter, useClient, useClientState, useClientXferState, useStateWatcher, useStateWatcherSuspense, useSyncOnResume, };
+export type { Applier, IDiplomaticClientState, IMessage, IMutateOp, IOp, IStoredMessage, IStoredMessageData, };

package/dist/index.mjs

@@ -7851,7 +7851,7 @@ var LibsodiumCrypto = class {
 var libsodiumCrypto = new LibsodiumCrypto(libsodium_esm_wrappers_exports);
 var crypto_default = libsodiumCrypto;
 
-// src/events.ts
+// ../shared/events.ts
 var TypedEventEmitter = class {
   listeners = /* @__PURE__ */ new Map();
   // Add an event listener for a specific event type
@@ -7887,6 +7887,8 @@ var TypedEventEmitter = class {
     }
   }
 };
+
+// src/events.ts
 var StateEmitter = class _StateEmitter {
   constructor(getter) {
     this.getter = getter;
@@ -11208,6 +11210,40 @@ var MemoryStore = class {
   }
 };
 
+// ../shared/singleton.ts
+var SingletonStateManager = class {
+  constructor(singletonType) {
+    this.singletonType = singletonType;
+  }
+  latest;
+  latestOff = -1;
+  emitter = new TypedEventEmitter();
+  async apply(messages) {
+    for (const msg of messages) {
+      const dec = new Decoder2(msg.eid);
+      const [eidDec, stat] = dec.readStruct(eidCodec);
+      if (stat !== 0 /* Success */) continue;
+      const encType = new Encoder2();
+      encType.writeVarString(this.singletonType);
+      const typeBytes = encType.result();
+      if (eidDec.id.length === typeBytes.length && eidDec.id.every((b, i) => b === typeBytes[i])) {
+        if (this.latest === void 0 || msg.off > this.latestOff) {
+          this.latestOff = msg.off;
+          this.latest = msg.bod;
+          this.emitter.emit(this.singletonType, null);
+        }
+      }
+    }
+    return messages.map(() => 0 /* Success */);
+  }
+  on = (event, listener) => {
+    this.emitter.addEventListener(event, listener);
+  };
+  off = (event, listener) => {
+    this.emitter.removeEventListener(event, listener);
+  };
+};
+
 // src/index.ts
 async function genWebClient(stateMgr, url) {
   const idbStore = await openIDBStore(crypto_default);
@@ -11227,15 +11263,20 @@ async function genWebClient(stateMgr, url) {
 }
 export {
   Clock,
+  Decoder2 as Decoder,
+  Encoder2 as Encoder,
   EntDBMemory,
   EntIDB,
   HTTPTransport,
   IDBStore,
   MemoryStore,
+  SingletonStateManager,
   StateManager,
   Status,
   SyncClient,
+  TypedEventEmitter,
   btoh,
+  eidCodec,
   entStateManager,
   genSingletonEID,
   genWebClient,

package/dist/react/useClient.d.ts

@@ -1,6 +1,6 @@
 import { SyncClient } from "../client";
-import { HostHandle, IHostConnectionInfo, MasterSeed } from "../shared/types";
-import type { IDiplomaticClientState, IDiplomaticClientXferState, IStateManager } from "../types";
+import { HostHandle, IHostConnectionInfo, IStateManager, MasterSeed } from "../shared/types";
+import type { IDiplomaticClientState, IDiplomaticClientXferState } from "../types";
 import { IEntDB } from "../entdb/entdb";
 import { IClock } from "../shared/clock";
 export declare function useClientState<Handle extends HostHandle>(client: SyncClient<Handle>): IDiplomaticClientState | undefined;

package/dist/react/useStateWatcher.d.ts

@@ -1,3 +1,3 @@
-import { IStateManager } from "../types";
+import { IStateManager } from "../shared/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/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/shared/http/server.d.ts

@@ -1,11 +1,14 @@
 import { IClock } from "../clock.ts";
-import { type IHostCrypto, type IProtoHost, type IStorage, type IWebSocketPushNotifier } from "../types.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: IWebSocketPushNotifier;
+    notifier: IPushNotifier;
     clock: IClock;
-    constructor(storage: IStorage, crypto: IHostCrypto, notifier: IWebSocketPushNotifier, 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/shared/message.d.ts

@@ -1,12 +1,5 @@
-import { IClock } from "./clock.ts";
-import type { ICrypto, IMessage, IMessageHead, SerializedContent } from "./types.ts";
+import type { ICrypto, IDeleteMessage, IMessage, IMessageHead, IUpsertMessage, 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;
@@ -26,5 +19,4 @@ interface IDeleteParams extends Omit<IMessage, "off" | "len" | "hsh" | "bod"> {
 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/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/shared/types.d.ts

@@ -115,9 +115,6 @@ export interface IPushNotifier {
     open(authTS: IAuthTimestamp, recv: PushReceiver, crypto: IHostCrypto, clock: IClock): Promise<IPushOpenResponse>;
     push(pubKey: PublicKey, data: Uint8Array): void;
 }
-export interface IWebSocketPushNotifier extends IPushNotifier {
-    handle(host: IProtoHost, req: Request): Promise<Response>;
-}
 export interface IPushListener {
     connect(authTS: IAuthTimestamp, recv: PushReceiver, onDisconnect: () => void): Promise<Status>;
     connected(): boolean;
@@ -153,4 +150,15 @@ export interface ITransport {
     call: (name: APICallName, enc: Encoder) => Promise<ValStat<Decoder>>;
     listener: IPushListener;
 }
+export interface IStateManager {
+    apply: (msgs: IMessage[]) => Promise<Status[]>;
+    on: (type: string, listener: () => void) => void;
+    off: (type: string, listener: () => void) => void;
+}
+export interface IUpsertMessage extends IMessage {
+    bod: SerializedContent;
+}
+export interface IDeleteMessage extends Omit<IMessage, "bod"> {
+    len: 0;
+}
 export {};

package/dist/state.d.ts

@@ -1,7 +1,7 @@
 import { Status } from "./shared/consts";
-import { IMessage, IMsgEntBody, IOp } from "./shared/types";
+import { IMessage, IMsgEntBody, IOp, IStateManager } from "./shared/types";
 import { ValStat } from "./shared/valstat";
-import type { Applier, IStateManager } from "./types";
+import type { Applier } from "./types";
 export declare function isMsgEntBody(bodDec: unknown): bodDec is IMsgEntBody;
 export declare function msgToOp(msg: IMessage): ValStat<IOp>;
 export declare class StateManager implements IStateManager {

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 import { Status } from "./shared/consts";
 import type { Enclave } from "./shared/enclave";
 import type { EncodedMessage } from "./shared/message";
-import type { EntityID, Hash, HostHandle, IHostConnectionInfo, IHostMetadata, IInsertParams, IMessage, IMessageHead, IOp, IUpsertParams, MasterSeed, SerializedContent } from "./shared/types";
+import type { EntityID, Hash, HostHandle, IHostConnectionInfo, IHostMetadata, IInsertParams, IMessageHead, IOp, IUpsertParams, MasterSeed, SerializedContent } from "./shared/types";
 import { ValStat } from "./shared/valstat";
 import { ICrypto } from "./shared/types";
 export interface IMsgParts {
@@ -115,9 +115,4 @@ export interface IClient<Handle extends HostHandle> {
     clientState: IStateEmitter<IDiplomaticClientState>;
     xferState: IStateEmitter<IDiplomaticClientXferState>;
 }
-export interface IStateManager {
-    apply: (msgs: IMessage[]) => Promise<Status[]>;
-    on: (type: string, listener: () => void) => void;
-    off: (type: string, listener: () => void) => void;
-}
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interncom/diplomatic",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "description": "Secure sync layer",
   "main": "dist/index.mjs",