@weasel-js/core 1.13.0 → 1.14.1

package/dist/{types-BEdRIhNc.d.ts → types-DW14eu9B.d.ts}

@@ -1,6 +1,6 @@
 import * as _weasel_js_history from '@weasel-js/history';
 import { Op, SerializedHistory, History } from '@weasel-js/history';
-import { P as ParallaxOpts, C as ContainerBounds, L as LayoutStrategy } from './types-49uYJN3j.js';
+import { P as ParallaxOpts, C as ContainerBounds, L as LayoutStrategy } from './types-A_sNJYRd.js';
 import { UnitScope } from '@weasel-js/quantity';
 import { NodeId } from '@weasel-js/routing';
 import { Path, PoseLinear, Affine } from '@weasel-js/geom';
@@ -61,10 +61,11 @@ interface SceneBatchOptions {
 }
 
 /** The form a scene's undo entries are recorded in. A serialized history
- *  carries it, and one carrying another is not restored. Form 3 names
- *  nodes `mark` and `group`; form 2 held the scene's own ops for every edit,
- *  and before it an `applyBatch` entry held the ops it was given. */
-declare const SCENE_HISTORY_FORM = 3;
+ *  carries it, and one carrying another is not restored. Form 4 records a
+ *  child's pose in its container's frame; form 3 named nodes `mark` and
+ *  `group`; form 2 held the scene's own ops for every edit, and before it an
+ *  `applyBatch` entry held the ops it was given. */
+declare const SCENE_HISTORY_FORM = 4;
 /** What `Scene.serializeHistory` answers with. */
 interface SerializedSceneHistory extends SerializedHistory {
     form: typeof SCENE_HISTORY_FORM;
@@ -151,6 +152,19 @@ interface PoseAdapter<TPose> {
      *  means every node is one. A container whose pose derives from its children
      *  is not: its children share its frame, so the fold passes over it. */
     definesFrame?(id: string): boolean;
+    /** The frame `id` gives its children, from `world`, the frame its own pose
+     *  folds to. Absent means `world` itself. A view that scrolls a container's
+     *  content answers the frame moved by that offset (`scrolledFrames`); the
+     *  document's own readers and writers never carry it. */
+    childFrame?(id: string, world: TPose): TPose;
+}
+/** How far a container's content is scrolled, in the container's own axes:
+ *  its children are shown at their stored poses moved by minus this. `z` is
+ *  for a pose with a third axis, and a 2D composition ignores it. */
+interface ScrollOffset {
+    readonly x: number;
+    readonly y: number;
+    readonly z?: number;
 }
 /**
  * What a container's pose does to its children under a `compose`: nothing,
@@ -161,17 +175,24 @@ interface PoseAdapter<TPose> {
 type PoseClosure = 'identity' | 'translation' | 'rigid';
 /** Consumer's pose-composition strategy for hierarchical scenes. `compose`
  *  folds a child's pose (in parent's frame) up to the next frame; `decompose`
- *  is its inverse. Default is IDENTITY — an absolute-pose scene where every
- *  node already stores world coords (parent is grouping-only, no transform). */
+ *  is its inverse. A scene's default is `RIGID_POSE_COMPOSITION`. */
 interface PoseComposition<TPose> {
     compose(parent: TPose, child: TPose): TPose;
     decompose(parent: TPose, world: TPose): TPose;
     closure: PoseClosure;
+    /** `frame` with its content scrolled by `offset`: the frame a child composed
+     *  under it lands where `compose(frame, child)` would put the child moved by
+     *  minus `offset` in `frame`'s own axes. Absent, a container's content cannot
+     *  be scrolled under this composition. */
+    scroll?(frame: TPose, offset: ScrollOffset): TPose;
 }
-/** Default pose-composition strategy: IDENTITY, an absolute-pose scene. */
-declare const IDENTITY_POSE_COMPOSITION: PoseComposition<unknown>;
+/** The absolute-pose strategy: every node stores its world pose, and a
+ *  container groups its children without carrying them — moving it moves
+ *  nothing else. For a scene whose poses have no frame to fold, such as one
+ *  whose readers take every stored pose as world. */
+declare const IDENTITY_POSE_COMPOSITION: PoseComposition<never>;
 /** Whether `composition` makes a container's pose a frame, so a stored pose
- *  is local to it. False for the absolute-pose model. */
+ *  is local to it. False for `IDENTITY_POSE_COMPOSITION`. */
 declare function composesFrames(composition: {
     closure: PoseClosure;
 }): boolean;
@@ -183,6 +204,12 @@ declare function composesFrames(composition: {
  * local frame* and returns the equivalent pose in the next frame up.
  */
 declare function composeWorldPose<TPose>(adapter: PoseAdapter<TPose>, id: string, compose: (parent: TPose, child: TPose) => TPose): TPose;
+/** World pose of the frame `id`'s children are expressed in: its own world
+ *  pose, through the adapter's `childFrame` when it has one and `id` is a
+ *  frame. */
+declare function composeChildFrame<TPose>(adapter: PoseAdapter<TPose>, id: string, compose: (parent: TPose, child: TPose) => TPose): TPose;
+/** The frame `id` gives its children when its own pose folds to `world`. */
+declare function childFrameAt<TPose>(adapter: PoseAdapter<TPose>, id: string, world: TPose): TPose;
 /**
  * Convert `worldPose` into a local pose expressed under `newParentId`'s
  * frame, so a reparented child keeps its visual world position.
@@ -394,7 +421,8 @@ interface SerializedLayer<TLayer extends string> extends SystemLayerSpec<TLayer>
  *  (e.g., `clipFromPose`) appear as string keys (`clipFromPoseKey`) and
  *  are resolved through `SceneRegistry` at load time. */
 interface SerializedScene<TData, TLayer extends string, TPose> {
-    version: 2;
+    /** 3 stores a child's pose in its container's frame. */
+    version: 3;
     /** The whole layer stack, system and user alike — the name predates user
      *  layers and is kept so existing snapshots still parse. */
     systemLayers: readonly SerializedLayer<TLayer>[];
@@ -437,16 +465,24 @@ interface SerializedNode<TData, TLayer extends string, TPose> {
     units?: UnitScope;
     /** Mirrors `SceneNode.clip`. Omitted when the node declares none. */
     clip?: NodeClip;
+    /** Mirrors `SceneNode.consumesChildren`. Omitted when the node draws its children. */
+    consumesChildren?: boolean;
 }
 /** A node as version 1 saves wrote it: the kinds were `leaf` and `container`. */
 interface SerializedNodeV1<TData, TLayer extends string, TPose> extends Omit<SerializedNode<TData, TLayer, TPose>, 'kind'> {
     kind: 'leaf' | 'container';
 }
-/** A version 1 save, still read and never written. */
+/** A version 1 save, still read and never written: every pose in it is world. */
 interface SerializedSceneV1<TData, TLayer extends string, TPose> extends Omit<SerializedScene<TData, TLayer, TPose>, 'version' | 'nodes'> {
     version: 1;
     nodes: readonly SerializedNodeV1<TData, TLayer, TPose>[];
 }
+/** A version 2 save, still read and never written: every pose in it is world. */
+interface SerializedSceneV2<TData, TLayer extends string, TPose> extends Omit<SerializedScene<TData, TLayer, TPose>, 'version'> {
+    version: 2;
+}
+/** Any save a scene reads: the current version or an older one. */
+type SavedScene<TData, TLayer extends string, TPose> = SerializedScene<TData, TLayer, TPose> | SerializedSceneV2<TData, TLayer, TPose> | SerializedSceneV1<TData, TLayer, TPose>;
 
 /**
  * A scene's document values. Keys are namespaced by their owner
@@ -481,6 +517,48 @@ interface SceneDeclaredFieldSetters {
     setClip(id: NodeId, clip: NodeClip | null): void;
 }
 
+/** The scene's scroll offsets, one per scrolled container. */
+interface ScrollOffsets {
+    /** How far `id`'s content is scrolled, or `undefined` when it is not. */
+    get(id: NodeId): ScrollOffset | undefined;
+    /** Scroll `id`'s content to `offset`. `null`, or an offset of zero on every
+     *  axis, unscrolls it. */
+    set(id: NodeId, offset: ScrollOffset | null): void;
+    /** The scrolled containers. */
+    ids(): IterableIterator<NodeId>;
+    /** Unscroll everything. */
+    clearAll(): void;
+    subscribe(listener: () => void): () => void;
+    /** Bumped by every change, for a cache keyed on what the view shows. */
+    getGeneration(): number;
+}
+/** The scroll store a `Scene` carries. */
+interface SceneScroll {
+    /** How far each container's content is scrolled. Like the selection, view
+     *  state shared by every view over the scene: never document content, never
+     *  recorded or serialized, and it does not bump the scene's version. */
+    readonly scroll: ScrollOffsets;
+}
+/** Build an empty {@link ScrollOffsets}. */
+declare function createScrollOffsets(): ScrollOffsets;
+/** What `scrolledFrames` reads of a scene. Partial stand-ins without a
+ *  `scroll` store read as unscrolled. */
+interface ScrollSource<TPose> {
+    readonly overrides?: unknown;
+    readonly scroll?: ScrollOffsets;
+    readonly composition?: PoseComposition<TPose>;
+}
+/**
+ * The view-side fold's `PoseAdapter.childFrame` over `scene`: each scrolled
+ * container's frame moved by its offset. `undefined` when the scene has no
+ * scroll store, its composition cannot scroll, or it is a `documentOf` view,
+ * which reads as the document holds it, so a reader skips the step.
+ */
+declare function scrolledFrames<TPose>(scene: ScrollSource<TPose>): ((id: string, world: TPose) => TPose) | undefined;
+/** `adapter` read as the view shows it: with `scene`'s scrolled frames as its
+ *  `childFrame`. The same adapter when nothing can scroll. */
+declare function viewPoseAdapter<TPose, A extends PoseAdapter<TPose>>(scene: ScrollSource<TPose>, adapter: A): A;
+
 /**
  * Decides what one edit's changes to containers do to their children.
  * `arrivals` maps each container to the ids that joined it — by an `add`
@@ -522,6 +600,8 @@ interface RegisteredOp<P> {
  * two readers that turn one back into layer records and node specs.
  */
 
+/** Whether `value` is a snapshot `specsFromSerialized` reads, as against a live scene. */
+declare function isSerializedScene<TData, TLayer extends string, TPose>(value: unknown): value is SavedScene<TData, TLayer, TPose>;
 /** Decides what a version 1 `container` becomes; `leaf` is always a mark. */
 type V1Classifier<TData, TLayer extends string, TPose> = (node: SerializedNodeV1<TData, TLayer, TPose>) => 'mark' | 'group';
 /** Options for {@link specsFromSerialized}. */
@@ -534,6 +614,9 @@ interface SpecsFromSerializedOptions<TData, TLayer extends string, TPose> {
     unknownKeys?: 'throw' | 'skip';
     /** Hears each key `unknownKeys: 'skip'` leaves out, as it is left out. */
     onSkip?: (skipped: SkippedKey) => void;
+    /** How a version 1 or 2 save's world poses are made local to their
+     *  containers' frames. Default `RIGID_POSE_COMPOSITION`; a scene passes its own. */
+    composition?: PoseComposition<TPose>;
 }
 /** A registry key a load left out: the node, the function field it named,
  *  and the key. */
@@ -547,8 +630,8 @@ interface SkippedKey {
  *  resolves every `NODE_FN_FIELDS` key → function via the registry;
  *  throws on an unsupported version, and on an unknown registry key unless
  *  `opts.unknownKeys` is `'skip'`. */
-declare function specsFromSerialized<TData, TLayer extends string, TPose>(json: SerializedScene<TData, TLayer, TPose> | SerializedSceneV1<TData, TLayer, TPose>, registry: SceneRegistry<TPose, TData, TLayer>, opts?: SpecsFromSerializedOptions<TData, TLayer, TPose>): AddNodeSpec<TData, TLayer, TPose>[];
-/** The kind a saved node loads as: its own on version 2; on version 1 a `leaf` is a
+declare function specsFromSerialized<TData, TLayer extends string, TPose>(json: SavedScene<TData, TLayer, TPose>, registry: SceneRegistry<TPose, TData, TLayer>, opts?: SpecsFromSerializedOptions<TData, TLayer, TPose>): AddNodeSpec<TData, TLayer, TPose>[];
+/** The kind a saved node loads as: its own from version 2; on version 1 a `leaf` is a
  *  mark and a `container` goes to `classify`, or is a group without one. */
 declare function nodeKindOf<TData, TLayer extends string, TPose>(version: 1 | 2, n: SerializedNode<TData, TLayer, TPose> | SerializedNodeV1<TData, TLayer, TPose>, classify?: V1Classifier<TData, TLayer, TPose>): 'mark' | 'group';
 
@@ -646,6 +729,10 @@ interface DerivedDep<TPose, TData = unknown, TLayer extends string = string> {
      *  `undefined` when it inherits nothing. A dependency built by hand rather
      *  than by the scene may leave it out, and then inherits nothing. */
     readonly inherited?: InheritedPaint;
+    /** Its children, as dependencies in the frame its own pose is in: what a
+     *  derivation reading through a group to its contents walks. Resolved on
+     *  each read; absent where the lookup cannot list them. */
+    readonly children?: readonly (DerivedDep<TPose, TData, TLayer> | undefined)[];
 }
 /** `F` with its parameters checked bivariantly, as a method's are, so that a
  *  `Scene<D, L, MyPose>` is a `Scene<unknown, string, unknown>`. A callback for
@@ -668,6 +755,22 @@ type ClipFromPoseFn<TPose> = Bivariant<(pose: TPose) => Path | null>;
  *  carries the children, as drawn, to one copy. */
 type CopiesFromPoseFn<TPose, TData = unknown, TLayer extends string = string> = Bivariant<(pose: TPose, node: Node<TData, TLayer, TPose>) => readonly Affine[] | null>;
 
+/** Per-scene registry mapping string keys to live function references.
+ *  Passed to `createScene({ ..., registry })` and `sceneFromJSON(json, { registry })`.
+ *  Each function-field type has its own keyed map. */
+interface SceneRegistry<TPose, TData = unknown, TLayer extends string = string> {
+    /** Maps registry keys to `clipFromPose` factory functions for nodes. */
+    clipFromPose?: Readonly<Record<string, ClipFromPoseFn<TPose>>>;
+    /** Maps registry keys to `copiesFromPose` functions for nodes. */
+    copiesFromPose?: Readonly<Record<string, CopiesFromPoseFn<TPose, TData, TLayer>>>;
+    /** Maps registry keys to `derivePath` functions for nodes with `dependsOn`. */
+    derivePath?: Readonly<Record<string, DerivePathFn<TPose, TData, TLayer>>>;
+    /** Maps registry keys to `derivePose` functions for nodes with `dependsOn`. */
+    derivePose?: Readonly<Record<string, DerivePoseFn<TPose, TData, TLayer>>>;
+    /** Maps registry keys to layout strategies. */
+    layout?: Readonly<Record<string, LayoutStrategy<TPose>>>;
+}
+
 /** Brand a string as a NodeId. */
 declare const asNodeId: (s: string) => NodeId;
 
@@ -745,6 +848,12 @@ interface NodeBase<TData, TLayer extends string, TPose> {
      *  A copy is a copy of the clipped content — the clip travels with it.
      *  Re-evaluated each render; `null` or `[]` draws no copies. */
     copiesFromPose?: CopiesFromPoseFn<TPose, TData, TLayer>;
+    /** Its children are the operands of its own geometry, drawn only through
+     *  it: the render walk paints none of them, and a press, a region select
+     *  or select-all reaches one only while this node, or a group inside it, is
+     *  entered. A node that consumes its children is entered as a group is.
+     *  The boolean group (`booleanGroupFields`) is the kit's one. */
+    consumesChildren?: boolean;
     /** How this node arranges its children. Whenever the node's
      *  child set or order changes, its bounds change size, or a child's pose is
      *  written, the scene hands the change to the strategy — `depart` for children that left it,
@@ -791,6 +900,8 @@ interface AddNodeSpec<TData, TLayer extends string, TPose = RectPose> {
     clipFromPose?: ClipFromPoseFn<TPose>;
     /** Mirrors `SceneNode.clip`. */
     clip?: NodeClip;
+    /** Mirrors `SceneNode.consumesChildren`. */
+    consumesChildren?: boolean;
     /** Mirrors `SceneNode.copiesFromPose`. */
     copiesFromPose?: CopiesFromPoseFn<TPose, TData, TLayer>;
     /** Mirrors `SceneNode.dependsOn`. */
@@ -805,21 +916,6 @@ interface AddNodeSpec<TData, TLayer extends string, TPose = RectPose> {
     /** Mirrors `SceneNode.units`. */
     units?: UnitScope;
 }
-/** Per-scene registry mapping string keys to live function references.
- *  Passed to `createScene({ ..., registry })` and `sceneFromJSON(json, { registry })`.
- *  Each function-field type has its own keyed map. */
-interface SceneRegistry<TPose, TData = unknown, TLayer extends string = string> {
-    /** Maps registry keys to `clipFromPose` factory functions for nodes. */
-    clipFromPose?: Readonly<Record<string, ClipFromPoseFn<TPose>>>;
-    /** Maps registry keys to `copiesFromPose` functions for nodes. */
-    copiesFromPose?: Readonly<Record<string, CopiesFromPoseFn<TPose, TData, TLayer>>>;
-    /** Maps registry keys to `derivePath` functions for nodes with `dependsOn`. */
-    derivePath?: Readonly<Record<string, DerivePathFn<TPose, TData, TLayer>>>;
-    /** Maps registry keys to `derivePose` functions for nodes with `dependsOn`. */
-    derivePose?: Readonly<Record<string, DerivePoseFn<TPose, TData, TLayer>>>;
-    /** Maps registry keys to layout strategies. */
-    layout?: Readonly<Record<string, LayoutStrategy<TPose>>>;
-}
 /**
  * The kit-owned scene tree: nodes, layers, and the undo history over both.
  *
@@ -832,14 +928,13 @@ interface SceneRegistry<TPose, TData = unknown, TLayer extends string = string>
  * which the kit never inspects; `TPose` is the transform shape, `RectPose` by
  * default; `TLayer` is the union of layer names.
  */
-interface Scene<TData, TLayer extends string, TPose = RectPose> extends ScenePoseReports<TPose, Node<TData, TLayer, TPose>>, SceneChanges, SceneDocValues, SceneEditPasses, SceneDeclaredFieldSetters {
+interface Scene<TData, TLayer extends string, TPose = RectPose> extends ScenePoseReports<TPose, Node<TData, TLayer, TPose>>, SceneChanges, SceneDocValues, SceneEditPasses, SceneDeclaredFieldSetters, SceneScroll {
     readonly nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>;
     readonly roots: readonly NodeId[];
     readonly layers: readonly LayerRecord<TLayer>[];
-    /** The registry this scene resolves node functions against — the consumer's
-     *  entries over the kit's. */
+    /** The registry this scene resolves node functions against — the consumer's entries over the kit's. */
     readonly registry: SceneRegistry<TPose, TData, TLayer>;
-    /** See {@link UseSceneOptions.composition}. */
+    /** See {@link SceneOptions.composition}. */
     readonly composition: PoseComposition<TPose>;
     get(id: NodeId): Node<TData, TLayer, TPose> | undefined;
     /** A token for the node `id` names right now, for telling one node from a
@@ -1105,8 +1200,8 @@ interface Scene<TData, TLayer extends string, TPose = RectPose> extends ScenePos
      *  undo — which would revert to a state this replaces. Throws on an unsupported version or unknown registry/layer ids; on a
      *  malformed snapshot the scene is left empty or partially populated (callers should treat a
      *  `loadState` throw as fatal and reload). Snapshots from `toJSON()` are
-     *  always well-formed. `opts` reads the snapshot as `specsFromSerialized` does. */
-    loadState(json: SerializedScene<TData, TLayer, TPose> | SerializedSceneV1<TData, TLayer, TPose>, opts?: SpecsFromSerializedOptions<TData, TLayer, TPose>): void;
+     *  always well-formed. `opts` reads it as `specsFromSerialized` does, under the scene's composition. */
+    loadState(json: SavedScene<TData, TLayer, TPose>, opts?: Omit<SpecsFromSerializedOptions<TData, TLayer, TPose>, 'composition'>): void;
 }
 
-export { type V1Classifier as $, type AddNodeSpec as A, type Bivariant as B, type ClipFromPoseFn as C, type DerivePoseFn as D, type SceneBatchOptions as E, type SceneDeclaredFieldSetters as F, type GroupNode as G, type SceneDoc as H, type InheritedPaint as I, type SceneDocValues as J, type SceneEditPass as K, type LayoutFrame as L, type MarkNode as M, type Node as N, type SceneEditPassOptions as O, type PoseComposition as P, type SceneEditSummary as Q, type RectPose as R, type Scene as S, type SerializedDoc as T, type SerializedLayer as U, type SerializedNode as V, type SerializedNodeV1 as W, type SerializedSceneHistory as X, type SkippedKey as Y, type SystemLayerRecord as Z, type UserLayerRecord as _, type SystemLayerSpec as a, asNodeId as a0, composeWorldPose as a1, composesFrames as a2, inheritedPaintIn as a3, inheritedPaintOf as a4, inheritsPaint as a5, nodeKindOf as a6, rebaseLocalPose as a7, specsFromSerialized as a8, withInheritedPaint as a9, type RegisteredOp as b, type SceneRegistry as c, type PoseAdapter as d, type PoseRemoval as e, type PoseWrite as f, type ScenePoseReports as g, type PoseOverrides as h, type SerializedScene as i, type SerializedSceneV1 as j, type SpecsFromSerializedOptions as k, type NodeClip as l, type DerivePathFn as m, type DerivedDep as n, type AddLayerSpec as o, type CopiesFromPoseFn as p, IDENTITY_POSE_COMPOSITION as q, type LayerRecord as r, type LayoutMove as s, type PoseClosure as t, type PoseHold as u, type PoseOverride as v, type PoseWriteOrigin as w, type RemovedNode as x, SCENE_HISTORY_FORM as y, type SceneArrivalHandler as z };
+export { type SerializedSceneHistory as $, type AddNodeSpec as A, type Bivariant as B, type ClipFromPoseFn as C, type DerivePoseFn as D, type SceneArrivalHandler as E, type SceneBatchOptions as F, type GroupNode as G, type SceneDeclaredFieldSetters as H, type InheritedPaint as I, type SceneDoc as J, type SceneDocValues as K, type LayoutFrame as L, type MarkNode as M, type Node as N, type SceneEditPass as O, type PoseComposition as P, type SceneEditPassOptions as Q, type RectPose as R, type Scene as S, type SceneEditSummary as T, type SceneScroll as U, type ScrollOffsets as V, type ScrollSource as W, type SerializedDoc as X, type SerializedLayer as Y, type SerializedNode as Z, type SerializedNodeV1 as _, type SystemLayerSpec as a, type SerializedSceneV1 as a0, type SerializedSceneV2 as a1, type SkippedKey as a2, type SystemLayerRecord as a3, type UserLayerRecord as a4, type V1Classifier as a5, asNodeId as a6, childFrameAt as a7, composeChildFrame as a8, composeWorldPose as a9, composesFrames as aa, createScrollOffsets as ab, inheritedPaintIn as ac, inheritedPaintOf as ad, inheritsPaint as ae, isSerializedScene as af, nodeKindOf as ag, rebaseLocalPose as ah, scrolledFrames as ai, specsFromSerialized as aj, viewPoseAdapter as ak, withInheritedPaint as al, type RegisteredOp as b, type SceneRegistry as c, type ScrollOffset as d, type PoseAdapter as e, type PoseRemoval as f, type PoseWrite as g, type ScenePoseReports as h, type PoseOverrides as i, type SerializedScene as j, type SavedScene as k, type SpecsFromSerializedOptions as l, type NodeClip as m, type DerivePathFn as n, type DerivedDep as o, type AddLayerSpec as p, type CopiesFromPoseFn as q, IDENTITY_POSE_COMPOSITION as r, type LayerRecord as s, type LayoutMove as t, type PoseClosure as u, type PoseHold as v, type PoseOverride as w, type PoseWriteOrigin as x, type RemovedNode as y, SCENE_HISTORY_FORM as z };

package/dist/{types-p2alu-R1.d.ts → types-VCtfchp-.d.ts}

@@ -1,8 +1,9 @@
-import { L as LayoutStrategy, P as ParallaxOpts } from './types-49uYJN3j.js';
+import { L as LayoutStrategy, P as ParallaxOpts } from './types-A_sNJYRd.js';
 import { Op } from '@weasel-js/history';
 import { View } from '@weasel-js/geom';
-import { P as PoseDescriptor } from './poseDescriptor-DN2yfnq_.js';
+import { P as PoseDescriptor } from './poseDescriptor-CvSxVhCd.js';
 import { Target } from '@weasel-js/animator';
+import { WorldPoint } from '@weasel-js/routing';
 
 /**
  * Opaque clipboard payload: the kit never inspects entries. The adapter both
@@ -29,10 +30,7 @@ interface PasteOmission {
 }
 /** What `commitPaste` is told beyond the snapshot and the offset. */
 interface PasteCtx {
-    dropPoint?: {
-        worldX: number;
-        worldY: number;
-    };
+    dropPoint?: WorldPoint;
     /** Called once per copied node the paste leaves out. */
     onOmit?: (omission: PasteOmission) => void;
 }

package/dist/util/color.js

@@ -1,28 +1,23 @@
+import { tryNormalizeHex } from "@weasel-js/paint";
+
 //#region src/util/color.ts
 /** Color hex8 helpers. All stored colors are `#rrggbbaa`. `<input type="color">`
 *  only round-trips the 6-char form, so call-sites pad the saved alpha back on
 *  when the user picks via the native widget. */
 /** Expand `#rgb` / `#rgba` / `#rrggbb` to `#rrggbbaa`. Pads `ff` when no alpha
-*  channel is present. Non-hex inputs (named colors, `rgba(...)`) are
-*  returned unchanged — the kit's renderer accepts arbitrary CSS, and
-*  we only normalize the hex shapes we actually persist. */
+*  channel is present. Anything else — named colors, `rgba(...)`, a malformed
+*  `#` value — is returned unchanged: the kit's renderer accepts arbitrary CSS,
+*  and we only normalize the hex shapes we actually persist. */
 function toHex8(color) {
 	if (!color.startsWith("#")) return color;
-	const hex = color.slice(1);
-	if (hex.length === 3 || hex.length === 4) {
-		const [r, g, b, a = "f"] = hex.toLowerCase();
-		return `#${r}${r}${g}${g}${b}${b}${a}${a}`;
-	}
-	if (hex.length === 6) return `#${hex}ff`;
-	if (hex.length === 8) return color.toLowerCase();
-	return color;
+	return tryNormalizeHex(color, "rgba") ?? color;
 }
 /** Return the alpha channel of `color` as 0..1. Defaults to 1 when the
 *  color is not in 8-char hex form. */
 function getAlpha01(color) {
 	if (!color.startsWith("#") || color.length !== 9) return 1;
-	const a = parseInt(color.slice(7, 9), 16);
-	return Number.isFinite(a) ? a / 255 : 1;
+	const hex = tryNormalizeHex(color);
+	return hex ? Number.parseInt(hex.slice(7), 16) / 255 : 1;
 }
 /** Replace the alpha channel of `color` with `alpha01` (clamped to 0..1).
 *  Expands shorter hex forms first. Pass-through for non-hex inputs. */
@@ -38,7 +33,10 @@ function withAlpha01(color, alpha01) {
 *  `prev` is adopted, which handles the common case where `<input type="color">`
 *  strips the alpha channel and returns a bare 6-char hex. */
 function mergeAlphaFromPrev(picked, prev) {
-	if (picked.length === 9 && picked.startsWith("#")) return picked.toLowerCase();
+	if (picked.length === 9 && picked.startsWith("#")) {
+		const hex = tryNormalizeHex(picked);
+		if (hex) return hex;
+	}
 	return withAlpha01(picked, getAlpha01(prev));
 }
 

package/dist/util/color.js.map

@@ -1 +1 @@
-{"version":3,"file":"color.js","names":[],"sources":["../../src/util/color.ts"],"sourcesContent":["/** Color hex8 helpers. All stored colors are `#rrggbbaa`. `<input type=\"color\">`\n *  only round-trips the 6-char form, so call-sites pad the saved alpha back on\n *  when the user picks via the native widget. */\n\n/** Expand `#rgb` / `#rgba` / `#rrggbb` to `#rrggbbaa`. Pads `ff` when no alpha\n *  channel is present. Non-hex inputs (named colors, `rgba(...)`) are\n *  returned unchanged — the kit's renderer accepts arbitrary CSS, and\n *  we only normalize the hex shapes we actually persist. */\nexport function toHex8(color: string): string {\n  if (!color.startsWith('#')) return color;\n  const hex = color.slice(1);\n  if (hex.length === 3 || hex.length === 4) {\n    const [r, g, b, a = 'f'] = hex.toLowerCase();\n    return `#${r}${r}${g}${g}${b}${b}${a}${a}`;\n  }\n  if (hex.length === 6) return `#${hex}ff`;\n  if (hex.length === 8) return color.toLowerCase();\n  return color;\n}\n\n/** Return the alpha channel of `color` as 0..1. Defaults to 1 when the\n *  color is not in 8-char hex form. */\nexport function getAlpha01(color: string): number {\n  if (!color.startsWith('#') || color.length !== 9) return 1;\n  const a = parseInt(color.slice(7, 9), 16);\n  return Number.isFinite(a) ? a / 255 : 1;\n}\n\n/** Replace the alpha channel of `color` with `alpha01` (clamped to 0..1).\n *  Expands shorter hex forms first. Pass-through for non-hex inputs. */\nexport function withAlpha01(color: string, alpha01: number): string {\n  const a = Math.max(0, Math.min(1, alpha01));\n  const aa = Math.round(a * 255).toString(16).padStart(2, '0');\n  const eight = toHex8(color);\n  if (!eight.startsWith('#') || eight.length !== 9) return color;\n  return `${eight.slice(0, 7)}${aa}`;\n}\n\n/** Merge a freshly-picked color with the previous color's alpha channel.\n *  If `picked` is already in 8-char hex form (`#rrggbbaa`, length 9), it is\n *  used as-is — its explicit alpha is preserved. Otherwise the alpha from\n *  `prev` is adopted, which handles the common case where `<input type=\"color\">`\n *  strips the alpha channel and returns a bare 6-char hex. */\nexport function mergeAlphaFromPrev(picked: string, prev: string): string {\n  if (picked.length === 9 && picked.startsWith('#')) return picked.toLowerCase();\n  return withAlpha01(picked, getAlpha01(prev));\n}\n"],"mappings":";;;;;;;;AAQA,SAAgB,OAAO,OAAuB;CAC5C,IAAI,CAAC,MAAM,WAAW,GAAG,GAAG,OAAO;CACnC,MAAM,MAAM,MAAM,MAAM,CAAC;CACzB,IAAI,IAAI,WAAW,KAAK,IAAI,WAAW,GAAG;EACxC,MAAM,CAAC,GAAG,GAAG,GAAG,IAAI,OAAO,IAAI,YAAY;EAC3C,OAAO,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;CACzC;CACA,IAAI,IAAI,WAAW,GAAG,OAAO,IAAI,IAAI;CACrC,IAAI,IAAI,WAAW,GAAG,OAAO,MAAM,YAAY;CAC/C,OAAO;AACT;;;AAIA,SAAgB,WAAW,OAAuB;CAChD,IAAI,CAAC,MAAM,WAAW,GAAG,KAAK,MAAM,WAAW,GAAG,OAAO;CACzD,MAAM,IAAI,SAAS,MAAM,MAAM,GAAG,CAAC,GAAG,EAAE;CACxC,OAAO,OAAO,SAAS,CAAC,IAAI,IAAI,MAAM;AACxC;;;AAIA,SAAgB,YAAY,OAAe,SAAyB;CAElE,MAAM,KAAK,KAAK,MADN,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,OAAO,CACnB,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG;CAC3D,MAAM,QAAQ,OAAO,KAAK;CAC1B,IAAI,CAAC,MAAM,WAAW,GAAG,KAAK,MAAM,WAAW,GAAG,OAAO;CACzD,OAAO,GAAG,MAAM,MAAM,GAAG,CAAC,IAAI;AAChC;;;;;;AAOA,SAAgB,mBAAmB,QAAgB,MAAsB;CACvE,IAAI,OAAO,WAAW,KAAK,OAAO,WAAW,GAAG,GAAG,OAAO,OAAO,YAAY;CAC7E,OAAO,YAAY,QAAQ,WAAW,IAAI,CAAC;AAC7C"}
+{"version":3,"file":"color.js","names":[],"sources":["../../src/util/color.ts"],"sourcesContent":["import { tryNormalizeHex } from '@weasel-js/paint';\n\n/** Color hex8 helpers. All stored colors are `#rrggbbaa`. `<input type=\"color\">`\n *  only round-trips the 6-char form, so call-sites pad the saved alpha back on\n *  when the user picks via the native widget. */\n\n/** Expand `#rgb` / `#rgba` / `#rrggbb` to `#rrggbbaa`. Pads `ff` when no alpha\n *  channel is present. Anything else — named colors, `rgba(...)`, a malformed\n *  `#` value — is returned unchanged: the kit's renderer accepts arbitrary CSS,\n *  and we only normalize the hex shapes we actually persist. */\nexport function toHex8(color: string): string {\n  if (!color.startsWith('#')) return color;\n  return tryNormalizeHex(color, 'rgba') ?? color;\n}\n\n/** Return the alpha channel of `color` as 0..1. Defaults to 1 when the\n *  color is not in 8-char hex form. */\nexport function getAlpha01(color: string): number {\n  if (!color.startsWith('#') || color.length !== 9) return 1;\n  const hex = tryNormalizeHex(color);\n  return hex ? Number.parseInt(hex.slice(7), 16) / 255 : 1;\n}\n\n/** Replace the alpha channel of `color` with `alpha01` (clamped to 0..1).\n *  Expands shorter hex forms first. Pass-through for non-hex inputs. */\nexport function withAlpha01(color: string, alpha01: number): string {\n  const a = Math.max(0, Math.min(1, alpha01));\n  const aa = Math.round(a * 255).toString(16).padStart(2, '0');\n  const eight = toHex8(color);\n  if (!eight.startsWith('#') || eight.length !== 9) return color;\n  return `${eight.slice(0, 7)}${aa}`;\n}\n\n/** Merge a freshly-picked color with the previous color's alpha channel.\n *  If `picked` is already in 8-char hex form (`#rrggbbaa`, length 9), it is\n *  used as-is — its explicit alpha is preserved. Otherwise the alpha from\n *  `prev` is adopted, which handles the common case where `<input type=\"color\">`\n *  strips the alpha channel and returns a bare 6-char hex. */\nexport function mergeAlphaFromPrev(picked: string, prev: string): string {\n  if (picked.length === 9 && picked.startsWith('#')) {\n    const hex = tryNormalizeHex(picked);\n    if (hex) return hex;\n  }\n  return withAlpha01(picked, getAlpha01(prev));\n}\n"],"mappings":";;;;;;;;;;AAUA,SAAgB,OAAO,OAAuB;CAC5C,IAAI,CAAC,MAAM,WAAW,GAAG,GAAG,OAAO;CACnC,OAAO,gBAAgB,OAAO,MAAM,KAAK;AAC3C;;;AAIA,SAAgB,WAAW,OAAuB;CAChD,IAAI,CAAC,MAAM,WAAW,GAAG,KAAK,MAAM,WAAW,GAAG,OAAO;CACzD,MAAM,MAAM,gBAAgB,KAAK;CACjC,OAAO,MAAM,OAAO,SAAS,IAAI,MAAM,CAAC,GAAG,EAAE,IAAI,MAAM;AACzD;;;AAIA,SAAgB,YAAY,OAAe,SAAyB;CAElE,MAAM,KAAK,KAAK,MADN,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,OAAO,CACnB,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG;CAC3D,MAAM,QAAQ,OAAO,KAAK;CAC1B,IAAI,CAAC,MAAM,WAAW,GAAG,KAAK,MAAM,WAAW,GAAG,OAAO;CACzD,OAAO,GAAG,MAAM,MAAM,GAAG,CAAC,IAAI;AAChC;;;;;;AAOA,SAAgB,mBAAmB,QAAgB,MAAsB;CACvE,IAAI,OAAO,WAAW,KAAK,OAAO,WAAW,GAAG,GAAG;EACjD,MAAM,MAAM,gBAAgB,MAAM;EAClC,IAAI,KAAK,OAAO;CAClB;CACA,OAAO,YAAY,QAAQ,WAAW,IAAI,CAAC;AAC7C"}

package/dist/version.js

@@ -7,7 +7,7 @@
 * throwing, since nothing about version reporting should be able to break a
 * consumer's build.
 */
-var VERSION = "1.13.0";
+var VERSION = "1.14.1";
 
 //#endregion
 export { VERSION };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/core",
-  "version": "1.13.0",
+  "version": "1.14.1",
   "description": "A 2D scene-graph engine for React, rendered on WebGL2: the scene tree, viewport math, pointer and keyboard input, layered rendering, and op-based undo.",
   "weasel": {
     "needs": ["webgl2"]
@@ -110,30 +110,31 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "peerDependencies": {
-    "@weasel-js/font": "1.13.0",
+    "@weasel-js/font": "1.14.1",
     "react": ">=18"
   },
   "dependencies": {
     "@msb235/blits": "0.12.0",
-    "@weasel-js/animator": "1.13.0",
-    "@weasel-js/cursor": "1.13.0",
-    "@weasel-js/geom": "1.13.0",
-    "@weasel-js/gestures": "1.13.0",
-    "@weasel-js/history": "1.13.0",
-    "@weasel-js/icons": "1.13.0",
-    "@weasel-js/modes": "1.13.0",
-    "@weasel-js/paint": "1.13.0",
-    "@weasel-js/prefs": "1.13.0",
-    "@weasel-js/quantity": "1.13.0",
-    "@weasel-js/react": "1.13.0",
-    "@weasel-js/registry": "1.13.0",
-    "@weasel-js/renderer": "1.13.0",
-    "@weasel-js/routing": "1.13.0",
-    "@weasel-js/select": "1.13.0",
-    "@weasel-js/simulation": "1.13.0",
-    "@weasel-js/stroke": "1.13.0",
-    "@weasel-js/text": "1.13.0",
-    "@weasel-js/text-dom": "1.13.0",
+    "@weasel-js/animator": "1.14.1",
+    "@weasel-js/cursor": "1.14.1",
+    "@weasel-js/geom": "1.14.1",
+    "@weasel-js/gestures": "1.14.1",
+    "@weasel-js/headless": "1.14.1",
+    "@weasel-js/history": "1.14.1",
+    "@weasel-js/icons": "1.14.1",
+    "@weasel-js/modes": "1.14.1",
+    "@weasel-js/paint": "1.14.1",
+    "@weasel-js/prefs": "1.14.1",
+    "@weasel-js/quantity": "1.14.1",
+    "@weasel-js/react": "1.14.1",
+    "@weasel-js/registry": "1.14.1",
+    "@weasel-js/renderer": "1.14.1",
+    "@weasel-js/routing": "1.14.1",
+    "@weasel-js/select": "1.14.1",
+    "@weasel-js/simulation": "1.14.1",
+    "@weasel-js/stroke": "1.14.1",
+    "@weasel-js/text": "1.14.1",
+    "@weasel-js/text-dom": "1.14.1",
     "earcut": "3.2.3",
     "polygon-clipping": "^0.15.7"
   },
@@ -151,8 +152,8 @@
     "2d"
   ],
   "devDependencies": {
-    "@weasel-js/icons-plugin": "1.13.0",
-    "@weasel-js/modes": "1.13.0",
-    "@weasel-js/theme": "1.13.0"
+    "@weasel-js/icons-plugin": "1.14.1",
+    "@weasel-js/modes": "1.14.1",
+    "@weasel-js/theme": "1.14.1"
   }
 }

package/dist/canvas/poseCascade.js

@@ -1,65 +0,0 @@
-import { poseDescriptorForNode, translatePoseViaDescriptor } from "../core/geometry/poseDescriptor.js";
-
-//#region src/canvas/poseCascade.ts
-/** Every node under `id`, each after its parent. */
-function descendantsOf(scene, id) {
-	const out = [];
-	const collect = (root) => {
-		for (const child of scene.childrenOf(root)) {
-			out.push(child);
-			collect(child);
-		}
-	};
-	collect(id);
-	return out;
-}
-/**
-* How container `id`'s pose target carries its descendants where each holds a pose of its own
-* in the same space: `write` commits a pose and moves them, and while the container shows
-* somewhere else each is shown moved by as much.
-*/
-function containerCascade(scene, id, d, write) {
-	return {
-		write,
-		*beside(pose) {
-			const node = scene.get(id);
-			if (!node) return;
-			const g = poseDescriptorForNode(d, node);
-			const from = g.getBounds(node.pose);
-			const to = g.getBounds(pose);
-			for (const child of descendantsOf(scene, id)) {
-				const n = scene.get(child);
-				if (!n) continue;
-				yield [child, translatePoseViaDescriptor(n.pose, to.x - from.x, to.y - from.y, poseDescriptorForNode(d, n))];
-			}
-		}
-	};
-}
-/**
-* `setPose` for a scene of absolute poses: posing a container moves every
-* descendant by as much, in one undo step.
-*/
-function cascadingSetPose(scene, d) {
-	return (id, pose) => {
-		const node = scene.get(id);
-		if (!node || node.kind !== "group") return scene.setPose(id, pose);
-		const g = poseDescriptorForNode(d, node);
-		const from = g.getBounds(node.pose);
-		const to = g.getBounds(pose);
-		const dx = to.x - from.x;
-		const dy = to.y - from.y;
-		if (dx === 0 && dy === 0) return scene.setPose(id, pose);
-		scene.batch("move container", () => {
-			scene.setPose(id, pose);
-			for (const child of descendantsOf(scene, id)) {
-				const n = scene.get(child);
-				if (!n) continue;
-				scene.setPose(child, translatePoseViaDescriptor(n.pose, dx, dy, poseDescriptorForNode(d, n)));
-			}
-		});
-	};
-}
-
-//#endregion
-export { cascadingSetPose, containerCascade, descendantsOf };
-//# sourceMappingURL=poseCascade.js.map

package/dist/canvas/poseCascade.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"poseCascade.js","names":[],"sources":["../../src/canvas/poseCascade.ts"],"sourcesContent":["import { poseDescriptorForNode, translatePoseViaDescriptor, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport type { NodeId } from 'core/scene/types';\nimport type { PoseCascade } from '../animation/poseTarget';\n\n/** The part of a scene a container's cascade reads. */\ninterface CascadeScene<TPose> {\n  get(id: NodeId): { pose: TPose; kind?: 'mark' | 'group' } | undefined;\n  childrenOf(id: NodeId): readonly NodeId[];\n}\n\n/** The part of a scene a cascading `setPose` writes. */\ninterface CascadeTarget<TPose> extends CascadeScene<TPose> {\n  setPose(id: NodeId, pose: TPose): void;\n  batch<T>(label: string, fn: () => T): T;\n}\n\n/** Every node under `id`, each after its parent. */\nexport function descendantsOf(scene: Pick<CascadeScene<unknown>, 'childrenOf'>, id: NodeId): NodeId[] {\n  const out: NodeId[] = [];\n  const collect = (root: NodeId): void => {\n    for (const child of scene.childrenOf(root)) {\n      out.push(child);\n      collect(child);\n    }\n  };\n  collect(id);\n  return out;\n}\n\n/**\n * How container `id`'s pose target carries its descendants where each holds a pose of its own\n * in the same space: `write` commits a pose and moves them, and while the container shows\n * somewhere else each is shown moved by as much.\n */\nexport function containerCascade<TPose>(\n  scene: CascadeScene<TPose>,\n  id: NodeId,\n  d: PoseDescriptor<TPose>,\n  write: (pose: TPose) => void,\n): PoseCascade<TPose> {\n  return {\n    write,\n    *beside(pose) {\n      const node = scene.get(id);\n      if (!node) return;\n      const g = poseDescriptorForNode(d, node);\n      const from = g.getBounds(node.pose);\n      const to = g.getBounds(pose);\n      for (const child of descendantsOf(scene, id)) {\n        const n = scene.get(child);\n        if (!n) continue;\n        yield [child, translatePoseViaDescriptor(n.pose, to.x - from.x, to.y - from.y, poseDescriptorForNode(d, n))];\n      }\n    },\n  };\n}\n\n/**\n * `setPose` for a scene of absolute poses: posing a container moves every\n * descendant by as much, in one undo step.\n */\nexport function cascadingSetPose<TPose>(\n  scene: CascadeTarget<TPose>,\n  d: PoseDescriptor<TPose>,\n): (id: NodeId, pose: TPose) => void {\n  return (id, pose) => {\n    const node = scene.get(id);\n    if (!node || node.kind !== 'group') return scene.setPose(id, pose);\n    const g = poseDescriptorForNode(d, node);\n    const from = g.getBounds(node.pose);\n    const to = g.getBounds(pose);\n    const dx = to.x - from.x;\n    const dy = to.y - from.y;\n    if (dx === 0 && dy === 0) return scene.setPose(id, pose);\n    scene.batch('move container', () => {\n      scene.setPose(id, pose);\n      for (const child of descendantsOf(scene, id)) {\n        const n = scene.get(child);\n        if (!n) continue;\n        scene.setPose(child, translatePoseViaDescriptor(n.pose, dx, dy, poseDescriptorForNode(d, n)));\n      }\n    });\n  };\n}\n"],"mappings":";;;;AAiBA,SAAgB,cAAc,OAAkD,IAAsB;CACpG,MAAM,MAAgB,CAAC;CACvB,MAAM,WAAW,SAAuB;EACtC,KAAK,MAAM,SAAS,MAAM,WAAW,IAAI,GAAG;GAC1C,IAAI,KAAK,KAAK;GACd,QAAQ,KAAK;EACf;CACF;CACA,QAAQ,EAAE;CACV,OAAO;AACT;;;;;;AAOA,SAAgB,iBACd,OACA,IACA,GACA,OACoB;CACpB,OAAO;EACL;EACA,CAAC,OAAO,MAAM;GACZ,MAAM,OAAO,MAAM,IAAI,EAAE;GACzB,IAAI,CAAC,MAAM;GACX,MAAM,IAAI,sBAAsB,GAAG,IAAI;GACvC,MAAM,OAAO,EAAE,UAAU,KAAK,IAAI;GAClC,MAAM,KAAK,EAAE,UAAU,IAAI;GAC3B,KAAK,MAAM,SAAS,cAAc,OAAO,EAAE,GAAG;IAC5C,MAAM,IAAI,MAAM,IAAI,KAAK;IACzB,IAAI,CAAC,GAAG;IACR,MAAM,CAAC,OAAO,2BAA2B,EAAE,MAAM,GAAG,IAAI,KAAK,GAAG,GAAG,IAAI,KAAK,GAAG,sBAAsB,GAAG,CAAC,CAAC,CAAC;GAC7G;EACF;CACF;AACF;;;;;AAMA,SAAgB,iBACd,OACA,GACmC;CACnC,QAAQ,IAAI,SAAS;EACnB,MAAM,OAAO,MAAM,IAAI,EAAE;EACzB,IAAI,CAAC,QAAQ,KAAK,SAAS,SAAS,OAAO,MAAM,QAAQ,IAAI,IAAI;EACjE,MAAM,IAAI,sBAAsB,GAAG,IAAI;EACvC,MAAM,OAAO,EAAE,UAAU,KAAK,IAAI;EAClC,MAAM,KAAK,EAAE,UAAU,IAAI;EAC3B,MAAM,KAAK,GAAG,IAAI,KAAK;EACvB,MAAM,KAAK,GAAG,IAAI,KAAK;EACvB,IAAI,OAAO,KAAK,OAAO,GAAG,OAAO,MAAM,QAAQ,IAAI,IAAI;EACvD,MAAM,MAAM,wBAAwB;GAClC,MAAM,QAAQ,IAAI,IAAI;GACtB,KAAK,MAAM,SAAS,cAAc,OAAO,EAAE,GAAG;IAC5C,MAAM,IAAI,MAAM,IAAI,KAAK;IACzB,IAAI,CAAC,GAAG;IACR,MAAM,QAAQ,OAAO,2BAA2B,EAAE,MAAM,IAAI,IAAI,sBAAsB,GAAG,CAAC,CAAC,CAAC;GAC9F;EACF,CAAC;CACH;AACF"}

package/dist/features/chrome-caps/buildChromeCtx.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildChromeCtx.js","names":[],"sources":["../../../src/features/chrome-caps/buildChromeCtx.ts"],"sourcesContent":["/**\n * Pure assembler for {@link ChromeCtx}. Sources are passed as plain values\n * rather than the live objects they come from, which keeps `chrome-caps`\n * from depending on React or the dispatcher's concrete type.\n */\n\nimport type { NodeId } from '../../core/scene/types';\nimport type { ModifierState } from '../../interactions/gestures/types';\nimport type { View } from '../../core/viewport/view';\nimport type { ChromeCtx } from './types';\n\n/** The pieces of live canvas state a `ChromeCtx` is assembled from. */\nexport interface BuildChromeCtxArgs {\n  focused: boolean;\n  selection: readonly NodeId[];\n  multiActive: boolean;\n  modifiers: ModifierState;\n  action: { kind: string | null; id: string | null };\n  hover: NodeId | null;\n  view: View;\n}\n\n/** Gather the current canvas state into the context that chrome-visibility\n *  rules are evaluated against. Rebuilt per frame. */\nexport function buildChromeCtx(args: BuildChromeCtxArgs): ChromeCtx {\n  return {\n    focused: args.focused,\n    selection: args.selection,\n    multiActive: args.multiActive,\n    modifiers: args.modifiers,\n    action: args.action,\n    hover: args.hover,\n    view: args.view,\n  };\n}\n"],"mappings":";;;AAwBA,SAAgB,eAAe,MAAqC;CAClE,OAAO;EACL,SAAS,KAAK;EACd,WAAW,KAAK;EAChB,aAAa,KAAK;EAClB,WAAW,KAAK;EAChB,QAAQ,KAAK;EACb,OAAO,KAAK;EACZ,MAAM,KAAK;CACb;AACF"}

package/dist/features/chrome-caps/conditions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"conditions.js","names":[],"sources":["../../../src/features/chrome-caps/conditions.ts"],"sourcesContent":["import type { Condition } from './types';\nimport type { Rule } from '@weasel-js/routing';\nimport type { RuleCtx } from '@weasel-js/routing';\nimport { evaluate, ALWAYS, NEVER } from '@weasel-js/routing';\nimport type { ModifierState } from '../../interactions/gestures/types';\n\n/**\n * Promote a Rule tree to a fluent Condition.\n *\n * **Chain semantics: strict left-to-right.** No boolean precedence.\n * `focused.or(hovering).and(selectionIs(1))` evaluates\n * `((focused || hovering) && selectionIs(1))`. For grouped disjunction, use\n * the top-level `or` / `and` / `not` helpers or name intermediates.\n *\n * Combinators flatten same-kind nesting on construction so `a.and(b).and(c)`\n * produces `{ all: [a, b, c] }`.\n */\nexport function cond(rule: Rule): Condition {\n  const fn = (ctx: RuleCtx) => evaluate(rule, ctx);\n  const condition = fn as Condition;\n  (condition as { rule: Rule }).rule = rule;\n  condition.and    = (other) => cond(combineAll(rule, asRule(other)));\n  condition.or     = (other) => cond(combineAny(rule, asRule(other)));\n  condition.andNot = (other) => cond(combineAll(rule, { not: asRule(other) }));\n  condition.orNot  = (other) => cond(combineAny(rule, { not: asRule(other) }));\n  return condition;\n}\n\nfunction asRule(value: Condition | Rule): Rule {\n  return typeof value === 'function' ? (value as Condition).rule : value;\n}\n\nfunction combineAll(a: Rule, b: Rule): Rule {\n  const left = 'all' in a ? a.all : [a];\n  const right = 'all' in b ? b.all : [b];\n  return { all: [...left, ...right] };\n}\n\nfunction combineAny(a: Rule, b: Rule): Rule {\n  const left = 'any' in a ? a.any : [a];\n  const right = 'any' in b ? b.any : [b];\n  return { any: [...left, ...right] };\n}\n\n/** Inline-lambda escape hatch. Wraps the closure as a `when` rule node. */\nexport function when(fn: (ctx: RuleCtx) => boolean): Condition {\n  return cond({ when: fn });\n}\n\n// ─── Variadic helpers (for grouped expressions) ─────────────────────\n\n/** `(a && b && c && ...)` — useful when chain mixing makes left-to-right\n *  semantics ambiguous. */\nexport function and(...cs: (Condition | Rule)[]): Condition {\n  return cond({ all: cs.map(asRule) });\n}\n\n/** `(a || b || c || ...)` — preferred over `.or` chains when mixed with\n *  `.and` to make grouping explicit. */\nexport function or(...cs: (Condition | Rule)[]): Condition {\n  return cond({ any: cs.map(asRule) });\n}\n\n/** `!c` — top-level negation. Most rules use `.andNot()` / `.orNot()`\n *  instead; this is for the lead-with-negation case. */\nexport function not(c: Condition | Rule): Condition {\n  return cond({ not: asRule(c) });\n}\n\n// ─── Constant atoms ─────────────────────────────────────────────────\n\n/** Always true. The fallback for any chrome id without a registered rule. */\nexport const always: Condition = cond(ALWAYS);\n\n/** Always false. Useful for \"turn this chrome off entirely\":\n *  `chromeVisibility={{ 'snap.guides': never }}`. */\nexport const never: Condition = cond(NEVER);\n\n// ─── Focus / action atoms ───────────────────────────────────────────\n\n/** Canvas surface currently focused. */\nexport const focused: Condition = cond({ focused: true });\n\n/** Any action currently in flight (read: user is gesturing). */\nexport const gesturing: Condition = cond({ gesturing: true });\n\n/** A path is currently in anchor-edit mode. */\nexport const editingAnchors: Condition = cond({ editingAnchors: true });\n\n/** Current selection is resizable (every selected node passes the consumer's\n *  `selectTool.resize.resizable` predicate). Absent predicate → resizable. */\nexport const resizable: Condition = cond({ resizable: true });\n\n/** Active action's kind matches `kind` (e.g. `actionIs('move')`). */\nexport const actionIs = (kind: string): Condition => cond({ actionIs: kind });\n\n// ─── Selection atoms ────────────────────────────────────────────────\n\n/** Nothing selected. */\nexport const selectionEmpty: Condition = cond({ selection: { empty: true } });\n\n/** Exactly `n` items selected. */\nexport const selectionIs = (n: number): Condition => cond({ selection: { is: n } });\n\n/** At least `n` items selected. `selectionAtLeast(1)` is the common\n *  \"something is selected\" check. */\nexport const selectionAtLeast = (n: number): Condition => cond({ selection: { atLeast: n } });\n\n/** Multi-mode handle behavior active (single shared union-bounds\n *  handle vs per-item handles). */\nexport const multiActive: Condition = cond({ when: (c) => c.multiActive });\n\n// ─── Hover atoms ────────────────────────────────────────────────────\n\n/** Pointer is hovering some node. */\nexport const hovering: Condition = cond({ hovering: true });\n\n/** Pointer is hovering a node that is currently selected. */\nexport const hoveringSelected: Condition = cond({ hoveringSelected: true });\n\n// ─── Modifier atoms ─────────────────────────────────────────────────\n\n/** Named modifier key currently held. */\nexport const modifierHeld = (m: keyof ModifierState): Condition => cond({ modifierHeld: m });\n\n// ─── View atoms ─────────────────────────────────────────────────────\n\n/** View scale (uniform or geometric mean for non-uniform) is at least\n *  `z`. Useful for \"hide hairline chrome at low zoom\" rules. */\nexport const zoomAtLeast = (z: number): Condition => cond({ zoomAtLeast: z });\n\n// ─── Mode + capability atoms ───────────────────────────────────────\n\n/** Active mode equals `m`. */\nexport const modeIs = (m: string): Condition => cond({ mode: m });\n\n/** Active mode is one of `modes`. */\nexport const modeIn = (modes: readonly string[]): Condition => cond({ mode: { in: modes } });\n\n/** Active mode is NOT `m`. */\nexport const modeNot = (m: string): Condition => cond({ mode: { not: m } });\n\n/** Active mode's `allows` includes capability `cap`. */\nexport const capabilityIs = (cap: string): Condition => cond({ capability: cap });\n\n/** Active mode's `allows` includes ANY of `caps` (OR). */\nexport const capabilityIn = (caps: readonly string[]): Condition => cond({ capability: { in: caps } });\n\n/** Active mode's `allows` includes ALL of `caps` (AND). */\nexport const capabilityAll = (caps: readonly string[]): Condition => cond({ capability: [...caps] });\n\n/** Active mode's `allows` does NOT include capability `cap`. */\nexport const capabilityNot = (cap: string): Condition => cond({ capability: { not: cap } });\n\n// ─── Device atoms ───────────────────────────────────────────────────\n\n/** Primary pointer is imprecise (touch, most styluses). Absent device\n *  profile → false. */\nexport const coarsePointer: Condition = cond({ coarsePointer: true });\n\n/** Primary pointer can hover. Absent device profile → true. */\nexport const canHover: Condition = cond({ canHover: true });\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,KAAK,MAAuB;CAC1C,MAAM,MAAM,QAAiB,SAAS,MAAM,GAAG;CAC/C,MAAM,YAAY;CAClB,UAA8B,OAAO;CACrC,UAAU,OAAU,UAAU,KAAK,WAAW,MAAM,OAAO,KAAK,CAAC,CAAC;CAClE,UAAU,MAAU,UAAU,KAAK,WAAW,MAAM,OAAO,KAAK,CAAC,CAAC;CAClE,UAAU,UAAU,UAAU,KAAK,WAAW,MAAM,EAAE,KAAK,OAAO,KAAK,EAAE,CAAC,CAAC;CAC3E,UAAU,SAAU,UAAU,KAAK,WAAW,MAAM,EAAE,KAAK,OAAO,KAAK,EAAE,CAAC,CAAC;CAC3E,OAAO;AACT;AAEA,SAAS,OAAO,OAA+B;CAC7C,OAAO,OAAO,UAAU,aAAc,MAAoB,OAAO;AACnE;AAEA,SAAS,WAAW,GAAS,GAAe;CAC1C,MAAM,OAAO,SAAS,IAAI,EAAE,MAAM,CAAC,CAAC;CACpC,MAAM,QAAQ,SAAS,IAAI,EAAE,MAAM,CAAC,CAAC;CACrC,OAAO,EAAE,KAAK,CAAC,GAAG,MAAM,GAAG,KAAK,EAAE;AACpC;AAEA,SAAS,WAAW,GAAS,GAAe;CAC1C,MAAM,OAAO,SAAS,IAAI,EAAE,MAAM,CAAC,CAAC;CACpC,MAAM,QAAQ,SAAS,IAAI,EAAE,MAAM,CAAC,CAAC;CACrC,OAAO,EAAE,KAAK,CAAC,GAAG,MAAM,GAAG,KAAK,EAAE;AACpC;;AAGA,SAAgB,KAAK,IAA0C;CAC7D,OAAO,KAAK,EAAE,MAAM,GAAG,CAAC;AAC1B;;;AAMA,SAAgB,IAAI,GAAG,IAAqC;CAC1D,OAAO,KAAK,EAAE,KAAK,GAAG,IAAI,MAAM,EAAE,CAAC;AACrC;;;AAIA,SAAgB,GAAG,GAAG,IAAqC;CACzD,OAAO,KAAK,EAAE,KAAK,GAAG,IAAI,MAAM,EAAE,CAAC;AACrC;;;AAIA,SAAgB,IAAI,GAAgC;CAClD,OAAO,KAAK,EAAE,KAAK,OAAO,CAAC,EAAE,CAAC;AAChC;;AAKA,IAAa,SAAoB,KAAK,MAAM;;;AAI5C,IAAa,QAAmB,KAAK,KAAK;;AAK1C,IAAa,UAAqB,KAAK,EAAE,SAAS,KAAK,CAAC;;AAGxD,IAAa,YAAuB,KAAK,EAAE,WAAW,KAAK,CAAC;;AAG5D,IAAa,iBAA4B,KAAK,EAAE,gBAAgB,KAAK,CAAC;;;AAItE,IAAa,YAAuB,KAAK,EAAE,WAAW,KAAK,CAAC;;AAG5D,IAAa,YAAY,SAA4B,KAAK,EAAE,UAAU,KAAK,CAAC;;AAK5E,IAAa,iBAA4B,KAAK,EAAE,WAAW,EAAE,OAAO,KAAK,EAAE,CAAC;;AAG5E,IAAa,eAAe,MAAyB,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,EAAE,CAAC;;;AAIlF,IAAa,oBAAoB,MAAyB,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE,CAAC;;;AAI5F,IAAa,cAAyB,KAAK,EAAE,OAAO,MAAM,EAAE,YAAY,CAAC;;AAKzE,IAAa,WAAsB,KAAK,EAAE,UAAU,KAAK,CAAC;;AAG1D,IAAa,mBAA8B,KAAK,EAAE,kBAAkB,KAAK,CAAC;;AAK1E,IAAa,gBAAgB,MAAsC,KAAK,EAAE,cAAc,EAAE,CAAC;;;AAM3F,IAAa,eAAe,MAAyB,KAAK,EAAE,aAAa,EAAE,CAAC;;AAK5E,IAAa,UAAU,MAAyB,KAAK,EAAE,MAAM,EAAE,CAAC;;AAGhE,IAAa,UAAU,UAAwC,KAAK,EAAE,MAAM,EAAE,IAAI,MAAM,EAAE,CAAC;;AAG3F,IAAa,WAAW,MAAyB,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;;AAG1E,IAAa,gBAAgB,QAA2B,KAAK,EAAE,YAAY,IAAI,CAAC;;AAGhF,IAAa,gBAAgB,SAAuC,KAAK,EAAE,YAAY,EAAE,IAAI,KAAK,EAAE,CAAC;;AAGrG,IAAa,iBAAiB,SAAuC,KAAK,EAAE,YAAY,CAAC,GAAG,IAAI,EAAE,CAAC;;AAGnG,IAAa,iBAAiB,QAA2B,KAAK,EAAE,YAAY,EAAE,KAAK,IAAI,EAAE,CAAC;;;AAM1F,IAAa,gBAA2B,KAAK,EAAE,eAAe,KAAK,CAAC;;AAGpE,IAAa,WAAsB,KAAK,EAAE,UAAU,KAAK,CAAC"}

package/dist/features/chrome-caps/defaults.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaults.js","names":[],"sources":["../../../src/features/chrome-caps/defaults.ts"],"sourcesContent":["import type { VisibilityRules } from './types';\nimport type { Rule } from '@weasel-js/routing';\n\n/**\n * Kit-shipped defaults. Merged with the consumer's `chromeVisibility` map\n * at resolve time; consumer entries take precedence per id.\n *\n * Gating is written in terms of **capabilities, not mode ids**. A\n * capability rule keeps holding when a new mode is added that permits the\n * same thing; a mode rule has to be found and edited every time.\n */\nexport const defaultVisibilityRules: VisibilityRules = {\n  // Off whenever an anchor-editing overlay has taken over the visuals.\n  'selection.outline': {\n    all: [\n      { selection: { atLeast: 1 } },\n      { capability: { not: 'edits-anchors' } },\n    ],\n  } as Rule,\n\n  // Handles hide during an action so the moving / resizing object isn't\n  // visually crowded; they reappear on commit.\n  'selection.resize-handles': {\n    all: [\n      { selection: { atLeast: 1 } },\n      { not: { gesturing: true } },\n      { capability: 'transforms-selection' },\n      { resizable: true },\n    ],\n  } as Rule,\n\n  'selection.rotation-handle': {\n    all: [\n      { selection: { atLeast: 1 } },\n      { focused: true },\n      { not: { gesturing: true } },\n      { capability: 'transforms-selection' },\n    ],\n  } as Rule,\n\n  // Transient action chrome — only shown during the matching action.\n  'action.marquee':     { actionIs: 'marquee' } as Rule,\n  'action.lasso':       { actionIs: 'lasso' } as Rule,\n  'action.move-ghosts': { actionIs: 'move' } as Rule,\n\n  // Path-edit chrome — gated on there actually being an edited path, not on\n  // `{ mode: 'path-edit' }`: consumers with no mode registry report mode\n  // `'normal'`, and one defining its own anchor-editing mode uses another id.\n  // A state selector rather than a `capability:` one on purpose: the\n  // capability says the user *may* edit anchors, which is not the same as\n  // a path *being* edited.\n  'path-edit.anchors': { editingAnchors: true } as Rule,\n  'path-edit.overlay': { editingAnchors: true } as Rule,\n\n  // Snap system — guides during any action; targets consumer-driven for now.\n  'snap.guides': { gesturing: true } as Rule,\n  // 'snap.targets' — no default; consumer-driven for now.\n\n  // 'grid' / 'debug.*' — no default; visibility is driven by dedicated\n  // boolean props on <SceneCanvas>.\n};\n"],"mappings":";;;;;;;;;AAWA,IAAa,yBAA0C;CAErD,qBAAqB,EACnB,KAAK,CACH,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE,GAC5B,EAAE,YAAY,EAAE,KAAK,gBAAgB,EAAE,CACzC,EACF;CAIA,4BAA4B,EAC1B,KAAK;EACH,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE;EAC5B,EAAE,KAAK,EAAE,WAAW,KAAK,EAAE;EAC3B,EAAE,YAAY,uBAAuB;EACrC,EAAE,WAAW,KAAK;CACpB,EACF;CAEA,6BAA6B,EAC3B,KAAK;EACH,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE;EAC5B,EAAE,SAAS,KAAK;EAChB,EAAE,KAAK,EAAE,WAAW,KAAK,EAAE;EAC3B,EAAE,YAAY,uBAAuB;CACvC,EACF;CAGA,kBAAsB,EAAE,UAAU,UAAU;CAC5C,gBAAsB,EAAE,UAAU,QAAQ;CAC1C,sBAAsB,EAAE,UAAU,OAAO;CAQzC,qBAAqB,EAAE,gBAAgB,KAAK;CAC5C,qBAAqB,EAAE,gBAAgB,KAAK;CAG5C,eAAe,EAAE,WAAW,KAAK;AAKnC"}

package/dist/features/chrome-caps/resolve.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve.js","names":[],"sources":["../../../src/features/chrome-caps/resolve.ts"],"sourcesContent":["import type { ChromeCtx, ChromeId, VisibilityRules } from './types';\nimport type { RuleCtx } from '@weasel-js/routing';\nimport { DEFAULT_ALLOWED_CAPABILITIES } from '@weasel-js/routing';\nimport { evaluate } from '@weasel-js/routing';\nimport { defaultVisibilityRules } from './defaults';\nimport { viewZoom } from 'core/viewport/view';\n\n/**\n * Build the per-frame visibility check: consumer rules merged on top of\n * the kit defaults, evaluated against `ctx`.\n *\n * `ChromeCtx` is the legacy shape; surfaces still on it get `mode='normal'`\n * and `DEFAULT_ALLOWED_CAPABILITIES` filled in here, so a caller that never\n * opted into modality behaves exactly like one sitting in normal mode.\n */\nexport function resolveVisibility(\n  consumer: VisibilityRules | undefined,\n  ctx: ChromeCtx | RuleCtx,\n): (id: ChromeId) => boolean {\n  const merged: VisibilityRules = consumer\n    ? { ...defaultVisibilityRules, ...consumer }\n    : defaultVisibilityRules;\n  const ruleCtx: RuleCtx = 'mode' in ctx\n    ? ctx\n    : {\n      ...ctx,\n      zoom: viewZoom(ctx.view),\n      mode: 'normal',\n      allowedCapabilities: DEFAULT_ALLOWED_CAPABILITIES,\n    };\n  return (id) => {\n    const entry = merged[id];\n    if (entry === undefined) return true;\n    if (typeof entry === 'function') return entry(ruleCtx);\n    return evaluate(entry, ruleCtx);\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAeA,SAAgB,kBACd,UACA,KAC2B;CAC3B,MAAM,SAA0B,WAC5B;EAAE,GAAG;EAAwB,GAAG;CAAS,IACzC;CACJ,MAAM,UAAmB,UAAU,MAC/B,MACA;EACA,GAAG;EACH,MAAM,SAAS,IAAI,IAAI;EACvB,MAAM;EACN,qBAAqB;CACvB;CACF,QAAQ,OAAO;EACb,MAAM,QAAQ,OAAO;EACrB,IAAI,UAAU,QAAW,OAAO;EAChC,IAAI,OAAO,UAAU,YAAY,OAAO,MAAM,OAAO;EACrD,OAAO,SAAS,OAAO,OAAO;CAChC;AACF"}