@weasel-js/core 1.9.3 → 1.10.0

package/dist/interactions/actions/move/gestureAdapter.js

@@ -1,35 +1,27 @@
-import { documentPose as e } from "../../../core/scene/effectivePose.js";
-import { asNodeId as t } from "../../../core/scene/types.js";
-import { fnFieldsOfNode as n } from "../../../core/scene/nodeFnFields.js";
+import { asNodeId as e } from "../../../core/scene/types.js";
+import { scenePoseTarget as t } from "../../../animation/poseTarget.js";
+import { defaultCommitAdapter as n } from "../defaultCommitAdapter.js";
 //#region src/interactions/actions/move/gestureAdapter.ts
-function r(r) {
-	return {
-		getNode: (e) => r.get(t(e)),
-		getNodes: () => [...r.renderOrderNodes()],
-		getPose: (n) => e(r, r.get(t(n))),
-		getParent: (e) => r.get(t(e))?.parent ?? null,
-		setPose: (e, n) => r.setPose(t(e), n),
-		setParent: (e, n) => r.move(t(e), n === null ? null : t(n)),
-		setData: (e, n) => r.update(t(e), { data: n }),
-		removeNode: (e) => r.remove(t(e)),
-		insertNode: (e, t) => r.add({
-			kind: e.kind,
-			layer: e.layer,
-			pose: e.pose,
-			data: e.data,
-			id: e.id,
-			...t === void 0 ? {} : { index: t },
-			...e.parent === null ? {} : { parent: e.parent },
-			...e.dependsOn === void 0 ? {} : { dependsOn: e.dependsOn },
-			...n(e)
-		}),
-		getChildren: (e) => e === null ? [...r.roots] : [...r.childrenOf(t(e))],
-		setChildOrder: (e, n) => {
-			r.batch("Reorder", () => {
-				for (let i = 0; i < n.length; i++) (e === null ? r.roots : r.childrenOf(t(e)))[i] !== n[i] && r.reorder(t(n[i]), i);
-			});
-		}
+function r(r, i, a) {
+	let o = /* @__PURE__ */ new Map(), s = {
+		...n(r, a),
+		...i ? { applyOps: (e, t) => i(e, t, s) } : {},
+		previewPoses: (t) => {
+			let { overrides: n } = r;
+			for (let [r, i] of t) {
+				let t = e(r), a = o.get(r), s = a !== void 0 && n.get(t) === a;
+				if (i === null) o.delete(r), s && n.clear(t);
+				else if (s) a.pose = i;
+				else {
+					let e = { pose: i };
+					o.set(r, e), n.set(t, e);
+				}
+			}
+			n.commit();
+		},
+		poseTarget: (e, n) => t(r, e, n)
 	};
+	return s;
 }
 //#endregion
 export { r as moveGestureAdapter };

package/dist/interactions/actions/move/gestureAdapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"gestureAdapter.js","names":["moveGestureAdapter","scene","asNodeId","id","documentPose","pose","parentId","node","index","fnFieldsOfNode","ids"],"sources":["../../../../src/interactions/actions/move/gestureAdapter.ts"],"sourcesContent":["/**\n * Minimal scene-backed adapter for the move behavior pipeline.\n *\n * Lives in `interactions/` rather than reusing `canvas/sceneAdapter.ts` so the\n * move action does not import from `canvas/` (that back-edge would create an\n * `interactions → canvas → interactions` cycle). Carries exactly the methods\n * the move behaviors call (`getParent` / `getNodes` / `getNode`) plus the\n * mutators the committed ops apply through (`setPose` / `setParent` /\n * `setData` / `removeNode` / `insertNode` — `setData` carries the\n * geometryProjection seam's data-sync op) and the sibling-order seam\n * (`getChildren` / `setChildOrder`) those ops read to restore a node's slot.\n */\nimport { documentPose } from 'core/scene/effectivePose';\nimport { fnFieldsOfNode } from 'core/scene/nodeFnFields';\nimport type { Node, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { MoveAdapter } from 'core/adapters/types';\n\nexport type MoveGestureAdapter<TPose> = MoveAdapter<Node<unknown, string, TPose>, TPose> & {\n  /** Required override — this adapter always provides parent lookup. */\n  getParent(id: string): string | null;\n  setParent(id: string, parentId: string | null): void;\n  setData(id: string, data: unknown): void;\n  removeNode(id: string): void;\n  insertNode(node: Node<unknown, string, TPose>, index?: number): void;\n  getChildren(parentId: string | null): string[];\n  setChildOrder(parentId: string | null, ids: string[]): void;\n};\n\nexport function moveGestureAdapter<TPose>(\n  scene: Scene<unknown, string, TPose>,\n): MoveGestureAdapter<TPose> {\n  return {\n    getNode: (id) => scene.get(asNodeId(id)),\n    getNodes: () => {\n      return [...scene.renderOrderNodes()] as Node<unknown, string, TPose>[];\n    },\n    getPose: (id) => documentPose(scene, scene.get(asNodeId(id))!),\n    getParent: (id) => scene.get(asNodeId(id))?.parent ?? null,\n    setPose: (id, pose) => scene.setPose(asNodeId(id), pose),\n    setParent: (id, parentId) =>\n      scene.move(asNodeId(id), parentId === null ? null : asNodeId(parentId)),\n    setData: (id, data) => scene.update(asNodeId(id), { data } as never),\n    removeNode: (id) => scene.remove(asNodeId(id)),\n    insertNode: (node, index) =>\n      scene.add({\n        kind: node.kind,\n        layer: node.layer,\n        pose: node.pose,\n        data: node.data,\n        id: node.id,\n        ...(index !== undefined ? { index } : {}),\n        ...(node.parent !== null ? { parent: node.parent } : {}),\n        ...(node.dependsOn !== undefined ? { dependsOn: node.dependsOn } : {}),\n        ...fnFieldsOfNode(node),\n      }),\n    getChildren: (parentId) =>\n      parentId === null ? [...scene.roots] : [...scene.childrenOf(asNodeId(parentId))],\n    setChildOrder: (parentId, ids) => {\n      scene.batch('Reorder', () => {\n        for (let i = 0; i < ids.length; i++) {\n          const current = parentId === null ? scene.roots : scene.childrenOf(asNodeId(parentId));\n          if (current[i] === ids[i]) continue;\n          scene.reorder(asNodeId(ids[i]), i);\n        }\n      });\n    },\n  };\n}\n"],"mappings":";;;;AA6BA,SAAgBA,EACd,GAC2B;CAC3B,OAAO;EACL,UAAU,MAAOC,EAAM,IAAIC,EAASC,CAAE,CAAC;EACvC,gBACS,CAAC,GAAGF,EAAM,iBAAiB,CAAC;EAErC,UAAU,MAAOG,EAAaH,GAAOA,EAAM,IAAIC,EAASC,CAAE,CAAC,CAAE;EAC7D,YAAY,MAAOF,EAAM,IAAIC,EAASC,CAAE,CAAC,CAAC,EAAE,UAAU;EACtD,UAAU,GAAI,MAASF,EAAM,QAAQC,EAASC,CAAE,GAAGE,CAAI;EACvD,YAAY,GAAI,MACdJ,EAAM,KAAKC,EAASC,CAAE,GAAGG,MAAa,OAAO,OAAOJ,EAASI,CAAQ,CAAC;EACxE,UAAU,GAAI,MAASL,EAAM,OAAOC,EAASC,CAAE,GAAG,EAAE,QAAK,CAAU;EACnE,aAAa,MAAOF,EAAM,OAAOC,EAASC,CAAE,CAAC;EAC7C,aAAa,GAAM,MACjBF,EAAM,IAAI;GACR,MAAMM,EAAK;GACX,OAAOA,EAAK;GACZ,MAAMA,EAAK;GACX,MAAMA,EAAK;GACX,IAAIA,EAAK;GACT,GAAIC,MAAU,KAAA,IAAwB,CAAC,IAAb,EAAE,SAAM;GAClC,GAAID,EAAK,WAAW,OAAiC,CAAC,IAA3B,EAAE,QAAQA,EAAK,OAAO;GACjD,GAAIA,EAAK,cAAc,KAAA,IAA4C,CAAC,IAAjC,EAAE,WAAWA,EAAK,UAAU;GAC/D,GAAGE,EAAeF,CAAI;EACxB,CAAC;EACH,cAAc,MACZD,MAAa,OAAO,CAAC,GAAGL,EAAM,KAAK,IAAI,CAAC,GAAGA,EAAM,WAAWC,EAASI,CAAQ,CAAC,CAAC;EACjF,gBAAgB,GAAU,MAAQ;GAChC,EAAM,MAAM,iBAAiB;IAC3B,KAAK,IAAI,IAAI,GAAG,IAAII,EAAI,QAAQ,KAE9B,CADgBJ,MAAa,OAAOL,EAAM,QAAQA,EAAM,WAAWC,EAASI,CAAQ,CAAC,EAAA,CACzE,OAAOI,EAAI,MACvBT,EAAM,QAAQC,EAASQ,EAAI,EAAE,GAAG,CAAC;GAErC,CAAC;EACH;CACF;AACF"}
+{"version":3,"file":"gestureAdapter.js","names":["moveGestureAdapter","previews","adapter","defaultCommitAdapter","scene","selection","commit","ops","label","id","pose","poses","nodeId","asNodeId","mine","installed","overrides","entry","scenePoseTarget","descriptor"],"sources":["../../../../src/interactions/actions/move/gestureAdapter.ts"],"sourcesContent":["/**\n * The scene-backed adapter the move behavior pipeline reads and commits\n * through: the default actions' commit adapter, plus what a behavior needs\n * while the gesture runs and after it ends (`previewPoses`, `poseTarget`, and\n * an `applyOps` of its own).\n */\nimport type { Op } from 'core/ops/types';\nimport type { Node, PoseOverride, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { MoveAdapter } from 'core/adapters/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { scenePoseTarget } from '../../../animation/poseTarget';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\n\nexport type MoveGestureAdapter<TPose> = MoveAdapter<Node<unknown, string, TPose>, TPose>\n  & ReturnType<typeof defaultCommitAdapter<TPose>>\n  & { previewPoses(poses: ReadonlyMap<string, TPose | null>): void };\n\n/** `commit` is how a behavior's own `applyOps` batch lands; the returned\n *  adapter is passed back so the ops apply through it. Left out, the adapter\n *  has no `applyOps`. `selection` is as `defaultCommitAdapter` takes it. */\nexport function moveGestureAdapter<TPose>(\n  scene: Scene<unknown, string, TPose>,\n  commit?: (ops: Op[], label: string, adapter: MoveGestureAdapter<TPose>) => void,\n  selection?: SelectionApi['adapterMethods'],\n): MoveGestureAdapter<TPose> {\n  const previews = new Map<string, PoseOverride<TPose>>();\n  const adapter: MoveGestureAdapter<TPose> = {\n    ...defaultCommitAdapter(scene, selection),\n    ...(commit ? { applyOps: (ops: Op[], label: string) => commit(ops, label, adapter) } : {}),\n    previewPoses: (poses) => {\n      const { overrides } = scene;\n      for (const [id, pose] of poses) {\n        const nodeId = asNodeId(id);\n        const mine = previews.get(id);\n        const installed = mine !== undefined && overrides.get(nodeId) === mine;\n        if (pose === null) {\n          previews.delete(id);\n          if (installed) overrides.clear(nodeId);\n        } else if (installed) {\n          mine.pose = pose;\n        } else {\n          const entry = { pose };\n          previews.set(id, entry);\n          overrides.set(nodeId, entry);\n        }\n      }\n      overrides.commit();\n    },\n    poseTarget: (id, descriptor) => scenePoseTarget(scene, id, descriptor),\n  };\n  return adapter;\n}\n"],"mappings":";;;;AAqBA,SAAgBA,EACd,GACA,GACA,GAC2B;CAC3B,IAAMC,oBAAW,IAAI,IAAiC,GAChDC,IAAqC;EACzC,GAAGC,EAAqBC,GAAOC,CAAS;EACxC,GAAIC,IAAS,EAAE,WAAW,GAAW,MAAkBA,EAAOC,GAAKC,GAAON,CAAO,EAAE,IAAI,CAAC;EACxF,eAAe,MAAU;GACvB,IAAM,EAAE,iBAAcE;GACtB,KAAK,IAAM,CAACK,GAAIC,MAASC,GAAO;IAC9B,IAAMC,IAASC,EAASJ,CAAE,GACpBK,IAAOb,EAAS,IAAIQ,CAAE,GACtBM,IAAYD,MAAS,KAAA,KAAaE,EAAU,IAAIJ,CAAM,MAAME;IAClE,IAAIJ,MAAS,MAEX,AADAT,EAAS,OAAOQ,CAAE,GACdM,KAAWC,EAAU,MAAMJ,CAAM;SAChC,IAAIG,GACT,EAAK,OAAOL;SACP;KACL,IAAMO,IAAQ,EAAE,QAAK;KAErB,AADAhB,EAAS,IAAIQ,GAAIQ,CAAK,GACtBD,EAAU,IAAIJ,GAAQK,CAAK;IAC7B;GACF;GACA,EAAU,OAAO;EACnB;EACA,aAAa,GAAI,MAAeC,EAAgBd,GAAOK,GAAIU,CAAU;CACvE;CACA,OAAOjB;AACT"}

package/dist/interactions/actions/move/landedDescendants.js

@@ -0,0 +1,33 @@
+import { translatePoseViaDescriptor as e } from "../../../core/geometry/poseDescriptor.js";
+import { subtreeIds as t } from "../selectionSubtree.js";
+import { createTransformOp as n } from "../../../core/ops/transform.js";
+//#region src/interactions/actions/move/landedDescendants.ts
+function r(r, i) {
+	let { scene: a, projection: o, startPoses: s, carried: c, label: l } = r, u = /* @__PURE__ */ new Map();
+	for (let e of i) {
+		if (e.name !== "transform") continue;
+		let t = e.args;
+		u.set(t.id, t.to);
+	}
+	let d = [];
+	for (let i of r.roots) {
+		let r = u.get(i), f = s.get(i);
+		if (r === void 0 || f === void 0) continue;
+		let p = o.getBounds(f), m = o.getBounds(r), h = m.x - p.x, g = m.y - p.y;
+		if (h !== 0 || g !== 0) for (let r of t(a, i)) {
+			if (r === i || u.has(r) || c.has(r)) continue;
+			let t = a.get(r);
+			t && d.push(n({
+				id: r,
+				from: t.pose,
+				to: e(t.pose, h, g, o),
+				label: l
+			}));
+		}
+	}
+	return d;
+}
+//#endregion
+export { r as landedDescendantOps };
+
+//# sourceMappingURL=landedDescendants.js.map

package/dist/interactions/actions/move/landedDescendants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"landedDescendants.js","names":["landedDescendantOps","input","landed","op","ops","a","out","root","to","start","startPoses","projection","b","dx","dy","id","subtreeIds","scene","carried","node","createTransformOp","translatePoseViaDescriptor"],"sources":["../../../../src/interactions/actions/move/landedDescendants.ts"],"sourcesContent":["import type { NodeId, Scene } from 'core/scene/types';\nimport type { Op } from 'core/ops/types';\nimport { createTransformOp } from 'core/ops/transform';\nimport { translatePoseViaDescriptor, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { subtreeIds } from '../selectionSubtree';\n\n/** What a move gesture captured at its start, as this pass reads it. */\nexport interface LandedDescendantsInput {\n  scene: Scene<unknown, string, unknown>;\n  projection: PoseDescriptor<unknown>;\n  /** The dragged roots. */\n  roots: readonly NodeId[];\n  /** Start pose of every root and descendant. */\n  startPoses: ReadonlyMap<NodeId, unknown>;\n  /** Descendants stored in a moving node's frame, which that node carries. */\n  carried: ReadonlySet<NodeId>;\n  label: string;\n}\n\n/**\n * Ops that bring each dragged root's descendants along to wherever `ops` put\n * the root. A layout drop or a behavior places the root itself, somewhere the\n * drag delta does not describe, so each descendant moves by its root's landed\n * pose less its start pose. A descendant `ops` already writes, or that a\n * moving frame carries, is left alone.\n */\nexport function landedDescendantOps(input: LandedDescendantsInput, ops: readonly Op[]): Op[] {\n  const { scene, projection, startPoses, carried, label } = input;\n  const landed = new Map<string, unknown>();\n  for (const op of ops) {\n    if (op.name !== 'transform') continue;\n    const a = op.args as { id: string; to: unknown };\n    landed.set(a.id, a.to);\n  }\n  const out: Op[] = [];\n  for (const root of input.roots) {\n    const to = landed.get(root);\n    const start = startPoses.get(root);\n    if (to === undefined || start === undefined) continue;\n    const a = projection.getBounds(start);\n    const b = projection.getBounds(to);\n    const dx = b.x - a.x;\n    const dy = b.y - a.y;\n    if (dx === 0 && dy === 0) continue;\n    for (const id of subtreeIds(scene, root)) {\n      if (id === root || landed.has(id) || carried.has(id)) continue;\n      const node = scene.get(id);\n      if (!node) continue;\n      out.push(createTransformOp<unknown>({\n        id,\n        from: node.pose,\n        to: translatePoseViaDescriptor(node.pose, dx, dy, projection),\n        label,\n      }));\n    }\n  }\n  return out;\n}\n"],"mappings":";;;;AA0BA,SAAgBA,EAAoB,GAA+B,GAA0B;CAC3F,IAAM,EAAE,UAAO,eAAY,eAAY,YAAS,aAAUC,GACpDC,oBAAS,IAAI,IAAqB;CACxC,KAAK,IAAMC,KAAMC,GAAK;EACpB,IAAID,EAAG,SAAS,aAAa;EAC7B,IAAME,IAAIF,EAAG;EACb,EAAO,IAAIE,EAAE,IAAIA,EAAE,EAAE;CACvB;CACA,IAAMC,IAAY,CAAC;CACnB,KAAK,IAAMC,KAAQN,EAAM,OAAO;EAC9B,IAAMO,IAAKN,EAAO,IAAIK,CAAI,GACpBE,IAAQC,EAAW,IAAIH,CAAI;EACjC,IAAIC,MAAO,KAAA,KAAaC,MAAU,KAAA,GAAW;EAC7C,IAAMJ,IAAIM,EAAW,UAAUF,CAAK,GAC9BG,IAAID,EAAW,UAAUH,CAAE,GAC3BK,IAAKD,EAAE,IAAIP,EAAE,GACbS,IAAKF,EAAE,IAAIP,EAAE;EACnB,IAAIQ,MAAO,KAAKC,MAAO,GACvB,KAAK,IAAMC,KAAMC,EAAWC,GAAOV,CAAI,GAAG;GACxC,IAAIQ,MAAOR,KAAQL,EAAO,IAAIa,CAAE,KAAKG,EAAQ,IAAIH,CAAE,GAAG;GACtD,IAAMI,IAAOF,EAAM,IAAIF,CAAE;GACzB,AAAKI,KACLb,EAAI,KAAKc,EAA2B;IAClC;IACA,MAAMD,EAAK;IACX,IAAIE,EAA2BF,EAAK,MAAMN,GAAIC,GAAIH,CAAU;IAC5D;GACF,CAAC,CAAC;EACJ;CACF;CACA,OAAOL;AACT"}

