@pygmalionjs/pygmalion 0.12.0 → 0.14.0

package/dist-lib/testing.js

@@ -1,6 +1,6 @@
-import { bW as l, T as u } from "./runtime-Bxn8116i.js";
-import { bi as y, cc as b, cd as E, ce as P, be as T, as as $ } from "./runtime-Bxn8116i.js";
-const v = {
+import { bY as l, T as u } from "./runtime-DkCf4iKe.js";
+import { bk as y, ce as b, cf as E, cg as P, bg as T, as as $ } from "./runtime-DkCf4iKe.js";
+const f = {
   mirror: ["status", "refresh", "refs"],
   session: ["open", "check", "previewVisual", "applyVisual", "revertVisual"],
   inspect: ["impact"],
@@ -8,12 +8,12 @@ const v = {
   preview: ["artifact", "progress", "catalog"],
   storyboard: ["environment", "sourceUsage", "componentBranches"]
 };
-function g(m = {}, t = {}) {
-  const n = [], d = t.origin ?? "", e = (r) => {
+function v(m = {}, t = {}) {
+  const n = [], d = t.origin ?? "", r = (e) => {
     var a;
     const i = {};
-    for (const o of v[r]) {
-      const s = `${r}.${String(o)}`, c = (a = m[r]) == null ? void 0 : a[o];
+    for (const o of f[e]) {
+      const s = `${e}.${String(o)}`, c = (a = m[e]) == null ? void 0 : a[o];
       i[String(o)] = (...p) => (n.push({ operation: s, request: p[0] }), c ? Promise.resolve(c(...p)) : Promise.reject(
         new u({
           operation: s,
@@ -27,13 +27,13 @@ function g(m = {}, t = {}) {
   return {
     calls: n,
     endpoints: l(t.endpoints),
-    resolveUrl: (r) => `${d}${r}`,
-    mirror: e("mirror"),
-    session: e("session"),
-    inspect: e("inspect"),
-    qa: e("qa"),
-    preview: e("preview"),
-    storyboard: e("storyboard")
+    resolveUrl: (e) => `${d}${e}`,
+    mirror: r("mirror"),
+    session: r("session"),
+    inspect: r("inspect"),
+    qa: r("qa"),
+    preview: r("preview"),
+    storyboard: r("storyboard")
   };
 }
 export {
@@ -42,6 +42,6 @@ export {
   E as FrozenRoutePreviewView,
   P as NodeModel,
   T as createEditorRuntime,
-  g as createMemoryTransport,
+  v as createMemoryTransport,
   $ as serializeNode
 };

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

@@ -10,6 +10,10 @@ export type { StylesPanelProps } from './workspace/edit/StylesPanel.js';
 export { TokenLibraryProvider, useTokenLibraryController, useHasTokenLibraryProvider } from './workspace/tokens/TokenLibraryContext.js';
 export { createTokenLibraryEngine, reopenTokenLibrary, validateTokenLibraryDocument, resolveTokenLibraryValue, tokenValueEditability, TokenLibraryValidationError } from './token-library/engine.js';
 export type * from './token-library/contracts.js';
+export { createTokenLibraryCache } from './token-library/cache.js';
+export type { TokenLibraryTextResolver, TokenLibraryPreviewContext, TokenLibraryCacheOptions, TokenLibraryCache } from './token-library/cache.js';
+export { formatTokenReferences, TokenReferenceFormatError } from './token-library/formatReferences.js';
+export type { TokenReferenceFormatContext } from './token-library/formatReferences.js';
 export { createTokenValueResolver } from './token-library/valueResolver.js';
 export type { TokenValueReferenceRange, TokenValueResolverOptions, ResolvedTokenText } from './token-library/valueResolver.js';
 export type * from './workspace/tokens/contracts.js';
@@ -429,5 +433,6 @@ export { PrototypePanel } from './workspace/edit/PrototypePanel.js';
 export { PrototypePlayer } from './workspace/view/PrototypePlayer.js';
 export type { PrototypePlayerProps } from './workspace/view/PrototypePlayer.js';
 export * from './workspace/view/prototypePlayback.js';
+export type { PrototypeInputFrame } from './workspace/view/prototypeInputFrame.js';
 export { createPrototypeProjectionContext } from './workspace/edit/prototypeProjection.js';
 export type { PrototypeProjectionContext } from './workspace/edit/prototypeProjection.js';

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

@@ -0,0 +1,20 @@
+import type { TokenLibraryDocument } from './contracts.js';
+import type { ResolvedTokenText } from './valueResolver.js';
+export type TokenLibraryTextResolver = (tokenId: string, modeId: string) => ResolvedTokenText;
+export interface TokenLibraryPreviewContext {
+    document: TokenLibraryDocument;
+    modeId: string;
+    resolve: TokenLibraryTextResolver;
+}
+export interface TokenLibraryCacheOptions<Preview> {
+    createResolver(document: TokenLibraryDocument): TokenLibraryTextResolver;
+    createPreview(context: TokenLibraryPreviewContext): Preview;
+}
+export interface TokenLibraryCache<Preview> {
+    resolver(document: TokenLibraryDocument): TokenLibraryTextResolver;
+    preview(document: TokenLibraryDocument, modeId: string): Preview;
+    /** Invalidate callbacks' external baseline inputs; previously returned resolvers remain usable. */
+    clear(): void;
+}
+/** Cache immutable document snapshots by object identity without retaining discarded snapshots. */
+export declare function createTokenLibraryCache<Preview>(options: TokenLibraryCacheOptions<Preview>): TokenLibraryCache<Preview>;

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

@@ -0,0 +1,12 @@
+import type { TokenReferenceSpan, TokenValue } from './contracts.js';
+export interface TokenReferenceFormatContext {
+    readonly reference: Readonly<TokenReferenceSpan>;
+    /** The exact original UTF-16 slice, unaffected by replacements of other spans. */
+    readonly original: string;
+}
+export declare class TokenReferenceFormatError extends Error {
+    readonly code: 'invalid-range' | 'invalid-replacement';
+    constructor(code: TokenReferenceFormatError['code'], message: string);
+}
+/** Validate every span before invoking a syntax-specific replacement callback. */
+export declare function formatTokenReferences(value: Pick<TokenValue, 'text' | 'references'>, replace: (context: TokenReferenceFormatContext) => string): string;

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

@@ -0,0 +1,7 @@
+import type { EditorDeclarations } from '../editor/declarations.js';
+
+export interface WorkspaceConditionsProps {
+    declarations: Pick<EditorDeclarations, 'getSessionPresets' | 'getSelectedSessionPreset' | 'selectSessionPreset' | 'subscribeSessionPresets' | 'getPreviewEnvironmentControls' | 'getPreviewEnvironmentControlValue' | 'getPreviewEnvironmentControlSelections' | 'setPreviewEnvironmentControlValue' | 'clearPreviewEnvironmentControlValues' | 'subscribePreviewEnvironmentControls' | 'getPreviewEnvironmentControlRevision'>;
+}
+/** Present declared catalog sessions and preview values without interpreting product policy. */
+export declare function WorkspaceConditions({ declarations }: WorkspaceConditionsProps): import("react").JSX.Element | null;

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

@@ -1,4 +1,4 @@
-import type { WorkspaceConfiguration } from './configuration.js';
+import { type WorkspaceConfiguration } from './configuration.js';
 
 export interface WorkspaceShellProps {
     configuration: WorkspaceConfiguration;

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

@@ -1,12 +1,14 @@
 import type { DesignDocument, DocumentEngine, DocumentNode } from '../../document/contracts.js';
 import { appearanceToCss } from '../../document/appearance.js';
 
+
 export interface AppearancePanelProps {
     engine: DocumentEngine;
     nodeId: string;
     disabled?: boolean;
+    compact?: boolean;
 }
-export declare function AppearancePanel({ engine, nodeId, disabled }: AppearancePanelProps): import("react").JSX.Element | null;
+export declare function AppearancePanel({ engine, nodeId, disabled, compact }: AppearancePanelProps): import("react").JSX.Element | null;
 /** Separate decorative layers preserve each paint's opacity independently of the content. */
 export declare function AppearanceSurface({ node, document }: {
     node: DocumentNode;

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

@@ -0,0 +1,25 @@
+import { type ReactNode } from 'react';
+import type { WorkspaceCamera } from '../contracts.js';
+import { type EditViewportBounds } from './editViewportModel.js';
+
+export interface EditViewportHandle {
+    fitAll(): void;
+    fitSelection(): void;
+    actualSize(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+}
+export interface EditViewportProps {
+    children: ReactNode;
+    camera: WorkspaceCamera;
+    onCameraChange(camera: WorkspaceCamera): void;
+    bounds: EditViewportBounds;
+    selectionBounds?: EditViewportBounds;
+    documentKey: string;
+    hand: boolean;
+    /** Captured once per document entry; false preserves a restored camera. */
+    initialFit?: boolean;
+    /** Wait for asynchronously projected geometry before the initial fit. */
+    ready?: boolean;
+}
+export declare const EditViewport: import("react").ForwardRefExoticComponent<EditViewportProps & import("react").RefAttributes<EditViewportHandle>>;

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

@@ -0,0 +1,19 @@
+
+export type EditorTool = 'select' | 'hand' | 'frame' | 'text' | 'rectangle' | 'ellipse' | 'line' | 'polygon' | 'star' | 'arc' | 'pen' | 'marquee';
+export interface EditorToolbarProps {
+    tool: EditorTool;
+    onToolChange(tool: EditorTool): void;
+    canUndo: boolean;
+    canRedo: boolean;
+    onUndo(): void;
+    onRedo(): void;
+    canGroup: boolean;
+    canDuplicate: boolean;
+    duplicateDisabledReason?: string;
+    onGroup(): void;
+    onDuplicate(): void;
+    canDelete?: boolean;
+    onDelete?(): void;
+}
+/** Tool selection and editor commands only; the canvas owns gestures and document transactions. */
+export declare function EditorToolbar(props: EditorToolbarProps): import("react").JSX.Element;

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

@@ -0,0 +1,20 @@
+import type { WorkspaceCamera } from '../contracts.js';
+export interface EditViewportBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface EditViewportSize {
+    width: number;
+    height: number;
+}
+export declare function validEditCamera(camera: WorkspaceCamera): boolean;
+/** A hidden viewport or invalid geometry must never replace a usable camera. */
+export declare function fitEditViewport(bounds: EditViewportBounds, viewport: EditViewportSize): WorkspaceCamera | null;
+/** Preserve the world point under a viewport-local pointer or viewport center. */
+export declare function zoomEditViewport(camera: WorkspaceCamera, anchor: {
+    x: number;
+    y: number;
+}, requestedZoom: number): WorkspaceCamera | null;
+export declare function panEditViewport(camera: WorkspaceCamera, dx: number, dy: number): WorkspaceCamera | null;

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

@@ -0,0 +1,27 @@
+import type { DataProjection } from '../../binding/preview.js';
+import type { DesignDocument, DocumentNode } from '../../document/contracts.js';
+import { type VectorShape } from '../../document/vector.js';
+export interface CanvasBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface CanvasEntry {
+    id: string;
+    box: CanvasBox;
+    topLevel: boolean;
+}
+export type DrawingTool = 'frame' | 'text' | VectorShape;
+export declare function canvasEntries(document: DesignDocument, projection: DataProjection | null, selected?: readonly string[]): CanvasEntry[];
+export declare function canvasBounds(entries: readonly CanvasEntry[]): CanvasBox;
+export declare function marqueeSelection(document: DesignDocument, entries: readonly CanvasEntry[], box: CanvasBox): readonly string[];
+export declare function drawingBox(start: {
+    x: number;
+    y: number;
+}, end: {
+    x: number;
+    y: number;
+}, square?: boolean): CanvasBox;
+/** New free layers are created in page space. Source components retain their owned geometry. */
+export declare function drawnNode(tool: DrawingTool, id: string, box: CanvasBox, reverseLine?: boolean): DocumentNode;

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

@@ -1,3 +1,5 @@
-export declare const StoryboardWorkspace: import("react").FunctionComponent<{
+export interface StoryboardWorkspaceProps {
     sourceRevision: string;
-}>;
+    canEditSelected: boolean;
+}
+export declare const StoryboardWorkspace: import("react").FunctionComponent<StoryboardWorkspaceProps>;

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

@@ -0,0 +1,13 @@
+/** Frame scheduling only. Input timestamps continue to come from the playback clock. */
+export interface PrototypeInputFrame {
+    request(callback: () => void): unknown;
+    cancel(handle: unknown): void;
+}
+/** Retain one latest value and publish it at most once per requested frame.
+ * Flush is for an owned release; cancel discards input on lifecycle changes.
+ * Generation checks also reject callbacks delivered after scheduler cancellation. */
+export declare function createPrototypeInputFrame<T>(frame: PrototypeInputFrame, publish: (value: T) => void): {
+    push(value: T): void;
+    flush: () => void;
+    cancel: () => void;
+};

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

@@ -1,6 +1,7 @@
 import type { DesignDocument, DocumentNode, ResolvedDocumentNode } from '../../document/contracts.js';
 import { type PrototypeEffect, type PrototypeEvent, type PrototypeRuntimeContext, type PrototypeStartOptions, type PrototypeState } from '../../document/prototype.js';
 import { type PrototypeDragFinishInput, type PrototypeDragStartInput } from '../../document/prototypeDrag.js';
+import { type PrototypeInputFrame } from './prototypeInputFrame.js';
 export interface PrototypeClock {
     now(): number;
     schedule(callback: () => void, delayMs: number): unknown;
@@ -21,6 +22,8 @@ export interface PrototypePlayerSnapshot {
 }
 export interface PrototypePlayerOptions extends PrototypeStartOptions {
     clock: PrototypeClock;
+    /** Optional presentation batching; raw samples still use this player's clock immediately. */
+    inputFrame?: PrototypeInputFrame;
     /** Effects describe intended links and scrolling; the adapter decides how to execute them. */
     onEffect?(effect: PrototypeEffect): void;
 }

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

@@ -0,0 +1,42 @@
+import type { PageModel } from '../../editor/store.js';
+import type { StoryboardGraph, StoryboardGraphEdge } from '../../editor/storyboardGraph.js';
+import type { WorkspaceCamera } from '../contracts.js';
+export interface StoryboardBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface StoryboardViewport {
+    width: number;
+    height: number;
+}
+export interface StoryboardArtboard extends StoryboardBounds {
+    page: PageModel;
+    screenId: string;
+    group: string;
+}
+export interface StoryboardConnection {
+    edge: StoryboardGraphEdge;
+    from: StoryboardArtboard;
+    to: StoryboardArtboard;
+    path: string;
+    labelX: number;
+    labelY: number;
+}
+export declare const storyboardFlow: (page: PageModel) => string;
+/** Arrange source-sized screens in flow lanes; never rewrite authored page geometry. */
+export declare function layoutStoryboard(pages: readonly PageModel[]): {
+    frames: StoryboardArtboard[];
+    bounds: StoryboardBounds;
+};
+export declare function storyboardFrameBounds(frame: StoryboardBounds): StoryboardBounds;
+export declare function fitStoryboard(bounds: StoryboardBounds, viewport: StoryboardViewport): WorkspaceCamera;
+/** Preserve the world point under the pointer when zooming. */
+export declare function zoomStoryboard(camera: WorkspaceCamera, point: {
+    x: number;
+    y: number;
+}, requested: number): WorkspaceCamera;
+export declare function visibleStoryboardFrames(frames: readonly StoryboardArtboard[], camera: WorkspaceCamera, viewport: StoryboardViewport): StoryboardArtboard[];
+/** A line means an authored transition. Layout proximity never creates an edge. */
+export declare function storyboardConnections(frames: readonly StoryboardArtboard[], graph: StoryboardGraph | null): StoryboardConnection[];

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

@@ -0,0 +1,26 @@
+import type { EditorRuntime } from '../../core/runtime.js';
+import { type CaptureSupplyDriverDeps } from '../../editor/captureSupply.js';
+import type { RoutePreviewArtifactOutcome } from '../../editor/routePreview.js';
+import type { PageModel } from '../../editor/store.js';
+type Runtime = Pick<EditorRuntime, 'host' | 'previews' | 'declarations'>;
+export interface StoryboardCaptureDemand {
+    sourceRevision: string;
+    /** Only frames intersecting the canvas viewport, after its catalog filters. */
+    pages: readonly PageModel[];
+    selected?: PageModel;
+}
+export interface StoryboardCaptureState {
+    outcome: RoutePreviewArtifactOutcome | null;
+    status: 'missing' | 'generating' | 'ready' | 'stale' | 'failed';
+    message?: string;
+    retry(): void;
+}
+/** Demand comes from the canvas; transport, deduplication and bounded readiness retries remain shared. */
+export declare function createStoryboardCaptureController(runtime: Runtime, timers?: Pick<CaptureSupplyDriverDeps, 'setTimeout' | 'clearTimeout'>): {
+    update: (next: StoryboardCaptureDemand, retryId?: string) => void;
+    dispose: () => void;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => import("../../editor/captureSupply.js").CaptureSupplyStatus;
+    capture(page: PageModel, sourceRevision?: string): StoryboardCaptureState;
+};
+export {};

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

@@ -0,0 +1,5 @@
+import type { EditorRuntime } from '../../core/runtime.js';
+import type { PageModel } from '../../editor/store.js';
+import { type StoryboardCaptureDemand } from './storyboardCaptures.js';
+/** Canvas visibility is supplied by its layout; repeated renders cannot enqueue another identical plan. */
+export declare function useStoryboardCaptures(runtime: EditorRuntime, demand: StoryboardCaptureDemand): (page: PageModel) => import("./storyboardCaptures.js").StoryboardCaptureState;

package/node/preview-capture-worker.mjs

@@ -231,6 +231,7 @@ export function createPreviewCaptureWorkerChannel({
   let degraded = false;
   let disposed = false;
   let idleTimer = null;
+  let restartWait = null;
   let requestCounter = 0;
   const crashTimestamps = [];
 
@@ -441,14 +442,21 @@ export function createPreviewCaptureWorkerChannel({
         // The wedged worker was killed and the crash recorded. When that
         // crash exhausted the restart budget, the caller takes the degraded
         // path; otherwise fall through to a fresh spawn below.
+        if (disposed) throw new Error('Preview capture worker channel is disposed.');
         if (degraded) return null;
       }
     }
     const backoff = restartBackoffMs();
     if (backoff > 0) {
-      await new Promise((resolve) => {
-        const timer = setTimeout(resolve, backoff);
-        timer.unref?.();
+      await new Promise((resolve, reject) => {
+        const pending = { timer: null, reject };
+        // There is no child process during backoff. The active capture owns
+        // this delay until it completes or dispose cancels the request.
+        pending.timer = setTimeout(() => {
+          if (restartWait === pending) restartWait = null;
+          resolve();
+        }, backoff);
+        restartWait = pending;
       });
     }
     if (disposed) {
@@ -595,6 +603,12 @@ export function createPreviewCaptureWorkerChannel({
     if (disposed) return;
     disposed = true;
     clearIdleTimer();
+    if (restartWait) {
+      const pending = restartWait;
+      restartWait = null;
+      clearTimeout(pending.timer);
+      pending.reject(new Error('Preview capture worker channel is disposed.'));
+    }
     await stopWorker();
   }
 

package/package.json

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