@felbrasil/dreamy 0.0.0-stage → 0.1.0

package/dist/types/core/src/atoms/math/mat4.d.ts

@@ -0,0 +1,14 @@
+import type { Quaternion, Transform, Vec3 } from "../../../../api/src/index.js";
+/** Column-major 4x4 matrix (three.js layout). */
+export type Mat4 = readonly number[];
+export declare const IDENTITY_M: Mat4;
+export declare function compose(position: Vec3, rotation: Quaternion, scale: Vec3): Mat4;
+export declare const composeTransform: (t: Transform) => Mat4;
+/** a * b. */
+export declare function multiplyM(a: Mat4, b: Mat4): Mat4;
+export declare function determinant(m: Mat4): number;
+export declare function invertM(m: Mat4): Mat4;
+/** Position, rotation and scale of a matrix (three.js decompose: a negative determinant flips x). */
+export declare function decompose(m: Mat4): Transform;
+export declare const transformPoint: (m: Mat4, p: Vec3) => Vec3;
+export declare const positionOf: (m: Mat4) => Vec3;

package/dist/types/core/src/atoms/math/quat.d.ts

@@ -0,0 +1,18 @@
+import type { Quaternion, Vec3 } from "../../../../api/src/index.js";
+export declare const quat: (x: number, y: number, z: number, w: number) => Quaternion;
+export declare const IDENTITY_Q: Quaternion;
+export declare function normalizeQ(q: Quaternion): Quaternion;
+/** a * b: apply b, then a. */
+export declare const multiplyQ: (a: Quaternion, b: Quaternion) => Quaternion;
+/** Inverse of a unit quaternion. */
+export declare const invertQ: (q: Quaternion) => Quaternion;
+export declare function rotate(v: Vec3, q: Quaternion): Vec3;
+/** The shortest rotation taking unit vector `from` onto unit vector `to` (three.js setFromUnitVectors). */
+export declare function fromUnitVectors(from: Vec3, to: Vec3): Quaternion;
+/** Rotation whose matrix has columns x, y, z (three.js makeBasis + setFromRotationMatrix). */
+export declare function fromBasis(x: Vec3, y: Vec3, z: Vec3): Quaternion;
+/** Row-major 3x3 rotation matrix to a quaternion. */
+export declare function fromRotationMatrix(m11: number, m12: number, m13: number, m21: number, m22: number, m23: number, m31: number, m32: number, m33: number): Quaternion;
+/** Euler angles in radians, XYZ order (three.js default). */
+export declare function fromEulerXYZ(x: number, y: number, z: number): Quaternion;
+export declare const isFiniteQ: (q: Quaternion) => boolean;

package/dist/types/core/src/atoms/math/transform.d.ts

@@ -0,0 +1,7 @@
+import type { Transform, Vec3 } from "../../../../api/src/index.js";
+export declare const IDENTITY_TRANSFORM: Transform;
+export declare const translation: (position: Vec3) => Transform;
+/** Why a transform cannot be stored, or undefined when it can (scale may be negative: mirrored objects). */
+export declare function transformProblem(t: Transform): string | undefined;
+/** Same transform with a unit rotation. */
+export declare const cleanTransform: (t: Transform) => Transform;

package/dist/types/core/src/atoms/math/vec3.d.ts

@@ -0,0 +1,18 @@
+import type { Vec3 } from "../../../../api/src/index.js";
+export declare const vec3: (x: number, y: number, z: number) => Vec3;
+export declare const ZERO: Vec3;
+export declare const ONE: Vec3;
+export declare const add: (a: Vec3, b: Vec3) => Vec3;
+export declare const sub: (a: Vec3, b: Vec3) => Vec3;
+export declare const scale: (a: Vec3, k: number) => Vec3;
+export declare const mul: (a: Vec3, b: Vec3) => Vec3;
+export declare const addScaled: (a: Vec3, b: Vec3, k: number) => Vec3;
+export declare const dot: (a: Vec3, b: Vec3) => number;
+export declare const cross: (a: Vec3, b: Vec3) => Vec3;
+export declare const length: (a: Vec3) => number;
+export declare const distance: (a: Vec3, b: Vec3) => number;
+export declare function normalize(a: Vec3): Vec3;
+export declare const lerp: (a: Vec3, b: Vec3, t: number) => Vec3;
+export declare const negate: (a: Vec3) => Vec3;
+export declare const fromArray: (a: readonly number[]) => Vec3;
+export declare const isFiniteVec: (a: Vec3) => boolean;

package/dist/types/core/src/atoms/palette/default-palette.d.ts

@@ -0,0 +1,4 @@
+import type { Palette, PaletteSlot } from "../../../../api/src/index.js";
+export declare const DEFAULT_PALETTE: Palette;
+/** The editable slots, in the POC's index order (`s:0` … `s:6`). */
+export declare const PALETTE_SLOTS: readonly PaletteSlot[];

