weifuwu 0.94.0 → 0.95.0

package/dist/level3/vdom/transform/table.ts

@@ -0,0 +1,56 @@
+/**
+ * vdom transform — table（转换表——状态机核心）
+ *
+ * 转换表：oldState × newState → 策略函数（各状态文件实现）——
+ * 同态（对角）走「就地 patch」（text→setText / element→就地 diff /
+ * component→同类型复用 / hole→no-op）；异态走「转换」——
+ * 占位法核心：**锚 ↔ 真实节点 replaceChild 互换**（childNodes 长度恒定——
+ * 同构不变量——禁止 removeChild 塌缩）。
+ *
+ * 转换策略（各文件实现）：
+ *   text.ts      —— text ↔ element/component/fragment（文本节点 ↔ 结构）
+ *   hole.ts      —— hole ↔ element/component/fragment/text
+ *                  （**null <-> component / null <-> fragment 主场景**——
+ *                  条件渲染 cond ? <X/> : null 的类型切换）
+ *   element.ts   —— element ↔ component/fragment/hole/text
+ *   component.ts —— component ↔ element/fragment/hole（同类型复用——
+ *                   异类型卸载 + 重建）
+ *   fragment.ts  —— fragment ↔ element/component/hole（多节点展开 ↔ 单节点）
+
+ */
+
+import type { VNodeChild } from '../../../level0/vdom/vnode.ts'
+import type { NodeState, TransformContext, TransitionFn } from './index.ts'
+import { transitionText } from './text.ts'
+import { transitionHole } from './hole.ts'
+import { transitionElement } from './element.ts'
+import { transitionComponent } from './component.ts'
+import { transitionFragment } from './fragment.ts'
+
+/** 转换表（old × new → 策略）——同态 = 就地 patch（diff 层处理——表中为 null） */
+export const TRANSITIONS: Record<NodeState, Record<NodeState, TransitionFn | null>> = {
+  text:       { text: null, hole: transitionText, element: transitionText, component: transitionText, fragment: transitionText, array: transitionText },
+  hole:       { text: transitionHole, hole: null, element: transitionHole, component: transitionHole, fragment: transitionHole, array: transitionHole },
+  element:    { text: transitionElement, hole: transitionElement, element: null, component: transitionElement, fragment: transitionElement, array: transitionElement },
+  component:  { text: transitionComponent, hole: transitionComponent, element: transitionComponent, component: null, fragment: transitionComponent, array: transitionComponent },
+  fragment:   { text: transitionFragment, hole: transitionFragment, element: transitionFragment, component: transitionFragment, fragment: null, array: transitionFragment },
+  array:      { text: transitionFragment, hole: transitionFragment, element: transitionFragment, component: transitionFragment, fragment: transitionFragment, array: null },
+}
+
+/** 转换调度（old × next → 策略）——同态返回 null（diff 就地 patch——不重建） */
+export function transitionOf(oldState: NodeState, newState: NodeState): TransitionFn | null {
+  return TRANSITIONS[oldState]?.[newState] ?? null
+}
+
+/** 执行转换（diff 调用——自动降级：同态/null 策略 → no-op） */
+export function runTransition(
+  oldState: NodeState,
+  newState: NodeState,
+  oldNode: unknown,
+  nextNode: VNodeChild,
+  ctx: TransformContext,
+): Promise<void> | void {
+  const fn = transitionOf(oldState, newState)
+  if (!fn) return undefined
+  return fn(oldNode, nextNode, ctx)
+}

package/dist/level3/vdom/transform/text.ts

@@ -0,0 +1,15 @@
+/**
+ * vdom transform — text（文本转换——text ↔ X）
+ *
+ * 场景：条件渲染/列表项类型切换（'a' <-> <div/> <-> 组件...）。
+ * 转换职责（old=text → new=X）：旧文本节点移除（让位）——新节点由 diff
+ * 渲染到同一位置。同态 text → text 不在本表（就地 setText——diff 层）。
+ */
+
+import type { TransformContext, TransitionFn } from './index.ts'
+
+/** text → X：旧文本节点移除（让位） */
+export const transitionText: TransitionFn = (_old, next, ctx) => {
+  ctx.emit({ op: 'remove', id: ctx.oldId })
+  ctx.emitNode(next, ctx.parent, ctx.index, ctx.ref)
+}

package/dist/level3/vdom/v2/cycle.d.ts

