@rpgjs/map-builder 0.0.0-stage → 5.0.0

package/dist/protocol/index.js

@@ -0,0 +1,106 @@
+import { isJsonValue, isPlainObject } from "../model/json.js";
+//#region src/protocol/index.ts
+/**
+* Messages between a map client and the authority of that map. They are plain JSON, so
+* any transport carries them: a WebSocket, an RPGJS socket event, a Worker message.
+*
+* The client asks (`intent`), the authority decides and tells everybody (`patches`).
+* A client never sends patches unless the authority trusts it.
+*/
+var MAP_BUILDER_EVENT = "map-builder";
+/** What an authority refuses to read, to keep a client from making it work too hard. */
+var PROTOCOL_LIMITS = {
+	/** Intents in one request. */
+	maxIntents: 64,
+	/** Patches in one trusted request. */
+	maxPatches: 256,
+	/** Length of a request id. */
+	maxIdLength: 64
+};
+var isId = (value) => typeof value === "string" && value.length > 0 && value.length <= PROTOCOL_LIMITS.maxIdLength;
+var isObjectWithType = (value) => isPlainObject(value) && typeof value.type === "string" && isJsonValue(value);
+/**
+* Reads a message that came from the network. Anything that does not have exactly
+* the expected shape is `undefined`: never trust a client, nor assume a message is one.
+*/
+function parseClientMessage(raw) {
+	if (!isPlainObject(raw) || typeof raw.type !== "string") return void 0;
+	switch (raw.type) {
+		case "sync":
+			if (raw.since !== void 0 && !(Number.isInteger(raw.since) && raw.since >= 0)) return void 0;
+			return raw.since === void 0 ? { type: "sync" } : {
+				type: "sync",
+				since: raw.since
+			};
+		case "intent":
+			if (!isId(raw.id) || !Array.isArray(raw.intents)) return void 0;
+			if (raw.intents.length === 0 || raw.intents.length > PROTOCOL_LIMITS.maxIntents) return void 0;
+			if (!raw.intents.every(isObjectWithType)) return void 0;
+			return {
+				type: "intent",
+				id: raw.id,
+				intents: raw.intents
+			};
+		case "patches":
+			if (!isId(raw.id) || !Array.isArray(raw.patches)) return void 0;
+			if (raw.patches.length === 0 || raw.patches.length > PROTOCOL_LIMITS.maxPatches) return void 0;
+			if (!raw.patches.every(isObjectWithType)) return void 0;
+			return {
+				type: "patches",
+				id: raw.id,
+				patches: raw.patches
+			};
+		default: return;
+	}
+}
+/** Reads a message the authority sent. A client must not crash on garbage either. */
+function parseServerMessage(raw) {
+	if (!isPlainObject(raw) || typeof raw.type !== "string") return void 0;
+	const revision = raw.revision;
+	const hasRevision = Number.isInteger(revision) && revision >= 0;
+	switch (raw.type) {
+		case "snapshot": return hasRevision && isPlainObject(raw.definition) && isJsonValue(raw.definition) ? {
+			type: "snapshot",
+			revision,
+			definition: raw.definition
+		} : void 0;
+		case "patches":
+			if (!hasRevision || !Array.isArray(raw.patches) || !raw.patches.every(isObjectWithType)) return void 0;
+			if (raw.requestId !== void 0 && typeof raw.requestId !== "string") return void 0;
+			if (raw.author !== void 0 && typeof raw.author !== "string") return void 0;
+			return {
+				type: "patches",
+				revision,
+				patches: raw.patches,
+				...raw.requestId !== void 0 ? { requestId: raw.requestId } : {},
+				...raw.author !== void 0 ? { author: raw.author } : {}
+			};
+		case "rejected": return typeof raw.id === "string" && typeof raw.reason === "string" && typeof raw.message === "string" ? {
+			type: "rejected",
+			id: raw.id,
+			reason: raw.reason,
+			message: raw.message,
+			...Number.isInteger(raw.patchIndex) ? { patchIndex: raw.patchIndex } : {}
+		} : void 0;
+		case "synced": return hasRevision ? {
+			type: "synced",
+			revision
+		} : void 0;
+		case "effect": {
+			const target = raw.target;
+			if (!(typeof target === "string" || isPlainObject(target) && (target.type === "element" || target.type === "event") && typeof target.id === "string") || typeof raw.name !== "string") return void 0;
+			if (raw.params !== void 0 && !(isPlainObject(raw.params) && isJsonValue(raw.params))) return void 0;
+			return {
+				type: "effect",
+				target,
+				name: raw.name,
+				...raw.params !== void 0 ? { params: raw.params } : {}
+			};
+		}
+		default: return;
+	}
+}
+//#endregion
+export { MAP_BUILDER_EVENT, PROTOCOL_LIMITS, parseClientMessage, parseServerMessage };
+
+//# sourceMappingURL=index.js.map

