@netforge/engine 0.0.0-stage → 0.1.0

package/dist/runtime/feel/audio.js

@@ -0,0 +1,327 @@
+/**
+ * Footstep and impact audio hooks: named cues with a
+ * throttle, a voice limit, pitch and gain variation, stereo pan from the
+ * screen and distance falloff. Every cue has a procedural synth recipe by
+ * default (no audio files); `addBuffer` swaps in a real CC0 sample later
+ * under the same name. WebAudio is created on the first user gesture.
+ */
+import { seededRandom } from "./noise.js";
+/** The built-in cues every template can use by name. */
+export const DEFAULT_CUES = {
+    hit: { wave: "square", f0: 420, f1: 140, ms: 60, gain: 0.35, minGapMs: 45, voices: 3 },
+    impact: { wave: "noise", f0: 900, f1: 200, ms: 90, gain: 0.5, minGapMs: 50, voices: 3 },
+    kill: { wave: "triangle", f0: 900, f1: 300, ms: 70, gain: 0.4, minGapMs: 60, voices: 3 },
+    bigKill: { wave: "sawtooth", f0: 160, f1: 40, ms: 260, gain: 0.8, minGapMs: 120, voices: 2 },
+    hurt: { wave: "sawtooth", f0: 220, f1: 70, ms: 180, gain: 0.9, minGapMs: 120, voices: 1 },
+    levelUp: { wave: "triangle", f0: 520, f1: 1040, ms: 260, gain: 0.8, minGapMs: 200, voices: 1, pitchVar: 0 },
+    pick: { wave: "sine", f0: 660, f1: 990, ms: 90, gain: 0.6, minGapMs: 80, voices: 2 },
+    coin: { wave: "sine", f0: 1320, f1: 1980, ms: 70, gain: 0.35, minGapMs: 35, voices: 3 },
+    dash: { wave: "noise", f0: 2400, f1: 500, ms: 140, gain: 0.45, minGapMs: 100, voices: 1 },
+    land: { wave: "noise", f0: 500, f1: 120, ms: 110, gain: 0.55, minGapMs: 120, voices: 1 },
+    step: { wave: "noise", f0: 700, f1: 180, ms: 45, gain: 0.22, minGapMs: 90, voices: 2, pitchVar: 0.1 },
+};
+/**
+ * The DOM-free decision core: may a cue start now? Per-cue gap and voice
+ * cap, and a global voice cap.
+ */
+export class CueGate {
+    maxVoices;
+    last = new Map();
+    playing = [];
+    constructor(maxVoices = 16) {
+        this.maxVoices = maxVoices;
+    }
+    allow(name, nowMs, durationMs, minGapMs, cueVoices) {
+        for (let i = this.playing.length - 1; i >= 0; i--)
+            if ((this.playing[i]?.until ?? 0) <= nowMs)
+                this.playing.splice(i, 1);
+        const last = this.last.get(name);
+        if (last !== undefined && nowMs - last < minGapMs)
+            return false;
+        if (this.playing.length >= this.maxVoices)
+            return false;
+        let mine = 0;
+        for (const p of this.playing)
+            if (p.name === name)
+                mine++;
+        if (mine >= cueVoices)
+            return false;
+        this.last.set(name, nowMs);
+        this.playing.push({ name, until: nowMs + durationMs });
+        return true;
+    }
+    get voices() {
+        return this.playing.length;
+    }
+}
+/** Gain for a source `distance` m away (inverse falloff, 0 past maxDistance). */
+export function distanceGain(distance, refDistance = 6, maxDistance = 40, rolloff = 1) {
+    if (!(distance > refDistance))
+        return 1;
+    if (distance >= maxDistance)
+        return 0;
+    return refDistance / (refDistance + rolloff * (distance - refDistance));
+}
+export class FeelAudio {
+    muted = false;
+    /** Cues actually started (playtest counters). */
+    played = 0;
+    gate;
+    ctx = null;
+    masterNode = null;
+    noise = null;
+    masterGain;
+    cues = new Map();
+    unlocked = [];
+    rnd;
+    o;
+    constructor(opts = {}) {
+        this.masterGain = opts.master ?? 0.18;
+        this.gate = new CueGate(opts.voices ?? 16);
+        this.rnd = seededRandom(opts.seed ?? 7);
+        this.o = {
+            refDistance: opts.refDistance ?? 6,
+            maxDistance: opts.maxDistance ?? 40,
+            context: opts.context,
+            now: opts.now ?? (() => (typeof performance !== "undefined" ? performance.now() : Date.now())),
+        };
+        for (const [name, c] of Object.entries(DEFAULT_CUES))
+            this.define(name, c, c);
+    }
+    /** Start WebAudio (call from a user gesture; browsers block audio before one). Safe to call repeatedly. */
+    unlock() {
+        if (this.ctx) {
+            if (this.ctx.state === "suspended")
+                void this.ctx.resume().catch(() => undefined);
+            return;
+        }
+        try {
+            const make = this.o.context ?? (typeof AudioContext !== "undefined" ? () => new AudioContext() : undefined);
+            if (!make)
+                return;
+            this.ctx = make();
+            this.masterNode = this.ctx.createGain();
+            this.masterNode.gain.value = this.masterGain;
+            this.masterNode.connect(this.ctx.destination);
+        }
+        catch {
+            this.ctx = null;
+            this.masterNode = null;
+            return;
+        }
+        const ctx = this.ctx;
+        for (const fn of this.unlocked.splice(0))
+            fn(ctx);
+    }
+    /** Run `fn` with the AudioContext once audio is unlocked (now, if it already is). */
+    whenUnlocked(fn) {
+        if (this.ctx)
+            fn(this.ctx);
+        else
+            this.unlocked.push(fn);
+    }
+    /** The AudioContext, once unlocked (music and other buses hang off it). */
+    get context() {
+        return this.ctx;
+    }
+    /** Unlock on the first pointer or key press on `target` (default window). */
+    unlockOnGesture(target) {
+        const t = target ?? (typeof window !== "undefined" ? window : undefined);
+        if (!t)
+            return;
+        const go = () => this.unlock();
+        t.addEventListener("pointerdown", go, { once: true });
+        t.addEventListener("keydown", go, { once: true });
+        t.addEventListener("touchstart", go, { once: true });
+    }
+    get ready() {
+        return this.ctx !== null;
+    }
+    get master() {
+        return this.masterGain;
+    }
+    set master(v) {
+        this.masterGain = Math.max(0, Math.min(1, v));
+        if (this.masterNode)
+            this.masterNode.gain.value = this.masterGain;
+    }
+    /** Define or replace a cue's synth recipe and options. */
+    define(name, recipe, opts = {}) {
+        const prev = this.cues.get(name);
+        this.cues.set(name, {
+            recipe,
+            buffer: prev?.buffer ?? null,
+            minGapMs: opts.minGapMs ?? prev?.minGapMs ?? 40,
+            pitchVar: opts.pitchVar ?? prev?.pitchVar ?? 0.06,
+            gainVar: opts.gainVar ?? prev?.gainVar ?? 0.1,
+            voices: opts.voices ?? prev?.voices ?? 4,
+        });
+    }
+    /**
+     * Use a real sample for a cue (an AudioBuffer, or a URL fetched and decoded once audio is unlocked).
+     * `opts.gain` is the sample's level before the master gain (default: the cue's synth level).
+     */
+    async addBuffer(name, source, opts = {}) {
+        let buffer;
+        if (typeof source === "string") {
+            if (!this.ctx)
+                this.unlock();
+            const ctx = this.ctx;
+            if (!ctx || typeof fetch === "undefined")
+                return;
+            const data = await (await fetch(source)).arrayBuffer();
+            buffer = await ctx.decodeAudioData(data);
+        }
+        else
+            buffer = source;
+        const prev = this.cues.get(name);
+        const base = prev?.recipe ?? { wave: "sine", f0: 440, f1: 440, ms: buffer.duration * 1000, gain: 1 };
+        const recipe = opts.gain !== undefined ? { ...base, gain: opts.gain } : base;
+        this.define(name, recipe, opts);
+        const cue = this.cues.get(name);
+        if (cue)
+            cue.buffer = buffer;
+    }
+    has(name) {
+        return this.cues.has(name);
+    }
+    /** Play a cue. Returns false when muted, locked, unknown, throttled or out of voices. */
+    play(name, opts = {}) {
+        const cue = this.cues.get(name);
+        if (!cue || this.muted)
+            return false;
+        const ctx = this.ctx;
+        const master = this.masterNode;
+        if (!ctx || !master)
+            return false;
+        let gain = cue.recipe.gain * (opts.gain ?? 1) * (1 + (this.rnd() * 2 - 1) * cue.gainVar);
+        if (opts.distance !== undefined)
+            gain *= distanceGain(opts.distance, this.o.refDistance, this.o.maxDistance);
+        if (gain <= 0.001)
+            return false;
+        const ms = cue.buffer ? cue.buffer.duration * 1000 : cue.recipe.ms;
+        if (!this.gate.allow(name, this.o.now(), ms, cue.minGapMs, cue.voices))
+            return false;
+        const pitch = (opts.pitch ?? 1) * (1 + (this.rnd() * 2 - 1) * cue.pitchVar);
+        let pan = opts.pan;
+        if (pan === undefined && opts.screenX !== undefined && opts.width !== undefined && opts.width > 0)
+            pan = (opts.screenX / opts.width) * 2 - 1;
+        try {
+            this.voice(ctx, master, cue, gain, pitch, Math.max(-1, Math.min(1, pan ?? 0)));
+        }
+        catch {
+            return false;
+        }
+        this.played++;
+        return true;
+    }
+    /** An impact scaled by damage (bigger hits are louder and lower). */
+    impact(damage, opts = {}) {
+        const k = Math.min(1, Math.max(0, Math.log10(1 + Math.max(0, damage)) / 2));
+        return this.play("impact", { ...opts, gain: (opts.gain ?? 1) * (0.5 + k * 0.7), pitch: (opts.pitch ?? 1) * (1.2 - k * 0.5) });
+    }
+    voice(ctx, master, cue, gain, pitch, pan) {
+        const t = ctx.currentTime;
+        const g = ctx.createGain();
+        let out = g;
+        if (pan !== 0 && typeof ctx.createStereoPanner === "function") {
+            const p = ctx.createStereoPanner();
+            p.pan.value = pan;
+            g.connect(p);
+            out = p;
+        }
+        out.connect(master);
+        if (cue.buffer) {
+            const src = ctx.createBufferSource();
+            src.buffer = cue.buffer;
+            src.playbackRate.value = pitch;
+            g.gain.setValueAtTime(gain, t);
+            src.connect(g);
+            src.start(t);
+            return;
+        }
+        const r = cue.recipe;
+        const dur = r.ms / 1000;
+        g.gain.setValueAtTime(gain, t);
+        g.gain.exponentialRampToValueAtTime(0.001, t + dur);
+        if (r.wave === "noise") {
+            const src = ctx.createBufferSource();
+            src.buffer = this.noiseBuffer(ctx);
+            const f = ctx.createBiquadFilter();
+            f.type = "bandpass";
+            f.Q.value = 1.2;
+            f.frequency.setValueAtTime(r.f0 * pitch, t);
+            f.frequency.exponentialRampToValueAtTime(Math.max(20, r.f1 * pitch), t + dur);
+            src.connect(f).connect(g);
+            src.start(t);
+            src.stop(t + dur + 0.02);
+            return;
+        }
+        const o = ctx.createOscillator();
+        o.type = r.wave;
+        o.frequency.setValueAtTime(r.f0 * pitch, t);
+        o.frequency.exponentialRampToValueAtTime(Math.max(20, r.f1 * pitch), t + dur);
+        o.connect(g);
+        o.start(t);
+        o.stop(t + dur + 0.02);
+    }
+    noiseBuffer(ctx) {
+        if (this.noise)
+            return this.noise;
+        const len = Math.floor(ctx.sampleRate * 0.5);
+        const b = ctx.createBuffer(1, len, ctx.sampleRate);
+        const d = b.getChannelData(0);
+        const rnd = seededRandom(99);
+        for (let i = 0; i < len; i++)
+            d[i] = rnd() * 2 - 1;
+        this.noise = b;
+        return b;
+    }
+}
+/** Surfaces change a footstep's pitch and weight. */
+export const SURFACES = {
+    grass: { pitch: 0.85, gain: 0.8 },
+    dirt: { pitch: 0.9, gain: 0.9 },
+    stone: { pitch: 1.25, gain: 1 },
+    wood: { pitch: 1.05, gain: 1 },
+    metal: { pitch: 1.6, gain: 1.1 },
+};
+/**
+ * Footstep cadence from speed: steps per second = speed / stride, with an
+ * alternating left/right pitch. Calls `play(pitch, gain)` on each step.
+ */
+export class Footsteps {
+    play;
+    surface = "dirt";
+    steps = 0;
+    phase = 0;
+    left = false;
+    o;
+    constructor(play, opts = {}) {
+        this.play = play;
+        this.o = { stride: 1.4, maxRate: 6, minSpeed: 0.6, ...opts };
+    }
+    /** Advance by `dt` seconds at `speed` m/s. Returns the number of steps played. */
+    update(dt, speed, grounded = true) {
+        if (dt <= 0)
+            return 0;
+        if (!grounded || speed < this.o.minSpeed) {
+            // Next step lands soon after moving again, not a full stride later.
+            this.phase = Math.min(this.phase, 0.7);
+            return 0;
+        }
+        const rate = Math.min(this.o.maxRate, speed / this.o.stride);
+        this.phase += rate * dt;
+        let n = 0;
+        while (this.phase >= 1) {
+            this.phase -= 1;
+            this.left = !this.left;
+            const s = SURFACES[this.surface];
+            const weight = Math.min(1.2, 0.6 + speed / 12);
+            this.play(s.pitch * (this.left ? 1 : 0.92), s.gain * weight);
+            this.steps++;
+            n++;
+        }
+        return n;
+    }
+}