@@ -0,0 +1,56 @@
+/**
+ * vdom v2 — 渲染周期（applyV2Inner 管线化——波次 1：渲染全链路流视图）
+ *
+ * VDOM-OBSERVABLE-COMPLETE 波次 1：
+ * - **管线形态**：build/diff → cmds$ → toArray（原子性——生成完成才应用——
+ *   错误 → 零 DOM 变更）→ tap(apply) → tap(cleanup) → currentTree →
+ *   applied$（sink 可观测）→ complete$
+ * - **度量流化**：三轴（builds/diffs/applies/unmounts）在周期计数——
+ *   删除 applyV2 手写 vt.builds/diffs（serve 同步到 __wfV2——兼容）
+ * - **sserve 解耦**：周期不含 DOM/applier——依赖注入（boot/resetRoot/
+ *   build/diff/apply/dispose/active）——契约层可注入假依赖直测管线
+ */
+import type { VNode } from '../../../level0/vdom/vnode.ts';
+import type { Command } from '../../../level0/vdom/command/index.ts';
+import { Observable } from '../../../level1/vdom/observable/index.ts';
+/** 周期三轴度量（渲染健康——流上取数——RENDER-HEALTH-PLAN 接管点） */
+export interface CycleMetrics {
+    builds: number;
+    diffs: number;
+    applies: number;
+    unmounts: number;
+}
+/** 渲染周期依赖（serve 注入 DOM/引擎——周期纯管线） */
+export interface RenderCycleDeps {
+    /** 首帧一次性（SSR 吸收 begin / root 清空——周期内 booted 标记） */
+    boot(): void;
+    /** root 整树替换前清空（innerHTML='' + 旧段全量 dispose——serve 实现） */
+    resetRoot(): void;
+    /** 全量构建（首帧 / 根替换 / 影子树重置后——currentTree null 时） */
+    build(vnode: VNode): Observable<Command>;
+    /** 增量 diff（currentTree 与 vnode 同型） */
+    diff(oldTree: VNode, nextTree: VNode): Observable<Command>;
+    /** 命令应用（applier.apply——副作用终态） */
+    apply(cmd: Command): void;
+    /** unmount 命令 → 段销毁（返回是否实际销毁——幂等防御）。
+     *  **beforeEpoch（2027-10——nav 链残留实修补正）**：只处理「该周期之前」
+     *  创建的段——unmount 目标永远是旧树段——同槽位 id 复用的新段不是目标 */
+    dispose(compId: string, beforeEpoch: number): boolean;
+    /** serve 活性（unmount 后周期零副作用） */
+    active(): boolean;
+}
+export interface RenderCycle {
+    /** 应用 vnode（首帧 build / 后续 diff / 异型根替换）——生成原子性 */
+    apply(vnode: VNode): Promise<void>;
+    /** 影子树重置（错误自愈 / R1 熔断 fallback 前置）——下次 apply 全量 */
+    reset(): void;
+    /** 三轴度量（builds/diffs/applies/unmounts） */
+    metrics(): CycleMetrics;
+    /** **应用后命令重发射**（sink 可观测——dev/度量订阅点——每周期一值） */
+    applied$: Observable<Command[]>;
+    /** **周期完成**（applied 后——afterRender 冲刷点——每周期一事件） */
+    complete$: Observable<void>;
+}
+/** 创建渲染周期（**原子性纪律**：命令生成完整（toArray）→ 应用——生成
+ *  错误 → 零 DOM 变更 + currentTree 重置（下次全量自愈——R1 语境界面）） */
+export declare function createRenderCycle(deps: RenderCycleDeps): RenderCycle;

package/dist/level3/vdom/v2/cycle.ts

