@weasel-js/core 1.15.0 → 1.15.2

package/dist/core/layers/layerGroup.js

@@ -1,4 +1,4 @@
-//#region src/core/layers/layerGroup.ts
+// src/core/layers/layerGroup.ts
 /**
 * Layer id → the group that owns it. First claim wins across groups, with a
 * warning for the second; the same group naming a layer twice — `['scene',
@@ -48,6 +48,5 @@ function wrapGroup(group, children, view, dims) {
 	}];
 }
 
-//#endregion
 export { groupMembership, wrapGroup };
 //# sourceMappingURL=layerGroup.js.map

package/dist/core/layers/redrawSource.js

@@ -1,4 +1,4 @@
-//#region src/core/layers/redrawSource.ts
+// src/core/layers/redrawSource.ts
 /** The `subscribe` for a layer that draws `sources`: it notifies whenever any
 *  of them does. A thunk is read when the subscription is made. */
 function subscribeToSources(sources) {
@@ -10,6 +10,5 @@ function subscribeToSources(sources) {
 	};
 }
 
-//#endregion
 export { subscribeToSources };
 //# sourceMappingURL=redrawSource.js.map

package/dist/core/layers/render.js

@@ -3,7 +3,7 @@ import { DEFAULT_LAYER_RETAIN, retainedId } from "./retain.js";
 import { subscribeToSources } from "./redrawSource.js";
 import { viewToMat3 } from "@weasel-js/renderer";
 