package/dist/runtime/feel/clock.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The render clock: hit-stop and slow motion for the DRAWN world only.
+ * The netcode never pauses; the clock returns a render time `now` that
+ * runs behind real time while frozen or slowed, then catches up smoothly so
+ * the world never jumps. `now` never runs ahead of real time.
+ */
+export interface FeelClockOptions {
+    /** Milliseconds over which accumulated lag eases back to zero. Default 200. */
+    readonly catchUpMs?: number;
+    /** Most the drawn world may fall behind (keeps interpolation buffers valid). Default 400. */
+    readonly maxLagMs?: number;
+    /** Clamp on one frame's real delta (tab switches). Default 100. */
+    readonly maxFrameMs?: number;
+}
+export interface ClockTick {
+    /** Time to draw the world at (ms, same base as `realNow`). */
+    readonly now: number;
+    /** Scaled frame delta in seconds (0 while frozen). */
+    readonly dt: number;
+    /** Unscaled frame delta in seconds (UI, shake and audio run on this). */
+    readonly realDt: number;
+    /** The time scale this frame (0 frozen, below 1 slowed, above 1 catching up). */
+    readonly timeScale: number;
+}
+export declare class FeelClock {
+    /** Hit-stops requested so far (playtest counters). */
+    stops: number;
+    /** Slow-motion requests so far. */
+    slows: number;
+    private frozenUntil;
+    private lag;
+    private lastReal;
+    private slowScale;
+    private slowUntil;
+    private slowEaseMs;
+    private readonly o;
+    constructor(opts?: FeelClockOptions);
+    /** Freeze the drawn world for `ms`. Longer stops win; they do not stack. */
+    hitStop(ms: number, realNow?: number): void;
+    /** Slow the drawn world to `scale` (0..1) for `ms`, then ease back to full speed over `easeMs`. */
+    slowMo(scale: number, ms: number, easeMs?: number, realNow?: number): void;
+    /** Current slow-motion scale (1 when none). */
+    private slowAt;
+    /** Advance with the frame's real time. */
+    tick(realNow?: number): ClockTick;
+    /** True while a hit-stop holds the drawn world. */
+    get stopped(): boolean;
+    /** Milliseconds the drawn world is behind real time. */
+    get lagMs(): number;
+}
+/** The name templates already use (template-survivor's RenderClock): same class. */
+export { FeelClock as RenderClock };

