@printstack/print-studio 0.0.0-stage → 0.1.0

package/designer/facade/output.d.ts

@@ -0,0 +1,21 @@
+import { HtmlParseOptions, PdfParseOptions, RenderExecutionOptions } from '../../parser';
+import { BrowserOutputOptions } from '../../runtime/browser-output';
+import { HtmlResult, PdfResult } from '../../studio-types';
+import { FacadeAccess } from './entities';
+export declare function createOutputFacade(access: FacadeAccess): {
+    export: {
+        html: (input?: Record<string, unknown>, options?: HtmlParseOptions, execution?: RenderExecutionOptions) => Promise<HtmlResult>;
+        json: () => string;
+        pdf: (input?: Record<string, unknown>, options?: PdfParseOptions, execution?: RenderExecutionOptions) => Promise<PdfResult>;
+    };
+    preview: (input?: Record<string, unknown>, options?: BrowserOutputOptions) => Promise<{
+        warnings: string[];
+        close(): void;
+        element: HTMLIFrameElement;
+    }>;
+    print: (input?: Record<string, unknown>, options?: BrowserOutputOptions) => Promise<{
+        warnings: string[];
+    }>;
+    toHTML: (input?: Record<string, unknown>, options?: HtmlParseOptions, execution?: RenderExecutionOptions) => Promise<HtmlResult>;
+    toPDF: (input?: Record<string, unknown>, options?: PdfParseOptions, execution?: RenderExecutionOptions) => Promise<PdfResult>;
+};

package/designer/facade/pages.d.ts

