@playdrop/playdrop-cli 0.16.12 → 0.17.0

package/node_modules/@playdrop/boxel-three/dist/src/voxels/faces.js

@@ -1,344 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var faces_exports = {};
-__export(faces_exports, {
-  FACE_ORDER: () => FACE_ORDER,
-  generateVoxelFaceSurfaces: () => generateVoxelFaceSurfaces
-});
-module.exports = __toCommonJS(faces_exports);
-const FACE_ORDER = ["east", "west", "top", "bottom", "north", "south"];
-const FACE_CONFIGS = {
-  east: { axis: 0, direction: 1, uAxis: 2, vAxis: 1 },
-  west: { axis: 0, direction: -1, uAxis: 2, vAxis: 1 },
-  top: { axis: 1, direction: 1, uAxis: 0, vAxis: 2 },
-  bottom: { axis: 1, direction: -1, uAxis: 0, vAxis: 2 },
-  north: { axis: 2, direction: 1, uAxis: 0, vAxis: 1 },
-  south: { axis: 2, direction: -1, uAxis: 0, vAxis: 1 }
-};
-function clamp(value, min, max) {
-  return Math.min(max, Math.max(min, value));
-}
-function getVoxelAt(voxels, dims, x, y, z) {
-  if (x < 0 || y < 0 || z < 0)
-    return 0;
-  if (x >= dims[0] || y >= dims[1] || z >= dims[2])
-    return 0;
-  const index = x + dims[0] * (y + dims[1] * z);
-  return voxels[index] ?? 0;
-}
-function generateVoxelFaceSurfaces(options) {
-  const { primitive, materialsById, defaultColor } = options;
-  if (!Array.isArray(primitive.voxels) || primitive.voxels.length === 0) {
-    return [];
-  }
-  const size = primitive.size ?? [1, 1, 1];
-  const dims = [
-    Math.max(1, Math.round(size[0])),
-    Math.max(1, Math.round(size[1])),
-    Math.max(1, Math.round(size[2]))
-  ];
-  if (primitive.voxels.length !== dims[0] * dims[1] * dims[2]) {
-    return [];
-  }
-  const voxelSize = [1, 1, 1];
-  const primitiveSize = [
-    dims[0] * voxelSize[0],
-    dims[1] * voxelSize[1],
-    dims[2] * voxelSize[2]
-  ];
-  const palette = primitive.palette ?? [];
-  const patches = [];
-  const createEmptyCell = () => ({
-    color: [0, 0, 0, 0],
-    emissive: [0, 0, 0, 0],
-    occupied: false
-  });
-  const ensurePlane = (planes, planeIndex, surfaceCoord, width, height) => {
-    let plane = planes.get(planeIndex);
-    if (!plane) {
-      const cells = Array.from({ length: height }, () => Array.from({ length: width }, () => createEmptyCell()));
-      plane = { surfaceCoord, cells };
-      planes.set(planeIndex, plane);
-    }
-    return plane;
-  };
-  const halfSize = [primitiveSize[0] / 2, primitiveSize[1] / 2, primitiveSize[2] / 2];
-  FACE_ORDER.forEach((face) => {
-    const config = FACE_CONFIGS[face];
-    const width = dims[config.uAxis];
-    const height = dims[config.vAxis];
-    const planes = /* @__PURE__ */ new Map();
-    for (let x = 0; x < dims[0]; x += 1) {
-      for (let y = 0; y < dims[1]; y += 1) {
-        for (let z = 0; z < dims[2]; z += 1) {
-          const paletteIndex = getVoxelAt(primitive.voxels, dims, x, y, z);
-          if (paletteIndex === 0) {
-            continue;
-          }
-          const neighborCoord = [x, y, z];
-          neighborCoord[config.axis] += config.direction;
-          const neighbor = getVoxelAt(primitive.voxels, dims, neighborCoord[0], neighborCoord[1], neighborCoord[2]);
-          if (neighbor !== 0) {
-            continue;
-          }
-          const uCoord = [x, y, z][config.uAxis];
-          const vCoord = [x, y, z][config.vAxis];
-          const voxelAxis = [x, y, z][config.axis];
-          const surfaceCoord = config.direction > 0 ? voxelAxis + 1 : voxelAxis;
-          const plane = ensurePlane(planes, surfaceCoord, surfaceCoord, width, height);
-          const cell = plane.cells[vCoord][uCoord];
-          const materialId = palette[paletteIndex - 1];
-          const material = materialId ? materialsById.get(materialId) : void 0;
-          const baseColor = material?.baseColor ?? defaultColor;
-          const opacity = material?.opacity !== void 0 ? clamp(material.opacity, 0, 1) : 1;
-          const alpha = Math.round(opacity * 255);
-          cell.color = [baseColor[0], baseColor[1], baseColor[2], alpha];
-          cell.occupied = alpha > 0;
-          if (material?.emissiveColor) {
-            cell.emissive = [material.emissiveColor[0], material.emissiveColor[1], material.emissiveColor[2], 255];
-          } else {
-            cell.emissive = [0, 0, 0, 0];
-          }
-        }
-      }
-    }
-    const cellSizeU = voxelSize[config.uAxis];
-    const cellSizeV = voxelSize[config.vAxis];
-    planes.forEach((plane) => {
-      const visited = Array.from({ length: height }, () => new Array(width).fill(false));
-      for (let v = 0; v < height; v += 1) {
-        for (let u = 0; u < width; u += 1) {
-          if (visited[v][u])
-            continue;
-          const cell = plane.cells[v][u];
-          if (!cell.occupied) {
-            visited[v][u] = true;
-            continue;
-          }
-          let patchWidth = 1;
-          while (u + patchWidth < width) {
-            const nextCell = plane.cells[v][u + patchWidth];
-            if (!nextCell.occupied || visited[v][u + patchWidth])
-              break;
-            patchWidth += 1;
-          }
-          let patchHeight = 1;
-          outer: while (v + patchHeight < height) {
-            for (let offset = 0; offset < patchWidth; offset += 1) {
-              const nextCell = plane.cells[v + patchHeight][u + offset];
-              if (!nextCell.occupied || visited[v + patchHeight][u + offset]) {
-                break outer;
-              }
-            }
-            patchHeight += 1;
-          }
-          for (let dv = 0; dv < patchHeight; dv += 1) {
-            for (let du = 0; du < patchWidth; du += 1) {
-              visited[v + dv][u + du] = true;
-            }
-          }
-          const textureWidth = patchWidth;
-          const textureHeight = patchHeight;
-          const colorBuffer = new Uint8Array(textureWidth * textureHeight * 4);
-          const emissiveBuffer = new Uint8Array(textureWidth * textureHeight * 4);
-          let patchHasEmissive = false;
-          let patchHasTransparency = false;
-          for (let pv = 0; pv < patchHeight; pv += 1) {
-            for (let pu = 0; pu < patchWidth; pu += 1) {
-              const sourceCell = plane.cells[v + pv][u + pu];
-              const targetY = textureHeight - 1 - pv;
-              const targetIndex = (targetY * textureWidth + pu) * 4;
-              colorBuffer[targetIndex] = sourceCell.color[0];
-              colorBuffer[targetIndex + 1] = sourceCell.color[1];
-              colorBuffer[targetIndex + 2] = sourceCell.color[2];
-              colorBuffer[targetIndex + 3] = sourceCell.color[3];
-              if (sourceCell.color[3] < 255) {
-                patchHasTransparency = true;
-              }
-              emissiveBuffer[targetIndex] = sourceCell.emissive[0];
-              emissiveBuffer[targetIndex + 1] = sourceCell.emissive[1];
-              emissiveBuffer[targetIndex + 2] = sourceCell.emissive[2];
-              emissiveBuffer[targetIndex + 3] = sourceCell.emissive[3];
-              if (sourceCell.emissive[3] > 0) {
-                patchHasEmissive = true;
-              }
-            }
-          }
-          const geometry = buildPatchGeometry({
-            face,
-            config,
-            primitiveSize,
-            voxelSize,
-            halfSize,
-            uStart: u,
-            vStart: v,
-            patchWidth,
-            patchHeight,
-            surfaceCoord: plane.surfaceCoord
-          });
-          patches.push({
-            face,
-            width: patchWidth * cellSizeU,
-            height: patchHeight * cellSizeV,
-            textureWidth,
-            textureHeight,
-            color: colorBuffer,
-            emissive: patchHasEmissive ? emissiveBuffer : void 0,
-            hasEmissive: patchHasEmissive,
-            hasTransparency: patchHasTransparency,
-            geometry
-          });
-        }
-      }
-    });
-  });
-  return patches;
-}
-function buildPatchGeometry(options) {
-  const { face, config, voxelSize, halfSize, uStart, vStart, patchWidth, patchHeight, surfaceCoord } = options;
-  const positions = new Float32Array(12);
-  const normals = new Float32Array(12);
-  const uvs = new Float32Array(8);
-  const indices = new Uint16Array([0, 1, 2, 0, 2, 3]);
-  const cellSizeAxis = voxelSize[config.axis];
-  const axisCoord = -halfSize[config.axis] + surfaceCoord * cellSizeAxis;
-  const cellSizeU = voxelSize[config.uAxis];
-  const cellSizeV = voxelSize[config.vAxis];
-  const uMin = -halfSize[config.uAxis] + uStart * cellSizeU;
-  const uMax = uMin + patchWidth * cellSizeU;
-  const vMin = -halfSize[config.vAxis] + vStart * cellSizeV;
-  const vMax = vMin + patchHeight * cellSizeV;
-  const pick = (sign, minValue, maxValue) => sign < 0 ? minValue : maxValue;
-  const vertexOrder = (() => {
-    switch (face) {
-      case "east":
-        return [
-          [-1, -1],
-          [-1, 1],
-          [1, 1],
-          [1, -1]
-        ];
-      case "west":
-        return [
-          [1, -1],
-          [1, 1],
-          [-1, 1],
-          [-1, -1]
-        ];
-      case "top":
-        return [
-          [-1, -1],
-          [-1, 1],
-          [1, 1],
-          [1, -1]
-        ];
-      case "bottom":
-        return [
-          [-1, -1],
-          [1, -1],
-          [1, 1],
-          [-1, 1]
-        ];
-      case "north":
-        return [
-          [-1, -1],
-          [1, -1],
-          [1, 1],
-          [-1, 1]
-        ];
-      case "south":
-      default:
-        return [
-          [1, -1],
-          [-1, -1],
-          [-1, 1],
-          [1, 1]
-        ];
-    }
-  })();
-  const uvOrder = (() => {
-    switch (face) {
-      case "east":
-        return [
-          [0, 1],
-          [0, 0],
-          [1, 0],
-          [1, 1]
-        ];
-      case "west":
-        return [
-          [1, 1],
-          [1, 0],
-          [0, 0],
-          [0, 1]
-        ];
-      case "top":
-        return [
-          [0, 1],
-          [0, 0],
-          [1, 0],
-          [1, 1]
-        ];
-      case "bottom":
-        return [
-          [0, 0],
-          [1, 0],
-          [1, 1],
-          [0, 1]
-        ];
-      case "north":
-        return [
-          [0, 1],
-          [1, 1],
-          [1, 0],
-          [0, 0]
-        ];
-      case "south":
-      default:
-        return [
-          [1, 1],
-          [0, 1],
-          [0, 0],
-          [1, 0]
-        ];
-    }
-  })();
-  for (let i = 0; i < vertexOrder.length; i += 1) {
-    const [uSign, vSign] = vertexOrder[i];
-    const pos = [0, 0, 0];
-    pos[config.axis] = axisCoord;
-    pos[config.uAxis] = pick(uSign, uMin, uMax);
-    pos[config.vAxis] = pick(vSign, vMin, vMax);
-    positions[i * 3] = pos[0];
-    positions[i * 3 + 1] = pos[1];
-    positions[i * 3 + 2] = pos[2];
-    const normal = [0, 0, 0];
-    normal[config.axis] = config.direction;
-    normals[i * 3] = normal[0];
-    normals[i * 3 + 1] = normal[1];
-    normals[i * 3 + 2] = normal[2];
-    uvs[i * 2] = uvOrder[i][0];
-    uvs[i * 2 + 1] = uvOrder[i][1];
-  }
-  return { positions, normals, uvs, indices };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  FACE_ORDER,
-  generateVoxelFaceSurfaces
-});

