@sudobility/music_spatial_core 0.0.2

package/README.md

@@ -0,0 +1,9 @@
+# @sudobility/music_spatial_core
+
+Platform-agnostic engine behind the Moosiac "Spatial" 3D view: instrument
+geometry, scene composition, camera/listener math, movement stepping, and
+map-overlay math — shared, byte-for-byte, by `@sudobility/music_spatial`
+(web) and `@sudobility/music_spatial_rn` (React Native). Depends on `three`
+and `react` core only — never `react-dom` or `react-native` — so the same
+build runs unmodified on both. Not yet implemented — see
+[`docs/SPEC.md`](docs/SPEC.md).

package/dist/colors.d.ts

@@ -0,0 +1,39 @@
+/**
+ * One colour per track, from its name — the same colour on the map marker
+ * and on the instrument's lines in the 3D view, so "which one is the
+ * cello" is answered the same way in both.
+ *
+ * The hue is a hash of the track's *name* (stable across sessions and
+ * devices, no state to store), then pushed apart from any other track's
+ * hue within the score so two "Violin" tracks — or two names that happen
+ * to hash close — still come out distinguishable. Saturation/lightness are
+ * fixed for the dark stage: a full-strength but not-quite-white "lit"
+ * colour while the part sounds, and a dimmer "base" while it rests.
+ */
+export interface TrackColor {
+    /** 0–360. */
+    readonly hue: number;
+    /** CSS colour for a resting instrument. */
+    readonly base: string;
+    /** CSS colour for a sounding one. */
+    readonly lit: string;
+}
+/** FNV-1a over the UTF-16 code units, then spread over the hue circle. */
+export declare function hueFromName(name: string): number;
+/**
+ * Resting: mostly grey with a tint of the track's hue — enough to tell
+ * which instrument is which, not enough to compete with the ones sounding.
+ * Sounding: the hue at full strength.
+ */
+export declare function colorFromHue(hue: number): TrackColor;
+/**
+ * Colours for every track in a score, keyed by id. Hues start from each
+ * name's hash and are then separated: going round the circle, any hue
+ * closer than `MIN_GAP` to the previous one is pushed forward. With more
+ * than 360/MIN_GAP tracks the gap shrinks to what fits.
+ */
+export declare function trackColors(tracks: readonly {
+    readonly id: string;
+    readonly name: string;
+}[]): Readonly<Record<string, TrackColor>>;
+//# sourceMappingURL=colors.d.ts.map

package/dist/colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../src/colors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,UAAU;IACzB,aAAa;IACb,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,qCAAqC;IACrC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,0EAA0E;AAC1E,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQhD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAOpD;AAKD;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,SAAS;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,GAChE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAmBtC"}

package/dist/colors.js

@@ -0,0 +1,67 @@
+/**
+ * One colour per track, from its name — the same colour on the map marker
+ * and on the instrument's lines in the 3D view, so "which one is the
+ * cello" is answered the same way in both.
+ *
+ * The hue is a hash of the track's *name* (stable across sessions and
+ * devices, no state to store), then pushed apart from any other track's
+ * hue within the score so two "Violin" tracks — or two names that happen
+ * to hash close — still come out distinguishable. Saturation/lightness are
+ * fixed for the dark stage: a full-strength but not-quite-white "lit"
+ * colour while the part sounds, and a dimmer "base" while it rests.
+ */
+/** FNV-1a over the UTF-16 code units, then spread over the hue circle. */
+export function hueFromName(name) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < name.length; i++) {
+        h ^= name.charCodeAt(i);
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    // The golden-angle stretch turns similar hashes into well-separated hues.
+    return (h * 137.508) % 360;
+}
+/**
+ * Resting: mostly grey with a tint of the track's hue — enough to tell
+ * which instrument is which, not enough to compete with the ones sounding.
+ * Sounding: the hue at full strength.
+ */
+export function colorFromHue(hue) {
+    const h = ((hue % 360) + 360) % 360;
+    return {
+        hue: h,
+        base: `hsl(${h.toFixed(0)}, 10%, 50%)`,
+        lit: `hsl(${h.toFixed(0)}, 100%, 70%)`,
+    };
+}
+/** The smallest hue gap two tracks are allowed, in degrees. */
+const MIN_GAP = 28;
+/**
+ * Colours for every track in a score, keyed by id. Hues start from each
+ * name's hash and are then separated: going round the circle, any hue
+ * closer than `MIN_GAP` to the previous one is pushed forward. With more
+ * than 360/MIN_GAP tracks the gap shrinks to what fits.
+ */
+export function trackColors(tracks) {
+    const out = {};
+    if (tracks.length === 0)
+        return out;
+    const gap = Math.min(MIN_GAP, 360 / tracks.length);
+    const order = tracks
+        .map((track, index) => ({ track, index, hue: hueFromName(track.name) }))
+        .sort((a, b) => a.hue - b.hue || a.index - b.index);
+    // Two passes round the circle: the second catches the wrap-around
+    // between the last and the first.
+    for (let pass = 0; pass < 2; pass++) {
+        for (let i = 0; i < order.length; i++) {
+            const prev = order[(i - 1 + order.length) % order.length];
+            const cur = order[i];
+            const prevHue = i === 0 ? prev.hue - 360 : prev.hue;
+            if (cur.hue - prevHue < gap)
+                cur.hue = prevHue + gap;
+        }
+    }
+    for (const { track, hue } of order)
+        out[track.id] = colorFromHue(hue);
+    return out;
+}
+//# sourceMappingURL=colors.js.map

