@shadow-js/realtime 0.0.0-stage → 1.0.0

package/dist/dev/cloudflare.js

@@ -0,0 +1,3 @@
+import { cloudflareAdapter } from "./cloudflare/adapter.js";
+import { RealtimeChannelObject } from "./cloudflare/object.js";
+export { RealtimeChannelObject, cloudflareAdapter };

package/dist/dev/errors.d.ts

@@ -0,0 +1,25 @@
+//#region src/errors.d.ts
+/**
+ * The codes an error of this package carries. They are the same strings the wire protocol uses in `err` frames.
+ * @since 1.0.0
+ */
+export type ErrorCode = "bad_frame" | "bad_channel" | "unauthorized" | "forbidden" | "not_subscribed" | "too_large" | "rate_limited" | "limit" | "timeout" | "unavailable" | "no_handler" | "handler_error" | "closed" | "queue_full" | "conflict";
+/**
+ * An error with a protocol code. A request handler that throws one answers the client with its code and message; any
+ * other error answers `handler_error` with no message, so internals never reach a client.
+ *
+ * @example
+ * import { RealtimeError } from "@shadow-js/realtime";
+ *
+ * const refusal = new RealtimeError("forbidden", "only moderators can pin messages");
+ * refusal.code; // "forbidden"
+ * @since 1.0.0
+ */
+export declare class RealtimeError extends Error {
+  readonly code: ErrorCode;
+  constructor(code: ErrorCode, message?: string, options?: {
+    readonly cause?: unknown;
+  });
+}
+//#endregion
+//# sourceMappingURL=errors.d.ts.map

package/dist/dev/errors.js

@@ -0,0 +1,24 @@
+//#region src/errors.ts
+/**
+* An error with a protocol code. A request handler that throws one answers the client with its code and message; any
+* other error answers `handler_error` with no message, so internals never reach a client.
+*
+* @example
+* import { RealtimeError } from "@shadow-js/realtime";
+*
+* const refusal = new RealtimeError("forbidden", "only moderators can pin messages");
+* refusal.code; // "forbidden"
+* @since 1.0.0
+*/
+var RealtimeError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message ?? code, options);
+		this.name = "RealtimeError";
+		this.code = code;
+	}
+};
+//#endregion
+export { RealtimeError };
+
+//# sourceMappingURL=errors.js.map

package/dist/dev/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../../src/errors.ts"],"sourcesContent":["/**\n * The codes an error of this package carries. They are the same strings the wire protocol uses in `err` frames.\n * @since 1.0.0\n */\nexport type ErrorCode =\n  | \"bad_frame\"\n  | \"bad_channel\"\n  | \"unauthorized\"\n  | \"forbidden\"\n  | \"not_subscribed\"\n  | \"too_large\"\n  | \"rate_limited\"\n  | \"limit\"\n  | \"timeout\"\n  | \"unavailable\"\n  | \"no_handler\"\n  | \"handler_error\"\n  | \"closed\"\n  | \"queue_full\"\n  | \"conflict\";\n\n/**\n * An error with a protocol code. A request handler that throws one answers the client with its code and message; any\n * other error answers `handler_error` with no message, so internals never reach a client.\n *\n * @example\n * import { RealtimeError } from \"@shadow-js/realtime\";\n *\n * const refusal = new RealtimeError(\"forbidden\", \"only moderators can pin messages\");\n * refusal.code; // \"forbidden\"\n * @since 1.0.0\n */\nexport class RealtimeError extends Error {\n  readonly code: ErrorCode;\n\n  constructor(code: ErrorCode, message?: string, options?: { readonly cause?: unknown }) {\n    super(message ?? code, options);\n    this.name = \"RealtimeError\";\n    this.code = code;\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAgCA,IAAa,gBAAb,cAAmC,MAAM;CACvC;CAEA,YAAY,MAAiB,SAAkB,SAAwC;EACrF,MAAM,WAAW,MAAM,OAAO;EAC9B,KAAK,OAAO;EACZ,KAAK,OAAO;CACd;AACF"}

package/dist/dev/hooks.d.ts

