@rooms.sh/sdk 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,344 @@
+declare const ROOM_FORMAT_VERSION: 1;
+type Vec2 = [number, number];
+type Vec3 = [number, number, number];
+type Euler3 = [number, number, number];
+type ColorValue = number | `#${string}`;
+type WallName = "north" | "south" | "east" | "west";
+type MaterialSide = "front" | "back" | "double";
+type TextureRef = string;
+interface Transform {
+    position?: Vec3;
+    rotation?: Euler3;
+    scale?: Vec3;
+}
+interface ShapePath {
+    outline: Vec2[];
+    holes?: Vec2[][];
+}
+interface CustomGeometrySpec {
+    type: "custom";
+    positions: number[];
+    indices?: number[];
+    normals?: number[];
+    uvs?: number[];
+    computeNormals?: boolean;
+}
+type GeometrySpec = {
+    type: "box";
+    width: number;
+    height: number;
+    depth: number;
+} | {
+    type: "rounded-box";
+    width: number;
+    height: number;
+    depth: number;
+    radius?: number;
+    segments?: number;
+} | {
+    type: "capsule";
+    radius: number;
+    length: number;
+    capSegments?: number;
+    radialSegments?: number;
+} | {
+    type: "circle";
+    radius: number;
+    segments?: number;
+    thetaStart?: number;
+    thetaLength?: number;
+} | {
+    type: "plane";
+    width: number;
+    height: number;
+    widthSegments?: number;
+    heightSegments?: number;
+} | {
+    type: "sphere";
+    radius: number;
+    widthSegments?: number;
+    heightSegments?: number;
+    phiStart?: number;
+    phiLength?: number;
+    thetaStart?: number;
+    thetaLength?: number;
+} | {
+    type: "cylinder";
+    radiusTop: number;
+    radiusBottom: number;
+    height: number;
+    radialSegments?: number;
+    heightSegments?: number;
+    openEnded?: boolean;
+} | {
+    type: "cone";
+    radius: number;
+    height: number;
+    radialSegments?: number;
+    heightSegments?: number;
+    openEnded?: boolean;
+} | {
+    type: "ring";
+    innerRadius: number;
+    outerRadius: number;
+    thetaSegments?: number;
+    phiSegments?: number;
+    thetaStart?: number;
+    thetaLength?: number;
+} | {
+    type: "torus";
+    radius: number;
+    tube: number;
+    radialSegments?: number;
+    tubularSegments?: number;
+    arc?: number;
+} | {
+    type: "torus-knot";
+    radius: number;
+    tube: number;
+    tubularSegments?: number;
+    radialSegments?: number;
+    p?: number;
+    q?: number;
+} | {
+    type: "tetrahedron";
+    radius?: number;
+    detail?: number;
+} | {
+    type: "octahedron";
+    radius?: number;
+    detail?: number;
+} | {
+    type: "icosahedron";
+    radius?: number;
+    detail?: number;
+} | {
+    type: "dodecahedron";
+    radius?: number;
+    detail?: number;
+} | {
+    type: "polyhedron";
+    vertices: number[];
+    indices: number[];
+    radius?: number;
+    detail?: number;
+} | {
+    type: "shape";
+    path: ShapePath;
+    depth?: number;
+} | {
+    type: "extrude";
+    path: ShapePath;
+    depth: number;
+    steps?: number;
+    bevelEnabled?: boolean;
+    bevelThickness?: number;
+    bevelSize?: number;
+    bevelOffset?: number;
+    bevelSegments?: number;
+} | {
+    type: "lathe";
+    points: Vec2[];
+    segments?: number;
+    phiStart?: number;
+    phiLength?: number;
+} | {
+    type: "tube";
+    points: Vec3[];
+    tubularSegments?: number;
+    radius?: number;
+    radialSegments?: number;
+    closed?: boolean;
+} | CustomGeometrySpec;
+interface StandardMaterialSpec {
+    type: "standard";
+    color: ColorValue;
+    roughness?: number;
+    metalness?: number;
+    emissive?: ColorValue;
+    emissiveIntensity?: number;
+    transparent?: boolean;
+    opacity?: number;
+    side?: MaterialSide;
+    map?: TextureRef;
+}
+interface UnlitMaterialSpec {
+    type: "unlit";
+    color: ColorValue;
+    transparent?: boolean;
+    opacity?: number;
+    side?: MaterialSide;
+    map?: TextureRef;
+}
+interface GlassMaterialSpec {
+    type: "glass";
+    color: ColorValue;
+    roughness?: number;
+    opacity?: number;
+    transmission?: number;
+    side?: MaterialSide;
+}
+type MaterialSpec = StandardMaterialSpec | UnlitMaterialSpec | GlassMaterialSpec;
+interface MeshNode extends Transform {
+    kind: "mesh";
+    geometry: GeometrySpec;
+    material: MaterialSpec;
+}
+interface ItemRefNode extends Transform {
+    kind: "item";
+    itemId: string;
+}
+interface PointLightNode extends Transform {
+    kind: "point-light";
+    color: ColorValue;
+    intensity: number;
+    distance?: number;
+    decay?: number;
+}
+interface AmbientLightSpec {
+    kind: "ambient-light";
+    color: ColorValue;
+    intensity: number;
+}
+interface DirectionalLightSpec {
+    kind: "directional-light";
+    color: ColorValue;
+    intensity: number;
+    position: Vec3;
+    target?: Vec3;
+}
+interface HemisphereLightSpec {
+    kind: "hemisphere-light";
+    skyColor: ColorValue;
+    groundColor: ColorValue;
+    intensity: number;
+}
+type ItemNode = MeshNode | ItemRefNode | PointLightNode;
+type RoomLight = AmbientLightSpec | DirectionalLightSpec | HemisphereLightSpec;
+interface ItemDefinition {
+    id: string;
+    collides?: boolean;
+    nodes: ItemNode[];
+}
+interface FloorPlacement {
+    mode: "floor";
+    x: number;
+    z: number;
+    rotationY?: number;
+    lift?: number;
+    scale?: Vec3;
+}
+interface WallPlacement {
+    mode: "wall";
+    wall: WallName;
+    offset: number;
+    bottom: number;
+    rotationY?: number;
+    inset?: number;
+    scale?: Vec3;
+}
+interface FreePlacement {
+    mode: "free";
+    position: Vec3;
+    rotation?: Euler3;
+    scale?: Vec3;
+}
+type Placement = FloorPlacement | WallPlacement | FreePlacement;
+interface RoomInstance {
+    id: string;
+    itemId: string;
+    placement: Placement;
+}
+interface CameraView {
+    position: Vec3;
+    target: Vec3;
+    fov?: number;
+}
+interface RoomShell {
+    width: number;
+    depth: number;
+    height: number;
+    openWalls?: WallName[];
+    floorMaterial: MaterialSpec;
+    wallMaterial: MaterialSpec;
+    ceilingMaterial: MaterialSpec;
+    ceilingGrid?: {
+        spacing: number;
+        thickness?: number;
+        material: MaterialSpec;
+    };
+}
+interface Atmosphere {
+    background: ColorValue;
+    fogColor?: ColorValue;
+    fogDensity?: number;
+}
+interface RoomDefinition {
+    formatVersion: typeof ROOM_FORMAT_VERSION;
+    id: string;
+    shell: RoomShell;
+    atmosphere?: Atmosphere;
+    items: Record<string, ItemDefinition>;
+    instances: RoomInstance[];
+    lights?: RoomLight[];
+    cameras: Record<string, CameraView>;
+    defaultCamera: string;
+}
+interface ValidationOptions {
+    maxItems?: number;
+    maxInstances?: number;
+    maxLights?: number;
+    maxShellExtent?: number;
+}
+declare function validateRoomDefinition(room: RoomDefinition, overrides?: ValidationOptions): RoomDefinition;
+declare const geometry: {
+    box: (width: number, height: number, depth: number) => GeometrySpec;
+    roundedBox: (width: number, height: number, depth: number, radius?: number, segments?: number) => GeometrySpec;
+    capsule: (radius: number, length: number, capSegments?: number, radialSegments?: number) => GeometrySpec;
+    circle: (radius: number, segments?: number) => GeometrySpec;
+    plane: (width: number, height: number, widthSegments?: number, heightSegments?: number) => GeometrySpec;
+    sphere: (radius: number, widthSegments?: number, heightSegments?: number) => GeometrySpec;
+    cylinder: (radiusTop: number, radiusBottom: number, height: number, radialSegments?: number, heightSegments?: number, openEnded?: boolean) => GeometrySpec;
+    cone: (radius: number, height: number, radialSegments?: number, heightSegments?: number, openEnded?: boolean) => GeometrySpec;
+    ring: (innerRadius: number, outerRadius: number, thetaSegments?: number, phiSegments?: number) => GeometrySpec;
+    torus: (radius: number, tube: number, radialSegments?: number, tubularSegments?: number, arc?: number) => GeometrySpec;
+    torusKnot: (radius: number, tube: number, tubularSegments?: number, radialSegments?: number, p?: number, q?: number) => GeometrySpec;
+    tetrahedron: (radius?: number, detail?: number) => GeometrySpec;
+    octahedron: (radius?: number, detail?: number) => GeometrySpec;
+    icosahedron: (radius?: number, detail?: number) => GeometrySpec;
+    dodecahedron: (radius?: number, detail?: number) => GeometrySpec;
+    polyhedron: (vertices: number[], indices: number[], radius?: number, detail?: number) => GeometrySpec;
+    shape: (path: ShapePath, depth?: number) => GeometrySpec;
+    extrude: (path: ShapePath, depth: number, bevelEnabled?: boolean) => GeometrySpec;
+    lathe: (points: Vec2[], segments?: number) => GeometrySpec;
+    tube: (points: Vec3[], tubularSegments?: number, radius?: number, radialSegments?: number, closed?: boolean) => GeometrySpec;
+    custom: (positions: number[], options?: {
+        indices?: number[];
+        normals?: number[];
+        uvs?: number[];
+        computeNormals?: boolean;
+    }) => GeometrySpec;
+    triangles: (triangles: [Vec3, Vec3, Vec3][], options?: {
+        normals?: number[];
+        uvs?: number[];
+        computeNormals?: boolean;
+    }) => GeometrySpec;
+};
+declare const material: {
+    standard: (options: Omit<StandardMaterialSpec, "type">) => StandardMaterialSpec;
+    unlit: (options: Omit<UnlitMaterialSpec, "type">) => UnlitMaterialSpec;
+    glass: (options: Omit<GlassMaterialSpec, "type">) => GlassMaterialSpec;
+};
+declare function mesh(geometrySpec: GeometrySpec, materialSpec: MaterialSpec, transform?: Transform): MeshNode;
+declare function item(itemId: string, transform?: Transform): ItemRefNode;
+declare function pointLight(color: ColorValue, intensity: number, distance?: number, decay?: number, transform?: Transform): PointLightNode;
+declare function ambientLight(color: ColorValue, intensity: number): AmbientLightSpec;
+declare function directionalLight(color: ColorValue, intensity: number, position: Vec3, target?: Vec3): DirectionalLightSpec;
+declare function hemisphereLight(skyColor: ColorValue, groundColor: ColorValue, intensity: number): HemisphereLightSpec;
+declare function defineItem(definition: ItemDefinition): ItemDefinition;
+declare function defineRoom(definition: Omit<RoomDefinition, "formatVersion">): RoomDefinition;
+declare function placeFloor(id: string, itemId: string, x: number, z: number, options?: Omit<FloorPlacement, "mode" | "x" | "z">): RoomInstance;
+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 };

