@weasel-js/core 1.11.0 → 1.12.0

package/dist/devtools/handlers.js

@@ -0,0 +1,112 @@
+import { serialize } from "./serialize.js";
+import { historySlice } from "./history.js";
+
+//#region src/devtools/handlers.ts
+function sceneOf(root) {
+	const scene = root.source.scene();
+	if (!scene) throw new Error("scene not mounted yet");
+	return scene;
+}
+function summaryOf(node) {
+	return {
+		id: node.id,
+		kind: node.kind,
+		layer: node.layer,
+		childCount: node.kind === "container" ? node.children.length : 0,
+		hidden: node.hidden === true,
+		locked: node.locked === true,
+		pickable: node.pickable !== false
+	};
+}
+function nodeOf(scene, id) {
+	const node = scene.get(id);
+	if (!node) throw new Error(`no node "${id}"`);
+	return node;
+}
+function childrenOf(root, nodeId) {
+	const scene = sceneOf(root);
+	return (nodeId === void 0 ? scene.roots : (nodeOf(scene, nodeId), scene.childrenOf(nodeId))).map((id) => summaryOf(nodeOf(scene, id)));
+}
+function nodeDetail(root, nodeId) {
+	const node = nodeOf(sceneOf(root), nodeId);
+	return {
+		...summaryOf(node),
+		parent: node.parent ?? null,
+		pose: serialize(node.pose),
+		data: serialize(node.data)
+	};
+}
+/** The on/off features of a debug config, leaving out its theme and strokes. */
+function overlayFlags(config) {
+	const flags = {};
+	if (!config) return flags;
+	for (const [key, value] of Object.entries(config)) if (typeof value === "boolean") flags[key] = value;
+	return flags;
+}
+function rootState(root) {
+	const { source } = root;
+	const probes = {};
+	for (const [name, read] of root.probes) try {
+		probes[name] = serialize(read());
+	} catch (err) {
+		probes[name] = `[threw: ${err.message}]`;
+	}
+	return {
+		selection: [...source.selection()],
+		view: serialize(source.view()),
+		activeTool: source.activeTool(),
+		tools: [...source.tools()],
+		overlays: overlayFlags(source.overlays()),
+		probes
+	};
+}
+/** Trace records are plain data by contract, and nest deeper than a node's data is shown. */
+var RECORD = { depth: 12 };
+function traceSlice(root, cursor, coordCursor) {
+	const { trace, coords } = root.source;
+	const slice = trace.since(cursor);
+	const out = {
+		entries: slice.entries.map((e) => serialize(e, RECORD)),
+		cursor: slice.cursor,
+		live: serialize(trace.live(), RECORD)
+	};
+	if (coordCursor !== void 0) {
+		const c = coords.since(coordCursor);
+		out.coords = {
+			entries: c.entries.map((e) => serialize(e, RECORD)),
+			cursor: c.cursor
+		};
+	}
+	return out;
+}
+/** Answer `req` about `root`. `steer` lays a change over the panel's override. Throws on a bad request. */
+function answer(root, req, steer) {
+	switch (req.type) {
+		case "get-children": return childrenOf(root, req.nodeId);
+		case "get-node": return nodeDetail(root, req.nodeId);
+		case "get-state": return rootState(root);
+		case "get-trace": return traceSlice(root, req.cursor, req.coordCursor);
+		case "get-frame": return serialize(root.source.frame());
+		case "get-registry":
+			if (!root.source.registry) throw new Error("this root serves no registry");
+			return root.source.registry();
+		case "get-history": return historySlice(root, req.cursor, req.checkpoints);
+		case "select":
+			root.source.select(req.ids);
+			return null;
+		case "set-tool":
+			if (req.toolId !== null && !root.source.tools().includes(req.toolId)) throw new Error(`no tool "${req.toolId}"`);
+			root.source.setTool(req.toolId);
+			return null;
+		case "highlight":
+			steer({ highlight: [...req.ids] });
+			return null;
+		case "set-overlays":
+			steer({ overlays: req.overlays });
+			return null;
+	}
+}
+
+//#endregion
+export { answer, childrenOf, nodeDetail, overlayFlags, rootState, traceSlice };
+//# sourceMappingURL=handlers.js.map

package/dist/devtools/handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.js","names":[],"sources":["../../src/devtools/handlers.ts"],"sourcesContent":["/** The answer to each devtools request, for one root. The session owns the override a steering request changes. */\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport type { DebugConfig } from '../debug/types';\nimport type { DevtoolsRoot } from './root';\nimport type {\n  DevtoolsNodeDetail, DevtoolsNodeSummary, DevtoolsOverlays, DevtoolsRequest, DevtoolsResult,\n  DevtoolsRootState, DevtoolsTraceSlice,\n} from './protocol';\nimport { serialize } from './serialize';\nimport { historySlice } from './history';\n\ntype AnyScene = Scene<unknown, string, unknown>;\ntype AnyNode = Node<unknown, string, unknown>;\n\nfunction sceneOf(root: DevtoolsRoot): AnyScene {\n  const scene = root.source.scene();\n  if (!scene) throw new Error('scene not mounted yet');\n  return scene;\n}\n\nfunction summaryOf(node: AnyNode): DevtoolsNodeSummary {\n  return {\n    id: node.id,\n    kind: node.kind,\n    layer: node.layer,\n    childCount: node.kind === 'container' ? node.children.length : 0,\n    hidden: node.hidden === true,\n    locked: node.locked === true,\n    pickable: node.pickable !== false,\n  };\n}\n\nfunction nodeOf(scene: AnyScene, id: string): AnyNode {\n  const node = scene.get(id as NodeId);\n  if (!node) throw new Error(`no node \"${id}\"`);\n  return node;\n}\n\nexport function childrenOf(root: DevtoolsRoot, nodeId: string | undefined): DevtoolsNodeSummary[] {\n  const scene = sceneOf(root);\n  const ids = nodeId === undefined ? scene.roots : (nodeOf(scene, nodeId), scene.childrenOf(nodeId as NodeId));\n  return ids.map((id) => summaryOf(nodeOf(scene, id)));\n}\n\nexport function nodeDetail(root: DevtoolsRoot, nodeId: string): DevtoolsNodeDetail {\n  const node = nodeOf(sceneOf(root), nodeId);\n  return {\n    ...summaryOf(node),\n    parent: node.parent ?? null,\n    pose: serialize(node.pose),\n    data: serialize(node.data),\n  };\n}\n\n/** The on/off features of a debug config, leaving out its theme and strokes. */\nexport function overlayFlags(config: DebugConfig | null): DevtoolsOverlays {\n  const flags: DevtoolsOverlays = {};\n  if (!config) return flags;\n  for (const [key, value] of Object.entries(config)) {\n    if (typeof value === 'boolean') (flags as Record<string, boolean>)[key] = value;\n  }\n  return flags;\n}\n\nexport function rootState(root: DevtoolsRoot): DevtoolsRootState {\n  const { source } = root;\n  const probes: DevtoolsRootState['probes'] = {};\n  for (const [name, read] of root.probes) {\n    try {\n      probes[name] = serialize(read());\n    } catch (err) {\n      probes[name] = `[threw: ${(err as Error).message}]`;\n    }\n  }\n  return {\n    selection: [...source.selection()],\n    view: serialize(source.view()),\n    activeTool: source.activeTool(),\n    tools: [...source.tools()],\n    overlays: overlayFlags(source.overlays()),\n    probes,\n  };\n}\n\n/** Trace records are plain data by contract, and nest deeper than a node's data is shown. */\nconst RECORD = { depth: 12 };\n\nexport function traceSlice(root: DevtoolsRoot, cursor: number, coordCursor: number | undefined): DevtoolsTraceSlice {\n  const { trace, coords } = root.source;\n  const slice = trace.since(cursor);\n  const out: DevtoolsTraceSlice = {\n    entries: slice.entries.map((e) => serialize(e, RECORD)),\n    cursor: slice.cursor,\n    live: serialize(trace.live(), RECORD),\n  };\n  if (coordCursor !== undefined) {\n    const c = coords.since(coordCursor);\n    out.coords = { entries: c.entries.map((e) => serialize(e, RECORD)), cursor: c.cursor };\n  }\n  return out;\n}\n\n/** Answer `req` about `root`. `steer` lays a change over the panel's override. Throws on a bad request. */\nexport function answer(\n  root: DevtoolsRoot,\n  req: DevtoolsRequest,\n  steer: (change: { overlays?: DevtoolsOverlays; highlight?: readonly string[] }) => void,\n): DevtoolsResult {\n  switch (req.type) {\n    case 'get-children': return childrenOf(root, req.nodeId);\n    case 'get-node': return nodeDetail(root, req.nodeId);\n    case 'get-state': return rootState(root);\n    case 'get-trace': return traceSlice(root, req.cursor, req.coordCursor);\n    case 'get-frame': return serialize(root.source.frame());\n    case 'get-registry':\n      if (!root.source.registry) throw new Error('this root serves no registry');\n      return root.source.registry();\n    case 'get-history': return historySlice(root, req.cursor, req.checkpoints);\n    case 'select':\n      root.source.select(req.ids);\n      return null;\n    case 'set-tool':\n      if (req.toolId !== null && !root.source.tools().includes(req.toolId)) throw new Error(`no tool \"${req.toolId}\"`);\n      root.source.setTool(req.toolId);\n      return null;\n    case 'highlight':\n      steer({ highlight: [...req.ids] });\n      return null;\n    case 'set-overlays':\n      steer({ overlays: req.overlays });\n      return null;\n  }\n}\n"],"mappings":"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"}

