mochi-avatar 1.0.0

package/dist/characters/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The characters this package ships, as distinct from the engine that draws
+ * them. Everything under this directory carries the character licence in
+ * `LICENSE.md`; the engine around it is MIT.
+ */
+export { MOCHI } from './mochi.js';
+export { COLOURWAYS, mochiIn, type Colourway, type ColourwayName } from './colourways.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/characters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/characters/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/characters/index.js

@@ -0,0 +1,8 @@
+/**
+ * The characters this package ships, as distinct from the engine that draws
+ * them. Everything under this directory carries the character licence in
+ * `LICENSE.md`; the engine around it is MIT.
+ */
+export { MOCHI } from './mochi.js';
+export { COLOURWAYS, mochiIn } from './colourways.js';
+//# sourceMappingURL=index.js.map

package/dist/characters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/characters/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAsC,MAAM,iBAAiB,CAAA"}

package/dist/characters/mochi.d.ts

@@ -0,0 +1,19 @@
+import type { FaceSpec } from '../core/spec.js';
+/**
+ * Mochi.
+ *
+ * A soft green ovoid with a low face, measured against `assets/mochi-icon.png`
+ * rather than tuned by eye — `silhouette-vs-icon.test.ts` fails the build if the
+ * rendered profile drifts from that artwork at any 5% of her height.
+ *
+ * ## She is not MIT
+ *
+ * Everything else in this package is. This directory is not: see
+ * `LICENSE.md`. You may use her as she is, including in things you give away.
+ * You may not rebrand her, sell her, or present her as your own character.
+ *
+ * If you want a character of your own, that is what the format is for — start
+ * from `PLAIN`, move the numbers, and the result owes nothing to this file.
+ */
+export declare const MOCHI: FaceSpec;
+//# sourceMappingURL=mochi.d.ts.map

package/dist/characters/mochi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mochi.d.ts","sourceRoot":"","sources":["../../src/characters/mochi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE/C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,KAAK,EAAE,QAsDnB,CAAA"}

package/dist/characters/mochi.js

@@ -0,0 +1,66 @@
+/**
+ * Mochi.
+ *
+ * A soft green ovoid with a low face, measured against `assets/mochi-icon.png`
+ * rather than tuned by eye — `silhouette-vs-icon.test.ts` fails the build if the
+ * rendered profile drifts from that artwork at any 5% of her height.
+ *
+ * ## She is not MIT
+ *
+ * Everything else in this package is. This directory is not: see
+ * `LICENSE.md`. You may use her as she is, including in things you give away.
+ * You may not rebrand her, sell her, or present her as your own character.
+ *
+ * If you want a character of your own, that is what the format is for — start
+ * from `PLAIN`, move the numbers, and the result owes nothing to this file.
+ */
+export const MOCHI = {
+    size: 100,
+    bodyW: 100,
+    bodyH: 78,
+    waist: 0.295,
+    upperShoulder: 1.86,
+    lowerShoulder: 2.58,
+    gripX: 0.82,
+    gripY: 0.82,
+    eyeX: 0.3,
+    eyeY: 0.46,
+    // 4, not the 5 these were tuned at. Two separate reductions land on the eyes
+    // -- the body itself is now drawn at 80% (see rig/mochi.ts) and these are 80%
+    // of what they were -- so in absolute pixels they end up near 64% of the
+    // first version. That compounding is intended, not an accident of two edits:
+    // the eyes read as too heavy for her at BOTH sizes.
+    eyeHw: 4,
+    eyeUpper: 4,
+    eyeLower: 4,
+    eyeTilt: 0,
+    eyeRound: 2,
+    eyeGlint: 1.4,
+    gazeTravel: 0.42,
+    mouthY: 0.24,
+    mouthHw: 9,
+    mouthUpper: 0,
+    mouthLower: 3.2,
+    mouthRound: 2,
+    mouthOpenGain: 9,
+    cheekAlpha: 0.34,
+    cheekX: 0.62,
+    cheekY: 0.33,
+    cheekR: 12,
+    // 0.024, down from 0.045, and the two numbers are not comparable: 0.045 was a
+    // HALF-amplitude either side of rest, so the body swung 0.09 peak to peak --
+    // 9% of her height and 9% of her width, on a 94 x 73px body. This is the
+    // whole excursion, in one direction, from a resting shape she now returns to.
+    breathAmp: 0.024,
+    breathMs: 3400,
+    stiffness: 190,
+    damping: 20,
+    shadowX: 0.059,
+    shadowY: 0.102,
+    colBody: '#8ec8a8',
+    colShadow: '#7dbd99',
+    colInk: '#24463a',
+    colCheek: '#ef8f86',
+    colGlint: '#ffffff',
+};
+//# sourceMappingURL=mochi.js.map

