@loaders.gl/scene 5.0.0-alpha.9 → 5.0.0-beta.1

package/dist/gltf/lib/api/convert-gltf-v1-matrix-nodes.cjs

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/gltf/lib/api/convert-gltf-v1-matrix-nodes.ts
+var convert_gltf_v1_matrix_nodes_exports = {};
+__export(convert_gltf_v1_matrix_nodes_exports, {
+  convertGLTFV1MatrixNodes: () => convertGLTFV1MatrixNodes
+});
+module.exports = __toCommonJS(convert_gltf_v1_matrix_nodes_exports);
+var import_core = require("@math.gl/core");
+function convertGLTFV1MatrixNodes(json, reportUnsupported, reportNote) {
+  const targets = /* @__PURE__ */ new Map();
+  for (const animation of json.animations || [])
+    for (const channel of animation.channels || []) {
+      const nodeIndex = channel.target?.node;
+      if (!Number.isSafeInteger(nodeIndex)) continue;
+      const paths = targets.get(nodeIndex) || /* @__PURE__ */ new Set();
+      paths.add(channel.target.path);
+      targets.set(nodeIndex, paths);
+    }
+  const plans = [];
+  for (const [nodeIndex, paths] of targets) {
+    const node = json.nodes?.[nodeIndex];
+    if (node?.matrix === void 0) continue;
+    const label = `animated matrix node ${nodeIndex}`;
+    if (paths.size !== 1 || !paths.has("translation")) {
+      reportUnsupported(`${label} rotation or scale animation requires an unambiguous TRS basis`);
+      continue;
+    }
+    if (node.translation !== void 0 || node.rotation !== void 0 || node.scale !== void 0 || node.extensions !== void 0) {
+      reportUnsupported(`${label} has conflicting TRS fields or opaque extensions`);
+      continue;
+    }
+    const transform = decomposeMatrix(node.matrix);
+    if (!transform) {
+      reportUnsupported(`${label} requires a finite affine, nonsingular matrix without shear`);
+      continue;
+    }
+    plans.push(() => {
+      Object.assign(node, transform);
+      delete node.matrix;
+      reportNote(
+        `Decomposed translation-only animated matrix node ${nodeIndex}, preserving its linear transform.`
+      );
+    });
+  }
+  for (const apply of plans) apply();
+}
+function decomposeMatrix(matrix) {
+  if (!Array.isArray(matrix) || matrix.length !== 16 || Array.from(matrix).some((value) => !Number.isFinite(value)) || matrix[3] !== 0 || matrix[7] !== 0 || matrix[11] !== 0 || matrix[15] !== 1)
+    return null;
+  const scale = [0, 1, 2].map((column) => Math.hypot(...matrix.slice(column * 4, column * 4 + 3)));
+  if (scale.some((value) => !Number.isFinite(value) || value === 0)) return null;
+  const columns = scale.map(
+    (length, column) => matrix.slice(column * 4, column * 4 + 3).map((value) => value / length)
+  );
+  for (let first = 0; first < 3; first++)
+    for (let second = first + 1; second < 3; second++)
+      if (Math.abs(
+        columns[first].reduce((sum, value, row) => sum + value * columns[second][row], 0)
+      ) > 1e-6)
+        return null;
+  const determinant = columns[0][0] * (columns[1][1] * columns[2][2] - columns[1][2] * columns[2][1]) - columns[1][0] * (columns[0][1] * columns[2][2] - columns[0][2] * columns[2][1]) + columns[2][0] * (columns[0][1] * columns[1][2] - columns[0][2] * columns[1][1]);
+  if (Math.abs(Math.abs(determinant) - 1) > 1e-6) return null;
+  if (determinant < 0) {
+    scale[0] = -scale[0];
+    columns[0] = columns[0].map((value) => -value);
+  }
+  const rotation = Array.from(new import_core.Quaternion().fromMatrix3(columns.flat()).normalize());
+  const translation = matrix.slice(12, 15);
+  const reconstructed = new import_core.Matrix4().translate(translation).multiplyRight(new import_core.Matrix4().fromQuaternion(rotation)).scale(scale);
+  if (Array.from(reconstructed).some(
+    (value, index) => !Number.isFinite(value) || Math.abs(value - matrix[index]) > 1e-6 * Math.max(1, Math.abs(matrix[index]))
+  ))
+    return null;
+  return { translation, rotation, scale };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertGLTFV1MatrixNodes
+});
+//# sourceMappingURL=convert-gltf-v1-matrix-nodes.cjs.map

