@anvilkit/plugin-asset-manager 0.1.8 → 0.1.10

package/dist/utils/run-resumable-upload.cjs

@@ -0,0 +1,160 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    runResumableUpload: ()=>runResumableUpload
+});
+const external_errors_cjs_namespaceObject = require("./errors.cjs");
+const external_retry_cjs_namespaceObject = require("./retry.cjs");
+const external_upload_session_store_cjs_namespaceObject = require("./upload-session-store.cjs");
+const DEFAULT_PART_SIZE = 8388608;
+async function runResumableUpload(adapter, file, options = {}) {
+    const sessionStore = options.sessionStore ?? (0, external_upload_session_store_cjs_namespaceObject.createUploadSessionStore)();
+    const { signal } = options;
+    const callOptions = signal ? {
+        signal
+    } : void 0;
+    throwIfAborted(signal);
+    const persisted = await sessionStore.load(file) ?? void 0;
+    const session = await adapter.begin(file, persisted, callOptions);
+    const resumedParts = session.parts ?? [];
+    let effectivePartSize;
+    if (void 0 !== persisted && resumedParts.length > 0) {
+        const locked = persisted.partSize;
+        if (void 0 !== session.partSize && session.partSize !== locked) throw new external_errors_cjs_namespaceObject.AssetValidationError("PART_SIZE_MISMATCH", `runResumableUpload: resumed session changed part size (${locked} → ${session.partSize}); refusing to corrupt already-uploaded parts.`);
+        effectivePartSize = locked;
+    } else effectivePartSize = session.partSize ?? options.partSize ?? DEFAULT_PART_SIZE;
+    if (!Number.isSafeInteger(effectivePartSize) || effectivePartSize <= 0) throw new external_errors_cjs_namespaceObject.AssetValidationError("INVALID_PART_SIZE", `runResumableUpload: part size must be a positive integer (got ${effectivePartSize}).`);
+    const plan = planParts(file, effectivePartSize);
+    const sizeByPart = new Map(plan.map((p)=>[
+            p.partNumber,
+            p.end - p.start
+        ]));
+    const completed = new Map();
+    for (const tag of resumedParts)if (sizeByPart.has(tag.partNumber)) completed.set(tag.partNumber, tag);
+    const emitProgress = ()=>{
+        options.onProgress?.({
+            uploadedBytes: sumCompletedBytes(completed, sizeByPart),
+            totalBytes: file.size,
+            uploadedParts: completed.size,
+            totalParts: plan.length
+        });
+    };
+    emitProgress();
+    try {
+        for (const part of plan){
+            throwIfAborted(signal);
+            if (completed.has(part.partNumber)) continue;
+            const tag = await (0, external_retry_cjs_namespaceObject.withRetry)(()=>adapter.uploadPart(session, part, callOptions), {
+                ...options.retry ?? {},
+                ...signal ? {
+                    signal
+                } : {}
+            });
+            completed.set(part.partNumber, tag);
+            await sessionStore.save(file, toPersisted(session, effectivePartSize, completed));
+            emitProgress();
+        }
+        const orderedTags = plan.map((part)=>{
+            const tag = completed.get(part.partNumber);
+            if (void 0 === tag) throw new Error(`runResumableUpload: missing tag for part ${part.partNumber}.`);
+            return tag;
+        });
+        const result = await adapter.complete(session, orderedTags, callOptions);
+        await sessionStore.clear(file);
+        return result;
+    } catch (error) {
+        if (isAbort(error, signal)) {
+            await safeAbort(adapter, session);
+            await sessionStore.clear(file);
+        }
+        throw error;
+    }
+}
+function planParts(file, partSize) {
+    const parts = [];
+    const size = file.size;
+    let partNumber = 1;
+    for(let start = 0; start < size; start += partSize){
+        const end = Math.min(start + partSize, size);
+        parts.push({
+            partNumber,
+            start,
+            end,
+            blob: file.slice(start, end)
+        });
+        partNumber += 1;
+    }
+    return parts;
+}
+function sumCompletedBytes(completed, sizeByPart) {
+    let total = 0;
+    for (const partNumber of completed.keys())total += sizeByPart.get(partNumber) ?? 0;
+    return total;
+}
+function toPersisted(session, partSize, completed) {
+    const parts = [
+        ...completed.values()
+    ].sort((a, b)=>a.partNumber - b.partNumber);
+    return {
+        uploadId: session.uploadId,
+        partSize,
+        parts,
+        ...session.meta ? {
+            meta: session.meta
+        } : {}
+    };
+}
+async function safeAbort(adapter, session) {
+    try {
+        await adapter.abort(session);
+    } catch  {}
+}
+function isAbort(error, signal) {
+    if (signal?.aborted) return true;
+    return null !== error && "object" == typeof error && "AbortError" === error.name;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) throw toAbortError(signal);
+}
+function toAbortError(signal) {
+    const reason = signal.reason;
+    if (reason instanceof Error) return reason;
+    if ("u" > typeof DOMException) return new DOMException("Aborted", "AbortError");
+    const error = new Error("Aborted");
+    error.name = "AbortError";
+    return error;
+}
+exports.runResumableUpload = __webpack_exports__.runResumableUpload;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runResumableUpload"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/run-resumable-upload.d.cts

