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

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/textAlong.js

@@ -0,0 +1,95 @@
+import { boundsOfPath, multiply, pathShape, placeAlongRun, rotate, runLength, trackRun, transformPath, translate } from "@weasel-js/geom";
+
+//#region src/core/scene/pathEffects/textAlong.ts
+/**
+* Text along a path: a source's items — a text node's grapheme clusters, or a
+* whole shape as one item — laid end to end along a path, each turned to it.
+*/
+var LEAD = {
+	start: 0,
+	center: .5,
+	end: 1
+};
+/** The parts `items` paint laid along `path` as `effect` says; `[]` when there is nothing to lay or nowhere to lay it. */
+function textAlongParts(effect, items, path) {
+	const shape = pathShape(path);
+	if (shape === null || !(shape.length > 0) || items.length === 0) return [];
+	const L = shape.length;
+	const closed = shape.closed;
+	const lengths = items.map((it) => it.length);
+	const k = LEAD[effect.align ?? "start"];
+	const at = clamp01(effect.start ?? 0) * L;
+	const gap = effect.overflow === "fit" ? fitGap(lengths, roomAt(at, L, k, closed)) : 0;
+	const total = runLength(lengths, gap);
+	const c = at + (.5 - k) * total;
+	const about = closed ? (c / L % 1 + 1) % 1 : clamp01(c / L);
+	const run = trackRun(shape, 0, 1, {
+		side: effect.side ?? "auto",
+		about
+	});
+	const places = placeAlongRun(run, lengths, {
+		gap,
+		align: "center",
+		at: run.reversed ? L - c : c,
+		shift: finiteOr(effect.shift, 0),
+		wrap: closed
+	});
+	const center = effect.anchor === "center";
+	const out = [];
+	const firstStart = places[0].center - lengths[0] / 2;
+	places.forEach((place, i) => {
+		if (dropped(place, closed ? firstStart : null, L)) return;
+		const item = items[i];
+		const m = itemFrame(place, item.length, center ? item.middle : 0);
+		for (const part of item.parts) out.push({
+			...part,
+			path: transformPath(part.path, m)
+		});
+	});
+	return out;
+}
+/** `source`'s whole outline as one item: its bounds' left at x = 0 and their vertical middle on the anchor line. */
+function wholeItem(source) {
+	const b = boundsOfPath(source.world);
+	return {
+		length: b.width,
+		middle: 0,
+		parts: [{
+			path: transformPath(source.world, translate(-b.x, -(b.y + b.height / 2))),
+			fill: source.fill,
+			stroke: source.stroke
+		}]
+	};
+}
+/** SVG `textPath`'s rule: an item is not drawn once its middle is past an open path's ends, or on a closed path a whole
+*  lap or more on from the first item's start. Judged within a hair of rounding. */
+function dropped(place, firstStart, L) {
+	const hair = 1e-9 * Math.max(1, L);
+	if (firstStart !== null) return place.center - firstStart >= L - hair;
+	return place.center < -hair || place.center > L + hair;
+}
+/** How much path the text has before it runs off, from `at`, with `k` of it laid back behind `at`. */
+function roomAt(at, L, k, closed) {
+	if (closed) return L;
+	return k === 0 ? L - at : k === 1 ? at : 2 * Math.min(at, L - at);
+}
+/** The gap that makes `lengths` fill `room`, or 0 when they fit already. Never so negative that an item's step back
+*  from the one before it (its length plus the gap) goes below zero, so items keep their order in too short a room. */
+function fitGap(lengths, room) {
+	const total = runLength(lengths, 0);
+	if (!(total > room) || lengths.length < 2) return 0;
+	let floor = -Infinity;
+	for (let i = 1; i < lengths.length; i++) floor = Math.max(floor, -(lengths[i - 1] + lengths[i]) / 2);
+	return Math.max((room - total) / (lengths.length - 1), floor);
+}
+/** Item frame to world: its middle on `place`, turned to it, its anchor line `lift` above y = 0 brought onto the path. */
+function itemFrame(place, length, lift) {
+	const turn = multiply(rotate(place.angle * Math.PI / 180), translate(-length / 2, lift));
+	return multiply(translate(place.point.x, place.point.y), turn);
+}
+var clamp01 = (v) => v > 1 ? 1 : v > 0 ? v : 0;
+var finiteOr = (v, d) => v !== void 0 && Number.isFinite(v) ? v : d;
+
+//#endregion
+export { textAlongParts, wholeItem };
+//# sourceMappingURL=textAlong.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"textAlong.js","names":[],"sources":["../../../../src/core/scene/pathEffects/textAlong.ts"],"sourcesContent":["/**\n * Text along a path: a source's items — a text node's grapheme clusters, or a\n * whole shape as one item — laid end to end along a path, each turned to it.\n */\nimport {\n  boundsOfPath, multiply, pathShape, placeAlongRun, rotate, runLength, trackRun, transformPath, translate,\n  type Affine, type Path, type RunAlign, type RunPlace, type TrackSide,\n} from '@weasel-js/geom';\nimport type { DerivedPart } from '../derivedParts';\nimport type { EffectItem, EffectSource, PathEffectOptions } from './source';\n\n/**\n * Text (or any shape) laid along a path, item by item. Its sources are `[text, path]`. Only the text's first laid line\n * follows the path; a color glyph keeps its advance and paints nothing; underlines and other decorations are not drawn.\n * On an open path an item whose middle falls past either end is not drawn; on a closed one the text wraps past the\n * seam, and an item a whole lap on from the first item's start is not drawn.\n */\nexport interface TextAlongEffect extends PathEffectOptions {\n  kind: 'textAlong';\n  /** Which part of the text sits at `start`. Default `'start'`. */\n  align?: RunAlign;\n  /** Where the text sits, as a fraction 0..1 of the path's length from its first point. Default 0. */\n  start?: number;\n  /** How far the anchor line sits off the path, toward the glyphs' up, in world units. Default 0. */\n  shift?: number;\n  /** What sits on the path: the glyphs' baseline, or (`'center'`) their x-height middle. Default `'baseline'`. */\n  anchor?: 'baseline' | 'center';\n  /** Text longer than its room is cut at the path's end (`'clip'`), or has the gaps between items squeezed until it\n   *  fits (`'fit'`). Default `'clip'`. */\n  overflow?: 'clip' | 'fit';\n  /** Which side of the path the glyphs stand on; see `TrackSide`. Default `'auto'`, whichever reads upright. Turned over,\n   *  the text keeps the stretch of path it had, and on an open path drops whichever letters fall off it. */\n  side?: TrackSide;\n}\n\nconst LEAD: Record<RunAlign, number> = { start: 0, center: 0.5, end: 1 };\n\n/** The parts `items` paint laid along `path` as `effect` says; `[]` when there is nothing to lay or nowhere to lay it. */\nexport function textAlongParts(effect: TextAlongEffect, items: readonly EffectItem[], path: Path): DerivedPart[] {\n  const shape = pathShape(path);\n  if (shape === null || !(shape.length > 0) || items.length === 0) return [];\n  const L = shape.length;\n  const closed = shape.closed;\n  const lengths = items.map((it) => it.length);\n  const k = LEAD[effect.align ?? 'start'];\n  const at = clamp01(effect.start ?? 0) * L;\n  const gap = effect.overflow === 'fit' ? fitGap(lengths, roomAt(at, L, k, closed)) : 0;\n  const total = runLength(lengths, gap);\n  const c = at + (0.5 - k) * total;\n  const about = closed ? ((c / L) % 1 + 1) % 1 : clamp01(c / L);\n  const run = trackRun(shape, 0, 1, { side: effect.side ?? 'auto', about });\n  const places = placeAlongRun(run, lengths, {\n    gap, align: 'center', at: run.reversed ? L - c : c, shift: finiteOr(effect.shift, 0), wrap: closed,\n  });\n  const center = effect.anchor === 'center';\n  const out: DerivedPart[] = [];\n  const firstStart = places[0]!.center - lengths[0]! / 2;\n  places.forEach((place, i) => {\n    // By center (SVG textPath's rule), not by RunPlace.clipped, which judges by extent.\n    if (dropped(place, closed ? firstStart : null, L)) return;\n    const item = items[i]!;\n    const m = itemFrame(place, item.length, center ? item.middle : 0);\n    for (const part of item.parts) out.push({ ...part, path: transformPath(part.path, m) });\n  });\n  return out;\n}\n\n/** `source`'s whole outline as one item: its bounds' left at x = 0 and their vertical middle on the anchor line. */\nexport function wholeItem(source: EffectSource): EffectItem {\n  const b = boundsOfPath(source.world);\n  return {\n    length: b.width,\n    middle: 0,\n    parts: [{\n      path: transformPath(source.world, translate(-b.x, -(b.y + b.height / 2))),\n      fill: source.fill,\n      stroke: source.stroke,\n    }],\n  };\n}\n\n/** SVG `textPath`'s rule: an item is not drawn once its middle is past an open path's ends, or on a closed path a whole\n *  lap or more on from the first item's start. Judged within a hair of rounding. */\nfunction dropped(place: RunPlace, firstStart: number | null, L: number): boolean {\n  const hair = 1e-9 * Math.max(1, L);\n  if (firstStart !== null) return place.center - firstStart >= L - hair;\n  return place.center < -hair || place.center > L + hair;\n}\n\n/** How much path the text has before it runs off, from `at`, with `k` of it laid back behind `at`. */\nfunction roomAt(at: number, L: number, k: number, closed: boolean): number {\n  if (closed) return L;\n  return k === 0 ? L - at : k === 1 ? at : 2 * Math.min(at, L - at);\n}\n\n/** The gap that makes `lengths` fill `room`, or 0 when they fit already. Never so negative that an item's step back\n *  from the one before it (its length plus the gap) goes below zero, so items keep their order in too short a room. */\nfunction fitGap(lengths: readonly number[], room: number): number {\n  const total = runLength(lengths, 0);\n  if (!(total > room) || lengths.length < 2) return 0;\n  let floor = -Infinity;\n  for (let i = 1; i < lengths.length; i++) floor = Math.max(floor, -(lengths[i - 1]! + lengths[i]!) / 2);\n  return Math.max((room - total) / (lengths.length - 1), floor);\n}\n\n/** Item frame to world: its middle on `place`, turned to it, its anchor line `lift` above y = 0 brought onto the path. */\nfunction itemFrame(place: RunPlace, length: number, lift: number): Affine {\n  const turn = multiply(rotate((place.angle * Math.PI) / 180), translate(-length / 2, lift));\n  return multiply(translate(place.point.x, place.point.y), turn);\n}\n\nconst clamp01 = (v: number): number => (v > 1 ? 1 : v > 0 ? v : 0);\nconst finiteOr = (v: number | undefined, d: number): number => (v !== undefined && Number.isFinite(v) ? v : d);\n"],"mappings":";;;;;;;AAmCA,IAAM,OAAiC;CAAE,OAAO;CAAG,QAAQ;CAAK,KAAK;AAAE;;AAGvE,SAAgB,eAAe,QAAyB,OAA8B,MAA2B;CAC/G,MAAM,QAAQ,UAAU,IAAI;CAC5B,IAAI,UAAU,QAAQ,EAAE,MAAM,SAAS,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC;CACzE,MAAM,IAAI,MAAM;CAChB,MAAM,SAAS,MAAM;CACrB,MAAM,UAAU,MAAM,KAAK,OAAO,GAAG,MAAM;CAC3C,MAAM,IAAI,KAAK,OAAO,SAAS;CAC/B,MAAM,KAAK,QAAQ,OAAO,SAAS,CAAC,IAAI;CACxC,MAAM,MAAM,OAAO,aAAa,QAAQ,OAAO,SAAS,OAAO,IAAI,GAAG,GAAG,MAAM,CAAC,IAAI;CACpF,MAAM,QAAQ,UAAU,SAAS,GAAG;CACpC,MAAM,IAAI,MAAM,KAAM,KAAK;CAC3B,MAAM,QAAQ,UAAW,IAAI,IAAK,IAAI,KAAK,IAAI,QAAQ,IAAI,CAAC;CAC5D,MAAM,MAAM,SAAS,OAAO,GAAG,GAAG;EAAE,MAAM,OAAO,QAAQ;EAAQ;CAAM,CAAC;CACxE,MAAM,SAAS,cAAc,KAAK,SAAS;EACzC;EAAK,OAAO;EAAU,IAAI,IAAI,WAAW,IAAI,IAAI;EAAG,OAAO,SAAS,OAAO,OAAO,CAAC;EAAG,MAAM;CAC9F,CAAC;CACD,MAAM,SAAS,OAAO,WAAW;CACjC,MAAM,MAAqB,CAAC;CAC5B,MAAM,aAAa,OAAO,EAAE,CAAE,SAAS,QAAQ,KAAM;CACrD,OAAO,SAAS,OAAO,MAAM;EAE3B,IAAI,QAAQ,OAAO,SAAS,aAAa,MAAM,CAAC,GAAG;EACnD,MAAM,OAAO,MAAM;EACnB,MAAM,IAAI,UAAU,OAAO,KAAK,QAAQ,SAAS,KAAK,SAAS,CAAC;EAChE,KAAK,MAAM,QAAQ,KAAK,OAAO,IAAI,KAAK;GAAE,GAAG;GAAM,MAAM,cAAc,KAAK,MAAM,CAAC;EAAE,CAAC;CACxF,CAAC;CACD,OAAO;AACT;;AAGA,SAAgB,UAAU,QAAkC;CAC1D,MAAM,IAAI,aAAa,OAAO,KAAK;CACnC,OAAO;EACL,QAAQ,EAAE;EACV,QAAQ;EACR,OAAO,CAAC;GACN,MAAM,cAAc,OAAO,OAAO,UAAU,CAAC,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;GACxE,MAAM,OAAO;GACb,QAAQ,OAAO;EACjB,CAAC;CACH;AACF;;;AAIA,SAAS,QAAQ,OAAiB,YAA2B,GAAoB;CAC/E,MAAM,OAAO,OAAO,KAAK,IAAI,GAAG,CAAC;CACjC,IAAI,eAAe,MAAM,OAAO,MAAM,SAAS,cAAc,IAAI;CACjE,OAAO,MAAM,SAAS,CAAC,QAAQ,MAAM,SAAS,IAAI;AACpD;;AAGA,SAAS,OAAO,IAAY,GAAW,GAAW,QAAyB;CACzE,IAAI,QAAQ,OAAO;CACnB,OAAO,MAAM,IAAI,IAAI,KAAK,MAAM,IAAI,KAAK,IAAI,KAAK,IAAI,IAAI,IAAI,EAAE;AAClE;;;AAIA,SAAS,OAAO,SAA4B,MAAsB;CAChE,MAAM,QAAQ,UAAU,SAAS,CAAC;CAClC,IAAI,EAAE,QAAQ,SAAS,QAAQ,SAAS,GAAG,OAAO;CAClD,IAAI,QAAQ;CACZ,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,QAAQ,KAAK,IAAI,OAAO,EAAE,QAAQ,IAAI,KAAM,QAAQ,MAAO,CAAC;CACrG,OAAO,KAAK,KAAK,OAAO,UAAU,QAAQ,SAAS,IAAI,KAAK;AAC9D;;AAGA,SAAS,UAAU,OAAiB,QAAgB,MAAsB;CACxE,MAAM,OAAO,SAAS,OAAQ,MAAM,QAAQ,KAAK,KAAM,GAAG,GAAG,UAAU,CAAC,SAAS,GAAG,IAAI,CAAC;CACzF,OAAO,SAAS,UAAU,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,GAAG,IAAI;AAC/D;AAEA,IAAM,WAAW,MAAuB,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;AAChE,IAAM,YAAY,GAAuB,MAAuB,MAAM,UAAa,OAAO,SAAS,CAAC,IAAI,IAAI"}