package/dist/index.js

@@ -0,0 +1,465 @@
+// src/index.ts
+var ROOM_FORMAT_VERSION = 1;
+var defaultValidationOptions = {
+  maxItems: 128,
+  maxInstances: 160,
+  maxLights: 24,
+  maxShellExtent: 64
+};
+function assertFiniteNumber(value, label) {
+  if (!Number.isFinite(value)) {
+    throw new Error(`${label} must be a finite number`);
+  }
+}
+function assertVec3(value, label) {
+  if (!value) {
+    return;
+  }
+  for (const [index, part] of value.entries()) {
+    assertFiniteNumber(part, `${label}[${index}]`);
+  }
+}
+function assertEuler(value, label) {
+  assertVec3(value, label);
+}
+function assertTransform(value, label) {
+  assertVec3(value.position, `${label}.position`);
+  assertEuler(value.rotation, `${label}.rotation`);
+  assertVec3(value.scale, `${label}.scale`);
+}
+function visitItem(itemId, items, visiting, visited) {
+  if (visited.has(itemId)) {
+    return;
+  }
+  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);
+  for (const node of item2.nodes) {
+    if (node.kind === "item") {
+      visitItem(node.itemId, items, visiting, visited);
+    }
+  }
+  visiting.delete(itemId);
+  visited.add(itemId);
+}
+function validateGeometry(spec, label) {
+  switch (spec.type) {
+    case "box":
+    case "rounded-box":
+      assertFiniteNumber(spec.width, `${label}.width`);
+      assertFiniteNumber(spec.height, `${label}.height`);
+      assertFiniteNumber(spec.depth, `${label}.depth`);
+      break;
+    case "capsule":
+      assertFiniteNumber(spec.radius, `${label}.radius`);
+      assertFiniteNumber(spec.length, `${label}.length`);
+      break;
+    case "circle":
+      assertFiniteNumber(spec.radius, `${label}.radius`);
+      break;
+    case "plane":
+      assertFiniteNumber(spec.width, `${label}.width`);
+      assertFiniteNumber(spec.height, `${label}.height`);
+      break;
+    case "sphere":
+      assertFiniteNumber(spec.radius, `${label}.radius`);
+      break;
+    case "cylinder":
+      assertFiniteNumber(spec.radiusTop, `${label}.radiusTop`);
+      assertFiniteNumber(spec.radiusBottom, `${label}.radiusBottom`);
+      assertFiniteNumber(spec.height, `${label}.height`);
+      break;
+    case "cone":
+      assertFiniteNumber(spec.radius, `${label}.radius`);
+      assertFiniteNumber(spec.height, `${label}.height`);
+      break;
+    case "ring":
+      assertFiniteNumber(spec.innerRadius, `${label}.innerRadius`);
+      assertFiniteNumber(spec.outerRadius, `${label}.outerRadius`);
+      break;
+    case "torus":
+    case "torus-knot":
+      assertFiniteNumber(spec.radius, `${label}.radius`);
+      assertFiniteNumber(spec.tube, `${label}.tube`);
+      break;
+    case "tetrahedron":
+    case "octahedron":
+    case "icosahedron":
+    case "dodecahedron":
+      if (spec.radius !== void 0) {
+        assertFiniteNumber(spec.radius, `${label}.radius`);
+      }
+      break;
+    case "polyhedron":
+      if (spec.vertices.length % 3 !== 0) {
+        throw new Error(`${label}.vertices must be a multiple of 3`);
+      }
+      break;
+    case "shape":
+      if (spec.path.outline.length < 3) {
+        throw new Error(`${label}.path.outline must have at least 3 points`);
+      }
+      break;
+    case "extrude":
+      if (spec.path.outline.length < 3) {
+        throw new Error(`${label}.path.outline must have at least 3 points`);
+      }
+      assertFiniteNumber(spec.depth, `${label}.depth`);
+      break;
+    case "lathe":
+      if (spec.points.length < 2) {
+        throw new Error(`${label}.points must have at least 2 points`);
+      }
+      break;
+    case "tube":
+      if (spec.points.length < 2) {
+        throw new Error(`${label}.points must have at least 2 points`);
+      }
+      break;
+    case "custom":
+      if (spec.positions.length === 0 || spec.positions.length % 3 !== 0) {
+        throw new Error(`${label}.positions must be a non-empty multiple of 3`);
+      }
+      if (spec.indices && spec.indices.length % 3 !== 0) {
+        throw new Error(`${label}.indices must be a multiple of 3`);
+      }
+      if (spec.normals && spec.normals.length !== spec.positions.length) {
+        throw new Error(`${label}.normals must match positions length`);
+      }
+      if (spec.uvs && spec.uvs.length % 2 !== 0) {
+        throw new Error(`${label}.uvs must be a multiple of 2`);
+      }
+      break;
+    default: {
+      const exhaustiveCheck = spec;
+      return exhaustiveCheck;
+    }
+  }
+}
+function validateRoomDefinition(room, overrides = {}) {
+  const options = { ...defaultValidationOptions, ...overrides };
+  if (room.formatVersion !== ROOM_FORMAT_VERSION) {
+    throw new Error(
+      `Unsupported room format version "${room.formatVersion}". Expected ${ROOM_FORMAT_VERSION}.`
+    );
+  }
+  if (!room.id) {
+    throw new Error("Room id is required");
+  }
+  assertFiniteNumber(room.shell.width, "room.shell.width");
+  assertFiniteNumber(room.shell.depth, "room.shell.depth");
+  assertFiniteNumber(room.shell.height, "room.shell.height");
+  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");
+  }
+  const itemEntries = Object.entries(room.items);
+  if (itemEntries.length > options.maxItems) {
+    throw new Error(`Room has too many item definitions (${itemEntries.length})`);
+  }
+  if (room.instances.length > options.maxInstances) {
+    throw new Error(`Room has too many instances (${room.instances.length})`);
+  }
+  if ((room.lights?.length ?? 0) > options.maxLights) {
+    throw new Error(`Room has too many room lights (${room.lights?.length ?? 0})`);
+  }
+  if (!room.cameras[room.defaultCamera]) {
+    throw new Error(`Default camera "${room.defaultCamera}" does not exist`);
+  }
+  for (const [itemId, item2] of itemEntries) {
+    if (item2.id !== itemId) {
+      throw new Error(`Item key "${itemId}" must match item.id "${item2.id}"`);
+    }
+    for (const [index, node] of item2.nodes.entries()) {
+      assertTransform(node, `room.items.${itemId}.nodes[${index}]`);
+      if (node.kind === "mesh") {
+        validateGeometry(node.geometry, `room.items.${itemId}.nodes[${index}].geometry`);
+      }
+      if (node.kind === "item" && !room.items[node.itemId]) {
+        throw new Error(`Item "${itemId}" references missing child item "${node.itemId}"`);
+      }
+    }
+  }
+  for (const instance of room.instances) {
+    if (!room.items[instance.itemId]) {
+      throw new Error(`Instance "${instance.id}" references missing item "${instance.itemId}"`);
+    }
+    if (instance.placement.mode === "free") {
+      assertVec3(instance.placement.position, `room.instances.${instance.id}.placement.position`);
+      assertEuler(instance.placement.rotation, `room.instances.${instance.id}.placement.rotation`);
+      assertVec3(instance.placement.scale, `room.instances.${instance.id}.placement.scale`);
+      continue;
+    }
+    if (instance.placement.mode === "floor") {
+      assertFiniteNumber(instance.placement.x, `room.instances.${instance.id}.placement.x`);
+      assertFiniteNumber(instance.placement.z, `room.instances.${instance.id}.placement.z`);
+      if (instance.placement.rotationY !== void 0) {
+        assertFiniteNumber(
+          instance.placement.rotationY,
+          `room.instances.${instance.id}.placement.rotationY`
+        );
+      }
+      assertVec3(instance.placement.scale, `room.instances.${instance.id}.placement.scale`);
+      continue;
+    }
+    assertFiniteNumber(instance.placement.offset, `room.instances.${instance.id}.placement.offset`);
+    assertFiniteNumber(instance.placement.bottom, `room.instances.${instance.id}.placement.bottom`);
+    if (instance.placement.rotationY !== void 0) {
+      assertFiniteNumber(
+        instance.placement.rotationY,
+        `room.instances.${instance.id}.placement.rotationY`
+      );
+    }
+    assertVec3(instance.placement.scale, `room.instances.${instance.id}.placement.scale`);
+  }
+  for (const camera of Object.values(room.cameras)) {
+    assertVec3(camera.position, "room.cameras.position");
+    assertVec3(camera.target, "room.cameras.target");
+    if (camera.fov !== void 0) {
+      assertFiniteNumber(camera.fov, "room.cameras.fov");
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  for (const itemId of Object.keys(room.items)) {
+    visitItem(itemId, room.items, /* @__PURE__ */ new Set(), visited);
+  }
+  return room;
+}
+var geometry = {
+  box: (width, height, depth) => ({
+    type: "box",
+    width,
+    height,
+    depth
+  }),
+  roundedBox: (width, height, depth, radius = 0.03, segments = 4) => ({
+    type: "rounded-box",
+    width,
+    height,
+    depth,
+    radius,
+    segments
+  }),
+  capsule: (radius, length, capSegments = 8, radialSegments = 12) => ({
+    type: "capsule",
+    radius,
+    length,
+    capSegments,
+    radialSegments
+  }),
+  circle: (radius, segments = 32) => ({
+    type: "circle",
+    radius,
+    segments
+  }),
+  plane: (width, height, widthSegments = 1, heightSegments = 1) => ({
+    type: "plane",
+    width,
+    height,
+    widthSegments,
+    heightSegments
+  }),
+  sphere: (radius, widthSegments = 24, heightSegments = 16) => ({
+    type: "sphere",
+    radius,
+    widthSegments,
+    heightSegments
+  }),
+  cylinder: (radiusTop, radiusBottom, height, radialSegments = 16, heightSegments = 1, openEnded = false) => ({
+    type: "cylinder",
+    radiusTop,
+    radiusBottom,
+    height,
+    radialSegments,
+    heightSegments,
+    openEnded
+  }),
+  cone: (radius, height, radialSegments = 16, heightSegments = 1, openEnded = false) => ({
+    type: "cone",
+    radius,
+    height,
+    radialSegments,
+    heightSegments,
+    openEnded
+  }),
+  ring: (innerRadius, outerRadius, thetaSegments = 24, phiSegments = 1) => ({
+    type: "ring",
+    innerRadius,
+    outerRadius,
+    thetaSegments,
+    phiSegments
+  }),
+  torus: (radius, tube, radialSegments = 12, tubularSegments = 48, arc = Math.PI * 2) => ({
+    type: "torus",
+    radius,
+    tube,
+    radialSegments,
+    tubularSegments,
+    arc
+  }),
+  torusKnot: (radius, tube, tubularSegments = 64, radialSegments = 8, p = 2, q = 3) => ({
+    type: "torus-knot",
+    radius,
+    tube,
+    tubularSegments,
+    radialSegments,
+    p,
+    q
+  }),
+  tetrahedron: (radius = 1, detail = 0) => ({ type: "tetrahedron", radius, detail }),
+  octahedron: (radius = 1, detail = 0) => ({ type: "octahedron", radius, detail }),
+  icosahedron: (radius = 1, detail = 0) => ({ type: "icosahedron", radius, detail }),
+  dodecahedron: (radius = 1, detail = 0) => ({ type: "dodecahedron", radius, detail }),
+  polyhedron: (vertices, indices, radius = 1, detail = 0) => ({
+    type: "polyhedron",
+    vertices,
+    indices,
+    radius,
+    detail
+  }),
+  shape: (path, depth = 0) => ({ type: "shape", path, depth }),
+  extrude: (path, depth, bevelEnabled = false) => ({
+    type: "extrude",
+    path,
+    depth,
+    bevelEnabled
+  }),
+  lathe: (points, segments = 12) => ({ type: "lathe", points, segments }),
+  tube: (points, tubularSegments = 32, radius = 0.02, radialSegments = 8, closed = false) => ({
+    type: "tube",
+    points,
+    tubularSegments,
+    radius,
+    radialSegments,
+    closed
+  }),
+  custom: (positions, options = {}) => ({
+    type: "custom",
+    positions,
+    indices: options.indices,
+    normals: options.normals,
+    uvs: options.uvs,
+    computeNormals: options.computeNormals
+  }),
+  triangles: (triangles, options = {}) => ({
+    type: "custom",
+    positions: triangles.flat(2),
+    normals: options.normals,
+    uvs: options.uvs,
+    computeNormals: options.computeNormals ?? true
+  })
+};
+var material = {
+  standard: (options) => ({
+    type: "standard",
+    ...options
+  }),
+  unlit: (options) => ({
+    type: "unlit",
+    ...options
+  }),
+  glass: (options) => ({
+    type: "glass",
+    ...options
+  })
+};
+function mesh(geometrySpec, materialSpec, transform = {}) {
+  return {
+    kind: "mesh",
+    geometry: geometrySpec,
+    material: materialSpec,
+    ...transform
+  };
+}
+function item(itemId, transform = {}) {
+  return {
+    kind: "item",
+    itemId,
+    ...transform
+  };
+}
+function pointLight(color, intensity, distance = 0, decay = 2, transform = {}) {
+  return {
+    kind: "point-light",
+    color,
+    intensity,
+    distance,
+    decay,
+    ...transform
+  };
+}
+function ambientLight(color, intensity) {
+  return { kind: "ambient-light", color, intensity };
+}
+function directionalLight(color, intensity, position, target) {
+  return { kind: "directional-light", color, intensity, position, target };
+}
+function hemisphereLight(skyColor, groundColor, intensity) {
+  return { kind: "hemisphere-light", skyColor, groundColor, intensity };
+}
+function defineItem(definition) {
+  return definition;
+}
+function defineRoom(definition) {
+  return validateRoomDefinition({
+    formatVersion: ROOM_FORMAT_VERSION,
+    ...definition
+  });
+}
+function placeFloor(id, itemId, x, z, options = {}) {
+  return {
+    id,
+    itemId,
+    placement: {
+      mode: "floor",
+      x,
+      z,
+      ...options
+    }
+  };
+}
+function placeWall(id, itemId, wall, offset, bottom, options = {}) {
+  return {
+    id,
+    itemId,
+    placement: {
+      mode: "wall",
+      wall,
+      offset,
+      bottom,
+      ...options
+    }
+  };
+}
+function place(id, itemId, position, options = {}) {
+  return {
+    id,
+    itemId,
+    placement: {
+      mode: "free",
+      position,
+      ...options
+    }
+  };
+}
+export {
+  ROOM_FORMAT_VERSION,
+  ambientLight,
+  defineItem,
+  defineRoom,
+  directionalLight,
+  geometry,
+  hemisphereLight,
+  item,
+  material,
+  mesh,
+  place,
+  placeFloor,
+  placeWall,
+  pointLight,
+  validateRoomDefinition
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@rooms.sh/sdk",
+  "version": "0.0.1",
+  "type": "module",
+  "private": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "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"
+  }
+}