package/dist/characters/mochi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mochi.js","sourceRoot":"","sources":["../../src/characters/mochi.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,KAAK,GAAa;IAC7B,IAAI,EAAE,GAAG;IACT,KAAK,EAAE,GAAG;IACV,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,KAAK;IACZ,aAAa,EAAE,IAAI;IACnB,aAAa,EAAE,IAAI;IACnB,KAAK,EAAE,IAAI;IACX,KAAK,EAAE,IAAI;IAEX,IAAI,EAAE,GAAG;IACT,IAAI,EAAE,IAAI;IACV,6EAA6E;IAC7E,8EAA8E;IAC9E,yEAAyE;IACzE,6EAA6E;IAC7E,oDAAoD;IACpD,KAAK,EAAE,CAAC;IACR,QAAQ,EAAE,CAAC;IACX,QAAQ,EAAE,CAAC;IACX,OAAO,EAAE,CAAC;IACV,QAAQ,EAAE,CAAC;IACX,QAAQ,EAAE,GAAG;IACb,UAAU,EAAE,IAAI;IAEhB,MAAM,EAAE,IAAI;IACZ,OAAO,EAAE,CAAC;IACV,UAAU,EAAE,CAAC;IACb,UAAU,EAAE,GAAG;IACf,UAAU,EAAE,CAAC;IACb,aAAa,EAAE,CAAC;IAEhB,UAAU,EAAE,IAAI;IAChB,MAAM,EAAE,IAAI;IACZ,MAAM,EAAE,IAAI;IACZ,MAAM,EAAE,EAAE;IAEV,8EAA8E;IAC9E,6EAA6E;IAC7E,yEAAyE;IACzE,8EAA8E;IAC9E,SAAS,EAAE,KAAK;IAChB,QAAQ,EAAE,IAAI;IACd,SAAS,EAAE,GAAG;IACd,OAAO,EAAE,EAAE;IAEX,OAAO,EAAE,KAAK;IACd,OAAO,EAAE,KAAK;IAEd,OAAO,EAAE,SAAS;IAClB,SAAS,EAAE,SAAS;IACpB,MAAM,EAAE,SAAS;IACjB,QAAQ,EAAE,SAAS;IACnB,QAAQ,EAAE,SAAS;CACpB,CAAA"}

package/dist/core/colour.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Reading a hex colour, which is the only interpretation this engine does.
+ *
+ * Inlined rather than imported. In the host application this lived beside the
+ * accent-colour machinery, which also knows about WCAG luminance, CSS custom
+ * properties and a theme — none of which an engine that fills two flat tones
+ * has any business depending on. Twenty lines is cheaper than the coupling.
+ *
+ * The forms accepted here are exactly the forms `parseFaceSpec` accepts, and
+ * that is not a coincidence: a colour that passes validation must be one this
+ * can read, or a face loads and then fails to paint. That equivalence used to
+ * be approximate — this trimmed its input and the validator did not, so
+ * `' #abc '` was readable here and rejected there. It does not trim any more.
+ *
+ * **Alpha is discarded.** `#rgba` and `#rrggbbaa` parse, and their alpha
+ * channel is dropped: the return type is RGB, and the one caller wants the
+ * channels so it can build its own transparent stop. Named for what it returns.
+ */
+export interface Rgb {
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+}
+export declare function parseHexRgb(hex: string): Rgb | null;
+//# sourceMappingURL=colour.d.ts.map

