@weasel-js/core 1.9.3 → 1.10.0

package/dist/core/layers/render.js.map

@@ -1 +1 @@
-{"version":3,"file":"render.js","names":["IDENTITY_VIEW","reportLayerFailure","layerId","error","subscribeToSources","offs","sources","l","listener","off","clockMs","drawLayers","layerById","layers","sequence","order","id","v","view","out","cache","groupOf","groupMembership","groups","bracketed","run","closeRun","start","t0","spans","c","wrapGroup","dims","layer","isLayerVisible","visibility","cmds","drawOneLayer","data","onLayerError","buildMs","group","stack","layerIds","byLayer","name","matched","claimed","declared","effects","children","isLayerPainted","layerCommands","viewToMat3","deps","entry","depsUnchanged","a","b","i"],"sources":["../../../src/core/layers/render.ts"],"sourcesContent":["import { viewToMat3, type DrawCommand } from '../../renderer';\nimport type { Effect } from '../../renderer/effects/types';\nimport type { View } from 'core/viewport/view';\n\nconst IDENTITY_VIEW: View = { x: 0, y: 0, scale: { x: 1, y: 1 } };\n\n/**\n * Canvas size in CSS pixels — passed to `draw` for layers that anchor to\n * canvas edges (e.g. the debug overlay's layer-list panel). The GL backend\n * supplies it explicitly so layers don't have to know about DPR.\n */\nexport interface Dims {\n  width: number;\n  height: number;\n}\n\n/**\n * What a layer's `draw` threw, and which layer threw it.\n *\n * A `draw` runs on the frame loop, so a throw that escapes it surfaces as an\n * uncaught `requestAnimationFrame` error on the window and takes the whole\n * frame with it — every other layer included. One broken layer painting\n * nothing, named in the console, is the lesser wrong.\n */\nexport interface LayerDrawFailure {\n  layerId: string;\n  error: unknown;\n}\n\n/** Default report: name the layer, keep the frame. */\nfunction reportLayerFailure({ layerId, error }: LayerDrawFailure): void {\n  console.error(\n    `[weasel] layer \"${layerId}\" threw while drawing; it painted nothing this frame.`,\n    error,\n  );\n}\n\n/**\n * Several consecutive layers composited as one.\n *\n * A layer's own `effects` run over that layer alone, which is the wrong\n * picture whenever a pass reads neighboring pixels: `blur(A over B)` is not\n * `blur(A) over blur(B)`, and it costs a buffer and a pass chain per layer. A\n * group draws its members into one buffer, runs one chain over it, and\n * composites the result back once.\n *\n * Membership is by `RenderLayer.id` — the same names `layerOrder` and\n * `layerVisibility` use, not the `layers` map's slot keys.\n *\n * Only *consecutive* members share a buffer, because anything drawn between\n * two members has to land between them. A group whose members are separated in\n * the render order is drawn as one bracket per run, with a warning: the\n * picture is right, the declaration almost certainly is not.\n *\n * This is a render-stack bracket, not a scene `ContainerNode` — it holds no\n * ids, survives no reload, and nothing in the scene knows about it.\n */\nexport interface LayerGroup {\n  /** Names the group in warnings; not a layer id and never drawn. */\n  id: string;\n  /**\n   * Member layer ids. Order here is ignored — the render order decides.\n   *\n   * A name claims that layer and every layer under it in the `:` namespace, so\n   * `'scene'` covers the `scene:<layerId>` layers a scene with declared layers\n   * draws as — the same set `before`/`after: 'scene'` anchors against. The\n   * separator is required: `'scene'` does not reach `scenery`. A name matching\n   * no layer being drawn is warned about rather than ignored.\n   */\n  layers: readonly string[];\n  /**\n   * Passes over the group's combined pixels, in order. A thunk is re-read on\n   * every frame, so an animating radius costs no React render; an array is\n   * read once per frame either way.\n   */\n  effects?: readonly Effect[] | ((view: View, dims: Dims) => readonly Effect[]);\n  /** Opacity applied to the group's composited result, not to each member. */\n  alpha?: number;\n  /** 4×5 color matrix (row-major, 20 numbers) applied to the composited\n   *  result. See `GroupDrawCommand.colorMatrix`. */\n  colorMatrix?: number[];\n}\n\n/** One layer's memoized output, keyed by layer id. Owned by the canvas that\n *  calls `drawLayers`, not by `drawLayers` itself — the function is pure. */\nexport type LayerCommandCache = Map<\n  string,\n  { deps: readonly unknown[]; cmds: DrawCommand[] }\n>;\n\n/**\n * A single named render sub-layer within a canvas renderer.\n *\n * @template TData - The data object passed to each draw call.\n */\n/** Something outside React whose changes a paint reads — a mode registry, a\n *  scoping lookup. A notification repaints the canvas; the listener takes no\n *  arguments and the returned function unsubscribes. */\nexport interface RedrawSource {\n  subscribe(listener: () => void): () => void;\n}\n\n/** The `subscribe` for a layer that draws `sources`: it notifies whenever any\n *  of them does. A thunk is read when the subscription is made. Every layer\n *  that draws other layers declares this, so wrapping never silences what\n *  repaints a source. */\nexport function subscribeToSources(\n  sources: readonly { subscribe?: RedrawSource['subscribe'] }[]\n    | (() => readonly { subscribe?: RedrawSource['subscribe'] }[]),\n): RedrawSource['subscribe'] {\n  return (listener) => {\n    const list = typeof sources === 'function' ? sources() : sources;\n    const offs = list.flatMap((l) => (l.subscribe ? [l.subscribe(listener)] : []));\n    return () => { for (const off of offs) off(); };\n  };\n}\n\n/** One layer of a canvas: `draw` turns `data` and the view into draw commands;\n *  the other fields control caching, visibility, coordinate space and hit-testing. */\nexport interface RenderLayer<TData> {\n  /** Unique identifier used in visibility maps and ordering arrays. When a\n   *  cache is in use, an id must identify the same logical layer across\n   *  frames — reusing it for a different layer can serve cross-layer commands. */\n  id: string;\n  /** Human-readable name for UI toggles. */\n  label: string;\n  /**\n   * Emit a DrawCommand tree for the GL backend to dispatch.\n   *\n   * For world-space layers (the default), emit commands in WORLD COORDS —\n   * `drawLayers` automatically wraps them in `{ kind: 'group', transform:\n   * viewToMat3(view), ... }` before handing them to the renderer. Do NOT\n   * apply the view transform yourself.\n   *\n   * For screen-space layers (`space: 'screen'`), emit commands in CSS-pixel\n   * coords directly; `drawLayers` passes them through unchanged. If part\n   * of a screen-space layer's output needs to track the view, wrap that\n   * subset manually with `viewToMat3(view)`.\n   */\n  draw: (data: TData, view: View, dims: Dims) => DrawCommand[];\n  /**\n   * Optional cache key. When present and a `LayerCommandCache` is supplied to\n   * `drawLayers`, the layer's previous `DrawCommand[]` is reused as long as\n   * every entry is `Object.is`-equal to the previous call's. A layer with no\n   * `deps` rebuilds on every frame.\n   *\n   * **The returned commands must be treated as immutable.** A cached tree is\n   * handed to the renderer again on later frames, so mutating a tree you\n   * previously returned corrupts the cache silently rather than erroring.\n   *\n   * **Screen-space layers are not protected against a stale `view`/`dims`\n   * the way world-space layers are** (see `space` below) — include them in\n   * `deps` if `draw` reads them.\n   */\n  deps?: (data: TData, view: View, dims: Dims) => readonly unknown[];\n  /**\n   * Whether the layer is shown when no explicit visibility entry exists.\n   * Defaults to `true` when absent.\n   */\n  defaultVisible?: boolean;\n  /**\n   * When true, the layer is always drawn regardless of the visibility map.\n   * Useful for layers that must never be hidden (e.g. base grid).\n   */\n  alwaysOn?: boolean;\n  /**\n   * Coordinate space the layer draws in.\n   *\n   * - `'world'` (default): the layer's `draw` returns world-space commands;\n   *   `drawLayers` wraps them in a `kind: 'group'` with `viewToMat3(view)`\n   *   automatically.\n   * - `'screen'`: the layer's `draw` returns screen-space (CSS-pixel)\n   *   commands; `drawLayers` passes them through unchanged. World-anchored\n   *   chrome inside a screen-space layer must call `worldToScreen` or wrap\n   *   the relevant subset with `viewToMat3(view)` manually.\n   */\n  space?: 'world' | 'screen';\n  /**\n   * Where the layer learns that state `draw` reads, outside the scene and the\n   * props, has changed. The canvas painting it subscribes while the layer is\n   * mounted and repaints on every notification, so a layer reading a mode\n   * registry needs no consumer code to follow a mode switch.\n   */\n  subscribe?: RedrawSource['subscribe'];\n  /**\n   * Full-screen passes run over this layer's own pixels before it joins the\n   * frame — a blur here blurs the world and leaves the HUD drawn above it\n   * sharp, which is the thing a CSS `filter` on the `<canvas>` cannot do.\n   *\n   * Costs nothing while empty: the renderer allocates no offscreen buffer\n   * until a layer actually declares one. See `GroupDrawCommand.effects` for\n   * what a pass may read, and {@link LayerGroup} to run one chain over\n   * several layers at once instead of one chain each.\n   */\n  effects?: readonly Effect[];\n  /**\n   * Optional hit-test for **consumer-attached** layers.\n   *\n   * Only layers registered through `CanvasExtensionApi.registerLayer` are\n   * hit-tested: `hitTestExtras` walks them last-registered-first on\n   * pointerdown, and `<SceneCanvas>` folds the result into its `affordanceAt`\n   * thunk ahead of the kit's own selection chrome. First non-null result\n   * wins; null means \"I don't claim this hit, try the next layer.\"\n   *\n   * Layers that reach the draw stack some other way — a `Tool.overlay`, an\n   * entry in the `layers` map — are painted but never hit-tested, so defining\n   * `hitTest` on one has no effect. (The kit's own chrome doesn't need it: it\n   * goes through `buildAffordanceAt`.)\n   *\n   * Coordinates are world-space. The `data` arg is the layer's\n   * configured data slot (same as `draw`); `view` and `dims` mirror\n   * `draw`'s arguments.\n   */\n  hitTest?: (\n    worldX: number,\n    worldY: number,\n    data: TData,\n    view: View,\n    dims: Dims,\n    /** Chrome-caps visibility predicate. When supplied, the layer must\n     *  not return a hit from any chrome element whose id reports\n     *  `false`. Absent → every element is hittable. */\n    isVisible?: (id: string) => boolean,\n  ) => import('../../affordances/types').LayerHit | null;\n  /**\n   * Called on every pointermove when no gesture is currently captured.\n   * Lets layers (e.g. HUD widgets) track hover state without participating\n   * in the drag pipeline. Coords are world-space; the layer is responsible\n   * for any further conversion (e.g. world→screen for screen-space layers)\n   * and for its own throttling.\n   */\n  onUncapturedMove?: (\n    worldX: number,\n    worldY: number,\n    evt: PointerEvent,\n    view: View,\n    dims: Dims,\n  ) => void;\n  /**\n   * Called when the cursor leaves the canvas element. Lets layers clear\n   * any hover state they're holding.\n   */\n  onUncapturedLeave?: () => void;\n}\n\n/** Where one layer's commands landed in {@link drawLayers}' output,\n *  `[start, end)`, and the CPU milliseconds its `draw` took. A layer group's\n *  run is one span under the group's id. */\nexport interface LayerDrawSpan {\n  id: string;\n  start: number;\n  end: number;\n  buildMs: number;\n}\n\nfunction clockMs(): number {\n  return typeof performance !== 'undefined' ? performance.now() : Date.now();\n}\n\n/**\n * Walk visible layers and concatenate their emitted DrawCommand arrays into\n * one flat list, ready to feed to `WeaselRenderer.render(commands)`.\n *\n * Visibility resolution order:\n *   1. `alwaysOn` — always drawn, ignores visibility map.\n *   2. Explicit entry in `visibility` map — overrides default.\n *   3. `layer.defaultVisible` — falls back to `true` when absent.\n *\n * Transform composition: world-space layers (the default; `space` unset or\n * `'world'`) have their commands wrapped in a `kind: 'group'` with\n * `viewToMat3(view)` before they reach the renderer. Screen-space layers\n * (`space: 'screen'`) pass through unchanged.\n *\n * A layer whose `draw` throws is dropped for the frame and reported through\n * `onLayerError` — the rest of the frame still paints.\n *\n * `groups` brackets runs of consecutive layers so they composite as one — see\n * `LayerGroup`. A layer named by no group is emitted exactly as it was before\n * groups existed, and a frame that declares none allocates nothing.\n *\n * `spans`, when passed, receives one {@link LayerDrawSpan} per layer drawn.\n */\nexport function drawLayers<TData>(\n  layers: RenderLayer<TData>[],\n  data: TData,\n  visibility: Record<string, boolean>,\n  order: string[] | undefined,\n  view: View | undefined,\n  dims: Dims,\n  cache?: LayerCommandCache,\n  onLayerError: (failure: LayerDrawFailure) => void = reportLayerFailure,\n  groups?: readonly LayerGroup[],\n  spans?: LayerDrawSpan[],\n): DrawCommand[] {\n  const layerById = new Map(layers.map((l) => [l.id, l]));\n  const sequence = order\n    ? order.map((id) => layerById.get(id)).filter((l): l is RenderLayer<TData> => l !== undefined)\n    : layers;\n  const v = view ?? IDENTITY_VIEW;\n  const out: DrawCommand[] = [];\n\n  if (cache) {\n    for (const id of [...cache.keys()]) {\n      if (!layerById.has(id)) cache.delete(id);\n    }\n  }\n\n  const groupOf = groupMembership(groups, layerById.keys());\n  const bracketed = new Set<LayerGroup>();\n  let run: { group: LayerGroup; children: DrawCommand[]; buildMs: number } | null = null;\n\n  const closeRun = () => {\n    if (!run) return;\n    const start = out.length;\n    const t0 = spans ? clockMs() : 0;\n    for (const c of wrapGroup(run.group, run.children, v, dims)) out.push(c);\n    spans?.push({ id: run.group.id, start, end: out.length, buildMs: run.buildMs + clockMs() - t0 });\n    run = null;\n  };\n\n  for (const layer of sequence) {\n    // `order` is already applied by `sequence`; passing it again would be a\n    // second, redundant lookup for the same answer.\n    if (!isLayerVisible(layer, visibility)) continue;\n\n    const t0 = spans ? clockMs() : 0;\n    const cmds = drawOneLayer(layer, data, v, dims, cache, onLayerError);\n    const buildMs = spans ? clockMs() - t0 : 0;\n    // A layer that painted nothing neither joins a run nor breaks one. Letting\n    // it break one would split a group over a debug overlay that is switched\n    // on but currently empty.\n    if (cmds.length === 0) {\n      spans?.push({ id: layer.id, start: out.length, end: out.length, buildMs });\n      continue;\n    }\n\n    const group = groupOf?.get(layer.id);\n    if (run && run.group !== group) closeRun();\n    if (!group) {\n      const start = out.length;\n      for (const c of cmds) out.push(c);\n      spans?.push({ id: layer.id, start, end: out.length, buildMs });\n      continue;\n    }\n    if (!run) {\n      if (bracketed.has(group)) {\n        console.warn(\n          `[weasel] layer group \"${group.id}\" is not one run — another layer is drawn ` +\n          'between its members, so it composites as more than one pass over more than ' +\n          'one buffer. Move its members together in the layer order.',\n        );\n      }\n      bracketed.add(group);\n      run = { group, children: [], buildMs: 0 };\n    }\n    run.buildMs += buildMs;\n    for (const c of cmds) run.children.push(c);\n  }\n  closeRun();\n\n  return out;\n}\n\n/**\n * Layer id → the group that owns it.\n *\n * A member name claims the layer of that exact id and every layer under it in\n * the `:` namespace, so `'scene'` claims the whole split scene slot. First\n * claim wins across groups, so a second one is a declaration bug rather than a\n * silent reassignment; the same group naming a layer twice — `['scene',\n * 'scene:tiles']` — is redundant, not a conflict, and passes quietly.\n */\nfunction groupMembership(\n  groups: readonly LayerGroup[] | undefined,\n  layerIds: Iterable<string>,\n): Map<string, LayerGroup> | null {\n  if (!groups || groups.length === 0) return null;\n  const stack = [...layerIds];\n  const byLayer = new Map<string, LayerGroup>();\n  for (const group of groups) {\n    for (const name of group.layers) {\n      let matched = false;\n      for (const id of stack) {\n        if (id !== name && !id.startsWith(`${name}:`)) continue;\n        matched = true;\n        const claimed = byLayer.get(id);\n        if (claimed === group) continue;\n        if (claimed) {\n          console.warn(\n            `[weasel] layer \"${id}\" is claimed by layer groups \"${claimed.id}\" and ` +\n            `\"${group.id}\"; it stays in \"${claimed.id}\".`,\n          );\n          continue;\n        }\n        byLayer.set(id, group);\n      }\n      if (!matched) {\n        console.warn(\n          `[weasel] layer group \"${group.id}\" names \"${name}\", which matches no layer ` +\n          'being drawn, so it groups nothing. Check the id against the layer stack — a ' +\n          'scene with declared layers draws as \"scene:<layerId>\", which \"scene\" covers.',\n        );\n      }\n    }\n  }\n  return byLayer;\n}\n\n/**\n * Put one run of a group's commands under its shared compositing.\n *\n * No transform: every member already carries its own space wrap, so a second\n * one here would apply the view twice to world layers and once to screen ones.\n * A group that composites plainly gets no wrapper at all — an extra group\n * command that changes nothing is still a push and a pop per frame.\n */\nfunction wrapGroup(\n  group: LayerGroup,\n  children: DrawCommand[],\n  view: View,\n  dims: Dims,\n): DrawCommand[] {\n  const declared = typeof group.effects === 'function'\n    ? group.effects(view, dims)\n    : group.effects;\n  const effects = declared && declared.length > 0 ? declared : undefined;\n  if (!effects && group.alpha === undefined && group.colorMatrix === undefined) return children;\n  return [{\n    kind: 'group',\n    ...(effects ? { effects } : {}),\n    ...(group.alpha !== undefined ? { alpha: group.alpha } : {}),\n    ...(group.colorMatrix !== undefined ? { colorMatrix: group.colorMatrix } : {}),\n    children,\n  }];\n}\n\n/**\n * Resolve one layer's visibility: `alwaysOn` wins, then an explicit entry in\n * `visibility`, then `defaultVisible`, defaulting to shown.\n */\nexport function isLayerVisible<TData>(\n  layer: RenderLayer<TData>,\n  visibility: Record<string, boolean>,\n): boolean {\n  if (layer.alwaysOn) return true;\n  if (layer.id in visibility) return visibility[layer.id]!;\n  return layer.defaultVisible ?? true;\n}\n\n/**\n * Does this layer reach the screen at all — both gates, in the order\n * `drawLayers` applies them.\n *\n * **A listed `order` is the whole list**, so omission from it drops a layer\n * that `visibility` would have shown, and `alwaysOn` does not rescue it.\n * Hit-testing asks this, not `isLayerVisible`: a layer that is not painted\n * but still claims pointer events is a pointer landing on nothing the user\n * can see.\n */\nexport function isLayerPainted<TData>(\n  layer: RenderLayer<TData>,\n  visibility: Record<string, boolean>,\n  order: string[] | undefined,\n): boolean {\n  if (order && !order.includes(layer.id)) return false;\n  return isLayerVisible(layer, visibility);\n}\n\n/**\n * Draw one layer and put its commands in the space its `space` declares:\n * world-space output wrapped in a `viewToMat3(view)` group, screen-space\n * output passed through.\n *\n * Anything rendering layers through a view — the canvas itself, a viewport\n * node's inner pass — goes through here. A second copy of this rule that\n * forgets the wrap draws world content at raw world coords, which looks\n * plausible at the identity view and wrong everywhere else.\n *\n * A `draw` that throws yields no commands, and `onLayerError` is told which\n * layer it was. The layer's cache entry goes with it, so the next frame is a\n * real re-attempt rather than a stale tree served under fresh deps.\n */\nexport function drawOneLayer<TData>(\n  layer: RenderLayer<TData>,\n  data: TData,\n  view: View,\n  dims: Dims,\n  cache?: LayerCommandCache,\n  onLayerError: (failure: LayerDrawFailure) => void = reportLayerFailure,\n): DrawCommand[] {\n  let cmds: DrawCommand[];\n  try {\n    cmds = layerCommands(layer, data, view, dims, cache);\n  } catch (error) {\n    cache?.delete(layer.id);\n    onLayerError({ layerId: layer.id, error });\n    return [];\n  }\n  if (cmds.length === 0) return [];\n  const effects = layer.effects && layer.effects.length > 0 ? layer.effects : undefined;\n  if ((layer.space ?? 'world') === 'screen') {\n    return effects ? [{ kind: 'group', effects, children: cmds }] : cmds;\n  }\n  return [{ kind: 'group', transform: viewToMat3(view), ...(effects ? { effects } : {}), children: cmds }];\n}\n\n/**\n * One layer's own commands, from cache when its deps are unchanged.\n *\n * What is cached is the layer's raw output, before the space wrap above. The\n * wrap is a function of `view`, and a layer whose content does not depend on\n * the camera is entitled to leave `view` out of its deps — caching the wrapped\n * group would then serve a stale transform the moment the camera moved.\n */\nfunction layerCommands<TData>(\n  layer: RenderLayer<TData>,\n  data: TData,\n  view: View,\n  dims: Dims,\n  cache: LayerCommandCache | undefined,\n): DrawCommand[] {\n  if (!cache || !layer.deps) return layer.draw(data, view, dims);\n\n  const deps = layer.deps(data, view, dims);\n  const entry = cache.get(layer.id);\n  if (entry && depsUnchanged(entry.deps, deps)) return entry.cmds;\n\n  const cmds = layer.draw(data, view, dims);\n  cache.set(layer.id, { deps, cmds });\n  return cmds;\n}\n\n/** Whether `b` matches `a` entry for entry under `Object.is` — how\n *  `RenderLayer.deps` is compared, and any cache keyed the same way. */\nexport function depsUnchanged(a: readonly unknown[], b: readonly unknown[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) {\n    if (!Object.is(a[i], b[i])) return false;\n  }\n  return true;\n}\n"],"mappings":"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"}
+{"version":3,"file":"render.js","names":["IDENTITY_VIEW","reportLayerFailure","layerId","error","subscribeToSources","offs","sources","l","listener","off","clockMs","drawLayers","layerById","layers","view","out","cache","id","groupOf","groupMembership","groups","bracketed","run","closeRun","start","t0","spans","c","wrapGroup","dims","layer","paintedLayers","visibility","order","cmds","drawOneLayer","data","onLayerError","buildMs","group","isLayerVisible","isLayerPainted","byId","layerCommands","effects","viewToMat3","deps","entry","depsUnchanged","a","b","i"],"sources":["../../../src/core/layers/render.ts"],"sourcesContent":["import { viewToMat3, type DrawCommand } from '@weasel-js/renderer';\nimport type { Effect } from '@weasel-js/renderer';\nimport type { View } from 'core/viewport/view';\nimport { groupMembership, wrapGroup, type LayerGroup } from './layerGroup';\n\nexport type { LayerGroup };\n\nconst IDENTITY_VIEW: View = { x: 0, y: 0, scale: { x: 1, y: 1 } };\n\n/** Canvas size in CSS pixels, so layers don't have to know about DPR. */\nexport interface Dims {\n  width: number;\n  height: number;\n}\n\n/**\n * What a layer's `draw` threw, and which layer threw it. A throw that escaped\n * the frame loop would take the whole frame with it, every other layer\n * included.\n */\nexport interface LayerDrawFailure {\n  layerId: string;\n  error: unknown;\n}\n\n/** Default report: name the layer, keep the frame. */\nfunction reportLayerFailure({ layerId, error }: LayerDrawFailure): void {\n  console.error(\n    `[weasel] layer \"${layerId}\" threw while drawing; it painted nothing this frame.`,\n    error,\n  );\n}\n\n/** One layer's memoized output, keyed by layer id. Owned by the canvas that\n *  calls `drawLayers`, not by `drawLayers` itself — the function is pure. */\nexport type LayerCommandCache = Map<\n  string,\n  { deps: readonly unknown[]; cmds: DrawCommand[] }\n>;\n\n/** Something outside React whose changes a paint reads — a mode registry, a\n *  scoping lookup. A notification repaints the canvas; the listener takes no\n *  arguments and the returned function unsubscribes. */\nexport interface RedrawSource {\n  subscribe(listener: () => void): () => void;\n}\n\n/** The `subscribe` for a layer that draws `sources`: it notifies whenever any\n *  of them does. A thunk is read when the subscription is made. */\nexport function subscribeToSources(\n  sources: readonly { subscribe?: RedrawSource['subscribe'] }[]\n    | (() => readonly { subscribe?: RedrawSource['subscribe'] }[]),\n): RedrawSource['subscribe'] {\n  return (listener) => {\n    const list = typeof sources === 'function' ? sources() : sources;\n    const offs = list.flatMap((l) => (l.subscribe ? [l.subscribe(listener)] : []));\n    return () => { for (const off of offs) off(); };\n  };\n}\n\n/**\n * One layer of a canvas: `draw` turns `data` and the view into draw commands;\n * the other fields control caching, visibility, coordinate space and hit-testing.\n *\n * @template TData - The data object passed to each draw call.\n */\nexport interface RenderLayer<TData> {\n  /** Unique identifier used in visibility maps and ordering arrays. When a\n   *  cache is in use, an id must identify the same logical layer across\n   *  frames — reusing it for a different layer can serve cross-layer commands. */\n  id: string;\n  /** Human-readable name for UI toggles. */\n  label: string;\n  /**\n   * Emit a DrawCommand tree, in the coordinates `space` names. A world-space\n   * layer must NOT apply the view transform itself.\n   */\n  draw: (data: TData, view: View, dims: Dims) => DrawCommand[];\n  /**\n   * Optional cache key. When present and a `LayerCommandCache` is supplied to\n   * `drawLayers`, the layer's previous `DrawCommand[]` is reused as long as\n   * every entry is `Object.is`-equal to the previous call's. A layer with no\n   * `deps` rebuilds on every frame.\n   *\n   * **The returned commands must be treated as immutable.** A cached tree is\n   * handed to the renderer again on later frames, so mutating a tree you\n   * previously returned corrupts the cache silently rather than erroring.\n   *\n   * **Screen-space layers are not protected against a stale `view`/`dims`\n   * the way world-space layers are** (see `space` below) — include them in\n   * `deps` if `draw` reads them.\n   */\n  deps?: (data: TData, view: View, dims: Dims) => readonly unknown[];\n  /** Whether the layer is shown when no explicit visibility entry exists.\n   *  Defaults to `true` when absent. */\n  defaultVisible?: boolean;\n  /** When true, the layer is always drawn regardless of the visibility map. */\n  alwaysOn?: boolean;\n  /**\n   * Coordinate space the layer draws in.\n   *\n   * - `'world'` (default): the layer's `draw` returns world-space commands;\n   *   `drawLayers` wraps them in a `kind: 'group'` with `viewToMat3(view)`\n   *   automatically.\n   * - `'screen'`: the layer's `draw` returns screen-space (CSS-pixel)\n   *   commands; `drawLayers` passes them through unchanged. World-anchored\n   *   chrome inside a screen-space layer must call `worldToScreen` or wrap\n   *   the relevant subset with `viewToMat3(view)` manually.\n   */\n  space?: 'world' | 'screen';\n  /**\n   * Where the layer learns that state `draw` reads, outside the scene and the\n   * props, has changed. The canvas painting it subscribes while the layer is\n   * mounted and repaints on every notification.\n   */\n  subscribe?: RedrawSource['subscribe'];\n  /**\n   * Full-screen passes run over this layer's own pixels before it joins the\n   * frame. See `GroupDrawCommand.effects` for what a pass may read, and\n   * {@link LayerGroup} to run one chain over several layers at once.\n   */\n  effects?: readonly Effect[];\n  /**\n   * Optional hit-test for **consumer-attached** layers.\n   *\n   * Only layers registered through `CanvasExtensionApi.registerLayer` are\n   * hit-tested, last-registered-first, ahead of the kit's own selection\n   * chrome. First non-null result wins; null means \"I don't claim this hit,\n   * try the next layer.\"\n   *\n   * Layers that reach the draw stack some other way — a `Tool.overlay`, an\n   * entry in the `layers` map — are painted but never hit-tested, so defining\n   * `hitTest` on one has no effect.\n   *\n   * Coordinates are world-space.\n   */\n  hitTest?: (\n    worldX: number,\n    worldY: number,\n    data: TData,\n    view: View,\n    dims: Dims,\n    /** Chrome-caps visibility predicate. When supplied, the layer must\n     *  not return a hit from any chrome element whose id reports\n     *  `false`. Absent → every element is hittable. */\n    isVisible?: (id: string) => boolean,\n  ) => import('../../affordances/types').LayerHit | null;\n  /**\n   * Called on every pointermove when no gesture is currently captured, so a\n   * layer can track hover state. Coords are world-space, and the layer does\n   * its own throttling.\n   */\n  onUncapturedMove?: (\n    worldX: number,\n    worldY: number,\n    evt: PointerEvent,\n    view: View,\n    dims: Dims,\n  ) => void;\n  /** Called when the cursor leaves the canvas element. */\n  onUncapturedLeave?: () => void;\n}\n\n/** Where one layer's commands landed in {@link drawLayers}' output,\n *  `[start, end)`, and the CPU milliseconds its `draw` took. A layer group's\n *  run is one span under the group's id. */\nexport interface LayerDrawSpan {\n  id: string;\n  start: number;\n  end: number;\n  buildMs: number;\n}\n\nfunction clockMs(): number {\n  return typeof performance !== 'undefined' ? performance.now() : Date.now();\n}\n\n/**\n * Walk visible layers and concatenate their emitted DrawCommand arrays into\n * one flat list, ready to feed to `WeaselRenderer.render(commands)`.\n *\n * A layer whose `draw` throws is dropped for the frame and reported through\n * `onLayerError` — the rest of the frame still paints.\n *\n * `groups` brackets runs of consecutive layers so they composite as one — see\n * `LayerGroup`. `spans`, when passed, receives one {@link LayerDrawSpan} per\n * layer drawn.\n */\nexport function drawLayers<TData>(\n  layers: RenderLayer<TData>[],\n  data: TData,\n  visibility: Record<string, boolean>,\n  order: string[] | undefined,\n  view: View | undefined,\n  dims: Dims,\n  cache?: LayerCommandCache,\n  onLayerError: (failure: LayerDrawFailure) => void = reportLayerFailure,\n  groups?: readonly LayerGroup[],\n  spans?: LayerDrawSpan[],\n): DrawCommand[] {\n  const layerById = new Map(layers.map((l) => [l.id, l]));\n  const v = view ?? IDENTITY_VIEW;\n  const out: DrawCommand[] = [];\n\n  if (cache) {\n    for (const id of [...cache.keys()]) {\n      if (!layerById.has(id)) cache.delete(id);\n    }\n  }\n\n  const groupOf = groupMembership(groups, layerById.keys());\n  const bracketed = new Set<LayerGroup>();\n  let run: { group: LayerGroup; children: DrawCommand[]; buildMs: number } | null = null;\n\n  const closeRun = () => {\n    if (!run) return;\n    const start = out.length;\n    const t0 = spans ? clockMs() : 0;\n    for (const c of wrapGroup(run.group, run.children, v, dims)) out.push(c);\n    spans?.push({ id: run.group.id, start, end: out.length, buildMs: run.buildMs + clockMs() - t0 });\n    run = null;\n  };\n\n  for (const layer of paintedLayers(layers, visibility, order)) {\n    const t0 = spans ? clockMs() : 0;\n    const cmds = drawOneLayer(layer, data, v, dims, cache, onLayerError);\n    const buildMs = spans ? clockMs() - t0 : 0;\n    // A layer that painted nothing neither joins a run nor breaks one.\n    if (cmds.length === 0) {\n      spans?.push({ id: layer.id, start: out.length, end: out.length, buildMs });\n      continue;\n    }\n\n    const group = groupOf?.get(layer.id);\n    if (run && run.group !== group) closeRun();\n    if (!group) {\n      const start = out.length;\n      for (const c of cmds) out.push(c);\n      spans?.push({ id: layer.id, start, end: out.length, buildMs });\n      continue;\n    }\n    if (!run) {\n      if (bracketed.has(group)) {\n        console.warn(\n          `[weasel] layer group \"${group.id}\" is not one run — another layer is drawn ` +\n          'between its members, so it composites as more than one pass over more than ' +\n          'one buffer. Move its members together in the layer order.',\n        );\n      }\n      bracketed.add(group);\n      run = { group, children: [], buildMs: 0 };\n    }\n    run.buildMs += buildMs;\n    for (const c of cmds) run.children.push(c);\n  }\n  closeRun();\n\n  return out;\n}\n\n/**\n * Resolve one layer's visibility: `alwaysOn` wins, then an explicit entry in\n * `visibility`, then `defaultVisible`, defaulting to shown.\n */\nexport function isLayerVisible<TData>(\n  layer: RenderLayer<TData>,\n  visibility: Record<string, boolean>,\n): boolean {\n  if (layer.alwaysOn) return true;\n  if (layer.id in visibility) return visibility[layer.id]!;\n  return layer.defaultVisible ?? true;\n}\n\n/**\n * Does this layer reach the screen at all — membership of\n * {@link paintedLayers}, asked of one layer.\n *\n * **A listed `order` is the whole list**, so omission from it drops a layer\n * that `visibility` would have shown, and `alwaysOn` does not rescue it.\n * Hit-testing asks this, not `isLayerVisible`.\n */\nexport function isLayerPainted<TData>(\n  layer: RenderLayer<TData>,\n  visibility: Record<string, boolean>,\n  order: readonly string[] | undefined,\n): boolean {\n  if (order && !order.includes(layer.id)) return false;\n  return isLayerVisible(layer, visibility);\n}\n\n/**\n * The layers that reach the screen, in the order they are drawn: `order`\n * sequences them and drops what it leaves out, then `visibility` drops what is\n * hidden. What `drawLayers` paints, and what a view narrows its stack with.\n */\nexport function paintedLayers<TData>(\n  layers: readonly RenderLayer<TData>[],\n  visibility: Record<string, boolean>,\n  order: readonly string[] | undefined,\n): RenderLayer<TData>[] {\n  if (!order) return layers.filter((l) => isLayerVisible(l, visibility));\n  const byId = new Map(layers.map((l) => [l.id, l]));\n  return order\n    .map((id) => byId.get(id))\n    .filter((l): l is RenderLayer<TData> => l !== undefined && isLayerVisible(l, visibility));\n}\n\n/**\n * Draw one layer and put its commands in the space its `space` declares:\n * world-space output wrapped in a `viewToMat3(view)` group, screen-space\n * output passed through.\n *\n * Anything rendering layers through a view goes through here.\n *\n * A `draw` that throws yields no commands, and `onLayerError` is told which\n * layer it was. The layer's cache entry goes with it, so the next frame is a\n * real re-attempt.\n */\nexport function drawOneLayer<TData>(\n  layer: RenderLayer<TData>,\n  data: TData,\n  view: View,\n  dims: Dims,\n  cache?: LayerCommandCache,\n  onLayerError: (failure: LayerDrawFailure) => void = reportLayerFailure,\n): DrawCommand[] {\n  let cmds: DrawCommand[];\n  try {\n    cmds = layerCommands(layer, data, view, dims, cache);\n  } catch (error) {\n    cache?.delete(layer.id);\n    onLayerError({ layerId: layer.id, error });\n    return [];\n  }\n  if (cmds.length === 0) return [];\n  const effects = layer.effects && layer.effects.length > 0 ? layer.effects : undefined;\n  if ((layer.space ?? 'world') === 'screen') {\n    return effects ? [{ kind: 'group', effects, children: cmds }] : cmds;\n  }\n  return [{ kind: 'group', transform: viewToMat3(view), ...(effects ? { effects } : {}), children: cmds }];\n}\n\n/**\n * One layer's own commands, from cache when its deps are unchanged.\n *\n * What is cached is the layer's raw output, before the space wrap above. The\n * wrap is a function of `view`, and a layer whose content does not depend on\n * the camera is entitled to leave `view` out of its deps — caching the wrapped\n * group would then serve a stale transform the moment the camera moved.\n */\nfunction layerCommands<TData>(\n  layer: RenderLayer<TData>,\n  data: TData,\n  view: View,\n  dims: Dims,\n  cache: LayerCommandCache | undefined,\n): DrawCommand[] {\n  if (!cache || !layer.deps) return layer.draw(data, view, dims);\n\n  const deps = layer.deps(data, view, dims);\n  const entry = cache.get(layer.id);\n  if (entry && depsUnchanged(entry.deps, deps)) return entry.cmds;\n\n  const cmds = layer.draw(data, view, dims);\n  cache.set(layer.id, { deps, cmds });\n  return cmds;\n}\n\n/** Whether `b` matches `a` entry for entry under `Object.is` — how\n *  `RenderLayer.deps` is compared, and any cache keyed the same way. */\nexport function depsUnchanged(a: readonly unknown[], b: readonly unknown[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) {\n    if (!Object.is(a[i], b[i])) return false;\n  }\n  return true;\n}\n"],"mappings":"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"}

