@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-WJIHFLMJ.js

@@ -0,0 +1,404 @@
+import { z } from 'zod';
+
+// src/compiler/BusinessQuestTools.ts
+var vrrQuestEntrySchema = z.object({
+  id: z.string().min(1),
+  title: z.string().min(1),
+  steps: z.array(z.string()).min(1)
+});
+var businessVRRDraftSchema = z.object({
+  compositionName: z.string().min(1).regex(/^[A-Za-z_][A-Za-z0-9_]*$/, "compositionName must be a valid HoloScript identifier"),
+  twin: z.object({
+    mirrorId: z.string().min(1),
+    realitySync: z.array(z.string()).min(1),
+    geoSync: z.object({
+      center: z.string().min(1),
+      radius: z.number().nonnegative().optional()
+    }).optional()
+  }),
+  weather: z.object({
+    provider: z.enum(["weather.gov", "openweathermap"]),
+    refresh: z.string().optional()
+  }).optional(),
+  events: z.object({
+    provider: z.enum(["eventbrite", "ticketmaster"]),
+    refresh: z.string().optional()
+  }).optional(),
+  businesses: z.array(
+    z.object({
+      id: z.string().min(1),
+      displayName: z.string().optional(),
+      geo: z.object({
+        lat: z.number().gte(-90).lte(90),
+        lng: z.number().gte(-180).lte(180)
+      }),
+      inventory: z.object({
+        provider: z.enum(["square_pos", "shopify", "woocommerce"]),
+        refresh: z.string().optional(),
+        websocket: z.boolean().optional()
+      }).optional(),
+      quests: z.array(vrrQuestEntrySchema).min(1)
+    })
+  ).min(1),
+  layerShift: z.object({
+    from: z.enum(["ar", "vrr", "vr"]),
+    to: z.enum(["ar", "vrr", "vr"]),
+    price: z.number().nonnegative().optional(),
+    persistState: z.boolean().optional()
+  }).optional()
+});
+function vrrTrait(name, params) {
+  return {
+    type: "ObjectTrait",
+    name,
+    config: params,
+    params
+  };
+}
+function emptyCompositionShell(name) {
+  return {
+    type: "Composition",
+    name,
+    templates: [],
+    objects: [],
+    spatialGroups: [],
+    lights: [],
+    imports: [],
+    timelines: [],
+    audio: [],
+    zones: [],
+    transitions: [],
+    conditionals: [],
+    iterators: [],
+    npcs: [],
+    quests: [],
+    abilities: [],
+    dialogues: [],
+    stateMachines: [],
+    achievements: [],
+    talentTrees: [],
+    shapes: [],
+    metadata: {
+      source: "business-quest-tools",
+      draftKind: "hololand-vrr"
+    }
+  };
+}
+function buildVRRCompositionFromDraft(draft) {
+  const composition = emptyCompositionShell(draft.compositionName);
+  const twinTraits = [
+    vrrTrait("vrr_twin", { mirror: draft.twin.mirrorId }),
+    vrrTrait("reality_mirror", { sync: draft.twin.realitySync })
+  ];
+  if (draft.twin.geoSync) {
+    twinTraits.push(
+      vrrTrait("geo_sync", {
+        center: draft.twin.geoSync.center,
+        radius: draft.twin.geoSync.radius ?? 0
+      })
+    );
+  }
+  const twinObject = {
+    type: "Object",
+    name: `${draft.compositionName}_twin_root`,
+    properties: [],
+    traits: twinTraits
+  };
+  const objects = [twinObject];
+  if (draft.weather) {
+    objects.push({
+      type: "Object",
+      name: `${draft.compositionName}_weather`,
+      properties: [],
+      traits: [
+        vrrTrait("weather_sync", {
+          provider: draft.weather.provider,
+          refresh: draft.weather.refresh ?? "5_minutes"
+        })
+      ]
+    });
+  }
+  if (draft.events) {
+    objects.push({
+      type: "Object",
+      name: `${draft.compositionName}_events`,
+      properties: [],
+      traits: [
+        vrrTrait("event_sync", {
+          provider: draft.events.provider,
+          refresh: draft.events.refresh ?? "5_minutes"
+        })
+      ]
+    });
+  }
+  for (const biz of draft.businesses) {
+    const questPayload = biz.quests.map((q) => ({
+      id: q.id,
+      title: q.title,
+      steps: q.steps
+    }));
+    const bizTraits = [
+      vrrTrait("geo_anchor", { lat: biz.geo.lat, lng: biz.geo.lng }),
+      vrrTrait("quest_hub", { quests: questPayload })
+    ];
+    if (biz.inventory) {
+      bizTraits.push(
+        vrrTrait("inventory_sync", {
+          provider: biz.inventory.provider,
+          refresh: biz.inventory.refresh ?? "1_minute",
+          websocket: biz.inventory.websocket ?? false
+        })
+      );
+    }
+    objects.push({
+      type: "Object",
+      name: biz.displayName ?? biz.id,
+      properties: [],
+      traits: bizTraits
+    });
+  }
+  if (draft.layerShift) {
+    objects.push({
+      type: "Object",
+      name: `${draft.compositionName}_layer_shift`,
+      properties: [],
+      traits: [
+        vrrTrait("layer_shift", {
+          from: draft.layerShift.from,
+          to: draft.layerShift.to,
+          price: draft.layerShift.price ?? 0,
+          persist_state: draft.layerShift.persistState !== false
+        })
+      ]
+    });
+  }
+  composition.objects = objects;
+  return composition;
+}
+function validateBusinessVRRDraft(draft, options) {
+  const issues = [];
+  const parsed = businessVRRDraftSchema.safeParse(draft);
+  if (!parsed.success) {
+    for (const err of parsed.error.issues) {
+      issues.push({
+        path: err.path.join("."),
+        message: err.message,
+        severity: "error"
+      });
+    }
+    return Promise.resolve({ ok: false, issues });
+  }
+  if (options?.parseWithVrrCompiler) {
+    return import('./compiler/vrr.js').then(({ VRRCompiler }) => {
+      const composition = buildVRRCompositionFromDraft(parsed.data);
+      const compiler = new VRRCompiler({
+        target: "threejs",
+        minify: false,
+        source_maps: false,
+        api_integrations: {},
+        performance: { target_fps: 60, max_players: 1e3, lazy_loading: true }
+      });
+      const data = compiler.parseVRRComposition(composition);
+      if (data.questNodes.length === 0) {
+        issues.push({
+          path: "businesses",
+          message: "VRR parse found no @quest_hub nodes \u2014 check draft.quests",
+          severity: "warning"
+        });
+      }
+      if (data.twinNodes.length === 0) {
+        issues.push({
+          path: "twin",
+          message: "VRR parse found no @vrr_twin nodes",
+          severity: "warning"
+        });
+      }
+      return { ok: issues.every((i) => i.severity !== "error"), issues };
+    }).catch((err) => {
+      issues.push({
+        path: "",
+        message: err instanceof Error ? err.message : String(err),
+        severity: "error"
+      });
+      return { ok: false, issues };
+    });
+  }
+  return Promise.resolve({ ok: true, issues });
+}
+function draftToHoloPreview(draft) {
+  const lines = [];
+  lines.push(`// Preview \u2014 generated by BusinessQuestTools (no-code VRR draft)`);
+  lines.push(`composition "${draft.compositionName}" {`);
+  lines.push(
+    `  // twin: mirror=${draft.twin.mirrorId} sync=[${draft.twin.realitySync.join(", ")}]`
+  );
+  if (draft.weather) {
+    lines.push(`  // weather: ${draft.weather.provider}`);
+  }
+  if (draft.events) {
+    lines.push(`  // events: ${draft.events.provider}`);
+  }
+  for (const biz of draft.businesses) {
+    lines.push(`  // business "${biz.id}" @ geo ${biz.geo.lat},${biz.geo.lng}`);
+    for (const q of biz.quests) {
+      lines.push(`  //   quest "${q.title}" (${q.steps.length} steps)`);
+    }
+  }
+  lines.push(`}`);
+  return lines.join("\n");
+}
+var BUSINESS_QUEST_TOOLS = [
+  {
+    name: "holoscript_business_quest_scaffold_vrr",
+    description: "Build a HoloComposition JSON for Hololand VRR from a structured draft (no .holo source). Includes @vrr_twin, @reality_mirror, optional @geo_sync, @weather_sync, @event_sync, per-business @geo_anchor + @quest_hub + optional @inventory_sync, and optional @layer_shift.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        draft: {
+          type: "object",
+          description: "BusinessVRRDraft \u2014 see businessVRRDraftSchema in @holoscript/core"
+        },
+        runVrrParse: {
+          type: "boolean",
+          description: "If true, run VRRCompiler.parseVRRComposition and return trait counts",
+          default: false
+        },
+        agentToken: {
+          type: "string",
+          description: "Optional agent token for future RBAC (reserved)"
+        }
+      },
+      required: ["draft"]
+    }
+  },
+  {
+    name: "holoscript_business_quest_validate_vrr_draft",
+    description: "Validate a BusinessVRRDraft (Zod). Optionally run VRRCompiler parse smoke check.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        draft: { type: "object", description: "Candidate BusinessVRRDraft JSON" },
+        parseWithVrrCompiler: {
+          type: "boolean",
+          description: "When true, dynamically loads VRRCompiler for wiring verification",
+          default: false
+        }
+      },
+      required: ["draft"]
+    }
+  },
+  {
+    name: "holoscript_business_quest_preview_holo",
+    description: "Return a commented HoloScript-style preview string for founder review (not a full parser round-trip).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        draft: { type: "object" }
+      },
+      required: ["draft"]
+    }
+  }
+];
+async function handleBusinessQuestToolCall(request) {
+  try {
+    switch (request.name) {
+      case "holoscript_business_quest_scaffold_vrr":
+        return await handleScaffold(request.arguments);
+      case "holoscript_business_quest_validate_vrr_draft":
+        return await handleValidate(request.arguments);
+      case "holoscript_business_quest_preview_holo":
+        return await handlePreview(request.arguments);
+      default:
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Unknown tool: ${request.name}` }]
+        };
+    }
+  } catch (error) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ]
+    };
+  }
+}
+async function handleScaffold(args) {
+  const parsed = businessVRRDraftSchema.safeParse(args.draft);
+  if (!parsed.success) {
+    return {
+      isError: true,
+      content: [{ type: "text", text: JSON.stringify(parsed.error.flatten(), null, 2) }]
+    };
+  }
+  const composition = buildVRRCompositionFromDraft(parsed.data);
+  const runParse = Boolean(args.runVrrParse);
+  let vrrSummary;
+  if (runParse) {
+    const { VRRCompiler } = await import('./compiler/vrr.js');
+    const compiler = new VRRCompiler({
+      target: "threejs",
+      minify: false,
+      source_maps: false,
+      api_integrations: {},
+      performance: { target_fps: 60, max_players: 1e3, lazy_loading: true }
+    });
+    const data = compiler.parseVRRComposition(composition);
+    vrrSummary = {
+      twinNodes: data.twinNodes.length,
+      weatherNodes: data.weatherNodes.length,
+      eventNodes: data.eventNodes.length,
+      inventoryNodes: data.inventoryNodes.length,
+      questNodes: data.questNodes.length,
+      layerShiftNodes: data.layerShiftNodes.length,
+      paywallNodes: data.paywallNodes.length,
+      geoAnchorNodes: data.geoAnchorNodes.length
+    };
+  }
+  const payload = {
+    success: true,
+    compositionName: composition.name,
+    objectCount: composition.objects.length,
+    composition,
+    vrrTraitCounts: vrrSummary
+  };
+  return {
+    isError: false,
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+async function handleValidate(args) {
+  const parseWithVrrCompiler = Boolean(args.parseWithVrrCompiler);
+  const result = await validateBusinessVRRDraft(args.draft, { parseWithVrrCompiler });
+  return {
+    isError: !result.ok,
+    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+  };
+}
+async function handlePreview(args) {
+  const parsed = businessVRRDraftSchema.safeParse(args.draft);
+  if (!parsed.success) {
+    return {
+      isError: true,
+      content: [{ type: "text", text: JSON.stringify(parsed.error.flatten(), null, 2) }]
+    };
+  }
+  const text = draftToHoloPreview(parsed.data);
+  return {
+    isError: false,
+    content: [{ type: "text", text }]
+  };
+}
+function registerBusinessQuestTools(server) {
+  for (const tool of BUSINESS_QUEST_TOOLS) {
+    server.registerTool(tool, handleBusinessQuestToolCall);
+  }
+}
+var BusinessQuestTools_default = handleBusinessQuestToolCall;
+
+export { BUSINESS_QUEST_TOOLS, BusinessQuestTools_default, buildVRRCompositionFromDraft, businessVRRDraftSchema, draftToHoloPreview, handleBusinessQuestToolCall, registerBusinessQuestTools, validateBusinessVRRDraft };
+//# sourceMappingURL=chunk-WJIHFLMJ.js.map
+//# sourceMappingURL=chunk-WJIHFLMJ.js.map

package/dist/chunk-WKX5AMOY.js

@@ -0,0 +1,309 @@
+import { __esm } from './chunk-OL46QLBJ.js';
+
+// src/traits/constants/mobile/geospatial.ts
+var GEOSPATIAL_ARCORE_TRAITS, GEOSPATIAL_DEFAULTS;
+var init_geospatial = __esm({
+  "src/traits/constants/mobile/geospatial.ts"() {
+    GEOSPATIAL_ARCORE_TRAITS = [
+      // --- VPS Core ---
+      "geospatial_vps",
+      // enables ARCore GeospatialMode.ENABLED on session
+      "geospatial_heading",
+      // heading/orientation alignment from VPS compass data
+      // --- Anchoring ---
+      "geospatial_anchor",
+      // lat/lng/alt/heading anchor via Earth.createAnchor
+      "geospatial_terrain_anchor",
+      // resolveAnchorOnTerrain — snaps to terrain surface
+      "geospatial_rooftop_anchor",
+      // resolveAnchorOnRooftop — snaps to building rooftops
+      // --- Streetscape ---
+      "geospatial_streetscape"
+      // Streetscape Geometry mesh access for buildings/terrain
+    ];
+    GEOSPATIAL_DEFAULTS = {
+      vps: {
+        accuracyThreshold: 25,
+        headingAccuracyThreshold: 25,
+        localizationTimeout: 3e4
+      },
+      anchor: {
+        latitude: 0,
+        longitude: 0,
+        altitude: 0,
+        heading: 0,
+        resolveTimeout: 1e4
+      },
+      terrainAnchor: {
+        latitude: 0,
+        longitude: 0,
+        altitudeOffset: 0,
+        heading: 0,
+        resolveTimeout: 1e4
+      },
+      rooftopAnchor: {
+        latitude: 0,
+        longitude: 0,
+        altitudeOffset: 0,
+        heading: 0,
+        resolveTimeout: 1e4
+      },
+      streetscape: {
+        enableTerrain: true,
+        enableBuildings: true
+      }
+    };
+  }
+});
+
+// src/traits/constants/mobile/spatial-authoring.ts
+var SPATIAL_AUTHORING_TRAITS, SPATIAL_AUTHORING_DEFAULTS;
+var init_spatial_authoring = __esm({
+  "src/traits/constants/mobile/spatial-authoring.ts"() {
+    SPATIAL_AUTHORING_TRAITS = [
+      // --- Gyro Placement ---
+      "author_gyro_place",
+      // gyroscope-stabilised AR object placement
+      // --- Pinch Scale ---
+      "author_pinch_scale",
+      // pinch-to-scale selected entity
+      // --- Swipe Browse ---
+      "author_swipe_browse",
+      // horizontal swipe to browse trait palette
+      // --- Voice Commands ---
+      "author_voice_cmd",
+      // speech recognition → parse and execute commands
+      // --- Shake Undo ---
+      "author_shake_undo"
+      // shake device to undo last action
+    ];
+    SPATIAL_AUTHORING_DEFAULTS = {
+      /** Gyro low-pass filter alpha (0-1, lower = smoother) */
+      gyroFilterAlpha: 0.15,
+      /** Minimum pinch scale factor */
+      pinchScaleMin: 0.1,
+      /** Maximum pinch scale factor */
+      pinchScaleMax: 10,
+      /** Shake acceleration threshold (m/s^2) to trigger undo */
+      shakeThreshold: 12,
+      /** Speech recognition locale */
+      speechLocale: "en-US",
+      /** Maximum undo stack depth */
+      undoStackDepth: 50
+    };
+  }
+});
+
+// src/traits/constants/mobile/haptic-feedback.ts
+var HAPTIC_FEEDBACK_TRAITS;
+var init_haptic_feedback = __esm({
+  "src/traits/constants/mobile/haptic-feedback.ts"() {
+    HAPTIC_FEEDBACK_TRAITS = [
+      // --- Interaction ---
+      "haptic_touch",
+      // vibration on hologram touch
+      "haptic_grab",
+      // resistance pulse when grabbing
+      "haptic_throw",
+      // release burst when throwing
+      "haptic_impact",
+      // impact feedback on collision
+      "haptic_select",
+      // click feedback on selection
+      // --- Ambient ---
+      "haptic_proximity",
+      // increasing vibration as hand nears hologram
+      "haptic_texture",
+      // surface texture simulation (rough, smooth, bumpy)
+      "haptic_resistance",
+      // force feedback simulation via vibration patterns
+      // --- System ---
+      "haptic_enable",
+      // enable haptic feedback engine
+      "haptic_intensity",
+      // global intensity multiplier (0.0-1.0)
+      "haptic_pattern_library"
+      // load custom haptic patterns (AHAP on iOS, VibrationEffect on Android)
+    ];
+  }
+});
+
+// src/traits/constants/mobile/nearby-connections.ts
+var NEARBY_CONNECTIONS_TRAITS;
+var init_nearby_connections = __esm({
+  "src/traits/constants/mobile/nearby-connections.ts"() {
+    NEARBY_CONNECTIONS_TRAITS = [
+      // --- Discovery ---
+      "nearby_discover",
+      // discover nearby devices running same .holo scene
+      "nearby_advertise",
+      // advertise this device as joinable
+      "nearby_auto_connect",
+      // automatically connect when same scene detected
+      // --- Mesh ---
+      "nearby_mesh",
+      // form local mesh network (star or mesh topology)
+      "nearby_max_peers",
+      // maximum number of connected peers
+      "nearby_bandwidth",
+      // connection strategy: HIGH_BANDWIDTH or LOW_POWER
+      // --- Sync ---
+      "nearby_p2p_sync",
+      // sync .holo scene state P2P via Loro CRDT
+      "nearby_broadcast",
+      // broadcast events to all connected peers
+      "nearby_spatial_anchor_share"
+      // share spatial anchors between nearby devices
+    ];
+  }
+});
+
+// src/traits/constants/mobile/foldable-display.ts
+var FOLDABLE_DISPLAY_TRAITS;
+var init_foldable_display = __esm({
+  "src/traits/constants/mobile/foldable-display.ts"() {
+    FOLDABLE_DISPLAY_TRAITS = [
+      "foldable_detect",
+      // detect foldable device and fold state
+      "foldable_split_view",
+      // AR viewfinder on one panel, controls on other
+      "foldable_flex_mode",
+      // Flip flex mode: top AR, bottom controls
+      "foldable_tabletop",
+      // tabletop mode: phone stands up, AR projects forward
+      "foldable_hinge_angle",
+      // expose hinge angle as input parameter
+      "foldable_continuity"
+      // seamless transition between fold states
+    ];
+  }
+});
+
+// src/traits/constants/mobile/samsung-dex.ts
+var SAMSUNG_DEX_TRAITS;
+var init_samsung_dex = __esm({
+  "src/traits/constants/mobile/samsung-dex.ts"() {
+    SAMSUNG_DEX_TRAITS = [
+      "dex_detect",
+      // detect Samsung DeX connection
+      "dex_handoff",
+      // hand off .holo scene from mobile AR to desktop view
+      "dex_desktop_controls",
+      // enable mouse/keyboard controls in DeX mode
+      "dex_multi_window",
+      // support multi-window layout in DeX
+      "dex_resolution_adapt"
+      // adapt rendering resolution to external display
+    ];
+  }
+});
+
+// src/traits/constants/mobile/webxr.ts
+var WEBXR_TRAITS;
+var init_webxr = __esm({
+  "src/traits/constants/mobile/webxr.ts"() {
+    WEBXR_TRAITS = [
+      // --- Session ---
+      "webxr_session",
+      // request immersive-ar or immersive-vr session
+      "webxr_inline",
+      // inline XR (non-immersive, preview mode)
+      // --- Features ---
+      "webxr_hit_test",
+      // ray-surface hit testing for placement
+      "webxr_anchors",
+      // persistent anchors across frames
+      "webxr_light_estimation",
+      // real-world lighting probe for hologram shading
+      "webxr_dom_overlay",
+      // HTML DOM overlay on top of XR scene
+      "webxr_depth_sensing",
+      // depth buffer access for occlusion
+      "webxr_hand_tracking",
+      // WebXR hand tracking API (where supported)
+      // --- Rendering ---
+      "webxr_layers",
+      // XR composition layers (projection, quad, cylinder)
+      "webxr_framebuffer",
+      // direct framebuffer access for custom rendering
+      "webxr_reference_space"
+      // reference space type (local, local-floor, bounded-floor)
+    ];
+  }
+});
+
+// src/traits/constants/mobile/google-lens.ts
+var GOOGLE_LENS_TRAITS;
+var init_google_lens = __esm({
+  "src/traits/constants/mobile/google-lens.ts"() {
+    GOOGLE_LENS_TRAITS = [
+      "lens_recognize",
+      // enable object/scene recognition
+      "lens_text_overlay",
+      // OCR text as holographic overlay
+      "lens_product_id",
+      // product identification and info overlay
+      "lens_translate",
+      // real-time text translation overlay
+      "lens_entity_pipe",
+      // pipe recognized entities into .holo scene graph
+      "lens_plant_animal_id",
+      // plant/animal species identification
+      "lens_landmark_info"
+      // landmark/building information overlay
+    ];
+  }
+});
+
+// src/traits/constants/mobile/depth-scanner.ts
+var DEPTH_SCANNER_TRAITS, DEPTH_SCANNER_DEFAULTS;
+var init_depth_scanner = __esm({
+  "src/traits/constants/mobile/depth-scanner.ts"() {
+    DEPTH_SCANNER_TRAITS = [
+      // --- Core ---
+      "depth_scan",
+      // enables depth scanning pipeline
+      "depth_auto_select",
+      // runtime picks best source: ToF > ARCore ML > stereo
+      // --- Backends ---
+      "depth_ml_arcore",
+      // ARCore Depth API — ML-based monocular depth (200+ devices)
+      "depth_tof",
+      // Time-of-Flight sensor path (hardware ToF required)
+      "depth_stereo",
+      // dual-camera stereo depth estimation
+      // --- Processing ---
+      "depth_confidence_map",
+      // per-pixel confidence image (0-255)
+      "depth_mesh_generate",
+      // convert depth map to triangle mesh
+      "depth_mesh_to_holo",
+      // convert reconstructed mesh to .holo scene graph
+      // --- Output ---
+      "depth_realtime",
+      // live depth updates every frame
+      "depth_export"
+      // export mesh as OBJ/GLB
+    ];
+    DEPTH_SCANNER_DEFAULTS = {
+      scan: {
+        confidenceThreshold: 128,
+        maxDepthMeters: 5,
+        meshDecimation: 0.5
+      },
+      export: {
+        format: "glb",
+        includeColor: true,
+        includeNormals: true
+      },
+      realtime: {
+        targetFps: 30,
+        temporalSmoothing: true
+      }
+    };
+  }
+});
+
+export { DEPTH_SCANNER_DEFAULTS, DEPTH_SCANNER_TRAITS, FOLDABLE_DISPLAY_TRAITS, GEOSPATIAL_ARCORE_TRAITS, GEOSPATIAL_DEFAULTS, GOOGLE_LENS_TRAITS, HAPTIC_FEEDBACK_TRAITS, NEARBY_CONNECTIONS_TRAITS, SAMSUNG_DEX_TRAITS, SPATIAL_AUTHORING_DEFAULTS, SPATIAL_AUTHORING_TRAITS, WEBXR_TRAITS, init_depth_scanner, init_foldable_display, init_geospatial, init_google_lens, init_haptic_feedback, init_nearby_connections, init_samsung_dex, init_spatial_authoring, init_webxr };
+//# sourceMappingURL=chunk-WKX5AMOY.js.map
+//# sourceMappingURL=chunk-WKX5AMOY.js.map