@weasel-js/core 1.13.0 → 1.14.1

package/dist/{depSchema-CpIQzKWQ.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.
  */
@@ -1113,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
@@ -1135,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
@@ -1153,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
@@ -1164,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
@@ -1189,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[];
@@ -1197,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;
@@ -1219,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>;
@@ -1253,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>[];
@@ -1297,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. */
@@ -1305,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. */
@@ -1336,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;
@@ -1351,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;
@@ -1414,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 {
@@ -1678,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. */
@@ -1726,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. */
@@ -1762,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;
 }
 
 /**
@@ -1832,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. */
@@ -1873,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: {
@@ -2144,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;
@@ -2207,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;
 
 /**
@@ -2276,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`
@@ -2354,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
@@ -2370,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
@@ -2419,10 +2459,7 @@ interface TextEditDep {
  */
 interface ClipboardDep {
     copy(): void;
-    paste(at?: {
-        worldX: number;
-        worldY: number;
-    }): void;
+    paste(at?: WorldPoint): void;
     isEmpty(): boolean;
 }
 /**
@@ -2489,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 {
@@ -2520,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;
@@ -2556,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';
@@ -2798,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
@@ -2827,4 +2847,4 @@ declare module '@weasel-js/routing' {
     }
 }
 
-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 TransformFollower 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 SnapBegin 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 Locus as aA, type MinSize as aB, type NodeAtPointDep as aC, type OutlinePathSpec as aD, PATH_OVERLAY_ROLES as aE, type PaintKind as aF, type PaintKindEditorProps as aG, type PaintKindFamily as aH, type PaintKindLoader as aI, type PanBounds as aJ, type PathEditDrag as aK, type PathEditDragStart as aL, type PathEditFinishCtx as aM, type PathEditHandleMove as aN, type PathEditMarksCtx as aO, type PathEditOther as aP, type PathEditPart as aQ, type PathEditStore as aR, type PathForm as aS, type PathOverlay as aT, type PathOverlayOptions as aU, type PathOverlayStyle as aV, type PathRepresentation as aW, type PathTransformFinishCtx as aX, type PreviewPathsDep as aY, type ResizePolicy as aZ, STICKY_DEFAULTS 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 FinishedPathEdit as aj, GEOMETRY_BOUND_DATA as ak, type HandleLock as al, type HitTestView as am, type IngestCtx as an, type IngestionDep as ao, type InsertDep as ap, type InsertEnds as aq, type InsertExtras as ar, type InsertIntoDep as as, type InsertLive as at, type LassoSelectDep as au, type LayerCommandCache as av, type LayerDrawFailure as aw, type LayerDrawSpan as ax, type LayerRetainPolicy as ay, type LayoutDep as az, type SnapGesture as b, type SnapEdge as b0, type SnapEdges as b1, type SnapMarks as b2, type SnapReadoutDep as b3, type SvgUnpacker as b4, type TextEditDep as b5, type TextNodeData as b6, type TransformPreviewNode as b7, type TransientPath as b8, VIEW_ANIMATION_KEY as b9, previewBooleanOp as bA, registerContentHandler as bB, registerPaintKind as bC, registerPaintKindLoader as bD, seedTile as bE, stickyData as bF, stickyNodeFactory as bG, subscribeToSources as bH, switchGradientKind as bI, textBoxOf as bJ, useDecayLoop as bK, useEnteredGroup as bL, useViewAnimation as bM, useViewAnimationOn as bN, viewAxes as bO, withoutGeometryBoundData as bP, type ViewAnimationApi as ba, type ViewApi as bb, type ViewChannel as bc, applyBooleanOp as bd, applyCreateOutlines as be, asPaint as bf, createEnteredGroup as bg, createPathOverlay as bh, createSnapOutcomeStore as bi, depsUnchanged as bj, drawLayers as bk, drawOneLayer as bl, fitViewToBounds as bm, getPaintKind as bn, isLayerPainted as bo, isLayerVisible as bp, listGradientKinds as bq, listPaintKinds as br, minSizeOf as bs, paintKindOf as bt, paintKindRegistry as bu, paintedLayers as bv, paintsLayer as bw, paletteInsertPaint as bx, pathPaintOf as by, patternFamily as bz, type SnapConstrain as c, type SnapResizeBox as d, type SnapGeometry as e, type SnapOutcomeStore as f, type SnapSession as g, type 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 GeometryProjection as q, type InsertNodeFactory as r, type InsertPaint as s, type SvgIngestOptions as t, type SceneCanvasSnap as u, type Affordance as v, type AffordanceRegion as w, type AffordanceBinding as x, type CommonAffordanceScratch as y, type TextOverflow 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.
 *

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

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

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

@@ -1,4 +1,4 @@
-//#region src/features/chrome-caps/defaults.ts
+//#region src/domains/chrome-caps/defaults.ts
 /**
 * Kit-shipped defaults. Merged with the consumer's `chromeVisibility` map
 * at resolve time; consumer entries take precedence per id.

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

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

@@ -2,7 +2,7 @@ import { viewZoom } from "../../core/viewport/view.js";
 import { defaultVisibilityRules } from "./defaults.js";
 import { DEFAULT_ALLOWED_CAPABILITIES, evaluate } from "@weasel-js/routing";
 
-//#region src/features/chrome-caps/resolve.ts
+//#region src/domains/chrome-caps/resolve.ts
 /**
 * Build the per-frame visibility check: consumer rules merged on top of
 * the kit defaults, evaluated against `ctx`.

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

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