@@ -0,0 +1,204 @@
+import { PageNode } from '../../core/types';
+import { PageOptions } from '../../studio-types';
+import { EntityReference, FacadeAccess } from './entities';
+export type { PageOptions, PagePatch } from '../../studio-types';
+export declare function createPagesFacade(access: FacadeAccess, defaultElementType: string): {
+    readonly active: {
+        readonly data: PageNode | undefined;
+        elements: {
+            add: (options?: import('../../studio-types').ElementOptions) => {
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            };
+            clear(): void;
+            duplicate(reference: EntityReference): ({
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            } | undefined)[];
+            get: (reference: EntityReference) => {
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            } | undefined;
+            readonly list: {
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            }[];
+            move(reference: EntityReference, displayIndex: number): void;
+            remove: (reference: EntityReference) => void;
+            rename(reference: EntityReference, name: string): void;
+            toggleFlag(reference: EntityReference, flag: "locked" | "visible"): void;
+            update(reference: EntityReference, patch: import('../../studio-types').ElementPatch, options?: import('../../studio-types').MutationOptions): void;
+            updateProps(reference: EntityReference, patch: Record<string, unknown>, options?: import('../../studio-types').MutationOptions): void;
+        };
+        id: string;
+        remove: () => void;
+        update: (patch: Partial<Pick<PageNode, "height" | "width" | "name" | "margins" | "background" | "templateId">>) => void;
+    };
+    create: (options?: PageOptions) => {
+        readonly data: PageNode | undefined;
+        elements: {
+            add: (options?: import('../../studio-types').ElementOptions) => {
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            };
+            clear(): void;
+            duplicate(reference: EntityReference): ({
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            } | undefined)[];
+            get: (reference: EntityReference) => {
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            } | undefined;
+            readonly list: {
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            }[];
+            move(reference: EntityReference, displayIndex: number): void;
+            remove: (reference: EntityReference) => void;
+            rename(reference: EntityReference, name: string): void;
+            toggleFlag(reference: EntityReference, flag: "locked" | "visible"): void;
+            update(reference: EntityReference, patch: import('../../studio-types').ElementPatch, options?: import('../../studio-types').MutationOptions): void;
+            updateProps(reference: EntityReference, patch: Record<string, unknown>, options?: import('../../studio-types').MutationOptions): void;
+        };
+        id: string;
+        remove: () => void;
+        update: (patch: Partial<Pick<PageNode, "height" | "width" | "name" | "margins" | "background" | "templateId">>) => void;
+    };
+    duplicate(reference: EntityReference): {
+        readonly data: PageNode | undefined;
+        elements: {
+            add: (options?: import('../../studio-types').ElementOptions) => {
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            };
+            clear(): void;
+            duplicate(reference: EntityReference): ({
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            } | undefined)[];
+            get: (reference: EntityReference) => {
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            } | undefined;
+            readonly list: {
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            }[];
+            move(reference: EntityReference, displayIndex: number): void;
+            remove: (reference: EntityReference) => void;
+            rename(reference: EntityReference, name: string): void;
+            toggleFlag(reference: EntityReference, flag: "locked" | "visible"): void;
+            update(reference: EntityReference, patch: import('../../studio-types').ElementPatch, options?: import('../../studio-types').MutationOptions): void;
+            updateProps(reference: EntityReference, patch: Record<string, unknown>, options?: import('../../studio-types').MutationOptions): void;
+        };
+        id: string;
+        remove: () => void;
+        update: (patch: Partial<Pick<PageNode, "height" | "width" | "name" | "margins" | "background" | "templateId">>) => void;
+    } | undefined;
+    get: (reference: EntityReference) => {
+        readonly data: PageNode | undefined;
+        elements: {
+            add: (options?: import('../../studio-types').ElementOptions) => {
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            };
+            clear(): void;
+            duplicate(reference: EntityReference): ({
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            } | undefined)[];
+            get: (reference: EntityReference) => {
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            } | undefined;
+            readonly list: {
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            }[];
+            move(reference: EntityReference, displayIndex: number): void;
+            remove: (reference: EntityReference) => void;
+            rename(reference: EntityReference, name: string): void;
+            toggleFlag(reference: EntityReference, flag: "locked" | "visible"): void;
+            update(reference: EntityReference, patch: import('../../studio-types').ElementPatch, options?: import('../../studio-types').MutationOptions): void;
+            updateProps(reference: EntityReference, patch: Record<string, unknown>, options?: import('../../studio-types').MutationOptions): void;
+        };
+        id: string;
+        remove: () => void;
+        update: (patch: Partial<Pick<PageNode, "height" | "width" | "name" | "margins" | "background" | "templateId">>) => void;
+    } | undefined;
+    readonly list: {
+        readonly data: PageNode | undefined;
+        elements: {
+            add: (options?: import('../../studio-types').ElementOptions) => {
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            };
+            clear(): void;
+            duplicate(reference: EntityReference): ({
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            } | undefined)[];
+            get: (reference: EntityReference) => {
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            } | undefined;
+            readonly list: {
+                readonly data: import('../../core/types').ElementNode | undefined;
+                id: string;
+                remove(): void;
+                update(patch: Partial<Omit<import('../../core/types').ElementNode, "id" | "type">>): void;
+            }[];
+            move(reference: EntityReference, displayIndex: number): void;
+            remove: (reference: EntityReference) => void;
+            rename(reference: EntityReference, name: string): void;
+            toggleFlag(reference: EntityReference, flag: "locked" | "visible"): void;
+            update(reference: EntityReference, patch: import('../../studio-types').ElementPatch, options?: import('../../studio-types').MutationOptions): void;
+            updateProps(reference: EntityReference, patch: Record<string, unknown>, options?: import('../../studio-types').MutationOptions): void;
+        };
+        id: string;
+        remove: () => void;
+        update: (patch: Partial<Pick<PageNode, "height" | "width" | "name" | "margins" | "background" | "templateId">>) => void;
+    }[];
+    remove: (reference: EntityReference) => void;
+    setActive(reference: EntityReference): void;
+    update: (reference: EntityReference, patch: Partial<Pick<PageNode, "height" | "width" | "name" | "margins" | "background" | "templateId">>) => void;
+};

package/designer/facade/print-studio.d.ts

@@ -0,0 +1,3 @@
+import { DesignStudio, PrintStudioOptions } from '../../studio-types';
+import { EditorContext } from '../context/editor-context';
+export declare function createStudioFacade(ctx: EditorContext, options?: Pick<PrintStudioOptions, 'defaultElementType'>, onDispose?: () => void): DesignStudio;

package/designer/facade/state.d.ts

