@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-EKYL4PE3.cjs

@@ -0,0 +1,404 @@
+'use strict';
+
+// src/traits/SkeletonTrait.ts
+var SkeletonTrait = class {
+  constructor(config = {}) {
+    this.bones = /* @__PURE__ */ new Map();
+    this.boneTransforms = /* @__PURE__ */ new Map();
+    this.clips = /* @__PURE__ */ new Map();
+    this.parameters = /* @__PURE__ */ new Map();
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.enabled = true;
+    this.config = {
+      rigType: config.rigType ?? "custom",
+      bones: config.bones,
+      humanoidMap: config.humanoidMap,
+      clips: config.clips,
+      blendTrees: config.blendTrees ?? /* @__PURE__ */ new Map(),
+      layers: config.layers ?? [{ name: "base", weight: 1, blendMode: "override" }],
+      parameters: config.parameters ?? /* @__PURE__ */ new Map(),
+      defaultClip: config.defaultClip,
+      speed: config.speed ?? 1,
+      rootMotion: config.rootMotion ?? false,
+      cullingMode: config.cullingMode ?? "always"
+    };
+    this.state = {
+      currentTime: 0,
+      normalizedTime: 0,
+      isPlaying: false,
+      layerWeights: this.config.layers?.map((l) => l.weight) ?? [1]
+    };
+    if (config.bones) {
+      for (const bone of config.bones) {
+        this.bones.set(bone.name, bone);
+        this.boneTransforms.set(bone.name, { ...bone.bindPose });
+      }
+    }
+    if (config.clips) {
+      for (const clip of config.clips) {
+        this.clips.set(clip.name, clip);
+      }
+    }
+    if (config.parameters) {
+      this.parameters = new Map(config.parameters);
+    }
+  }
+  // ============================================================================
+  // Configuration
+  // ============================================================================
+  /**
+   * Get configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get animation state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Get bone count
+   */
+  getBoneCount() {
+    return this.bones.size;
+  }
+  /**
+   * Get bone names
+   */
+  getBoneNames() {
+    return Array.from(this.bones.keys());
+  }
+  /**
+   * Get bone transform
+   */
+  getBoneTransform(boneName) {
+    return this.boneTransforms.get(boneName);
+  }
+  /**
+   * Set bone transform (for IK or procedural animation)
+   */
+  setBoneTransform(boneName, transform) {
+    const current = this.boneTransforms.get(boneName);
+    if (current) {
+      this.boneTransforms.set(boneName, {
+        position: transform.position ?? current.position,
+        rotation: transform.rotation ?? current.rotation,
+        scale: transform.scale ?? current.scale
+      });
+    }
+  }
+  // ============================================================================
+  // Animation Playback
+  // ============================================================================
+  /**
+   * Play animation clip
+   */
+  play(clipName, options) {
+    const clip = this.clips.get(clipName);
+    if (!clip) {
+      console.warn(`Animation clip not found: ${clipName}`);
+      return;
+    }
+    const crossfade = options?.crossfade ?? 0;
+    if (crossfade > 0 && this.state.currentClip) {
+      this.state.crossfadeTarget = clipName;
+      this.state.crossfadeProgress = 0;
+    } else {
+      this.state.currentClip = clipName;
+      this.state.currentTime = 0;
+      this.state.normalizedTime = 0;
+    }
+    this.state.isPlaying = true;
+  }
+  /**
+   * Stop animation
+   */
+  stop() {
+    this.state.isPlaying = false;
+    this.state.currentTime = 0;
+    this.state.normalizedTime = 0;
+  }
+  /**
+   * Pause animation
+   */
+  pause() {
+    this.state.isPlaying = false;
+  }
+  /**
+   * Resume animation
+   */
+  resume() {
+    this.state.isPlaying = true;
+  }
+  /**
+   * Is playing
+   */
+  isPlaying() {
+    return this.state.isPlaying;
+  }
+  /**
+   * Get current clip name
+   */
+  getCurrentClip() {
+    return this.state.currentClip;
+  }
+  /**
+   * Set playback speed
+   */
+  setSpeed(speed) {
+    this.config.speed = speed;
+  }
+  /**
+   * Get playback speed
+   */
+  getSpeed() {
+    return this.config.speed ?? 1;
+  }
+  // ============================================================================
+  // Parameters (for blend trees and state machines)
+  // ============================================================================
+  /**
+   * Set parameter
+   */
+  setParameter(name, value) {
+    this.parameters.set(name, value);
+  }
+  /**
+   * Get parameter
+   */
+  getParameter(name) {
+    return this.parameters.get(name);
+  }
+  /**
+   * Set float parameter
+   */
+  setFloat(name, value) {
+    this.parameters.set(name, value);
+  }
+  /**
+   * Set bool parameter
+   */
+  setBool(name, value) {
+    this.parameters.set(name, value);
+  }
+  /**
+   * Set trigger (auto-resets)
+   */
+  setTrigger(name) {
+    this.parameters.set(name, true);
+  }
+  // ============================================================================
+  // Blend Trees
+  // ============================================================================
+  /**
+   * Add blend tree
+   */
+  addBlendTree(name, tree) {
+    if (!this.config.blendTrees) {
+      this.config.blendTrees = /* @__PURE__ */ new Map();
+    }
+    this.config.blendTrees.set(name, tree);
+  }
+  /**
+   * Activate blend tree
+   */
+  activateBlendTree(name) {
+    if (this.config.blendTrees?.has(name)) {
+      this.state.activeBlendTree = name;
+    }
+  }
+  // ============================================================================
+  // Layers
+  // ============================================================================
+  /**
+   * Set layer weight
+   */
+  setLayerWeight(layerIndex, weight) {
+    if (this.state.layerWeights[layerIndex] !== void 0) {
+      this.state.layerWeights[layerIndex] = Math.max(0, Math.min(1, weight));
+    }
+  }
+  /**
+   * Get layer weight
+   */
+  getLayerWeight(layerIndex) {
+    return this.state.layerWeights[layerIndex] ?? 0;
+  }
+  // ============================================================================
+  // Clips
+  // ============================================================================
+  /**
+   * Add animation clip
+   */
+  addClip(clip) {
+    this.clips.set(clip.name, clip);
+    if (!this.config.clips) {
+      this.config.clips = [];
+    }
+    this.config.clips.push(clip);
+  }
+  /**
+   * Get clip
+   */
+  getClip(name) {
+    return this.clips.get(name);
+  }
+  /**
+   * Get clip duration
+   */
+  getClipDuration(name) {
+    return this.clips.get(name)?.duration ?? 0;
+  }
+  /**
+   * Get all clip names
+   */
+  getClipNames() {
+    return Array.from(this.clips.keys());
+  }
+  // ============================================================================
+  // Update (called each frame)
+  // ============================================================================
+  /**
+   * Update animation (called by animation system each frame)
+   */
+  update(deltaTime) {
+    if (!this.enabled || !this.state.isPlaying) return;
+    const clip = this.state.currentClip ? this.clips.get(this.state.currentClip) : void 0;
+    if (!clip) return;
+    const speed = this.config.speed ?? 1;
+    this.state.currentTime += deltaTime * speed;
+    if (clip.loop) {
+      this.state.currentTime = this.state.currentTime % clip.duration;
+    } else if (this.state.currentTime >= clip.duration) {
+      this.state.currentTime = clip.duration;
+      this.state.isPlaying = false;
+    }
+    this.state.normalizedTime = clip.duration > 0 ? this.state.currentTime / clip.duration : 0;
+    if (clip.events) {
+      for (const event of clip.events) {
+        if (Math.abs(this.state.currentTime - event.time) < deltaTime) {
+          this.emitEvent(event);
+        }
+      }
+    }
+    if (this.state.crossfadeTarget && this.state.crossfadeProgress !== void 0) {
+      this.state.crossfadeProgress += deltaTime;
+    }
+  }
+  // ============================================================================
+  // Events
+  // ============================================================================
+  /**
+   * Add event listener
+   */
+  on(event, callback) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, []);
+    }
+    this.eventListeners.get(event).push(callback);
+  }
+  /**
+   * Remove event listener
+   */
+  off(event, callback) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      const index = listeners.indexOf(callback);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+    }
+  }
+  /**
+   * Emit animation event
+   */
+  emitEvent(event) {
+    const listeners = this.eventListeners.get(event.name);
+    if (listeners) {
+      for (const callback of listeners) {
+        callback(event);
+      }
+    }
+  }
+  // ============================================================================
+  // Enable/Disable
+  // ============================================================================
+  /**
+   * Enable/disable skeleton
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  /**
+   * Is enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  // ============================================================================
+  // Serialization
+  // ============================================================================
+  /**
+   * Serialize for animation system
+   */
+  serialize() {
+    return {
+      rigType: this.config.rigType,
+      boneCount: this.bones.size,
+      clipCount: this.clips.size,
+      layerCount: this.config.layers?.length ?? 0,
+      currentClip: this.state.currentClip,
+      currentTime: this.state.currentTime,
+      normalizedTime: this.state.normalizedTime,
+      isPlaying: this.state.isPlaying,
+      speed: this.config.speed,
+      rootMotion: this.config.rootMotion,
+      enabled: this.enabled
+    };
+  }
+};
+function createSkeletonTrait(config = {}) {
+  return new SkeletonTrait(config);
+}
+var skeletonHandler = {
+  name: "skeleton",
+  defaultConfig: {},
+  onAttach(node, config, ctx) {
+    const instance = new SkeletonTrait(config);
+    node.__skeleton_instance = instance;
+    ctx.emit("skeleton_attached", { node, config });
+  },
+  onDetach(node, _config, ctx) {
+    const instance = node.__skeleton_instance;
+    if (instance) {
+      if (typeof instance.onDetach === "function") instance.onDetach(node, ctx);
+      else if (typeof instance.dispose === "function") instance.dispose();
+      else if (typeof instance.cleanup === "function") instance.cleanup();
+    }
+    ctx.emit("skeleton_detached", { node });
+    delete node.__skeleton_instance;
+  },
+  onEvent(node, _config, ctx, event) {
+    const instance = node.__skeleton_instance;
+    if (!instance) return;
+    if (typeof instance.onEvent === "function") instance.onEvent(event);
+    else if (typeof instance.emit === "function" && event.type) instance.emit(event);
+    if (event.type === "skeleton_configure" && event.payload) {
+      Object.assign(instance, event.payload);
+      ctx.emit("skeleton_configured", { node });
+    }
+  },
+  onUpdate(node, _config, ctx, dt) {
+    const instance = node.__skeleton_instance;
+    if (!instance) return;
+    if (typeof instance.onUpdate === "function") instance.onUpdate(node, ctx, dt);
+  }
+};
+
+exports.SkeletonTrait = SkeletonTrait;
+exports.createSkeletonTrait = createSkeletonTrait;
+exports.skeletonHandler = skeletonHandler;
+//# sourceMappingURL=chunk-EKYL4PE3.cjs.map
+//# sourceMappingURL=chunk-EKYL4PE3.cjs.map