@@ -0,0 +1,56 @@
+/**
+ * @file Adapter-agnostic resumable-upload runner (PRD 0004 §5.1 — M3).
+ *
+ * Drives any {@link ResumableUploadAdapter} through a full multipart lifecycle:
+ * slice the file into ordered parts, resume the ones a prior run already
+ * uploaded, upload the rest with per-part retry, emit progress, finalize, and
+ * tear down on abort. It is deliberately backend-neutral — it never assumes S3;
+ * the S3 specifics live in the adapter (M4).
+ *
+ * Trust boundary: this returns the adapter's raw {@link UploadResult}. The
+ * pipeline (M5) runs it through `validateUploadResult()` exactly as it does for
+ * single-shot uploads, so the runner stays a pure orchestrator.
+ *
+ * @experimental Public surface may change before v1.0.
+ */
+import type { ResumableUploadAdapter, UploadSessionStore } from "../types/resumable.js";
+import type { UploadResult } from "../types/types.js";
+import { type RetryOptions } from "./retry.js";
+/** Progress snapshot emitted as parts complete. */
+export interface ResumableUploadProgress {
+    /** Bytes confirmed stored so far (sum of completed part sizes). */
+    readonly uploadedBytes: number;
+    /** Total bytes in the source file. */
+    readonly totalBytes: number;
+    /** Number of parts confirmed stored. */
+    readonly uploadedParts: number;
+    /** Total number of parts in the plan. */
+    readonly totalParts: number;
+}
+/** Options for {@link runResumableUpload}. */
+export interface RunResumableUploadOptions {
+    /**
+     * Bytes per part for a *fresh* upload. Ignored when resuming — the locked
+     * size from the persisted/echoed session is used instead. Defaults to 8 MiB.
+     */
+    readonly partSize?: number;
+    /** Aborts the upload (and any in-flight part + retry sleeps). */
+    readonly signal?: AbortSignal;
+    /** Called after `begin` (with resumed progress) and after each part completes. */
+    readonly onProgress?: (progress: ResumableUploadProgress) => void;
+    /**
+     * Where progress is persisted for resume. Defaults to the built-in
+     * `createUploadSessionStore()` (localStorage, in-memory fallback).
+     */
+    readonly sessionStore?: UploadSessionStore;
+    /** Forwarded to `withRetry()` for each part upload (retry-by-part). */
+    readonly retry?: RetryOptions;
+}
+/**
+ * Upload `file` through `adapter` as a resumable multipart upload. Returns the
+ * adapter's `UploadResult` (unvalidated — the caller validates). Rejects on
+ * abort (after best-effort backend teardown) or when a part's retries are
+ * exhausted (leaving the session persisted so a later call can resume).
+ */
+export declare function runResumableUpload(adapter: ResumableUploadAdapter, file: File, options?: RunResumableUploadOptions): Promise<UploadResult>;
+//# sourceMappingURL=run-resumable-upload.d.cts.map

