@flighthq/texture-formats 0.1.0

package/dist/parseKtx2.js

@@ -0,0 +1,173 @@
+import { createByteReader, hasByteReaderBytes, readByteReaderU32, readByteReaderU64, skipByteReader, } from './byteReader';
+// Parses a KTX2 container (Khronos KTX 2.0) into a `TextureContainer`, or returns `null` if the bytes
+// are not KTX2, are truncated, or carry a `vkFormat`/supercompression this package does not map yet.
+//
+// Reads the 12-byte identifier, the fixed header (`vkFormat`, `pixelWidth/Height/Depth`, `layerCount`,
+// `faceCount`, `levelCount`, `supercompressionScheme`), and the level index (per-level `byteOffset` /
+// `byteLength`). The Data Format Descriptor and key/value data are skipped — `vkFormat` alone
+// determines the format, except when it is `VK_FORMAT_UNDEFINED` (0), where the payload is Basis: a
+// `BasisLZ`-supercompressed level is ETC1S, otherwise it is UASTC (the DFD's exact colorModel is not
+// deep-parsed). Supercompressed levels are reported as single compressed blobs (they cannot be split
+// per face/layer without inflating); uncompressed levels are split into their per-`(layer, face)`
+// sub-images, nested mip-major → layer → face to match the KTX2 image order.
+export function parseKtx2(bytes) {
+    if (!hasKtx2Identifier(bytes))
+        return null;
+    // 12 id + 68 header/index (17 u32 = 68 bytes) before the level index at offset 80.
+    if (bytes.byteLength < ktx2LevelIndexOffset)
+        return null;
+    const reader = createByteReader(bytes, 12);
+    const vkFormat = readByteReaderU32(reader);
+    skipByteReader(reader, 4); // typeSize
+    const pixelWidth = readByteReaderU32(reader);
+    const pixelHeight = readByteReaderU32(reader);
+    const pixelDepth = readByteReaderU32(reader);
+    const layerCount = readByteReaderU32(reader);
+    const faceCount = readByteReaderU32(reader);
+    const levelCount = readByteReaderU32(reader);
+    const supercompressionScheme = readByteReaderU32(reader);
+    // dfd/kvd/sgd index (2 u32 + 2 u32 + 2 u64 = 32 bytes) — not needed to locate levels.
+    const supercompression = ktx2Supercompression[supercompressionScheme];
+    if (supercompression === undefined)
+        return null;
+    const format = mapKtx2Format(vkFormat, supercompressionScheme);
+    if (format === null)
+        return null;
+    const width = Math.max(1, pixelWidth);
+    const height = Math.max(1, pixelHeight);
+    const depth = Math.max(1, pixelDepth);
+    const layers = Math.max(1, layerCount);
+    const faces = faceCount === 6 ? 6 : 1;
+    const levelCountPresent = Math.max(1, levelCount);
+    reader.offset = ktx2LevelIndexOffset;
+    if (!hasByteReaderBytes(reader, levelCountPresent * 24))
+        return null;
+    const levels = [];
+    const imagesPerLevel = layers * faces;
+    for (let mip = 0; mip < levelCountPresent; mip += 1) {
+        const byteOffset = readByteReaderU64(reader);
+        const byteLength = readByteReaderU64(reader);
+        skipByteReader(reader, 8); // uncompressedByteLength
+        if (byteOffset + byteLength > bytes.byteLength)
+            return null;
+        const mipWidth = Math.max(1, width >> mip);
+        const mipHeight = Math.max(1, height >> mip);
+        const splittable = supercompression === 'None' && imagesPerLevel > 1 && byteLength % imagesPerLevel === 0;
+        if (!splittable) {
+            levels.push({ byteLength, byteOffset, height: mipHeight, width: mipWidth });
+            continue;
+        }
+        const imageSize = byteLength / imagesPerLevel;
+        for (let image = 0; image < imagesPerLevel; image += 1) {
+            levels.push({
+                byteLength: imageSize,
+                byteOffset: byteOffset + image * imageSize,
+                height: mipHeight,
+                width: mipWidth,
+            });
+        }
+    }
+    return {
+        depth,
+        faces,
+        format,
+        height,
+        layers,
+        levels,
+        mipLevels: levelCountPresent,
+        supercompression,
+        width,
+    };
+}
+function hasKtx2Identifier(bytes) {
+    if (bytes.byteLength < 12)
+        return false;
+    for (let i = 0; i < 12; i += 1) {
+        if (bytes[i] !== ktx2Identifier[i])
+            return false;
+    }
+    return true;
+}
+function mapKtx2Format(vkFormat, supercompressionScheme) {
+    if (vkFormat === 0)
+        return supercompressionScheme === 1 ? 'etc1s' : 'uastc';
+    return ktx2VkFormat[vkFormat] ?? null;
+}
+// «KTX 20»\r\n\x1A\n
+const ktx2Identifier = [0xab, 0x4b, 0x54, 0x58, 0x20, 0x32, 0x30, 0xbb, 0x0d, 0x0a, 0x1a, 0x0a];
+// 12 (identifier) + 48 (header: 9 u32) + 20 (dfd/kvd offsets: 2 u32 each + 2 u64) = 80.
+const ktx2LevelIndexOffset = 80;
+const ktx2Supercompression = {
+    0: 'None',
+    1: 'BasisLZ',
+    2: 'Zstd',
+    3: 'ZLIB',
+};
+// Curated Vulkan `vkFormat` → `TextureContainerFormat`. Uncompressed 8-bit/float, the full BC set, ETC2/EAC,
+// and ASTC LDR block sizes. ASTC sRGB codes collapse onto their unorm block (the vocabulary keys ASTC by
+// block size, not color space); BC1 RGB and RGBA codes both map to `bc1`. Unmapped codes → `null`.
+const ktx2VkFormat = {
+    9: 'r8unorm',
+    16: 'rg8unorm',
+    37: 'rgba8unorm',
+    43: 'rgba8Srgb',
+    44: 'bgra8unorm',
+    50: 'bgra8Srgb',
+    97: 'rgba16f',
+    109: 'rgba32f',
+    131: 'bc1',
+    132: 'bc1Srgb',
+    133: 'bc1',
+    134: 'bc1Srgb',
+    135: 'bc2',
+    136: 'bc2Srgb',
+    137: 'bc3',
+    138: 'bc3Srgb',
+    139: 'bc4',
+    140: 'bc4Snorm',
+    141: 'bc5',
+    142: 'bc5Snorm',
+    143: 'bc6hUfloat',
+    144: 'bc6hSfloat',
+    145: 'bc7',
+    146: 'bc7Srgb',
+    147: 'etc2Rgb',
+    148: 'etc2RgbSrgb',
+    149: 'etc2RgbA1',
+    150: 'etc2RgbA1Srgb',
+    151: 'etc2Rgba',
+    152: 'etc2RgbaSrgb',
+    153: 'eacR11',
+    154: 'eacR11Snorm',
+    155: 'eacRg11',
+    156: 'eacRg11Snorm',
+    157: 'astc4x4',
+    158: 'astc4x4',
+    159: 'astc5x4',
+    160: 'astc5x4',
+    161: 'astc5x5',
+    162: 'astc5x5',
+    163: 'astc6x5',
+    164: 'astc6x5',
+    165: 'astc6x6',
+    166: 'astc6x6',
+    167: 'astc8x5',
+    168: 'astc8x5',
+    169: 'astc8x6',
+    170: 'astc8x6',
+    171: 'astc8x8',
+    172: 'astc8x8',
+    173: 'astc10x5',
+    174: 'astc10x5',
+    175: 'astc10x6',
+    176: 'astc10x6',
+    177: 'astc10x8',
+    178: 'astc10x8',
+    179: 'astc10x10',
+    180: 'astc10x10',
+    181: 'astc12x10',
+    182: 'astc12x10',
+    183: 'astc12x12',
+    184: 'astc12x12',
+};
+//# sourceMappingURL=parseKtx2.js.map

