@codexo/exojs-tilemap 0.15.3 → 0.16.0

package/dist/esm/MapObjectSpawner.d.ts

@@ -0,0 +1,133 @@
+import type { Destroyable, SceneNode } from '@codexo/exojs';
+import type { MapObjectDescriptor } from './MapObject';
+import { MapSpawnSession } from './MapSpawnSession';
+import type { TileMap } from './TileMap';
+/** Why a {@link MapSpawnError} was raised. */
+export type MapSpawnErrorReason = 
+/** No factory is registered for the object's dispatch key and `unknown` is `'error'`. */
+'unknown-kind'
+/** Two objects of the same map resolved to the same stable id. */
+ | 'duplicate-id'
+/** A factory threw or rejected. The original error is the `cause`. */
+ | 'factory-failed';
+/**
+ * A spawn failed. The whole spawn is rolled back before this is thrown - no
+ * partial session exists.
+ *
+ * For `'factory-failed'` the error a factory raised is preserved as `cause`.
+ */
+export declare class MapSpawnError extends Error {
+    readonly name = "MapSpawnError";
+    readonly reason: MapSpawnErrorReason;
+    /** {@link MapObjectDescriptor.id} of the object that failed. */
+    readonly objectId: string;
+    /** {@link MapObjectDescriptor.kind} of the object that failed. */
+    readonly kind: string | null;
+    constructor(reason: MapSpawnErrorReason, objectId: string, kind: string | null, message: string, options?: ErrorOptions);
+}
+/**
+ * Creates one runtime object from one map object, or `null` to deliberately
+ * create nothing for it.
+ *
+ * `signal` aborts with the spawn it belongs to; a factory that loads assets or
+ * awaits anything else should pass it on, so a level unloaded mid-load stops
+ * its own work too.
+ */
+export type MapObjectFactory<Context, Result extends Destroyable> = (object: MapObjectDescriptor, context: Context, signal: AbortSignal) => Result | null | Promise<Result | null>;
+/** Dispatch key to factory. Keys are matched against the spawner's `identify` result. */
+export type MapObjectFactories<Context, Result extends Destroyable> = Readonly<Record<string, MapObjectFactory<Context, Result>>>;
+/** What to do with an object no factory is registered for. */
+export type UnknownMapObjectPolicy = 'ignore' | 'error';
+/** Options for {@link MapObjectSpawner}. */
+export interface MapObjectSpawnerOptions<Context> {
+    /**
+     * Picks the factory key for an object, or returns `null` to treat it as
+     * unknown. Defaults to {@link MapObjectDescriptor.kind}.
+     *
+     * This is where project-specific dispatch policy lives - keying on a
+     * property, a name prefix, or a compound key:
+     *
+     * ```ts
+     * identify: object => `${object.kind}:${object.properties.variant}`
+     * ```
+     */
+    readonly identify?: (object: MapObjectDescriptor, context: Context) => string | null;
+    /**
+     * What to do with an object no factory matched. Defaults to `'ignore'`,
+     * because maps legitimately carry editor markers, decoration and metadata
+     * objects that no game entity corresponds to. Use `'error'` for a map format
+     * the project fully controls and wants validated.
+     */
+    readonly unknown?: UnknownMapObjectPolicy;
+}
+/** Options for {@link MapObjectSpawner.spawn}. */
+export interface MapSpawnOptions {
+    /**
+     * Cancels the spawn. An in-flight factory is still awaited - abandoning it
+     * would leak whatever it eventually produced - but its result is destroyed
+     * along with the rest of the rollback.
+     */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Turns the objects authored in a map into game objects.
+ *
+ * A spawner owns its own dispatch table, so several games, tests, editor
+ * previews or mods can run in one process without seeing each other's
+ * factories. There is no global registry to register into and nothing to reset
+ * between tests.
+ *
+ * ExoJS owns the mechanism: identity, ordering, cancellation, rollback and
+ * lifetime. The game owns the policy: which object becomes what, and what those
+ * objects need - dependencies travel through `Context`, not through any
+ * service locator in the engine.
+ *
+ * A spawn is **atomic**: if any factory fails, everything already created is
+ * destroyed in reverse order and no session is produced.
+ *
+ * @typeParam Context - the per-spawn value handed to every factory.
+ * @typeParam Result - what the factories produce. Defaults to `SceneNode`.
+ *
+ * @example
+ * ```ts
+ * interface GameContext {
+ *   services: GameServices;
+ *   save: SaveGame;
+ * }
+ *
+ * const spawner = new MapObjectSpawner<GameContext>({
+ *   Enemy: (object, ctx) => new Enemy({ x: object.x, y: object.y, services: ctx.services }),
+ *   Chest: (object, ctx) => new Chest({ id: object.id, save: ctx.save }),
+ * });
+ *
+ * const session = await spawner.spawn(map, { services, save });
+ * session.get('chest-in-the-cellar')?.open();
+ * session.destroy();
+ * ```
+ */
+export declare class MapObjectSpawner<Context = void, Result extends Destroyable = SceneNode> {
+    /** What to do with an object no factory matched. */
+    readonly unknown: UnknownMapObjectPolicy;
+    private readonly _factories;
+    private readonly _identify;
+    constructor(factories: MapObjectFactories<Context, Result>, options?: MapObjectSpawnerOptions<Context>);
+    /** Whether a factory is registered under `key`. */
+    handles(key: string): boolean;
+    /**
+     * Create a game object for every object of `map` a factory matches, and
+     * return the {@link MapSpawnSession} that owns them.
+     *
+     * Objects are visited in object-layer order, then object order within each
+     * layer, and asynchronous factories are awaited in that same order - a
+     * factory that resolves early can never overtake one before it.
+     *
+     * @throws {MapSpawnError} when a factory fails, two objects share a stable id,
+     * or an unmatched object is found while `unknown` is `'error'`. In every case
+     * the objects already created are destroyed first. A factory that fails while
+     * the spawn is also being aborted reports the factory failure, not the abort -
+     * the more specific of the two.
+     * @throws {DOMException} named `AbortError` when `options.signal` aborts.
+     */
+    spawn(map: TileMap, context: Context, options?: MapSpawnOptions): Promise<MapSpawnSession<Result>>;
+}
+//# sourceMappingURL=MapObjectSpawner.d.ts.map

package/dist/esm/MapObjectSpawner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapObjectSpawner.d.ts","sourceRoot":"","sources":["../../src/MapObjectSpawner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,8CAA8C;AAC9C,MAAM,MAAM,mBAAmB;AAC7B,yFAAyF;AACvF,cAAc;AAChB,kEAAkE;GAChE,cAAc;AAChB,sEAAsE;GACpE,gBAAgB,CAAC;AAErB;;;;;GAKG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,SAAyB,IAAI,mBAAmB;IAChD,SAAgB,MAAM,EAAE,mBAAmB,CAAC;IAC5C,gEAAgE;IAChE,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,kEAAkE;IAClE,SAAgB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;gBAEjB,MAAM,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAM/H;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,CAAC,OAAO,EAAE,MAAM,SAAS,WAAW,IAAI,CAClE,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,WAAW,KAChB,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;AAE5C,yFAAyF;AACzF,MAAM,MAAM,kBAAkB,CAAC,OAAO,EAAE,MAAM,SAAS,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;AAElI,8DAA8D;AAC9D,MAAM,MAAM,sBAAsB,GAAG,QAAQ,GAAG,OAAO,CAAC;AAExD,4CAA4C;AAC5C,MAAM,WAAW,uBAAuB,CAAC,OAAO;IAC9C;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,OAAO,KAAK,MAAM,GAAG,IAAI,CAAC;IACrF;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,sBAAsB,CAAC;CAC3C;AAED,kDAAkD;AAClD,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAAa,gBAAgB,CAAC,OAAO,GAAG,IAAI,EAAE,MAAM,SAAS,WAAW,GAAG,SAAS;IAClF,oDAAoD;IACpD,SAAgB,OAAO,EAAE,sBAAsB,CAAC;IAEhD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsC;IACjE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmE;gBAE1E,SAAS,EAAE,kBAAkB,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,uBAAuB,CAAC,OAAO,CAAC;IAM7G,mDAAmD;IAC5C,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIpC;;;;;;;;;;;;;;OAcG;IACU,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;CAwEhH"}

package/dist/esm/MapObjectSpawner.js

@@ -0,0 +1,147 @@
+import { mapObjectDescriptors } from "./MapObject.js";
+import { MapSpawnSession } from "./MapSpawnSession.js";
+import { logger } from "@codexo/exojs";
+
+//#region src/MapObjectSpawner.ts
+/**
+* A spawn failed. The whole spawn is rolled back before this is thrown - no
+* partial session exists.
+*
+* For `'factory-failed'` the error a factory raised is preserved as `cause`.
+*/
+var MapSpawnError = class extends Error {
+	name = "MapSpawnError";
+	reason;
+	/** {@link MapObjectDescriptor.id} of the object that failed. */
+	objectId;
+	/** {@link MapObjectDescriptor.kind} of the object that failed. */
+	kind;
+	constructor(reason, objectId, kind, message, options) {
+		super(message, options);
+		this.reason = reason;
+		this.objectId = objectId;
+		this.kind = kind;
+	}
+};
+/**
+* Turns the objects authored in a map into game objects.
+*
+* A spawner owns its own dispatch table, so several games, tests, editor
+* previews or mods can run in one process without seeing each other's
+* factories. There is no global registry to register into and nothing to reset
+* between tests.
+*
+* ExoJS owns the mechanism: identity, ordering, cancellation, rollback and
+* lifetime. The game owns the policy: which object becomes what, and what those
+* objects need - dependencies travel through `Context`, not through any
+* service locator in the engine.
+*
+* A spawn is **atomic**: if any factory fails, everything already created is
+* destroyed in reverse order and no session is produced.
+*
+* @typeParam Context - the per-spawn value handed to every factory.
+* @typeParam Result - what the factories produce. Defaults to `SceneNode`.
+*
+* @example
+* ```ts
+* interface GameContext {
+*   services: GameServices;
+*   save: SaveGame;
+* }
+*
+* const spawner = new MapObjectSpawner<GameContext>({
+*   Enemy: (object, ctx) => new Enemy({ x: object.x, y: object.y, services: ctx.services }),
+*   Chest: (object, ctx) => new Chest({ id: object.id, save: ctx.save }),
+* });
+*
+* const session = await spawner.spawn(map, { services, save });
+* session.get('chest-in-the-cellar')?.open();
+* session.destroy();
+* ```
+*/
+var MapObjectSpawner = class {
+	/** What to do with an object no factory matched. */
+	unknown;
+	_factories;
+	_identify;
+	constructor(factories, options) {
+		this._factories = factories;
+		this._identify = options?.identify ?? defaultIdentify;
+		this.unknown = options?.unknown ?? "ignore";
+	}
+	/** Whether a factory is registered under `key`. */
+	handles(key) {
+		return Object.prototype.hasOwnProperty.call(this._factories, key);
+	}
+	/**
+	* Create a game object for every object of `map` a factory matches, and
+	* return the {@link MapSpawnSession} that owns them.
+	*
+	* Objects are visited in object-layer order, then object order within each
+	* layer, and asynchronous factories are awaited in that same order - a
+	* factory that resolves early can never overtake one before it.
+	*
+	* @throws {MapSpawnError} when a factory fails, two objects share a stable id,
+	* or an unmatched object is found while `unknown` is `'error'`. In every case
+	* the objects already created are destroyed first. A factory that fails while
+	* the spawn is also being aborted reports the factory failure, not the abort -
+	* the more specific of the two.
+	* @throws {DOMException} named `AbortError` when `options.signal` aborts.
+	*/
+	async spawn(map, context, options) {
+		const signal = options?.signal ?? neverAborts();
+		const entries = [];
+		const seen = /* @__PURE__ */ new Set();
+		try {
+			throwIfAborted(signal);
+			for (const object of mapObjectDescriptors(map)) {
+				if (seen.has(object.id)) throw new MapSpawnError("duplicate-id", object.id, object.kind, `MapObjectSpawner: two objects of this map resolve to the stable id "${object.id}"; ids must be unique within a map for session lookup and savegame restoration to work.`);
+				seen.add(object.id);
+				const key = this._identify(object, context);
+				const factory = key !== null && this.handles(key) ? this._factories[key] : void 0;
+				if (factory === void 0) {
+					if (this.unknown === "error") throw new MapSpawnError("unknown-kind", object.id, object.kind, `MapObjectSpawner: no factory registered for "${key ?? "<no kind>"}" (object "${object.id}" on layer "${object.layer.name}"). Register one, or set unknown: 'ignore'.`);
+					continue;
+				}
+				const result = await runFactory(factory, object, context, signal);
+				if (result !== null) entries.push([object.id, result]);
+				throwIfAborted(signal);
+			}
+		} catch (error) {
+			for (let i = entries.length - 1; i >= 0; i--) {
+				const entry = entries[i];
+				if (entry === void 0) continue;
+				try {
+					entry[1].destroy();
+				} catch (rollbackError) {
+					logger.error(`MapObjectSpawner: rolling back object "${entry[0]}" failed; continuing rollback.`, {
+						source: "tilemap",
+						...rollbackError instanceof Error && { error: rollbackError }
+					});
+				}
+			}
+			throw error;
+		}
+		return new MapSpawnSession(entries);
+	}
+};
+const defaultIdentify = (object) => object.kind;
+const runFactory = async (factory, object, context, signal) => {
+	try {
+		return await factory(object, context, signal);
+	} catch (error) {
+		throw new MapSpawnError("factory-failed", object.id, object.kind, `MapObjectSpawner: the factory for "${object.kind ?? "<no kind>"}" failed on object "${object.id}" of layer "${object.layer.name}".`, { cause: error });
+	}
+};
+const throwIfAborted = (signal) => {
+	if (signal.aborted) throw new DOMException("Map object spawn was cancelled.", "AbortError");
+};
+let sharedNeverAborts;
+const neverAborts = () => {
+	sharedNeverAborts ??= new AbortController().signal;
+	return sharedNeverAborts;
+};
+
+//#endregion
+export { MapObjectSpawner, MapSpawnError };
+//# sourceMappingURL=MapObjectSpawner.js.map

package/dist/esm/MapObjectSpawner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapObjectSpawner.js","names":[],"sources":["../../src/MapObjectSpawner.ts"],"sourcesContent":["import type { Destroyable, SceneNode } from '@codexo/exojs';\nimport { logger } from '@codexo/exojs';\n\nimport type { MapObjectDescriptor } from './MapObject';\nimport { mapObjectDescriptors } from './MapObject';\nimport { MapSpawnSession } from './MapSpawnSession';\nimport type { TileMap } from './TileMap';\n\n/** Why a {@link MapSpawnError} was raised. */\nexport type MapSpawnErrorReason =\n  /** No factory is registered for the object's dispatch key and `unknown` is `'error'`. */\n  | 'unknown-kind'\n  /** Two objects of the same map resolved to the same stable id. */\n  | 'duplicate-id'\n  /** A factory threw or rejected. The original error is the `cause`. */\n  | 'factory-failed';\n\n/**\n * A spawn failed. The whole spawn is rolled back before this is thrown - no\n * partial session exists.\n *\n * For `'factory-failed'` the error a factory raised is preserved as `cause`.\n */\nexport class MapSpawnError extends Error {\n  public override readonly name = 'MapSpawnError';\n  public readonly reason: MapSpawnErrorReason;\n  /** {@link MapObjectDescriptor.id} of the object that failed. */\n  public readonly objectId: string;\n  /** {@link MapObjectDescriptor.kind} of the object that failed. */\n  public readonly kind: string | null;\n\n  public constructor(reason: MapSpawnErrorReason, objectId: string, kind: string | null, message: string, options?: ErrorOptions) {\n    super(message, options);\n    this.reason = reason;\n    this.objectId = objectId;\n    this.kind = kind;\n  }\n}\n\n/**\n * Creates one runtime object from one map object, or `null` to deliberately\n * create nothing for it.\n *\n * `signal` aborts with the spawn it belongs to; a factory that loads assets or\n * awaits anything else should pass it on, so a level unloaded mid-load stops\n * its own work too.\n */\nexport type MapObjectFactory<Context, Result extends Destroyable> = (\n  object: MapObjectDescriptor,\n  context: Context,\n  signal: AbortSignal,\n) => Result | null | Promise<Result | null>;\n\n/** Dispatch key to factory. Keys are matched against the spawner's `identify` result. */\nexport type MapObjectFactories<Context, Result extends Destroyable> = Readonly<Record<string, MapObjectFactory<Context, Result>>>;\n\n/** What to do with an object no factory is registered for. */\nexport type UnknownMapObjectPolicy = 'ignore' | 'error';\n\n/** Options for {@link MapObjectSpawner}. */\nexport interface MapObjectSpawnerOptions<Context> {\n  /**\n   * Picks the factory key for an object, or returns `null` to treat it as\n   * unknown. Defaults to {@link MapObjectDescriptor.kind}.\n   *\n   * This is where project-specific dispatch policy lives - keying on a\n   * property, a name prefix, or a compound key:\n   *\n   * ```ts\n   * identify: object => `${object.kind}:${object.properties.variant}`\n   * ```\n   */\n  readonly identify?: (object: MapObjectDescriptor, context: Context) => string | null;\n  /**\n   * What to do with an object no factory matched. Defaults to `'ignore'`,\n   * because maps legitimately carry editor markers, decoration and metadata\n   * objects that no game entity corresponds to. Use `'error'` for a map format\n   * the project fully controls and wants validated.\n   */\n  readonly unknown?: UnknownMapObjectPolicy;\n}\n\n/** Options for {@link MapObjectSpawner.spawn}. */\nexport interface MapSpawnOptions {\n  /**\n   * Cancels the spawn. An in-flight factory is still awaited - abandoning it\n   * would leak whatever it eventually produced - but its result is destroyed\n   * along with the rest of the rollback.\n   */\n  readonly signal?: AbortSignal;\n}\n\n/**\n * Turns the objects authored in a map into game objects.\n *\n * A spawner owns its own dispatch table, so several games, tests, editor\n * previews or mods can run in one process without seeing each other's\n * factories. There is no global registry to register into and nothing to reset\n * between tests.\n *\n * ExoJS owns the mechanism: identity, ordering, cancellation, rollback and\n * lifetime. The game owns the policy: which object becomes what, and what those\n * objects need - dependencies travel through `Context`, not through any\n * service locator in the engine.\n *\n * A spawn is **atomic**: if any factory fails, everything already created is\n * destroyed in reverse order and no session is produced.\n *\n * @typeParam Context - the per-spawn value handed to every factory.\n * @typeParam Result - what the factories produce. Defaults to `SceneNode`.\n *\n * @example\n * ```ts\n * interface GameContext {\n *   services: GameServices;\n *   save: SaveGame;\n * }\n *\n * const spawner = new MapObjectSpawner<GameContext>({\n *   Enemy: (object, ctx) => new Enemy({ x: object.x, y: object.y, services: ctx.services }),\n *   Chest: (object, ctx) => new Chest({ id: object.id, save: ctx.save }),\n * });\n *\n * const session = await spawner.spawn(map, { services, save });\n * session.get('chest-in-the-cellar')?.open();\n * session.destroy();\n * ```\n */\nexport class MapObjectSpawner<Context = void, Result extends Destroyable = SceneNode> {\n  /** What to do with an object no factory matched. */\n  public readonly unknown: UnknownMapObjectPolicy;\n\n  private readonly _factories: MapObjectFactories<Context, Result>;\n  private readonly _identify: (object: MapObjectDescriptor, context: Context) => string | null;\n\n  public constructor(factories: MapObjectFactories<Context, Result>, options?: MapObjectSpawnerOptions<Context>) {\n    this._factories = factories;\n    this._identify = options?.identify ?? defaultIdentify;\n    this.unknown = options?.unknown ?? 'ignore';\n  }\n\n  /** Whether a factory is registered under `key`. */\n  public handles(key: string): boolean {\n    return Object.prototype.hasOwnProperty.call(this._factories, key);\n  }\n\n  /**\n   * Create a game object for every object of `map` a factory matches, and\n   * return the {@link MapSpawnSession} that owns them.\n   *\n   * Objects are visited in object-layer order, then object order within each\n   * layer, and asynchronous factories are awaited in that same order - a\n   * factory that resolves early can never overtake one before it.\n   *\n   * @throws {MapSpawnError} when a factory fails, two objects share a stable id,\n   * or an unmatched object is found while `unknown` is `'error'`. In every case\n   * the objects already created are destroyed first. A factory that fails while\n   * the spawn is also being aborted reports the factory failure, not the abort -\n   * the more specific of the two.\n   * @throws {DOMException} named `AbortError` when `options.signal` aborts.\n   */\n  public async spawn(map: TileMap, context: Context, options?: MapSpawnOptions): Promise<MapSpawnSession<Result>> {\n    const signal = options?.signal ?? neverAborts();\n    const entries: Array<readonly [id: string, result: Result]> = [];\n    const seen = new Set<string>();\n\n    try {\n      throwIfAborted(signal);\n\n      for (const object of mapObjectDescriptors(map)) {\n        if (seen.has(object.id)) {\n          throw new MapSpawnError(\n            'duplicate-id',\n            object.id,\n            object.kind,\n            `MapObjectSpawner: two objects of this map resolve to the stable id \"${object.id}\"; ` +\n              'ids must be unique within a map for session lookup and savegame restoration to work.',\n          );\n        }\n\n        seen.add(object.id);\n\n        const key = this._identify(object, context);\n        // Own-property check before indexing: a map is free to name an object\n        // class \"toString\" or \"constructor\", and a bare index would resolve\n        // those against Object.prototype and call a function that is not a\n        // factory at all.\n        const factory = key !== null && this.handles(key) ? this._factories[key] : undefined;\n\n        if (factory === undefined) {\n          if (this.unknown === 'error') {\n            throw new MapSpawnError(\n              'unknown-kind',\n              object.id,\n              object.kind,\n              `MapObjectSpawner: no factory registered for \"${key ?? '<no kind>'}\" (object \"${object.id}\" ` +\n                `on layer \"${object.layer.name}\"). Register one, or set unknown: 'ignore'.`,\n            );\n          }\n\n          continue;\n        }\n\n        const result = await runFactory(factory, object, context, signal);\n\n        // Push before the abort check so a result that arrived after the abort\n        // is rolled back with the rest instead of being left unowned.\n        if (result !== null) entries.push([object.id, result]);\n\n        throwIfAborted(signal);\n      }\n    } catch (error) {\n      for (let i = entries.length - 1; i >= 0; i--) {\n        const entry = entries[i];\n        if (entry === undefined) continue;\n\n        // A failing rollback step must neither replace the error that caused\n        // the rollback nor strand the objects before it.\n        try {\n          entry[1].destroy();\n        } catch (rollbackError) {\n          logger.error(`MapObjectSpawner: rolling back object \"${entry[0]}\" failed; continuing rollback.`, {\n            source: 'tilemap',\n            ...(rollbackError instanceof Error && { error: rollbackError }),\n          });\n        }\n      }\n\n      throw error;\n    }\n\n    return new MapSpawnSession(entries);\n  }\n}\n\nconst defaultIdentify = (object: MapObjectDescriptor): string | null => object.kind;\n\nconst runFactory = async <Context, Result extends Destroyable>(\n  factory: MapObjectFactory<Context, Result>,\n  object: MapObjectDescriptor,\n  context: Context,\n  signal: AbortSignal,\n): Promise<Result | null> => {\n  try {\n    return await factory(object, context, signal);\n  } catch (error) {\n    throw new MapSpawnError(\n      'factory-failed',\n      object.id,\n      object.kind,\n      `MapObjectSpawner: the factory for \"${object.kind ?? '<no kind>'}\" failed on object \"${object.id}\" ` + `of layer \"${object.layer.name}\".`,\n      { cause: error },\n    );\n  }\n};\n\nconst throwIfAborted = (signal: AbortSignal): void => {\n  if (signal.aborted) {\n    throw new DOMException('Map object spawn was cancelled.', 'AbortError');\n  }\n};\n\n// One shared never-aborting signal: `spawn` without a signal is the common\n// case, and a fresh AbortController per spawn would allocate for nothing.\nlet sharedNeverAborts: AbortSignal | undefined;\n\nconst neverAborts = (): AbortSignal => {\n  sharedNeverAborts ??= new AbortController().signal;\n  return sharedNeverAborts;\n};\n"],"mappings":";;;;;;;;;;;AAuBA,IAAa,gBAAb,cAAmC,MAAM;CACvC,AAAyB,OAAO;CAChC,AAAgB;;CAEhB,AAAgB;;CAEhB,AAAgB;CAEhB,AAAO,YAAY,QAA6B,UAAkB,MAAqB,SAAiB,SAAwB;EAC9H,MAAM,SAAS,OAAO;EACtB,KAAK,SAAS;EACd,KAAK,WAAW;EAChB,KAAK,OAAO;CACd;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2FA,IAAa,mBAAb,MAAsF;;CAEpF,AAAgB;CAEhB,AAAiB;CACjB,AAAiB;CAEjB,AAAO,YAAY,WAAgD,SAA4C;EAC7G,KAAK,aAAa;EAClB,KAAK,YAAY,SAAS,YAAY;EACtC,KAAK,UAAU,SAAS,WAAW;CACrC;;CAGA,AAAO,QAAQ,KAAsB;EACnC,OAAO,OAAO,UAAU,eAAe,KAAK,KAAK,YAAY,GAAG;CAClE;;;;;;;;;;;;;;;;CAiBA,MAAa,MAAM,KAAc,SAAkB,SAA6D;EAC9G,MAAM,SAAS,SAAS,UAAU,YAAY;EAC9C,MAAM,UAAwD,CAAC;EAC/D,MAAM,uBAAO,IAAI,IAAY;EAE7B,IAAI;GACF,eAAe,MAAM;GAErB,KAAK,MAAM,UAAU,qBAAqB,GAAG,GAAG;IAC9C,IAAI,KAAK,IAAI,OAAO,EAAE,GACpB,MAAM,IAAI,cACR,gBACA,OAAO,IACP,OAAO,MACP,uEAAuE,OAAO,GAAG,wFAEnF;IAGF,KAAK,IAAI,OAAO,EAAE;IAElB,MAAM,MAAM,KAAK,UAAU,QAAQ,OAAO;IAK1C,MAAM,UAAU,QAAQ,QAAQ,KAAK,QAAQ,GAAG,IAAI,KAAK,WAAW,OAAO;IAE3E,IAAI,YAAY,QAAW;KACzB,IAAI,KAAK,YAAY,SACnB,MAAM,IAAI,cACR,gBACA,OAAO,IACP,OAAO,MACP,gDAAgD,OAAO,YAAY,aAAa,OAAO,GAAG,cAC3E,OAAO,MAAM,KAAK,4CACnC;KAGF;IACF;IAEA,MAAM,SAAS,MAAM,WAAW,SAAS,QAAQ,SAAS,MAAM;IAIhE,IAAI,WAAW,MAAM,QAAQ,KAAK,CAAC,OAAO,IAAI,MAAM,CAAC;IAErD,eAAe,MAAM;GACvB;EACF,SAAS,OAAO;GACd,KAAK,IAAI,IAAI,QAAQ,SAAS,GAAG,KAAK,GAAG,KAAK;IAC5C,MAAM,QAAQ,QAAQ;IACtB,IAAI,UAAU,QAAW;IAIzB,IAAI;KACF,MAAM,EAAE,CAAC,QAAQ;IACnB,SAAS,eAAe;KACtB,OAAO,MAAM,0CAA0C,MAAM,GAAG,iCAAiC;MAC/F,QAAQ;MACR,GAAI,yBAAyB,SAAS,EAAE,OAAO,cAAc;KAC/D,CAAC;IACH;GACF;GAEA,MAAM;EACR;EAEA,OAAO,IAAI,gBAAgB,OAAO;CACpC;AACF;AAEA,MAAM,mBAAmB,WAA+C,OAAO;AAE/E,MAAM,aAAa,OACjB,SACA,QACA,SACA,WAC2B;CAC3B,IAAI;EACF,OAAO,MAAM,QAAQ,QAAQ,SAAS,MAAM;CAC9C,SAAS,OAAO;EACd,MAAM,IAAI,cACR,kBACA,OAAO,IACP,OAAO,MACP,sCAAsC,OAAO,QAAQ,YAAY,sBAAsB,OAAO,GAAG,cAAmB,OAAO,MAAM,KAAK,KACtI,EAAE,OAAO,MAAM,CACjB;CACF;AACF;AAEA,MAAM,kBAAkB,WAA8B;CACpD,IAAI,OAAO,SACT,MAAM,IAAI,aAAa,mCAAmC,YAAY;AAE1E;AAIA,IAAI;AAEJ,MAAM,oBAAiC;CACrC,sBAAsB,IAAI,gBAAgB,CAAC,CAAC;CAC5C,OAAO;AACT"}

package/dist/esm/MapSpawnSession.d.ts

@@ -0,0 +1,53 @@
+import type { Destroyable } from '@codexo/exojs';
+/**
+ * The objects one spawn produced, and their shared lifetime.
+ *
+ * A session is handed out by
+ * {@link import('./MapObjectSpawner').MapObjectSpawner.spawn} and owns every
+ * result in it. Destroying the session destroys them all; nothing else has to
+ * be tracked, and nothing scans the scene to find them again.
+ *
+ * A session is not reusable - destroy it and spawn again.
+ *
+ * @typeParam Result - what the factories produced.
+ */
+export declare class MapSpawnSession<Result extends Destroyable> implements Destroyable {
+    /**
+     * The spawned objects in spawn order: object-layer order, then object order
+     * within each layer. Objects whose factory returned `null` are not in here.
+     */
+    readonly objects: readonly Result[];
+    private readonly _byId;
+    private _destroyed;
+    /**
+     * Sessions are produced by
+     * {@link import('./MapObjectSpawner').MapObjectSpawner.spawn}, not
+     * constructed directly.
+     * @internal
+     */
+    constructor(entries: ReadonlyArray<readonly [id: string, result: Result]>);
+    /** Whether {@link destroy} has run. */
+    get destroyed(): boolean;
+    /**
+     * The object spawned from the source object with this
+     * {@link import('./MapObject').MapObjectDescriptor.id}, or `undefined` when
+     * no object with that id spawned anything. Constant time.
+     *
+     * The ids are the source-stable ones, which is what makes this the hook for
+     * savegame restoration: persist the id, look the runtime object back up.
+     */
+    get(sourceId: string): Result | undefined;
+    /** Whether {@link get} would find an object for `sourceId`. */
+    has(sourceId: string): boolean;
+    /**
+     * Destroy every spawned object, in reverse spawn order. Idempotent;
+     * {@link objects} still lists what the session held.
+     *
+     * Reverse order is the contract, not an implementation detail: an object
+     * spawned later may have attached itself to an earlier one (a turret to its
+     * platform, a light to its lamp), and tearing down the dependent first is
+     * the order that never observes a half-destroyed owner.
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=MapSpawnSession.d.ts.map

package/dist/esm/MapSpawnSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapSpawnSession.d.ts","sourceRoot":"","sources":["../../src/MapSpawnSession.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAGjD;;;;;;;;;;;GAWG;AACH,qBAAa,eAAe,CAAC,MAAM,SAAS,WAAW,CAAE,YAAW,WAAW;IAC7E;;;OAGG;IACH,SAAgB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAE3C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8B;IACpD,OAAO,CAAC,UAAU,CAAS;IAE3B;;;;;OAKG;gBACgB,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAahF,uCAAuC;IACvC,IAAW,SAAS,IAAI,OAAO,CAE9B;IAED;;;;;;;OAOG;IACI,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIhD,+DAA+D;IACxD,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIrC;;;;;;;;OAQG;IACI,OAAO,IAAI,IAAI;CAqBvB"}

package/dist/esm/MapSpawnSession.js

@@ -0,0 +1,88 @@
+import { logger } from "@codexo/exojs";
+
+//#region src/MapSpawnSession.ts
+/**
+* The objects one spawn produced, and their shared lifetime.
+*
+* A session is handed out by
+* {@link import('./MapObjectSpawner').MapObjectSpawner.spawn} and owns every
+* result in it. Destroying the session destroys them all; nothing else has to
+* be tracked, and nothing scans the scene to find them again.
+*
+* A session is not reusable - destroy it and spawn again.
+*
+* @typeParam Result - what the factories produced.
+*/
+var MapSpawnSession = class {
+	/**
+	* The spawned objects in spawn order: object-layer order, then object order
+	* within each layer. Objects whose factory returned `null` are not in here.
+	*/
+	objects;
+	_byId;
+	_destroyed = false;
+	/**
+	* Sessions are produced by
+	* {@link import('./MapObjectSpawner').MapObjectSpawner.spawn}, not
+	* constructed directly.
+	* @internal
+	*/
+	constructor(entries) {
+		const objects = [];
+		const byId = /* @__PURE__ */ new Map();
+		for (const [id, result] of entries) {
+			objects.push(result);
+			byId.set(id, result);
+		}
+		this.objects = Object.freeze(objects);
+		this._byId = byId;
+	}
+	/** Whether {@link destroy} has run. */
+	get destroyed() {
+		return this._destroyed;
+	}
+	/**
+	* The object spawned from the source object with this
+	* {@link import('./MapObject').MapObjectDescriptor.id}, or `undefined` when
+	* no object with that id spawned anything. Constant time.
+	*
+	* The ids are the source-stable ones, which is what makes this the hook for
+	* savegame restoration: persist the id, look the runtime object back up.
+	*/
+	get(sourceId) {
+		return this._byId.get(sourceId);
+	}
+	/** Whether {@link get} would find an object for `sourceId`. */
+	has(sourceId) {
+		return this._byId.has(sourceId);
+	}
+	/**
+	* Destroy every spawned object, in reverse spawn order. Idempotent;
+	* {@link objects} still lists what the session held.
+	*
+	* Reverse order is the contract, not an implementation detail: an object
+	* spawned later may have attached itself to an earlier one (a turret to its
+	* platform, a light to its lamp), and tearing down the dependent first is
+	* the order that never observes a half-destroyed owner.
+	*/
+	destroy() {
+		if (this._destroyed) return;
+		this._destroyed = true;
+		for (let i = this.objects.length - 1; i >= 0; i--) {
+			const object = this.objects[i];
+			if (object === void 0) continue;
+			try {
+				object.destroy();
+			} catch (error) {
+				logger.error("MapSpawnSession: destroying a spawned object failed; continuing teardown.", {
+					source: "tilemap",
+					...error instanceof Error && { error }
+				});
+			}
+		}
+	}
+};
+
+//#endregion
+export { MapSpawnSession };
+//# sourceMappingURL=MapSpawnSession.js.map

package/dist/esm/MapSpawnSession.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapSpawnSession.js","names":[],"sources":["../../src/MapSpawnSession.ts"],"sourcesContent":["import type { Destroyable } from '@codexo/exojs';\nimport { logger } from '@codexo/exojs';\n\n/**\n * The objects one spawn produced, and their shared lifetime.\n *\n * A session is handed out by\n * {@link import('./MapObjectSpawner').MapObjectSpawner.spawn} and owns every\n * result in it. Destroying the session destroys them all; nothing else has to\n * be tracked, and nothing scans the scene to find them again.\n *\n * A session is not reusable - destroy it and spawn again.\n *\n * @typeParam Result - what the factories produced.\n */\nexport class MapSpawnSession<Result extends Destroyable> implements Destroyable {\n  /**\n   * The spawned objects in spawn order: object-layer order, then object order\n   * within each layer. Objects whose factory returned `null` are not in here.\n   */\n  public readonly objects: readonly Result[];\n\n  private readonly _byId: ReadonlyMap<string, Result>;\n  private _destroyed = false;\n\n  /**\n   * Sessions are produced by\n   * {@link import('./MapObjectSpawner').MapObjectSpawner.spawn}, not\n   * constructed directly.\n   * @internal\n   */\n  public constructor(entries: ReadonlyArray<readonly [id: string, result: Result]>) {\n    const objects: Result[] = [];\n    const byId = new Map<string, Result>();\n\n    for (const [id, result] of entries) {\n      objects.push(result);\n      byId.set(id, result);\n    }\n\n    this.objects = Object.freeze(objects);\n    this._byId = byId;\n  }\n\n  /** Whether {@link destroy} has run. */\n  public get destroyed(): boolean {\n    return this._destroyed;\n  }\n\n  /**\n   * The object spawned from the source object with this\n   * {@link import('./MapObject').MapObjectDescriptor.id}, or `undefined` when\n   * no object with that id spawned anything. Constant time.\n   *\n   * The ids are the source-stable ones, which is what makes this the hook for\n   * savegame restoration: persist the id, look the runtime object back up.\n   */\n  public get(sourceId: string): Result | undefined {\n    return this._byId.get(sourceId);\n  }\n\n  /** Whether {@link get} would find an object for `sourceId`. */\n  public has(sourceId: string): boolean {\n    return this._byId.has(sourceId);\n  }\n\n  /**\n   * Destroy every spawned object, in reverse spawn order. Idempotent;\n   * {@link objects} still lists what the session held.\n   *\n   * Reverse order is the contract, not an implementation detail: an object\n   * spawned later may have attached itself to an earlier one (a turret to its\n   * platform, a light to its lamp), and tearing down the dependent first is\n   * the order that never observes a half-destroyed owner.\n   */\n  public destroy(): void {\n    if (this._destroyed) return;\n\n    this._destroyed = true;\n\n    for (let i = this.objects.length - 1; i >= 0; i--) {\n      const object = this.objects[i];\n      if (object === undefined) continue;\n\n      // One object's failure must not strand the rest: the session is single\n      // use, so anything skipped here is never destroyed at all.\n      try {\n        object.destroy();\n      } catch (error) {\n        logger.error('MapSpawnSession: destroying a spawned object failed; continuing teardown.', {\n          source: 'tilemap',\n          ...(error instanceof Error && { error }),\n        });\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAeA,IAAa,kBAAb,MAAgF;;;;;CAK9E,AAAgB;CAEhB,AAAiB;CACjB,AAAQ,aAAa;;;;;;;CAQrB,AAAO,YAAY,SAA+D;EAChF,MAAM,UAAoB,CAAC;EAC3B,MAAM,uBAAO,IAAI,IAAoB;EAErC,KAAK,MAAM,CAAC,IAAI,WAAW,SAAS;GAClC,QAAQ,KAAK,MAAM;GACnB,KAAK,IAAI,IAAI,MAAM;EACrB;EAEA,KAAK,UAAU,OAAO,OAAO,OAAO;EACpC,KAAK,QAAQ;CACf;;CAGA,IAAW,YAAqB;EAC9B,OAAO,KAAK;CACd;;;;;;;;;CAUA,AAAO,IAAI,UAAsC;EAC/C,OAAO,KAAK,MAAM,IAAI,QAAQ;CAChC;;CAGA,AAAO,IAAI,UAA2B;EACpC,OAAO,KAAK,MAAM,IAAI,QAAQ;CAChC;;;;;;;;;;CAWA,AAAO,UAAgB;EACrB,IAAI,KAAK,YAAY;EAErB,KAAK,aAAa;EAElB,KAAK,IAAI,IAAI,KAAK,QAAQ,SAAS,GAAG,KAAK,GAAG,KAAK;GACjD,MAAM,SAAS,KAAK,QAAQ;GAC5B,IAAI,WAAW,QAAW;GAI1B,IAAI;IACF,OAAO,QAAQ;GACjB,SAAS,OAAO;IACd,OAAO,MAAM,6EAA6E;KACxF,QAAQ;KACR,GAAI,iBAAiB,SAAS,EAAE,MAAM;IACxC,CAAC;GACH;EACF;CACF;AACF"}

package/dist/esm/MapWorld.d.ts

@@ -0,0 +1,134 @@
+import type { TileProperties } from './types';
+/** An axis-aligned rectangle in world pixel space (+Y down). */
+export interface MapBounds {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * Where a neighbouring level sits relative to the level that names it.
+ *
+ * `Overlap`, `Below` and `Above` describe depth relationships rather than
+ * cardinal directions - a source format that stacks levels (LDtk's depth
+ * layers) reports those. `Unknown` preserves an adjacency whose direction code
+ * this version does not recognise: the levels are neighbours, but the side is
+ * not interpretable.
+ */
+export declare const MapLevelSide: {
+    readonly North: "north";
+    readonly South: "south";
+    readonly West: "west";
+    readonly East: "east";
+    readonly Overlap: "overlap";
+    readonly Below: "below";
+    readonly Above: "above";
+    readonly Unknown: "unknown";
+};
+/** Side discriminant for a {@link MapLevelNeighbour}. */
+export type MapLevelSide = (typeof MapLevelSide)[keyof typeof MapLevelSide];
+/** One adjacency edge from a level to another level in the same {@link MapWorld}. */
+export interface MapLevelNeighbour {
+    /** {@link MapLevel.id} of the neighbouring level. */
+    readonly id: string;
+    readonly side: MapLevelSide;
+}
+/**
+ * Immutable metadata for one level of a {@link MapWorld} - everything needed to
+ * decide whether to load it, without loading it.
+ */
+export interface MapLevel {
+    /**
+     * Stable identity, unique within the world. Carried from the source format
+     * (LDtk uses the level `iid`), so it survives re-ordering and re-export and
+     * is safe to persist in a savegame.
+     */
+    readonly id: string;
+    /** Human-readable level name. Not guaranteed unique. */
+    readonly name: string;
+    /** Position in source document order. */
+    readonly index: number;
+    /** Placement and size in world pixel space. */
+    readonly bounds: MapBounds;
+    /**
+     * Whether the level's layer payload lives outside the root document and has
+     * to be fetched separately when the level is loaded.
+     */
+    readonly external: boolean;
+    /** Adjacency edges declared by the source format; empty when it declares none. */
+    readonly neighbours: readonly MapLevelNeighbour[];
+    /** Level-level custom properties. */
+    readonly properties: TileProperties;
+}
+/** Construction options for a {@link MapWorld}. */
+export interface MapWorldOptions {
+    /** World name. Defaults to an empty string. */
+    readonly name?: string;
+    /** The world's levels, in source document order. */
+    readonly levels: readonly MapLevel[];
+}
+/**
+ * A format-neutral description of how levels are laid out in a world.
+ *
+ * A `MapWorld` holds metadata only - no tiles, no textures, no runtime maps.
+ * It is what a game reads to decide which levels it needs; loading them is
+ * {@link import('./MapWorldRuntime').MapWorldRuntime}'s job.
+ *
+ * Adapters build one from their source document
+ * (`@codexo/exojs-ldtk` does so from a `.ldtk` project). A format with no world
+ * concept of its own - Tiled, today - can be described by constructing one
+ * directly from whatever placement data the game keeps.
+ *
+ * @example
+ * ```ts
+ * const world = new MapWorld({
+ *   name: 'overworld',
+ *   levels: [
+ *     { id: 'forest', name: 'Forest', index: 0, external: false,
+ *       bounds: { x: 0, y: 0, width: 512, height: 512 },
+ *       neighbours: [{ id: 'cave', side: MapLevelSide.East }], properties: {} },
+ *   ],
+ * });
+ * ```
+ */
+export declare class MapWorld {
+    /** World name; empty when the source format does not name it. */
+    readonly name: string;
+    /** The world's levels, in source document order. */
+    readonly levels: readonly MapLevel[];
+    private readonly _byId;
+    private readonly _byName;
+    private _bounds?;
+    constructor(options: MapWorldOptions);
+    /**
+     * Union of every level's bounds, or a zero rectangle for an empty world.
+     * Computed once and cached - a `MapWorld` is immutable.
+     */
+    get bounds(): MapBounds;
+    /** The level with this {@link MapLevel.id}, or `undefined`. Constant time. */
+    getLevel(id: string): MapLevel | undefined;
+    /**
+     * The first level in document order whose {@link MapLevel.name} matches, or
+     * `undefined`. Constant time. Names are not unique by contract.
+     */
+    getLevelByName(name: string): MapLevel | undefined;
+    /**
+     * The levels `id` declares as adjacent, resolved to their metadata and in the
+     * order the source format declared them.
+     *
+     * A neighbour naming a level this world does not contain is skipped - LDtk
+     * can reference across worlds of a multi-world project, and each of those
+     * worlds is its own `MapWorld`. Returns an empty array for an unknown `id`.
+     */
+    getNeighbours(id: string): readonly MapLevel[];
+    /**
+     * Every level whose bounds intersect `bounds`, in document order. Edge
+     * contact alone does not count as an intersection, so two levels laid out
+     * side by side are not reported for a query that only touches the seam.
+     *
+     * Linear in the number of levels - intended for a per-camera-move query over
+     * a world of hundreds of levels, not for a per-frame query over thousands.
+     */
+    getLevelsInBounds(bounds: MapBounds): MapLevel[];
+}
+//# sourceMappingURL=MapWorld.d.ts.map

package/dist/esm/MapWorld.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapWorld.d.ts","sourceRoot":"","sources":["../../src/MapWorld.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,gEAAgE;AAChE,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY;;;;;;;;;CASf,CAAC;AAEX,yDAAyD;AACzD,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE5E,qFAAqF;AACrF,MAAM,WAAW,iBAAiB;IAChC,qDAAqD;IACrD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;CAC7B;AAED;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,kFAAkF;IAClF,QAAQ,CAAC,UAAU,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAClD,qCAAqC;IACrC,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;CACrC;AAED,mDAAmD;AACnD,MAAM,WAAW,eAAe;IAC9B,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,oDAAoD;IACpD,QAAQ,CAAC,MAAM,EAAE,SAAS,QAAQ,EAAE,CAAC;CACtC;AAID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,QAAQ;IACnB,iEAAiE;IACjE,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,oDAAoD;IACpD,SAAgB,MAAM,EAAE,SAAS,QAAQ,EAAE,CAAC;IAE5C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgC;IACtD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgC;IACxD,OAAO,CAAC,OAAO,CAAC,CAAY;gBAET,OAAO,EAAE,eAAe;IAsB3C;;;OAGG;IACH,IAAW,MAAM,IAAI,SAAS,CAuB7B;IAED,8EAA8E;IACvE,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAIjD;;;OAGG;IACI,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAIzD;;;;;;;OAOG;IACI,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,QAAQ,EAAE;IAcrD;;;;;;;OAOG;IACI,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,QAAQ,EAAE;CAYxD"}