@rpgjs/map-builder 0.0.0-stage → 5.0.0

package/dist/authority/authority.js

@@ -0,0 +1,289 @@
+import { createMapModel } from "../model/model.js";
+import { describeElement, describeEvent } from "../renderer/scene.js";
+import { createInteraction } from "../interaction/controller.js";
+import { registerElementIntents } from "../interaction/builtin-intents.js";
+import { registerPlacementIntent } from "../interaction/placement.js";
+import { parseClientMessage } from "../protocol/index.js";
+import { MapStoreCorruptError } from "./store.js";
+//#region src/authority/authority.ts
+var DEFAULT_LOG = 512;
+var DEFAULT_SNAPSHOT_EVERY = 50;
+var DEFAULT_SAVE_DELAY = 1e3;
+var sceneOf = (state, context) => [...state.elements.flatMap((element) => describeElement(element, context) ?? []), ...state.events.flatMap((event) => describeEvent(event, context) ?? [])];
+/**
+* The authority over one map: it holds the truth, decides what clients may do, tells
+* everybody what became true, catches late clients up and keeps the map between
+* restarts. It knows nothing of any framework: connect it to whatever carries messages.
+*/
+function createMapAuthority(options) {
+	const reportError = options.onError ?? ((error) => console.error(error));
+	const model = createMapModel(options.definition, {
+		...options.revision !== void 0 ? { revision: options.revision } : {},
+		...options.patchHandlers ? { patchHandlers: options.patchHandlers } : {},
+		history: false,
+		onListenerError: reportError
+	});
+	const describeContext = {
+		assets: options.assets,
+		...options.hooks ? { hooks: options.hooks } : {}
+	};
+	const sessions = /* @__PURE__ */ new Set();
+	let acting;
+	let destroyed = false;
+	const controller = createInteraction({
+		model,
+		assets: options.assets,
+		describe: describeContext,
+		nodes: () => sceneOf(model.state, describeContext),
+		actor: () => acting?.session.actor,
+		onError: reportError
+	});
+	registerElementIntents(controller);
+	if (options.pipeline?.move) controller.usePipeline("element.move", options.pipeline.move);
+	if (options.pipeline?.remove) controller.usePipeline("element.remove", options.pipeline.remove);
+	if (options.placement) registerPlacementIntent(controller, options.placement);
+	options.setup?.(controller);
+	for (const entry of options.replay ?? []) {
+		if (entry.revision !== model.revision + 1) throw new MapStoreCorruptError(`Expected revision ${model.revision + 1}, found ${entry.revision} while restoring the map`);
+		const result = model.apply(entry.patches);
+		if (!result.ok) throw new MapStoreCorruptError(`Revision ${entry.revision} cannot be replayed: ${result.rejection.message}`);
+	}
+	const logLimit = Math.max(0, options.log ?? DEFAULT_LOG);
+	const patchLog = [];
+	const send = (session, message) => {
+		try {
+			session.send(message);
+		} catch (error) {
+			reportError(error);
+		}
+	};
+	const broadcast = (message) => {
+		for (const session of [...sessions]) send(session, message);
+	};
+	const persist = options.persist;
+	const snapshotEvery = Math.max(1, persist?.snapshotEvery ?? DEFAULT_SNAPSHOT_EVERY);
+	const saveDelay = persist?.saveDelayMs ?? DEFAULT_SAVE_DELAY;
+	const schedule = persist?.schedule ?? ((run, delayMs) => {
+		const handle = setTimeout(run, delayMs);
+		return () => clearTimeout(handle);
+	});
+	let lastSnapshotRevision = model.revision - (options.replay?.length ?? 0);
+	let cancelScheduled;
+	let queue = Promise.resolve();
+	const enqueue = (work) => {
+		queue = queue.then(work).catch(reportError);
+	};
+	if (persist && !persist.baseSaved) {
+		const base = {
+			definition: model.getDefinition(),
+			revision: model.revision
+		};
+		enqueue(() => persist.store.save(persist.id, base));
+	}
+	const saveSnapshot = () => {
+		if (!persist) return;
+		cancelScheduled?.();
+		cancelScheduled = void 0;
+		const snapshot = {
+			definition: model.getDefinition(),
+			revision: model.revision
+		};
+		lastSnapshotRevision = snapshot.revision;
+		enqueue(() => persist.store.save(persist.id, snapshot));
+	};
+	const unsubscribe = model.subscribe((change) => {
+		if (change.reset) return;
+		const entry = {
+			revision: change.revision,
+			patches: change.patches
+		};
+		if (logLimit > 0) {
+			patchLog.push(entry);
+			if (patchLog.length > logLimit) patchLog.splice(0, patchLog.length - logLimit);
+		}
+		const author = acting ? options.author?.(acting.session.actor) : void 0;
+		const base = {
+			type: "patches",
+			revision: change.revision,
+			patches: change.patches,
+			...author !== void 0 ? { author } : {}
+		};
+		for (const session of [...sessions]) send(session, acting && acting.requestId !== void 0 && acting.session === session ? {
+			...base,
+			requestId: acting.requestId
+		} : base);
+		if (persist) {
+			if (persist.store.append) enqueue(() => persist.store.append(persist.id, entry));
+			if (change.revision - lastSnapshotRevision >= snapshotEvery) saveSnapshot();
+			else {
+				cancelScheduled?.();
+				cancelScheduled = schedule(saveSnapshot, saveDelay);
+			}
+		}
+		try {
+			options.onChange?.(change);
+		} catch (error) {
+			reportError(error);
+		}
+	});
+	const snapshotMessage = () => ({
+		type: "snapshot",
+		revision: model.revision,
+		definition: model.getDefinition()
+	});
+	const catchUp = (session, since) => {
+		if (since === model.revision) return send(session, {
+			type: "synced",
+			revision: model.revision
+		});
+		const oldest = patchLog[0]?.revision;
+		if (!(since !== void 0 && since < model.revision && oldest !== void 0 && since + 1 >= oldest)) return send(session, snapshotMessage());
+		for (const entry of patchLog) if (entry.revision > since) send(session, {
+			type: "patches",
+			revision: entry.revision,
+			patches: entry.patches
+		});
+		send(session, {
+			type: "synced",
+			revision: model.revision
+		});
+	};
+	const reject = (session, id, failure) => send(session, {
+		type: "rejected",
+		id,
+		reason: failure.rejection.code,
+		message: failure.rejection.message,
+		...failure.rejection.patchIndex !== void 0 ? { patchIndex: failure.rejection.patchIndex } : {}
+	});
+	const handle = (session, raw) => {
+		if (destroyed || !sessions.has(session)) return;
+		const message = parseClientMessage(raw);
+		if (!message) return;
+		switch (message.type) {
+			case "sync": return catchUp(session, message.since);
+			case "intent":
+				acting = {
+					session,
+					requestId: message.id
+				};
+				try {
+					const result = controller.submit(message.intents);
+					if (!result.ok) reject(session, message.id, result);
+				} finally {
+					acting = void 0;
+				}
+				return;
+			case "patches":
+				if (!options.trustPatches?.(session.actor)) return reject(session, message.id, {
+					ok: false,
+					rejection: {
+						code: "patches-not-allowed",
+						message: "Only intents are accepted from this client"
+					}
+				});
+				acting = {
+					session,
+					requestId: message.id
+				};
+				try {
+					const result = model.apply(message.patches);
+					if (!result.ok) reject(session, message.id, result);
+				} finally {
+					acting = void 0;
+				}
+		}
+	};
+	return {
+		model,
+		get revision() {
+			return model.revision;
+		},
+		interaction: controller,
+		get connections() {
+			return sessions.size;
+		},
+		connect(session) {
+			sessions.add(session);
+			send(session, snapshotMessage());
+			return {
+				session,
+				receive: (raw) => handle(session, raw),
+				disconnect: () => void sessions.delete(session)
+			};
+		},
+		apply: (patches) => model.apply(patches),
+		submit(intents, actor) {
+			const before = acting;
+			acting = {
+				session: {
+					id: "server",
+					actor,
+					send: () => void 0
+				},
+				requestId: void 0
+			};
+			try {
+				return controller.submit(intents);
+			} finally {
+				acting = before;
+			}
+		},
+		effect(target, name, params) {
+			broadcast({
+				type: "effect",
+				target,
+				name,
+				...params ? { params } : {}
+			});
+		},
+		snapshot: snapshotMessage,
+		async flush() {
+			if (persist && model.revision > lastSnapshotRevision) saveSnapshot();
+			await queue;
+		},
+		async destroy() {
+			if (destroyed) return;
+			await this.flush();
+			destroyed = true;
+			unsubscribe();
+			cancelScheduled?.();
+			controller.destroy();
+			sessions.clear();
+		}
+	};
+}
+/**
+* Brings a map back from a store, or starts it from `definition` when the store has
+* nothing yet. Changes written after the last snapshot are replayed.
+*/
+async function restoreMapAuthority(options) {
+	const { store, id } = options.persist;
+	const stored = await store.load(id);
+	if (!stored) {
+		await store.save(id, {
+			definition: options.definition,
+			revision: options.revision ?? 0
+		});
+		return createMapAuthority({
+			...options,
+			persist: {
+				...options.persist,
+				baseSaved: true
+			}
+		});
+	}
+	return createMapAuthority({
+		...options,
+		persist: {
+			...options.persist,
+			baseSaved: true
+		},
+		definition: stored.snapshot.definition,
+		revision: stored.snapshot.revision,
+		replay: stored.patches
+	});
+}
+//#endregion
+export { createMapAuthority, restoreMapAuthority };
+
+//# sourceMappingURL=authority.js.map