package/dist/parseKtx2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseKtx2.js","sourceRoot":"","sources":["../src/parseKtx2.ts"],"names":[],"mappings":"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"}

package/dist/selectTextureContainer.d.ts

@@ -0,0 +1,4 @@
+import type { TextureContainer } from '@flighthq/types';
+import type { TextureContainerFormat } from '@flighthq/types';
+export declare function selectTextureContainer(containers: readonly TextureContainer[], supportedFormats: readonly TextureContainerFormat[]): TextureContainer | null;
+//# sourceMappingURL=selectTextureContainer.d.ts.map

package/dist/selectTextureContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectTextureContainer.d.ts","sourceRoot":"","sources":["../src/selectTextureContainer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAS9D,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,SAAS,gBAAgB,EAAE,EACvC,gBAAgB,EAAE,SAAS,sBAAsB,EAAE,GAClD,gBAAgB,GAAG,IAAI,CAKzB"}

package/dist/selectTextureContainer.js

@@ -0,0 +1,15 @@
+// Picks the first container whose `format` a GPU supports from a set of peer `TextureContainer`s,
+// returning `null` when none match. This is the consumer side of `parseAtf`'s peer array: an ATF holds
+// the same texture in several GPU encodings (DXT + PVRTC + ETC, ...), and the runtime uploads whichever
+// one its GPU can consume. `supportedFormats` is the caller's list of GPU-supported
+// `TextureContainerFormat`s, in preference order within `containers` (the first supported container
+// wins, so order `containers` by upload preference). Format-agnostic — it works on any
+// `TextureContainer[]`, not only ATF's, so a caller can filter a KTX2/Basis format set the same way.
+export function selectTextureContainer(containers, supportedFormats) {
+    for (const container of containers) {
+        if (supportedFormats.includes(container.format))
+            return container;
+    }
+    return null;
+}
+//# sourceMappingURL=selectTextureContainer.js.map