package/dist/gltf/lib/api/convert-gltf-v1-matrix-nodes.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/gltf/lib/api/convert-gltf-v1-matrix-nodes.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport {Matrix4, Quaternion} from '@math.gl/core';\nimport type {GLTF} from '../types/gltf-types';\n\n/** Convert translation-only animated matrices while preserving their entire linear transform. */\nexport function convertGLTFV1MatrixNodes(\n  json: GLTF,\n  reportUnsupported: (feature: string) => void,\n  reportNote: (message: string) => void\n): void {\n  const targets = new Map<number, Set<string>>();\n  for (const animation of json.animations || [])\n    for (const channel of animation.channels || []) {\n      const nodeIndex = channel.target?.node;\n      if (!Number.isSafeInteger(nodeIndex)) continue;\n      const paths = targets.get(nodeIndex as number) || new Set<string>();\n      paths.add(channel.target.path);\n      targets.set(nodeIndex as number, paths);\n    }\n  const plans: Array<() => void> = [];\n  for (const [nodeIndex, paths] of targets) {\n    const node = json.nodes?.[nodeIndex];\n    if (node?.matrix === undefined) continue;\n    const label = `animated matrix node ${nodeIndex}`;\n    if (paths.size !== 1 || !paths.has('translation')) {\n      reportUnsupported(`${label} rotation or scale animation requires an unambiguous TRS basis`);\n      continue;\n    }\n    if (\n      node.translation !== undefined ||\n      node.rotation !== undefined ||\n      node.scale !== undefined ||\n      node.extensions !== undefined\n    ) {\n      reportUnsupported(`${label} has conflicting TRS fields or opaque extensions`);\n      continue;\n    }\n    const transform = decomposeMatrix(node.matrix);\n    if (!transform) {\n      reportUnsupported(`${label} requires a finite affine, nonsingular matrix without shear`);\n      continue;\n    }\n    plans.push(() => {\n      Object.assign(node, transform);\n      delete node.matrix;\n      reportNote(\n        `Decomposed translation-only animated matrix node ${nodeIndex}, preserving its linear transform.`\n      );\n    });\n  }\n  for (const apply of plans) apply();\n}\n\n/** TRS representation checked by recomposing the complete source transform. */\ntype MatrixTransform = {\n  /** Original local translation. */\n  translation: number[];\n  /** Unit quaternion, with reflected scale assigned to the first axis. */\n  rotation: number[];\n  /** Column lengths, retaining the determinant sign on the first axis. */\n  scale: number[];\n};\n\n/** Decompose orthogonal columns; reject singular, perspective, and shear transforms. */\nfunction decomposeMatrix(matrix: number[]): MatrixTransform | null {\n  if (\n    !Array.isArray(matrix) ||\n    matrix.length !== 16 ||\n    Array.from(matrix).some(value => !Number.isFinite(value)) ||\n    matrix[3] !== 0 ||\n    matrix[7] !== 0 ||\n    matrix[11] !== 0 ||\n    matrix[15] !== 1\n  )\n    return null;\n  const scale = [0, 1, 2].map(column => Math.hypot(...matrix.slice(column * 4, column * 4 + 3)));\n  if (scale.some(value => !Number.isFinite(value) || value === 0)) return null;\n  const columns = scale.map((length, column) =>\n    matrix.slice(column * 4, column * 4 + 3).map(value => value / length)\n  );\n  for (let first = 0; first < 3; first++)\n    for (let second = first + 1; second < 3; second++)\n      if (\n        Math.abs(\n          columns[first].reduce((sum, value, row) => sum + value * columns[second][row], 0)\n        ) > 1e-6\n      )\n        return null;\n  const determinant =\n    columns[0][0] * (columns[1][1] * columns[2][2] - columns[1][2] * columns[2][1]) -\n    columns[1][0] * (columns[0][1] * columns[2][2] - columns[0][2] * columns[2][1]) +\n    columns[2][0] * (columns[0][1] * columns[1][2] - columns[0][2] * columns[1][1]);\n  if (Math.abs(Math.abs(determinant) - 1) > 1e-6) return null;\n  if (determinant < 0) {\n    scale[0] = -scale[0];\n    columns[0] = columns[0].map(value => -value);\n  }\n  const rotation = Array.from(new Quaternion().fromMatrix3(columns.flat()).normalize());\n  const translation = matrix.slice(12, 15);\n  const reconstructed = new Matrix4()\n    .translate(translation)\n    .multiplyRight(new Matrix4().fromQuaternion(rotation))\n    .scale(scale);\n  if (\n    Array.from(reconstructed).some(\n      (value, index) =>\n        !Number.isFinite(value) ||\n        Math.abs(value - matrix[index]) > 1e-6 * Math.max(1, Math.abs(matrix[index]))\n    )\n  )\n    return null;\n  return {translation, rotation, scale};\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,kBAAkC;AAI3B,SAAS,yBACd,MACA,mBACA,YACM;AACN,QAAM,UAAU,oBAAI,IAAyB;AAC7C,aAAW,aAAa,KAAK,cAAc,CAAC;AAC1C,eAAW,WAAW,UAAU,YAAY,CAAC,GAAG;AAC9C,YAAM,YAAY,QAAQ,QAAQ;AAClC,UAAI,CAAC,OAAO,cAAc,SAAS,EAAG;AACtC,YAAM,QAAQ,QAAQ,IAAI,SAAmB,KAAK,oBAAI,IAAY;AAClE,YAAM,IAAI,QAAQ,OAAO,IAAI;AAC7B,cAAQ,IAAI,WAAqB,KAAK;AAAA,IACxC;AACF,QAAM,QAA2B,CAAC;AAClC,aAAW,CAAC,WAAW,KAAK,KAAK,SAAS;AACxC,UAAM,OAAO,KAAK,QAAQ,SAAS;AACnC,QAAI,MAAM,WAAW,OAAW;AAChC,UAAM,QAAQ,wBAAwB,SAAS;AAC/C,QAAI,MAAM,SAAS,KAAK,CAAC,MAAM,IAAI,aAAa,GAAG;AACjD,wBAAkB,GAAG,KAAK,gEAAgE;AAC1F;AAAA,IACF;AACA,QACE,KAAK,gBAAgB,UACrB,KAAK,aAAa,UAClB,KAAK,UAAU,UACf,KAAK,eAAe,QACpB;AACA,wBAAkB,GAAG,KAAK,kDAAkD;AAC5E;AAAA,IACF;AACA,UAAM,YAAY,gBAAgB,KAAK,MAAM;AAC7C,QAAI,CAAC,WAAW;AACd,wBAAkB,GAAG,KAAK,6DAA6D;AACvF;AAAA,IACF;AACA,UAAM,KAAK,MAAM;AACf,aAAO,OAAO,MAAM,SAAS;AAC7B,aAAO,KAAK;AACZ;AAAA,QACE,oDAAoD,SAAS;AAAA,MAC/D;AAAA,IACF,CAAC;AAAA,EACH;AACA,aAAW,SAAS,MAAO,OAAM;AACnC;AAaA,SAAS,gBAAgB,QAA0C;AACjE,MACE,CAAC,MAAM,QAAQ,MAAM,KACrB,OAAO,WAAW,MAClB,MAAM,KAAK,MAAM,EAAE,KAAK,WAAS,CAAC,OAAO,SAAS,KAAK,CAAC,KACxD,OAAO,CAAC,MAAM,KACd,OAAO,CAAC,MAAM,KACd,OAAO,EAAE,MAAM,KACf,OAAO,EAAE,MAAM;AAEf,WAAO;AACT,QAAM,QAAQ,CAAC,GAAG,GAAG,CAAC,EAAE,IAAI,YAAU,KAAK,MAAM,GAAG,OAAO,MAAM,SAAS,GAAG,SAAS,IAAI,CAAC,CAAC,CAAC;AAC7F,MAAI,MAAM,KAAK,WAAS,CAAC,OAAO,SAAS,KAAK,KAAK,UAAU,CAAC,EAAG,QAAO;AACxE,QAAM,UAAU,MAAM;AAAA,IAAI,CAAC,QAAQ,WACjC,OAAO,MAAM,SAAS,GAAG,SAAS,IAAI,CAAC,EAAE,IAAI,WAAS,QAAQ,MAAM;AAAA,EACtE;AACA,WAAS,QAAQ,GAAG,QAAQ,GAAG;AAC7B,aAAS,SAAS,QAAQ,GAAG,SAAS,GAAG;AACvC,UACE,KAAK;AAAA,QACH,QAAQ,KAAK,EAAE,OAAO,CAAC,KAAK,OAAO,QAAQ,MAAM,QAAQ,QAAQ,MAAM,EAAE,GAAG,GAAG,CAAC;AAAA,MAClF,IAAI;AAEJ,eAAO;AACb,QAAM,cACJ,QAAQ,CAAC,EAAE,CAAC,KAAK,QAAQ,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,KAC7E,QAAQ,CAAC,EAAE,CAAC,KAAK,QAAQ,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,KAC7E,QAAQ,CAAC,EAAE,CAAC,KAAK,QAAQ,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC;AAC/E,MAAI,KAAK,IAAI,KAAK,IAAI,WAAW,IAAI,CAAC,IAAI,KAAM,QAAO;AACvD,MAAI,cAAc,GAAG;AACnB,UAAM,CAAC,IAAI,CAAC,MAAM,CAAC;AACnB,YAAQ,CAAC,IAAI,QAAQ,CAAC,EAAE,IAAI,WAAS,CAAC,KAAK;AAAA,EAC7C;AACA,QAAM,WAAW,MAAM,KAAK,IAAI,uBAAW,EAAE,YAAY,QAAQ,KAAK,CAAC,EAAE,UAAU,CAAC;AACpF,QAAM,cAAc,OAAO,MAAM,IAAI,EAAE;AACvC,QAAM,gBAAgB,IAAI,oBAAQ,EAC/B,UAAU,WAAW,EACrB,cAAc,IAAI,oBAAQ,EAAE,eAAe,QAAQ,CAAC,EACpD,MAAM,KAAK;AACd,MACE,MAAM,KAAK,aAAa,EAAE;AAAA,IACxB,CAAC,OAAO,UACN,CAAC,OAAO,SAAS,KAAK,KACtB,KAAK,IAAI,QAAQ,OAAO,KAAK,CAAC,IAAI,OAAO,KAAK,IAAI,GAAG,KAAK,IAAI,OAAO,KAAK,CAAC,CAAC;AAAA,EAChF;AAEA,WAAO;AACT,SAAO,EAAC,aAAa,UAAU,MAAK;AACtC;",
+  "names": []
+}

