@weasel-js/core 1.12.0 → 1.13.0

package/dist/core/scene/nodeFnFields.js

@@ -4,35 +4,30 @@ var NODE_FN_FIELDS = [
 		field: "clipFromPose",
 		opKey: "clipKey",
 		jsonKey: "clipFromPoseKey",
-		containersOnly: true,
 		lost: "clip"
 	},
 	{
 		field: "copiesFromPose",
 		opKey: "copiesKey",
 		jsonKey: "copiesFromPoseKey",
-		containersOnly: true,
 		lost: "copies"
 	},
 	{
 		field: "derivePath",
 		opKey: "derivePathKey",
 		jsonKey: "derivePathKey",
-		containersOnly: false,
 		lost: "derived path"
 	},
 	{
 		field: "derivePose",
 		opKey: "derivePoseKey",
 		jsonKey: "derivePoseKey",
-		containersOnly: false,
 		lost: "derived pose"
 	},
 	{
 		field: "layout",
 		opKey: "layoutKey",
 		jsonKey: "layoutKey",
-		containersOnly: true,
 		lost: "layout"
 	}
 ];
@@ -41,14 +36,12 @@ function createNodeFnFields(registry, onWrite) {
 		const table = registry[spec.field];
 		const reverse = /* @__PURE__ */ new Map();
 		if (table) for (const [key, fn] of Object.entries(table)) reverse.set(fn, key);
-		const applies = (node) => !spec.containersOnly || node.kind === "container";
 		return {
 			spec,
 			keyOf: (fn) => reverse.get(fn),
 			fnOf: (key) => table?.[key],
-			read: (node) => applies(node) ? node[spec.field] : void 0,
+			read: (node) => node[spec.field],
 			write: (node, fn) => {
-				if (!applies(node)) return;
 				node[spec.field] = fn;
 				onWrite?.(spec.field, node);
 			}
@@ -87,14 +80,13 @@ function fnKeysOf(fields, node, which, onUnregistered) {
 /**
 * The function fields to carry from a live node into an `AddNodeSpec`. An
 * insert that drops them brings an edge back as a static path that never
-* follows its endpoints again, and a clipped container back with nothing
+* follows its endpoints again, and a clipped group back with nothing
 * clipped.
 */
 function fnFieldsOfNode(node) {
 	const src = node;
 	const out = {};
 	for (const spec of NODE_FN_FIELDS) {
-		if (spec.containersOnly && node.kind !== "container") continue;
 		const fn = src[spec.field];
 		if (fn !== void 0) out[spec.field] = fn;
 	}

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

@@ -1 +1 @@
-{"version":3,"file":"nodeFnFields.js","names":[],"sources":["../../../src/core/scene/nodeFnFields.ts"],"sourcesContent":["/**\n * The registry-keyed function fields a node can carry, as a table.\n *\n * These fields are live functions on a node, and a function travels through\n * neither a serializable op payload nor a JSON snapshot. Each one therefore\n * needs the same things: a function→key reverse map, a name in the op\n * payload, a name in the snapshot, and a registry lookup on restore.\n */\nimport type { NodeId, SceneRegistry } from './types';\n\n/** A node's function field, opaque here: the table moves these around by\n *  reference and never calls one. A container's `layout` is an object rather\n *  than a function, and rides the same table for the same reason. */\nexport type NodeFn = ((...args: never[]) => unknown) | object;\n\n/** A node as this module reads it — a bag with the function fields on it. */\nexport type FnBearingNode = { id: NodeId; kind: 'leaf' | 'container' } & {\n  [K in NodeFnFieldName]?: NodeFn;\n};\n\nexport type NodeFnFieldName = 'clipFromPose' | 'copiesFromPose' | 'derivePath' | 'derivePose' | 'layout';\n\nexport interface NodeFnFieldSpec {\n  /** The field's name on `Node` — and, deliberately, its name in\n   *  `SceneRegistry` too, so one string indexes both. */\n  readonly field: NodeFnFieldName;\n  /** Its key in the `kit:add` and `kit:remove` op payloads. `clipFromPose`'s\n   *  is the short one because a persisted history already carries that name. */\n  readonly opKey: string;\n  /** Its key in a `SerializedNode`. */\n  readonly jsonKey: string;\n  /** True for a field only a `ContainerNode` can carry. */\n  readonly containersOnly: boolean;\n  /** What a node loses when its key is not in the registry, for the warning. */\n  readonly lost: string;\n}\n\nexport const NODE_FN_FIELDS: readonly NodeFnFieldSpec[] = [\n  {\n    field: 'clipFromPose',\n    opKey: 'clipKey',\n    jsonKey: 'clipFromPoseKey',\n    containersOnly: true,\n    lost: 'clip',\n  },\n  {\n    field: 'copiesFromPose',\n    opKey: 'copiesKey',\n    jsonKey: 'copiesFromPoseKey',\n    containersOnly: true,\n    lost: 'copies',\n  },\n  {\n    field: 'derivePath',\n    opKey: 'derivePathKey',\n    jsonKey: 'derivePathKey',\n    containersOnly: false,\n    lost: 'derived path',\n  },\n  {\n    field: 'derivePose',\n    opKey: 'derivePoseKey',\n    jsonKey: 'derivePoseKey',\n    containersOnly: false,\n    lost: 'derived pose',\n  },\n  {\n    field: 'layout',\n    opKey: 'layoutKey',\n    jsonKey: 'layoutKey',\n    containersOnly: true,\n    lost: 'layout',\n  },\n];\n\n/** One field's per-scene state. */\nexport interface NodeFnField {\n  readonly spec: NodeFnFieldSpec;\n  /** `fn → registry key`, for writing a payload or a snapshot. */\n  keyOf(fn: NodeFn): string | undefined;\n  /** `registry key → fn`, for restoring one. */\n  fnOf(key: string): NodeFn | undefined;\n  /** The function on `node`, or `undefined` — including when the field is\n   *  container-only and `node` is a leaf. */\n  read(node: FnBearingNode): NodeFn | undefined;\n  /** Attach `fn` to `node`, ignoring a container-only field on a leaf. */\n  write(node: FnBearingNode, fn: NodeFn): void;\n}\n\nexport function createNodeFnFields<TPose>(\n  registry: SceneRegistry<TPose>,\n  /** Called after a field is written onto a node it applies to. */\n  onWrite?: (field: NodeFnFieldName, node: FnBearingNode) => void,\n): readonly NodeFnField[] {\n  return NODE_FN_FIELDS.map((spec) => {\n    const table = registry[spec.field] as Readonly<Record<string, NodeFn>> | undefined;\n    const reverse = new Map<NodeFn, string>();\n    if (table) for (const [key, fn] of Object.entries(table)) reverse.set(fn, key);\n    const applies = (node: FnBearingNode): boolean =>\n      !spec.containersOnly || node.kind === 'container';\n    return {\n      spec,\n      keyOf: (fn) => reverse.get(fn),\n      fnOf: (key) => table?.[key],\n      read: (node) => (applies(node) ? node[spec.field] : undefined),\n      write: (node, fn) => {\n        if (!applies(node)) return;\n        node[spec.field] = fn;\n        onWrite?.(spec.field, node);\n      },\n    };\n  });\n}\n\n/**\n * Attach the function `key` names to `node`. Warns and leaves the field\n * unset when the key is not in this scene's registry — a snapshot outliving\n * the code that registered its functions must still load.\n */\nexport function restoreFn(\n  field: NodeFnField,\n  node: FnBearingNode,\n  key: string,\n  site: string,\n  warn: (channel: string, message: string) => void,\n): void {\n  const fn = field.fnOf(key);\n  if (fn === undefined) {\n    warn(\n      'scene',\n      `${site}: ${field.spec.opKey} \"${key}\" not in this scene's registry — node \"${node.id}\" ` +\n        `restored without its ${field.spec.lost}. Register a function with this key in the ` +\n        `registry option to restore it.`,\n    );\n    return;\n  }\n  field.write(node, fn);\n}\n\n/** The `{ clipKey?, derivePathKey?, … }` an op payload or a snapshot carries\n *  for `node`. Empty when the node has no keyed function on it. */\nexport function fnKeysOf(\n  fields: readonly NodeFnField[],\n  node: FnBearingNode,\n  which: 'opKey' | 'jsonKey',\n  onUnregistered?: (field: NodeFnField) => never,\n): Record<string, string> {\n  const out: Record<string, string> = {};\n  for (const field of fields) {\n    const fn = field.read(node);\n    if (fn === undefined) continue;\n    const key = field.keyOf(fn);\n    if (key === undefined) {\n      onUnregistered?.(field);\n      continue;\n    }\n    out[field.spec[which]] = key;\n  }\n  return out;\n}\n\n/**\n * The function fields to carry from a live node into an `AddNodeSpec`. An\n * insert that drops them brings an edge back as a static path that never\n * follows its endpoints again, and a clipped container back with nothing\n * clipped.\n */\nexport function fnFieldsOfNode<T extends { kind: 'leaf' | 'container' }>(\n  node: T,\n): Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>> {\n  const src = node as Record<string, unknown>;\n  const out: Record<string, unknown> = {};\n  for (const spec of NODE_FN_FIELDS) {\n    if (spec.containersOnly && node.kind !== 'container') continue;\n    const fn = src[spec.field];\n    if (fn !== undefined) out[spec.field] = fn;\n  }\n  return out as Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>>;\n}\n"],"mappings":";AAqCA,IAAa,iBAA6C;CACxD;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;AACF;AAgBA,SAAgB,mBACd,UAEA,SACwB;CACxB,OAAO,eAAe,KAAK,SAAS;EAClC,MAAM,QAAQ,SAAS,KAAK;EAC5B,MAAM,0BAAU,IAAI,IAAoB;EACxC,IAAI,OAAO,KAAK,MAAM,CAAC,KAAK,OAAO,OAAO,QAAQ,KAAK,GAAG,QAAQ,IAAI,IAAI,GAAG;EAC7E,MAAM,WAAW,SACf,CAAC,KAAK,kBAAkB,KAAK,SAAS;EACxC,OAAO;GACL;GACA,QAAQ,OAAO,QAAQ,IAAI,EAAE;GAC7B,OAAO,QAAQ,QAAQ;GACvB,OAAO,SAAU,QAAQ,IAAI,IAAI,KAAK,KAAK,SAAS;GACpD,QAAQ,MAAM,OAAO;IACnB,IAAI,CAAC,QAAQ,IAAI,GAAG;IACpB,KAAK,KAAK,SAAS;IACnB,UAAU,KAAK,OAAO,IAAI;GAC5B;EACF;CACF,CAAC;AACH;;;;;;AAOA,SAAgB,UACd,OACA,MACA,KACA,MACA,MACM;CACN,MAAM,KAAK,MAAM,KAAK,GAAG;CACzB,IAAI,OAAO,QAAW;EACpB,KACE,SACA,GAAG,KAAK,IAAI,MAAM,KAAK,MAAM,IAAI,IAAI,yCAAyC,KAAK,GAAG,yBAC5D,MAAM,KAAK,KAAK,0EAE5C;EACA;CACF;CACA,MAAM,MAAM,MAAM,EAAE;AACtB;;;AAIA,SAAgB,SACd,QACA,MACA,OACA,gBACwB;CACxB,MAAM,MAA8B,CAAC;CACrC,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,KAAK,MAAM,KAAK,IAAI;EAC1B,IAAI,OAAO,QAAW;EACtB,MAAM,MAAM,MAAM,MAAM,EAAE;EAC1B,IAAI,QAAQ,QAAW;GACrB,iBAAiB,KAAK;GACtB;EACF;EACA,IAAI,MAAM,KAAK,UAAU;CAC3B;CACA,OAAO;AACT;;;;;;;AAQA,SAAgB,eACd,MACqD;CACrD,MAAM,MAAM;CACZ,MAAM,MAA+B,CAAC;CACtC,KAAK,MAAM,QAAQ,gBAAgB;EACjC,IAAI,KAAK,kBAAkB,KAAK,SAAS,aAAa;EACtD,MAAM,KAAK,IAAI,KAAK;EACpB,IAAI,OAAO,QAAW,IAAI,KAAK,SAAS;CAC1C;CACA,OAAO;AACT"}
+{"version":3,"file":"nodeFnFields.js","names":[],"sources":["../../../src/core/scene/nodeFnFields.ts"],"sourcesContent":["/**\n * The registry-keyed function fields a node can carry, as a table.\n *\n * These fields are live functions on a node, and a function travels through\n * neither a serializable op payload nor a JSON snapshot. Each one therefore\n * needs the same things: a function→key reverse map, a name in the op\n * payload, a name in the snapshot, and a registry lookup on restore.\n */\nimport type { NodeId, SceneRegistry } from './types';\n\n/** A node's function field, opaque here: the table moves these around by\n *  reference and never calls one. A node's `layout` is an object rather\n *  than a function, and rides the same table for the same reason. */\nexport type NodeFn = ((...args: never[]) => unknown) | object;\n\n/** A node as this module reads it — a bag with the function fields on it. */\nexport type FnBearingNode = { id: NodeId; kind: 'mark' | 'group' } & {\n  [K in NodeFnFieldName]?: NodeFn;\n};\n\nexport type NodeFnFieldName = 'clipFromPose' | 'copiesFromPose' | 'derivePath' | 'derivePose' | 'layout';\n\nexport interface NodeFnFieldSpec {\n  /** The field's name on `Node` — and, deliberately, its name in\n   *  `SceneRegistry` too, so one string indexes both. */\n  readonly field: NodeFnFieldName;\n  /** Its key in the `kit:add` and `kit:remove` op payloads. `clipFromPose`'s\n   *  is the short one because a persisted history already carries that name. */\n  readonly opKey: string;\n  /** Its key in a `SerializedNode`. */\n  readonly jsonKey: string;\n  /** What a node loses when its key is not in the registry, for the warning. */\n  readonly lost: string;\n}\n\nexport const NODE_FN_FIELDS: readonly NodeFnFieldSpec[] = [\n  {\n    field: 'clipFromPose',\n    opKey: 'clipKey',\n    jsonKey: 'clipFromPoseKey',\n    lost: 'clip',\n  },\n  {\n    field: 'copiesFromPose',\n    opKey: 'copiesKey',\n    jsonKey: 'copiesFromPoseKey',\n    lost: 'copies',\n  },\n  {\n    field: 'derivePath',\n    opKey: 'derivePathKey',\n    jsonKey: 'derivePathKey',\n    lost: 'derived path',\n  },\n  {\n    field: 'derivePose',\n    opKey: 'derivePoseKey',\n    jsonKey: 'derivePoseKey',\n    lost: 'derived pose',\n  },\n  {\n    field: 'layout',\n    opKey: 'layoutKey',\n    jsonKey: 'layoutKey',\n    lost: 'layout',\n  },\n];\n\n/** One field's per-scene state. */\nexport interface NodeFnField {\n  readonly spec: NodeFnFieldSpec;\n  /** `fn → registry key`, for writing a payload or a snapshot. */\n  keyOf(fn: NodeFn): string | undefined;\n  /** `registry key → fn`, for restoring one. */\n  fnOf(key: string): NodeFn | undefined;\n  /** The function on `node`, or `undefined`. */\n  read(node: FnBearingNode): NodeFn | undefined;\n  /** Attach `fn` to `node`. */\n  write(node: FnBearingNode, fn: NodeFn): void;\n}\n\nexport function createNodeFnFields<TPose>(\n  registry: SceneRegistry<TPose>,\n  /** Called after a field is written onto a node it applies to. */\n  onWrite?: (field: NodeFnFieldName, node: FnBearingNode) => void,\n): readonly NodeFnField[] {\n  return NODE_FN_FIELDS.map((spec) => {\n    const table = registry[spec.field] as Readonly<Record<string, NodeFn>> | undefined;\n    const reverse = new Map<NodeFn, string>();\n    if (table) for (const [key, fn] of Object.entries(table)) reverse.set(fn, key);\n    return {\n      spec,\n      keyOf: (fn) => reverse.get(fn),\n      fnOf: (key) => table?.[key],\n      read: (node) => node[spec.field],\n      write: (node, fn) => {\n        node[spec.field] = fn;\n        onWrite?.(spec.field, node);\n      },\n    };\n  });\n}\n\n/**\n * Attach the function `key` names to `node`. Warns and leaves the field\n * unset when the key is not in this scene's registry — a snapshot outliving\n * the code that registered its functions must still load.\n */\nexport function restoreFn(\n  field: NodeFnField,\n  node: FnBearingNode,\n  key: string,\n  site: string,\n  warn: (channel: string, message: string) => void,\n): void {\n  const fn = field.fnOf(key);\n  if (fn === undefined) {\n    warn(\n      'scene',\n      `${site}: ${field.spec.opKey} \"${key}\" not in this scene's registry — node \"${node.id}\" ` +\n        `restored without its ${field.spec.lost}. Register a function with this key in the ` +\n        `registry option to restore it.`,\n    );\n    return;\n  }\n  field.write(node, fn);\n}\n\n/** The `{ clipKey?, derivePathKey?, … }` an op payload or a snapshot carries\n *  for `node`. Empty when the node has no keyed function on it. */\nexport function fnKeysOf(\n  fields: readonly NodeFnField[],\n  node: FnBearingNode,\n  which: 'opKey' | 'jsonKey',\n  onUnregistered?: (field: NodeFnField) => never,\n): Record<string, string> {\n  const out: Record<string, string> = {};\n  for (const field of fields) {\n    const fn = field.read(node);\n    if (fn === undefined) continue;\n    const key = field.keyOf(fn);\n    if (key === undefined) {\n      onUnregistered?.(field);\n      continue;\n    }\n    out[field.spec[which]] = key;\n  }\n  return out;\n}\n\n/**\n * The function fields to carry from a live node into an `AddNodeSpec`. An\n * insert that drops them brings an edge back as a static path that never\n * follows its endpoints again, and a clipped group back with nothing\n * clipped.\n */\nexport function fnFieldsOfNode<T extends { kind: 'mark' | 'group' }>(\n  node: T,\n): Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>> {\n  const src = node as Record<string, unknown>;\n  const out: Record<string, unknown> = {};\n  for (const spec of NODE_FN_FIELDS) {\n    const fn = src[spec.field];\n    if (fn !== undefined) out[spec.field] = fn;\n  }\n  return out as Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>>;\n}\n"],"mappings":";AAmCA,IAAa,iBAA6C;CACxD;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,MAAM;CACR;AACF;AAeA,SAAgB,mBACd,UAEA,SACwB;CACxB,OAAO,eAAe,KAAK,SAAS;EAClC,MAAM,QAAQ,SAAS,KAAK;EAC5B,MAAM,0BAAU,IAAI,IAAoB;EACxC,IAAI,OAAO,KAAK,MAAM,CAAC,KAAK,OAAO,OAAO,QAAQ,KAAK,GAAG,QAAQ,IAAI,IAAI,GAAG;EAC7E,OAAO;GACL;GACA,QAAQ,OAAO,QAAQ,IAAI,EAAE;GAC7B,OAAO,QAAQ,QAAQ;GACvB,OAAO,SAAS,KAAK,KAAK;GAC1B,QAAQ,MAAM,OAAO;IACnB,KAAK,KAAK,SAAS;IACnB,UAAU,KAAK,OAAO,IAAI;GAC5B;EACF;CACF,CAAC;AACH;;;;;;AAOA,SAAgB,UACd,OACA,MACA,KACA,MACA,MACM;CACN,MAAM,KAAK,MAAM,KAAK,GAAG;CACzB,IAAI,OAAO,QAAW;EACpB,KACE,SACA,GAAG,KAAK,IAAI,MAAM,KAAK,MAAM,IAAI,IAAI,yCAAyC,KAAK,GAAG,yBAC5D,MAAM,KAAK,KAAK,0EAE5C;EACA;CACF;CACA,MAAM,MAAM,MAAM,EAAE;AACtB;;;AAIA,SAAgB,SACd,QACA,MACA,OACA,gBACwB;CACxB,MAAM,MAA8B,CAAC;CACrC,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,KAAK,MAAM,KAAK,IAAI;EAC1B,IAAI,OAAO,QAAW;EACtB,MAAM,MAAM,MAAM,MAAM,EAAE;EAC1B,IAAI,QAAQ,QAAW;GACrB,iBAAiB,KAAK;GACtB;EACF;EACA,IAAI,MAAM,KAAK,UAAU;CAC3B;CACA,OAAO;AACT;;;;;;;AAQA,SAAgB,eACd,MACqD;CACrD,MAAM,MAAM;CACZ,MAAM,MAA+B,CAAC;CACtC,KAAK,MAAM,QAAQ,gBAAgB;EACjC,MAAM,KAAK,IAAI,KAAK;EACpB,IAAI,OAAO,QAAW,IAAI,KAAK,SAAS;CAC1C;CACA,OAAO;AACT"}

package/dist/core/scene/nodeMemo.js

@@ -86,6 +86,11 @@ function scopedNodeMemo(node, scope, pose, derive, also) {
 function bumpNodeMemoGeneration() {
 	generation++;
 }
+/** The generation {@link bumpNodeMemoGeneration} last moved to: a freshness
+*  key for a cache outside this memo that reads the same ambient state. */
+function nodeMemoGeneration() {
+	return generation;
+}
 /**
 * Drop the slots of `node` that were keyed on a pose, keeping the ones that
 * weren't.
@@ -110,5 +115,5 @@ function dropPoseKeyedMemoSlots(node) {
 }
 
 //#endregion
-export { bumpNodeMemoGeneration, createNodeMemoScope, dropPoseKeyedMemoSlots, nodeMemo };
+export { bumpNodeMemoGeneration, createNodeMemoScope, dropPoseKeyedMemoSlots, nodeMemo, nodeMemoGeneration };
 //# sourceMappingURL=nodeMemo.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"nodeMemo.js","names":[],"sources":["../../../src/core/scene/nodeMemo.ts"],"sourcesContent":["/**\n * `nodeMemo` — memoize anything derived from a node, keyed on the node's\n * identity plus the `pose` / `data` references the scene swaps on every edit.\n *\n * The scene mutates node objects in place but *replaces* `pose` and `data`\n * with new references, so those two references are an exact freshness signal.\n * The assumption it rests on: nobody mutates `node.data` (or `node.pose`) in\n * place without replacing the reference. A consumer who violates it sees a\n * stale derivation until the next real edit.\n *\n * **What the key does not cover** is ambient state that `derive` reads — a\n * registry, a font set, a decode cache. Whoever owns the ambient state calls\n * {@link bumpNodeMemoGeneration}. Derivations that read ambient state with\n * *no* such signal (an async image decode landing, say) must not be memoized\n * here at all.\n */\n\n/** One memoized derivation: the references it was derived against, plus the\n *  value. Presence in the slot map is what \"computed\" means — a `null` or\n *  `undefined` value is a real answer and stays cached. */\ninterface MemoSlot {\n  /** Reference-compared against the caller's `pose` argument. */\n  pose: unknown;\n  /** Reference-compared against `node.data` at call time. */\n  data: unknown;\n  /** Reference-compared against the caller's `also` argument. */\n  also: unknown;\n  value: unknown;\n}\n\ninterface NodeMemoRecord {\n  /** `generation` at the time the slots were filled. */\n  generation: number;\n  slots: Map<string, MemoSlot>;\n  /** How many times {@link dropPoseKeyedMemoSlots} has run for this node,\n   *  which is how a drop reaches the scopes it cannot enumerate. */\n  drops: number;\n}\n\n/** A scoped entry also carries what a named slot's record holds for it. */\ninterface ScopedSlot extends MemoSlot {\n  generation: number;\n  drops: number;\n}\n\ndeclare const scopeBrand: unique symbol;\n\n/**\n * A private place to memoize one derivation, in place of a slot name.\n *\n * A named slot lives on the node, so it lasts as long as the node does. That\n * is wrong for a derivation that belongs to some shorter-lived reader — one\n * `toPose` function among many over the life of a scene. A scope is held by\n * that reader, and its entries go when the reader does.\n */\nexport type NodeMemoScope = { readonly [scopeBrand]: true };\n\nexport function createNodeMemoScope(): NodeMemoScope {\n  return new WeakMap<object, ScopedSlot>() as unknown as NodeMemoScope;\n}\n\nconst MEMO = new WeakMap<object, NodeMemoRecord>();\n\n/** Bumped whenever ambient state a derivation reads has changed. Entries\n *  stamped with an older value are dropped rather than served stale. */\nlet generation = 0;\n\n/** A node, as far as the memo is concerned: an object identity that may carry\n *  a `data` reference. */\ntype MemoizableNode = { data?: unknown };\n\n/**\n * Return the value `derive` produces for `node`, recomputing only when the\n * node's `data` reference, the given `pose` reference, the `also` reference,\n * or the global generation has changed since the last call for this `slot`.\n *\n * `slot` names the derivation, so a node's several derived values do not\n * overwrite each other.\n *\n * `pose` is a **parameter rather than a read off the node**, because callers\n * legitimately derive against a pose that isn't `node.pose`: a preview or\n * ghost pose mid-drag. Pass `undefined` for derivations that don't depend on\n * the pose at all, leaving `data` as the only key.\n *\n * `also` is for an input that lives outside the node, such as the paint a\n * node inherits from its container. It must be a reference its owner keeps\n * while the input is unchanged.\n */\nexport function nodeMemo<T>(\n  node: MemoizableNode,\n  slot: string | NodeMemoScope,\n  pose: unknown,\n  derive: () => T,\n  also?: unknown,\n): T {\n  if (typeof slot !== 'string') return scopedNodeMemo(node, slot, pose, derive, also);\n  let record = MEMO.get(node);\n  if (record === undefined) {\n    record = { generation, slots: new Map(), drops: 0 };\n    MEMO.set(node, record);\n  } else if (record.generation !== generation) {\n    record.generation = generation;\n    record.slots.clear();\n  }\n\n  const data = node.data;\n  const hit = record.slots.get(slot);\n  if (hit !== undefined && hit.pose === pose && hit.data === data && hit.also === also) {\n    return hit.value as T;\n  }\n\n  const value = derive();\n  // Reuse the slot object when there is one: this runs per node per frame, and\n  // the entry churn is the only allocation the memo would otherwise add.\n  if (hit !== undefined) {\n    hit.pose = pose;\n    hit.data = data;\n    hit.also = also;\n    hit.value = value;\n  } else {\n    record.slots.set(slot, { pose, data, also, value });\n  }\n  return value;\n}\n\nfunction scopedNodeMemo<T>(\n  node: MemoizableNode,\n  scope: NodeMemoScope,\n  pose: unknown,\n  derive: () => T,\n  also: unknown,\n): T {\n  const entries = scope as unknown as WeakMap<object, ScopedSlot>;\n  const data = node.data;\n  const drops = MEMO.get(node)?.drops ?? 0;\n  const hit = entries.get(node);\n  if (\n    hit !== undefined && hit.generation === generation && hit.pose === pose && hit.data === data\n    && hit.also === also    && (pose === undefined || hit.drops === drops)\n  ) {\n    return hit.value as T;\n  }\n  const value = derive();\n  // Read again: a derivation that hit a cycle drops this node's slots itself.\n  const dropsNow = MEMO.get(node)?.drops ?? 0;\n  if (hit !== undefined) {\n    hit.pose = pose;\n    hit.data = data;\n    hit.also = also;\n    hit.value = value;\n    hit.generation = generation;\n    hit.drops = dropsNow;\n  } else {\n    entries.set(node, { pose, data, also, value, generation, drops: dropsNow });\n  }\n  return value;\n}\n\n/** How many named slots `node` holds. For tests of what is kept on a node. */\nexport function nodeMemoSlotCount(node: MemoizableNode): number {\n  const record = MEMO.get(node);\n  return record === undefined || record.generation !== generation ? 0 : record.slots.size;\n}\n\n/**\n * Drop every memoized slot on every node. For owners of ambient state that\n * changes what a `derive` would return. Cheap — it bumps a counter.\n */\nexport function bumpNodeMemoGeneration(): void {\n  generation++;\n}\n\n/**\n * Drop the slots of `node` that were keyed on a pose, keeping the ones that\n * weren't.\n *\n * For per-frame pose overrides, which mutate one buffer in place rather than\n * replacing the reference, which the `(pose, data)` key cannot see.\n * {@link bumpNodeMemoGeneration} is the wrong tool there — it would drop every\n * static node's slots too, every frame.\n */\nexport function dropPoseKeyedMemoSlots(node: MemoizableNode): void {\n  const record = MEMO.get(node);\n  if (record === undefined) {\n    MEMO.set(node, { generation, slots: new Map(), drops: 1 });\n    return;\n  }\n  record.drops++;\n  for (const [slot, entry] of record.slots) {\n    if (entry.pose !== undefined) record.slots.delete(slot);\n  }\n}\n"],"mappings":";AAyDA,SAAgB,sBAAqC;CACnD,uBAAO,IAAI,QAA4B;AACzC;AAEA,IAAM,uBAAO,IAAI,QAAgC;;;AAIjD,IAAI,aAAa;;;;;;;;;;;;;;;;;;AAuBjB,SAAgB,SACd,MACA,MACA,MACA,QACA,MACG;CACH,IAAI,OAAO,SAAS,UAAU,OAAO,eAAe,MAAM,MAAM,MAAM,QAAQ,IAAI;CAClF,IAAI,SAAS,KAAK,IAAI,IAAI;CAC1B,IAAI,WAAW,QAAW;EACxB,SAAS;GAAE;GAAY,uBAAO,IAAI,IAAI;GAAG,OAAO;EAAE;EAClD,KAAK,IAAI,MAAM,MAAM;CACvB,OAAO,IAAI,OAAO,eAAe,YAAY;EAC3C,OAAO,aAAa;EACpB,OAAO,MAAM,MAAM;CACrB;CAEA,MAAM,OAAO,KAAK;CAClB,MAAM,MAAM,OAAO,MAAM,IAAI,IAAI;CACjC,IAAI,QAAQ,UAAa,IAAI,SAAS,QAAQ,IAAI,SAAS,QAAQ,IAAI,SAAS,MAC9E,OAAO,IAAI;CAGb,MAAM,QAAQ,OAAO;CAGrB,IAAI,QAAQ,QAAW;EACrB,IAAI,OAAO;EACX,IAAI,OAAO;EACX,IAAI,OAAO;EACX,IAAI,QAAQ;CACd,OACE,OAAO,MAAM,IAAI,MAAM;EAAE;EAAM;EAAM;EAAM;CAAM,CAAC;CAEpD,OAAO;AACT;AAEA,SAAS,eACP,MACA,OACA,MACA,QACA,MACG;CACH,MAAM,UAAU;CAChB,MAAM,OAAO,KAAK;CAClB,MAAM,QAAQ,KAAK,IAAI,IAAI,CAAC,EAAE,SAAS;CACvC,MAAM,MAAM,QAAQ,IAAI,IAAI;CAC5B,IACE,QAAQ,UAAa,IAAI,eAAe,cAAc,IAAI,SAAS,QAAQ,IAAI,SAAS,QACrF,IAAI,SAAS,SAAY,SAAS,UAAa,IAAI,UAAU,QAEhE,OAAO,IAAI;CAEb,MAAM,QAAQ,OAAO;CAErB,MAAM,WAAW,KAAK,IAAI,IAAI,CAAC,EAAE,SAAS;CAC1C,IAAI,QAAQ,QAAW;EACrB,IAAI,OAAO;EACX,IAAI,OAAO;EACX,IAAI,OAAO;EACX,IAAI,QAAQ;EACZ,IAAI,aAAa;EACjB,IAAI,QAAQ;CACd,OACE,QAAQ,IAAI,MAAM;EAAE;EAAM;EAAM;EAAM;EAAO;EAAY,OAAO;CAAS,CAAC;CAE5E,OAAO;AACT;;;;;AAYA,SAAgB,yBAA+B;CAC7C;AACF;;;;;;;;;;AAWA,SAAgB,uBAAuB,MAA4B;CACjE,MAAM,SAAS,KAAK,IAAI,IAAI;CAC5B,IAAI,WAAW,QAAW;EACxB,KAAK,IAAI,MAAM;GAAE;GAAY,uBAAO,IAAI,IAAI;GAAG,OAAO;EAAE,CAAC;EACzD;CACF;CACA,OAAO;CACP,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,OACjC,IAAI,MAAM,SAAS,QAAW,OAAO,MAAM,OAAO,IAAI;AAE1D"}
+{"version":3,"file":"nodeMemo.js","names":[],"sources":["../../../src/core/scene/nodeMemo.ts"],"sourcesContent":["/**\n * `nodeMemo` — memoize anything derived from a node, keyed on the node's\n * identity plus the `pose` / `data` references the scene swaps on every edit.\n *\n * The scene mutates node objects in place but *replaces* `pose` and `data`\n * with new references, so those two references are an exact freshness signal.\n * The assumption it rests on: nobody mutates `node.data` (or `node.pose`) in\n * place without replacing the reference. A consumer who violates it sees a\n * stale derivation until the next real edit.\n *\n * **What the key does not cover** is ambient state that `derive` reads — a\n * registry, a font set, a decode cache. Whoever owns the ambient state calls\n * {@link bumpNodeMemoGeneration}. Derivations that read ambient state with\n * *no* such signal (an async image decode landing, say) must not be memoized\n * here at all.\n */\n\n/** One memoized derivation: the references it was derived against, plus the\n *  value. Presence in the slot map is what \"computed\" means — a `null` or\n *  `undefined` value is a real answer and stays cached. */\ninterface MemoSlot {\n  /** Reference-compared against the caller's `pose` argument. */\n  pose: unknown;\n  /** Reference-compared against `node.data` at call time. */\n  data: unknown;\n  /** Reference-compared against the caller's `also` argument. */\n  also: unknown;\n  value: unknown;\n}\n\ninterface NodeMemoRecord {\n  /** `generation` at the time the slots were filled. */\n  generation: number;\n  slots: Map<string, MemoSlot>;\n  /** How many times {@link dropPoseKeyedMemoSlots} has run for this node,\n   *  which is how a drop reaches the scopes it cannot enumerate. */\n  drops: number;\n}\n\n/** A scoped entry also carries what a named slot's record holds for it. */\ninterface ScopedSlot extends MemoSlot {\n  generation: number;\n  drops: number;\n}\n\ndeclare const scopeBrand: unique symbol;\n\n/**\n * A private place to memoize one derivation, in place of a slot name.\n *\n * A named slot lives on the node, so it lasts as long as the node does. That\n * is wrong for a derivation that belongs to some shorter-lived reader — one\n * `toPose` function among many over the life of a scene. A scope is held by\n * that reader, and its entries go when the reader does.\n */\nexport type NodeMemoScope = { readonly [scopeBrand]: true };\n\nexport function createNodeMemoScope(): NodeMemoScope {\n  return new WeakMap<object, ScopedSlot>() as unknown as NodeMemoScope;\n}\n\nconst MEMO = new WeakMap<object, NodeMemoRecord>();\n\n/** Bumped whenever ambient state a derivation reads has changed. Entries\n *  stamped with an older value are dropped rather than served stale. */\nlet generation = 0;\n\n/** A node, as far as the memo is concerned: an object identity that may carry\n *  a `data` reference. */\ntype MemoizableNode = { data?: unknown };\n\n/**\n * Return the value `derive` produces for `node`, recomputing only when the\n * node's `data` reference, the given `pose` reference, the `also` reference,\n * or the global generation has changed since the last call for this `slot`.\n *\n * `slot` names the derivation, so a node's several derived values do not\n * overwrite each other.\n *\n * `pose` is a **parameter rather than a read off the node**, because callers\n * legitimately derive against a pose that isn't `node.pose`: a preview or\n * ghost pose mid-drag. Pass `undefined` for derivations that don't depend on\n * the pose at all, leaving `data` as the only key.\n *\n * `also` is for an input that lives outside the node, such as the paint a\n * node inherits from its container. It must be a reference its owner keeps\n * while the input is unchanged.\n */\nexport function nodeMemo<T>(\n  node: MemoizableNode,\n  slot: string | NodeMemoScope,\n  pose: unknown,\n  derive: () => T,\n  also?: unknown,\n): T {\n  if (typeof slot !== 'string') return scopedNodeMemo(node, slot, pose, derive, also);\n  let record = MEMO.get(node);\n  if (record === undefined) {\n    record = { generation, slots: new Map(), drops: 0 };\n    MEMO.set(node, record);\n  } else if (record.generation !== generation) {\n    record.generation = generation;\n    record.slots.clear();\n  }\n\n  const data = node.data;\n  const hit = record.slots.get(slot);\n  if (hit !== undefined && hit.pose === pose && hit.data === data && hit.also === also) {\n    return hit.value as T;\n  }\n\n  const value = derive();\n  // Reuse the slot object when there is one: this runs per node per frame, and\n  // the entry churn is the only allocation the memo would otherwise add.\n  if (hit !== undefined) {\n    hit.pose = pose;\n    hit.data = data;\n    hit.also = also;\n    hit.value = value;\n  } else {\n    record.slots.set(slot, { pose, data, also, value });\n  }\n  return value;\n}\n\nfunction scopedNodeMemo<T>(\n  node: MemoizableNode,\n  scope: NodeMemoScope,\n  pose: unknown,\n  derive: () => T,\n  also: unknown,\n): T {\n  const entries = scope as unknown as WeakMap<object, ScopedSlot>;\n  const data = node.data;\n  const drops = MEMO.get(node)?.drops ?? 0;\n  const hit = entries.get(node);\n  if (\n    hit !== undefined && hit.generation === generation && hit.pose === pose && hit.data === data\n    && hit.also === also    && (pose === undefined || hit.drops === drops)\n  ) {\n    return hit.value as T;\n  }\n  const value = derive();\n  // Read again: a derivation that hit a cycle drops this node's slots itself.\n  const dropsNow = MEMO.get(node)?.drops ?? 0;\n  if (hit !== undefined) {\n    hit.pose = pose;\n    hit.data = data;\n    hit.also = also;\n    hit.value = value;\n    hit.generation = generation;\n    hit.drops = dropsNow;\n  } else {\n    entries.set(node, { pose, data, also, value, generation, drops: dropsNow });\n  }\n  return value;\n}\n\n/** How many named slots `node` holds. For tests of what is kept on a node. */\nexport function nodeMemoSlotCount(node: MemoizableNode): number {\n  const record = MEMO.get(node);\n  return record === undefined || record.generation !== generation ? 0 : record.slots.size;\n}\n\n/**\n * Drop every memoized slot on every node. For owners of ambient state that\n * changes what a `derive` would return. Cheap — it bumps a counter.\n */\nexport function bumpNodeMemoGeneration(): void {\n  generation++;\n}\n\n/** The generation {@link bumpNodeMemoGeneration} last moved to: a freshness\n *  key for a cache outside this memo that reads the same ambient state. */\nexport function nodeMemoGeneration(): number {\n  return generation;\n}\n\n/**\n * Drop the slots of `node` that were keyed on a pose, keeping the ones that\n * weren't.\n *\n * For per-frame pose overrides, which mutate one buffer in place rather than\n * replacing the reference, which the `(pose, data)` key cannot see.\n * {@link bumpNodeMemoGeneration} is the wrong tool there — it would drop every\n * static node's slots too, every frame.\n */\nexport function dropPoseKeyedMemoSlots(node: MemoizableNode): void {\n  const record = MEMO.get(node);\n  if (record === undefined) {\n    MEMO.set(node, { generation, slots: new Map(), drops: 1 });\n    return;\n  }\n  record.drops++;\n  for (const [slot, entry] of record.slots) {\n    if (entry.pose !== undefined) record.slots.delete(slot);\n  }\n}\n"],"mappings":";AAyDA,SAAgB,sBAAqC;CACnD,uBAAO,IAAI,QAA4B;AACzC;AAEA,IAAM,uBAAO,IAAI,QAAgC;;;AAIjD,IAAI,aAAa;;;;;;;;;;;;;;;;;;AAuBjB,SAAgB,SACd,MACA,MACA,MACA,QACA,MACG;CACH,IAAI,OAAO,SAAS,UAAU,OAAO,eAAe,MAAM,MAAM,MAAM,QAAQ,IAAI;CAClF,IAAI,SAAS,KAAK,IAAI,IAAI;CAC1B,IAAI,WAAW,QAAW;EACxB,SAAS;GAAE;GAAY,uBAAO,IAAI,IAAI;GAAG,OAAO;EAAE;EAClD,KAAK,IAAI,MAAM,MAAM;CACvB,OAAO,IAAI,OAAO,eAAe,YAAY;EAC3C,OAAO,aAAa;EACpB,OAAO,MAAM,MAAM;CACrB;CAEA,MAAM,OAAO,KAAK;CAClB,MAAM,MAAM,OAAO,MAAM,IAAI,IAAI;CACjC,IAAI,QAAQ,UAAa,IAAI,SAAS,QAAQ,IAAI,SAAS,QAAQ,IAAI,SAAS,MAC9E,OAAO,IAAI;CAGb,MAAM,QAAQ,OAAO;CAGrB,IAAI,QAAQ,QAAW;EACrB,IAAI,OAAO;EACX,IAAI,OAAO;EACX,IAAI,OAAO;EACX,IAAI,QAAQ;CACd,OACE,OAAO,MAAM,IAAI,MAAM;EAAE;EAAM;EAAM;EAAM;CAAM,CAAC;CAEpD,OAAO;AACT;AAEA,SAAS,eACP,MACA,OACA,MACA,QACA,MACG;CACH,MAAM,UAAU;CAChB,MAAM,OAAO,KAAK;CAClB,MAAM,QAAQ,KAAK,IAAI,IAAI,CAAC,EAAE,SAAS;CACvC,MAAM,MAAM,QAAQ,IAAI,IAAI;CAC5B,IACE,QAAQ,UAAa,IAAI,eAAe,cAAc,IAAI,SAAS,QAAQ,IAAI,SAAS,QACrF,IAAI,SAAS,SAAY,SAAS,UAAa,IAAI,UAAU,QAEhE,OAAO,IAAI;CAEb,MAAM,QAAQ,OAAO;CAErB,MAAM,WAAW,KAAK,IAAI,IAAI,CAAC,EAAE,SAAS;CAC1C,IAAI,QAAQ,QAAW;EACrB,IAAI,OAAO;EACX,IAAI,OAAO;EACX,IAAI,OAAO;EACX,IAAI,QAAQ;EACZ,IAAI,aAAa;EACjB,IAAI,QAAQ;CACd,OACE,QAAQ,IAAI,MAAM;EAAE;EAAM;EAAM;EAAM;EAAO;EAAY,OAAO;CAAS,CAAC;CAE5E,OAAO;AACT;;;;;AAYA,SAAgB,yBAA+B;CAC7C;AACF;;;AAIA,SAAgB,qBAA6B;CAC3C,OAAO;AACT;;;;;;;;;;AAWA,SAAgB,uBAAuB,MAA4B;CACjE,MAAM,SAAS,KAAK,IAAI,IAAI;CAC5B,IAAI,WAAW,QAAW;EACxB,KAAK,IAAI,MAAM;GAAE;GAAY,uBAAO,IAAI,IAAI;GAAG,OAAO;EAAE,CAAC;EACzD;CACF;CACA,OAAO;CACP,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,OACjC,IAAI,MAAM,SAAS,QAAW,OAAO,MAAM,OAAO,IAAI;AAE1D"}

package/dist/core/scene/nodeStore.js

@@ -85,8 +85,7 @@ function createNodeStore(state, invalidateOrder, fnFields) {
 	function siblingsOf(parent) {
 		if (parent === null) return state.roots;
 		const p = requireNode(parent);
-		if (p.kind !== "container") throw new Error(`Scene: parent "${parent}" is not a container`);
-		return p.children;
+		return p.children ??= [];
 	}
 	function detach(id) {
 		const node = requireNode(id);
@@ -110,7 +109,7 @@ function createNodeStore(state, invalidateOrder, fnFields) {
 	}
 	function descendants(id, out) {
 		const n = state.nodes.get(id);
-		if (!n || n.kind !== "container") return;
+		if (!n?.children) return;
 		for (const c of n.children) {
 			out.push(c);
 			descendants(c, out);
@@ -164,7 +163,6 @@ function createNodeStore(state, invalidateOrder, fnFields) {
 		for (const field of fnFields) {
 			const fn = spec[field.spec.field];
 			if (fn === void 0) continue;
-			if (field.spec.containersOnly && spec.kind !== "container") continue;
 			field.write(node, fn);
 			attached.set(field, fn);
 		}

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

@@ -1 +1 @@
-{"version":3,"file":"nodeStore.js","names":[],"sources":["../../../src/core/scene/nodeStore.ts"],"sourcesContent":["/**\n * The scene's node store: the tree links, the reverse index of who derives\n * from whom, and the function fields a node carries beside its data.\n *\n * Everything here reads and writes `state.nodes` and `state.roots` directly;\n * none of it records. The kit ops call it from both of their directions.\n */\nimport { dwarn } from 'debug/flag';\nimport { createDependentsIndex } from './dependents';\nimport { dropPoseKeyedMemoSlots } from './nodeMemo';\nimport { restoreFn, type FnBearingNode, type NodeFn, type NodeFnField } from './nodeFnFields';\nimport { SceneMembershipError } from './staleReplay';\nimport type { AddNodeSpec, Node, NodeId } from './types';\n\n/** What the store keeps of a scene's state. */\nexport interface NodeStoreState<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  roots: NodeId[];\n}\n\nexport function createNodeStore<TData, TLayer extends string, TPose>(\n  state: NodeStoreState<TData, TLayer, TPose>,\n  /** Called on every edit to the tree's links. */\n  invalidateOrder: () => void,\n  fnFields: readonly NodeFnField[],\n) {\n  /** Maintained from `kit:add` / `kit:remove` — the only two places a node is\n   *  created or destroyed, and unlike `add`/`remove` they replay on undo/redo.\n   *  Only explicit `dependsOn` id lists are registered here; `'children'` is\n   *  the ancestor walk in `invalidateDependents` instead. */\n  const dependents = createDependentsIndex();\n\n  /** Nodes carrying `dependsOn: 'children'`. Empty in every scene that has no\n   *  container hugging its contents, which is what keeps the ancestor walk off\n   *  the hot path. */\n  const childDerived = new Set<NodeId>();\n\n  /** Walks `id`'s whole subtree: under a composing pose strategy a container's\n   *  move carries every descendant, and whatever derives from one. */\n  function invalidateDependents(id: NodeId): void {\n    invalidateChildDerivedFrom(state.nodes.get(id)?.parent ?? null);\n    if (dependents.isEmpty()) return;\n    const subtree: NodeId[] = [id];\n    descendants(id, subtree);\n    for (const src of subtree) {\n      for (const dep of dependents.transitiveDependentsOf(src)) {\n        const node = state.nodes.get(dep);\n        if (node !== undefined) dropPoseKeyedMemoSlots(node);\n      }\n    }\n  }\n\n  /** A `dependsOn: 'children'` container derives from nodes the reverse index\n   *  never sees, so its invalidation runs the other way: up the parent chain\n   *  from `start` inclusive, and on to each such ancestor's own dependents.\n   *\n   *  Callers that removed or reparented a node pass the parent explicitly —\n   *  a gone node cannot say who its parent was. */\n  function invalidateChildDerivedFrom(start: NodeId | null): void {\n    if (childDerived.size === 0) return;\n    let cursor = start;\n    while (cursor !== null) {\n      const node = state.nodes.get(cursor);\n      if (node === undefined) return;\n      if (childDerived.has(cursor)) {\n        dropPoseKeyedMemoSlots(node);\n        for (const dep of dependents.transitiveDependentsOf(cursor)) {\n          const d = state.nodes.get(dep);\n          if (d !== undefined) dropPoseKeyedMemoSlots(d);\n        }\n      }\n      cursor = node.parent;\n    }\n  }\n\n  /** Track (or forget) a node whose `dependsOn` is `'children'`. Paired with\n   *  `dependents.add` / `.remove` at every site a node is created or destroyed. */\n  function trackChildDerived(id: NodeId, dependsOn: Node<TData, TLayer, TPose>['dependsOn']): void {\n    if (dependsOn === 'children') childDerived.add(id);\n    else childDerived.delete(id);\n  }\n\n  /** Point `id` at a different set of dependencies, keeping both indices and\n   *  every memo that reads them in step. Shared by `kit:setDependsOn`'s two\n   *  directions, which differ only in which value they install.\n   *\n   *  `id`'s own memo is dropped as well as its dependents': its derivation now\n   *  reads different sources, and nothing else would clear it. */\n  function retarget(id: NodeId, dependsOn: Node<TData, TLayer, TPose>['dependsOn']): void {\n    const node = requireNode(id) as { dependsOn?: readonly NodeId[] | 'children' };\n    if (dependsOn === undefined) delete node.dependsOn;\n    else node.dependsOn = dependsOn;\n    dependents.add(id, dependsOn === undefined || dependsOn === 'children' ? [] : dependsOn);\n    trackChildDerived(id, dependsOn);\n    dropPoseKeyedMemoSlots(requireNode(id));\n    invalidateDependents(id);\n  }\n\n  function requireNode(id: NodeId): Node<TData, TLayer, TPose> {\n    const n = state.nodes.get(id);\n    if (!n) throw new SceneMembershipError(`Scene: unknown node id \"${id}\"`);\n    return n;\n  }\n\n  function siblingsOf(parent: NodeId | null): NodeId[] {\n    if (parent === null) return state.roots;\n    const p = requireNode(parent);\n    if (p.kind !== 'container') {\n      throw new Error(`Scene: parent \"${parent}\" is not a container`);\n    }\n    return p.children;\n  }\n\n  function detach(id: NodeId): { parent: NodeId | null; index: number } {\n    const node = requireNode(id);\n    const sibs = siblingsOf(node.parent);\n    const idx = sibs.indexOf(id);\n    if (idx < 0) throw new Error(`Scene: node \"${id}\" not found in its parent's children`);\n    sibs.splice(idx, 1);\n    invalidateOrder();\n    return { parent: node.parent, index: idx };\n  }\n\n  function attach(id: NodeId, parent: NodeId | null, index: number): void {\n    const sibs = siblingsOf(parent);\n    const i = Math.max(0, Math.min(index, sibs.length));\n    sibs.splice(i, 0, id);\n    const node = requireNode(id);\n    (node as { parent: NodeId | null }).parent = parent;\n    invalidateOrder();\n  }\n\n  function descendants(id: NodeId, out: NodeId[]): void {\n    const n = state.nodes.get(id);\n    if (!n || n.kind !== 'container') return;\n    for (const c of n.children) {\n      out.push(c);\n      descendants(c, out);\n    }\n  }\n\n  /** Everything removing `rootIds` takes with it: each root's subtree, then\n   *  every node deriving from any of those, then those nodes' subtrees in turn.\n   *  A dependent is not a descendant, so the second pass is a separate\n   *  reachability walk; `ids` grows as it runs, which is what carries the\n   *  cascade transitively and upward through a dependent's own ancestors.\n   *\n   *  Published as {@link Scene.removalClosure}, which is what the delete op and\n   *  `buildDeleteOps` ask instead of rebuilding the walk from `dependsOn` and\n   *  `children` — a third cascade relation is then added here alone. */\n  function removalClosure(rootIds: readonly NodeId[]): {\n    ids: NodeId[];\n    removing: Set<NodeId>;\n  } {\n    const ids: NodeId[] = [];\n    const removing = new Set<NodeId>();\n    function take(id: NodeId): void {\n      if (removing.has(id)) return;\n      removing.add(id);\n      ids.push(id);\n      const sub: NodeId[] = [];\n      descendants(id, sub);\n      for (const s of sub) {\n        if (removing.has(s)) continue;\n        removing.add(s);\n        ids.push(s);\n      }\n    }\n    for (const root of rootIds) take(root);\n    for (let i = 0; i < ids.length; i++) {\n      for (const dep of dependents.transitiveDependentsOf(ids[i])) take(dep);\n    }\n    return { ids, removing };\n  }\n\n  /** The functions a live `scene.add` attached, by the `kit:add` payload it\n   *  recorded: redo replays that payload without the spec. Keyed on the\n   *  payload rather than the node id because an id is reusable, and each\n   *  add of it owns its own functions. */\n  const addedFns = new WeakMap<object, Map<NodeFnField, NodeFn>>();\n\n  /** Post-patch the registry-keyed function fields onto a node after its\n   *  `kit:add` op runs. A function cannot travel through the serializable op\n   *  payload, so it is attached to the live node here, and kept against\n   *  `payload` for redo when there is one. `dependsOn` is plain data and\n   *  rides the payload instead. */\n  function patchNodeFunctions(\n    spec: AddNodeSpec<TData, TLayer, TPose>,\n    id: NodeId,\n    payload: object | null,\n  ): void {\n    const node = state.nodes.get(id) as FnBearingNode | undefined;\n    if (node === undefined) return;\n    const attached = new Map<NodeFnField, NodeFn>();\n    for (const field of fnFields) {\n      const fn = (spec as unknown as Record<string, unknown>)[field.spec.field] as NodeFn | undefined;\n      if (fn === undefined) continue;\n      if (field.spec.containersOnly && spec.kind !== 'container') continue;\n      field.write(node, fn);\n      attached.set(field, fn);\n    }\n    if (payload && attached.size > 0) addedFns.set(payload, attached);\n  }\n\n  /** Re-attach those fields to a node restored from a `kit:remove` snapshot.\n   *  In-session the clone already carries them; a persisted history does not,\n   *  so the registry keys are what is left. */\n  function restoreNodeFunctions(\n    node: Node<TData, TLayer, TPose>,\n    keys: Record<string, string | undefined> | undefined,\n  ): void {\n    if (!keys) return;\n    const target = node as unknown as FnBearingNode;\n    for (const field of fnFields) {\n      if (field.read(target) !== undefined) continue;\n      const key = keys[field.spec.opKey];\n      if (key === undefined) continue;\n      restoreFn(field, target, key, 'kit:remove', dwarn);\n    }\n  }\n\n  return {\n    dependents, childDerived, invalidateDependents, invalidateChildDerivedFrom, trackChildDerived, retarget,\n    requireNode, siblingsOf, detach, attach, descendants, removalClosure, addedFns, patchNodeFunctions,\n    restoreNodeFunctions,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"nodeStore.js","names":[],"sources":["../../../src/core/scene/nodeStore.ts"],"sourcesContent":["/**\n * The scene's node store: the tree links, the reverse index of who derives\n * from whom, and the function fields a node carries beside its data.\n *\n * Everything here reads and writes `state.nodes` and `state.roots` directly;\n * none of it records. The kit ops call it from both of their directions.\n */\nimport { dwarn } from 'debug/flag';\nimport { createDependentsIndex } from './dependents';\nimport { dropPoseKeyedMemoSlots } from './nodeMemo';\nimport { restoreFn, type FnBearingNode, type NodeFn, type NodeFnField } from './nodeFnFields';\nimport { SceneMembershipError } from './staleReplay';\nimport type { AddNodeSpec, Node, NodeId } from './types';\n\n/** What the store keeps of a scene's state. */\nexport interface NodeStoreState<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  roots: NodeId[];\n}\n\nexport function createNodeStore<TData, TLayer extends string, TPose>(\n  state: NodeStoreState<TData, TLayer, TPose>,\n  /** Called on every edit to the tree's links. */\n  invalidateOrder: () => void,\n  fnFields: readonly NodeFnField[],\n) {\n  /** Maintained from `kit:add` / `kit:remove` — the only two places a node is\n   *  created or destroyed, and unlike `add`/`remove` they replay on undo/redo.\n   *  Only explicit `dependsOn` id lists are registered here; `'children'` is\n   *  the ancestor walk in `invalidateDependents` instead. */\n  const dependents = createDependentsIndex();\n\n  /** Nodes carrying `dependsOn: 'children'`. Empty in every scene that has no\n   *  container hugging its contents, which is what keeps the ancestor walk off\n   *  the hot path. */\n  const childDerived = new Set<NodeId>();\n\n  /** Walks `id`'s whole subtree: under a composing pose strategy a container's\n   *  move carries every descendant, and whatever derives from one. */\n  function invalidateDependents(id: NodeId): void {\n    invalidateChildDerivedFrom(state.nodes.get(id)?.parent ?? null);\n    if (dependents.isEmpty()) return;\n    const subtree: NodeId[] = [id];\n    descendants(id, subtree);\n    for (const src of subtree) {\n      for (const dep of dependents.transitiveDependentsOf(src)) {\n        const node = state.nodes.get(dep);\n        if (node !== undefined) dropPoseKeyedMemoSlots(node);\n      }\n    }\n  }\n\n  /** A `dependsOn: 'children'` container derives from nodes the reverse index\n   *  never sees, so its invalidation runs the other way: up the parent chain\n   *  from `start` inclusive, and on to each such ancestor's own dependents.\n   *\n   *  Callers that removed or reparented a node pass the parent explicitly —\n   *  a gone node cannot say who its parent was. */\n  function invalidateChildDerivedFrom(start: NodeId | null): void {\n    if (childDerived.size === 0) return;\n    let cursor = start;\n    while (cursor !== null) {\n      const node = state.nodes.get(cursor);\n      if (node === undefined) return;\n      if (childDerived.has(cursor)) {\n        dropPoseKeyedMemoSlots(node);\n        for (const dep of dependents.transitiveDependentsOf(cursor)) {\n          const d = state.nodes.get(dep);\n          if (d !== undefined) dropPoseKeyedMemoSlots(d);\n        }\n      }\n      cursor = node.parent;\n    }\n  }\n\n  /** Track (or forget) a node whose `dependsOn` is `'children'`. Paired with\n   *  `dependents.add` / `.remove` at every site a node is created or destroyed. */\n  function trackChildDerived(id: NodeId, dependsOn: Node<TData, TLayer, TPose>['dependsOn']): void {\n    if (dependsOn === 'children') childDerived.add(id);\n    else childDerived.delete(id);\n  }\n\n  /** Point `id` at a different set of dependencies, keeping both indices and\n   *  every memo that reads them in step. Shared by `kit:setDependsOn`'s two\n   *  directions, which differ only in which value they install.\n   *\n   *  `id`'s own memo is dropped as well as its dependents': its derivation now\n   *  reads different sources, and nothing else would clear it. */\n  function retarget(id: NodeId, dependsOn: Node<TData, TLayer, TPose>['dependsOn']): void {\n    const node = requireNode(id) as { dependsOn?: readonly NodeId[] | 'children' };\n    if (dependsOn === undefined) delete node.dependsOn;\n    else node.dependsOn = dependsOn;\n    dependents.add(id, dependsOn === undefined || dependsOn === 'children' ? [] : dependsOn);\n    trackChildDerived(id, dependsOn);\n    dropPoseKeyedMemoSlots(requireNode(id));\n    invalidateDependents(id);\n  }\n\n  function requireNode(id: NodeId): Node<TData, TLayer, TPose> {\n    const n = state.nodes.get(id);\n    if (!n) throw new SceneMembershipError(`Scene: unknown node id \"${id}\"`);\n    return n;\n  }\n\n  function siblingsOf(parent: NodeId | null): NodeId[] {\n    if (parent === null) return state.roots;\n    const p = requireNode(parent);\n    return (p.children ??= []);\n  }\n\n  function detach(id: NodeId): { parent: NodeId | null; index: number } {\n    const node = requireNode(id);\n    const sibs = siblingsOf(node.parent);\n    const idx = sibs.indexOf(id);\n    if (idx < 0) throw new Error(`Scene: node \"${id}\" not found in its parent's children`);\n    sibs.splice(idx, 1);\n    invalidateOrder();\n    return { parent: node.parent, index: idx };\n  }\n\n  function attach(id: NodeId, parent: NodeId | null, index: number): void {\n    const sibs = siblingsOf(parent);\n    const i = Math.max(0, Math.min(index, sibs.length));\n    sibs.splice(i, 0, id);\n    const node = requireNode(id);\n    (node as { parent: NodeId | null }).parent = parent;\n    invalidateOrder();\n  }\n\n  function descendants(id: NodeId, out: NodeId[]): void {\n    const n = state.nodes.get(id);\n    if (!n?.children) return;\n    for (const c of n.children) {\n      out.push(c);\n      descendants(c, out);\n    }\n  }\n\n  /** Everything removing `rootIds` takes with it: each root's subtree, then\n   *  every node deriving from any of those, then those nodes' subtrees in turn.\n   *  A dependent is not a descendant, so the second pass is a separate\n   *  reachability walk; `ids` grows as it runs, which is what carries the\n   *  cascade transitively and upward through a dependent's own ancestors.\n   *\n   *  Published as {@link Scene.removalClosure}, which is what the delete op and\n   *  `buildDeleteOps` ask instead of rebuilding the walk from `dependsOn` and\n   *  `children` — a third cascade relation is then added here alone. */\n  function removalClosure(rootIds: readonly NodeId[]): {\n    ids: NodeId[];\n    removing: Set<NodeId>;\n  } {\n    const ids: NodeId[] = [];\n    const removing = new Set<NodeId>();\n    function take(id: NodeId): void {\n      if (removing.has(id)) return;\n      removing.add(id);\n      ids.push(id);\n      const sub: NodeId[] = [];\n      descendants(id, sub);\n      for (const s of sub) {\n        if (removing.has(s)) continue;\n        removing.add(s);\n        ids.push(s);\n      }\n    }\n    for (const root of rootIds) take(root);\n    for (let i = 0; i < ids.length; i++) {\n      for (const dep of dependents.transitiveDependentsOf(ids[i])) take(dep);\n    }\n    return { ids, removing };\n  }\n\n  /** The functions a live `scene.add` attached, by the `kit:add` payload it\n   *  recorded: redo replays that payload without the spec. Keyed on the\n   *  payload rather than the node id because an id is reusable, and each\n   *  add of it owns its own functions. */\n  const addedFns = new WeakMap<object, Map<NodeFnField, NodeFn>>();\n\n  /** Post-patch the registry-keyed function fields onto a node after its\n   *  `kit:add` op runs. A function cannot travel through the serializable op\n   *  payload, so it is attached to the live node here, and kept against\n   *  `payload` for redo when there is one. `dependsOn` is plain data and\n   *  rides the payload instead. */\n  function patchNodeFunctions(\n    spec: AddNodeSpec<TData, TLayer, TPose>,\n    id: NodeId,\n    payload: object | null,\n  ): void {\n    const node = state.nodes.get(id) as FnBearingNode | undefined;\n    if (node === undefined) return;\n    const attached = new Map<NodeFnField, NodeFn>();\n    for (const field of fnFields) {\n      const fn = (spec as unknown as Record<string, unknown>)[field.spec.field] as NodeFn | undefined;\n      if (fn === undefined) continue;\n      field.write(node, fn);\n      attached.set(field, fn);\n    }\n    if (payload && attached.size > 0) addedFns.set(payload, attached);\n  }\n\n  /** Re-attach those fields to a node restored from a `kit:remove` snapshot.\n   *  In-session the clone already carries them; a persisted history does not,\n   *  so the registry keys are what is left. */\n  function restoreNodeFunctions(\n    node: Node<TData, TLayer, TPose>,\n    keys: Record<string, string | undefined> | undefined,\n  ): void {\n    if (!keys) return;\n    const target = node as unknown as FnBearingNode;\n    for (const field of fnFields) {\n      if (field.read(target) !== undefined) continue;\n      const key = keys[field.spec.opKey];\n      if (key === undefined) continue;\n      restoreFn(field, target, key, 'kit:remove', dwarn);\n    }\n  }\n\n  return {\n    dependents, childDerived, invalidateDependents, invalidateChildDerivedFrom, trackChildDerived, retarget,\n    requireNode, siblingsOf, detach, attach, descendants, removalClosure, addedFns, patchNodeFunctions,\n    restoreNodeFunctions,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;AAoBA,SAAgB,gBACd,OAEA,iBACA,UACA;;;;;CAKA,MAAM,aAAa,sBAAsB;;;;CAKzC,MAAM,+BAAe,IAAI,IAAY;;;CAIrC,SAAS,qBAAqB,IAAkB;EAC9C,2BAA2B,MAAM,MAAM,IAAI,EAAE,CAAC,EAAE,UAAU,IAAI;EAC9D,IAAI,WAAW,QAAQ,GAAG;EAC1B,MAAM,UAAoB,CAAC,EAAE;EAC7B,YAAY,IAAI,OAAO;EACvB,KAAK,MAAM,OAAO,SAChB,KAAK,MAAM,OAAO,WAAW,uBAAuB,GAAG,GAAG;GACxD,MAAM,OAAO,MAAM,MAAM,IAAI,GAAG;GAChC,IAAI,SAAS,QAAW,uBAAuB,IAAI;EACrD;CAEJ;;;;;;;CAQA,SAAS,2BAA2B,OAA4B;EAC9D,IAAI,aAAa,SAAS,GAAG;EAC7B,IAAI,SAAS;EACb,OAAO,WAAW,MAAM;GACtB,MAAM,OAAO,MAAM,MAAM,IAAI,MAAM;GACnC,IAAI,SAAS,QAAW;GACxB,IAAI,aAAa,IAAI,MAAM,GAAG;IAC5B,uBAAuB,IAAI;IAC3B,KAAK,MAAM,OAAO,WAAW,uBAAuB,MAAM,GAAG;KAC3D,MAAM,IAAI,MAAM,MAAM,IAAI,GAAG;KAC7B,IAAI,MAAM,QAAW,uBAAuB,CAAC;IAC/C;GACF;GACA,SAAS,KAAK;EAChB;CACF;;;CAIA,SAAS,kBAAkB,IAAY,WAA0D;EAC/F,IAAI,cAAc,YAAY,aAAa,IAAI,EAAE;OAC5C,aAAa,OAAO,EAAE;CAC7B;;;;;;;CAQA,SAAS,SAAS,IAAY,WAA0D;EACtF,MAAM,OAAO,YAAY,EAAE;EAC3B,IAAI,cAAc,QAAW,OAAO,KAAK;OACpC,KAAK,YAAY;EACtB,WAAW,IAAI,IAAI,cAAc,UAAa,cAAc,aAAa,CAAC,IAAI,SAAS;EACvF,kBAAkB,IAAI,SAAS;EAC/B,uBAAuB,YAAY,EAAE,CAAC;EACtC,qBAAqB,EAAE;CACzB;CAEA,SAAS,YAAY,IAAwC;EAC3D,MAAM,IAAI,MAAM,MAAM,IAAI,EAAE;EAC5B,IAAI,CAAC,GAAG,MAAM,IAAI,qBAAqB,2BAA2B,GAAG,EAAE;EACvE,OAAO;CACT;CAEA,SAAS,WAAW,QAAiC;EACnD,IAAI,WAAW,MAAM,OAAO,MAAM;EAClC,MAAM,IAAI,YAAY,MAAM;EAC5B,OAAQ,EAAE,aAAa,CAAC;CAC1B;CAEA,SAAS,OAAO,IAAsD;EACpE,MAAM,OAAO,YAAY,EAAE;EAC3B,MAAM,OAAO,WAAW,KAAK,MAAM;EACnC,MAAM,MAAM,KAAK,QAAQ,EAAE;EAC3B,IAAI,MAAM,GAAG,MAAM,IAAI,MAAM,gBAAgB,GAAG,qCAAqC;EACrF,KAAK,OAAO,KAAK,CAAC;EAClB,gBAAgB;EAChB,OAAO;GAAE,QAAQ,KAAK;GAAQ,OAAO;EAAI;CAC3C;CAEA,SAAS,OAAO,IAAY,QAAuB,OAAqB;EACtE,MAAM,OAAO,WAAW,MAAM;EAC9B,MAAM,IAAI,KAAK,IAAI,GAAG,KAAK,IAAI,OAAO,KAAK,MAAM,CAAC;EAClD,KAAK,OAAO,GAAG,GAAG,EAAE;EACpB,MAAM,OAAO,YAAY,EAAE;EAC3B,KAAoC,SAAS;EAC7C,gBAAgB;CAClB;CAEA,SAAS,YAAY,IAAY,KAAqB;EACpD,MAAM,IAAI,MAAM,MAAM,IAAI,EAAE;EAC5B,IAAI,CAAC,GAAG,UAAU;EAClB,KAAK,MAAM,KAAK,EAAE,UAAU;GAC1B,IAAI,KAAK,CAAC;GACV,YAAY,GAAG,GAAG;EACpB;CACF;;;;;;;;;;CAWA,SAAS,eAAe,SAGtB;EACA,MAAM,MAAgB,CAAC;EACvB,MAAM,2BAAW,IAAI,IAAY;EACjC,SAAS,KAAK,IAAkB;GAC9B,IAAI,SAAS,IAAI,EAAE,GAAG;GACtB,SAAS,IAAI,EAAE;GACf,IAAI,KAAK,EAAE;GACX,MAAM,MAAgB,CAAC;GACvB,YAAY,IAAI,GAAG;GACnB,KAAK,MAAM,KAAK,KAAK;IACnB,IAAI,SAAS,IAAI,CAAC,GAAG;IACrB,SAAS,IAAI,CAAC;IACd,IAAI,KAAK,CAAC;GACZ;EACF;EACA,KAAK,MAAM,QAAQ,SAAS,KAAK,IAAI;EACrC,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAC9B,KAAK,MAAM,OAAO,WAAW,uBAAuB,IAAI,EAAE,GAAG,KAAK,GAAG;EAEvE,OAAO;GAAE;GAAK;EAAS;CACzB;;;;;CAMA,MAAM,2BAAW,IAAI,QAA0C;;;;;;CAO/D,SAAS,mBACP,MACA,IACA,SACM;EACN,MAAM,OAAO,MAAM,MAAM,IAAI,EAAE;EAC/B,IAAI,SAAS,QAAW;EACxB,MAAM,2BAAW,IAAI,IAAyB;EAC9C,KAAK,MAAM,SAAS,UAAU;GAC5B,MAAM,KAAM,KAA4C,MAAM,KAAK;GACnE,IAAI,OAAO,QAAW;GACtB,MAAM,MAAM,MAAM,EAAE;GACpB,SAAS,IAAI,OAAO,EAAE;EACxB;EACA,IAAI,WAAW,SAAS,OAAO,GAAG,SAAS,IAAI,SAAS,QAAQ;CAClE;;;;CAKA,SAAS,qBACP,MACA,MACM;EACN,IAAI,CAAC,MAAM;EACX,MAAM,SAAS;EACf,KAAK,MAAM,SAAS,UAAU;GAC5B,IAAI,MAAM,KAAK,MAAM,MAAM,QAAW;GACtC,MAAM,MAAM,KAAK,MAAM,KAAK;GAC5B,IAAI,QAAQ,QAAW;GACvB,UAAU,OAAO,QAAQ,KAAK,cAAc,KAAK;EACnD;CACF;CAEA,OAAO;EACL;EAAY;EAAc;EAAsB;EAA4B;EAAmB;EAC/F;EAAa;EAAY;EAAQ;EAAQ;EAAa;EAAgB;EAAU;EAChF;CACF;AACF"}

package/dist/core/scene/pathEffects/derive.js

@@ -42,6 +42,7 @@ function createPathEffectDerivations(read) {
 			depData: deps.map((d) => d?.node.data),
 			poses: deps.map((d) => d === void 0 ? void 0 : snapshotPose(d.pose)),
 			paths: deps.map((d) => d?.path ?? null),
+			inherited: deps.map((d) => d?.inherited),
 			path: parts === null ? null : pathFromParts(parts),
 			faces: fonts ? generation : null
 		};
@@ -71,7 +72,7 @@ function current(held, node, deps) {
 		if (held.nodes[i] !== d?.node) return false;
 		if (d === void 0) continue;
 		if (held.depData[i] !== d.node.data || !samePoseValue(held.poses[i], d.pose)) return false;
-		if (held.paths[i] !== d.path) return false;
+		if (held.paths[i] !== d.path || held.inherited[i] !== d.inherited) return false;
 	}
 	if (held.faces !== null) noteFontRead();
 	return true;
@@ -87,7 +88,7 @@ function pathEffectParts(node, deps) {
 *  `derivations` — the ones the scene registers under {@link PATH_EFFECT}. */
 function pathEffectNode(effect, sources, layer, derivations) {
 	return {
-		kind: "leaf",
+		kind: "mark",
 		layer,
 		pose: {
 			x: 0,

package/dist/core/scene/pathEffects/derive.js.map

@@ -1 +1 @@
-{"version":3,"file":"derive.js","names":[],"sources":["../../../../src/core/scene/pathEffects/derive.ts"],"sourcesContent":["/**\n * A path effect as a scene node: a leaf whose `dependsOn` names its sources,\n * whose `data.pathEffect` says what to make of them, and whose path and pose\n * are both derived — the path to paint and pick, the pose as that path's\n * bounds, so selection chrome and marquee see where it is.\n *\n * Reading a source's outline and paint is its painter's business, which sits\n * above the scene, so the derivations are made from a reader:\n * `createPathEffectDerivations(read)`. The canvas layer makes the kit's, and\n * a scene that holds path effects registers them under {@link PATH_EFFECT}.\n */\nimport { boundsOfPath, type Path } from '@weasel-js/geom';\nimport { derivedPartsOf, pathFromParts, type DerivedPart } from '../derivedParts';\nimport { fontGeneration, noteFontRead, withFontReads } from '../fontReads';\nimport { samePoseValue, snapshotPose } from '../poseSnapshot';\nimport type { DerivedDep, NodeId } from '../types';\nimport { effectParts, type PathEffect } from './effects';\nimport type { EffectSourceReader } from './source';\n\n/** The registry key both derivations go by, for `derivePath` and `derivePose`. */\nexport const PATH_EFFECT = 'kit:pathEffect';\n\n/** A node's path effect, or `null` when its data holds none. */\nexport function pathEffectOf(node: { data?: unknown } | undefined): PathEffect | null {\n  const effect = (node?.data as { pathEffect?: PathEffect } | null | undefined)?.pathEffect;\n  return effect && typeof effect === 'object' && typeof effect.kind === 'string' ? effect : null;\n}\n\n/** A path-effect node's two derivations. */\nexport interface PathEffectDerivations {\n  /** What it paints and picks by. */\n  derivePath(node: { data?: unknown }, deps: readonly (DerivedDep<unknown> | undefined)[]): Path | null;\n  /** The bounds of what it paints, or `null` — its authored pose — while it\n   *  paints nothing. */\n  derivePose(node: { data?: unknown }, deps: readonly (DerivedDep<unknown> | undefined)[]): { x: number; y: number; width: number; height: number } | null;\n}\n\ninterface Derived {\n  data: unknown;\n  nodes: unknown[];\n  depData: unknown[];\n  poses: unknown[];\n  paths: (Path | null)[];\n  path: Path | null;\n  /** The face generation it was worked out under, or `null` when it read no\n   *  glyph outlines. */\n  faces: number | null;\n}\n\n/** The derivations of a path effect whose sources `read` reads. */\nexport function createPathEffectDerivations(read: EffectSourceReader): PathEffectDerivations {\n  /** One result per effect node, shared by its two derivations: the pose is\n   *  the path's bounds, and working the effect out twice a frame would double\n   *  its cost. Checked against everything it read, by value for poses — a\n   *  drag's override mutates its pose in place. */\n  const results = new WeakMap<object, Derived>();\n  const derive = (node: { data?: unknown }, deps: readonly (DerivedDep<unknown> | undefined)[]): Derived => {\n    const held = results.get(node);\n    if (held !== undefined && current(held, node, deps)) return held;\n    const effect = pathEffectOf(node);\n    const generation = fontGeneration();\n    const { value: parts, fonts } = withFontReads(() => (effect === null\n      ? null\n      : effectParts(effect, deps.map((d) => (d === undefined ? null : read(d))))));\n    const result: Derived = {\n      data: node.data,\n      nodes: deps.map((d) => d?.node),\n      depData: deps.map((d) => d?.node.data),\n      poses: deps.map((d) => (d === undefined ? undefined : snapshotPose(d.pose))),\n      paths: deps.map((d) => d?.path ?? null),\n      path: parts === null ? null : pathFromParts(parts),\n      faces: fonts ? generation : null,\n    };\n    results.set(node, result);\n    return result;\n  };\n  return {\n    derivePath: (node, deps) => derive(node, deps).path,\n    derivePose: (node, deps) => {\n      const path = derive(node, deps).path;\n      if (path === null) return null;\n      const { x, y, width, height } = boundsOfPath(path);\n      return { x, y, width, height };\n    },\n  };\n}\n\nfunction current(held: Derived, node: { data?: unknown }, deps: readonly (DerivedDep<unknown> | undefined)[]): boolean {\n  if (held.data !== node.data || held.nodes.length !== deps.length) return false;\n  if (held.faces !== null && held.faces !== fontGeneration()) return false;\n  for (let i = 0; i < deps.length; i++) {\n    const d = deps[i];\n    if (held.nodes[i] !== d?.node) return false;\n    if (d === undefined) continue;\n    if (held.depData[i] !== d.node.data || !samePoseValue(held.poses[i], d.pose)) return false;\n    if (held.paths[i] !== d.path) return false;\n  }\n  // A hit is still a read, for the scene memo enclosing this one.\n  if (held.faces !== null) noteFontRead();\n  return true;\n}\n\n/** The parts a path-effect node paints, as its sources stand, or `null` when\n *  it has no derivation or nothing to paint. */\nexport function pathEffectParts(\n  node: { data?: unknown; derivePath?: unknown },\n  deps: readonly (DerivedDep<unknown> | undefined)[],\n): readonly DerivedPart[] | null {\n  if (typeof node.derivePath !== 'function') return null;\n  return derivedPartsOf((node.derivePath as PathEffectDerivations['derivePath'])(node, deps)) ?? null;\n}\n\n/** What to hand `Scene.add` (or an insert op) for a path-effect node over\n *  `sources`, in the order its kind reads them, deriving through\n *  `derivations` — the ones the scene registers under {@link PATH_EFFECT}. */\nexport function pathEffectNode<TLayer extends string>(\n  effect: PathEffect,\n  sources: readonly NodeId[],\n  layer: TLayer,\n  derivations: PathEffectDerivations,\n): {\n  kind: 'leaf';\n  layer: TLayer;\n  pose: { x: number; y: number; width: number; height: number };\n  data: { pathEffect: PathEffect };\n  dependsOn: readonly NodeId[];\n  derivePath: PathEffectDerivations['derivePath'];\n  derivePose: PathEffectDerivations['derivePose'];\n} {\n  return {\n    kind: 'leaf',\n    layer,\n    pose: { x: 0, y: 0, width: 0, height: 0 },\n    data: { pathEffect: effect },\n    dependsOn: [...sources],\n    derivePath: derivations.derivePath,\n    derivePose: derivations.derivePose,\n  };\n}\n\n/** The path-effect derivations `registry` holds under {@link PATH_EFFECT},\n *  or `null` when it holds none. */\nexport function registeredPathEffects(registry: {\n  derivePath?: Readonly<Record<string, unknown>>;\n  derivePose?: Readonly<Record<string, unknown>>;\n}): PathEffectDerivations | null {\n  const derivePath = registry.derivePath?.[PATH_EFFECT];\n  const derivePose = registry.derivePose?.[PATH_EFFECT];\n  return typeof derivePath === 'function' && typeof derivePose === 'function'\n    ? { derivePath, derivePose } as PathEffectDerivations\n    : null;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAoBA,IAAa,cAAc;;AAG3B,SAAgB,aAAa,MAAyD;CACpF,MAAM,UAAU,MAAM,KAAA,EAAyD;CAC/E,OAAO,UAAU,OAAO,WAAW,YAAY,OAAO,OAAO,SAAS,WAAW,SAAS;AAC5F;;AAwBA,SAAgB,4BAA4B,MAAiD;;;;;CAK3F,MAAM,0BAAU,IAAI,QAAyB;CAC7C,MAAM,UAAU,MAA0B,SAAgE;EACxG,MAAM,OAAO,QAAQ,IAAI,IAAI;EAC7B,IAAI,SAAS,UAAa,QAAQ,MAAM,MAAM,IAAI,GAAG,OAAO;EAC5D,MAAM,SAAS,aAAa,IAAI;EAChC,MAAM,aAAa,eAAe;EAClC,MAAM,EAAE,OAAO,OAAO,UAAU,oBAAqB,WAAW,OAC5D,OACA,YAAY,QAAQ,KAAK,KAAK,MAAO,MAAM,SAAY,OAAO,KAAK,CAAC,CAAE,CAAC,CAAE;EAC7E,MAAM,SAAkB;GACtB,MAAM,KAAK;GACX,OAAO,KAAK,KAAK,MAAM,GAAG,IAAI;GAC9B,SAAS,KAAK,KAAK,MAAM,GAAG,KAAK,IAAI;GACrC,OAAO,KAAK,KAAK,MAAO,MAAM,SAAY,SAAY,aAAa,EAAE,IAAI,CAAE;GAC3E,OAAO,KAAK,KAAK,MAAM,GAAG,QAAQ,IAAI;GACtC,MAAM,UAAU,OAAO,OAAO,cAAc,KAAK;GACjD,OAAO,QAAQ,aAAa;EAC9B;EACA,QAAQ,IAAI,MAAM,MAAM;EACxB,OAAO;CACT;CACA,OAAO;EACL,aAAa,MAAM,SAAS,OAAO,MAAM,IAAI,CAAC,CAAC;EAC/C,aAAa,MAAM,SAAS;GAC1B,MAAM,OAAO,OAAO,MAAM,IAAI,CAAC,CAAC;GAChC,IAAI,SAAS,MAAM,OAAO;GAC1B,MAAM,EAAE,GAAG,GAAG,OAAO,WAAW,aAAa,IAAI;GACjD,OAAO;IAAE;IAAG;IAAG;IAAO;GAAO;EAC/B;CACF;AACF;AAEA,SAAS,QAAQ,MAAe,MAA0B,MAA6D;CACrH,IAAI,KAAK,SAAS,KAAK,QAAQ,KAAK,MAAM,WAAW,KAAK,QAAQ,OAAO;CACzE,IAAI,KAAK,UAAU,QAAQ,KAAK,UAAU,eAAe,GAAG,OAAO;CACnE,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,MAAM,IAAI,KAAK;EACf,IAAI,KAAK,MAAM,OAAO,GAAG,MAAM,OAAO;EACtC,IAAI,MAAM,QAAW;EACrB,IAAI,KAAK,QAAQ,OAAO,EAAE,KAAK,QAAQ,CAAC,cAAc,KAAK,MAAM,IAAI,EAAE,IAAI,GAAG,OAAO;EACrF,IAAI,KAAK,MAAM,OAAO,EAAE,MAAM,OAAO;CACvC;CAEA,IAAI,KAAK,UAAU,MAAM,aAAa;CACtC,OAAO;AACT;;;AAIA,SAAgB,gBACd,MACA,MAC+B;CAC/B,IAAI,OAAO,KAAK,eAAe,YAAY,OAAO;CAClD,OAAO,eAAgB,KAAK,WAAmD,MAAM,IAAI,CAAC,KAAK;AACjG;;;;AAKA,SAAgB,eACd,QACA,SACA,OACA,aASA;CACA,OAAO;EACL,MAAM;EACN;EACA,MAAM;GAAE,GAAG;GAAG,GAAG;GAAG,OAAO;GAAG,QAAQ;EAAE;EACxC,MAAM,EAAE,YAAY,OAAO;EAC3B,WAAW,CAAC,GAAG,OAAO;EACtB,YAAY,YAAY;EACxB,YAAY,YAAY;CAC1B;AACF;;;AAIA,SAAgB,sBAAsB,UAGL;CAC/B,MAAM,aAAa,SAAS,aAAa;CACzC,MAAM,aAAa,SAAS,aAAa;CACzC,OAAO,OAAO,eAAe,cAAc,OAAO,eAAe,aAC7D;EAAE;EAAY;CAAW,IACzB;AACN"}
+{"version":3,"file":"derive.js","names":[],"sources":["../../../../src/core/scene/pathEffects/derive.ts"],"sourcesContent":["/**\n * A path effect as a scene node: a leaf whose `dependsOn` names its sources,\n * whose `data.pathEffect` says what to make of them, and whose path and pose\n * are both derived — the path to paint and pick, the pose as that path's\n * bounds, so selection chrome and marquee see where it is.\n *\n * Reading a source's outline and paint is its painter's business, which sits\n * above the scene, so the derivations are made from a reader:\n * `createPathEffectDerivations(read)`. The canvas layer makes the kit's, and\n * a scene that holds path effects registers them under {@link PATH_EFFECT}.\n */\nimport { boundsOfPath, type Path } from '@weasel-js/geom';\nimport { derivedPartsOf, pathFromParts, type DerivedPart } from '../derivedParts';\nimport { fontGeneration, noteFontRead, withFontReads } from '../fontReads';\nimport { samePoseValue, snapshotPose } from '../poseSnapshot';\nimport type { DerivedDep, NodeId } from '../types';\nimport { effectParts, type PathEffect } from './effects';\nimport type { EffectSourceReader } from './source';\n\n/** The registry key both derivations go by, for `derivePath` and `derivePose`. */\nexport const PATH_EFFECT = 'kit:pathEffect';\n\n/** A node's path effect, or `null` when its data holds none. */\nexport function pathEffectOf(node: { data?: unknown } | undefined): PathEffect | null {\n  const effect = (node?.data as { pathEffect?: PathEffect } | null | undefined)?.pathEffect;\n  return effect && typeof effect === 'object' && typeof effect.kind === 'string' ? effect : null;\n}\n\n/** A path-effect node's two derivations. */\nexport interface PathEffectDerivations {\n  /** What it paints and picks by. */\n  derivePath(node: { data?: unknown }, deps: readonly (DerivedDep<unknown> | undefined)[]): Path | null;\n  /** The bounds of what it paints, or `null` — its authored pose — while it\n   *  paints nothing. */\n  derivePose(node: { data?: unknown }, deps: readonly (DerivedDep<unknown> | undefined)[]): { x: number; y: number; width: number; height: number } | null;\n}\n\ninterface Derived {\n  data: unknown;\n  nodes: unknown[];\n  depData: unknown[];\n  poses: unknown[];\n  paths: (Path | null)[];\n  inherited: unknown[];\n  path: Path | null;\n  /** The face generation it was worked out under, or `null` when it read no\n   *  glyph outlines. */\n  faces: number | null;\n}\n\n/** The derivations of a path effect whose sources `read` reads. */\nexport function createPathEffectDerivations(read: EffectSourceReader): PathEffectDerivations {\n  /** One result per effect node, shared by its two derivations: the pose is\n   *  the path's bounds, and working the effect out twice a frame would double\n   *  its cost. Checked against everything it read, by value for poses — a\n   *  drag's override mutates its pose in place. */\n  const results = new WeakMap<object, Derived>();\n  const derive = (node: { data?: unknown }, deps: readonly (DerivedDep<unknown> | undefined)[]): Derived => {\n    const held = results.get(node);\n    if (held !== undefined && current(held, node, deps)) return held;\n    const effect = pathEffectOf(node);\n    const generation = fontGeneration();\n    const { value: parts, fonts } = withFontReads(() => (effect === null\n      ? null\n      : effectParts(effect, deps.map((d) => (d === undefined ? null : read(d))))));\n    const result: Derived = {\n      data: node.data,\n      nodes: deps.map((d) => d?.node),\n      depData: deps.map((d) => d?.node.data),\n      poses: deps.map((d) => (d === undefined ? undefined : snapshotPose(d.pose))),\n      paths: deps.map((d) => d?.path ?? null),\n      inherited: deps.map((d) => d?.inherited),\n      path: parts === null ? null : pathFromParts(parts),\n      faces: fonts ? generation : null,\n    };\n    results.set(node, result);\n    return result;\n  };\n  return {\n    derivePath: (node, deps) => derive(node, deps).path,\n    derivePose: (node, deps) => {\n      const path = derive(node, deps).path;\n      if (path === null) return null;\n      const { x, y, width, height } = boundsOfPath(path);\n      return { x, y, width, height };\n    },\n  };\n}\n\nfunction current(held: Derived, node: { data?: unknown }, deps: readonly (DerivedDep<unknown> | undefined)[]): boolean {\n  if (held.data !== node.data || held.nodes.length !== deps.length) return false;\n  if (held.faces !== null && held.faces !== fontGeneration()) return false;\n  for (let i = 0; i < deps.length; i++) {\n    const d = deps[i];\n    if (held.nodes[i] !== d?.node) return false;\n    if (d === undefined) continue;\n    if (held.depData[i] !== d.node.data || !samePoseValue(held.poses[i], d.pose)) return false;\n    if (held.paths[i] !== d.path || held.inherited[i] !== d.inherited) return false;\n  }\n  // A hit is still a read, for the scene memo enclosing this one.\n  if (held.faces !== null) noteFontRead();\n  return true;\n}\n\n/** The parts a path-effect node paints, as its sources stand, or `null` when\n *  it has no derivation or nothing to paint. */\nexport function pathEffectParts(\n  node: { data?: unknown; derivePath?: unknown },\n  deps: readonly (DerivedDep<unknown> | undefined)[],\n): readonly DerivedPart[] | null {\n  if (typeof node.derivePath !== 'function') return null;\n  return derivedPartsOf((node.derivePath as PathEffectDerivations['derivePath'])(node, deps)) ?? null;\n}\n\n/** What to hand `Scene.add` (or an insert op) for a path-effect node over\n *  `sources`, in the order its kind reads them, deriving through\n *  `derivations` — the ones the scene registers under {@link PATH_EFFECT}. */\nexport function pathEffectNode<TLayer extends string>(\n  effect: PathEffect,\n  sources: readonly NodeId[],\n  layer: TLayer,\n  derivations: PathEffectDerivations,\n): {\n  kind: 'mark';\n  layer: TLayer;\n  pose: { x: number; y: number; width: number; height: number };\n  data: { pathEffect: PathEffect };\n  dependsOn: readonly NodeId[];\n  derivePath: PathEffectDerivations['derivePath'];\n  derivePose: PathEffectDerivations['derivePose'];\n} {\n  return {\n    kind: 'mark',\n    layer,\n    pose: { x: 0, y: 0, width: 0, height: 0 },\n    data: { pathEffect: effect },\n    dependsOn: [...sources],\n    derivePath: derivations.derivePath,\n    derivePose: derivations.derivePose,\n  };\n}\n\n/** The path-effect derivations `registry` holds under {@link PATH_EFFECT},\n *  or `null` when it holds none. */\nexport function registeredPathEffects(registry: {\n  derivePath?: Readonly<Record<string, unknown>>;\n  derivePose?: Readonly<Record<string, unknown>>;\n}): PathEffectDerivations | null {\n  const derivePath = registry.derivePath?.[PATH_EFFECT];\n  const derivePose = registry.derivePose?.[PATH_EFFECT];\n  return typeof derivePath === 'function' && typeof derivePose === 'function'\n    ? { derivePath, derivePose } as PathEffectDerivations\n    : null;\n}\n"],"mappings":"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"}

package/dist/core/scene/pathEffects/foundHidden.js

@@ -0,0 +1,35 @@
+import { pathEffectOf } from "./derive.js";
+
+//#region src/core/scene/pathEffects/foundHidden.ts
+/**
+* A path effect's `foundHidden` names its sources by position, so a retarget
+* of its `dependsOn` carries the record along: every writer of `dependsOn`
+* goes through `scene.setDependsOn`, which asks this.
+*/
+/**
+* `data` with its path effect's `foundHidden` moved from the positions the
+* sources held in `from` to the ones they hold in `to`, dropping a source
+* `to` no longer names; `null` where nothing moves.
+*/
+function foundHiddenRetargeted(data, from, to) {
+	const effect = pathEffectOf({ data });
+	const found = effect?.foundHidden;
+	if (!effect || !found || found.length === 0) return null;
+	const was = Array.isArray(from) ? from : [];
+	const ids = new Set(found.map((at) => was[at]));
+	const next = (Array.isArray(to) ? to : []).flatMap((id, at) => ids.has(id) ? [at] : []);
+	if (next.length === found.length && next.every((at, k) => at === found[k])) return null;
+	const moved = {
+		...effect,
+		foundHidden: next
+	};
+	if (next.length === 0) delete moved.foundHidden;
+	return {
+		...data,
+		pathEffect: moved
+	};
+}
+
+//#endregion
+export { foundHiddenRetargeted };
+//# sourceMappingURL=foundHidden.js.map

package/dist/core/scene/pathEffects/foundHidden.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"foundHidden.js","names":[],"sources":["../../../../src/core/scene/pathEffects/foundHidden.ts"],"sourcesContent":["/**\n * A path effect's `foundHidden` names its sources by position, so a retarget\n * of its `dependsOn` carries the record along: every writer of `dependsOn`\n * goes through `scene.setDependsOn`, which asks this.\n */\nimport { pathEffectOf } from './derive';\nimport type { PathEffect } from './effects';\n\n/**\n * `data` with its path effect's `foundHidden` moved from the positions the\n * sources held in `from` to the ones they hold in `to`, dropping a source\n * `to` no longer names; `null` where nothing moves.\n */\nexport function foundHiddenRetargeted(data: unknown, from: unknown, to: unknown): unknown {\n  const effect = pathEffectOf({ data });\n  const found = effect?.foundHidden;\n  if (!effect || !found || found.length === 0) return null;\n  const was = Array.isArray(from) ? from : [];\n  const ids = new Set(found.map((at) => was[at]));\n  const next = (Array.isArray(to) ? to : []).flatMap((id, at) => (ids.has(id) ? [at] : []));\n  if (next.length === found.length && next.every((at, k) => at === found[k])) return null;\n  const moved: PathEffect = { ...effect, foundHidden: next };\n  if (next.length === 0) delete moved.foundHidden;\n  return { ...(data as object), pathEffect: moved };\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,SAAgB,sBAAsB,MAAe,MAAe,IAAsB;CACxF,MAAM,SAAS,aAAa,EAAE,KAAK,CAAC;CACpC,MAAM,QAAQ,QAAQ;CACtB,IAAI,CAAC,UAAU,CAAC,SAAS,MAAM,WAAW,GAAG,OAAO;CACpD,MAAM,MAAM,MAAM,QAAQ,IAAI,IAAI,OAAO,CAAC;CAC1C,MAAM,MAAM,IAAI,IAAI,MAAM,KAAK,OAAO,IAAI,GAAG,CAAC;CAC9C,MAAM,QAAQ,MAAM,QAAQ,EAAE,IAAI,KAAK,CAAC,EAAA,CAAG,SAAS,IAAI,OAAQ,IAAI,IAAI,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,CAAE;CACxF,IAAI,KAAK,WAAW,MAAM,UAAU,KAAK,OAAO,IAAI,MAAM,OAAO,MAAM,EAAE,GAAG,OAAO;CACnF,MAAM,QAAoB;EAAE,GAAG;EAAQ,aAAa;CAAK;CACzD,IAAI,KAAK,WAAW,GAAG,OAAO,MAAM;CACpC,OAAO;EAAE,GAAI;EAAiB,YAAY;CAAM;AAClD"}

package/dist/core/scene/plyStacks.js

@@ -0,0 +1,89 @@
+import { carryBoxPath } from "./depFrame.js";
+
+//#region src/core/scene/plyStacks.ts
+/** Empty stacks. */
+function createPlyStacks() {
+	const plies = /* @__PURE__ */ new Map();
+	/** Each entry's claim, in claiming order; outlives a full drop, so a reinstall goes back in place. */
+	const claims = /* @__PURE__ */ new WeakMap();
+	let claimed = 0;
+	/** How many nodes hold each number of plies. */
+	const sizes = [];
+	let deepest = 0;
+	const resized = (from, to) => {
+		if (from > 0) sizes[from]--;
+		if (to > 0) sizes[to] = (sizes[to] ?? 0) + 1;
+		if (to > deepest) deepest = to;
+		while (deepest > 0 && (sizes[deepest] ?? 0) === 0) deepest--;
+	};
+	return {
+		plies,
+		claim(id, entry) {
+			let stack = plies.get(id);
+			if (stack === void 0) plies.set(id, stack = []);
+			const at = stack.indexOf(entry);
+			if (at >= 0) stack.splice(at, 1);
+			let claim = at >= 0 ? void 0 : claims.get(entry);
+			if (claim === void 0) claims.set(entry, claim = ++claimed);
+			let i = stack.length;
+			while (i > 0 && claims.get(stack[i - 1]) > claim) i--;
+			stack.splice(i, 0, entry);
+			if (at < 0) resized(stack.length - 1, stack.length);
+		},
+		release(id, entry) {
+			claims.delete(entry);
+			const stack = plies.get(id);
+			const at = stack?.indexOf(entry) ?? -1;
+			if (stack === void 0 || at < 0) return false;
+			stack.splice(at, 1);
+			resized(stack.length + 1, stack.length);
+			if (stack.length === 0) plies.delete(id);
+			return true;
+		},
+		drop(id) {
+			const stack = plies.get(id);
+			if (stack === void 0) return false;
+			plies.delete(id);
+			resized(stack.length, 0);
+			return true;
+		},
+		dropAll() {
+			plies.clear();
+			sizes.length = 0;
+			deepest = 0;
+		},
+		depth: () => Math.max(deepest, 1)
+	};
+}
+var boxOf = (pose) => {
+	const p = pose;
+	return p !== null && typeof p === "object" && typeof p.x === "number" && typeof p.y === "number" && typeof p.width === "number" && typeof p.height === "number" ? p : null;
+};
+var sameBox = (a, b) => a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+/**
+* The path `stack` shows, folded to `pose`: the topmost ply's path, in the box of the pose
+* that ply gives beside it, carried to `pose` where a ply above gives another. A path given
+* with no pose of its own is drawn where it is. `held` keeps the last carry.
+*/
+function plyPath(stack, pose, held) {
+	for (let k = stack.length - 1; k >= 0; k--) {
+		const ply = stack[k];
+		if (ply.path === void 0) continue;
+		const from = boxOf(ply.pose);
+		const to = boxOf(pose);
+		if (from === null || to === null || sameBox(from, to)) return ply.path;
+		const last = held.carried;
+		if (last !== void 0 && last.source === ply.path && sameBox(last.from, from) && sameBox(last.to, to)) return last.path;
+		held.carried = {
+			source: ply.path,
+			from: { ...from },
+			to: { ...to },
+			path: carryBoxPath(ply.path, from, to)
+		};
+		return held.carried.path;
+	}
+}
+
+//#endregion
+export { createPlyStacks, plyPath };
+//# sourceMappingURL=plyStacks.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plyStacks.js","names":[],"sources":["../../../src/core/scene/plyStacks.ts"],"sourcesContent":["/**\n * Each node's plies of overrides, kept in the order their writers claimed\n * the node, and the path a stack shows.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { carryBoxPath } from './depFrame';\nimport type { NodeId, PoseOverride } from './types';\n\n/** {@link createPlyStacks}'s handle. */\nexport interface PlyStacks<Entry> {\n  /** Per node, its plies bottom first. */\n  readonly plies: ReadonlyMap<NodeId, readonly Entry[]>;\n  /** Install `entry` on `id`: on top, or where it stood when a full drop took it off. An\n   *  installed entry moves to the top. */\n  claim(id: NodeId, entry: Entry): void;\n  /** Take `entry` off `id` and forget where it stood. Whether it was installed. */\n  release(id: NodeId, entry: Entry): boolean;\n  /** Take every ply off `id`, each keeping its place for when its writer reinstalls it.\n   *  Whether the node had any. */\n  drop(id: NodeId): boolean;\n  /** {@link PlyStacks.drop} for every node. */\n  dropAll(): void;\n  /** The deepest stack, and at least 1. */\n  depth(): number;\n}\n\n/** Empty stacks. */\nexport function createPlyStacks<Entry extends object>(): PlyStacks<Entry> {\n  const plies = new Map<NodeId, Entry[]>();\n  /** Each entry's claim, in claiming order; outlives a full drop, so a reinstall goes back in place. */\n  const claims = new WeakMap<Entry, number>();\n  let claimed = 0;\n  /** How many nodes hold each number of plies. */\n  const sizes: number[] = [];\n  let deepest = 0;\n\n  const resized = (from: number, to: number): void => {\n    if (from > 0) sizes[from]!--;\n    if (to > 0) sizes[to] = (sizes[to] ?? 0) + 1;\n    if (to > deepest) deepest = to;\n    while (deepest > 0 && (sizes[deepest] ?? 0) === 0) deepest--;\n  };\n\n  return {\n    plies,\n    claim(id, entry) {\n      let stack = plies.get(id);\n      if (stack === undefined) plies.set(id, stack = []);\n      const at = stack.indexOf(entry);\n      if (at >= 0) stack.splice(at, 1);\n      let claim = at >= 0 ? undefined : claims.get(entry);\n      if (claim === undefined) claims.set(entry, claim = ++claimed);\n      let i = stack.length;\n      while (i > 0 && claims.get(stack[i - 1]!)! > claim) i--;\n      stack.splice(i, 0, entry);\n      if (at < 0) resized(stack.length - 1, stack.length);\n    },\n    release(id, entry) {\n      claims.delete(entry);\n      const stack = plies.get(id);\n      const at = stack?.indexOf(entry) ?? -1;\n      if (stack === undefined || at < 0) return false;\n      stack.splice(at, 1);\n      resized(stack.length + 1, stack.length);\n      if (stack.length === 0) plies.delete(id);\n      return true;\n    },\n    drop(id) {\n      const stack = plies.get(id);\n      if (stack === undefined) return false;\n      plies.delete(id);\n      resized(stack.length, 0);\n      return true;\n    },\n    dropAll() {\n      plies.clear();\n      sizes.length = 0;\n      deepest = 0;\n    },\n    depth: () => Math.max(deepest, 1),\n  };\n}\n\ntype Box = { x: number; y: number; width: number; height: number };\n\nconst boxOf = (pose: unknown): Box | null => {\n  const p = pose as Partial<Box> | null;\n  return p !== null && typeof p === 'object' && typeof p.x === 'number' && typeof p.y === 'number'\n    && typeof p.width === 'number' && typeof p.height === 'number'\n    ? p as Box : null;\n};\n\nconst sameBox = (a: Box, b: Box): boolean => a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;\n\n/** A carried path and what it was carried from and to, so a stack whose poses hold still shows one path. */\nexport interface CarriedPath {\n  source: Path;\n  from: Box;\n  to: Box;\n  path: Path;\n}\n\n/**\n * The path `stack` shows, folded to `pose`: the topmost ply's path, in the box of the pose\n * that ply gives beside it, carried to `pose` where a ply above gives another. A path given\n * with no pose of its own is drawn where it is. `held` keeps the last carry.\n */\nexport function plyPath<TPose, TData>(\n  stack: readonly PoseOverride<TPose, TData>[],\n  pose: TPose | undefined,\n  held: { carried?: CarriedPath },\n): Path | undefined {\n  for (let k = stack.length - 1; k >= 0; k--) {\n    const ply = stack[k]!;\n    if (ply.path === undefined) continue;\n    const from = boxOf(ply.pose);\n    const to = boxOf(pose);\n    if (from === null || to === null || sameBox(from, to)) return ply.path;\n    const last = held.carried;\n    if (last !== undefined && last.source === ply.path && sameBox(last.from, from) && sameBox(last.to, to)) return last.path;\n    held.carried = { source: ply.path, from: { ...from }, to: { ...to }, path: carryBoxPath(ply.path, from, to) };\n    return held.carried.path;\n  }\n  return undefined;\n}\n"],"mappings":"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"}

package/dist/core/scene/poseHold.js

@@ -1,47 +1,65 @@
 //#region src/core/scene/poseHold.ts
-/** Build the {@link PoseHold} a table hands out from `hold()`. */
-function createPoseHold(table) {
+/** Build the {@link PoseHold} a table hands out from `hold()`. `pliesOf`
+*  answers a node's plies, bottom first. */
+function createPoseHold(table, pliesOf) {
 	/** The entry published per id, held by reference so a frame mutates it in place. */
 	const held = /* @__PURE__ */ new Map();
 	const seen = /* @__PURE__ */ new Set();
+	const publish = (frame) => {
+		seen.clear();
+		for (const [id, shown] of frame) {
+			seen.add(id);
+			const existing = held.get(id);
+			if (existing) {
+				existing.pose = shown.pose;
+				existing.data = shown.data;
+				if (!table.has(id, existing)) table.set(id, existing);
+				continue;
+			}
+			const entry = {
+				pose: shown.pose,
+				data: shown.data
+			};
+			held.set(id, entry);
+			table.set(id, entry);
+		}
+		for (const [id, entry] of held) {
+			if (seen.has(id)) continue;
+			held.delete(id);
+			table.clear(id, entry);
+		}
+		table.commit();
+	};
 	return {
 		set(poses) {
-			seen.clear();
-			for (const [id, pose] of poses) {
-				seen.add(id);
-				const existing = held.get(id);
-				if (existing) {
-					existing.pose = pose;
-					continue;
-				}
-				const entry = { pose };
-				held.set(id, entry);
-				table.set(id, entry);
-			}
-			for (const [id, entry] of held) {
-				if (seen.has(id)) continue;
-				held.delete(id);
-				if (table.get(id) === entry) table.clear(id);
-			}
-			table.commit();
+			publish(mapped(poses));
 		},
+		show: publish,
 		others() {
 			const out = /* @__PURE__ */ new Map();
 			for (const id of table.ids()) {
-				const entry = table.get(id);
-				if (entry === void 0 || entry === held.get(id) || entry.pose === void 0) continue;
-				out.set(id, entry.pose);
+				const stack = pliesOf(id) ?? [];
+				const mine = held.get(id);
+				for (let k = stack.length - 1; k >= 0; k--) {
+					const entry = stack[k];
+					if (entry === mine || entry.pose === void 0) continue;
+					out.set(id, entry.pose);
+					break;
+				}
 			}
 			return out;
 		},
 		drop() {
 			if (held.size === 0) return;
-			for (const [id, entry] of held) if (table.get(id) === entry) table.clear(id);
+			for (const [id, entry] of held) table.clear(id, entry);
 			held.clear();
 			table.commit();
 		}
 	};
 }
+function* mapped(poses) {
+	for (const [id, pose] of poses) yield [id, { pose }];
+}
 
 //#endregion
 export { createPoseHold };

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

@@ -1 +1 @@
-{"version":3,"file":"poseHold.js","names":[],"sources":["../../../src/core/scene/poseHold.ts"],"sourcesContent":["import type { NodeId, PoseHold, PoseOverride, PoseOverrides } from './types';\n\n/** The table methods a hold writes through. */\ntype HoldTable<TPose> = Pick<PoseOverrides<TPose>, 'set' | 'get' | 'ids' | 'clear' | 'commit'>;\n\n/** Build the {@link PoseHold} a table hands out from `hold()`. */\nexport function createPoseHold<TPose>(table: HoldTable<TPose>): PoseHold<TPose> {\n  /** The entry published per id, held by reference so a frame mutates it in place. */\n  const held = new Map<NodeId, PoseOverride<TPose>>();\n  const seen = new Set<NodeId>();\n\n  return {\n    set(poses) {\n      seen.clear();\n      for (const [id, pose] of poses) {\n        seen.add(id);\n        const existing = held.get(id);\n        if (existing) {\n          existing.pose = pose;\n          continue;\n        }\n        const entry: PoseOverride<TPose> = { pose };\n        held.set(id, entry);\n        // `table.set` notifies per call, so an id is set once and mutated after.\n        table.set(id, entry);\n      }\n      for (const [id, entry] of held) {\n        if (seen.has(id)) continue;\n        held.delete(id);\n        if (table.get(id) === entry) table.clear(id);\n      }\n      table.commit();\n    },\n    others() {\n      const out = new Map<NodeId, TPose>();\n      for (const id of table.ids()) {\n        const entry = table.get(id);\n        if (entry === undefined || entry === held.get(id) || entry.pose === undefined) continue;\n        out.set(id, entry.pose);\n      }\n      return out;\n    },\n    drop() {\n      if (held.size === 0) return;\n      for (const [id, entry] of held) {\n        if (table.get(id) === entry) table.clear(id);\n      }\n      held.clear();\n      table.commit();\n    },\n  };\n}\n"],"mappings":";;AAMA,SAAgB,eAAsB,OAA0C;;CAE9E,MAAM,uBAAO,IAAI,IAAiC;CAClD,MAAM,uBAAO,IAAI,IAAY;CAE7B,OAAO;EACL,IAAI,OAAO;GACT,KAAK,MAAM;GACX,KAAK,MAAM,CAAC,IAAI,SAAS,OAAO;IAC9B,KAAK,IAAI,EAAE;IACX,MAAM,WAAW,KAAK,IAAI,EAAE;IAC5B,IAAI,UAAU;KACZ,SAAS,OAAO;KAChB;IACF;IACA,MAAM,QAA6B,EAAE,KAAK;IAC1C,KAAK,IAAI,IAAI,KAAK;IAElB,MAAM,IAAI,IAAI,KAAK;GACrB;GACA,KAAK,MAAM,CAAC,IAAI,UAAU,MAAM;IAC9B,IAAI,KAAK,IAAI,EAAE,GAAG;IAClB,KAAK,OAAO,EAAE;IACd,IAAI,MAAM,IAAI,EAAE,MAAM,OAAO,MAAM,MAAM,EAAE;GAC7C;GACA,MAAM,OAAO;EACf;EACA,SAAS;GACP,MAAM,sBAAM,IAAI,IAAmB;GACnC,KAAK,MAAM,MAAM,MAAM,IAAI,GAAG;IAC5B,MAAM,QAAQ,MAAM,IAAI,EAAE;IAC1B,IAAI,UAAU,UAAa,UAAU,KAAK,IAAI,EAAE,KAAK,MAAM,SAAS,QAAW;IAC/E,IAAI,IAAI,IAAI,MAAM,IAAI;GACxB;GACA,OAAO;EACT;EACA,OAAO;GACL,IAAI,KAAK,SAAS,GAAG;GACrB,KAAK,MAAM,CAAC,IAAI,UAAU,MACxB,IAAI,MAAM,IAAI,EAAE,MAAM,OAAO,MAAM,MAAM,EAAE;GAE7C,KAAK,MAAM;GACX,MAAM,OAAO;EACf;CACF;AACF"}
+{"version":3,"file":"poseHold.js","names":[],"sources":["../../../src/core/scene/poseHold.ts"],"sourcesContent":["import type { NodeId, PoseHold, PoseOverride, PoseOverrides, ShownOverride } from './types';\n\n/** The table methods a hold writes through. */\ntype HoldTable<TPose, TData> = Pick<PoseOverrides<TPose, TData>, 'set' | 'has' | 'ids' | 'clear' | 'commit'>;\n\n/** Build the {@link PoseHold} a table hands out from `hold()`. `pliesOf`\n *  answers a node's plies, bottom first. */\nexport function createPoseHold<TPose, TData = unknown>(\n  table: HoldTable<TPose, TData>,\n  pliesOf: (id: NodeId) => readonly PoseOverride<TPose, TData>[] | undefined,\n): PoseHold<TPose, TData> {\n  /** The entry published per id, held by reference so a frame mutates it in place. */\n  const held = new Map<NodeId, PoseOverride<TPose, TData>>();\n  const seen = new Set<NodeId>();\n\n  const publish = (frame: Iterable<readonly [NodeId, ShownOverride<TPose, TData>]>): void => {\n    seen.clear();\n    for (const [id, shown] of frame) {\n      seen.add(id);\n      const existing = held.get(id);\n      if (existing) {\n        existing.pose = shown.pose;\n        existing.data = shown.data;\n        // The table drops a node's plies on its own when the node goes; put back the node, and the frame goes back too.\n        if (!table.has(id, existing)) table.set(id, existing);\n        continue;\n      }\n      const entry: PoseOverride<TPose, TData> = { pose: shown.pose, data: shown.data };\n      held.set(id, entry);\n      // `table.set` notifies per call, so an id is set once and mutated after.\n      table.set(id, entry);\n    }\n    for (const [id, entry] of held) {\n      if (seen.has(id)) continue;\n      held.delete(id);\n      table.clear(id, entry);\n    }\n    table.commit();\n  };\n\n  return {\n    set(poses) {\n      publish(mapped(poses));\n    },\n    show: publish,\n    others() {\n      const out = new Map<NodeId, TPose>();\n      for (const id of table.ids()) {\n        const stack = pliesOf(id) ?? [];\n        const mine = held.get(id);\n        for (let k = stack.length - 1; k >= 0; k--) {\n          const entry = stack[k]!;\n          if (entry === mine || entry.pose === undefined) continue;\n          out.set(id, entry.pose);\n          break;\n        }\n      }\n      return out;\n    },\n    drop() {\n      if (held.size === 0) return;\n      for (const [id, entry] of held) table.clear(id, entry);\n      held.clear();\n      table.commit();\n    },\n  };\n}\n\nfunction* mapped<TPose, TData>(poses: Iterable<readonly [NodeId, TPose]>): Iterable<readonly [NodeId, ShownOverride<TPose, TData>]> {\n  for (const [id, pose] of poses) yield [id, { pose }];\n}\n"],"mappings":";;;AAOA,SAAgB,eACd,OACA,SACwB;;CAExB,MAAM,uBAAO,IAAI,IAAwC;CACzD,MAAM,uBAAO,IAAI,IAAY;CAE7B,MAAM,WAAW,UAA0E;EACzF,KAAK,MAAM;EACX,KAAK,MAAM,CAAC,IAAI,UAAU,OAAO;GAC/B,KAAK,IAAI,EAAE;GACX,MAAM,WAAW,KAAK,IAAI,EAAE;GAC5B,IAAI,UAAU;IACZ,SAAS,OAAO,MAAM;IACtB,SAAS,OAAO,MAAM;IAEtB,IAAI,CAAC,MAAM,IAAI,IAAI,QAAQ,GAAG,MAAM,IAAI,IAAI,QAAQ;IACpD;GACF;GACA,MAAM,QAAoC;IAAE,MAAM,MAAM;IAAM,MAAM,MAAM;GAAK;GAC/E,KAAK,IAAI,IAAI,KAAK;GAElB,MAAM,IAAI,IAAI,KAAK;EACrB;EACA,KAAK,MAAM,CAAC,IAAI,UAAU,MAAM;GAC9B,IAAI,KAAK,IAAI,EAAE,GAAG;GAClB,KAAK,OAAO,EAAE;GACd,MAAM,MAAM,IAAI,KAAK;EACvB;EACA,MAAM,OAAO;CACf;CAEA,OAAO;EACL,IAAI,OAAO;GACT,QAAQ,OAAO,KAAK,CAAC;EACvB;EACA,MAAM;EACN,SAAS;GACP,MAAM,sBAAM,IAAI,IAAmB;GACnC,KAAK,MAAM,MAAM,MAAM,IAAI,GAAG;IAC5B,MAAM,QAAQ,QAAQ,EAAE,KAAK,CAAC;IAC9B,MAAM,OAAO,KAAK,IAAI,EAAE;IACxB,KAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK;KAC1C,MAAM,QAAQ,MAAM;KACpB,IAAI,UAAU,QAAQ,MAAM,SAAS,QAAW;KAChD,IAAI,IAAI,IAAI,MAAM,IAAI;KACtB;IACF;GACF;GACA,OAAO;EACT;EACA,OAAO;GACL,IAAI,KAAK,SAAS,GAAG;GACrB,KAAK,MAAM,CAAC,IAAI,UAAU,MAAM,MAAM,MAAM,IAAI,KAAK;GACrD,KAAK,MAAM;GACX,MAAM,OAAO;EACf;CACF;AACF;AAEA,UAAU,OAAqB,OAAqG;CAClI,KAAK,MAAM,CAAC,IAAI,SAAS,OAAO,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC;AACrD"}