@proteus-vue/render-backend 0.1.0

package/dist/native.d.ts

@@ -0,0 +1,42 @@
+import type { ProteusRenderBackend } from './spi';
+/** 原生视图描述（G-27 语义节点在原生后端的表示） */
+export interface NativeViewDescriptor {
+    id: number;
+    /** 语义标签（view/text/button/...——宿主映射到 UIView/View/ArkUI 组件） */
+    type: string;
+    props: Record<string, unknown>;
+    children: NativeViewDescriptor[];
+    parent: NativeViewDescriptor | null;
+    text: string;
+    /** 宿主句柄（adapter.createView 返回值；无宿主 = 自身） */
+    handle: unknown;
+}
+/** 宿主适配器（iOS/Android/鸿蒙 SDK 桥实现本接口；mock 见 createMockNativeAdapter） */
+export interface NativeViewAdapter {
+    /** 创建宿主视图（返回宿主句柄——UIView / View / ArkUI Node） */
+    createView(descriptor: NativeViewDescriptor): unknown;
+    /** 属性/样式/事件同步到宿主（key=onXxx 为事件 → 原生手势桥） */
+    updateView(handle: unknown, key: string, prev: unknown, next: unknown): void;
+    /** 插入子视图（anchor 可选） */
+    insertView(child: unknown, parent: unknown, anchor?: unknown): void;
+    /** 移除视图 */
+    removeView(child: unknown): void;
+    /** 文本同步 */
+    setViewText(handle: unknown, text: string): void;
+}
+export interface MockNativeAdapter extends NativeViewAdapter {
+    /** 操作日志（断言 create/insert/update/remove/setText 顺序） */
+    ops: string[];
+}
+/** 内置 mock 适配器（无宿主环境验证接线；真实平台 B4 后接 SDK 实现替换） */
+export declare function createMockNativeAdapter(): MockNativeAdapter;
+/** 原生平台（iOS UIKit / Android Jetpack / 鸿蒙 ArkUI） */
+export type NativePlatform = 'ios' | 'android' | 'harmony';
+/**
+ * NativeBackend：nodeOps → 原生视图（B4——验证「nodeOps → UIView」抽象层；G-31 B3 三平台语义映射）
+ * - 维护 NativeViewDescriptor 树（nodeOps 层句柄，唯一 id）
+ * - 所有变更同步宿主 adapter（createView/updateView/insertView/removeView/setViewText）
+ * - adapter 缺省 mock（ops 日志）；真实平台注入 SDK 桥
+ * - platform：ios（UIKit 基准）/ android（Jetpack）/ harmony（ArkUI）——决定 id + semantic 映射表
+ */
+export declare function createNativeBackend(adapter?: NativeViewAdapter, platform?: NativePlatform): ProteusRenderBackend;

package/dist/ownership-observability.d.ts