package/dist/chunk-EXKSFGSX.cjs

@@ -0,0 +1,274 @@
+'use strict';
+
+var chunkOSYNRVOV_cjs = require('./chunk-OSYNRVOV.cjs');
+
+// src/interop/InteropBindingGenerator.ts
+var InteropBindingGenerator = class {
+  /**
+   * Extract exports from a HoloScript AST
+   */
+  extractExports(ast) {
+    const exports$1 = [];
+    if (!ast.body) return exports$1;
+    for (const node of ast.body) {
+      const nodeRecord = node;
+      const nodeType = nodeRecord.type;
+      const nodeName = nodeRecord.name;
+      if (nodeType === "FunctionDeclaration" || nodeType === "function") {
+        const params = nodeRecord.params || [];
+        exports$1.push({
+          name: nodeName || "anonymous",
+          type: "function",
+          parameters: params.map((p) => {
+            if (typeof p === "string") {
+              return { name: p, type: "any", optional: false };
+            }
+            return {
+              name: p.name || "",
+              type: p.type || "any",
+              optional: p.optional || false
+            };
+          }),
+          returnType: nodeRecord.returnType || "void"
+        });
+      }
+      if (nodeType === "template" || nodeType === "ClassDeclaration") {
+        exports$1.push({
+          name: nodeName || "UnnamedTemplate",
+          type: "class"
+        });
+      }
+      if (nodeType === "composition") {
+        exports$1.push({
+          name: nodeName || "default",
+          type: "module"
+        });
+      }
+      if (nodeType === "VariableDeclaration" || nodeType === "state") {
+        exports$1.push({
+          name: nodeName || "unnamed",
+          type: "constant",
+          value: nodeRecord.value
+        });
+      }
+    }
+    return exports$1;
+  }
+  /**
+   * Generate Python bindings from HoloScript AST
+   */
+  generatePythonBindings(ast, sourceFile) {
+    const exports$1 = this.extractExports(ast);
+    const lines = [
+      '"""',
+      `Auto-generated Python bindings for ${sourceFile}`,
+      `Generated by HoloScript InteropBindingGenerator`,
+      `Do not edit manually \u2014 regenerate with: holoscript compile ${sourceFile} --target python`,
+      '"""',
+      "",
+      "from typing import Any, Optional, Dict, List",
+      "import json",
+      ""
+    ];
+    for (const exp of exports$1) {
+      switch (exp.type) {
+        case "function": {
+          const params = (exp.parameters || []).map((p) => {
+            const pyType = this.tsPyType(p.type);
+            return p.optional ? `${p.name}: ${pyType} = None` : `${p.name}: ${pyType}`;
+          }).join(", ");
+          const retType = this.tsPyType(exp.returnType || "void");
+          lines.push(`def ${exp.name}(${params}) -> ${retType}:`);
+          lines.push(`    """HoloScript function: ${exp.name}"""`);
+          lines.push(`    raise NotImplementedError("Bridge to HoloScript runtime required")`);
+          lines.push("");
+          break;
+        }
+        case "class": {
+          lines.push(`class ${exp.name}:`);
+          lines.push(`    """HoloScript template: ${exp.name}"""`);
+          lines.push(`    def __init__(self, **kwargs: Any) -> None:`);
+          lines.push(`        self._props = kwargs`);
+          lines.push("");
+          break;
+        }
+        case "constant": {
+          lines.push(`${exp.name} = ${JSON.stringify(exp.value ?? "None")}`);
+          lines.push("");
+          break;
+        }
+        case "module": {
+          lines.push(`class ${exp.name}Module:`);
+          lines.push(`    """HoloScript composition: ${exp.name}"""`);
+          lines.push(`    pass`);
+          lines.push("");
+          break;
+        }
+      }
+    }
+    lines.push(`__all__ = [${exports$1.map((e) => `"${e.name}"`).join(", ")}]`);
+    return {
+      language: "python",
+      code: lines.join("\n"),
+      exports: exports$1.map((e) => e.name),
+      metadata: {
+        sourceFile,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        holoScriptVersion: "5.0.0"
+      }
+    };
+  }
+  /**
+   * Generate JavaScript (ESM) bindings from HoloScript AST
+   */
+  generateJSBindings(ast, sourceFile) {
+    const exports$1 = this.extractExports(ast);
+    const lines = [
+      `// Auto-generated JS bindings for ${sourceFile}`,
+      `// Generated by HoloScript InteropBindingGenerator`,
+      `// Do not edit manually`,
+      ""
+    ];
+    for (const exp of exports$1) {
+      switch (exp.type) {
+        case "function": {
+          const params = (exp.parameters || []).map((p) => p.name).join(", ");
+          lines.push(`export function ${exp.name}(${params}) {`);
+          lines.push(`  throw new Error("Bridge to HoloScript runtime required");`);
+          lines.push(`}`);
+          lines.push("");
+          break;
+        }
+        case "class": {
+          lines.push(`export class ${exp.name} {`);
+          lines.push(`  constructor(props = {}) { this._props = props; }`);
+          lines.push(`}`);
+          lines.push("");
+          break;
+        }
+        case "constant": {
+          lines.push(`export const ${exp.name} = ${JSON.stringify(exp.value ?? null)};`);
+          lines.push("");
+          break;
+        }
+        case "module": {
+          lines.push(`export const ${exp.name} = { /* HoloScript composition */ };`);
+          lines.push("");
+          break;
+        }
+      }
+    }
+    return {
+      language: "javascript",
+      code: lines.join("\n"),
+      exports: exports$1.map((e) => e.name),
+      metadata: {
+        sourceFile,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        holoScriptVersion: "5.0.0"
+      }
+    };
+  }
+  /**
+   * Map TypeScript types to Python types
+   */
+  tsPyType(tsType) {
+    const mapping = {
+      string: "str",
+      number: "float",
+      int: "int",
+      boolean: "bool",
+      void: "None",
+      any: "Any",
+      unknown: "Any",
+      "string[]": "List[str]",
+      "number[]": "List[float]"
+    };
+    return mapping[tsType] || "Any";
+  }
+};
+
+// src/mcp/MCPCircuitBreaker.ts
+var MCPCircuitBreaker = class {
+  constructor(config = {}) {
+    this.breaker = new chunkOSYNRVOV_cjs.CircuitBreaker({
+      failureThreshold: config.failureThreshold ?? 5,
+      successThreshold: config.successThreshold ?? 2,
+      resetTimeoutMs: config.resetTimeoutMs ?? 3e4,
+      windowMs: config.windowMs ?? 6e4
+    });
+    this.baseUrl = config.baseUrl ?? "http://localhost:3000";
+  }
+  /**
+   * Call an MCP tool with circuit breaker protection + retry + timeout
+   */
+  async callTool(tool, args, timeoutMs = 15e3) {
+    try {
+      const result = await this.breaker.execute(async () => {
+        return chunkOSYNRVOV_cjs.retryWithBackoff(
+          async () => {
+            const response = await chunkOSYNRVOV_cjs.withTimeout(
+              fetch(`${this.baseUrl}/api/mcp/tools/${tool}`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ arguments: args })
+              }),
+              timeoutMs
+            );
+            if (!response.ok) {
+              throw new Error(`MCP tool ${tool} failed: ${response.status} ${response.statusText}`);
+            }
+            return response.json();
+          },
+          {
+            maxAttempts: 2,
+            initialBackoffMs: 500,
+            maxBackoffMs: 3e3
+          }
+        );
+      });
+      return {
+        success: true,
+        content: result,
+        circuitState: this.breaker.getState()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        circuitState: this.breaker.getState()
+      };
+    }
+  }
+  /**
+   * Get current circuit breaker state
+   */
+  getState() {
+    return this.breaker.getState();
+  }
+  /**
+   * Get circuit breaker metrics
+   */
+  getMetrics() {
+    return this.breaker.getMetrics();
+  }
+  /**
+   * Check if MCP server is available (circuit not open)
+   */
+  isAvailable() {
+    return this.breaker.getState() !== "OPEN" /* OPEN */;
+  }
+};
+var defaultInstance = null;
+function getMCPCircuitBreaker(config) {
+  if (!defaultInstance) {
+    defaultInstance = new MCPCircuitBreaker(config);
+  }
+  return defaultInstance;
+}
+
+exports.InteropBindingGenerator = InteropBindingGenerator;
+exports.MCPCircuitBreaker = MCPCircuitBreaker;
+exports.getMCPCircuitBreaker = getMCPCircuitBreaker;
+//# sourceMappingURL=chunk-EXKSFGSX.cjs.map
+//# sourceMappingURL=chunk-EXKSFGSX.cjs.map