package/dist/colors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"colors.js","sourceRoot":"","sources":["../src/colors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAWH,0EAA0E;AAC1E,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,IAAI,CAAC,GAAG,UAAU,CAAC;IACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QACxB,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;IACrC,CAAC;IACD,0EAA0E;IAC1E,OAAO,CAAC,CAAC,GAAG,OAAO,CAAC,GAAG,GAAG,CAAC;AAC7B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,GAAW;IACtC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;IACpC,OAAO;QACL,GAAG,EAAE,CAAC;QACN,IAAI,EAAE,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,aAAa;QACtC,GAAG,EAAE,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,cAAc;KACvC,CAAC;AACJ,CAAC;AAED,+DAA+D;AAC/D,MAAM,OAAO,GAAG,EAAE,CAAC;AAEnB;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CACzB,MAAiE;IAEjE,MAAM,GAAG,GAA+B,EAAE,CAAC;IAC3C,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,GAAG,CAAC;IACpC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;IACnD,MAAM,KAAK,GAAG,MAAM;SACjB,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;SACvE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;IACtD,kEAAkE;IAClE,kCAAkC;IAClC,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC;QACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;YAC1D,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACrB,MAAM,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;YACpD,IAAI,GAAG,CAAC,GAAG,GAAG,OAAO,GAAG,GAAG;gBAAE,GAAG,CAAC,GAAG,GAAG,OAAO,GAAG,GAAG,CAAC;QACvD,CAAC;IACH,CAAC;IACD,KAAK,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,KAAK;QAAE,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACtE,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/facing.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Which instrument the listener is looking at — the nearest one inside the
+ * field of view — so a host can follow it with its active track while the
+ * Spatial view is on.
+ *
+ * Sticky on purpose: the current pick is kept until it leaves the field of
+ * view or another instrument is clearly nearer (by `SWITCH_MARGIN`).
+ * Without that, standing between two instruments at equal distance would
+ * flip the selection every frame as the listener drifted.
+ */
+import type { UnpluggedListener, UnpluggedPoint } from '@sudobility/music_types';
+export interface FacingCandidate {
+    readonly id: string;
+    readonly point: UnpluggedPoint;
+}
+/** Half-angle of the field of view an instrument must be within, degrees. */
+export declare const FACING_HALF_ANGLE = 60;
+/**
+ * The id of the instrument to follow, or `currentId` when nothing has
+ * changed, or null when nothing is in view.
+ */
+export declare function facingTrackId(listener: UnpluggedListener, candidates: readonly FacingCandidate[], currentId: string | null, halfAngleDeg?: number): string | null;
+//# sourceMappingURL=facing.d.ts.map

package/dist/facing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"facing.d.ts","sourceRoot":"","sources":["../src/facing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACf,MAAM,yBAAyB,CAAC;AAEjC,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;CAChC;AAED,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAQpC;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,iBAAiB,EAC3B,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,YAAY,SAAoB,GAC/B,MAAM,GAAG,IAAI,CAsBf"}

package/dist/facing.js

@@ -0,0 +1,38 @@
+/** Half-angle of the field of view an instrument must be within, degrees. */
+export const FACING_HALF_ANGLE = 60;
+/** A challenger must be this much nearer than the current pick to take over. */
+const SWITCH_MARGIN = 0.85;
+function normalizeDeg(deg) {
+    return ((((deg + 180) % 360) + 360) % 360) - 180;
+}
+/**
+ * The id of the instrument to follow, or `currentId` when nothing has
+ * changed, or null when nothing is in view.
+ */
+export function facingTrackId(listener, candidates, currentId, halfAngleDeg = FACING_HALF_ANGLE) {
+    let best = null;
+    let current = null;
+    for (const c of candidates) {
+        const dx = c.point.x - listener.x;
+        const dz = c.point.z - listener.z;
+        const bearing = (Math.atan2(dx, dz) * 180) / Math.PI;
+        const off = Math.abs(normalizeDeg(bearing - listener.facingDeg));
+        if (off > halfAngleDeg)
+            continue;
+        // "Facing" weighs the angle as well as the range: an instrument dead
+        // ahead beats a slightly nearer one at the edge of view. The effective
+        // distance grows as the instrument moves off-axis — doubled at the
+        // edge of a 60° half-angle — rather than a hard nearest-wins.
+        const distance = Math.hypot(dx, dz) / Math.max(0.5, Math.cos((off * Math.PI) / 180));
+        if (c.id === currentId)
+            current = { id: c.id, distance };
+        if (!best || distance < best.distance)
+            best = { id: c.id, distance };
+    }
+    if (!best)
+        return null;
+    if (current && best.distance >= current.distance * SWITCH_MARGIN)
+        return current.id;
+    return best.id;
+}
+//# sourceMappingURL=facing.js.map

package/dist/facing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"facing.js","sourceRoot":"","sources":["../src/facing.ts"],"names":[],"mappings":"AAoBA,6EAA6E;AAC7E,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,CAAC;AACpC,gFAAgF;AAChF,MAAM,aAAa,GAAG,IAAI,CAAC;AAE3B,SAAS,YAAY,CAAC,GAAW;IAC/B,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;AACnD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAC3B,QAA2B,EAC3B,UAAsC,EACtC,SAAwB,EACxB,YAAY,GAAG,iBAAiB;IAEhC,IAAI,IAAI,GAA4C,IAAI,CAAC;IACzD,IAAI,OAAO,GAA4C,IAAI,CAAC;IAC5D,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;QAC3B,MAAM,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;QAClC,MAAM,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;QAClC,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC;QACrD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,OAAO,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC;QACjE,IAAI,GAAG,GAAG,YAAY;YAAE,SAAS;QACjC,qEAAqE;QACrE,uEAAuE;QACvE,mEAAmE;QACnE,8DAA8D;QAC9D,MAAM,QAAQ,GACZ,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;QACtE,IAAI,CAAC,CAAC,EAAE,KAAK,SAAS;YAAE,OAAO,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC;QACzD,IAAI,CAAC,IAAI,IAAI,QAAQ,GAAG,IAAI,CAAC,QAAQ;YAAE,IAAI,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC;IACvE,CAAC;IACD,IAAI,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IACvB,IAAI,OAAO,IAAI,IAAI,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,GAAG,aAAa;QAC9D,OAAO,OAAO,CAAC,EAAE,CAAC;IACpB,OAAO,IAAI,CAAC,EAAE,CAAC;AACjB,CAAC"}

package/dist/geometry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Turns an authored `InstrumentSpatialModel`'s strokes into drawable
+ * `three` geometry — the one mechanical, non-authored step in the pipeline.
+ *
+ * Deliberately does NOT take a pose. A model's pose (offset/rotation/scale
+ * from `spatialModelForTrack`) becomes an *object* transform — applied by
+ * `buildScene` as the `position`/`rotation`/`scale` a platform package
+ * hands to `<group>`/`<lineSegments>` — rather than baked into vertex
+ * coordinates here. `three`'s own transform pipeline already does this
+ * correctly; re-deriving rotation matrices by hand in this file would only
+ * be a second, riskier way to compute the same thing.
+ */
+import { BufferGeometry } from 'three';
+import type { InstrumentSpatialModel } from '@sudobility/music_types';
+/** One `THREE.BufferGeometry` per stroke, set up for `THREE.LineSegments`
+ *  (consecutive point pairs, not a single continuous line strip) — both
+ *  platform packages wrap each in `<lineSegments geometry={g} />`. */
+export declare function buildInstrumentGeometry(model: InstrumentSpatialModel): readonly BufferGeometry[];
+//# sourceMappingURL=geometry.d.ts.map

package/dist/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../src/geometry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,cAAc,EAA0B,MAAM,OAAO,CAAC;AAC/D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAEtE;;sEAEsE;AACtE,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,sBAAsB,GAC5B,SAAS,cAAc,EAAE,CAM3B"}

package/dist/geometry.js

@@ -0,0 +1,51 @@
+/**
+ * Turns an authored `InstrumentSpatialModel`'s strokes into drawable
+ * `three` geometry — the one mechanical, non-authored step in the pipeline.
+ *
+ * Deliberately does NOT take a pose. A model's pose (offset/rotation/scale
+ * from `spatialModelForTrack`) becomes an *object* transform — applied by
+ * `buildScene` as the `position`/`rotation`/`scale` a platform package
+ * hands to `<group>`/`<lineSegments>` — rather than baked into vertex
+ * coordinates here. `three`'s own transform pipeline already does this
+ * correctly; re-deriving rotation matrices by hand in this file would only
+ * be a second, riskier way to compute the same thing.
+ */
+import { BufferGeometry, Float32BufferAttribute } from 'three';
+/** One `THREE.BufferGeometry` per stroke, set up for `THREE.LineSegments`
+ *  (consecutive point pairs, not a single continuous line strip) — both
+ *  platform packages wrap each in `<lineSegments geometry={g} />`. */
+export function buildInstrumentGeometry(model) {
+    const cached = GEOMETRY_CACHE.get(model);
+    if (cached)
+        return cached;
+    const built = buildUncached(model);
+    GEOMETRY_CACHE.set(model, built);
+    return built;
+}
+/**
+ * Keyed by model identity: the models are module-level singletons in
+ * music_types (a violin is one object for the life of the process), and
+ * `buildScene` runs on every sounding-state change — many times a second
+ * while playing — so without this every note-on rebuilt a few hundred
+ * segments per instrument. Geometries are never mutated after creation,
+ * so sharing one across instances and frames is safe.
+ */
+const GEOMETRY_CACHE = new WeakMap();
+function buildUncached(model) {
+    return model.strokes.map(stroke => {
+        const positions = [];
+        for (let i = 0; i < stroke.length - 1; i++) {
+            const [ax, ay, az] = stroke[i];
+            const [bx, by, bz] = stroke[i + 1];
+            // x mirrored: the models are authored in the left-handed arrangement
+            // frame (+x = the player's right facing +z); three.js is
+            // right-handed. See scene.ts, which mirrors positions and rotations
+            // to match.
+            positions.push(-ax, ay, az, -bx, by, bz);
+        }
+        const geometry = new BufferGeometry();
+        geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
+        return geometry;
+    });
+}
+//# sourceMappingURL=geometry.js.map