package/dist/runtime/feel/clock.js

@@ -0,0 +1,80 @@
+const nowMs = () => (typeof performance !== "undefined" ? performance.now() : Date.now());
+export class FeelClock {
+    /** Hit-stops requested so far (playtest counters). */
+    stops = 0;
+    /** Slow-motion requests so far. */
+    slows = 0;
+    frozenUntil = 0;
+    lag = 0;
+    lastReal = 0;
+    slowScale = 1;
+    slowUntil = 0;
+    slowEaseMs = 0;
+    o;
+    constructor(opts = {}) {
+        this.o = { catchUpMs: 200, maxLagMs: 400, maxFrameMs: 100, ...opts };
+    }
+    /** Freeze the drawn world for `ms`. Longer stops win; they do not stack. */
+    hitStop(ms, realNow = this.lastReal || nowMs()) {
+        if (!(ms > 0))
+            return;
+        this.stops++;
+        this.frozenUntil = Math.max(this.frozenUntil, realNow + ms);
+    }
+    /** Slow the drawn world to `scale` (0..1) for `ms`, then ease back to full speed over `easeMs`. */
+    slowMo(scale, ms, easeMs = 200, realNow = this.lastReal || nowMs()) {
+        if (!(ms > 0))
+            return;
+        this.slows++;
+        const s = Math.min(1, Math.max(0.01, scale));
+        // The deeper slow wins while both are active.
+        if (realNow < this.slowUntil + this.slowEaseMs)
+            this.slowScale = Math.min(this.slowScale, s);
+        else
+            this.slowScale = s;
+        this.slowUntil = Math.max(this.slowUntil, realNow + ms);
+        this.slowEaseMs = Math.max(0, easeMs);
+    }
+    /** Current slow-motion scale (1 when none). */
+    slowAt(realNow) {
+        if (realNow < this.slowUntil)
+            return this.slowScale;
+        if (this.slowEaseMs > 0 && realNow < this.slowUntil + this.slowEaseMs) {
+            const t = (realNow - this.slowUntil) / this.slowEaseMs;
+            const e = t * t * (3 - 2 * t);
+            return this.slowScale + (1 - this.slowScale) * e;
+        }
+        return 1;
+    }
+    /** Advance with the frame's real time. */
+    tick(realNow = nowMs()) {
+        const realDt = this.lastReal === 0 ? 1000 / 60 : Math.max(0, Math.min(this.o.maxFrameMs, realNow - this.lastReal));
+        this.lastReal = realNow;
+        if (realNow < this.frozenUntil) {
+            this.lag = Math.min(this.o.maxLagMs, this.lag + realDt);
+            return { now: realNow - this.lag, dt: 0, realDt: realDt / 1000, timeScale: 0 };
+        }
+        const scale = this.slowAt(realNow);
+        if (scale < 1) {
+            const lagged = Math.min(this.o.maxLagMs, this.lag + realDt * (1 - scale));
+            const drawn = realDt - (lagged - this.lag);
+            this.lag = lagged;
+            return { now: realNow - this.lag, dt: drawn / 1000, realDt: realDt / 1000, timeScale: realDt > 0 ? drawn / realDt : 1 };
+        }
+        // Catch up over ~catchUpMs so the world never jumps.
+        const catchUp = Math.min(this.lag, this.lag * Math.min(1, realDt / this.o.catchUpMs) + 0.5);
+        this.lag = Math.max(0, this.lag - catchUp);
+        const drawn = realDt + catchUp;
+        return { now: realNow - this.lag, dt: drawn / 1000, realDt: realDt / 1000, timeScale: realDt > 0 ? drawn / realDt : 1 };
+    }
+    /** True while a hit-stop holds the drawn world. */
+    get stopped() {
+        return this.lastReal < this.frozenUntil;
+    }
+    /** Milliseconds the drawn world is behind real time. */
+    get lagMs() {
+        return this.lag;
+    }
+}
+/** The name templates already use (template-survivor's RenderClock): same class. */
+export { FeelClock as RenderClock };