package/dist/interactions/actions/move/layout/container.js

@@ -0,0 +1,94 @@
+import { toPlane as e } from "../../../../core/viewport/parallax.js";
+import { composeWorldPose as t } from "../../../../core/scene/composeFrame.js";
+import { poseDescriptorForNode as n } from "../../../../core/geometry/poseDescriptor.js";
+import { planeOf as r } from "../../planeInput.js";
+import { scenePoseAdapter as i } from "../../../../core/scene/scenePoseAdapter.js";
+import { carryDragged as a } from "./dragged.js";
+import { pointInPath as o } from "@weasel-js/geom";
+//#region src/interactions/actions/move/layout/container.ts
+function s(e, t) {
+	return t.x >= e.x && t.x < e.x + e.width && t.y >= e.y && t.y < e.y + e.height;
+}
+function c(e, t, n) {
+	let r = {
+		x: n.x - t.x,
+		y: n.y - t.y
+	};
+	return typeof e == "function" ? e(r) : o(e, r.x, r.y);
+}
+function l(e, t, n) {
+	let r = null;
+	if (t === "topmost") {
+		let t = new Map(n.map((e) => [e.id, e]));
+		for (let n of e.renderOrder()) r = t.get(n) ?? r;
+	} else for (let e of n) {
+		if (r === null) {
+			r = e;
+			continue;
+		}
+		if (e.depth > r.depth) {
+			r = e;
+			continue;
+		}
+		if (e.depth < r.depth) continue;
+		let t = !1;
+		for (let n = 0; n < e.zPath.length; n++) {
+			if (e.zPath[n] > r.zPath[n]) {
+				t = !0;
+				break;
+			}
+			if (e.zPath[n] < r.zPath[n]) {
+				t = !1;
+				break;
+			}
+		}
+		t && (r = e);
+	}
+	return r;
+}
+function u(o, u, d) {
+	let f = o.layout;
+	if (!f) return null;
+	let p = o.scene, m = o.pc, h = i(p), g = o.projection, _ = new Set(u.map((e) => e.id)), v = [], y = f.dropTarget ?? "innermost", b = (e, t, n, r, i) => {
+		let a = r.dropRegion?.({
+			id: e,
+			bounds: n
+		}) ?? null;
+		return a ? c(a, n, i) : y === "region" ? !1 : r.contains ? r.contains(t, i) : s(n, i);
+	}, x = (i, s) => {
+		let c = f.getLayout(i);
+		if (!c) return;
+		let l = p.get(i);
+		if (!l) return;
+		let _ = t(h, i, m.compose), y = n(g, l).getBounds(_), x = r(o.view, l.layer), S = x ? e(x, d) : d;
+		if (b(i, _, y, c, S)) {
+			if (c.acceptsDrop) {
+				let e = {
+					id: i,
+					bounds: y
+				};
+				for (let t of u) if (!c.acceptsDrop(e, a(o, t, x).arg)) return;
+			}
+			v.push({
+				id: i,
+				bounds: y,
+				layout: c,
+				zPath: s,
+				depth: s.length,
+				plane: x
+			});
+		}
+	}, S = (e, t) => {
+		let n = e === null ? p.roots : p.childrenOf(e);
+		for (let e = 0; e < n.length; e++) {
+			if (_.has(n[e])) continue;
+			let r = [...t, e];
+			x(n[e], r), S(n[e], r);
+		}
+	};
+	return S(null, []), l(p, y, v);
+}
+//#endregion
+export { u as pickContainer, s as pointInBounds };
+
+//# sourceMappingURL=container.js.map

