@pygmalionjs/pygmalion 0.17.0 → 0.19.0

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

@@ -0,0 +1,77 @@
+import type { TextFontFaceRequest, TextResizeMode } from './richText.js';
+export interface TextLayoutAddress {
+    readonly sourceNodeId: string;
+    readonly instancePath: readonly string[];
+    readonly rowPath: readonly {
+        readonly repeatId: string;
+        readonly key: string | number;
+    }[];
+}
+export interface TextLayoutRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** Captured effective input, not a replacement canonical node or a saved document sidecar. */
+export interface TextLayoutPlan {
+    readonly documentId: string;
+    readonly sourceRevision: string;
+    readonly revisionKey: string;
+    readonly address: TextLayoutAddress;
+    readonly authoredBounds: TextLayoutRect;
+    readonly mode: TextResizeMode;
+    readonly text: string;
+    readonly font: Omit<TextFontFaceRequest, 'sample'>;
+    readonly fontSize: number;
+    readonly lineHeight: number;
+    readonly align: 'start' | 'center' | 'end';
+}
+export interface TextLayoutFace {
+    readonly environmentId: string;
+    readonly faceId: string;
+    readonly family: string;
+    readonly weight: number;
+    readonly style: 'normal' | 'italic';
+    readonly sample: string;
+}
+export interface TextLayoutRange {
+    /** UTF-16 offsets into the complete plain string; boundaries follow native grapheme segmentation. */
+    readonly start: number;
+    readonly end: number;
+    readonly line: number;
+    readonly rects: readonly TextLayoutRect[];
+}
+export interface TextLayoutLine {
+    readonly paragraph: number;
+    readonly start: number;
+    readonly end: number;
+    readonly box: TextLayoutRect;
+    readonly baseline: number;
+    readonly fragments: readonly TextLayoutRect[];
+}
+export interface TextLayoutGeometry {
+    /** Native advance/line extents, not glyph ink bounds or ancestor-clipped output extents. */
+    readonly effectiveBounds: TextLayoutRect;
+    readonly contentBounds: TextLayoutRect;
+    readonly lines: readonly TextLayoutLine[];
+    readonly ranges: readonly TextLayoutRange[];
+}
+/** All geometry is local CSS pixels. Apply the existing scene transform and ancestor clip at consumption. */
+export interface TextLayoutSnapshot extends TextLayoutGeometry {
+    readonly inputKey: string;
+    readonly plan: TextLayoutPlan;
+    readonly environmentId: string;
+    readonly faces: readonly TextLayoutFace[];
+}
+export declare const TEXT_LAYOUT_MAX_UNITS = 32768;
+export declare const TEXT_LAYOUT_MAX_RANGES = 8192;
+export declare const TEXT_LAYOUT_MAX_LINES = 2048;
+/** This initial LTR contract conservatively excludes bidi controls and RTL script blocks. */
+export declare const textLayoutNeedsBidi: (text: string) => boolean;
+/** Only immutable data is accepted; DOM objects and mutable resolver state never enter a snapshot. */
+export declare function freezeTextLayout<T>(value: T): T;
+export declare function captureTextLayoutPlan(value: TextLayoutPlan): TextLayoutPlan;
+export declare const textLayoutInputKey: (plan: TextLayoutPlan) => string;
+/** Empty paragraphs explicitly prepare the same face's space metric for their native strut. */
+export declare function textLayoutFontRequests(plan: TextLayoutPlan): readonly TextFontFaceRequest[];

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

