@bitefoundry/retrieviewer 0.0.3 → 0.0.4

package/retrieviewer.d.mts

@@ -35,16 +35,22 @@ export interface PetState {
   [key: string]: unknown;
 }
 export interface LifeReport {
+  /** Last selected autonomous episode; null before the first decision. */
+  episode: string | null;
   intent: string;
   label: string;
-  interaction: 'ball' | 'treat' | null;
+  interaction: 'ball' | 'treat' | 'tug' | null;
   busy: boolean;
   energy: number;
   decisions: number;
-  cooldowns: {ball: number; treat: number};
+  cooldowns: {ball: number; treat: number; tug: number};
   gesture: {clip: string; progress: number} | null;
   ball: {x: number; z: number; height: number; carried: boolean} | null;
   treat: {x: number; z: number; height: number} | null;
+  /** Tug-of-war state while a tug interaction is active. */
+  tug: {progress: number; grip: number} | null;
+  /** Silent rising sleep cue, normalized cycle progress; no audio process. */
+  snore: number | null;
 }
 export interface PetFrame {
   artProfile: 'original' | 'q5';
@@ -70,7 +76,7 @@ export interface Pet {
   step(dt: number): number;
   frame(options: FrameOptions): PetFrame;
   /** False when busy or cooling down. */
-  interact(kind: 'ball' | 'treat'): boolean;
+  interact(kind: 'ball' | 'treat' | 'tug'): boolean;
   readonly disposed: boolean;
   dispose(): void;
 }
@@ -78,7 +84,7 @@ export function createPet(options?: PetOptions): Promise<Pet>;
 export function defaultLoadAsset(name: string): Promise<ArrayBuffer | Uint8Array>;
 export const STEP_SECONDS: number;
 export const MAX_CATCH_UP_SECONDS: number;
-export const INTERACTIONS: readonly ['ball', 'treat'];
+export const INTERACTIONS: readonly ['ball', 'treat', 'tug'];
 export const ART_PROFILES: readonly ['original', 'q5'];
 export const DEFAULT_ART_PROFILE: 'q5';
 export function getPetAssetFiles(artProfile?: 'original' | 'q5'): readonly string[];

package/retrieviewer.mjs

@@ -1,6 +1,5 @@
-import {makeLabAnimal} from './locomotion-core.mjs';
-import {createPaperActor,createPaperRenderer} from './puppy-paper.mjs';
-import {createPaperProjection} from './puppy-paper-world.mjs';
+import {createPaperActor,createPaperRenderer,createPaperComfortTimings} from './puppy-paper.mjs';
+import {createPaperProjection,createPaperBody} from './puppy-paper-world.mjs';
 import {rgbaToBraille} from './braille.mjs';
 import {createSnappyTrickTimings} from './puppy-paper-trick-timing.mjs';
 import {createCompanionLife} from './puppy-companion-life.mjs';
@@ -11,24 +10,25 @@ import {readPackedFrames} from './puppy-frame-store.mjs';
 // or listener side effects: the host owns the loop and calls step() then frame().
 export const STEP_SECONDS=1/60;
 export const MAX_CATCH_UP_SECONDS=.1;
-export const INTERACTIONS=Object.freeze(['ball','treat']);
+export const INTERACTIONS=Object.freeze(['ball','treat','tug']);
 // Approved 32-level art ships by default; preserved original art is optional.
 export const DEFAULT_ART_PROFILE='q5';
 export const ART_PROFILES=Object.freeze(['original','q5']);
 // Current companion runtime: v9 tricks + interactions-v3, same as puppy-paper.html.
 export const PET_ASSETS=Object.freeze({
+ // Kept as a legacy identifier only; createPet/getPetAssetFiles no longer load it.
  animal:'locomotion-puppy.animal',
  stride:'puppy-stride-tweens-q5.bin.gz',strideInfo:'puppy-stride-meta.json',stableInfo:'puppy-stable-meta.json',
  rear:'puppy-paper-rear-gallop',approach:'puppy-paper-approach',seat:'puppy-paper-seat',arrivalSeat:'puppy-paper-arrival-seat',
- behaviors:'puppy-paper-behaviors',actions:'puppy-paper-actions-v9',interactions:'puppy-companion-interactions-v3',
+ behaviors:'puppy-paper-behaviors',actions:'puppy-paper-actions-v9',interactions:'puppy-companion-interactions-v3',comfort:'puppy-companion-comfort',
 });
-const BUNDLES=['rear','approach','seat','arrivalSeat','behaviors','actions','interactions'];
+const BUNDLES=['rear','approach','seat','arrivalSeat','behaviors','actions','interactions','comfort'];
 const frameFile=(base,profile)=>base+(profile==='q5'?'-q5.bin.gz':'-compact.bin.gz');
 /** Exact files a host/bundler must copy, including metadata. Never loads assets. */
 export function getPetAssetFiles(artProfile=DEFAULT_ART_PROFILE){
  if(!ART_PROFILES.includes(artProfile))throw RangeError('artProfile must be original or q5');
  return Object.freeze([PET_ASSETS.strideInfo,PET_ASSETS.stableInfo,frameFile('puppy-stride-tweens',artProfile),
-  ...BUNDLES.flatMap(key=>[PET_ASSETS[key]+'.json',frameFile(PET_ASSETS[key],artProfile)]),PET_ASSETS.animal]);
+  ...BUNDLES.flatMap(key=>[PET_ASSETS[key]+'.json',frameFile(PET_ASSETS[key],artProfile)])]);
 }
 
 // Relative to this module, never the process cwd: file: URLs in Node, HTTP in browsers.
