# fileformat.co — Complete Binary Format Specification & QA Fixture Reference

Generated deterministically with compile-time byte-offset truth verification.

## .aab — Android App Bundle (slug: aab)
- Spec Page: https://fileformat.co/ext/aab
- Samples Page: https://fileformat.co/samples/aab
- JSON API: https://fileformat.co/api/v1/ext/aab.json
- MIME Types: application/vnd.android.aab, application/octet-stream, application/zip
- Endianness: little
- Container Family: zip
- Summary: Google Play publishing format packaging `BundleConfig.pb`, Protocol-Buffer encoded `base/manifest/AndroidManifest.xml`, and DEX bytecode inside a modular ZIP container.
- Magic Bytes:
  - offset 0x0: `50 4B 03 04` (PK..) — PKZIP bundle containing BundleConfig.pb & base/manifest/AndroidManifest.xml
- Header Layout:
  - 0x00 - 0x03 (4 B, uint32_le) `zip_magic`: PKZIP Local File Header
  - 0x1E+ (var, utf8) `bundle_config`: 'BundleConfig.pb' protobuf descriptor
- Security Advisory (Risk: medium): Distinguish .aab from .apk by requiring root BundleConfig.pb and verifying JAR/APK signature blocks (META-INF/) in release pipelines.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/aab/minimal-base.aab (450 bytes, sha256: 2564e236b066e8187c9c16be9d3e13332ce02e5d69a7171cf91372d96ebf16f8, expectValid: true) — UNSIGNED container-structure fixture: real ZIP with BundleConfig.pb, base/manifest/AndroidManifest.xml and dex\n039 header stub. NOT a Play-signed publishable bundle.
  - [realistic] https://fileformat.co/fixtures/v1/aab/release-module.aab (572 bytes, sha256: 875c6a215d912e50d0274d36512ef9c5b9564b5c10f1822e631636234fe3016d, expectValid: true) — UNSIGNED fixture adding base/resources.pb alongside BundleConfig.pb and classes.dex to distinguish .aab from legacy .apk.
  - [edge-case] https://fileformat.co/fixtures/v1/aab/truncated-bundle.aab (436 bytes, sha256: af8a9755a801d6c9890cbf897fe1cc1314cfc39a5769e1d56d8418fc8a63883c, expectValid: false) — AAB archive truncated inside the ZIP Central Directory — zipfile must raise.

## .arrow — Apache Arrow IPC Random-Access File (slug: arrow)
- Spec Page: https://fileformat.co/ext/arrow
- Samples Page: https://fileformat.co/samples/arrow
- JSON API: https://fileformat.co/api/v1/ext/arrow.json
- MIME Types: application/vnd.apache.arrow.file
- Endianness: little
- Summary: Zero-copy in-memory columnar format serialized to disk with 8-byte aligned `ARROW1\x00\x00` framing and FlatBuffers schema/record-batch descriptors.
- Magic Bytes:
  - offset 0x0: `41 52 52 4F 57 31 00 00` (ARROW1..) — 6-byte ARROW1 magic padded to 8-byte SIMD alignment
- Header Layout:
  - 0x00 - 0x07 (8 B, char[6]+pad) `header_magic`: 'ARROW1' + 2 zero padding bytes
  - 0x08 - 0x0B (4 B, uint32_le) `continuation`: 0xFFFFFFFF IPC message continuation marker
  - EOF-10 .. EOF-7 (4 B, int32_le) `footer_size`: FlatBuffers Footer byte length
  - EOF-6 .. EOF-1 (6 B, char[6]) `footer_magic`: Trailing 'ARROW1' magic
- Security Advisory (Risk: low): Verify both leading 'ARROW1\x00\x00' and trailing 'ARROW1', and validate FlatBuffer buffer offsets before zero-copy pointer arithmetic.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/arrow/minimal-ipc.arrow (666 bytes, sha256: b86279b7e38e81af141b12db151638fa780d57567b64de10e4a4e1c1610e6b64, expectValid: true) — Real Arrow IPC file-format output from pyarrow RecordBatchFileWriter with ARROW1 magic + FlatBuffers footer.
  - [realistic] https://fileformat.co/fixtures/v1/arrow/record-batch.arrow (3402 bytes, sha256: 469652943f52989ed6b08a1ebea08fe5755d9fed2be0a6e9d4ee8f22a8775121, expectValid: true) — pyarrow-written 100-row IPC file with int64/float64/string columns in a single record batch.
  - [edge-case] https://fileformat.co/fixtures/v1/arrow/missing-footer.arrow (650 bytes, sha256: 2c7855bd0e3ae0dc6aad8260b0c03c8c3aeed62adcd2c5211a7fd6ab98bd6e5d, expectValid: false) — Arrow IPC file-format bytes truncated inside the FlatBuffers footer — RecordBatchFileReader must raise.

## .avif — AVIF (AV1 Image File Format) (slug: avif)
- Spec Page: https://fileformat.co/ext/avif
- Samples Page: https://fileformat.co/samples/avif
- JSON API: https://fileformat.co/api/v1/ext/avif.json
- MIME Types: image/avif
- Endianness: big
- Container Family: isobmff
- Summary: Royalty-free HDR & wide-gamut next-gen web image format wrapping AV1 keyframes inside an ISO Base Media (`ftyp`) container (`major_brand` = `avif` or `avis`).
- Magic Bytes:
  - offset 0x4: `66 74 79 70 61 76 69` (ftypavi) — ISOBMFF ftyp box with 'avif' or 'avis' brand prefix
- Header Layout:
  - 0x00 - 0x03 (4 B, uint32_be) `ftyp_size`: Box byte length
  - 0x04 - 0x07 (4 B, char[4]) `box_type`: 'ftyp' FourCC
  - 0x08 - 0x0B (4 B, char[4]) `major_brand`: 'avif' (still) or 'avis' (sequence)
- Security Advisory (Risk: low): Inspect `ispe` box dimensions before full pixel decoding to block decompression bombs (e.g. 65000x65000px 10KB solid-color AV1 frames).
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/avif/minimal-128x128.avif (2446 bytes, sha256: c1d62b9cfb1ac1ef878cabf2033ef0bd25067ff3fcc032aa0dc5c2c833687918, expectValid: true) — Real AVIF encoded by libavif via pillow-avif: ftyp avif, decodable AV1 primary item.
  - [realistic] https://fileformat.co/fixtures/v1/avif/photo-640x480.avif (40636 bytes, sha256: 66e43e004db1ebc43bcf2b7e3f44198d43d83ec0d828b064a69e5ffa1254667e, expectValid: true) — Real AV1 Image File Format still encoded by libavif at 640×480.
  - [edge-case] https://fileformat.co/fixtures/v1/avif/truncated-box.avif (2414 bytes, sha256: 8fc0516c40d536a757998b236c6d6d96a4b5a36874d8b17c72a64829251e0ae4, expectValid: false) — Real AVIF truncated inside the mdat payload — libavif decoder must raise.

## .avro — Apache Avro Object Container File (slug: avro)
- Spec Page: https://fileformat.co/ext/avro
- Samples Page: https://fileformat.co/samples/avro
- JSON API: https://fileformat.co/api/v1/ext/avro.json
- MIME Types: application/avro, application/octet-stream
- Endianness: little
- Summary: Row-oriented binary data serialization container widely used in Kafka/Confluent event streaming and Iceberg manifest lists, embedding full JSON writer schema in the file header.
- Magic Bytes:
  - offset 0x0: `4F 62 6A 01` (Obj.) — Avro Object Container v1 magic ('O','b','j', 0x01)
- Header Layout:
  - 0x00 - 0x03 (4 B, uint8[4]) `magic`: 'Obj\x01' container signature
  - 0x04+ (var, avro_map) `file_metadata`: ZigZag varint map containing avro.schema & avro.codec
  - hdr_end-16 (16 B, uint8[16]) `sync_marker`: 16-byte random block boundary sync token