package/dist/utils/run-resumable-upload.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-resumable-upload.d.cts","sourceRoot":"","sources":["../../src/utils/run-resumable-upload.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAGX,sBAAsB,EAGtB,kBAAkB,EAClB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,EAAE,KAAK,YAAY,EAAa,MAAM,YAAY,CAAC;AAM1D,mDAAmD;AACnD,MAAM,WAAW,uBAAuB;IACvC,mEAAmE;IACnE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,sCAAsC;IACtC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wCAAwC;IACxC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,yCAAyC;IACzC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC5B;AAED,8CAA8C;AAC9C,MAAM,WAAW,yBAAyB;IACzC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,iEAAiE;IACjE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,kFAAkF;IAClF,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAClE;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAC3C,uEAAuE;IACvE,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC;CAC9B;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACvC,OAAO,EAAE,sBAAsB,EAC/B,IAAI,EAAE,IAAI,EACV,OAAO,GAAE,yBAA8B,GACrC,OAAO,CAAC,YAAY,CAAC,CAwGvB"}

package/dist/utils/run-resumable-upload.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @file Adapter-agnostic resumable-upload runner (PRD 0004 §5.1 — M3).
+ *
+ * Drives any {@link ResumableUploadAdapter} through a full multipart lifecycle:
+ * slice the file into ordered parts, resume the ones a prior run already
+ * uploaded, upload the rest with per-part retry, emit progress, finalize, and
+ * tear down on abort. It is deliberately backend-neutral — it never assumes S3;
+ * the S3 specifics live in the adapter (M4).
+ *
+ * Trust boundary: this returns the adapter's raw {@link UploadResult}. The
+ * pipeline (M5) runs it through `validateUploadResult()` exactly as it does for
+ * single-shot uploads, so the runner stays a pure orchestrator.
+ *
+ * @experimental Public surface may change before v1.0.
+ */
+import type { ResumableUploadAdapter, UploadSessionStore } from "../types/resumable.js";
+import type { UploadResult } from "../types/types.js";
+import { type RetryOptions } from "./retry.js";
+/** Progress snapshot emitted as parts complete. */
+export interface ResumableUploadProgress {
+    /** Bytes confirmed stored so far (sum of completed part sizes). */
+    readonly uploadedBytes: number;
+    /** Total bytes in the source file. */
+    readonly totalBytes: number;
+    /** Number of parts confirmed stored. */
+    readonly uploadedParts: number;
+    /** Total number of parts in the plan. */
+    readonly totalParts: number;
+}
+/** Options for {@link runResumableUpload}. */
+export interface RunResumableUploadOptions {
+    /**
+     * Bytes per part for a *fresh* upload. Ignored when resuming — the locked
+     * size from the persisted/echoed session is used instead. Defaults to 8 MiB.
+     */
+    readonly partSize?: number;
+    /** Aborts the upload (and any in-flight part + retry sleeps). */
+    readonly signal?: AbortSignal;
+    /** Called after `begin` (with resumed progress) and after each part completes. */
+    readonly onProgress?: (progress: ResumableUploadProgress) => void;
+    /**
+     * Where progress is persisted for resume. Defaults to the built-in
+     * `createUploadSessionStore()` (localStorage, in-memory fallback).
+     */
+    readonly sessionStore?: UploadSessionStore;
+    /** Forwarded to `withRetry()` for each part upload (retry-by-part). */
+    readonly retry?: RetryOptions;
+}
+/**
+ * Upload `file` through `adapter` as a resumable multipart upload. Returns the
+ * adapter's `UploadResult` (unvalidated — the caller validates). Rejects on
+ * abort (after best-effort backend teardown) or when a part's retries are
+ * exhausted (leaving the session persisted so a later call can resume).
+ */
+export declare function runResumableUpload(adapter: ResumableUploadAdapter, file: File, options?: RunResumableUploadOptions): Promise<UploadResult>;
+//# sourceMappingURL=run-resumable-upload.d.ts.map

package/dist/utils/run-resumable-upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-resumable-upload.d.ts","sourceRoot":"","sources":["../../src/utils/run-resumable-upload.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAGX,sBAAsB,EAGtB,kBAAkB,EAClB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,EAAE,KAAK,YAAY,EAAa,MAAM,YAAY,CAAC;AAM1D,mDAAmD;AACnD,MAAM,WAAW,uBAAuB;IACvC,mEAAmE;IACnE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,sCAAsC;IACtC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wCAAwC;IACxC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,yCAAyC;IACzC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC5B;AAED,8CAA8C;AAC9C,MAAM,WAAW,yBAAyB;IACzC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,iEAAiE;IACjE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,kFAAkF;IAClF,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAClE;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAC3C,uEAAuE;IACvE,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC;CAC9B;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACvC,OAAO,EAAE,sBAAsB,EAC/B,IAAI,EAAE,IAAI,EACV,OAAO,GAAE,yBAA8B,GACrC,OAAO,CAAC,YAAY,CAAC,CAwGvB"}