package/dist/types/core/src/atoms/palette/is-color-ref.d.ts

@@ -0,0 +1,2 @@
+import type { ColorRef } from "../../../../api/src/index.js";
+export declare const isColorRef: (value: unknown) => value is ColorRef;

package/dist/types/core/src/atoms/palette/poc-color-ref.d.ts

@@ -0,0 +1,6 @@
+import type { ColorRef } from "../../../../api/src/index.js";
+/**
+ * A POC slot reference (`s:0` … `s:6`, `s:tongue`, `s:teeth`, `s:black`) as a palette ref.
+ * Anything else (a literal number) falls back to `fallback`: the new model never stores raw colors.
+ */
+export declare function pocColorRef(ref: unknown, fallback?: ColorRef): ColorRef;

package/dist/types/core/src/atoms/rig/bone-matrices.d.ts

@@ -0,0 +1,8 @@
+import type { Bone, Id, Vec3 } from "../../../../api/src/index.js";
+import { type Mat4 } from "../math/mat4.js";
+/** Every bone's matrix in the rig's space, for the bind or the pose channel. */
+export declare function boneMatrices(bones: readonly Bone[], channel: "bind" | "pose"): Map<Id, Mat4>;
+/** Every bone's bind head (joint position) in the rig's space. */
+export declare function bindHeads(bones: readonly Bone[]): Map<Id, Vec3>;
+/** True when `id` is `ancestorId` or one of its descendants. */
+export declare function isBoneInSubtree(bones: readonly Bone[], id: Id, ancestorId: Id): boolean;

package/dist/types/core/src/atoms/rig/bone-region.d.ts

@@ -0,0 +1,8 @@
+import type { BodyRegion, RegionBlends } from "../../../../api/src/index.js";
+export declare const DEFAULT_REGION_BLENDS: RegionBlends;
+export declare const BODY_REGIONS: readonly BodyRegion[];
+/** POC getBoneRegion: which region blend a bone's part follows. */
+export declare function boneRegion(bone: {
+    readonly name: string;
+    readonly tags: readonly string[];
+}): BodyRegion;

package/dist/types/core/src/atoms/rig/bone-role.d.ts

@@ -0,0 +1,11 @@
+/** Name patterns for bones without a `role:` tag (POC PART_ROLES, first match wins, else "limb"). */
+export declare const PART_ROLES: readonly (readonly [string, RegExp])[];
+type Named = {
+    readonly name: string;
+    readonly tags: readonly string[];
+};
+/** The `role:<role>` tag, if any. */
+export declare function taggedRole(bone: Named): string | undefined;
+/** POC resolveBoneRole: the role tag, else a role guessed from the name. */
+export declare function resolveBoneRole(bone: Named): string;
+export {};

package/dist/types/core/src/atoms/rig/bone-size.d.ts

@@ -0,0 +1,7 @@
+import type { Bone, BoneSize } from "../../../../api/src/index.js";
+export declare const DEFAULT_BONE_SIZE: BoneSize;
+export declare const MAX_BONE_SIZE = 2.5;
+/** A bone's proportions (absent = 1, 1). */
+export declare const boneSize: (bone: Pick<Bone, "size">) => BoneSize;
+/** The smallest size a bone may take: a head is never smaller than it was made. */
+export declare const minBoneSize: (bone: Pick<Bone, "name" | "tags">) => number;

package/dist/types/core/src/atoms/rig/compose-local.d.ts

@@ -0,0 +1,6 @@
+import type { Transform } from "../../../../api/src/index.js";
+import { type Mat4 } from "../math/mat4.js";
+/** parent ∘ child as one local transform (the child lifted one level up). */
+export declare const composeLocal: (parent: Transform, child: Transform) => Transform;
+/** The local transform under `parentWorld` that keeps `world` where it is. */
+export declare const relativeTo: (parentWorld: Mat4, world: Mat4) => Transform;

package/dist/types/core/src/atoms/rig/find-rig.d.ts