package/dist/{cornerHandles-BHuoMs1o.d.ts → cornerHandles-p8fDIAKt.d.ts}

@@ -139,7 +139,8 @@ declare function handlePoint(bounds: FramedBox, entry: Pick<ResizeHandleAnchor,
     x: number;
     y: number;
 };
-/** @deprecated Use {@link handlePoint}, which also places edge handles. */
+/** A corner handle's position for the given bounds, in the bounds' frame.
+ *  @deprecated Use {@link handlePoint}, which also places edge handles. */
 declare const cornerPoint: (bounds: FramedBox, entry: Pick<CornerAnchor, 'xEdge' | 'yEdge'>) => {
     x: number;
     y: number;

package/dist/{depSchema-BpZNOv7q.d.ts → depSchema-mG19aEdD.d.ts}

@@ -1,4 +1,5 @@
-import { TileKind, Paint, GradStop, TilePaint, Fill, Stroke, CommandFill, CommandStroke, CommandPaint } from '@weasel-js/paint';
+import * as _weasel_js_paint from '@weasel-js/paint';
+import { TileKind, Paint, GradStop, TilePaint, PaintedFill, PaintedStroke, Inherit, Fill, Stroke, CommandFill, CommandStroke, CommandPaint } from '@weasel-js/paint';
 import { Reflection } from '@weasel-js/registry';
 import { ComponentType } from 'react';
 import { IconRef } from '@weasel-js/icons';
@@ -200,6 +201,53 @@ declare function paintKindOf(fill: Paint): PaintKindEntry | undefined;
 /** @internal Test helper — do not call from product code. */
 declare function _resetPaintKindsForTests(): void;
 
+/**
+ * What a node's `'inherit'` fill and stroke resolve to: its nearest enclosing
+ * container's, `null` for none. A field the node does not inherit is `null`
+ * here whatever its containers hold.
+ */
+interface InheritedPaint {
+    readonly fill: PaintedFill | null;
+    readonly stroke: PaintedStroke | null;
+}
+/** Whether `node`'s fill or stroke is {@link INHERIT}, so painting it needs
+ *  its containers' paint. */
+declare function inheritsPaint(node: {
+    data?: unknown;
+}): boolean;
+/**
+ * {@link InheritedPaint} for `node`, given its ancestors innermost first. Only
+ * containers are sources; one whose own field is `'inherit'` passes the
+ * question on to the next, and running out of containers is none.
+ *
+ * Hands back the object it returned last time for `node` while both values
+ * are the same references, so a memo can key on it.
+ */
+declare function inheritedPaintOf(node: {
+    data?: unknown;
+}, ancestors: Iterable<{
+    kind?: string;
+    data?: unknown;
+}>): InheritedPaint;
+/** The fields {@link withInheritedPaint} resolves. */
+type ResolvedPaintFields<T> = Omit<T, 'fill' | 'stroke'> & {
+    fill?: Exclude<T extends {
+        fill?: infer F;
+    } ? F : never, Inherit>;
+    stroke?: Exclude<T extends {
+        stroke?: infer S;
+    } ? S : never, Inherit>;
+};
+/**
+ * `data` with an `'inherit'` fill or stroke replaced by what `inherited` says
+ * it resolves to, for a reader that wants the paint a node shows rather than
+ * the one it declares. Hands `data` back as is when nothing inherits.
+ */
+declare function withInheritedPaint<T extends {
+    fill?: unknown;
+    stroke?: unknown;
+}>(data: T, inherited: InheritedPaint | undefined): ResolvedPaintFields<T>;
+
 /** The paint a path node wears, resolved: what an action that turns ink into
  *  geometry reads from a node and tells a consumer to put on a result. */
 interface PathPaint {
@@ -209,13 +257,12 @@ interface PathPaint {
     stroke?: Stroke;
 }
 /** {@link PathPaint} of a node that keeps its paint in `data.fill` and
- *  `data.stroke`, as the built-in path painter draws it: a stroke with no
- *  `paint` is none, and an undeclared fill is the default shape fill unless
- *  the node is stroked. */
+ *  `data.stroke`, as the built-in path painter draws it: a stroke or a fill
+ *  with no `paint` is none, and an `'inherit'` one is `inherited`'s. */
 declare function pathPaintOf(data: {
-    fill?: Fill | null;
-    stroke?: Stroke | null;
-}): PathPaint;
+    fill?: Fill | Inherit | null;
+    stroke?: Stroke | Inherit | null;
+}, inherited?: InheritedPaint): PathPaint;
 
 /**
  * Create Outlines: replace each selected text node with path nodes carrying
@@ -1450,7 +1497,7 @@ type InsertNodeFactory = (bounds: {
 /**
  * The paint a kit-built shape is inserted with. `kind` is the shape being
  * built and `seq` counts this canvas's inserts from 1. A key left out stays
- * off the node, so its painter's default applies; `null` is "none". A pencil
+ * off the node, which paints none of it, the same as `null`. A pencil
  * trail too short to fit is built as a rect and asks as one. A line and an
  * open pen path are inserted unfilled: a fill given to either is dropped.
  * `fillRule` is the rule a path that carries one is built with, where the
@@ -1474,8 +1521,8 @@ interface TextNodeData {
     text: string;
     style?: TextStyle;
     runs?: readonly StyledRun[];
-    fill?: Fill | null;
-    stroke?: Stroke | null;
+    fill?: Fill | Inherit | null;
+    stroke?: Stroke | Inherit | null;
     verticalAlign?: TextVerticalAlign;
     /** Paint for the whole pose box, drawn under the glyphs. `fill` is the
      *  glyphs' own paint, so a box behind them needs a key of its own. */
