incanto 0.1.0

package/dist/register-Dasmnurl.js

@@ -0,0 +1,374 @@
+import { f as Node, t as buildNodeJson, y as Signal } from "./loader-CGs_G-r0.js";
+import { t as IncantoError } from "./errors-BpWbnbb_.js";
+import { t as registerCoreNodes } from "./register-BuUV1_KB.js";
+import { n as jsonEquals, t as jsonClone } from "./json-BLk7H2Qa.js";
+import { l as registerNode } from "./registry-BVJ2HbCn.js";
+//#region src/net/network-manager.ts
+const managers = /* @__PURE__ */ new WeakMap();
+/**
+* Per-engine multiplayer hub: joins a room, exposes the room channels as core
+* Signals, replicates `network: {mode:'owner'}` node props on a throttle
+* window, and resolves registered scenes for NetworkSpawner.
+*/
+var NetworkManager = class NetworkManager {
+	account;
+	roomId;
+	roomState = new Signal();
+	allUserStates = new Signal();
+	userJoined = new Signal();
+	userLeft = new Signal();
+	/**
+	* GLOBAL (cross-room, persistent) channels — populated only when the transport
+	* supports them (`LocalGameServer`, the agent8 adapter). On a transport without a
+	* global tier they stay empty / never fire.
+	*/
+	globalState = new Signal();
+	globalMyState = new Signal();
+	/** The local account's `$asset` ledger. */
+	asset = new Signal();
+	/** Latest snapshots for polling consumers (NetworkSpawner). */
+	latestUserStates = {};
+	latestRoomState = {};
+	latestGlobalState = {};
+	latestGlobalMyState = {};
+	latestAsset = {};
+	server;
+	engine;
+	throttleMs;
+	subs = [];
+	messageSignals = /* @__PURE__ */ new Map();
+	collectionSignals = /* @__PURE__ */ new Map();
+	latestCollections = /* @__PURE__ */ new Map();
+	globalMessageSignals = /* @__PURE__ */ new Map();
+	globalCollectionSignals = /* @__PURE__ */ new Map();
+	latestGlobalCollections = /* @__PURE__ */ new Map();
+	scenes = /* @__PURE__ */ new Map();
+	lastSent = /* @__PURE__ */ new Map();
+	sendAccumulator = 0;
+	detachReplication = null;
+	lastOwner = null;
+	boundScene = null;
+	static get(engine) {
+		return managers.get(engine) ?? null;
+	}
+	static async create(engine, opts = {}) {
+		await managers.get(engine)?.dispose();
+		const server = opts.transport ?? await createDefaultTransport(opts.config);
+		await server.connect();
+		const requested = opts.room ?? engine.scene?.multiplayer?.room ?? "auto";
+		const manager = new NetworkManager(engine, server, await server.remoteFunction("joinRoom", [requested === "auto" ? void 0 : requested], { needResponse: true }), opts.throttleMs ?? 50);
+		managers.set(engine, manager);
+		return manager;
+	}
+	constructor(engine, server, roomId, throttleMs) {
+		this.engine = engine;
+		this.server = server;
+		this.roomId = roomId;
+		this.account = server.account;
+		this.throttleMs = Math.max(30, throttleMs);
+		this.boundScene = engine.scene;
+		this.subs.push(server.subscribeRoomState(roomId, (state) => {
+			this.latestRoomState = state;
+			this.roomState.emit(state);
+		}), server.subscribeRoomAllUserStates(roomId, (states) => {
+			this.latestUserStates = states;
+			this.allUserStates.emit(states);
+		}), server.onRoomUserJoin(roomId, (account) => this.userJoined.emit(account)), server.onRoomUserLeave(roomId, (account) => this.userLeft.emit(account)));
+		if (server.subscribeGlobalState) this.subs.push(server.subscribeGlobalState((state) => {
+			this.latestGlobalState = state;
+			this.globalState.emit(state);
+		}));
+		if (server.subscribeGlobalMyState) this.subs.push(server.subscribeGlobalMyState((state) => {
+			this.latestGlobalMyState = state;
+			this.globalMyState.emit(state);
+		}));
+		if (server.subscribeAsset) this.subs.push(server.subscribeAsset(this.account, (assets) => {
+			this.latestAsset = assets;
+			this.asset.emit(assets);
+		}));
+		this.detachReplication = engine.fixedUpdated.connect((dt) => this.replicate(dt));
+	}
+	/** Signal for a typed room message (`sendEvent` on any client). */
+	message(type) {
+		let sig = this.messageSignals.get(type);
+		if (!sig) {
+			sig = new Signal();
+			this.messageSignals.set(type, sig);
+			this.subs.push(this.server.onRoomMessage(this.roomId, type, (m) => sig?.emit(m)));
+		}
+		return sig;
+	}
+	/** Signal + snapshot for a room collection (spawned entities). */
+	collection(id) {
+		let sig = this.collectionSignals.get(id);
+		if (!sig) {
+			sig = new Signal();
+			this.collectionSignals.set(id, sig);
+			this.subs.push(this.server.subscribeRoomCollection(this.roomId, id, (entities) => {
+				this.latestCollections.set(id, entities);
+				sig?.emit(entities);
+			}));
+		}
+		return sig;
+	}
+	latestCollection(id) {
+		this.collection(id);
+		return this.latestCollections.get(id) ?? {};
+	}
+	/** Signal for a typed GLOBAL message (`$global.broadcastToAll`/`sendMessageToUser`). */
+	globalMessage(type) {
+		let sig = this.globalMessageSignals.get(type);
+		if (!sig) {
+			sig = new Signal();
+			this.globalMessageSignals.set(type, sig);
+			const sub = this.server.onGlobalMessage?.(type, (m) => sig?.emit(m));
+			if (sub) this.subs.push(sub);
+		}
+		return sig;
+	}
+	/** Signal + snapshot for a GLOBAL collection (persistent, cross-room). */
+	globalCollection(id) {
+		let sig = this.globalCollectionSignals.get(id);
+		if (!sig) {
+			sig = new Signal();
+			this.globalCollectionSignals.set(id, sig);
+			const sub = this.server.subscribeGlobalCollection?.(id, (entities) => {
+				this.latestGlobalCollections.set(id, entities);
+				sig?.emit(entities);
+			});
+			if (sub) this.subs.push(sub);
+		}
+		return sig;
+	}
+	latestGlobalCollection(id) {
+		this.globalCollection(id);
+		return this.latestGlobalCollections.get(id) ?? {};
+	}
+	setMyState(patch) {
+		return this.server.remoteFunction("setMyState", [this.roomId, patch], {
+			throttle: this.throttleMs,
+			throttleKey: "incanto:myState"
+		});
+	}
+	patchRoomState(patch) {
+		return this.server.remoteFunction("patchRoomState", [this.roomId, patch]);
+	}
+	addEntity(collectionId, entity) {
+		return this.server.remoteFunction("addEntity", [
+			this.roomId,
+			collectionId,
+			entity
+		]);
+	}
+	updateEntity(collectionId, id, patch) {
+		return this.server.remoteFunction("updateEntity", [
+			this.roomId,
+			collectionId,
+			id,
+			patch
+		]);
+	}
+	removeEntity(collectionId, id) {
+		return this.server.remoteFunction("removeEntity", [
+			this.roomId,
+			collectionId,
+			id
+		]);
+	}
+	sendEvent(type, payload) {
+		return this.server.remoteFunction("sendEvent", [
+			this.roomId,
+			type,
+			payload
+		]);
+	}
+	/**
+	* Invoke a CUSTOM server-authoritative function — a method you added to your
+	* `server/src/server.ts` `Server` class (run live on the Agent8 platform, or
+	* locally via `createLocalGameServer`). The room id is prepended automatically,
+	* matching the `(roomId, …)` shape every server method takes:
+	*
+	*   `manager.call('claimCoin', coinId)` → server `claimCoin(roomId, coinId)`
+	*
+	* Returns the function's result (use it for server-validated outcomes — a
+	* rejected claim, a rolled value). This is THE entry point for game rules the
+	* client must not be trusted to compute.
+	*/
+	call(fn, ...args) {
+		return this.server.remoteFunction(fn, [this.roomId, ...args], { needResponse: true });
+	}
+	/** Register a scene for NetworkSpawner (`"scene": "<key>"`). */
+	registerScene(key, json) {
+		this.scenes.set(key, json);
+	}
+	resolveScene(key) {
+		const json = this.scenes.get(key);
+		if (!json) throw new IncantoError("UNRESOLVED_INSTANCE", `No scene registered for '${key}'. Registered: [${[...this.scenes.keys()].join(", ")}]. Call manager.registerScene('${key}', sceneJson).`);
+		return json;
+	}
+	async dispose() {
+		this.detachReplication?.();
+		for (const off of this.subs) off();
+		await this.server.remoteFunction("leaveRoom", [this.roomId]);
+		managers.delete(this.engine);
+	}
+	replicate(dt) {
+		const scene = this.engine.scene;
+		if (!scene || scene !== this.boundScene) return;
+		this.sendAccumulator += dt * 1e3;
+		const owner = findOwnerNode(scene.root, true);
+		if (!owner) return;
+		if (owner !== this.lastOwner) {
+			this.lastOwner = owner;
+			this.lastSent.clear();
+		}
+		const net = owner.network;
+		const window = Math.max(30, typeof net.throttleMs === "number" ? net.throttleMs : this.throttleMs);
+		const syncKeys = Array.isArray(net.sync) ? net.sync : [];
+		const patch = {};
+		for (const key of syncKeys) {
+			const value = readSyncKey(owner, key);
+			if (value === void 0) continue;
+			if (!jsonEquals(this.lastSent.get(key) ?? null, value)) patch[key] = jsonClone(value);
+		}
+		if (this.sendAccumulator < window) return;
+		if (Object.keys(patch).length === 0) return;
+		for (const [key, value] of Object.entries(patch)) this.lastSent.set(key, jsonClone(value));
+		this.sendAccumulator = 0;
+		this.setMyState({ sync: patch });
+	}
+};
+function findOwnerNode(node, enforceSingle = false) {
+	const owners = [];
+	collectOwners(node, owners);
+	if (enforceSingle && owners.length > 1) throw new IncantoError("BAD_FORMAT", `Multiple network owner nodes found (${owners.map((o) => o.getPath()).join(", ")}). Exactly ONE node per player may declare network.mode 'owner' — replicate spawned entities through collections instead.`);
+	return owners[0] ?? null;
+}
+function collectOwners(node, out) {
+	if (node.network?.mode === "owner") out.push(node);
+	for (const c of node.children) collectOwners(c, out);
+}
+/** `'position'` → own prop; `'Sprite.animation'` → child path + prop (last dot splits). */
+function readSyncKey(node, key) {
+	const lastDot = key.lastIndexOf(".");
+	const target = lastDot === -1 ? node : node.getNodeOrNull(key.slice(0, lastDot)) ?? void 0;
+	const prop = lastDot === -1 ? key : key.slice(lastDot + 1);
+	if (!target) return void 0;
+	return target[prop];
+}
+/**
+* @internal Applies a replicated flat sync patch (`{'position': …,
+* 'Sprite.animation': …}`) onto a spawned subtree (NetworkSpawner).
+*/
+function applySyncPatch(root, patch, setProp) {
+	for (const [key, value] of Object.entries(patch)) {
+		const lastDot = key.lastIndexOf(".");
+		const target = lastDot === -1 ? root : root.getNodeOrNull(key.slice(0, lastDot));
+		const prop = lastDot === -1 ? key : key.slice(lastDot + 1);
+		if (target) setProp(target, prop, value);
+	}
+}
+async function createDefaultTransport(config) {
+	const { createAgent8Server } = await import("./agent8-DzU2fFyH.js").then((n) => n.t);
+	return createAgent8Server(config);
+}
+//#endregion
+//#region src/net/nodes/network-spawner.ts
+/**
+* Materializes a registered scene per remote player or collection entity:
+*
+* - `source: 'users'` — one instance per OTHER account in the room
+*   (self is skipped; the local player is your own owned node)
+* - `source: 'collection:<id>'` — one instance per entity (bullets, pickups…)
+*
+* Replicated flat `{sync: {...}}` patches apply onto each instance's root;
+* `position` lerps toward its target when `interpolate` is on. Emits
+* `spawned(node, key)` / `despawned(node, key)`.
+*/
+var NetworkSpawner = class extends Node {
+	static typeName = "NetworkSpawner";
+	static signals = ["spawned", "despawned"];
+	static props = {
+		source: { default: "users" },
+		scene: { default: "" },
+		interpolate: { default: true }
+	};
+	source = "users";
+	/** Key registered via `manager.registerScene(key, json)`. */
+	scene = "";
+	interpolate = true;
+	spawned = /* @__PURE__ */ new Map();
+	positionTargets = /* @__PURE__ */ new Map();
+	failedKeys = /* @__PURE__ */ new Set();
+	update(dt) {
+		const engine = this.tree?.engine;
+		if (!engine) return;
+		const manager = NetworkManager.get(engine);
+		if (!manager || this.scene === "") return;
+		const entries = this.currentEntries(manager);
+		for (const [key, state] of Object.entries(entries)) {
+			let instance = this.spawned.get(key);
+			if (!instance) {
+				if (this.failedKeys.has(key)) continue;
+				try {
+					instance = buildNodeJson(manager.resolveScene(this.scene).root);
+				} catch (error) {
+					this.failedKeys.add(key);
+					throw error;
+				}
+				instance.name = sanitizeName(key);
+				this.addChild(instance);
+				this.spawned.set(key, instance);
+				this.emit("spawned", instance, key);
+			}
+			const patch = state.sync;
+			if (patch) applySyncPatch(instance, patch, (target, prop, value) => this.setProp(target, prop, value));
+		}
+		for (const [key, instance] of [...this.spawned.entries()]) if (!(key in entries)) {
+			this.spawned.delete(key);
+			this.positionTargets.delete(instance);
+			this.emit("despawned", instance, key);
+			instance.free();
+		}
+		if (this.interpolate) this.stepInterpolation(dt);
+	}
+	currentEntries(manager) {
+		if (this.source === "users") {
+			const out = {};
+			for (const [account, state] of Object.entries(manager.latestUserStates)) if (account !== manager.account) out[account] = state;
+			return out;
+		}
+		if (this.source.startsWith("collection:")) return manager.latestCollection(this.source.slice(11));
+		return {};
+	}
+	setProp(target, prop, value) {
+		if (this.interpolate && prop === "position" && Array.isArray(value)) {
+			this.positionTargets.set(target, value);
+			return;
+		}
+		target[prop] = value;
+	}
+	stepInterpolation(dt) {
+		const f = Math.min(1, dt * 8);
+		for (const [target, goal] of this.positionTargets) {
+			const pos = target.position;
+			if (!Array.isArray(pos)) continue;
+			target.position = pos.map((v, i) => v + ((goal[i] ?? v) - v) * f);
+		}
+	}
+};
+function sanitizeName(key) {
+	return key.replace(/[/%]/g, "_") || "remote";
+}
+//#endregion
+//#region src/net/register.ts
+/**
+* Register the networking node types (and the core nodes). Call once in your
+* game entry before loading a multiplayer scene. Explicit — never a side effect.
+*/
+function registerNodesNet() {
+	registerCoreNodes();
+	registerNode(NetworkSpawner);
+}
+//#endregion
+export { applySyncPatch as i, NetworkSpawner as n, NetworkManager as r, registerNodesNet as t };

