@ptengine/inline-editor 0.0.0-stage → 0.1.0

package/dist/kernel/shrinkImageForUpload.js

@@ -0,0 +1,61 @@
+export const AI_UPLOAD_LIMITS = {
+    maxBytes: 5 * 1024 * 1024,
+    maxWidth: 1024,
+    maxHeight: 8000
+};
+export const JPEG_QUALITY_LADDER = [0.85, 0.7, 0.55];
+export function planShrink(size, limits) {
+    const scale = Math.min(1, limits.maxWidth / size.width, limits.maxHeight / size.height);
+    if (scale >= 1)
+        return { scale: 1, width: size.width, height: size.height };
+    return {
+        scale,
+        width: Math.max(1, Math.round(size.width * scale)),
+        height: Math.max(1, Math.round(size.height * scale))
+    };
+}
+const browserDeps = {
+    async decode(blob) {
+        const bitmap = await createImageBitmap(blob);
+        return { width: bitmap.width, height: bitmap.height, source: bitmap };
+    },
+    async encode(image, plan, quality) {
+        const canvas = document.createElement('canvas');
+        canvas.width = plan.width;
+        canvas.height = plan.height;
+        const ctx = canvas.getContext('2d');
+        if (!ctx)
+            throw new Error('canvas 2d context unavailable');
+        ctx.drawImage(image.source, 0, 0, plan.width, plan.height);
+        return new Promise((resolve, reject) => {
+            canvas.toBlob(b => (b ? resolve(b) : reject(new Error('toBlob returned null'))), 'image/jpeg', quality);
+        });
+    }
+};
+export async function shrinkImageForUpload(blob, limits = AI_UPLOAD_LIMITS, deps = browserDeps) {
+    let image;
+    try {
+        image = await deps.decode(blob);
+    }
+    catch {
+        return blob;
+    }
+    const plan = planShrink(image, limits);
+    if (plan.scale === 1 && blob.size <= limits.maxBytes && blob.type === 'image/jpeg')
+        return blob;
+    let best = null;
+    for (const quality of JPEG_QUALITY_LADDER) {
+        let encoded;
+        try {
+            encoded = await deps.encode(image, plan, quality);
+        }
+        catch {
+            break;
+        }
+        if (!best || encoded.size < best.size)
+            best = encoded;
+        if (encoded.size <= limits.maxBytes)
+            return encoded;
+    }
+    return best ?? blob;
+}

package/dist/kernel/useCanvasBridge.d.ts

@@ -0,0 +1,36 @@
+import type { HandshakeResult } from '@ptengine/inline-core/protocol';
+/**
+ * 插件上报 id 用的根节点属性。⚠️ 与 ptengine-kit `extensionIdBeacon.ts` 逐字一致，
+ * 改一边必须改另一边。插件只在 externally_connectable 白名单的 origin 上写它。
+ */
+export declare const EXTENSION_ID_ATTR = "data-ptengine-kit-id";
+/**
+ * 本次要通信的扩展 id：配了就用配置（`configureInlineEditor`，严格模式），没配就读插件上报的（内测模式）。
+ * 读不到返回空串 —— 调用方据此判 NO_EXTENSION，绝不把空 id 传给 chrome.runtime。
+ *
+ * 扩展 id 由消费方经 `configureInlineEditor({ extensionId })` 配置。**非空 = 严格模式**：
+ * 只认这一个 id（正式上线填商店 id）。不配 = 内测模式：id 改由插件在产品页根节点上报
+ * （`EXTENSION_ID_ATTR`）。unpacked 构建没有 manifest `key`，id 由加载路径派生、每个人都不一样，
+ * 构建时烤一个 id 进产物只对一个人成立。
+ *
+ * 只换了「id 从哪来」，通信方式不变：照旧 externally_connectable + sendMessage / connect，
+ * 扩展侧照旧按 origin 白名单放行。
+ */
+export declare function getExtensionId(): string;
+/**
+ * 「忘配 extensionId」与「用户没装插件」原本是两种故障（EXTENSION_ID_MISSING /
+ * NO_EXTENSION）。内测模式下不配 id 是**合法配置**（id 由插件上报），所以这里恒为真；
+ * 读不到上报的 id 只说明插件没装 / 没在本页生效，落 NO_EXTENSION、走安装引导。
+ *
+ * 保留这个函数与 EXTENSION_ID_MISSING：外部调用方与失败原因枚举不用跟着改。
+ */
+export declare function isExtensionIdConfigured(): boolean;
+export declare function hasExtensionChannel(): boolean;
+export declare function sendCanvasCommand<T = unknown>(msg: Record<string, unknown>): Promise<T>;
+/**
+ * 未装插件 / 握手失败一律返回 null，交由门禁（P9）决定 UI。
+ *
+ * `origins` 是要让 SW 检查 host 访问权的 pattern 列表 —— 网页上下文没有
+ * `chrome.permissions`，检测只能由 SW 做（见 HandshakeParams 的注释）。
+ */
+export declare function probeExtension(origins: string[]): Promise<HandshakeResult | null>;

