@powerhousedao/reactor 6.2.3-dev.44 → 6.2.3-dev.46

package/dist/rpc.d.ts

@@ -0,0 +1,332 @@
+import { Sr as IDocumentModelRegistry, pt as IReactorClient } from "./index-81SYQKda.js";
+//#region src/rpc/protocol.d.ts
+type CorrelationId = string;
+type ErrorInfo = {
+  name: string;
+  message: string;
+  stack?: string;
+  cause?: ErrorInfo;
+};
+type RpcRequest = {
+  k: "req";
+  id: CorrelationId;
+  method: string;
+  args: unknown[];
+  abortAt?: number;
+};
+type RpcResponse = {
+  k: "res";
+  id: CorrelationId;
+  value: unknown;
+};
+type RpcError = {
+  k: "err";
+  id: CorrelationId;
+  error: ErrorInfo;
+};
+/** Failed document subscribe; routed to the change-subscription registry. */
+type RpcSubError = {
+  k: "sub-err";
+  id: CorrelationId;
+  error: ErrorInfo;
+};
+/** Failed live query; routed to the live-query registry. */
+type RpcLiveError = {
+  k: "live-err";
+  id: CorrelationId;
+  error: ErrorInfo;
+};
+type RpcAbort = {
+  k: "abort";
+  targetId: CorrelationId;
+};
+type RpcSubscribe = {
+  k: "sub";
+  id: CorrelationId;
+  search: unknown;
+  view?: unknown;
+};
+type RpcEvent = {
+  k: "event";
+  id: CorrelationId;
+  change: unknown;
+};
+type RpcUnsub = {
+  k: "unsub";
+  id: CorrelationId;
+};
+type RpcNextPage = {
+  k: "page";
+  id: CorrelationId;
+  token: string;
+};
+export declare const RPC_PROTOCOL_VERSION = 3;
+/**
+ * A package the worker loads by URL rather than by registry spec: local
+ * project packages, whose models the registry does not serve. The URL must be
+ * a worker-importable models entry - the dev server's transformed
+ * `document-models/index.js` in dev, a prebuilt bundle under
+ * `__reactor_worker__/packages/` in production.
+ */
+type WorkerPackageSource = {
+  name: string;
+  version?: string;
+  url: string;
+};
+type VersionFingerprint = {
+  appBuildId: string;
+  rpcProtocolVersion: number;
+  models: {
+    id: string;
+    version: number;
+  }[];
+  featureFlags?: string;
+};
+type RpcHello = {
+  k: "hello";
+  id: CorrelationId;
+  version: VersionFingerprint;
+  construct?: unknown;
+  packages?: string[];
+};
+type RpcRegisterPackages = {
+  k: "register-packages";
+  id: CorrelationId;
+  specs: string[];
+  /** URL-addressed packages; the worker REPLACES a source it already loaded. */
+  sources?: WorkerPackageSource[];
+};
+type RpcUnregisterPackages = {
+  k: "unregister-packages";
+  id: CorrelationId;
+  names: string[];
+};
+type RpcReload = {
+  k: "reload";
+  reason: string;
+  workerGen?: string;
+};
+type RpcAdmin = {
+  k: "admin";
+  id: CorrelationId;
+  method: "info" | "restart" | "clearStorage" | "migrate";
+};
+type WorkerMigrationState = {
+  status: "idle" | "needed" | "migrating" | "failed";
+  legacyMajor?: number;
+  phase?: "clone" | "dump" | "restore";
+  error?: string;
+};
+type RpcMigration = {
+  k: "migration";
+  state: WorkerMigrationState;
+};
+type WorkerInspectorInfo = {
+  namespace: string;
+  ownerId: string;
+  bootedAtMs: number;
+  connectedClients: number;
+  appBuildId: string;
+  rpcProtocolVersion: number;
+  /** Flags this worker is enforcing, from the fingerprint that built it. */
+  featureFlags?: string;
+};
+type ReactorIdentity = {
+  address: string;
+  chainId: number;
+  networkId: string;
+};
+type RpcIdentity = {
+  k: "identity";
+  user: ReactorIdentity | null;
+};
+type RpcBusEvent = {
+  k: "bus-event";
+  eventType: number;
+  event: unknown;
+};
+type OpKind = "sync-op" | "db-op" | "inspector-op";
+type MethodCallMessage<K extends OpKind> = {
+  k: K;
+  id: CorrelationId;
+  method: string;
+  args: unknown[];
+};
+type RpcSyncOp = MethodCallMessage<"sync-op">;
+type RpcDbOp = MethodCallMessage<"db-op">;
+type RpcInspectorOp = MethodCallMessage<"inspector-op">;
+type RpcLiveSubscribe = {
+  k: "sub-live";
+  id: CorrelationId;
+  sql: string;
+  params: unknown[];
+};
+type RpcLiveEvent = {
+  k: "event-live";
+  id: CorrelationId;
+  results: unknown;
+};
+type RpcLiveUnsub = {
+  k: "unsub-live";
+  id: CorrelationId;
+};
+type RpcPing = {
+  k: "ping";
+  id: CorrelationId;
+};
+type RpcPong = {
+  k: "pong";
+  id: CorrelationId;
+  ownerId: string;
+  bootedAtMs: number;
+};
+type ClientMessage = RpcRequest | RpcAbort | RpcSubscribe | RpcUnsub | RpcNextPage | RpcHello | RpcRegisterPackages | RpcUnregisterPackages | RpcIdentity | RpcAdmin | RpcSyncOp | RpcDbOp | RpcInspectorOp | RpcLiveSubscribe | RpcLiveUnsub | RpcPing;
+type OwnerMessage = RpcResponse | RpcError | RpcSubError | RpcLiveError | RpcEvent | RpcReload | RpcBusEvent | RpcLiveEvent | RpcMigration | RpcPong;
+type RpcMessage = ClientMessage | OwnerMessage;
+//#endregion
+//#region src/rpc/rpc-correlator.d.ts
+type RpcRequestOptions = {
+  /** Reject if no response arrives within this many ms; omit for no timeout. */
+  timeoutMs?: number;
+  /** Maps a successful response value (e.g. paged-result rehydration). */
+  transform?: (value: unknown) => unknown;
+  /** Runs after the post; may return a cleanup invoked when the request settles. */
+  setup?: (id: CorrelationId) => (() => void) | void;
+};
+/** Anything that can send a client message (the router). */
+type RpcPoster = {
+  post(message: ClientMessage): void;
+};
+/**
+ * Request/response correlation shared by every RPC proxy: one pending map,
+ * res/err settlement, and per-request timeout/transform/cleanup.
+ */
+export declare class RpcCorrelator {
+  private readonly poster;
+  private readonly prefix;
+  private counter;
+  private readonly pending;
+  constructor(poster: RpcPoster, prefix?: string);
+  nextId(): CorrelationId;
+  /** Settle the pending request a res/err refers to; a missing id is a no-op. */
+  handleMessage(message: OwnerMessage): void;
+  /** Send a request, resolving on its res/err. `build` stamps the generated id. */
+  request(build: (id: CorrelationId) => ClientMessage, options?: RpcRequestOptions): Promise<unknown>;
+}
+//#endregion
+//#region src/rpc/transport.d.ts
+interface IRpcTransport {
+  post(message: RpcMessage): void;
+  onMessage(listener: (message: RpcMessage) => void): () => void;
+  close(): void;
+}
+export declare function createPortTransport(port: MessagePort): IRpcTransport;
+//#endregion
+//#region src/rpc/message-router.d.ts
+type OwnerKind = OwnerMessage["k"];
+/**
+ * Owns the single transport.onMessage and dispatches each message to the one
+ * consumer that owns its kind. Composes the shared RpcCorrelator (res/err) and
+ * exposes request/nextId; attach/detach swap the transport for reconnect.
+ */
+export declare class MessageRouter {
+  private readonly handlers;
+  private readonly correlator;
+  private transport;
+  private detachTransport;
+  constructor(prefix?: string);
+  attach(transport: IRpcTransport): void;
+  detach(): void;
+  post(message: ClientMessage): void;
+  /** Register the sole owner of a message kind; throws on a duplicate. */
+  on<K extends OwnerKind>(kind: K, handler: (message: Extract<OwnerMessage, {
+    k: K;
+  }>) => void): () => void;
+  request(build: (id: CorrelationId) => ClientMessage, options?: RpcRequestOptions): Promise<unknown>;
+  nextId(): CorrelationId;
+}
+//#endregion
+//#region src/rpc/client-proxy.d.ts
+type ReactorClientProxyOptions = {
+  onReload?: (reason: string, workerGen?: string) => void;
+  /** Tab-local registry for module lookups (reducers/editors can't cross the worker boundary). */
+  registry?: IDocumentModelRegistry;
+};
+export declare function createReactorClientProxy(router: MessageRouter, options?: ReactorClientProxyOptions): IReactorClient;
+//#endregion
+//#region src/rpc/error-info.d.ts
+export declare function toErrorInfo(err: unknown, depth?: number): ErrorInfo;
+export declare function fromErrorInfo(info: ErrorInfo): Error;
+//#endregion
+//#region src/rpc/host-reply.d.ts
+interface IHostResponder {
+  ok(id: CorrelationId, value?: unknown): void;
+  err(id: CorrelationId, error: unknown): void;
+  errForKind(message: ClientMessage, error: unknown): void;
+  run(id: CorrelationId, body: () => Promise<unknown>, mapOk?: (value: unknown) => unknown): Promise<void>;
+}
+export declare function hostResponder(transport: IRpcTransport): IHostResponder;
+//#endregion
+//#region src/rpc/host-server.d.ts
+export declare class ReactorHostServer {
+  private readonly client;
+  private readonly transport;
+  private readonly reply;
+  private readonly aborters;
+  private readonly subscriptions;
+  private readonly pages;
+  private pageCounter;
+  private detach;
+  constructor(client: IReactorClient, transport: IRpcTransport);
+  start(): void;
+  stop(): void;
+  handleMessage(message: ClientMessage): Promise<void>;
+  private handleRequest;
+  private handlePage;
+  private handleSubscribe;
+  private prepareResult;
+  private resolveMethod;
+}
+//#endregion
+//#region src/rpc/listeners.d.ts
+export declare class KeyedListeners<K, A extends unknown[] = []> {
+  private readonly map;
+  add(key: K, fn: (...a: A) => void): () => void;
+  emit(key: K, ...a: A): void;
+  emitAll(...a: A): void;
+}
+export declare class Listeners<A extends unknown[] = []> {
+  private readonly keyed;
+  add(fn: (...a: A) => void): () => void;
+  emit(...a: A): void;
+}
+//#endregion
+//#region src/rpc/subscription.d.ts
+export declare class SubscriptionStore {
+  private readonly map;
+  set(id: CorrelationId, unsubscribe: () => void): void;
+  get(id: CorrelationId): (() => void) | undefined;
+  delete(id: CorrelationId): void;
+  end(id: CorrelationId): void;
+  drain(): void;
+}
+interface ICorrelatedSubscriptions<Sub> {
+  subscribe(sub: Sub, open: (id: CorrelationId) => ClientMessage): () => void;
+}
+interface CorrelatedConfig<Sub, EK extends OwnerMessage["k"], ErrK extends OwnerMessage["k"]> {
+  idPrefix: string;
+  eventKind: EK;
+  errKind: ErrK;
+  onEvent: (sub: Sub, message: Extract<OwnerMessage, {
+    k: EK;
+  }>) => void;
+  onError: (sub: Sub, message: Extract<OwnerMessage, {
+    k: ErrK;
+  }>) => void;
+  close: (id: CorrelationId) => ClientMessage;
+}
+export declare function createCorrelatedSubscriptions<Sub, EK extends OwnerMessage["k"], ErrK extends OwnerMessage["k"]>(router: MessageRouter, config: CorrelatedConfig<Sub, EK, ErrK>): ICorrelatedSubscriptions<Sub>;
+//#endregion
+export type { ClientMessage, CorrelationId, ErrorInfo, ICorrelatedSubscriptions, IHostResponder, IRpcTransport, MethodCallMessage, OpKind, OwnerMessage, ReactorIdentity, RpcAbort, RpcAdmin, RpcBusEvent, RpcDbOp, RpcError, RpcEvent, RpcHello, RpcIdentity, RpcInspectorOp, RpcLiveError, RpcLiveEvent, RpcLiveSubscribe, RpcLiveUnsub, RpcMessage, RpcMigration, RpcNextPage, RpcPing, RpcPong, RpcPoster, RpcRegisterPackages, RpcReload, RpcRequest, RpcRequestOptions, RpcResponse, RpcSubError, RpcSubscribe, RpcSyncOp, RpcUnregisterPackages, RpcUnsub, VersionFingerprint, WorkerInspectorInfo, WorkerMigrationState, WorkerPackageSource };
+export {};
+//# sourceMappingURL=rpc.d.ts.map

package/dist/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","names":[],"sources":["../src/rpc/protocol.ts","../src/rpc/rpc-correlator.ts","../src/rpc/transport.ts","../src/rpc/message-router.ts","../src/rpc/client-proxy.ts","../src/rpc/error-info.ts","../src/rpc/host-reply.ts","../src/rpc/host-server.ts","../src/rpc/listeners.ts","../src/rpc/subscription.ts"],"mappings":"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"}