@felbrasil/dreamy 0.0.0-stage → 0.1.0

package/dist/types/core/src/premades/make-flat-part.d.ts

@@ -0,0 +1,13 @@
+import type { BodyPart, Material } from "../../../api/src/index.js";
+import type { BoneNode } from "./bone-tree.js";
+import type { PartContext } from "./part-context.js";
+/**
+ * POC makeFlatPart + createFlatWingPart: defaults, then the frame's fore / hind guess, then the style's
+ * parameters ("@key" colors from the template; base and base2 default to the style's color key).
+ */
+export declare function makeFlatPart(node: BoneNode, style: {
+    readonly colorKey: string;
+    readonly wing?: {
+        readonly [key: string]: number | string;
+    };
+}, material: Partial<Material>, ctx: PartContext): BodyPart;

package/dist/types/core/src/premades/part-context.d.ts

@@ -0,0 +1,20 @@
+import type { RegionBlends, Vec3 } from "../../../api/src/index.js";
+import type { Bake, TemplateColor } from "./bake-types.js";
+import type { BoneNode } from "./bone-tree.js";
+import type { TemplateStyle } from "./rig-builder.js";
+/** What building one body part needs to know about its rig and template (POC partHints). */
+export type PartContext = {
+    readonly colors: {
+        readonly [key: string]: TemplateColor;
+    };
+    readonly styles: {
+        readonly [pattern: string]: TemplateStyle;
+    };
+    readonly bake?: Bake;
+    /** The template fit: template-space p maps to c + p * h. */
+    readonly c: Vec3;
+    readonly h: Vec3;
+    readonly regionBlends: RegionBlends;
+    readonly extent: number;
+    readonly roots: readonly BoneNode[];
+};

package/dist/types/core/src/premades/part-kits.d.ts

@@ -0,0 +1,36 @@
+import type { Decal, FlatWing, Material, PartSlot, Rig, SculptLook, Stamp, Vec3 } from "../../../api/src/index.js";
+import { type SlotChain } from "./part-slots.js";
+/** A stamp of a kit with the look of the part it came from. */
+export type KitStamp = {
+    readonly stamp: Stamp;
+    readonly look: SculptLook;
+};
+/** One chain of a kit, in its premade's rig space at the template's default fit. */
+export type KitChain = {
+    /** Its first bone's name (to match a rig's chain of the same name). */
+    readonly name?: string;
+    readonly start: Vec3;
+    readonly end: Vec3;
+    /** Its joints in order, when the chain is a single path (no branches): parts are fitted segment by segment. */
+    readonly path?: readonly Vec3[];
+    readonly side: 1 | -1 | 0;
+    readonly front: boolean;
+    readonly stamps: readonly KitStamp[];
+    readonly decals: readonly Decal[];
+    /** The chain's flat wing, when its parts are a flat membrane. */
+    readonly wing?: {
+        readonly wing: Omit<FlatWing, "frame">;
+        readonly material: Material;
+    };
+};
+/** A premade's parts for one slot (chains), or its coat (the look of its torso). */
+export type PartKit = {
+    readonly chains: readonly KitChain[];
+    readonly coat?: SculptLook;
+};
+/** The premade's (or part variant's) rig as built for a new rig (cached; ids are local to the kit). */
+export declare function kitRig(templateId: string): Rig | undefined;
+/** True when a chain is a single path: each of its bones has at most one child in it. */
+export declare const isPath: (c: SlotChain) => boolean;
+/** A premade's kit for a slot; undefined for an unknown premade. */
+export declare function partKit(templateId: string, slot: PartSlot): PartKit | undefined;

package/dist/types/core/src/premades/part-slots.d.ts

@@ -0,0 +1,17 @@
+import type { Bone, PartSlot, Vec3 } from "../../../api/src/index.js";
+/** The chain slots in picker order; the coat is the skin, not a chain. */
+export declare const PART_SLOTS: readonly PartSlot[];
+/** Bone roles whose parts wear the coat (not claws, horns, fangs, wings, fins or eyes). */
+export declare const COAT_ROLES: Set<string>;
+export declare const slotOfBone: (bone: Pick<Bone, "name" | "tags">) => PartSlot | undefined;
+/** One chain of a slot: its bones from the start outward, their bind heads, side and (legs) front or hind. */
+export type SlotChain = {
+    readonly bones: readonly Bone[];
+    readonly heads: readonly Vec3[];
+    readonly side: 1 | -1 | 0;
+    readonly front: boolean;
+};
+/** A slot's chains in a rig: runs of bones in that slot, each from a bone whose parent is not in it. */
+export declare function slotChains(bones: readonly Bone[], slot: PartSlot): SlotChain[];
+/** The slots a skeleton has (chains present, plus the coat when it has any coat part). */
+export declare const slotsOf: (bones: readonly Bone[]) => PartSlot[];