package/dist/interactions/actions/move/layout/container.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.js","names":["pointInBounds","at","b","regionContains","local","point","bounds","region","pointInPath","chooseContainer","dest","mode","byId","candidates","c","id","scene","cAfter","i","pickContainer","layoutDep","session","pc","poseAdapter","scenePoseAdapter","d","draggedIds","dragged","testInside","layout","aabb","cPose","consider","node","worldPose","composeWorldPose","worldAABB","poseDescriptorForNode","plane","planeOf","toPlane","center","arg","carryDragged","zPath","walk","childIds","parentId","childPath","parentPath"],"sources":["../../../../../src/interactions/actions/move/layout/container.ts"],"sourcesContent":["import { pointInPath } from '@weasel-js/geom';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport { poseDescriptorForNode } from 'core/geometry/poseDescriptor';\nimport { toPlane, type PlaneMap } from 'core/viewport/parallax';\nimport { composeWorldPose } from 'core/scene/composePose';\nimport { scenePoseAdapter } from 'core/scene/scenePoseAdapter';\nimport type { DropRegion, LayoutContainer, LayoutStrategy } from '../../../../layout/types';\nimport type { LayoutDep } from '../../depSchema';\nimport { planeOf } from '../../planeInput';\nimport type { MoveSession } from '../session';\nimport { carryDragged, type DraggedChild } from './dragged';\n\nexport interface Bounds4 { x: number; y: number; width: number; height: number }\nexport function pointInBounds(b: Bounds4, at: { x: number; y: number }): boolean {\n  return at.x >= b.x && at.x < b.x + b.width && at.y >= b.y && at.y < b.y + b.height;\n}\n\ntype Layout = LayoutStrategy<unknown>;\nexport interface Candidate {\n  id: NodeId;\n  bounds: Bounds4;\n  layout: LayoutStrategy<unknown>;\n  zPath: number[];\n  depth: number;\n  /** The edited plane into this container's. */\n  plane: PlaneMap | null;\n}\n\n/** Whether a world point falls in a drop region, which is authored relative to\n *  the top-left of the container's world bounds. */\nfunction regionContains(\n  region: DropRegion,\n  bounds: { x: number; y: number },\n  point: { x: number; y: number },\n): boolean {\n  const local = { x: point.x - bounds.x, y: point.y - bounds.y };\n  return typeof region === 'function'\n    ? region(local)\n    : pointInPath(region, local.x, local.y);\n}\n\nfunction chooseContainer(\n  scene: Scene<unknown, string, unknown>,\n  mode: NonNullable<LayoutDep['dropTarget']>,\n  candidates: readonly Candidate[],\n): Candidate | null {\n  let dest: Candidate | null = null;\n  if (mode === 'topmost') {\n    // Painted last wins, in the scene's own render order — which crosses\n    // subtrees and layers, where a sibling-index path cannot.\n    const byId = new Map<NodeId, Candidate>(candidates.map((c) => [c.id, c]));\n    for (const id of scene.renderOrder()) dest = byId.get(id) ?? dest;\n  } else {\n    // Deepest wins; sibling-index path breaks ties (higher z = later index).\n    for (const c of candidates) {\n      if (dest === null) { dest = c; continue; }\n      if (c.depth > dest.depth) { dest = c; continue; }\n      if (c.depth < dest.depth) continue;\n      let cAfter = false;\n      for (let i = 0; i < c.zPath.length; i++) {\n        if (c.zPath[i] > dest.zPath[i]) { cAfter = true; break; }\n        if (c.zPath[i] < dest.zPath[i]) { cAfter = false; break; }\n      }\n      if (cAfter) dest = c;\n    }\n  }\n  return dest;\n}\n\n/** The layout container that takes the drop at `center`, or null. */\nexport function pickContainer(\n  session: MoveSession,\n  dragged: readonly DraggedChild[],\n  center: { x: number; y: number },\n): Candidate | null {\n  const layoutDep = session.layout;\n  if (!layoutDep) return null;\n  const scene = session.scene;\n  const pc = session.pc;\n  const poseAdapter = scenePoseAdapter(scene);\n  const d = session.projection;\n  const draggedIds = new Set<NodeId>(dragged.map((c) => c.id));\n  const candidates: Candidate[] = [];\n  const mode = layoutDep.dropTarget ?? 'innermost';\n  const testInside = (\n    id: NodeId, cPose: unknown, aabb: Bounds4, layout: Layout, at: { x: number; y: number },\n  ): boolean => {\n    const region = layout.dropRegion?.({ id: id as string, bounds: aabb }) ?? null;\n    if (region) return regionContains(region, aabb, at);\n    if (mode === 'region') return false;\n    if (layout.contains) return layout.contains(cPose, at);\n    return pointInBounds(aabb, at);\n  };\n  const consider = (id: NodeId, zPath: number[]): void => {\n    const layout = layoutDep.getLayout(id as string);\n    if (!layout) return;\n    const node = scene.get(id);\n    if (!node) return;\n    const worldPose = composeWorldPose(poseAdapter, id as string, pc.compose);\n    const worldAABB = poseDescriptorForNode(d, node).getBounds(worldPose);\n    const plane = planeOf(session.view, node.layer);\n    const at = plane ? toPlane(plane, center) : center;\n    if (!testInside(id, worldPose, worldAABB, layout, at)) return;\n    if (layout.acceptsDrop) {\n      const arg: LayoutContainer = { id: id as string, bounds: worldAABB };\n      for (const c of dragged) if (!layout.acceptsDrop(arg, carryDragged(session, c, plane).arg)) return;\n    }\n    candidates.push({\n      id,\n      bounds: worldAABB,\n      layout,\n      zPath,\n      depth: zPath.length,\n      plane,\n    });\n  };\n  const walk = (parentId: NodeId | null, parentPath: number[]): void => {\n    const childIds = parentId === null ? scene.roots : scene.childrenOf(parentId);\n    for (let i = 0; i < childIds.length; i++) {\n      // A dragged root's subtree goes with it: dropping into one of its own\n      // descendants would reparent it under itself.\n      if (draggedIds.has(childIds[i])) continue;\n      const childPath = [...parentPath, i];\n      consider(childIds[i], childPath);\n      walk(childIds[i], childPath);\n    }\n  };\n  walk(null, []);\n\n  return chooseContainer(scene, mode, candidates);\n}\n"],"mappings":"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"}

package/dist/interactions/actions/move/layout/dragged.js

@@ -0,0 +1,58 @@
+import { toPlane as e } from "../../../../core/viewport/parallax.js";
+import { composeWorldPose as t } from "../../../../core/scene/composeFrame.js";
+import { poseDescriptorForNode as n, translatePoseViaDescriptor as r } from "../../../../core/geometry/poseDescriptor.js";
+import { carryPose as i, invertPlane as a, planeOf as o } from "../../planeInput.js";
+import { scenePoseAdapter as s } from "../../../../core/scene/scenePoseAdapter.js";
+import { grabbedPoseAdapter as c, planeDelta as l } from "../delta.js";
+//#region src/interactions/actions/move/layout/dragged.ts
+function u(e, u) {
+	let d = e.scene, f = e.pc, p = s(d), { dx: m, dy: h } = u, g = e.projection, _ = c(e, p), v = [];
+	for (let s of e.ids) {
+		let c = d.get(s);
+		if (!c) continue;
+		let u = t(_, s, f.compose), p = n(g, c), y = l(e, s, m, h), b = a(o(e.view, c.layer)), x = i(p, r(u, y.dx, y.dy, p), b), S = p.getBounds(x);
+		v.push({
+			id: s,
+			arg: {
+				id: s,
+				originPose: i(p, u, b),
+				pose: x,
+				sourceContainerId: c.parent ?? null
+			},
+			center: {
+				x: S.x + S.width / 2,
+				y: S.y + S.height / 2
+			}
+		});
+	}
+	return v;
+}
+function d(t, r, a) {
+	let { scene: o, projection: s } = t;
+	if (a === null) return r;
+	let c = n(s, o.get(r.id));
+	return {
+		id: r.id,
+		arg: {
+			...r.arg,
+			originPose: i(c, r.arg.originPose, a),
+			pose: i(c, r.arg.pose, a)
+		},
+		center: e(a, r.center)
+	};
+}
+function f(e, t) {
+	let n = e.projection, r = Infinity, i = Infinity, a = -Infinity, o = -Infinity;
+	for (let e of t) {
+		let t = n.getBounds(e.arg.pose);
+		r = Math.min(r, t.x), i = Math.min(i, t.y), a = Math.max(a, t.x + t.width), o = Math.max(o, t.y + t.height);
+	}
+	return {
+		x: (r + a) / 2,
+		y: (i + o) / 2
+	};
+}
+//#endregion
+export { d as carryDragged, u as gatherDragged, f as selectionCenter };
+
+//# sourceMappingURL=dragged.js.map

package/dist/interactions/actions/move/layout/dragged.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dragged.js","names":["gatherDragged","scene","session","pc","poseAdapter","scenePoseAdapter","delta","d","grabAdapter","grabbedPoseAdapter","dragged","id","node","startWorld","composeWorldPose","g","poseDescriptorForNode","own","planeDelta","dx","dy","toEdited","invertPlane","planeOf","world","carryPose","translatePoseViaDescriptor","b","carryDragged","m","c","toPlane","selectionCenter","minX","minY","maxX","maxY"],"sources":["../../../../../src/interactions/actions/move/layout/dragged.ts"],"sourcesContent":["import type { NodeId } from 'core/scene/types';\nimport { poseDescriptorForNode, translatePoseViaDescriptor } from 'core/geometry/poseDescriptor';\nimport { toPlane, type PlaneMap } from 'core/viewport/parallax';\nimport { composeWorldPose } from 'core/scene/composePose';\nimport { scenePoseAdapter } from 'core/scene/scenePoseAdapter';\nimport type { LayoutDragged } from '../../../../layout/types';\nimport { carryPose, invertPlane, planeOf } from '../../planeInput';\nimport { grabbedPoseAdapter, planeDelta } from '../delta';\nimport type { MoveSession } from '../session';\n\nexport interface DraggedChild {\n  id: NodeId;\n  arg: LayoutDragged<unknown>;\n  center: { x: number; y: number };\n}\n\n/** Each dragged root in world, in the edited plane. */\nexport function gatherDragged(session: MoveSession, delta: { dx: number; dy: number }): DraggedChild[] {\n  const scene = session.scene;\n  const pc = session.pc;\n  const poseAdapter = scenePoseAdapter(scene);\n  const { dx, dy } = delta;\n  // Each dragged preview in WORLD: compose the committed start pose up the\n  // parent chain, then add the world drag delta (same math as `applyReparent`).\n  // The LayoutStrategy contract is world-framed, so every pose handed to it\n  // below is composed to world; reflow results are rebased back to local.\n  // A selection spanning planes is gathered in the edited plane, and handed\n  // to each container carried into the plane that container is stored in.\n  const d = session.projection;\n  const grabAdapter = grabbedPoseAdapter(session, poseAdapter);\n  const dragged: DraggedChild[] = [];\n  for (const id of session.ids) {\n    const node = scene.get(id);\n    if (!node) continue;\n    const startWorld = composeWorldPose(grabAdapter, id as string, pc.compose);\n    const g = poseDescriptorForNode(d, node);\n    const own = planeDelta(session, id, dx, dy);\n    const toEdited = invertPlane(planeOf(session.view, node.layer));\n    const world = carryPose(g, translatePoseViaDescriptor(startWorld, own.dx, own.dy, g), toEdited);\n    const b = g.getBounds(world);\n    dragged.push({\n      id,\n      arg: {\n        id: id as string,\n        originPose: carryPose(g, startWorld, toEdited),\n        pose: world,\n        sourceContainerId: (node.parent ?? null) as string | null,\n      },\n      center: { x: b.x + b.width / 2, y: b.y + b.height / 2 },\n    });\n  }\n  return dragged;\n}\n\n/** `c` carried into the plane `m` maps to; `c` itself when `m` is null. */\nexport function carryDragged(session: MoveSession, c: DraggedChild, m: PlaneMap | null): DraggedChild {\n  const { scene, projection: d } = session;\n  if (m === null) return c;\n  const g = poseDescriptorForNode(d, scene.get(c.id)!);\n  return {\n    id: c.id,\n    arg: { ...c.arg, originPose: carryPose(g, c.arg.originPose, m), pose: carryPose(g, c.arg.pose, m) },\n    center: toPlane(m, c.center),\n  };\n}\n\n/** Center of the bounds of everything dragged. */\nexport function selectionCenter(session: MoveSession, dragged: readonly DraggedChild[]): { x: number; y: number } {\n  const d = session.projection;\n  // The selection lands as a unit, so one point decides the container: the\n  // center of the whole dragged group. Hit-testing each child on its own\n  // would scatter a selection straddling two containers.\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  for (const c of dragged) {\n    const b = d.getBounds(c.arg.pose);\n    minX = Math.min(minX, b.x);\n    minY = Math.min(minY, b.y);\n    maxX = Math.max(maxX, b.x + b.width);\n    maxY = Math.max(maxY, b.y + b.height);\n  }\n  return { x: (minX + maxX) / 2, y: (minY + maxY) / 2 };\n}\n"],"mappings":";;;;;;;AAiBA,SAAgBA,EAAc,GAAsB,GAAmD;CACrG,IAAMC,IAAQC,EAAQ,OAChBC,IAAKD,EAAQ,IACbE,IAAcC,EAAiBJ,CAAK,GACpC,EAAE,OAAI,UAAOK,GAObC,IAAIL,EAAQ,YACZM,IAAcC,EAAmBP,GAASE,CAAW,GACrDM,IAA0B,CAAC;CACjC,KAAK,IAAMC,KAAMT,EAAQ,KAAK;EAC5B,IAAMU,IAAOX,EAAM,IAAIU,CAAE;EACzB,IAAI,CAACC,GAAM;EACX,IAAMC,IAAaC,EAAiBN,GAAaG,GAAcR,EAAG,OAAO,GACnEY,IAAIC,EAAsBT,GAAGK,CAAI,GACjCK,IAAMC,EAAWhB,GAASS,GAAIQ,GAAIC,CAAE,GACpCC,IAAWC,EAAYC,EAAQrB,EAAQ,MAAMU,EAAK,KAAK,CAAC,GACxDY,IAAQC,EAAUV,GAAGW,EAA2Bb,GAAYI,EAAI,IAAIA,EAAI,IAAIF,CAAC,GAAGM,CAAQ,GACxFM,IAAIZ,EAAE,UAAUS,CAAK;EAC3B,EAAQ,KAAK;GACX;GACA,KAAK;IACC;IACJ,YAAYC,EAAUV,GAAGF,GAAYQ,CAAQ;IAC7C,MAAMG;IACN,mBAAoBZ,EAAK,UAAU;GACrC;GACA,QAAQ;IAAE,GAAGe,EAAE,IAAIA,EAAE,QAAQ;IAAG,GAAGA,EAAE,IAAIA,EAAE,SAAS;GAAE;EACxD,CAAC;CACH;CACA,OAAOjB;AACT;AAGA,SAAgBkB,EAAa,GAAsB,GAAiB,GAAkC;CACpG,IAAM,EAAE,UAAO,YAAYrB,MAAML;CACjC,IAAI2B,MAAM,MAAM,OAAOC;CACvB,IAAMf,IAAIC,EAAsBT,GAAGN,EAAM,IAAI6B,EAAE,EAAE,CAAE;CACnD,OAAO;EACL,IAAIA,EAAE;EACN,KAAK;GAAE,GAAGA,EAAE;GAAK,YAAYL,EAAUV,GAAGe,EAAE,IAAI,YAAYD,CAAC;GAAG,MAAMJ,EAAUV,GAAGe,EAAE,IAAI,MAAMD,CAAC;EAAE;EAClG,QAAQE,EAAQF,GAAGC,EAAE,MAAM;CAC7B;AACF;AAGA,SAAgBE,EAAgB,GAAsB,GAA4D;CAChH,IAAMzB,IAAIL,EAAQ,YAId+B,IAAO,UACPC,IAAO,UACPC,IAAO,WACPC,IAAO;CACX,KAAK,IAAMN,KAAKpB,GAAS;EACvB,IAAMiB,IAAIpB,EAAE,UAAUuB,EAAE,IAAI,IAAI;EAIhC,AAHA,IAAO,KAAK,IAAIG,GAAMN,EAAE,CAAC,GACzB,IAAO,KAAK,IAAIO,GAAMP,EAAE,CAAC,GACzB,IAAO,KAAK,IAAIQ,GAAMR,EAAE,IAAIA,EAAE,KAAK,GACnC,IAAO,KAAK,IAAIS,GAAMT,EAAE,IAAIA,EAAE,MAAM;CACtC;CACA,OAAO;EAAE,IAAIM,IAAOE,KAAQ;EAAG,IAAID,IAAOE,KAAQ;CAAE;AACtD"}

package/dist/interactions/actions/move/layout/dropPass.js

@@ -0,0 +1,122 @@
+import { toPlane as e } from "../../../../core/viewport/parallax.js";
+import { composeWorldPose as t, rebaseLocalPose as n } from "../../../../core/scene/composeFrame.js";
+import { asNodeId as r } from "../../../../core/scene/types.js";
+import { scenePoseAdapter as i } from "../../../../core/scene/scenePoseAdapter.js";
+import { carryDragged as a, gatherDragged as o, selectionCenter as s } from "./dragged.js";
+import { pickContainer as c } from "./container.js";
+//#region src/interactions/actions/move/layout/dropPass.ts
+function l(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let r of e) {
+		let e = r.sourceContainerId;
+		if (!e || e === t) continue;
+		let i = n.get(e);
+		i || (i = /* @__PURE__ */ new Set(), n.set(e, i)), i.add(r.id);
+	}
+	return n;
+}
+function u(n, o, s, c, l) {
+	let { scene: u, pc: d } = n, f = i(u), p = new Set(c.map((e) => e.id)), m = o.layout, h = u.childrenOf(o.id).map((e) => ({
+		id: e,
+		pose: t(f, e, d.compose)
+	})), g = (e, t) => {
+		let n = h.findIndex((t) => t.id === e);
+		n >= 0 ? h[n] = {
+			id: e,
+			pose: t
+		} : h.push({
+			id: e,
+			pose: t
+		});
+	}, _ = [], v = /* @__PURE__ */ new Map(), y = o.plane;
+	for (let t of c) {
+		let i = a(n, t, y), o = h.map((e) => ({ ...e })), c = m.getDropTargets(s, o, i.arg), u = {
+			x: t.center.x + l.x,
+			y: t.center.y + l.y
+		}, d = m.snap.pickTarget(c, y ? e(y, u) : u);
+		if (!d) return null;
+		_.push({
+			dragged: i.arg,
+			children: o,
+			target: d
+		});
+		let f = m.reflowPoses(s, o, i.arg, d);
+		for (let [e, t] of f) g(e, t), p.has(r(e)) || v.set(r(e), t);
+		g(i.arg.id, f.get(i.arg.id) ?? d.pose);
+	}
+	return {
+		placements: _,
+		destReflow: v
+	};
+}
+function d(e, n, a) {
+	let { scene: o, pc: s, projection: c } = e, u = i(o), d = /* @__PURE__ */ new Map(), f = e.layout;
+	if (!f) return d;
+	for (let [e, i] of l(n.map((e) => ({
+		id: e.id,
+		sourceContainerId: e.arg.sourceContainerId
+	})), a)) {
+		let n = f.getLayout(e), a = o.get(r(e));
+		if (!n || !a) continue;
+		let l = {
+			id: e,
+			bounds: c.getBounds(t(u, e, s.compose))
+		}, p = o.childrenOf(r(e)).filter((e) => !i.has(e)).map((e) => ({
+			id: e,
+			pose: t(u, e, s.compose)
+		}));
+		for (let [e, r] of n.childPoses(l, p)) {
+			let n = c.getBounds(t(u, e, s.compose)), i = c.getBounds(r);
+			(n.x !== i.x || n.y !== i.y || n.width !== i.width || n.height !== i.height) && d.set(e, r);
+		}
+	}
+	return d;
+}
+function f(e, t, a) {
+	if (!e.layout) return null;
+	let { scene: l, pc: f } = e, p = i(l), m = o(e, t);
+	if (m.length === 0) return null;
+	let h = s(e, m), g = {
+		x: a.x - h.x,
+		y: a.y - h.y
+	}, _ = c(e, m, h);
+	if (!_) return {
+		dropCenter: h,
+		pass: null,
+		reflow: /* @__PURE__ */ new Map()
+	};
+	let v = {
+		id: _.id,
+		bounds: _.bounds
+	}, y = u(e, _, v, m, g);
+	if (!y) return {
+		dropCenter: h,
+		pass: null,
+		reflow: /* @__PURE__ */ new Map()
+	};
+	let b = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Set();
+	for (let [e, t] of y.destReflow) {
+		let r = l.get(e)?.parent ?? null;
+		b.set(e, n(p, t, r, f.compose, f.decompose)), x.add(e);
+	}
+	let S = d(e, m, v.id);
+	for (let [e, t] of S) {
+		let i = l.get(r(e))?.parent ?? null;
+		b.set(r(e), n(p, t, i, f.compose, f.decompose)), x.add(r(e));
+	}
+	return {
+		dropCenter: h,
+		pass: {
+			layout: _.layout,
+			container: v,
+			placements: y.placements,
+			sourceReflow: S,
+			reflowIds: x
+		},
+		reflow: b
+	};
+}
+//#endregion
+export { l as groupBySourceContainer, f as runDropPass };
+
+//# sourceMappingURL=dropPass.js.map

package/dist/interactions/actions/move/layout/dropPass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropPass.js","names":["groupBySourceContainer","out","d","dragged","src","exclude","set","placeAll","session","poseAdapter","scenePoseAdapter","scene","draggedIds","c","layout","dest","working","cid","composeWorldPose","pc","setWorking","at","id","placements","destReflow","destPlane","edited","dc","carryDragged","children","targets","container","probe","probeOffset","target","toPlane","poses","pose","asNodeId","sourceReflow","layoutDep","srcId","leaving","destId","srcLayout","srcNode","srcContainer","srcChildren","cur","next","runDropPass","gatherDragged","delta","dropCenter","selectionCenter","pointer","pickContainer","placed","reflow","reflowIds","parent","rebaseLocalPose","leftovers"],"sources":["../../../../../src/interactions/actions/move/layout/dropPass.ts"],"sourcesContent":["import { asNodeId, type NodeId } from 'core/scene/types';\nimport { toPlane } from 'core/viewport/parallax';\nimport { composeWorldPose, rebaseLocalPose } from 'core/scene/composePose';\nimport { scenePoseAdapter } from 'core/scene/scenePoseAdapter';\nimport type { LayoutChild, LayoutContainer } from '../../../../layout/types';\nimport type { MoveSession } from '../session';\nimport { pickContainer, type Candidate } from './container';\nimport { carryDragged, gatherDragged, selectionCenter, type DraggedChild } from './dragged';\nimport type { DropPass, LayoutPlacement } from './types';\n\n/** Dragged ids grouped by the container they are leaving, skipping any that\n *  stay put (`exclude` is the destination) or that had no container. */\nexport function groupBySourceContainer(\n  dragged: ReadonlyArray<{ id: NodeId; sourceContainerId: string | null }>,\n  exclude: string | null,\n): Map<string, Set<NodeId>> {\n  const out = new Map<string, Set<NodeId>>();\n  for (const d of dragged) {\n    const src = d.sourceContainerId;\n    if (!src || src === exclude) continue;\n    let set = out.get(src);\n    if (!set) { set = new Set<NodeId>(); out.set(src, set); }\n    set.add(d.id);\n  }\n  return out;\n}\n\n/** Place each dragged child in `dest` in turn. Null when the snap rejects\n *  any of them: a container that cannot take every member takes none. */\nfunction placeAll(\n  session: MoveSession,\n  dest: Candidate,\n  container: LayoutContainer,\n  dragged: readonly DraggedChild[],\n  probeOffset: { x: number; y: number },\n): { placements: LayoutPlacement[]; destReflow: Map<NodeId, unknown> } | null {\n  const { scene, pc } = session;\n  const poseAdapter = scenePoseAdapter(scene);\n  const draggedIds = new Set<NodeId>(dragged.map((c) => c.id));\n  const layout = dest.layout;\n  // The container state the placements run against, advanced by each one.\n  const working: LayoutChild<unknown>[] = scene.childrenOf(dest.id).map((cid) => ({\n    id: cid as string,\n    pose: composeWorldPose(poseAdapter, cid as string, pc.compose),\n  }));\n  const setWorking = (id: string, pose: unknown): void => {\n    const at = working.findIndex((c) => c.id === id);\n    if (at >= 0) working[at] = { id, pose };\n    else working.push({ id, pose });\n  };\n\n  const placements: LayoutPlacement[] = [];\n  const destReflow = new Map<NodeId, unknown>();\n  const destPlane = dest.plane;\n  for (const edited of dragged) {\n    const dc = carryDragged(session, edited, destPlane);\n    const children = working.map((c) => ({ ...c }));\n    const targets = layout.getDropTargets(container, children, dc.arg);\n    const probe = { x: edited.center.x + probeOffset.x, y: edited.center.y + probeOffset.y };\n    const target = layout.snap.pickTarget(targets, destPlane ? toPlane(destPlane, probe) : probe);\n    // All-or-nothing: a container that cannot take every member takes none\n    // rather than splitting the selection between two homes.\n    if (!target) return null;\n    placements.push({ dragged: dc.arg, children, target });\n    const poses = layout.reflowPoses(container, children, dc.arg, target);\n    for (const [cid, pose] of poses) {\n      setWorking(cid, pose);\n      if (!draggedIds.has(asNodeId(cid))) destReflow.set(asNodeId(cid), pose);\n    }\n    setWorking(dc.arg.id, poses.get(dc.arg.id) ?? target.pose);\n  }\n  return { placements, destReflow };\n}\n\n/** World poses of the leftovers that moved in each container the selection left. */\nfunction sourceReflow(\n  session: MoveSession, dragged: readonly DraggedChild[], destId: string,\n): Map<string, unknown> {\n  const { scene, pc, projection: d } = session;\n  const poseAdapter = scenePoseAdapter(scene);\n  // Source reflow (cross-container) → fold changed leftovers into previews.\n  // One pass per container the selection left behind, with everything that\n  // left it withdrawn at once.\n  const sourceReflow = new Map<string, unknown>();\n  const layoutDep = session.layout;\n  if (!layoutDep) return sourceReflow;\n  for (const [srcId, leaving] of groupBySourceContainer(dragged.map((c) => ({\n    id: c.id,\n    sourceContainerId: c.arg.sourceContainerId,\n  })), destId)) {\n    const srcLayout = layoutDep.getLayout(srcId);\n    const srcNode = scene.get(asNodeId(srcId));\n    if (!srcLayout || !srcNode) continue;\n    const srcContainer: LayoutContainer = {\n      id: srcId,\n      bounds: d.getBounds(composeWorldPose(poseAdapter, srcId, pc.compose)),\n    };\n    const srcChildren: LayoutChild<unknown>[] = scene.childrenOf(asNodeId(srcId))\n      .filter((cid) => !leaving.has(cid))\n      .map((cid) => ({\n        id: cid as string,\n        pose: composeWorldPose(poseAdapter, cid as string, pc.compose),\n      }));\n    for (const [cid, pose] of srcLayout.childPoses(srcContainer, srcChildren)) {\n      const cur = d.getBounds(composeWorldPose(poseAdapter, cid, pc.compose));\n      const next = d.getBounds(pose);\n      const same = cur.x === next.x && cur.y === next.y\n        && cur.width === next.width && cur.height === next.height;\n      if (same) continue;\n      sourceReflow.set(cid, pose); // WORLD — rebased at each consumption point\n    }\n  }\n  return sourceReflow;\n}\n\n/** One frame's layout result, or null with no layout dep or nothing dragged. */\nexport function runDropPass(\n  session: MoveSession,\n  delta: { dx: number; dy: number },\n  pointer: { x: number; y: number },\n): DropPass | null {\n  if (!session.layout) return null;\n  const { scene, pc } = session;\n  const poseAdapter = scenePoseAdapter(scene);\n  const dragged = gatherDragged(session, delta);\n  if (dragged.length === 0) return null;\n  const dropCenter = selectionCenter(session, dragged);\n  // Each child is snapped at its own position, displaced by however far the\n  // pointer sits from that center — the group keeps its shape, and a lone\n  // child is still probed at the pointer itself.\n  const probeOffset = {\n    x: pointer.x - dropCenter.x,\n    y: pointer.y - dropCenter.y,\n  };\n\n  const dest = pickContainer(session, dragged, dropCenter);\n  if (!dest) return { dropCenter, pass: null, reflow: new Map() };\n\n  const container: LayoutContainer = { id: dest.id as string, bounds: dest.bounds };\n  const placed = placeAll(session, dest, container, dragged, probeOffset);\n  if (!placed) return { dropCenter, pass: null, reflow: new Map() };\n\n  // Destination reflow → fold into previews (the dragged children keep their\n  // pointer-following ghosts). `reflowPoses` returns world; previews are\n  // local, so rebase to the child's current parent frame first.\n  const reflow = new Map<NodeId, unknown>();\n  const reflowIds = new Set<NodeId>();\n  for (const [cid, pose] of placed.destReflow) {\n    const parent = scene.get(cid)?.parent ?? null;\n    reflow.set(cid, rebaseLocalPose(poseAdapter, pose, parent, pc.compose, pc.decompose));\n    reflowIds.add(cid);\n  }\n\n  const leftovers = sourceReflow(session, dragged, container.id);\n  for (const [cid, pose] of leftovers) {\n    const parent = scene.get(asNodeId(cid))?.parent ?? null;\n    reflow.set(asNodeId(cid), rebaseLocalPose(poseAdapter, pose, parent, pc.compose, pc.decompose));\n    reflowIds.add(asNodeId(cid));\n  }\n\n  return {\n    dropCenter,\n    pass: { layout: dest.layout, container, placements: placed.placements, sourceReflow: leftovers, reflowIds },\n    reflow,\n  };\n}\n"],"mappings":";;;;;;;AAYA,SAAgBA,EACd,GACA,GAC0B;CAC1B,IAAMC,oBAAM,IAAI,IAAyB;CACzC,KAAK,IAAMC,KAAKC,GAAS;EACvB,IAAMC,IAAMF,EAAE;EACd,IAAI,CAACE,KAAOA,MAAQC,GAAS;EAC7B,IAAIC,IAAML,EAAI,IAAIG,CAAG;EAErB,AADKE,MAAO,oBAAM,IAAI,IAAY,GAAGL,EAAI,IAAIG,GAAKE,CAAG,IACrDA,EAAI,IAAIJ,EAAE,EAAE;CACd;CACA,OAAOD;AACT;AAIA,SAASM,EACP,GACA,GACA,GACA,GACA,GAC4E;CAC5E,IAAM,EAAE,UAAO,UAAOC,GAChBC,IAAcC,EAAiBC,CAAK,GACpCC,IAAa,IAAI,IAAYT,EAAQ,KAAK,MAAMU,EAAE,EAAE,CAAC,GACrDC,IAASC,EAAK,QAEdC,IAAkCL,EAAM,WAAWI,EAAK,EAAE,CAAC,CAAC,KAAK,OAAS;EAC9E,IAAIE;EACJ,MAAMC,EAAiBT,GAAaQ,GAAeE,EAAG,OAAO;CAC/D,EAAE,GACIC,KAAc,GAAY,MAAwB;EACtD,IAAMC,IAAKL,EAAQ,WAAW,MAAMH,EAAE,OAAOS,CAAE;EAC/C,AAAID,KAAM,IAAG,EAAQA,KAAM;GAAE;GAAI;EAAK,IACjCL,EAAQ,KAAK;GAAE;GAAI;EAAK,CAAC;CAChC,GAEMO,IAAgC,CAAC,GACjCC,oBAAa,IAAI,IAAqB,GACtCC,IAAYV,EAAK;CACvB,KAAK,IAAMW,KAAUvB,GAAS;EAC5B,IAAMwB,IAAKC,EAAapB,GAASkB,GAAQD,CAAS,GAC5CI,IAAWb,EAAQ,KAAK,OAAO,EAAE,GAAGH,EAAE,EAAE,GACxCiB,IAAUhB,EAAO,eAAeiB,GAAWF,GAAUF,EAAG,GAAG,GAC3DK,IAAQ;GAAE,GAAGN,EAAO,OAAO,IAAIO,EAAY;GAAG,GAAGP,EAAO,OAAO,IAAIO,EAAY;EAAE,GACjFC,IAASpB,EAAO,KAAK,WAAWgB,GAASL,IAAYU,EAAQV,GAAWO,CAAK,IAAIA,CAAK;EAG5F,IAAI,CAACE,GAAQ,OAAO;EACpB,EAAW,KAAK;GAAE,SAASP,EAAG;GAAK;GAAU;EAAO,CAAC;EACrD,IAAMS,IAAQtB,EAAO,YAAYiB,GAAWF,GAAUF,EAAG,KAAKO,CAAM;EACpE,KAAK,IAAM,CAACjB,GAAKoB,MAASD,GAExB,AADAhB,EAAWH,GAAKoB,CAAI,GACfzB,EAAW,IAAI0B,EAASrB,CAAG,CAAC,KAAGO,EAAW,IAAIc,EAASrB,CAAG,GAAGoB,CAAI;EAExE,EAAWV,EAAG,IAAI,IAAIS,EAAM,IAAIT,EAAG,IAAI,EAAE,KAAKO,EAAO,IAAI;CAC3D;CACA,OAAO;EAAE;EAAY;CAAW;AAClC;AAGA,SAASK,EACP,GAAsB,GAAkC,GAClC;CACtB,IAAM,EAAE,UAAO,OAAI,YAAYrC,MAAMM,GAC/BC,IAAcC,EAAiBC,CAAK,GAIpC4B,oBAAe,IAAI,IAAqB,GACxCC,IAAYhC,EAAQ;CAC1B,IAAI,CAACgC,GAAW,OAAOD;CACvB,KAAK,IAAM,CAACE,GAAOC,MAAY1C,EAAuBG,EAAQ,KAAK,OAAO;EACxE,IAAIU,EAAE;EACN,mBAAmBA,EAAE,IAAI;CAC3B,EAAE,GAAG8B,CAAM,GAAG;EACZ,IAAMC,IAAYJ,EAAU,UAAUC,CAAK,GACrCI,IAAUlC,EAAM,IAAI2B,EAASG,CAAK,CAAC;EACzC,IAAI,CAACG,KAAa,CAACC,GAAS;EAC5B,IAAMC,IAAgC;GACpC,IAAIL;GACJ,QAAQvC,EAAE,UAAUgB,EAAiBT,GAAagC,GAAOtB,EAAG,OAAO,CAAC;EACtE,GACM4B,IAAsCpC,EAAM,WAAW2B,EAASG,CAAK,CAAC,CAAC,CAC1E,QAAQ,MAAQ,CAACC,EAAQ,IAAIzB,CAAG,CAAC,CAAC,CAClC,KAAK,OAAS;GACb,IAAIA;GACJ,MAAMC,EAAiBT,GAAaQ,GAAeE,EAAG,OAAO;EAC/D,EAAE;EACJ,KAAK,IAAM,CAACF,GAAKoB,MAASO,EAAU,WAAWE,GAAcC,CAAW,GAAG;GACzE,IAAMC,IAAM9C,EAAE,UAAUgB,EAAiBT,GAAaQ,GAAKE,EAAG,OAAO,CAAC,GAChE8B,IAAO/C,EAAE,UAAUmC,CAAI;GAG7B,CAFaW,EAAI,MAAMC,EAAK,KAAKD,EAAI,MAAMC,EAAK,KAC3CD,EAAI,UAAUC,EAAK,SAASD,EAAI,WAAWC,EAAK,WAErDV,EAAa,IAAItB,GAAKoB,CAAI;EAC5B;CACF;CACA,OAAOE;AACT;AAGA,SAAgBW,EACd,GACA,GACA,GACiB;CACjB,IAAI,CAAC1C,EAAQ,QAAQ,OAAO;CAC5B,IAAM,EAAE,UAAO,UAAOA,GAChBC,IAAcC,EAAiBC,CAAK,GACpCR,IAAUgD,EAAc3C,GAAS4C,CAAK;CAC5C,IAAIjD,EAAQ,WAAW,GAAG,OAAO;CACjC,IAAMkD,IAAaC,EAAgB9C,GAASL,CAAO,GAI7C8B,IAAc;EAClB,GAAGsB,EAAQ,IAAIF,EAAW;EAC1B,GAAGE,EAAQ,IAAIF,EAAW;CAC5B,GAEMtC,IAAOyC,EAAchD,GAASL,GAASkD,CAAU;CACvD,IAAI,CAACtC,GAAM,OAAO;EAAE;EAAY,MAAM;EAAM,wBAAQ,IAAI,IAAI;CAAE;CAE9D,IAAMgB,IAA6B;EAAE,IAAIhB,EAAK;EAAc,QAAQA,EAAK;CAAO,GAC1E0C,IAASlD,EAASC,GAASO,GAAMgB,GAAW5B,GAAS8B,CAAW;CACtE,IAAI,CAACwB,GAAQ,OAAO;EAAE;EAAY,MAAM;EAAM,wBAAQ,IAAI,IAAI;CAAE;CAKhE,IAAMC,oBAAS,IAAI,IAAqB,GAClCC,oBAAY,IAAI,IAAY;CAClC,KAAK,IAAM,CAAC1C,GAAKoB,MAASoB,EAAO,YAAY;EAC3C,IAAMG,IAASjD,EAAM,IAAIM,CAAG,CAAC,EAAE,UAAU;EAEzC,AADAyC,EAAO,IAAIzC,GAAK4C,EAAgBpD,GAAa4B,GAAMuB,GAAQzC,EAAG,SAASA,EAAG,SAAS,CAAC,GACpFwC,EAAU,IAAI1C,CAAG;CACnB;CAEA,IAAM6C,IAAYvB,EAAa/B,GAASL,GAAS4B,EAAU,EAAE;CAC7D,KAAK,IAAM,CAACd,GAAKoB,MAASyB,GAAW;EACnC,IAAMF,IAASjD,EAAM,IAAI2B,EAASrB,CAAG,CAAC,CAAC,EAAE,UAAU;EAEnD,AADAyC,EAAO,IAAIpB,EAASrB,CAAG,GAAG4C,EAAgBpD,GAAa4B,GAAMuB,GAAQzC,EAAG,SAASA,EAAG,SAAS,CAAC,GAC9FwC,EAAU,IAAIrB,EAASrB,CAAG,CAAC;CAC7B;CAEA,OAAO;EACL;EACA,MAAM;GAAE,QAAQF,EAAK;GAAQ;GAAW,YAAY0C,EAAO;GAAY,cAAcK;GAAW;EAAU;EAC1G;CACF;AACF"}

package/dist/interactions/actions/move/layout/exits.js

@@ -0,0 +1,38 @@
+import { toPlane as e } from "../../../../core/viewport/parallax.js";
+import { composeWorldPose as t } from "../../../../core/scene/composeFrame.js";
+import { poseDescriptorForNode as n } from "../../../../core/geometry/poseDescriptor.js";
+import { planeOf as r } from "../../planeInput.js";
+import { scenePoseAdapter as i } from "../../../../core/scene/scenePoseAdapter.js";
+import { pointInBounds as a } from "./container.js";
+//#region src/interactions/actions/move/layout/exits.ts
+function o(o, s, c) {
+	let l = /* @__PURE__ */ new Map(), u = o.layout, d = s;
+	if (!u || !d) return l;
+	let { scene: f, pc: p, projection: m } = o, h = i(f), g = /* @__PURE__ */ new Set([...o.ids, ...o.cascadeIds]), _ = (i, s) => {
+		let c = f.get(i), l = r(o.view, c.layer), u = l ? e(l, d) : d, g = t(h, i, p.compose);
+		if (s?.contains) return s.contains(g, u);
+		let _ = n(m, c).getBounds(g);
+		return a(_, u);
+	}, v = /* @__PURE__ */ new Map(), y = (e) => {
+		if (v.has(e)) return v.get(e);
+		let t = null, n = -1, r = (i, a) => {
+			for (let o of i === null ? f.roots : f.childrenOf(i)) {
+				if (g.has(o)) continue;
+				let i = f.get(o);
+				i && i.kind === "container" && (i.layer === e && a >= n && u.getLayout(o) === null && _(o, null) && (t = o, n = a), r(o, a + 1));
+			}
+		};
+		return r(null, 0), v.set(e, t), t;
+	};
+	for (let e of c) {
+		let t = f.get(e), n = t?.parent ?? null;
+		if (!t || n === null) continue;
+		let r = u.getLayout(n);
+		r && !_(n, r) && l.set(e, y(t.layer));
+	}
+	return l;
+}
+//#endregion
+export { o as resolveLayoutExits };
+
+//# sourceMappingURL=exits.js.map

package/dist/interactions/actions/move/layout/exits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exits.js","names":["resolveLayoutExits","out","layoutDep","session","center","dropCenter","d","poseAdapter","scenePoseAdapter","scene","excluded","holds","node","id","plane","planeOf","at","toPlane","pose","composeWorldPose","pc","layout","b","poseDescriptorForNode","pointInBounds","landings","landingOn","layer","best","bestDepth","walk","parentId","depth","ids","parent"],"sources":["../../../../../src/interactions/actions/move/layout/exits.ts"],"sourcesContent":["import type { NodeId } from 'core/scene/types';\nimport { poseDescriptorForNode } from 'core/geometry/poseDescriptor';\nimport { toPlane } from 'core/viewport/parallax';\nimport { composeWorldPose } from 'core/scene/composePose';\nimport { scenePoseAdapter } from 'core/scene/scenePoseAdapter';\nimport type { LayoutStrategy } from '../../../../layout/types';\nimport { planeOf } from '../../planeInput';\nimport type { MoveSession } from '../session';\nimport { pointInBounds } from './container';\n\n/** Where each dragged root that leaves its layout container on release lands.\n *  A root leaves when the drop center falls outside the body of the layout\n *  container holding it, and lands under the innermost plain container beneath\n *  the drop — a layout container there has already declined it — or at the top\n *  level of its layer. A root whose parent has no layout is not this pass's to\n *  move; `reparentOnDrop` decides for those. */\nexport function resolveLayoutExits(\n  session: MoveSession, dropCenter: { x: number; y: number } | null, ids: Iterable<NodeId>,\n): Map<NodeId, NodeId | null> {\n  const out = new Map<NodeId, NodeId | null>();\n  const layoutDep = session.layout;\n  const center = dropCenter;\n  if (!layoutDep || !center) return out;\n  const { scene, pc, projection: d } = session;\n  const poseAdapter = scenePoseAdapter(scene);\n  const excluded = new Set<NodeId>([...session.ids, ...session.cascadeIds]);\n  const holds = (id: NodeId, layout: LayoutStrategy<unknown> | null): boolean => {\n    const node = scene.get(id)!;\n    const plane = planeOf(session.view, node.layer);\n    const at = plane ? toPlane(plane, center) : center;\n    const pose = composeWorldPose(poseAdapter, id as string, pc.compose);\n    if (layout?.contains) return layout.contains(pose, at);\n    const b = poseDescriptorForNode(d, node).getBounds(pose);\n    return pointInBounds(b, at);\n  };\n  const landings = new Map<string, NodeId | null>();\n  const landingOn = (layer: string): NodeId | null => {\n    if (landings.has(layer)) return landings.get(layer)!;\n    // Deepest wins; among equals, the later sibling (painted over the other).\n    let best: NodeId | null = null;\n    let bestDepth = -1;\n    const walk = (parentId: NodeId | null, depth: number): void => {\n      for (const id of parentId === null ? scene.roots : scene.childrenOf(parentId)) {\n        if (excluded.has(id)) continue;\n        const node = scene.get(id);\n        if (!node || node.kind !== 'container') continue;\n        if (node.layer === layer && depth >= bestDepth\n          && layoutDep.getLayout(id as string) === null && holds(id, null)) {\n          best = id;\n          bestDepth = depth;\n        }\n        walk(id, depth + 1);\n      }\n    };\n    walk(null, 0);\n    landings.set(layer, best);\n    return best;\n  };\n  for (const id of ids) {\n    const node = scene.get(id);\n    const parent = node?.parent ?? null;\n    if (!node || parent === null) continue;\n    const layout = layoutDep.getLayout(parent as string);\n    if (!layout || holds(parent, layout)) continue;\n    out.set(id, landingOn(node.layer));\n  }\n  return out;\n}\n"],"mappings":";;;;;;;AAgBA,SAAgBA,EACd,GAAsB,GAA6C,GACvC;CAC5B,IAAMC,oBAAM,IAAI,IAA2B,GACrCC,IAAYC,EAAQ,QACpBC,IAASC;CACf,IAAI,CAACH,KAAa,CAACE,GAAQ,OAAOH;CAClC,IAAM,EAAE,UAAO,OAAI,YAAYK,MAAMH,GAC/BI,IAAcC,EAAiBC,CAAK,GACpCC,oBAAW,IAAI,IAAY,CAAC,GAAGP,EAAQ,KAAK,GAAGA,EAAQ,UAAU,CAAC,GAClEQ,KAAS,GAAY,MAAoD;EAC7E,IAAMC,IAAOH,EAAM,IAAII,CAAE,GACnBC,IAAQC,EAAQZ,EAAQ,MAAMS,EAAK,KAAK,GACxCI,IAAKF,IAAQG,EAAQH,GAAOV,CAAM,IAAIA,GACtCc,IAAOC,EAAiBZ,GAAaM,GAAcO,EAAG,OAAO;EACnE,IAAIC,GAAQ,UAAU,OAAOA,EAAO,SAASH,GAAMF,CAAE;EACrD,IAAMM,IAAIC,EAAsBjB,GAAGM,CAAI,CAAC,CAAC,UAAUM,CAAI;EACvD,OAAOM,EAAcF,GAAGN,CAAE;CAC5B,GACMS,oBAAW,IAAI,IAA2B,GAC1CC,KAAa,MAAiC;EAClD,IAAID,EAAS,IAAIE,CAAK,GAAG,OAAOF,EAAS,IAAIE,CAAK;EAElD,IAAIC,IAAsB,MACtBC,IAAY,IACVC,KAAQ,GAAyB,MAAwB;GAC7D,KAAK,IAAMjB,KAAMkB,MAAa,OAAOtB,EAAM,QAAQA,EAAM,WAAWsB,CAAQ,GAAG;IAC7E,IAAIrB,EAAS,IAAIG,CAAE,GAAG;IACtB,IAAMD,IAAOH,EAAM,IAAII,CAAE;IACzB,AAAKD,KAAQA,EAAK,SAAS,gBACvBA,EAAK,UAAUe,KAASK,KAASH,KAChC3B,EAAU,UAAUW,CAAY,MAAM,QAAQF,EAAME,GAAI,IAAI,MAC/D,IAAOA,GACP,IAAYmB,IAEdF,EAAKjB,GAAImB,IAAQ,CAAC;GACpB;EACF;EAGA,OAFAF,EAAK,MAAM,CAAC,GACZL,EAAS,IAAIE,GAAOC,CAAI,GACjBA;CACT;CACA,KAAK,IAAMf,KAAMoB,GAAK;EACpB,IAAMrB,IAAOH,EAAM,IAAII,CAAE,GACnBqB,IAAStB,GAAM,UAAU;EAC/B,IAAI,CAACA,KAAQsB,MAAW,MAAM;EAC9B,IAAMb,IAASnB,EAAU,UAAUgC,CAAgB;EACnD,AAAKb,KAAU,GAAMa,GAAQb,CAAM,KACnCpB,EAAI,IAAIY,GAAIa,EAAUd,EAAK,KAAK,CAAC;CACnC;CACA,OAAOX;AACT"}

package/dist/interactions/actions/move/layout/glide.js

@@ -0,0 +1,48 @@
+import { composeWorldPose as e, frameAtOrAbove as t, rebaseLocalPose as n } from "../../../../core/scene/composeFrame.js";
+import { documentPose as r } from "../../../../core/scene/effectivePose.js";
+import { scenePoseAdapter as i } from "../../../../core/scene/scenePoseAdapter.js";
+//#region src/interactions/actions/move/layout/glide.ts
+function a(e, t, n, i) {
+	let a = t?.poseOf(i);
+	if (!t || a === void 0) return null;
+	t.glide(i, a, { from: a });
+	let o = n.getBounds(a), s = n.getBounds(r(e, e.get(i)));
+	return {
+		dx: o.x - s.x,
+		dy: o.y - s.y
+	};
+}
+function o(e, t, n) {
+	for (let [r, i] of n) e.glide(r, i), t.add(r);
+	for (let r of t) n.has(r) || (e.settle(r), t.delete(r));
+}
+function s(n, r) {
+	let a = /* @__PURE__ */ new Map(), { scene: o, pc: s } = n, c = i(o);
+	for (let i of n.startPoses.keys()) {
+		let n = r.get(i);
+		if (n === void 0) continue;
+		let l = o.get(i)?.parent ?? null, u = t(c, l), d = u === null ? n : s.compose(e(c, u, s.compose), n);
+		a.set(i, {
+			local: n,
+			parent: l,
+			world: d
+		});
+	}
+	return a;
+}
+function c(e, t, r) {
+	let { scene: a, pc: o } = e, s = i(a);
+	for (let i of e.startPoses.keys()) {
+		let c = r.get(i);
+		if (!c) {
+			e.caught.has(i) && t.settle(i);
+			continue;
+		}
+		let l = a.get(i)?.parent ?? null, u = l === c.parent ? c.local : n(s, c.world, l, o.compose, o.decompose);
+		t.settle(i, { from: u });
+	}
+}
+//#endregion
+export { a as catchGliding, c as landReleased, s as releasedPoses, o as stepGlide };
+
+//# sourceMappingURL=glide.js.map

package/dist/interactions/actions/move/layout/glide.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glide.js","names":["catchGliding","shown","reflow","id","at","projection","home","documentPose","scene","stepGlide","pose","targets","gliding","releasedPoses","out","session","adapter","scenePoseAdapter","local","previews","parent","frame","frameAtOrAbove","world","pc","composeWorldPose","landReleased","r","released","from","rebaseLocalPose"],"sources":["../../../../../src/interactions/actions/move/layout/glide.ts"],"sourcesContent":["import type { NodeId, Scene } from 'core/scene/types';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { documentPose } from 'core/scene/effectivePose';\nimport { composeWorldPose, frameAtOrAbove, rebaseLocalPose } from 'core/scene/composePose';\nimport { scenePoseAdapter } from 'core/scene/scenePoseAdapter';\nimport type { ReflowTransition } from '../../../../layout/types';\nimport type { MoveSession } from '../session';\n\n/** Hold a node still gliding from an earlier reflow where it is shown. Returns\n *  how far that stands from its document pose, or null when it is not gliding. */\nexport function catchGliding(\n  scene: Scene<unknown, string, unknown>,\n  reflow: ReflowTransition | null,\n  projection: PoseDescriptor<unknown>,\n  id: NodeId,\n): { dx: number; dy: number } | null {\n  const shown = reflow?.poseOf(id as string);\n  if (!reflow || shown === undefined) return null;\n  reflow.glide(id as string, shown, { from: shown });\n  const at = projection.getBounds(shown);\n  const home = projection.getBounds(documentPose(scene, scene.get(id)!));\n  return { dx: at.x - home.x, dy: at.y - home.y };\n}\n\n/** Send this frame's reflow targets gliding and settle what stopped reflowing. */\nexport function stepGlide(reflow: ReflowTransition, gliding: Set<NodeId>, targets: ReadonlyMap<NodeId, unknown>): void {\n  for (const [id, pose] of targets) {\n    reflow.glide(id as string, pose);\n    gliding.add(id);\n  }\n  for (const id of gliding) {\n    if (targets.has(id)) continue;\n    reflow.settle(id as string);\n    gliding.delete(id);\n  }\n}\n\n/** Where a dragged id was shown when the gesture ended: its stored pose then,\n *  the parent that pose was stored under, and the same pose in world. */\nexport interface Released {\n  local: unknown;\n  parent: NodeId | null;\n  world: unknown;\n}\n\nexport function releasedPoses(session: MoveSession, previews: ReadonlyMap<NodeId, unknown>): Map<NodeId, Released> {\n  const out = new Map<NodeId, Released>();\n  const { scene, pc } = session;\n  const adapter = scenePoseAdapter(scene);\n  for (const id of session.startPoses.keys()) {\n    const local = previews.get(id);\n    if (local === undefined) continue;\n    const parent = scene.get(id)?.parent ?? null;\n    const frame = frameAtOrAbove(adapter, parent);\n    const world = frame === null ? local : pc.compose(composeWorldPose(adapter, frame, pc.compose), local);\n    out.set(id, { local, parent, world });\n  }\n  return out;\n}\n\n/** Hand every dragged id to the reflow transition to glide from where it was\n *  let go onto the pose the document now holds. An id caught mid-glide that\n *  never moved resumes settling from where it was held. */\nexport function landReleased(\n  session: MoveSession,\n  reflow: ReflowTransition,\n  released: Map<NodeId, Released>,\n): void {\n  const { scene, pc } = session;\n  const adapter = scenePoseAdapter(scene);\n  for (const id of session.startPoses.keys()) {\n    const r = released.get(id);\n    if (!r) {\n      if (session.caught.has(id)) reflow.settle(id as string);\n      continue;\n    }\n    const parent = scene.get(id)?.parent ?? null;\n    const from = parent === r.parent\n      ? r.local\n      : rebaseLocalPose(adapter, r.world, parent, pc.compose, pc.decompose);\n    reflow.settle(id as string, { from });\n  }\n}\n"],"mappings":";;;;AAUA,SAAgBA,EACd,GACA,GACA,GACA,GACmC;CACnC,IAAMC,IAAQC,GAAQ,OAAOC,CAAY;CACzC,IAAI,CAACD,KAAUD,MAAU,KAAA,GAAW,OAAO;CAC3C,EAAO,MAAME,GAAcF,GAAO,EAAE,MAAMA,EAAM,CAAC;CACjD,IAAMG,IAAKC,EAAW,UAAUJ,CAAK,GAC/BK,IAAOD,EAAW,UAAUE,EAAaC,GAAOA,EAAM,IAAIL,CAAE,CAAE,CAAC;CACrE,OAAO;EAAE,IAAIC,EAAG,IAAIE,EAAK;EAAG,IAAIF,EAAG,IAAIE,EAAK;CAAE;AAChD;AAGA,SAAgBG,EAAU,GAA0B,GAAsB,GAA6C;CACrH,KAAK,IAAM,CAACN,GAAIO,MAASC,GAEvB,AADAT,EAAO,MAAMC,GAAcO,CAAI,GAC/BE,EAAQ,IAAIT,CAAE;CAEhB,KAAK,IAAMA,KAAMS,GACf,AAAID,EAAQ,IAAIR,CAAE,MAClBD,EAAO,OAAOC,CAAY,GAC1BS,EAAQ,OAAOT,CAAE;AAErB;AAUA,SAAgBU,EAAc,GAAsB,GAA+D;CACjH,IAAMC,oBAAM,IAAI,IAAsB,GAChC,EAAE,UAAO,UAAOC,GAChBC,IAAUC,EAAiBT,CAAK;CACtC,KAAK,IAAML,KAAMY,EAAQ,WAAW,KAAK,GAAG;EAC1C,IAAMG,IAAQC,EAAS,IAAIhB,CAAE;EAC7B,IAAIe,MAAU,KAAA,GAAW;EACzB,IAAME,IAASZ,EAAM,IAAIL,CAAE,CAAC,EAAE,UAAU,MAClCkB,IAAQC,EAAeN,GAASI,CAAM,GACtCG,IAAQF,MAAU,OAAOH,IAAQM,EAAG,QAAQC,EAAiBT,GAASK,GAAOG,EAAG,OAAO,GAAGN,CAAK;EACrG,EAAI,IAAIf,GAAI;GAAE;GAAO;GAAQ;EAAM,CAAC;CACtC;CACA,OAAOW;AACT;AAKA,SAAgBY,EACd,GACA,GACA,GACM;CACN,IAAM,EAAE,UAAO,UAAOX,GAChBC,IAAUC,EAAiBT,CAAK;CACtC,KAAK,IAAML,KAAMY,EAAQ,WAAW,KAAK,GAAG;EAC1C,IAAMY,IAAIC,EAAS,IAAIzB,CAAE;EACzB,IAAI,CAACwB,GAAG;GACN,AAAIZ,EAAQ,OAAO,IAAIZ,CAAE,KAAGD,EAAO,OAAOC,CAAY;GACtD;EACF;EACA,IAAMiB,IAASZ,EAAM,IAAIL,CAAE,CAAC,EAAE,UAAU,MAClC0B,IAAOT,MAAWO,EAAE,SACtBA,EAAE,QACFG,EAAgBd,GAASW,EAAE,OAAOP,GAAQI,EAAG,SAASA,EAAG,SAAS;EACtE,EAAO,OAAOrB,GAAc,EAAE,QAAK,CAAC;CACtC;AACF"}