@georeferencing/plugins 0.1.0

package/dist/report.js

@@ -0,0 +1,224 @@
+import { coordinateUnits, ENGINE_VERSION, fail, forward, project, } from "@georeferencing/core";
+import { accuracyReport } from "./serializers.js";
+async function png(canvas) {
+    try {
+        return await new Promise((resolve, reject) => canvas.toBlob((value) => value
+            ? resolve(value)
+            : reject(Error("Could not encode report image.")), "image/png"));
+    }
+    catch {
+        return fail("REPORT_CORS", "A map layer prevents canvas export. Configure CORS on its source, or generate the report without the optional host-map frame.");
+    }
+}
+/**
+ * Capture currently rendered canvas layers as PNG without changing the host view.
+ *
+ * Calls renderSync and copies available canvas content; does not await outstanding tiles or capture arbitrary DOM overlays. WebGL/non-canvas renderers are outside this capture contract.
+ * @param map - Visible initialized host map.
+ * @throws {@link core.GeoreferenceError} If the viewport is unavailable or a source taints canvas export.
+ */
+export async function captureMap(map) {
+    map.renderSync();
+    const size = map.getSize();
+    if (!size || size[0] <= 0 || size[1] <= 0)
+        fail("REPORT_MAP", "Map has no visible viewport.");
+    const canvas = document.createElement("canvas");
+    canvas.width = size[0];
+    canvas.height = size[1];
+    const context = canvas.getContext("2d");
+    try {
+        for (const layer of map
+            .getViewport()
+            .querySelectorAll(".ol-layer canvas")) {
+            if (!layer.width || !layer.height)
+                continue;
+            context.save();
+            context.globalAlpha = Number(layer.parentElement?.style.opacity || layer.style.opacity || 1);
+            const transform = layer.style.transform;
+            if (transform && transform !== "none")
+                context.setTransform(new DOMMatrix(transform));
+            else
+                context.scale(parseFloat(layer.style.width || String(layer.width)) / layer.width, parseFloat(layer.style.height || String(layer.height)) / layer.height);
+            context.drawImage(layer, 0, 0);
+            context.restore();
+        }
+        return await png(canvas);
+    }
+    finally {
+        canvas.width = 0;
+        canvas.height = 0;
+    }
+}
+/**
+ * Create a local PDF with source identity, alignment diagnostics, GCPs, raster overview and an embedded full-precision alignment.json attachment. pdf-lib loads lazily.
+ *
+ * Training residuals are not independent accuracy measurements. The caller must pass document, fit and raster from the same alignment; use a controller export result for its exact revision.
+ * @param doc - Revisioned document snapshot.
+ * @param fit - Fit corresponding to that document alignment.
+ * @param raster - Georeferenced preview/export pixels for that alignment.
+ * @param options - Paper layout, projections and optional current map capture.
+ * @returns PDF Blob suitable for download; no host persistence is performed.
+ */
+export async function createPdfReport(doc, fit, raster, options = {}) {
+    const capturedMap = options.map
+        ? {
+            frame: {
+                crs: options.map.getView().getProjection().getCode(),
+                extent: options.map.getView().calculateExtent(options.map.getSize()),
+                rotation: options.map.getView().getRotation(),
+            },
+            attribution: options.attribution ??
+                options.map.getViewport().querySelector(".ol-attribution")
+                    ?.textContent ??
+                "Attribution: supplied by the host map.",
+            blob: await captureMap(options.map),
+        }
+        : undefined;
+    const { PDFDocument, StandardFonts, rgb } = await import("pdf-lib");
+    const pdf = await PDFDocument.create(), font = await pdf.embedFont(StandardFonts.Helvetica), mono = await pdf.embedFont(StandardFonts.Courier);
+    const sizes = {
+        A4: [595.28, 841.89],
+        A3: [841.89, 1190.55],
+        Letter: [612, 792],
+    };
+    const paper = sizes[options.paper ?? "A4"], [pageWidth, pageHeight] = options.landscape ? [...paper].reverse() : paper;
+    const margin = options.margin ?? 40, contentWidth = pageWidth - margin * 2;
+    if (!Number.isFinite(margin) ||
+        margin < 15 ||
+        contentWidth < 200 ||
+        pageHeight - margin * 2 < 200)
+        fail("REPORT_LAYOUT", "PDF margins leave insufficient room for the report.");
+    pdf.setTitle("Georeferencing map and alignment report");
+    pdf.setProducer(ENGINE_VERSION);
+    await pdf.attach(new TextEncoder().encode(accuracyReport(doc, fit)), "alignment.json", {
+        mimeType: "application/json",
+        description: "Complete Unicode source identity, revisioned document, coefficients and diagnostics",
+    });
+    let page = pdf.addPage([pageWidth, pageHeight]), y = pageHeight - margin;
+    const newPage = () => {
+        page = pdf.addPage([pageWidth, pageHeight]);
+        y = pageHeight - margin;
+    };
+    const text = (value, size = 10, fixed = false) => {
+        const safe = value.replace(/[^\x20-\x7e]/g, "?"), width = Math.max(1, Math.floor(contentWidth / (size * (fixed ? 0.6 : 0.55))));
+        for (let i = 0; i < safe.length || i === 0; i += width) {
+            if (y < margin + size)
+                newPage();
+            page.drawText(safe.slice(i, i + width), {
+                x: margin,
+                y,
+                size,
+                font: fixed ? mono : font,
+                color: rgb(0.12, 0.2, 0.17),
+            });
+            y -= size + 5;
+        }
+    };
+    const drawImage = async (blob, maxHeight) => {
+        const image = await pdf.embedPng(await blob.arrayBuffer()), scale = Math.min(contentWidth / image.width, maxHeight / image.height);
+        const width = image.width * scale, height = image.height * scale;
+        if (y - height - 20 < margin)
+            newPage();
+        y -= height + 10;
+        page.drawImage(image, { x: margin, y, width, height });
+        return { x: margin, y, width, height };
+    };
+    text("Georeferencing map & alignment report", 20);
+    text(`Source: ${doc.sourceImage?.name} | ${doc.sourceImage?.width} x ${doc.sourceImage?.height} pixels`);
+    text(`Document ${doc.id} / revision ${doc.documentRevision}`);
+    text(`Model ${doc.model} | Working CRS ${doc.workingCrs} | Alignment revision ${doc.alignmentRevision}`);
+    text(`Confirmed: ${doc.confirmedAlignmentRevision === doc.alignmentRevision} | Feature review: ${doc.featuresReviewedAgainstAlignmentRevision === doc.alignmentRevision}`);
+    text(`Grid extent in ${raster.crs}: ${raster.bounds.map((v) => v.toPrecision(10)).join(", ")}`, 9);
+    const canvas = document.createElement("canvas");
+    canvas.width = raster.width;
+    canvas.height = raster.height;
+    canvas
+        .getContext("2d")
+        .putImageData(new ImageData(raster.data, raster.width, raster.height), 0, 0);
+    let imageBlob;
+    try {
+        imageBlob = await png(canvas);
+    }
+    finally {
+        canvas.width = 0;
+        canvas.height = 0;
+    }
+    const box = await drawImage(imageBlob, Math.min(350, pageHeight * 0.4));
+    const toPage = (p) => [
+        box.x +
+            ((p[0] - raster.bounds[0]) / (raster.bounds[2] - raster.bounds[0])) *
+                box.width,
+        box.y +
+            ((p[1] - raster.bounds[1]) / (raster.bounds[3] - raster.bounds[1])) *
+                box.height,
+    ];
+    const vectors = doc.gcps.map((gcp) => ({
+        gcp,
+        a: toPage(project(gcp.target, gcp.crs, raster.crs, options.definitions)),
+        b: toPage(project(forward(fit, gcp.image), doc.workingCrs, raster.crs, options.definitions)),
+    }));
+    const max = Math.max(0, ...vectors
+        .filter((v) => v.gcp.enabled)
+        .map(({ a, b }) => Math.hypot(b[0] - a[0], b[1] - a[1]))), exaggeration = max > 1e-6
+        ? Math.min(1000, Math.max(1, (Math.min(box.width, box.height) * 0.12) / max))
+        : 1;
+    for (const { gcp, a, b } of vectors) {
+        if (a[0] < box.x ||
+            a[0] > box.x + box.width ||
+            a[1] < box.y ||
+            a[1] > box.y + box.height)
+            continue;
+        const color = gcp.enabled ? rgb(0.8, 0.25, 0.1) : rgb(0.4, 0.4, 0.4);
+        page.drawCircle({ x: a[0], y: a[1], size: 2, color });
+        page.drawText(String(gcp.label), {
+            x: a[0] + 3,
+            y: a[1] + 3,
+            size: 8,
+            font,
+            color,
+        });
+        if (gcp.enabled)
+            page.drawLine({
+                start: { x: a[0], y: a[1] },
+                end: {
+                    x: a[0] + (b[0] - a[0]) * exaggeration,
+                    y: a[1] + (b[1] - a[1]) * exaggeration,
+                },
+                thickness: 1,
+                color,
+            });
+    }
+    y -= 20;
+    text(`Control-point residual vectors exaggerated ${exaggeration.toPrecision(4)}x. Grid north is up.`);
+    text(`RMSE: ${fit.rmse.toPrecision(12)} ${coordinateUnits(doc.workingCrs, options.definitions)} in ${doc.workingCrs}`);
+    text("r = T(image) - target; RMSE = sqrt(sum(||r||^2)/enabledCount).");
+    text("Training residuals do not measure independent positional accuracy.");
+    text(`Condition number: ${fit.condition}; backward mapping: ${fit.backward}`);
+    text(`Engine: ${ENGINE_VERSION}; output: ${JSON.stringify(doc.output)}`, 9);
+    text(`SHA-256: ${doc.sourceImage?.fingerprint}`, 8, true);
+    if (capturedMap) {
+        newPage();
+        text("Host map: currently rendered layers and drawings", 16);
+        text(JSON.stringify(capturedMap.frame), 9, true);
+        await drawImage(capturedMap.blob, pageHeight * 0.65);
+        y -= 20;
+        text(capturedMap.attribution, 8);
+        text("Snapshot includes currently loaded canvas layers. Geographic coordinates remain in the attached document.", 9);
+    }
+    newPage();
+    text("Ground control points", 16);
+    for (const gcp of doc.gcps) {
+        const r = fit.residuals.find((v) => v.id === gcp.id);
+        text(`#${gcp.label} ${gcp.enabled ? "enabled" : "disabled"} | pixel ${gcp.image.join(", ")} -> ${gcp.target.join(", ")} [${gcp.crs}]`, 9, true);
+        if (r)
+            text(`r=[${r.vector.join(", ")}]; length=${r.distance}; pixel residual=${r.pixels ?? "unavailable"}`, 8, true);
+    }
+    text("Normalized transformation parameters", 14);
+    for (const [key, value] of Object.entries(fit))
+        if (key !== "residuals")
+            text(`${key}: ${JSON.stringify(value)}`, 8, true);
+    text("Reproduce: restore the attached alignment.json document with its matching SHA-256 source bytes and recorded engine version. GDAL CLI model substitution is not implied.");
+    return new Blob([(await pdf.save())], {
+        type: "application/pdf",
+    });
+}