package/dist/core/colour.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colour.d.ts","sourceRoot":"","sources":["../../src/core/colour.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,MAAM,WAAW,GAAG;IAClB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,IAAI,CAenD"}

package/dist/core/colour.js

@@ -0,0 +1,37 @@
+/**
+ * Reading a hex colour, which is the only interpretation this engine does.
+ *
+ * Inlined rather than imported. In the host application this lived beside the
+ * accent-colour machinery, which also knows about WCAG luminance, CSS custom
+ * properties and a theme — none of which an engine that fills two flat tones
+ * has any business depending on. Twenty lines is cheaper than the coupling.
+ *
+ * The forms accepted here are exactly the forms `parseFaceSpec` accepts, and
+ * that is not a coincidence: a colour that passes validation must be one this
+ * can read, or a face loads and then fails to paint. That equivalence used to
+ * be approximate — this trimmed its input and the validator did not, so
+ * `' #abc '` was readable here and rejected there. It does not trim any more.
+ *
+ * **Alpha is discarded.** `#rgba` and `#rrggbbaa` parse, and their alpha
+ * channel is dropped: the return type is RGB, and the one caller wants the
+ * channels so it can build its own transparent stop. Named for what it returns.
+ */
+import { HEX_COLOUR } from './spec.js';
+export function parseHexRgb(hex) {
+    const text = hex;
+    // Checked BEFORE parsing, not after. `red` is three characters, so it took
+    // the shorthand path and `parseInt('rr', 16)` handed back NaN channels --
+    // a colour object that passes every null check and paints nothing.
+    if (!HEX_COLOUR.test(text))
+        return null;
+    const body = text.slice(1);
+    const expand = (index) => Number.parseInt(body.charAt(index).repeat(2), 16);
+    if (body.length <= 4) {
+        return { r: expand(0), g: expand(1), b: expand(2) };
+    }
+    // No NaN check and no trailing `return null`: the regex admits exactly the
+    // four lengths handled above and below, so both were unreachable.
+    const value = Number.parseInt(body.slice(0, 6), 16);
+    return { r: (value >> 16) & 255, g: (value >> 8) & 255, b: value & 255 };
+}
+//# sourceMappingURL=colour.js.map

package/dist/core/colour.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"colour.js","sourceRoot":"","sources":["../../src/core/colour.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAQtC,MAAM,UAAU,WAAW,CAAC,GAAW;IACrC,MAAM,IAAI,GAAG,GAAG,CAAA;IAChB,2EAA2E;IAC3E,0EAA0E;IAC1E,mEAAmE;IACnE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAA;IACvC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IAC1B,MAAM,MAAM,GAAG,CAAC,KAAa,EAAU,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;IAC3F,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;QACrB,OAAO,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAA;IACrD,CAAC;IACD,2EAA2E;IAC3E,kEAAkE;IAClE,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;IACnD,OAAO,EAAE,CAAC,EAAE,CAAC,KAAK,IAAI,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,KAAK,GAAG,GAAG,EAAE,CAAA;AAC1E,CAAC"}