@@ -0,0 +1,11 @@
+import type { Bone, Creation, Id, RigObject } from "../../../../api/src/index.js";
+export type RigLookup = {
+    readonly ok: true;
+    readonly object: RigObject;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+export declare function findRig(creation: Creation, rigId: Id): RigLookup;
+export declare const findBone: (object: RigObject, boneId: Id) => Bone | undefined;
+export declare const MAX_BONES = 64;

package/dist/types/core/src/atoms/rig/mirror-partner.d.ts

@@ -0,0 +1,3 @@
+import type { Bone } from "../../../../api/src/index.js";
+/** POC mirrorPartner: the bone on the opposite `side:` sharing a `mirror:` key, if any. */
+export declare function mirrorPartner(bones: readonly Bone[], bone: Bone): Bone | undefined;

package/dist/types/core/src/atoms/rig/mirror-sculpt.d.ts

@@ -0,0 +1,9 @@
+import type { Sculpt, Stamp } from "../../../../api/src/index.js";
+/** POC mirrorStamp: position reflected across x = mirrorX, rotation reflected, scale kept. */
+export declare const mirrorStamp: (s: Stamp, mirrorX: number) => Stamp;
+/**
+ * POC syncMirrorPart: the partner part becomes the source's stamps reflected, with the same smear groups.
+ * Without an existing twin, the twin also takes the source's look. Stamp and group ids are shared with the
+ * source (they are scoped to the part), so edits keep landing on the same stamps.
+ */
+export declare function mirrorSculpt(source: Sculpt, mirrorX: number, twin: Sculpt | undefined): Sculpt;

package/dist/types/core/src/atoms/rig/mirror-transform.d.ts

@@ -0,0 +1,9 @@
+import type { Quaternion, Transform, Vec3 } from "../../../../api/src/index.js";
+/** A rotation reflected across a YZ plane (M R M with M = scale(-1, 1, 1)). */
+export declare const mirrorRotation: (q: Quaternion) => Quaternion;
+export declare const mirrorPoint: (p: Vec3, mirrorX: number) => Vec3;
+/**
+ * POC mirrorChannel: a bone's local transform reflected for its partner (M L M). A child bone mirrors
+ * across its parent's x = 0; a root bone across the rig's mirror plane x = mirrorX.
+ */
+export declare function mirrorBoneTransform(t: Transform, isRoot: boolean, mirrorX: number): Transform;

package/dist/types/core/src/atoms/rig/partner-target.d.ts

@@ -0,0 +1,3 @@
+import type { Creation, SculptTarget } from "../../../../api/src/index.js";
+/** With the rig's mirror on, the target of the bone's mirror partner (POC: part edits are mirrored). */
+export declare function partnerTarget(creation: Creation, target: SculptTarget): SculptTarget | undefined;

package/dist/types/core/src/atoms/rig/pose-presets.d.ts

@@ -0,0 +1,11 @@
+import type { Bone, Id, PosePreset, PosePresetId, Rig, Transform } from "../../../../api/src/index.js";
+/** Every preset, in picker order (Custom is offered only once a rig has a hand-posed pose). */
+export declare const POSE_PRESETS: readonly PosePresetId[];
+/** Picker names; a wingless rig flies by leaping. */
+export declare function posePresetName(id: PosePresetId, winged: boolean): string;
+/** Whether a skeleton has wings (its flying presets fly; without wings they leap and pounce). */
+export declare const isWinged: (bones: readonly Pick<Bone, "name" | "tags">[]) => boolean;
+/** One preset's pose for every bone (bone id → pose transform). Custom falls back to the bind for unknown bones. */
+export declare function presetPose(rig: Rig, id: PosePresetId): Map<Id, Transform>;
+/** The pose a preset choice gives: `a`, or `a` blended toward `b` by `t`. */
+export declare function blendedPose(rig: Rig, preset: PosePreset): Map<Id, Transform>;

package/dist/types/core/src/atoms/rig/pose-rule.d.ts

@@ -0,0 +1,48 @@
+import type { Vec3 } from "../../../../api/src/index.js";
+/** What a pose rule knows about one bone. */
+export type BoneInfo = {
+    readonly name: string;
+    /** The numbers in its name ("Arm 3 Seg 2" → [3, 2]); premade rules address chains by them. */
+    readonly nums: readonly number[];
+    readonly role: string;
+    /** +1 side L (+x), -1 side R, 0 on the middle. */
+    readonly side: 1 | -1 | 0;
+    /** Index in its run of same-role bones, and that run's length. */
+    readonly depth: number;
+    readonly n: number;
+    readonly isRoot: boolean;
+    /** Legs: the chain's first bone is in the front half of the legs. */
+    readonly front: boolean;
+    readonly winged: boolean;
+    /** Wing chains: the chain's rest elevation above level (radians), in the side-L frame. */
+    readonly elevation: number;
+    /** Level unit direction from the root to the start of its chain (radial limbs such as tentacles). */
+    readonly radial: Vec3;
+};
+/** Euler XYZ (radians) in the side-L frame, mirrored for side R. */
+export type Euler = readonly [number, number, number];
+/**
+ * A radial limb's turn: `curl` about the level axis across its radial direction (positive lifts the tip up and out),
+ * then `swirl` about the vertical. For limbs with no side, such as an octopus's arms.
+ */
+export type Turn = {
+    readonly curl: number;
+    readonly swirl?: number;
+};
+export type Rule = {
+    /** Root move as a fraction of the skeleton's height (y) and length (z). */
+    readonly lift?: number;
+    readonly ahead?: number;
+    readonly bone: (b: BoneInfo) => Euler | Turn | undefined;
+};
+export declare const WING_ROLES: Set<string>;
+export declare const LEG_ROLES: Set<string>;
+/** A chain's total angle spread over its bones. */
+export declare const per: (b: BoneInfo, total: number) => number;
+export declare const isLeg: (b: BoneInfo) => boolean;
+export declare const isWing: (b: BoneInfo) => boolean;
+export declare const chainStart: (b: BoneInfo) => boolean;
+/** Roll a wing chain from its rest elevation to `target` (radians above level): wings rest at different angles. */
+export declare const wingTo: (b: BoneInfo, target: number, sweep?: number) => Euler;
+/** A bone named "<stem> <k>" (the body chains of the premades). */
+export declare const isNamed: (b: BoneInfo, stem: string, k?: number) => boolean;

package/dist/types/core/src/atoms/rig/pose-template-rules.d.ts

@@ -0,0 +1,8 @@
+import type { PosePresetId } from "../../../../api/src/index.js";
+import { type Rule } from "./pose-rule.js";
+type PresetRules = Partial<Record<Exclude<PosePresetId, "front" | "custom">, Rule>>;
+/** Premades whose body plan the role rules don't cover: their own rules replace the generic ones per preset. */
+export declare const TEMPLATE_RULES: {
+    readonly [templateId: string]: PresetRules;
+};
+export {};

package/dist/types/core/src/atoms/rig/rebase-pose.d.ts

@@ -0,0 +1,6 @@
+import type { Transform } from "../../../../api/src/index.js";
+/**
+ * POC Skeleton.setRigMode: a rig-mode edit moves the bind; the pose rides on top as a delta
+ * (p = bind.p + dp, q = bind.q * dq, s = bind.s * ds).
+ */
+export declare function rebasePose(oldBind: Transform, pose: Transform, newBind: Transform): Transform;

package/dist/types/core/src/atoms/rig/resize-bones.d.ts

@@ -0,0 +1,12 @@
+import type { BodyPart, BoneSize, BoneSizesSet, Id, Rig, Vec3 } from "../../../../api/src/index.js";
+type Resolved = BoneSizesSet["payload"];
+/** A part carried along with its joint: stamps, decals, pivot and a flat wing's frame move by `d`. */
+export declare function translatePart(part: BodyPart, d: Vec3): BodyPart;
+/**
+ * What new bone sizes do to a rig: a length change moves the bone's child joints (their bind offsets scale by new /
+ * old length; their poses keep their deltas), and every part below carries along with its joint.
+ */
+export declare function resolveBoneSizes(rig: Rig, sizes: ReadonlyMap<Id, BoneSize>): Omit<Resolved, "rigId">;
+/** A rig with resolved bone sizes applied (the fold's and the generator's one way of doing it). */
+export declare function applyBoneSizes(r: Rig, e: Omit<Resolved, "rigId">): Rig;
+export {};

package/dist/types/core/src/atoms/rig/rig-extent.d.ts

@@ -0,0 +1,3 @@
+import type { Vec3 } from "../../../../api/src/index.js";
+/** POC rigExtent: half the largest side of the bind joints' box, at least 0.8. */
+export declare function rigExtent(heads: readonly Vec3[]): number;

package/dist/types/core/src/atoms/rig/side-from-name.d.ts

@@ -0,0 +1,7 @@
+/** POC autoTagSides: "Arm L", "Arm_R", "Left Arm" → the side letter and the shared stem. */
+export declare function sideFromName(name: string): {
+    readonly side: "L" | "R";
+    readonly stem: string;
+} | undefined;
+/** The tags with the side and mirror tags replaced. */
+export declare const withSideTags: (tags: readonly string[], side: "L" | "R", stem: string) => string[];

package/dist/types/core/src/atoms/rig/size-frame.d.ts

@@ -0,0 +1,18 @@
+import type { Bone, Id, Vec3 } from "../../../../api/src/index.js";
+/**
+ * The frame a bone's size scales its part in: its head, and its axis toward its farthest child that isn't a side
+ * branch (a centre bone's left / right ears, antennae or legs don't count), else from its parent. The viewport's
+ * `writeSegmentMatrices` uses the same rule, so a head sized unevenly stays symmetric and doesn't depend on its ears.
+ */
+export declare function sizeFrame(bone: Bone, bones: readonly Bone[], heads: ReadonlyMap<Id, Vec3>): {
+    readonly h: Vec3;
+    readonly axis: Vec3;
+};
+/**
+ * A point and scale of a sized bone's part as drawn: along the bone by its length, across it by its thickness
+ * (`inverse` maps a drawn one back to how it's stored).
+ */
+export declare function sizePoint(bone: Bone, bones: readonly Bone[], heads: ReadonlyMap<Id, Vec3>, p: Vec3, s: Vec3, inverse?: boolean): {
+    p: Vec3;
+    s: Vec3;
+};

package/dist/types/core/src/atoms/rig/with-slot-parts.d.ts

@@ -0,0 +1,9 @@
+import type { BodyPart, Id, PartSlot, Rig } from "../../../../api/src/index.js";
+/**
+ * A rig with a slot's fitted parts in place: `parts` replace their bones' parts, `removed` bones lose theirs. A
+ * generated rig's recipe follows, so a later re-roll that keeps the slot keeps this kit.
+ */
+export declare function withSlotParts(r: Rig, slot: PartSlot, kit: string, fitted: {
+    readonly parts: readonly BodyPart[];
+    readonly removed: readonly Id[];
+}): Rig;

package/dist/types/core/src/atoms/scene/copy-with-new-ids.d.ts

@@ -0,0 +1,7 @@
+import type { Id, IdGenerator, Rig, SceneObject, Sculpt } from "../../../../api/src/index.js";
+/** A sculpt with fresh stamp, smear group and decal ids (references between them kept). */
+export declare function copySculpt(s: Sculpt, ids: IdGenerator): Sculpt;
+/** A rig with fresh bone ids; parents and parts follow their bones. */
+export declare function copyRig(r: Rig, ids: IdGenerator): Rig;
+/** An object's copy with a new id (its parent is set by the caller). */
+export declare function copyObject(o: SceneObject, id: Id, ids: IdGenerator): SceneObject;

package/dist/types/core/src/atoms/scene/object-tree.d.ts

@@ -0,0 +1,8 @@
+import type { Creation, Id, SceneObject } from "../../../../api/src/index.js";
+export declare const findObject: (creation: Creation, id: Id) => SceneObject | undefined;
+/** The object's children, in scene order. */
+export declare const childrenOf: (objects: readonly SceneObject[], parentId: Id | undefined) => SceneObject[];
+/** The object and every object below it, in scene order. */
+export declare function subtreeIds(objects: readonly SceneObject[], rootId: Id): Id[];
+/** True when `id` is `ancestorId` or sits somewhere below it. */
+export declare function isInSubtree(objects: readonly SceneObject[], id: Id, ancestorId: Id): boolean;

package/dist/types/core/src/atoms/scene/place-in-order.d.ts

@@ -0,0 +1,7 @@
+import type { SceneObject } from "../../../../api/src/index.js";
+/**
+ * The scene list with `object` (already re-parented) moved so it becomes child number `index` of its
+ * parent. Only the order among siblings carries meaning, so it goes just before the sibling it displaces,
+ * or to the end of the list.
+ */
+export declare function placeInOrder(objects: readonly SceneObject[], object: SceneObject, index: number): SceneObject[];

package/dist/types/core/src/atoms/scene/unique-name.d.ts

@@ -0,0 +1,4 @@
+/** `base`, or `base 2`, `base 3`… when the name is taken (POC rig builder naming). */
+export declare function uniqueName(base: string, taken: readonly string[]): string;
+/** `Prefix N` with N one past the highest number already used by that prefix. */
+export declare function nextNumberedName(prefix: string, taken: readonly string[]): string;

package/dist/types/core/src/atoms/scene/world-matrix.d.ts

@@ -0,0 +1,4 @@
+import type { Id, SceneObject } from "../../../../api/src/index.js";
+import { type Mat4 } from "../math/mat4.js";
+/** An object's world matrix: its parents' transforms composed down to it (identity for the scene root). */
+export declare function worldMatrix(objects: readonly SceneObject[], id: Id | undefined): Mat4;

package/dist/types/core/src/atoms/sculpt/all-sculpts.d.ts

@@ -0,0 +1,3 @@
+import type { Creation, Sculpt } from "../../../../api/src/index.js";
+/** Every sculpt in the creation: sculpt objects, rig bodies and rig sculpt parts. */
+export declare function allSculpts(creation: Creation): Sculpt[];

package/dist/types/core/src/atoms/sculpt/is-wing-target.d.ts

@@ -0,0 +1,3 @@
+import type { Creation, SculptTarget } from "../../../../api/src/index.js";
+/** True when the target names a rig bone whose part is a flat wing. */
+export declare function isWingTarget(creation: Creation, target: SculptTarget): boolean;

package/dist/types/core/src/atoms/sculpt/target-sculpt.d.ts

@@ -0,0 +1,10 @@
+import type { Creation, Sculpt, SculptTarget } from "../../../../api/src/index.js";
+export type TargetLookup = {
+    readonly ok: true;
+    readonly sculpt: Sculpt;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+/** The sculpt a target names: a sculpt object, a rig's skinned body, or the sculpt part of a rig's bone. */
+export declare function targetSculpt(creation: Creation, target: SculptTarget): TargetLookup;

package/dist/types/core/src/atoms/sculpt/update-target.d.ts

@@ -0,0 +1,8 @@
+import type { Creation, Rig, Sculpt, SculptTarget, SceneObject } from "../../../../api/src/index.js";
+export declare const mapObject: (creation: Creation, id: string, fn: (o: SceneObject) => SceneObject) => Creation;
+export declare const mapRig: (creation: Creation, id: string, fn: (r: Rig) => Rig) => Creation;
+/**
+ * The creation with the target's sculpt replaced by `fn(sculpt)`. Edits to a rig part are mirrored onto
+ * the partner part when the rig's mirror is on (`mirror: false` skips that, e.g. for decals).
+ */
+export declare function updateTarget(creation: Creation, target: SculptTarget, fn: (s: Sculpt) => Sculpt, mirror?: boolean): Creation;

package/dist/types/core/src/atoms/stamp/apply-stamp-props.d.ts

@@ -0,0 +1,11 @@
+import type { SmearGroup, Stamp, StampPropsPatch } from "../../../../api/src/index.js";
+/** A stamp with the patch applied: `null` clears an override, absent keeps it. */
+export declare function applyStampProps(stamp: Stamp, patch: StampPropsPatch): Stamp;
+/**
+ * A smear group with the patch applied. A group always has a mode, color and blend, so clearing those
+ * keeps them; the foundation and symmetry can be cleared.
+ */
+export declare function applyGroupProps(group: SmearGroup, patch: StampPropsPatch & {
+    readonly unlocked?: boolean;
+    readonly name?: string;
+}): SmearGroup;

package/dist/types/core/src/atoms/stamp/clamp-symmetry.d.ts

@@ -0,0 +1,11 @@
+import type { Symmetry, SymmetryAxis } from "../../../../api/src/index.js";
+export declare const SYM_MAX_N = 12;
+export declare const SYM_MAX_INSTANCES = 128;
+/** The listed axes once each, in x, y, z order. */
+export declare const symmetryAxes: (axes: readonly SymmetryAxis[]) => SymmetryAxis[];
+/**
+ * POC symClampN: N rounded into 1–12, then lowered until N^(axis count) fits 128 instances
+ * (1 axis: 12, 2 axes: 11, 3 axes: 5).
+ */
+export declare function clampCount(n: number, axes: readonly SymmetryAxis[]): number;
+export declare function clampSymmetry(s: Symmetry): Symmetry;

package/dist/types/core/src/atoms/stamp/clean-props.d.ts

@@ -0,0 +1,3 @@
+import type { StampPropsPatch } from "../../../../api/src/index.js";
+/** A props patch with its symmetry clamped (POC symClampN). */
+export declare const cleanProps: <P extends StampPropsPatch>(p: P) => P;

package/dist/types/core/src/atoms/stamp/emptied-groups.d.ts

@@ -0,0 +1,3 @@
+import type { Id, Sculpt } from "../../../../api/src/index.js";
+/** The smear groups that have no stamps left once `removed` are gone (POC cleanupGroups). */
+export declare function emptiedGroups(sculpt: Sculpt, removed: ReadonlySet<Id>): Id[];

package/dist/types/core/src/atoms/stamp/move-locked-groups.d.ts

@@ -0,0 +1,12 @@
+import type { Id, Quaternion, Sculpt, Vec3 } from "../../../../api/src/index.js";
+export type PlacementChange = {
+    readonly stampId: Id;
+    readonly position: Vec3;
+    readonly rotation: Quaternion;
+    readonly scale: Vec3;
+};
+/**
+ * A locked smear group moves as one: when a change touches a locked group but leaves some members out,
+ * the moved stamp's change (new ∘ old⁻¹) is applied to those members too.
+ */
+export declare function moveLockedGroups(sculpt: Sculpt, changes: readonly PlacementChange[]): PlacementChange[];

package/dist/types/core/src/atoms/stamp/normalize-base.d.ts

@@ -0,0 +1,6 @@
+import type { Sculpt } from "../../../../api/src/index.js";
+/** POC normalizeBase: the first stamp (or the smear group it belongs to) is always additive. */
+export declare function normalizeBase(sculpt: Sculpt): Sculpt;
+/** True when the stamp or group is the base: its mode cannot leave "add". */
+export declare function isBaseStamp(sculpt: Sculpt, stampId: string): boolean;
+export declare function isBaseGroup(sculpt: Sculpt, groupId: string): boolean;

package/dist/types/core/src/atoms/stamp/resolve-stamp-props.d.ts

@@ -0,0 +1,14 @@
+import type { ColorRef, MaterialOverrides, Sculpt, Stamp, StampMode, Symmetry } from "../../../../api/src/index.js";
+export type ResolvedStampProps = {
+    readonly mode: StampMode;
+    readonly color: ColorRef;
+    readonly foundationColor: ColorRef;
+    readonly blend: number;
+    readonly material: MaterialOverrides;
+    readonly symmetry?: Symmetry;
+};
+/**
+ * What a stamp actually uses (POC resolveStampProps): its smear group's mode, color, foundation, blend and
+ * symmetry win over its own; anything left unset falls back to the sculpt's look.
+ */
+export declare function resolveStampProps(stamp: Stamp, sculpt: Sculpt): ResolvedStampProps;

package/dist/types/core/src/atoms/stamp/smear.d.ts

@@ -0,0 +1,15 @@
+import type { Sculpt, Vec3 } from "../../../../api/src/index.js";
+/** Fraction of the stamp size between smear dabs. */
+export declare const SMEAR_SPACING_FACTOR = 0.4;
+/** Most dabs one pointer move adds. */
+export declare const SMEAR_MAX_DABS = 24;
+export declare const smearSpacing: (stampSize: number) => number;
+/**
+ * POC stampCurrentShape while smearing: evenly spaced dabs from the last dab to the pointer, none when the
+ * pointer moved less than one spacing, at most 24 per move. The module may use this to build its preview.
+ */
+export declare function smearDabs(last: Vec3, target: Vec3, stampSize: number): Vec3[];
+/** A small brush gets a proportionally small blend so dabs do not melt into one blob (POC: size × 0.5). */
+export declare const smearGroupBlend: (requested: number, dabScale: Vec3) => number;
+/** "Smear N": one more than the highest smear number already in the sculpt. */
+export declare function nextSmearName(sculpt: Sculpt): string;

package/dist/types/core/src/atoms/stamp/stamp-problem.d.ts

@@ -0,0 +1,7 @@
+import type { MaterialOverrides, StampPropsPatch, StampSpec, Symmetry } from "../../../../api/src/index.js";
+import { type Problem } from "../check/check.js";
+export declare function symmetryProblem(s: Symmetry | null | undefined): Problem;
+export declare function overridesProblem(m: MaterialOverrides | null | undefined): Problem;
+export declare function placementProblem(p: StampSpec["position"], r: StampSpec["rotation"], s: StampSpec["scale"]): Problem;
+export declare function propsProblem(p: StampPropsPatch): Problem;
+export declare function stampSpecProblem(s: StampSpec): Problem;

package/dist/types/core/src/atoms/wing/wing-problem.d.ts

@@ -0,0 +1,6 @@
+import type { FlatWing, WingOutline, WingPatternStyle } from "../../../../api/src/index.js";
+import { type Problem } from "../check/check.js";
+export declare const WING_OUTLINES: readonly WingOutline[];
+export declare const WING_STYLES: readonly WingPatternStyle[];
+/** Why a wing tab edit breaks the model's ranges, if it does. */
+export declare function wingProblem(w: Partial<Omit<FlatWing, "frame">>): Problem;

package/dist/types/core/src/create-creation-api.d.ts

@@ -0,0 +1,12 @@
+import type { Clock, CreationApi, CreationLog, IdGenerator } from "../../api/src/index.js";
+export type CreationApiDeps = {
+    readonly ids: IdGenerator;
+    readonly clock: Clock;
+    /** The log to open; absent starts an empty creation. */
+    readonly log?: CreationLog;
+};
+/**
+ * The core: validates commands, appends one event per accepted command and folds the log. Undo and redo
+ * move a cursor over the events; the redo tail lives here, and the next accepted command drops it.
+ */
+export declare function createCreationApi({ ids, clock, log }: CreationApiDeps): CreationApi;

package/dist/types/core/src/decide.d.ts

@@ -0,0 +1,4 @@
+import type { Command, Creation } from "../../api/src/index.js";
+import { type Decision, type MoleculeContext } from "./molecules/molecule.js";
+/** Routes a command to its molecule. */
+export declare function decide(c: Creation, cmd: Command, ctx: MoleculeContext): Decision;

package/dist/types/core/src/empty-creation.d.ts

@@ -0,0 +1,2 @@
+import type { Creation } from "../../api/src/index.js";
+export declare const EMPTY_CREATION: Creation;

package/dist/types/core/src/fold.d.ts

@@ -0,0 +1,6 @@
+import type { Creation, CreationEvent, CreationLog } from "../../api/src/index.js";
+/** One event folded into the creation. Events naming things that no longer exist change nothing. */
+export declare function applyEvent(c: Creation, e: CreationEvent): Creation;
+/** The creation a list of events describes. */
+export declare const foldEvents: (events: readonly CreationEvent[]) => Creation;
+export declare const fold: (log: CreationLog) => Creation;

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

@@ -0,0 +1,9 @@
+export { createCreationApi, type CreationApiDeps } from "./create-creation-api.js";
+export { fold, foldEvents, applyEvent } from "./fold.js";
+export { EMPTY_CREATION } from "./empty-creation.js";
+export { DEFAULT_PALETTE } from "./atoms/palette/default-palette.js";
+export { resolveStampProps, type ResolvedStampProps } from "./atoms/stamp/resolve-stamp-props.js";
+export { smearDabs, smearSpacing, SMEAR_MAX_DABS, SMEAR_SPACING_FACTOR } from "./atoms/stamp/smear.js";
+export { clampSymmetry } from "./atoms/stamp/clamp-symmetry.js";
+export { mirrorPartner } from "./atoms/rig/mirror-partner.js";
+export { boneRegion } from "./atoms/rig/bone-region.js";

package/dist/types/core/src/molecules/add-body-part.d.ts

@@ -0,0 +1,8 @@
+import type { AddBodyPart } from "../../../api/src/index.js";
+import { type Molecule } from "./molecule.js";
+/**
+ * POC sculptBonePart: a generated part for the bone (styled and colored by the rig's template when it has
+ * one), a flat wing for a wing chain's first bone, else a knob to sculpt from. Baked parts are not
+ * regenerated: the bake's fit is not stored on the rig.
+ */
+export declare const addBodyPart: Molecule<AddBodyPart>;

package/dist/types/core/src/molecules/add-bone.d.ts

@@ -0,0 +1,8 @@
+import type { AddBone } from "../../../api/src/index.js";
+import { type Molecule } from "./molecule.js";
+/**
+ * POC addBone (rig mode only): a bone whose head sits at `head` in rig space. With mirror on and the head
+ * off the mirror plane, the partner is added too at the reflected head (under the parent's partner, if
+ * any), the pair tagged side:L (+x) / side:R and sharing a mirror key.
+ */
+export declare const addBone: Molecule<AddBone>;

package/dist/types/core/src/molecules/add-decals.d.ts

@@ -0,0 +1,4 @@
+import type { AddDecals } from "../../../api/src/index.js";
+import { type Molecule } from "./molecule.js";
+/** Places decals on a sculpt (at most 64, of which 8 interior rooms). */
+export declare const addDecals: Molecule<AddDecals>;

package/dist/types/core/src/molecules/add-stamps.d.ts

@@ -0,0 +1,8 @@
+import type { AddStamps } from "../../../api/src/index.js";
+import { type Molecule } from "./molecule.js";
+/**
+ * One click adds one stamp; a smear stroke adds all its dabs as a new smear group (POC stampCurrentShape).
+ * The group carries the stroke's mode, color, symmetry and a blend no larger than half the dab size. A
+ * stroke of a single dab is no group: the dab takes the stroke's settings itself (POC finalizeSmearGroup).
+ */
+export declare const addStamps: Molecule<AddStamps>;

package/dist/types/core/src/molecules/apply-pose-preset.d.ts

@@ -0,0 +1,4 @@
+import type { ApplyPosePreset } from "../../../api/src/index.js";
+import { type Molecule } from "./molecule.js";
+/** Poses a premade rig from its presets (one, or two blended by `t`); the event carries the resolved poses. */
+export declare const applyPosePreset: Molecule<ApplyPosePreset>;

package/dist/types/core/src/molecules/apply-premade.d.ts

@@ -0,0 +1,9 @@
+import type { ApplyPremade } from "../../../api/src/index.js";
+import { type Molecule } from "./molecule.js";
+/**
+ * POC applyPremadeSkeleton. A new rig is named after the template and raised so its feet stand on the
+ * transform's ground height. On an object, the skeleton replaces the old one, fitted to the given bounds:
+ * a sculpt (or a rig with a skinned body) keeps its stamps as the rig's body and gets no parts, as in the
+ * POC; a body-less rig gets the template's parts when `withBody` is set.
+ */
+export declare const applyPremade: Molecule<ApplyPremade>;

package/dist/types/core/src/molecules/auto-tag-sides.d.ts

@@ -0,0 +1,4 @@
+import type { AutoTagSides } from "../../../api/src/index.js";
+import { type Molecule } from "./molecule.js";
+/** POC autoTagSides: names like "Arm L" or "Left Arm" become side + mirror tags. */
+export declare const autoTagSides: Molecule<AutoTagSides>;

package/dist/types/core/src/molecules/create-rig.d.ts

@@ -0,0 +1,4 @@
+import type { CreateRig } from "../../../api/src/index.js";
+import { type Molecule } from "./molecule.js";
+/** An empty rig in rig mode, ready for bones. */
+export declare const createRig: Molecule<CreateRig>;