- Security Advisory (Risk: low): Validate `Obj\x01` prefix and cap maximum `avro.schema` JSON recursion depth and block decompression size.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/avro/minimal-null.avro (198 bytes, sha256: 8f5420609b6bb63e55d37521ce5163e81467a3ec798784bf5857e3c4131acdfd, expectValid: true) — Real Avro OCF from fastavro with embedded record schema, null codec, and 16-byte sync markers.
  - [realistic] https://fileformat.co/fixtures/v1/avro/events-deflate.avro (241 bytes, sha256: bc90476179aca51aae52611b266a87a02d16fd5392fa551554874ce3218f341a, expectValid: true) — fastavro-written OCF with deflate-compressed block of 10 UserEvent records.
  - [edge-case] https://fileformat.co/fixtures/v1/avro/corrupted-sync-marker.avro (186 bytes, sha256: 6534e49af5871a7f976a650fb164f50be0a9231d34ec2a6e46600354ca5da803, expectValid: false) — Avro block cut off mid-sync-marker — fastavro reader must raise on block-boundary failure.

## .csv — Comma-Separated Values (RFC 4180) (slug: csv)
- Spec Page: https://fileformat.co/ext/csv
- Samples Page: https://fileformat.co/samples/csv
- JSON API: https://fileformat.co/api/v1/ext/csv.json
- MIME Types: text/csv, application/csv
- Endianness: text
- Container Family: text
- Summary: Plain-text tabular interchange format notorious for real-world parser edge cases: optional UTF-8 BOMs (`EF BB BF`), multiline quoted cells, doubled quote escapes (`""`), and formula injection.
- Header Layout:
  - 0x00 (opt) (0 or 3 B, uint8[3]) `utf8_bom`: Optional Excel UTF-8 BOM (EF BB BF)
  - Row 1 (var, utf8) `header_record`: Comma-delimited column names terminated by LF or CRLF
- Security Advisory (Risk: medium): Guard against CSV Formula Injection (DDE): sanitize or prefix cells starting with '=', '+', '-', or '@' when exporting user-uploaded CSVs back to Excel/Sheets.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/csv/minimal-rfc4180.csv (89 bytes, sha256: 05718c2daf0ae301a68f435f20cbb9feb8f079fae27efc908a41c41a86daba62, expectValid: true) — Clean 2-row comma-separated table with LF line endings and no BOM.
  - [realistic] https://fileformat.co/fixtures/v1/csv/orders-unicode-quoted.csv (230 bytes, sha256: 8dcc3d4302a7e62ad485797bc492f9d5217e8a919469109eed8af219eb4e1354, expectValid: true) — Realistic UTF-8 CSV containing quoted commas, whitespace padding, and Japanese characters.
  - [edge-case] https://fileformat.co/fixtures/v1/csv/utf8-bom-multiline-escaped.csv (158 bytes, sha256: 1550b6c3787e1ad84d709a50341f88dbd2b5ae5a96e5e620e3459a82d0392a5f, expectValid: true) — Classic parser breaker: starts with `EF BB BF` BOM, uses `\r\n` inside quoted cells, doubled `""` escapes, and ZWJ emoji.

## .feather — Feather v2 Columnar DataFrame (slug: feather)
- Spec Page: https://fileformat.co/ext/feather
- Samples Page: https://fileformat.co/samples/feather
- JSON API: https://fileformat.co/api/v1/ext/feather.json
- MIME Types: application/vnd.apache.arrow.file, application/octet-stream
- Endianness: little
- Summary: Fast, language-agnostic DataFrame persistence format for Python (Pandas/Polars) and R, standardized since v2 directly atop the Apache Arrow IPC file specification.
- Magic Bytes:
  - offset 0x0: `41 52 52 4F 57 31 00 00` (ARROW1..) — Feather v2 / Arrow IPC 8-byte aligned header
- Header Layout:
  - 0x00 - 0x07 (8 B, char[8]) `magic`: 'ARROW1\x00\x00' (Feather v1 used 'FEA1')
  - EOF-6 .. EOF-1 (6 B, char[6]) `trailer`: Trailing 'ARROW1' footer
- Security Advisory (Risk: low): Check head[0:6] == 'ARROW1' (or 'FEA1' if supporting legacy Feather v1) and trailing 'ARROW1'.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/feather/minimal-v2.feather (698 bytes, sha256: a7b7e3734e10f27781a826cecf82630049d2b74468dea4744a47c433f88ddc4a, expectValid: true) — Feather v2 file written by pyarrow.feather — a 2-column float64 frame on the Arrow IPC file spec.
  - [realistic] https://fileformat.co/fixtures/v1/feather/dataframe-metrics.feather (2314 bytes, sha256: 9c926ae0f0b8243b5c925b4148d223a0087992617977aa1f8a24537e9ee400ca, expectValid: true) — 120-row Feather v2 frame with timestamp/string/float64 columns for pandas / Polars / R interchange tests.
  - [edge-case] https://fileformat.co/fixtures/v1/feather/truncated-tail.feather (682 bytes, sha256: d3a2f23f36b2b0ae8ebfbffd7606ce33280de61a137e55e3ce62bce679e6ed70, expectValid: false) — Feather file missing footer bytes and trailing ARROW1 signature — pyarrow read must raise.

## .gguf — GGUF (GGML Universal File Format) (slug: gguf)
- Spec Page: https://fileformat.co/ext/gguf
- Samples Page: https://fileformat.co/samples/gguf
- JSON API: https://fileformat.co/api/v1/ext/gguf.json
- MIME Types: application/octet-stream
- Endianness: little
- Summary: Self-contained binary model weight format for llama.cpp and local LLM inference engines, storing architecture KV metadata, BPE vocabulary, and quantized tensor blocks in a single mmap-ready file.
- Magic Bytes:
  - offset 0x0: `47 47 55 46` (GGUF) — GGUF 4-byte ASCII magic signature
- Header Layout:
  - 0x00 - 0x03 (4 B, char[4]) `magic`: Fixed ASCII magic 'GGUF' (0x46554747 LE)
  - 0x04 - 0x07 (4 B, uint32_le) `version`: Format version (v2 or v3 in production)
  - 0x08 - 0x0F (8 B, uint64_le) `tensor_count`: Number of tensor descriptors following KV section
  - 0x10 - 0x17 (8 B, uint64_le) `metadata_kv_count`: Number of typed metadata key-value entries
- Security Advisory (Risk: low): Verify 0x00=='GGUF', version in {2,3}, and enforce sane upper bounds on uint64 string/array lengths to prevent integer-overflow OOM in C++ parsers.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/gguf/minimal-llama.gguf (1120 bytes, sha256: 2ec356e162053c781631412e0ef64fe4672618855458afc781eff05dbda10a5d, expectValid: true) — Compact GGUF v3 binary with Llama architecture KV metadata, 8-token vocabulary array, and 2 aligned tensors (F16 & Q8_0).
  - [realistic] https://fileformat.co/fixtures/v1/gguf/llama3-tiny.gguf (6368 bytes, sha256: 1e9c572f8666905c15ab3bd03689a613980af4547600b7eeccde39a387424044, expectValid: true) — Rich GGUF v3 model fixture with RoPE/GQA hyperparameters, multilingual/emoji tokenizer table, and F32/F16/Q8_0/Q4_K tensor descriptors.
  - [edge-case] https://fileformat.co/fixtures/v1/gguf/truncated-metadata.gguf (112 bytes, sha256: 81fec5725175f7820eaebf9d3ddcc53edb19595f60f24e73a29ef13731e032c9, expectValid: false) — Negative test fixture claiming 6 tensors and 14 KV entries but truncated at 112 bytes to verify parser bounds checking.

## .glb — glTF 2.0 Binary 3D Asset (slug: glb)
- Spec Page: https://fileformat.co/ext/glb
- Samples Page: https://fileformat.co/samples/glb
- JSON API: https://fileformat.co/api/v1/ext/glb.json
- MIME Types: model/gltf-binary
- Endianness: little
- Summary: Khronos Group's single-file binary 3D delivery format combining a 12-byte header, a UTF-8 JSON scene-graph chunk (`0x4E4F534A`), and a raw GPU geometry/texture buffer (`0x004E4942`).
- Magic Bytes:
  - offset 0x0: `67 6C 54 46 02 00 00 00` (glTF....) — 'glTF' ASCII magic + uint32_le version 2
- Header Layout:
  - 0x00 - 0x03 (4 B, char[4]) `magic`: ASCII 'glTF' (0x46546C67)
  - 0x04 - 0x07 (4 B, uint32_le) `version`: Container version (2)
  - 0x08 - 0x0B (4 B, uint32_le) `length`: Total byte length of GLB file
  - 0x0C - 0x13 (8 B, uint32_le[2]) `chunk0_hdr`: JSON chunk length + type 0x4E4F534A ('JSON')
