@holoscript/core 6.0.3 → 6.0.4

package/dist/chunk-MPXBVFHQ.js

@@ -0,0 +1,768 @@
+import { init_constants, VR_TRAITS } from './chunk-NDQNIJEH.js';
+
+// src/constants.ts
+init_constants();
+init_constants();
+var STRUCTURAL_DIRECTIVES = [
+  // Asset & Manifest
+  "manifest",
+  "asset",
+  // Semantic Annotations
+  "semantic",
+  "annotate",
+  "semantic_ref",
+  "bindings",
+  "artwork_metadata",
+  "npc_behavior",
+  // World Definition
+  "world_metadata",
+  "world_config",
+  "zones",
+  "spawn_points",
+  // Environment Lighting
+  "skybox",
+  "ambient_light",
+  "directional_light",
+  "fog",
+  // Advanced Simulation & AI
+  "time_zones",
+  "reality_capture",
+  "reality_mesh",
+  "reality_blend",
+  "diminished_reality",
+  "reality_portals",
+  "reality_effects",
+  "consciousness_model",
+  "global_workspace",
+  "attention_schema",
+  "predictive_mind",
+  "information_integration",
+  "qualia_generator",
+  "swarm_config",
+  "minimal_brain",
+  "rules",
+  "pheromone_system",
+  "emergence_detector",
+  "collective_memory",
+  "swarm_optimization",
+  "time_engine",
+  "time_buffer",
+  "time_abilities",
+  "paradox_prevention",
+  "knowledge_integration",
+  "neural_device",
+  "signal_processor",
+  "decoder",
+  "thought_mapping",
+  "haptic_feedback",
+  "visual_prosthesis",
+  "memory_interface",
+  "affective_computing",
+  "quantum_backend",
+  "quantum_rng",
+  "quantum_optimization",
+  "quantum_ml",
+  "quantum_simulation",
+  "quantum_crypto"
+];
+var LIFECYCLE_HOOKS = [
+  // Standard lifecycle
+  "on_mount",
+  "on_unmount",
+  "on_update",
+  "on_data_update",
+  "on_tick",
+  "on_activate",
+  "on_deactivate",
+  "on_detected",
+  // VR lifecycle
+  "on_grab",
+  "on_release",
+  "on_hover_enter",
+  "on_hover_exit",
+  "on_point_enter",
+  "on_point_exit",
+  "on_collision",
+  "on_trigger_enter",
+  "on_trigger_exit",
+  "on_click",
+  "on_double_click",
+  // Controller hooks
+  "on_controller_button",
+  "on_trigger_hold",
+  "on_trigger_release",
+  "on_grip_hold",
+  "on_grip_release",
+  // Stretchable/Moldable hooks
+  "on_stretch",
+  "on_sculpt",
+  // Humanoid/Avatar hooks
+  "on_pose_change",
+  "on_expression_change",
+  "on_gesture",
+  "on_speak",
+  "on_pose_save",
+  "on_morph_change",
+  // Media Production hooks
+  "on_record_start",
+  "on_record_stop",
+  "on_record_pause",
+  "on_stream_start",
+  "on_stream_stop",
+  "on_viewer_join",
+  "on_viewer_leave",
+  "on_chat_message",
+  "on_camera_switch",
+  "on_video_end",
+  "on_video_error",
+  // Analytics hooks
+  "on_track_event",
+  "on_survey_start",
+  "on_survey_complete",
+  "on_survey_skip",
+  "on_variant_assigned",
+  "on_conversion",
+  "on_hotspot_detected",
+  // Social hooks
+  "on_share",
+  "on_share_complete",
+  "on_embed",
+  "on_scan",
+  "on_user_join",
+  "on_user_leave",
+  "on_draw_stroke",
+  "on_object_lock",
+  "on_object_unlock",
+  // Effects hooks
+  "on_particle_spawn",
+  "on_particle_death",
+  "on_transition_start",
+  "on_transition_complete",
+  "on_filter_change",
+  // Audio hooks
+  "on_audio_start",
+  "on_audio_end",
+  "on_voice_command",
+  "on_speech_start",
+  "on_speech_end",
+  "on_beat",
+  "on_frequency_peak",
+  // AI hooks
+  "on_narration_start",
+  "on_narration_end",
+  "on_user_question",
+  "on_response_ready",
+  "on_emotion_change",
+  "on_generation_complete",
+  // Timeline hooks
+  "on_timeline_start",
+  "on_timeline_complete",
+  "on_keyframe_hit",
+  "on_keyframe_add",
+  "on_beat_sync",
+  "on_move_complete",
+  // Environment Understanding hooks
+  "on_plane_detected",
+  "on_plane_lost",
+  "on_plane_updated",
+  "on_mesh_detected",
+  "on_mesh_updated",
+  "on_anchor_created",
+  "on_anchor_resolved",
+  "on_anchor_lost",
+  "on_anchor_shared",
+  "on_light_estimated",
+  "on_occlusion_updated",
+  // Input Modality hooks
+  "on_gaze_enter",
+  "on_gaze_exit",
+  "on_gaze_dwell",
+  "on_hand_gesture",
+  "on_hand_pinch",
+  "on_hand_lost",
+  "on_body_pose_update",
+  "on_face_expression",
+  "on_controller_vibrate",
+  "on_accessory_input",
+  // Accessibility hooks
+  "on_accessibility_announce",
+  "on_subtitle_display",
+  "on_magnify",
+  "on_contrast_change",
+  "on_motion_reduce",
+  "on_screen_reader_focus",
+  "on_sonification_update",
+  // Gaussian Splatting & Volumetric hooks
+  "on_splat_loaded",
+  "on_nerf_ready",
+  "on_volume_frame",
+  "on_point_cloud_loaded",
+  "on_capture_complete",
+  // WebGPU Compute hooks
+  "on_compute_complete",
+  "on_buffer_ready",
+  "on_gpu_error",
+  // Digital Twin & IoT hooks
+  "on_sensor_update",
+  "on_data_change",
+  "on_alert_triggered",
+  "on_twin_sync",
+  "on_heatmap_update",
+  // Autonomous Agent hooks
+  "on_goal_completed",
+  "on_goal_failed",
+  "on_perception_change",
+  "on_emotion_shift",
+  "on_faction_change",
+  "on_patrol_waypoint",
+  "on_llm_response",
+  "on_memory_recalled",
+  "on_dialogue_start",
+  "on_dialogue_end",
+  // Advanced Spatial Audio hooks
+  "on_reverb_enter",
+  "on_reverb_exit",
+  "on_audio_occluded",
+  "on_audio_portal_enter",
+  // OpenUSD & Interoperability hooks
+  "on_asset_loaded",
+  "on_format_converted",
+  "on_scene_composed",
+  // Co-Presence & Shared Experience hooks
+  "on_co_presence_joined",
+  "on_co_presence_left",
+  "on_voice_proximity_change",
+  "on_role_change",
+  "on_spectator_join",
+  "on_avatar_sync",
+  // Geospatial & AR Cloud hooks
+  "on_vps_localized",
+  "on_poi_proximity",
+  "on_terrain_resolved",
+  "on_rooftop_resolved",
+  // Web3 & Ownership hooks
+  "on_wallet_connected",
+  "on_token_verified",
+  "on_nft_transferred",
+  "on_purchase_complete",
+  "on_asset_ported",
+  // Physics Expansion hooks
+  "on_cloth_tear",
+  "on_fluid_splash",
+  "on_soft_body_deform",
+  "on_rope_snap",
+  "on_wind_change",
+  "on_submerge",
+  "on_destruction_complete"
+];
+
+// src/parser/ErrorRecovery.ts
+var VALID_KEYWORDS = [
+  "composition",
+  "object",
+  "group",
+  "template",
+  "state",
+  "logic",
+  "environment",
+  "timeline",
+  "zone",
+  "audio",
+  "ui_panel",
+  "ui_button",
+  "ui_text",
+  "ui_slider",
+  "ui_input",
+  "ui_image",
+  "ui_chart",
+  "import",
+  "using",
+  "action",
+  "on",
+  "if",
+  "else",
+  "for",
+  "while",
+  "animate",
+  "emit",
+  "spawn",
+  "transition"
+];
+var VALID_GEOMETRIES = [
+  "cube",
+  "box",
+  "sphere",
+  "cylinder",
+  "cone",
+  "torus",
+  "plane",
+  "text",
+  "model",
+  "sparkles",
+  "particles"
+];
+var VALID_TRAITS = [...VR_TRAITS];
+var COMMON_PROPERTIES = [
+  "position",
+  "rotation",
+  "scale",
+  "color",
+  "material",
+  "geometry",
+  "mesh",
+  "model",
+  "src",
+  "text",
+  "content",
+  "width",
+  "height",
+  "radius",
+  "size",
+  "opacity",
+  "visible",
+  "name",
+  "id"
+];
+var ERROR_PATTERNS = [
+  // Missing closing brace
+  {
+    pattern: /unexpected end of input/i,
+    code: "MISSING_BRACE",
+    message: () => "Missing closing brace. Check that all { have matching }.",
+    suggestions: () => [
+      {
+        description: "Add closing brace at the end",
+        fix: "Add } to close the block"
+      },
+      {
+        description: "Check for unclosed nested blocks",
+        fix: "Ensure each { has a corresponding }"
+      }
+    ]
+  },
+  // Missing colon in property
+  {
+    pattern: /expected.*:/i,
+    code: "MISSING_COLON",
+    message: () => "Missing colon after property name.",
+    suggestions: () => [
+      {
+        description: "Add colon after property name",
+        fix: "propertyName: value"
+      }
+    ]
+  },
+  // Unclosed string
+  {
+    pattern: /unterminated string|unexpected newline in string/i,
+    code: "MISSING_QUOTE",
+    message: () => "Unclosed string literal. Make sure strings have closing quotes.",
+    suggestions: () => [
+      {
+        description: "Add closing quote",
+        fix: `Ensure string ends with matching " or '`
+      },
+      {
+        description: "For multi-line strings, use template literals",
+        fix: "Use backticks ` for multi-line strings"
+      }
+    ]
+  },
+  // Unknown keyword
+  {
+    pattern: /unexpected identifier ["']?(\w+)["']?/i,
+    code: "UNKNOWN_KEYWORD",
+    message: (match) => `Unknown keyword: ${match[1]}`,
+    suggestions: (match) => {
+      const word = match[1];
+      const similar = findSimilar(word, VALID_KEYWORDS);
+      return similar.map((s) => ({
+        description: `Did you mean '${s}'?`,
+        fix: `Replace '${word}' with '${s}'`
+      }));
+    }
+  }
+];
+var ErrorRecovery = class {
+  constructor() {
+    this.errors = [];
+  }
+  /**
+   * Create an enhanced error with suggestions
+   */
+  createError(code, message, line, column, source) {
+    const error = {
+      code,
+      message,
+      line,
+      column,
+      source,
+      suggestions: this.getSuggestions(code, message, source)
+    };
+    this.errors.push(error);
+    return error;
+  }
+  /**
+   * Get suggestions based on error type
+   */
+  getSuggestions(code, message, _source) {
+    const suggestions = [];
+    switch (code) {
+      case "UNKNOWN_TRAIT":
+        const traitMatch = message.match(/trait.*["'](\w+)["']/i);
+        if (traitMatch) {
+          const similar = findSimilar(traitMatch[1], VALID_TRAITS);
+          suggestions.push(
+            ...similar.map((s) => ({
+              description: `Did you mean '@${s}'?`,
+              fix: `Replace with @${s}`
+            }))
+          );
+        }
+        break;
+      case "UNKNOWN_GEOMETRY":
+        const geoMatch = message.match(/geometry.*["'](\w+)["']/i);
+        if (geoMatch) {
+          const similar = findSimilar(geoMatch[1], VALID_GEOMETRIES);
+          suggestions.push(
+            ...similar.map((s) => ({
+              description: `Did you mean '${s}'?`,
+              fix: `geometry: "${s}"`
+            }))
+          );
+        }
+        break;
+      case "INVALID_PROPERTY":
+        const propMatch = message.match(/property.*["'](\w+)["']/i);
+        if (propMatch) {
+          const similar = findSimilar(propMatch[1], COMMON_PROPERTIES);
+          suggestions.push(
+            ...similar.map((s) => ({
+              description: `Did you mean '${s}'?`,
+              fix: `${s}: value`
+            }))
+          );
+        }
+        break;
+      case "TRAIT_CONFLICT":
+        suggestions.push({
+          description: "Remove one of the conflicting traits",
+          fix: "Check trait documentation for compatibility"
+        });
+        break;
+      case "TRAIT_REQUIRES":
+        suggestions.push({
+          description: "Add the required trait",
+          fix: "Some traits depend on others (e.g., @throwable requires @grabbable)"
+        });
+        break;
+      case "MISSING_BRACE":
+        suggestions.push({
+          description: "Check for matching braces",
+          fix: "Every { must have a corresponding }"
+        });
+        break;
+      case "MISSING_COLON":
+        suggestions.push({
+          description: "Add colon after property name",
+          fix: "Format: propertyName: value"
+        });
+        break;
+      case "MISSING_QUOTE":
+        suggestions.push({
+          description: "Close the string with matching quote",
+          fix: "Strings must end with the same quote they started with"
+        });
+        break;
+      case "INVALID_VALUE":
+        suggestions.push({
+          description: "Check value type",
+          fix: 'position expects [x, y, z], color expects "#rrggbb"'
+        });
+        break;
+      case "DUPLICATE_NAME":
+        suggestions.push({
+          description: "Use unique names for objects",
+          fix: "Each object in a composition must have a unique name"
+        });
+        break;
+      case "MISSING_REQUIRED":
+        suggestions.push({
+          description: "Add required properties",
+          fix: "Some blocks require certain properties to be defined"
+        });
+        break;
+      case "UNKNOWN_KEYWORD": {
+        const kwMatch = message.match(/keyword.*[:"']?\s*(\w+)/i);
+        if (kwMatch) {
+          const similar = findSimilar(kwMatch[1], VALID_KEYWORDS);
+          suggestions.push(
+            ...similar.map((s) => ({
+              description: `Did you mean '${s}'?`,
+              fix: `Replace with ${s}`
+            }))
+          );
+        }
+        if (suggestions.length === 0) {
+          suggestions.push({
+            description: "Check available keywords",
+            fix: "Valid keywords: composition, object, group, template, etc."
+          });
+        }
+        break;
+      }
+      case "SYNTAX_ERROR":
+        suggestions.push({
+          description: "Check syntax around this location",
+          fix: "Verify braces, quotes, and property format"
+        });
+        break;
+    }
+    return suggestions;
+  }
+  /**
+   * Analyze raw error message and enhance it
+   */
+  analyzeError(rawMessage, source, line, column) {
+    for (const pattern of ERROR_PATTERNS) {
+      const match = rawMessage.match(pattern.pattern);
+      if (match) {
+        const context = { source, line, column };
+        return {
+          code: pattern.code,
+          message: pattern.message(match),
+          line,
+          column,
+          source,
+          suggestions: pattern.suggestions(match, context)
+        };
+      }
+    }
+    return {
+      code: "SYNTAX_ERROR",
+      message: rawMessage,
+      line,
+      column,
+      source,
+      suggestions: [
+        {
+          description: "Check syntax around this location",
+          fix: "Verify braces, quotes, and property format"
+        }
+      ]
+    };
+  }
+  /**
+   * Format error for display
+   */
+  formatError(error) {
+    const lines = [];
+    lines.push(`[${error.code}] ${error.message}`);
+    lines.push(`  at line ${error.line}, column ${error.column}`);
+    if (error.source) {
+      lines.push("");
+      lines.push(`  ${error.source}`);
+      lines.push(`  ${" ".repeat(error.column - 1)}^`);
+    }
+    if (error.suggestions && error.suggestions.length > 0) {
+      lines.push("");
+      lines.push("Suggestions:");
+      for (const suggestion of error.suggestions) {
+        lines.push(`  \u2022 ${suggestion.description}`);
+        if (suggestion.fix) {
+          lines.push(`    Fix: ${suggestion.fix}`);
+        }
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Get all collected errors
+   */
+  getErrors() {
+    return [...this.errors];
+  }
+  /**
+   * Clear collected errors
+   */
+  clear() {
+    this.errors = [];
+  }
+  /**
+   * Check if there are any errors
+   */
+  hasErrors() {
+    return this.errors.length > 0;
+  }
+};
+function findSimilar(input, candidates, maxDistance = 3) {
+  const results = [];
+  for (const candidate of candidates) {
+    const distance = levenshteinDistance(input.toLowerCase(), candidate.toLowerCase());
+    if (distance <= maxDistance) {
+      results.push({ word: candidate, distance });
+    }
+  }
+  return results.sort((a, b) => a.distance - b.distance).slice(0, 3).map((r) => r.word);
+}
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function enrichErrorWithSuggestions(error, source) {
+  if (error.suggestions && error.suggestions.length > 0) {
+    return error;
+  }
+  const suggestions = [];
+  switch (error.code) {
+    case "UNKNOWN_TRAIT":
+      const traitMatch = error.message.match(/trait.*["'](\w+)["']/i);
+      if (traitMatch) {
+        const similar = findSimilar(traitMatch[1], VALID_TRAITS);
+        suggestions.push(
+          ...similar.map((s) => ({
+            description: `Did you mean '@${s}'?`,
+            fix: `Replace with @${s}`
+          }))
+        );
+      }
+      break;
+    case "UNKNOWN_KEYWORD":
+      const keywordMatch = error.message.match(/keyword.*["'](\w+)["']/i);
+      if (keywordMatch) {
+        const similar = findSimilar(keywordMatch[1], VALID_KEYWORDS);
+        suggestions.push(
+          ...similar.map((s) => ({
+            description: `Did you mean '${s}'?`,
+            fix: `Replace with ${s}`
+          }))
+        );
+      }
+      break;
+    case "UNKNOWN_GEOMETRY":
+      const geomMatch = error.message.match(/geometry.*["'](\w+)["']/i);
+      if (geomMatch) {
+        const similar = findSimilar(geomMatch[1], VALID_GEOMETRIES);
+        suggestions.push(
+          ...similar.map((s) => ({
+            description: `Did you mean '${s}'?`,
+            fix: `Replace with ${s}`
+          }))
+        );
+      }
+      break;
+    case "MISSING_BRACE":
+      suggestions.push({
+        description: "Add closing brace at the end",
+        fix: "Add } to close the block"
+      });
+      break;
+    case "MISSING_COLON":
+      suggestions.push({
+        description: "Add colon after property name",
+        fix: "propertyName: value"
+      });
+      break;
+    case "MISSING_QUOTE":
+      suggestions.push({
+        description: "Add closing quote",
+        fix: `Ensure string ends with matching " or '`
+      });
+      break;
+  }
+  for (const pattern of ERROR_PATTERNS) {
+    const match = error.message.match(pattern.pattern);
+    if (match) {
+      const context = {
+        source,
+        line: error.line,
+        column: error.column
+      };
+      suggestions.push(...pattern.suggestions(match, context));
+      break;
+    }
+  }
+  return {
+    ...error,
+    suggestions: suggestions.length > 0 ? suggestions : error.suggestions
+  };
+}
+function generateQuickFixes(error, source) {
+  const fixes = [];
+  switch (error.code) {
+    case "MISSING_BRACE":
+      fixes.push({
+        title: "Add closing brace",
+        edit: {
+          range: { start: source.length, end: source.length },
+          newText: "\n}"
+        }
+      });
+      break;
+    case "MISSING_COLON":
+      const lineStart = getLineStart(source, error.line);
+      const lineEnd = source.indexOf("\n", lineStart);
+      const line = source.substring(lineStart, lineEnd === -1 ? void 0 : lineEnd);
+      const match = line.match(/^\s*(\w+)\s+/);
+      if (match) {
+        fixes.push({
+          title: "Add colon after property",
+          edit: {
+            range: { start: lineStart + match[0].length - 1, end: lineStart + match[0].length - 1 },
+            newText: ":"
+          }
+        });
+      }
+      break;
+    case "MISSING_QUOTE":
+      fixes.push({
+        title: "Add closing quote",
+        edit: {
+          range: { start: source.length, end: source.length },
+          newText: '"'
+        }
+      });
+      break;
+  }
+  return fixes;
+}
+function getLineStart(source, lineNumber) {
+  let line = 1;
+  let pos = 0;
+  while (line < lineNumber && pos < source.length) {
+    if (source[pos] === "\n") {
+      line++;
+    }
+    pos++;
+  }
+  return pos;
+}
+var HOLOSCHEMA_KEYWORDS = VALID_KEYWORDS;
+var HOLOSCHEMA_GEOMETRIES = VALID_GEOMETRIES;
+var HOLOSCHEMA_PROPERTIES = COMMON_PROPERTIES;
+
+export { ErrorRecovery, HOLOSCHEMA_GEOMETRIES, HOLOSCHEMA_KEYWORDS, HOLOSCHEMA_PROPERTIES, LIFECYCLE_HOOKS, STRUCTURAL_DIRECTIVES, enrichErrorWithSuggestions, generateQuickFixes };
+//# sourceMappingURL=chunk-MPXBVFHQ.js.map
+//# sourceMappingURL=chunk-MPXBVFHQ.js.map