@felbrasil/dreamy 0.0.0-stage → 0.1.0

package/dist/types/evaluator/src/chunks.d.ts

@@ -0,0 +1,53 @@
+import { type MesherCore } from "./abi.js";
+import type { Packed } from "./prep/pack.js";
+export declare const CHUNK_MIN_EXTENT = 8;
+export declare const CHUNK_CELLS = 144;
+export type ChunkView = {
+    readonly camera: {
+        readonly x: number;
+        readonly y: number;
+        readonly z: number;
+    };
+    readonly pixelsPerUnitAtDistance1: number;
+};
+type Part = {
+    readonly nV: number;
+    readonly pos: Float32Array;
+    readonly nor: Float32Array;
+    readonly col: Float32Array;
+    readonly fcol: Float32Array;
+    readonly mat: Float32Array;
+    readonly idx: Uint32Array;
+};
+type Rec = {
+    readonly i: number;
+    readonly j: number;
+    readonly k: number;
+    level: number | null;
+    readonly meshes: Map<number, Part>;
+    skirt: Part | null;
+    skirtDepth: number;
+    skirtOf: Part | null;
+};
+export type ChunkState = {
+    readonly h0: number;
+    readonly W: number;
+    readonly chunks: Map<string, Rec>;
+    table: Float64Array;
+    count: number;
+};
+export type ChunkOutput = Part & {
+    readonly bounds: readonly [number, number, number, number, number, number];
+    readonly chunks: number;
+};
+/** Whether this sculpt meshes in chunks (a little slack once chunked, so it doesn't flip back and forth). */
+export declare function wantsChunks(P: Packed, chunkedBefore: boolean): boolean;
+/**
+ * Meshes a packed sculpt in chunks around the view. `prev` is the key's previous state (null on the first
+ * chunked mesh); returns the new state and the merged mesh.
+ */
+export declare function chunkMesh(core: MesherCore, prev: ChunkState | null, P: Packed, view: ChunkView): {
+    state: ChunkState;
+    out: ChunkOutput;
+};
+export {};

package/dist/types/evaluator/src/index.d.ts

@@ -0,0 +1,11 @@
+export { createEvaluator, createInlineEvaluator, createWorkerEvaluator, AbortError } from "./worker/client.js";
+export type { CoreKind, EvaluatorHandle, WorkerEvaluatorOptions } from "./worker/client.js";
+export { startWorkerHost } from "./worker/host.js";
+export type { PortLike } from "./worker/protocol.js";
+export { createMeshSession, VOX_CACHE_MAX } from "./session.js";
+export type { MeshSession, RemeshInfo } from "./session.js";
+export { createReferenceCore } from "./reference/core.js";
+export { fetchWasmCore, loadWasmCore, wasmCoreFromInstance, WASM_URL } from "./wasm/core.js";
+export { clampResolution, lodLevels, packSculpt } from "./prep/pack.js";
+export { FIXED_COLORS, colorHex, rgbOf } from "./prep/colors.js";
+export * from "./abi.js";

package/dist/types/evaluator/src/prep/colors.d.ts

@@ -0,0 +1,11 @@
+import type { ColorRef, FixedColor, Palette, Rgb } from "../../../api/src/index.js";
+/** Fixed colors: always available, never edited (POC FIXED_COLORS). */
+export declare const FIXED_COLORS: {
+    readonly [C in FixedColor]: Rgb;
+};
+export declare function colorHex(ref: ColorRef, palette: Palette): Rgb;
+/**
+ * The shader-space RGB of a color: byte / 255 per channel, exactly what the POC's r128
+ * `new THREE.Color(hex)` held (and its shaders treated as linear).
+ */
+export declare function rgbOf(ref: ColorRef, palette: Palette): readonly [number, number, number];

package/dist/types/evaluator/src/prep/mat3.d.ts

