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

package/dist/{depSchema-B1RS-IJx.d.ts → depSchema-C3BwxitB.d.ts}

@@ -6,20 +6,20 @@ import { IconRef } from '@weasel-js/icons';
 import { PaintDrawKind, DrawCommand, Effect, CompositeOp, BlendFactors } from '@weasel-js/renderer';
 import * as _weasel_js_routing_react from '@weasel-js/routing/react';
 import * as _weasel_js_geom from '@weasel-js/geom';
-import { FramedBox, View, Path, Affine, Rect, Scale2, PolygonPath, PathFillRule, AnchorSet, PointOrigin } from '@weasel-js/geom';
-import { I as InheritedPaint, S as Scene, R as RectPose } from './types-BEdRIhNc.js';
+import { FramedBox, View, Path, Affine, Rect, Scale2, PolygonPath, Point, PathFillRule, AnchorSet, PointOrigin } from '@weasel-js/geom';
+import { I as InheritedPaint, S as Scene, R as RectPose } from './types-DW14eu9B.js';
 import { Op, History } from '@weasel-js/history';
-import { NodeId, ModifierState, OverlayRole, ResizeAnchor, ActionDeps, OngoingHandle, OngoingOverlay, SelectionApi, IngestItem, Point2, DragSample, DebugSink, LongPressState } from '@weasel-js/routing';
+import { NodeId, ModifierState, OverlayRole, WorldPoint, ResizeAnchor, ActionDeps, OngoingHandle, OngoingOverlay, IngestItem, SelectionApi, Point2, DragSample, DebugSink, LongPressState } from '@weasel-js/routing';
 import { TextNodeSource, TextOutlinesError, TextStyle, StyledRun, TextVerticalAlign } from '@weasel-js/text';
 import { CursorSpec } from '@weasel-js/cursor';
 import { ClaimableGesture } from '@weasel-js/gestures';
 import { SnapTier, ProbeRole } from '@weasel-js/geom/nd';
-import { a as PlaneMap, L as LayoutStrategy, b as LayoutDropTargetMode, R as ReflowTransition } from './types-49uYJN3j.js';
+import { a as PlaneMap, L as LayoutStrategy, b as LayoutDropTargetMode, R as ReflowTransition } from './types-A_sNJYRd.js';
 import { O as OriginProjection } from './originProjection-gY0jb4Wb.js';
 import { EasingSpec, InterpolatorFactory, Target, Animator, TargetAxes } from '@weasel-js/animator';