@@ -0,0 +1,99 @@
+import type { GraphEdge, GraphNode, LeakInfo, OwnershipGraph } from './ownership';
+export type OwnershipRecordKind = 'alloc' | 'drop' | 'moved' | 'borrow' | 'weak' | 'strong';
+export interface OwnershipRecord {
+    readonly ts: number;
+    readonly kind: OwnershipRecordKind;
+    readonly id?: string;
+    readonly owner?: string | null;
+    readonly type?: string;
+    readonly byteSize?: number;
+    readonly sourceLocation?: string | null;
+    /** borrow/weak/strong 的引用方（edge.from） */
+    readonly from?: string;
+    /** edge.to（borrow/weak/strong 的目标资源） */
+    readonly to?: string;
+}
+export interface OwnershipHistoryOptions {
+    /** 环形缓冲上限（缺省 2000——V-06 时间线消费，超限丢最旧） */
+    readonly limit?: number;
+    /** 缺省 true；生产期可关（setEnabled(false)——仅计数仍开） */
+    readonly enabled?: boolean;
+}
+export interface OwnershipHistory {
+    readonly records: readonly OwnershipRecord[];
+    enabled: boolean;
+    setEnabled(v: boolean): void;
+    clear(): void;
+    /** 解绑图订阅并清空（面板/诊断生命周期结束） */
+    dispose(): void;
+}
+/** ★G-43 B4：历史时间线——订阅 graph mutation 记录 alloc/drop/borrow/weak/strong（面板/诊断消费） */
+export declare function createOwnershipHistory(graph: OwnershipGraph, opts?: OwnershipHistoryOptions): OwnershipHistory;
+export interface TypeCounter {
+    readonly allocated: number;
+    readonly alive: number;
+}
+export interface OwnershipCounters {
+    readonly alive: number;
+    readonly total: number;
+    readonly bytesAlive: number;
+    readonly byType: Readonly<Record<string, TypeCounter>>;
+    /** V-01 一致性：计数器与图 stats 同步（counter 模式下的自证） */
+    consistent(): boolean;
+}
+/** ★G-43 B4：计数器采样（V-07——生产期开销 O(1) 每资源；完整历史可单独关闭） */
+export declare function createOwnershipCounters(graph: OwnershipGraph): OwnershipCounters;
+export interface LongBorrow {
+    readonly resourceId: string;
+    readonly type: string;
+    readonly owner: string | null;
+    readonly borrowedBy: string;
+    readonly sinceMs: number;
+}
+export interface CrossPageRef {
+    readonly resourceId: string;
+    readonly type: string;
+    readonly owner: string | null;
+    /** 跨页强持有的引用方（strong edge.from——显式登记，见 GraphEdge.kind 'strong'） */
+    readonly heldBy: string;
+}
+export interface OwnershipDiagnosisOptions {
+    /** 已销毁页面 scope（V-02 泄漏路径输入——该域资源预期已释放） */
+    readonly destroyedScopes?: readonly string[];
+    /** 长期借用阈值（缺省 1000ms——V-03） */
+    readonly longBorrowMs?: number;
+    /** 时钟注入（测试用——缺省 Date.now） */
+    readonly now?: () => number;
+}
+export interface OwnershipDiagnosis {
+    /** V-01：图中存活节点数（与 stats 一致性在计数器模块自证） */
+    readonly aliveNodes: number;
+    readonly totalNodes: number;
+    /** V-05：无主资源（owner === null 的存活节点——必然泄漏） */
+    readonly orphans: GraphNode[];
+    /** V-02：泄漏路径（destroyedScopes 内仍存活资源 + 反向引用链 + 源码行） */
+    readonly leaks: LeakInfo[];
+    /** V-03：长期借用（借用持续时间 > longBorrowMs——借用的运行时逃逸表现） */
+    readonly longBorrows: LongBorrow[];
+    /** V-04：跨页面强引用（资源 owner=A 被 B 强持有——销毁时无法释放，应 transferTo/weak） */
+    readonly crossPageRefs: CrossPageRef[];
+}
+/** ★G-43 B4：四类检测一次跑齐（V-01~V-05——DevTools 面板/远程诊断的公共输入） */
+export declare function diagnoseOwnershipIssues(graph: OwnershipGraph, opts?: OwnershipDiagnosisOptions): OwnershipDiagnosis;
+export interface TimelineEvent extends OwnershipRecord {
+    /** 该 drop/moved 对应的 alloc 记录（V-06：每条升降可点到源码行；无 = 历史裁剪或前置分配） */
+    readonly matchedAlloc?: OwnershipRecord;
+}
+export interface OwnershipTimeline {
+    readonly events: readonly TimelineEvent[];
+    /** 未配对 alloc（历史内有 alloc 无 drop 且图节点仍 alive——可疑高亮；页面销毁 force-drop 后消失） */
+    readonly unpairedAllocs: readonly OwnershipRecord[];
+}
+/** ★G-43 B4：alloc/drop 配对时间线（V-06——输入记录序列，输出可渲染事件序列 + 可疑未配对） */
+export declare function buildOwnershipTimeline(history: Pick<OwnershipHistory, 'records'>, graph: OwnershipGraph): OwnershipTimeline;
+export interface FormatOptions {
+    readonly sourceLabel?: string;
+}
+/** ★G-43 B4：诊断文本报告（对齐 devtools-ownership-graph.md §2.1 主视图叙事） */
+export declare function formatOwnershipDiagnosis(d: OwnershipDiagnosis, opts?: FormatOptions): string;
+export type { GraphEdge, GraphNode };