@@ -0,0 +1,140 @@
+/**
+ * vdom v2 — 渲染周期（applyV2Inner 管线化——波次 1：渲染全链路流视图）
+ *
+ * VDOM-OBSERVABLE-COMPLETE 波次 1：
+ * - **管线形态**：build/diff → cmds$ → toArray（原子性——生成完成才应用——
+ *   错误 → 零 DOM 变更）→ tap(apply) → tap(cleanup) → currentTree →
+ *   applied$（sink 可观测）→ complete$
+ * - **度量流化**：三轴（builds/diffs/applies/unmounts）在周期计数——
+ *   删除 applyV2 手写 vt.builds/diffs（serve 同步到 __wfV2——兼容）
+ * - **sserve 解耦**：周期不含 DOM/applier——依赖注入（boot/resetRoot/
+ *   build/diff/apply/dispose/active）——契约层可注入假依赖直测管线
+ */
+import type { VNode } from '../../../level0/vdom/vnode.ts'
+import type { Command } from '../../../level0/vdom/command/index.ts'
+import { Observable, Subject, tap, toArray } from '../../../level1/vdom/observable/index.ts'
+import { spyEvent } from '../../../level1/vdom/v2/spy.ts'
+import { nextSegmentEpoch } from './diff.ts'
+
+/** 周期三轴度量（渲染健康——流上取数——RENDER-HEALTH-PLAN 接管点） */
+export interface CycleMetrics {
+  builds: number
+  diffs: number
+  applies: number
+  unmounts: number
+}
+
+/** 渲染周期依赖（serve 注入 DOM/引擎——周期纯管线） */
+export interface RenderCycleDeps {
+  /** 首帧一次性（SSR 吸收 begin / root 清空——周期内 booted 标记） */
+  boot(): void
+  /** root 整树替换前清空（innerHTML='' + 旧段全量 dispose——serve 实现） */
+  resetRoot(): void
+  /** 全量构建（首帧 / 根替换 / 影子树重置后——currentTree null 时） */
+  build(vnode: VNode): Observable<Command>
+  /** 增量 diff（currentTree 与 vnode 同型） */
+  diff(oldTree: VNode, nextTree: VNode): Observable<Command>
+  /** 命令应用（applier.apply——副作用终态） */
+  apply(cmd: Command): void
+  /** unmount 命令 → 段销毁（返回是否实际销毁——幂等防御）。
+   *  **beforeEpoch（2027-10——nav 链残留实修补正）**：只处理「该周期之前」
+   *  创建的段——unmount 目标永远是旧树段——同槽位 id 复用的新段不是目标 */
+  dispose(compId: string, beforeEpoch: number): boolean
+  /** serve 活性（unmount 后周期零副作用） */
+  active(): boolean
+}
+
+export interface RenderCycle {
+  /** 应用 vnode（首帧 build / 后续 diff / 异型根替换）——生成原子性 */
+  apply(vnode: VNode): Promise<void>
+  /** 影子树重置（错误自愈 / R1 熔断 fallback 前置）——下次 apply 全量 */
+  reset(): void
+  /** 三轴度量（builds/diffs/applies/unmounts） */
+  metrics(): CycleMetrics
+  /** **应用后命令重发射**（sink 可观测——dev/度量订阅点——每周期一值） */
+  applied$: Observable<Command[]>
+  /** **周期完成**（applied 后——afterRender 冲刷点——每周期一事件） */
+  complete$: Observable<void>
+}
+
+/** 创建渲染周期（**原子性纪律**：命令生成完整（toArray）→ 应用——生成
+ *  错误 → 零 DOM 变更 + currentTree 重置（下次全量自愈——R1 语境界面）） */
+export function createRenderCycle(deps: RenderCycleDeps): RenderCycle {
+  let booted = false
+  let currentTree: VNode | null = null
+  const metrics: CycleMetrics = { builds: 0, diffs: 0, applies: 0, unmounts: 0 }
+  const appliedSub = new Subject<Command[]>()
+  const completeSub = new Subject<void>()
+
+  // **应用（tap——命令逐个应用——apply 错误 = break（后续命令跳过——
+  // 现有语义）——影子树保持（周期推进）——错误不终结管线（cleanup 仍执行）**
+  const applyCmds = (cmds: Command[]): void => {
+    if (!deps.active()) return
+    for (const cmd of cmds) {
+      try { metrics.applies++; deps.apply(cmd) }
+      catch (e) { console.error('[vdom] v2 apply:', e); break }
+    }
+  }
+  // **清理（unmount 命令 → 段销毁——幂等——生成端已统一 dispose 的防御
+  //  性消费端路径）**——**纪元守卫（2027-10）**：unmount 目标永远是旧树段
+  //  （生成期已 dispose 的除外）——同周期新挂载的同 id 段（槽位复用——
+  //  nav 链 accordion→index→actionsheet 残留实证：nav1 的 unmount
+  //  root.0.1.0 在 cleanup 阶段误杀当期新挂载的 index 段 → nav2 旧输出
+  //  无清理命令 → 组件列表残留）——纪元 < 当前周期才销毁
+  const cleanupCmds = (cmds: Command[], beforeEpoch: number): void => {
+    if (!deps.active()) return
+    for (const cmd of cmds) {
+      if (cmd.op === 'unmount' && deps.dispose(cmd.compId, beforeEpoch)) metrics.unmounts++
+    }
+  }
+
+  const apply = (vnode: VNode): Promise<void> => new Promise<void>((resolve, reject) => {
+    if (!deps.active()) { resolve(); return }
+    // **周期纪元（2027-10）**：本周期创建的段打上当前纪元——cleanup 以
+    //  纪元为界（不误杀当期新建段）
+    const beforeEpoch = nextSegmentEpoch()
+    let stream: Observable<Command>
+    if (!booted) {
+      booted = true
+      try { deps.boot() } catch (e) { reject(e); return }
+    }
+    if (currentTree === null) {
+      metrics.builds++
+      stream = deps.build(vnode)
+    } else if (currentTree.type !== vnode.type) {
+      // **root 整树替换**（组件/元素切换——异型走转换表会违例——清空重建）
+      metrics.builds++
+      try { deps.resetRoot() } catch (e) { reject(e); return }
+      currentTree = null
+      stream = deps.build(vnode)
+    } else {
+      metrics.diffs++
+      stream = deps.diff(currentTree, vnode)
+    }
+    stream.pipe(
+      toArray(),
+      tap((cmds) => spyEvent('cmd:render', `${cmds.length}条`)),
+      tap(applyCmds),
+      tap((cmds) => cleanupCmds(cmds, beforeEpoch)),
+      tap((cmds) => { if (deps.active()) currentTree = vnode; void cmds }),
+    ).subscribe({
+      next: (cmds) => {
+        if (!deps.active()) { resolve(); return }
+        appliedSub.next(cmds)
+        completeSub.next()
+        resolve()
+      },
+      error: (e) => { currentTree = null; reject(e) },
+    })
+  })
+
+  const reset = (): void => { currentTree = null }
+
+  return {
+    apply,
+    reset,
+    metrics: () => ({ ...metrics }),
+    applied$: appliedSub.asObservable(),
+    complete$: completeSub.asObservable(),
+  }
+}