package/dist/serializers.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Pure serializers for QGIS points, world files and alignment accuracy reports.
+ * Import from `@georeferencing/plugins/serializers`; no workers or UI are loaded.
+ * @module serializers
+ */
+import type { Definitions, Document, Fit } from "@georeferencing/core";
+/**
+ * Export a QGIS-compatible `.points` text file. Targets are projected into the document working CRS; canonical image y is negated to QGIS source y-up coordinates.
+ *
+ * Residual columns are placeholders set to zero; use `accuracyReport` for actual diagnostics. IDs and snap provenance are not represented by this format.
+ */
+export declare function exportPoints(doc: Document, definitions?: Definitions): string;
+/**
+ * Create a six-line world file plus an explicit CRS sidecar value for Linear or Helmert fits without reprojection.
+ *
+ * Line order is A, D, B, E, C, F. The final two values locate the first pixel centre, `[0.5, 0.5]`. A world file alone contains no CRS.
+ * @throws {@link core.GeoreferenceError} For ineligible models or different working/output CRSs.
+ */
+export declare function worldFile(fit: Fit, workingCrs: string, outputCrs: string): {
+    /**
+     * Six newline-separated values in A, D, B, E, C, F order, including the pixel-centre
+     * offset.
+     */
+    text: string;
+    /** Explicit CRS to retain beside the world file. */
+    crs: string;
+};
+/**
+ * Serialize the supplied document, fit, residual formulas and engine identity as readable JSON.
+ *
+ * The caller must supply a fit for this exact document revision. Training residuals do not certify independent accuracy; the report explicitly records that limitation and does not claim plain GDAL CLI equivalence.
+ */
+export declare function accuracyReport(doc: Document, fit: Fit): string;

