@carbonenginejs/runtime-resource 0.8.0 → 0.9.0

package/dist/formats/gltf/core/targets.js

@@ -1,163 +1,163 @@
-const CMF_CLASS_KEYS = Object.freeze(["Root", "Section", "Metadata", "MetadataEntry", "Mesh", "IndexGroup", "VertexElement", "MeshLod", "MeshArea", "LodMeshArea", "BoneBinding", "MorphTargets", "MorphTarget", "LodMorphTarget", "AudioOcclusionMesh", "Skeleton", "BoneMask", "BoneWeight", "Animation", "AnimationChannel", "AnimationCurve"]);
-function buildCmfFromShared(root) {
-  return {
-    version: 1,
-    metadata: null,
-    meshes: (root.meshes ?? []).map(mesh => buildMesh(mesh)),
-    skeletons: [],
-    animations: []
-  };
-}
-function buildMesh(mesh) {
-  const vertex = mesh.vertex ?? {},
-    indices = mesh.indices ?? [],
-    stride = estimateVertexStride(vertex),
-    vertexCount = stride === 0 ? 0 : Math.floor((vertex.position ?? []).length / 3);
-  return {
-    name: mesh.name ?? "",
-    decl: buildDecl(vertex),
-    lods: [{
-      vb: {
-        index: 1,
-        offset: 0,
-        size: vertexCount * stride,
-        stride
-      },
-      ib: {
-        index: 2,
-        offset: 0,
-        size: totalIndexCount(indices) * bytesPerIndex(indices),
-        stride: bytesPerIndex(indices)
-      },
-      areas: indices.map((group, index) => ({
-        firstElement: firstTriangle(indices, index),
-        elementCount: Math.floor((group.faces ?? []).length / 3)
-      })),
-      morphTargets: [],
-      threshold: 0xffffffff,
-      vertex,
-      indices
-    }],
-    areas: indices.map(group => ({
-      name: group.name ?? "",
-      bounds: bounds(mesh),
-      bones: [],
-      affectedByBones: false,
-      affectedByMorphTargets: false
-    })),
-    boneBindings: [],
-    morphTargets: {
-      decl: [],
-      targets: []
-    },
-    uvDensities: [],
-    bounds: bounds(mesh),
-    audioOcclusionMesh: {
-      vertices: [],
-      indices: [],
-      bounds: {
-        min: [0, 0, 0],
-        max: [0, 0, 0]
-      }
-    },
-    topology: "TriangleList",
-    skeleton: null,
-    vertex,
-    indices
-  };
-}
-function buildDecl(vertex) {
-  const decl = [];
-  let offset = 0;
-  for (const channel of [["position", "Position", 3], ["normal", "Normal", 3], ["tangent", "Tangent", 3], ["binormal", "Binormal", 3], ["texcoord0", "TexCoord", 2, 0], ["texcoord1", "TexCoord", 2, 1], ["color0", "Color", 4, 0], ["blendIndice", "BoneIndices", 4, 0, "UInt16"], ["blendWeight", "BoneWeights", 4, 0]]) {
-    const [name, usage, elementCount, usageIndex = 0, type = "Float32"] = channel;
-    if (!Array.isArray(vertex[name]) || vertex[name].length === 0) continue;
-    decl.push({
-      usage,
-      usageIndex,
-      type,
-      elementCount,
-      offset
-    });
-    offset += elementCount * elementTypeSize(type);
-  }
-  return decl;
-}
-function estimateVertexStride(vertex) {
-  return buildDecl(vertex).reduce((stride, element) => Math.max(stride, element.offset + element.elementCount * elementTypeSize(element.type)), 0);
-}
-function elementTypeSize(type) {
-  return type === "Float32" ? 4 : type.includes("16") ? 2 : 1;
-}
-function totalIndexCount(indices) {
-  return indices.reduce((total, group) => total + (group.faces?.length ?? 0), 0);
-}
-function bytesPerIndex(indices) {
-  return indices.some(group => group.bytesPerIndex === 4 || (group.faces ?? []).some(index => index > 0xffff)) ? 4 : 2;
-}
-function firstTriangle(indices, areaIndex) {
-  let first = 0;
-  for (let i = 0; i < areaIndex; i++) first += Math.floor((indices[i].faces ?? []).length / 3);
-  return first;
-}
-function bounds(mesh) {
-  return {
-    min: mesh.minBounds ?? [0, 0, 0],
-    max: mesh.maxBounds ?? [0, 0, 0]
-  };
-}
-function hydrateCmf(root, classes, hydrationOptions = {}) {
-  const hydrationClasses = createHydrationClasses(classes, hydrationOptions);
-  return hydrate("Root", {
-    ...root,
-    metadata: root.metadata ? hydrate("Metadata", root.metadata, hydrationClasses) : null,
-    meshes: root.meshes.map(mesh => hydrateMesh(mesh, hydrationClasses)),
-    skeletons: root.skeletons.map(skeleton => hydrate("Skeleton", skeleton, hydrationClasses)),
-    animations: root.animations.map(animation => hydrate("Animation", animation, hydrationClasses))
-  }, hydrationClasses, hydrationOptions);
-}
-function hydrateMesh(mesh, classes) {
-  return hydrate("Mesh", {
-    ...mesh,
-    decl: mesh.decl.map(element => hydrate("VertexElement", element, classes)),
-    lods: mesh.lods.map(lod => hydrate("MeshLod", {
-      ...lod,
-      areas: lod.areas.map(area => hydrate("LodMeshArea", area, classes)),
-      morphTargets: lod.morphTargets.map(target => hydrate("LodMorphTarget", target, classes))
-    }, classes)),
-    areas: mesh.areas.map(area => hydrate("MeshArea", area, classes)),
-    boneBindings: mesh.boneBindings.map(binding => hydrate("BoneBinding", binding, classes)),
-    morphTargets: hydrate("MorphTargets", {
-      decl: mesh.morphTargets.decl.map(element => hydrate("VertexElement", element, classes)),
-      targets: mesh.morphTargets.targets.map(target => hydrate("MorphTarget", target, classes))
-    }, classes),
-    audioOcclusionMesh: hydrate("AudioOcclusionMesh", mesh.audioOcclusionMesh, classes)
-  }, classes);
-}
-function hydrate(type, fields, classes, hydrationOptions = {}) {
-  const Class = classes?.[type];
-  const options = Object.keys(hydrationOptions).length > 0 ? hydrationOptions : classes?.__hydrationOptions || {};
-  return Class ? populate(new Class(), fields, options) : fields;
-}
-function populate(instance, fields, hydrationOptions = {}) {
-  if (!instance || typeof instance.SetValues !== "function") {
-    throw new TypeError("CjsGltfFormat CMF class population requires classes to implement SetValues(values)");
-  }
-  instance.SetValues(fields, {
-    ...hydrationOptions,
-    skipUpdate: true,
-    skipEvents: true
-  });
-  return instance;
-}
-function createHydrationClasses(classes, hydrationOptions) {
-  const map = Object.create(classes || null);
-  Object.defineProperty(map, "__hydrationOptions", {
-    value: hydrationOptions,
-    enumerable: false
-  });
-  return map;
-}
-
-export { CMF_CLASS_KEYS, buildCmfFromShared, hydrateCmf };
-//# sourceMappingURL=targets.js.map
+const CMF_CLASS_KEYS = Object.freeze(["Root", "Section", "Metadata", "MetadataEntry", "Mesh", "IndexGroup", "VertexElement", "MeshLod", "MeshArea", "LodMeshArea", "BoneBinding", "MorphTargets", "MorphTarget", "LodMorphTarget", "AudioOcclusionMesh", "Skeleton", "BoneMask", "BoneWeight", "Animation", "AnimationChannel", "AnimationCurve"]);
+function buildCmfFromShared(root) {
+  return {
+    version: 1,
+    metadata: null,
+    meshes: (root.meshes ?? []).map(mesh => buildMesh(mesh)),
+    skeletons: [],
+    animations: []
+  };
+}
+function buildMesh(mesh) {
+  const vertex = mesh.vertex ?? {},
+    indices = mesh.indices ?? [],
+    stride = estimateVertexStride(vertex),
+    vertexCount = stride === 0 ? 0 : Math.floor((vertex.position ?? []).length / 3);
+  return {
+    name: mesh.name ?? "",
+    decl: buildDecl(vertex),
+    lods: [{
+      vb: {
+        index: 1,
+        offset: 0,
+        size: vertexCount * stride,
+        stride
+      },
+      ib: {
+        index: 2,
+        offset: 0,
+        size: totalIndexCount(indices) * bytesPerIndex(indices),
+        stride: bytesPerIndex(indices)
+      },
+      areas: indices.map((group, index) => ({
+        firstElement: firstTriangle(indices, index),
+        elementCount: Math.floor((group.faces ?? []).length / 3)
+      })),
+      morphTargets: [],
+      threshold: 0xffffffff,
+      vertex,
+      indices
+    }],
+    areas: indices.map(group => ({
+      name: group.name ?? "",
+      bounds: bounds(mesh),
+      bones: [],
+      affectedByBones: false,
+      affectedByMorphTargets: false
+    })),
+    boneBindings: [],
+    morphTargets: {
+      decl: [],
+      targets: []
+    },
+    uvDensities: [],
+    bounds: bounds(mesh),
+    audioOcclusionMesh: {
+      vertices: [],
+      indices: [],
+      bounds: {
+        min: [0, 0, 0],
+        max: [0, 0, 0]
+      }
+    },
+    topology: "TriangleList",
+    skeleton: null,
+    vertex,
+    indices
+  };
+}
+function buildDecl(vertex) {
+  const decl = [];
+  let offset = 0;
+  for (const channel of [["position", "Position", 3], ["normal", "Normal", 3], ["tangent", "Tangent", 3], ["binormal", "Binormal", 3], ["texcoord0", "TexCoord", 2, 0], ["texcoord1", "TexCoord", 2, 1], ["color0", "Color", 4, 0], ["blendIndice", "BoneIndices", 4, 0, "UInt16"], ["blendWeight", "BoneWeights", 4, 0]]) {
+    const [name, usage, elementCount, usageIndex = 0, type = "Float32"] = channel;
+    if (!Array.isArray(vertex[name]) || vertex[name].length === 0) continue;
+    decl.push({
+      usage,
+      usageIndex,
+      type,
+      elementCount,
+      offset
+    });
+    offset += elementCount * elementTypeSize(type);
+  }
+  return decl;
+}
+function estimateVertexStride(vertex) {
+  return buildDecl(vertex).reduce((stride, element) => Math.max(stride, element.offset + element.elementCount * elementTypeSize(element.type)), 0);
+}
+function elementTypeSize(type) {
+  return type === "Float32" ? 4 : type.includes("16") ? 2 : 1;
+}
+function totalIndexCount(indices) {
+  return indices.reduce((total, group) => total + (group.faces?.length ?? 0), 0);
+}
+function bytesPerIndex(indices) {
+  return indices.some(group => group.bytesPerIndex === 4 || (group.faces ?? []).some(index => index > 0xffff)) ? 4 : 2;
+}
+function firstTriangle(indices, areaIndex) {
+  let first = 0;
+  for (let i = 0; i < areaIndex; i++) first += Math.floor((indices[i].faces ?? []).length / 3);
+  return first;
+}
+function bounds(mesh) {
+  return {
+    min: mesh.minBounds ?? [0, 0, 0],
+    max: mesh.maxBounds ?? [0, 0, 0]
+  };
+}
+function hydrateCmf(root, classes, hydrationOptions = {}) {
+  const hydrationClasses = createHydrationClasses(classes, hydrationOptions);
+  return hydrate("Root", {
+    ...root,
+    metadata: root.metadata ? hydrate("Metadata", root.metadata, hydrationClasses) : null,
+    meshes: root.meshes.map(mesh => hydrateMesh(mesh, hydrationClasses)),
+    skeletons: root.skeletons.map(skeleton => hydrate("Skeleton", skeleton, hydrationClasses)),
+    animations: root.animations.map(animation => hydrate("Animation", animation, hydrationClasses))
+  }, hydrationClasses, hydrationOptions);
+}
+function hydrateMesh(mesh, classes) {
+  return hydrate("Mesh", {
+    ...mesh,
+    decl: mesh.decl.map(element => hydrate("VertexElement", element, classes)),
+    lods: mesh.lods.map(lod => hydrate("MeshLod", {
+      ...lod,
+      areas: lod.areas.map(area => hydrate("LodMeshArea", area, classes)),
+      morphTargets: lod.morphTargets.map(target => hydrate("LodMorphTarget", target, classes))
+    }, classes)),
+    areas: mesh.areas.map(area => hydrate("MeshArea", area, classes)),
+    boneBindings: mesh.boneBindings.map(binding => hydrate("BoneBinding", binding, classes)),
+    morphTargets: hydrate("MorphTargets", {
+      decl: mesh.morphTargets.decl.map(element => hydrate("VertexElement", element, classes)),
+      targets: mesh.morphTargets.targets.map(target => hydrate("MorphTarget", target, classes))
+    }, classes),
+    audioOcclusionMesh: hydrate("AudioOcclusionMesh", mesh.audioOcclusionMesh, classes)
+  }, classes);
+}
+function hydrate(type, fields, classes, hydrationOptions = {}) {
+  const Class = classes?.[type];
+  const options = Object.keys(hydrationOptions).length > 0 ? hydrationOptions : classes?.__hydrationOptions || {};
+  return Class ? populate(new Class(), fields, options) : fields;
+}
+function populate(instance, fields, hydrationOptions = {}) {
+  if (!instance || typeof instance.SetValues !== "function") {
+    throw new TypeError("CjsGltfFormat CMF class population requires classes to implement SetValues(values)");
+  }
+  instance.SetValues(fields, {
+    ...hydrationOptions,
+    skipUpdate: true,
+    skipEvents: true
+  });
+  return instance;
+}
+function createHydrationClasses(classes, hydrationOptions) {
+  const map = Object.create(classes || null);
+  Object.defineProperty(map, "__hydrationOptions", {
+    value: hydrationOptions,
+    enumerable: false
+  });
+  return map;
+}
+
+export { CMF_CLASS_KEYS, buildCmfFromShared, hydrateCmf };
+//# sourceMappingURL=targets.js.map