package/dist/selectTextureContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectTextureContainer.js","sourceRoot":"","sources":["../src/selectTextureContainer.ts"],"names":[],"mappings":"AAGA,kGAAkG;AAClG,uGAAuG;AACvG,wGAAwG;AACxG,oFAAoF;AACpF,oGAAoG;AACpG,uFAAuF;AACvF,qGAAqG;AACrG,MAAM,UAAU,sBAAsB,CACpC,UAAuC,EACvC,gBAAmD;IAEnD,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,IAAI,gBAAgB,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC;YAAE,OAAO,SAAS,CAAC;IACpE,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/textureLevelLayout.d.ts

@@ -0,0 +1,8 @@
+import type { TextureContainerFormat } from '@flighthq/types';
+import type { TextureContainerLevel } from '@flighthq/types';
+export declare function computeTextureContainerLevels(format: TextureContainerFormat, baseWidth: number, baseHeight: number, mipLevels: number, layers: number, faces: number, startOffset: number): {
+    readonly levels: TextureContainerLevel[];
+    readonly endOffset: number;
+} | null;
+export declare function getTextureContainerLevelByteLength(format: TextureContainerFormat, width: number, height: number): number;
+//# sourceMappingURL=textureLevelLayout.d.ts.map

package/dist/textureLevelLayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textureLevelLayout.d.ts","sourceRoot":"","sources":["../src/textureLevelLayout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAC9D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAa7D,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,sBAAsB,EAC9B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,GAClB;IAAE,QAAQ,CAAC,MAAM,EAAE,qBAAqB,EAAE,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAiBjF;AAID,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,sBAAsB,EAC9B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,MAAM,CAMR"}

package/dist/textureLevelLayout.js