package/dist/serializers.js

@@ -0,0 +1,68 @@
+import { ENGINE_VERSION, fail, forward, project } from "@georeferencing/core";
+/**
+ * Export a QGIS-compatible `.points` text file. Targets are projected into the document working CRS; canonical image y is negated to QGIS source y-up coordinates.
+ *
+ * Residual columns are placeholders set to zero; use `accuracyReport` for actual diagnostics. IDs and snap provenance are not represented by this format.
+ */
+export function exportPoints(doc, definitions = {}) {
+    return (`#CRS: ${doc.workingCrs}\nmapX,mapY,sourceX,sourceY,enable,dX,dY,residual\n` +
+        doc.gcps
+            .map((p) => [
+            ...project(p.target, p.crs, doc.workingCrs, definitions),
+            p.image[0],
+            -p.image[1],
+            p.enabled ? 1 : 0,
+            0,
+            0,
+            0,
+        ].join(","))
+            .join("\n") +
+        "\n");
+}
+/**
+ * Create a six-line world file plus an explicit CRS sidecar value for Linear or Helmert fits without reprojection.
+ *
+ * Line order is A, D, B, E, C, F. The final two values locate the first pixel centre, `[0.5, 0.5]`. A world file alone contains no CRS.
+ * @throws {@link core.GeoreferenceError} For ineligible models or different working/output CRSs.
+ */
+export function worldFile(fit, workingCrs, outputCrs) {
+    if (!["linear", "helmert"].includes(fit.model) || workingCrs !== outputCrs)
+        fail("WORLD_FILE", "World-file-only output requires Linear/Helmert without reprojection.");
+    const a = forward(fit, [0, 0]), b = forward(fit, [1, 0]), c = forward(fit, [0, 1]), center = forward(fit, [0.5, 0.5]);
+    return {
+        /**
+         * Six newline-separated values in A, D, B, E, C, F order, including the pixel-centre
+         * offset.
+         */
+        text: `${[
+            b[0] - a[0],
+            b[1] - a[1],
+            c[0] - a[0],
+            c[1] - a[1],
+            ...center,
+        ].join("\n")}\n`,
+        /** Explicit CRS to retain beside the world file. */
+        crs: workingCrs,
+    };
+}
+/**
+ * Serialize the supplied document, fit, residual formulas and engine identity as readable JSON.
+ *
+ * The caller must supply a fit for this exact document revision. Training residuals do not certify independent accuracy; the report explicitly records that limitation and does not claim plain GDAL CLI equivalence.
+ */
+export function accuracyReport(doc, fit) {
+    return JSON.stringify({
+        document: doc,
+        engine: ENGINE_VERSION,
+        diagnostics: {
+            definition: "r = T(image) - target; RMSE = sqrt(sum(||r||²)/enabledCount)",
+            units: doc.workingCrs,
+            independentAccuracy: "Not measured; training residuals do not certify accuracy.",
+            ...fit,
+        },
+        reproducibility: {
+            inverse: fit.backward,
+            recipe: "Restore this document and matching SHA-256 image using this package version. Plain GDAL CLI equivalence is unverified.",
+        },
+    }, null, 2);
+}

