@classytic/stage 0.1.0

package/dist/primitives/Plot.d.mts

@@ -0,0 +1,50 @@
+import { StyleProps } from "./props.mjs";
+import { ReactNode } from "react";
+
+//#region src/primitives/Plot.d.ts
+interface OfXProps extends StyleProps {
+  y: (x: number) => number;
+  domain?: [number, number];
+  samples?: number;
+}
+declare function OfX({
+  y,
+  domain,
+  samples,
+  color,
+  weight,
+  opacity
+}: OfXProps): ReactNode;
+interface OfYProps extends StyleProps {
+  x: (y: number) => number;
+  domain?: [number, number];
+  samples?: number;
+}
+declare function OfY({
+  x,
+  domain,
+  samples,
+  color,
+  weight,
+  opacity
+}: OfYProps): ReactNode;
+interface ParametricProps extends StyleProps {
+  xy: (t: number) => [number, number];
+  domain: [number, number];
+  samples?: number;
+}
+declare function Parametric({
+  xy,
+  domain,
+  samples,
+  color,
+  weight,
+  opacity
+}: ParametricProps): ReactNode;
+declare const Plot: {
+  OfX: typeof OfX;
+  OfY: typeof OfY;
+  Parametric: typeof Parametric;
+};
+//#endregion
+export { OfXProps, OfYProps, ParametricProps, Plot };

package/dist/primitives/Plot.mjs

@@ -0,0 +1,87 @@
+'use client';
+
+import { useCoords } from "../core/context.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/primitives/Plot.tsx
+/** Build an SVG path string, breaking the pen on non-finite samples (asymptotes). */
+function pathFrom(c, pts) {
+	let d = "";
+	let pen = false;
+	for (const p of pts) {
+		if (!p || !Number.isFinite(p[0]) || !Number.isFinite(p[1])) {
+			pen = false;
+			continue;
+		}
+		const [px, py] = c.toPx(p[0], p[1]);
+		if (!Number.isFinite(px) || !Number.isFinite(py)) {
+			pen = false;
+			continue;
+		}
+		d += `${pen ? "L" : "M"}${px.toFixed(2)},${py.toFixed(2)} `;
+		pen = true;
+	}
+	return d;
+}
+function OfX({ y, domain, samples = 300, color = "var(--stage-accent)", weight = 2.5, opacity = 1 }) {
+	const c = useCoords();
+	const [x0, x1] = domain ?? [c.view.xMin, c.view.xMax];
+	const pts = [];
+	for (let i = 0; i <= samples; i++) {
+		const x = x0 + (x1 - x0) * (i / samples);
+		pts.push([x, y(x)]);
+	}
+	return /* @__PURE__ */ jsx("path", {
+		d: pathFrom(c, pts),
+		fill: "none",
+		stroke: color,
+		strokeWidth: weight,
+		opacity,
+		strokeLinejoin: "round",
+		strokeLinecap: "round"
+	});
+}
+function OfY({ x, domain, samples = 300, color = "var(--stage-accent)", weight = 2.5, opacity = 1 }) {
+	const c = useCoords();
+	const [y0, y1] = domain ?? [c.view.yMin, c.view.yMax];
+	const pts = [];
+	for (let i = 0; i <= samples; i++) {
+		const y = y0 + (y1 - y0) * (i / samples);
+		pts.push([x(y), y]);
+	}
+	return /* @__PURE__ */ jsx("path", {
+		d: pathFrom(c, pts),
+		fill: "none",
+		stroke: color,
+		strokeWidth: weight,
+		opacity,
+		strokeLinejoin: "round",
+		strokeLinecap: "round"
+	});
+}
+function Parametric({ xy, domain, samples = 400, color = "var(--stage-accent)", weight = 2.5, opacity = 1 }) {
+	const c = useCoords();
+	const [t0, t1] = domain;
+	const pts = [];
+	for (let i = 0; i <= samples; i++) {
+		const t = t0 + (t1 - t0) * (i / samples);
+		pts.push(xy(t));
+	}
+	return /* @__PURE__ */ jsx("path", {
+		d: pathFrom(c, pts),
+		fill: "none",
+		stroke: color,
+		strokeWidth: weight,
+		opacity,
+		strokeLinejoin: "round",
+		strokeLinecap: "round"
+	});
+}
+const Plot = {
+	OfX,
+	OfY,
+	Parametric
+};
+
+//#endregion
+export { Plot };