package/dist/kernel/useCanvasBridge.js

@@ -0,0 +1,41 @@
+import { getInlineEditorConfig } from './config.js';
+export const EXTENSION_ID_ATTR = 'data-ptengine-kit-id';
+export function getExtensionId() {
+    const configured = getInlineEditorConfig().extensionId;
+    if (configured)
+        return configured;
+    if (typeof document === 'undefined')
+        return '';
+    return document.documentElement?.getAttribute(EXTENSION_ID_ATTR) ?? '';
+}
+export function isExtensionIdConfigured() {
+    return true;
+}
+export function hasExtensionChannel() {
+    return typeof chrome !== 'undefined' && !!chrome?.runtime?.sendMessage;
+}
+export function sendCanvasCommand(msg) {
+    const extensionId = getExtensionId();
+    if (!extensionId || !hasExtensionChannel()) {
+        return Promise.reject(new Error('NO_EXTENSION'));
+    }
+    return new Promise((resolve, reject) => {
+        chrome.runtime.sendMessage(extensionId, msg, (res) => {
+            const lastError = chrome.runtime.lastError;
+            if (lastError || !res)
+                return reject(new Error('NO_EXTENSION'));
+            if (!res.ok)
+                return reject(new Error(res.error ?? 'canvas command failed'));
+            resolve(res.result);
+        });
+    });
+}
+export async function probeExtension(origins) {
+    try {
+        const params = { origins };
+        return await sendCanvasCommand({ command: 'handshake', ...params });
+    }
+    catch {
+        return null;
+    }
+}

package/dist/kernel/useCanvasGate.d.ts

@@ -0,0 +1,22 @@
+import { type HandshakeResult, type LoadFailedReason } from '@ptengine/inline-core/protocol';
+export type GateResult = {
+    ok: true;
+    handshake: HandshakeResult;
+    /** 本会话可用的能力集（握手推导 + 产品页开关），消费方据此逐项启用 / 降级。 */
+    capabilities: Set<string>;
+} | {
+    ok: false;
+    reason: LoadFailedReason;
+};
+/**
+ * 门禁四道：① 构建时配了扩展 id 没有 ② 插件装没装 ③ 契约是否兼容（见下）
+ * ④ 目标域 + 产品页自身域的 Site access 有没有被用户收回。
+ *
+ * ③④ 都只能靠扩展回答：`chrome.permissions` **只存在于扩展上下文**，
+ * externally_connectable 放行的普通网页拿到的 `chrome` 只有 loadTimes / csi / app /
+ * runtime（runtime 又只有 connect / sendMessage / id）—— 产品页里读
+ * `chrome.permissions.contains` 恒为 undefined。所以这里把两个 origin pattern 交给 SW，
+ * 由 SW 判定后随 handshake 回传 `hasHostAccess`。
+ * （`<all_urls>` 只在 manifest 里声明，用户可在扩展详情页改成 "On click" 把它收回。）
+ */
+export declare function checkCanvasGate(targetUrl: string): Promise<GateResult>;

package/dist/kernel/useCanvasGate.js

