@weasel-js/core 1.11.0 → 1.12.0

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

@@ -10,37 +10,43 @@ function useHoverTracking(args) {
 	const { nodeAtClientPoint, enabled = true } = args;
 	const hoverRef = useRef(null);
 	const nodeAtRef = useLatest(nodeAtClientPoint);
+	const onChangeRef = useLatest(args.onChange);
 	const elementRef = useRef(null);
 	const enabledRef = useRef(enabled);
 	const detachRef = useRef(null);
+	const hover = useCallback((id) => {
+		if (hoverRef.current === id) return;
+		hoverRef.current = id;
+		onChangeRef.current?.(id);
+	}, [onChangeRef]);
 	const sync = useCallback(() => {
 		detachRef.current?.();
 		detachRef.current = null;
-		hoverRef.current = null;
+		hover(null);
 		const el = elementRef.current;
 		if (!el || !enabledRef.current) return;
-		const onMove = (e) => {
-			hoverRef.current = nodeAtRef.current(e.clientX, e.clientY)?.id ?? null;
-		};
-		const onLeave = () => {
-			hoverRef.current = null;
-		};
+		const onMove = (e) => hover(nodeAtRef.current(e.clientX, e.clientY)?.id ?? null);
+		const onLeave = () => hover(null);
 		el.addEventListener("pointermove", onMove);
 		el.addEventListener("pointerleave", onLeave);
 		detachRef.current = () => {
 			el.removeEventListener("pointermove", onMove);
 			el.removeEventListener("pointerleave", onLeave);
 		};
-	}, [nodeAtRef]);
+	}, [nodeAtRef, hover]);
 	useEffect(() => {
 		enabledRef.current = enabled;
 		sync();
 		return () => {
 			detachRef.current?.();
 			detachRef.current = null;
-			hoverRef.current = null;
+			hover(null);
 		};
-	}, [enabled, sync]);
+	}, [
+		enabled,
+		sync,
+		hover
+	]);
 	const canvasRef = useCallback((element) => {
 		if (elementRef.current === element) return;
 		elementRef.current = element;

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

@@ -1 +1 @@
-{"version":3,"file":"useHoverTracking.js","names":[],"sources":["../../../src/features/chrome-caps/useHoverTracking.ts"],"sourcesContent":["/** Last-hovered NodeId for chrome-caps rules. */\n\nimport { useCallback, useEffect, useMemo, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { NodeId } from '../../core/scene/types';\n\n/** Options for `useHoverTracking`. */\nexport interface UseHoverTrackingArgs {\n  /** Topmost id under a client point, or null. */\n  nodeAtClientPoint: (clientX: number, clientY: number) => { id: NodeId } | null;\n  enabled?: boolean;\n}\n\n/** What `useHoverTracking` returns. Both members keep their identity. */\nexport interface HoverTracking {\n  /** The node the pointer is over, or null. */\n  getHover: () => NodeId | null;\n  /** Hand it the element to track, or null to stop: a callback ref, so an\n   *  element that mounts after the hook is tracked from the moment it arrives. */\n  canvasRef: (element: HTMLElement | null) => void;\n}\n\n/** Track which node the pointer is over. Returns a getter rather than state,\n *  so a pointer move does not re-render the component. Cleared on\n *  `pointerleave`. */\nexport function useHoverTracking(args: UseHoverTrackingArgs): HoverTracking {\n  const { nodeAtClientPoint, enabled = true } = args;\n  const hoverRef = useRef<NodeId | null>(null);\n  const nodeAtRef = useLatest(nodeAtClientPoint);\n  const elementRef = useRef<HTMLElement | null>(null);\n  const enabledRef = useRef(enabled);\n  const detachRef = useRef<(() => void) | null>(null);\n\n  const sync = useCallback(() => {\n    detachRef.current?.();\n    detachRef.current = null;\n    hoverRef.current = null;\n    const el = elementRef.current;\n    if (!el || !enabledRef.current) return;\n    const onMove = (e: PointerEvent) => {\n      hoverRef.current = nodeAtRef.current(e.clientX, e.clientY)?.id ?? null;\n    };\n    const onLeave = () => { hoverRef.current = null; };\n    el.addEventListener('pointermove', onMove);\n    el.addEventListener('pointerleave', onLeave);\n    detachRef.current = () => {\n      el.removeEventListener('pointermove', onMove);\n      el.removeEventListener('pointerleave', onLeave);\n    };\n  }, [nodeAtRef]);\n\n  useEffect(() => {\n    enabledRef.current = enabled;\n    sync();\n    return () => {\n      detachRef.current?.();\n      detachRef.current = null;\n      hoverRef.current = null;\n    };\n  }, [enabled, sync]);\n\n  const canvasRef = useCallback((element: HTMLElement | null) => {\n    if (elementRef.current === element) return;\n    elementRef.current = element;\n    sync();\n  }, [sync]);\n  const getHover = useCallback(() => hoverRef.current, []);\n\n  return useMemo(() => ({ getHover, canvasRef }), [getHover, canvasRef]);\n}\n"],"mappings":";;;;;;;;AAyBA,SAAgB,iBAAiB,MAA2C;CAC1E,MAAM,EAAE,mBAAmB,UAAU,SAAS;CAC9C,MAAM,WAAW,OAAsB,IAAI;CAC3C,MAAM,YAAY,UAAU,iBAAiB;CAC7C,MAAM,aAAa,OAA2B,IAAI;CAClD,MAAM,aAAa,OAAO,OAAO;CACjC,MAAM,YAAY,OAA4B,IAAI;CAElD,MAAM,OAAO,kBAAkB;EAC7B,UAAU,UAAU;EACpB,UAAU,UAAU;EACpB,SAAS,UAAU;EACnB,MAAM,KAAK,WAAW;EACtB,IAAI,CAAC,MAAM,CAAC,WAAW,SAAS;EAChC,MAAM,UAAU,MAAoB;GAClC,SAAS,UAAU,UAAU,QAAQ,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM;EACpE;EACA,MAAM,gBAAgB;GAAE,SAAS,UAAU;EAAM;EACjD,GAAG,iBAAiB,eAAe,MAAM;EACzC,GAAG,iBAAiB,gBAAgB,OAAO;EAC3C,UAAU,gBAAgB;GACxB,GAAG,oBAAoB,eAAe,MAAM;GAC5C,GAAG,oBAAoB,gBAAgB,OAAO;EAChD;CACF,GAAG,CAAC,SAAS,CAAC;CAEd,gBAAgB;EACd,WAAW,UAAU;EACrB,KAAK;EACL,aAAa;GACX,UAAU,UAAU;GACpB,UAAU,UAAU;GACpB,SAAS,UAAU;EACrB;CACF,GAAG,CAAC,SAAS,IAAI,CAAC;CAElB,MAAM,YAAY,aAAa,YAAgC;EAC7D,IAAI,WAAW,YAAY,SAAS;EACpC,WAAW,UAAU;EACrB,KAAK;CACP,GAAG,CAAC,IAAI,CAAC;CACT,MAAM,WAAW,kBAAkB,SAAS,SAAS,CAAC,CAAC;CAEvD,OAAO,eAAe;EAAE;EAAU;CAAU,IAAI,CAAC,UAAU,SAAS,CAAC;AACvE"}
+{"version":3,"file":"useHoverTracking.js","names":[],"sources":["../../../src/features/chrome-caps/useHoverTracking.ts"],"sourcesContent":["/** Last-hovered NodeId for chrome-caps rules. */\n\nimport { useCallback, useEffect, useMemo, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { NodeId } from '../../core/scene/types';\n\n/** Options for `useHoverTracking`. */\nexport interface UseHoverTrackingArgs {\n  /** Topmost id under a client point, or null. */\n  nodeAtClientPoint: (clientX: number, clientY: number) => { id: NodeId } | null;\n  enabled?: boolean;\n  /** Called when the hovered id changes, `null` once the pointer is over no node or has left. */\n  onChange?: (id: NodeId | null) => void;\n}\n\n/** What `useHoverTracking` returns. Both members keep their identity. */\nexport interface HoverTracking {\n  /** The node the pointer is over, or null. */\n  getHover: () => NodeId | null;\n  /** Hand it the element to track, or null to stop: a callback ref, so an\n   *  element that mounts after the hook is tracked from the moment it arrives. */\n  canvasRef: (element: HTMLElement | null) => void;\n}\n\n/** Track which node the pointer is over. Returns a getter rather than state,\n *  so a pointer move does not re-render the component. Cleared on\n *  `pointerleave`. */\nexport function useHoverTracking(args: UseHoverTrackingArgs): HoverTracking {\n  const { nodeAtClientPoint, enabled = true } = args;\n  const hoverRef = useRef<NodeId | null>(null);\n  const nodeAtRef = useLatest(nodeAtClientPoint);\n  const onChangeRef = useLatest(args.onChange);\n  const elementRef = useRef<HTMLElement | null>(null);\n  const enabledRef = useRef(enabled);\n  const detachRef = useRef<(() => void) | null>(null);\n\n  const hover = useCallback((id: NodeId | null) => {\n    if (hoverRef.current === id) return;\n    hoverRef.current = id;\n    onChangeRef.current?.(id);\n  }, [onChangeRef]);\n\n  const sync = useCallback(() => {\n    detachRef.current?.();\n    detachRef.current = null;\n    hover(null);\n    const el = elementRef.current;\n    if (!el || !enabledRef.current) return;\n    const onMove = (e: PointerEvent) => hover(nodeAtRef.current(e.clientX, e.clientY)?.id ?? null);\n    const onLeave = () => hover(null);\n    el.addEventListener('pointermove', onMove);\n    el.addEventListener('pointerleave', onLeave);\n    detachRef.current = () => {\n      el.removeEventListener('pointermove', onMove);\n      el.removeEventListener('pointerleave', onLeave);\n    };\n  }, [nodeAtRef, hover]);\n\n  useEffect(() => {\n    enabledRef.current = enabled;\n    sync();\n    return () => {\n      detachRef.current?.();\n      detachRef.current = null;\n      hover(null);\n    };\n  }, [enabled, sync, hover]);\n\n  const canvasRef = useCallback((element: HTMLElement | null) => {\n    if (elementRef.current === element) return;\n    elementRef.current = element;\n    sync();\n  }, [sync]);\n  const getHover = useCallback(() => hoverRef.current, []);\n\n  return useMemo(() => ({ getHover, canvasRef }), [getHover, canvasRef]);\n}\n"],"mappings":";;;;;;;;AA2BA,SAAgB,iBAAiB,MAA2C;CAC1E,MAAM,EAAE,mBAAmB,UAAU,SAAS;CAC9C,MAAM,WAAW,OAAsB,IAAI;CAC3C,MAAM,YAAY,UAAU,iBAAiB;CAC7C,MAAM,cAAc,UAAU,KAAK,QAAQ;CAC3C,MAAM,aAAa,OAA2B,IAAI;CAClD,MAAM,aAAa,OAAO,OAAO;CACjC,MAAM,YAAY,OAA4B,IAAI;CAElD,MAAM,QAAQ,aAAa,OAAsB;EAC/C,IAAI,SAAS,YAAY,IAAI;EAC7B,SAAS,UAAU;EACnB,YAAY,UAAU,EAAE;CAC1B,GAAG,CAAC,WAAW,CAAC;CAEhB,MAAM,OAAO,kBAAkB;EAC7B,UAAU,UAAU;EACpB,UAAU,UAAU;EACpB,MAAM,IAAI;EACV,MAAM,KAAK,WAAW;EACtB,IAAI,CAAC,MAAM,CAAC,WAAW,SAAS;EAChC,MAAM,UAAU,MAAoB,MAAM,UAAU,QAAQ,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM,IAAI;EAC7F,MAAM,gBAAgB,MAAM,IAAI;EAChC,GAAG,iBAAiB,eAAe,MAAM;EACzC,GAAG,iBAAiB,gBAAgB,OAAO;EAC3C,UAAU,gBAAgB;GACxB,GAAG,oBAAoB,eAAe,MAAM;GAC5C,GAAG,oBAAoB,gBAAgB,OAAO;EAChD;CACF,GAAG,CAAC,WAAW,KAAK,CAAC;CAErB,gBAAgB;EACd,WAAW,UAAU;EACrB,KAAK;EACL,aAAa;GACX,UAAU,UAAU;GACpB,UAAU,UAAU;GACpB,MAAM,IAAI;EACZ;CACF,GAAG;EAAC;EAAS;EAAM;CAAK,CAAC;CAEzB,MAAM,YAAY,aAAa,YAAgC;EAC7D,IAAI,WAAW,YAAY,SAAS;EACpC,WAAW,UAAU;EACrB,KAAK;CACP,GAAG,CAAC,IAAI,CAAC;CACT,MAAM,WAAW,kBAAkB,SAAS,SAAS,CAAC,CAAC;CAEvD,OAAO,eAAe;EAAE;EAAU;CAAU,IAAI,CAAC,UAAU,SAAS,CAAC;AACvE"}

package/dist/features/ingestion/contentHandlers.js

@@ -1,4 +1,5 @@
 import { dwarn } from "../../debug/flag.js";
+import { admitIngestMime } from "@weasel-js/routing";
 import { UNKNOWN_MIME, mimeMatchesGlob } from "@weasel-js/gestures";
 
 //#region src/features/ingestion/contentHandlers.ts
@@ -16,12 +17,34 @@ import { UNKNOWN_MIME, mimeMatchesGlob } from "@weasel-js/gestures";
 * matched can never disagree with the registry about what a glob means.
 */
 var HANDLERS = [];
+var RELEASES = /* @__PURE__ */ new Map();
+/** The exact MIMEs a handler names, for string flavors to be kept. A glob
+*  names no one flavor, and `application/octet-stream` is what an untyped
+*  file reports, never a string flavor anyone meant. */
+function namedMimes(entry) {
+	const named = [...typeof entry.match === "function" ? [] : [entry.match].flat(), ...entry.types ?? []];
+	return [...new Set(named)].filter((m) => !m.includes("*") && m !== "application/octet-stream");
+}
+function unregister(entry) {
+	const i = HANDLERS.indexOf(entry);
+	if (i < 0) return;
+	HANDLERS.splice(i, 1);
+	const releases = RELEASES.get(entry);
+	releases?.pop()?.();
+	if (releases?.length === 0) RELEASES.delete(entry);
+}
 /** Register a content handler. Returns a disposer that removes it. */
 function registerContentHandler(entry) {
 	HANDLERS.push(entry);
+	const admits = namedMimes(entry).map(admitIngestMime);
+	const releases = RELEASES.get(entry) ?? [];
+	releases.push(() => admits.forEach((release) => release()));
+	RELEASES.set(entry, releases);
+	let removed = false;
 	return () => {
-		const i = HANDLERS.indexOf(entry);
-		if (i >= 0) HANDLERS.splice(i, 1);
+		if (removed) return;
+		removed = true;
+		unregister(entry);
 	};
 }
 function byPriority(handlers) {

package/dist/features/ingestion/contentHandlers.js.map

@@ -1 +1 @@
-{"version":3,"file":"contentHandlers.js","names":[],"sources":["../../../src/features/ingestion/contentHandlers.ts"],"sourcesContent":["/**\n * Content-handler registry for external-content ingestion.\n *\n * All three arrival paths (OS drop, clipboard paste, file picker /\n * `CanvasExtensionApi.ingest`) converge here: `runIngest(items, ctx)`\n * partitions the items across registered handlers in priority order — the\n * first matching handler takes every item it matches; leftovers continue\n * down the list.\n *\n * MIME matching delegates to `mimeMatchesGlob` from `@weasel-js/gestures` —\n * the SAME matcher the binding-level `types` filter uses, so a binding that\n * matched can never disagree with the registry about what a glob means.\n */\nimport { mimeMatchesGlob, UNKNOWN_MIME } from '@weasel-js/gestures';\nimport { dwarn } from '../../debug';\nimport type { Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Op } from 'core/ops/types';\nimport type { ClipboardIngestCtx, InsertDep, SvgIngestOptions } from 'interactions/actions/depSchema';\nimport type { ActionDeps } from '@weasel-js/routing';\nimport type { IngestItem } from '@weasel-js/routing';\n\n/** Context handed to every content handler for one ingest event. */\nexport interface IngestCtx {\n  /** World-space arrival point (drop / pointed imperative ingest); `null`\n   *  for paste and point-less calls — handlers pick their own policy\n   *  (the kit image handler centers on the viewport). */\n  point: { x: number; y: number } | null;\n  /** Visible canvas area in world coordinates. */\n  viewportWorldRect(): { x: number; y: number; width: number; height: number };\n  /** The kit insert dep — id/layer/undoable-op supplied; the canonical way\n   *  for a handler to mint a node (`insert.commit(bounds, { kind, ... })`). */\n  insert: InsertDep;\n  /** Raw op commit for handlers that build their own ops. */\n  applyOps(ops: Op[], label?: string): void;\n  scene: Scene<unknown, string, unknown>;\n  selection: SelectionApi;\n  /** Consumer file→src resolver (SceneCanvas `ingestion.resolveSrc`).\n   *  When absent, the kit image handler embeds as a `data:` URI. */\n  resolveSrc?: (file: File) => Promise<string>;\n  /** Kit SVG-handler options (SceneCanvas `ingestion.svg`) — e.g.\n   *  `{ unpack: unpackSvgFiles }` (from `@weasel-js/svg`) to parse SVG files\n   *  into scene nodes. */\n  svg?: SvgIngestOptions;\n  /** Clipboard-paste seam — present when the hosting `SceneCanvas` supplied\n   *  an adapter with `commitPaste`. `reviver` comes from\n   *  `SceneCanvasProps.ingestion.clipboard`. Absent ⇒ the kit weasel-JSON\n   *  handler declines inert (dwarn, nothing ingested) — its matched items\n   *  were already consumed at match time, so they do NOT fall through;\n   *  only match-level misses flow on to other handlers. */\n  clipboard?: ClipboardIngestCtx;\n  /** Set to `true` by the kit weasel-JSON handler when it successfully\n   *  pastes a payload in this event. `kit:svg`'s `text/plain` SVG fallback\n   *  reads this to decline the SVG flavor of a copy whose weasel-JSON flavor\n   *  already ingested (avoids a double-paste when both flavors ride one\n   *  clipboard event). */\n  consumedWeaselPayload?: boolean;\n  /** Full action-deps bag, for consumer handlers that need more. */\n  deps: ActionDeps;\n}\n\n/** A handler for content arriving by paste, drop or file picker. Handlers are\n *  matched by MIME glob or predicate and run highest-priority first; the kit's\n *  own register at a low priority so a consumer's handler wins by default. */\nexport interface ContentHandlerEntry {\n  /** Stable identifier — used for unregistration and debugging\n   *  (`'kit:image'`, `'app:csv'`). */\n  id: string;\n  /** MIME glob(s) (`'image/*'`, `'text/csv'`) or an item predicate. */\n  match: string | string[] | ((item: IngestItem) => boolean);\n  /** For a predicate `match`: the MIME globs it could say yes to. A drag\n   *  still in flight shows its MIMEs and no contents, so a predicate cannot be\n   *  asked about it; this is what it is asked instead. Without it, no drag\n   *  can be refused while this handler is registered. */\n  types?: readonly string[];\n  /** Higher runs earlier. Kit defaults register at -100 so any consumer\n   *  handler (default 0) beats them. */\n  priority?: number;\n  handle(items: IngestItem[], ctx: IngestCtx): void | Promise<void>;\n}\n\nconst HANDLERS: ContentHandlerEntry[] = [];\n\n/** Register a content handler. Returns a disposer that removes it. */\nexport function registerContentHandler(entry: ContentHandlerEntry): () => void {\n  HANDLERS.push(entry);\n  return () => {\n    const i = HANDLERS.indexOf(entry);\n    if (i >= 0) HANDLERS.splice(i, 1);\n  };\n}\n\nfunction byPriority(handlers: readonly ContentHandlerEntry[]): ContentHandlerEntry[] {\n  return [...handlers].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));\n}\n\n/** Snapshot of registered handlers, priority-ordered (stable within ties —\n *  registration order; Array.prototype.sort is stable per ES2019). */\nexport function getContentHandlers(): readonly ContentHandlerEntry[] {\n  return byPriority(HANDLERS);\n}\n\n/** Options for {@link runIngest}. */\nexport interface RunIngestOptions {\n  /**\n   * The handlers to route through, in place of the registry. The registry is\n   * shared by every canvas on the page, so this is how one arrival path\n   * accepts a narrower set of content than the page has handlers for.\n   * Ordered by `priority` like registered handlers; an item none of them\n   * matches is ignored.\n   */\n  handlers?: readonly ContentHandlerEntry[];\n}\n\nfunction entryMatches(entry: ContentHandlerEntry, item: IngestItem): boolean {\n  const { match } = entry;\n  if (typeof match === 'function') {\n    try {\n      return match(item);\n    } catch (err) {\n      console.warn(`weasel ingest: handler \"${entry.id}\" match predicate threw`, err);\n      return false;\n    }\n  }\n  const globs = Array.isArray(match) ? match : [match];\n  return globs.some((g) => mimeMatchesGlob(item.mime, g));\n}\n\n/**\n * Whether some handler could claim one of `items`: the registry's, or\n * `handlers`. An item with contents is put to each handler's `match`. One\n * with a MIME alone, from a drag still in flight, is answered from the globs\n * and a predicate's declared `types`; it is never refused when its MIME is\n * `UNKNOWN_MIME`, or while a predicate handler declares no types.\n */\nexport function couldClaim(\n  items: readonly IngestItem[],\n  handlers: readonly ContentHandlerEntry[] = HANDLERS,\n): boolean {\n  return items.some((item) => {\n    if ((item as { kind?: string }).kind !== undefined) return handlers.some((h) => entryMatches(h, item));\n    if (item.mime === UNKNOWN_MIME) return true;\n    return handlers.some((h) => {\n      const globs = typeof h.match === 'function' ? h.types : [h.match].flat();\n      return globs === undefined || globs.some((g) => mimeMatchesGlob(item.mime, g));\n    });\n  });\n}\n\n/**\n * Route one ingest event's items through the registry. Handlers are queued\n * as microtasks in priority order and their async work then overlaps (each\n * already owns a disjoint item set); a throwing or rejecting handler\n * `console.warn`s and doesn't block the others. The queue order is a real\n * invariant: a higher-priority handler's `handle` body runs before lower\n * ones start, so ctx-flag coordination (e.g. `consumedWeaselPayload`)\n * works — but only while the writing handler stays synchronous up to the\n * write and the reading handler reads before its first `await`.\n * Unmatched items are ignored with a debug-gated `dwarn('ingest', ...)`.\n */\nexport async function runIngest(\n  items: IngestItem[],\n  ctx: IngestCtx,\n  opts: RunIngestOptions = {},\n): Promise<void> {\n  let remaining = items;\n  const runs: Promise<void>[] = [];\n  const handlers = opts.handlers ? byPriority(opts.handlers) : getContentHandlers();\n\n  for (const entry of handlers) {\n    if (remaining.length === 0) break;\n    const mine = remaining.filter((it) => entryMatches(entry, it));\n    if (mine.length === 0) continue;\n    remaining = remaining.filter((it) => !mine.includes(it));\n    runs.push(\n      Promise.resolve()\n        .then(() => entry.handle(mine, ctx))\n        .catch((err) => {\n          console.warn(`weasel ingest: handler \"${entry.id}\" threw`, err);\n        }),\n    );\n  }\n\n  if (remaining.length > 0) {\n    dwarn(\n      'ingest',\n      `no content handler matched ${remaining.length} item(s):`,\n      remaining.map((it) => it.mime).join(', '),\n    );\n  }\n\n  await Promise.all(runs);\n}\n\n/** @internal test seam — clear the registry. Not part of the public barrel. */\nexport function _resetContentHandlersForTests(): void {\n  HANDLERS.length = 0;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAiFA,IAAM,WAAkC,CAAC;;AAGzC,SAAgB,uBAAuB,OAAwC;CAC7E,SAAS,KAAK,KAAK;CACnB,aAAa;EACX,MAAM,IAAI,SAAS,QAAQ,KAAK;EAChC,IAAI,KAAK,GAAG,SAAS,OAAO,GAAG,CAAC;CAClC;AACF;AAEA,SAAS,WAAW,UAAiE;CACnF,OAAO,CAAC,GAAG,QAAQ,CAAC,CAAC,MAAM,GAAG,OAAO,EAAE,YAAY,MAAM,EAAE,YAAY,EAAE;AAC3E;;;AAIA,SAAgB,qBAAqD;CACnE,OAAO,WAAW,QAAQ;AAC5B;AAcA,SAAS,aAAa,OAA4B,MAA2B;CAC3E,MAAM,EAAE,UAAU;CAClB,IAAI,OAAO,UAAU,YACnB,IAAI;EACF,OAAO,MAAM,IAAI;CACnB,SAAS,KAAK;EACZ,QAAQ,KAAK,2BAA2B,MAAM,GAAG,0BAA0B,GAAG;EAC9E,OAAO;CACT;CAGF,QADc,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK,EAC5C,CAAM,MAAM,MAAM,gBAAgB,KAAK,MAAM,CAAC,CAAC;AACxD;;;;;;;;AASA,SAAgB,WACd,OACA,WAA2C,UAClC;CACT,OAAO,MAAM,MAAM,SAAS;EAC1B,IAAK,KAA2B,SAAS,QAAW,OAAO,SAAS,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC;EACrG,IAAI,KAAK,SAAS,cAAc,OAAO;EACvC,OAAO,SAAS,MAAM,MAAM;GAC1B,MAAM,QAAQ,OAAO,EAAE,UAAU,aAAa,EAAE,QAAQ,CAAC,EAAE,KAAK,CAAC,CAAC,KAAK;GACvE,OAAO,UAAU,UAAa,MAAM,MAAM,MAAM,gBAAgB,KAAK,MAAM,CAAC,CAAC;EAC/E,CAAC;CACH,CAAC;AACH;;;;;;;;;;;;AAaA,eAAsB,UACpB,OACA,KACA,OAAyB,CAAC,GACX;CACf,IAAI,YAAY;CAChB,MAAM,OAAwB,CAAC;CAC/B,MAAM,WAAW,KAAK,WAAW,WAAW,KAAK,QAAQ,IAAI,mBAAmB;CAEhF,KAAK,MAAM,SAAS,UAAU;EAC5B,IAAI,UAAU,WAAW,GAAG;EAC5B,MAAM,OAAO,UAAU,QAAQ,OAAO,aAAa,OAAO,EAAE,CAAC;EAC7D,IAAI,KAAK,WAAW,GAAG;EACvB,YAAY,UAAU,QAAQ,OAAO,CAAC,KAAK,SAAS,EAAE,CAAC;EACvD,KAAK,KACH,QAAQ,QAAQ,CAAC,CACd,WAAW,MAAM,OAAO,MAAM,GAAG,CAAC,CAAC,CACnC,OAAO,QAAQ;GACd,QAAQ,KAAK,2BAA2B,MAAM,GAAG,UAAU,GAAG;EAChE,CAAC,CACL;CACF;CAEA,IAAI,UAAU,SAAS,GACrB,MACE,UACA,8BAA8B,UAAU,OAAO,YAC/C,UAAU,KAAK,OAAO,GAAG,IAAI,CAAC,CAAC,KAAK,IAAI,CAC1C;CAGF,MAAM,QAAQ,IAAI,IAAI;AACxB"}
+{"version":3,"file":"contentHandlers.js","names":[],"sources":["../../../src/features/ingestion/contentHandlers.ts"],"sourcesContent":["/**\n * Content-handler registry for external-content ingestion.\n *\n * All three arrival paths (OS drop, clipboard paste, file picker /\n * `CanvasExtensionApi.ingest`) converge here: `runIngest(items, ctx)`\n * partitions the items across registered handlers in priority order — the\n * first matching handler takes every item it matches; leftovers continue\n * down the list.\n *\n * MIME matching delegates to `mimeMatchesGlob` from `@weasel-js/gestures` —\n * the SAME matcher the binding-level `types` filter uses, so a binding that\n * matched can never disagree with the registry about what a glob means.\n */\nimport { mimeMatchesGlob, UNKNOWN_MIME } from '@weasel-js/gestures';\nimport { dwarn } from '../../debug';\nimport type { Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Op } from 'core/ops/types';\nimport type { ClipboardIngestCtx, InsertDep, SnapDep, SvgIngestOptions } from 'interactions/actions/depSchema';\nimport { admitIngestMime, type ActionDeps, type IngestItem } from '@weasel-js/routing';\n\n/** Context handed to every content handler for one ingest event. */\nexport interface IngestCtx {\n  /** World-space arrival point (drop / pointed imperative ingest); `null`\n   *  for paste and point-less calls — handlers pick their own policy\n   *  (the kit image handler centers on the viewport). */\n  point: { x: number; y: number } | null;\n  /** Visible canvas area in world coordinates. */\n  viewportWorldRect(): { x: number; y: number; width: number; height: number };\n  /** The kit insert dep — id/layer/undoable-op supplied; the canonical way\n   *  for a handler to mint a node (`insert.commit(bounds, { kind, ... })`). */\n  insert: InsertDep;\n  /** The canvas's snap dep, for a handler that places what it inserts where a\n   *  gesture would: begin a session, take `at()`, `end()`. Its points are ctx\n   *  coordinates: world on a 2D canvas, screen in a 3D host. */\n  snap?: SnapDep;\n  /** Raw op commit for handlers that build their own ops. */\n  applyOps(ops: Op[], label?: string): void;\n  scene: Scene<unknown, string, unknown>;\n  selection: SelectionApi;\n  /** Consumer file→src resolver (SceneCanvas `ingestion.resolveSrc`).\n   *  When absent, the kit image handler embeds as a `data:` URI. */\n  resolveSrc?: (file: File) => Promise<string>;\n  /** Kit SVG-handler options (SceneCanvas `ingestion.svg`) — e.g.\n   *  `{ unpack: unpackSvgFiles }` (from `@weasel-js/svg`) to parse SVG files\n   *  into scene nodes. */\n  svg?: SvgIngestOptions;\n  /** Clipboard-paste seam — present when the hosting `SceneCanvas` supplied\n   *  an adapter with `commitPaste`. `reviver` comes from\n   *  `SceneCanvasProps.ingestion.clipboard`. Absent ⇒ the kit weasel-JSON\n   *  handler declines inert (dwarn, nothing ingested) — its matched items\n   *  were already consumed at match time, so they do NOT fall through;\n   *  only match-level misses flow on to other handlers. */\n  clipboard?: ClipboardIngestCtx;\n  /** Set to `true` by the kit weasel-JSON handler when it successfully\n   *  pastes a payload in this event. `kit:svg`'s `text/plain` SVG fallback\n   *  reads this to decline the SVG flavor of a copy whose weasel-JSON flavor\n   *  already ingested (avoids a double-paste when both flavors ride one\n   *  clipboard event). */\n  consumedWeaselPayload?: boolean;\n  /** Full action-deps bag, for consumer handlers that need more. */\n  deps: ActionDeps;\n}\n\n/** A handler for content arriving by paste, drop or file picker. Handlers are\n *  matched by MIME glob or predicate and run highest-priority first; the kit's\n *  own register at a low priority so a consumer's handler wins by default. */\nexport interface ContentHandlerEntry {\n  /** Stable identifier — used for unregistration and debugging\n   *  (`'kit:image'`, `'app:csv'`). */\n  id: string;\n  /** MIME glob(s) (`'image/*'`, `'text/csv'`) or an item predicate. A drop\n   *  or paste keeps string flavors of any exact MIME named here or in\n   *  `types` while the handler is registered, so a handler can claim a drag\n   *  from the app's own UI by a type of its own. */\n  match: string | string[] | ((item: IngestItem) => boolean);\n  /** For a predicate `match`: the MIME globs it could say yes to. A drag\n   *  still in flight shows its MIMEs and no contents, so a predicate cannot be\n   *  asked about it; this is what it is asked instead. Without it, no drag\n   *  can be refused while this handler is registered. */\n  types?: readonly string[];\n  /** Higher runs earlier. Kit defaults register at -100 so any consumer\n   *  handler (default 0) beats them. */\n  priority?: number;\n  handle(items: IngestItem[], ctx: IngestCtx): void | Promise<void>;\n}\n\nconst HANDLERS: ContentHandlerEntry[] = [];\nconst RELEASES = new Map<ContentHandlerEntry, (() => void)[]>();\n\n/** The exact MIMEs a handler names, for string flavors to be kept. A glob\n *  names no one flavor, and `application/octet-stream` is what an untyped\n *  file reports, never a string flavor anyone meant. */\nfunction namedMimes(entry: ContentHandlerEntry): string[] {\n  const named = [...(typeof entry.match === 'function' ? [] : [entry.match].flat()), ...(entry.types ?? [])];\n  return [...new Set(named)].filter((m) => !m.includes('*') && m !== 'application/octet-stream');\n}\n\nfunction unregister(entry: ContentHandlerEntry): void {\n  const i = HANDLERS.indexOf(entry);\n  if (i < 0) return;\n  HANDLERS.splice(i, 1);\n  // The same entry may be registered more than once; each registration admitted once.\n  const releases = RELEASES.get(entry);\n  releases?.pop()?.();\n  if (releases?.length === 0) RELEASES.delete(entry);\n}\n\n/** Register a content handler. Returns a disposer that removes it. */\nexport function registerContentHandler(entry: ContentHandlerEntry): () => void {\n  HANDLERS.push(entry);\n  const admits = namedMimes(entry).map(admitIngestMime);\n  const releases = RELEASES.get(entry) ?? [];\n  releases.push(() => admits.forEach((release) => release()));\n  RELEASES.set(entry, releases);\n  let removed = false;\n  return () => {\n    if (removed) return;\n    removed = true;\n    unregister(entry);\n  };\n}\n\nfunction byPriority(handlers: readonly ContentHandlerEntry[]): ContentHandlerEntry[] {\n  return [...handlers].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));\n}\n\n/** Snapshot of registered handlers, priority-ordered (stable within ties —\n *  registration order; Array.prototype.sort is stable per ES2019). */\nexport function getContentHandlers(): readonly ContentHandlerEntry[] {\n  return byPriority(HANDLERS);\n}\n\n/** Options for {@link runIngest}. */\nexport interface RunIngestOptions {\n  /**\n   * The handlers to route through, in place of the registry. The registry is\n   * shared by every canvas on the page, so this is how one arrival path\n   * accepts a narrower set of content than the page has handlers for.\n   * Ordered by `priority` like registered handlers; an item none of them\n   * matches is ignored.\n   */\n  handlers?: readonly ContentHandlerEntry[];\n}\n\nfunction entryMatches(entry: ContentHandlerEntry, item: IngestItem): boolean {\n  const { match } = entry;\n  if (typeof match === 'function') {\n    try {\n      return match(item);\n    } catch (err) {\n      console.warn(`weasel ingest: handler \"${entry.id}\" match predicate threw`, err);\n      return false;\n    }\n  }\n  const globs = Array.isArray(match) ? match : [match];\n  return globs.some((g) => mimeMatchesGlob(item.mime, g));\n}\n\n/**\n * Whether some handler could claim one of `items`: the registry's, or\n * `handlers`. An item with contents is put to each handler's `match`. One\n * with a MIME alone, from a drag still in flight, is answered from the globs\n * and a predicate's declared `types`; it is never refused when its MIME is\n * `UNKNOWN_MIME`, or while a predicate handler declares no types.\n */\nexport function couldClaim(\n  items: readonly IngestItem[],\n  handlers: readonly ContentHandlerEntry[] = HANDLERS,\n): boolean {\n  return items.some((item) => {\n    if ((item as { kind?: string }).kind !== undefined) return handlers.some((h) => entryMatches(h, item));\n    if (item.mime === UNKNOWN_MIME) return true;\n    return handlers.some((h) => {\n      const globs = typeof h.match === 'function' ? h.types : [h.match].flat();\n      return globs === undefined || globs.some((g) => mimeMatchesGlob(item.mime, g));\n    });\n  });\n}\n\n/**\n * Route one ingest event's items through the registry. Handlers are queued\n * as microtasks in priority order and their async work then overlaps (each\n * already owns a disjoint item set); a throwing or rejecting handler\n * `console.warn`s and doesn't block the others. The queue order is a real\n * invariant: a higher-priority handler's `handle` body runs before lower\n * ones start, so ctx-flag coordination (e.g. `consumedWeaselPayload`)\n * works — but only while the writing handler stays synchronous up to the\n * write and the reading handler reads before its first `await`.\n * Unmatched items are ignored with a debug-gated `dwarn('ingest', ...)`.\n */\nexport async function runIngest(\n  items: IngestItem[],\n  ctx: IngestCtx,\n  opts: RunIngestOptions = {},\n): Promise<void> {\n  let remaining = items;\n  const runs: Promise<void>[] = [];\n  const handlers = opts.handlers ? byPriority(opts.handlers) : getContentHandlers();\n\n  for (const entry of handlers) {\n    if (remaining.length === 0) break;\n    const mine = remaining.filter((it) => entryMatches(entry, it));\n    if (mine.length === 0) continue;\n    remaining = remaining.filter((it) => !mine.includes(it));\n    runs.push(\n      Promise.resolve()\n        .then(() => entry.handle(mine, ctx))\n        .catch((err) => {\n          console.warn(`weasel ingest: handler \"${entry.id}\" threw`, err);\n        }),\n    );\n  }\n\n  if (remaining.length > 0) {\n    dwarn(\n      'ingest',\n      `no content handler matched ${remaining.length} item(s):`,\n      remaining.map((it) => it.mime).join(', '),\n    );\n  }\n\n  await Promise.all(runs);\n}\n\n/** @internal test seam — clear the registry. Not part of the public barrel. */\nexport function _resetContentHandlersForTests(): void {\n  while (HANDLERS.length > 0) unregister(HANDLERS[0]!);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAuFA,IAAM,WAAkC,CAAC;AACzC,IAAM,2BAAW,IAAI,IAAyC;;;;AAK9D,SAAS,WAAW,OAAsC;CACxD,MAAM,QAAQ,CAAC,GAAI,OAAO,MAAM,UAAU,aAAa,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,KAAK,GAAI,GAAI,MAAM,SAAS,CAAC,CAAE;CACzG,OAAO,CAAC,GAAG,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,QAAQ,MAAM,CAAC,EAAE,SAAS,GAAG,KAAK,MAAM,0BAA0B;AAC/F;AAEA,SAAS,WAAW,OAAkC;CACpD,MAAM,IAAI,SAAS,QAAQ,KAAK;CAChC,IAAI,IAAI,GAAG;CACX,SAAS,OAAO,GAAG,CAAC;CAEpB,MAAM,WAAW,SAAS,IAAI,KAAK;CACnC,UAAU,IAAI,CAAC,GAAG;CAClB,IAAI,UAAU,WAAW,GAAG,SAAS,OAAO,KAAK;AACnD;;AAGA,SAAgB,uBAAuB,OAAwC;CAC7E,SAAS,KAAK,KAAK;CACnB,MAAM,SAAS,WAAW,KAAK,CAAC,CAAC,IAAI,eAAe;CACpD,MAAM,WAAW,SAAS,IAAI,KAAK,KAAK,CAAC;CACzC,SAAS,WAAW,OAAO,SAAS,YAAY,QAAQ,CAAC,CAAC;CAC1D,SAAS,IAAI,OAAO,QAAQ;CAC5B,IAAI,UAAU;CACd,aAAa;EACX,IAAI,SAAS;EACb,UAAU;EACV,WAAW,KAAK;CAClB;AACF;AAEA,SAAS,WAAW,UAAiE;CACnF,OAAO,CAAC,GAAG,QAAQ,CAAC,CAAC,MAAM,GAAG,OAAO,EAAE,YAAY,MAAM,EAAE,YAAY,EAAE;AAC3E;;;AAIA,SAAgB,qBAAqD;CACnE,OAAO,WAAW,QAAQ;AAC5B;AAcA,SAAS,aAAa,OAA4B,MAA2B;CAC3E,MAAM,EAAE,UAAU;CAClB,IAAI,OAAO,UAAU,YACnB,IAAI;EACF,OAAO,MAAM,IAAI;CACnB,SAAS,KAAK;EACZ,QAAQ,KAAK,2BAA2B,MAAM,GAAG,0BAA0B,GAAG;EAC9E,OAAO;CACT;CAGF,QADc,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK,EAC5C,CAAM,MAAM,MAAM,gBAAgB,KAAK,MAAM,CAAC,CAAC;AACxD;;;;;;;;AASA,SAAgB,WACd,OACA,WAA2C,UAClC;CACT,OAAO,MAAM,MAAM,SAAS;EAC1B,IAAK,KAA2B,SAAS,QAAW,OAAO,SAAS,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC;EACrG,IAAI,KAAK,SAAS,cAAc,OAAO;EACvC,OAAO,SAAS,MAAM,MAAM;GAC1B,MAAM,QAAQ,OAAO,EAAE,UAAU,aAAa,EAAE,QAAQ,CAAC,EAAE,KAAK,CAAC,CAAC,KAAK;GACvE,OAAO,UAAU,UAAa,MAAM,MAAM,MAAM,gBAAgB,KAAK,MAAM,CAAC,CAAC;EAC/E,CAAC;CACH,CAAC;AACH;;;;;;;;;;;;AAaA,eAAsB,UACpB,OACA,KACA,OAAyB,CAAC,GACX;CACf,IAAI,YAAY;CAChB,MAAM,OAAwB,CAAC;CAC/B,MAAM,WAAW,KAAK,WAAW,WAAW,KAAK,QAAQ,IAAI,mBAAmB;CAEhF,KAAK,MAAM,SAAS,UAAU;EAC5B,IAAI,UAAU,WAAW,GAAG;EAC5B,MAAM,OAAO,UAAU,QAAQ,OAAO,aAAa,OAAO,EAAE,CAAC;EAC7D,IAAI,KAAK,WAAW,GAAG;EACvB,YAAY,UAAU,QAAQ,OAAO,CAAC,KAAK,SAAS,EAAE,CAAC;EACvD,KAAK,KACH,QAAQ,QAAQ,CAAC,CACd,WAAW,MAAM,OAAO,MAAM,GAAG,CAAC,CAAC,CACnC,OAAO,QAAQ;GACd,QAAQ,KAAK,2BAA2B,MAAM,GAAG,UAAU,GAAG;EAChE,CAAC,CACL;CACF;CAEA,IAAI,UAAU,SAAS,GACrB,MACE,UACA,8BAA8B,UAAU,OAAO,YAC/C,UAAU,KAAK,OAAO,GAAG,IAAI,CAAC,CAAC,KAAK,IAAI,CAC1C;CAGF,MAAM,QAAQ,IAAI,IAAI;AACxB"}