package/dist/geometry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.js","sourceRoot":"","sources":["../src/geometry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,OAAO,CAAC;AAG/D;;sEAEsE;AACtE,MAAM,UAAU,uBAAuB,CACrC,KAA6B;IAE7B,MAAM,MAAM,GAAG,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACzC,IAAI,MAAM;QAAE,OAAO,MAAM,CAAC;IAC1B,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;IACnC,cAAc,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACjC,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,cAAc,GAAG,IAAI,OAAO,EAG/B,CAAC;AAEJ,SAAS,aAAa,CACpB,KAA6B;IAE7B,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;QAChC,MAAM,SAAS,GAAa,EAAE,CAAC;QAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3C,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YAC/B,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACnC,qEAAqE;YACrE,yDAAyD;YACzD,oEAAoE;YACpE,YAAY;YACZ,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QAC3C,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,cAAc,EAAE,CAAC;QACtC,QAAQ,CAAC,YAAY,CAAC,UAAU,EAAE,IAAI,sBAAsB,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;QAC5E,OAAO,QAAQ,CAAC;IAClB,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './geometry';
+export * from './map-math';
+export * from './movement';
+export * from './scene';
+export * from './use-throttled-commit';
+export { effectiveUnpluggedArrangement, UNPLUGGED_RADIUS, } from '@sudobility/music_types';
+export type { EffectiveUnpluggedArrangement } from '@sudobility/music_types';
+export * from './colors';
+export * from './wander';
+export * from './facing';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,wBAAwB,CAAC;AAMvC,OAAO,EACL,6BAA6B,EAC7B,gBAAgB,GACjB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AAC7E,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,14 @@
+export * from './geometry';
+export * from './map-math';
+export * from './movement';
+export * from './scene';
+export * from './use-throttled-commit';
+// Re-exported for the platform packages, which already depend on
+// music_types themselves but read these through here alongside everything
+// above. They live in music_types (domain/unplugged) — this package has no
+// music_lib dependency.
+export { effectiveUnpluggedArrangement, UNPLUGGED_RADIUS, } from '@sudobility/music_types';
+export * from './colors';
+export * from './wander';
+export * from './facing';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,wBAAwB,CAAC;AAEvC,iEAAiE;AACjE,0EAA0E;AAC1E,2EAA2E;AAC3E,wBAAwB;AACxB,OAAO,EACL,6BAA6B,EAC7B,gBAAgB,GACjB,MAAM,yBAAyB,CAAC;AAEjC,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/dist/map-math.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Pure geometry for the 2D map overlay: pixel position <-> arrangement
+ * point, and the listener's rotation-handle bearing — extracted from the
+ * existing `UnpluggedTab.tsx` (both platforms) so it's written once. Each
+ * platform still owns *capturing* a pixel position (DOM pointer events vs.
+ * RN `measureInWindow`/gesture-handler); everything downstream of "here is
+ * a pixel position" lives here.
+ */
+import type { UnpluggedPoint } from '@sudobility/music_types';
+export interface OverlayGeometry {
+    readonly centerX: number;
+    readonly centerY: number;
+    /** The rendered circle's radius, in the overlay's own pixel space. */
+    readonly radiusPx: number;
+    /** The arrangement-space radius (e.g. `UNPLUGGED_RADIUS`) that `radiusPx`
+     *  represents — together they give the pixels-per-unit scale. */
+    readonly radiusUnits: number;
+}
+/**
+ * Pixel position -> a point in arrangement space, clamped to the
+ * arrangement's radius so a drag can never place an instrument or the
+ * listener further out than the overlay can show.
+ *
+ * Screen Y increases downward; arrangement `z` increases into the
+ * arrangement (away from the overlay's bottom, where the listener's default
+ * position sits) — so screen-down maps to arrangement-backward, not forward.
+ */
+export declare function pointFromPixel(geometry: OverlayGeometry, pixelX: number, pixelY: number): UnpluggedPoint;
+/** The reverse of `pointFromPixel`, for drawing a marker at a point's pixel
+ *  position. */
+export declare function pixelFromPoint(geometry: OverlayGeometry, point: UnpluggedPoint): {
+    readonly x: number;
+    readonly y: number;
+};
+/**
+ * A pixel *delta* converted to a stage-space delta — for dragging a marker
+ * by accumulating movement onto its own last position, not by snapping the
+ * marker to the pointer's absolute position. That distinction matters:
+ * grabbing a marker somewhere other than its exact center and dragging it
+ * would otherwise make the marker jump to re-center itself under the
+ * pointer on the very first event. Rotation (`bearingFromCenter`) is the
+ * opposite case on purpose — always absolute, never delta, so it cannot
+ * drift from compounding rounding the way this function's own accumulation
+ * would if used for an angle.
+ */
+export declare function stageDeltaFromPixelDelta(geometry: OverlayGeometry, dxPx: number, dyPx: number): {
+    readonly dx: number;
+    readonly dz: number;
+};
+/**
+ * Bearing from the arrangement's center to a pixel position, in degrees,
+ * using the exact same convention as `unpluggedMixFor` (music_lib):
+ * `atan2(dx, dz)`, clockwise-positive from `+z`.
+ *
+ * Computed fresh from the CURRENT absolute pixel position every call, never
+ * from an accumulated delta — that's the exact-rotation fix the 2D build
+ * already needed (drift from compounding rounding when a bearing was
+ * derived from its own previous answer) and it applies identically here.
+ */
+export declare function bearingFromCenter(geometry: OverlayGeometry, pixelX: number, pixelY: number): number;
+//# sourceMappingURL=map-math.d.ts.map

package/dist/map-math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-math.d.ts","sourceRoot":"","sources":["../src/map-math.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAE9D,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;qEACiE;IACjE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,eAAe,EACzB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,cAAc,CAYhB;AAED;gBACgB;AAChB,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,eAAe,EACzB,KAAK,EAAE,cAAc,GACpB;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAM5C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAG9C;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,eAAe,EACzB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,MAAM,CAIR"}

package/dist/map-math.js

@@ -0,0 +1,61 @@
+/**
+ * Pixel position -> a point in arrangement space, clamped to the
+ * arrangement's radius so a drag can never place an instrument or the
+ * listener further out than the overlay can show.
+ *
+ * Screen Y increases downward; arrangement `z` increases into the
+ * arrangement (away from the overlay's bottom, where the listener's default
+ * position sits) — so screen-down maps to arrangement-backward, not forward.
+ */
+export function pointFromPixel(geometry, pixelX, pixelY) {
+    const unitsPerPixel = geometry.radiusUnits / geometry.radiusPx;
+    let x = (pixelX - geometry.centerX) * unitsPerPixel;
+    let z = -(pixelY - geometry.centerY) * unitsPerPixel;
+    const distance = Math.hypot(x, z);
+    if (distance > geometry.radiusUnits) {
+        const factor = geometry.radiusUnits / distance;
+        x *= factor;
+        z *= factor;
+    }
+    return { x, z };
+}
+/** The reverse of `pointFromPixel`, for drawing a marker at a point's pixel
+ *  position. */
+export function pixelFromPoint(geometry, point) {
+    const pixelsPerUnit = geometry.radiusPx / geometry.radiusUnits;
+    return {
+        x: geometry.centerX + point.x * pixelsPerUnit,
+        y: geometry.centerY - point.z * pixelsPerUnit,
+    };
+}
+/**
+ * A pixel *delta* converted to a stage-space delta — for dragging a marker
+ * by accumulating movement onto its own last position, not by snapping the
+ * marker to the pointer's absolute position. That distinction matters:
+ * grabbing a marker somewhere other than its exact center and dragging it
+ * would otherwise make the marker jump to re-center itself under the
+ * pointer on the very first event. Rotation (`bearingFromCenter`) is the
+ * opposite case on purpose — always absolute, never delta, so it cannot
+ * drift from compounding rounding the way this function's own accumulation
+ * would if used for an angle.
+ */
+export function stageDeltaFromPixelDelta(geometry, dxPx, dyPx) {
+    const unitsPerPixel = geometry.radiusUnits / geometry.radiusPx;
+    return { dx: dxPx * unitsPerPixel, dz: -dyPx * unitsPerPixel };
+}
+/**
+ * Bearing from the arrangement's center to a pixel position, in degrees,
+ * using the exact same convention as `unpluggedMixFor` (music_lib):
+ * `atan2(dx, dz)`, clockwise-positive from `+z`.
+ *
+ * Computed fresh from the CURRENT absolute pixel position every call, never
+ * from an accumulated delta — that's the exact-rotation fix the 2D build
+ * already needed (drift from compounding rounding when a bearing was
+ * derived from its own previous answer) and it applies identically here.
+ */
+export function bearingFromCenter(geometry, pixelX, pixelY) {
+    const dx = pixelX - geometry.centerX;
+    const dz = -(pixelY - geometry.centerY);
+    return (Math.atan2(dx, dz) * 180) / Math.PI;
+}
+//# sourceMappingURL=map-math.js.map