@@ -1508,11 +1555,11 @@ interface MinSize {
 declare function minSizeOf(data: unknown): MinSize | null;
 
 /** How a sticky note looks as it is made, named as the text node it becomes
- *  names them. Every field but `fill` has a default, in {@link STICKY_DEFAULTS}. */
+ *  names them. Every field has a default, in {@link STICKY_DEFAULTS}. */
 interface StickyStyle {
     /** The note itself, painted over its whole box. */
     background?: Fill;
-    /** The text's paint. Absent, the text style's default. */
+    /** The text's paint. */
     fill?: Fill;
     /** World units from the note's edge to its text, on every side. */
     padding?: number;
@@ -1538,6 +1585,7 @@ declare const STICKY_DEFAULTS: {
             readonly color: "#fff1a6ff";
         };
     };
+    readonly fill: _weasel_js_paint.PaintedFill;
     readonly padding: 12;
     readonly style: {
         readonly fontSize: 18;
@@ -2800,4 +2848,4 @@ declare module '@weasel-js/routing' {
     }
 }
 
-export { type SnapCollect as $, type AnchorMarkerShape as A, type PathEditTarget as B, type ContentHandlerEntry as C, type Dims as D, type EditAnchorsDep as E, type FitViewToBoundsOptions as F, type GestureLifecycleOptions as G, type HandleLocks as H, type InertiaConfig as I, type FinishedEditFrame as J, type PathSymmetryDep as K, type LayerHit as L, type BooleanOpOptions as M, type BooleansAdapter as N, type BooleanOp as O, type PathEditMark as P, type PathPaint as Q, type RenderLayer as R, type SnapSource as S, type TransformFollower as T, type BooleanOpResult as U, type ViewAnimationOptions as V, type BooleanStrokes as W, type SnapMods as X, type SourceCandidate as Y, type SnapProbeAt as Z, _resetPaintKindsForTests as _, type PathEditExtension as a, type SnapEdges as a$, type SnapMark as a0, type SnapDep as a1, type SnapOutcome as a2, type SnapReadoutStyle as a3, type AngleCandidate as a4, type AngleCollect as a5, type AnimateToBoundsOptions as a6, type AreaSelectDep as a7, type BooleanOpPreview as a8, type BooleanPreviewPiece as a9, type NodeAtPointDep as aA, type OutlinePathSpec as aB, PATH_OVERLAY_ROLES as aC, type PaintKind as aD, type PaintKindEditorProps as aE, type PaintKindFamily as aF, type PaintKindLoader as aG, type PanBounds as aH, type PathEditDrag as aI, type PathEditDragStart as aJ, type PathEditFinishCtx as aK, type PathEditHandleMove as aL, type PathEditMarksCtx as aM, type PathEditOther as aN, type PathEditPart as aO, type PathEditStore as aP, type PathForm as aQ, type PathOverlay as aR, type PathOverlayOptions as aS, type PathOverlayStyle as aT, type PathRepresentation as aU, type PathTransformFinishCtx as aV, type PreviewPathsDep as aW, type ResizePolicy as aX, STICKY_DEFAULTS as aY, type SnapBegin as aZ, type SnapEdge as a_, type CanDropIntoDep as aa, type ClipboardDep as ab, type ClipboardIngestCtx as ac, type CreateOutlinesResult as ad, type CustomPaintContext as ae, DEFAULT_LAYER_RETAIN as af, type DecayLoopConfig as ag, type FinishedPathEdit as ah, GEOMETRY_BOUND_DATA as ai, type HandleLock as aj, type HitTestView as ak, type IngestCtx as al, type IngestionDep as am, type InsertDep as an, type InsertEnds as ao, type InsertExtras as ap, type InsertIntoDep as aq, type InsertLive as ar, type LassoSelectDep as as, type LayerCommandCache as at, type LayerDrawFailure as au, type LayerDrawSpan as av, type LayerRetainPolicy as aw, type LayoutDep as ax, type Locus as ay, type MinSize as az, type SnapGesture as b, type SnapMarks as b0, type SnapReadoutDep as b1, type SvgUnpacker as b2, type TextEditDep as b3, type TextNodeData as b4, type TransformPreviewNode as b5, type TransientPath as b6, VIEW_ANIMATION_KEY as b7, type ViewAnimationApi as b8, type ViewApi as b9, registerPaintKindLoader as bA, seedTile as bB, stickyData as bC, stickyNodeFactory as bD, subscribeToSources as bE, switchGradientKind as bF, textBoxOf as bG, useDecayLoop as bH, useViewAnimation as bI, useViewAnimationOn as bJ, viewAxes as bK, withoutGeometryBoundData as bL, type ViewChannel as ba, applyBooleanOp as bb, applyCreateOutlines as bc, asPaint as bd, createPathOverlay as be, createSnapOutcomeStore as bf, depsUnchanged as bg, drawLayers as bh, drawOneLayer as bi, fitViewToBounds as bj, getPaintKind as bk, isLayerPainted as bl, isLayerVisible as bm, listGradientKinds as bn, listPaintKinds as bo, minSizeOf as bp, paintKindOf as bq, paintKindRegistry as br, paintedLayers as bs, paintsLayer as bt, paletteInsertPaint as bu, pathPaintOf as bv, patternFamily as bw, previewBooleanOp as bx, registerContentHandler as by, registerPaintKind as bz, type SnapConstrain as c, type SnapResizeBox as d, type SnapGeometry as e, type SnapOutcomeStore as f, type SnapSession as g, type ViewportDims as h, type RedrawSource as i, type EditAnchorsParams as j, type SliceDep as k, type StickyStyle as l, type ChromeState as m, type LayerGroup as n, type GeometryProjection as o, type InsertNodeFactory as p, type InsertPaint as q, type SvgIngestOptions as r, type SceneCanvasSnap as s, type Affordance as t, type AffordanceRegion as u, type AffordanceBinding as v, type CommonAffordanceScratch as w, type TextOverflow as x, type CreateOutlinesAdapter as y, type PaintKindEntry as z };
+export { type SnapProbeAt as $, type AnchorMarkerShape as A, type PaintKindEntry as B, type ContentHandlerEntry as C, type Dims as D, type EditAnchorsDep as E, type FitViewToBoundsOptions as F, type GestureLifecycleOptions as G, type HandleLocks as H, type InheritedPaint as I, type PathEditTarget as J, type FinishedEditFrame as K, type LayerHit as L, type PathSymmetryDep as M, type BooleanOpOptions as N, type BooleansAdapter as O, type PathEditMark as P, type BooleanOp as Q, type RenderLayer as R, type SnapSource as S, type TransformFollower as T, type PathPaint as U, type ViewAnimationOptions as V, type BooleanOpResult as W, type BooleanStrokes as X, type SnapMods as Y, type SourceCandidate as Z, _resetPaintKindsForTests as _, type PathEditExtension as a, type SnapEdge as a$, type SnapCollect as a0, type SnapMark as a1, type SnapDep as a2, type SnapOutcome as a3, type SnapReadoutStyle as a4, type AngleCandidate as a5, type AngleCollect as a6, type AnimateToBoundsOptions as a7, type AreaSelectDep as a8, type BooleanOpPreview as a9, type MinSize as aA, type NodeAtPointDep as aB, type OutlinePathSpec as aC, PATH_OVERLAY_ROLES as aD, type PaintKind as aE, type PaintKindEditorProps as aF, type PaintKindFamily as aG, type PaintKindLoader as aH, type PanBounds as aI, type PathEditDrag as aJ, type PathEditDragStart as aK, type PathEditFinishCtx as aL, type PathEditHandleMove as aM, type PathEditMarksCtx as aN, type PathEditOther as aO, type PathEditPart as aP, type PathEditStore as aQ, type PathForm as aR, type PathOverlay as aS, type PathOverlayOptions as aT, type PathOverlayStyle as aU, type PathRepresentation as aV, type PathTransformFinishCtx as aW, type PreviewPathsDep as aX, type ResizePolicy as aY, STICKY_DEFAULTS as aZ, type SnapBegin as a_, type BooleanPreviewPiece as aa, type CanDropIntoDep as ab, type ClipboardDep as ac, type ClipboardIngestCtx as ad, type CreateOutlinesResult as ae, type CustomPaintContext as af, DEFAULT_LAYER_RETAIN as ag, type DecayLoopConfig as ah, type FinishedPathEdit as ai, GEOMETRY_BOUND_DATA as aj, type HandleLock as ak, type HitTestView as al, type IngestCtx as am, type IngestionDep as an, type InsertDep as ao, type InsertEnds as ap, type InsertExtras as aq, type InsertIntoDep as ar, type InsertLive as as, type LassoSelectDep as at, type LayerCommandCache as au, type LayerDrawFailure as av, type LayerDrawSpan as aw, type LayerRetainPolicy as ax, type LayoutDep as ay, type Locus as az, type SnapGesture as b, type SnapEdges as b0, type SnapMarks as b1, type SnapReadoutDep as b2, type SvgUnpacker as b3, type TextEditDep as b4, type TextNodeData as b5, type TransformPreviewNode as b6, type TransientPath as b7, VIEW_ANIMATION_KEY as b8, type ViewAnimationApi as b9, previewBooleanOp as bA, registerContentHandler as bB, registerPaintKind as bC, registerPaintKindLoader as bD, seedTile as bE, stickyData as bF, stickyNodeFactory as bG, subscribeToSources as bH, switchGradientKind as bI, textBoxOf as bJ, useDecayLoop as bK, useViewAnimation as bL, useViewAnimationOn as bM, viewAxes as bN, withInheritedPaint as bO, withoutGeometryBoundData as bP, type ViewApi as ba, type ViewChannel as bb, applyBooleanOp as bc, applyCreateOutlines as bd, asPaint as be, createPathOverlay as bf, createSnapOutcomeStore as bg, depsUnchanged as bh, drawLayers as bi, drawOneLayer as bj, fitViewToBounds as bk, getPaintKind as bl, inheritedPaintOf as bm, inheritsPaint as bn, isLayerPainted as bo, isLayerVisible as bp, listGradientKinds as bq, listPaintKinds as br, minSizeOf as bs, paintKindOf as bt, paintKindRegistry as bu, paintedLayers as bv, paintsLayer as bw, paletteInsertPaint as bx, pathPaintOf as by, patternFamily as bz, type SnapConstrain as c, type SnapResizeBox as d, type SnapGeometry as e, type SnapOutcomeStore as f, type SnapSession as g, type ViewportDims as h, type RedrawSource as i, type EditAnchorsParams as j, type InertiaConfig as k, type SliceDep as l, type StickyStyle as m, type ChromeState as n, type LayerGroup as o, type GeometryProjection as p, type InsertNodeFactory as q, type InsertPaint as r, type SvgIngestOptions as s, type SceneCanvasSnap as t, type Affordance as u, type AffordanceRegion as v, type AffordanceBinding as w, type CommonAffordanceScratch as x, type TextOverflow as y, type CreateOutlinesAdapter as z };

package/dist/devtools/registry.js

@@ -1,5 +1,5 @@
 import { serialize } from "./serialize.js";
-import { actionBindings, buildDepsFromRequires, evaluateActive, evaluateEnabled, routesForSpec } from "@weasel-js/routing";
+import { actionBindings, buildDepsFromRequires, evaluateActive, evaluateEnabled, overriddenBindings, routesForSpec } from "@weasel-js/routing";
 
 //#region src/devtools/registry.ts
 /** What one canvas has registered — its tools, actions, deps and node kinds — as plain data for `get-registry`. */
@@ -18,7 +18,7 @@ function bindingOf(binding) {
 		opts: serialize(binding.opts)
 	};
 }