package/dist/level3/vdom/v2/diff.d.ts

@@ -0,0 +1,89 @@
+import type { VNode, VNodeChild } from '../../../level0/vdom/vnode.ts';
+import type { Component, RenderFn } from '../../../level0/vdom/vnode.ts';
+import type { Command } from '../../../level0/vdom/command/index.ts';
+import type { UIContext } from '../context/UIContext.ts';
+import { Observable } from '../../../level1/vdom/observable/index.ts';
+import { type CompOutput } from '../node/component.ts';
+/** v2 组件流段（实例复用载体——**工厂执行一次——后续复用**） */
+export interface Segment {
+    factory: Component;
+    renderFn: RenderFn;
+    /** memo 比较基准（上次实际渲染的 props——跳过后不更新） */
+    lastProps?: Record<string, unknown>;
+    lastOutput: CompOutput | undefined;
+    hookSeq: {
+        n: number;
+    };
+    /** 渲染 hook 基准（mount 后计数——v1 renderBase 等价——**每次 renderFn 前
+     *  重置——渲染期 hook 索引跨渲染稳定——useOpen 状态保留（2027-08
+     *  漂移实证——Popover 点后 open 复位）**） */
+    renderBase: number;
+    instData: Map<unknown, unknown>;
+    /** **destroy$（2027-08——段级卸载信号——单信号全停）**：卸载时 next——
+     *  **单轨清理（2027-09——onUnmounts 字段删除）**：订阅者（onUnmount
+     *  闭包栈 LIFO + 外部 takeUntil 流清理）统一由本信号驱动——不再有
+     *  平行数组 */
+    destroy$: import('../../../level1/vdom/observable/index.ts').Subject<void>;
+    disposed: boolean;
+    /** **创建纪元（2027-10——nav 链残留实修补正）**：createSegment 打上创建
+     *  时全局纪元（渲染周期开始时递推）——cleanup 阶段（unmount 防御性
+     *  dispose）只处理「当前周期之前」创建的段——unmount 命令目标永远是
+     *  旧树段——同槽位 id 复用的新段不是目标（accordion→index→actionsheet
+     *  实证：nav1 生成期的 unmount root.0.1.0 在 cleanup 阶段误杀同周期
+     *  新挂载的 index 段 → 旧输出无物可清 → 组件列表残留） */
+    epoch: number;
+}
+/** 渲染周期开始（纪元递推——返回新纪元） */
+export declare function nextSegmentEpoch(): number;
+export type SegmentMap = Map<string, Segment>;
+/** 创建段（mount——工厂执行——hooks 环境已注入 ctx.ui） */
+export declare function createSegment(factory: Component, props: Record<string, unknown>, ctx: UIContext, compId: string, requestSegmentRender?: () => void): Segment;
+export declare function rerenderSegment(seg: Segment, props: Record<string, unknown>): VNodeChild;
+/** 段销毁（unmount——destroy$ 单信号全停——onUnmount 闭包栈 LIFO + 订阅
+ *  者清理统一由信号驱动）——段接口无平行数组（单轨清理） */
+export declare function disposeSegment(id: string, segments: SegmentMap): void;
+/**
+ * **段输出根枚举（VDOM-CORE-EXCELLENCE KEYED-MOVE M1——单一实现源）**：
+ * keyed 组件输出的物理节点 id 清单——顺移物理 move 的命令目标。
+ * **形态映射（四形态探针实证——2027-10）**：
+ * - 单 vnode 元素/文本输出 → **槽位 id**（pathId——C2 锚点法——P 契约
+ *   槽位 remap 有效实证）
+ * - 数组输出 → **compId.i 平铺**（root.0.kk1.0/.1——与兄弟槽位隔离）
+ * - null/空洞输出 → **compId.0 锚**（G11 修正——null 锚也挂子空间）
+ * - 嵌套组件输出 → **compId.0**（单 vnode 组件输出——防冲突——HoverCard
+ *   事故实证；嵌套段在 compId.0.0 递归子空间）
+ */
+export declare function outputRootIds(seg: Segment | undefined, kid: string, parent: string, index: number): string[];
+/** 任意子节点的物理输出根 id（M2 ref 链——新位置左邻定位）：
+ *  元素/文本 → 槽位 id；keyed 组件 → 输出根[0]（compId.0/槽位） */
+export declare function outputRootIdOf(c: VNodeChild, parent: string, index: number, segments?: SegmentMap): string;
+/** 节点对照（old vs new——流式增量命令） */
+export declare function diffV2Node(oldC: VNodeChild, newC: VNodeChild, parent: string, index: number, ref: string | null, ctx: UIContext, segments: SegmentMap, registry: import('../node/component.ts').ComponentRegistry, requestRender?: () => void): Observable<Command>;
+/** 组件 id（keyedId/pathId——单一点——v1 双实现收敛） */
+export declare function v2CompId(vn: VNode, parent: string, index: number): string;
+/** 根对照（v2 diff——diffStream 的 Observable 等价） */
+export declare function diffV2(oldTree: VNode, newTree: VNode, ctx: UIContext, segments: SegmentMap, registry: import('../node/component.ts').ComponentRegistry, requestRender?: () => void): Observable<Command>;
+/** keyed 列表对照（流式——顺移 move / 冲突重建 / key 映射对照——v1 语义等价） */
+export declare function diffKeyedV2(oldCs: VNodeChild[], newCs: VNodeChild[], parent: string, ctx: UIContext, segments: SegmentMap, registry: import('../node/component.ts').ComponentRegistry, requestRender?: () => void): Observable<Command>;
+/** 完整区间移除（v1 removeVNodeTree 等价——子树全部节点 remove——先子后父）
+ *  **组件项 unmount 信号**：v1 removeVNodeTree 同语义（compId——消费端
+ *  applier 的 registry 清理）
+ *  **段 dispose 生成期（2027-08——段表是 v2 权威——同 compId 重渲染碰撞
+ *  实证：列表→编辑器切换——旧按钮内 Icon 段残留 root.0.1.0.0——新 Button
+ *  落同槽——段错配崩溃）**：段清理必须在 diff 生成期完成（命令流生产端
+ *  完整自足——不依赖消费端时序——消费端 apply 循环的 dispose 是幂等兜底 */
+export declare function removeTreeV2(v: VNodeChild, parent: string, index: number, segments?: SegmentMap, opts?: {
+    keepSegments?: boolean;
+}): Command[];
+/** 列表含 keyed 项检测（v2——keyOf 桥） */
+export declare function hasKeyedId(items: VNodeChild[]): boolean;
+/**
+ * v2 转换（异态——v1 transitionOf 表语义单源——流式适配）
+ * - 转换表同步执行（emit 收集让位命令 + emitNode 记录新侧）——**不 await**
+ * - **顺序纪律三段流（2027-09——C1 fuzz seed=11 结构化修复）**：
+ *   concatObs([disposeOp → removeCmds → 新侧渲染])——按序订阅：① 旧段
+ *   dispose（段表权威更新）② 旧侧让位命令发射 ③ 新侧渲染构造（**订阅时**
+ *   ——createSegment 在 dispose 后——同 id 命中旧段/工厂错配结构性不可能）
+ *   ——pendingSink 时序 hack 删除（旧实现 Promise.resolve().then 时序不保）
+ */
+export declare function transformV2(oldC: VNodeChild, newC: VNodeChild, parent: string, index: number, ref: string | null, ctx: UIContext, registry: import('../node/component.ts').ComponentRegistry, oldCompId?: string, segments?: SegmentMap, requestRender?: () => void): Observable<Command>;