@holoscript/core 6.0.4 → 6.1.2

package/dist/{USDZExporter-NTMBNTDB.js → USDZExporter-D2HQLQYK.js}

@@ -1,4 +1,4 @@
-import './chunk-2CWOLHTE.js';
+import './chunk-OL46QLBJ.js';
 
 // src/export/usdz/USDTypes.ts
 function createUSDXform(name, path) {
@@ -90,6 +90,10 @@ var _USDZExporter = class _USDZExporter {
     // materialId -> USD path
     this.meshMap = /* @__PURE__ */ new Map();
     // meshId -> USD path
+    this.nodePrimMap = /* @__PURE__ */ new Map();
+    // nodeId -> USD prim
+    this.sceneGraphAccessorData = /* @__PURE__ */ new Map();
+    // accessorIndex -> flat data
     this.textureFiles = [];
     this.options = { ..._USDZExporter.DEFAULT_OPTIONS, ...options };
   }
@@ -117,8 +121,243 @@ var _USDZExporter = class _USDZExporter {
   /**
    * Convert from GLTF intermediate representation
    */
-  async convertFromGLTF(_gltfResult) {
-    throw new Error("Direct GLTF conversion not yet implemented. Use export() with scene graph.");
+  async convertFromGLTF(gltfResult) {
+    const sceneGraph = this.gltfToSceneGraph(gltfResult);
+    const result = await this.export(sceneGraph);
+    return result.usdz;
+  }
+  // ========================================================================
+  // Private Methods - GLTF Bridge
+  // ========================================================================
+  gltfToSceneGraph(gltfResult) {
+    const doc = gltfResult.document;
+    const buffers = this.extractGLTFBuffers(gltfResult);
+    const sgBuffers = buffers.map((data, i) => ({
+      id: `buf_${i}`,
+      byteLength: data.byteLength,
+      data
+    }));
+    const sgBufferViews = (doc.bufferViews || []).map((bv, i) => ({
+      id: `bv_${i}`,
+      bufferIndex: bv.buffer,
+      byteOffset: bv.byteOffset || 0,
+      byteLength: bv.byteLength,
+      byteStride: bv.byteStride,
+      target: bv.target === 34962 ? "arrayBuffer" : bv.target === 34963 ? "elementArrayBuffer" : void 0
+    }));
+    const componentTypeMap = {
+      5120: "byte",
+      5121: "ubyte",
+      5122: "short",
+      5123: "ushort",
+      5125: "uint",
+      5126: "float"
+    };
+    const accessorTypeMap = {
+      SCALAR: "scalar",
+      VEC2: "vec2",
+      VEC3: "vec3",
+      VEC4: "vec4",
+      MAT2: "mat2",
+      MAT3: "mat3",
+      MAT4: "mat4"
+    };
+    const sgAccessors = (doc.accessors || []).map((acc, i) => ({
+      id: `acc_${i}`,
+      bufferViewIndex: acc.bufferView !== void 0 ? acc.bufferView : 0,
+      byteOffset: acc.byteOffset || 0,
+      componentType: componentTypeMap[acc.componentType] || "float",
+      type: accessorTypeMap[acc.type] || "scalar",
+      count: acc.count,
+      normalized: acc.normalized || false,
+      min: acc.min,
+      max: acc.max
+    }));
+    const sgMeshes = (doc.meshes || []).map((mesh, i) => ({
+      id: `mesh_${i}`,
+      name: mesh.name || `Mesh_${i}`,
+      primitives: mesh.primitives.map((prim) => ({
+        attributes: { ...prim.attributes },
+        indices: prim.indices,
+        mode: this.mapGLTFPrimitiveMode(prim.mode),
+        materialRef: prim.material !== void 0 ? `mat_${prim.material}` : void 0
+      })),
+      bounds: { min: [0, 0, 0], max: [1, 1, 1] }
+    }));
+    const sgMaterials = (doc.materials || []).map((mat, i) => {
+      const pbr = mat.pbrMetallicRoughness;
+      return {
+        id: `mat_${i}`,
+        name: mat.name || `Material_${i}`,
+        type: "pbr",
+        doubleSided: mat.doubleSided || false,
+        alphaMode: mat.alphaMode?.toLowerCase() || "opaque",
+        alphaCutoff: mat.alphaCutoff ?? 0.5,
+        baseColor: pbr?.baseColorFactor || [1, 1, 1, 1],
+        metallic: pbr?.metallicFactor ?? 0,
+        roughness: pbr?.roughnessFactor ?? 0.5,
+        emissiveColor: mat.emissiveFactor || [0, 0, 0],
+        emissiveIntensity: 1,
+        normalScale: mat.normalTexture?.scale ?? 1,
+        occlusionStrength: mat.occlusionTexture?.strength ?? 1,
+        baseColorTexture: pbr?.baseColorTexture ? this.mapGLTFTextureRef(pbr.baseColorTexture.index, pbr.baseColorTexture.texCoord || 0) : void 0,
+        normalTexture: mat.normalTexture ? this.mapGLTFTextureRef(mat.normalTexture.index, mat.normalTexture.texCoord || 0) : void 0,
+        occlusionTexture: mat.occlusionTexture ? this.mapGLTFTextureRef(mat.occlusionTexture.index, mat.occlusionTexture.texCoord || 0) : void 0,
+        emissiveTexture: mat.emissiveTexture ? this.mapGLTFTextureRef(mat.emissiveTexture.index, mat.emissiveTexture.texCoord || 0) : void 0,
+        metallicRoughnessTexture: pbr?.metallicRoughnessTexture ? this.mapGLTFTextureRef(pbr.metallicRoughnessTexture.index, pbr.metallicRoughnessTexture.texCoord || 0) : void 0
+      };
+    });
+    const nodeIdMap = /* @__PURE__ */ new Map();
+    const buildNode = (gltfNode, index) => {
+      const id = `node_${index}`;
+      nodeIdMap.set(index, id);
+      const children = (gltfNode.children || []).map(
+        (ci) => buildNode(doc.nodes[ci], ci)
+      );
+      const components = [];
+      if (gltfNode.mesh !== void 0) {
+        components.push({
+          type: "mesh",
+          meshRef: `mesh_${gltfNode.mesh}`,
+          materialRefs: [],
+          castShadows: true,
+          receiveShadows: true,
+          enabled: true,
+          properties: {}
+        });
+      }
+      return {
+        id,
+        name: gltfNode.name || `Node_${index}`,
+        type: "object",
+        transform: {
+          position: gltfNode.translation || [0, 0, 0],
+          rotation: gltfNode.rotation ? {
+            x: gltfNode.rotation[0],
+            y: gltfNode.rotation[1],
+            z: gltfNode.rotation[2],
+            w: gltfNode.rotation[3]
+          } : { x: 0, y: 0, z: 0, w: 1 },
+          scale: gltfNode.scale || [1, 1, 1]
+        },
+        children,
+        components,
+        active: true,
+        layers: 1,
+        tags: [],
+        metadata: {}
+      };
+    };
+    const scene = doc.scenes?.[doc.scene ?? 0];
+    const rootChildren = (scene?.nodes || []).map((ni) => buildNode(doc.nodes[ni], ni));
+    const root = {
+      id: "root",
+      name: "Root",
+      type: "group",
+      transform: {
+        position: [0, 0, 0],
+        rotation: { x: 0, y: 0, z: 0, w: 1 },
+        scale: [1, 1, 1]
+      },
+      children: rootChildren,
+      components: [],
+      active: true,
+      layers: 1,
+      tags: [],
+      metadata: {}
+    };
+    const sgAnimations = (doc.animations || []).map((anim, i) => {
+      const channels = anim.channels.map((ch) => ({
+        targetNode: nodeIdMap.get(ch.target.node) || `node_${ch.target.node}`,
+        targetPath: ch.target.path,
+        samplerIndex: ch.sampler
+      }));
+      const samplers = anim.samplers.map((s) => ({
+        inputBufferView: s.input,
+        outputBufferView: s.output,
+        interpolation: s.interpolation?.toLowerCase() || "linear"
+      }));
+      return {
+        id: `anim_${i}`,
+        name: anim.name || `Animation_${i}`,
+        duration: 0,
+        channels,
+        samplers
+      };
+    });
+    return {
+      version: "3.3.0",
+      generator: "HoloScript USDZExporter (GLTF bridge)",
+      metadata: {
+        name: "GLTFImport",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        modifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        tags: [],
+        properties: {}
+      },
+      root,
+      materials: sgMaterials,
+      textures: [],
+      meshes: sgMeshes,
+      buffers: sgBuffers,
+      bufferViews: sgBufferViews,
+      accessors: sgAccessors,
+      animations: sgAnimations,
+      skins: [],
+      extensions: {},
+      extras: {}
+    };
+  }
+  extractGLTFBuffers(gltfResult) {
+    const doc = gltfResult.document;
+    if (gltfResult.glb) {
+      const binChunk = this.extractGLBBinChunk(gltfResult.glb);
+      if (binChunk) return [binChunk];
+    }
+    const buffers = [];
+    for (const buffer of doc.buffers || []) {
+      if (buffer.uri) {
+        const resource = gltfResult.resources.get(buffer.uri);
+        if (resource) {
+          buffers.push(resource);
+          continue;
+        }
+      }
+      buffers.push(new ArrayBuffer(buffer.byteLength));
+    }
+    return buffers;
+  }
+  extractGLBBinChunk(glb) {
+    const view = new DataView(glb);
+    const magic = view.getUint32(0, true);
+    if (magic !== 1179937895) return void 0;
+    const version = view.getUint32(4, true);
+    if (version !== 2) return void 0;
+    const length = view.getUint32(8, true);
+    let offset = 12;
+    while (offset < length) {
+      const chunkLength = view.getUint32(offset, true);
+      const chunkType = view.getUint32(offset + 4, true);
+      offset += 8;
+      if (chunkType === 5130562) {
+        return glb.slice(offset, offset + chunkLength);
+      }
+      offset += chunkLength;
+    }
+    return void 0;
+  }
+  mapGLTFPrimitiveMode(mode) {
+    const modes = ["points", "lines", "lineLoop", "lineStrip", "triangles", "triangleStrip", "triangleFan"];
+    return modes[mode ?? 4] || "triangles";
+  }
+  mapGLTFTextureRef(index, uvChannel) {
+    return {
+      id: `tex_${index}`,
+      uvChannel,
+      offset: { u: 0, v: 0 },
+      scale: { u: 1, v: 1 },
+      rotation: 0
+    };
   }
   // ========================================================================
   // Private Methods - Stage Creation
@@ -140,6 +379,7 @@ var _USDZExporter = class _USDZExporter {
     };
   }
   async convertSceneGraph(sceneGraph) {
+    this.cacheAccessorData(sceneGraph);
     const rootPrim = createUSDXform("Root", "/Root");
     this.stage.prims.push(rootPrim);
     await this.convertMaterials(sceneGraph.materials || []);
@@ -149,6 +389,12 @@ var _USDZExporter = class _USDZExporter {
       this.convertAnimations(sceneGraph.animations);
     }
   }
+  cacheAccessorData(sceneGraph) {
+    for (let i = 0; i < (sceneGraph.accessors || []).length; i++) {
+      const data = this.extractAccessorData(i, sceneGraph);
+      this.sceneGraphAccessorData.set(i, data);
+    }
+  }
   // ========================================================================
   // Private Methods - Node Conversion
   // ========================================================================
@@ -158,6 +404,9 @@ var _USDZExporter = class _USDZExporter {
     const nodeName = sanitizeUSDName(node.name || `Node_${this.primCounter++}`);
     const nodePath = `${parentPrim.path}/${nodeName}`;
     const xformPrim = createUSDXform(nodeName, nodePath);
+    if (node.id) {
+      this.nodePrimMap.set(node.id, xformPrim);
+    }
     if (node.transform) {
       this.addTransform(xformPrim, node.transform);
     }
@@ -181,21 +430,21 @@ var _USDZExporter = class _USDZExporter {
       }
     }
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Deep nested transform object access (position.x/y/z, rotation.x/y/z/w, scale.x/y/z)
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Deep nested transform object access (position[0]/y/z, rotation[0]/y/z/w, scale[0]/y/z)
   addTransform(prim, transform) {
     const ops = [];
     if (transform.position) {
       ops.push({
         type: "translate",
-        value: [transform.position.x, transform.position.y, transform.position.z]
+        value: [transform.position[0], transform.position[1], transform.position[2]]
       });
     }
     if (transform.rotation) {
       const euler = quaternionToEuler([
-        transform.rotation.x,
-        transform.rotation.y,
-        transform.rotation.z,
-        transform.rotation.w
+        transform.rotation[0],
+        transform.rotation[1],
+        transform.rotation[2],
+        transform.rotation[3]
       ]);
       ops.push({
         type: "rotateXYZ",
@@ -205,7 +454,7 @@ var _USDZExporter = class _USDZExporter {
     if (transform.scale) {
       ops.push({
         type: "scale",
-        value: [transform.scale.x, transform.scale.y, transform.scale.z]
+        value: [transform.scale[0], transform.scale[1], transform.scale[2]]
       });
     }
     if (ops.length > 0) {
@@ -466,8 +715,76 @@ var _USDZExporter = class _USDZExporter {
   // ========================================================================
   // Private Methods - Animation Conversion
   // ========================================================================
-  convertAnimations(_animations) {
-    console.warn("Animation export not yet implemented");
+  convertAnimations(animations) {
+    for (const animation of animations) {
+      this.convertAnimation(animation);
+    }
+  }
+  convertAnimation(animation) {
+    const channelsByNode = /* @__PURE__ */ new Map();
+    for (const channel of animation.channels) {
+      const list = channelsByNode.get(channel.targetNode) || [];
+      list.push(channel);
+      channelsByNode.set(channel.targetNode, list);
+    }
+    for (const [nodeId, channels] of Array.from(channelsByNode.entries())) {
+      const prim = this.nodePrimMap.get(nodeId);
+      if (!prim) continue;
+      for (const channel of channels) {
+        this.applyAnimationChannel(prim, channel, animation.samplers);
+      }
+    }
+  }
+  applyAnimationChannel(prim, channel, samplers) {
+    const sampler = samplers[channel.samplerIndex];
+    if (!sampler) return;
+    const times = this.extractAccessorDataFlat(sampler.inputBufferView);
+    const values = this.extractAccessorDataFlat(sampler.outputBufferView);
+    if (times.length === 0 || values.length === 0) return;
+    const timeSamples = /* @__PURE__ */ new Map();
+    switch (channel.targetPath) {
+      case "translation": {
+        for (let i = 0; i < times.length; i++) {
+          timeSamples.set(times[i], [values[i * 3], values[i * 3 + 1], values[i * 3 + 2]]);
+        }
+        this.setXformOpTimeSamples(prim, "xformOp:translate", "float3", timeSamples);
+        break;
+      }
+      case "rotation": {
+        for (let i = 0; i < times.length; i++) {
+          const qx = values[i * 4];
+          const qy = values[i * 4 + 1];
+          const qz = values[i * 4 + 2];
+          const qw = values[i * 4 + 3];
+          const euler = quaternionToEuler([qx, qy, qz, qw]);
+          timeSamples.set(times[i], euler);
+        }
+        this.setXformOpTimeSamples(prim, "xformOp:rotateXYZ", "float3", timeSamples);
+        break;
+      }
+      case "scale": {
+        for (let i = 0; i < times.length; i++) {
+          timeSamples.set(times[i], [values[i * 3], values[i * 3 + 1], values[i * 3 + 2]]);
+        }
+        this.setXformOpTimeSamples(prim, "xformOp:scale", "float3", timeSamples);
+        break;
+      }
+      case "weights": {
+        console.warn(`Morph target animation not yet supported for ${prim.name}`);
+        break;
+      }
+    }
+  }
+  extractAccessorDataFlat(accessorIndex) {
+    return this.sceneGraphAccessorData.get(accessorIndex) || [];
+  }
+  setXformOpTimeSamples(prim, opName, type, timeSamples) {
+    let attr = prim.attributes.find((a) => a.name === opName);
+    if (!attr) {
+      attr = { name: opName, type, value: timeSamples.values().next().value || [] };
+      prim.attributes.push(attr);
+    }
+    attr.timeSamples = timeSamples;
   }
   // ========================================================================
   // Private Methods - AR Metadata
@@ -549,8 +866,17 @@ var _USDZExporter = class _USDZExporter {
   }
   serializeAttribute(attr, lines, indent) {
     const ind = "    ".repeat(indent);
-    const value = this.serializeValue(attr.value, attr.type);
-    lines.push(`${ind}${attr.type} ${attr.name} = ${value}`);
+    if (attr.timeSamples && attr.timeSamples.size > 0) {
+      lines.push(`${ind}${attr.type} ${attr.name}.timeSamples = {`);
+      for (const [time, sample] of Array.from(attr.timeSamples.entries())) {
+        const serializedSample = this.serializeValue(sample, attr.type);
+        lines.push(`${ind}    ${time}: ${serializedSample},`);
+      }
+      lines.push(`${ind}}`);
+    } else {
+      const value = this.serializeValue(attr.value, attr.type);
+      lines.push(`${ind}${attr.type} ${attr.name} = ${value}`);
+    }
   }
   serializeValue(value, type) {
     if (Array.isArray(value)) {
@@ -659,6 +985,8 @@ var _USDZExporter = class _USDZExporter {
     this.primCounter = 0;
     this.materialMap.clear();
     this.meshMap.clear();
+    this.nodePrimMap.clear();
+    this.sceneGraphAccessorData.clear();
     this.textureFiles = [];
   }
   calculateStats(usdzSize, exportTime) {
@@ -703,5 +1031,5 @@ _USDZExporter.DEFAULT_OPTIONS = {
 var USDZExporter = _USDZExporter;
 
 export { USDZExporter };
-//# sourceMappingURL=USDZExporter-NTMBNTDB.js.map
-//# sourceMappingURL=USDZExporter-NTMBNTDB.js.map
+//# sourceMappingURL=USDZExporter-D2HQLQYK.js.map
+//# sourceMappingURL=USDZExporter-D2HQLQYK.js.map

package/dist/agents/index.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+require('../chunk-HCCQLAA4.cjs');
+
+// src/agents/index.ts
+var PHASE_ORDER = [
+  "intake",
+  "reflect",
+  "execute",
+  "compress",
+  "reintake",
+  "grow",
+  "evolve",
+  "autonomize"
+];
+
+exports.PHASE_ORDER = PHASE_ORDER;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/agents/index.d.ts

@@ -0,0 +1,100 @@
+/**
+ * @holoscript/core/agents
+ *
+ * Canonical agent protocol types for HoloScript Core.
+ */
+export type AgentPhase = 'intake' | 'reflect' | 'execute' | 'compress' | 'reintake' | 'grow' | 'evolve' | 'autonomize';
+export declare const PHASE_ORDER: readonly AgentPhase[];
+export interface AgentConfig {
+  name: string;
+  endpoint?: string;
+  timeout?: number;
+  [key: string]: unknown;
+}
+export interface AgentMessage {
+  action: string;
+  payload: unknown;
+  timestamp: number;
+}
+export interface AgentResponse {
+  success: boolean;
+  data?: unknown;
+  error?: string;
+}
+export interface CycleResult {
+  success: boolean;
+  phase: AgentPhase;
+  data?: unknown;
+  error?: Error;
+}
+export type TaskStatus = 'idle' | 'pending' | 'running' | 'success' | 'error' | 'cancelled' | 'timeout';
+export interface TaskParams {
+  input?: Record<string, unknown>;
+  priority?: 'low' | 'medium' | 'high' | 'critical';
+  timeout?: number;
+  retry?: boolean;
+  maxRetries?: number;
+  retryDelay?: number;
+  metadata?: Record<string, unknown>;
+}
+export interface TaskResult<T = unknown> {
+  taskId: string;
+  status: TaskStatus;
+  data?: T;
+  error?: Error;
+  startedAt: number;
+  completedAt?: number;
+  duration?: number;
+  retryCount: number;
+}
+export interface TaskLog {
+  timestamp: number;
+  level: 'debug' | 'info' | 'warn' | 'error';
+  message: string;
+  data?: unknown;
+}
+export interface TaskProgress {
+  progress: number;
+  phase?: AgentPhase;
+  estimatedTime?: number;
+  logs: TaskLog[];
+  status: TaskStatus;
+}
+export type CircuitState = 'closed' | 'open' | 'half-open';
+export interface CircuitBreakerConfig {
+  threshold: number;
+  timeout: number;
+  windowSize: number;
+  minimumRequests: number;
+}
+export interface CircuitBreakerStatus {
+  state: CircuitState;
+  failureCount: number;
+  successCount: number;
+  failureRate: number;
+  lastError?: Error;
+  timeUntilClose?: number;
+  nextRetryTime?: number;
+}
+export interface DegradedModeStatus {
+  isDegraded: boolean;
+  affectedServices: string[];
+  recoveryStatus: {
+    inProgress: boolean;
+    progress: number;
+    estimatedTime?: number;
+  };
+  degradedSince?: number;
+}
+export interface AgentMetrics {
+  agentName: string;
+  circuitState: CircuitState;
+  successRate: number;
+  averageLatency: number;
+  requestCount: number;
+  errorCount: number;
+  lastError?: Error;
+  lastUpdated: number;
+  activeTasks: number;
+  queuedTasks: number;
+}

package/dist/agents/index.js

@@ -0,0 +1,17 @@
+import '../chunk-OL46QLBJ.js';
+
+// src/agents/index.ts
+var PHASE_ORDER = [
+  "intake",
+  "reflect",
+  "execute",
+  "compress",
+  "reintake",
+  "grow",
+  "evolve",
+  "autonomize"
+];
+
+export { PHASE_ORDER };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map