@adatechnology/game-fluids 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,2184 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// 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;
+}
+export {
+  ITEM_USES,
+  LIQUIDS,
+  SAMPLES as STAIN_SAMPLES,
+  ballistic,
+  createFluids,
+  createItemUse,
+  describeEvent,
+  locales,
+  resolveStrings,
+  sampleStream,
+  stainDirection
+};
+//# sourceMappingURL=index.js.map