@downdraft/engine 0.1.0 → 0.1.2-alpha.5

package/dist/libraries/models/src/index.js

@@ -0,0 +1,46 @@
+// ============================================================================
+// Model Loading Library — format parsers for FBX, GLTF/GLB, OBJ, DAE, STL
+// ============================================================================
+// Pure parsers: ArrayBuffer + filename → ModelData (glTF is async due to codec
+// dispatch; other formats remain synchronous).
+// Async loaders: URI → fetch → parse (for AssetManager integration).
+//
+// Codec registry + bundled codecs
+export { configureBasisuWasmPath, configureDracoWasmPath, createBasisuTextureCodec, createDracoMeshCodec, createMeshoptBufferViewCodec, getDefaultCodecRegistry, GLTFCodecRegistry, registerDefaultCodecs, setDefaultCodecRegistry } from "./codecs/index.js";
+export { parseDAE } from "./dae.js";
+export { parseDXF } from "./dxf.js";
+export { parseGLTF } from "./gltf.js";
+export { extractTextureTransform, getSupportedExtensions, isExtensionSupported, parseAnimationEvents, parseMorphTargets, processMaterialExtensions, processMeshPrimitiveExtensions } from "./gltf-extensions.js";
+export { parseOBJ } from "./obj.js";
+export { parseOFF } from "./off.js";
+export { parsePLY } from "./ply.js";
+export { parseSTL } from "./stl.js";
+export { parse3DS } from "./threeds.js";
+export { parse3MF } from "./threemf.js";
+export { detectFormat, getMaterialVariant } from "./types.js";
+export { parseVTK } from "./vtk.js";
+export { declaredCompanionUri, loadModel } from "./loader.js";
+// FBX parser (for direct parsing without normalization)
+export { parseFBX } from "./fbx/index.js";
+// Model normalization — import-time correction (up-axis, units, node transforms, bounds)
+export { bakeNodeTransforms } from "./bake-node-transforms.js";
+export { bindUnskinnedMeshes } from "./bind-unskinned-meshes.js";
+export { normalizeModel, normalizeModelWithResolution, resolveImportSettings, resolveImportSettingsSync } from "./normalize.js";
+export { synthesizeSkeletonSkin } from "./skeleton-synthesis.js";
+// CPU pose sampling — AnimationData → AnimationClip → skin matrices
+export { buildClip, PoseSampler } from "./pose-sampler.js";
+// Default outfit selection for skinned variant-packed character models
+export { defaultCharacterMeshIndices, defaultCharacterParts } from "./default-part-selection.js";
+// Sidecar system — per-model import settings
+export { parseBlenderExtras } from "./sidecar/blender-extras.js";
+export { createDefaultDdmeta, parseDdmeta, writeDdmeta } from "./sidecar/ddmeta.js";
+export { parseGodotImport } from "./sidecar/godot-import.js";
+export { ddmetaPath, godotImportPath, unityMetaPath } from "./sidecar/resolver.js";
+export { createDefaultImportSettings, mergeImportSettings } from "./sidecar/types.js";
+export { parseUnityMeta } from "./sidecar/unity-meta.js";
+// Material adapter — bridges serialized MaterialData to the core Material surface.
+export { materialDataArrayToMaterials, materialDataToMaterial } from "./material-adapter.js";
+import { createModelAsyncLoader, registerModelLoaders } from "./loader.js";
+export { createModelAsyncLoader, registerModelLoaders };
+// Engine library descriptor (declarative GameModule wiring)
+export { ModelLoaderTok, ModelsLib } from "./library.js";

package/dist/libraries/models/src/library.js