package/dist/authority/authority.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authority.js","names":[],"sources":["../../src/authority/authority.ts"],"sourcesContent":["import type { AssetResolver } from \"../model/assets\";\nimport type { MapDefinition } from \"../model/definition\";\nimport { createMapModel, type MapChange, type MapModel } from \"../model/model\";\nimport type { PatchHandlers } from \"../model/patches\";\nimport type { MapPatch } from \"../model/patches\";\nimport type { ApplyFailure, ApplyResult } from \"../model/result\";\nimport type { Catalog } from \"../interaction/catalog\";\nimport { registerElementIntents } from \"../interaction/builtin-intents\";\nimport { createInteraction, type InteractionController } from \"../interaction/controller\";\nimport type { MapIntent } from \"../interaction/intents\";\nimport type { PipelineStep } from \"../interaction/pipeline\";\nimport { registerPlacementIntent, type PlacementIntentOptions } from \"../interaction/placement\";\nimport {\n  parseClientMessage,\n  type EffectTargetMessage,\n  type ServerMessage,\n} from \"../protocol\";\nimport { describeElement, describeEvent, type DescribeContext, type MapViewHooks, type SceneNode } from \"../renderer/scene\";\nimport { MapStoreCorruptError, type MapStore, type PatchEntry } from \"./store\";\n\n/** A client connected to the authority. The authority does not care how: `send` is all it needs. */\nexport interface AuthoritySession {\n  readonly id: string;\n  /** Who is acting: whatever the game decides, handed to the steps of the pipelines. */\n  readonly actor: unknown;\n  send(message: ServerMessage): void;\n}\n\nexport interface AuthorityConnection {\n  readonly session: AuthoritySession;\n  /** Gives the authority what the client sent. Anything that is not a valid message is ignored. */\n  receive(raw: unknown): void;\n  disconnect(): void;\n}\n\nexport interface PersistOptions {\n  readonly store: MapStore;\n  /** Key of the map in the store. */\n  readonly id: string;\n  /** Write a snapshot every this many revisions. Defaults to 50. */\n  readonly snapshotEvery?: number;\n  /** Write a snapshot this long after the last change. Defaults to 1000. */\n  readonly saveDelayMs?: number;\n  /** Replaces `setTimeout`, so tests control time. Returns the function that cancels it. */\n  readonly schedule?: (run: () => void, delayMs: number) => () => void;\n  /**\n   * The store already holds a snapshot of the state the authority starts from, so it does\n   * not write one first. `restoreMapAuthority` sets it. Otherwise the authority writes the\n   * starting snapshot itself, so that the changes it appends have something to follow.\n   */\n  readonly baseSaved?: boolean;\n}\n\nexport interface MapAuthorityOptions<C extends Catalog<string> = Catalog<string>> {\n  readonly definition: MapDefinition;\n  /** Revision the map starts at. Defaults to 0. */\n  readonly revision?: number;\n  /**\n   * What the map is made of. Sizes and hitboxes come from here, so assets must declare\n   * a `size` or a `frame`: a server has no image to measure.\n   */\n  readonly assets: AssetResolver;\n  readonly hooks?: MapViewHooks;\n  /** Rules for every move and removal, whoever asks. The same steps the clients use to preview. */\n  readonly pipeline?: {\n    readonly move?: readonly PipelineStep<\"element.move\">[];\n    readonly remove?: readonly PipelineStep<\"element.remove\">[];\n  };\n  /** What can be placed, and the rules for it. */\n  readonly placement?: PlacementIntentOptions<C>;\n  /** Handlers of the patch types features add (`terrainPatchHandlers`): the authority must know them to apply them. */\n  readonly patchHandlers?: readonly PatchHandlers[];\n  /** Registers more intents and pipelines, e.g. those of a custom feature. */\n  readonly setup?: (controller: InteractionController) => void;\n  /**\n   * Whether this actor may send patches as they are (an editor, an undo). Never by default:\n   * a client asks with intents, and the authority decides.\n   */\n  readonly trustPatches?: (actor: unknown) => boolean;\n  /** Who made a change, in the words other players see. */\n  readonly author?: (actor: unknown) => string | undefined;\n  /** Changes kept to catch late clients up without sending the whole map. Defaults to 512. */\n  readonly log?: number;\n  readonly persist?: PersistOptions;\n  /** Called after every change, whoever made it: the place to keep a physics world in step. */\n  readonly onChange?: (change: MapChange) => void;\n  readonly onError?: (error: unknown) => void;\n  /** Changes to replay on top of `definition`, in order: what a store gives back after a restart. */\n  readonly replay?: readonly PatchEntry[];\n}\n\nexport interface MapAuthority {\n  /** The truth. Never change it directly: use `apply`, so everybody hears about it. */\n  readonly model: MapModel<ApplyResult>;\n  readonly revision: number;\n  readonly interaction: InteractionController;\n  /** How many clients are connected. */\n  readonly connections: number;\n  connect(session: AuthoritySession): AuthorityConnection;\n  /**\n   * A change the game itself makes (a lever, a quest). It is trusted: no pipeline. Everybody\n   * connected hears about it.\n   */\n  apply(patches: MapPatch | readonly MapPatch[]): ApplyResult;\n  /** Runs intents through the pipelines on behalf of an actor, e.g. a non-player character. */\n  submit(intents: MapIntent | readonly MapIntent[], actor?: unknown): ApplyResult | ApplyFailure;\n  /** Shows a short effect to everybody connected. It is not kept. */\n  effect(target: EffectTargetMessage, name: string, params?: Readonly<Record<string, unknown>>): void;\n  /** The map as it is now, as a message. */\n  snapshot(): ServerMessage;\n  /** Writes what is pending to the store. */\n  flush(): Promise<void>;\n  /** Flushes, then stops. */\n  destroy(): Promise<void>;\n}\n\nconst DEFAULT_LOG = 512;\nconst DEFAULT_SNAPSHOT_EVERY = 50;\nconst DEFAULT_SAVE_DELAY = 1000;\n\nconst sceneOf = (state: MapDefinition, context: DescribeContext): SceneNode[] => [\n  ...state.elements.flatMap((element) => describeElement(element, context) ?? []),\n  ...state.events.flatMap((event) => describeEvent(event, context) ?? []),\n];\n\n/**\n * The authority over one map: it holds the truth, decides what clients may do, tells\n * everybody what became true, catches late clients up and keeps the map between\n * restarts. It knows nothing of any framework: connect it to whatever carries messages.\n */\nexport function createMapAuthority<C extends Catalog<string> = Catalog<string>>(options: MapAuthorityOptions<C>): MapAuthority {\n  const reportError = options.onError ?? ((error: unknown) => console.error(error));\n  const model = createMapModel(options.definition, {\n    ...(options.revision !== undefined ? { revision: options.revision } : {}),\n    ...(options.patchHandlers ? { patchHandlers: options.patchHandlers } : {}),\n    // The authority has nothing to undo: clients keep their own history.\n    history: false,\n    onListenerError: reportError,\n  });\n\n  const describeContext: DescribeContext = { assets: options.assets, ...(options.hooks ? { hooks: options.hooks } : {}) };\n  const sessions = new Set<AuthoritySession>();\n  let acting: { session: AuthoritySession; requestId: string | undefined } | undefined;\n  let destroyed = false;\n\n  const controller = createInteraction({\n    model,\n    assets: options.assets,\n    describe: describeContext,\n    nodes: () => sceneOf(model.state, describeContext),\n    actor: () => acting?.session.actor,\n    onError: reportError,\n  });\n  registerElementIntents(controller);\n  if (options.pipeline?.move) controller.usePipeline(\"element.move\", options.pipeline.move);\n  if (options.pipeline?.remove) controller.usePipeline(\"element.remove\", options.pipeline.remove);\n  if (options.placement) registerPlacementIntent(controller, options.placement);\n  options.setup?.(controller);\n\n  // Changes made before anybody listens: what a restart replays.\n  for (const entry of options.replay ?? []) {\n    if (entry.revision !== model.revision + 1) {\n      throw new MapStoreCorruptError(`Expected revision ${model.revision + 1}, found ${entry.revision} while restoring the map`);\n    }\n    const result = model.apply(entry.patches);\n    if (!result.ok) throw new MapStoreCorruptError(`Revision ${entry.revision} cannot be replayed: ${result.rejection.message}`);\n  }\n\n  const logLimit = Math.max(0, options.log ?? DEFAULT_LOG);\n  const patchLog: PatchEntry[] = [];\n\n  const send = (session: AuthoritySession, message: ServerMessage): void => {\n    try {\n      session.send(message);\n    } catch (error) {\n      reportError(error);\n    }\n  };\n  const broadcast = (message: ServerMessage): void => {\n    for (const session of [...sessions]) send(session, message);\n  };\n\n  // --- persistence\n  const persist = options.persist;\n  const snapshotEvery = Math.max(1, persist?.snapshotEvery ?? DEFAULT_SNAPSHOT_EVERY);\n  const saveDelay = persist?.saveDelayMs ?? DEFAULT_SAVE_DELAY;\n  const schedule =\n    persist?.schedule ??\n    ((run: () => void, delayMs: number) => {\n      const handle = setTimeout(run, delayMs);\n      return () => clearTimeout(handle);\n    });\n  let lastSnapshotRevision = model.revision - (options.replay?.length ?? 0);\n  let cancelScheduled: (() => void) | undefined;\n  let queue: Promise<void> = Promise.resolve();\n\n  const enqueue = (work: () => Promise<void>): void => {\n    queue = queue.then(work).catch(reportError);\n  };\n  if (persist && !persist.baseSaved) {\n    const base = { definition: model.getDefinition(), revision: model.revision };\n    enqueue(() => persist.store.save(persist.id, base));\n  }\n  const saveSnapshot = (): void => {\n    if (!persist) return;\n    cancelScheduled?.();\n    cancelScheduled = undefined;\n    const snapshot = { definition: model.getDefinition(), revision: model.revision };\n    lastSnapshotRevision = snapshot.revision;\n    enqueue(() => persist.store.save(persist.id, snapshot));\n  };\n\n  // --- what everybody must hear about\n  const unsubscribe = model.subscribe((change) => {\n    if (change.reset) return;\n    const entry: PatchEntry = { revision: change.revision, patches: change.patches };\n    if (logLimit > 0) {\n      patchLog.push(entry);\n      if (patchLog.length > logLimit) patchLog.splice(0, patchLog.length - logLimit);\n    }\n\n    const author = acting ? options.author?.(acting.session.actor) : undefined;\n    const base = {\n      type: \"patches\" as const,\n      revision: change.revision,\n      patches: change.patches,\n      ...(author !== undefined ? { author } : {}),\n    };\n    // The request id goes only to whoever asked: it is how they recognise their own change.\n    for (const session of [...sessions]) {\n      send(session, acting && acting.requestId !== undefined && acting.session === session ? { ...base, requestId: acting.requestId } : base);\n    }\n\n    if (persist) {\n      if (persist.store.append) enqueue(() => persist.store.append!(persist.id, entry));\n      if (change.revision - lastSnapshotRevision >= snapshotEvery) saveSnapshot();\n      else {\n        cancelScheduled?.();\n        cancelScheduled = schedule(saveSnapshot, saveDelay);\n      }\n    }\n    try {\n      options.onChange?.(change);\n    } catch (error) {\n      reportError(error);\n    }\n  });\n\n  const snapshotMessage = (): ServerMessage => ({ type: \"snapshot\", revision: model.revision, definition: model.getDefinition() });\n\n  const catchUp = (session: AuthoritySession, since: number | undefined): void => {\n    if (since === model.revision) return send(session, { type: \"synced\", revision: model.revision });\n    const oldest = patchLog[0]?.revision;\n    const canReplay = since !== undefined && since < model.revision && oldest !== undefined && since + 1 >= oldest;\n    if (!canReplay) return send(session, snapshotMessage());\n    for (const entry of patchLog) {\n      if (entry.revision > since) send(session, { type: \"patches\", revision: entry.revision, patches: entry.patches });\n    }\n    send(session, { type: \"synced\", revision: model.revision });\n  };\n\n  const reject = (session: AuthoritySession, id: string, failure: ApplyFailure): void =>\n    send(session, {\n      type: \"rejected\",\n      id,\n      reason: failure.rejection.code,\n      message: failure.rejection.message,\n      ...(failure.rejection.patchIndex !== undefined ? { patchIndex: failure.rejection.patchIndex } : {}),\n    });\n\n  const handle = (session: AuthoritySession, raw: unknown): void => {\n    if (destroyed || !sessions.has(session)) return;\n    const message = parseClientMessage(raw);\n    if (!message) return;\n\n    switch (message.type) {\n      case \"sync\":\n        return catchUp(session, message.since);\n      case \"intent\": {\n        acting = { session, requestId: message.id };\n        try {\n          const result = controller.submit(message.intents);\n          if (!result.ok) reject(session, message.id, result);\n        } finally {\n          acting = undefined;\n        }\n        return;\n      }\n      case \"patches\": {\n        if (!options.trustPatches?.(session.actor)) {\n          return reject(session, message.id, {\n            ok: false,\n            rejection: { code: \"patches-not-allowed\", message: \"Only intents are accepted from this client\" },\n          });\n        }\n        acting = { session, requestId: message.id };\n        try {\n          const result = model.apply(message.patches);\n          if (!result.ok) reject(session, message.id, result);\n        } finally {\n          acting = undefined;\n        }\n      }\n    }\n  };\n\n  return {\n    model,\n    get revision() {\n      return model.revision;\n    },\n    interaction: controller,\n    get connections() {\n      return sessions.size;\n    },\n    connect(session) {\n      sessions.add(session);\n      // The client gets the map at once, without having to ask.\n      send(session, snapshotMessage());\n      return {\n        session,\n        receive: (raw) => handle(session, raw),\n        disconnect: () => void sessions.delete(session),\n      };\n    },\n    apply: (patches) => model.apply(patches),\n    submit(intents, actor) {\n      const before = acting;\n      acting = { session: { id: \"server\", actor, send: () => undefined }, requestId: undefined };\n      try {\n        return controller.submit(intents);\n      } finally {\n        acting = before;\n      }\n    },\n    effect(target, name, params) {\n      broadcast({ type: \"effect\", target, name, ...(params ? { params } : {}) });\n    },\n    snapshot: snapshotMessage,\n    async flush() {\n      if (persist && model.revision > lastSnapshotRevision) saveSnapshot();\n      await queue;\n    },\n    async destroy() {\n      if (destroyed) return;\n      await this.flush();\n      destroyed = true;\n      unsubscribe();\n      cancelScheduled?.();\n      controller.destroy();\n      sessions.clear();\n    },\n  };\n}\n\n/**\n * Brings a map back from a store, or starts it from `definition` when the store has\n * nothing yet. Changes written after the last snapshot are replayed.\n */\nexport async function restoreMapAuthority<C extends Catalog<string> = Catalog<string>>(\n  options: MapAuthorityOptions<C> & { readonly persist: PersistOptions },\n): Promise<MapAuthority> {\n  const { store, id } = options.persist;\n  const stored = await store.load(id);\n  if (!stored) {\n    // A snapshot first, so that changes appended later have something to follow.\n    await store.save(id, { definition: options.definition, revision: options.revision ?? 0 });\n    return createMapAuthority({ ...options, persist: { ...options.persist, baseSaved: true } });\n  }\n  return createMapAuthority({\n    ...options,\n    persist: { ...options.persist, baseSaved: true },\n    definition: stored.snapshot.definition,\n    revision: stored.snapshot.revision,\n    replay: stored.patches,\n  });\n}\n"],"mappings":"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"}