@@ -0,0 +1,110 @@
+import { Member } from "./protocol.js";
+import { AnyMessage, Channel, ChannelDef, ChannelOptions, ChannelSchema, ChannelStatus, MessageMeta, PresenceOf, Realtime, RequestData, RequestReply, RequestsOf, Status } from "./client/types.js";
+import { Accessor } from "@shadow-js/core";
+//#region src/hooks.d.ts
+/**
+ * What {@link useChannel} returns: the reactive state of a channel and the calls on it.
+ * @since 1.0.0
+ */
+export interface ChannelHandle<Def extends ChannelDef> {
+  /** The channel's status, as a signal. */
+  readonly status: Accessor<ChannelStatus>;
+  /** The latest message of any event, as a signal (undefined until one arrives). */
+  readonly lastMessage: Accessor<AnyMessage<Def> | undefined>;
+  /** Publishes a message; see `Channel.publish`. */
+  readonly publish: Channel<Def>["publish"];
+  /** Sends a request to the server handler; see `Channel.request`. */
+  readonly request: <E extends keyof RequestsOf<Def> & string>(event: E, data: RequestData<Def, E>, options?: {
+    readonly timeoutMs?: number;
+  }) => Promise<RequestReply<Def, E>>;
+  /** The channel itself, for `onGap`, `presence` and the other calls. */
+  readonly channel: Channel<Def>;
+}
+/**
+ * Opens a channel for the owning component and releases it when the component is disposed: `status` and `lastMessage` are
+ * signals, `publish` and `request` act on the channel. The channel subscribes while the component lives; other components may
+ * share it. During the server render nothing connects.
+ *
+ * @param rt The client from `createRealtime`.
+ * @param name The channel name (fixed for the life of the component; key the component to change it).
+ * @param options Echo, presence and replay, applied when the channel is first created.
+ * @returns The reactive handle.
+ * @example
+ * import { createRealtime } from "@shadow-js/realtime/client";
+ * import { useChannel } from "@shadow-js/realtime/hooks";
+ *
+ * type Schema = { [name: `chat:${string}`]: { events: { message: { text: string } } } };
+ * const rt = createRealtime<Schema>({ url: "/rt" });
+ *
+ * function Lobby() {
+ *   const lobby = useChannel(rt, "chat:lobby");
+ *   return <button onClick={() => lobby.publish("message", { text: "hi" })}>{lobby.status()}</button>;
+ * }
+ * @since 1.0.0
+ */
+export declare function useChannel<Schema extends ChannelSchema, Name extends keyof Schema & string>(rt: Realtime<Schema>, name: Name, options?: ChannelOptions<PresenceOf<Schema[Name]>>): ChannelHandle<Schema[Name]>;
+/**
+ * Calls `handler` for each message of `event` on `channel` while the owning component lives.
+ *
+ * @param channel A channel from `useChannel(...).channel` or `rt.channel(...)`.
+ * @param event The event name.
+ * @param handler Called with the data and the message meta.
+ * @example
+ * import { createRealtime } from "@shadow-js/realtime/client";
+ * import { useChannel, useChannelEvent } from "@shadow-js/realtime/hooks";
+ *
+ * type Schema = { [name: `chat:${string}`]: { events: { message: { text: string } } } };
+ * const rt = createRealtime<Schema>({ url: "/rt" });
+ *
+ * function Log() {
+ *   const { channel } = useChannel(rt, "chat:lobby");
+ *   useChannelEvent(channel, "message", (data) => console.log(data.text));
+ *   return <p>listening</p>;
+ * }
+ * @since 1.0.0
+ */
+export declare function useChannelEvent<Def extends ChannelDef, E extends keyof Def["events"] & string>(channel: Channel<Def>, event: E, handler: (data: Def["events"][E], meta: MessageMeta) => void): void;
+/**
+ * The presence set of `channel` as a signal, and a setter that joins it (or changes this client's state) from the owning
+ * component. Passing `undefined` leaves. The component leaves the set when it is disposed.
+ *
+ * @param channel A channel from `useChannel(...).channel` or `rt.channel(...)`.
+ * @returns The members and `setPresence`.
+ * @example
+ * import { createRealtime } from "@shadow-js/realtime/client";
+ * import { useChannel, useChannelPresence } from "@shadow-js/realtime/hooks";
+ *
+ * type Schema = {
+ *   [name: `chat:${string}`]: { events: { message: string }; presence: { name: string } };
+ * };
+ * const rt = createRealtime<Schema>({ url: "/rt" });
+ *
+ * function Who() {
+ *   const { channel } = useChannel(rt, "chat:lobby");
+ *   const [members, setPresence] = useChannelPresence(channel);
+ *   setPresence({ name: "ann" });
+ *   return <p>{members().length} here</p>;
+ * }
+ * @since 1.0.0
+ */
+export declare function useChannelPresence<Def extends ChannelDef>(channel: Channel<Def>): readonly [Accessor<readonly Member<PresenceOf<Def>>[]>, (state: PresenceOf<Def> | undefined) => void];
+/**
+ * The connection status of `rt` as a signal.
+ *
+ * @param rt The client from `createRealtime`.
+ * @returns The status accessor.
+ * @example
+ * import { createRealtime } from "@shadow-js/realtime/client";
+ * import { useRealtimeStatus } from "@shadow-js/realtime/hooks";
+ *
+ * const rt = createRealtime({ url: "/rt" });
+ *
+ * function Badge() {
+ *   const status = useRealtimeStatus(rt);
+ *   return <span>{status()}</span>;
+ * }
+ * @since 1.0.0
+ */
+export declare function useRealtimeStatus<Schema extends ChannelSchema>(rt: Realtime<Schema>): Accessor<Status>;
+//#endregion
+//# sourceMappingURL=hooks.d.ts.map

