@holoscript/core 6.0.3 → 7.0.0

package/dist/chunk-4SMUJFHL.js

@@ -1,1213 +0,0 @@
-import { loadConstraintsFromConfig, BUILTIN_CONSTRAINTS } from './chunk-BKIGPPVM.js';
-
-// 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 = 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?.x ?? 0;
-    this.currentColumn = node.position?.y ?? 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 = [...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();
-}
-
-export { HoloScriptTypeChecker, createTypeChecker };
-//# sourceMappingURL=chunk-4SMUJFHL.js.map
-//# sourceMappingURL=chunk-4SMUJFHL.js.map