@@ -427,7 +427,17 @@ export { assetInteropSourceDeltaDiagnostics, ASSETS_METADATA_KEY, ASSET_STORE_VE
 export type { DocumentAsset, ImageAsset, SvgAsset, AssetStore, ImageAssetInput, SvgAssetInput, AssetFileLike, InventoryAssetMedia, InventoryAssetEntry } from './document/assets.js';
 export * from './document/svgImport.js';
 export * from './document/exportSettings.js';
-export * from './workspace/edit/clipboard.js';
+export { DESIGN_CLIPBOARD_FORMAT, DESIGN_INTERCHANGE_FORMAT, copyDesignSubtrees, serializeDesignClipboard, parseDesignClipboard, pasteDesignSubtrees, applyDesignPaste, exportDesignInterchange, importDesignInterchange } from './workspace/edit/clipboard.js';
+export type { DesignClipboard, PasteDesignResult } from './workspace/edit/clipboard.js';
+export * from './workspace/edit/clipboardTransfer.js';
+export * from './workspace/edit/clipboardStyles.js';
+export * from './workspace/edit/clipboardPrototype.js';
+export { createTextLayoutPlan } from './workspace/edit/textLayoutPlan.js';
+export type { TextLayoutPlanOptions } from './workspace/edit/textLayoutPlan.js';
+export { createTextLayoutRuntime } from './workspace/edit/textLayoutRuntime.js';
+export type { TextLayoutRuntime } from './workspace/edit/textLayoutRuntime.js';
+export type { TextLayoutAddress, TextLayoutRect, TextLayoutPlan, TextLayoutFace, TextLayoutRange, TextLayoutLine, TextLayoutGeometry, TextLayoutSnapshot } from './document/textLayout.js';
+export type { PreparedTextFaceReference, PreparedTextFaceResolver } from './workspace/edit/preparedTextFace.js';
 export { AssetsPanel } from './workspace/edit/AssetsPanel.js';
 export type { AssetsPanelProps } from './workspace/edit/AssetsPanel.js';
 export * from './document/prototype.js';

package/dist-lib/types/token-library/bindings.d.ts

@@ -8,6 +8,43 @@ export interface VariableBinding {
 }
 export type VariableBindings = Record<string, VariableBinding>;
 export type VariableValueCodec = (library: TokenLibraryDocument, resolved: TokenValueResolution) => VariableScalar;
+export type VariableModeProvider = {
+    kind: 'binding';
+} | {
+    kind: 'node';
+    nodeId: string;
+} | {
+    kind: 'instance';
+    instanceId: string;
+    overrideAddress: string;
+} | {
+    kind: 'default';
+};
+export interface VariableModeResolution {
+    collectionId: string;
+    /** The requested mode, even when an alias is authored in a fallback mode. */
+    modeId: string;
+    provider: VariableModeProvider;
+    visitedNodeIds: readonly string[];
+}
+export interface VariableInstanceAddress {
+    instanceId: string;
+    overrideAddress: string;
+}
+export type VariableOccurrenceAddress = {
+    nodeId: string;
+} | VariableInstanceAddress;
+export interface VariableOccurrencePlan {
+    address: VariableOccurrenceAddress;
+    property: VariableTarget;
+    binding: VariableBinding;
+    mode: VariableModeResolution;
+    resolved: TokenValueResolution;
+    value: VariableScalar;
+    before: DocumentValue | undefined;
+    /** Literal projection only. Binding identity and transaction ownership stay with the caller. */
+    patch: DocumentNodePatch;
+}
 export interface VariableChange {
     nodeId: string;
     overrideAddress?: string;
@@ -50,8 +87,15 @@ export declare function isVariableBinding(value: unknown): value is VariableBind
 export declare function nodeVariableBindings(node: Pick<DocumentNode, 'properties'>): VariableBindings;
 /** Built-in values are JSON scalars. Other syntax remains the host codec's responsibility. */
 export declare function resolveScalarVariable(library: TokenLibraryDocument, resolved: TokenValueResolution, seen?: Set<string>): VariableScalar;
+export declare function resolveVariableModeForNode(document: DesignDocument, nodeId: string, library: TokenLibraryDocument, tokenId: string, explicit?: string): VariableModeResolution;
 export declare function variableModeForNode(document: DesignDocument, nodeId: string, library: TokenLibraryDocument, tokenId: string, explicit?: string): string;
+/** Resolves an opaque override address through the actual component resolver. */
+export declare function resolveVariableModeForInstance(document: DesignDocument, address: VariableInstanceAddress, library: TokenLibraryDocument, binding: VariableBinding): VariableModeResolution;
 export declare function variableTargetsForNode(node: DocumentNode): VariableTarget[];
+/** Override projection stays sparse; unrelated inherited properties never become local overrides. */
+export declare function projectVariableScalar(node: DocumentNode, property: VariableTarget, value: VariableScalar, placement: 'own' | 'override'): DocumentNodePatch;
+/** Reads one occurrence without refreshing unrelated nodes or changing either document. */
+export declare function planVariableOccurrence(document: DesignDocument, address: VariableOccurrenceAddress, property: VariableTarget, library: TokenLibraryDocument, codec?: VariableValueCodec): VariableOccurrencePlan;
 export declare function bindVariablePatch(document: DesignDocument, nodeId: string, property: VariableTarget, library: TokenLibraryDocument, binding: VariableBinding, codec?: VariableValueCodec): DocumentNodePatch;
 export declare function detachVariablePatch(node: DocumentNode, property: VariableTarget): DocumentNodePatch;
 /** A refresh plan records all affected nodes before the caller commits one history entry. */

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

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

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

@@ -1,13 +1,17 @@
 import type { DataProjection } from '../../binding/preview.js';
 import type { WorkspaceCamera } from '../contracts.js';
+import { type ProjectedDocumentNode } from './projection.js';
 import type { DesignDocument, DocumentNode, DocumentTransaction } from '../../document/contracts.js';
 
 type Act = (label: string, apply: (transaction: DocumentTransaction) => void) => unknown;
 /** 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 }: {
+export declare function CanvasGuides({ document, selected, projection, scene, geometryKey, isGeometryCurrent, camera, zoom: suppliedZoom, act, width, height, visibleRootIds }: {
     document: DesignDocument;
     selected?: readonly string[];
     projection?: DataProjection | null;
+    scene?: ProjectedDocumentNode;
+    geometryKey?: string;
+    isGeometryCurrent?: () => boolean;
     camera?: WorkspaceCamera;
     zoom?: number;
     act: Act;

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

@@ -0,0 +1,21 @@
+import type { DesignDocument } from '../../document/contracts.js';
+import type { DesignClipboardRelationshipMaps, DesignClipboardWithRelationships } from './clipboardTransfer.js';
+import type { ClipboardPrototypeFlowPolicy } from './clipboardPrototype.js';
+
+export interface ClipboardRelationshipChoice {
+    relationships: DesignClipboardRelationshipMaps;
+    flowPolicy: ClipboardPrototypeFlowPolicy;
+}
+export interface ClipboardRelationshipDialogProps {
+    document: DesignDocument;
+    payload: DesignClipboardWithRelationships;
+    error?: string;
+    disabled?: boolean;
+    onChoiceChange?(): void;
+    onConfirm(choice: ClipboardRelationshipChoice): void;
+    onCancel(): void;
+}
+/** Internal default for validated pastes that need no naming or destination decision. */
+export declare function defaultClipboardRelationshipChoice(document: DesignDocument, payload: DesignClipboardWithRelationships): ClipboardRelationshipChoice;
+/** Collects explicit relationship decisions. Only the caller may validate and commit a paste. */
+export declare function ClipboardRelationshipDialog(props: ClipboardRelationshipDialogProps): import("react").JSX.Element | null;

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

@@ -1,3 +1,4 @@
+import type { ProjectedDocumentNode } from './projection.js';
 import type { DataProjection } from '../../binding/preview.js';
 import type { DesignDocument, DocumentTransaction } from '../../document/contracts.js';
 import { type PrototypeConnectionSelection } from './prototypeWiringModel.js';
@@ -8,6 +9,9 @@ export interface PrototypeWiringProps {
     selected: readonly string[];
     projection: DataProjection | null;
     zoom: number;
+    scene?: ProjectedDocumentNode;
+    geometryKey?: string;
+    isGeometryCurrent?: () => boolean;
     visibleRootIds?: readonly string[];
     selectedConnection: PrototypeConnectionSelection | null;
     onSelectConnection(value: PrototypeConnectionSelection | null): void;

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

@@ -1,5 +1,6 @@
 import type { DataProjection } from '../../binding/preview.js';
 import type { DesignDocument, DocumentTransaction } from '../../document/contracts.js';
+import type { ProjectedDocumentNode } from './projection.js';
 import { type LayerPlacement, type SnapGuide } from './geometryHandles.js';
 
 type Act = (label: string, apply: (transaction: DocumentTransaction) => void) => boolean;
@@ -11,6 +12,11 @@ export interface SelectionHandlesProps {
     selected: readonly string[];
     visibleRootIds?: readonly string[];
     projection: DataProjection | null;
+    scene?: ProjectedDocumentNode;
+    /** Measurement/provider lifetime, including changes that return to the same screen. */
+    geometryKey?: string;
+    /** Synchronous owner check, captured at gesture start and checked before committing. */
+    isGeometryCurrent?: () => boolean;
     /** Canvas scale; handles keep a constant screen size and snapping a constant screen tolerance. */
     zoom: number;
     act: Act;
@@ -41,15 +47,17 @@ export declare const SELECTION_BOX_ID = "selection";
  * mirroring layer arrangement. The dimension badge follows the live world bounds without
  * applying its own document changes.
  */
-export declare function SelectionHandles({ document, selected, visibleRootIds, projection, zoom, act, movePreview, movePreviews, onPreview, onPreviewMany }: SelectionHandlesProps): import("react").JSX.Element;
+export declare function SelectionHandles({ document, selected, visibleRootIds, projection, scene, geometryKey, isGeometryCurrent, 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, compact }: {
+export declare function LayerGeometryInspector({ document, selected, projection, scene, isGeometryCurrent, act, compact }: {
     document: DesignDocument;
     selected: readonly string[];
     projection: DataProjection | null;
+    scene?: ProjectedDocumentNode;
+    isGeometryCurrent?: () => boolean;
     act: Act;
     compact?: boolean;
 }): import("react").JSX.Element | null;

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

@@ -3,6 +3,7 @@ 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';
+import type { ProjectedDocumentNode } from './projection.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. */
@@ -13,6 +14,12 @@ export interface VectorGeometryPreview {
 export interface VectorEditingSession {
     readonly document: DesignDocument;
     readonly projection: DataProjection | null;
+    /** The same disposable measured scene rendered by the canvas. */
+    readonly scene?: ProjectedDocumentNode;
+    readonly geometryKey?: string;
+    /** Captured at gesture start and checked again before any document command. */
+    readonly isGeometryCurrent?: () => boolean;
+    readonly visibleRootIds?: readonly string[];
     readonly selection: readonly string[];
     readonly tool: VectorTool;
     setTool(tool: VectorTool): void;
@@ -42,6 +49,10 @@ export interface VectorEditingInput {
     document: DesignDocument;
     selection: readonly string[];
     projection: DataProjection | null;
+    scene?: ProjectedDocumentNode;
+    geometryKey?: string;
+    isGeometryCurrent?: () => boolean;
+    visibleRootIds?: readonly string[];
     act: Act;
     select(id: string): void;
 }
@@ -67,7 +78,7 @@ export declare function VectorNodeSurface({ node, width, height, vector }: {
  * 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;
+export declare function useVectorEditing({ document, selection, projection, scene, geometryKey, isGeometryCurrent, visibleRootIds, 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

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

@@ -15,6 +15,7 @@ export interface DesignClipboard {
 /** 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 designClipboardDocument(payload: DesignClipboard): DesignDocument;
 export declare function parseDesignClipboard(serialized: string): DesignClipboard;
 export interface PasteDesignResult {
     document: DesignDocument;

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

@@ -0,0 +1,9 @@
+import type { DesignDocument, DocumentNode } from '../../document/contracts.js';
+export interface ClipboardGraph {
+    roots: string[];
+    nodes: DocumentNode[];
+    definitions: DocumentNode[];
+    includedNodeIds: string[];
+}
+/** Shared structural closure for a validated source; relationship planners use these exact IDs. */
+export declare function collectClipboardGraph(document: DesignDocument, selection: readonly string[]): ClipboardGraph;

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

@@ -0,0 +1,55 @@
+import type { DesignDocument } from '../../document/contracts.js';
+import { type PrototypeDocument, type PrototypeFlow, type PrototypeInteraction, type PrototypeVariable } from '../../document/prototype.js';
+export type ClipboardPrototypeFlowPolicy = 'selected-starts' | 'none';
+export type ClipboardPrototypeDestinationKind = 'navigate' | 'change-to' | 'open-overlay' | 'swap-overlay' | 'scroll-to';
+export interface ClipboardPrototypeOwner {
+    readonly nodeId: string;
+    readonly targetNodeId: string;
+    /** Opaque source address; structural clipboard code remaps it through the component graph. */
+    readonly overrideAddress?: string;
+    readonly interactions: readonly PrototypeInteraction[];
+}
+export interface ClipboardPrototypeData {
+    readonly version: 1;
+    readonly includedNodeIds: readonly string[];
+    readonly copiedRoots: readonly string[];
+    readonly flowPolicy: ClipboardPrototypeFlowPolicy;
+    readonly owners: readonly ClipboardPrototypeOwner[];
+    readonly variables: readonly PrototypeVariable[];
+    readonly flows: readonly PrototypeFlow[];
+    readonly externalNodes: readonly {
+        readonly nodeId: string;
+        readonly kinds: readonly ClipboardPrototypeDestinationKind[];
+    }[];
+}
+export interface ClipboardPrototypeMaps {
+    readonly nodeIds: Readonly<Record<string, string>>;
+    readonly externalNodeIds: Readonly<Record<string, string>>;
+    readonly variableIds: Readonly<Record<string, string>>;
+    readonly flowIds: Readonly<Record<string, string>>;
+    readonly variableNames?: Readonly<Record<string, string>>;
+}
+export interface ClipboardPrototypeTransferPlan {
+    readonly prototype: PrototypeDocument;
+    readonly owners: readonly {
+        readonly sourceNodeId: string;
+        readonly sourceOverrideAddress?: string;
+        readonly nodeId: string;
+        readonly targetNodeId: string;
+        readonly interactions: readonly PrototypeInteraction[];
+    }[];
+    readonly nodeIds: Readonly<Record<string, string>>;
+    readonly externalNodeIds: Readonly<Record<string, string>>;
+    readonly variableIds: Readonly<Record<string, string>>;
+    readonly flowIds: Readonly<Record<string, string>>;
+    /** Source-wide presentation settings are intentionally not imported with a selection. */
+    readonly settingsPolicy: 'preserve-target';
+}
+/** The root collector supplies the exact structural/definition closure; this helper never adds nodes. */
+export declare function collectClipboardPrototype(sourceInput: DesignDocument, includedNodeIdsInput: readonly string[], copiedRootsInput: readonly string[], options: {
+    flowPolicy: ClipboardPrototypeFlowPolicy;
+}): ClipboardPrototypeData;
+/** Validates untrusted serialized relationships without consulting or changing a document. */
+export declare function validateClipboardPrototypeClosure(input: unknown): ClipboardPrototypeData;
+/** Pure relationship plan for an already allocated structural candidate; callers commit atomically. */
+export declare function planClipboardPrototypeTransfer(dataInput: ClipboardPrototypeData, targetInput: DesignDocument, mapsInput: ClipboardPrototypeMaps): ClipboardPrototypeTransferPlan;

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

@@ -0,0 +1,46 @@
+import type { DesignDocument, DocumentDiagnostic } from '../../document/contracts.js';
+import { type StylesMetadata, type StyleSlot } from '../../document/styles.js';
+import { type AssetStore } from '../../document/assets.js';
+export interface ClipboardStyleReference {
+    nodeId: string;
+    overrideAddress?: string;
+    slot: StyleSlot;
+    styleId: string;
+}
+/** Only the style-owned closure. Graph selection and other sidecar guards belong to the clipboard coordinator. */
+export interface ClipboardStyleClosure {
+    sourceDocumentId: string;
+    includedNodeIds: string[];
+    styleReferences: ClipboardStyleReference[];
+    metadata: StylesMetadata;
+    assets: AssetStore;
+}
+export interface ClipboardStyleOptions {
+    /** Complete source-style to destination-style mapping; no identity or name guessing. */
+    styleIds: Readonly<Record<string, string>>;
+    /** When present, declares the destination name for every source style. */
+    names?: Readonly<Record<string, string>>;
+    /** Source style IDs explicitly authorized to reuse an identical destination style. */
+    reuse?: readonly string[];
+}
+export interface ClipboardStyleDiagnostic extends DocumentDiagnostic {
+    styleId?: string;
+    targetStyleId?: string;
+    libraryId?: string;
+}
+export type ClipboardStylePlan = {
+    ok: true;
+    metadata: StylesMetadata;
+    assets: AssetStore;
+    styleIds: Record<string, string>;
+    targetFingerprint: string;
+} | {
+    ok: false;
+    diagnostics: ClipboardStyleDiagnostic[];
+};
+/** Reads own properties and every declared opaque override address, including inactive component overrides. */
+export declare function collectClipboardStyles(sourceInput: DesignDocument, includedNodeIdsInput: readonly string[]): ClipboardStyleClosure;
+/** Validates serialized style-owned data; the coordinator additionally compares the references with its node payload. */
+export declare function validateClipboardStylesClosure(input: unknown): ClipboardStyleDiagnostic[];
+/** Pure merge plan. Existing target styles and consumers are never updated by a clipboard operation. */
+export declare function planClipboardStyles(targetInput: DesignDocument, closureInput: ClipboardStyleClosure, optionsInput: ClipboardStyleOptions): ClipboardStylePlan;

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

@@ -0,0 +1,38 @@
+import type { DesignDocument, DocumentTransaction } from '../../document/contracts.js';
+import { pasteDesignSubtrees, type DesignClipboard, type PasteDesignResult } from './clipboard.js';
+import { type ClipboardStyleClosure, type ClipboardStyleOptions } from './clipboardStyles.js';
+import { type ClipboardPrototypeData, type ClipboardPrototypeFlowPolicy, type ClipboardPrototypeMaps } from './clipboardPrototype.js';
+export interface DesignClipboardWithRelationships extends Omit<DesignClipboard, 'version'> {
+    version: 2;
+    relationships: {
+        styles: ClipboardStyleClosure;
+        prototype: ClipboardPrototypeData;
+    };
+}
+export type DesignTransferClipboard = DesignClipboard | DesignClipboardWithRelationships;
+export interface DesignClipboardRelationshipMaps {
+    styles: ClipboardStyleOptions;
+    prototype: Omit<ClipboardPrototypeMaps, 'nodeIds'>;
+}
+export interface DesignTransferPasteResult extends PasteDesignResult {
+    targetFingerprint: string;
+    styleIds: Readonly<Record<string, string>>;
+    variableIds: Readonly<Record<string, string>>;
+    flowIds: Readonly<Record<string, string>>;
+    externalNodeIds: Readonly<Record<string, string>>;
+    settingsPolicy: 'preserve-target';
+}
+/** Opt-in owned relationship transfer. Legacy copy retains its existing refusal boundary. */
+export declare function copyDesignSubtreesWithRelationships(documentInput: DesignDocument, selectionInput: readonly string[], options: {
+    flowPolicy: ClipboardPrototypeFlowPolicy;
+}): DesignTransferClipboard;
+export declare function serializeDesignClipboardWithRelationships(payload: DesignTransferClipboard): string;
+export declare function parseDesignClipboardWithRelationships(text: string): DesignTransferClipboard;
+/** A reviewed paste may explicitly omit copied flow starts; absent source flows cannot be inferred. */
+export declare function withDesignClipboardFlowPolicy(payload: DesignClipboardWithRelationships, flowPolicy: ClipboardPrototypeFlowPolicy): DesignClipboardWithRelationships;
+/** Captures every caller input before allocation and returns one complete document transaction. */
+export declare function pasteDesignSubtreesWithRelationships(targetInput: DesignDocument, payloadInput: DesignTransferClipboard, options: Parameters<typeof pasteDesignSubtrees>[2] & {
+    relationships?: DesignClipboardRelationshipMaps;
+}): DesignTransferPasteResult;
+/** New relationship plans must be applied against the exact target that was reviewed. */
+export declare function applyDesignTransferPaste(transaction: Pick<DocumentTransaction, 'replaceDocument'>, current: DesignDocument, plan: DesignTransferPasteResult): void;

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

@@ -1,6 +1,7 @@
 import type { DataProjection } from '../../binding/preview.js';
 import type { DesignDocument, DocumentNode } from '../../document/contracts.js';
 import { type VectorShape } from '../../document/vector.js';
+import { type ProjectedDocumentNode } from './projection.js';
 export interface CanvasBox {
     x: number;
     y: number;
@@ -13,7 +14,11 @@ export interface CanvasEntry {
     topLevel: boolean;
 }
 export type DrawingTool = 'frame' | 'text' | VectorShape;
-export declare function canvasEntries(document: DesignDocument, projection: DataProjection | null, selected?: readonly string[], visibleRootIds?: readonly string[]): CanvasEntry[];
+/** A selected definition descendant keeps its shared root visible without exposing inactive pages. */
+export declare function selectedSharedRootIds(document: DesignDocument, selected: readonly string[]): readonly string[];
+export declare function canvasEntries(document: DesignDocument, projection: DataProjection | null, selected?: readonly string[], visibleRootIds?: readonly string[], scene?: ProjectedDocumentNode): CanvasEntry[];
+/** A mixed unavailable/preparing scene must not finalize a fit using partial bounds. */
+export declare function canvasGeometryReady(scene: ProjectedDocumentNode): boolean;
 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

@@ -1,6 +1,7 @@
 import type { DataProjection } from '../../binding/preview.js';
 import type { DesignDocument, DocumentDiagnostic, DocumentMatrix, DocumentNodeConstraints, DocumentTransaction } from '../../document/contracts.js';
 import { documentTransformedBounds } from '../../document/geometry.js';
+import { type ProjectedDocumentNode } from './projection.js';
 /**
  * Pure geometry for the selection handles: which layers may be edited on the
  * canvas, how a handle drag becomes a new size and placement, how a rotation
@@ -36,6 +37,15 @@ export interface LayerGeometry extends LayerPlacement {
         readonly width: boolean;
         readonly height: boolean;
     };
+    /** Canonical sizes are retained even when the disposable scene derives an axis. */
+    readonly authoredSize?: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly derivedAxes?: {
+        readonly width: boolean;
+        readonly height: boolean;
+    };
     readonly notes: readonly DocumentDiagnostic[];
     readonly constraints: DocumentNodeConstraints | undefined;
     /** Constraints only act inside a free-placement container that can itself be resized. */
@@ -95,6 +105,8 @@ export interface SnapResult {
     readonly guides: readonly SnapGuide[];
 }
 export interface SnapCandidateOptions {
+    /** The same disposable final scene used by the canvas, including measured text. */
+    readonly scene?: ProjectedDocumentNode;
     /** 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). */
@@ -226,6 +238,6 @@ export declare function snapMove(session: MoveSnapSession, delta: {
  * uses `resize` so child constraints apply, a placement change uses `move`, and a rotation
  * replaces the transform. Nothing is issued when the placement is unchanged.
  */
-export declare function applyLayerPlacement(transaction: DocumentTransaction, nodeId: string, before: LayerPlacement, after: LayerPlacement): boolean;
+export declare function applyLayerPlacement(transaction: DocumentTransaction, nodeId: string, before: LayerPlacement & Pick<LayerGeometry, 'authoredSize' | 'derivedAxes' | 'resizeAxes'>, after: LayerPlacement): boolean;
 /** Commit every member of a selection gesture in the caller's transaction; true when any layer changed. */
 export declare function applySelectionPlacements(transaction: DocumentTransaction, layers: readonly LayerGeometry[], placements: readonly SelectionPlacement[]): boolean;

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

@@ -1,5 +1,6 @@
 import type { DataProjection } from '../../binding/preview.js';
 import type { DesignDocument, DocumentDiagnostic, DocumentEngineOptions, DocumentTransaction } from '../../document/contracts.js';
+import { type ProjectedDocumentNode } from './projection.js';
 export type DocumentLayerArrangement = 'align-left' | 'align-center-x' | 'align-right' | 'align-top' | 'align-center-y' | 'align-bottom' | 'distribute-horizontal' | 'distribute-vertical';
 export interface DocumentLayerArrangementRequest {
     nodeIds: readonly string[];
@@ -7,6 +8,8 @@ export interface DocumentLayerArrangementRequest {
 }
 export interface DocumentLayerArrangementOptions extends Pick<DocumentEngineOptions, 'preflight'> {
     projection?: DataProjection | null;
+    scene?: ProjectedDocumentNode;
+    visibleRootIds?: readonly string[];
 }
 export interface ReadyDocumentLayerArrangement {
     readonly status: 'ready';
@@ -36,4 +39,4 @@ export type DocumentLayerArrangementPlan = ReadyDocumentLayerArrangement | {
  */
 export declare function planDocumentLayerArrangement(document: DesignDocument, request: DocumentLayerArrangementRequest, options?: DocumentLayerArrangementOptions): DocumentLayerArrangementPlan;
 /** Run as the only move batch in one live transaction; let validation errors roll it back. */
-export declare function applyDocumentLayerArrangement(transaction: DocumentTransaction, plan: ReadyDocumentLayerArrangement, currentDocument: DesignDocument, projection?: DataProjection | null): void;
+export declare function applyDocumentLayerArrangement(transaction: DocumentTransaction, plan: ReadyDocumentLayerArrangement, currentDocument: DesignDocument, projection?: DataProjection | null, scene?: ProjectedDocumentNode): void;

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

@@ -0,0 +1,31 @@
+import type { TextFontFaceRequest } from '../../document/richText.js';
+import type { TextFontPreparationRuntime } from './textFontRuntime.js';
+export interface PreparedTextFaceReference {
+    readonly environmentId: string;
+    readonly faceId: string;
+    readonly family: string;
+    readonly weight: number;
+    readonly style: 'normal' | 'italic';
+    readonly sample: string;
+}
+/** The owner maps its exact prepared identity to the same FontFace object registered for drawing. */
+export type PreparedTextFaceResolver = (reference: PreparedTextFaceReference) => FontFace | undefined;
+/** Registered face descriptors must support the requested style and weight without synthesis. */
+export declare function supportsPreparedTextFace(face: Pick<FontFace, 'family' | 'style' | 'weight' | 'stretch' | 'status'>, family: string, request: TextFontFaceRequest): boolean;
+/** Registered unicode-range restrictions are distinct from the provider's glyph-coverage attestation. */
+export declare function preparedTextFaceCoversSample(unicodeRange: string, sample: string): boolean;
+export interface PreparedBrowserTextFace {
+    readonly reference: PreparedTextFaceReference;
+    readonly face: FontFace;
+    readonly descriptor: string;
+    readonly owner: Document;
+}
+/** Revalidates the current browser registration even when preparation was served from a cache. */
+export declare function prepareBrowserTextFace(font: TextFontFaceRequest, fontSize: number, runtime: TextFontPreparationRuntime, options: {
+    nodeId: string;
+    signal?: AbortSignal;
+    retry?: boolean;
+    ownerDocument?: Document;
+    resolvePreparedFace?: PreparedTextFaceResolver;
+    diagnosticPrefix?: string;
+}): Promise<PreparedBrowserTextFace>;

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

@@ -1,6 +1,7 @@
 import type { BindingRuntimeScope } from '../../binding/contracts.js';
 import type { DataProjection } from '../../binding/preview.js';
-import type { DesignDocument, DocumentNode, DocumentResolveOptions } from '../../document/contracts.js';
+import type { DesignDocument, DocumentDiagnostic, DocumentNode, DocumentResolveOptions } from '../../document/contracts.js';
+import type { TextLayoutSnapshot } from '../../document/textLayout.js';
 export interface ProjectedDocumentNode {
     sourceNodeId: string;
     instanceId?: string;
@@ -9,6 +10,27 @@ export interface ProjectedDocumentNode {
     rowPath: BindingRuntimeScope['rowPath'];
     node: DocumentNode;
     children: ProjectedDocumentNode[];
+    /** Disposable measured geometry; never serialized into the authored document. */
+    textLayout?: ProjectedTextLayout;
 }
+export interface ProjectedTextLayout {
+    readonly status: 'preparing' | 'ready' | 'unavailable' | 'failed';
+    readonly authoredSize: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly derivedAxes: {
+        readonly width: boolean;
+        readonly height: boolean;
+    };
+    readonly diagnostics: readonly DocumentDiagnostic[];
+    readonly snapshot?: TextLayoutSnapshot;
+    /** Parent bounds may be fixed while unresolved layout changes its child placements. */
+    readonly childrenPending?: boolean;
+}
+/** Fixed parent bounds remain usable; only derived size or unresolved ancestor placement is refused. */
+export declare function projectedGeometryDiagnostics(item: ProjectedDocumentNode, ancestors?: readonly ProjectedDocumentNode[]): readonly DocumentDiagnostic[];
+/** Reuses the canonical layout solver on a disposable scene, including repeated index addresses. */
+export declare function reflowProjectedDocumentScene(scene: ProjectedDocumentNode): ProjectedDocumentNode;
 /** Fixture rows affect this disposable scene only, never canonical document geometry. */
 export declare function projectDocumentScene(document: DesignDocument, data: DataProjection | null, resolveOptions?: DocumentResolveOptions, resolveRowOptions?: (rowPath: BindingRuntimeScope['rowPath']) => DocumentResolveOptions): ProjectedDocumentNode;