package/dist/map-math.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-math.js","sourceRoot":"","sources":["../src/map-math.ts"],"names":[],"mappings":"AAoBA;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAC5B,QAAyB,EACzB,MAAc,EACd,MAAc;IAEd,MAAM,aAAa,GAAG,QAAQ,CAAC,WAAW,GAAG,QAAQ,CAAC,QAAQ,CAAC;IAC/D,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,aAAa,CAAC;IACpD,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,aAAa,CAAC;IAErD,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAClC,IAAI,QAAQ,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC;QACpC,MAAM,MAAM,GAAG,QAAQ,CAAC,WAAW,GAAG,QAAQ,CAAC;QAC/C,CAAC,IAAI,MAAM,CAAC;QACZ,CAAC,IAAI,MAAM,CAAC;IACd,CAAC;IACD,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AAClB,CAAC;AAED;gBACgB;AAChB,MAAM,UAAU,cAAc,CAC5B,QAAyB,EACzB,KAAqB;IAErB,MAAM,aAAa,GAAG,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC,WAAW,CAAC;IAC/D,OAAO;QACL,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,KAAK,CAAC,CAAC,GAAG,aAAa;QAC7C,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,KAAK,CAAC,CAAC,GAAG,aAAa;KAC9C,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,wBAAwB,CACtC,QAAyB,EACzB,IAAY,EACZ,IAAY;IAEZ,MAAM,aAAa,GAAG,QAAQ,CAAC,WAAW,GAAG,QAAQ,CAAC,QAAQ,CAAC;IAC/D,OAAO,EAAE,EAAE,EAAE,IAAI,GAAG,aAAa,EAAE,EAAE,EAAE,CAAC,IAAI,GAAG,aAAa,EAAE,CAAC;AACjE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,iBAAiB,CAC/B,QAAyB,EACzB,MAAc,EACd,MAAc;IAEd,MAAM,EAAE,GAAG,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC;IACrC,MAAM,EAAE,GAAG,CAAC,CAAC,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;IACxC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC;AAC9C,CAAC"}

package/dist/movement.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Continuous, frame-rate-independent listener movement for the Spatial 3D
+ * view — walking while a key is held or a joystick is pushed, as distinct
+ * from the 2D map's discrete one-step-per-keypress nudge (which stays a
+ * direct, simpler caller of the Unplugged commands, unchanged by this).
+ *
+ * Lives here, not in `@sudobility/music_lib`, because it's Spatial-view-only
+ * behavior — nothing else in either app ever calls it — while `music_lib`
+ * keeps only what's needed independent of whether the Spatial view exists
+ * (`effectiveUnpluggedArrangement`, the audio mix formula).
+ */
+import type { UnpluggedListener } from '@sudobility/music_types';
+export interface MovementInput {
+    /** -1 (backward) .. 1 (forward), relative to the listener's current facing. */
+    readonly forward: number;
+    /** -1 (left) .. 1 (right), relative to the listener's current facing. */
+    readonly strafe: number;
+    /** -1 (turn left) .. 1 (turn right). */
+    readonly turn: number;
+}
+export interface MovementSpeed {
+    readonly metersPerSecond: number;
+    readonly degreesPerSecond: number;
+}
+export declare const DEFAULT_MOVEMENT_SPEED: MovementSpeed;
+/**
+ * One frame's movement: turn first, then move along the *new* facing — the
+ * way a person actually walks while turning, and the only order that makes
+ * "hold forward and turn" curve rather than move in a straight line then
+ * snap direction.
+ *
+ * Uses the exact bearing convention `unplugged.ts` (music_lib) already
+ * established: `dx = distance * sin(bearingRad)`, `dz = distance *
+ * cos(bearingRad)`, `facingDeg` clockwise-positive from `+z`. Strafe moves
+ * perpendicular to facing, 90° clockwise (right).
+ */
+export declare function stepListener(listener: UnpluggedListener, input: MovementInput, deltaSeconds: number, speed?: MovementSpeed): UnpluggedListener;
+//# sourceMappingURL=movement.d.ts.map

package/dist/movement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"movement.d.ts","sourceRoot":"","sources":["../src/movement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,MAAM,WAAW,aAAa;IAC5B,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAED,eAAO,MAAM,sBAAsB,EAAE,aAGpC,CAAC;AAYF;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,aAAa,EACpB,YAAY,EAAE,MAAM,EACpB,KAAK,GAAE,aAAsC,GAC5C,iBAAiB,CAyBnB"}

package/dist/movement.js

@@ -0,0 +1,43 @@
+export const DEFAULT_MOVEMENT_SPEED = {
+    metersPerSecond: 3,
+    degreesPerSecond: 120,
+};
+function clampAxis(v) {
+    return Math.max(-1, Math.min(1, v));
+}
+/** Normalizes to (-180, 180], the same range a long play session's
+ *  accumulated turning would otherwise drift outside of. */
+function normalizeDeg(deg) {
+    return ((((deg + 180) % 360) + 360) % 360) - 180;
+}
+/**
+ * One frame's movement: turn first, then move along the *new* facing — the
+ * way a person actually walks while turning, and the only order that makes
+ * "hold forward and turn" curve rather than move in a straight line then
+ * snap direction.
+ *
+ * Uses the exact bearing convention `unplugged.ts` (music_lib) already
+ * established: `dx = distance * sin(bearingRad)`, `dz = distance *
+ * cos(bearingRad)`, `facingDeg` clockwise-positive from `+z`. Strafe moves
+ * perpendicular to facing, 90° clockwise (right).
+ */
+export function stepListener(listener, input, deltaSeconds, speed = DEFAULT_MOVEMENT_SPEED) {
+    const forward = clampAxis(input.forward);
+    const strafe = clampAxis(input.strafe);
+    const turn = clampAxis(input.turn);
+    const facingDeg = normalizeDeg(listener.facingDeg + turn * speed.degreesPerSecond * deltaSeconds);
+    const facingRad = (facingDeg * Math.PI) / 180;
+    const strafeRad = facingRad + Math.PI / 2;
+    const forwardDistance = forward * speed.metersPerSecond * deltaSeconds;
+    const strafeDistance = strafe * speed.metersPerSecond * deltaSeconds;
+    return {
+        x: listener.x +
+            forwardDistance * Math.sin(facingRad) +
+            strafeDistance * Math.sin(strafeRad),
+        z: listener.z +
+            forwardDistance * Math.cos(facingRad) +
+            strafeDistance * Math.cos(strafeRad),
+        facingDeg,
+    };
+}
+//# sourceMappingURL=movement.js.map

package/dist/movement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"movement.js","sourceRoot":"","sources":["../src/movement.ts"],"names":[],"mappings":"AA2BA,MAAM,CAAC,MAAM,sBAAsB,GAAkB;IACnD,eAAe,EAAE,CAAC;IAClB,gBAAgB,EAAE,GAAG;CACtB,CAAC;AAEF,SAAS,SAAS,CAAC,CAAS;IAC1B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACtC,CAAC;AAED;4DAC4D;AAC5D,SAAS,YAAY,CAAC,GAAW;IAC/B,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;AACnD,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAC1B,QAA2B,EAC3B,KAAoB,EACpB,YAAoB,EACpB,QAAuB,sBAAsB;IAE7C,MAAM,OAAO,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACzC,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACvC,MAAM,IAAI,GAAG,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAEnC,MAAM,SAAS,GAAG,YAAY,CAC5B,QAAQ,CAAC,SAAS,GAAG,IAAI,GAAG,KAAK,CAAC,gBAAgB,GAAG,YAAY,CAClE,CAAC;IACF,MAAM,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC;IAC9C,MAAM,SAAS,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;IAE1C,MAAM,eAAe,GAAG,OAAO,GAAG,KAAK,CAAC,eAAe,GAAG,YAAY,CAAC;IACvE,MAAM,cAAc,GAAG,MAAM,GAAG,KAAK,CAAC,eAAe,GAAG,YAAY,CAAC;IAErE,OAAO;QACL,CAAC,EACC,QAAQ,CAAC,CAAC;YACV,eAAe,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC;YACrC,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC;QACtC,CAAC,EACC,QAAQ,CAAC,CAAC;YACV,eAAe,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC;YACrC,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC;QACtC,SAAS;KACV,CAAC;AACJ,CAAC"}

