@ttt-productions/media-processing-core 0.8.4 → 0.8.6

package/dist/__tests__/local-input.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=local-input.test.d.ts.map

package/dist/__tests__/local-input.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-input.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/local-input.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/local-input.test.js

@@ -0,0 +1,92 @@
+import { describe, it, expect } from "vitest";
+import { Readable } from "node:stream";
+import { readFile, stat, writeFile, mkdtemp, rm } from "node:fs/promises";
+import { createHash, randomBytes } from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { streamToTempFile, hashFileSha256, readFileHeader, ByteLimitExceededError, FILE_HEADER_BYTES, } from "../io/local-input.js";
+const chunked = (buf, chunkSize) => {
+    const chunks = [];
+    for (let i = 0; i < buf.length; i += chunkSize)
+        chunks.push(buf.subarray(i, i + chunkSize));
+    return Readable.from(chunks);
+};
+describe("streamToTempFile", () => {
+    it("writes the exact bytes and reports bytesWritten; cleanup removes the file", async () => {
+        const data = randomBytes(256 * 1024 + 17);
+        const input = await streamToTempFile(chunked(data, 64 * 1024), { maxBytes: 1024 * 1024 });
+        try {
+            expect(input.bytesWritten).toBe(data.length);
+            expect(Buffer.compare(await readFile(input.localPath), data)).toBe(0);
+        }
+        finally {
+            await input.cleanup();
+        }
+        await expect(stat(input.localPath)).rejects.toThrow();
+    });
+    it("HARD CAP: throws ByteLimitExceededError and leaves no temp file behind", async () => {
+        const data = randomBytes(100_000);
+        let caught;
+        try {
+            await streamToTempFile(chunked(data, 10_000), { maxBytes: 50_000 });
+        }
+        catch (err) {
+            caught = err;
+        }
+        expect(caught).toBeInstanceOf(ByteLimitExceededError);
+        expect(caught.maxBytes).toBe(50_000);
+    });
+    it("a source stream error cleans up and propagates", async () => {
+        const bad = new Readable({
+            read() {
+                this.emit("error", new Error("source died"));
+            },
+        });
+        await expect(streamToTempFile(bad, { maxBytes: 1000 })).rejects.toThrow("source died");
+    });
+    it("rejects a non-positive maxBytes", async () => {
+        await expect(streamToTempFile(Readable.from([]), { maxBytes: 0 })).rejects.toThrow(/positive finite maxBytes/);
+    });
+    it("cleanup is idempotent", async () => {
+        const input = await streamToTempFile(Readable.from([Buffer.from("x")]), { maxBytes: 10 });
+        await input.cleanup();
+        await expect(input.cleanup()).resolves.toBeUndefined();
+    });
+});
+describe("hashFileSha256", () => {
+    it("matches crypto's whole-buffer digest", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "local-input-test-"));
+        const p = path.join(dir, "f");
+        const data = randomBytes(300_000);
+        try {
+            await writeFile(p, data);
+            const expected = createHash("sha256").update(data).digest("hex");
+            await expect(hashFileSha256(p)).resolves.toBe(expected);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("readFileHeader", () => {
+    it("reads at most the requested window and the whole file when smaller", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "local-input-test-"));
+        const p = path.join(dir, "f");
+        const data = randomBytes(FILE_HEADER_BYTES + 500);
+        try {
+            await writeFile(p, data);
+            const header = await readFileHeader(p);
+            expect(header.byteLength).toBe(FILE_HEADER_BYTES);
+            expect(Buffer.compare(Buffer.from(header), data.subarray(0, FILE_HEADER_BYTES))).toBe(0);
+            const small = await readFileHeader(p, 16);
+            expect(small.byteLength).toBe(16);
+            await writeFile(p, Buffer.from("tiny"));
+            const whole = await readFileHeader(p);
+            expect(Buffer.from(whole).toString()).toBe("tiny");
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+//# sourceMappingURL=local-input.test.js.map

package/dist/__tests__/local-input.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-input.test.js","sourceRoot":"","sources":["../../src/__tests__/local-input.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, it, expect } from \"vitest\";\nimport { Readable } from \"node:stream\";\nimport { readFile, stat, writeFile, mkdtemp, rm } from \"node:fs/promises\";\nimport { createHash, randomBytes } from \"node:crypto\";\nimport os from \"node:os\";\nimport path from \"node:path\";\nimport {\n  streamToTempFile,\n  hashFileSha256,\n  readFileHeader,\n  ByteLimitExceededError,\n  FILE_HEADER_BYTES,\n} from \"../io/local-input.js\";\n\nconst chunked = (buf: Buffer, chunkSize: number): Readable => {\n  const chunks: Buffer[] = [];\n  for (let i = 0; i < buf.length; i += chunkSize) chunks.push(buf.subarray(i, i + chunkSize));\n  return Readable.from(chunks);\n};\n\ndescribe(\"streamToTempFile\", () => {\n  it(\"writes the exact bytes and reports bytesWritten; cleanup removes the file\", async () => {\n    const data = randomBytes(256 * 1024 + 17);\n    const input = await streamToTempFile(chunked(data, 64 * 1024), { maxBytes: 1024 * 1024 });\n    try {\n      expect(input.bytesWritten).toBe(data.length);\n      expect(Buffer.compare(await readFile(input.localPath), data)).toBe(0);\n    } finally {\n      await input.cleanup();\n    }\n    await expect(stat(input.localPath)).rejects.toThrow();\n  });\n\n  it(\"HARD CAP: throws ByteLimitExceededError and leaves no temp file behind\", async () => {\n    const data = randomBytes(100_000);\n    let caught: unknown;\n    try {\n      await streamToTempFile(chunked(data, 10_000), { maxBytes: 50_000 });\n    } catch (err) {\n      caught = err;\n    }\n    expect(caught).toBeInstanceOf(ByteLimitExceededError);\n    expect((caught as ByteLimitExceededError).maxBytes).toBe(50_000);\n  });\n\n  it(\"a source stream error cleans up and propagates\", async () => {\n    const bad = new Readable({\n      read() {\n        this.emit(\"error\", new Error(\"source died\"));\n      },\n    });\n    await expect(streamToTempFile(bad, { maxBytes: 1000 })).rejects.toThrow(\"source died\");\n  });\n\n  it(\"rejects a non-positive maxBytes\", async () => {\n    await expect(streamToTempFile(Readable.from([]), { maxBytes: 0 })).rejects.toThrow(\n      /positive finite maxBytes/,\n    );\n  });\n\n  it(\"cleanup is idempotent\", async () => {\n    const input = await streamToTempFile(Readable.from([Buffer.from(\"x\")]), { maxBytes: 10 });\n    await input.cleanup();\n    await expect(input.cleanup()).resolves.toBeUndefined();\n  });\n});\n\ndescribe(\"hashFileSha256\", () => {\n  it(\"matches crypto's whole-buffer digest\", async () => {\n    const dir = await mkdtemp(path.join(os.tmpdir(), \"local-input-test-\"));\n    const p = path.join(dir, \"f\");\n    const data = randomBytes(300_000);\n    try {\n      await writeFile(p, data);\n      const expected = createHash(\"sha256\").update(data).digest(\"hex\");\n      await expect(hashFileSha256(p)).resolves.toBe(expected);\n    } finally {\n      await rm(dir, { recursive: true, force: true });\n    }\n  });\n});\n\ndescribe(\"readFileHeader\", () => {\n  it(\"reads at most the requested window and the whole file when smaller\", async () => {\n    const dir = await mkdtemp(path.join(os.tmpdir(), \"local-input-test-\"));\n    const p = path.join(dir, \"f\");\n    const data = randomBytes(FILE_HEADER_BYTES + 500);\n    try {\n      await writeFile(p, data);\n      const header = await readFileHeader(p);\n      expect(header.byteLength).toBe(FILE_HEADER_BYTES);\n      expect(Buffer.compare(Buffer.from(header), data.subarray(0, FILE_HEADER_BYTES))).toBe(0);\n\n      const small = await readFileHeader(p, 16);\n      expect(small.byteLength).toBe(16);\n\n      await writeFile(p, Buffer.from(\"tiny\"));\n      const whole = await readFileHeader(p);\n      expect(Buffer.from(whole).toString()).toBe(\"tiny\");\n    } finally {\n      await rm(dir, { recursive: true, force: true });\n    }\n  });\n});\n"]}

package/dist/index.d.ts

@@ -8,7 +8,9 @@ export * from "./audio/index.js";
 export * from "./audio/audio-processor.js";
 export * from "./io/types.js";
 export * from "./run-pipeline.js";
+export * from "./inspection/inspect-media.js";
 export * from "./io/fs.js";
+export * from "./io/local-input.js";
 export * from "./moderation/types.js";
 export * from "./moderation/merge.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAE3C,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAE3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAE3C,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAElC,cAAc,YAAY,CAAC;AAE3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAE3C,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAE3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAE3C,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAElC,cAAc,+BAA+B,CAAC;AAE9C,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AAEpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}

package/dist/index.js

@@ -8,7 +8,9 @@ export * from "./audio/index.js"; // Not ./audio.js
 export * from "./audio/audio-processor.js";
 export * from "./io/types.js";
 export * from "./run-pipeline.js";
+export * from "./inspection/inspect-media.js";
 export * from "./io/fs.js";
+export * from "./io/local-input.js";
 export * from "./moderation/types.js";
 export * from "./moderation/merge.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC,CAAW,iBAAiB;AAC7D,cAAc,4BAA4B,CAAC;AAE3C,cAAc,kBAAkB,CAAC,CAAW,iBAAiB;AAC7D,cAAc,4BAA4B,CAAC;AAE3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,kBAAkB,CAAC,CAAW,iBAAiB;AAC7D,cAAc,4BAA4B,CAAC;AAE3C,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAElC,cAAc,YAAY,CAAC;AAE3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC","sourcesContent":["export * from \"./image/index.js\";           // Not ./image.js\nexport * from \"./image/image-processor.js\";\n\nexport * from \"./video/index.js\";           // Not ./video.js\nexport * from \"./video/video-processor.js\";\n\nexport * from \"./process-media.js\";\nexport * from \"./workspace/temp.js\";\n\nexport * from \"./audio/index.js\";           // Not ./audio.js\nexport * from \"./audio/audio-processor.js\";\n\nexport * from \"./io/types.js\";\nexport * from \"./run-pipeline.js\";\n\nexport * from \"./io/fs.js\";\n\nexport * from \"./moderation/types.js\";\nexport * from \"./moderation/merge.js\";"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC,CAAW,iBAAiB;AAC7D,cAAc,4BAA4B,CAAC;AAE3C,cAAc,kBAAkB,CAAC,CAAW,iBAAiB;AAC7D,cAAc,4BAA4B,CAAC;AAE3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,kBAAkB,CAAC,CAAW,iBAAiB;AAC7D,cAAc,4BAA4B,CAAC;AAE3C,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAElC,cAAc,+BAA+B,CAAC;AAE9C,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AAEpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC","sourcesContent":["export * from \"./image/index.js\";           // Not ./image.js\nexport * from \"./image/image-processor.js\";\n\nexport * from \"./video/index.js\";           // Not ./video.js\nexport * from \"./video/video-processor.js\";\n\nexport * from \"./process-media.js\";\nexport * from \"./workspace/temp.js\";\n\nexport * from \"./audio/index.js\";           // Not ./audio.js\nexport * from \"./audio/audio-processor.js\";\n\nexport * from \"./io/types.js\";\nexport * from \"./run-pipeline.js\";\n\nexport * from \"./inspection/inspect-media.js\";\n\nexport * from \"./io/fs.js\";\nexport * from \"./io/local-input.js\";\n\nexport * from \"./moderation/types.js\";\nexport * from \"./moderation/merge.js\";"]}

