@melite/formats 0.0.0-stage → 0.1.4-alpha

package/lib/npz.d.ts

@@ -0,0 +1,24 @@
+/**
+ * npz — minimal browser-side NPZ (NumPy ZIP) reader.
+ *
+ * NPZ files are ZIP archives whose entries are .npy arrays. NumPy's
+ * np.savez_compressed (what Kimodo emits) uses DEFLATE (ZIP method 8);
+ * np.savez uses stored (method 0). Both are handled here via the browser's
+ * native DecompressionStream — no dependency.
+ *
+ * Only the subset needed for motion preview is implemented: little-endian
+ * float32 / float64 arrays, 1-D through N-D. Integers / strings / big-endian
+ * are rejected with a clear error.
+ */
+export type NpyData = Float32Array | Int32Array | BigInt64Array | Uint32Array;
+export interface NpyArray {
+    shape: number[];
+    data: NpyData;
+}
+/**
+ * Parse an NPZ file and return a map of array-name → {shape, data}.
+ * Entry names have their `.npy` extension stripped (so `posed_joints.npy`
+ * is keyed as `"posed_joints"`).
+ */
+export declare function parseNpz(bytes: Uint8Array): Promise<Map<string, NpyArray>>;
+//# sourceMappingURL=npz.d.ts.map

package/lib/npz.js

