@carbonenginejs/runtime-resource 0.1.0

package/dist/formats/cmf/core/writer.js

@@ -0,0 +1,517 @@
+import { MeshoptEncoder } from 'meshoptimizer/encoder';
+import { STRUCT_SIZE, FILE_SIGNATURE, FILE_VERSION, SectionType, SectionCompression, MeshTopology, AnimationChannelTargetType, Interpolation, ElementType, Usage } from './constants.js';
+import { crc32 } from './binary.js';
+
+/**
+ * Binary CMF v1 writer.
+ *
+ * Mirrors CarbonEngine's `cmf::BuildFile`: the object graph is flattened into
+ * the Data section as structs with self-relative tagged span offsets
+ * (depth-first in member order, 8-byte chunk alignment, identical leaf chunks
+ * deduplicated), GPU buffers referenced by BufferViews become one section
+ * each (remapped to section indices in first-encounter order, meshoptimizer
+ * compressed by default), optional metadata flattens into a trailing section,
+ * and the header CRC covers everything after the crc32 field.
+ */
+
+const textEncoder = new TextEncoder();
+let encoderReady = false;
+MeshoptEncoder.ready.then(() => {
+  encoderReady = true;
+});
+function writeError(message) {
+  const error = new Error(`CMF write: ${message}`);
+  error.code = "CJS_FORMAT_WRITE_ERROR";
+  return error;
+}
+function enumValue(names, value, label) {
+  if (typeof value === "number") return value;
+  const index = names.indexOf(value);
+  if (index >= 0) return index;
+  const unknown = /^Unknown\((\d+)\)$/u.exec(String(value ?? ""));
+  if (unknown) return Number(unknown[1]);
+  throw writeError(`unknown ${label} value ${JSON.stringify(value)}`);
+}
+
+/**
+ * Growable little-endian struct buffer with tagged span support.
+ */
+class Flattener {
+  #bytes = new Uint8Array(1024);
+  #view = new DataView(this.#bytes.buffer);
+  #chunkCache = new Map();
+  size = 0;
+  #ensure(capacity) {
+    if (capacity <= this.#bytes.length) return;
+    let next = this.#bytes.length * 2;
+    while (next < capacity) next *= 2;
+    const grown = new Uint8Array(next);
+    grown.set(this.#bytes.subarray(0, this.size));
+    this.#bytes = grown;
+    this.#view = new DataView(grown.buffer);
+  }
+  reserve(byteLength) {
+    const offset = this.size;
+    this.#ensure(offset + byteLength);
+    this.#bytes.fill(0, offset, offset + byteLength);
+    this.size = offset + byteLength;
+    return offset;
+  }
+  reserveAligned(byteLength, alignment = 8) {
+    const padded = Math.ceil(this.size / alignment) * alignment;
+    this.#ensure(padded);
+    this.#bytes.fill(0, this.size, padded);
+    this.size = padded;
+    return this.reserve(byteLength);
+  }
+  u8(offset, value) {
+    this.#view.setUint8(offset, value);
+  }
+  u16(offset, value) {
+    this.#view.setUint16(offset, value, true);
+  }
+  u32(offset, value) {
+    this.#view.setUint32(offset, value >>> 0, true);
+  }
+  f32(offset, value) {
+    this.#view.setFloat32(offset, value || 0, true);
+  }
+  i64(offset, value) {
+    this.#view.setBigInt64(offset, BigInt(value), true);
+  }
+  u64(offset, value) {
+    this.#view.setBigUint64(offset, BigInt(value), true);
+  }
+  setBytes(offset, bytes) {
+    this.#bytes.set(bytes, offset);
+  }
+
+  /**
+   * Write a span field and append its element chunk.
+   *
+   * `writeElement(flattener, offset, element)` may itself append nested
+   * chunks; leaf chunks (`dedup: true`) are shared when byte-identical,
+   * matching the reference writer.
+   */
+  span(fieldOffset, elements, elementSize, writeElement, {
+    dedup = false
+  } = {}) {
+    const count = elements ? elements.length : 0;
+    const byteSize = count * elementSize;
+    if (byteSize === 0) {
+      // tagged self-relative offset of 0 keeps span pointers valid
+      this.i64(fieldOffset, 1);
+      this.u64(fieldOffset + 8, 0);
+      return;
+    }
+    if (dedup) {
+      const scratch = new Flattener();
+      const scratchOffset = scratch.reserve(byteSize);
+      for (let i = 0; i < count; i++) writeElement(scratch, scratchOffset + i * elementSize, elements[i]);
+      const chunk = scratch.bytes();
+      const key = chunkKey(chunk);
+      const cached = this.#chunkCache.get(key);
+      if (cached !== undefined && bytesEqual(this.#bytes, cached, chunk)) {
+        this.i64(fieldOffset, cached - fieldOffset | 1);
+        this.u64(fieldOffset + 8, byteSize);
+        return;
+      }
+      const chunkOffset = this.reserveAligned(byteSize);
+      this.setBytes(chunkOffset, chunk);
+      this.#chunkCache.set(key, chunkOffset);
+      this.i64(fieldOffset, chunkOffset - fieldOffset | 1);
+      this.u64(fieldOffset + 8, byteSize);
+      return;
+    }
+    const chunkOffset = this.reserveAligned(byteSize);
+    this.i64(fieldOffset, chunkOffset - fieldOffset | 1);
+    this.u64(fieldOffset + 8, byteSize);
+    for (let i = 0; i < count; i++) writeElement(this, chunkOffset + i * elementSize, elements[i]);
+  }
+  string(fieldOffset, value) {
+    const encoded = textEncoder.encode(value || "");
+    this.span(fieldOffset, encoded, 1, (buffer, offset, byte) => buffer.u8(offset, byte), {
+      dedup: true
+    });
+  }
+  bytes() {
+    return this.#bytes.slice(0, this.size);
+  }
+}
+function chunkKey(bytes) {
+  let hash = 2166136261 >>> 0;
+  for (let i = 0; i < bytes.length; i++) {
+    hash = Math.imul(hash, 16777619) >>> 0;
+    hash = (hash ^ bytes[i]) >>> 0;
+  }
+  return `${bytes.length}:${hash}`;
+}
+function bytesEqual(target, offset, chunk) {
+  for (let i = 0; i < chunk.length; i++) {
+    if (target[offset + i] !== chunk[i]) return false;
+  }
+  return true;
+}
+function writeBounds(buffer, offset, bounds) {
+  const min = bounds?.min || [0, 0, 0];
+  const max = bounds?.max || [0, 0, 0];
+  for (let i = 0; i < 3; i++) buffer.f32(offset + i * 4, min[i]);
+  for (let i = 0; i < 3; i++) buffer.f32(offset + 12 + i * 4, max[i]);
+}
+function writeBufferView(buffer, offset, view, remap) {
+  const size = view?.size || 0;
+  const index = view?.index || 0;
+  buffer.u32(offset, size === 0 ? index : remap.get(index) ?? index);
+  buffer.u32(offset + 4, view?.offset || 0);
+  buffer.u32(offset + 8, size);
+  buffer.u32(offset + 12, view?.stride || 0);
+}
+function writeVertexElement(buffer, offset, element) {
+  buffer.u8(offset, enumValue(Usage, element.usage, "vertex usage"));
+  buffer.u8(offset + 1, element.usageIndex || 0);
+  buffer.u8(offset + 2, enumValue(ElementType, element.type, "element type"));
+  buffer.u8(offset + 3, element.elementCount || 0);
+  buffer.u32(offset + 4, element.offset || 0);
+}
+function writeData(buffer, offset, graph, remap) {
+  const writeMesh = (target, meshOffset, mesh) => {
+    target.string(meshOffset, mesh.name);
+    target.span(meshOffset + 16, mesh.decl || [], STRUCT_SIZE.VertexElement, writeVertexElement, {
+      dedup: true
+    });
+    target.span(meshOffset + 32, mesh.lods || [], STRUCT_SIZE.MeshLod, (lodTarget, lodOffset, lod) => {
+      writeBufferView(lodTarget, lodOffset, lod.vb, remap);
+      writeBufferView(lodTarget, lodOffset + 16, lod.ib, remap);
+      lodTarget.span(lodOffset + 32, lod.areas || [], STRUCT_SIZE.LodMeshArea, (areaTarget, areaOffset, area) => {
+        areaTarget.u32(areaOffset, area.firstElement || 0);
+        areaTarget.u32(areaOffset + 4, area.elementCount || 0);
+      }, {
+        dedup: true
+      });
+      lodTarget.span(lodOffset + 48, lod.morphTargets || [], STRUCT_SIZE.LodMorphTarget, (morphTarget, morphOffset, morph) => {
+        writeBufferView(morphTarget, morphOffset, morph.vb, remap);
+      });
+      lodTarget.u32(lodOffset + 64, lod.threshold ?? 0xffffffff);
+    });
+    target.span(meshOffset + 48, mesh.areas || [], STRUCT_SIZE.MeshArea, (areaTarget, areaOffset, area) => {
+      areaTarget.string(areaOffset, area.name);
+      writeBounds(areaTarget, areaOffset + 16, area.bounds);
+      areaTarget.span(areaOffset + 40, area.bones || [], 2, (boneTarget, boneOffset, bone) => boneTarget.u16(boneOffset, bone), {
+        dedup: true
+      });
+      areaTarget.u8(areaOffset + 56, area.affectedByBones ? 1 : 0);
+      areaTarget.u8(areaOffset + 57, area.affectedByMorphTargets ? 1 : 0);
+    });
+    target.span(meshOffset + 64, mesh.boneBindings || [], STRUCT_SIZE.BoneBinding, (bindingTarget, bindingOffset, binding) => {
+      bindingTarget.string(bindingOffset, binding.name);
+      writeBounds(bindingTarget, bindingOffset + 16, binding.bounds);
+    });
+    target.span(meshOffset + 80, mesh.morphTargets?.decl || [], STRUCT_SIZE.VertexElement, writeVertexElement, {
+      dedup: true
+    });
+    target.span(meshOffset + 96, mesh.morphTargets?.targets || [], STRUCT_SIZE.MorphTarget, (morphTarget, morphOffset, morph) => {
+      morphTarget.string(morphOffset, morph.name);
+      morphTarget.f32(morphOffset + 16, morph.maxDisplacement || 0);
+    });
+    target.span(meshOffset + 112, mesh.uvDensities || [], 4, (densityTarget, densityOffset, value) => densityTarget.f32(densityOffset, value), {
+      dedup: true
+    });
+    writeBounds(target, meshOffset + 128, mesh.bounds);
+    const occlusion = mesh.audioOcclusionMesh || {};
+    target.span(meshOffset + 152, occlusion.vertices || [], 12, (vertexTarget, vertexOffset, vertex) => {
+      for (let i = 0; i < 3; i++) vertexTarget.f32(vertexOffset + i * 4, vertex[i]);
+    }, {
+      dedup: true
+    });
+    target.span(meshOffset + 168, occlusion.indices || [], 2, (indexTarget, indexOffset, index) => indexTarget.u16(indexOffset, index), {
+      dedup: true
+    });
+    writeBounds(target, meshOffset + 184, occlusion.bounds);
+    target.u8(meshOffset + 208, enumValue(MeshTopology, mesh.topology ?? "TriangleList", "topology"));
+    target.u8(meshOffset + 209, mesh.skeleton === null || mesh.skeleton === undefined ? 0xff : mesh.skeleton);
+  };
+  const writeSkeleton = (target, skeletonOffset, skeleton) => {
+    if ((skeleton.bones || []).some(bone => typeof bone !== "string")) {
+      throw writeError("skeleton bones must be name strings; GR2-shaped skeletons need conversion (use writeShared) before writing");
+    }
+    target.string(skeletonOffset, skeleton.name);
+    target.span(skeletonOffset + 16, skeleton.bones || [], 16, (boneTarget, boneOffset, bone) => boneTarget.string(boneOffset, bone));
+    target.span(skeletonOffset + 32, skeleton.parents || [], 4, (parentTarget, parentOffset, parent) => parentTarget.u32(parentOffset, parent), {
+      dedup: true
+    });
+    target.span(skeletonOffset + 48, skeleton.restTransforms || [], STRUCT_SIZE.Transform, (transformTarget, transformOffset, transform) => {
+      const position = transform.position || [0, 0, 0];
+      const rotation = transform.rotation || [0, 0, 0, 1];
+      const scale = transform.scale || [1, 1, 1];
+      for (let i = 0; i < 3; i++) transformTarget.f32(transformOffset + i * 4, position[i]);
+      for (let i = 0; i < 4; i++) transformTarget.f32(transformOffset + 12 + i * 4, rotation[i]);
+      for (let i = 0; i < 3; i++) transformTarget.f32(transformOffset + 28 + i * 4, scale[i]);
+    }, {
+      dedup: true
+    });
+    target.span(skeletonOffset + 64, skeleton.invBindTransforms || [], 64, (matrixTarget, matrixOffset, matrix) => {
+      for (let i = 0; i < 16; i++) matrixTarget.f32(matrixOffset + i * 4, matrix[i]);
+    }, {
+      dedup: true
+    });
+    target.span(skeletonOffset + 80, skeleton.boneMasks || [], STRUCT_SIZE.BoneMask, (maskTarget, maskOffset, mask) => {
+      maskTarget.string(maskOffset, mask.name);
+      maskTarget.span(maskOffset + 16, mask.weights || [], STRUCT_SIZE.BoneWeight, (weightTarget, weightOffset, weight) => {
+        weightTarget.u32(weightOffset, weight.index || 0);
+        weightTarget.f32(weightOffset + 4, weight.weight ?? 1);
+      }, {
+        dedup: true
+      });
+    });
+  };
+  const writeAnimation = (target, animationOffset, animation) => {
+    target.string(animationOffset, animation.name);
+    target.span(animationOffset + 16, animation.channels || [], STRUCT_SIZE.AnimationChannel, (channelTarget, channelOffset, channel) => {
+      channelTarget.string(channelOffset, channel.target);
+      channelTarget.u8(channelOffset + 16, enumValue(AnimationChannelTargetType, channel.targetType, "channel target type"));
+      channelTarget.u32(channelOffset + 20, channel.curveIndex || 0);
+    });
+    target.span(animationOffset + 32, animation.curves || [], STRUCT_SIZE.AnimationCurve, (curveTarget, curveOffset, curve) => {
+      curveTarget.u8(curveOffset, curve.valueDimension || 0);
+      curveTarget.u8(curveOffset + 1, enumValue(Interpolation, curve.interpolation, "interpolation"));
+      curveTarget.u8(curveOffset + 2, enumValue(ElementType, curve.knotType, "knot type"));
+      curveTarget.u8(curveOffset + 3, enumValue(ElementType, curve.valueType, "value type"));
+      curveTarget.u32(curveOffset + 4, curve.knotCount || 0);
+      curveTarget.span(curveOffset + 8, curve.knots || [], 1, (knotTarget, knotOffset, knot) => knotTarget.u8(knotOffset, knot), {
+        dedup: true
+      });
+      curveTarget.span(curveOffset + 24, curve.values || [], 1, (valueTarget, valueOffset, value) => valueTarget.u8(valueOffset, value), {
+        dedup: true
+      });
+    });
+    target.f32(animationOffset + 48, animation.duration || 0);
+  };
+  buffer.span(offset, graph.meshes || [], STRUCT_SIZE.Mesh, writeMesh);
+  buffer.span(offset + 16, graph.skeletons || [], STRUCT_SIZE.Skeleton, writeSkeleton);
+  buffer.span(offset + 32, graph.animations || [], STRUCT_SIZE.Animation, writeAnimation);
+}
+
+/**
+ * Collect BufferView usage in reference-writer order and decide per-buffer
+ * compression (conflicting stride/kind across views falls back to None).
+ */
+function collectBufferRecords(graph, compress) {
+  const records = [];
+  const recordsByIndex = new Map();
+  const visit = (view, compression) => {
+    if (!view || !view.size) return;
+    const existing = recordsByIndex.get(view.index);
+    if (!existing) {
+      const record = {
+        index: view.index,
+        stride: view.stride || 0,
+        compression: compress ? compression : "None"
+      };
+      records.push(record);
+      recordsByIndex.set(view.index, record);
+    } else if (existing.stride !== (view.stride || 0) || (compress ? compression : "None") !== existing.compression) {
+      existing.stride = 0;
+      existing.compression = "None";
+    }
+  };
+  for (const mesh of graph.meshes || []) {
+    for (const lod of mesh.lods || []) {
+      visit(lod.vb, "MeshOptimizerVertexBuffer");
+      visit(lod.ib, "MeshOptimizerIndexBuffer");
+      for (const morph of lod.morphTargets || []) {
+        visit(morph.vb, "MeshOptimizerVertexBuffer");
+      }
+    }
+  }
+  return records;
+}
+function resolveBufferBytes(graph, record) {
+  const buffers = graph.buffers || [];
+  const entry = buffers.find?.(buffer => buffer && buffer.index === record.index) ?? buffers[record.index];
+  const data = entry?.data ?? (entry instanceof Uint8Array ? entry : null);
+  if (!data) {
+    throw writeError(`no buffer data supplied for BufferView index ${record.index}`);
+  }
+  return data instanceof Uint8Array ? data : new Uint8Array(data);
+}
+function compressBuffer(bytes, record) {
+  if (record.compression === "None" || bytes.byteLength === 0) {
+    return {
+      data: bytes,
+      compression: "None",
+      gpuAlignment: record.stride
+    };
+  }
+  if (!encoderReady) {
+    throw writeError("compressed output requires writeAsync/WriteAsync so meshoptimizer can initialize (or pass compress: false)");
+  }
+  if (record.compression === "MeshOptimizerVertexBuffer") {
+    if (record.stride === 0 || bytes.byteLength % record.stride !== 0) {
+      return {
+        data: bytes,
+        compression: "None",
+        gpuAlignment: record.stride
+      };
+    }
+    const count = bytes.byteLength / record.stride;
+    const data = MeshoptEncoder.encodeVertexBuffer(bytes, count, record.stride);
+    return {
+      data,
+      compression: "MeshOptimizerVertexBuffer",
+      gpuAlignment: record.stride
+    };
+  }
+
+  // index buffers: meshopt encodes triangle lists of u32; u16 sources widen
+  const stride = record.stride;
+  if (stride !== 2 && stride !== 4 || bytes.byteLength % stride !== 0) {
+    return {
+      data: bytes,
+      compression: "None",
+      gpuAlignment: stride
+    };
+  }
+  const count = bytes.byteLength / stride;
+  if (count % 3 !== 0) {
+    return {
+      data: bytes,
+      compression: "None",
+      gpuAlignment: stride
+    };
+  }
+  let source = bytes;
+  if (stride === 2) {
+    const wide = new Uint32Array(count);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    for (let i = 0; i < count; i++) wide[i] = view.getUint16(i * 2, true);
+    source = new Uint8Array(wide.buffer);
+  }
+  const data = MeshoptEncoder.encodeIndexBuffer(source, count, 4);
+  return {
+    data,
+    compression: "MeshOptimizerIndexBuffer",
+    gpuAlignment: stride
+  };
+}
+
+/**
+ * Serialize a CMF-native graph into .cmf bytes.
+ *
+ * @param {object} graph Native graph: `{ meshes, skeletons, animations, metadata?, buffers? }`
+ *   where `buffers` supplies uncompressed GPU bytes for each BufferView
+ *   `index` (as `{ index, data }` entries or an index-keyed array).
+ * @param {object} [options] `compress` (default false for the sync writer)
+ *   enables meshoptimizer vertex/index compression.
+ * @returns {Uint8Array} Complete .cmf file bytes.
+ */
+function writeCmf(graph, options = {}) {
+  if (!graph || typeof graph !== "object") {
+    throw writeError("input graph must be an object");
+  }
+  const compress = options.compress === true;
+  const records = collectBufferRecords(graph, compress);
+  const compressed = records.map(record => {
+    const bytes = resolveBufferBytes(graph, record);
+    return {
+      record,
+      ...compressBuffer(bytes, record),
+      uncompressedSize: bytes.byteLength
+    };
+  });
+  const remap = new Map(records.map((record, position) => [record.index, position + 1]));
+  const data = new Flattener();
+  data.reserve(STRUCT_SIZE.Data);
+  writeData(data, 0, graph, remap);
+  const dataBytes = data.bytes();
+  let metadataBytes = null;
+  if (graph.metadata && (graph.metadata.entries || []).length) {
+    const metadata = new Flattener();
+    metadata.reserve(STRUCT_SIZE.Metadata);
+    metadata.span(0, graph.metadata.entries, STRUCT_SIZE.MetadataEntry, (target, offset, entry) => {
+      target.string(offset, entry.key);
+      target.string(offset + 16, entry.value);
+    });
+    metadataBytes = metadata.bytes();
+  }
+  const sections = [{
+    type: "Data",
+    compression: "None",
+    gpuAlignment: 0,
+    compressedSize: dataBytes.byteLength,
+    uncompressedSize: dataBytes.byteLength,
+    data: dataBytes
+  }];
+  for (const entry of compressed) {
+    sections.push({
+      type: "GpuBuffer",
+      compression: entry.compression,
+      gpuAlignment: entry.gpuAlignment,
+      compressedSize: entry.data.byteLength,
+      uncompressedSize: entry.uncompressedSize,
+      data: entry.data
+    });
+  }
+  if (metadataBytes) {
+    sections.push({
+      type: "Metadata",
+      compression: "None",
+      gpuAlignment: 0,
+      compressedSize: metadataBytes.byteLength,
+      uncompressedSize: metadataBytes.byteLength,
+      data: metadataBytes
+    });
+  }
+  const header = new Flattener();
+  header.reserve(STRUCT_SIZE.Header);
+  header.u32(0, FILE_SIGNATURE);
+  header.u32(4, FILE_VERSION);
+  header.span(16, sections, STRUCT_SIZE.Section, () => {});
+  const headerSize = header.size;
+  header.u32(8, headerSize);
+  let offset = headerSize;
+  const sectionOffsets = sections.map(section => {
+    offset = Math.ceil(offset / 8) * 8;
+    const sectionOffset = offset;
+    offset += section.compressedSize;
+    return sectionOffset;
+  });
+  const sectionsChunk = headerSize - sections.length * STRUCT_SIZE.Section;
+  sections.forEach((section, index) => {
+    const base = sectionsChunk + index * STRUCT_SIZE.Section;
+    header.u32(base, sectionOffsets[index]);
+    header.u32(base + 4, section.compressedSize);
+    header.u32(base + 8, section.uncompressedSize);
+    header.u16(base + 12, section.gpuAlignment || 0);
+    header.u8(base + 14, enumValue(SectionType, section.type, "section type"));
+    header.u8(base + 15, enumValue(SectionCompression, section.compression, "section compression"));
+  });
+  const total = offset;
+  const file = new Uint8Array(total);
+  file.set(header.bytes(), 0);
+  sections.forEach((section, index) => {
+    file.set(section.data, sectionOffsets[index]);
+  });
+  const checksum = crc32(file, 16, file.byteLength);
+  new DataView(file.buffer).setUint32(12, checksum, true);
+  return file;
+}
+
+/**
+ * Serialize a CMF-native graph asynchronously with compression enabled by
+ * default (awaits meshoptimizer encoder initialization).
+ *
+ * @param {object} graph Native graph (see `writeCmf`).
+ * @param {object} [options] `compress` defaults to true.
+ * @returns {Promise<Uint8Array>} Complete .cmf file bytes.
+ */
+async function writeCmfAsync(graph, options = {}) {
+  await MeshoptEncoder.ready;
+  encoderReady = true;
+  return writeCmf(graph, {
+    ...options,
+    compress: options.compress !== false
+  });
+}
+
+export { writeCmf, writeCmfAsync };
+//# sourceMappingURL=writer.js.map

package/dist/formats/cmf/core/writer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.js","sources":["../../../../../src/formats/cmf/core/writer.js"],"sourcesContent":["import { MeshoptEncoder } from \"meshoptimizer/encoder\";\nimport {\n    AnimationChannelTargetType,\n    ElementType,\n    FILE_SIGNATURE,\n    FILE_VERSION,\n    Interpolation,\n    MeshTopology,\n    STRUCT_SIZE,\n    SectionCompression,\n    SectionType,\n    Usage\n} from \"./constants.js\";\nimport { crc32 } from \"./binary.js\";\n\n/**\n * Binary CMF v1 writer.\n *\n * Mirrors CarbonEngine's `cmf::BuildFile`: the object graph is flattened into\n * the Data section as structs with self-relative tagged span offsets\n * (depth-first in member order, 8-byte chunk alignment, identical leaf chunks\n * deduplicated), GPU buffers referenced by BufferViews become one section\n * each (remapped to section indices in first-encounter order, meshoptimizer\n * compressed by default), optional metadata flattens into a trailing section,\n * and the header CRC covers everything after the crc32 field.\n */\n\nconst textEncoder = new TextEncoder();\n\nlet encoderReady = false;\nMeshoptEncoder.ready.then(() => { encoderReady = true; });\n\nfunction writeError(message)\n{\n    const error = new Error(`CMF write: ${message}`);\n    error.code = \"CJS_FORMAT_WRITE_ERROR\";\n    return error;\n}\n\nfunction enumValue(names, value, label)\n{\n    if (typeof value === \"number\") return value;\n    const index = names.indexOf(value);\n    if (index >= 0) return index;\n    const unknown = /^Unknown\\((\\d+)\\)$/u.exec(String(value ?? \"\"));\n    if (unknown) return Number(unknown[1]);\n    throw writeError(`unknown ${label} value ${JSON.stringify(value)}`);\n}\n\n/**\n * Growable little-endian struct buffer with tagged span support.\n */\nclass Flattener\n{\n    #bytes = new Uint8Array(1024);\n    #view = new DataView(this.#bytes.buffer);\n    #chunkCache = new Map();\n    size = 0;\n\n    #ensure(capacity)\n    {\n        if (capacity <= this.#bytes.length) return;\n        let next = this.#bytes.length * 2;\n        while (next < capacity) next *= 2;\n        const grown = new Uint8Array(next);\n        grown.set(this.#bytes.subarray(0, this.size));\n        this.#bytes = grown;\n        this.#view = new DataView(grown.buffer);\n    }\n\n    reserve(byteLength)\n    {\n        const offset = this.size;\n        this.#ensure(offset + byteLength);\n        this.#bytes.fill(0, offset, offset + byteLength);\n        this.size = offset + byteLength;\n        return offset;\n    }\n\n    reserveAligned(byteLength, alignment = 8)\n    {\n        const padded = Math.ceil(this.size / alignment) * alignment;\n        this.#ensure(padded);\n        this.#bytes.fill(0, this.size, padded);\n        this.size = padded;\n        return this.reserve(byteLength);\n    }\n\n    u8(offset, value) { this.#view.setUint8(offset, value); }\n    u16(offset, value) { this.#view.setUint16(offset, value, true); }\n    u32(offset, value) { this.#view.setUint32(offset, value >>> 0, true); }\n    f32(offset, value) { this.#view.setFloat32(offset, value || 0, true); }\n    i64(offset, value) { this.#view.setBigInt64(offset, BigInt(value), true); }\n    u64(offset, value) { this.#view.setBigUint64(offset, BigInt(value), true); }\n\n    setBytes(offset, bytes)\n    {\n        this.#bytes.set(bytes, offset);\n    }\n\n    /**\n     * Write a span field and append its element chunk.\n     *\n     * `writeElement(flattener, offset, element)` may itself append nested\n     * chunks; leaf chunks (`dedup: true`) are shared when byte-identical,\n     * matching the reference writer.\n     */\n    span(fieldOffset, elements, elementSize, writeElement, { dedup = false } = {})\n    {\n        const count = elements ? elements.length : 0;\n        const byteSize = count * elementSize;\n        if (byteSize === 0)\n        {\n            // tagged self-relative offset of 0 keeps span pointers valid\n            this.i64(fieldOffset, 1);\n            this.u64(fieldOffset + 8, 0);\n            return;\n        }\n\n        if (dedup)\n        {\n            const scratch = new Flattener();\n            const scratchOffset = scratch.reserve(byteSize);\n            for (let i = 0; i < count; i++) writeElement(scratch, scratchOffset + i * elementSize, elements[i]);\n            const chunk = scratch.bytes();\n            const key = chunkKey(chunk);\n            const cached = this.#chunkCache.get(key);\n            if (cached !== undefined && bytesEqual(this.#bytes, cached, chunk))\n            {\n                this.i64(fieldOffset, ((cached - fieldOffset) | 1));\n                this.u64(fieldOffset + 8, byteSize);\n                return;\n            }\n            const chunkOffset = this.reserveAligned(byteSize);\n            this.setBytes(chunkOffset, chunk);\n            this.#chunkCache.set(key, chunkOffset);\n            this.i64(fieldOffset, ((chunkOffset - fieldOffset) | 1));\n            this.u64(fieldOffset + 8, byteSize);\n            return;\n        }\n\n        const chunkOffset = this.reserveAligned(byteSize);\n        this.i64(fieldOffset, ((chunkOffset - fieldOffset) | 1));\n        this.u64(fieldOffset + 8, byteSize);\n        for (let i = 0; i < count; i++) writeElement(this, chunkOffset + i * elementSize, elements[i]);\n    }\n\n    string(fieldOffset, value)\n    {\n        const encoded = textEncoder.encode(value || \"\");\n        this.span(fieldOffset, encoded, 1, (buffer, offset, byte) => buffer.u8(offset, byte), { dedup: true });\n    }\n\n    bytes()\n    {\n        return this.#bytes.slice(0, this.size);\n    }\n}\n\nfunction chunkKey(bytes)\n{\n    let hash = 2166136261 >>> 0;\n    for (let i = 0; i < bytes.length; i++)\n    {\n        hash = Math.imul(hash, 16777619) >>> 0;\n        hash = (hash ^ bytes[i]) >>> 0;\n    }\n    return `${bytes.length}:${hash}`;\n}\n\nfunction bytesEqual(target, offset, chunk)\n{\n    for (let i = 0; i < chunk.length; i++)\n    {\n        if (target[offset + i] !== chunk[i]) return false;\n    }\n    return true;\n}\n\nfunction writeBounds(buffer, offset, bounds)\n{\n    const min = bounds?.min || [ 0, 0, 0 ];\n    const max = bounds?.max || [ 0, 0, 0 ];\n    for (let i = 0; i < 3; i++) buffer.f32(offset + i * 4, min[i]);\n    for (let i = 0; i < 3; i++) buffer.f32(offset + 12 + i * 4, max[i]);\n}\n\nfunction writeBufferView(buffer, offset, view, remap)\n{\n    const size = view?.size || 0;\n    const index = view?.index || 0;\n    buffer.u32(offset, size === 0 ? index : (remap.get(index) ?? index));\n    buffer.u32(offset + 4, view?.offset || 0);\n    buffer.u32(offset + 8, size);\n    buffer.u32(offset + 12, view?.stride || 0);\n}\n\nfunction writeVertexElement(buffer, offset, element)\n{\n    buffer.u8(offset, enumValue(Usage, element.usage, \"vertex usage\"));\n    buffer.u8(offset + 1, element.usageIndex || 0);\n    buffer.u8(offset + 2, enumValue(ElementType, element.type, \"element type\"));\n    buffer.u8(offset + 3, element.elementCount || 0);\n    buffer.u32(offset + 4, element.offset || 0);\n}\n\nfunction writeData(buffer, offset, graph, remap)\n{\n    const writeMesh = (target, meshOffset, mesh) =>\n    {\n        target.string(meshOffset, mesh.name);\n        target.span(meshOffset + 16, mesh.decl || [], STRUCT_SIZE.VertexElement, writeVertexElement, { dedup: true });\n        target.span(meshOffset + 32, mesh.lods || [], STRUCT_SIZE.MeshLod, (lodTarget, lodOffset, lod) =>\n        {\n            writeBufferView(lodTarget, lodOffset, lod.vb, remap);\n            writeBufferView(lodTarget, lodOffset + 16, lod.ib, remap);\n            lodTarget.span(lodOffset + 32, lod.areas || [], STRUCT_SIZE.LodMeshArea, (areaTarget, areaOffset, area) =>\n            {\n                areaTarget.u32(areaOffset, area.firstElement || 0);\n                areaTarget.u32(areaOffset + 4, area.elementCount || 0);\n            }, { dedup: true });\n            lodTarget.span(lodOffset + 48, lod.morphTargets || [], STRUCT_SIZE.LodMorphTarget, (morphTarget, morphOffset, morph) =>\n            {\n                writeBufferView(morphTarget, morphOffset, morph.vb, remap);\n            });\n            lodTarget.u32(lodOffset + 64, lod.threshold ?? 0xffffffff);\n        });\n        target.span(meshOffset + 48, mesh.areas || [], STRUCT_SIZE.MeshArea, (areaTarget, areaOffset, area) =>\n        {\n            areaTarget.string(areaOffset, area.name);\n            writeBounds(areaTarget, areaOffset + 16, area.bounds);\n            areaTarget.span(areaOffset + 40, area.bones || [], 2, (boneTarget, boneOffset, bone) => boneTarget.u16(boneOffset, bone), { dedup: true });\n            areaTarget.u8(areaOffset + 56, area.affectedByBones ? 1 : 0);\n            areaTarget.u8(areaOffset + 57, area.affectedByMorphTargets ? 1 : 0);\n        });\n        target.span(meshOffset + 64, mesh.boneBindings || [], STRUCT_SIZE.BoneBinding, (bindingTarget, bindingOffset, binding) =>\n        {\n            bindingTarget.string(bindingOffset, binding.name);\n            writeBounds(bindingTarget, bindingOffset + 16, binding.bounds);\n        });\n        target.span(meshOffset + 80, mesh.morphTargets?.decl || [], STRUCT_SIZE.VertexElement, writeVertexElement, { dedup: true });\n        target.span(meshOffset + 96, mesh.morphTargets?.targets || [], STRUCT_SIZE.MorphTarget, (morphTarget, morphOffset, morph) =>\n        {\n            morphTarget.string(morphOffset, morph.name);\n            morphTarget.f32(morphOffset + 16, morph.maxDisplacement || 0);\n        });\n        target.span(meshOffset + 112, mesh.uvDensities || [], 4, (densityTarget, densityOffset, value) => densityTarget.f32(densityOffset, value), { dedup: true });\n        writeBounds(target, meshOffset + 128, mesh.bounds);\n        const occlusion = mesh.audioOcclusionMesh || {};\n        target.span(meshOffset + 152, occlusion.vertices || [], 12, (vertexTarget, vertexOffset, vertex) =>\n        {\n            for (let i = 0; i < 3; i++) vertexTarget.f32(vertexOffset + i * 4, vertex[i]);\n        }, { dedup: true });\n        target.span(meshOffset + 168, occlusion.indices || [], 2, (indexTarget, indexOffset, index) => indexTarget.u16(indexOffset, index), { dedup: true });\n        writeBounds(target, meshOffset + 184, occlusion.bounds);\n        target.u8(meshOffset + 208, enumValue(MeshTopology, mesh.topology ?? \"TriangleList\", \"topology\"));\n        target.u8(meshOffset + 209, mesh.skeleton === null || mesh.skeleton === undefined ? 0xff : mesh.skeleton);\n    };\n\n    const writeSkeleton = (target, skeletonOffset, skeleton) =>\n    {\n        if ((skeleton.bones || []).some((bone) => typeof bone !== \"string\"))\n        {\n            throw writeError(\n                \"skeleton bones must be name strings; GR2-shaped skeletons need conversion (use writeShared) before writing\"\n            );\n        }\n        target.string(skeletonOffset, skeleton.name);\n        target.span(skeletonOffset + 16, skeleton.bones || [], 16, (boneTarget, boneOffset, bone) => boneTarget.string(boneOffset, bone));\n        target.span(skeletonOffset + 32, skeleton.parents || [], 4, (parentTarget, parentOffset, parent) => parentTarget.u32(parentOffset, parent), { dedup: true });\n        target.span(skeletonOffset + 48, skeleton.restTransforms || [], STRUCT_SIZE.Transform, (transformTarget, transformOffset, transform) =>\n        {\n            const position = transform.position || [ 0, 0, 0 ];\n            const rotation = transform.rotation || [ 0, 0, 0, 1 ];\n            const scale = transform.scale || [ 1, 1, 1 ];\n            for (let i = 0; i < 3; i++) transformTarget.f32(transformOffset + i * 4, position[i]);\n            for (let i = 0; i < 4; i++) transformTarget.f32(transformOffset + 12 + i * 4, rotation[i]);\n            for (let i = 0; i < 3; i++) transformTarget.f32(transformOffset + 28 + i * 4, scale[i]);\n        }, { dedup: true });\n        target.span(skeletonOffset + 64, skeleton.invBindTransforms || [], 64, (matrixTarget, matrixOffset, matrix) =>\n        {\n            for (let i = 0; i < 16; i++) matrixTarget.f32(matrixOffset + i * 4, matrix[i]);\n        }, { dedup: true });\n        target.span(skeletonOffset + 80, skeleton.boneMasks || [], STRUCT_SIZE.BoneMask, (maskTarget, maskOffset, mask) =>\n        {\n            maskTarget.string(maskOffset, mask.name);\n            maskTarget.span(maskOffset + 16, mask.weights || [], STRUCT_SIZE.BoneWeight, (weightTarget, weightOffset, weight) =>\n            {\n                weightTarget.u32(weightOffset, weight.index || 0);\n                weightTarget.f32(weightOffset + 4, weight.weight ?? 1);\n            }, { dedup: true });\n        });\n    };\n\n    const writeAnimation = (target, animationOffset, animation) =>\n    {\n        target.string(animationOffset, animation.name);\n        target.span(animationOffset + 16, animation.channels || [], STRUCT_SIZE.AnimationChannel, (channelTarget, channelOffset, channel) =>\n        {\n            channelTarget.string(channelOffset, channel.target);\n            channelTarget.u8(channelOffset + 16, enumValue(AnimationChannelTargetType, channel.targetType, \"channel target type\"));\n            channelTarget.u32(channelOffset + 20, channel.curveIndex || 0);\n        });\n        target.span(animationOffset + 32, animation.curves || [], STRUCT_SIZE.AnimationCurve, (curveTarget, curveOffset, curve) =>\n        {\n            curveTarget.u8(curveOffset, curve.valueDimension || 0);\n            curveTarget.u8(curveOffset + 1, enumValue(Interpolation, curve.interpolation, \"interpolation\"));\n            curveTarget.u8(curveOffset + 2, enumValue(ElementType, curve.knotType, \"knot type\"));\n            curveTarget.u8(curveOffset + 3, enumValue(ElementType, curve.valueType, \"value type\"));\n            curveTarget.u32(curveOffset + 4, curve.knotCount || 0);\n            curveTarget.span(curveOffset + 8, curve.knots || [], 1, (knotTarget, knotOffset, knot) => knotTarget.u8(knotOffset, knot), { dedup: true });\n            curveTarget.span(curveOffset + 24, curve.values || [], 1, (valueTarget, valueOffset, value) => valueTarget.u8(valueOffset, value), { dedup: true });\n        });\n        target.f32(animationOffset + 48, animation.duration || 0);\n    };\n\n    buffer.span(offset, graph.meshes || [], STRUCT_SIZE.Mesh, writeMesh);\n    buffer.span(offset + 16, graph.skeletons || [], STRUCT_SIZE.Skeleton, writeSkeleton);\n    buffer.span(offset + 32, graph.animations || [], STRUCT_SIZE.Animation, writeAnimation);\n}\n\n/**\n * Collect BufferView usage in reference-writer order and decide per-buffer\n * compression (conflicting stride/kind across views falls back to None).\n */\nfunction collectBufferRecords(graph, compress)\n{\n    const records = [];\n    const recordsByIndex = new Map();\n    const visit = (view, compression) =>\n    {\n        if (!view || !view.size) return;\n        const existing = recordsByIndex.get(view.index);\n        if (!existing)\n        {\n            const record = {\n                index: view.index,\n                stride: view.stride || 0,\n                compression: compress ? compression : \"None\"\n            };\n            records.push(record);\n            recordsByIndex.set(view.index, record);\n        }\n        else if (existing.stride !== (view.stride || 0) || (compress ? compression : \"None\") !== existing.compression)\n        {\n            existing.stride = 0;\n            existing.compression = \"None\";\n        }\n    };\n\n    for (const mesh of graph.meshes || [])\n    {\n        for (const lod of mesh.lods || [])\n        {\n            visit(lod.vb, \"MeshOptimizerVertexBuffer\");\n            visit(lod.ib, \"MeshOptimizerIndexBuffer\");\n            for (const morph of lod.morphTargets || [])\n            {\n                visit(morph.vb, \"MeshOptimizerVertexBuffer\");\n            }\n        }\n    }\n    return records;\n}\n\nfunction resolveBufferBytes(graph, record)\n{\n    const buffers = graph.buffers || [];\n    const entry = buffers.find?.((buffer) => buffer && buffer.index === record.index) ?? buffers[record.index];\n    const data = entry?.data ?? (entry instanceof Uint8Array ? entry : null);\n    if (!data)\n    {\n        throw writeError(`no buffer data supplied for BufferView index ${record.index}`);\n    }\n    return data instanceof Uint8Array ? data : new Uint8Array(data);\n}\n\nfunction compressBuffer(bytes, record)\n{\n    if (record.compression === \"None\" || bytes.byteLength === 0)\n    {\n        return { data: bytes, compression: \"None\", gpuAlignment: record.stride };\n    }\n    if (!encoderReady)\n    {\n        throw writeError(\"compressed output requires writeAsync/WriteAsync so meshoptimizer can initialize (or pass compress: false)\");\n    }\n\n    if (record.compression === \"MeshOptimizerVertexBuffer\")\n    {\n        if (record.stride === 0 || bytes.byteLength % record.stride !== 0)\n        {\n            return { data: bytes, compression: \"None\", gpuAlignment: record.stride };\n        }\n        const count = bytes.byteLength / record.stride;\n        const data = MeshoptEncoder.encodeVertexBuffer(bytes, count, record.stride);\n        return { data, compression: \"MeshOptimizerVertexBuffer\", gpuAlignment: record.stride };\n    }\n\n    // index buffers: meshopt encodes triangle lists of u32; u16 sources widen\n    const stride = record.stride;\n    if ((stride !== 2 && stride !== 4) || bytes.byteLength % stride !== 0)\n    {\n        return { data: bytes, compression: \"None\", gpuAlignment: stride };\n    }\n    const count = bytes.byteLength / stride;\n    if (count % 3 !== 0)\n    {\n        return { data: bytes, compression: \"None\", gpuAlignment: stride };\n    }\n    let source = bytes;\n    if (stride === 2)\n    {\n        const wide = new Uint32Array(count);\n        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n        for (let i = 0; i < count; i++) wide[i] = view.getUint16(i * 2, true);\n        source = new Uint8Array(wide.buffer);\n    }\n    const data = MeshoptEncoder.encodeIndexBuffer(source, count, 4);\n    return { data, compression: \"MeshOptimizerIndexBuffer\", gpuAlignment: stride };\n}\n\n/**\n * Serialize a CMF-native graph into .cmf bytes.\n *\n * @param {object} graph Native graph: `{ meshes, skeletons, animations, metadata?, buffers? }`\n *   where `buffers` supplies uncompressed GPU bytes for each BufferView\n *   `index` (as `{ index, data }` entries or an index-keyed array).\n * @param {object} [options] `compress` (default false for the sync writer)\n *   enables meshoptimizer vertex/index compression.\n * @returns {Uint8Array} Complete .cmf file bytes.\n */\nexport function writeCmf(graph, options = {})\n{\n    if (!graph || typeof graph !== \"object\")\n    {\n        throw writeError(\"input graph must be an object\");\n    }\n    const compress = options.compress === true;\n\n    const records = collectBufferRecords(graph, compress);\n    const compressed = records.map((record) =>\n    {\n        const bytes = resolveBufferBytes(graph, record);\n        return { record, ...compressBuffer(bytes, record), uncompressedSize: bytes.byteLength };\n    });\n    const remap = new Map(records.map((record, position) => [ record.index, position + 1 ]));\n\n    const data = new Flattener();\n    data.reserve(STRUCT_SIZE.Data);\n    writeData(data, 0, graph, remap);\n    const dataBytes = data.bytes();\n\n    let metadataBytes = null;\n    if (graph.metadata && (graph.metadata.entries || []).length)\n    {\n        const metadata = new Flattener();\n        metadata.reserve(STRUCT_SIZE.Metadata);\n        metadata.span(0, graph.metadata.entries, STRUCT_SIZE.MetadataEntry, (target, offset, entry) =>\n        {\n            target.string(offset, entry.key);\n            target.string(offset + 16, entry.value);\n        });\n        metadataBytes = metadata.bytes();\n    }\n\n    const sections = [\n        { type: \"Data\", compression: \"None\", gpuAlignment: 0, compressedSize: dataBytes.byteLength, uncompressedSize: dataBytes.byteLength, data: dataBytes }\n    ];\n    for (const entry of compressed)\n    {\n        sections.push({\n            type: \"GpuBuffer\",\n            compression: entry.compression,\n            gpuAlignment: entry.gpuAlignment,\n            compressedSize: entry.data.byteLength,\n            uncompressedSize: entry.uncompressedSize,\n            data: entry.data\n        });\n    }\n    if (metadataBytes)\n    {\n        sections.push({ type: \"Metadata\", compression: \"None\", gpuAlignment: 0, compressedSize: metadataBytes.byteLength, uncompressedSize: metadataBytes.byteLength, data: metadataBytes });\n    }\n\n    const header = new Flattener();\n    header.reserve(STRUCT_SIZE.Header);\n    header.u32(0, FILE_SIGNATURE);\n    header.u32(4, FILE_VERSION);\n    header.span(16, sections, STRUCT_SIZE.Section, () => {});\n    const headerSize = header.size;\n    header.u32(8, headerSize);\n\n    let offset = headerSize;\n    const sectionOffsets = sections.map((section) =>\n    {\n        offset = Math.ceil(offset / 8) * 8;\n        const sectionOffset = offset;\n        offset += section.compressedSize;\n        return sectionOffset;\n    });\n\n    const sectionsChunk = headerSize - sections.length * STRUCT_SIZE.Section;\n    sections.forEach((section, index) =>\n    {\n        const base = sectionsChunk + index * STRUCT_SIZE.Section;\n        header.u32(base, sectionOffsets[index]);\n        header.u32(base + 4, section.compressedSize);\n        header.u32(base + 8, section.uncompressedSize);\n        header.u16(base + 12, section.gpuAlignment || 0);\n        header.u8(base + 14, enumValue(SectionType, section.type, \"section type\"));\n        header.u8(base + 15, enumValue(SectionCompression, section.compression, \"section compression\"));\n    });\n\n    const total = offset;\n    const file = new Uint8Array(total);\n    file.set(header.bytes(), 0);\n    sections.forEach((section, index) =>\n    {\n        file.set(section.data, sectionOffsets[index]);\n    });\n\n    const checksum = crc32(file, 16, file.byteLength);\n    new DataView(file.buffer).setUint32(12, checksum, true);\n    return file;\n}\n\n/**\n * Serialize a CMF-native graph asynchronously with compression enabled by\n * default (awaits meshoptimizer encoder initialization).\n *\n * @param {object} graph Native graph (see `writeCmf`).\n * @param {object} [options] `compress` defaults to true.\n * @returns {Promise<Uint8Array>} Complete .cmf file bytes.\n */\nexport async function writeCmfAsync(graph, options = {})\n{\n    await MeshoptEncoder.ready;\n    encoderReady = true;\n    return writeCmf(graph, { ...options, compress: options.compress !== false });\n}\n"],"names":["textEncoder","TextEncoder","encoderReady","MeshoptEncoder","ready","then","writeError","message","error","Error","code","enumValue","names","value","label","index","indexOf","unknown","exec","String","Number","JSON","stringify","Flattener","Uint8Array","DataView","buffer","Map","size","#ensure","capacity","length","next","grown","set","subarray","reserve","byteLength","offset","fill","reserveAligned","alignment","padded","Math","ceil","u8","setUint8","u16","setUint16","u32","setUint32","f32","setFloat32","i64","setBigInt64","BigInt","u64","setBigUint64","setBytes","bytes","span","fieldOffset","elements","elementSize","writeElement","dedup","count","byteSize","scratch","scratchOffset","i","chunk","key","chunkKey","cached","get","undefined","bytesEqual","chunkOffset","string","encoded","encode","byte","slice","hash","imul","target","writeBounds","bounds","min","max","writeBufferView","view","remap","stride","writeVertexElement","element","Usage","usage","usageIndex","ElementType","type","elementCount","writeData","graph","writeMesh","meshOffset","mesh","name","decl","STRUCT_SIZE","VertexElement","lods","MeshLod","lodTarget","lodOffset","lod","vb","ib","areas","LodMeshArea","areaTarget","areaOffset","area","firstElement","morphTargets","LodMorphTarget","morphTarget","morphOffset","morph","threshold","MeshArea","bones","boneTarget","boneOffset","bone","affectedByBones","affectedByMorphTargets","boneBindings","BoneBinding","bindingTarget","bindingOffset","binding","targets","MorphTarget","maxDisplacement","uvDensities","densityTarget","densityOffset","occlusion","audioOcclusionMesh","vertices","vertexTarget","vertexOffset","vertex","indices","indexTarget","indexOffset","MeshTopology","topology","skeleton","writeSkeleton","skeletonOffset","some","parents","parentTarget","parentOffset","parent","restTransforms","Transform","transformTarget","transformOffset","transform","position","rotation","scale","invBindTransforms","matrixTarget","matrixOffset","matrix","boneMasks","BoneMask","maskTarget","maskOffset","mask","weights","BoneWeight","weightTarget","weightOffset","weight","writeAnimation","animationOffset","animation","channels","AnimationChannel","channelTarget","channelOffset","channel","AnimationChannelTargetType","targetType","curveIndex","curves","AnimationCurve","curveTarget","curveOffset","curve","valueDimension","Interpolation","interpolation","knotType","valueType","knotCount","knots","knotTarget","knotOffset","knot","values","valueTarget","valueOffset","duration","meshes","Mesh","skeletons","Skeleton","animations","Animation","collectBufferRecords","compress","records","recordsByIndex","visit","compression","existing","record","push","resolveBufferBytes","buffers","entry","find","data","compressBuffer","gpuAlignment","encodeVertexBuffer","source","wide","Uint32Array","byteOffset","getUint16","encodeIndexBuffer","writeCmf","options","compressed","map","uncompressedSize","Data","dataBytes","metadataBytes","metadata","entries","Metadata","MetadataEntry","sections","compressedSize","header","Header","FILE_SIGNATURE","FILE_VERSION","Section","headerSize","sectionOffsets","section","sectionOffset","sectionsChunk","forEach","base","SectionType","SectionCompression","total","file","checksum","crc32","writeCmfAsync"],"mappings":"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"}

package/dist/formats/cmf/index.js

@@ -0,0 +1,2 @@
+export { CjsCmfFormat, CjsCmfFormat as default } from './CjsCmfFormat.js';
+//# sourceMappingURL=index.js.map

package/dist/formats/cmf/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}