-function toolOf(entry, slot) {
+function toolOf(entry, slot, overrides) {
 	const p = entry.presentation;
 	return {
 		id: entry.id,
@@ -31,7 +31,7 @@ function toolOf(entry, slot) {
 		hidden: p?.hide === true,
 		cursor: serialize(entry.cursor),
 		eligibility: serialize(entry.eligibility),
-		bindings: (entry.bindings ?? []).map(bindingOf),
+		bindings: overriddenBindings(entry.bindings ?? [], entry.id, overrides).map(bindingOf),
 		actions: (entry.actions ?? []).map((a) => a.id),
 		deps: Object.keys(entry.deps ?? {}),
 		hasOverlay: entry.overlay !== void 0
@@ -71,7 +71,7 @@ function describeRegistry(inputs) {
 		for (const e of entries) {
 			if (seen.has(e.id)) continue;
 			seen.add(e.id);
-			tools.push(toolOf(e, slot));
+			tools.push(toolOf(e, slot, inputs.overrides));
 		}
 	};
 	add(Object.values(inputs.tools.registry), "tool");

package/dist/devtools/registry.js.map

@@ -1 +1 @@
-{"version":3,"file":"registry.js","names":[],"sources":["../../src/devtools/registry.ts"],"sourcesContent":["/** What one canvas has registered — its tools, actions, deps and node kinds — as plain data for `get-registry`. */\nimport {\n  actionBindings, buildDepsFromRequires, evaluateActive, evaluateEnabled, routesForSpec,\n  type Action, type ActionSource, type Contribution, type DepRegistry, type GestureBinding,\n} from '@weasel-js/routing';\nimport type {\n  DevtoolsActionEntry, DevtoolsBinding, DevtoolsRegistry, DevtoolsToolEntry,\n} from './protocol';\nimport { serialize } from './serialize';\n\ntype Entry = Contribution<unknown> & { cursor?: unknown };\n\n/** The live registries {@link describeRegistry} reads. */\nexport interface RegistryInputs {\n  tools: { registry: Readonly<Record<string, Entry>>; ambient: readonly Entry[] };\n  /** The entries a `features` preset brought beside the tools. */\n  contributions: readonly Entry[];\n  actions: ActionSource | null;\n  deps: DepRegistry | null;\n  routingKinds: readonly string[];\n}\n\nfunction routesOf(binding: GestureBinding): string[] {\n  try {\n    return [...routesForSpec(binding.spec)];\n  } catch {\n    return [];\n  }\n}\n\nfunction bindingOf(binding: GestureBinding): DevtoolsBinding {\n  return {\n    actionId: binding.actionId,\n    spec: serialize(binding.spec),\n    routes: routesOf(binding),\n    opts: serialize(binding.opts),\n  };\n}\n\nfunction toolOf(entry: Entry, slot: DevtoolsToolEntry['slot']): DevtoolsToolEntry {\n  const p = entry.presentation;\n  return {\n    id: entry.id,\n    slot,\n    label: p?.label ?? entry.id,\n    icon: p?.icon ?? null,\n    group: p?.group ?? null,\n    shortcut: p?.shortcut ?? null,\n    hotkey: entry.eligibility?.offhand ?? null,\n    hidden: p?.hide === true,\n    cursor: serialize(entry.cursor),\n    eligibility: serialize(entry.eligibility),\n    bindings: (entry.bindings ?? []).map(bindingOf),\n    actions: (entry.actions ?? []).map((a) => a.id),\n    deps: Object.keys(entry.deps ?? {}),\n    hasOverlay: entry.overlay !== undefined,\n  };\n}\n\nfunction actionOf(action: Action, deps: DepRegistry | null): DevtoolsActionEntry {\n  const bag = deps ? buildDepsFromRequires(action, deps) : undefined;\n  const enabled = evaluateEnabled(action, bag);\n  const rule: unknown = action.eligible;\n  return {\n    id: action.id,\n    label: action.label ?? action.id,\n    icon: action.icon ?? null,\n    group: action.group ?? null,\n    tags: [...(action.tags ?? [])],\n    shortcut: action.shortcut ?? null,\n    scope: action.scope === 'hotkey' ? 'hotkey' : 'ambient',\n    invoker: action.invoker?.timing ?? null,\n    requires: [...(action.requires ?? [])],\n    variants: (action.variants ?? []).map((v) => ({\n      key: v.key, label: v.label, icon: v.icon ?? null, params: serialize(v.params),\n    })),\n    enabled: enabled.enabled ? true : (enabled.reason ?? 'disabled'),\n    active: evaluateActive(action, bag) ?? null,\n    hasPreview: action.preview !== undefined,\n    // A fluent condition is callable and carries its rule tree on `.rule`.\n    eligible: serialize(typeof rule === 'function' ? (rule as { rule?: unknown }).rule : (rule ?? null)),\n    bindings: actionBindings(action).map(bindingOf),\n  };\n}\n\nexport function describeRegistry(inputs: RegistryInputs): DevtoolsRegistry {\n  const seen = new Set<string>();\n  const tools: DevtoolsToolEntry[] = [];\n  const add = (entries: readonly Entry[], slot: DevtoolsToolEntry['slot']): void => {\n    for (const e of entries) {\n      if (seen.has(e.id)) continue;\n      seen.add(e.id);\n      tools.push(toolOf(e, slot));\n    }\n  };\n  add(Object.values(inputs.tools.registry), 'tool');\n  add(inputs.tools.ambient, 'ambient');\n  add(inputs.contributions, 'contribution');\n  return {\n    tools,\n    actions: (inputs.actions?.list() ?? []).map((a) => actionOf(a, inputs.deps)),\n    deps: (inputs.deps?.list?.() ?? []).map((d) => ({ ...d })),\n    routingKinds: [...inputs.routingKinds],\n  };\n}\n"],"mappings":";;;;;AAsBA,SAAS,SAAS,SAAmC;CACnD,IAAI;EACF,OAAO,CAAC,GAAG,cAAc,QAAQ,IAAI,CAAC;CACxC,QAAQ;EACN,OAAO,CAAC;CACV;AACF;AAEA,SAAS,UAAU,SAA0C;CAC3D,OAAO;EACL,UAAU,QAAQ;EAClB,MAAM,UAAU,QAAQ,IAAI;EAC5B,QAAQ,SAAS,OAAO;EACxB,MAAM,UAAU,QAAQ,IAAI;CAC9B;AACF;AAEA,SAAS,OAAO,OAAc,MAAoD;CAChF,MAAM,IAAI,MAAM;CAChB,OAAO;EACL,IAAI,MAAM;EACV;EACA,OAAO,GAAG,SAAS,MAAM;EACzB,MAAM,GAAG,QAAQ;EACjB,OAAO,GAAG,SAAS;EACnB,UAAU,GAAG,YAAY;EACzB,QAAQ,MAAM,aAAa,WAAW;EACtC,QAAQ,GAAG,SAAS;EACpB,QAAQ,UAAU,MAAM,MAAM;EAC9B,aAAa,UAAU,MAAM,WAAW;EACxC,WAAW,MAAM,YAAY,CAAC,EAAA,CAAG,IAAI,SAAS;EAC9C,UAAU,MAAM,WAAW,CAAC,EAAA,CAAG,KAAK,MAAM,EAAE,EAAE;EAC9C,MAAM,OAAO,KAAK,MAAM,QAAQ,CAAC,CAAC;EAClC,YAAY,MAAM,YAAY;CAChC;AACF;AAEA,SAAS,SAAS,QAAgB,MAA+C;CAC/E,MAAM,MAAM,OAAO,sBAAsB,QAAQ,IAAI,IAAI;CACzD,MAAM,UAAU,gBAAgB,QAAQ,GAAG;CAC3C,MAAM,OAAgB,OAAO;CAC7B,OAAO;EACL,IAAI,OAAO;EACX,OAAO,OAAO,SAAS,OAAO;EAC9B,MAAM,OAAO,QAAQ;EACrB,OAAO,OAAO,SAAS;EACvB,MAAM,CAAC,GAAI,OAAO,QAAQ,CAAC,CAAE;EAC7B,UAAU,OAAO,YAAY;EAC7B,OAAO,OAAO,UAAU,WAAW,WAAW;EAC9C,SAAS,OAAO,SAAS,UAAU;EACnC,UAAU,CAAC,GAAI,OAAO,YAAY,CAAC,CAAE;EACrC,WAAW,OAAO,YAAY,CAAC,EAAA,CAAG,KAAK,OAAO;GAC5C,KAAK,EAAE;GAAK,OAAO,EAAE;GAAO,MAAM,EAAE,QAAQ;GAAM,QAAQ,UAAU,EAAE,MAAM;EAC9E,EAAE;EACF,SAAS,QAAQ,UAAU,OAAQ,QAAQ,UAAU;EACrD,QAAQ,eAAe,QAAQ,GAAG,KAAK;EACvC,YAAY,OAAO,YAAY;EAE/B,UAAU,UAAU,OAAO,SAAS,aAAc,KAA4B,OAAQ,QAAQ,IAAK;EACnG,UAAU,eAAe,MAAM,CAAC,CAAC,IAAI,SAAS;CAChD;AACF;AAEA,SAAgB,iBAAiB,QAA0C;CACzE,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,QAA6B,CAAC;CACpC,MAAM,OAAO,SAA2B,SAA0C;EAChF,KAAK,MAAM,KAAK,SAAS;GACvB,IAAI,KAAK,IAAI,EAAE,EAAE,GAAG;GACpB,KAAK,IAAI,EAAE,EAAE;GACb,MAAM,KAAK,OAAO,GAAG,IAAI,CAAC;EAC5B;CACF;CACA,IAAI,OAAO,OAAO,OAAO,MAAM,QAAQ,GAAG,MAAM;CAChD,IAAI,OAAO,MAAM,SAAS,SAAS;CACnC,IAAI,OAAO,eAAe,cAAc;CACxC,OAAO;EACL;EACA,UAAU,OAAO,SAAS,KAAK,KAAK,CAAC,EAAA,CAAG,KAAK,MAAM,SAAS,GAAG,OAAO,IAAI,CAAC;EAC3E,OAAO,OAAO,MAAM,OAAO,KAAK,CAAC,EAAA,CAAG,KAAK,OAAO,EAAE,GAAG,EAAE,EAAE;EACzD,cAAc,CAAC,GAAG,OAAO,YAAY;CACvC;AACF"}
+{"version":3,"file":"registry.js","names":[],"sources":["../../src/devtools/registry.ts"],"sourcesContent":["/** What one canvas has registered — its tools, actions, deps and node kinds — as plain data for `get-registry`. */\nimport {\n  actionBindings, buildDepsFromRequires, evaluateActive, evaluateEnabled, overriddenBindings, routesForSpec,\n  type Action, type ActionSource, type Contribution, type DepRegistry, type GestureBinding, type ResolvedBindingOverrides,\n} from '@weasel-js/routing';\nimport type {\n  DevtoolsActionEntry, DevtoolsBinding, DevtoolsRegistry, DevtoolsToolEntry,\n} from './protocol';\nimport { serialize } from './serialize';\n\ntype Entry = Contribution<unknown> & { cursor?: unknown };\n\n/** The live registries {@link describeRegistry} reads. */\nexport interface RegistryInputs {\n  tools: { registry: Readonly<Record<string, Entry>>; ambient: readonly Entry[] };\n  /** The entries a `features` preset brought beside the tools. */\n  contributions: readonly Entry[];\n  actions: ActionSource | null;\n  /** Binding overrides in force, applied to the entries' bindings; `actions`\n   *  lists its own already overridden. */\n  overrides?: ResolvedBindingOverrides;\n  deps: DepRegistry | null;\n  routingKinds: readonly string[];\n}\n\nfunction routesOf(binding: GestureBinding): string[] {\n  try {\n    return [...routesForSpec(binding.spec)];\n  } catch {\n    return [];\n  }\n}\n\nfunction bindingOf(binding: GestureBinding): DevtoolsBinding {\n  return {\n    actionId: binding.actionId,\n    spec: serialize(binding.spec),\n    routes: routesOf(binding),\n    opts: serialize(binding.opts),\n  };\n}\n\nfunction toolOf(entry: Entry, slot: DevtoolsToolEntry['slot'], overrides: ResolvedBindingOverrides | undefined): DevtoolsToolEntry {\n  const p = entry.presentation;\n  return {\n    id: entry.id,\n    slot,\n    label: p?.label ?? entry.id,\n    icon: p?.icon ?? null,\n    group: p?.group ?? null,\n    shortcut: p?.shortcut ?? null,\n    hotkey: entry.eligibility?.offhand ?? null,\n    hidden: p?.hide === true,\n    cursor: serialize(entry.cursor),\n    eligibility: serialize(entry.eligibility),\n    bindings: overriddenBindings(entry.bindings ?? [], entry.id, overrides).map(bindingOf),\n    actions: (entry.actions ?? []).map((a) => a.id),\n    deps: Object.keys(entry.deps ?? {}),\n    hasOverlay: entry.overlay !== undefined,\n  };\n}\n\nfunction actionOf(action: Action, deps: DepRegistry | null): DevtoolsActionEntry {\n  const bag = deps ? buildDepsFromRequires(action, deps) : undefined;\n  const enabled = evaluateEnabled(action, bag);\n  const rule: unknown = action.eligible;\n  return {\n    id: action.id,\n    label: action.label ?? action.id,\n    icon: action.icon ?? null,\n    group: action.group ?? null,\n    tags: [...(action.tags ?? [])],\n    shortcut: action.shortcut ?? null,\n    scope: action.scope === 'hotkey' ? 'hotkey' : 'ambient',\n    invoker: action.invoker?.timing ?? null,\n    requires: [...(action.requires ?? [])],\n    variants: (action.variants ?? []).map((v) => ({\n      key: v.key, label: v.label, icon: v.icon ?? null, params: serialize(v.params),\n    })),\n    enabled: enabled.enabled ? true : (enabled.reason ?? 'disabled'),\n    active: evaluateActive(action, bag) ?? null,\n    hasPreview: action.preview !== undefined,\n    // A fluent condition is callable and carries its rule tree on `.rule`.\n    eligible: serialize(typeof rule === 'function' ? (rule as { rule?: unknown }).rule : (rule ?? null)),\n    bindings: actionBindings(action).map(bindingOf),\n  };\n}\n\nexport function describeRegistry(inputs: RegistryInputs): DevtoolsRegistry {\n  const seen = new Set<string>();\n  const tools: DevtoolsToolEntry[] = [];\n  const add = (entries: readonly Entry[], slot: DevtoolsToolEntry['slot']): void => {\n    for (const e of entries) {\n      if (seen.has(e.id)) continue;\n      seen.add(e.id);\n      tools.push(toolOf(e, slot, inputs.overrides));\n    }\n  };\n  add(Object.values(inputs.tools.registry), 'tool');\n  add(inputs.tools.ambient, 'ambient');\n  add(inputs.contributions, 'contribution');\n  return {\n    tools,\n    actions: (inputs.actions?.list() ?? []).map((a) => actionOf(a, inputs.deps)),\n    deps: (inputs.deps?.list?.() ?? []).map((d) => ({ ...d })),\n    routingKinds: [...inputs.routingKinds],\n  };\n}\n"],"mappings":";;;;;AAyBA,SAAS,SAAS,SAAmC;CACnD,IAAI;EACF,OAAO,CAAC,GAAG,cAAc,QAAQ,IAAI,CAAC;CACxC,QAAQ;EACN,OAAO,CAAC;CACV;AACF;AAEA,SAAS,UAAU,SAA0C;CAC3D,OAAO;EACL,UAAU,QAAQ;EAClB,MAAM,UAAU,QAAQ,IAAI;EAC5B,QAAQ,SAAS,OAAO;EACxB,MAAM,UAAU,QAAQ,IAAI;CAC9B;AACF;AAEA,SAAS,OAAO,OAAc,MAAiC,WAAoE;CACjI,MAAM,IAAI,MAAM;CAChB,OAAO;EACL,IAAI,MAAM;EACV;EACA,OAAO,GAAG,SAAS,MAAM;EACzB,MAAM,GAAG,QAAQ;EACjB,OAAO,GAAG,SAAS;EACnB,UAAU,GAAG,YAAY;EACzB,QAAQ,MAAM,aAAa,WAAW;EACtC,QAAQ,GAAG,SAAS;EACpB,QAAQ,UAAU,MAAM,MAAM;EAC9B,aAAa,UAAU,MAAM,WAAW;EACxC,UAAU,mBAAmB,MAAM,YAAY,CAAC,GAAG,MAAM,IAAI,SAAS,CAAC,CAAC,IAAI,SAAS;EACrF,UAAU,MAAM,WAAW,CAAC,EAAA,CAAG,KAAK,MAAM,EAAE,EAAE;EAC9C,MAAM,OAAO,KAAK,MAAM,QAAQ,CAAC,CAAC;EAClC,YAAY,MAAM,YAAY;CAChC;AACF;AAEA,SAAS,SAAS,QAAgB,MAA+C;CAC/E,MAAM,MAAM,OAAO,sBAAsB,QAAQ,IAAI,IAAI;CACzD,MAAM,UAAU,gBAAgB,QAAQ,GAAG;CAC3C,MAAM,OAAgB,OAAO;CAC7B,OAAO;EACL,IAAI,OAAO;EACX,OAAO,OAAO,SAAS,OAAO;EAC9B,MAAM,OAAO,QAAQ;EACrB,OAAO,OAAO,SAAS;EACvB,MAAM,CAAC,GAAI,OAAO,QAAQ,CAAC,CAAE;EAC7B,UAAU,OAAO,YAAY;EAC7B,OAAO,OAAO,UAAU,WAAW,WAAW;EAC9C,SAAS,OAAO,SAAS,UAAU;EACnC,UAAU,CAAC,GAAI,OAAO,YAAY,CAAC,CAAE;EACrC,WAAW,OAAO,YAAY,CAAC,EAAA,CAAG,KAAK,OAAO;GAC5C,KAAK,EAAE;GAAK,OAAO,EAAE;GAAO,MAAM,EAAE,QAAQ;GAAM,QAAQ,UAAU,EAAE,MAAM;EAC9E,EAAE;EACF,SAAS,QAAQ,UAAU,OAAQ,QAAQ,UAAU;EACrD,QAAQ,eAAe,QAAQ,GAAG,KAAK;EACvC,YAAY,OAAO,YAAY;EAE/B,UAAU,UAAU,OAAO,SAAS,aAAc,KAA4B,OAAQ,QAAQ,IAAK;EACnG,UAAU,eAAe,MAAM,CAAC,CAAC,IAAI,SAAS;CAChD;AACF;AAEA,SAAgB,iBAAiB,QAA0C;CACzE,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,QAA6B,CAAC;CACpC,MAAM,OAAO,SAA2B,SAA0C;EAChF,KAAK,MAAM,KAAK,SAAS;GACvB,IAAI,KAAK,IAAI,EAAE,EAAE,GAAG;GACpB,KAAK,IAAI,EAAE,EAAE;GACb,MAAM,KAAK,OAAO,GAAG,MAAM,OAAO,SAAS,CAAC;EAC9C;CACF;CACA,IAAI,OAAO,OAAO,OAAO,MAAM,QAAQ,GAAG,MAAM;CAChD,IAAI,OAAO,MAAM,SAAS,SAAS;CACnC,IAAI,OAAO,eAAe,cAAc;CACxC,OAAO;EACL;EACA,UAAU,OAAO,SAAS,KAAK,KAAK,CAAC,EAAA,CAAG,KAAK,MAAM,SAAS,GAAG,OAAO,IAAI,CAAC;EAC3E,OAAO,OAAO,MAAM,OAAO,KAAK,CAAC,EAAA,CAAG,KAAK,OAAO,EAAE,GAAG,EAAE,EAAE;EACzD,cAAc,CAAC,GAAG,OAAO,YAAY;CACvC;AACF"}

package/dist/features/measure/measureContribution.js

@@ -40,14 +40,16 @@ function measurementsContribution(scene, ms) {
 				target: { kindOf: onMeasurement },
 				mods: MODS_ANY
 			},
-			actionId: MEASURE_ACTION_IDS.pick
+			actionId: MEASURE_ACTION_IDS.pick,
+			opts: { id: "weasel-measure.click" }
 		}, {
 			spec: {
 				kind: "drag",
 				target: { kindOf: onMeasurement },
 				mods: MODS_ANY
 			},
-			actionId: MEASURE_ACTION_IDS.drag
+			actionId: MEASURE_ACTION_IDS.drag,
+			opts: { id: "weasel-measure.drag" }
 		}]
 	};
 }

