@reekon-tools/boldr-utils 1.21.1 → 1.23.0

package/dist/export/pdf/pageMapping.d.ts

@@ -0,0 +1,51 @@
+import type { AnnotationPdfDocument, AnnotationPdfPageSize } from '../../types/annotation.js';
+export interface DocRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** A PDF page's box in unrotated user space (pdf-lib's getCropBox shape). */
+export interface PdfBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** PDF `cm` matrix [a b c d e f]: (x, y) → (a·x + c·y + e, b·x + d·y + f). */
+export type AffineMatrix = [
+    a: number,
+    b: number,
+    c: number,
+    d: number,
+    e: number,
+    f: number
+];
+export type PageRotation = 0 | 90 | 180 | 270;
+export declare const normalizeRotation: (degrees: number) => PageRotation;
+/** Doc-space rect of every page, index-aligned with `doc.pages`. */
+export declare const pageRectsOf: (doc: AnnotationPdfDocument) => DocRect[];
+/** The displayed (post-rotation) size a CropBox has under `rotation`. */
+export declare const rotatedBoxSize: (box: PdfBox, rotation: PageRotation) => AnnotationPdfPageSize;
+/**
+ * The matrix that maps a doc-space point (stack coordinates, y-down) onto the
+ * page's PDF user space (y-up, unrotated, CropBox origin). `pageRect` is the
+ * page's rect in the stack, `cropBox` its box in user space, `rotation` its
+ * normalized `/Rotate`.
+ */
+export declare const docToPageMatrix: (pageRect: DocRect, cropBox: PdfBox, rotation: PageRotation) => AffineMatrix;
+/** Apply an affine matrix to a point (for tests and bounds checks). */
+export declare const applyMatrix: (m: AffineMatrix, x: number, y: number) => {
+    x: number;
+    y: number;
+};
+/** The overlap of two rects, or null when they do not overlap. */
+export declare const intersectRects: (a: DocRect, b: DocRect) => DocRect | null;
+export declare const rectsIntersect: (a: DocRect, b: DocRect) => boolean;
+/** Axis-aligned bounds → DocRect, inflated by `pad` on every side. */
+export declare const boundsToRect: (b: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}, pad?: number) => DocRect;

package/dist/export/pdf/pageMapping.js

@@ -0,0 +1,77 @@
+// Where each PDF page sits in canvas doc space, and the one affine matrix that
+// carries a doc-space point onto that page's PDF user space.
+//
+// Doc space on a PDF-backed canvas IS PDF points, y-down, with the pages laid
+// out by pdfPageDocRects (the continuous vertical filmstrip). PDF user space is
+// y-up, unrotated, and its origin is wherever the CropBox says. The matrix
+// below folds all three differences — the page's offset in the stack, the
+// y-flip, and `/Rotate` — into a single `cm` so every mark is emitted in its
+// stored doc coordinates unchanged.
+//
+// ROTATION CONVENTION (measured against PDFium in __tests__/pageMapping): a
+// `/Rotate 90` page is displayed rotated 90° clockwise, so the unrotated
+// page's top-left corner lands at the displayed page's top-RIGHT. The stored
+// page sizes (AnnotationPdfDocument.pages) are post-rotation extents, i.e.
+// exactly the displayed W×H the matrix maps from.
+import { pdfPageDocRects } from '../../annotation/canvas/pdfDocument.js';
+export const normalizeRotation = (degrees) => {
+    const r = (((Math.round(degrees / 90) * 90) % 360) + 360) % 360;
+    return r;
+};
+/** Doc-space rect of every page, index-aligned with `doc.pages`. */
+export const pageRectsOf = (doc) => pdfPageDocRects(doc);
+/** The displayed (post-rotation) size a CropBox has under `rotation`. */
+export const rotatedBoxSize = (box, rotation) => rotation === 90 || rotation === 270
+    ? { width: box.height, height: box.width }
+    : { width: box.width, height: box.height };
+/**
+ * The matrix that maps a doc-space point (stack coordinates, y-down) onto the
+ * page's PDF user space (y-up, unrotated, CropBox origin). `pageRect` is the
+ * page's rect in the stack, `cropBox` its box in user space, `rotation` its
+ * normalized `/Rotate`.
+ */
+export const docToPageMatrix = (pageRect, cropBox, rotation) => {
+    const { x: rx, y: ry } = pageRect;
+    const { x: cx, y: cy, width: cw, height: ch } = cropBox;
+    switch (rotation) {
+        case 0:
+            // X = cx + (x - rx);  Y = cy + ch - (y - ry)
+            return [1, 0, 0, -1, cx - rx, cy + ch + ry];
+        case 90:
+            // Displayed top-left is the unrotated bottom-left.
+            // X = cx + (y - ry);  Y = cy + (x - rx)
+            return [0, 1, 1, 0, cx - ry, cy - rx];
+        case 180:
+            // X = cx + cw - (x - rx);  Y = cy + (y - ry)
+            return [-1, 0, 0, 1, cx + cw + rx, cy - ry];
+        case 270:
+            // X = cx + cw - (y - ry);  Y = cy + ch - (x - rx)
+            return [0, -1, -1, 0, cx + cw + ry, cy + ch + rx];
+    }
+};
+/** Apply an affine matrix to a point (for tests and bounds checks). */
+export const applyMatrix = (m, x, y) => ({
+    x: m[0] * x + m[2] * y + m[4],
+    y: m[1] * x + m[3] * y + m[5],
+});
+/** The overlap of two rects, or null when they do not overlap. */
+export const intersectRects = (a, b) => {
+    const x = Math.max(a.x, b.x);
+    const y = Math.max(a.y, b.y);
+    const right = Math.min(a.x + a.width, b.x + b.width);
+    const bottom = Math.min(a.y + a.height, b.y + b.height);
+    if (right <= x || bottom <= y)
+        return null;
+    return { x, y, width: right - x, height: bottom - y };
+};
+export const rectsIntersect = (a, b) => a.x < b.x + b.width &&
+    a.x + a.width > b.x &&
+    a.y < b.y + b.height &&
+    a.y + a.height > b.y;
+/** Axis-aligned bounds → DocRect, inflated by `pad` on every side. */
+export const boundsToRect = (b, pad = 0) => ({
+    x: b.minX - pad,
+    y: b.minY - pad,
+    width: b.maxX - b.minX + 2 * pad,
+    height: b.maxY - b.minY + 2 * pad,
+});