package/dist/gltf/lib/api/convert-gltf-v1-matrix-nodes.d.ts

@@ -0,0 +1,4 @@
+import type { GLTF } from "../types/gltf-types.js";
+/** Convert translation-only animated matrices while preserving their entire linear transform. */
+export declare function convertGLTFV1MatrixNodes(json: GLTF, reportUnsupported: (feature: string) => void, reportNote: (message: string) => void): void;
+//# sourceMappingURL=convert-gltf-v1-matrix-nodes.d.ts.map

package/dist/gltf/lib/api/convert-gltf-v1-matrix-nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-gltf-v1-matrix-nodes.d.ts","sourceRoot":"","sources":["../../../../src/gltf/lib/api/convert-gltf-v1-matrix-nodes.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,IAAI,EAAC,+BAA4B;AAE9C,iGAAiG;AACjG,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,IAAI,EACV,iBAAiB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EAC5C,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GACpC,IAAI,CA0CN"}

package/dist/gltf/lib/api/convert-gltf-v1-matrix-nodes.js

@@ -0,0 +1,86 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { Matrix4, Quaternion } from '@math.gl/core';
+/** Convert translation-only animated matrices while preserving their entire linear transform. */
+export function convertGLTFV1MatrixNodes(json, reportUnsupported, reportNote) {
+    const targets = new Map();
+    for (const animation of json.animations || [])
+        for (const channel of animation.channels || []) {
+            const nodeIndex = channel.target?.node;
+            if (!Number.isSafeInteger(nodeIndex))
+                continue;
+            const paths = targets.get(nodeIndex) || new Set();
+            paths.add(channel.target.path);
+            targets.set(nodeIndex, paths);
+        }
+    const plans = [];
+    for (const [nodeIndex, paths] of targets) {
+        const node = json.nodes?.[nodeIndex];
+        if (node?.matrix === undefined)
+            continue;
+        const label = `animated matrix node ${nodeIndex}`;
+        if (paths.size !== 1 || !paths.has('translation')) {
+            reportUnsupported(`${label} rotation or scale animation requires an unambiguous TRS basis`);
+            continue;
+        }
+        if (node.translation !== undefined ||
+            node.rotation !== undefined ||
+            node.scale !== undefined ||
+            node.extensions !== undefined) {
+            reportUnsupported(`${label} has conflicting TRS fields or opaque extensions`);
+            continue;
+        }
+        const transform = decomposeMatrix(node.matrix);
+        if (!transform) {
+            reportUnsupported(`${label} requires a finite affine, nonsingular matrix without shear`);
+            continue;
+        }
+        plans.push(() => {
+            Object.assign(node, transform);
+            delete node.matrix;
+            reportNote(`Decomposed translation-only animated matrix node ${nodeIndex}, preserving its linear transform.`);
+        });
+    }
+    for (const apply of plans)
+        apply();
+}
+/** Decompose orthogonal columns; reject singular, perspective, and shear transforms. */
+function decomposeMatrix(matrix) {
+    if (!Array.isArray(matrix) ||
+        matrix.length !== 16 ||
+        Array.from(matrix).some(value => !Number.isFinite(value)) ||
+        matrix[3] !== 0 ||
+        matrix[7] !== 0 ||
+        matrix[11] !== 0 ||
+        matrix[15] !== 1)
+        return null;
+    const scale = [0, 1, 2].map(column => Math.hypot(...matrix.slice(column * 4, column * 4 + 3)));
+    if (scale.some(value => !Number.isFinite(value) || value === 0))
+        return null;
+    const columns = scale.map((length, column) => matrix.slice(column * 4, column * 4 + 3).map(value => value / length));
+    for (let first = 0; first < 3; first++)
+        for (let second = first + 1; second < 3; second++)
+            if (Math.abs(columns[first].reduce((sum, value, row) => sum + value * columns[second][row], 0)) > 1e-6)
+                return null;
+    const determinant = columns[0][0] * (columns[1][1] * columns[2][2] - columns[1][2] * columns[2][1]) -
+        columns[1][0] * (columns[0][1] * columns[2][2] - columns[0][2] * columns[2][1]) +
+        columns[2][0] * (columns[0][1] * columns[1][2] - columns[0][2] * columns[1][1]);
+    if (Math.abs(Math.abs(determinant) - 1) > 1e-6)
+        return null;
+    if (determinant < 0) {
+        scale[0] = -scale[0];
+        columns[0] = columns[0].map(value => -value);
+    }
+    const rotation = Array.from(new Quaternion().fromMatrix3(columns.flat()).normalize());
+    const translation = matrix.slice(12, 15);
+    const reconstructed = new Matrix4()
+        .translate(translation)
+        .multiplyRight(new Matrix4().fromQuaternion(rotation))
+        .scale(scale);
+    if (Array.from(reconstructed).some((value, index) => !Number.isFinite(value) ||
+        Math.abs(value - matrix[index]) > 1e-6 * Math.max(1, Math.abs(matrix[index]))))
+        return null;
+    return { translation, rotation, scale };
+}
+//# sourceMappingURL=convert-gltf-v1-matrix-nodes.js.map