package/dist/scene.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Composes a `Score` and its Unplugged arrangement into everything a
+ * platform package needs to render one frame: each instrument's geometry
+ * and world transform, and the camera transform for the listener. Called
+ * once per relevant render/tick — a platform's `SpatialCanvas` becomes
+ * close to a plain `.map()` over `instruments` plus one camera assignment.
+ *
+ * ## Handedness
+ *
+ * The arrangement convention (`unplugged.ts`, the map overlay, the audio
+ * pan) is: +z is straight ahead of the listener's default facing and **+x
+ * is the listener's right**. That is a left-handed frame. three.js is
+ * right-handed — facing +z with +y up puts +x on the *left* — so rendering
+ * arrangement coordinates as-is produced a mirror image: an instrument
+ * panned right appeared on the left, turning left turned the camera right,
+ * and a violin held on the left shoulder rendered on the performer's
+ * right. This module is the one place the two meet, so it mirrors x here:
+ * positions, geometry (see `buildInstrumentGeometry`), and the sign of
+ * every rotation about y and z. Nothing upstream has to know.
+ */
+import type { BufferGeometry } from 'three';
+import type { Score } from '@sudobility/music_types';
+export type Vec3Tuple = readonly [number, number, number];
+export interface SpatialInstrument {
+    readonly trackId: string;
+    readonly geometry: readonly BufferGeometry[];
+    readonly position: Vec3Tuple;
+    readonly rotation: Vec3Tuple;
+    readonly scale: number;
+    readonly lit: boolean;
+    /** The track's own colour (see `colors.ts`), dimmed while it rests. */
+    readonly color: string;
+    /** The same colour at full strength — what to draw while it sounds. */
+    readonly litColor: string;
+}
+export interface SpatialCamera {
+    readonly position: Vec3Tuple;
+    readonly rotation: Vec3Tuple;
+}
+export interface SpatialScene {
+    readonly instruments: readonly SpatialInstrument[];
+    readonly camera: SpatialCamera;
+}
+export declare function buildScene(score: Pick<Score, 'tracks' | 'unplugged'>, soundingTrackIds: ReadonlySet<string>): SpatialScene;
+//# sourceMappingURL=scene.d.ts.map

package/dist/scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../src/scene.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAK5C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAIrD,MAAM,MAAM,SAAS,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAE1D,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,CAAC;IAC7C,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,uEAAuE;IACvE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,uEAAuE;IACvE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;CAC9B;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,WAAW,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACnD,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;CAChC;AAqBD,wBAAgB,UAAU,CACxB,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,QAAQ,GAAG,WAAW,CAAC,EAC1C,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAC,GACpC,YAAY,CAiDd"}

package/dist/scene.js

@@ -0,0 +1,66 @@
+import { effectiveUnpluggedArrangement, trackSpatialModel, } from '@sudobility/music_types';
+import { buildInstrumentGeometry } from './geometry';
+import { trackColors } from './colors';
+/** Stage floor height every instrument's own pose offset is measured from. */
+const GROUND_Y = 0;
+/** A first-person listener's ear height above the floor. */
+const EAR_HEIGHT = 1.6;
+/**
+ * Every instrument on stage is yawed 180° from its authored rest
+ * orientation, so a model authored facing +z (toward its own audience)
+ * faces back toward the listener's default position — a stage convention
+ * (performers face the audience), applied uniformly rather than aimed
+ * per-instrument at wherever the listener currently stands.
+ */
+const AUDIENCE_YAW = Math.PI;
+function degToRad(deg) {
+    return (deg * Math.PI) / 180;
+}
+export function buildScene(score, soundingTrackIds) {
+    const arrangement = effectiveUnpluggedArrangement(score);
+    const colors = trackColors(score.tracks);
+    const instruments = score.tracks.map(track => {
+        const point = arrangement.tracks[track.id] ?? { x: 0, z: 0 };
+        const { model, pose } = trackSpatialModel(track);
+        const lit = soundingTrackIds.has(track.id);
+        const color = colors[track.id];
+        return {
+            trackId: track.id,
+            geometry: buildInstrumentGeometry(model),
+            // x mirrored — see the module doc.
+            position: [
+                -(point.x + pose.position[0]),
+                GROUND_Y + pose.position[1],
+                point.z + pose.position[2],
+            ],
+            // Mirroring x negates rotations about y and z and keeps those about
+            // x. Composing the instrument's own tilt with the stage yaw by adding
+            // the y components is an approximation, exact for the y-only stage
+            // yaw and the zero poses every authored model uses today (their
+            // poses are baked into the geometry).
+            rotation: [
+                degToRad(pose.rotationDeg[0]),
+                -(degToRad(pose.rotationDeg[1]) + AUDIENCE_YAW),
+                -degToRad(pose.rotationDeg[2]),
+            ],
+            scale: pose.scale,
+            lit,
+            color: color.base,
+            litColor: color.lit,
+        };
+    });
+    return {
+        instruments,
+        camera: {
+            position: [-arrangement.listener.x, EAR_HEIGHT, arrangement.listener.z],
+            // Three.js cameras look down their local -Z. With x mirrored, a
+            // facing of f degrees (clockwise-positive from +z in arrangement
+            // space) is a camera yaw of PI - f: PI looks toward +z, and turning
+            // left (f decreasing) turns the camera toward its own left. Pinned
+            // by scene.test.ts rather than left to visual inspection — the sign
+            // is exactly what was wrong before.
+            rotation: [0, Math.PI - degToRad(arrangement.listener.facingDeg), 0],
+        },
+    };
+}
+//# sourceMappingURL=scene.js.map

package/dist/scene.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene.js","sourceRoot":"","sources":["../src/scene.ts"],"names":[],"mappings":"AAqBA,OAAO,EACL,6BAA6B,EAC7B,iBAAiB,GAClB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AA2BvC,8EAA8E;AAC9E,MAAM,QAAQ,GAAG,CAAC,CAAC;AAEnB,4DAA4D;AAC5D,MAAM,UAAU,GAAG,GAAG,CAAC;AAEvB;;;;;;GAMG;AACH,MAAM,YAAY,GAAG,IAAI,CAAC,EAAE,CAAC;AAE7B,SAAS,QAAQ,CAAC,GAAW;IAC3B,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC;AAC/B,CAAC;AAED,MAAM,UAAU,UAAU,CACxB,KAA0C,EAC1C,gBAAqC;IAErC,MAAM,WAAW,GAAG,6BAA6B,CAAC,KAAK,CAAC,CAAC;IACzD,MAAM,MAAM,GAAG,WAAW,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAEzC,MAAM,WAAW,GAAwB,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;QAChE,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;QAC7D,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC;QACjD,MAAM,GAAG,GAAG,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC3C,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAE/B,OAAO;YACL,OAAO,EAAE,KAAK,CAAC,EAAE;YACjB,QAAQ,EAAE,uBAAuB,CAAC,KAAK,CAAC;YACxC,mCAAmC;YACnC,QAAQ,EAAE;gBACR,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC7B,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAC3B,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;aAC3B;YACD,oEAAoE;YACpE,sEAAsE;YACtE,mEAAmE;YACnE,gEAAgE;YAChE,sCAAsC;YACtC,QAAQ,EAAE;gBACR,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;gBAC7B,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC;gBAC/C,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;aAC/B;YACD,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,GAAG;YACH,KAAK,EAAE,KAAK,CAAC,IAAI;YACjB,QAAQ,EAAE,KAAK,CAAC,GAAG;SACpB,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,OAAO;QACL,WAAW;QACX,MAAM,EAAE;YACN,QAAQ,EAAE,CAAC,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,EAAE,UAAU,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC;YACvE,gEAAgE;YAChE,iEAAiE;YACjE,oEAAoE;YACpE,mEAAmE;YACnE,oEAAoE;YACpE,oCAAoC;YACpC,QAAQ,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,GAAG,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;SACrE;KACF,CAAC;AACJ,CAAC"}

package/dist/use-throttled-commit.d.ts

@@ -0,0 +1,11 @@
+export interface ThrottledCommit<T> {
+    /** The in-progress value — updates instantly on every `setValue`, back to `initial` after `commitNow`. */
+    readonly value: T;
+    /** Instant local update; the store commit is scheduled for the next frame. */
+    readonly setValue: (next: T) => void;
+    /** Forces a pending commit through synchronously — call on drag end, so
+     *  the final position is never lost to a frame that never arrives. */
+    readonly commitNow: () => void;
+}
+export declare function useThrottledCommit<T>(initial: T, commit: (value: T) => void): ThrottledCommit<T>;
+//# sourceMappingURL=use-throttled-commit.d.ts.map

package/dist/use-throttled-commit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-throttled-commit.d.ts","sourceRoot":"","sources":["../src/use-throttled-commit.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,0GAA0G;IAC1G,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IACrC;0EACsE;IACtE,QAAQ,CAAC,SAAS,EAAE,MAAM,IAAI,CAAC;CAChC;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GACzB,eAAe,CAAC,CAAC,CAAC,CAqCpB"}

