@pygmalionjs/pygmalion 0.8.1 → 0.9.0

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

@@ -0,0 +1,16 @@
+import type { DocumentEngine } from '../../document/contracts.js';
+import { type DesignExportArtifact, type RasterExportRenderer } from '../../document/exportSettings.js';
+
+export interface AssetsPanelProps {
+    engine: DocumentEngine;
+    parentId?: string;
+    selectedNodeId?: string;
+    allocateId: (sourceId: string) => string;
+    onSelect?: (nodeId: string) => void;
+    onExport?: (artifact: DesignExportArtifact) => void | Promise<void>;
+    rasterRenderer?: RasterExportRenderer;
+    disabled?: boolean;
+}
+export declare function AssetsPanel({ engine, 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

@@ -0,0 +1,19 @@
+import type { DataProjection } from '../../binding/preview.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 }: {
+    document: DesignDocument;
+    selected?: readonly string[];
+    projection?: DataProjection | null;
+    zoom: number;
+    act: Act;
+    width?: number;
+    height?: number;
+}): import("react").JSX.Element;
+export declare function CanvasGuidesPanel({ node, act }: {
+    node: DocumentNode;
+    act: Act;
+}): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,11 @@
+import type { DesignDocument, DocumentDuplicateMetadataRemapper, DocumentTransaction } from '../../document/contracts.js';
+
+export interface ComponentPanelProps {
+    document: DesignDocument;
+    selected: readonly string[];
+    act(label: string, apply: (transaction: DocumentTransaction) => void): boolean;
+    onSelect(id: string): void;
+    allocateId?(sourceId: string): string;
+    remapMetadata?: DocumentDuplicateMetadataRemapper;
+}
+export declare function ComponentPanel({ document, selected, act, onSelect, allocateId, remapMetadata }: ComponentPanelProps): import("react").JSX.Element | null;

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

@@ -0,0 +1,16 @@
+import type { DocumentEngine } from '../../document/contracts.js';
+import type { HostDataCapabilities } from '../../binding/contracts.js';
+import type { DataProjection } from '../../binding/preview.js';
+export interface DataPanelProps {
+    engine: DocumentEngine;
+    selectedNodeId: string | null;
+    capabilities: HostDataCapabilities;
+    screenId: string;
+    onProjection?(projection: DataProjection | null): void;
+    onRequestData?(request: {
+        screenId: string;
+        description: string;
+    }): void;
+}
+/** Data is read-only host knowledge; this panel changes only placement and presentation. */
+export declare function DataPanel({ engine, selectedNodeId, capabilities, screenId, onProjection, onRequestData }: DataPanelProps): import("react").JSX.Element;

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

@@ -0,0 +1,10 @@
+import type { EditorRuntime } from '../../core/runtime.js';
+import { type WorkspaceConfiguration } from '../configuration.js';
+import { type WorkspaceDocumentSessions } from '../documentSessions.js';
+
+export interface DesignWorkspaceProps {
+    runtime: EditorRuntime;
+    configuration: WorkspaceConfiguration;
+    sessions: WorkspaceDocumentSessions;
+}
+export declare function DesignWorkspace(props: DesignWorkspaceProps): import("react").JSX.Element;

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