@@ -0,0 +1,44 @@
+// ============================================================================
+// ModelsLib — declarative engine library descriptor for @downdraft/engine/libraries/models
+//
+// Games declare `libraries: [ModelsLib]` (or with config override) in their
+// GameModule. The host creates the async model loader (renderer-side only —
+// model loading + parsing happens on the renderer thread where the GPU device
+// and AssetManager live) and exposes it via the ModelLoaderTok typed token.
+//
+// Games that need full control can still import loadModel /
+// createModelAsyncLoader / registerModelLoaders directly (escape hatch).
+// ============================================================================
+import { resourceToken } from "@downdraft/engine";
+import { createModelAsyncLoader } from "./loader.js";
+/** Token for the renderer-side async model loader. Inject in renderer systems. */
+export const ModelLoaderTok = resourceToken("models:loader");
+// ── Descriptor ──
+export const ModelsLib = {
+    name: "models",
+    version: "1.0.0",
+    // No SAB channels — model loading is renderer-only; parsed ModelData is
+    // consumed in-process by the renderer's mesh upload path.
+    sabChannels: [],
+    provides: [ModelLoaderTok],
+    // No sim setup — model loading happens entirely on the renderer thread.
+    renderer: {
+        init(config, ctx) {
+            const loader = createModelAsyncLoader({
+                normalize: config.normalize,
+                fetchFn: config.fetchFn,
+                mtlResolver: config.mtlResolver,
+                binResolver: config.binResolver,
+                sidecarResolver: config.sidecarResolver,
+            });
+            ctx.provide(ModelLoaderTok, loader);
+            return loader;
+        },
+        dispose(_loader) {
+            // The async loader is a pure function — no GPU resources or state to free.
+        },
+    },
+    defaultConfig: {
+        normalize: true,
+    },
+};

package/dist/libraries/models/src/loader.js