@@ -0,0 +1,109 @@
+// Block-size-aware mip-chain layout, shared by the container parsers. A `TextureContainerFormat` is
+// either uncompressed (a 1x1 "block" of N bytes per pixel) or block-compressed (a fixed WxH block of N
+// bytes); a mip level's byte length is `bytesPerBlock * ceil(width/blockWidth) * ceil(height/blockHeight)`.
+// DDS stores no level index, so it computes every level's size here; KTX2 and Basis carry explicit
+// per-level ranges and use this only where they still need a size.
+// Builds the flat sub-image list for a mip chain that is laid out contiguously from `startOffset`, in
+// DDS/D3D subresource order — layer-major, then face, then mip contiguous within a face
+// (`subresource = mip + (face + layer * faces) * mipLevels`). Returns the built `levels` plus the
+// offset just past the last level, or `null` if the format has no fixed block size (a transcoded
+// Basis format never reaches this path). Dimensions halve per mip, floored at 1.
+export function computeTextureContainerLevels(format, baseWidth, baseHeight, mipLevels, layers, faces, startOffset) {
+    if (getTextureContainerFormatBlockInfo(format) === null)
+        return null;
+    const levels = [];
+    let offset = startOffset;
+    for (let layer = 0; layer < layers; layer += 1) {
+        for (let face = 0; face < faces; face += 1) {
+            for (let mip = 0; mip < mipLevels; mip += 1) {
+                const width = Math.max(1, baseWidth >> mip);
+                const height = Math.max(1, baseHeight >> mip);
+                const byteLength = getTextureContainerLevelByteLength(format, width, height);
+                levels.push({ byteOffset: offset, byteLength, height, width });
+                offset += byteLength;
+            }
+        }
+    }
+    return { endOffset: offset, levels };
+}
+// Bytes occupied by a single mip level of the given format at the given pixel dimensions, or `-1` if the
+// format has no fixed block size (`etc1s`, whose rate is variable and only known after transcoding).
+export function getTextureContainerLevelByteLength(format, width, height) {
+    const block = getTextureContainerFormatBlockInfo(format);
+    if (block === null)
+        return -1;
+    const blocksWide = Math.ceil(width / block.blockWidth);
+    const blocksHigh = Math.ceil(height / block.blockHeight);
+    return blocksWide * blocksHigh * block.bytesPerBlock;
+}
+function getTextureContainerFormatBlockInfo(format) {
+    return formatBlockInfo[format];
+}
+function pixelBlock(bytesPerPixel) {
+    return { blockHeight: 1, blockWidth: 1, bytesPerBlock: bytesPerPixel };
+}
+function compressedBlock(blockWidth, blockHeight, bytesPerBlock) {
+    return { blockHeight, blockWidth, bytesPerBlock };
+}
+// Exhaustive so the compiler flags any new `TextureContainerFormat` that lacks block sizing. `etc1s` is
+// intentionally null (variable-rate Basis ETC1S — its byte layout comes from the container's own slice
+// table, not from a block formula).
+const formatBlockInfo = {
+    astc4x4: compressedBlock(4, 4, 16),
+    astc5x4: compressedBlock(5, 4, 16),
+    astc5x5: compressedBlock(5, 5, 16),
+    astc6x5: compressedBlock(6, 5, 16),
+    astc6x6: compressedBlock(6, 6, 16),
+    astc8x5: compressedBlock(8, 5, 16),
+    astc8x6: compressedBlock(8, 6, 16),
+    astc8x8: compressedBlock(8, 8, 16),
+    astc10x5: compressedBlock(10, 5, 16),
+    astc10x6: compressedBlock(10, 6, 16),
+    astc10x8: compressedBlock(10, 8, 16),
+    astc10x10: compressedBlock(10, 10, 16),
+    astc12x10: compressedBlock(12, 10, 16),
+    astc12x12: compressedBlock(12, 12, 16),
+    bc1: compressedBlock(4, 4, 8),
+    bc1Srgb: compressedBlock(4, 4, 8),
+    bc2: compressedBlock(4, 4, 16),
+    bc2Srgb: compressedBlock(4, 4, 16),
+    bc3: compressedBlock(4, 4, 16),
+    bc3Srgb: compressedBlock(4, 4, 16),
+    bc4: compressedBlock(4, 4, 8),
+    bc4Snorm: compressedBlock(4, 4, 8),
+    bc5: compressedBlock(4, 4, 16),
+    bc5Snorm: compressedBlock(4, 4, 16),
+    bc6hSfloat: compressedBlock(4, 4, 16),
+    bc6hUfloat: compressedBlock(4, 4, 16),
+    bc7: compressedBlock(4, 4, 16),
+    bc7Srgb: compressedBlock(4, 4, 16),
+    bgra8Srgb: pixelBlock(4),
+    bgra8unorm: pixelBlock(4),
+    eacR11: compressedBlock(4, 4, 8),
+    eacR11Snorm: compressedBlock(4, 4, 8),
+    eacRg11: compressedBlock(4, 4, 16),
+    eacRg11Snorm: compressedBlock(4, 4, 16),
+    etc1: compressedBlock(4, 4, 8),
+    etc1s: null,
+    etc2Rgb: compressedBlock(4, 4, 8),
+    etc2RgbA1: compressedBlock(4, 4, 8),
+    etc2RgbA1Srgb: compressedBlock(4, 4, 8),
+    etc2RgbSrgb: compressedBlock(4, 4, 8),
+    etc2Rgba: compressedBlock(4, 4, 16),
+    etc2RgbaSrgb: compressedBlock(4, 4, 16),
+    // PVRTC v1 blocks are 64-bit (8 bytes): 4bpp packs a 4x4 pixel tile, 2bpp an 8x4 tile. The formula
+    // matches the tightly-packed (aligned) size; PVRTC's real minimum-size/overlap rules are a decode
+    // concern, not needed to locate ATF's explicitly length-prefixed blocks.
+    pvrtc2bppRgb: compressedBlock(8, 4, 8),
+    pvrtc2bppRgba: compressedBlock(8, 4, 8),
+    pvrtc4bppRgb: compressedBlock(4, 4, 8),
+    pvrtc4bppRgba: compressedBlock(4, 4, 8),
+    r8unorm: pixelBlock(1),
+    rg8unorm: pixelBlock(2),
+    rgba16f: pixelBlock(8),
+    rgba32f: pixelBlock(16),
+    rgba8Srgb: pixelBlock(4),
+    rgba8unorm: pixelBlock(4),
+    uastc: compressedBlock(4, 4, 16),
+};
+//# sourceMappingURL=textureLevelLayout.js.map