package/dist/primitives/Shapes.d.mts

@@ -0,0 +1,76 @@
+import { Vec2 } from "../core/vec.mjs";
+import { StyleProps } from "./props.mjs";
+import { ReactNode } from "react";
+
+//#region src/primitives/Shapes.d.ts
+interface CircleProps extends StyleProps {
+  center: Vec2;
+  r: number;
+  fill?: string;
+  fillOpacity?: number;
+}
+declare function Circle({
+  center,
+  r,
+  color,
+  fill,
+  fillOpacity,
+  weight,
+  opacity
+}: CircleProps): ReactNode;
+interface EllipseProps extends StyleProps {
+  center: Vec2;
+  rx: number;
+  ry: number;
+  fill?: string;
+  fillOpacity?: number;
+}
+declare function Ellipse({
+  center,
+  rx,
+  ry,
+  color,
+  fill,
+  fillOpacity,
+  weight,
+  opacity
+}: EllipseProps): ReactNode;
+interface PolygonProps extends StyleProps {
+  points: Vec2[];
+  fill?: string;
+  fillOpacity?: number;
+}
+declare function Polygon({
+  points,
+  color,
+  fill,
+  fillOpacity,
+  weight,
+  opacity
+}: PolygonProps): ReactNode;
+interface PolylineProps extends StyleProps {
+  points: Vec2[];
+}
+declare function Polyline({
+  points,
+  color,
+  weight,
+  opacity,
+  dashed
+}: PolylineProps): ReactNode;
+/** Low-level pixel-space path (d is already in pixels). */
+interface PathProps extends StyleProps {
+  d: string;
+  fill?: string;
+  fillOpacity?: number;
+}
+declare function Path({
+  d,
+  color,
+  fill,
+  fillOpacity,
+  weight,
+  opacity
+}: PathProps): ReactNode;
+//#endregion
+export { Circle, CircleProps, Ellipse, EllipseProps, Path, PathProps, Polygon, PolygonProps, Polyline, PolylineProps };

package/dist/primitives/Shapes.mjs

@@ -0,0 +1,79 @@
+'use client';
+
+import { fmt } from "../core/coords.mjs";
+import { useCoords } from "../core/context.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/primitives/Shapes.tsx
+const toPoints = (c, points) => points.map((p) => {
+	const [x, y] = c.toPx(p.x, p.y);
+	return `${fmt(x)},${fmt(y)}`;
+}).join(" ");
+function Circle({ center, r, color = "var(--stage-accent)", fill = "none", fillOpacity = .12, weight = 2, opacity = 1 }) {
+	const c = useCoords();
+	const [cx, cy] = c.toPx(center.x, center.y);
+	return /* @__PURE__ */ jsx("ellipse", {
+		cx: fmt(cx),
+		cy: fmt(cy),
+		rx: fmt(c.sx(r)),
+		ry: fmt(c.sy(r)),
+		stroke: color,
+		strokeWidth: weight,
+		fill,
+		fillOpacity: fill === "none" ? void 0 : fillOpacity,
+		opacity
+	});
+}
+function Ellipse({ center, rx, ry, color = "var(--stage-accent)", fill = "none", fillOpacity = .12, weight = 2, opacity = 1 }) {
+	const c = useCoords();
+	const [cx, cy] = c.toPx(center.x, center.y);
+	return /* @__PURE__ */ jsx("ellipse", {
+		cx: fmt(cx),
+		cy: fmt(cy),
+		rx: fmt(c.sx(rx)),
+		ry: fmt(c.sy(ry)),
+		stroke: color,
+		strokeWidth: weight,
+		fill,
+		fillOpacity: fill === "none" ? void 0 : fillOpacity,
+		opacity
+	});
+}
+function Polygon({ points, color = "var(--stage-accent)", fill = "var(--stage-accent)", fillOpacity = .12, weight = 2, opacity = 1 }) {
+	return /* @__PURE__ */ jsx("polygon", {
+		points: toPoints(useCoords(), points),
+		stroke: color,
+		strokeWidth: weight,
+		fill,
+		fillOpacity,
+		opacity,
+		strokeLinejoin: "round"
+	});
+}
+function Polyline({ points, color = "var(--stage-fg)", weight = 2, opacity = 1, dashed }) {
+	return /* @__PURE__ */ jsx("polyline", {
+		points: toPoints(useCoords(), points),
+		fill: "none",
+		stroke: color,
+		strokeWidth: weight,
+		opacity,
+		strokeLinejoin: "round",
+		strokeLinecap: "round",
+		strokeDasharray: dashed ? "6 6" : void 0
+	});
+}
+function Path({ d, color = "var(--stage-fg)", fill = "none", fillOpacity = 1, weight = 2, opacity = 1 }) {
+	return /* @__PURE__ */ jsx("path", {
+		d,
+		stroke: color,
+		strokeWidth: weight,
+		fill,
+		fillOpacity: fill === "none" ? void 0 : fillOpacity,
+		opacity,
+		strokeLinejoin: "round",
+		strokeLinecap: "round"
+	});
+}
+
+//#endregion
+export { Circle, Ellipse, Path, Polygon, Polyline };