package/dist/utils/run-resumable-upload.js

@@ -0,0 +1,122 @@
+import { AssetValidationError } from "./errors.js";
+import { withRetry } from "./retry.js";
+import { createUploadSessionStore } from "./upload-session-store.js";
+const DEFAULT_PART_SIZE = 8388608;
+async function runResumableUpload(adapter, file, options = {}) {
+    const sessionStore = options.sessionStore ?? createUploadSessionStore();
+    const { signal } = options;
+    const callOptions = signal ? {
+        signal
+    } : void 0;
+    throwIfAborted(signal);
+    const persisted = await sessionStore.load(file) ?? void 0;
+    const session = await adapter.begin(file, persisted, callOptions);
+    const resumedParts = session.parts ?? [];
+    let effectivePartSize;
+    if (void 0 !== persisted && resumedParts.length > 0) {
+        const locked = persisted.partSize;
+        if (void 0 !== session.partSize && session.partSize !== locked) throw new AssetValidationError("PART_SIZE_MISMATCH", `runResumableUpload: resumed session changed part size (${locked} → ${session.partSize}); refusing to corrupt already-uploaded parts.`);
+        effectivePartSize = locked;
+    } else effectivePartSize = session.partSize ?? options.partSize ?? DEFAULT_PART_SIZE;
+    if (!Number.isSafeInteger(effectivePartSize) || effectivePartSize <= 0) throw new AssetValidationError("INVALID_PART_SIZE", `runResumableUpload: part size must be a positive integer (got ${effectivePartSize}).`);
+    const plan = planParts(file, effectivePartSize);
+    const sizeByPart = new Map(plan.map((p)=>[
+            p.partNumber,
+            p.end - p.start
+        ]));
+    const completed = new Map();
+    for (const tag of resumedParts)if (sizeByPart.has(tag.partNumber)) completed.set(tag.partNumber, tag);
+    const emitProgress = ()=>{
+        options.onProgress?.({
+            uploadedBytes: sumCompletedBytes(completed, sizeByPart),
+            totalBytes: file.size,
+            uploadedParts: completed.size,
+            totalParts: plan.length
+        });
+    };
+    emitProgress();
+    try {
+        for (const part of plan){
+            throwIfAborted(signal);
+            if (completed.has(part.partNumber)) continue;
+            const tag = await withRetry(()=>adapter.uploadPart(session, part, callOptions), {
+                ...options.retry ?? {},
+                ...signal ? {
+                    signal
+                } : {}
+            });
+            completed.set(part.partNumber, tag);
+            await sessionStore.save(file, toPersisted(session, effectivePartSize, completed));
+            emitProgress();
+        }
+        const orderedTags = plan.map((part)=>{
+            const tag = completed.get(part.partNumber);
+            if (void 0 === tag) throw new Error(`runResumableUpload: missing tag for part ${part.partNumber}.`);
+            return tag;
+        });
+        const result = await adapter.complete(session, orderedTags, callOptions);
+        await sessionStore.clear(file);
+        return result;
+    } catch (error) {
+        if (isAbort(error, signal)) {
+            await safeAbort(adapter, session);
+            await sessionStore.clear(file);
+        }
+        throw error;
+    }
+}
+function planParts(file, partSize) {
+    const parts = [];
+    const size = file.size;
+    let partNumber = 1;
+    for(let start = 0; start < size; start += partSize){
+        const end = Math.min(start + partSize, size);
+        parts.push({
+            partNumber,
+            start,
+            end,
+            blob: file.slice(start, end)
+        });
+        partNumber += 1;
+    }
+    return parts;
+}
+function sumCompletedBytes(completed, sizeByPart) {
+    let total = 0;
+    for (const partNumber of completed.keys())total += sizeByPart.get(partNumber) ?? 0;
+    return total;
+}
+function toPersisted(session, partSize, completed) {
+    const parts = [
+        ...completed.values()
+    ].sort((a, b)=>a.partNumber - b.partNumber);
+    return {
+        uploadId: session.uploadId,
+        partSize,
+        parts,
+        ...session.meta ? {
+            meta: session.meta
+        } : {}
+    };
+}
+async function safeAbort(adapter, session) {
+    try {
+        await adapter.abort(session);
+    } catch  {}
+}
+function isAbort(error, signal) {
+    if (signal?.aborted) return true;
+    return null !== error && "object" == typeof error && "AbortError" === error.name;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) throw toAbortError(signal);
+}
+function toAbortError(signal) {
+    const reason = signal.reason;
+    if (reason instanceof Error) return reason;
+    if ("u" > typeof DOMException) return new DOMException("Aborted", "AbortError");
+    const error = new Error("Aborted");
+    error.name = "AbortError";
+    return error;
+}
+export { runResumableUpload };