@@ -0,0 +1,13 @@
+import type { Quaternion } from "../../../api/src/index.js";
+/** Row-major 3x3 matrix. */
+export type Mat3 = readonly [number, number, number, number, number, number, number, number, number];
+export declare const IDENTITY: Mat3;
+/** Rotation of a (normalized) quaternion, as THREE.Matrix4.makeRotationFromQuaternion. */
+export declare function fromQuaternion(q: Quaternion): Mat3;
+/** Rotation by `angle` about a unit axis, as THREE.Matrix4.makeRotationAxis. */
+export declare function fromAxisAngle(ax: number, ay: number, az: number, angle: number): Mat3;
+export declare function scale(sx: number, sy: number, sz: number): Mat3;
+export declare function mul(a: Mat3, b: Mat3): Mat3;
+export declare function transpose(m: Mat3): Mat3;
+export declare function det(m: Mat3): number;
+export declare function apply(m: Mat3, x: number, y: number, z: number): [number, number, number];

package/dist/types/evaluator/src/prep/pack.d.ts

@@ -0,0 +1,23 @@
+import type { Palette, Sculpt } from "../../../api/src/index.js";
+export type Packed = {
+    /** STAMP_STRIDE f64 per expanded stamp (see abi.ts). */
+    readonly table: Float64Array;
+    readonly count: number;
+    /** Derived copies dropped by the 1024-stamp cap. */
+    readonly overflow: number;
+    readonly maxBlend: number;
+    /** Grid box (stamp bounds padded by the blend margin). */
+    readonly bMin: readonly [number, number, number];
+    readonly bSize: readonly [number, number, number];
+};
+/** Resolution clamp: the POC base is 16–64 and LOD goes down to 12. */
+export declare const MIN_RESOLUTION = 4;
+export declare const MAX_RESOLUTION = 128;
+export declare function clampResolution(r: number): number;
+/** POC lod.js: the three levels derived from a base resolution, finest first. */
+export declare function lodLevels(base: number): readonly [number, number, number];
+/**
+ * Expands symmetry, resolves smear-group props, colors and material channels, and packs the stamp
+ * table plus the grid box (POC _extractSculptMeshImpl up to the voxel pass).
+ */
+export declare function packSculpt(sculpt: Sculpt, palette: Palette): Packed;

package/dist/types/evaluator/src/prep/props.d.ts

@@ -0,0 +1,16 @@
+import type { ColorRef, MaterialOverrides, Sculpt, Stamp, StampMode, Symmetry } from "../../../api/src/index.js";
+/** A stamp's effective settings: its smear group's when it belongs to one (POC resolveStampProps). */
+export type StampProps = {
+    readonly mode: StampMode;
+    readonly blend: number;
+    readonly color: ColorRef;
+    readonly foundationColor: ColorRef;
+    readonly material: MaterialOverrides;
+    readonly symmetry: Symmetry | undefined;
+};
+/**
+ * The group wins for mode, color, foundation, blend and symmetry. Material overrides stay the stamp's
+ * (a smear group carries none in the contract). Colors fall back to the sculpt's look; a foundation
+ * follows the stamp's own color when only that is set, else the look's foundation.
+ */
+export declare function resolveStampProps(stamp: Stamp, sculpt: Sculpt): StampProps;

package/dist/types/evaluator/src/prep/symmetry.d.ts