package/dist/use-throttled-commit.js

@@ -0,0 +1,49 @@
+/**
+ * Instant local feedback + rAF-throttled store commits, with a guaranteed
+ * final synchronous commit — the drag-performance fix already built and
+ * verified for the 2D map. Turns out to have no DOM or RN dependency at
+ * all: `useState`/`useRef`/`useCallback` are core React, and
+ * `requestAnimationFrame` is standard on both web and RN (RN polyfills it)
+ * — so the hook itself, not just the pattern, is shared rather than
+ * reimplemented per platform.
+ *
+ * `value` is only ever the *in-progress* drag: it returns to `initial`
+ * once `commitNow` has handed the final value to the store, so a caller
+ * that renders `value ?? committed` follows the store again afterwards.
+ * Without that, a marker dragged once stayed pinned to its last dragged
+ * position for good and ignored every later store change — which is how
+ * the map overlay stopped following the keyboard after a single drag.
+ */
+import { useCallback, useRef, useState } from 'react';
+export function useThrottledCommit(initial, commit) {
+    const [value, setValueState] = useState(initial);
+    const pendingRef = useRef(null);
+    const frameRef = useRef(null);
+    const flush = useCallback(() => {
+        frameRef.current = null;
+        if (pendingRef.current) {
+            commit(pendingRef.current.value);
+            pendingRef.current = null;
+        }
+    }, [commit]);
+    const setValue = useCallback((next) => {
+        setValueState(next);
+        pendingRef.current = { value: next };
+        if (frameRef.current === null) {
+            frameRef.current = requestAnimationFrame(flush);
+        }
+    }, [flush]);
+    const commitNow = useCallback(() => {
+        if (frameRef.current !== null) {
+            cancelAnimationFrame(frameRef.current);
+            frameRef.current = null;
+        }
+        if (pendingRef.current) {
+            commit(pendingRef.current.value);
+            pendingRef.current = null;
+        }
+        setValueState(initial);
+    }, [commit, initial]);
+    return { value, setValue, commitNow };
+}
+//# sourceMappingURL=use-throttled-commit.js.map

package/dist/use-throttled-commit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-throttled-commit.js","sourceRoot":"","sources":["../src/use-throttled-commit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAYtD,MAAM,UAAU,kBAAkB,CAChC,OAAU,EACV,MAA0B;IAE1B,MAAM,CAAC,KAAK,EAAE,aAAa,CAAC,GAAG,QAAQ,CAAI,OAAO,CAAC,CAAC;IACpD,MAAM,UAAU,GAAG,MAAM,CAA+B,IAAI,CAAC,CAAC;IAC9D,MAAM,QAAQ,GAAG,MAAM,CAAgB,IAAI,CAAC,CAAC;IAE7C,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE;QAC7B,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC;QACxB,IAAI,UAAU,CAAC,OAAO,EAAE,CAAC;YACvB,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACjC,UAAU,CAAC,OAAO,GAAG,IAAI,CAAC;QAC5B,CAAC;IACH,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;IAEb,MAAM,QAAQ,GAAG,WAAW,CAC1B,CAAC,IAAO,EAAE,EAAE;QACV,aAAa,CAAC,IAAI,CAAC,CAAC;QACpB,UAAU,CAAC,OAAO,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QACrC,IAAI,QAAQ,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YAC9B,QAAQ,CAAC,OAAO,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;IACH,CAAC,EACD,CAAC,KAAK,CAAC,CACR,CAAC;IAEF,MAAM,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE;QACjC,IAAI,QAAQ,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YAC9B,oBAAoB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YACvC,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC;QAC1B,CAAC;QACD,IAAI,UAAU,CAAC,OAAO,EAAE,CAAC;YACvB,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACjC,UAAU,CAAC,OAAO,GAAG,IAAI,CAAC;QAC5B,CAAC;QACD,aAAa,CAAC,OAAO,CAAC,CAAC;IACzB,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAEtB,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;AACxC,CAAC"}

package/dist/wander.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Random walking: the listener strolls from one *playing* instrument to
+ * another on its own — picks one that is sounding (not the one it has just
+ * visited, when there is a choice), walks up to it and stops a pace or two
+ * in front, stands there facing it for a while, then picks another. If the
+ * instrument it is heading for or standing at falls silent, it turns to
+ * another that is playing; if nothing is playing, it stands where it is.
+ *
+ * "Playing" carries a short memory: a part rests for a beat between notes,
+ * and a wanderer that gave up on every rest would never arrive anywhere.
+ * An instrument counts as playing for `RECENT` seconds after it last
+ * sounded.
+ *
+ * Never far from the group: every stop is within the instruments' own
+ * spread plus a margin, and never inside one.
+ *
+ * Pure and frame-rate independent like `stepListener`, which it drives:
+ * the platform package owns the frame loop and the random source, this
+ * owns the behaviour, so it can be tested with a fixed `rng`.
+ */
+import type { UnpluggedListener, UnpluggedPoint } from '@sudobility/music_types';
+import { type MovementSpeed } from './movement';
+export interface WanderInstrument {
+    readonly id: string;
+    readonly point: UnpluggedPoint;
+    /** Has an active note right now. */
+    readonly sounding: boolean;
+}
+export interface WanderState {
+    /** Where the listener is walking to, or null while standing. */
+    readonly target: UnpluggedPoint | null;
+    /** The instrument being visited — faced while standing, not chosen twice running. */
+    readonly anchorId: string | null;
+    /** Elapsed-time value at which standing ends and a new target is picked. */
+    readonly dwellUntil: number;
+    /** Seconds of wandering so far — the clock `dwellUntil` is measured on. */
+    readonly elapsed: number;
+    /** When each instrument last sounded, on the same clock. */
+    readonly heard: Readonly<Record<string, number>>;
+}
+export declare const IDLE_WANDER: WanderState;
+export interface WanderOptions {
+    /** Walking pace. Default: a slow stroll. */
+    readonly speed?: MovementSpeed;
+    /** How long to stand at each instrument, seconds, [min, max]. */
+    readonly dwell?: readonly [number, number];
+    /** Closest the listener will stand to an instrument, meters. */
+    readonly clearance?: number;
+    /** How far beyond the instruments' own spread the listener may go, meters. */
+    readonly margin?: number;
+    /** Uniform random in [0, 1). Default `Math.random`; tests pass their own. */
+    readonly rng?: () => number;
+}
+export declare const WANDER_SPEED: MovementSpeed;
+/** How long after its last note an instrument still counts as playing. */
+export declare const RECENT = 2.5;
+/**
+ * The next instrument to visit, from `candidates`, and where to stand for
+ * it: a spot a pace or two (`clearance` + 0.3–0.9 m) in front of it on the
+ * side the listener is coming from, so the walk heads *toward* it. Never
+ * the instrument just visited when there is a choice; never inside any
+ * other instrument's clearance (`all`) or outside the group's reach —
+ * after ten tries the stand-off point on the direct line is taken as is.
+ */
+export declare function pickWanderTarget(candidates: readonly WanderInstrument[], all: readonly WanderInstrument[], from: UnpluggedPoint, previousId: string | null, rng: () => number, clearance?: number, margin?: number): {
+    readonly target: UnpluggedPoint;
+    readonly anchorId: string;
+};
+/**
+ * One frame of wandering. Standing: turns to face the instrument it is
+ * visiting and waits out the dwell, then picks the next playing one.
+ * Walking: turns toward the target at a rate proportional to how far off
+ * it is (so the turn eases out), and moves forward only once roughly
+ * facing it, easing in as it lines up and easing out as it arrives.
+ * Arrival starts the next dwell. Whichever it is doing, an anchor that
+ * has fallen silent is dropped for a playing one at once; with nothing
+ * playing it stands still.
+ */
+export declare function stepWander(listener: UnpluggedListener, state: WanderState, instruments: readonly WanderInstrument[], deltaSeconds: number, options?: WanderOptions): {
+    readonly listener: UnpluggedListener;
+    readonly state: WanderState;
+};
+//# sourceMappingURL=wander.d.ts.map

