@fideus-labs/fiff 0.1.2 → 0.2.0

package/dist/ome-xml-writer.js

@@ -0,0 +1,210 @@
+// SPDX-FileCopyrightText: Copyright (c) Fideus Labs LLC
+// SPDX-License-Identifier: MIT
+import { zarrToOmePixelType } from "./dtypes.js";
+/**
+ * Generate an OME-XML metadata string from a Multiscales object.
+ *
+ * @param multiscales - The ngff-zarr Multiscales to generate XML for.
+ * @param dtype - The Zarr data type of the pixel data.
+ * @param options - Writer options.
+ * @returns A complete OME-XML string suitable for a TIFF ImageDescription tag.
+ */
+export function buildOmeXml(multiscales, dtype, options = {}) {
+    const dimensionOrder = options.dimensionOrder ?? "XYZCT";
+    const creator = options.creator ?? "fiff";
+    const dims = extractDimensions(multiscales);
+    const omeType = zarrToOmePixelType(dtype);
+    const imageName = options.imageName ?? multiscales.metadata.name ?? "image";
+    const channels = buildChannelElements(multiscales, dims.sizeC);
+    const physAttrs = buildPhysicalSizeAttrs(dims);
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<OME xmlns="http://www.openmicroscopy.org/Schemas/OME/2016-06"
+     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+     xsi:schemaLocation="http://www.openmicroscopy.org/Schemas/OME/2016-06
+       http://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd"
+     Creator="${escapeXml(creator)}">
+  <Image ID="Image:0" Name="${escapeXml(imageName)}">
+    <Pixels ID="Pixels:0" DimensionOrder="${dimensionOrder}" Type="${omeType}"
+            SizeX="${dims.sizeX}" SizeY="${dims.sizeY}" SizeZ="${dims.sizeZ}" SizeC="${dims.sizeC}" SizeT="${dims.sizeT}"
+            BigEndian="false"${physAttrs}>
+${channels}      <TiffData/>
+    </Pixels>
+  </Image>
+</OME>`;
+}
+/**
+ * Extract dimension sizes and physical sizes from a Multiscales object.
+ * Uses the highest-resolution image (images[0]).
+ */
+export function extractDimensions(multiscales) {
+    const image = multiscales.images[0];
+    const shape = image.data.shape;
+    const dimNames = image.dims;
+    const info = {
+        sizeX: 1,
+        sizeY: 1,
+        sizeZ: 1,
+        sizeC: 1,
+        sizeT: 1,
+    };
+    for (let i = 0; i < dimNames.length; i++) {
+        const dim = dimNames[i];
+        switch (dim) {
+            case "x":
+                info.sizeX = shape[i];
+                break;
+            case "y":
+                info.sizeY = shape[i];
+                break;
+            case "z":
+                info.sizeZ = shape[i];
+                break;
+            case "c":
+                info.sizeC = shape[i];
+                break;
+            case "t":
+                info.sizeT = shape[i];
+                break;
+        }
+    }
+    // Extract physical sizes from scale and units
+    const axes = multiscales.metadata.axes;
+    for (const axis of axes) {
+        const scaleFactor = image.scale[axis.name];
+        if (scaleFactor === undefined || scaleFactor <= 0)
+            continue;
+        const unit = axis.unit ? ngffUnitToOmeUnit(axis.unit) : undefined;
+        switch (axis.name) {
+            case "x":
+                info.physicalSizeX = scaleFactor;
+                info.physicalSizeXUnit = unit;
+                break;
+            case "y":
+                info.physicalSizeY = scaleFactor;
+                info.physicalSizeYUnit = unit;
+                break;
+            case "z":
+                info.physicalSizeZ = scaleFactor;
+                info.physicalSizeZUnit = unit;
+                break;
+        }
+    }
+    return info;
+}
+// ── Internal helpers ────────────────────────────────────────────────
+/**
+ * Build <Channel> XML elements from Multiscales omero metadata.
+ * Falls back to generic channel names if omero metadata is not available.
+ */
+function buildChannelElements(multiscales, sizeC) {
+    const omero = multiscales.metadata.omero;
+    const lines = [];
+    for (let c = 0; c < sizeC; c++) {
+        const omeroChannel = omero?.channels?.[c];
+        const name = omeroChannel?.label ?? `Ch${c}`;
+        const colorAttr = omeroChannel
+            ? ` Color="${hexColorToOmeInt(omeroChannel.color)}"`
+            : "";
+        lines.push(`      <Channel ID="Channel:0:${c}" Name="${escapeXml(name)}" SamplesPerPixel="1"${colorAttr}/>`);
+    }
+    return lines.length > 0 ? lines.join("\n") + "\n" : "";
+}
+/**
+ * Build physical size XML attributes string.
+ */
+function buildPhysicalSizeAttrs(dims) {
+    let attrs = "";
+    if (dims.physicalSizeX !== undefined) {
+        attrs += ` PhysicalSizeX="${dims.physicalSizeX}"`;
+        if (dims.physicalSizeXUnit) {
+            attrs += ` PhysicalSizeXUnit="${escapeXml(dims.physicalSizeXUnit)}"`;
+        }
+    }
+    if (dims.physicalSizeY !== undefined) {
+        attrs += ` PhysicalSizeY="${dims.physicalSizeY}"`;
+        if (dims.physicalSizeYUnit) {
+            attrs += ` PhysicalSizeYUnit="${escapeXml(dims.physicalSizeYUnit)}"`;
+        }
+    }
+    if (dims.physicalSizeZ !== undefined) {
+        attrs += ` PhysicalSizeZ="${dims.physicalSizeZ}"`;
+        if (dims.physicalSizeZUnit) {
+            attrs += ` PhysicalSizeZUnit="${escapeXml(dims.physicalSizeZUnit)}"`;
+        }
+    }
+    return attrs;
+}
+/**
+ * Convert a 6-digit hex color string (e.g. "FF0000") to a signed 32-bit RGBA int.
+ * Alpha defaults to 0xFF.
+ */
+export function hexColorToOmeInt(hex) {
+    // Strip leading # if present
+    const h = hex.startsWith("#") ? hex.slice(1) : hex;
+    // Parse as RGBA (alpha defaults to FF)
+    const r = parseInt(h.substring(0, 2), 16);
+    const g = parseInt(h.substring(2, 4), 16);
+    const b = parseInt(h.substring(4, 6), 16);
+    const a = h.length >= 8 ? parseInt(h.substring(6, 8), 16) : 0xff;
+    // Combine as RGBA and convert to signed 32-bit int
+    const unsigned = ((r << 24) | (g << 16) | (b << 8) | a) >>> 0;
+    return unsigned > 0x7fffffff ? unsigned - 0x100000000 : unsigned;
+}
+/**
+ * Convert an OME signed 32-bit RGBA int to a 6-digit hex color string.
+ */
+export function omeIntToHexColor(value) {
+    const unsigned = value < 0 ? value + 0x100000000 : value;
+    const r = (unsigned >>> 24) & 0xff;
+    const g = (unsigned >>> 16) & 0xff;
+    const b = (unsigned >>> 8) & 0xff;
+    return (r.toString(16).padStart(2, "0") +
+        g.toString(16).padStart(2, "0") +
+        b.toString(16).padStart(2, "0")).toUpperCase();
+}
+/**
+ * Map NGFF unit names to OME-XML PhysicalSize unit symbols.
+ *
+ * NGFF uses full names (e.g. "micrometer"), OME-XML uses symbols (e.g. "µm").
+ */
+function ngffUnitToOmeUnit(unit) {
+    const map = {
+        angstrom: "\u00C5",
+        attometer: "am",
+        centimeter: "cm",
+        decimeter: "dm",
+        exameter: "Em",
+        femtometer: "fm",
+        foot: "ft",
+        gigameter: "Gm",
+        hectometer: "hm",
+        inch: "in",
+        kilometer: "km",
+        megameter: "Mm",
+        meter: "m",
+        micrometer: "\u00B5m",
+        mile: "mi",
+        millimeter: "mm",
+        nanometer: "nm",
+        parsec: "pc",
+        petameter: "Pm",
+        picometer: "pm",
+        terameter: "Tm",
+        yard: "yd",
+        yoctometer: "ym",
+        yottameter: "Ym",
+        zeptometer: "zm",
+        zettameter: "Zm",
+    };
+    return map[unit] ?? unit;
+}
+/** Escape XML special characters. */
+function escapeXml(str) {
+    return str
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+//# sourceMappingURL=ome-xml-writer.js.map

package/dist/ome-xml-writer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ome-xml-writer.js","sourceRoot":"","sources":["../src/ome-xml-writer.ts"],"names":[],"mappings":"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"}

package/dist/tiff-writer.d.ts

@@ -0,0 +1,65 @@
+/** TIFF tag data types and their byte sizes. */
+export declare const TIFF_TYPE_BYTE = 1;
+export declare const TIFF_TYPE_ASCII = 2;
+export declare const TIFF_TYPE_SHORT = 3;
+export declare const TIFF_TYPE_LONG = 4;
+export declare const TIFF_TYPE_RATIONAL = 5;
+/** Well-known TIFF tags. */
+export declare const TAG_NEW_SUBFILE_TYPE = 254;
+export declare const TAG_IMAGE_WIDTH = 256;
+export declare const TAG_IMAGE_LENGTH = 257;
+export declare const TAG_BITS_PER_SAMPLE = 258;
+export declare const TAG_COMPRESSION = 259;
+export declare const TAG_PHOTOMETRIC = 262;
+export declare const TAG_IMAGE_DESCRIPTION = 270;
+export declare const TAG_STRIP_OFFSETS = 273;
+export declare const TAG_SAMPLES_PER_PIXEL = 277;
+export declare const TAG_ROWS_PER_STRIP = 278;
+export declare const TAG_STRIP_BYTE_COUNTS = 279;
+export declare const TAG_PLANAR_CONFIGURATION = 284;
+export declare const TAG_SAMPLE_FORMAT = 339;
+export declare const TAG_SUB_IFDS = 330;
+/** TIFF compression codes. */
+export declare const COMPRESSION_NONE = 1;
+export declare const COMPRESSION_DEFLATE = 8;
+/** A single TIFF tag entry. */
+export interface TiffTag {
+    /** TIFF tag number (e.g. 256 for ImageWidth). */
+    tag: number;
+    /** TIFF data type (e.g. TIFF_TYPE_SHORT = 3). */
+    type: number;
+    /** Tag values. For ASCII tags, pass a string. */
+    values: number[] | string;
+}
+/** Describes one IFD (image) to be written. */
+export interface WritableIfd {
+    /** Tags for this IFD (excluding StripOffsets/StripByteCounts — those are auto-generated). */
+    tags: TiffTag[];
+    /** Raw (possibly compressed) strip data. Each entry is one strip. */
+    strips: Uint8Array[];
+    /** Optional SubIFDs attached to this IFD (for pyramid sub-resolutions). */
+    subIfds?: WritableIfd[];
+}
+/** Options for buildTiff. */
+export interface BuildTiffOptions {
+    /** Compression to apply to strip data before writing. Default: "none". */
+    compression?: "none" | "deflate";
+    /** Deflate compression level (1-9). Default: 6. */
+    compressionLevel?: number;
+}
+/**
+ * Build a complete TIFF file from a list of IFDs.
+ *
+ * @param ifds - Main IFD chain (linked via next-IFD pointers).
+ * @param options - Build options (compression, etc.).
+ * @returns A complete TIFF file as an ArrayBuffer.
+ */
+export declare function buildTiff(ifds: WritableIfd[], options?: BuildTiffOptions): ArrayBuffer;
+/**
+ * Compress a Uint8Array using deflate (zlib-wrapped, RFC 1950).
+ * Compatible with TIFF compression code 8 and geotiff.js's pako.inflate().
+ */
+export declare function compressDeflate(data: Uint8Array, level?: number): Uint8Array;
+/** Create a standard set of tags for a grayscale image plane. */
+export declare function makeImageTags(width: number, height: number, bitsPerSample: number, sampleFormat: number, compression?: "none" | "deflate", imageDescription?: string, isSubResolution?: boolean): TiffTag[];
+//# sourceMappingURL=tiff-writer.d.ts.map

package/dist/tiff-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiff-writer.d.ts","sourceRoot":"","sources":["../src/tiff-writer.ts"],"names":[],"mappings":"AA2BA,gDAAgD;AAChD,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAUpC,4BAA4B;AAC5B,eAAO,MAAM,oBAAoB,MAAM,CAAC;AACxC,eAAO,MAAM,eAAe,MAAM,CAAC;AACnC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AACpC,eAAO,MAAM,mBAAmB,MAAM,CAAC;AACvC,eAAO,MAAM,eAAe,MAAM,CAAC;AACnC,eAAO,MAAM,eAAe,MAAM,CAAC;AACnC,eAAO,MAAM,qBAAqB,MAAM,CAAC;AACzC,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,qBAAqB,MAAM,CAAC;AACzC,eAAO,MAAM,kBAAkB,MAAM,CAAC;AACtC,eAAO,MAAM,qBAAqB,MAAM,CAAC;AACzC,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAC5C,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,YAAY,MAAM,CAAC;AAEhC,8BAA8B;AAC9B,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAClC,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAIrC,+BAA+B;AAC/B,MAAM,WAAW,OAAO;IACtB,iDAAiD;IACjD,GAAG,EAAE,MAAM,CAAC;IACZ,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;CAC3B;AAED,+CAA+C;AAC/C,MAAM,WAAW,WAAW;IAC1B,6FAA6F;IAC7F,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,qEAAqE;IACrE,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;CACzB;AAED,6BAA6B;AAC7B,MAAM,WAAW,gBAAgB;IAC/B,0EAA0E;IAC1E,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,mDAAmD;IACnD,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAmCD;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,WAAW,EAAE,EACnB,OAAO,GAAE,gBAAqB,GAC7B,WAAW,CA4Bb;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,KAAK,GAAE,MAAU,GAChB,UAAU,CAEZ;AA8TD,iEAAiE;AACjE,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,EACpB,WAAW,GAAE,MAAM,GAAG,SAAkB,EACxC,gBAAgB,CAAC,EAAE,MAAM,EACzB,eAAe,CAAC,EAAE,OAAO,GACxB,OAAO,EAAE,CA0BX"}

package/dist/tiff-writer.js

@@ -0,0 +1,373 @@
+// SPDX-FileCopyrightText: Copyright (c) Fideus Labs LLC
+// SPDX-License-Identifier: MIT
+/**
+ * Low-level TIFF binary builder.
+ *
+ * Assembles IFD entries, tag values, strip data, and SubIFD chains into
+ * a valid classic TIFF file (little-endian, magic 42).
+ *
+ * Layout strategy (two-pass):
+ *   Pass 1: Collect all IFDs and pixel data, compute sizes.
+ *   Pass 2: Compute offsets and write into a pre-allocated ArrayBuffer.
+ *
+ * File layout:
+ *   [Header 8 bytes]
+ *   [Main IFD 0 entries + overflow data + strip data]
+ *   [Main IFD 1 entries + overflow data + strip data]
+ *   ...
+ *   [SubIFD 0,0 entries + overflow data + strip data]
+ *   [SubIFD 0,1 entries + overflow data + strip data]
+ *   ...
+ */
+import { deflate } from "pako";
+// ── TIFF constants ──────────────────────────────────────────────────
+/** TIFF tag data types and their byte sizes. */
+export const TIFF_TYPE_BYTE = 1; // 1 byte
+export const TIFF_TYPE_ASCII = 2; // 1 byte (null-terminated)
+export const TIFF_TYPE_SHORT = 3; // 2 bytes
+export const TIFF_TYPE_LONG = 4; // 4 bytes
+export const TIFF_TYPE_RATIONAL = 5; // 8 bytes (two LONGs)
+const TYPE_SIZES = {
+    [TIFF_TYPE_BYTE]: 1,
+    [TIFF_TYPE_ASCII]: 1,
+    [TIFF_TYPE_SHORT]: 2,
+    [TIFF_TYPE_LONG]: 4,
+    [TIFF_TYPE_RATIONAL]: 8,
+};
+/** Well-known TIFF tags. */
+export const TAG_NEW_SUBFILE_TYPE = 254;
+export const TAG_IMAGE_WIDTH = 256;
+export const TAG_IMAGE_LENGTH = 257;
+export const TAG_BITS_PER_SAMPLE = 258;
+export const TAG_COMPRESSION = 259;
+export const TAG_PHOTOMETRIC = 262;
+export const TAG_IMAGE_DESCRIPTION = 270;
+export const TAG_STRIP_OFFSETS = 273;
+export const TAG_SAMPLES_PER_PIXEL = 277;
+export const TAG_ROWS_PER_STRIP = 278;
+export const TAG_STRIP_BYTE_COUNTS = 279;
+export const TAG_PLANAR_CONFIGURATION = 284;
+export const TAG_SAMPLE_FORMAT = 339;
+export const TAG_SUB_IFDS = 330;
+/** TIFF compression codes. */
+export const COMPRESSION_NONE = 1;
+export const COMPRESSION_DEFLATE = 8;
+// ── Public API ──────────────────────────────────────────────────────
+/**
+ * Build a complete TIFF file from a list of IFDs.
+ *
+ * @param ifds - Main IFD chain (linked via next-IFD pointers).
+ * @param options - Build options (compression, etc.).
+ * @returns A complete TIFF file as an ArrayBuffer.
+ */
+export function buildTiff(ifds, options = {}) {
+    const compression = options.compression ?? "none";
+    const compressionLevel = options.compressionLevel ?? 6;
+    // Compress strips if needed
+    const processedIfds = ifds.map((ifd) => processIfd(ifd, compression, compressionLevel));
+    // Pass 1: compute sizes and place all IFDs
+    const placed = placeIfds(processedIfds);
+    // Pass 2: compute total file size
+    const totalSize = computeTotalSize(placed);
+    // Pass 3: write into buffer
+    const buffer = new ArrayBuffer(totalSize);
+    const view = new DataView(buffer);
+    // Write TIFF header (little-endian)
+    view.setUint16(0, 0x4949, true); // "II" byte order
+    view.setUint16(2, 42, true); // magic number
+    view.setUint32(4, placed.length > 0 ? placed[0].ifdOffset : 0, true); // offset to first IFD
+    // Write all placed IFDs
+    for (const p of placed) {
+        writeIfd(view, buffer, p);
+    }
+    return buffer;
+}
+/**
+ * Compress a Uint8Array using deflate (zlib-wrapped, RFC 1950).
+ * Compatible with TIFF compression code 8 and geotiff.js's pako.inflate().
+ */
+export function compressDeflate(data, level = 6) {
+    return deflate(data, { level: level });
+}
+// ── Internal helpers ────────────────────────────────────────────────
+/**
+ * Process an IFD: compress strips if needed, add compression tag,
+ * and recursively process SubIFDs.
+ */
+function processIfd(ifd, compression, level) {
+    let strips = ifd.strips;
+    const tags = [...ifd.tags];
+    if (compression === "deflate") {
+        strips = strips.map((s) => compressDeflate(s, level));
+        // Replace or add Compression tag
+        const compIdx = tags.findIndex((t) => t.tag === TAG_COMPRESSION);
+        if (compIdx >= 0) {
+            tags[compIdx] = { tag: TAG_COMPRESSION, type: TIFF_TYPE_SHORT, values: [COMPRESSION_DEFLATE] };
+        }
+        else {
+            tags.push({ tag: TAG_COMPRESSION, type: TIFF_TYPE_SHORT, values: [COMPRESSION_DEFLATE] });
+        }
+    }
+    const subIfds = ifd.subIfds?.map((sub) => processIfd(sub, compression, level));
+    return { tags, strips, subIfds };
+}
+/** Resolve a TiffTag to its byte representation. */
+function resolveTag(tag) {
+    if (typeof tag.values === "string") {
+        // ASCII: null-terminated
+        const encoder = new TextEncoder();
+        const strBytes = encoder.encode(tag.values);
+        const valueBytes = new Uint8Array(strBytes.length + 1); // +1 for null terminator
+        valueBytes.set(strBytes);
+        valueBytes[strBytes.length] = 0;
+        return { tag: tag.tag, type: TIFF_TYPE_ASCII, count: valueBytes.length, valueBytes };
+    }
+    const typeSize = TYPE_SIZES[tag.type];
+    if (!typeSize) {
+        throw new Error(`Unknown TIFF type: ${tag.type}`);
+    }
+    const count = tag.type === TIFF_TYPE_RATIONAL ? tag.values.length / 2 : tag.values.length;
+    const totalBytes = count * typeSize;
+    const valueBytes = new Uint8Array(totalBytes);
+    const dv = new DataView(valueBytes.buffer, valueBytes.byteOffset, valueBytes.byteLength);
+    for (let i = 0; i < tag.values.length; i++) {
+        switch (tag.type) {
+            case TIFF_TYPE_BYTE:
+                dv.setUint8(i, tag.values[i]);
+                break;
+            case TIFF_TYPE_SHORT:
+                dv.setUint16(i * 2, tag.values[i], true);
+                break;
+            case TIFF_TYPE_LONG:
+                dv.setUint32(i * 4, tag.values[i], true);
+                break;
+            case TIFF_TYPE_RATIONAL:
+                // Rationals are stored as two LONGs (numerator, denominator)
+                dv.setUint32(i * 4, tag.values[i], true);
+                break;
+        }
+    }
+    return { tag: tag.tag, type: tag.type, count, valueBytes };
+}
+/**
+ * Compute the byte size of an IFD entry block:
+ *   2 bytes (entry count) + 12 bytes per entry + 4 bytes (next IFD offset)
+ */
+function ifdEntryBlockSize(numTags) {
+    return 2 + numTags * 12 + 4;
+}
+/** Compute overflow size for resolved tags (values that don't fit in 4 bytes). */
+function overflowSize(tags) {
+    let size = 0;
+    for (const t of tags) {
+        if (t.valueBytes.length > 4) {
+            size += t.valueBytes.length;
+            // Pad to word boundary (2-byte alignment)
+            if (t.valueBytes.length % 2 !== 0)
+                size += 1;
+        }
+    }
+    return size;
+}
+/** Compute total strip data size. */
+function totalStripSize(strips) {
+    return strips.reduce((sum, s) => sum + s.length, 0);
+}
+/**
+ * Place all IFDs sequentially, computing absolute offsets.
+ * Returns a flat list of PlacedIfds (main chain first, then SubIFDs).
+ */
+function placeIfds(ifds) {
+    const allPlaced = [];
+    function resolveIfdInfo(ifd) {
+        // Build tags list — we'll add StripOffsets and StripByteCounts as placeholders
+        // They'll be patched during the write phase
+        const userTags = ifd.tags.map(resolveTag);
+        // Add StripOffsets (placeholder — count = number of strips, values will be patched)
+        const stripOffsetsTag = {
+            tag: TAG_STRIP_OFFSETS,
+            type: TIFF_TYPE_LONG,
+            count: ifd.strips.length,
+            valueBytes: new Uint8Array(ifd.strips.length * 4),
+        };
+        // Add StripByteCounts
+        const stripByteCountsBytes = new Uint8Array(ifd.strips.length * 4);
+        const sbcView = new DataView(stripByteCountsBytes.buffer);
+        for (let i = 0; i < ifd.strips.length; i++) {
+            sbcView.setUint32(i * 4, ifd.strips[i].length, true);
+        }
+        const stripByteCountsTag = {
+            tag: TAG_STRIP_BYTE_COUNTS,
+            type: TIFF_TYPE_LONG,
+            count: ifd.strips.length,
+            valueBytes: stripByteCountsBytes,
+        };
+        const allTags = [...userTags, stripOffsetsTag, stripByteCountsTag];
+        // Add SubIFDs tag if there are SubIFDs
+        const subIfdInfos = (ifd.subIfds ?? []).map(resolveIfdInfo);
+        if (subIfdInfos.length > 0) {
+            const subIfdsTag = {
+                tag: TAG_SUB_IFDS,
+                type: TIFF_TYPE_LONG,
+                count: subIfdInfos.length,
+                valueBytes: new Uint8Array(subIfdInfos.length * 4), // placeholder offsets
+            };
+            allTags.push(subIfdsTag);
+        }
+        // Sort by tag number (TIFF spec requires this)
+        allTags.sort((a, b) => a.tag - b.tag);
+        return {
+            tags: allTags,
+            strips: ifd.strips,
+            subIfdInfos,
+            entryBlockSize: ifdEntryBlockSize(allTags.length),
+            overflow: overflowSize(allTags),
+            stripSize: totalStripSize(ifd.strips),
+        };
+    }
+    const mainInfos = ifds.map(resolveIfdInfo);
+    // Second pass: place IFDs sequentially
+    let cursor = 8; // Start after TIFF header
+    function placeIfdInfo(info) {
+        const ifdOffset = cursor;
+        cursor += info.entryBlockSize;
+        const overflowOffset = cursor;
+        cursor += info.overflow;
+        const stripDataOffset = cursor;
+        cursor += info.stripSize;
+        const placed = {
+            ifdOffset,
+            tags: info.tags,
+            overflowOffset,
+            overflowSize: info.overflow,
+            stripDataOffset,
+            strips: info.strips,
+            subIfds: [], // will be filled after SubIFD placement
+            nextIfdOffset: 0, // will be patched below for main chain
+        };
+        info.placed = placed;
+        allPlaced.push(placed);
+        // Place SubIFDs immediately after this IFD's strip data
+        for (const subInfo of info.subIfdInfos) {
+            placed.subIfds.push(placeIfdInfo(subInfo));
+        }
+        return placed;
+    }
+    // Place main chain IFDs (SubIFDs are placed within each main IFD's placeIfdInfo call)
+    const mainPlaced = [];
+    for (let i = 0; i < mainInfos.length; i++) {
+        mainPlaced.push(placeIfdInfo(mainInfos[i]));
+    }
+    // Link main chain next-IFD pointers
+    for (let i = 0; i < mainPlaced.length - 1; i++) {
+        mainPlaced[i].nextIfdOffset = mainPlaced[i + 1].ifdOffset;
+    }
+    return allPlaced;
+}
+/** Compute total file size from placed IFDs. */
+function computeTotalSize(placed) {
+    if (placed.length === 0)
+        return 8;
+    let maxEnd = 8;
+    for (const p of placed) {
+        const end = p.stripDataOffset + totalStripSize(p.strips);
+        if (end > maxEnd)
+            maxEnd = end;
+    }
+    return maxEnd;
+}
+/** Write a single placed IFD (and its SubIFDs) into the buffer. */
+function writeIfd(view, buffer, placed) {
+    let pos = placed.ifdOffset;
+    // Write entry count
+    view.setUint16(pos, placed.tags.length, true);
+    pos += 2;
+    // Compute strip offsets for this IFD
+    const stripOffsets = [];
+    let stripCursor = placed.stripDataOffset;
+    for (const strip of placed.strips) {
+        stripOffsets.push(stripCursor);
+        stripCursor += strip.length;
+    }
+    // Compute SubIFD offsets
+    const subIfdOffsets = placed.subIfds.map((s) => s.ifdOffset);
+    // Track overflow cursor
+    let overflowCursor = placed.overflowOffset;
+    // Write each tag entry (12 bytes each)
+    for (const tag of placed.tags) {
+        view.setUint16(pos, tag.tag, true);
+        view.setUint16(pos + 2, tag.type, true);
+        view.setUint32(pos + 4, tag.count, true);
+        // Determine the value bytes to write
+        let valueBytes = tag.valueBytes;
+        // Patch StripOffsets
+        if (tag.tag === TAG_STRIP_OFFSETS) {
+            valueBytes = new Uint8Array(stripOffsets.length * 4);
+            const dv = new DataView(valueBytes.buffer, valueBytes.byteOffset, valueBytes.byteLength);
+            for (let i = 0; i < stripOffsets.length; i++) {
+                dv.setUint32(i * 4, stripOffsets[i], true);
+            }
+        }
+        // Patch SubIFDs offsets
+        if (tag.tag === TAG_SUB_IFDS && subIfdOffsets.length > 0) {
+            valueBytes = new Uint8Array(subIfdOffsets.length * 4);
+            const dv = new DataView(valueBytes.buffer, valueBytes.byteOffset, valueBytes.byteLength);
+            for (let i = 0; i < subIfdOffsets.length; i++) {
+                dv.setUint32(i * 4, subIfdOffsets[i], true);
+            }
+        }
+        if (valueBytes.length <= 4) {
+            // Inline: write value bytes directly in the 4-byte value/offset field
+            const dest = new Uint8Array(buffer, pos + 8, 4);
+            dest.fill(0);
+            dest.set(valueBytes);
+        }
+        else {
+            // Overflow: write offset to overflow area, then write bytes there
+            view.setUint32(pos + 8, overflowCursor, true);
+            const dest = new Uint8Array(buffer, overflowCursor, valueBytes.length);
+            dest.set(valueBytes);
+            overflowCursor += valueBytes.length;
+            // Pad to word boundary
+            if (valueBytes.length % 2 !== 0)
+                overflowCursor += 1;
+        }
+        pos += 12;
+    }
+    // Write next IFD offset
+    view.setUint32(pos, placed.nextIfdOffset, true);
+    // Write strip data
+    let stripPos = placed.stripDataOffset;
+    for (const strip of placed.strips) {
+        const dest = new Uint8Array(buffer, stripPos, strip.length);
+        dest.set(strip);
+        stripPos += strip.length;
+    }
+    // SubIFDs are already in allPlaced and will be written by the caller's loop
+}
+// ── Convenience helpers for building IFD tags ───────────────────────
+/** Create a standard set of tags for a grayscale image plane. */
+export function makeImageTags(width, height, bitsPerSample, sampleFormat, compression = "none", imageDescription, isSubResolution) {
+    const tags = [];
+    if (isSubResolution) {
+        tags.push({ tag: TAG_NEW_SUBFILE_TYPE, type: TIFF_TYPE_LONG, values: [1] });
+    }
+    tags.push({ tag: TAG_IMAGE_WIDTH, type: TIFF_TYPE_LONG, values: [width] });
+    tags.push({ tag: TAG_IMAGE_LENGTH, type: TIFF_TYPE_LONG, values: [height] });
+    tags.push({ tag: TAG_BITS_PER_SAMPLE, type: TIFF_TYPE_SHORT, values: [bitsPerSample] });
+    tags.push({
+        tag: TAG_COMPRESSION,
+        type: TIFF_TYPE_SHORT,
+        values: [compression === "deflate" ? COMPRESSION_DEFLATE : COMPRESSION_NONE],
+    });
+    tags.push({ tag: TAG_PHOTOMETRIC, type: TIFF_TYPE_SHORT, values: [1] }); // MinIsBlack
+    tags.push({ tag: TAG_SAMPLES_PER_PIXEL, type: TIFF_TYPE_SHORT, values: [1] });
+    tags.push({ tag: TAG_ROWS_PER_STRIP, type: TIFF_TYPE_LONG, values: [height] }); // single strip
+    tags.push({ tag: TAG_PLANAR_CONFIGURATION, type: TIFF_TYPE_SHORT, values: [1] }); // chunky
+    tags.push({ tag: TAG_SAMPLE_FORMAT, type: TIFF_TYPE_SHORT, values: [sampleFormat] });
+    if (imageDescription) {
+        tags.push({ tag: TAG_IMAGE_DESCRIPTION, type: TIFF_TYPE_ASCII, values: imageDescription });
+    }
+    return tags;
+}
+//# sourceMappingURL=tiff-writer.js.map