package/dist/ownership.d.ts

@@ -0,0 +1,206 @@
+export type OwnershipErrorCode = 'use_after_move' | 'use_after_drop' | 'double_move' | 'has_active_borrows' | 'already_dropped' | 'resource_not_transferable';
+export declare class OwnershipError extends Error {
+    readonly code: OwnershipErrorCode;
+    readonly resourceId: string;
+    constructor(code: OwnershipErrorCode, message: string, extra: {
+        resourceId: string;
+    });
+}
+export declare const OWNERSHIP_ERRORS: {
+    useAfterMove: (id: string, movedTo: string) => OwnershipError;
+    useAfterDrop: (id: string) => OwnershipError;
+    doubleMove: (id: string) => OwnershipError;
+    hasActiveBorrows: (id: string, count: number) => OwnershipError;
+    alreadyDropped: (id: string) => OwnershipError;
+    notTransferable: (id: string, reason: string) => OwnershipError;
+};
+export interface GraphNode {
+    id: string;
+    type: string;
+    byteSize: number;
+    owner: string | null;
+    state: 'alive' | 'moved' | 'dropped';
+    createdAt: number;
+    sourceLocation: string | null;
+}
+export interface GraphEdge {
+    kind: 'owns' | 'borrows' | 'weak' | 'moved-from' | 'strong';
+    from: string;
+    to: string;
+    since?: number;
+}
+/** ★G-43 B4：所有权图 mutation 事件（图变化通知——history/计数器/诊断的订阅源） */
+export type OwnershipMutation = {
+    kind: 'register';
+    id: string;
+    owner: string | null;
+    type: string;
+    byteSize: number;
+    sourceLocation: string | null;
+    ts: number;
+} | {
+    kind: 'state';
+    id: string;
+    state: 'alive' | 'moved' | 'dropped';
+    ts: number;
+} | {
+    kind: 'edge';
+    edge: GraphEdge;
+    ts: number;
+};
+export interface OwnershipGraphOptions {
+    /** ★G-43 B4：图变化订阅（history/counters/诊断的单一事件源；不提供则零开销） */
+    onMutate?: (m: OwnershipMutation) => void;
+}
+type MutateListener = (m: OwnershipMutation) => void;
+export interface LeakInfo {
+    resourceId: string;
+    type: string;
+    byteSize: number;
+    sourceLocation: string | null;
+    referenceChain: string[];
+}
+export declare class OwnershipGraph {
+    readonly nodes: Map<string, GraphNode>;
+    readonly edges: GraphEdge[];
+    private _nextId;
+    private readonly _listeners;
+    constructor(opts?: OwnershipGraphOptions);
+    nextId(): string;
+    /** ★G-43 B4：动态订阅图 mutation（可任意时刻挂接；返回解绑） */
+    subscribe(cb: MutateListener): () => void;
+    private _emit;
+    register(opts: {
+        id: string;
+        type: string;
+        byteSize: number;
+        owner?: string | null;
+        sourceLocation?: string | null;
+    }): GraphNode;
+    addEdge(edge: GraphEdge): void;
+    setState(id: string, state: GraphNode['state']): void;
+    resourcesOf(owner: string): GraphNode[];
+    /** 无主资源检测（G-43.1——owner === null 的存活节点数为 0） */
+    findOrphans(): GraphNode[];
+    /** 泄漏检测：页面销毁后仍存活的资源 + 反向引用链（谁还持有它——DevTools 泄漏定位） */
+    detectLeaks(destroyedScope: string): LeakInfo[];
+    /** 反向引用链（资源 ← 谁持有 ← 谁又持有……） */
+    backTrace(resourceId: string): string[];
+    stats(): {
+        total: number;
+        alive: number;
+        moved: number;
+        dropped: number;
+        totalBytes: number;
+        edges: number;
+    };
+}
+export declare function createQuotaTracker(): {
+    request(owner: string, bytes: number): number;
+    release(owner: string, bytes: number): number;
+    usageOf(owner: string): number;
+};
+export type OwnedState = 'alive' | 'moved' | 'dropped';
+/** ★G-43 B5：Owned 状态变化订阅（useOwned/useBorrow 响应式元信息的底座） */
+export type OwnedStateListener = (state: OwnedState) => void;
+export declare class Owned<T> {
+    readonly id: string;
+    readonly resourceType: string;
+    readonly byteSize: number;
+    readonly owner: string;
+    private _state;
+    private _movedTo;
+    private _activeBorrows;
+    private _borrows;
+    private _transferable;
+    private _releaseHook;
+    private readonly _graph;
+    private readonly _value;
+    private readonly _sourceLocation;
+    private readonly _listeners;
+    constructor(opts: {
+        id: string;
+        resourceType: string;
+        byteSize: number;
+        owner: string;
+        value: T;
+        graph: OwnershipGraph;
+        transferable?: boolean;
+        releaseHook?: (value: T) => void;
+        sourceLocation?: string | null;
+    });
+    get state(): OwnedState;
+    get activeBorrows(): number;
+    /** ★G-43 B5：订阅状态变化（moved/dropped 时通知——返回解绑） */
+    subscribe(cb: OwnedStateListener): () => void;
+    private _notify;
+    /** 存活断言（G-43.2/43.6：Move/Drop 后禁访问） */
+    private _assertAlive;
+    /** 读取（G-43.2：Move/Drop 后禁访问——use-after-move 拦截） */
+    read(): T;
+    /** ★Move 语义：转移所有权后原所有者不可再访问 */
+    transferTo(targetOwner: string): Owned<T>;
+    /** ★Borrow：临时借用（G-43.3 不逃逸作用域——drop 后失效） */
+    borrow(scopeName?: string): Borrow<T>;
+    /** ★Weak：弱引用（打破循环） */
+    weak(): Weak<T>;
+    /** ★确定性 Drop（五阶段协议） */
+    drop(opts?: {
+        force?: boolean;
+    }): {
+        ok: boolean;
+        freedBytes: number;
+        freedHandles: number;
+        invalidatedBorrows: number;
+        error?: OwnershipError;
+    };
+}
+export declare class Borrow<T> {
+    readonly borrowedAt: number;
+    private _valid;
+    private readonly _source;
+    private readonly _scopeName;
+    private readonly _graph;
+    constructor(source: Owned<T>, scopeName: string, graph: OwnershipGraph);
+    get valid(): boolean;
+    get durationMs(): number;
+    get(): T | undefined;
+    release(): void;
+    invalidate(): void;
+}
+export declare class Weak<T> {
+    private readonly _source;
+    constructor(source: Owned<T>);
+    get alive(): boolean;
+    /** 升级为借用（弱引用仅在持有者存活时可用） */
+    upgrade(): Borrow<T> | undefined;
+}
+export declare class Managed {
+    readonly value: unknown;
+    readonly owner: string;
+    disposed: boolean;
+    private readonly _disposeFn;
+    constructor(opts: {
+        value: unknown;
+        owner: string;
+        disposeFn?: () => void;
+        registry?: ManagedRegistry;
+    });
+    /** 释放（框架在页面销毁时自动调用——业务零心智负担） */
+    dispose(): boolean;
+}
+/** 框架代管注册表（页面销毁 → disposeAll——G-42.3 releaseResources 的所有权对应） */
+export declare class ManagedRegistry {
+    private readonly _items;
+    add(m: Managed): void;
+    /** 全部释放（返回释放数） */
+    disposeAll(): number;
+    get size(): number;
+}
+/**
+ * ★G-43 B4：全局默认所有权图（惰性单例）——业务/容器零配置挂接的面板数据源。
+ * 宿主也可显式建图传给容器（StackContainerOptions.ownership）或 installProteusDevtools({ ownership: { graph } })；
+ * 未显式建图时容器/面板默认消费本单例。
+ */
+export declare function getProteusOwnershipGraph(): OwnershipGraph;
+export {};