@@ -0,0 +1,218 @@
+// ============================================================================
+// Model Loader — parser dispatch + async loader helpers
+// ============================================================================
+// glTF/GLB parsing is async (codec dispatch for Draco/meshopt). Other formats
+// remain synchronous but are wrapped in async for uniform call sites.
+//
+import { MAX_FETCH_SIZE } from "@downdraft/engine";
+import { getDefaultCodecRegistry } from "./codecs/registry.js";
+import { parseDAE } from "./dae.js";
+import { parseDXF } from "./dxf.js";
+import { parseFBX } from "./fbx/index.js";
+import { parseGLTF } from "./gltf.js";
+import { normalizeModel, normalizeModelWithResolution, resolveImportSettingsSync } from "./normalize.js";
+import { parseOBJ } from "./obj.js";
+import { parseOFF } from "./off.js";
+import { parsePLY } from "./ply.js";
+import { synthesizeSkeletonSkin } from "./skeleton-synthesis.js";
+import { parseSTL } from "./stl.js";
+import { parse3DS } from "./threeds.js";
+import { parse3MF } from "./threemf.js";
+import { detectFormat } from "./types.js";
+import { parseVTK } from "./vtk.js";
+/**
+ * Companion filename declared inside the model file — `mtllib` for OBJ and
+ * `buffers[0].uri` for glTF. Real assets frequently name sidecars something
+ * other than `<stem>.mtl`/`<stem>.bin`, so resolve the declared name first.
+ */
+export function declaredCompanionUri(data, format) {
+    if (format === "obj") {
+        const m = new TextDecoder().decode(data.slice(0, 65536)).match(/^[ \t]*mtllib[ \t]+(.+?)[ \t]*$/m);
+        // mtllib can be a space-separated list; take the first entry.
+        return m?.[1]?.split(/\s+/)[0] ?? null;
+    }
+    if (format === "gltf") {
+        try {
+            const json = JSON.parse(new TextDecoder().decode(data));
+            const uri = json?.buffers?.[0]?.uri;
+            return typeof uri === "string" && !uri.startsWith("data:") ? uri : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+export async function loadModel(data, filename, mtlData, binData, options) {
+    const format = detectFormat(filename);
+    if (!format)
+        throw new Error(`Unknown model format: ${filename}`);
+    const baseName = filename.replace(/\.[^.]+$/, "");
+    const registry = options?.codecRegistry ?? getDefaultCodecRegistry();
+    const shouldNormalize = options?.normalize ?? true;
+    let modelData;
+    switch (format) {
+        case "obj":
+            modelData = parseOBJ(data, baseName, mtlData);
+            break;
+        case "gltf":
+            modelData = await parseGLTF(data, baseName, false, binData, { registry });
+            break;
+        case "glb":
+            modelData = await parseGLTF(data, baseName, true, null, { registry });
+            break;
+        case "fbx":
+            modelData = parseFBX(data, baseName);
+            break;
+        case "dae":
+            modelData = parseDAE(data, baseName);
+            break;
+        case "stl":
+            modelData = parseSTL(data, baseName);
+            break;
+        case "ply":
+            modelData = parsePLY(data, baseName);
+            break;
+        case "3ds":
+            modelData = parse3DS(data, baseName);
+            break;
+        case "off":
+            modelData = parseOFF(data, baseName);
+            break;
+        case "vtk":
+            modelData = parseVTK(data, baseName);
+            break;
+        case "dxf":
+            modelData = parseDXF(data, baseName);
+            break;
+        case "3mf":
+            modelData = parse3MF(data, baseName);
+            break;
+        default:
+            throw new Error(`Unknown model format: ${filename}`);
+    }
+    synthesizeSkeletonIfNeeded(modelData);
+    if (!shouldNormalize)
+        return modelData;
+    // Use custom sidecar resolver if provided, otherwise use sync parser defaults.
+    // The async path (normalizeModelWithResolution) is used by createModelAsyncLoader
+    // which has the full URI for sidecar fetching.
+    if (options?.sidecarResolver) {
+        const settings = await options.sidecarResolver(filename, modelData);
+        return normalizeModel(modelData, settings);
+    }
+    // Synchronous fallback: use parser-detected defaults (no sidecar fetching)
+    const settings = resolveImportSettingsSync(modelData);
+    return normalizeModel(modelData, settings);
+}
+async function defaultFetch(uri) {
+    return fetch(uri);
+}
+/**
+ * Animation-only / skeleton-only files (e.g. Mixamo clip exports) carry a
+ * node hierarchy but no skin deformers and no meshes. Synthesize a SkinData
+ * from the node tree so viewers, animators, and retargeting can use it.
+ * Runs before normalization so skin.normalizationMatrix is accumulated.
+ */
+function synthesizeSkeletonIfNeeded(modelData) {
+    if (modelData.skin || modelData.meshes.length > 0 || !modelData.nodes?.length)
+        return;
+    modelData.skin = synthesizeSkeletonSkin(modelData.nodes, modelData.animations ?? [], modelData.sourceUpAxis);
+}
+export function createModelAsyncLoader(opts = {}) {
+    const fetchFn = opts.fetchFn ?? defaultFetch;
+    const registry = opts.codecRegistry ?? getDefaultCodecRegistry();
+    const shouldNormalize = opts.normalize ?? true;
+    return async function loadModelAsync(uri) {
+        const filename = uri.split("/").pop() ?? uri;
+        const format = detectFormat(filename);
+        if (!format)
+            throw new Error(`Unknown model format: ${filename}`);
+        const resp = await fetchFn(uri);
+        if (!resp.ok)
+            throw new Error(`Failed to fetch ${uri}: ${resp.status}`);
+        // Abort if Content-Length exceeds the maximum fetch size
+        const contentLength = parseInt(resp.headers.get("Content-Length") ?? "", 10);
+        if (Number.isFinite(contentLength) && contentLength > MAX_FETCH_SIZE) {
+            throw new RangeError(`Model fetch ${uri}: Content-Length ${contentLength} exceeds max ${MAX_FETCH_SIZE}`);
+        }
+        const data = await resp.arrayBuffer();
+        const baseName = filename.replace(/\.[^.]+$/, "");
+        let modelData;
+        switch (format) {
+            case "obj": {
+                let mtlData = null;
+                if (opts.mtlResolver) {
+                    const dir = uri.slice(0, uri.lastIndexOf("/") + 1);
+                    const declared = declaredCompanionUri(data, "obj");
+                    if (declared)
+                        mtlData = await opts.mtlResolver(dir + decodeURIComponent(declared));
+                    mtlData ??= await opts.mtlResolver(uri.replace(/\.[^.]+$/, ".mtl"));
+                }
+                modelData = parseOBJ(data, baseName, mtlData);
+                break;
+            }
+            case "gltf": {
+                let binData = null;
+                if (opts.binResolver) {
+                    const dir = uri.slice(0, uri.lastIndexOf("/") + 1);
+                    const declared = declaredCompanionUri(data, "gltf");
+                    if (declared)
+                        binData = await opts.binResolver(dir + decodeURIComponent(declared));
+                    binData ??= await opts.binResolver(uri.replace(/\.[^.]+$/, ".bin"));
+                }
+                modelData = await parseGLTF(data, baseName, false, binData, { registry });
+                break;
+            }
+            case "glb":
+                modelData = await parseGLTF(data, baseName, true, null, { registry });
+                break;
+            case "fbx":
+                modelData = parseFBX(data, baseName);
+                break;
+            case "dae":
+                modelData = parseDAE(data, baseName);
+                break;
+            case "stl":
+                modelData = parseSTL(data, baseName);
+                break;
+            case "ply":
+                modelData = parsePLY(data, baseName);
+                break;
+            case "3ds":
+                modelData = parse3DS(data, baseName);
+                break;
+            case "off":
+                modelData = parseOFF(data, baseName);
+                break;
+            case "vtk":
+                modelData = parseVTK(data, baseName);
+                break;
+            case "dxf":
+                modelData = parseDXF(data, baseName);
+                break;
+            case "3mf":
+                modelData = parse3MF(data, baseName);
+                break;
+            default:
+                throw new Error(`Unknown model format: ${filename}`);
+        }
+        synthesizeSkeletonIfNeeded(modelData);
+        if (!shouldNormalize)
+            return modelData;
+        // Use custom sidecar resolver if provided
+        if (opts.sidecarResolver) {
+            const settings = await opts.sidecarResolver(uri, modelData);
+            return normalizeModel(modelData, settings);
+        }
+        // Default: async sidecar resolution (fetches .ddmeta.json, .meta, .import)
+        return normalizeModelWithResolution(modelData, uri, { fetchFn });
+    };
+}
+export function registerModelLoaders(assetManager, opts = {}) {
+    const loader = createModelAsyncLoader(opts);
+    const extensions = ["fbx", "gltf", "glb", "obj", "dae", "stl", "ply", "3ds", "off", "vtk", "dxf", "3mf"];
+    extensions.forEach((ext) => {
+        assetManager.registerLoader(ext, loader);
+    });
+}

package/dist/libraries/models/src/material-adapter.js

@@ -0,0 +1,82 @@
+// Material adapter — bridges the serialized asset format (MaterialData) to the
+// core engine's unified Material surface. MaterialData stays as the on-disk
+// glTF/obj material format; this adapter maps it onto a core Material that
+// uses the shader-graph pipeline (PBR profile, graph or fallback physical .wgsl).
+//
+// The game's renderer delegates material upload to the core surface via this
+// adapter, retiring the parallel material rendering path.
+import { BlendMode, CullMode, DEFAULT_VARIANT_FLAGS, Material, MaterialType } from "@downdraft/engine";
+const PHYSICAL_WGSL = "// Physical material — extends PBR with clearcoat, transmission, sheen, iridescence\n// Forward-rendered, Cook-Torrance BRDF + clearcoat layer\n\nstruct PhysicalUniforms {\n  baseColor: vec4<f32>,\n  roughness: f32,\n  metallic: f32,\n  clearcoat: f32,\n  clearcoatRoughness: f32,\n  transmission: f32,\n  ior: f32,\n  thickness: f32,\n  sheenColor: vec3<f32>,\n  sheenRoughness: f32,\n  iridescence: f32,\n  iridescenceIOR: f32,\n  attenuationColor: vec3<f32>,\n  attenuationDistance: f32,\n  envMapIntensity: f32,\n  _pad: f32,\n  _pad2: f32,\n  emissive: vec3<f32>,\n};\n\nstruct CameraUniforms {\n  viewProj: mat4x4<f32>,\n  cameraPos: vec3<f32>,\n  _pad: f32,\n};\n\nstruct ModelUniforms {\n  model: mat4x4<f32>,\n  normalMatrix: mat4x4<f32>,\n};\n\nstruct LightUniforms {\n  dirDirection: vec4<f32>,\n  dirColor: vec4<f32>,\n};\n\n@group(0) @binding(0) var<uniform> mat: PhysicalUniforms;\n@group(0) @binding(1) var<uniform> camera: CameraUniforms;\n@group(0) @binding(2) var<uniform> model: ModelUniforms;\n@group(0) @binding(3) var<uniform> lights: LightUniforms;\n@group(0) @binding(4) var albedoMap: texture_2d<f32>;\n@group(0) @binding(5) var normalMap: texture_2d<f32>;\n@group(0) @binding(6) var clearcoatNormalMap: texture_2d<f32>;\n@group(0) @binding(7) var texSampler: sampler;\n\nconst PI = 3.14159265359;\n\nfn distributionGGX(N: vec3<f32>, H: vec3<f32>, roughness: f32) -> f32 {\n  let a = roughness * roughness;\n  let a2 = a * a;\n  let NdotH = max(dot(N, H), 0.0);\n  let NdotH2 = NdotH * NdotH;\n  let nom = a2;\n  let denom = NdotH2 * (a2 - 1.0) + 1.0;\n  return nom / (PI * denom * denom);\n}\n\nfn geometrySmith(N: vec3<f32>, V: vec3<f32>, L: vec3<f32>, roughness: f32) -> f32 {\n  let r = roughness + 1.0;\n  let k = (r * r) / 8.0;\n  let NdotV = max(dot(N, V), 0.0);\n  let NdotL = max(dot(N, L), 0.0);\n  let ggxV = NdotV / (NdotV * (1.0 - k) + k);\n  let ggxL = NdotL / (NdotL * (1.0 - k) + k);\n  return ggxV * ggxL;\n}\n\nfn fresnelSchlick(cosTheta: f32, F0: vec3<f32>) -> vec3<f32> {\n  return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);\n}\n\nfn fresnelSchlickRoughness(cosTheta: f32, F0: vec3<f32>, roughness: f32) -> vec3<f32> {\n  return F0 + (max(vec3<f32>(1.0 - roughness), F0) - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);\n}\n\nstruct VertexInput {\n  @location(0) position: vec3<f32>,\n  @location(1) normal: vec3<f32>,\n  @location(2) uv: vec2<f32>,\n  @location(3) tangent: vec3<f32>,\n};\n\nstruct VertexOutput {\n  @builtin(position) clipPosition: vec4<f32>,\n  @location(0) uv: vec2<f32>,\n  @location(1) worldNormal: vec3<f32>,\n  @location(2) worldPos: vec3<f32>,\n  @location(3) worldTangent: vec3<f32>,\n};\n\n@vertex\nfn vs_main(input: VertexInput) -> VertexOutput {\n  var output: VertexOutput;\n  let worldPos = model.model * vec4<f32>(input.position, 1.0);\n  output.clipPosition = camera.viewProj * worldPos;\n  output.uv = input.uv;\n  output.worldNormal = normalize((model.normalMatrix * vec4<f32>(input.normal, 0.0)).xyz);\n  output.worldPos = worldPos.xyz;\n  output.worldTangent = normalize((model.normalMatrix * vec4<f32>(input.tangent, 0.0)).xyz);\n  return output;\n}\n\n@fragment\nfn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {\n  let N = normalize(input.worldNormal);\n  let V = normalize(camera.cameraPos - input.worldPos);\n\n  let albedo = textureSample(albedoMap, texSampler, input.uv).rgb * mat.baseColor.rgb;\n  let F0 = mix(vec3<f32>(0.04), albedo, mat.metallic);\n\n  let L = normalize(-lights.dirDirection.xyz);\n  let H = normalize(V + L);\n  let NdotL = max(dot(N, L), 0.0);\n\n  let NDF = distributionGGX(N, H, mat.roughness);\n  let G = geometrySmith(N, V, L, mat.roughness);\n  let F = fresnelSchlick(max(dot(H, V), 0.0), F0);\n\n  let numerator = NDF * G * F;\n  let denominator = 4.0 * max(dot(N, V), 0.0) * NdotL + 0.0001;\n  let specular = numerator / denominator;\n\n  let kS = F;\n  let kD = (vec3<f32>(1.0) - kS) * (1.0 - mat.metallic);\n\n  let diffuse = kD * albedo / PI;\n  var color = (diffuse + specular) * lights.dirColor.rgb * NdotL;\n\n  if (mat.clearcoat > 0.0) {\n    let ccN = normalize(textureSample(clearcoatNormalMap, texSampler, input.uv).xyz * 2.0 - 1.0);\n    let ccF0 = vec3<f32>(0.04);\n    let ccNDF = distributionGGX(ccN, H, mat.clearcoatRoughness);\n    let ccG = geometrySmith(ccN, V, L, mat.clearcoatRoughness);\n    let ccF = fresnelSchlick(max(dot(H, V), 0.0), ccF0);\n    let ccSpec = (ccNDF * ccG * ccF) / (4.0 * max(dot(ccN, V), 0.0) * NdotL + 0.0001);\n    color = mix(color, color + ccSpec * lights.dirColor.rgb * NdotL, mat.clearcoat);\n  }\n\n  if (mat.sheenRoughness < 1.0) {\n    let sheenF = pow(1.0 - max(dot(N, V), 0.0), 5.0) * (1.0 - mat.sheenRoughness);\n    color += mat.sheenColor * sheenF * NdotL * 0.3;\n  }\n\n  let ambient = albedo * 0.03 * mat.envMapIntensity;\n  color += ambient;\n\n  return vec4<f32>(color, mat.baseColor.a);\n}\n";
+/**
+ * Convert a serialized MaterialData (glTF/obj material) into a core Material.
+ *
+ * Maps:
+ *   baseColor      → baseColor uniform
+ *   metallic       → metallic uniform
+ *   roughness      → roughness uniform
+ *   emissiveColor  → emissive uniform (if present)
+ *   textureUri     → albedoMap texture binding
+ *   normalTextureUri → normalMap texture binding
+ *
+ * The resulting Material uses the Physical fallback shader (inlineShaderSource
+ * from material-types/physical.wgsl) by default, or a PBR graph if useGraph.
+ */
+export function materialDataToMaterial(md, options = {}) {
+    const name = options.name ?? md.name;
+    const library = options.library;
+    // If the library has a graph-based preset and useGraph is set, use it.
+    if (options.useGraph && library) {
+        const existing = library.get(name);
+        if (existing)
+            return existing;
+        const graphMat = library.createPBRGraph(name);
+        // Apply MaterialData values as uniform overrides.
+        graphMat.setUniform("baseColor", md.baseColor);
+        graphMat.setUniform("metallic", md.metallic);
+        graphMat.setUniform("roughness", md.roughness);
+        if (md.emissiveColor) {
+            graphMat.setUniform("emissive", md.emissiveColor);
+        }
+        return graphMat;
+    }
+    // Determine alpha mode from baseColor alpha and material data.
+    const alphaMode = md.baseColor[3] < 1.0 ? "blend" : "opaque";
+    // Default: create a Physical fallback material with MaterialData mapped to uniforms.
+    const def = {
+        name,
+        shader: "material-types/physical.wgsl",
+        inlineShaderSource: PHYSICAL_WGSL,
+        materialType: MaterialType.Physical,
+        uniforms: {
+            baseColor: { name: "baseColor", type: "vec4", binding: 0 },
+            roughness: { name: "roughness", type: "f32", binding: 1 },
+            metallic: { name: "metallic", type: "f32", binding: 2 },
+        },
+        // Bindless convention: textures are registered into the global
+        // texture_2d_array buckets (@group(3)) and sampled via handles in the
+        // material SSBO — no per-material texture bindings.
+        textures: {},
+        blendMode: alphaMode === "blend" ? BlendMode.AlphaBlend : BlendMode.Opaque,
+        cullMode: CullMode.Back,
+        variantFlags: { ...DEFAULT_VARIANT_FLAGS, alphaMode },
+    };
+    const material = new Material(def);
+    // Apply MaterialData values as uniform overrides.
+    material.setUniform("baseColor", md.baseColor);
+    material.setUniform("metallic", md.metallic);
+    material.setUniform("roughness", md.roughness);
+    if (md.emissiveColor) {
+        material.setUniform("emissive", md.emissiveColor);
+    }
+    if (library) {
+        library.register(material);
+    }
+    return material;
+}
+/**
+ * Batch-convert an array of MaterialData into core Materials, registering
+ * each into the library. Returns the array of created Materials.
+ */
+export function materialDataArrayToMaterials(materials, library, options = {}) {
+    return materials.map((md) => materialDataToMaterial(md, { ...options, library }));
+}

package/dist/libraries/models/src/mini-xml.js

@@ -0,0 +1,145 @@
+// ============================================================================
+// mini-xml.ts — minimal XML parser for runtimes without a real DOMParser.
+//
+// The native runtime's DOMParser is a stub that returns empty results.
+// COLLADA (.dae) parsing needs a small DOM surface: getElementsByTagName,
+// getElementById, getAttribute, textContent, children, tagName. This parser
+// produces exactly that — it is not a general XML implementation (no
+// namespaces, DTDs, or mixed-content fidelity beyond text concatenation).
+// ============================================================================
+class El {
+    tagName;
+    attributes = new Map();
+    children = [];
+    textParts = [];
+    parent = null;
+    ownerDocument = null;
+    constructor(tag) {
+        this.tagName = tag;
+    }
+    get textContent() {
+        let s = this.textParts.join("");
+        this.children.forEach((c) => { s += c.textContent; ; });
+        return s;
+    }
+    getAttribute(name) {
+        return this.attributes.get(name) ?? null;
+    }
+    getElementsByTagName(name) {
+        const out = [];
+        const lower = name.toLowerCase();
+        const walk = (el) => {
+            el.children.forEach((c) => {
+                if (c.tagName.toLowerCase() === lower)
+                    out.push(c);
+                walk(c);
+            });
+        };
+        walk(this);
+        return out;
+    }
+}
+function decodeEntities(s) {
+    return s
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+        .replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(parseInt(d, 10)))
+        .replace(/&amp;/g, "&");
+}
+const ATTR_RE = /([^\s=]+)\s*=\s*("[^"]*"|'[^']*')/g;
+/**
+ * Parse well-formed XML into a MiniXmlDocument. Throws on malformed input.
+ * Tag matching for getElementsByTagName is case-insensitive and ignores
+ * namespace prefixes (`x:foo` matches "foo").
+ */
+export function parseMiniXml(text) {
+    const root = new El("#document");
+    const stack = [root];
+    const byId = new Map();
+    let i = 0;
+    const n = text.length;
+    const top = () => stack[stack.length - 1];
+    while (i < n) {
+        const lt = text.indexOf("<", i);
+        if (lt < 0) {
+            top().textParts.push(decodeEntities(text.slice(i)));
+            break;
+        }
+        if (lt > i)
+            top().textParts.push(decodeEntities(text.slice(i, lt)));
+        // Comments / CDATA / processing instructions / doctype.
+        if (text.startsWith("<!--", lt)) {
+            const end = text.indexOf("-->", lt);
+            i = end < 0 ? n : end + 3;
+            continue;
+        }
+        if (text.startsWith("<![CDATA[", lt)) {
+            const end = text.indexOf("]]>", lt);
+            top().textParts.push(text.slice(lt + 9, end < 0 ? n : end));
+            i = end < 0 ? n : end + 3;
+            continue;
+        }
+        if (text.startsWith("<?", lt)) {
+            const end = text.indexOf("?>", lt);
+            i = end < 0 ? n : end + 2;
+            continue;
+        }
+        if (text.startsWith("<!", lt)) {
+            const end = text.indexOf(">", lt);
+            i = end < 0 ? n : end + 1;
+            continue;
+        }
+        const gt = text.indexOf(">", lt);
+        if (gt < 0)
+            throw new Error("mini-xml: unterminated tag");
+        const inner = text.slice(lt + 1, gt);
+        if (inner.startsWith("/")) {
+            const name = inner.slice(1).trim().toLowerCase();
+            // Pop to the matching open tag (tolerates mis-nested content).
+            for (let s = stack.length - 1; s > 0; s--) {
+                if (stack[s].tagName.toLowerCase() === name) {
+                    stack.length = s;
+                    break;
+                }
+            }
+            i = gt + 1;
+            continue;
+        }
+        const selfClose = inner.endsWith("/");
+        const body = selfClose ? inner.slice(0, -1) : inner;
+        const sp = body.search(/[\s]/);
+        const tag = (sp < 0 ? body : body.slice(0, sp)).trim();
+        // Strip namespace prefix so getElementsByTagName("source") matches <ns:source>.
+        const local = tag.includes(":") ? tag.slice(tag.indexOf(":") + 1) : tag;
+        const el = new El(local);
+        el.parent = top();
+        const attrText = sp < 0 ? "" : body.slice(sp + 1);
+        ATTR_RE.lastIndex = 0;
+        let am;
+        while ((am = ATTR_RE.exec(attrText))) {
+            const key = am[1].includes(":") ? am[1].slice(am[1].indexOf(":") + 1) : am[1];
+            const val = decodeEntities(am[2].slice(1, -1));
+            el.attributes.set(key, val);
+            if (key === "id")
+                byId.set(val, el);
+        }
+        top().children.push(el);
+        if (!selfClose)
+            stack.push(el);
+        i = gt + 1;
+    }
+    const docEl = root.children[0];
+    if (!docEl)
+        throw new Error("mini-xml: no document element");
+    const doc = {
+        documentElement: docEl,
+        getElementsByTagName: (name) => root.getElementsByTagName(name),
+        getElementById: (id) => byId.get(id) ?? null,
+    };
+    const attach = (el) => { el.ownerDocument = doc; el.children.forEach(attach); };
+    attach(docEl);
+    return doc;
+}