@majikah/majik-signature 0.6.0 → 0.7.1

package/dist/core/embed/fallback.d.ts

@@ -1,18 +1,134 @@
 /**
- * handlers/fallback.ts — Tier-2 universal trailer handler
+ * handlers/fallback.ts — Tier-2 universal trailer handler.
  *
- * Works on ANY file format. Appends a self-describing binary trailer:
- *   [original bytes][signature_json_utf8][8-byte length LE][8-byte magic]
+ * The universal fallback is the final embedding strategy used when no
+ * format-specific handler recognizes a file. It can therefore operate on
+ * arbitrary binary content without needing to understand the file format.
  *
- * Files remain valid for their primary use — most parsers ignore trailing bytes.
- * The magic bytes allow detection and clean stripping from any file.
+ * Trailer layout:
+ *   [original bytes]
+ *   [signature JSON encoded as UTF-8]
+ *   [8-byte payload length, little-endian]
+ *   [8-byte magic marker]
+ *
+ * @remarks
+ * The handler intentionally treats the signature payload as opaque JSON text.
+ * Format awareness, cryptographic signing, and signature verification remain
+ * outside this handler.
+ *
+ * The fallback is designed for formats whose parsers tolerate trailing bytes.
+ * That is a compatibility strategy, not a universal guarantee: some formats
+ * or downstream tools may reject, rewrite, truncate, or otherwise normalize
+ * trailing data. Prefer a native format handler when one is available and
+ * durable cross-tool interoperability matters.
+ *
+ * Embedding is idempotent. Before writing a new trailer, any existing
+ * universal trailer is removed so signatures do not accumulate back-to-back.
  */
 import { FormatHandler } from "../types";
+/**
+ * Last-resort {@link FormatHandler} that embeds signatures using the universal
+ * binary trailer format.
+ *
+ * @remarks
+ * `FallbackHandler` is intended to be registered after format-specific
+ * handlers. Its {@link canHandle} method always returns `true`, making this
+ * handler the universal catch-all for otherwise unsupported file types.
+ *
+ * The handler does not perform cryptographic operations itself. It only:
+ * - appends a serialized signature payload,
+ * - extracts that payload when the trailer is present, and
+ * - removes the trailer to recover the original bytes.
+ *
+ * The trailer is self-describing through its terminating magic bytes and
+ * length field, allowing extraction and stripping without knowing the file's
+ * MIME type or format.
+ *
+ * @example
+ * ```ts
+ * const handler = new FallbackHandler();
+ *
+ * const signed = await handler.embed(bytes, signatureJson);
+ * const extracted = await handler.extract(signed);
+ * const original = await handler.strip(signed);
+ * ```
+ *
+ * @see {@link FormatHandler}
+ */
 export declare class FallbackHandler implements FormatHandler {
+    /**
+     * Human-readable handler name used by the embedding pipeline and diagnostics.
+     */
     readonly name = "Fallback (Universal Trailer)";
+    /**
+     * MIME types accepted by this handler.
+     *
+     * @remarks
+     * Intentionally declares a catch-all rather than a concrete media
+     * type. Actual selection is still governed by handler ordering and
+     * `canHandle()`.
+     */
     readonly supportedMimeTypes: readonly ["*/*"];
+    /**
+     * Determine whether this handler can process the supplied content.
+     *
+     * @remarks
+     * This method always returns `true` because the universal trailer is the
+     * Tier-2 last-resort embedding mechanism. It should therefore remain the
+     * final handler in the handler-selection chain; placing it earlier would
+     * prevent more format-aware handlers from being selected.
+     *
+     * The byte content and MIME type are intentionally ignored.
+     *
+     * @param _bytes File bytes to inspect. Ignored by the fallback handler.
+     * @param _mimeType Optional MIME type hint. Ignored by the fallback handler.
+     * @returns Always `true`.
+     */
     canHandle(_bytes: Uint8Array, _mimeType?: string): boolean;
+    /**
+     * Embed a serialized signature payload using the universal trailer format.
+     *
+     * @remarks
+     * Any existing universal trailer is stripped before the new payload is
+     * appended. This makes repeated embedding idempotent: re-embedding replaces
+     * the existing fallback signature rather than stacking multiple trailers.
+     *
+     * The supplied `signatureJson` is treated as already-serialized signature
+     * data. This method does not parse, validate, or cryptographically verify
+     * it.
+     *
+     * @param bytes Original or previously signed file bytes.
+     * @param signatureJson Serialized signature envelope JSON to append.
+     * @returns The file bytes with exactly one universal signature trailer.
+     */
     embed(bytes: Uint8Array, signatureJson: string): Promise<Uint8Array>;
+    /**
+     * Extract the serialized signature payload from a universal trailer.
+     *
+     * @remarks
+     * Extraction is structural only. A non-null return value means a well-formed
+     * universal trailer was found; it does not mean that the contained signature
+     * is cryptographically valid or trusted.
+     *
+     * @param bytes File bytes that may contain a universal trailer.
+     * @returns The serialized signature JSON when a valid trailer is present;
+     * otherwise `null`.
+     */
     extract(bytes: Uint8Array): Promise<string | null>;
+    /**
+     * Remove the universal trailer and recover the original file bytes.
+     *
+     * @remarks
+     * If no recognizable universal trailer is present, the input bytes are
+     * returned unchanged.
+     *
+     * This operation only removes the trailer produced by the universal
+     * fallback format. It does not remove signatures embedded by native,
+     * format-specific handlers.
+     *
+     * @param bytes File bytes that may contain a universal trailer.
+     * @returns The original bytes when a trailer is found; otherwise the
+     * unchanged input bytes.
+     */
     strip(bytes: Uint8Array): Promise<Uint8Array>;
 }