package/dist/page-ownership.d.ts

@@ -0,0 +1,55 @@
+import { Owned, ManagedRegistry, OwnershipGraph } from './ownership';
+export interface PageOwnershipOptions {
+    readonly graph: OwnershipGraph;
+    /** 页面配额上限（bytes；缺省不限额——⑤ reclaim 记账对象仍生效，销毁兜底归零） */
+    readonly quotaBytes?: number;
+}
+export interface PageAllocOptions<T> {
+    /** 缺省 'shared-buffer'（对齐 ownership-reference.cjs PageContext.alloc） */
+    readonly type?: string;
+    readonly byteSize: number;
+    /** 缺省 new ArrayBuffer(byteSize) */
+    readonly value?: T;
+    readonly transferable?: boolean;
+    readonly sourceLocation?: string | null;
+    readonly releaseHook?: (value: T) => void;
+}
+export interface PageOwnershipDestroyReport {
+    /** 成功强制释放的资源数 */
+    readonly freedCount: number;
+    /** 释放字节合计（⑤ reclaim——与 G-42 releaseQuota 合并） */
+    readonly freedBytes: number;
+    /** forceDrop 过程中被强制失效的活跃借用数 */
+    readonly invalidatedBorrows: number;
+    /** 框架代管资源释放数（G-42.3） */
+    readonly managedDisposed: number;
+    /** 销毁后页面配额剩余（验收：= 0——配额完全归还） */
+    readonly quotaRemaining: number;
+    /** force:false 时因活跃借用未能释放的资源（页面销毁场景默认 force 全清，此清单为空） */
+    readonly leaked: Array<{
+        resourceId: string;
+        reason: string;
+    }>;
+}
+/** ★G-43 B3：页面所有权上下文——业务在该页分配的资源随页面销毁确定性回收（G-42 五原子第 3 步的委托方） */
+export interface PageOwnership {
+    readonly owner: string;
+    /** 分配唯一所有权资源（登记进页面 scope + 所有权图 + 配额记账） */
+    alloc<T = ArrayBuffer>(opts: PageAllocOptions<T>): Owned<T>;
+    /** 登记页面已有 Owned（业务自建、owner 为本页的资源——销毁时一并 forceDrop） */
+    register<T>(owned: Owned<T>): void;
+    /** 页面框架代管资源注册表（new Managed({ registry })——页面销毁自动 disposeAll） */
+    readonly managed: ManagedRegistry;
+    /** 本页存活资源（所有权图快照——验收「销毁后资源计数 = 0」的数据源） */
+    resourcesOf(): ReturnType<OwnershipGraph['resourcesOf']>;
+    /**
+     * ★页面销毁回收（drop-protocol §3.2：releaseResources → 遍历本页资源逐个 Drop 五阶段）：
+     *   force=true（默认）= forceDrop——忽略活跃借用强制释放（drop ② invalidate 阶段自动失效全部借用）
+     *   force=false = drop 语义——存在活跃借用的资源跳过并列入 leaked
+     */
+    destroy(opts?: {
+        force?: boolean;
+    }): PageOwnershipDestroyReport;
+}
+/** ★G-43 B3：创建页面所有权上下文（页面 = 所有权 scope——G-42 createPage 的伴随物） */
+export declare function createPageOwnership(owner: string, opts: PageOwnershipOptions): PageOwnership;