package/node_modules/@playdrop/boxel-three/dist/src/voxels/mesher.d.ts

@@ -1,24 +0,0 @@
-import { type VoxelBox } from "@playdrop/boxel-core";
-export interface BuildVoxelMeshOptions {
-    voxels: number[];
-    dimensions: [number, number, number];
-    size: [number, number, number];
-}
-export interface VoxelMaterialGroup {
-    material: number;
-    start: number;
-    count: number;
-}
-export interface VoxelMeshResult {
-    positions: Float32Array;
-    normals: Float32Array;
-    uvs: Float32Array;
-    indices: Uint32Array;
-    groups: VoxelMaterialGroup[];
-    stats: {
-        voxels: number;
-        faces: number;
-    };
-}
-export declare function buildVoxelMesh(options: BuildVoxelMeshOptions): VoxelMeshResult;
-export declare function hasVoxelData(primitive: VoxelBox): boolean;

package/node_modules/@playdrop/boxel-three/dist/src/voxels/mesher.js

@@ -1,113 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var mesher_exports = {};
-__export(mesher_exports, {
-  buildVoxelMesh: () => buildVoxelMesh,
-  hasVoxelData: () => hasVoxelData
-});
-module.exports = __toCommonJS(mesher_exports);
-var import_boxel_core = require("@playdrop/boxel-core");
-function buildVoxelMesh(options) {
-  const { voxels, dimensions, size } = options;
-  const quads = (0, import_boxel_core.generateGreedyQuads)(voxels, dimensions);
-  const halfSize = [size[0] / 2, size[1] / 2, size[2] / 2];
-  const cellSizes = [
-    dimensions[0] > 0 ? size[0] / dimensions[0] : 1,
-    dimensions[1] > 0 ? size[1] / dimensions[1] : 1,
-    dimensions[2] > 0 ? size[2] / dimensions[2] : 1
-  ];
-  if (quads.length === 0) {
-    return {
-      positions: new Float32Array(0),
-      normals: new Float32Array(0),
-      uvs: new Float32Array(0),
-      indices: new Uint32Array(0),
-      groups: [],
-      stats: {
-        voxels: voxels.filter((value) => value !== 0).length,
-        faces: 0
-      }
-    };
-  }
-  const positions = [];
-  const normals = [];
-  const uvs = [];
-  const indices = [];
-  const groups = [];
-  const pushQuad = (quad) => {
-    const baseIndex = positions.length / 3;
-    const axis = quad.axis;
-    const uAxis = (axis + 1) % 3;
-    const vAxis = (axis + 2) % 3;
-    const width = quad.size[0];
-    const height = quad.size[1];
-    const base = [quad.origin[0], quad.origin[1], quad.origin[2]];
-    base[axis] = quad.plane;
-    const corners = quad.normal === 1 ? [
-      [0, 0],
-      [width, 0],
-      [width, height],
-      [0, height]
-    ] : [
-      [0, 0],
-      [0, height],
-      [width, height],
-      [width, 0]
-    ];
-    const normalVector = [0, 0, 0];
-    normalVector[axis] = quad.normal;
-    corners.forEach(([uOffset, vOffset]) => {
-      const vertex = [base[0], base[1], base[2]];
-      vertex[uAxis] = base[uAxis] + uOffset;
-      vertex[vAxis] = base[vAxis] + vOffset;
-      positions.push(vertex[0] * cellSizes[0] - halfSize[0], vertex[1] * cellSizes[1] - halfSize[1], vertex[2] * cellSizes[2] - halfSize[2]);
-      normals.push(normalVector[0], normalVector[1], normalVector[2]);
-      const u = width > 0 ? uOffset / width : 0;
-      const v = height > 0 ? vOffset / height : 0;
-      uvs.push(u, v);
-    });
-    const startIndex = indices.length;
-    indices.push(baseIndex, baseIndex + 1, baseIndex + 2, baseIndex, baseIndex + 2, baseIndex + 3);
-    const lastGroup = groups[groups.length - 1];
-    if (lastGroup && lastGroup.material === quad.material && lastGroup.start + lastGroup.count === startIndex) {
-      lastGroup.count += 6;
-    } else {
-      groups.push({ material: quad.material, start: startIndex, count: 6 });
-    }
-  };
-  quads.forEach(pushQuad);
-  return {
-    positions: Float32Array.from(positions),
-    normals: Float32Array.from(normals),
-    uvs: Float32Array.from(uvs),
-    indices: Uint32Array.from(indices),
-    groups,
-    stats: {
-      voxels: voxels.filter((value) => value !== 0).length,
-      faces: quads.length
-    }
-  };
-}
-function hasVoxelData(primitive) {
-  return Array.isArray(primitive.voxels) && primitive.voxels.length > 0;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  buildVoxelMesh,
-  hasVoxelData
-});