package/dist/tiff.d.ts

@@ -0,0 +1,45 @@
+import type { Extent, OutputSettings } from "@georeferencing/core";
+/**
+ * Supported TIFF strip creation and no-data options, shared with raster output settings.
+ */
+export type TiffOptions = Pick<OutputSettings, "compression" | "noData" | "rowsPerStrip" | "predictor">;
+/**
+ * Validate byte no-data, strip height, compression and predictor compatibility before
+ * encoding.
+ */
+export declare function validateTiffOptions(options: TiffOptions): void;
+/**
+ * Encode an uncompressed north-up RGBA GeoTIFF synchronously using PixelIsArea. Allocates a complete ArrayBuffer; prefer encodeGeoTiffBlob for bounded-strip encoding.
+ * @param data - Row-major 8-bit RGBA with unassociated alpha.
+ * @param width - Positive integer pixel width.
+ * @param height - Positive integer pixel height.
+ * @param bounds - Outer pixel-edge extent in the output CRS, with row zero at maxY.
+ * @param crs - EPSG identifier with numeric code below 32767. Custom WKT GeoKeys are not supported.
+ * @param geographic - True for geographic CRS GeoKeys, false for projected CRS GeoKeys; must agree with crs.
+ * @returns Encoded TIFF with CRS, tiepoint, pixel scale and unassociated-alpha metadata.
+ */
+export declare function encodeGeoTiff(data: Uint8ClampedArray, width: number, height: number, bounds: Extent, crs: string, geographic: boolean): ArrayBuffer;
+/**
+ * Encode a north-up GeoTIFF as bounded strips assembled into a Blob, avoiding a second concatenated full TIFF buffer.
+ * @param data - Row-major 8-bit RGBA with unassociated alpha.
+ * @param width - Positive integer pixel width.
+ * @param height - Positive integer pixel height.
+ * @param bounds - Outer pixel-edge extent in the output CRS, with row zero at maxY.
+ * @param crs - EPSG identifier with numeric code below 32767. Custom WKT GeoKeys are not supported.
+ * @param geographic - True for geographic CRS GeoKeys, false for projected CRS GeoKeys; must agree with crs.
+ * @param options - Compression, strip height, predictor and optional RGB no-data.
+ * @param progress - Encoding progress fraction per completed strip.
+ * @throws {@link core.GeoreferenceError} For invalid layouts/settings, unavailable Deflate or partial transparency with numeric no-data.
+ */
+export declare function encodeGeoTiffBlob(data: Uint8ClampedArray, width: number, height: number, bounds: Extent, crs: string, geographic: boolean, options?: TiffOptions, progress?: (value: number) => void): Promise<Blob>;
+/**
+ * Convenience ArrayBuffer encoder wrapping encodeGeoTiffBlob. Materializes a complete output copy; the worker uses the Blob API.
+ * @param data - Row-major 8-bit RGBA with unassociated alpha.
+ * @param width - Positive integer pixel width.
+ * @param height - Positive integer pixel height.
+ * @param bounds - Outer pixel-edge extent in the output CRS, with row zero at maxY.
+ * @param crs - EPSG identifier with numeric code below 32767. Custom WKT GeoKeys are not supported.
+ * @param geographic - True for geographic CRS GeoKeys, false for projected CRS GeoKeys; must agree with crs.
+ * @param compression - Strip codec; defaults to none.
+ */
+export declare function encodeGeoTiffOutput(data: Uint8ClampedArray, width: number, height: number, bounds: Extent, crs: string, geographic: boolean, compression?: NonNullable<OutputSettings["compression"]>): Promise<ArrayBuffer>;