package/dist/pss.d.ts

@@ -0,0 +1,54 @@
+import type { BorrowDiagnostic, BorrowSeverity, PssMode } from './borrow-checker';
+export type PssRule = 'P1' | 'P2' | 'P3' | 'P4' | 'P5' | 'P6' | 'P7' | 'P8' | 'P9' | 'CMP071';
+export interface PssDiagnostic {
+    rule: PssRule;
+    severity: BorrowSeverity;
+    line: number;
+    message: string;
+}
+export interface PssAnalysisResult {
+    diagnostics: PssDiagnostic[];
+    /** 声明的 PSS 模式（pragma 覆盖后） */
+    mode: PssMode;
+}
+/** ★G-43 B5：解析模块级 PSS 声明（文件头 pragma `@proteus-pss: strict`；未声明 → fallback） */
+export declare function resolvePssMode(source: string, fallback?: PssMode): PssMode;
+export interface PssAnalysisOptions {
+    mode?: PssMode;
+    /** 已分析的 Owned 变量（缺省内部调 analyzeOwnershipSource 获取） */
+    ownedVars?: string[];
+}
+/** ★G-43 B5：P1~P9 限制检测 + CMP071 ref(Owned) 拦截 */
+export declare function analyzePss(source: string, opts?: PssAnalysisOptions): PssAnalysisResult;
+export interface ScopeDropInsertion {
+    readonly varName: string;
+    /** drop 语句插入后所在行号（1-based） */
+    readonly line: number;
+}
+export interface ScopeDropResult {
+    /** 插入后的源码（无插入 = 原样） */
+    readonly code: string;
+    readonly insertions: ScopeDropInsertion[];
+}
+/** ★G-43 B5：作用域级自动 drop 插入——函数内未处置的 Owned 在函数闭合前插入 `<var>.drop()` */
+export declare function insertScopeDrops(source: string): ScopeDropResult;
+export interface PssPipelineOptions {
+    /** 全局缺省模式（文件头 pragma 可覆盖；缺省 off——渐进采用 §7.1 存量默认） */
+    mode?: PssMode;
+    /** strict 自动 drop 插入（缺省 true——「业务不写 drop 也能正确释放」） */
+    autoDrop?: boolean;
+}
+export interface PssPipelineResult {
+    /** 生效模式（pragma 覆盖后） */
+    mode: PssMode;
+    /** B 规则（B-01~B-08）+ P 限制（P1~P9/CMP071）诊断合集 */
+    diagnostics: Array<BorrowDiagnostic | PssDiagnostic>;
+    /** strict + 有 error → 阻断构建 */
+    blocksBuild: boolean;
+    ownedVars: string[];
+    /** autoDrop 后的源码（无插入 = 原样；off 模式 = 原样） */
+    code: string;
+    insertions: ScopeDropInsertion[];
+}
+/** ★G-43 B5：PSS 管线——B 规则 + P 限制 + 自动 drop 一次跑齐（编译管线在 parse 前调用的独立步骤） */
+export declare function runPss(source: string, opts?: PssPipelineOptions): PssPipelineResult;