package/dist/authority/index.d.ts

@@ -0,0 +1,3 @@
+export * from './store';
+export * from './authority';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/authority/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC"}

package/dist/authority/index.js

@@ -0,0 +1,3 @@
+import { MapStoreCorruptError, memoryMapStore } from "./store.js";
+import { createMapAuthority, restoreMapAuthority } from "./authority.js";
+export { MapStoreCorruptError, createMapAuthority, memoryMapStore, restoreMapAuthority };

package/dist/authority/store.d.ts

@@ -0,0 +1,36 @@
+import { MapDefinition } from '../model/definition';
+import { MapPatch } from '../model/patches';
+/** The whole map at a revision. */
+export interface MapStoreSnapshot {
+    readonly definition: MapDefinition;
+    readonly revision: number;
+}
+/** One change, as it was applied. */
+export interface PatchEntry {
+    readonly revision: number;
+    readonly patches: readonly MapPatch[];
+}
+export interface StoredMap {
+    readonly snapshot: MapStoreSnapshot;
+    /** Changes made after the snapshot, in order. */
+    readonly patches: readonly PatchEntry[];
+}
+/**
+ * Where an authority keeps a map between restarts. A snapshot is written from time to
+ * time; `append`, when the store offers it, records each change in between, so a restart
+ * loses nothing even if the last snapshot is old.
+ */
+export interface MapStore {
+    load(id: string): Promise<StoredMap | undefined>;
+    /** Replaces the snapshot. Changes up to its revision are no longer needed. */
+    save(id: string, snapshot: MapStoreSnapshot): Promise<void>;
+    append?(id: string, entry: PatchEntry): Promise<void>;
+}
+export declare class MapStoreCorruptError extends Error {
+    constructor(message: string);
+}
+/** Keeps maps in memory. For tests, and for games that do not need to survive a restart. */
+export declare function memoryMapStore(): MapStore & {
+    readonly maps: ReadonlyMap<string, StoredMap>;
+};
+//# sourceMappingURL=store.d.ts.map