package/dist/types/core/src/premades/part-stamp.d.ts

@@ -0,0 +1,13 @@
+import type { ColorRef, Quaternion, Stamp, StampMode, StampShape, Vec3 } from "../../../api/src/index.js";
+/** A stamp before it gets its id (the part generator's output). */
+export type PartStamp = {
+    readonly shape: StampShape;
+    readonly mode: StampMode;
+    readonly position: Vec3;
+    readonly rotation: Quaternion;
+    readonly scale: Vec3;
+    readonly color: ColorRef;
+    readonly blend?: number;
+    readonly foundationColor?: ColorRef;
+};
+export declare const withId: (s: PartStamp, id: string) => Stamp;

package/dist/types/core/src/premades/part-styles.d.ts

@@ -0,0 +1,44 @@
+import type { FleckShape } from "../../../api/src/index.js";
+export type PartFleck = {
+    readonly shape: FleckShape;
+    readonly size?: number;
+    readonly coverage?: number;
+    readonly variation?: number;
+    readonly regularity?: number;
+    readonly boil?: number;
+    readonly normalStrength?: number;
+};
+export type PartStyle = {
+    readonly kind: "body" | "head" | "limb" | "wing" | "flat";
+    readonly colorKey: string;
+    readonly fleck?: PartFleck;
+    readonly mat?: {
+        readonly roughness?: number;
+        readonly metalness?: number;
+        readonly foundationDarkness?: number;
+    };
+    readonly opacity?: number;
+    /** limb: radius at the chain root / tip (× extent), joint sphere factor, cone at the chain tip. */
+    readonly r0?: number;
+    readonly r1?: number;
+    readonly joint?: number;
+    readonly tipCone?: boolean;
+    /** wing panels: thickness and chord (× extent). */
+    readonly thick?: number;
+    readonly chord?: readonly number[];
+    /** flat wing parameters (templates override them per bone). */
+    readonly wing?: {
+        readonly [key: string]: number | string;
+    };
+};
+/** Radius = segment length × K for body kinds. */
+export declare const PART_K: {
+    readonly [role: string]: number;
+};
+/** Default color per role (index into the editable palette) when no template color applies. */
+export declare const PART_PALETTE: {
+    readonly [role: string]: number;
+};
+export declare const PART_STYLES: {
+    readonly [role: string]: PartStyle;
+};

package/dist/types/core/src/premades/premade-fit.d.ts

@@ -0,0 +1,18 @@
+import type { Vec3 } from "../../../api/src/index.js";
+import type { SkeletonTemplate } from "./template-catalog.js";
+/** Templates fill 90% of the object's bounds. */
+export declare const RIG_FIT = 0.9;
+export declare const RIG_DEFAULT_SIZE: readonly [number, number, number];
+export type Fit = {
+    readonly c: Vec3;
+    readonly h: Vec3;
+};
+/**
+ * POC applyPremadeSkeleton's fit: a new rig uses the template size around the origin; an object uses its
+ * content's center and 90% of its half-size (no content, e.g. an empty rig: the template size). Each
+ * half-size is at least 0.15.
+ */
+export declare function premadeFit(tpl: SkeletonTemplate, content?: {
+    readonly center: Vec3;
+    readonly halfSize: Vec3;
+}): Fit;

package/dist/types/core/src/premades/premade-infos.d.ts

@@ -0,0 +1,3 @@
+import type { PremadeInfo } from "../../../api/src/index.js";
+/** The picker's list, in the POC's order. */
+export declare const PREMADE_INFOS: readonly PremadeInfo[];

package/dist/types/core/src/premades/reseat-attachments.d.ts