package/dist/wander.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wander.d.ts","sourceRoot":"","sources":["../src/wander.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACf,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAgB,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAE9D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,oCAAoC;IACpC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,WAAW;IAC1B,gEAAgE;IAChE,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC;IACvC,qFAAqF;IACrF,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,4EAA4E;IAC5E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAClD;AAED,eAAO,MAAM,WAAW,EAAE,WAMzB,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B,4CAA4C;IAC5C,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;IAC/B,iEAAiE;IACjE,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3C,gEAAgE;IAChE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,6EAA6E;IAC7E,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC7B;AAED,eAAO,MAAM,YAAY,EAAE,aAG1B,CAAC;AACF,0EAA0E;AAC1E,eAAO,MAAM,MAAM,MAAM,CAAC;AA4C1B;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,SAAS,gBAAgB,EAAE,EACvC,GAAG,EAAE,SAAS,gBAAgB,EAAE,EAChC,IAAI,EAAE,cAAc,EACpB,UAAU,EAAE,MAAM,GAAG,IAAI,EACzB,GAAG,EAAE,MAAM,MAAM,EACjB,SAAS,SAAoB,EAC7B,MAAM,SAAiB,GACtB;IAAE,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAiChE;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACxB,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,WAAW,EAClB,WAAW,EAAE,SAAS,gBAAgB,EAAE,EACxC,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,aAAkB,GAC1B;IAAE,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAA;CAAE,CAyFvE"}

package/dist/wander.js

@@ -0,0 +1,153 @@
+import { stepListener } from './movement';
+export const IDLE_WANDER = {
+    target: null,
+    anchorId: null,
+    dwellUntil: 0,
+    elapsed: 0,
+    heard: {},
+};
+export const WANDER_SPEED = {
+    metersPerSecond: 0.6,
+    degreesPerSecond: 45,
+};
+/** How long after its last note an instrument still counts as playing. */
+export const RECENT = 2.5;
+const DEFAULT_DWELL = [4, 9];
+const DEFAULT_CLEARANCE = 0.9;
+const DEFAULT_MARGIN = 1.5;
+/** Considered arrived within this distance of the target, meters. */
+const ARRIVE = 0.2;
+/** Close enough to facing: stop turning, in degrees. */
+const FACING_DEADBAND = 0.25;
+function normalizeDeg(deg) {
+    return ((((deg + 180) % 360) + 360) % 360) - 180;
+}
+function centroid(points) {
+    let x = 0;
+    let z = 0;
+    for (const p of points) {
+        x += p.x;
+        z += p.z;
+    }
+    return { x: x / points.length, z: z / points.length };
+}
+function bearingDeg(from, to) {
+    return (Math.atan2(to.x - from.x, to.z - from.z) * 180) / Math.PI;
+}
+function turnToward(listener, point, deltaSeconds, speed) {
+    const off = normalizeDeg(bearingDeg(listener, point) - listener.facingDeg);
+    if (Math.abs(off) < FACING_DEADBAND)
+        return { listener, off };
+    const turned = stepListener(listener, { forward: 0, strafe: 0, turn: Math.max(-1, Math.min(1, off / 25)) }, deltaSeconds, speed);
+    return { listener: turned, off };
+}
+/**
+ * The next instrument to visit, from `candidates`, and where to stand for
+ * it: a spot a pace or two (`clearance` + 0.3–0.9 m) in front of it on the
+ * side the listener is coming from, so the walk heads *toward* it. Never
+ * the instrument just visited when there is a choice; never inside any
+ * other instrument's clearance (`all`) or outside the group's reach —
+ * after ten tries the stand-off point on the direct line is taken as is.
+ */
+export function pickWanderTarget(candidates, all, from, previousId, rng, clearance = DEFAULT_CLEARANCE, margin = DEFAULT_MARGIN) {
+    const points = all.map(i => i.point);
+    const center = centroid(points);
+    const reach = Math.max(...points.map(p => Math.hypot(p.x - center.x, p.z - center.z))) +
+        margin;
+    const choices = candidates.length > 1 && previousId
+        ? candidates.filter(i => i.id !== previousId)
+        : candidates;
+    const anchor = choices[Math.floor(rng() * choices.length)];
+    const standOff = clearance + 0.3 + rng() * 0.6;
+    const direct = bearingDeg(anchor.point, from);
+    let fallback = null;
+    for (let attempt = 0; attempt < 10; attempt++) {
+        // Straight toward it first; if that spot is taken, fan out around it.
+        const spreadDeg = attempt === 0 ? 0 : (rng() - 0.5) * 120;
+        const a = ((direct + spreadDeg) * Math.PI) / 180;
+        const candidate = {
+            x: anchor.point.x + Math.sin(a) * standOff,
+            z: anchor.point.z + Math.cos(a) * standOff,
+        };
+        fallback ?? (fallback = candidate);
+        const tooClose = all.some(i => i.id !== anchor.id &&
+            Math.hypot(i.point.x - candidate.x, i.point.z - candidate.z) < clearance);
+        const tooFar = Math.hypot(candidate.x - center.x, candidate.z - center.z) > reach;
+        if (!tooClose && !tooFar)
+            return { target: candidate, anchorId: anchor.id };
+    }
+    return { target: fallback, anchorId: anchor.id };
+}
+/**
+ * One frame of wandering. Standing: turns to face the instrument it is
+ * visiting and waits out the dwell, then picks the next playing one.
+ * Walking: turns toward the target at a rate proportional to how far off
+ * it is (so the turn eases out), and moves forward only once roughly
+ * facing it, easing in as it lines up and easing out as it arrives.
+ * Arrival starts the next dwell. Whichever it is doing, an anchor that
+ * has fallen silent is dropped for a playing one at once; with nothing
+ * playing it stands still.
+ */
+export function stepWander(listener, state, instruments, deltaSeconds, options = {}) {
+    const rng = options.rng ?? Math.random;
+    const speed = options.speed ?? WANDER_SPEED;
+    const dwell = options.dwell ?? DEFAULT_DWELL;
+    const elapsed = state.elapsed + deltaSeconds;
+    // Remember what sounded, and decide what counts as playing.
+    let heard = state.heard;
+    for (const i of instruments) {
+        if (i.sounding && heard[i.id] !== elapsed)
+            heard = { ...heard, [i.id]: elapsed };
+    }
+    const playing = instruments.filter(i => i.sounding ||
+        (heard[i.id] !== undefined && elapsed - heard[i.id] <= RECENT));
+    const idle = (extra = {}) => ({
+        ...state,
+        ...extra,
+        elapsed,
+        heard,
+    });
+    if (instruments.length === 0 || playing.length === 0) {
+        // Nothing to walk toward. Forget any visit so the next note starts one.
+        return {
+            listener,
+            state: idle({ target: null, anchorId: null, dwellUntil: 0 }),
+        };
+    }
+    const anchorPlaying = state.anchorId !== null && playing.some(i => i.id === state.anchorId);
+    let target = anchorPlaying ? state.target : null;
+    let anchorId = anchorPlaying ? state.anchorId : null;
+    // A silent anchor is dropped: no dwell to wait out, pick afresh now.
+    const dwellUntil = anchorPlaying ? state.dwellUntil : 0;
+    if (!target) {
+        if (elapsed < dwellUntil && anchorId) {
+            // Standing: settle on facing the instrument being visited.
+            const anchor = instruments.find(i => i.id === anchorId);
+            const { listener: turned } = turnToward(listener, anchor.point, deltaSeconds, speed);
+            return {
+                listener: turned,
+                state: idle({ target: null, anchorId, dwellUntil }),
+            };
+        }
+        const pick = pickWanderTarget(playing, instruments, listener, state.anchorId, rng, options.clearance, options.margin);
+        target = pick.target;
+        anchorId = pick.anchorId;
+    }
+    const dx = target.x - listener.x;
+    const dz = target.z - listener.z;
+    const distance = Math.hypot(dx, dz);
+    if (distance < ARRIVE) {
+        const wait = dwell[0] + rng() * (dwell[1] - dwell[0]);
+        return {
+            listener,
+            state: idle({ target: null, anchorId, dwellUntil: elapsed + wait }),
+        };
+    }
+    const off = normalizeDeg(bearingDeg(listener, target) - listener.facingDeg);
+    const turn = Math.max(-1, Math.min(1, off / 25));
+    const facingFactor = Math.max(0, 1 - Math.abs(off) / 60);
+    const forward = Math.min(1, distance / 1.2) * facingFactor;
+    const next = stepListener(listener, { forward, strafe: 0, turn }, deltaSeconds, speed);
+    return { listener: next, state: idle({ target, anchorId, dwellUntil }) };
+}
+//# sourceMappingURL=wander.js.map