package/dist/formats/gltf/index.js

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

package/dist/formats/gr2/CjsGr2Format.js

@@ -0,0 +1,46 @@
+import { CjsFormatGr2 } from './core/CjsFormatGr2.js';
+import { GR2_MAGICS, bytesToHex } from './core/reader.js';
+
+/**
+ * Exposed CarbonEngineJS-facing GR2/GSF format class.
+ *
+ * Runtime adaptation of the migrated `format-gr2` reader: the copied engine
+ * under core/ keeps its donor behavior (including the legacy `CjsFormatGr2`
+ * name), while this class adds the runtime-resource format-contract statics
+ * ResMan uses for byte probing and async reads.
+ */
+
+
+/**
+ * CarbonEngineJS-facing GR2 (Granny 3D) and GSF (Granny State) reader.
+ *
+ * The Cjs prefix marks this as a JavaScript format/construction boundary. It
+ * reads `.gr2` geometry/skeleton/animation graphs and `.gsf` state profiles,
+ * emitting GR2 JSON, hydrated caller classes, or CMF-shaped output.
+ */
+class CjsGr2Format extends CjsFormatGr2 {
+  /**
+   * Cheap magic probe for GR2/GSF byte streams.
+   *
+   * @param {Uint8Array} bytes Candidate source bytes.
+   * @returns {boolean} True when the 16-byte Granny magic is recognized.
+   */
+  static isSupported(bytes) {
+    if (!bytes || bytes.length < 16) return false;
+    return bytesToHex(bytes.subarray(0, 16)) in GR2_MAGICS;
+  }
+
+  /**
+   * Async read entrypoint for the resource-manager contract.
+   *
+   * @param {Uint8Array} bytes Source bytes.
+   * @param {object} [options] Read options (emit, classes, conversions).
+   * @returns {Promise<object>} The emitted GR2/GSF result.
+   */
+  static async readAsync(bytes, options = {}) {
+    return CjsGr2Format.read(bytes, options);
+  }
+}
+
+export { CjsGr2Format, CjsGr2Format as default };
+//# sourceMappingURL=CjsGr2Format.js.map