package/dist/export/pdf/renderCanvasToPdf.d.ts

@@ -0,0 +1,2 @@
+import { type RenderCanvasToPdfInput, type RenderCanvasToPdfResult } from './types.js';
+export declare const renderCanvasToPdf: (input: RenderCanvasToPdfInput) => Promise<RenderCanvasToPdfResult>;

package/dist/export/pdf/renderCanvasToPdf.js

@@ -0,0 +1,288 @@
+// The canvas → PDF renderer: opens the original document, and appends the
+// canvas's layers, marks and tiles to each page's content stream under one
+// matrix per page. The original page content and its own /Annots are never
+// touched, so the source stays vector, searchable and selectable.
+import { EncryptedPDFError, PDFDocument, } from 'pdf-lib';
+import { backgroundLayersOf } from '../../annotation/canvas/backgroundLayers.js';
+import { fitRectToScreen } from '../../annotation/canvas/viewport.js';
+import { STAMP_TILE_SIZE } from '../../annotation/canvas/stampLayout.js';
+import { clipRectOps, withMatrix } from './emit.js';
+import { PdfFonts } from './fonts.js';
+import { layerOps, layerVisibleRect } from './layers.js';
+import { addMarkAnnotation } from './annots.js';
+import { measurementMark, measurementMarkBounds, measurementMarkOps, shapeBounds, shapeMark, shapeOps, strokeBounds, strokeMark, strokeOps, } from './marks.js';
+import { FormScope, PageScope } from './resources.js';
+import { docToPageMatrix, normalizeRotation, pageRectsOf, rectsIntersect, rotatedBoxSize, } from './pageMapping.js';
+import { designBoxFor, tileFootprint, tileOps } from './tiles.js';
+import { PdfExportError, } from './types.js';
+/** Stored page sizes may differ from the file's boxes by rounding only. */
+const PAGE_SIZE_TOLERANCE_PT = 1.5;
+/**
+ * Reference view for the calibration fallback: the doc-space edge a scale-1
+ * tile covers when the first page is fitted into a landscape tablet-ish view.
+ */
+const FALLBACK_VIEW = { width: 1024, height: 768 };
+const intersectBoxes = (a, b) => {
+    const x = Math.max(a.x, b.x);
+    const y = Math.max(a.y, b.y);
+    const right = Math.min(a.x + a.width, b.x + b.width);
+    const top = Math.min(a.y + a.height, b.y + b.height);
+    if (right <= x || top <= y)
+        return a;
+    return { x, y, width: right - x, height: top - y };
+};
+/** PDFium's page box: CropBox ∩ MediaBox, falling back to the MediaBox. */
+const pageBox = (page) => {
+    const media = page.getMediaBox();
+    const crop = page.node.CropBox() ? page.getCropBox() : media;
+    return intersectBoxes(crop, media);
+};
+const embedImage = (doc, img) => img.mime === 'image/png' ? doc.embedPng(img.bytes) : doc.embedJpg(img.bytes);
+const loadSource = async (bytes) => {
+    try {
+        return await PDFDocument.load(bytes, { updateMetadata: false });
+    }
+    catch (e) {
+        // Both checks: pdf-lib's dual CJS/ESM build can hand back an
+        // EncryptedPDFError whose class identity differs from the one imported.
+        if (e instanceof EncryptedPDFError ||
+            (e instanceof Error && /is encrypted/i.test(e.message))) {
+            throw new PdfExportError('encrypted', 'The source PDF is encrypted; strip it with stripPdfEncryption before rendering');
+        }
+        throw new PdfExportError('corrupt', `The source PDF could not be parsed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+};
+export const renderCanvasToPdf = async (input) => {
+    const { canvas } = input;
+    const pdfDoc = canvas.viewport.pdfDocument;
+    if (!pdfDoc) {
+        throw new PdfExportError('no-pdf-document', 'This canvas has no PDF document to export');
+    }
+    const doc = await loadSource(input.sourcePdf);
+    const pages = doc.getPages();
+    if (pages.length !== pdfDoc.pageCount ||
+        pdfDoc.pages.length !== pages.length) {
+        throw new PdfExportError('page-count-mismatch', `The canvas records ${pdfDoc.pages.length} pages but the PDF has ${pages.length}`);
+    }
+    const pageRects = pageRectsOf(pdfDoc);
+    const skipped = [];
+    // Per-page geometry, validated against what the canvas was laid out from.
+    const geometry = pages.map((page, i) => {
+        const box = pageBox(page);
+        const rotation = normalizeRotation(page.getRotation().angle);
+        const size = rotatedBoxSize(box, rotation);
+        const stored = pdfDoc.pages[i];
+        if (Math.abs(size.width - stored.width) > PAGE_SIZE_TOLERANCE_PT ||
+            Math.abs(size.height - stored.height) > PAGE_SIZE_TOLERANCE_PT) {
+            throw new PdfExportError('page-geometry-mismatch', `Page ${i + 1} is ${size.width}×${size.height} pt in the PDF but ${stored.width}×${stored.height} pt on the canvas`);
+        }
+        return { page, box, rotation, rect: pageRects[i] };
+    });
+    const fonts = await PdfFonts.create(doc, input.primaryFont);
+    // Background layers: embed once, draw on every page they overlap.
+    const layers = backgroundLayersOf(canvas.viewport);
+    const layerImages = new Map();
+    for (const layer of layers) {
+        if (layer.format === 'svg') {
+            skipped.push({
+                id: layer.id,
+                kind: 'layer',
+                reason: 'SVG background layers are not exported yet',
+            });
+            continue;
+        }
+        const bytes = input.layerImages[layer.id];
+        if (!bytes) {
+            skipped.push({
+                id: layer.id,
+                kind: 'layer',
+                reason: 'Layer image bytes were not provided',
+            });
+            continue;
+        }
+        try {
+            layerImages.set(layer.id, await embedImage(doc, bytes));
+        }
+        catch (e) {
+            skipped.push({
+                id: layer.id,
+                kind: 'layer',
+                reason: `Layer image could not be embedded: ${e instanceof Error ? e.message : String(e)}`,
+            });
+        }
+    }
+    // Tiles: resolve content once; embed object thumbnails once.
+    const tiles = canvas.placedMeasurements.map((placed) => {
+        const content = input.resolveTile(placed) ?? {
+            kind: 'empty',
+        };
+        return { placed, content };
+    });
+    const thumbnails = new Map();
+    for (const { placed, content } of tiles) {
+        if (content.kind === 'object' && content.thumbnail) {
+            try {
+                thumbnails.set(placed.id, await embedImage(doc, content.thumbnail));
+            }
+            catch (e) {
+                skipped.push({
+                    id: placed.id,
+                    kind: 'tile',
+                    reason: `Object thumbnail could not be embedded: ${e instanceof Error ? e.message : String(e)}`,
+                });
+            }
+        }
+    }
+    const firstRect = pageRects[0];
+    const fallbackDocEdge = STAMP_TILE_SIZE /
+        Math.max(fitRectToScreen(firstRect, FALLBACK_VIEW.width, FALLBACK_VIEW.height)
+            .zoom, 1e-6);
+    const hiddenLayerIds = new Set(canvas.layers.filter((l) => l.visible === false).map((l) => l.id));
+    const visible = (layerId) => !hiddenLayerIds.has(layerId);
+    const mode = input.mode ?? 'annotations';
+    let annotationCount = 0;
+    /** Content string for a tile's annotation (what Acrobat's comment shows). */
+    const tileContents = (content) => {
+        switch (content.kind) {
+            case 'measurement':
+                return [
+                    content.label,
+                    `${content.negative ? '-' : ''}${content.value} ${content.unit}`.trim(),
+                ]
+                    .filter(Boolean)
+                    .join(': ');
+            case 'planeDimension':
+                return `${content.value} ${content.unit}`.trim();
+            case 'header':
+                return (content.descriptor.name ??
+                    content.descriptor.badges.map((b) => b.text).join(' '));
+            case 'object':
+                return content.name;
+            case 'literal':
+                return content.value || undefined;
+            case 'instructions':
+                return content.text || undefined;
+            default:
+                return undefined;
+        }
+    };
+    for (const { page, box, rotation, rect } of geometry) {
+        const matrix = docToPageMatrix(rect, box, rotation);
+        const onPage = (b) => b !== null && rectsIntersect(b, rect);
+        if (mode === 'flatten') {
+            // Everything into the page's content stream, under one matrix + clip.
+            const scope = new PageScope(page, doc.context);
+            const ctx = { scope, fonts, skipped };
+            const ops = [];
+            for (const layer of layers) {
+                const img = layerImages.get(layer.id);
+                if (!img || !onPage(layerVisibleRect(layer)))
+                    continue;
+                ops.push(...layerOps(layer, scope.imageKey(img)));
+            }
+            for (const s of canvas.strokes) {
+                if (!visible(s.layerId) || !onPage(strokeBounds(s)))
+                    continue;
+                ops.push(...strokeOps(s, ctx));
+            }
+            for (const sh of canvas.shapes) {
+                if (!visible(sh.layerId) || !onPage(shapeBounds(sh)))
+                    continue;
+                ops.push(...shapeOps(sh, ctx));
+            }
+            for (const { placed } of tiles) {
+                if (!visible(placed.layerId) || !onPage(measurementMarkBounds(placed)))
+                    continue;
+                ops.push(...measurementMarkOps(placed, ctx));
+            }
+            for (const { placed, content } of tiles) {
+                if (!visible(placed.layerId))
+                    continue;
+                const footprint = tileFootprint(placed, canvas, input.calibration, fallbackDocEdge, designBoxFor(placed, content));
+                if (!onPage(footprint))
+                    continue;
+                ops.push(...tileOps({ scope, fonts, thumbnail: thumbnails.get(placed.id) }, content, footprint));
+            }
+            if (ops.length === 0)
+                continue;
+            page.pushOperators(...withMatrix(matrix, [
+                ...clipRectOps(rect.x, rect.y, rect.width, rect.height),
+                ...ops,
+            ]));
+            continue;
+        }
+        // Annotation mode: one annotation per element, each with its own
+        // appearance stream and resources. Same z-order as the screen.
+        const add = (mark, scope, groupWith) => {
+            if (!mark)
+                return null;
+            const ref = addMarkAnnotation({
+                doc,
+                page,
+                mark,
+                pageRect: rect,
+                matrix,
+                scope,
+                groupWith,
+            });
+            if (ref)
+                annotationCount++;
+            return ref;
+        };
+        for (const layer of layers) {
+            const img = layerImages.get(layer.id);
+            const bounds = layerVisibleRect(layer);
+            if (!img || !onPage(bounds))
+                continue;
+            const scope = new FormScope(doc.context);
+            add({
+                id: layer.id,
+                ops: layerOps(layer, scope.imageKey(img)),
+                bounds,
+                annot: {
+                    subtype: 'Stamp',
+                    contents: layer.fileId ? 'Placed file' : 'Background image',
+                },
+            }, scope);
+        }
+        for (const s of canvas.strokes) {
+            if (!visible(s.layerId) || !onPage(strokeBounds(s)))
+                continue;
+            const scope = new FormScope(doc.context);
+            add(strokeMark(s, { scope, fonts, skipped }), scope);
+        }
+        for (const sh of canvas.shapes) {
+            if (!visible(sh.layerId) || !onPage(shapeBounds(sh)))
+                continue;
+            const scope = new FormScope(doc.context);
+            add(shapeMark(sh, { scope, fonts, skipped }), scope);
+        }
+        // A measurement's line/rect and its tile are grouped (Acrobat honours
+        // /IRT + /RT /Group; other viewers treat them independently).
+        const markRefs = new Map();
+        for (const { placed } of tiles) {
+            if (!visible(placed.layerId) || !onPage(measurementMarkBounds(placed)))
+                continue;
+            const scope = new FormScope(doc.context);
+            const ref = add(measurementMark(placed, { scope, fonts, skipped }), scope);
+            if (ref)
+                markRefs.set(placed.id, ref);
+        }
+        for (const { placed, content } of tiles) {
+            if (!visible(placed.layerId))
+                continue;
+            const footprint = tileFootprint(placed, canvas, input.calibration, fallbackDocEdge, designBoxFor(placed, content));
+            if (!onPage(footprint))
+                continue;
+            const scope = new FormScope(doc.context);
+            add({
+                id: placed.id,
+                ops: tileOps({ scope, fonts, thumbnail: thumbnails.get(placed.id) }, content, footprint),
+                bounds: footprint,
+                annot: { subtype: 'Stamp', contents: tileContents(content) },
+            }, scope, markRefs.get(placed.id));
+        }
+    }
+    const pdf = await doc.save({ useObjectStreams: false });
+    return { pdf, pageCount: pages.length, annotationCount, skipped };
+};

package/dist/export/pdf/resources.d.ts

@@ -0,0 +1,35 @@
+import { PDFContext, PDFDict, PDFFont, PDFImage, PDFName, PDFPage } from 'pdf-lib';
+export interface ResourceScope {
+    fontKey(font: PDFFont): PDFName;
+    imageKey(image: PDFImage): PDFName;
+    /** An ExtGState carrying `alpha` (CA/ca), or undefined at full opacity. */
+    alphaState(alpha: number): PDFName | undefined;
+}
+/** Resources on the page itself — content-stream (flatten) output. */
+export declare class PageScope implements ResourceScope {
+    private readonly page;
+    private readonly context;
+    private readonly fonts;
+    private readonly images;
+    private readonly alphas;
+    constructor(page: PDFPage, context: PDFContext);
+    fontKey(font: PDFFont): PDFName;
+    imageKey(image: PDFImage): PDFName;
+    alphaState(alpha: number): PDFName | undefined;
+}
+/** Resources collected for ONE appearance stream (annotation mode). */
+export declare class FormScope implements ResourceScope {
+    private readonly context;
+    private readonly fontDict;
+    private readonly xobjectDict;
+    private readonly gsDict;
+    private readonly fonts;
+    private readonly images;
+    private readonly alphas;
+    constructor(context: PDFContext);
+    fontKey(font: PDFFont): PDFName;
+    imageKey(image: PDFImage): PDFName;
+    alphaState(alpha: number): PDFName | undefined;
+    /** The /Resources dictionary for the appearance stream. */
+    resources(): PDFDict;
+}

package/dist/export/pdf/resources.js

@@ -0,0 +1,95 @@
+// Where an element's PDF resources (fonts, images, opacity states) get
+// registered. The emitters only ask a scope for a resource NAME; whether that
+// name lands in the page's resource dictionary (flatten mode) or in one
+// annotation appearance stream's own /Resources (annotation mode) is the
+// scope's business.
+import { PDFName, } from 'pdf-lib';
+const roundAlpha = (alpha) => Math.round(Math.min(1, Math.max(0, alpha)) * 1000) / 1000;
+const extGState = (context, alpha) => context.obj({ Type: 'ExtGState', CA: alpha, ca: alpha });
+/** Resources on the page itself — content-stream (flatten) output. */
+export class PageScope {
+    constructor(page, context) {
+        this.page = page;
+        this.context = context;
+        this.fonts = new Map();
+        this.images = new Map();
+        this.alphas = new Map();
+    }
+    fontKey(font) {
+        let key = this.fonts.get(font);
+        if (!key) {
+            key = this.page.node.newFontDictionary(font.name, font.ref);
+            this.fonts.set(font, key);
+        }
+        return key;
+    }
+    imageKey(image) {
+        let key = this.images.get(image);
+        if (!key) {
+            key = this.page.node.newXObject('Im', image.ref);
+            this.images.set(image, key);
+        }
+        return key;
+    }
+    alphaState(alpha) {
+        const a = roundAlpha(alpha);
+        if (a >= 1)
+            return undefined;
+        let key = this.alphas.get(a);
+        if (!key) {
+            key = this.page.node.newExtGState('GSa', extGState(this.context, a));
+            this.alphas.set(a, key);
+        }
+        return key;
+    }
+}
+/** Resources collected for ONE appearance stream (annotation mode). */
+export class FormScope {
+    constructor(context) {
+        this.context = context;
+        this.fonts = new Map();
+        this.images = new Map();
+        this.alphas = new Map();
+        this.fontDict = context.obj({});
+        this.xobjectDict = context.obj({});
+        this.gsDict = context.obj({});
+    }
+    fontKey(font) {
+        let key = this.fonts.get(font);
+        if (!key) {
+            key = PDFName.of(`F${this.fonts.size + 1}`);
+            this.fontDict.set(key, font.ref);
+            this.fonts.set(font, key);
+        }
+        return key;
+    }
+    imageKey(image) {
+        let key = this.images.get(image);
+        if (!key) {
+            key = PDFName.of(`Im${this.images.size + 1}`);
+            this.xobjectDict.set(key, image.ref);
+            this.images.set(image, key);
+        }
+        return key;
+    }
+    alphaState(alpha) {
+        const a = roundAlpha(alpha);
+        if (a >= 1)
+            return undefined;
+        let key = this.alphas.get(a);
+        if (!key) {
+            key = PDFName.of(`GS${this.alphas.size + 1}`);
+            this.gsDict.set(key, extGState(this.context, a));
+            this.alphas.set(a, key);
+        }
+        return key;
+    }
+    /** The /Resources dictionary for the appearance stream. */
+    resources() {
+        return this.context.obj({
+            Font: this.fontDict,
+            XObject: this.xobjectDict,
+            ExtGState: this.gsDict,
+        });
+    }
+}

package/dist/export/pdf/tileContent.d.ts

@@ -0,0 +1,39 @@
+import type { AnnotationCanvasState, PlacedMeasurementRef } from '../../types/annotation.js';
+import { DecimalTolerance, FractionalTolerance, Units, type Formula, type Group, type Measurement, type Section } from '../../types/firestore.js';
+import type { EmbeddedImage, ResolvedTileContent } from './types.js';
+/** Fill for a FORM formula-column tile (the job page's purple). */
+export declare const FORMULA_COLUMN_TILE_FILL = "#7B4783";
+/** Fill for a plane-computed length tile (calibration teal). */
+export declare const PLANE_COMPUTED_TILE_FILL = "#0E7490";
+export interface TileFileInfo {
+    name: string;
+    type?: string;
+    thumbnail?: EmbeddedImage;
+}
+export interface TileResolutionContext {
+    canvas: Pick<AnnotationCanvasState, 'planes'>;
+    units: Units;
+    fractionalTolerance?: FractionalTolerance;
+    decimalTolerance?: DecimalTolerance;
+    groups: Group[];
+    sections: Section[];
+    /** Every measurement a tile may reference, by id. */
+    measurementsById: Map<string, Measurement>;
+    formulas?: Formula[];
+    /** Placed object files, by file id. */
+    filesById?: Map<string, TileFileInfo>;
+    /** The canvas file's own group — the fallback source group for a tile. */
+    hostGroupId?: string;
+}
+/**
+ * The tile fill, in measurementTileFill's precedence: unsaved scratch grey-blue,
+ * completed grey, an explicit colour, formula magenta, else tile blue.
+ */
+export declare const measurementTileFillFor: ({ internal, isCompleted, groupFormula, color, }: {
+    internal?: boolean;
+    isCompleted?: boolean;
+    groupFormula?: unknown;
+    color?: string;
+}) => string;
+/** What a placed tile shows, from the documents in `ctx`. */
+export declare const resolveTileContent: (placed: PlacedMeasurementRef, ctx: TileResolutionContext) => ResolvedTileContent;