package/node_modules/@playdrop/boxel-three/dist/test/export-image.playwright.test.d.ts

@@ -1 +0,0 @@
-export {};

package/node_modules/@playdrop/boxel-three/dist/test/export-image.playwright.test.js

@@ -1,137 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var import_node_test = __toESM(require("node:test"));
-var import_strict = __toESM(require("node:assert/strict"));
-var import_node_path = __toESM(require("node:path"));
-var import_node_url = require("node:url");
-const import_meta = {};
-const HERE = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
-const WORKER_ENTRY = import_node_path.default.resolve(HERE, "fixtures/render-worker.js");
-async function bundleEntityWorker() {
-  const { build } = await import("esbuild");
-  const result = await build({
-    entryPoints: [WORKER_ENTRY],
-    bundle: true,
-    platform: "browser",
-    format: "esm",
-    target: "es2022",
-    write: false,
-    sourcemap: false,
-    logLevel: "silent"
-  });
-  const output = result.outputFiles?.[0]?.text;
-  if (!output) {
-    throw new Error("failed_to_bundle_entity_worker");
-  }
-  return output;
-}
-function createPlaywrightLaunchError(tool, error) {
-  const message = error && typeof error === "object" && "message" in error ? String(error.message) : String(error);
-  if (/browserType\.launch/i.test(message) || /MachPortRendezvousServer/i.test(message)) {
-    return new Error([
-      `[${tool}] Failed to launch Playwright Chromium.`,
-      "",
-      "Required setup:",
-      "  1. npx playwright install chromium",
-      '  2. On macOS: xattr -dr com.apple.quarantine "$HOME/Library/Caches/ms-playwright"',
-      "",
-      `Original error: ${message}`
-    ].join("\n"));
-  }
-  return error instanceof Error ? error : new Error(message);
-}
-(0, import_node_test.default)("renderBoxelToDataURL produces a PNG data URL", async (t) => {
-  const { chromium } = await import("playwright-core");
-  const bundle = await bundleEntityWorker();
-  let browser = null;
-  try {
-    browser = await chromium.launch({ headless: true, args: ["--no-sandbox"], chromiumSandbox: false });
-  } catch (error) {
-    const launchError = createPlaywrightLaunchError("boxel-three-test", error);
-    t.skip(launchError.message);
-    return;
-  }
-  const page = await browser.newPage({ viewport: { width: 512, height: 512 } });
-  const consoleErrors = [];
-  page.on("console", (message) => {
-    if (message.type() === "error") {
-      consoleErrors.push(message.text());
-    }
-  });
-  page.on("pageerror", (error) => {
-    consoleErrors.push(error?.message ?? String(error));
-  });
-  try {
-    await page.setContent('<canvas id="viewport"></canvas>', { waitUntil: "domcontentloaded" });
-    await page.addScriptTag({ type: "module", content: bundle });
-    await page.waitForFunction(() => typeof window.boxelExport !== "undefined");
-    const minimalEntity = {
-      id: "render-test",
-      geometry: {
-        id: "geom",
-        root: {
-          id: "Root",
-          position: [0, 0, 0],
-          children: [
-            {
-              id: "Node",
-              position: [0, 0.5, 0],
-              mesh: "box",
-              children: []
-            }
-          ]
-        }
-      },
-      primitives: [
-        {
-          id: "box",
-          kind: "plain_box",
-          size: [1, 1, 1],
-          material: "mat"
-        }
-      ],
-      materials: [{ id: "mat", baseColor: [200, 120, 60] }],
-      textures: [],
-      patterns: [],
-      animations: []
-    };
-    const dataUrl = await page.evaluate((model) => window.boxelExport.renderBoxel(model, {
-      mode: "hierarchical",
-      width: 512,
-      height: 512,
-      direction: "preview",
-      animationIds: null
-    }), minimalEntity);
-    import_strict.default.strictEqual(typeof dataUrl, "string");
-    import_strict.default.ok(dataUrl.startsWith("data:image/png;base64,"), "Render output is not a PNG data URL");
-    import_strict.default.ok(dataUrl.length > "data:image/png;base64,".length, "Render output is empty");
-    if (consoleErrors.length > 0) {
-      throw new Error(consoleErrors.join("\n"));
-    }
-  } finally {
-    await page.close();
-    if (browser) {
-      await browser.close();
-    }
-  }
-});

package/node_modules/@playdrop/boxel-three/dist/test/fixtures/render-worker.d.ts

@@ -1,20 +0,0 @@
-import { type ExportMode } from "../../src/index.js";
-interface ExportEntityOptions {
-    mode?: ExportMode;
-    animationIds?: string[] | null;
-}
-interface RenderEntityOptions extends ExportEntityOptions {
-    width?: number;
-    height?: number;
-    direction?: string;
-    background?: number | string | null;
-}
-declare global {
-    interface Window {
-        boxelExport?: {
-            exportBoxel(modelJson: unknown, options?: ExportEntityOptions): Promise<string>;
-            renderBoxel(modelJson: unknown, options?: RenderEntityOptions): Promise<string>;
-        };
-    }
-}
-export {};