@pygmalionjs/pygmalion 0.7.4 → 0.8.0

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

@@ -43,20 +43,17 @@ export declare const UNDECLARED_LANE_ID = "";
 export declare function validateScreenLanes(lanes: readonly ScreenLaneDef[], context?: {
     sections?: readonly string[];
 }): ScreenLaneDiagnostic[];
-export declare function setScreenLanes(lanes: readonly ScreenLaneDef[] | undefined): void;
-export declare function getScreenLanes(): readonly ScreenLaneDef[];
-/** Declared lanes of one section, in declaration order. */
-export declare function lanesForSection(section: string): ScreenLaneDef[];
-export declare function laneCaptionFor(section: string, laneId: string): ScreenLaneDef | null;
-/**
- * Groups frames into lanes in declaration order, appending the implicit lane
- * last. A frame tagged with a lane the section did not declare counts as
- * undeclared rather than creating a lane of its own, so a typo shows up as a
- * frame that fell out of its situation instead of as a phantom row.
- */
-export declare function groupByLane<T extends {
-    lane?: string;
-}>(section: string, frames: readonly T[]): {
-    laneId: string;
-    frames: T[];
-}[];
+/** One editor's declared screen lanes. */
+export declare function createFrameLanes(): {
+    setScreenLanes: (lanes: readonly ScreenLaneDef[] | undefined) => void;
+    getScreenLanes: () => readonly ScreenLaneDef[];
+    lanesForSection: (section: string) => ScreenLaneDef[];
+    laneCaptionFor: (section: string, laneId: string) => ScreenLaneDef | null;
+    groupByLane: <T extends {
+        lane?: string;
+    }>(section: string, frames: readonly T[]) => {
+        laneId: string;
+        frames: T[];
+    }[];
+};
+export type FrameLanes = ReturnType<typeof createFrameLanes>;

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

@@ -131,3 +131,20 @@ export declare function resolveFrameLodTiers({ frames, camera, viewport, previou
     config?: FrameLodConfig;
     budget: number;
 }): Map<string, FrameLifecycleTier>;
+/**
+ * Which frames should render live, best first: the active frame, then every
+ * frame by its screen-space gap to the viewport (intersecting frames first),
+ * ties broken by distance from the viewport centre. The live-screen budget
+ * takes the head of this list; the rest keep their frozen capture.
+ */
+export declare function rankLiveScreenCandidates({ frames, camera, viewport, activeId, preferredIds, }: {
+    frames: readonly {
+        id: string;
+        rect: FrameLodRect;
+    }[];
+    camera: FrameLodCamera;
+    viewport: FrameLodViewport;
+    activeId: string | null;
+    /** Ids that outrank distance, in order: the active group's standby variants. */
+    preferredIds?: readonly string[];
+}): string[];

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

@@ -1,42 +1,6 @@
-import { type FrameLifecycleTier, type FrameLodCamera, type FrameLodConfig, type FrameLodFrame, type FrameLodViewport } from './frameLod';
+import { type FrameLifecycleTier, type FrameLodCamera, type FrameLodConfig, type FrameLodFrame, type FrameLodViewport } from './frameLod.js';
 /** Frames the controller has not classified render at full detail. */
 export declare const DEFAULT_FRAME_LOD_TIER: FrameLifecycleTier;