package/dist/formats/gr2/CjsGr2Format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CjsGr2Format.js","sources":["../../../../src/formats/gr2/CjsGr2Format.js"],"sourcesContent":["/**\n * Exposed CarbonEngineJS-facing GR2/GSF format class.\n *\n * Runtime adaptation of the migrated `format-gr2` reader: the copied engine\n * under core/ keeps its donor behavior (including the legacy `CjsFormatGr2`\n * name), while this class adds the runtime-resource format-contract statics\n * ResMan uses for byte probing and async reads.\n */\n\nimport { CjsFormatGr2 } from \"./core/CjsFormatGr2.js\";\nimport { GR2_MAGICS, bytesToHex } from \"./core/reader.js\";\n\n/**\n * CarbonEngineJS-facing GR2 (Granny 3D) and GSF (Granny State) reader.\n *\n * The Cjs prefix marks this as a JavaScript format/construction boundary. It\n * reads `.gr2` geometry/skeleton/animation graphs and `.gsf` state profiles,\n * emitting GR2 JSON, hydrated caller classes, or CMF-shaped output.\n */\nexport class CjsGr2Format extends CjsFormatGr2\n{\n    /**\n     * Cheap magic probe for GR2/GSF byte streams.\n     *\n     * @param {Uint8Array} bytes Candidate source bytes.\n     * @returns {boolean} True when the 16-byte Granny magic is recognized.\n     */\n    static isSupported(bytes)\n    {\n        if (!bytes || bytes.length < 16) return false;\n        return bytesToHex(bytes.subarray(0, 16)) in GR2_MAGICS;\n    }\n\n    /**\n     * Async read entrypoint for the resource-manager contract.\n     *\n     * @param {Uint8Array} bytes Source bytes.\n     * @param {object} [options] Read options (emit, classes, conversions).\n     * @returns {Promise<object>} The emitted GR2/GSF result.\n     */\n    static async readAsync(bytes, options = {})\n    {\n        return CjsGr2Format.read(bytes, options);\n    }\n}\n\nexport default CjsGr2Format;\n"],"names":["CjsGr2Format","CjsFormatGr2","isSupported","bytes","length","bytesToHex","subarray","GR2_MAGICS","readAsync","options","read"],"mappings":";;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMA,YAAY,SAASC,YAAY,CAC9C;AACI;AACJ;AACA;AACA;AACA;AACA;EACI,OAAOC,WAAWA,CAACC,KAAK,EACxB;IACI,IAAI,CAACA,KAAK,IAAIA,KAAK,CAACC,MAAM,GAAG,EAAE,EAAE,OAAO,KAAK;AAC7C,IAAA,OAAOC,UAAU,CAACF,KAAK,CAACG,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAIC,UAAU;AAC1D,EAAA;;AAEA;AACJ;AACA;AACA;AACA;AACA;AACA;EACI,aAAaC,SAASA,CAACL,KAAK,EAAEM,OAAO,GAAG,EAAE,EAC1C;AACI,IAAA,OAAOT,YAAY,CAACU,IAAI,CAACP,KAAK,EAAEM,OAAO,CAAC;AAC5C,EAAA;AACJ;;;;"}

