@holoscript/core 6.0.4 → 7.0.0

package/dist/chunk-NOZZ46QU.js

@@ -1,168 +0,0 @@
-import { init_ProvenanceSemiring, authorityWeight, ProvenanceSemiring } from './chunk-A7PIMZGU.js';
-import { getRBAC, WorkflowStep, ResourceType } from '@holoscript/platform';
-
-// src/compiler/TraitCompositionCompiler.ts
-init_ProvenanceSemiring();
-var CompositionConflictError = class extends Error {
-  constructor(traitA, traitB, conflictKey) {
-    super(
-      `Trait composition conflict: "${traitA}" and "${traitB}" both declare conflicting key "${conflictKey}".`
-    );
-    this.traitA = traitA;
-    this.traitB = traitB;
-    this.conflictKey = conflictKey;
-    this.name = "CompositionConflictError";
-  }
-};
-var MissingComponentError = class extends Error {
-  constructor(composedName, missingComponent) {
-    super(
-      `Composition "${composedName}" references unknown component trait "${missingComponent}". Register it in TraitBinder before compiling.`
-    );
-    this.composedName = composedName;
-    this.missingComponent = missingComponent;
-    this.name = "MissingComponentError";
-  }
-};
-var TraitCompositionCompiler = class {
-  constructor(inheritanceResolver) {
-    this.inheritanceResolver = inheritanceResolver;
-  }
-  /**
-   * Set or replace the trait inheritance resolver.
-   * Call this after constructing if the resolver becomes available later.
-   */
-  setInheritanceResolver(resolver) {
-    this.inheritanceResolver = resolver;
-  }
-  /**
-   * Compile a set of composition declarations.
-   *
-   * @param decls         - Declarations to compile.
-   * @param getHandler    - Lookup a component handler by name.
-   * @param traitGraph    - Optional TraitDependencyGraph; if supplied, new
-   *                        composed traits are registered there.
-   * @param agentToken    - JWT token proving agent identity (optional for backwards compatibility).
-   * @returns Compiled ComposedTraitDef[], in declaration order.
-   * @throws UnauthorizedTraitCompositionAccessError if token is provided but invalid.
-   */
-  compile(decls, getHandler, traitGraph, agentToken) {
-    this.validateAccess(agentToken);
-    return decls.map((decl) => this.compileOne(decl, getHandler, traitGraph));
-  }
-  // ---------------------------------------------------------------------------
-  // RBAC enforcement
-  // ---------------------------------------------------------------------------
-  /**
-   * Validate agent has permission to compile trait compositions.
-   * Skips validation when no token is provided (backwards compatibility / testing).
-   */
-  validateAccess(agentToken) {
-    if (!agentToken) return;
-    const rbac = getRBAC();
-    const decision = rbac.checkAccess({
-      token: agentToken,
-      resourceType: ResourceType.AST,
-      operation: "read",
-      expectedWorkflowStep: WorkflowStep.GENERATE_ASSEMBLY
-    });
-    if (!decision.allowed) {
-      throw new UnauthorizedTraitCompositionAccessError(decision, "TraitCompositionCompiler");
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // Private
-  // ---------------------------------------------------------------------------
-  compileOne(decl, getHandler, traitGraph) {
-    const handlers = decl.components.map((name) => {
-      const handler = getHandler(name);
-      if (!handler) throw new MissingComponentError(decl.name, name);
-      return { name, handler };
-    });
-    if (authorityWeight(
-      decl.provenance?.context?.authorityLevel ?? 0
-    ) < 100) {
-      this.detectConflicts(handlers);
-    }
-    const semiring = new ProvenanceSemiring();
-    const applications = [];
-    for (const { name, handler } of handlers) {
-      let configAccumulator = {};
-      if (this.inheritanceResolver && this.inheritanceResolver.hasTrait(name)) {
-        const resolvedProps = this.inheritanceResolver.getFlattenedProperties(name);
-        configAccumulator = { ...resolvedProps };
-      }
-      if (handler.defaultConfig) {
-        configAccumulator = { ...configAccumulator, ...handler.defaultConfig };
-      }
-      applications.push({ name, config: configAccumulator });
-    }
-    if (decl.overrides) {
-      applications.push({
-        name: `${decl.name}_overrides`,
-        config: decl.overrides,
-        context: { authorityLevel: Number.MAX_SAFE_INTEGER }
-        // Overrides always win!
-      });
-    }
-    const { config: merged, errors } = semiring.add(applications);
-    if (errors.length > 0) {
-      const match = errors[0].match(/Composition conflict: @(.+) and @(.+) both supply '(.+)'/);
-      if (match) {
-        throw new CompositionConflictError(match[1], match[2], match[3]);
-      } else {
-        throw new CompositionConflictError("Merge", "Failure", errors[0]);
-      }
-    }
-    if (this.inheritanceResolver && decl.components.length > 1) {
-      const diamonds = this.inheritanceResolver.detectDiamondInheritance(decl.components);
-      for (const diamond of diamonds) {
-      }
-    }
-    if (traitGraph) {
-      traitGraph.registerTrait({
-        name: decl.name,
-        requires: decl.components,
-        conflicts: []
-      });
-    }
-    return {
-      name: decl.name,
-      components: decl.components,
-      defaultConfig: merged
-    };
-  }
-  /**
-   * Naive conflict check: if handler A's `conflicts` array includes handler B's
-   * name (or vice-versa), throw.
-   */
-  detectConflicts(handlers) {
-    for (let i = 0; i < handlers.length; i++) {
-      const a = handlers[i];
-      const aConflicts = a.handler.conflicts ?? [];
-      for (let j = i + 1; j < handlers.length; j++) {
-        const b = handlers[j];
-        const bConflicts = b.handler.conflicts ?? [];
-        if (aConflicts.includes(b.name) || bConflicts.includes(a.name)) {
-          throw new CompositionConflictError(a.name, b.name, b.name);
-        }
-      }
-    }
-  }
-};
-var UnauthorizedTraitCompositionAccessError = class extends Error {
-  constructor(decision, compilerName) {
-    super(
-      `[${compilerName}] Unauthorized access: ${decision.reason || "Access denied"}
-Agent Role: ${decision.agentRole || "unknown"}
-Required Permission: ${decision.requiredPermission || "unknown"}`
-    );
-    this.decision = decision;
-    this.compilerName = compilerName;
-    this.name = "UnauthorizedTraitCompositionAccessError";
-  }
-};
-
-export { CompositionConflictError, MissingComponentError, TraitCompositionCompiler, UnauthorizedTraitCompositionAccessError };
-//# sourceMappingURL=chunk-NOZZ46QU.js.map
-//# sourceMappingURL=chunk-NOZZ46QU.js.map

package/dist/chunk-OFKWH2IP.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-DEN36VNK.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-OFKWH2IP.js.map
-//# sourceMappingURL=chunk-OFKWH2IP.js.map

package/dist/chunk-PHENW4MQ.js

@@ -1,65 +0,0 @@
-// src/logger.ts
-var NoOpLogger = class {
-  /**
-   * Debug-level logging (no-op implementation).
-   * @param message - Debug message to discard
-   * @param meta - Optional metadata to discard
-   */
-  debug(message, meta) {
-  }
-  /**
-   * Info-level logging (no-op implementation).
-   * @param message - Info message to discard
-   * @param meta - Optional metadata to discard
-   */
-  info(message, meta) {
-  }
-  /**
-   * Warning-level logging (no-op implementation).
-   * @param message - Warning message to discard
-   * @param meta - Optional metadata to discard
-   */
-  warn(message, meta) {
-  }
-  /**
-   * Error-level logging (no-op implementation).
-   * @param message - Error message to discard
-   * @param meta - Optional metadata to discard
-   */
-  error(message, meta) {
-  }
-};
-var ConsoleLogger = class {
-  debug(message, meta) {
-    console.debug(`[HoloScript:DEBUG] ${message}`, meta ?? "");
-  }
-  info(message, meta) {
-    console.info(`[HoloScript:INFO] ${message}`, meta ?? "");
-  }
-  warn(message, meta) {
-    console.warn(`[HoloScript:WARN] ${message}`, meta ?? "");
-  }
-  error(message, meta) {
-    console.error(`[HoloScript:ERROR] ${message}`, meta ?? "");
-  }
-};
-var currentLogger = new NoOpLogger();
-function setHoloScriptLogger(logger2) {
-  currentLogger = logger2;
-}
-function enableConsoleLogging() {
-  currentLogger = new ConsoleLogger();
-}
-function resetLogger() {
-  currentLogger = new NoOpLogger();
-}
-var logger = {
-  debug: (msg, meta) => currentLogger.debug(msg, meta),
-  info: (msg, meta) => currentLogger.info(msg, meta),
-  warn: (msg, meta) => currentLogger.warn(msg, meta),
-  error: (msg, meta) => currentLogger.error(msg, meta)
-};
-
-export { ConsoleLogger, NoOpLogger, enableConsoleLogging, logger, resetLogger, setHoloScriptLogger };
-//# sourceMappingURL=chunk-PHENW4MQ.js.map
-//# sourceMappingURL=chunk-PHENW4MQ.js.map