@@ -0,0 +1,10 @@
+import { StudioSnapshot } from '../../studio-types';
+import { EditorContext } from '../context/editor-context';
+import { FacadeAccess } from './entities';
+export declare function createStateFacade(ctx: EditorContext, access: FacadeAccess): {
+    dispose(): void;
+    state: {
+        getSnapshot(): StudioSnapshot;
+        subscribe(listener: () => void): () => void;
+    };
+};

package/designer/facade/use-print-studio.d.ts

@@ -0,0 +1,6 @@
+import { DesignStudio, PrintStudioOptions } from '../../studio-types';
+import { EditorContext } from '../context/editor-context';
+export interface UsePrintStudioOptions extends PrintStudioOptions {
+    context?: EditorContext;
+}
+export declare function usePrintStudio(options?: UsePrintStudioOptions): DesignStudio;

package/designer/frame/host.d.ts

@@ -0,0 +1,7 @@
+import { DesignerFrameProps, mountDesignerView } from './view';
+import { frameShared } from './shared';
+export interface DesignerFrameBridge {
+    shared: typeof frameShared;
+    start(mount: typeof mountDesignerView): void;
+}
+export declare function createDesignerFrame(container: HTMLElement, props: DesignerFrameProps): () => void;

package/designer/frame/print-designer-frame.vue.d.ts