package/dist/spi.d.ts

@@ -0,0 +1,73 @@
+export type BackendId = 'vue-dom' | 'flutter' | 'native-ios' | 'native-android' | 'native-harmony' | 'skyline' | 'skia' | 'canvas2d' | 'headless';
+/** 节点句柄（后端自己的节点表示——DOM 元素 / Flutter Element / 内存树节点……） */
+export type NodeHandle = unknown;
+/** 语义节点描述（IR 层：后端消费的中间表示，不绑定任何平台） */
+export interface IRNode {
+    type: string;
+    /** ★G-31：语义类型（layout.grid/ui.button/...）——Backend 映射 semantic 而非 tag 字符串；缺省用 type */
+    semantic?: string;
+    props: Record<string, unknown>;
+    children: IRNode[];
+    ref?: unknown;
+}
+/** 布局约束（后端可自带布局器，否则走框架 IR 求解） */
+export interface LayoutConstraints {
+    width?: number;
+    height?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+}
+export interface Size {
+    width: number;
+    height: number;
+}
+/** 归一化输入事件（后端把平台事件归一化为 Proteus 标准事件） */
+export interface NormalizedInputEvent {
+    kind: 'tap' | 'longPress' | 'scroll' | 'focus' | 'key' | 'pointer';
+    pointerType: 'touch' | 'mouse' | 'pen' | 'remote' | 'dial';
+    x?: number;
+    y?: number;
+    key?: string;
+    target: NodeHandle;
+}
+/** 外部纹理（混合渲染 Texture Sharing——原生视图混入自绘场景） */
+export interface ExternalTexture {
+    id: string;
+    nativeView?: unknown;
+    width: number;
+    height: number;
+}
+/** 能力声明（对齐 G-22 CapabilityRegistry：框架按能力降级，不按 if/else 判断平台） */
+export interface BackendCapabilities {
+    layout: 'yoga' | 'native' | 'none';
+    glass: 'L3' | 'L2' | 'L1' | 'none';
+    blur: 'true' | 'approximate' | 'none';
+    animation: 'native' | 'js' | 'none';
+    textureSharing: boolean;
+    remoteRendering: boolean;
+    ssr: boolean;
+    input: Array<'touch' | 'cursor' | 'remote' | 'dial' | 'voice'>;
+}
+/** ★G-27 核心：可插拔渲染后端接口（后端只需实现本接口即可接入任意渲染引擎） */
+export interface ProteusRenderBackend {
+    readonly id: BackendId;
+    readonly version: string;
+    readonly capabilities: BackendCapabilities;
+    createElement(node: IRNode): NodeHandle;
+    insert(child: NodeHandle, parent: NodeHandle, anchor?: NodeHandle): void;
+    remove(child: NodeHandle): void;
+    patchProp(el: NodeHandle, key: string, prev: unknown, next: unknown): void;
+    setText(el: NodeHandle, text: string): void;
+    querySelector?(selector: string): NodeHandle | null;
+    measure?(node: NodeHandle, constraints: LayoutConstraints): Size;
+    layout?(root: NodeHandle, constraints: LayoutConstraints): void;
+    scheduleFrame?(task: () => void): void;
+    flush?(): void;
+    dispatchInput?(event: NormalizedInputEvent): void;
+    onMount?(root: NodeHandle): void;
+    onUnmount?(root: NodeHandle): void;
+    registerExternalTexture?(id: string, texture: ExternalTexture): void;
+    unregisterExternalTexture?(id: string): void;
+}