package/dist/core/envelope.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Audio loudness to mouth openness.
+ *
+ * The coarse path, and behind cloud speech-to-speech the ONLY path: an audio
+ * stream carries no phoneme timings, so this is not a shortcut here -- it is
+ * the whole option.
+ *
+ * ## Why this is relative rather than a fixed threshold
+ *
+ * mochi's version gated at an absolute 0.01 with a gain of 12. Measured against
+ * a live gpt-realtime session (2026-08-11) those
+ * constants turn out to WORK -- and to work for a reason nobody wrote down, on
+ * a scale nobody had checked:
+ *
+ *   - the gap floor is 8.4e-5 median, 8.1e-4 at p99. So the gate cleared it by
+ *     roughly 12x. Comfortable, but by luck rather than by design.
+ *   - speech sits at 0.057 median and 0.137 at p90, while gain 12 saturates at
+ *     0.093. So more than a tenth of speech frames were pinned fully open --
+ *     a mouth hitting its stop instead of modulating.
+ *
+ * Both numbers belong to one voice on one provider. A different voice, a
+ * provider change, or anyone adding a volume `GainNode` upstream moves them,
+ * and nothing in an absolute design would notice: her mouth would simply hang
+ * open, or stop moving, with nothing to say why.
+ *
+ * So openness is expressed against the signal's OWN recent floor and peak. The
+ * headline property is scale invariance -- multiply the input by any constant
+ * and the output is unchanged -- which is what makes it survive all three of
+ * those changes without being retuned.
+ *
+ * ## What the floor is NOT
+ *
+ * It is not room tone. There is no microphone on this path. Between phrases the
+ * stream carries codec comfort noise at ~1e-4, and it does NOT return to
+ * digital silence once media is flowing (measured: exact zero appears only
+ * before the first audio arrives). So a gate is genuinely required -- a zero
+ * gate leaves the mouth twitching on noise -- but it needs to sit just above a
+ * floor three orders of magnitude below speech, not at a hand-picked constant.
+ */
+export interface EnvelopeSettings {
+    /**
+     * Gate, as a multiple of the tracked noise floor.
+     *
+     * 12 puts it at ~1e-3 against the measured floor, just clear of the loudest
+     * gap frame at 8.9e-4, and still 50x below median speech.
+     */
+    readonly floorMargin: number;
+    /** How much of the reference peak survives one second of quiet. */
+    readonly peakDecayPerSecond: number;
+    /**
+     * Floor under the reference peak, as a FRACTION of the loudest she has been.
+     *
+     * Without a floor, a long quiet passage decays the reference until a murmur
+     * throws her mouth wide open. It has to be a fraction rather than a level:
+     * an absolute one silently reintroduces exactly the scale dependence this
+     * module exists to remove, and it does it invisibly, because the arithmetic
+     * still looks relative.
+     */
+    readonly minPeakFraction: number;
+    /** How slowly the "loudest so far" reference fades, per second. */
+    readonly loudestDecayPerSecond: number;
+    /**
+     * How far the peak must stand above the floor before ANY of this counts as
+     * speech.
+     *
+     * The one thing a purely relative design cannot do on its own is notice that
+     * nothing is happening: given only comfort noise it will happily normalise
+     * that noise to full scale and mouth silently for as long as the gap lasts.
+     * Measured, speech stands ~680x above the floor and noise-only sits within
+     * ~2x of it, so the two are not close and this does not need to be delicate.
+     *
+     * A RATIO rather than a level, so it stays scale invariant -- which is the
+     * whole reason the absolute gate was removed.
+     */
+    readonly speechRatio: number;
+    /**
+     * Headroom above the running peak.
+     *
+     * Without it the loudest frame of every syllable maps to exactly 1, because
+     * it IS the peak -- so the mouth spends a seventh of her speech pinned at the
+     * stop instead of modulating. This buys back the top of the range.
+     */
+    readonly peakHeadroom: number;
+    /** How fast the tracked noise floor is allowed to rise, per second. */
+    readonly floorRisePerSecond: number;
+    /**
+     * How long `speaking` survives the last frame that cleared the ratio.
+     *
+     * A HOLD, in seconds, rather than a decay -- because bridging the dip between
+     * two syllables and dropping promptly at the end of a phrase are a problem
+     * about TIME, and every attempt to solve them with one decay rate trades one
+     * against the other. The judgement used to read the reference peak, which
+     * decays at 0.4 per second: from a 0.057 speech level down to 20x the
+     * measured 8.4e-5 floor is `ln(0.02)/ln(0.4)` = 4.27 SECONDS of "still
+     * talking" after she has stopped, on top of the caller's own 500ms debounce.
+     * The farewell waits on exactly this signal, so she could not finish saying
+     * goodbye and settle.
+     *
+     * 180ms spans an inter-syllable dip comfortably -- those land near a tenth of
+     * speech level, two orders above the gate, nowhere near the floor -- while
+     * the p99 gap frame at 8.1e-4 can only ever re-arm a hold this short.
+     */
+    readonly speechHoldSeconds: number;
+    /**
+     * Hard cap on the gate, as a fraction of the usable range.
+     *
+     * A backstop, not a tuning knob. The floor estimator can be wrong -- if the
+     * first audio frame of a session is loud it seeds high, and a signal with no
+     * gaps never gives it a chance to fall. Uncapped, the gate then sits above
+     * everything and her mouth never opens again, silently, for the rest of the
+     * run. This bounds that failure to a slightly insensitive mouth.
+     */
+    readonly maxGateFraction: number;
+    /** One-pole smoothing per frame. Raw per-frame RMS makes the mouth buzz. */
+    readonly smoothing: number;
+}
+export declare const DEFAULT_ENVELOPE: EnvelopeSettings;
+export interface EnvelopeState {
+    /** 0..1, what to hand to setMouthOpen. */
+    readonly mouthOpen: number;
+    /** Fast-decaying reference for "as loud as this phrase gets". */
+    readonly peak: number;
+    /** Very slowly decaying reference for "as loud as she ever gets". */
+    readonly loudest: number;
+    /** Slow estimate of the between-phrase noise floor. */
+    readonly floor: number;
+    /**
+     * Whether this step judged the signal to be speech.
+     *
+     * Exposed because it is the only adaptive answer to "is she talking", and it
+     * was previously computed here and thrown away -- which left the caller to
+     * invent an absolute RMS threshold of its own. That contradicted the entire
+     * point of a relative envelope: comfort noise above the constant pinned her
+     * as permanently speaking, and quiet speech below it never registered at all.
+     */
+    readonly speaking: boolean;
+    /**
+     * Seconds since the last frame that stood clear of the floor.
+     *
+     * Carried in the state because the hold is the only part of this module with
+     * a memory measured in time rather than in levels.
+     */
+    readonly quietFor: number;
+}
+export declare const SILENT: EnvelopeState;
+/** Root mean square of a block of samples, in 0..1 for normalised audio. */
+export declare function rms(samples: Float32Array): number;
+/**
+ * One step. The caller owns the state, so this is pure and testable against a
+ * recorded trace rather than against a live session.
+ */
+export declare function advanceEnvelope(level: number, state: EnvelopeState, dtSeconds: number, settings?: EnvelopeSettings): EnvelopeState;
+//# sourceMappingURL=envelope.d.ts.map

