@nayan-ui/engine 1.0.0-beta.5 → 1.0.0-beta.6

package/lib/web/index.js

@@ -53,6 +53,12 @@ function restore_asset_record(name, bytes) {
   const ret = wasm.restore_asset_record(ptr0, len0, ptr1, len1);
   return ret !== 0;
 }
+function speech_request(command) {
+  const ptr0 = passStringToWasm0(command, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.speech_request(ptr0, len0);
+  return takeObject(ret);
+}
 function __wbg_get_imports() {
   const import0 = {
     __proto__: null,
@@ -238,6 +244,9 @@ function __wbg_get_imports() {
         return addHeapObject(ret);
       }, arguments);
     },
+    __wbg_cancel_fa9c526b1bfea1fa: function(arg0) {
+      getObject(arg0).cancel();
+    },
     __wbg_clearBufferfv_05f7fc7252e623eb: function(arg0, arg1, arg2, arg3, arg4) {
       getObject(arg0).clearBufferfv(arg1 >>> 0, arg2, getArrayF32FromWasm0(arg3, arg4));
     },
@@ -762,6 +771,10 @@ function __wbg_get_imports() {
       const ret = getObject(arg0).getUniformLocation(getObject(arg1), getStringFromWasm0(arg2, arg3));
       return isLikeNone(ret) ? 0 : addHeapObject(ret);
     },
+    __wbg_getVoices_a94654c567778a75: function(arg0) {
+      const ret = getObject(arg0).getVoices();
+      return addHeapObject(ret);
+    },
     __wbg_get_31af05bd4842a84f: function() {
       return handleError(function(arg0, arg1) {
         const ret = Reflect.get(getObject(arg0), getObject(arg1));
@@ -862,6 +875,13 @@ function __wbg_get_imports() {
       getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
       getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     },
+    __wbg_lang_124ac9807c8fd7c7: function(arg0, arg1) {
+      const ret = getObject(arg1).lang;
+      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
     __wbg_length_7f3c00c40364105e: function(arg0) {
       const ret = getObject(arg0).length;
       return ret;
@@ -1025,6 +1045,13 @@ function __wbg_get_imports() {
       const ret = getObject(arg0).minUniformBufferOffsetAlignment;
       return ret;
     },
+    __wbg_name_73552c55bcab8bef: function(arg0, arg1) {
+      const ret = getObject(arg1).name;
+      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
     __wbg_navigator_2156486643462a87: function(arg0) {
       const ret = getObject(arg0).navigator;
       return addHeapObject(ret);
@@ -1037,6 +1064,24 @@ function __wbg_get_imports() {
       const ret = new Uint8Array(getObject(arg0));
       return addHeapObject(ret);
     },
+    __wbg_new_5502aad30c185fc8: function(arg0, arg1) {
+      try {
+        var state0 = { a: arg0, b: arg1 };
+        var cb0 = (arg0, arg1) => {
+          const a = state0.a;
+          state0.a = 0;
+          try {
+            return __wasm_bindgen_func_elem_10645(a, state0.b, arg0, arg1);
+          } finally {
+            state0.a = a;
+          }
+        };
+        const ret = new Promise(cb0);
+        return addHeapObject(ret);
+      } finally {
+        state0.a = 0;
+      }
+    },
     __wbg_new_617a8cdb8bb1130e: function() {
       const ret = new Object;
       return addHeapObject(ret);
@@ -1066,7 +1111,7 @@ function __wbg_get_imports() {
           const a = state0.a;
           state0.a = 0;
           try {
-            return __wasm_bindgen_func_elem_9779(a, state0.b, arg0, arg1);
+            return __wasm_bindgen_func_elem_10645(a, state0.b, arg0, arg1);
           } finally {
             state0.a = a;
           }
@@ -1081,6 +1126,12 @@ function __wbg_get_imports() {
       const ret = new Uint8Array(arg0 >>> 0);
       return addHeapObject(ret);
     },
+    __wbg_new_with_text_de120aa95bd08db1: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = new SpeechSynthesisUtterance(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+      }, arguments);
+    },
     __wbg_now_aa4ccb83129e9e55: function() {
       const ret = Date.now();
       return ret;
@@ -1093,6 +1144,13 @@ function __wbg_get_imports() {
       const ret = getObject(arg0).onSubmittedWorkDone();
       return addHeapObject(ret);
     },
+    __wbg_pause_b7da1d13ff23f1f3: function(arg0) {
+      getObject(arg0).pause();
+    },
+    __wbg_pending_decfa19ee64ef69d: function(arg0) {
+      const ret = getObject(arg0).pending;
+      return ret;
+    },
     __wbg_pixelStorei_af18e636b3e7b725: function(arg0, arg1, arg2) {
       getObject(arg0).pixelStorei(arg1 >>> 0, arg2);
     },
@@ -1177,6 +1235,9 @@ function __wbg_get_imports() {
       const ret = Promise.resolve(getObject(arg0));
       return addHeapObject(ret);
     },
+    __wbg_resume_8132df443cbde759: function(arg0) {
+      getObject(arg0).resume();
+    },
     __wbg_samplerParameterf_2d62cb907392e2d6: function(arg0, arg1, arg2, arg3) {
       getObject(arg0).samplerParameterf(getObject(arg1), arg2 >>> 0, arg3);
     },
@@ -1206,6 +1267,12 @@ function __wbg_get_imports() {
     __wbg_setPipeline_b6f981027e02cd16: function(arg0, arg1) {
       getObject(arg0).setPipeline(getObject(arg1));
     },
+    __wbg_setTimeout_db7bbc18a17e152a: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).setTimeout(getObject(arg1), arg2);
+        return ret;
+      }, arguments);
+    },
     __wbg_setVertexBuffer_6db3b60e99280744: function(arg0, arg1, arg2, arg3) {
       getObject(arg0).setVertexBuffer(arg1 >>> 0, getObject(arg2), arg3);
     },
@@ -1470,6 +1537,9 @@ function __wbg_get_imports() {
     __wbg_set_label_ee172cd5f6a96961: function(arg0, arg1, arg2) {
       getObject(arg0).label = getStringFromWasm0(arg1, arg2);
     },
+    __wbg_set_lang_fdb29fe7a7f6b538: function(arg0, arg1, arg2) {
+      getObject(arg0).lang = getStringFromWasm0(arg1, arg2);
+    },
     __wbg_set_layout_454e3a091b390cd4: function(arg0, arg1) {
       getObject(arg0).layout = getObject(arg1);
     },
@@ -1554,6 +1624,9 @@ function __wbg_get_imports() {
     __wbg_set_pass_op_3cf10feb3d76ab97: function(arg0, arg1) {
       getObject(arg0).passOp = __wbindgen_enum_GpuStencilOperation[arg1];
     },
+    __wbg_set_pitch_793c4498ea6e6817: function(arg0, arg1) {
+      getObject(arg0).pitch = arg1;
+    },
     __wbg_set_power_preference_b42d00a8facfbade: function(arg0, arg1) {
       getObject(arg0).powerPreference = __wbindgen_enum_GpuPowerPreference[arg1];
     },
@@ -1566,6 +1639,9 @@ function __wbg_get_imports() {
     __wbg_set_r_6ece4d74af63364f: function(arg0, arg1) {
       getObject(arg0).r = arg1;
     },
+    __wbg_set_rate_caba1c2a5e041669: function(arg0, arg1) {
+      getObject(arg0).rate = arg1;
+    },
     __wbg_set_required_features_bbab71414c45e621: function(arg0, arg1, arg2) {
       getObject(arg0).requiredFeatures = getArrayJsValueViewFromWasm0(arg1, arg2);
     },
@@ -1710,6 +1786,12 @@ function __wbg_get_imports() {
     __wbg_set_visibility_d8a6821789538c25: function(arg0, arg1) {
       getObject(arg0).visibility = arg1 >>> 0;
     },
+    __wbg_set_voice_3e1a3ef98a8d5ecd: function(arg0, arg1) {
+      getObject(arg0).voice = getObject(arg1);
+    },
+    __wbg_set_volume_d84050ffb0189f47: function(arg0, arg1) {
+      getObject(arg0).volume = arg1;
+    },
     __wbg_set_width_0ca908d167690992: function(arg0, arg1) {
       getObject(arg0).width = arg1 >>> 0;
     },
@@ -1737,6 +1819,19 @@ function __wbg_get_imports() {
     __wbg_shaderSource_c8812639b47d87b9: function(arg0, arg1, arg2, arg3) {
       getObject(arg0).shaderSource(getObject(arg1), getStringFromWasm0(arg2, arg3));
     },
+    __wbg_speak_0522b6116a03fd31: function(arg0, arg1) {
+      getObject(arg0).speak(getObject(arg1));
+    },
+    __wbg_speaking_bbf159df39686677: function(arg0) {
+      const ret = getObject(arg0).speaking;
+      return ret;
+    },
+    __wbg_speechSynthesis_9178be485e9e2ef1: function() {
+      return handleError(function(arg0) {
+        const ret = getObject(arg0).speechSynthesis;
+        return addHeapObject(ret);
+      }, arguments);
+    },
     __wbg_static_accessor_GLOBAL_266715b9d96ba635: function() {
       const ret = typeof global === "undefined" ? null : global;
       return isLikeNone(ret) ? 0 : addHeapObject(ret);
@@ -2054,6 +2149,13 @@ function __wbg_get_imports() {
     __wbg_viewport_e35d16c542d2ce70: function(arg0, arg1, arg2, arg3, arg4) {
       getObject(arg0).viewport(arg1, arg2, arg3, arg4);
     },
+    __wbg_voiceURI_85f8d4604a52970f: function(arg0, arg1) {
+      const ret = getObject(arg1).voiceURI;
+      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
     __wbg_width_3d0dce3d9892e35e: function(arg0) {
       const ret = getObject(arg0).width;
       return ret;
@@ -2069,23 +2171,23 @@ function __wbg_get_imports() {
       }, arguments);
     },
     __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_9777);
+      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_10643);
       return addHeapObject(ret);
     },
     __wbindgen_generic_0000000000000002: function(arg0, arg1) {
-      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2414);
+      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_3241);
       return addHeapObject(ret);
     },
     __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2415);
+      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_3242);
       return addHeapObject(ret);
     },
     __wbindgen_generic_0000000000000004: function(arg0, arg1) {
-      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2414_9);
+      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_3241_10);
       return addHeapObject(ret);
     },
     __wbindgen_generic_0000000000000005: function(arg0, arg1) {
-      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2414_10);
+      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_3241_11);
       return addHeapObject(ret);
     },
     __wbindgen_generic_0000000000000006: function(arg0) {
@@ -2138,16 +2240,16 @@ function __wbg_get_imports() {
     "./snippets/engine-core-64626f8edd8232bb/inline0.js": exports_inline0
   };
 }
-function __wasm_bindgen_func_elem_2415(arg0, arg1, arg2) {
-  wasm.__wasm_bindgen_func_elem_2415(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_3242(arg0, arg1, arg2) {
+  wasm.__wasm_bindgen_func_elem_3242(arg0, arg1, addHeapObject(arg2));
 }
-function __wasm_bindgen_func_elem_9779(arg0, arg1, arg2, arg3) {
-  wasm.__wasm_bindgen_func_elem_9779(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_10645(arg0, arg1, arg2, arg3) {
+  wasm.__wasm_bindgen_func_elem_10645(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
-function __wasm_bindgen_func_elem_9777(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_10643(arg0, arg1, arg2) {
   try {
     const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-    wasm.__wasm_bindgen_func_elem_9777(retptr, arg0, arg1, addHeapObject(arg2));
+    wasm.__wasm_bindgen_func_elem_10643(retptr, arg0, arg1, addHeapObject(arg2));
     var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
     var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
     if (r1) {
@@ -2157,10 +2259,10 @@ function __wasm_bindgen_func_elem_9777(arg0, arg1, arg2) {
     wasm.__wbindgen_add_to_stack_pointer(16);
   }
 }
-function __wasm_bindgen_func_elem_2414(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_3241(arg0, arg1, arg2) {
   try {
     const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-    wasm.__wasm_bindgen_func_elem_2414(retptr, arg0, arg1, addHeapObject(arg2));
+    wasm.__wasm_bindgen_func_elem_3241(retptr, arg0, arg1, addHeapObject(arg2));
     var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
     var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
     if (r1) {
@@ -2170,10 +2272,10 @@ function __wasm_bindgen_func_elem_2414(arg0, arg1, arg2) {
     wasm.__wbindgen_add_to_stack_pointer(16);
   }
 }
-function __wasm_bindgen_func_elem_2414_9(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_3241_10(arg0, arg1, arg2) {
   try {
     const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-    wasm.__wasm_bindgen_func_elem_2414_9(retptr, arg0, arg1, addHeapObject(arg2));
+    wasm.__wasm_bindgen_func_elem_3241_10(retptr, arg0, arg1, addHeapObject(arg2));
     var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
     var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
     if (r1) {
@@ -2183,10 +2285,10 @@ function __wasm_bindgen_func_elem_2414_9(arg0, arg1, arg2) {
     wasm.__wbindgen_add_to_stack_pointer(16);
   }
 }
-function __wasm_bindgen_func_elem_2414_10(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_3241_11(arg0, arg1, arg2) {
   try {
     const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-    wasm.__wasm_bindgen_func_elem_2414_10(retptr, arg0, arg1, addHeapObject(arg2));
+    wasm.__wasm_bindgen_func_elem_3241_11(retptr, arg0, arg1, addHeapObject(arg2));
     var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
     var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
     if (r1) {
@@ -2723,6 +2825,99 @@ class IndexedDbCache {
   }
 }
 
+// src/media/input.web.ts
+var BLOCK = 2048;
+var MIC_FAILED = -1;
+function installMicrophoneInput(core, bridge) {
+  if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia)
+    return;
+  let permission = 0;
+  let stream = null;
+  let context = null;
+  let failed = false;
+  let session = 0;
+  const startCore = bridge.micStart;
+  const stopCore = bridge.micStop;
+  const stateCore = bridge.micState;
+  const allocate = core.engine_web_alloc;
+  const push = core.engine_audio_mic_push;
+  let pointer = 0;
+  navigator.permissions?.query({ name: "microphone" }).then((status) => {
+    const read = () => {
+      permission = status.state === "granted" ? 1 : status.state === "denied" ? -1 : 0;
+    };
+    read();
+    status.onchange = read;
+  }).catch(() => {});
+  const open = async () => {
+    stream ??= await navigator.mediaDevices.getUserMedia({
+      audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true, channelCount: 1 }
+    });
+    permission = 1;
+    return stream;
+  };
+  const close = () => {
+    stream?.getTracks().forEach((track) => track.stop());
+    stream = null;
+    context?.close().catch(() => {});
+    context = null;
+  };
+  bridge.micPermission = () => permission;
+  bridge.micRequestPermission = async () => {
+    try {
+      await open();
+      return true;
+    } catch {
+      permission = -1;
+      return false;
+    }
+  };
+  bridge.micStart = (maxSeconds) => {
+    session++;
+    const current = session;
+    close();
+    failed = false;
+    if (!startCore(maxSeconds))
+      return false;
+    (async () => {
+      const input = await open();
+      const audio = new AudioContext;
+      context = audio;
+      await audio.audioWorklet.addModule(new URL("./audio-worklet.js", import.meta.url));
+      if (current !== session)
+        return audio.close();
+      const node = new AudioWorkletNode(audio, "nayan-microphone", { numberOfInputs: 1, numberOfOutputs: 1 });
+      const muted = audio.createGain();
+      muted.gain.value = 0;
+      audio.createMediaStreamSource(input).connect(node).connect(muted).connect(audio.destination);
+      pointer ||= allocate(BLOCK * 4);
+      node.port.onmessage = ({ data }) => {
+        if (current !== session)
+          return;
+        new Float32Array(core.memory.buffer, pointer, data.length).set(data);
+        push(pointer, data.length, audio.sampleRate);
+      };
+      await audio.resume();
+    })().catch(() => {
+      if (current !== session)
+        return;
+      failed = true;
+      if (permission === 0)
+        permission = -1;
+      stopCore();
+      close();
+    });
+    return true;
+  };
+  bridge.micStop = () => {
+    session++;
+    failed = false;
+    stopCore();
+    close();
+  };
+  bridge.micState = () => failed ? MIC_FAILED : stateCore();
+}
+
 // src/media/output.web.ts
 function installAudioOutput(core) {
   if (typeof window === "undefined")
@@ -2940,6 +3135,16 @@ function createBrowserEngine(core) {
       end++;
     return decoder.decode(b.subarray(pointer, end));
   };
+  const text = (index, value) => {
+    const b = encoder.encode(value);
+    return [put(index, b), b.length];
+  };
+  const readDoubles = (read) => {
+    const count = read(0, 0);
+    const out = zeroed(2, Math.max(8, count * 8));
+    read(out, count);
+    return copy(out, count * 8);
+  };
   const geometry = (handle) => {
     try {
       const error = cString(fn("geometry_error", handle));
@@ -3173,6 +3378,18 @@ function createBrowserEngine(core) {
       const [x, y, z] = dimensions("model_size", mesh, 3, true);
       return [x, y, z];
     },
+    bakeKept(key) {
+      const [k, length] = text(0, key);
+      return fn("bake_kept", k, length) !== 0;
+    },
+    modelBake(mesh, spec) {
+      const [s, length] = text(0, spec);
+      const out = zeroed(1, 16);
+      if (!fn("model_bake", mesh, s, length, out))
+        return [];
+      const [texture, x, y, extent] = new Float32Array(u8().slice(out, out + 16).buffer);
+      return [texture, x, y, extent];
+    },
     modelLoadAsync(value, center, fit) {
       return settle(() => engine.modelLoad(value, center, fit));
     },
@@ -3287,6 +3504,14 @@ function createBrowserEngine(core) {
       const buckets = source(4, ranges);
       ex("render_overlay")(surface, m, c, r, capacity, buckets, ranges.byteLength / 4, count, width, height);
     },
+    renderBackdrop(surface, matrices, colors, regions, ranges, count) {
+      const capacity = Math.min(buf(matrices).byteLength / MATRIX_BYTES, buf(colors).byteLength / VEC4_BYTES, buf(regions).byteLength / VEC4_BYTES);
+      const m = source(1, matrices);
+      const c = source(2, colors);
+      const r = source(3, regions);
+      const buckets = source(4, ranges);
+      ex("render_backdrop")(surface, m, c, r, capacity, buckets, ranges.byteLength / 4, count);
+    },
     renderError: () => string("render_error"),
     renderBackend: () => string("render_backend"),
     drawingCreate: (width, height, ratio) => fn("drawing_create", width, height, ratio),
@@ -3327,10 +3552,100 @@ function createBrowserEngine(core) {
       fn("audio_set_muted", +muted);
     },
     audioIsRunning: () => fn("audio_is_running") !== 0,
+    audioRelease(sound) {
+      fn("audio_release", sound);
+    },
+    audioDuration: (sound) => fn("audio_duration", sound),
+    audioLevels(sound, perSecond) {
+      const count = fn("audio_levels", sound, perSecond, 0, 0);
+      if (!count)
+        return new ArrayBuffer(0);
+      const p = zeroed(0, count * 4);
+      fn("audio_levels", sound, perSecond, p, count);
+      return copy(p, count * 4);
+    },
+    micPermission: () => 0,
+    micRequestPermission: () => Promise.resolve(false),
+    micStart: (maxSeconds) => fn("audio_mic_start", maxSeconds) !== 0,
+    micStop() {
+      fn("audio_mic_stop");
+    },
+    micState: () => fn("audio_mic_state"),
+    micLevel: () => fn("audio_mic_level"),
+    micHeld: () => fn("audio_mic_held"),
+    micTake: (seconds, skipEnd) => fn("audio_mic_take", seconds, skipEnd),
     hapticsSupported: () => fn("haptics_supported") !== 0,
     hapticsPlay(taps, throttle) {
       const p = put(0, new Uint8Array(new Float32Array(taps).buffer));
       fn("haptics_play", p, taps.length / 3, +throttle);
+    },
+    worldgenBuild: (recipe, key, prepareTerrain) => {
+      const [r, rl] = text(0, recipe);
+      const [k, kl] = text(1, key);
+      return fn("worldgen_build", r, rl, k, kl, +prepareTerrain) >>> 0;
+    },
+    worldgenBuildAsync: async (recipe, key, prepareTerrain) => engine.worldgenBuild(recipe, key, prepareTerrain),
+    worldgenError: () => string("worldgen_error"),
+    worldgenKept(key) {
+      const [k, kl] = text(0, key);
+      return fn("worldgen_kept", k, kl) !== 0;
+    },
+    worldgenFree(world) {
+      fn("worldgen_free", world);
+    },
+    worldgenInfo: (world) => string("worldgen_info", [world]),
+    worldgenLayer(world, name) {
+      const [n, nl] = text(1, name);
+      return readDoubles((out, capacity) => fn("worldgen_layer", world, n, nl, out, capacity));
+    },
+    worldgenReachable: (world) => readDoubles((out, capacity) => fn("worldgen_reachable", world, out, capacity)),
+    worldgenOverview(world) {
+      const count = fn("worldgen_overview", world, 0, 0);
+      const out = zeroed(0, Math.max(1, count));
+      fn("worldgen_overview", world, out, count);
+      return copy(out, count);
+    },
+    worldgenPick: (world, run) => fn("worldgen_pick", world, run) !== 0,
+    worldgenTerrain: (world, material) => geometry(fn("worldgen_terrain", world, material)),
+    worldgenMesh(recipe) {
+      const [r, rl] = text(0, recipe);
+      return geometry(fn("worldgen_mesh", r, rl));
+    },
+    worldgenPaint(vertices, recipe) {
+      const [v] = data(vertices);
+      const [r, rl] = text(1, recipe);
+      const ok = fn("worldgen_paint", v, bytes(vertices).length / 44, r, rl) !== 0;
+      if (ok)
+        bytes(vertices).set(u8().subarray(v, v + vertices.byteLength));
+      return ok;
+    },
+    worldgenGround: (world, x, z) => fn("worldgen_ground", world, x, z),
+    worldgenSurface: (world, x, z) => fn("worldgen_surface", world, x, z),
+    worldgenPlatform: (world, x, z) => fn("worldgen_platform", world, x, z),
+    worldgenWalkable: (world, x, z, radius) => fn("worldgen_walkable", world, x, z, radius) !== 0,
+    worldgenClearance: (world, x, z, radius) => fn("worldgen_clearance", world, x, z, radius),
+    worldgenSolidClearance: (world, x, z, radius, bottom, top) => fn("worldgen_solid_clearance", world, x, z, radius, bottom, top),
+    worldgenFieldIndex(world, name) {
+      const [n, nl] = text(0, name);
+      return fn("worldgen_field_index", world, n, nl);
+    },
+    worldgenField: (world, field, x, z) => fn("worldgen_field", world, field, x, z),
+    worldgenTilt(world, x, z, yaw) {
+      const out = zeroed(0, 32);
+      fn("worldgen_tilt", world, x, z, yaw, out);
+      const at = out >> 3;
+      const q = f64();
+      return [q[at], q[at + 1], q[at + 2], q[at + 3]];
+    },
+    worldgenSight: (world, ax, az, bx, bz, radius, step, rise) => fn("worldgen_sight", world, ax, az, bx, bz, radius, step, rise) !== 0,
+    worldgenMove(world, x, z, dx, dz, radius, bodies) {
+      const list = bytes(bodies);
+      const b = put(1, list);
+      const p = zeroed(0, 16);
+      f64().set([x, z], p >> 3);
+      fn("worldgen_move", world, p, dx, dz, radius, b, Math.floor(list.byteLength / 24));
+      const q = f64();
+      return [q[p >> 3], q[(p >> 3) + 1]];
     }
   };
   return engine;
@@ -3351,6 +3666,7 @@ function prepareEngine() {
     } catch {}
     const ready = createBrowserEngine(core);
     ready.audioIsRunning = installAudioOutput(core);
+    installMicrophoneInput(core, ready);
     Object.assign(browser, ready);
   })().catch((error) => {
     pending = undefined;
@@ -3619,50 +3935,6 @@ var SHAPE_MESH = {
 
 // src/render/meshes.ts
 var VERTEX_FLOATS = 11;
-
-class Builder {
-  vertices = [];
-  indices = [];
-  vertex(p, n, u, v) {
-    this.vertices.push(p[0], p[1], p[2], n[0], n[1], n[2], 1, 1, 1, u, v);
-    return this.vertices.length / VERTEX_FLOATS - 1;
-  }
-  quad(a, b, c, d) {
-    this.indices.push(a, b, c, a, c, d);
-  }
-  grid(rows, cols, at) {
-    const first = this.vertices.length / VERTEX_FLOATS;
-    for (let i = 0;i <= rows; i++) {
-      for (let j = 0;j <= cols; j++) {
-        const [p, n] = at(j / cols, i / rows);
-        this.vertex(p, n, j / cols, i / rows);
-      }
-    }
-    for (let i = 0;i < rows; i++) {
-      for (let j = 0;j < cols; j++) {
-        const a = first + i * (cols + 1) + j;
-        const b = a + cols + 1;
-        this.indices.push(a, b, a + 1, a + 1, b, b + 1);
-      }
-    }
-  }
-  disc(y, radius, facing, segments) {
-    const center = this.vertex([0, y, 0], [0, facing, 0], 0.5, 0.5);
-    const first = center + 1;
-    for (let j = 0;j <= segments; j++) {
-      const t = j / segments * TAU;
-      const x = Math.cos(t);
-      const z = Math.sin(t);
-      this.vertex([x * radius, y, z * radius], [0, facing, 0], 0.5 + x / 2, 0.5 + z / 2);
-    }
-    for (let j = 0;j < segments; j++) {
-      if (facing === 1)
-        this.indices.push(center, first + j + 1, first + j);
-      else
-        this.indices.push(center, first + j, first + j + 1);
-    }
-  }
-}
 var TAU = Math.PI * 2;
 var registered = new Map;
 var idLimit = 16;
@@ -3906,36 +4178,6 @@ function layoutText(font, text, align, options = {}) {
   return placed;
 }
 
-// src/assets/texture.ts
-var loader3 = new AssetLoader("loadTexture");
-function loadTexture(source) {
-  return loader3.load(source, (native, bytes) => {
-    const finish = (id) => {
-      if (id < 0)
-        throw new Error(native.loadError() || "not a PNG or JPEG image");
-      const [width, height] = native.textureSize(id);
-      return { id, width, height };
-    };
-    return typeof native.textureLoadAsync === "function" ? native.textureLoadAsync(bytes).then(finish) : finish(native.textureLoad(bytes));
-  });
-}
-var variants = new Map;
-function texturedMesh(mesh, texture) {
-  const key = `${mesh}:${texture.id}`;
-  let id = variants.get(key);
-  if (id === undefined) {
-    const base = meshInfo(mesh);
-    if (!base)
-      throw new Error("texture: this mesh has nothing to draw");
-    id = NativeNayanEngine_web_default.meshAlias(mesh);
-    if (id < 0)
-      throw new Error(`texture: ${NativeNayanEngine_web_default.loadError()}`);
-    registerCoreMesh(id, { texture: texture.id, shine: base.shine }, () => base.geometry);
-    variants.set(key, id);
-  }
-  return id;
-}
-
 // src/world/color.ts
 var HEX = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
 var RGB = /^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*(?:,\s*([\d.]+%?)\s*)?\)$/i;
@@ -4000,6 +4242,77 @@ function resolveColors(colors) {
   return colors.map(resolveColor);
 }
 
+// src/assets/texture.ts
+var loader3 = new AssetLoader("loadTexture");
+function loadTexture(source) {
+  return loader3.load(source, (native, bytes) => {
+    const finish = (id) => {
+      if (id < 0)
+        throw new Error(native.loadError() || "not a PNG or JPEG image");
+      const [width, height] = native.textureSize(id);
+      return { id, width, height };
+    };
+    return typeof native.textureLoadAsync === "function" ? native.textureLoadAsync(bytes).then(finish) : finish(native.textureLoad(bytes));
+  });
+}
+var variants = new Map;
+function texturedMesh(mesh, texture) {
+  const key = `${mesh}:${texture.id}`;
+  let id = variants.get(key);
+  if (id === undefined) {
+    const base = meshInfo(mesh);
+    if (!base)
+      throw new Error("texture: this mesh has nothing to draw");
+    id = NativeNayanEngine_web_default.meshAlias(mesh);
+    if (id < 0)
+      throw new Error(`texture: ${NativeNayanEngine_web_default.loadError()}`);
+    registerCoreMesh(id, { texture: texture.id, shine: base.shine }, () => base.geometry);
+    variants.set(key, id);
+  }
+  return id;
+}
+function bakeModel(model, options) {
+  const mesh = model == null ? -1 : typeof model === "number" ? model : model.id;
+  const native = NativeNayanEngine_web_default;
+  if (typeof native.modelBake !== "function")
+    throw new Error("bakeModel: this app's native core predates baked models: rebuild it");
+  const { light } = options;
+  const lightColor = resolveColor(light.color ?? [1, 1, 1]);
+  const sky = resolveColor(options.background ?? [0, 0, 0]);
+  const spec = {
+    size: Math.max(1, Math.min(1024, Math.round(options.size))),
+    supersample: options.supersample ?? 4,
+    light: light.direction,
+    ambient: light.ambient,
+    lightColor: [lightColor[0], lightColor[1], lightColor[2]],
+    sky: [sky[0], sky[1], sky[2]],
+    shine: options.shine ?? meshInfo(mesh)?.shine ?? 0,
+    padding: options.padding ?? 0.04,
+    parts: options.parts?.map((part) => {
+      const id = typeof part.model === "number" ? part.model : part.model.id;
+      const scale = part.scale ?? 1;
+      const color = resolveColor(part.color ?? [1, 1, 1]);
+      return {
+        mesh: id,
+        position: part.position ?? [0, 0, 0],
+        scale: typeof scale === "number" ? [scale, scale, scale] : scale,
+        color: [color[0], color[1], color[2]],
+        shine: part.shine ?? meshInfo(id)?.shine ?? 0
+      };
+    }),
+    frame: options.frame && [options.frame.center[0], options.frame.center[1], options.frame.extent],
+    key: options.key
+  };
+  const baked = native.modelBake(Math.max(0, mesh), JSON.stringify(spec));
+  if (baked.length !== 4)
+    throw new Error(`bakeModel: ${native.loadError() || "failed"}`);
+  const [texture, x, y, extent] = baked;
+  return { texture: { id: texture, width: spec.size, height: spec.size }, center: [x, y], extent };
+}
+function isBakeKept(key) {
+  return typeof NativeNayanEngine_web_default?.bakeKept === "function" && NativeNayanEngine_web_default.bakeKept(key);
+}
+
 // src/world/desc.ts
 var DESC_LEN = 64;
 var FLAG = {
@@ -4463,6 +4776,9 @@ class World {
   boundsValue = null;
   listenerValue = null;
   updates = 0;
+  backdropValue = null;
+  stills = new Map;
+  stillChanged = false;
   constructor(capacity) {
     this.capacity = capacity;
     if (!NativeNayanEngine_web_default) {
@@ -4491,6 +4807,8 @@ class World {
     return this.disposed ? 0 : this.native.count(this.id);
   }
   spawn(options = {}) {
+    if (options.still)
+      return this.spawnStill(options);
     if (options.parent != null && options.physics != null) {
       throw new Error("World.spawn: attached entities can't have physics (put it on the parent)");
     }
@@ -4523,9 +4841,35 @@ class World {
     }
     return e;
   }
+  get backdrop() {
+    return this.backdropValue;
+  }
+  backdropLayer(capacity = 64) {
+    if (this.disposed)
+      throw new Error("World: used after dispose()");
+    return this.backdropValue ??= new World(capacity);
+  }
+  spawnStill({ still: _, ...options }) {
+    if (options.parent != null || options.physics != null || options.text !== undefined) {
+      throw new Error("World.spawn: a still entity can't be attached or have physics or text");
+    }
+    const layer = this.backdropLayer();
+    const entity = layer.spawn({ pickable: false, ...options });
+    const standIn = this.spawn({ mesh: "none", pickable: false });
+    this.stills.set(standIn, entity);
+    this.stillChanged = true;
+    return standIn;
+  }
   set(e, options) {
     if (this.disposed)
       return false;
+    const still = this.stills.get(e);
+    if (still !== undefined) {
+      if (options.parent != null || options.physics != null)
+        throw new Error("World.set: a still entity can't be attached or have physics");
+      this.stillChanged = true;
+      return this.backdropValue.set(still, options);
+    }
     const text = this.texts.get(e);
     encode(this.desc, options, text ? undefined : this.resolveMesh(options, "set"));
     const ok = this.native.setDesc(this.id, e, this.desc.buffer);
@@ -4573,6 +4917,12 @@ class World {
   despawn(e) {
     if (this.disposed)
       return false;
+    const still = this.stills.get(e);
+    if (still !== undefined) {
+      this.stills.delete(e);
+      this.backdropValue.despawn(still);
+      this.stillChanged = true;
+    }
     const existed = this.native.despawn(this.id, e);
     this.texts.delete(e);
     this.resolveFinished();
@@ -4949,6 +5299,10 @@ class World {
     this.runFallbackTimers(dt);
     if (!this.disposed)
       this.scoreboardValue?.dispatch();
+    if (this.stillChanged && this.backdropValue && !this.disposed) {
+      this.stillChanged = false;
+      this.backdropValue.update(0);
+    }
   }
   forEachCollision(fn) {
     if (this.disposed)
@@ -4973,6 +5327,8 @@ class World {
     this.pending.clear();
     this.timers.clear();
     this.fallbackTimers = [];
+    this.stills.clear();
+    this.backdropValue?.dispose();
     NativeNayanEngine_web_default.destroyWorld(this.id);
   }
 }
@@ -5915,14 +6271,27 @@ function Surface({ surfaceId, style, onSize, onError, touch, onPrimaryAction })
 }
 
 // src/render/quality.ts
-var QUALITIES = ["high", "medium", "low", "lowest"];
 var QUALITY_LEVELS = {
-  high: { maxPixelRatio: 3, samples: 4, shadowSize: 2048, softShadows: true },
-  medium: { maxPixelRatio: 3, samples: 4, shadowSize: 1024, softShadows: true },
-  low: { maxPixelRatio: 3, samples: 1, shadowSize: 1024, softShadows: false },
-  lowest: { maxPixelRatio: 2, samples: 1, shadowSize: 512, softShadows: false }
+  high: { maxPixelRatio: 3, samples: 4, shadows: true, shadowSize: 2048, softShadows: true },
+  medium: { maxPixelRatio: 3, samples: 4, shadows: true, shadowSize: 2048, softShadows: false },
+  low: { maxPixelRatio: 3, samples: 1, shadows: false, shadowSize: 2048, softShadows: true },
+  lowest: { maxPixelRatio: 2, samples: 1, fxaa: true, shadows: false, shadowSize: 2048, softShadows: true, maxPixels: 800000 }
 };
-var SLOW_FRAME_MS = 20;
+var AUTO_STEPS = [
+  { quality: "high" },
+  { quality: "high", maxPixels: 1500000 },
+  { quality: "high", maxPixels: 1100000 },
+  { quality: "medium", maxPixels: 1100000 },
+  { quality: "low", maxPixels: 1100000 },
+  { quality: "lowest" }
+];
+function stepLevel(step) {
+  const level = QUALITY_LEVELS[step.quality];
+  if (!step.maxPixels || level.maxPixels && level.maxPixels <= step.maxPixels)
+    return level;
+  return { ...level, maxPixels: step.maxPixels };
+}
+var SLOW_FRAME_MS = 18.5;
 var VERY_SLOW_FRAME_MS = 30;
 var FAST_FRAME_MS = 17.4;
 var RENDER_SHARE = 0.6;
@@ -5931,7 +6300,42 @@ var SETTLE_MS = 1500;
 var SLOW_SECONDS = 3;
 var VERY_SLOW_SECONDS = 1;
 var FAST_SECONDS = 10;
+var HEADROOM_RENDER_MS = 10;
+var HEADROOM_SECONDS = 2;
 var RELAPSE_MS = 20000;
+function levelPixelRatio(level, screen, width, height) {
+  const ratio = Math.min(screen, level.maxPixelRatio);
+  const area = width * height;
+  if (!level.maxPixels || area <= 0)
+    return ratio;
+  return Math.min(ratio, Math.sqrt(level.maxPixels / area));
+}
+var storeKey = (key) => `quality-step:${key}`;
+var settled = new Map;
+function settledQuality(key, store) {
+  if (!key)
+    return;
+  const known = settled.get(key);
+  if (known !== undefined || typeof store?.cacheRead !== "function")
+    return known;
+  try {
+    const bytes = new Uint8Array(store.cacheRead(storeKey(key)));
+    const step = bytes.length === 1 && bytes[0] < AUTO_STEPS.length ? bytes[0] : undefined;
+    if (step !== undefined)
+      settled.set(key, step);
+    return step;
+  } catch {
+    return;
+  }
+}
+function rememberQuality(key, step, store) {
+  if (!key || settledQuality(key, store) === step)
+    return;
+  settled.set(key, step);
+  try {
+    store?.cacheWrite?.(storeKey(key), new Uint8Array([step]).buffer);
+  } catch {}
+}
 
 class AutoQuality {
   index = 0;
@@ -5942,8 +6346,19 @@ class AutoQuality {
   slow = 0;
   verySlow = 0;
   fast = 0;
+  headroom = 0;
+  constructor(start = 0) {
+    const index = typeof start === "number" ? Math.floor(start) : AUTO_STEPS.findIndex((s) => s.quality === start);
+    this.index = Math.min(Math.max(0, index), AUTO_STEPS.length - 1);
+  }
+  get step() {
+    return this.index;
+  }
   get quality() {
-    return QUALITIES[this.index];
+    return AUTO_STEPS[this.index].quality;
+  }
+  get level() {
+    return stepLevel(AUTO_STEPS[this.index]);
   }
   report(now, frames) {
     if (!this.started)
@@ -5955,24 +6370,35 @@ class AutoQuality {
     this.slow = gpuBound ? this.slow + 1 : 0;
     this.verySlow = gpuBound && frames.frameMs > VERY_SLOW_FRAME_MS ? this.verySlow + 1 : 0;
     this.fast = smooth ? this.fast + 1 : 0;
-    if ((this.slow >= SLOW_SECONDS || this.verySlow >= VERY_SLOW_SECONDS) && this.index < QUALITIES.length - 1) {
+    this.headroom = !gpuBound && frames.renderMs <= HEADROOM_RENDER_MS ? this.headroom + 1 : 0;
+    if ((this.slow >= SLOW_SECONDS || this.verySlow >= VERY_SLOW_SECONDS) && this.index < AUTO_STEPS.length - 1) {
       if (now - this.raisedAt < RELAPSE_MS)
         this.ceiling = Math.max(this.ceiling, this.index + 1);
       this.index++;
       return this.moved(now);
     }
-    if (this.fast >= FAST_SECONDS && this.index > this.ceiling) {
+    if ((this.fast >= FAST_SECONDS || this.headroom >= HEADROOM_SECONDS) && this.index > this.ceiling) {
       this.index--;
       this.raisedAt = now;
       return this.moved(now);
     }
     return false;
   }
+  hold(now) {
+    if (!this.started)
+      this.started = now;
+    this.changed = now;
+    this.slow = 0;
+    this.verySlow = 0;
+    this.fast = 0;
+    this.headroom = 0;
+  }
   moved(now) {
     this.changed = now;
     this.slow = 0;
     this.verySlow = 0;
     this.fast = 0;
+    this.headroom = 0;
     return true;
   }
 }
@@ -5987,7 +6413,7 @@ function median(values) {
 // src/render/GameView.tsx
 import { jsx as jsx2 } from "react/jsx-runtime";
 var DEFAULT_BACKGROUND = [0.04, 0.05, 0.09];
-var FRAME_LEN = 26;
+var FRAME_LEN = 29;
 var WHITE3 = [1, 1, 1];
 var nextSurface = 1;
 var defaultCamera = () => ({
@@ -6078,11 +6504,11 @@ function GameView(props) {
     const threaded = native2.hasFrameClock?.() === true && typeof native2.publishFrame === "function" && typeof native2.startFrames === "function";
     let presentedAt = 0;
     if (autoQuality.current?.source !== source)
-      autoQuality.current = { source, auto: new AutoQuality };
+      autoQuality.current = { source, auto: new AutoQuality(settledQuality(live.current.props.qualityKey, native)) };
     const auto = autoQuality.current.auto;
     const chosen = () => {
       const setting = live.current.props.quality ?? "auto";
-      return setting === "auto" ? auto.quality : setting;
+      return setting === "auto" ? [auto.quality, auto.level] : [setting, QUALITY_LEVELS[setting]];
     };
     const followed = [0, 0, 0];
     const shaken = { eye: [0, 0, 0], target: [0, 0, 0], fov: 1 };
@@ -6111,10 +6537,12 @@ function GameView(props) {
       return Math.min(s.count, end);
     };
     let overlay = null;
+    let backdrop = null;
     let last = 0;
     let frames = 0;
     let fpsStart = 0;
     let updateTime = 0;
+    let publishTime = 0;
     let renderTime = 0;
     const intervals = [];
     const draws = [];
@@ -6143,10 +6571,10 @@ function GameView(props) {
       updateTime += performance.now() - t0;
       follow(camera, source, followed, dt);
       const view = shake(camera, shaken, dt);
-      const quality = chosen();
-      const level = QUALITY_LEVELS[quality];
+      const [quality, level] = chosen();
       const { width, height } = size.current;
-      const ratio = Math.min(pixelRatio(), level.maxPixelRatio);
+      const screenRatio = Math.min(pixelRatio(), level.maxPixelRatio);
+      const ratio = levelPixelRatio(level, pixelRatio(), width, height);
       const f = frameData;
       f.set(view.eye, 0);
       f.set(view.target, 3);
@@ -6154,7 +6582,7 @@ function GameView(props) {
       f[7] = view.ortho ?? 0;
       f.set(light.direction, 8);
       f[11] = light.ambient;
-      f[12] = light.shadows ?? true ? 1 : 0;
+      f[12] = (light.shadows ?? true) !== false && level.shadows ? 1 : 0;
       f[13] = light.shadowExtent ?? 30;
       const lightColor = light.color === undefined ? WHITE3 : resolveColor(light.color);
       f[14] = lightColor[0];
@@ -6165,11 +6593,14 @@ function GameView(props) {
       f[18] = sky[1];
       f[19] = sky[2];
       f[20] = environment.fog;
-      f[21] = Math.round(width * ratio);
-      f[22] = Math.round(height * ratio);
+      f[21] = Math.round(width * screenRatio);
+      f[22] = Math.round(height * screenRatio);
       f[23] = level.samples;
       f[24] = level.shadowSize;
       f[25] = level.softShadows ? 1 : 0;
+      f[26] = screenRatio > 0 ? ratio / screenRatio : 1;
+      f[27] = level.fxaa ? 1 : 0;
+      f[28] = light.shadows === "backdrop" ? 0 : 1;
       const t1 = performance.now();
       if (layer) {
         if (overlay?.source !== layer)
@@ -6179,9 +6610,23 @@ function GameView(props) {
         overlay = null;
         native.renderOverlay(surfaceId, regions.buffer, regions.buffer, regions.buffer, regions.buffer, 0, 0, 0);
       }
+      const backSource = current.backdrop ?? source.backdrop;
+      const back = backSource && !backSource.isDisposed ? backSource : undefined;
+      if (back && typeof native.renderBackdrop === "function") {
+        if (backdrop?.source !== back || backdrop.updates !== (back.updateCount ?? 0)) {
+          if (!back.updateCount && back.update)
+            back.update(0);
+          backdrop = { source: back, updates: back.updateCount ?? 0, regions: wholeRegions(back) };
+          native.renderBackdrop(surfaceId, back.matrices.buffer, back.colors.buffer, backdrop.regions.buffer, back.ranges.buffer, drawn(back));
+        }
+      } else if (backdrop) {
+        backdrop = null;
+        native.renderBackdrop?.(surfaceId, regions.buffer, regions.buffer, regions.buffer, regions.buffer, 0);
+      }
       const render = threaded ? native2.publishFrame : native.renderFrame;
       const rendered = render(surfaceId, f.buffer, source.matrices.buffer, source.colors.buffer, regions.buffer, source.ranges.buffer, drawn(source), viewProj.buffer, source.nativeWorld ?? -1);
       const drawMs = performance.now() - t1;
+      publishTime += drawMs;
       if (!threaded) {
         renderTime += drawMs;
         draws.push(drawMs);
@@ -6207,18 +6652,26 @@ function GameView(props) {
           frameMs = shownFrames > 0 ? Math.max(frameMs, elapsed / shownFrames) : elapsed;
           renderMs = meanRenderMs = nativeMs;
         }
-        auto.report(now, { frameMs, renderMs });
+        if (current.adaptQuality ?? true)
+          auto.report(now, { frameMs, renderMs });
+        else
+          auto.hold(now);
+        if ((current.quality ?? "auto") === "auto")
+          rememberQuality(current.qualityKey, auto.step, native);
         intervals.length = 0;
         draws.length = 0;
         current.onStats?.({
           fps,
           updateMs: updateTime / frames,
+          publishMs: publishTime / frames,
           renderMs: meanRenderMs,
           quality,
+          sceneScale: frameData[26],
           backend: native.renderBackend()
         });
         frames = 0;
         updateTime = 0;
+        publishTime = 0;
         renderTime = 0;
         fpsStart = now;
       }
@@ -6346,6 +6799,9 @@ class ProceduralCache {
     this.revision = revision;
     this.storage = storage;
   }
+  storageKey(key) {
+    return `procedural:${this.revision}:${key}`;
+  }
   get stats() {
     return {
       hits: this.hits,
@@ -6556,6 +7012,322 @@ class ProceduralCache {
     return mapValue(header.value, restored);
   }
 }
+// src/assets/procedural.ts
+class FieldRef {
+  id;
+  constructor(id) {
+    this.id = id;
+  }
+}
+
+class FieldGraph {
+  nodes = [];
+  outputs = {};
+  constants = new Map;
+  inputs = new Map;
+  node(node) {
+    this.nodes.push(node);
+    return new FieldRef(this.nodes.length - 1);
+  }
+  ref(value) {
+    return (value instanceof FieldRef ? value : this.constant(value)).id;
+  }
+  refs(values) {
+    return values.map((v) => this.ref(v));
+  }
+  constant(value) {
+    if (!Number.isFinite(value))
+      throw new Error("FieldGraph: constants must be finite");
+    let ref = this.constants.get(value);
+    if (!ref || Object.is(value, -0) !== Object.is(this.nodes[ref.id]?.value, -0)) {
+      ref = this.node({ op: "const", value });
+      this.constants.set(value, ref);
+    }
+    return ref;
+  }
+  input(name) {
+    let ref = this.inputs.get(name);
+    if (!ref) {
+      ref = this.node({ op: "var", name });
+      this.inputs.set(name, ref);
+    }
+    return ref;
+  }
+  get x() {
+    return this.input("x");
+  }
+  get z() {
+    return this.input("z");
+  }
+  add(a, b) {
+    return this.node({ op: "add", a: this.ref(a), b: this.ref(b) });
+  }
+  sub(a, b) {
+    return this.node({ op: "sub", a: this.ref(a), b: this.ref(b) });
+  }
+  mul(a, b) {
+    return this.node({ op: "mul", a: this.ref(a), b: this.ref(b) });
+  }
+  div(a, b) {
+    return this.node({ op: "div", a: this.ref(a), b: this.ref(b) });
+  }
+  sum(...values) {
+    if (!values.length)
+      return this.constant(0);
+    let total = values[0] instanceof FieldRef ? values[0] : this.constant(values[0]);
+    for (const value of values.slice(1))
+      total = this.add(total, value);
+    return total;
+  }
+  product(...values) {
+    if (!values.length)
+      return this.constant(1);
+    let total = values[0] instanceof FieldRef ? values[0] : this.constant(values[0]);
+    for (const value of values.slice(1))
+      total = this.mul(total, value);
+    return total;
+  }
+  min(...args) {
+    return this.node({ op: "min", args: this.refs(args) });
+  }
+  max(...args) {
+    return this.node({ op: "max", args: this.refs(args) });
+  }
+  neg(a) {
+    return this.node({ op: "neg", a: this.ref(a) });
+  }
+  abs(a) {
+    return this.node({ op: "abs", a: this.ref(a) });
+  }
+  sqrt(a) {
+    return this.node({ op: "sqrt", a: this.ref(a) });
+  }
+  floor(a) {
+    return this.node({ op: "floor", a: this.ref(a) });
+  }
+  square(a) {
+    return this.node({ op: "square", a: this.ref(a) });
+  }
+  sin(a) {
+    return this.node({ op: "sin", a: this.ref(a) });
+  }
+  cos(a) {
+    return this.node({ op: "cos", a: this.ref(a) });
+  }
+  exp(a) {
+    return this.node({ op: "exp", a: this.ref(a) });
+  }
+  pow(a, b) {
+    return this.node({ op: "pow", a: this.ref(a), b: this.ref(b) });
+  }
+  fract(a) {
+    return this.node({ op: "fract", a: this.ref(a) });
+  }
+  noise(x, z, period = 0) {
+    return this.node({ op: "noise", x: this.ref(x), z: this.ref(z), period });
+  }
+  mix(a, b, t) {
+    return this.add(a, this.mul(this.sub(b, a), t));
+  }
+  hypot(...args) {
+    return this.node({ op: "hypot", args: this.refs(args) });
+  }
+  smooth(a) {
+    return this.node({ op: "smooth", a: this.ref(a) });
+  }
+  clamp(a, lo, hi) {
+    return this.node({ op: "clamp", a: this.ref(a), lo: this.ref(lo), hi: this.ref(hi) });
+  }
+  select(test, le, gt) {
+    return this.node({ op: "select", test: this.ref(test), le: this.ref(le), gt: this.ref(gt) });
+  }
+  sines(x, z, base, terms) {
+    return this.node({ op: "sines", x: this.ref(x), z: this.ref(z), base, terms });
+  }
+  bumps(x, z, items, power = 2) {
+    return this.node({ op: "bumps", x: this.ref(x), z: this.ref(z), items, power });
+  }
+  distance(x, z, shapes) {
+    return this.node({ op: "distance", x: this.ref(x), z: this.ref(z), shapes });
+  }
+  falloff(x, z, shapes) {
+    return this.node({ op: "falloff", x: this.ref(x), z: this.ref(z), shapes });
+  }
+  depth(x, z, shapes) {
+    return this.node({ op: "depth", x: this.ref(x), z: this.ref(z), shapes });
+  }
+  output(name, value) {
+    this.outputs[name] = this.ref(value);
+    return name;
+  }
+  toJSON() {
+    return { nodes: this.nodes, outputs: this.outputs };
+  }
+}
+
+class FieldFunction {
+  fields;
+  outputs;
+  constructor(fields, outputs) {
+    this.fields = fields;
+    this.outputs = outputs;
+  }
+  toJSON() {
+    return { fields: this.fields, out: Array.from({ length: this.outputs }, (_, i) => `out${i}`) };
+  }
+}
+function fieldFunction(names, build) {
+  const f = new FieldGraph;
+  const inputs = Object.fromEntries(names.map((name) => [name, f.input(name)]));
+  const result = build(f, inputs);
+  const out = Array.isArray(result) ? result : [result];
+  out.forEach((value, i) => f.output(`out${i}`, value));
+  return new FieldFunction(f, out.length);
+}
+var surfaceColor = (build) => fieldFunction(["u", "v", "x", "y", "z", "nx", "ny", "nz"], build);
+var faceColor = (build) => fieldFunction(["r", "angle"], build);
+var sectionColor = (build) => fieldFunction(["r", "y"], build);
+var surfaceDisplacement = (build) => fieldFunction(["u", "v"], build);
+var engine = () => {
+  const native = NativeNayanEngine_web_default;
+  if (!native)
+    throw new Error("procedural worlds: the native core is not linked into this build");
+  if (typeof native.worldgenBuild !== "function")
+    throw new Error("procedural worlds: this app's native core predates them: rebuild it");
+  return native;
+};
+var recipeText = (recipe) => JSON.stringify(recipe, (_key, value) => value instanceof FieldGraph ? value.toJSON() : value);
+var geometry = (buffers) => ({
+  vertices: new Float32Array(buffers.vertices),
+  indices: new Uint32Array(buffers.indices)
+});
+var spots = (points) => points.map(([x, z]) => ({ x, z }));
+var bodyBuffers = new Map;
+
+class ProceduralWorld {
+  handle;
+  spawn;
+  restored;
+  layers;
+  picks;
+  fields = new Map;
+  disposed = false;
+  constructor(handle) {
+    this.handle = handle;
+    const info = JSON.parse(engine().worldgenInfo(handle));
+    this.spawn = { x: info.spawn[0], z: info.spawn[1] };
+    this.restored = info.restored;
+    this.layers = info.layers;
+    this.picks = Object.fromEntries(Object.entries(info.picks).map(([name, points]) => [name, spots(points)]));
+  }
+  get id() {
+    if (this.disposed)
+      throw new Error("ProceduralWorld: used after dispose");
+    return this.handle;
+  }
+  layer(name) {
+    return new Float64Array(engine().worldgenLayer(this.id, name));
+  }
+  reachable() {
+    return new Float64Array(engine().worldgenReachable(this.id));
+  }
+  overview() {
+    return new Uint8Array(engine().worldgenOverview(this.id));
+  }
+  pick(run) {
+    const native = engine();
+    if (!native.worldgenPick(this.id, run))
+      return false;
+    const info = JSON.parse(native.worldgenInfo(this.id));
+    this.picks = Object.fromEntries(Object.entries(info.picks).map(([name, points]) => [name, spots(points)]));
+    return true;
+  }
+  terrain(material) {
+    return geometry(engine().worldgenTerrain(this.id, material));
+  }
+  ground(x, z) {
+    return engine().worldgenGround(this.id, x, z);
+  }
+  surface(x, z) {
+    return engine().worldgenSurface(this.id, x, z);
+  }
+  platformAt(x, z) {
+    return engine().worldgenPlatform(this.id, x, z);
+  }
+  walkable(x, z, radius) {
+    return engine().worldgenWalkable(this.id, x, z, radius);
+  }
+  clearance(x, z, radius) {
+    return engine().worldgenClearance(this.id, x, z, radius);
+  }
+  solidClearance(x, z, radius, bottom, top) {
+    return engine().worldgenSolidClearance(this.id, x, z, radius, bottom, top);
+  }
+  field(name, x, z) {
+    let index = this.fields.get(name);
+    if (index === undefined) {
+      index = engine().worldgenFieldIndex(this.id, name);
+      if (index < 0)
+        throw new Error(`ProceduralWorld: no field named ${name}`);
+      this.fields.set(name, index);
+    }
+    return engine().worldgenField(this.id, index, x, z);
+  }
+  tilt(x, z, yaw = 0) {
+    return engine().worldgenTilt(this.id, x, z, yaw);
+  }
+  canSee(a, b, { radius = 0.25, step = 0.4, rise = Infinity } = {}) {
+    return engine().worldgenSight(this.id, a.x, a.z, b.x, b.z, radius, step, rise === Infinity ? Number.MAX_VALUE : rise);
+  }
+  move(point, dx, dz, radius, bodies = []) {
+    let buffer = bodyBuffers.get(bodies.length);
+    if (!buffer)
+      bodyBuffers.set(bodies.length, buffer = new Float64Array(bodies.length * 3));
+    for (let i = 0;i < bodies.length; i++) {
+      const b = bodies[i];
+      buffer[i * 3] = b.x;
+      buffer[i * 3 + 1] = b.z;
+      buffer[i * 3 + 2] = b.radius;
+    }
+    const [x, z] = engine().worldgenMove(this.id, point.x, point.z, dx, dz, radius, buffer.buffer);
+    point.x = x;
+    point.z = z;
+  }
+  dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    engine().worldgenFree(this.handle);
+  }
+}
+var opened = (handle) => {
+  if (!handle)
+    throw new Error(`procedural world: ${engine().worldgenError() || "generation failed"}`);
+  return new ProceduralWorld(handle);
+};
+function generateWorld(recipe, options = {}) {
+  return opened(engine().worldgenBuild(recipeText(recipe), options.key ?? "", options.prepareTerrain ?? false));
+}
+async function generateWorldAsync(recipe, options = {}) {
+  return opened(await engine().worldgenBuildAsync(recipeText(recipe), options.key ?? "", options.prepareTerrain ?? false));
+}
+function isWorldKept(key) {
+  return engine().worldgenKept(key);
+}
+function generateMesh(recipe) {
+  return geometry(engine().worldgenMesh(recipeText(recipe)));
+}
+function paintGeometry(geometry, color) {
+  const v = geometry.vertices;
+  const whole = v.byteOffset === 0 && v.byteLength === v.buffer.byteLength;
+  const buffer = whole ? v.buffer : v.slice().buffer;
+  if (!engine().worldgenPaint(buffer, JSON.stringify(color)))
+    throw new Error(`recolor: ${engine().worldgenError()}`);
+  if (!whole)
+    v.set(new Float32Array(buffer));
+  return geometry;
+}
+
 // src/assets/shape.ts
 var TAU2 = Math.PI * 2;
 var CURVE_STEPS = 12;
@@ -6874,10 +7646,6 @@ function paint(g, color) {
   }
   return g;
 }
-var fromBuilder = (b) => ({
-  vertices: new Float32Array(b.vertices),
-  indices: new Uint32Array(b.indices)
-});
 function shapeGeometry(shape, options = {}) {
   const info = meshInfo(SHAPE_MESH[shape]);
   if (!info)
@@ -6907,7 +7675,11 @@ function extrude(path, options = {}) {
     indices[i] = i;
   return paint({ vertices, indices }, options.color);
 }
+var perPoint = (x) => typeof x === "function" || x instanceof FieldFunction;
+var asField = (x) => x instanceof FieldFunction ? x : undefined;
 function paintBy(g, color) {
+  if (color instanceof FieldFunction)
+    return paintGeometry(g, color);
   if (typeof color !== "function")
     return paint(g, color);
   const v = g.vertices;
@@ -6927,29 +7699,40 @@ function paintBy(g, color) {
 function recolor(geometry, color) {
   return paintBy(geometry, color);
 }
-function roundFace(center, x, y, normal, radius, sweep, segments, rings, color) {
-  const b = new Builder;
-  b.grid(rings, segments, (u, v) => {
-    const a = u * sweep;
-    const r = radius(u) * v;
-    const [c, s] = [Math.cos(a) * r, Math.sin(a) * r];
-    return [[center[0] + x[0] * c + y[0] * s, center[1] + x[1] * c + y[1] * s, center[2] + x[2] * c + y[2] * s], normal];
-  });
-  const g = facingOutward(fromBuilder(b));
+var flat = (color) => color ? [color[0], color[1], color[2]] : undefined;
+function nativeSweep(part) {
+  const core = native();
+  if (typeof core.worldgenMesh !== "function")
+    throw new Error("shapes: this app's native core predates native lathes and tubes: rebuild it");
+  const built = core.worldgenMesh(JSON.stringify({ parts: [part] }));
+  return { vertices: new Float32Array(built.vertices), indices: new Uint32Array(built.indices) };
+}
+function paintRange(g, from, to, color) {
+  const v = g.vertices;
+  for (let i = from * VERTEX_FLOATS;i < to * VERTEX_FLOATS; i += VERTEX_FLOATS) {
+    const c = color({
+      u: v[i + 9],
+      v: v[i + 10],
+      position: [v[i], v[i + 1], v[i + 2]],
+      normal: [v[i + 3], v[i + 4], v[i + 5]]
+    });
+    v[i + 6] = c[0];
+    v[i + 7] = c[1];
+    v[i + 8] = c[2];
+  }
+}
+function paintFace(g, from, to, sweep, color) {
   const vs = g.vertices;
-  for (let i = 0;i < vs.length; i += VERTEX_FLOATS) {
+  for (let i = from * VERTEX_FLOATS;i < to * VERTEX_FLOATS; i += VERTEX_FLOATS) {
     const a = vs[i + 9] * sweep;
     const r = vs[i + 10];
     vs[i + 9] = 0.5 + Math.cos(a) * r / 2;
     vs[i + 10] = 0.5 + Math.sin(a) * r / 2;
-    if (typeof color === "function") {
-      const c = color(r, a);
-      vs[i + 6] = c[0];
-      vs[i + 7] = c[1];
-      vs[i + 8] = c[2];
-    }
+    const c = color(r, a);
+    vs[i + 6] = c[0];
+    vs[i + 7] = c[1];
+    vs[i + 8] = c[2];
   }
-  return typeof color === "function" ? g : paint(g, color);
 }
 var whole = (a) => a.byteOffset === 0 && a.byteLength === a.buffer.byteLength;
 var nativeGeometry3 = (g) => NativeNayanEngine_web_default && typeof NativeNayanEngine_web_default.geometryPlace === "function" && whole(g.vertices) && whole(g.indices) ? NativeNayanEngine_web_default : null;
@@ -7013,70 +7796,52 @@ function lathe(profile, options = {}) {
   const sweep = Math.min(TAU2, Math.max(0.001, options.sweep ?? TAU2));
   const full = sweep >= TAU2 - 0.000001;
   const last = points.length - 1;
-  const edge = (i) => {
-    const a = points[Math.max(0, i)];
-    const b = points[Math.min(last, i + 1)];
-    const len = Math.hypot(b[0] - a[0], b[1] - a[1]) || 1;
-    return [(a[1] - b[1]) / len, (b[0] - a[0]) / len];
-  };
-  const normals = points.map(([r], i) => {
-    if (r < 0.000001 && (i === 0 || i === last))
-      return [0, i === 0 ? 1 : -1];
-    const e1 = edge(i - 1);
-    const e2 = edge(i);
-    const n = i === 0 ? e2 : i === last ? e1 : [e1[0] + e2[0], e1[1] + e2[1]];
-    const len = Math.hypot(n[0], n[1]) || 1;
-    return [n[0] / len, n[1] / len];
-  });
-  const b = new Builder;
   const displace = options.displace;
-  b.grid(last, segments, (u, v) => {
-    const i = Math.round(v * last);
-    const a = u * sweep;
-    const [r, y] = points[i];
-    const [nr, ny] = normals[i];
-    const n = [nr * Math.cos(a), ny, -nr * Math.sin(a)];
-    const d = displace ? displace(r < 0.000001 || full && u === 1 ? 0 : u, v) : 0;
-    return [[r * Math.cos(a) + n[0] * d, y + n[1] * d, -r * Math.sin(a) + n[2] * d], n];
-  });
-  const parts = [
-    {
-      geometry: paintBy(displace ? smoothNormals(fromBuilder(b)) : fromBuilder(b), options.color)
+  let offsets;
+  if (typeof displace === "function") {
+    offsets = new Array((last + 1) * (segments + 1));
+    for (let i = 0;i <= last; i++) {
+      const pole = points[i][0] < 0.000001;
+      for (let j = 0;j <= segments; j++) {
+        const u = j / segments;
+        offsets[i * (segments + 1) + j] = displace(pole || full && u === 1 ? 0 : u, i / last);
+      }
     }
-  ];
-  const capColor = options.capColor ?? (typeof options.color === "function" ? undefined : options.color);
-  const rings = Math.max(1, Math.round(options.capRings ?? (typeof capColor === "function" ? 12 : 1)));
-  for (const [i, facing] of [
-    [0, 1],
-    [last, -1]
-  ]) {
-    const [r, y] = points[i];
-    if (r < 0.000001)
-      continue;
-    parts.push({
-      geometry: roundFace([0, y, 0], [1, 0, 0], [0, 0, -1], [0, facing, 0], () => r, sweep, segments, rings, capColor)
-    });
   }
-  if (full)
-    return parts.length > 1 ? merge(parts) : parts[0].geometry;
-  const cutColor = options.cutColor ?? (typeof options.color === "function" ? undefined : options.color);
-  const falling = points.every((p, i) => i === 0 || p[1] <= points[i - 1][1] + 0.000000001);
-  let face;
-  if (falling) {
-    const g = new Builder;
-    const steps = Math.max(1, Math.round(options.cutSteps ?? (typeof cutColor === "function" ? 12 : 1)));
-    g.grid(last, steps, (u, v) => {
-      const [r, y] = points[Math.round(v * last)];
-      return [
-        [u * r, y, 0],
-        [0, 0, 1]
-      ];
-    });
-    face = facingOutward(fromBuilder(g));
-  } else {
-    face = extrude(new Path().addPolygon([[0, -points[0][1]], ...points.map(([r, y]) => [r, -y]), [0, -points[last][1]]]), { depth: 0 });
+  const color = options.color;
+  const capColor = options.capColor ?? (perPoint(color) ? undefined : color);
+  const capRings = Math.max(1, Math.round(options.capRings ?? (perPoint(capColor) ? 12 : 1)));
+  const cutColor = options.cutColor ?? (perPoint(color) ? undefined : color);
+  const cutSteps = Math.max(1, Math.round(options.cutSteps ?? (perPoint(cutColor) ? 12 : 1)));
+  const g = nativeSweep({
+    kind: "lathe",
+    points,
+    segments,
+    sweep,
+    displace: offsets,
+    displaceField: asField(displace),
+    color: perPoint(color) ? undefined : flat(color),
+    colorField: asField(color),
+    capColor: perPoint(capColor) ? undefined : flat(capColor),
+    capColorField: asField(capColor),
+    rawCaps: typeof capColor === "function",
+    capRings,
+    cutColor: perPoint(cutColor) ? undefined : flat(cutColor),
+    cutColorField: asField(cutColor),
+    cutSteps
+  });
+  let at = (last + 1) * (segments + 1);
+  if (typeof color === "function")
+    paintRange(g, 0, at, color);
+  for (const i of [0, last]) {
+    if (points[i][0] < 0.000001)
+      continue;
+    const end = at + (capRings + 1) * (segments + 1);
+    if (typeof capColor === "function")
+      paintFace(g, at, end, sweep, capColor);
+    at = end;
   }
-  if (typeof cutColor === "function") {
+  if (!full && typeof cutColor === "function") {
     const widest = Math.max(...points.map((p) => p[0]), 0.000001);
     const skinAt = (y) => {
       let best = 0;
@@ -7088,33 +7853,19 @@ function lathe(profile, options = {}) {
       }
       return best || widest;
     };
-    const fv = face.vertices;
-    for (let i = 0;i < fv.length; i += VERTEX_FLOATS) {
-      const c = cutColor(Math.min(1, fv[i] / skinAt(fv[i + 1])), fv[i + 1]);
-      fv.set(c.slice(0, 3), i + 6);
+    const v = g.vertices;
+    const half = (v.length / VERTEX_FLOATS - at) / 2;
+    for (let k = 0;k < half; k++) {
+      const i = (at + k) * VERTEX_FLOATS;
+      const c = cutColor(Math.min(1, v[i] / skinAt(v[i + 1])), v[i + 1]);
+      for (const o of [i, i + half * VERTEX_FLOATS]) {
+        v[o + 6] = c[0];
+        v[o + 7] = c[1];
+        v[o + 8] = c[2];
+      }
     }
-  } else {
-    paint(face, cutColor);
   }
-  const cut = (angle, flip) => {
-    const g = {
-      vertices: face.vertices.slice(),
-      indices: face.indices.slice()
-    };
-    const [c, s] = [Math.cos(angle), Math.sin(angle)];
-    const n = angle === 0 ? [0, 0, 1] : [-s, 0, -c];
-    for (let v = 0;v < g.vertices.length; v += VERTEX_FLOATS) {
-      const r = g.vertices[v];
-      g.vertices[v] = r * c;
-      g.vertices[v + 2] = -r * s;
-      g.vertices.set(n, v + 3);
-    }
-    if (flip)
-      for (let t = 0;t < g.indices.length; t += 3)
-        [g.indices[t + 1], g.indices[t + 2]] = [g.indices[t + 2], g.indices[t + 1]];
-    return g;
-  };
-  return merge([...parts, { geometry: cut(0, false) }, { geometry: cut(sweep, true) }]);
+  return g;
 }
 function tube(points, options = {}) {
   if (points.some((p) => p.some((v) => !Number.isFinite(v))))
@@ -7127,133 +7878,43 @@ function tube(points, options = {}) {
   if (points.length < (closed ? 3 : 2))
     throw new Error(`tube: needs at least ${closed ? "three" : "two"} distinct points`);
   const radius = typeof options.radius === "function" ? options.radius : () => options.radius ?? 0.1;
-  const shape = options.shape ?? (() => 1);
+  const shape = options.shape;
   const sides = Math.max(3, Math.round(options.sides ?? 12));
   const steps = Math.max(1, Math.round(options.smoothness ?? 8));
-  const p = (i) => points[closed ? (i + points.length) % points.length : Math.max(0, Math.min(points.length - 1, i))];
-  const curve = [];
-  for (let i = 0;i < points.length - (closed ? 0 : 1); i++) {
-    const [a, b, c, d] = [p(i - 1), p(i), p(i + 1), p(i + 2)];
-    for (let s = 0;s < steps; s++) {
-      const t = s / steps;
-      const t2 = t * t;
-      const t3 = t2 * t;
-      const coordinate = (k) => 0.5 * (2 * b[k] + (-a[k] + c[k]) * t + (2 * a[k] - 5 * b[k] + 4 * c[k] - d[k]) * t2 + (-a[k] + 3 * b[k] - 3 * c[k] + d[k]) * t3);
-      curve.push([coordinate(0), coordinate(1), coordinate(2)]);
-    }
-  }
-  curve.push(p(closed ? 0 : points.length - 1));
-  const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-  const 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]];
-  const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-  const norm = (a) => {
-    const l = Math.hypot(a[0], a[1], a[2]) || 1;
-    return [a[0] / l, a[1] / l, a[2] / l];
-  };
-  const last = curve.length - 1;
-  const tangents = curve.map((_, i) => {
-    let delta = sub(curve[closed && i === last ? 1 : Math.min(last, i + 1)], curve[closed && i === 0 ? last - 1 : Math.max(0, i - 1)]);
-    if (Math.hypot(...delta) < 0.000000001)
-      delta = i > 0 ? sub(curve[i], curve[i - 1]) : sub(curve[1], curve[0]);
-    return norm(delta);
-  });
-  if (closed)
-    tangents[last] = tangents[0];
-  const t0 = tangents[0];
-  let normal = norm(cross(t0, Math.abs(t0[1]) < 0.9 ? [0, 1, 0] : [1, 0, 0]));
-  let previous = t0;
-  const frames = [];
-  for (const t of tangents) {
-    const axis = cross(previous, t);
-    const cosine = Math.max(-1, Math.min(1, dot(previous, t)));
-    if (cosine > -1 + 0.00000001) {
-      const turn = cross(axis, normal);
-      const second = cross(axis, turn);
-      normal = [
-        normal[0] + turn[0] + second[0] / (1 + cosine),
-        normal[1] + turn[1] + second[1] / (1 + cosine),
-        normal[2] + turn[2] + second[2] / (1 + cosine)
-      ];
-    }
-    const projection = dot(normal, t);
-    normal = norm(sub(normal, [t[0] * projection, t[1] * projection, t[2] * projection]));
-    frames.push([normal, cross(t, normal)]);
-    previous = t;
-  }
-  if (closed) {
-    const end = frames[last][0], start = frames[0][0];
-    const correction = Math.atan2(dot(t0, cross(end, start)), dot(end, start));
-    const lengths = [0];
-    for (let i = 1;i <= last; i++)
-      lengths.push(lengths[i - 1] + distance(curve[i], curve[i - 1]));
-    for (let i = 1;i <= last; i++) {
-      const angle = correction * lengths[i] / lengths[last];
-      const [n, bn] = frames[i];
-      const c = Math.cos(angle), s = Math.sin(angle);
-      const corrected = [n[0] * c + bn[0] * s, n[1] * c + bn[1] * s, n[2] * c + bn[2] * s];
-      frames[i] = [corrected, cross(tangents[i], corrected)];
-    }
-    frames[last] = frames[0];
-  }
-  const b = new Builder;
-  const ring = curve.map((c, i) => {
-    const r = Math.max(0, radius(closed && i === last ? 0 : i / last));
-    const [n, bn] = frames[i];
-    const first = b.vertices.length / VERTEX_FLOATS;
-    for (let j = 0;j <= sides; j++) {
-      const a = (j === sides ? 0 : j / sides) * TAU2;
-      const cosine = Math.cos(a), sine = Math.sin(a);
-      const dir = [cosine * n[0] + sine * bn[0], cosine * n[1] + sine * bn[1], cosine * n[2] + sine * bn[2]];
-      const rj = r * shape(j === sides ? 0 : j / sides);
-      b.vertex([c[0] + dir[0] * rj, c[1] + dir[1] * rj, c[2] + dir[2] * rj], dir, j / sides, i / (curve.length - 1));
-    }
-    return { first, r };
+  const count = (points.length - (closed ? 0 : 1)) * steps + 1;
+  const last = count - 1;
+  const radii = Array.from({ length: count }, (_, i) => Math.max(0, radius(closed && i === last ? 0 : i / last)));
+  const color = options.color;
+  const caps = !closed && (options.caps ?? true);
+  const capColor = options.capColor ?? (perPoint(color) ? undefined : color);
+  const capRings = perPoint(capColor) ? 8 : 1;
+  const g = nativeSweep({
+    kind: "tube",
+    points,
+    closed,
+    sides,
+    steps,
+    radii,
+    shape: shape && Array.from({ length: sides + 1 }, (_, j) => shape(j === sides ? 0 : j / sides)),
+    smooth: !!shape || typeof options.radius === "function",
+    caps,
+    color: perPoint(color) ? undefined : flat(color),
+    colorField: asField(color),
+    capColor: perPoint(capColor) ? undefined : flat(capColor),
+    capColorField: asField(capColor),
+    rawCaps: typeof capColor === "function",
+    capRings
   });
-  for (let i = 0;i < ring.length - 1; i++) {
-    for (let j = 0;j < sides; j++) {
-      const a = ring[i].first + j;
-      const c = ring[i + 1].first + j;
-      b.indices.push(a, a + 1, c, a + 1, c + 1, c);
-    }
-  }
-  let side = facingOutward(fromBuilder(b));
-  if (options.shape || typeof options.radius === "function")
-    side = smoothNormals(side);
-  const parts = [{ geometry: paintBy(side, options.color) }];
-  if (!closed && (options.caps ?? true)) {
-    const capColor = options.capColor ?? (typeof options.color === "function" ? undefined : options.color);
-    const rings = typeof capColor === "function" ? 8 : 1;
-    for (const [i, facing] of [
-      [0, -1],
-      [ring.length - 1, 1]
-    ]) {
-      const { r } = ring[i];
-      if (r < 0.000001)
+  let at = count * (sides + 1);
+  if (typeof color === "function")
+    paintRange(g, 0, at, color);
+  if (caps && typeof capColor === "function") {
+    for (const i of [0, last]) {
+      if (radii[i] < 0.000001)
         continue;
-      const t = tangents[i];
-      const [fn, fb] = frames[i];
-      parts.push({
-        geometry: roundFace(curve[i], fn, fb, [t[0] * facing, t[1] * facing, t[2] * facing], (u) => r * shape(u === 1 ? 0 : u), TAU2, sides, rings, capColor)
-      });
-    }
-  }
-  return parts.length > 1 ? merge(parts) : parts[0].geometry;
-}
-function facingOutward(g) {
-  const native = nativeGeometry3(g);
-  if (native) {
-    native.geometryFaceOutward(g.vertices.buffer, g.indices.buffer);
-    return g;
-  }
-  const v = g.vertices;
-  const at = (i, k) => v[g.indices[i] * VERTEX_FLOATS + k];
-  for (let t = 0;t < g.indices.length; t += 3) {
-    const e1 = [0, 1, 2].map((k) => at(t + 1, k) - at(t, k));
-    const e2 = [0, 1, 2].map((k) => at(t + 2, k) - at(t, k));
-    const face = [e1[1] * e2[2] - e1[2] * e2[1], e1[2] * e2[0] - e1[0] * e2[2], e1[0] * e2[1] - e1[1] * e2[0]];
-    const n = [0, 1, 2].map((k) => at(t, k + 3) + at(t + 1, k + 3) + at(t + 2, k + 3));
-    if (face[0] * n[0] + face[1] * n[1] + face[2] * n[2] < 0) {
-      [g.indices[t + 1], g.indices[t + 2]] = [g.indices[t + 2], g.indices[t + 1]];
+      const end = at + (capRings + 1) * (sides + 1);
+      paintFace(g, at, end, TAU2, capColor);
+      at = end;
     }
   }
   return g;
@@ -7513,42 +8174,6 @@ function deformGeometry(geometry, deform) {
   }
   return smoothNormals({ vertices, indices: geometry.indices.slice() });
 }
-// src/assets/surface.ts
-function parametricSurface(sample, options = {}) {
-  const nu = options.uSegments ?? 32, nv = options.vSegments ?? 16;
-  if (![nu, nv].every((n) => Number.isInteger(n) && n >= 1 && n <= 1024) || (nu + 1) * (nv + 1) > 1e6)
-    throw new Error("parametricSurface: invalid segments or surface exceeds one million vertices");
-  const vertices = new Float32Array((nu + 1) * (nv + 1) * 11);
-  for (let y = 0;y <= nv; y++)
-    for (let x = 0;x <= nu; x++) {
-      const u = x / nu, v = y / nv;
-      const p = sample(options.wrapU && x === nu ? 0 : u, options.wrapV && y === nv ? 0 : v);
-      if (p.some((c) => !Number.isFinite(c)))
-        throw new Error("parametricSurface: sample returned a non-finite position");
-      vertices.set([p[0], p[1], p[2], 0, 1, 0, 1, 1, 1, u, v], (y * (nu + 1) + x) * 11);
-    }
-  const indices = [];
-  const triangle = (a, b, c) => {
-    const v = vertices;
-    const oa = a * 11, ob = b * 11, oc = c * 11;
-    const x1 = v[ob] - v[oa], y1 = v[ob + 1] - v[oa + 1], z1 = v[ob + 2] - v[oa + 2];
-    const x2 = v[oc] - v[oa], y2 = v[oc + 1] - v[oa + 1], z2 = v[oc + 2] - v[oa + 2];
-    if (Math.hypot(y1 * z2 - z1 * y2, z1 * x2 - x1 * z2, x1 * y2 - y1 * x2) > 0)
-      indices.push(a, b, c);
-  };
-  for (let y = 0;y < nv; y++)
-    for (let x = 0;x < nu; x++) {
-      const a = y * (nu + 1) + x, b = a + nu + 1;
-      triangle(a, a + 1, b);
-      triangle(a + 1, b + 1, b);
-    }
-  const geometry = smoothNormals({
-    vertices,
-    indices: new Uint32Array(indices)
-  });
-  return options.color ? recolor(geometry, typeof options.color === "function" ? options.color : () => options.color) : geometry;
-}
-
 // src/assets/loft.ts
 function loft(sections, options = {}) {
   if (sections.length < 2 || sections.some((s) => ![s.z, s.bottom, s.top, s.width, s.topWidth ?? s.width, s.square ?? 4].every(Number.isFinite) || s.width < 0 || (s.topWidth ?? s.width) < 0 || s.top <= s.bottom || (s.square ?? 4) < 1))
@@ -7560,53 +8185,23 @@ function loft(sections, options = {}) {
   if (!Number.isInteger(n) || n < 6 || n > 512 || !Number.isInteger(steps) || steps < 1 || steps > 64)
     throw new Error("loft: invalid around/smoothness");
   const values = ordered.map((s) => [s.z, s.bottom, s.top, s.width, s.topWidth ?? s.width, s.square ?? 4]);
-  const at = (i) => values[Math.max(0, Math.min(values.length - 1, i))];
-  const row = (v) => {
-    const cursor = v * (values.length - 1), i = Math.min(values.length - 2, Math.floor(cursor)), t = cursor - i;
-    const a = at(i - 1), b = at(i), c = at(i + 1), d = at(i + 2);
-    const f = b.map((_, k) => 0.5 * (2 * b[k] + (-a[k] + c[k]) * t + (2 * a[k] - 5 * b[k] + 4 * c[k] - d[k]) * t * t + (-a[k] + 3 * b[k] - 3 * c[k] + d[k]) * t * t * t));
-    f[2] = Math.max(f[1] + 0.000001, f[2]);
-    f[3] = Math.max(0, f[3]);
-    f[4] = Math.max(0, f[4]);
-    f[5] = Math.max(1, f[5]);
-    return f;
-  };
-  const rowCount = (sections.length - 1) * steps;
-  const rows = Array.from({ length: rowCount + 1 }, (_, i) => row(i / rowCount));
-  const point = (u, v) => {
-    const [z, bottom, top, width, topWidth, square] = rows[Math.round(v * rowCount)], angle = -Math.PI / 2 + u * Math.PI * 2;
-    const c = Math.cos(angle), s = Math.sin(angle), exponent = 2 / square;
-    const x = Math.sign(c) * Math.abs(c) ** exponent, y = Math.sign(s) * Math.abs(s) ** exponent;
-    return [x * (y > 0 ? width + (topWidth - width) * y : width), (bottom + top) / 2 + y * (top - bottom) / 2, z];
-  };
-  const side = parametricSurface(point, {
-    uSegments: n,
-    vSegments: rowCount,
-    wrapU: true
+  const color = options.color;
+  const g = nativeSweep({
+    kind: "loft",
+    sections: values,
+    around: n,
+    smoothness: steps,
+    color: typeof color === "function" || color instanceof FieldFunction || !color ? undefined : [color[0], color[1], color[2]],
+    colorField: color instanceof FieldFunction ? color : undefined
   });
-  const parts = [{ geometry: side }];
-  for (const [v, facing] of [
-    [0, -1],
-    [1, 1]
-  ]) {
-    const section = rows[v * rowCount], cy = (section[1] + section[2]) / 2;
-    const vertices = new Float32Array((n + 1) * 11), indices = [];
-    vertices.set([0, cy, section[0], 0, 0, facing, 1, 1, 1, 0.5, 0.5]);
-    for (let j = 0;j < n; j++) {
-      const p = point(j / n, v), width = Math.max(section[3], section[4], 0.000001);
-      vertices.set([p[0], p[1], p[2], 0, 0, facing, 1, 1, 1, 0.5 + p[0] / (2 * width), (p[1] - section[1]) / (section[2] - section[1])], (j + 1) * 11);
-      const a = j + 1, b = (j + 1) % n + 1;
-      if (facing === 1)
-        indices.push(0, a, b);
-      else
-        indices.push(0, b, a);
-    }
-    parts.push({ geometry: { vertices, indices: new Uint32Array(indices) } });
-  }
-  return paint2(merge(parts), options.color);
+  return typeof color === "function" ? paint2(g, color) : g;
 }
 function paint2(geometry, color) {
-  return color ? recolor(geometry, typeof color === "function" ? ({ position, normal }) => color(position, normal) : () => color) : geometry;
+  if (!color)
+    return geometry;
+  if (color instanceof FieldFunction)
+    return recolor(geometry, color);
+  return recolor(geometry, typeof color === "function" ? ({ position, normal }) => color(position, normal) : () => color);
 }
 function block(w, h, d, square = 6, color) {
   return loft([
@@ -7643,6 +8238,41 @@ function smoothCurve(points) {
     return (2 * t * t * t - 3 * t * t + 1) * y0 + (t * t * t - 2 * t * t + t) * h * slope(i) + (-2 * t * t * t + 3 * t * t) * y1 + (t * t * t - t * t) * h * slope(i + 1);
   };
 }
+// src/assets/surface.ts
+function parametricSurface(sample, options = {}) {
+  const nu = options.uSegments ?? 32, nv = options.vSegments ?? 16;
+  if (![nu, nv].every((n) => Number.isInteger(n) && n >= 1 && n <= 1024) || (nu + 1) * (nv + 1) > 1e6)
+    throw new Error("parametricSurface: invalid segments or surface exceeds one million vertices");
+  const vertices = new Float32Array((nu + 1) * (nv + 1) * 11);
+  for (let y = 0;y <= nv; y++)
+    for (let x = 0;x <= nu; x++) {
+      const u = x / nu, v = y / nv;
+      const p = sample(options.wrapU && x === nu ? 0 : u, options.wrapV && y === nv ? 0 : v);
+      if (p.some((c) => !Number.isFinite(c)))
+        throw new Error("parametricSurface: sample returned a non-finite position");
+      vertices.set([p[0], p[1], p[2], 0, 1, 0, 1, 1, 1, u, v], (y * (nu + 1) + x) * 11);
+    }
+  const indices = [];
+  const triangle = (a, b, c) => {
+    const v = vertices;
+    const oa = a * 11, ob = b * 11, oc = c * 11;
+    const x1 = v[ob] - v[oa], y1 = v[ob + 1] - v[oa + 1], z1 = v[ob + 2] - v[oa + 2];
+    const x2 = v[oc] - v[oa], y2 = v[oc + 1] - v[oa + 1], z2 = v[oc + 2] - v[oa + 2];
+    if (Math.hypot(y1 * z2 - z1 * y2, z1 * x2 - x1 * z2, x1 * y2 - y1 * x2) > 0)
+      indices.push(a, b, c);
+  };
+  for (let y = 0;y < nv; y++)
+    for (let x = 0;x < nu; x++) {
+      const a = y * (nu + 1) + x, b = a + nu + 1;
+      triangle(a, a + 1, b);
+      triangle(a + 1, b + 1, b);
+    }
+  const geometry = smoothNormals({
+    vertices,
+    indices: new Uint32Array(indices)
+  });
+  return options.color ? recolor(geometry, typeof options.color === "function" ? options.color : () => options.color) : geometry;
+}
 // src/media/audio.ts
 var loader4 = new AssetLoader("audio");
 function loadSound(source) {
@@ -7693,6 +8323,17 @@ var audio = {
     if (voice)
       NativeNayanEngine_web_default?.audioStop(voice);
   },
+  release(sound) {
+    if (sound != null)
+      NativeNayanEngine_web_default?.audioRelease?.(sound);
+  },
+  duration(sound) {
+    return NativeNayanEngine_web_default?.audioDuration?.(sound) ?? 0;
+  },
+  levels(sound, perSecond = 30) {
+    const buffer = NativeNayanEngine_web_default?.audioLevels?.(sound, perSecond);
+    return buffer ? new Float32Array(buffer) : new Float32Array(0);
+  },
   get muted() {
     return muted;
   },
@@ -7717,6 +8358,108 @@ var audio = {
     return NativeNayanEngine_web_default?.audioIsRunning() ?? false;
   }
 };
+// src/media/speechPlatform.web.ts
+var speechPlatform = {
+  get supported() {
+    return typeof window !== "undefined" && "speechSynthesis" in window && "SpeechSynthesisUtterance" in window;
+  },
+  async request(command) {
+    await prepareEngine();
+    return speech_request(command);
+  }
+};
+
+// src/media/speech.ts
+async function request(command) {
+  if (!speechPlatform.supported)
+    throw new Error("Speech is unavailable on this platform or engine build");
+  const result = JSON.parse(await speechPlatform.request(JSON.stringify(command)));
+  if (result.error)
+    throw new Error(result.error);
+  return result.value;
+}
+var speech = {
+  get supported() {
+    return speechPlatform.supported;
+  },
+  async speak(text, options = {}) {
+    if (typeof text !== "string")
+      throw new TypeError("Speech text must be a string");
+    for (const [key, min, max] of [
+      ["rate", 0.1, 2],
+      ["pitch", 0.5, 2],
+      ["volume", 0, 1]
+    ]) {
+      const value = options[key];
+      if (value !== undefined && (!Number.isFinite(value) || value < min || value > max)) {
+        throw new RangeError(`Speech ${key} must be between ${min} and ${max}`);
+      }
+    }
+    for (const key of ["language", "voice"]) {
+      if (options[key] !== undefined && typeof options[key] !== "string")
+        throw new TypeError(`Speech ${key} must be a string`);
+    }
+    if (!text.trim())
+      return;
+    const { language, voice, rate, pitch, volume } = options;
+    await request({ action: "speak", text, language, voice, rate, pitch, volume });
+  },
+  async stop() {
+    await request({ action: "stop" });
+  },
+  async pause() {
+    await request({ action: "pause" });
+  },
+  async resume() {
+    await request({ action: "resume" });
+  },
+  isSpeakingAsync() {
+    return request({ action: "isSpeaking" });
+  },
+  getAvailableVoicesAsync() {
+    return request({ action: "voices" });
+  }
+};
+// src/media/microphone.ts
+var STATES = { 0: "off", 1: "starting", 2: "listening", [-1]: "failed" };
+var microphone = {
+  get supported() {
+    return typeof NativeNayanEngine_web_default?.micStart === "function";
+  },
+  get permission() {
+    const value = microphone.supported ? NativeNayanEngine_web_default.micPermission() : -1;
+    return value > 0 ? "granted" : value < 0 ? "denied" : "undetermined";
+  },
+  requestPermission() {
+    return microphone.supported ? NativeNayanEngine_web_default.micRequestPermission() : Promise.resolve(false);
+  },
+  start({ maxSeconds = 10 } = {}) {
+    return microphone.supported && NativeNayanEngine_web_default.micStart(maxSeconds);
+  },
+  stop() {
+    if (microphone.supported)
+      NativeNayanEngine_web_default.micStop();
+  },
+  get state() {
+    return microphone.supported ? STATES[NativeNayanEngine_web_default.micState()] ?? "off" : "off";
+  },
+  get level() {
+    return microphone.supported ? NativeNayanEngine_web_default.micLevel() : 0;
+  },
+  get held() {
+    return microphone.supported ? NativeNayanEngine_web_default.micHeld() : 0;
+  },
+  take(seconds = Infinity, { skipEnd = 0, levelsPerSecond = 30 } = {}) {
+    if (!microphone.supported)
+      return null;
+    const id = NativeNayanEngine_web_default.micTake(Number.isFinite(seconds) ? seconds : 3600, skipEnd);
+    if (id < 0)
+      return null;
+    const sound = id;
+    const buffer = NativeNayanEngine_web_default.audioLevels(sound, levelsPerSecond);
+    return { sound, duration: NativeNayanEngine_web_default.audioDuration(sound), levels: new Float32Array(buffer), levelsPerSecond };
+  }
+};
 // src/media/haptics.ts
 var PATTERNS = {
   success: [
@@ -7862,7 +8605,7 @@ class DrawingDocument {
   boundTexture = null;
   constructor(width, height, pixelRatio = 2) {
     if (!NativeNayanEngine_web_default || typeof NativeNayanEngine_web_default.drawingCreate !== "function") {
-      throw new Error("Drawing requires a native app rebuild with the updated Nayan engine.");
+      throw new Error("Drawing requires a native app rebuild with the updated Nayan Game Engine.");
     }
     NativeNayanEngine_web_default.renderWarmUp?.();
     const id = NativeNayanEngine_web_default.drawingCreate(width, height, pixelRatio);
@@ -8190,16 +8933,21 @@ var DrawingCanvas = memo(function DrawingCanvas({
 export {
   DrawingCanvas,
   DrawingDocument,
+  FieldFunction,
+  FieldGraph,
+  FieldRef,
   GameView,
   Joystick,
   MAX_MESHES,
   Path,
   ProceduralCache,
+  ProceduralWorld,
   Scoreboard,
   Solid,
   World,
   afterNextFrame,
   audio,
+  bakeModel,
   block,
   clearAssetCache,
   createGeometryLods,
@@ -8210,11 +8958,17 @@ export {
   effects,
   ellipsoid,
   extrude,
+  faceColor,
   frontLight,
+  generateMesh,
+  generateWorld,
+  generateWorldAsync,
   getGeometryStats,
   getMeshIdLimit,
   haptics,
+  isBakeKept,
   isEngineAvailable,
+  isWorldKept,
   lathe,
   loadFont,
   loadModel,
@@ -8222,14 +8976,19 @@ export {
   loft,
   measureText,
   merge,
+  microphone,
   optimizeGeometry,
   parametricSurface,
   quat,
   recolor,
+  sectionColor,
   shapeGeometry,
   smoothCurve,
   smoothNormals,
   solidGeometry,
+  speech,
+  surfaceColor,
+  surfaceDisplacement,
   toColor,
   tube,
   useJoystick,
@@ -8237,4 +8996,4 @@ export {
   warmUpEngine
 };
 
-//# debugId=1367AF6CC344167A64756E2164756E21
+//# debugId=089DF8C707AEEB2364756E2164756E21