package/dist/gltf/lib/api/convert-gltf-v1-matrix-nodes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-gltf-v1-matrix-nodes.js","sourceRoot":"","sources":["../../../../src/gltf/lib/api/convert-gltf-v1-matrix-nodes.ts"],"names":[],"mappings":"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"}

package/dist/gltf/lib/api/convert-gltf-v1-skin-scenes.cjs

@@ -0,0 +1,87 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/gltf/lib/api/convert-gltf-v1-skin-scenes.ts
+var convert_gltf_v1_skin_scenes_exports = {};
+__export(convert_gltf_v1_skin_scenes_exports, {
+  convertGLTFV1SkinScenes: () => convertGLTFV1SkinScenes
+});
+module.exports = __toCommonJS(convert_gltf_v1_skin_scenes_exports);
+function convertGLTFV1SkinScenes(json, reportUnsupported, reportNote) {
+  const nodes = json.nodes || [];
+  const parents = /* @__PURE__ */ new Map();
+  for (const [parentIndex, node] of nodes.entries())
+    for (const childIndex of node.children || []) {
+      parents.set(childIndex, parents.has(childIndex) ? null : parentIndex);
+    }
+  const plans = [];
+  for (const [sceneIndex, scene] of (json.scenes || []).entries()) {
+    const reachable = collectNodes(scene.nodes || []);
+    if (!reachable) {
+      reportUnsupported(`scene ${sceneIndex} invalid node hierarchy`);
+      continue;
+    }
+    for (const nodeIndex of Array.from(reachable)) {
+      const skin = json.skins?.[nodes[nodeIndex].skin];
+      if (!Array.isArray(skin?.joints) || !skin.joints.length || skin.skeleton === void 0)
+        continue;
+      if (reachable.has(skin.skeleton) && skin.joints.every((jointIndex) => reachable.has(jointIndex)))
+        continue;
+      let rootIndex = skin.skeleton;
+      const ancestors = /* @__PURE__ */ new Set();
+      while (!ancestors.has(rootIndex) && typeof parents.get(rootIndex) === "number") {
+        ancestors.add(rootIndex);
+        rootIndex = parents.get(rootIndex);
+      }
+      const hierarchy = collectNodes([rootIndex]);
+      if (ancestors.has(rootIndex) || parents.get(rootIndex) === null || !hierarchy || !skin.joints.every((jointIndex) => hierarchy.has(jointIndex)) || Array.from(hierarchy).some(
+        (index) => reachable.has(index) || nodes[index].mesh !== void 0 || nodes[index].camera !== void 0 || nodes[index].extensions !== void 0
+      )) {
+        reportUnsupported(
+          `scene ${sceneIndex} skin ${nodes[nodeIndex].skin} cannot safely attach detached skeleton`
+        );
+        continue;
+      }
+      for (const index of hierarchy) reachable.add(index);
+      plans.push(() => {
+        scene.nodes ||= [];
+        scene.nodes.push(rootIndex);
+        reportNote(`Attached detached skeleton root ${rootIndex} to scene ${sceneIndex}.`);
+      });
+    }
+  }
+  for (const apply of plans) apply();
+  function collectNodes(roots) {
+    const visited = /* @__PURE__ */ new Set();
+    const pending = [...roots];
+    while (pending.length) {
+      const index = pending.pop();
+      if (!Number.isSafeInteger(index) || !nodes[index] || visited.has(index) || parents.get(index) === null)
+        return null;
+      visited.add(index);
+      pending.push(...nodes[index].children || []);
+    }
+    return visited;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertGLTFV1SkinScenes
+});
+//# sourceMappingURL=convert-gltf-v1-skin-scenes.cjs.map