package/dist/devtools/history.js

@@ -0,0 +1,71 @@
+import { serialize } from "./serialize.js";
+import { touchedIdsFromOps } from "@weasel-js/history";
+
+//#region src/devtools/history.ts
+/** A scene's history steps as the devtools hook keeps them: one plain record per step, in a rolling ring. */
+/** How much of one step a record keeps: a jump can walk the whole stack, and a batch can hold any number of ops. */
+var HISTORY_RECORD_LIMITS = {
+	entries: 50,
+	ops: 50
+};
+var SUMMARY = {
+	depth: 4,
+	items: 20,
+	chars: 200
+};
+function opOf(op) {
+	return {
+		kind: op.name ?? "?",
+		targets: [...touchedIdsFromOps([op])],
+		summary: serialize(op.args, SUMMARY)
+	};
+}
+function recordOf(step, history) {
+	const index = history.undoDepth();
+	return {
+		ts: Date.now(),
+		step: step.kind,
+		entries: step.entries.slice(0, HISTORY_RECORD_LIMITS.entries).map((e) => ({
+			id: e.id,
+			label: e.label,
+			opCount: e.ops.length,
+			ops: e.ops.slice(0, HISTORY_RECORD_LIMITS.ops).map(opOf)
+		})),
+		position: {
+			index,
+			total: index + history.redoDepth()
+		}
+	};
+}
+/** Push a record of each step `history` takes into `ring`, while the ring is recording. Returns the stop. */
+function recordHistory(history, ring) {
+	return history.observe((step) => {
+		if (ring.recording()) ring.push(recordOf(step, history));
+	});
+}
+function historySlice(root, cursor, checkpoints) {
+	const ring = root.source.history;
+	const scene = root.source.scene();
+	if (!ring || !scene) throw new Error("no history to read");
+	const slice = ring.since(cursor);
+	const index = scene.history.undoDepth();
+	const out = {
+		entries: slice.entries,
+		cursor: slice.cursor,
+		position: {
+			index,
+			total: index + scene.history.redoDepth(),
+			canUndo: scene.canUndo(),
+			canRedo: scene.canRedo()
+		}
+	};
+	if (checkpoints) out.checkpoints = scene.historyEntries().map((e) => ({
+		id: e.id,
+		label: e.label
+	}));
+	return out;
+}
+
+//#endregion
+export { HISTORY_RECORD_LIMITS, historySlice, recordHistory };
+//# sourceMappingURL=history.js.map

package/dist/devtools/history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.js","names":[],"sources":["../../src/devtools/history.ts"],"sourcesContent":["/** A scene's history steps as the devtools hook keeps them: one plain record per step, in a rolling ring. */\nimport { touchedIdsFromOps, type History, type HistoryStep } from '@weasel-js/history';\nimport type { TraceRing } from '@weasel-js/routing';\nimport type { DevtoolsHistoryOp, DevtoolsHistoryRecord, DevtoolsHistorySlice } from './protocol';\nimport type { DevtoolsRoot } from './root';\nimport { serialize } from './serialize';\n\n/** How much of one step a record keeps: a jump can walk the whole stack, and a batch can hold any number of ops. */\nexport const HISTORY_RECORD_LIMITS = { entries: 50, ops: 50 };\n\nconst SUMMARY = { depth: 4, items: 20, chars: 200 };\n\nfunction opOf(op: HistoryStep['entries'][number]['ops'][number]): DevtoolsHistoryOp {\n  return { kind: op.name ?? '?', targets: [...touchedIdsFromOps([op])], summary: serialize(op.args, SUMMARY) };\n}\n\nfunction recordOf(step: HistoryStep, history: Pick<History, 'undoDepth' | 'redoDepth'>): DevtoolsHistoryRecord {\n  const index = history.undoDepth();\n  return {\n    ts: Date.now(),\n    step: step.kind,\n    entries: step.entries.slice(0, HISTORY_RECORD_LIMITS.entries).map((e) => ({\n      id: e.id,\n      label: e.label,\n      opCount: e.ops.length,\n      ops: e.ops.slice(0, HISTORY_RECORD_LIMITS.ops).map(opOf),\n    })),\n    position: { index, total: index + history.redoDepth() },\n  };\n}\n\n/** Push a record of each step `history` takes into `ring`, while the ring is recording. Returns the stop. */\nexport function recordHistory(history: History, ring: TraceRing<DevtoolsHistoryRecord>): () => void {\n  return history.observe((step) => {\n    if (ring.recording()) ring.push(recordOf(step, history));\n  });\n}\n\nexport function historySlice(root: DevtoolsRoot, cursor: number, checkpoints: boolean | undefined): DevtoolsHistorySlice {\n  const ring = root.source.history;\n  const scene = root.source.scene();\n  if (!ring || !scene) throw new Error('no history to read');\n  const slice = ring.since(cursor);\n  const index = scene.history.undoDepth();\n  const out: DevtoolsHistorySlice = {\n    entries: slice.entries,\n    cursor: slice.cursor,\n    position: { index, total: index + scene.history.redoDepth(), canUndo: scene.canUndo(), canRedo: scene.canRedo() },\n  };\n  if (checkpoints) out.checkpoints = scene.historyEntries().map((e) => ({ id: e.id, label: e.label }));\n  return out;\n}\n"],"mappings":";;;;;;AAQA,IAAa,wBAAwB;CAAE,SAAS;CAAI,KAAK;AAAG;AAE5D,IAAM,UAAU;CAAE,OAAO;CAAG,OAAO;CAAI,OAAO;AAAI;AAElD,SAAS,KAAK,IAAsE;CAClF,OAAO;EAAE,MAAM,GAAG,QAAQ;EAAK,SAAS,CAAC,GAAG,kBAAkB,CAAC,EAAE,CAAC,CAAC;EAAG,SAAS,UAAU,GAAG,MAAM,OAAO;CAAE;AAC7G;AAEA,SAAS,SAAS,MAAmB,SAA0E;CAC7G,MAAM,QAAQ,QAAQ,UAAU;CAChC,OAAO;EACL,IAAI,KAAK,IAAI;EACb,MAAM,KAAK;EACX,SAAS,KAAK,QAAQ,MAAM,GAAG,sBAAsB,OAAO,CAAC,CAAC,KAAK,OAAO;GACxE,IAAI,EAAE;GACN,OAAO,EAAE;GACT,SAAS,EAAE,IAAI;GACf,KAAK,EAAE,IAAI,MAAM,GAAG,sBAAsB,GAAG,CAAC,CAAC,IAAI,IAAI;EACzD,EAAE;EACF,UAAU;GAAE;GAAO,OAAO,QAAQ,QAAQ,UAAU;EAAE;CACxD;AACF;;AAGA,SAAgB,cAAc,SAAkB,MAAoD;CAClG,OAAO,QAAQ,SAAS,SAAS;EAC/B,IAAI,KAAK,UAAU,GAAG,KAAK,KAAK,SAAS,MAAM,OAAO,CAAC;CACzD,CAAC;AACH;AAEA,SAAgB,aAAa,MAAoB,QAAgB,aAAwD;CACvH,MAAM,OAAO,KAAK,OAAO;CACzB,MAAM,QAAQ,KAAK,OAAO,MAAM;CAChC,IAAI,CAAC,QAAQ,CAAC,OAAO,MAAM,IAAI,MAAM,oBAAoB;CACzD,MAAM,QAAQ,KAAK,MAAM,MAAM;CAC/B,MAAM,QAAQ,MAAM,QAAQ,UAAU;CACtC,MAAM,MAA4B;EAChC,SAAS,MAAM;EACf,QAAQ,MAAM;EACd,UAAU;GAAE;GAAO,OAAO,QAAQ,MAAM,QAAQ,UAAU;GAAG,SAAS,MAAM,QAAQ;GAAG,SAAS,MAAM,QAAQ;EAAE;CAClH;CACA,IAAI,aAAa,IAAI,cAAc,MAAM,eAAe,CAAC,CAAC,KAAK,OAAO;EAAE,IAAI,EAAE;EAAI,OAAO,EAAE;CAAM,EAAE;CACnG,OAAO;AACT"}

