@weasel-js/core 1.10.1 → 1.11.1

package/dist/devtools-protocol.d.ts

@@ -0,0 +1,435 @@
+import { e as DebugFeature, a as DebugConfig } from './types-BN9hbdMI.js';
+import { DispatchTrace, TraceRing } from '@weasel-js/routing';
+import { S as Scene } from './types-CniVctmk.js';
+import '@weasel-js/history';
+import './types-7puAuVD2.js';
+import '@weasel-js/geom';
+import '@weasel-js/quantity';
+
+/**
+ * Turn any value into plain data a panel can display. A node's `data` is the
+ * app's own type, so nothing here assumes it is JSON-safe.
+ */
+/** What {@link serialize} produces: JSON-safe apart from `undefined`, which structured clone carries. */
+type SerializedValue = string | number | boolean | null | undefined | SerializedValue[] | {
+    [key: string]: SerializedValue;
+};
+/** How much of a value {@link serialize} writes out. */
+interface SerializeLimits {
+    /** Nesting below this depth is written as `'…'`. */
+    depth?: number;
+    /** Array, map, set and object entries past this many are cut, with a note of how many. */
+    items?: number;
+    /** Strings longer than this are cut. */
+    chars?: number;
+}
+/** `value` as plain data: functions as `ƒ name`, typed arrays as their type and
+ *  length, maps and sets tagged, cycles marked, and every size capped. */
+declare function serialize(value: unknown, limits?: SerializeLimits): SerializedValue;
+
+/**
+ * The messages a devtools panel and a page running weasel exchange. Plain
+ * data only, so the same messages cross a direct call or `window.postMessage`.
+ */
+
+/** Bumped on any change a panel built against the previous number would misread. */
+declare const DEVTOOLS_PROTOCOL = 1;
+/** The areas of a root a `changed` notice reports. */
+type DevtoolsArea = 'scene' | 'selection' | 'view' | 'tool' | 'trace' | 'registry' | 'history';
+/** One mounted `<SceneCanvas>`. */
+interface DevtoolsRootInfo {
+    id: string;
+    /** The canvas's `aria-label`, else its DOM id, else its root id. */
+    label: string;
+    dimension: '2d' | '3d';
+}
+/** Debug overlay features a panel turns on or off over the canvas's own `debug` prop. */
+type DevtoolsOverlays = Partial<Record<DebugFeature, boolean>>;
+/** A request a panel sends about one root. */
+type DevtoolsRequest = {
+    protocol: number;
+    requestId: number;
+    rootId: string;
+} & ({
+    type: 'get-children';
+    nodeId?: string;
+} | {
+    type: 'get-node';
+    nodeId: string;
+} | {
+    type: 'get-state';
+}
+/** Coord records come back only when `coordCursor` is given. */
+ | {
+    type: 'get-trace';
+    cursor: number;
+    coordCursor?: number;
+} | {
+    type: 'get-frame';
+} | {
+    type: 'get-registry';
+}
+/** The stack's entry labels come back only when `checkpoints` is true. */
+ | {
+    type: 'get-history';
+    cursor: number;
+    checkpoints?: boolean;
+} | {
+    type: 'select';
+    ids: string[];
+} | {
+    type: 'highlight';
+    ids: string[];
+} | {
+    type: 'set-tool';
+    toolId: string | null;
+} | {
+    type: 'set-overlays';
+    overlays: DevtoolsOverlays;
+});
+/** Every message a panel sends the page. */
+type PanelMessage = {
+    type: 'yo';
+    protocol: number;
+}
+/** The panel is closing: drop its overlays and highlight, and stop tracing for it. */
+ | {
+    type: 'bye';
+    protocol: number;
+} | DevtoolsRequest;
+/** Every message the page sends a panel. */
+type PageMessage = {
+    type: 'sup';
+    protocol: number;
+    kitVersion: string;
+    roots: DevtoolsRootInfo[];
+} | {
+    type: 'root-added';
+    protocol: number;
+    root: DevtoolsRootInfo;
+} | {
+    type: 'root-removed';
+    protocol: number;
+    rootId: string;
+}
+/** Each changed area with its new version. At most one per root per frame. */
+ | {
+    type: 'changed';
+    protocol: number;
+    rootId: string;
+    areas: Partial<Record<DevtoolsArea, number>>;
+} | {
+    type: 'result';
+    protocol: number;
+    requestId: number;
+    result: DevtoolsResult;
+}
+/** `requestId` is null for a message that was not a request. */
+ | {
+    type: 'error';
+    protocol: number;
+    requestId: number | null;
+    message: string;
+};
+/** One child row of the scene tree. `nodeId` absent asks for the top level. */
+interface DevtoolsNodeSummary {
+    id: string;
+    kind: 'leaf' | 'container';
+    layer: string;
+    childCount: number;
+    hidden: boolean;
+    locked: boolean;
+    pickable: boolean;
+}
+/** A node as `get-node` returns it: its row in the tree, plus its parent, pose and data. */
+interface DevtoolsNodeDetail extends DevtoolsNodeSummary {
+    parent: string | null;
+    pose: SerializedValue;
+    data: SerializedValue;
+}
+/** What `get-state` returns about a root. */
+interface DevtoolsRootState {
+    selection: string[];
+    view: SerializedValue;
+    activeTool: string | null;
+    tools: string[];
+    /** The debug overlay features in effect: the canvas's own, with the panel's over them. */
+    overlays: DevtoolsOverlays;
+    /** Probes registered through the test hook, by name. */
+    probes: Record<string, SerializedValue>;
+}
+/** What `get-trace` returns: the records after the cursor, and the cursor to send next. */
+interface DevtoolsTraceSlice {
+    entries: SerializedValue[];
+    cursor: number;
+    /** What a press at the pointer would do, or null when the pointer is off the canvas. */
+    live: SerializedValue;
+    coords?: {
+        entries: SerializedValue[];
+        cursor: number;
+    };
+}
+/** One gesture-to-action binding, as a tool, an always-on entry or an action declares it. */
+interface DevtoolsBinding {
+    actionId: string;
+    /** The `GestureSpec` as written. */
+    spec: SerializedValue;
+    /** The spec in the route grammar, one string per route it expands to. */
+    routes: string[];
+    /** The binding's `BindingOpts`: params, roles, views. */
+    opts: SerializedValue;
+}
+/** A tool or other contribution the canvas's dispatcher assembles bindings from. */
+interface DevtoolsToolEntry {
+    id: string;
+    /** A switchable tool, an always-on entry, or one a `features` preset brought. */
+    slot: 'tool' | 'ambient' | 'contribution';
+    label: string;
+    /** The icon's qualified name. */
+    icon: string | null;
+    group: string | null;
+    shortcut: string | null;
+    /** The key that holds it engaged while pressed. */
+    hotkey: string | null;
+    hidden: boolean;
+    cursor: SerializedValue;
+    eligibility: SerializedValue;
+    bindings: DevtoolsBinding[];
+    /** Ids of the actions it brings with it. */
+    actions: string[];
+    /** Names of the deps it registers. */
+    deps: string[];
+    hasOverlay: boolean;
+}
+/** A registered action. `enabled` and `active` are asked when the registry is read. */
+interface DevtoolsActionEntry {
+    id: string;
+    label: string;
+    icon: string | null;
+    group: string | null;
+    tags: string[];
+    shortcut: string | null;
+    /** Which binding scope its own bindings ride. */
+    scope: 'hotkey' | 'ambient';
+    invoker: 'immediate' | 'ongoing' | null;
+    requires: string[];
+    variants: {
+        key: string;
+        label: string;
+        icon: string | null;
+        params: SerializedValue;
+    }[];
+    /** `true`, or the reason it is disabled. */
+    enabled: true | string;
+    /** Null for an action with no pressed state. */
+    active: boolean | null;
+    hasPreview: boolean;
+    /** The eligibility rule, or null for always eligible. */
+    eligible: SerializedValue;
+    bindings: DevtoolsBinding[];
+}
+/** A dep name the canvas's registry answers. */
+interface DevtoolsDepEntry {
+    name: string;
+    /** How many scopes above the canvas's own its live source sits: 0 for the canvas's. */
+    depth: number;
+    /** How many sources are stacked under the name there, the live one included. */
+    stacked: number;
+}
+/** What `get-registry` returns: what one canvas has registered. */
+interface DevtoolsRegistry {
+    tools: DevtoolsToolEntry[];
+    actions: DevtoolsActionEntry[];
+    deps: DevtoolsDepEntry[];
+    /** The node routing kinds a binding's `kind:` target can name, in classify order. */
+    routingKinds: string[];
+}
+/** One op of a recorded history step. */
+interface DevtoolsHistoryOp {
+    /** The op's registered name, `'kit:setPose'` and the like; `'?'` for an op with none. */
+    kind: string;
+    /** The node ids its args address. */
+    targets: string[];
+    summary: SerializedValue;
+}
+/** One change to a scene's history: an edit recorded, merged, undone, redone or jumped across. */
+interface DevtoolsHistoryRecord {
+    ts: number;
+    step: 'push' | 'coalesce' | 'undo' | 'redo' | 'goto' | 'branch' | 'prune' | 'clear' | 'restore';
+    /** The entries the step pushed, merged into or walked across, in the order it touched them. */
+    entries: {
+        id: number;
+        label: string;
+        opCount: number;
+        ops: DevtoolsHistoryOp[];
+    }[];
+    /** Where the history stood after the step: entries applied, and entries in all. */
+    position: {
+        index: number;
+        total: number;
+    };
+}
+/** What `get-history` returns: the steps after the cursor, the cursor to send next, and where the history stands. */
+interface DevtoolsHistorySlice {
+    entries: DevtoolsHistoryRecord[];
+    cursor: number;
+    position: {
+        index: number;
+        total: number;
+        canUndo: boolean;
+        canRedo: boolean;
+    };
+    /** Every entry on the stacks, oldest applied first, then the redoable ones. */
+    checkpoints?: {
+        id: string;
+        label: string;
+    }[];
+}
+/** The body of a `result` reply; which one depends on the request it answers. */
+type DevtoolsResult = DevtoolsNodeSummary[] | DevtoolsNodeDetail | DevtoolsRootState | DevtoolsTraceSlice | DevtoolsRegistry | DevtoolsHistorySlice | SerializedValue | null;
+
+/** One `clientToWorld` call, so a cursor position can be reconciled with the
+ *  world point it became. A canvas keeps these beside its dispatch trace, and
+ *  the devtools hook's `get-trace` reads them. */
+interface CoordTraceEntry {
+    ts: number;
+    clientX: number;
+    clientY: number;
+    rect: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    } | null;
+    view: {
+        x: number;
+        y: number;
+        scaleX: number;
+        scaleY: number;
+    } | null;
+    world: {
+        x: number;
+        y: number;
+    };
+    /** True when canvas/view weren't available and we returned identity. */
+    fallback: boolean;
+}
+
+/**
+ * A root: what one mounted `<SceneCanvas>` exposes to the devtools hook and to
+ * the test hook. The canvas supplies live getters; the root adds change
+ * versions and the probe registry.
+ */
+
+/** What a canvas hands {@link createDevtoolsRoot}. Every getter reads the latest committed value. */
+interface DevtoolsRootSource {
+    label(): string;
+    readonly dimension: '2d' | '3d';
+    scene(): Scene<unknown, string, unknown> | null;
+    selection(): readonly string[];
+    select(ids: readonly string[]): void;
+    view(): unknown;
+    activeTool(): string | null;
+    tools(): readonly string[];
+    setTool(id: string | null): void;
+    trace: DispatchTrace;
+    coords: TraceRing<CoordTraceEntry>;
+    /** The debug sink's stats for the last paint, or null while the frame panel is off. */
+    frame(): unknown;
+    /** The debug overlay config in effect, or null when the overlay is off. */
+    overlays(): DebugConfig | null;
+    /** Lay the panel's overlay flags and highlight over the canvas's own `debug`; null drops them. */
+    setOverride(override: {
+        overlays: DevtoolsOverlays;
+        highlight: readonly string[];
+    } | null): void;
+    /** What the canvas has registered, described when asked. Absent, `get-registry` is refused. */
+    registry?(): DevtoolsRegistry;
+    /** Hear that what {@link DevtoolsRootSource.registry} describes may have changed. Returns the unsubscribe. */
+    subscribeRegistry?(listener: () => void): () => void;
+    /** The scene's history steps. Absent, `get-history` is refused. */
+    history?: TraceRing<DevtoolsHistoryRecord>;
+}
+/** One canvas as the devtools hook holds it. */
+interface DevtoolsRoot {
+    readonly id: string;
+    readonly source: DevtoolsRootSource;
+    info(): DevtoolsRootInfo;
+    /** Name-keyed probes; the test hook's `registerProbe` writes here. */
+    readonly probes: Map<string, () => unknown>;
+    version(area: DevtoolsArea): number;
+    /** Say that `area` changed. The scene and the trace say so themselves while anything listens. */
+    notify(area: DevtoolsArea): void;
+    /** Hear each change, with the area. Returns the unsubscribe. */
+    subscribe(listener: (area: DevtoolsArea) => void): () => void;
+}
+/** A root over `source`, with a fresh page-unique id. */
+declare function createDevtoolsRoot(source: DevtoolsRootSource): DevtoolsRoot;
+
+/** A session's change notices: the roots it follows, and what changed in each since the last flush. */
+
+/** Run `flush` once, soon. The hook's default waits for the next animation frame. */
+type DevtoolsSchedule = (flush: () => void) => void;
+
+/**
+ * How devtools messages travel. A transport sends one side's messages and
+ * hears the other side's; the session neither knows nor cares which kind it has.
+ */
+
+/** One end of a connection: it sends `Out` and hears `In`. */
+interface DevtoolsTransport<Out, In> {
+    send(message: Out): void;
+    /** Hear the other side. Returns the unsubscribe. */
+    onMessage(listener: (message: In) => void): () => void;
+}
+/** The page's end of a connection. */
+type PageTransport = DevtoolsTransport<PageMessage, PanelMessage>;
+/** The panel's end of a connection. */
+type PanelTransport = DevtoolsTransport<PanelMessage, PageMessage>;
+/** Marks devtools traffic among whatever else a page posts to its window. */
+declare const DEVTOOLS_ENVELOPE = "weasel-devtools";
+/** A devtools message as posted to a window. */
+interface DevtoolsEnvelope {
+    source: typeof DEVTOOLS_ENVELOPE;
+    side: 'page' | 'panel';
+    message: PageMessage | PanelMessage;
+}
+/** Whether a posted message's `data` is devtools traffic. */
+declare function isDevtoolsEnvelope(data: unknown): data is DevtoolsEnvelope;
+/** Both ends of a connection within one page: delivery is a direct, synchronous call. */
+declare function createInPageTransports(): {
+    page: PageTransport;
+    panel: PanelTransport;
+};
+/** The page's end over `window.postMessage`, for an extension's content script. */
+declare function createWindowPageTransport(target?: Window): PageTransport;
+/** The panel's end over `window.postMessage`: what a content script uses to reach the page. */
+declare function createWindowPanelTransport(target?: Window): PanelTransport;
+
+/** What `window.__weaselDevtools__` holds: the page's canvases, and the way a panel connects to them. */
+interface WeaselDevtoolsHook {
+    readonly protocol: number;
+    readonly kitVersion: string;
+    roots(): DevtoolsRootInfo[];
+    /** The root registered under `id`, for in-page readers such as the test hook. */
+    root(id: string): DevtoolsRoot | undefined;
+    /** Add a canvas's root. Returns its removal. */
+    register(root: DevtoolsRoot): () => void;
+    /** Serve a panel over `transport` until the panel says `bye` or the returned close is called.
+     *  `opening` is a message that arrived before the transport was listened to — the `yo` that
+     *  prompted the connection. */
+    connect(transport: PageTransport, opening?: PanelMessage): () => void;
+}
+declare global {
+    interface Window {
+        __weaselDevtools__?: WeaselDevtoolsHook;
+    }
+}
+/** A hook not published anywhere: what {@link installDevtoolsHook} publishes, and what tests build. */
+declare function createDevtoolsHook(opts?: {
+    schedule?: DevtoolsSchedule;
+}): WeaselDevtoolsHook;
+/** Publish the hook on `window.__weaselDevtools__`, once; later calls return the same hook. */
+declare function installDevtoolsHook(): WeaselDevtoolsHook | null;
+
+export { DEVTOOLS_ENVELOPE, DEVTOOLS_PROTOCOL, type DevtoolsActionEntry, type DevtoolsArea, type DevtoolsBinding, type DevtoolsDepEntry, type DevtoolsEnvelope, type DevtoolsHistoryOp, type DevtoolsHistoryRecord, type DevtoolsHistorySlice, type DevtoolsNodeDetail, type DevtoolsNodeSummary, type DevtoolsOverlays, type DevtoolsRegistry, type DevtoolsRequest, type DevtoolsResult, type DevtoolsRoot, type DevtoolsRootInfo, type DevtoolsRootSource, type DevtoolsRootState, type DevtoolsSchedule, type DevtoolsToolEntry, type DevtoolsTraceSlice, type DevtoolsTransport, type PageMessage, type PageTransport, type PanelMessage, type PanelTransport, type SerializeLimits, type SerializedValue, type WeaselDevtoolsHook, createDevtoolsHook, createDevtoolsRoot, createInPageTransports, createWindowPageTransport, createWindowPanelTransport, installDevtoolsHook, isDevtoolsEnvelope, serialize };