@@ -0,0 +1,35 @@
+import { isExtensionIdConfigured, probeExtension } from './useCanvasBridge.js';
+import { capabilitiesFromHandshake, missingCoreCapabilities } from './canvasCapabilities.js';
+import { CONTRACT_VERSION } from '@ptengine/inline-core/protocol';
+function productOriginPattern() {
+    return `${location.origin}/*`;
+}
+function originPattern(url) {
+    try {
+        return `${new URL(url).origin}/*`;
+    }
+    catch {
+        return null;
+    }
+}
+export async function checkCanvasGate(targetUrl) {
+    if (!isExtensionIdConfigured())
+        return { ok: false, reason: 'EXTENSION_ID_MISSING' };
+    const pattern = originPattern(targetUrl);
+    if (!pattern)
+        return { ok: false, reason: 'NAV_AWAY' };
+    const handshake = await probeExtension([pattern, productOriginPattern()]);
+    if (!handshake)
+        return { ok: false, reason: 'NO_EXTENSION' };
+    const minSupported = handshake.minSupportedContractVersion ?? handshake.contractVersion;
+    if (CONTRACT_VERSION < minSupported) {
+        return { ok: false, reason: 'CONTRACT_MISMATCH' };
+    }
+    const capabilities = capabilitiesFromHandshake(handshake);
+    if (missingCoreCapabilities(capabilities).length > 0) {
+        return { ok: false, reason: 'CONTRACT_MISMATCH' };
+    }
+    if (!handshake.hasHostAccess)
+        return { ok: false, reason: 'PERMISSION_DENIED' };
+    return { ok: true, handshake, capabilities };
+}

package/dist/kernel/useCanvasSession.d.ts

@@ -0,0 +1,44 @@
+import { type CanvasDevice, type HandshakeResult, type LoadFailedReason, type ReadyPayload } from '@ptengine/inline-core/protocol';
+import type { CanvasStreamMessage } from './useCanvasStream.js';
+type State = 'gating' | 'opening' | 'loading' | 'ready' | 'failed';
+interface FrameProps {
+    sessionId: string;
+    url: string;
+    device: CanvasDevice;
+}
+/**
+ * Port 心跳间隔。
+ *
+ * ⚠️ 这条 Port 是 SW 往产品页推事件（geometry / lifecycle / elementPicked / textEditCommit）
+ * 的**唯一**通道，而 SW 的 Port 表只在内存里。Chrome 回收空闲 SW 时 Port 随之断开，SW 被下
+ * 一条消息唤醒后 Port 表是空的 —— agent 的每一条事件都被静默丢掉，命令（走 sendMessage）
+ * 却照常能用。真机表现：分析画布放着等 agent 想几分钟，之后区块框再也不跟随滚动、编辑器
+ * 点元素没反应，零报错。
+ *
+ * 真机实测（Chrome 153，2026-09-24）：
+ * - 画布空闲约 6 分钟 Port 断开；
+ * - 期间有流量（agent 推事件、或产品页经 Port 发消息）就不会断 —— 所以心跳走 Port 本身；
+ * - 只靠断开后重连不够：新起的 SW 空闲 30 秒又被回收，会陷入每 30 秒断一次的循环。
+ *
+ * 取 20s：落在 30s 空闲回收阈值之内，留出定时器在后台标签页被节流的余量。
+ */
+export declare const PORT_KEEPALIVE_MS = 20000;
+/**
+ * 画布会话编排：门禁 → open（装 DNR 规则）→ 挂 iframe → 等扩展回报 ready。
+ * 顺序是硬要求：规则必须在 iframe 发起导航之前就位，否则第一次加载会被 XFO 挡住。
+ */
+export declare function useCanvasSession(input: {
+    url: string;
+    device: CanvasDevice;
+    /** agent 主动发来的流（lifecycle / geometry / elementPicked / …）转出去给 useCanvasStream 消费。 */
+    onStreamEvent?: (msg: CanvasStreamMessage) => void;
+}): {
+    state: State;
+    reason: LoadFailedReason | undefined;
+    portError: string | null;
+    frameProps: FrameProps | null;
+    handshake: HandshakeResult | undefined;
+    readyPayload: ReadyPayload | undefined;
+    capabilities: Set<string> | undefined;
+};
+export {};

package/dist/kernel/useCanvasSession.js