package/dist/dev/hooks.js

@@ -0,0 +1,162 @@
+import { RealtimeError } from "./errors.js";
+import { isServer, onCleanup, useSignal } from "@shadow-js/core";
+//#region src/hooks.ts
+/** A channel for the server render: it never connects, listens or publishes. */
+function inertChannel(name) {
+	const refuse = () => Promise.reject(new RealtimeError("closed", "a realtime channel is not available during the server render"));
+	const none = () => () => void 0;
+	return {
+		name,
+		status: "idle",
+		lastSeq: 0,
+		on: none,
+		onAny: none,
+		onGap: none,
+		onStatus: none,
+		publish: refuse,
+		request: refuse,
+		presence: {
+			members: () => [],
+			set: () => void 0,
+			leave: () => void 0,
+			on: none
+		},
+		close: () => void 0
+	};
+}
+/**
+* Opens a channel for the owning component and releases it when the component is disposed: `status` and `lastMessage` are
+* signals, `publish` and `request` act on the channel. The channel subscribes while the component lives; other components may
+* share it. During the server render nothing connects.
+*
+* @param rt The client from `createRealtime`.
+* @param name The channel name (fixed for the life of the component; key the component to change it).
+* @param options Echo, presence and replay, applied when the channel is first created.
+* @returns The reactive handle.
+* @example
+* import { createRealtime } from "@shadow-js/realtime/client";
+* import { useChannel } from "@shadow-js/realtime/hooks";
+*
+* type Schema = { [name: `chat:${string}`]: { events: { message: { text: string } } } };
+* const rt = createRealtime<Schema>({ url: "/rt" });
+*
+* function Lobby() {
+*   const lobby = useChannel(rt, "chat:lobby");
+*   return <button onClick={() => lobby.publish("message", { text: "hi" })}>{lobby.status()}</button>;
+* }
+* @since 1.0.0
+*/
+function useChannel(rt, name, options) {
+	const channel = isServer ? inertChannel(name) : rt.channel(name, options);
+	const [status, setStatus] = useSignal(channel.status);
+	const [lastMessage, setLastMessage] = useSignal(void 0);
+	if (!isServer) {
+		const stopStatus = channel.onStatus((next) => setStatus(next));
+		const stopMessages = channel.onAny((message) => setLastMessage(() => message));
+		onCleanup(() => {
+			stopStatus();
+			stopMessages();
+		});
+	}
+	return {
+		status,
+		lastMessage,
+		publish: (event, data, publishOptions) => channel.publish(event, data, publishOptions),
+		request: (event, data, requestOptions) => channel.request(event, data, requestOptions),
+		channel
+	};
+}
+/**
+* Calls `handler` for each message of `event` on `channel` while the owning component lives.
+*
+* @param channel A channel from `useChannel(...).channel` or `rt.channel(...)`.
+* @param event The event name.
+* @param handler Called with the data and the message meta.
+* @example
+* import { createRealtime } from "@shadow-js/realtime/client";
+* import { useChannel, useChannelEvent } from "@shadow-js/realtime/hooks";
+*
+* type Schema = { [name: `chat:${string}`]: { events: { message: { text: string } } } };
+* const rt = createRealtime<Schema>({ url: "/rt" });
+*
+* function Log() {
+*   const { channel } = useChannel(rt, "chat:lobby");
+*   useChannelEvent(channel, "message", (data) => console.log(data.text));
+*   return <p>listening</p>;
+* }
+* @since 1.0.0
+*/
+function useChannelEvent(channel, event, handler) {
+	if (isServer) return;
+	onCleanup(channel.on(event, handler));
+}
+/**
+* The presence set of `channel` as a signal, and a setter that joins it (or changes this client's state) from the owning
+* component. Passing `undefined` leaves. The component leaves the set when it is disposed.
+*
+* @param channel A channel from `useChannel(...).channel` or `rt.channel(...)`.
+* @returns The members and `setPresence`.
+* @example
+* import { createRealtime } from "@shadow-js/realtime/client";
+* import { useChannel, useChannelPresence } from "@shadow-js/realtime/hooks";
+*
+* type Schema = {
+*   [name: `chat:${string}`]: { events: { message: string }; presence: { name: string } };
+* };
+* const rt = createRealtime<Schema>({ url: "/rt" });
+*
+* function Who() {
+*   const { channel } = useChannel(rt, "chat:lobby");
+*   const [members, setPresence] = useChannelPresence(channel);
+*   setPresence({ name: "ann" });
+*   return <p>{members().length} here</p>;
+* }
+* @since 1.0.0
+*/
+function useChannelPresence(channel) {
+	const [members, setMembers] = useSignal(channel.presence.members());
+	let joined = false;
+	if (!isServer) {
+		const stop = channel.presence.on((list) => setMembers(() => list));
+		onCleanup(() => {
+			stop();
+			if (joined) channel.presence.leave();
+		});
+	}
+	return [members, (state) => {
+		if (isServer) return;
+		if (state === void 0) {
+			joined = false;
+			channel.presence.leave();
+		} else {
+			joined = true;
+			channel.presence.set(state);
+		}
+	}];
+}
+/**
+* The connection status of `rt` as a signal.
+*
+* @param rt The client from `createRealtime`.
+* @returns The status accessor.
+* @example
+* import { createRealtime } from "@shadow-js/realtime/client";
+* import { useRealtimeStatus } from "@shadow-js/realtime/hooks";
+*
+* const rt = createRealtime({ url: "/rt" });
+*
+* function Badge() {
+*   const status = useRealtimeStatus(rt);
+*   return <span>{status()}</span>;
+* }
+* @since 1.0.0
+*/
+function useRealtimeStatus(rt) {
+	const [status, setStatus] = useSignal(rt.status);
+	if (!isServer) onCleanup(rt.onStatus((next) => setStatus(next)));
+	return status;
+}
+//#endregion
+export { useChannel, useChannelEvent, useChannelPresence, useRealtimeStatus };
+
+//# sourceMappingURL=hooks.js.map