package/dist/wander.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wander.js","sourceRoot":"","sources":["../src/wander.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAE,YAAY,EAAsB,MAAM,YAAY,CAAC;AAsB9D,MAAM,CAAC,MAAM,WAAW,GAAgB;IACtC,MAAM,EAAE,IAAI;IACZ,QAAQ,EAAE,IAAI;IACd,UAAU,EAAE,CAAC;IACb,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,EAAE;CACV,CAAC;AAeF,MAAM,CAAC,MAAM,YAAY,GAAkB;IACzC,eAAe,EAAE,GAAG;IACpB,gBAAgB,EAAE,EAAE;CACrB,CAAC;AACF,0EAA0E;AAC1E,MAAM,CAAC,MAAM,MAAM,GAAG,GAAG,CAAC;AAC1B,MAAM,aAAa,GAA8B,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACxD,MAAM,iBAAiB,GAAG,GAAG,CAAC;AAC9B,MAAM,cAAc,GAAG,GAAG,CAAC;AAC3B,qEAAqE;AACrE,MAAM,MAAM,GAAG,GAAG,CAAC;AACnB,wDAAwD;AACxD,MAAM,eAAe,GAAG,IAAI,CAAC;AAE7B,SAAS,YAAY,CAAC,GAAW;IAC/B,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;AACnD,CAAC;AAED,SAAS,QAAQ,CAAC,MAAiC;IACjD,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACT,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACX,CAAC;IACD,OAAO,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;AACxD,CAAC;AAED,SAAS,UAAU,CAAC,IAAoB,EAAE,EAAkB;IAC1D,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC;AACpE,CAAC;AAED,SAAS,UAAU,CACjB,QAA2B,EAC3B,KAAqB,EACrB,YAAoB,EACpB,KAAoB;IAEpB,MAAM,GAAG,GAAG,YAAY,CAAC,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC3E,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,eAAe;QAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC;IAC9D,MAAM,MAAM,GAAG,YAAY,CACzB,QAAQ,EACR,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,GAAG,EAAE,CAAC,CAAC,EAAE,EACpE,YAAY,EACZ,KAAK,CACN,CAAC;IACF,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;AACnC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAC9B,UAAuC,EACvC,GAAgC,EAChC,IAAoB,EACpB,UAAyB,EACzB,GAAiB,EACjB,SAAS,GAAG,iBAAiB,EAC7B,MAAM,GAAG,cAAc;IAEvB,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IACrC,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IAChC,MAAM,KAAK,GACT,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACxE,MAAM,CAAC;IACT,MAAM,OAAO,GACX,UAAU,CAAC,MAAM,GAAG,CAAC,IAAI,UAAU;QACjC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,UAAU,CAAC;QAC7C,CAAC,CAAC,UAAU,CAAC;IACjB,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IAC3D,MAAM,QAAQ,GAAG,SAAS,GAAG,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,CAAC;IAC/C,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC9C,IAAI,QAAQ,GAA0B,IAAI,CAAC;IAC3C,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,EAAE,EAAE,OAAO,EAAE,EAAE,CAAC;QAC9C,sEAAsE;QACtE,MAAM,SAAS,GAAG,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;QAC1D,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC;QACjD,MAAM,SAAS,GAAG;YAChB,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,QAAQ;YAC1C,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,QAAQ;SAC3C,CAAC;QACF,QAAQ,KAAR,QAAQ,GAAK,SAAS,EAAC;QACvB,MAAM,QAAQ,GAAG,GAAG,CAAC,IAAI,CACvB,CAAC,CAAC,EAAE,CACF,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,EAAE;YAClB,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAC3E,CAAC;QACF,MAAM,MAAM,GACV,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;QACrE,IAAI,CAAC,QAAQ,IAAI,CAAC,MAAM;YAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC;IAC9E,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,QAAS,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC;AACpD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,UAAU,CACxB,QAA2B,EAC3B,KAAkB,EAClB,WAAwC,EACxC,YAAoB,EACpB,UAAyB,EAAE;IAE3B,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC;IACvC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,YAAY,CAAC;IAC5C,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,aAAa,CAAC;IAC7C,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,GAAG,YAAY,CAAC;IAE7C,4DAA4D;IAC5D,IAAI,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IACxB,KAAK,MAAM,CAAC,IAAI,WAAW,EAAE,CAAC;QAC5B,IAAI,CAAC,CAAC,QAAQ,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO;YACvC,KAAK,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC;IAC1C,CAAC;IACD,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,CAChC,CAAC,CAAC,EAAE,CACF,CAAC,CAAC,QAAQ;QACV,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,SAAS,IAAI,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,MAAM,CAAC,CACjE,CAAC;IACF,MAAM,IAAI,GAAG,CAAC,QAA8B,EAAE,EAAe,EAAE,CAAC,CAAC;QAC/D,GAAG,KAAK;QACR,GAAG,KAAK;QACR,OAAO;QACP,KAAK;KACN,CAAC,CAAC;IAEH,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACrD,wEAAwE;QACxE,OAAO;YACL,QAAQ;YACR,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC;SAC7D,CAAC;IACJ,CAAC;IAED,MAAM,aAAa,GACjB,KAAK,CAAC,QAAQ,KAAK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,CAAC,QAAQ,CAAC,CAAC;IACxE,IAAI,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;IACjD,IAAI,QAAQ,GAAG,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC;IACrD,qEAAqE;IACrE,MAAM,UAAU,GAAG,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;IAExD,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,IAAI,OAAO,GAAG,UAAU,IAAI,QAAQ,EAAE,CAAC;YACrC,2DAA2D;YAC3D,MAAM,MAAM,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,QAAQ,CAAE,CAAC;YACzD,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CACrC,QAAQ,EACR,MAAM,CAAC,KAAK,EACZ,YAAY,EACZ,KAAK,CACN,CAAC;YACF,OAAO;gBACL,QAAQ,EAAE,MAAM;gBAChB,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC;aACpD,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,GAAG,gBAAgB,CAC3B,OAAO,EACP,WAAW,EACX,QAAQ,EACR,KAAK,CAAC,QAAQ,EACd,GAAG,EACH,OAAO,CAAC,SAAS,EACjB,OAAO,CAAC,MAAM,CACf,CAAC;QACF,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QACrB,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;IAC3B,CAAC;IAED,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;IACjC,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;IACjC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;IACpC,IAAI,QAAQ,GAAG,MAAM,EAAE,CAAC;QACtB,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QACtD,OAAO;YACL,QAAQ;YACR,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,GAAG,IAAI,EAAE,CAAC;SACpE,CAAC;IACJ,CAAC;IAED,MAAM,GAAG,GAAG,YAAY,CAAC,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC5E,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC;IACjD,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC;IACzD,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,GAAG,GAAG,CAAC,GAAG,YAAY,CAAC;IAC3D,MAAM,IAAI,GAAG,YAAY,CACvB,QAAQ,EACR,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,EAC5B,YAAY,EACZ,KAAK,CACN,CAAC;IACF,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC;AAC3E,CAAC"}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@sudobility/music_spatial_core",
+  "version": "0.0.2",
+  "description": "Platform-agnostic engine behind the Moosiac Spatial view: instrument geometry, scene composition, camera/listener math, movement, and map-overlay math shared by music_spatial and music_spatial_rn.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "react-native": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.esm.json",
+    "clean": "rimraf dist",
+    "test:unit": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "typecheck": "tsc --noEmit",
+    "verify": "bun run format:check && bun run typecheck && bun run lint && bun run test:unit && bun run build",
+    "prepublishOnly": "bun run clean && bun run verify"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "@sudobility/music_types": "^0.13.39",
+    "react": ">=18",
+    "three": "^0.160.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.38.0",
+    "@sudobility/music_types": "^0.13.39",
+    "@testing-library/react": "^16.0.0",
+    "@types/react": "^19.2.18",
+    "@types/react-dom": "^19.2.0",
+    "@types/three": "^0.186.0",
+    "@typescript-eslint/eslint-plugin": "^8.46.2",
+    "@typescript-eslint/parser": "^8.46.2",
+    "eslint": "^9.38.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "globals": "^16.4.0",
+    "jsdom": "^25.0.0",
+    "prettier": "^3.6.2",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "rimraf": "^6.0.1",
+    "three": "^0.186.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.15"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/johnqh/music_spatial_core.git"
+  },
+  "license": "BUSL-1.1"
+}