@@ -0,0 +1,182 @@
+import { useEffect, useRef, useState } from 'react';
+import { CANVAS_MSG_NAMESPACE } from '@ptengine/inline-core/protocol';
+import { getExtensionId, hasExtensionChannel, sendCanvasCommand } from './useCanvasBridge.js';
+import { checkCanvasGate } from './useCanvasGate.js';
+import { narrowByReady } from './canvasCapabilities.js';
+const READY_TIMEOUT_MS = 20000;
+const GATE_TIMEOUT_MS = 3000;
+export const PORT_KEEPALIVE_MS = 20000;
+const QUICK_DROP_MS = 1000;
+const MAX_QUICK_DROPS = 3;
+export function useCanvasSession(input) {
+    const [state, setState] = useState('gating');
+    const [reason, setReason] = useState();
+    const [portError, setPortError] = useState(null);
+    const [frameProps, setFrameProps] = useState(null);
+    const [handshake, setHandshake] = useState();
+    const [readyPayload, setReadyPayload] = useState();
+    const [capabilities, setCapabilities] = useState();
+    const sessionIdRef = useRef('');
+    const onStreamEventRef = useRef(input.onStreamEvent);
+    onStreamEventRef.current = input.onStreamEvent;
+    useEffect(() => {
+        let cancelled = false;
+        const sessionId = crypto.randomUUID();
+        sessionIdRef.current = sessionId;
+        setHandshake(undefined);
+        setReadyPayload(undefined);
+        setCapabilities(undefined);
+        let readyTimer;
+        const clearReadyTimer = () => {
+            if (readyTimer !== undefined) {
+                clearTimeout(readyTimer);
+                readyTimer = undefined;
+            }
+        };
+        let port = null;
+        let readyReached = false;
+        let quickDrops = 0;
+        let keepaliveTimer;
+        const stopKeepalive = () => {
+            if (keepaliveTimer !== undefined) {
+                clearInterval(keepaliveTimer);
+                keepaliveTimer = undefined;
+            }
+        };
+        const onPortMessage = (msg) => {
+            if (msg?.namespace !== CANVAS_MSG_NAMESPACE)
+                return;
+            if (msg.sessionId !== sessionIdRef.current)
+                return;
+            if (msg.event === 'ready') {
+                clearReadyTimer();
+                readyReached = true;
+                if (msg.payload) {
+                    const payload = msg.payload;
+                    setReadyPayload(payload);
+                    setCapabilities(prev => (prev ? narrowByReady(prev, payload) : prev));
+                }
+                setState('ready');
+                return;
+            }
+            onStreamEventRef.current?.(msg);
+        };
+        const connectPort = () => {
+            let next;
+            try {
+                next = chrome.runtime.connect(getExtensionId(), { name: CANVAS_MSG_NAMESPACE });
+            }
+            catch {
+                port = null;
+                return;
+            }
+            port = next;
+            const connectedAt = Date.now();
+            next.onMessage.addListener(onPortMessage);
+            next.onDisconnect.addListener(() => {
+                const connectError = chrome.runtime?.lastError?.message;
+                if (connectError) {
+                    console.warn('[inline-editor] canvas port disconnected', connectError);
+                }
+                if (next !== port)
+                    return;
+                stopKeepalive();
+                port = null;
+                if (cancelled)
+                    return;
+                if (readyReached) {
+                    if (connectError)
+                        return;
+                    quickDrops = Date.now() - connectedAt < QUICK_DROP_MS ? quickDrops + 1 : 0;
+                    if (quickDrops >= MAX_QUICK_DROPS)
+                        return;
+                    connectPort();
+                    return;
+                }
+                clearReadyTimer();
+                setState(prev => {
+                    if (prev === 'ready')
+                        return prev;
+                    setReason('NO_EXTENSION');
+                    setPortError(connectError ?? null);
+                    return 'failed';
+                });
+            });
+            stopKeepalive();
+            keepaliveTimer = setInterval(() => {
+                try {
+                    next.postMessage({ namespace: CANVAS_MSG_NAMESPACE, event: 'keepalive' });
+                }
+                catch {
+                }
+            }, PORT_KEEPALIVE_MS);
+        };
+        if (getExtensionId() && hasExtensionChannel())
+            connectPort();
+        let gateTimer;
+        const clearGateTimer = () => {
+            if (gateTimer !== undefined) {
+                clearTimeout(gateTimer);
+                gateTimer = undefined;
+            }
+        };
+        (async () => {
+            const gateTimeout = new Promise(resolve => {
+                gateTimer = setTimeout(() => {
+                    resolve({ ok: false, reason: 'TIMEOUT' });
+                }, GATE_TIMEOUT_MS);
+            });
+            const gate = await Promise.race([checkCanvasGate(input.url), gateTimeout]);
+            clearGateTimer();
+            if (cancelled)
+                return;
+            if (gate.ok === false) {
+                setReason(gate.reason);
+                setState('failed');
+                return;
+            }
+            setHandshake(gate.handshake);
+            setCapabilities(gate.capabilities);
+            setState('opening');
+            readyTimer = setTimeout(() => {
+                if (cancelled)
+                    return;
+                setState(prev => {
+                    if (prev === 'ready' || prev === 'failed')
+                        return prev;
+                    setReason('TIMEOUT');
+                    return 'failed';
+                });
+            }, READY_TIMEOUT_MS);
+            try {
+                await sendCanvasCommand({
+                    command: 'open',
+                    sessionId,
+                    url: input.url,
+                    device: input.device
+                });
+            }
+            catch {
+                if (!cancelled) {
+                    clearReadyTimer();
+                    setReason('NO_EXTENSION');
+                    setState('failed');
+                }
+                return;
+            }
+            if (cancelled)
+                return;
+            setFrameProps({ sessionId, url: input.url, device: input.device });
+            setState('loading');
+        })();
+        return () => {
+            cancelled = true;
+            clearGateTimer();
+            clearReadyTimer();
+            stopKeepalive();
+            void sendCanvasCommand({ command: 'destroy', sessionId }).catch(() => { });
+            port?.disconnect();
+        };
+    }, [input.url, input.device]);
+    return { state, reason, portError, frameProps, handshake, readyPayload, capabilities };
+}