package/dist/protocol/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/protocol/index.ts"],"sourcesContent":["import type { MapDefinition } from \"../model/definition\";\nimport { isJsonValue, isPlainObject } from \"../model/json\";\nimport type { MapPatch } from \"../model/patches\";\nimport type { MapIntent } from \"../interaction/intents\";\n\n/**\n * Messages between a map client and the authority of that map. They are plain JSON, so\n * any transport carries them: a WebSocket, an RPGJS socket event, a Worker message.\n *\n * The client asks (`intent`), the authority decides and tells everybody (`patches`).\n * A client never sends patches unless the authority trusts it.\n */\nexport const MAP_BUILDER_EVENT = \"map-builder\";\n\nexport type ClientMessage =\n  /** Join, or catch up. `since` is the last revision the client has. */\n  | { readonly type: \"sync\"; readonly since?: number }\n  /** Ask for something to happen. `id` comes back in the answer. */\n  | { readonly type: \"intent\"; readonly id: string; readonly intents: readonly MapIntent[] }\n  /** Ask for patches to be applied as they are. Only for clients the authority trusts (an editor, an undo). */\n  | { readonly type: \"patches\"; readonly id: string; readonly patches: readonly MapPatch[] };\n\nexport type ServerMessage =\n  /** The whole map, at a revision: to join, or when the client is too far behind. */\n  | { readonly type: \"snapshot\"; readonly revision: number; readonly definition: MapDefinition }\n  /** A change that became true. `requestId` is set for the client that asked for it. */\n  | {\n      readonly type: \"patches\";\n      readonly revision: number;\n      readonly patches: readonly MapPatch[];\n      readonly requestId?: string;\n      /** Who made the change, when the authority knows and wants to say. */\n      readonly author?: string;\n    }\n  /** The authority said no, and why. */\n  | { readonly type: \"rejected\"; readonly id: string; readonly reason: string; readonly message: string; readonly patchIndex?: number }\n  /** The client is up to date: nothing to send. */\n  | { readonly type: \"synced\"; readonly revision: number }\n  /** A short visual effect: it is shown, not kept. */\n  | { readonly type: \"effect\"; readonly target: EffectTargetMessage; readonly name: string; readonly params?: Readonly<Record<string, unknown>> };\n\nexport type EffectTargetMessage = string | { readonly type: \"element\" | \"event\"; readonly id: string };\n\n/** What an authority refuses to read, to keep a client from making it work too hard. */\nexport const PROTOCOL_LIMITS = {\n  /** Intents in one request. */\n  maxIntents: 64,\n  /** Patches in one trusted request. */\n  maxPatches: 256,\n  /** Length of a request id. */\n  maxIdLength: 64,\n} as const;\n\nconst isId = (value: unknown): value is string =>\n  typeof value === \"string\" && value.length > 0 && value.length <= PROTOCOL_LIMITS.maxIdLength;\n\nconst isObjectWithType = (value: unknown): boolean => isPlainObject(value) && typeof value.type === \"string\" && isJsonValue(value);\n\n/**\n * Reads a message that came from the network. Anything that does not have exactly\n * the expected shape is `undefined`: never trust a client, nor assume a message is one.\n */\nexport function parseClientMessage(raw: unknown): ClientMessage | undefined {\n  if (!isPlainObject(raw) || typeof raw.type !== \"string\") return undefined;\n  switch (raw.type) {\n    case \"sync\":\n      if (raw.since !== undefined && !(Number.isInteger(raw.since) && (raw.since as number) >= 0)) return undefined;\n      return raw.since === undefined ? { type: \"sync\" } : { type: \"sync\", since: raw.since as number };\n    case \"intent\":\n      if (!isId(raw.id) || !Array.isArray(raw.intents)) return undefined;\n      if (raw.intents.length === 0 || raw.intents.length > PROTOCOL_LIMITS.maxIntents) return undefined;\n      if (!raw.intents.every(isObjectWithType)) return undefined;\n      return { type: \"intent\", id: raw.id, intents: raw.intents as MapIntent[] };\n    case \"patches\":\n      if (!isId(raw.id) || !Array.isArray(raw.patches)) return undefined;\n      if (raw.patches.length === 0 || raw.patches.length > PROTOCOL_LIMITS.maxPatches) return undefined;\n      if (!raw.patches.every(isObjectWithType)) return undefined;\n      return { type: \"patches\", id: raw.id, patches: raw.patches as MapPatch[] };\n    default:\n      return undefined;\n  }\n}\n\n/** Reads a message the authority sent. A client must not crash on garbage either. */\nexport function parseServerMessage(raw: unknown): ServerMessage | undefined {\n  if (!isPlainObject(raw) || typeof raw.type !== \"string\") return undefined;\n  const revision = raw.revision;\n  const hasRevision = Number.isInteger(revision) && (revision as number) >= 0;\n  switch (raw.type) {\n    case \"snapshot\":\n      return hasRevision && isPlainObject(raw.definition) && isJsonValue(raw.definition)\n        ? { type: \"snapshot\", revision: revision as number, definition: raw.definition as unknown as MapDefinition }\n        : undefined;\n    case \"patches\":\n      if (!hasRevision || !Array.isArray(raw.patches) || !raw.patches.every(isObjectWithType)) return undefined;\n      if (raw.requestId !== undefined && typeof raw.requestId !== \"string\") return undefined;\n      if (raw.author !== undefined && typeof raw.author !== \"string\") return undefined;\n      return {\n        type: \"patches\",\n        revision: revision as number,\n        patches: raw.patches as MapPatch[],\n        ...(raw.requestId !== undefined ? { requestId: raw.requestId as string } : {}),\n        ...(raw.author !== undefined ? { author: raw.author as string } : {}),\n      };\n    case \"rejected\":\n      return typeof raw.id === \"string\" && typeof raw.reason === \"string\" && typeof raw.message === \"string\"\n        ? {\n            type: \"rejected\",\n            id: raw.id,\n            reason: raw.reason,\n            message: raw.message,\n            ...(Number.isInteger(raw.patchIndex) ? { patchIndex: raw.patchIndex as number } : {}),\n          }\n        : undefined;\n    case \"synced\":\n      return hasRevision ? { type: \"synced\", revision: revision as number } : undefined;\n    case \"effect\": {\n      const target = raw.target;\n      const validTarget =\n        typeof target === \"string\" ||\n        (isPlainObject(target) && (target.type === \"element\" || target.type === \"event\") && typeof target.id === \"string\");\n      if (!validTarget || typeof raw.name !== \"string\") return undefined;\n      if (raw.params !== undefined && !(isPlainObject(raw.params) && isJsonValue(raw.params))) return undefined;\n      return {\n        type: \"effect\",\n        target: target as EffectTargetMessage,\n        name: raw.name,\n        ...(raw.params !== undefined ? { params: raw.params as Record<string, unknown> } : {}),\n      };\n    }\n    default:\n      return undefined;\n  }\n}\n\n/** A way to carry messages, whatever the framework: both ends of a connection implement it. */\nexport interface MapTransport {\n  send(message: ClientMessage): void;\n  /** Called for every message from the authority. Returns the function that stops listening. */\n  onMessage(listener: (message: ServerMessage) => void): () => void;\n}\n"],"mappings":";;;;;;;;;AAYA,IAAa,oBAAoB;;AAgCjC,IAAa,kBAAkB;;CAE7B,YAAY;;CAEZ,YAAY;;CAEZ,aAAa;AACf;AAEA,IAAM,QAAQ,UACZ,OAAO,UAAU,YAAY,MAAM,SAAS,KAAK,MAAM,UAAU,gBAAgB;AAEnF,IAAM,oBAAoB,UAA4B,cAAc,KAAK,KAAK,OAAO,MAAM,SAAS,YAAY,YAAY,KAAK;;;;;AAMjI,SAAgB,mBAAmB,KAAyC;CAC1E,IAAI,CAAC,cAAc,GAAG,KAAK,OAAO,IAAI,SAAS,UAAU,OAAO,KAAA;CAChE,QAAQ,IAAI,MAAZ;EACE,KAAK;GACH,IAAI,IAAI,UAAU,KAAA,KAAa,EAAE,OAAO,UAAU,IAAI,KAAK,KAAM,IAAI,SAAoB,IAAI,OAAO,KAAA;GACpG,OAAO,IAAI,UAAU,KAAA,IAAY,EAAE,MAAM,OAAO,IAAI;IAAE,MAAM;IAAQ,OAAO,IAAI;GAAgB;EACjG,KAAK;GACH,IAAI,CAAC,KAAK,IAAI,EAAE,KAAK,CAAC,MAAM,QAAQ,IAAI,OAAO,GAAG,OAAO,KAAA;GACzD,IAAI,IAAI,QAAQ,WAAW,KAAK,IAAI,QAAQ,SAAS,gBAAgB,YAAY,OAAO,KAAA;GACxF,IAAI,CAAC,IAAI,QAAQ,MAAM,gBAAgB,GAAG,OAAO,KAAA;GACjD,OAAO;IAAE,MAAM;IAAU,IAAI,IAAI;IAAI,SAAS,IAAI;GAAuB;EAC3E,KAAK;GACH,IAAI,CAAC,KAAK,IAAI,EAAE,KAAK,CAAC,MAAM,QAAQ,IAAI,OAAO,GAAG,OAAO,KAAA;GACzD,IAAI,IAAI,QAAQ,WAAW,KAAK,IAAI,QAAQ,SAAS,gBAAgB,YAAY,OAAO,KAAA;GACxF,IAAI,CAAC,IAAI,QAAQ,MAAM,gBAAgB,GAAG,OAAO,KAAA;GACjD,OAAO;IAAE,MAAM;IAAW,IAAI,IAAI;IAAI,SAAS,IAAI;GAAsB;EAC3E,SACE;CACJ;AACF;;AAGA,SAAgB,mBAAmB,KAAyC;CAC1E,IAAI,CAAC,cAAc,GAAG,KAAK,OAAO,IAAI,SAAS,UAAU,OAAO,KAAA;CAChE,MAAM,WAAW,IAAI;CACrB,MAAM,cAAc,OAAO,UAAU,QAAQ,KAAM,YAAuB;CAC1E,QAAQ,IAAI,MAAZ;EACE,KAAK,YACH,OAAO,eAAe,cAAc,IAAI,UAAU,KAAK,YAAY,IAAI,UAAU,IAC7E;GAAE,MAAM;GAAsB;GAAoB,YAAY,IAAI;EAAuC,IACzG,KAAA;EACN,KAAK;GACH,IAAI,CAAC,eAAe,CAAC,MAAM,QAAQ,IAAI,OAAO,KAAK,CAAC,IAAI,QAAQ,MAAM,gBAAgB,GAAG,OAAO,KAAA;GAChG,IAAI,IAAI,cAAc,KAAA,KAAa,OAAO,IAAI,cAAc,UAAU,OAAO,KAAA;GAC7E,IAAI,IAAI,WAAW,KAAA,KAAa,OAAO,IAAI,WAAW,UAAU,OAAO,KAAA;GACvE,OAAO;IACL,MAAM;IACI;IACV,SAAS,IAAI;IACb,GAAI,IAAI,cAAc,KAAA,IAAY,EAAE,WAAW,IAAI,UAAoB,IAAI,CAAC;IAC5E,GAAI,IAAI,WAAW,KAAA,IAAY,EAAE,QAAQ,IAAI,OAAiB,IAAI,CAAC;GACrE;EACF,KAAK,YACH,OAAO,OAAO,IAAI,OAAO,YAAY,OAAO,IAAI,WAAW,YAAY,OAAO,IAAI,YAAY,WAC1F;GACE,MAAM;GACN,IAAI,IAAI;GACR,QAAQ,IAAI;GACZ,SAAS,IAAI;GACb,GAAI,OAAO,UAAU,IAAI,UAAU,IAAI,EAAE,YAAY,IAAI,WAAqB,IAAI,CAAC;EACrF,IACA,KAAA;EACN,KAAK,UACH,OAAO,cAAc;GAAE,MAAM;GAAoB;EAAmB,IAAI,KAAA;EAC1E,KAAK,UAAU;GACb,MAAM,SAAS,IAAI;GAInB,IAAI,EAFF,OAAO,WAAW,YACjB,cAAc,MAAM,MAAM,OAAO,SAAS,aAAa,OAAO,SAAS,YAAY,OAAO,OAAO,OAAO,aACvF,OAAO,IAAI,SAAS,UAAU,OAAO,KAAA;GACzD,IAAI,IAAI,WAAW,KAAA,KAAa,EAAE,cAAc,IAAI,MAAM,KAAK,YAAY,IAAI,MAAM,IAAI,OAAO,KAAA;GAChG,OAAO;IACL,MAAM;IACE;IACR,MAAM,IAAI;IACV,GAAI,IAAI,WAAW,KAAA,IAAY,EAAE,QAAQ,IAAI,OAAkC,IAAI,CAAC;GACtF;EACF;EACA,SACE;CACJ;AACF"}