package/dist/textureLevelLayout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"textureLevelLayout.js","sourceRoot":"","sources":["../src/textureLevelLayout.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@flighthq/texture-formats",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "Tree-shakable GPU texture-container parsers (KTX2 / DDS / Basis) — identify format and locate per-level byte ranges, no transcode",
+  "sideEffects": false
+}

package/src/byteReader.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  createByteReader,
+  hasByteReaderBytes,
+  readByteReaderU16,
+  readByteReaderU24BigEndian,
+  readByteReaderU32,
+  readByteReaderU32BigEndian,
+  readByteReaderU64,
+  readByteReaderU8,
+  skipByteReader,
+} from './byteReader';
+
+describe('createByteReader', () => {
+  it('starts at the given offset', () => {
+    const reader = createByteReader(new Uint8Array([1, 2, 3, 4]), 2);
+    expect(reader.offset).toBe(2);
+    expect(readByteReaderU8(reader)).toBe(3);
+  });
+
+  it('views a subarray by its byteOffset', () => {
+    const backing = new Uint8Array([9, 9, 0x01, 0x00]);
+    const reader = createByteReader(backing.subarray(2));
+    expect(readByteReaderU16(reader)).toBe(1);
+  });
+});
+
+describe('hasByteReaderBytes', () => {
+  it('reports whether count bytes remain from the current offset', () => {
+    const reader = createByteReader(new Uint8Array(8), 4);
+    expect(hasByteReaderBytes(reader, 4)).toBe(true);
+    expect(hasByteReaderBytes(reader, 5)).toBe(false);
+    expect(hasByteReaderBytes(reader, 0)).toBe(true);
+  });
+});
+
+describe('readByteReaderU16', () => {
+  it('reads little-endian and advances 2', () => {
+    const reader = createByteReader(new Uint8Array([0x34, 0x12]));
+    expect(readByteReaderU16(reader)).toBe(0x1234);
+    expect(reader.offset).toBe(2);
+  });
+});
+
+describe('readByteReaderU24BigEndian', () => {
+  it('reads a 3-byte big-endian value and advances 3', () => {
+    const reader = createByteReader(new Uint8Array([0x12, 0x34, 0x56]));
+    expect(readByteReaderU24BigEndian(reader)).toBe(0x123456);
+    expect(reader.offset).toBe(3);
+  });
+
+  it('reads the full 24-bit range without sign issues', () => {
+    const reader = createByteReader(new Uint8Array([0xff, 0xff, 0xff]));
+    expect(readByteReaderU24BigEndian(reader)).toBe(0xffffff);
+  });
+});
+
+describe('readByteReaderU32', () => {
+  it('reads little-endian and advances 4', () => {
+    const reader = createByteReader(new Uint8Array([0x78, 0x56, 0x34, 0x12]));
+    expect(readByteReaderU32(reader)).toBe(0x12345678);
+    expect(reader.offset).toBe(4);
+  });
+});
+
+describe('readByteReaderU32BigEndian', () => {
+  it('reads a 4-byte big-endian value and advances 4', () => {
+    const reader = createByteReader(new Uint8Array([0x12, 0x34, 0x56, 0x78]));
+    expect(readByteReaderU32BigEndian(reader)).toBe(0x12345678);
+    expect(reader.offset).toBe(4);
+  });
+
+  it('reads the full 32-bit range as an unsigned value', () => {
+    const reader = createByteReader(new Uint8Array([0xff, 0xff, 0xff, 0xff]));
+    expect(readByteReaderU32BigEndian(reader)).toBe(0xffffffff);
+  });
+});
+
+describe('readByteReaderU64', () => {
+  it('reads little-endian as a number and advances 8', () => {
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setUint32(0, 0x1000, true);
+    new DataView(bytes.buffer).setUint32(4, 0x2, true);
+    const reader = createByteReader(bytes);
+    expect(readByteReaderU64(reader)).toBe(0x2 * 0x1_0000_0000 + 0x1000);
+    expect(reader.offset).toBe(8);
+  });
+});
+
+describe('readByteReaderU8', () => {
+  it('reads one byte and advances 1', () => {
+    const reader = createByteReader(new Uint8Array([0xab]));
+    expect(readByteReaderU8(reader)).toBe(0xab);
+    expect(reader.offset).toBe(1);
+  });
+});
+
+describe('skipByteReader', () => {
+  it('advances the offset without reading', () => {
+    const reader = createByteReader(new Uint8Array(8));
+    skipByteReader(reader, 3);
+    expect(reader.offset).toBe(3);
+  });
+});