package/dist/runtime/feel/flash.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Hit flash: per-entity timers that read as 0..1 intensity, for instanced
+ * crowds that tint an instance toward white (or any colour) on a hit.
+ */
+export declare class HitFlash {
+    seconds: number;
+    private readonly t;
+    /** Flashes triggered so far (playtest counters). */
+    count: number;
+    /** `seconds`: how long a full flash lasts. */
+    constructor(seconds?: number);
+    /** Start (or refresh) a flash on `id`; `strength` 0..1 scales its length. */
+    trigger(id: number, strength?: number): void;
+    /** 0..1 flash intensity of `id` now. */
+    value(id: number): number;
+    /** Advance every flash; expired entries are pruned. */
+    update(dt: number): void;
+    /** Live flashes (for tests and budgets). */
+    get size(): number;
+    clear(): void;
+}
+/** Colour multiplier for a flash: 1 at rest, 1 + boost at full flash (instance colours above 1 read as glowing white). */
+export declare const flashMultiplier: (flash: number, boost?: number) => number;
+/**
+ * Write a flashed instance colour into `out` at `offset` (rgb floats):
+ * base colour mixed toward `tint` and boosted by the flash.
+ */
+export declare function flashColor(out: Float32Array | number[], offset: number, flash: number, base?: readonly [number, number, number], tint?: readonly [number, number, number], boost?: number): void;