@@ -0,0 +1,23 @@
+import type { Pivot, SymmetryAxis, Vec3 } from "../../../api/src/index.js";
+import { type Mat3 } from "./mat3.js";
+export declare const SYM_MAX_N = 12;
+export declare const SYM_MAX_INSTANCES = 128;
+export declare const SYM_STAMP_CAP = 1024;
+export declare function symAxesOf(axes: readonly SymmetryAxis[] | undefined): SymmetryAxis[];
+/** N clamped to [1, 12] and so that N^(axis count) <= 128. */
+export declare function symClampN(n: number, axes: readonly SymmetryAxis[] | undefined): number;
+/**
+ * Every non-identity transform of a source shape: k * 360/N about each selected axis, composed X then Y
+ * then Z; N = 2 mirrors across the axis' plane. No axis: off (N = 1) or N-fold about Y.
+ */
+export declare function symInstanceMatrices(n: number, axes: readonly SymmetryAxis[] | undefined): readonly Mat3[];
+export type Placement = {
+    readonly position: readonly [number, number, number];
+    /** Shape rotation (local -> sculpt space), a proper rotation. */
+    readonly rotation: Mat3;
+};
+/**
+ * Instance placements of one shape about the pivot. A reflection has no rotation, but every primitive
+ * is symmetric about its local x = 0 plane, so L*R*Fx (a proper rotation) replaces the mirrored L*R.
+ */
+export declare function symInstancesOf(position: Vec3, rotation: Mat3, pivot: Pivot, n: number, axes: readonly SymmetryAxis[] | undefined): Placement[];

package/dist/types/evaluator/src/reference/core.d.ts

@@ -0,0 +1,3 @@
+import type { MesherCore } from "../abi.js";
+/** The TypeScript mesher core: the WASM fallback and the parity oracle. */
+export declare function createReferenceCore(): MesherCore;

package/dist/types/evaluator/src/reference/mesher.d.ts

@@ -0,0 +1,22 @@
+import { type RawMesh } from "../abi.js";
+export type VoxArrays = {
+    readonly field: Float32Array;
+    readonly cR: Float32Array;
+    readonly cG: Float32Array;
+    readonly cB: Float32Array;
+    readonly fR: Float32Array;
+    readonly fG: Float32Array;
+    readonly fB: Float32Array;
+    /** 4 per voxel: roughness, metalness, glow, flecks. */
+    readonly mat: Float32Array;
+};
+export declare function newVoxArrays(total: number): VoxArrays;
+/** Signed distance of a shape in its local frame, with per-axis half sizes. */
+export declare function sdShape(code: number, x: number, y: number, z: number, hx: number, hy: number, hz: number): number;
+/**
+ * Evaluates the stamp stack at every sample of the inclusive box [x0..x1, y0..y1, z0..z1] of a grid
+ * with RX x RY samples per layer, writing distance, color, foundation and material into A.
+ */
+export declare function evalRange(T: Float64Array, list: Int32Array, A: VoxArrays, RX: number, RY: number, ox: number, oy: number, oz: number, sx: number, sy: number, sz: number, x0: number, x1: number, y0: number, y1: number, z0: number, z1: number): void;
+/** Surface Nets over the whole grid, with per-vertex gradient normals and interpolated channels. */
+export declare function surfaceNets(A: VoxArrays, RX: number, RY: number, RZ: number, ox: number, oy: number, oz: number, sx: number, sy: number, sz: number, own: number): RawMesh;

package/dist/types/evaluator/src/reference/skin.d.ts

@@ -0,0 +1,8 @@
+import { type RawSkin } from "../abi.js";
+/** POC skeleton.js: auto-weights softness (larger = softer blends between bones). */
+export declare const WEIGHT_FALLOFF = 0.08;
+/**
+ * Distance-based auto weights (POC computeSkinWeights): each bone's distance is its nearest segment's
+ * squared distance; the 4 nearest bones get 1 / (d + falloff)^2, normalized.
+ */
+export declare function skinWeights(positions: Float32Array, segs: Float64Array, segCount: number, boneCount: number): RawSkin;

package/dist/types/evaluator/src/session.d.ts

@@ -0,0 +1,21 @@
+import type { MeshRequest, MeshResult, SkinRequest, SkinResult } from "../../api/src/index.js";
+import { type MesherCore } from "./abi.js";
+export declare const VOX_CACHE_MAX = 4;
+export type RemeshInfo = {
+    readonly mode: "full" | "region" | "none" | "chunks";
+    readonly voxels: number;
+    readonly total: number;
+};
+export type MeshSession = {
+    readonly core: MesherCore;
+    mesh(request: MeshRequest): MeshResult;
+    skinWeights(request: SkinRequest): SkinResult;
+    /** Frees the key's cached voxels. */
+    forget(key: string): void;
+    /** How the last mesh was evaluated (for stats and tests). */
+    lastInfo(): RemeshInfo;
+};
+/** Synchronous meshing over one core: what the Worker host runs, and what Node tests call directly. */
+export declare function createMeshSession(core: MesherCore, options?: {
+    readonly cache?: boolean;
+}): MeshSession;