package/dist/kernel/useCanvasStream.d.ts

@@ -0,0 +1,39 @@
+import { type CanvasDocumentSizePayload, type CanvasGeometryPayload, type CanvasLifecyclePayload, type CanvasPickedPayload, type CanvasTextEditPayload } from '@ptengine/inline-core/protocol';
+export interface CanvasStreamMessage {
+    namespace?: string;
+    event?: string;
+    sessionId?: string;
+    payload?: unknown;
+}
+/**
+ * 消费 Port 上 agent 主动发来的流：生命周期事件（时间线）、选中、几何帧、文字编辑回程、
+ * 文档尺寸变化。
+ *
+ * 与短命令（`canvasCommands.ts`）是**两套机制**，不要混（D2）：短命令走 sendMessage
+ * 回调链、天然请求-响应配对；这里是单向流。
+ *
+ * v11 起不再有整页 DOM 分片（`domChunk` / `getDom`）：agent 曾在每次加载后推两次整页 HTML
+ * （上限 8MB），而产品页拼好的快照没有任何消费者 —— 白白序列化、传输，还多一份数据暴露。
+ * 契约 v11 把它删了（inline-core `docs/contract-v11-design.md` §6）。
+ *
+ * **契约：调用方必须在切换会话（`sessionId` 变化）时调用 `reset()`**——传入
+ * `sessionId` 参数即可自动做到这一点（见下方 effect）；如果不传，调用方要自己在
+ * `useCanvasSession` 的 `sessionId` 变化时手动调 `reset()`，否则 `timeline` 会把两次会话的
+ * 生命周期事件混在一条列表里，出现两组 `injected/domReady/loaded` 且 `seq` 重复。
+ */
+export declare function useCanvasStream(sessionId?: string, onGeometry?: (payload: CanvasGeometryPayload) => void, onTextEditCommit?: (payload: CanvasTextEditPayload) => void, 
+/**
+ * 生命周期事件（带**它属于哪个会话**）。
+ *
+ * ⚠️ 存在的理由：`timeline` 是跨会话累积的，从它 `some()` 出来的 domReady 会让
+ * 新会话一诞生就"已经就绪"。消费方要的是「**这个** sessionId 就绪了没有」，
+ * 那个信息只有事件信封上有，timeline 里的 payload 不带。
+ */
+onLifecycle?: (payload: CanvasLifecyclePayload, sessionId: string | undefined) => void, 
+/** v11：`observeDocumentSize` 打开后的尺寸变化帧。与 geometry 同理不进 state，直接交给回调。 */
+onDocumentSize?: (payload: CanvasDocumentSizePayload) => void): {
+    timeline: CanvasLifecyclePayload[];
+    picked: CanvasPickedPayload | null;
+    onStreamEvent: (msg: CanvasStreamMessage) => void;
+    reset: () => void;
+};

package/dist/kernel/useCanvasStream.js