package/dist/authority/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/authority/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,mCAAmC;AACnC,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,qCAAqC;AACrC,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,CAAC;CACvC;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC,iDAAiD;IACjD,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;CACzC;AAED;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;IACjD,8EAA8E;IAC9E,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,MAAM,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvD;AAED,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAI5B;AAED,4FAA4F;AAC5F,wBAAgB,cAAc,IAAI,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;CAAE,CAsB7F"}

package/dist/authority/store.js

@@ -0,0 +1,35 @@
+//#region src/authority/store.ts
+var MapStoreCorruptError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "MapStoreCorruptError";
+	}
+};
+/** Keeps maps in memory. For tests, and for games that do not need to survive a restart. */
+function memoryMapStore() {
+	const maps = /* @__PURE__ */ new Map();
+	const copy = (value) => JSON.parse(JSON.stringify(value));
+	return {
+		maps,
+		async load(id) {
+			const stored = maps.get(id);
+			return stored ? copy(stored) : void 0;
+		},
+		async save(id, snapshot) {
+			const previous = maps.get(id);
+			maps.set(id, {
+				snapshot: copy(snapshot),
+				patches: (previous?.patches ?? []).filter((entry) => entry.revision > snapshot.revision)
+			});
+		},
+		async append(id, entry) {
+			const stored = maps.get(id);
+			if (!stored) throw new Error(`Cannot append to "${id}": it has no snapshot yet`);
+			stored.patches.push(copy(entry));
+		}
+	};
+}
+//#endregion
+export { MapStoreCorruptError, memoryMapStore };
+
+//# sourceMappingURL=store.js.map