package/dist/utils/sniff-file-type.cjs

@@ -0,0 +1,209 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const ascii = (text)=>Array.from(text, (ch)=>ch.charCodeAt(0));
+const SIGNATURES = [
+    {
+        mime: "image/png",
+        parts: [
+            {
+                offset: 0,
+                bytes: [
+                    0x89,
+                    0x50,
+                    0x4e,
+                    0x47,
+                    0x0d,
+                    0x0a,
+                    0x1a,
+                    0x0a
+                ]
+            }
+        ]
+    },
+    {
+        mime: "image/jpeg",
+        parts: [
+            {
+                offset: 0,
+                bytes: [
+                    0xff,
+                    0xd8,
+                    0xff
+                ]
+            }
+        ]
+    },
+    {
+        mime: "image/gif",
+        parts: [
+            {
+                offset: 0,
+                bytes: ascii("GIF8")
+            }
+        ]
+    },
+    {
+        mime: "image/bmp",
+        parts: [
+            {
+                offset: 0,
+                bytes: ascii("BM")
+            }
+        ]
+    },
+    {
+        mime: "image/webp",
+        parts: [
+            {
+                offset: 0,
+                bytes: ascii("RIFF")
+            },
+            {
+                offset: 8,
+                bytes: ascii("WEBP")
+            }
+        ]
+    },
+    {
+        mime: "audio/wav",
+        parts: [
+            {
+                offset: 0,
+                bytes: ascii("RIFF")
+            },
+            {
+                offset: 8,
+                bytes: ascii("WAVE")
+            }
+        ]
+    },
+    {
+        mime: "video/webm",
+        parts: [
+            {
+                offset: 0,
+                bytes: [
+                    0x1a,
+                    0x45,
+                    0xdf,
+                    0xa3
+                ]
+            }
+        ]
+    },
+    {
+        mime: "audio/ogg",
+        parts: [
+            {
+                offset: 0,
+                bytes: ascii("OggS")
+            }
+        ]
+    },
+    {
+        mime: "audio/mpeg",
+        parts: [
+            {
+                offset: 0,
+                bytes: ascii("ID3")
+            }
+        ]
+    },
+    {
+        mime: "application/pdf",
+        parts: [
+            {
+                offset: 0,
+                bytes: ascii("%PDF")
+            }
+        ]
+    }
+];
+const FTYP_BRAND_MIME = {
+    avif: "image/avif",
+    avis: "image/avif",
+    heic: "image/heic",
+    heix: "image/heic",
+    heim: "image/heic",
+    heis: "image/heic",
+    mif1: "image/heic",
+    isom: "video/mp4",
+    iso2: "video/mp4",
+    mp41: "video/mp4",
+    mp42: "video/mp4",
+    avc1: "video/mp4",
+    dash: "video/mp4",
+    "qt  ": "video/quicktime"
+};
+const FTYP = ascii("ftyp");
+const SNIFF_BYTE_COUNT = 16;
+function detectMimeFromBytes(bytes) {
+    if (matchesAt(bytes, {
+        offset: 4,
+        bytes: FTYP
+    })) {
+        const brand = readAscii(bytes, 8, 4);
+        return void 0 !== brand ? FTYP_BRAND_MIME[brand] : void 0;
+    }
+    for (const signature of SIGNATURES)if (signature.parts.every((part)=>matchesAt(bytes, part))) return signature.mime;
+}
+function readAscii(bytes, offset, length) {
+    if (offset + length > bytes.length) return;
+    let out = "";
+    for(let i = 0; i < length; i += 1)out += String.fromCharCode(bytes[offset + i]);
+    return out;
+}
+function matchesAt(bytes, part) {
+    if (part.offset + part.bytes.length > bytes.length) return false;
+    for(let i = 0; i < part.bytes.length; i += 1)if (bytes[part.offset + i] !== part.bytes[i]) return false;
+    return true;
+}
+async function sniffFileMime(file) {
+    if ("function" != typeof file.slice) return;
+    const buffer = await file.slice(0, SNIFF_BYTE_COUNT).arrayBuffer();
+    return detectMimeFromBytes(new Uint8Array(buffer));
+}
+__webpack_require__.d(__webpack_exports__, {
+    detectMimeFromBytes: ()=>detectMimeFromBytes,
+    sniffFileMime: ()=>sniffFileMime
+}, {
+    SNIFF_BYTE_COUNT: SNIFF_BYTE_COUNT
+});
+exports.SNIFF_BYTE_COUNT = __webpack_exports__.SNIFF_BYTE_COUNT;
+exports.detectMimeFromBytes = __webpack_exports__.detectMimeFromBytes;
+exports.sniffFileMime = __webpack_exports__.sniffFileMime;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SNIFF_BYTE_COUNT",
+    "detectMimeFromBytes",
+    "sniffFileMime"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/sniff-file-type.d.cts

