@playdrop/playdrop-cli 0.16.5 → 0.16.12

package/node_modules/@playdrop/boxel-core/dist/src/types.d.ts

@@ -8,8 +8,8 @@ export type GeometryId = string;
 export type AnimationId = string;
 export type Vec2 = [number, number];
 export type Vec3 = [number, number, number];
-export type PrimitiveKind = 'plain_box' | 'textured_box' | 'voxel_box' | 'combo_box';
-export type ConnectMode = 'none' | 'child' | 'parent' | 'both';
+export type PrimitiveKind = "plain_box" | "textured_box" | "voxel_box" | "combo_box";
+export type ConnectMode = "none" | "child" | "parent" | "both";
 export interface Node {
     id: NodeId;
     position: Vec3;
@@ -71,11 +71,11 @@ interface BoxPrimitiveBase {
     size: Vec3;
 }
 export interface PlainBox extends BoxPrimitiveBase {
-    kind: 'plain_box';
+    kind: "plain_box";
     material: MaterialId;
 }
 export interface TexturedBox extends BoxPrimitiveBase {
-    kind: 'textured_box';
+    kind: "textured_box";
     top?: TextureId | undefined;
     bottom?: TextureId | undefined;
     north?: TextureId | undefined;
@@ -97,7 +97,7 @@ export interface TexturedBox extends BoxPrimitiveBase {
      * - `plain`: opaque surface; faces are single sided and rendered without alpha cutouts.
      * - `cutout`: semi-transparent/cutout surface; faces render double sided with alpha testing.
      */
-    renderMode?: 'plain' | 'cutout' | undefined;
+    renderMode?: "plain" | "cutout" | undefined;
     /**
      * Optional overlay textures rendered as a thin outer shell using cutout blending. Overlay fields
      * follow the same fallback rules as their base counterparts (face > sides > all).
@@ -112,7 +112,7 @@ export interface TexturedBox extends BoxPrimitiveBase {
     allOverlay?: TextureId | undefined;
 }
 export interface VoxelBox extends BoxPrimitiveBase {
-    kind: 'voxel_box';
+    kind: "voxel_box";
     /**
      * Flattened material indices for the voxel volume. Length must equal size[0] * size[1] * size[2].
      * Index ordering is X-major, then Y, then Z (x + y * sizeX + z * sizeX * sizeY). A value of 0
@@ -126,7 +126,7 @@ export interface VoxelBox extends BoxPrimitiveBase {
     palette: MaterialId[];
 }
 export interface ComboBox extends BoxPrimitiveBase {
-    kind: 'combo_box';
+    kind: "combo_box";
     slots: Array<{
         id: string;
         primitive: PrimitiveId;
@@ -134,7 +134,7 @@ export interface ComboBox extends BoxPrimitiveBase {
     }>;
 }
 export type Primitive = PlainBox | TexturedBox | VoxelBox | ComboBox;
-export type AnimationChannelProperty = 'position' | 'rotation' | 'scale';
+export type AnimationChannelProperty = "position" | "rotation" | "scale";
 export interface AnimationKeyframe {
     time: number;
     value: Vec3;

package/node_modules/@playdrop/boxel-core/dist/src/validation.d.ts

@@ -1,4 +1,4 @@
-import type { Animation, BoxelDefinition, Material, Pattern, Primitive, Texture, TexturedBox, Vec2, Vec3 } from './types';
+import type { Animation, BoxelDefinition, Material, Pattern, Primitive, Texture, TexturedBox, Vec2, Vec3 } from "./types";
 export interface BoxelValidationIssue {
     path: string;
     message: string;

package/node_modules/@playdrop/boxel-core/dist/src/validation.js

@@ -16,26 +16,26 @@ exports.collectBoxelValidationIssues = collectBoxelValidationIssues;
 const textures_1 = require("./textures");
 const VEC2_LENGTH = 2;
 const VEC3_LENGTH = 3;
-const CONNECT_MODES = ['none', 'child', 'parent', 'both'];
-const isConnectMode = (value) => typeof value === 'string' && CONNECT_MODES.includes(value);
+const CONNECT_MODES = ["none", "child", "parent", "both"];
+const isConnectMode = (value) => typeof value === "string" && CONNECT_MODES.includes(value);
 class BoxelValidationError extends Error {
     constructor(message, issues) {
         super(message);
         this.issues = issues;
-        this.name = 'BoxelValidationError';
+        this.name = "BoxelValidationError";
     }
 }
 exports.BoxelValidationError = BoxelValidationError;
 const sanitizeMessage = (error) => {
     if (!error)
-        return 'Unknown validation error';
-    if (typeof error === 'string')
+        return "Unknown validation error";
+    if (typeof error === "string")
         return error;
     if (error instanceof Error)
         return error.message;
-    if (typeof error === 'object' && 'message' in error) {
+    if (typeof error === "object" && "message" in error) {
         const candidate = error.message;
-        return typeof candidate === 'string' ? candidate : 'Unknown validation error';
+        return typeof candidate === "string" ? candidate : "Unknown validation error";
     }
     return String(error);
 };
@@ -43,7 +43,9 @@ const pushIssue = (issues, path, error) => {
     issues.push({ path, message: sanitizeMessage(error) });
 };
 function isTupleOfNumbers(value, expectedLength) {
-    return Array.isArray(value) && value.length === expectedLength && value.every(item => typeof item === 'number' && Number.isFinite(item));
+    return (Array.isArray(value) &&
+        value.length === expectedLength &&
+        value.every((item) => typeof item === "number" && Number.isFinite(item)));
 }
 function assertVec3(value, context) {
     if (!isTupleOfNumbers(value, VEC3_LENGTH)) {
@@ -56,16 +58,16 @@ function assertVec2(value, context) {
     }
 }
 function assertPattern(value, index) {
-    if (!value || typeof value !== 'object') {
+    if (!value || typeof value !== "object") {
         throw new Error(`Pattern at index ${index} must be an object`);
     }
     const pattern = value;
-    if (typeof pattern.id !== 'string') {
+    if (typeof pattern.id !== "string") {
         throw new Error(`Pattern at index ${index} is missing id`);
     }
     assertVec2(pattern.size, `pattern ${pattern.id} size`);
     const patternSize = pattern.size;
-    if (!Array.isArray(pattern.data) || !pattern.data.every(cell => Number.isInteger(cell) && cell >= 0)) {
+    if (!Array.isArray(pattern.data) || !pattern.data.every((cell) => Number.isInteger(cell) && cell >= 0)) {
         throw new Error(`Pattern ${pattern.id} data must be an array of non-negative integers`);
     }
     const expectedLength = patternSize[0] * patternSize[1];
@@ -74,74 +76,74 @@ function assertPattern(value, index) {
     }
 }
 function assertMaterial(value, index) {
-    if (!value || typeof value !== 'object') {
+    if (!value || typeof value !== "object") {
         throw new Error(`Material at index ${index} must be an object`);
     }
     const material = value;
-    if (typeof material.id !== 'string') {
+    if (typeof material.id !== "string") {
         throw new Error(`Material at index ${index} is missing id`);
     }
     assertVec3(material.baseColor, `material ${material.id} baseColor`);
     if (material.emissiveColor !== undefined) {
         assertVec3(material.emissiveColor, `material ${material.id} emissiveColor`);
     }
-    if (material.opacity !== undefined && (typeof material.opacity !== 'number' || !Number.isFinite(material.opacity))) {
+    if (material.opacity !== undefined && (typeof material.opacity !== "number" || !Number.isFinite(material.opacity))) {
         throw new Error(`Material ${material.id} opacity must be a finite number`);
     }
 }
 function assertTexture(value, index) {
-    if (!value || typeof value !== 'object') {
+    if (!value || typeof value !== "object") {
         throw new Error(`Texture at index ${index} must be an object`);
     }
     const texture = value;
-    if (typeof texture.id !== 'string') {
+    if (typeof texture.id !== "string") {
         throw new Error(`Texture at index ${index} is missing id`);
     }
-    if (typeof texture.pattern !== 'string') {
+    if (typeof texture.pattern !== "string") {
         throw new Error(`Texture ${texture.id} pattern must be a string`);
     }
-    if (!Array.isArray(texture.materials) || !texture.materials.every(id => typeof id === 'string')) {
+    if (!Array.isArray(texture.materials) || !texture.materials.every((id) => typeof id === "string")) {
         throw new Error(`Texture ${texture.id} materials must be an array of strings`);
     }
 }
 function assertPlainBox(primitive, context) {
-    if (primitive.kind !== 'plain_box') {
+    if (primitive.kind !== "plain_box") {
         throw new Error(`${context} expected kind plain_box`);
     }
-    if (typeof primitive.material !== 'string') {
+    if (typeof primitive.material !== "string") {
         throw new Error(`${context} material must be a string`);
     }
 }
 function assertTexturedBox(primitive, context) {
-    if (primitive.kind !== 'textured_box') {
+    if (primitive.kind !== "textured_box") {
         throw new Error(`${context} expected kind textured_box`);
     }
     const candidate = primitive;
-    const faces = ['top', 'bottom', 'north', 'south', 'east', 'west', 'sides', 'all'];
-    faces.forEach(face => {
+    const faces = ["top", "bottom", "north", "south", "east", "west", "sides", "all"];
+    faces.forEach((face) => {
         const value = candidate[face];
-        if (value !== undefined && typeof value !== 'string') {
+        if (value !== undefined && typeof value !== "string") {
             throw new Error(`${context} face ${face} must be a string id`);
         }
     });
 }
 function assertVoxelBox(primitive, context) {
-    if (primitive.kind !== 'voxel_box') {
+    if (primitive.kind !== "voxel_box") {
         throw new Error(`${context} expected kind voxel_box`);
     }
     const candidate = primitive;
-    if (!Array.isArray(candidate.voxels) || !candidate.voxels.every(cell => typeof cell === 'number')) {
+    if (!Array.isArray(candidate.voxels) || !candidate.voxels.every((cell) => typeof cell === "number")) {
         throw new Error(`${context} voxels must be an array of numbers`);
     }
     if (candidate.palette !== undefined) {
-        if (!Array.isArray(candidate.palette) || !candidate.palette.every(entry => typeof entry === 'string')) {
+        if (!Array.isArray(candidate.palette) || !candidate.palette.every((entry) => typeof entry === "string")) {
             throw new Error(`${context} palette must be an array of material ids`);
         }
     }
     const size = primitive.size;
     assertVec3(size, `${context} size`);
-    const dims = size.map(axis => Math.round(axis));
-    if (dims.some(value => value <= 0 || !Number.isFinite(value))) {
+    const dims = size.map((axis) => Math.round(axis));
+    if (dims.some((value) => value <= 0 || !Number.isFinite(value))) {
         throw new Error(`${context} size must contain positive finite numbers`);
     }
     const expected = dims[0] * dims[1] * dims[2];
@@ -150,7 +152,7 @@ function assertVoxelBox(primitive, context) {
     }
 }
 function assertComboBox(primitive, context) {
-    if (primitive.kind !== 'combo_box') {
+    if (primitive.kind !== "combo_box") {
         throw new Error(`${context} expected kind combo_box`);
     }
     const candidate = primitive;
@@ -158,43 +160,43 @@ function assertComboBox(primitive, context) {
         throw new Error(`${context} slots must be an array`);
     }
     candidate.slots.forEach((slot, idx) => {
-        if (!slot || typeof slot !== 'object') {
+        if (!slot || typeof slot !== "object") {
             throw new Error(`${context} slot ${idx} must be an object`);
         }
         const slotId = slot.id;
-        if (slotId !== undefined && typeof slotId !== 'string') {
+        if (slotId !== undefined && typeof slotId !== "string") {
             throw new Error(`${context} slot ${idx} id must be a string when provided`);
         }
-        if (typeof slot.primitive !== 'string') {
+        if (typeof slot.primitive !== "string") {
             throw new Error(`${context} slot ${idx} primitive must be a string`);
         }
         assertVec3(slot.offset, `${context} slot ${idx} offset`);
     });
 }
 function assertPrimitive(value, index) {
-    if (!value || typeof value !== 'object') {
+    if (!value || typeof value !== "object") {
         throw new Error(`Primitive at index ${index} must be an object`);
     }
     const primitive = value;
-    if (typeof primitive.id !== 'string') {
+    if (typeof primitive.id !== "string") {
         throw new Error(`Primitive at index ${index} is missing id`);
     }
     const primitiveId = primitive.id;
-    if (typeof primitive.kind !== 'string') {
+    if (typeof primitive.kind !== "string") {
         throw new Error(`Primitive ${primitiveId} kind must be a string discriminator`);
     }
     assertVec3(primitive.size, `primitive ${primitiveId} size`);
     switch (primitive.kind) {
-        case 'plain_box':
+        case "plain_box":
             assertPlainBox(primitive, `primitive ${primitiveId}`);
             break;
-        case 'textured_box':
+        case "textured_box":
             assertTexturedBox(primitive, `primitive ${primitiveId}`);
             break;
-        case 'voxel_box':
+        case "voxel_box":
             assertVoxelBox(primitive, `primitive ${primitiveId}`);
             break;
-        case 'combo_box':
+        case "combo_box":
             assertComboBox(primitive, `primitive ${primitiveId}`);
             break;
         default: {
@@ -203,41 +205,41 @@ function assertPrimitive(value, index) {
         }
     }
 }
-const animationProperties = ['position', 'rotation', 'scale'];
+const animationProperties = ["position", "rotation", "scale"];
 function assertAnimationChannel(value, context) {
-    if (!value || typeof value !== 'object') {
+    if (!value || typeof value !== "object") {
         throw new Error(`${context} channel must be an object`);
     }
     const channel = value;
-    if (typeof channel.node !== 'string') {
+    if (typeof channel.node !== "string") {
         throw new Error(`${context} channel node must be a string`);
     }
     if (!animationProperties.includes(channel.property)) {
-        throw new Error(`${context} channel property must be one of ${animationProperties.join(', ')}`);
+        throw new Error(`${context} channel property must be one of ${animationProperties.join(", ")}`);
     }
     if (!Array.isArray(channel.keyframes)) {
         throw new Error(`${context} keyframes must be an array`);
     }
     channel.keyframes.forEach((keyframe, idx) => {
-        if (!keyframe || typeof keyframe !== 'object') {
+        if (!keyframe || typeof keyframe !== "object") {
             throw new Error(`${context} keyframe ${idx} must be an object`);
         }
         const reference = keyframe;
-        if (typeof reference.time !== 'number' || !Number.isFinite(reference.time) || reference.time < 0) {
+        if (typeof reference.time !== "number" || !Number.isFinite(reference.time) || reference.time < 0) {
             throw new Error(`${context} keyframe ${idx} time must be a non-negative number`);
         }
         assertVec3(reference.value, `${context} keyframe ${idx} value`);
     });
 }
 function assertAnimation(value, index) {
-    if (!value || typeof value !== 'object') {
+    if (!value || typeof value !== "object") {
         throw new Error(`Animation at index ${index} must be an object`);
     }
     const animation = value;
-    if (typeof animation.id !== 'string' || !animation.id) {
+    if (typeof animation.id !== "string" || !animation.id) {
         throw new Error(`Animation at index ${index} is missing id`);
     }
-    if (typeof animation.duration !== 'number' || !Number.isFinite(animation.duration) || animation.duration < 0) {
+    if (typeof animation.duration !== "number" || !Number.isFinite(animation.duration) || animation.duration < 0) {
         throw new Error(`Animation ${animation.id} duration must be a non-negative finite number`);
     }
     if (!Array.isArray(animation.channels)) {
@@ -246,12 +248,12 @@ function assertAnimation(value, index) {
     animation.channels.forEach((channel, channelIndex) => assertAnimationChannel(channel, `animation ${animation.id} channel ${channelIndex}`));
 }
 const FACE_DIMENSIONS = {
-    top: size => [size[0], size[2]],
-    bottom: size => [size[0], size[2]],
-    north: size => [size[0], size[1]],
-    south: size => [size[0], size[1]],
-    east: size => [size[2], size[1]],
-    west: size => [size[2], size[1]],
+    top: (size) => [size[0], size[2]],
+    bottom: (size) => [size[0], size[2]],
+    north: (size) => [size[0], size[1]],
+    south: (size) => [size[0], size[1]],
+    east: (size) => [size[2], size[1]],
+    west: (size) => [size[2], size[1]],
     sides: () => [0, 0],
     all: () => [0, 0],
 };
@@ -269,15 +271,11 @@ function assertTexturedBoxFaceSizes(box, textureLookup, patternLookup, materialL
             throw new Error(`primitive ${box.id} size component ${idx} must be finite to validate textures`);
         }
     });
-    const normalizedSize = [
-        normalizeDimension(sizeX),
-        normalizeDimension(sizeY),
-        normalizeDimension(sizeZ),
-    ];
-    if (normalizedSize.some(dimension => dimension === 0)) {
+    const normalizedSize = [normalizeDimension(sizeX), normalizeDimension(sizeY), normalizeDimension(sizeZ)];
+    if (normalizedSize.some((dimension) => dimension === 0)) {
         throw new Error(`primitive ${box.id} must not contain zero-sized dimensions for textured faces`);
     }
-    ['top', 'bottom', 'north', 'south', 'east', 'west'].forEach(face => {
+    ["top", "bottom", "north", "south", "east", "west"].forEach((face) => {
         const textureId = (0, textures_1.resolveFaceTextureId)(box, face);
         if (!textureId) {
             return;
@@ -306,7 +304,7 @@ function assertTexturedBoxFaceSizes(box, textureLookup, patternLookup, materialL
             throw new Error(`primitive ${box.id} face ${face} expects texture size ${expectedWidth}x${expectedHeight} but texture ${textureId} pattern ${pattern.id} is ${patternWidth}x${patternHeight}`);
         }
     });
-    ['top', 'bottom', 'north', 'south', 'east', 'west'].forEach(face => {
+    ["top", "bottom", "north", "south", "east", "west"].forEach((face) => {
         const textureId = (0, textures_1.resolveOverlayFaceTextureId)(box, face);
         if (!textureId) {
             return;
@@ -335,17 +333,17 @@ function assertTexturedBoxFaceSizes(box, textureLookup, patternLookup, materialL
             throw new Error(`primitive ${box.id} overlay face ${face} expects texture size ${expectedWidth}x${expectedHeight} but texture ${textureId} pattern ${pattern.id} is ${patternWidth}x${patternHeight}`);
         }
     });
-    const mode = box.renderMode ?? 'plain';
-    if (mode !== 'plain' && mode !== 'cutout') {
+    const mode = box.renderMode ?? "plain";
+    if (mode !== "plain" && mode !== "cutout") {
         throw new Error(`primitive ${box.id} has invalid renderMode ${String(mode)}`);
     }
     const faceTextureIds = (0, textures_1.collectFaceTextureIds)(box);
-    const usesTransparency = faceTextureIds.some(textureId => {
+    const usesTransparency = faceTextureIds.some((textureId) => {
         const texture = textureLookup.get(textureId);
         if (!texture) {
             return false;
         }
-        return texture.materials.some(materialId => {
+        return texture.materials.some((materialId) => {
             const material = materialLookup.get(materialId);
             if (!material) {
                 return false;
@@ -356,16 +354,16 @@ function assertTexturedBoxFaceSizes(box, textureLookup, patternLookup, materialL
             return Number(material.opacity) < 1;
         });
     });
-    if (mode === 'plain' && usesTransparency) {
+    if (mode === "plain" && usesTransparency) {
         throw new Error(`primitive ${box.id} renderMode plain but references textures with transparent materials`);
     }
 }
 function assertNode(value, path, primitiveLookup) {
-    if (!value || typeof value !== 'object') {
+    if (!value || typeof value !== "object") {
         throw new Error(`Node ${path} must be an object`);
     }
     const node = value;
-    if (typeof node.id !== 'string') {
+    if (typeof node.id !== "string") {
         throw new Error(`Node ${path} is missing id`);
     }
     assertVec3(node.position, `node ${node.id} position`);
@@ -384,14 +382,14 @@ function assertNode(value, path, primitiveLookup) {
     if (node.connect !== undefined) {
         const connectValue = node.connect;
         if (connectValue === true) {
-            node.connect = 'child';
+            node.connect = "child";
         }
         else if (connectValue === false) {
             delete node.connect;
         }
-        else if (typeof connectValue === 'string') {
+        else if (typeof connectValue === "string") {
             if (!isConnectMode(connectValue)) {
-                throw new Error(`Node ${node.id} connect must be one of ${CONNECT_MODES.join(', ')}`);
+                throw new Error(`Node ${node.id} connect must be one of ${CONNECT_MODES.join(", ")}`);
             }
             node.connect = connectValue;
         }
@@ -400,7 +398,7 @@ function assertNode(value, path, primitiveLookup) {
         }
     }
     if (node.mesh !== undefined) {
-        if (typeof node.mesh !== 'string') {
+        if (typeof node.mesh !== "string") {
             throw new Error(`Node ${node.id} mesh must be a primitive id`);
         }
         if (!primitiveLookup.has(node.mesh)) {
@@ -414,7 +412,7 @@ function assertNode(value, path, primitiveLookup) {
 }
 function collectNodeIds(node, set) {
     set.add(node.id);
-    node.children.forEach(child => collectNodeIds(child, set));
+    node.children.forEach((child) => collectNodeIds(child, set));
 }
 function assertAnimationChannels(animation, nodeIds) {
     const seenChannels = new Set();
@@ -442,22 +440,22 @@ function assertAnimationChannels(animation, nodeIds) {
 }
 function validateBoxel(candidate) {
     const issues = [];
-    if (!candidate || typeof candidate !== 'object') {
-        pushIssue(issues, 'boxel', 'BoxelDefinition must be an object');
+    if (!candidate || typeof candidate !== "object") {
+        pushIssue(issues, "boxel", "BoxelDefinition must be an object");
         return { boxel: null, issues };
     }
     const raw = candidate;
     let id = null;
-    if (typeof raw.id === 'string' && raw.id.trim().length > 0) {
+    if (typeof raw.id === "string" && raw.id.trim().length > 0) {
         id = raw.id;
     }
     else {
-        pushIssue(issues, 'boxel.id', 'BoxelDefinition id must be a non-empty string');
+        pushIssue(issues, "boxel.id", "BoxelDefinition id must be a non-empty string");
     }
     const primitives = [];
     const primitiveLookup = new Map();
     if (!Array.isArray(raw.primitives)) {
-        pushIssue(issues, 'boxel.primitives', 'BoxelDefinition primitives must be an array');
+        pushIssue(issues, "boxel.primitives", "BoxelDefinition primitives must be an array");
     }
     else {
         raw.primitives.forEach((primitive, index) => {
@@ -473,32 +471,32 @@ function validateBoxel(candidate) {
     }
     let geometry = null;
     const geometryNodeIds = new Set();
-    if (!raw.geometry || typeof raw.geometry !== 'object') {
-        pushIssue(issues, 'boxel.geometry', 'BoxelDefinition geometry is missing or invalid');
+    if (!raw.geometry || typeof raw.geometry !== "object") {
+        pushIssue(issues, "boxel.geometry", "BoxelDefinition geometry is missing or invalid");
     }
     else {
         const geo = raw.geometry;
-        if (typeof geo.id !== 'string') {
-            pushIssue(issues, 'boxel.geometry.id', 'Geometry id must be a string');
+        if (typeof geo.id !== "string") {
+            pushIssue(issues, "boxel.geometry.id", "Geometry id must be a string");
         }
         else if (!geo.root) {
-            pushIssue(issues, 'boxel.geometry.root', 'Geometry root is missing');
+            pushIssue(issues, "boxel.geometry.root", "Geometry root is missing");
         }
         else {
             try {
-                assertNode(geo.root, 'root', primitiveLookup);
+                assertNode(geo.root, "root", primitiveLookup);
                 geometry = geo;
                 collectNodeIds(geo.root, geometryNodeIds);
             }
             catch (error) {
-                pushIssue(issues, 'boxel.geometry.root', error);
+                pushIssue(issues, "boxel.geometry.root", error);
             }
         }
     }
     const patterns = [];
     const patternLookup = new Map();
     if (!Array.isArray(raw.patterns)) {
-        pushIssue(issues, 'boxel.patterns', 'BoxelDefinition patterns must be an array');
+        pushIssue(issues, "boxel.patterns", "BoxelDefinition patterns must be an array");
     }
     else {
         raw.patterns.forEach((pattern, index) => {
@@ -515,7 +513,7 @@ function validateBoxel(candidate) {
     const materials = [];
     const materialLookup = new Map();
     if (!Array.isArray(raw.materials)) {
-        pushIssue(issues, 'boxel.materials', 'BoxelDefinition materials must be an array');
+        pushIssue(issues, "boxel.materials", "BoxelDefinition materials must be an array");
     }
     else {
         raw.materials.forEach((material, index) => {
@@ -532,7 +530,7 @@ function validateBoxel(candidate) {
     const textures = [];
     const textureLookup = new Map();
     if (!Array.isArray(raw.textures)) {
-        pushIssue(issues, 'boxel.textures', 'BoxelDefinition textures must be an array');
+        pushIssue(issues, "boxel.textures", "BoxelDefinition textures must be an array");
     }
     else {
         raw.textures.forEach((texture, index) => {
@@ -543,7 +541,7 @@ function validateBoxel(candidate) {
                 if (!pattern) {
                     throw new Error(`Texture ${typed.id} references unknown pattern ${typed.pattern}`);
                 }
-                typed.materials.forEach(materialId => {
+                typed.materials.forEach((materialId) => {
                     if (!materialLookup.has(materialId)) {
                         throw new Error(`Texture ${typed.id} references unknown material ${materialId}`);
                     }
@@ -565,8 +563,8 @@ function validateBoxel(candidate) {
     }
     if (textures.length > 0) {
         primitives
-            .filter(primitive => primitive.kind === 'textured_box')
-            .forEach(primitive => {
+            .filter((primitive) => primitive.kind === "textured_box")
+            .forEach((primitive) => {
             try {
                 assertTexturedBoxFaceSizes(primitive, textureLookup, patternLookup, materialLookup);
             }
@@ -578,7 +576,7 @@ function validateBoxel(candidate) {
     const animations = [];
     if (!Array.isArray(raw.animations)) {
         if (raw.animations !== undefined) {
-            pushIssue(issues, 'boxel.animations', 'BoxelDefinition animations must be an array');
+            pushIssue(issues, "boxel.animations", "BoxelDefinition animations must be an array");
         }
     }
     else {
@@ -614,7 +612,7 @@ function assertBoxel(candidate) {
     if (boxel) {
         return boxel;
     }
-    throw new BoxelValidationError('BoxelDefinition validation failed', issues);
+    throw new BoxelValidationError("BoxelDefinition validation failed", issues);
 }
 function collectBoxelValidationIssues(candidate) {
     return validateBoxel(candidate).issues;