package/dist/devtools/hook.js

@@ -0,0 +1,74 @@
+import { VERSION } from "../version.js";
+import { DEVTOOLS_PROTOCOL } from "./protocol.js";
+import { openSession } from "./session.js";
+import { createWindowPageTransport, isDevtoolsEnvelope } from "./transport.js";
+import { createEmitter } from "@weasel-js/registry";
+
+//#region src/devtools/hook.ts
+/**
+* The devtools hook: the page-wide registry of roots a panel connects to,
+* published as `window.__weaselDevtools__`.
+*/
+/** Waits for the next frame: the one-shot callback coalesces notices, it never loops. */
+var nextFrame = (flush) => {
+	if (typeof requestAnimationFrame === "function") requestAnimationFrame(() => flush());
+	else setTimeout(flush, 16);
+};
+/** A hook not published anywhere: what {@link installDevtoolsHook} publishes, and what tests build. */
+function createDevtoolsHook(opts = {}) {
+	const live = /* @__PURE__ */ new Map();
+	const rootEvents = createEmitter();
+	const host = {
+		roots: () => [...live.values()],
+		root: (id) => live.get(id),
+		onRoots: (listener) => rootEvents.subscribe(listener),
+		schedule: opts.schedule ?? nextFrame
+	};
+	return {
+		protocol: DEVTOOLS_PROTOCOL,
+		kitVersion: VERSION,
+		roots: () => [...live.values()].map((r) => r.info()),
+		root: (id) => live.get(id),
+		register(root) {
+			live.set(root.id, root);
+			rootEvents.emit({ added: root });
+			return () => {
+				if (live.get(root.id) !== root) return;
+				live.delete(root.id);
+				rootEvents.emit({ removed: root.id });
+			};
+		},
+		connect(transport, opening) {
+			const session = openSession(host, transport);
+			const off = transport.onMessage((m) => session.receive(m));
+			if (opening) session.receive(opening);
+			return () => {
+				off();
+				session.close();
+			};
+		}
+	};
+}
+/** Serve the one window-transport panel there can be: a `yo` posted to the window opens it, replacing any before. */
+function serveWindow(hook) {
+	const transport = createWindowPageTransport();
+	let close = null;
+	window.addEventListener("message", (e) => {
+		if (!isDevtoolsEnvelope(e.data) || e.data.side !== "panel" || e.data.message.type !== "yo") return;
+		close?.();
+		close = hook.connect(transport, e.data.message);
+	});
+}
+/** Publish the hook on `window.__weaselDevtools__`, once; later calls return the same hook. */
+function installDevtoolsHook() {
+	if (typeof window === "undefined") return null;
+	if (window.__weaselDevtools__) return window.__weaselDevtools__;
+	const hook = createDevtoolsHook();
+	window.__weaselDevtools__ = hook;
+	serveWindow(hook);
+	return hook;
+}
+
+//#endregion
+export { createDevtoolsHook, installDevtoolsHook };
+//# sourceMappingURL=hook.js.map

package/dist/devtools/hook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook.js","names":[],"sources":["../../src/devtools/hook.ts"],"sourcesContent":["/**\n * The devtools hook: the page-wide registry of roots a panel connects to,\n * published as `window.__weaselDevtools__`.\n */\nimport { createEmitter } from '@weasel-js/registry';\nimport { VERSION } from '../version';\nimport { DEVTOOLS_PROTOCOL, type DevtoolsRootInfo, type PanelMessage } from './protocol';\nimport type { DevtoolsRoot } from './root';\nimport type { DevtoolsSchedule } from './notices';\nimport { openSession, type SessionHost } from './session';\nimport { createWindowPageTransport, isDevtoolsEnvelope, type PageTransport } from './transport';\n\n/** What `window.__weaselDevtools__` holds: the page's canvases, and the way a panel connects to them. */\nexport interface WeaselDevtoolsHook {\n  readonly protocol: number;\n  readonly kitVersion: string;\n  roots(): DevtoolsRootInfo[];\n  /** The root registered under `id`, for in-page readers such as the test hook. */\n  root(id: string): DevtoolsRoot | undefined;\n  /** Add a canvas's root. Returns its removal. */\n  register(root: DevtoolsRoot): () => void;\n  /** Serve a panel over `transport` until the panel says `bye` or the returned close is called.\n   *  `opening` is a message that arrived before the transport was listened to — the `yo` that\n   *  prompted the connection. */\n  connect(transport: PageTransport, opening?: PanelMessage): () => void;\n}\n\ndeclare global {\n  interface Window {\n    __weaselDevtools__?: WeaselDevtoolsHook;\n  }\n}\n\n/** Waits for the next frame: the one-shot callback coalesces notices, it never loops. */\nconst nextFrame: DevtoolsSchedule = (flush) => {\n  if (typeof requestAnimationFrame === 'function') requestAnimationFrame(() => flush());\n  else setTimeout(flush, 16);\n};\n\n/** A hook not published anywhere: what {@link installDevtoolsHook} publishes, and what tests build. */\nexport function createDevtoolsHook(opts: { schedule?: DevtoolsSchedule } = {}): WeaselDevtoolsHook {\n  const live = new Map<string, DevtoolsRoot>();\n  const rootEvents = createEmitter<[{ added: DevtoolsRoot } | { removed: string }]>();\n  const host: SessionHost = {\n    roots: () => [...live.values()],\n    root: (id) => live.get(id),\n    onRoots: (listener) => rootEvents.subscribe(listener),\n    schedule: opts.schedule ?? nextFrame,\n  };\n  return {\n    protocol: DEVTOOLS_PROTOCOL,\n    kitVersion: VERSION,\n    roots: () => [...live.values()].map((r) => r.info()),\n    root: (id) => live.get(id),\n    register(root) {\n      live.set(root.id, root);\n      rootEvents.emit({ added: root });\n      return () => {\n        if (live.get(root.id) !== root) return;\n        live.delete(root.id);\n        rootEvents.emit({ removed: root.id });\n      };\n    },\n    connect(transport, opening) {\n      const session = openSession(host, transport);\n      const off = transport.onMessage((m) => session.receive(m));\n      if (opening) session.receive(opening);\n      return () => { off(); session.close(); };\n    },\n  };\n}\n\n/** Serve the one window-transport panel there can be: a `yo` posted to the window opens it, replacing any before. */\nfunction serveWindow(hook: WeaselDevtoolsHook): void {\n  const transport = createWindowPageTransport();\n  let close: (() => void) | null = null;\n  window.addEventListener('message', (e) => {\n    if (!isDevtoolsEnvelope(e.data) || e.data.side !== 'panel' || e.data.message.type !== 'yo') return;\n    close?.();\n    close = hook.connect(transport, e.data.message as PanelMessage);\n  });\n}\n\n/** Publish the hook on `window.__weaselDevtools__`, once; later calls return the same hook. */\nexport function installDevtoolsHook(): WeaselDevtoolsHook | null {\n  if (typeof window === 'undefined') return null;\n  if (window.__weaselDevtools__) return window.__weaselDevtools__;\n  const hook = createDevtoolsHook();\n  window.__weaselDevtools__ = hook;\n  serveWindow(hook);\n  return hook;\n}\n"],"mappings":";;;;;;;;;;;;AAkCA,IAAM,aAA+B,UAAU;CAC7C,IAAI,OAAO,0BAA0B,YAAY,4BAA4B,MAAM,CAAC;MAC/E,WAAW,OAAO,EAAE;AAC3B;;AAGA,SAAgB,mBAAmB,OAAwC,CAAC,GAAuB;CACjG,MAAM,uBAAO,IAAI,IAA0B;CAC3C,MAAM,aAAa,cAA+D;CAClF,MAAM,OAAoB;EACxB,aAAa,CAAC,GAAG,KAAK,OAAO,CAAC;EAC9B,OAAO,OAAO,KAAK,IAAI,EAAE;EACzB,UAAU,aAAa,WAAW,UAAU,QAAQ;EACpD,UAAU,KAAK,YAAY;CAC7B;CACA,OAAO;EACL,UAAU;EACV,YAAY;EACZ,aAAa,CAAC,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,MAAM,EAAE,KAAK,CAAC;EACnD,OAAO,OAAO,KAAK,IAAI,EAAE;EACzB,SAAS,MAAM;GACb,KAAK,IAAI,KAAK,IAAI,IAAI;GACtB,WAAW,KAAK,EAAE,OAAO,KAAK,CAAC;GAC/B,aAAa;IACX,IAAI,KAAK,IAAI,KAAK,EAAE,MAAM,MAAM;IAChC,KAAK,OAAO,KAAK,EAAE;IACnB,WAAW,KAAK,EAAE,SAAS,KAAK,GAAG,CAAC;GACtC;EACF;EACA,QAAQ,WAAW,SAAS;GAC1B,MAAM,UAAU,YAAY,MAAM,SAAS;GAC3C,MAAM,MAAM,UAAU,WAAW,MAAM,QAAQ,QAAQ,CAAC,CAAC;GACzD,IAAI,SAAS,QAAQ,QAAQ,OAAO;GACpC,aAAa;IAAE,IAAI;IAAG,QAAQ,MAAM;GAAG;EACzC;CACF;AACF;;AAGA,SAAS,YAAY,MAAgC;CACnD,MAAM,YAAY,0BAA0B;CAC5C,IAAI,QAA6B;CACjC,OAAO,iBAAiB,YAAY,MAAM;EACxC,IAAI,CAAC,mBAAmB,EAAE,IAAI,KAAK,EAAE,KAAK,SAAS,WAAW,EAAE,KAAK,QAAQ,SAAS,MAAM;EAC5F,QAAQ;EACR,QAAQ,KAAK,QAAQ,WAAW,EAAE,KAAK,OAAuB;CAChE,CAAC;AACH;;AAGA,SAAgB,sBAAiD;CAC/D,IAAI,OAAO,WAAW,aAAa,OAAO;CAC1C,IAAI,OAAO,oBAAoB,OAAO,OAAO;CAC7C,MAAM,OAAO,mBAAmB;CAChC,OAAO,qBAAqB;CAC5B,YAAY,IAAI;CAChB,OAAO;AACT"}