@@ -0,0 +1,25 @@
+import { PrintDocument } from '../../core/types';
+import { PrintDesignerProps } from '../types';
+declare function getDocument(): PrintDocument;
+declare function loadDocument(document: PrintDocument): void;
+declare function isDirty(): boolean;
+declare function save(): Promise<void>;
+declare const __VLS_export: import('vue').DefineComponent<PrintDesignerProps, {
+    context: import('../context/editor-context').EditorContext;
+    getDocument: typeof getDocument;
+    isDirty: typeof isDirty;
+    loadDocument: typeof loadDocument;
+    save: typeof save;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    ready: (context: import('../context/editor-context').EditorContext) => any;
+    error: (error: unknown) => any;
+    dispose: () => any;
+    "dirty-change": (dirty: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<PrintDesignerProps> & Readonly<{
+    onReady?: ((context: import('../context/editor-context').EditorContext) => any) | undefined;
+    onError?: ((error: unknown) => any) | undefined;
+    onDispose?: (() => any) | undefined;
+    "onDirty-change"?: ((dirty: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/designer/frame/shared.d.ts

@@ -0,0 +1,30 @@
+import * as vue from 'vue';
+import * as popupContainer from '../../components/popup-layer/container';
+import * as formContext from '../../components/s-form/context';
+import * as fieldStatus from '../../components/s-form/field-status';
+import * as zIndex from '../../composables/use-z-index';
+import * as errors from '../../core/errors';
+import * as editorRuntime from '../context/editor-runtime';
+import * as editorView from '../context/editor-view';
+import * as inspectorLayout from '../context/inspector-layout';
+import * as bindings from '../facade/bindings';
+import * as editorResources from '../services/editor-resources';
+import * as stageService from '../services/stage-service';
+import * as locales from '../../locales/runtime';
+import * as workerClient from '../../parser/worker/worker-client';
+export declare const frameShared: {
+    bindings: typeof bindings;
+    editorResources: typeof editorResources;
+    editorRuntime: typeof editorRuntime;
+    editorView: typeof editorView;
+    errors: typeof errors;
+    fieldStatus: typeof fieldStatus;
+    formContext: typeof formContext;
+    inspectorLayout: typeof inspectorLayout;
+    locales: typeof locales;
+    popupContainer: typeof popupContainer;
+    stageService: typeof stageService;
+    vue: typeof vue;
+    workerClient: typeof workerClient;
+    zIndex: typeof zIndex;
+};

package/designer/frame/view.d.ts

@@ -0,0 +1,8 @@
+import { PrintDesignerProps } from '../types';
+export interface DesignerFrameProps extends PrintDesignerProps {
+    'onDirty-change'?: (dirty: boolean) => void;
+    onDispose(): void;
+    onError(error: unknown): void;
+    onReady(): void;
+}
+export declare function mountDesignerView(container: HTMLElement, props: DesignerFrameProps): () => void;

package/designer/interactions/create.d.ts

@@ -0,0 +1,3 @@
+import { PageNode } from '../../core/types';
+import { EditorStore } from '../stores/editor-store';
+export declare function beginCreateDrag(store: EditorStore, event: PointerEvent, type: string, page: PageNode): void;

package/designer/interactions/geometry-update.d.ts

@@ -0,0 +1,3 @@
+import { ElementLayoutPatch, PageNode } from '../../core/types';
+import { EditorStore } from '../stores/editor-store';
+export declare function createGeometryUpdater(store: EditorStore, page: PageNode): (patches: ElementLayoutPatch[]) => ElementLayoutPatch[];

package/designer/interactions/guides.d.ts

@@ -0,0 +1,7 @@
+import { Guide, PageNode } from '../../core/types';
+import { EditorStore } from '../stores/editor-store';
+export interface BeginGuideDragOptions {
+    /** 未越过拖动阈值时丢弃从标尺新建的参考线。 */
+    discardIfUnmoved?: boolean;
+}
+export declare function beginGuideDrag(store: EditorStore, event: PointerEvent, page: PageNode, guide: Guide, options?: BeginGuideDragOptions): void;

package/designer/interactions/marquee.d.ts

@@ -0,0 +1,3 @@
+import { PageNode } from '../../core/types';
+import { EditorStore } from '../stores/editor-store';
+export declare function beginMarqueeDrag(store: EditorStore, event: PointerEvent, page: PageNode): void;

package/designer/interactions/move.d.ts

@@ -0,0 +1,3 @@
+import { PageNode } from '../../core/types';
+import { EditorStore } from '../stores/editor-store';
+export declare function beginMoveDrag(store: EditorStore, event: PointerEvent, nodeId: string, page: PageNode): void;

package/designer/interactions/point.d.ts

@@ -0,0 +1,3 @@
+import { PageNode } from '../../core/types';
+import { EditorStore } from '../stores/editor-store';
+export declare function beginPointDrag(store: EditorStore, event: PointerEvent, nodeId: string, pointIndex: number, page: PageNode): void;

package/designer/interactions/pointer-drag.d.ts

@@ -0,0 +1,3 @@
+import { PointerDragHandle, PointerDragOptions } from '../../core/pointer-drag';
+import { EditorStore } from '../stores/editor-store';
+export declare function startStagePointerDrag(store: EditorStore, options: PointerDragOptions): PointerDragHandle;

package/designer/interactions/resize-strategies.d.ts

@@ -0,0 +1,23 @@
+import { ElementRegistry } from '../../core/element-registry';
+import { HandleId, Point } from '../../core/geometry';
+import { ElementNode, PageNode } from '../../core/types';
+import { SnapOptions } from './snap';
+interface ResizeOptions {
+    elements?: ElementRegistry;
+    excludeIds: Set<string>;
+    handle: HandleId;
+    keepRatio: boolean;
+    page: PageNode;
+    snap: SnapOptions;
+}
+interface ResizeResult {
+    hLines: number[];
+    patches: {
+        id: string;
+        patch: Partial<ElementNode>;
+    }[];
+    vLines: number[];
+}
+type ResizeStrategy = (mouse: Point, startPoint: Point, keepRatio?: boolean) => ResizeResult;
+export declare function createResizeStrategy(nodes: ElementNode[], options: ResizeOptions): ResizeStrategy | undefined;
+export {};

package/designer/interactions/snap.d.ts

@@ -0,0 +1,48 @@
+import { Rect } from '../../core/geometry';
+import { PageNode } from '../../core/types';
+export interface SnapOptions {
+    gridSize: number;
+    snapElements: boolean;
+    snapGrid: boolean;
+    snapGuides: boolean;
+    snapMargins?: boolean;
+    /** 吸附触发距离（mm），一般取 4px 换算 */
+    threshold: number;
+}
+export interface SnapResult {
+    dx: number;
+    dy: number;
+    hLines: number[];
+    /** 命中的竖直参考线（x 值），用于绘制吸附提示线 */
+    vLines: number[];
+}
+/** 4 CSS px 换算为毫米的吸附触发阈值（随画布缩放变化） */
+export declare function snapThresholdMm(zoom: number): number;
+export declare function computeSnap(bounds: Rect, page: PageNode, excludeIds: Set<string>, options: SnapOptions): SnapResult;
+export interface EdgeSnapResult {
+    dx: number;
+    dy: number;
+    hLines: number[];
+    vLines: number[];
+}
+/**
+ * 缩放吸附：仅把"正在移动的边"吸附到目标线（元素边/中心、参考线、页面边/中心）。
+ * movingX / movingY 为该边当前的页面坐标；null 表示该轴没有移动边（完全冻结，不参与吸附）。
+ * 固定锚边与矩形中心不作为吸附源，避免拖动手柄时锚点漂移。
+ */
+export declare function computeEdgeSnap(movingX: null | number, movingY: null | number, page: PageNode, excludeIds: Set<string>, options: SnapOptions): EdgeSnapResult;
+export interface PointSnapResult {
+    hLines: number[];
+    vLines: number[];
+    x: number;
+    y: number;
+}
+/**
+ * 点吸附：点驱动元素拖动顶点用。把单个点吸附到目标线（元素边/中心、
+ * 参考线、页面边/中心），未命中时回退网格。语义与 computeEdgeSnap 一致，
+ * 只是吸附源从"移动边"换成"移动点"。
+ */
+export declare function computePointSnap(point: {
+    x: number;
+    y: number;
+}, page: PageNode, excludeIds: Set<string>, options: SnapOptions): PointSnapResult;

package/designer/interactions/transform.d.ts

@@ -0,0 +1,5 @@
+import { HandleId } from '../../core/geometry';
+import { PageNode } from '../../core/types';
+import { EditorStore } from '../stores/editor-store';
+export declare function beginResizeDrag(store: EditorStore, event: PointerEvent, handle: HandleId, page: PageNode): void;
+export declare function beginRotateDrag(store: EditorStore, event: PointerEvent, nodeId: string, page: PageNode): void;

package/designer/mount-print-designer.d.ts

@@ -0,0 +1,2 @@
+import { MountedPrintDesigner, MountPrintDesignerOptions } from './types';
+export declare function mountPrintDesigner(container: HTMLElement, options?: MountPrintDesignerOptions): MountedPrintDesigner;

package/designer/plugins/builtins.d.ts

@@ -0,0 +1,6 @@
+import { EditorContext } from '../context/editor-context';
+import { DesignerPlugin } from './types';
+export { builtinEventsPlugin } from './domain-builtins';
+export declare const builtinCommandsPlugin: DesignerPlugin;
+/** main.ts 的 installDesigner() 调用：按依赖顺序安装内置插件 */
+export declare function installBuiltinPlugins(ctx: EditorContext, use?: (plugin: DesignerPlugin) => void): void;

package/designer/plugins/context-menu-guard.d.ts

@@ -0,0 +1,2 @@
+import { DesignerPlugin } from './types';
+export declare const builtinContextMenuGuardPlugin: DesignerPlugin;

package/designer/plugins/domain-builtins.d.ts

@@ -0,0 +1,5 @@
+import { EditorContext } from '../context/editor-context';
+import { DesignerPlugin } from './types';
+export declare const builtinEventsPlugin: DesignerPlugin;
+export declare function installDomainPlugins(ctx: EditorContext): void;
+export declare const domainCommandsPlugin: DesignerPlugin;

package/designer/plugins/element-previews.d.ts

@@ -0,0 +1,2 @@
+import { DesignerPlugin } from './types';
+export declare const elementPreviewsPlugin: DesignerPlugin;

package/designer/plugins/error-handling.d.ts

@@ -0,0 +1,5 @@
+import { ErrorRuntime } from '../../components/error-fallback/core';
+import { DesignerPlugin } from './types';
+/** 全局错误运行时单例（Vue / 浏览器适配器、ErrorBoundary、store 初始化共用） */
+export declare function getErrorRuntime(): ErrorRuntime;
+export declare const errorHandlingPlugin: DesignerPlugin;

package/designer/plugins/extension-points.d.ts

@@ -0,0 +1,34 @@
+import { PluginContext } from './plugin-context';
+import { PluginDisposer, PluginPermission } from './types';
+export declare const PLUGIN_API_VERSION: "1.0";
+export type ExtensionKind = 'button' | 'data' | 'hook' | 'menu' | 'override' | 'slot' | 'tab';
+export interface ExtensionOwner {
+    readonly context: PluginContext;
+    readonly pluginId: string;
+    readonly signal: AbortSignal;
+}
+export interface ExtensionPointDefinition<T> {
+    readonly apiVersion: string;
+    readonly id: string;
+    readonly kind: ExtensionKind;
+    readonly mount?: (value: T, owner: ExtensionOwner) => PluginDisposer;
+    readonly permission?: PluginPermission;
+    readonly validate: (value: unknown) => value is T;
+}
+export interface ExtensionContribution<T = unknown> {
+    readonly apiVersion: string;
+    readonly id: string;
+    readonly order?: number;
+    readonly point: string;
+    readonly value: T;
+}
+export interface ExtensionEntry<T = unknown> extends ExtensionContribution<T> {
+    readonly pluginId: string;
+}
+export declare class ExtensionPointRegistry {
+    #private;
+    contribute<T>(owner: ExtensionOwner, contribution: ExtensionContribution<T>): PluginDisposer;
+    define<T>(definition: ExtensionPointDefinition<T>): PluginDisposer;
+    describe(id: string): Readonly<Pick<ExtensionPointDefinition<unknown>, 'apiVersion' | 'id' | 'kind' | 'permission'>>;
+    list<T = unknown>(point: string): readonly ExtensionEntry<T>[];
+}

package/designer/plugins/follow-layout.d.ts

@@ -0,0 +1,2 @@
+import { DesignerPlugin } from './types';
+export declare const followLayoutPlugin: DesignerPlugin;

package/designer/plugins/panels.d.ts

@@ -0,0 +1,2 @@
+import { DesignerPlugin } from './types';
+export declare const panelsPlugin: DesignerPlugin;

package/designer/plugins/plugin-bootstrap.d.ts

@@ -0,0 +1,5 @@
+import { RegistryOptions } from '../../runtime/registries';
+import { PluginResources } from './types';
+export declare function registerPluginResourceLocales(resources?: readonly PluginResources[]): () => void;
+/** 资源先于文档加载，交互插件仍由插件管理器在上下文就绪后装配。 */
+export declare function preparePluginRegistries(options: RegistryOptions, resources?: readonly PluginResources[]): RegistryOptions;

package/designer/plugins/plugin-canvas.d.ts

@@ -0,0 +1,29 @@
+import { ElementDefinition } from '../../core/element-registry';
+import { ElementNode, PageNode } from '../../core/types';
+import { EditorContext } from '../context/editor-context';
+import { ElementPatch } from '../../studio-types';
+import { PluginScope } from './plugin-scope';
+import { PluginPermission } from './types';
+export interface PluginElementEdit {
+    cancel(): void;
+    finish(): void;
+    update(patch: ElementPatch): boolean;
+}
+/** 插件画布适配器：几何交互由插件实现，文档修改仍经过宿主 action。 */
+export declare function createPluginCanvas(host: EditorContext, scope: PluginScope, assert: (permission?: PluginPermission) => void): {
+    activate(pageId: string): void;
+    readonly activeTool: string;
+    add(type: string, patch: Partial<ElementNode>, pageId: string): void;
+    beginEdit(id: string): PluginElementEdit | undefined;
+    readonly pages: PageNode[];
+    readonly panning: boolean;
+    readonly previewing: boolean;
+    readonly pxPerMm: number;
+    registerElement(definition: ElementDefinition, options?: {
+        replace?: boolean;
+    }): () => void;
+    readonly selection: ElementNode[];
+    setTool(id: string): void;
+    surface(pageId: string, root?: HTMLElement): HTMLElement | undefined;
+};
+export type PluginCanvas = ReturnType<typeof createPluginCanvas>;