@weasel-js/labkit 1.4.0 → 1.4.2

package/dist/job/index.js

@@ -1,3 +1,3 @@
-export { useJob } from '../chunk-LN6JDUGB.js';
+export { useJob } from '../chunk-HXXTULDN.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/layers/index.d.ts

@@ -1,24 +1,39 @@
-import { E as LayerDescriptor } from '../_dts/frac-QS7XzvpG.js';
-export { B as LayerCapability } from '../_dts/frac-QS7XzvpG.js';
+import { E as LayerDescriptor } from '../_dts/frac-A4R6v4ld.js';
+export { B as LayerCapability } from '../_dts/frac-A4R6v4ld.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import 'react';
-import '../_dts/types-C1Zw7s5P.js';
-import '../_dts/PrefsForm-BkUJZx0A.js';
-import '../_dts/types-ChVJJHvk.js';
+import '../_dts/types-lg4TSCb2.js';
+import '../_dts/weasel-canvas-FJTFi3ZZ.js';
+import '../_dts/PrefsForm.d-CgxUequc.js';
+import '../_dts/types-BbXpvQa8.js';
 import '../_dts/types-DJ79Tg5J.js';
-import '../_dts/types-C-gh9Ap-.js';
 
+/** A layer that may itself contain layers. A plain `LayerDescriptor` is one
+ *  of these with no children, so a flat list needs no change. */
+interface LayerTreeNode extends LayerDescriptor {
+    children?: LayerTreeNode[];
+    /** Render this node's children hidden on first paint. Ignored once
+     *  `collapsedIds` is supplied. */
+    defaultCollapsed?: boolean;
+}
 /** Props for `<LayerList>`. */
 interface LayerListProps {
-    layers: LayerDescriptor[];
+    layers: LayerTreeNode[];
     visibility: Record<string, boolean>;
-    onReorder: (newOrder: LayerDescriptor[]) => void;
+    /** The whole tree, with the dragged node moved. Reordering is scoped to a
+     *  node's siblings: a drag never changes which parent a layer sits under. */
+    onReorder: (newOrder: LayerTreeNode[]) => void;
     onToggle: (id: string, visible: boolean) => void;
+    /** Ids whose children are hidden. Supplying it makes collapse controlled;
+     *  without it the list keeps its own, seeded from `defaultCollapsed`. */
+    collapsedIds?: readonly string[];
+    onCollapsedChange?: (ids: string[]) => void;
     className?: string;
 }
 /** A reorderable list of layers with per-layer visibility toggles. Layers
- *  marked `alwaysOn` are pinned and cannot be reordered or hidden. */
-declare function LayerList({ layers, visibility, onReorder, onToggle, className }: LayerListProps): react_jsx_runtime.JSX.Element;
+ *  marked `alwaysOn` are pinned and cannot be reordered or hidden. Layers with
+ *  `children` render as an expandable subtree. */
+declare function LayerList({ layers, visibility, onReorder, onToggle, collapsedIds, onCollapsedChange, className, }: LayerListProps): react_jsx_runtime.JSX.Element;
 
 export { LayerDescriptor, LayerList };
-export type { LayerListProps };
+export type { LayerListProps, LayerTreeNode };

package/dist/layers/index.js

@@ -1,6 +1,6 @@
-export { LayerList } from '../chunk-XCBCZEBO.js';
+export { LayerList } from '../chunk-NSOVI3AZ.js';
 import '../chunk-SBXNQW4G.js';
-import '../chunk-L5WBGUVR.js';
-import '../chunk-7VW3S44V.js';
+import '../chunk-ISSVF5PT.js';
+import '../chunk-54ZWZ5FQ.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/loupe/index.d.ts

@@ -1,19 +1,13 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ae as LoupeMode, V as ViewTransform, W as WorldFrame, c as WorldSpec, a2 as ViewportSize, K as LoupeRenderArgs, N as ResolvedLoupe } from '../_dts/frac-QS7XzvpG.js';
-export { L as LOUPE_DEFAULTS, G as LoupeCapability, J as LoupeDeclaration, ab as resolveLoupe } from '../_dts/frac-QS7XzvpG.js';
-import { c as CanvasStackSurface, C as CanvasLayerDescriptor } from '../_dts/CanvasStackContext-D6M0o8cQ.js';
+import { ae as LoupePoint, af as LoupeMode, V as ViewTransform, W as WorldFrame, c as WorldSpec, a2 as ViewportSize, K as LoupeRenderArgs, N as ResolvedLoupe } from '../_dts/frac-A4R6v4ld.js';
+export { L as LOUPE_DEFAULTS, G as LoupeCapability, J as LoupeDeclaration, ab as resolveLoupe } from '../_dts/frac-A4R6v4ld.js';
+import { c as CanvasStackSurface, C as CanvasLayerDescriptor } from '../_dts/CanvasStackContext-kjILVnPj.js';
 import { RefObject, ReactNode } from 'react';