package/dist/core/ops/arrange.js

@@ -6,6 +6,7 @@ function t(e, n, r) {
 		name: "arrange",
 		args: i,
 		label: "Arrange",
+		elideNoop: !0,
 		get coalesceKey() {
 			return i.placed === void 0 ? void 0 : `arrange:${i.placed.map((e) => e.id).sort().join(",")}`;
 		},

package/dist/core/ops/arrange.js.map

@@ -1 +1 @@
-{"version":3,"file":"arrange.js","names":["createArrangeOp","self","args","p","compute","set","write","adapter","id","pose","registerOpFactory"],"sources":["../../../src/core/ops/arrange.ts"],"sourcesContent":["import type { Op } from './types';\nimport { registerOpFactory } from './registry';\n\ninterface ArrangeAdapter {\n  setPose(id: string, pose: unknown): void;\n}\n\n/** One pose write an {@link createArrangeOp} made. */\nexport interface ArrangedPose {\n  id: string;\n  from: unknown;\n  to: unknown;\n}\n\n/** Arguments to {@link createArrangeOp}. */\nexport interface ArrangeArgs {\n  /** The writes to make. Absent until a computed arrangement has run once. */\n  placed?: ArrangedPose[];\n}\n\n/**\n * Op: write a set of poses decided when the op first applies, not when it is\n * built. The scene appends one to an edit that moves nodes into a container,\n * and `compute` asks the container what to do with them after the rest of\n * the edit has landed. Every later apply — redo, or a rebuild from a\n * serialized history — replays the writes it recorded, so the arrangement is\n * decided once. `write` replaces the adapter's `setPose` for this op and its\n * inverses — the scene passes its own, since not every adapter an edit is\n * applied through can write poses.\n */\nexport function createArrangeOp(\n  args: ArrangeArgs,\n  compute?: () => ArrangedPose[],\n  write?: (id: string, pose: unknown) => void,\n): Op {\n  const self: ArrangeArgs = { ...(args.placed ? { placed: args.placed } : {}) };\n  return {\n    name: 'arrange',\n    args: self,\n    label: 'Arrange',\n    // Names what it moved, so a coalesced entry never undoes to a pose only\n    // a later push wrote.\n    get coalesceKey() {\n      return self.placed === undefined ? undefined : `arrange:${self.placed.map((p) => p.id).sort().join(',')}`;\n    },\n    apply(adapter) {\n      if (self.placed === undefined) self.placed = compute?.() ?? [];\n      const set = write ?? ((id: string, pose: unknown) => (adapter as ArrangeAdapter).setPose(id, pose));\n      for (const p of self.placed) set(p.id, p.to);\n      return self.placed.length > 0 ? undefined : 'noop';\n    },\n    invert() {\n      const placed = self.placed ?? [];\n      return createArrangeOp({\n        placed: [...placed].reverse().map((p) => ({ id: p.id, from: p.to, to: p.from })),\n      }, undefined, write);\n    },\n  };\n}\n\nregisterOpFactory<ArrangeArgs>('arrange', (args) => createArrangeOp(args));\n"],"mappings":";;AA8BA,SAAgBA,EACd,GACA,GACA,GACI;CACJ,IAAMC,IAAoB,EAAE,GAAIC,EAAK,SAAS,EAAE,QAAQA,EAAK,OAAO,IAAI,CAAC,EAAG;CAC5E,OAAO;EACL,MAAM;EACN,MAAMD;EACN,OAAO;EAGP,IAAI,cAAc;GAChB,OAAOA,EAAK,WAAW,KAAA,IAAY,KAAA,IAAY,WAAWA,EAAK,OAAO,KAAK,MAAME,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG;EACxG;EACA,MAAM,GAAS;GACb,AAAIF,EAAK,WAAW,KAAA,MAAW,EAAK,SAASG,IAAU,KAAK,CAAC;GAC7D,IAAMC,IAAMC,OAAW,GAAY,MAAmBC,EAA2B,QAAQC,GAAIC,CAAI;GACjG,KAAK,IAAMN,KAAKF,EAAK,QAAQ,EAAIE,EAAE,IAAIA,EAAE,EAAE;GAC3C,OAAOF,EAAK,OAAO,SAAS,IAAI,KAAA,IAAY;EAC9C;EACA,SAAS;GAEP,OAAOD,EAAgB,EACrB,QAAQ,CAAC,GAFIC,EAAK,UAAU,CAAC,CAEX,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,OAAO;IAAE,IAAIE,EAAE;IAAI,MAAMA,EAAE;IAAI,IAAIA,EAAE;GAAK,EAAE,EACjF,GAAG,KAAA,GAAWG,CAAK;EACrB;CACF;AACF;AAEAI,EAA+B,YAAY,MAASV,EAAgBE,CAAI,CAAC"}
+{"version":3,"file":"arrange.js","names":["createArrangeOp","self","args","p","compute","set","write","adapter","id","pose","registerOpFactory"],"sources":["../../../src/core/ops/arrange.ts"],"sourcesContent":["import type { Op } from './types';\nimport { registerOpFactory } from './registry';\n\ninterface ArrangeAdapter {\n  setPose(id: string, pose: unknown): void;\n}\n\n/** One pose write an {@link createArrangeOp} made. */\nexport interface ArrangedPose {\n  id: string;\n  from: unknown;\n  to: unknown;\n}\n\n/** Arguments to {@link createArrangeOp}. */\nexport interface ArrangeArgs {\n  /** The writes to make. Absent until a computed arrangement has run once. */\n  placed?: ArrangedPose[];\n}\n\n/**\n * Op: write a set of poses decided when the op first applies, not when it is\n * built. The scene appends one to an edit that moves nodes into a container,\n * and `compute` asks the container what to do with them after the rest of\n * the edit has landed. Every later apply — redo, or a rebuild from a\n * serialized history — replays the writes it recorded, so the arrangement is\n * decided once. `write` replaces the adapter's `setPose` for this op and its\n * inverses — the scene passes its own, since not every adapter an edit is\n * applied through can write poses.\n */\nexport function createArrangeOp(\n  args: ArrangeArgs,\n  compute?: () => ArrangedPose[],\n  write?: (id: string, pose: unknown) => void,\n): Op {\n  const self: ArrangeArgs = { ...(args.placed ? { placed: args.placed } : {}) };\n  return {\n    name: 'arrange',\n    args: self,\n    label: 'Arrange',\n    elideNoop: true,\n    // Names what it moved, so a coalesced entry never undoes to a pose only\n    // a later push wrote.\n    get coalesceKey() {\n      return self.placed === undefined ? undefined : `arrange:${self.placed.map((p) => p.id).sort().join(',')}`;\n    },\n    apply(adapter) {\n      if (self.placed === undefined) self.placed = compute?.() ?? [];\n      const set = write ?? ((id: string, pose: unknown) => (adapter as ArrangeAdapter).setPose(id, pose));\n      for (const p of self.placed) set(p.id, p.to);\n      return self.placed.length > 0 ? undefined : 'noop';\n    },\n    invert() {\n      const placed = self.placed ?? [];\n      return createArrangeOp({\n        placed: [...placed].reverse().map((p) => ({ id: p.id, from: p.to, to: p.from })),\n      }, undefined, write);\n    },\n  };\n}\n\nregisterOpFactory<ArrangeArgs>('arrange', (args) => createArrangeOp(args));\n"],"mappings":";;AA8BA,SAAgBA,EACd,GACA,GACA,GACI;CACJ,IAAMC,IAAoB,EAAE,GAAIC,EAAK,SAAS,EAAE,QAAQA,EAAK,OAAO,IAAI,CAAC,EAAG;CAC5E,OAAO;EACL,MAAM;EACN,MAAMD;EACN,OAAO;EACP,WAAW;EAGX,IAAI,cAAc;GAChB,OAAOA,EAAK,WAAW,KAAA,IAAY,KAAA,IAAY,WAAWA,EAAK,OAAO,KAAK,MAAME,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG;EACxG;EACA,MAAM,GAAS;GACb,AAAIF,EAAK,WAAW,KAAA,MAAW,EAAK,SAASG,IAAU,KAAK,CAAC;GAC7D,IAAMC,IAAMC,OAAW,GAAY,MAAmBC,EAA2B,QAAQC,GAAIC,CAAI;GACjG,KAAK,IAAMN,KAAKF,EAAK,QAAQ,EAAIE,EAAE,IAAIA,EAAE,EAAE;GAC3C,OAAOF,EAAK,OAAO,SAAS,IAAI,KAAA,IAAY;EAC9C;EACA,SAAS;GAEP,OAAOD,EAAgB,EACrB,QAAQ,CAAC,GAFIC,EAAK,UAAU,CAAC,CAEX,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,OAAO;IAAE,IAAIE,EAAE;IAAI,MAAMA,EAAE;IAAI,IAAIA,EAAE;GAAK,EAAE,EACjF,GAAG,KAAA,GAAWG,CAAK;EACrB;CACF;AACF;AAEAI,EAA+B,YAAY,MAASV,EAAgBE,CAAI,CAAC"}

package/dist/core/ops/create.js

@@ -3,24 +3,29 @@ import { parentOf as t, resolveSlot as n, slotFromIndex as r } from "./slot.js";
 import { createDeleteOp as i } from "./delete.js";
 //#region src/core/ops/create.ts
 function a(e) {
-	let { node: a, label: o } = e, s = e.slot ?? r(e.index);
+	let { node: a, label: o, cascaded: s } = e, c = e.slot ?? r(e.index);
 	return {
 		name: "insert",
 		args: {
 			node: a,
 			label: o,
-			slot: s
+			slot: c,
+			...s ? { cascaded: s } : {}
 		},
 		label: o,
 		apply(e) {
-			let r = e, i = t(a);
-			r.insertNode(a, n(r.getChildren?.(i), s));
+			let r = e, i = () => {
+				r.insertNode(a, n(r.getChildren?.(t(a)), c));
+			};
+			if (!s || s.length === 0) return i();
+			for (let e of s) r.getNode?.(e.node.id) || (e.node.id === a.id ? i() : r.insertNode(e.node, e.index));
 		},
 		invert() {
 			return i({
 				node: a,
 				label: o,
-				slot: s
+				slot: c,
+				...s ? { cascaded: s } : {}
 			});
 		}
 	};

package/dist/core/ops/create.js.map

@@ -1 +1 @@
-{"version":3,"file":"create.js","names":["createInsertOp","args","slot","slotFromIndex","a","adapter","parentId","parentOf","node","resolveSlot","createDeleteOp","registerOpFactory"],"sources":["../../../src/core/ops/create.ts"],"sourcesContent":["import type { Op } from './types';\nimport { createDeleteOp } from './delete';\nimport { registerOpFactory } from './registry';\nimport { parentOf, resolveSlot, slotFromIndex, type OrderedReader, type SiblingSlot } from './slot';\n\ninterface InsertAdapter<TNode> extends OrderedReader {\n  /** When `index` is supplied, insert at that position; adapters that ignore\n   *  the second arg (or don't expose it) fall back to their default\n   *  placement (typically append-to-end). */\n  insertNode(node: TNode, index?: number): void;\n}\n\n/** Type alias for ops produced by `createInsertOp`. Carries no extra type info today;\n *  exists so consumers can name the op type when needed. */\nexport type InsertOp = Op;\n\n/** Arguments to {@link createInsertOp}: the node to insert and where among its siblings. */\nexport interface InsertArgs<TNode extends { id: string }> {\n  node: TNode;\n  label?: string;\n  /** Sibling ordinal to insert at. Sugar for `slot: { index }` — the weaker\n   *  of the two forms, and all a fresh-insert callsite can know. */\n  index?: number;\n  /** Full slot, anchor included. Produced only by `captureSlot` (via a\n   *  delete op's `invert`), and supersedes `index` when present. */\n  slot?: SiblingSlot;\n}\n\n/** Op: insert `node` into the scene; inverts to a delete of the same id. */\nexport function createInsertOp<TNode extends { id: string }>(args: InsertArgs<TNode>): InsertOp {\n  const { node, label } = args;\n  const slot: SiblingSlot = args.slot ?? slotFromIndex(args.index);\n  return {\n    name: 'insert',\n    args: { node, label, slot },\n    label,\n    apply(adapter) {\n      const a = adapter as InsertAdapter<TNode>;\n      const parentId = parentOf(node);\n      a.insertNode(node, resolveSlot(a.getChildren?.(parentId), slot));\n    },\n    invert() {\n      return createDeleteOp({ node, label, slot });\n    },\n  };\n}\n\nregisterOpFactory<InsertArgs<{ id: string }>>('insert', (args) => createInsertOp(args));\n"],"mappings":";;;;AA6BA,SAAgBA,EAA6C,GAAmC;CAC9F,IAAM,EAAE,SAAM,aAAUC,GAClBC,IAAoBD,EAAK,QAAQE,EAAcF,EAAK,KAAK;CAC/D,OAAO;EACL,MAAM;EACN,MAAM;GAAE;GAAM;GAAO;EAAK;EAC1B;EACA,MAAM,GAAS;GACb,IAAMG,IAAIC,GACJC,IAAWC,EAASC,CAAI;GAC9B,EAAE,WAAWA,GAAMC,EAAYL,EAAE,cAAcE,CAAQ,GAAGJ,CAAI,CAAC;EACjE;EACA,SAAS;GACP,OAAOQ,EAAe;IAAE;IAAM;IAAO;GAAK,CAAC;EAC7C;CACF;AACF;AAEAC,EAA8C,WAAW,MAASX,EAAeC,CAAI,CAAC"}
+{"version":3,"file":"create.js","names":["createInsertOp","args","slot","slotFromIndex","cascaded","a","adapter","insertRoot","node","resolveSlot","parentOf","entry","createDeleteOp","registerOpFactory"],"sources":["../../../src/core/ops/create.ts"],"sourcesContent":["import type { Op } from './types';\nimport { createDeleteOp, type PlacedNode } from './delete';\nimport { registerOpFactory } from './registry';\nimport { parentOf, resolveSlot, slotFromIndex, type OrderedReader, type SiblingSlot } from './slot';\n\ninterface InsertAdapter<TNode> extends OrderedReader {\n  getNode?(id: string): TNode | undefined;\n  /** When `index` is supplied, insert at that position; adapters that ignore\n   *  the second arg (or don't expose it) fall back to their default\n   *  placement (typically append-to-end). */\n  insertNode(node: TNode, index?: number): void;\n}\n\n/** Type alias for ops produced by `createInsertOp`. Carries no extra type info today;\n *  exists so consumers can name the op type when needed. */\nexport type InsertOp = Op;\n\n/** Arguments to {@link createInsertOp}: the node to insert and where among its siblings. */\nexport interface InsertArgs<TNode extends { id: string }> {\n  node: TNode;\n  label?: string;\n  /** Sibling ordinal to insert at. Sugar for `slot: { index }` — the weaker\n   *  of the two forms, and all a fresh-insert callsite can know. */\n  index?: number;\n  /** Full slot, anchor included. Produced only by `captureSlot` (via a\n   *  delete op's `invert`), and supersedes `index` when present. */\n  slot?: SiblingSlot;\n  /** Every node to insert, `node` itself included, each at its ordinal among\n   *  its own parent's children and ordered so a parent precedes its children.\n   *  What a delete's `cascaded` captures, and how its inverse brings the whole\n   *  set back; `node` still goes in at `slot`. One already present is skipped. */\n  cascaded?: PlacedNode<TNode>[];\n}\n\n/** Op: insert `node`, and the rest of `cascaded` with it; inverts to a delete\n *  of `node`. */\nexport function createInsertOp<TNode extends { id: string }>(args: InsertArgs<TNode>): InsertOp {\n  const { node, label, cascaded } = args;\n  const slot: SiblingSlot = args.slot ?? slotFromIndex(args.index);\n  return {\n    name: 'insert',\n    args: { node, label, slot, ...(cascaded ? { cascaded } : {}) },\n    label,\n    apply(adapter) {\n      const a = adapter as InsertAdapter<TNode>;\n      const insertRoot = (): void => {\n        a.insertNode(node, resolveSlot(a.getChildren?.(parentOf(node)), slot));\n      };\n      if (!cascaded || cascaded.length === 0) return insertRoot();\n      for (const entry of cascaded) {\n        // A flat adapter's removeNode doesn't cascade, so its children\n        // were never gone — re-inserting them would duplicate them.\n        if (a.getNode?.(entry.node.id)) continue;\n        if (entry.node.id === node.id) insertRoot();\n        else a.insertNode(entry.node, entry.index);\n      }\n    },\n    invert() {\n      return createDeleteOp({ node, label, slot, ...(cascaded ? { cascaded } : {}) });\n    },\n  };\n}\n\nregisterOpFactory<InsertArgs<{ id: string }>>('insert', (args) => createInsertOp(args));\n"],"mappings":";;;;AAoCA,SAAgBA,EAA6C,GAAmC;CAC9F,IAAM,EAAE,SAAM,UAAO,gBAAaC,GAC5BC,IAAoBD,EAAK,QAAQE,EAAcF,EAAK,KAAK;CAC/D,OAAO;EACL,MAAM;EACN,MAAM;GAAE;GAAM;GAAO;GAAM,GAAIG,IAAW,EAAE,YAAS,IAAI,CAAC;EAAG;EAC7D;EACA,MAAM,GAAS;GACb,IAAMC,IAAIC,GACJC,UAAyB;IAC7B,EAAE,WAAWC,GAAMC,EAAYJ,EAAE,cAAcK,EAASF,CAAI,CAAC,GAAGN,CAAI,CAAC;GACvE;GACA,IAAI,CAACE,KAAYA,EAAS,WAAW,GAAG,OAAOG,EAAW;GAC1D,KAAK,IAAMI,KAASP,GAGlB,AAAIC,EAAE,UAAUM,EAAM,KAAK,EAAE,MACzBA,EAAM,KAAK,OAAOH,EAAK,KAAID,EAAW,IACrCF,EAAE,WAAWM,EAAM,MAAMA,EAAM,KAAK;EAE7C;EACA,SAAS;GACP,OAAOC,EAAe;IAAE;IAAM;IAAO;IAAM,GAAIR,IAAW,EAAE,YAAS,IAAI,CAAC;GAAG,CAAC;EAChF;CACF;AACF;AAEAS,EAA8C,WAAW,MAASb,EAAeC,CAAI,CAAC"}

package/dist/core/ops/createHistory.js

@@ -1,17 +1,17 @@
-import { rebuildOp as e } from "./registry.js";
-import { dlog as t, dwarn as n } from "../../debug/flag.js";
+import { dlog as e, dwarn as t } from "../../debug/flag.js";
+import { rebuildOp as n } from "./registry.js";
 import { createHistory as r } from "@weasel-js/history";
 //#region src/core/ops/createHistory.ts
 var i = {
-	log: (e) => t("history", e),
-	warn: (e) => n("history", e)
+	log: (t) => e("history", t),
+	warn: (e) => t("history", e)
 };
-function a(t, n = {}) {
-	let a = n.rebuildOp;
-	return r(t, {
+function a(e, t = {}) {
+	let a = t.rebuildOp;
+	return r(e, {
 		debug: i,
-		...n,
-		rebuildOp: (t, n) => a?.(t, n) ?? e(t, n)
+		...t,
+		rebuildOp: (e, t) => a?.(e, t) ?? n(e, t)
 	});
 }
 //#endregion

package/dist/core/ops/createHistory.js.map

@@ -1 +1 @@
-{"version":3,"file":"createHistory.js","names":["createHistory","createHistoryEngine","kitLogger","dlog","message","dwarn","createHistory$1","custom","options","createHistory","adapter","name","args","rebuildOp"],"sources":["../../../src/core/ops/createHistory.ts"],"sourcesContent":["import {\n  createHistory as createHistoryEngine,\n  type History,\n  type CreateHistoryOptions,\n  type HistoryLogger,\n} from '@weasel-js/history';\nimport { rebuildOp } from './registry';\nimport { dlog, dwarn } from '../../debug/flag';\n\n/** Routes the engine's diagnostics into the kit's `history` debug namespace,\n *  so `localStorage.setItem('weasel.debug', '1')` still surfaces them. */\nconst kitLogger: HistoryLogger = {\n  log: (message) => dlog('history', message),\n  warn: (message) => dwarn('history', message),\n};\n\n/**\n * Build an op-batched undo/redo `History`, defaulting restore-time op\n * hydration to core's global op-factory registry and its diagnostics to the\n * kit's debug namespace.\n *\n * The engine in `@weasel-js/history` is registry-agnostic: it can only rebuild\n * a serialized `(name, args)` pair through the `rebuildOp` hook it is handed,\n * which is what lets that package build without depending on core. Core owns\n * the registry, so this wrapper supplies it — meaning `createHistory(adapter)`\n * with no options still restores kit-emitted ops, exactly as before.\n *\n * A caller-supplied `rebuildOp` wins; return `null` from it to fall through to\n * the registry.\n */\nexport function createHistory(adapter: unknown, options: CreateHistoryOptions = {}): History {\n  const custom = options.rebuildOp;\n  return createHistoryEngine(adapter, {\n    debug: kitLogger,\n    ...options,\n    rebuildOp: (name, args) => custom?.(name, args) ?? rebuildOp(name, args),\n  });\n}\n"],"mappings":";;;;AAWA,IAAME,IAA2B;CAC/B,MAAM,MAAYC,EAAK,WAAWC,CAAO;CACzC,OAAO,MAAYC,EAAM,WAAWD,CAAO;AAC7C;AAgBA,SAAgBJ,EAAc,GAAkB,IAAgC,CAAC,GAAY;CAC3F,IAAMO,IAASC,EAAQ;CACvB,OAAOP,EAAoBS,GAAS;EAClC,OAAOR;EACP,GAAGM;EACH,YAAY,GAAM,MAASD,IAASI,GAAMC,CAAI,KAAKC,EAAUF,GAAMC,CAAI;CACzE,CAAC;AACH"}
+{"version":3,"file":"createHistory.js","names":["createHistory","createHistoryEngine","kitLogger","dlog","message","dwarn","createHistory$1","custom","options","createHistory","adapter","name","args","rebuildOp"],"sources":["../../../src/core/ops/createHistory.ts"],"sourcesContent":["import {\n  createHistory as createHistoryEngine,\n  type History,\n  type CreateHistoryOptions,\n  type HistoryLogger,\n} from '@weasel-js/history';\nimport { rebuildOp } from './registry';\nimport { dlog, dwarn } from '../../debug/flag';\n\n/** Routes the engine's diagnostics into the kit's `history` debug namespace,\n *  so `localStorage.setItem('weasel.debug', '1')` still surfaces them. */\nconst kitLogger: HistoryLogger = {\n  log: (message) => dlog('history', message),\n  warn: (message) => dwarn('history', message),\n};\n\n/**\n * Build an op-batched undo/redo `History`, defaulting restore-time op\n * hydration to core's global op-factory registry and its diagnostics to the\n * kit's debug namespace. A caller-supplied `rebuildOp` wins; return `null`\n * from it to fall through to the registry.\n */\nexport function createHistory(adapter: unknown, options: CreateHistoryOptions = {}): History {\n  const custom = options.rebuildOp;\n  return createHistoryEngine(adapter, {\n    debug: kitLogger,\n    ...options,\n    rebuildOp: (name, args) => custom?.(name, args) ?? rebuildOp(name, args),\n  });\n}\n"],"mappings":";;;;AAWA,IAAME,IAA2B;CAC/B,MAAM,MAAYC,EAAK,WAAWC,CAAO;CACzC,OAAO,MAAYC,EAAM,WAAWD,CAAO;AAC7C;AAQA,SAAgBJ,EAAc,GAAkB,IAAgC,CAAC,GAAY;CAC3F,IAAMO,IAASC,EAAQ;CACvB,OAAOP,EAAoBS,GAAS;EAClC,OAAOR;EACP,GAAGM;EACH,YAAY,GAAM,MAASD,IAASI,GAAMC,CAAI,KAAKC,EAAUF,GAAMC,CAAI;CACzE,CAAC;AACH"}

package/dist/core/ops/delete.js

@@ -44,41 +44,29 @@ function o(e, t) {
 	return l;
 }
 function s(e) {
-	let { node: a, label: c } = e, l = e.slot ?? r(e.index), u = {
+	let { node: a, label: s } = e, c = e.slot ?? r(e.index), l = {
 		node: a,
-		label: c,
-		slot: l,
+		label: s,
+		slot: c,
 		cascaded: e.cascaded
-	}, d = e.cascaded ?? [];
+	}, u = e.cascaded ?? [];
 	return {
 		name: "delete",
-		args: u,
-		label: c,
+		args: l,
+		label: s,
 		apply(e) {
 			let r = e, i = t(r, n(a), a.id);
-			i && (l = i, u.slot = i);
+			i && (c = i, l.slot = i);
 			let s = o(r, a.id);
-			s && (d = s, u.cascaded = s), r.removeNode(a.id);
+			s && (u = s, l.cascaded = s), r.removeNode(a.id);
 		},
 		invert() {
-			let e = d, t = l, n = i({
+			return i({
 				node: a,
-				label: c,
-				slot: t
+				label: s,
+				slot: c,
+				...u.length > 0 ? { cascaded: u } : {}
 			});
-			return e.length === 0 ? n : {
-				label: c,
-				apply(t) {
-					let r = t;
-					for (let i of e) r.getNode?.(i.node.id) || (i.node.id === a.id ? n.apply(t) : r.insertNode(i.node, i.index));
-				},
-				invert: () => s({
-					node: a,
-					label: c,
-					slot: t,
-					cascaded: e
-				})
-			};
 		}
 	};
 }

package/dist/core/ops/delete.js.map

@@ -1 +1 @@
-{"version":3,"file":"delete.js","names":["indexIn","a","parentId","id","captureCascade","getChildren","getNode","closure","rootId","taken","node","walk","kid","detachRoots","p","parentOf","n","l","r","out","emitSubtree","entry","kids","i","child","createDeleteOp","args","slot","slotFromIndex","argsForSerial","captured","adapter","observed","captureSlot","snapshot","cascaded","restoredSlot","reinsertRoot","createInsertOp","registerOpFactory"],"sources":["../../../src/core/ops/delete.ts"],"sourcesContent":["import type { Op } from './types';\nimport { createInsertOp } from './create';\nimport { registerOpFactory } from './registry';\nimport { captureSlot, parentOf, slotFromIndex, type OrderedReader, type SiblingSlot } from './slot';\n\ninterface DeleteAdapter<TNode> extends OrderedReader {\n  removeNode(id: string): void;\n  /** Subtree reads, used to snapshot the cascade before it runs. Optional\n   *  — a flat adapter has neither, and a delete there is a single node. */\n  getNode?(id: string): TNode | undefined;\n  /** Every id `removeNode` would take with this one. Optional: a store whose\n   *  removal cascades along nothing but the subtree needs no such answer, and\n   *  `getChildren` is enough. A store that cascades further — the kit's scene\n   *  takes a deleted node's dependents too — must answer here, or the nodes it\n   *  cascades away are absent from the snapshot and undo brings back the named\n   *  node alone. */\n  getRemovalClosure?(ids: readonly string[]): readonly string[];\n}\n\ninterface InsertAdapter<TNode> {\n  insertNode(node: TNode, index?: number): void;\n  getNode?(id: string): TNode | undefined;\n}\n\n/** A captured node plus its slot in its own parent's child list. */\nexport interface PlacedNode<TNode> {\n  node: TNode;\n  index: number;\n}\n\n/** Arguments to {@link createDeleteOp}: the node to remove, plus what undo needs to put it back. */\nexport interface DeleteArgs<TNode extends { id: string }> {\n  node: TNode;\n  label?: string;\n  /** Sibling ordinal the node occupies at the moment of delete. Sugar for\n   *  `slot: { index }`, and only a seed: `apply` re-observes the node's full\n   *  slot through the adapter and that observation supersedes this. Kept\n   *  because it is the whole story for a flat adapter with no `getChildren`,\n   *  where nothing can be observed. */\n  index?: number;\n  /** Full slot, anchor included. Written by `apply`; supersedes `index`. */\n  slot?: SiblingSlot;\n  /** Everything `removeNode` takes, `node` itself included — its subtree, and\n   *  whatever else the adapter cascades. An inverse that re-inserts `node`\n   *  alone brings a container back empty and leaves every dependent deleted.\n   *  Ordered so a node's parent precedes it, which is the order they have to\n   *  be re-inserted in. Captured on apply; mirrored into the serialized args so\n   *  a rebuilt op can invert without having run. */\n  cascaded?: PlacedNode<TNode>[];\n}\n\n/** `id`'s ordinal among `parentId`'s children, or `-1` when unobservable. */\nfunction indexIn(a: OrderedReader, parentId: string | null, id: string): number {\n  return a.getChildren?.(parentId)?.indexOf(id) ?? -1;\n}\n\n/**\n * Snapshot everything removing `rootId` takes with it, `rootId` included.\n *\n * Returns `null` when the adapter can't enumerate, which leaves any previously\n * captured snapshot in place rather than clobbering it with an empty one.\n *\n * The order is the whole point. A cascade unlinks several disjoint subtrees, so\n * the captured set is walked as a forest: a node whose parent is not also going\n * is a detach root, and each one is emitted — ascending sibling index first, so\n * every slot still means what it meant — followed by its captured descendants\n * preorder. The closure's own order will not do: it reaches a dependent before\n * the parent it sits under whenever that parent is in the closure as a\n * dependent too, and re-inserting a child under a parent that is not back yet\n * puts it in the wrong place.\n */\nfunction captureCascade<TNode extends { id: string }>(\n  a: DeleteAdapter<TNode>,\n  rootId: string,\n): PlacedNode<TNode>[] | null {\n  const { getChildren, getNode } = a;\n  if (!getChildren || !getNode) return null;\n\n  const closure = a.getRemovalClosure?.([rootId]);\n  const taken = new Map<string, TNode>();\n  if (closure) {\n    for (const id of closure) {\n      const node = getNode.call(a, id);\n      if (node) taken.set(id, node);\n    }\n  } else {\n    // No closure read: the cascade is the subtree, discovered here.\n    const walk = (id: string): void => {\n      const node = getNode.call(a, id);\n      if (!node) return;\n      taken.set(id, node);\n      for (const kid of getChildren.call(a, id)) walk(kid);\n    };\n    walk(rootId);\n  }\n\n  const detachRoots = [...taken.values()]\n    .filter((n) => { const p = parentOf(n); return p === null || !taken.has(p); })\n    .map((n) => ({ node: n, index: indexIn(a, parentOf(n), n.id) }))\n    .sort((l, r) => l.index - r.index);\n\n  const out: PlacedNode<TNode>[] = [];\n  const emitSubtree = (entry: PlacedNode<TNode>): void => {\n    out.push(entry);\n    const kids = getChildren.call(a, entry.node.id);\n    for (let i = 0; i < kids.length; i++) {\n      const child = taken.get(kids[i]!);\n      if (child) emitSubtree({ node: child, index: i });\n    }\n  };\n  for (const entry of detachRoots) emitSubtree(entry);\n  return out;\n}\n\n/** Op: remove `node` and everything the adapter cascades with it; inverts to a\n *  re-insert of the whole set at its captured slots. */\nexport function createDeleteOp<TNode extends { id: string }>(args: DeleteArgs<TNode>): Op {\n  const { node, label } = args;\n  let slot: SiblingSlot = args.slot ?? slotFromIndex(args.index);\n  const argsForSerial: DeleteArgs<TNode> = { node, label, slot, cascaded: args.cascaded };\n  let captured: PlacedNode<TNode>[] = args.cascaded ?? [];\n  return {\n    name: 'delete',\n    args: argsForSerial,\n    label,\n    apply(adapter) {\n      const a = adapter as DeleteAdapter<TNode>;\n      const observed = captureSlot(a, parentOf(node), node.id);\n      if (observed) {\n        slot = observed;\n        argsForSerial.slot = observed;\n      }\n      const snapshot = captureCascade(a, node.id);\n      if (snapshot) {\n        captured = snapshot;\n        argsForSerial.cascaded = snapshot;\n      }\n      a.removeNode(node.id);\n    },\n    invert() {\n      const cascaded = captured;\n      const restoredSlot = slot;\n      // The root's own placement keeps the anchor-bearing slot; the rest have\n      // only an ordinal, which is all `getChildren` can observe of them.\n      const reinsertRoot = createInsertOp<TNode>({ node, label, slot: restoredSlot });\n      if (cascaded.length === 0) return reinsertRoot;\n      return {\n        label,\n        apply(adapter) {\n          const a = adapter as InsertAdapter<TNode>;\n          for (const entry of cascaded) {\n            // A flat adapter's removeNode doesn't cascade, so its children\n            // were never gone — re-inserting them would duplicate them.\n            if (a.getNode?.(entry.node.id)) continue;\n            if (entry.node.id === node.id) reinsertRoot.apply(adapter);\n            else a.insertNode(entry.node, entry.index);\n          }\n        },\n        invert: () =>\n          createDeleteOp<TNode>({ node, label, slot: restoredSlot, cascaded }),\n      };\n    },\n  };\n}\n\nregisterOpFactory<DeleteArgs<{ id: string }>>('delete', (args) => createDeleteOp(args));\n"],"mappings":"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"}
+{"version":3,"file":"delete.js","names":["indexIn","a","parentId","id","captureCascade","getChildren","getNode","closure","rootId","taken","node","walk","kid","detachRoots","p","parentOf","n","l","r","out","emitSubtree","entry","kids","i","child","createDeleteOp","args","slot","slotFromIndex","argsForSerial","captured","adapter","observed","captureSlot","snapshot","createInsertOp","registerOpFactory"],"sources":["../../../src/core/ops/delete.ts"],"sourcesContent":["import type { Op } from './types';\nimport { createInsertOp } from './create';\nimport { registerOpFactory } from './registry';\nimport { captureSlot, parentOf, slotFromIndex, type OrderedReader, type SiblingSlot } from './slot';\n\ninterface DeleteAdapter<TNode> extends OrderedReader {\n  removeNode(id: string): void;\n  /** Subtree reads, used to snapshot the cascade before it runs. Optional\n   *  — a flat adapter has neither, and a delete there is a single node. */\n  getNode?(id: string): TNode | undefined;\n  /** Every id `removeNode` would take with this one. A store whose removal\n   *  cascades past the subtree — the kit's scene takes a deleted node's\n   *  dependents too — must answer here, or those nodes are absent from the\n   *  snapshot and undo does not bring them back. */\n  getRemovalClosure?(ids: readonly string[]): readonly string[];\n}\n\n/** A captured node plus its slot in its own parent's child list. */\nexport interface PlacedNode<TNode> {\n  node: TNode;\n  index: number;\n}\n\n/** Arguments to {@link createDeleteOp}: the node to remove, plus what undo needs to put it back. */\nexport interface DeleteArgs<TNode extends { id: string }> {\n  node: TNode;\n  label?: string;\n  /** Sibling ordinal the node occupies at the moment of delete. Sugar for\n   *  `slot: { index }`, and only a seed: `apply` re-observes the node's full\n   *  slot through the adapter, where it can, and that supersedes this. */\n  index?: number;\n  /** Full slot, anchor included. Written by `apply`; supersedes `index`. */\n  slot?: SiblingSlot;\n  /** Everything `removeNode` takes, `node` itself included — its subtree, and\n   *  whatever else the adapter cascades. Ordered so a node's parent precedes\n   *  it, which is the order they have to be re-inserted in. Captured on apply;\n   *  mirrored into the serialized args so a rebuilt op can invert without\n   *  having run. */\n  cascaded?: PlacedNode<TNode>[];\n}\n\n/** `id`'s ordinal among `parentId`'s children, or `-1` when unobservable. */\nfunction indexIn(a: OrderedReader, parentId: string | null, id: string): number {\n  return a.getChildren?.(parentId)?.indexOf(id) ?? -1;\n}\n\n/**\n * Snapshot everything removing `rootId` takes with it, `rootId` included.\n *\n * Returns `null` when the adapter can't enumerate, which leaves any previously\n * captured snapshot in place rather than clobbering it with an empty one.\n *\n * A cascade unlinks several disjoint subtrees, so the captured set is walked\n * as a forest: a node whose parent is not also going is a detach root, and\n * each one is emitted — ascending sibling index first, so every slot still\n * means what it meant — followed by its captured descendants preorder. The\n * closure's own order will not do: it can reach a dependent before the parent\n * it sits under, and re-inserting a child under a parent that is not back yet\n * puts it in the wrong place.\n */\nfunction captureCascade<TNode extends { id: string }>(\n  a: DeleteAdapter<TNode>,\n  rootId: string,\n): PlacedNode<TNode>[] | null {\n  const { getChildren, getNode } = a;\n  if (!getChildren || !getNode) return null;\n\n  const closure = a.getRemovalClosure?.([rootId]);\n  const taken = new Map<string, TNode>();\n  if (closure) {\n    for (const id of closure) {\n      const node = getNode.call(a, id);\n      if (node) taken.set(id, node);\n    }\n  } else {\n    // No closure read: the cascade is the subtree, discovered here.\n    const walk = (id: string): void => {\n      const node = getNode.call(a, id);\n      if (!node) return;\n      taken.set(id, node);\n      for (const kid of getChildren.call(a, id)) walk(kid);\n    };\n    walk(rootId);\n  }\n\n  const detachRoots = [...taken.values()]\n    .filter((n) => { const p = parentOf(n); return p === null || !taken.has(p); })\n    .map((n) => ({ node: n, index: indexIn(a, parentOf(n), n.id) }))\n    .sort((l, r) => l.index - r.index);\n\n  const out: PlacedNode<TNode>[] = [];\n  const emitSubtree = (entry: PlacedNode<TNode>): void => {\n    out.push(entry);\n    const kids = getChildren.call(a, entry.node.id);\n    for (let i = 0; i < kids.length; i++) {\n      const child = taken.get(kids[i]!);\n      if (child) emitSubtree({ node: child, index: i });\n    }\n  };\n  for (const entry of detachRoots) emitSubtree(entry);\n  return out;\n}\n\n/** Op: remove `node` and everything the adapter cascades with it; inverts to a\n *  re-insert of the whole set at its captured slots. */\nexport function createDeleteOp<TNode extends { id: string }>(args: DeleteArgs<TNode>): Op {\n  const { node, label } = args;\n  let slot: SiblingSlot = args.slot ?? slotFromIndex(args.index);\n  const argsForSerial: DeleteArgs<TNode> = { node, label, slot, cascaded: args.cascaded };\n  let captured: PlacedNode<TNode>[] = args.cascaded ?? [];\n  return {\n    name: 'delete',\n    args: argsForSerial,\n    label,\n    apply(adapter) {\n      const a = adapter as DeleteAdapter<TNode>;\n      const observed = captureSlot(a, parentOf(node), node.id);\n      if (observed) {\n        slot = observed;\n        argsForSerial.slot = observed;\n      }\n      const snapshot = captureCascade(a, node.id);\n      if (snapshot) {\n        captured = snapshot;\n        argsForSerial.cascaded = snapshot;\n      }\n      a.removeNode(node.id);\n    },\n    invert() {\n      // The root's own placement keeps the anchor-bearing slot; the rest have\n      // only an ordinal, which is all `getChildren` can observe of them.\n      return createInsertOp<TNode>({\n        node, label, slot,\n        ...(captured.length > 0 ? { cascaded: captured } : {}),\n      });\n    },\n  };\n}\n\nregisterOpFactory<DeleteArgs<{ id: string }>>('delete', (args) => createDeleteOp(args));\n"],"mappings":";;;;AA0CA,SAASA,EAAQ,GAAkB,GAAyB,GAAoB;CAC9E,OAAOC,EAAE,cAAcC,CAAQ,CAAC,EAAE,QAAQC,CAAE,KAAK;AACnD;AAgBA,SAASC,EACP,GACA,GAC4B;CAC5B,IAAM,EAAE,gBAAa,eAAYH;CACjC,IAAI,CAACI,KAAe,CAACC,GAAS,OAAO;CAErC,IAAMC,IAAUN,EAAE,oBAAoB,CAACO,CAAM,CAAC,GACxCC,oBAAQ,IAAI,IAAmB;CACrC,IAAIF,GACF,KAAK,IAAMJ,KAAMI,GAAS;EACxB,IAAMG,IAAOJ,EAAQ,KAAKL,GAAGE,CAAE;EAC/B,AAAIO,KAAMD,EAAM,IAAIN,GAAIO,CAAI;CAC9B;MACK;EAEL,IAAMC,KAAQ,MAAqB;GACjC,IAAMD,IAAOJ,EAAQ,KAAKL,GAAGE,CAAE;GAC/B,IAAKO,GACL;MAAM,IAAIP,GAAIO,CAAI;IAClB,KAAK,IAAME,KAAOP,EAAY,KAAKJ,GAAGE,CAAE,GAAG,EAAKS,CAAG;GADjC;EAEpB;EACA,EAAKJ,CAAM;CACb;CAEA,IAAMK,IAAc,CAAC,GAAGJ,EAAM,OAAO,CAAC,CAAC,CACpC,QAAQ,MAAM;EAAE,IAAMK,IAAIC,EAASC,CAAC;EAAG,OAAOF,MAAM,QAAQ,CAACL,EAAM,IAAIK,CAAC;CAAG,CAAC,CAAC,CAC7E,KAAK,OAAO;EAAE,MAAME;EAAG,OAAOhB,EAAQC,GAAGc,EAASC,CAAC,GAAGA,EAAE,EAAE;CAAE,EAAE,CAAC,CAC/D,MAAM,GAAG,MAAMC,EAAE,QAAQC,EAAE,KAAK,GAE7BC,IAA2B,CAAC,GAC5BC,KAAe,MAAmC;EACtD,EAAI,KAAKC,CAAK;EACd,IAAMC,IAAOjB,EAAY,KAAKJ,GAAGoB,EAAM,KAAK,EAAE;EAC9C,KAAK,IAAIE,IAAI,GAAGA,IAAID,EAAK,QAAQ,KAAK;GACpC,IAAME,IAAQf,EAAM,IAAIa,EAAKC,EAAG;GAChC,AAAIC,KAAOJ,EAAY;IAAE,MAAMI;IAAO,OAAOD;GAAE,CAAC;EAClD;CACF;CACA,KAAK,IAAMF,KAASR,GAAa,EAAYQ,CAAK;CAClD,OAAOF;AACT;AAIA,SAAgBM,EAA6C,GAA6B;CACxF,IAAM,EAAE,SAAM,aAAUC,GACpBC,IAAoBD,EAAK,QAAQE,EAAcF,EAAK,KAAK,GACvDG,IAAmC;EAAE;EAAM;EAAO;EAAM,UAAUH,EAAK;CAAS,GAClFI,IAAgCJ,EAAK,YAAY,CAAC;CACtD,OAAO;EACL,MAAM;EACN,MAAMG;EACN;EACA,MAAM,GAAS;GACb,IAAM5B,IAAI8B,GACJC,IAAWC,EAAYhC,GAAGc,EAASL,CAAI,GAAGA,EAAK,EAAE;GACvD,AAAIsB,MACF,IAAOA,GACP,EAAc,OAAOA;GAEvB,IAAME,IAAW9B,EAAeH,GAAGS,EAAK,EAAE;GAK1C,AAJIwB,MACF,IAAWA,GACX,EAAc,WAAWA,IAE3BjC,EAAE,WAAWS,EAAK,EAAE;EACtB;EACA,SAAS;GAGP,OAAOyB,EAAsB;IAC3B;IAAM;IAAO;IACb,GAAIL,EAAS,SAAS,IAAI,EAAE,UAAUA,EAAS,IAAI,CAAC;GACtD,CAAC;EACH;CACF;AACF;AAEAM,EAA8C,WAAW,MAASX,EAAeC,CAAI,CAAC"}

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

@@ -1,12 +1,13 @@
 import { registerOpFactory as e } from "../registry.js";
 import { bringForward as t, bringToFront as n, canBringForward as r, canSendBackward as i, moveToIndex as a, sendBackward as o, sendToBack as s } from "./algorithms.js";
+import { createSetChildOrderOp as c } from "./setChildOrder.js";
 //#region src/core/ops/reorder/index.ts
-function c(e, t) {
+function l(e, t) {
 	if (e.length !== t.length) return !1;
 	for (let n = 0; n < e.length; n++) if (e[n] !== t[n]) return !1;
 	return !0;
 }
-function l(e) {
+function u(e) {
 	let { ids: t, direction: n, fn: r, label: i, prevOrders: a } = e, o = {
 		ids: t,
 		direction: n,
@@ -31,41 +32,41 @@ function l(e) {
 				let t = n.getParent ? n.getParent(e) : null, r = i.get(t) ?? [];
 				r.push(e), i.set(t, r);
 			}
-			let a = [], l = !1;
+			let a = [], c = !1;
 			for (let [e, t] of i) {
 				let i = n.getChildren(e), o = r(i, t);
-				c(i, o) || (a.push({
+				l(i, o) || (a.push({
 					parentId: e,
 					before: i.slice()
-				}), n.setChildOrder(e, o), l = !0);
+				}), n.setChildOrder(e, o), c = !0);
 			}
 			return s = a, o.prevOrders = a.map((e) => ({
 				...e,
 				before: e.before.slice()
-			})), l;
+			})), c;
 		},
 		invert() {
 			let e = s;
 			return {
-				label: i,
-				apply(t) {
-					if (!e) return;
-					let n = t;
-					if (n.setChildOrder) for (let t of e) n.setChildOrder(t.parentId, t.before.slice());
-				},
-				invert() {
-					return {
-						apply() {},
-						invert() {
-							return this;
-						}
-					};
-				}
+				...c({
+					orders: (e ?? []).map((e) => ({
+						parentId: e.parentId,
+						ids: e.before
+					})),
+					label: i
+				}),
+				invert: () => u({
+					ids: t,
+					direction: n,
+					fn: r,
+					label: i,
+					prevOrders: e ?? void 0
+				})
 			};
 		}
 	};
 }
-var u = {
+var d = {
 	forward: {
 		fn: t,
 		defaultLabel: "Bring forward"
@@ -83,9 +84,9 @@ var u = {
 		defaultLabel: "Send to back"
 	}
 };
-function d(e) {
-	let { ids: t, direction: n, label: r, prevOrders: i } = e, { fn: a, defaultLabel: o } = u[n];
-	return l({
+function f(e) {
+	let { ids: t, direction: n, label: r, prevOrders: i } = e, { fn: a, defaultLabel: o } = d[n];
+	return u({
 		ids: t,
 		direction: n,
 		fn: a,
@@ -93,8 +94,8 @@ function d(e) {
 		prevOrders: i
 	});
 }
-e("reorder", (e) => d(e));
-function f(e) {
+e("reorder", (e) => f(e));
+function p(e) {
 	let { ids: t, parentId: n, index: r, label: i } = e, o = {
 		ids: t,
 		parentId: n,
@@ -117,24 +118,26 @@ function f(e) {
 		invert() {
 			let e = s;
 			return {
-				label: i,
-				apply(t) {
-					e && t.setChildOrder?.(n, e.slice());
-				},
-				invert() {
-					return {
-						apply() {},
-						invert() {
-							return this;
-						}
-					};
-				}
+				...c({
+					orders: e ? [{
+						parentId: n,
+						ids: e
+					}] : [],
+					label: i
+				}),
+				invert: () => p({
+					ids: t,
+					parentId: n,
+					index: r,
+					label: i,
+					prevPositions: e ?? void 0
+				})
 			};
 		}
 	};
 }
-e("moveToIndex", (e) => f(e));
+e("moveToIndex", (e) => p(e));
 //#endregion
-export { r as canBringForward, i as canSendBackward, f as createMoveToIndexOp, d as createReorderOp };
+export { r as canBringForward, i as canSendBackward, p as createMoveToIndexOp, f as createReorderOp, c as createSetChildOrderOp };
 
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["arraysEqual","a","b","i","createPartitionedReorderOp","args","argsForSerial","prevOrders","restore","adapter","byParent","id","ids","parent","list","snapshots","mutated","parentId","parentIds","before","after","fn","captured","entry","REORDER_DIRECTIONS","bringForward","sendBackward","bringToFront","sendToBack","createReorderOp","direction","label","defaultLabel","registerOpFactory","createMoveToIndexOp","eligible","current","moveToIndex","index","canBringForward","canSendBackward"],"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\nexport { canBringForward, canSendBackward } from './algorithms';\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      if (!a.getChildren || !a.setChildOrder) return false; // graceful no-op\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 ? a.getParent(id) : null;\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        label,\n        apply(adapter) {\n          if (!captured) return;\n          const a = adapter as ReorderAdapter;\n          if (!a.setChildOrder) return;\n          for (const entry of captured) {\n            a.setChildOrder(entry.parentId, entry.before.slice());\n          }\n        },\n        invert() {\n          // Inverting twice should reapply the original; we don't support\n          // this round-trip beyond two levels — the kit's history layer\n          // doesn't need it. Return a no-op for safety.\n          return { apply() {}, invert() { return this; } };\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      if (!a.getChildren || !a.setChildOrder) return;\n      // Filter to ids whose current parent matches target parent.\n      const eligible = ids.filter((id) => {\n        const p = a.getParent ? a.getParent(id) : null;\n        return p === parentId;\n      });\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        label,\n        apply(adapter) {\n          if (!captured) return;\n          const a = adapter as ReorderAdapter;\n          a.setChildOrder?.(parentId, captured.slice());\n        },\n        invert() { return { apply() {}, invert() { return this; } }; },\n      };\n    },\n  };\n}\n\nregisterOpFactory<MoveToIndexArgs>('moveToIndex', (args) => createMoveToIndexOp(args));\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["arraysEqual","a","b","i","createPartitionedReorderOp","args","argsForSerial","prevOrders","restore","adapter","byParent","id","ids","parent","list","snapshots","mutated","parentId","parentIds","before","after","fn","captured","createSetChildOrderOp","REORDER_DIRECTIONS","bringForward","sendBackward","bringToFront","sendToBack","createReorderOp","direction","label","defaultLabel","registerOpFactory","createMoveToIndexOp","eligible","current","moveToIndex","index","canBringForward","canSendBackward"],"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      if (!a.getChildren || !a.setChildOrder) return false; // graceful no-op\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 ? a.getParent(id) : null;\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      if (!a.getChildren || !a.setChildOrder) return;\n      // Filter to ids whose current parent matches target parent.\n      const eligible = ids.filter((id) => {\n        const p = a.getParent ? a.getParent(id) : null;\n        return p === parentId;\n      });\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

@@ -0,0 +1,34 @@
+import { registerOpFactory as e } from "../registry.js";
+//#region src/core/ops/reorder/setChildOrder.ts
+function t(e) {
+	let { orders: n, label: r } = e, i = {
+		orders: n,
+		label: r,
+		prevOrders: e.prevOrders
+	}, a = e.prevOrders ?? null;
+	return {
+		name: "setChildOrder",
+		args: i,
+		label: r,
+		apply(e) {
+			let t = e;
+			if (!t.setChildOrder) return !1;
+			let { getChildren: r } = t;
+			a === null && r && (a = n.map((e) => ({
+				parentId: e.parentId,
+				ids: r.call(t, e.parentId).slice()
+			})), i.prevOrders = a);
+			for (let e of n) t.setChildOrder(e.parentId, e.ids.slice());
+		},
+		invert: () => t({
+			orders: a ?? [],
+			label: r,
+			prevOrders: n
+		})
+	};
+}
+e("setChildOrder", (e) => t(e));
+//#endregion
+export { t as createSetChildOrderOp };
+
+//# sourceMappingURL=setChildOrder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setChildOrder.js","names":["createSetChildOrderOp","args","argsForSerial","before","a","adapter","getChildren","orders","o","registerOpFactory"],"sources":["../../../../src/core/ops/reorder/setChildOrder.ts"],"sourcesContent":["import type { Op } from '../types';\nimport { registerOpFactory } from '../registry';\n\ninterface ChildOrderAdapter {\n  getChildren?(parentId: string | null): string[];\n  setChildOrder?(parentId: string | null, ids: string[]): void;\n}\n\n/** One parent's children, in order. */\nexport interface ChildOrder {\n  parentId: string | null;\n  ids: string[];\n}\n\n/** Arguments to {@link createSetChildOrderOp}: the whole child order to write, per parent. */\nexport interface SetChildOrderArgs {\n  orders: ChildOrder[];\n  label?: string;\n  /** Each parent's order before the write. Filled in on first apply;\n   *  arrives populated when the op is rebuilt from a snapshot. */\n  prevOrders?: ChildOrder[];\n}\n\n/** Op: write each listed parent's whole child order; inverts to a write of the\n *  orders it replaced. Where `createMoveToIndexOp` keeps the moved ids in their\n *  current relative order, this states every position. */\nexport function createSetChildOrderOp(args: SetChildOrderArgs): Op {\n  const { orders, label } = args;\n  const argsForSerial: SetChildOrderArgs = { orders, label, prevOrders: args.prevOrders };\n  let before: ChildOrder[] | null = args.prevOrders ?? null;\n  return {\n    name: 'setChildOrder',\n    args: argsForSerial,\n    label,\n    apply(adapter) {\n      const a = adapter as ChildOrderAdapter;\n      if (!a.setChildOrder) return false;\n      const { getChildren } = a;\n      if (before === null && getChildren) {\n        before = orders.map((o) => ({ parentId: o.parentId, ids: getChildren.call(a, o.parentId).slice() }));\n        argsForSerial.prevOrders = before;\n      }\n      for (const o of orders) a.setChildOrder(o.parentId, o.ids.slice());\n      return undefined;\n    },\n    invert: () => createSetChildOrderOp({ orders: before ?? [], label, prevOrders: orders }),\n  };\n}\n\nregisterOpFactory<SetChildOrderArgs>('setChildOrder', (args) => createSetChildOrderOp(args));\n"],"mappings":";;AA0BA,SAAgBA,EAAsB,GAA6B;CACjE,IAAM,EAAE,WAAQ,aAAUC,GACpBC,IAAmC;EAAE;EAAQ;EAAO,YAAYD,EAAK;CAAW,GAClFE,IAA8BF,EAAK,cAAc;CACrD,OAAO;EACL,MAAM;EACN,MAAMC;EACN;EACA,MAAM,GAAS;GACb,IAAME,IAAIC;GACV,IAAI,CAACD,EAAE,eAAe,OAAO;GAC7B,IAAM,EAAE,mBAAgBA;GACxB,AAAID,MAAW,QAAQG,MACrB,IAASC,EAAO,KAAK,OAAO;IAAE,UAAUC,EAAE;IAAU,KAAKF,EAAY,KAAKF,GAAGI,EAAE,QAAQ,CAAC,CAAC,MAAM;GAAE,EAAE,GACnG,EAAc,aAAaL;GAE7B,KAAK,IAAMK,KAAKD,GAAQ,EAAE,cAAcC,EAAE,UAAUA,EAAE,IAAI,MAAM,CAAC;EAEnE;EACA,cAAcR,EAAsB;GAAE,QAAQG,KAAU,CAAC;GAAG;GAAO,YAAYI;EAAO,CAAC;CACzF;AACF;AAEAE,EAAqC,kBAAkB,MAAST,EAAsBC,CAAI,CAAC"}

package/dist/core/paint/meshKind.js

@@ -0,0 +1,16 @@
+import { meshDrawKind as e, meshFromStops as t, meshGradientXml as n, meshStops as r, seedMeshPatch as i } from "@weasel-js/renderer/mesh";
+//#region src/core/paint/meshKind.ts
+var a = (e) => e, o = (e) => e, s = {
+	...e,
+	label: "Mesh",
+	icon: "paintMesh",
+	seed: (e) => o(i(e)),
+	colorOf: (e) => a(e).patches?.[0]?.colors?.[0],
+	stopsOf: (e) => r(a(e)),
+	fromStops: (e) => o(t(e)),
+	toSvg: (e, t) => n(e, a(t))
+};
+//#endregion
+export { s as meshGradientKind };
+
+//# sourceMappingURL=meshKind.js.map

package/dist/core/paint/meshKind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meshKind.js","names":["asMesh","fill","asFill","mesh","meshGradientKind","meshDrawKind","seedMeshPatch","color","paint","meshStops","meshFromStops","stops","meshGradientXml","id"],"sources":["../../../src/core/paint/meshKind.ts"],"sourcesContent":["import type { Paint } from '@weasel-js/paint';\nimport {\n  meshDrawKind, meshFromStops, meshGradientXml, meshStops, seedMeshPatch, type MeshGradientPaint,\n} from '@weasel-js/renderer/mesh';\nimport type { PaintKindEntry } from './paintKindEntry';\n\n// `asPaint`'s cast both ways, kept local: this module must import nothing\n// stateful, or `meshKindLazy`'s self-contained copy would duplicate it.\nconst asMesh = (fill: Paint): MeshGradientPaint => fill as unknown as MeshGradientPaint;\nconst asFill = (mesh: MeshGradientPaint): Paint => mesh as unknown as Paint;\n\n/** The `mesh-gradient` kind's registry entry. `./registerMesh` registers it;\n *  the paint-kind registry loads it on demand otherwise. */\nexport const meshGradientKind: PaintKindEntry = {\n  ...meshDrawKind,\n  label: 'Mesh',\n  icon: 'paintMesh',\n  seed: (color) => asFill(seedMeshPatch(color)),\n  // The first corner of the first patch: a mesh has no single color, and this\n  // is the one a fallback swatch and an SVG paint fallback both read.\n  colorOf: (paint) => asMesh(paint).patches?.[0]?.colors?.[0],\n  stopsOf: (paint) => meshStops(asMesh(paint)),\n  fromStops: (stops) => asFill(meshFromStops(stops)),\n  toSvg: (id, fill) => meshGradientXml(id, asMesh(fill)),\n};\n"],"mappings":";;AAQA,IAAMA,KAAU,MAAmCC,GAC7CC,KAAU,MAAmCC,GAItCC,IAAmC;CAC9C,GAAGC;CACH,OAAO;CACP,MAAM;CACN,OAAO,MAAUH,EAAOI,EAAcC,CAAK,CAAC;CAG5C,UAAU,MAAUP,EAAOQ,CAAK,CAAC,CAAC,UAAU,EAAE,EAAE,SAAS;CACzD,UAAU,MAAUC,EAAUT,EAAOQ,CAAK,CAAC;CAC3C,YAAY,MAAUN,EAAOQ,EAAcC,CAAK,CAAC;CACjD,QAAQ,GAAI,MAASC,EAAgBC,GAAIb,EAAOC,CAAI,CAAC;AACvD"}