minerender 2.1.0-alpha.118 → 2.1.0-alpha.119

package/dist/browser/index.js

@@ -87,6 +87,19 @@ var init_PersistentCache = __esm({
   }
 });
 
+// src/util/log.ts
+function prefix(prefix2) {
+  return `${FgGreen}MR${BgBlack}${prefix2 ?? ""}${Reset}`;
+}
+var Reset, FgGreen, BgBlack;
+var init_log = __esm({
+  "src/util/log.ts"() {
+    Reset = "\x1B[0m";
+    FgGreen = "\x1B[32m";
+    BgBlack = "\x1B[40m";
+  }
+});
+
 // src/Axis.ts
 function axisToVec3(axis) {
   switch (axis) {
@@ -377,19 +390,6 @@ var init_CanvasCompat = __esm({
   }
 });
 
-// src/util/log.ts
-function prefix(prefix2) {
-  return `${FgGreen}MR${BgBlack}${prefix2 ?? ""}${Reset}`;
-}
-var Reset, FgGreen, BgBlack;
-var init_log = __esm({
-  "src/util/log.ts"() {
-    Reset = "\x1B[0m";
-    FgGreen = "\x1B[32m";
-    BgBlack = "\x1B[40m";
-  }
-});
-
 // src/request/Requests.ts
 async function fetchRequest(config, defaultBaseURL) {
   const { url, baseURL = defaultBaseURL, timeout = 5e3, responseType = "json", signal, ...options } = config;
@@ -443,12 +443,12 @@ async function abortable(promise, signal) {
     signal.removeEventListener("abort", abort);
   }
 }
-var import_jobqu, p, RequestError, RequestQueue, Requests;
+var import_jobqu, p2, RequestError, RequestQueue, Requests;
 var init_Requests = __esm({
   "src/request/Requests.ts"() {
     import_jobqu = require("jobqu");
     init_log();
-    p = prefix("Requests");
+    p2 = prefix("Requests");
     RequestError = class extends Error {
       constructor(message, response, cause) {
         super(message);
@@ -475,7 +475,7 @@ var init_Requests = __esm({
             try {
               return await abortable(this.queue.add(request), signal);
             } catch (error) {
-              console.debug(p, "Request failed", error);
+              console.debug(p2, "Request failed", error);
               const delay = this.retryDelay(error, request, retries);
               if (delay === void 0) {
                 throw error;
@@ -639,7 +639,7 @@ var init_WrappedImage = __esm({
 });
 
 // src/image/ImageLoader.ts
-var import_buffer, p2, ImageLoader;
+var import_buffer, p3, ImageLoader;
 var init_ImageLoader = __esm({
   "src/image/ImageLoader.ts"() {
     init_CanvasCompat();
@@ -650,7 +650,7 @@ var init_ImageLoader = __esm({
     init_WrappedImage();
     import_buffer = require("buffer");
     init_log();
-    p2 = prefix("ImageLoader");
+    p3 = prefix("ImageLoader");
     ImageLoader = class _ImageLoader {
       static _createImage() {
         return createImage();
@@ -675,7 +675,7 @@ var init_ImageLoader = __esm({
         return image;
       }
       static async loadData(src) {
-        console.debug(p2, "loadData", src);
+        console.debug(p3, "loadData", src);
         const image = await this.loadCanvasData(src);
         return image.data.getImageData(0, 0, image.width, image.height);
       }
@@ -1237,8 +1237,8 @@ var require_dist = __commonJS({
       __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
           s = arguments[i];
-          for (var p10 in s) if (Object.prototype.hasOwnProperty.call(s, p10))
-            t[p10] = s[p10];
+          for (var p11 in s) if (Object.prototype.hasOwnProperty.call(s, p11))
+            t[p11] = s[p11];
         }
         return t;
       };
@@ -1419,12 +1419,12 @@ var init_AssetKey = __esm({
       }
       /** Joins the type subdirectory and path without adding a namespace or file extension. */
       getFullPath() {
-        let p10 = [];
+        let p11 = [];
         if (this.type) {
-          p10.push(this.type);
+          p11.push(this.type);
         }
-        p10.push(this.path);
-        return p10.join("/");
+        p11.push(this.path);
+        return p11.join("/");
       }
       toNamespacedString() {
         return this.namespace + ":" + this.getFullPath();
@@ -1530,7 +1530,7 @@ var init_ModelMerger = __esm({
             merged.display = { ...inheritedDisplay, ...DisplayTransforms.withHandFallbacks(source.display) };
           }
         }
-        merged.hierarchy = models.map((m) => m.parent).filter((p10) => `${p10}`);
+        merged.hierarchy = models.map((m) => m.parent).filter((p11) => `${p11}`);
         merged.hierarchy.push(`${merged.parent}`);
         if (model.components) merged.components = model.components;
         return merged;
@@ -2723,7 +2723,7 @@ var init_parser = __esm({
 });
 
 // src/assets/source/HostedAssetSource.ts
-var import_ts_deepmerge2, p3, DEFAULT_OPTIONS, _HostedAssetSource, HostedAssetSource;
+var import_ts_deepmerge2, p4, DEFAULT_OPTIONS, _HostedAssetSource, HostedAssetSource;
 var init_HostedAssetSource = __esm({
   "src/assets/source/HostedAssetSource.ts"() {
     init_AssetSource();
@@ -2736,7 +2736,7 @@ var init_HostedAssetSource = __esm({
     init_AssetLoader();
     init_parser();
     import_ts_deepmerge2 = __toESM(require_dist());
-    p3 = prefix("HostedAssetSource");
+    p4 = prefix("HostedAssetSource");
     DEFAULT_OPTIONS = {
       retryDefaults: true
     };
@@ -2748,14 +2748,14 @@ var init_HostedAssetSource = __esm({
           return direct;
         }
         if (key.namespace !== DEFAULT_NAMESPACE) {
-          console.info(p3, "Retrying", key, "with default namespace");
+          console.info(p4, "Retrying", key, "with default namespace");
           const namespaceKey = new AssetKey(DEFAULT_NAMESPACE, key.path, key.assetType, key.type, key.rootType, key.extension, key.root);
           const namespaced = await this.load(namespaceKey, parser);
           if (typeof namespaced !== "undefined") {
             return namespaced;
           }
           if (typeof key.root !== "undefined" && key.root !== AssetLoader.ROOT || typeof this.root !== "undefined" && this.root !== AssetLoader.ROOT) {
-            console.info(p3, "Retrying", key, "with default root+namespace");
+            console.info(p4, "Retrying", key, "with default root+namespace");
             const namespacedRootedKey = new AssetKey(DEFAULT_NAMESPACE, key.path, key.assetType, key.type, key.rootType, key.extension, AssetLoader.ROOT);
             const namespacedRooted = await this.load(namespacedRootedKey, parser);
             if (typeof namespacedRooted !== "undefined") {
@@ -2763,7 +2763,7 @@ var init_HostedAssetSource = __esm({
             }
           }
         } else if (typeof key.root !== "undefined" && key.root !== AssetLoader.ROOT || typeof this.root !== "undefined" && this.root !== AssetLoader.ROOT) {
-          console.info(p3, "Retrying", key, "with default root");
+          console.info(p4, "Retrying", key, "with default root");
           const rootKey = new AssetKey(key.namespace, key.path, key.assetType, key.type, key.rootType, key.extension, AssetLoader.ROOT);
           const rooted = await this.load(rootKey, parser);
           if (typeof rooted !== "undefined") {
@@ -2773,9 +2773,9 @@ var init_HostedAssetSource = __esm({
         return void 0;
       }
       async load(key, parser) {
-        console.info(p3, "Loading", key);
+        console.info(p4, "Loading", key);
         const url = `${this.assetBasePath(key)}${key.type !== void 0 ? key.type + "/" : ""}${key.path}${key.extension}`;
-        console.debug(p3, url);
+        console.debug(p4, url);
         const request = { url };
         try {
           parser.config(request);
@@ -3218,7 +3218,7 @@ var init_source = __esm({
 });
 
 // src/assets/AssetLoader.ts
-var p4, _AssetLoader, AssetLoader;
+var p5, _AssetLoader, AssetLoader;
 var init_AssetLoader = __esm({
   "src/assets/AssetLoader.ts"() {
     init_Assets();
@@ -3226,7 +3226,7 @@ var init_AssetLoader = __esm({
     init_log();
     init_source();
     init_Caching();
-    p4 = prefix("AssetLoader");
+    p5 = prefix("AssetLoader");
     _AssetLoader = class _AssetLoader {
       static get version() {
         return this.ROOT.substring(this.ROOT.lastIndexOf("/") + 1);
@@ -3275,11 +3275,11 @@ ${key}` : key;
         if (override) {
           const existing = this.removeSource(key);
           if (existing) {
-            console.log(p4, "Removed existing AssetSource", key);
+            console.log(p5, "Removed existing AssetSource", key);
           }
         }
         this._SOURCES.unshift({ key, source });
-        console.log(p4, "Added AssetSource", key);
+        console.log(p5, "Added AssetSource", key);
       }
       /** Removes and returns the first source with this name. Call {@link Caching.clear} to reload assets. */
       static removeSource(key) {
@@ -3670,7 +3670,7 @@ var init_ModelGenerator = __esm({
 });
 
 // src/UVMapper.ts
-var import_three9, p5, DEFAULT_UV, X, Y, Z, FACE_UV_AXES, UVMapper, MinecraftFaceUV;
+var import_three9, p6, DEFAULT_UV, X, Y, Z, FACE_UV_AXES, UVMapper, MinecraftFaceUV;
 var init_UVMapper = __esm({
   "src/UVMapper.ts"() {
     import_three9 = require("three");
@@ -3684,7 +3684,7 @@ var init_UVMapper = __esm({
     init_AssetKey();
     init_ModelGenerator();
     init_log();
-    p5 = prefix("UVMapper");
+    p6 = prefix("UVMapper");
     DEFAULT_UV = [0, 0, 16, 16];
     X = 0;
     Y = 1;
@@ -3945,7 +3945,7 @@ var init_UVMapper = __esm({
           model.elements = originalModel.elements.map((element) => ({ ...element }));
         }
         const isItemModel = !("elements" in model);
-        console.debug(p5, "Creating Atlas for", model.key);
+        console.debug(p6, "Creating Atlas for", model.key);
         if (model.textures) {
           const promises = [];
           const uniqueTextureNames = [];
@@ -3959,7 +3959,7 @@ var init_UVMapper = __esm({
               const assetKey = AssetKey.parse("textures", textureValue, model.key);
               promises.push(ModelTextures.get(assetKey).then((asset2) => {
                 if (!asset2) {
-                  console.warn(p5, "Missing texture", assetKey);
+                  console.warn(p6, "Missing texture", assetKey);
                   return;
                 }
                 textureMap[textureKey] = new WrappedImage(asset2);
@@ -3971,7 +3971,7 @@ var init_UVMapper = __esm({
           }
           await Promise.all(promises);
           const textureCount = uniqueTextureNames.length;
-          console.debug(p5, "Creating Atlas for", textureCount, "textures");
+          console.debug(p6, "Creating Atlas for", textureCount, "textures");
           this.fillMissingTextureKeys(model.textures, textureMap);
           this.fillMissingTextureKeys(model.textures, metaMap);
           const sizes = {};
@@ -4002,7 +4002,7 @@ var init_UVMapper = __esm({
           this.fillMissingTextureKeys(model.textures, sizes);
           const s = Math.ceil(Math.sqrt(textureCount + 1));
           const size = Math.ceil(s * maxWidth);
-          console.debug(p5, "Atlas size:", size);
+          console.debug(p6, "Atlas size:", size);
           const squaredSize = size * size;
           const image = new CanvasImage(size, size);
           const missing = Textures.getMissing().image;
@@ -4081,7 +4081,7 @@ var init_UVMapper = __esm({
           }
           this.fillMissingTextureKeys(model.textures, positions);
           if (isItemModel) {
-            console.debug(p5, "Generating item model for", model);
+            console.debug(p6, "Generating item model for", model);
             model.elements = [];
             for (let layerName of ModelGenerator.ITEM_LAYERS) {
               const textureImage = textureMap[layerName];
@@ -4097,7 +4097,7 @@ var init_UVMapper = __esm({
                 ), layerName));
               }
             }
-            console.debug(p5, "Item model elements", model.elements);
+            console.debug(p6, "Item model elements", model.elements);
           }
           if (!model.elements) {
           }
@@ -4154,7 +4154,7 @@ var init_UVMapper = __esm({
             hasTranslucency
           );
         } else {
-          console.warn(p5, "Model does not have any textures", model);
+          console.warn(p6, "Model does not have any textures", model);
         }
         return void 0;
       }
@@ -4673,7 +4673,7 @@ var init_InstanceReference = __esm({
 function isSceneObject(obj) {
   return obj.isSceneObject;
 }
-var import_three12, import_ts_deepmerge3, p6, _SceneObject, SceneObject;
+var import_three12, import_ts_deepmerge3, p7, _SceneObject, SceneObject;
 var init_SceneObject = __esm({
   "src/renderer/SceneObject.ts"() {
     import_three12 = require("three");
@@ -4687,7 +4687,7 @@ var init_SceneObject = __esm({
     init_Disposable();
     import_ts_deepmerge3 = __toESM(require_dist());
     init_log();
-    p6 = prefix("SceneObject");
+    p7 = prefix("SceneObject");
     _SceneObject = class _SceneObject extends import_three12.Object3D {
       constructor(options) {
         super();
@@ -6934,7 +6934,7 @@ var init_ItemGlint = __esm({
 function isModelObject(obj) {
   return obj.isModelObject;
 }
-var import_three27, import_ts_deepmerge5, p7, _ModelObject, ModelObject;
+var import_three27, import_ts_deepmerge5, p8, _ModelObject, ModelObject;
 var init_ModelObject = __esm({
   "src/model/scene/ModelObject.ts"() {
     init_SceneObject();
@@ -6954,7 +6954,7 @@ var init_ModelObject = __esm({
     init_GuiLight();
     init_ItemTints();
     init_ItemGlint();
-    p7 = prefix("ModelObject");
+    p8 = prefix("ModelObject");
     _ModelObject = class _ModelObject extends SceneObject {
       constructor(originalModel, options) {
         super(options);
@@ -7127,10 +7127,10 @@ var init_ModelObject = __esm({
               }
             });
           } else {
-            console.debug(p7, this.atlas.model, "has no elements");
+            console.debug(p8, this.atlas.model, "has no elements");
           }
         } else {
-          console.debug(p7, "Missing atlas for", this);
+          console.debug(p8, "Missing atlas for", this);
         }
         if (this.options.mergeMeshes) {
           let combinedGeo;
@@ -7571,6 +7571,7 @@ __export(index_browser_exports, {
   Renderer: () => Renderer,
   RequestError: () => RequestError,
   Requests: () => Requests,
+  SCENE_DOCUMENT_MAX_BYTES: () => SCENE_DOCUMENT_MAX_BYTES,
   SKIN_PARTS: () => SKIN_PARTS,
   SceneDocumentLoader: () => SceneDocumentLoader,
   SceneExporter: () => SceneExporter,
@@ -7622,6 +7623,8 @@ __export(index_browser_exports, {
   createGuiTextGeometry: () => createGuiTextGeometry,
   createGuiTextureGeometry: () => createGuiTextureGeometry,
   createImage: () => createImage,
+  decodeSceneDocument: () => decodeSceneDocument,
+  encodeSceneDocument: () => encodeSceneDocument,
   entityAnimationTime: () => entityAnimationTime,
   estimateBytesUsed: () => estimateBytesUsed,
   fluidKindOf: () => fluidKindOf,
@@ -7696,32 +7699,53 @@ init_Env();
 
 // src/env/browser/BrowserCache.ts
 init_PersistentCache();
+init_log();
+var p = prefix("BrowserCache");
 var BrowserCache = class extends PersistentCache {
   constructor(backing) {
     super(backing);
   }
+  async initialize() {
+    try {
+      await this.backing.ready();
+      return true;
+    } catch (error) {
+      this.memory = /* @__PURE__ */ new Map();
+      console.warn(p, "Could not open browser storage; using an in-memory store", error);
+      return false;
+    }
+  }
+  async run(operation, fallback) {
+    if (await (this.initialized ?? (this.initialized = this.initialize()))) return operation();
+    return fallback(this.memory);
+  }
   get(key) {
-    return this.backing.getItem(key);
+    return this.run(() => this.backing.getItem(key), (memory) => memory.get(key));
   }
   put(key, value) {
-    return this.backing.setItem(key, value);
+    return this.run(() => this.backing.setItem(key, value), (memory) => {
+      memory.set(key, value);
+      return value;
+    });
   }
   delete(key) {
-    return this.backing.removeItem(key);
+    return this.run(() => this.backing.removeItem(key), (memory) => {
+      memory.delete(key);
+    });
   }
   clear() {
-    return this.backing.clear();
+    return this.run(() => this.backing.clear(), (memory) => memory.clear());
   }
   length() {
-    return this.backing.length();
+    return this.run(() => this.backing.length(), (memory) => memory.size);
   }
   keys() {
-    return this.backing.keys();
+    return this.run(() => this.backing.keys(), (memory) => [...memory.keys()]);
   }
   forEach(callback) {
-    return this.backing.iterate((v, k) => {
-      callback(v, k);
-    });
+    return this.run(() => this.backing.iterate((value, key) => {
+      callback(value, key);
+    }), (memory) => memory.forEach((value, key) => callback(value, key)));
   }
 };
 
@@ -7929,7 +7953,7 @@ function createPermutation() {
   return values;
 }
 function swampGrassColor(x, z) {
-  const p10 = permutation ?? (permutation = createPermutation());
+  const p11 = permutation ?? (permutation = createPermutation());
   x *= 0.0225;
   z *= 0.0225;
   const s = (x + z) * skew;
@@ -7940,7 +7964,7 @@ function swampGrassColor(x, z) {
   const corner = (gx, gz, a, b) => {
     let falloff = 0.5 - a * a - b * b;
     if (falloff < 0) return 0;
-    const gradient = gradients[p10[gx + p10[gz & 255] & 255] % 12];
+    const gradient = gradients[p11[gx + p11[gz & 255] & 255] % 12];
     falloff *= falloff;
     return falloff * falloff * (gradient[0] * a + gradient[1] * b);
   };
@@ -11903,7 +11927,7 @@ init_SceneObject();
 init_util();
 init_log();
 init_three();
-var p8 = prefix("SceneInspector");
+var p9 = prefix("SceneInspector");
 var help = "<span>Ctrl/Cmd+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
@@ -11997,7 +12021,7 @@ var SceneInspector = class {
   }
   selectObject(targetObject, targetIntersection, instance = this.getIntersectionInstance(targetIntersection)) {
     this.selectedObject = targetObject;
-    console.log(p8, "selected", targetObject);
+    console.log(p9, "selected", targetObject);
     this.redraw(targetObject, targetIntersection, instance);
   }
   redraw(targetObject, targetIntersection, instance) {
@@ -12257,7 +12281,7 @@ var SceneStatsDisplay = class {
 
 // src/instance/InstanceManager.ts
 init_log();
-var p9 = prefix("InstanceManager");
+var p10 = prefix("InstanceManager");
 var InstanceManager = class {
   constructor() {
     this.isInstanceManager = true;
@@ -12266,7 +12290,7 @@ var InstanceManager = class {
   /** Allocates a new placement of a cached model, or returns `undefined` if the key is unknown. */
   async get(key) {
     if (key in this.instanceCache) {
-      console.debug(p9, "key in cache", key);
+      console.debug(p10, "key in cache", key);
       return (await this.instanceCache[key]).nextInstance();
     }
     return void 0;
@@ -12276,7 +12300,7 @@ var InstanceManager = class {
     if (key in this.instanceCache) {
       return await this.get(key);
     }
-    console.debug(p9, "key not in cache", key);
+    console.debug(p10, "key not in cache", key);
     const pending = Promise.resolve().then(supplier).then((obj) => obj.nextInstance());
     this.instanceCache[key] = pending;
     try {
@@ -16263,6 +16287,79 @@ function parseSceneDocument(value) {
   return JSON.parse(JSON.stringify(input));
 }
 
+// src/scene/SceneDocumentCodec.ts
+var SCENE_DOCUMENT_MAX_BYTES = 1024 * 1024;
+async function readBounded(stream, label) {
+  const reader = stream.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > SCENE_DOCUMENT_MAX_BYTES) throw new RangeError(`${label} exceeds ${SCENE_DOCUMENT_MAX_BYTES} bytes`);
+      chunks.push(value);
+    }
+  } catch (error) {
+    await reader.cancel().catch(() => {
+    });
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+function encodeBase64(bytes) {
+  let binary = "";
+  for (let offset = 0; offset < bytes.length; offset += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + 32768));
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function encodeSceneDocument(value) {
+  const scene = parseSceneDocument(value);
+  const bytes = new TextEncoder().encode(JSON.stringify(scene));
+  if (bytes.byteLength > SCENE_DOCUMENT_MAX_BYTES) {
+    throw new RangeError(`Scene document exceeds ${SCENE_DOCUMENT_MAX_BYTES} bytes`);
+  }
+  const compressed = await readBounded(new Blob([bytes]).stream().pipeThrough(new CompressionStream("deflate")), "Encoded scene");
+  return `v1.${encodeBase64(compressed)}`;
+}
+async function decodeSceneDocument(value) {
+  if (!value.startsWith("v1.")) throw new Error("Unsupported scene encoding version; expected v1");
+  const encoded = value.slice(3);
+  if (encoded.length > Math.ceil(SCENE_DOCUMENT_MAX_BYTES * 4 / 3)) {
+    throw new RangeError(`Encoded scene exceeds ${SCENE_DOCUMENT_MAX_BYTES} bytes`);
+  }
+  if (!/^[A-Za-z0-9_-]+$/.test(encoded) || encoded.length % 4 === 1) {
+    throw new Error("Invalid scene base64url encoding");
+  }
+  const binary = atob(encoded.replace(/-/g, "+").replace(/_/g, "/"));
+  const compressed = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+  if (encodeBase64(compressed) !== encoded) throw new Error("Invalid scene base64url encoding");
+  let bytes;
+  try {
+    bytes = await readBounded(new Blob([compressed]).stream().pipeThrough(new DecompressionStream("deflate")), "Scene document");
+  } catch (error) {
+    if (error instanceof RangeError) throw error;
+    throw new Error("Invalid compressed scene document");
+  }
+  let json;
+  try {
+    json = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new Error("Invalid UTF-8 scene document");
+  }
+  return parseSceneDocument(json);
+}
+
 // src/scene/SceneDocumentLoader.ts
 var import_three40 = require("three");
 init_AssetKey();