package/dist/primitives/Tex.d.mts

@@ -0,0 +1,27 @@
+import { ReactNode } from "react";
+
+//#region src/primitives/Tex.d.ts
+interface TexProps {
+  x: number;
+  y: number;
+  tex: string;
+  color?: string;
+  size?: number;
+  dx?: number;
+  dy?: number;
+  width?: number;
+  height?: number;
+}
+declare function Tex({
+  x,
+  y,
+  tex,
+  color,
+  size,
+  dx,
+  dy,
+  width,
+  height
+}: TexProps): ReactNode;
+//#endregion
+export { Tex, TexProps };

package/dist/primitives/Tex.mjs

@@ -0,0 +1,54 @@
+'use client';
+
+import { fmt } from "../core/coords.mjs";
+import { useCoords } from "../core/context.mjs";
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+import katex from "katex";
+
+//#region src/primitives/Tex.tsx
+/**
+* Tex — KaTeX maths in a <foreignObject>, rendered AT RENDER TIME (not in an
+* effect) so the markup is identical on the server and the client: SSR/static
+* exports show real maths (not raw `\left…\right`), there's no raw-then-hydrate
+* flash, and hydration matches. KaTeX is a static import kept in its OWN module so
+* only Tex's importers pull it (stage's neverBundle leaves `katex` external — the
+* consumer resolves the peer; non-Tex consumers never bundle it).
+*
+* Needs the consumer to load `katex/dist/katex.min.css` for proper glyphs.
+*/
+function Tex({ x, y, tex, color = "var(--stage-fg)", size = 18, dx = 0, dy = 0, width = 220, height = 64 }) {
+	const [px, py] = useCoords().toPx(x, y);
+	const html = useMemo(() => {
+		try {
+			return katex.renderToString(tex, { throwOnError: false });
+		} catch {
+			return null;
+		}
+	}, [tex]);
+	return /* @__PURE__ */ jsx("foreignObject", {
+		x: fmt(px + dx - width / 2),
+		y: fmt(py + dy - height / 2),
+		width,
+		height,
+		style: {
+			overflow: "visible",
+			pointerEvents: "none"
+		},
+		children: /* @__PURE__ */ jsx("div", {
+			style: {
+				display: "flex",
+				alignItems: "center",
+				justifyContent: "center",
+				width: "100%",
+				height: "100%",
+				color,
+				fontSize: size
+			},
+			children: html ? /* @__PURE__ */ jsx("span", { dangerouslySetInnerHTML: { __html: html } }) : /* @__PURE__ */ jsx("span", { children: tex })
+		})
+	});
+}
+
+//#endregion
+export { Tex };

package/dist/primitives/index.d.mts

