@weasel-js/core 1.10.0 → 1.11.0

package/dist/core/scene/recorder.js

@@ -1,86 +1,119 @@
-import { bindOpToAdapter as e } from "./boundOps.js";
+import { bindOpToAdapter } from "./boundOps.js";
+
 //#region src/core/scene/recorder.ts
-function t(e) {
-	for (let t = e.length - 1; t >= 0; t--) try {
-		e[t].invert().apply(void 0);
+/** Take back ops that wrote outside the scene, newest first. The scene's own
+*  writes are reverted by the applied log. */
+function unwind(outer) {
+	for (let i = outer.length - 1; i >= 0; i--) try {
+		outer[i].invert().apply(void 0);
 	} catch {}
 }
-function n(n) {
-	let { notifier: r, mode: i, engine: a, log: o, arrivals: s } = n, c = null, l = null;
-	function u(e, t) {
-		let r = e();
-		if (t) for (let e of s.settle()) n.writePose(e.id, e.to);
-		return r;
+function createRecorder(env) {
+	const { notifier, mode, engine, log, arrivals } = env;
+	/** The outermost open batch, while it is recording. */
+	let collecting = null;
+	/** The kit ops applied since the innermost `capturing` opened. */
+	let captured = null;
+	/** `fn`, then the poses its arrivals settle to when this edit owns them. */
+	function withArrivalsSettled(fn, owns) {
+		const result = fn();
+		if (owns) for (const p of arrivals.settle()) env.writePose(p.id, p.to);
+		return result;
 	}
-	function d(e, l) {
-		let d = !i.open();
-		d && (c = {
-			label: e,
+	function batch(label, fn) {
+		const outermost = !mode.open();
+		if (outermost) collecting = {
+			label,
 			ops: [],
 			outer: [],
-			selectionBefore: n.selection()
-		});
-		let f = d && s.open(!0);
-		return r.deferred(() => i.during("batch", () => {
-			if (!d) return l();
+			selectionBefore: env.selection()
+		};
+		const ownsArrivals = outermost && arrivals.open(true);
+		return env.labeled(label, "call", () => notifier.deferred(() => mode.during("batch", () => {
+			if (!outermost) return fn();
 			try {
-				let e = o.atomically(() => u(l, f), () => (c?.ops.length ?? 0) > 0);
-				return f && s.emitReflow(), e;
-			} catch (e) {
-				throw t(c?.outer ?? []), c = null, e;
+				const result = log.atomically(() => withArrivalsSettled(fn, ownsArrivals), () => (collecting?.ops.length ?? 0) > 0);
+				if (ownsArrivals) arrivals.emitReflow();
+				return result;
+			} catch (err) {
+				unwind(collecting?.outer ?? []);
+				collecting = null;
+				throw err;
 			}
 		}), () => {
-			if (f && s.abandon(), !d || !c) return;
-			let e = c;
-			c = null, e.ops.length > 0 && a.recordEntry(e.ops, e.label, { selectionBefore: e.selectionBefore });
-		});
+			if (ownsArrivals) arrivals.abandon();
+			if (!outermost || !collecting) return;
+			const finished = collecting;
+			collecting = null;
+			if (finished.ops.length > 0) engine.recordEntry(finished.ops, finished.label, { selectionBefore: finished.selectionBefore });
+		}));
 	}
 	return {
-		record(e, t, s) {
-			i.records() && !c ? i.during("own", () => a.applyOps([n.makeOp(e, t)], s)) : (n.runOp(e, t), o.logApplied(e, t), i.records() ? c.ops.push(n.makeOp(e, t)) : i.untracked() || l?.push(n.makeOp(e, t))), r.notify();
+		record(kind, payload, label) {
+			env.labeled(label, "call", () => {
+				if (mode.records() && !collecting) mode.during("own", () => engine.applyOps([env.makeOp(kind, payload)], label));
+				else {
+					env.runOp(kind, payload);
+					log.logApplied(kind, payload);
+					if (mode.records()) collecting.ops.push(env.makeOp(kind, payload));
+					else if (!mode.untracked()) captured?.push(env.makeOp(kind, payload));
+				}
+			});
+			notifier.notify();
 		},
-		edit: (e, t, n) => t && s.bareLayoutEdit() ? d(e, n) : n(),
-		batch: d,
-		untracked(e) {
-			let t = r.version(), n = s.open(!0);
-			return r.deferred(() => i.during("untracked", () => {
-				let t = o.atomically(() => u(e, n), () => !1);
-				return n && s.emitReflow(), t;
+		edit: (label, touchesLayout, fn) => touchesLayout && arrivals.bareLayoutEdit() ? batch(label, fn) : fn(),
+		batch,
+		untracked(fn) {
+			const versionBefore = notifier.version();
+			const ownsArrivals = arrivals.open(true);
+			return notifier.deferred(() => mode.during("untracked", () => {
+				const result = log.atomically(() => withArrivalsSettled(fn, ownsArrivals), () => false);
+				if (ownsArrivals) arrivals.emitReflow();
+				return result;
 			}), () => {
-				n && s.abandon(), r.version() !== t && a.seal();
+				if (ownsArrivals) arrivals.abandon();
+				if (notifier.version() !== versionBefore) engine.seal();
 			});
 		},
-		joins: () => i.records() && c !== null,
-		join(n, r) {
-			let i = c, a = i.ops.length, s = [];
+		joins: () => mode.records() && collecting !== null,
+		join(ops, adapter) {
+			const into = collecting;
+			const mark = into.ops.length;
+			const outer = [];
 			try {
-				o.atomically(() => {
-					for (let t of n) {
-						let n = i.ops.length, a = t.apply(r);
-						i.ops.length > n || a === !1 || a === "noop" || (s.push(e(t, r)), i.ops.push(s[s.length - 1]));
+				log.atomically(() => {
+					for (const op of ops) {
+						const before = into.ops.length;
+						const result = op.apply(adapter);
+						if (into.ops.length > before || result === false || result === "noop") continue;
+						outer.push(bindOpToAdapter(op, adapter));
+						into.ops.push(outer[outer.length - 1]);
 					}
-				}, () => !1);
-			} catch (e) {
-				throw t(s), i.ops.length = a, e;
+				}, () => false);
+			} catch (err) {
+				unwind(outer);
+				into.ops.length = mark;
+				throw err;
 			}
-			i.outer.push(...s);
+			into.outer.push(...outer);
 		},
-		capturing(e) {
-			let t = l, n = [];
-			l = n;
+		capturing(step) {
+			const enclosing = captured;
+			const ops = [];
+			captured = ops;
 			try {
 				return {
-					result: e(),
-					ops: n
+					result: step(),
+					ops
 				};
 			} finally {
-				l = t;
+				captured = enclosing;
 			}
 		},
-		engineDriven: (e) => i.during("engine", () => r.muted(e))
+		engineDriven: (fn) => mode.during("engine", () => notifier.muted(fn))
 	};
 }
-//#endregion
-export { n as createRecorder };
 
+//#endregion
+export { createRecorder };
 //# sourceMappingURL=recorder.js.map

package/dist/core/scene/recorder.js.map

@@ -1 +1 @@
-{"version":3,"file":"recorder.js","names":["unwind","i","outer","createRecorder","env","collecting","captured","withArrivalsSettled","result","fn","owns","p","arrivals","batch","outermost","mode","ownsArrivals","notifier","log","err","finished","engine","kind","payload","label","touchesLayout","versionBefore","into","mark","op","ops","before","adapter","bindOpToAdapter","enclosing","step"],"sources":["../../../src/core/scene/recorder.ts"],"sourcesContent":["/**\n * How a scene mutation becomes an undo entry: recorded on its own, collected\n * into the batch it runs in, or left to the engine or the untracked run that\n * is driving it.\n */\nimport type { History } from '@weasel-js/history';\nimport type { Op } from 'core/ops/types';\nimport type { AppliedLog } from './appliedLog';\nimport type { ArrivalWindow } from './arrivalWindow';\nimport { bindOpToAdapter } from './boundOps';\nimport type { EditMode } from './editMode';\nimport type { Notifier } from './notifier';\nimport type { NodeId } from './types';\n\n/** What the recorder needs from the scene it records for. */\nexport interface RecorderEnv {\n  notifier: Notifier;\n  mode: EditMode;\n  /** The scene's own undo/redo engine. */\n  engine: History;\n  /** Apply a registered op's forward half. */\n  runOp(kind: string, payload: unknown): void;\n  /** A registered op as the engine holds it. */\n  makeOp(kind: string, payload: unknown): Op;\n  log: AppliedLog;\n  arrivals: Pick<ArrivalWindow<unknown>, 'bareLayoutEdit' | 'open' | 'settle' | 'emitReflow' | 'abandon'>;\n  selection(): readonly NodeId[];\n  /** Write one pose an arrival settle decided. */\n  writePose(id: string, pose: unknown): void;\n}\n\nexport interface Recorder {\n  /** Apply a registered op as part of whatever edit is running. */\n  record(kind: string, payload: unknown, label: string): void;\n  /** Run the recording half of a mutation. One that touches a laid-out\n   *  container, called bare, runs as a batch of its own: that is what puts\n   *  the arrangement it triggers in the same undo step. */\n  edit<T>(label: string, touchesLayout: boolean, fn: () => T): T;\n  batch<T>(label: string, fn: () => T): T;\n  untracked<T>(fn: () => T): T;\n  /** Whether an edit made now would join an open `batch`'s entry. */\n  joins(): boolean;\n  /** Apply ops built outside the scene as part of the open `batch`, all or\n   *  none. Its entry holds the kit ops they cause, and beside them, bound to\n   *  `adapter`, any op that wrote no scene state. */\n  join(ops: Op[], adapter: unknown): void;\n  /** Run `step`, and answer with the kit ops applied during it. */\n  capturing<T>(step: () => T): { result: T; ops: Op[] };\n  /** Run `fn` as a history engine's step: the ops it applies may re-enter\n   *  scene mutation methods, which apply but do not record. The caller\n   *  notifies once after. */\n  engineDriven<T>(fn: () => T): T;\n}\n\n/** Take back ops that wrote outside the scene, newest first. The scene's own\n *  writes are reverted by the applied log. */\nfunction unwind(outer: readonly Op[]): void {\n  for (let i = outer.length - 1; i >= 0; i--) {\n    try {\n      outer[i].invert().apply(undefined);\n    } catch {\n      // The throw being unwound is the one the caller sees.\n    }\n  }\n}\n\nexport function createRecorder(env: RecorderEnv): Recorder {\n  const { notifier, mode, engine, log, arrivals } = env;\n  /** The outermost open batch, while it is recording. */\n  let collecting: { label: string; ops: Op[]; outer: Op[]; selectionBefore: readonly NodeId[] } | null = null;\n  /** The kit ops applied since the innermost `capturing` opened. */\n  let captured: Op[] | null = null;\n\n  /** `fn`, then the poses its arrivals settle to when this edit owns them. */\n  function withArrivalsSettled<T>(fn: () => T, owns: boolean): T {\n    const result = fn();\n    if (owns) for (const p of arrivals.settle()) env.writePose(p.id, p.to);\n    return result;\n  }\n\n  function batch<T>(label: string, fn: () => T): T {\n    const outermost = !mode.open();\n    // Captured at open, not at recordEntry: by the time the batch closes\n    // the selection has already moved to wherever the batch put it.\n    if (outermost) collecting = { label, ops: [], outer: [], selectionBefore: env.selection() };\n    const ownsArrivals = outermost && arrivals.open(true);\n    return notifier.deferred(() => mode.during('batch', () => {\n      if (!outermost) return fn();\n      try {\n        const result = log.atomically(\n          () => withArrivalsSettled(fn, ownsArrivals),\n          () => (collecting?.ops.length ?? 0) > 0,\n        );\n        if (ownsArrivals) arrivals.emitReflow();\n        return result;\n      } catch (err) {\n        // Reverted already; the half-built entry must not reach history.\n        unwind(collecting?.outer ?? []);\n        collecting = null;\n        throw err;\n      }\n    }), () => {\n      if (ownsArrivals) arrivals.abandon();\n      if (!outermost || !collecting) return;\n      const finished = collecting;\n      collecting = null;\n      // The ops were applied as they were issued, so the entry is pushed\n      // without re-applying.\n      if (finished.ops.length > 0) {\n        engine.recordEntry(finished.ops, finished.label, { selectionBefore: finished.selectionBefore });\n      }\n    });\n  }\n\n  return {\n    record(kind, payload, label) {\n      if (mode.records() && !collecting) {\n        // The engine applies the op itself, which is what lets it coalesce.\n        mode.during('own', () => engine.applyOps([env.makeOp(kind, payload)], label));\n      } else {\n        env.runOp(kind, payload);\n        log.logApplied(kind, payload);\n        if (mode.records()) collecting!.ops.push(env.makeOp(kind, payload));\n        else if (!mode.untracked()) captured?.push(env.makeOp(kind, payload));\n      }\n      notifier.notify();\n    },\n    edit: (label, touchesLayout, fn) => (touchesLayout && arrivals.bareLayoutEdit() ? batch(label, fn) : fn()),\n    batch,\n    untracked(fn) {\n      const versionBefore = notifier.version();\n      const ownsArrivals = arrivals.open(true);\n      return notifier.deferred(() => mode.during('untracked', () => {\n        const result = log.atomically(() => withArrivalsSettled(fn, ownsArrivals), () => false);\n        if (ownsArrivals) arrivals.emitReflow();\n        return result;\n      }), () => {\n        if (ownsArrivals) arrivals.abandon();\n        if (notifier.version() !== versionBefore) engine.seal();\n      });\n    },\n    joins: () => mode.records() && collecting !== null,\n    join(ops, adapter) {\n      const into = collecting!;\n      const mark = into.ops.length;\n      const outer: Op[] = [];\n      try {\n        log.atomically(() => {\n          for (const op of ops) {\n            const before = into.ops.length;\n            const result = op.apply(adapter);\n            if (into.ops.length > before || result === false || result === 'noop') continue;\n            outer.push(bindOpToAdapter(op, adapter));\n            into.ops.push(outer[outer.length - 1]);\n          }\n        }, () => false);\n      } catch (err) {\n        unwind(outer);\n        into.ops.length = mark;\n        throw err;\n      }\n      into.outer.push(...outer);\n    },\n    capturing(step) {\n      const enclosing = captured;\n      const ops: Op[] = [];\n      captured = ops;\n      try {\n        return { result: step(), ops };\n      } finally {\n        captured = enclosing;\n      }\n    },\n    engineDriven: (fn) => mode.during('engine', () => notifier.muted(fn)),\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"recorder.js","names":[],"sources":["../../../src/core/scene/recorder.ts"],"sourcesContent":["/**\n * How a scene mutation becomes an undo entry: recorded on its own, collected\n * into the batch it runs in, or left to the engine or the untracked run that\n * is driving it.\n */\nimport type { History } from '@weasel-js/history';\nimport type { Op } from 'core/ops/types';\nimport type { AppliedLog } from './appliedLog';\nimport type { ArrivalWindow } from './arrivalWindow';\nimport { bindOpToAdapter } from './boundOps';\nimport type { EditMode } from './editMode';\nimport type { Notifier } from './notifier';\nimport type { NodeId } from './types';\n\n/** What the recorder needs from the scene it records for. */\nexport interface RecorderEnv {\n  notifier: Notifier;\n  mode: EditMode;\n  /** The scene's own undo/redo engine. */\n  engine: History;\n  /** Apply a registered op's forward half. */\n  runOp(kind: string, payload: unknown): void;\n  /** A registered op as the engine holds it. */\n  makeOp(kind: string, payload: unknown): Op;\n  log: AppliedLog;\n  arrivals: Pick<ArrivalWindow<unknown>, 'bareLayoutEdit' | 'open' | 'settle' | 'emitReflow' | 'abandon'>;\n  selection(): readonly NodeId[];\n  /** Write one pose an arrival settle decided. */\n  writePose(id: string, pose: unknown): void;\n  /** Run `fn` as an edit made by a scene call labeled `label`. */\n  labeled<T>(label: string, via: 'call', fn: () => T): T;\n}\n\nexport interface Recorder {\n  /** Apply a registered op as part of whatever edit is running. */\n  record(kind: string, payload: unknown, label: string): void;\n  /** Run the recording half of a mutation. One that touches a laid-out\n   *  container, called bare, runs as a batch of its own: that is what puts\n   *  the arrangement it triggers in the same undo step. */\n  edit<T>(label: string, touchesLayout: boolean, fn: () => T): T;\n  batch<T>(label: string, fn: () => T): T;\n  untracked<T>(fn: () => T): T;\n  /** Whether an edit made now would join an open `batch`'s entry. */\n  joins(): boolean;\n  /** Apply ops built outside the scene as part of the open `batch`, all or\n   *  none. Its entry holds the kit ops they cause, and beside them, bound to\n   *  `adapter`, any op that wrote no scene state. */\n  join(ops: Op[], adapter: unknown): void;\n  /** Run `step`, and answer with the kit ops applied during it. */\n  capturing<T>(step: () => T): { result: T; ops: Op[] };\n  /** Run `fn` as a history engine's step: the ops it applies may re-enter\n   *  scene mutation methods, which apply but do not record. The caller\n   *  notifies once after. */\n  engineDriven<T>(fn: () => T): T;\n}\n\n/** Take back ops that wrote outside the scene, newest first. The scene's own\n *  writes are reverted by the applied log. */\nfunction unwind(outer: readonly Op[]): void {\n  for (let i = outer.length - 1; i >= 0; i--) {\n    try {\n      outer[i].invert().apply(undefined);\n    } catch {\n      // The throw being unwound is the one the caller sees.\n    }\n  }\n}\n\nexport function createRecorder(env: RecorderEnv): Recorder {\n  const { notifier, mode, engine, log, arrivals } = env;\n  /** The outermost open batch, while it is recording. */\n  let collecting: { label: string; ops: Op[]; outer: Op[]; selectionBefore: readonly NodeId[] } | null = null;\n  /** The kit ops applied since the innermost `capturing` opened. */\n  let captured: Op[] | null = null;\n\n  /** `fn`, then the poses its arrivals settle to when this edit owns them. */\n  function withArrivalsSettled<T>(fn: () => T, owns: boolean): T {\n    const result = fn();\n    if (owns) for (const p of arrivals.settle()) env.writePose(p.id, p.to);\n    return result;\n  }\n\n  function batch<T>(label: string, fn: () => T): T {\n    const outermost = !mode.open();\n    // Captured at open, not at recordEntry: by the time the batch closes\n    // the selection has already moved to wherever the batch put it.\n    if (outermost) collecting = { label, ops: [], outer: [], selectionBefore: env.selection() };\n    const ownsArrivals = outermost && arrivals.open(true);\n    return env.labeled(label, 'call', () => notifier.deferred(() => mode.during('batch', () => {\n      if (!outermost) return fn();\n      try {\n        const result = log.atomically(\n          () => withArrivalsSettled(fn, ownsArrivals),\n          () => (collecting?.ops.length ?? 0) > 0,\n        );\n        if (ownsArrivals) arrivals.emitReflow();\n        return result;\n      } catch (err) {\n        // Reverted already; the half-built entry must not reach history.\n        unwind(collecting?.outer ?? []);\n        collecting = null;\n        throw err;\n      }\n    }), () => {\n      if (ownsArrivals) arrivals.abandon();\n      if (!outermost || !collecting) return;\n      const finished = collecting;\n      collecting = null;\n      // The ops were applied as they were issued, so the entry is pushed\n      // without re-applying.\n      if (finished.ops.length > 0) {\n        engine.recordEntry(finished.ops, finished.label, { selectionBefore: finished.selectionBefore });\n      }\n    }));\n  }\n\n  return {\n    record(kind, payload, label) {\n      env.labeled(label, 'call', () => {\n        if (mode.records() && !collecting) {\n          // The engine applies the op itself, which is what lets it coalesce.\n          mode.during('own', () => engine.applyOps([env.makeOp(kind, payload)], label));\n        } else {\n          env.runOp(kind, payload);\n          log.logApplied(kind, payload);\n          if (mode.records()) collecting!.ops.push(env.makeOp(kind, payload));\n          else if (!mode.untracked()) captured?.push(env.makeOp(kind, payload));\n        }\n      });\n      notifier.notify();\n    },\n    edit: (label, touchesLayout, fn) => (touchesLayout && arrivals.bareLayoutEdit() ? batch(label, fn) : fn()),\n    batch,\n    untracked(fn) {\n      const versionBefore = notifier.version();\n      const ownsArrivals = arrivals.open(true);\n      return notifier.deferred(() => mode.during('untracked', () => {\n        const result = log.atomically(() => withArrivalsSettled(fn, ownsArrivals), () => false);\n        if (ownsArrivals) arrivals.emitReflow();\n        return result;\n      }), () => {\n        if (ownsArrivals) arrivals.abandon();\n        if (notifier.version() !== versionBefore) engine.seal();\n      });\n    },\n    joins: () => mode.records() && collecting !== null,\n    join(ops, adapter) {\n      const into = collecting!;\n      const mark = into.ops.length;\n      const outer: Op[] = [];\n      try {\n        log.atomically(() => {\n          for (const op of ops) {\n            const before = into.ops.length;\n            const result = op.apply(adapter);\n            if (into.ops.length > before || result === false || result === 'noop') continue;\n            outer.push(bindOpToAdapter(op, adapter));\n            into.ops.push(outer[outer.length - 1]);\n          }\n        }, () => false);\n      } catch (err) {\n        unwind(outer);\n        into.ops.length = mark;\n        throw err;\n      }\n      into.outer.push(...outer);\n    },\n    capturing(step) {\n      const enclosing = captured;\n      const ops: Op[] = [];\n      captured = ops;\n      try {\n        return { result: step(), ops };\n      } finally {\n        captured = enclosing;\n      }\n    },\n    engineDriven: (fn) => mode.during('engine', () => notifier.muted(fn)),\n  };\n}\n"],"mappings":"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"}

package/dist/core/scene/renderOrder.js

@@ -1,84 +1,130 @@
 //#region src/core/scene/renderOrder.ts
-function e(e) {
-	function t() {
-		return e.layers.length === 1 ? c() : u();
+function createRenderOrder(state) {
+	/**
+	* Layer-major DFS-preorder ids, and the same sequence as nodes. Four walks
+	* for two sequences, which wants explaining, because collapsing them is the
+	* obvious cleanup and each collapse was measured to cost something:
+	*
+	* - ids vs nodes: projecting one from the other is a whole extra pass, worth
+	*   20% of `renderOrder()` on a multi-layer scene.
+	* - flat vs bucketed: a single layer needs no buckets and can compare the
+	*   layer id instead of indexing it, which is 1.4x. Behind a branch in one
+	*   function it also slows the bucketed path by 20% — the two shapes share
+	*   one optimized body, and whichever ran first wins it.
+	*
+	* All four emit the same order and `renderOrder.test.ts` holds them to it.
+	*/
+	function walkIds() {
+		return state.layers.length === 1 ? renderOrderFlat() : renderOrderBucketed();
 	}
-	function n() {
-		return e.layers.length === 1 ? l() : d();
+	function walkNodes() {
+		return state.layers.length === 1 ? renderOrderNodesFlat() : renderOrderNodesBucketed();
 	}
-	let r = 0, i = { gen: 0 };
-	function a() {
-		r++;
+	/**
+	* Render order survives everything except a structural edit, so both walks
+	* are cached against a counter the structural writers bump. Pose and data
+	* edits leave order alone and must NOT invalidate — they fire per frame
+	* during a drag, which is exactly when the cache pays.
+	*
+	* A missed bump is a silent wrong answer: nodes painted in the wrong z-order,
+	* or unpickable. `renderOrder.test.ts` walks each structural op and asserts
+	* the order moved.
+	*/
+	let structureGeneration = 0;
+	let orderCache = { gen: 0 };
+	function invalidate() {
+		structureGeneration++;
 	}
-	let o = [];
-	function s() {
-		return i.gen !== r && (i = { gen: r }), i;
+	const EMPTY_NODES = [];
+	function currentOrderCache() {
+		if (orderCache.gen !== structureGeneration) orderCache = { gen: structureGeneration };
+		return orderCache;
 	}
-	function c() {
-		let t = e.layers[0].id, n = [], r = [...e.roots].reverse();
-		for (; r.length > 0;) {
-			let i = r.pop(), a = e.nodes.get(i);
-			if (a && (a.layer === t && n.push(i), a.kind === "container")) for (let e = a.children.length - 1; e >= 0; e--) r.push(a.children[e]);
+	function renderOrderFlat() {
+		const only = state.layers[0].id;
+		const out = [];
+		const stack = [...state.roots].reverse();
+		while (stack.length > 0) {
+			const id = stack.pop();
+			const node = state.nodes.get(id);
+			if (!node) continue;
+			if (node.layer === only) out.push(id);
+			if (node.kind === "container") for (let i = node.children.length - 1; i >= 0; i--) stack.push(node.children[i]);
 		}
-		return n;
+		return out;
 	}
-	function l() {
-		let t = e.layers[0].id, n = [], r = [...e.roots].reverse();
-		for (; r.length > 0;) {
-			let i = r.pop(), a = e.nodes.get(i);
-			if (a && (a.layer === t && n.push(a), a.kind === "container")) for (let e = a.children.length - 1; e >= 0; e--) r.push(a.children[e]);
+	function renderOrderNodesFlat() {
+		const only = state.layers[0].id;
+		const out = [];
+		const stack = [...state.roots].reverse();
+		while (stack.length > 0) {
+			const id = stack.pop();
+			const node = state.nodes.get(id);
+			if (!node) continue;
+			if (node.layer === only) out.push(node);
+			if (node.kind === "container") for (let i = node.children.length - 1; i >= 0; i--) stack.push(node.children[i]);
 		}
-		return n;
+		return out;
 	}
-	function u() {
-		let t = e.layers.map(() => []), n = [...e.roots].reverse();
-		for (; n.length > 0;) {
-			let r = n.pop(), i = e.nodes.get(r);
-			if (!i) continue;
-			let a = t[e.layerIndex.get(i.layer) ?? -1];
-			if (a && a.push(r), i.kind === "container") for (let e = i.children.length - 1; e >= 0; e--) n.push(i.children[e]);
+	/** One DFS of the tree, bucketed by layer: appending in preorder keeps each
+	*  bucket in preorder, so concatenating them is the layer-major sequence. */
+	function renderOrderBucketed() {
+		const buckets = state.layers.map(() => []);
+		const stack = [...state.roots].reverse();
+		while (stack.length > 0) {
+			const id = stack.pop();
+			const node = state.nodes.get(id);
+			if (!node) continue;
+			const bucket = buckets[state.layerIndex.get(node.layer) ?? -1];
+			if (bucket) bucket.push(id);
+			if (node.kind === "container") for (let i = node.children.length - 1; i >= 0; i--) stack.push(node.children[i]);
 		}
-		let r = [];
-		for (let e of t) for (let t of e) r.push(t);
-		return r;
+		const out = [];
+		for (const bucket of buckets) for (const id of bucket) out.push(id);
+		return out;
 	}
-	function d() {
-		let t = e.layers.map(() => []), n = [...e.roots].reverse();
-		for (; n.length > 0;) {
-			let r = n.pop(), i = e.nodes.get(r);
-			if (!i) continue;
-			let a = t[e.layerIndex.get(i.layer) ?? -1];
-			if (a && a.push(i), i.kind === "container") for (let e = i.children.length - 1; e >= 0; e--) n.push(i.children[e]);
+	function renderOrderNodesBucketed() {
+		const buckets = state.layers.map(() => []);
+		const stack = [...state.roots].reverse();
+		while (stack.length > 0) {
+			const id = stack.pop();
+			const node = state.nodes.get(id);
+			if (!node) continue;
+			const bucket = buckets[state.layerIndex.get(node.layer) ?? -1];
+			if (bucket) bucket.push(node);
+			if (node.kind === "container") for (let i = node.children.length - 1; i >= 0; i--) stack.push(node.children[i]);
 		}
-		let r = [];
-		for (let e of t) for (let t of e) r.push(t);
-		return r;
+		const out = [];
+		for (const bucket of buckets) for (const node of bucket) out.push(node);
+		return out;
 	}
 	return {
 		ids() {
-			let e = s();
-			return e.ids ??= t();
+			const c = currentOrderCache();
+			return c.ids ??= walkIds();
 		},
 		nodes() {
-			let e = s();
-			return e.nodes ??= n();
+			const c = currentOrderCache();
+			return c.nodes ??= walkNodes();
 		},
-		nodesOnLayer(e) {
-			let t = s(), r = t.byLayer;
-			if (!r) {
-				r = /* @__PURE__ */ new Map();
-				for (let e of t.nodes ??= n()) {
-					let t = r.get(e.layer);
-					t || r.set(e.layer, t = []), t.push(e);
+		nodesOnLayer(layer) {
+			const c = currentOrderCache();
+			let byLayer = c.byLayer;
+			if (!byLayer) {
+				byLayer = /* @__PURE__ */ new Map();
+				for (const node of c.nodes ??= walkNodes()) {
+					let bucket = byLayer.get(node.layer);
+					if (!bucket) byLayer.set(node.layer, bucket = []);
+					bucket.push(node);
 				}
-				t.byLayer = r;
+				c.byLayer = byLayer;
 			}
-			return r.get(e) ?? o;
+			return byLayer.get(layer) ?? EMPTY_NODES;
 		},
-		invalidate: a
+		invalidate
 	};
 }
-//#endregion
-export { e as createRenderOrder };
 
+//#endregion
+export { createRenderOrder };
 //# sourceMappingURL=renderOrder.js.map

package/dist/core/scene/renderOrder.js.map

@@ -1 +1 @@
-{"version":3,"file":"renderOrder.js","names":["createRenderOrder","walkIds","state","renderOrderFlat","renderOrderBucketed","walkNodes","renderOrderNodesFlat","renderOrderNodesBucketed","structureGeneration","orderCache","invalidate","EMPTY_NODES","currentOrderCache","only","out","stack","id","node","i","buckets","bucket","c","byLayer","layer"],"sources":["../../../src/core/scene/renderOrder.ts"],"sourcesContent":["/**\n * A scene's render order: its nodes layer-major, each layer in tree preorder,\n * cached until the structure changes.\n */\nimport type { Node, NodeId } from './types';\n\n/** What the walks read of a scene's state. */\nexport interface RenderOrderState<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  roots: NodeId[];\n  layers: { id: TLayer }[];\n  layerIndex: Map<TLayer, number>;\n}\n\nexport interface RenderOrder<TData, TLayer extends string, TPose> {\n  ids(): NodeId[];\n  nodes(): Node<TData, TLayer, TPose>[];\n  nodesOnLayer(layer: TLayer): readonly Node<TData, TLayer, TPose>[];\n  /** Call on every structural edit; see the cache note below. */\n  invalidate(): void;\n}\n\nexport function createRenderOrder<TData, TLayer extends string, TPose>(\n  state: RenderOrderState<TData, TLayer, TPose>,\n): RenderOrder<TData, TLayer, TPose> {\n  /**\n   * Layer-major DFS-preorder ids, and the same sequence as nodes. Four walks\n   * for two sequences, which wants explaining, because collapsing them is the\n   * obvious cleanup and each collapse was measured to cost something:\n   *\n   * - ids vs nodes: projecting one from the other is a whole extra pass, worth\n   *   20% of `renderOrder()` on a multi-layer scene.\n   * - flat vs bucketed: a single layer needs no buckets and can compare the\n   *   layer id instead of indexing it, which is 1.4x. Behind a branch in one\n   *   function it also slows the bucketed path by 20% — the two shapes share\n   *   one optimized body, and whichever ran first wins it.\n   *\n   * All four emit the same order and `renderOrder.test.ts` holds them to it.\n   */\n  function walkIds(): NodeId[] {\n    return state.layers.length === 1 ? renderOrderFlat() : renderOrderBucketed();\n  }\n\n  function walkNodes(): Node<TData, TLayer, TPose>[] {\n    return state.layers.length === 1 ? renderOrderNodesFlat() : renderOrderNodesBucketed();\n  }\n\n  /**\n   * Render order survives everything except a structural edit, so both walks\n   * are cached against a counter the structural writers bump. Pose and data\n   * edits leave order alone and must NOT invalidate — they fire per frame\n   * during a drag, which is exactly when the cache pays.\n   *\n   * A missed bump is a silent wrong answer: nodes painted in the wrong z-order,\n   * or unpickable. `renderOrder.test.ts` walks each structural op and asserts\n   * the order moved.\n   */\n  let structureGeneration = 0;\n  let orderCache: {\n    gen: number;\n    ids?: NodeId[];\n    nodes?: Node<TData, TLayer, TPose>[];\n    byLayer?: Map<TLayer, Node<TData, TLayer, TPose>[]>;\n  } = { gen: 0 };\n\n  function invalidate(): void {\n    structureGeneration++;\n  }\n\n  const EMPTY_NODES: readonly Node<TData, TLayer, TPose>[] = [];\n\n  function currentOrderCache(): typeof orderCache {\n    if (orderCache.gen !== structureGeneration) {\n      orderCache = { gen: structureGeneration };\n    }\n    return orderCache;\n  }\n\n  function renderOrderFlat(): NodeId[] {\n    const only = state.layers[0].id;\n    const out: NodeId[] = [];\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      if (node.layer === only) out.push(id);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    return out;\n  }\n\n  function renderOrderNodesFlat(): Node<TData, TLayer, TPose>[] {\n    const only = state.layers[0].id;\n    const out: Node<TData, TLayer, TPose>[] = [];\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      if (node.layer === only) out.push(node);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    return out;\n  }\n\n  /** One DFS of the tree, bucketed by layer: appending in preorder keeps each\n   *  bucket in preorder, so concatenating them is the layer-major sequence. */\n  function renderOrderBucketed(): NodeId[] {\n    const buckets: NodeId[][] = state.layers.map(() => []);\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      const bucket = buckets[state.layerIndex.get(node.layer) ?? -1];\n      if (bucket) bucket.push(id);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    const out: NodeId[] = [];\n    for (const bucket of buckets) {\n      for (const id of bucket) out.push(id);\n    }\n    return out;\n  }\n\n  function renderOrderNodesBucketed(): Node<TData, TLayer, TPose>[] {\n    const buckets: Node<TData, TLayer, TPose>[][] = state.layers.map(() => []);\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      const bucket = buckets[state.layerIndex.get(node.layer) ?? -1];\n      if (bucket) bucket.push(node);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    const out: Node<TData, TLayer, TPose>[] = [];\n    for (const bucket of buckets) {\n      for (const node of bucket) out.push(node);\n    }\n    return out;\n  }\n\n  return {\n    ids() {\n      const c = currentOrderCache();\n      return (c.ids ??= walkIds());\n    },\n    nodes() {\n      const c = currentOrderCache();\n      return (c.nodes ??= walkNodes());\n    },\n    nodesOnLayer(layer) {\n      const c = currentOrderCache();\n      let byLayer = c.byLayer;\n      if (!byLayer) {\n        byLayer = new Map();\n        for (const node of (c.nodes ??= walkNodes())) {\n          let bucket = byLayer.get(node.layer);\n          if (!bucket) byLayer.set(node.layer, (bucket = []));\n          bucket.push(node);\n        }\n        c.byLayer = byLayer;\n      }\n      return byLayer.get(layer) ?? EMPTY_NODES;\n    },\n    invalidate,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"renderOrder.js","names":[],"sources":["../../../src/core/scene/renderOrder.ts"],"sourcesContent":["/**\n * A scene's render order: its nodes layer-major, each layer in tree preorder,\n * cached until the structure changes.\n */\nimport type { Node, NodeId } from './types';\n\n/** What the walks read of a scene's state. */\nexport interface RenderOrderState<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  roots: NodeId[];\n  layers: { id: TLayer }[];\n  layerIndex: Map<TLayer, number>;\n}\n\nexport interface RenderOrder<TData, TLayer extends string, TPose> {\n  ids(): NodeId[];\n  nodes(): Node<TData, TLayer, TPose>[];\n  nodesOnLayer(layer: TLayer): readonly Node<TData, TLayer, TPose>[];\n  /** Call on every structural edit; see the cache note below. */\n  invalidate(): void;\n}\n\nexport function createRenderOrder<TData, TLayer extends string, TPose>(\n  state: RenderOrderState<TData, TLayer, TPose>,\n): RenderOrder<TData, TLayer, TPose> {\n  /**\n   * Layer-major DFS-preorder ids, and the same sequence as nodes. Four walks\n   * for two sequences, which wants explaining, because collapsing them is the\n   * obvious cleanup and each collapse was measured to cost something:\n   *\n   * - ids vs nodes: projecting one from the other is a whole extra pass, worth\n   *   20% of `renderOrder()` on a multi-layer scene.\n   * - flat vs bucketed: a single layer needs no buckets and can compare the\n   *   layer id instead of indexing it, which is 1.4x. Behind a branch in one\n   *   function it also slows the bucketed path by 20% — the two shapes share\n   *   one optimized body, and whichever ran first wins it.\n   *\n   * All four emit the same order and `renderOrder.test.ts` holds them to it.\n   */\n  function walkIds(): NodeId[] {\n    return state.layers.length === 1 ? renderOrderFlat() : renderOrderBucketed();\n  }\n\n  function walkNodes(): Node<TData, TLayer, TPose>[] {\n    return state.layers.length === 1 ? renderOrderNodesFlat() : renderOrderNodesBucketed();\n  }\n\n  /**\n   * Render order survives everything except a structural edit, so both walks\n   * are cached against a counter the structural writers bump. Pose and data\n   * edits leave order alone and must NOT invalidate — they fire per frame\n   * during a drag, which is exactly when the cache pays.\n   *\n   * A missed bump is a silent wrong answer: nodes painted in the wrong z-order,\n   * or unpickable. `renderOrder.test.ts` walks each structural op and asserts\n   * the order moved.\n   */\n  let structureGeneration = 0;\n  let orderCache: {\n    gen: number;\n    ids?: NodeId[];\n    nodes?: Node<TData, TLayer, TPose>[];\n    byLayer?: Map<TLayer, Node<TData, TLayer, TPose>[]>;\n  } = { gen: 0 };\n\n  function invalidate(): void {\n    structureGeneration++;\n  }\n\n  const EMPTY_NODES: readonly Node<TData, TLayer, TPose>[] = [];\n\n  function currentOrderCache(): typeof orderCache {\n    if (orderCache.gen !== structureGeneration) {\n      orderCache = { gen: structureGeneration };\n    }\n    return orderCache;\n  }\n\n  function renderOrderFlat(): NodeId[] {\n    const only = state.layers[0].id;\n    const out: NodeId[] = [];\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      if (node.layer === only) out.push(id);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    return out;\n  }\n\n  function renderOrderNodesFlat(): Node<TData, TLayer, TPose>[] {\n    const only = state.layers[0].id;\n    const out: Node<TData, TLayer, TPose>[] = [];\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      if (node.layer === only) out.push(node);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    return out;\n  }\n\n  /** One DFS of the tree, bucketed by layer: appending in preorder keeps each\n   *  bucket in preorder, so concatenating them is the layer-major sequence. */\n  function renderOrderBucketed(): NodeId[] {\n    const buckets: NodeId[][] = state.layers.map(() => []);\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      const bucket = buckets[state.layerIndex.get(node.layer) ?? -1];\n      if (bucket) bucket.push(id);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    const out: NodeId[] = [];\n    for (const bucket of buckets) {\n      for (const id of bucket) out.push(id);\n    }\n    return out;\n  }\n\n  function renderOrderNodesBucketed(): Node<TData, TLayer, TPose>[] {\n    const buckets: Node<TData, TLayer, TPose>[][] = state.layers.map(() => []);\n    const stack: NodeId[] = [...state.roots].reverse();\n    while (stack.length > 0) {\n      const id = stack.pop()!;\n      const node = state.nodes.get(id);\n      if (!node) continue;\n      const bucket = buckets[state.layerIndex.get(node.layer) ?? -1];\n      if (bucket) bucket.push(node);\n      if (node.kind === 'container') {\n        for (let i = node.children.length - 1; i >= 0; i--) {\n          stack.push(node.children[i]);\n        }\n      }\n    }\n    const out: Node<TData, TLayer, TPose>[] = [];\n    for (const bucket of buckets) {\n      for (const node of bucket) out.push(node);\n    }\n    return out;\n  }\n\n  return {\n    ids() {\n      const c = currentOrderCache();\n      return (c.ids ??= walkIds());\n    },\n    nodes() {\n      const c = currentOrderCache();\n      return (c.nodes ??= walkNodes());\n    },\n    nodesOnLayer(layer) {\n      const c = currentOrderCache();\n      let byLayer = c.byLayer;\n      if (!byLayer) {\n        byLayer = new Map();\n        for (const node of (c.nodes ??= walkNodes())) {\n          let bucket = byLayer.get(node.layer);\n          if (!bucket) byLayer.set(node.layer, (bucket = []));\n          bucket.push(node);\n        }\n        c.byLayer = byLayer;\n      }\n      return byLayer.get(layer) ?? EMPTY_NODES;\n    },\n    invalidate,\n  };\n}\n"],"mappings":"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"}