package/dist/stack-container.d.ts

@@ -0,0 +1,43 @@
+import type { PageOwnership } from './page-ownership';
+import type { OwnershipGraph } from './ownership';
+import type { PageConfig, PageHandle, ProteusHostContainer, QuotaHandle, QuotaManager, ResourcePool, StackPolicy } from './container-spi';
+export interface PoolTimer {
+    readonly id: string;
+    readonly label: string;
+    cleared: boolean;
+    cancel(): void;
+}
+export interface ManagedResource {
+    readonly id: string;
+    released: boolean;
+}
+/** ★G-42.3：框架代管资源池——业务不再裸用 setTimeout/addEventListener */
+export declare function createResourcePool(ownerLabel: string): ResourcePool & {
+    readonly total: number;
+};
+export declare function createQuotaManager(limitBytes: number): QuotaManager & {
+    attach(scope: string, bytes: number): QuotaHandle | null;
+};
+export interface StackContainerOptions {
+    policy?: StackPolicy;
+    quotaLimitBytes?: number;
+    /** 页面 IR 工厂（config.irId → IR 实例；容器持有但不解析内容——G-42.4） */
+    createIR?: (config: PageConfig) => unknown;
+    /** ★G-43 B3：所有权图接入——启用后每页创建所有权上下文（G-42 五原子第 3 步委托 G-43 Drop 协议） */
+    ownership?: {
+        graph: OwnershipGraph;
+        /** 页面所有权配额上限（bytes；缺省不限额——destroy 兜底归零仍生效） */
+        quotaBytes?: number;
+    };
+}
+export interface StackContainer extends ProteusHostContainer {
+    readonly id: 'stack';
+    /** 当前栈（不修改只读视图） */
+    readonly stackView: readonly PageHandle[];
+    /** 内部事件（'overflow-destroyed'/'page-destroyed' 等——CMP060 显式事件） */
+    events: Record<string, Array<(payload: unknown) => void>>;
+    /** ★G-43 B3：页面所有权上下文（ownership 选项启用时可用——业务经它 alloc/登记该页 Owned 资源） */
+    ownershipOf(pageId: string): PageOwnership | null;
+}
+/** ★G-42 B2：StackContainer 参考实现（页面栈 + 五原子销毁 + 资源代管 + 深度治理 + keep-alive 配额） */
+export declare function createStackContainer(opts?: StackContainerOptions): StackContainer;

package/dist/superapp-container.d.ts