package/dist/remote/committer.d.ts

@@ -0,0 +1,43 @@
+import { MapCommitter } from '../model/committer';
+import { ApplyResult } from '../model/result';
+import { MapTransport, ServerMessage } from '../protocol';
+export interface RemoteCommitterOptions {
+    readonly transport: MapTransport;
+    /** How long to wait for the authority before giving up on a request. Defaults to 10000. */
+    readonly timeoutMs?: number;
+    readonly onError?: (error: unknown) => void;
+    /** Replaces `setTimeout`, so tests control time. Returns the function that cancels it. */
+    readonly schedule?: (run: () => void, delayMs: number) => () => void;
+}
+export interface RemoteEffect {
+    readonly target: Extract<ServerMessage, {
+        type: "effect";
+    }>["target"];
+    readonly name: string;
+    readonly params?: Readonly<Record<string, unknown>> | undefined;
+}
+export interface RemoteCommitter extends MapCommitter<Promise<ApplyResult>> {
+    /** Called when the authority shows an effect (a shake, a blink) to everybody. */
+    onEffect(listener: (effect: RemoteEffect) => void): () => void;
+    /**
+     * The map the authority sends first. Messages that arrive while the model does not exist
+     * yet are kept, and replayed once it is attached.
+     */
+    nextSnapshot(timeoutMs?: number): Promise<Extract<ServerMessage, {
+        type: "snapshot";
+    }>>;
+    /** Stops listening. Requests still waiting end with the code `disconnected`. */
+    disconnect(): void;
+}
+/**
+ * A committer that does not decide anything: it asks the authority and waits. The change
+ * becomes true when the authority says so, for everybody at once, in the same order.
+ *
+ * - Intents are sent as they are. Patches are only sent when there are no intents (an undo),
+ *   and the authority refuses them unless it trusts this client.
+ * - Changes come back as `patches` messages. Those that answer a request of ours are
+ *   recorded in the history; the others, made by someone else, are not.
+ * - A hole in the revisions, or a change that does not fit, makes it ask to catch up.
+ */
+export declare function remoteCommitter(options: RemoteCommitterOptions): RemoteCommitter;
+//# sourceMappingURL=committer.d.ts.map