package/dist/dev/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","names":[],"sources":["../../src/hooks.ts"],"sourcesContent":["import type { Accessor } from \"@shadow-js/core\";\nimport { isServer, onCleanup, useSignal } from \"@shadow-js/core\";\nimport type {\n  AnyMessage,\n  Channel,\n  ChannelDef,\n  ChannelOptions,\n  ChannelSchema,\n  ChannelStatus,\n  MessageMeta,\n  PresenceOf,\n  Realtime,\n  RequestData,\n  RequestReply,\n  RequestsOf,\n  Status,\n} from \"./client/types\";\nimport { RealtimeError } from \"./errors\";\nimport type { Member } from \"./protocol\";\n\n/**\n * What {@link useChannel} returns: the reactive state of a channel and the calls on it.\n * @since 1.0.0\n */\nexport interface ChannelHandle<Def extends ChannelDef> {\n  /** The channel's status, as a signal. */\n  readonly status: Accessor<ChannelStatus>;\n  /** The latest message of any event, as a signal (undefined until one arrives). */\n  readonly lastMessage: Accessor<AnyMessage<Def> | undefined>;\n  /** Publishes a message; see `Channel.publish`. */\n  readonly publish: Channel<Def>[\"publish\"];\n  /** Sends a request to the server handler; see `Channel.request`. */\n  readonly request: <E extends keyof RequestsOf<Def> & string>(\n    event: E,\n    data: RequestData<Def, E>,\n    options?: { readonly timeoutMs?: number },\n  ) => Promise<RequestReply<Def, E>>;\n  /** The channel itself, for `onGap`, `presence` and the other calls. */\n  readonly channel: Channel<Def>;\n}\n\n/** A channel for the server render: it never connects, listens or publishes. */\nfunction inertChannel<Def extends ChannelDef>(name: string): Channel<Def> {\n  const refuse = (): Promise<never> =>\n    Promise.reject(\n      new RealtimeError(\"closed\", \"a realtime channel is not available during the server render\"),\n    );\n  const none = (): (() => void) => () => undefined;\n  return {\n    name,\n    status: \"idle\",\n    lastSeq: 0,\n    on: none,\n    onAny: none,\n    onGap: none,\n    onStatus: none,\n    publish: refuse,\n    request: refuse,\n    presence: { members: () => [], set: () => undefined, leave: () => undefined, on: none },\n    close: () => undefined,\n  };\n}\n\n/**\n * Opens a channel for the owning component and releases it when the component is disposed: `status` and `lastMessage` are\n * signals, `publish` and `request` act on the channel. The channel subscribes while the component lives; other components may\n * share it. During the server render nothing connects.\n *\n * @param rt The client from `createRealtime`.\n * @param name The channel name (fixed for the life of the component; key the component to change it).\n * @param options Echo, presence and replay, applied when the channel is first created.\n * @returns The reactive handle.\n * @example\n * import { createRealtime } from \"@shadow-js/realtime/client\";\n * import { useChannel } from \"@shadow-js/realtime/hooks\";\n *\n * type Schema = { [name: `chat:${string}`]: { events: { message: { text: string } } } };\n * const rt = createRealtime<Schema>({ url: \"/rt\" });\n *\n * function Lobby() {\n *   const lobby = useChannel(rt, \"chat:lobby\");\n *   return <button onClick={() => lobby.publish(\"message\", { text: \"hi\" })}>{lobby.status()}</button>;\n * }\n * @since 1.0.0\n */\nexport function useChannel<Schema extends ChannelSchema, Name extends keyof Schema & string>(\n  rt: Realtime<Schema>,\n  name: Name,\n  options?: ChannelOptions<PresenceOf<Schema[Name]>>,\n): ChannelHandle<Schema[Name]> {\n  const channel: Channel<Schema[Name]> = isServer\n    ? inertChannel<Schema[Name]>(name)\n    : rt.channel(name, options);\n  const [status, setStatus] = useSignal<ChannelStatus>(channel.status);\n  const [lastMessage, setLastMessage] = useSignal<AnyMessage<Schema[Name]> | undefined>(undefined);\n  if (!isServer) {\n    const stopStatus = channel.onStatus((next) => setStatus(next));\n    const stopMessages = channel.onAny((message) => setLastMessage(() => message));\n    onCleanup(() => {\n      stopStatus();\n      stopMessages();\n    });\n  }\n  return {\n    status,\n    lastMessage,\n    publish: (event, data, publishOptions) => channel.publish(event, data, publishOptions),\n    request: (event, data, requestOptions) => channel.request(event, data, requestOptions),\n    channel,\n  };\n}\n\n/**\n * Calls `handler` for each message of `event` on `channel` while the owning component lives.\n *\n * @param channel A channel from `useChannel(...).channel` or `rt.channel(...)`.\n * @param event The event name.\n * @param handler Called with the data and the message meta.\n * @example\n * import { createRealtime } from \"@shadow-js/realtime/client\";\n * import { useChannel, useChannelEvent } from \"@shadow-js/realtime/hooks\";\n *\n * type Schema = { [name: `chat:${string}`]: { events: { message: { text: string } } } };\n * const rt = createRealtime<Schema>({ url: \"/rt\" });\n *\n * function Log() {\n *   const { channel } = useChannel(rt, \"chat:lobby\");\n *   useChannelEvent(channel, \"message\", (data) => console.log(data.text));\n *   return <p>listening</p>;\n * }\n * @since 1.0.0\n */\nexport function useChannelEvent<Def extends ChannelDef, E extends keyof Def[\"events\"] & string>(\n  channel: Channel<Def>,\n  event: E,\n  handler: (data: Def[\"events\"][E], meta: MessageMeta) => void,\n): void {\n  if (isServer) return;\n  onCleanup(channel.on(event, handler));\n}\n\n/**\n * The presence set of `channel` as a signal, and a setter that joins it (or changes this client's state) from the owning\n * component. Passing `undefined` leaves. The component leaves the set when it is disposed.\n *\n * @param channel A channel from `useChannel(...).channel` or `rt.channel(...)`.\n * @returns The members and `setPresence`.\n * @example\n * import { createRealtime } from \"@shadow-js/realtime/client\";\n * import { useChannel, useChannelPresence } from \"@shadow-js/realtime/hooks\";\n *\n * type Schema = {\n *   [name: `chat:${string}`]: { events: { message: string }; presence: { name: string } };\n * };\n * const rt = createRealtime<Schema>({ url: \"/rt\" });\n *\n * function Who() {\n *   const { channel } = useChannel(rt, \"chat:lobby\");\n *   const [members, setPresence] = useChannelPresence(channel);\n *   setPresence({ name: \"ann\" });\n *   return <p>{members().length} here</p>;\n * }\n * @since 1.0.0\n */\nexport function useChannelPresence<Def extends ChannelDef>(\n  channel: Channel<Def>,\n): readonly [\n  Accessor<readonly Member<PresenceOf<Def>>[]>,\n  (state: PresenceOf<Def> | undefined) => void,\n] {\n  const [members, setMembers] = useSignal<readonly Member<PresenceOf<Def>>[]>(\n    channel.presence.members(),\n  );\n  let joined = false;\n  if (!isServer) {\n    const stop = channel.presence.on((list) => setMembers(() => list));\n    onCleanup(() => {\n      stop();\n      if (joined) channel.presence.leave();\n    });\n  }\n  return [\n    members,\n    (state) => {\n      if (isServer) return;\n      if (state === undefined) {\n        joined = false;\n        channel.presence.leave();\n      } else {\n        joined = true;\n        channel.presence.set(state);\n      }\n    },\n  ];\n}\n\n/**\n * The connection status of `rt` as a signal.\n *\n * @param rt The client from `createRealtime`.\n * @returns The status accessor.\n * @example\n * import { createRealtime } from \"@shadow-js/realtime/client\";\n * import { useRealtimeStatus } from \"@shadow-js/realtime/hooks\";\n *\n * const rt = createRealtime({ url: \"/rt\" });\n *\n * function Badge() {\n *   const status = useRealtimeStatus(rt);\n *   return <span>{status()}</span>;\n * }\n * @since 1.0.0\n */\nexport function useRealtimeStatus<Schema extends ChannelSchema>(\n  rt: Realtime<Schema>,\n): Accessor<Status> {\n  const [status, setStatus] = useSignal<Status>(rt.status);\n  if (!isServer) onCleanup(rt.onStatus((next) => setStatus(next)));\n  return status;\n}\n"],"mappings":";;;;AA0CA,SAAS,aAAqC,MAA4B;CACxE,MAAM,eACJ,QAAQ,OACN,IAAI,cAAc,UAAU,8DAA8D,CAC5F;CACF,MAAM,mBAAiC,KAAA;CACvC,OAAO;EACL;EACA,QAAQ;EACR,SAAS;EACT,IAAI;EACJ,OAAO;EACP,OAAO;EACP,UAAU;EACV,SAAS;EACT,SAAS;EACT,UAAU;GAAE,eAAe,CAAC;GAAG,WAAW,KAAA;GAAW,aAAa,KAAA;GAAW,IAAI;EAAK;EACtF,aAAa,KAAA;CACf;AACF;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,WACd,IACA,MACA,SAC6B;CAC7B,MAAM,UAAiC,WACnC,aAA2B,IAAI,IAC/B,GAAG,QAAQ,MAAM,OAAO;CAC5B,MAAM,CAAC,QAAQ,aAAa,UAAyB,QAAQ,MAAM;CACnE,MAAM,CAAC,aAAa,kBAAkB,UAAgD,KAAA,CAAS;CAC/F,IAAI,CAAC,UAAU;EACb,MAAM,aAAa,QAAQ,UAAU,SAAS,UAAU,IAAI,CAAC;EAC7D,MAAM,eAAe,QAAQ,OAAO,YAAY,qBAAqB,OAAO,CAAC;EAC7E,gBAAgB;GACd,WAAW;GACX,aAAa;EACf,CAAC;CACH;CACA,OAAO;EACL;EACA;EACA,UAAU,OAAO,MAAM,mBAAmB,QAAQ,QAAQ,OAAO,MAAM,cAAc;EACrF,UAAU,OAAO,MAAM,mBAAmB,QAAQ,QAAQ,OAAO,MAAM,cAAc;EACrF;CACF;AACF;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,gBACd,SACA,OACA,SACM;CACN,IAAI,UAAU;CACd,UAAU,QAAQ,GAAG,OAAO,OAAO,CAAC;AACtC;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,mBACd,SAIA;CACA,MAAM,CAAC,SAAS,cAAc,UAC5B,QAAQ,SAAS,QAAQ,CAC3B;CACA,IAAI,SAAS;CACb,IAAI,CAAC,UAAU;EACb,MAAM,OAAO,QAAQ,SAAS,IAAI,SAAS,iBAAiB,IAAI,CAAC;EACjE,gBAAgB;GACd,KAAK;GACL,IAAI,QAAQ,QAAQ,SAAS,MAAM;EACrC,CAAC;CACH;CACA,OAAO,CACL,UACC,UAAU;EACT,IAAI,UAAU;EACd,IAAI,UAAU,KAAA,GAAW;GACvB,SAAS;GACT,QAAQ,SAAS,MAAM;EACzB,OAAO;GACL,SAAS;GACT,QAAQ,SAAS,IAAI,KAAK;EAC5B;CACF,CACF;AACF;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,kBACd,IACkB;CAClB,MAAM,CAAC,QAAQ,aAAa,UAAkB,GAAG,MAAM;CACvD,IAAI,CAAC,UAAU,UAAU,GAAG,UAAU,SAAS,UAAU,IAAI,CAAC,CAAC;CAC/D,OAAO;AACT"}