package/dist/authority/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":[],"sources":["../../src/authority/store.ts"],"sourcesContent":["import type { MapDefinition } from \"../model/definition\";\nimport type { MapPatch } from \"../model/patches\";\n\n/** The whole map at a revision. */\nexport interface MapStoreSnapshot {\n  readonly definition: MapDefinition;\n  readonly revision: number;\n}\n\n/** One change, as it was applied. */\nexport interface PatchEntry {\n  readonly revision: number;\n  readonly patches: readonly MapPatch[];\n}\n\nexport interface StoredMap {\n  readonly snapshot: MapStoreSnapshot;\n  /** Changes made after the snapshot, in order. */\n  readonly patches: readonly PatchEntry[];\n}\n\n/**\n * Where an authority keeps a map between restarts. A snapshot is written from time to\n * time; `append`, when the store offers it, records each change in between, so a restart\n * loses nothing even if the last snapshot is old.\n */\nexport interface MapStore {\n  load(id: string): Promise<StoredMap | undefined>;\n  /** Replaces the snapshot. Changes up to its revision are no longer needed. */\n  save(id: string, snapshot: MapStoreSnapshot): Promise<void>;\n  append?(id: string, entry: PatchEntry): Promise<void>;\n}\n\nexport class MapStoreCorruptError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"MapStoreCorruptError\";\n  }\n}\n\n/** Keeps maps in memory. For tests, and for games that do not need to survive a restart. */\nexport function memoryMapStore(): MapStore & { readonly maps: ReadonlyMap<string, StoredMap> } {\n  const maps = new Map<string, { snapshot: MapStoreSnapshot; patches: PatchEntry[] }>();\n  const copy = <T>(value: T): T => JSON.parse(JSON.stringify(value)) as T;\n  return {\n    maps,\n    async load(id) {\n      const stored = maps.get(id);\n      return stored ? copy(stored) : undefined;\n    },\n    async save(id, snapshot) {\n      const previous = maps.get(id);\n      maps.set(id, {\n        snapshot: copy(snapshot),\n        patches: (previous?.patches ?? []).filter((entry) => entry.revision > snapshot.revision),\n      });\n    },\n    async append(id, entry) {\n      const stored = maps.get(id);\n      if (!stored) throw new Error(`Cannot append to \"${id}\": it has no snapshot yet`);\n      stored.patches.push(copy(entry));\n    },\n  };\n}\n"],"mappings":";AAiCA,IAAa,uBAAb,cAA0C,MAAM;CAC9C,YAAY,SAAiB;EAC3B,MAAM,OAAO;EACb,KAAK,OAAO;CACd;AACF;;AAGA,SAAgB,iBAA+E;CAC7F,MAAM,uBAAO,IAAI,IAAmE;CACpF,MAAM,QAAW,UAAgB,KAAK,MAAM,KAAK,UAAU,KAAK,CAAC;CACjE,OAAO;EACL;EACA,MAAM,KAAK,IAAI;GACb,MAAM,SAAS,KAAK,IAAI,EAAE;GAC1B,OAAO,SAAS,KAAK,MAAM,IAAI,KAAA;EACjC;EACA,MAAM,KAAK,IAAI,UAAU;GACvB,MAAM,WAAW,KAAK,IAAI,EAAE;GAC5B,KAAK,IAAI,IAAI;IACX,UAAU,KAAK,QAAQ;IACvB,UAAU,UAAU,WAAW,CAAC,EAAA,CAAG,QAAQ,UAAU,MAAM,WAAW,SAAS,QAAQ;GACzF,CAAC;EACH;EACA,MAAM,OAAO,IAAI,OAAO;GACtB,MAAM,SAAS,KAAK,IAAI,EAAE;GAC1B,IAAI,CAAC,QAAQ,MAAM,IAAI,MAAM,qBAAqB,GAAG,0BAA0B;GAC/E,OAAO,QAAQ,KAAK,KAAK,KAAK,CAAC;EACjC;CACF;AACF"}