package/dist/remote/committer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"committer.d.ts","sourceRoot":"","sources":["../../src/remote/committer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA6B,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAA0C,KAAK,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5G,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,2FAA2F;IAC3F,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC5C,0FAA0F;IAC1F,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,IAAI,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,IAAI,CAAC;CACtE;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAA;KAAE,CAAC,CAAC,QAAQ,CAAC,CAAC;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;CACjE;AAED,MAAM,WAAW,eAAgB,SAAQ,YAAY,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IACzE,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAC/D;;;OAGG;IACH,YAAY,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,EAAE;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,CAAC,CAAC,CAAC;IACxF,gFAAgF;IAChF,UAAU,IAAI,IAAI,CAAC;CACpB;AAoBD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,eAAe,CA8KhF"}

package/dist/remote/committer.js

@@ -0,0 +1,206 @@
+import { parseServerMessage } from "../protocol/index.js";
+//#region src/remote/committer.ts
+var failure = (code, message, patchIndex) => ({
+	ok: false,
+	rejection: {
+		code,
+		message,
+		...patchIndex !== void 0 ? { patchIndex } : {}
+	}
+});
+var requestCounter = 0;
+var newRequestId = () => {
+	return globalThis.crypto?.randomUUID?.() ?? `r${Date.now().toString(36)}-${(requestCounter += 1).toString(36)}`;
+};
+/**
+* A committer that does not decide anything: it asks the authority and waits. The change
+* becomes true when the authority says so, for everybody at once, in the same order.
+*
+* - Intents are sent as they are. Patches are only sent when there are no intents (an undo),
+*   and the authority refuses them unless it trusts this client.
+* - Changes come back as `patches` messages. Those that answer a request of ours are
+*   recorded in the history; the others, made by someone else, are not.
+* - A hole in the revisions, or a change that does not fit, makes it ask to catch up.
+*/
+function remoteCommitter(options) {
+	const timeoutMs = options.timeoutMs ?? 1e4;
+	const reportError = options.onError ?? ((error) => console.error(error));
+	const schedule = options.schedule ?? ((run, delayMs) => {
+		const handle = setTimeout(run, delayMs);
+		return () => clearTimeout(handle);
+	});
+	let host;
+	let disconnected = false;
+	let waitingForSync = false;
+	let cancelSyncTimeout;
+	const queue = [];
+	let snapshotWaiter;
+	const pending = /* @__PURE__ */ new Map();
+	const effectListeners = /* @__PURE__ */ new Set();
+	const send = (message) => {
+		try {
+			options.transport.send(message);
+			return true;
+		} catch (error) {
+			reportError(error);
+			return false;
+		}
+	};
+	const syncDone = () => {
+		waitingForSync = false;
+		cancelSyncTimeout?.();
+		cancelSyncTimeout = void 0;
+	};
+	/** Asks the authority to catch us up. Asks again after a while if nothing came back. */
+	const requestSync = (full = false) => {
+		if (waitingForSync || disconnected) return;
+		waitingForSync = true;
+		send(full || !host ? { type: "sync" } : {
+			type: "sync",
+			since: host.revision
+		});
+		cancelSyncTimeout = schedule(() => {
+			waitingForSync = false;
+			cancelSyncTimeout = void 0;
+		}, timeoutMs);
+	};
+	const settle = (id, result) => {
+		const request = pending.get(id);
+		if (!request) return;
+		pending.delete(id);
+		request.cancelTimeout();
+		request.settle(result);
+	};
+	const handle = (message) => {
+		if (disconnected) return;
+		switch (message.type) {
+			case "effect":
+				for (const listener of [...effectListeners]) try {
+					listener({
+						target: message.target,
+						name: message.name,
+						params: message.params
+					});
+				} catch (error) {
+					reportError(error);
+				}
+				return;
+			case "rejected":
+				settle(message.id, failure(message.reason, message.message, message.patchIndex));
+				return;
+			case "synced":
+				syncDone();
+				return;
+			case "snapshot":
+				if (!host) {
+					if (snapshotWaiter) {
+						const waiter = snapshotWaiter;
+						snapshotWaiter = void 0;
+						waiter(message);
+					} else queue.push(message);
+					return;
+				}
+				syncDone();
+				if (message.revision !== host.revision) host.reset(message.definition, message.revision);
+				return;
+			case "patches": {
+				if (!host) {
+					queue.push(message);
+					return;
+				}
+				const answered = () => {
+					if (message.requestId !== void 0) settle(message.requestId, {
+						ok: true,
+						revision: message.revision,
+						patches: message.patches,
+						inverse: []
+					});
+				};
+				if (message.revision <= host.revision) return answered();
+				if (message.revision !== host.revision + 1) {
+					answered();
+					return requestSync();
+				}
+				const mine = message.requestId !== void 0 ? pending.get(message.requestId) : void 0;
+				const result = host.integrate(message.patches, {
+					origin: mine ? "local" : "remote",
+					revision: message.revision,
+					...mine ? {
+						record: mine.record,
+						...mine.coalesce !== void 0 ? { coalesce: mine.coalesce } : {}
+					} : {}
+				});
+				if (message.requestId !== void 0) settle(message.requestId, result);
+				if (!result.ok) requestSync(true);
+				else syncDone();
+				return;
+			}
+		}
+	};
+	const stop = options.transport.onMessage((raw) => {
+		const message = parseServerMessage(raw);
+		if (message) handle(message);
+	});
+	return {
+		attach(next) {
+			if (host && host !== next) throw new Error("A committer can only be attached to one model");
+			host = next;
+			for (const message of queue.splice(0)) handle(message);
+		},
+		nextSnapshot(waitMs = timeoutMs) {
+			return new Promise((resolve, reject) => {
+				const index = queue.findIndex((message) => message.type === "snapshot");
+				if (index >= 0) return resolve(queue.splice(index, 1)[0]);
+				const cancel = schedule(() => {
+					snapshotWaiter = void 0;
+					reject(/* @__PURE__ */ new Error("The authority did not send the map"));
+				}, waitMs);
+				snapshotWaiter = (message) => {
+					cancel();
+					resolve(message);
+				};
+			});
+		},
+		commit(request) {
+			if (disconnected) return Promise.resolve(failure("disconnected", "The connection to the authority is closed"));
+			const id = newRequestId();
+			const message = request.intents && request.intents.length > 0 ? {
+				type: "intent",
+				id,
+				intents: request.intents
+			} : {
+				type: "patches",
+				id,
+				patches: request.patches
+			};
+			return new Promise((resolve) => {
+				const cancelTimeout = schedule(() => {
+					if (pending.delete(id)) resolve(failure("timeout", "The authority did not answer"));
+				}, timeoutMs);
+				pending.set(id, {
+					record: request.record,
+					coalesce: request.coalesce,
+					settle: resolve,
+					cancelTimeout
+				});
+				if (!send(message)) settle(id, failure("transport-error", "The message could not be sent"));
+			});
+		},
+		onEffect(listener) {
+			effectListeners.add(listener);
+			return () => effectListeners.delete(listener);
+		},
+		disconnect() {
+			if (disconnected) return;
+			disconnected = true;
+			stop();
+			syncDone();
+			for (const id of [...pending.keys()]) settle(id, failure("disconnected", "The connection to the authority is closed"));
+			effectListeners.clear();
+		}
+	};
+}
+//#endregion
+export { remoteCommitter };
+
+//# sourceMappingURL=committer.js.map