package/dist/registry-BVJ2HbCn.js

@@ -0,0 +1,132 @@
+import { t as IncantoError } from "./errors-BpWbnbb_.js";
+import { r as jsonKind, t as jsonClone } from "./json-BLk7H2Qa.js";
+//#region src/core/registry.ts
+/**
+* Validate a prop value against its schema default:
+* - JSON kind must match (unless the default is null = "any")
+* - numbers must be finite (NaN/Infinity corrupt JSON files)
+* - non-empty default arrays are FIXED templates: same length, element-wise match
+*   (empty default arrays are unconstrained — variable-length lists)
+*/
+function validatePropValue(value, def, at) {
+	const expected = jsonKind(def);
+	if (expected === "null") return;
+	const actual = jsonKind(value);
+	if (actual !== expected) throw new IncantoError("PROP_TYPE_MISMATCH", `Prop '${at}' expects ${expected} (default ${JSON.stringify(def)}), got ${actual} (${JSON.stringify(value)}).`, { prop: at });
+	if (typeof value === "number" && !Number.isFinite(value)) throw new IncantoError("PROP_TYPE_MISMATCH", `Prop '${at}' is ${value} — props must be finite numbers.`, { prop: at });
+	if (Array.isArray(def) && Array.isArray(value) && def.length > 0) {
+		if (value.length !== def.length) throw new IncantoError("PROP_TYPE_MISMATCH", `Prop '${at}' expects an array of length ${def.length} (default ${JSON.stringify(def)}), got length ${value.length}.`, { prop: at });
+		for (let i = 0; i < def.length; i++) validatePropValue(value[i], def[i], `${at}[${i}]`);
+	}
+}
+/**
+* Global node-type registry (Godot's ClassDB role).
+*
+* Registration is EXPLICIT — never an import-time side effect, so
+* `sideEffects: false` tree-shaking can never silently drop node types.
+*/
+const types = /* @__PURE__ */ new Map();
+function registerNode(ctor, opts) {
+	const existing = types.get(ctor.typeName);
+	if (existing && existing !== ctor && !opts?.replace) throw new IncantoError("DUPLICATE_NODE_TYPE", `Node type '${ctor.typeName}' is already registered by a different class. Replacing an implementation (e.g. under hot reload) needs registerNode(ctor, { replace: true }).`, { nodeType: ctor.typeName });
+	types.set(ctor.typeName, ctor);
+}
+function getNodeType(typeName) {
+	const ctor = types.get(typeName);
+	if (!ctor) {
+		const registered = [...types.keys()];
+		throw new IncantoError("UNKNOWN_NODE_TYPE", `Unknown node type '${typeName}'. Registered types: [${registered.join(", ")}].`, {
+			nodeType: typeName,
+			validOptions: registered
+		});
+	}
+	return ctor;
+}
+function registeredTypes() {
+	return [...types.keys()];
+}
+/** Test isolation helper. */
+function clearRegistry() {
+	types.clear();
+}
+/**
+* Effective prop schema for a type: own static `props` merged over every
+* ancestor's (subclass keys win).
+*/
+function getNodeSchema(typeName) {
+	return mergeStaticProps(getNodeType(typeName));
+}
+/** Walk a constructor's prototype chain collecting static `signals` (deduped). */
+function mergeStaticSignals(ctor) {
+	const out = [];
+	let current = ctor;
+	while (current) {
+		if (Object.hasOwn(current, "signals") && current.signals) out.unshift(...current.signals);
+		const parent = Object.getPrototypeOf(current);
+		current = typeof parent === "function" ? parent : null;
+	}
+	return [...new Set(out)];
+}
+/** Every signal a registered type declares (its own + inherited). */
+function getNodeSignals(typeName) {
+	return mergeStaticSignals(getNodeType(typeName));
+}
+/** Walk a constructor's prototype chain merging static `props` (subclass wins). */
+function mergeStaticProps(ctor) {
+	const chain = [];
+	let current = ctor;
+	while (current) {
+		if (Object.hasOwn(current, "props") && current.props) chain.unshift(current.props);
+		const parent = Object.getPrototypeOf(current);
+		current = typeof parent === "function" ? parent : null;
+	}
+	return Object.assign({}, ...chain);
+}
+/** Walk a constructor's prototype chain merging static `propAliases` (legacy
+* prop key → its current canonical key; subclass wins). Lets a renamed prop keep
+* loading old scenes (e.g. 2D `zIndex` → `renderOrder`) without a format bump. */
+function mergeStaticAliases(ctor) {
+	const chain = [];
+	let current = ctor;
+	while (current) {
+		if (Object.hasOwn(current, "propAliases") && current.propAliases) chain.unshift(current.propAliases);
+		const parent = Object.getPrototypeOf(current);
+		current = typeof parent === "function" ? parent : null;
+	}
+	return Object.assign({}, ...chain);
+}
+/**
+* Assign schema defaults (cloned) then the given props onto a target,
+* hard-validating every key and JSON kind. Shared by nodes and behaviors.
+* `aliases` maps legacy keys onto current ones (back-compat for renamed props).
+*/
+function applySchemaProps(target, schema, props, label, aliases = {}) {
+	for (const [key, def] of Object.entries(schema)) target[key] = jsonClone(def.default);
+	if (!props) return;
+	for (const [rawKey, value] of Object.entries(props)) {
+		const key = schema[rawKey] ? rawKey : aliases[rawKey] ?? rawKey;
+		const def = schema[key];
+		if (!def) {
+			const valid = Object.keys(schema);
+			throw new IncantoError("UNKNOWN_PROP", `Unknown prop '${rawKey}' on '${label}'. Valid props: [${valid.join(", ")}].`, {
+				prop: rawKey,
+				nodeType: label,
+				validOptions: valid
+			});
+		}
+		validatePropValue(value, def.default, `${label}.${key}`);
+		target[key] = jsonClone(value);
+	}
+}
+/**
+* Instantiate a registered type, assign schema defaults (cloned), then the
+* given props — validating every key and its JSON kind against the default.
+*/
+function createNode(typeName, props) {
+	const ctor = getNodeType(typeName);
+	const node = new ctor();
+	applySchemaProps(node, getNodeSchema(typeName), props, typeName, mergeStaticAliases(ctor));
+	return node;
+}
+//#endregion
+export { getNodeSignals as a, mergeStaticSignals as c, getNodeSchema as i, registerNode as l, clearRegistry as n, getNodeType as o, createNode as r, mergeStaticProps as s, applySchemaProps as t, registeredTypes as u };

