@flighthq/scene3d-formats 0.2.1-next.840.857425c

package/dist/awd2Parse.js

@@ -0,0 +1,1533 @@
+import { createAnimationChannel, createAnimationClip, createAnimationTrack } from '@flighthq/animation';
+import { copyMatrix4, createMatrix4, createTransform3D, decomposeMatrix4ToTransform3D, inverseMatrix4, multiplyMatrix4, } from '@flighthq/geometry';
+import { detectImageMimeType } from '@flighthq/image-codec';
+import { reportImportDiagnostic } from '@flighthq/importdiagnostics';
+import { CANONICAL_SKINNED_MESH_GEOMETRY_LAYOUT, computeMeshGeometryNormals, computeMeshGeometryTangents, createMeshGeometry, } from '@flighthq/mesh';
+import { createScene3DFromDocument } from '@flighthq/scene3d';
+import { createShadedMaterial } from '@flighthq/shading';
+import { ImportDiagnosticSeverity, MeshKind, Scene3DAnimationPathRotation, Scene3DAnimationPathScale, Scene3DAnimationPathTranslation, Node3DKind, } from '@flighthq/types';
+import { AWD2_BLOCK_CONTAINER, AWD2_BLOCK_HEADER_BYTES, AWD2_BLOCK_MATERIAL, AWD2_BLOCK_MESH_INSTANCE, AWD2_BLOCK_SKELETON, AWD2_BLOCK_SKELETON_ANIMATION, AWD2_BLOCK_SKELETON_POSE, AWD2_BLOCK_TEXTURE, AWD2_BLOCK_TRIANGLE_GEOMETRY, AWD2_COMPRESSION_NONE, AWD2_DATA_FLOAT32, AWD2_DATA_FLOAT64, AWD2_DATA_INT16, AWD2_DATA_INT32, AWD2_DATA_INT8, AWD2_DATA_UINT16, AWD2_DATA_UINT32, AWD2_DATA_UINT8, AWD2_FORMAT_VERSION, AWD2_HEADER_BYTES, AWD2_MAGIC_0, AWD2_MAGIC_1, AWD2_MAGIC_2, AWD2_MATERIAL_PROP_ALPHA, AWD2_MATERIAL_PROP_COLOR, AWD2_MATERIAL_PROP_DIFFUSE_TEXTURE, AWD2_MATERIAL_PROP_NORMAL_TEXTURE, AWD2_NAMESPACE_CORE, AWD2_STREAM_INDICES, AWD2_STREAM_JOINT_INDICES, AWD2_STREAM_JOINT_WEIGHTS, AWD2_STREAM_NORMALS, AWD2_STREAM_POSITIONS, AWD2_STREAM_TANGENTS, AWD2_STREAM_UVS, AWD2_TEXTURE_TYPE_EMBEDDED, AWD2_VERSION_MAJOR_OFFSET, } from './awd2Schema';
+import { CANONICAL_FLOATS_PER_VERTEX, CANONICAL_LAYOUT, convertTransformLhToRh, createEmbeddedTextureRef, createExternalTextureRef, negateVec3Z, packSkinInfluences, reverseTriangleWinding, SKINNED_FLOATS_PER_VERTEX, } from './shared';
+// Parses an Away3D AWD 2.x binary file into a Scene3D. Convenience over `createScene3DFromDocument(parseAwd2
+// (bytes, diagnostics))`. See parseAwd2 for the import model.
+export function createScene3DFromAwd2(bytes, diagnostics) {
+    return createScene3DFromDocument(parseAwd2(bytes, diagnostics));
+}
+// Parses an Away3D AWD 2.x binary file into a format-neutral Scene3DDocument. The 12-byte header (magic
+// `AWD`, version, flags, compression, body length) is validated, then the block stream is walked to
+// extract geometry blocks (type 1), container blocks (type 22), mesh-instance blocks (type 23), material
+// blocks (type 81), texture blocks (type 82), and the skeleton block (type 101). Mesh instances reference
+// geometry and material blocks by block ID; materials reference texture blocks the same way.
+//
+// The file's skeleton (if any) becomes a skeleton-group + joint node subtree in the document node table
+// (`nodes`) plus one entry in `skins` (its `joints` are those joint node indices, its `inverseBind` the
+// AWD joint matrices, which ARE the inverse bind pose); each skinned sub-mesh's document mesh names that
+// skin by index. Containers become group nodes, mesh instances become mesh nodes (one geometry → one mesh
+// node carrying the instance name; several geometries → a named group of anonymous per-subset mesh nodes),
+// and parenting is expressed through `children` index lists with the unparented nodes as scene roots. Each
+// AWD material becomes a ShadedMaterial in the document `materials` table — AWD's AwayJS MethodMaterial model
+// (BlinnPhong base + method array) maps structurally onto ShadedMaterial (base + modifier stack); see the
+// resolveAwdMaterial note for why the mapping is uniform. It carries the diffuse color+alpha and/or a
+// diffuseMap/normalMap referencing an unresolved AWD texture ImageResourceReference — the parser references,
+// it does not fetch or decode; the resolution is
+// @flighthq/scene3d-resources's explicit pass. The file's skeleton animations become document `animations`
+// whose channels bind by joint node index. Assemble into a live Scene3D with `createScene3DFromDocument`.
+//
+// A compressed body (Away3D's exporter default — deflate or LZMA) is inflated first when a decompressor
+// has been registered for that compression method via `registerAwd2Decompressor`; with no codec registered
+// the file records a diagnostic and returns an empty document. Malformed input records a diagnostic and returns empty rather
+// than throwing.
+export function parseAwd2(bytes, diagnostics) {
+    const input = bytes;
+    if (input.byteLength < AWD2_HEADER_BYTES) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Reject, 'awd2.header-too-short', 'parseAwd2');
+        return emptyAwdDocument();
+    }
+    if (input[0] !== AWD2_MAGIC_0 || input[1] !== AWD2_MAGIC_1 || input[2] !== AWD2_MAGIC_2) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Reject, 'awd2.bad-magic', 'parseAwd2');
+        return emptyAwdDocument();
+    }
+    if (!isAwd2Version(input, diagnostics))
+        return emptyAwdDocument();
+    // A compressed body is inflated (via a registered decompressor) and spliced back behind the header so
+    // the block walk below is identical for compressed and uncompressed input; bails to empty when no codec
+    // is registered for the file's compression method.
+    const rehydrated = rehydrateAwdBody(input, diagnostics);
+    if (rehydrated === null)
+        return emptyAwdDocument();
+    const source = rehydrated.source;
+    const view = rehydrated.view;
+    const bodyLength = view.getUint32(8, true);
+    const bodyEnd = Math.min(AWD2_HEADER_BYTES + bodyLength, source.byteLength);
+    const geometryBlocks = new Map();
+    const containerBlocks = new Map();
+    const meshInstanceBlocks = new Map();
+    const materialBlocks = new Map();
+    const textureBlocks = new Map();
+    const skeletonBlocks = new Map();
+    let offset = AWD2_HEADER_BYTES;
+    while (offset + AWD2_BLOCK_HEADER_BYTES <= bodyEnd) {
+        const blockId = view.getUint32(offset, true);
+        const namespace = source[offset + 4];
+        const blockType = source[offset + 5];
+        const blockFlags = source[offset + 6];
+        const blockLength = view.getUint32(offset + 7, true);
+        const blockDataStart = offset + AWD2_BLOCK_HEADER_BYTES;
+        if (blockDataStart + blockLength > bodyEnd) {
+            reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Recover, 'awd2.block-length-past-end', 'parseAwd2');
+            break;
+        }
+        const matrixWide = (blockFlags & 1) !== 0;
+        const geometryWide = (blockFlags & 2) !== 0;
+        if (namespace === AWD2_NAMESPACE_CORE) {
+            if (blockType === AWD2_BLOCK_TRIANGLE_GEOMETRY) {
+                const geoms = parseTriangleGeometryBlock(view, source, blockDataStart, blockDataStart + blockLength, geometryWide, diagnostics);
+                geometryBlocks.set(blockId, geoms);
+            }
+            else if (blockType === AWD2_BLOCK_CONTAINER) {
+                const container = parseContainerBlock(view, source, blockDataStart, blockDataStart + blockLength, matrixWide, diagnostics);
+                if (container !== null)
+                    containerBlocks.set(blockId, container);
+            }
+            else if (blockType === AWD2_BLOCK_MESH_INSTANCE) {
+                const meshInst = parseMeshInstanceBlock(view, source, blockDataStart, blockDataStart + blockLength, matrixWide, diagnostics);
+                if (meshInst !== null)
+                    meshInstanceBlocks.set(blockId, meshInst);
+            }
+            else if (blockType === AWD2_BLOCK_MATERIAL) {
+                const material = parseMaterialBlock(view, source, blockDataStart, blockDataStart + blockLength, diagnostics);
+                if (material !== null)
+                    materialBlocks.set(blockId, material);
+            }
+            else if (blockType === AWD2_BLOCK_TEXTURE) {
+                const texture = parseTextureBlock(view, source, blockDataStart, blockDataStart + blockLength, diagnostics);
+                if (texture !== null)
+                    textureBlocks.set(blockId, texture);
+            }
+            else if (blockType === AWD2_BLOCK_SKELETON) {
+                const skeleton = parseSkeletonBlock(view, source, blockDataStart, blockDataStart + blockLength, matrixWide, diagnostics);
+                if (skeleton !== null)
+                    skeletonBlocks.set(blockId, skeleton);
+            }
+        }
+        offset = blockDataStart + blockLength;
+    }
+    const document = emptyAwdDocument();
+    // Maps an AWD block id to the document node index it produced (containers + mesh instances), so parenting
+    // can rewire the flat node array by index the way the scene graph did by Node3D reference.
+    const nodeIndexForBlock = new Map();
+    // Build the file's skeleton (if any) once as document nodes: a skeleton-group node + joint nodes with
+    // their bind-pose local transforms, and one skin entry whose joints are those node indices. AWD binds a
+    // mesh to a skeleton through an animator block Flight does not parse yet; with the common single-skeleton
+    // file (the shambler) every skinned mesh is bound to that one skeleton.
+    let skinIndex;
+    let skeletonJointNodeIndices = [];
+    if (skeletonBlocks.size > 0) {
+        const built = buildAwdSkeletonDocument(skeletonBlocks.values().next().value, document);
+        skeletonJointNodeIndices = built.jointNodeIndices;
+        skinIndex = document.skins.length;
+        document.skins.push(built.skin);
+        document.scenes[0].rootNodes.push(built.skeletonRootIndex);
+        if (skeletonBlocks.size > 1) {
+            reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.multiple-skeletons', 'parseAwd2', {
+                skeletons: skeletonBlocks.size,
+            });
+        }
+    }
+    for (const [blockId, container] of containerBlocks) {
+        const nodeIndex = document.nodes.length;
+        document.nodes.push({
+            children: [],
+            kind: Node3DKind,
+            name: container.name || undefined,
+            transform: awdTransformToTransform3D(container.transform),
+        });
+        nodeIndexForBlock.set(blockId, nodeIndex);
+    }
+    // One Flight Material per AWD material block, shared across every subset that references it (and thus one
+    // Texture + one ImageResource per shared texture). Keyed by AWD material block id → document material index.
+    const resolvedMaterials = new Map();
+    const materialForSubset = (meshInst, subsetIndex) => {
+        const materialId = subsetIndex < meshInst.materialIds.length ? meshInst.materialIds[subsetIndex] : 0;
+        const index = resolveAwdMaterial(materialId, materialBlocks, textureBlocks, resolvedMaterials, document, diagnostics);
+        return index >= 0 ? [index] : [];
+    };
+    for (const [blockId, meshInst] of meshInstanceBlocks) {
+        const geometries = geometryBlocks.get(meshInst.geometryId);
+        const transform = awdTransformToTransform3D(meshInst.transform);
+        let nodeIndex;
+        if (geometries !== undefined && geometries.length > 0) {
+            if (geometries.length === 1) {
+                // The single mesh node carries the instance name directly; the multi-geometry branch instead names
+                // the wrapping group (its subset meshes stay anonymous parts).
+                const meshIndex = document.meshes.length;
+                const mesh = {
+                    geometry: geometries[0].geometry,
+                    materials: materialForSubset(meshInst, 0),
+                };
+                if (skinIndex !== undefined && geometries[0].skinned)
+                    mesh.skin = skinIndex;
+                document.meshes.push(mesh);
+                nodeIndex = document.nodes.length;
+                document.nodes.push({
+                    children: [],
+                    kind: MeshKind,
+                    mesh: meshIndex,
+                    name: meshInst.name || undefined,
+                    transform,
+                });
+            }
+            else {
+                nodeIndex = document.nodes.length;
+                const group = {
+                    children: [],
+                    kind: Node3DKind,
+                    name: meshInst.name || undefined,
+                    transform,
+                };
+                document.nodes.push(group);
+                for (let i = 0; i < geometries.length; i++) {
+                    const meshIndex = document.meshes.length;
+                    const mesh = {
+                        geometry: geometries[i].geometry,
+                        materials: materialForSubset(meshInst, i),
+                    };
+                    if (skinIndex !== undefined && geometries[i].skinned)
+                        mesh.skin = skinIndex;
+                    document.meshes.push(mesh);
+                    const childIndex = document.nodes.length;
+                    document.nodes.push({
+                        children: [],
+                        kind: MeshKind,
+                        mesh: meshIndex,
+                        transform: createTransform3D(),
+                    });
+                    group.children.push(childIndex);
+                }
+            }
+        }
+        else {
+            nodeIndex = document.nodes.length;
+            document.nodes.push({
+                children: [],
+                kind: Node3DKind,
+                name: meshInst.name || undefined,
+                transform,
+            });
+            if (meshInst.geometryId !== 0) {
+                reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Recover, 'awd2.mesh-instance-missing-geometry', 'parseAwd2', { block: blockId, geometry: meshInst.geometryId });
+            }
+        }
+        nodeIndexForBlock.set(blockId, nodeIndex);
+    }
+    const parented = new Set();
+    for (const [blockId, container] of containerBlocks) {
+        if (container.parentId !== 0) {
+            const parentIndex = nodeIndexForBlock.get(container.parentId);
+            if (parentIndex !== undefined) {
+                document.nodes[parentIndex].children.push(nodeIndexForBlock.get(blockId));
+                parented.add(blockId);
+            }
+        }
+    }
+    for (const [blockId, meshInst] of meshInstanceBlocks) {
+        if (meshInst.parentId !== 0) {
+            const parentIndex = nodeIndexForBlock.get(meshInst.parentId);
+            if (parentIndex !== undefined) {
+                document.nodes[parentIndex].children.push(nodeIndexForBlock.get(blockId));
+                parented.add(blockId);
+            }
+        }
+    }
+    for (const blockId of nodeIndexForBlock.keys()) {
+        if (!parented.has(blockId))
+            document.scenes[0].rootNodes.push(nodeIndexForBlock.get(blockId));
+    }
+    // The file's skeleton animations become document animations whose channels bind by joint node index. Uses
+    // the same block-walk as the live parseAwd2SkeletonAnimations, but emits node-index-bound document channels.
+    // Walks the rehydrated `source` (not the original `bytes`): a compressed file — Away3D's export default —
+    // still has a deflated body in `bytes`, so re-walking that would find no blocks and silently drop every
+    // animation. `source` is already inflated with the compression byte + body-length rewritten by rehydrate.
+    if (skeletonJointNodeIndices.length > 0) {
+        document.animations.push(...buildAwdDocumentAnimations(source, skeletonJointNodeIndices, diagnostics));
+    }
+    return document;
+}
+// Parses every named skeleton-animation block in an AWD file into a name→clip map. Each clip drives the
+// given joint Node3Ds — the joints createScene3DFromAwd2 built and exposed as mesh.skin.skeleton.joints —
+// so binding to those same nodes (rather than freshly-created ones) is what lets a clip deform the skinned
+// mesh: animation, skeleton, and skin all reference one joint hierarchy. Mirrors parseMd5Anim(source,
+// joints). A file may carry several named animations (idle/walk/attack); each is keyed by its block name
+// (or `animation${i}` in file order when unnamed), so a caller selects one with `clips['walk']`. Returns
+// an empty map when the header is invalid or no skeleton/animation blocks are found. The `joints` array
+// must be in AWD skeleton order (index j = joint j); a length mismatch with the file's skeleton records a diagnostic.
+export function parseAwd2SkeletonAnimations(bytes, joints, diagnostics) {
+    const input = bytes;
+    if (input.byteLength < AWD2_HEADER_BYTES) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Reject, 'awd2.header-too-short', 'parseAwd2SkeletonAnimations');
+        return {};
+    }
+    if (input[0] !== AWD2_MAGIC_0 || input[1] !== AWD2_MAGIC_1 || input[2] !== AWD2_MAGIC_2) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Reject, 'awd2.bad-magic', 'parseAwd2SkeletonAnimations');
+        return {};
+    }
+    if (!isAwd2Version(input, diagnostics))
+        return {};
+    // Inflate a compressed body and splice it back behind the header so the walk is identical to the
+    // uncompressed path; bails to an empty result when no codec is registered for the compression method.
+    const rehydrated = rehydrateAwdBody(input, diagnostics);
+    if (rehydrated === null)
+        return {};
+    const source = rehydrated.source;
+    const view = rehydrated.view;
+    const bodyLength = view.getUint32(8, true);
+    const bodyEnd = Math.min(AWD2_HEADER_BYTES + bodyLength, source.byteLength);
+    const skeletonBlocks = new Map();
+    const poseBlocks = new Map();
+    const animationBlocks = new Map();
+    let offset = AWD2_HEADER_BYTES;
+    while (offset + AWD2_BLOCK_HEADER_BYTES <= bodyEnd) {
+        const blockId = view.getUint32(offset, true);
+        const namespace = source[offset + 4];
+        const blockType = source[offset + 5];
+        const blockFlags = source[offset + 6];
+        const blockLength = view.getUint32(offset + 7, true);
+        const blockDataStart = offset + AWD2_BLOCK_HEADER_BYTES;
+        if (blockDataStart + blockLength > bodyEnd) {
+            reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Recover, 'awd2.block-length-past-end', 'parseAwd2SkeletonAnimations');
+            break;
+        }
+        const matrixWide = (blockFlags & 1) !== 0;
+        if (namespace === AWD2_NAMESPACE_CORE) {
+            if (blockType === AWD2_BLOCK_SKELETON) {
+                const skeleton = parseSkeletonBlock(view, source, blockDataStart, blockDataStart + blockLength, matrixWide, diagnostics);
+                if (skeleton !== null)
+                    skeletonBlocks.set(blockId, skeleton);
+            }
+            else if (blockType === AWD2_BLOCK_SKELETON_POSE) {
+                const pose = parseSkeletonPoseBlock(view, source, blockDataStart, blockDataStart + blockLength, matrixWide, diagnostics);
+                if (pose !== null)
+                    poseBlocks.set(blockId, pose);
+            }
+            else if (blockType === AWD2_BLOCK_SKELETON_ANIMATION) {
+                const anim = parseSkeletonAnimationBlock(view, source, blockDataStart, blockDataStart + blockLength, diagnostics);
+                if (anim !== null)
+                    animationBlocks.set(blockId, anim);
+            }
+        }
+        offset = blockDataStart + blockLength;
+    }
+    if (skeletonBlocks.size === 0) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Reject, 'awd2.no-skeleton-blocks', 'parseAwd2SkeletonAnimations');
+        return {};
+    }
+    if (animationBlocks.size === 0) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Reject, 'awd2.no-skeleton-animation-blocks', 'parseAwd2SkeletonAnimations');
+        return {};
+    }
+    const parsedSkeleton = skeletonBlocks.values().next().value;
+    if (joints.length < parsedSkeleton.joints.length) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Reject, 'awd2.joint-count-mismatch', 'parseAwd2SkeletonAnimations', {
+            jointNodes: joints.length,
+            skeletonJoints: parsedSkeleton.joints.length,
+        });
+        return {};
+    }
+    // A file can carry several named animations (idle/walk/attack); build a clip for each and key it by the
+    // block's name (falling back to file order when unnamed). All bind to the one shared joint hierarchy.
+    const out = {};
+    let index = 0;
+    for (const parsedAnimation of animationBlocks.values()) {
+        const clip = buildAwdSkeletonAnimationClip(parsedAnimation, parsedSkeleton.joints.length, poseBlocks, joints, diagnostics);
+        if (clip !== null)
+            out[parsedAnimation.name || `animation${index}`] = clip;
+        index++;
+    }
+    return out;
+}
+// Registers a decompressor for an AWD compression method (AWD2_COMPRESSION_DEFLATE / _LZMA), enabling
+// `parseAwd2`/`parseAwd2SkeletonAnimations` to import compressed files. Kept as an opt-in registry so the
+// codec stays tree-shakable — a bundle that only reads uncompressed AWD never pulls an inflate into its
+// output. Last registration for a method wins; passing null clears it. Codecs are keyed by the header's
+// compression byte, so a vendor can supply its own (e.g. a host-native inflate) for either method.
+export function registerAwd2Decompressor(compression, decompressor) {
+    if (decompressor === null)
+        awdDecompressors.delete(compression);
+    else
+        awdDecompressors.set(compression, decompressor);
+}
+// Builds one AnimationClip from a parsed AWD skeleton-animation block: samples each pose's per-joint local
+// matrix into a translation + rotation track bound to the matching joint node. Null when it has no poses.
+function buildAwdSkeletonAnimationClip(parsedAnimation, jointCount, poseBlocks, joints, diagnostics) {
+    const poseCount = parsedAnimation.poses.length;
+    if (poseCount === 0) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.animation-no-poses', 'buildAwdSkeletonAnimationClip');
+        return null;
+    }
+    const times = [];
+    let timeAccumulator = 0;
+    for (let p = 0; p < poseCount; p++) {
+        times.push(timeAccumulator);
+        timeAccumulator += parsedAnimation.poses[p].duration / 1000;
+    }
+    // Each AWD pose carries a full local joint matrix (rotation + translation). A skeletal animation is
+    // driven mostly by joint rotation; emitting only translation leaves every joint at its bind-pose
+    // orientation, which compounds down the chain into a wildly deformed mesh. So decompose each pose's
+    // 3×3 into a quaternion and drive both the joint's rotation and translation.
+    const poseMatrix = createMatrix4();
+    const poseTransform = createTransform3D();
+    const channels = [];
+    // A pose block referenced by the animation can be missing; the same block is re-hit for every joint,
+    // so collect the distinct offenders and report once. Only allocated when a collector is engaged.
+    const missingPoseBlocks = diagnostics ? new Set() : null;
+    for (let j = 0; j < jointCount; j++) {
+        const translationValues = [];
+        const rotationValues = [];
+        const scaleValues = [];
+        let hasScale = false;
+        for (let p = 0; p < poseCount; p++) {
+            const poseBlockId = parsedAnimation.poses[p].poseBlockId;
+            const pose = poseBlocks.get(poseBlockId);
+            if (pose === undefined) {
+                missingPoseBlocks?.add(poseBlockId);
+                translationValues.push(0, 0, 0);
+                rotationValues.push(0, 0, 0, 1);
+                scaleValues.push(1, 1, 1);
+            }
+            else if (j < pose.jointTransforms.length && pose.jointTransforms[j] !== null) {
+                const transform = pose.jointTransforms[j];
+                translationValues.push(transform[9], transform[10], transform[11]);
+                // Decompose the pose's 3×3 basis into rotation AND scale. A plain setQuaternionFromMatrix4 would
+                // read a skewed quaternion off a scaled basis and drop the scale entirely; decompose normalizes
+                // the basis first, so both come out correct. The lifted matrix's translation is unused here.
+                awdTransformToMatrix4(poseMatrix, transform);
+                decomposeMatrix4ToTransform3D(poseTransform, poseMatrix);
+                rotationValues.push(poseTransform.rotation.x, poseTransform.rotation.y, poseTransform.rotation.z, poseTransform.rotation.w);
+                scaleValues.push(poseTransform.scale.x, poseTransform.scale.y, poseTransform.scale.z);
+                if (hasNonUnitScale(poseTransform.scale.x, poseTransform.scale.y, poseTransform.scale.z))
+                    hasScale = true;
+            }
+            else {
+                translationValues.push(0, 0, 0);
+                rotationValues.push(0, 0, 0, 1);
+                scaleValues.push(1, 1, 1);
+            }
+        }
+        const translationTrack = createAnimationTrack({
+            components: 3,
+            times,
+            values: translationValues,
+        });
+        channels.push(createAnimationChannel(translationTrack, {
+            node: joints[j],
+            path: Scene3DAnimationPathTranslation,
+        }));
+        const rotationTrack = createAnimationTrack({
+            components: 4,
+            quaternion: true,
+            times,
+            values: rotationValues,
+        });
+        channels.push(createAnimationChannel(rotationTrack, {
+            node: joints[j],
+            path: Scene3DAnimationPathRotation,
+        }));
+        // Only emit a scale track when some pose actually scales the joint — AWD skeletons rarely do, and a
+        // redundant unit-scale channel would bloat every clip.
+        if (hasScale) {
+            const scaleTrack = createAnimationTrack({
+                components: 3,
+                times,
+                values: scaleValues,
+            });
+            channels.push(createAnimationChannel(scaleTrack, {
+                node: joints[j],
+                path: Scene3DAnimationPathScale,
+            }));
+        }
+    }
+    if (missingPoseBlocks !== null && missingPoseBlocks.size > 0) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Recover, 'awd2.pose-block-missing', 'buildAwdSkeletonAnimationClip', {
+            distinctPoseBlocks: missingPoseBlocks.size,
+            firstPoseBlock: Math.min(...missingPoseBlocks),
+        });
+    }
+    return createAnimationClip(channels, timeAccumulator);
+}
+// Builds the document animation table from an AWD file's skeleton-animation blocks, binding each channel by
+// the joint's document node index (in `jointNodeIndices`, AWD joint order). The block walk mirrors the live
+// parseAwd2SkeletonAnimations; the difference is only the sink — document channels carry a node index + path
+// + track rather than a live-node-bound AnimationChannel. Every named animation (idle/walk/attack) becomes
+// one Scene3DDocumentAnimation keyed by its block name (or `animation${i}` in file order when unnamed). Returns
+// an empty array when no skeleton/animation blocks are found. `bytes` must be the REHYDRATED body (compression
+// byte NONE, inflated), not the raw file — this helper does not decompress, unlike parseAwd2SkeletonAnimations.
+function buildAwdDocumentAnimations(bytes, jointNodeIndices, diagnostics) {
+    const source = bytes;
+    const view = new DataView(source.buffer, source.byteOffset, source.byteLength);
+    const bodyLength = view.getUint32(8, true);
+    const bodyEnd = Math.min(AWD2_HEADER_BYTES + bodyLength, source.byteLength);
+    const skeletonBlocks = new Map();
+    const poseBlocks = new Map();
+    const animationBlocks = new Map();
+    let offset = AWD2_HEADER_BYTES;
+    while (offset + AWD2_BLOCK_HEADER_BYTES <= bodyEnd) {
+        const namespace = source[offset + 4];
+        const blockType = source[offset + 5];
+        const blockFlags = source[offset + 6];
+        const blockLength = view.getUint32(offset + 7, true);
+        const blockDataStart = offset + AWD2_BLOCK_HEADER_BYTES;
+        if (blockDataStart + blockLength > bodyEnd)
+            break;
+        const blockId = view.getUint32(offset, true);
+        const matrixWide = (blockFlags & 1) !== 0;
+        if (namespace === AWD2_NAMESPACE_CORE) {
+            if (blockType === AWD2_BLOCK_SKELETON) {
+                const skeleton = parseSkeletonBlock(view, source, blockDataStart, blockDataStart + blockLength, matrixWide);
+                if (skeleton !== null)
+                    skeletonBlocks.set(blockId, skeleton);
+            }
+            else if (blockType === AWD2_BLOCK_SKELETON_POSE) {
+                // Pose/animation blocks are NOT parsed by parseAwd2's first walk, so this document-path walk is
+                // their only reporting site — thread the sink. The skeleton block above is deliberately left
+                // sink-less: the first walk already parses (and reports) it, so threading here would double-report.
+                const pose = parseSkeletonPoseBlock(view, source, blockDataStart, blockDataStart + blockLength, matrixWide, diagnostics);
+                if (pose !== null)
+                    poseBlocks.set(blockId, pose);
+            }
+            else if (blockType === AWD2_BLOCK_SKELETON_ANIMATION) {
+                const anim = parseSkeletonAnimationBlock(view, source, blockDataStart, blockDataStart + blockLength, diagnostics);
+                if (anim !== null)
+                    animationBlocks.set(blockId, anim);
+            }
+        }
+        offset = blockDataStart + blockLength;
+    }
+    if (skeletonBlocks.size === 0 || animationBlocks.size === 0)
+        return [];
+    const parsedSkeleton = skeletonBlocks.values().next().value;
+    const jointCount = parsedSkeleton.joints.length;
+    const animations = [];
+    let index = 0;
+    for (const parsedAnimation of animationBlocks.values()) {
+        const built = buildAwdDocumentAnimation(parsedAnimation, jointCount, poseBlocks, jointNodeIndices, diagnostics);
+        if (built !== null) {
+            built.name = parsedAnimation.name || `animation${index}`;
+            animations.push(built);
+        }
+        index++;
+    }
+    return animations;
+}
+// Builds one Scene3DDocumentAnimation from a parsed AWD skeleton-animation block: samples each pose's per-joint
+// local matrix into a translation + rotation track bound to the matching joint node INDEX. Null when it has
+// no poses. Mirrors buildAwdSkeletonAnimationClip's per-joint sampling, emitting document channels.
+function buildAwdDocumentAnimation(parsedAnimation, jointCount, poseBlocks, jointNodeIndices, diagnostics) {
+    const poseCount = parsedAnimation.poses.length;
+    if (poseCount === 0) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.animation-no-poses', 'buildAwdDocumentAnimation');
+        return null;
+    }
+    const times = [];
+    let timeAccumulator = 0;
+    for (let p = 0; p < poseCount; p++) {
+        times.push(timeAccumulator);
+        timeAccumulator += parsedAnimation.poses[p].duration / 1000;
+    }
+    const poseMatrix = createMatrix4();
+    const poseTransform = createTransform3D();
+    const channels = [];
+    // See buildAwdSkeletonAnimationClip: aggregate the distinct missing pose blocks, report once.
+    const missingPoseBlocks = diagnostics ? new Set() : null;
+    for (let j = 0; j < jointCount; j++) {
+        if (j >= jointNodeIndices.length)
+            break;
+        const translationValues = [];
+        const rotationValues = [];
+        const scaleValues = [];
+        let hasScale = false;
+        for (let p = 0; p < poseCount; p++) {
+            const poseBlockId = parsedAnimation.poses[p].poseBlockId;
+            const pose = poseBlocks.get(poseBlockId);
+            if (pose === undefined) {
+                missingPoseBlocks?.add(poseBlockId);
+                translationValues.push(0, 0, 0);
+                rotationValues.push(0, 0, 0, 1);
+                scaleValues.push(1, 1, 1);
+            }
+            else if (j < pose.jointTransforms.length && pose.jointTransforms[j] !== null) {
+                const transform = pose.jointTransforms[j];
+                translationValues.push(transform[9], transform[10], transform[11]);
+                // Decompose rotation + scale from the pose basis (see the live-clip path for why decompose,
+                // not setQuaternionFromMatrix4 alone).
+                awdTransformToMatrix4(poseMatrix, transform);
+                decomposeMatrix4ToTransform3D(poseTransform, poseMatrix);
+                rotationValues.push(poseTransform.rotation.x, poseTransform.rotation.y, poseTransform.rotation.z, poseTransform.rotation.w);
+                scaleValues.push(poseTransform.scale.x, poseTransform.scale.y, poseTransform.scale.z);
+                if (hasNonUnitScale(poseTransform.scale.x, poseTransform.scale.y, poseTransform.scale.z))
+                    hasScale = true;
+            }
+            else {
+                translationValues.push(0, 0, 0);
+                rotationValues.push(0, 0, 0, 1);
+                scaleValues.push(1, 1, 1);
+            }
+        }
+        const translationTrack = createAnimationTrack({
+            components: 3,
+            times,
+            values: translationValues,
+        });
+        channels.push({
+            node: jointNodeIndices[j],
+            path: Scene3DAnimationPathTranslation,
+            track: translationTrack,
+        });
+        const rotationTrack = createAnimationTrack({
+            components: 4,
+            quaternion: true,
+            times,
+            values: rotationValues,
+        });
+        channels.push({
+            node: jointNodeIndices[j],
+            path: Scene3DAnimationPathRotation,
+            track: rotationTrack,
+        });
+        if (hasScale) {
+            const scaleTrack = createAnimationTrack({
+                components: 3,
+                times,
+                values: scaleValues,
+            });
+            channels.push({
+                node: jointNodeIndices[j],
+                path: Scene3DAnimationPathScale,
+                track: scaleTrack,
+            });
+        }
+    }
+    if (missingPoseBlocks !== null && missingPoseBlocks.size > 0) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Recover, 'awd2.pose-block-missing', 'buildAwdDocumentAnimation', {
+            distinctPoseBlocks: missingPoseBlocks.size,
+            firstPoseBlock: Math.min(...missingPoseBlocks),
+        });
+    }
+    return { channels, duration: timeAccumulator, name: parsedAnimation.name };
+}
+// Validates the header version-major byte before the block walk. An 'AWD'-magic file with a version other
+// than 2 (in practice version 3 — AWD3, AwayJS's Scene3DGraph format) has an entirely different block model,
+// so the AWD2 block walk would silently misparse it to an empty/garbage document. Reject it by name here
+// instead, pointing at AWD3 as a recognized but not-yet-implemented future format.
+function isAwd2Version(input, diagnostics) {
+    const versionMajor = input[AWD2_VERSION_MAJOR_OFFSET];
+    if (versionMajor === AWD2_FORMAT_VERSION)
+        return true;
+    reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Reject, 'awd2.unsupported-version', 'isAwd2Version', {
+        version: versionMajor,
+    });
+    return false;
+}
+// The empty Scene3DDocument returned when AWD parsing fails or before assembly begins — every table present.
+function emptyAwdDocument() {
+    return {
+        animations: [],
+        cameras: [],
+        lights: [],
+        materials: [],
+        meshes: [],
+        metadata: null,
+        nodes: [],
+        resources: [],
+        scenes: [{ rootNodes: [] }],
+        skins: [],
+    };
+}
+// Emits an AWD skeleton block into a Scene3DDocument as a "skeleton" group node + one joint node per AWD
+// joint (with its bind-pose local transform), plus a Scene3DDocumentSkin whose joints are those node indices
+// and whose inverseBind are the AWD joint matrices (which ARE the inverse bind pose). Appends the nodes to
+// `document.nodes` and returns the skeleton-group node index, the joint node indices (in AWD joint order,
+// for animation binding), and the skin. The parent chain is wired through the joint nodes' `children` index
+// lists (AWD parent index is 1-based, 0 = root; roots hang under the group). Each joint's LOCAL transform
+// is seeded to the bind pose so the skinned mesh renders undeformed until the animation poses the joints —
+// the same math the live scene path used, decomposed to a Transform3D for the document node.
+function buildAwdSkeletonDocument(parsedSkeleton, document) {
+    const jointCount = parsedSkeleton.joints.length;
+    const skeletonRootIndex = document.nodes.length;
+    document.nodes.push({
+        children: [],
+        kind: Node3DKind,
+        name: 'skeleton',
+        transform: createTransform3D(),
+    });
+    const jointNodeIndices = [];
+    for (let j = 0; j < jointCount; j++) {
+        jointNodeIndices.push(document.nodes.length);
+        document.nodes.push({
+            children: [],
+            kind: Node3DKind,
+            name: parsedSkeleton.joints[j].name || undefined,
+            transform: createTransform3D(),
+        });
+    }
+    for (let j = 0; j < jointCount; j++) {
+        const parentIndex1 = parsedSkeleton.joints[j].parentIndex;
+        if (parentIndex1 > 0 && parentIndex1 - 1 < jointCount) {
+            document.nodes[jointNodeIndices[parentIndex1 - 1]].children.push(jointNodeIndices[j]);
+        }
+        else {
+            document.nodes[skeletonRootIndex].children.push(jointNodeIndices[j]);
+        }
+    }
+    // The AWD skeleton joint matrix is the joint's INVERSE bind pose (model→joint at bind), not a local
+    // transform — see the AWD format and AwayJS's AWDParser (joint.inverseBindPose). So carry it as the skin's
+    // explicit inverse-bind palette, and seed each joint's LOCAL transform to the bind pose so the rig renders
+    // undeformed until the animation poses the joints. Bind world = inverseBind⁻¹, and a joint's bind-local =
+    // parentBindWorld⁻¹ · jointBindWorld (roots use bind world directly). The animation clip then overrides
+    // these locals per frame; the skinning palette is jointWorld · inverseBind, which is identity at bind
+    // (undeformed) and the pose delta once animated.
+    const inverseBind = [];
+    const bindWorld = [];
+    for (let j = 0; j < jointCount; j++) {
+        const invBind = createMatrix4();
+        awdTransformToMatrix4(invBind, parsedSkeleton.joints[j].transform);
+        inverseBind.push(invBind);
+        const bw = createMatrix4();
+        inverseMatrix4(bw, invBind);
+        bindWorld.push(bw);
+    }
+    const invParent = createMatrix4();
+    const local = createMatrix4();
+    for (let j = 0; j < jointCount; j++) {
+        const parentIndex1 = parsedSkeleton.joints[j].parentIndex;
+        if (parentIndex1 > 0 && parentIndex1 - 1 < jointCount) {
+            inverseMatrix4(invParent, bindWorld[parentIndex1 - 1]);
+            multiplyMatrix4(local, invParent, bindWorld[j]);
+        }
+        else {
+            copyMatrix4(local, bindWorld[j]);
+        }
+        decomposeMatrix4ToTransform3D(document.nodes[jointNodeIndices[j]].transform, local);
+    }
+    const skin = { inverseBind, joints: jointNodeIndices };
+    return { jointNodeIndices, skeletonRootIndex, skin };
+}
+function readAwdString(view, source, offset) {
+    const length = view.getUint16(offset, true);
+    const stringBytes = source.subarray(offset + 2, offset + 2 + length);
+    const value = new TextDecoder().decode(stringBytes);
+    return { end: offset + 2 + length, value };
+}
+function readAwdTransform(view, offset, widePrecision) {
+    const dv = view;
+    const transform = new Float64Array(12);
+    const floatSize = widePrecision ? 8 : 4;
+    for (let i = 0; i < 12; i++) {
+        transform[i] = widePrecision
+            ? dv.getFloat64(offset + i * floatSize, true)
+            : dv.getFloat32(offset + i * floatSize, true);
+    }
+    convertTransformLhToRh(transform);
+    return { end: offset + 12 * floatSize, transform };
+}
+// Decomposes an AWD 12-float column-major transform into a document node's authored TRS Transform3D
+// (lossy only on shear, which AWD authoring does not produce).
+function awdTransformToTransform3D(transform) {
+    awdTransformToMatrix4(_awdTransformScratch, transform);
+    const out = createTransform3D();
+    decomposeMatrix4ToTransform3D(out, _awdTransformScratch);
+    return out;
+}
+const _awdTransformScratch = createMatrix4();
+// AWD stores transforms as 12 column-major floats: [c0x,c0y,c0z, c1x,c1y,c1z, c2x,c2y,c2z, tx,ty,tz] →
+// 4×4 column-major with w-column [0,0,0,1]. Lifts one into `out` (its runtime binding is left intact).
+function awdTransformToMatrix4(out, transform) {
+    const m = out.m;
+    m[0] = transform[0];
+    m[1] = transform[1];
+    m[2] = transform[2];
+    m[3] = 0;
+    m[4] = transform[3];
+    m[5] = transform[4];
+    m[6] = transform[5];
+    m[7] = 0;
+    m[8] = transform[6];
+    m[9] = transform[7];
+    m[10] = transform[8];
+    m[11] = 0;
+    m[12] = transform[9];
+    m[13] = transform[10];
+    m[14] = transform[11];
+    m[15] = 1;
+}
+function awdDataTypeByteSize(dataType) {
+    switch (dataType) {
+        case AWD2_DATA_INT8:
+        case AWD2_DATA_UINT8:
+            return 1;
+        case AWD2_DATA_INT16:
+        case AWD2_DATA_UINT16:
+            return 2;
+        case AWD2_DATA_INT32:
+        case AWD2_DATA_UINT32:
+        case AWD2_DATA_FLOAT32:
+            return 4;
+        case AWD2_DATA_FLOAT64:
+            return 8;
+        default:
+            return 4;
+    }
+}
+function readAwdDataValue(view, offset, dataType) {
+    const dv = view;
+    switch (dataType) {
+        case AWD2_DATA_INT8:
+            return dv.getInt8(offset);
+        case AWD2_DATA_INT16:
+            return dv.getInt16(offset, true);
+        case AWD2_DATA_INT32:
+            return dv.getInt32(offset, true);
+        case AWD2_DATA_UINT8:
+            return dv.getUint8(offset);
+        case AWD2_DATA_UINT16:
+            return dv.getUint16(offset, true);
+        case AWD2_DATA_UINT32:
+            return dv.getUint32(offset, true);
+        case AWD2_DATA_FLOAT32:
+            return dv.getFloat32(offset, true);
+        case AWD2_DATA_FLOAT64:
+            return dv.getFloat64(offset, true);
+        default:
+            return dv.getFloat32(offset, true);
+    }
+}
+// Skips an AWD attribute list (NumAttrList or UserAttrList). The list is a uint32 byte-length
+// prefix followed by that many bytes of attribute data.
+function skipAwdAttrList(view, offset, end) {
+    if (offset + 4 > end)
+        return offset;
+    const byteLength = view.getUint32(offset, true);
+    return offset + 4 + byteLength;
+}
+// Parses a TriangleGeometry block (type 1). Layout:
+// name(VarString) → numSubMeshes(uint16) → NumAttrList → per sub-mesh:
+//   totalByteLen(uint32) → NumAttrList → streams → UserAttrList
+function parseTriangleGeometryBlock(view, source, start, end, geometryWide, diagnostics) {
+    const dv = view;
+    let offset = start;
+    // Guard the name in two steps: the 2-byte VarString length prefix, then its declared payload — otherwise a
+    // truncated name payload slips past readAwdString (which does not bound-check) and mislabels the next
+    // guard's field as 'num-submeshes' when the missing bytes actually belong to the name.
+    if (offset + 2 > end || offset + 2 + dv.getUint16(offset, true) > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.geometry-truncated', 'parseTriangleGeometryBlock', {
+            field: 'name',
+        });
+        return [];
+    }
+    const nameResult = readAwdString(view, source, offset);
+    offset = nameResult.end;
+    if (offset + 2 > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.geometry-truncated', 'parseTriangleGeometryBlock', {
+            field: 'num-submeshes',
+        });
+        return [];
+    }
+    const numSubMeshes = dv.getUint16(offset, true);
+    offset += 2;
+    offset = skipAwdAttrList(view, offset, end);
+    const geometries = [];
+    for (let s = 0; s < numSubMeshes; s++) {
+        if (offset + 4 > end) {
+            // The sub-mesh header is truncated: this and every remaining sub-mesh of the block are omitted.
+            reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.submesh-truncated', 'parseTriangleGeometryBlock', {
+                firstSubMesh: s,
+            });
+            break;
+        }
+        const subMeshByteLen = dv.getUint32(offset, true);
+        const subMeshEnd = offset + 4 + subMeshByteLen;
+        offset += 4;
+        // NumAttrList for sub-mesh properties.
+        offset = skipAwdAttrList(view, offset, end);
+        let positions = null;
+        let indices = null;
+        let uvs = null;
+        let normals = null;
+        let tangents = null;
+        let jointIndices = null;
+        let jointWeights = null;
+        // Read streams until we reach the sub-mesh byte boundary (leaving room for UserAttrList).
+        while (offset + 6 <= subMeshEnd) {
+            const streamType = dv.getUint8(offset);
+            offset += 1;
+            const dataType = dv.getUint8(offset);
+            offset += 1;
+            const streamByteLength = dv.getUint32(offset, true);
+            offset += 4;
+            if (offset + streamByteLength > end) {
+                reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Recover, 'awd2.stream-data-past-end', 'parseTriangleGeometryBlock');
+                break;
+            }
+            // AWD stores per-vertex joint indices as uint16 (Away3D reads them with readUnsignedShort),
+            // regardless of the stream's declared data type — exporters write float32 in that field but
+            // pack the payload as tight uint16 indices. Read them as uint16 by byte length; the paired
+            // weight stream is genuine float32 and goes through the generic reader below.
+            if (streamType === AWD2_STREAM_JOINT_INDICES) {
+                const jointCount = Math.floor(streamByteLength / 2);
+                const values = [];
+                for (let i = 0; i < jointCount; i++)
+                    values.push(dv.getUint16(offset + i * 2, true));
+                jointIndices = values;
+                offset += streamByteLength;
+                continue;
+            }
+            const elementSize = awdDataTypeByteSize(dataType);
+            const count = Math.floor(streamByteLength / elementSize);
+            const values = [];
+            for (let i = 0; i < count; i++) {
+                values.push(readAwdDataValue(view, offset + i * elementSize, dataType));
+            }
+            offset += streamByteLength;
+            switch (streamType) {
+                case AWD2_STREAM_POSITIONS:
+                    positions = values;
+                    break;
+                case AWD2_STREAM_INDICES:
+                    indices = values;
+                    break;
+                case AWD2_STREAM_UVS:
+                    uvs = values;
+                    break;
+                case AWD2_STREAM_NORMALS:
+                    normals = values;
+                    break;
+                case AWD2_STREAM_TANGENTS:
+                    tangents = values;
+                    break;
+                case AWD2_STREAM_JOINT_WEIGHTS:
+                    jointWeights = values;
+                    break;
+                default:
+                    break;
+            }
+        }
+        // UserAttrList for sub-mesh.
+        offset = skipAwdAttrList(view, offset, end);
+        if (positions === null || positions.length < 3) {
+            reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.submesh-no-positions', 'parseTriangleGeometryBlock');
+            continue;
+        }
+        // Convert from AWD's left-handed Y-up to Flight's right-handed Y-up. Joint indices/weights are
+        // index/scalar data — unaffected by the handedness flip, which the skeleton transforms mirror.
+        negateVec3Z(positions);
+        if (normals !== null)
+            negateVec3Z(normals);
+        if (tangents !== null)
+            negateVec3Z(tangents);
+        if (indices !== null)
+            reverseTriangleWinding(indices);
+        const vertexCount = positions.length / 3;
+        // A sub-mesh is skinned when it carries both influence streams; it then emits the skinned layout
+        // (joints0/weights0 past uv0) and feeds the shared packSkinInfluences path. AWD lists an arbitrary
+        // number of influences per vertex (shambler uses 8); the top four by weight are kept, renormalized.
+        let jointsPerVertex = 0;
+        if (jointIndices !== null && jointWeights !== null && vertexCount > 0) {
+            jointsPerVertex = Math.floor(jointWeights.length / vertexCount);
+            if (jointsPerVertex < 1 || jointIndices.length < vertexCount * jointsPerVertex) {
+                reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Recover, 'awd2.skin-streams-mismatch', 'parseTriangleGeometryBlock');
+                jointsPerVertex = 0;
+            }
+        }
+        const skinned = jointsPerVertex > 0;
+        const floatsPerVertex = skinned ? SKINNED_FLOATS_PER_VERTEX : CANONICAL_FLOATS_PER_VERTEX;
+        const vertices = new Float32Array(vertexCount * floatsPerVertex);
+        const jointScratch = [0, 0, 0, 0];
+        const weightScratch = [0, 0, 0, 0];
+        for (let v = 0; v < vertexCount; v++) {
+            const o = v * floatsPerVertex;
+            vertices[o] = positions[v * 3];
+            vertices[o + 1] = positions[v * 3 + 1];
+            vertices[o + 2] = positions[v * 3 + 2];
+            if (normals !== null && v * 3 + 2 < normals.length) {
+                vertices[o + 3] = normals[v * 3];
+                vertices[o + 4] = normals[v * 3 + 1];
+                vertices[o + 5] = normals[v * 3 + 2];
+            }
+            if (tangents !== null && v * 3 + 2 < tangents.length) {
+                vertices[o + 6] = tangents[v * 3];
+                vertices[o + 7] = tangents[v * 3 + 1];
+                vertices[o + 8] = tangents[v * 3 + 2];
+                // Tangent W is the bitangent handedness the shader reconstructs the bitangent with (B = W·N×T).
+                // AWD's tangent stream is xyz only, so W must be synthesized: Away3D derives the bitangent as
+                // N×T in its LEFT-handed space (one handedness for the whole mesh), and the left→right-handed
+                // conversion above (negateVec3Z on N and T is a det=-1 reflection) flips that handedness. So the
+                // correct sign in Flight's right-handed space is AWD2_TANGENT_HANDEDNESS. Left 0 (no bitangent) for
+                // a vertex the tangent stream does not cover.
+                vertices[o + 9] = AWD2_TANGENT_HANDEDNESS;
+            }
+            if (uvs !== null && v * 2 + 1 < uvs.length) {
+                vertices[o + 10] = uvs[v * 2];
+                vertices[o + 11] = uvs[v * 2 + 1];
+            }
+            if (skinned) {
+                const influences = [];
+                for (let k = 0; k < jointsPerVertex; k++) {
+                    const weight = jointWeights[v * jointsPerVertex + k];
+                    if (weight > 0)
+                        influences.push({
+                            jointIndex: jointIndices[v * jointsPerVertex + k],
+                            weight,
+                        });
+                }
+                packSkinInfluences(influences, jointScratch, weightScratch);
+                vertices[o + 12] = jointScratch[0];
+                vertices[o + 13] = jointScratch[1];
+                vertices[o + 14] = jointScratch[2];
+                vertices[o + 15] = jointScratch[3];
+                vertices[o + 16] = weightScratch[0];
+                vertices[o + 17] = weightScratch[1];
+                vertices[o + 18] = weightScratch[2];
+                vertices[o + 19] = weightScratch[3];
+            }
+        }
+        const indexArray = indices !== null ? Uint32Array.from(indices) : undefined;
+        const geometry = createMeshGeometry({
+            indices: indexArray,
+            layout: skinned ? CANONICAL_SKINNED_MESH_GEOMETRY_LAYOUT : CANONICAL_LAYOUT,
+            vertices,
+        });
+        // Regenerate normals only when the sub-mesh carried none, matching the shared emitter; authored
+        // AWD normals (present on skinned models like the shambler) are kept.
+        if (normals === null && indexArray !== undefined)
+            computeMeshGeometryNormals(geometry, geometry);
+        // Away3D commonly ships meshes with UVs but NO tangent stream and derives tangents at load time. With
+        // no stream the tangent frame above is left zero, so a normal-mapped material renders black (its
+        // sampled normal has no basis to transform through). Synthesize a tangent basis (xyz + handedness W)
+        // from positions/normals/UVs — the -1 W this yields for real AWD geometry is render-confirmed correct.
+        // Only when the stream is absent and there are UVs (and indices, for the per-triangle UV gradient);
+        // an authored tangent stream is kept untouched.
+        if (tangents === null && uvs !== null && indexArray !== undefined) {
+            computeMeshGeometryTangents(geometry, geometry);
+        }
+        geometries.push({ geometry, skinned });
+    }
+    return geometries;
+}
+// Parses a Container block (type 22). AWD Scene3DHeader layout:
+// parentId(uint32) → matrix4x3(12 × floatSize) → name(VarString) → NumAttrList → UserAttrList
+function parseContainerBlock(view, source, start, end, matrixWide, diagnostics) {
+    const dv = view;
+    let offset = start;
+    if (offset + 4 > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.container-truncated', 'parseContainerBlock', {
+            field: 'parentId',
+        });
+        return null;
+    }
+    const parentId = dv.getUint32(offset, true);
+    offset += 4;
+    const floatSize = matrixWide ? 8 : 4;
+    if (offset + 12 * floatSize > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.container-truncated', 'parseContainerBlock', {
+            field: 'transform',
+        });
+        return null;
+    }
+    const transformResult = readAwdTransform(view, offset, matrixWide);
+    offset = transformResult.end;
+    if (offset + 2 > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.container-truncated', 'parseContainerBlock', {
+            field: 'name',
+        });
+        return null;
+    }
+    const nameResult = readAwdString(view, source, offset);
+    offset = nameResult.end;
+    offset = skipAwdAttrList(view, offset, end);
+    offset = skipAwdAttrList(view, offset, end);
+    return {
+        name: nameResult.value,
+        parentId,
+        transform: transformResult.transform,
+    };
+}
+// Parses a MeshInstance block (type 23). Layout:
+// Scene3DHeader(parentId → matrix → name) → geometryId(uint32)
+// → numMaterials(uint16) → materialIds(uint32 × N) → NumAttrList → UserAttrList
+function parseMeshInstanceBlock(view, source, start, end, matrixWide, diagnostics) {
+    const dv = view;
+    let offset = start;
+    if (offset + 4 > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.mesh-instance-truncated', 'parseMeshInstanceBlock', {
+            field: 'parentId',
+        });
+        return null;
+    }
+    const parentId = dv.getUint32(offset, true);
+    offset += 4;
+    const floatSize = matrixWide ? 8 : 4;
+    if (offset + 12 * floatSize > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.mesh-instance-truncated', 'parseMeshInstanceBlock', {
+            field: 'transform',
+        });
+        return null;
+    }
+    const transformResult = readAwdTransform(view, offset, matrixWide);
+    offset = transformResult.end;
+    if (offset + 2 > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.mesh-instance-truncated', 'parseMeshInstanceBlock', {
+            field: 'name',
+        });
+        return null;
+    }
+    const nameResult = readAwdString(view, source, offset);
+    offset = nameResult.end;
+    if (offset + 4 > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.mesh-instance-truncated', 'parseMeshInstanceBlock', {
+            field: 'geometryId',
+        });
+        return null;
+    }
+    const geometryId = dv.getUint32(offset, true);
+    offset += 4;
+    // Material block ids, positional per geometry sub-mesh. Previously read-and-discarded; kept now so
+    // the diffuse material/texture for each subset can be resolved and attached.
+    const materialIds = [];
+    if (offset + 2 <= end) {
+        const numMaterials = dv.getUint16(offset, true);
+        offset += 2;
+        for (let i = 0; i < numMaterials && offset + 4 <= end; i++) {
+            materialIds.push(dv.getUint32(offset, true));
+            offset += 4;
+        }
+    }
+    // NumAttrList (block properties) and UserAttrList.
+    offset = skipAwdAttrList(view, offset, end);
+    offset = skipAwdAttrList(view, offset, end);
+    return {
+        geometryId,
+        materialIds,
+        name: nameResult.value,
+        parentId,
+        transform: transformResult.transform,
+    };
+}
+// Parses a Material block (type 81). Layout:
+// name(VarString) → matType(uint8) → numMethods(uint8) → PropertyList → methods → UserAttrList.
+// The base PropertyList carries the flat color (property 1), diffuse texture id (property 2), normal
+// texture id (property 3), and alpha (property 10) — the properties Flight maps onto the ShadedMaterial
+// base. `numMethods` is captured so the resolver can record a diagnostic that a method-bearing material's shading methods
+// (fog/env/fresnel/specular in Away3D's MethodMaterial model) are not yet imported as modifiers; the
+// method bodies themselves (which follow the base PropertyList) are left unwalked pending a real
+// method-bearing fixture and the verified AWD2 method-type layout — every AWD2 asset in the reference
+// corpus is `numMethods == 0`, so there is nothing to observe or test the walk against yet.
+function parseMaterialBlock(view, source, start, end, diagnostics) {
+    let offset = start;
+    if (offset + 2 > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.material-truncated', 'parseMaterialBlock', {
+            field: 'name',
+        });
+        return null;
+    }
+    const nameResult = readAwdString(view, source, offset);
+    offset = nameResult.end;
+    if (offset + 2 > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.material-truncated', 'parseMaterialBlock', {
+            field: 'type',
+        });
+        return null;
+    }
+    offset += 1; // matType (uint8) — texture vs color is inferred from which properties are present
+    const numMethods = source[offset];
+    offset += 1; // numMethods (uint8)
+    const props = readAwdProperties(view, offset, end);
+    const diffuseTextureId = readAwdPropertyUint32(view, props.values, AWD2_MATERIAL_PROP_DIFFUSE_TEXTURE) ?? 0;
+    const normalTextureId = readAwdPropertyUint32(view, props.values, AWD2_MATERIAL_PROP_NORMAL_TEXTURE) ?? 0;
+    const color = readAwdPropertyUint32(view, props.values, AWD2_MATERIAL_PROP_COLOR);
+    const alpha = readAwdPropertyFloat32(view, props.values, AWD2_MATERIAL_PROP_ALPHA);
+    return {
+        alpha,
+        color,
+        diffuseTextureId,
+        name: nameResult.value,
+        normalTextureId,
+        numMethods,
+    };
+}
+// Parses a Texture block (type 82). Layout:
+// name(VarString) → texType(uint8) → dataLen(uint32) → data(dataLen bytes) → PropertyList → UserAttrList.
+// The embedded form carries a self-describing image payload (PNG/JPEG/…); the external form stores a
+// URL Flight cannot fetch at parse time and is returned as an unresolved (byte-less) slot.
+function parseTextureBlock(view, source, start, end, diagnostics) {
+    const dv = view;
+    let offset = start;
+    if (offset + 2 > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.texture-truncated', 'parseTextureBlock', {
+            field: 'name',
+        });
+        return null;
+    }
+    const nameResult = readAwdString(view, source, offset);
+    offset = nameResult.end;
+    if (offset + 5 > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.texture-truncated', 'parseTextureBlock', {
+            field: 'payload',
+        });
+        return null;
+    }
+    const texType = source[offset];
+    offset += 1;
+    const dataLen = dv.getUint32(offset, true);
+    offset += 4;
+    if (offset + dataLen > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.texture-truncated', 'parseTextureBlock', {
+            bytes: dataLen,
+            field: 'data',
+        });
+        return null;
+    }
+    if (texType !== AWD2_TEXTURE_TYPE_EMBEDDED) {
+        // AWD's external form carries the image URL as the block name; emit it as an External ref for
+        // the resolver to fetch, rather than dropping it.
+        return {
+            bytes: null,
+            mimeType: null,
+            name: nameResult.value,
+            url: nameResult.value,
+        };
+    }
+    const bytes = source.slice(offset, offset + dataLen);
+    const mimeType = detectImageMimeType(bytes);
+    if (mimeType === null) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Recover, 'awd2.texture-unrecognized-format', 'parseTextureBlock');
+        return { bytes: null, mimeType: null, name: nameResult.value, url: null };
+    }
+    return { bytes, mimeType, name: nameResult.value, url: null };
+}
+// Reads an AWD typed-property list: a uint32 byte-length prefix followed by `uint16 key, uint32
+// fieldLength, <value>` records. Returns each key's value span so callers decode only the keys they
+// know; unknown keys are stepped over by their length.
+function readAwdProperties(view, offset, end) {
+    const dv = view;
+    const values = new Map();
+    if (offset + 4 > end)
+        return { end: offset, values };
+    const listLength = dv.getUint32(offset, true);
+    offset += 4;
+    const listEnd = Math.min(offset + listLength, end);
+    while (offset + 6 <= listEnd) {
+        const key = dv.getUint16(offset, true);
+        offset += 2;
+        const fieldLength = dv.getUint32(offset, true);
+        offset += 4;
+        if (offset + fieldLength > listEnd)
+            break;
+        values.set(key, { length: fieldLength, offset });
+        offset += fieldLength;
+    }
+    return { end: listEnd, values };
+}
+function readAwdPropertyFloat32(view, values, key) {
+    const entry = values.get(key);
+    if (entry === undefined || entry.length < 4)
+        return null;
+    return view.getFloat32(entry.offset, true);
+}
+function readAwdPropertyUint32(view, values, key) {
+    const entry = values.get(key);
+    if (entry === undefined || entry.length < 4)
+        return null;
+    return view.getUint32(entry.offset, true);
+}
+// Resolves an AWD material block id to a document material INDEX (appended to `document.materials`),
+// memoized so a material shared by several subsets registers one entry (and one Texture/ImageResource per
+// shared texture). An EXISTING material block ALWAYS produces a ShadedMaterial — a block with no base
+// properties (no color, no textures, alpha-only, or method-only) is a valid material and defaults to
+// opaque white, honoring the uniform-ShadedMaterial rule. Only the sentinel id 0 (subset declares no
+// material) and a referenced-but-missing block id return -1 (the assembler resolves that to a null material).
+//
+// AWD materials import as ShadedMaterial UNIFORMLY — including numMethods=0 (empty modifiers[]). AWD's
+// material model is a MethodMaterial = a BlinnPhong base + a METHODS ARRAY; ShadedMaterial (base + an
+// ordered modifiers[]) is its structural image. An empty stack honestly encodes a method-less material
+// and compiles to the same base program as BlinnPhong (zero pixel cost), while (a) preserving losslessness
+// if a file/exporter DOES carry methods, and (b) letting a demo author reproduce the original Away3D look
+// by APPENDING a fresnel/fog modifier — no material-kind conversion. Do NOT collapse method-less materials
+// to BlinnPhong: that discards the format's array-shaped intent to save a type. (Callers who genuinely want
+// the leaner kind can down-convert a modifier-less ShadedMaterial to BlinnPhong themselves.)
+//
+// A method-bearing material (numMethods > 0) records a Skip diagnostic and imports its base only: the AWD2 method-block layout
+// is unverified in-sandbox (the whole reference corpus is numMethods=0), so shipping a blind method→modifier
+// walk would be speculative. The base carries color(1), diffuseTex(2), normalTex(3), alpha(10) — the only
+// base properties real AWD2 files use; specular/gloss/ambient are METHODS in Away3D's model, not base props.
+function resolveAwdMaterial(materialId, materialBlocks, textureBlocks, cache, document, diagnostics) {
+    if (materialId === 0)
+        return -1;
+    const cached = cache.get(materialId);
+    if (cached !== undefined)
+        return cached;
+    const parsed = materialBlocks.get(materialId);
+    if (parsed === undefined) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.material-missing', 'resolveAwdMaterial', {
+            material: materialId,
+        });
+        cache.set(materialId, -1);
+        return -1;
+    }
+    const diffuseTexture = parsed.diffuseTextureId !== 0
+        ? resolveAwdTexture(parsed.diffuseTextureId, textureBlocks, document, diagnostics)
+        : null;
+    const normalTexture = parsed.normalTextureId !== 0
+        ? resolveAwdTexture(parsed.normalTextureId, textureBlocks, document, diagnostics)
+        : null;
+    // A method-bearing material imports its base only (see the header note) — record a diagnostic rather than silently drop.
+    if (parsed.numMethods > 0) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Skip, 'awd2.material-methods-unsupported', 'resolveAwdMaterial', { methods: parsed.numMethods });
+    }
+    const diffuse = getAwdDiffuseRgba(parsed.color, parsed.alpha);
+    const material = createShadedMaterial({
+        diffuse,
+        diffuseMap: diffuseTexture,
+        normalMap: normalTexture,
+    });
+    // An alpha below 1 must actually blend; ShadedMaterial defaults to opaque coverage.
+    if (parsed.alpha !== null && parsed.alpha < 1)
+        material.alphaMode = 'blend';
+    // Preserve the AWD material block name as the material's authored name (empty → anonymous).
+    material.name = parsed.name.length > 0 ? parsed.name : null;
+    const index = document.materials.length;
+    document.materials.push(material);
+    cache.set(materialId, index);
+    return index;
+}
+// Resolves an AWD texture block id to a Flight Texture carrying an unresolved ImageResourceReference, or
+// null when the texture is missing or its embedded payload was an unrecognized image format. The
+// parser references — it does not decode: an embedded block emits an Embedded ref holding the encoded
+// bytes; an external block emits an External ref holding the URL. The Texture's `image` stays null
+// until @flighthq/scene3d-resources resolves the ref.
+function resolveAwdTexture(textureId, textureBlocks, document, diagnostics) {
+    const parsed = textureBlocks.get(textureId);
+    if (parsed === undefined) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.texture-missing', 'resolveAwdTexture', {
+            texture: textureId,
+        });
+        return null;
+    }
+    if (parsed.bytes !== null && parsed.mimeType !== null) {
+        return createEmbeddedTextureRef(parsed.bytes, parsed.mimeType, document.resources);
+    }
+    if (parsed.url !== null) {
+        return createExternalTextureRef(parsed.url, null, document.resources);
+    }
+    return null;
+}
+// Packs an AWD material's diffuse into a Flight 0xrrggbbaa color. AWD stores the color as 24-bit 0xrrggbb
+// (property 1) and opacity as a separate float32 alpha (property 10); Flight folds them into one packed
+// RGBA. A missing color defaults to white, a missing alpha to fully opaque.
+function getAwdDiffuseRgba(color, alpha) {
+    const rgb = color ?? 0xffffff;
+    const alphaByte = alpha !== null ? Math.max(0, Math.min(255, Math.round(alpha * 255))) : 0xff;
+    return (((rgb << 8) >>> 0) | alphaByte) >>> 0;
+}
+// Parses a Skeleton block (type 101). Layout:
+// name(VarString) → jointCount(uint16) → NumAttrList → per joint:
+//   jointId(uint16) → parentId(uint16, 1-based, 0=root) → name(VarString)
+//   → matrix4x3(12 × floatSize) → NumAttrList → UserAttrList
+function parseSkeletonBlock(view, source, start, end, matrixWide, diagnostics) {
+    const dv = view;
+    let offset = start;
+    if (offset + 2 > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.skeleton-truncated', 'parseSkeletonBlock', {
+            field: 'name',
+        });
+        return null;
+    }
+    const nameResult = readAwdString(view, source, offset);
+    offset = nameResult.end;
+    if (offset + 2 > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.skeleton-truncated', 'parseSkeletonBlock', {
+            field: 'jointCount',
+        });
+        return null;
+    }
+    const jointCount = dv.getUint16(offset, true);
+    offset += 2;
+    offset = skipAwdAttrList(view, offset, end);
+    const joints = [];
+    for (let j = 0; j < jointCount; j++) {
+        // Joint ID (sequential, 0-based).
+        if (offset + 4 > end) {
+            reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.skeleton-truncated', 'parseSkeletonBlock', {
+                field: 'jointFields',
+            });
+            return null;
+        }
+        offset += 2; // skip jointId (implicit from array position)
+        const parentIndex = dv.getUint16(offset, true);
+        offset += 2;
+        if (offset + 2 > end) {
+            reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.skeleton-truncated', 'parseSkeletonBlock', {
+                field: 'jointName',
+            });
+            return null;
+        }
+        const jointNameResult = readAwdString(view, source, offset);
+        offset = jointNameResult.end;
+        const floatSize = matrixWide ? 8 : 4;
+        if (offset + 12 * floatSize > end) {
+            reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.skeleton-truncated', 'parseSkeletonBlock', {
+                field: 'jointTransform',
+            });
+            return null;
+        }
+        const transformResult = readAwdTransform(view, offset, matrixWide);
+        offset = transformResult.end;
+        offset = skipAwdAttrList(view, offset, end);
+        offset = skipAwdAttrList(view, offset, end);
+        joints.push({
+            name: jointNameResult.value,
+            parentIndex,
+            transform: transformResult.transform,
+        });
+    }
+    return { joints, name: nameResult.value };
+}
+// Parses a SkeletonPose block (type 102). Layout:
+// name(VarString) → jointCount(uint16) → NumAttrList → per joint:
+//   hasTransform(uint8) → optional matrix4x3(12 × floatSize)
+function parseSkeletonPoseBlock(view, source, start, end, matrixWide, diagnostics) {
+    const dv = view;
+    let offset = start;
+    if (offset + 2 > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.skeleton-pose-truncated', 'parseSkeletonPoseBlock', {
+            field: 'name',
+        });
+        return null;
+    }
+    const nameResult = readAwdString(view, source, offset);
+    offset = nameResult.end;
+    if (offset + 2 > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.skeleton-pose-truncated', 'parseSkeletonPoseBlock', {
+            field: 'jointCount',
+        });
+        return null;
+    }
+    const jointCount = dv.getUint16(offset, true);
+    offset += 2;
+    offset = skipAwdAttrList(view, offset, end);
+    const jointTransforms = [];
+    for (let j = 0; j < jointCount; j++) {
+        if (offset + 1 > end) {
+            reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.skeleton-pose-truncated', 'parseSkeletonPoseBlock', {
+                field: 'hasTransform',
+            });
+            return null;
+        }
+        const hasTransform = dv.getUint8(offset);
+        offset += 1;
+        if (hasTransform !== 0) {
+            const floatSize = matrixWide ? 8 : 4;
+            if (offset + 12 * floatSize > end) {
+                reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.skeleton-pose-truncated', 'parseSkeletonPoseBlock', {
+                    field: 'jointTransform',
+                });
+                return null;
+            }
+            const transformResult = readAwdTransform(view, offset, matrixWide);
+            offset = transformResult.end;
+            jointTransforms.push(transformResult.transform);
+        }
+        else {
+            jointTransforms.push(null);
+        }
+    }
+    return { jointTransforms, name: nameResult.value };
+}
+// Parses a SkeletonAnimation block (type 103). Layout:
+// name(VarString) → frameCount(uint16) → NumAttrList → per frame:
+//   poseBlockId(uint32) → duration(uint16, milliseconds)
+function parseSkeletonAnimationBlock(view, source, start, end, diagnostics) {
+    const dv = view;
+    let offset = start;
+    if (offset + 2 > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.skeleton-animation-truncated', 'parseSkeletonAnimationBlock', {
+            field: 'name',
+        });
+        return null;
+    }
+    const nameResult = readAwdString(view, source, offset);
+    offset = nameResult.end;
+    if (offset + 2 > end) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.skeleton-animation-truncated', 'parseSkeletonAnimationBlock', {
+            field: 'frameCount',
+        });
+        return null;
+    }
+    const poseCount = dv.getUint16(offset, true);
+    offset += 2;
+    offset = skipAwdAttrList(view, offset, end);
+    const poses = [];
+    for (let p = 0; p < poseCount; p++) {
+        if (offset + 4 > end) {
+            reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.skeleton-animation-truncated', 'parseSkeletonAnimationBlock', {
+                field: 'poseBlockId',
+            });
+            return null;
+        }
+        const poseBlockId = dv.getUint32(offset, true);
+        offset += 4;
+        if (offset + 2 > end) {
+            reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Drop, 'awd2.skeleton-animation-truncated', 'parseSkeletonAnimationBlock', {
+                field: 'poseDuration',
+            });
+            return null;
+        }
+        const duration = dv.getUint16(offset, true);
+        offset += 2;
+        poses.push({ duration, poseBlockId });
+    }
+    return { name: nameResult.value, poses };
+}
+// Resolves the block-stream buffer to walk: the source unchanged for an uncompressed body, or the 12-byte
+// header spliced in front of the inflated body for a compressed one — so the caller's walk is identical
+// either way (compression byte rewritten to NONE, body-length field to the inflated length). Returns null
+// (after recording a diagnostic) when the compression method has no registered decompressor or the codec fails.
+function rehydrateAwdBody(input, diagnostics) {
+    const view = new DataView(input.buffer, input.byteOffset, input.byteLength);
+    const compression = input[7];
+    if (compression === AWD2_COMPRESSION_NONE)
+        return { source: input, view };
+    const decompressor = awdDecompressors.get(compression);
+    if (decompressor === undefined) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Reject, 'awd2.compression-no-decompressor', 'rehydrateAwdBody', { compression });
+        return null;
+    }
+    // The header's body-length field is the on-disk (compressed) length; the compressed stream is the bytes
+    // from the end of the 12-byte header to there.
+    const compressedEnd = Math.min(AWD2_HEADER_BYTES + view.getUint32(8, true), input.byteLength);
+    const inflated = decompressor(input.subarray(AWD2_HEADER_BYTES, compressedEnd));
+    if (inflated === null) {
+        reportImportDiagnostic(diagnostics, ImportDiagnosticSeverity.Reject, 'awd2.decompression-failed', 'rehydrateAwdBody', { compression });
+        return null;
+    }
+    const rehydrated = new Uint8Array(AWD2_HEADER_BYTES + inflated.byteLength);
+    rehydrated.set(input.subarray(0, AWD2_HEADER_BYTES), 0);
+    rehydrated.set(inflated, AWD2_HEADER_BYTES);
+    const rehydratedView = new DataView(rehydrated.buffer);
+    rehydrated[7] = AWD2_COMPRESSION_NONE;
+    rehydratedView.setUint32(8, inflated.byteLength, true);
+    return { source: rehydrated, view: rehydratedView };
+}
+// Bitangent handedness written into every AWD tangent's W (B = W·normal×tangent). AWD carries no W and
+// Away3D uses a single mesh-wide handedness (bitangent = normal×tangent in its left-handed space); the
+// left→right-handed conversion (negateVec3Z, det = -1) inverts it, making -1 the correct Flight-space
+// sign. Kept as one named constant so a render proof against a normal-mapped fixture (shambler) can flip
+// it in one place if Away3D's convention proves to be the opposite chirality.
+const AWD2_TANGENT_HANDEDNESS = -1;
+// Opt-in decompressor registry keyed by the header compression byte. Empty by default so an inflate/LZMA
+// codec is only pulled into a bundle when the caller registers one (registerAwd2Decompressor).
+const awdDecompressors = new Map();
+// Whether a decomposed pose scale departs from unit within tolerance — the gate for emitting a scale
+// animation channel (skipped for the common identity-scale skeletons so clips stay lean).
+function hasNonUnitScale(sx, sy, sz) {
+    return Math.abs(sx - 1) > 1e-4 || Math.abs(sy - 1) > 1e-4 || Math.abs(sz - 1) > 1e-4;
+}
+//# sourceMappingURL=awd2Parse.js.map