package/dist/inspection/inspect-media.d.ts

@@ -0,0 +1,57 @@
+import { type MediaInspectionResult, type MediaFormatId } from "@ttt-productions/media-schemas";
+/** Bump on any classification-rule change (rides every decision event). */
+export declare const INSPECTOR_VERSION = "mpc-inspect-1";
+type SignatureFamily = {
+    family: "image";
+    formatId: MediaFormatId;
+    container: string;
+} | {
+    family: "svg";
+} | {
+    family: "ebml";
+} | {
+    family: "isobmff";
+    brand: string;
+} | {
+    family: "ogg";
+} | {
+    family: "avi";
+} | {
+    family: "wav";
+} | {
+    family: "mp3";
+} | {
+    family: "flac";
+} | {
+    family: "unknown";
+};
+export declare function detectSignatureFamily(b: Uint8Array): SignatureFamily;
+export interface InspectMediaDeps {
+    /** Probe the local file; default shells to the hardened `ffprobe`. */
+    probe?: (localPath: string, opts: {
+        timeoutMs: number;
+        signal?: AbortSignal;
+    }) => Promise<{
+        ok: true;
+        json: unknown;
+    } | {
+        ok: false;
+        reason: "timeout" | "truncated" | "failed" | "bad_json";
+    }>;
+    /** Decode-prove an image; default uses sharp metadata. Returns frame count
+     *  (pages) on success, null on decode failure. */
+    decodeImage?: (localPath: string) => Promise<{
+        frames: number;
+    } | null>;
+    /** Injected ffprobe version (default: cached `ffprobe -version` first line). */
+    ffprobeVersion?: string;
+}
+export interface InspectMediaArgs {
+    localPath: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    deps?: InspectMediaDeps;
+}
+export declare function inspectMedia(args: InspectMediaArgs): Promise<MediaInspectionResult>;
+export {};
+//# sourceMappingURL=inspect-media.d.ts.map