package/dist/remote/committer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"committer.js","names":[],"sources":["../../src/remote/committer.ts"],"sourcesContent":["import type { CommitHost, CommitRequest, MapCommitter } from \"../model/committer\";\nimport type { ApplyResult } from \"../model/result\";\nimport { parseServerMessage, type ClientMessage, type MapTransport, type ServerMessage } from \"../protocol\";\n\nexport interface RemoteCommitterOptions {\n  readonly transport: MapTransport;\n  /** How long to wait for the authority before giving up on a request. Defaults to 10000. */\n  readonly timeoutMs?: number;\n  readonly onError?: (error: unknown) => void;\n  /** Replaces `setTimeout`, so tests control time. Returns the function that cancels it. */\n  readonly schedule?: (run: () => void, delayMs: number) => () => void;\n}\n\nexport interface RemoteEffect {\n  readonly target: Extract<ServerMessage, { type: \"effect\" }>[\"target\"];\n  readonly name: string;\n  readonly params?: Readonly<Record<string, unknown>> | undefined;\n}\n\nexport interface RemoteCommitter extends MapCommitter<Promise<ApplyResult>> {\n  /** Called when the authority shows an effect (a shake, a blink) to everybody. */\n  onEffect(listener: (effect: RemoteEffect) => void): () => void;\n  /**\n   * The map the authority sends first. Messages that arrive while the model does not exist\n   * yet are kept, and replayed once it is attached.\n   */\n  nextSnapshot(timeoutMs?: number): Promise<Extract<ServerMessage, { type: \"snapshot\" }>>;\n  /** Stops listening. Requests still waiting end with the code `disconnected`. */\n  disconnect(): void;\n}\n\ninterface Pending {\n  readonly record: boolean;\n  readonly coalesce: string | undefined;\n  readonly settle: (result: ApplyResult) => void;\n  readonly cancelTimeout: () => void;\n}\n\nconst failure = (code: string, message: string, patchIndex?: number): ApplyResult => ({\n  ok: false,\n  rejection: { code, message, ...(patchIndex !== undefined ? { patchIndex } : {}) },\n});\n\nlet requestCounter = 0;\nconst newRequestId = (): string => {\n  const random = globalThis.crypto?.randomUUID?.();\n  return random ?? `r${Date.now().toString(36)}-${(requestCounter += 1).toString(36)}`;\n};\n\n/**\n * A committer that does not decide anything: it asks the authority and waits. The change\n * becomes true when the authority says so, for everybody at once, in the same order.\n *\n * - Intents are sent as they are. Patches are only sent when there are no intents (an undo),\n *   and the authority refuses them unless it trusts this client.\n * - Changes come back as `patches` messages. Those that answer a request of ours are\n *   recorded in the history; the others, made by someone else, are not.\n * - A hole in the revisions, or a change that does not fit, makes it ask to catch up.\n */\nexport function remoteCommitter(options: RemoteCommitterOptions): RemoteCommitter {\n  const timeoutMs = options.timeoutMs ?? 10_000;\n  const reportError = options.onError ?? ((error: unknown) => console.error(error));\n  const schedule =\n    options.schedule ??\n    ((run: () => void, delayMs: number) => {\n      const handle = setTimeout(run, delayMs);\n      return () => clearTimeout(handle);\n    });\n\n  let host: CommitHost | undefined;\n  let disconnected = false;\n  let waitingForSync = false;\n  let cancelSyncTimeout: (() => void) | undefined;\n  const queue: ServerMessage[] = [];\n  let snapshotWaiter: ((message: Extract<ServerMessage, { type: \"snapshot\" }>) => void) | undefined;\n  const pending = new Map<string, Pending>();\n  const effectListeners = new Set<(effect: RemoteEffect) => void>();\n\n  const send = (message: ClientMessage): boolean => {\n    try {\n      options.transport.send(message);\n      return true;\n    } catch (error) {\n      reportError(error);\n      return false;\n    }\n  };\n\n  const syncDone = (): void => {\n    waitingForSync = false;\n    cancelSyncTimeout?.();\n    cancelSyncTimeout = undefined;\n  };\n\n  /** Asks the authority to catch us up. Asks again after a while if nothing came back. */\n  const requestSync = (full = false): void => {\n    if (waitingForSync || disconnected) return;\n    waitingForSync = true;\n    send(full || !host ? { type: \"sync\" } : { type: \"sync\", since: host.revision });\n    cancelSyncTimeout = schedule(() => {\n      waitingForSync = false;\n      cancelSyncTimeout = undefined;\n    }, timeoutMs);\n  };\n\n  const settle = (id: string, result: ApplyResult): void => {\n    const request = pending.get(id);\n    if (!request) return;\n    pending.delete(id);\n    request.cancelTimeout();\n    request.settle(result);\n  };\n\n  const handle = (message: ServerMessage): void => {\n    if (disconnected) return;\n    switch (message.type) {\n      case \"effect\":\n        for (const listener of [...effectListeners]) {\n          try {\n            listener({ target: message.target, name: message.name, params: message.params });\n          } catch (error) {\n            reportError(error);\n          }\n        }\n        return;\n      case \"rejected\":\n        settle(message.id, failure(message.reason, message.message, message.patchIndex));\n        return;\n      case \"synced\":\n        syncDone();\n        return;\n      case \"snapshot\":\n        if (!host) {\n          if (snapshotWaiter) {\n            const waiter = snapshotWaiter;\n            snapshotWaiter = undefined;\n            waiter(message);\n          } else queue.push(message);\n          return;\n        }\n        syncDone();\n        // The same revision is the same map: no need to rebuild everything for a repeated snapshot.\n        if (message.revision !== host.revision) host.reset(message.definition, message.revision);\n        return;\n      case \"patches\": {\n        if (!host) {\n          queue.push(message);\n          return;\n        }\n        // The authority applied one of our requests: it is done even if we cannot integrate it here\n        // (we caught up past it, or we are catching up), so the caller must not wait for a timeout.\n        const answered = (): void => {\n          if (message.requestId !== undefined) settle(message.requestId, { ok: true, revision: message.revision, patches: message.patches, inverse: [] });\n        };\n        // Already known: a repeat, or a change we got while catching up.\n        if (message.revision <= host.revision) return answered();\n        if (message.revision !== host.revision + 1) {\n          answered();\n          return requestSync();\n        }\n\n        const mine = message.requestId !== undefined ? pending.get(message.requestId) : undefined;\n        const result = host.integrate(message.patches, {\n          origin: mine ? \"local\" : \"remote\",\n          revision: message.revision,\n          ...(mine ? { record: mine.record, ...(mine.coalesce !== undefined ? { coalesce: mine.coalesce } : {}) } : {}),\n        });\n        if (message.requestId !== undefined) settle(message.requestId, result);\n        // A change that does not fit means we drifted: start again from the map.\n        if (!result.ok) requestSync(true);\n        else syncDone();\n        return;\n      }\n    }\n  };\n\n  // Listening starts now, not when the model exists: nothing the authority says may be lost.\n  // Whatever comes from the wire is checked first: a client never acts on garbage.\n  const stop = options.transport.onMessage((raw) => {\n    const message = parseServerMessage(raw);\n    if (message) handle(message);\n  });\n\n  return {\n    attach(next) {\n      if (host && host !== next) throw new Error(\"A committer can only be attached to one model\");\n      host = next;\n      // What arrived before the model existed, in order.\n      for (const message of queue.splice(0)) handle(message);\n    },\n    nextSnapshot(waitMs = timeoutMs) {\n      return new Promise((resolve, reject) => {\n        const index = queue.findIndex((message) => message.type === \"snapshot\");\n        if (index >= 0) return resolve(queue.splice(index, 1)[0] as never);\n        const cancel = schedule(() => {\n          snapshotWaiter = undefined;\n          reject(new Error(\"The authority did not send the map\"));\n        }, waitMs);\n        snapshotWaiter = (message) => {\n          cancel();\n          resolve(message);\n        };\n      });\n    },\n    commit(request: CommitRequest) {\n      if (disconnected) return Promise.resolve(failure(\"disconnected\", \"The connection to the authority is closed\"));\n      const id = newRequestId();\n      const message: ClientMessage =\n        request.intents && request.intents.length > 0\n          ? { type: \"intent\", id, intents: request.intents as never }\n          : { type: \"patches\", id, patches: request.patches };\n\n      return new Promise<ApplyResult>((resolve) => {\n        const cancelTimeout = schedule(() => {\n          if (pending.delete(id)) resolve(failure(\"timeout\", \"The authority did not answer\"));\n        }, timeoutMs);\n        pending.set(id, { record: request.record, coalesce: request.coalesce, settle: resolve, cancelTimeout });\n        if (!send(message)) settle(id, failure(\"transport-error\", \"The message could not be sent\"));\n      });\n    },\n    onEffect(listener) {\n      effectListeners.add(listener);\n      return () => effectListeners.delete(listener);\n    },\n    disconnect() {\n      if (disconnected) return;\n      disconnected = true;\n      stop();\n      syncDone();\n      for (const id of [...pending.keys()]) settle(id, failure(\"disconnected\", \"The connection to the authority is closed\"));\n      effectListeners.clear();\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/remote/index.d.ts

@@ -0,0 +1,4 @@
+export * from './committer';
+export * from './join';
+export * from './memory-transport';
+//# sourceMappingURL=index.d.ts.map

package/dist/remote/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/remote/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,oBAAoB,CAAC"}

package/dist/remote/index.js

@@ -0,0 +1,4 @@
+import { remoteCommitter } from "./committer.js";
+import { bindRemoteEffects, joinRemoteMap } from "./join.js";
+import { connectInMemory } from "./memory-transport.js";
+export { bindRemoteEffects, connectInMemory, joinRemoteMap, remoteCommitter };

package/dist/remote/join.d.ts

@@ -0,0 +1,30 @@
+import { MapModel, MapModelOptions } from '../model/model';
+import { ApplyResult } from '../model/result';
+import { MapTransport } from '../protocol';
+import { RemoteCommitter, RemoteCommitterOptions, RemoteEffect } from './committer';
+export interface JoinRemoteMapOptions extends Omit<RemoteCommitterOptions, "transport"> {
+    readonly transport: MapTransport;
+    /** Options of the model, other than the committer and the revision, which come from the authority. */
+    readonly model?: Omit<MapModelOptions, "committer" | "revision">;
+}
+export interface RemoteMap {
+    /** The map as the authority has it. Changes go through the authority: `apply` answers when it has decided. */
+    readonly model: MapModel<Promise<ApplyResult>>;
+    readonly committer: RemoteCommitter;
+    /** Stops listening to the authority. */
+    disconnect(): void;
+}
+/**
+ * Joins the map of an authority: asks for it, waits for it, and returns a model that
+ * stays in step with everybody else's changes.
+ */
+export declare function joinRemoteMap(options: JoinRemoteMapOptions): Promise<RemoteMap>;
+/** Anything that can play an effect on an element or an event: a view's `effects`. */
+export interface EffectPlayer {
+    play(target: RemoteEffect["target"], name: string, params?: Record<string, unknown>): unknown;
+}
+/** Shows the effects the authority plays: `bindRemoteEffects(remote, view.effects)`. Returns the function that stops. */
+export declare function bindRemoteEffects(remote: {
+    readonly committer: RemoteCommitter;
+}, effects: EffectPlayer): () => void;
+//# sourceMappingURL=join.d.ts.map

package/dist/remote/join.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../src/remote/join.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACrF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAmB,KAAK,eAAe,EAAE,KAAK,sBAAsB,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEpH,MAAM,WAAW,oBAAqB,SAAQ,IAAI,CAAC,sBAAsB,EAAE,WAAW,CAAC;IACrF,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,sGAAsG;IACtG,QAAQ,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,WAAW,GAAG,UAAU,CAAC,CAAC;CAClE;AAED,MAAM,WAAW,SAAS;IACxB,8GAA8G;IAC9G,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;IAC/C,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,wCAAwC;IACxC,UAAU,IAAI,IAAI,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,SAAS,CAAC,CAgBrF;AAED,sFAAsF;AACtF,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;CAC/F;AAED,yHAAyH;AACzH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAA;CAAE,EAAE,OAAO,EAAE,YAAY,GAAG,MAAM,IAAI,CAEpH"}

package/dist/remote/join.js

@@ -0,0 +1,36 @@
+import { createMapModel } from "../model/model.js";
+import { remoteCommitter } from "./committer.js";
+//#region src/remote/join.ts
+/**
+* Joins the map of an authority: asks for it, waits for it, and returns a model that
+* stays in step with everybody else's changes.
+*/
+async function joinRemoteMap(options) {
+	const committer = remoteCommitter(options);
+	const waiting = committer.nextSnapshot();
+	options.transport.send({ type: "sync" });
+	let first;
+	try {
+		first = await waiting;
+	} catch (error) {
+		committer.disconnect();
+		throw error;
+	}
+	return {
+		model: createMapModel(first.definition, {
+			...options.model,
+			committer,
+			revision: first.revision
+		}),
+		committer,
+		disconnect: () => committer.disconnect()
+	};
+}
+/** Shows the effects the authority plays: `bindRemoteEffects(remote, view.effects)`. Returns the function that stops. */
+function bindRemoteEffects(remote, effects) {
+	return remote.committer.onEffect((effect) => void effects.play(effect.target, effect.name, effect.params));
+}
+//#endregion
+export { bindRemoteEffects, joinRemoteMap };
+
+//# sourceMappingURL=join.js.map

package/dist/remote/join.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.js","names":[],"sources":["../../src/remote/join.ts"],"sourcesContent":["import { createMapModel, type MapModel, type MapModelOptions } from \"../model/model\";\nimport type { ApplyResult } from \"../model/result\";\nimport type { MapTransport } from \"../protocol\";\nimport { remoteCommitter, type RemoteCommitter, type RemoteCommitterOptions, type RemoteEffect } from \"./committer\";\n\nexport interface JoinRemoteMapOptions extends Omit<RemoteCommitterOptions, \"transport\"> {\n  readonly transport: MapTransport;\n  /** Options of the model, other than the committer and the revision, which come from the authority. */\n  readonly model?: Omit<MapModelOptions, \"committer\" | \"revision\">;\n}\n\nexport interface RemoteMap {\n  /** The map as the authority has it. Changes go through the authority: `apply` answers when it has decided. */\n  readonly model: MapModel<Promise<ApplyResult>>;\n  readonly committer: RemoteCommitter;\n  /** Stops listening to the authority. */\n  disconnect(): void;\n}\n\n/**\n * Joins the map of an authority: asks for it, waits for it, and returns a model that\n * stays in step with everybody else's changes.\n */\nexport async function joinRemoteMap(options: JoinRemoteMapOptions): Promise<RemoteMap> {\n  const committer = remoteCommitter(options);\n  // Ask after listening: the authority may also send the map on its own, on connection.\n  const waiting = committer.nextSnapshot();\n  options.transport.send({ type: \"sync\" });\n\n  let first;\n  try {\n    first = await waiting;\n  } catch (error) {\n    committer.disconnect();\n    throw error;\n  }\n\n  const model = createMapModel(first.definition, { ...options.model, committer, revision: first.revision });\n  return { model, committer, disconnect: () => committer.disconnect() };\n}\n\n/** Anything that can play an effect on an element or an event: a view's `effects`. */\nexport interface EffectPlayer {\n  play(target: RemoteEffect[\"target\"], name: string, params?: Record<string, unknown>): unknown;\n}\n\n/** Shows the effects the authority plays: `bindRemoteEffects(remote, view.effects)`. Returns the function that stops. */\nexport function bindRemoteEffects(remote: { readonly committer: RemoteCommitter }, effects: EffectPlayer): () => void {\n  return remote.committer.onEffect((effect) => void effects.play(effect.target, effect.name, effect.params as Record<string, unknown> | undefined));\n}\n"],"mappings":";;;;;;;AAuBA,eAAsB,cAAc,SAAmD;CACrF,MAAM,YAAY,gBAAgB,OAAO;CAEzC,MAAM,UAAU,UAAU,aAAa;CACvC,QAAQ,UAAU,KAAK,EAAE,MAAM,OAAO,CAAC;CAEvC,IAAI;CACJ,IAAI;EACF,QAAQ,MAAM;CAChB,SAAS,OAAO;EACd,UAAU,WAAW;EACrB,MAAM;CACR;CAGA,OAAO;EAAE,OADK,eAAe,MAAM,YAAY;GAAE,GAAG,QAAQ;GAAO;GAAW,UAAU,MAAM;EAAS,CAC9F;EAAO;EAAW,kBAAkB,UAAU,WAAW;CAAE;AACtE;;AAQA,SAAgB,kBAAkB,QAAiD,SAAmC;CACpH,OAAO,OAAO,UAAU,UAAU,WAAW,KAAK,QAAQ,KAAK,OAAO,QAAQ,OAAO,MAAM,OAAO,MAA6C,CAAC;AAClJ"}

