@weasel-js/core 1.11.1 → 1.13.0-rc.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"nodeAsShown.js","names":[],"sources":["../../../src/core/scene/nodeAsShown.ts"],"sourcesContent":["/**\n * `nodeAsShown` — a node with the data its override shows it with.\n *\n * The one read of `PoseOverride.data`. Painting, picking, drawn bounds and the\n * effective reading of a derivation go through it; the document reading\n * (`documentOf`), history and `scene.get` never do.\n */\nimport type { NodeId } from './types';\n\n/** What `nodeAsShown` reads of the overrides: a `Scene`'s satisfy it. */\nexport interface ShownDataSource {\n  read(id: NodeId): { data?(stored: never): unknown } | undefined;\n}\n\n/** Marks a node whose data is already shown. An own enumerable key, so a spread\n *  of the node (`{ ...node, pose }`) carries it, and applying an override to a\n *  copy of a shown node is a no-op however the copy was made. */\nconst SHOWN: unique symbol = Symbol('weasel.shownData');\n\ninterface Held {\n  stored: unknown;\n  data: (stored: never) => unknown;\n  shown: object;\n}\n\n/** Per stored node, the last shown copy and what it was made from: keeping it\n *  is what lets a memo keyed on the node, or on its data, hit frame to frame\n *  while neither changes. */\nconst shownCopies = new WeakMap<object, Held>();\n\n/**\n * `node` with its `data` replaced by what its override's `data` answers from\n * it, or `node` itself when nothing overrides its data or its data is already\n * shown. The same object while the stored node, its data and the override's\n * function are unchanged.\n */\nexport function nodeAsShown<TNode extends { id: NodeId; data?: unknown }>(\n  overrides: ShownDataSource,\n  node: TNode,\n): TNode {\n  if (SHOWN in node) return node;\n  const data = overrides.read(node.id)?.data;\n  if (data === undefined) return node;\n  const held = shownCopies.get(node);\n  if (held !== undefined && held.data === data && held.stored === node.data) return held.shown as TNode;\n  const shown = withShownData(node, data(node.data as never));\n  shownCopies.set(node, { stored: node.data, data, shown });\n  return shown;\n}\n\n/** `node` showing `data`, marked so that no override applies to it again: for\n *  a reader that already holds the data to show, such as a gesture's ghost. */\nexport function withShownData<TNode extends object>(node: TNode, data: unknown): TNode {\n  return { ...node, data, [SHOWN]: true };\n}\n\n/** The last copy `nodeAsShown` made of `node`, if any — what a reader handed\n *  the shown node memoized against, for invalidating with the stored one. */\nexport function shownCopyOf(node: object): object | undefined {\n  return shownCopies.get(node)?.shown;\n}\n\n/** `source`'s `get`, answering each node as it shows. For a reader that walks\n *  up from a node, such as inherited paint looking through its containers. */\nexport function shownLookup<TNode extends { id: NodeId; data?: unknown }>(\n  source: { overrides: ShownDataSource; get(id: NodeId): TNode | undefined },\n): { get(id: NodeId): TNode | undefined } {\n  return {\n    get: (id) => {\n      const node = source.get(id);\n      return node === undefined ? undefined : nodeAsShown(source.overrides, node);\n    },\n  };\n}\n\ntype CountedSource = ShownDataSource & { ids(): readonly NodeId[]; getGeneration(): number };\n\n/** Per overrides table, whether any entry shows data, as of a generation. */\nconst anyData = new WeakMap<object, { at: number; any: boolean }>();\n\n/** `nodes`, each as it shows; the same array when nothing overrides any node's\n *  data. Answers that from the table's generation, so a pick with nothing\n *  overridden allocates nothing. */\nexport function nodesAsShown<TNode extends { id: NodeId; data?: unknown }>(\n  overrides: CountedSource,\n  nodes: readonly TNode[],\n): readonly TNode[] {\n  const at = overrides.getGeneration();\n  let held = anyData.get(overrides);\n  if (held === undefined || held.at !== at) {\n    held = { at, any: overrides.ids().some((id) => overrides.read(id)?.data !== undefined) };\n    anyData.set(overrides, held);\n  }\n  return held.any ? nodes.map((node) => nodeAsShown(overrides, node)) : nodes;\n}\n"],"mappings":";;;;AAiBA,IAAM,QAAuB,OAAO,kBAAkB;;;;AAWtD,IAAM,8BAAc,IAAI,QAAsB;;;;;;;AAQ9C,SAAgB,YACd,WACA,MACO;CACP,IAAI,SAAS,MAAM,OAAO;CAC1B,MAAM,OAAO,UAAU,KAAK,KAAK,EAAE,CAAC,EAAE;CACtC,IAAI,SAAS,QAAW,OAAO;CAC/B,MAAM,OAAO,YAAY,IAAI,IAAI;CACjC,IAAI,SAAS,UAAa,KAAK,SAAS,QAAQ,KAAK,WAAW,KAAK,MAAM,OAAO,KAAK;CACvF,MAAM,QAAQ,cAAc,MAAM,KAAK,KAAK,IAAa,CAAC;CAC1D,YAAY,IAAI,MAAM;EAAE,QAAQ,KAAK;EAAM;EAAM;CAAM,CAAC;CACxD,OAAO;AACT;;;AAIA,SAAgB,cAAoC,MAAa,MAAsB;CACrF,OAAO;EAAE,GAAG;EAAM;GAAO,QAAQ;CAAK;AACxC;;;AAIA,SAAgB,YAAY,MAAkC;CAC5D,OAAO,YAAY,IAAI,IAAI,CAAC,EAAE;AAChC;;;AAIA,SAAgB,YACd,QACwC;CACxC,OAAO,EACL,MAAM,OAAO;EACX,MAAM,OAAO,OAAO,IAAI,EAAE;EAC1B,OAAO,SAAS,SAAY,SAAY,YAAY,OAAO,WAAW,IAAI;CAC5E,EACF;AACF;;AAKA,IAAM,0BAAU,IAAI,QAA8C;;;;AAKlE,SAAgB,aACd,WACA,OACkB;CAClB,MAAM,KAAK,UAAU,cAAc;CACnC,IAAI,OAAO,QAAQ,IAAI,SAAS;CAChC,IAAI,SAAS,UAAa,KAAK,OAAO,IAAI;EACxC,OAAO;GAAE;GAAI,KAAK,UAAU,IAAI,CAAC,CAAC,MAAM,OAAO,UAAU,KAAK,EAAE,CAAC,EAAE,SAAS,MAAS;EAAE;EACvF,QAAQ,IAAI,WAAW,IAAI;CAC7B;CACA,OAAO,KAAK,MAAM,MAAM,KAAK,SAAS,YAAY,WAAW,IAAI,CAAC,IAAI;AACxE"}

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