package/dist/inspection/inspect-media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect-media.d.ts","sourceRoot":"","sources":["../../src/inspection/inspect-media.ts"],"names":[],"mappings":"AA8BA,OAAO,EAEL,KAAK,qBAAqB,EAG1B,KAAK,aAAa,EACnB,MAAM,gCAAgC,CAAC;AAGxC,2EAA2E;AAC3E,eAAO,MAAM,iBAAiB,kBAAkB,CAAC;AA2DjD,KAAK,eAAe,GAChB;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,aAAa,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC/D;IAAE,MAAM,EAAE,KAAK,CAAA;CAAE,GACjB;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAClB;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,MAAM,EAAE,KAAK,CAAA;CAAE,GACjB;IAAE,MAAM,EAAE,KAAK,CAAA;CAAE,GACjB;IAAE,MAAM,EAAE,KAAK,CAAA;CAAE,GACjB;IAAE,MAAM,EAAE,KAAK,CAAA;CAAE,GACjB;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAClB;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,CAAC;AAY1B,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,UAAU,GAAG,eAAe,CAiCpE;AAID,MAAM,WAAW,gBAAgB;IAC/B,sEAAsE;IACtE,KAAK,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CACrF;QAAE,EAAE,EAAE,IAAI,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,GAC3B;QAAE,EAAE,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,UAAU,CAAA;KAAE,CACzE,CAAC;IACF;sDACkD;IAClD,WAAW,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IACxE,gFAAgF;IAChF,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAyGD,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,IAAI,CAAC,EAAE,gBAAgB,CAAC;CACzB;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CA0HzF"}