package/dist/types/evaluator/src/wasm/core.d.ts

@@ -0,0 +1,9 @@
+import { type MesherCore } from "../abi.js";
+/** The module's location inside the package (bundlers resolve it as an asset). */
+export declare const WASM_URL: URL;
+/** Wraps an instantiated module. Inputs go through one reusable scratch block; outputs are copied out. */
+export declare function wasmCoreFromInstance(instance: WebAssembly.Instance): MesherCore;
+/** Instantiates the module from its bytes (Node tests, or a host that fetched it itself). */
+export declare function loadWasmCore(bytes: BufferSource): Promise<MesherCore>;
+/** Fetches and instantiates the module (browser / Worker). */
+export declare function fetchWasmCore(url?: string | URL): Promise<MesherCore>;

package/dist/types/evaluator/src/worker/client.d.ts

@@ -0,0 +1,28 @@
+import type { Evaluator } from "../../../api/src/index.js";
+import type { MesherCore } from "../abi.js";
+import type { PortLike } from "./protocol.js";
+export type CoreKind = "wasm" | "reference";
+/** The Evaluator port plus which core ended up running. */
+export type EvaluatorHandle = Evaluator & {
+    /** Resolves once the core is loaded: "reference" when WASM (or the Worker) failed. */
+    readonly ready: Promise<CoreKind>;
+};
+/** Superseded (a newer request for the key), cancelled and disposed jobs reject with this. */
+export declare class AbortError extends Error {
+    readonly name = "AbortError";
+}
+/** Runs in this thread over a core (Node tests, or when no Worker is available). */
+export declare function createInlineEvaluator(core?: MesherCore): EvaluatorHandle;
+export type WorkerEvaluatorOptions = {
+    /** Port to a running host: a Worker on worker.ts, or a MessagePort in tests. */
+    readonly port: PortLike;
+    /** Called on dispose (e.g. worker.terminate()). */
+    readonly close?: () => void;
+};
+/** An Evaluator over a Worker host. A Worker that errors before it is ready falls back to inline TS. */
+export declare function createWorkerEvaluator(options: WorkerEvaluatorOptions): EvaluatorHandle;
+/**
+ * The default Evaluator: the WASM core in a module Worker, falling back to the TS reference (in the
+ * Worker when WASM fails to load, inline when Workers are unavailable).
+ */
+export declare function createEvaluator(): EvaluatorHandle;

package/dist/types/evaluator/src/worker/host.d.ts

@@ -0,0 +1,8 @@
+import type { MesherCore } from "../abi.js";
+import { type MeshSession } from "../session.js";
+import { type PortLike } from "./protocol.js";
+/**
+ * Serves mesh / skin jobs on a port (the Worker's global scope, or a MessagePort in tests). Jobs that
+ * arrive before the core is loaded wait for it. If loading fails, `fallback` provides the core.
+ */
+export declare function startWorkerHost(port: PortLike, load: () => Promise<MesherCore>, fallback: () => MesherCore): Promise<MeshSession>;

package/dist/types/evaluator/src/worker/protocol.d.ts