- Security Advisory (Risk: low): Disallow external relative URI references inside glTF buffers/images when accepting untrusted .glb uploads on server-side renderers.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/glb/minimal-triangle.glb (316 bytes, sha256: f9316dd27503e6edb7ab6cd653e6c920cd996cdd186c9cf0e829407a68ee5d8b, expectValid: true) — 4-byte aligned binary glTF 2.0 (`67 6C 54 46`) with JSON scene graph chunk and 36-byte float32 vertex BIN chunk.
  - [realistic] https://fileformat.co/fixtures/v1/glb/pbr-scene-rig.glb (508 bytes, sha256: 6d0c78f35cee7254d016f06a0fcc812b412655abf063a8ce98aafb1fcbe7b7e9, expectValid: true) — glTF 2.0 binary asset with CameraRig, KeyLight, ChassisMesh nodes and PBR material definition.
  - [edge-case] https://fileformat.co/fixtures/v1/glb/truncated-bin-chunk.glb (300 bytes, sha256: 68a6984ac6eb610b64917f6a23ad957e2f5a6c692e2a2ccc0605d531d9302e65, expectValid: false) — GLB header `total_length` exceeds actual EOF by 16 bytes.

## .har — HTTP Archive v1.2 Capture (slug: har)
- Spec Page: https://fileformat.co/ext/har
- Samples Page: https://fileformat.co/samples/har
- JSON API: https://fileformat.co/api/v1/ext/har.json
- MIME Types: application/json
- Endianness: text
- Container Family: text
- Summary: UTF-8 JSON network session capture exported by Chrome/Firefox/Playwright containing full HTTP headers, cookies, request payloads, and timing waterfalls.
- Header Layout:
  - 0x00+ (var, utf8_json) `log_root`: JSON object with root `log.version` ('1.2') and `log.entries[]`
- Security Advisory (Risk: high): Never upload raw .har files to third-party cloud viewers. Strip Authorization, Cookie, Set-Cookie, X-API-Key, and query tokens locally (e.g. via /tools/har-sanitizer).
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/har/minimal.har (1642 bytes, sha256: be133a81b716a13a5d522aadc458e221ba61a151794f62ca0747f8457040a3ec, expectValid: true) — Sanitized single-entry HAR 1.2 JSON capture with timing metrics and zero sensitive headers.
  - [realistic] https://fileformat.co/fixtures/v1/har/api-trace.har (7212 bytes, sha256: cc221c9784a6a58ffc8b3a3a15659372cc8d7bfb1fe530b3ff5983a9f681c972, expectValid: true) — Multi-entry HAR 1.2 waterfall: session GET, inference POST with postData.params, job poll, metrics GET, cache DELETE — distinct bytes from minimal.har.
  - [edge-case] https://fileformat.co/fixtures/v1/har/edge-case-auth-leak.har (2170 bytes, sha256: d39ab47406fe2557509be31ef0eff1c5d38ad506abcfa2043c3bca836931c290, expectValid: true) — Designed to test HAR credential scrubbers: inert BENIGN_CANARY tokens in headers, cookies, query params AND the JSON response body (access_token/refresh_token).

## .heic — HEIC (High Efficiency Image Container) (slug: heic)
- Spec Page: https://fileformat.co/ext/heic
- Samples Page: https://fileformat.co/samples/heic
- JSON API: https://fileformat.co/api/v1/ext/heic.json
- MIME Types: image/heic, image/heif
- Endianness: big
- Container Family: isobmff
- Summary: Apple iOS default camera photo container encapsulating HEVC (H.265) intra-coded image tiles, depth maps, and EXIF metadata inside an ISO Base Media (`ftyp`) box hierarchy.
- Magic Bytes:
  - offset 0x4: `66 74 79 70 68 65 69 63` (ftypheic) — ISOBMFF ftyp box with major_brand 'heic' at offset 0x04
  - offset 0x4: `66 74 79 70 6D 69 66 31` (ftypmif1) — Common real-world variant: major_brand 'mif1' (most iPhone photos) with 'heic' in compatible_brands
  - offset 0x4: `66 74 79 70 68 65 69 78` (ftypheix) — Variant: major_brand 'heix' (HEIC sequences without image items)
- Header Layout:
  - 0x00 - 0x03 (4 B, uint32_be) `ftyp_size`: Byte length of FileTypeBox
  - 0x04 - 0x07 (4 B, char[4]) `box_type`: ASCII 'ftyp'
  - 0x08 - 0x0B (4 B, char[4]) `major_brand`: Primary brand ('heic', 'heix', 'mif1')
  - 0x10 .. (4*k B, char[4][]) `compatible_brands`: List of compatible 4CC brands
- Security Advisory (Risk: low): Check both major_brand AND compatible_brands inside ftyp (many valid HEIC photos use major_brand='mif1' with 'heic' in compatible_brands). Strip EXIF GPS boxes before public CDN storage.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/heic/minimal-64x64.heic (1192 bytes, sha256: a391bd763c27113162242a0e7fbe0bacbe60be3c2e1458b1f0c65d9396b4554c, expectValid: true) — Real HEIC encoded by libheif via pillow-heif: ftyp heic, decodable HEVC primary item.
  - [realistic] https://fileformat.co/fixtures/v1/heic/photo-1024x768.heic (183476 bytes, sha256: 833313fb74d55f1505032f5cb002d32d727eeae891a646e52311910875cc15c6, expectValid: true) — Real HEIF/HEVC still image encoded by libheif at 1024×768 for decoder validation.
  - [edge-case] https://fileformat.co/fixtures/v1/heic/truncated-mdat.heic (1160 bytes, sha256: f5de0f071b251c113f04832efea09a58ec1fc9908ac083c2f1da96bd7ab46eb8, expectValid: false) — Real HEIC bytes truncated inside the HEVC payload — libheif decoder must raise.