@@ -0,0 +1,10 @@
+import { A11yProps, StyleProps } from "./props.mjs";
+import { Dot, DotProps, Point } from "./Dot.mjs";
+import { Line, LineProps, Ray, Segment, SegmentProps, Vector, VectorProps } from "./Lines.mjs";
+import { Circle, CircleProps, Ellipse, EllipseProps, Path, PathProps, Polygon, PolygonProps, Polyline, PolylineProps } from "./Shapes.mjs";
+import { Label, LabelProps } from "./Label.mjs";
+import { Tex, TexProps } from "./Tex.mjs";
+import { Axes, AxesProps, Grid, GridProps, niceStep } from "./Grid.mjs";
+import { OfXProps, OfYProps, ParametricProps, Plot } from "./Plot.mjs";
+import { CanvasLayer, CanvasLayerProps } from "./CanvasLayer.mjs";
+export { type A11yProps, Axes, type AxesProps, CanvasLayer, type CanvasLayerProps, Circle, type CircleProps, Dot, type DotProps, Ellipse, type EllipseProps, Grid, type GridProps, Label, type LabelProps, Line, type LineProps, type OfXProps, type OfYProps, type ParametricProps, Path, type PathProps, Plot, Point, Polygon, type PolygonProps, Polyline, type PolylineProps, Ray, Segment, type SegmentProps, type StyleProps, Tex, type TexProps, Vector, type VectorProps, niceStep };

package/dist/primitives/index.mjs

@@ -0,0 +1,10 @@
+import { Dot, Point } from "./Dot.mjs";
+import { Line, Ray, Segment, Vector } from "./Lines.mjs";
+import { Circle, Ellipse, Path, Polygon, Polyline } from "./Shapes.mjs";
+import { Label } from "./Label.mjs";
+import { Tex } from "./Tex.mjs";
+import { Axes, Grid, niceStep } from "./Grid.mjs";
+import { Plot } from "./Plot.mjs";
+import { CanvasLayer } from "./CanvasLayer.mjs";
+
+export { Axes, CanvasLayer, Circle, Dot, Ellipse, Grid, Label, Line, Path, Plot, Point, Polygon, Polyline, Ray, Segment, Tex, Vector, niceStep };

package/dist/primitives/props.d.mts

@@ -0,0 +1,15 @@
+//#region src/primitives/props.d.ts
+/** Shared styling + a11y props for primitives. */
+interface StyleProps {
+  color?: string;
+  opacity?: number;
+  /** Stroke width in pixels (never scaled by zoom). */
+  weight?: number;
+  dashed?: boolean;
+}
+interface A11yProps {
+  role?: string;
+  ariaLabel?: string;
+}
+//#endregion
+export { A11yProps, StyleProps };

package/dist/scene/Scene.d.mts

@@ -0,0 +1,31 @@
+import { ViewBox } from "../core/coords.mjs";
+import { SceneDoc } from "./types.mjs";
+import { ReactNode } from "react";
+
+//#region src/scene/Scene.d.ts
+interface SceneProps {
+  doc: SceneDoc;
+  onChange?: (doc: SceneDoc) => void;
+  interactive?: boolean;
+  showGrid?: boolean;
+  showAxes?: boolean;
+  height?: number;
+  view?: ViewBox;
+  ariaLabel?: string;
+  /** Author opt-in: start a sim running immediately (ambient motion) instead of
+   *  the default "press Play". A SceneDoc with no `meta.sims` is always static. */
+  autoPlay?: boolean;
+}
+declare function Scene({
+  doc,
+  onChange,
+  interactive,
+  showGrid,
+  showAxes,
+  height,
+  view,
+  ariaLabel,
+  autoPlay
+}: SceneProps): ReactNode;
+//#endregion
+export { Scene, SceneProps };

package/dist/scene/Scene.mjs