package/dist/devtools/label.js

@@ -0,0 +1,25 @@
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/devtools/label.tsx
+var DevtoolsLabelContext = createContext(null);
+/**
+* Names the canvases beneath it in a devtools panel, ahead of any labeled
+* element between them and it. A host that frames canvases it did not write,
+* such as a lab's trial or a story's frame, knows the right name; the nearest
+* labeled ancestor is only a guess.
+*/
+function DevtoolsLabel({ value, children }) {
+	return /* @__PURE__ */ jsx(DevtoolsLabelContext.Provider, {
+		value,
+		children
+	});
+}
+/** The label the nearest `<DevtoolsLabel>` gives, or null outside one. */
+function useDevtoolsLabel() {
+	return useContext(DevtoolsLabelContext);
+}
+
+//#endregion
+export { DevtoolsLabel, useDevtoolsLabel };
+//# sourceMappingURL=label.js.map

package/dist/devtools/label.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"label.js","names":[],"sources":["../../src/devtools/label.tsx"],"sourcesContent":["import { createContext, useContext, type ReactNode } from 'react';\n\nconst DevtoolsLabelContext = createContext<string | null>(null);\n\n/** Props for `<DevtoolsLabel>`. */\nexport interface DevtoolsLabelProps {\n  /** The name a devtools panel lists each canvas below this under, unless the canvas has an `aria-label` or id. */\n  value: string;\n  children?: ReactNode;\n}\n\n/**\n * Names the canvases beneath it in a devtools panel, ahead of any labeled\n * element between them and it. A host that frames canvases it did not write,\n * such as a lab's trial or a story's frame, knows the right name; the nearest\n * labeled ancestor is only a guess.\n */\nexport function DevtoolsLabel({ value, children }: DevtoolsLabelProps) {\n  return <DevtoolsLabelContext.Provider value={value}>{children}</DevtoolsLabelContext.Provider>;\n}\n\n/** The label the nearest `<DevtoolsLabel>` gives, or null outside one. */\nexport function useDevtoolsLabel(): string | null {\n  return useContext(DevtoolsLabelContext);\n}\n"],"mappings":";;;;AAEA,IAAM,uBAAuB,cAA6B,IAAI;;;;;;;AAe9D,SAAgB,cAAc,EAAE,OAAO,YAAgC;CACrE,OAAO,oBAAC,qBAAqB,UAAtB;EAAsC;EAAQ;CAAwC,CAAA;AAC/F;;AAGA,SAAgB,mBAAkC;CAChD,OAAO,WAAW,oBAAoB;AACxC"}

package/dist/devtools/notices.js

@@ -0,0 +1,58 @@
+import { DEVTOOLS_PROTOCOL } from "./protocol.js";
+
+//#region src/devtools/notices.ts
+/** A session's change notices: the roots it follows, and what changed in each since the last flush. */
+function createNotices(rootOf, schedule, send) {
+	const following = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	let scheduled = false;
+	const flush = () => {
+		scheduled = false;
+		for (const [rootId, areas] of pending) {
+			const root = rootOf(rootId);
+			if (!root || !following.has(rootId)) continue;
+			const versions = {};
+			for (const area of areas) versions[area] = root.version(area);
+			send({
+				type: "changed",
+				protocol: DEVTOOLS_PROTOCOL,
+				rootId,
+				areas: versions
+			});
+		}
+		pending.clear();
+	};
+	return {
+		follow(root) {
+			if (following.has(root.id)) return;
+			const releaseTrace = root.source.trace.watch();
+			const releaseCoords = root.source.coords.watch();
+			const releaseHistory = root.source.history?.watch();
+			const off = root.subscribe((area) => {
+				let areas = pending.get(root.id);
+				if (!areas) pending.set(root.id, areas = /* @__PURE__ */ new Set());
+				areas.add(area);
+				if (!scheduled) {
+					scheduled = true;
+					schedule(flush);
+				}
+			});
+			following.set(root.id, () => {
+				releaseTrace();
+				releaseCoords();
+				releaseHistory?.();
+				off();
+			});
+		},
+		unfollow(rootId) {
+			following.get(rootId)?.();
+			following.delete(rootId);
+			pending.delete(rootId);
+		},
+		ids: () => [...following.keys()]
+	};
+}
+
+//#endregion
+export { createNotices };
+//# sourceMappingURL=notices.js.map

package/dist/devtools/notices.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notices.js","names":[],"sources":["../../src/devtools/notices.ts"],"sourcesContent":["/** A session's change notices: the roots it follows, and what changed in each since the last flush. */\nimport { DEVTOOLS_PROTOCOL, type DevtoolsArea, type PageMessage } from './protocol';\nimport type { DevtoolsRoot } from './root';\n\n/** Run `flush` once, soon. The hook's default waits for the next animation frame. */\nexport type DevtoolsSchedule = (flush: () => void) => void;\n\nexport interface Notices {\n  /** Trace this root and report its changes, until {@link Notices.unfollow}. */\n  follow(root: DevtoolsRoot): void;\n  unfollow(rootId: string): void;\n  /** The roots followed now. */\n  ids(): string[];\n}\n\nexport function createNotices(\n  rootOf: (id: string) => DevtoolsRoot | undefined,\n  schedule: DevtoolsSchedule,\n  send: (m: PageMessage) => void,\n): Notices {\n  const following = new Map<string, () => void>();\n  const pending = new Map<string, Set<DevtoolsArea>>();\n  let scheduled = false;\n\n  const flush = (): void => {\n    scheduled = false;\n    for (const [rootId, areas] of pending) {\n      const root = rootOf(rootId);\n      if (!root || !following.has(rootId)) continue;\n      const versions: Partial<Record<DevtoolsArea, number>> = {};\n      for (const area of areas) versions[area] = root.version(area);\n      send({ type: 'changed', protocol: DEVTOOLS_PROTOCOL, rootId, areas: versions });\n    }\n    pending.clear();\n  };\n\n  return {\n    follow(root) {\n      if (following.has(root.id)) return;\n      const releaseTrace = root.source.trace.watch();\n      const releaseCoords = root.source.coords.watch();\n      const releaseHistory = root.source.history?.watch();\n      const off = root.subscribe((area) => {\n        let areas = pending.get(root.id);\n        if (!areas) pending.set(root.id, (areas = new Set()));\n        areas.add(area);\n        if (!scheduled) {\n          scheduled = true;\n          schedule(flush);\n        }\n      });\n      following.set(root.id, () => { releaseTrace(); releaseCoords(); releaseHistory?.(); off(); });\n    },\n    unfollow(rootId) {\n      following.get(rootId)?.();\n      following.delete(rootId);\n      pending.delete(rootId);\n    },\n    ids: () => [...following.keys()],\n  };\n}\n"],"mappings":";;;;AAeA,SAAgB,cACd,QACA,UACA,MACS;CACT,MAAM,4BAAY,IAAI,IAAwB;CAC9C,MAAM,0BAAU,IAAI,IAA+B;CACnD,IAAI,YAAY;CAEhB,MAAM,cAAoB;EACxB,YAAY;EACZ,KAAK,MAAM,CAAC,QAAQ,UAAU,SAAS;GACrC,MAAM,OAAO,OAAO,MAAM;GAC1B,IAAI,CAAC,QAAQ,CAAC,UAAU,IAAI,MAAM,GAAG;GACrC,MAAM,WAAkD,CAAC;GACzD,KAAK,MAAM,QAAQ,OAAO,SAAS,QAAQ,KAAK,QAAQ,IAAI;GAC5D,KAAK;IAAE,MAAM;IAAW,UAAU;IAAmB;IAAQ,OAAO;GAAS,CAAC;EAChF;EACA,QAAQ,MAAM;CAChB;CAEA,OAAO;EACL,OAAO,MAAM;GACX,IAAI,UAAU,IAAI,KAAK,EAAE,GAAG;GAC5B,MAAM,eAAe,KAAK,OAAO,MAAM,MAAM;GAC7C,MAAM,gBAAgB,KAAK,OAAO,OAAO,MAAM;GAC/C,MAAM,iBAAiB,KAAK,OAAO,SAAS,MAAM;GAClD,MAAM,MAAM,KAAK,WAAW,SAAS;IACnC,IAAI,QAAQ,QAAQ,IAAI,KAAK,EAAE;IAC/B,IAAI,CAAC,OAAO,QAAQ,IAAI,KAAK,IAAK,wBAAQ,IAAI,IAAI,CAAE;IACpD,MAAM,IAAI,IAAI;IACd,IAAI,CAAC,WAAW;KACd,YAAY;KACZ,SAAS,KAAK;IAChB;GACF,CAAC;GACD,UAAU,IAAI,KAAK,UAAU;IAAE,aAAa;IAAG,cAAc;IAAG,iBAAiB;IAAG,IAAI;GAAG,CAAC;EAC9F;EACA,SAAS,QAAQ;GACf,UAAU,IAAI,MAAM,CAAC,GAAG;GACxB,UAAU,OAAO,MAAM;GACvB,QAAQ,OAAO,MAAM;EACvB;EACA,WAAW,CAAC,GAAG,UAAU,KAAK,CAAC;CACjC;AACF"}