@@ -0,0 +1,45 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { CANVAS_MSG_NAMESPACE } from '@ptengine/inline-core/protocol';
+export function useCanvasStream(sessionId, onGeometry, onTextEditCommit, onLifecycle, onDocumentSize) {
+    const [timeline, setTimeline] = useState([]);
+    const [picked, setPicked] = useState(null);
+    const onStreamEvent = useCallback((msg) => {
+        if (msg?.namespace !== CANVAS_MSG_NAMESPACE)
+            return;
+        if (msg.event === 'lifecycle') {
+            const payload = msg.payload;
+            setTimeline(prev => [...prev, payload]);
+            onLifecycle?.(payload, msg.sessionId);
+            return;
+        }
+        if (msg.event === 'elementPicked') {
+            setPicked(msg.payload);
+            return;
+        }
+        if (msg.event === 'textEditCommit') {
+            onTextEditCommit?.(msg.payload);
+            return;
+        }
+        if (msg.event === 'geometry') {
+            onGeometry?.(msg.payload);
+            return;
+        }
+        if (msg.event === 'documentSize') {
+            onDocumentSize?.(msg.payload);
+        }
+    }, [onGeometry, onTextEditCommit, onLifecycle, onDocumentSize]);
+    const reset = useCallback(() => {
+        setTimeline([]);
+        setPicked(null);
+    }, []);
+    const sessionIdRef = useRef(sessionId);
+    useEffect(() => {
+        if (sessionId === undefined)
+            return;
+        if (sessionIdRef.current === sessionId)
+            return;
+        sessionIdRef.current = sessionId;
+        reset();
+    }, [sessionId, reset]);
+    return { timeline, picked, onStreamEvent, reset };
+}

package/dist/kernel/useMobileFit.d.ts

@@ -0,0 +1,40 @@
+import type { CanvasDevice, CanvasDocumentSizePayload } from '@ptengine/inline-core/protocol';
+/**
+ * 移动端超宽缩小的**编排**（算法见 `mobileFit.ts`）。
+ *
+ * 触发条件全部满足才动：`device === 'mobile'`、当前会话 domReady、插件回报了
+ * `measureDocument` + `setStyleLayer`（老插件 / `disabledCapabilities` 配置关掉其一 →
+ * 原样不缩，和 v11 之前一致）。`observeDocumentSize` 是锦上添花：没有它只在 domReady 时缩一次。
+ *
+ * 流程（每个会话一次）：量（摘掉 `mobile-fit` 层）→ 按需写 `render-fixes` 层并重量 → 写 `mobile-fit`
+ * 层 → 打开尺寸观察。之后每帧 `documentSize`：**宽度变了才重跑整套**（懒加载、轮播初始化会把
+ * scrollWidth 撑大），只有高度变就只改 `height`。宽度不变就什么都不做 —— 这是不和自己的样式层
+ * 互相触发的关键（engage-editor 用 `isApplyingScale` 锁干的是同一件事）。
+ *
+ * 所有命令失败都静默：缩放是增强，失败的后果只是「和以前一样横向溢出」，不值得让编辑器进 failed。
+ */
+export interface MobileFitState {
+    /** 当前施加在 `<html>` 上的比例；1 = 没缩。热图坐标对齐、文档坐标换算要除以它（设计稿 §8.5）。 */
+    scale: number;
+    /** 自然宽高；`null` = 还没量过（非移动端 / 能力缺失 / 还没 domReady）。 */
+    naturalWidth: number | null;
+    naturalHeight: number | null;
+    /**
+     * 当前会话的首轮缩放还没落地。会缩的页面在这段窗口里 `scale` 还是 1 —— 宿主拿比例去对
+     * 热图坐标（`resolveBlocks` 的 band、区块框、截图标注）必须等它变 false，否则对的是缩放前
+     * 的页面。不会缩（PC / 能力缺失）时恒为 false，与之前的时序完全一致。
+     */
+    pending: boolean;
+}
+export interface UseMobileFitInput {
+    sessionId: string | undefined;
+    device: CanvasDevice;
+    domReady: boolean;
+    capabilities: Set<string> | undefined;
+}
+export interface UseMobileFitResult {
+    state: MobileFitState;
+    /** 接到 `useCanvasStream` 的 `onDocumentSize`。引用恒定。 */
+    onDocumentSize: (payload: CanvasDocumentSizePayload) => void;
+}
+export declare function useMobileFit(input: UseMobileFitInput): UseMobileFitResult;