@@ -0,0 +1,47 @@
+import type { OwnershipGraph } from './ownership';
+import type { PageOwnership } from './page-ownership';
+import type { BusinessSandbox, ProteusHostContainer, SuperAppPolicy } from './container-spi';
+export interface SandboxExecutionResult<T = unknown> {
+    ok: boolean;
+    bizId?: string;
+    hostAlive?: boolean;
+    otherSandboxesAlive?: number;
+    error?: string;
+    result?: T;
+}
+export interface SuperSandbox extends BusinessSandbox {
+    scope: {
+        bizId: string;
+        values: Record<string, unknown>;
+    };
+    crashCount: number;
+    run<T>(fn: () => T): {
+        ok: boolean;
+        error?: unknown;
+        result?: T;
+    };
+}
+export interface SuperAppOptions {
+    policy?: Partial<SuperAppPolicy>;
+    quotaLimitBytes?: number;
+    /** ★G-43 B3：所有权图接入 pass-through（页面销毁时该页 Owned 资源 forceDrop——委托内部 StackContainer） */
+    ownership?: {
+        graph: OwnershipGraph;
+        quotaBytes?: number;
+    };
+}
+export interface SuperAppContainer extends ProteusHostContainer {
+    readonly id: 'superapp';
+    crashLog: Array<{
+        bizId: string;
+        error: string;
+        at: number;
+    }>;
+    /** 崩溃隔离执行器：业务 fn 抛错 → 捕获 + 事件 + 自动重启，宿主与其他业务不受影响 */
+    executeInSandbox<T>(bizId: string, fn: () => T): SandboxExecutionResult<T>;
+    readonly sandboxView: readonly SuperSandbox[];
+    /** ★G-43 B3：页面所有权上下文（ownership 选项启用时——委托内部 StackContainer） */
+    ownershipOf(pageId: string): PageOwnership | null;
+}
+/** ★G-42 B4：SuperAppContainer（业务沙箱 + 崩溃隔离 L1-L3 + 配额 + 安全网关；页面栈委托 StackContainer） */
+export declare function createSuperAppContainer(opts?: SuperAppOptions): SuperAppContainer;

package/dist/vue-bridge.d.ts

@@ -0,0 +1,22 @@
+import { createRenderer } from '@vue/runtime-core';
+import type { RendererOptions } from '@vue/runtime-core';
+import type { NodeHandle } from './spi';
+import { createNodeOpsDispatcher } from './dispatcher';
+import type { ProteusNodeOpsDispatcher } from './dispatcher';
+/** B3 bridge：Dispatcher → Vue RendererOptions（HostNode=HostElement=NodeHandle——后端句柄即 Vue 的"节点"） */
+export declare function createVueRendererOptions(dispatch: ProteusNodeOpsDispatcher): RendererOptions<NodeHandle, NodeHandle>;
+export interface ProteusRenderer {
+    /** 底层 Dispatcher（换引擎/查 trace/热切换） */
+    dispatch: ProteusNodeOpsDispatcher;
+    /** 标准 Vue renderer（createRenderer(nodeOps) 产物——createApp/render 均可用） */
+    renderer: ReturnType<typeof createRenderer<NodeHandle, NodeHandle>>;
+}
+/**
+ * 创建 Proteus 渲染器：Dispatcher → Vue RendererOptions → createRenderer
+ *   const { renderer } = createProteusRenderer(createNodeOpsDispatcher(headlessBackend))
+ *   renderer.render(h('p-text', { content: '商品 A' }), containerNode)  // containerNode = 后端容器句柄
+ *   或 renderer.createApp(App).mount(containerNode)                      // 标准 App 入口
+ */
+export declare function createProteusRenderer(dispatch: ProteusNodeOpsDispatcher): ProteusRenderer;
+/** 便捷：直接给后端就建好 Dispatcher + renderer（省一步 createNodeOpsDispatcher） */
+export declare function createProteusRendererForBackend(backend: Parameters<typeof createNodeOpsDispatcher>[0]): ProteusRenderer;

package/dist/vue-dom.d.ts

@@ -0,0 +1,6 @@
+import type { ProteusRenderBackend } from './spi';
+interface DocumentLike {
+    createElement(tag: string): HTMLElement;
+}
+export declare function createVueDomBackend(doc?: DocumentLike): ProteusRenderBackend;
+export {};