-export declare function getFrameTier(frameId: string): FrameLifecycleTier;
-/**
- * True when the camera currently draws this frame beyond its screenshot's
- * pixel density. Published from the same recompute as the tiers, over the
- * same per-frame channels, so only frames whose flag flips re-render.
- */
-export declare function getFrameMagnification(frameId: string): boolean;
-/**
- * Whether screenshots should display at native capture resolution right now.
- * Camera-global: below one device pixel per CSS pixel every frame's
- * half-scale bitmap is indistinguishable and far cheaper to keep decoded.
- */
-export declare function getFrameBitmapFull(): boolean;
-export declare function subscribeFrameBitmapScale(listener: () => void): () => void;
-/** Diagnostic view of the published LOD state, for headless debugging. */
-export declare function __debugFrameLodState(): {
-    tiers: [string, FrameLifecycleTier][];
-    magnified: [string, boolean][];
-    lastRecompute: {
-        displayDensity?: number;
-        overview?: boolean;
-        frames?: {
-            id: string;
-            screenshotDensity: number | null | undefined;
-            tier: string;
-        }[];
-    };
-};
-export declare function subscribeFrameLod(frameId: string, listener: () => void): () => void;
-/**
- * Total live tier listeners across all frames. A diagnostic seam for leak
- * tests: after any number of mount/unmount cycles the count must return to
- * what it was before them, because every subscribeFrameLod cleanup removes
- * its listener and drops the frame's empty set.
- */
-export declare function countFrameLodListeners(): number;
 export interface FrameLodCameraSample extends FrameLodCamera {
     /** Tracked so a canvas switch retriggers the reaction; unused by the math. */
     canvas?: string;
@@ -54,6 +18,13 @@ export interface FrameLodControllerOptions {
     resolveBudget?(frames: readonly FrameLodFrame[]): number;
     /** Screen device pixels per CSS pixel. Defaults to window.devicePixelRatio. */
     readDevicePixelRatio?(): number;
+    /** Called after every recompute with what it read and decided. */
+    onRecompute?(input: {
+        frames: readonly FrameLodFrame[];
+        camera: FrameLodCameraSample;
+        viewport: FrameLodViewport;
+        tiers: ReadonlyMap<string, FrameLifecycleTier>;
+    }): void;
 }
 export interface FrameLodController {
     start(): void;
@@ -61,4 +32,33 @@ export interface FrameLodController {
     /** Runs the tier computation immediately (initial mount and tests). */
     recompute(): void;
 }
-export declare function createFrameLodController(options: FrameLodControllerOptions): FrameLodController;
+/**
+ * The per-runtime frame LOD state: the published tiers and magnification
+ * flags with their per-frame listeners, the camera-global bitmap-resolution
+ * signal, the last recompute diagnostic, and the controller factory that
+ * publishes into them. The bodies below are the former module-level
+ * functions, closed over instance state instead of module state.
+ */
+export declare function createFrameLodRuntime(): {
+    getFrameTier: (frameId: string) => FrameLifecycleTier;
+    getFrameMagnification: (frameId: string) => boolean;
+    getFrameBitmapFull: () => boolean;
+    subscribeFrameBitmapScale: (listener: () => void) => () => void;
+    __debugFrameLodState: () => {
+        tiers: [string, FrameLifecycleTier][];
+        magnified: [string, boolean][];
+        lastRecompute: {
+            displayDensity?: number;
+            overview?: boolean;
+            frames?: {
+                id: string;
+                screenshotDensity: number | null | undefined;
+                tier: string;
+            }[];
+        };
+    };
+    subscribeFrameLod: (frameId: string, listener: () => void) => () => void;
+    countFrameLodListeners: () => number;
+    createFrameLodController: (options: FrameLodControllerOptions) => FrameLodController;
+};
+export type FrameLodRuntime = ReturnType<typeof createFrameLodRuntime>;

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

@@ -1,4 +1,6 @@
-import type { PageModel } from './store';
+import type { RoutePreviewCache } from './routePreview.js';
+import type { EditorDeclarations } from './declarations.js';
+import type { PageModel } from './store.js';
 /**
  * The preview environment of one page: its own declared environment, plus the
  * host's preview-environment override when the page is the active one.
@@ -10,12 +12,19 @@ import type { PageModel } from './store';
  * is active (FrameView receives it as a prop; a store-side caller compares
  * ids), and passing it keeps the computation free of any store.
  */
-export declare function pagePreviewEnvironment(page: PageModel, active: boolean): import("./designImport").StoryboardEnvironment | undefined;
+export declare function pagePreviewEnvironment(declarations: Pick<EditorDeclarations, 'getPreviewEnvironmentOverride'>, page: PageModel, active: boolean): import("./designImport.js").StoryboardEnvironment | undefined;
+/** What a cache key needs from the preview cache: its namespace and its key format. */
+export type RoutePreviewKeySource = Pick<RoutePreviewCache, 'createRoutePreviewRecipeKey' | 'getRoutePreviewCacheNamespace'>;
+/** What a cache key needs from a runtime: its preview cache and its host declarations. */
+export interface RoutePreviewKeyRuntime {
+    readonly previews: RoutePreviewKeySource;
+    readonly declarations: EditorDeclarations;
+}
 /**
- * The recipe cache key of one page. `active` is forwarded to
- * pagePreviewEnvironment — see its note on selection reactivity.
+ * The recipe cache key of one page in one runtime's cache. `active` is
+ * forwarded to pagePreviewEnvironment — see its note on selection reactivity.
  */
-export declare function routePreviewCacheKey(page: PageModel, previewRevision: string, active: boolean, viewport?: {
+export declare function routePreviewCacheKey(runtime: RoutePreviewKeyRuntime, page: PageModel, previewRevision: string, active: boolean, viewport?: {
     width: number;
     height: number;
 }): string;

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

@@ -1,6 +1,7 @@
-import type { DomImportOptions, DomImportResult } from './domImport';
-import type { InstanceResolver } from './fiberMap';
-import type { ShadowPreviewHandle } from './shadowPreview';
+import type { DesignImportRegistry } from './designImport.js';
+import type { DomImportOptions, DomImportResult } from './domImport.js';
+import type { InstanceResolver } from './fiberMap.js';
+import type { ShadowPreviewHandle } from './shadowPreview.js';
 /** Reads Track-D stamped attributes back into the fiberMap InstanceHit shape. */
 export declare function createStampedInstanceResolver(): InstanceResolver;
 /**
@@ -47,7 +48,7 @@ export declare function importCountFloor(sourceElements: number): number;
  * Counts opening tags; the floor only needs the order of magnitude.
  */
 export declare function countMarkupElements(markup: string | null | undefined, limit?: number): number;
-export declare function importDomFromShadowPreview(handle: ShadowPreviewHandle, options?: ShadowPreviewImportOptions): DomImportResult | null;
+export declare function importDomFromShadowPreview(declarations: Pick<DesignImportRegistry, 'getDesignImportController'>, handle: ShadowPreviewHandle, options?: ShadowPreviewImportOptions): DomImportResult | null;
 export interface LiveImportSwapInput {
     /** True when the page tree changed after the provisional frozen import. */
     editedSinceImport: boolean;
@@ -58,13 +59,11 @@ export interface LiveImportSwapInput {
  * boot — the existing stale affordance covers manual refresh instead.
  */
 export declare function shouldSwapLiveImport(input: LiveImportSwapInput): boolean;
-/**
- * Registers the live mount handle for a page. The returned cleanup removes
- * exactly this registration, so a newer mount is never clobbered by a stale
- * teardown.
- */
-export declare function registerMountedShadowPreview(pageId: string, handle: ShadowPreviewHandle, options?: {
-    stale?: boolean;
-}): () => void;
-/** The mounted handle for a page, or null when none is mounted or the mounted preview is stale. */
-export declare function getMountedShadowPreviewHandle(pageId: string): ShadowPreviewHandle | null;
+/** The frozen previews one editor has mounted, by page id, so the store and the debug surface can reach a live handle. */
+export declare function createMountedShadowPreviews(): {
+    registerMountedShadowPreview: (pageId: string, handle: ShadowPreviewHandle, options?: {
+        stale?: boolean;
+    }) => () => void;
+    getMountedShadowPreviewHandle: (pageId: string) => ShadowPreviewHandle | null;
+};
+export type MountedShadowPreviews = ReturnType<typeof createMountedShadowPreviews>;

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

@@ -1,4 +1,4 @@
-import type { DesignScreenInteraction } from './designImport';
+import type { DesignScreenInteraction } from './designImport.js';
 export type HeldPseudoState = 'hover' | 'focus' | 'focus-visible' | 'active';
 /** The pseudo gestures still held after the complete recipe has run. */
 export declare function heldPseudoInteractionsFromRecipe(interactions: readonly DesignScreenInteraction[]): DesignScreenInteraction[];

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

@@ -1,6 +1,5 @@
-import type { InspectApplyPayload } from './inspect';
-import type { DesignImportKind } from './designImport';
-import type { InspectQaResult } from './visualQa';
+import type { DesignImportKind } from './designImport.js';
+import type { InspectQaResult } from './visualQa.js';
 export interface ApplyPayload {
     tokens: {
         name: string;
@@ -39,8 +38,16 @@ export interface InspectPreviewResult {
     /** Based on comparison of impact screens captured in current revision. */
     qa?: InspectQaResult;
 }
+/** A frame the node side decided a source change reaches. */
+export interface InspectImpactFrame {
+    /** The canonical frame id the editor and the capture worker share. */
+    id: string;
+    name?: string;
+}
 export interface InspectImpactResult {
     files: string[];
+    /** Present when the service knows the revision catalog; the editor prefers it to its own matching. */
+    frames?: InspectImpactFrame[];
 }
 /**
  * Unit of code edited on the canvas.
@@ -93,55 +100,3 @@ export interface DesignChangeResult {
     files?: string[];
     message?: string;
 }
-/** @deprecated Use `runtime.host.setAppOrigin`. */
-export declare function setAppOrigin(origin: string): void;
-/** @deprecated Use `runtime.host.appOrigin`. */
-export declare function getAppOrigin(): string;
-/** @deprecated Use `runtime.host.subscribeAppOrigin`. */
-export declare function subscribeAppOrigin(listener: () => void): () => void;
-/** @deprecated Use `runtime.host.setArtifactOrigin`. */
-export declare function setArtifactOrigin(origin: string): void;
-/** @deprecated Use `runtime.host.artifactOrigin`; see its documentation for the fallback order. */
-export declare function getArtifactOrigin(): string;
-/** @deprecated Use `runtime.host.subscribeArtifactOrigin`. */
-export declare function subscribeArtifactOrigin(listener: () => void): () => void;
-/** @deprecated Use `runtime.host.setPreviewRevision`. */
-export declare function setPreviewRevision(revision: string): void;
-/** @deprecated Use `runtime.host.previewRevision`. */
-export declare function getPreviewRevision(): string;
-/** @deprecated Use `runtime.host.subscribePreviewRevision`. */
-export declare function subscribePreviewRevision(listener: () => void): () => void;
-/** @deprecated Use `runtime.host.setFlowCanvas`. */
-export declare function setFlowCanvas(canvas: string): void;
-/** @deprecated Use `runtime.host.flowCanvas`. */
-export declare function getFlowCanvas(): string;
-/** @deprecated Use `runtime.host.setStaticFrameSurface`. */
-export declare function setStaticFrameSurface(surface: 'bitmap' | 'dom'): void;
-/** @deprecated Use `runtime.host.staticFrameSurface`. */
-export declare function getStaticFrameSurface(): 'bitmap' | 'dom';
-/** @deprecated Use `runtime.host.setOnApply`. */
-export declare function setOnApply(cb: ((payload: ApplyPayload) => Promise<{
-    branch: string;
-} | void>) | null): void;
-/** @deprecated Use `runtime.host.onApply`. */
-export declare function getOnApply(): import("../core/hostBindings").ApplyHandler | null;
-/** @deprecated Use `runtime.host.setOnInspectApply`. */
-export declare function setOnInspectApply(cb: ((payload: InspectApplyPayload) => Promise<InspectApplyResult | void>) | null): void;
-/** @deprecated Use `runtime.host.onInspectApply`. */
-export declare function getOnInspectApply(): import("../core/hostBindings").InspectApplyHandler | null;
-/** @deprecated Use `runtime.host.setOnInspectPreview`. */
-export declare function setOnInspectPreview(cb: ((payload: InspectApplyPayload) => Promise<InspectPreviewResult>) | null): void;
-/** @deprecated Use `runtime.host.onInspectPreview`. */
-export declare function getOnInspectPreview(): import("../core/hostBindings").InspectPreviewHandler | null;
-/** @deprecated Use `runtime.host.setOnInspectImpact`. */
-export declare function setOnInspectImpact(cb: ((componentFiles: string[]) => Promise<InspectImpactResult>) | null): void;
-/** @deprecated Use `runtime.host.onInspectImpact`. */
-export declare function getOnInspectImpact(): import("../core/hostBindings").InspectImpactHandler | null;
-/** @deprecated Use `runtime.host.setOnDesignChange`. */
-export declare function setOnDesignChange(cb: ((payload: DesignChangePayload) => Promise<DesignChangeResult | void>) | null): void;
-/** @deprecated Use `runtime.host.onDesignChange`. */
-export declare function getOnDesignChange(): import("../core/hostBindings").DesignChangeHandler | null;
-/** @deprecated Use `runtime.host.setOnPreviewOpenChange`. */
-export declare function setOnPreviewOpenChange(cb: ((open: boolean) => void) | null): void;
-/** @deprecated Use `runtime.host.onPreviewOpenChange`. */
-export declare function getOnPreviewOpenChange(): import("../core/hostBindings").PreviewOpenChangeHandler | null;

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

@@ -1,5 +1,5 @@
-import type { DesignIRComponent } from './designCompiler';
-import type { NodeJSON, NodeModel } from './store';
+import type { DesignIRComponent } from './designCompiler.js';
+import type { NodeJSON, NodeModel } from './store.js';
 type SourceNode = NodeModel | NodeJSON;
 export interface ImplementationComponentSource {
     name: string;

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

@@ -1,4 +1,4 @@
-import type { ImportedGeometryEntry } from './domImport';
+import type { ImportedGeometryEntry } from './domImport.js';
 /** The shape of a mounted layer tree this check needs — NodeModel satisfies it. */
 export interface LayerImportFidelityNode {
     id: string;

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

@@ -1,3 +1,4 @@
+import type { Registry } from './registry.js';
 /**
  * css module source mapping — host vite plugin (pygmalion-inspect-plugin)
  * window.__PYG_CSS_MODULES__ Derived from registration stacked in an array (scope class → scss file/local name).
@@ -97,7 +98,7 @@ export declare function canPreviewSourceProp(el: HTMLElement, prop: string): boo
 /** Relative paths whose meaning varies based on the target file are excluded. This slice supports only alias and bare package. */
 export declare function isSafeComponentImportPath(importPath: string): boolean;
 /** Normalize registry metadata only when it can be shared as is with AST payload and UI. */
-export declare function sourceInsertComponentFor(componentName: string): SourceInsertComponent | null;
+export declare function sourceInsertComponentFor(registry: Pick<Registry, 'getRegistry'>, componentName: string): SourceInsertComponent | null;
 interface ComponentStructurePreview {
     wrapper: HTMLElement;
     mount: () => boolean;
@@ -163,10 +164,15 @@ export interface InspectApplyPayload {
     operations: SourceEditOperation[];
 }
 export declare class InspectSession {
+    /** The registry of the editor this session edits. */
+    private readonly registry;
+    constructor(registry: Pick<Registry, 'getRegistry'>);
     /** Final commit candidate. Only one combination of the same element, attribute, and breakpoint is always maintained. */
     entries: InspectEntry[];
     toastMsg: string;
     toastSeq: number;
+    /** Bumps on every change to the entries or the history; panels compare it. */
+    revision: number;
     private seq;
     /** Undo/Redo is a session memory cache separate from the final patch. */
     private undoHistory;
@@ -221,5 +227,4 @@ export declare class InspectSession {
     clearApplied(): void;
 }
 export declare function isSourceBackedEntry(entry: InspectEntry): boolean;
-export declare const inspectSession: InspectSession;
 export {};

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

@@ -6,7 +6,7 @@
  * published, while the active frame may mirror the running document
  * immediately so capture stability never becomes interaction latency.
  */
-import type { DesignScreenDesiredState } from './designImport';
+import type { DesignScreenDesiredState } from './designImport.js';
 export interface InteractiveSessionSurface {
     iframe: HTMLIFrameElement;
     screenId: string;
@@ -14,37 +14,29 @@ export interface InteractiveSessionSurface {
 /** Stable presentation slot shared by sibling direct-state options. */
 export declare function directInteractiveSessionSurfaceId(pageId: string, stateId: string): string;
 /**
- * Connects the store's synchronous option selection to the session scheduler
- * without making the store import the scheduler that already depends on it.
+ * One editor's registry of live documents presenting a screen state, with the
+ * two direct-state handlers its flow-session scheduler installs. Every runtime
+ * owns one, so a store's option click reaches its own scheduler.
  */
-export declare function setDirectInteractiveStateRequestHandler(handler: ((pageId: string) => void) | null): void;
-/** Starts direct-state delivery in the same task as the right-panel click. */
-export declare function requestDirectInteractiveState(pageId: string): boolean;
-/** Installs the paint-first path used before the observable page recipe changes. */
-export declare function setDirectInteractiveStatePreviewHandler(handler: ((request: {
-    pageId: string;
-    stateId: string;
-    desiredState: DesignScreenDesiredState;
-}) => boolean) | null): void;
-/** Applies a direct host state without invalidating the editor model yet. */
-export declare function requestDirectInteractiveStatePreview(request: {
-    pageId: string;
-    stateId: string;
-    desiredState: DesignScreenDesiredState;
-}): boolean;
-/** Exposes a runner-owned iframe without transferring its ownership. */
-export declare function exposeInteractiveSessionSurface(screenId: string, iframe: HTMLIFrameElement): void;
-/**
- * Hands an in-flight prewarm slot to the frame that has just exposed its axis.
- * If preparation has not presented the iframe yet, its first exposure follows
- * the redirect instead of landing in the now-private staging slot.
- */
-export declare function redirectInteractiveSessionSurface(fromScreenId: string, toScreenId: string): boolean;
-/** Releases a surface only when the caller still owns the registered iframe. */
-export declare function releaseInteractiveSessionSurface(screenId: string, iframe: HTMLIFrameElement): void;
-/** Clears a presentation slot when its page returns to an authored state. */
-export declare function clearInteractiveSessionSurface(screenId: string): void;
-/** Active direct-state surfaces pin their warm React document against eviction. */
-export declare function hasInteractiveSessionSurfaceIframe(iframe: HTMLIFrameElement): boolean;
-export declare function getInteractiveSessionSurface(screenId: string): InteractiveSessionSurface | null;
-export declare function subscribeInteractiveSessionSurface(screenId: string, listener: () => void): () => void;
+export declare function createInteractiveSessionSurfaces(): {
+    setDirectInteractiveStateRequestHandler: (handler: ((pageId: string) => void) | null) => void;
+    requestDirectInteractiveState: (pageId: string) => boolean;
+    setDirectInteractiveStatePreviewHandler: (handler: ((request: {
+        pageId: string;
+        stateId: string;
+        desiredState: DesignScreenDesiredState;
+    }) => boolean) | null) => void;
+    requestDirectInteractiveStatePreview: (request: {
+        pageId: string;
+        stateId: string;
+        desiredState: DesignScreenDesiredState;
+    }) => boolean;
+    exposeInteractiveSessionSurface: (screenId: string, iframe: HTMLIFrameElement) => void;
+    redirectInteractiveSessionSurface: (fromScreenId: string, toScreenId: string) => boolean;
+    releaseInteractiveSessionSurface: (screenId: string, iframe: HTMLIFrameElement) => void;
+    clearInteractiveSessionSurface: (screenId: string) => void;
+    hasInteractiveSessionSurfaceIframe: (iframe: HTMLIFrameElement) => boolean;
+    getInteractiveSessionSurface: (screenId: string) => InteractiveSessionSurface | null;
+    subscribeInteractiveSessionSurface: (screenId: string, listener: () => void) => () => void;
+};
+export type InteractiveSessionSurfaces = ReturnType<typeof createInteractiveSessionSurfaces>;

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

@@ -1,6 +1,6 @@
-import type { DesignScreenInteraction, DesignSerializable, StoryboardEnvironment } from './designImport';
-import type { PageModel } from './store';
-export { reachablePreviewTestIds } from './previewReachability';
+import type { DesignScreenInteraction, DesignSerializable, StoryboardEnvironment } from './designImport.js';
+import type { PageModel } from './store.js';
+export { reachablePreviewTestIds } from './previewReachability.js';
 /**
  * Screen-state axes — same-frame variations reproduced by a gesture or a boot
  * condition.
@@ -145,8 +145,6 @@ export declare function previewMarkupTestIds(markup: string | null | undefined,
  * whole layer tree, while a frame without that control still hides the axis.
  */
 export declare function interactiveStatesForPage(page: PageModel, defs: readonly InteractiveStateDef[]): InteractiveStateDef[];
-/** The first axis whose options can render directly on a warm host document. */
-export declare function directInteractiveStateAxisForPage(page: PageModel, defs?: readonly InteractiveStateDef[]): InteractiveStateDef | undefined;
 /** Preferred public name for axes applicable to one frame. */
 export declare const screenStateAxesForPage: typeof interactiveStatesForPage;
 /**
@@ -161,8 +159,12 @@ export declare function capturedInteractiveOption(def: InteractiveStateDef, page
  * one option declared without steps.
  */
 export declare function baseInteractiveOption(def: InteractiveStateDef, page?: PageModel): InteractiveStateOption | undefined;
-export declare function setScreenStateAxes(defs: readonly InteractiveStateDef[] | undefined): void;
-/** @deprecated Use setScreenStateAxes. */
-export declare function setInteractiveStates(defs: readonly InteractiveStateDef[] | undefined): void;
-export declare function getInteractiveStates(): readonly InteractiveStateDef[];
-export declare const getScreenStateAxes: typeof getInteractiveStates;
+/** One editor's declared screen state axes. */
+export declare function createInteractiveStates(): {
+    directInteractiveStateAxisForPage: (page: PageModel, defs?: readonly InteractiveStateDef[]) => InteractiveStateDef | undefined;
+    setScreenStateAxes: (defs: readonly InteractiveStateDef[] | undefined) => void;
+    setInteractiveStates: (defs: readonly InteractiveStateDef[] | undefined) => void;
+    getInteractiveStates: () => readonly InteractiveStateDef[];
+    getScreenStateAxes: () => readonly InteractiveStateDef[];
+};
+export type InteractiveStates = ReturnType<typeof createInteractiveStates>;

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

@@ -1,5 +1,6 @@
 /**
- * Shared live application instances for producing screen previews.
+ * Live application instances the frames of one editor share to produce
+ * screen previews.
  *
  * A frame that has no frozen snapshot yet has to run the real application once.
  * Doing that per frame means one boot per screen, which is what made opening a
@@ -9,6 +10,11 @@
  *
  * A lease is exclusive. Snapshot production reads the document while it freezes,
  * so two frames must never drive one instance at the same time.
+ *
+ * Every editor runtime owns one pool, `runtime.schedulers.livePreviews`, so two
+ * editors on one page never queue behind each other's screens. React
+ * components reach it through `useEditorRuntime()`; other code takes it as a
+ * parameter.
  */
 export interface LivePreviewInstanceOptions {
     /** Creates the offscreen frame. Injected so the pool can be tested without a browser. */
@@ -86,8 +92,12 @@ export declare function createLivePreviewInstances(options?: LivePreviewInstance
     /** Drops an instance whose document can no longer be trusted. */
     discard(key: string): void;
     size(): number;
+    /**
+     * Releases every instance: the offscreen frames are removed and waiting
+     * leases are resumed. The pool stays usable — the next lease boots fresh —
+     * which is what a change of origin or revision needs, since every booted
+     * document would otherwise keep showing old code.
+     */
     dispose(): void;
 };
 export type LivePreviewInstances = ReturnType<typeof createLivePreviewInstances>;
-export declare function getLivePreviewInstances(): LivePreviewInstances;
-export declare function resetLivePreviewInstances(): void;

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

@@ -1,20 +1,29 @@
-export declare function subscribeLiveScreens(listener: () => void): () => void;
 /**
- * Sets how many frames may render live at once. Lowering it releases the
- * least recently requested frames back to the frozen surface.
+ * One editor's live-screen holds: the budget, the page ids holding a slot in
+ * recency order, and the listeners frames subscribe through. The bodies below
+ * are the former module-level functions, closed over instance state instead
+ * of module state. Every runtime owns one.
  */
-export declare function setLiveScreenBudget(next: number): void;
-export declare function getLiveScreenBudget(): number;
+/** How many frames render live unless the host says otherwise. */
+export declare const DEFAULT_LIVE_SCREEN_BUDGET = 3;
 /**
- * Claims a live slot for a page, or refreshes its recency when it already
- * holds one. Returns whether the page holds a slot afterwards, so a caller
- * can fall back to the frozen surface without waiting for a re-render.
+ * The most instances a screen-state group may hold at once. The budget
+ * follows the active group's size up to here so every variant of a small
+ * group stays booted and a switch between them is instant; a larger group
+ * keeps its most recently used variants live.
  */
-export declare function requestLiveScreen(pageId: string): boolean;
-/** Releases a page's slot, if it holds one. */
-export declare function releaseLiveScreen(pageId: string): void;
-export declare function holdsLiveScreen(pageId: string): boolean;
-/** Page ids currently rendering live, least recently requested first. */
-export declare function liveScreenHolders(): readonly string[];
-/** Test seam — drops every claim and the budget. */
-export declare function resetLiveScreens(): void;
+export declare const LIVE_SCREEN_GROUP_BUDGET_CAP = 5;
+export declare function createLiveScreens(): {
+    subscribeLiveScreens: (listener: () => void) => () => void;
+    setLiveScreenBudget: (next: number) => void;
+    setLiveScreenGroupSize: (next: number) => void;
+    getEffectiveLiveScreenBudget: () => number;
+    setLiveScreenCandidates: (next: readonly string[]) => void;
+    getLiveScreenBudget: () => number;
+    requestLiveScreen: (pageId: string) => boolean;
+    releaseLiveScreen: (pageId: string) => void;
+    holdsLiveScreen: (pageId: string) => boolean;
+    liveScreenHolders: () => readonly string[];
+    resetLiveScreens: () => void;
+};
+export type LiveScreens = ReturnType<typeof createLiveScreens>;

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

@@ -18,14 +18,11 @@ export declare const MOUNT_PRIORITY: Readonly<{
     background: 2;
 }>;
 export declare const DEFAULT_MOUNTS_PER_FRAME = 3;
-/** Test/tuning hook. */
-export declare function configureMountScheduler(options: MountSchedulerOptions): void;
-/** Drops queued mounts and counters; tests call it between cases. */
-export declare function resetMountScheduler(): void;
-export declare function pendingMountCount(): number;
-/**
- * Runs the mount now if this frame's budget allows, otherwise queues it.
- * The returned ticket withdraws a queued mount when the frame goes away
- * before its turn.
- */
-export declare function scheduleMount(run: () => void, priority?: number): MountTicket;
+/** One editor's frame-mount budget: the queue of pending mounts and how many run per animation frame. */
+export declare function createMountScheduler(): {
+    configureMountScheduler: (options: MountSchedulerOptions) => void;
+    resetMountScheduler: () => void;
+    pendingMountCount: () => number;
+    scheduleMount: (run: () => void, priority?: number) => MountTicket;
+};
+export type MountScheduler = ReturnType<typeof createMountScheduler>;

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

@@ -1,4 +1,4 @@
-import type { NodeModel } from './store';
+import type { NodeModel } from './store.js';
 export interface NodeSelector {
     testId?: string;
     classIncludes?: string | readonly string[];

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

@@ -0,0 +1,19 @@
+import type { InspectApplyPayload, InspectSession } from './inspect.js';
+import type { EditorStore } from './store.js';
+export interface PendingSourceChanges {
+    /** The store journal's revision, acknowledged with `ackPendingSourceChanges`. */
+    journalRevision: number;
+    /** The inspect session's revision, cleared with `clearApplied`. */
+    inspectRevision: number;
+    /** Both revisions in one comparable token. */
+    revision: string;
+    payload: InspectApplyPayload;
+}
+/**
+ * Folds two payloads into one. Style patches to the same file, class, and
+ * media query merge their declarations, the later one winning; texts and
+ * operations keep their order, first payload first.
+ */
+export declare function mergeSourcePayloads(first: InspectApplyPayload, second: InspectApplyPayload): InspectApplyPayload;
+/** Everything staged in this editor that the host has not written yet. */
+export declare function collectPendingSourceChanges(store: Pick<EditorStore, 'getPendingSourceChanges'>, inspect: Pick<InspectSession, 'buildApplyPayload' | 'revision'>): PendingSourceChanges;