meridian-sdk 1.3.0 → 1.4.1

package/src/agents.ts

@@ -51,9 +51,6 @@ export interface Tool {
   };
 }
 
-// ---------------------------------------------------------------------------
-// OpenAI adapter
-// ---------------------------------------------------------------------------
 
 /** OpenAI-compatible tool definition (Chat Completions `tools` array entry). */
 export interface OpenAITool {
@@ -92,9 +89,6 @@ export function toOpenAITools(tools: Tool[]): OpenAITool[] {
   }));
 }
 
-// ---------------------------------------------------------------------------
-// Gemini adapter
-// ---------------------------------------------------------------------------
 
 /** Gemini FunctionDeclaration (single entry inside a `Tool.functionDeclarations` array). */
 export interface GeminiFunctionDeclaration {
@@ -134,9 +128,7 @@ export function toGeminiTools(tools: Tool[]): GeminiTool {
   };
 }
 
-// ---------------------------------------------------------------------------
-// Provider-specific input types (structural matches — no provider SDK deps)
-// ---------------------------------------------------------------------------
+
 
 /** Anthropic tool_use block — matches `ContentBlock` from `@anthropic-ai/sdk`. */
 export interface ToolUseBlock {
@@ -248,10 +240,6 @@ export function getMeridianTools(
   return tools;
 }
 
-// ---------------------------------------------------------------------------
-// Shared dispatcher (private)
-// ---------------------------------------------------------------------------
-
 /**
  * Core dispatch logic — routes a (name, input) pair to the right HTTP operation.
  * All provider-specific executors delegate here.
@@ -302,10 +290,6 @@ async function dispatchTool(
   return JSON.stringify({ error: `Unknown tool: ${name}` });
 }
 
-// ---------------------------------------------------------------------------
-// Provider executors
-// ---------------------------------------------------------------------------
-
 /**
  * Execute a Meridian tool call returned by **Anthropic Claude**.
  *

package/src/auth/permissions.ts

@@ -0,0 +1,130 @@
+/**
+ * Client-side permission evaluation — mirrors the Rust `claims.rs` logic exactly.
+ *
+ * Lets callers check `canRead` / `canWrite` locally without a round-trip to the
+ * server. Useful for disabling UI elements before attempting an op that would
+ * fail with 403.
+ */
+
+import type { Permissions, PermEntry } from "../schema.js";
+
+export const OpMasks = {
+  /** Allow all ops (sentinel — 0 means no restriction). */
+  ALL: 0,
+
+  // GCounter / PNCounter
+  GC_INCREMENT: 0b0000_0001,
+  PN_INCREMENT: 0b0000_0001,
+  PN_DECREMENT: 0b0000_0010,
+
+  // ORSet
+  OR_ADD:    0b0000_0001,
+  OR_REMOVE: 0b0000_0010,
+
+  // LWW Register
+  LWW_SET: 0b0000_0001,
+
+  // Presence
+  PRESENCE_UPDATE: 0b0000_0001,
+
+  // RGA
+  RGA_INSERT: 0b0000_0001,
+  RGA_DELETE: 0b0000_0010,
+
+  // Tree
+  TREE_ADD:    0b0000_0001,
+  TREE_MOVE:   0b0000_0010,
+  TREE_UPDATE: 0b0000_0100,
+  TREE_DELETE: 0b0000_1000,
+
+  // CRDTMap
+  MAP_WRITE: 0b0000_0001,
+} as const;
+
+export type OpMask = number;
+
+function globMatch(pattern: string, value: string): boolean {
+  if (pattern === "*") return true;
+  const starPos = pattern.indexOf("*");
+  if (starPos === -1) return pattern === value;
+
+  const prefix = pattern.slice(0, starPos);
+  const suffix = pattern.slice(starPos + 1);
+  if (!value.startsWith(prefix)) return false;
+  const rest = value.slice(prefix.length);
+  if (suffix === "") return true;
+  for (let i = 0; i <= rest.length; i++) {
+    if (globMatch(suffix, rest.slice(i))) return true;
+  }
+  return false;
+}
+
+function isAllMask(mask: number): boolean {
+  return mask === 0 || mask === 0xffff;
+}
+
+function entryMatches(
+  entry: PermEntry,
+  crdtId: string,
+  opMask: OpMask,
+  nowMs: number,
+  clientId: number,
+): boolean {
+  // TTL gate
+  if (entry.e !== undefined && nowMs >= entry.e) return false;
+
+  // Expand {clientId} placeholder
+  const pattern = entry.p.includes("{clientId}")
+    ? entry.p.replaceAll("{clientId}", String(clientId))
+    : entry.p;
+
+  if (!globMatch(pattern, crdtId)) return false;
+
+  const ruleOp = entry.o ?? OpMasks.ALL;
+  if (isAllMask(ruleOp) || isAllMask(opMask)) return true;
+  return (opMask & ruleOp) !== 0;
+}
+
+/**
+ * Check whether the token's permissions allow reading `crdtId`.
+ *
+ * @param permissions - parsed from `TokenClaims.permissions`
+ * @param crdtId      - e.g. `"gc:views"`, `"or:cart-42"`
+ * @param clientId    - `TokenClaims.client_id` (needed for `{clientId}` expansion)
+ * @param nowMs       - current time in ms (default: `Date.now()`)
+ */
+export function canRead(
+  permissions: Permissions,
+  crdtId: string,
+  clientId: number,
+  nowMs = Date.now(),
+): boolean {
+  if ("v" in permissions) {
+    // V2
+    return permissions.r.some((e) => entryMatches(e, crdtId, OpMasks.ALL, nowMs, clientId));
+  }
+  // V1
+  return permissions.read.some((p) => globMatch(p, crdtId));
+}
+
+/**
+ * Check whether the token's permissions allow writing `crdtId`.
+ *
+ * @param opMask - op-level bitmask (e.g. `OpMasks.OR_ADD`). Omit or pass `0` to
+ *                 check key-level access without op granularity (V2 rule with a
+ *                 mask will still be matched if the caller passes `ALL=0`).
+ */
+export function canWrite(
+  permissions: Permissions,
+  crdtId: string,
+  clientId: number,
+  opMask: OpMask = OpMasks.ALL,
+  nowMs = Date.now(),
+): boolean {
+  if ("v" in permissions) {
+    // V2
+    return permissions.w.some((e) => entryMatches(e, crdtId, opMask, nowMs, clientId));
+  }
+  // V1
+  return permissions.write.some((p) => globMatch(p, crdtId));
+}

package/src/client.ts

@@ -1,4 +1,5 @@
 import { Effect, type Schema } from "effect";
+import type { QuerySpec, QueryResult, LiveQueryResult } from "./schema.js";
 import type { WsState } from "./transport/websocket.js";
 import { WsTransport } from "./transport/websocket.js";
 import type { CrdtMapValue } from "./crdt/crdtmap.js";
@@ -25,6 +26,9 @@ import {
 } from "./sync/delta.js";
 import type { TreeNodeValue } from "./sync/delta.js";
 import { parseAndValidateToken } from "./auth/token.js";
+import { canRead as evalCanRead, canWrite as evalCanWrite } from "./auth/permissions.js";
+import { decode as msgpackDecode } from "./codec.js";
+import type { OpMask } from "./auth/permissions.js";
 import type { ServerMsg, TokenClaims } from "./schema.js";
 import type { TokenParseError, TokenExpiredError } from "./errors.js";
 
@@ -82,6 +86,17 @@ export type CRDTSnapshotEntry =
   | RGASnapshotEntry
   | TreeSnapshotEntry;
 
+/**
+ * A handle returned by `client.liveQuery()`. Receives pushed `LiveQueryResult`
+ * frames whenever matching CRDTs change.
+ */
+export interface LiveQueryHandle {
+  /** Register a listener for live query result pushes. Returns an unsubscribe fn. */
+  onResult(listener: (result: LiveQueryResult) => void): () => void;
+  /** Cancel the subscription and clean up. */
+  close(): void;
+}
+
 export interface DeltaEvent {
   crdtId: string;
   type: CRDTSnapshotEntry["type"];
@@ -152,6 +167,16 @@ export class MeridianClient {
   private readonly deltaListeners = new Set<(event: DeltaEvent) => void>();
   private readonly handleUnsubs: Array<() => void> = [];
 
+  // Live query subscriptions: query_id → { spec, listeners }
+  private readonly liveQueries = new Map<string, {
+    spec: QuerySpec;
+    listeners: Set<(result: LiveQueryResult) => void>;
+  }>();
+  private liveQueryCounter = 0;
+
+  // RPC frame listeners — registered by createMeridianRpc
+  private readonly rpcListeners = new Set<(frame: unknown) => void>();
+
   private constructor(config: MeridianClientConfig, claims: TokenClaims) {
     this.namespace = config.namespace;
     this.claims = claims;
@@ -176,6 +201,10 @@ export class MeridianClient {
     // Internal listener: routes transport state changes through onAnyChange
     // so devtools only needs one subscription (avoids WsTransport chaining issue).
     this.transport.onStateChange(() => { this.notifyAnyChange(); });
+
+    // Re-send all active SubscribeQuery frames after each reconnect so the
+    // server-side registry is restored and live queries keep firing.
+    this.transport.onReconnect(() => { this.resubscribeLiveQueries(); });
   }
 
   /**
@@ -396,7 +425,7 @@ export class MeridianClient {
   rga(crdtId: string, opts?: { validator?: CrdtValidator }): RGAHandle {
     let handle = this.rgaHandles.get(crdtId);
     if (!handle) {
-      handle = new RGAHandle({ crdtId, clientId: this.clientId, transport: this.transport, ...(opts?.validator !== undefined && { validator: opts.validator }) });
+      handle = new RGAHandle({ crdtId, clientId: this.clientId, transport: this.transport, ...(opts?.validator !== undefined ? { validator: opts.validator } : {}) });
       this.rgaHandles.set(crdtId, handle);
       this.transport.subscribe(crdtId);
       this.handleUnsubs.push(handle.onChange(() => { this.notifyAnyChange(); }));
@@ -426,7 +455,7 @@ export class MeridianClient {
   tree(crdtId: string, opts?: { validator?: CrdtValidator }): TreeHandle {
     let handle = this.treeHandles.get(crdtId);
     if (!handle) {
-      handle = new TreeHandle({ crdtId, clientId: this.clientId, transport: this.transport, ...(opts?.validator !== undefined && { validator: opts.validator }) });
+      handle = new TreeHandle({ crdtId, clientId: this.clientId, transport: this.transport, ...(opts?.validator !== undefined ? { validator: opts.validator } : {}) });
       this.treeHandles.set(crdtId, handle);
       this.transport.subscribe(crdtId);
       this.handleUnsubs.push(handle.onChange(() => { this.notifyAnyChange(); }));
@@ -488,6 +517,26 @@ export class MeridianClient {
     return this.transport.onStateChange(listener);
   }
 
+  /**
+   * Register a listener for incoming RPC frames (used by `createMeridianRpc`).
+   * Frames arrive as `AwarenessBroadcast` messages with key `"__rpc__"`.
+   * Returns an unsubscribe function.
+   * @internal
+   */
+  onRpcFrame(listener: (frame: unknown) => void): () => void {
+    this.rpcListeners.add(listener);
+    return () => { this.rpcListeners.delete(listener); };
+  }
+
+  /**
+   * Send a raw msgpack-encoded `ClientMsg` over the WebSocket transport.
+   * Used by `createMeridianRpc` to send typed RPC frames.
+   * @internal
+   */
+  sendRpcFrame(data: Uint8Array): void {
+    this.transport.send({ AwarenessUpdate: { key: "__rpc__", data } });
+  }
+
   /**
    * Subscribe to any state change (CRDT value or connection state).
    * Fires whenever any handle emits or the WebSocket transitions.
@@ -546,11 +595,49 @@ export class MeridianClient {
    * using `<MeridianProvider>` in React, the provider calls this automatically
    * on unmount.
    */
+
+  /**
+   * Returns `true` if the token's permissions allow reading `crdtId`.
+   *
+   * Evaluated locally against the parsed claims — no network round-trip.
+   * Useful for disabling UI elements before attempting an op that would fail.
+   *
+   * @example
+   * ```ts
+   * if (!client.canRead("or:cart-42")) showLockIcon();
+   * ```
+   */
+  canRead(crdtId: string): boolean {
+    return evalCanRead(this.claims.permissions, crdtId, this.clientId);
+  }
+
+  /**
+   * Returns `true` if the token's permissions allow writing `crdtId`.
+   *
+   * Pass an optional `opMask` to check op-level access (V2 tokens only).
+   * Without `opMask`, checks key-level write access.
+   *
+   * @example
+   * ```ts
+   * import { OpMasks } from "meridian-sdk";
+   *
+   * if (!client.canWrite("or:cart-42", OpMasks.OR_ADD)) disableAddButton();
+   * if (!client.canWrite("gc:views")) disableIncrementButton();
+   * ```
+   */
+  canWrite(crdtId: string, opMask?: OpMask): boolean {
+    return evalCanWrite(this.claims.permissions, crdtId, this.clientId, opMask);
+  }
+
   close(): void {
     for (const unsub of this.handleUnsubs) unsub();
     this.handleUnsubs.length = 0;
     this.anyListeners.clear();
     this.deltaListeners.clear();
+    for (const queryId of this.liveQueries.keys()) {
+      this.transport.send({ UnsubscribeQuery: { query_id: queryId } });
+    }
+    this.liveQueries.clear();
     this.transport.close();
   }
 
@@ -559,6 +646,74 @@ export class MeridianClient {
     this.transport.reopen();
   }
 
+  /**
+   * Execute a cross-CRDT query against the namespace.
+   *
+   * @example
+   * ```ts
+   * const result = await client.query({ from: "gc:views-*", aggregate: "sum" });
+   * console.log(result.value); // total view count
+   * ```
+   */
+  query(spec: QuerySpec): Promise<QueryResult> {
+    return Effect.runPromise(this.http.query(this.namespace, spec));
+  }
+
+  /**
+   * Subscribe to a live cross-CRDT query over WebSocket.
+   * The server re-executes the query and pushes a result whenever a matching CRDT changes.
+   *
+   * @example
+   * ```ts
+   * const handle = client.liveQuery({ from: "gc:views-*", aggregate: "sum" });
+   * handle.onResult(result => console.log("live total:", result.value));
+   * // later:
+   * handle.close();
+   * ```
+   */
+  liveQuery(spec: QuerySpec): LiveQueryHandle {
+    const queryId = `lq-${++this.liveQueryCounter}`;
+    const listeners = new Set<(result: LiveQueryResult) => void>();
+    this.liveQueries.set(queryId, { spec, listeners });
+    this.sendSubscribeQuery(queryId, spec);
+
+    return {
+      onResult: (listener) => {
+        listeners.add(listener);
+        return () => { listeners.delete(listener); };
+      },
+      close: () => {
+        this.transport.send({ UnsubscribeQuery: { query_id: queryId } });
+        this.liveQueries.delete(queryId);
+      },
+    };
+  }
+
+  private sendSubscribeQuery(queryId: string, spec: QuerySpec): void {
+    this.transport.send({
+      SubscribeQuery: {
+        query_id: queryId,
+        query: {
+          from: spec.from,
+          ...(spec.type !== undefined && { type: spec.type }),
+          aggregate: spec.aggregate,
+          ...(spec.where !== undefined && {
+            where: {
+              ...(spec.where.contains !== undefined && { contains: spec.where.contains }),
+              ...(spec.where.updatedAfter !== undefined && { updated_after: spec.where.updatedAfter }),
+            },
+          }),
+        },
+      },
+    });
+  }
+
+  private resubscribeLiveQueries(): void {
+    for (const [queryId, { spec }] of this.liveQueries) {
+      this.sendSubscribeQuery(queryId, spec);
+    }
+  }
+
   private notifyAnyChange(): void {
     for (const fn of this.anyListeners) fn();
   }
@@ -566,10 +721,27 @@ export class MeridianClient {
   private handleServerMsg(msg: ServerMsg): void {
     if ("AwarenessBroadcast" in msg) {
       const { client_id, key, data } = msg.AwarenessBroadcast;
+      // Dispatch RPC frames — these are AwarenessUpdates with a "__rpc__" key.
+      if (key === "__rpc__" && this.rpcListeners.size > 0) {
+        try {
+          const frame = msgpackDecode(data);
+          for (const fn of this.rpcListeners) fn(frame);
+        } catch { /* malformed frame — drop silently */ }
+        return;
+      }
       this.awHandles.get(key)?.applyBroadcast(client_id, data);
       return;
     }
 
+    if ("QueryResult" in msg) {
+      const { query_id, value, matched } = msg.QueryResult;
+      const entry = this.liveQueries.get(query_id);
+      if (entry) {
+        for (const fn of entry.listeners) fn({ value, matched });
+      }
+      return;
+    }
+
     if (!("Delta" in msg)) return;
     const { crdt_id, delta_bytes } = msg.Delta;
 

package/src/codec.ts

@@ -39,6 +39,10 @@ export const uuidToBytes = (uuid: string): Uint8Array => {
 
 export const encodeVectorClock = (vc: VectorClock): Uint8Array => encode({ entries: vc });
 
+const VectorClockWire = Schema.Struct({
+  entries: Schema.Record({ key: Schema.String, value: Schema.Number }),
+});
+
 export const decodeVectorClock = (bytes: Uint8Array): Effect.Effect<VectorClock, CodecError> => {
   let raw: unknown;
   try {
@@ -47,12 +51,8 @@ export const decodeVectorClock = (bytes: Uint8Array): Effect.Effect<VectorClock,
     return Effect.fail(new CodecError({ message: "VectorClock msgpack decode failed", raw: bytes }));
   }
 
-  const entries = raw !== null && typeof raw === "object" && "entries" in raw
-    ? (raw as { entries: unknown }).entries
-    : {};
-  return Schema.decodeUnknown(Schema.Record({ key: Schema.String, value: Schema.Number }))(
-    entries ?? {},
-  ).pipe(
+  return Schema.decodeUnknown(VectorClockWire)(raw).pipe(
+    Effect.map((w) => w.entries),
     Effect.mapError((e) =>
       new CodecError({ message: `VectorClock schema validation failed: ${e.message}`, raw: bytes }),
     ),

package/src/index.ts

@@ -5,6 +5,7 @@ export type {
   MeridianClientConfig,
   ClientSnapshot,
   DeltaEvent,
+  LiveQueryHandle,
   CRDTSnapshotEntry,
   GCounterSnapshotEntry,
   PNCounterSnapshotEntry,
@@ -39,6 +40,8 @@ export type { WsTransportConfig, WsState } from "./transport/websocket.js";
 
 // Auth
 export { parseToken, parseAndValidateToken, checkTokenExpiry, tokenTtlMs } from "./auth/token.js";
+export { canRead, canWrite, OpMasks } from "./auth/permissions.js";
+export type { OpMask } from "./auth/permissions.js";
 
 // Errors (all Data.TaggedError — matchable with Effect.catchTag)
 export {
@@ -68,6 +71,9 @@ export {
   CrdtGetResponse,
   CrdtOpResponse,
   ErrorResponse,
+  QuerySpec,
+  QueryResult,
+  LiveQueryResult,
 } from "./schema.js";
 export type { TimestampMs, ClientId } from "./schema.js";
 
@@ -106,6 +112,10 @@ export type {
   MeridianAgentConfig,
 } from "./agents.js";
 
+// RPC — type-safe WS events + responses (à la partyRPC)
+export { createMeridianRpc } from "./rpc.js";
+export type { MeridianRpc, MeridianRpcClient, MeridianRpcConfig, Unsubscribe } from "./rpc.js";
+
 // Effect Layer — dependency injection
 export { MeridianService, MeridianLive } from "./layer.js";
 

package/src/rpc.ts

@@ -0,0 +1,156 @@
+/**
+ * Type-safe RPC layer for Meridian WebSocket + HTTP.
+ *
+ * Inspired by partyRPC — define your events and responses once, get fully
+ * typed `send` / `on` on the client with Effect Schema validation at every
+ * decode boundary.
+ *
+ * Custom messages piggyback on the existing `AwarenessUpdate` transport using
+ * a reserved `"__rpc__"` key. The server broadcasts them via the
+ * `AwarenessBroadcast` path — no server changes required.
+ *
+ * @example
+ * ```ts
+ * import { Schema } from "effect";
+ * import { createMeridianRpc } from "meridian-sdk";
+ *
+ * const rpc = createMeridianRpc({
+ *   events: {
+ *     "cursor-move": Schema.Struct({ x: Schema.Number, y: Schema.Number }),
+ *     "reaction":    Schema.Struct({ emoji: Schema.String }),
+ *   },
+ *   responses: {
+ *     "cursor-moved": Schema.Struct({ clientId: Schema.Number, x: Schema.Number, y: Schema.Number }),
+ *     "reacted":      Schema.Struct({ clientId: Schema.Number, emoji: Schema.String }),
+ *   },
+ * });
+ *
+ * export type AppRpc = typeof rpc;
+ *
+ * const client = rpc.createClient(meridianClient);
+ *
+ * client.send("cursor-move", { x: 10, y: 20 });     // ✅
+ * client.send("cursor-move", { x: "oops" });         // ❌ compile error
+ *
+ * client.on("cursor-moved", (msg) => {
+ *   console.log(msg.clientId, msg.x, msg.y);         // ✅ no casts
+ * });
+ * ```
+ */
+
+import { Schema, Effect, type ParseResult, pipe } from "effect";
+import { encode } from "./codec.js";
+import type { MeridianClient } from "./client.js";
+
+type AnySchema = Schema.Schema<unknown, unknown, never>;
+type SchemaMap = Record<string, AnySchema>;
+type InferSchema<M extends SchemaMap, K extends keyof M> = Schema.Schema.Type<M[K]>;
+
+/** Unsubscribe function returned by `on()`. */
+export type Unsubscribe = () => void;
+
+interface RpcFrame {
+  t: string;
+  p: unknown;
+}
+
+export interface MeridianRpcConfig<
+  Events extends SchemaMap,
+  Responses extends SchemaMap,
+> {
+  /** Messages the client can **send** to the server. Key = event type, value = Effect Schema for the payload. */
+  events: Events;
+  /** Messages the server can **send** to the client. Key = response type, value = Effect Schema for the payload. */
+  responses: Responses;
+}
+
+export interface MeridianRpcClient<
+  Events extends SchemaMap,
+  Responses extends SchemaMap,
+> {
+  /**
+   * Send a typed event to the server.
+   * Payload is validated against the schema before encoding.
+   */
+  send<K extends keyof Events & string>(
+    type: K,
+    payload: InferSchema<Events, K>,
+  ): Effect.Effect<void, ParseResult.ParseError>;
+
+  /**
+   * Subscribe to a typed response from the server.
+   * Invalid frames are dropped silently.
+   * Returns an unsubscribe function.
+   */
+  on<K extends keyof Responses & string>(
+    type: K,
+    listener: (payload: InferSchema<Responses, K>) => void,
+  ): Unsubscribe;
+}
+
+export interface MeridianRpc<
+  Events extends SchemaMap,
+  Responses extends SchemaMap,
+> {
+  readonly events: Events;
+  readonly responses: Responses;
+  /** Bind this definition to a live `MeridianClient`. */
+  createClient(client: MeridianClient): MeridianRpcClient<Events, Responses>;
+}
+
+/**
+ * Define a type-safe RPC layer on top of a Meridian WebSocket connection.
+ */
+export function createMeridianRpc<
+  Events extends SchemaMap,
+  Responses extends SchemaMap,
+>(config: MeridianRpcConfig<Events, Responses>): MeridianRpc<Events, Responses> {
+  return {
+    events: config.events,
+    responses: config.responses,
+
+    createClient(client: MeridianClient): MeridianRpcClient<Events, Responses> {
+      const listeners = new Map<string, Set<(payload: unknown) => void>>();
+
+      client.onRpcFrame((raw: unknown) => {
+        const frame = raw as RpcFrame;
+        if (typeof frame?.t !== "string") return;
+        const schema = config.responses[frame.t];
+        if (!schema) return;
+
+        const parsed = Schema.decodeUnknownOption(schema)(frame.p);
+        if (parsed._tag === "None") return;
+
+        const typeListeners = listeners.get(frame.t);
+        if (typeListeners) {
+          for (const fn of typeListeners) fn(parsed.value);
+        }
+      });
+
+      return {
+        send<K extends keyof Events & string>(
+          type: K,
+          payload: InferSchema<Events, K>,
+        ): Effect.Effect<void, ParseResult.ParseError> {
+          const schema = config.events[type] as Events[K];
+          return pipe(
+            Schema.encode(schema)(payload),
+            Effect.andThen((validated) => {
+              const frame: RpcFrame = { t: type, p: validated };
+              client.sendRpcFrame(encode(frame));
+            }),
+          );
+        },
+
+        on<K extends keyof Responses & string>(
+          type: K,
+          listener: (payload: InferSchema<Responses, K>) => void,
+        ): Unsubscribe {
+          if (!listeners.has(type)) listeners.set(type, new Set());
+          listeners.get(type)?.add(listener as (p: unknown) => void);
+          return () => { listeners.get(type)?.delete(listener as (p: unknown) => void); };
+        },
+      };
+    },
+  };
+}