package/dist/formats/gr2/core/CjsFormatGr2.js

@@ -0,0 +1,273 @@
+import { curves } from './curves.js';
+import { tangents } from './tangents.js';
+import { isGsfRaw, projectGsf, inspectGsfRaw } from './gsf.js';
+import { DEFAULT_VALUES, normalizeValues, validateClassKey, validateClass, readWithValues, readRawInput, inspectRawGr2Result, toJsonValue, OUTPUT_JSON, OUTPUT_GR2, OUTPUT_GR2_JSON, OUTPUT_CMF, OUTPUT_RAW, CLASS_KEYS } from './helpers.js';
+
+/**
+ * Exposed CarbonEngineJS-facing GR2 format class.
+ *
+ * Keep this file small and reviewable: parsing, conversion, rebuild, and JSON
+ * helper glue live in core/helpers.js.
+ */
+
+
+/**
+ * CarbonEngineJS-facing GR2 reader.
+ *
+ * The Cjs prefix marks this as a JavaScript format/construction boundary. It
+ * can emit plain GR2 JSON data or hydrate caller-supplied CarbonEngineJS-style
+ * classes without pretending those classes are the engine runtime itself.
+ */
+class CjsFormatGr2 {
+  #emit = DEFAULT_VALUES.emit;
+  #decompressCurves = DEFAULT_VALUES.decompressCurves;
+  #unpackTangents = DEFAULT_VALUES.unpackTangents;
+  #rebuildMissingNormals = DEFAULT_VALUES.rebuildMissingNormals;
+  #rebuildMissingTangents = DEFAULT_VALUES.rebuildMissingTangents;
+  #rebuildMissingBiNormals = DEFAULT_VALUES.rebuildMissingBiNormals;
+  #classes = {};
+
+  /**
+   * Create a reusable format profile.
+   *
+   * @param {object} [options] Default format/build values.
+   */
+  constructor(options = {}) {
+    this.SetValues(options);
+  }
+
+  /**
+   * Set format values for this reusable profile.
+   *
+   * @param {object} [options] Values to merge into the profile.
+   * @returns {CjsFormatGr2} This format profile.
+   */
+  SetValues(options = {}) {
+    const values = normalizeValues(this.GetValues(), options);
+    this.#emit = values.emit;
+    this.#decompressCurves = values.decompressCurves;
+    this.#unpackTangents = values.unpackTangents;
+    this.#rebuildMissingNormals = values.rebuildMissingNormals;
+    this.#rebuildMissingTangents = values.rebuildMissingTangents;
+    this.#rebuildMissingBiNormals = values.rebuildMissingBiNormals;
+    this.#classes = values.classes;
+    return this;
+  }
+
+  /**
+   * Get this profile's current values, optionally with per-call overrides.
+   *
+   * @param {object} [options] Optional values to merge into a copy.
+   * @returns {object} A copy of the effective values.
+   */
+  GetValues(options = {}) {
+    return normalizeValues({
+      emit: this.#emit,
+      decompressCurves: this.#decompressCurves,
+      unpackTangents: this.#unpackTangents,
+      rebuildMissingNormals: this.#rebuildMissingNormals,
+      rebuildMissingTangents: this.#rebuildMissingTangents,
+      rebuildMissingBiNormals: this.#rebuildMissingBiNormals,
+      classes: this.#classes
+    }, options);
+  }
+
+  /**
+   * Set multiple GR2 JSON node constructors for this profile.
+   *
+   * @param {object} [classes] Map of node class keys to constructors.
+   * @returns {CjsFormatGr2} This format profile.
+   */
+  SetClasses(classes = {}) {
+    return this.SetValues({
+      classes
+    });
+  }
+
+  /**
+   * Set a GR2 JSON node constructor for this profile.
+   *
+   * @param {string} type Node class key.
+   * @param {Function|null|undefined} Class Constructor to use, or nullish to delete.
+   * @returns {CjsFormatGr2} This format profile.
+   */
+  SetClass(type, Class) {
+    validateClassKey(type);
+    if (Class === null || Class === undefined) {
+      delete this.#classes[type];
+      return this;
+    }
+    validateClass(type, Class);
+    this.#classes = {
+      ...this.#classes,
+      [type]: Class
+    };
+    return this;
+  }
+
+  /**
+   * Get a configured GR2 JSON node constructor.
+   *
+   * @param {string} type Node class key.
+   * @returns {Function|undefined}
+   */
+  GetClass(type) {
+    validateClassKey(type);
+    return this.#classes[type];
+  }
+
+  /**
+   * Whether this reader has a constructor for a GR2 JSON node key.
+   *
+   * @param {string} type Node class key.
+   * @returns {boolean}
+   */
+  HasClass(type) {
+    return !!this.GetClass(type);
+  }
+
+  /**
+   * Parse a .gr2 buffer and return JSON by default, classes when configured,
+   * or raw reflection data when `emit` is "raw".
+   *
+   * @param {Uint8Array|Buffer|object} input Raw .gr2 bytes or an existing raw read result.
+   * @param {object} [options] Per-call values.
+   * @returns {object}
+   */
+  Read(input, options = {}) {
+    return readWithValues(this, input, this.GetValues(options));
+  }
+
+  /**
+   * Parse a .gr2 buffer into the reflected Granny object graph.
+   *
+   * @param {Uint8Array|Buffer|object} input Raw .gr2 bytes or an existing raw read result.
+   * @returns {object}
+   */
+  ReadRaw(input) {
+    return readRawInput(input);
+  }
+
+  /**
+   * Return a stable, lightweight summary for a GR2 buffer or raw result.
+   *
+   * @param {Uint8Array|Buffer|object} input Raw .gr2 bytes or an existing raw read result.
+   * @returns {object}
+   */
+  Inspect(input) {
+    return inspectRawGr2Result(this.ReadRaw(input));
+  }
+
+  /** Whether input is a Granny State document carried by the GR2 container. */
+  IsGSF(input) {
+    return isGsfRaw(this.ReadRaw(input));
+  }
+
+  /** Read the GState semantic projection, or raw reflected data with `emit: "raw"`. */
+  ReadGSF(input, options = {}) {
+    const raw = this.ReadRaw(input);
+    return options.emit === "raw" ? raw : projectGsf(raw);
+  }
+
+  /** Inspect a GSF document and its referenced GR2 animations. */
+  InspectGSF(input) {
+    return inspectGsfRaw(this.ReadRaw(input));
+  }
+
+  /**
+   * Convert format output to plain JSON-compatible data.
+   *
+   * @param {object} value Format output to convert.
+   * @returns {any} Plain JSON-compatible data.
+   */
+  ToJSON(value) {
+    return toJsonValue(value);
+  }
+
+  /**
+   * Static one-shot read. Static methods use camelCase by convention.
+   *
+   * @param {Uint8Array|Buffer|object} input Raw .gr2 bytes or an existing raw read result.
+   * @param {object} [options] Reader and post-processing values.
+   * @returns {object}
+   */
+  static read(input, options = {}) {
+    return readWithValues(CjsFormatGr2, input, normalizeValues(DEFAULT_VALUES, options));
+  }
+
+  /**
+   * Static one-shot raw read.
+   *
+   * @param {Uint8Array|Buffer|object} input Raw .gr2 bytes or an existing raw read result.
+   * @returns {object}
+   */
+  static readRaw(input) {
+    return readRawInput(input);
+  }
+
+  /**
+   * Static one-shot inspection.
+   *
+   * @param {Uint8Array|Buffer|object} input Raw .gr2 bytes or an existing raw read result.
+   * @returns {object}
+   */
+  static inspect(input) {
+    return inspectRawGr2Result(readRawInput(input));
+  }
+
+  /** Whether input is a Granny State document carried by the GR2 container. */
+  static isGsf(input) {
+    try {
+      return isGsfRaw(readRawInput(input));
+    } catch {
+      return false;
+    }
+  }
+
+  /** Read the GState semantic projection, or raw reflected data with `emit: "raw"`. */
+  static readGsf(input, options = {}) {
+    const raw = readRawInput(input);
+    return options.emit === "raw" ? raw : projectGsf(raw);
+  }
+
+  /** Async one-shot GSF read for standard format API compatibility. */
+  static readGsfAsync(input, options = {}) {
+    return Promise.resolve(this.readGsf(input, options));
+  }
+
+  /** Inspect a GSF document and its referenced GR2 animations. */
+  static inspectGsf(input) {
+    return inspectGsfRaw(readRawInput(input));
+  }
+
+  /**
+   * Static JSON-compatible conversion.
+   *
+   * @param {object} value Format output to convert.
+   * @returns {any} Plain JSON-compatible data.
+   */
+  static toJSON(value) {
+    return toJsonValue(value);
+  }
+  static OUTPUT_JSON = OUTPUT_JSON;
+  static OUTPUT_GR2 = OUTPUT_GR2;
+  static OUTPUT_GR2_JSON = OUTPUT_GR2_JSON;
+  static OUTPUT_CMF = OUTPUT_CMF;
+  static OUTPUT_RAW = OUTPUT_RAW;
+  static CLASS_KEYS = CLASS_KEYS;
+  static type = Object.freeze(["geometry"]);
+  static mediaTypes = Object.freeze(["geometry"]);
+  static inputTypes = Object.freeze(["gr2", "gsf"]);
+  static outputTypes = Object.freeze([OUTPUT_GR2, OUTPUT_CMF]);
+  static debugOutputTypes = Object.freeze([OUTPUT_JSON, OUTPUT_GR2_JSON, OUTPUT_RAW]);
+  static curves = curves;
+  static tangents = tangents;
+  static gsf = Object.freeze({
+    isRaw: isGsfRaw,
+    project: projectGsf,
+    inspectRaw: inspectGsfRaw
+  });
+}
+
+export { CjsFormatGr2 };
+//# sourceMappingURL=CjsFormatGr2.js.map