package/dist/tiff.js

@@ -0,0 +1,249 @@
+import { fail } from "@georeferencing/core";
+const compressionCodes = { none: 1, deflate: 8, packbits: 32773 };
+/**
+ * Validate byte no-data, strip height, compression and predictor compatibility before
+ * encoding.
+ */
+export function validateTiffOptions(options) {
+    if (!Object.hasOwn(compressionCodes, options.compression ?? "none"))
+        fail("OUTPUT", "Unsupported TIFF compression.");
+    if (options.noData !== undefined &&
+        (!Number.isInteger(options.noData) ||
+            options.noData < 0 ||
+            options.noData > 255))
+        fail("NODATA", "Byte-image no-data must be an integer from 0 to 255.");
+    if (options.rowsPerStrip !== undefined &&
+        (!Number.isInteger(options.rowsPerStrip) ||
+            options.rowsPerStrip < 1 ||
+            options.rowsPerStrip > 4096))
+        fail("OUTPUT", "Rows per strip must be an integer from 1 to 4096.");
+    if (![1, 2].includes(options.predictor ?? 1) ||
+        (options.predictor === 2 && options.compression !== "deflate"))
+        fail("OUTPUT", "Horizontal prediction requires Deflate compression.");
+}
+function check(data, width, height, bounds) {
+    if (!Number.isSafeInteger(width) ||
+        !Number.isSafeInteger(height) ||
+        width < 1 ||
+        height < 1 ||
+        data.length !== width * height * 4)
+        fail("RASTER", "Raster buffer dimensions disagree.");
+    if (!bounds.every(Number.isFinite) ||
+        bounds[0] >= bounds[2] ||
+        bounds[1] >= bounds[3])
+        fail("EXTENT", "Invalid TIFF bounds.");
+}
+/**
+ * Encode an uncompressed north-up RGBA GeoTIFF synchronously using PixelIsArea. Allocates a complete ArrayBuffer; prefer encodeGeoTiffBlob for bounded-strip encoding.
+ * @param data - Row-major 8-bit RGBA with unassociated alpha.
+ * @param width - Positive integer pixel width.
+ * @param height - Positive integer pixel height.
+ * @param bounds - Outer pixel-edge extent in the output CRS, with row zero at maxY.
+ * @param crs - EPSG identifier with numeric code below 32767. Custom WKT GeoKeys are not supported.
+ * @param geographic - True for geographic CRS GeoKeys, false for projected CRS GeoKeys; must agree with crs.
+ * @returns Encoded TIFF with CRS, tiepoint, pixel scale and unassociated-alpha metadata.
+ */
+export function encodeGeoTiff(data, width, height, bounds, crs, geographic) {
+    check(data, width, height, bounds);
+    const header = tiffHeader(width, height, bounds, crs, geographic, {}, [data.length], height, 4);
+    const output = new Uint8Array(header.byteLength + data.byteLength);
+    output.set(new Uint8Array(header));
+    output.set(data, header.byteLength);
+    return output.buffer;
+}
+/**
+ * Encode a north-up GeoTIFF as bounded strips assembled into a Blob, avoiding a second concatenated full TIFF buffer.
+ * @param data - Row-major 8-bit RGBA with unassociated alpha.
+ * @param width - Positive integer pixel width.
+ * @param height - Positive integer pixel height.
+ * @param bounds - Outer pixel-edge extent in the output CRS, with row zero at maxY.
+ * @param crs - EPSG identifier with numeric code below 32767. Custom WKT GeoKeys are not supported.
+ * @param geographic - True for geographic CRS GeoKeys, false for projected CRS GeoKeys; must agree with crs.
+ * @param options - Compression, strip height, predictor and optional RGB no-data.
+ * @param progress - Encoding progress fraction per completed strip.
+ * @throws {@link core.GeoreferenceError} For invalid layouts/settings, unavailable Deflate or partial transparency with numeric no-data.
+ */
+export async function encodeGeoTiffBlob(data, width, height, bounds, crs, geographic, options = {}, progress) {
+    check(data, width, height, bounds);
+    validateTiffOptions(options);
+    const channels = options.noData === undefined ? 4 : 3;
+    const rows = Math.min(height, options.rowsPerStrip ?? 256), strips = [];
+    const compression = options.compression ?? "none";
+    if (compression === "deflate" && typeof CompressionStream === "undefined")
+        fail("CAPABILITY", "Deflate is unavailable; select uncompressed or PackBits output.");
+    for (let y = 0; y < height; y += rows) {
+        const count = Math.min(rows, height - y), pixels = new Uint8Array(width * count * channels);
+        for (let i = 0; i < width * count; i++) {
+            const p = (y * width + i) * 4;
+            if (channels === 3 && data[p + 3] !== 0 && data[p + 3] !== 255)
+                fail("NODATA_ALPHA", "Numeric no-data cannot preserve partial transparency; select alpha output.");
+            for (let c = 0; c < channels; c++)
+                pixels[i * channels + c] =
+                    channels === 3 && data[p + 3] === 0 ? options.noData : data[p + c];
+        }
+        if (options.predictor === 2)
+            for (let row = 0; row < count; row++)
+                for (let x = width - 1; x > 0; x--)
+                    for (let c = 0; c < channels; c++) {
+                        const p = (row * width + x) * channels + c;
+                        pixels[p] -= pixels[p - channels];
+                    }
+        let blob = new Blob([
+            compression === "packbits" ? packBits(pixels) : pixels,
+        ]);
+        if (compression === "deflate")
+            blob = await new Response(blob.stream().pipeThrough(new CompressionStream("deflate"))).blob();
+        strips.push(blob);
+        progress?.(Math.min(1, (y + count) / height));
+    }
+    const header = tiffHeader(width, height, bounds, crs, geographic, options, strips.map((s) => s.size), rows, channels);
+    return new Blob([header, ...strips], { type: "image/tiff" });
+}
+/**
+ * Convenience ArrayBuffer encoder wrapping encodeGeoTiffBlob. Materializes a complete output copy; the worker uses the Blob API.
+ * @param data - Row-major 8-bit RGBA with unassociated alpha.
+ * @param width - Positive integer pixel width.
+ * @param height - Positive integer pixel height.
+ * @param bounds - Outer pixel-edge extent in the output CRS, with row zero at maxY.
+ * @param crs - EPSG identifier with numeric code below 32767. Custom WKT GeoKeys are not supported.
+ * @param geographic - True for geographic CRS GeoKeys, false for projected CRS GeoKeys; must agree with crs.
+ * @param compression - Strip codec; defaults to none.
+ */
+export async function encodeGeoTiffOutput(data, width, height, bounds, crs, geographic, compression = "none") {
+    return (await encodeGeoTiffBlob(data, width, height, bounds, crs, geographic, {
+        compression,
+    })).arrayBuffer();
+}
+/**
+ * Encode TIFF PackBits literal/repeated runs of at most 128 bytes, with a bounded
+ * worst-case output allocation.
+ */
+function packBits(data) {
+    const out = new Uint8Array(data.length + Math.ceil(data.length / 128) + 2);
+    let cursor = 0;
+    for (let i = 0; i < data.length;) {
+        let run = 1;
+        while (run < 128 && i + run < data.length && data[i + run] === data[i])
+            run++;
+        if (run >= 3) {
+            out[cursor++] = 257 - run;
+            out[cursor++] = data[i];
+            i += run;
+            continue;
+        }
+        const start = i;
+        i += run;
+        while (i < data.length && i - start < 128) {
+            run = 1;
+            while (run < 3 && i + run < data.length && data[i + run] === data[i])
+                run++;
+            if (run >= 3)
+                break;
+            i += Math.min(run, 128 - (i - start));
+        }
+        out[cursor++] = i - start - 1;
+        out.set(data.subarray(start, i), cursor);
+        cursor += i - start;
+    }
+    return out.subarray(0, cursor);
+}
+/**
+ * Build a little-endian classic TIFF IFD with PixelIsArea, upper-left tiepoint, GeoKeys
+ * and strip offsets. Rejects offsets reaching the 4 GiB classic-TIFF limit.
+ */
+function tiffHeader(width, height, bounds, crs, geographic, options, lengths, rows, channels) {
+    const epsg = Number(/^EPSG:(\d+)$/.exec(crs)?.[1]);
+    if (!epsg || epsg >= 32767)
+        fail("CRS", "GeoTIFF requires an EPSG code below 32767 with a registered definition.");
+    const keys = [
+        1,
+        1,
+        0,
+        3,
+        1024,
+        0,
+        1,
+        geographic ? 2 : 1,
+        1025,
+        0,
+        1,
+        1,
+        geographic ? 2048 : 3072,
+        0,
+        1,
+        epsg,
+    ];
+    const entries = [
+        [256, 4, [width]],
+        [257, 4, [height]],
+        [258, 3, Array(channels).fill(8)],
+        [259, 3, [compressionCodes[options.compression ?? "none"]]],
+        [262, 3, [2]],
+        [273, 4, lengths.map(() => 0)],
+        [274, 3, [1]],
+        [277, 3, [channels]],
+        [278, 4, [rows]],
+        [279, 4, lengths],
+        [284, 3, [1]],
+        [339, 3, Array(channels).fill(1)],
+        [
+            33550,
+            12,
+            [(bounds[2] - bounds[0]) / width, (bounds[3] - bounds[1]) / height, 0],
+        ],
+        [33922, 12, [0, 0, 0, bounds[0], bounds[3], 0]],
+        [34735, 3, keys],
+    ];
+    if (channels === 4)
+        entries.push([338, 3, [2]]);
+    if (options.predictor === 2)
+        entries.push([317, 3, [2]]);
+    if (options.noData !== undefined)
+        entries.push([
+            42113,
+            2,
+            [...new TextEncoder().encode(String(options.noData)), 0],
+        ]);
+    entries.sort((a, b) => a[0] - b[0]);
+    const size = (type) => type === 2 ? 1 : type === 3 ? 2 : type === 4 ? 4 : 8;
+    const align = (n) => Math.ceil(n / 8) * 8;
+    let end = align(8 + 2 + 12 * entries.length + 4);
+    for (const [, type, values] of entries)
+        if (values.length * size(type) > 4)
+            end = align(end + values.length * size(type));
+    let offset = end;
+    entries.find((e) => e[0] === 273)[2] = lengths.map((n) => {
+        const start = offset;
+        offset += n;
+        return start;
+    });
+    if (offset >= 0xffffffff)
+        fail("OUTPUT_BUDGET", "Classic TIFF is limited to 4 GiB. Reduce output dimensions.");
+    const header = new ArrayBuffer(end), view = new DataView(header);
+    view.setUint16(0, 0x4949, true);
+    view.setUint16(2, 42, true);
+    view.setUint32(4, 8, true);
+    view.setUint16(8, entries.length, true);
+    let payload = align(8 + 2 + 12 * entries.length + 4);
+    entries.forEach(([tag, type, values], index) => {
+        const p = 10 + index * 12, bytes = values.length * size(type), dest = bytes <= 4 ? p + 8 : payload;
+        view.setUint16(p, tag, true);
+        view.setUint16(p + 2, type, true);
+        view.setUint32(p + 4, values.length, true);
+        if (bytes > 4) {
+            view.setUint32(p + 8, payload, true);
+            payload = align(payload + bytes);
+        }
+        values.forEach((v, i) => {
+            if (type === 2)
+                view.setUint8(dest + i, v);
+            else if (type === 3)
+                view.setUint16(dest + i * 2, v, true);
+            else if (type === 4)
+                view.setUint32(dest + i * 4, v, true);
+            else
+                view.setFloat64(dest + i * 8, v, true);
+        });
+    });
+    return header;
+}

package/dist/types.d.ts

@@ -0,0 +1,14 @@
+/** Optional deployment overrides for one format's dedicated encoding worker. */
+export interface RasterPluginOptions {
+    /** Host factory for a dedicated codec worker; takes precedence over workerUrl. */
+    workerFactory?: () => Worker;
+    /** Same-origin URL of this format's deployed module worker. */
+    workerUrl?: string | URL;
+}
+/** JPEG encoding options. Georeferencing is delivered in required sidecars. */
+export interface JpegOptions extends RasterPluginOptions {
+    /** Browser JPEG quality in [0, 1]; defaults to 0.92. JPEG is lossy. */
+    quality?: number;
+    /** Opaque RGB background for transparent/no-data pixels; defaults to white. */
+    background?: [number, number, number];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/workers/geotiff.d.ts

@@ -0,0 +1 @@
+export {};