@@ -0,0 +1,31 @@
+import type { BodyPart, Id, Rig, Transform, Vec3 } from "../../../api/src/index.js";
+/** A head as drawn: its parts' additive stamps as ellipsoids, sized as the viewport sizes them. */
+/** Where a seated chain sits: on the head, or on the torso (core / abdomen bones). */
+export type SeatRegion = "head" | "torso" | ReadonlySet<Id>;
+export type Reseated = {
+    readonly moved: readonly {
+        readonly boneId: Id;
+        readonly bind: Transform;
+        readonly pose: Transform;
+    }[];
+    readonly parts: readonly BodyPart[];
+};
+/**
+ * Where a point near one rig's head (or torso) goes on another's: the same direction from the head's center, at the same
+ * fraction of the way to its surface. Undefined when either rig has no head shape.
+ */
+export declare function seatPoint(from: Rig, to: Rig, p: Vec3, region?: SeatRegion, toRegion?: SeatRegion): Vec3 | undefined;
+/** The heads' size ratio (`to` over `from`), by their craniums (largest stamps); 1 without a head shape. */
+export declare function headRatio(from: Rig, to: Rig, region?: SeatRegion, toRegion?: SeatRegion): number;
+/** Resolved joint moves and parts with re-seated ones laid over them (by bone). */
+export declare function withReseated<T extends Reseated>(resolved: T, re: Reseated): T;
+/** True when a change touches the head (its parts or its size), so the chains on it may need re-seating. */
+export declare const touchesHead: (rig: Rig, boneIds: Iterable<Id>) => boolean;
+/**
+ * Keeps the chains on a head (ears, horns, antennae, mandibles, a beak) on its surface when the head changes (a
+ * swapped head, a resized one). Each chain's root sat some fraction of the way to the `before` head's surface along
+ * its direction from the head's center; it's put at the same fraction of the `after` head's. An unchanged head moves
+ * nothing, and swapping a head back restores the roots. The chain and its parts move with the root. Bones only
+ * `after` has (a fresh graft) stay where they are.
+ */
+export declare function reseatAttachments(before: Rig, after: Rig): Reseated;

package/dist/types/core/src/premades/rig-builder.d.ts

@@ -0,0 +1,51 @@
+import type { Bake, TemplateColor } from "./bake-types.js";
+type V3 = readonly [number, number, number];
+/** A bone of a template, in template space (the fit maps p to c + p * h). */
+export type TemplateBone = {
+    readonly name: string;
+    readonly parent: string | null;
+    readonly p: V3;
+    readonly tags: readonly string[];
+};
+/** A face decal of a generated template: u / v across the head's front, size in head widths. */
+export type TemplateDecal = {
+    readonly bone: string;
+    readonly cat: string;
+    readonly name: string;
+    readonly pair?: boolean;
+    readonly u?: number;
+    readonly v?: number;
+    readonly size?: number;
+    readonly flip?: boolean;
+    readonly tint?: TemplateColor;
+};
+/** A per-bone style override (bone-name regex → style), used for flat wing parameters. */
+export type TemplateStyle = {
+    readonly kind: "flat";
+    readonly colorKey: string;
+    readonly wing: {
+        readonly [key: string]: number | string;
+    };
+};
+export type RigBuilder = {
+    readonly bones: TemplateBone[];
+    readonly decals: TemplateDecal[];
+    readonly styles: {
+        [pattern: string]: TemplateStyle;
+    };
+    bake: Bake | undefined;
+    role<T>(id: string, fn: () => T): T;
+    decal(bone: string, cat: string, name: string, o?: Omit<TemplateDecal, "bone" | "cat" | "name">): void;
+    style(key: string, over: TemplateStyle): void;
+    bone(name: string, parent: string | null, p: V3, tags?: readonly string[]): string;
+    chain(name: string, parent: string | null, from: V3, to: V3, n: number): string[];
+    limb(parent: string | readonly string[] | null, names: string | readonly string[], pts: readonly V3[], mirror?: boolean): {
+        first: string[];
+        last: string[];
+    };
+};
+/** POC makeRigBuilder: bone() adds one bone, chain() a line of bones, limb() a (mirrored) chain. */
+export declare function makeRigBuilder(): RigBuilder;
+/** POC bakeBones: a baked template's bones come straight from the bake, and so do its parts and decals. */
+export declare function bakeBones(b: RigBuilder, bake: Bake): void;
+export {};

package/dist/types/core/src/premades/rodent-bake.d.ts

@@ -0,0 +1,2 @@
+import type { Bake } from "./bake-types.js";
+export declare const RODENT_BAKE: Bake;

package/dist/types/core/src/premades/scorpion-bake.d.ts