package/dist/devtools/protocol.js

@@ -0,0 +1,7 @@
+//#region src/devtools/protocol.ts
+/** Bumped on any change a panel built against the previous number would misread. */
+var DEVTOOLS_PROTOCOL = 1;
+
+//#endregion
+export { DEVTOOLS_PROTOCOL };
+//# sourceMappingURL=protocol.js.map

package/dist/devtools/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","names":[],"sources":["../../src/devtools/protocol.ts"],"sourcesContent":["/**\n * The messages a devtools panel and a page running weasel exchange. Plain\n * data only, so the same messages cross a direct call or `window.postMessage`.\n */\nimport type { DebugFeature } from '../debug/types';\nimport type { SerializedValue } from './serialize';\n\n/** Bumped on any change a panel built against the previous number would misread. */\nexport const DEVTOOLS_PROTOCOL = 1;\n\n/** The areas of a root a `changed` notice reports. */\nexport type DevtoolsArea = 'scene' | 'selection' | 'view' | 'tool' | 'trace' | 'registry' | 'history';\n\n/** One mounted `<SceneCanvas>`. */\nexport interface DevtoolsRootInfo {\n  id: string;\n  /** The canvas's `aria-label`, else its DOM id, else its root id. */\n  label: string;\n  dimension: '2d' | '3d';\n}\n\n/** Debug overlay features a panel turns on or off over the canvas's own `debug` prop. */\nexport type DevtoolsOverlays = Partial<Record<DebugFeature, boolean>>;\n\n/** A request a panel sends about one root. */\nexport type DevtoolsRequest = { protocol: number; requestId: number; rootId: string } & (\n  | { type: 'get-children'; nodeId?: string }\n  | { type: 'get-node'; nodeId: string }\n  | { type: 'get-state' }\n  /** Coord records come back only when `coordCursor` is given. */\n  | { type: 'get-trace'; cursor: number; coordCursor?: number }\n  | { type: 'get-frame' }\n  | { type: 'get-registry' }\n  /** The stack's entry labels come back only when `checkpoints` is true. */\n  | { type: 'get-history'; cursor: number; checkpoints?: boolean }\n  | { type: 'select'; ids: string[] }\n  | { type: 'highlight'; ids: string[] }\n  | { type: 'set-tool'; toolId: string | null }\n  | { type: 'set-overlays'; overlays: DevtoolsOverlays }\n);\n\n/** Every message a panel sends the page. */\nexport type PanelMessage =\n  | { type: 'yo'; protocol: number }\n  /** The panel is closing: drop its overlays and highlight, and stop tracing for it. */\n  | { type: 'bye'; protocol: number }\n  | DevtoolsRequest;\n\n/** Every message the page sends a panel. */\nexport type PageMessage =\n  | { type: 'sup'; protocol: number; kitVersion: string; roots: DevtoolsRootInfo[] }\n  | { type: 'root-added'; protocol: number; root: DevtoolsRootInfo }\n  | { type: 'root-removed'; protocol: number; rootId: string }\n  /** Each changed area with its new version. At most one per root per frame. */\n  | { type: 'changed'; protocol: number; rootId: string; areas: Partial<Record<DevtoolsArea, number>> }\n  | { type: 'result'; protocol: number; requestId: number; result: DevtoolsResult }\n  /** `requestId` is null for a message that was not a request. */\n  | { type: 'error'; protocol: number; requestId: number | null; message: string };\n\n/** One child row of the scene tree. `nodeId` absent asks for the top level. */\nexport interface DevtoolsNodeSummary {\n  id: string;\n  kind: 'leaf' | 'container';\n  layer: string;\n  childCount: number;\n  hidden: boolean;\n  locked: boolean;\n  pickable: boolean;\n}\n\n/** A node as `get-node` returns it: its row in the tree, plus its parent, pose and data. */\nexport interface DevtoolsNodeDetail extends DevtoolsNodeSummary {\n  parent: string | null;\n  pose: SerializedValue;\n  data: SerializedValue;\n}\n\n/** What `get-state` returns about a root. */\nexport interface DevtoolsRootState {\n  selection: string[];\n  view: SerializedValue;\n  activeTool: string | null;\n  tools: string[];\n  /** The debug overlay features in effect: the canvas's own, with the panel's over them. */\n  overlays: DevtoolsOverlays;\n  /** Probes registered through the test hook, by name. */\n  probes: Record<string, SerializedValue>;\n}\n\n/** What `get-trace` returns: the records after the cursor, and the cursor to send next. */\nexport interface DevtoolsTraceSlice {\n  entries: SerializedValue[];\n  cursor: number;\n  /** What a press at the pointer would do, or null when the pointer is off the canvas. */\n  live: SerializedValue;\n  coords?: { entries: SerializedValue[]; cursor: number };\n}\n\n/** One gesture-to-action binding, as a tool, an always-on entry or an action declares it. */\nexport interface DevtoolsBinding {\n  actionId: string;\n  /** The `GestureSpec` as written. */\n  spec: SerializedValue;\n  /** The spec in the route grammar, one string per route it expands to. */\n  routes: string[];\n  /** The binding's `BindingOpts`: params, roles, views. */\n  opts: SerializedValue;\n}\n\n/** A tool or other contribution the canvas's dispatcher assembles bindings from. */\nexport interface DevtoolsToolEntry {\n  id: string;\n  /** A switchable tool, an always-on entry, or one a `features` preset brought. */\n  slot: 'tool' | 'ambient' | 'contribution';\n  label: string;\n  /** The icon's qualified name. */\n  icon: string | null;\n  group: string | null;\n  shortcut: string | null;\n  /** The key that holds it engaged while pressed. */\n  hotkey: string | null;\n  hidden: boolean;\n  cursor: SerializedValue;\n  eligibility: SerializedValue;\n  bindings: DevtoolsBinding[];\n  /** Ids of the actions it brings with it. */\n  actions: string[];\n  /** Names of the deps it registers. */\n  deps: string[];\n  hasOverlay: boolean;\n}\n\n/** A registered action. `enabled` and `active` are asked when the registry is read. */\nexport interface DevtoolsActionEntry {\n  id: string;\n  label: string;\n  icon: string | null;\n  group: string | null;\n  tags: string[];\n  shortcut: string | null;\n  /** Which binding scope its own bindings ride. */\n  scope: 'hotkey' | 'ambient';\n  invoker: 'immediate' | 'ongoing' | null;\n  requires: string[];\n  variants: { key: string; label: string; icon: string | null; params: SerializedValue }[];\n  /** `true`, or the reason it is disabled. */\n  enabled: true | string;\n  /** Null for an action with no pressed state. */\n  active: boolean | null;\n  hasPreview: boolean;\n  /** The eligibility rule, or null for always eligible. */\n  eligible: SerializedValue;\n  bindings: DevtoolsBinding[];\n}\n\n/** A dep name the canvas's registry answers. */\nexport interface DevtoolsDepEntry {\n  name: string;\n  /** How many scopes above the canvas's own its live source sits: 0 for the canvas's. */\n  depth: number;\n  /** How many sources are stacked under the name there, the live one included. */\n  stacked: number;\n}\n\n/** What `get-registry` returns: what one canvas has registered. */\nexport interface DevtoolsRegistry {\n  tools: DevtoolsToolEntry[];\n  actions: DevtoolsActionEntry[];\n  deps: DevtoolsDepEntry[];\n  /** The node routing kinds a binding's `kind:` target can name, in classify order. */\n  routingKinds: string[];\n}\n\n/** One op of a recorded history step. */\nexport interface DevtoolsHistoryOp {\n  /** The op's registered name, `'kit:setPose'` and the like; `'?'` for an op with none. */\n  kind: string;\n  /** The node ids its args address. */\n  targets: string[];\n  summary: SerializedValue;\n}\n\n/** One change to a scene's history: an edit recorded, merged, undone, redone or jumped across. */\nexport interface DevtoolsHistoryRecord {\n  ts: number;\n  step: 'push' | 'coalesce' | 'undo' | 'redo' | 'goto' | 'branch' | 'prune' | 'clear' | 'restore';\n  /** The entries the step pushed, merged into or walked across, in the order it touched them. */\n  entries: { id: number; label: string; opCount: number; ops: DevtoolsHistoryOp[] }[];\n  /** Where the history stood after the step: entries applied, and entries in all. */\n  position: { index: number; total: number };\n}\n\n/** What `get-history` returns: the steps after the cursor, the cursor to send next, and where the history stands. */\nexport interface DevtoolsHistorySlice {\n  entries: DevtoolsHistoryRecord[];\n  cursor: number;\n  position: { index: number; total: number; canUndo: boolean; canRedo: boolean };\n  /** Every entry on the stacks, oldest applied first, then the redoable ones. */\n  checkpoints?: { id: string; label: string }[];\n}\n\n/** The body of a `result` reply; which one depends on the request it answers. */\nexport type DevtoolsResult =\n  | DevtoolsNodeSummary[]\n  | DevtoolsNodeDetail\n  | DevtoolsRootState\n  | DevtoolsTraceSlice\n  | DevtoolsRegistry\n  | DevtoolsHistorySlice\n  | SerializedValue\n  | null;\n"],"mappings":";;AAQA,IAAa,oBAAoB"}

