@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-YIVFJNYV.js

@@ -0,0 +1,176 @@
+// src/math/tropicalSpmv.ts
+var TROPICAL_INF = 1e30;
+function mulberry32(seed) {
+  let t = seed >>> 0;
+  return () => {
+    t += 1831565813;
+    let r = Math.imul(t ^ t >>> 15, 1 | t);
+    r ^= r + Math.imul(r ^ r >>> 7, 61 | r);
+    return ((r ^ r >>> 14) >>> 0) / 4294967296;
+  };
+}
+function tropicalMinPlusSpmv(csr, x, y) {
+  const { n, rowPtr, colIdx, values } = csr;
+  if (x.length < n || y.length < n) {
+    throw new Error(`tropicalMinPlusSpmv: x and y must have length >= n (${n})`);
+  }
+  for (let i = 0; i < n; i++) {
+    let best = TROPICAL_INF;
+    const end = rowPtr[i + 1];
+    for (let k = rowPtr[i]; k < end; k++) {
+      const j = colIdx[k];
+      const aij = values[k];
+      const xj = x[j];
+      if (aij >= TROPICAL_INF || xj >= TROPICAL_INF) continue;
+      const s = aij + xj;
+      if (s < best) best = s;
+    }
+    y[i] = best;
+  }
+}
+function tropicalMinPlusSpmvDense(n, aRowMajor, x, y) {
+  if (aRowMajor.length !== n * n) throw new Error("tropicalMinPlusSpmvDense: expected n*n matrix");
+  for (let i = 0; i < n; i++) {
+    let best = TROPICAL_INF;
+    const row = i * n;
+    for (let j = 0; j < n; j++) {
+      const aij = aRowMajor[row + j];
+      if (aij >= TROPICAL_INF) continue;
+      const xj = x[j];
+      if (xj >= TROPICAL_INF) continue;
+      const s = aij + xj;
+      if (s < best) best = s;
+    }
+    y[i] = best;
+  }
+}
+function csrFromDense(n, dense) {
+  if (dense.length !== n * n) throw new Error("csrFromDense: dense must be n*n");
+  const rowCounts = new Uint32Array(n);
+  for (let i = 0; i < n; i++) {
+    let c = 0;
+    for (let j = 0; j < n; j++) {
+      const v = dense[i * n + j];
+      if (v < TROPICAL_INF && v === v) c++;
+    }
+    rowCounts[i] = c;
+  }
+  const rowPtr = new Uint32Array(n + 1);
+  for (let i = 0; i < n; i++) rowPtr[i + 1] = rowPtr[i] + rowCounts[i];
+  const nnz = rowPtr[n];
+  const colIdx = new Uint32Array(nnz);
+  const values = new Float32Array(nnz);
+  const write = new Uint32Array(rowPtr);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      const v = dense[i * n + j];
+      if (v < TROPICAL_INF && v === v) {
+        const p = write[i];
+        colIdx[p] = j;
+        values[p] = v;
+        write[i] = p + 1;
+      }
+    }
+  }
+  return { n, rowPtr, colIdx, values };
+}
+function erdosRenyiCsr(n, p, rng) {
+  const rows = Array.from({ length: n }, () => []);
+  const vals = Array.from({ length: n }, () => []);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      if (rng() < p) {
+        rows[i].push(j);
+        vals[i].push(1e-6 + rng() * (1 - 1e-6));
+      }
+    }
+  }
+  return packCsr(n, rows, vals);
+}
+function barabasiAlbertCsr(n, m, rng) {
+  if (n < 2 || m < 1) throw new Error("barabasiAlbertCsr: need n>=2, m>=1");
+  const rows = Array.from({ length: n }, () => []);
+  const vals = Array.from({ length: n }, () => []);
+  const indeg = new Uint32Array(n);
+  const addEdge = (from, to, w) => {
+    rows[from].push(to);
+    vals[from].push(w);
+    indeg[to]++;
+  };
+  const m0 = Math.min(m + 1, n);
+  for (let i = 1; i < m0; i++) {
+    addEdge(i, 0, 1e-6 + rng());
+  }
+  for (let v = m0; v < n; v++) {
+    const chosen = /* @__PURE__ */ new Set();
+    let guard = 0;
+    while (chosen.size < Math.min(m, v) && guard < m * v * 5) {
+      guard++;
+      let tot = 0;
+      for (let u = 0; u < v; u++) tot += indeg[u] + 1;
+      let r = rng() * tot;
+      let acc = 0;
+      let pick = 0;
+      for (let u = 0; u < v; u++) {
+        acc += indeg[u] + 1;
+        if (r <= acc) {
+          pick = u;
+          break;
+        }
+      }
+      if (!chosen.has(pick)) {
+        chosen.add(pick);
+        addEdge(v, pick, 1e-6 + rng());
+      }
+    }
+  }
+  return packCsr(n, rows, vals);
+}
+function layeredNeuralCsr(n, layers, skipProbability, rng) {
+  if (layers < 2) throw new Error("layeredNeuralCsr: layers >= 2");
+  const rows = Array.from({ length: n }, () => []);
+  const vals = Array.from({ length: n }, () => []);
+  const layerOf = (i) => Math.floor(i * layers / n);
+  for (let i = 0; i < n; i++) {
+    const li = layerOf(i);
+    for (let j = 0; j < n; j++) {
+      const lj = layerOf(j);
+      if (lj === li + 1 || lj > li && rng() < skipProbability) {
+        rows[i].push(j);
+        vals[i].push(1e-6 + rng());
+      }
+    }
+  }
+  return packCsr(n, rows, vals);
+}
+function packCsr(n, rows, vals) {
+  const rowPtr = new Uint32Array(n + 1);
+  let nnz = 0;
+  for (let i = 0; i < n; i++) nnz += rows[i].length;
+  for (let i = 0; i < n; i++) rowPtr[i + 1] = rowPtr[i] + rows[i].length;
+  const colIdx = new Uint32Array(nnz);
+  const values = new Float32Array(nnz);
+  let w = 0;
+  for (let i = 0; i < n; i++) {
+    const rc = rows[i].length;
+    for (let k = 0; k < rc; k++) {
+      colIdx[w] = rows[i][k];
+      values[w] = vals[i][k];
+      w++;
+    }
+  }
+  return { n, rowPtr, colIdx, values };
+}
+function maxAbsDiff(a, b) {
+  let m = 0;
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const d = Math.abs(a[i] - b[i]);
+    if (d > m) m = d;
+  }
+  return m;
+}
+
+export { TROPICAL_INF, barabasiAlbertCsr, csrFromDense, erdosRenyiCsr, layeredNeuralCsr, maxAbsDiff, mulberry32, tropicalMinPlusSpmv, tropicalMinPlusSpmvDense };
+//# sourceMappingURL=chunk-YIVFJNYV.js.map
+//# sourceMappingURL=chunk-YIVFJNYV.js.map