package/dist/dev/index.d.ts

@@ -0,0 +1,4 @@
+import { ErrorCode, RealtimeError } from "./errors.js";
+import { ClientFrame, DecodedClientFrame, Json, Member, PROTOCOL_VERSION, PresenceEvent, ServerFrame, StoredEntry, StoredMessage, decodeClientFrame, decodeServerFrame, isChannelName, isEventName } from "./protocol.js";
+import { Adapter, HistoryResult, PresenceRef, PublishOptions, PublishResult, Unsubscribe } from "./adapter.js";
+export { type Adapter, type ClientFrame, type DecodedClientFrame, type ErrorCode, type HistoryResult, type Json, type Member, PROTOCOL_VERSION, type PresenceEvent, type PresenceRef, type PublishOptions, type PublishResult, RealtimeError, type ServerFrame, type StoredEntry, type StoredMessage, type Unsubscribe, decodeClientFrame, decodeServerFrame, isChannelName, isEventName };

package/dist/dev/index.js

@@ -0,0 +1,3 @@
+import { RealtimeError } from "./errors.js";
+import { PROTOCOL_VERSION, decodeClientFrame, decodeServerFrame, isChannelName, isEventName } from "./protocol.js";
+export { PROTOCOL_VERSION, RealtimeError, decodeClientFrame, decodeServerFrame, isChannelName, isEventName };