package/dist/runtime/feel/flash.js

@@ -0,0 +1,60 @@
+/**
+ * Hit flash: per-entity timers that read as 0..1 intensity, for instanced
+ * crowds that tint an instance toward white (or any colour) on a hit.
+ */
+export class HitFlash {
+    seconds;
+    t = new Map();
+    /** Flashes triggered so far (playtest counters). */
+    count = 0;
+    /** `seconds`: how long a full flash lasts. */
+    constructor(seconds = 0.09) {
+        this.seconds = seconds;
+    }
+    /** Start (or refresh) a flash on `id`; `strength` 0..1 scales its length. */
+    trigger(id, strength = 1) {
+        const s = Math.max(0, Math.min(1, strength)) * this.seconds;
+        if (s <= 0)
+            return;
+        this.count++;
+        this.t.set(id, Math.max(this.t.get(id) ?? 0, s));
+    }
+    /** 0..1 flash intensity of `id` now. */
+    value(id) {
+        const v = this.t.get(id);
+        return v === undefined || this.seconds <= 0 ? 0 : Math.min(1, v / this.seconds);
+    }
+    /** Advance every flash; expired entries are pruned. */
+    update(dt) {
+        if (dt <= 0)
+            return;
+        for (const [id, v] of this.t) {
+            const n = v - dt;
+            if (n <= 0)
+                this.t.delete(id);
+            else
+                this.t.set(id, n);
+        }
+    }
+    /** Live flashes (for tests and budgets). */
+    get size() {
+        return this.t.size;
+    }
+    clear() {
+        this.t.clear();
+    }
+}
+/** Colour multiplier for a flash: 1 at rest, 1 + boost at full flash (instance colours above 1 read as glowing white). */
+export const flashMultiplier = (flash, boost = 2.5) => 1 + Math.max(0, Math.min(1, flash)) * boost;
+/**
+ * Write a flashed instance colour into `out` at `offset` (rgb floats):
+ * base colour mixed toward `tint` and boosted by the flash.
+ */
+export function flashColor(out, offset, flash, base = [1, 1, 1], tint = [1, 1, 1], boost = 2.5) {
+    const f = Math.max(0, Math.min(1, flash));
+    const m = 1 + f * boost;
+    for (let i = 0; i < 3; i++) {
+        const b = base[i] ?? 1;
+        out[offset + i] = (b + ((tint[i] ?? 1) - b) * f) * m;
+    }
+}