package/dist/chunk-YKGPCZEE.cjs

@@ -0,0 +1,237 @@
+'use strict';
+
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+
+// src/traits/constants/mobile/ios-object-capture.ts
+exports.IOS_OBJECT_CAPTURE_TRAITS = void 0;
+var init_ios_object_capture = chunkHCCQLAA4_cjs.__esm({
+  "src/traits/constants/mobile/ios-object-capture.ts"() {
+    exports.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
+exports.AIRPODS_SPATIAL_AUDIO_TRAITS = void 0;
+var init_airpods_spatial_audio = chunkHCCQLAA4_cjs.__esm({
+  "src/traits/constants/mobile/airpods-spatial-audio.ts"() {
+    exports.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
+exports.SHAREPLAY_TRAITS = void 0;
+var init_shareplay = chunkHCCQLAA4_cjs.__esm({
+  "src/traits/constants/mobile/shareplay.ts"() {
+    exports.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
+exports.UWB_POSITIONING_TRAITS = void 0;
+var init_uwb_positioning = chunkHCCQLAA4_cjs.__esm({
+  "src/traits/constants/mobile/uwb-positioning.ts"() {
+    exports.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
+exports.FACE_TRACKING_TRAITS = void 0;
+var init_face_tracking = chunkHCCQLAA4_cjs.__esm({
+  "src/traits/constants/mobile/face-tracking.ts"() {
+    exports.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
+exports.LIDAR_SCANNER_TRAITS = void 0;
+var init_lidar_scanner = chunkHCCQLAA4_cjs.__esm({
+  "src/traits/constants/mobile/lidar-scanner.ts"() {
+    exports.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
+exports.ROOMPLAN_TRAITS = void 0;
+var init_roomplan = chunkHCCQLAA4_cjs.__esm({
+  "src/traits/constants/mobile/roomplan.ts"() {
+    exports.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
+    ];
+  }
+});
+
+exports.init_airpods_spatial_audio = init_airpods_spatial_audio;
+exports.init_face_tracking = init_face_tracking;
+exports.init_ios_object_capture = init_ios_object_capture;
+exports.init_lidar_scanner = init_lidar_scanner;
+exports.init_roomplan = init_roomplan;
+exports.init_shareplay = init_shareplay;
+exports.init_uwb_positioning = init_uwb_positioning;
+//# sourceMappingURL=chunk-YKGPCZEE.cjs.map
+//# sourceMappingURL=chunk-YKGPCZEE.cjs.map