@@ -0,0 +1,2 @@
+import type { Bake } from "./bake-types.js";
+export declare const SCORPION_BAKE: Bake;

package/dist/types/core/src/premades/shark-bake.d.ts

@@ -0,0 +1,2 @@
+import type { Bake } from "./bake-types.js";
+export declare const SHARK_BAKE: Bake;

package/dist/types/core/src/premades/sitter-bake.d.ts

@@ -0,0 +1,3 @@
+import type { Bake } from "./bake-types.js";
+export declare const FELINE_BAKE: Bake;
+export declare const FOX_BAKE: Bake;

package/dist/types/core/src/premades/skeleton-bakes.d.ts

@@ -0,0 +1,4 @@
+import type { Bake } from "./bake-types.js";
+export declare const SKELETON_BAKES: {
+    readonly [id: string]: Bake;
+};

package/dist/types/core/src/premades/snake-bake.d.ts

@@ -0,0 +1,2 @@
+import type { Bake } from "./bake-types.js";
+export declare const SNAKE_BAKE: Bake;

package/dist/types/core/src/premades/spider-bake.d.ts

@@ -0,0 +1,2 @@
+import type { Bake } from "./bake-types.js";
+export declare const SPIDER_BAKE: Bake;

package/dist/types/core/src/premades/stamps-box.d.ts

@@ -0,0 +1,9 @@
+import type { Stamp, Vec3 } from "../../../api/src/index.js";
+/**
+ * The box around a sculpt's additive stamps (each a rotated box of its scale): the core's stand-in for the
+ * mesh bounds the POC read after meshing. Blends make the real mesh slightly larger.
+ */
+export declare function stampsBox(stamps: readonly Pick<Stamp, "mode" | "position" | "rotation" | "scale">[]): {
+    readonly min: Vec3;
+    readonly max: Vec3;
+} | undefined;

package/dist/types/core/src/premades/style-for-bone.d.ts

@@ -0,0 +1,7 @@
+import type { BoneNode } from "./bone-tree.js";
+import { type PartStyle } from "./part-styles.js";
+import type { TemplateStyle } from "./rig-builder.js";
+/** POC getStyleForBone: a template style whose key (a regex) matches the name, else the role's style. */
+export declare function styleForBone(node: BoneNode, role: string, styles: {
+    readonly [pattern: string]: TemplateStyle;
+}): PartStyle | TemplateStyle | undefined;

package/dist/types/core/src/premades/swap-slot.d.ts

@@ -0,0 +1,13 @@
+import type { IdGenerator, PartSlot, PartSlotSwapped, Rig } from "../../../api/src/index.js";
+export type ResolvedSwap = Omit<PartSlotSwapped["payload"], "rigId">;
+/** The tag on bones a kit brought for a slot (a variant's trunk, ear chains): the slot's next swap removes them. */
+export declare const kitTag: (slot: PartSlot) => string;
+/**
+ * What giving a slot `kit`'s parts does to a rig. A head takes the kit's head parts; the chains a head variant carries
+ * (a trunk) come as bones, and an earlier kit's are removed; the chains on the head re-seat on it. Ears or horns from
+ * a variant (or replacing a variant's) come as their own bones seated on this head, a variant's tail as its own bones
+ * on the torso. Anything else is fitted to the rig's own chains.
+ */
+export declare function resolveSwap(rig: Rig, slot: PartSlot, kit: string, ids: IdGenerator): ResolvedSwap | string;
+/** A rig with a resolved swap applied (the fold's and the generator's one way of doing it). */
+export declare function withSwap(r: Rig, e: ResolvedSwap): Rig;

package/dist/types/core/src/premades/template-catalog.d.ts

@@ -0,0 +1,20 @@
+import { type RigBuilder } from "./rig-builder.js";
+import type { CreatureFamily } from "../../../api/src/index.js";
+import type { TemplateColor } from "./bake-types.js";
+export type SkeletonTemplate = {
+    readonly id: string;
+    readonly name: string;
+    readonly icon: string;
+    /** Parts swap within a family unless the user asks for a chimera. */
+    readonly family: CreatureFamily;
+    readonly desc: string;
+    /** Template-space extent for a new rig (default 2.2 on each axis). */
+    readonly size?: readonly [number, number, number];
+    /** Body color keys → POC color refs ("s:0", "s:black"…). */
+    readonly colors: {
+        readonly [key: string]: TemplateColor;
+    };
+    readonly build: (b: RigBuilder) => void;
+};
+export declare const SKELETON_TEMPLATES: readonly SkeletonTemplate[];
+export declare const findTemplate: (id: string) => SkeletonTemplate | undefined;