package/src/detectTextureContainer.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+
+import { detectTextureContainer } from './detectTextureContainer';
+
+const ktx2Magic = [0xab, 0x4b, 0x54, 0x58, 0x20, 0x32, 0x30, 0xbb, 0x0d, 0x0a, 0x1a, 0x0a];
+
+describe('detectTextureContainer', () => {
+  it('sniffs the KTX2 identifier', () => {
+    expect(detectTextureContainer(new Uint8Array([...ktx2Magic, 0, 0, 0, 0]))).toBe('ktx2');
+  });
+
+  it('sniffs the ATF signature', () => {
+    expect(detectTextureContainer(new Uint8Array([0x41, 0x54, 0x46, 0, 0, 0]))).toBe('atf');
+  });
+
+  it('sniffs the DDS magic', () => {
+    expect(detectTextureContainer(new Uint8Array([0x44, 0x44, 0x53, 0x20, 0, 0]))).toBe('dds');
+  });
+
+  it('sniffs the Basis signature', () => {
+    expect(detectTextureContainer(new Uint8Array([0x73, 0x42, 0, 0]))).toBe('basis');
+  });
+
+  it('returns null for an unrecognized or too-short buffer', () => {
+    expect(detectTextureContainer(new Uint8Array([0x89, 0x50, 0x4e, 0x47]))).toBeNull(); // PNG
+    expect(detectTextureContainer(new Uint8Array([0x73]))).toBeNull();
+    expect(detectTextureContainer(new Uint8Array(0))).toBeNull();
+  });
+
+  it('does not mistake a truncated KTX2 identifier for KTX2', () => {
+    expect(detectTextureContainer(new Uint8Array(ktx2Magic.slice(0, 8)))).toBeNull();
+  });
+});