@@ -0,0 +1,158 @@
+/**
+ * npz — minimal browser-side NPZ (NumPy ZIP) reader.
+ *
+ * NPZ files are ZIP archives whose entries are .npy arrays. NumPy's
+ * np.savez_compressed (what Kimodo emits) uses DEFLATE (ZIP method 8);
+ * np.savez uses stored (method 0). Both are handled here via the browser's
+ * native DecompressionStream — no dependency.
+ *
+ * Only the subset needed for motion preview is implemented: little-endian
+ * float32 / float64 arrays, 1-D through N-D. Integers / strings / big-endian
+ * are rejected with a clear error.
+ */
+// ── ZIP signatures (little-endian on disk: 50 4b 0x 0x) ───────────────────
+const CDFH_SIG = 0x02014b50; // central directory file header
+// LFH_SIG isn't checked — we trust the central directory's local-header offset.
+function readU16(d, o) {
+    return d[o] | (d[o + 1] << 8);
+}
+function readU32(d, o) {
+    return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16) | (d[o + 3] << 24)) >>> 0);
+}
+async function inflateRaw(compressed) {
+    // 'deflate-raw' = ZIP method 8 (raw DEFLATE, no zlib header/checksum).
+    // Supported in Chrome 103+, Firefox 113+, Safari 16.4+ — fine for a
+    // WebGL dev tool. Blob → stream → pipeThrough → arrayBuffer.
+    const ds = new DecompressionStream("deflate-raw");
+    const stream = new Blob([compressed]).stream().pipeThrough(ds);
+    const buf = await new Response(stream).arrayBuffer();
+    return new Uint8Array(buf);
+}
+/** Parse a single .npy file from its raw (decompressed) bytes. */
+function parseNpy(bytes) {
+    // Magic: \x93 N U M P Y  (6 bytes), then version major/minor, then header.
+    if (bytes.length < 10 ||
+        bytes[0] !== 0x93 || bytes[1] !== 0x4e || bytes[2] !== 0x55 ||
+        bytes[3] !== 0x4d || bytes[4] !== 0x50 || bytes[5] !== 0x59) {
+        throw new Error("Invalid .npy magic bytes");
+    }
+    // bytes[0..5] = magic, bytes[6] = major version, bytes[7] = minor version.
+    const ver = bytes[6];
+    let headerLen;
+    let headerOff;
+    if (ver <= 1) {
+        headerLen = readU16(bytes, 8);
+        headerOff = 10;
+    }
+    else {
+        headerLen = readU32(bytes, 8);
+        headerOff = 12;
+    }
+    const headerBytes = bytes.subarray(headerOff, headerOff + headerLen);
+    const header = new TextDecoder().decode(headerBytes);
+    const dataBytes = bytes.subarray(headerOff + headerLen);
+    const shapeMatch = header.match(/'shape':\s*\(([^)]*)\)/);
+    const dtypeMatch = header.match(/'descr':\s*'([^']+)'/);
+    if (!shapeMatch || !dtypeMatch) {
+        throw new Error(`Unparseable .npy header: ${header.slice(0, 120)}`);
+    }
+    const shape = shapeMatch[1]
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0)
+        .map(Number);
+    const dtype = dtypeMatch[1].trim();
+    // Copy the data bytes into a fresh, 4/8-byte-aligned ArrayBuffer so the
+    // typed-array view is always valid (the .npy data offset may not share
+    // alignment with the enclosing NPZ buffer).
+    const copy = new Uint8Array(dataBytes.length);
+    copy.set(dataBytes);
+    if (dtype === "<f4" || dtype === "|f4" || dtype === "=f4") {
+        return { shape, data: new Float32Array(copy.buffer, 0, Math.floor(copy.length / 4)) };
+    }
+    if (dtype === "<f8" || dtype === "|f8" || dtype === "=f8") {
+        const f64 = new Float64Array(copy.buffer, 0, Math.floor(copy.length / 8));
+        return { shape, data: new Float32Array(f64) };
+    }
+    // int32 (lbs_indices in the SOMA skin) and int64 (faces) — needed for the
+    // neutral soma skin NPZ. Uint32Array for int32 (face/idx values are
+    // non-negative), BigInt64Array for int64 (face indices can exceed 2^31 in
+    // large meshes; here max is 18056 so it fits, but keep the lossless path).
+    if (dtype === "<i4" || dtype === "|i4" || dtype === "=i4") {
+        const i32 = new Int32Array(copy.buffer, 0, Math.floor(copy.length / 4));
+        return { shape, data: new Uint32Array(i32) };
+    }
+    if (dtype === "<i8" || dtype === "|i8" || dtype === "=i8") {
+        return { shape, data: new BigInt64Array(copy.buffer, 0, Math.floor(copy.length / 8)) };
+    }
+    throw new Error(`Unsupported .npy dtype "${dtype}" (float32/64 + int32/64 supported)`);
+}
+/** Find the End-of-Central-Directory record, searching backward from EOF. */
+function findEocd(bytes) {
+    const min = Math.max(0, bytes.length - 22 - 65535);
+    for (let i = bytes.length - 22; i >= min; i--) {
+        if (bytes[i] === 0x50 && bytes[i + 1] === 0x4b &&
+            bytes[i + 2] === 0x05 && bytes[i + 3] === 0x06) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Parse an NPZ file and return a map of array-name → {shape, data}.
+ * Entry names have their `.npy` extension stripped (so `posed_joints.npy`
+ * is keyed as `"posed_joints"`).
+ */
+export async function parseNpz(bytes) {
+    const out = new Map();
+    const eocd = findEocd(bytes);
+    if (eocd < 0)
+        throw new Error("NPZ parse failed: End-of-Central-Directory not found");
+    const cdEntries = readU16(bytes, eocd + 10);
+    const cdOff = readU32(bytes, eocd + 16);
+    let off = cdOff;
+    for (let i = 0; i < cdEntries; i++) {
+        if (readU32(bytes, off) !== CDFH_SIG)
+            break;
+        const method = readU16(bytes, off + 10);
+        const compSize = readU32(bytes, off + 20);
+        const nameLen = readU16(bytes, off + 28);
+        const extraLen = readU16(bytes, off + 30);
+        const commentLen = readU16(bytes, off + 32);
+        const localOff = readU32(bytes, off + 42);
+        const name = new TextDecoder().decode(bytes.subarray(off + 46, off + 46 + nameLen));
+        // Read the local file header to find the true data offset (the central
+        // directory's compressed-size is authoritative; the local header's own
+        // size fields can be zero when the ZIP was streamed).
+        const lfhNameLen = readU16(bytes, localOff + 26);
+        const lfhExtraLen = readU16(bytes, localOff + 28);
+        const dataOff = localOff + 30 + lfhNameLen + lfhExtraLen;
+        const compressed = bytes.subarray(dataOff, dataOff + compSize);
+        let raw;
+        if (method === 0) {
+            raw = compressed; // stored, no compression
+        }
+        else if (method === 8) {
+            raw = await inflateRaw(compressed);
+        }
+        else {
+            throw new Error(`NPZ entry "${name}": unsupported compression method ${method}`);
+        }
+        if (name.endsWith(".npy")) {
+            const key = name.slice(0, -4); // strip ".npy"
+            // Skip entries with dtypes we don't handle (bool flags, int indices,
+            // string arrays — Kimodo packs metadata alongside the float arrays).
+            // The caller asks for specific keys (posed_joints, fps) and gets a
+            // clear error if those are missing; non-float metadata is irrelevant.
+            try {
+                out.set(key, parseNpy(raw));
+            }
+            catch {
+                /* unsupported dtype — skip */
+            }
+        }
+        off += 46 + nameLen + extraLen + commentLen;
+    }
+    return out;
+}
+//# sourceMappingURL=npz.js.map

package/lib/openPoseCanvas.d.ts

@@ -0,0 +1,17 @@
+/** openPoseCanvas — the COCO-18 stick-figure renderer (pure DOM canvas,
+ * ex-lib/text-to-pose). Fetch-free by law. */
+/**
+ * Render COCO-18 keypoints as an OpenPose-style stick figure on a canvas.
+ * Returns a PNG Blob.
+ *
+ * @param keypoints Flat array of 54 numbers (18 joints × [x, y, confidence])
+ * @param opts width, height, background, lineWidth, pointRadius
+ */
+export declare function renderOpenPoseCanvas(keypoints: number[], opts?: {
+    width?: number;
+    height?: number;
+    background?: string | "transparent";
+    lineWidth?: number;
+    pointRadius?: number;
+}): Blob;
+//# sourceMappingURL=openPoseCanvas.d.ts.map

package/lib/openPoseCanvas.js

@@ -0,0 +1,90 @@
+/** openPoseCanvas — the COCO-18 stick-figure renderer (pure DOM canvas,
+ * ex-lib/text-to-pose). Fetch-free by law. */
+// ── OpenPose canvas renderer ──────────────────────────────────────────────
+// Draws the COCO-18 stick figure on a 2D canvas with standard OpenPose colors.
+// Used for "OpenPose mode" export — alternative to the 3D mesh render.
+const OPENPOSE_SKELETON = [
+    // Limbs (purple/pink)
+    [0, 1], [0, 14], [0, 15], [1, 2], [1, 5],
+    [2, 3], [3, 4], [5, 6], [6, 7],
+    [8, 9], [9, 10], [11, 12], [12, 13],
+    [14, 16], [15, 17],
+    // Body trunk
+    [1, 8], [1, 11], [8, 11],
+];
+const OPENPOSE_COLORS = [
+    "#8B00FF", "#FF6B00", "#00FF6B", "#FFFF00", "#FFFFFF",
+];
+/**
+ * Render COCO-18 keypoints as an OpenPose-style stick figure on a canvas.
+ * Returns a PNG Blob.
+ *
+ * @param keypoints Flat array of 54 numbers (18 joints × [x, y, confidence])
+ * @param opts width, height, background, lineWidth, pointRadius
+ */
+export function renderOpenPoseCanvas(keypoints, opts = {}) {
+    const w = opts.width ?? 1024;
+    const h = opts.height ?? 1024;
+    const bg = opts.background ?? "transparent";
+    const lw = opts.lineWidth ?? 4;
+    const pr = opts.pointRadius ?? 5;
+    const canvas = document.createElement("canvas");
+    canvas.width = w;
+    canvas.height = h;
+    const ctx = canvas.getContext("2d");
+    // Background
+    if (bg === "transparent") {
+        ctx.clearRect(0, 0, w, h);
+    }
+    else {
+        ctx.fillStyle = bg;
+        ctx.fillRect(0, 0, w, h);
+    }
+    // Extract joint positions (keypoints are normalized 0..1 in SOMA space)
+    // pose-transforms renderCustomPose sends raw flat keypoints where
+    // x,y are in pixel coords already (1024×1024 space).
+    const pts = [];
+    for (let i = 0; i < 18; i++) {
+        const x = keypoints[i * 3];
+        const y = keypoints[i * 3 + 1];
+        const c = keypoints[i * 3 + 2];
+        pts.push({
+            x: typeof x === "number" && isFinite(x) ? (x / 1024) * w : -9999,
+            y: typeof y === "number" && isFinite(y) ? (y / 1024) * h : -9999,
+            c: typeof c === "number" ? c : 0,
+        });
+    }
+    // Draw limbs
+    ctx.lineCap = "round";
+    ctx.lineJoin = "round";
+    OPENPOSE_SKELETON.forEach(([a, b], idx) => {
+        const pa = pts[a], pb = pts[b];
+        if (pa.c < 0.1 || pb.c < 0.1)
+            return;
+        if (pa.x < 0 || pb.x < 0)
+            return;
+        ctx.strokeStyle = OPENPOSE_COLORS[idx % OPENPOSE_COLORS.length];
+        ctx.lineWidth = lw;
+        ctx.beginPath();
+        ctx.moveTo(pa.x, pa.y);
+        ctx.lineTo(pb.x, pb.y);
+        ctx.stroke();
+    });
+    // Draw joints
+    pts.forEach((p) => {
+        if (p.c < 0.1 || p.x < 0)
+            return;
+        ctx.fillStyle = "#00FFFF";
+        ctx.beginPath();
+        ctx.arc(p.x, p.y, pr, 0, Math.PI * 2);
+        ctx.fill();
+    });
+    // Return as blob (sync via toBlob needs callback, but we can use dataURL)
+    const dataUrl = canvas.toDataURL("image/png");
+    const bin = atob(dataUrl.split(",")[1]);
+    const bytes = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++)
+        bytes[i] = bin.charCodeAt(i);
+    return new Blob([bytes], { type: "image/png" });
+}
+//# sourceMappingURL=openPoseCanvas.js.map

package/lib/pngMeta.d.ts

@@ -0,0 +1,42 @@
+/**
+ * PNG tEXt chunk utilities — embed and parse metadata in PNG files.
+ *
+ * Compatible with the chunk layout ComfyUI uses (keys `workflow` and
+ * `prompt`), so images saved from Pose Studio can be dragged back in
+ * to recover the full generation state, and vice-versa.
+ *
+ * PNG chunk grammar:
+ *   chunk = [length:u32be][type:4 bytes][data:length][crc:u32be]
+ *   tEXt data = keyword (1-79 bytes, Latin-1) + 0x00 + text (Latin-1)
+ *
+ * We insert metadata chunks immediately after IHDR so they appear
+ * before IDAT — readers that scan only the file head will find them.
+ *
+ * JSON values are forced to ASCII (via \\uXXXX escapes for any code
+ * point above 0x7F) because the tEXt chunk is Latin-1: a raw UTF-8
+ * multibyte sequence would be mis-decoded as one byte == one char.
+ */
+/**
+ * Force JSON to pure ASCII by escaping any code point above 0x7F as
+ * \uXXXX. Keeps tEXt payloads spec-compliant (Latin-1) while preserving
+ * the full Unicode content for recovery.
+ */
+export declare function asciiJsonStringify(value: unknown): string;
+/**
+ * Embed key/value pairs as tEXt chunks in a PNG data: URL. Chunks are
+ * inserted immediately after IHDR. Returns the original URL unchanged
+ * if the input is not a valid PNG data URL or metadata is empty.
+ */
+export declare function embedPngText(dataUrl: string, metadata: Record<string, string>): string;
+/**
+ * Parse every tEXt chunk in a PNG data: URL into a {key: value} record.
+ * Also surfaces iTXt (uncompressed, UTF-8) if present. Last write wins
+ * on duplicate keys. Returns {} for non-PNG or unreadable input.
+ */
+export declare function parsePngText(dataUrl: string): Record<string, string>;
+/**
+ * Read the embedded `workflow` (or fallback `prompt`/`parameters`) JSON
+ * from a PNG data: URL. Returns the parsed object or null.
+ */
+export declare function readWorkflowFromPng(dataUrl: string): unknown | null;
+//# sourceMappingURL=pngMeta.d.ts.map

package/lib/pngMeta.js

@@ -0,0 +1,212 @@
+/**
+ * PNG tEXt chunk utilities — embed and parse metadata in PNG files.
+ *
+ * Compatible with the chunk layout ComfyUI uses (keys `workflow` and
+ * `prompt`), so images saved from Pose Studio can be dragged back in
+ * to recover the full generation state, and vice-versa.
+ *
+ * PNG chunk grammar:
+ *   chunk = [length:u32be][type:4 bytes][data:length][crc:u32be]
+ *   tEXt data = keyword (1-79 bytes, Latin-1) + 0x00 + text (Latin-1)
+ *
+ * We insert metadata chunks immediately after IHDR so they appear
+ * before IDAT — readers that scan only the file head will find them.
+ *
+ * JSON values are forced to ASCII (via \\uXXXX escapes for any code
+ * point above 0x7F) because the tEXt chunk is Latin-1: a raw UTF-8
+ * multibyte sequence would be mis-decoded as one byte == one char.
+ */
+const PNG_SIG = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+// ── CRC32 (IEEE 802.3 / PNG polynomial 0xedb88320) ─────────────────────────
+const CRC_TABLE = (() => {
+    const t = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++) {
+            c = (c & 1) ? (0xedb88320 ^ (c >>> 1)) : (c >>> 1);
+        }
+        t[n] = c >>> 0;
+    }
+    return t;
+})();
+function crc32(bytes) {
+    let c = 0xffffffff;
+    for (let i = 0; i < bytes.length; i++) {
+        c = CRC_TABLE[(c ^ bytes[i]) & 0xff] ^ (c >>> 8);
+    }
+    return (c ^ 0xffffffff) >>> 0;
+}
+function u32be(n) {
+    return new Uint8Array([(n >>> 24) & 0xff, (n >>> 16) & 0xff, (n >>> 8) & 0xff, n & 0xff]);
+}
+function buildChunk(type, data) {
+    const typeBytes = new Uint8Array(4);
+    for (let i = 0; i < 4; i++)
+        typeBytes[i] = type.charCodeAt(i);
+    const crcInput = new Uint8Array(typeBytes.length + data.length);
+    crcInput.set(typeBytes, 0);
+    crcInput.set(data, typeBytes.length);
+    const out = new Uint8Array(12 + data.length);
+    out.set(u32be(data.length), 0);
+    out.set(typeBytes, 4);
+    out.set(data, 8);
+    out.set(u32be(crc32(crcInput)), 8 + data.length);
+    return out;
+}
+function encodeLatin1(s) {
+    const out = new Uint8Array(s.length);
+    for (let i = 0; i < out.length; i++)
+        out[i] = s.charCodeAt(i) & 0xff;
+    return out;
+}
+// ── data: URL ⇄ bytes ──────────────────────────────────────────────────────
+function dataUrlToBytes(dataUrl) {
+    const comma = dataUrl.indexOf(",");
+    if (comma < 0)
+        return null;
+    const b64 = dataUrl.slice(comma + 1);
+    let bin;
+    try {
+        bin = atob(b64);
+    }
+    catch {
+        return null; // malformed base64 — caller handles null gracefully
+    }
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < out.length; i++)
+        out[i] = bin.charCodeAt(i);
+    return out;
+}
+function bytesToDataUrl(bytes) {
+    let binary = "";
+    // Chunked to avoid call-stack limits on large PNGs.
+    const CHUNK = 0x8000;
+    for (let i = 0; i < bytes.length; i += CHUNK) {
+        binary += String.fromCharCode.apply(null, bytes.subarray(i, Math.min(i + CHUNK, bytes.length)));
+    }
+    return `data:image/png;base64,${btoa(binary)}`;
+}
+// ── Public API ─────────────────────────────────────────────────────────────
+/**
+ * Force JSON to pure ASCII by escaping any code point above 0x7F as
+ * \uXXXX. Keeps tEXt payloads spec-compliant (Latin-1) while preserving
+ * the full Unicode content for recovery.
+ */
+export function asciiJsonStringify(value) {
+    return JSON.stringify(value).replace(/[\u007f-\uffff]/g, (c) => {
+        const hex = c.charCodeAt(0).toString(16);
+        return "\\u" + "0".repeat(4 - hex.length) + hex;
+    });
+}
+/**
+ * Embed key/value pairs as tEXt chunks in a PNG data: URL. Chunks are
+ * inserted immediately after IHDR. Returns the original URL unchanged
+ * if the input is not a valid PNG data URL or metadata is empty.
+ */
+export function embedPngText(dataUrl, metadata) {
+    if (Object.keys(metadata).length === 0)
+        return dataUrl;
+    const bytes = dataUrlToBytes(dataUrl);
+    if (!bytes || bytes.length < 8)
+        return dataUrl;
+    for (let i = 0; i < 8; i++)
+        if (bytes[i] !== PNG_SIG[i])
+            return dataUrl;
+    // IHDR is always the first chunk and always 13 bytes of data.
+    const ihdrLen = (bytes[8] << 24) | (bytes[9] << 16) | (bytes[10] << 8) | bytes[11];
+    const ihdrEnd = 8 + 8 + ihdrLen + 4; // sig + len+type + data + crc
+    const chunks = [];
+    for (const [key, val] of Object.entries(metadata)) {
+        if (!key)
+            continue;
+        const payload = encodeLatin1(`${key}\0${val}`);
+        chunks.push(buildChunk("tEXt", payload));
+    }
+    if (chunks.length === 0)
+        return dataUrl;
+    const before = bytes.subarray(0, ihdrEnd);
+    const after = bytes.subarray(ihdrEnd);
+    const total = before.length + after.length + chunks.reduce((s, c) => s + c.length, 0);
+    const out = new Uint8Array(total);
+    let off = 0;
+    out.set(before, off);
+    off += before.length;
+    for (const c of chunks) {
+        out.set(c, off);
+        off += c.length;
+    }
+    out.set(after, off);
+    return bytesToDataUrl(out);
+}
+/**
+ * Parse every tEXt chunk in a PNG data: URL into a {key: value} record.
+ * Also surfaces iTXt (uncompressed, UTF-8) if present. Last write wins
+ * on duplicate keys. Returns {} for non-PNG or unreadable input.
+ */
+export function parsePngText(dataUrl) {
+    const bytes = dataUrlToBytes(dataUrl);
+    if (!bytes || bytes.length < 8)
+        return {};
+    for (let i = 0; i < 8; i++)
+        if (bytes[i] !== PNG_SIG[i])
+            return {};
+    const out = {};
+    const latin1 = new TextDecoder("latin1");
+    const utf8 = new TextDecoder("utf-8");
+    let off = 8;
+    while (off + 8 <= bytes.length) {
+        const len = (bytes[off] << 24) | (bytes[off + 1] << 16) | (bytes[off + 2] << 8) | bytes[off + 3];
+        const type = latin1.decode(bytes.subarray(off + 4, off + 8));
+        const dataStart = off + 8;
+        const dataEnd = dataStart + len;
+        if (dataEnd > bytes.length)
+            break;
+        if (type === "tEXt") {
+            const payload = latin1.decode(bytes.subarray(dataStart, dataEnd));
+            const nul = payload.indexOf("\0");
+            if (nul > 0)
+                out[payload.slice(0, nul)] = payload.slice(nul + 1);
+        }
+        else if (type === "iTXt") {
+            // iTXt: keyword\0 compressionFlag(1) compressionMethod(1) lang\0 translated\0 text(UTF-8)
+            const payload = bytes.subarray(dataStart, dataEnd);
+            const nul = payload.indexOf(0);
+            if (nul > 0) {
+                const key = latin1.decode(payload.subarray(0, nul));
+                const flag = payload[nul + 1];
+                // Skip compression flag + method bytes, language tag, translated keyword
+                let p = nul + 3;
+                const nul2 = payload.indexOf(0, p);
+                const nul3 = nul2 >= 0 ? payload.indexOf(0, nul2 + 1) : -1;
+                if (nul3 >= 0 && flag === 0) {
+                    out[key] = utf8.decode(payload.subarray(nul3 + 1));
+                }
+            }
+        }
+        else if (type === "IEND") {
+            break;
+        }
+        off = dataEnd + 4;
+    }
+    return out;
+}
+/**
+ * Read the embedded `workflow` (or fallback `prompt`/`parameters`) JSON
+ * from a PNG data: URL. Returns the parsed object or null.
+ */
+export function readWorkflowFromPng(dataUrl) {
+    const chunks = parsePngText(dataUrl);
+    const raw = chunks["workflow"] ?? chunks["prompt"] ?? chunks["parameters"];
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch (e) {
+        // NO SILENT SWALLOW — embedded workflow JSON was malformed. Log so we
+        // know PNG-saved workflows are being silently dropped on import.
+        console.error('[pngMeta] readWorkflowFromPng: failed to parse embedded JSON:', e);
+        return null;
+    }
+}
+//# sourceMappingURL=pngMeta.js.map

package/lib/pngMetaInfo.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Minimal PNG tEXt chunk injector / reader.
+ *
+ * PNG format: 8-byte signature, then a sequence of chunks.
+ * Each chunk: [4-byte length][4-byte type][N-byte data][4-byte CRC].
+ * tEXt chunk data: <keyword>\0<text> (both Latin-1, no compression).
+ *
+ * We use the key "tech_noir" to store generation params as JSON.
+ */
+/** Inject generation params into a PNG as a tEXt chunk (inserted after IHDR). */
+export declare function injectPngMeta(b64: string, params: Record<string, unknown>): string;
+/** Read generation params from a PNG's tEXt chunk, or null if not present. */
+export declare function readPngMeta(b64OrDataUrl: string): Record<string, unknown> | null;
+//# sourceMappingURL=pngMetaInfo.d.ts.map