@penpair/core 0.3.7 → 0.4.1

package/dist/map-penpot/projection.js

@@ -0,0 +1,176 @@
+import { nativeMapIcons } from "./icons.js";
+import { validateMapDrawingContent } from "./content-validation.js";
+import { nativeMapRoles } from "./content.js";
+import { observationHash } from "../journal.js";
+import { selectPage, withPageSession } from "../page-session.js";
+import { runSnippet } from "../snippet.js";
+import { inspectMapSnippet } from "./snippets.js";
+export function drawingFromPlan(plan) {
+    if (!plan.complete) {
+        throw new Error(`Map requires smaller detail boards: ${plan.reasons.join("; ")}`);
+    }
+    return {
+        mapId: `${plan.mapKind}:${plan.mapId}`,
+        contractHash: plan.mapHash,
+        title: plan.title,
+        goal: plan.goal,
+        ...(plan.summary !== undefined
+            ? {
+                summary: plan.summary,
+            }
+            : {}),
+        ...(plan.description !== undefined
+            ? {
+                description: plan.description,
+            }
+            : {}),
+        ...(plan.headerSummary !== undefined
+            ? {
+                headerSummary: plan.headerSummary,
+            }
+            : {}),
+        header: plan.header,
+        annotations: plan.annotations,
+        fontFamily: plan.fontFamily,
+        nodes: plan.nodes,
+        edges: plan.edges,
+    };
+}
+export function validateDrawing(drawing) {
+    validateMapDrawingContent(drawing);
+    if (!drawing.mapId ||
+        !/^[a-f0-9]{64}$/.test(drawing.contractHash) ||
+        !drawing.title ||
+        drawing.title.length > 1000) {
+        throw new Error("Map identity, title and SHA-256 contract hash are required");
+    }
+    if (drawing.nodes.length > 1000 || drawing.edges.length > 2000) {
+        throw new Error("Map exceeds graph limits");
+    }
+    if (drawing.origin &&
+        ![
+            drawing.origin.x,
+            drawing.origin.y,
+        ].every(Number.isFinite)) {
+        throw new Error("Map origin must be finite");
+    }
+    const identifiers = new Set(drawing.nodes.map((node) => node.id));
+    if (identifiers.size !== drawing.nodes.length ||
+        drawing.nodes.some((node) => !node.id ||
+            (node.icon !== undefined && !Object.hasOwn(nativeMapIcons, node.icon)) ||
+            (node.summary !== undefined &&
+                (typeof node.summary !== "string" || node.summary.length > 240)) ||
+            (node.description !== undefined &&
+                (typeof node.description !== "string" || node.description.length > 4000)) ||
+            (node.detail !== undefined &&
+                (node.kind !== "detail-link" ||
+                    !node.detail.fileId ||
+                    !node.detail.pageId ||
+                    !node.detail.frameId ||
+                    !node.detail.path ||
+                    !/^[a-f0-9]{64}$/.test(node.detail.sha256))) ||
+            (node.origin !== undefined &&
+                ![
+                    "observed",
+                    "proposed",
+                    "owner-decision",
+                    "unknown",
+                ].includes(node.origin)) ||
+            !node.label ||
+            node.label.length > 4000 ||
+            ![
+                node.x,
+                node.y,
+                node.width,
+                node.height,
+            ].every(Number.isFinite) ||
+            node.width < 64 ||
+            node.height < 32)) {
+        throw new Error("Map nodes need unique IDs, bounded labels and finite positive geometry");
+    }
+    if (new Set(drawing.edges.map((edge) => edge.id)).size !== drawing.edges.length ||
+        drawing.edges.some((edge) => !edge.id ||
+            !identifiers.has(edge.from) ||
+            !identifiers.has(edge.to) ||
+            typeof edge.label !== "string" ||
+            edge.label.length > 4000 ||
+            (edge.labelBox !== undefined &&
+                (![
+                    edge.labelBox.x,
+                    edge.labelBox.y,
+                    edge.labelBox.width,
+                    edge.labelBox.height,
+                ].every(Number.isFinite) ||
+                    edge.labelBox.width <= 0 ||
+                    edge.labelBox.height <= 0)) ||
+            (edge.points !== undefined &&
+                (!Array.isArray(edge.points) ||
+                    edge.points.length < 2 ||
+                    edge.points.length > 32 ||
+                    edge.points.some((point) => ![
+                        point.x,
+                        point.y,
+                    ].every(Number.isFinite)))))) {
+        throw new Error("Map edges need unique IDs and existing endpoints");
+    }
+}
+export function projection(target, mapId, result) {
+    if (!Array.isArray(result.shapes) ||
+        !Array.isArray(result.conflicts) ||
+        !(result.boardId === null || typeof result.boardId === "string") ||
+        !(result.boardBounds === null ||
+            (typeof result.boardBounds === "object" &&
+                result.boardBounds &&
+                [
+                    "x",
+                    "y",
+                    "width",
+                    "height",
+                ].every((key) => Number.isFinite(result.boardBounds[key])))) ||
+        !(result.contractHash === null || typeof result.contractHash === "string")) {
+        throw new Error("Native map inspection returned incomplete evidence");
+    }
+    if (result.shapes.some((shape) => !shape ||
+        typeof shape !== "object" ||
+        typeof shape.shapeId !== "string" ||
+        typeof shape.logicalId !== "string" ||
+        !nativeMapRoles.includes(shape.role) ||
+        ![
+            shape.x,
+            shape.y,
+            shape.width,
+            shape.height,
+        ].every(Number.isFinite) ||
+        !(shape.label === null || typeof shape.label === "string") ||
+        !(shape.content === null || typeof shape.content === "string")) ||
+        result.conflicts.some((conflict) => typeof conflict !== "string")) {
+        throw new Error("Native map inspection returned malformed shape evidence");
+    }
+    const observed = {
+        boardId: result.boardId,
+        boardBounds: result.boardBounds,
+        contractHash: result.contractHash,
+        shapes: result.shapes,
+        conflicts: result.conflicts,
+    };
+    return {
+        schemaVersion: 1,
+        kind: "native-map-projection",
+        ...target,
+        boardId: result.boardId,
+        boardBounds: result.boardBounds,
+        mapId,
+        contractHash: result.contractHash,
+        fingerprint: observationHash(observed),
+        shapes: result.shapes,
+        conflicts: result.conflicts,
+    };
+}
+export async function readProjection(client, target, mapId, options = {}) {
+    return withPageSession(client, async () => {
+        await selectPage(client, {
+            id: target.pageId,
+        }, options);
+        return projection(target, mapId, await runSnippet(client, inspectMapSnippet(target, mapId), options));
+    });
+}

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