package/dist/remote/memory-transport.d.ts

@@ -0,0 +1,20 @@
+import { AuthoritySession, MapAuthority } from '../authority/authority';
+import { MapTransport } from '../protocol';
+export interface MemoryConnectionOptions {
+    /** Who is acting for this connection. Handed to the pipelines. */
+    readonly actor?: unknown;
+    readonly id?: string;
+    /** `"microtask"` (default) delivers like a network would, after the current code; `"sync"` at once. */
+    readonly delivery?: "microtask" | "sync";
+}
+export interface MemoryConnection {
+    readonly transport: MapTransport;
+    readonly session: AuthoritySession;
+    disconnect(): void;
+}
+/**
+ * Connects a client to an authority in the same process, with no network: for tests, for
+ * a demo, for a single-player game that still wants the rules of the authority.
+ */
+export declare function connectInMemory(authority: MapAuthority, options?: MemoryConnectionOptions): MemoryConnection;
+//# sourceMappingURL=memory-transport.d.ts.map

package/dist/remote/memory-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-transport.d.ts","sourceRoot":"","sources":["../../src/remote/memory-transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC7E,OAAO,KAAK,EAAiB,YAAY,EAAiB,MAAM,aAAa,CAAC;AAE9E,MAAM,WAAW,uBAAuB;IACtC,kEAAkE;IAClE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,uGAAuG;IACvG,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC;CAC1C;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC,UAAU,IAAI,IAAI,CAAC;CACpB;AAID;;;GAGG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,GAAE,uBAA4B,GAAG,gBAAgB,CAwChH"}