package/dist/core/embed/fallback.js

@@ -1,29 +1,145 @@
 /**
- * handlers/fallback.ts — Tier-2 universal trailer handler
+ * handlers/fallback.ts — Tier-2 universal trailer handler.
  *
- * Works on ANY file format. Appends a self-describing binary trailer:
- *   [original bytes][signature_json_utf8][8-byte length LE][8-byte magic]
+ * The universal fallback is the final embedding strategy used when no
+ * format-specific handler recognizes a file. It can therefore operate on
+ * arbitrary binary content without needing to understand the file format.
  *
- * Files remain valid for their primary use — most parsers ignore trailing bytes.
- * The magic bytes allow detection and clean stripping from any file.
+ * Trailer layout:
+ *   [original bytes]
+ *   [signature JSON encoded as UTF-8]
+ *   [8-byte payload length, little-endian]
+ *   [8-byte magic marker]
+ *
+ * @remarks
+ * The handler intentionally treats the signature payload as opaque JSON text.
+ * Format awareness, cryptographic signing, and signature verification remain
+ * outside this handler.
+ *
+ * The fallback is designed for formats whose parsers tolerate trailing bytes.
+ * That is a compatibility strategy, not a universal guarantee: some formats
+ * or downstream tools may reject, rewrite, truncate, or otherwise normalize
+ * trailing data. Prefer a native format handler when one is available and
+ * durable cross-tool interoperability matters.
+ *
+ * Embedding is idempotent. Before writing a new trailer, any existing
+ * universal trailer is removed so signatures do not accumulate back-to-back.
  */
 import { appendTrailer, extractTrailer } from "./utils";
