@autono/pinbox-toolbar 0.19.0 → 0.21.0

package/dist/{index-DENhglDF.d.ts → index-CMSOhoVs.d.ts}

@@ -69,6 +69,8 @@ interface ToolbarState {
    * Persisted per endpoint; the bar's camera button flips it.
    */
   captureMode: "dom" | "tab";
+  /** Optional model camera action label; absent preserves the 2D capture toggle. */
+  captureLabel?: string | undefined;
 }
 interface Store {
   get(): ToolbarState;
@@ -148,6 +150,9 @@ declare class PinboxToolbarElement extends BaseElement {
   restore(keyboard?: boolean): void;
 }
 //#endregion
+//#region src/previews.d.ts
+declare function mountPreviewSwitcher(host: HTMLElement, endpoint: string): void;
+//#endregion
 //#region src/transport/mirror.d.ts
 interface StorageLike {
   getItem(key: string): string | null;
@@ -281,4 +286,4 @@ declare const Pinbox: {
   init(config: PinboxConfig): PinboxToolbarElement;
 };
 //#endregion
-export { applyHubEvent as _, HubEvent as a, upsertPin as b, WebSocketLike as c, PinboxToolbarElement as d, Draft as f, appendThreadMessage as g, UiStatus as h, ConnectionState as i, HubError as l, ToolbarState as m, PinboxConfig as n, HubTransport as o, Store as p, defineToolbarElement as r, TransportOptions as s, Pinbox as t, StorageLike as u, createStore as v, CaptureResult as x, deriveUiStatus as y };
+export { CaptureResult as S, appendThreadMessage as _, HubEvent as a, deriveUiStatus as b, WebSocketLike as c, mountPreviewSwitcher as d, PinboxToolbarElement as f, UiStatus as g, ToolbarState as h, ConnectionState as i, HubError as l, Store as m, PinboxConfig as n, HubTransport as o, Draft as p, defineToolbarElement as r, TransportOptions as s, Pinbox as t, StorageLike as u, applyHubEvent as v, upsertPin as x, createStore as y };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { _ as applyHubEvent, a as HubEvent, b as upsertPin, c as WebSocketLike, d as PinboxToolbarElement, f as Draft, g as appendThreadMessage, h as UiStatus, i as ConnectionState, l as HubError, m as ToolbarState, n as PinboxConfig, o as HubTransport, p as Store, r as defineToolbarElement, s as TransportOptions, t as Pinbox, u as StorageLike, v as createStore, x as CaptureResult, y as deriveUiStatus } from "./index-DENhglDF.js";
-export { type CaptureResult, type ConnectionState, type Draft, HubError, type HubEvent, HubTransport, Pinbox, PinboxConfig, PinboxToolbarElement, type StorageLike, type Store, type ToolbarState, type TransportOptions, type UiStatus, type WebSocketLike, appendThreadMessage, applyHubEvent, createStore, defineToolbarElement, deriveUiStatus, upsertPin };
+import { S as CaptureResult, _ as appendThreadMessage, a as HubEvent, b as deriveUiStatus, c as WebSocketLike, d as mountPreviewSwitcher, f as PinboxToolbarElement, g as UiStatus, h as ToolbarState, i as ConnectionState, l as HubError, m as Store, n as PinboxConfig, o as HubTransport, p as Draft, r as defineToolbarElement, s as TransportOptions, t as Pinbox, u as StorageLike, v as applyHubEvent, x as upsertPin, y as createStore } from "./index-CMSOhoVs.js";
+export { type CaptureResult, type ConnectionState, type Draft, HubError, type HubEvent, HubTransport, Pinbox, PinboxConfig, PinboxToolbarElement, type StorageLike, type Store, type ToolbarState, type TransportOptions, type UiStatus, type WebSocketLike, appendThreadMessage, applyHubEvent, createStore, defineToolbarElement, deriveUiStatus, mountPreviewSwitcher, upsertPin };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as HubError, c as createStore, i as HubTransport, l as deriveUiStatus, n as defineToolbarElement, o as appendThreadMessage, r as PinboxToolbarElement, s as applyHubEvent, t as Pinbox, u as upsertPin } from "./src-BsWnyGwB.js";
-export { HubError, HubTransport, Pinbox, PinboxToolbarElement, appendThreadMessage, applyHubEvent, createStore, defineToolbarElement, deriveUiStatus, upsertPin };
+import { a as HubTransport, c as applyHubEvent, d as upsertPin, i as PinboxToolbarElement, l as createStore, n as defineToolbarElement, o as HubError, r as mountPreviewSwitcher, s as appendThreadMessage, t as Pinbox, u as deriveUiStatus } from "./src-B134WXZ8.js";
+export { HubError, HubTransport, Pinbox, PinboxToolbarElement, appendThreadMessage, applyHubEvent, createStore, defineToolbarElement, deriveUiStatus, mountPreviewSwitcher, upsertPin };

package/dist/model-target-BykKL8H5.js

@@ -0,0 +1,350 @@
+//#region src/capture-mode.ts
+function captureKey(prefix) {
+	return `${prefix}:capture`;
+}
+function loadCaptureMode(storage, key, fallback) {
+	try {
+		const raw = storage?.getItem(key);
+		if (raw === "dom" || raw === "tab") return raw;
+	} catch {}
+	return fallback;
+}
+function saveCaptureMode(storage, key, mode) {
+	try {
+		storage?.setItem(key, mode);
+	} catch {}
+}
+//#endregion
+//#region src/model-capture.ts
+const handlers = /* @__PURE__ */ new WeakMap();
+/** The first viewer owns the camera until another registered surface is entered. */
+function registerModelCapture(owner, run, error) {
+	const entry = {
+		run,
+		error,
+		busy: false
+	};
+	const entries = handlers.get(owner) ?? [];
+	entries.push(entry);
+	handlers.set(owner, entries);
+	owner.store.update({ captureLabel: "Capture model screenshot (S)" });
+	return {
+		activate() {
+			const index = entries.indexOf(entry);
+			if (index < 0) return;
+			entries.splice(index, 1);
+			entries.unshift(entry);
+		},
+		destroy() {
+			const index = entries.indexOf(entry);
+			if (index < 0) return;
+			entries.splice(index, 1);
+			if (!entries.length) {
+				handlers.delete(owner);
+				owner.store.update({ captureLabel: void 0 });
+			}
+		}
+	};
+}
+function runModelCapture(owner) {
+	const entries = handlers.get(owner);
+	const entry = entries?.[0];
+	if (!entries || !entry) return false;
+	if (entries.some((candidate) => candidate.busy)) return true;
+	entry.busy = true;
+	try {
+		Promise.resolve(entry.run()).catch(entry.error).finally(() => {
+			entry.busy = false;
+		});
+	} catch (error) {
+		entry.busy = false;
+		entry.error(error);
+	}
+	return true;
+}
+/** Shared by the camera button, puck and S shortcut; preserve the 2D fallback. */
+function toggleToolbarCapture(owner, endpoint, release) {
+	if (runModelCapture(owner)) return true;
+	const next = owner.store.get().captureMode === "tab" ? "dom" : "tab";
+	owner.store.update({ captureMode: next });
+	if (next === "dom") release();
+	saveCaptureMode(globalThis.localStorage, captureKey(`pinbox:${endpoint}`), next);
+	return true;
+}
+//#endregion
+//#region src/targeting/dom.ts
+/**
+* Deepest element under (clientX, clientY) that the caller does not ignore, or null when there is
+* nothing there but page chrome (html/body).
+*
+* Looks THROUGH our own overlay rather than giving up at it. The single-element form could not:
+* the drag-aim grip sits exactly on the point being aimed at, so it is always the topmost thing
+* under the crosshair, and every probe came back "nothing" the moment touch aiming existed.
+*/
+function hitTest(doc, x, y, ignore) {
+	const stack = doc.elementsFromPoint?.(x, y) ?? [doc.elementFromPoint(x, y)];
+	for (const el of stack) {
+		if (!el || el === doc.body || el === doc.documentElement) return null;
+		if (!ignore(el)) return el;
+	}
+	return null;
+}
+/** CLASS-or-TAG display name with a sibling index when needed (prototype nodeName). */
+function nodeName(el) {
+	const key = el.classList[0];
+	let name = (key ?? el.tagName).toUpperCase();
+	const parent = el.parentElement;
+	if (parent) {
+		const sibs = [...parent.children].filter((c) => c.classList[0] === key && c.tagName === el.tagName);
+		if (sibs.length > 1) name += ` ${sibs.indexOf(el) + 1}`;
+	}
+	return name;
+}
+/**
+* Human label for a target: an explicit data-pb-el annotation wins; otherwise a
+* CLASS/TAG ancestry chain of at most 3 parts joined with ›, terminating early
+* at the first annotated ancestor.
+*/
+function targetLabel(el) {
+	const own = el.getAttribute("data-pb-el");
+	if (own) return own;
+	const parts = [nodeName(el)];
+	const body = el.ownerDocument.body;
+	let node = el.parentElement;
+	while (node && node !== body && parts.length < 3) {
+		const anchor = node.getAttribute("data-pb-el");
+		if (anchor) {
+			parts.unshift(anchor);
+			break;
+		}
+		if (node.classList[0]) parts.unshift(nodeName(node));
+		node = node.parentElement;
+	}
+	return parts.join(" › ");
+}
+const SAFE_ID = /^[A-Za-z][\w-]*$/;
+/** Data attributes trusted as stable hooks, in priority order. */
+const STABLE_DATA_ATTRS = [
+	"data-pb-anchor",
+	"data-pb-el",
+	"data-testid"
+];
+function attrSegment(el, doc) {
+	for (const attr of STABLE_DATA_ATTRS) {
+		const value = el.getAttribute(attr);
+		if (value === null || value.includes("\"") || value.includes("\\")) continue;
+		const selector = `${el.tagName.toLowerCase()}[${attr}="${value}"]`;
+		if (doc.querySelectorAll(selector).length === 1) return selector;
+	}
+	return null;
+}
+function nthSegment(el) {
+	const tag = el.tagName.toLowerCase();
+	const parent = el.parentElement;
+	if (!parent) return tag;
+	const sameTag = [...parent.children].filter((c) => c.tagName === el.tagName);
+	return sameTag.length > 1 ? `${tag}:nth-of-type(${sameTag.indexOf(el) + 1})` : tag;
+}
+/**
+* Stable CSS path for an element: ids > stable data attributes > an
+* nth-of-type chain. Guaranteed round-trip: querySelector(buildSelector(el)) === el.
+*/
+function buildSelector(el) {
+	const doc = el.ownerDocument;
+	const segments = [];
+	let node = el;
+	while (node && node !== doc.documentElement) {
+		const id = node.getAttribute("id");
+		if (id && SAFE_ID.test(id) && doc.querySelectorAll(`#${id}`).length === 1) {
+			segments.unshift(`#${id}`);
+			return segments.join(" > ");
+		}
+		const byAttr = attrSegment(node, doc);
+		if (byAttr) {
+			segments.unshift(byAttr);
+			return segments.join(" > ");
+		}
+		segments.unshift(nthSegment(node));
+		node = node.parentElement;
+	}
+	return segments.join(" > ");
+}
+//#endregion
+//#region src/capture.ts
+/** Curated computed-style subset — enough to reconstruct layout intent, tiny on the wire. */
+const STYLE_KEYS = [
+	"display",
+	"position",
+	"font-size",
+	"color",
+	"background-color",
+	"margin",
+	"padding",
+	"overflow"
+];
+const NEARBY_TEXT_MAX = 160;
+function styleSubset(win, el) {
+	let cs;
+	try {
+		cs = win.getComputedStyle(el);
+	} catch {
+		return;
+	}
+	const out = {};
+	for (const key of STYLE_KEYS) {
+		const value = cs.getPropertyValue(key);
+		if (value !== "") out[key] = value;
+	}
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function ariaMap(el) {
+	const out = {};
+	for (const name of el.getAttributeNames()) if (name.startsWith("aria-")) out[name] = el.getAttribute(name) ?? "";
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function nearbyText(el) {
+	const text = (el.textContent ?? "").replace(/\s+/g, " ").trim();
+	return text === "" ? void 0 : text.slice(0, NEARBY_TEXT_MAX);
+}
+/** The user's selection, only when it intersects the captured element. */
+function selectedText(win, el) {
+	try {
+		const sel = win.getSelection?.();
+		if (!sel || sel.isCollapsed || sel.rangeCount === 0) return void 0;
+		if (!sel.getRangeAt(0).intersectsNode(el)) return void 0;
+		const text = sel.toString().trim();
+		return text === "" ? void 0 : text;
+	} catch {
+		return;
+	}
+}
+/** `fixed` detected via ancestry: any ancestor with computed position: fixed. */
+function isFixed(win, el) {
+	for (let node = el; node !== null; node = node.parentElement) try {
+		if (win.getComputedStyle(node).position === "fixed") return true;
+	} catch {
+		return false;
+	}
+	return false;
+}
+/** Beyond this an element is not a thing you pinned, it is a region. Too many to rewrite as a set. */
+const MAX_RUNS = 40;
+const MAX_RUN_LENGTH = 200;
+/** Text that is not content: a script body or a stylesheet is not something to rewrite. */
+const NON_CONTENT = /* @__PURE__ */ new Set([
+	"SCRIPT",
+	"STYLE",
+	"NOSCRIPT",
+	"TEMPLATE"
+]);
+/**
+* The element's text, split the way the browser stores it: one entry per run of characters.
+*
+* This walks TEXT NODES, not elements, and that distinction is the whole point — it makes no
+* assumption about how a site is built. A heading is one run. A nav bar is one per link. A
+* paragraph with a bold word in the middle is three, in reading order, including the halves either
+* side of the bold. An earlier version keyed off "elements with no element children", which
+* quietly lost the "Hello " in `<p>Hello <b>world</b></p>` — text a person can obviously see and
+* would obviously expect to be able to change.
+*
+* `nearbyText` runs them all together, which is fine to read and useless to edit: it cannot tell
+* an agent that "work approach people contact" is four separate places. This can.
+*/
+function textRuns(el) {
+	const runs = [];
+	const walk = (node) => {
+		if (node.nodeType === 3) {
+			const text = (node.nodeValue ?? "").trim();
+			if (text.length > 0) runs.push(text.slice(0, MAX_RUN_LENGTH));
+			return runs.length <= MAX_RUNS;
+		}
+		if (node.nodeType !== 1 || NON_CONTENT.has(node.tagName)) return true;
+		for (const child of node.childNodes) if (!walk(child)) return false;
+		return true;
+	};
+	if (!walk(el) || runs.length === 0) return void 0;
+	return runs;
+}
+function buildContext(win, el) {
+	const context = {};
+	if (el.classList.length > 0) context.classes = [...el.classList];
+	const styles = styleSubset(win, el);
+	if (styles !== void 0) context.styles = styles;
+	const aria = ariaMap(el);
+	if (aria !== void 0) context.aria = aria;
+	const nearby = nearbyText(el);
+	if (nearby !== void 0) context.nearbyText = nearby;
+	const selected = selectedText(win, el);
+	if (selected !== void 0) context.selectedText = selected;
+	const runs = textRuns(el);
+	if (runs !== void 0) context.textRuns = runs;
+	return Object.keys(context).length > 0 ? context : void 0;
+}
+/** Fills PinInput.target/env from a chosen element (shapes come from the pin schema). */
+function captureTarget(el, opts) {
+	const win = el.ownerDocument.defaultView;
+	const r = el.getBoundingClientRect();
+	const target = {
+		url: win.location.href,
+		selector: buildSelector(el),
+		tag: el.tagName.toLowerCase(),
+		rect: {
+			x: r.left + win.scrollX,
+			y: r.top + win.scrollY,
+			width: r.width,
+			height: r.height
+		},
+		fixed: isFixed(win, el)
+	};
+	if (opts?.anchor !== void 0) target.anchor = opts.anchor;
+	if (opts?.at !== void 0 && r.width > 0 && r.height > 0) {
+		const fx = (opts.at.x - (r.left + win.scrollX)) / r.width;
+		const fy = (opts.at.y - (r.top + win.scrollY)) / r.height;
+		if (fx >= 0 && fx <= 1 && fy >= 0 && fy <= 1) target.spot = {
+			x: fx,
+			y: fy
+		};
+	}
+	const context = buildContext(win, el);
+	if (context !== void 0) target.context = context;
+	return {
+		target,
+		env: {
+			viewport: {
+				w: win.innerWidth,
+				h: win.innerHeight,
+				dpr: win.devicePixelRatio
+			},
+			browser: win.navigator.userAgent,
+			os: win.navigator.platform || "unknown",
+			colorScheme: win.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light"
+		}
+	};
+}
+//#endregion
+//#region src/model-target.ts
+const projectors = /* @__PURE__ */ new WeakMap();
+function registerModelProjection(doc, project) {
+	const set = projectors.get(doc) ?? /* @__PURE__ */ new Set();
+	const entry = (anchor) => project(anchor);
+	set.add(entry);
+	projectors.set(doc, set);
+	return () => {
+		set.delete(entry);
+		if (!set.size) projectors.delete(doc);
+	};
+}
+function projectModelTarget(doc, anchor) {
+	for (const project of projectors.get(doc) ?? []) {
+		const p = project(anchor);
+		if (p && Number.isFinite(p.x) && Number.isFinite(p.y)) return {
+			x: p.x,
+			y: p.y,
+			width: 0,
+			height: 0
+		};
+	}
+	return null;
+}
+//#endregion
+export { targetLabel as a, captureKey as c, hitTest as i, loadCaptureMode as l, registerModelProjection as n, registerModelCapture as o, captureTarget as r, toggleToolbarCapture as s, projectModelTarget as t };

package/dist/model.d.ts

@@ -0,0 +1,52 @@
+import { f as PinboxToolbarElement } from "./index-CMSOhoVs.js";
+import { ModelAnchor, ModelAnchor as ModelAnchor$1, Pin } from "@autono/pinbox-core/schema";
+//#region src/model-target.d.ts
+type ModelProjection = (anchor: ModelAnchor$1) => {
+  x: number;
+  y: number;
+} | null;
+//#endregion
+//#region src/model-ui.d.ts
+type ModelViewerAdapter = {
+  /** Canvas or element containing the model. DOM pins outside it keep working. */
+  surface: HTMLElement;
+  /** Raycast a viewport point; return a part-local anchor, or null for empty space. */
+  pick: (clientX: number, clientY: number) => ModelAnchor$1 | null;
+  /** Project to viewport CSS pixels. Null for a stale, hidden or occluded anchor. */
+  project: ModelProjection;
+  /** Called each update in pin mode, or null when the hover clears. */
+  onHover?: (anchor: ModelAnchor$1 | null) => void;
+  /** Filter activation for multiple viewers; may accept older revisions for loading. */
+  acceptsAnchor?: (anchor: ModelAnchor$1) => boolean;
+  /** Animate/load a pin view. Stop stale asynchronous work when signal is aborted. */
+  onActivate?: (anchor: ModelAnchor$1, pin: Pin, context: {
+    signal: AbortSignal;
+  }) => void | Promise<void>;
+  /** Camera button and S action. Host owns capture, preview, save and chat/storage UI. */
+  onCapture?: () => void | Promise<void>;
+  onError?: (error: unknown) => void;
+};
+/** Connect the real Pinbox toolbar, draft card and needle markers to a 3D viewer.
+ * Call update() after rendering a frame. Destroy before removing the viewer. */
+declare function attachModelViewer(toolbar: PinboxToolbarElement, adapter: ModelViewerAdapter): {
+  openPin: (id: string) => Promise<void>;
+  update(): void;
+  destroy(): void;
+};
+//#endregion
+//#region src/model.d.ts
+type ModelScene = {
+  modelId: string;
+  revision: string;
+  /** Column-major 4x4 object-to-world matrix (e.g. Three.js matrixWorld.elements). */
+  partMatrix: (partId: string) => readonly number[] | undefined;
+};
+type AnchorResolution = {
+  status: "visible";
+  worldPosition: [number, number, number];
+} | {
+  status: "stale" | "missing";
+};
+declare function resolveModelAnchor(anchor: ModelAnchor, scene: ModelScene): AnchorResolution;
+//#endregion
+export { AnchorResolution, type ModelAnchor, ModelScene, type ModelViewerAdapter, attachModelViewer, resolveModelAnchor };

package/dist/model.js

@@ -0,0 +1,182 @@
+import { n as registerModelProjection, o as registerModelCapture, r as captureTarget } from "./model-target-BykKL8H5.js";
+//#region src/model-hooks.ts
+/** Renderer callbacks stay separate from placement and marker projection. */
+function attachModelHooks(toolbar, adapter) {
+	const surface = adapter.surface, win = surface.ownerDocument.defaultView;
+	if (!win) throw new Error("The model surface must belong to a browser document");
+	const error = adapter.onError ?? ((cause) => console.error("Pinbox model hook failed", cause));
+	const capture = adapter.onCapture ? registerModelCapture(toolbar, adapter.onCapture, error) : void 0;
+	let point, hovering = false, disposed = false;
+	let active = null, controller;
+	let activation = Promise.resolve();
+	const clear = () => {
+		point = void 0;
+		if (hovering) {
+			hovering = false;
+			adapter.onHover?.(null);
+		}
+	};
+	const move = (event) => {
+		if (!event.composedPath().includes(surface)) {
+			clear();
+			return;
+		}
+		point = {
+			x: event.clientX,
+			y: event.clientY
+		};
+		capture?.activate();
+	};
+	const focus = () => capture?.activate();
+	const activate = (pin) => {
+		controller?.abort();
+		controller = new AbortController();
+		const signal = controller.signal, anchor = pin.target?.model;
+		if (!anchor || !adapter.onActivate || adapter.acceptsAnchor && !adapter.acceptsAnchor(anchor)) return Promise.resolve();
+		try {
+			return Promise.resolve(adapter.onActivate(anchor, pin, { signal })).catch((cause) => {
+				if (!signal.aborted) error(cause);
+			});
+		} catch (cause) {
+			error(cause);
+			return Promise.resolve();
+		}
+	};
+	const unsubscribe = toolbar.store.subscribe((state) => {
+		if (state.mode !== "placing" && hovering) {
+			hovering = false;
+			adapter.onHover?.(null);
+		}
+		if (active === state.activePinId) return;
+		const pin = state.pins.find((p) => p.id === state.activePinId);
+		if (state.activePinId && !pin) return;
+		active = state.activePinId;
+		controller?.abort();
+		if (pin) activation = activate(pin);
+	});
+	win.addEventListener("pointermove", move, true);
+	win.addEventListener("blur", clear);
+	surface.addEventListener("pointerleave", clear);
+	surface.addEventListener("pointerdown", focus, true);
+	return {
+		update() {
+			if (disposed || !adapter.onHover || !point || toolbar.store.get().mode !== "placing") return;
+			try {
+				const anchor = adapter.pick(point.x, point.y);
+				hovering = anchor !== null;
+				adapter.onHover(anchor);
+			} catch (cause) {
+				clear();
+				error(cause);
+			}
+		},
+		async openPin(id) {
+			if (disposed) return;
+			const pin = toolbar.store.get().pins.find((p) => p.id === id);
+			if (!pin) throw new Error("Pin not found.");
+			if (active === id) activation = activate(pin);
+			toolbar.store.update({
+				mode: "idle",
+				activePinId: id,
+				pinsHidden: false
+			});
+			await activation;
+		},
+		destroy() {
+			if (disposed) return;
+			disposed = true;
+			controller?.abort();
+			unsubscribe();
+			clear();
+			capture?.destroy();
+			win.removeEventListener("pointermove", move, true);
+			win.removeEventListener("blur", clear);
+			surface.removeEventListener("pointerleave", clear);
+			surface.removeEventListener("pointerdown", focus, true);
+		}
+	};
+}
+//#endregion
+//#region src/model-ui.ts
+/** Connect the real Pinbox toolbar, draft card and needle markers to a 3D viewer.
+* Call update() after rendering a frame. Destroy before removing the viewer. */
+function attachModelViewer(toolbar, adapter) {
+	const doc = adapter.surface.ownerDocument, win = doc.defaultView;
+	if (!win) throw new Error("The model surface must belong to a browser document");
+	const unregister = registerModelProjection(doc, adapter.project);
+	const hooks = attachModelHooks(toolbar, adapter);
+	let down;
+	const pointerDown = (e) => {
+		if (e.composedPath().includes(adapter.surface)) down = {
+			x: e.clientX,
+			y: e.clientY
+		};
+	};
+	const click = (e) => {
+		if (toolbar.store.get().mode !== "placing" || e.composedPath().includes(toolbar) || !e.composedPath().includes(adapter.surface)) return;
+		e.preventDefault();
+		e.stopImmediatePropagation();
+		if (down && Math.hypot(e.clientX - down.x, e.clientY - down.y) > 5) {
+			down = void 0;
+			return;
+		}
+		down = void 0;
+		const model = adapter.pick(e.clientX, e.clientY);
+		if (!model) return;
+		const at = {
+			x: e.clientX + win.scrollX,
+			y: e.clientY + win.scrollY
+		};
+		const captured = captureTarget(adapter.surface, { at });
+		captured.target.model = model;
+		captured.target.anchor = `3D · ${model.partId}`;
+		delete captured.target.spot;
+		toolbar.store.place({
+			target: captured,
+			placedAt: at
+		});
+	};
+	win.addEventListener("pointerdown", pointerDown, true);
+	win.addEventListener("click", click, true);
+	let destroyed = false;
+	return {
+		openPin: hooks.openPin,
+		update() {
+			if (destroyed || !toolbar.isConnected) return;
+			hooks.update();
+			const s = toolbar.store.get();
+			if (s.pins.some((p) => p.target?.model) || s.draft?.target.target.model) toolbar.store.update({ clock: s.clock });
+		},
+		destroy() {
+			if (destroyed) return;
+			destroyed = true;
+			hooks.destroy();
+			unregister();
+			win.removeEventListener("pointerdown", pointerDown, true);
+			win.removeEventListener("click", click, true);
+		}
+	};
+}
+//#endregion
+//#region src/model.ts
+function resolveModelAnchor(anchor, scene) {
+	if (anchor.modelId !== scene.modelId || anchor.revision !== scene.revision) return { status: "stale" };
+	const values = scene.partMatrix(anchor.partId);
+	if (values?.length !== 16 || !values.every(Number.isFinite)) return { status: "missing" };
+	const m = values;
+	const [x, y, z] = anchor.position;
+	const w = m[3] * x + m[7] * y + m[11] * z + m[15];
+	if (!Number.isFinite(w) || Math.abs(w) < 1e-12) return { status: "missing" };
+	const worldPosition = [
+		(m[0] * x + m[4] * y + m[8] * z + m[12]) / w,
+		(m[1] * x + m[5] * y + m[9] * z + m[13]) / w,
+		(m[2] * x + m[6] * y + m[10] * z + m[14]) / w
+	];
+	if (!worldPosition.every(Number.isFinite)) return { status: "missing" };
+	return {
+		status: "visible",
+		worldPosition
+	};
+}
+//#endregion
+export { attachModelViewer, resolveModelAnchor };

package/dist/{options-CNqXqkp9.d.ts → options-DPsmmgra.d.ts}

@@ -3,6 +3,10 @@
 interface PinboxPluginOptions {
   /** Explicit hub base URL. When set, `.pinbox/server.json` discovery is skipped entirely. */
   hub?: string;
+  /** Vite only: show registered local worktree previews. Opt-in, dev-only. */
+  previews?: boolean;
+  /** Local CLI executable used for preview discovery. Defaults to pinbox on PATH. */
+  previewExecutable?: string;
   /** Directory containing `.pinbox/server.json`. Defaults to `process.cwd()`. */
   projectRoot?: string;
   /** Spawn `pinbox serve` when no healthy hub is found. Defaults to true. */

package/dist/plugins/next.d.ts

@@ -1,4 +1,4 @@
-import { t as PinboxPluginOptions } from "../options-CNqXqkp9.js";
+import { t as PinboxPluginOptions } from "../options-DPsmmgra.js";
 //#region src/plugins/next.d.ts
 /**
  * Structural stand-in for Next's `NextConfig`.

package/dist/plugins/vite.d.ts

@@ -1,4 +1,4 @@
-import { t as PinboxPluginOptions } from "../options-CNqXqkp9.js";
+import { t as PinboxPluginOptions } from "../options-DPsmmgra.js";
 import { Plugin } from "vite";
 //#region src/plugins/vite.d.ts
 /**