@rooms.sh/sdk 0.0.2 → 0.0.4

package/dist/index.d.ts

@@ -6,6 +6,15 @@ type ColorValue = number | `#${string}`;
 type WallName = "north" | "south" | "east" | "west";
 type MaterialSide = "front" | "back" | "double";
 type TextureRef = string;
+declare const MAX_TEXTURE_DATA_URL_BYTES: number;
+declare const MAX_GEOMETRY_TESSELLATION_SEGMENTS = 256;
+declare const MAX_GEOMETRY_DETAIL = 6;
+declare const MAX_GEOMETRY_POINTS = 4096;
+declare const MAX_ESTIMATED_GEOMETRY_VERTICES = 500000;
+declare const MIN_CEILING_GRID_SPACING = 0.05;
+declare const MAX_CEILING_GRID_LINES = 256;
+declare const MAX_RENDERED_OBJECTS = 10000;
+declare const MAX_EXPANDED_POINT_LIGHTS = 2000;
 interface Transform {
     position?: Vec3;
     rotation?: Euler3;
@@ -286,10 +295,24 @@ interface RoomDefinition {
 }
 interface ValidationOptions {
     maxItems?: number;
+    maxItemNodes?: number;
     maxInstances?: number;
     maxLights?: number;
     maxShellExtent?: number;
+    maxCustomGeometryValues?: number;
+    maxShapePoints?: number;
+    maxGeometryPoints?: number;
+    maxGeometryTessellationSegments?: number;
+    maxGeometryDetail?: number;
+    maxEstimatedGeometryVertices?: number;
+    maxTextureDataUrlBytes?: number;
+    minCeilingGridSpacing?: number;
+    maxCeilingGridLines?: number;
+    maxRenderedObjects?: number;
+    maxExpandedPointLights?: number;
 }
+declare function isDataTextureUrl(source: string): boolean;
+declare function validateTextureRef(source: TextureRef, label: string, options?: Pick<Required<ValidationOptions>, "maxTextureDataUrlBytes">): string;
 declare function validateRoomDefinition(room: RoomDefinition, overrides?: ValidationOptions): RoomDefinition;
 declare const geometry: {
     box: (width: number, height: number, depth: number) => GeometrySpec;
@@ -341,4 +364,4 @@ declare function placeFloor(id: string, itemId: string, x: number, z: number, op
 declare function placeWall(id: string, itemId: string, wall: WallName, offset: number, bottom: number, options?: Omit<WallPlacement, "mode" | "wall" | "offset" | "bottom">): RoomInstance;
 declare function place(id: string, itemId: string, position: Vec3, options?: Omit<FreePlacement, "mode" | "position">): RoomInstance;
 
-export { type AmbientLightSpec, type Atmosphere, type CameraView, type ColorValue, type CustomGeometrySpec, type DirectionalLightSpec, type Euler3, type FloorPlacement, type FreePlacement, type GeometrySpec, type GlassMaterialSpec, type HemisphereLightSpec, type ItemDefinition, type ItemNode, type ItemRefNode, type MaterialSide, type MaterialSpec, type MeshNode, type Placement, type PointLightNode, ROOM_FORMAT_VERSION, type RoomDefinition, type RoomInstance, type RoomLight, type RoomShell, type ShapePath, type StandardMaterialSpec, type TextureRef, type Transform, type UnlitMaterialSpec, type ValidationOptions, type Vec2, type Vec3, type WallName, type WallPlacement, ambientLight, defineItem, defineRoom, directionalLight, geometry, hemisphereLight, item, material, mesh, place, placeFloor, placeWall, pointLight, validateRoomDefinition };
+export { type AmbientLightSpec, type Atmosphere, type CameraView, type ColorValue, type CustomGeometrySpec, type DirectionalLightSpec, type Euler3, type FloorPlacement, type FreePlacement, type GeometrySpec, type GlassMaterialSpec, type HemisphereLightSpec, type ItemDefinition, type ItemNode, type ItemRefNode, MAX_CEILING_GRID_LINES, MAX_ESTIMATED_GEOMETRY_VERTICES, MAX_EXPANDED_POINT_LIGHTS, MAX_GEOMETRY_DETAIL, MAX_GEOMETRY_POINTS, MAX_GEOMETRY_TESSELLATION_SEGMENTS, MAX_RENDERED_OBJECTS, MAX_TEXTURE_DATA_URL_BYTES, MIN_CEILING_GRID_SPACING, type MaterialSide, type MaterialSpec, type MeshNode, type Placement, type PointLightNode, ROOM_FORMAT_VERSION, type RoomDefinition, type RoomInstance, type RoomLight, type RoomShell, type ShapePath, type StandardMaterialSpec, type TextureRef, type Transform, type UnlitMaterialSpec, type ValidationOptions, type Vec2, type Vec3, type WallName, type WallPlacement, ambientLight, defineItem, defineRoom, directionalLight, geometry, hemisphereLight, isDataTextureUrl, item, material, mesh, place, placeFloor, placeWall, pointLight, validateRoomDefinition, validateTextureRef };

package/dist/index.js

@@ -1,10 +1,31 @@
 // src/index.ts
 var ROOM_FORMAT_VERSION = 1;
+var MAX_TEXTURE_DATA_URL_BYTES = 5 * 1024 * 1024;
+var MAX_GEOMETRY_TESSELLATION_SEGMENTS = 256;
+var MAX_GEOMETRY_DETAIL = 6;
+var MAX_GEOMETRY_POINTS = 4096;
+var MAX_ESTIMATED_GEOMETRY_VERTICES = 5e5;
+var MIN_CEILING_GRID_SPACING = 0.05;
+var MAX_CEILING_GRID_LINES = 256;
+var MAX_RENDERED_OBJECTS = 1e4;
+var MAX_EXPANDED_POINT_LIGHTS = 2e3;
 var defaultValidationOptions = {
   maxItems: 128,
+  maxItemNodes: 2048,
   maxInstances: 160,
   maxLights: 24,
-  maxShellExtent: 64
+  maxShellExtent: 64,
+  maxCustomGeometryValues: 2e5,
+  maxShapePoints: 4096,
+  maxGeometryPoints: MAX_GEOMETRY_POINTS,
+  maxGeometryTessellationSegments: MAX_GEOMETRY_TESSELLATION_SEGMENTS,
+  maxGeometryDetail: MAX_GEOMETRY_DETAIL,
+  maxEstimatedGeometryVertices: MAX_ESTIMATED_GEOMETRY_VERTICES,
+  maxTextureDataUrlBytes: MAX_TEXTURE_DATA_URL_BYTES,
+  minCeilingGridSpacing: MIN_CEILING_GRID_SPACING,
+  maxCeilingGridLines: MAX_CEILING_GRID_LINES,
+  maxRenderedObjects: MAX_RENDERED_OBJECTS,
+  maxExpandedPointLights: MAX_EXPANDED_POINT_LIGHTS
 };
 function assertFiniteNumber(value, label) {
   if (!Number.isFinite(value)) {
@@ -12,20 +33,105 @@ function assertFiniteNumber(value, label) {
   }
 }
 function assertVec3(value, label) {
-  if (!value) {
-    return;
+  if (!Array.isArray(value) || value.length !== 3) {
+    throw new Error(`${label} must be a 3-number tuple`);
   }
   for (const [index, part] of value.entries()) {
     assertFiniteNumber(part, `${label}[${index}]`);
   }
 }
-function assertEuler(value, label) {
+function assertOptionalVec3(value, label) {
+  if (!value) {
+    return;
+  }
   assertVec3(value, label);
 }
+function assertEuler(value, label) {
+  assertOptionalVec3(value, label);
+}
 function assertTransform(value, label) {
-  assertVec3(value.position, `${label}.position`);
+  assertOptionalVec3(value.position, `${label}.position`);
   assertEuler(value.rotation, `${label}.rotation`);
-  assertVec3(value.scale, `${label}.scale`);
+  assertOptionalVec3(value.scale, `${label}.scale`);
+}
+function assertMaxLength(value, max, label) {
+  if (value.length > max) {
+    throw new Error(`${label} exceeds the allowed length of ${max}`);
+  }
+}
+function assertBoundedInteger(value, label, max, min = 0) {
+  if (value === void 0) {
+    return;
+  }
+  if (!Number.isInteger(value) || value < min || value > max) {
+    throw new Error(`${label} must be an integer between ${min} and ${max}`);
+  }
+}
+function assertFiniteNumberArray(values, label) {
+  if (!Array.isArray(values)) {
+    throw new Error(`${label} must be an array`);
+  }
+  for (const [index, value] of values.entries()) {
+    assertFiniteNumber(value, `${label}[${index}]`);
+  }
+}
+function assertVec2(value, label) {
+  if (!Array.isArray(value) || value.length !== 2) {
+    throw new Error(`${label} must be a 2-number tuple`);
+  }
+  for (const [index, part] of value.entries()) {
+    assertFiniteNumber(part, `${label}[${index}]`);
+  }
+}
+function assertVec2Array(values, label, minLength, maxLength) {
+  if (!Array.isArray(values)) {
+    throw new Error(`${label} must be an array`);
+  }
+  if (values.length < minLength) {
+    throw new Error(`${label} must have at least ${minLength} points`);
+  }
+  assertMaxLength(values, maxLength, label);
+  for (const [index, point] of values.entries()) {
+    assertVec2(point, `${label}[${index}]`);
+  }
+}
+function assertVec3Array(values, label, minLength, maxLength) {
+  if (!Array.isArray(values)) {
+    throw new Error(`${label} must be an array`);
+  }
+  if (values.length < minLength) {
+    throw new Error(`${label} must have at least ${minLength} points`);
+  }
+  assertMaxLength(values, maxLength, label);
+  for (const [index, point] of values.entries()) {
+    assertVec3(point, `${label}[${index}]`);
+  }
+}
+function encodedByteLength(value) {
+  return new TextEncoder().encode(value).length;
+}
+function isDataTextureUrl(source) {
+  if (!source || source.trim() !== source) {
+    return false;
+  }
+  try {
+    return new URL(source).protocol === "data:";
+  } catch {
+    return false;
+  }
+}
+function validateTextureRef(source, label, options = {
+  maxTextureDataUrlBytes: MAX_TEXTURE_DATA_URL_BYTES
+}) {
+  if (typeof source !== "string" || !isDataTextureUrl(source)) {
+    throw new Error(`${label} must be a data: URL`);
+  }
+  if (encodedByteLength(source) > options.maxTextureDataUrlBytes) {
+    throw new Error(
+      `${label} exceeds the allowed size of ${options.maxTextureDataUrlBytes} bytes`
+    );
+  }
+  return source;
 }
 function visitItem(itemId, items, visiting, visited) {
   if (visited.has(itemId)) {
@@ -47,93 +153,593 @@ function visitItem(itemId, items, visiting, visited) {
   visiting.delete(itemId);
   visited.add(itemId);
 }
-function validateGeometry(spec, label) {
+function countShapePathPoints(path) {
+  return path.outline.length + (path.holes?.reduce((total, hole) => total + hole.length, 0) ?? 0);
+}
+function validateShapePath(path, label, options) {
+  if (countShapePathPoints(path) > options.maxShapePoints) {
+    throw new Error(`${label} exceeds the allowed point count`);
+  }
+  assertVec2Array(path.outline, `${label}.outline`, 3, options.maxShapePoints);
+  for (const [index, hole] of (path.holes ?? []).entries()) {
+    assertVec2Array(hole, `${label}.holes[${index}]`, 3, options.maxShapePoints);
+  }
+}
+function boundedSegments(value, label, options, defaultValue, min = 1) {
+  assertBoundedInteger(
+    value,
+    label,
+    options.maxGeometryTessellationSegments,
+    min
+  );
+  return value ?? defaultValue;
+}
+function boundedDetail(value, label, options) {
+  assertBoundedInteger(value, label, options.maxGeometryDetail);
+  return value ?? 0;
+}
+function assertEstimatedGeometryVertices(count, label, options) {
+  if (count > options.maxEstimatedGeometryVertices) {
+    throw new Error(
+      `${label} exceeds the estimated vertex budget of ${options.maxEstimatedGeometryVertices}`
+    );
+  }
+}
+function assertRenderedObjectCount(count, label, options) {
+  if (count > options.maxRenderedObjects) {
+    throw new Error(
+      `${label} exceeds the rendered object budget of ${options.maxRenderedObjects}`
+    );
+  }
+}
+function assertExpandedPointLightCount(count, label, options) {
+  if (count > options.maxExpandedPointLights) {
+    throw new Error(
+      `${label} exceeds the expanded point-light budget of ${options.maxExpandedPointLights}`
+    );
+  }
+}
+function addItemRenderCost(left, right) {
+  left.geometryVertices += right.geometryVertices;
+  left.objects += right.objects;
+  left.pointLights += right.pointLights;
+}
+function multiplyItemRenderCost(cost, multiplier) {
+  return {
+    geometryVertices: cost.geometryVertices * multiplier,
+    objects: cost.objects * multiplier,
+    pointLights: cost.pointLights * multiplier
+  };
+}
+function assertItemRenderCost(cost, label, options) {
+  assertEstimatedGeometryVertices(cost.geometryVertices, label, options);
+  assertRenderedObjectCount(cost.objects, label, options);
+  assertExpandedPointLightCount(cost.pointLights, label, options);
+}
+function validateCeilingGridBudget(room, options) {
+  const ceilingGrid = room.shell.ceilingGrid;
+  if (!ceilingGrid) {
+    return;
+  }
+  if (ceilingGrid.spacing < options.minCeilingGridSpacing) {
+    throw new Error(
+      `room.shell.ceilingGrid.spacing must be at least ${options.minCeilingGridSpacing}`
+    );
+  }
+  const estimatedLineCount = Math.ceil(room.shell.width / ceilingGrid.spacing) + Math.ceil(room.shell.depth / ceilingGrid.spacing);
+  if (estimatedLineCount > options.maxCeilingGridLines) {
+    throw new Error(
+      `room.shell.ceilingGrid exceeds the ${options.maxCeilingGridLines} line budget`
+    );
+  }
+}
+function estimateExpandedItemRenderCost(itemId, items, directRenderCostByItem, cache, visiting, options) {
+  const cached = cache.get(itemId);
+  if (cached !== void 0) {
+    return cached;
+  }
+  if (visiting.has(itemId)) {
+    throw new Error(`Recursive item definition detected at "${itemId}"`);
+  }
+  const item2 = items[itemId];
+  if (!item2) {
+    throw new Error(`Missing item definition "${itemId}"`);
+  }
+  visiting.add(itemId);
+  const total = {
+    geometryVertices: 0,
+    objects: 1,
+    pointLights: 0,
+    ...directRenderCostByItem.get(itemId) ?? {}
+  };
+  for (const node of item2.nodes) {
+    if (node.kind !== "item") {
+      continue;
+    }
+    addItemRenderCost(
+      total,
+      estimateExpandedItemRenderCost(
+        node.itemId,
+        items,
+        directRenderCostByItem,
+        cache,
+        visiting,
+        options
+      )
+    );
+    assertItemRenderCost(
+      total,
+      `room.items.${itemId} expanded render cost`,
+      options
+    );
+  }
+  visiting.delete(itemId);
+  cache.set(itemId, total);
+  return total;
+}
+function subdividedTriangleVertexCount(baseFaces, detail) {
+  return baseFaces * 3 * 4 ** detail;
+}
+function validateGeometry(spec, label, options) {
+  let estimatedVertices = 0;
   switch (spec.type) {
     case "box":
-    case "rounded-box":
       assertFiniteNumber(spec.width, `${label}.width`);
       assertFiniteNumber(spec.height, `${label}.height`);
       assertFiniteNumber(spec.depth, `${label}.depth`);
+      estimatedVertices = 24;
       break;
-    case "capsule":
+    case "rounded-box": {
+      assertFiniteNumber(spec.width, `${label}.width`);
+      assertFiniteNumber(spec.height, `${label}.height`);
+      assertFiniteNumber(spec.depth, `${label}.depth`);
+      if (spec.radius !== void 0) {
+        assertFiniteNumber(spec.radius, `${label}.radius`);
+      }
+      const segments = boundedSegments(
+        spec.segments,
+        `${label}.segments`,
+        options,
+        4
+      );
+      estimatedVertices = 6 * (segments + 1) ** 2;
+      break;
+    }
+    case "capsule": {
       assertFiniteNumber(spec.radius, `${label}.radius`);
       assertFiniteNumber(spec.length, `${label}.length`);
+      const capSegments = boundedSegments(
+        spec.capSegments,
+        `${label}.capSegments`,
+        options,
+        8
+      );
+      const radialSegments = boundedSegments(
+        spec.radialSegments,
+        `${label}.radialSegments`,
+        options,
+        12
+      );
+      estimatedVertices = (radialSegments + 1) * (capSegments * 2 + 2);
       break;
-    case "circle":
+    }
+    case "circle": {
       assertFiniteNumber(spec.radius, `${label}.radius`);
+      const segments = boundedSegments(
+        spec.segments,
+        `${label}.segments`,
+        options,
+        32,
+        3
+      );
+      if (spec.thetaStart !== void 0) {
+        assertFiniteNumber(spec.thetaStart, `${label}.thetaStart`);
+      }
+      if (spec.thetaLength !== void 0) {
+        assertFiniteNumber(spec.thetaLength, `${label}.thetaLength`);
+      }
+      estimatedVertices = segments + 2;
       break;
-    case "plane":
+    }
+    case "plane": {
       assertFiniteNumber(spec.width, `${label}.width`);
       assertFiniteNumber(spec.height, `${label}.height`);
+      const widthSegments = boundedSegments(
+        spec.widthSegments,
+        `${label}.widthSegments`,
+        options,
+        1
+      );
+      const heightSegments = boundedSegments(
+        spec.heightSegments,
+        `${label}.heightSegments`,
+        options,
+        1
+      );
+      estimatedVertices = (widthSegments + 1) * (heightSegments + 1);
       break;
-    case "sphere":
+    }
+    case "sphere": {
       assertFiniteNumber(spec.radius, `${label}.radius`);
+      const widthSegments = boundedSegments(
+        spec.widthSegments,
+        `${label}.widthSegments`,
+        options,
+        32,
+        3
+      );
+      const heightSegments = boundedSegments(
+        spec.heightSegments,
+        `${label}.heightSegments`,
+        options,
+        16,
+        2
+      );
+      if (spec.phiStart !== void 0) {
+        assertFiniteNumber(spec.phiStart, `${label}.phiStart`);
+      }
+      if (spec.phiLength !== void 0) {
+        assertFiniteNumber(spec.phiLength, `${label}.phiLength`);
+      }
+      if (spec.thetaStart !== void 0) {
+        assertFiniteNumber(spec.thetaStart, `${label}.thetaStart`);
+      }
+      if (spec.thetaLength !== void 0) {
+        assertFiniteNumber(spec.thetaLength, `${label}.thetaLength`);
+      }
+      estimatedVertices = (widthSegments + 1) * (heightSegments + 1);
       break;
-    case "cylinder":
+    }
+    case "cylinder": {
       assertFiniteNumber(spec.radiusTop, `${label}.radiusTop`);
       assertFiniteNumber(spec.radiusBottom, `${label}.radiusBottom`);
       assertFiniteNumber(spec.height, `${label}.height`);
+      const radialSegments = boundedSegments(
+        spec.radialSegments,
+        `${label}.radialSegments`,
+        options,
+        32,
+        3
+      );
+      const heightSegments = boundedSegments(
+        spec.heightSegments,
+        `${label}.heightSegments`,
+        options,
+        1
+      );
+      estimatedVertices = (radialSegments + 1) * (heightSegments + 3);
       break;
-    case "cone":
+    }
+    case "cone": {
       assertFiniteNumber(spec.radius, `${label}.radius`);
       assertFiniteNumber(spec.height, `${label}.height`);
+      const radialSegments = boundedSegments(
+        spec.radialSegments,
+        `${label}.radialSegments`,
+        options,
+        32,
+        3
+      );
+      const heightSegments = boundedSegments(
+        spec.heightSegments,
+        `${label}.heightSegments`,
+        options,
+        1
+      );
+      estimatedVertices = (radialSegments + 1) * (heightSegments + 3);
       break;
-    case "ring":
+    }
+    case "ring": {
       assertFiniteNumber(spec.innerRadius, `${label}.innerRadius`);
       assertFiniteNumber(spec.outerRadius, `${label}.outerRadius`);
+      const thetaSegments = boundedSegments(
+        spec.thetaSegments,
+        `${label}.thetaSegments`,
+        options,
+        32,
+        3
+      );
+      const phiSegments = boundedSegments(
+        spec.phiSegments,
+        `${label}.phiSegments`,
+        options,
+        1
+      );
+      if (spec.thetaStart !== void 0) {
+        assertFiniteNumber(spec.thetaStart, `${label}.thetaStart`);
+      }
+      if (spec.thetaLength !== void 0) {
+        assertFiniteNumber(spec.thetaLength, `${label}.thetaLength`);
+      }
+      estimatedVertices = (thetaSegments + 1) * (phiSegments + 1);
+      break;
+    }
+    case "torus": {
+      assertFiniteNumber(spec.radius, `${label}.radius`);
+      assertFiniteNumber(spec.tube, `${label}.tube`);
+      const radialSegments = boundedSegments(
+        spec.radialSegments,
+        `${label}.radialSegments`,
+        options,
+        12,
+        3
+      );
+      const tubularSegments = boundedSegments(
+        spec.tubularSegments,
+        `${label}.tubularSegments`,
+        options,
+        48,
+        3
+      );
+      if (spec.arc !== void 0) {
+        assertFiniteNumber(spec.arc, `${label}.arc`);
+      }
+      estimatedVertices = (radialSegments + 1) * (tubularSegments + 1);
       break;
-    case "torus":
-    case "torus-knot":
+    }
+    case "torus-knot": {
       assertFiniteNumber(spec.radius, `${label}.radius`);
       assertFiniteNumber(spec.tube, `${label}.tube`);
+      const tubularSegments = boundedSegments(
+        spec.tubularSegments,
+        `${label}.tubularSegments`,
+        options,
+        64,
+        3
+      );
+      const radialSegments = boundedSegments(
+        spec.radialSegments,
+        `${label}.radialSegments`,
+        options,
+        8,
+        3
+      );
+      assertBoundedInteger(
+        spec.p,
+        `${label}.p`,
+        options.maxGeometryTessellationSegments,
+        1
+      );
+      assertBoundedInteger(
+        spec.q,
+        `${label}.q`,
+        options.maxGeometryTessellationSegments,
+        1
+      );
+      estimatedVertices = (radialSegments + 1) * (tubularSegments + 1);
       break;
-    case "tetrahedron":
-    case "octahedron":
-    case "icosahedron":
-    case "dodecahedron":
+    }
+    case "tetrahedron": {
       if (spec.radius !== void 0) {
         assertFiniteNumber(spec.radius, `${label}.radius`);
       }
+      const detail = boundedDetail(spec.detail, `${label}.detail`, options);
+      estimatedVertices = subdividedTriangleVertexCount(4, detail);
       break;
-    case "polyhedron":
+    }
+    case "octahedron": {
+      if (spec.radius !== void 0) {
+        assertFiniteNumber(spec.radius, `${label}.radius`);
+      }
+      const detail = boundedDetail(spec.detail, `${label}.detail`, options);
+      estimatedVertices = subdividedTriangleVertexCount(8, detail);
+      break;
+    }
+    case "icosahedron": {
+      if (spec.radius !== void 0) {
+        assertFiniteNumber(spec.radius, `${label}.radius`);
+      }
+      const detail = boundedDetail(spec.detail, `${label}.detail`, options);
+      estimatedVertices = subdividedTriangleVertexCount(20, detail);
+      break;
+    }
+    case "dodecahedron": {
+      if (spec.radius !== void 0) {
+        assertFiniteNumber(spec.radius, `${label}.radius`);
+      }
+      const detail = boundedDetail(spec.detail, `${label}.detail`, options);
+      estimatedVertices = subdividedTriangleVertexCount(36, detail);
+      break;
+    }
+    case "polyhedron": {
+      assertMaxLength(
+        spec.vertices,
+        options.maxCustomGeometryValues,
+        `${label}.vertices`
+      );
+      assertMaxLength(
+        spec.indices,
+        options.maxCustomGeometryValues,
+        `${label}.indices`
+      );
+      assertFiniteNumberArray(spec.vertices, `${label}.vertices`);
+      assertFiniteNumberArray(spec.indices, `${label}.indices`);
       if (spec.vertices.length % 3 !== 0) {
         throw new Error(`${label}.vertices must be a multiple of 3`);
       }
+      if (spec.indices.length % 3 !== 0) {
+        throw new Error(`${label}.indices must be a multiple of 3`);
+      }
+      if (spec.radius !== void 0) {
+        assertFiniteNumber(spec.radius, `${label}.radius`);
+      }
+      const detail = boundedDetail(spec.detail, `${label}.detail`, options);
+      estimatedVertices = (spec.indices.length || spec.vertices.length) * 4 ** detail;
       break;
+    }
     case "shape":
-      if (spec.path.outline.length < 3) {
-        throw new Error(`${label}.path.outline must have at least 3 points`);
+      validateShapePath(spec.path, `${label}.path`, options);
+      if (spec.depth !== void 0) {
+        assertFiniteNumber(spec.depth, `${label}.depth`);
       }
+      estimatedVertices = countShapePathPoints(spec.path) * (spec.depth ? 4 : 2);
       break;
     case "extrude":
-      if (spec.path.outline.length < 3) {
-        throw new Error(`${label}.path.outline must have at least 3 points`);
-      }
+      validateShapePath(spec.path, `${label}.path`, options);
       assertFiniteNumber(spec.depth, `${label}.depth`);
+      const steps = boundedSegments(spec.steps, `${label}.steps`, options, 1);
+      const bevelSegments = boundedSegments(
+        spec.bevelSegments,
+        `${label}.bevelSegments`,
+        options,
+        3
+      );
+      if (spec.bevelThickness !== void 0) {
+        assertFiniteNumber(spec.bevelThickness, `${label}.bevelThickness`);
+      }
+      if (spec.bevelSize !== void 0) {
+        assertFiniteNumber(spec.bevelSize, `${label}.bevelSize`);
+      }
+      if (spec.bevelOffset !== void 0) {
+        assertFiniteNumber(spec.bevelOffset, `${label}.bevelOffset`);
+      }
+      estimatedVertices = countShapePathPoints(spec.path) * (steps + bevelSegments + 2) * 2;
       break;
-    case "lathe":
-      if (spec.points.length < 2) {
-        throw new Error(`${label}.points must have at least 2 points`);
+    case "lathe": {
+      assertVec2Array(
+        spec.points,
+        `${label}.points`,
+        2,
+        options.maxGeometryPoints
+      );
+      const segments = boundedSegments(
+        spec.segments,
+        `${label}.segments`,
+        options,
+        12,
+        3
+      );
+      if (spec.phiStart !== void 0) {
+        assertFiniteNumber(spec.phiStart, `${label}.phiStart`);
       }
+      if (spec.phiLength !== void 0) {
+        assertFiniteNumber(spec.phiLength, `${label}.phiLength`);
+      }
+      estimatedVertices = spec.points.length * (segments + 1);
       break;
-    case "tube":
-      if (spec.points.length < 2) {
-        throw new Error(`${label}.points must have at least 2 points`);
+    }
+    case "tube": {
+      assertVec3Array(
+        spec.points,
+        `${label}.points`,
+        2,
+        options.maxGeometryPoints
+      );
+      const tubularSegments = boundedSegments(
+        spec.tubularSegments,
+        `${label}.tubularSegments`,
+        options,
+        64
+      );
+      if (spec.radius !== void 0) {
+        assertFiniteNumber(spec.radius, `${label}.radius`);
       }
+      const radialSegments = boundedSegments(
+        spec.radialSegments,
+        `${label}.radialSegments`,
+        options,
+        8,
+        3
+      );
+      estimatedVertices = (tubularSegments + 1) * (radialSegments + 1);
       break;
+    }
     case "custom":
+      assertMaxLength(
+        spec.positions,
+        options.maxCustomGeometryValues,
+        `${label}.positions`
+      );
+      if (spec.indices) {
+        assertMaxLength(
+          spec.indices,
+          options.maxCustomGeometryValues,
+          `${label}.indices`
+        );
+      }
+      if (spec.normals) {
+        assertMaxLength(
+          spec.normals,
+          options.maxCustomGeometryValues,
+          `${label}.normals`
+        );
+      }
+      if (spec.uvs) {
+        assertMaxLength(
+          spec.uvs,
+          options.maxCustomGeometryValues,
+          `${label}.uvs`
+        );
+      }
       if (spec.positions.length === 0 || spec.positions.length % 3 !== 0) {
         throw new Error(`${label}.positions must be a non-empty multiple of 3`);
       }
+      assertFiniteNumberArray(spec.positions, `${label}.positions`);
       if (spec.indices && spec.indices.length % 3 !== 0) {
         throw new Error(`${label}.indices must be a multiple of 3`);
       }
+      if (spec.indices) {
+        assertFiniteNumberArray(spec.indices, `${label}.indices`);
+      }
       if (spec.normals && spec.normals.length !== spec.positions.length) {
         throw new Error(`${label}.normals must match positions length`);
       }
+      if (spec.normals) {
+        assertFiniteNumberArray(spec.normals, `${label}.normals`);
+      }
       if (spec.uvs && spec.uvs.length % 2 !== 0) {
         throw new Error(`${label}.uvs must be a multiple of 2`);
       }
+      if (spec.uvs) {
+        assertFiniteNumberArray(spec.uvs, `${label}.uvs`);
+      }
+      estimatedVertices = spec.positions.length / 3;
+      break;
+    default: {
+      const exhaustiveCheck = spec;
+      return exhaustiveCheck;
+    }
+  }
+  assertEstimatedGeometryVertices(estimatedVertices, label, options);
+  return estimatedVertices;
+}
+function validateMaterial(spec, label, options) {
+  switch (spec.type) {
+    case "standard":
+      if (spec.roughness !== void 0) {
+        assertFiniteNumber(spec.roughness, `${label}.roughness`);
+      }
+      if (spec.metalness !== void 0) {
+        assertFiniteNumber(spec.metalness, `${label}.metalness`);
+      }
+      if (spec.emissiveIntensity !== void 0) {
+        assertFiniteNumber(spec.emissiveIntensity, `${label}.emissiveIntensity`);
+      }
+      if (spec.opacity !== void 0) {
+        assertFiniteNumber(spec.opacity, `${label}.opacity`);
+      }
+      if (spec.map !== void 0) {
+        validateTextureRef(spec.map, `${label}.map`, options);
+      }
+      break;
+    case "unlit":
+      if (spec.opacity !== void 0) {
+        assertFiniteNumber(spec.opacity, `${label}.opacity`);
+      }
+      if (spec.map !== void 0) {
+        validateTextureRef(spec.map, `${label}.map`, options);
+      }
+      break;
+    case "glass":
+      if (spec.roughness !== void 0) {
+        assertFiniteNumber(spec.roughness, `${label}.roughness`);
+      }
+      if (spec.opacity !== void 0) {
+        assertFiniteNumber(spec.opacity, `${label}.opacity`);
+      }
+      if (spec.transmission !== void 0) {
+        assertFiniteNumber(spec.transmission, `${label}.transmission`);
+      }
       break;
     default: {
       const exhaustiveCheck = spec;
@@ -154,9 +760,38 @@ function validateRoomDefinition(room, overrides = {}) {
   assertFiniteNumber(room.shell.width, "room.shell.width");
   assertFiniteNumber(room.shell.depth, "room.shell.depth");
   assertFiniteNumber(room.shell.height, "room.shell.height");
+  validateMaterial(
+    room.shell.floorMaterial,
+    "room.shell.floorMaterial",
+    options
+  );
+  validateMaterial(room.shell.wallMaterial, "room.shell.wallMaterial", options);
+  validateMaterial(
+    room.shell.ceilingMaterial,
+    "room.shell.ceilingMaterial",
+    options
+  );
+  if (room.shell.ceilingGrid) {
+    assertFiniteNumber(
+      room.shell.ceilingGrid.spacing,
+      "room.shell.ceilingGrid.spacing"
+    );
+    if (room.shell.ceilingGrid.thickness !== void 0) {
+      assertFiniteNumber(
+        room.shell.ceilingGrid.thickness,
+        "room.shell.ceilingGrid.thickness"
+      );
+    }
+    validateMaterial(
+      room.shell.ceilingGrid.material,
+      "room.shell.ceilingGrid.material",
+      options
+    );
+  }
   if (room.shell.width <= 0 || room.shell.depth <= 0 || room.shell.height <= 0 || room.shell.width > options.maxShellExtent || room.shell.depth > options.maxShellExtent || room.shell.height > options.maxShellExtent) {
     throw new Error("Room shell dimensions are outside allowed bounds");
   }
+  validateCeilingGridBudget(room, options);
   const itemEntries = Object.entries(room.items);
   if (itemEntries.length > options.maxItems) {
     throw new Error(
@@ -174,16 +809,39 @@ function validateRoomDefinition(room, overrides = {}) {
   if (!room.cameras[room.defaultCamera]) {
     throw new Error(`Default camera "${room.defaultCamera}" does not exist`);
   }
+  const directRenderCostByItem = /* @__PURE__ */ new Map();
   for (const [itemId, item2] of itemEntries) {
     if (item2.id !== itemId) {
       throw new Error(`Item key "${itemId}" must match item.id "${item2.id}"`);
     }
+    if (item2.nodes.length > options.maxItemNodes) {
+      throw new Error(
+        `Item "${itemId}" has too many nodes (${item2.nodes.length})`
+      );
+    }
+    const itemDirectRenderCost = {
+      geometryVertices: 0,
+      objects: 0,
+      pointLights: 0
+    };
     for (const [index, node] of item2.nodes.entries()) {
       assertTransform(node, `room.items.${itemId}.nodes[${index}]`);
       if (node.kind === "mesh") {
-        validateGeometry(
+        itemDirectRenderCost.geometryVertices += validateGeometry(
           node.geometry,
-          `room.items.${itemId}.nodes[${index}].geometry`
+          `room.items.${itemId}.nodes[${index}].geometry`,
+          options
+        );
+        itemDirectRenderCost.objects += 1;
+        assertItemRenderCost(
+          itemDirectRenderCost,
+          `room.items.${itemId}`,
+          options
+        );
+        validateMaterial(
+          node.material,
+          `room.items.${itemId}.nodes[${index}].material`,
+          options
         );
       }
       if (node.kind === "item" && !room.items[node.itemId]) {
@@ -191,14 +849,53 @@ function validateRoomDefinition(room, overrides = {}) {
           `Item "${itemId}" references missing child item "${node.itemId}"`
         );
       }
+      if (node.kind === "item") {
+        itemDirectRenderCost.objects += 1;
+        assertItemRenderCost(
+          itemDirectRenderCost,
+          `room.items.${itemId}`,
+          options
+        );
+      }
+      if (node.kind === "point-light") {
+        itemDirectRenderCost.objects += 1;
+        itemDirectRenderCost.pointLights += 1;
+        assertItemRenderCost(
+          itemDirectRenderCost,
+          `room.items.${itemId}`,
+          options
+        );
+        assertFiniteNumber(
+          node.intensity,
+          `room.items.${itemId}.nodes[${index}].intensity`
+        );
+        if (node.distance !== void 0) {
+          assertFiniteNumber(
+            node.distance,
+            `room.items.${itemId}.nodes[${index}].distance`
+          );
+        }
+        if (node.decay !== void 0) {
+          assertFiniteNumber(
+            node.decay,
+            `room.items.${itemId}.nodes[${index}].decay`
+          );
+        }
+      }
     }
+    directRenderCostByItem.set(itemId, itemDirectRenderCost);
   }
+  const instanceCountsByItem = /* @__PURE__ */ new Map();
   for (const instance of room.instances) {
     if (!room.items[instance.itemId]) {
       throw new Error(
         `Instance "${instance.id}" references missing item "${instance.itemId}"`
       );
     }
+    instanceCountsByItem.set(
+      instance.itemId,
+      (instanceCountsByItem.get(instance.itemId) ?? 0) + 1
+    );
     if (instance.placement.mode === "free") {
       assertVec3(
         instance.placement.position,
@@ -208,7 +905,7 @@ function validateRoomDefinition(room, overrides = {}) {
         instance.placement.rotation,
         `room.instances.${instance.id}.placement.rotation`
       );
-      assertVec3(
+      assertOptionalVec3(
         instance.placement.scale,
         `room.instances.${instance.id}.placement.scale`
       );
@@ -229,7 +926,7 @@ function validateRoomDefinition(room, overrides = {}) {
           `room.instances.${instance.id}.placement.rotationY`
         );
       }
-      assertVec3(
+      assertOptionalVec3(
         instance.placement.scale,
         `room.instances.${instance.id}.placement.scale`
       );
@@ -249,11 +946,38 @@ function validateRoomDefinition(room, overrides = {}) {
         `room.instances.${instance.id}.placement.rotationY`
       );
     }
-    assertVec3(
+    assertOptionalVec3(
       instance.placement.scale,
       `room.instances.${instance.id}.placement.scale`
     );
   }
+  const expandedRenderCostByItem = /* @__PURE__ */ new Map();
+  const totalInstancedRenderCost = {
+    geometryVertices: 0,
+    objects: 0,
+    pointLights: 0
+  };
+  for (const [itemId, instanceCount] of instanceCountsByItem.entries()) {
+    addItemRenderCost(
+      totalInstancedRenderCost,
+      multiplyItemRenderCost(
+        estimateExpandedItemRenderCost(
+          itemId,
+          room.items,
+          directRenderCostByItem,
+          expandedRenderCostByItem,
+          /* @__PURE__ */ new Set(),
+          options
+        ),
+        instanceCount
+      )
+    );
+    assertItemRenderCost(
+      totalInstancedRenderCost,
+      "room instanced render cost",
+      options
+    );
+  }
   for (const camera of Object.values(room.cameras)) {
     assertVec3(camera.position, "room.cameras.position");
     assertVec3(camera.target, "room.cameras.target");
@@ -261,6 +985,13 @@ function validateRoomDefinition(room, overrides = {}) {
       assertFiniteNumber(camera.fov, "room.cameras.fov");
     }
   }
+  for (const [index, light] of (room.lights ?? []).entries()) {
+    assertFiniteNumber(light.intensity, `room.lights[${index}].intensity`);
+    if (light.kind === "directional-light") {
+      assertVec3(light.position, `room.lights[${index}].position`);
+      assertOptionalVec3(light.target, `room.lights[${index}].target`);
+    }
+  }
   const visited = /* @__PURE__ */ new Set();
   for (const itemId of Object.keys(room.items)) {
     visitItem(itemId, room.items, /* @__PURE__ */ new Set(), visited);
@@ -509,6 +1240,15 @@ function place(id, itemId, position, options = {}) {
   };
 }
 export {
+  MAX_CEILING_GRID_LINES,
+  MAX_ESTIMATED_GEOMETRY_VERTICES,
+  MAX_EXPANDED_POINT_LIGHTS,
+  MAX_GEOMETRY_DETAIL,
+  MAX_GEOMETRY_POINTS,
+  MAX_GEOMETRY_TESSELLATION_SEGMENTS,
+  MAX_RENDERED_OBJECTS,
+  MAX_TEXTURE_DATA_URL_BYTES,
+  MIN_CEILING_GRID_SPACING,
   ROOM_FORMAT_VERSION,
   ambientLight,
   defineItem,
@@ -516,6 +1256,7 @@ export {
   directionalLight,
   geometry,
   hemisphereLight,
+  isDataTextureUrl,
   item,
   material,
   mesh,
@@ -523,5 +1264,6 @@ export {
   placeFloor,
   placeWall,
   pointLight,
-  validateRoomDefinition
+  validateRoomDefinition,
+  validateTextureRef
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rooms.sh/sdk",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "private": false,
   "main": "./dist/index.js",
@@ -17,16 +17,16 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
-    "lint": "eslint",
-    "format": "prettier --write \"**/*.{ts,tsx}\"",
-    "typecheck": "tsc --noEmit"
-  },
   "devDependencies": {
     "@types/node": "^25.1.0",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "lint": "eslint",
+    "format": "prettier --write \"**/*.{ts,tsx}\"",
+    "typecheck": "tsc --noEmit"
   }
-}
+}