package/dist/remote/memory-transport.js

@@ -0,0 +1,48 @@
+//#region src/remote/memory-transport.ts
+var sessionCounter = 0;
+/**
+* Connects a client to an authority in the same process, with no network: for tests, for
+* a demo, for a single-player game that still wants the rules of the authority.
+*/
+function connectInMemory(authority, options = {}) {
+	const listeners = /* @__PURE__ */ new Set();
+	const deliver = options.delivery ?? "microtask";
+	const later = (run) => deliver === "sync" ? run() : queueMicrotask(run);
+	let open = true;
+	const session = {
+		id: options.id ?? `memory-${sessionCounter += 1}`,
+		actor: options.actor,
+		send(message) {
+			const copy = JSON.parse(JSON.stringify(message));
+			later(() => {
+				if (open) for (const listener of [...listeners]) listener(copy);
+			});
+		}
+	};
+	const connection = authority.connect(session);
+	return {
+		session,
+		transport: {
+			send(message) {
+				if (!open) return;
+				const copy = JSON.parse(JSON.stringify(message));
+				later(() => {
+					if (open) connection.receive(copy);
+				});
+			},
+			onMessage(listener) {
+				listeners.add(listener);
+				return () => listeners.delete(listener);
+			}
+		},
+		disconnect() {
+			open = false;
+			connection.disconnect();
+			listeners.clear();
+		}
+	};
+}
+//#endregion
+export { connectInMemory };
+
+//# sourceMappingURL=memory-transport.js.map