@@ -0,0 +1,14 @@
+import type { DesignDocument, DocumentEngineOptions, DocumentTransaction } from '../../document/contracts.js';
+import type { HostDataCapabilities } from '../../binding/contracts.js';
+
+export interface LayerTreeProps {
+    document: DesignDocument;
+    selected: readonly string[];
+    onSelectionChange(ids: readonly string[]): void;
+    act(label: string, apply: (transaction: DocumentTransaction) => void): boolean;
+    preflight?: DocumentEngineOptions['preflight'];
+    /** With host declarations, a drop blocked only by a data-scope escape asks for explicit binding decisions. */
+    capabilities?: HostDataCapabilities;
+}
+/** 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;

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

@@ -0,0 +1,13 @@
+import type { DesignDocument, DocumentNode, DocumentTransaction } from '../../document/contracts.js';
+
+type Act = (label: string, apply: (transaction: DocumentTransaction) => void) => unknown;
+export interface LayoutPanelProps {
+    document: DesignDocument;
+    node: DocumentNode;
+    act: Act;
+    sourceGroup?: boolean;
+    intrinsic?: 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 {};

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

@@ -0,0 +1,12 @@
+import type { DocumentEngine } from '../../document/contracts.js';
+
+export declare function PrototypeField({ label, value, onCommit, numeric }: {
+    label: string;
+    value: string | number;
+    onCommit(value: string): void;
+    numeric?: boolean;
+}): import("react").JSX.Element;
+export declare function PrototypePanel({ engine, nodeId }: {
+    engine: DocumentEngine;
+    nodeId: string | null;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,40 @@
+import type { ReactNode } from 'react';
+import type { HostDataCapabilities } from '../../binding/contracts.js';
+import type { DesignDocument, DocumentEngineOptions, DocumentTransaction } from '../../document/contracts.js';
+import { type DocumentLayerMoveRequest, type ReadyDocumentLayerMove } from './layerMoves.js';
+import { type ScopeTransferDecision, type ScopeTransferDecisionPlan, type ScopeTransferPlan } from './scopeTransfer.js';
+
+export interface ScopeTransferDialogProps {
+    plan: ScopeTransferDecisionPlan;
+    /** A rejected decision set stays open with its diagnostics; the document is untouched. */
+    error?: string;
+    onCancel(): void;
+    onApply(decisions: readonly ScopeTransferDecision[]): void;
+}
+/**
+ * Presents every connection a move would carry out of its data scope, with declaration evidence,
+ * and collects one explicit decision per connection. Cancel is the default; nothing is committed
+ * until the caller applies the complete decision set in one document transaction.
+ */
+export declare function ScopeTransferDialog({ plan, error, onCancel, onApply }: ScopeTransferDialogProps): import("react").JSX.Element;
+export interface ScopeTransferHandlers {
+    label: string;
+    onCommitted?(move: ReadyDocumentLayerMove): void;
+    /** The move was planned but not applied: the live transaction failed or the document changed. */
+    onRejected?(message: string): void;
+    onCancelled?(): void;
+}
+export interface ScopeTransferController {
+    /** Commits a plain move immediately; a scope-only rejection opens the decision dialog instead. */
+    move(request: DocumentLayerMoveRequest, handlers: ScopeTransferHandlers): ScopeTransferPlan;
+    pending: ScopeTransferDecisionPlan | null;
+    cancel(): void;
+    dialog: ReactNode;
+}
+/** Shared by the layer tree and any inspector control that reparents layers through the live transaction. */
+export declare function useScopeTransfer({ document, capabilities, preflight, act }: {
+    document: DesignDocument;
+    capabilities?: HostDataCapabilities;
+    preflight?: DocumentEngineOptions['preflight'];
+    act(label: string, apply: (transaction: DocumentTransaction) => void): boolean;
+}): ScopeTransferController;

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

@@ -0,0 +1,52 @@
+import type { DataProjection } from '../../binding/preview.js';
+import type { DesignDocument, DocumentTransaction } from '../../document/contracts.js';
+import { type LayerPlacement, type SnapGuide } from './geometryHandles.js';
+
+type Act = (label: string, apply: (transaction: DocumentTransaction) => void) => boolean;
+export interface LayerGeometryPreview extends LayerPlacement {
+    readonly nodeId: string;
+}
+export interface SelectionHandlesProps {
+    document: DesignDocument;
+    selected: readonly string[];
+    projection: DataProjection | null;
+    /** Canvas scale; handles keep a constant screen size and snapping a constant screen tolerance. */
+    zoom: number;
+    act: Act;
+    /** A move the canvas is previewing itself: the box follows it and its guides are drawn here. */
+    movePreview?: {
+        readonly nodeId: string;
+        readonly x: number;
+        readonly y: number;
+        readonly guides?: readonly SnapGuide[];
+    } | 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. */
+    onPreviewMany?(previews: readonly LayerGeometryPreview[] | null): void;
+}
+/** Key of the shared box in `data-selection-box` when several layers are selected. */
+export declare const SELECTION_BOX_ID = "selection";
+/**
+ * Canvas overlay for free-placement layers: eight resize handles, a rotation handle, and snap
+ * guides. One selected layer gets its own box; several selected layers share one selection box
+ * that resizes and rotates every independent member together. It is mounted inside the scaled
+ * stage so its coordinates are canvas units, while handle sizes divide by the zoom to stay
+ * 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.
+ */
+export declare function SelectionHandles({ document, selected, projection, zoom, act, movePreview, 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 }: {
+    document: DesignDocument;
+    selected: readonly string[];
+    projection: DataProjection | null;
+    act: Act;
+}): import("react").JSX.Element | null;
+export {};

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