package/dist/types/core/src/premades/template-color.d.ts

@@ -0,0 +1,9 @@
+import type { ColorRef } from "../../../api/src/index.js";
+import type { TemplateColor } from "./bake-types.js";
+/**
+ * POC bakeColor + slot refs: "@key" is the template's color for that key (the POC falls back to the
+ * literal 0xfbbf24, the default Secondary, which is the Secondary slot here); "s:N" refs become slots.
+ */
+export declare function templateColor(c: TemplateColor | undefined, colors: {
+    readonly [key: string]: TemplateColor;
+}): ColorRef;

package/dist/types/core/src/premades/turtle-bake.d.ts

@@ -0,0 +1,2 @@
+import type { Bake } from "./bake-types.js";
+export declare const TURTLE_BAKE: Bake;

package/dist/types/core/src/premades/variants/aquatic-variants.d.ts

@@ -0,0 +1,16 @@
+import type { BakeBone, BakeLook, BakePart, BakeStamp } from "../bake-types.js";
+import { type V3 } from "../bake-authoring.js";
+import type { PartVariant } from "./part-variant.js";
+export declare const FISH: {
+    head: V3;
+    spine: V3[];
+    pecBase: V3;
+};
+export declare const TAIL_BASE: V3;
+export declare const finBones: (tailUp: V3, tailDown: V3, dorsal: V3, pecTip: V3, pelvic: V3) => BakeBone[];
+export declare const finVariant: (id: string, name: string, icon: string, desc: string, bones: readonly BakeBone[], parts: {
+    readonly [bone: string]: BakePart | null;
+}, family?: PartVariant["family"]) => PartVariant;
+export declare const tentacleVariant: (id: string, name: string, icon: string, desc: string, segment: (k: number, j: number, a: V3, b: V3) => readonly BakeStamp[], look?: BakeLook, reach?: number, droop?: number, family?: PartVariant["family"]) => PartVariant;
+/** Aquatic variants: fins, tentacles and sea heads. */
+export declare const AQUATIC_VARIANTS: readonly PartVariant[];

package/dist/types/core/src/premades/variants/coat-variants.d.ts

@@ -0,0 +1,7 @@
+import type { BakeLook } from "../bake-types.js";
+import type { PartVariant } from "./part-variant.js";
+/** A patterned look: the pattern (by its index in the catalog), its scale, strength and colors. */
+export declare const patterned: (base: BakeLook, kind: number, scale: number, rot?: readonly [number, number, number], strength?: number, color?: string) => BakeLook;
+export declare const coatVariant: (id: string, name: string, icon: string, desc: string, look: BakeLook, family?: PartVariant["family"]) => PartVariant;
+/** Coat variants: a fleck and a pattern for a rig's skin. */
+export declare const COAT_VARIANTS: readonly PartVariant[];

package/dist/types/core/src/premades/variants/ear-variants.d.ts

@@ -0,0 +1,8 @@
+import type { BakePart } from "../bake-types.js";
+import { type V3 } from "../bake-authoring.js";
+import type { PartVariant } from "./part-variant.js";
+export declare const earVariant: (id: string, name: string, icon: string, desc: string, joints: readonly (readonly [string, V3])[], parts: {
+    readonly [bone: string]: BakePart | null;
+}, family?: PartVariant["family"]) => PartVariant;
+/** Ear variants: jointed ear chains on a reference head (the head itself isn't given). */
+export declare const EAR_VARIANTS: readonly PartVariant[];

package/dist/types/core/src/premades/variants/fantasy-more-variants.d.ts

@@ -0,0 +1,3 @@
+import type { PartVariant } from "./part-variant.js";
+/** The second batch of made-up variants. */
+export declare const FANTASY_MORE_VARIANTS: readonly PartVariant[];

package/dist/types/core/src/premades/variants/fantasy-variants.d.ts