@@ -0,0 +1,4 @@
+import type { PenpotToolClient } from "../client.js";
+import type { MapDrawing, MapTarget, NativeMapProjection, PublishMapOptions, PublishMapResult } from "./types.js";
+export declare function verificationProblems(drawing: MapDrawing, observed: NativeMapProjection): string[];
+export declare function publishMap(client: PenpotToolClient, target: MapTarget, drawing: MapDrawing, options?: PublishMapOptions): Promise<PublishMapResult>;

package/dist/map-penpot/publish.js

@@ -0,0 +1,301 @@
+import { nativeMapShapeKeys, nativeMapTextEntries } from "./content.js";
+import { defaultMapIcon, identifyMapIcon } from "./icons.js";
+import { mapOriginLabels, mapOriginLegend } from "./status-labels.js";
+import { redactEndpoint } from "../endpoint.js";
+import { MapExportEvidenceError } from "./evidence-error.js";
+import { resolveMapDetails } from "./details.js";
+import { exportShapePng } from "../export.js";
+import { runOperation } from "../operation.js";
+import { routeMapEdges, mapDrawingGeometryProblems } from "../maps/layout.js";
+import { preserveMapPresentation } from "./presentation.js";
+import { withPageSession } from "../page-session.js";
+import { readMapPathPoints } from "./path-geometry.js";
+import { inspectMapSnippet, publishMapSnippet } from "./snippets.js";
+import { validateDrawing, projection, readProjection } from "./projection.js";
+export function verificationProblems(drawing, observed) {
+    const problems = [
+        ...observed.conflicts,
+    ];
+    if (!observed.boardId || observed.contractHash !== drawing.contractHash) {
+        problems.push("Map board or contract identity differs");
+    }
+    const expectedKeys = nativeMapShapeKeys(drawing);
+    for (const shape of observed.shapes) {
+        if (!expectedKeys.delete(`${shape.role}:${shape.logicalId}`)) {
+            problems.push(`Unexpected shape ${shape.shapeId}`);
+        }
+    }
+    if (expectedKeys.size) {
+        problems.push("Managed shapes are missing");
+    }
+    if (drawing.nodes.some((node) => node.origin) &&
+        observed.shapes.find((shape) => shape.role === "legend")?.label !== mapOriginLegend) {
+        problems.push("Origin legend differs");
+    }
+    for (const shape of observed.shapes) {
+        const style = shape.appearance;
+        const radius = shape.role === "node" || shape.role === "annotation-panel"
+            ? 12
+            : shape.role === "icon-well"
+                ? 8
+                : undefined;
+        if (radius !== undefined &&
+            [
+                "borderRadiusTopLeft",
+                "borderRadiusTopRight",
+                "borderRadiusBottomLeft",
+                "borderRadiusBottomRight",
+            ].some((corner) => typeof style?.[corner] === "number" && style[corner] !== radius)) {
+            problems.push(`Native rounded corners differ: ${shape.role}:${shape.logicalId}`);
+        }
+        if ((typeof style?.opacity === "number" && style.opacity !== 1) ||
+            (typeof style?.blendMode === "string" && style.blendMode !== "normal")) {
+            problems.push(`Native decorative opacity/blend differs: ${shape.role}:${shape.logicalId}`);
+        }
+    }
+    const bounds = observed.boardBounds;
+    if (bounds) {
+        for (const shape of observed.shapes.filter((shape) => shape.role !== "edge")) {
+            if (shape.x < bounds.x ||
+                shape.y < bounds.y ||
+                shape.x + shape.width > bounds.x + bounds.width + 0.01 ||
+                shape.y + shape.height > bounds.y + bounds.height + 0.01) {
+                problems.push(`Map content exceeds board bounds: ${shape.logicalId}`);
+            }
+        }
+    }
+    for (const node of drawing.nodes) {
+        const label = observed.shapes.find((shape) => shape.role === "label" && shape.logicalId === node.id);
+        for (const clickable of observed.shapes.filter((shape) => shape.logicalId === node.id &&
+            [
+                "node",
+                "label",
+                "badge",
+                "summary",
+                "icon-well",
+                "icon",
+                "port-in",
+                "port-out",
+            ].includes(shape.role))) {
+            if (node.detail &&
+                (clickable.interactions?.length !== 1 ||
+                    clickable.interactions[0]?.trigger !== "click" ||
+                    clickable.interactions[0]?.type !== "navigate-to" ||
+                    clickable.interactions[0]?.destinationId !== node.detail.frameId ||
+                    clickable.interactions[0]?.destinationPageId !== node.detail.pageId ||
+                    clickable.interactions[0]?.destinationMapHash !== node.detail.contractHash ||
+                    clickable.interactions[0]?.destinationMapId !== node.detail.mapId)) {
+                problems.push(`Detail link destination differs or is unobservable: ${node.id}`);
+            }
+            if (!node.detail && clickable.interactions?.length) {
+                problems.push(`Unexpected native interaction: ${node.id}`);
+            }
+        }
+        if (node.origin) {
+            const status = mapOriginLabels[node.origin];
+            if (observed.shapes.find((shape) => shape.role === "badge" && shape.logicalId === node.id)
+                ?.label !== status) {
+                problems.push(`Origin badge differs: ${node.id}`);
+            }
+        }
+        const icon = observed.shapes.find((shape) => shape.role === "icon" && shape.logicalId === node.id);
+        if (!icon || identifyMapIcon(icon) !== (node.icon ?? defaultMapIcon(node.kind))) {
+            problems.push(`Native icon differs: ${node.id}`);
+        }
+        const card = observed.shapes.find((shape) => shape.role === "node" && shape.logicalId === node.id);
+        if (card &&
+            label &&
+            (label.x < card.x ||
+                label.y < card.y ||
+                label.x + label.width > card.x + card.width + 0.01 ||
+                label.y + label.height > card.y + card.height + 0.01)) {
+            problems.push(`Node label exceeds card bounds: ${node.id}`);
+        }
+    }
+    if (observed.shapes.find((shape) => shape.role === "title")?.label !== drawing.title) {
+        problems.push("Map title differs");
+    }
+    for (const entry of nativeMapTextEntries(drawing)) {
+        const actual = observed.shapes.find((shape) => shape.role === entry.role && shape.logicalId === entry.logicalId);
+        if (actual?.label !== entry.text) {
+            problems.push(`Native text differs: ${entry.role}:${entry.logicalId}`);
+        }
+        if (actual && actual.height > entry.height + 0.01) {
+            problems.push(`Native text exceeds reserved space: ${entry.role}:${entry.logicalId}`);
+        }
+    }
+    const title = observed.shapes.find((shape) => shape.role === "title");
+    const legend = observed.shapes.find((shape) => shape.role === "legend");
+    if (title &&
+        (title.height > (drawing.header?.titleBox.height ?? 48) ||
+            (legend && title.y + title.height > legend.y))) {
+        problems.push("Map title exceeds the reserved header space");
+    }
+    for (const edge of drawing.edges) {
+        const path = observed.shapes.find((shape) => shape.role === "edge" && shape.logicalId === edge.id);
+        if (path?.from !== edge.from || path.to !== edge.to) {
+            problems.push(`Relationship differs: ${edge.id}`);
+        }
+        const edgeLabel = observed.shapes.find((shape) => shape.role === "edge-label" && shape.logicalId === edge.id);
+        if (edge.label && edgeLabel?.label !== edge.label) {
+            problems.push(`Relationship label differs: ${edge.id}`);
+        }
+        if (edge.labelBox && edgeLabel && edgeLabel.height > edge.labelBox.height + 0.01) {
+            problems.push(`Relationship label exceeds reserved space: ${edge.id}`);
+        }
+        const from = observed.shapes.find((shape) => shape.role === "node" && shape.logicalId === edge.from);
+        const to = observed.shapes.find((shape) => shape.role === "node" && shape.logicalId === edge.to);
+        const vertices = readMapPathPoints(path?.content);
+        const start = vertices?.[0];
+        const end = vertices?.at(-1);
+        const close = (left, right) => left !== undefined && Number.isFinite(left) && Math.abs(left - right) < 0.01;
+        if (!from ||
+            !to ||
+            !vertices ||
+            !(close(start?.x, from.x + from.width) || close(start?.x, from.x)) ||
+            !close(start?.y, from.y + from.height / 2) ||
+            !((close(end?.x, to.x) && close(end?.y, to.y + to.height / 2)) ||
+                (edge.from === edge.to && close(end?.x, to.x + to.width / 2) && close(end?.y, to.y)))) {
+            problems.push(`Relationship native geometry differs: ${edge.id}`);
+        }
+    }
+    if (bounds) {
+        const nodes = observed.shapes
+            .filter((shape) => shape.role === "node")
+            .map((shape) => ({
+            id: shape.logicalId,
+            x: shape.x - bounds.x,
+            y: shape.y - bounds.y,
+            width: shape.width,
+            height: shape.height,
+        }));
+        const edges = drawing.edges.flatMap((edge) => {
+            const path = observed.shapes.find((shape) => shape.role === "edge" && shape.logicalId === edge.id);
+            const points = readMapPathPoints(path?.content);
+            const label = observed.shapes.find((shape) => shape.role === "edge-label" && shape.logicalId === edge.id);
+            return points && label
+                ? [
+                    {
+                        id: edge.id,
+                        points: points.map((point) => ({
+                            x: point.x - bounds.x,
+                            y: point.y - bounds.y,
+                        })),
+                        labelBox: {
+                            x: label.x - bounds.x,
+                            y: label.y - bounds.y,
+                            width: label.width,
+                            height: label.height,
+                        },
+                    },
+                ]
+                : [];
+        });
+        problems.push(...mapDrawingGeometryProblems(nodes, edges));
+    }
+    return problems;
+}
+export async function publishMap(client, target, drawing, options = {}) {
+    const configuredRedact = options.redact ?? options.journal?.redact;
+    const redact = (text) => redactEndpoint(configuredRedact ? configuredRedact(text) : text);
+    const requireProtectedValuesAbsent = (value) => {
+        const encoded = JSON.stringify(value);
+        if (redact(encoded) !== encoded) {
+            throw new Error("Native map contains protected values; publication refused");
+        }
+    };
+    requireProtectedValuesAbsent(drawing);
+    validateDrawing(drawing);
+    if (drawing.nodes.some((node) => node.detail)) {
+        if (!options.journal?.root) {
+            throw new Error("Pinned detail publication needs its project root");
+        }
+        drawing = await resolveMapDetails(options.journal.root, drawing);
+    }
+    drawing = {
+        ...drawing,
+        edges: drawing.edges.every((edge) => edge.points && edge.labelBox)
+            ? drawing.edges
+            : routeMapEdges(drawing.nodes, drawing.edges),
+    };
+    requireProtectedValuesAbsent(drawing);
+    const geometryProblems = mapDrawingGeometryProblems(drawing.nodes, drawing.edges);
+    if (geometryProblems.length) {
+        throw new Error(`Map layout requires review: ${geometryProblems.join("; ")}`);
+    }
+    if (options.apply && !options.journal) {
+        throw new Error("Map publication requires a durable operation journal");
+    }
+    return withPageSession(client, async () => {
+        const before = await readProjection(client, target, drawing.mapId, options);
+        requireProtectedValuesAbsent(before);
+        if (before.conflicts.length) {
+            throw new Error(before.conflicts.join("; "));
+        }
+        if (options.apply &&
+            before.boardId &&
+            !options.journal?.resume &&
+            (!options.expected ||
+                options.expected.fingerprint !== before.fingerprint ||
+                options.expected.mapId !== drawing.mapId ||
+                options.expected.fileId !== target.fileId ||
+                options.expected.pageId !== target.pageId)) {
+            throw new Error("Existing map requires matching prior projection; import and reconcile edits first");
+        }
+        // Build the full write during preview too; size limits fail before a journal or remote mutation.
+        publishMapSnippet(target, before.boardId ? preserveMapPresentation(drawing, before) : drawing, before);
+        const operation = {
+            name: "publish-map",
+            page: () => undefined,
+            inspect: () => inspectMapSnippet(target, drawing.mapId),
+            apply: (_drawing, inspected) => {
+                const observed = inspected
+                    ? projection(target, drawing.mapId, inspected)
+                    : {
+                        ...before,
+                        boardId: null,
+                        boardBounds: null,
+                        contractHash: null,
+                        shapes: [],
+                        conflicts: [],
+                    };
+                const projectedDrawing = observed.boardId
+                    ? preserveMapPresentation(drawing, observed)
+                    : drawing;
+                requireProtectedValuesAbsent(projectedDrawing);
+                requireProtectedValuesAbsent(observed);
+                return publishMapSnippet(target, projectedDrawing, observed);
+            },
+            readback: () => inspectMapSnippet(target, drawing.mapId),
+            verify: ({ readback }) => verificationProblems(drawing, projection(target, drawing.mapId, readback)),
+        };
+        const report = await runOperation(client, operation, drawing, options);
+        const observed = report.readback ? projection(target, drawing.mapId, report.readback) : before;
+        let image;
+        if (options.apply && report.verified && options.export !== false && observed.boardId) {
+            try {
+                image = await exportShapePng(client, observed.boardId, {
+                    ...options,
+                    stable: true,
+                });
+            }
+            catch (error) {
+                const detail = redact(error instanceof Error ? error.message : String(error));
+                if (report.journal?.runId) {
+                    throw new MapExportEvidenceError(report.journal.runId, detail);
+                }
+                throw error;
+            }
+        }
+        return {
+            report,
+            projection: observed,
+            ...(image
+                ? {
+                    image,
+                }
+                : {}),
+            visualReviewRequired: Boolean(options.apply),
+        };
+    });
+}

