@holoscript/core 6.0.3 → 7.0.0

package/dist/chunk-F5LVGHNT.js

@@ -1,449 +0,0 @@
-// src/compiler/GLTFPipelineMCPTool.ts
-var GLTF_PIPELINE_TOOLS = [
-  {
-    name: "holoscript_gltf_export",
-    description: "Export a HoloScript composition AST to glTF/GLB format. Supports PBR materials, mesh primitives, animations, and texture embedding.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        composition: {
-          type: "object",
-          description: "HoloComposition AST (JSON serialized)"
-        },
-        format: {
-          type: "string",
-          description: "Output format",
-          enum: ["glb", "gltf"],
-          default: "glb"
-        },
-        dracoCompression: {
-          type: "boolean",
-          description: "Enable Draco mesh compression",
-          default: false
-        },
-        quantize: {
-          type: "boolean",
-          description: "Enable vertex quantization for smaller file size",
-          default: false
-        },
-        prune: {
-          type: "boolean",
-          description: "Remove unused resources",
-          default: true
-        },
-        dedupe: {
-          type: "boolean",
-          description: "Deduplicate accessors and materials",
-          default: true
-        },
-        embedTextures: {
-          type: "boolean",
-          description: "Embed textures as base64",
-          default: true
-        },
-        agentToken: {
-          type: "string",
-          description: "Agent authentication token (JWT or empty for dev)",
-          default: ""
-        }
-      },
-      required: ["composition"]
-    }
-  },
-  {
-    name: "holoscript_gltf_inspect",
-    description: "Inspect a glTF/GLB file and return metadata including node count, mesh count, material count, texture count, animation count, and file size.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        composition: {
-          type: "object",
-          description: "HoloComposition AST to inspect (will be processed through GLTFPipeline)"
-        },
-        format: {
-          type: "string",
-          description: "Target format for size estimation",
-          enum: ["glb", "gltf"],
-          default: "glb"
-        }
-      },
-      required: ["composition"]
-    }
-  },
-  {
-    name: "holoscript_gltf_validate",
-    description: "Validate a HoloComposition AST for glTF export compatibility. Returns validation errors and warnings without performing the actual export.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        composition: {
-          type: "object",
-          description: "HoloComposition AST to validate"
-        }
-      },
-      required: ["composition"]
-    }
-  },
-  {
-    name: "holoscript_gltf_optimize",
-    description: "Optimize a HoloComposition for efficient glTF export. Returns optimization recommendations and optionally applies them.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        composition: {
-          type: "object",
-          description: "HoloComposition AST to optimize"
-        },
-        applyOptimizations: {
-          type: "boolean",
-          description: "Whether to apply optimizations to the AST (true) or just report (false)",
-          default: false
-        }
-      },
-      required: ["composition"]
-    }
-  },
-  {
-    name: "holoscript_gltf_material_list",
-    description: "List all available HoloScript material presets that can be used in glTF export. Returns names and PBR properties for each preset.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        filter: {
-          type: "string",
-          description: "Optional substring filter for preset names"
-        }
-      }
-    }
-  }
-];
-async function handleGLTFToolCall(request) {
-  try {
-    switch (request.name) {
-      case "holoscript_gltf_export":
-        return await handleExport(request.arguments);
-      case "holoscript_gltf_inspect":
-        return await handleInspect(request.arguments);
-      case "holoscript_gltf_validate":
-        return await handleValidate(request.arguments);
-      case "holoscript_gltf_optimize":
-        return await handleOptimize(request.arguments);
-      case "holoscript_gltf_material_list":
-        return await handleMaterialList(request.arguments);
-      default:
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Unknown tool: ${request.name}` }]
-        };
-    }
-  } catch (error) {
-    return {
-      isError: true,
-      content: [
-        {
-          type: "text",
-          text: `Error: ${error instanceof Error ? error.message : String(error)}`
-        }
-      ]
-    };
-  }
-}
-async function handleExport(args) {
-  const composition = args.composition;
-  if (!composition || !composition.name) {
-    return {
-      isError: true,
-      content: [{ type: "text", text: 'Invalid composition: missing "name" field' }]
-    };
-  }
-  const format = args.format ?? "glb";
-  const agentToken = args.agentToken ?? "";
-  const { GLTFPipeline } = await importGLTFPipeline();
-  const pipeline = new GLTFPipeline({
-    format,
-    dracoCompression: args.dracoCompression ?? false,
-    quantize: args.quantize ?? false,
-    prune: args.prune ?? true,
-    dedupe: args.dedupe ?? true,
-    embedTextures: args.embedTextures ?? true
-  });
-  const result = pipeline.compile(composition, agentToken);
-  const content = [];
-  content.push({
-    type: "text",
-    text: JSON.stringify(
-      {
-        success: true,
-        format,
-        stats: result.stats
-      },
-      null,
-      2
-    )
-  });
-  if (result.binary) {
-    content.push({
-      type: "resource",
-      uri: `holoscript://gltf/${composition.name}.${format}`,
-      mimeType: format === "glb" ? "model/gltf-binary" : "model/gltf+json",
-      data: uint8ArrayToBase64(result.binary)
-    });
-  }
-  if (result.json) {
-    content.push({
-      type: "text",
-      text: JSON.stringify(result.json, null, 2),
-      mimeType: "application/json"
-    });
-  }
-  return { isError: false, content };
-}
-async function handleInspect(args) {
-  const composition = args.composition;
-  if (!composition || !composition.name) {
-    return {
-      isError: true,
-      content: [{ type: "text", text: 'Invalid composition: missing "name" field' }]
-    };
-  }
-  const stats = inspectComposition(composition);
-  return {
-    isError: false,
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(
-          {
-            name: composition.name,
-            stats,
-            estimated_export_format: args.format ?? "glb"
-          },
-          null,
-          2
-        )
-      }
-    ]
-  };
-}
-async function handleValidate(args) {
-  const composition = args.composition;
-  if (!composition || !composition.name) {
-    return {
-      isError: true,
-      content: [{ type: "text", text: 'Invalid composition: missing "name" field' }]
-    };
-  }
-  const validation = validateForGLTF(composition);
-  return {
-    isError: false,
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(validation, null, 2)
-      }
-    ]
-  };
-}
-async function handleOptimize(args) {
-  const composition = args.composition;
-  if (!composition || !composition.name) {
-    return {
-      isError: true,
-      content: [{ type: "text", text: 'Invalid composition: missing "name" field' }]
-    };
-  }
-  const recommendations = analyzeOptimizations(composition);
-  return {
-    isError: false,
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(
-          {
-            composition: composition.name,
-            recommendations,
-            total_recommendations: recommendations.length
-          },
-          null,
-          2
-        )
-      }
-    ]
-  };
-}
-async function handleMaterialList(args) {
-  const filter = args.filter ?? "";
-  let presets = {};
-  try {
-    const { MATERIAL_PRESETS } = await import('./compiler/r3f.js');
-    presets = MATERIAL_PRESETS;
-  } catch {
-    presets = {
-      default: { metalness: 0, roughness: 0.5 },
-      metal: { metalness: 1, roughness: 0.2 },
-      glass: { metalness: 0, roughness: 0, transmission: 1 },
-      wood: { metalness: 0, roughness: 0.8 },
-      plastic: { metalness: 0, roughness: 0.4 }
-    };
-  }
-  let entries = Object.entries(presets);
-  if (filter) {
-    entries = entries.filter(([name]) => name.toLowerCase().includes(filter.toLowerCase()));
-  }
-  return {
-    isError: false,
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(
-          {
-            total: entries.length,
-            presets: Object.fromEntries(entries)
-          },
-          null,
-          2
-        )
-      }
-    ]
-  };
-}
-function inspectComposition(composition) {
-  let traitCount = 0;
-  let objectCount = 0;
-  function countObjects(objects) {
-    for (const obj of objects ?? []) {
-      objectCount++;
-      traitCount += obj.traits?.length ?? 0;
-      if (obj.children) countObjects(obj.children);
-    }
-  }
-  countObjects(composition.objects);
-  for (const group of composition.spatialGroups ?? []) {
-    countObjects(group.objects);
-  }
-  return {
-    objectCount,
-    spatialGroupCount: composition.spatialGroups?.length ?? 0,
-    lightCount: composition.lights?.length ?? 0,
-    hasCamera: !!composition.camera,
-    timelineCount: composition.timelines?.length ?? 0,
-    audioCount: composition.audio?.length ?? 0,
-    npcCount: composition.npcs?.length ?? 0,
-    shapeCount: composition.shapes?.length ?? 0,
-    domainBlockCount: composition.domainBlocks?.length ?? 0,
-    traitCount,
-    estimatedNodeCount: objectCount + (composition.spatialGroups?.length ?? 0) + (composition.lights?.length ?? 0),
-    estimatedMeshCount: objectCount
-  };
-}
-function validateForGLTF(composition) {
-  const errors = [];
-  const warnings = [];
-  if (!composition.name) {
-    errors.push("Composition is missing a name");
-  }
-  if (!composition.objects?.length && !composition.spatialGroups?.length && !composition.shapes?.length) {
-    warnings.push("Composition has no objects, spatial groups, or shapes to export");
-  }
-  if (composition.npcs?.length) {
-    warnings.push(
-      `${composition.npcs.length} NPC(s) will be exported as basic meshes (no behavior trees in glTF)`
-    );
-  }
-  if (composition.stateMachines?.length) {
-    warnings.push("State machines are not representable in glTF and will be omitted");
-  }
-  if (composition.quests?.length) {
-    warnings.push("Quest definitions are not representable in glTF and will be omitted");
-  }
-  function checkObjects(objects) {
-    for (const obj of objects ?? []) {
-      const hasGeometry = obj.properties.some(
-        (p) => p.key === "geometry" || p.key === "shape" || p.key === "model"
-      ) || obj.traits?.some((t) => t.name === "geometry" || t.name === "mesh");
-      if (!hasGeometry) {
-        warnings.push(`Object "${obj.name}" has no explicit geometry; will default to cube`);
-      }
-      if (obj.children) checkObjects(obj.children);
-    }
-  }
-  checkObjects(composition.objects);
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-function analyzeOptimizations(composition) {
-  const recommendations = [];
-  const stats = inspectComposition(composition);
-  if (stats.objectCount > 100) {
-    recommendations.push({
-      category: "performance",
-      severity: "warning",
-      message: `Scene has ${stats.objectCount} objects. Consider using instancing or LOD for objects with shared geometry.`,
-      action: "Enable dedupe and consider spatial grouping for draw call batching."
-    });
-  }
-  if (stats.lightCount > 8) {
-    recommendations.push({
-      category: "performance",
-      severity: "warning",
-      message: `Scene has ${stats.lightCount} lights. Most real-time renderers support 4-8 dynamic lights.`,
-      action: "Bake some lights into lightmaps or reduce dynamic light count."
-    });
-  }
-  if (stats.objectCount > 50) {
-    recommendations.push({
-      category: "filesize",
-      severity: "suggestion",
-      message: "Consider enabling Draco compression for meshes to reduce file size by 40-90%.",
-      action: "Set dracoCompression: true in GLTFPipelineOptions."
-    });
-  }
-  recommendations.push({
-    category: "filesize",
-    severity: "info",
-    message: "Enable vertex quantization to reduce vertex attribute precision and save ~30% on geometry data.",
-    action: "Set quantize: true in GLTFPipelineOptions."
-  });
-  if (stats.domainBlockCount > 0) {
-    recommendations.push({
-      category: "compatibility",
-      severity: "info",
-      message: `${stats.domainBlockCount} domain block(s) detected. Domain-specific data will be stored in glTF extras for custom loader support.`
-    });
-  }
-  if (stats.traitCount === 0 && stats.objectCount > 0) {
-    recommendations.push({
-      category: "quality",
-      severity: "suggestion",
-      message: "No traits found on objects. Add material/shader traits for richer visual output.",
-      action: "Add @material, @shader, or @emissive traits to objects."
-    });
-  }
-  return recommendations;
-}
-function uint8ArrayToBase64(data) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(data).toString("base64");
-  }
-  let binary = "";
-  for (let i = 0; i < data.length; i++) {
-    binary += String.fromCharCode(data[i]);
-  }
-  return btoa(binary);
-}
-async function importGLTFPipeline() {
-  return import('./GLTFPipeline-LYII2ZVQ.js');
-}
-function registerGLTFTools(server) {
-  for (const tool of GLTF_PIPELINE_TOOLS) {
-    server.registerTool(tool, handleGLTFToolCall);
-  }
-}
-var GLTFPipelineMCPTool_default = handleGLTFToolCall;
-
-export { GLTFPipelineMCPTool_default, GLTF_PIPELINE_TOOLS, analyzeOptimizations, handleGLTFToolCall, inspectComposition, registerGLTFTools, validateForGLTF };
-//# sourceMappingURL=chunk-F5LVGHNT.js.map
-//# sourceMappingURL=chunk-F5LVGHNT.js.map