package/dist/core/envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../../src/core/envelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,mEAAmE;IACnE,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAA;IACnC;;;;;;;;OAQG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,mEAAmE;IACnE,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAA;IACtC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,uEAAuE;IACvE,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAA;IACnC;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;IAClC;;;;;;;;OAQG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,4EAA4E;IAC5E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED,eAAO,MAAM,gBAAgB,EAAE,gBAW9B,CAAA;AAED,MAAM,WAAW,aAAa;IAC5B,0CAA0C;IAC1C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB;;;;;;;;OAQG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED,eAAO,MAAM,MAAM,EAAE,aAOpB,CAAA;AAED,4EAA4E;AAC5E,wBAAgB,GAAG,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAWjD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,aAAa,EACpB,SAAS,EAAE,MAAM,EACjB,QAAQ,GAAE,gBAAmC,GAC5C,aAAa,CAoEf"}

package/dist/core/envelope.js

@@ -0,0 +1,141 @@
+/**
+ * Audio loudness to mouth openness.
+ *
+ * The coarse path, and behind cloud speech-to-speech the ONLY path: an audio
+ * stream carries no phoneme timings, so this is not a shortcut here -- it is
+ * the whole option.
+ *
+ * ## Why this is relative rather than a fixed threshold
+ *
+ * mochi's version gated at an absolute 0.01 with a gain of 12. Measured against
+ * a live gpt-realtime session (2026-08-11) those
+ * constants turn out to WORK -- and to work for a reason nobody wrote down, on
+ * a scale nobody had checked:
+ *
+ *   - the gap floor is 8.4e-5 median, 8.1e-4 at p99. So the gate cleared it by
+ *     roughly 12x. Comfortable, but by luck rather than by design.
+ *   - speech sits at 0.057 median and 0.137 at p90, while gain 12 saturates at
+ *     0.093. So more than a tenth of speech frames were pinned fully open --
+ *     a mouth hitting its stop instead of modulating.
+ *
+ * Both numbers belong to one voice on one provider. A different voice, a
+ * provider change, or anyone adding a volume `GainNode` upstream moves them,
+ * and nothing in an absolute design would notice: her mouth would simply hang
+ * open, or stop moving, with nothing to say why.
+ *
+ * So openness is expressed against the signal's OWN recent floor and peak. The
+ * headline property is scale invariance -- multiply the input by any constant
+ * and the output is unchanged -- which is what makes it survive all three of
+ * those changes without being retuned.
+ *
+ * ## What the floor is NOT
+ *
+ * It is not room tone. There is no microphone on this path. Between phrases the
+ * stream carries codec comfort noise at ~1e-4, and it does NOT return to
+ * digital silence once media is flowing (measured: exact zero appears only
+ * before the first audio arrives). So a gate is genuinely required -- a zero
+ * gate leaves the mouth twitching on noise -- but it needs to sit just above a
+ * floor three orders of magnitude below speech, not at a hand-picked constant.
+ */
+export const DEFAULT_ENVELOPE = {
+    floorMargin: 12,
+    peakDecayPerSecond: 0.4,
+    minPeakFraction: 0.35,
+    loudestDecayPerSecond: 0.94,
+    speechRatio: 20,
+    peakHeadroom: 1.15,
+    floorRisePerSecond: 1.6,
+    speechHoldSeconds: 0.18,
+    maxGateFraction: 0.25,
+    smoothing: 0.35,
+};
+export const SILENT = {
+    mouthOpen: 0,
+    peak: 0,
+    loudest: 0,
+    floor: 0,
+    speaking: false,
+    quietFor: Number.POSITIVE_INFINITY,
+};
+/** Root mean square of a block of samples, in 0..1 for normalised audio. */
+export function rms(samples) {
+    let sum = 0;
+    let counted = 0;
+    for (const sample of samples) {
+        // One bad sample from a decoder glitch would otherwise produce NaN and,
+        // through the filter, freeze the mouth for the rest of the session.
+        if (!Number.isFinite(sample))
+            continue;
+        sum += sample * sample;
+        counted++;
+    }
+    return counted === 0 ? 0 : Math.sqrt(sum / counted);
+}
+/**
+ * One step. The caller owns the state, so this is pure and testable against a
+ * recorded trace rather than against a live session.
+ */
+export function advanceEnvelope(level, state, dtSeconds, settings = DEFAULT_ENVELOPE) {
+    const value = Number.isFinite(level) ? Math.max(0, level) : 0;
+    const dt = Number.isFinite(dtSeconds) ? Math.min(Math.max(dtSeconds, 0), 0.25) : 0;
+    // The floor falls to any new minimum at once and rises only slowly. That
+    // asymmetry is the point: a quiet moment is evidence about the floor, a loud
+    // one is not, so speech must not be able to drag the estimate up after it.
+    //
+    // A frame of DIGITAL SILENCE is skipped, and that is not a nicety. Zero is
+    // doing double duty here as "no estimate yet", and an exact zero -- a muted
+    // mic, a gap in the stream, a decoder handing back an empty block -- used to
+    // be accepted as a new minimum. The floor then read as uninitialised again,
+    // so the next frame with any signal in it seeded the floor AT SPEAKING
+    // LEVEL. From there `value > floor * 20` can never be true, and zero is an
+    // absorbing state for a multiplicative rise, so she stayed silent-looking
+    // through continuous speech with every flag reporting success.
+    //
+    // Skipping is also the physically honest reading: a dropout is the absence
+    // of a measurement, not a measurement of an extremely quiet room.
+    const rise = Math.pow(settings.floorRisePerSecond, dt);
+    const floor = value === 0
+        ? state.floor
+        : state.floor === 0
+            ? value
+            : value < state.floor
+                ? value
+                : Math.min(value, state.floor * rise);
+    // The peak rises instantly and decays slowly, so a single loud syllable sets
+    // the reference for the phrase around it rather than only for its own frame.
+    const peak = Math.max(value, state.peak * Math.pow(settings.peakDecayPerSecond, dt));
+    // And a much slower one behind it, so the phrase reference cannot fall so far
+    // during a pause that the next murmur reads as a shout.
+    const loudest = Math.max(value, state.loudest * Math.pow(settings.loudestDecayPerSecond, dt));
+    // Nothing is happening unless the signal stands well clear of the floor. This
+    // is the one judgement a relative design cannot derive from the ratio it is
+    // currently computing, because on noise alone that ratio is 1.
+    //
+    // Against the CURRENT value, held open for `speechHoldSeconds`. It used to
+    // read `peak`, whose whole purpose is to decay slowly so one loud syllable
+    // sets the reference for the phrase around it -- a good property for scaling
+    // the mouth and a disastrous one for deciding she has stopped, because the
+    // decay outlives the speech by seconds. Two jobs, one number; they are now
+    // two numbers.
+    const clear = value > floor * settings.speechRatio;
+    const quietFor = clear ? 0 : state.quietFor + dt;
+    const speaking = quietFor < settings.speechHoldSeconds;
+    const ceiling = Math.max(peak * settings.peakHeadroom, loudest * settings.minPeakFraction);
+    // Capped, so a floor estimate that seeded high cannot swallow the whole
+    // range. Both terms scale with the signal, which is what keeps the result
+    // invariant under a change of level.
+    const gate = Math.min(floor * settings.floorMargin, ceiling * settings.maxGateFraction);
+    const span = ceiling - gate;
+    const target = !speaking || span <= 0 ? 0 : Math.min(1, Math.max(0, (value - gate) / span));
+    const smoothing = Math.min(1, Math.max(0, settings.smoothing));
+    const previous = Number.isFinite(state.mouthOpen) ? state.mouthOpen : 0;
+    return {
+        mouthOpen: previous + (target - previous) * smoothing,
+        peak,
+        loudest,
+        floor,
+        speaking,
+        quietFor,
+    };
+}
+//# sourceMappingURL=envelope.js.map

