@adatechnology/game-fluids 0.0.0-stage → 0.1.0

package/dist/index.global.js

@@ -0,0 +1,2207 @@
+"use strict";
+var GameFluids = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    ITEM_USES: () => ITEM_USES,
+    LIQUIDS: () => LIQUIDS,
+    STAIN_SAMPLES: () => SAMPLES,
+    ballistic: () => ballistic,
+    createFluids: () => createFluids,
+    createItemUse: () => createItemUse,
+    describeEvent: () => describeEvent,
+    locales: () => locales,
+    resolveStrings: () => resolveStrings,
+    sampleStream: () => sampleStream,
+    stainDirection: () => stainDirection
+  });
+
+  // src/data/liquids.json
+  var liquids_default = [
+    {
+      id: "water",
+      color: 11064558,
+      opacity: 0.35,
+      stainColor: 7309206,
+      viscosity: 1,
+      density: 1e3,
+      dryTime: 600,
+      gloss: 0.9,
+      drink: {
+        thirst: 100,
+        effects: []
+      },
+      tags: [
+        "drink",
+        "clear"
+      ]
+    },
+    {
+      id: "coffee",
+      color: 3875604,
+      opacity: 0.95,
+      stainColor: 2824202,
+      viscosity: 1.5,
+      density: 1005,
+      dryTime: 900,
+      gloss: 0.8,
+      leavesMark: true,
+      steamC: 60,
+      drink: {
+        thirst: 80,
+        effects: [
+          "caffeine"
+        ]
+      },
+      tags: [
+        "drink",
+        "hot"
+      ]
+    },
+    {
+      id: "tea",
+      color: 9063188,
+      opacity: 0.8,
+      stainColor: 6961682,
+      viscosity: 1.4,
+      density: 1005,
+      dryTime: 800,
+      gloss: 0.8,
+      leavesMark: true,
+      steamC: 60,
+      drink: {
+        thirst: 90,
+        effects: []
+      },
+      tags: [
+        "drink",
+        "hot"
+      ]
+    },
+    {
+      id: "milk",
+      color: 16052712,
+      opacity: 0.98,
+      stainColor: 14473160,
+      viscosity: 2,
+      density: 1030,
+      dryTime: 900,
+      gloss: 0.5,
+      leavesMark: true,
+      drink: {
+        thirst: 70,
+        effects: []
+      },
+      tags: [
+        "drink"
+      ]
+    },
+    {
+      id: "soda",
+      color: 3808530,
+      opacity: 0.85,
+      stainColor: 2757901,
+      viscosity: 1.3,
+      density: 1040,
+      dryTime: 1200,
+      gloss: 0.85,
+      leavesMark: true,
+      drink: {
+        thirst: 60,
+        effects: []
+      },
+      tags: [
+        "drink",
+        "sticky"
+      ]
+    },
+    {
+      id: "juice",
+      color: 15239467,
+      opacity: 0.9,
+      stainColor: 12741916,
+      viscosity: 2,
+      density: 1045,
+      dryTime: 1100,
+      gloss: 0.8,
+      leavesMark: true,
+      drink: {
+        thirst: 75,
+        effects: []
+      },
+      tags: [
+        "drink",
+        "sticky"
+      ]
+    },
+    {
+      id: "beer",
+      color: 14259740,
+      opacity: 0.8,
+      stainColor: 11039764,
+      viscosity: 1.4,
+      density: 1010,
+      dryTime: 900,
+      gloss: 0.8,
+      drink: {
+        thirst: 50,
+        effects: [
+          "alcohol"
+        ]
+      },
+      tags: [
+        "drink",
+        "alcohol"
+      ]
+    },
+    {
+      id: "wine",
+      color: 7016223,
+      opacity: 0.9,
+      stainColor: 5048854,
+      viscosity: 1.6,
+      density: 990,
+      dryTime: 800,
+      gloss: 0.85,
+      leavesMark: true,
+      drink: {
+        thirst: 40,
+        effects: [
+          "alcohol"
+        ]
+      },
+      tags: [
+        "drink",
+        "alcohol"
+      ]
+    },
+    {
+      id: "spirits",
+      color: 13214042,
+      opacity: 0.6,
+      stainColor: 10320959,
+      viscosity: 1.8,
+      density: 940,
+      dryTime: 200,
+      gloss: 0.85,
+      flammable: true,
+      drink: {
+        thirst: 5,
+        effects: [
+          "alcohol"
+        ]
+      },
+      tags: [
+        "drink",
+        "alcohol"
+      ]
+    },
+    {
+      id: "fuel",
+      color: 14926682,
+      opacity: 0.6,
+      stainColor: 7232298,
+      viscosity: 0.6,
+      density: 740,
+      dryTime: 120,
+      gloss: 0.95,
+      leavesMark: true,
+      flammable: true,
+      drink: {
+        thirst: 0,
+        effects: [
+          "poison"
+        ]
+      },
+      tags: [
+        "fuel",
+        "gasoline"
+      ]
+    },
+    {
+      id: "diesel",
+      color: 12098094,
+      opacity: 0.8,
+      stainColor: 5917208,
+      viscosity: 3,
+      density: 830,
+      dryTime: 3600,
+      gloss: 0.95,
+      leavesMark: true,
+      flammable: true,
+      drink: {
+        thirst: 0,
+        effects: [
+          "poison"
+        ]
+      },
+      tags: [
+        "fuel"
+      ]
+    },
+    {
+      id: "motor_oil",
+      color: 3877388,
+      opacity: 0.95,
+      stainColor: 1840134,
+      viscosity: 100,
+      density: 880,
+      dryTime: 0,
+      gloss: 1,
+      leavesMark: true,
+      flammable: true,
+      drink: {
+        thirst: 0,
+        effects: [
+          "poison"
+        ]
+      },
+      tags: [
+        "oil"
+      ]
+    },
+    {
+      id: "cooking_oil",
+      color: 14267708,
+      opacity: 0.85,
+      stainColor: 11110698,
+      viscosity: 60,
+      density: 920,
+      dryTime: 0,
+      gloss: 1,
+      leavesMark: true,
+      flammable: true,
+      drink: {
+        thirst: 0,
+        effects: [
+          "poison"
+        ]
+      },
+      tags: [
+        "oil",
+        "food"
+      ]
+    },
+    {
+      id: "blood",
+      color: 7997964,
+      opacity: 0.92,
+      stainColor: 4850950,
+      viscosity: 4,
+      density: 1060,
+      dryTime: 1200,
+      gloss: 0.75,
+      leavesMark: true,
+      drink: {
+        thirst: 10,
+        effects: [
+          "disgust"
+        ]
+      },
+      tags: [
+        "organic"
+      ]
+    },
+    {
+      id: "sap",
+      color: 13146940,
+      opacity: 0.8,
+      stainColor: 10122282,
+      viscosity: 200,
+      density: 1100,
+      dryTime: 3600,
+      gloss: 0.8,
+      leavesMark: true,
+      drink: {
+        thirst: 20,
+        effects: []
+      },
+      tags: [
+        "organic",
+        "sticky"
+      ]
+    },
+    {
+      id: "acid",
+      color: 10146378,
+      opacity: 0.6,
+      stainColor: 7313970,
+      viscosity: 1.5,
+      density: 1200,
+      dryTime: 900,
+      gloss: 0.9,
+      leavesMark: true,
+      drink: {
+        thirst: 0,
+        effects: [
+          "poison"
+        ]
+      },
+      tags: [
+        "corrosive"
+      ]
+    },
+    {
+      id: "paint",
+      color: 11740715,
+      opacity: 0.98,
+      stainColor: 9050655,
+      viscosity: 300,
+      density: 1300,
+      dryTime: 1800,
+      gloss: 0.6,
+      leavesMark: true,
+      drink: {
+        thirst: 0,
+        effects: [
+          "poison"
+        ]
+      },
+      tags: [
+        "paint"
+      ]
+    },
+    {
+      id: "bleach",
+      color: 15134688,
+      opacity: 0.7,
+      stainColor: 13621446,
+      viscosity: 1.2,
+      density: 1100,
+      dryTime: 900,
+      gloss: 0.85,
+      leavesMark: true,
+      drink: {
+        thirst: 0,
+        effects: [
+          "poison"
+        ]
+      },
+      tags: [
+        "corrosive"
+      ]
+    },
+    {
+      id: "honey",
+      color: 14193162,
+      opacity: 0.9,
+      stainColor: 12089350,
+      viscosity: 3e3,
+      density: 1420,
+      dryTime: 14400,
+      gloss: 0.95,
+      leavesMark: true,
+      drink: {
+        thirst: 10,
+        effects: []
+      },
+      tags: [
+        "drink",
+        "sticky"
+      ]
+    }
+  ];
+
+  // src/liquids.ts
+  var LIQUIDS = liquids_default;
+
+  // src/math.ts
+  var GRAVITY = 9.81;
+  var clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+  var lerp = (a, b, t) => a + (b - a) * t;
+  var add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+  var sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+  var scale = (a, s) => [a[0] * s, a[1] * s, a[2] * s];
+  var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+  var cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+  var length = (a) => Math.hypot(a[0], a[1], a[2]);
+  var distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+  var normalize = (a, fallback = [0, 1, 0]) => {
+    const l = length(a);
+    return l < 1e-9 ? [fallback[0], fallback[1], fallback[2]] : [a[0] / l, a[1] / l, a[2] / l];
+  };
+  var copy3 = (a) => [a[0], a[1], a[2]];
+  var lerp3 = (a, b, t) => [lerp(a[0], b[0], t), lerp(a[1], b[1], t), lerp(a[2], b[2], t)];
+  var quatRotate = (q, v) => {
+    const u = [q[0], q[1], q[2]];
+    const c1 = cross(u, v);
+    const c2 = cross(u, c1);
+    return [v[0] + 2 * (q[3] * c1[0] + c2[0]), v[1] + 2 * (q[3] * c1[1] + c2[1]), v[2] + 2 * (q[3] * c1[2] + c2[2])];
+  };
+  var quatConjugate = (q) => [-q[0], -q[1], -q[2], q[3]];
+  var quatMultiply = (a, b) => [
+    a[3] * b[0] + a[0] * b[3] + a[1] * b[2] - a[2] * b[1],
+    a[3] * b[1] - a[0] * b[2] + a[1] * b[3] + a[2] * b[0],
+    a[3] * b[2] + a[0] * b[1] - a[1] * b[0] + a[2] * b[3],
+    a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2]
+  ];
+  var quatFromEuler = (x, y, z) => {
+    const c1 = Math.cos(x / 2);
+    const c2 = Math.cos(y / 2);
+    const c3 = Math.cos(z / 2);
+    const s1 = Math.sin(x / 2);
+    const s2 = Math.sin(y / 2);
+    const s3 = Math.sin(z / 2);
+    return [s1 * c2 * c3 + c1 * s2 * s3, c1 * s2 * c3 - s1 * c2 * s3, c1 * c2 * s3 + s1 * s2 * c3, c1 * c2 * c3 - s1 * s2 * s3];
+  };
+  var Rng = class {
+    constructor(seed) {
+      __publicField(this, "state");
+      this.state = Math.imul((seed | 0) ^ 2654435769, 2246822507) >>> 0 || 1;
+    }
+    next() {
+      this.state = this.state + 1831565813 >>> 0;
+      let t = this.state;
+      t = Math.imul(t ^ t >>> 15, t | 1);
+      t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+      return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    }
+  };
+
+  // src/landing.ts
+  var GROUND_ID = "ground";
+  var MAX_FLIGHT = 3;
+  var ballistic = (origin, velocity, gravity, t) => [
+    origin[0] + velocity[0] * t,
+    origin[1] + velocity[1] * t - 0.5 * gravity * t * t,
+    origin[2] + velocity[2] * t
+  ];
+  var sampleStream = (stream, gravity, t) => ballistic(stream.origin, stream.velocity, gravity, t);
+  var velocityAt = (velocity, gravity, t) => [velocity[0], velocity[1] - gravity * t, velocity[2]];
+  var trace = (surfaces, groundAt, origin, velocity, gravity) => {
+    let best = null;
+    for (const s of surfaces) {
+      const n = s.normal;
+      const c = dot(n, sub(origin, s.point));
+      if (c < -5e-3) continue;
+      const a = -0.5 * gravity * n[1];
+      const b = dot(n, velocity);
+      let t = Infinity;
+      if (Math.abs(a) < 1e-9) {
+        if (b < -1e-9) t = -c / b;
+      } else {
+        const disc = b * b - 4 * a * c;
+        if (disc >= 0) {
+          const sq = Math.sqrt(disc);
+          for (const root of [(-b - sq) / (2 * a), (-b + sq) / (2 * a)]) {
+            if (root >= -1e-6 && b + 2 * a * root < 0 && root < t) t = root;
+          }
+        }
+      }
+      if (!Number.isFinite(t) || t > MAX_FLIGHT) continue;
+      t = Math.max(0, t);
+      if (best && t >= best.t) continue;
+      const p = ballistic(origin, velocity, gravity, t);
+      const rel = sub(p, s.point);
+      if (Math.abs(dot(rel, s.t1)) > s.half[0] || Math.abs(dot(rel, s.t2)) > s.half[1]) continue;
+      best = { t, point: p, normal: n, surface: s.id, velocity: velocityAt(velocity, gravity, t) };
+    }
+    const step = 0.02;
+    let prevT = 0;
+    const startOver = origin[1] - groundAt(origin[0], origin[2]);
+    const limit = best ? best.t : MAX_FLIGHT;
+    if (startOver <= 0) {
+      return best && best.t <= 0 ? best : { t: 0, point: [origin[0], groundAt(origin[0], origin[2]), origin[2]], normal: [0, 1, 0], surface: GROUND_ID, velocity };
+    }
+    for (let t = step; t <= limit + step; t += step) {
+      const tt = Math.min(t, limit);
+      const p = ballistic(origin, velocity, gravity, tt);
+      const over = p[1] - groundAt(p[0], p[2]);
+      if (over <= 0) {
+        let lo = prevT;
+        let hi = tt;
+        for (let i = 0; i < 18; i++) {
+          const mid = (lo + hi) / 2;
+          const q2 = ballistic(origin, velocity, gravity, mid);
+          if (q2[1] - groundAt(q2[0], q2[2]) > 0) lo = mid;
+          else hi = mid;
+        }
+        if (best && hi >= best.t - 1e-3) return best;
+        const q = ballistic(origin, velocity, gravity, hi);
+        return { t: hi, point: [q[0], groundAt(q[0], q[2]), q[2]], normal: [0, 1, 0], surface: GROUND_ID, velocity: velocityAt(velocity, gravity, hi) };
+      }
+      prevT = tt;
+      if (tt >= limit) break;
+    }
+    return best;
+  };
+
+  // src/locale.ts
+  var locales = {
+    en: {
+      liquids: {
+        water: "water",
+        coffee: "coffee",
+        tea: "tea",
+        milk: "milk",
+        soda: "soda",
+        juice: "juice",
+        beer: "beer",
+        wine: "wine",
+        spirits: "spirits",
+        fuel: "gasoline",
+        diesel: "diesel",
+        motor_oil: "motor oil",
+        cooking_oil: "cooking oil",
+        blood: "blood",
+        sap: "sap",
+        acid: "acid",
+        paint: "paint",
+        bleach: "bleach",
+        honey: "honey"
+      },
+      events: {
+        fill: "filled",
+        pour: "poured",
+        spill: "spilled",
+        leak: "leaking",
+        drink: "drank",
+        empty: "emptied",
+        stream_end: "stream ended",
+        splash: "splash",
+        stain: "stain",
+        dried: "dried",
+        steam: "steam",
+        mix: "mixed",
+        tap: "tap"
+      },
+      on: "on",
+      off: "off"
+    },
+    "pt-BR": {
+      liquids: {
+        water: "\xE1gua",
+        coffee: "caf\xE9",
+        tea: "ch\xE1",
+        milk: "leite",
+        soda: "refrigerante",
+        juice: "suco",
+        beer: "cerveja",
+        wine: "vinho",
+        spirits: "destilado",
+        fuel: "gasolina",
+        diesel: "diesel",
+        motor_oil: "\xF3leo de motor",
+        cooking_oil: "\xF3leo de cozinha",
+        blood: "sangue",
+        sap: "seiva",
+        acid: "\xE1cido",
+        paint: "tinta",
+        bleach: "\xE1gua sanit\xE1ria",
+        honey: "mel"
+      },
+      events: {
+        fill: "encheu",
+        pour: "despejou",
+        spill: "derramou",
+        leak: "vazando",
+        drink: "bebeu",
+        empty: "esvaziou",
+        stream_end: "parou de escorrer",
+        splash: "respingo",
+        stain: "mancha",
+        dried: "secou",
+        steam: "vapor",
+        mix: "misturou",
+        tap: "torneira"
+      },
+      on: "ligado",
+      off: "desligado"
+    }
+  };
+  var resolveStrings = (locale) => locales[locale ?? "en"] ?? locales.en;
+  var fmt = (n) => `${(Math.round(n * 1e3) / 1e3).toString()} l`;
+  var pt = (p) => `(${p.map((v) => Math.round(v * 100) / 100).join(", ")})`;
+  var describeEvent = (strings, event) => {
+    const label = strings.events[event.type];
+    const name = (id) => strings.liquids[id] ?? id;
+    switch (event.type) {
+      case "fill":
+        return `${label}: ${event.container} ${name(event.liquid)} ${fmt(event.liters)}`;
+      case "pour":
+      case "spill":
+        return `${label}: ${event.container} ${name(event.liquid)} ${fmt(event.rate)}/s`;
+      case "leak":
+        return `${label}: ${event.container} ${name(event.liquid)} ${fmt(event.rate)}/s ${pt(event.point)}`;
+      case "drink":
+        return `${label}: ${event.container} ${name(event.liquid)} ${fmt(event.liters)}${event.effects.length ? ` [${event.effects.join(", ")}]` : ""}${event.burn ? " !" : ""}`;
+      case "empty":
+        return `${label}: ${event.container}`;
+      case "stream_end":
+        return `${label}: ${event.stream}`;
+      case "splash":
+        return `${label}: ${name(event.liquid)} ${pt(event.point)}`;
+      case "stain":
+        return `${label}: ${event.stain} ${name(event.liquid)} ${event.surface} ${pt(event.point)}`;
+      case "dried":
+        return `${label}: ${event.stain}${event.mark ? " (mark)" : ""}`;
+      case "steam":
+        return `${label}: ${event.container} ${event.on ? strings.on : strings.off}`;
+      case "mix":
+        return `${label}: ${event.container} ${name(event.from)} -> ${name(event.into)}`;
+      case "tap":
+        return `${label}: ${event.tap} ${event.on ? strings.on : strings.off}`;
+    }
+  };
+
+  // src/shapes.ts
+  var RINGS = 8;
+  var SEGMENTS = 16;
+  var GRID = 12;
+  var makeColumns = (shape) => {
+    if (shape.kind === "cylinder") {
+      const x2 = new Float64Array(RINGS * SEGMENTS);
+      const z2 = new Float64Array(RINGS * SEGMENTS);
+      let n2 = 0;
+      for (let k = 0; k < RINGS; k++) {
+        const rr = shape.radius * Math.sqrt((k + 0.5) / RINGS);
+        for (let m = 0; m < SEGMENTS; m++) {
+          const a = (m + k % 2 * 0.5) / SEGMENTS * Math.PI * 2;
+          x2[n2] = Math.cos(a) * rr;
+          z2[n2] = Math.sin(a) * rr;
+          n2++;
+        }
+      }
+      return { x: x2, z: z2, h: shape.height, kind: "cylinder", r: shape.radius, hx: shape.radius, hz: shape.radius };
+    }
+    const [sx, sy, sz] = shape.size;
+    const x = new Float64Array(GRID * GRID);
+    const z = new Float64Array(GRID * GRID);
+    let n = 0;
+    for (let i = 0; i < GRID; i++) {
+      for (let j = 0; j < GRID; j++) {
+        x[n] = ((i + 0.5) / GRID - 0.5) * sx;
+        z[n] = ((j + 0.5) / GRID - 0.5) * sz;
+        n++;
+      }
+    }
+    return { x, z, h: sy, kind: "box", r: Math.hypot(sx, sz) / 2, hx: sx / 2, hz: sz / 2 };
+  };
+  var planeRange = (c, u) => {
+    const horizontal = c.kind === "cylinder" ? c.r * Math.hypot(u[0], u[2]) : Math.abs(u[0]) * c.hx + Math.abs(u[2]) * c.hz;
+    const top = u[1] * c.h;
+    return [-horizontal + Math.min(0, top), horizontal + Math.max(0, top)];
+  };
+  var planeFraction = (c, u, d) => {
+    const uy = u[1];
+    let total = 0;
+    const n = c.x.length;
+    for (let i = 0; i < n; i++) {
+      const s0 = u[0] * c.x[i] + u[2] * c.z[i];
+      let len;
+      if (uy > 1e-6) len = clamp((d - s0) / uy, 0, c.h);
+      else if (uy < -1e-6) len = c.h - clamp((d - s0) / uy, 0, c.h);
+      else len = s0 <= d ? c.h : 0;
+      total += len;
+    }
+    return total / (n * c.h);
+  };
+  var levelFor = (c, u, f) => {
+    const [lo0, hi0] = planeRange(c, u);
+    if (f <= 0) return lo0;
+    if (f >= 1) return hi0;
+    if (Math.abs(u[0]) + Math.abs(u[2]) < 1e-9) {
+      return u[1] > 0 ? f * c.h * u[1] : u[1] * c.h - f * c.h * u[1];
+    }
+    let lo = lo0;
+    let hi = hi0;
+    for (let i = 0; i < 28; i++) {
+      const mid = (lo + hi) / 2;
+      if (planeFraction(c, u, mid) < f) lo = mid;
+      else hi = mid;
+    }
+    return (lo + hi) / 2;
+  };
+  var lipRadius = (shape, opening) => {
+    const limit = shape.kind === "cylinder" ? shape.radius : Math.min(shape.size[0], shape.size[2]) / 2;
+    return opening > 0 ? Math.min(opening, limit) : limit * 0.5;
+  };
+  var shapeHeight = (shape) => shape.kind === "cylinder" ? shape.height : shape.size[1];
+  var lipOf = (shape, opening, u) => {
+    const h = shapeHeight(shape);
+    const ro = lipRadius(shape, opening);
+    const center = [0, h, 0];
+    const uh = Math.hypot(u[0], u[2]);
+    if (uh < 1e-6) return { point: center, center, outward: null, level: u[1] * h };
+    const out = normalize([-u[0], 0, -u[2]]);
+    const point = [out[0] * ro, h, out[2] * ro];
+    return { point, center, outward: out, level: u[0] * point[0] + u[1] * point[1] + u[2] * point[2] };
+  };
+
+  // src/stains.ts
+  var SAMPLES = 16;
+  var COS = [];
+  var SIN = [];
+  for (let i = 0; i < SAMPLES; i++) {
+    COS.push(Math.cos(i / SAMPLES * Math.PI * 2));
+    SIN.push(Math.sin(i / SAMPLES * Math.PI * 2));
+  }
+  var makeBasis = (normalIn, tangentIn) => {
+    const normal = normalize(normalIn);
+    const ref = tangentIn && length(tangentIn) > 1e-6 ? tangentIn : Math.abs(normal[1]) > 0.9 ? [1, 0, 0] : [0, 1, 0];
+    const t1 = normalize(sub(ref, scale(normal, dot(ref, normal))), [1, 0, 0]);
+    return { normal, t1, t2: cross(normal, t1) };
+  };
+  var sampleDir = (b, i) => [
+    b.t1[0] * COS[i] + b.t2[0] * SIN[i],
+    b.t1[1] * COS[i] + b.t2[1] * SIN[i],
+    b.t1[2] * COS[i] + b.t2[2] * SIN[i]
+  ];
+  var stainArea = (front) => {
+    let a = 0;
+    for (let i = 0; i < SAMPLES; i++) a += front[i] * front[(i + 1) % SAMPLES];
+    return 0.5 * Math.sin(Math.PI * 2 / SAMPLES) * a;
+  };
+  var meanRadius = (front) => front.reduce((s, v) => s + v, 0) / front.length;
+  var minFilm = (def) => 1e-3 * (1 + 0.8 * Math.log10(Math.max(1, def.viscosity)));
+  var makeNoise = (rng) => {
+    const amp = [0.12 + rng.next() * 0.18, 0.08 + rng.next() * 0.14, 0.05 + rng.next() * 0.08];
+    const phase = [rng.next() * Math.PI * 2, rng.next() * Math.PI * 2, rng.next() * Math.PI * 2];
+    const raw = [];
+    for (let i = 0; i < SAMPLES; i++) {
+      const a = i / SAMPLES * Math.PI * 2;
+      let v = 1 + (rng.next() - 0.5) * 0.3;
+      for (let k = 0; k < 3; k++) v += amp[k] * Math.sin((k + 2) * a + phase[k]);
+      raw.push(v);
+    }
+    const out = raw.map((v, i) => 0.25 * raw[(i + SAMPLES - 1) % SAMPLES] + 0.5 * v + 0.25 * raw[(i + 1) % SAMPLES]);
+    return out.map((v) => clamp(v, 0.45, 1.7));
+  };
+  var downhill = (normal) => {
+    const d = add([0, -1, 0], scale(normal, normal[1]));
+    const slope = length(d);
+    return slope < 1e-6 ? { dir: [0, 0, 0], slope: 0 } : { dir: scale(d, 1 / slope), slope };
+  };
+  var createStain = (id, surfaceId, def, basis, center, liters, rng) => {
+    const r0 = clamp(Math.sqrt(liters / 1e3 / minFilm(def) / Math.PI) * 0.4, 0.012, 0.12);
+    return {
+      id,
+      surface: surfaceId,
+      liquid: def.id,
+      center: [center[0], center[1], center[2]],
+      front: new Array(SAMPLES).fill(r0),
+      liters,
+      soaked: 0,
+      wetness: 1,
+      wetRadius: 1,
+      normal: basis.normal,
+      tangent: basis.t1,
+      noise: makeNoise(rng),
+      sinceInflow: 0,
+      dry: 0,
+      mark: false,
+      age: 0
+    };
+  };
+  var addInflow = (s, liters, velocity) => {
+    s.liters += liters;
+    s.sinceInflow = 0;
+    if (s.dry > 0 || s.mark) {
+      s.dry = 0;
+      s.mark = false;
+      s.wetness = 1;
+      s.wetRadius = 1;
+    }
+    if (velocity) {
+      const n = s.normal;
+      const tangential = sub(velocity, scale(n, dot(velocity, n)));
+      if (length(tangential) > 0.2) s.flow = normalize(tangential);
+    }
+  };
+  var nudgeCenter = (s, point, weight, basis) => {
+    const delta = scale(sub(point, s.center), weight);
+    if (length(delta) < 1e-6) return;
+    s.center = add(s.center, delta);
+    for (let i = 0; i < SAMPLES; i++) s.front[i] = Math.max(8e-3, s.front[i] - dot(delta, sampleDir(basis, i)));
+  };
+  var edgeLimit = (s, surface, i) => {
+    if (!Number.isFinite(surface.half[0]) && !Number.isFinite(surface.half[1])) return Infinity;
+    const rel = sub(s.center, surface.point);
+    const cx = dot(rel, surface.t1);
+    const cy = dot(rel, surface.t2);
+    let limit = Infinity;
+    if (COS[i] > 1e-6) limit = Math.min(limit, (surface.half[0] - cx) / COS[i]);
+    else if (COS[i] < -1e-6) limit = Math.min(limit, (-surface.half[0] - cx) / COS[i]);
+    if (SIN[i] > 1e-6) limit = Math.min(limit, (surface.half[1] - cy) / SIN[i]);
+    else if (SIN[i] < -1e-6) limit = Math.min(limit, (-surface.half[1] - cy) / SIN[i]);
+    return Math.max(0.01, limit);
+  };
+  var stepStain = (s, def, surface, ambientC, dt) => {
+    s.age += dt;
+    s.sinceInflow += dt;
+    const basis = surface;
+    const { dir: down, slope } = downhill(s.normal);
+    if (s.liters > 0 && surface.porosity > 0) {
+      const soak = Math.min(s.liters, surface.porosity * 0.2 * stainArea(s.front) * dt);
+      s.liters -= soak;
+      s.soaked += soak;
+    }
+    if (s.liters > 1e-7 && s.wetness > 0) {
+      const area = stainArea(s.front);
+      const cover = s.liters / 1e3 / (minFilm(def) * (1 - 0.7 * slope));
+      if (area < cover) {
+        const taper = clamp(1 - area / cover, 0, 1);
+        const v0 = (0.02 + 0.2 * Math.sqrt(s.liters)) / Math.sqrt(Math.max(1, def.viscosity));
+        const delta = [];
+        for (let i = 0; i < SAMPLES; i++) {
+          let m = s.noise[i];
+          if (s.flow) m *= 1 + 0.5 * Math.max(0, dot(sampleDir(basis, i), s.flow));
+          if (slope > 0.02) {
+            const a = dot(sampleDir(basis, i), down);
+            m *= a > 0 ? 1 + 14 * slope * a : Math.max(0.1, 1 + 2.5 * slope * a);
+          }
+          delta.push(Math.max(0, Math.min(s.front[i] + v0 * m * taper * dt, edgeLimit(s, surface, i)) - s.front[i]));
+        }
+        let lambda = 1;
+        const apply = (k) => s.front.map((r, i) => r + delta[i] * k);
+        if (stainArea(apply(1)) > cover) {
+          let lo = 0;
+          let hi = 1;
+          for (let i = 0; i < 14; i++) {
+            const mid = (lo + hi) / 2;
+            if (stainArea(apply(mid)) > cover) hi = mid;
+            else lo = mid;
+          }
+          lambda = lo;
+        }
+        s.front = apply(lambda);
+      }
+    }
+    if (s.sinceInflow > 1 && def.dryTime > 0 && s.dry < 1) {
+      const warm = Math.pow(2, (ambientC - 20) / 12);
+      const ds = dt * warm * (1 + 0.5 * surface.porosity) / def.dryTime;
+      const before = s.dry;
+      s.dry = Math.min(1, s.dry + ds);
+      if (before < 1) s.liters *= 1 - (s.dry - before) / (1 - before);
+      s.wetness = 1 - s.dry;
+      s.wetRadius = Math.sqrt(Math.max(0, 1 - s.dry));
+      if (s.dry >= 1) {
+        s.liters = 0;
+        s.wetness = 0;
+        s.wetRadius = 0;
+        if (def.leavesMark) {
+          s.mark = true;
+          return "dried_mark";
+        }
+        return "dried_gone";
+      }
+    }
+    return "alive";
+  };
+  var stainDirection = (s, i) => sampleDir(makeBasis(s.normal ?? [0, 1, 0], s.tangent), i);
+
+  // src/world.ts
+  var GROUND_POROSITY = 0.2;
+  var MAX_STEP = 0.1;
+  var MAX_SUBSTEPS = 50;
+  var MAX_HOLES = 32;
+  var clone = (v) => JSON.parse(JSON.stringify(v));
+  function createFluids(options = {}) {
+    const strings = resolveStrings(options.locale);
+    const liquids = /* @__PURE__ */ new Map();
+    for (const def of LIQUIDS) liquids.set(def.id, def);
+    for (const def of options.liquids ?? []) liquids.set(def.id, def);
+    const ambientC = options.ambientC ?? 20;
+    const gravity = options.gravity ?? GRAVITY;
+    const groundAt = options.groundAt ?? (() => 0);
+    const mergeDistance = options.mergeDistance ?? 0.15;
+    const maxStains = options.maxStains ?? 64;
+    let rng = new Rng(options.seed ?? 1);
+    let time = 0;
+    const counters = { container: 0, stream: 0, stain: 0, tap: 0 };
+    let containers = /* @__PURE__ */ new Map();
+    let surfaces = /* @__PURE__ */ new Map();
+    let streams = /* @__PURE__ */ new Map();
+    let taps = /* @__PURE__ */ new Map();
+    let stains = /* @__PURE__ */ new Map();
+    const listeners = /* @__PURE__ */ new Map();
+    let queue = [];
+    let updating = false;
+    const groundSurface = {
+      normal: [0, 1, 0],
+      t1: [1, 0, 0],
+      t2: [0, 0, -1],
+      point: [0, 0, 0],
+      half: [Infinity, Infinity],
+      porosity: GROUND_POROSITY
+    };
+    const emit = (e) => {
+      if (updating) queue.push(e);
+      options.onEvent?.(e);
+      listeners.get(e.type)?.forEach((fn) => fn(e));
+      listeners.get("*")?.forEach((fn) => fn(e));
+    };
+    const toWorld = (c, p) => add(c.position, quatRotate(c.rotation, p));
+    const defOf = (c) => c.liquid ? liquids.get(c.liquid) ?? null : null;
+    const viscScale = (def) => 1 / Math.sqrt(Math.max(1, def.viscosity));
+    const refreshLevel = (c) => {
+      c.normal = normalize([c.slosh[0], 1, c.slosh[1]]);
+      c.u = normalize(quatRotate(quatConjugate(c.rotation), c.normal));
+      c.d = levelFor(c.cols, c.u, c.spec.capacity > 0 ? c.liters / c.spec.capacity : 0);
+    };
+    const surfaceFor = (id) => id === GROUND_ID ? groundSurface : surfaces.get(id) ?? groundSurface;
+    const landingSurfaces = () => {
+      const list = [];
+      for (const [id, s] of surfaces) list.push({ id, normal: s.normal, t1: s.t1, t2: s.t2, point: s.point, half: s.half });
+      return list;
+    };
+    const stopStream = (id) => {
+      const s = streams.get(id);
+      if (!s) return;
+      streams.delete(id);
+      const c = s.container ? containers.get(s.container) : void 0;
+      if (c) delete c.streams[s.key];
+      const tap = s.tap ? taps.get(s.tap) : void 0;
+      if (tap && tap.stream === id) tap.stream = void 0;
+      emit({ type: "stream_end", stream: id });
+    };
+    const endStreamKey = (c, key) => {
+      const id = c.streams[key];
+      if (id) stopStream(id);
+    };
+    const syncStream = (c, key, cause, rate, origin, velocity, visualOnly = false) => {
+      if (rate < 1e-5 || !c.liquid) {
+        endStreamKey(c, key);
+        return;
+      }
+      const existing = c.streams[key] ? streams.get(c.streams[key]) : void 0;
+      if (existing) {
+        existing.rate = rate;
+        existing.origin = origin;
+        existing.velocity = velocity;
+        existing.thin = rate < 0.04;
+        existing.visualOnly = visualOnly;
+        existing.temperature = c.temperature;
+        return;
+      }
+      const id = `stream_${++counters.stream}`;
+      const stream = {
+        id,
+        liquid: c.liquid,
+        cause,
+        container: c.id,
+        origin,
+        velocity,
+        rate,
+        landing: null,
+        thin: rate < 0.04,
+        flightTime: MAX_FLIGHT,
+        key,
+        lastSplash: -1,
+        visualOnly,
+        temperature: c.temperature
+      };
+      streams.set(id, stream);
+      c.streams[key] = id;
+      if (cause === "leak") emit({ type: "leak", container: c.id, liquid: c.liquid, rate, stream: id, point: copy3(origin) });
+      else if (cause === "spill") emit({ type: "spill", container: c.id, liquid: c.liquid, rate, stream: id });
+      else emit({ type: "pour", container: c.id, liquid: c.liquid, rate, stream: id });
+    };
+    const TAP_SPEED = 1.2;
+    const syncTap = (t) => {
+      if (!t.on || t.rate < 1e-5 || !liquids.has(t.liquid)) {
+        if (t.stream) stopStream(t.stream);
+        return;
+      }
+      const velocity = [t.direction[0] * TAP_SPEED, t.direction[1] * TAP_SPEED, t.direction[2] * TAP_SPEED];
+      const existing = t.stream ? streams.get(t.stream) : void 0;
+      if (existing) {
+        existing.rate = t.rate;
+        existing.thin = t.rate < 0.04;
+        existing.temperature = t.temperature;
+        existing.velocity = velocity;
+        return;
+      }
+      const id = `stream_${++counters.stream}`;
+      streams.set(id, {
+        id,
+        liquid: t.liquid,
+        cause: "tap",
+        tap: t.id,
+        origin: copy3(t.position),
+        velocity,
+        rate: t.rate,
+        landing: null,
+        thin: t.rate < 0.04,
+        flightTime: MAX_FLIGHT,
+        key: `tap:${t.id}`,
+        lastSplash: -1,
+        visualOnly: false,
+        temperature: t.temperature
+      });
+      t.stream = id;
+    };
+    const lipFlow = (c, head) => {
+      const lip = lipOf(c.spec.shape, c.spec.opening, c.u);
+      const origin = toWorld(c, lip.point);
+      let dir = [1, 0, 0];
+      const horizontal = (v) => Math.hypot(v[0], v[2]) > 1e-3 ? normalize([v[0], 0, v[2]]) : null;
+      if (lip.outward) dir = horizontal(quatRotate(c.rotation, lip.outward)) ?? horizontal(quatRotate(c.rotation, [1, 0, 0])) ?? dir;
+      else dir = horizontal(quatRotate(c.rotation, [1, 0, 0])) ?? dir;
+      const speed = clamp(0.3 + 0.5 * Math.sqrt(2 * gravity * Math.max(0, head)), 0.2, 2.5);
+      return { origin, velocity: [dir[0] * speed, -0.1, dir[2] * speed] };
+    };
+    const removeLiters = (c, amount) => {
+      c.liters = Math.max(0, c.liters - amount);
+    };
+    const settle = (c) => {
+      if (c.liquid && c.liters <= 1e-6) {
+        c.liters = 0;
+        c.liquid = null;
+        emit({ type: "empty", container: c.id });
+      }
+    };
+    const fillInternal = (c, liquid, liters, temperature, announce) => {
+      if (!(liters > 0) || !liquids.has(liquid)) return 0;
+      const room = c.spec.capacity - c.liters;
+      const accepted = Math.min(liters, Math.max(0, room));
+      if (accepted <= 0) return 0;
+      const t = temperature ?? ambientC;
+      if (c.liquid && c.liquid !== liquid && c.liters > 1e-6) {
+        const incomingWins = accepted > c.liters;
+        const into = incomingWins ? liquid : c.liquid;
+        const from = incomingWins ? c.liquid : liquid;
+        if (announce || time - c.lastMix > 0.5) {
+          c.lastMix = time;
+          emit({ type: "mix", container: c.id, from, into });
+        }
+        c.liquid = into;
+      } else if (!c.liquid || c.liters <= 1e-6) {
+        c.liquid = liquid;
+      }
+      c.temperature = c.liters > 1e-6 ? (c.temperature * c.liters + t * accepted) / (c.liters + accepted) : t;
+      c.liters += accepted;
+      if (announce) emit({ type: "fill", container: c.id, liquid, liters: accepted });
+      return accepted;
+    };
+    const stainAt = (surfaceId, liquid, point) => {
+      let best = null;
+      let bestD = Infinity;
+      for (const s of stains.values()) {
+        if (s.surface !== surfaceId || s.liquid !== liquid) continue;
+        const d = distance(point, s.center);
+        if (d < mergeDistance + 0.5 * meanRadius(s.front) && d < bestD) {
+          best = s;
+          bestD = d;
+        }
+      }
+      return best;
+    };
+    const evictStain = () => {
+      let victim = null;
+      for (const s of stains.values()) {
+        const rank = (x) => (x.wetness <= 0 ? 0 : 1) * 1e9 - x.age;
+        if (!victim || rank(s) < rank(victim)) victim = s;
+      }
+      if (victim) stains.delete(victim.id);
+    };
+    const deposit = (liquid, hit, liters, velocity) => {
+      const def = liquids.get(liquid);
+      if (!def || liters <= 0) return;
+      let s = stainAt(hit.surface, liquid, hit.point);
+      if (s) {
+        const basis2 = { normal: s.normal, t1: s.tangent, t2: cross(s.normal, s.tangent) };
+        nudgeCenter(s, hit.point, clamp(liters / (s.liters + liters) * 0.5, 0, 0.5), basis2);
+        addInflow(s, liters, velocity);
+        return;
+      }
+      while (stains.size >= maxStains) evictStain();
+      const surface = surfaceFor(hit.surface);
+      const basis = hit.surface === GROUND_ID ? makeBasis(hit.normal) : surface;
+      s = createStain(`stain_${++counters.stain}`, hit.surface, def, basis, hit.point, liters, rng);
+      if (velocity) addInflow(s, 0, velocity);
+      s.sinceInflow = 0;
+      stains.set(s.id, s);
+      emit({ type: "stain", stain: s.id, surface: hit.surface, liquid, point: copy3(hit.point) });
+    };
+    const lipCenterWorld = (c) => toWorld(c, [0, shapeHeight(c.spec.shape), 0]);
+    const catcher = (s, landingT) => {
+      let best = null;
+      for (const oc of containers.values()) {
+        if (oc.id === s.container || oc.closed || oc.liters >= oc.spec.capacity) continue;
+        const lip = lipCenterWorld(oc);
+        const disc = s.velocity[1] * s.velocity[1] - 2 * gravity * (lip[1] - s.origin[1]);
+        if (disc < 0) continue;
+        const t = (s.velocity[1] + Math.sqrt(disc)) / gravity;
+        if (t <= 0 || t >= landingT || best && t >= best.t) continue;
+        const p = ballistic(s.origin, s.velocity, gravity, t);
+        if (Math.hypot(p[0] - lip[0], p[2] - lip[2]) <= lipRadius(oc.spec.shape, oc.spec.opening) + 0.01) best = { container: oc, t, point: p };
+      }
+      return best;
+    };
+    const stepStream = (s, dt) => {
+      const hit = trace(landingSurfaces(), groundAt, s.origin, s.velocity, gravity);
+      const caught = catcher(s, hit ? hit.t : MAX_FLIGHT);
+      if (caught) {
+        s.landing = caught.point;
+        s.flightTime = caught.t;
+        if (!s.visualOnly) fillInternal(caught.container, s.liquid, s.rate * dt, s.temperature, false);
+        return;
+      }
+      s.landing = hit ? copy3(hit.point) : null;
+      s.flightTime = hit ? hit.t : MAX_FLIGHT;
+      if (!hit || s.visualOnly) return;
+      const speed = length(hit.velocity);
+      if (time - s.lastSplash >= 0.12) {
+        s.lastSplash = time;
+        emit({ type: "splash", liquid: s.liquid, point: copy3(hit.point), intensity: clamp(0.15 + s.rate * 1.2 + speed * 0.05, 0, 1) });
+      }
+      deposit(s.liquid, hit, s.rate * dt, hit.velocity);
+    };
+    const spillRate = (c, def, h) => {
+      const ro = lipRadius(c.spec.shape, c.spec.opening);
+      const area = 2 * ro * Math.min(h, ro);
+      return Math.max(0.6 * area * Math.sqrt(2 * gravity * h) * 1e3 * viscScale(def), 4e-3);
+    };
+    const steamThreshold = (def) => def.steamC ?? (def.drink && def.drink.thirst > 0 ? 60 : Infinity);
+    const stepContainer = (c, dt) => {
+      if (c.hasPrev && dt > 0) {
+        const ax = (c.velocity[0] - c.prevVelocity[0]) / dt;
+        const az = (c.velocity[2] - c.prevVelocity[2]) / dt;
+        const tx = clamp(ax / gravity, -0.35, 0.35);
+        const tz = clamp(az / gravity, -0.35, 0.35);
+        const w = 9;
+        const z = 0.12;
+        c.slosh[2] += (w * w * (tx - c.slosh[0]) - 2 * z * w * c.slosh[2]) * dt;
+        c.slosh[3] += (w * w * (tz - c.slosh[1]) - 2 * z * w * c.slosh[3]) * dt;
+      } else {
+        c.slosh[2] *= 0.5;
+        c.slosh[3] *= 0.5;
+      }
+      c.slosh[0] += c.slosh[2] * dt;
+      c.slosh[1] += c.slosh[3] * dt;
+      if (Math.abs(c.slosh[0]) + Math.abs(c.slosh[1]) + Math.abs(c.slosh[2]) + Math.abs(c.slosh[3]) < 1e-5) c.slosh = [0, 0, 0, 0];
+      c.prevVelocity = copy3(c.velocity);
+      c.hasPrev = true;
+      if (c.temperature !== ambientC) {
+        const tau = (600 + 2400 * c.liters) * (c.spec.insulated ? 10 : 1);
+        c.temperature = ambientC + (c.temperature - ambientC) * Math.exp(-dt / tau);
+        if (Math.abs(c.temperature - ambientC) < 0.01) c.temperature = ambientC;
+      }
+      refreshLevel(c);
+      const def = defOf(c);
+      const steaming = !!def && c.liters > 1e-6 && !c.closed && c.temperature > steamThreshold(def);
+      if (steaming !== c.steaming) {
+        c.steaming = steaming;
+        emit({ type: "steam", container: c.id, on: steaming });
+      }
+      c.outflow = 0;
+      if (!def || c.liters <= 1e-6) {
+        for (const key of Object.keys(c.streams)) endStreamKey(c, key);
+        c.pourTTL = 0;
+        settle(c);
+        return;
+      }
+      if (c.pourTTL > 0) {
+        c.pourTTL -= dt;
+        if (c.pourTTL > 0) {
+          const flow = lipFlow(c, 0.05);
+          syncStream(c, "pour", "pour", c.pourRate, flow.origin, flow.velocity, c.pourVisual);
+          c.outflow += c.pourRate;
+        } else endStreamKey(c, "pour");
+        endStreamKey(c, "spill");
+      } else {
+        endStreamKey(c, "pour");
+        const lip = lipOf(c.spec.shape, c.spec.opening, c.u);
+        const h = c.d - lip.level;
+        let handled = false;
+        if (!c.closed && h > 1e-5) {
+          const excess = c.liters - c.spec.capacity * planeFraction(c.cols, c.u, lip.level);
+          if (excess > 1e-6) {
+            const rate = Math.min(spillRate(c, def, h), excess / Math.max(dt, 1e-6));
+            removeLiters(c, Math.min(rate * dt, excess, c.liters));
+            const flow = lipFlow(c, h);
+            syncStream(c, "spill", "spill", rate, flow.origin, flow.velocity);
+            c.outflow += rate;
+            handled = true;
+          }
+        }
+        if (!handled) endStreamKey(c, "spill");
+      }
+      for (let i = 0; i < c.holes.length; i++) {
+        const hole = c.holes[i];
+        const key = `leak:${i}`;
+        const hh = dot(c.u, hole.point);
+        const head = c.d - hh;
+        if (c.liters > 1e-6 && head > 1e-4) {
+          const area = Math.PI * (hole.diameter / 2) ** 2;
+          const natural = 0.6 * area * Math.sqrt(2 * gravity * head) * 1e3 * viscScale(def);
+          const avail = c.liters - c.spec.capacity * planeFraction(c.cols, c.u, hh);
+          if (avail > 1e-7) {
+            const rate = Math.min(natural, avail / Math.max(dt, 1e-6));
+            removeLiters(c, Math.min(rate * dt, avail));
+            const nW = normalize(quatRotate(c.rotation, hole.normal));
+            const v = Math.min(3, 0.6 * Math.sqrt(2 * gravity * head));
+            syncStream(c, key, "leak", rate, toWorld(c, hole.point), [nW[0] * v, nW[1] * v - 0.05, nW[2] * v]);
+            c.outflow += rate;
+            continue;
+          }
+        }
+        endStreamKey(c, key);
+      }
+      if (c.holes.length > 0 || c.outflow > 0) refreshLevel(c);
+      settle(c);
+    };
+    const step = (dt) => {
+      time += dt;
+      for (const c of [...containers.values()]) stepContainer(c, dt);
+      for (const s of [...streams.values()]) stepStream(s, dt);
+      for (const st of [...stains.values()]) {
+        const def = liquids.get(st.liquid);
+        if (!def) continue;
+        const status = stepStain(st, def, surfaceFor(st.surface), ambientC, dt);
+        if (status === "dried_mark") emit({ type: "dried", stain: st.id, mark: true });
+        else if (status === "dried_gone") {
+          stains.delete(st.id);
+          emit({ type: "dried", stain: st.id, mark: false });
+        }
+      }
+    };
+    const stateOf = (c) => ({
+      id: c.id,
+      liquid: c.liquid,
+      liters: c.liters,
+      capacity: c.spec.capacity,
+      temperature: c.temperature,
+      closed: c.closed,
+      surfaceHeight: c.liters > 0 ? c.d : 0,
+      surfacePoint: add(c.position, scale(c.normal, c.liters > 0 ? c.d : 0)),
+      surfaceNormal: copy3(c.normal),
+      holes: c.holes.map((h) => ({ point: copy3(h.point), normal: copy3(h.normal), diameter: h.diameter })),
+      outflow: c.outflow,
+      steaming: c.steaming,
+      shape: c.spec.shape,
+      lipRadius: lipRadius(c.spec.shape, c.spec.opening),
+      position: copy3(c.position),
+      rotation: [...c.rotation]
+    });
+    const streamView = (s) => ({
+      id: s.id,
+      liquid: s.liquid,
+      cause: s.cause,
+      container: s.container,
+      tap: s.tap,
+      origin: copy3(s.origin),
+      velocity: copy3(s.velocity),
+      rate: s.rate,
+      landing: s.landing ? copy3(s.landing) : null,
+      thin: s.thin,
+      flightTime: s.flightTime
+    });
+    const stainView = (s) => ({
+      id: s.id,
+      surface: s.surface,
+      liquid: s.liquid,
+      center: copy3(s.center),
+      front: [...s.front],
+      liters: s.liters,
+      soaked: s.soaked,
+      wetness: s.wetness,
+      wetRadius: s.wetRadius,
+      normal: copy3(s.normal),
+      tangent: copy3(s.tangent),
+      flow: s.flow ? copy3(s.flow) : void 0,
+      mark: s.mark,
+      age: s.age
+    });
+    const world = {
+      liquids,
+      gravity,
+      describe: (event) => describeEvent(strings, event),
+      addContainer(spec, opts = {}) {
+        const id = opts.id ?? `container_${++counters.container}`;
+        if (containers.has(id)) world.removeContainer(id);
+        const liquid = spec.liquid && liquids.has(spec.liquid) ? spec.liquid : null;
+        const liters = liquid ? clamp(spec.liters ?? 0, 0, spec.capacity) : 0;
+        const c = {
+          id,
+          spec: clone(spec),
+          cols: makeColumns(spec.shape),
+          liquid: liters > 0 ? liquid : null,
+          liters,
+          temperature: spec.temperature ?? ambientC,
+          closed: spec.closed ?? spec.opening <= 0,
+          position: copy3(opts.position ?? [0, 0, 0]),
+          rotation: opts.rotation ? [...opts.rotation] : [0, 0, 0, 1],
+          velocity: [0, 0, 0],
+          prevVelocity: [0, 0, 0],
+          hasPrev: false,
+          holes: [],
+          slosh: [0, 0, 0, 0],
+          normal: [0, 1, 0],
+          u: [0, 1, 0],
+          d: 0,
+          steaming: false,
+          outflow: 0,
+          streams: {},
+          pourRate: 0,
+          pourTTL: 0,
+          pourVisual: false,
+          lastMix: -10
+        };
+        containers.set(id, c);
+        refreshLevel(c);
+        return id;
+      },
+      addTap(spec) {
+        const id = spec.id ?? `tap_${++counters.tap}`;
+        if (taps.has(id)) world.removeTap(id);
+        const d = spec.direction ?? [0, -1, 0];
+        const len = Math.hypot(d[0], d[1], d[2]) || 1;
+        const t = {
+          id,
+          position: copy3(spec.position),
+          direction: [d[0] / len, d[1] / len, d[2] / len],
+          liquid: spec.liquid,
+          rate: Math.max(0, spec.rate),
+          temperature: spec.temperature ?? ambientC,
+          on: false
+        };
+        taps.set(id, t);
+        if (spec.on ?? true) world.setTap(id, true);
+        return id;
+      },
+      setTap(id, on, rate) {
+        const t = taps.get(id);
+        if (!t) return;
+        if (rate !== void 0) t.rate = Math.max(0, rate);
+        const changed = t.on !== on;
+        t.on = on;
+        syncTap(t);
+        if (changed) emit({ type: "tap", tap: id, on });
+      },
+      removeTap(id) {
+        const t = taps.get(id);
+        if (!t) return;
+        t.on = false;
+        syncTap(t);
+        taps.delete(id);
+      },
+      taps: () => [...taps.values()].map((t) => ({ id: t.id, position: copy3(t.position), direction: copy3(t.direction), liquid: t.liquid, rate: t.rate, temperature: t.temperature, on: t.on, stream: t.stream })),
+      removeContainer(id) {
+        const c = containers.get(id);
+        if (!c) return;
+        for (const key of Object.keys(c.streams)) endStreamKey(c, key);
+        containers.delete(id);
+      },
+      setTransform(id, position, rotation, velocity) {
+        const c = containers.get(id);
+        if (!c) return;
+        c.position = copy3(position);
+        c.rotation = [...rotation];
+        if (velocity) c.velocity = copy3(velocity);
+        refreshLevel(c);
+      },
+      open(id) {
+        const c = containers.get(id);
+        if (c) c.closed = false;
+      },
+      close(id) {
+        const c = containers.get(id);
+        if (!c) return;
+        c.closed = true;
+        for (const key of ["pour", "spill"]) endStreamKey(c, key);
+        c.pourTTL = 0;
+      },
+      fill(id, liquid, liters, temperature) {
+        const c = containers.get(id);
+        if (!c || c.closed) return 0;
+        const accepted = fillInternal(c, liquid, liters, temperature, true);
+        refreshLevel(c);
+        return accepted;
+      },
+      pour(id, dt, into) {
+        const c = containers.get(id);
+        const def = c ? defOf(c) : null;
+        if (!c || !def || c.closed || c.liters <= 1e-6 || !(dt > 0)) return 0;
+        refreshLevel(c);
+        const lip = lipOf(c.spec.shape, c.spec.opening, c.u);
+        const depth = Math.max(0, c.d - planeRange(c.cols, c.u)[0]);
+        const head = Math.max(c.d - lip.level, 0.02 + 0.5 * depth);
+        const ro = lipRadius(c.spec.shape, c.spec.opening);
+        const natural = 0.6 * Math.PI * ro * ro * Math.sqrt(2 * gravity * head) * 1e3;
+        const rate = Math.min(natural, 0.15 + 12 * ro) * viscScale(def);
+        const out = Math.min(rate * dt, c.liters);
+        const target = into ? containers.get(into) : void 0;
+        let delivered = out;
+        if (target) {
+          delivered = fillInternal(target, c.liquid, out, c.temperature, false);
+          refreshLevel(target);
+          const overflow = out - delivered;
+          if (overflow > 1e-6) {
+            const flow2 = lipFlow(c, head);
+            const hit = trace(landingSurfaces(), groundAt, flow2.origin, flow2.velocity, gravity);
+            if (hit) deposit(c.liquid, hit, overflow, hit.velocity);
+          }
+        }
+        removeLiters(c, out);
+        c.pourRate = out / dt;
+        c.pourTTL = Math.max(0.12, dt * 1.5);
+        c.pourVisual = !!target;
+        const flow = lipFlow(c, head);
+        syncStream(c, "pour", "pour", c.pourRate, flow.origin, flow.velocity, c.pourVisual);
+        refreshLevel(c);
+        settle(c);
+        return out;
+      },
+      drink(id, liters) {
+        const c = containers.get(id);
+        const def = c ? defOf(c) : null;
+        if (!c || !def || c.closed || c.liters <= 1e-6 || !(liters > 0)) return null;
+        const amount = Math.min(liters, c.liters);
+        removeLiters(c, amount);
+        const event = {
+          type: "drink",
+          container: c.id,
+          liquid: def.id,
+          liters: amount,
+          temperature: c.temperature,
+          thirst: (def.drink?.thirst ?? 0) * amount,
+          effects: [...def.drink?.effects ?? []],
+          burn: c.temperature > 65
+        };
+        emit(event);
+        refreshLevel(c);
+        settle(c);
+        return event;
+      },
+      puncture(id, point, normal, diameter) {
+        const c = containers.get(id);
+        if (!c || !(diameter > 0) || c.holes.length >= MAX_HOLES) return;
+        c.holes.push({ point: copy3(point), normal: normalize(normal), diameter });
+      },
+      heat(id, deltaC) {
+        const c = containers.get(id);
+        if (c) c.temperature = clamp(c.temperature + deltaC, -50, 1e3);
+      },
+      addSurface(spec) {
+        const basis = makeBasis(spec.normal, spec.tangent);
+        surfaces.set(spec.id, {
+          ...clone(spec),
+          ...basis,
+          point: copy3(spec.point),
+          half: [spec.halfSize[0], spec.halfSize[1]]
+        });
+      },
+      removeSurface(id) {
+        surfaces.delete(id);
+        for (const s of [...stains.values()]) if (s.surface === id) stains.delete(s.id);
+      },
+      splash(liquid, point, liters, velocity) {
+        if (!liquids.has(liquid) || !(liters > 0)) return;
+        const v = velocity ?? [0, -0.1, 0];
+        const origin = add(point, [0, 0.02, 0]);
+        const hit = trace(landingSurfaces(), groundAt, origin, v, gravity);
+        if (!hit) return;
+        emit({ type: "splash", liquid, point: copy3(hit.point), intensity: clamp(0.3 + liters * 2, 0, 1) });
+        deposit(liquid, hit, liters, length(v) > 0.3 ? hit.velocity : null);
+      },
+      clearStains(point, radius) {
+        for (const s of [...stains.values()]) {
+          if (distance(point, s.center) <= radius + 0.5 * meanRadius(s.front)) {
+            stains.delete(s.id);
+            emit({ type: "dried", stain: s.id, mark: false });
+          }
+        }
+      },
+      update(dt) {
+        if (dt > 0) {
+          const n = clamp(Math.ceil(dt / MAX_STEP), 1, MAX_SUBSTEPS);
+          updating = true;
+          try {
+            for (let i = 0; i < n; i++) step(dt / n);
+          } finally {
+            updating = false;
+          }
+        }
+        const out = queue;
+        queue = [];
+        return out;
+      },
+      container: (id) => {
+        const c = containers.get(id);
+        return c ? stateOf(c) : null;
+      },
+      containers: () => [...containers.values()].map(stateOf),
+      streams: () => [...streams.values()].map(streamView),
+      stains: () => [...stains.values()].map(stainView),
+      on(type, fn) {
+        let set = listeners.get(type);
+        if (!set) listeners.set(type, set = /* @__PURE__ */ new Set());
+        set.add(fn);
+        return () => {
+          set?.delete(fn);
+        };
+      },
+      serialize() {
+        const snapshot = {
+          version: 1,
+          time,
+          rng: rng.state,
+          counters: { ...counters },
+          containers: [...containers.values()].map((c) => {
+            const { cols: _cols, ...rest } = c;
+            return clone(rest);
+          }),
+          surfaces: [...surfaces.values()].map((s) => clone({ id: s.id, point: s.point, normal: s.normal, halfSize: s.half, tangent: s.t1, porosity: s.porosity })),
+          streams: [...streams.values()].map((s) => clone(s)),
+          taps: [...taps.values()].map((t) => clone(t)),
+          stains: [...stains.values()].map((s) => clone(s))
+        };
+        return snapshot;
+      },
+      load(input) {
+        const snap = clone(input);
+        if (!snap || snap.version !== 1) throw new Error("game-fluids: unsupported snapshot");
+        time = snap.time;
+        rng = new Rng(0);
+        rng.state = snap.rng;
+        counters.container = snap.counters.container;
+        counters.stream = snap.counters.stream;
+        counters.stain = snap.counters.stain;
+        containers = /* @__PURE__ */ new Map();
+        for (const raw of snap.containers) containers.set(raw.id, { ...raw, cols: makeColumns(raw.spec.shape) });
+        surfaces = /* @__PURE__ */ new Map();
+        for (const s of snap.surfaces) world.addSurface(s);
+        counters.tap = snap.counters.tap ?? 0;
+        streams = new Map(snap.streams.map((s) => [s.id, s]));
+        taps = new Map((snap.taps ?? []).map((t) => [t.id, t]));
+        stains = new Map(snap.stains.map((s) => [s.id, s]));
+        queue = [];
+      }
+    };
+    return world;
+  }
+
+  // src/data/item-uses.json
+  var item_uses_default = [
+    {
+      id: "sip",
+      duration: 1.2,
+      keys: [
+        {
+          t: 0,
+          position: [
+            0.22,
+            -0.2,
+            -0.4
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 0.35,
+          position: [
+            0,
+            0.02,
+            -0.2
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 0.45,
+          position: [
+            0,
+            0.02,
+            -0.2
+          ],
+          rotation: [
+            -0.9,
+            0,
+            0
+          ],
+          action: "drink",
+          rate: 0.06
+        },
+        {
+          t: 0.95,
+          position: [
+            0,
+            0.02,
+            -0.2
+          ],
+          rotation: [
+            -0.9,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 1.2,
+          position: [
+            0.22,
+            -0.2,
+            -0.4
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        }
+      ]
+    },
+    {
+      id: "drink",
+      duration: 2.5,
+      keys: [
+        {
+          t: 0,
+          position: [
+            0.22,
+            -0.2,
+            -0.4
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 0.5,
+          position: [
+            0,
+            0.02,
+            -0.2
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 0.8,
+          position: [
+            0,
+            0.02,
+            -0.2
+          ],
+          rotation: [
+            -1.22,
+            0,
+            0
+          ],
+          action: "drink",
+          rate: 0.1667
+        },
+        {
+          t: 2,
+          position: [
+            0,
+            0.02,
+            -0.2
+          ],
+          rotation: [
+            -1.22,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 2.5,
+          position: [
+            0.22,
+            -0.2,
+            -0.4
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        }
+      ]
+    },
+    {
+      id: "chug",
+      duration: 4,
+      keys: [
+        {
+          t: 0,
+          position: [
+            0.22,
+            -0.2,
+            -0.4
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 0.5,
+          position: [
+            0,
+            0.02,
+            -0.2
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 0.9,
+          position: [
+            0,
+            0.02,
+            -0.2
+          ],
+          rotation: [
+            -1.45,
+            0,
+            0
+          ],
+          action: "drink",
+          rate: 0.2
+        },
+        {
+          t: 3.4,
+          position: [
+            0,
+            0.02,
+            -0.2
+          ],
+          rotation: [
+            -1.45,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 4,
+          position: [
+            0.22,
+            -0.2,
+            -0.4
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        }
+      ]
+    },
+    {
+      id: "pour",
+      duration: 3,
+      keys: [
+        {
+          t: 0,
+          position: [
+            0.22,
+            -0.2,
+            -0.4
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 0.4,
+          position: [
+            0.1,
+            0,
+            -0.35
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 0.8,
+          position: [
+            0.1,
+            0,
+            -0.35
+          ],
+          rotation: [
+            -1.745,
+            0,
+            0
+          ],
+          action: "pour",
+          rate: 1
+        },
+        {
+          t: 2.4,
+          position: [
+            0.1,
+            0,
+            -0.35
+          ],
+          rotation: [
+            -1.745,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 3,
+          position: [
+            0.22,
+            -0.2,
+            -0.4
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        }
+      ]
+    },
+    {
+      id: "pour_out",
+      duration: 4,
+      keys: [
+        {
+          t: 0,
+          position: [
+            0.22,
+            -0.2,
+            -0.4
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 0.5,
+          position: [
+            0.1,
+            0.1,
+            -0.35
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 1,
+          position: [
+            0.1,
+            0.1,
+            -0.35
+          ],
+          rotation: [
+            -2.2,
+            0,
+            0
+          ],
+          action: "pour",
+          rate: 40
+        },
+        {
+          t: 3.2,
+          position: [
+            0.1,
+            0.1,
+            -0.35
+          ],
+          rotation: [
+            -2.2,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 4,
+          position: [
+            0.22,
+            -0.2,
+            -0.4
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        }
+      ]
+    },
+    {
+      id: "open",
+      duration: 1,
+      keys: [
+        {
+          t: 0,
+          position: [
+            0.22,
+            -0.2,
+            -0.4
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 0.25,
+          position: [
+            0.1,
+            0,
+            -0.3
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "open"
+        },
+        {
+          t: 0.7,
+          position: [
+            0.1,
+            0,
+            -0.3
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 1,
+          position: [
+            0.22,
+            -0.2,
+            -0.4
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        }
+      ]
+    },
+    {
+      id: "close",
+      duration: 1,
+      keys: [
+        {
+          t: 0,
+          position: [
+            0.22,
+            -0.2,
+            -0.4
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 0.25,
+          position: [
+            0.1,
+            0,
+            -0.3
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "close"
+        },
+        {
+          t: 0.7,
+          position: [
+            0.1,
+            0,
+            -0.3
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        },
+        {
+          t: 1,
+          position: [
+            0.22,
+            -0.2,
+            -0.4
+          ],
+          rotation: [
+            0,
+            0,
+            0
+          ],
+          action: "none"
+        }
+      ]
+    }
+  ];
+
+  // src/item-use.ts
+  var ITEM_USES = item_uses_default;
+  var DEFAULT_DRINK_RATE = 0.1;
+  function createItemUse(world, containerId, def, getHandTransform) {
+    const keys = [...def.keys].sort((a, b) => a.t - b.t);
+    let time = 0;
+    let done = keys.length === 0 || def.duration <= 0;
+    let checked = false;
+    let lastPos = null;
+    const fired = /* @__PURE__ */ new Set();
+    const pose = () => {
+      if (keys.length === 0) return { position: [0, 0, 0], rotation: [0, 0, 0] };
+      if (time <= keys[0].t) return { position: [...keys[0].position], rotation: [...keys[0].rotation] };
+      for (let i = 0; i < keys.length - 1; i++) {
+        const a = keys[i];
+        const b = keys[i + 1];
+        if (time <= b.t) {
+          const k = b.t > a.t ? (time - a.t) / (b.t - a.t) : 1;
+          return { position: lerp3(a.position, b.position, k), rotation: lerp3(a.rotation, b.rotation, k) };
+        }
+      }
+      const last = keys[keys.length - 1];
+      return { position: [...last.position], rotation: [...last.rotation] };
+    };
+    const follow = (dt) => {
+      if (!getHandTransform) return;
+      const hand = getHandTransform();
+      const p = pose();
+      const position = add(hand.position, quatRotate(hand.rotation, p.position));
+      const rotation = quatMultiply(hand.rotation, quatFromEuler(p.rotation[0], p.rotation[1], p.rotation[2]));
+      const velocity = lastPos && dt > 0 ? [(position[0] - lastPos[0]) / dt, (position[1] - lastPos[1]) / dt, (position[2] - lastPos[2]) / dt] : void 0;
+      lastPos = position;
+      world.setTransform(containerId, position, rotation, velocity);
+    };
+    const player = {
+      def,
+      get time() {
+        return time;
+      },
+      get done() {
+        return done;
+      },
+      pose,
+      update(dt) {
+        if (done) return [];
+        const events = [];
+        const off = world.on("*", (e) => events.push(e));
+        try {
+          if (!checked) {
+            checked = true;
+            const state = world.container(containerId);
+            if (!state || def.liquids && def.liquids.length > 0 && (!state.liquid || !def.liquids.includes(state.liquid))) {
+              done = true;
+              return events;
+            }
+          }
+          const start = time;
+          const end = Math.min(def.duration, time + Math.max(0, dt));
+          for (let i = 0; i < keys.length && !done; i++) {
+            const key = keys[i];
+            const spanStart = key.t;
+            const spanEnd = i + 1 < keys.length ? keys[i + 1].t : def.duration;
+            if ((key.action === "open" || key.action === "close") && !fired.has(i) && end >= spanStart) {
+              fired.add(i);
+              if (key.action === "open") world.open(containerId);
+              else world.close(containerId);
+            }
+            const overlap = Math.min(end, spanEnd) - Math.max(start, spanStart);
+            if (overlap <= 0) continue;
+            if (key.action === "drink") {
+              const ev = world.drink(containerId, (key.rate ?? DEFAULT_DRINK_RATE) * overlap);
+              const left = world.container(containerId);
+              if (!ev || !left || left.liters <= 1e-6) {
+                time = def.duration;
+                done = true;
+              }
+            } else if (key.action === "pour") {
+              world.pour(containerId, overlap * (key.rate ?? 1));
+            }
+          }
+          if (!done) {
+            time = end;
+            done = time >= def.duration;
+          }
+          follow(dt);
+        } finally {
+          off();
+        }
+        return events;
+      },
+      cancel() {
+        done = true;
+      }
+    };
+    return player;
+  }
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map