-//#region src/core/layers/render.ts
+// src/core/layers/render.ts
 var IDENTITY_VIEW = {
 	x: 0,
 	y: 0,
@@ -210,6 +210,5 @@ function depsUnchanged(a, b) {
 	return true;
 }
 
-//#endregion
 export { DEFAULT_LAYER_RETAIN, depsUnchanged, drawLayers, drawOneLayer, isLayerPainted, isLayerVisible, paintedLayers, subscribeToSources };
 //# sourceMappingURL=render.js.map

package/dist/core/layers/retain.js

@@ -1,4 +1,4 @@
-//#region src/core/layers/retain.ts
+// src/core/layers/retain.ts
 /** Measured on 1280x800 at dpr 2: an unchanged layer composites cheaper than
 *  it submits from about 130 to 250 commands, depending on the layer count. */
 var DEFAULT_LAYER_RETAIN = { minCommands: 250 };
@@ -35,6 +35,5 @@ function retainedId(layer, cache, view, policy) {
 	return layer.retain === true || countDrawCommands(entry.cmds) >= policy.minCommands ? layer.id : void 0;
 }
 
-//#endregion
 export { DEFAULT_LAYER_RETAIN, countDrawCommands, retainedId };
 //# sourceMappingURL=retain.js.map

package/dist/core/ops/arrange.js

@@ -1,6 +1,6 @@
 import { registerOpFactory } from "./registry.js";
 
-//#region src/core/ops/arrange.ts
+// src/core/ops/arrange.ts
 /**
 * Op: write a set of poses decided when the op first applies, not when it is
 * built. The scene appends one to an edit that moves nodes into a container,
@@ -38,6 +38,5 @@ function createArrangeOp(args, compute, write) {
 }
 registerOpFactory("arrange", (args) => createArrangeOp(args));
 
-//#endregion
 export { createArrangeOp };
 //# sourceMappingURL=arrange.js.map

package/dist/core/ops/create.js

@@ -1,8 +1,8 @@
+import { createDeleteOp } from "./delete.js";
 import { registerOpFactory } from "./registry.js";
 import { parentOf, resolveSlot, slotFromIndex } from "./slot.js";
-import { createDeleteOp } from "./delete.js";
 
-//#region src/core/ops/create.ts
+// src/core/ops/create.ts
 /** Op: insert `node`, and the rest of `cascaded` with it; inverts to a delete
 *  of `node`. */
 function createInsertOp(args) {
@@ -41,6 +41,5 @@ function createInsertOp(args) {
 }
 registerOpFactory("insert", (args) => createInsertOp(args));
 
-//#endregion
 export { createInsertOp };
 //# sourceMappingURL=create.js.map

package/dist/core/ops/createHistory.js

@@ -1,8 +1,8 @@
-import { dlog, dwarn } from "../../debug/flag.js";
 import { rebuildOp } from "./registry.js";
+import { dlog, dwarn } from "../../debug/flag.js";
 import { createHistory } from "@weasel-js/history";
 
-//#region src/core/ops/createHistory.ts
+// src/core/ops/createHistory.ts
 /** Routes the engine's diagnostics into the kit's `history` debug namespace,
 *  so `localStorage.setItem('weasel.debug', '1')` still surfaces them. */
 var kitLogger = {
@@ -24,6 +24,5 @@ function createHistory$1(adapter, options = {}) {
 	});
 }
 
-//#endregion
 export { createHistory$1 as createHistory };
 //# sourceMappingURL=createHistory.js.map

package/dist/core/ops/delete.js

@@ -1,8 +1,8 @@
+import { createInsertOp } from "./create.js";
 import { registerOpFactory } from "./registry.js";
 import { captureSlot, parentOf, slotFromIndex } from "./slot.js";
-import { createInsertOp } from "./create.js";
 
-//#region src/core/ops/delete.ts
+// src/core/ops/delete.ts
 /** `id`'s ordinal among `parentId`'s children, or `-1` when it is not one. */
 function indexIn(a, parentId, id) {
 	return a.getChildren(parentId).indexOf(id);
@@ -95,6 +95,5 @@ function createDeleteOp(args) {
 }
 registerOpFactory("delete", (args) => createDeleteOp(args));
 
-//#endregion
 export { createDeleteOp };
 //# sourceMappingURL=delete.js.map

package/dist/core/ops/nodeFlags.js

@@ -1,6 +1,6 @@
 import { registerOpFactory } from "./registry.js";
 
-//#region src/core/ops/nodeFlags.ts
+// src/core/ops/nodeFlags.ts
 function flagOp(name, args) {
 	const { id, from, to, label, coalesceKey } = args;
 	return {
@@ -39,6 +39,5 @@ function createSetLockedOp(args) {
 registerOpFactory("setHidden", (args) => createSetHiddenOp(args));
 registerOpFactory("setLocked", (args) => createSetLockedOp(args));
 
-//#endregion
 export { createSetHiddenOp, createSetLockedOp };
 //# sourceMappingURL=nodeFlags.js.map

package/dist/core/ops/registry.js

@@ -1,6 +1,6 @@
 import { createReflectable } from "@weasel-js/registry";
 
-//#region src/core/ops/registry.ts
+// src/core/ops/registry.ts
 var FACTORIES = createReflectable();
 /** Every registered op factory, keyed by op name, in registration order. */
 var opFactoryRegistry = FACTORIES.reflection;
@@ -27,6 +27,5 @@ function registeredOpNames() {
 	return FACTORIES.entries().map((e) => e.key);
 }
 
-//#endregion
 export { opFactoryRegistry, rebuildOp, registerOpFactory, registeredOpNames };
 //# sourceMappingURL=registry.js.map

package/dist/core/ops/reorder/algorithms.js

@@ -1,4 +1,4 @@
-//#region src/core/ops/reorder/algorithms.ts
+// src/core/ops/reorder/algorithms.ts
 /**
 * Pure reorder primitives. All operate on a flat ordered id list (z-order:
 * index 0 = bottom, last = top) and return a new list. Stable: relative
@@ -74,6 +74,5 @@ function canSendBackward(list, ids) {
 	return false;
 }
 
-//#endregion
 export { bringForward, bringToFront, canBringForward, canSendBackward, moveToIndex, sendBackward, sendToBack };
 //# sourceMappingURL=algorithms.js.map

package/dist/core/ops/reorder/index.js

@@ -1,13 +1,9 @@
 import { registerOpFactory } from "../registry.js";
 import { bringForward, bringToFront, canBringForward, canSendBackward, moveToIndex, sendBackward, sendToBack } from "./algorithms.js";
 import { createSetChildOrderOp } from "./setChildOrder.js";
+import { sameList } from "@weasel-js/registry";
 
-//#region src/core/ops/reorder/index.ts
-function arraysEqual(a, b) {
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
-	return true;
-}
+// src/core/ops/reorder/index.ts
 /**
 * Build an op that, on apply, partitions `ids` by their current parent,
 * runs `fn(currentChildren, idsForParent)` per parent, and writes the
@@ -52,7 +48,7 @@ function createPartitionedReorderOp(args) {
 			for (const [parentId, parentIds] of byParent) {
 				const before = a.getChildren(parentId);
 				const after = fn(before, parentIds);
-				if (arraysEqual(before, after)) continue;
+				if (sameList(before, after)) continue;
 				snapshots.push({
 					parentId,
 					before: before.slice()
@@ -174,6 +170,5 @@ function createMoveToIndexOp(args) {
 }
 registerOpFactory("moveToIndex", (args) => createMoveToIndexOp(args));
 
-//#endregion
 export { canBringForward, canSendBackward, createMoveToIndexOp, createReorderOp, createSetChildOrderOp };
 //# sourceMappingURL=index.js.map

package/dist/core/ops/reorder/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../../src/core/ops/reorder/index.ts"],"sourcesContent":["import type { Op } from '../types';\nimport { registerOpFactory } from '../registry';\nimport {\n  bringForward,\n  sendBackward,\n  bringToFront,\n  sendToBack,\n  moveToIndex,\n} from './algorithms';\n\nimport { createSetChildOrderOp } from './setChildOrder';\n\nexport { canBringForward, canSendBackward } from './algorithms';\nexport { createSetChildOrderOp, type ChildOrder, type SetChildOrderArgs } from './setChildOrder';\n\ninterface ReorderAdapter {\n  getParent(id: string): string | null;\n  getChildren(parentId: string | null): string[];\n  setChildOrder(parentId: string | null, ids: string[]): void;\n}\n\ntype ReorderFn = (list: string[], ids: string[]) => string[];\n\nfunction arraysEqual(a: readonly string[], b: readonly string[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n  return true;\n}\n\n/** One parent's child order before a reorder, kept so undo can restore it. */\nexport interface ReorderRestoreEntry {\n  parentId: string | null;\n  before: string[];\n}\n\n/** Arguments to {@link createReorderOp}: move `ids` in paint order, one step or to the front/back. */\nexport interface ReorderArgs {\n  ids: string[];\n  direction: ReorderDirection;\n  label?: string;\n  /** Pre-mutation child order per touched parent. Filled in on first apply;\n   *  arrives populated when the op is rebuilt from a snapshot. */\n  prevOrders?: ReorderRestoreEntry[];\n}\n\n/**\n * Build an op that, on apply, partitions `ids` by their current parent,\n * runs `fn(currentChildren, idsForParent)` per parent, and writes the\n * result back via setChildOrder. Records before-state per parent so invert\n * is exact.\n *\n * `prevOrders` is that before-state, mirrored into the op's serialized args\n * on first apply. A deserialized op has never run its own `apply`, so its\n * invert has nothing to capture — reading it back from the args is what lets\n * a reorder survive a reload, the same trick `createMoveToIndexOp` uses.\n */\nfunction createPartitionedReorderOp(args: {\n  ids: string[];\n  direction: ReorderDirection;\n  fn: ReorderFn;\n  label?: string;\n  prevOrders?: ReorderRestoreEntry[];\n}): Op {\n  const { ids, direction, fn, label, prevOrders } = args;\n  const argsForSerial: ReorderArgs = {\n    ids,\n    direction,\n    label,\n    prevOrders: prevOrders ? prevOrders.map((e) => ({ ...e, before: e.before.slice() })) : undefined,\n  };\n  let restore: ReorderRestoreEntry[] | null =\n    prevOrders ? prevOrders.map((e) => ({ ...e, before: e.before.slice() })) : null;\n\n  return {\n    name: 'reorder',\n    args: argsForSerial,\n    label,\n    apply(adapter) {\n      const a = adapter as ReorderAdapter;\n      // Partition ids by current parent.\n      const byParent = new Map<string | null, string[]>();\n      for (const id of ids) {\n        const parent = a.getParent(id);\n        const list = byParent.get(parent) ?? [];\n        list.push(id);\n        byParent.set(parent, list);\n      }\n      const snapshots: ReorderRestoreEntry[] = [];\n      let mutated = false;\n      for (const [parentId, parentIds] of byParent) {\n        const before = a.getChildren(parentId);\n        const after = fn(before, parentIds);\n        if (arraysEqual(before, after)) continue; // already at the desired order\n        snapshots.push({ parentId, before: before.slice() });\n        a.setChildOrder(parentId, after);\n        mutated = true;\n      }\n      restore = snapshots;\n      argsForSerial.prevOrders = snapshots.map((e) => ({ ...e, before: e.before.slice() }));\n      return mutated;\n    },\n    invert() {\n      const captured = restore;\n      return {\n        ...createSetChildOrderOp({\n          orders: (captured ?? []).map((e) => ({ parentId: e.parentId, ids: e.before })),\n          label,\n        }),\n        invert: () =>\n          createPartitionedReorderOp({\n            ids, direction, fn, label, prevOrders: captured ?? undefined,\n          }),\n      };\n    },\n  };\n}\n\n/** Direction of a sibling z-order reorder. */\nexport type ReorderDirection = 'forward' | 'backward' | 'front' | 'back';\n\nconst REORDER_DIRECTIONS: Record<ReorderDirection, { fn: ReorderFn; defaultLabel: string }> = {\n  forward:  { fn: bringForward,  defaultLabel: 'Bring forward' },\n  backward: { fn: sendBackward,  defaultLabel: 'Send backward' },\n  front:    { fn: bringToFront,  defaultLabel: 'Bring to front' },\n  back:     { fn: sendToBack,    defaultLabel: 'Send to back' },\n};\n\n/**\n * Op: shift each id within its parent's child order per `direction`:\n *   - `'forward'`  — bump one step toward the top\n *   - `'backward'` — bump one step toward the bottom\n *   - `'front'`    — move to the top, preserving relative order\n *   - `'back'`     — move to the bottom, preserving relative order\n */\nexport function createReorderOp(args: ReorderArgs): Op {\n  const { ids, direction, label, prevOrders } = args;\n  const { fn, defaultLabel } = REORDER_DIRECTIONS[direction];\n  return createPartitionedReorderOp({\n    ids, direction, fn, label: label ?? defaultLabel, prevOrders,\n  });\n}\n\nregisterOpFactory<ReorderArgs>('reorder', (args) => createReorderOp(args));\n\n/** Arguments to {@link createMoveToIndexOp}: move `ids` to `index` under `parentId`. */\nexport interface MoveToIndexArgs {\n  ids: string[];\n  parentId: string | null;\n  index: number;\n  label?: string;\n  /** Optional pre-mutation child order for the parent. When present, the op\n   *  uses it as the invert target instead of capturing at apply time — this\n   *  is how a deserialized op (whose original `apply` already ran in a prior\n   *  session) restores its invert behavior across an IDB round-trip. */\n  prevPositions?: string[];\n}\n\n/** Op: move all `ids` to a contiguous block starting at `index` within `parentId`'s child order. */\nexport function createMoveToIndexOp(args: MoveToIndexArgs): Op {\n  const { ids, parentId, index, label } = args;\n  // Outer args record we'll mutate so the captured `before` lands in the\n  // serialized form. `prevPositions` arrives populated when reconstructed\n  // from a snapshot; otherwise it's filled in on first apply.\n  const argsForSerial: MoveToIndexArgs = {\n    ids,\n    parentId,\n    index,\n    label,\n    prevPositions: args.prevPositions ? args.prevPositions.slice() : undefined,\n  };\n  let before: string[] | null = args.prevPositions ? args.prevPositions.slice() : null;\n\n  return {\n    name: 'moveToIndex',\n    args: argsForSerial,\n    label: label ?? 'Move to index',\n    apply(adapter) {\n      const a = adapter as ReorderAdapter;\n      // Filter to ids whose current parent matches target parent.\n      const eligible = ids.filter((id) => a.getParent(id) === parentId);\n      const current = a.getChildren(parentId);\n      // Only overwrite `before` the first time we apply; redo (a second\n      // apply) must not clobber the originally-captured order, otherwise\n      // invert would replay the post-move state and undo nothing.\n      if (before === null) {\n        before = current.slice();\n        argsForSerial.prevPositions = before.slice();\n      }\n      const after = moveToIndex(current, eligible, index);\n      a.setChildOrder(parentId, after);\n    },\n    invert() {\n      const captured = before;\n      return {\n        ...createSetChildOrderOp({ orders: captured ? [{ parentId, ids: captured }] : [], label }),\n        invert: () =>\n          createMoveToIndexOp({\n            ids, parentId, index, label, prevPositions: captured ?? undefined,\n          }),\n      };\n    },\n  };\n}\n\nregisterOpFactory<MoveToIndexArgs>('moveToIndex', (args) => createMoveToIndexOp(args));\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/core/ops/reorder/index.ts"],"sourcesContent":["import { sameList } from '@weasel-js/registry';\nimport type { Op } from '../types';\nimport { registerOpFactory } from '../registry';\nimport {\n  bringForward,\n  sendBackward,\n  bringToFront,\n  sendToBack,\n  moveToIndex,\n} from './algorithms';\n\nimport { createSetChildOrderOp } from './setChildOrder';\n\nexport { canBringForward, canSendBackward } from './algorithms';\nexport { createSetChildOrderOp, type ChildOrder, type SetChildOrderArgs } from './setChildOrder';\n\ninterface ReorderAdapter {\n  getParent(id: string): string | null;\n  getChildren(parentId: string | null): string[];\n  setChildOrder(parentId: string | null, ids: string[]): void;\n}\n\ntype ReorderFn = (list: string[], ids: string[]) => string[];\n\n/** One parent's child order before a reorder, kept so undo can restore it. */\nexport interface ReorderRestoreEntry {\n  parentId: string | null;\n  before: string[];\n}\n\n/** Arguments to {@link createReorderOp}: move `ids` in paint order, one step or to the front/back. */\nexport interface ReorderArgs {\n  ids: string[];\n  direction: ReorderDirection;\n  label?: string;\n  /** Pre-mutation child order per touched parent. Filled in on first apply;\n   *  arrives populated when the op is rebuilt from a snapshot. */\n  prevOrders?: ReorderRestoreEntry[];\n}\n\n/**\n * Build an op that, on apply, partitions `ids` by their current parent,\n * runs `fn(currentChildren, idsForParent)` per parent, and writes the\n * result back via setChildOrder. Records before-state per parent so invert\n * is exact.\n *\n * `prevOrders` is that before-state, mirrored into the op's serialized args\n * on first apply. A deserialized op has never run its own `apply`, so its\n * invert has nothing to capture — reading it back from the args is what lets\n * a reorder survive a reload, the same trick `createMoveToIndexOp` uses.\n */\nfunction createPartitionedReorderOp(args: {\n  ids: string[];\n  direction: ReorderDirection;\n  fn: ReorderFn;\n  label?: string;\n  prevOrders?: ReorderRestoreEntry[];\n}): Op {\n  const { ids, direction, fn, label, prevOrders } = args;\n  const argsForSerial: ReorderArgs = {\n    ids,\n    direction,\n    label,\n    prevOrders: prevOrders ? prevOrders.map((e) => ({ ...e, before: e.before.slice() })) : undefined,\n  };\n  let restore: ReorderRestoreEntry[] | null =\n    prevOrders ? prevOrders.map((e) => ({ ...e, before: e.before.slice() })) : null;\n\n  return {\n    name: 'reorder',\n    args: argsForSerial,\n    label,\n    apply(adapter) {\n      const a = adapter as ReorderAdapter;\n      // Partition ids by current parent.\n      const byParent = new Map<string | null, string[]>();\n      for (const id of ids) {\n        const parent = a.getParent(id);\n        const list = byParent.get(parent) ?? [];\n        list.push(id);\n        byParent.set(parent, list);\n      }\n      const snapshots: ReorderRestoreEntry[] = [];\n      let mutated = false;\n      for (const [parentId, parentIds] of byParent) {\n        const before = a.getChildren(parentId);\n        const after = fn(before, parentIds);\n        if (sameList(before, after)) continue; // already at the desired order\n        snapshots.push({ parentId, before: before.slice() });\n        a.setChildOrder(parentId, after);\n        mutated = true;\n      }\n      restore = snapshots;\n      argsForSerial.prevOrders = snapshots.map((e) => ({ ...e, before: e.before.slice() }));\n      return mutated;\n    },\n    invert() {\n      const captured = restore;\n      return {\n        ...createSetChildOrderOp({\n          orders: (captured ?? []).map((e) => ({ parentId: e.parentId, ids: e.before })),\n          label,\n        }),\n        invert: () =>\n          createPartitionedReorderOp({\n            ids, direction, fn, label, prevOrders: captured ?? undefined,\n          }),\n      };\n    },\n  };\n}\n\n/** Direction of a sibling z-order reorder. */\nexport type ReorderDirection = 'forward' | 'backward' | 'front' | 'back';\n\nconst REORDER_DIRECTIONS: Record<ReorderDirection, { fn: ReorderFn; defaultLabel: string }> = {\n  forward:  { fn: bringForward,  defaultLabel: 'Bring forward' },\n  backward: { fn: sendBackward,  defaultLabel: 'Send backward' },\n  front:    { fn: bringToFront,  defaultLabel: 'Bring to front' },\n  back:     { fn: sendToBack,    defaultLabel: 'Send to back' },\n};\n\n/**\n * Op: shift each id within its parent's child order per `direction`:\n *   - `'forward'`  — bump one step toward the top\n *   - `'backward'` — bump one step toward the bottom\n *   - `'front'`    — move to the top, preserving relative order\n *   - `'back'`     — move to the bottom, preserving relative order\n */\nexport function createReorderOp(args: ReorderArgs): Op {\n  const { ids, direction, label, prevOrders } = args;\n  const { fn, defaultLabel } = REORDER_DIRECTIONS[direction];\n  return createPartitionedReorderOp({\n    ids, direction, fn, label: label ?? defaultLabel, prevOrders,\n  });\n}\n\nregisterOpFactory<ReorderArgs>('reorder', (args) => createReorderOp(args));\n\n/** Arguments to {@link createMoveToIndexOp}: move `ids` to `index` under `parentId`. */\nexport interface MoveToIndexArgs {\n  ids: string[];\n  parentId: string | null;\n  index: number;\n  label?: string;\n  /** Optional pre-mutation child order for the parent. When present, the op\n   *  uses it as the invert target instead of capturing at apply time — this\n   *  is how a deserialized op (whose original `apply` already ran in a prior\n   *  session) restores its invert behavior across an IDB round-trip. */\n  prevPositions?: string[];\n}\n\n/** Op: move all `ids` to a contiguous block starting at `index` within `parentId`'s child order. */\nexport function createMoveToIndexOp(args: MoveToIndexArgs): Op {\n  const { ids, parentId, index, label } = args;\n  // Outer args record we'll mutate so the captured `before` lands in the\n  // serialized form. `prevPositions` arrives populated when reconstructed\n  // from a snapshot; otherwise it's filled in on first apply.\n  const argsForSerial: MoveToIndexArgs = {\n    ids,\n    parentId,\n    index,\n    label,\n    prevPositions: args.prevPositions ? args.prevPositions.slice() : undefined,\n  };\n  let before: string[] | null = args.prevPositions ? args.prevPositions.slice() : null;\n\n  return {\n    name: 'moveToIndex',\n    args: argsForSerial,\n    label: label ?? 'Move to index',\n    apply(adapter) {\n      const a = adapter as ReorderAdapter;\n      // Filter to ids whose current parent matches target parent.\n      const eligible = ids.filter((id) => a.getParent(id) === parentId);\n      const current = a.getChildren(parentId);\n      // Only overwrite `before` the first time we apply; redo (a second\n      // apply) must not clobber the originally-captured order, otherwise\n      // invert would replay the post-move state and undo nothing.\n      if (before === null) {\n        before = current.slice();\n        argsForSerial.prevPositions = before.slice();\n      }\n      const after = moveToIndex(current, eligible, index);\n      a.setChildOrder(parentId, after);\n    },\n    invert() {\n      const captured = before;\n      return {\n        ...createSetChildOrderOp({ orders: captured ? [{ parentId, ids: captured }] : [], label }),\n        invert: () =>\n          createMoveToIndexOp({\n            ids, parentId, index, label, prevPositions: captured ?? undefined,\n          }),\n      };\n    },\n  };\n}\n\nregisterOpFactory<MoveToIndexArgs>('moveToIndex', (args) => createMoveToIndexOp(args));\n"],"mappings":"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"}

package/dist/core/ops/reorder/setChildOrder.js

@@ -1,6 +1,6 @@
 import { registerOpFactory } from "../registry.js";
 
-//#region src/core/ops/reorder/setChildOrder.ts
+// src/core/ops/reorder/setChildOrder.ts
 /** Op: write each listed parent's whole child order; inverts to a write of the
 *  orders it replaced. Where `createMoveToIndexOp` keeps the moved ids in their
 *  current relative order, this states every position. */
@@ -36,6 +36,5 @@ function createSetChildOrderOp(args) {
 }
 registerOpFactory("setChildOrder", (args) => createSetChildOrderOp(args));
 
-//#endregion
 export { createSetChildOrderOp };
 //# sourceMappingURL=setChildOrder.js.map

package/dist/core/ops/reparent.js

@@ -1,7 +1,7 @@
 import { registerOpFactory } from "./registry.js";
 import { captureSlot, resolveSlot, slotFromIndex } from "./slot.js";
 
-//#region src/core/ops/reparent.ts
+// src/core/ops/reparent.ts
 /** Move `id` to `slot` among `parentId`'s children. No-op when `id` isn't
 *  there or is already in place. */
 function placeAt(a, parentId, id, slot) {
@@ -72,6 +72,5 @@ function createReparentOp(args) {
 }
 registerOpFactory("reparent", (args) => createReparentOp(args));
 
-//#endregion
 export { createReparentOp };
 //# sourceMappingURL=reparent.js.map

package/dist/core/ops/select.js

@@ -1,6 +1,6 @@
 import { registerOpFactory } from "./registry.js";
 
-//#region src/core/ops/select.ts
+// src/core/ops/select.ts
 /** Op: replace the current selection with `to`; inverts back to `from`. */
 function createSetSelectionOp(args) {
 	const { from, to, label } = args;
@@ -32,6 +32,5 @@ function sequenceEqual(a, b) {
 	return true;
 }
 
-//#endregion
 export { createSetSelectionOp };
 //# sourceMappingURL=select.js.map

package/dist/core/ops/setData.js

@@ -1,6 +1,6 @@
 import { registerOpFactory } from "./registry.js";
 
-//#region src/core/ops/setData.ts
+// src/core/ops/setData.ts
 /** Op: set a node's app-defined `data` payload, inverting back to `from`. */
 function createSetDataOp(args) {
 	const { id, from, to, label, coalesceKey } = args;
@@ -31,6 +31,5 @@ function createSetDataOp(args) {
 }
 registerOpFactory("setData", (args) => createSetDataOp(args));
 
-//#endregion
 export { createSetDataOp };
 //# sourceMappingURL=setData.js.map

package/dist/core/ops/setDependsOn.js

@@ -1,6 +1,6 @@
 import { registerOpFactory } from "./registry.js";
 
-//#region src/core/ops/setDependsOn.ts
+// src/core/ops/setDependsOn.ts
 /** Op: set what a derived node's geometry derives from, inverting back to
 *  `from`. */
 function createSetDependsOnOp(args) {
@@ -32,6 +32,5 @@ function createSetDependsOnOp(args) {
 }
 registerOpFactory("setDependsOn", (args) => createSetDependsOnOp(args));
 
-//#endregion
 export { createSetDependsOnOp };
 //# sourceMappingURL=setDependsOn.js.map

package/dist/core/ops/setLayer.js

@@ -1,6 +1,6 @@
 import { registerOpFactory } from "./registry.js";
 
-//#region src/core/ops/setLayer.ts
+// src/core/ops/setLayer.ts
 /** Op: set a node's `layer` tag, inverting back to `from`. `coalesceKey`
 *  defaults to `setLayer:${id}` so successive layer changes to the same node
 *  merge into one undo entry within the history's coalesce window. Pass an
@@ -34,6 +34,5 @@ function createSetLayerOp(args) {
 }
 registerOpFactory("setLayer", (args) => createSetLayerOp(args));
 
-//#endregion
 export { createSetLayerOp };
 //# sourceMappingURL=setLayer.js.map

package/dist/core/ops/setLayout.js

@@ -1,6 +1,6 @@
 import { registerOpFactory } from "./registry.js";
 
-//#region src/core/ops/setLayout.ts
+// src/core/ops/setLayout.ts
 /**
 * Op: give a container a different layout, inverting back to `from`. Applied
 * through a scene adapter (`adapter.setLayout`), the scene re-arranges the
@@ -35,6 +35,5 @@ function createSetLayoutOp(args) {
 }
 registerOpFactory("setLayout", (args) => createSetLayoutOp(args));
 
-//#endregion
 export { createSetLayoutOp };
 //# sourceMappingURL=setLayout.js.map

package/dist/core/ops/setPath.js

@@ -1,7 +1,7 @@
 import { registerOpFactory } from "./registry.js";
 import { originOf } from "@weasel-js/geom";
 
-//#region src/core/ops/setPath.ts
+// src/core/ops/setPath.ts
 /**
 * Op: atomically replace a PathObj's geometric fields (path + closed + params).
 * Used for pen-edit anchor mutations and parametric-shape trapdoor conversions.
@@ -74,6 +74,5 @@ function shallowEqual(a, b) {
 	return true;
 }
 
-//#endregion
 export { createSetPathOp };
 //# sourceMappingURL=setPath.js.map

package/dist/core/ops/setText.js

@@ -1,6 +1,6 @@
 import { registerOpFactory } from "./registry.js";
 
-//#region src/core/ops/setText.ts
+// src/core/ops/setText.ts
 /** Op: set a text node's text content, inverting back to `from`. `coalesceKey`
 *  defaults to `setText:${id}` so successive edits to the same node (typing)
 *  merge into one undo entry within the history's coalesce window. Pass an
@@ -34,6 +34,5 @@ function createSetTextOp(args) {
 }
 registerOpFactory("setText", (args) => createSetTextOp(args));
 
-//#endregion
 export { createSetTextOp };
 //# sourceMappingURL=setText.js.map

package/dist/core/ops/slot.js

@@ -1,4 +1,4 @@
-//#region src/core/ops/slot.ts
+// src/core/ops/slot.ts
 /** Observe `id`'s slot among `parentId`'s children. `null` when `id` isn't
 *  there — callers keep whatever weaker slot they already had rather than
 *  overwriting it with a guess. */
@@ -43,6 +43,5 @@ function parentOf(node) {
 	return node.parent ?? null;
 }
 
-//#endregion
 export { captureSlot, locateChild, parentOf, resolveSlot, slotFromIndex };
 //# sourceMappingURL=slot.js.map

package/dist/core/ops/transform.js

@@ -1,6 +1,6 @@
 import { registerOpFactory } from "./registry.js";
 
-//#region src/core/ops/transform.ts
+// src/core/ops/transform.ts
 /** Op: set an object's pose, inverting back to `from`. `coalesceKey` defaults to
 *  `transform:${id}` so successive pose writes to the same node (drag-move,
 *  resize, repeated nudges) merge into one undo entry within the history's
@@ -44,6 +44,5 @@ function poseShallowEqual(a, b) {
 	return true;
 }
 
-//#endregion
 export { createTransformOp };
 //# sourceMappingURL=transform.js.map

package/dist/core/ops/writtenBy.js

@@ -1,6 +1,6 @@
 import { sceneMutators } from "../scene/sceneMutators.js";
 
-//#region src/core/ops/writtenBy.ts
+// src/core/ops/writtenBy.ts
 /**
 * The pose and data `ops` leave each node they write, by id, read by applying
 * them to a recorder rather than the scene; null when one cannot be read that
@@ -48,6 +48,5 @@ function writtenBy(sc, ops) {
 	return after;
 }
 
-//#endregion
 export { writtenBy };
 //# sourceMappingURL=writtenBy.js.map

package/dist/core/pages/fitViewToPage.js

@@ -1,7 +1,8 @@
 import { fitViewToBounds } from "../viewport/fitViewToBounds.js";
+import { viewportWorldRect } from "../viewport/viewportWorldRect.js";
 import { pageOfBounds } from "./pages.js";
 
-//#region src/core/pages/fitViewToPage.ts
+// src/core/pages/fitViewToPage.ts
 /** The view that shows one placed page whole: `fitViewToBounds` on its rect. */
 function fitViewToPage(page, viewportDims, currentView, options) {
 	const { x, y, width, height } = page;
@@ -14,15 +15,8 @@ function fitViewToPage(page, viewportDims, currentView, options) {
 }
 /** The page the view shows most of: the one overlapping the visible world rect most, or `null` when none shows. */
 function pageInView(pages, view, viewportDims) {
-	const visible = {
-		x: view.x,
-		y: view.y,
-		width: viewportDims.width / view.scale.x,
-		height: viewportDims.height / view.scale.y
-	};
-	return pageOfBounds(pages, visible);
+	return pageOfBounds(pages, viewportWorldRect(view, viewportDims));
 }
 
-//#endregion
 export { fitViewToPage, pageInView };
 //# sourceMappingURL=fitViewToPage.js.map

package/dist/core/pages/fitViewToPage.js.map

@@ -1 +1 @@
-{"version":3,"file":"fitViewToPage.js","names":[],"sources":["../../../src/core/pages/fitViewToPage.ts"],"sourcesContent":["import {\n  fitViewToBounds,\n  type FitViewToBoundsOptions,\n  type ViewportDims,\n} from '../viewport/fitViewToBounds';\nimport type { View } from '../viewport/view';\nimport { pageOfBounds, type PlacedPage } from './pages';\n\n/** The view that shows one placed page whole: `fitViewToBounds` on its rect. */\nexport function fitViewToPage(\n  page: PlacedPage,\n  viewportDims: ViewportDims,\n  currentView: View,\n  options?: FitViewToBoundsOptions,\n): View {\n  const { x, y, width, height } = page;\n  return fitViewToBounds({ x, y, width, height }, viewportDims, currentView, options);\n}\n\n/** The page the view shows most of: the one overlapping the visible world rect most, or `null` when none shows. */\nexport function pageInView(\n  pages: readonly PlacedPage[],\n  view: View,\n  viewportDims: ViewportDims,\n): PlacedPage | null {\n  const visible = { x: view.x, y: view.y, width: viewportDims.width / view.scale.x, height: viewportDims.height / view.scale.y };\n  return pageOfBounds(pages, visible);\n}\n"],"mappings":";;;;;AASA,SAAgB,cACd,MACA,cACA,aACA,SACM;CACN,MAAM,EAAE,GAAG,GAAG,OAAO,WAAW;CAChC,OAAO,gBAAgB;EAAE;EAAG;EAAG;EAAO;CAAO,GAAG,cAAc,aAAa,OAAO;AACpF;;AAGA,SAAgB,WACd,OACA,MACA,cACmB;CACnB,MAAM,UAAU;EAAE,GAAG,KAAK;EAAG,GAAG,KAAK;EAAG,OAAO,aAAa,QAAQ,KAAK,MAAM;EAAG,QAAQ,aAAa,SAAS,KAAK,MAAM;CAAE;CAC7H,OAAO,aAAa,OAAO,OAAO;AACpC"}
+{"version":3,"file":"fitViewToPage.js","names":[],"sources":["../../../src/core/pages/fitViewToPage.ts"],"sourcesContent":["import {\n  fitViewToBounds,\n  type FitViewToBoundsOptions,\n  type ViewportDims,\n} from '../viewport/fitViewToBounds';\nimport type { View } from '../viewport/view';\nimport { viewportWorldRect } from '../viewport/viewportWorldRect';\nimport { pageOfBounds, type PlacedPage } from './pages';\n\n/** The view that shows one placed page whole: `fitViewToBounds` on its rect. */\nexport function fitViewToPage(\n  page: PlacedPage,\n  viewportDims: ViewportDims,\n  currentView: View,\n  options?: FitViewToBoundsOptions,\n): View {\n  const { x, y, width, height } = page;\n  return fitViewToBounds({ x, y, width, height }, viewportDims, currentView, options);\n}\n\n/** The page the view shows most of: the one overlapping the visible world rect most, or `null` when none shows. */\nexport function pageInView(\n  pages: readonly PlacedPage[],\n  view: View,\n  viewportDims: ViewportDims,\n): PlacedPage | null {\n  return pageOfBounds(pages, viewportWorldRect(view, viewportDims));\n}\n"],"mappings":";;;;;;AAUA,SAAgB,cACd,MACA,cACA,aACA,SACM;CACN,MAAM,EAAE,GAAG,GAAG,OAAO,WAAW;CAChC,OAAO,gBAAgB;EAAE;EAAG;EAAG;EAAO;CAAO,GAAG,cAAc,aAAa,OAAO;AACpF;;AAGA,SAAgB,WACd,OACA,MACA,cACmB;CACnB,OAAO,aAAa,OAAO,kBAAkB,MAAM,YAAY,CAAC;AAClE"}

package/dist/core/pages/pageEdits.js

@@ -1,9 +1,9 @@
-import { effectivePose, isEnvelope } from "../scene/effectivePose.js";
-import { layoutPages, pageOfBounds } from "./pages.js";
 import { RECT_POSE_DESCRIPTOR, poseDescriptorForNode, translatePoseViaDescriptor } from "../geometry/poseDescriptor.js";
 import { carriedDescendants, sceneCarrySource } from "../scene/carryDescendants.js";
+import { effectivePose, isEnvelope } from "../scene/effectivePose.js";
+import { layoutPages, pageOfBounds } from "./pages.js";
 
-//#region src/core/pages/pageEdits.ts
+// src/core/pages/pageEdits.ts
 /**
 * A document's pages as a scene document value, and the edits that change
 * them. Each edit moves the nodes on a page by however far the page itself
@@ -158,6 +158,5 @@ function renamePage(scene, id, name, options = {}) {
 	}));
 }
 
-//#endregion
 export { PAGES_DOC_KEY, addPage, movePage, nextPageId, pageMembers, pagesOf, placedPagesOf, removePage, renamePage, resizePage, setPages };
 //# sourceMappingURL=pageEdits.js.map

package/dist/core/pages/pages.js

@@ -1,4 +1,6 @@
-//#region src/core/pages/pages.ts
+import { unionRects } from "@weasel-js/geom";
+
+// src/core/pages/pages.ts
 var ALIGN = {
 	start: 0,
 	center: .5,
@@ -109,17 +111,8 @@ function adjacentPage(pages, current, step, options = {}) {
 }
 /** The box around every page, or `null` for a document with none. */
 function pagesBounds(pages) {
-	if (pages.length === 0) return null;
-	const x = Math.min(...pages.map((p) => p.x));
-	const y = Math.min(...pages.map((p) => p.y));
-	return {
-		x,
-		y,
-		width: Math.max(...pages.map((p) => p.x + p.width)) - x,
-		height: Math.max(...pages.map((p) => p.y + p.height)) - y
-	};
+	return unionRects(pages);
 }
 
-//#endregion
 export { adjacentPage, layoutPages, pageAt, pageHolding, pageName, pageOfBounds, pagesBounds };
 //# sourceMappingURL=pages.js.map

package/dist/core/pages/pages.js.map

@@ -1 +1 @@
-{"version":3,"file":"pages.js","names":[],"sources":["../../../src/core/pages/pages.ts"],"sourcesContent":["import type { Bounds } from '@weasel-js/routing';\n\n/** One page of a document: a sheet of a fixed size, in world units. */\nexport interface Page {\n  readonly id: string;\n  readonly name?: string;\n  readonly width: number;\n  readonly height: number;\n}\n\n/** A page and where it sits in world space. */\nexport interface PlacedPage extends Page {\n  readonly x: number;\n  readonly y: number;\n  /** Its place in the document's page order. */\n  readonly index: number;\n}\n\n/** Options for {@link layoutPages}. */\nexport interface PageLayoutOptions {\n  /** Which way the pages run. Default `'row'`. */\n  direction?: 'row' | 'column';\n  /** World units between neighbors. Default 40. */\n  gap?: number;\n  /** Where a page sits across the run, against the largest page. Default `'start'`. */\n  align?: 'start' | 'center' | 'end';\n  /** Where the first page's run starts. Default the world origin. */\n  origin?: { readonly x: number; readonly y: number };\n}\n\nconst ALIGN = { start: 0, center: 0.5, end: 1 } as const;\n\n/**\n * Place a document's pages in one world space, in order, so a single scene,\n * view, and history serve all of them. With the defaults the first page's\n * top-left corner is the world origin, where a one-page document's page is.\n * Throws on two pages with one id.\n */\nexport function layoutPages(pages: readonly Page[], options: PageLayoutOptions = {}): PlacedPage[] {\n  const { direction = 'row', gap = 40, align = 'start', origin = { x: 0, y: 0 } } = options;\n  const row = direction === 'row';\n  const across = Math.max(0, ...pages.map((p) => (row ? p.height : p.width)));\n  const seen = new Set<string>();\n  let along = 0;\n  return pages.map((page, index) => {\n    if (seen.has(page.id)) throw new Error(`layoutPages: two pages have the id \"${page.id}\"`);\n    seen.add(page.id);\n    const offset = (across - (row ? page.height : page.width)) * ALIGN[align];\n    const placed = {\n      ...page,\n      x: origin.x + (row ? along : offset),\n      y: origin.y + (row ? offset : along),\n      index,\n    };\n    along += (row ? page.width : page.height) + gap;\n    return placed;\n  });\n}\n\n/** The name page `index` of the page order shows: its own, else \"Page\" and its place. */\nexport function pageName(page: { readonly name?: string | undefined }, index: number): string {\n  return page.name ?? `Page ${index + 1}`;\n}\n\n/** The page under a world point, or `null` between and outside them. A point on an edge is on the page. */\nexport function pageAt(\n  pages: readonly PlacedPage[],\n  point: { readonly x: number; readonly y: number },\n): PlacedPage | null {\n  return pageOfBounds(pages, { x: point.x, y: point.y, width: 0, height: 0 });\n}\n\nfunction overlap(page: PlacedPage, b: Bounds): number | null {\n  const w = Math.min(page.x + page.width, b.x + b.width) - Math.max(page.x, b.x);\n  const h = Math.min(page.y + page.height, b.y + b.height) - Math.max(page.y, b.y);\n  return w < 0 || h < 0 ? null : w * h;\n}\n\n/**\n * The page a world-space box belongs to: the one it overlaps most, the earlier\n * of two it overlaps equally, and `null` when it touches none. This is the\n * rule that says which page an object is on.\n */\nexport function pageOfBounds(pages: readonly PlacedPage[], bounds: Bounds): PlacedPage | null {\n  let best: PlacedPage | null = null;\n  let most = -1;\n  for (const page of pages) {\n    const area = overlap(page, bounds);\n    if (area !== null && area > most) {\n      best = page;\n      most = area;\n    }\n  }\n  return best;\n}\n\nfunction gap(page: PlacedPage, b: Bounds): number {\n  const dx = Math.max(page.x - (b.x + b.width), b.x - (page.x + page.width), 0);\n  const dy = Math.max(page.y - (b.y + b.height), b.y - (page.y + page.height), 0);\n  return Math.hypot(dx, dy);\n}\n\n/**\n * The page a world-space box is held by: the one it is on (`pageOfBounds`),\n * else the one nearest it by the box-to-box gap, the earlier of two equally\n * near. `null` only with no pages. Used where every object must land on some\n * page, such as an export; `pageOfBounds` stays the rule for what is on one.\n */\nexport function pageHolding(pages: readonly PlacedPage[], bounds: Bounds): PlacedPage | null {\n  const on = pageOfBounds(pages, bounds);\n  if (on !== null) return on;\n  let best: PlacedPage | null = null;\n  let least = Infinity;\n  for (const page of pages) {\n    const d = gap(page, bounds);\n    if (d < least) {\n      best = page;\n      least = d;\n    }\n  }\n  return best;\n}\n\n/**\n * The page `step` places along the page order from the one with id `current`:\n * the next slide is `1`, the one before is `-1`. `null` past either end, unless\n * `wrap`. With no current page in the list, a step forward starts at the first\n * page and a step back at the last.\n */\nexport function adjacentPage(\n  pages: readonly PlacedPage[],\n  current: string | null,\n  step: number,\n  options: { wrap?: boolean } = {},\n): PlacedPage | null {\n  const n = pages.length;\n  if (n === 0) return null;\n  const at = pages.findIndex((p) => p.id === current);\n  if (at < 0) return pages[step < 0 ? n - 1 : 0] ?? null;\n  const to = at + step;\n  return pages[options.wrap ? ((to % n) + n) % n : to] ?? null;\n}\n\n/** The box around every page, or `null` for a document with none. */\nexport function pagesBounds(pages: readonly PlacedPage[]): Bounds | null {\n  if (pages.length === 0) return null;\n  const x = Math.min(...pages.map((p) => p.x));\n  const y = Math.min(...pages.map((p) => p.y));\n  return {\n    x,\n    y,\n    width: Math.max(...pages.map((p) => p.x + p.width)) - x,\n    height: Math.max(...pages.map((p) => p.y + p.height)) - y,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"pages.js","names":[],"sources":["../../../src/core/pages/pages.ts"],"sourcesContent":["import { unionRects } from '@weasel-js/geom';\nimport type { Bounds } from '@weasel-js/routing';\n\n/** One page of a document: a sheet of a fixed size, in world units. */\nexport interface Page {\n  readonly id: string;\n  readonly name?: string;\n  readonly width: number;\n  readonly height: number;\n  /** What other packages keep on the page, each under its owner's key (`'diagram:graph'`). Every page edit\n   *  carries it, and the page's placement copies it. */\n  readonly meta?: Readonly<Record<string, unknown>>;\n}\n\n/** A page and where it sits in world space. */\nexport interface PlacedPage extends Page {\n  readonly x: number;\n  readonly y: number;\n  /** Its place in the document's page order. */\n  readonly index: number;\n}\n\n/** Options for {@link layoutPages}. */\nexport interface PageLayoutOptions {\n  /** Which way the pages run. Default `'row'`. */\n  direction?: 'row' | 'column';\n  /** World units between neighbors. Default 40. */\n  gap?: number;\n  /** Where a page sits across the run, against the largest page. Default `'start'`. */\n  align?: 'start' | 'center' | 'end';\n  /** Where the first page's run starts. Default the world origin. */\n  origin?: { readonly x: number; readonly y: number };\n}\n\nconst ALIGN = { start: 0, center: 0.5, end: 1 } as const;\n\n/**\n * Place a document's pages in one world space, in order, so a single scene,\n * view, and history serve all of them. With the defaults the first page's\n * top-left corner is the world origin, where a one-page document's page is.\n * Throws on two pages with one id.\n */\nexport function layoutPages(pages: readonly Page[], options: PageLayoutOptions = {}): PlacedPage[] {\n  const { direction = 'row', gap = 40, align = 'start', origin = { x: 0, y: 0 } } = options;\n  const row = direction === 'row';\n  const across = Math.max(0, ...pages.map((p) => (row ? p.height : p.width)));\n  const seen = new Set<string>();\n  let along = 0;\n  return pages.map((page, index) => {\n    if (seen.has(page.id)) throw new Error(`layoutPages: two pages have the id \"${page.id}\"`);\n    seen.add(page.id);\n    const offset = (across - (row ? page.height : page.width)) * ALIGN[align];\n    const placed = {\n      ...page,\n      x: origin.x + (row ? along : offset),\n      y: origin.y + (row ? offset : along),\n      index,\n    };\n    along += (row ? page.width : page.height) + gap;\n    return placed;\n  });\n}\n\n/** The name page `index` of the page order shows: its own, else \"Page\" and its place. */\nexport function pageName(page: { readonly name?: string | undefined }, index: number): string {\n  return page.name ?? `Page ${index + 1}`;\n}\n\n/** The page under a world point, or `null` between and outside them. A point on an edge is on the page. */\nexport function pageAt(\n  pages: readonly PlacedPage[],\n  point: { readonly x: number; readonly y: number },\n): PlacedPage | null {\n  return pageOfBounds(pages, { x: point.x, y: point.y, width: 0, height: 0 });\n}\n\nfunction overlap(page: PlacedPage, b: Bounds): number | null {\n  const w = Math.min(page.x + page.width, b.x + b.width) - Math.max(page.x, b.x);\n  const h = Math.min(page.y + page.height, b.y + b.height) - Math.max(page.y, b.y);\n  return w < 0 || h < 0 ? null : w * h;\n}\n\n/**\n * The page a world-space box belongs to: the one it overlaps most, the earlier\n * of two it overlaps equally, and `null` when it touches none. This is the\n * rule that says which page an object is on.\n */\nexport function pageOfBounds(pages: readonly PlacedPage[], bounds: Bounds): PlacedPage | null {\n  let best: PlacedPage | null = null;\n  let most = -1;\n  for (const page of pages) {\n    const area = overlap(page, bounds);\n    if (area !== null && area > most) {\n      best = page;\n      most = area;\n    }\n  }\n  return best;\n}\n\nfunction gap(page: PlacedPage, b: Bounds): number {\n  const dx = Math.max(page.x - (b.x + b.width), b.x - (page.x + page.width), 0);\n  const dy = Math.max(page.y - (b.y + b.height), b.y - (page.y + page.height), 0);\n  return Math.hypot(dx, dy);\n}\n\n/**\n * The page a world-space box is held by: the one it is on (`pageOfBounds`),\n * else the one nearest it by the box-to-box gap, the earlier of two equally\n * near. `null` only with no pages. Used where every object must land on some\n * page, such as an export; `pageOfBounds` stays the rule for what is on one.\n */\nexport function pageHolding(pages: readonly PlacedPage[], bounds: Bounds): PlacedPage | null {\n  const on = pageOfBounds(pages, bounds);\n  if (on !== null) return on;\n  let best: PlacedPage | null = null;\n  let least = Infinity;\n  for (const page of pages) {\n    const d = gap(page, bounds);\n    if (d < least) {\n      best = page;\n      least = d;\n    }\n  }\n  return best;\n}\n\n/**\n * The page `step` places along the page order from the one with id `current`:\n * the next slide is `1`, the one before is `-1`. `null` past either end, unless\n * `wrap`. With no current page in the list, a step forward starts at the first\n * page and a step back at the last.\n */\nexport function adjacentPage(\n  pages: readonly PlacedPage[],\n  current: string | null,\n  step: number,\n  options: { wrap?: boolean } = {},\n): PlacedPage | null {\n  const n = pages.length;\n  if (n === 0) return null;\n  const at = pages.findIndex((p) => p.id === current);\n  if (at < 0) return pages[step < 0 ? n - 1 : 0] ?? null;\n  const to = at + step;\n  return pages[options.wrap ? ((to % n) + n) % n : to] ?? null;\n}\n\n/** The box around every page, or `null` for a document with none. */\nexport function pagesBounds(pages: readonly PlacedPage[]): Bounds | null {\n  return unionRects(pages);\n}\n"],"mappings":"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"}

package/dist/core/pages/pagesLayer.js

@@ -1,4 +1,4 @@
-//#region src/core/pages/pagesLayer.ts
+// src/core/pages/pagesLayer.ts
 /**
 * The sheets themselves: a world-space layer that paints each placed page as a
 * filled rect, to sit under the scene. Build it again when the pages or the
@@ -28,6 +28,5 @@ function pagesLayer(pages, options) {
 	};
 }
 
-//#endregion
 export { pagesLayer };
 //# sourceMappingURL=pagesLayer.js.map

package/dist/core/paint/meshKind.js

@@ -1,6 +1,6 @@
 import { meshDrawKind, meshFromStops, meshGradientXml, meshStops, seedMeshPatch } from "@weasel-js/renderer/mesh";
 
-//#region src/core/paint/meshKind.ts
+// src/core/paint/meshKind.ts
 var asMesh = (fill) => fill;
 var asFill = (mesh) => mesh;
 /** The `mesh-gradient` kind's registry entry. `./registerMesh` registers it;
@@ -16,6 +16,5 @@ var meshGradientKind = {
 	toSvg: (id, fill) => meshGradientXml(id, asMesh(fill))
 };
 
-//#endregion
 export { meshGradientKind };
 //# sourceMappingURL=meshKind.js.map