@@ -0,0 +1,39 @@
+import type { MeshRequest, MeshResult, SkinRequest, SkinResult } from "../../../api/src/index.js";
+/** Client -> host. */
+export type HostMessage = {
+    readonly t: "mesh";
+    readonly id: number;
+    readonly req: MeshRequest;
+} | {
+    readonly t: "skin";
+    readonly id: number;
+    readonly req: SkinRequest;
+} | {
+    readonly t: "forget";
+    readonly key: string;
+};
+/** Host -> client. */
+export type ClientMessage = {
+    readonly t: "ready";
+    readonly core: "wasm" | "reference";
+    readonly error?: string;
+} | {
+    readonly t: "mesh";
+    readonly id: number;
+    readonly res: MeshResult;
+} | {
+    readonly t: "skin";
+    readonly id: number;
+    readonly res: SkinResult;
+} | {
+    readonly t: "err";
+    readonly id: number;
+    readonly message: string;
+};
+/** What a Worker, a DedicatedWorkerGlobalScope and a MessagePort have in common. */
+export type PortLike = {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    onmessage: ((event: MessageEvent) => void) | null;
+};
+export declare function meshTransfer(r: MeshResult): Transferable[];
+export declare function skinTransfer(r: SkinResult): Transferable[];

package/dist/types/evaluator/src/worker/spawn.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Starts the evaluator's Worker. Classic, not { type: "module" }: webpack (Next) emits the worker as a classic
+ * bundle whose last line assigns an undeclared global, which throws in a module worker's strict mode.
+ * The npm build (packages/dreamy) replaces this module with an inline Worker that carries the WASM.
+ */
+export declare function spawnWorker(): Worker;

package/dist/types/evaluator/src/worker/worker-inline.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/evaluator/src/worker/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/module/src/index.d.ts

@@ -0,0 +1,2 @@
+export { EditorPage } from "./ui/pages/editor-page.js";
+export type { EditorPageProps } from "./ui/pages/editor-page.js";

package/dist/types/module/src/ui/atoms/action-button.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+export type ActionButtonProps = {
+    /** sp-lock: pink panel action; sp-delete: red; de-act: dialog action. */
+    readonly variant: "sp-lock" | "sp-delete" | "de-act" | "de-act primary" | "de-act danger";
+    readonly icon?: string | undefined;
+    readonly children: ReactNode;
+    readonly onClick: () => void;
+};
+/** A wide labelled button in panels and dialogs. */
+export declare function ActionButton({ variant, icon, children, onClick }: ActionButtonProps): import("react").JSX.Element;

package/dist/types/module/src/ui/atoms/badge.d.ts

@@ -0,0 +1,9 @@
+export type BadgeProps = {
+    readonly icon: string;
+    readonly label: string;
+    readonly active?: boolean | undefined;
+    readonly id?: string | undefined;
+    readonly onClick: () => void;
+};
+/** A frosted pill toggle (Mirror, Area, Add); green while on. */
+export declare function Badge({ icon, label, active, id, onClick }: BadgeProps): import("react").JSX.Element;

package/dist/types/module/src/ui/atoms/checkbox.d.ts

@@ -0,0 +1,6 @@
+export type CheckboxProps = {
+    readonly checked: boolean;
+    readonly label: string;
+    readonly onChange: (checked: boolean) => void;
+};
+export declare function Checkbox({ checked, label, onChange }: CheckboxProps): import("react").JSX.Element;

package/dist/types/module/src/ui/atoms/color-input.d.ts

@@ -0,0 +1,10 @@
+export type ColorInputProps = {
+    readonly value: string;
+    readonly label: string;
+    readonly className?: string | undefined;
+    readonly disabled?: boolean | undefined;
+    /** Once, when the picker closes. */
+    readonly onCommit: (rgb: number) => void;
+};
+/** A native color picker that shows the picked color locally and commits once. */
+export declare function ColorInput({ value, label, className, disabled, onCommit }: ColorInputProps): import("react").JSX.Element;

package/dist/types/module/src/ui/atoms/hex-chip.d.ts

@@ -0,0 +1,5 @@
+import type { ReactNode } from "react";
+/** A small monospace value chip ("#fbbf24", a count). */
+export declare function HexChip({ children }: {
+    readonly children: ReactNode;
+}): import("react").JSX.Element;