package/dist/devtools/registry.js

@@ -0,0 +1,90 @@
+import { serialize } from "./serialize.js";
+import { actionBindings, buildDepsFromRequires, evaluateActive, evaluateEnabled, overriddenBindings, routesForSpec } from "@weasel-js/routing";
+
+//#region src/devtools/registry.ts
+/** What one canvas has registered — its tools, actions, deps and node kinds — as plain data for `get-registry`. */
+function routesOf(binding) {
+	try {
+		return [...routesForSpec(binding.spec)];
+	} catch {
+		return [];
+	}
+}
+function bindingOf(binding) {
+	return {
+		actionId: binding.actionId,
+		spec: serialize(binding.spec),
+		routes: routesOf(binding),
+		opts: serialize(binding.opts)
+	};
+}
+function toolOf(entry, slot, overrides) {
+	const p = entry.presentation;
+	return {
+		id: entry.id,
+		slot,
+		label: p?.label ?? entry.id,
+		icon: p?.icon ?? null,
+		group: p?.group ?? null,
+		shortcut: p?.shortcut ?? null,
+		hotkey: entry.eligibility?.offhand ?? null,
+		hidden: p?.hide === true,
+		cursor: serialize(entry.cursor),
+		eligibility: serialize(entry.eligibility),
+		bindings: overriddenBindings(entry.bindings ?? [], entry.id, overrides).map(bindingOf),
+		actions: (entry.actions ?? []).map((a) => a.id),
+		deps: Object.keys(entry.deps ?? {}),
+		hasOverlay: entry.overlay !== void 0
+	};
+}
+function actionOf(action, deps) {
+	const bag = deps ? buildDepsFromRequires(action, deps) : void 0;
+	const enabled = evaluateEnabled(action, bag);
+	const rule = action.eligible;
+	return {
+		id: action.id,
+		label: action.label ?? action.id,
+		icon: action.icon ?? null,
+		group: action.group ?? null,
+		tags: [...action.tags ?? []],
+		shortcut: action.shortcut ?? null,
+		scope: action.scope === "hotkey" ? "hotkey" : "ambient",
+		invoker: action.invoker?.timing ?? null,
+		requires: [...action.requires ?? []],
+		variants: (action.variants ?? []).map((v) => ({
+			key: v.key,
+			label: v.label,
+			icon: v.icon ?? null,
+			params: serialize(v.params)
+		})),
+		enabled: enabled.enabled ? true : enabled.reason ?? "disabled",
+		active: evaluateActive(action, bag) ?? null,
+		hasPreview: action.preview !== void 0,
+		eligible: serialize(typeof rule === "function" ? rule.rule : rule ?? null),
+		bindings: actionBindings(action).map(bindingOf)
+	};
+}
+function describeRegistry(inputs) {
+	const seen = /* @__PURE__ */ new Set();
+	const tools = [];
+	const add = (entries, slot) => {
+		for (const e of entries) {
+			if (seen.has(e.id)) continue;
+			seen.add(e.id);
+			tools.push(toolOf(e, slot, inputs.overrides));
+		}
+	};
+	add(Object.values(inputs.tools.registry), "tool");
+	add(inputs.tools.ambient, "ambient");
+	add(inputs.contributions, "contribution");
+	return {
+		tools,
+		actions: (inputs.actions?.list() ?? []).map((a) => actionOf(a, inputs.deps)),
+		deps: (inputs.deps?.list?.() ?? []).map((d) => ({ ...d })),
+		routingKinds: [...inputs.routingKinds]
+	};
+}
+
+//#endregion
+export { describeRegistry };
+//# sourceMappingURL=registry.js.map