@@ -0,0 +1,17 @@
+import type { BakeLook, BakeStamp } from "../bake-types.js";
+import { type V3 } from "../bake-authoring.js";
+import type { PartVariant } from "./part-variant.js";
+export declare const METAL_LOOK: BakeLook;
+export declare const CRYSTAL_LOOK: BakeLook;
+export declare const ROCK_LOOK: BakeLook;
+export declare const BARK_LOOK: BakeLook;
+export declare const LEAF_LOOK: BakeLook;
+export declare const SHROOM_LOOK: BakeLook;
+export declare const FIRE_LOOK: BakeLook;
+export declare const SLIME_LOOK: BakeLook;
+export declare const NEON_LOOK: BakeLook;
+/** An ellipsoid from a to b, `w` wide and `t` thin (a leaf, a plate, a petal). */
+export declare const blade: (a: V3, b: V3, w: number, t: number, color: string) => BakeStamp;
+export declare const lerp3: (a: V3, b: V3, t: number) => V3;
+/** Made-up variants: fungus, plant, mineral, machine and elemental parts. */
+export declare const FANTASY_VARIANTS: readonly PartVariant[];

package/dist/types/core/src/premades/variants/head-variants.d.ts

@@ -0,0 +1,9 @@
+import type { BakeDecal, TemplateColor } from "../bake-types.js";
+import { type V3 } from "../bake-authoring.js";
+import type { PartVariant } from "./part-variant.js";
+import { variant } from "./variant-authoring.js";
+export declare const eyes: (c: V3, s: V3, name: string, size: number, d: V3) => BakeDecal[];
+export declare const mouth: (c: V3, s: V3, name: string, size: number, d: V3, tint?: TemplateColor) => BakeDecal;
+export declare const headVariant: (...args: Parameters<typeof variant> extends [unknown, ...infer R] ? R : never) => PartVariant;
+/** Head variants (the slot's parts: the head's shapes and face; a trunk comes as a jointed chain). */
+export declare const HEAD_VARIANTS: readonly PartVariant[];

package/dist/types/core/src/premades/variants/horn-variants.d.ts

@@ -0,0 +1,7 @@
+import type { BakeBone, BakePart } from "../bake-types.js";
+import type { PartVariant } from "./part-variant.js";
+export declare const hornVariant: (id: string, name: string, icon: string, desc: string, bones: readonly BakeBone[], parts: {
+    readonly [bone: string]: BakePart | null;
+}, head?: BakePart, family?: PartVariant["family"]) => PartVariant;
+/** Horn variants: jointed horn chains on a reference head (the head itself isn't given). */
+export declare const HORN_VARIANTS: readonly PartVariant[];

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

@@ -0,0 +1,10 @@
+import type { PartVariantInfo } from "../../../../api/src/index.js";
+import { type SkeletonTemplate } from "../template-catalog.js";
+import type { PartVariant } from "./part-variant.js";
+export type { PartVariant } from "./part-variant.js";
+/** Every part variant, by slot then picker order. */
+export declare const PART_VARIANTS: readonly PartVariant[];
+export declare const PART_VARIANT_INFOS: readonly PartVariantInfo[];
+export declare const findVariant: (id: string) => PartVariant | undefined;
+/** A kit's source: a premade template or a part variant. */
+export declare const findKitTemplate: (id: string) => SkeletonTemplate | undefined;

package/dist/types/core/src/premades/variants/land-variants.d.ts

@@ -0,0 +1,3 @@
+import type { PartVariant } from "./part-variant.js";
+/** Land-animal variants: more heads, horns, ears and coats. */
+export declare const LAND_VARIANTS: readonly PartVariant[];

package/dist/types/core/src/premades/variants/leg-variants.d.ts

@@ -0,0 +1,7 @@
+import type { BakeStamp } from "../bake-types.js";
+import { type V3 } from "../bake-authoring.js";
+import type { PartVariant } from "./part-variant.js";
+export declare const legVariant: (id: string, name: string, icon: string, family: PartVariant["family"], desc: string, segs: readonly (readonly BakeStamp[])[], look?: import("../bake-types.js").BakeLook) => PartVariant;
+export declare const LEG_JOINTS: readonly V3[];
+/** Leg variants: leg shapes fitted along a rig's own legs. */
+export declare const LEG_VARIANTS: readonly PartVariant[];

package/dist/types/core/src/premades/variants/part-variant.d.ts