package/dist/types/module/src/ui/atoms/icon-button.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from "react";
+import type { IconSpec } from "../lib/catalog.js";
+export type IconButtonProps = {
+    readonly icon: string | IconSpec;
+    readonly title: string;
+    /** stamp-btn: list row button; de-btn: dialog button. */
+    readonly variant?: "stamp-btn" | "stamp-btn del" | "de-btn" | "de-btn sm" | "de-btn sm confirm" | undefined;
+    readonly active?: boolean | undefined;
+    readonly disabled?: boolean | undefined;
+    readonly children?: ReactNode | undefined;
+    readonly onClick: () => void;
+};
+/** A small square / round icon-only button. Clicks never reach the row underneath. */
+export declare function IconButton({ icon, title, variant, active, disabled, children, onClick }: IconButtonProps): import("react").JSX.Element;

package/dist/types/module/src/ui/atoms/icon.d.ts

@@ -0,0 +1,8 @@
+import type { IconSpec } from "../lib/catalog.js";
+export type IconProps = {
+    /** A Font Awesome solid icon name ("cube"), or a full spec. */
+    readonly icon: string | IconSpec;
+    readonly className?: string | undefined;
+};
+/** One icon: Font Awesome (loaded by the host page), a text glyph, or a 24 × 24 outline path. */
+export declare function Icon({ icon, className }: IconProps): import("react").JSX.Element;

package/dist/types/module/src/ui/atoms/kbd.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNode } from "react";
+export declare function Kbd({ children }: {
+    readonly children: ReactNode;
+}): import("react").JSX.Element;

package/dist/types/module/src/ui/atoms/match-button.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+export type MatchButtonProps = {
+    readonly icon?: string | undefined;
+    readonly title?: string | undefined;
+    readonly active?: boolean | undefined;
+    readonly children: ReactNode;
+    readonly onClick: () => void;
+};
+/** The small outlined text button (Match, Inherit, Re-roll, presets). */
+export declare function MatchButton({ icon, title, active, children, onClick }: MatchButtonProps): import("react").JSX.Element;

package/dist/types/module/src/ui/atoms/number-input.d.ts

@@ -0,0 +1,11 @@
+export type NumberInputProps = {
+    readonly value: number;
+    readonly label: string;
+    readonly step?: number | undefined;
+    readonly min?: number | undefined;
+    readonly digits?: number | undefined;
+    readonly className?: string | undefined;
+    readonly onCommit: (value: number) => void;
+};
+/** A number field: typing is local, Enter or leaving the field commits. */
+export declare function NumberInput({ value, label, step, min, digits, className, onCommit }: NumberInputProps): import("react").JSX.Element;

package/dist/types/module/src/ui/atoms/pill-button.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from "react";
+export type PillButtonProps = {
+    readonly title: string;
+    readonly active?: boolean | undefined;
+    readonly wide?: boolean | undefined;
+    readonly disabled?: boolean | undefined;
+    readonly children: ReactNode;
+    readonly onClick: () => void;
+};
+/** A small round button inside a pill group (modes, axes, steppers). */
+export declare function PillButton({ title, active, wide, disabled, children, onClick }: PillButtonProps): import("react").JSX.Element;

package/dist/types/module/src/ui/atoms/range-input.d.ts

@@ -0,0 +1,17 @@
+import { type CSSProperties } from "react";
+export type RangeInputProps = {
+    readonly value: number;
+    readonly min: number;
+    readonly max: number;
+    readonly step?: number | undefined;
+    readonly id?: string | undefined;
+    readonly label: string;
+    readonly disabled?: boolean | undefined;
+    readonly style?: CSSProperties | undefined;
+    /** Every move while dragging (the value shown locally). */
+    readonly onPreview?: (value: number) => void;
+    /** Once, on release. */
+    readonly onCommit: (value: number) => void;
+};
+/** A native range input that previews while dragging and commits one value on release. */
+export declare function RangeInput({ value, min, max, step, id, label, disabled, style, onPreview, onCommit }: RangeInputProps): import("react").JSX.Element;