package/dist/devtools-protocol.js

@@ -0,0 +1,7 @@
+import { serialize } from "./devtools/serialize.js";
+import { DEVTOOLS_PROTOCOL } from "./devtools/protocol.js";
+import { DEVTOOLS_ENVELOPE, createInPageTransports, createWindowPageTransport, createWindowPanelTransport, isDevtoolsEnvelope } from "./devtools/transport.js";
+import { createDevtoolsHook, installDevtoolsHook } from "./devtools/hook.js";
+import { createDevtoolsRoot } from "./devtools/root.js";
+
+export { DEVTOOLS_ENVELOPE, DEVTOOLS_PROTOCOL, createDevtoolsHook, createDevtoolsRoot, createInPageTransports, createWindowPageTransport, createWindowPanelTransport, installDevtoolsHook, isDevtoolsEnvelope, serialize };

package/dist/devtools.d.ts

@@ -0,0 +1,8 @@
+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-CniVctmk.js';
+import '@weasel-js/history';
+import './types-7puAuVD2.js';
+import '@weasel-js/geom';
+import '@weasel-js/quantity';

package/dist/devtools.js

@@ -0,0 +1,12 @@
+import { serialize } from "./devtools/serialize.js";
+import { DEVTOOLS_PROTOCOL } from "./devtools/protocol.js";
+import { DEVTOOLS_ENVELOPE, createInPageTransports, createWindowPageTransport, createWindowPanelTransport, isDevtoolsEnvelope } from "./devtools/transport.js";
+import { createDevtoolsHook, installDevtoolsHook } from "./devtools/hook.js";
+import { createDevtoolsRoot } from "./devtools/root.js";
+
+//#region src/import-shims/devtools.ts
+installDevtoolsHook();
+
+//#endregion
+export { DEVTOOLS_ENVELOPE, DEVTOOLS_PROTOCOL, createDevtoolsHook, createDevtoolsRoot, createInPageTransports, createWindowPageTransport, createWindowPanelTransport, installDevtoolsHook, isDevtoolsEnvelope, serialize };
+//# sourceMappingURL=devtools.js.map

