@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-W6RW64BB.cjs

@@ -0,0 +1,1219 @@
+'use strict';
+
+var chunkC37BHB7N_cjs = require('./chunk-C37BHB7N.cjs');
+
+// src/types/AdvancedTypeSystem.ts
+var ExhaustivenessChecker = class {
+  /**
+   * Check if all union members are covered in match statement
+   */
+  checkMatch(unionType, casePatterns) {
+    const patterns = new Set(casePatterns.map((p) => p.toLowerCase()));
+    const uncovered = [];
+    for (const member of unionType.members) {
+      const caseName = this.getCaseName(member);
+      if (!patterns.has(caseName.toLowerCase()) && caseName !== "_") {
+        uncovered.push(caseName);
+      }
+    }
+    return {
+      isExhaustive: uncovered.length === 0 || patterns.has("_"),
+      uncoveredCases: uncovered
+    };
+  }
+  getCaseName(type) {
+    if (type.kind === "literal") {
+      return String(type.value);
+    }
+    if (type.kind === "custom") {
+      return type.name;
+    }
+    return type.kind;
+  }
+};
+
+// src/types/TypeAliasRegistry.ts
+var TypeAliasRegistry = class {
+  constructor() {
+    this.aliases = /* @__PURE__ */ new Map();
+    /** Tracks which aliases are currently being expanded (cycle detection) */
+    this.expanding = /* @__PURE__ */ new Set();
+  }
+  // ---------------------------------------------------------------------------
+  // Registration
+  // ---------------------------------------------------------------------------
+  register(decl) {
+    this.aliases.set(decl.name, decl);
+  }
+  has(name) {
+    return this.aliases.has(name);
+  }
+  get(name) {
+    return this.aliases.get(name);
+  }
+  all() {
+    return Array.from(this.aliases.values());
+  }
+  clear() {
+    this.aliases.clear();
+    this.expanding.clear();
+  }
+  // ---------------------------------------------------------------------------
+  // Parsing helper (parses a `type Foo = ...` source line)
+  // ---------------------------------------------------------------------------
+  /**
+   * Parse a type alias declaration from source text.
+   * Recognises:
+   *   type Name = definition
+   *   type Name<T, U> = definition
+   */
+  static parse(source, line) {
+    const match = source.match(/^\s*type\s+([A-Z][A-Za-z0-9_]*)(?:<([^>]+)>)?\s*=\s*(.+)$/);
+    if (!match) return null;
+    const name = match[1];
+    const rawParams = match[2];
+    const definition = match[3].trim();
+    const typeParams = rawParams ? rawParams.split(",").map((p) => p.trim()).filter(Boolean) : [];
+    const isUnion = definition.includes("|");
+    const kind = typeParams.length > 0 ? "generic" : isUnion ? "union" : "simple";
+    return { name, kind, definition, typeParams, line };
+  }
+  // ---------------------------------------------------------------------------
+  // Resolution
+  // ---------------------------------------------------------------------------
+  /**
+   * Resolve an alias by name, substituting type params if provided.
+   * Returns null if unknown or recursive.
+   *
+   * Example:
+   *   registry.resolve('Optional', ['string'])
+   *   → 'string | null'
+   */
+  resolve(name, typeArgs = []) {
+    if (this.expanding.has(name)) {
+      return null;
+    }
+    const decl = this.aliases.get(name);
+    if (!decl) return null;
+    if (this.containsAlias(decl.definition, name)) {
+      return null;
+    }
+    this.expanding.add(name);
+    try {
+      let expanded = decl.definition;
+      if (decl.typeParams && decl.typeParams.length > 0) {
+        for (let i = 0; i < decl.typeParams.length; i++) {
+          const param = decl.typeParams[i];
+          const arg = typeArgs[i] ?? "any";
+          expanded = expanded.replace(new RegExp(`\\b${param}\\b`, "g"), arg);
+        }
+      }
+      expanded = this.expandReferences(expanded);
+      return expanded;
+    } finally {
+      this.expanding.delete(name);
+    }
+  }
+  /**
+   * Detect recursive/self-referential type aliases.
+   */
+  isRecursive(name) {
+    const decl = this.aliases.get(name);
+    if (!decl) return false;
+    this.expanding.add(name);
+    const result = this.containsAlias(decl.definition, name);
+    this.expanding.delete(name);
+    return result;
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  expandReferences(definition) {
+    let result = definition;
+    for (const [aliasName, decl] of this.aliases) {
+      if (this.expanding.has(aliasName)) continue;
+      const pattern = new RegExp(`\\b${aliasName}\\b`, "g");
+      if (pattern.test(result)) {
+        const resolved = this.resolve(aliasName);
+        if (resolved) {
+          result = result.replace(new RegExp(`\\b${aliasName}\\b`, "g"), `(${resolved})`);
+        }
+      }
+    }
+    return result;
+  }
+  containsAlias(definition, targetName) {
+    const pattern = new RegExp(`\\b${targetName}\\b`);
+    return pattern.test(definition);
+  }
+};
+
+// src/HoloScriptTypeChecker.ts
+var BUILTIN_FUNCTIONS = /* @__PURE__ */ new Map([
+  [
+    "add",
+    {
+      type: "function",
+      parameters: [
+        { name: "a", type: "number" },
+        { name: "b", type: "number" }
+      ],
+      returnType: "number"
+    }
+  ],
+  [
+    "subtract",
+    {
+      type: "function",
+      parameters: [
+        { name: "a", type: "number" },
+        { name: "b", type: "number" }
+      ],
+      returnType: "number"
+    }
+  ],
+  [
+    "multiply",
+    {
+      type: "function",
+      parameters: [
+        { name: "a", type: "number" },
+        { name: "b", type: "number" }
+      ],
+      returnType: "number"
+    }
+  ],
+  [
+    "divide",
+    {
+      type: "function",
+      parameters: [
+        { name: "a", type: "number" },
+        { name: "b", type: "number" }
+      ],
+      returnType: "number"
+    }
+  ],
+  [
+    "concat",
+    {
+      type: "function",
+      parameters: [
+        { name: "a", type: "string" },
+        { name: "b", type: "string" }
+      ],
+      returnType: "string"
+    }
+  ],
+  [
+    "length",
+    { type: "function", parameters: [{ name: "value", type: "any" }], returnType: "number" }
+  ],
+  [
+    "push",
+    {
+      type: "function",
+      parameters: [
+        { name: "arr", type: "array" },
+        { name: "item", type: "any" }
+      ],
+      returnType: "array"
+    }
+  ],
+  ["pop", { type: "function", parameters: [{ name: "arr", type: "array" }], returnType: "any" }],
+  ["log", { type: "function", parameters: [{ name: "message", type: "any" }], returnType: "void" }],
+  [
+    "print",
+    { type: "function", parameters: [{ name: "message", type: "any" }], returnType: "void" }
+  ],
+  ["show", { type: "function", parameters: [{ name: "target", type: "orb" }], returnType: "void" }],
+  ["hide", { type: "function", parameters: [{ name: "target", type: "orb" }], returnType: "void" }],
+  [
+    "pulse",
+    { type: "function", parameters: [{ name: "target", type: "orb" }], returnType: "void" }
+  ],
+  [
+    "animate",
+    {
+      type: "function",
+      parameters: [
+        { name: "target", type: "orb" },
+        { name: "config", type: "object" }
+      ],
+      returnType: "void"
+    }
+  ],
+  [
+    "spawn",
+    {
+      type: "function",
+      parameters: [
+        { name: "type", type: "string" },
+        { name: "position", type: "object" }
+      ],
+      returnType: "orb"
+    }
+  ],
+  [
+    "isNumber",
+    { type: "function", parameters: [{ name: "value", type: "any" }], returnType: "boolean" }
+  ],
+  [
+    "isString",
+    { type: "function", parameters: [{ name: "value", type: "any" }], returnType: "boolean" }
+  ],
+  [
+    "isArray",
+    { type: "function", parameters: [{ name: "value", type: "any" }], returnType: "boolean" }
+  ],
+  // Simulation built-in functions (v4.2)
+  [
+    "createCollider",
+    {
+      type: "function",
+      parameters: [
+        { name: "shape", type: "string" },
+        { name: "config", type: "object" }
+      ],
+      returnType: "object"
+    }
+  ],
+  [
+    "createRigidbody",
+    {
+      type: "function",
+      parameters: [
+        { name: "mass", type: "number" },
+        { name: "config", type: "object" }
+      ],
+      returnType: "object"
+    }
+  ],
+  [
+    "createMaterial",
+    {
+      type: "function",
+      parameters: [
+        { name: "name", type: "string" },
+        { name: "preset", type: "string" }
+      ],
+      returnType: "object"
+    }
+  ],
+  [
+    "createParticleSystem",
+    { type: "function", parameters: [{ name: "config", type: "object" }], returnType: "object" }
+  ],
+  [
+    "applyForce",
+    {
+      type: "function",
+      parameters: [
+        { name: "target", type: "orb" },
+        { name: "force", type: "vec3" }
+      ],
+      returnType: "void"
+    }
+  ],
+  [
+    "raycast",
+    {
+      type: "function",
+      parameters: [
+        { name: "origin", type: "vec3" },
+        { name: "direction", type: "vec3" },
+        { name: "maxDistance", type: "number" }
+      ],
+      returnType: "object"
+    }
+  ],
+  [
+    "playAudio",
+    {
+      type: "function",
+      parameters: [
+        { name: "clip", type: "string" },
+        { name: "config", type: "object" }
+      ],
+      returnType: "void"
+    }
+  ],
+  [
+    "setWeather",
+    { type: "function", parameters: [{ name: "preset", type: "string" }], returnType: "void" }
+  ],
+  [
+    "generateTerrain",
+    { type: "function", parameters: [{ name: "config", type: "object" }], returnType: "object" }
+  ],
+  [
+    "navigate",
+    {
+      type: "function",
+      parameters: [
+        { name: "agent", type: "orb" },
+        { name: "target", type: "vec3" }
+      ],
+      returnType: "void"
+    }
+  ],
+  [
+    "distance",
+    {
+      type: "function",
+      parameters: [
+        { name: "a", type: "vec3" },
+        { name: "b", type: "vec3" }
+      ],
+      returnType: "number"
+    }
+  ]
+]);
+var HoloScriptTypeChecker = class {
+  constructor() {
+    this.typeMap = /* @__PURE__ */ new Map();
+    this.diagnostics = [];
+    this.currentLine = 0;
+    this.currentColumn = 0;
+    /** Registry for user-defined union types (e.g., type State = "idle" | "loading" | "error") */
+    this.unionTypes = /* @__PURE__ */ new Map();
+    /** Type alias registry (type Color = string | number[], type List<T> = T[]) */
+    this.typeAliasRegistry = new TypeAliasRegistry();
+    /** Custom constraints merged from holoscript.config.json */
+    this.customConstraints = [];
+    /** Diagnostics accumulated before check() so they survive the diagnostics reset */
+    this.preCheckDiagnostics = [];
+    BUILTIN_FUNCTIONS.forEach((type, name) => {
+      this.typeMap.set(name, type);
+    });
+    this.exhaustivenessChecker = new ExhaustivenessChecker();
+  }
+  /**
+   * Merge custom constraints from a parsed config object.
+   * Call before check() when you have a holoscript.config.json.
+   */
+  loadConfig(config) {
+    this.customConstraints = chunkC37BHB7N_cjs.loadConstraintsFromConfig(config);
+  }
+  /**
+   * Register a type alias (e.g. from a `type Foo = ...` declaration in source).
+   */
+  registerTypeAlias(decl) {
+    this.typeAliasRegistry.register(decl);
+    if (this.typeAliasRegistry.isRecursive(decl.name)) {
+      this.preCheckDiagnostics.push({
+        severity: "error",
+        message: `Type alias '${decl.name}' is recursive and cannot be expanded.`,
+        line: decl.line ?? 0,
+        column: 0,
+        code: "HSP020",
+        suggestions: [`Remove the self-reference in '${decl.name}' definition.`]
+      });
+    }
+  }
+  /**
+   * Type check an AST
+   */
+  check(ast) {
+    this.diagnostics = [...this.preCheckDiagnostics];
+    for (const node of ast) {
+      this.collectDeclaration(node);
+    }
+    this.checkBlock(ast);
+    return {
+      valid: this.diagnostics.filter((d) => d.severity === "error").length === 0,
+      diagnostics: this.diagnostics,
+      typeMap: new Map(this.typeMap)
+    };
+  }
+  /**
+   * Collect type declarations
+   */
+  collectDeclaration(node) {
+    switch (node.type) {
+      case "orb":
+        this.collectOrbDeclaration(node);
+        break;
+      case "method":
+        this.collectMethodDeclaration(node);
+        break;
+      case "variable-declaration":
+        this.collectVariableDeclaration(node);
+        break;
+      case "stream":
+        this.collectStreamDeclaration(node);
+        break;
+      case "template":
+        this.collectTemplateDeclaration(node);
+        break;
+    }
+  }
+  collectTemplateDeclaration(node) {
+    this.typeMap.set(node.name, {
+      type: "object"
+      // We could try to infer properties from body if structure allows,
+      // but for now simple registration is enough to pass "Unknown variable" checks
+    });
+  }
+  collectOrbDeclaration(node) {
+    const properties = /* @__PURE__ */ new Map();
+    properties.set("position", { type: "vec3" });
+    properties.set("rotation", { type: "euler" });
+    properties.set("scale", { type: "vec3" });
+    properties.set("color", { type: "color" });
+    properties.set("glow", { type: "boolean" });
+    properties.set("interactive", { type: "boolean" });
+    properties.set("visible", { type: "boolean" });
+    for (const [key, value] of Object.entries(node.properties)) {
+      const expectedType = properties.get(key);
+      properties.set(key, this.inferTypeWithContext(value, expectedType));
+    }
+    this.typeMap.set(node.name, {
+      type: "orb",
+      properties
+    });
+  }
+  collectMethodDeclaration(node) {
+    const parameters = node.parameters.map((p) => ({
+      name: p.name,
+      type: this.parseTypeString(p.dataType),
+      optional: p.defaultValue !== void 0,
+      defaultValue: p.defaultValue
+    }));
+    this.typeMap.set(node.name, {
+      type: "function",
+      parameters,
+      returnType: node.returnType ? this.parseTypeString(node.returnType) : "void"
+    });
+  }
+  collectVariableDeclaration(node) {
+    let typeInfo = { type: "any" };
+    if (node.dataType) {
+      typeInfo = { type: this.parseTypeString(node.dataType) };
+      if (node.value !== void 0) {
+        this.inferTypeWithContext(node.value, typeInfo);
+      }
+    } else if (node.value !== void 0) {
+      typeInfo = this.inferType(node.value);
+    }
+    this.typeMap.set(node.name, typeInfo);
+  }
+  collectStreamDeclaration(node) {
+    this.typeMap.set(node.name, {
+      type: "stream",
+      properties: /* @__PURE__ */ new Map([
+        ["source", { type: "string" }],
+        ["result", { type: "any" }]
+      ])
+    });
+  }
+  /**
+   * Check a node for type errors
+   */
+  checkNode(node) {
+    this.currentLine = node.position?.[0] ?? 0;
+    this.currentColumn = node.position?.[1] ?? 0;
+    switch (node.type) {
+      case "connection":
+        this.checkConnection(node);
+        break;
+      case "gate":
+        this.checkGate(node);
+        break;
+      case "for-loop":
+        this.checkForLoop(node);
+        break;
+      case "while-loop":
+        this.checkWhileLoop(node);
+        break;
+      case "foreach-loop":
+        this.checkForEachLoop(node);
+        break;
+      case "import":
+        this.checkImport(node);
+        break;
+      case "export":
+        this.checkExport(node);
+        break;
+      case "type-guard":
+        this.checkTypeGuard(node);
+        break;
+      case "variable-declaration":
+        this.checkVariableDeclaration(node);
+        break;
+      case "method":
+        this.checkBlock(node.body);
+        break;
+      case "orb":
+        this.validateTraitConstraints(node);
+        this.checkBlock(node.children || []);
+        break;
+      case "template":
+        this.validateTraitConstraints(node);
+        this.checkBlock(node.children || []);
+        break;
+      case "spread":
+        this.checkSpread(node);
+        break;
+      case "nullCoalescingAssignment":
+        this.checkNullCoalescingAssignment(node);
+        break;
+      case "match":
+        this.checkMatchExpression(node);
+        break;
+    }
+  }
+  checkNullCoalescingAssignment(node) {
+    if (!node.target) {
+      this.addDiagnostic("error", `Null coalescing assignment missing target`, "E104");
+      return;
+    }
+    const targetStr = typeof node.target === "string" ? node.target : node.target?.__ref || node.target?.name;
+    if (!targetStr) {
+      this.addDiagnostic(
+        "error",
+        `Null coalescing assignment to non-assignable expression`,
+        "E105"
+      );
+      return;
+    }
+    const targetType = this.typeMap.get(targetStr);
+    const valueType = node.value ? this.inferType(node.value) : "unknown";
+    this.typeMap.set(
+      targetStr,
+      targetType || { type: valueType, nullable: false }
+    );
+  }
+  checkSpread(node) {
+    if (!node.target) {
+      this.addDiagnostic("error", `Spread expression missing target`, "E102");
+      return;
+    }
+    if (!this.typeMap.has(node.target)) {
+      this.addDiagnostic("error", `Unknown template or object '${node.target}' in spread`, "E102");
+    } else {
+      const type = this.typeMap.get(node.target);
+      if (type && type.type !== "object" && type.type !== "orb" && type.type !== "any") {
+        this.addDiagnostic(
+          "error",
+          `Cannot spread '${node.target}' type '${type.type}', must be object or template`,
+          "E103"
+        );
+      }
+    }
+  }
+  /**
+   * Check a match expression for:
+   * 1. Valid subject expression
+   * 2. Exhaustiveness - all union cases are covered
+   * 3. Unreachable patterns (after wildcard)
+   * 4. Type consistency in case bodies
+   */
+  checkMatchExpression(node) {
+    if (!node.subject) {
+      this.addDiagnostic("error", "Match expression missing subject", "E200");
+      return;
+    }
+    if (!node.cases || node.cases.length === 0) {
+      this.addDiagnostic("error", "Match expression has no cases", "E201");
+      return;
+    }
+    const subjectId = typeof node.subject === "string" ? node.subject : node.subject?.__ref || node.subject?.name;
+    let unionType;
+    if (subjectId && this.unionTypes.has(subjectId)) {
+      unionType = this.unionTypes.get(subjectId);
+    }
+    const casePatterns = [];
+    let hasWildcard = false;
+    let wildcardIndex = -1;
+    for (let i = 0; i < node.cases.length; i++) {
+      const matchCase = node.cases[i];
+      const pattern = matchCase.pattern;
+      if (!pattern) {
+        this.addDiagnostic("error", `Match case ${i + 1} has no pattern`, "E202");
+        continue;
+      }
+      if (pattern.type === "wildcard-pattern") {
+        if (hasWildcard) {
+          this.addDiagnostic(
+            "warning",
+            `Duplicate wildcard pattern at case ${i + 1} - only the first wildcard will be reached`,
+            "W200"
+          );
+        } else {
+          hasWildcard = true;
+          wildcardIndex = i;
+        }
+        casePatterns.push("_");
+      } else if (pattern.type === "literal-pattern") {
+        const value = String(pattern.value);
+        if (casePatterns.includes(value)) {
+          this.addDiagnostic(
+            "warning",
+            `Duplicate pattern "${value}" at case ${i + 1} - this case will never be reached`,
+            "W201"
+          );
+        }
+        casePatterns.push(value);
+      } else if (pattern.type === "binding-pattern") {
+        casePatterns.push(pattern.name);
+      }
+      if (hasWildcard && i > wildcardIndex) {
+        this.addDiagnostic(
+          "warning",
+          `Unreachable pattern at case ${i + 1} - previous wildcard (_) matches all remaining cases`,
+          "W202",
+          ["Remove this case or reorder patterns"]
+        );
+      }
+      if (Array.isArray(matchCase.body)) {
+        this.checkBlock(matchCase.body);
+      }
+    }
+    if (unionType) {
+      const result = this.exhaustivenessChecker.checkMatch(unionType, casePatterns);
+      if (!result.isExhaustive && !hasWildcard) {
+        const missingCases = result.uncoveredCases.map((c) => `"${c}"`).join(", ");
+        this.addDiagnostic(
+          "error",
+          `Non-exhaustive match. Missing cases: ${missingCases}`,
+          "E203",
+          result.uncoveredCases.map((c) => `Add case: "${c}" => ...`)
+        );
+      }
+    } else if (!hasWildcard && subjectId) {
+      this.addDiagnostic(
+        "info",
+        `Match expression on '${subjectId}' may be non-exhaustive. Consider adding a wildcard (_) case.`,
+        "I200"
+      );
+    }
+  }
+  /**
+   * Register a union type for exhaustiveness checking
+   * Example: type State = "idle" | "loading" | "success" | "error"
+   */
+  registerUnionType(name, members) {
+    const unionMembers = members.map((m) => ({
+      kind: "literal",
+      value: m
+    }));
+    this.unionTypes.set(name, {
+      kind: "union",
+      members: unionMembers
+    });
+  }
+  /**
+   * Get the union type for a registered name
+   */
+  getUnionType(name) {
+    return this.unionTypes.get(name);
+  }
+  /**
+   * Check if a match expression is exhaustive given the union type.
+   * Returns HSP021 diagnostics for missing cases.
+   */
+  checkExhaustiveMatch(matchExpr) {
+    const decl = this.typeAliasRegistry.get(matchExpr.typeName);
+    if (!decl) return [];
+    if (decl.kind !== "union" && decl.kind !== "simple") return [];
+    if (matchExpr.coveredPatterns.includes("_")) return [];
+    const members = this.extractUnionMembers(decl.definition);
+    if (members.length === 0) return [];
+    const coveredSet = new Set(matchExpr.coveredPatterns);
+    const missing = members.filter((m) => !coveredSet.has(m));
+    if (missing.length === 0) return [];
+    const missingStr = missing.map((m) => '"' + m + '"').join(", ");
+    return [
+      {
+        code: "HSP021",
+        message: "Non-exhaustive match on '" + matchExpr.typeName + "'. Missing: " + missingStr,
+        severity: "error",
+        line: matchExpr.line ?? 0,
+        column: matchExpr.column ?? 0,
+        suggestions: missing.map((m) => "Add case: " + m + " => ...")
+      }
+    ];
+  }
+  /**
+   * Extract individual members from a union type definition string.
+   * Handles string literals, number literals, and identifiers.
+   */
+  extractUnionMembers(definition) {
+    const parts = definition.split("|").map((p) => p.trim()).filter(Boolean);
+    const members = [];
+    for (const part of parts) {
+      const strMatch = part.match(/^["'](.+?)["']$/);
+      if (strMatch) {
+        members.push(strMatch[1]);
+        continue;
+      }
+      if (/^-?\d+(\.\d+)?$/.test(part)) {
+        members.push(part);
+        continue;
+      }
+    }
+    return members;
+  }
+  checkBlock(nodes) {
+    if (!nodes) return;
+    for (const node of nodes) {
+      this.checkNode(node);
+      if (node.type === "expression-statement" && typeof node.expression === "string") {
+        const varName = node.expression;
+        const typeInfo = this.typeMap.get(varName);
+        if (typeInfo) {
+          this.addDiagnostic("info", `Type of '${varName}' is ${typeInfo.type}`, "DEBUG");
+        }
+      }
+    }
+  }
+  /**
+   * Check if two types are compatible
+   */
+  isCompatible(source, target) {
+    if (source.type === "any" || target.type === "any") return true;
+    if (source.type === target.type) return true;
+    if (target.type === "vec3" && source.type === "euler") return true;
+    if (target.type === "euler" && source.type === "vec3") return true;
+    if (target.type === "vec4" && source.type === "quat") return true;
+    if (target.type === "quat" && source.type === "vec4") return true;
+    return false;
+  }
+  checkConnection(node) {
+    const fromType = this.typeMap.get(node.from);
+    const toType = this.typeMap.get(node.to);
+    if (!fromType) {
+      this.addDiagnostic("error", `Unknown source '${node.from}' in connection`, "E001");
+    }
+    if (!toType) {
+      this.addDiagnostic("error", `Unknown target '${node.to}' in connection`, "E002");
+    }
+    if (fromType && toType && node.dataType !== "any") {
+      if (!this.isCompatible(fromType, toType)) {
+        this.addDiagnostic(
+          "warning",
+          `Connection from '${node.from}' (${fromType.type}) to '${node.to}' (${toType.type}) may be incompatible`,
+          "W001",
+          [`Consider using 'as "any"' to bypass type checking`]
+        );
+      }
+    }
+  }
+  checkGate(node) {
+    let narrowedVar;
+    let narrowedType;
+    if (typeof node.condition === "string") {
+      const conditionVars = this.extractVariables(node.condition);
+      for (const varName of conditionVars) {
+        if (!this.typeMap.has(varName) && !this.isLiteral(varName)) {
+          this.addDiagnostic("error", `Unknown variable '${varName}' in gate condition`, "E003");
+        }
+      }
+    } else if (node.condition.type === "type-guard") {
+      narrowedVar = node.condition.subject;
+      narrowedType = { type: this.parseTypeString(node.condition.guardType) };
+      this.checkTypeGuard(node.condition);
+    }
+    if (narrowedVar && narrowedType) {
+      const originalType = this.typeMap.get(narrowedVar);
+      this.typeMap.set(narrowedVar, narrowedType);
+      this.addDiagnostic("info", `Type of '${narrowedVar}' is ${narrowedType.type}`, "DEBUG");
+      this.checkBlock(node.truePath);
+      if (originalType) this.typeMap.set(narrowedVar, originalType);
+      else this.typeMap.delete(narrowedVar);
+    } else {
+      this.checkBlock(node.truePath);
+    }
+    if (node.falsePath && node.falsePath.length > 0) {
+      this.checkBlock(node.falsePath);
+    }
+  }
+  checkTypeGuard(node) {
+    if (!this.typeMap.has(node.subject)) {
+      this.addDiagnostic("error", `Unknown variable '${node.subject}' in type guard`, "E101");
+    }
+  }
+  checkVariableDeclaration(node) {
+    const typeInfo = this.typeMap.get(node.name);
+    if (typeInfo && node.value !== void 0 && !node.isExpression) {
+      const inferredValueType = this.inferTypeWithContext(node.value, typeInfo);
+      if (!this.isCompatible(inferredValueType, typeInfo)) {
+        this.addDiagnostic(
+          "error",
+          `Type mismatch: cannot assign ${inferredValueType.type} to ${typeInfo.type}`,
+          "E102"
+        );
+      }
+    }
+    if (node.isExpression && typeof node.value === "string") {
+      const vars = this.extractVariables(node.value);
+      for (const v of vars) {
+        if (!this.typeMap.has(v) && !this.isLiteral(v) && !BUILTIN_FUNCTIONS.has(v)) {
+          this.addDiagnostic(
+            "warning",
+            `Reference to potentially undeclared variable '${v}'`,
+            "W101"
+          );
+        }
+      }
+    }
+  }
+  checkForLoop(node) {
+    const initVars = this.extractVariables(node.init);
+    for (const varName of initVars) {
+      if (!this.typeMap.has(varName)) {
+        this.typeMap.set(varName, { type: "number" });
+      }
+    }
+    if (typeof node.condition === "string") {
+      const condVars = this.extractVariables(node.condition);
+      for (const varName of condVars) {
+        if (!this.typeMap.has(varName) && !this.isLiteral(varName)) {
+          this.addDiagnostic(
+            "error",
+            `Unknown variable '${varName}' in for loop condition`,
+            "E004"
+          );
+        }
+      }
+    } else {
+      this.checkTypeGuard(node.condition);
+    }
+    this.checkBlock(node.body);
+  }
+  checkWhileLoop(node) {
+    if (typeof node.condition === "string") {
+      const condVars = this.extractVariables(node.condition);
+      for (const varName of condVars) {
+        if (!this.typeMap.has(varName) && !this.isLiteral(varName)) {
+          this.addDiagnostic(
+            "error",
+            `Unknown variable '${varName}' in while loop condition`,
+            "E005"
+          );
+        }
+      }
+    } else {
+      this.checkTypeGuard(node.condition);
+    }
+    this.checkBlock(node.body);
+  }
+  checkForEachLoop(node) {
+    if (!this.typeMap.has(node.collection)) {
+      this.addDiagnostic(
+        "error",
+        `Unknown collection '${node.collection}' in forEach loop`,
+        "E006"
+      );
+    } else {
+      const collectionType2 = this.typeMap.get(node.collection);
+      if (collectionType2 && collectionType2.type !== "array" && collectionType2.type !== "any") {
+        this.addDiagnostic(
+          "error",
+          `'${node.collection}' is not iterable (type: ${collectionType2.type})`,
+          "E007"
+        );
+      }
+    }
+    const collectionType = this.typeMap.get(node.collection);
+    const itemType = collectionType?.type === "array" && collectionType.elementType ? collectionType.elementType : "any";
+    const originalType = this.typeMap.get(node.variable);
+    this.typeMap.set(node.variable, { type: itemType });
+    this.checkBlock(node.body);
+    if (originalType) this.typeMap.set(node.variable, originalType);
+    else this.typeMap.delete(node.variable);
+  }
+  checkImport(node) {
+    if (!node.modulePath) {
+      this.addDiagnostic("error", "Import statement missing module path", "E008");
+    }
+    for (const name of node.imports) {
+      this.typeMap.set(name, { type: "any" });
+    }
+    if (node.defaultImport) {
+      this.typeMap.set(node.defaultImport, { type: "any" });
+    }
+  }
+  checkExport(node) {
+    if (node.exports) {
+      for (const name of node.exports) {
+        if (!this.typeMap.has(name)) {
+          this.addDiagnostic("error", `Cannot export unknown identifier '${name}'`, "E009");
+        }
+      }
+    }
+  }
+  /**
+   * Infer type from a value
+   */
+  inferType(value) {
+    if (value === null || value === void 0) {
+      return { type: "any", nullable: true };
+    }
+    if (typeof value === "function") {
+      const fn = value;
+      return {
+        type: "function",
+        parameters: Array.from({ length: fn.length }, (_, i) => ({
+          name: `arg${i}`,
+          type: "any"
+        })),
+        returnType: "void"
+      };
+    }
+    if (typeof value === "number") {
+      return { type: "number" };
+    }
+    if (typeof value === "string") {
+      if (/^\(.*\)\s*=>/.test(value) || /^\w+\s*=>/.test(value)) {
+        const arrowMatch = value.match(/=>\s*(.+)$/s);
+        let returnType = "void";
+        if (arrowMatch) {
+          const body = arrowMatch[1].trim();
+          if (/^["']/.test(body)) returnType = "string";
+          else if (/^-?\d/.test(body)) returnType = "number";
+          else if (body === "true" || body === "false") returnType = "boolean";
+          else if (/^\[/.test(body)) returnType = "array";
+          else if (/^\{/.test(body) && !body.startsWith("{\n")) returnType = "object";
+          else if (body !== "" && !body.startsWith("{")) returnType = "any";
+        }
+        return { type: "function", parameters: [], returnType };
+      }
+      if (/^#([A-Fa-f0-9]{3}){1,2}$/.test(value)) return { type: "color" };
+      if (/^rgba?\s*\(/.test(value)) return { type: "color" };
+      return { type: "string" };
+    }
+    if (typeof value === "boolean") {
+      return { type: "boolean" };
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 2 && value.every((v) => typeof v === "number")) return { type: "vec2" };
+      if (value.length === 3 && value.every((v) => typeof v === "number")) return { type: "vec3" };
+      if (value.length === 4 && value.every((v) => typeof v === "number")) return { type: "vec4" };
+      const elementType = value.length > 0 ? this.inferType(value[0]).type : "any";
+      return { type: "array", elementType };
+    }
+    if (typeof value === "object") {
+      if ("x" in value && "y" in value) {
+        if ("z" in value) return { type: "vec3" };
+        return { type: "vec2" };
+      }
+      const properties = /* @__PURE__ */ new Map();
+      for (const [key, val] of Object.entries(value)) {
+        properties.set(key, this.inferType(val));
+      }
+      return { type: "object", properties };
+    }
+    return { type: "any" };
+  }
+  /**
+   * Infer type with context
+   */
+  inferTypeWithContext(value, expectedType) {
+    if (!expectedType) return this.inferType(value);
+    const baseInferred = this.inferType(value);
+    if (expectedType.type === "color" && typeof value === "string") {
+      return { type: "color" };
+    }
+    if (expectedType.type === "euler" && Array.isArray(value) && value.length === 3) {
+      return { type: "euler" };
+    }
+    if (expectedType.type === "quat" && Array.isArray(value) && value.length === 4) {
+      return { type: "quat" };
+    }
+    if (expectedType.type === "vec3" && Array.isArray(value) && value.length === 3) {
+      return { type: "vec3" };
+    }
+    return baseInferred;
+  }
+  /**
+   * Parse type string to HoloScriptType
+   */
+  parseTypeString(typeStr) {
+    const normalized = typeStr.toLowerCase().trim();
+    const validTypes = [
+      "number",
+      "string",
+      "boolean",
+      "array",
+      "object",
+      "function",
+      "void",
+      "any",
+      "unknown",
+      "never",
+      "orb",
+      "stream",
+      "connection",
+      "gate",
+      "vec2",
+      "vec3",
+      "vec4",
+      "color",
+      "euler",
+      "quat",
+      "mat4"
+    ];
+    if (validTypes.includes(normalized)) {
+      return normalized;
+    }
+    return "any";
+  }
+  /**
+   * Extract variable names from an expression string
+   */
+  extractVariables(expr) {
+    const varPattern = /\b([a-zA-Z_][a-zA-Z0-9_]*)\b/g;
+    const matches = expr.match(varPattern) || [];
+    const keywords = ["true", "false", "null", "undefined", "if", "else", "for", "while", "return"];
+    return matches.filter((m) => !keywords.includes(m));
+  }
+  /**
+   * Check if string is a literal
+   */
+  isLiteral(str) {
+    if (/^-?\d+(\.\d+)?$/.test(str)) return true;
+    if (str === "true" || str === "false") return true;
+    if (/^["'].*["']$/.test(str)) return true;
+    return false;
+  }
+  validateTraitConstraints(node) {
+    const traitsMap = node.traits;
+    if (!traitsMap || traitsMap.size === 0) {
+      return;
+    }
+    const traitNames = Array.from(traitsMap.keys());
+    const allConstraints = [...chunkC37BHB7N_cjs.BUILTIN_CONSTRAINTS, ...this.customConstraints];
+    for (const constraint of allConstraints) {
+      if (constraint.type === "requires") {
+        if (traitNames.includes(constraint.source)) {
+          for (const target of constraint.targets) {
+            if (!traitNames.includes(target)) {
+              const suggestions = constraint.suggestion ? [constraint.suggestion] : [`Add @${target} to the same orb as @${constraint.source}.`];
+              this.addDiagnostic(
+                "error",
+                constraint.message || `Trait @${constraint.source} requires @${target}.`,
+                "HSP014",
+                suggestions
+              );
+            }
+          }
+        }
+      } else if (constraint.type === "conflicts") {
+        if (traitNames.includes(constraint.source)) {
+          for (const target of constraint.targets) {
+            if (traitNames.includes(target)) {
+              const suggestions = constraint.suggestion ? [constraint.suggestion] : [`Remove either @${constraint.source} or @${target} from the orb.`];
+              this.addDiagnostic(
+                "error",
+                constraint.message || `Trait @${constraint.source} conflicts with @${target}.`,
+                "HSP014",
+                suggestions
+              );
+            }
+          }
+        }
+      } else if (constraint.type === "oneof") {
+        const matches = traitNames.filter((t) => constraint.targets.includes(t));
+        if (matches.length > 1) {
+          const suggestions = constraint.suggestion ? [constraint.suggestion] : [`Keep only one of: ${matches.map((t) => "@" + t).join(", ")}. Remove the others.`];
+          this.addDiagnostic(
+            "error",
+            constraint.message || `Only one of the following traits can be used at a time: ${constraint.targets.map((t) => "@" + t).join(", ")}.`,
+            "HSP014",
+            suggestions
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Add a diagnostic
+   */
+  addDiagnostic(severity, message, code, suggestions) {
+    this.diagnostics.push({
+      severity,
+      message,
+      line: this.currentLine,
+      column: this.currentColumn,
+      code,
+      suggestions
+    });
+  }
+  /**
+   * Get type info for a name
+   */
+  getType(name) {
+    return this.typeMap.get(name);
+  }
+  /**
+   * Get all registered types
+   */
+  getAllTypes() {
+    return new Map(this.typeMap);
+  }
+  /**
+   * Reset the type checker
+   */
+  reset() {
+    this.typeMap.clear();
+    this.diagnostics = [];
+    this.unionTypes.clear();
+    BUILTIN_FUNCTIONS.forEach((type, name) => {
+      this.typeMap.set(name, type);
+    });
+  }
+  /**
+   * Get all registered union types
+   */
+  getAllUnionTypes() {
+    return new Map(this.unionTypes);
+  }
+  /**
+   * Sprint 5 — String-based type inference.
+   *
+   * Infers a simplified HoloScript type name from an expression string.
+   * This is a lightweight syntactic analysis that does NOT require the AST:
+   *
+   * | Expression                | Inferred type |
+   * |---------------------------|---------------|
+   * | `[0, 1, 0]`               | `'vec3'`      |
+   * | `[0, 1]`                  | `'vec2'`      |
+   * | `3.14`                    | `'float'`     |
+   * | `42`, `0`                 | `'int'`       |
+   * | `true` / `false`          | `'bool'`      |
+   * | `"hello"` / `'world'`     | `'string'`    |
+   * | anything else             | `'any'`       |
+   *
+   * @param expr  Raw expression string (trimmed)
+   */
+  inferTypeExpression(expr) {
+    const s = expr.trim();
+    if (!s) return "any";
+    if (s === "true" || s === "false") return "bool";
+    if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'"))
+      return "string";
+    if (/^-?\d+$/.test(s)) return "int";
+    if (/^-?\d+\.\d+$/.test(s)) return "float";
+    if (s.startsWith("[") && s.endsWith("]")) {
+      const inner = s.slice(1, -1).trim();
+      if (!inner) return "any";
+      const parts = inner.split(",").map((p) => p.trim());
+      const allNumeric = parts.every((p) => /^-?\d+(\.\d+)?$/.test(p));
+      if (allNumeric) {
+        if (parts.length === 2) return "vec2";
+        if (parts.length === 3) return "vec3";
+      }
+    }
+    return "any";
+  }
+};
+function createTypeChecker() {
+  return new HoloScriptTypeChecker();
+}
+
+exports.HoloScriptTypeChecker = HoloScriptTypeChecker;
+exports.createTypeChecker = createTypeChecker;
+//# sourceMappingURL=chunk-W6RW64BB.cjs.map
+//# sourceMappingURL=chunk-W6RW64BB.cjs.map