package/dist/types/module/src/ui/atoms/select-input.d.ts

@@ -0,0 +1,12 @@
+export type SelectInputProps<Value extends string> = {
+    readonly value: Value;
+    readonly label: string;
+    readonly options: readonly {
+        readonly id: Value;
+        readonly name: string;
+    }[];
+    readonly className?: string | undefined;
+    readonly onChange: (value: Value) => void;
+};
+/** A rounded select. */
+export declare function SelectInput<Value extends string>({ value, label, options, className, onChange }: SelectInputProps<Value>): import("react").JSX.Element;

package/dist/types/module/src/ui/atoms/separator.d.ts

@@ -0,0 +1,2 @@
+/** The thin divider between toolbar sections. */
+export declare function Separator(): import("react").JSX.Element;

package/dist/types/module/src/ui/atoms/side-button.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from "react";
+export type SideButtonProps = {
+    readonly icon: string;
+    readonly tooltip: string;
+    readonly id?: string | undefined;
+    /** scope-in-btn / scope-out-btn give the yellow / green look. */
+    readonly className?: string | undefined;
+    readonly active?: boolean | undefined;
+    readonly children?: ReactNode | undefined;
+    readonly onClick: () => void;
+};
+/** The big round frosted button of the side dock and the left stack. */
+export declare function SideButton({ icon, tooltip, id, className, active, children, onClick }: SideButtonProps): import("react").JSX.Element;

package/dist/types/module/src/ui/atoms/swatch.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from "react";
+export type SwatchProps = {
+    readonly color: string;
+    readonly title: string;
+    readonly fixed?: boolean | undefined;
+    readonly active?: boolean | undefined;
+    /** Fixed pixel size (rows); grids size swatches themselves. */
+    readonly size?: number | undefined;
+    readonly children?: ReactNode | undefined;
+    readonly onClick: () => void;
+};
+/** One round palette swatch. */
+export declare function Swatch({ color, title, fixed, active, size, children, onClick }: SwatchProps): import("react").JSX.Element;

package/dist/types/module/src/ui/atoms/tool-button.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from "react";
+import type { IconSpec } from "../lib/catalog.js";
+export type ToolButtonProps = {
+    readonly icon?: string | IconSpec | undefined;
+    /** Shown on hover, and the accessible name. */
+    readonly tooltip: string;
+    readonly active?: boolean | undefined;
+    /** "active-tool" (default) or "active-cat" for the category bar. */
+    readonly activeClass?: "active-tool" | "active-cat" | "play-active" | undefined;
+    /** Resting background and icon color. They are CSS variables the stylesheet reads, never inline `background` /
+     *  `color`, so a state class (on, active) always wins over them. */
+    readonly background?: string | undefined;
+    readonly color?: string | undefined;
+    readonly className?: string | undefined;
+    readonly id?: string | undefined;
+    readonly disabled?: boolean | undefined;
+    readonly children?: ReactNode | undefined;
+    readonly onClick?: () => void;
+    readonly onDoubleClick?: () => void;
+};
+/** The POC's round tool button with its tooltip. */
+export declare function ToolButton({ icon, tooltip, active, activeClass, background, color, className, id, disabled, children, onClick, onDoubleClick, }: ToolButtonProps): import("react").JSX.Element;

package/dist/types/module/src/ui/hooks/editor-actions.d.ts