package/dist/runtime/feel/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The game-feel kit: one-line components every
+ * template uses. See kit.ts for the FeelKit facade.
+ */
+export { FeelKit, FEEL_PRESETS } from "./kit.js";
+export type { FeelKitOptions, FeelPreset, FeelPresetName, HitEvent, KillEvent } from "./kit.js";
+export { Trauma } from "./trauma.js";
+export type { TraumaOptions } from "./trauma.js";
+export { FeelClock, RenderClock } from "./clock.js";
+export type { ClockTick, FeelClockOptions } from "./clock.js";
+export { HitFlash, flashColor, flashMultiplier } from "./flash.js";
+export { KnockbackOffsets } from "./knockback.js";
+export type { KnockbackOptions, KnockbackSample } from "./knockback.js";
+export { Spring, Spring3, stepSpring } from "./spring.js";
+export type { SpringOptions } from "./spring.js";
+export { DamageNumbers, NumberStack } from "./numbers.js";
+export type { DamageNumbersOptions, NumberDraw, NumberInput, NumberSlot, NumberStackOptions } from "./numbers.js";
+export { Ease, Tweens, uiTweens, pop, shakeEl, countUp } from "./tween.js";
+export type { EaseFn, EaseName, FeelElement, TweenOptions, TweenProps } from "./tween.js";
+export { FeelAudio, Footsteps, CueGate, DEFAULT_CUES, SURFACES, distanceGain } from "./audio.js";
+export type { CueOptions, FeelAudioOptions, FootstepOptions, PlayOptions, Surface, SynthRecipe } from "./audio.js";
+export { SoundPlayer } from "./sound.js";
+export type { MusicElement, SoundBank, SoundBankEntry, SoundPlayerOptions } from "./sound.js";
+export { Rumble } from "./rumble.js";
+export type { GamepadLike, NavigatorLike, RumbleActuator, RumbleOptions } from "./rumble.js";
+export { hashSigned, valueNoise1, seededRandom } from "./noise.js";
+export type { ParticleBurstOptions, ParticleSink, Projector, TraumaTarget } from "./types.js";

package/dist/runtime/feel/index.js

@@ -0,0 +1,16 @@
+/**
+ * The game-feel kit: one-line components every
+ * template uses. See kit.ts for the FeelKit facade.
+ */
+export { FeelKit, FEEL_PRESETS } from "./kit.js";
+export { Trauma } from "./trauma.js";
+export { FeelClock, RenderClock } from "./clock.js";
+export { HitFlash, flashColor, flashMultiplier } from "./flash.js";
+export { KnockbackOffsets } from "./knockback.js";
+export { Spring, Spring3, stepSpring } from "./spring.js";
+export { DamageNumbers, NumberStack } from "./numbers.js";
+export { Ease, Tweens, uiTweens, pop, shakeEl, countUp } from "./tween.js";
+export { FeelAudio, Footsteps, CueGate, DEFAULT_CUES, SURFACES, distanceGain } from "./audio.js";
+export { SoundPlayer } from "./sound.js";
+export { Rumble } from "./rumble.js";
+export { hashSigned, valueNoise1, seededRandom } from "./noise.js";