@@ -0,0 +1,14 @@
+import type { PartSlot } from "../../../../api/src/index.js";
+import type { SkeletonTemplate } from "../template-catalog.js";
+/**
+ * A body part variant: a small bake built like a premade (a `Head` bone, and for ears a reference head, plus its
+ * chains), whose parts for `slot` fill that slot of a premade rig. Its bones beyond the head chain (a trunk, ear
+ * chains) come along as jointed chains.
+ */
+export type PartVariant = SkeletonTemplate & {
+    readonly slot: PartSlot;
+    /** Parts that suit it in other slots (an elephant head's ears): the generator usually takes them along. */
+    readonly companions?: {
+        readonly [Slot in PartSlot]?: string;
+    };
+};

package/dist/types/core/src/premades/variants/tail-variants.d.ts

@@ -0,0 +1,6 @@
+import type { BakeStamp } from "../bake-types.js";
+import { type V3 } from "../bake-authoring.js";
+import type { PartVariant } from "./part-variant.js";
+export declare const tailVariant: (id: string, name: string, icon: string, desc: string, joints: readonly V3[], parts: (j: readonly V3[]) => readonly (readonly BakeStamp[] | null)[], look?: import("../bake-types.js").BakeLook, blend?: number, family?: PartVariant["family"]) => PartVariant;
+/** Tail variants: a jointed tail chain on a reference torso (the torso itself isn't given). */
+export declare const TAIL_VARIANTS: readonly PartVariant[];

package/dist/types/core/src/premades/variants/variant-authoring.d.ts

@@ -0,0 +1,29 @@
+import type { CreatureFamily, PartSlot } from "../../../../api/src/index.js";
+import type { Bake, BakeBone, BakeLook, BakePart, BakeStamp, TemplateColor } from "../bake-types.js";
+import { type V3 } from "../bake-authoring.js";
+import type { PartVariant } from "./part-variant.js";
+export declare const LEAF = "@leaf", MOSS = "@moss", PETAL = "@petal", CAP = "@cap", SPOT = "@spot", STEM = "@stem", CRYSTAL = "@crystal", ROCK = "@rock";
+export declare const METAL = "@metal", PANEL = "@panel", NEON = "@neon", FIRE = "@fire", EMBER = "@ember", ICE = "@ice", SLIME = "@slime";
+export declare const CORE = "@core", HORN = "@horn", HOOF = "@hoof", WHITE = "@white", PALE = "@pale", NOSE = "@nose", INNER = "@inner", STRIPE = "@stripe", MANE = "@mane", TUSK = "@tusk", BEAK = "@beak";
+/** Every variant's color keys (the scene palette's roles). */
+export declare const COLORS: {
+    readonly [key: string]: TemplateColor;
+};
+export declare const FUR: BakeLook;
+export declare const SKIN: BakeLook;
+export declare const SCALES: BakeLook;
+export declare const FEATHERS: BakeLook;
+export declare const HORNY: BakeLook;
+export declare const corePart: (stamps: readonly BakeStamp[], look?: BakeLook, blend?: number) => BakePart;
+/** A paint mark with its own sharp blend (a part's blend would smear a small mark into a blot). */
+export declare const mark: (p: V3, s: V3, color: TemplateColor, rot?: V3) => BakeStamp;
+/** Both sides of a sided stamp. */
+export declare const both: (f: (side: 1 | -1) => BakeStamp) => BakeStamp[];
+export declare const HEAD_BONE: BakeBone;
+/** A reference torso (`Hips`, a core bone at the origin) for variants that hang from the body: tails, legs, coats. */
+export declare const HIPS_BONE: BakeBone;
+/** A variant from its bake (the `Head` bone is added first, or `root` instead: the `Hips` for body parts). */
+export declare function variant(slot: PartSlot, id: string, name: string, icon: string, family: CreatureFamily, desc: string, bake: Omit<Bake, "regionBlends" | "bones"> & {
+    readonly bones?: readonly BakeBone[];
+    readonly root?: BakeBone;
+}, companions?: PartVariant["companions"]): PartVariant;

package/dist/types/core/src/premades/whale-bake.d.ts

@@ -0,0 +1,2 @@
+import type { Bake } from "./bake-types.js";
+export declare const WHALE_BAKE: Bake;

package/dist/types/core/src/premades/wing-defaults.d.ts

@@ -0,0 +1,4 @@
+import type { FlatWing } from "../../../api/src/index.js";
+/** POC WING_DEFAULTS (colors as palette refs). */
+export declare const WING_DEFAULTS: Omit<FlatWing, "frame">;
+export declare const WING_COLOR_KEYS: readonly ["base", "base2", "mark", "ink", "dot"];