@@ -0,0 +1,50 @@
+import type { Command, CreationApi, Id, Persistence, StampMode, SymmetryAxis } from "../../../../api/src/index.js";
+import { type ViewState } from "../lib/view-state.js";
+/** What the actions need from the page (read at call time, so they always see the latest state). */
+export type EditorCore = {
+    readonly api: CreationApi;
+    readonly persistence: Persistence;
+    view(): ViewState;
+    update(change: (view: ViewState) => ViewState): void;
+    dispatch(command: Command): boolean;
+    toast(message: string): void;
+    undo(): void;
+    redo(): void;
+};
+/** Studio actions shared by the chrome and the keyboard. */
+export type EditorActions = ReturnType<typeof editorActions>;
+export declare function editorActions(core: EditorCore): {
+    undo: () => void;
+    redo: () => void;
+    /** Sculpt the selected bone's part, giving the bone one first if it has none. */
+    sculptPart(boneId?: Id): void;
+    scopeIn(): void;
+    scopeOut(): void;
+    deselect(): void;
+    deleteSelection(): void;
+    deleteObject(id: Id): void;
+    duplicate(): void;
+    mirror(axis: "x" | "z"): void;
+    setBrushMode(mode: StampMode): void;
+    /** E: Add → Subtract → Intersect → Paint (modes only exist inside a sculpt). */
+    cycleMode(): void;
+    /** The size of whichever tool uses the size panel (stamp brush or decal). */
+    setSize(size: number): void;
+    resize(direction: 1 | -1): void;
+    rollDecal(degrees: number): void;
+    flipDecal(): void;
+    toggleBrushAxis(axes: readonly SymmetryAxis[]): void;
+    toggleHelp(force?: boolean): void;
+    openProperties(): void;
+    /** Double-click in the view: select the object and open its Properties. */
+    focus(id: Id): void;
+    togglePlay(): void;
+    toggleStress(): void;
+    toggleHints(): void;
+    /** Esc outside sculpt mode: close Help, back to the Select tool, then deselect. */
+    escapeStep(): void;
+    /** An Esc tap in sculpt mode (released before the hold completes). */
+    escapeTap(): void;
+    /** Downloads one object (with its subtree), the palette and the designs it uses as JSON. */
+    exportObject(id?: Id): void;
+};

package/dist/types/module/src/ui/hooks/editor-context.d.ts

@@ -0,0 +1,37 @@
+import type { Command, Creation, CreationApi, DecalCatalogEntry, DispatchResult, Id, LibrarySync, Persistence, ViewPreferences, Viewport, ViewportCallbacks } from "../../../../api/src/index.js";
+import type { ViewState } from "../lib/view-state.js";
+import type { EditorActions } from "./editor-actions.js";
+/** One open creation and its view state, shared by the page's organisms. Scoped to one page: not a global store. */
+export type Editor = {
+    readonly api: CreationApi;
+    readonly viewport: Viewport;
+    readonly persistence: Persistence;
+    readonly sync: LibrarySync | undefined;
+    readonly creationId: Id;
+    readonly onOpen: (id: Id) => void;
+    readonly creation: Creation;
+    readonly view: ViewState;
+    readonly compact: boolean;
+    readonly stats: string;
+    readonly toastMessage: {
+        readonly text: string;
+        readonly key: number;
+    } | undefined;
+    /** Esc hold progress in sculpt mode, 0–1. */
+    readonly escHold: number;
+    readonly catalog: readonly (DecalCatalogEntry & {
+        readonly category: string;
+    })[];
+    readonly callbacks: ViewportCallbacks;
+    readonly actions: EditorActions;
+    update(change: (view: ViewState) => ViewState): void;
+    /** Dispatches through the contract; a rejection shows the core's reason. True when accepted. */
+    dispatch(command: Command): boolean;
+    run(command: Command): DispatchResult;
+    toast(message: string): void;
+    setPrefs(patch: Partial<ViewPreferences>): void;
+    /** Saves the open creation's log now (with a viewport thumbnail). */
+    save(): Promise<void>;
+};
+export declare const EditorContext: import("react").Context<Editor | undefined>;
+export declare function useEditor(): Editor;

package/dist/types/module/src/ui/hooks/use-compact.d.ts

@@ -0,0 +1,2 @@
+/** The phone layout: small screens, or `?ui=compact` (`?ui=desktop` forces the desktop layout). */
+export declare function useCompact(): boolean;