@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-S6YWHCKV.cjs

@@ -0,0 +1,410 @@
+'use strict';
+
+// src/compiler/NodeToyMapping.ts
+var NODE_TYPE_MAP = {
+  // Math operations
+  Add: { expression: "({in:a} + {in:b})", outputType: "float" },
+  Subtract: { expression: "({in:a} - {in:b})", outputType: "float" },
+  Multiply: { expression: "({in:a} * {in:b})", outputType: "float" },
+  Divide: { expression: "({in:a} / max({in:b}, 0.0001))", outputType: "float" },
+  Power: { expression: "pow({in:a}, {in:b})", outputType: "float" },
+  Sqrt: { expression: "sqrt({in:a})", outputType: "float" },
+  Abs: { expression: "abs({in:a})", outputType: "float" },
+  Sign: { expression: "sign({in:a})", outputType: "float" },
+  Floor: { expression: "floor({in:a})", outputType: "float" },
+  Ceil: { expression: "ceil({in:a})", outputType: "float" },
+  Fract: { expression: "fract({in:a})", outputType: "float" },
+  Mod: { expression: "mod({in:a}, {in:b})", outputType: "float" },
+  Min: { expression: "min({in:a}, {in:b})", outputType: "float" },
+  Max: { expression: "max({in:a}, {in:b})", outputType: "float" },
+  Clamp: { expression: "clamp({in:a}, {in:min}, {in:max})", outputType: "float" },
+  Lerp: { expression: "mix({in:a}, {in:b}, {in:t})", outputType: "float" },
+  Smoothstep: { expression: "smoothstep({in:edge0}, {in:edge1}, {in:x})", outputType: "float" },
+  Step: { expression: "step({in:edge}, {in:x})", outputType: "float" },
+  OneMinus: { expression: "(1.0 - {in:a})", outputType: "float" },
+  Negate: { expression: "(-{in:a})", outputType: "float" },
+  Length: { expression: "length({in:a})", outputType: "float" },
+  Distance: { expression: "distance({in:a}, {in:b})", outputType: "float" },
+  Dot: { expression: "dot({in:a}, {in:b})", outputType: "float" },
+  Cross: { expression: "cross({in:a}, {in:b})", outputType: "vec3" },
+  Normalize: { expression: "normalize({in:a})", outputType: "vec3" },
+  Reflect: { expression: "reflect({in:a}, {in:b})", outputType: "vec3" },
+  // Trigonometry
+  Sin: { expression: "sin({in:a})", outputType: "float" },
+  Cos: { expression: "cos({in:a})", outputType: "float" },
+  Tan: { expression: "tan({in:a})", outputType: "float" },
+  Asin: { expression: "asin({in:a})", outputType: "float" },
+  Acos: { expression: "acos({in:a})", outputType: "float" },
+  Atan: { expression: "atan({in:a})", outputType: "float" },
+  Atan2: { expression: "atan({in:y}, {in:x})", outputType: "float" },
+  // Color operations
+  Mix: { expression: "mix({in:a}, {in:b}, {in:factor})", outputType: "vec3" },
+  Saturate: { expression: "clamp({in:a}, 0.0, 1.0)", outputType: "float" },
+  // Constructors
+  Vec2: { expression: "vec2({in:x}, {in:y})", outputType: "vec2" },
+  Vec3: { expression: "vec3({in:x}, {in:y}, {in:z})", outputType: "vec3" },
+  Vec4: { expression: "vec4({in:x}, {in:y}, {in:z}, {in:w})", outputType: "vec4" },
+  // Component extraction
+  SplitVec2: { expression: "{in:a}", outputType: "float" },
+  SplitVec3: { expression: "{in:a}", outputType: "float" },
+  SplitVec4: { expression: "{in:a}", outputType: "float" },
+  // Texture sampling
+  Texture2D: { expression: "texture2D({in:sampler}, {in:uv})", outputType: "vec4" },
+  CubeMap: { expression: "textureCube({in:sampler}, {in:dir})", outputType: "vec4" },
+  // Noise
+  ProceduralNoise: { expression: "snoise({in:uv} * {in:scale})", outputType: "float" }
+};
+var BUILTIN_INPUT_NODES = /* @__PURE__ */ new Set([
+  "Time",
+  "Resolution",
+  "ScreenUV",
+  "UV",
+  "Normal",
+  "Position",
+  "ViewDirection",
+  "FragCoord",
+  "Constant",
+  "Parameter"
+]);
+var OUTPUT_NODES = /* @__PURE__ */ new Set(["FragColor", "Output", "Emission", "Alpha", "Discard"]);
+function mapNodeToyToShader(graph, options = {}) {
+  const mapper = new NodeToyMapper(options);
+  return mapper.map(graph);
+}
+var NodeToyMapper = class {
+  constructor(options = {}) {
+    this.warnings = [];
+    this.unsupportedNodes = [];
+    this.uniforms = {};
+    this.varyingDecls = [];
+    this.fragmentLines = [];
+    this.nodeOutputVars = /* @__PURE__ */ new Map();
+    this.nodeMap = /* @__PURE__ */ new Map();
+    this.edgesByTarget = /* @__PURE__ */ new Map();
+    this.visitedNodes = /* @__PURE__ */ new Set();
+    this.language = options.language ?? "glsl";
+    this.autoTimeUniform = options.autoTimeUniform ?? true;
+    this.autoResolutionUniform = options.autoResolutionUniform ?? true;
+    this.variablePrefix = options.variablePrefix ?? "nt_";
+    this.optimization = options.optimization ?? "basic";
+  }
+  map(graph) {
+    this.warnings = [];
+    this.unsupportedNodes = [];
+    this.uniforms = {};
+    this.varyingDecls = [];
+    this.fragmentLines = [];
+    this.nodeOutputVars.clear();
+    this.nodeMap.clear();
+    this.edgesByTarget.clear();
+    this.visitedNodes.clear();
+    for (const node of graph.nodes) {
+      this.nodeMap.set(node.id, node);
+    }
+    for (const edge of graph.edges) {
+      const key = `${edge.toNode}:${edge.toPort}`;
+      if (!this.edgesByTarget.has(key)) {
+        this.edgesByTarget.set(key, []);
+      }
+      this.edgesByTarget.get(key).push(edge);
+    }
+    const outputNodes = graph.nodes.filter((n) => OUTPUT_NODES.has(n.type));
+    if (outputNodes.length === 0) {
+      this.warnings.push("No output node found in graph; generating passthrough shader");
+    }
+    for (const outputNode of outputNodes) {
+      this.traverseNode(outputNode.id);
+    }
+    const hasTimeNode = graph.nodes.some((n) => n.type === "Time");
+    const hasResolutionNode = graph.nodes.some((n) => n.type === "Resolution");
+    if (this.autoTimeUniform && hasTimeNode) {
+      this.uniforms["time"] = { type: "float", value: 0 };
+    }
+    if (this.autoResolutionUniform && hasResolutionNode) {
+      this.uniforms["resolution"] = { type: "vec2", value: [1920, 1080] };
+    }
+    for (const node of graph.nodes) {
+      if (node.type === "Parameter" || node.type === "Constant") {
+        this.extractParameterUniform(node);
+      }
+    }
+    const vertexSource = this.generateVertexSource();
+    const fragmentSource = this.generateFragmentSource(outputNodes);
+    const shaderConfig = {
+      name: graph.name || "nodetoy_shader",
+      source: {
+        language: this.language,
+        vertex: vertexSource,
+        fragment: fragmentSource
+      },
+      uniforms: this.uniforms,
+      blendMode: graph.settings?.blendMode ?? "opaque",
+      depthTest: graph.settings?.depthTest ?? true,
+      depthWrite: graph.settings?.depthWrite ?? true,
+      cullFace: graph.settings?.doubleSided ? "none" : "back"
+    };
+    return {
+      shaderConfig,
+      vertexSource,
+      fragmentSource,
+      uniforms: this.uniforms,
+      warnings: this.warnings,
+      unsupportedNodes: this.unsupportedNodes
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Graph traversal (reverse topological from output nodes)
+  // ---------------------------------------------------------------------------
+  traverseNode(nodeId) {
+    if (this.nodeOutputVars.has(nodeId)) {
+      return this.nodeOutputVars.get(nodeId);
+    }
+    if (this.visitedNodes.has(nodeId)) {
+      this.warnings.push(`Cycle detected at node ${nodeId}; breaking with default value`);
+      return "0.0";
+    }
+    this.visitedNodes.add(nodeId);
+    const node = this.nodeMap.get(nodeId);
+    if (!node) {
+      this.warnings.push(`Missing node: ${nodeId}`);
+      return "0.0";
+    }
+    if (BUILTIN_INPUT_NODES.has(node.type)) {
+      const varExpr = this.resolveBuiltinNode(node);
+      this.nodeOutputVars.set(nodeId, varExpr);
+      return varExpr;
+    }
+    if (OUTPUT_NODES.has(node.type)) {
+      for (const input of node.inputs) {
+        const inputExpr = this.resolveInputPort(nodeId, input.name, input);
+        if (node.type === "FragColor" || node.type === "Output") {
+          this.fragmentLines.push(`  // Output: ${node.label || node.type}`);
+          if (input.type === "vec4") {
+            this.fragmentLines.push(`  gl_FragColor = ${inputExpr};`);
+          } else if (input.type === "vec3") {
+            this.fragmentLines.push(`  gl_FragColor = vec4(${inputExpr}, 1.0);`);
+          } else {
+            this.fragmentLines.push(`  gl_FragColor = vec4(vec3(${inputExpr}), 1.0);`);
+          }
+        }
+      }
+      const varName2 = `${this.variablePrefix}out_${this.sanitize(nodeId)}`;
+      this.nodeOutputVars.set(nodeId, varName2);
+      return varName2;
+    }
+    const codegen = NODE_TYPE_MAP[node.type];
+    if (!codegen) {
+      this.unsupportedNodes.push(node.type);
+      this.warnings.push(`Unsupported node type: ${node.type}; using default value`);
+      this.nodeOutputVars.set(nodeId, "0.0");
+      return "0.0";
+    }
+    const resolvedInputs = {};
+    for (const input of node.inputs) {
+      resolvedInputs[input.name] = this.resolveInputPort(nodeId, input.name, input);
+    }
+    let expression = codegen.expression;
+    for (const [portName, portExpr] of Object.entries(resolvedInputs)) {
+      expression = expression.replace(`{in:${portName}}`, portExpr);
+    }
+    expression = expression.replace(/\{in:\w+\}/g, "0.0");
+    const varName = `${this.variablePrefix}${this.sanitize(nodeId)}`;
+    const glslType = this.uniformTypeToGLSL(codegen.outputType);
+    this.fragmentLines.push(`  ${glslType} ${varName} = ${expression};`);
+    this.nodeOutputVars.set(nodeId, varName);
+    return varName;
+  }
+  resolveInputPort(nodeId, portName, port) {
+    const edgeKey = `${nodeId}:${portName}`;
+    const edges = this.edgesByTarget.get(edgeKey);
+    if (edges && edges.length > 0) {
+      const edge = edges[0];
+      return this.traverseNode(edge.fromNode);
+    }
+    if (port.default !== void 0) {
+      if (typeof port.default === "number") return String(port.default);
+      if (Array.isArray(port.default)) {
+        const len = port.default.length;
+        if (len === 2) return `vec2(${port.default.join(", ")})`;
+        if (len === 3) return `vec3(${port.default.join(", ")})`;
+        if (len === 4) return `vec4(${port.default.join(", ")})`;
+        return String(port.default[0] ?? 0);
+      }
+    }
+    return "0.0";
+  }
+  resolveBuiltinNode(node) {
+    switch (node.type) {
+      case "Time":
+        return "time";
+      case "Resolution":
+        return "resolution";
+      case "UV":
+      case "ScreenUV":
+        this.ensureVarying("vUv", "vec2");
+        return "vUv";
+      case "Normal":
+        this.ensureVarying("vNormal", "vec3");
+        return "vNormal";
+      case "Position":
+        this.ensureVarying("vPosition", "vec3");
+        return "vPosition";
+      case "ViewDirection":
+        this.ensureVarying("vViewDir", "vec3");
+        return "vViewDir";
+      case "FragCoord":
+        return "gl_FragCoord.xy";
+      case "Constant": {
+        const val = node.params?.["value"];
+        if (typeof val === "number") return String(val);
+        if (Array.isArray(val)) {
+          if (val.length === 2) return `vec2(${val.join(", ")})`;
+          if (val.length === 3) return `vec3(${val.join(", ")})`;
+          if (val.length === 4) return `vec4(${val.join(", ")})`;
+        }
+        return "0.0";
+      }
+      case "Parameter": {
+        const name = node.params?.["name"] || `param_${node.id}`;
+        return name;
+      }
+      default:
+        return "0.0";
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Uniform and varying management
+  // ---------------------------------------------------------------------------
+  extractParameterUniform(node) {
+    const name = node.params?.["name"] || `param_${node.id}`;
+    const value = node.params?.["value"];
+    const uniformType = this.inferUniformType(value);
+    if (!this.uniforms[name]) {
+      this.uniforms[name] = {
+        type: uniformType,
+        value: typeof value === "number" || Array.isArray(value) ? value : 0,
+        min: node.params?.["min"],
+        max: node.params?.["max"],
+        label: node.label
+      };
+    }
+  }
+  inferUniformType(value) {
+    if (typeof value === "number") return "float";
+    if (typeof value === "boolean") return "bool";
+    if (Array.isArray(value)) {
+      if (value.length === 2) return "vec2";
+      if (value.length === 3) return "vec3";
+      if (value.length === 4) return "vec4";
+      if (value.length === 9) return "mat3";
+      if (value.length === 16) return "mat4";
+    }
+    return "float";
+  }
+  ensureVarying(name, type) {
+    const decl = `varying ${type} ${name};`;
+    if (!this.varyingDecls.includes(decl)) {
+      this.varyingDecls.push(decl);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Source generation
+  // ---------------------------------------------------------------------------
+  generateVertexSource() {
+    const lines = [];
+    for (const decl of this.varyingDecls) {
+      lines.push(decl);
+    }
+    lines.push("");
+    lines.push("void main() {");
+    if (this.varyingDecls.some((d) => d.includes("vUv"))) {
+      lines.push("  vUv = uv;");
+    }
+    if (this.varyingDecls.some((d) => d.includes("vNormal"))) {
+      lines.push("  vNormal = normalize(normalMatrix * normal);");
+    }
+    if (this.varyingDecls.some((d) => d.includes("vPosition"))) {
+      lines.push("  vPosition = position;");
+    }
+    if (this.varyingDecls.some((d) => d.includes("vViewDir"))) {
+      lines.push("  vec4 mvPos = modelViewMatrix * vec4(position, 1.0);");
+      lines.push("  vViewDir = normalize(-mvPos.xyz);");
+    }
+    lines.push("  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);");
+    lines.push("}");
+    return lines.join("\n");
+  }
+  generateFragmentSource(outputNodes) {
+    const lines = [];
+    lines.push("precision highp float;");
+    lines.push("");
+    for (const [name, uniform] of Object.entries(this.uniforms)) {
+      lines.push(`uniform ${this.uniformTypeToGLSL(uniform.type)} ${name};`);
+    }
+    lines.push("");
+    for (const decl of this.varyingDecls) {
+      lines.push(decl);
+    }
+    lines.push("");
+    if (this.nodeMap.size > 0) {
+      const hasNoise = Array.from(this.nodeMap.values()).some((n) => n.type === "ProceduralNoise");
+      if (hasNoise) {
+        lines.push(SIMPLEX_NOISE_2D);
+        lines.push("");
+      }
+    }
+    lines.push("void main() {");
+    for (const line of this.fragmentLines) {
+      lines.push(line);
+    }
+    if (!this.fragmentLines.some((l) => l.includes("gl_FragColor"))) {
+      lines.push("  gl_FragColor = vec4(1.0, 0.0, 1.0, 1.0); // No output node");
+    }
+    lines.push("}");
+    return lines.join("\n");
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  uniformTypeToGLSL(type) {
+    return type;
+  }
+  sanitize(id) {
+    return id.replace(/[^a-zA-Z0-9]/g, "_");
+  }
+};
+var SIMPLEX_NOISE_2D = `
+// Simplex 2D noise for ProceduralNoise nodes
+vec3 mod289_n(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+vec2 mod289_n(vec2 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+vec3 permute_n(vec3 x) { return mod289_n(((x*34.0)+1.0)*x); }
+
+float snoise(vec2 v) {
+  const vec4 C = vec4(0.211324865405187, 0.366025403784439,
+                      -0.577350269189626, 0.024390243902439);
+  vec2 i = floor(v + dot(v, C.yy));
+  vec2 x0 = v - i + dot(i, C.xx);
+  vec2 i1 = (x0[0] > x0[1]) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+  vec4 x12 = x0.xyxy + C.xxzz;
+  x12.xy -= i1;
+  i = mod289_n(i);
+  vec3 p = permute_n(permute_n(i[1] + vec3(0.0, i1[1], 1.0)) + i[0] + vec3(0.0, i1[0], 1.0));
+  vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
+  m = m*m; m = m*m;
+  vec3 x = 2.0 * fract(p * C.www) - 1.0;
+  vec3 h = abs(x) - 0.5;
+  vec3 ox = floor(x + 0.5);
+  vec3 a0 = x - ox;
+  m *= 1.79284291400159 - 0.85373472095314 * (a0*a0 + h*h);
+  vec3 g;
+  g[0] = a0[0] * x0[0] + h[0] * x0[1];
+  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+  return 130.0 * dot(m, g);
+}`.trim();
+var NodeToyMapping_default = mapNodeToyToShader;
+
+exports.NodeToyMapper = NodeToyMapper;
+exports.NodeToyMapping_default = NodeToyMapping_default;
+exports.mapNodeToyToShader = mapNodeToyToShader;
+//# sourceMappingURL=chunk-S6YWHCKV.cjs.map
+//# sourceMappingURL=chunk-S6YWHCKV.cjs.map

package/dist/chunk-SIEXCILW.js

@@ -0,0 +1,229 @@
+import { __esm } from './chunk-OL46QLBJ.js';
+
+// src/traits/constants/mobile/ios-object-capture.ts
+var IOS_OBJECT_CAPTURE_TRAITS;
+var init_ios_object_capture = __esm({
+  "src/traits/constants/mobile/ios-object-capture.ts"() {
+    IOS_OBJECT_CAPTURE_TRAITS = [
+      "object_capture",
+      // enable Object Capture session
+      "object_capture_guide",
+      // guided capture overlay (orbit path, coverage indicator)
+      "object_capture_feedback",
+      // real-time quality feedback during scan
+      "photogrammetry_scan",
+      // photogrammetry reconstruction pipeline
+      "pbr_texture_extract",
+      // extract PBR materials (diffuse, normal, roughness, metallic)
+      "object_capture_lod",
+      // generate LOD levels (preview, reduced, medium, full, raw)
+      "object_capture_to_holo",
+      // convert captured object to .holo asset
+      "object_capture_export_usdz"
+      // export as USDZ for Quick Look
+    ];
+  }
+});
+
+// src/traits/constants/mobile/airpods-spatial-audio.ts
+var AIRPODS_SPATIAL_AUDIO_TRAITS;
+var init_airpods_spatial_audio = __esm({
+  "src/traits/constants/mobile/airpods-spatial-audio.ts"() {
+    AIRPODS_SPATIAL_AUDIO_TRAITS = [
+      "spatial_audio_airpods",
+      // enable AirPods spatial audio
+      "audio_head_track",
+      // head-tracked audio stays pinned in space
+      "audio_source_3d",
+      // define 3D audio source position on .holo entity
+      "audio_falloff",
+      // distance-based volume falloff model
+      "audio_directivity",
+      // directional audio cone (inner/outer angle)
+      "audio_reverb_match",
+      // match reverb to physical room acoustics
+      "audio_occlusion"
+      // audio occluded by physical/holographic objects
+    ];
+  }
+});
+
+// src/traits/constants/mobile/shareplay.ts
+var SHAREPLAY_TRAITS;
+var init_shareplay = __esm({
+  "src/traits/constants/mobile/shareplay.ts"() {
+    SHAREPLAY_TRAITS = [
+      // --- Session ---
+      "shareplay_session",
+      // enable SharePlay session for .holo scene
+      "shareplay_host",
+      // designate host who controls scene state
+      "shareplay_join",
+      // join existing SharePlay session
+      // --- Sync ---
+      "shareplay_sync",
+      // sync scene state across participants (Loro CRDT)
+      "shareplay_anchor_local",
+      // each participant anchors scene to their own space
+      "shareplay_entity_ownership",
+      // per-entity ownership for conflict resolution
+      "shareplay_late_join",
+      // full state sync for late-joining participants
+      // --- Audio ---
+      "shareplay_voice_spatial",
+      // spatial audio for participant voices in shared scene
+      "shareplay_mute_zone"
+      // define zones where spatial audio is attenuated
+    ];
+  }
+});
+
+// src/traits/constants/mobile/uwb-positioning.ts
+var UWB_POSITIONING_TRAITS;
+var init_uwb_positioning = __esm({
+  "src/traits/constants/mobile/uwb-positioning.ts"() {
+    UWB_POSITIONING_TRAITS = [
+      "uwb_discover",
+      // discover nearby UWB-capable devices
+      "uwb_range",
+      // measure distance to peer device (cm precision)
+      "uwb_direction",
+      // determine direction to peer device (azimuth + elevation)
+      "uwb_handoff",
+      // hand off .holo entity to nearby device by pointing
+      "uwb_anchor_peer",
+      // use peer device position as spatial anchor
+      "uwb_controller"
+      // use second device as spatial controller/wand
+    ];
+  }
+});
+
+// src/traits/constants/mobile/face-tracking.ts
+var FACE_TRACKING_TRAITS;
+var init_face_tracking = __esm({
+  "src/traits/constants/mobile/face-tracking.ts"() {
+    FACE_TRACKING_TRAITS = [
+      // --- Tracking ---
+      "face_track_truedepth",
+      // enable TrueDepth face tracking (ARFaceAnchor)
+      "face_blendshapes",
+      // 52 ARKit blendshape coefficients
+      "face_mesh",
+      // face topology mesh (1220 vertices)
+      "face_transform",
+      // head position and orientation in world space
+      // --- Avatar ---
+      "face_avatar_drive",
+      // drive .holo avatar with face blendshapes
+      "face_blendshape_mirror",
+      // mirror blendshapes to avatar (1:1 mapping)
+      "face_puppet",
+      // face-driven holographic puppet mode
+      "face_retarget",
+      // retarget blendshapes to non-human avatar topology
+      // --- Analysis ---
+      "face_emotion_detect",
+      // derive emotion from blendshape combinations
+      "face_gaze_direction",
+      // eye gaze vector from lookAtPoint
+      "face_tongue_detect"
+      // tongue out detection (blendshape tongueOut)
+    ];
+  }
+});
+
+// src/traits/constants/mobile/lidar-scanner.ts
+var LIDAR_SCANNER_TRAITS;
+var init_lidar_scanner = __esm({
+  "src/traits/constants/mobile/lidar-scanner.ts"() {
+    LIDAR_SCANNER_TRAITS = [
+      // --- Scanning ---
+      "lidar_scan",
+      // enable LiDAR scanning session
+      "lidar_mesh_capture",
+      // capture raw triangle mesh from LiDAR
+      "lidar_realtime_mesh",
+      // live-updating mesh during scan (ARMeshAnchor stream)
+      // --- Mesh Processing ---
+      "lidar_mesh_classification",
+      // ARKit mesh classification (floor, wall, ceiling, table, seat, window, door)
+      "lidar_point_cloud",
+      // raw point cloud access (ARPointCloud)
+      "lidar_mesh_simplify",
+      // reduce mesh complexity for performance
+      "lidar_mesh_smooth",
+      // smooth captured mesh normals
+      // --- Output ---
+      "lidar_mesh_to_holo",
+      // convert mesh to .holo scene graph with semantic labels
+      "lidar_mesh_export",
+      // export mesh as USDZ/OBJ/GLB
+      // --- Depth ---
+      "lidar_depth_map",
+      // per-frame depth buffer (ARFrame.sceneDepth)
+      "lidar_depth_confidence"
+      // per-pixel confidence map for depth data
+    ];
+  }
+});
+
+// src/traits/constants/mobile/roomplan.ts
+var ROOMPLAN_TRAITS;
+var init_roomplan = __esm({
+  "src/traits/constants/mobile/roomplan.ts"() {
+    ROOMPLAN_TRAITS = [
+      // --- Scanning ---
+      "roomplan_scan",
+      // marks scene as a RoomPlan capture target (iOS 16+)
+      "roomplan_realtime_preview",
+      // show live mesh preview during scan
+      "roomplan_scan_quality",
+      // scan quality level: quick | standard | detailed
+      // --- Structural Surfaces ---
+      "roomplan_wall",
+      // detected wall surface
+      "roomplan_floor",
+      // detected floor surface
+      "roomplan_ceiling",
+      // detected ceiling surface
+      // --- Openings ---
+      "roomplan_door",
+      // detected door opening
+      "roomplan_window",
+      // detected window opening
+      "roomplan_opening",
+      // generic opening (archway, pass-through)
+      // --- Furniture & Fixtures ---
+      "roomplan_furniture",
+      // generic detected furniture item
+      "roomplan_table",
+      // classified table
+      "roomplan_chair",
+      // classified chair / seating
+      "roomplan_sofa",
+      // classified sofa / couch
+      "roomplan_bed",
+      // classified bed
+      "roomplan_storage",
+      // classified storage (cabinet, shelf, dresser)
+      "roomplan_appliance",
+      // classified appliance (oven, fridge, washer)
+      "roomplan_fixture",
+      // classified fixture (sink, toilet, bathtub)
+      "roomplan_screen",
+      // classified screen (TV, monitor)
+      "roomplan_fireplace",
+      // classified fireplace
+      // --- Output ---
+      "roomplan_scene_export",
+      // export captured room as .holo scene graph
+      "roomplan_coordinate_map"
+      // map RoomPlan world coordinates to HoloScript space
+    ];
+  }
+});
+
+export { AIRPODS_SPATIAL_AUDIO_TRAITS, FACE_TRACKING_TRAITS, IOS_OBJECT_CAPTURE_TRAITS, LIDAR_SCANNER_TRAITS, ROOMPLAN_TRAITS, SHAREPLAY_TRAITS, UWB_POSITIONING_TRAITS, init_airpods_spatial_audio, init_face_tracking, init_ios_object_capture, init_lidar_scanner, init_roomplan, init_shareplay, init_uwb_positioning };
+//# sourceMappingURL=chunk-SIEXCILW.js.map
+//# sourceMappingURL=chunk-SIEXCILW.js.map