@penpair/core 0.3.7 → 0.4.0

package/dist/image-evidence.js

@@ -0,0 +1,121 @@
+import { open } from "node:fs/promises";
+import { resolveProjectInput } from "./project-input.js";
+export const maximumImageBytes = 64 * 1024 * 1024;
+function losslessWebpSize(bytes) {
+    const malformed = () => new Error("Malformed static lossless WebP evidence");
+    if (bytes.readUInt32LE(4) + 8 !== bytes.length) {
+        throw malformed();
+    }
+    let imageSize;
+    let canvasSize;
+    let offset = 12;
+    while (offset < bytes.length) {
+        if (offset + 8 > bytes.length) {
+            throw malformed();
+        }
+        const chunk = bytes.subarray(offset, offset + 4).toString("latin1");
+        const size = bytes.readUInt32LE(offset + 4);
+        const payload = offset + 8;
+        const end = payload + size;
+        const paddedEnd = end + (size % 2);
+        if (paddedEnd > bytes.length || (size % 2 !== 0 && bytes[end] !== 0)) {
+            throw malformed();
+        }
+        if (chunk === "VP8 " || chunk === "ANIM" || chunk === "ANMF" || chunk === "ALPH") {
+            throw new Error("Provider evidence must reference PNG or static lossless WebP bytes");
+        }
+        if (chunk === "VP8X") {
+            if (offset !== 12 ||
+                canvasSize ||
+                size !== 10 ||
+                (bytes[payload] & 0xc3) !== 0 ||
+                bytes.readUIntLE(payload + 1, 3) !== 0) {
+                throw malformed();
+            }
+            canvasSize = {
+                width: bytes.readUIntLE(payload + 4, 3) + 1,
+                height: bytes.readUIntLE(payload + 7, 3) + 1,
+            };
+        }
+        else if (chunk === "VP8L") {
+            if (imageSize || size <= 5 || bytes[payload] !== 0x2f) {
+                throw malformed();
+            }
+            const dimensions = bytes.readUInt32LE(payload + 1);
+            if (dimensions >>> 29 !== 0) {
+                throw malformed();
+            }
+            imageSize = {
+                width: (dimensions & 0x3fff) + 1,
+                height: ((dimensions >>> 14) & 0x3fff) + 1,
+            };
+        }
+        else if (offset === 12) {
+            throw malformed();
+        }
+        offset = paddedEnd;
+    }
+    if (!imageSize ||
+        (canvasSize && (canvasSize.width !== imageSize.width || canvasSize.height !== imageSize.height))) {
+        throw malformed();
+    }
+    return imageSize;
+}
+/** Header/container assurance only; this does not decode compressed pixels. */
+export function inspectImageEvidence(bytes) {
+    if (bytes.length > maximumImageBytes) {
+        throw new Error("Image exceeds 64 MiB");
+    }
+    if (bytes.length >= 24 &&
+        bytes.subarray(0, 8).toString("hex") === "89504e470d0a1a0a" &&
+        bytes.subarray(12, 16).toString("latin1") === "IHDR") {
+        const width = bytes.readUInt32BE(16);
+        const height = bytes.readUInt32BE(20);
+        if (width > 0 && height > 0) {
+            return {
+                format: "png",
+                width,
+                height,
+            };
+        }
+    }
+    else if (bytes.length >= 12 &&
+        bytes.subarray(0, 4).toString("latin1") === "RIFF" &&
+        bytes.subarray(8, 12).toString("latin1") === "WEBP") {
+        return {
+            format: "webp",
+            ...losslessWebpSize(bytes),
+        };
+    }
+    throw new Error("Provider evidence must reference PNG or static lossless WebP bytes");
+}
+export async function readImageEvidence(root, file) {
+    const input = await resolveProjectInput(root, file);
+    const handle = await open(input, "r");
+    try {
+        const info = await handle.stat();
+        if (!info.isFile() || info.size > maximumImageBytes) {
+            throw new Error("Image exceeds 64 MiB or is not a regular file");
+        }
+        const buffer = Buffer.alloc(info.size + 1);
+        let length = 0;
+        while (length < buffer.length) {
+            const { bytesRead } = await handle.read(buffer, length, buffer.length - length, null);
+            if (bytesRead === 0) {
+                break;
+            }
+            length += bytesRead;
+        }
+        if (length > info.size) {
+            throw new Error("Image changed during bounded read");
+        }
+        const bytes = buffer.subarray(0, length);
+        return {
+            bytes,
+            ...inspectImageEvidence(bytes),
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}

package/dist/index.d.ts

@@ -56,3 +56,8 @@ export * from "./project-status.js";
 export * from "./audit-rules.js";
 export * from "./credentials.js";
 export * from "./token-projection.js";
+export * from "./image-evidence.js";
+export * from "./image-codec.js";
+export * from "./maps/index.js";
+export * from "./map-penpot/index.js";
+export * from "./design-releases/index.js";

package/dist/index.js

@@ -55,3 +55,8 @@ export * from "./project-status.js";
 export * from "./audit-rules.js";
 export * from "./credentials.js";
 export * from "./token-projection.js";
+export * from "./image-evidence.js";
+export * from "./image-codec.js";
+export * from "./maps/index.js";
+export * from "./map-penpot/index.js";
+export * from "./design-releases/index.js";

package/dist/inspection.js

@@ -79,6 +79,7 @@ const clone = (value, unknowns, key) => {
   } catch { unknowns.push(key); return null; }
 };
 const read = (object,key,unknowns,label=key) => { try { return clone(object[key],unknowns,label); } catch { unknowns.push(label); return null; } };
+const optional = (object,key,unknowns,label=key) => { try { const value=object[key]; return value===undefined?null:clone(value,unknowns,label); } catch {unknowns.push(label);return null;} };
 const pick = (object,keys,unknowns,prefix) => Object.fromEntries(keys.map(key=>[key,read(object,key,unknowns,prefix+"."+key)]));
 let estimatedBytes = 1024;
 if (CFG.kind === "shape") {
@@ -97,11 +98,11 @@ if (CFG.kind === "shape") {
     if (item.depth <= CFG.depth) {
       const unknowns = [], row = {id:s.id,parentId:item.parentId,index:item.index,depth:item.depth,type:read(s,"type",unknowns),name:read(s,"name",unknowns),childIds:children.slice(0,CFG.maxNodes).map(c=>c.id),childrenTotal:children.length,unknowns};
       if (children.length > CFG.maxNodes) reasons.add("node-budget");
-      if (CFG.fields.includes("geometry")) row.geometry = pick(s,["x","y","width","height","rotation","hidden","blocked"],unknowns,"geometry");
-      if (CFG.fields.includes("text")) row.text = s.type === "text" ? {characters:read(s,"characters",unknowns),typography:pick(s,["fontId","fontFamily","fontVariantId","fontSize","fontWeight","fontStyle","lineHeight","letterSpacing","growType","direction","align","verticalAlign"],unknowns,"typography")} : null;
+      if (CFG.fields.includes("geometry")) row.geometry = pick(s,["x","y","width","height","rotation","hidden","blocked","flipX","flipY","proportionLock"],unknowns,"geometry");
+      if (CFG.fields.includes("text")) row.text = s.type === "text" ? {characters:read(s,"characters",unknowns),typography:pick(s,["fontId","fontFamily","fontVariantId","fontSize","fontWeight","fontStyle","lineHeight","letterSpacing","growType","direction","align","verticalAlign","textTransform","textDecoration"],unknowns,"typography")} : null;
       if (row.text && Object.values(row.text.typography).includes("mixed")) unknowns.push("text.mixedRangeStyles");
       if (CFG.fields.includes("layout")) {
-        row.layout = {};
+        row.layout = {constraints:pick(s,["constraintsHorizontal","constraintsVertical","fixedWhenScrolling"],unknowns,"layout.constraints")};
         for (const [key,keys] of [["flex",["dir","wrap","alignItems","alignContent","justifyContent","rowGap","columnGap","topPadding","rightPadding","bottomPadding","leftPadding","horizontalSizing","verticalSizing"]],["layoutChild",["absolute","zIndex","horizontalSizing","verticalSizing","alignSelf","topMargin","rightMargin","bottomMargin","leftMargin","minWidth","maxWidth","minHeight","maxHeight"]]]) {
           try { row.layout[key] = s[key] ? pick(s[key],keys,unknowns,"layout."+key) : null; } catch { row.layout[key]=null; unknowns.push("layout."+key); }
         }
@@ -111,10 +112,17 @@ if (CFG.kind === "shape") {
           if(grid)for(const key of ["rows","columns"])row.layout.grid[key]=(grid[key]||[]).map((track,index)=>pick(track,["type","value"],unknowns,"layout.grid."+key+"."+index));
         } catch {row.layout.grid=null;unknowns.push("layout.grid");}
         try {row.layout.cell=s.layoutCell?pick(s.layoutCell,["row","rowSpan","column","columnSpan","areaName","position"],unknowns,"layout.cell"):null;} catch {row.layout.cell=null;unknowns.push("layout.cell");}
-        row.layout.clipContent = read(s,"clipContent",unknowns,"layout.clipContent");
+        row.layout.clipContent = s.type === "board" ? read(s,"clipContent",unknowns,"layout.clipContent") : null;
+        row.layout.showInViewMode = s.type === "board" ? read(s,"showInViewMode",unknowns,"layout.showInViewMode") : null;
+        row.layout.boardSizing = s.type === "board" ? Object.fromEntries(["horizontalSizing","verticalSizing"].map(key=>[key,optional(s,key,unknowns,"layout.boardSizing."+key)])) : null;
       }
       if (CFG.fields.includes("tokens")) row.tokens = read(s,"tokens",unknowns);
-      if (CFG.fields.includes("style")) row.style = pick(s,["fills","strokes","shadows","opacity","blendMode","borderRadiusTopLeft","borderRadiusTopRight","borderRadiusBottomRight","borderRadiusBottomLeft"],unknowns,"style");
+      if (CFG.fields.includes("style")) {
+        row.style = pick(s,["fills","strokes","shadows","opacity","blendMode","borderRadiusTopLeft","borderRadiusTopRight","borderRadiusBottomRight","borderRadiusBottomLeft"],unknowns,"style");
+        for (const key of ["blur","backgroundBlur"]) {
+          row.style[key]=optional(s,key,unknowns,"style."+key);
+        }
+      }
       if (CFG.fields.includes("component")) {
         row.component = {};
         for (const key of ["isComponentInstance","isComponentMainInstance","isComponentCopyInstance","isComponentRoot"]) {

package/dist/instance/config-schema.d.ts

@@ -160,6 +160,10 @@ export declare const projectConfigSchema: {
             readonly type: "object";
             readonly required: readonly ["page", "root", "frames"];
             readonly properties: {
+                readonly format: {
+                    readonly enum: readonly ["png", "webp"];
+                    readonly description: "Format for new references; existing approved formats are preserved unless explicitly migrated.";
+                };
                 readonly page: {
                     readonly type: "string";
                     readonly minLength: 1;

package/dist/instance/config-schema.js

@@ -280,6 +280,13 @@ export const projectConfigSchema = {
                 "frames",
             ],
             properties: {
+                format: {
+                    enum: [
+                        "png",
+                        "webp",
+                    ],
+                    description: "Format for new references; existing approved formats are preserved unless explicitly migrated.",
+                },
                 page: {
                     type: "string",
                     minLength: 1,

package/dist/map-penpot/content-validation.d.ts

@@ -0,0 +1,3 @@
+import type { MapDrawing } from "./types.js";
+/** Reject malformed content geometry before a publication can contact Penpot. */
+export declare function validateMapDrawingContent(drawing: MapDrawing): void;

package/dist/map-penpot/content-validation.js

@@ -0,0 +1,57 @@
+function text(value, maximum) {
+    return value === undefined || (typeof value === "string" && value.length <= maximum);
+}
+function box(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const bounds = value;
+    return ([
+        "x",
+        "y",
+        "width",
+        "height",
+    ].every((key) => Number.isFinite(bounds[key])) &&
+        Number(bounds.x) >= 0 &&
+        Number(bounds.y) >= 0 &&
+        Number(bounds.width) >= 64 &&
+        Number(bounds.height) > 0);
+}
+/** Reject malformed content geometry before a publication can contact Penpot. */
+export function validateMapDrawingContent(drawing) {
+    if (!text(drawing.goal, 8000) ||
+        !text(drawing.summary, 240) ||
+        !text(drawing.description, 8000)) {
+        throw new Error("Map descriptions exceed their supported text budgets");
+    }
+    if (drawing.header &&
+        (!box(drawing.header.titleBox) ||
+            (drawing.header.summaryBox !== undefined && !box(drawing.header.summaryBox)) ||
+            !Number.isFinite(drawing.header.legendY) ||
+            drawing.header.legendY < 0 ||
+            !Number.isFinite(drawing.header.height) ||
+            drawing.header.height <= 0)) {
+        throw new Error("Map header requires finite positive geometry");
+    }
+    if (drawing.annotations === undefined) {
+        return;
+    }
+    const nodeIds = new Set(drawing.nodes.map((node) => node.id));
+    if (!Array.isArray(drawing.annotations) ||
+        drawing.annotations.length > 1001 ||
+        new Set(drawing.annotations.map((annotation) => annotation?.id)).size !==
+            drawing.annotations.length ||
+        drawing.annotations.some((annotation) => !annotation ||
+            typeof annotation.id !== "string" ||
+            !/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,255}$/.test(annotation.id) ||
+            !box(annotation) ||
+            (annotation.nodeId !== undefined && !nodeIds.has(annotation.nodeId)) ||
+            typeof annotation.title !== "string" ||
+            !annotation.title.trim() ||
+            annotation.title.length > 4000 ||
+            !text(annotation.goal, 8000) ||
+            !text(annotation.summary, 240) ||
+            !text(annotation.description, annotation.nodeId ? 4000 : 8000))) {
+        throw new Error("Map annotations require unique identities, bounded text and finite geometry");
+    }
+}

package/dist/map-penpot/content.d.ts

@@ -0,0 +1,22 @@
+import type { MapDrawing, ProjectionShape } from "./types.js";
+export declare const nativeMapRoles: readonly ["node", "label", "edge", "edge-label", "title", "badge", "legend", "map-summary", "map-full-summary", "map-goal", "map-description", "summary", "full-label", "full-summary", "description", "annotation-panel", "annotation-id", "annotation-heading", "icon-well", "icon", "port-in", "port-out"];
+export interface NativeMapTextEntry {
+    role: ProjectionShape["role"];
+    logicalId: string;
+    text: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fontSize: number;
+    color: string;
+    strong?: boolean;
+    semantic?: {
+        scope: "map" | "node";
+        field: "title" | "goal" | "label" | "summary" | "description";
+        nodeId?: string;
+        compact?: boolean;
+    };
+}
+export declare function nativeMapTextEntries(drawing: MapDrawing): NativeMapTextEntry[];
+export declare function nativeMapShapeKeys(drawing: MapDrawing): Set<string>;

package/dist/map-penpot/content.js

@@ -0,0 +1,173 @@
+import { mapAnnotationLayout } from "../maps/annotation-layout.js";
+import { mapLabelHeight } from "../maps/layout.js";
+import { mapOriginLabels, mapOriginLegend } from "./status-labels.js";
+export const nativeMapRoles = [
+    "node",
+    "label",
+    "edge",
+    "edge-label",
+    "title",
+    "badge",
+    "legend",
+    "map-summary",
+    "map-full-summary",
+    "map-goal",
+    "map-description",
+    "summary",
+    "full-label",
+    "full-summary",
+    "description",
+    "annotation-panel",
+    "annotation-id",
+    "annotation-heading",
+    "icon-well",
+    "icon",
+    "port-in",
+    "port-out",
+];
+export function nativeMapTextEntries(drawing) {
+    const result = [];
+    const add = (role, logicalId, text, x, y, width, height, fontSize = 14, color = "#101828", semantic, strong = false) => {
+        result.push({
+            role,
+            logicalId,
+            text,
+            x,
+            y,
+            width,
+            height,
+            fontSize,
+            color,
+            ...(semantic
+                ? {
+                    semantic,
+                }
+                : {}),
+            ...(strong
+                ? {
+                    strong,
+                }
+                : {}),
+        });
+    };
+    const titleBox = drawing.header?.titleBox ?? {
+        x: 32,
+        y: 24,
+        width: 900,
+        height: 40,
+    };
+    add("title", drawing.mapId, drawing.title, titleBox.x, titleBox.y, titleBox.width, titleBox.height, 24, "#101828", {
+        scope: "map",
+        field: "title",
+    }, true);
+    const headerText = drawing.headerSummary ??
+        drawing.summary ??
+        (drawing.goal && drawing.goal.length <= 240 ? drawing.goal : undefined);
+    if (headerText) {
+        const box = drawing.header?.summaryBox ?? {
+            x: 32,
+            y: 72,
+            width: 900,
+            height: mapLabelHeight(headerText, 900),
+        };
+        add("map-summary", drawing.mapId, headerText, box.x, box.y, box.width, box.height, 14, "#667085", {
+            scope: "map",
+            field: drawing.summary !== undefined ? "summary" : "goal",
+        });
+    }
+    if (drawing.nodes.some((node) => node.origin)) {
+        add("legend", drawing.mapId, mapOriginLegend, 32, drawing.header?.legendY ?? (headerText ? 132 : 72), 1000, 20, 10, "#667085");
+    }
+    for (const node of drawing.nodes) {
+        const modern = node.cardTitle !== undefined;
+        const title = modern
+            ? node.cardTitle
+            : (node.kind === "decision" ? "Decision: " : node.kind === "detail-link" ? "Details: " : "") +
+                node.label;
+        add("label", node.id, title, node.x + 64, node.y + 18, node.width - 80, 32, 14, "#101828", {
+            scope: "node",
+            field: "label",
+            nodeId: node.id,
+            compact: modern && title !== node.label,
+        }, true);
+        const summary = node.cardSummary ?? node.summary;
+        if (summary) {
+            add("summary", node.id, summary, node.x + 64, node.y + 50, node.width - 80, 48, 12, "#667085", {
+                scope: "node",
+                field: "summary",
+                nodeId: node.id,
+                compact: summary !== node.summary,
+            });
+        }
+        if (node.origin) {
+            add("badge", node.id, mapOriginLabels[node.origin], node.x + 16, node.y + node.height - 24, node.width - 32, 16, 10, "#667085");
+        }
+    }
+    for (const edge of drawing.edges) {
+        if (edge.label && edge.labelBox) {
+            add("edge-label", edge.id, edge.label, edge.labelBox.x, edge.labelBox.y, edge.labelBox.width, edge.labelBox.height, 12, "#667085");
+        }
+    }
+    for (const annotation of drawing.annotations ?? []) {
+        const node = annotation.nodeId
+            ? drawing.nodes.find((candidate) => candidate.id === annotation.nodeId)
+            : undefined;
+        const id = node?.id ?? drawing.mapId;
+        const layout = mapAnnotationLayout(annotation);
+        const x = annotation.x + 20;
+        const width = annotation.width - 40;
+        add("annotation-id", annotation.id, node ? `Node · ${node.id}` : "Map context", x, annotation.y + layout.idBox.y, width, layout.idBox.height, 10, "#667085");
+        if (node && layout.titleBox) {
+            add("full-label", node.id, node.label, x, annotation.y + layout.titleBox.y, width, layout.titleBox.height, 16, "#101828", {
+                scope: "node",
+                field: "label",
+                nodeId: node.id,
+            }, true);
+        }
+        for (const fieldLayout of layout.fields) {
+            const field = fieldLayout.field;
+            const value = annotation[field];
+            add("annotation-heading", `${annotation.id}:${field}`, field[0].toUpperCase() + field.slice(1), x, annotation.y + fieldLayout.headingY, width, fieldLayout.headingHeight, 11, "#667085", undefined, true);
+            const role = node
+                ? field === "summary"
+                    ? "full-summary"
+                    : "description"
+                : field === "goal"
+                    ? "map-goal"
+                    : field === "summary"
+                        ? "map-full-summary"
+                        : "map-description";
+            add(role, id, value, x, annotation.y + fieldLayout.y, width, fieldLayout.height, 14, "#344054", {
+                scope: node ? "node" : "map",
+                field,
+                ...(node
+                    ? {
+                        nodeId: node.id,
+                    }
+                    : {}),
+            });
+        }
+    }
+    return result;
+}
+export function nativeMapShapeKeys(drawing) {
+    return new Set([
+        ...nativeMapTextEntries(drawing).map((entry) => `${entry.role}:${entry.logicalId}`),
+        ...drawing.nodes.flatMap((node) => [
+            "node",
+            "icon-well",
+            "icon",
+            "port-in",
+            "port-out",
+        ].map((role) => `${role}:${node.id}`)),
+        ...drawing.edges.flatMap((edge) => [
+            `edge:${edge.id}`,
+            ...(edge.label
+                ? [
+                    `edge-label:${edge.id}`,
+                ]
+                : []),
+        ]),
+        ...(drawing.annotations ?? []).map((annotation) => `annotation-panel:${annotation.id}`),
+    ]);
+}

package/dist/map-penpot/details.d.ts

@@ -0,0 +1,4 @@
+import type { MapDrawing } from "./types.js";
+/** Resolve only explicitly pinned direct contracts; never recurse into another map's sources. */
+export declare function resolveMapDetails(root: string, drawing: MapDrawing): Promise<MapDrawing>;
+export declare function requireResolvedMapDetails(drawing: MapDrawing): void;

package/dist/map-penpot/details.js

@@ -0,0 +1,84 @@
+import { createHash } from "node:crypto";
+import { readProjectBytes } from "../bounded-file.js";
+import { hashMapContract, maxMapBytes, validateMapContract, validateMapDetail, } from "../maps/validation.js";
+/** Resolve only explicitly pinned direct contracts; never recurse into another map's sources. */
+export async function resolveMapDetails(root, drawing) {
+    const references = drawing.nodes.filter((node) => node.detail);
+    if (references.length > 64) {
+        throw new Error("Native map supports at most 64 direct detail references");
+    }
+    const identity = drawing.mapId.match(/^(journey-map|integration-map):(.+)$/);
+    if (references.length && !identity) {
+        throw new Error("Native detail maps require a namespaced canonical parent identity");
+    }
+    const parent = {
+        kind: identity?.[1],
+        id: identity?.[2] ?? "",
+        sources: references.map((node) => ({
+            ...node.detail,
+            id: node.detail.sourceId,
+            kind: "contract",
+        })),
+    };
+    let totalBytes = 0;
+    const cache = new Map();
+    const resolved = new Map();
+    for (const node of references) {
+        const detail = node.detail;
+        const key = `${detail.path}:${detail.sha256}`;
+        let contract = cache.get(key);
+        if (!contract) {
+            const bytes = await readProjectBytes(root, detail.path, maxMapBytes);
+            totalBytes += bytes.length;
+            if (totalBytes > 128 * 1024 * 1024) {
+                throw new Error("Direct detail contracts exceed the 128 MiB aggregate budget");
+            }
+            if (createHash("sha256").update(bytes).digest("hex") !== detail.sha256) {
+                throw new Error(`Pinned detail contract changed: ${detail.sourceId}`);
+            }
+            let raw;
+            try {
+                raw = JSON.parse(bytes.toString("utf8"));
+            }
+            catch {
+                throw new Error(`Invalid detail contract JSON: ${detail.sourceId}`);
+            }
+            contract = validateMapContract(raw);
+            cache.set(key, contract);
+        }
+        validateMapDetail(parent, {
+            id: node.id,
+            sourceIds: [
+                detail.sourceId,
+            ],
+            requirementIds: node.requirementIds,
+        }, contract);
+        const identity = {
+            mapId: `${contract.kind}:${contract.id}`,
+            contractHash: hashMapContract(contract),
+        };
+        if ((detail.mapId !== undefined && detail.mapId !== identity.mapId) ||
+            (detail.contractHash !== undefined && detail.contractHash !== identity.contractHash)) {
+            throw new Error(`Resolved detail contract identity differs: ${detail.sourceId}`);
+        }
+        resolved.set(key, identity);
+    }
+    return {
+        ...drawing,
+        nodes: drawing.nodes.map((node) => node.detail
+            ? {
+                ...node,
+                detail: {
+                    ...node.detail,
+                    ...resolved.get(`${node.detail.path}:${node.detail.sha256}`),
+                },
+            }
+            : node),
+    };
+}
+export function requireResolvedMapDetails(drawing) {
+    if (drawing.nodes.some((node) => node.detail &&
+        (!node.detail.mapId || !/^[a-f0-9]{64}$/.test(node.detail.contractHash ?? "")))) {
+        throw new Error("Resolve pinned detail contract identities before using native map evidence");
+    }
+}

package/dist/map-penpot/evidence-error.d.ts

@@ -0,0 +1,5 @@
+import { PenpairError } from "../errors.js";
+export declare class MapExportEvidenceError extends PenpairError {
+    readonly runId: string;
+    constructor(runId: string, detail: string);
+}

package/dist/map-penpot/evidence-error.js

@@ -0,0 +1,9 @@
+import { PenpairError } from "../errors.js";
+export class MapExportEvidenceError extends PenpairError {
+    runId;
+    constructor(runId, detail) {
+        super("incomplete-output", `Native map write is verified, but export evidence failed for run ${runId}: ${detail}. Inspect the run and rerun the original publish command with --apply --resume ${runId}.`);
+        this.runId = runId;
+        this.name = "MapExportEvidenceError";
+    }
+}

package/dist/map-penpot/icons.d.ts

@@ -0,0 +1,5 @@
+import type { MapIcon } from "../maps/types.js";
+import type { ProjectionShape } from "./types.js";
+export declare const nativeMapIcons: Record<MapIcon, string>;
+export declare function defaultMapIcon(kind: string): MapIcon;
+export declare function identifyMapIcon(shape: Pick<ProjectionShape, "content">): MapIcon | undefined;

package/dist/map-penpot/icons.js

@@ -0,0 +1,79 @@
+export const nativeMapIcons = {
+    screen: "M0 0 L24 0 L24 18 L0 18 L0 0 M6 24 L18 24 M12 18 L12 24",
+    action: "M14 0 L2 14 L11 14 L10 24 L22 9 L13 9 L14 0",
+    decision: "M12 0 L24 12 L12 24 L0 12 L12 0",
+    data: "M0 0 L24 0 L24 24 L0 24 L0 0 M0 8 L24 8 M0 16 L24 16",
+    service: "M0 0 L24 0 L24 10 L0 10 L0 0 M0 14 L24 14 L24 24 L0 24 L0 14 M5 5 L8 5 M5 19 L8 19",
+    code: "M8 0 L0 12 L8 24 M16 0 L24 12 L16 24",
+    check: "M0 12 L8 22 L24 0",
+    link: "M0 8 L0 0 L16 0 L16 16 L8 16 M8 8 L24 8 L24 24 L8 24 L8 8",
+};
+export function defaultMapIcon(kind) {
+    if (kind === "decision") {
+        return "decision";
+    }
+    if (kind === "detail-link") {
+        return "link";
+    }
+    if (/screen|view|page|route/.test(kind)) {
+        return "screen";
+    }
+    if (/data|store|state/.test(kind)) {
+        return "data";
+    }
+    if (/service|api|request/.test(kind)) {
+        return "service";
+    }
+    if (/component|hook|code/.test(kind)) {
+        return "code";
+    }
+    if (/success|outcome|complete/.test(kind)) {
+        return "check";
+    }
+    return "action";
+}
+function normalizedIcon(content) {
+    if (typeof content !== "string" || content.length > 8192) {
+        return undefined;
+    }
+    const tokens = content.match(/[ML]|[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/g);
+    if (!tokens || tokens.join("") !== content.replace(/[\s,]/g, "")) {
+        return undefined;
+    }
+    const points = [];
+    for (let index = 0; index < tokens.length; index += 3) {
+        const command = tokens[index];
+        const x = Number(tokens[index + 1]);
+        const y = Number(tokens[index + 2]);
+        if (![
+            "M",
+            "L",
+        ].includes(command ?? "") ||
+            !Number.isFinite(x) ||
+            !Number.isFinite(y)) {
+            return undefined;
+        }
+        points.push({
+            command: command,
+            x,
+            y,
+        });
+    }
+    const minX = Math.min(...points.map((point) => point.x));
+    const minY = Math.min(...points.map((point) => point.y));
+    const width = Math.max(...points.map((point) => point.x)) - minX;
+    const height = Math.max(...points.map((point) => point.y)) - minY;
+    if (width <= 0 || height <= 0) {
+        return undefined;
+    }
+    return points
+        .map((point) => `${point.command}${Math.round(((point.x - minX) / width) * 10000)},${Math.round(((point.y - minY) / height) * 10000)}`)
+        .join(" ");
+}
+export function identifyMapIcon(shape) {
+    const actual = normalizedIcon(shape.content);
+    if (!actual) {
+        return undefined;
+    }
+    return Object.keys(nativeMapIcons).find((icon) => normalizedIcon(nativeMapIcons[icon]) === actual);
+}