package/dist/features/measure/measureContribution.js.map

@@ -1 +1 @@
-{"version":3,"file":"measureContribution.js","names":[],"sources":["../../../src/features/measure/measureContribution.ts"],"sourcesContent":["import { hitPredicate } from '@weasel-js/gestures';\nimport type { Scene } from 'core/scene/types';\nimport type { SurfaceContribution } from 'canvas/surfaceContribution';\nimport type { Measurements } from './measurements';\nimport { measureCommands } from './measureCommands';\nimport { measureDragAction, measurePickAction } from './measureGestures';\nimport { MEASURE_AFFORDANCE_KIND, measurementsLayer } from './measureLayer';\nimport { MEASURE_ACTION_IDS } from './actionIds';\n\nconst onMeasurement = hitPredicate((hit) => (hit as { kind?: string } | null | undefined)?.kind === MEASURE_AFFORDANCE_KIND);\n\nconst MODS_ANY = { shift: 'optional', alt: 'optional', meta: 'optional', ctrl: 'optional' } as const;\n\n/**\n * A scene's measurements on a canvas, whatever tool is active: the layer\n * that shows the picked one and claims presses on measurements, a click on\n * one to pick it and a drag to edit it, and the commands — Move by, Rotate\n * by, Delete, Clear — a readout binds buttons to. Install it with\n * `<SceneCanvas ambient={[…]}>`; `useMeasureTool` adds the measuring itself.\n */\nexport function measurementsContribution(\n  scene: Scene<unknown, string, unknown>,\n  ms: Measurements,\n): SurfaceContribution {\n  const layer = measurementsLayer(scene, ms);\n  return {\n    id: 'weasel-measure',\n    eligibility: { claimed: true },\n    attach: (api) => {\n      const off = api.registerLayer(layer);\n      api.requestRedraw();\n      return off;\n    },\n    actions: [...measureCommands(ms), measurePickAction(ms), measureDragAction(ms)],\n    bindings: [\n      { spec: { kind: 'click', target: { kindOf: onMeasurement }, mods: MODS_ANY }, actionId: MEASURE_ACTION_IDS.pick },\n      { spec: { kind: 'drag', target: { kindOf: onMeasurement }, mods: MODS_ANY }, actionId: MEASURE_ACTION_IDS.drag },\n    ],\n  };\n}\n"],"mappings":";;;;;;;AASA,IAAM,gBAAgB,cAAc,QAAS,KAA8C,SAAS,uBAAuB;AAE3H,IAAM,WAAW;CAAE,OAAO;CAAY,KAAK;CAAY,MAAM;CAAY,MAAM;AAAW;;;;;;;;AAS1F,SAAgB,yBACd,OACA,IACqB;CACrB,MAAM,QAAQ,kBAAkB,OAAO,EAAE;CACzC,OAAO;EACL,IAAI;EACJ,aAAa,EAAE,SAAS,KAAK;EAC7B,SAAS,QAAQ;GACf,MAAM,MAAM,IAAI,cAAc,KAAK;GACnC,IAAI,cAAc;GAClB,OAAO;EACT;EACA,SAAS;GAAC,GAAG,gBAAgB,EAAE;GAAG,kBAAkB,EAAE;GAAG,kBAAkB,EAAE;EAAC;EAC9E,UAAU,CACR;GAAE,MAAM;IAAE,MAAM;IAAS,QAAQ,EAAE,QAAQ,cAAc;IAAG,MAAM;GAAS;GAAG,UAAU,mBAAmB;EAAK,GAChH;GAAE,MAAM;IAAE,MAAM;IAAQ,QAAQ,EAAE,QAAQ,cAAc;IAAG,MAAM;GAAS;GAAG,UAAU,mBAAmB;EAAK,CACjH;CACF;AACF"}
+{"version":3,"file":"measureContribution.js","names":[],"sources":["../../../src/features/measure/measureContribution.ts"],"sourcesContent":["import { hitPredicate } from '@weasel-js/gestures';\nimport type { Scene } from 'core/scene/types';\nimport type { SurfaceContribution } from 'canvas/surfaceContribution';\nimport type { Measurements } from './measurements';\nimport { measureCommands } from './measureCommands';\nimport { measureDragAction, measurePickAction } from './measureGestures';\nimport { MEASURE_AFFORDANCE_KIND, measurementsLayer } from './measureLayer';\nimport { MEASURE_ACTION_IDS } from './actionIds';\n\nconst onMeasurement = hitPredicate((hit) => (hit as { kind?: string } | null | undefined)?.kind === MEASURE_AFFORDANCE_KIND);\n\nconst MODS_ANY = { shift: 'optional', alt: 'optional', meta: 'optional', ctrl: 'optional' } as const;\n\n/**\n * A scene's measurements on a canvas, whatever tool is active: the layer\n * that shows the picked one and claims presses on measurements, a click on\n * one to pick it and a drag to edit it, and the commands — Move by, Rotate\n * by, Delete, Clear — a readout binds buttons to. Install it with\n * `<SceneCanvas ambient={[…]}>`; `useMeasureTool` adds the measuring itself.\n */\nexport function measurementsContribution(\n  scene: Scene<unknown, string, unknown>,\n  ms: Measurements,\n): SurfaceContribution {\n  const layer = measurementsLayer(scene, ms);\n  return {\n    id: 'weasel-measure',\n    eligibility: { claimed: true },\n    attach: (api) => {\n      const off = api.registerLayer(layer);\n      api.requestRedraw();\n      return off;\n    },\n    actions: [...measureCommands(ms), measurePickAction(ms), measureDragAction(ms)],\n    bindings: [\n      { spec: { kind: 'click', target: { kindOf: onMeasurement }, mods: MODS_ANY }, actionId: MEASURE_ACTION_IDS.pick, opts: { id: 'weasel-measure.click' } },\n      { spec: { kind: 'drag', target: { kindOf: onMeasurement }, mods: MODS_ANY }, actionId: MEASURE_ACTION_IDS.drag, opts: { id: 'weasel-measure.drag' } },\n    ],\n  };\n}\n"],"mappings":";;;;;;;AASA,IAAM,gBAAgB,cAAc,QAAS,KAA8C,SAAS,uBAAuB;AAE3H,IAAM,WAAW;CAAE,OAAO;CAAY,KAAK;CAAY,MAAM;CAAY,MAAM;AAAW;;;;;;;;AAS1F,SAAgB,yBACd,OACA,IACqB;CACrB,MAAM,QAAQ,kBAAkB,OAAO,EAAE;CACzC,OAAO;EACL,IAAI;EACJ,aAAa,EAAE,SAAS,KAAK;EAC7B,SAAS,QAAQ;GACf,MAAM,MAAM,IAAI,cAAc,KAAK;GACnC,IAAI,cAAc;GAClB,OAAO;EACT;EACA,SAAS;GAAC,GAAG,gBAAgB,EAAE;GAAG,kBAAkB,EAAE;GAAG,kBAAkB,EAAE;EAAC;EAC9E,UAAU,CACR;GAAE,MAAM;IAAE,MAAM;IAAS,QAAQ,EAAE,QAAQ,cAAc;IAAG,MAAM;GAAS;GAAG,UAAU,mBAAmB;GAAM,MAAM,EAAE,IAAI,uBAAuB;EAAE,GACtJ;GAAE,MAAM;IAAE,MAAM;IAAQ,QAAQ,EAAE,QAAQ,cAAc;IAAG,MAAM;GAAS;GAAG,UAAU,mBAAmB;GAAM,MAAM,EAAE,IAAI,sBAAsB;EAAE,CACtJ;CACF;AACF"}