## .ipa — Apple iOS App Store Package (slug: ipa)
- Spec Page: https://fileformat.co/ext/ipa
- Samples Page: https://fileformat.co/samples/ipa
- JSON API: https://fileformat.co/api/v1/ext/ipa.json
- MIME Types: application/octet-stream, application/x-ios-app
- Endianness: little
- Container Family: zip
- Summary: ZIP-compressed iOS/iPadOS application distribution archive structured around `Payload/<AppName>.app/Info.plist` (`bplist00`) and Mach-O ARM64 binaries.
- Magic Bytes:
  - offset 0x0: `50 4B 03 04` (PK..) — PKZIP archive containing Payload/*.app/Info.plist
- Header Layout:
  - 0x00 - 0x03 (4 B, uint32_le) `zip_magic`: PKZIP Local File Header
  - 0x1E+ (var, utf8) `payload_entry`: 'Payload/<App>.app/...' bundle path
- Security Advisory (Risk: medium): Guard mobile CI extractors against Zip Slip (`../`) and symlink escapes inside Payload/ before running codesign or plist parsers.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/ipa/minimal-app.ipa (694 bytes, sha256: 85778c5134a0d4c6235923fcfd82c823b35e2e9577a5fd61f7c8b5226000d479, expectValid: true) — UNSIGNED container-structure fixture: real ZIP with Payload/DemoApp.app/Info.plist (binary plist via plistlib) and a Mach-O arm64 header stub. NOT a signed installable app.
  - [realistic] https://fileformat.co/fixtures/v1/ipa/observatory-ios-bundle.ipa (777 bytes, sha256: 53e13f6ea9bf56efe9c454706fa93e38d45bd77fa86d033b9cba843202a66348, expectValid: true) — UNSIGNED container-structure fixture: binary-plist Info.plist + PkgInfo + Mach-O stub for mobile CI artifact scanner tests. NOT a signed installable app.
  - [edge-case] https://fileformat.co/fixtures/v1/ipa/truncated-eocd.ipa (678 bytes, sha256: c4abf5147786a39819f7c469079e22f72bfa617f2d9a7d10641c99c41a7c0717, expectValid: false) — Interrupted-upload fixture: ZIP container missing the EOCD record — zipfile must raise.

## .jpg — JPEG / JFIF / EXIF Image (slug: jpg)
- Spec Page: https://fileformat.co/ext/jpg
- Samples Page: https://fileformat.co/samples/jpg
- JSON API: https://fileformat.co/api/v1/ext/jpg.json
- MIME Types: image/jpeg
- Endianness: mixed
- Summary: Marker-segmented DCT lossy image format (`FF D8 FF ... FF D9`), where embedded APP1 EXIF TIFF headers carry camera rotation flags (`Orientation=6`) and GPS coordinates.
- Magic Bytes:
  - offset 0x0: `FF D8 FF` — JPEG SOI marker (FF D8) followed by first marker prefix 0xFF
- Header Layout:
  - 0x00 - 0x01 (2 B, uint16_be) `soi_marker`: 0xFFD8 Start of Image
  - 0x02 - 0x03 (2 B, uint16_be) `app_marker`: 0xFFE0 (JFIF) or 0xFFE1 (EXIF)
  - 0x04 - 0x05 (2 B, uint16_be) `segment_len`: Marker segment byte length (includes these 2 bytes)
- Security Advisory (Risk: low): Auto-orient pixels according to EXIF Orientation (0x0112) before stripping APP1 EXIF/GPS metadata on user photo uploads.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/jpg/minimal-8x8-jfif.jpg (644 bytes, sha256: 72ad937c3cc136955b18dfa3209c4a86e6a6c739eab2e9d1d05fb3b75c051d62, expectValid: true) — Real baseline JPEG encoded by Pillow: FF D8 SOI, JFIF APP0, Huffman-compressed 8×8 RGB pixels, FF D9 EOI.
  - [realistic] https://fileformat.co/fixtures/v1/jpg/photo-1080p-exif.jpg (523936 bytes, sha256: 0810b6422b4ef7f11b623036c6870f20cb7e75fadbdcc05f12b7c13b35825ba6, expectValid: true) — Real Pillow-encoded 1080p JPEG carrying an APP1 Exif TIFF directory with Orientation=1.
  - [edge-case] https://fileformat.co/fixtures/v1/jpg/exif-orientation-6-null-island-gps.jpg (551116 bytes, sha256: 9e84120c7d4e36e75154329a088f3226aaca6e96aa28a43fcff7b4cfd421ebaf, expectValid: true) — Fully decodable JPEG whose EXIF IFD declares Orientation=6 and a GPSInfo IFD at Null Island — tests pipelines that strip tags without rotating pixels.

## .jsonl — JSON Lines / Newline-Delimited JSON (slug: jsonl)
- Spec Page: https://fileformat.co/ext/jsonl
- Samples Page: https://fileformat.co/samples/jsonl
- JSON API: https://fileformat.co/api/v1/ext/jsonl.json
- MIME Types: application/jsonl, application/x-ndjson
- Endianness: text
- Container Family: text
- Summary: Streaming line-oriented text format where every newline-separated record is a standalone UTF-8 JSON value—standard for LLM fine-tuning (SFT/DPO) datasets and batch APIs.
- Header Layout:
  - Line 1 (var, utf8_json) `record_0`: First standalone JSON object terminated by LF (0x0A)
- Security Advisory (Risk: low): Enforce max single-line byte length (e.g. 16 MB) before buffering newline splits to prevent memory exhaustion from newline-free gigabyte files.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/jsonl/minimal-sft.jsonl (308 bytes, sha256: 85b7b589f6426c997e2e17ca60dc35cf0285c8408f1141b39ef574a13de69918, expectValid: true) — 3-line UTF-8 JSON Lines fine-tuning dataset with LF delimiters.
  - [realistic] https://fileformat.co/fixtures/v1/jsonl/multilingual-rag-chunks.jsonl (2575 bytes, sha256: 20fb244b631707aecb497b1c320f5fde5504679044c7e799326c686bcac6d0a5, expectValid: true) — 10-line JSONL stream featuring CJK/Japanese text, ZWJ emoji sequences, nested arrays, and nullable fields.
  - [edge-case] https://fileformat.co/fixtures/v1/jsonl/bom-bigint-malformed.jsonl (210 bytes, sha256: 7b279351978bf216b68fca66051d03953d625b0555450c3f8c59051e0b8f0568, expectValid: false) — Starts with EF BB BF BOM, contains 9007199254740993 (> JS Number.MAX_SAFE_INTEGER), and ends with a truncated JSON record.

## .npy — NumPy Array Binary Format (slug: npy)
- Spec Page: https://fileformat.co/ext/npy
- Samples Page: https://fileformat.co/samples/npy
- JSON API: https://fileformat.co/api/v1/ext/npy.json
- MIME Types: application/x-npy, application/octet-stream
- Endianness: little
- Summary: Simple, mmap-friendly binary representation of a single homogeneous dense tensor with an explicit ASCII header dictionary describing dtype, byte order, and shape.
- Magic Bytes:
  - offset 0x0: `93 4E 55 4D 50 59` (.NUMPY) — 6-byte NumPy binary magic (0x93 prevents text-mode mangling)
- Header Layout:
  - 0x00 - 0x05 (6 B, uint8[6]) `magic`: 0x93 followed by ASCII 'NUMPY'
  - 0x06 - 0x07 (2 B, uint8[2]) `version`: Major and minor format version (e.g. 1.0)
  - 0x08 - 0x09 (2 B, uint16_le) `header_len`: Byte length of padded ASCII descriptor dict
  - 0x0A+ (header_len, ascii) `header_dict`: Literal dict: descr, fortran_order, shape
- Security Advisory (Risk: low): Reject files whose header_dict declares dtype '|O' (Python object array), which invokes pickle.load(). Parse header_dict with a strict regex/AST rather than eval().
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/npy/minimal-f32-4x8.npy (256 bytes, sha256: fd4257fe798868b27cf704172e1220473164dad2866b833f7e8fd58060fad063, expectValid: true) — Real np.save output: '<f4' descriptor, C-contiguous order, 32 IEEE-754 float32 elements.
  - [realistic] https://fileformat.co/fixtures/v1/npy/embeddings-f64-8x16.npy (1152 bytes, sha256: d4d9449ca4484124d49b8a4d6aab51baf502d3a7b15f26441a38acb20ec4f81f, expectValid: true) — Double-precision '<f8' dense embedding matrix written by np.save.
  - [edge-case] https://fileformat.co/fixtures/v1/npy/fortran-nan-truncated.npy (152 bytes, sha256: 2fcb431d32fa5281d8f1e465105e015b209fcb619761b0407fa19adaaa4b35db, expectValid: false) — Real np.save Fortran-order header declaring (32, 32) f4 with payload truncated after 6 floats — np.load must raise.

## .npz — NumPy Zipped Array Archive (slug: npz)
- Spec Page: https://fileformat.co/ext/npz
- Samples Page: https://fileformat.co/samples/npz
- JSON API: https://fileformat.co/api/v1/ext/npz.json
- MIME Types: application/x-npz, application/zip
- Endianness: little
- Container Family: zip
- Summary: ZIP container bundling multiple named NumPy `.npy` tensor arrays, widely used for embeddings, calibration datasets, and JAX/MLX checkpoints.
- Magic Bytes:
  - offset 0x0: `50 4B 03 04` (PK..) — PKZIP Local File Header containing .npy member streams
- Header Layout:
  - 0x00 - 0x03 (4 B, uint32_le) `zip_lfh_sig`: PKZIP signature 0x04034B50
  - 0x08 - 0x09 (2 B, uint16_le) `compression`: 0 = Store (np.savez), 8 = Deflate (np.savez_compressed)
  - 0x1E+ (var, utf8) `member_name`: First array entry name ending in .npy
- Security Advisory (Risk: medium): Always load with np.load(file, allow_pickle=False) and enforce decompression byte quotas on Deflate-compressed .npz uploads.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/npz/minimal-weights.npz (668 bytes, sha256: 5df985f2575c4c4a1f58f21970bd74830b277688976534283c269be2ccfb2637, expectValid: true) — Real np.savez output containing weights.npy (4x8 float32) and bias.npy (8 float32).
  - [realistic] https://fileformat.co/fixtures/v1/npz/checkpoint-deflated.npz (1151 bytes, sha256: 1da30aadf475322bd6b9df64d90d6fda4f4e600251c6c542bcca7c2a0d8a39ca, expectValid: true) — Real np.savez_compressed bundle with float32, float64, and int32 arrays.
  - [edge-case] https://fileformat.co/fixtures/v1/npz/truncated-eocd.npz (654 bytes, sha256: 3d8d77b9c97b839f497301ec2cbfb8fd34e7c19ae6e0f7ddee51c864c7eb05f5, expectValid: false) — Valid PK local headers but missing complete EOCD — np.load on the archive must raise.

## .parquet — Apache Parquet Columnar Storage (slug: parquet)
- Spec Page: https://fileformat.co/ext/parquet
- Samples Page: https://fileformat.co/samples/parquet
- JSON API: https://fileformat.co/api/v1/ext/parquet.json
- MIME Types: application/vnd.apache.parquet, application/octet-stream
- Endianness: little
- Summary: De-facto standard hybrid columnar storage format for modern data lakes (Iceberg, Delta, DuckDB, Spark), placing Thrift Compact Protocol schema and statistics in the file trailer.
- Magic Bytes:
  - offset 0x0: `50 41 52 31` (PAR1) — Leading 4-byte Apache Parquet magic (mirrored at EOF-4)
- Header Layout:
  - 0x00 - 0x03 (4 B, char[4]) `header_magic`: ASCII 'PAR1' (or 'PARE' for encrypted footer)
  - 0x04 .. EOF-8-L (var, chunks) `row_groups`: Compressed column chunks & data/dictionary pages
  - EOF-8-L .. EOF-8 (L B, thrift_compact) `file_metadata`: Thrift Compact encoded FileMetaData (schema, stats, codecs)
  - EOF-8 .. EOF-5 (4 B, uint32_le) `footer_length`: Byte length L of FileMetaData
  - EOF-4 .. EOF-1 (4 B, char[4]) `footer_magic`: Trailing ASCII 'PAR1' confirming uncorrupted write
- Security Advisory (Risk: low): Always check BOTH head[0:4] == 'PAR1' and tail[-4:] == 'PAR1' to reject interrupted multipart S3 uploads before enqueueing ETL jobs.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/parquet/minimal-snappy.parquet (1131 bytes, sha256: 8b84a4eb04fdad847b748c47f6132f1a61f5b1de219178e86fea93aca5ac90f5, expectValid: true) — Real Parquet file written by pyarrow with Snappy compression: 3 rows × user_id INT64, latency_ms DOUBLE, service UTF8.
  - [realistic] https://fileformat.co/fixtures/v1/parquet/events-zstd-decimal.parquet (3158 bytes, sha256: 1b9a434953963317ee622358bccb62cce53d74422b0b8331f063f237ff8b123b, expectValid: true) — pyarrow-written 250-row Parquet with ZSTD codec, DECIMAL(12,2) and TIMESTAMP_MICROS logical types.
  - [edge-case] https://fileformat.co/fixtures/v1/parquet/truncated-footer.parquet (1121 bytes, sha256: 042078532f4fd53caf059416a0dd17b81c8620cf769ad5c88dafc7a1d8f30491, expectValid: false) — Real Parquet bytes truncated before the footer length and trailing PAR1 magic — pyarrow must raise.

## .pcap — libpcap Network Packet Capture (slug: pcap)
- Spec Page: https://fileformat.co/ext/pcap
- Samples Page: https://fileformat.co/samples/pcap
- JSON API: https://fileformat.co/api/v1/ext/pcap.json
- MIME Types: application/vnd.tcpdump.pcap, application/x-pcap
- Endianness: mixed
- Summary: Classic 24-byte header packet capture format produced by `tcpdump` and Wireshark, encoding host endianness and timestamp precision directly in its 4-byte magic number.
- Magic Bytes:
  - offset 0x0: `D4 C3 B2 A1` — Little-endian microsecond libpcap magic (0xA1B2C3D4)
  - offset 0x0: `A1 B2 C3 D4` — Big-endian microsecond libpcap variant (legacy tcpdump on BE hosts)
  - offset 0x0: `4D 3C B2 A1` — Little-endian nanosecond-resolution variant (0xA1B23C4D)
  - offset 0x0: `A1 B2 3C 4D` — Big-endian nanosecond-resolution variant
- Header Layout:
  - 0x00 - 0x03 (4 B, uint32) `magic_number`: 0xA1B2C3D4 (µs) or 0xA1B23C4D (ns) determines endianness
  - 0x04 - 0x07 (4 B, uint16[2]) `version`: Major.Minor version (2.4)
  - 0x10 - 0x13 (4 B, uint32) `snaplen`: Max captured bytes per packet (e.g. 65535)
  - 0x14 - 0x17 (4 B, uint32) `network`: Link-layer header type (1 = Ethernet)
- Security Advisory (Risk: medium): PCAP captures may contain cleartext HTTP/DNS/DB credentials or internal IP topologies; enforce `incl_len <= snaplen` when parsing untrusted packet records.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/pcap/minimal-ethernet.pcap (82 bytes, sha256: 8e6bf3f1ae8790e789ba3972cec94620b890fed7d3f6b9212467fcd5cedf3e48, expectValid: true) — 24-byte little-endian microsecond PCAP v2.4 header (`D4 C3 B2 A1`) plus one 42-byte Ethernet frame.
  - [realistic] https://fileformat.co/fixtures/v1/pcap/three-frames-capture.pcap (198 bytes, sha256: 289189333aa50832b63f984ebcbd5f8d9a71316a5e9864e07781e193478711c8, expectValid: true) — Three sequential packet records with incrementing microsecond timestamps.
  - [edge-case] https://fileformat.co/fixtures/v1/pcap/snaplen-truncated-packet.pcap (72 bytes, sha256: a5ce5c7570b15f92fc0a3896b4254af5f94891bd5a7528c7847319864b0175d0, expectValid: false) — Packet record `incl_len` exceeds remaining bytes at EOF—tests packet parser bounds checks.

## .pdf — Portable Document Format (ISO 32000) (slug: pdf)
- Spec Page: https://fileformat.co/ext/pdf
- Samples Page: https://fileformat.co/samples/pdf
- JSON API: https://fileformat.co/api/v1/ext/pdf.json
- MIME Types: application/pdf
- Endianness: text
- Summary: Object-graph document format parsed bottom-up from its trailing `startxref` and `%%EOF` markers—primary battleground for AI RAG table extraction and active `/JavaScript` upload sanitization.
- Magic Bytes:
  - offset 0x0: `25 50 44 46 2D` (%PDF-) — 5-byte '%PDF-' header followed by version (e.g. 1.7 or 2.0)
- Header Layout:
  - 0x00 - 0x07 (8 B, ascii) `pdf_version`: '%PDF-1.7' version header
  - 0x09 - 0x0E (6 B, uint8[6]) `binary_comment`: High-bit comment (%\xE2\xE3\xCF\xD3) signaling binary content
  - EOF-64.. (var, ascii) `xref_trailer`: Cross-reference table, startxref byte offset & %%EOF
- Security Advisory (Risk: high): Require '%PDF-' strictly at offset 0x00 (blocking polyglots), verify trailing '%%EOF', and reject or flatten `/JavaScript`, `/JS`, `/Launch`, and `/EmbeddedFiles` actions.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/pdf/minimal-1page.pdf (1376 bytes, sha256: 3d510c3e24ce7b489b9861769c0643c75e13c5364754a752186baaf68546a0d7, expectValid: true) — Real single-page PDF generated by reportlab and parseable by pypdf.
  - [realistic] https://fileformat.co/fixtures/v1/pdf/rag-two-column-financial-table.pdf (2945 bytes, sha256: d547e41d47d805961980567b9776216f65f3744ea2906789dfa6bb629c40569a, expectValid: true) — Real 2-page reportlab PDF with financial Table cells, heading hierarchy and rule lines for RAG extractor benchmarking.
  - [edge-case] https://fileformat.co/fixtures/v1/pdf/benign-js-dictionary-canary.pdf (1091 bytes, sha256: dc38f4be9c4ba992b60254dab44878c1c111e7d7bd06169e6a3836a48850cfc3, expectValid: true) — Real reportlab PDF with an inert /JavaScript name tree added via pypdf (FILEFORMAT_CO_BENIGN_TEST_MARKER) for security scanner verification.

## .png — Portable Network Graphics (PNG) (slug: png)
- Spec Page: https://fileformat.co/ext/png
- Samples Page: https://fileformat.co/samples/png
- JSON API: https://fileformat.co/api/v1/ext/png.json
- MIME Types: image/png
- Endianness: big
- Summary: Lossless CRC-checked chunked raster image format, heavily used in AI workflows (ComfyUI / Stable Diffusion) to store generation graphs and prompts inside `tEXt`/`iTXt` chunks.
- Magic Bytes:
  - offset 0x0: `89 50 4E 47 0D 0A 1A 0A` (.PNG....) — 8-byte PNG transport-integrity signature
- Header Layout:
  - 0x00 - 0x07 (8 B, uint8[8]) `png_sig`: 89 50 4E 47 0D 0A 1A 0A
  - 0x08 - 0x0F (8 B, u32_be+char[4]) `ihdr_hdr`: Length (13) + 'IHDR' chunk type
  - 0x10 - 0x17 (8 B, uint32_be[2]) `dimensions`: Width and Height in pixels
  - 0x18 - 0x1C (5 B, uint8[5]) `pixel_fmt`: Bit depth, color type, compression, filter, interlace
- Security Advisory (Risk: low): Check width * height <= max_pixels from bytes 0x10..0x17 BEFORE zlib decompression, and strip ancillary tEXt/iTXt/eXIf chunks to prevent metadata leaks (and Acropalypse-style trailing byte leaks after IEND).
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/png/minimal-2x2-rgba.png (83 bytes, sha256: 275f56b84188ce563dfa9364ba7d2b3dfec7beb5d62de11bddcafb0390e85752, expectValid: true) — Real 8-bit RGBA PNG encoded by Pillow with valid CRC32 checksums on every chunk.
  - [realistic] https://fileformat.co/fixtures/v1/png/ai-prompt-metadata.png (305 bytes, sha256: 1c159eb8d483c4379933d83bac5ba8581b50e5651f9877c059e999cc102840de, expectValid: true) — 16×16 RGBA PNG from Pillow containing AI generation prompt metadata inside a standard tEXt chunk.
  - [edge-case] https://fileformat.co/fixtures/v1/png/truncated-idat.png (47 bytes, sha256: ac4cc6aeb4c37baeee650f26c1651411aaade073ecee5db776d40defcac6e53a, expectValid: false) — Real Pillow PNG truncated inside the compressed IDAT payload — decode must fail (missing IEND alone would still decode).

## .pt — PyTorch Model & Tensor Checkpoint (slug: pt)
- Spec Page: https://fileformat.co/ext/pt
- Samples Page: https://fileformat.co/samples/pt
- JSON API: https://fileformat.co/api/v1/ext/pt.json
- MIME Types: application/x-pytorch, application/zip
- Endianness: little
- Container Family: zip
- Summary: Default PyTorch `torch.save()` archive wrapping a Python Pickle instruction stream (`data.pkl`) alongside raw tensor storage files inside a ZIP container.
- Magic Bytes:
  - offset 0x0: `50 4B 03 04` (PK..) — PyTorch ZIP archive header (disambiguated via archive/data.pkl)
- Header Layout:
  - 0x00 - 0x03 (4 B, uint32_le) `zip_magic`: PKZIP local header 0x04034B50
  - 0x1E+ (var, ascii) `entry_path`: Archive entry (e.g. archive/version or archive/data.pkl)
- Security Advisory (Risk: high): CRITICAL: Never call legacy torch.load() without weights_only=True on untrusted .pt/.pth uploads—Pickle GLOBAL/REDUCE opcodes enable instant RCE. Prefer SafeTensors.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/pt/minimal-checkpoint.pt (1829 bytes, sha256: 64f990b860de211afe49a1c8c9627cf4da92d75f69a29a2cb85c06927c62720c, expectValid: true) — Real torch.save state dict (2 tensors) — loads cleanly via torch.load(weights_only=True).
  - [realistic] https://fileformat.co/fixtures/v1/pt/transformer-state-dict.pt (2657 bytes, sha256: b927171a147cb843af3458e867b7972bca05a77969fd0d47f01f62fd32ef3c27, expectValid: true) — Real torch.save transformer weight dict with q_proj/v_proj/down_proj tensors.
  - [edge-case] https://fileformat.co/fixtures/v1/pt/benign-pickle-canary.pt (1641 bytes, sha256: 06de6e85a3acdeaf03bfb30aac49b6d7e697bf8d63d6c6f7882228a5bde0dff7, expectValid: true) — Real torch.save archive containing an inert FILEFORMAT_CO_BENIGN_TEST_MARKER string — still loads with weights_only=True.

## .safetensors — SafeTensors Zero-Copy Model Weights (slug: safetensors)
- Spec Page: https://fileformat.co/ext/safetensors
- Samples Page: https://fileformat.co/samples/safetensors
- JSON API: https://fileformat.co/api/v1/ext/safetensors.json
- MIME Types: application/octet-stream
- Endianness: little
- Summary: Hugging Face's memory-safe, zero-copy tensor serialization format designed to replace Pickle-based PyTorch checkpoints without arbitrary code execution risks.
- Magic Bytes:
  - offset 0x8: `7B 22` ({") — UTF-8 JSON header object opening immediately after uint64_le header_size
- Header Layout:
  - 0x00 - 0x07 (8 B, uint64_le) `header_size`: Byte length N of the UTF-8 JSON header
  - 0x08 - 8+N (N B (dynamic), utf8_json) `json_header`: Tensor dtype, shape, data_offsets & optional __metadata__
- Security Advisory (Risk: low): Cap header_size N (e.g. <= 100 MB) before allocating buffer, parse UTF-8 JSON without duplicate keys, and verify every tensor's [begin, end] offset is non-overlapping and <= file_size - 8 - N.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/safetensors/minimal-bf16.safetensors (432 bytes, sha256: 0d9894b505b77ec0d719fa112eead1695c8a2be9e1820c81267dfe1a64a2214b, expectValid: true) — Real safetensors.torch output with __metadata__ and 3 tensors across BF16, F16, and F32 dtypes.
  - [realistic] https://fileformat.co/fixtures/v1/safetensors/weights-bf16.safetensors (3560 bytes, sha256: 7594cbd039f2978e74012d1e761368a7d18f2f6efe6038e11a869f6d1c5a6b7f, expectValid: true) — Multi-layer transformer weight shard written by safetensors.torch with exact contiguous data_offsets.
  - [edge-case] https://fileformat.co/fixtures/v1/safetensors/unaligned-truncated.safetensors (138 bytes, sha256: 70d504e4e3dc7cc38bf0d72fe83b78badaf96f16be32402100c1450a9bb2e004, expectValid: false) — Negative fixture with non-zero starting data_offsets [3, 8195] and truncated 24-byte body — safetensors must raise.

## .sqlite — SQLite 3 Database File (slug: sqlite)
- Spec Page: https://fileformat.co/ext/sqlite
- Samples Page: https://fileformat.co/samples/sqlite
- JSON API: https://fileformat.co/api/v1/ext/sqlite.json
- MIME Types: application/vnd.sqlite3, application/x-sqlite3
- Endianness: big
- Container Family: sqlite
- Summary: Ubiquitous single-file ACID relational B-tree database with a big-endian 100-byte header at offset 0x00 and full SQL DDL catalog stored in Root Page 1 (`sqlite_schema`).
- Magic Bytes:
  - offset 0x0: `53 51 4C 69 74 65 20 66 6F 72 6D 61 74 20 33 00` (SQLite format 3.) — 16-byte null-terminated SQLite 3 header string
- Header Layout:
  - 0x00 - 0x0F (16 B, char[16]) `header_string`: 'SQLite format 3\0'
  - 0x10 - 0x11 (2 B, uint16_be) `page_size`: Database page size in bytes (1 means 65536)
  - 0x12 - 0x13 (2 B, uint8[2]) `journal_versions`: 1=Rollback journal, 2=WAL mode
  - 0x1C - 0x1F (4 B, uint32_be) `page_count`: Total pages in database file
  - 0x38 - 0x3B (4 B, uint32_be) `text_encoding`: 1=UTF-8, 2=UTF-16le, 3=UTF-16be
- Security Advisory (Risk: medium): Disable load_extension() and defensive=ON when opening untrusted SQLite files; corrupted shadow tables (FTS3/RTREE) have historically triggered memory corruption in older libsqlite3 builds.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/sqlite/minimal-users.sqlite (12288 bytes, sha256: dee45e02f67ee69f23295ad0de07601253ad41c8da4dfb9cb173e5ebb3b71e50, expectValid: true) — Valid 4096-byte single-page SQLite 3 database with a `users` table and two UTF-8 rows.
  - [realistic] https://fileformat.co/fixtures/v1/sqlite/app-telemetry-schema.sqlite (188416 bytes, sha256: 0ea395a85610cdf41278eff1b123008b580dfd0d5732e96eb419eab56e8e4bc1, expectValid: true) — SQLite 3 database whose sqlite_schema B-tree spans interior (0x05) pages across 42 tables plus a ~6KB CHECK-constraint DDL stored on an overflow-page chain.
  - [edge-case] https://fileformat.co/fixtures/v1/sqlite/truncated-half-page.sqlite (2048 bytes, sha256: 3f7627faa065ed6cd65c4fcccd2cbb8493f9d7330fadd9a68b4ca6fccb0e041c, expectValid: false) — Valid 100-byte SQLite header whose first B-tree page is truncated mid-page.

## .usdz — USDZ Spatial 3D Archive (Pixar / Apple VisionOS) (slug: usdz)
- Spec Page: https://fileformat.co/ext/usdz
- Samples Page: https://fileformat.co/samples/usdz
- JSON API: https://fileformat.co/api/v1/ext/usdz.json
- MIME Types: model/vnd.usdz+zip
- Endianness: little
- Container Family: zip
- Summary: Zero-compression, 64-byte mmap-aligned PKZIP package created by Pixar & Apple for AR QuickLook and VisionOS spatial scenes, beginning with a root `.usdc` (`PXR-USDC`) or `.usda` stage.
- Magic Bytes:
  - offset 0x0: `50 4B 03 04` (PK..) — Uncompressed 64-byte aligned ZIP containing PXR-USDC layer at offset 0x40
- Header Layout:
  - 0x00 - 0x1D (30 B, zip_lfh) `local_header`: ZIP header with compression_method == 0 (Store)
  - 0x1E - 0x3F (var, name+pad) `alignment_pad`: Filename + extra field padding to 64-byte boundary
  - 0x40 - 0x47 (8 B, char[8]) `usdc_magic`: 'PXR-USDC' Crate binary stage header
- Security Advisory (Risk: low): Verify method==0 (uncompressed), data_offset % 64 == 0 for every entry, and first entry extension in {.usdc, .usda, .usd}.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/usdz/minimal-64b-aligned.usdz (206 bytes, sha256: 84ed4c279742f4c9aa8557034806427c40d29fb91d3415def454b5371035f3bf, expectValid: true) — Apple VisionOS / QuickLook compliant uncompressed ZIP with 64-byte mmap alignment and `PXR-USDC` Crate root layer.
  - [realistic] https://fileformat.co/fixtures/v1/usdz/spatial-stage-textured.usdz (483 bytes, sha256: 30477e3f8aaf315b7f84c5950a266a44d86d615dd8ad087d49825eb2b6a35f1e, expectValid: true) — 64-byte aligned USDZ archive bundling both a `PXR-USDC` binary stage and an uncompressed RGBA PNG texture.
  - [edge-case] https://fileformat.co/fixtures/v1/usdz/unaligned-violation.usdz (182 bytes, sha256: 1b5d09db530a3b47b91227c552a243fc0a0debb7e2e757ad2d6988a07e86cdae, expectValid: false) — Valid ZIP containing `scene.usdc`, but entry data starts at non-64B-aligned offset—catches subtle USDZ packager bugs.

## .wasm — WebAssembly Binary Module (slug: wasm)
- Spec Page: https://fileformat.co/ext/wasm
- Samples Page: https://fileformat.co/samples/wasm
- JSON API: https://fileformat.co/api/v1/ext/wasm.json
- MIME Types: application/wasm
- Endianness: little
- Summary: Portable, sandboxed stack-machine binary bytecode format (`\0asm` v1) structured as a sequence of LEB128-framed Type, Import, Function, Memory, Export, and Code sections.
- Magic Bytes:
  - offset 0x0: `00 61 73 6D 01 00 00 00` (.asm....) — '\0asm' magic + uint32_le binary version 1
- Header Layout:
  - 0x00 - 0x03 (4 B, uint8[4]) `magic`: 0x00 0x61 0x73 0x6D ('\0asm')
  - 0x04 - 0x07 (4 B, uint32_le) `version`: Binary format version (1)
  - 0x08+ (var, u8+leb128) `sections`: Section ID (0..12) + LEB128 byte length + payload
- Security Advisory (Risk: medium): Audit the Import section (id=2) before instantiating untrusted .wasm plugins to verify they only bind approved WASI/host capabilities, and enforce fuel/epoch CPU limits.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/wasm/minimal-add.wasm (41 bytes, sha256: f61fd62f57c41269c3c23f360eeaf1090b1db9c38651106674d48bc65dba88ba, expectValid: true) — 41-byte valid WASM v1 binary exporting `add(i32, i32) -> i32`, directly instantiable via `WebAssembly.instantiate()`.
  - [realistic] https://fileformat.co/fixtures/v1/wasm/env-import-memory.wasm (80 bytes, sha256: f6462abef751b355d056c266a6e5d376afb018bd445477af9d9df333fa0f4f47, expectValid: true) — Contains Type, Import, Function, Memory, Export, and Code sections for symbol scanner tests.
  - [edge-case] https://fileformat.co/fixtures/v1/wasm/truncated-code-section.wasm (75 bytes, sha256: a43778279d60ece37b28759e01fc505e73e18e6274db914e148bd8bfdd8b295d, expectValid: false) — WASM binary whose Code section LEB128 byte length exceeds remaining file bytes.

## .webp — WebP Image Container (slug: webp)
- Spec Page: https://fileformat.co/ext/webp
- Samples Page: https://fileformat.co/samples/webp
- JSON API: https://fileformat.co/api/v1/ext/webp.json
- MIME Types: image/webp
- Endianness: little
- Container Family: riff
- Summary: RIFF-based modern raster image container supporting lossy (`VP8 `), lossless (`VP8L`), and extended alpha/animated/EXIF (`VP8X`) bitstreams.
- Magic Bytes:
  - offset 0x0: `52 49 46 46 ?? ?? ?? ?? 57 45 42 50` (RIFF....WEBP) — 'RIFF' + 4-byte LE chunk size + 'WEBP' FourCC
- Header Layout:
  - 0x00 - 0x03 (4 B, char[4]) `riff_magic`: ASCII 'RIFF'
  - 0x04 - 0x07 (4 B, uint32_le) `riff_size`: File size minus 8 bytes
  - 0x08 - 0x0B (4 B, char[4]) `webp_fourcc`: ASCII 'WEBP'
  - 0x0C - 0x0F (4 B, char[4]) `first_chunk`: 'VP8 ', 'VP8L', or 'VP8X'
- Security Advisory (Risk: low): Keep libwebp patched (>= 1.3.2, post CVE-2023-4863 Huffman heap overflow) and check both 0x00=='RIFF' and 0x08=='WEBP'.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/webp/minimal-vp8x.webp (58 bytes, sha256: 297ca327517d16217664fbb2ab4e878a676db57b3050a92b5ab929259266ffde, expectValid: true) — Real WebP encoded by libwebp via Pillow — RIFF/WEBP container with decodable VP8L/VP8 payload.
  - [realistic] https://fileformat.co/fixtures/v1/webp/og-banner-1200x630.webp (60664 bytes, sha256: 1cf094696041edb5cd955bf546811c69b1e8cdd5092cdfd765300849e2ceee2d, expectValid: true) — Real 1200×630 lossy WebP from Pillow at quality 85 for OpenGraph-dimension checks.
  - [edge-case] https://fileformat.co/fixtures/v1/webp/truncated-riff.webp (50 bytes, sha256: 6b6b3468c2e38c48255de9164388e169324215d8fe802e113b1b109f631deee3, expectValid: false) — WebP truncated inside the image payload — declared RIFF size exceeds available bytes, Pillow must raise.

## .xlsx — Office Open XML Workbook (Excel) (slug: xlsx)
- Spec Page: https://fileformat.co/ext/xlsx
- Samples Page: https://fileformat.co/samples/xlsx
- JSON API: https://fileformat.co/api/v1/ext/xlsx.json
- MIME Types: application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
- Endianness: little
- Container Family: zip
- Summary: ZIP-packaged XML spreadsheet container (`[Content_Types].xml` + `xl/workbook.xml`). Frequently misdiagnosed when backend export endpoints fail and save HTML/JSON error pages as `.xlsx`.
- Magic Bytes:
  - offset 0x0: `50 4B 03 04` (PK..) — PKZIP container verified via xl/workbook.xml entry
- Header Layout:
  - 0x00 - 0x03 (4 B, uint32_le) `zip_sig`: 0x04034B50 PKZIP Local File Header
  - 0x1E+ (var, utf8) `content_types`: Typically '[Content_Types].xml'
- Security Advisory (Risk: medium): Disable XML DTD / external entity resolution (XXE) in server-side XLSX parsers, enforce Zip Bomb decompression limits, and reject `xl/vbaProject.bin` macro blobs.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/xlsx/minimal-sheet.xlsx (4843 bytes, sha256: 872a54723dd14451428342c5f097a0c3c7d5097a7d7fb28a86905e0df685a9f7, expectValid: true) — Real single-cell workbook written by openpyxl with Content_Types, rels, workbook.xml and sheet1.xml.
  - [realistic] https://fileformat.co/fixtures/v1/xlsx/quarterly-revenue.xlsx (5037 bytes, sha256: d5ab69cbec81720b5a6399b0d77de88308017bad09e0b3919b15c0e4cf8afe3e, expectValid: true) — Real openpyxl workbook: 4 quarterly revenue rows with USD floats for tabular import tests.
  - [edge-case] https://fileformat.co/fixtures/v1/xlsx/spoofed-gateway-error.xlsx (203 bytes, sha256: 22cceb2a5564d2877e94960a59b434289c9f4aa0c56e346c0aa9ce8bf361cceb, expectValid: false) — Real-world debugging classic: filename ends .xlsx but bytes are an HTML gateway error page — openpyxl must raise.

## .duckdb — DuckDB Analytical Database File (slug: duckdb)
- Spec Page: https://fileformat.co/ext/duckdb
- Samples Page: https://fileformat.co/samples/duckdb
- JSON API: https://fileformat.co/api/v1/ext/duckdb.json
- MIME Types: application/vnd.duckdb, application/octet-stream
- Endianness: little
- Summary: Single-file vectorized OLAP database format storing compressed columnar row-groups in 4 KB / 256 KB block-managed pages.
- Magic Bytes:
  - offset 0x8: `44 55 43 4B` (DUCK) — 4-byte 'DUCK' magic at offset 0x08 after 8-byte checksum
- Header Layout:
  - 0x00 - 0x07 (8 B, uint64_le) `checksum`: 64-bit block checksum of main header
  - 0x08 - 0x0B (4 B, char[4]) `magic`: ASCII 'DUCK' identifier
  - 0x0C - 0x13 (8 B, uint64_le) `version`: DuckDB storage layout version (e.g. 64)
- Security Advisory (Risk: medium): Open untrusted .duckdb files with enable_external_access=false and lock_configuration=true so embedded views cannot invoke read_parquet('http://...') SSRF.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/duckdb/minimal-v64.duckdb (536576 bytes, sha256: 465f054e7e501c946c263070389322a8f1f96195ab9bb115a1e80d34401298f5, expectValid: true) — Real single-table DuckDB database produced by duckdb.connect() — includes valid checksum preamble and DUCK magic.
  - [realistic] https://fileformat.co/fixtures/v1/duckdb/analytics-store.duckdb (1585152 bytes, sha256: 92b98fd5e4954d171d464a36c6cfe175d15e12d09f8492382ed11458fdeb8278, expectValid: true) — Real DuckDB database with two tables, primary keys, and a secondary index.
  - [edge-case] https://fileformat.co/fixtures/v1/duckdb/truncated-header.duckdb (20 bytes, sha256: b9fb1ef9dc5827bddb7c61b93433aea5cdbcb75d63941f72704906f6ddeb45b8, expectValid: false) — First 20 bytes of a real DuckDB file — duckdb.connect() must raise 'not a valid DuckDB database file'.

## .onnx — ONNX (Open Neural Network Exchange) (slug: onnx)
- Spec Page: https://fileformat.co/ext/onnx
- Samples Page: https://fileformat.co/samples/onnx
- JSON API: https://fileformat.co/api/v1/ext/onnx.json
- MIME Types: application/onnx, application/octet-stream
- Endianness: little
- Summary: Cross-framework Protocol Buffers computation graph and weight format used by ONNX Runtime, TensorRT, and CoreML converters.
- Magic Bytes:
  - offset 0x0: `08` — Protobuf field #1 (ir_version) varint wire tag
- Header Layout:
  - 0x00 (1 B, uint8) `ir_version_tag`: Protobuf tag 0x08 (field 1, varint)
  - 0x01 (1-2 B, varint) `ir_version`: ONNX IR specification version
  - 0x02+ (var, protobuf) `producer_and_graph`: Producer name, opset_import, and GraphProto
- Security Advisory (Risk: medium): Audit external_data tensor file paths inside TensorProto to block arbitrary local file read (LFI / path traversal) when loading untrusted ONNX models.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/onnx/minimal-linear.onnx (319 bytes, sha256: aa4e82d69b4579c1a7bfbf12228776f121238825abb64a45e937d4e1299a33fb, expectValid: true) — Real ONNX ModelProto (ir_version=9, opset=21) verified by onnx.checker.check_model — MatMul + Relu.
  - [realistic] https://fileformat.co/fixtures/v1/onnx/mlp-classifier.onnx (702 bytes, sha256: bc52092748c786119aa203b36f61a706a5f40a426b9626ed0469552d9566ff4e, expectValid: true) — onnx.helper-built MLP with float32 TensorProto initializers, Gelu activation — passes onnx.checker.
  - [edge-case] https://fileformat.co/fixtures/v1/onnx/truncated-protobuf.onnx (56 bytes, sha256: d4db86720670b6fb423cba89dae6fd0d3dc7a92624f836148e6fc29a590b06f4, expectValid: false) — ModelProto wire frame truncated mid-GraphProto — ModelProto.ParseFromString must raise DecodeError.

## .orc — Apache ORC (Optimized Row Columnar) (slug: orc)
- Spec Page: https://fileformat.co/ext/orc
- Samples Page: https://fileformat.co/samples/orc
- JSON API: https://fileformat.co/api/v1/ext/orc.json
- MIME Types: application/vnd.apache.orc, application/octet-stream
- Endianness: little
- Summary: Stripe-based columnar storage format originating in the Hive/Trino/Presto ecosystem with Protobuf-encoded Footer and a 1-byte PostScript length at the very last byte of the file.
- Magic Bytes:
  - offset 0x0: `4F 52 43` (ORC) — 3-byte ASCII 'ORC' file header
- Header Layout:
  - 0x00 - 0x02 (3 B, char[3]) `magic`: ASCII 'ORC' header
  - 0x03 .. (var, stripes) `stripe_data`: Index, data, and stripe footer streams
  - EOF-1 (1 B, uint8) `postscript_len`: Byte length of uncompressed PostScript message
- Security Advisory (Risk: low): Check head[0:3] == 'ORC' and verify that the PostScript struct preceding EOF-1 ends with 'ORC'.
- QA Sample Fixtures:
  - [minimal] https://fileformat.co/fixtures/v1/orc/minimal-stripe.orc (344 bytes, sha256: 09713ef2158b8196359189b71dc332a3e57f8203547a2926a4bd3d0407f1ce0e, expectValid: true) — Real ORC file written by pyarrow.orc: ORC magic, single stripe, Footer + PostScript trailer.
  - [realistic] https://fileformat.co/fixtures/v1/orc/warehouse-stripe.orc (2915 bytes, sha256: 53afde4eadd2f23134d25a33b5b7418de973fc6996d3aeb39a20f2095b5e066c, expectValid: true) — 200-row ORC file from pyarrow.orc for Hive/Trino/Spark reader identification tests.
  - [edge-case] https://fileformat.co/fixtures/v1/orc/truncated-postscript.orc (339 bytes, sha256: 8dd70b083ac96f1241bf50e890d1e5126bbd49910ad9cb927a00111ba693a2da, expectValid: false) — ORC file missing the trailing PostScript tail — pyarrow ORCFile must raise.