@pygmalionjs/pygmalion 0.14.0 → 0.15.0

package/dist-lib/types/document/assets.d.ts

@@ -1,4 +1,5 @@
-import type { DesignDocument, DocumentDiagnostic, DocumentDuplicateMetadataRemapper, DocumentNode, DocumentTransaction, DocumentValue } from './contracts.js';
+import type { DesignDocument, DocumentMatrix, DocumentDiagnostic, DocumentDuplicateMetadataRemapper, DocumentNode, DocumentTransaction, DocumentValue } from './contracts.js';
+import { type ImagePaintBox } from './imagePaintGeometry.js';
 /**
  * Asset store of a design document. Images and SVG sources live under
  * `document.metadata.assets` as plain JSON so a saved document is
@@ -63,6 +64,7 @@ export interface ImagePaint {
     visible?: boolean;
     blendMode?: string;
     scale?: number;
+    imageTransform?: DocumentMatrix;
 }
 export interface ImageAssetInput {
     name: string;
@@ -167,12 +169,18 @@ export declare function assetSourceUrl(asset: DocumentAsset): string;
 export declare const imagePaint: (assetId: string, scaleMode?: ImageScaleMode) => ImagePaint;
 /**
  * CSS for one image paint as a background, keyed like React `CSSProperties`. `fill` covers the box,
- * `fit` letterboxes, `crop` covers (the crop transform is not modelled), `tile` repeats at natural size.
+ * `fit` letterboxes, `crop` covers unless an explicit image-to-local transform is present, `tile` repeats at natural size.
  * A missing asset yields an empty object so the layer keeps its other paints.
  */
-export declare function imagePaintCss(source: Pick<DesignDocument, 'metadata'> | AssetStore, paint: ImagePaint): Record<string, string>;
+export declare function imagePaintCss(source: Pick<DesignDocument, 'metadata'> | AssetStore, paint: ImagePaint, box?: ImagePaintBox): Record<string, string>;
+/** SVG fragments need the SVG namespace when rendered as an image resource; stored markup stays unchanged. */
+export declare function imagePaintSourceUrl(asset: DocumentAsset): string;
+/** SVG image envelopes cannot fetch external references when used as image backgrounds. */
+export declare function imageCropDiagnostic(asset: DocumentAsset): DocumentDiagnostic | null;
+/** A clipped image envelope references original bytes and shares the canonical image projection. */
+export declare function imagePaintBackground(asset: DocumentAsset, paint: ImagePaint, box: ImagePaintBox, opacity?: number): string;
 /** Background CSS of a node's first image paint; the appearance owner layers this under its own projection. */