-import '../_dts/types-C1Zw7s5P.js';
-import '../_dts/PrefsForm-BkUJZx0A.js';
-import '../_dts/types-ChVJJHvk.js';
+import '../_dts/types-lg4TSCb2.js';
+import '../_dts/weasel-canvas-FJTFi3ZZ.js';
+import '../_dts/PrefsForm.d-CgxUequc.js';
+import '../_dts/types-BbXpvQa8.js';
 import '../_dts/types-DJ79Tg5J.js';
-import '../_dts/types-C-gh9Ap-.js';
-
-/** A point on the magnified surface, in its own CSS pixels. */
-interface LoupePoint {
-    x: number;
-    y: number;
-}
 
 /** Props for `<CanvasLoupe>`. */
 interface CanvasLoupeProps {

package/dist/loupe/index.js

@@ -1,7 +1,7 @@
-export { CanvasLoupe, DomLoupe, LOUPE_DEFAULTS, LoupeBubble, TrialLoupe, drawCanvasLens, lensCamera, lensSourceRect, resolveLoupe, sampleStack, useLoupe } from '../chunk-Y2HK44TG.js';
+export { CanvasLoupe, DomLoupe, LOUPE_DEFAULTS, LoupeBubble, TrialLoupe, drawCanvasLens, lensCamera, lensSourceRect, resolveLoupe, sampleStack, useLoupe } from '../chunk-D5KQ5OY6.js';
 import '../chunk-CTRKTLYZ.js';
 import '../chunk-2AYGEN57.js';
 import '../chunk-CQLQPQ4P.js';
-import '../chunk-7VW3S44V.js';
+import '../chunk-54ZWZ5FQ.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/passthrough/weasel-canvas.d.ts

@@ -1,343 +1,3 @@
-import { N as Node, P as Path, S as Scene } from '../_dts/types-C-gh9Ap-.js';
-import { V as View, D as DrawCommand, P as PathDrawCommand } from '../_dts/DrawCommand-B3bskUsC.js';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { Ref } from 'react';
-import { B as Bounds, V as ViewportDims } from '../_dts/fitViewToBounds-dZ2UDB6e.js';
-
-/**
- * NodeShape — the **shape trait's** registry. Each trait of a node
- * (shape, routing, label, icon, affordances, …) is its own registry;
- * this one holds the per-kind `paint` + `silhouette` (and future
- * fields) used by `defaultDrawOne`, clipping, non-rect hit-testing,
- * and lasso/area-select.
- *
- * Teaching the kit about a new kind of shape goes through this registry
- * rather than by overriding `drawOne`. Overrides are still possible but
- * shouldn't be the default seam: most consumers want the same dispatch
- * logic, just extended with their own shape kinds (images, custom paths,
- * SVG fragments, etc.).
- *
- * Built-in entries (`kit:text`, `kit:path`, `kit:rect-fallback`) are
- * registered at module load. Consumer entries added via
- * `registerNodeShape` join the chain; the first entry whose
- * `matches` predicate returns true paints the node.
- *
- * Two priority tiers:
- *   - `'high'` — checked before all `'normal'` entries. Use this to
- *     override a kit built-in for a specific data shape (e.g. a custom
- *     text renderer that wins over `kit:text`).
- *   - `'normal'` (default) — appended after the built-ins.
- *
- * Within a tier, entries run in registration order. Each
- * `registerNodeShape` call returns a disposer that removes the
- * entry — useful for tests, for plugin lifecycles, and for swapping
- * implementations at runtime.
- *
- * See `docs/superpowers/specs/2026-05-24-node-traits-reframe-design.md`
- * for the trait taxonomy.
- */
-
-/** Optional per-call paint context, threaded through `defaultDrawOne`'s third
- *  argument. Lets a rendering entry point override ambient environment reads
- *  — the headless `renderSceneToPixels` path supplies its own bitmap resolver
- *  here so consumers reuse their own decode caches. Custom painters may
- *  ignore it entirely. */
-interface NodePaintCtx {
-    /** Override bitmap resolution for image nodes. When set it is authoritative:
-     *  the global `imageCache` is not consulted, and an `undefined` result
-     *  paints the deterministic grey placeholder outline (never the ambient
-     *  load-status error variant). */
-    resolveImage?: (node: Node<unknown, string, unknown>) => ImageBitmap | undefined;
-    /** The node's derived path, resolved by the scene-aware `drawOne` wrapper
-     *  before painting: `paint` has no scene handle, and deriving needs the
-     *  dependencies' poses. **Absent** for a node that derives from nothing —
-     *  the wrapper hands such a node the caller's own ctx untouched. `null`
-     *  means the node derives but has nothing to draw. */
-    derivedPath?: Path | null;
-}
-/**
- * Per-node draw function — the scene-slot `drawOne` signature shared by
- * `<SceneCanvas>`, `renderSceneToCanvas` and `renderSceneToPixels`, so a
- * consumer can reuse one callback across a main canvas and a detached view.
- *
- * Called once per node in the walk. Returned commands are world-space; the
- * caller applies the view transform at the group level. `ctx` is supplied by
- * the scene-aware wrappers — see {@link NodePaintCtx}.
- */
-type SceneViewDrawOne<TData, TLayer extends string, TPose> = (node: Node<TData, TLayer, TPose>, pose: TPose, view: View, ctx?: NodePaintCtx) => DrawCommand[];
-
-/**
- * `renderSceneToCanvas` — substrate for detached, read-only scene views
- * (`<SceneViewCanvas>` / `<MinimapCanvas>`). Given a `<canvas>`, a `Scene`,
- * a `View`, and a per-node `drawOne`, render one frame.
- *
- * Step 1 of the detached-minimap spec
- * (`docs/superpowers/specs/2026-05-31-detached-minimap-design.md`). The full
- * `<SceneCanvas>` render pipeline does much more than this (slots, layer
- * ordering, debug sinks, tool overlays). The helper deliberately re-implements
- * the small subset needed for a non-interactive scene view rather than
- * refactoring `<SceneCanvas>` to share code — the spec calls for that
- * dedupe as a follow-up.
- *
- * Note: this duplicates `<SceneCanvas>`'s GL setup + view-wrap pattern in
- * miniature. When `<SceneCanvas>` is eventually migrated onto this helper,
- * the duplication collapses; until then, keep the two render paths
- * in sync by hand where it matters (DPR handling, viewToMat3 wrap).
- */
-
-/** What to draw into an existing canvas: the scene, the view, and the same
- *  painting hooks `<SceneCanvas>` takes. */
-interface RenderSceneToCanvasArgs<TData, TLayer extends string, TPose> {
-    /** The DOM canvas to paint into. The helper owns its WebGL2 context: the
-     *  first call on a given canvas creates a renderer and stashes it; subsequent
-     *  calls reuse the same renderer (and resize the drawing buffer on dim
-     *  changes). */
-    canvas: HTMLCanvasElement;
-    /** Scene to walk. `scene.renderOrder()` provides the per-node order. */
-    scene: Scene<TData, TLayer, TPose>;
-    /** Camera view applied to scene + extras (both ride the same world→screen
-     *  transform; extras living in screen space should be supplied via a
-     *  separately-prepared `extraCommands` group or rendered outside this
-     *  helper). */
-    view: View;
-    /** CSS-pixel size. The drawing buffer is set to `width × dpr` and
-     *  `height × dpr`; CSS size to `width` / `height`. */
-    width: number;
-    height: number;
-    /** Per-node draw callback. */
-    drawOne: SceneViewDrawOne<TData, TLayer, TPose>;
-    /** Optional commands appended after the scene-node output. Used for the
-     *  minimap's visible-window indicator. Wrapped in the same view transform
-     *  as scene commands. */
-    extraCommands?: DrawCommand[];
-    /** Optional per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot
-     *  `alphaFor`. Pass the same function the main canvas uses to keep a
-     *  scoping-dim treatment consistent across both. Defaults to `() => 1`. */
-    alphaFor?: (id: string) => number;
-    /** Optional device-pixel ratio. Defaults to `window.devicePixelRatio || 1`
-     *  when available, otherwise 1. Tests typically pin this to 1 or 2. */
-    dpr?: number;
-}
-/**
- * Build the DrawCommand list that `renderSceneToCanvas` would dispatch.
- *
- * Pure — no GL, no DOM, no side effects. Walks the scene through
- * `buildSceneTree` — the same walk `<SceneCanvas>`'s `buildSceneLayer` uses —
- * appends any `extraCommands`, and wraps the result in a single
- * `{ kind: 'group', transform: viewToMat3(view) }` so the output is in screen
- * space. Sharing the walk is what keeps hidden layers unpainted and container
- * clips applied here; a hand-rolled `renderOrder()` loop silently dropped both.
- *
- * Each node's commands additionally go through `wrapNodeOutput` — pose
- * rotation, then the `alphaFor` multiplier — exactly as `buildSceneLayer`
- * does, so a `drawOne` shared between the two paints the same thing in both.
- * A `drawOne` that rotates its own output will therefore rotate twice here;
- * emit unrotated geometry and let the pose drive it.
- *
- * Output shape follows `buildSceneTree`: one group per **visible** layer, in
- * scene-layer order, each holding one group per node on that layer.
- *
- * Exported for tests and for callers that want to render into something
- * other than a real `<canvas>` (e.g. an offscreen renderer or a
- * snapshot fixture).
- */
-declare function buildSceneViewCommands<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, view: View, drawOne: SceneViewDrawOne<TData, TLayer, TPose>, extraCommands?: ReadonlyArray<DrawCommand>, alphaFor?: (id: string) => number): DrawCommand[];
-/**
- * Render one frame of `scene` at `view` into `canvas`. See module docstring
- * for the design context.
- *
- * Idempotent at the GL-context level: on first call a `WeaselRenderer` is
- * constructed against the canvas's WebGL2 context and cached in a
- * module-level WeakMap keyed by the canvas element. Subsequent calls reuse
- * that renderer. When `width` / `height` / `dpr` change between calls, the
- * renderer's `resize` is invoked (which also updates the canvas's `width` /
- * `height` attributes and CSS `style.width` / `style.height`).
- *
- * Returns `void`. If the underlying environment can't supply a WebGL2 context
- * (e.g. jsdom in tests), the call is a silent no-op — mirroring `<Canvas>`'s
- * `getContext` bail-out (`Canvas.tsx` line ~1445).
- */
-declare function renderSceneToCanvas<TData, TLayer extends string, TPose>(args: RenderSceneToCanvasArgs<TData, TLayer, TPose>): void;
-
-/** Props for `<SceneViewCanvas>`. */
-interface SceneViewCanvasProps<TData, TLayer extends string, TPose> {
-    /** Scene to render. Must be the same `Scene` instance passed to whoever
-     *  is mutating it; the component subscribes to its version stream and
-     *  repaints when the version advances. */
-    scene: Scene<TData, TLayer, TPose>;
-    /** Camera. Applied to scene + `extraCommands` via the renderer's group
-     *  transform. */
-    view: View;
-    /** CSS-pixel width. Drives both layout (via the rendered drawing-buffer
-     *  size) and the renderer's coordinate space. */
-    width: number;
-    /** CSS-pixel height. */
-    height: number;
-    /** Per-node draw callback. See `SceneViewDrawOne`. The consumer is
-     *  responsible for what gets painted — there is no AABB-fill default. */
-    drawOne: SceneViewDrawOne<TData, TLayer, TPose>;
-    /** Optional extra commands appended after scene commands, inside the same
-     *  view transform. Used by `<MinimapCanvas>` for its visible-window
-     *  indicator; available to other consumers that want to overlay a
-     *  world-space annotation. */
-    extraCommands?: ReadonlyArray<DrawCommand>;
-    /** Optional per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot
-     *  `alphaFor`. Pass the same function the main canvas uses to keep a
-     *  scoping-dim treatment consistent across both. Defaults to `() => 1`. */
-    alphaFor?: (id: string) => number;
-    /** Optional CSS class for sizing / positioning the `<canvas>`. The kit
-     *  does not emit inline styles for layout — use a class. */
-    className?: string;
-    /** Forwarded ref to the underlying `<canvas>`. Consumers attach their own
-     *  pointer listeners or call `toBlob` for snapshots through this. */
-    canvasRef?: Ref<HTMLCanvasElement>;
-}
-declare function SceneViewCanvasInner<TData, TLayer extends string, TPose>(props: SceneViewCanvasProps<TData, TLayer, TPose>): react_jsx_runtime.JSX.Element;
-/**
- * Pointer-inert read-only scene view. See `SceneViewCanvasProps` for the
- * full surface and the module docstring for the rendering model.
- *
- * `forwardRef` is not used because the component is generic over `<TData,
- * TLayer, TPose>` and React's `forwardRef` erases generics. The
- * `canvasRef` prop is the plain-prop equivalent (the spec calls it out as
- * the public surface).
- */
-declare const SceneViewCanvas: typeof SceneViewCanvasInner;
-
-/**
- * Pure math helpers for `<MinimapCanvas>`.
- *
- * `computeFitView` derives a `View` that fits a chosen world rect into a
- * minimap canvas of given pixel dims. `computeIndicatorCommand` builds the
- * dashed "visible window" rect — the main canvas's screen window projected
- * into the minimap's own screen coordinates.
- *
- * Neither helper touches GL, the DOM, or the renderer; they're pure
- * functions, unit-testable with `expect`.
- *
- * See `docs/superpowers/specs/2026-05-31-detached-minimap-design.md`.
- */
-
-/**
- * Fallback view returned when there is nothing to fit (empty scene, etc.).
- * Identity view at the origin — produces a 1:1 mapping centered on (0, 0).
- */
-declare const FALLBACK_FIT_VIEW: View;
-/**
- * Fit policy for `<MinimapCanvas>` / `computeFitView`.
- *
- * - `"scene"` — union of leaf-node pose AABBs (via `poseBounds`).
- * - `{ kind: "world", rect }` — caller-supplied world rect.
- * - `(scene, dims) => View` — caller derives the view directly.
- */
-type MinimapFit<TData, TLayer extends string, TPose> = 'scene' | {
-    kind: 'world';
-    rect: Bounds;
-} | ((scene: Scene<TData, TLayer, TPose>, dims: ViewportDims) => View);
-/** Style for the visible-window indicator rect drawn over the minimap. */
-interface IndicatorStyle {
-    /** Stroke color (any CSS color). Defaults to `'#ffffff'`. */
-    stroke?: string;
-    /** Stroke width in CSS px. Defaults to `1`. */
-    width?: number;
-    /** Dash pattern in CSS px. Defaults to `[2, 3]`. */
-    dash?: number[];
-}
-/** Options for {@link computeFitView}. */
-interface ComputeFitViewOptions {
-    /** Inset (CSS px) around the fit rect on each side. Defaults to `8`. */
-    padding?: number;
-}
-/**
- * Derive a `View` that fits the chosen world rect into a minimap of
- * `dims.width × dims.height` CSS px. Uniform scale on both axes; the rect
- * is centered with `padding` (default 8) on each side. The smaller-axis
- * fit ratio wins, so the whole rect is visible.
- *
- * - `fit === "scene"`: union AABB of leaf-node poses via `poseBounds`.
- *   Empty scene → {@link FALLBACK_FIT_VIEW}.
- * - `fit` is `{ kind: "world", rect }`: fit `rect`. A degenerate rect
- *   (zero or negative area) falls back to identity scale centered on the
- *   rect's top-left — we don't divide by zero.
- * - `fit` is a function: called with `(scene, dims)`; its return is
- *   passed through unchanged.
- */
-declare function computeFitView<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, dims: ViewportDims, fit: MinimapFit<TData, TLayer, TPose>, poseBounds: (pose: TPose) => Bounds, opts?: ComputeFitViewOptions): View;
-/**
- * Build the visible-window indicator `DrawCommand` for the minimap.
- *
- * The main canvas's visible world rect is:
- * ```
- * worldX = mainView.x
- * worldY = mainView.y
- * worldW = mainViewDims.width  / mainView.scale.x
- * worldH = mainViewDims.height / mainView.scale.y
- * ```
- * That world rect is then transformed into the minimap's screen
- * coordinates through `minimapView`.
- *
- * The returned command is a dashed-stroke `path` rect with no fill —
- * matching the `ViewportLayerDemo` indicator math.
- */
-declare function computeIndicatorCommand(mainView: View, mainViewDims: ViewportDims, style?: IndicatorStyle): PathDrawCommand;
-
-/** Props for `<MinimapCanvas>`. */
-interface MinimapCanvasProps<TData, TLayer extends string, TPose> {
-    /** Same scene the main canvas is rendering. */
-    scene: Scene<TData, TLayer, TPose>;
-    /** Main canvas's view — used to position the visible-window indicator and
-     *  to preserve `scale` when the minimap recenters. */
-    mainView: View;
-    /** Main canvas's CSS-pixel dims. Used to compute the visible-window rect
-     *  and the recenter offset. */
-    mainViewDims: {
-        width: number;
-        height: number;
-    };
-    /** Setter called on click (single recenter) and during drag (continuous
-     *  recenter). Receives a `View` with the same `scale` as `mainView` and
-     *  `(x, y)` shifted so the pointer's world point lands at the main
-     *  canvas's center. */
-    onMainViewChange: (next: View) => void;
-    /** Minimap's own CSS-pixel dims. */
-    width: number;
-    height: number;
-    /** Consumer's draw callback. Applied through the derived fit view; same
-     *  signature as `<SceneCanvas>`'s scene-slot `drawOne` so the consumer
-     *  can reuse it (typically simplified — just colored AABBs). */
-    drawOne: SceneViewDrawOne<TData, TLayer, TPose>;
-    /** Fit policy. Defaults to `"scene"` (AABB union of leaf poses). See
-     *  `MinimapFit` for the full shape.
-     *
-     *  Framing is derived from **document** poses, not `scene.overrides` — a
-     *  node moved by an override paints where the override puts it, outside the
-     *  frame if it goes there, rather than making the whole minimap rescale on
-     *  every frame of a drag or a settle. */
-    fit?: MinimapFit<TData, TLayer, TPose>;
-    /** Pose → AABB. Defaults to identity (`pose as Bounds`), matching
-     *  `sceneAdapter` / `useSelectTool`. */
-    poseBounds?: (pose: TPose) => Bounds;
-    /** Optional per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot
-     *  `alphaFor`. Pass the same function the main canvas uses so a
-     *  scoping-dim treatment shows up in the minimap too. */
-    alphaFor?: (id: string) => number;
-    /** Visual tuning of the indicator stroke. */
-    indicatorStyle?: IndicatorStyle;
-    /** CSS class for sizing / positioning the canvas. */
-    className?: string;
-    /** Forwarded ref to the underlying `<canvas>`. */
-    canvasRef?: Ref<HTMLCanvasElement>;
-}
-declare function MinimapCanvasInner<TData, TLayer extends string, TPose>(props: MinimapCanvasProps<TData, TLayer, TPose>): react_jsx_runtime.JSX.Element;
-/**
- * Opinionated minimap. See `MinimapCanvasProps` for the full surface and
- * the module docstring for the rendering / pointer model.
- *
- * `forwardRef` is not used because the component is generic over
- * `<TData, TLayer, TPose>` and React's `forwardRef` erases generics. The
- * `canvasRef` prop is the plain-prop equivalent.
- */
-declare const MinimapCanvas: typeof MinimapCanvasInner;
-
-export { FALLBACK_FIT_VIEW, MinimapCanvas, SceneViewCanvas, buildSceneViewCommands, computeFitView, computeIndicatorCommand, renderSceneToCanvas };
-export type { ComputeFitViewOptions, IndicatorStyle, MinimapCanvasProps, MinimapFit, SceneViewCanvasProps, SceneViewDrawOne };
+export { C as ComputeFitViewOptions, v as FALLBACK_FIT_VIEW, I as IndicatorStyle, w as MinimapCanvas, x as MinimapCanvasProps, y as MinimapFit, z as SceneViewCanvas, A as SceneViewCanvasProps, E as SceneViewDrawOne, G as buildSceneViewCommands, H as computeFitView, J as computeIndicatorCommand, K as renderSceneToCanvas } from '../_dts/weasel-canvas-FJTFi3ZZ.js';
+import 'react';
+import 'react/jsx-runtime';

package/dist/passthrough/weasel-canvas.js

@@ -1,3 +1,3 @@
-export { FALLBACK_FIT_VIEW, MinimapCanvas, SceneViewCanvas, buildSceneViewCommands, computeFitView, computeIndicatorCommand, renderSceneToCanvas } from '../chunk-7VW3S44V.js';
+export { FALLBACK_FIT_VIEW, MinimapCanvas, SceneViewCanvas, buildSceneViewCommands, computeFitView, computeIndicatorCommand, renderSceneToCanvas } from '../chunk-54ZWZ5FQ.js';
 //# sourceMappingURL=weasel-canvas.js.map
 //# sourceMappingURL=weasel-canvas.js.map