@pygmalionjs/pygmalion 0.16.0 → 0.18.0

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

@@ -34,6 +34,7 @@ export interface RasterExportRequest {
     height: number;
     scale: number;
     contentsOnly: boolean;
+    signal?: AbortSignal;
 }
 export type RasterExportRenderer = (request: RasterExportRequest) => Promise<Uint8Array>;
 export interface DesignExportArtifact {
@@ -42,4 +43,6 @@ export interface DesignExportArtifact {
     bytes: Uint8Array;
 }
 /** Raster bytes come only from an explicit host renderer; no hidden capture or network access. */
-export declare function exportDesignNode(document: DesignDocument, nodeId: string, setting: ExportSetting, renderer?: RasterExportRenderer): Promise<DesignExportArtifact>;
+export declare function exportDesignNode(document: DesignDocument, nodeId: string, setting: ExportSetting, renderer?: RasterExportRenderer, options?: {
+    signal?: AbortSignal;
+}): Promise<DesignExportArtifact>;

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';
@@ -445,4 +455,5 @@ export type { PrototypeInputFrame } from './workspace/view/prototypeInputFrame.j
 export { createPrototypeProjectionContext } from './workspace/edit/prototypeProjection.js';
 export type { PrototypeProjectionContext } from './workspace/edit/prototypeProjection.js';
 export * from './workspace/edit/rasterExport.js';
+export type { PreparedTextRasterFaceReference, TextRasterFaceResolver } from './workspace/edit/staticTextRaster.js';
 export * from './document/imagePaintGeometry.js';

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

@@ -5,6 +5,7 @@ import type { WorkspaceSourceCapabilities } from './source/flowContracts.js';
 import type { WorkspaceTarget } from './contracts.js';
 import type { WorkspaceTokenLibraryCapabilities } from './tokens/contracts.js';
 import type { TextFontPreparationRuntime } from './edit/textFontRuntime.js';
+import type { TextRasterFaceResolver } from './edit/staticTextRaster.js';
 /** One target's source, data, rendering, and persistence capabilities travel together. */
 export interface WorkspaceTargetConfiguration {
     data?: HostDataCapabilities;
@@ -12,6 +13,8 @@ export interface WorkspaceTargetConfiguration {
     duplicateMetadata?: DocumentDuplicateMetadataRemapper;
     /** Explicit font face and sample preparation; browser fallback rendering is not exact readiness. */
     textFontPreparation?: TextFontPreparationRuntime;
+    /** Bind a prepared face identity to its exact registered browser FontFace for static text output. */
+    textRasterFaceResolver?: TextRasterFaceResolver;
     loadDocument?(target: WorkspaceTarget, options: {
         signal: AbortSignal;
     }): Promise<DesignDocument>;

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

@@ -10,8 +10,10 @@ export interface AssetsPanelProps {
     onSelect?: (nodeId: string) => void;
     onExport?: (artifact: DesignExportArtifact) => void | Promise<void>;
     rasterRenderer?: RasterExportRenderer;
+    lifetimeKey?: string;
+    subscribeLifetime?: (invalidate: () => void) => () => void;
     disabled?: boolean;
 }
-export declare function AssetsPanel({ engine, pageId, parentId, selectedNodeId, allocateId, onSelect, onExport, rasterRenderer, disabled }: AssetsPanelProps): import("react").JSX.Element;
+export declare function AssetsPanel({ engine, pageId, parentId, selectedNodeId, allocateId, onSelect, onExport, rasterRenderer, lifetimeKey, subscribeLifetime, 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/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/NodeExportPanel.d.ts

@@ -1,10 +1,12 @@
 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 }: {
+export declare function NodeExportPanel({ engine, nodeId, onExport, rasterRenderer, disabled, lifetimeKey, subscribeLifetime }: {
     engine: DocumentEngine;
     nodeId?: string;
     onExport?(artifact: DesignExportArtifact): void | Promise<void>;
     rasterRenderer?: RasterExportRenderer;
     disabled?: boolean;
+    lifetimeKey?: string;
+    subscribeLifetime?: (invalidate: () => void) => () => void;
 }): import("react").JSX.Element;

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

@@ -0,0 +1,6 @@
+import type { DesignDocument } from '../../document/contracts.js';
+
+/** Browse authored style metadata without selecting a layer or requesting fonts. */
+export declare function TextStyleCatalog({ document }: {
+    document: DesignDocument;
+}): import("react").JSX.Element;

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/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/rasterCanvas.d.ts

@@ -0,0 +1,6 @@
+import type { RasterExportRequest } from '../../document/exportSettings.js';
+export declare function assertRasterActive(signal?: AbortSignal): void;
+export declare function validateRasterSize(request: Pick<RasterExportRequest, 'width' | 'height'>): void;
+/** Cancellation ends this reader even if a browser decode or encode cannot be interrupted internally. */
+export declare function awaitRasterActive<T>(work: Promise<T>, signal?: AbortSignal): Promise<T>;
+export declare function encodeRasterCanvas(canvas: HTMLCanvasElement, format: RasterExportRequest['format'], signal?: AbortSignal): Promise<Uint8Array>;

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

@@ -1,5 +1,13 @@
+import { type TextRasterFaceResolver } from './staticTextRaster.js';
+import type { TextFontPreparationRuntime } from './textFontRuntime.js';
 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. */
+/** Adds bounded authored text output only when an explicit exact-face provider is available. */
+export declare function createDesignRasterRenderer(options?: {
+    textFontPreparation?: TextFontPreparationRuntime;
+    sourceMapped?: boolean;
+    resolvePreparedFace?: TextRasterFaceResolver;
+}): RasterExportRenderer;
+/** Backward-compatible geometry renderer. Exact text output is explicitly enabled through the factory. */
 export declare const renderDesignRaster: RasterExportRenderer;

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

@@ -0,0 +1,39 @@
+import { type RasterExportRequest } from '../../document/exportSettings.js';
+import { type TextFontFaceRequest } from '../../document/richText.js';
+import type { TextFontPreparationRuntime } from './textFontRuntime.js';
+import { type PreparedTextFaceResolver } from './preparedTextFace.js';
+export { supportsPreparedTextFace as supportsStaticTextFace, preparedTextFaceCoversSample as staticTextFaceCoversSample } from './preparedTextFace.js';
+export type { PreparedTextFaceReference as PreparedTextRasterFaceReference, PreparedTextFaceResolver as TextRasterFaceResolver } from './preparedTextFace.js';
+export interface StaticTextRasterPlan {
+    readonly nodeId: string;
+    readonly width: number;
+    readonly height: number;
+    readonly outputWidth: number;
+    readonly outputHeight: number;
+    readonly font: TextFontFaceRequest;
+    readonly fontSize: number;
+    readonly lineHeight: number;
+    readonly align: 'start' | 'center' | 'end';
+    readonly color: string;
+    readonly opacity: number;
+}
+/** The first text raster slice is a single authored, fixed-size, undecorated line with explicit typography. */
+export declare function createStaticTextRasterPlan(request: RasterExportRequest, options?: {
+    sourceMapped?: boolean;
+}): StaticTextRasterPlan;
+/** Matches the SVG renderer's default xMidYMid meet behavior after output dimension rounding. */
+export declare function staticTextRasterViewport(plan: Pick<StaticTextRasterPlan, 'width' | 'height' | 'outputWidth' | 'outputHeight'>): {
+    scale: number;
+    x: number;
+    y: number;
+};
+/** Measures the same pre-wrap line box as TextNodeSurface, using a zero-height inline baseline marker. */
+export declare function measureStaticTextRaster(plan: StaticTextRasterPlan, family: string, owner: Document): {
+    x: number;
+    baseline: number;
+};
+/** A ready explicit provider plus a registered browser face is required; platform fallback checks are insufficient. */
+export declare function renderStaticTextRaster(request: RasterExportRequest, runtime: TextFontPreparationRuntime, options?: {
+    sourceMapped?: boolean;
+    resolvePreparedFace?: PreparedTextFaceResolver;
+}): Promise<Uint8Array>;

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

@@ -0,0 +1,3 @@
+import { type TextLayoutGeometry, type TextLayoutPlan } from '../../document/textLayout.js';
+/** Reads a fully shaped native paragraph. No character is drawn or laid out independently. */
+export declare function measureBrowserTextLayout(plan: TextLayoutPlan, family: string, owner: Document, signal?: AbortSignal): TextLayoutGeometry;

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

@@ -0,0 +1,12 @@
+import type { DesignDocument } from '../../document/contracts.js';
+import { type TextLayoutAddress, type TextLayoutPlan } from '../../document/textLayout.js';
+import { type ProjectedDocumentNode } from './projection.js';
+export interface TextLayoutPlanOptions {
+    readonly revisionKey: string;
+    readonly address: TextLayoutAddress;
+    readonly scene?: ProjectedDocumentNode;
+    readonly visibleRootIds?: readonly string[];
+    readonly sourceMapped?: boolean;
+}
+/** Selects one visible effective occurrence without changing canonical geometry or rewriting IDs. */
+export declare function createTextLayoutPlan(document: DesignDocument, options: TextLayoutPlanOptions): TextLayoutPlan;

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

@@ -0,0 +1,20 @@
+import { type TextLayoutPlan, type TextLayoutSnapshot } from '../../document/textLayout.js';
+import { type PreparedTextFaceResolver } from './preparedTextFace.js';
+import type { TextFontPreparationRuntime } from './textFontRuntime.js';
+export interface TextLayoutRuntime {
+    readonly environmentId: string;
+    measure(plan: TextLayoutPlan, options?: {
+        signal?: AbortSignal;
+        retry?: boolean;
+    }): Promise<TextLayoutSnapshot>;
+    /** Invalidates this measurement cache; the injected font runtime keeps its own lifetime. */
+    clear(): void;
+    dispose(): void;
+}
+/** One runtime belongs to one browser font environment. Cached geometry still revalidates actual faces. */
+export declare function createTextLayoutRuntime(options: {
+    textFontPreparation: TextFontPreparationRuntime;
+    resolvePreparedFace?: PreparedTextFaceResolver;
+    ownerDocument?: Document;
+    maxEntries?: number;
+}): TextLayoutRuntime;

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

@@ -0,0 +1,19 @@
+import type { DocumentEngine } from '../../document/contracts.js';
+import { type DesignTransferPasteResult } from './clipboardTransfer.js';
+interface ClipboardPasteOptions {
+    engine: DocumentEngine;
+    parentId: string;
+    pageId?: string;
+    allocateId: (sourceId: string) => string;
+    onApply: (plan: DesignTransferPasteResult) => boolean;
+    onError: (message: string) => void;
+    lifetimeKey?: string;
+    subscribeLifetime?: (invalidate: () => void) => () => void;
+    disabled?: boolean;
+}
+/** The mapping dialog is a pending operation, never a partial document mutation. */
+export declare function useDesignClipboardPaste({ engine, parentId, pageId, allocateId, onApply, onError, lifetimeKey, subscribeLifetime, disabled }: ClipboardPasteOptions): {
+    paste: (text: string) => void;
+    dialog: import("react").JSX.Element | null;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pygmalionjs/pygmalion",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Code-backed DOM design sandbox and visual QA editor",
   "license": "Apache-2.0",
   "repository": {