@@ -62,13 +62,19 @@ const sharedAssets=new Map();
 async function loadPetAssets(loadAsset,artProfile){
  const load=async name=>bytesOf(name,await loadAsset(name));
  const json=async name=>JSON.parse(new TextDecoder().decode(await load(name)));
- const frames=async name=>readPackedFrames(await gunzip(await load(name)));
+ const frames=async (name,options)=>readPackedFrames(await gunzip(await load(name)),options);
  // One family at a time: never inflate all eight legacy-sized buffers together.
  const data={assets:{}};
  data.info=await json(PET_ASSETS.strideInfo);data.meta=await json(PET_ASSETS.stableInfo);
  data.cache=await frames(frameFile('puppy-stride-tweens',artProfile));
- for(const key of BUNDLES){const base=PET_ASSETS[key];data.assets[key]={info:await json(base+'.json'),bytes:await frames(frameFile(base,artProfile))};}
- data.baked=await load(PET_ASSETS.animal);
+ for(const key of BUNDLES){
+  const base=PET_ASSETS[key],info=await json(base+'.json');
+  // Old interaction sheets include preparation frames no runtime clip can reach.
+  // Keep exact active samples only, leaving room for small new gestures without
+  // keeping another multi-megabyte art family resident. Original RVF1 unchanged.
+  const options=key==='interactions'&&artProfile==='q5'?{frameIndices:[...new Set(Object.values(info.clips).flatMap(list=>list.flatMap(p=>Array.from({length:info.samples},(_,s)=>p*info.samples+s))))]}:undefined;
+  data.assets[key]={info,bytes:await frames(frameFile(base,artProfile),options)};
+ }
  return data;
 }
 async function acquireAssets(loadAsset,artProfile){
@@ -90,12 +96,12 @@ export async function createPet({loadAsset=defaultLoadAsset,seed,energy,pawTrans
  if(!ART_PROFILES.includes(artProfile))throw RangeError('artProfile must be original or q5');
  let lease=await acquireAssets(loadAsset,artProfile),data=lease.data;
  const release=lease.release;lease=null;
- let {cache,info,meta,baked}=data;const assets={...data.assets};data=null;
+ let {cache,info,meta}=data;const assets={...data.assets};data=null;
  let animal,actor,life;
  try{
   if(!assets.actions.info.clips?.['lie-down']||!assets.actions.info.clips?.['lie-up'])throw Error('v9 action cache lacks lie-down/lie-up clips');
-  animal=await makeLabAnimal({baked:baked.buffer.slice(baked.byteOffset,baked.byteOffset+baked.byteLength)});baked=null;
-  actor=createPaperActor(animal,info,{manualTricks:true,trickTimings:createSnappyTrickTimings(assets.actions.info),walkTransitions:true});
+  animal=createPaperBody();
+  actor=createPaperActor(animal,info,{manualTricks:true,trickTimings:createSnappyTrickTimings(assets.actions.info),comfortTimings:createPaperComfortTimings(assets.actions.info),walkTransitions:true});
   life=createCompanionLife(actor,{seed,...energy===undefined?{}:{energy}});
  }catch(e){animal?.dispose?.();release();throw e;}
  let paint=null,paintKey='',time=0,acc=0,disposed=false;
@@ -127,7 +133,7 @@ export async function createPet({loadAsset=defaultLoadAsset,seed,energy,pawTrans
    const {text}=rgbaToBraille(pixels,width,height,{method:'stable',brightness:1.18,contrast:1.1});
    return {text,columns,rows,pixels,state,report,placement,projection,artProfile,mouth:paint.lastMouth,contacts:paint.report()};
   },
-  // 'ball' | 'treat'. False when busy or cooling down; unknown kinds throw.
+  // 'ball' | 'treat' | 'tug'. False when busy or cooling down; unknown kinds throw.
   interact(kind){alive();if(!INTERACTIONS.includes(kind))throw TypeError(`Unknown interaction: ${kind}`);return life.interact(kind);},
   get disposed(){return disposed;},
   dispose(){

package/locomotion-core.mjs

@@ -1,21 +0,0 @@
-import * as THREE from 'three';
-import {createAnimal} from './vendor/procedural-animals/src/index.js';
-export const LAB_OPTIONS={variant:'retriever',age:'juvenile',seed:2,quality:'low',worker:false,overrides:{colour:'yellow',stanceSoftMargin:.005}};
-export async function makeLabAnimal(extra={}){
- return createAnimal('dog',{...LAB_OPTIONS,...extra,overrides:{...LAB_OPTIONS.overrides,...extra.overrides}});
-}
-// Never translate the mesh externally. The gait engine owns root motion + IK.
-export function makeLabController(animal){
- let target=null,speed=animal.gears.walk;
- return {get target(){return target;},get speed(){return speed;},setSpeed(kind){
-  if(!['walk','trot','gallop'].includes(kind))throw Error('Unknown gait');
-  speed=animal.gears[kind];if(target)animal.moveTo(target,{speed});
- },go(x,z){
-  if(![x,z].every(Number.isFinite))throw Error('Invalid ground target');
-  target=new THREE.Vector3(Math.max(-.8,Math.min(.8,x)),0,Math.max(-1.7,Math.min(.3,z)));
-  animal.stopAction();animal.moveTo(target,{speed});
- },stop(){target=null;animal.stop();},update(dt){
-  if(!Number.isFinite(dt)||dt<0||dt>.1)throw Error('Invalid lab step');animal.update(dt);
-  if(target&&animal.position.distanceTo(target)<.025&&animal.speed<.03){target=null;animal.stop();}
- }};
-}

package/vendor/procedural-animals/package.json

@@ -1,40 +0,0 @@
-{
-  "name": "procedural-animals",
-  "version": "0.1.0",
-  "description": "24 fully procedural animals for three.js: SDF-sculpted bodies, dual-quaternion skinning, GPU fur, feathers and scales, IK locomotion and actions. No models, no textures, no downloads.",
-  "license": "MIT",
-  "author": "Majid Manzarpour",
-  "homepage": "https://majidmanzarpour.github.io/threejs-procedural-animals/",
-  "repository": { "type": "git", "url": "git+https://github.com/majidmanzarpour/threejs-procedural-animals.git" },
-  "bugs": { "url": "https://github.com/majidmanzarpour/threejs-procedural-animals/issues" },
-  "type": "module",
-  "main": "./src/index.js",
-  "module": "./src/index.js",
-  "types": "./src/index.d.ts",
-  "exports": {
-    ".": { "types": "./src/index.d.ts", "default": "./src/index.js" },
-    "./species/*": "./src/species/*/index.js",
-    "./worker": "./src/worker.js",
-    "./bake": "./src/bake.js",
-    "./package.json": "./package.json"
-  },
-  "bin": { "procedural-animals-bake": "./tools/bake.mjs" },
-  "sideEffects": ["./src/worker.js"],
-  "files": [
-    "src/**/*.js",
-    "src/index.d.ts",
-    "tools/bake.mjs",
-    "README.md",
-    "LICENSE",
-    "llms.txt"
-  ],
-  "engines": { "node": ">=18" },
-  "peerDependencies": { "three": ">=0.160.0" },
-  "devDependencies": { "esbuild": "^0.28.2", "playwright-core": "1.56", "three": "^0.186.0" },
-  "scripts": {
-    "build:showcase": "node showcase/build.mjs",
-    "build:pages": "node showcase/build.mjs --pages",
-    "test": "node tools/test.mjs"
-  },
-  "keywords": ["three", "threejs", "procedural", "animals", "animation", "ik", "fur", "sdf", "creatures", "gamedev", "webgl"]
-}

package/vendor/procedural-animals/src/animal.js

@@ -1,146 +0,0 @@
-// The public Animal: build data + render object + motion engine behind a small game-facing API.
-import * as THREE from 'three';
-import { createAnimalObject } from './core/render/animalObject.js';
-import { createMotion } from './core/motion/index.js';
-
-const _v = new THREE.Vector3();
-
-export class Animal {
-  constructor(species, data, opts = {}) {
-    this.species = species;
-    this.id = species.id;
-    this.data = data;
-    this.seed = data.seed;
-    this.params = data.params;
-    this.quality = opts.quality || data.quality;
-    const ground = opts.ground || (() => 0);
-    this.ground = ground;
-    this.water = opts.water || null;
-    this.render = createAnimalObject(data, species, { quality: this.quality, castShadow: opts.castShadow, receiveShadow: opts.receiveShadow });
-    /** Add this to your scene. Keep its own transform at identity: the animal moves by itself. */
-    this.object = this.render.group;
-    this.object.userData.animal = this;
-    this._listeners = new Map();
-    this.motion = createMotion(species.plan, {
-      species, data, skeleton: this.render.skeleton, ground, water: this.water, perches: opts.perches,
-      position: opts.position, heading: opts.heading ?? 0,
-      emit: (type, payload) => this._emit(type, payload),
-    });
-    this.attachments = {};
-    this._attachDefs = [];
-    for (const [name, def] of Object.entries(this.motion.attachmentPoints || {})) {
-      const o = new THREE.Object3D();
-      o.name = name;
-      o.matrixAutoUpdate = false;
-      this.object.add(o);
-      this.attachments[name] = o;
-      this._attachDefs.push({ o, ...def });
-    }
-    this.stats = { vertices: data.nV, triangles: data.index.length / 3, bones: data.bones.length, buildMs: data.stats?.buildMs || 0, updateMs: 0 };
-    this.time = 0;
-    this._lastDt = 1 / 60;
-    this.update(0);
-  }
-
-  // ---------------------------------------------------------------- control
-  /** Locomotion: the animal moves itself. speed in m/s, heading in radians (0 = +Z). */
-  move({ speed = 0, heading, climb = 0, gait } = {}) {
-    const inp = this.motion.input;
-    inp.follow = null;
-    inp.target = null;
-    inp.speed = Math.max(0, speed);
-    if (heading !== undefined) inp.heading = heading;
-    inp.climb = climb;
-    inp.gait = gait || null;
-    return this;
-  }
-  stop() { return this.move({ speed: 0 }); }
-  /** Walk / run to a point and stop there. */
-  moveTo(point, { speed = 3 } = {}) {
-    const inp = this.motion.input;
-    inp.follow = null;
-    inp.target = point ? new THREE.Vector3().copy(point) : null;
-    inp.targetSpeed = speed;
-    return this;
-  }
-  /** Match your own physics body: the animal is placed at `position` and animates for `velocity`. */
-  follow(position, velocity, { heading } = {}) {
-    const inp = this.motion.input;
-    inp.follow = inp.follow || { position: new THREE.Vector3(), velocity: new THREE.Vector3(), heading: null };
-    inp.follow.position.copy(position);
-    inp.follow.velocity.copy(velocity || _v.set(0, 0, 0));
-    inp.follow.heading = heading ?? null;
-    return this;
-  }
-  /** Look at a world point (Vector3) or stop looking (null). The animal keeps tracking the point you pass. */
-  lookAt(target) {
-    this.motion.input.look = target ? (target.isVector3 ? target : new THREE.Vector3().copy(target)) : null;
-    return this;
-  }
-  /**
-   * Play an action ('jump', 'sit', 'lie', 'sleep', 'eat', 'drink', 'attack', 'hit', 'death', 'stand', ...).
-   * A new one-shot interrupts the running one; postures cross-fade.
-   * Resolves with 'done' | 'interrupted' | 'stopped' | 'refused'.
-   */
-  play(name, opts = {}) { return this.motion.play(name, opts); }
-  /** End an action (a posture: stand up), or every action but death when no name is given. */
-  stopAction(name) { this.motion.stop(name); return this; }
-  get actions() { return this.motion.actions; }
-  get gaits() { return this.motion.gaits; }
-  /** Named speeds for UIs ({ walk, trot, ... } in m/s, scaled to this individual's size). */
-  get gears() { return this.motion.gears || {}; }
-
-  // ---------------------------------------------------------------- events
-  on(type, fn) {
-    if (!this._listeners.has(type)) this._listeners.set(type, new Set());
-    this._listeners.get(type).add(fn);
-    return () => this.off(type, fn);
-  }
-  off(type, fn) { this._listeners.get(type)?.delete(fn); return this; }
-  _emit(type, payload) {
-    const set = this._listeners.get(type);
-    if (set) for (const fn of set) fn({ type, animal: this, ...payload });
-  }
-
-  // ---------------------------------------------------------------- state
-  get position() { return this.motion.state.position; }
-  get heading() { return this.motion.state.heading; }
-  get speed() { return this.motion.state.speed; }
-  get velocity() { return this.motion.state.velocity; }
-  get state() { return this.motion.state; }
-
-  // ---------------------------------------------------------------- frame
-  /** Call once per frame with the frame time in seconds. */
-  update(dt) {
-    const t0 = now();
-    if (!(dt >= 0) || !Number.isFinite(dt)) dt = 0;
-    dt = Math.min(dt, 0.1);
-    this.time += dt;
-    this.motion.update(dt);
-    this.render.update({ dt, time: this.time, motion: this.motion });
-    for (const a of this._attachDefs) {
-      const b = this.render.skeleton.byName[a.bone];
-      if (!b) continue;
-      a.o.matrix.multiplyMatrices(b.matrixWorld, a.local);
-      a.o.matrixWorld.multiplyMatrices(this.object.matrixWorld, a.o.matrix);
-      a.o.matrixWorldNeedsUpdate = false;
-    }
-    this.stats.updateMs = this.stats.updateMs * 0.9 + (now() - t0) * 0.1;
-    return this;
-  }
-
-  setQuality(q) { this.render.setQuality?.(q); this.quality = q; return this; }
-  /** Motion level of detail: 0 full, 1 reduced secondary motion, 2 crowd (half-rate IK). */
-  setLod(level) { this.motion.setLod?.(level); this.lod = level; return this; }
-  setDebug(mode, on) { this.render.setDebug?.(mode, on); return this; }
-  /** Show or hide the coverings (fur shells and silhouette fins); the base still reads as fur. */
-  setCoverings(on) { this.render.setCoverings?.(on); return this; }
-
-  dispose() {
-    this.render.dispose();
-    this.motion.dispose?.();
-    this._listeners.clear();
-  }
-}
-
-const now = () => (typeof performance !== 'undefined' ? performance.now() : Date.now());

package/vendor/procedural-animals/src/bake.js

@@ -1,51 +0,0 @@
-// .animal bake files: a built individual, stored so it loads instantly (no SDF meshing, no weights).
-// Layout: "PANM" | u32 version | u32 headerBytes | header JSON (utf-8, padded to 8) | array blobs (8-aligned)
-import { ARRAY_KEYS, FORMAT_VERSION } from './core/build/pipeline.js';
-
-const TYPES = { Float32Array, Uint32Array, Uint16Array, Int16Array, Uint8Array, Int8Array, Int32Array };
-
-export function writeBake(data) {
-  const header = {};
-  for (const [k, v] of Object.entries(data)) if (!ARRAY_KEYS.includes(k)) header[k] = v;
-  header.arrays = [];
-  let offset = 0;
-  for (const k of ARRAY_KEYS) {
-    const a = data[k];
-    header.arrays.push({ key: k, type: a.constructor.name, length: a.length, offset });
-    offset += Math.ceil(a.byteLength / 8) * 8;
-  }
-  let json = new TextEncoder().encode(JSON.stringify(header));
-  const hb = Math.ceil((json.length) / 8) * 8;
-  const total = 12 + hb + offset;
-  const buf = new ArrayBuffer(Math.ceil(total / 8) * 8 + 8);
-  const u8 = new Uint8Array(buf);
-  u8.set([80, 65, 78, 77], 0); // "PANM"
-  const dv = new DataView(buf);
-  dv.setUint32(4, FORMAT_VERSION, true);
-  dv.setUint32(8, hb, true);
-  u8.set(json, 12);
-  for (let i = 12 + json.length; i < 12 + hb; i++) u8[i] = 32;
-  const base = 16 + hb - ((16 + hb) % 8 === 0 ? 0 : (16 + hb) % 8) ;
-  // blobs start at an 8-aligned offset after the header
-  const start = align8(12 + hb);
-  for (const a of header.arrays) u8.set(new Uint8Array(data[a.key].buffer, data[a.key].byteOffset, data[a.key].byteLength), start + a.offset);
-  void base;
-  return buf.slice(0, start + offset);
-}
-
-export function readBake(buf) {
-  const u8 = new Uint8Array(buf);
-  if (u8[0] !== 80 || u8[1] !== 65 || u8[2] !== 78 || u8[3] !== 77) throw new Error('not a .animal file');
-  const dv = new DataView(buf);
-  const version = dv.getUint32(4, true);
-  if (version !== FORMAT_VERSION) throw new Error(`.animal version ${version} is not supported (expected ${FORMAT_VERSION})`);
-  const hb = dv.getUint32(8, true);
-  const header = JSON.parse(new TextDecoder().decode(u8.subarray(12, 12 + hb)));
-  const start = align8(12 + hb);
-  const data = { ...header };
-  for (const a of header.arrays) data[a.key] = new TYPES[a.type](buf, start + a.offset, a.length);
-  delete data.arrays;
-  return data;
-}
-
-const align8 = (n) => Math.ceil(n / 8) * 8;

package/vendor/procedural-animals/src/build.js

@@ -1,81 +0,0 @@
-// Builds an individual's data: in Web Workers when possible (meshing jobs in parallel, then
-// weights + coat), otherwise on the calling thread. Results are cached per (species, seed, quality,
-// sex, age) so a herd that reuses individuals shares geometry.
-import { buildSync, normaliseOptions } from './core/build/pipeline.js';
-import { loadSpecies } from './registry.js';
-
-let defaultWorkerFactory = null;
-export function setWorkerFactory(fn) { defaultWorkerFactory = fn; }
-
-function makeWorker(opt) {
-  if (opt === false) return null;
-  try {
-    if (typeof opt === 'function') return opt();
-    if (defaultWorkerFactory) return defaultWorkerFactory();
-    if (typeof Worker === 'undefined') return null;
-    return new Worker(new URL('./worker.js', import.meta.url), { type: 'module' });
-  } catch (e) {
-    return null;
-  }
-}
-
-const cache = new Map();
-export function cacheKey(speciesId, opts) {
-  const o = normaliseOptions(opts);
-  return [speciesId, o.seed, o.quality, o.sex || '', o.age || '', o.variant || '', JSON.stringify(o.overrides)].join('|');
-}
-
-export async function buildAnimalData(species, opts = {}, onProgress = () => {}) {
-  const s = await loadSpecies(species);
-  const key = cacheKey(s.id, opts);
-  if (cache.has(key)) return cache.get(key);
-  const p = buildInWorkers(s, opts, onProgress).catch((e) => { cache.delete(key); throw e; });
-  cache.set(key, p);
-  return p;
-}
-export function clearBuildCache() { cache.clear(); }
-
-async function buildInWorkers(species, opts, onProgress) {
-  const o = normaliseOptions(opts);
-  const nJobs = species.regions ? null : 1;
-  void nJobs;
-  const first = makeWorker(opts.worker);
-  if (!first) {
-    await new Promise((r) => setTimeout(r, 0));
-    return buildSync(species, o, onProgress);
-  }
-  const t0 = performance.now();
-  // how many meshing jobs? (cheap: prepare runs the sculpt only)
-  const { prepare } = await import('./core/build/pipeline.js');
-  const jobsN = prepare(species, o).reg.jobs.length;
-  const workers = [first];
-  for (let i = 1; i < jobsN; i++) { const w = makeWorker(opts.worker); if (w) workers.push(w); }
-  const call = (w, msg) => new Promise((resolve, reject) => {
-    w.onmessage = (e) => {
-      const m = e.data;
-      if (m.type === 'progress') onProgress(m.msg);
-      else if (m.type === 'error') reject(new Error(m.message));
-      else resolve(m);
-    };
-    w.onerror = (e) => reject(new Error(e.message || 'procedural-animals worker failed'));
-    w.postMessage(msg);
-  });
-  try {
-    const jobs = new Array(jobsN);
-    let next = 0;
-    await Promise.all(workers.map(async (w) => {
-      while (next < jobsN) {
-        const j = next++;
-        onProgress('mesh ' + j);
-        const r = await call(w, { task: 'mesh', species: species.id, opts: o, job: j });
-        jobs[j] = r.parts;
-      }
-    }));
-    onProgress('finish');
-    const r = await call(first, { task: 'finish', species: species.id, opts: o, jobs });
-    r.data.stats.buildMs = Math.round(performance.now() - t0);
-    return r.data;
-  } finally {
-    for (const w of workers) w.terminate();
-  }
-}

package/vendor/procedural-animals/src/core/build/coatKit.js

@@ -1,121 +0,0 @@
-// Helpers for species coat painters.
-import { SDFModel } from '../sdf/sdf.js';
-import { sub, add, mul, dot, len, clamp, mix } from '../math/vec.js';
-
-// sRGB hex -> linear rgb
-export const srgb = (hex) => {
-  const c = [(hex >> 16) & 255, (hex >> 8) & 255, hex & 255].map((v) => v / 255);
-  return c.map((v) => (v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4)));
-};
-export const mix3 = (a, b, t) => [mix(a[0], b[0], t), mix(a[1], b[1], t), mix(a[2], b[2], t)];
-export const scale3 = (a, k) => [a[0] * k, a[1] * k, a[2] * k];
-
-// Material ids stored in tint.w (see render/coatMaterial.js)
-export const MAT = { FUR: 0, NOSE: 1, DARK_SKIN: 2, MOUTH: 3, SKIN: 4, KERATIN: 5, SCALES: 6, WET_SKIN: 7, CHITIN: 8, FEATHER: 9, VANE: 10, FIN: 11 }; // 10: flight-feather vane (featherCards.js), 11: fin membrane (render/membranes.js)
-
-// Newton-project a point onto the zero set of a primitive list
-export function projectToSurface(prims, q, iters = 6) {
-  let x = q.slice();
-  for (let i = 0; i < iters; i++) {
-    const d = SDFModel.evalList(prims, x[0], x[1], x[2]);
-    const e = 0.0005;
-    const g = [
-      SDFModel.evalList(prims, x[0] + e, x[1], x[2]) - d,
-      SDFModel.evalList(prims, x[0], x[1] + e, x[2]) - d,
-      SDFModel.evalList(prims, x[0], x[1], x[2] + e) - d,
-    ].map((c) => c / e);
-    const gl = len(g) || 1;
-    x = sub(x, mul(g, d / (gl * gl)));
-  }
-  return x;
-}
-
-// distance from p to a polyline with per-vertex half widths (negative inside)
-export function distPolyline(p, poly, widths) {
-  let best = 1e9;
-  for (let i = 0; i < poly.length - 1; i++) {
-    const a = poly[i], b = poly[i + 1], ab = sub(b, a);
-    const t = clamp(dot(sub(p, a), ab) / dot(ab, ab), 0, 1);
-    const d = len(sub(p, add(a, mul(ab, t)))) - mix(widths[i], widths[i + 1], t);
-    if (d < best) best = d;
-  }
-  return best;
-}
-
-// Laplacian smoothing of a scalar field over the mesh graph; `lock(v)` keeps a vertex fixed
-export function smoothField(f, neighbors, iters = 2, lock = null) {
-  const n = f.length, tmp = new Float32Array(n);
-  for (let it = 0; it < iters; it++) {
-    for (let v = 0; v < n; v++) {
-      const ns = neighbors[v];
-      if (!ns.length || (lock && lock(v))) { tmp[v] = f[v]; continue; }
-      let a = 0;
-      for (const u of ns) a += f[u];
-      tmp[v] = 0.5 * f[v] + (0.5 * a) / ns.length;
-    }
-    f.set(tmp);
-  }
-  return f;
-}
-
-// Poisson-disc features grown on the surface. radius(v) -> r (0 = no feature here);
-// returns { spots, grid, cell, key } for use with featureField.
-export function poissonFeatures({ pos, nrm, nV, radius, R, spacing = 1.52, gap = 0.0025, cell = 0.03, skip = null, extra = null }) {
-  const order = new Uint32Array(nV);
-  for (let i = 0; i < nV; i++) order[i] = i;
-  for (let i = nV - 1; i > 0; i--) { const j = Math.floor(R() * (i + 1)); const t = order[i]; order[i] = order[j]; order[j] = t; }
-  const grid = new Map();
-  const key = (x, y, z) => ((x + 512) * 1024 + (y + 512)) * 1024 + (z + 512);
-  const spots = [];
-  for (let k = 0; k < nV; k++) {
-    const v = order[k];
-    if (skip && skip(v)) continue;
-    let r = radius(v);
-    if (!(r > 0)) continue;
-    r *= 0.78 + 0.44 * R();
-    const p = [pos[v * 3], pos[v * 3 + 1], pos[v * 3 + 2]];
-    const gx = Math.floor(p[0] / cell), gy = Math.floor(p[1] / cell), gz = Math.floor(p[2] / cell);
-    let ok = true;
-    for (let dz = -1; dz <= 1 && ok; dz++)
-      for (let dy = -1; dy <= 1 && ok; dy++)
-        for (let dx = -1; dx <= 1 && ok; dx++) {
-          const arr = grid.get(key(gx + dx, gy + dy, gz + dz));
-          if (!arr) continue;
-          for (const s of arr) {
-            const minD = spacing * (r + s.r) + gap;
-            const ddx = p[0] - s.p[0], ddy = p[1] - s.p[1], ddz = p[2] - s.p[2];
-            if (ddx * ddx + ddy * ddy + ddz * ddz < minD * minD) { ok = false; break; }
-          }
-        }
-    if (!ok) continue;
-    const s = { v, p, r, n: [nrm[v * 3], nrm[v * 3 + 1], nrm[v * 3 + 2]], ...(extra ? extra(v, R) : {}) };
-    spots.push(s);
-    const kk = key(gx, gy, gz);
-    (grid.get(kk) || grid.set(kk, []).get(kk)).push(s);
-  }
-  return { spots, grid, cell, key };
-}
-
-// Signed distance to the nearest feature of a poissonFeatures() set, elongated along each
-// feature's comb direction `c` by `el`. Returns [sdf, feature].
-export function featureDistance(F, p, n, wob = 1) {
-  const { grid, cell, key } = F;
-  let best = 1e9, bs = null;
-  const gx = Math.floor(p[0] / cell), gy = Math.floor(p[1] / cell), gz = Math.floor(p[2] / cell);
-  for (let dz = -1; dz <= 1; dz++)
-    for (let dy = -1; dy <= 1; dy++)
-      for (let dx = -1; dx <= 1; dx++) {
-        const arr = grid.get(key(gx + dx, gy + dy, gz + dz));
-        if (!arr) continue;
-        for (const s of arr) {
-          if (dot(s.n, n) < 0.2) continue;
-          const d = sub(p, s.p);
-          const el = s.el || 1;
-          const along = s.c ? dot(d, s.c) : 0;
-          const dd = Math.sqrt(Math.max(0, dot(d, d) - along * along * (1 - 1 / (el * el))));
-          const sd = dd - s.r * wob;
-          if (sd < best) { best = sd; bs = s; }
-        }
-      }
-  return [best, bs];
-}