@@ -0,0 +1,8 @@
+import type { DesignDocument, DocumentNode, DocumentTransaction } from '../../document/contracts.js';
+
+export interface StylesPanelProps {
+    document: DesignDocument;
+    node: DocumentNode | null;
+    act(label: string, apply: (tx: DocumentTransaction) => void): boolean;
+}
+export declare function StylesPanel({ document, node, act }: StylesPanelProps): import("react").JSX.Element | null;

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

@@ -0,0 +1,50 @@
+import type { DesignDocument, DocumentNode, DocumentTransaction } from '../../document/contracts.js';
+import { type TextFontLoader, type TextFontLoadReport } from '../../document/richText.js';
+
+type Act = (label: string, apply: (transaction: DocumentTransaction) => void) => boolean;
+/**
+ * Renders a text node's paragraphs and runs with inline styles. Lists are real `<ul>`/`<ol>` elements and
+ * links are `<a>` elements that never navigate inside the editor. `content` is projected bound data,
+ * rendered plain with the node-level style only.
+ */
+export declare function TextNodeSurface({ node, content }: {
+    node: DocumentNode;
+    content?: string;
+}): import("react").JSX.Element;
+/**
+ * Loads the faces a text node needs through the injected loader (the browser font set when none is given) and
+ * reports what stayed unavailable. `null` while nothing is required, no loader exists, or the load is pending.
+ * Nothing here reaches the network on its own; the host declares its faces.
+ */
+export declare function useTextFontStatus(node: DocumentNode, loader?: TextFontLoader | null): TextFontLoadReport | null;
+export interface TextInlineEditorProps {
+    document: DesignDocument;
+    node: DocumentNode;
+    act: Act;
+    /** Called once the edit is committed or discarded; the canvas then shows the surface again. */
+    onDone(): void;
+    /** Whether a binding targets the node; derived from the document when omitted. */
+    connected?: boolean;
+}
+/**
+ * Edits the written text in place on the canvas. Mounted by the canvas instead of the surface after a
+ * double-click; blur or Ctrl/Cmd+Enter commits one transaction, Escape discards the draft. Connected text
+ * is refused because its content comes from data.
+ */
+export declare function TextInlineEditor({ document, node, act, onDone, connected }: TextInlineEditorProps): import("react").JSX.Element;
+export interface TextEditorProps {
+    document: DesignDocument;
+    node: DocumentNode;
+    act: Act;
+    /** Whether a binding targets the node; derived from the document when omitted. */
+    connected?: boolean;
+    /** Resolves required faces; the browser font set when omitted, no loading when null. */
+    fontLoader?: TextFontLoader | null;
+}
+/**
+ * Inspector section for a text node. The written text is edited in a textarea whose selection decides
+ * whether a style applies to a character range or to the whole layer. Every committed edit is one
+ * document transaction; Escape discards the uncommitted draft.
+ */
+export declare function TextEditor({ document, node, act, connected, fontLoader }: TextEditorProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,89 @@
+import type { ReactNode } from 'react';
+import type { DataProjection } from '../../binding/preview.js';
+import type { DesignDocument, DocumentNode, DocumentTransaction } from '../../document/contracts.js';
+import { type VectorAnchor, type VectorAnchorAddress, type VectorBooleanOperation, type VectorProperties, type VectorShape } from '../../document/vector.js';
+import { type VectorAnchorAction, type VectorAnchorActions, type VectorBooleanPlan, type VectorEditPlan, type VectorStyle, type VectorTool } from './vectorTools.js';
+
+type Act = (label: string, apply: (transaction: DocumentTransaction) => void) => boolean;
+/** Box geometry a canvas gesture is previewing for one layer; the surface draws it instead of the stored path. */
+export interface VectorGeometryPreview {
+    readonly nodeId: string;
+    readonly vector: VectorProperties;
+}
+export interface VectorEditingSession {
+    readonly document: DesignDocument;
+    readonly projection: DataProjection | null;
+    readonly selection: readonly string[];
+    readonly tool: VectorTool;
+    setTool(tool: VectorTool): void;
+    readonly plan: VectorEditPlan;
+    /** Selected anchors of the edit target; addresses that no longer exist are dropped. */
+    readonly anchors: readonly VectorAnchorAddress[];
+    setAnchors(anchors: readonly VectorAnchorAddress[]): void;
+    readonly actions: VectorAnchorActions;
+    readonly boolean: VectorBooleanPlan;
+    readonly feedback: string;
+    report(text: string): void;
+    insertShape(shape: VectorShape): void;
+    /** Commits a pen path; points are canvas coordinates of the stage. */
+    drawPath(points: readonly VectorAnchor[], closed: boolean): boolean;
+    /** Stores box geometry on the edit target as one transaction, refitting the layer box. */
+    commitGeometry(label: string, next: VectorProperties, anchors?: readonly VectorAnchorAddress[]): boolean;
+    changeArc(key: 'start' | 'sweep' | 'innerRadius', value: number): void;
+    restyle(label: string, style: Partial<VectorStyle>): boolean;
+    runAnchorAction(action: VectorAnchorAction): void;
+    combine(operation: VectorBooleanOperation): void;
+}
+export interface VectorEditing extends VectorEditingSession {
+    readonly toolbar: ReactNode;
+    readonly inspector: ReactNode;
+}
+export interface VectorEditingInput {
+    document: DesignDocument;
+    selection: readonly string[];
+    projection: DataProjection | null;
+    act: Act;
+    select(id: string): void;
+}
+export interface VectorEditorProps {
+    session: VectorEditingSession;
+    zoom: number;
+    onPreview?(preview: VectorGeometryPreview | null): void;
+}
+/**
+ * Renders a vector layer: one `<svg>` filling the layer box with the stored path, fitted to
+ * the box, honouring fill, fill rule, stroke, and corner radius. A mask layer shows no paint
+ * of its own; the canvas clips the siblings above it with the mask's outline.
+ */
+export declare function VectorNodeSurface({ node, width, height, vector }: {
+    node: DocumentNode;
+    width?: number;
+    height?: number;
+    vector?: VectorProperties;
+}): import("react").JSX.Element;
+/**
+ * Owns the vector editing state for a design workspace: the active tool, the anchor selection,
+ * gesture feedback, and every command the toolbar, the canvas overlay, and the inspector issue.
+ * The returned `toolbar` and `inspector` are ready to mount; the canvas mounts `VectorEditor`
+ * with the same session inside the stage.
+ */
+export declare function useVectorEditing({ document, selection, projection, act, select }: VectorEditingInput): VectorEditing;
+/**
+ * Canvas overlay inside the scaled stage. With the pen tool it covers the stage and turns
+ * clicks into anchors (a click on the first anchor closes the path, Enter finishes an open
+ * one, Escape discards the draft). With the select tool it draws the selected path's
+ * anchors and handles: drag moves them with a live preview and commits one transaction on
+ * release, Escape cancels with the document untouched, double-clicking a segment adds an
+ * anchor, Delete removes the selected anchors. Handle and anchor sizes divide by the zoom.
+ */
+export declare function VectorEditor({ session, zoom, onPreview }: VectorEditorProps): import("react").JSX.Element;
+/**
+ * Inspector section for vector layers: paint, stroke, corner radius, and mask for one selected
+ * layer; anchor actions for the anchors selected on the canvas; boolean operations when two
+ * vector layers sharing a parent are selected. Policy and gesture feedback show here, never
+ * inside the canvas.
+ */
+export declare function VectorInspector({ session }: {
+    session: VectorEditingSession;
+}): import("react").JSX.Element | null;
+export {};

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

@@ -0,0 +1,5 @@
+import type { VectorEditingSession } from './VectorEditor.js';
+/** Toolbar group: the select and pen tools plus one button per shape. */
+export declare function VectorToolbar({ session }: {
+    session: VectorEditingSession;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,102 @@
+import type { DocumentNode, DocumentNodeKind, DocumentNodePatch } from '../../document/contracts.js';
+/**
+ * Pure model for the canvas furniture that Figma keeps next to the layers: persisted
+ * guides, layout grids on frames, and the rulers that measure the stage.
+ *
+ * Guides live on the node they belong to as `node.properties.guides`: the document root
+ * carries the canvas guides (canvas units, the space root children are placed in) and a
+ * frame carries its own guides in its local space. Layout grids live on frames and
+ * component definitions as `node.properties.layoutGrids`, in the local space of the box
+ * they describe. Both are plain document values, so they save, reopen, and undo with the
+ * document like any other property; nothing here reaches the DOM.
+ */
+export type GuideAxis = 'x' | 'y';
+/** A guide is one straight line across its owner: `axis: 'x'` is a vertical line at `position`. */
+export interface CanvasGuide {
+    axis: GuideAxis;
+    position: number;
+}
+export type LayoutGridPattern = 'columns' | 'rows' | 'grid';
+export type LayoutGridAlign = 'stretch' | 'start' | 'center' | 'end';
+export interface LayoutGridTracks {
+    pattern: 'columns' | 'rows';
+    count: number;
+    gutter: number;
+    align: LayoutGridAlign;
+    /** Track width or height; ignored (derived) for `stretch`. */
+    size?: number;
+    /** Margin from both edges for `stretch`, from the leading edge for `start`, from the trailing edge for `end`. */
+    offset?: number;
+    visible?: boolean;
+    color?: string;
+}
+export interface LayoutGridPixels {
+    pattern: 'grid';
+    size: number;
+    visible?: boolean;
+    color?: string;
+}
+export type LayoutGrid = LayoutGridTracks | LayoutGridPixels;
+export interface LayoutGridTrack {
+    readonly start: number;
+    readonly end: number;
+}
+export interface LayoutGridGeometry {
+    readonly axis: GuideAxis;
+    readonly tracks: readonly LayoutGridTrack[];
+}
+export interface RulerTick {
+    readonly position: number;
+    readonly major: boolean;
+    readonly label?: string;
+}
+export interface RulerScale {
+    readonly major: number;
+    readonly minor: number;
+}
+export declare const GUIDES_PROPERTY = "guides";
+export declare const LAYOUT_GRIDS_PROPERTY = "layoutGrids";
+/** Node kinds that may carry layout grids; the document root carries canvas guides only. */
+export declare const LAYOUT_GRID_KINDS: readonly DocumentNodeKind[];
+export declare const LAYOUT_GRID_PATTERNS: readonly LayoutGridPattern[];
+export declare const LAYOUT_GRID_ALIGNMENTS: readonly LayoutGridAlign[];
+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 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;
+/** Valid guides stored on a node, detached; invalid entries are dropped so one bad value never hides the rest. */
+export declare function nodeGuides(node: Pick<DocumentNode, 'properties'>): CanvasGuide[];
+/** Valid layout grids stored on a node, detached. */
+export declare function nodeLayoutGrids(node: Pick<DocumentNode, 'properties'>): LayoutGrid[];
+export declare function canCarryLayoutGrids(node: Pick<DocumentNode, 'kind'>): boolean;
+/** Stores guides on a node in canonical form; an empty list removes the key. */
+export declare function guidesPatch(node: Pick<DocumentNode, 'properties'>, guides: readonly CanvasGuide[]): DocumentNodePatch;
+/** Stores layout grids on a node in canonical form; an empty list removes the key. */
+export declare function layoutGridsPatch(node: Pick<DocumentNode, 'kind' | 'properties'>, grids: readonly LayoutGrid[]): DocumentNodePatch;
+/** Guides sorted by axis then position, without duplicates closer than `EPSILON`. */
+export declare function normalizeGuides(guides: readonly CanvasGuide[]): CanvasGuide[];
+export declare function addGuide(guides: readonly CanvasGuide[], guide: CanvasGuide): CanvasGuide[];
+export declare function moveGuide(guides: readonly CanvasGuide[], index: number, position: number): CanvasGuide[];
+export declare function removeGuide(guides: readonly CanvasGuide[], index: number): CanvasGuide[];
+/** A grid with the defaults Figma offers: five stretched columns with a 20 gutter, or an eight-unit pixel grid. */
+export declare function defaultLayoutGrid(pattern: LayoutGridPattern): LayoutGrid;
+/**
+ * Track extents of a column or row grid along its axis inside a box of the given length.
+ * Stretch divides the room left by the margins; the other alignments lay fixed-size tracks
+ * from the leading edge, the trailing edge, or the center. Tracks that do not fit are dropped
+ * rather than drawn outside the box.
+ */
+export declare function layoutGridTracks(grid: LayoutGridTracks, length: number): LayoutGridTrack[];
+/** Column tracks run along x, row tracks along y; a pixel grid has no tracks (it is drawn as a lattice). */
+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[];
+/** 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;

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

@@ -0,0 +1,35 @@
+import type { DesignDocument, DocumentMatrix, DocumentNode, DocumentTransaction } from '../../document/contracts.js';
+import { type AssetStore } from '../../document/assets.js';
+export declare const DESIGN_CLIPBOARD_FORMAT = "pygmalion/design-clipboard";
+export declare const DESIGN_INTERCHANGE_FORMAT = "pygmalion/design-document";
+export interface DesignClipboard {
+    format: typeof DESIGN_CLIPBOARD_FORMAT;
+    version: 1;
+    sourceDocumentId: string;
+    roots: string[];
+    nodes: DocumentNode[];
+    definitions: DocumentNode[];
+    assets: AssetStore;
+    worldTransforms: Record<string, DocumentMatrix>;
+}
+/** Copies owned subtrees and the transitive component definitions they reference. */
+export declare function copyDesignSubtrees(document: DesignDocument, selection: readonly string[]): DesignClipboard;
+export declare function serializeDesignClipboard(payload: DesignClipboard): string;
+export declare function parseDesignClipboard(serialized: string): DesignClipboard;
+export interface PasteDesignResult {
+    document: DesignDocument;
+    roots: string[];
+    nodeIds: Record<string, string>;
+}
+/** Pure paste plan; commit the returned same-identity snapshot as one undoable transaction. */
+export declare function pasteDesignSubtrees(target: DesignDocument, payload: DesignClipboard, options: {
+    parentId: string;
+    allocateId: (sourceId: string) => string;
+    offset?: {
+        x: number;
+        y: number;
+    };
+}): PasteDesignResult;
+export declare function applyDesignPaste(transaction: Pick<DocumentTransaction, 'replaceDocument'>, plan: PasteDesignResult): void;
+export declare function exportDesignInterchange(document: DesignDocument): string;
+export declare function importDesignInterchange(text: string): DesignDocument;

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

@@ -0,0 +1,2 @@
+import type { DesignDocument, DocumentDuplicateMetadataRemapper } from '../../document/contracts.js';
+export declare function designDuplicateMetadata(document: DesignDocument, host?: DocumentDuplicateMetadataRemapper): DocumentDuplicateMetadataRemapper | undefined;