package/dist/devtools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"devtools.js","names":[],"sources":["../src/import-shims/devtools.ts"],"sourcesContent":["// `@weasel-js/core/devtools` — importing it publishes the devtools hook on\n// `window.__weaselDevtools__`. A dev build does that by itself; a production\n// build does it only for an app that imports this. Its exports are\n// `@weasel-js/core/devtools-protocol`'s, which installs nothing.\nimport { installDevtoolsHook } from '../devtools/hook';\n\ninstallDevtoolsHook();\n\nexport * from './devtools-protocol';\n"],"mappings":";;;;;;;AAMA,oBAAoB"}

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

@@ -1,16 +1,18 @@
 //#region src/features/chrome-caps/buildChromeCtx.ts
-function e(e) {
+/** Gather the current canvas state into the context that chrome-visibility
+*  rules are evaluated against. Rebuilt per frame. */
+function buildChromeCtx(args) {
 	return {
-		focused: e.focused,
-		selection: e.selection,
-		multiActive: e.multiActive,
-		modifiers: e.modifiers,
-		action: e.action,
-		hover: e.hover,
-		view: e.view
+		focused: args.focused,
+		selection: args.selection,
+		multiActive: args.multiActive,
+		modifiers: args.modifiers,
+		action: args.action,
+		hover: args.hover,
+		view: args.view
 	};
 }
-//#endregion
-export { e as buildChromeCtx };
 
+//#endregion
+export { buildChromeCtx };
 //# sourceMappingURL=buildChromeCtx.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"buildChromeCtx.js","names":["buildChromeCtx","args"],"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,SAAgBA,EAAe,GAAqC;CAClE,OAAO;EACL,SAASC,EAAK;EACd,WAAWA,EAAK;EAChB,aAAaA,EAAK;EAClB,WAAWA,EAAK;EAChB,QAAQA,EAAK;EACb,OAAOA,EAAK;EACZ,MAAMA,EAAK;CACb;AACF"}
+{"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

@@ -1,36 +1,114 @@
-import { ALWAYS as e, NEVER as t, evaluate as n } from "@weasel-js/routing";
+import { ALWAYS, NEVER, evaluate } from "@weasel-js/routing";
+
 //#region src/features/chrome-caps/conditions.ts
-function r(e) {
-	let t = (t) => n(e, t);
-	return t.rule = e, t.and = (t) => r(a(e, i(t))), t.or = (t) => r(o(e, i(t))), t.andNot = (t) => r(a(e, { not: i(t) })), t.orNot = (t) => r(o(e, { not: i(t) })), t;
+/**
+* Promote a Rule tree to a fluent Condition.
+*
+* **Chain semantics: strict left-to-right.** No boolean precedence.
+* `focused.or(hovering).and(selectionIs(1))` evaluates
+* `((focused || hovering) && selectionIs(1))`. For grouped disjunction, use
+* the top-level `or` / `and` / `not` helpers or name intermediates.
+*
+* Combinators flatten same-kind nesting on construction so `a.and(b).and(c)`
+* produces `{ all: [a, b, c] }`.
+*/
+function cond(rule) {
+	const fn = (ctx) => evaluate(rule, ctx);
+	const condition = fn;
+	condition.rule = rule;
+	condition.and = (other) => cond(combineAll(rule, asRule(other)));
+	condition.or = (other) => cond(combineAny(rule, asRule(other)));
+	condition.andNot = (other) => cond(combineAll(rule, { not: asRule(other) }));
+	condition.orNot = (other) => cond(combineAny(rule, { not: asRule(other) }));
+	return condition;
 }
-function i(e) {
-	return typeof e == "function" ? e.rule : e;
+function asRule(value) {
+	return typeof value === "function" ? value.rule : value;
 }
-function a(e, t) {
-	let n = "all" in e ? e.all : [e], r = "all" in t ? t.all : [t];
-	return { all: [...n, ...r] };
+function combineAll(a, b) {
+	const left = "all" in a ? a.all : [a];
+	const right = "all" in b ? b.all : [b];
+	return { all: [...left, ...right] };
 }
-function o(e, t) {
-	let n = "any" in e ? e.any : [e], r = "any" in t ? t.any : [t];
-	return { any: [...n, ...r] };
+function combineAny(a, b) {
+	const left = "any" in a ? a.any : [a];
+	const right = "any" in b ? b.any : [b];
+	return { any: [...left, ...right] };
 }
-function s(e) {
-	return r({ when: e });
+/** Inline-lambda escape hatch. Wraps the closure as a `when` rule node. */
+function when(fn) {
+	return cond({ when: fn });
 }
-function c(...e) {
-	return r({ all: e.map(i) });
+/** `(a && b && c && ...)` — useful when chain mixing makes left-to-right
+*  semantics ambiguous. */
+function and(...cs) {
+	return cond({ all: cs.map(asRule) });
 }
-function l(...e) {
-	return r({ any: e.map(i) });
+/** `(a || b || c || ...)` — preferred over `.or` chains when mixed with
+*  `.and` to make grouping explicit. */
+function or(...cs) {
+	return cond({ any: cs.map(asRule) });
 }
-function u(e) {
-	return r({ not: i(e) });
+/** `!c` — top-level negation. Most rules use `.andNot()` / `.orNot()`
+*  instead; this is for the lead-with-negation case. */
+function not(c) {
+	return cond({ not: asRule(c) });
 }
-var d = r(e), f = r(t), p = r({ focused: !0 }), m = r({ gesturing: !0 });
-r({ editingAnchors: !0 }), r({ resizable: !0 });
-var h = (e) => r({ actionIs: e }), g = r({ selection: { empty: !0 } }), _ = (e) => r({ selection: { is: e } }), v = (e) => r({ selection: { atLeast: e } }), y = r({ when: (e) => e.multiActive }), b = r({ hovering: !0 }), x = r({ hoveringSelected: !0 }), S = (e) => r({ modifierHeld: e }), C = (e) => r({ zoomAtLeast: e }), w = (e) => r({ mode: e }), T = (e) => r({ mode: { in: e } }), E = (e) => r({ mode: { not: e } }), D = (e) => r({ capability: e }), O = (e) => r({ capability: { in: e } }), k = (e) => r({ capability: [...e] }), A = (e) => r({ capability: { not: e } }), j = r({ coarsePointer: !0 }), M = r({ canHover: !0 });
-//#endregion
-export { h as actionIs, d as always, c as and, M as canHover, k as capabilityAll, O as capabilityIn, D as capabilityIs, A as capabilityNot, j as coarsePointer, r as cond, p as focused, m as gesturing, b as hovering, x as hoveringSelected, T as modeIn, w as modeIs, E as modeNot, S as modifierHeld, y as multiActive, f as never, u as not, l as or, v as selectionAtLeast, g as selectionEmpty, _ as selectionIs, s as when, C as zoomAtLeast };
+/** Always true. The fallback for any chrome id without a registered rule. */
+var always = cond(ALWAYS);
+/** Always false. Useful for "turn this chrome off entirely":
+*  `chromeVisibility={{ 'snap.guides': never }}`. */
+var never = cond(NEVER);
+/** Canvas surface currently focused. */
+var focused = cond({ focused: true });
+/** Any action currently in flight (read: user is gesturing). */
+var gesturing = cond({ gesturing: true });
+/** A path is currently in anchor-edit mode. */
+var editingAnchors = cond({ editingAnchors: true });
+/** Current selection is resizable (every selected node passes the consumer's
+*  `selectTool.resize.resizable` predicate). Absent predicate → resizable. */
+var resizable = cond({ resizable: true });
+/** Active action's kind matches `kind` (e.g. `actionIs('move')`). */
+var actionIs = (kind) => cond({ actionIs: kind });
+/** Nothing selected. */
+var selectionEmpty = cond({ selection: { empty: true } });
+/** Exactly `n` items selected. */
+var selectionIs = (n) => cond({ selection: { is: n } });
+/** At least `n` items selected. `selectionAtLeast(1)` is the common
+*  "something is selected" check. */
+var selectionAtLeast = (n) => cond({ selection: { atLeast: n } });
+/** Multi-mode handle behavior active (single shared union-bounds
+*  handle vs per-item handles). */
+var multiActive = cond({ when: (c) => c.multiActive });
+/** Pointer is hovering some node. */
+var hovering = cond({ hovering: true });
+/** Pointer is hovering a node that is currently selected. */
+var hoveringSelected = cond({ hoveringSelected: true });
+/** Named modifier key currently held. */
+var modifierHeld = (m) => cond({ modifierHeld: m });
+/** View scale (uniform or geometric mean for non-uniform) is at least
+*  `z`. Useful for "hide hairline chrome at low zoom" rules. */
+var zoomAtLeast = (z) => cond({ zoomAtLeast: z });
+/** Active mode equals `m`. */
+var modeIs = (m) => cond({ mode: m });
+/** Active mode is one of `modes`. */
+var modeIn = (modes) => cond({ mode: { in: modes } });
+/** Active mode is NOT `m`. */
+var modeNot = (m) => cond({ mode: { not: m } });
+/** Active mode's `allows` includes capability `cap`. */
+var capabilityIs = (cap) => cond({ capability: cap });
+/** Active mode's `allows` includes ANY of `caps` (OR). */
+var capabilityIn = (caps) => cond({ capability: { in: caps } });
+/** Active mode's `allows` includes ALL of `caps` (AND). */
+var capabilityAll = (caps) => cond({ capability: [...caps] });
+/** Active mode's `allows` does NOT include capability `cap`. */
+var capabilityNot = (cap) => cond({ capability: { not: cap } });
+/** Primary pointer is imprecise (touch, most styluses). Absent device
+*  profile → false. */
+var coarsePointer = cond({ coarsePointer: true });
+/** Primary pointer can hover. Absent device profile → true. */
+var canHover = cond({ canHover: true });
 
+//#endregion
+export { actionIs, always, and, canHover, capabilityAll, capabilityIn, capabilityIs, capabilityNot, coarsePointer, cond, editingAnchors, focused, gesturing, hovering, hoveringSelected, modeIn, modeIs, modeNot, modifierHeld, multiActive, never, not, or, selectionAtLeast, selectionEmpty, selectionIs, when, zoomAtLeast };
 //# sourceMappingURL=conditions.js.map