package/dist/remote/memory-transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-transport.js","names":[],"sources":["../../src/remote/memory-transport.ts"],"sourcesContent":["import type { AuthoritySession, MapAuthority } from \"../authority/authority\";\nimport type { ClientMessage, MapTransport, ServerMessage } from \"../protocol\";\n\nexport interface MemoryConnectionOptions {\n  /** Who is acting for this connection. Handed to the pipelines. */\n  readonly actor?: unknown;\n  readonly id?: string;\n  /** `\"microtask\"` (default) delivers like a network would, after the current code; `\"sync\"` at once. */\n  readonly delivery?: \"microtask\" | \"sync\";\n}\n\nexport interface MemoryConnection {\n  readonly transport: MapTransport;\n  readonly session: AuthoritySession;\n  disconnect(): void;\n}\n\nlet sessionCounter = 0;\n\n/**\n * Connects a client to an authority in the same process, with no network: for tests, for\n * a demo, for a single-player game that still wants the rules of the authority.\n */\nexport function connectInMemory(authority: MapAuthority, options: MemoryConnectionOptions = {}): MemoryConnection {\n  const listeners = new Set<(message: ServerMessage) => void>();\n  const deliver = options.delivery ?? \"microtask\";\n  const later = (run: () => void): void => (deliver === \"sync\" ? run() : queueMicrotask(run));\n  let open = true;\n\n  const session: AuthoritySession = {\n    id: options.id ?? `memory-${(sessionCounter += 1)}`,\n    actor: options.actor,\n    send(message) {\n      // Through JSON, as a network would: nothing is shared between the two sides.\n      const copy = JSON.parse(JSON.stringify(message)) as ServerMessage;\n      later(() => {\n        if (open) for (const listener of [...listeners]) listener(copy);\n      });\n    },\n  };\n\n  const connection = authority.connect(session);\n  return {\n    session,\n    transport: {\n      send(message: ClientMessage) {\n        if (!open) return;\n        const copy = JSON.parse(JSON.stringify(message)) as unknown;\n        later(() => {\n          if (open) connection.receive(copy);\n        });\n      },\n      onMessage(listener) {\n        listeners.add(listener);\n        return () => listeners.delete(listener);\n      },\n    },\n    disconnect() {\n      open = false;\n      connection.disconnect();\n      listeners.clear();\n    },\n  };\n}\n"],"mappings":";AAiBA,IAAI,iBAAiB;;;;;AAMrB,SAAgB,gBAAgB,WAAyB,UAAmC,CAAC,GAAqB;CAChH,MAAM,4BAAY,IAAI,IAAsC;CAC5D,MAAM,UAAU,QAAQ,YAAY;CACpC,MAAM,SAAS,QAA2B,YAAY,SAAS,IAAI,IAAI,eAAe,GAAG;CACzF,IAAI,OAAO;CAEX,MAAM,UAA4B;EAChC,IAAI,QAAQ,MAAM,UAAW,kBAAkB;EAC/C,OAAO,QAAQ;EACf,KAAK,SAAS;GAEZ,MAAM,OAAO,KAAK,MAAM,KAAK,UAAU,OAAO,CAAC;GAC/C,YAAY;IACV,IAAI,MAAM,KAAK,MAAM,YAAY,CAAC,GAAG,SAAS,GAAG,SAAS,IAAI;GAChE,CAAC;EACH;CACF;CAEA,MAAM,aAAa,UAAU,QAAQ,OAAO;CAC5C,OAAO;EACL;EACA,WAAW;GACT,KAAK,SAAwB;IAC3B,IAAI,CAAC,MAAM;IACX,MAAM,OAAO,KAAK,MAAM,KAAK,UAAU,OAAO,CAAC;IAC/C,YAAY;KACV,IAAI,MAAM,WAAW,QAAQ,IAAI;IACnC,CAAC;GACH;GACA,UAAU,UAAU;IAClB,UAAU,IAAI,QAAQ;IACtB,aAAa,UAAU,OAAO,QAAQ;GACxC;EACF;EACA,aAAa;GACX,OAAO;GACP,WAAW,WAAW;GACtB,UAAU,MAAM;EAClB;CACF;AACF"}

package/dist/renderer/effects.d.ts

@@ -0,0 +1,52 @@
+/** What an effect writes for one frame. Effects combine: offsets add up, alphas multiply. */
+export interface EffectOutput {
+    offsetX: number;
+    offsetY: number;
+    alpha: number;
+}
+export type EffectParams = Readonly<Record<string, unknown>>;
+/**
+ * A short-lived visual change: an element shaking, blinking. It never goes
+ * through the model, so it is not persisted, undoable, nor replayed to late joiners.
+ */
+export interface EffectDefinition<P extends EffectParams = EffectParams> {
+    /** Default duration in milliseconds. A `duration` param overrides it. */
+    readonly duration: number;
+    /** `progress` goes from 0 to 1. */
+    update(progress: number, params: P, output: EffectOutput): void;
+}
+/** Left-right oscillation that fades out. Params: `intensity` (pixels), `frequency` (oscillations). */
+export declare const shakeEffect: EffectDefinition;
+/** Fades out and back in. Params: `strength` (0 to 1, how transparent it gets). */
+export declare const blinkEffect: EffectDefinition;
+export declare const builtInEffects: Readonly<Record<string, EffectDefinition>>;
+export type EffectStatus = "completed" | "cancelled"
+/** The element disappeared while the effect was running. */
+ | "target-removed" | "unknown-effect" | "target-missing";
+export interface EffectHandle {
+    readonly id: number;
+    /** Stops the effect and restores the target. No effect if it already ended. */
+    cancel(): void;
+    readonly finished: Promise<EffectStatus>;
+}
+export interface EffectRunnerOptions {
+    /** Whether a target still exists. */
+    exists(targetKey: string): boolean;
+    /** Receives the combined result for a target each frame, and `null` once its last effect ended. */
+    apply(targetKey: string, output: EffectOutput | null): void;
+    onWarning?(message: string): void;
+}
+export interface EffectRunner {
+    register(name: string, definition: EffectDefinition): void;
+    /** Starts an effect. It never throws: an unknown effect or target ends immediately with a status. */
+    play(targetKey: string, name: string, params?: EffectParams): EffectHandle;
+    /** Advances every running effect by `deltaMs`. Time only moves here, so effects are deterministic. */
+    tick(deltaMs: number): void;
+    /** Cancels every effect on a target, or on all targets. */
+    clear(targetKey?: string): void;
+    /** Called when a target is removed from the scene. */
+    targetRemoved(targetKey: string): void;
+    readonly running: number;
+}
+export declare function createEffectRunner(options: EffectRunnerOptions): EffectRunner;
+//# sourceMappingURL=effects.d.ts.map