@@ -8,8 +8,8 @@ var MEMO = /* @__PURE__ */ new WeakMap();
 var generation = 0;
 /**
 * Return the value `derive` produces for `node`, recomputing only when the
-* node's `data` reference, the given `pose` reference, or the global
-* generation has changed since the last call for this `slot`.
+* node's `data` reference, the given `pose` reference, the `also` reference,
+* or the global generation has changed since the last call for this `slot`.
 *
 * `slot` names the derivation, so a node's several derived values do not
 * overwrite each other.
@@ -18,9 +18,13 @@ var generation = 0;
 * legitimately derive against a pose that isn't `node.pose`: a preview or
 * ghost pose mid-drag. Pass `undefined` for derivations that don't depend on
 * the pose at all, leaving `data` as the only key.
+*
+* `also` is for an input that lives outside the node, such as the paint a
+* node inherits from its container. It must be a reference its owner keeps
+* while the input is unchanged.
 */
-function nodeMemo(node, slot, pose, derive) {
-	if (typeof slot !== "string") return scopedNodeMemo(node, slot, pose, derive);
+function nodeMemo(node, slot, pose, derive, also) {
+	if (typeof slot !== "string") return scopedNodeMemo(node, slot, pose, derive, also);
 	let record = MEMO.get(node);
 	if (record === void 0) {
 		record = {
@@ -35,36 +39,40 @@ function nodeMemo(node, slot, pose, derive) {
 	}
 	const data = node.data;
 	const hit = record.slots.get(slot);
-	if (hit !== void 0 && hit.pose === pose && hit.data === data) return hit.value;
+	if (hit !== void 0 && hit.pose === pose && hit.data === data && hit.also === also) return hit.value;
 	const value = derive();
 	if (hit !== void 0) {
 		hit.pose = pose;
 		hit.data = data;
+		hit.also = also;
 		hit.value = value;
 	} else record.slots.set(slot, {
 		pose,
 		data,
+		also,
 		value
 	});
 	return value;
 }
-function scopedNodeMemo(node, scope, pose, derive) {
+function scopedNodeMemo(node, scope, pose, derive, also) {
 	const entries = scope;
 	const data = node.data;
 	const drops = MEMO.get(node)?.drops ?? 0;
 	const hit = entries.get(node);
-	if (hit !== void 0 && hit.generation === generation && hit.pose === pose && hit.data === data && (pose === void 0 || hit.drops === drops)) return hit.value;
+	if (hit !== void 0 && hit.generation === generation && hit.pose === pose && hit.data === data && hit.also === also && (pose === void 0 || hit.drops === drops)) return hit.value;
 	const value = derive();
 	const dropsNow = MEMO.get(node)?.drops ?? 0;
 	if (hit !== void 0) {
 		hit.pose = pose;
 		hit.data = data;
+		hit.also = also;
 		hit.value = value;
 		hit.generation = generation;
 		hit.drops = dropsNow;
 	} else entries.set(node, {
 		pose,
 		data,
+		also,
 		value,
 		generation,
 		drops: dropsNow
@@ -78,6 +86,11 @@ function scopedNodeMemo(node, scope, pose, derive) {
 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.
@@ -102,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  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, or the global\n * 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 */\nexport function nodeMemo<T>(\n  node: MemoizableNode,\n  slot: string | NodeMemoScope,\n  pose: unknown,\n  derive: () => T,\n): T {\n  if (typeof slot !== 'string') return scopedNodeMemo(node, slot, pose, derive);\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) {\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.value = value;\n  } else {\n    record.slots.set(slot, { pose, data, value });\n  }\n  return value;\n}\n\nfunction scopedNodeMemo<T>(\n  node: MemoizableNode,\n  scope: NodeMemoScope,\n  pose: unknown,\n  derive: () => T,\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    && (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.value = value;\n    hit.generation = generation;\n    hit.drops = dropsNow;\n  } else {\n    entries.set(node, { pose, data, 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":";AAuDA,SAAgB,sBAAqC;CACnD,uBAAO,IAAI,QAA4B;AACzC;AAEA,IAAM,uBAAO,IAAI,QAAgC;;;AAIjD,IAAI,aAAa;;;;;;;;;;;;;;AAmBjB,SAAgB,SACd,MACA,MACA,MACA,QACG;CACH,IAAI,OAAO,SAAS,UAAU,OAAO,eAAe,MAAM,MAAM,MAAM,MAAM;CAC5E,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,MACzD,OAAO,IAAI;CAGb,MAAM,QAAQ,OAAO;CAGrB,IAAI,QAAQ,QAAW;EACrB,IAAI,OAAO;EACX,IAAI,OAAO;EACX,IAAI,QAAQ;CACd,OACE,OAAO,MAAM,IAAI,MAAM;EAAE;EAAM;EAAM;CAAM,CAAC;CAE9C,OAAO;AACT;AAEA,SAAS,eACP,MACA,OACA,MACA,QACG;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,SACpF,SAAS,UAAa,IAAI,UAAU,QAExC,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,QAAQ;EACZ,IAAI,aAAa;EACjB,IAAI,QAAQ;CACd,OACE,QAAQ,IAAI,MAAM;EAAE;EAAM;EAAM;EAAO;EAAY,OAAO;CAAS,CAAC;CAEtE,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":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"blend.js","names":[],"sources":["../../../../src/core/scene/pathEffects/blend.ts"],"sourcesContent":["/**\n * A blend's steps: where each sits between its two sources — evenly by\n * count, or a fixed distance apart — and, with a spine, laid along it.\n */\nimport {\n  boundsOfPath, measurePath, multiply, prepareBlend, rotate, rotatePathAround, transformPath, translate,\n  type BlendPathsOptions, type Path, type PathMeasure,\n} from '@weasel-js/geom';\nimport { lerpFill, lerpStroke } from '@weasel-js/paint';\nimport type { DerivedPart } from '../derivedParts';\nimport type { EffectSource } from './source';\n\n/** Steps between two shapes. Its sources are `[from, to]`, or\n *  `[from, to, spine]` to lay the steps along a third path. */\nexport interface BlendEffect extends BlendPathsOptions {\n  kind: 'blend';\n  /** How many shapes stand between the two sources, spacing by count. */\n  steps: number;\n  /**\n   * How the steps are spaced. `'count'` puts `steps` of them evenly between\n   * the sources; `'distance'` puts one every `distance` along the run from\n   * the first source, as many as fit short of the second, so the last gap is\n   * whatever is left. Default `'count'`.\n   */\n  spaceBy?: 'count' | 'distance';\n  /** Distance from one shape's middle to the next, spacing by distance —\n   *  along the spine where there is one. Spacing by count when unset. */\n  distance?: number;\n  /**\n   * Interpolate each source's rotation as a turn about its middle, rather\n   * than moving every point in a straight line — so a shape turned 90° at\n   * one end turns through 45° halfway instead of shrinking there. Default\n   * `true`; it applies where both sources are turned boxes.\n   */\n  rotate?: boolean;\n  /** With a spine, turn each step by how far the spine's heading where it\n   *  sits differs from the straight run between the sources. Default\n   *  `false`, which only moves them. */\n  orient?: boolean;\n}\n\nconst EPS = 1e-9;\n\n/** The fractions of the way from the first source to the second that the\n *  steps sit at, over a run `length` long. */\nexport function blendStations(effect: BlendEffect, length: number): number[] {\n  const out: number[] = [];\n  const d = effect.distance;\n  if (effect.spaceBy === 'distance' && d !== undefined && d > 0) {\n    if (!(length > 0)) return out;\n    for (let s = d; s < length - EPS * Math.max(length, 1); s += d) out.push(s / length);\n    return out;\n  }\n  const steps = Math.max(Math.floor(effect.steps), 0);\n  for (let i = 1; i <= steps; i++) out.push(i / (steps + 1));\n  return out;\n}\n\n/** The middle a source's steps are interpolated about: its turn's center\n *  where it is a turned box, else its outline's bounds' middle. */\nfunction middleOf(source: EffectSource): { x: number; y: number } {\n  if (source.framed) return { x: source.framed.cx, y: source.framed.cy };\n  const b = boundsOfPath(source.world);\n  return { x: b.x + b.width / 2, y: b.y + b.height / 2 };\n}\n\n/** The parts of `effect` between `a` and `b`, along `spine` when given.\n *  `null` when the spine has no length to measure. */\nexport function blendParts(effect: BlendEffect, a: EffectSource, b: EffectSource, spine?: Path): DerivedPart[] | null {\n  const from = middleOf(a);\n  const to = middleOf(b);\n  const along: PathMeasure | null = spine === undefined ? null : measurePath(spine);\n  if (spine !== undefined && along === null) return null;\n  const stations = blendStations(effect, along ? along.length : Math.hypot(to.x - from.x, to.y - from.y));\n  if (stations.length === 0) return [];\n\n  const turned = (effect.rotate ?? true) && a.framed !== undefined && b.framed !== undefined\n    ? { a: a.framed, b: b.framed }\n    : null;\n  const blend = turned\n    ? prepareBlend(turned.a.path, turned.b.path, effect)\n    : prepareBlend(a.world, b.world, effect);\n  // The shorter way round, so a turn of 350° reads as -10°.\n  const turn = turned\n    ? Math.atan2(Math.sin(turned.b.rotation - turned.a.rotation), Math.cos(turned.b.rotation - turned.a.rotation))\n    : 0;\n  const chord = Math.atan2(to.y - from.y, to.x - from.x);\n  return stations.map((t) => {\n    let path: Path = blend.at(t);\n    if (turned) {\n      const cx = turned.a.cx + (turned.b.cx - turned.a.cx) * t;\n      const cy = turned.a.cy + (turned.b.cy - turned.a.cy) * t;\n      const rotation = turned.a.rotation + turn * t;\n      if (rotation !== 0) path = rotatePathAround(path, cx, cy, rotation);\n    }\n    if (along) {\n      const { point, tangent } = along.at(t * along.length);\n      const angle = effect.orient ? Math.atan2(tangent.y, tangent.x) - chord : 0;\n      const middle = { x: from.x + (to.x - from.x) * t, y: from.y + (to.y - from.y) * t };\n      path = transformPath(path, multiply(translate(point.x, point.y), multiply(rotate(angle), translate(-middle.x, -middle.y))));\n    }\n    return { path, fill: lerpFill(a.fill, b.fill, t) ?? null, stroke: lerpStroke(a.stroke, b.stroke, t) ?? null };\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"blend.js","names":[],"sources":["../../../../src/core/scene/pathEffects/blend.ts"],"sourcesContent":["/**\n * A blend's steps: where each sits between its two sources — evenly by\n * count, or a fixed distance apart — and, with a spine, laid along it.\n */\nimport {\n  boundsOfPath, measurePath, multiply, prepareBlend, rotate, rotatePathAround, transformPath, translate,\n  type BlendPathsOptions, type Path, type PathMeasure,\n} from '@weasel-js/geom';\nimport { lerpFill, lerpStroke } from '@weasel-js/paint';\nimport type { DerivedPart } from '../derivedParts';\nimport type { EffectSource, PathEffectOptions } from './source';\n\n/** Steps between two shapes. Its sources are `[from, to]`, or\n *  `[from, to, spine]` to lay the steps along a third path. */\nexport interface BlendEffect extends BlendPathsOptions, PathEffectOptions {\n  kind: 'blend';\n  /** How many shapes stand between the two sources, spacing by count. */\n  steps: number;\n  /**\n   * How the steps are spaced. `'count'` puts `steps` of them evenly between\n   * the sources; `'distance'` puts one every `distance` along the run from\n   * the first source, as many as fit short of the second, so the last gap is\n   * whatever is left. Default `'count'`.\n   */\n  spaceBy?: 'count' | 'distance';\n  /** Distance from one shape's middle to the next, spacing by distance —\n   *  along the spine where there is one. Spacing by count when unset. */\n  distance?: number;\n  /**\n   * Interpolate each source's rotation as a turn about its middle, rather\n   * than moving every point in a straight line — so a shape turned 90° at\n   * one end turns through 45° halfway instead of shrinking there. Default\n   * `true`; it applies where both sources are turned boxes.\n   */\n  rotate?: boolean;\n  /** With a spine, turn each step by how far the spine's heading where it\n   *  sits differs from the straight run between the sources. Default\n   *  `false`, which only moves them. */\n  orient?: boolean;\n}\n\nconst EPS = 1e-9;\n\n/** The fractions of the way from the first source to the second that the\n *  steps sit at, over a run `length` long. */\nexport function blendStations(effect: BlendEffect, length: number): number[] {\n  const out: number[] = [];\n  const d = effect.distance;\n  if (effect.spaceBy === 'distance' && d !== undefined && d > 0) {\n    if (!(length > 0)) return out;\n    for (let s = d; s < length - EPS * Math.max(length, 1); s += d) out.push(s / length);\n    return out;\n  }\n  const steps = Math.max(Math.floor(effect.steps), 0);\n  for (let i = 1; i <= steps; i++) out.push(i / (steps + 1));\n  return out;\n}\n\n/** The middle a source's steps are interpolated about: its turn's center\n *  where it is a turned box, else its outline's bounds' middle. */\nfunction middleOf(source: EffectSource): { x: number; y: number } {\n  if (source.framed) return { x: source.framed.cx, y: source.framed.cy };\n  const b = boundsOfPath(source.world);\n  return { x: b.x + b.width / 2, y: b.y + b.height / 2 };\n}\n\n/** The parts of `effect` between `a` and `b`, along `spine` when given.\n *  `null` when the spine has no length to measure. */\nexport function blendParts(effect: BlendEffect, a: EffectSource, b: EffectSource, spine?: Path): DerivedPart[] | null {\n  const from = middleOf(a);\n  const to = middleOf(b);\n  const along: PathMeasure | null = spine === undefined ? null : measurePath(spine);\n  if (spine !== undefined && along === null) return null;\n  const stations = blendStations(effect, along ? along.length : Math.hypot(to.x - from.x, to.y - from.y));\n  if (stations.length === 0) return [];\n\n  const turned = (effect.rotate ?? true) && a.framed !== undefined && b.framed !== undefined\n    ? { a: a.framed, b: b.framed }\n    : null;\n  const blend = turned\n    ? prepareBlend(turned.a.path, turned.b.path, effect)\n    : prepareBlend(a.world, b.world, effect);\n  // The shorter way round, so a turn of 350° reads as -10°.\n  const turn = turned\n    ? Math.atan2(Math.sin(turned.b.rotation - turned.a.rotation), Math.cos(turned.b.rotation - turned.a.rotation))\n    : 0;\n  const chord = Math.atan2(to.y - from.y, to.x - from.x);\n  return stations.map((t) => {\n    let path: Path = blend.at(t);\n    if (turned) {\n      const cx = turned.a.cx + (turned.b.cx - turned.a.cx) * t;\n      const cy = turned.a.cy + (turned.b.cy - turned.a.cy) * t;\n      const rotation = turned.a.rotation + turn * t;\n      if (rotation !== 0) path = rotatePathAround(path, cx, cy, rotation);\n    }\n    if (along) {\n      const { point, tangent } = along.at(t * along.length);\n      const angle = effect.orient ? Math.atan2(tangent.y, tangent.x) - chord : 0;\n      const middle = { x: from.x + (to.x - from.x) * t, y: from.y + (to.y - from.y) * t };\n      path = transformPath(path, multiply(translate(point.x, point.y), multiply(rotate(angle), translate(-middle.x, -middle.y))));\n    }\n    return { path, fill: lerpFill(a.fill, b.fill, t) ?? null, stroke: lerpStroke(a.stroke, b.stroke, t) ?? null };\n  });\n}\n"],"mappings":"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"}

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

@@ -1,3 +1,4 @@
+import { fontGeneration, noteFontRead, withFontReads } from "../fontReads.js";
 import { samePoseValue, snapshotPose } from "../poseSnapshot.js";
 import { derivedPartsOf, pathFromParts } from "../derivedParts.js";
 import { effectParts } from "./effects.js";
@@ -33,14 +34,17 @@ function createPathEffectDerivations(read) {
 		const held = results.get(node);
 		if (held !== void 0 && current(held, node, deps)) return held;
 		const effect = pathEffectOf(node);
-		const parts = effect === null ? null : effectParts(effect, deps.map((d) => d === void 0 ? null : read(d)));
+		const generation = fontGeneration();
+		const { value: parts, fonts } = withFontReads(() => effect === null ? null : effectParts(effect, deps.map((d) => d === void 0 ? null : read(d))));
 		const result = {
 			data: node.data,
 			nodes: deps.map((d) => d?.node),
 			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),
-			path: parts === null ? null : pathFromParts(parts)
+			inherited: deps.map((d) => d?.inherited),
+			path: parts === null ? null : pathFromParts(parts),
+			faces: fonts ? generation : null
 		};
 		results.set(node, result);
 		return result;
@@ -62,13 +66,15 @@ function createPathEffectDerivations(read) {
 }
 function current(held, node, deps) {
 	if (held.data !== node.data || held.nodes.length !== deps.length) return false;
+	if (held.faces !== null && held.faces !== fontGeneration()) return false;
 	for (let i = 0; i < deps.length; i++) {
 		const d = deps[i];
 		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;
 }
 /** The parts a path-effect node paints, as its sources stand, or `null` when
@@ -82,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 { 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}\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 parts = 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    };\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  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  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":";;;;;;;;;;;;;;;;;;AAmBA,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;;AAqBA,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,QAAQ,WAAW,OACrB,OACA,YAAY,QAAQ,KAAK,KAAK,MAAO,MAAM,SAAY,OAAO,KAAK,CAAC,CAAE,CAAC;EAC3E,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;EACnD;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,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;CACA,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":";;;;;;;;;;;;;;;;;;;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;;AAyBA,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,WAAW,KAAK,KAAK,MAAM,GAAG,SAAS;GACvC,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,QAAQ,KAAK,UAAU,OAAO,EAAE,WAAW,OAAO;CAC5E;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"}

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

@@ -1,11 +1,12 @@
 import { blendParts } from "./blend.js";
+import { textAlongParts, wholeItem } from "./textAlong.js";
 import { bendAlongPath, repeatAlongPath } from "@weasel-js/geom";
 
 //#region src/core/scene/pathEffects/effects.ts
 /**
 * The path effects, each as the parts it paints from its sources: a blend's
 * steps between two shapes, a shape bent along a spine, copies of a shape
-* along a path.
+* along a path, text laid along a path.
 */
 /** The parts `effect` paints from `sources`, in its sources' order, or
 *  `null` when a source it needs is missing — a blend's spine among them,
@@ -32,6 +33,7 @@ function effectParts(effect, sources) {
 			fill: a.fill,
 			stroke: a.stroke
 		}));
+		case "textAlong": return textAlongParts(effect, a.items?.() ?? [wholeItem(a)], b.world);
 	}
 }
 

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

@@ -1 +1 @@
-{"version":3,"file":"effects.js","names":[],"sources":["../../../../src/core/scene/pathEffects/effects.ts"],"sourcesContent":["/**\n * The path effects, each as the parts it paints from its sources: a blend's\n * steps between two shapes, a shape bent along a spine, copies of a shape\n * along a path.\n */\nimport {\n  bendAlongPath, repeatAlongPath, type BendAlongPathOptions, type RepeatAlongPathOptions,\n} from '@weasel-js/geom';\nimport type { DerivedPart } from '../derivedParts';\nimport { blendParts, type BlendEffect } from './blend';\nimport type { EffectSource } from './source';\n\nexport type { BlendEffect };\n\n/** A shape bent along a spine. Its sources are `[shape, spine]`. */\nexport interface BendAlongEffect extends BendAlongPathOptions {\n  kind: 'bendAlong';\n}\n\n/** Copies of a shape along a path. Its sources are `[shape, path]`. */\nexport interface RepeatAlongEffect extends Omit<RepeatAlongPathOptions, 'flattenTolerance'> {\n  kind: 'repeatAlong';\n}\n\n/** A path effect, as a node's `data.pathEffect` holds it. */\nexport type PathEffect = BlendEffect | BendAlongEffect | RepeatAlongEffect;\n\n/** The parts `effect` paints from `sources`, in its sources' order, or\n *  `null` when a source it needs is missing — a blend's spine among them,\n *  where it names one. */\nexport function effectParts(effect: PathEffect, sources: readonly (EffectSource | null)[]): DerivedPart[] | null {\n  const [a, b] = sources;\n  if (!a || !b) return null;\n  switch (effect.kind) {\n    case 'blend': {\n      if (sources.length < 3) return blendParts(effect, a, b);\n      const spine = sources[2];\n      return spine ? blendParts(effect, a, b, spine.world) : null;\n    }\n    case 'bendAlong': {\n      const path = bendAlongPath(a.world, b.world, effect);\n      return path === null ? null : [{ path, fill: a.fill, stroke: a.stroke }];\n    }\n    case 'repeatAlong':\n      return repeatAlongPath(a.world, b.world, effect).map((path) => ({ path, fill: a.fill, stroke: a.stroke }));\n  }\n}\n"],"mappings":";;;;;;;;;;;;AA8BA,SAAgB,YAAY,QAAoB,SAAiE;CAC/G,MAAM,CAAC,GAAG,KAAK;CACf,IAAI,CAAC,KAAK,CAAC,GAAG,OAAO;CACrB,QAAQ,OAAO,MAAf;EACE,KAAK,SAAS;GACZ,IAAI,QAAQ,SAAS,GAAG,OAAO,WAAW,QAAQ,GAAG,CAAC;GACtD,MAAM,QAAQ,QAAQ;GACtB,OAAO,QAAQ,WAAW,QAAQ,GAAG,GAAG,MAAM,KAAK,IAAI;EACzD;EACA,KAAK,aAAa;GAChB,MAAM,OAAO,cAAc,EAAE,OAAO,EAAE,OAAO,MAAM;GACnD,OAAO,SAAS,OAAO,OAAO,CAAC;IAAE;IAAM,MAAM,EAAE;IAAM,QAAQ,EAAE;GAAO,CAAC;EACzE;EACA,KAAK,eACH,OAAO,gBAAgB,EAAE,OAAO,EAAE,OAAO,MAAM,CAAC,CAAC,KAAK,UAAU;GAAE;GAAM,MAAM,EAAE;GAAM,QAAQ,EAAE;EAAO,EAAE;CAC7G;AACF"}
+{"version":3,"file":"effects.js","names":[],"sources":["../../../../src/core/scene/pathEffects/effects.ts"],"sourcesContent":["/**\n * The path effects, each as the parts it paints from its sources: a blend's\n * steps between two shapes, a shape bent along a spine, copies of a shape\n * along a path, text laid along a path.\n */\nimport {\n  bendAlongPath, repeatAlongPath, type BendAlongPathOptions, type RepeatAlongPathOptions,\n} from '@weasel-js/geom';\nimport type { DerivedPart } from '../derivedParts';\nimport { blendParts, type BlendEffect } from './blend';\nimport type { EffectSource, PathEffectOptions } from './source';\nimport { textAlongParts, wholeItem, type TextAlongEffect } from './textAlong';\n\nexport type { BlendEffect, PathEffectOptions, TextAlongEffect };\n\n/** A shape bent along a spine. Its sources are `[shape, spine]`. */\nexport interface BendAlongEffect extends BendAlongPathOptions, PathEffectOptions {\n  kind: 'bendAlong';\n}\n\n/** Copies of a shape along a path. Its sources are `[shape, path]`. */\nexport interface RepeatAlongEffect extends Omit<RepeatAlongPathOptions, 'flattenTolerance'>, PathEffectOptions {\n  kind: 'repeatAlong';\n}\n\n/** A path effect, as a node's `data.pathEffect` holds it. */\nexport type PathEffect = BlendEffect | BendAlongEffect | RepeatAlongEffect | TextAlongEffect;\n\n/** The parts `effect` paints from `sources`, in its sources' order, or\n *  `null` when a source it needs is missing — a blend's spine among them,\n *  where it names one. */\nexport function effectParts(effect: PathEffect, sources: readonly (EffectSource | null)[]): DerivedPart[] | null {\n  const [a, b] = sources;\n  if (!a || !b) return null;\n  switch (effect.kind) {\n    case 'blend': {\n      if (sources.length < 3) return blendParts(effect, a, b);\n      const spine = sources[2];\n      return spine ? blendParts(effect, a, b, spine.world) : null;\n    }\n    case 'bendAlong': {\n      const path = bendAlongPath(a.world, b.world, effect);\n      return path === null ? null : [{ path, fill: a.fill, stroke: a.stroke }];\n    }\n    case 'repeatAlong':\n      return repeatAlongPath(a.world, b.world, effect).map((path) => ({ path, fill: a.fill, stroke: a.stroke }));\n    case 'textAlong':\n      return textAlongParts(effect, a.items?.() ?? [wholeItem(a)], b.world);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AA+BA,SAAgB,YAAY,QAAoB,SAAiE;CAC/G,MAAM,CAAC,GAAG,KAAK;CACf,IAAI,CAAC,KAAK,CAAC,GAAG,OAAO;CACrB,QAAQ,OAAO,MAAf;EACE,KAAK,SAAS;GACZ,IAAI,QAAQ,SAAS,GAAG,OAAO,WAAW,QAAQ,GAAG,CAAC;GACtD,MAAM,QAAQ,QAAQ;GACtB,OAAO,QAAQ,WAAW,QAAQ,GAAG,GAAG,MAAM,KAAK,IAAI;EACzD;EACA,KAAK,aAAa;GAChB,MAAM,OAAO,cAAc,EAAE,OAAO,EAAE,OAAO,MAAM;GACnD,OAAO,SAAS,OAAO,OAAO,CAAC;IAAE;IAAM,MAAM,EAAE;IAAM,QAAQ,EAAE;GAAO,CAAC;EACzE;EACA,KAAK,eACH,OAAO,gBAAgB,EAAE,OAAO,EAAE,OAAO,MAAM,CAAC,CAAC,KAAK,UAAU;GAAE;GAAM,MAAM,EAAE;GAAM,QAAQ,EAAE;EAAO,EAAE;EAC3G,KAAK,aACH,OAAO,eAAe,QAAQ,EAAE,QAAQ,KAAK,CAAC,UAAU,CAAC,CAAC,GAAG,EAAE,KAAK;CACxE;AACF"}

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"}