package/dist/dev/memory.d.ts

@@ -0,0 +1,33 @@
+import { Adapter } from "./adapter.js";
+//#region src/memory.d.ts
+/**
+ * Options of {@link memoryAdapter}.
+ * @since 1.0.0
+ */
+export interface MemoryAdapterOptions {
+  /** The clock, in epoch milliseconds. Default: `Date.now`. */
+  readonly now?: () => number;
+  /**
+   * Milliseconds a channel with no listener and no retained message is remembered. After that its head is forgotten and its
+   * numbering restarts, which a resuming client sees as `reset`. Default: one hour.
+   */
+  readonly idleMs?: number;
+}
+/**
+ * The single-process adapter, and the default of `createHub`. Messages, history, idempotency keys and presence live in memory
+ * of this process; several hubs created over one adapter object share them, which is how tests exercise two servers. Use the Redis
+ * or Cloudflare adapter when more than one process serves clients.
+ *
+ * @param options The clock.
+ * @returns The adapter.
+ * @example
+ * import { createHub, memoryAdapter } from "@shadow-js/realtime/server";
+ *
+ * const adapter = memoryAdapter();
+ * const hub = createHub({ adapter });
+ * void hub.close();
+ * @since 1.0.0
+ */
+export declare function memoryAdapter(options?: MemoryAdapterOptions): Adapter;
+//#endregion
+//# sourceMappingURL=memory.d.ts.map