package/dist/inspection/inspect-media.js

@@ -0,0 +1,412 @@
+// =============================================================================
+// Canonical media content inspection (canonical-upload-content-classification)
+// =============================================================================
+//
+// The ONE server-side classification authority. Consumes a LOCAL file (the
+// pipeline's generation-pinned temp download), establishes what the bytes
+// actually contain, and returns the bounded `MediaInspectionResult` contract
+// from @ttt-productions/media-schemas. Everything downstream — origin/kind
+// validation, processing-spec selection, the persisted asset kind, and the
+// safety (PhotoDNA) routing — derives from this one result. Client MIME,
+// filename, extension, container brand, and payload-byte heuristics are never
+// consulted.
+//
+// Design (reviewed 2026-07-31; see the consuming app's
+// CODE_CHANGE_canonical_upload_content_classification.md):
+//   - family selection by a bounded 64 KiB SIGNATURE read (header only —
+//     semantic elements are NEVER searched for in arbitrary payload; that
+//     flat-scan heuristic caused the WebM audio misclassification twice);
+//   - shared A/V containers (EBML/ISO-BMFF/Ogg/AVI) classified by a hardened
+//     `ffprobe` stream table (libavformat's structural parsers), with timeout,
+//     kill-on-abort, output cap, and strict schema validation;
+//   - image-family proof by DECODER (sharp) — a signature or `ftyp` brand is a
+//     candidate, not proof, and image-family ISO-BMFF (AVIF/HEIC) is resolved
+//     BEFORE the ordinary "any timed video stream wins" rule (a valid AVIF
+//     probes as a one-frame AV1 `video` stream);
+//   - FAIL-CLOSED: anything unproven is `indeterminate` with the
+//     `strict-video-fallback` safety plan — never audio, never publishable.
+import { open } from "node:fs/promises";
+import { z } from "zod";
+import { MediaInspectionResultSchema, } from "@ttt-productions/media-schemas";
+import { runCmd } from "../video/ffmpeg.js";
+/** Bump on any classification-rule change (rides every decision event). */
+export const INSPECTOR_VERSION = "mpc-inspect-1";
+const SIGNATURE_READ_BYTES = 64 * 1024;
+const DEFAULT_PROBE_TIMEOUT_MS = 20_000;
+const PROBE_SIZE_BYTES = 4 * 1024 * 1024; // -probesize: metadata, not playback
+const ANALYZE_DURATION_US = 10 * 1000 * 1000;
+// ---- ffprobe JSON boundary (strict; anything else is malformed) ----
+const ProbeStreamSchema = z
+    .object({
+    codec_type: z.string().max(32).optional(),
+    codec_name: z.string().max(64).optional(),
+    disposition: z
+        .object({ attached_pic: z.number().int().min(0).max(1).optional() })
+        .loose()
+        .optional(),
+    nb_frames: z.string().max(20).optional(),
+    duration: z.string().max(32).optional(),
+})
+    .loose();
+const ProbeJsonSchema = z
+    .object({
+    format: z.object({ format_name: z.string().max(200).optional() }).loose().optional(),
+    streams: z.array(ProbeStreamSchema).max(256).optional(),
+})
+    .loose();
+// ---- codec normalization (bounded — raw strings never escape) ----
+const CODEC_MAP = {
+    h264: "h264",
+    hevc: "hevc",
+    vp8: "vp8",
+    vp9: "vp9",
+    av1: "av1",
+    theora: "theora",
+    mpeg4: "mpeg4",
+    mjpeg: "mjpeg",
+    aac: "aac",
+    alac: "alac",
+    opus: "opus",
+    vorbis: "vorbis",
+    mp3: "mp3",
+    flac: "flac",
+};
+function normalizeCodec(name) {
+    if (!name)
+        return "other";
+    const n = name.toLowerCase();
+    if (CODEC_MAP[n])
+        return CODEC_MAP[n];
+    if (n.startsWith("pcm_"))
+        return "pcm";
+    if (n.startsWith("amr"))
+        return "amr";
+    return "other";
+}
+/** ISO-BMFF brands that declare an IMAGE-item file (HEIF family). Resolved via
+ *  decoder proof BEFORE the timed-video rule — see the AVIF note above. */
+const ISOBMFF_IMAGE_BRANDS = new Set(["avif", "avis", "heic", "heix", "heim", "heis", "hevc", "hevx", "mif1", "msf1"]);
+function ascii(b, off, s) {
+    if (off + s.length > b.length)
+        return false;
+    for (let i = 0; i < s.length; i++)
+        if (b[off + i] !== s.charCodeAt(i))
+            return false;
+    return true;
+}
+export function detectSignatureFamily(b) {
+    if (b.length < 12)
+        return { family: "unknown" };
+    // images (single-format signatures)
+    if (b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff)
+        return { family: "image", formatId: "jpeg", container: "jpeg" };
+    if (b[0] === 0x89 && ascii(b, 1, "PNG"))
+        return { family: "image", formatId: "png", container: "png" };
+    if (ascii(b, 0, "GIF8"))
+        return { family: "image", formatId: "gif", container: "gif" };
+    if (ascii(b, 0, "RIFF") && ascii(b, 8, "WEBP"))
+        return { family: "image", formatId: "webp", container: "webp" };
+    if (b[0] === 0x42 && b[1] === 0x4d)
+        return { family: "image", formatId: "bmp", container: "bmp" };
+    if ((b[0] === 0x49 && b[1] === 0x49 && b[2] === 0x2a) || (b[0] === 0x4d && b[1] === 0x4d && b[3] === 0x2a)) {
+        return { family: "image", formatId: "tiff", container: "tiff" };
+    }
+    // SVG: XML text — scan a short prefix for '<svg' (bounded; case-insensitive).
+    {
+        const prefix = Buffer.from(b.slice(0, Math.min(b.length, 4096)))
+            .toString("latin1")
+            .toLowerCase();
+        if (prefix.includes("<svg") && (prefix.trimStart().startsWith("<?xml") || prefix.trimStart().startsWith("<svg") || prefix.includes("<!doctype svg"))) {
+            return { family: "svg" };
+        }
+    }
+    // containers
+    if (b[0] === 0x1a && b[1] === 0x45 && b[2] === 0xdf && b[3] === 0xa3)
+        return { family: "ebml" };
+    if (ascii(b, 4, "ftyp")) {
+        const brand = String.fromCharCode(b[8], b[9], b[10], b[11]).trim().toLowerCase();
+        return { family: "isobmff", brand };
+    }
+    if (ascii(b, 0, "OggS"))
+        return { family: "ogg" };
+    if (ascii(b, 0, "RIFF") && ascii(b, 8, "AVI "))
+        return { family: "avi" };
+    if (ascii(b, 0, "RIFF") && ascii(b, 8, "WAVE"))
+        return { family: "wav" };
+    if (ascii(b, 0, "ID3"))
+        return { family: "mp3" };
+    if (b[0] === 0xff && (b[1] & 0xe0) === 0xe0)
+        return { family: "mp3" };
+    if (ascii(b, 0, "fLaC"))
+        return { family: "flac" };
+    return { family: "unknown" };
+}
+let cachedFfprobeVersion;
+async function getFfprobeVersion() {
+    if (cachedFfprobeVersion !== undefined)
+        return cachedFfprobeVersion ?? undefined;
+    try {
+        const r = await runCmd("ffprobe", ["-version"], { timeoutMs: 5_000 });
+        const first = (r.stdout || r.stderr).split(/\r?\n/)[0]?.trim() ?? "";
+        cachedFfprobeVersion = first ? first.slice(0, 120) : null;
+    }
+    catch {
+        cachedFfprobeVersion = null;
+    }
+    return cachedFfprobeVersion ?? undefined;
+}
+async function defaultProbe(localPath, opts) {
+    let r;
+    try {
+        r = await runCmd("ffprobe", [
+            "-v",
+            "error",
+            "-print_format",
+            "json",
+            "-show_format",
+            "-show_streams",
+            "-probesize",
+            String(PROBE_SIZE_BYTES),
+            "-analyzeduration",
+            String(ANALYZE_DURATION_US),
+            localPath,
+        ], { timeoutMs: opts.timeoutMs, signal: opts.signal });
+    }
+    catch {
+        return { ok: false, reason: "failed" }; // spawn failure (ffprobe missing) — fail closed
+    }
+    if (r.timedOut)
+        return { ok: false, reason: "timeout" };
+    if (r.truncated)
+        return { ok: false, reason: "truncated" };
+    if (r.code !== 0)
+        return { ok: false, reason: "failed" };
+    try {
+        return { ok: true, json: JSON.parse(r.stdout || "{}") };
+    }
+    catch {
+        return { ok: false, reason: "bad_json" };
+    }
+}
+async function defaultDecodeImage(localPath) {
+    try {
+        const sharp = (await import("sharp")).default;
+        const meta = await sharp(localPath, { limitInputPixels: 268402689 /* sharp default ~16k x 16k */ }).metadata();
+        if (!meta.width || !meta.height)
+            return null;
+        return { frames: Math.max(1, meta.pages ?? 1) };
+    }
+    catch {
+        return null;
+    }
+}
+// ---- result builders ----
+function baseResult(partial, ffprobeVersion) {
+    const result = {
+        inspectorVersion: INSPECTOR_VERSION,
+        ...(ffprobeVersion ? { ffprobeVersion } : {}),
+        streams: partial.streams ?? { audio: 0, timedVideo: 0, attachedPictures: 0, imageFrames: 0, auxiliary: 0 },
+        codecs: partial.codecs ?? { audio: [], video: [] },
+        status: partial.status,
+        container: partial.container,
+        safetyPlan: partial.safetyPlan,
+        reasonCode: partial.reasonCode,
+        ...(partial.canonicalKind ? { canonicalKind: partial.canonicalKind } : {}),
+        ...(partial.formatId ? { formatId: partial.formatId } : {}),
+    };
+    return MediaInspectionResultSchema.parse(result);
+}
+function indeterminate(container, reasonCode, ffprobeVersion, formatId) {
+    return baseResult({
+        status: "indeterminate",
+        container,
+        safetyPlan: "strict-video-fallback",
+        reasonCode,
+        ...(formatId ? { formatId } : {}),
+    }, ffprobeVersion);
+}
+export async function inspectMedia(args) {
+    const timeoutMs = args.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
+    const probe = args.deps?.probe ?? defaultProbe;
+    const decodeImage = args.deps?.decodeImage ?? defaultDecodeImage;
+    const ffprobeVersion = args.deps?.ffprobeVersion ?? (await getFfprobeVersion());
+    // 1) bounded signature read (header only)
+    let head;
+    try {
+        const fh = await open(args.localPath, "r");
+        try {
+            const buf = Buffer.alloc(SIGNATURE_READ_BYTES);
+            const { bytesRead } = await fh.read(buf, 0, SIGNATURE_READ_BYTES, 0);
+            head = buf.subarray(0, bytesRead);
+        }
+        finally {
+            await fh.close();
+        }
+    }
+    catch {
+        return indeterminate("unknown", "read_failed", ffprobeVersion);
+    }
+    const sig = detectSignatureFamily(head);
+    // 2) family routing
+    switch (sig.family) {
+        case "unknown":
+            return indeterminate("unknown", "unrecognized_signature", ffprobeVersion);
+        case "svg":
+            // Scriptable XML "image" — structurally recognized, deliberately NOT a
+            // processable format until a sanitize/rasterize design exists (launch
+            // policy 2026-07-31). Never classified by decoder capability alone.
+            return baseResult({
+                status: "unsupported",
+                container: "svg",
+                formatId: "svg",
+                safetyPlan: "strict-video-fallback",
+                reasonCode: "unsupported_format:svg",
+            }, ffprobeVersion);
+        case "image": {
+            // Single-format image signature: decoder proof required — a signature is
+            // a candidate, not a classification.
+            const decoded = await decodeImage(args.localPath);
+            if (!decoded)
+                return baseResult({ status: "malformed", container: sig.container, formatId: sig.formatId, safetyPlan: "strict-video-fallback", reasonCode: "image_decode_failed" }, ffprobeVersion);
+            const frames = decoded.frames;
+            return baseResult({
+                status: "definitive",
+                canonicalKind: "image",
+                container: sig.container,
+                formatId: sig.formatId,
+                streams: { audio: 0, timedVideo: 0, attachedPictures: 0, imageFrames: frames, auxiliary: 0 },
+                safetyPlan: frames > 1 ? "animated-image-frames" : "still-image",
+                reasonCode: "ok",
+            }, ffprobeVersion);
+        }
+        case "isobmff":
+            if (ISOBMFF_IMAGE_BRANDS.has(sig.brand)) {
+                // IMAGE-FAMILY ISO-BMFF resolves BEFORE the timed-video rule: a valid
+                // AVIF probes as a one-frame AV1 `video` stream. Proof = image brand +
+                // successful bounded decode + no ordinary timed A/V presentation.
+                const probed = await probe(args.localPath, { timeoutMs, signal: args.signal });
+                const parsed = probed.ok ? ProbeJsonSchema.safeParse(probed.json) : null;
+                const streams = parsed?.success ? parsed.data.streams ?? [] : null;
+                const hasAudio = streams ? streams.some((s) => s.codec_type === "audio") : true; // unknown ⇒ assume worst
+                const formatId = sig.brand.startsWith("avi") ? "avif" : "heic";
+                const decoded = await decodeImage(args.localPath);
+                if (!decoded || hasAudio) {
+                    if (formatId === "heic" && !decoded && !hasAudio) {
+                        // Recognized HEIC-family that the runtime cannot decode: explicit
+                        // unsupported-image (launch policy) — NEVER relabeled video.
+                        return baseResult({ status: "unsupported", container: "heif", formatId, safetyPlan: "strict-video-fallback", reasonCode: "unsupported_format:heic" }, ffprobeVersion);
+                    }
+                    // Undecodable/ambiguous image-brand file, or one carrying audio (a
+                    // real timed presentation wearing an image brand): fail toward the
+                    // stricter visual path.
+                    return indeterminate("heif", decoded ? "image_brand_with_audio" : "image_decode_failed", ffprobeVersion, formatId);
+                }
+                const frames = decoded.frames;
+                return baseResult({
+                    status: "definitive",
+                    canonicalKind: "image",
+                    container: "heif",
+                    formatId,
+                    streams: { audio: 0, timedVideo: 0, attachedPictures: 0, imageFrames: frames, auxiliary: 0 },
+                    safetyPlan: frames > 1 ? "animated-image-frames" : "still-image",
+                    reasonCode: "ok",
+                }, ffprobeVersion);
+            }
+            return classifyAvContainer(args, "isobmff", "isobmff", probe, timeoutMs, ffprobeVersion);
+        case "ebml":
+            return classifyAvContainer(args, "webm", "webm", probe, timeoutMs, ffprobeVersion);
+        case "ogg":
+            return classifyAvContainer(args, "ogg", "ogg", probe, timeoutMs, ffprobeVersion);
+        case "avi":
+            // Real container ffprobe parses; no registry entry (no origin enables it
+            // today) — the stream truth still classifies it, policy rejects by format.
+            return classifyAvContainer(args, "avi", undefined, probe, timeoutMs, ffprobeVersion);
+        case "wav":
+            return classifyAvContainer(args, "wav", "wav", probe, timeoutMs, ffprobeVersion);
+        case "mp3":
+            return classifyAvContainer(args, "mp3", "mp3", probe, timeoutMs, ffprobeVersion);
+        case "flac":
+            return classifyAvContainer(args, "flac", "flac", probe, timeoutMs, ffprobeVersion);
+    }
+}
+async function classifyAvContainer(args, container, formatId, probe, timeoutMs, ffprobeVersion) {
+    const probed = await probe(args.localPath, { timeoutMs, signal: args.signal });
+    if (!probed.ok) {
+        return indeterminate(container, `probe_${probed.reason}`, ffprobeVersion, formatId);
+    }
+    const parsed = ProbeJsonSchema.safeParse(probed.json);
+    if (!parsed.success)
+        return indeterminate(container, "probe_schema_invalid", ffprobeVersion, formatId);
+    const rawStreams = parsed.data.streams ?? [];
+    if (rawStreams.length === 0)
+        return indeterminate(container, "no_streams", ffprobeVersion, formatId);
+    const counts = { audio: 0, timedVideo: 0, attachedPictures: 0, imageFrames: 0, auxiliary: 0 };
+    const audioCodecs = new Set();
+    const videoCodecs = new Set();
+    let sawUnknownType = false;
+    for (const s of rawStreams) {
+        const type = s.codec_type ?? "";
+        if (type === "audio") {
+            counts.audio++;
+            audioCodecs.add(normalizeCodec(s.codec_name));
+        }
+        else if (type === "video") {
+            // An attached picture (cover art) is NOT a timed presentation — but the
+            // disposition flag is untrusted container data, so it is COUNTED and the
+            // safety plan forces every such picture through the image hash path
+            // before the audio guard may return clean.
+            if (s.disposition?.attached_pic === 1) {
+                counts.attachedPictures++;
+            }
+            else {
+                counts.timedVideo++;
+                videoCodecs.add(normalizeCodec(s.codec_name));
+            }
+        }
+        else if (type === "subtitle" || type === "data" || type === "attachment") {
+            counts.auxiliary++;
+        }
+        else {
+            counts.auxiliary++;
+            sawUnknownType = true;
+        }
+    }
+    const codecs = { audio: [...audioCodecs], video: [...videoCodecs] };
+    // classification table (fail-closed)
+    if (counts.timedVideo > 0) {
+        return baseResult({
+            status: "definitive",
+            canonicalKind: "video",
+            container,
+            ...(formatId ? { formatId } : {}),
+            streams: counts,
+            codecs,
+            safetyPlan: "video-frames",
+            reasonCode: "ok",
+        }, ffprobeVersion);
+    }
+    if (counts.audio > 0 && !sawUnknownType) {
+        return baseResult({
+            status: "definitive",
+            canonicalKind: "audio",
+            container,
+            ...(formatId ? { formatId } : {}),
+            streams: counts,
+            codecs,
+            safetyPlan: counts.attachedPictures > 0 ? "audio-plus-artwork" : "audio-only",
+            reasonCode: "ok",
+        }, ffprobeVersion);
+    }
+    // auxiliary-only, unknown stream types alongside audio, or nothing usable:
+    // never audio — the strict visual fallback owns it.
+    return baseResult({
+        status: "indeterminate",
+        container,
+        ...(formatId ? { formatId } : {}),
+        streams: counts,
+        codecs,
+        safetyPlan: "strict-video-fallback",
+        reasonCode: sawUnknownType ? "unknown_stream_type" : "auxiliary_only",
+    }, ffprobeVersion);
+}
+//# sourceMappingURL=inspect-media.js.map