@@ -0,0 +1,168 @@
+'use client';
+
+import { useFrameLoop } from "../core/clock.mjs";
+import { Stage } from "../view/Stage.mjs";
+import { useInView } from "../view/useInView.mjs";
+import { Axes, Grid } from "../primitives/Grid.mjs";
+import { isCircleVal, isLineVal, isVec2 } from "./types.mjs";
+import { resolve } from "./resolve.mjs";
+import { applyCommand } from "./commands.mjs";
+import { renderElements } from "./render.mjs";
+import { initSims, stepSims } from "./sims.mjs";
+import { useMemo, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/scene/Scene.tsx
+/**
+* <Scene> — renders a SceneDoc (read/play): resolve() → shared element renderer.
+* Free draggable points commit one `mutate` via onChange on pointer-up; live drag
+* uses an ephemeral overlay (descendants re-resolve without mutating the doc).
+*/
+function autoView(resolved) {
+	const xs = [];
+	const ys = [];
+	for (const v of resolved.values.values()) if (isVec2(v)) {
+		xs.push(v.x);
+		ys.push(v.y);
+	} else if (isCircleVal(v)) {
+		xs.push(v.center.x - v.r, v.center.x + v.r);
+		ys.push(v.center.y - v.r, v.center.y + v.r);
+	} else if (isLineVal(v)) {
+		xs.push(v.a.x, v.b.x);
+		ys.push(v.a.y, v.b.y);
+	}
+	if (!xs.length) return {
+		xMin: -8,
+		xMax: 8,
+		yMin: -5,
+		yMax: 5
+	};
+	const pad = 1.5;
+	return {
+		xMin: Math.min(...xs) - pad,
+		xMax: Math.max(...xs) + pad,
+		yMin: Math.min(...ys) - pad,
+		yMax: Math.max(...ys) + pad
+	};
+}
+function Scene({ doc, onChange, interactive = true, showGrid = true, showAxes = true, height, view, ariaLabel = "Interactive figure", autoPlay = false }) {
+	const [overlay, setOverlay] = useState(/* @__PURE__ */ new Map());
+	const prevRef = useRef(void 0);
+	const sims = doc.meta?.sims;
+	const simStates = useRef(void 0);
+	if (!simStates.current) simStates.current = initSims(sims ?? []);
+	const simScalars = useRef(/* @__PURE__ */ new Map());
+	const [frame, setFrame] = useState(0);
+	const { ref: rootRef, inView } = useInView();
+	const [done, setDone] = useState(false);
+	const [playing, setPlaying] = useState(autoPlay);
+	useFrameLoop((f) => {
+		if (!sims?.length || !simStates.current) return;
+		const next = stepSims(sims, simStates.current, Math.min(.05, f.dtMs / 1e3));
+		simStates.current = next.states;
+		simScalars.current = next.scalars;
+		setFrame((n) => (n + 1) % 1e6);
+		if (next.done) setDone(true);
+	}, { running: !!sims?.length && inView && playing && !done });
+	const merged = useMemo(() => {
+		const scalars = simScalars.current;
+		if (!overlay.size && !scalars.size) return void 0;
+		const m = new Map(scalars);
+		for (const [k, v] of overlay) m.set(k, v);
+		return m;
+	}, [overlay, frame]);
+	const resolved = useMemo(() => {
+		const r = resolve(doc, merged, prevRef.current, simStates.current);
+		prevRef.current = r;
+		return r;
+	}, [
+		doc,
+		merged,
+		frame
+	]);
+	const v = view ?? doc.view ?? autoView(resolved);
+	const move = (id, p, phase) => {
+		if (phase === "move") setOverlay((prev) => new Map(prev).set(id, p));
+		else {
+			setOverlay(/* @__PURE__ */ new Map());
+			onChange?.(applyCommand(doc, {
+				op: "mutate",
+				id,
+				patch: { free: { at: p } }
+			}));
+		}
+	};
+	const hasSims = !!sims?.length;
+	return /* @__PURE__ */ jsxs("div", {
+		ref: rootRef,
+		style: { position: "relative" },
+		children: [
+			/* @__PURE__ */ jsxs(Stage, {
+				view: v,
+				height,
+				ariaLabel,
+				children: [
+					showGrid && /* @__PURE__ */ jsx(Grid, {}),
+					showAxes && /* @__PURE__ */ jsx(Axes, { ticks: false }),
+					renderElements(doc, resolved, {
+						draggablePoints: interactive && !!onChange,
+						onPointMove: move
+					})
+				]
+			}),
+			hasSims && !done && !playing && /* @__PURE__ */ jsx("button", {
+				type: "button",
+				onClick: () => setPlaying(true),
+				"aria-label": "Play simulation",
+				style: {
+					position: "absolute",
+					inset: 0,
+					display: "flex",
+					alignItems: "center",
+					justifyContent: "center",
+					background: "color-mix(in oklab, var(--stage-bg) 38%, transparent)",
+					border: "none",
+					borderRadius: 12,
+					cursor: "pointer"
+				},
+				children: /* @__PURE__ */ jsx("span", {
+					style: {
+						display: "inline-flex",
+						alignItems: "center",
+						gap: 8,
+						padding: "11px 26px",
+						borderRadius: 999,
+						background: "var(--stage-accent)",
+						color: "#fff",
+						fontWeight: 800,
+						fontSize: 16,
+						boxShadow: "0 6px 18px rgba(0,0,0,.28)"
+					},
+					children: "▶ Play"
+				})
+			}),
+			hasSims && !done && playing && /* @__PURE__ */ jsx("button", {
+				type: "button",
+				onClick: () => setPlaying(false),
+				"aria-label": "Pause simulation",
+				style: {
+					position: "absolute",
+					top: 10,
+					right: 10,
+					width: 34,
+					height: 34,
+					borderRadius: 999,
+					border: "1px solid var(--stage-grid)",
+					background: "color-mix(in oklab, var(--stage-bg) 80%, transparent)",
+					color: "var(--stage-fg)",
+					cursor: "pointer",
+					fontSize: 13
+				},
+				children: "⏸"
+			})
+		]
+	});
+}
+
+//#endregion
+export { Scene };

package/dist/scene/assets.d.mts

@@ -0,0 +1,37 @@
+import { Vec2 } from "../core/vec.mjs";
+import { AssetGeometry, ElementStyle, Val } from "./types.mjs";
+import { ReactNode } from "react";
+
+//#region src/scene/assets.d.ts
+interface AssetResolveArgs {
+  params: Record<string, number | Vec2>;
+  bound: Record<string, Val | undefined>;
+  /** Live sim-state values pulled in via the asset's `simBind` (any type: number/string/array). */
+  sim?: Record<string, unknown>;
+}
+interface AssetSpec {
+  resolver: (args: AssetResolveArgs) => AssetGeometry;
+  Component: (props: {
+    geom: AssetGeometry;
+    style?: ElementStyle;
+    label?: string;
+  }) => ReactNode;
+}
+declare function registerAsset(name: string, spec: AssetSpec): void;
+declare function getAsset(name: string): AssetSpec | undefined;
+declare function listAssets(): string[];
+/**
+ * Typed read of an asset's `meta` — write `const m = assetMeta<MyMeta>(geom)` in a
+ * Component instead of an inline `(geom.meta ?? {}) as MyMeta` cast everywhere.
+ *
+ * We deliberately keep `AssetGeometry` NON-generic: `parts` must stay
+ * `Vec2 | Vec2[] | number` so it remains a clean member of the resolver's `Val`
+ * union, and a fully generic `AssetGeometry<TParts, TMeta>` would force `AssetSpec`,
+ * `registerAsset`, `resolve()`, and the render path to be generic too — and a
+ * specific `TMeta` interface isn't assignable to `Record<string, unknown>` without
+ * index-signature friction. This helper gives the type-safety at the read site
+ * with none of that ripple. (Asset domain data lives in `meta`; `parts` is geometry.)
+ */
+declare function assetMeta<T>(geom: AssetGeometry): T;
+//#endregion
+export { AssetResolveArgs, AssetSpec, assetMeta, getAsset, listAssets, registerAsset };

package/dist/scene/assets.mjs

@@ -0,0 +1,31 @@
+'use client';
+
+//#region src/scene/assets.ts
+const ASSETS = /* @__PURE__ */ new Map();
+function registerAsset(name, spec) {
+	ASSETS.set(name, spec);
+}
+function getAsset(name) {
+	return ASSETS.get(name);
+}
+function listAssets() {
+	return [...ASSETS.keys()];
+}
+/**
+* Typed read of an asset's `meta` — write `const m = assetMeta<MyMeta>(geom)` in a
+* Component instead of an inline `(geom.meta ?? {}) as MyMeta` cast everywhere.
+*
+* We deliberately keep `AssetGeometry` NON-generic: `parts` must stay
+* `Vec2 | Vec2[] | number` so it remains a clean member of the resolver's `Val`
+* union, and a fully generic `AssetGeometry<TParts, TMeta>` would force `AssetSpec`,
+* `registerAsset`, `resolve()`, and the render path to be generic too — and a
+* specific `TMeta` interface isn't assignable to `Record<string, unknown>` without
+* index-signature friction. This helper gives the type-safety at the read site
+* with none of that ripple. (Asset domain data lives in `meta`; `parts` is geometry.)
+*/
+function assetMeta(geom) {
+	return geom.meta ?? {};
+}
+
+//#endregion
+export { assetMeta, getAsset, listAssets, registerAsset };