package/dist/dev/memory.js

@@ -0,0 +1,255 @@
+//#region src/memory.ts
+/**
+* The single-process adapter, and the default of `createHub`. Messages, history, idempotency keys and presence live in memory
+* of this process; several hubs created over one adapter object share them, which is how tests exercise two servers. Use the Redis
+* or Cloudflare adapter when more than one process serves clients.
+*
+* @param options The clock.
+* @returns The adapter.
+* @example
+* import { createHub, memoryAdapter } from "@shadow-js/realtime/server";
+*
+* const adapter = memoryAdapter();
+* const hub = createHub({ adapter });
+* void hub.close();
+* @since 1.0.0
+*/
+function memoryAdapter(options = {}) {
+	const now = options.now ?? Date.now;
+	const idleMs = options.idleMs ?? 36e5;
+	let sweepAt = 1024;
+	const channels = /* @__PURE__ */ new Map();
+	const presence = /* @__PURE__ */ new Map();
+	const presenceListeners = /* @__PURE__ */ new Map();
+	const presenceQueue = [];
+	let presenceDraining = false;
+	let closed = false;
+	/** Forgets channels nobody listens to and nothing retains; runs when the table has doubled since the last sweep. */
+	function sweep() {
+		const cutoff = now() - idleMs;
+		for (const [name, state] of channels) if (state.listeners.size === 0 && state.lastActive < cutoff) {
+			trim(state, state.log.length, idleMs);
+			if (state.log.length === 0) channels.delete(name);
+		}
+		sweepAt = Math.max(1024, channels.size * 2);
+	}
+	function channelOf(name) {
+		let state = channels.get(name);
+		if (state === void 0) {
+			if (channels.size >= sweepAt) sweep();
+			state = {
+				lastActive: now(),
+				seq: 0,
+				log: [],
+				keys: /* @__PURE__ */ new Map(),
+				listeners: /* @__PURE__ */ new Set(),
+				pending: [],
+				draining: false
+			};
+			channels.set(name, state);
+		}
+		state.lastActive = now();
+		return state;
+	}
+	/** Delivers queued messages in order; a listener that publishes in turn queues behind the message being delivered. */
+	function drain(state) {
+		if (state.draining) return;
+		state.draining = true;
+		try {
+			for (let next = state.pending.shift(); next !== void 0; next = state.pending.shift()) for (const listener of [...state.listeners]) try {
+				listener(next);
+			} catch {}
+		} finally {
+			state.draining = false;
+		}
+	}
+	function emitPresence(event) {
+		presenceQueue.push(event);
+		if (presenceDraining) return;
+		presenceDraining = true;
+		try {
+			for (let next = presenceQueue.shift(); next !== void 0; next = presenceQueue.shift()) for (const listener of [...presenceListeners.get(next.channel) ?? []]) try {
+				listener(next);
+			} catch {}
+		} finally {
+			presenceDraining = false;
+		}
+	}
+	function trim(state, history, ttl) {
+		const cutoff = now() - ttl;
+		let drop = Math.max(0, state.log.length - history);
+		while (drop < state.log.length && (state.log[drop]?.at ?? Infinity) < cutoff) drop += 1;
+		if (drop > 0) state.log = state.log.slice(drop);
+	}
+	function live(name) {
+		let set = presence.get(name);
+		if (set === void 0) {
+			set = /* @__PURE__ */ new Map();
+			presence.set(name, set);
+		}
+		return set;
+	}
+	function check() {
+		if (closed) throw new Error("the adapter is closed.");
+	}
+	return {
+		async publish(channel, entry, publish) {
+			check();
+			const state = channelOf(channel);
+			const at = now();
+			if (publish.key !== void 0) {
+				const known = state.keys.get(publish.key);
+				if (known !== void 0 && known.expires > at) return {
+					seq: known.seq,
+					duplicate: true
+				};
+				if (state.keys.size >= 4096) {
+					for (const [key, value] of state.keys) if (value.expires <= at) state.keys.delete(key);
+				}
+			}
+			state.seq += 1;
+			const message = {
+				...entry,
+				seq: state.seq,
+				at
+			};
+			if (publish.key !== void 0) state.keys.set(publish.key, {
+				seq: state.seq,
+				expires: at + publish.idempotencyTtlMs
+			});
+			if (publish.history > 0) {
+				state.log.push(message);
+				trim(state, publish.history, publish.historyTtlMs);
+			} else state.log = [];
+			state.pending.push(message);
+			drain(state);
+			return {
+				seq: message.seq,
+				duplicate: false
+			};
+		},
+		async subscribe(channel, listener) {
+			check();
+			const state = channelOf(channel);
+			state.listeners.add(listener);
+			return async () => {
+				state.listeners.delete(listener);
+			};
+		},
+		async history(channel, after, limit) {
+			check();
+			const state = channels.get(channel);
+			if (state === void 0) return {
+				messages: [],
+				head: 0,
+				oldest: 0
+			};
+			const retained = state.log;
+			const messages = [];
+			for (const message of retained) {
+				if (messages.length >= limit) break;
+				if (message.seq > after) messages.push(message);
+			}
+			return {
+				messages,
+				head: state.seq,
+				oldest: retained[0]?.seq ?? 0
+			};
+		},
+		async presenceSet(channel, member, ttlMs) {
+			check();
+			const set = live(channel);
+			const known = set.get(member.id);
+			if (known !== void 0 && known.member.v > member.v) return;
+			set.set(member.id, {
+				member,
+				expires: now() + ttlMs
+			});
+			if (known === void 0) emitPresence({
+				channel,
+				op: "join",
+				member
+			});
+			else if (known.member.v < member.v) emitPresence({
+				channel,
+				op: "set",
+				member
+			});
+		},
+		async presenceRemove(channel, id) {
+			check();
+			const set = presence.get(channel);
+			const known = set?.get(id);
+			if (set === void 0 || known === void 0) return false;
+			set.delete(id);
+			if (set.size === 0) presence.delete(channel);
+			emitPresence({
+				channel,
+				op: "leave",
+				member: known.member
+			});
+			return true;
+		},
+		async presenceList(channel) {
+			check();
+			const at = now();
+			const out = [];
+			for (const entry of presence.get(channel)?.values() ?? []) if (entry.expires > at) out.push(entry.member);
+			return out;
+		},
+		async presenceTouch(entries, ttlMs) {
+			check();
+			const expires = now() + ttlMs;
+			const missing = [];
+			for (const ref of entries) {
+				const entry = presence.get(ref.channel)?.get(ref.id);
+				if (entry === void 0) missing.push(ref);
+				else entry.expires = expires;
+			}
+			return missing;
+		},
+		async presenceReap(channel) {
+			check();
+			const set = presence.get(channel);
+			if (set === void 0) return [];
+			const at = now();
+			const removed = [];
+			for (const [id, entry] of [...set]) {
+				if (entry.expires > at) continue;
+				set.delete(id);
+				removed.push(entry.member);
+				emitPresence({
+					channel,
+					op: "leave",
+					member: entry.member
+				});
+			}
+			if (set.size === 0) presence.delete(channel);
+			return removed;
+		},
+		async presenceSubscribe(channel, listener) {
+			check();
+			let set = presenceListeners.get(channel);
+			if (set === void 0) {
+				set = /* @__PURE__ */ new Set();
+				presenceListeners.set(channel, set);
+			}
+			set.add(listener);
+			const owner = set;
+			return async () => {
+				owner.delete(listener);
+				if (owner.size === 0 && presenceListeners.get(channel) === owner) presenceListeners.delete(channel);
+			};
+		},
+		async close() {
+			closed = true;
+			channels.clear();
+			presence.clear();
+			presenceListeners.clear();
+		}
+	};
+}
+//#endregion
+export { memoryAdapter };
+
+//# sourceMappingURL=memory.js.map