incanto 0.69.0 → 0.71.0

package/dist/{replay-BEHLDcQV.js → replay-DEvp3kyV.js}

@@ -1,7 +1,23 @@
-import { D as handlerShadowWarnings, j as nodeRefWarnings } from "./loader-DZE7B07H.js";
-import { R as translationKey, k as HudWidgetBase } from "./register-mmfugpaQ.js";
-import { o as getNodeType } from "./registry-CF70EArN.js";
+import { L as handlerShadowWarnings, R as sceneDimension, V as HudWidgetBase, Z as nodeRefWarnings } from "./save-slots-Bvuh2p_r.js";
+import { N as translationKey } from "./register-DuVdzxbq.js";
+import { t as IncantoError } from "./errors-BpWbnbb_.js";
+import { u as getNodeType } from "./touch-BnCyPA0G.js";
 //#region src/core/audit.ts
+/**
+* Behaviours whose ENTIRE observable effect is the signals they emit.
+*
+* Membership is the claim, so it is written down rather than guessed: a
+* behaviour belongs here only if attaching it and wiring none of its signals
+* leaves the game bit-identical. `Clickable` qualifies — it picks, it hovers,
+* and it tells you; it changes nothing itself. `Pickup` does not (it frees
+* itself), nor does `Health` (it holds the number), nor `Interactable` (it
+* gates on range and shows a prompt).
+*/
+const SIGNAL_ONLY = new Map([["Clickable", [
+	"clicked",
+	"hovered",
+	"unhovered"
+]]]);
 const ANIMATED_TYPES = new Set([
 	"Particles2D",
 	"Particles3D",
@@ -48,11 +64,14 @@ function isHudWidget(type) {
 	}
 	return false;
 }
-const LIGHT_TYPES = new Set([
-	"DirectionalLight3D",
-	"OmniLight3D",
-	"SpotLight3D"
+/** The node types that auto-find a terrain when their `terrain` path is empty. */
+const DRAPERS = new Set([
+	"Foliage3D",
+	"Flowers3D",
+	"Tree3D",
+	"River3D"
 ]);
+const LIGHT_TYPES = new Set(["DirectionalLight3D", "OmniLight3D"]);
 /**
 * Nodes whose gameplay answer comes from a CPU twin built out of `size`.
 *
@@ -62,6 +81,7 @@ const LIGHT_TYPES = new Set([
 */
 const WORLD_QUERY_TYPES = new Set([
 	"Terrain3D",
+	"TileMap2D",
 	"Water3D",
 	"River3D"
 ]);
@@ -74,11 +94,21 @@ const WORLD_QUERY_TYPES = new Set([
 * A JSON walk cannot ask a behavior whether it serializes, so this is the list
 * of the ones that do. Your own behavior with a `serialize()` is caught at
 * runtime instead, by `captureState`.
+*
+* It is a CLOSED list beside an OPEN one — every engine `Behavior` overriding
+* `serialize()` — and it drifted: `Currency` (a game's money) and `SavePoint`
+* (how long the run has been going) both saved, and both audited clean on a
+* node with no uid. `saveable-scripts.test.ts` reads the sources and fails when
+* the two lists disagree again.
 */
 const SAVEABLE_SCRIPTS = new Set([
+	"Collector",
+	"Currency",
+	"DayNight",
 	"Health",
+	"SavePoint",
 	"ScoreKeeper",
-	"Collector"
+	"WaveSpawner"
 ]);
 /** Does the scene header light anything by itself (sky, hdri, ambient, preset)? */
 function isLit(environment) {
@@ -123,7 +153,7 @@ function instancedScenes(corpus, resolveRef) {
 		if (typeof ref === "string" && ref) instanced.add(resolveRef(from, ref));
 		for (const child of node.children ?? []) walk(child, from);
 	};
-	for (const { path, json } of corpus) walk(json.root, path);
+	for (const { path, json } of corpus) walk(json?.root, path);
 	return instanced;
 }
 function auditScene(scene, opts = {}) {
@@ -135,10 +165,15 @@ function auditScene(scene, opts = {}) {
 	let lights = 0;
 	/** Nodes that drive the current camera themselves — see the warning below. */
 	const cameraDrivers = [];
+	const terrains = [];
+	const autoDrapers = [];
 	const followedCameras = [];
 	const needUid = [];
 	/** Every `DamageOnContact.targetGroup` in the scene, with the node that set it. */
 	const damageGroups = [];
+	/** Nodes whose script produces NOTHING but signals — see `SIGNAL_ONLY`. */
+	const silentSignals = [];
+	const groupRefs = [];
 	const walk = (node, path, insideHud, staticRoot, transformed) => {
 		const type = node.type ?? "";
 		const props = node.props ?? {};
@@ -155,8 +190,14 @@ function auditScene(scene, opts = {}) {
 			if (script === "FollowCamera") followedCameras.push(path);
 		}
 		if (type === "CharacterController3D") cameraDrivers.push(path);
+		if (type === "Terrain3D") terrains.push(path);
+		if (DRAPERS.has(type) && (props.terrain ?? "") === "") autoDrapers.push(path);
 		if (LIGHT_TYPES.has(type)) lights += 1;
 		if (BODY_TYPES.has(type) && transformed) warnings.push(`${path}: ${type} sits under '${transformed.path}', whose ${transformed.what} physics cannot compose — the collider will not line up with what is drawn. Keep body ancestors untransformed or translation-only, or put the body outside them.`);
+		if (script && SIGNAL_ONLY.has(script)) silentSignals.push({
+			path,
+			script
+		});
 		if (script === "DamageOnContact") {
 			const group = (node.script?.props)?.targetGroup;
 			if (typeof group === "string" && group !== "") damageGroups.push({
@@ -164,6 +205,15 @@ function auditScene(scene, opts = {}) {
 				group
 			});
 		}
+		for (const [name, prop] of [["Pickup", "collectorGroup"], ["Collector", "group"]]) {
+			if (script !== name) continue;
+			const group = (node.script?.props)?.[prop];
+			if (typeof group === "string" && group !== "") groupRefs.push({
+				path,
+				group,
+				what: `${name}.${prop}`
+			});
+		}
 		if (WORLD_QUERY_TYPES.has(type) && transformed) warnings.push(`${path}: ${type} sits under '${transformed.path}', whose ${transformed.what} it cannot compose — the ground (or water) you can see would not be the ground you can stand on. Keep its ancestors untransformed or translation-only.`);
 		if (BODY_TYPES.has(type)) {
 			const collider = props.collider;
@@ -185,22 +235,52 @@ function auditScene(scene, opts = {}) {
 		what: transformOf(root.props ?? {})
 	} : null);
 	if (needUid.length > 0) warnings.push(`these carry state a save keeps and have no uid to key it under, so the save comes back EMPTY and the load reports no problem: ${needUid.join(", ")}. Give each one a "uid" from newUid().`);
+	if (terrains.length > 1 && autoDrapers.length > 0) warnings.push(`${autoDrapers.join(", ")}: this scene has ${terrains.length} Terrain3Ds (${terrains.join(", ")}) and these do not say which one they grow on — with no \`terrain\` path they take the FIRST one in the tree, so the rest drape to the wrong height with nothing reported. Name it: "terrain": "%Name".`);
+	if (cameraDrivers.length > 1) warnings.push(`${cameraDrivers.join(", ")}: ${cameraDrivers.length} CharacterController3Ds drive the SAME camera (each one finds the first \`current\` camera in the tree), so the last of them wins every frame and the others have no view. For local co-op give each player a panel with \`createSplitScreen\` (one engine each); otherwise only one node may carry a controller.`);
 	if (cameraDrivers.length > 0 && followedCameras.length > 0) warnings.push(`${followedCameras.join(", ")}: a FollowCamera writes this camera's position every frame, and so does the CharacterController3D at ${cameraDrivers.join(", ")} — the controller owns the camera in every view it has. Drop one of them: use the controller's own \`view\`/\`camDistance\`, or take the controller off the camera duty.`);
 	if (cameras > 0 && currentCameras === 0) warnings.push("no camera has \"current\": true — the screen renders from a default view, probably not what you framed.");
 	if (currentCameras > 1) warnings.push(`${currentCameras} cameras claim "current": true — only the first found wins.`);
 	const isFragment = opts.instanced === true || scene.fragment === true;
-	if (scene.dimension === "3d" && !isFragment && cameras === 0) warnings.push("this 3D scene has no camera — the screen renders from a default view, which is almost never the shot you want. Add a Camera3D with \"current\": true, or set \"fragment\": true in the scene header if this file is a prefab another scene drops in.");
-	if (scene.dimension === "3d" && !isFragment && lights === 0 && !isLit(scene.environment)) warnings.push("nothing lights this 3D scene — no light node, no environment sky/hdri, and no ambient intensity. It will render black. Add a DirectionalLight3D, or an \"environment\": { \"sky\": { \"type\": \"atmosphere\" } } / { \"preset\": \"...\" } — or set \"fragment\": true if another scene lights this one.");
+	const is3d = sceneDimension(scene) === "3d";
+	if (is3d && !isFragment && cameras === 0) warnings.push("this 3D scene has no camera — the screen renders from a default view, which is almost never the shot you want. Add a Camera3D with \"current\": true, or set \"fragment\": true in the scene header if this file is a prefab another scene drops in.");
+	if (is3d && !isFragment && lights === 0 && !isLit(scene.environment)) warnings.push("nothing lights this 3D scene — no light node, no environment sky/hdri, and no ambient intensity. It will render black. Add a DirectionalLight3D, or an \"environment\": { \"sky\": { \"type\": \"atmosphere\" } } / { \"preset\": \"...\" } — or set \"fragment\": true if another scene lights this one.");
+	if (silentSignals.length > 0) {
+		const heard = /* @__PURE__ */ new Set();
+		for (const conn of scene.connections ?? []) if (typeof conn.from === "string") heard.add(conn.from);
+		for (const { path, script } of silentSignals) {
+			const relative = path.slice(path.indexOf("/") + 1);
+			if (heard.has(relative) || heard.has(path) || heard.has(`/root/${relative}`)) continue;
+			const signals = SIGNAL_ONLY.get(script) ?? [];
+			warnings.push(`${path}: ${script} produces nothing but ${signals.map((x) => `'${x}'`).join("/")}, and no connection listens to any of them — so it can never do anything. Wire one, or listen in code with \`node.on('${signals[0]}', …)\`.`);
+		}
+	}
 	if (damageGroups.length > 0) {
 		const hurtable = hurtableGroups(root);
 		for (const { path, group } of damageGroups) {
 			if (hurtable.has(group)) continue;
-			warnings.push(`${path}: DamageOnContact targets group '${group}', and nothing in this scene both carries a Health and is in that group — so this hazard can never damage anything. Groups that CAN be hurt here: [${[...hurtable].join(", ") || "none"}].`);
+			warnings.push(isFragment ? `${path}: DamageOnContact targets group '${group}', and no Health in THIS file is in that group — fine if the target lives in the host scene, a typo otherwise. Groups hurtable here: [${[...hurtable].join(", ") || "none"}].` : `${path}: DamageOnContact targets group '${group}', and nothing in this scene both carries a Health and is in that group — so this hazard can never damage anything. Groups that CAN be hurt here: [${[...hurtable].join(", ") || "none"}].`);
+		}
+	}
+	for (const { filter } of scene.connections ?? []) {
+		const group = filter?.group;
+		if (typeof group === "string" && group !== "") groupRefs.push({
+			path: "connections",
+			group,
+			what: "filter.group"
+		});
+	}
+	if (groupRefs.length > 0) {
+		const present = groupsInScene(root);
+		for (const { path, group, what } of groupRefs) {
+			if (present.has(group)) continue;
+			warnings.push(`${path}: ${what} names group '${group}', and no node in this scene is in it — so this never fires. Groups that exist here: [${[...present].join(", ") || "none"}].`);
 		}
 	}
-	for (const warning of nodeRefWarnings(scene)) warnings.push(warning);
+	for (const warning of nodeRefWarnings(scene, { fragment: isFragment })) warnings.push(warning);
 	for (const warning of handlerShadowWarnings(scene)) warnings.push(warning);
 	for (const warning of auditStrings(scene, opts.declaredElsewhere)) warnings.push(warning);
+	for (const warning of auditInputBindings(scene)) warnings.push(warning);
+	for (const warning of auditKeyHints(scene, root)) warnings.push(warning);
 	return warnings;
 }
 /**
@@ -216,6 +296,16 @@ function auditScene(scene, opts = {}) {
 * end), but the shape generalises: a hazard whose `targetGroup` nothing can
 * satisfy is wired, validated, and disarmed, and every check comes back green.
 */
+/** Every group any node in the scene is in — the set a group REFERENCE can hit. */
+function groupsInScene(root) {
+	const out = /* @__PURE__ */ new Set();
+	const walk = (node) => {
+		for (const g of node.groups ?? []) out.add(g);
+		for (const child of node.children ?? []) walk(child);
+	};
+	walk(root);
+	return out;
+}
 function hurtableGroups(root) {
 	const out = /* @__PURE__ */ new Set();
 	const hasHealth = (node) => node.script?.name === "Health" || (node.children ?? []).some(hasHealth);
@@ -291,6 +381,125 @@ function auditStrings(scene, elsewhere) {
 	}
 	return out;
 }
+/**
+* One physical key, two actions.
+*
+* Found in the shipped `tps-3d` starter: `reload` and `restart` were both
+* `KeyR`. Pressing R reloaded, because `restart` was never read by anything —
+* the collision and the dead binding hid each other, and neither is visible to
+* a loader that validates each action's own shape.
+*
+* A warning rather than an error: two actions on one key are legal and
+* sometimes deliberate (an `interact` that also advances a dialogue), which is
+* why the message says what will happen rather than refusing to load.
+*/
+function auditInputBindings(scene) {
+	const input = scene.input;
+	if (!input || typeof input !== "object" || Array.isArray(input)) return [];
+	const byKey = /* @__PURE__ */ new Map();
+	const add = (code, action) => {
+		if (typeof code !== "string" || code === "") return;
+		const list = byKey.get(code) ?? [];
+		if (!list.includes(action)) list.push(action);
+		byKey.set(code, list);
+	};
+	for (const [action, decl] of Object.entries(input)) {
+		if (!decl || typeof decl !== "object" || Array.isArray(decl)) continue;
+		const keys = decl.keys;
+		if (Array.isArray(keys)) for (const code of keys) add(code, action);
+		else if (keys && typeof keys === "object") {
+			for (const codes of Object.values(keys)) if (Array.isArray(codes)) for (const code of codes) add(code, action);
+		}
+	}
+	const out = [];
+	for (const [code, actions] of byKey) {
+		if (actions.length < 2) continue;
+		out.push(`input: '${code}' is bound to ${actions.map((a) => `'${a}'`).join(" and ")} — both fire on the same press, so whichever one your code reads first wins and the other looks broken. Give one of them its own key.`);
+	}
+	return out;
+}
+/**
+* How a HUD line spells a key, and how `input{}` spells the same key.
+*
+* Only the ones a player would ever type in a hint. A miss here is silence, not
+* a false alarm: the check needs BOTH ends to be recognisable before it says
+* anything.
+*/
+const KEY_WORDS = {
+	esc: ["Escape"],
+	escape: ["Escape"],
+	enter: ["Enter", "NumpadEnter"],
+	return: ["Enter"],
+	space: ["Space"],
+	tab: ["Tab"],
+	shift: ["ShiftLeft", "ShiftRight"],
+	ctrl: ["ControlLeft", "ControlRight"],
+	alt: ["AltLeft", "AltRight"]
+};
+/** Every key code an action binds, however the declaration is shaped. */
+function keysOfAction(decl) {
+	if (!decl || typeof decl !== "object" || Array.isArray(decl)) return [];
+	const keys = decl.keys;
+	if (Array.isArray(keys)) return keys.filter((k) => typeof k === "string");
+	if (keys && typeof keys === "object") {
+		const out = [];
+		for (const codes of Object.values(keys)) if (Array.isArray(codes)) {
+			for (const c of codes) if (typeof c === "string") out.push(c);
+		}
+		return out;
+	}
+	return [];
+}
+/**
+* A HUD line that tells the player a key the input map does not bind.
+*
+* `tps-3d`'s pause menu read `Esc to resume · R to restart` for exactly three
+* hours after `restart` was moved off `KeyR` (which `reload` already owned) —
+* the binding moved and the sentence about it did not, which is the whole
+* failure mode of any fact written down twice.
+*
+* Deliberately narrow. It fires only when a hint names BOTH a key this table
+* knows and a word that is a DECLARED ACTION in the same scene, so "Esc to
+* resume" says nothing (there is no `resume` action) and prose about a "T shape"
+* says nothing. What is left is the case where the scene itself contains both
+* halves and they disagree.
+*/
+function auditKeyHints(scene, root) {
+	const input = scene.input;
+	if (!input || typeof input !== "object" || Array.isArray(input)) return [];
+	const actions = input;
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	const check = (path, text) => {
+		for (const m of text.matchAll(/\b([A-Za-z]{1,6})\s+to\s+([a-z]+)\b/g)) {
+			const word = (m[1] ?? "").toLowerCase();
+			const action = m[2] ?? "";
+			if (!(action in actions)) continue;
+			const wanted = KEY_WORDS[word] ?? (word.length === 1 ? [`Key${word.toUpperCase()}`] : null);
+			if (!wanted) continue;
+			const bound = keysOfAction(actions[action]);
+			if (bound.length === 0 || wanted.some((k) => bound.includes(k))) continue;
+			const line = `${path}: says "${m[0]}", and '${action}' is bound to [${bound.join(", ")}]`;
+			if (seen.has(line)) continue;
+			seen.add(line);
+			out.push(`${line} — the HUD is telling the player a key that does something else. Rebind the action, or fix the line.`);
+		}
+	};
+	const walk = (node, path) => {
+		const props = node.props ?? {};
+		for (const key of [
+			"text",
+			"format",
+			"label"
+		]) {
+			const value = props[key];
+			if (typeof value === "string" && value !== "") check(`${path}.${key}`, value);
+		}
+		for (const child of node.children ?? []) walk(child, `${path}/${child.name ?? "?"}`);
+	};
+	walk(root, `/${root.name ?? "?"}`);
+	return out;
+}
 //#endregion
 //#region src/core/replay.ts
 /**
@@ -377,7 +586,8 @@ function replay(engine, recording, opts) {
 		}
 		const at = recording.ticks[i];
 		if (at === null) engine.step();
-		else engine.tick(at);
+		else if (typeof at === "number" && Number.isFinite(at)) engine.tick(at);
+		else throw new IncantoError("BAD_FORMAT", `Replay tick ${i} is ${JSON.stringify(at)}, not a timestamp. A recording holds a finite millisecond value per frame, or null for a frame driven by step().`);
 		opts?.onTick?.(i);
 	}
 }

package/dist/{replay-BQfkX4x7.d.ts → replay-F7IZHdFR.d.ts}

@@ -1,5 +1,5 @@
-import { b as Engine } from "./behavior-rm8vVzu_.js";
-import { s as JsonObject } from "./schema-B6ugCV1Q.js";
+import { b as Engine } from "./behavior-Dcz0fr1S.js";
+import { s as JsonObject } from "./rng-Bb-IutXB.js";
 
 //#region src/core/audit.d.ts
 /** Human-readable warnings (empty = clean). Pure JSON walk, no registry. */
@@ -59,7 +59,7 @@ declare function auditScene(scene: JsonObject, opts?: AuditOptions): string[];
 * Incanto fails loudly with machine-readable codes and messages that list valid
 * alternatives — AI agents self-correct on hard failures, not warnings.
 */
-type IncantoErrorCode = "AMBIGUOUS_HANDLER" | "BAD_FORMAT" | "BAD_NODE_PATH" | "DANGLING_CONNECTION" | "DUPLICATE_BEHAVIOR" | "DUPLICATE_NODE_TYPE" | "DUPLICATE_UNIQUE_NAME" | "DUPLICATE_UID" | "NODE_NOT_FOUND" | "PROP_TYPE_MISMATCH" | "TREE_VIOLATION" | "UNKNOWN_ANIMATION" | "UNKNOWN_ASSET" | "UNKNOWN_CONSTANT" | "UNKNOWN_BEHAVIOR" | "UNKNOWN_HANDLER" | "UNKNOWN_NODE_TYPE" | "UNKNOWN_PROP" | "UNKNOWN_SIGNAL" | "UNRESOLVED_INSTANCE" | "WEBGL_UNAVAILABLE";
+type IncantoErrorCode = "AMBIGUOUS_HANDLER" | "BAD_FORMAT" | "BAD_NODE_PATH" | "DANGLING_CONNECTION" | "DUPLICATE_BEHAVIOR" | "DUPLICATE_NODE_TYPE" | "DUPLICATE_UNIQUE_NAME" | "DUPLICATE_UID" | "NETWORK_UNAVAILABLE" | "NODE_NOT_FOUND" | "PROP_TYPE_MISMATCH" | "TREE_VIOLATION" | "UNKNOWN_ANIMATION" | "UNKNOWN_ASSET" | "UNKNOWN_CONSTANT" | "UNKNOWN_BEHAVIOR" | "UNKNOWN_HANDLER" | "UNKNOWN_NODE_TYPE" | "UNKNOWN_PROP" | "UNKNOWN_SIGNAL" | "UNRESOLVED_INSTANCE" | "WEBGL_UNAVAILABLE";
 /**
 * Structured context mirrored from the prose message — tools and agents parse
 * THESE instead of regexing the message (which is for humans and may reword).
@@ -115,6 +115,23 @@ interface ReplayJson {
   */
   ticks: Array<number | null>;
   events: ReplayEvent[];
+  /**
+  * WHICH GAME this is a recording of — optional, and stamped by the tools.
+  *
+  * `.incanto/playtest` is keyed only by `(outcome, seed)` and never cleaned, so
+  * the second playtest in a project either left a stale replay of a scene that
+  * no longer exists beside the current one, or silently overwrote another
+  * scene's. Nothing downstream could tell: `incanto-play --commands` accepted
+  * any recording against any scene and reported success.
+  *
+  * Absent on an older recording, which still replays — this identifies, it
+  * does not gate.
+  */
+  scene?: {
+    /** The scene file this was recorded against, as the tool was given it. */path?: string; /** The scene's own `name`, which survives the file being moved. */
+    name?: string; /** The engine that recorded it, so a replay across a format change reads odd. */
+    engine?: string;
+  };
 }
 interface Recorder {
   /** Detach the taps and return the recording. */

package/dist/{schema-B6ugCV1Q.d.ts → rng-Bb-IutXB.d.ts}

@@ -14,26 +14,6 @@ declare function jsonEquals(a: JsonValue, b: JsonValue): boolean;
 */
 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;
@@ -132,4 +112,41 @@ interface ConnectionJson {
   };
 }
 //#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 };
+//#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;
+  /**
+  * Where this stream has got to.
+  *
+  * A save that cannot carry this replays the seeded sequence from the top, so
+  * every "random" event after a load is the one the run opened with. Measured:
+  *
+  * ```
+  * continue WITHOUT save/load: rolls 10-13 = 0.2967 0.0860 0.7333 0.0400
+  * continue AFTER  save/load : rolls 10-13 = 0.5628 0.3253 0.4690 0.8367
+  * ```
+  *
+  * and 0.5628 is not merely different — it is the FIRST roll a fresh run of
+  * that game makes. The state was private, so a game could not fix it either:
+  * `serialize()` had nothing to carry.
+  */
+  get position(): number;
+  set position(value: number);
+  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
+export { SceneJson as a, JsonValue as c, jsonKind as d, SCENE_FORMAT as i, jsonClone as l, ConnectionJson as n, JsonKind as o, NodeJson as r, JsonObject as s, Rng as t, jsonEquals as u };

package/dist/{rng-DP-SR7eg.js → rng-CDOMybym.js}

@@ -8,6 +8,28 @@ import { t as IncantoError } from "./errors-BpWbnbb_.js";
 */
 var Rng = class {
 	state;
+	/**
+	* Where this stream has got to.
+	*
+	* A save that cannot carry this replays the seeded sequence from the top, so
+	* every "random" event after a load is the one the run opened with. Measured:
+	*
+	* ```
+	* continue WITHOUT save/load: rolls 10-13 = 0.2967 0.0860 0.7333 0.0400
+	* continue AFTER  save/load : rolls 10-13 = 0.5628 0.3253 0.4690 0.8367
+	* ```
+	*
+	* and 0.5628 is not merely different — it is the FIRST roll a fresh run of
+	* that game makes. The state was private, so a game could not fix it either:
+	* `serialize()` had nothing to carry.
+	*/
+	get position() {
+		return this.state >>> 0;
+	}
+	set position(value) {
+		const next = value >>> 0;
+		this.state = next === 0 ? 2654435769 : next;
+	}
 	constructor(seed) {
 		this.state = seed >>> 0;
 		if (this.state === 0) this.state = 2654435769;