package/dist/map-penpot/release-maps.d.ts

@@ -0,0 +1,21 @@
+import type { PenpotToolClient } from "../client.js";
+import type { MapContract } from "../maps/types.js";
+import type { MapTarget, PublishMapOptions, PublishMapResult } from "./types.js";
+export interface ReleaseMapPublication {
+    mapKind: MapContract["kind"];
+    mapId: string;
+    contractHash: string;
+    publication: PublishMapResult;
+}
+/** Each contract has its own recoverable journal; an interrupted batch is never replayed blindly. */
+export declare function assembleReleaseMaps(client: PenpotToolClient, root: string, target: MapTarget, contracts: MapContract[], options?: Omit<PublishMapOptions, "journal" | "expected"> & {
+    origin?: {
+        x: number;
+        y: number;
+    };
+    journals?: Record<string, {
+        runId: string;
+        resume?: boolean;
+    }>;
+    projections?: Record<string, NonNullable<PublishMapOptions["expected"]>>;
+}): Promise<ReleaseMapPublication[]>;

package/dist/map-penpot/release-maps.js

@@ -0,0 +1,104 @@
+import { observeMapSources } from "../maps/store.js";
+import { buildMapDrawingPlan } from "../maps/render.js";
+import { resolveMapDetails } from "./details.js";
+import { drawingFromPlan } from "./projection.js";
+import { publishMap } from "./publish.js";
+/** Each contract has its own recoverable journal; an interrupted batch is never replayed blindly. */
+export async function assembleReleaseMaps(client, root, target, contracts, options = {}) {
+    if (contracts.length > 100 ||
+        new Set(contracts.map((contract) => `${contract.kind}:${contract.id}`)).size !==
+            contracts.length) {
+        throw new Error("Release maps require at most 100 unique contract identities");
+    }
+    const prepared = new Map();
+    for (const contract of contracts) {
+        const observation = await observeMapSources(root, contract);
+        const plan = buildMapDrawingPlan(contract, observation.detailMaps);
+        const drawing = await resolveMapDetails(root, drawingFromPlan(plan));
+        prepared.set(drawing.mapId, {
+            contract,
+            drawing,
+            width: plan.width,
+        });
+    }
+    const ordered = [];
+    const visiting = new Set();
+    const completed = new Set();
+    const visit = (id) => {
+        if (visiting.has(id)) {
+            throw new Error("Release detail-map dependencies contain a cycle");
+        }
+        if (completed.has(id)) {
+            return;
+        }
+        const current = prepared.get(id);
+        visiting.add(id);
+        for (const node of current.drawing.nodes.filter((node) => node.detail)) {
+            const detail = node.detail;
+            const child = prepared.get(detail.mapId);
+            if (!child || child.drawing.contractHash !== detail.contractHash) {
+                throw new Error("Every detail contract must be explicitly included at its pinned revision in the release");
+            }
+            visit(child.drawing.mapId);
+        }
+        visiting.delete(id);
+        completed.add(id);
+        ordered.push(id);
+    };
+    for (const id of prepared.keys()) {
+        visit(id);
+    }
+    const results = [];
+    const published = new Map();
+    let nextX = options.origin?.x ?? 0;
+    for (const id of ordered) {
+        const entry = prepared.get(id);
+        const contract = entry.contract;
+        const drawing = {
+            ...entry.drawing,
+            origin: {
+                x: nextX,
+                y: options.origin?.y ?? 0,
+            },
+            nodes: entry.drawing.nodes.map((node) => {
+                if (!node.detail) {
+                    return node;
+                }
+                const child = published.get(node.detail.mapId);
+                if (options.apply && !child?.projection.boardId) {
+                    throw new Error("Release child map has no verified native target");
+                }
+                return child?.projection.boardId
+                    ? {
+                        ...node,
+                        detail: {
+                            ...node.detail,
+                            fileId: target.fileId,
+                            pageId: target.pageId,
+                            frameId: child.projection.boardId,
+                        },
+                    }
+                    : node;
+            }),
+        };
+        const recovery = options.journals?.[drawing.mapId];
+        const publication = await publishMap(client, target, drawing, {
+            ...options,
+            expected: options.projections?.[drawing.mapId],
+            journal: {
+                root,
+                redact: options.redact,
+                ...recovery,
+            },
+        });
+        nextX += Math.max(entry.width, publication.projection.boardBounds?.width ?? 964) + 160;
+        published.set(drawing.mapId, publication);
+        results.push({
+            mapKind: contract.kind,
+            mapId: contract.id,
+            contractHash: drawing.contractHash,
+            publication,
+        });
+    }
+    return results;
+}

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

@@ -0,0 +1,4 @@
+import { type Snippet } from "../snippet.js";
+import type { MapDrawing, MapTarget, NativeMapProjection } from "./types.js";
+export declare function inspectMapSnippet(target: MapTarget, mapId: string): Snippet;
+export declare function publishMapSnippet(target: MapTarget, drawing: MapDrawing, expected: NativeMapProjection): Snippet;