package/dist/client/index.d.ts

@@ -0,0 +1,72 @@
+import { RpgProvider } from '@rpgjs/common';
+import { RpgClient } from '@rpgjs/client';
+import { Container } from 'pixi.js';
+import { AssetResolver } from '../model/assets';
+import { PatchHandlers } from '../model/patches';
+import { ApplyResult, Unsubscribe } from '../model/result';
+import { RemoteMap } from '../remote';
+import { FeatureApis, MapFeature } from '../renderer/feature';
+import { MapView, MapViewOptions } from '../renderer/view';
+import { elements } from '../features';
+export { MAP_BUILDER_CHANNEL } from '../rpgjs/shared';
+type Features = readonly MapFeature<string, object>[];
+export interface MapBuilderClientOptions<F extends Features = Features> {
+    /** What the maps are made of: the same assets the server has. */
+    readonly assets: AssetResolver;
+    /**
+     * What the view draws and lets the player do. Defaults to `[elements()]`: events are RPGJS
+     * events, drawn by RPGJS, so `events()` would draw them twice.
+     */
+    readonly features?: F;
+    /** Options of the view: textures, hooks, modes, actor, culling… */
+    readonly view?: Omit<MapViewOptions<F, Promise<ApplyResult>>, "model" | "assets" | "features">;
+    /** Keep the static colliders of the client's physics in step, so the player does not walk through what was built. Defaults to true. */
+    readonly physics?: boolean;
+    /** Handlers of the patch types the features add (`terrainPatchHandlers`): the model must know them to apply what the server tells. */
+    readonly patchHandlers?: readonly PatchHandlers[];
+    /** How long to wait for the server before giving up. Defaults to 10000. */
+    readonly timeoutMs?: number;
+    /** The player is on a modifiable map: the place to wire controls (`handle.view.placement.start("oak")`). */
+    readonly onJoin?: (handle: MapBuilderHandle<F>) => void;
+    readonly onLeave?: (handle: MapBuilderHandle<F>) => void;
+    readonly onError?: (error: unknown) => void;
+}
+export interface MapBuilderHandle<F extends Features = Features> {
+    readonly mapId: string;
+    readonly remote: RemoteMap;
+    readonly view: MapView<Promise<ApplyResult>> & FeatureApis<F>;
+    /** Adds the view to a PixiJS container, e.g. the `componentInstance` of a CanvasEngine component. */
+    attachTo(container: Container): () => void;
+    /** Leaves the map: stops listening, removes the colliders, destroys the view. */
+    dispose(): void;
+}
+export interface MapBuilderClient<F extends Features = Features> {
+    /** The map the player is on, once joined. */
+    current(): MapBuilderHandle<F> | undefined;
+    /** Resolves once the player has joined a modifiable map. */
+    whenReady(): Promise<MapBuilderHandle<F>>;
+    /**
+     * The view as PixiJS children, for the `pixiChildren` prop of RPGJS's `EventLayerComponent`: that
+     * puts the elements in the same layer as the characters, so they are sorted in depth together.
+     * Empty when the player is not on a modifiable map.
+     */
+    readonly pixiChildren: {
+        (): Container[];
+        set(value: Container[]): void;
+    };
+    /** Called when the player joins or leaves a modifiable map. */
+    onChange(listener: (handle: MapBuilderHandle<F> | undefined) => void): Unsubscribe;
+}
+/** What the map builder gives a game on the client. Pass the type of your features to get `view.placement` and the like typed. */
+export declare function getMapBuilder<F extends Features = Features>(engine?: object): MapBuilderClient<F>;
+/** The module of the map builder for an RPGJS client. Install it with `provideMapBuilder`, or `provideClientModules`. */
+export declare function createMapBuilderClient<const F extends Features = readonly [ReturnType<typeof elements>]>(options: MapBuilderClientOptions<F>): RpgClient;
+/**
+ * Installs the map builder on an RPGJS client:
+ *
+ * ```ts
+ * startGame({ providers: [provideMapBuilder({ assets, features: [elements(), selection(), placement({ catalog })] })] })
+ * ```
+ */
+export declare function provideMapBuilder<const F extends Features = readonly [ReturnType<typeof elements>]>(options: MapBuilderClientOptions<F>): RpgProvider[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"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"}