-import { I as InsertAdapter, P as PasteOmission, R as RegionPickView } from './types-p2alu-R1.js';
-import { B as BoundsConstraint } from './clone-qb2e1F5p.js';
-import { P as PoseDescriptor } from './poseDescriptor-DN2yfnq_.js';
+import { I as InsertAdapter, P as PasteOmission, R as RegionPickView } from './types-VCtfchp-.js';
+import { B as BoundsConstraint } from './clone-Bz4iqGfE.js';
+import { P as PoseDescriptor } from './poseDescriptor-CvSxVhCd.js';
 
 /** Pixel dimensions of the canvas viewport. */
 interface ViewportDims {
@@ -64,11 +64,11 @@ declare function fitViewToBounds(bounds: FramedBox, viewportDims: ViewportDims,
  * `Paint`'s discriminant, open on the string the way `ChromeId` is: the
  * kinds the kit ships, plus whatever a consumer registers.
  */
-type PaintKind = 'solid' | 'linear-gradient' | 'radial-gradient' | 'conic-gradient' | TileKind | 'texture' | (string & {});
+type PaintKind = 'solid' | 'linear-gradient' | 'radial-gradient' | 'conic-gradient' | TileKind | 'image' | 'texture' | (string & {});
 /**
  * A set of kinds an editor offers as one choice. Kinds sharing a family show
  * as a single segment in a kind bar, named by the family, and the member is
- * picked inside that segment's body. The built-in tiles and `texture` are the
+ * picked inside that segment's body. The built-in tiles, `image` and `texture` are the
  * `patternFamily`.
  */
 interface PaintKindFamily {
@@ -149,7 +149,7 @@ declare function asPaint<T extends {
  * GL renderer and its serialize slot lives in `@weasel-js/svg`.
  */
 
-/** The family the built-in tiles and `texture` are offered under. A consumer's
+/** The family the built-in tiles, `image` and `texture` are offered under. A consumer's
  *  own pattern kind joins it by naming this as its `family`. */
 declare const patternFamily: PaintKindFamily;
 /** A tile paint seeded from a color. `units: 'bounds'` anchors the tile to the
@@ -519,6 +519,10 @@ interface Affordance {
     /** This affordance's interactive regions. Each lives in some target id's local frame (or
      *  the world frame when `targetId` is `null`). `[]` means no chrome for this state. */
     regions(state: ChromeState): readonly AffordanceRegion[];
+    /** The regions a press at world `(wx, wy)` can hit, in the order `regions` lists them: a hit
+     *  test reads these in place of `regions`, so one that leaves out a region the point is in
+     *  changes which region wins. For an affordance with many regions, narrowed by an index. */
+    regionsAt?(state: ChromeState, wx: number, wy: number, view: View): readonly AffordanceRegion[];
     /** Optional non-interactive decoration (e.g., a leader line from a bounds edge to a
      *  handle). Receives raw state + view because it may live outside any single target's
      *  local frame. */
@@ -778,9 +782,10 @@ interface LayerGroup {
  * When `drawLayers` asks the renderer to keep a layer's pixels between frames
  * (`GroupDrawCommand.retain`) rather than submit its commands again.
  *
- * A layer is retained once its `deps` have held for a frame, the view has held
- * since the frame before (for a world-space layer, whose pixels move with
- * it), and it holds at least `minCommands` drawing commands. A layer changing
+ * A layer is retained once its `deps` have held for a frame, the view's zoom
+ * has held since the frame before (for a world-space layer, whose pixels move
+ * with it; the renderer moves a kept surface with a pan where it can), and it
+ * holds at least `minCommands` drawing commands. A layer changing
  * every frame is never retained: drawing it into its surface and compositing
  * that costs more than drawing it.
  */
@@ -805,11 +810,17 @@ declare function subscribeToSources(sources: readonly {
     subscribe?: RedrawSource['subscribe'];
 }[])): RedrawSource['subscribe'];
 
-/** Canvas size in CSS pixels, so layers don't have to know about DPR. */
+/** Canvas size in CSS pixels. */
 interface Dims {
     width: number;
     height: number;
 }
+/** What a layer draws into: its size, and the device pixels to the CSS pixel
+ *  the frame is painted at, which is what an effect's reach is measured in. */
+interface LayerDims extends Dims {
+    dpr: number;
+}
+
 /**
  * What a layer's `draw` threw, and which layer threw it. A throw that escaped
  * the frame loop would take the whole frame with it, every other layer
@@ -846,7 +857,7 @@ interface RenderLayer<TData> {
      * Emit a DrawCommand tree, in the coordinates `space` names. A world-space
      * layer must NOT apply the view transform itself.
      */
-    draw: (data: TData, view: View, dims: Dims) => DrawCommand[];
+    draw: (data: TData, view: View, dims: LayerDims) => DrawCommand[];
     /**
      * Optional cache key. When present and a `LayerCommandCache` is supplied to
      * `drawLayers`, the layer's previous `DrawCommand[]` is reused as long as
@@ -861,7 +872,7 @@ interface RenderLayer<TData> {
      * the way world-space layers are** (see `space` below) — include them in
      * `deps` if `draw` reads them.
      */
-    deps?: (data: TData, view: View, dims: Dims) => readonly unknown[];
+    deps?: (data: TData, view: View, dims: LayerDims) => readonly unknown[];
     /** Whether the layer is shown when no explicit visibility entry exists.
      *  Defaults to `true` when absent. */
     defaultVisible?: boolean;
@@ -948,7 +959,7 @@ interface LayerDrawSpan {
  * layer drawn. `retain` decides which unchanged layers the renderer keeps
  * as pixels between frames; `false` keeps none.
  */
-declare function drawLayers<TData>(layers: RenderLayer<TData>[], data: TData, visibility: Record<string, boolean>, order: string[] | undefined, view: View | undefined, dims: Dims, cache?: LayerCommandCache, onLayerError?: (failure: LayerDrawFailure) => void, groups?: readonly LayerGroup[], spans?: LayerDrawSpan[], retain?: LayerRetainPolicy | false): DrawCommand[];
+declare function drawLayers<TData>(layers: RenderLayer<TData>[], data: TData, visibility: Record<string, boolean>, order: string[] | undefined, view: View | undefined, dims: LayerDims, cache?: LayerCommandCache, onLayerError?: (failure: LayerDrawFailure) => void, groups?: readonly LayerGroup[], spans?: LayerDrawSpan[], retain?: LayerRetainPolicy | false): DrawCommand[];
 /**
  * Resolve one layer's visibility: `alwaysOn` wins, then an explicit entry in
  * `visibility`, then `defaultVisible`, defaulting to shown.
@@ -980,7 +991,7 @@ declare function paintedLayers<TData>(layers: readonly RenderLayer<TData>[], vis
  * layer it was. The layer's cache entry goes with it, so the next frame is a
  * real re-attempt.
  */
-declare function drawOneLayer<TData>(layer: RenderLayer<TData>, data: TData, view: View, dims: Dims, cache?: LayerCommandCache, onLayerError?: (failure: LayerDrawFailure) => void): DrawCommand[];
+declare function drawOneLayer<TData>(layer: RenderLayer<TData>, data: TData, view: View, dims: LayerDims, cache?: LayerCommandCache, onLayerError?: (failure: LayerDrawFailure) => void): DrawCommand[];
 /** Whether `b` matches `a` entry for entry under `Object.is` — how
  *  `RenderLayer.deps` is compared, and any cache keyed the same way. */
 declare function depsUnchanged(a: readonly unknown[], b: readonly unknown[]): boolean;
@@ -1107,16 +1118,12 @@ interface PreviewPathsDep {
 
 /** The `snap` dep: what a drawn or dragged point locks to. */
 
-type Point$4 = {
-    x: number;
-    y: number;
-};
 /** Geometry a gesture brings to snap to that is in no scene node: what stays
  *  put of a path whose anchors it is dragging. World coords. */
 interface SnapGeometry {
     paths?: readonly Path[];
     /** Points to snap to as anchors. */
-    anchors?: readonly Point$4[];
+    anchors?: readonly WorldPoint[];
 }
 /** What builds a gesture's input subspace while `snap.constrain` is held:
  *  an angle step in radians about `origin` (a rotate's every multiple of
@@ -1129,13 +1136,13 @@ type SnapConstrain = {
 interface SnapResizeBox {
     bounds: FramedBox;
     /** Its frame into ctx coordinates, an affine map. Default: the identity. */
-    toWorld?: (p: Point$4) => Point$4;
+    toWorld?: (p: WorldPoint) => WorldPoint;
 }
 /** What a gesture tells the snap dep when it starts. Points are ctx
  *  coordinates: world in 2D. */
 interface SnapBegin {
     gesture: SnapGesture;
-    press: Point$4;
+    press: WorldPoint;
     /** The subject, whose geometry offers no targets. */
     ids?: readonly string[];
     /** The container a subject not yet in the scene lands in: an insert's
@@ -1147,7 +1154,7 @@ interface SnapBegin {
      *  axis-aligned. */
     box?: SnapResizeBox;
     /** Rotate, handle: the point the angle turns about. Default `press`. */
-    pivot?: Point$4;
+    pivot?: WorldPoint;
     /** Rotate: the subject's angle at press, radians. Default 0. */
     theta0?: number;
     /** Angle gestures: the reach as an angle, radians, in place of screen px
@@ -1158,7 +1165,7 @@ interface SnapBegin {
      *  start, the previous anchor, the anchor a handle pulls from. Tangent and
      *  perpendicular targets are measured from it, a `constrain` step turns
      *  about it, and no point target on it is offered. */
-    origin?: Point$4;
+    origin?: WorldPoint;
     also?: SnapGeometry;
     constrain?: SnapConstrain;
     /** How the camera's world maps into the parallax plane the gesture's points
@@ -1183,7 +1190,7 @@ interface SnapMods {
 }
 /** Where a session put one frame's point, and the marks to draw for it. */
 interface SnapOutcome {
-    point: Point$4;
+    point: WorldPoint;
     /** Whether some target holds the point. */
     held: boolean;
     marks: readonly SnapMark[];
@@ -1191,7 +1198,7 @@ interface SnapOutcome {
 /** One gesture's snapping, from press to release. */
 interface SnapSession {
     /** Where `p` lands. */
-    at(p: Point$4, mods: SnapMods): SnapOutcome;
+    at(p: WorldPoint, mods: SnapMods): SnapOutcome;
     /** Where the angle `theta` (radians, about `pivot`) lands. */
     angle(theta: number, mods: SnapMods): {
         theta: number;
@@ -1213,20 +1220,23 @@ interface SnapDep {
 /** The snap source contract: what a target set offers a snap session, and
  *  the marks a session draws for what it met. */
 
-type Point$3 = {
-    x: number;
-    y: number;
-};
 /** The positions a target allows: `at` plus any combination of `dirs`. No
  *  dirs is a point, one a line, two a plane. */
-interface Locus<P = Point$3> {
+interface Locus<P = Point> {
     at: P;
     dirs: readonly P[];
     /** One interval per dir, in multiples of it: a segment or a bounded face. */
     span?: readonly (readonly [number, number])[];
 }
+/** An affine map between a frame and world, in a host's point type. */
+interface SnapFrame<P = Point> {
+    /** A point given in the frame, in world. */
+    toWorld(p: P): P;
+    /** A world point in the frame; null where nothing maps back. */
+    toLocal(p: P): P | null;
+}
 /** One locus a source offers one probe. */
-interface SourceCandidate<P = Point$3> {
+interface SourceCandidate<P = Point> {
     /** The id of a probe the source was offered. */
     probe: string;
     locus: Locus<P>;
@@ -1247,13 +1257,13 @@ interface SnapEdges {
     y: SnapEdge;
 }
 /** A point on the subject that should land on a locus. */
-interface SnapProbeAt<P = Point$3> {
+interface SnapProbeAt<P = Point> {
     id: string;
     at: P;
     role: ProbeRole;
 }
 /** What a session asks a source for, once per frame. */
-interface SnapCollect<P = Point$3> {
+interface SnapCollect<P = Point> {
     gesture: SnapGesture;
     /** The probes this source matches, where the unsnapped gesture puts them. */
     probes: readonly SnapProbeAt<P>[];
@@ -1291,6 +1301,11 @@ interface SnapCollect<P = Point$3> {
     reachPx: number;
     /** Absent in a host with no 2D scene. */
     scene?: Scene<unknown, string, unknown>;
+    /** `id`'s own frame: the coordinates its box is laid out in, from its
+     *  corner along its own axes, turned and transformed as it is drawn. A
+     *  container whose pose is a frame stores its children's poses in it.
+     *  Undefined for a node with no box; absent in a host that has none. */
+    frameOf?(id: string): SnapFrame<P> | undefined;
     /** How the camera's world maps into the parallax plane the probes are in.
      *  Absent in the camera's own world. A target the camera draws, a grid or
      *  a ruler guide, is carried through it. */
@@ -1299,10 +1314,10 @@ interface SnapCollect<P = Point$3> {
 /** What a rotate or handle drag asks a source for, once per frame. Angles
  *  are radians about `pivot`, in the frame `rotationOf` reads. */
 interface AngleCollect {
-    pivot: Point$3;
+    pivot: WorldPoint;
     /** Where the gesture was pressed: its distance from `pivot` is the radius
      *  the default marks are drawn at. */
-    press: Point$3;
+    press: WorldPoint;
     /** The angle at press. */
     theta0: number;
     /** The unsnapped angle now. */
@@ -1330,7 +1345,7 @@ interface AngleCandidate {
     mark?: SnapMarks;
 }
 /** A set of snap targets. */
-interface SnapSource<P = Point$3> {
+interface SnapSource<P = Point> {
     id: string;
     /** Default `'target'`. A fallback never displaces a target in reach. */
     tier?: SnapTier;
@@ -1345,9 +1360,9 @@ interface SnapSource<P = Point$3> {
     angles?(q: AngleCollect): Iterable<AngleCandidate>;
 }
 /** One mark, or several, for one candidate. */
-type SnapMarks<P = Point$3> = SnapMark<P> | readonly SnapMark<P>[];
+type SnapMarks<P = Point> = SnapMark<P> | readonly SnapMark<P>[];
 /** What a session draws for a candidate the result meets. World coords. */
-type SnapMark<P = Point$3> = {
+type SnapMark<P = Point> = {
     kind: 'point';
     at: P;
     glyph: string;
@@ -1408,18 +1423,14 @@ interface SnapReadoutStyle {
     lineWidth?: number;
 }
 
-type Point$2 = {
-    x: number;
-    y: number;
-};
 /** The marks of the snap in flight, for the readout to draw. */
-interface SnapOutcomeStore<P = Point$2> {
+interface SnapOutcomeStore<P = Point> {
     get(): readonly SnapMark<P>[];
     set(marks: readonly SnapMark<P>[]): void;
     subscribe(listener: () => void): () => void;
 }
 /** An empty outcome store, which notifies only when the marks change. */
-declare function createSnapOutcomeStore<P = Point$2>(): SnapOutcomeStore<P>;
+declare function createSnapOutcomeStore<P = Point>(): SnapOutcomeStore<P>;
 
 /** The `snapReadout` dep: where marks go to be drawn. */
 interface SnapReadoutDep {
@@ -1672,16 +1683,31 @@ interface GestureLifecycleOptions {
     onGestureEnd?(committed: boolean): void;
 }
 
-/** Optional consumer seam: given a node and the affine `m` that a pose-transform
+/** The pose a node is stored with before one pose-transform action, and the
+ *  pose the action moved it to. A resize whose data took a mirror commits that
+ *  pose with its box normalized. */
+interface PoseChange<TPose = unknown> {
+    readonly from: TPose;
+    readonly to: TPose;
+}
+/** Optional consumer seam: given a node and the transform that a pose-transform
  *  action applied to the node's POSE, return updated `data` with the node's
- *  data-held geometry transformed by `m`, or `null` if this node has no
- *  data-held geometry (the kit leaves `data` alone). */
-interface GeometryProjection {
+ *  data-held geometry transformed the same way, or `null` if this node has no
+ *  data-held geometry (the kit leaves `data` alone).
+ *
+ *  `m` is that transform as a plane affine, in the node's stored frame and the
+ *  coordinates gesture points arrive in: world on a 2D canvas, screen under the
+ *  identity `clientToWorld` a camera-bearing host passes. A host whose poses
+ *  are not planar reads the transform from `change` instead, which carries the
+ *  stored pose before and after in the pose's own terms. For a flip of a pose
+ *  that is only a box, `change` holds the same box twice and only `m` says
+ *  which way the content mirrored. */
+interface GeometryProjection<TPose = unknown> {
     transform(node: {
         id?: string;
         data: unknown;
-        pose: unknown;
-    }, m: Affine): unknown | null;
+        pose: TPose;
+    }, m: Affine, change: PoseChange<TPose>): unknown | null;
 }
 
 /** What a handle drag holds fixed: its direction from the anchor, or its length. */
@@ -1720,14 +1746,10 @@ interface PathForm {
     readonly kind: string;
     readonly [field: string]: unknown;
 }
-type Point$1 = {
-    x: number;
-    y: number;
-};
 /** The outline of an anchor's marker, in screen space: `size` px across at
  *  `at`, with the anchor's neighbors along its subpath, null past an open
  *  end. */
-type AnchorMarkerShape = (at: Point$1, size: number, prev: Point$1 | null, next: Point$1 | null) => PolygonPath;
+type AnchorMarkerShape = (at: Point, size: number, prev: Point | null, next: Point | null) => PolygonPath;
 /** How path edit reads and writes one kind of {@link PathForm}. */
 interface PathRepresentation {
     /** The `kind` of the forms it reads. */
@@ -1756,7 +1778,7 @@ interface PathRepresentation {
      * representation that has this takes every segment press, in place of
      * Bend segment.
      */
-    segmentPress?(deps: ActionDeps, at: Point$1): (() => OngoingHandle) | null;
+    segmentPress?(deps: ActionDeps, at: WorldPoint): (() => OngoingHandle) | null;
 }
 
 /**
@@ -1826,10 +1848,6 @@ interface PathEditPart {
         };
     };
 }
-type Point = {
-    x: number;
-    y: number;
-};
 /** An anchor or handle drag on the open path, as it starts. */
 interface PathEditDragStart extends Omit<PathEditTarget, 'node'> {
     /** The node's committed pose and data; null when it cannot be read. */
@@ -1867,7 +1885,7 @@ interface PathEditDrag {
     /** For a handle drag, where the handle goes, given `to`: where the pointer
      *  and the locks in force put it. Extensions answer in turn, each from the
      *  last one's answer. */
-    handle?(to: Point, move: PathEditHandleMove): Point;
+    handle?(to: WorldPoint, move: PathEditHandleMove): WorldPoint;
     /** A wheel turned while the drag is in flight. Return true to claim it;
      *  the drag then redoes its last move. */
     wheel?(wheel: {
@@ -2138,6 +2156,10 @@ interface IngestCtx {
         x: number;
         y: number;
     } | null;
+    /** Every item the arrival carried, the ones other handlers took included:
+     *  a handler can tell that the string it was given rides beside a file.
+     *  Absent reads as the items the handler was handed. */
+    items?: readonly IngestItem[];
     /** Visible canvas area in world coordinates. */
     viewportWorldRect(): {
         x: number;
@@ -2201,7 +2223,8 @@ interface ContentHandlerEntry {
     priority?: number;
     handle(items: IngestItem[], ctx: IngestCtx): void | Promise<void>;
 }
-/** Register a content handler. Returns a disposer that removes it. */
+/** Register a content handler for every canvas on the page. Returns a disposer that removes
+ *  it. A handler for one canvas goes in that canvas's `ingestion.handlers` instead. */
 declare function registerContentHandler(entry: ContentHandlerEntry): () => void;
 
 /**
@@ -2270,6 +2293,11 @@ interface IngestionDep {
     /** Clipboard-paste seam for the kit weasel-JSON handler.
      *  Live accessor, same caveat as `resolveSrc`. */
     clipboard?: ClipboardIngestCtx;
+    /** The canvas's own content handlers and the kit's it keeps (SceneCanvas's
+     *  `ingestion.handlers` and `ingestion.kitHandlers`). An arrival routes
+     *  through these and the page-wide registry's. Absent reads as none.
+     *  Live accessor, same caveat as `resolveSrc`. */
+    handlers?: readonly ContentHandlerEntry[];
 }
 
 /** The gesture an insert's bounds came from, in the same coordinates: `bounds`
@@ -2348,6 +2376,20 @@ interface InsertLive {
     gesture: unknown;
 }
 
+/** A no with a reason: words for the user, shown beside the pointer while a drag is over what refuses it. */
+interface DropRefusal {
+    refuse: string;
+}
+/**
+ * The answer to "may this land here?": `true` lands, `false` is a silent no,
+ * and a {@link DropRefusal} is a no the user is told about. A drag over a
+ * refusal draws its target refused and the reason beside the pointer, and a
+ * release there lands nothing.
+ */
+type DropVerdict = boolean | DropRefusal;
+/** The reason `verdict` gives, or `null` when it lands or says no silently. */
+declare function refusalOf(verdict: DropVerdict | undefined): string | null;
+
 /**
  * Layout-strategy lookup by container id, consumed by `moveAction` to run
  * the drag-time reflow pass. Sourced by `<SceneCanvas>` from the layout each
@@ -2364,19 +2406,23 @@ interface LayoutDep {
 }
 /**
  * Whether the nodes `ids` may be dropped into the container `parent`. A move
- * consults it before reparenting anything: reparent-on-drop passes over a
- * refused container to the nearest one around it that admits them, and the
- * layout drop treats a refused layout container as if it were not there.
- * Absent, every container takes any drop.
+ * consults it before reparenting anything. Where it answers `false`,
+ * reparent-on-drop passes over the container to the nearest one around it
+ * that admits them, and the layout drop treats a layout container as if it
+ * were not there. Where it answers a `DropRefusal`, a drag over the container
+ * draws it refused with the reason beside the pointer, and a release there
+ * moves nothing. Absent, every container takes any drop.
  */
-type CanDropIntoDep = (parent: string, ids: readonly string[]) => boolean;
+type CanDropIntoDep = (parent: string, ids: readonly string[]) => DropVerdict;
 
 /**
  * The deps behind text editing, the clipboard, and Slice.
  */
 
 /**
- * Dep for `enterTextEditAction`.
+ * Dep for `enterTextEditAction`. `<SceneCanvas>` answers it with its own
+ * editor (its `textEditor` prop); a host with an editor of its own, one
+ * driving character controls, publishes it instead.
  *
  * Wrap the return value of `useTextEdit` / `useSceneTextEdit` to source this
  * dep. The `isTextNode` predicate is optional — when absent the action fires
@@ -2413,10 +2459,7 @@ interface TextEditDep {
  */
 interface ClipboardDep {
     copy(): void;
-    paste(at?: {
-        worldX: number;
-        worldY: number;
-    }): void;
+    paste(at?: WorldPoint): void;
     isEmpty(): boolean;
 }
 /**
@@ -2483,10 +2526,7 @@ type HitTestView = RegionPickView;
  * `exclude`. Pass moving-node roots + their descendants when the caller
  * wants to ignore the nodes it's manipulating.
  */
-type NodeAtPointDep = (point: {
-    x: number;
-    y: number;
-}, exclude?: Iterable<NodeId>) => NodeId | null;
+type NodeAtPointDep = (point: WorldPoint, exclude?: Iterable<NodeId>) => NodeId | null;
 /** What an area-selecting action needs: a way to ask what a region covers,
  *  and a way to read and replace the selection. */
 interface AreaSelectDep {
@@ -2514,10 +2554,7 @@ interface LassoSelectDep {
      * Optional — when absent, `lassoSelectAction` falls back to AABB via
      * `hitTestArea`.
      */
-    hitTestLasso?(polygon: ReadonlyArray<{
-        x: number;
-        y: number;
-    }>, mode: 'centers' | 'intersect' | 'enclosed', view?: HitTestView): string[];
+    hitTestLasso?(polygon: ReadonlyArray<WorldPoint>, mode: 'centers' | 'intersect' | 'enclosed', view?: HitTestView): string[];
     /** Return ids of nodes whose AABB overlaps the given rect (fallback). */
     hitTestArea(bounds: {
         x: number;
@@ -2550,32 +2587,20 @@ type InsertExtras = {
     kind: 'ellipse';
 } | {
     kind: 'line';
-    a: {
-        x: number;
-        y: number;
-    };
-    b: {
-        x: number;
-        y: number;
-    };
+    a: WorldPoint;
+    b: WorldPoint;
 } | {
     kind: 'polygon';
     sides: number;
     rotation: number;
-    center?: {
-        x: number;
-        y: number;
-    };
+    center?: WorldPoint;
     radius?: number;
 } | {
     kind: 'star';
     points: number;
     innerRadiusRatio: number;
     rotation: number;
-    center?: {
-        x: number;
-        y: number;
-    };
+    center?: WorldPoint;
     outerRadius?: number;
 } | {
     kind: 'pencil';
@@ -2792,9 +2817,10 @@ declare module '@weasel-js/routing' {
         /**
          * Optional consumer seam for the eager-sync layer: lets pose-transform
          * actions (resize/move/nudge/flip — NOT rotate) ALSO rewrite a node's
-         * data-held geometry. Given a node and the affine `m` applied to its pose,
-         * `transform(node, m)` returns updated `data` (geometry mapped by `m`) or
-         * `null` for nodes with no data-held geometry.
+         * data-held geometry. Given a node, the affine `m` applied to its pose,
+         * and the pose change itself, `transform(node, m, change)` returns updated
+         * `data` (geometry mapped the same way) or `null` for nodes with no
+         * data-held geometry. A host whose poses are not planar reads `change`.
          *
          * Strictly opt-in: when absent (or when `transform` returns null), the kit
          * emits only the pose op and leaves `data` untouched. Rotate intentionally
@@ -2821,4 +2847,4 @@ declare module '@weasel-js/routing' {
     }
 }
 
-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 InertiaConfig 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, registerContentHandler as bA, registerPaintKind as bB, registerPaintKindLoader as bC, seedTile as bD, stickyData as bE, stickyNodeFactory as bF, subscribeToSources as bG, switchGradientKind as bH, textBoxOf as bI, useDecayLoop as bJ, useEnteredGroup as bK, useViewAnimation as bL, useViewAnimationOn as bM, viewAxes as bN, withoutGeometryBoundData as bO, type ViewApi as ba, type ViewChannel as bb, applyBooleanOp as bc, applyCreateOutlines as bd, asPaint as be, createEnteredGroup as bf, createPathOverlay as bg, createSnapOutcomeStore as bh, depsUnchanged as bi, drawLayers as bj, drawOneLayer as bk, fitViewToBounds as bl, getPaintKind as bm, isLayerPainted as bn, isLayerVisible as bo, listGradientKinds as bp, listPaintKinds as bq, minSizeOf as br, paintKindOf as bs, paintKindRegistry as bt, paintedLayers as bu, paintsLayer as bv, paletteInsertPaint as bw, pathPaintOf as bx, patternFamily as by, previewBooleanOp 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 EnteredGroupApi 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 };
+export { type SourceCandidate as $, type AnchorMarkerShape as A, type CreateOutlinesAdapter 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 PaintKindEntry as J, type PathEditTarget as K, type LayerHit as L, type FinishedEditFrame as M, type PathSymmetryDep as N, type BooleanOpOptions as O, type PathEditMark as P, type BooleansAdapter as Q, type RenderLayer as R, type SnapSource as S, type TextOverflow as T, type BooleanOp as U, type ViewAnimationOptions as V, type PathPaint as W, type BooleanOpResult as X, type BooleanStrokes as Y, type SnapMods as Z, _resetPaintKindsForTests as _, type PathEditExtension as a, type PreviewPathsDep as a$, type SnapProbeAt as a0, type SnapCollect as a1, type SnapMark as a2, type SnapDep as a3, type SnapOutcome as a4, type SnapReadoutStyle as a5, type AngleCandidate as a6, type AngleCollect as a7, type AnimateToBoundsOptions as a8, type AreaSelectDep as a9, type LayerRetainPolicy as aA, type LayoutDep as aB, type Locus as aC, type MinSize as aD, type NodeAtPointDep as aE, type OutlinePathSpec as aF, PATH_OVERLAY_ROLES as aG, type PaintKind as aH, type PaintKindEditorProps as aI, type PaintKindFamily as aJ, type PaintKindLoader as aK, type PanBounds as aL, type PathEditDrag as aM, type PathEditDragStart as aN, type PathEditFinishCtx as aO, type PathEditHandleMove as aP, type PathEditMarksCtx as aQ, type PathEditOther as aR, type PathEditPart as aS, type PathEditStore as aT, type PathForm as aU, type PathOverlay as aV, type PathOverlayOptions as aW, type PathOverlayStyle as aX, type PathRepresentation as aY, type PathTransformFinishCtx as aZ, type PoseChange as a_, type BooleanOpPreview as aa, type BooleanPreviewPiece as ab, type CanDropIntoDep as ac, type ClipboardDep as ad, type ClipboardIngestCtx as ae, type CreateOutlinesResult as af, type CustomPaintContext as ag, DEFAULT_LAYER_RETAIN as ah, type DecayLoopConfig as ai, type DropRefusal as aj, type DropVerdict as ak, type FinishedPathEdit as al, GEOMETRY_BOUND_DATA as am, type HandleLock as an, type HitTestView as ao, type IngestCtx as ap, type IngestionDep as aq, type InsertDep as ar, type InsertEnds as as, type InsertExtras as at, type InsertIntoDep as au, type InsertLive as av, type LassoSelectDep as aw, type LayerCommandCache as ax, type LayerDrawFailure as ay, type LayerDrawSpan as az, type SnapGesture as b, type ResizePolicy as b0, STICKY_DEFAULTS as b1, type SnapBegin as b2, type SnapEdge as b3, type SnapEdges as b4, type SnapFrame as b5, type SnapMarks as b6, type SnapReadoutDep as b7, type SvgUnpacker as b8, type TextEditDep as b9, paintsLayer as bA, paletteInsertPaint as bB, pathPaintOf as bC, patternFamily as bD, previewBooleanOp as bE, refusalOf as bF, registerContentHandler as bG, registerPaintKind as bH, registerPaintKindLoader as bI, seedTile as bJ, stickyData as bK, stickyNodeFactory as bL, subscribeToSources as bM, switchGradientKind as bN, textBoxOf as bO, useDecayLoop as bP, useEnteredGroup as bQ, useViewAnimation as bR, useViewAnimationOn as bS, viewAxes as bT, withoutGeometryBoundData as bU, type TextNodeData as ba, type TransformPreviewNode as bb, type TransientPath as bc, VIEW_ANIMATION_KEY as bd, type ViewAnimationApi as be, type ViewApi as bf, type ViewChannel as bg, applyBooleanOp as bh, applyCreateOutlines as bi, asPaint as bj, createEnteredGroup as bk, createPathOverlay as bl, createSnapOutcomeStore as bm, depsUnchanged as bn, drawLayers as bo, drawOneLayer as bp, fitViewToBounds as bq, getPaintKind as br, isLayerPainted as bs, isLayerVisible as bt, listGradientKinds as bu, listPaintKinds as bv, minSizeOf as bw, paintKindOf as bx, paintKindRegistry as by, paintedLayers as bz, type SnapConstrain as c, type SnapResizeBox as d, type SnapGeometry as e, type SnapOutcomeStore as f, type SnapSession as g, type LayerDims as h, type ViewportDims as i, type RedrawSource as j, type EditAnchorsParams as k, type SliceDep as l, type StickyStyle as m, type EnteredGroupApi as n, type ChromeState as o, type LayerGroup as p, type TransformFollower as q, type GeometryProjection as r, type InsertNodeFactory as s, type InsertPaint as t, type SvgIngestOptions as u, type SceneCanvasSnap as v, type Affordance as w, type AffordanceRegion as x, type AffordanceBinding as y, type CommonAffordanceScratch as z };

package/dist/devtools-protocol.d.ts

@@ -1,8 +1,8 @@
 import { e as DebugFeature, a as DebugConfig } from './types-BN9hbdMI.js';
 import { DispatchTrace, TraceRing } from '@weasel-js/routing';
-import { S as Scene } from './types-BEdRIhNc.js';
+import { S as Scene } from './types-DW14eu9B.js';
 import '@weasel-js/history';
-import './types-49uYJN3j.js';
+import './types-A_sNJYRd.js';
 import '@weasel-js/geom';
 import '@weasel-js/quantity';
 import '@weasel-js/paint';

package/dist/devtools.d.ts

@@ -1,9 +1,9 @@
 export { DEVTOOLS_ENVELOPE, DEVTOOLS_PROTOCOL, DevtoolsActionEntry, DevtoolsArea, DevtoolsBinding, DevtoolsDepEntry, DevtoolsEnvelope, DevtoolsHistoryOp, DevtoolsHistoryRecord, DevtoolsHistorySlice, DevtoolsNodeDetail, DevtoolsNodeSummary, DevtoolsOverlays, DevtoolsRegistry, DevtoolsRequest, DevtoolsResult, DevtoolsRoot, DevtoolsRootInfo, DevtoolsRootSource, DevtoolsRootState, DevtoolsSchedule, DevtoolsToolEntry, DevtoolsTraceSlice, DevtoolsTransport, PageMessage, PageTransport, PanelMessage, PanelTransport, SerializeLimits, SerializedValue, WeaselDevtoolsHook, createDevtoolsHook, createDevtoolsRoot, createInPageTransports, createWindowPageTransport, createWindowPanelTransport, installDevtoolsHook, isDevtoolsEnvelope, serialize } from './devtools-protocol.js';
 import './types-BN9hbdMI.js';
 import '@weasel-js/routing';
-import './types-BEdRIhNc.js';
+import './types-DW14eu9B.js';
 import '@weasel-js/history';
-import './types-49uYJN3j.js';
+import './types-A_sNJYRd.js';
 import '@weasel-js/geom';
 import '@weasel-js/quantity';
 import '@weasel-js/paint';

package/dist/{features → domains}/chrome-caps/buildChromeCtx.js

@@ -1,4 +1,4 @@
-//#region src/features/chrome-caps/buildChromeCtx.ts
+//#region src/domains/chrome-caps/buildChromeCtx.ts
 /** Gather the current canvas state into the context that chrome-visibility
 *  rules are evaluated against. Rebuilt per frame. */
 function buildChromeCtx(args) {

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildChromeCtx.js","names":[],"sources":["../../../src/domains/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 → domains}/chrome-caps/conditions.js

@@ -1,6 +1,6 @@
 import { ALWAYS, NEVER, evaluate } from "@weasel-js/routing";
 
-//#region src/features/chrome-caps/conditions.ts
+//#region src/domains/chrome-caps/conditions.ts
 /**
 * Promote a Rule tree to a fluent Condition.
 *