package/dist/core/envelope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.js","sourceRoot":"","sources":["../../src/core/envelope.ts"],"names":[],"mappings":"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"}

package/dist/core/geometry.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The mochi's silhouette, as arithmetic.
+ *
+ * Deliberately canvas-free: these functions return points, and the backend
+ * turns points into a Path2D. That is what makes the shape testable without a
+ * rasteriser, and it is also what makes hit testing exact -- the polygon that
+ * is filled and the polygon that is hit-tested are the same array.
+ *
+ * Local space throughout: origin at the point where she meets the surface,
+ * +y UP. The renderer flips. Heights read as positive numbers here, which is
+ * worth the one transform at the boundary.
+ *
+ * The shape is an OVOID, not a dome, and that came from measuring
+ * `rig/__fixtures__/mochi-icon.png` rather than from taste. The first version of this file
+ * was a single superellipse planted on a flat base, which put the widest point
+ * at the bottom -- and the icon's widest point is at 0.295 of its height, with
+ * a rounded underside. Those are different creatures, and the difference is
+ * exactly what makes one read as a dumpling and the other as a mochi.
+ */
+export interface Point {
+    readonly x: number;
+    readonly y: number;
+}
+export interface BodyShape {
+    readonly halfWidth: number;
+    readonly height: number;
+    /**
+     * Height of the widest point, as a fraction of height.
+     *
+     * Measured 0.295 on the icon. At 0 this degenerates to the old flat-based
+     * dome; at 0.5 it is a symmetric egg.
+     */
+    readonly waist: number;
+    /**
+     * Superellipse exponent ABOVE the waist. Measured 1.86.
+     *
+     * Below 2 is pointier than an ellipse, which is what gives the icon its soft
+     * peak rather than a hemispherical top.
+     */
+    readonly upperShoulder: number;
+    /**
+     * Superellipse exponent BELOW the waist. Measured 2.58.
+     *
+     * Above 2 is fuller than an ellipse: the underside stays wide and then turns
+     * quickly, which is what makes her look like she is resting her weight on the
+     * desk instead of balancing on a curve.
+     */
+    readonly lowerShoulder: number;
+    /** -1..1. Shear that grows with height, so she leans like dough rather than tipping like a box. */
+    readonly lean: number;
+}
+/**
+ * Squash, preserving area.
+ *
+ * `halfWidth * factor` and `height / factor`: the ovoid's area is
+ * proportional to the product for fixed exponents, so this is exactly
+ * volume-preserving. That is the property that makes it read as dough being
+ * compressed rather than as a picture being scaled.
+ *
+ * The factor is floored well above zero. A squash of -1 would otherwise divide
+ * by zero and produce an infinitely tall mochi.
+ */
+export declare function squashed(shape: BodyShape, amount: number): BodyShape;
+/**
+ * Horizontal displacement at a given height above the base.
+ *
+ * Zero at the base and maximal at the apex, which is what distinguishes a lean
+ * from a translation: her contact point stays where it was.
+ */
+export declare function shearAt(shape: BodyShape, heightAboveBase: number): number;
+/**
+ * Half-width at a height, as a fraction of halfWidth.
+ *
+ * Exported because it is the cheapest way to compare this shape against the
+ * measured icon: the test walks heights and checks the profile, which pins the
+ * silhouette to the artwork rather than to whatever looked right on the day.
+ */
+export declare function widthAt(shape: BodyShape, heightFraction: number): number;
+/**
+ * The closed outline, from the contact point up the right side and back down
+ * the left.
+ *
+ * The base sits exactly on y = 0 and the body occupies y > 0, so "resting on a
+ * surface" is a property of the coordinates rather than something the caller
+ * has to arrange. Squash therefore grows upward, which is how something resting
+ * on a table actually deforms.
+ */
+export declare function domeOutline(shape: BodyShape, steps?: number): Point[];
+/**
+ * Where a feature sits, in body-local space.
+ *
+ * `grip` is the point of this function. At 1 the face deforms exactly as much
+ * as the body and looks printed on; at 0 it floats, unaffected. Real features
+ * on something soft resist deformation without escaping it, so the placement
+ * interpolates between the squashed and unsquashed frames. That single number
+ * is most of what makes it read as a face ON something rather than a decal.
+ *
+ * The lean is measured in that SAME interpolated frame. It used to be taken
+ * from the squashed one unconditionally, which quietly broke the contract: a
+ * zero-grip feature was placed at its undeformed width and then displaced by a
+ * shear computed from the wider, shorter squashed body -- so it moved
+ * horizontally during a squash it was supposed to be ignoring. At grip 1 the
+ * interpolated frame IS the squashed frame, so nothing about her changes.
+ */
+export declare function placeFeature(base: BodyShape, squashedShape: BodyShape, normalisedX: number, normalisedY: number, gripX: number, gripY: number): Point;
+//# sourceMappingURL=geometry.d.ts.map

package/dist/core/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/core/geometry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAoBH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,mGAAmG;IACnG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAIpE;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,CAIzE;AAQD;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,CAWxE;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,SAAK,GAAG,KAAK,EAAE,CAuCjE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,SAAS,EACf,aAAa,EAAE,SAAS,EACxB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,KAAK,CAMP"}