package/dist/devtools/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","names":[],"sources":["../../src/devtools/registry.ts"],"sourcesContent":["/** What one canvas has registered — its tools, actions, deps and node kinds — as plain data for `get-registry`. */\nimport {\n  actionBindings, buildDepsFromRequires, evaluateActive, evaluateEnabled, overriddenBindings, routesForSpec,\n  type Action, type ActionSource, type Contribution, type DepRegistry, type GestureBinding, type ResolvedBindingOverrides,\n} from '@weasel-js/routing';\nimport type {\n  DevtoolsActionEntry, DevtoolsBinding, DevtoolsRegistry, DevtoolsToolEntry,\n} from './protocol';\nimport { serialize } from './serialize';\n\ntype Entry = Contribution<unknown> & { cursor?: unknown };\n\n/** The live registries {@link describeRegistry} reads. */\nexport interface RegistryInputs {\n  tools: { registry: Readonly<Record<string, Entry>>; ambient: readonly Entry[] };\n  /** The entries a `features` preset brought beside the tools. */\n  contributions: readonly Entry[];\n  actions: ActionSource | null;\n  /** Binding overrides in force, applied to the entries' bindings; `actions`\n   *  lists its own already overridden. */\n  overrides?: ResolvedBindingOverrides;\n  deps: DepRegistry | null;\n  routingKinds: readonly string[];\n}\n\nfunction routesOf(binding: GestureBinding): string[] {\n  try {\n    return [...routesForSpec(binding.spec)];\n  } catch {\n    return [];\n  }\n}\n\nfunction bindingOf(binding: GestureBinding): DevtoolsBinding {\n  return {\n    actionId: binding.actionId,\n    spec: serialize(binding.spec),\n    routes: routesOf(binding),\n    opts: serialize(binding.opts),\n  };\n}\n\nfunction toolOf(entry: Entry, slot: DevtoolsToolEntry['slot'], overrides: ResolvedBindingOverrides | undefined): DevtoolsToolEntry {\n  const p = entry.presentation;\n  return {\n    id: entry.id,\n    slot,\n    label: p?.label ?? entry.id,\n    icon: p?.icon ?? null,\n    group: p?.group ?? null,\n    shortcut: p?.shortcut ?? null,\n    hotkey: entry.eligibility?.offhand ?? null,\n    hidden: p?.hide === true,\n    cursor: serialize(entry.cursor),\n    eligibility: serialize(entry.eligibility),\n    bindings: overriddenBindings(entry.bindings ?? [], entry.id, overrides).map(bindingOf),\n    actions: (entry.actions ?? []).map((a) => a.id),\n    deps: Object.keys(entry.deps ?? {}),\n    hasOverlay: entry.overlay !== undefined,\n  };\n}\n\nfunction actionOf(action: Action, deps: DepRegistry | null): DevtoolsActionEntry {\n  const bag = deps ? buildDepsFromRequires(action, deps) : undefined;\n  const enabled = evaluateEnabled(action, bag);\n  const rule: unknown = action.eligible;\n  return {\n    id: action.id,\n    label: action.label ?? action.id,\n    icon: action.icon ?? null,\n    group: action.group ?? null,\n    tags: [...(action.tags ?? [])],\n    shortcut: action.shortcut ?? null,\n    scope: action.scope === 'hotkey' ? 'hotkey' : 'ambient',\n    invoker: action.invoker?.timing ?? null,\n    requires: [...(action.requires ?? [])],\n    variants: (action.variants ?? []).map((v) => ({\n      key: v.key, label: v.label, icon: v.icon ?? null, params: serialize(v.params),\n    })),\n    enabled: enabled.enabled ? true : (enabled.reason ?? 'disabled'),\n    active: evaluateActive(action, bag) ?? null,\n    hasPreview: action.preview !== undefined,\n    // A fluent condition is callable and carries its rule tree on `.rule`.\n    eligible: serialize(typeof rule === 'function' ? (rule as { rule?: unknown }).rule : (rule ?? null)),\n    bindings: actionBindings(action).map(bindingOf),\n  };\n}\n\nexport function describeRegistry(inputs: RegistryInputs): DevtoolsRegistry {\n  const seen = new Set<string>();\n  const tools: DevtoolsToolEntry[] = [];\n  const add = (entries: readonly Entry[], slot: DevtoolsToolEntry['slot']): void => {\n    for (const e of entries) {\n      if (seen.has(e.id)) continue;\n      seen.add(e.id);\n      tools.push(toolOf(e, slot, inputs.overrides));\n    }\n  };\n  add(Object.values(inputs.tools.registry), 'tool');\n  add(inputs.tools.ambient, 'ambient');\n  add(inputs.contributions, 'contribution');\n  return {\n    tools,\n    actions: (inputs.actions?.list() ?? []).map((a) => actionOf(a, inputs.deps)),\n    deps: (inputs.deps?.list?.() ?? []).map((d) => ({ ...d })),\n    routingKinds: [...inputs.routingKinds],\n  };\n}\n"],"mappings":";;;;;AAyBA,SAAS,SAAS,SAAmC;CACnD,IAAI;EACF,OAAO,CAAC,GAAG,cAAc,QAAQ,IAAI,CAAC;CACxC,QAAQ;EACN,OAAO,CAAC;CACV;AACF;AAEA,SAAS,UAAU,SAA0C;CAC3D,OAAO;EACL,UAAU,QAAQ;EAClB,MAAM,UAAU,QAAQ,IAAI;EAC5B,QAAQ,SAAS,OAAO;EACxB,MAAM,UAAU,QAAQ,IAAI;CAC9B;AACF;AAEA,SAAS,OAAO,OAAc,MAAiC,WAAoE;CACjI,MAAM,IAAI,MAAM;CAChB,OAAO;EACL,IAAI,MAAM;EACV;EACA,OAAO,GAAG,SAAS,MAAM;EACzB,MAAM,GAAG,QAAQ;EACjB,OAAO,GAAG,SAAS;EACnB,UAAU,GAAG,YAAY;EACzB,QAAQ,MAAM,aAAa,WAAW;EACtC,QAAQ,GAAG,SAAS;EACpB,QAAQ,UAAU,MAAM,MAAM;EAC9B,aAAa,UAAU,MAAM,WAAW;EACxC,UAAU,mBAAmB,MAAM,YAAY,CAAC,GAAG,MAAM,IAAI,SAAS,CAAC,CAAC,IAAI,SAAS;EACrF,UAAU,MAAM,WAAW,CAAC,EAAA,CAAG,KAAK,MAAM,EAAE,EAAE;EAC9C,MAAM,OAAO,KAAK,MAAM,QAAQ,CAAC,CAAC;EAClC,YAAY,MAAM,YAAY;CAChC;AACF;AAEA,SAAS,SAAS,QAAgB,MAA+C;CAC/E,MAAM,MAAM,OAAO,sBAAsB,QAAQ,IAAI,IAAI;CACzD,MAAM,UAAU,gBAAgB,QAAQ,GAAG;CAC3C,MAAM,OAAgB,OAAO;CAC7B,OAAO;EACL,IAAI,OAAO;EACX,OAAO,OAAO,SAAS,OAAO;EAC9B,MAAM,OAAO,QAAQ;EACrB,OAAO,OAAO,SAAS;EACvB,MAAM,CAAC,GAAI,OAAO,QAAQ,CAAC,CAAE;EAC7B,UAAU,OAAO,YAAY;EAC7B,OAAO,OAAO,UAAU,WAAW,WAAW;EAC9C,SAAS,OAAO,SAAS,UAAU;EACnC,UAAU,CAAC,GAAI,OAAO,YAAY,CAAC,CAAE;EACrC,WAAW,OAAO,YAAY,CAAC,EAAA,CAAG,KAAK,OAAO;GAC5C,KAAK,EAAE;GAAK,OAAO,EAAE;GAAO,MAAM,EAAE,QAAQ;GAAM,QAAQ,UAAU,EAAE,MAAM;EAC9E,EAAE;EACF,SAAS,QAAQ,UAAU,OAAQ,QAAQ,UAAU;EACrD,QAAQ,eAAe,QAAQ,GAAG,KAAK;EACvC,YAAY,OAAO,YAAY;EAE/B,UAAU,UAAU,OAAO,SAAS,aAAc,KAA4B,OAAQ,QAAQ,IAAK;EACnG,UAAU,eAAe,MAAM,CAAC,CAAC,IAAI,SAAS;CAChD;AACF;AAEA,SAAgB,iBAAiB,QAA0C;CACzE,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,QAA6B,CAAC;CACpC,MAAM,OAAO,SAA2B,SAA0C;EAChF,KAAK,MAAM,KAAK,SAAS;GACvB,IAAI,KAAK,IAAI,EAAE,EAAE,GAAG;GACpB,KAAK,IAAI,EAAE,EAAE;GACb,MAAM,KAAK,OAAO,GAAG,MAAM,OAAO,SAAS,CAAC;EAC9C;CACF;CACA,IAAI,OAAO,OAAO,OAAO,MAAM,QAAQ,GAAG,MAAM;CAChD,IAAI,OAAO,MAAM,SAAS,SAAS;CACnC,IAAI,OAAO,eAAe,cAAc;CACxC,OAAO;EACL;EACA,UAAU,OAAO,SAAS,KAAK,KAAK,CAAC,EAAA,CAAG,KAAK,MAAM,SAAS,GAAG,OAAO,IAAI,CAAC;EAC3E,OAAO,OAAO,MAAM,OAAO,KAAK,CAAC,EAAA,CAAG,KAAK,OAAO,EAAE,GAAG,EAAE,EAAE;EACzD,cAAc,CAAC,GAAG,OAAO,YAAY;CACvC;AACF"}

package/dist/devtools/root.js

@@ -0,0 +1,80 @@
+//#region src/devtools/root.ts
+var nextId = 1;
+/** A root over `source`, with a fresh page-unique id. */
+function createDevtoolsRoot(source) {
+	const id = `root-${nextId++}`;
+	const versions = {
+		scene: 0,
+		selection: 0,
+		view: 0,
+		tool: 0,
+		trace: 0,
+		registry: 0,
+		history: 0
+	};
+	const listeners = /* @__PURE__ */ new Set();
+	const notify = (area) => {
+		versions[area]++;
+		for (const l of [...listeners]) l(area);
+	};
+	let detach = null;
+	let watchedScene = null;
+	let offScene = null;
+	const followScene = () => {
+		const s = detach ? source.scene() : null;
+		if (s === watchedScene) return;
+		offScene?.();
+		watchedScene = s;
+		if (!s) {
+			offScene = null;
+			return;
+		}
+		let content = s.getContentVersion();
+		offScene = s.subscribe(() => {
+			const next = s.getContentVersion();
+			if (next === content) return;
+			content = next;
+			notify("scene");
+		});
+	};
+	const attach = () => {
+		const offs = [
+			source.trace.subscribe(() => notify("trace")),
+			source.history?.subscribe(() => notify("history")),
+			source.subscribeRegistry?.(() => notify("registry"))
+		];
+		detach = () => {
+			for (const off of offs) off?.();
+			detach = null;
+			followScene();
+		};
+		followScene();
+	};
+	return {
+		id,
+		source,
+		info: () => ({
+			id,
+			label: source.label() || id,
+			dimension: source.dimension
+		}),
+		probes: /* @__PURE__ */ new Map(),
+		version: (area) => versions[area],
+		notify(area) {
+			if (area === "scene") followScene();
+			notify(area);
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			if (!detach) attach();
+			return () => {
+				listeners.delete(listener);
+				if (listeners.size === 0) detach?.();
+			};
+		}
+	};
+}
+
+//#endregion
+export { createDevtoolsRoot };
+//# sourceMappingURL=root.js.map

package/dist/devtools/root.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.js","names":[],"sources":["../../src/devtools/root.ts"],"sourcesContent":["/**\n * A root: what one mounted `<SceneCanvas>` exposes to the devtools hook and to\n * the test hook. The canvas supplies live getters; the root adds change\n * versions and the probe registry.\n */\nimport type { DispatchTrace, TraceRing } from '@weasel-js/routing';\nimport type { Scene } from 'core/scene/types';\nimport type { CoordTraceEntry } from '../canvas/SceneCanvas/coordTrace';\nimport type { DebugConfig } from '../debug/types';\nimport type {\n  DevtoolsArea, DevtoolsHistoryRecord, DevtoolsOverlays, DevtoolsRegistry, DevtoolsRootInfo,\n} from './protocol';\n\n/** What a canvas hands {@link createDevtoolsRoot}. Every getter reads the latest committed value. */\nexport interface DevtoolsRootSource {\n  label(): string;\n  readonly dimension: '2d' | '3d';\n  scene(): Scene<unknown, string, unknown> | null;\n  selection(): readonly string[];\n  select(ids: readonly string[]): void;\n  view(): unknown;\n  activeTool(): string | null;\n  tools(): readonly string[];\n  setTool(id: string | null): void;\n  trace: DispatchTrace;\n  coords: TraceRing<CoordTraceEntry>;\n  /** The debug sink's stats for the last paint, or null while the frame panel is off. */\n  frame(): unknown;\n  /** The debug overlay config in effect, or null when the overlay is off. */\n  overlays(): DebugConfig | null;\n  /** Lay the panel's overlay flags and highlight over the canvas's own `debug`; null drops them. */\n  setOverride(override: { overlays: DevtoolsOverlays; highlight: readonly string[] } | null): void;\n  /** What the canvas has registered, described when asked. Absent, `get-registry` is refused. */\n  registry?(): DevtoolsRegistry;\n  /** Hear that what {@link DevtoolsRootSource.registry} describes may have changed. Returns the unsubscribe. */\n  subscribeRegistry?(listener: () => void): () => void;\n  /** The scene's history steps. Absent, `get-history` is refused. */\n  history?: TraceRing<DevtoolsHistoryRecord>;\n}\n\n/** One canvas as the devtools hook holds it. */\nexport interface DevtoolsRoot {\n  readonly id: string;\n  readonly source: DevtoolsRootSource;\n  info(): DevtoolsRootInfo;\n  /** Name-keyed probes; the test hook's `registerProbe` writes here. */\n  readonly probes: Map<string, () => unknown>;\n  version(area: DevtoolsArea): number;\n  /** Say that `area` changed. The scene and the trace say so themselves while anything listens. */\n  notify(area: DevtoolsArea): void;\n  /** Hear each change, with the area. Returns the unsubscribe. */\n  subscribe(listener: (area: DevtoolsArea) => void): () => void;\n}\n\nlet nextId = 1;\n\n/** A root over `source`, with a fresh page-unique id. */\nexport function createDevtoolsRoot(source: DevtoolsRootSource): DevtoolsRoot {\n  const id = `root-${nextId++}`;\n  const versions: Record<DevtoolsArea, number> = {\n    scene: 0, selection: 0, view: 0, tool: 0, trace: 0, registry: 0, history: 0,\n  };\n  const listeners = new Set<(area: DevtoolsArea) => void>();\n  const notify = (area: DevtoolsArea): void => {\n    versions[area]++;\n    for (const l of [...listeners]) l(area);\n  };\n\n  // Attached only while something listens, so a root nobody inspects holds no\n  // subscription on a scene that may outlive its canvas.\n  let detach: (() => void) | null = null;\n  let watchedScene: Scene<unknown, string, unknown> | null = null;\n  let offScene: (() => void) | null = null;\n  const followScene = (): void => {\n    const s = detach ? source.scene() : null;\n    if (s === watchedScene) return;\n    offScene?.();\n    watchedScene = s;\n    if (!s) {\n      offScene = null;\n      return;\n    }\n    // A selection change notifies the scene's subscribers too; the canvas reports it as `selection`.\n    let content = s.getContentVersion();\n    offScene = s.subscribe(() => {\n      const next = s.getContentVersion();\n      if (next === content) return;\n      content = next;\n      notify('scene');\n    });\n  };\n  const attach = (): void => {\n    const offs = [\n      source.trace.subscribe(() => notify('trace')),\n      source.history?.subscribe(() => notify('history')),\n      source.subscribeRegistry?.(() => notify('registry')),\n    ];\n    detach = () => {\n      for (const off of offs) off?.();\n      detach = null;\n      followScene();\n    };\n    followScene();\n  };\n\n  return {\n    id,\n    source,\n    info: () => ({ id, label: source.label() || id, dimension: source.dimension }),\n    probes: new Map(),\n    version: (area) => versions[area],\n    notify(area) {\n      if (area === 'scene') followScene();\n      notify(area);\n    },\n    subscribe(listener) {\n      listeners.add(listener);\n      if (!detach) attach();\n      return () => {\n        listeners.delete(listener);\n        if (listeners.size === 0) detach?.();\n      };\n    },\n  };\n}\n"],"mappings":";AAsDA,IAAI,SAAS;;AAGb,SAAgB,mBAAmB,QAA0C;CAC3E,MAAM,KAAK,QAAQ;CACnB,MAAM,WAAyC;EAC7C,OAAO;EAAG,WAAW;EAAG,MAAM;EAAG,MAAM;EAAG,OAAO;EAAG,UAAU;EAAG,SAAS;CAC5E;CACA,MAAM,4BAAY,IAAI,IAAkC;CACxD,MAAM,UAAU,SAA6B;EAC3C,SAAS,KAAK;EACd,KAAK,MAAM,KAAK,CAAC,GAAG,SAAS,GAAG,EAAE,IAAI;CACxC;CAIA,IAAI,SAA8B;CAClC,IAAI,eAAuD;CAC3D,IAAI,WAAgC;CACpC,MAAM,oBAA0B;EAC9B,MAAM,IAAI,SAAS,OAAO,MAAM,IAAI;EACpC,IAAI,MAAM,cAAc;EACxB,WAAW;EACX,eAAe;EACf,IAAI,CAAC,GAAG;GACN,WAAW;GACX;EACF;EAEA,IAAI,UAAU,EAAE,kBAAkB;EAClC,WAAW,EAAE,gBAAgB;GAC3B,MAAM,OAAO,EAAE,kBAAkB;GACjC,IAAI,SAAS,SAAS;GACtB,UAAU;GACV,OAAO,OAAO;EAChB,CAAC;CACH;CACA,MAAM,eAAqB;EACzB,MAAM,OAAO;GACX,OAAO,MAAM,gBAAgB,OAAO,OAAO,CAAC;GAC5C,OAAO,SAAS,gBAAgB,OAAO,SAAS,CAAC;GACjD,OAAO,0BAA0B,OAAO,UAAU,CAAC;EACrD;EACA,eAAe;GACb,KAAK,MAAM,OAAO,MAAM,MAAM;GAC9B,SAAS;GACT,YAAY;EACd;EACA,YAAY;CACd;CAEA,OAAO;EACL;EACA;EACA,aAAa;GAAE;GAAI,OAAO,OAAO,MAAM,KAAK;GAAI,WAAW,OAAO;EAAU;EAC5E,wBAAQ,IAAI,IAAI;EAChB,UAAU,SAAS,SAAS;EAC5B,OAAO,MAAM;GACX,IAAI,SAAS,SAAS,YAAY;GAClC,OAAO,IAAI;EACb;EACA,UAAU,UAAU;GAClB,UAAU,IAAI,QAAQ;GACtB,IAAI,CAAC,QAAQ,OAAO;GACpB,aAAa;IACX,UAAU,OAAO,QAAQ;IACzB,IAAI,UAAU,SAAS,GAAG,SAAS;GACrC;EACF;CACF;AACF"}