@@ -0,0 +1,25 @@
+/**
+ * @file Magic-byte file-type sniffer (PRD 0004 — review #5 residual).
+ *
+ * Browser `File.type` is host-set and often empty or spoofable, so the MIME /
+ * extension allowlists in `validateSelectedFile` can be lied to. This detects a
+ * file's REAL type from its leading bytes (a small signature table covering the
+ * common image / video / audio / document formats) so the upload pipeline can
+ * reject content that contradicts its declared type.
+ *
+ * Lazy-loaded (imported only when `sniffContent` is enabled) so the signature
+ * table never enters the eager headless entry.
+ *
+ * @experimental Public surface may change before v1.0.
+ */
+/** Number of leading bytes the table needs (max offset + part length). */
+export declare const SNIFF_BYTE_COUNT = 16;
+/**
+ * Detect a MIME type from a file's leading bytes, or `undefined` when no known
+ * signature matches (many valid types — SVG, plain text, etc. — have no fixed
+ * magic bytes, so the caller must treat `undefined` as "unknown", not "bad").
+ */
+export declare function detectMimeFromBytes(bytes: Uint8Array): string | undefined;
+/** Read a file's leading bytes and detect its type (see {@link detectMimeFromBytes}). */
+export declare function sniffFileMime(file: File): Promise<string | undefined>;
+//# sourceMappingURL=sniff-file-type.d.cts.map

package/dist/utils/sniff-file-type.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sniff-file-type.d.cts","sourceRoot":"","sources":["../../src/utils/sniff-file-type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AA8EH,0EAA0E;AAC1E,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAYzE;AAuBD,yFAAyF;AACzF,wBAAsB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAI3E"}

package/dist/utils/sniff-file-type.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @file Magic-byte file-type sniffer (PRD 0004 — review #5 residual).
+ *
+ * Browser `File.type` is host-set and often empty or spoofable, so the MIME /
+ * extension allowlists in `validateSelectedFile` can be lied to. This detects a
+ * file's REAL type from its leading bytes (a small signature table covering the
+ * common image / video / audio / document formats) so the upload pipeline can
+ * reject content that contradicts its declared type.
+ *
+ * Lazy-loaded (imported only when `sniffContent` is enabled) so the signature
+ * table never enters the eager headless entry.
+ *
+ * @experimental Public surface may change before v1.0.
+ */
+/** Number of leading bytes the table needs (max offset + part length). */
+export declare const SNIFF_BYTE_COUNT = 16;
+/**
+ * Detect a MIME type from a file's leading bytes, or `undefined` when no known
+ * signature matches (many valid types — SVG, plain text, etc. — have no fixed
+ * magic bytes, so the caller must treat `undefined` as "unknown", not "bad").
+ */
+export declare function detectMimeFromBytes(bytes: Uint8Array): string | undefined;
+/** Read a file's leading bytes and detect its type (see {@link detectMimeFromBytes}). */
+export declare function sniffFileMime(file: File): Promise<string | undefined>;
+//# sourceMappingURL=sniff-file-type.d.ts.map

package/dist/utils/sniff-file-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sniff-file-type.d.ts","sourceRoot":"","sources":["../../src/utils/sniff-file-type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AA8EH,0EAA0E;AAC1E,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAYzE;AAuBD,yFAAyF;AACzF,wBAAsB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAI3E"}