package/dist/features/modes/modeTriggers.js

@@ -38,12 +38,16 @@ function triggerAction(mode, targets, enter, canEnter) {
 		if (id === void 0) return null;
 		return canEnter?.(mode.id, id) === false ? null : id;
 	};
+	const id = `mode.${mode.id}.trigger`;
 	return {
-		id: `mode.${mode.id}.trigger`,
+		id,
 		label: `Enter ${modeLabel(mode)}`,
 		defaultBinding: targets.map((kind) => ({
-			kind: "doubleClick",
-			target: `kind:${kind}`
+			spec: {
+				kind: "doubleClick",
+				target: `kind:${kind}`
+			},
+			opts: { id: `${id}.doubleClick.${kind}` }
 		})),
 		requires: ["hitAt"],
 		enabled: (deps, at) => targetAt(deps, at) !== null ? true : ActionDisabledReason.NotApplicable,

package/dist/features/modes/modeTriggers.js.map

@@ -1 +1 @@
-{"version":3,"file":"modeTriggers.js","names":[],"sources":["../../../src/features/modes/modeTriggers.ts"],"sourcesContent":["import { modeLabel, type ModeDefinition, type ModeRegistry } from '@weasel-js/modes';\nimport { ActionDisabledReason, type Action, type ActionDeps, type Contribution } from '@weasel-js/routing';\n\n/** What a mode's double-click trigger does. */\nexport interface ModeTriggerHandlers {\n  /** Enter mode `id` on the node `targetId`. Without it nothing is bound. */\n  enter?: (id: string, targetId: string) => void;\n  /**\n   * Whether mode `id` can be entered on `targetId` now. Where it says no the double-click falls\n   * through to the next binding on it, so a canvas action that already enters the mode on some\n   * of those nodes keeps them: `enterPathEdit` on a path with anchors, say. Default yes.\n   */\n  canEnter?: (id: string, targetId: string) => boolean;\n}\n\n/**\n * The registry's double-click entries as an always-on contribution: for each mode whose\n * `entry.trigger` is `'double-click-target'`, one action bound to a double-click on each routing\n * kind its `entry.targets` names, entering the mode on the node double-clicked. Install it with\n * `<SceneCanvas ambient>`, beside `modeShortcuts`.\n *\n * The target is the node the dispatcher classified the double-click on (the `hitAt` dep's\n * `doubleClick`, else its hit), the one the binding's `kind:` target matched: a double-click on\n * a grouped member names its outermost group inside `<SceneCanvas isolatedGroup>`. The action is live in every mode, the target mode\n * included, so a double-click on another node moves a mode onto it; `canEnter` and `enter`\n * decide what a switch from the current mode means.\n *\n * The bindings ride the ambient tier: a tool that claims the double-click itself, the pen\n * finishing a stroke, keeps it.\n */\nexport function modeTriggers(registry: ModeRegistry, handlers: ModeTriggerHandlers): Contribution<never> {\n  const actions: Action[] = [];\n  const { enter } = handlers;\n  if (enter) {\n    for (const mode of registry.list()) {\n      const targets = mode.entry?.trigger === 'double-click-target' ? mode.entry.targets ?? [] : [];\n      if (targets.length > 0) actions.push(triggerAction(mode, targets, enter, handlers.canEnter));\n    }\n  }\n  return { id: 'modes.triggers', eligibility: { always: true }, actions };\n}\n\nfunction triggerAction(\n  mode: ModeDefinition,\n  targets: readonly string[],\n  enter: (id: string, targetId: string) => void,\n  canEnter: ModeTriggerHandlers['canEnter'],\n): Action {\n  const targetAt = (deps: ActionDeps | undefined, at: { x: number; y: number } | undefined): string | null => {\n    if (!at) return null;\n    const hit = deps?.hitAt?.(at);\n    const id = (hit?.doubleClick ?? hit)?.id;\n    if (id === undefined) return null;\n    return canEnter?.(mode.id, id) === false ? null : id;\n  };\n  return {\n    id: `mode.${mode.id}.trigger`,\n    label: `Enter ${modeLabel(mode)}`,\n    defaultBinding: targets.map((kind) => ({ kind: 'doubleClick' as const, target: `kind:${kind}` as const })),\n    requires: ['hitAt'],\n    enabled: (deps, at) => (targetAt(deps, at) !== null ? true : ActionDisabledReason.NotApplicable),\n    invoker: {\n      timing: 'immediate',\n      run: (deps, params) => {\n        const x = params?.worldX, y = params?.worldY;\n        const id = typeof x === 'number' && typeof y === 'number' ? targetAt(deps, { x, y }) : null;\n        if (id !== null) enter(mode.id, id);\n      },\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,aAAa,UAAwB,UAAoD;CACvG,MAAM,UAAoB,CAAC;CAC3B,MAAM,EAAE,UAAU;CAClB,IAAI,OACF,KAAK,MAAM,QAAQ,SAAS,KAAK,GAAG;EAClC,MAAM,UAAU,KAAK,OAAO,YAAY,wBAAwB,KAAK,MAAM,WAAW,CAAC,IAAI,CAAC;EAC5F,IAAI,QAAQ,SAAS,GAAG,QAAQ,KAAK,cAAc,MAAM,SAAS,OAAO,SAAS,QAAQ,CAAC;CAC7F;CAEF,OAAO;EAAE,IAAI;EAAkB,aAAa,EAAE,QAAQ,KAAK;EAAG;CAAQ;AACxE;AAEA,SAAS,cACP,MACA,SACA,OACA,UACQ;CACR,MAAM,YAAY,MAA8B,OAA4D;EAC1G,IAAI,CAAC,IAAI,OAAO;EAChB,MAAM,MAAM,MAAM,QAAQ,EAAE;EAC5B,MAAM,MAAM,KAAK,eAAe,IAAA,EAAM;EACtC,IAAI,OAAO,QAAW,OAAO;EAC7B,OAAO,WAAW,KAAK,IAAI,EAAE,MAAM,QAAQ,OAAO;CACpD;CACA,OAAO;EACL,IAAI,QAAQ,KAAK,GAAG;EACpB,OAAO,SAAS,UAAU,IAAI;EAC9B,gBAAgB,QAAQ,KAAK,UAAU;GAAE,MAAM;GAAwB,QAAQ,QAAQ;EAAgB,EAAE;EACzG,UAAU,CAAC,OAAO;EAClB,UAAU,MAAM,OAAQ,SAAS,MAAM,EAAE,MAAM,OAAO,OAAO,qBAAqB;EAClF,SAAS;GACP,QAAQ;GACR,MAAM,MAAM,WAAW;IACrB,MAAM,IAAI,QAAQ,QAAQ,IAAI,QAAQ;IACtC,MAAM,KAAK,OAAO,MAAM,YAAY,OAAO,MAAM,WAAW,SAAS,MAAM;KAAE;KAAG;IAAE,CAAC,IAAI;IACvF,IAAI,OAAO,MAAM,MAAM,KAAK,IAAI,EAAE;GACpC;EACF;CACF;AACF"}
+{"version":3,"file":"modeTriggers.js","names":[],"sources":["../../../src/features/modes/modeTriggers.ts"],"sourcesContent":["import { modeLabel, type ModeDefinition, type ModeRegistry } from '@weasel-js/modes';\nimport { ActionDisabledReason, type Action, type ActionDeps, type Contribution } from '@weasel-js/routing';\n\n/** What a mode's double-click trigger does. */\nexport interface ModeTriggerHandlers {\n  /** Enter mode `id` on the node `targetId`. Without it nothing is bound. */\n  enter?: (id: string, targetId: string) => void;\n  /**\n   * Whether mode `id` can be entered on `targetId` now. Where it says no the double-click falls\n   * through to the next binding on it, so a canvas action that already enters the mode on some\n   * of those nodes keeps them: `enterPathEdit` on a path with anchors, say. Default yes.\n   */\n  canEnter?: (id: string, targetId: string) => boolean;\n}\n\n/**\n * The registry's double-click entries as an always-on contribution: for each mode whose\n * `entry.trigger` is `'double-click-target'`, one action bound to a double-click on each routing\n * kind its `entry.targets` names, entering the mode on the node double-clicked. Install it with\n * `<SceneCanvas ambient>`, beside `modeShortcuts`.\n *\n * The target is the node the dispatcher classified the double-click on (the `hitAt` dep's\n * `doubleClick`, else its hit), the one the binding's `kind:` target matched: a double-click on\n * a grouped member names its outermost group inside `<SceneCanvas isolatedGroup>`. The action is live in every mode, the target mode\n * included, so a double-click on another node moves a mode onto it; `canEnter` and `enter`\n * decide what a switch from the current mode means.\n *\n * The bindings ride the ambient tier: a tool that claims the double-click itself, the pen\n * finishing a stroke, keeps it.\n */\nexport function modeTriggers(registry: ModeRegistry, handlers: ModeTriggerHandlers): Contribution<never> {\n  const actions: Action[] = [];\n  const { enter } = handlers;\n  if (enter) {\n    for (const mode of registry.list()) {\n      const targets = mode.entry?.trigger === 'double-click-target' ? mode.entry.targets ?? [] : [];\n      if (targets.length > 0) actions.push(triggerAction(mode, targets, enter, handlers.canEnter));\n    }\n  }\n  return { id: 'modes.triggers', eligibility: { always: true }, actions };\n}\n\nfunction triggerAction(\n  mode: ModeDefinition,\n  targets: readonly string[],\n  enter: (id: string, targetId: string) => void,\n  canEnter: ModeTriggerHandlers['canEnter'],\n): Action {\n  const targetAt = (deps: ActionDeps | undefined, at: { x: number; y: number } | undefined): string | null => {\n    if (!at) return null;\n    const hit = deps?.hitAt?.(at);\n    const id = (hit?.doubleClick ?? hit)?.id;\n    if (id === undefined) return null;\n    return canEnter?.(mode.id, id) === false ? null : id;\n  };\n  const id = `mode.${mode.id}.trigger`;\n  return {\n    id,\n    label: `Enter ${modeLabel(mode)}`,\n    defaultBinding: targets.map((kind) => ({\n      spec: { kind: 'doubleClick' as const, target: `kind:${kind}` as const },\n      opts: { id: `${id}.doubleClick.${kind}` },\n    })),\n    requires: ['hitAt'],\n    enabled: (deps, at) => (targetAt(deps, at) !== null ? true : ActionDisabledReason.NotApplicable),\n    invoker: {\n      timing: 'immediate',\n      run: (deps, params) => {\n        const x = params?.worldX, y = params?.worldY;\n        const id = typeof x === 'number' && typeof y === 'number' ? targetAt(deps, { x, y }) : null;\n        if (id !== null) enter(mode.id, id);\n      },\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,aAAa,UAAwB,UAAoD;CACvG,MAAM,UAAoB,CAAC;CAC3B,MAAM,EAAE,UAAU;CAClB,IAAI,OACF,KAAK,MAAM,QAAQ,SAAS,KAAK,GAAG;EAClC,MAAM,UAAU,KAAK,OAAO,YAAY,wBAAwB,KAAK,MAAM,WAAW,CAAC,IAAI,CAAC;EAC5F,IAAI,QAAQ,SAAS,GAAG,QAAQ,KAAK,cAAc,MAAM,SAAS,OAAO,SAAS,QAAQ,CAAC;CAC7F;CAEF,OAAO;EAAE,IAAI;EAAkB,aAAa,EAAE,QAAQ,KAAK;EAAG;CAAQ;AACxE;AAEA,SAAS,cACP,MACA,SACA,OACA,UACQ;CACR,MAAM,YAAY,MAA8B,OAA4D;EAC1G,IAAI,CAAC,IAAI,OAAO;EAChB,MAAM,MAAM,MAAM,QAAQ,EAAE;EAC5B,MAAM,MAAM,KAAK,eAAe,IAAA,EAAM;EACtC,IAAI,OAAO,QAAW,OAAO;EAC7B,OAAO,WAAW,KAAK,IAAI,EAAE,MAAM,QAAQ,OAAO;CACpD;CACA,MAAM,KAAK,QAAQ,KAAK,GAAG;CAC3B,OAAO;EACL;EACA,OAAO,SAAS,UAAU,IAAI;EAC9B,gBAAgB,QAAQ,KAAK,UAAU;GACrC,MAAM;IAAE,MAAM;IAAwB,QAAQ,QAAQ;GAAgB;GACtE,MAAM,EAAE,IAAI,GAAG,GAAG,eAAe,OAAO;EAC1C,EAAE;EACF,UAAU,CAAC,OAAO;EAClB,UAAU,MAAM,OAAQ,SAAS,MAAM,EAAE,MAAM,OAAO,OAAO,qBAAqB;EAClF,SAAS;GACP,QAAQ;GACR,MAAM,MAAM,WAAW;IACrB,MAAM,IAAI,QAAQ,QAAQ,IAAI,QAAQ;IACtC,MAAM,KAAK,OAAO,MAAM,YAAY,OAAO,MAAM,WAAW,SAAS,MAAM;KAAE;KAAG;IAAE,CAAC,IAAI;IACvF,IAAI,OAAO,MAAM,MAAM,KAAK,IAAI,EAAE;GACpC;EACF;CACF;AACF"}

package/dist/features/pathEffects/effectSources.js

@@ -0,0 +1,60 @@
+import { pathEffectOf } from "../../core/scene/pathEffects/derive.js";
+import { isTextData } from "@weasel-js/text";
+
+//#region src/features/pathEffects/effectSources.ts
+/**
+* A path effect that hides its sources is edited through itself: its text and
+* its path are reached from the effect node.
+*/
+/**
+* For a path-effect node with `hideSources`, the source an edit of `role`
+* goes to: `'text'`, its first source when that is a text node; `'path'`, the
+* path it lays along — the second source of an along kind, a blend's spine.
+* `null` otherwise. The one answer every edit route asks.
+*/
+function effectSourceFor(scene, id, role) {
+	const node = scene.get(id);
+	const effect = pathEffectOf(node);
+	const sources = node?.dependsOn;
+	if (effect === null || effect.hideSources !== true || !Array.isArray(sources)) return null;
+	const source = sources[role === "text" ? 0 : effect.kind === "blend" ? 2 : 1];
+	const found = source === void 0 ? void 0 : scene.get(source);
+	if (found === void 0) return null;
+	return role === "text" && !isTextData(found.data) ? null : source;
+}
+/**
+* The sources a removal of `ids` takes with it: those that a path effect with
+* `hideSources` in the removal hid, and that nothing staying still derives
+* from. A source another effect still reads stays, and so does one shown
+* again since or named in `keep`. Transitive, so an effect's hidden effect
+* takes its own too.
+*/
+function hiddenSourcesTakenWith(scene, ids, keep = /* @__PURE__ */ new Set()) {
+	const going = new Set(scene.removalClosure(ids));
+	const taken = [];
+	const within = (node, root) => {
+		for (let at = node; at != null; at = scene.get(at)?.parent) if (at === root) return true;
+		return false;
+	};
+	let grew = true;
+	while (grew) {
+		grew = false;
+		for (const id of [...going]) {
+			const node = scene.get(id);
+			if (pathEffectOf(node)?.hideSources !== true || !Array.isArray(node?.dependsOn)) continue;
+			for (const source of node.dependsOn) {
+				if (going.has(source) || keep.has(source) || scene.get(source)?.hidden !== true) continue;
+				const closure = scene.removalClosure([source]);
+				if (!closure.every((n) => going.has(n) || within(n, source))) continue;
+				for (const n of closure) going.add(n);
+				taken.push(source);
+				grew = true;
+			}
+		}
+	}
+	return taken;
+}
+
+//#endregion
+export { effectSourceFor, hiddenSourcesTakenWith };
+//# sourceMappingURL=effectSources.js.map

package/dist/features/pathEffects/effectSources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effectSources.js","names":[],"sources":["../../../src/features/pathEffects/effectSources.ts"],"sourcesContent":["/**\n * A path effect that hides its sources is edited through itself: its text and\n * its path are reached from the effect node.\n */\nimport { isTextData } from '@weasel-js/text';\nimport { pathEffectOf } from 'core/scene/pathEffects/derive';\nimport type { NodeId, Scene } from 'core/scene/types';\n\n/**\n * For a path-effect node with `hideSources`, the source an edit of `role`\n * goes to: `'text'`, its first source when that is a text node; `'path'`, the\n * path it lays along — the second source of an along kind, a blend's spine.\n * `null` otherwise. The one answer every edit route asks.\n */\nexport function effectSourceFor<TData, TLayer extends string, TPose>(\n  scene: Pick<Scene<TData, TLayer, TPose>, 'get'>,\n  id: NodeId,\n  role: 'text' | 'path',\n): NodeId | null {\n  const node = scene.get(id);\n  const effect = pathEffectOf(node);\n  const sources = node?.dependsOn;\n  if (effect === null || effect.hideSources !== true || !Array.isArray(sources)) return null;\n  const at = role === 'text' ? 0 : effect.kind === 'blend' ? 2 : 1;\n  const source = (sources as readonly NodeId[])[at];\n  const found = source === undefined ? undefined : scene.get(source);\n  if (found === undefined) return null;\n  return role === 'text' && !isTextData(found.data) ? null : source!;\n}\n\n/**\n * The sources a removal of `ids` takes with it: those that a path effect with\n * `hideSources` in the removal hid, and that nothing staying still derives\n * from. A source another effect still reads stays, and so does one shown\n * again since or named in `keep`. Transitive, so an effect's hidden effect\n * takes its own too.\n */\nexport function hiddenSourcesTakenWith<TData, TLayer extends string, TPose>(\n  scene: Pick<Scene<TData, TLayer, TPose>, 'get' | 'removalClosure'>,\n  ids: readonly NodeId[],\n  keep: ReadonlySet<NodeId> = new Set(),\n): NodeId[] {\n  const going = new Set<NodeId>(scene.removalClosure(ids));\n  const taken: NodeId[] = [];\n  const within = (node: NodeId, root: NodeId): boolean => {\n    for (let at: NodeId | null | undefined = node; at != null; at = scene.get(at)?.parent) if (at === root) return true;\n    return false;\n  };\n  let grew = true;\n  while (grew) {\n    grew = false;\n    for (const id of [...going]) {\n      const node = scene.get(id);\n      if (pathEffectOf(node)?.hideSources !== true || !Array.isArray(node?.dependsOn)) continue;\n      for (const source of node.dependsOn as readonly NodeId[]) {\n        if (going.has(source) || keep.has(source) || scene.get(source)?.hidden !== true) continue;\n        const closure = scene.removalClosure([source]);\n        if (!closure.every((n) => going.has(n) || within(n, source))) continue;\n        for (const n of closure) going.add(n);\n        taken.push(source);\n        grew = true;\n      }\n    }\n  }\n  return taken;\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,SAAgB,gBACd,OACA,IACA,MACe;CACf,MAAM,OAAO,MAAM,IAAI,EAAE;CACzB,MAAM,SAAS,aAAa,IAAI;CAChC,MAAM,UAAU,MAAM;CACtB,IAAI,WAAW,QAAQ,OAAO,gBAAgB,QAAQ,CAAC,MAAM,QAAQ,OAAO,GAAG,OAAO;CAEtF,MAAM,SAAU,QADL,SAAS,SAAS,IAAI,OAAO,SAAS,UAAU,IAAI;CAE/D,MAAM,QAAQ,WAAW,SAAY,SAAY,MAAM,IAAI,MAAM;CACjE,IAAI,UAAU,QAAW,OAAO;CAChC,OAAO,SAAS,UAAU,CAAC,WAAW,MAAM,IAAI,IAAI,OAAO;AAC7D;;;;;;;;AASA,SAAgB,uBACd,OACA,KACA,uBAA4B,IAAI,IAAI,GAC1B;CACV,MAAM,QAAQ,IAAI,IAAY,MAAM,eAAe,GAAG,CAAC;CACvD,MAAM,QAAkB,CAAC;CACzB,MAAM,UAAU,MAAc,SAA0B;EACtD,KAAK,IAAI,KAAgC,MAAM,MAAM,MAAM,KAAK,MAAM,IAAI,EAAE,CAAC,EAAE,QAAQ,IAAI,OAAO,MAAM,OAAO;EAC/G,OAAO;CACT;CACA,IAAI,OAAO;CACX,OAAO,MAAM;EACX,OAAO;EACP,KAAK,MAAM,MAAM,CAAC,GAAG,KAAK,GAAG;GAC3B,MAAM,OAAO,MAAM,IAAI,EAAE;GACzB,IAAI,aAAa,IAAI,CAAC,EAAE,gBAAgB,QAAQ,CAAC,MAAM,QAAQ,MAAM,SAAS,GAAG;GACjF,KAAK,MAAM,UAAU,KAAK,WAAgC;IACxD,IAAI,MAAM,IAAI,MAAM,KAAK,KAAK,IAAI,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,EAAE,WAAW,MAAM;IACjF,MAAM,UAAU,MAAM,eAAe,CAAC,MAAM,CAAC;IAC7C,IAAI,CAAC,QAAQ,OAAO,MAAM,MAAM,IAAI,CAAC,KAAK,OAAO,GAAG,MAAM,CAAC,GAAG;IAC9D,KAAK,MAAM,KAAK,SAAS,MAAM,IAAI,CAAC;IACpC,MAAM,KAAK,MAAM;IACjB,OAAO;GACT;EACF;CACF;CACA,OAAO;AACT"}

package/dist/features/pathEffects/readSource.js

@@ -1,15 +1,31 @@
+import { noteFontRead } from "../../core/scene/fontReads.js";
 import { isRectPose } from "../../core/geometry/autoPoseDescriptor.js";
 import { pathPaintOf } from "../../canvas/nodeShapes/nodePaint.js";
 import { findNodeShape } from "../../canvas/NodeShape.js";
+import { textEffectItems } from "./textItems.js";
 import { pathThroughPoseFrame, poseLinearOf } from "@weasel-js/geom";
+import { isTextData } from "@weasel-js/text";
 
 //#region src/features/pathEffects/readSource.ts
 /**
 * How the kit's path effects read a source node: its outline from its
 * painter's silhouette, its paint as `kit:path` resolves it.
 */
-/** `dep` as a path effect's source, or `null` when it has no outline. */
+/** `dep` as a path effect's source, or `null` when it has no outline. A text
+*  node's source also carries its grapheme clusters as items. */
 function readEffectSource(dep) {
+	const data = dep.node.data;
+	const text = isTextData(data);
+	if (text) noteFontRead();
+	const source = readShape(dep);
+	const pose = dep.pose;
+	if (source === null || !text || !isRectPose(pose)) return source;
+	return {
+		...source,
+		items: () => textEffectItems(data, pose)
+	};
+}
+function readShape(dep) {
 	const data = dep.node.data ?? {};
 	const { fill, stroke } = pathPaintOf(data);
 	const paint = {