package/dist/gltf/lib/api/convert-gltf-v1-skin-scenes.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/gltf/lib/api/convert-gltf-v1-skin-scenes.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {GLTF} from '../types/gltf-types';\n\n/** Attach fully detached, non-renderable skeleton hierarchies to scenes using their skins. */\nexport function convertGLTFV1SkinScenes(\n  json: GLTF,\n  reportUnsupported: (feature: string) => void,\n  reportNote: (message: string) => void\n): void {\n  const nodes = json.nodes || [];\n  const parents = new Map<number, number | null>();\n  for (const [parentIndex, node] of nodes.entries())\n    for (const childIndex of node.children || []) {\n      parents.set(childIndex, parents.has(childIndex) ? null : parentIndex);\n    }\n  const plans: Array<() => void> = [];\n  for (const [sceneIndex, scene] of (json.scenes || []).entries()) {\n    const reachable = collectNodes(scene.nodes || []);\n    if (!reachable) {\n      reportUnsupported(`scene ${sceneIndex} invalid node hierarchy`);\n      continue;\n    }\n    for (const nodeIndex of Array.from(reachable)) {\n      const skin = json.skins?.[nodes[nodeIndex].skin as number];\n      if (!Array.isArray(skin?.joints) || !skin.joints.length || skin.skeleton === undefined)\n        continue;\n      if (\n        reachable.has(skin.skeleton) &&\n        skin.joints.every(jointIndex => reachable.has(jointIndex))\n      )\n        continue;\n      let rootIndex = skin.skeleton;\n      const ancestors = new Set<number>();\n      while (!ancestors.has(rootIndex) && typeof parents.get(rootIndex) === 'number') {\n        ancestors.add(rootIndex);\n        rootIndex = parents.get(rootIndex) as number;\n      }\n      const hierarchy = collectNodes([rootIndex]);\n      if (\n        ancestors.has(rootIndex) ||\n        parents.get(rootIndex) === null ||\n        !hierarchy ||\n        !skin.joints.every(jointIndex => hierarchy.has(jointIndex)) ||\n        Array.from(hierarchy).some(\n          index =>\n            reachable.has(index) ||\n            nodes[index].mesh !== undefined ||\n            nodes[index].camera !== undefined ||\n            nodes[index].extensions !== undefined\n        )\n      ) {\n        reportUnsupported(\n          `scene ${sceneIndex} skin ${nodes[nodeIndex].skin} cannot safely attach detached skeleton`\n        );\n        continue;\n      }\n      for (const index of hierarchy) reachable.add(index);\n      plans.push(() => {\n        scene.nodes ||= [];\n        scene.nodes.push(rootIndex);\n        reportNote(`Attached detached skeleton root ${rootIndex} to scene ${sceneIndex}.`);\n      });\n    }\n  }\n  for (const apply of plans) apply();\n\n  /** Traverse a forest while detecting missing nodes, cycles, and repeated paths. */\n  function collectNodes(roots: number[]): Set<number> | null {\n    const visited = new Set<number>();\n    const pending = [...roots];\n    while (pending.length) {\n      const index = pending.pop()!;\n      if (\n        !Number.isSafeInteger(index) ||\n        !nodes[index] ||\n        visited.has(index) ||\n        parents.get(index) === null\n      )\n        return null;\n      visited.add(index);\n      pending.push(...(nodes[index].children || []));\n    }\n    return visited;\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOO,SAAS,wBACd,MACA,mBACA,YACM;AACN,QAAM,QAAQ,KAAK,SAAS,CAAC;AAC7B,QAAM,UAAU,oBAAI,IAA2B;AAC/C,aAAW,CAAC,aAAa,IAAI,KAAK,MAAM,QAAQ;AAC9C,eAAW,cAAc,KAAK,YAAY,CAAC,GAAG;AAC5C,cAAQ,IAAI,YAAY,QAAQ,IAAI,UAAU,IAAI,OAAO,WAAW;AAAA,IACtE;AACF,QAAM,QAA2B,CAAC;AAClC,aAAW,CAAC,YAAY,KAAK,MAAM,KAAK,UAAU,CAAC,GAAG,QAAQ,GAAG;AAC/D,UAAM,YAAY,aAAa,MAAM,SAAS,CAAC,CAAC;AAChD,QAAI,CAAC,WAAW;AACd,wBAAkB,SAAS,UAAU,yBAAyB;AAC9D;AAAA,IACF;AACA,eAAW,aAAa,MAAM,KAAK,SAAS,GAAG;AAC7C,YAAM,OAAO,KAAK,QAAQ,MAAM,SAAS,EAAE,IAAc;AACzD,UAAI,CAAC,MAAM,QAAQ,MAAM,MAAM,KAAK,CAAC,KAAK,OAAO,UAAU,KAAK,aAAa;AAC3E;AACF,UACE,UAAU,IAAI,KAAK,QAAQ,KAC3B,KAAK,OAAO,MAAM,gBAAc,UAAU,IAAI,UAAU,CAAC;AAEzD;AACF,UAAI,YAAY,KAAK;AACrB,YAAM,YAAY,oBAAI,IAAY;AAClC,aAAO,CAAC,UAAU,IAAI,SAAS,KAAK,OAAO,QAAQ,IAAI,SAAS,MAAM,UAAU;AAC9E,kBAAU,IAAI,SAAS;AACvB,oBAAY,QAAQ,IAAI,SAAS;AAAA,MACnC;AACA,YAAM,YAAY,aAAa,CAAC,SAAS,CAAC;AAC1C,UACE,UAAU,IAAI,SAAS,KACvB,QAAQ,IAAI,SAAS,MAAM,QAC3B,CAAC,aACD,CAAC,KAAK,OAAO,MAAM,gBAAc,UAAU,IAAI,UAAU,CAAC,KAC1D,MAAM,KAAK,SAAS,EAAE;AAAA,QACpB,WACE,UAAU,IAAI,KAAK,KACnB,MAAM,KAAK,EAAE,SAAS,UACtB,MAAM,KAAK,EAAE,WAAW,UACxB,MAAM,KAAK,EAAE,eAAe;AAAA,MAChC,GACA;AACA;AAAA,UACE,SAAS,UAAU,SAAS,MAAM,SAAS,EAAE,IAAI;AAAA,QACnD;AACA;AAAA,MACF;AACA,iBAAW,SAAS,UAAW,WAAU,IAAI,KAAK;AAClD,YAAM,KAAK,MAAM;AACf,cAAM,UAAU,CAAC;AACjB,cAAM,MAAM,KAAK,SAAS;AAC1B,mBAAW,mCAAmC,SAAS,aAAa,UAAU,GAAG;AAAA,MACnF,CAAC;AAAA,IACH;AAAA,EACF;AACA,aAAW,SAAS,MAAO,OAAM;AAGjC,WAAS,aAAa,OAAqC;AACzD,UAAM,UAAU,oBAAI,IAAY;AAChC,UAAM,UAAU,CAAC,GAAG,KAAK;AACzB,WAAO,QAAQ,QAAQ;AACrB,YAAM,QAAQ,QAAQ,IAAI;AAC1B,UACE,CAAC,OAAO,cAAc,KAAK,KAC3B,CAAC,MAAM,KAAK,KACZ,QAAQ,IAAI,KAAK,KACjB,QAAQ,IAAI,KAAK,MAAM;AAEvB,eAAO;AACT,cAAQ,IAAI,KAAK;AACjB,cAAQ,KAAK,GAAI,MAAM,KAAK,EAAE,YAAY,CAAC,CAAE;AAAA,IAC/C;AACA,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

package/dist/gltf/lib/api/convert-gltf-v1-skin-scenes.d.ts

@@ -0,0 +1,4 @@
+import type { GLTF } from "../types/gltf-types.js";
+/** Attach fully detached, non-renderable skeleton hierarchies to scenes using their skins. */
+export declare function convertGLTFV1SkinScenes(json: GLTF, reportUnsupported: (feature: string) => void, reportNote: (message: string) => void): void;
+//# sourceMappingURL=convert-gltf-v1-skin-scenes.d.ts.map

package/dist/gltf/lib/api/convert-gltf-v1-skin-scenes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-gltf-v1-skin-scenes.d.ts","sourceRoot":"","sources":["../../../../src/gltf/lib/api/convert-gltf-v1-skin-scenes.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,IAAI,EAAC,+BAA4B;AAE9C,8FAA8F;AAC9F,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,IAAI,EACV,iBAAiB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EAC5C,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GACpC,IAAI,CA4EN"}

package/dist/gltf/lib/api/convert-gltf-v1-skin-scenes.js

@@ -0,0 +1,72 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/** Attach fully detached, non-renderable skeleton hierarchies to scenes using their skins. */
+export function convertGLTFV1SkinScenes(json, reportUnsupported, reportNote) {
+    const nodes = json.nodes || [];
+    const parents = new Map();
+    for (const [parentIndex, node] of nodes.entries())
+        for (const childIndex of node.children || []) {
+            parents.set(childIndex, parents.has(childIndex) ? null : parentIndex);
+        }
+    const plans = [];
+    for (const [sceneIndex, scene] of (json.scenes || []).entries()) {
+        const reachable = collectNodes(scene.nodes || []);
+        if (!reachable) {
+            reportUnsupported(`scene ${sceneIndex} invalid node hierarchy`);
+            continue;
+        }
+        for (const nodeIndex of Array.from(reachable)) {
+            const skin = json.skins?.[nodes[nodeIndex].skin];
+            if (!Array.isArray(skin?.joints) || !skin.joints.length || skin.skeleton === undefined)
+                continue;
+            if (reachable.has(skin.skeleton) &&
+                skin.joints.every(jointIndex => reachable.has(jointIndex)))
+                continue;
+            let rootIndex = skin.skeleton;
+            const ancestors = new Set();
+            while (!ancestors.has(rootIndex) && typeof parents.get(rootIndex) === 'number') {
+                ancestors.add(rootIndex);
+                rootIndex = parents.get(rootIndex);
+            }
+            const hierarchy = collectNodes([rootIndex]);
+            if (ancestors.has(rootIndex) ||
+                parents.get(rootIndex) === null ||
+                !hierarchy ||
+                !skin.joints.every(jointIndex => hierarchy.has(jointIndex)) ||
+                Array.from(hierarchy).some(index => reachable.has(index) ||
+                    nodes[index].mesh !== undefined ||
+                    nodes[index].camera !== undefined ||
+                    nodes[index].extensions !== undefined)) {
+                reportUnsupported(`scene ${sceneIndex} skin ${nodes[nodeIndex].skin} cannot safely attach detached skeleton`);
+                continue;
+            }
+            for (const index of hierarchy)
+                reachable.add(index);
+            plans.push(() => {
+                scene.nodes ||= [];
+                scene.nodes.push(rootIndex);
+                reportNote(`Attached detached skeleton root ${rootIndex} to scene ${sceneIndex}.`);
+            });
+        }
+    }
+    for (const apply of plans)
+        apply();
+    /** Traverse a forest while detecting missing nodes, cycles, and repeated paths. */
+    function collectNodes(roots) {
+        const visited = new Set();
+        const pending = [...roots];
+        while (pending.length) {
+            const index = pending.pop();
+            if (!Number.isSafeInteger(index) ||
+                !nodes[index] ||
+                visited.has(index) ||
+                parents.get(index) === null)
+                return null;
+            visited.add(index);
+            pending.push(...(nodes[index].children || []));
+        }
+        return visited;
+    }
+}
+//# sourceMappingURL=convert-gltf-v1-skin-scenes.js.map

package/dist/gltf/lib/api/convert-gltf-v1-skin-scenes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-gltf-v1-skin-scenes.js","sourceRoot":"","sources":["../../../../src/gltf/lib/api/convert-gltf-v1-skin-scenes.ts"],"names":[],"mappings":"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"}

package/dist/gltf/lib/api/convert-gltf-v1-skins.cjs

@@ -0,0 +1,173 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/gltf/lib/api/convert-gltf-v1-skins.ts
+var convert_gltf_v1_skins_exports = {};
+__export(convert_gltf_v1_skins_exports, {
+  convertGLTFV1Skins: () => convertGLTFV1Skins
+});
+module.exports = __toCommonJS(convert_gltf_v1_skins_exports);
+function convertGLTFV1Skins(json, resolveNodeId, reportUnsupported) {
+  const nodes = json.nodes || [];
+  const skins = json.skins || [];
+  const originalSkinCount = skins.length;
+  let hasUnconvertedSkin = false;
+  for (let skinIndex = 0; skinIndex < originalSkinCount; skinIndex++) {
+    const skin = skins[skinIndex];
+    const jointNames = skin.jointNames;
+    if (!Array.isArray(jointNames) || jointNames.length === 0 || jointNames.some((name) => typeof name !== "string" || !name) || new Set(jointNames).size !== jointNames.length) {
+      reportUnsupported(`skin ${skinIndex} has invalid joint names`);
+      hasUnconvertedSkin = true;
+      continue;
+    }
+    const instanceIndices = nodes.flatMap(
+      (node, nodeIndex) => node.skin === skinIndex ? [nodeIndex] : []
+    );
+    const plans = (instanceIndices.length ? instanceIndices : [void 0]).map(
+      (nodeIndex) => resolveSkinInstance(
+        nodes,
+        jointNames,
+        nodeIndex,
+        resolveNodeId,
+        (feature) => reportUnsupported(`skin ${skinIndex} ${feature}`)
+      )
+    );
+    const hasFailedPlan = plans.some((plan) => !plan);
+    hasUnconvertedSkin ||= hasFailedPlan;
+    const convertedBindings = /* @__PURE__ */ new Map();
+    for (const plan of plans) {
+      if (!plan) continue;
+      const bindingKey = `${plan.skeletonIndex}:${plan.jointIndices.join(",")}`;
+      let convertedSkinIndex = convertedBindings.get(bindingKey);
+      if (convertedSkinIndex === void 0) {
+        const convertedSkin = {
+          ...skin,
+          joints: plan.jointIndices,
+          skeleton: plan.skeletonIndex
+        };
+        delete convertedSkin.jointNames;
+        if (skin.bindShapeMatrix !== void 0 && isIdentityBindShape(skin.bindShapeMatrix)) {
+          delete convertedSkin.bindShapeMatrix;
+        }
+        if (!hasFailedPlan && convertedBindings.size === 0) {
+          convertedSkinIndex = skinIndex;
+          skins[skinIndex] = convertedSkin;
+        } else {
+          delete convertedSkin.id;
+          convertedSkinIndex = skins.length;
+          skins.push(convertedSkin);
+        }
+        convertedBindings.set(bindingKey, convertedSkinIndex);
+      }
+      if (plan.nodeIndex !== void 0) {
+        nodes[plan.nodeIndex].skin = convertedSkinIndex;
+        delete nodes[plan.nodeIndex].skeletons;
+      }
+    }
+  }
+  if (!hasUnconvertedSkin) {
+    for (const node of nodes) delete node.jointName;
+  }
+}
+function resolveSkinInstance(nodes, jointNames, nodeIndex, resolveNodeId, reportUnsupported) {
+  const skeletonIds = nodeIndex === void 0 ? void 0 : nodes[nodeIndex].skeletons;
+  if (skeletonIds !== void 0 && (!Array.isArray(skeletonIds) || skeletonIds.some((id) => typeof id !== "string" || !id) || new Set(skeletonIds).size !== skeletonIds.length)) {
+    reportUnsupported("has invalid skeleton roots");
+    return null;
+  }
+  const explicitRoots = (skeletonIds || []).map(resolveNodeId);
+  const candidates = !explicitRoots.length ? nodes.map((node, candidateIndex) => candidateIndex) : collectSkeletonNodes(nodes, explicitRoots);
+  if (!candidates) {
+    reportUnsupported("has invalid or overlapping skeleton subtrees");
+    return null;
+  }
+  const jointIndices = [];
+  const namedCandidates = /* @__PURE__ */ new Map();
+  for (const candidateIndex of candidates) {
+    const jointName = nodes[candidateIndex].jointName;
+    if (jointName === void 0) continue;
+    const matches = namedCandidates.get(jointName) || [];
+    matches.push(candidateIndex);
+    namedCandidates.set(jointName, matches);
+  }
+  for (const jointName of jointNames) {
+    const matches = namedCandidates.get(jointName) || [];
+    if (matches.length !== 1) {
+      reportUnsupported(`cannot uniquely resolve joint ${jointName}`);
+      return null;
+    }
+    jointIndices.push(matches[0]);
+  }
+  const commonRoot = findCommonJointRoot(nodes, [...jointIndices, ...explicitRoots]);
+  if (commonRoot === void 0) {
+    reportUnsupported("joints have no unambiguous common hierarchy root");
+    return null;
+  }
+  return {
+    nodeIndex,
+    jointIndices,
+    skeletonIndex: explicitRoots.length === 1 ? explicitRoots[0] : commonRoot
+  };
+}
+function collectSkeletonNodes(nodes, rootIndices) {
+  const visited = /* @__PURE__ */ new Set();
+  const pending = [...rootIndices];
+  while (pending.length) {
+    const nodeIndex = pending.pop();
+    if (!Number.isSafeInteger(nodeIndex) || !nodes[nodeIndex] || visited.has(nodeIndex))
+      return null;
+    visited.add(nodeIndex);
+    pending.push(...nodes[nodeIndex].children || []);
+  }
+  return Array.from(visited);
+}
+function findCommonJointRoot(nodes, jointIndices) {
+  const parents = /* @__PURE__ */ new Map();
+  for (const [nodeIndex, node] of nodes.entries()) {
+    for (const childIndex of node.children || []) {
+      if (!Number.isSafeInteger(childIndex) || !nodes[childIndex] || parents.has(childIndex))
+        return void 0;
+      parents.set(childIndex, nodeIndex);
+    }
+  }
+  const ancestorPaths = jointIndices.map((jointIndex) => {
+    const path = [];
+    const visited = /* @__PURE__ */ new Set();
+    let ancestorIndex = jointIndex;
+    while (ancestorIndex !== void 0) {
+      if (visited.has(ancestorIndex)) return [];
+      visited.add(ancestorIndex);
+      path.push(ancestorIndex);
+      ancestorIndex = parents.get(ancestorIndex);
+    }
+    return path;
+  });
+  const ancestorSets = ancestorPaths.map((path) => new Set(path));
+  return ancestorPaths[0].find(
+    (ancestorIndex) => ancestorSets.every((ancestors) => ancestors.has(ancestorIndex))
+  );
+}
+function isIdentityBindShape(matrix) {
+  return Array.isArray(matrix) && matrix.length === 16 && Array.from(matrix).every((value, index) => value === (index % 5 === 0 ? 1 : 0));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertGLTFV1Skins
+});
+//# sourceMappingURL=convert-gltf-v1-skins.cjs.map

package/dist/gltf/lib/api/convert-gltf-v1-skins.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/gltf/lib/api/convert-gltf-v1-skins.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {GLTF, GLTFNode, GLTFSkin} from '../types/gltf-types';\n\n/** Legacy node fields used to resolve one skin instance. */\ntype LegacyNode = GLTFNode & {\n  /** Symbolic name referenced by a glTF 1 skin. */\n  jointName?: string;\n  /** Root node IDs selecting this instance's skeleton hierarchy. */\n  skeletons?: string[];\n};\n\n/** Legacy skin fields, before joint names become node indices. */\ntype LegacySkin = Omit<GLTFSkin, 'joints'> & {\n  /** Ordered symbolic joint names, matching inverse-bind matrix order. */\n  jointNames?: string[];\n  /** Optional existing joint indices on a hybrid input. */\n  joints?: number[];\n  /** Matrix to bake into geometry or inverse-bind matrices; absent means identity. */\n  bindShapeMatrix?: number[];\n};\n\n/** A resolved skin binding for one mesh node, or for an unused skin. */\ntype SkinInstancePlan = {\n  /** Mesh node using this binding, absent for an unused skin. */\n  nodeIndex?: number;\n  /** Ordered glTF 2 joint node indices. */\n  jointIndices: number[];\n  /** Explicit skeleton root or the inferred common ancestor. */\n  skeletonIndex: number;\n};\n\n/**\n * Resolve glTF 1 joint names inside each instance's skeleton hierarchy.\n * Shared skins are cloned when instances use different joint nodes. Non-identity bind shapes\n * remain available for binary baking. Multiple explicit roots are supported when their\n * disjoint subtrees resolve every joint uniquely and share an unambiguous common ancestor.\n */\nexport function convertGLTFV1Skins(\n  json: GLTF,\n  resolveNodeId: (nodeId: string) => number,\n  reportUnsupported: (feature: string) => void\n): void {\n  const nodes = (json.nodes || []) as LegacyNode[];\n  const skins = (json.skins || []) as LegacySkin[];\n  const originalSkinCount = skins.length;\n  let hasUnconvertedSkin = false;\n\n  for (let skinIndex = 0; skinIndex < originalSkinCount; skinIndex++) {\n    const skin = skins[skinIndex];\n    const jointNames = skin.jointNames;\n    if (\n      !Array.isArray(jointNames) ||\n      jointNames.length === 0 ||\n      jointNames.some(name => typeof name !== 'string' || !name) ||\n      new Set(jointNames).size !== jointNames.length\n    ) {\n      reportUnsupported(`skin ${skinIndex} has invalid joint names`);\n      hasUnconvertedSkin = true;\n      continue;\n    }\n\n    const instanceIndices = nodes.flatMap((node, nodeIndex) =>\n      node.skin === skinIndex ? [nodeIndex] : []\n    );\n    const plans = (instanceIndices.length ? instanceIndices : [undefined]).map(nodeIndex =>\n      resolveSkinInstance(nodes, jointNames, nodeIndex, resolveNodeId, feature =>\n        reportUnsupported(`skin ${skinIndex} ${feature}`)\n      )\n    );\n    const hasFailedPlan = plans.some(plan => !plan);\n    hasUnconvertedSkin ||= hasFailedPlan;\n    const convertedBindings = new Map<string, number>();\n\n    for (const plan of plans) {\n      if (!plan) continue;\n      const bindingKey = `${plan.skeletonIndex}:${plan.jointIndices.join(',')}`;\n      let convertedSkinIndex = convertedBindings.get(bindingKey);\n      if (convertedSkinIndex === undefined) {\n        const convertedSkin: LegacySkin = {\n          ...skin,\n          joints: plan.jointIndices,\n          skeleton: plan.skeletonIndex\n        };\n        delete convertedSkin.jointNames;\n        if (skin.bindShapeMatrix !== undefined && isIdentityBindShape(skin.bindShapeMatrix)) {\n          delete convertedSkin.bindShapeMatrix;\n        }\n        if (!hasFailedPlan && convertedBindings.size === 0) {\n          convertedSkinIndex = skinIndex;\n          skins[skinIndex] = convertedSkin;\n        } else {\n          delete convertedSkin.id;\n          convertedSkinIndex = skins.length;\n          skins.push(convertedSkin);\n        }\n        convertedBindings.set(bindingKey, convertedSkinIndex);\n      }\n      if (plan.nodeIndex !== undefined) {\n        nodes[plan.nodeIndex].skin = convertedSkinIndex;\n        delete nodes[plan.nodeIndex].skeletons;\n      }\n    }\n  }\n  // Keep symbolic names available when a best-effort result contains an unresolved legacy skin.\n  if (!hasUnconvertedSkin) {\n    for (const node of nodes) delete node.jointName;\n  }\n}\n\n/** Resolve ordered names within explicit subtrees, or uniquely across the document. */\nfunction resolveSkinInstance(\n  nodes: LegacyNode[],\n  jointNames: string[],\n  nodeIndex: number | undefined,\n  resolveNodeId: (nodeId: string) => number,\n  reportUnsupported: (feature: string) => void\n): SkinInstancePlan | null {\n  const skeletonIds = nodeIndex === undefined ? undefined : nodes[nodeIndex].skeletons;\n  if (\n    skeletonIds !== undefined &&\n    (!Array.isArray(skeletonIds) ||\n      skeletonIds.some(id => typeof id !== 'string' || !id) ||\n      new Set(skeletonIds).size !== skeletonIds.length)\n  ) {\n    reportUnsupported('has invalid skeleton roots');\n    return null;\n  }\n  const explicitRoots = (skeletonIds || []).map(resolveNodeId);\n  const candidates = !explicitRoots.length\n    ? nodes.map((node, candidateIndex) => candidateIndex)\n    : collectSkeletonNodes(nodes, explicitRoots);\n  if (!candidates) {\n    reportUnsupported('has invalid or overlapping skeleton subtrees');\n    return null;\n  }\n  const jointIndices: number[] = [];\n  const namedCandidates = new Map<string, number[]>();\n  for (const candidateIndex of candidates) {\n    const jointName = nodes[candidateIndex].jointName;\n    if (jointName === undefined) continue;\n    const matches = namedCandidates.get(jointName) || [];\n    matches.push(candidateIndex);\n    namedCandidates.set(jointName, matches);\n  }\n  for (const jointName of jointNames) {\n    const matches = namedCandidates.get(jointName) || [];\n    if (matches.length !== 1) {\n      reportUnsupported(`cannot uniquely resolve joint ${jointName}`);\n      return null;\n    }\n    jointIndices.push(matches[0]);\n  }\n  const commonRoot = findCommonJointRoot(nodes, [...jointIndices, ...explicitRoots]);\n  if (commonRoot === undefined) {\n    reportUnsupported('joints have no unambiguous common hierarchy root');\n    return null;\n  }\n  return {\n    nodeIndex,\n    jointIndices,\n    skeletonIndex: explicitRoots.length === 1 ? explicitRoots[0] : commonRoot\n  };\n}\n\n/** Collect disjoint subtrees, rejecting missing nodes, cycles, and overlapping paths. */\nfunction collectSkeletonNodes(nodes: LegacyNode[], rootIndices: number[]): number[] | null {\n  const visited = new Set<number>();\n  const pending = [...rootIndices];\n  while (pending.length) {\n    const nodeIndex = pending.pop()!;\n    if (!Number.isSafeInteger(nodeIndex) || !nodes[nodeIndex] || visited.has(nodeIndex))\n      return null;\n    visited.add(nodeIndex);\n    pending.push(...(nodes[nodeIndex].children || []));\n  }\n  return Array.from(visited);\n}\n\n/** Find the closest common ancestor, rejecting cycles and multiply-parented node graphs. */\nfunction findCommonJointRoot(nodes: LegacyNode[], jointIndices: number[]): number | undefined {\n  const parents = new Map<number, number>();\n  for (const [nodeIndex, node] of nodes.entries()) {\n    for (const childIndex of node.children || []) {\n      if (!Number.isSafeInteger(childIndex) || !nodes[childIndex] || parents.has(childIndex))\n        return undefined;\n      parents.set(childIndex, nodeIndex);\n    }\n  }\n  const ancestorPaths = jointIndices.map(jointIndex => {\n    const path: number[] = [];\n    const visited = new Set<number>();\n    let ancestorIndex: number | undefined = jointIndex;\n    while (ancestorIndex !== undefined) {\n      if (visited.has(ancestorIndex)) return [];\n      visited.add(ancestorIndex);\n      path.push(ancestorIndex);\n      ancestorIndex = parents.get(ancestorIndex);\n    }\n    return path;\n  });\n  const ancestorSets = ancestorPaths.map(path => new Set(path));\n  return ancestorPaths[0].find(ancestorIndex =>\n    ancestorSets.every(ancestors => ancestors.has(ancestorIndex))\n  );\n}\n\n/** Check exact identity; even small non-identity values require actual matrix baking. */\nfunction isIdentityBindShape(matrix: number[]): boolean {\n  return (\n    Array.isArray(matrix) &&\n    matrix.length === 16 &&\n    Array.from(matrix).every((value, index) => value === (index % 5 === 0 ? 1 : 0))\n  );\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/gltf/lib/api/convert-gltf-v1-skins.d.ts

@@ -0,0 +1,9 @@
+import type { GLTF } from "../types/gltf-types.js";
+/**
+ * Resolve glTF 1 joint names inside each instance's skeleton hierarchy.
+ * Shared skins are cloned when instances use different joint nodes. Non-identity bind shapes
+ * remain available for binary baking. Multiple explicit roots are supported when their
+ * disjoint subtrees resolve every joint uniquely and share an unambiguous common ancestor.
+ */
+export declare function convertGLTFV1Skins(json: GLTF, resolveNodeId: (nodeId: string) => number, reportUnsupported: (feature: string) => void): void;
+//# sourceMappingURL=convert-gltf-v1-skins.d.ts.map

package/dist/gltf/lib/api/convert-gltf-v1-skins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-gltf-v1-skins.d.ts","sourceRoot":"","sources":["../../../../src/gltf/lib/api/convert-gltf-v1-skins.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,IAAI,EAAqB,+BAA4B;AA8BlE;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,IAAI,EACV,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,EACzC,iBAAiB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAC3C,IAAI,CAkEN"}