package/dist/types/core/src/premades/wing-frame.d.ts

@@ -0,0 +1,10 @@
+import type { WingFrame } from "../../../api/src/index.js";
+import type { BoneNode } from "./bone-tree.js";
+/**
+ * POC wingFrameFor: span from the root to the end of the wing chain; the membrane plane is the sibling
+ * wing pair's plane (fore and hind coplanar), else level; the chord points backwards, as long as the span.
+ */
+export declare function wingFrameFor(node: BoneNode, siblings: readonly BoneNode[], extent: number): {
+    frame: WingFrame;
+    part: "fore" | "hind";
+};

package/dist/types/core/src/premades/wolf-bake.d.ts

@@ -0,0 +1,2 @@
+import type { Bake } from "./bake-types.js";
+export declare const WOLF_BAKE: Bake;

package/dist/types/core/src/premades/worm-bake.d.ts

@@ -0,0 +1,2 @@
+import type { Bake } from "./bake-types.js";
+export declare const WORM_BAKE: Bake;

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

@@ -0,0 +1,64 @@
+/**
+ * The mesher ABI shared by the Rust / WASM core and the TypeScript reference core.
+ *
+ * Stamp table: `STAMP_STRIDE` f64 per stamp, in CSG order (stamp 0 starts the stack):
+ *   0 shape code (SHAPE_CODE)      1 mode code (MODE_CODE)
+ *   2..4 position                  5..13 inverse rotation, row-major 3x3 (local = SR * (p - position))
+ *   14..16 half sizes              17 blend
+ *   18 bounding radius             19 bound scale (lower-bound factor of stretched shapes)
+ *   20..22 color rgb               23..25 foundation rgb
+ *   26..29 roughness, metalness, glow, flecks (f32-rounded)
+ *   30 override mask (bit k = material channel k is the stamp's own)   31 unused
+ *
+ * Grid params: `PARAMS_LEN` f64:
+ *   0..2 origin of sample (0,0,0)   3..5 step   6..8 samples per axis (RX, RY, RZ)
+ *   9 own (first index along an edge's axis that emits quads; chunks own their low side only)
+ *   10 cache slot (-1: none)   11..16 inclusive voxel box to evaluate x0 x1 y0 y1 z0 z1 (x0 > x1: none)
+ *
+ * The optional stamp list (i32) holds the stamp indices to apply, in order; empty means all.
+ * When a slot's arrays have to be (re)allocated, the core evaluates the whole grid whatever the box says.
+ */
+export declare const STAMP_STRIDE = 32;
+export declare const PARAMS_LEN = 17;
+export declare const SHAPE_CODE: {
+    readonly cube: 0;
+    readonly sphere: 1;
+    readonly cylinder: 2;
+    readonly torus: 3;
+    readonly cone: 4;
+    readonly pyramid: 5;
+    readonly prism: 6;
+    readonly octahedron: 7;
+    readonly capsule: 8;
+    readonly dome: 9;
+};
+export declare const MODE_CODE: {
+    readonly add: 0;
+    readonly subtract: 1;
+    readonly intersect: 2;
+    readonly paint: 3;
+};
+/** Skin segment table: 7 f64 per segment: head xyz, end xyz, bone index. */
+export declare const SEGMENT_STRIDE = 7;
+export type RawMesh = {
+    readonly positions: Float32Array;
+    readonly normals: Float32Array;
+    readonly colors: Float32Array;
+    readonly foundation: Float32Array;
+    readonly material: Float32Array;
+    readonly indices: Uint32Array;
+    /** Vertex AABB (zeros for an empty mesh). */
+    readonly bounds: readonly [number, number, number, number, number, number];
+};
+export type RawSkin = {
+    readonly boneIndices: Float32Array;
+    readonly boneWeights: Float32Array;
+};
+/** One mesher implementation. Every output array is freshly allocated (safe to transfer). */
+export type MesherCore = {
+    readonly kind: "wasm" | "reference";
+    mesh(table: Float64Array, stampCount: number, params: Float64Array, list: Int32Array | null): RawMesh;
+    /** Frees a cache slot's voxel arrays. */
+    dropSlot(slot: number): void;
+    skin(positions: Float32Array, segments: Float64Array, segmentCount: number, boneCount: number): RawSkin;
+};