-export declare function nodeImageCss(document: Pick<DesignDocument, 'metadata'>, node: Pick<DocumentNode, 'properties'>): Record<string, string>;
+export declare function nodeImageCss(document: Pick<DesignDocument, 'metadata'>, node: Pick<DocumentNode, 'properties'> & Partial<Pick<DocumentNode, 'width' | 'height'>>): Record<string, string>;
 /** Size for a newly placed image: natural size, scaled down uniformly to fit the limit. */
 export declare function imagePlacementSize(asset: Pick<DocumentAsset, 'width' | 'height'>, limit?: number): {
     width: number;

package/dist-lib/types/document/imagePaintGeometry.d.ts

@@ -0,0 +1,23 @@
+import type { DocumentMatrix } from './contracts.js';
+export interface ImagePaintPlacement {
+    scaleMode: 'fill' | 'fit' | 'crop' | 'tile';
+    scale?: number;
+    /** Natural image pixels to layer-local pixels. Active in crop mode; resize keeps these coordinates. */
+    imageTransform?: DocumentMatrix;
+}
+export interface ImagePaintBox {
+    width: number;
+    height: number;
+}
+export interface ImagePaintGeometry {
+    matrix: DocumentMatrix;
+    pattern: ImagePaintBox;
+    tiled: boolean;
+}
+export declare function isImageTransform(value: unknown): value is DocumentMatrix;
+/** One projection for box, vector, text and export; explicit crop matrices never resize the asset. */
+export declare function imagePaintGeometry(paint: ImagePaintPlacement, asset: ImagePaintBox, box: ImagePaintBox): ImagePaintGeometry;
+/** A different asset starts from its mode default; selecting the same asset preserves the current crop. */
+export declare function replaceImagePaintAsset<T extends ImagePaintPlacement & {
+    assetId: string;
+}>(paint: T, assetId: string): T;

package/dist-lib/types/document/pages.d.ts

@@ -0,0 +1,48 @@
+import type { DesignDocument, DocumentDuplicateMetadataRemapper, DocumentTransaction } from './contracts.js';
+import { type DocumentPage } from './pagesMetadata.js';
+export { DOCUMENT_PAGES_KEY, IMPLICIT_DOCUMENT_PAGE_ID, documentPageDiagnostics } from './pagesMetadata.js';
+export type { DocumentPage, DocumentPagesMetadata } from './pagesMetadata.js';
+/** Reading a legacy document never writes a sidecar or changes node identities. */
+export declare function documentPages(document: DesignDocument): readonly DocumentPage[];
+export declare function pageRootIds(document: DesignDocument, pageId: string): readonly string[];
+/** Page defaults are presentation values until an explicit edit persists them. */
+export declare function pageAppearance(document: DesignDocument, pageId: string): Readonly<{
+    background: string;
+    opacity: number;
+}>;
+export declare function pageForNode(document: DesignDocument, nodeId: string): string | null;
+/** Wrap ordinary canvas commands so membership follows structural edits in the same undo step. */
+export declare function applyDocumentPageEdit(transaction: DocumentTransaction, before: DesignDocument, activePageId: string, apply: (transaction: DocumentTransaction) => void): void;
+export type DocumentPageAction = {
+    type: 'create';
+    id: string;
+    name: string;
+    index?: number;
+} | {
+    type: 'rename';
+    pageId: string;
+    name: string;
+} | {
+    type: 'appearance';
+    pageId: string;
+    background?: string;
+    opacity?: number;
+} | {
+    type: 'move';
+    pageId: string;
+    index: number;
+} | {
+    type: 'duplicate';
+    pageId: string;
+    id: string;
+    name?: string;
+} | {
+    type: 'delete';
+    pageId: string;
+};
+export interface DocumentPageActionOptions {
+    allocateNodeId?: (sourceNodeId: string) => string;
+    remapMetadata?: DocumentDuplicateMetadataRemapper;
+}
+/** Page mutations use existing engine commands and then replace one same-identity canonical snapshot. */
+export declare function applyDocumentPageAction(transaction: DocumentTransaction, before: DesignDocument, action: DocumentPageAction, options?: DocumentPageActionOptions): void;

package/dist-lib/types/document/pagesMetadata.d.ts

@@ -0,0 +1,16 @@
+import type { DesignDocument, DocumentDiagnostic } from './contracts.js';
+export declare const DOCUMENT_PAGES_KEY = "pages";
+export declare const IMPLICIT_DOCUMENT_PAGE_ID = "page:default";
+export interface DocumentPage {
+    id: string;
+    name: string;
+    rootIds: readonly string[];
+    background?: string;
+    opacity?: number;
+}
+export interface DocumentPagesMetadata {
+    version: 1;
+    pages: readonly DocumentPage[];
+}
+/** Page membership partitions ordinary root children; component definitions remain shared. */
+export declare function documentPageDiagnostics(document: DesignDocument): DocumentDiagnostic[];

package/dist-lib/types/lib.d.ts

@@ -3,6 +3,7 @@ export * from './token-library/bindings.js';
 export { STYLE_KINDS, STYLE_SLOTS, STYLE_SLOT_KIND, STYLE_KIND_LABEL, STYLE_SLOT_LABEL, TEXT_STYLE_CHARACTER_KEYS, TEXT_STYLE_PARAGRAPH_KEYS, TEXT_STYLE_KEYS, StyleError, isStylePaint, isTextStyleValue, isStyleEffect, isStyleValue, isDesignStyle, isStylesMetadata, isStyleReferences, validateStyleLibrary, EMPTY_STYLES, documentStyles, documentStyle, documentStylesOfKind, nodeStyleReferences, styleSlotsFor, documentStyleDiagnostics, createStyle, renameStyle, describeStyle, setStyleValue, removeStyle, detachStyleFromLibrary, projectStyle, detachStyleReference, styleValueFromNode, styleConsumers, propagateStyle, applyStylePropagation, writeStyles, applyStylePatch, detachStylePatch, commitCreateStyle, commitStyleValue, commitRenameStyle, commitRemoveStyle, commitApplyStyle, commitDetachStyle, commitStyleFromNode, importLibraryStyle, planStyleLibraryUpdate, commitStyleLibraryUpdate, stylesDuplicateRemapper, STYLES_METADATA_KEY, STYLE_SIDECAR_PROPERTY_KEYS, stylesSourceDiagnostics } from './document/styles.js';
 export type { StyleKind, StyleSlot, StylePaint, PaintStyleValue, TextStyleValue, StyleEffect, EffectStyleValue, GridStyleValue, StyleValue, StyleValueByKind, StyleOrigin, DesignStyle, StylesMetadata, StyleLibraryDocument, StyleReferences, StyleConsumer, StylePropagation, StyleLibraryChange, StyleLibraryUpdatePlan } from './document/styles.js';
 export { componentOverrideTarget, remapComponentOverrideAddress } from './document/engine.js';
+export * from './document/pages.js';
 export { ComponentPanel } from './workspace/edit/ComponentPanel.js';
 export type { ComponentPanelProps } from './workspace/edit/ComponentPanel.js';
 export { StylesPanel } from './workspace/edit/StylesPanel.js';
@@ -436,3 +437,5 @@ export * from './workspace/view/prototypePlayback.js';
 export type { PrototypeInputFrame } from './workspace/view/prototypeInputFrame.js';
 export { createPrototypeProjectionContext } from './workspace/edit/prototypeProjection.js';
 export type { PrototypeProjectionContext } from './workspace/edit/prototypeProjection.js';
+export * from './workspace/edit/rasterExport.js';
+export * from './document/imagePaintGeometry.js';

package/dist-lib/types/workspace/contracts.d.ts

@@ -13,6 +13,12 @@ export interface WorkspaceDesignContext {
     target: WorkspaceTarget;
     selection: readonly string[];
     camera: WorkspaceCamera;
+    /** Page navigation is view state, separate from the saved design document. */
+    pageId?: string;
+    pages?: Readonly<Record<string, {
+        selection: readonly string[];
+        camera: WorkspaceCamera;
+    }>>;
 }
 export interface WorkspaceApplicationSurface {
     /** An implementation URL or a built draft URL supplied by the host. */

package/dist-lib/types/workspace/controller.d.ts

@@ -17,6 +17,7 @@ export declare class WorkspaceController {
     edit(target?: WorkspaceTarget | null): void;
     setMode(mode: Exclude<WorkspaceMode, 'application'>): void;
     setSelection(selection: readonly string[]): void;
+    setDesignPage(pageId: string, currentPageId?: string): void;
     setCamera(mode: 'view' | 'edit', next: WorkspaceCamera): void;
     beginApplication(request: WorkspaceRunRequest): number;
     private startApplication;

package/dist-lib/types/workspace/edit/ArrangeLayers.d.ts

@@ -1,10 +1,11 @@
 import type { DesignDocument, DocumentEngineOptions, DocumentTransaction } from '../../document/contracts.js';
 import type { DataProjection } from '../../binding/preview.js';
 
-export declare function ArrangeLayers({ document, selected, projection, preflight, act }: {
+export declare function ArrangeLayers({ document, selected, projection, preflight, act, compact }: {
     document: DesignDocument;
     selected: readonly string[];
     projection: DataProjection | null;
+    compact?: boolean;
     preflight?: DocumentEngineOptions['preflight'];
     act(label: string, apply: (transaction: DocumentTransaction) => void): boolean;
 }): import("react").JSX.Element;

package/dist-lib/types/workspace/edit/AssetsPanel.d.ts

@@ -1,8 +1,9 @@
 import type { DocumentEngine } from '../../document/contracts.js';
-import { type DesignExportArtifact, type RasterExportRenderer } from '../../document/exportSettings.js';
+import type { DesignExportArtifact, RasterExportRenderer } from '../../document/exportSettings.js';
 
 export interface AssetsPanelProps {
     engine: DocumentEngine;
+    pageId?: string;
     parentId?: string;
     selectedNodeId?: string;
     allocateId: (sourceId: string) => string;
@@ -11,6 +12,6 @@ export interface AssetsPanelProps {
     rasterRenderer?: RasterExportRenderer;
     disabled?: boolean;
 }
-export declare function AssetsPanel({ engine, parentId, selectedNodeId, allocateId, onSelect, onExport, rasterRenderer, disabled }: AssetsPanelProps): import("react").JSX.Element;
+export declare function AssetsPanel({ engine, pageId, parentId, selectedNodeId, allocateId, onSelect, onExport, rasterRenderer, disabled }: AssetsPanelProps): import("react").JSX.Element;
 /** Explicit local download callback for the panel; raster output still needs a separate host renderer. */
 export declare function downloadDesignArtifact(artifact: DesignExportArtifact): void;

package/dist-lib/types/workspace/edit/CanvasGuides.d.ts

@@ -1,16 +1,19 @@
 import type { DataProjection } from '../../binding/preview.js';
+import type { WorkspaceCamera } from '../contracts.js';
 import type { DesignDocument, DocumentNode, DocumentTransaction } from '../../document/contracts.js';
 
 type Act = (label: string, apply: (transaction: DocumentTransaction) => void) => unknown;
-/** Rulers and persisted guide/grid overlays use canvas units inside the scaled stage. */
-export declare function CanvasGuides({ document, selected, projection, zoom, act, width, height }: {
+/** A camera mounts rulers in viewport pixels and transforms document annotations exactly once. */
+export declare function CanvasGuides({ document, selected, projection, camera, zoom: suppliedZoom, act, width, height, visibleRootIds }: {
     document: DesignDocument;
     selected?: readonly string[];
     projection?: DataProjection | null;
-    zoom: number;
+    camera?: WorkspaceCamera;
+    zoom?: number;
     act: Act;
     width?: number;
     height?: number;
+    visibleRootIds?: readonly string[];
 }): import("react").JSX.Element;
 export declare function CanvasGuidesPanel({ node, act }: {
     node: DocumentNode;

package/dist-lib/types/workspace/edit/EditViewport.d.ts

@@ -21,5 +21,11 @@ export interface EditViewportProps {
     initialFit?: boolean;
     /** Wait for asynchronously projected geometry before the initial fit. */
     ready?: boolean;
+    /** Viewport furniture stays outside the transformed document stage. */
+    overlay?(viewport: {
+        camera: WorkspaceCamera;
+        width: number;
+        height: number;
+    }): ReactNode;
 }
 export declare const EditViewport: import("react").ForwardRefExoticComponent<EditViewportProps & import("react").RefAttributes<EditViewportHandle>>;

package/dist-lib/types/workspace/edit/EditorCommandMenu.d.ts

@@ -0,0 +1,18 @@
+
+export interface EditorMenuCommand {
+    id: string;
+    label: string;
+    shortcut?: string;
+    disabled?: boolean;
+    reason?: string;
+    group: string;
+    run(): void;
+}
+/** One keyboard-accessible command surface for both the file and layer menus. */
+export declare function EditorCommandMenu({ x, y, label, commands, onClose }: {
+    x: number;
+    y: number;
+    label: string;
+    commands: readonly EditorMenuCommand[];
+    onClose(): void;
+}): import("react").ReactPortal;

package/dist-lib/types/workspace/edit/ImageCropEditor.d.ts

@@ -0,0 +1,13 @@
+import type { DocumentMatrix } from '../../document/contracts.js';
+import type { DocumentAsset, ImagePaint } from '../../document/assets.js';
+
+export interface ImageCropEditorProps {
+    asset: DocumentAsset;
+    paint: ImagePaint;
+    width: number;
+    height: number;
+    onApply(matrix: DocumentMatrix): void;
+    onCancel(): void;
+}
+/** This local preview keeps asset bytes and canonical history unchanged until Apply. */
+export declare function ImageCropEditor({ asset, paint, width, height, onApply, onCancel }: ImageCropEditorProps): import("react").JSX.Element;

package/dist-lib/types/workspace/edit/LayerTree.d.ts

@@ -1,3 +1,4 @@
+import type { MouseEvent } from 'react';
 import type { DesignDocument, DocumentEngineOptions, DocumentTransaction } from '../../document/contracts.js';
 import type { HostDataCapabilities } from '../../binding/contracts.js';
 
@@ -9,6 +10,9 @@ export interface LayerTreeProps {
     preflight?: DocumentEngineOptions['preflight'];
     /** With host declarations, a drop blocked only by a data-scope escape asks for explicit binding decisions. */
     capabilities?: HostDataCapabilities;
+    /** Undefined preserves the full document tree; an empty array shows an empty page. */
+    rootIds?: readonly string[];
+    onContextMenu?(event: MouseEvent<HTMLDivElement>, nodeId: string): void;
 }
 /** A document-owned tree gesture always commits through the existing document transaction. */
-export declare function LayerTree({ document, selected, onSelectionChange, act, preflight, capabilities }: LayerTreeProps): import("react").JSX.Element;
+export declare function LayerTree({ document, selected, onSelectionChange, act, preflight, capabilities, rootIds, onContextMenu }: LayerTreeProps): import("react").JSX.Element;

package/dist-lib/types/workspace/edit/LayoutPanel.d.ts

@@ -7,7 +7,8 @@ export interface LayoutPanelProps {
     act: Act;
     sourceGroup?: boolean;
     intrinsic?: boolean;
+    compact?: boolean;
 }
 /** Authored layout controls. Source wrappers retain host-declared spacing spellings on review. */
-export declare function LayoutPanel({ document, node, act, sourceGroup, intrinsic }: LayoutPanelProps): import("react").JSX.Element;
+export declare function LayoutPanel({ document, node, act, sourceGroup, intrinsic, compact }: LayoutPanelProps): import("react").JSX.Element;
 export {};

package/dist-lib/types/workspace/edit/NodeExportPanel.d.ts

@@ -0,0 +1,10 @@
+import type { DocumentEngine } from '../../document/contracts.js';
+import { type DesignExportArtifact, type RasterExportRenderer } from '../../document/exportSettings.js';
+/** The inspector and asset browser share one persisted export-settings editor. */
+export declare function NodeExportPanel({ engine, nodeId, onExport, rasterRenderer, disabled }: {
+    engine: DocumentEngine;
+    nodeId?: string;
+    onExport?(artifact: DesignExportArtifact): void | Promise<void>;
+    rasterRenderer?: RasterExportRenderer;
+    disabled?: boolean;
+}): import("react").JSX.Element;

package/dist-lib/types/workspace/edit/PagesPanel.d.ts

@@ -0,0 +1,12 @@
+import type { DesignDocument, DocumentDuplicateMetadataRemapper, DocumentTransaction } from '../../document/contracts.js';
+
+export interface PagesPanelProps {
+    document: DesignDocument;
+    activePageId: string;
+    onPageChange(pageId: string): void;
+    act(label: string, apply: (transaction: DocumentTransaction) => void): boolean;
+    duplicateMetadata?: DocumentDuplicateMetadataRemapper;
+    allocateId?(): string;
+}
+/** Page selection is UI state; only explicit page edits create document history. */
+export declare function PagesPanel({ document, activePageId, onPageChange, act, duplicateMetadata, allocateId }: PagesPanelProps): import("react").JSX.Element;

package/dist-lib/types/workspace/edit/PanelResizeHandle.d.ts

@@ -0,0 +1,12 @@
+
+export interface PanelResizeHandleProps {
+    side: 'left' | 'right';
+    width: number;
+    min: number;
+    max: number;
+    defaultWidth: number;
+    onWidthChange(width: number): void;
+    label?: string;
+}
+/** Panel layout only. Live widths are controlled; cancellation restores the starting width. */
+export declare function PanelResizeHandle({ side, width, min, max, defaultWidth, onWidthChange, label }: PanelResizeHandleProps): import("react").JSX.Element;

package/dist-lib/types/workspace/edit/PrototypePanel.d.ts

@@ -1,4 +1,5 @@
 import type { DocumentEngine } from '../../document/contracts.js';
+import type { PrototypeConnectionSelection } from './prototypeWiringModel.js';
 
 export declare function PrototypeField({ label, value, onCommit, numeric }: {
     label: string;
@@ -6,7 +7,10 @@ export declare function PrototypeField({ label, value, onCommit, numeric }: {
     onCommit(value: string): void;
     numeric?: boolean;
 }): import("react").JSX.Element;
-export declare function PrototypePanel({ engine, nodeId }: {
+export declare function PrototypePanel({ engine, nodeId, selectedConnection, onSelectConnection, compact }: {
+    compact?: boolean;
     engine: DocumentEngine;
     nodeId: string | null;
+    selectedConnection?: PrototypeConnectionSelection | null;
+    onSelectConnection?(value: PrototypeConnectionSelection | null): void;
 }): import("react").JSX.Element;

package/dist-lib/types/workspace/edit/PrototypeWiring.d.ts

@@ -0,0 +1,18 @@
+import type { DataProjection } from '../../binding/preview.js';
+import type { DesignDocument, DocumentTransaction } from '../../document/contracts.js';
+import { type PrototypeConnectionSelection } from './prototypeWiringModel.js';
+
+export type { PrototypeConnectionSelection } from './prototypeWiringModel.js';
+export interface PrototypeWiringProps {
+    document: DesignDocument;
+    selected: readonly string[];
+    projection: DataProjection | null;
+    zoom: number;
+    visibleRootIds?: readonly string[];
+    selectedConnection: PrototypeConnectionSelection | null;
+    onSelectConnection(value: PrototypeConnectionSelection | null): void;
+    onSelect(nodeId: string): void;
+    act(label: string, apply: (transaction: DocumentTransaction) => void): boolean;
+}
+/** An authoring overlay in page coordinates. Browsing or dragging never runs a prototype action. */
+export declare function PrototypeWiring(props: PrototypeWiringProps): import("react").JSX.Element | null;

package/dist-lib/types/workspace/edit/SelectionHandles.d.ts

@@ -9,6 +9,7 @@ export interface LayerGeometryPreview extends LayerPlacement {
 export interface SelectionHandlesProps {
     document: DesignDocument;
     selected: readonly string[];
+    visibleRootIds?: readonly string[];
     projection: DataProjection | null;
     /** Canvas scale; handles keep a constant screen size and snapping a constant screen tolerance. */
     zoom: number;
@@ -20,6 +21,8 @@ export interface SelectionHandlesProps {
         readonly y: number;
         readonly guides?: readonly SnapGuide[];
     } | null;
+    /** Pending canvas placements for a move involving several layers. */
+    movePreviews?: readonly LayerGeometryPreview[] | null;
     /** Lets the canvas render the layer with in-gesture geometry; `null` ends the preview. */
     onPreview?(preview: LayerGeometryPreview | null): void;
     /** Same for a selection box gesture, which previews several layers at once; `null` ends the preview. */
@@ -35,18 +38,19 @@ export declare const SELECTION_BOX_ID = "selection";
  * constant on screen. Every gesture becomes one document transaction on release; Escape cancels
  * it with the document untouched. Layers the geometry policy refuses (auto layout children,
  * source layout, repeated rows) get no handles; the inspector section reports the diagnostic,
- * mirroring layer arrangement, so the canvas DOM carries no text beyond the transient gesture
- * feedback.
+ * mirroring layer arrangement. The dimension badge follows the live world bounds without
+ * applying its own document changes.
  */
-export declare function SelectionHandles({ document, selected, projection, zoom, act, movePreview, onPreview, onPreviewMany }: SelectionHandlesProps): import("react").JSX.Element;
+export declare function SelectionHandles({ document, selected, visibleRootIds, projection, zoom, act, movePreview, movePreviews, onPreview, onPreviewMany }: SelectionHandlesProps): import("react").JSX.Element;
 /**
  * Inspector section: the geometry policy for the whole selection, plus parent-relative rotation
  * in degrees and resize constraints when exactly one layer is selected.
  */
-export declare function LayerGeometryInspector({ document, selected, projection, act }: {
+export declare function LayerGeometryInspector({ document, selected, projection, act, compact }: {
     document: DesignDocument;
     selected: readonly string[];
     projection: DataProjection | null;
     act: Act;
+    compact?: boolean;
 }): import("react").JSX.Element | null;
 export {};

package/dist-lib/types/workspace/edit/canvasGuideModel.d.ts

@@ -45,11 +45,20 @@ export interface LayoutGridGeometry {
     readonly axis: GuideAxis;
     readonly tracks: readonly LayoutGridTrack[];
 }
+/** An origin-zero pixel lattice, clipped to its owner's local box; no individual lines are allocated. */
+export interface LayoutGridLattice {
+    readonly axis: GuideAxis;
+    readonly step: number;
+    readonly extent: number;
+}
 export interface RulerTick {
     readonly position: number;
     readonly major: boolean;
     readonly label?: string;
 }
+export interface ViewportRulerTick extends RulerTick {
+    readonly screen: number;
+}
 export interface RulerScale {
     readonly major: number;
     readonly minor: number;
@@ -64,6 +73,7 @@ export declare const LAYOUT_GRID_DEFAULT_COLOR = "#ff4d4d1a";
 export declare const PIXEL_GRID_DEFAULT_COLOR = "#0000000f";
 /** Screen pixels between two labelled ruler ticks, at least. */
 export declare const RULER_LABEL_SPACING = 60;
+export declare const RULER_THICKNESS = 18;
 export declare function isCanvasGuide(value: unknown): value is CanvasGuide;
 /** Strict structural check of a stored layout grid; unknown keys and non-finite numbers are rejected. */
 export declare function isLayoutGrid(value: unknown): value is LayoutGrid;
@@ -94,9 +104,15 @@ export declare function layoutGridTracks(grid: LayoutGridTracks, length: number)
 export declare function layoutGridGeometry(grid: LayoutGrid, width: number, height: number): LayoutGridGeometry | null;
 /** Distinct track edges of every visible column and row grid on a node, by axis, for snapping. */
 export declare function layoutGridSnapLines(grids: readonly LayoutGrid[], width: number, height: number): CanvasGuide[];
+/** Two constant-size descriptors per visible pixel grid, including subpixel and very dense grids. */
+export declare function layoutGridSnapLattices(grids: readonly LayoutGrid[], width: number, height: number): readonly LayoutGridLattice[];
+/** Nearest visible line, with the lower line winning a midpoint tie. Work is independent of line count. */
+export declare function nearestLayoutGridLine(lattice: Pick<LayoutGridLattice, 'step' | 'extent'>, position: number): number | null;
 /** Labelled step and tick step for a ruler at a zoom: labels stay at least `RULER_LABEL_SPACING` screen pixels apart. */
 export declare function rulerScale(zoom: number, labelSpacing?: number): RulerScale;
 /** Ticks covering `[from, to]` canvas units; every `major` multiple carries its value as the label. */
 export declare function rulerTicks(zoom: number, from: number, to: number, labelSpacing?: number): RulerTick[];
 /** Canvas position under a ruler pointer: `screen` is measured from the ruler's zero corner, `origin` is where canvas 0 sits on that ruler. */
 export declare function rulerPointToCanvas(screen: number, origin: number, zoom: number): number;
+/** Camera origin is viewport-local; only ticks outside the fixed corner are displayed. */
+export declare function viewportRulerTicks(zoom: number, origin: number, length: number): ViewportRulerTick[];

package/dist-lib/types/workspace/edit/clipboard.d.ts

@@ -29,6 +29,7 @@ export declare function pasteDesignSubtrees(targetInput: DesignDocument, payload
         x: number;
         y: number;
     };
+    pageId?: string;
 }): PasteDesignResult;
 export declare function applyDesignPaste(transaction: Pick<DocumentTransaction, 'replaceDocument'>, plan: PasteDesignResult): void;
 export declare function exportDesignInterchange(document: DesignDocument): string;

package/dist-lib/types/workspace/edit/editorCanvas.d.ts

@@ -13,7 +13,7 @@ export interface CanvasEntry {
     topLevel: boolean;
 }
 export type DrawingTool = 'frame' | 'text' | VectorShape;
-export declare function canvasEntries(document: DesignDocument, projection: DataProjection | null, selected?: readonly string[]): CanvasEntry[];
+export declare function canvasEntries(document: DesignDocument, projection: DataProjection | null, selected?: readonly string[], visibleRootIds?: readonly string[]): CanvasEntry[];
 export declare function canvasBounds(entries: readonly CanvasEntry[]): CanvasBox;
 export declare function marqueeSelection(document: DesignDocument, entries: readonly CanvasEntry[], box: CanvasBox): readonly string[];
 export declare function drawingBox(start: {

package/dist-lib/types/workspace/edit/geometryHandles.d.ts

@@ -73,7 +73,7 @@ export interface SnapGap {
 export interface SnapGuide {
     readonly axis: 'x' | 'y';
     readonly position: number;
-    /** `edge` and `center` come from boxes, `guide` from persisted guides, `grid` from layout grid tracks, `spacing` from equal sibling distances. */
+    /** `edge` and `center` come from boxes, `guide` from persisted guides, `grid` from layout grids, `spacing` from equal sibling distances. */
     readonly kind: 'edge' | 'center' | 'guide' | 'grid' | 'spacing';
     readonly nodeId: string;
     /** Extent along the other axis, for drawing the guide line; equal values mean "the moving box only". */
@@ -83,6 +83,11 @@ export interface SnapGuide {
     readonly reference?: SnapReference;
     /** The equal distances a `spacing` candidate reproduces, for drawing. */
     readonly gaps?: readonly SnapGap[];
+    /** Candidate-only pixel lattice, starting at `position`; resolved feedback never contains this field. */
+    readonly lattice?: {
+        readonly step: number;
+        readonly extent: number;
+    };
 }
 export interface SnapResult {
     readonly dx: number;
@@ -90,6 +95,8 @@ export interface SnapResult {
     readonly guides: readonly SnapGuide[];
 }
 export interface SnapCandidateOptions {
+    /** Ordinary root layers visible on the current page; undefined retains the complete scene. */
+    readonly visibleRootIds?: readonly string[];
     /** Include the moving layers' own children: right for a resize, wrong for a move (the children travel along). */
     readonly children?: boolean;
 }
@@ -105,7 +112,7 @@ export interface MoveSnapSession {
  * refused with a diagnostic instead of guessed bounds. Derived sizes keep move and
  * rotation but drop the resize handles.
  */
-export declare function planSelectionHandles(document: DesignDocument, nodeIds: readonly string[], projection: DataProjection | null): SelectionHandlesPlan;
+export declare function planSelectionHandles(document: DesignDocument, nodeIds: readonly string[], projection: DataProjection | null, options?: SnapCandidateOptions): SelectionHandlesPlan;
 export declare function layerResizeHandles(layer: Pick<LayerGeometry, 'resizable' | 'resizeAxes'>): readonly GeometryHandle[];
 /**
  * Turn a handle drag into a new local size and placement. The handle's opposite edge or
@@ -202,7 +209,7 @@ export declare function snapResizeGesture(layer: LayerPlacement & {
  * Snapshot for a move gesture: the moving box, its candidates (siblings, parent, guides, grids,
  * and equal sibling distances for this box size), and the zoom-aware tolerance.
  */
-export declare function beginMoveSnap(document: DesignDocument, nodeIds: readonly string[], projection: DataProjection | null, zoom: number): MoveSnapSession | null;
+export declare function beginMoveSnap(document: DesignDocument, nodeIds: readonly string[], projection: DataProjection | null, zoom: number, options?: SnapCandidateOptions): MoveSnapSession | null;
 /** Adjust world pointer travel so the moving box snaps; exact in one pass because only translation changes. */
 export declare function snapMove(session: MoveSnapSession, delta: {
     x: number;

package/dist-lib/types/workspace/edit/prototypeWiringModel.d.ts

@@ -0,0 +1,47 @@
+import type { DataProjection } from '../../binding/preview.js';
+import type { DesignDocument, DocumentTransaction } from '../../document/contracts.js';
+import { type PrototypeAction, type PrototypeInteraction } from '../../document/prototype.js';
+export type PrototypeActionPath = readonly (number | 'branches' | 'actions' | 'otherwise')[];
+export interface PrototypeConnectionSelection {
+    nodeId: string;
+    interactionId: string;
+    actionPath: PrototypeActionPath;
+}
+export interface PrototypeConnection extends PrototypeConnectionSelection {
+    destinationId: string;
+    action: PrototypeAction;
+    label: string;
+}
+export interface WiringPoint {
+    x: number;
+    y: number;
+}
+export interface WiringBounds extends WiringPoint {
+    width: number;
+    height: number;
+}
+export interface PrototypeWiringLayer {
+    nodeId: string;
+    name: string;
+    bounds: WiringBounds;
+    rootId: string;
+    visible: boolean;
+}
+export interface PrototypeWiringPlan {
+    layers: readonly PrototypeWiringLayer[];
+    diagnostics: readonly string[];
+}
+export declare const connectionKey: (value: PrototypeConnectionSelection) => string;
+/** Only explicit destination actions become wires. No flow or action is inferred. */
+export declare function prototypeConnections(document: DesignDocument): PrototypeConnection[];
+/** Canonical, uniquely placed layers only; projected rows and instance leaves cannot acquire shared actions accidentally. */
+export declare function planPrototypeWiring(document: DesignDocument, projection: DataProjection | null, selected?: readonly string[], visibleRootIds?: readonly string[]): PrototypeWiringPlan;
+/** Builds a complete detached edit before the caller opens its single history transaction. */
+export declare function preparePrototypeConnection(document: DesignDocument, sourceId: string, destinationId: string | null, selection?: PrototypeConnectionSelection, interactionId?: string): PrototypeInteraction[];
+export declare function writePrototypeConnection(transaction: DocumentTransaction, document: DesignDocument, sourceId: string, interactions: readonly PrototypeInteraction[]): void;
+export declare function prototypeWireCurve(source: WiringBounds, target: WiringBounds, lane: number, zoom: number, loop?: boolean): {
+    path: string;
+    start: WiringPoint;
+    end: WiringPoint;
+    middle: WiringPoint;
+};

package/dist-lib/types/workspace/edit/rasterExport.d.ts

@@ -0,0 +1,5 @@
+import { type RasterExportRenderer, type RasterExportRequest } from '../../document/exportSettings.js';
+/** The same supported SVG geometry supplies browser raster output; unsupported visuals stay explicit. */
+export declare function rasterExportSvg(request: RasterExportRequest): string;
+/** Explicit browser renderer for supported geometry. It never captures a page or fetches external resources. */
+export declare const renderDesignRaster: RasterExportRenderer;

package/dist-lib/types/workspace/view/prototypeMotionInterruption.d.ts

@@ -0,0 +1,37 @@
+import type { PrototypeTransition } from '../../document/prototype.js';
+export declare const prototypeMotionProperties: readonly ["transform", "width", "height", "opacity", "backgroundColor", "borderRadius"];
+export type PrototypeMotionProperty = typeof prototypeMotionProperties[number];
+export type PrototypeMotionStyles = Record<PrototypeMotionProperty, string>;
+export interface PrototypeMotionCapture {
+    styles: PrototypeMotionStyles;
+    velocity: Partial<Record<PrototypeMotionProperty, readonly number[]>>;
+}
+export interface PrototypeMotionRecord {
+    element: HTMLElement;
+    animation: Animation;
+    frames: readonly Keyframe[];
+    durationMs: number;
+    easing(progress: number): number;
+}
+/** Mirrors the bounded CSS linear() samples used by the physical spring renderer. */
+export declare function prototypeMotionTiming(transition: PrototypeTransition, durationMs: number): (progress: number) => number;
+/** Reads presentation once. No time seeks, inline-style writes, frame history or DOM mutations. */
+export declare function capturePrototypeMotionStyles(elements: readonly HTMLElement[], records: readonly PrototypeMotionRecord[], drag?: {
+    progress: number;
+    velocity: number;
+} | null): Map<HTMLElement, PrototypeMotionCapture>;
+export interface PrototypeInterruptedTiming {
+    readonly samples: readonly {
+        offset: number;
+        progress: number;
+        velocityResponse: number;
+    }[];
+    readonly initialSlope: number;
+}
+/** One shared timing table per interrupted transition, never one solver per layer/channel. */
+export declare function createPrototypeInterruptedTiming(transition: PrototypeTransition, durationMs: number): PrototypeInterruptedTiming;
+/** Existing computed 2D/px/RGB tracks only. Unsupported values retain explicit diagnostics. */
+export declare function createPrototypeInterruptedFrames(captured: PrototypeMotionCapture, target: Partial<PrototypeMotionStyles>, timing: PrototypeInterruptedTiming): {
+    frames: Keyframe[];
+    unsupported: PrototypeMotionProperty[];
+};