package/dist/rng-DP-SR7eg.js

@@ -0,0 +1,38 @@
+import { t as IncantoError } from "./errors-BpWbnbb_.js";
+//#region src/core/rng.ts
+/**
+* Deterministic seeded PRNG (mulberry32). Game logic should draw randomness
+* from `engine.rng` (or `this.rng` in a Behavior) instead of `Math.random()` —
+* a seeded engine then replays identically, which is what makes scripted
+* headless verification and multiplayer-adjacent determinism possible.
+*/
+var Rng = class {
+	state;
+	constructor(seed) {
+		this.state = seed >>> 0;
+		if (this.state === 0) this.state = 2654435769;
+	}
+	/** Next float in [0, 1). */
+	next() {
+		this.state = this.state + 1831565813 >>> 0;
+		let t = this.state;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	}
+	/** Float in [min, max). */
+	range(min, max) {
+		return min + this.next() * (max - min);
+	}
+	/** Integer in [min, max] — inclusive of BOTH bounds. */
+	int(min, max) {
+		return Math.floor(this.range(min, max + 1));
+	}
+	/** A uniformly random element. Empty arrays are a hard error. */
+	pick(items) {
+		if (items.length === 0) throw new IncantoError("BAD_FORMAT", "Rng.pick needs a non-empty array.");
+		return items[this.int(0, items.length - 1)];
+	}
+};
+//#endregion
+export { Rng as t };