+/**
+ * Last-resort {@link FormatHandler} that embeds signatures using the universal
+ * binary trailer format.
+ *
+ * @remarks
+ * `FallbackHandler` is intended to be registered after format-specific
+ * handlers. Its {@link canHandle} method always returns `true`, making this
+ * handler the universal catch-all for otherwise unsupported file types.
+ *
+ * The handler does not perform cryptographic operations itself. It only:
+ * - appends a serialized signature payload,
+ * - extracts that payload when the trailer is present, and
+ * - removes the trailer to recover the original bytes.
+ *
+ * The trailer is self-describing through its terminating magic bytes and
+ * length field, allowing extraction and stripping without knowing the file's
+ * MIME type or format.
+ *
+ * @example
+ * ```ts
+ * const handler = new FallbackHandler();
+ *
+ * const signed = await handler.embed(bytes, signatureJson);
+ * const extracted = await handler.extract(signed);
+ * const original = await handler.strip(signed);
+ * ```
+ *
+ * @see {@link FormatHandler}
+ */
 export class FallbackHandler {
+    /**
+     * Human-readable handler name used by the embedding pipeline and diagnostics.
+     */
     name = "Fallback (Universal Trailer)";
+    /**
+     * MIME types accepted by this handler.
+     *
+     * @remarks
+     * Intentionally declares a catch-all rather than a concrete media
+     * type. Actual selection is still governed by handler ordering and
+     * `canHandle()`.
+     */
     supportedMimeTypes = ["*/*"];
+    /**
+     * Determine whether this handler can process the supplied content.
+     *
+     * @remarks
+     * This method always returns `true` because the universal trailer is the
+     * Tier-2 last-resort embedding mechanism. It should therefore remain the
+     * final handler in the handler-selection chain; placing it earlier would
+     * prevent more format-aware handlers from being selected.
+     *
+     * The byte content and MIME type are intentionally ignored.
+     *
+     * @param _bytes File bytes to inspect. Ignored by the fallback handler.
+     * @param _mimeType Optional MIME type hint. Ignored by the fallback handler.
+     * @returns Always `true`.
+     */
     canHandle(_bytes, _mimeType) {
         // Always handles — it's the last resort
         return true;
     }
+    /**
+     * Embed a serialized signature payload using the universal trailer format.
+     *
+     * @remarks
+     * Any existing universal trailer is stripped before the new payload is
+     * appended. This makes repeated embedding idempotent: re-embedding replaces
+     * the existing fallback signature rather than stacking multiple trailers.
+     *
+     * The supplied `signatureJson` is treated as already-serialized signature
+     * data. This method does not parse, validate, or cryptographically verify
+     * it.
+     *
+     * @param bytes Original or previously signed file bytes.
+     * @param signatureJson Serialized signature envelope JSON to append.
+     * @returns The file bytes with exactly one universal signature trailer.
+     */
     async embed(bytes, signatureJson) {
         // Strip any existing trailer first (idempotent)
         const stripped = await this.strip(bytes);
         return appendTrailer(stripped, signatureJson);
     }
+    /**
+     * Extract the serialized signature payload from a universal trailer.
+     *
+     * @remarks
+     * Extraction is structural only. A non-null return value means a well-formed
+     * universal trailer was found; it does not mean that the contained signature
+     * is cryptographically valid or trusted.
+     *
+     * @param bytes File bytes that may contain a universal trailer.
+     * @returns The serialized signature JSON when a valid trailer is present;
+     * otherwise `null`.
+     */
     async extract(bytes) {
         const result = extractTrailer(bytes);
         return result ? result.signatureJson : null;
     }
+    /**
+     * Remove the universal trailer and recover the original file bytes.
+     *
+     * @remarks
+     * If no recognizable universal trailer is present, the input bytes are
+     * returned unchanged.
+     *
+     * This operation only removes the trailer produced by the universal
+     * fallback format. It does not remove signatures embedded by native,
+     * format-specific handlers.
+     *
+     * @param bytes File bytes that may contain a universal trailer.
+     * @returns The original bytes when a trailer is found; otherwise the
+     * unchanged input bytes.
+     */
     async strip(bytes) {
         const result = extractTrailer(bytes);
         return result ? result.original : bytes;

package/dist/core/embed/handlers/flac.d.ts

@@ -1,17 +1,13 @@
 /**
  * handlers/flac.ts — FLAC handler
  *
- * FLAC files start with "fLaC" and a series of metadata blocks before audio frames.
- * We embed in a VORBIS_COMMENT block (block type 4) using a standard key=value pair:
- *   MAJIK-SIGNATURE=<json>
+ * FLAC files start with "fLaC" (4 bytes) followed by one or more metadata blocks.
+ * Each metadata block header (4 bytes):
+ *   [1B: is_last (1 bit) + block_type (7 bits)]
+ *   [3B: 24-bit big-endian length]
  *
- * FLAC metadata block header:
- *   [1B: last-block flag (7) | block_type (7)][3B: block_length]
- *
- * VORBIS_COMMENT format (all LE):
- *   [4B vendor_length][vendor_string]
- *   [4B comment_count]
- *   [4B comment_length][comment_utf8] × comment_count
+ * We embed signatures using an APPLICATION block (type = 2) with 4-byte
+ * application ID "MAJK" followed by the signature JSON payload.
  */
 import { FormatHandler } from "../../types";
 export declare class FlacHandler implements FormatHandler {
@@ -21,9 +17,7 @@ export declare class FlacHandler implements FormatHandler {
     embed(bytes: Uint8Array, signatureJson: string): Promise<Uint8Array>;
     extract(bytes: Uint8Array): Promise<string | null>;
     strip(bytes: Uint8Array): Promise<Uint8Array>;
-    private _parseBlocks;
-    private _serializeBlocks;
-    private _buildVorbisComment;
-    private _serializeVorbisComment;
-    private _readVorbisComment;
+    private _parseMetadata;
+    private _buildMetadataBlock;
+    private _validateAudioStream;
 }

package/dist/core/embed/handlers/flac.js

@@ -1,24 +1,27 @@
 /**
  * handlers/flac.ts — FLAC handler
  *
- * FLAC files start with "fLaC" and a series of metadata blocks before audio frames.
- * We embed in a VORBIS_COMMENT block (block type 4) using a standard key=value pair:
- *   MAJIK-SIGNATURE=<json>
+ * FLAC files start with "fLaC" (4 bytes) followed by one or more metadata blocks.
+ * Each metadata block header (4 bytes):
+ *   [1B: is_last (1 bit) + block_type (7 bits)]
+ *   [3B: 24-bit big-endian length]
  *
- * FLAC metadata block header:
- *   [1B: last-block flag (7) | block_type (7)][3B: block_length]
- *
- * VORBIS_COMMENT format (all LE):
- *   [4B vendor_length][vendor_string]
- *   [4B comment_count]
- *   [4B comment_length][comment_utf8] × comment_count
+ * We embed signatures using an APPLICATION block (type = 2) with 4-byte
+ * application ID "MAJK" followed by the signature JSON payload.
  */
-import { concatBytes, readUint32LE, textDecode, textEncode, writeUint32LE, } from "../utils";
+import { concatBytes, textDecode, textEncode } from "../utils";
 const FLAC_MAGIC = textEncode("fLaC");
-const BLOCK_TYPE_STREAMINFO = 0;
-const BLOCK_TYPE_VORBIS_COMMENT = 4;
-const VENDOR_STRING = "MajikSignatureEmbed/1.0";
-const COMMENT_KEY = "MAJIK-SIGNATURE";
+const APPLICATION_ID = textEncode("MAJK"); // 4-byte custom Application ID
+var FlacBlockType;
+(function (FlacBlockType) {
+    FlacBlockType[FlacBlockType["STREAMINFO"] = 0] = "STREAMINFO";
+    FlacBlockType[FlacBlockType["PADDING"] = 1] = "PADDING";
+    FlacBlockType[FlacBlockType["APPLICATION"] = 2] = "APPLICATION";
+    FlacBlockType[FlacBlockType["SEEKTABLE"] = 3] = "SEEKTABLE";
+    FlacBlockType[FlacBlockType["VORBIS_COMMENT"] = 4] = "VORBIS_COMMENT";
+    FlacBlockType[FlacBlockType["CUESHEET"] = 5] = "CUESHEET";
+    FlacBlockType[FlacBlockType["PICTURE"] = 6] = "PICTURE";
+})(FlacBlockType || (FlacBlockType = {}));
 export class FlacHandler {
     name = "FLAC";
     supportedMimeTypes = ["audio/flac", "audio/x-flac"];
@@ -27,40 +30,44 @@ export class FlacHandler {
             return true;
         if (bytes.length < 4)
             return false;
-        return textDecode(bytes.slice(0, 4)) === "fLaC";
+        return (bytes[0] === 0x66 && // 'f'
+            bytes[1] === 0x4c && // 'L'
+            bytes[2] === 0x61 && // 'a'
+            bytes[3] === 0x43 // 'C'
+        );
     }
     async embed(bytes, signatureJson) {
         const clean = await this.strip(bytes);
-        const blocks = this._parseBlocks(clean);
-        // Build a new VORBIS_COMMENT block with our signature
-        const commentBlockData = this._buildVorbisComment(signatureJson);
-        // Find existing VORBIS_COMMENT block index, or insert after STREAMINFO
-        const vcIdx = blocks.findIndex((b) => b.type === BLOCK_TYPE_VORBIS_COMMENT);
-        const insertAt = vcIdx >= 0 ? vcIdx : 1; // after STREAMINFO
-        const newBlocks = [...blocks];
-        const newBlock = {
-            type: BLOCK_TYPE_VORBIS_COMMENT,
-            data: commentBlockData,
-        };
-        if (vcIdx >= 0) {
-            newBlocks[vcIdx] = newBlock;
-        }
-        else {
-            newBlocks.splice(insertAt, 0, newBlock);
-        }
-        return this._serializeBlocks(newBlocks, clean);
+        const { blocks, audioData } = this._parseMetadata(clean);
+        // Build signature APPLICATION payload: [4B App ID "MAJK"][signature JSON]
+        const appPayload = concatBytes(APPLICATION_ID, textEncode(signatureJson));
+        // Safely clear the isLast flag bit on all existing metadata blocks
+        const updatedBlocks = blocks.map((b) => {
+            const newBlock = new Uint8Array(b.raw);
+            newBlock[0] &= 0x7f; // Clear bit 7 (isLast)
+            return newBlock;
+        });
+        // Append our new APPLICATION metadata block marked as isLast = true
+        const sigBlock = this._buildMetadataBlock(FlacBlockType.APPLICATION, appPayload, true);
+        return concatBytes(FLAC_MAGIC, ...updatedBlocks, sigBlock, audioData);
     }
     async extract(bytes) {
         if (!this.canHandle(bytes))
             return null;
         try {
-            const blocks = this._parseBlocks(bytes);
+            const { blocks, audioData, endOffset } = this._parseMetadata(bytes);
+            // Verify overall stream integrity and ensure no trailing garbage was appended
+            if (!this._validateAudioStream(audioData, bytes.length - endOffset)) {
+                return null;
+            }
             for (const block of blocks) {
-                if (block.type === BLOCK_TYPE_VORBIS_COMMENT) {
-                    const comments = this._readVorbisComment(block.data);
-                    for (const comment of comments) {
-                        if (comment.key === COMMENT_KEY)
-                            return comment.value;
+                if (block.type === FlacBlockType.APPLICATION &&
+                    block.data.length >= 4) {
+                    const appId = textDecode(block.data.slice(0, 4));
+                    // Inside FlacHandler.extract()
+                    if (appId === "MAJK") {
+                        const jsonStr = textDecode(block.data.slice(4));
+                        return jsonStr.replace(/\0+$/, ""); // Strip trailing null padding if present
                     }
                 }
             }
@@ -74,114 +81,91 @@ export class FlacHandler {
         if (!this.canHandle(bytes))
             return bytes;
         try {
-            const blocks = this._parseBlocks(bytes);
-            const filtered = blocks.map((b) => {
-                if (b.type !== BLOCK_TYPE_VORBIS_COMMENT)
-                    return b;
-                // Rebuild without our comment
-                const comments = this._readVorbisComment(b.data);
-                const kept = comments.filter((c) => c.key !== COMMENT_KEY);
-                return {
-                    type: BLOCK_TYPE_VORBIS_COMMENT,
-                    data: this._serializeVorbisComment(kept),
-                };
+            const { blocks, audioData } = this._parseMetadata(bytes);
+            // Filter out MAJK application metadata blocks
+            const kept = blocks.filter((b) => {
+                if (b.type !== FlacBlockType.APPLICATION)
+                    return true;
+                if (b.data.length < 4)
+                    return true;
+                const appId = textDecode(b.data.slice(0, 4));
+                return appId !== "MAJK";
+            });
+            // Return original buffer unmodified if no signature block was found
+            if (kept.length === blocks.length) {
+                return bytes;
+            }
+            // Reconstruct metadata blocks and restore is_last bit on the final block
+            const rebuiltBlocks = kept.map((b, index) => {
+                const isLast = index === kept.length - 1;
+                const header = new Uint8Array(b.raw.slice(0, 4));
+                if (isLast) {
+                    header[0] |= 0x80; // Set bit 7 to 1
+                }
+                else {
+                    header[0] &= 0x7f; // Clear bit 7 to 0
+                }
+                return concatBytes(header, b.data);
             });
-            return this._serializeBlocks(filtered, bytes);
+            return concatBytes(FLAC_MAGIC, ...rebuiltBlocks, audioData);
         }
         catch {
             return bytes;
         }
     }
-    // ─── Block Parser ────────────────────────────────────────────────────────────
-    _parseBlocks(bytes) {
+    // ─── Helpers ─────────────────────────────────────────────────────────────
+    _parseMetadata(bytes) {
+        if (bytes.length < 4 || textDecode(bytes.slice(0, 4)) !== "fLaC") {
+            throw new Error("Invalid FLAC magic header");
+        }
         const blocks = [];
-        let offset = 4; // skip "fLaC"
-        while (offset + 4 <= bytes.length) {
-            const header = bytes[offset];
-            const isLast = (header & 0x80) !== 0;
-            const blockType = header & 0x7f;
+        let offset = 4;
+        while (offset < bytes.length) {
+            if (offset + 4 > bytes.length) {
+                throw new Error("Truncated metadata block header");
+            }
+            const headerByte = bytes[offset];
+            const isLast = (headerByte & 0x80) !== 0;
+            const type = headerByte & 0x7f;
+            // 24-bit big-endian integer reading
             const length = (bytes[offset + 1] << 16) |
                 (bytes[offset + 2] << 8) |
                 bytes[offset + 3];
+            if (offset + 4 + length > bytes.length) {
+                throw new Error("Truncated metadata block payload");
+            }
             const data = bytes.slice(offset + 4, offset + 4 + length);
-            blocks.push({ type: blockType, data });
+            const raw = bytes.slice(offset, offset + 4 + length);
+            blocks.push({ isLast, type, data, raw });
             offset += 4 + length;
             if (isLast)
                 break;
         }
-        return blocks;
-    }
-    _serializeBlocks(blocks, originalBytes) {
-        // Find where audio data starts in original
-        let audioOffset = 4;
-        let offset = 4;
-        while (offset + 4 <= originalBytes.length) {
-            const header = originalBytes[offset];
-            const isLast = (header & 0x80) !== 0;
-            const length = (originalBytes[offset + 1] << 16) |
-                (originalBytes[offset + 2] << 8) |
-                originalBytes[offset + 3];
-            audioOffset = offset + 4 + length;
-            offset = audioOffset;
-            if (isLast)
-                break;
-        }
-        const audioData = originalBytes.slice(audioOffset);
-        const serialized = [FLAC_MAGIC];
-        for (let i = 0; i < blocks.length; i++) {
-            const isLast = i === blocks.length - 1;
-            const { type, data } = blocks[i];
-            const header = (isLast ? 0x80 : 0x00) | (type & 0x7f);
-            const length = data.length;
-            const headerBytes = new Uint8Array([
-                header,
-                (length >> 16) & 0xff,
-                (length >> 8) & 0xff,
-                length & 0xff,
-            ]);
-            serialized.push(concatBytes(headerBytes, data));
-        }
-        serialized.push(audioData);
-        return concatBytes(...serialized);
-    }
-    // ─── Vorbis Comment Helpers ──────────────────────────────────────────────────
-    _buildVorbisComment(signatureJson) {
-        const comments = [{ key: COMMENT_KEY, value: signatureJson }];
-        return this._serializeVorbisComment(comments);
+        const audioData = bytes.slice(offset);
+        return { blocks, audioData, endOffset: offset };
     }
-    _serializeVorbisComment(comments) {
-        const vendor = textEncode(VENDOR_STRING);
-        const vendorLength = writeUint32LE(vendor.length);
-        const commentCount = writeUint32LE(comments.length);
-        const commentEntries = comments.map(({ key, value }) => {
-            const entry = textEncode(`${key}=${value}`);
-            return concatBytes(writeUint32LE(entry.length), entry);
-        });
-        return concatBytes(vendorLength, vendor, commentCount, ...commentEntries);
+    _buildMetadataBlock(type, data, isLast) {
+        const header = new Uint8Array(4);
+        // Byte 0: [is_last (1 bit)][block_type (7 bits)]
+        header[0] = (isLast ? 0x80 : 0x00) | (type & 0x7f);
+        // Bytes 1–3: 24-bit big-endian payload size
+        header[1] = (data.length >> 16) & 0xff;
+        header[2] = (data.length >> 8) & 0xff;
+        header[3] = data.length & 0xff;
+        return concatBytes(header, data);
     }
-    _readVorbisComment(data) {
-        const comments = [];
-        let offset = 0;
-        const vendorLength = readUint32LE(data, offset);
-        offset += 4 + vendorLength;
-        const count = readUint32LE(data, offset);
-        offset += 4;
-        for (let i = 0; i < count; i++) {
-            if (offset + 4 > data.length)
-                break;
-            const length = readUint32LE(data, offset);
-            offset += 4;
-            const comment = textDecode(data.slice(offset, offset + length));
-            offset += length;
-            const eqIdx = comment.indexOf("=");
-            if (eqIdx >= 0) {
-                comments.push({
-                    key: comment.slice(0, eqIdx).toUpperCase(),
-                    value: comment.slice(eqIdx + 1),
-                });
+    _validateAudioStream(audioData, expectedAudioBytes) {
+        if (audioData.length !== expectedAudioBytes)
+            return false;
+        if (audioData.length === 0)
+            return true;
+        // Validate initial audio frame sync code (14 bits: 11111111 111110xx)
+        if (audioData.length >= 2) {
+            if (audioData[0] !== 0xff || (audioData[1] & 0xfc) !== 0xf8) {
+                return false;
             }
         }
-        return comments;
+        return true;
     }
 }
 // Freeze static methods

package/dist/core/embed/handlers/index.d.ts

@@ -0,0 +1,10 @@
+export { PdfHandler } from "./pdf";
+export { PngHandler } from "./png";
+export { JpegHandler } from "./jpeg";
+export { WavHandler } from "./wav";
+export { Mp3Handler } from "./mp3";
+export { Mp4Handler } from "./mp4";
+export { FlacHandler } from "./flac";
+export { MkvHandler } from "./mkv";
+export { OfficeHandler } from "./office";
+export { TextHandler } from "./text";

package/dist/core/embed/handlers/index.js

@@ -0,0 +1,10 @@
+export { PdfHandler } from "./pdf";
+export { PngHandler } from "./png";
+export { JpegHandler } from "./jpeg";
+export { WavHandler } from "./wav";
+export { Mp3Handler } from "./mp3";
+export { Mp4Handler } from "./mp4";
+export { FlacHandler } from "./flac";
+export { MkvHandler } from "./mkv";
+export { OfficeHandler } from "./office";
+export { TextHandler } from "./text";