package/dist/rolldown-runtime-D7D4PA-g.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/schema-CcoWb32N.d.ts

@@ -0,0 +1,104 @@
+//#region src/core/json.d.ts
+/** JSON-safe value types — the only types allowed in scene files and node props. */
+type JsonValue = string | number | boolean | null | JsonValue[] | JsonObject;
+interface JsonObject {
+  [key: string]: JsonValue;
+}
+type JsonKind = "string" | "number" | "boolean" | "null" | "array" | "object";
+declare function jsonKind(value: JsonValue): JsonKind;
+/** Deep structural equality over JSON values (used for delta-only serialization). */
+declare function jsonEquals(a: JsonValue, b: JsonValue): boolean;
+/**
+* Deep clone of JSON-safe data (defaults must never be shared between
+* instances). The value must contain only JSON types.
+*/
+declare function jsonClone<T>(value: T): T;
+//#endregion
+//#region src/core/rng.d.ts
+/**
+* Deterministic seeded PRNG (mulberry32). Game logic should draw randomness
+* from `engine.rng` (or `this.rng` in a Behavior) instead of `Math.random()` —
+* a seeded engine then replays identically, which is what makes scripted
+* headless verification and multiplayer-adjacent determinism possible.
+*/
+declare class Rng {
+  private state;
+  constructor(seed: number);
+  /** Next float in [0, 1). */
+  next(): number;
+  /** Float in [min, max). */
+  range(min: number, max: number): number;
+  /** Integer in [min, max] — inclusive of BOTH bounds. */
+  int(min: number, max: number): number;
+  /** A uniformly random element. Empty arrays are a hard error. */
+  pick<T>(items: readonly T[]): T;
+}
+//#endregion
+//#region src/core/scene/schema.d.ts
+/** Current scene file format version. Defaults are frozen per format version. */
+declare const SCENE_FORMAT: 1;
+interface SceneJson {
+  format: typeof SCENE_FORMAT;
+  type: "scene";
+  name: string;
+  dimension?: "2d" | "3d";
+  /** Asset declarations, keyed by stable human-readable keys referenced as `$key`. */
+  assets?: Record<string, JsonObject>;
+  /**
+  * Named, reusable typed values, keyed by stable name (e.g. `{ "UI": 1000 }`).
+  * A node prop may reference one as `{"@const": "NAME"}`; the loader replaces it
+  * with the literal value at load (see scene/constants.ts).
+  */
+  constants?: Record<string, JsonValue>;
+  /** Declarative input action map (loaded into Engine.input). */
+  input?: JsonObject;
+  /** Physics config — `{gravity: [x,y]}` (2D px/s²) or `{gravity: [x,y,z]}` (3D m/s²). */
+  physics?: JsonObject;
+  /** Multiplayer config (interpreted in M6; preserved verbatim until then). */
+  multiplayer?: JsonObject;
+  /** Scene-level rendering environment (ambient light, background — interpreted by renderers). */
+  environment?: JsonObject;
+  /**
+  * Design-resolution viewport: `{design: [w, h], fit: 'expand'|'letterbox'|'integer'}`.
+  * Author the world in fixed design px; the renderer maps them onto any canvas size.
+  */
+  viewport?: JsonObject;
+  root: NodeJson;
+  connections?: ConnectionJson[];
+}
+interface NodeJson {
+  name: string;
+  /** Optional scene-wide-unique stable id (addressable via getNodeByUid). */
+  uid?: string;
+  /** Registered node type. Mutually exclusive with `instance`. */
+  type?: string;
+  /** Sub-scene reference (resolved via `LoadSceneOptions.resolveScene`). */
+  instance?: string;
+  /** Deep-merged onto the instanced scene root's props. Only valid with `instance`. */
+  overrides?: JsonObject;
+  groups?: string[];
+  tags?: JsonObject;
+  /** Delta-only: values equal to the type's schema defaults are omitted. */
+  props?: JsonObject;
+  /** Behavior attachment (resolved in M5; preserved verbatim until then). */
+  script?: JsonObject;
+  /** Replication config (resolved in M6; preserved verbatim until then). */
+  network?: JsonObject;
+  children?: NodeJson[];
+}
+interface ConnectionJson {
+  signal: string;
+  /** NodePath relative to the scene root ('.' = the root itself). */
+  from: string;
+  to: string;
+  /** Method name on the target node (or its behavior, once M5 lands). */
+  handler: string;
+  once?: boolean;
+  /** Only fire when the first emitted arg is a Node matching the filter. */
+  filter?: {
+    group?: string;
+    tag?: JsonObject;
+  };
+}
+//#endregion
+export { Rng as a, JsonValue as c, jsonKind as d, SceneJson as i, jsonClone as l, NodeJson as n, JsonKind as o, SCENE_FORMAT as r, JsonObject as s, ConnectionJson as t, jsonEquals as u };