create-windy 0.2.17 → 0.2.19

package/dist/cli.js

@@ -412,13 +412,20 @@ var platformModules = [
       "apps/web/src/pages/settings",
       "apps/web/src/layout/GlobalWatermark.vue",
       "apps/web/src/layout/GlobalWatermark.webtest.ts",
+      "apps/web/src/layout/GlobalWatermark.layering.webtest.ts",
       "apps/web/src/services/platform-settings-api.ts",
       "apps/web/src/composables/useWatermarkSettings.ts",
+      "apps/web/src/composables/useWatermarkSettings.webtest.ts",
       "apps/web/src/composables/watermark-settings.ts",
-      "apps/web/src/composables/watermark-settings.webtest.ts"
+      "apps/web/src/composables/watermark-settings.webtest.ts",
+      "packages/modules/src/system-api-watermark.ts",
+      "packages/modules/src/system-watermark-policy.test.ts"
     ],
     documentation: ["docs/platform/platform-shell-settings.md"],
-    databaseTables: ["platform_branding_settings"]
+    databaseTables: [
+      "platform_branding_settings",
+      "platform_watermark_policies"
+    ]
   },
   {
     ...module2("system.configuration", "配置版本", "类型化配置、应用和回滚。", "recommended", ["system"]),
@@ -1033,6 +1040,7 @@ var ignoredFiles = new Set([
 ]);
 var projectOwnedRoots = [
   "apps/web/src/app",
+  "apps/server/src/installed-business-modules.ts",
   "apps/server/src/work-order",
   "packages/example-work-order"
 ];
@@ -1041,8 +1049,13 @@ var sharedScaffoldRoots = [
   "AGENTS.md",
   ".env.example",
   "docker-compose.yml",
+  "drizzle.config.ts",
+  "apps/server/Dockerfile",
+  "apps/server/src/index.ts",
+  "apps/web/Dockerfile",
   "apps/web/src/layout",
-  "apps/web/src/router"
+  "apps/web/src/router",
+  "packages/database/src/schema/index.ts"
 ];
 async function writeManagedFilesManifest(targetDirectory, generatorVersion) {
   const paths = await collectFiles(targetDirectory);
@@ -1305,7 +1318,7 @@ var starterCompose = `services:
       POSTGRES_USER: windy
       POSTGRES_PASSWORD: \${POSTGRES_PASSWORD:?请在 .env 中设置 POSTGRES_PASSWORD}
     ports:
-      - "5432:5432"
+      - "15432:5432"
     volumes:
       - postgres-data:/var/lib/postgresql/data
     healthcheck:
@@ -1334,14 +1347,15 @@ var starterCompose = `services:
     command: ["bun", "run", "--cwd", "apps/server", "dev"]
     environment:
       NODE_ENV: development
-      PORT: 3000
+      PORT: 9747
       DATABASE_URL: postgresql://windy:\${POSTGRES_PASSWORD}@postgres:5432/windy
       WINDY_BOOTSTRAP_ADMIN_PASSWORD: \${WINDY_BOOTSTRAP_ADMIN_PASSWORD:?请在 .env 中设置管理员初始密码}
       WINDY_AUDIT_QUEUE_FILE: /app/data/audit/recovery-queue.json
       WINDY_CONTAINERIZED: "1"
+      BUN_CONFIG_NO_CLEAR_TERMINAL_ON_RELOAD: "true"
       WINDY_SYSTEM_USAGE_PATHS: /app/data/audit
     ports:
-      - "3000:3000"
+      - "9747:9747"
     volumes:
       - ./apps/server:/app/apps/server
       - ./packages:/app/packages
@@ -1357,14 +1371,26 @@ var starterCompose = `services:
     command: ["bun", "run", "--cwd", "apps/web", "dev"]
     environment:
       NODE_ENV: development
-      WINDY_DEV_PORT: 9746
-      API_UPSTREAM: http://server:3000
+      WINDY_DEV_PORT: 18746
+      WINDY_DEV_USE_POLLING: "1"
+      API_UPSTREAM: http://server:9747
       VITE_DEV_HOST: 0.0.0.0
     ports:
-      - "9746:9746"
+      - "18746:18746"
     volumes:
       - ./apps/web:/app/apps/web
       - ./packages:/app/packages
+    healthcheck:
+      test:
+        [
+          "CMD",
+          "bun",
+          "-e",
+          "const r=await fetch('http://127.0.0.1:18746/-/windy-dev');process.exit(r.ok?0:1)",
+        ]
+      interval: 5s
+      timeout: 3s
+      retries: 6
     depends_on:
       - server
 
@@ -1435,15 +1461,17 @@ create-windy 已创建仅供本机使用且被 Git 忽略的 \`.env\`，其中
 文件权限为 \`0600\`。\`bun run dev\` 会通过 Docker Compose 等待 PostgreSQL、执行
 Drizzle migration，再启动 Server 与 Web；不要跳过 migration 后直接把 Server 连接到
 空数据库。首次启动需要本机已经安装并启动 Docker 与 Docker Compose，并可能需要下载
-基础镜像。
+基础镜像。后续 \`bun run dev\` 会复用已有镜像，不会重复构建；依赖、Dockerfile 或
+\`bun.lock\` 变化后运行 \`bun run dev:build\`。
 
 | 服务 | 地址 |
 | ---- | ---- |
-| Web | http://localhost:9746 |
-| Server 健康检查 | http://localhost:3000/api/health |
-| PostgreSQL | localhost:5432 |
+| Web | http://localhost:18746 |
+| Server 健康检查 | http://localhost:9747/api/health |
+| PostgreSQL | localhost:15432 |
 
-Docker Web 固定使用 \`9746\`。只启动单个应用时使用：
+Docker Web 固定使用 \`18746\`，Web 与 Server 都挂载宿主机源码并保持热更新。只启动
+单个应用时使用：
 
 \`\`\`bash
 bun run dev:web
@@ -1502,6 +1530,7 @@ ${moduleRows}
 
 \`\`\`bash
 bun run dev
+bun run dev:build
 bun run dev:web
 bun run dev:server
 bun run typecheck
@@ -1574,7 +1603,8 @@ function createStarterPackage(source, projectName, includeOxc = true, projectLic
       ...includeOxc ? {
         prepare: "git rev-parse --git-dir >/dev/null 2>&1 || exit 0; husky"
       } : {},
-      dev: "docker compose up --build",
+      dev: "docker compose up",
+      "dev:build": "docker compose up --build",
       ...generatorVersion ? { windy: "create-windy" } : {},
       "dev:web": "bun run --cwd apps/web dev",
       "dev:server": "bun run --cwd apps/server dev",
@@ -3788,7 +3818,7 @@ function sentenceWithoutStop(value) {
 
 // src/update/cli.ts
 import { rm as rm8 } from "node:fs/promises";
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve5 } from "node:path";
 
 // src/update/doctor.ts
 import { readFile as readFile11 } from "node:fs/promises";
@@ -3826,9 +3856,10 @@ import {
   mkdir as mkdir5,
   readFile as readFile10,
   rm as rm5,
+  rmdir,
   writeFile as writeFile9
 } from "node:fs/promises";
-import { dirname as dirname3, join as join10 } from "node:path";
+import { dirname as dirname3, join as join10, resolve as resolve4, sep as sep3 } from "node:path";
 var updateStatePath = ".windy/update-state.json";
 async function applyTransaction(plan) {
   if (plan.conflicts.length) {
@@ -3866,7 +3897,11 @@ async function applyTransaction(plan) {
     for (const file of changed) {
       const target = join10(plan.projectDirectory, file.path);
       if (file.action === "delete") {
+        const existed = await exists(target);
         await rm5(target, { force: true });
+        if (existed) {
+          await removeEmptyDeletedFileParents(target, plan.projectDirectory);
+        }
         continue;
       }
       if (!file.content)
@@ -3929,6 +3964,26 @@ async function exists(path2) {
     return false;
   }
 }
+async function removeEmptyDeletedFileParents(deletedFile, projectDirectory) {
+  const projectRoot = resolve4(projectDirectory);
+  let directory = dirname3(resolve4(deletedFile));
+  while (directory !== projectRoot && directory.startsWith(`${projectRoot}${sep3}`)) {
+    try {
+      await rmdir(directory);
+    } catch (error) {
+      if (isDirectoryNotRemovable(error))
+        return;
+      throw error;
+    }
+    directory = dirname3(directory);
+  }
+}
+function isDirectoryNotRemovable(error) {
+  if (!(error instanceof Error) || !("code" in error))
+    return false;
+  const code = error.code;
+  return code === "ENOENT" || code === "ENOTEMPTY" || code === "EEXIST";
+}
 function assertSafePath(path2) {
   if (!path2 || path2.startsWith("/") || path2.split("/").includes("..")) {
     throw new Error(`更新计划包含不安全路径：${path2}`);
@@ -4013,7 +4068,9 @@ var recipes = [
   { id: "starter-0.2.13-to-0.2.14", from: "0.2.13", to: "0.2.14" },
   { id: "starter-0.2.14-to-0.2.15", from: "0.2.14", to: "0.2.15" },
   { id: "starter-0.2.15-to-0.2.16", from: "0.2.15", to: "0.2.16" },
-  { id: "starter-0.2.16-to-0.2.17", from: "0.2.16", to: "0.2.17" }
+  { id: "starter-0.2.16-to-0.2.17", from: "0.2.16", to: "0.2.17" },
+  { id: "starter-0.2.17-to-0.2.18", from: "0.2.17", to: "0.2.18" },
+  { id: "starter-0.2.18-to-0.2.19", from: "0.2.18", to: "0.2.19" }
 ];
 function resolveRecipeChain(sourceVersion, targetVersion) {
   if (sourceVersion === targetVersion)
@@ -4038,8 +4095,8 @@ function resolveRecipeChain(sourceVersion, targetVersion) {
 }
 
 // src/update/updater.ts
-import { mkdir as mkdir7, readFile as readFile14, rm as rm7, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname4, join as join15 } from "node:path";
+import { mkdir as mkdir7, readFile as readFile15, rm as rm7, writeFile as writeFile11 } from "node:fs/promises";
+import { dirname as dirname4, join as join16 } from "node:path";
 
 // src/update/artifacts.ts
 import { mkdir as mkdir6, mkdtemp, readFile as readFile12 } from "node:fs/promises";
@@ -4101,8 +4158,8 @@ async function readProjectName2(projectDirectory) {
 }
 
 // src/update/planner.ts
-import { access as access3, readFile as readFile13 } from "node:fs/promises";
-import { join as join14 } from "node:path";
+import { access as access3, readFile as readFile14 } from "node:fs/promises";
+import { join as join15 } from "node:path";
 
 // src/update/known-repairs.ts
 var wrongTextVersions = new Set(["0.2.12", "0.2.13"]);
@@ -4163,13 +4220,397 @@ async function mergeTextFile(base, ours, theirs) {
     if (result.code === 0) {
       return { content: new TextEncoder().encode(result.stdout) };
     }
-    if (result.code === 1)
-      return { conflict: "三方合并存在重叠修改" };
+    if (result.code === 1) {
+      const resolved = resolveConservativeConflicts(result.stdout);
+      return resolved ? { content: new TextEncoder().encode(resolved) } : { conflict: "三方合并存在重叠修改" };
+    }
     return { conflict: result.stderr.trim() || "git merge-file 执行失败" };
   } finally {
     await rm6(root, { recursive: true, force: true });
   }
 }
+function resolveConservativeConflicts(content) {
+  const lines = content.split(`
+`);
+  const output = [];
+  for (let index = 0;index < lines.length; index += 1) {
+    if (!lines[index]?.startsWith("<<<<<<< ")) {
+      output.push(lines[index] ?? "");
+      continue;
+    }
+    const baseMarker = lines.findIndex((line, candidate) => candidate > index && line.startsWith("||||||| "));
+    const separator = lines.indexOf("=======", baseMarker + 1);
+    const endMarker = lines.findIndex((line, candidate) => candidate > separator && line.startsWith(">>>>>>> "));
+    if (baseMarker < 0 || separator < 0 || endMarker < 0)
+      return;
+    const ours = lines.slice(index + 1, baseMarker);
+    const base = lines.slice(baseMarker + 1, separator);
+    const theirs = lines.slice(separator + 1, endMarker);
+    const resolved = resolveRegion(ours, base, theirs);
+    if (!resolved)
+      return;
+    output.push(...resolved);
+    index = endMarker;
+  }
+  return output.join(`
+`);
+}
+function resolveRegion(ours, base, theirs) {
+  const oursRebased = replaceSubsequence(ours, base, theirs);
+  if (oursRebased)
+    return oursRebased;
+  const theirsRebased = replaceSubsequence(theirs, base, ours);
+  if (theirsRebased)
+    return theirsRebased;
+  if (normalizeWhitespace(ours) === normalizeWhitespace(base))
+    return theirs;
+  if (normalizeWhitespace(theirs) === normalizeWhitespace(base))
+    return ours;
+  return applySemanticTokenEdits(ours, base, theirs) ?? mergeMarkdownTable(ours, base, theirs);
+}
+function replaceSubsequence(content, baseline, replacement) {
+  if (!baseline.length || baseline.length > content.length)
+    return;
+  const starts = [];
+  for (let index = 0;index <= content.length - baseline.length; index += 1) {
+    if (baseline.every((line, offset) => content[index + offset] === line)) {
+      starts.push(index);
+    }
+  }
+  if (starts.length !== 1)
+    return;
+  const start = starts[0] ?? 0;
+  return [
+    ...content.slice(0, start),
+    ...replacement,
+    ...content.slice(start + baseline.length)
+  ];
+}
+function normalizeWhitespace(lines) {
+  return lines.join(" ").replaceAll(/\s+/g, " ").trim();
+}
+function applySemanticTokenEdits(oursLines, baseLines, theirsLines) {
+  const oursText = oursLines.join(`
+`);
+  const baseText = baseLines.join(`
+`);
+  const theirsText = theirsLines.join(`
+`);
+  const ours = semanticTokens(oursText);
+  const base = semanticTokens(baseText);
+  const theirs = semanticTokens(theirsText);
+  let prefix = 0;
+  while (prefix < base.length && prefix < theirs.length && base[prefix]?.value === theirs[prefix]?.value) {
+    prefix += 1;
+  }
+  let suffix = 0;
+  while (suffix < base.length - prefix && suffix < theirs.length - prefix && base[base.length - 1 - suffix]?.value === theirs[theirs.length - 1 - suffix]?.value) {
+    suffix += 1;
+  }
+  const baseEnd = base.length - suffix;
+  const targetEnd = theirs.length - suffix;
+  const needle = base.slice(prefix, baseEnd).map(({ value }) => value);
+  if (!needle.length)
+    return;
+  const starts = findTokenSequence(ours, needle);
+  if (starts.length !== 1)
+    return;
+  const oursStart = starts[0] ?? 0;
+  const oursEnd = oursStart + needle.length - 1;
+  const targetFirst = theirs[prefix];
+  const targetLast = theirs[targetEnd - 1];
+  const replacement = targetFirst && targetLast ? theirsText.slice(targetFirst.start, targetLast.end) : "";
+  const merged = oursText.slice(0, ours[oursStart]?.start ?? 0) + replacement + oursText.slice(ours[oursEnd]?.end ?? 0);
+  return merged.split(`
+`);
+}
+function semanticTokens(content) {
+  return [...content.matchAll(/[A-Za-z0-9_@./:-]+|[^\s]/g)].map((match) => ({
+    value: match[0],
+    start: match.index,
+    end: match.index + match[0].length
+  }));
+}
+function findTokenSequence(tokens, needle) {
+  const starts = [];
+  for (let index = 0;index <= tokens.length - needle.length; index += 1) {
+    if (needle.every((value, offset) => tokens[index + offset]?.value === value)) {
+      starts.push(index);
+    }
+  }
+  return starts;
+}
+function mergeMarkdownTable(ours, base, theirs) {
+  if (![ours, base, theirs].every((rows) => rows.length === base.length && rows.every(isMarkdownTableRow))) {
+    return;
+  }
+  const parsed = [ours, base, theirs].map((rows) => rows.map(parseTableRow));
+  const [oursRows, baseRows, theirsRows] = parsed;
+  if (!oursRows || !baseRows || !theirsRows || !oursRows.every((cells, index) => cells.length === baseRows[index]?.length && cells.length === theirsRows[index]?.length)) {
+    return;
+  }
+  const merged = [];
+  for (let row = 0;row < baseRows.length; row += 1) {
+    const cells = [];
+    for (let column = 0;column < (baseRows[row]?.length ?? 0); column += 1) {
+      const baseCell = baseRows[row]?.[column] ?? "";
+      const oursCell = oursRows[row]?.[column] ?? "";
+      const theirsCell = theirsRows[row]?.[column] ?? "";
+      if (isTableSeparator(baseCell)) {
+        cells.push("---");
+      } else if (oursCell === baseCell || oursCell === theirsCell) {
+        cells.push(theirsCell);
+      } else if (theirsCell === baseCell) {
+        cells.push(oursCell);
+      } else {
+        return;
+      }
+    }
+    merged.push(`| ${cells.join(" | ")} |`);
+  }
+  return merged;
+}
+function isMarkdownTableRow(line) {
+  const trimmed = line.trim();
+  return trimmed.startsWith("|") && trimmed.endsWith("|");
+}
+function parseTableRow(line) {
+  return line.trim().slice(1, -1).split("|").map((cell) => cell.trim());
+}
+function isTableSeparator(cell) {
+  return /^:?-{3,}:?$/.test(cell);
+}
+
+// src/update/migration-reconciler.ts
+import { readFile as readFile13 } from "node:fs/promises";
+import { join as join14 } from "node:path";
+
+// src/update/snapshot-delta.ts
+function applySnapshotDelta(before, after, current, path2, conflicts, conflictPath) {
+  if (deepEqual(before, after))
+    return structuredClone(current);
+  if (!isRecord(before) || !isRecord(after) || !isRecord(current)) {
+    if (deepEqual(current, before) || deepEqual(current, after)) {
+      return structuredClone(after);
+    }
+    conflicts.push(`${conflictPath}：平台与业务同时修改 snapshot 节点 ${path2.join(".") || "<root>"}`);
+    return structuredClone(current);
+  }
+  const merged = structuredClone(current);
+  const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
+  for (const key of keys) {
+    if (path2.length === 0 && (key === "id" || key === "prevId"))
+      continue;
+    const nextPath = [...path2, key];
+    if (!(key in after)) {
+      if (!(key in current))
+        continue;
+      if (deepEqual(current[key], before[key]))
+        delete merged[key];
+      else
+        conflicts.push(`${conflictPath}：平台删除了业务已修改的 snapshot 节点 ${nextPath.join(".")}`);
+      continue;
+    }
+    if (!(key in before)) {
+      if (!(key in current) || deepEqual(current[key], after[key])) {
+        merged[key] = structuredClone(after[key]);
+      } else {
+        conflicts.push(`${conflictPath}：平台新增的 snapshot 节点已被业务占用 ${nextPath.join(".")}`);
+      }
+      continue;
+    }
+    merged[key] = applySnapshotDelta(before[key], after[key], current[key], nextPath, conflicts, conflictPath);
+  }
+  return merged;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function deepEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+// src/update/migration-reconciler.ts
+var drizzleRoot = "packages/database/drizzle";
+var journalPath = `${drizzleRoot}/meta/_journal.json`;
+var migrationPattern = /^(\d{4})_(.+)$/;
+async function reconcileDrizzleMigrations(input) {
+  const journals = await readJournals(input);
+  if (!journals) {
+    return unchanged(input.targetManifest);
+  }
+  const { base, project, target } = journals;
+  const conflicts = [];
+  validateUniqueNames(base, "来源模板", conflicts);
+  validateUniqueNames(project, "当前项目", conflicts);
+  validateUniqueNames(target, "目标模板", conflicts);
+  if (conflicts.length) {
+    return { ...unchanged(input.targetManifest), conflicts };
+  }
+  const baseNames = new Set(base.entries.map(({ tag }) => stableName(tag)));
+  const projectNames = new Set(project.entries.map(({ tag }) => stableName(tag)));
+  const managedNames = new Set(input.sourceManifest.files.filter(({ path: path2 }) => isSqlMigration(path2)).map(({ path: path2 }) => stableName(path2.slice(drizzleRoot.length + 1, -4))));
+  const candidates = target.entries.filter(({ tag }) => !baseNames.has(stableName(tag)));
+  for (const { tag } of candidates) {
+    const name = stableName(tag);
+    if (projectNames.has(name) && !managedNames.has(name)) {
+      conflicts.push(`${journalPath}：平台 migration 名称与下游业务历史冲突 ${name}`);
+    }
+  }
+  const additions = candidates.filter(({ tag }) => !projectNames.has(stableName(tag)));
+  const contentOverrides = new Map;
+  const files = await preservePublishedHistory(input.sourceManifest, input.projectDirectory, contentOverrides);
+  const publishedPaths = new Set(files.map(({ path: path2 }) => path2));
+  files.push(...input.targetManifest.files.filter(({ path: path2 }) => !isDrizzleHistoryPath(path2)));
+  if (!additions.length) {
+    const journalContent2 = encodeJson(project);
+    contentOverrides.set(journalPath, journalContent2);
+    files.push(managedEntry(journalPath, journalContent2));
+    return result(input.targetManifest, files, contentOverrides, publishedPaths, conflicts);
+  }
+  let nextPrefix = highestPrefix(project) + 1;
+  let nextIndex = highestIndex(project) + 1;
+  let previousWhen = project.entries.at(-1)?.when ?? 0;
+  let currentSnapshot = await readLatestSnapshot(input.projectDirectory, project);
+  const mergedJournal = structuredClone(project);
+  for (const addition of additions) {
+    const targetPosition = target.entries.indexOf(addition);
+    const previousTarget = target.entries[targetPosition - 1];
+    if (!previousTarget) {
+      conflicts.push(`${journalPath}：目标 migration 缺少前置快照`);
+      break;
+    }
+    const targetBefore = await readSnapshot(input.targetDirectory, previousTarget.tag);
+    const targetAfter = await readSnapshot(input.targetDirectory, addition.tag);
+    const merged = applySnapshotDelta(targetBefore, targetAfter, currentSnapshot, [], conflicts, journalPath);
+    if (conflicts.length)
+      break;
+    const prefix = String(nextPrefix).padStart(4, "0");
+    const name = stableName(addition.tag);
+    const tag = `${prefix}_${name}`;
+    const sqlPath = `${drizzleRoot}/${tag}.sql`;
+    const snapshotPath = `${drizzleRoot}/meta/${prefix}_snapshot.json`;
+    const sql = await readFile13(join14(input.targetDirectory, `${drizzleRoot}/${addition.tag}.sql`));
+    merged.id = targetAfter.id;
+    merged.prevId = currentSnapshot.id;
+    const snapshot = encodeJson(merged);
+    contentOverrides.set(sqlPath, sql);
+    contentOverrides.set(snapshotPath, snapshot);
+    files.push(managedEntry(sqlPath, sql), managedEntry(snapshotPath, snapshot));
+    previousWhen = Math.max(previousWhen + 1, addition.when);
+    mergedJournal.entries.push({
+      ...addition,
+      idx: nextIndex,
+      when: previousWhen,
+      tag
+    });
+    currentSnapshot = merged;
+    nextPrefix += 1;
+    nextIndex += 1;
+  }
+  const journalContent = encodeJson(mergedJournal);
+  contentOverrides.set(journalPath, journalContent);
+  files.push(managedEntry(journalPath, journalContent));
+  return result(input.targetManifest, files, contentOverrides, publishedPaths, conflicts);
+}
+function result(targetManifest, files, contentOverrides, forcePreserves, conflicts) {
+  return {
+    targetManifest: {
+      ...targetManifest,
+      files: deduplicate(files).sort((left, right) => left.path.localeCompare(right.path))
+    },
+    contentOverrides,
+    forceUpdates: new Set([journalPath]),
+    forcePreserves,
+    conflicts
+  };
+}
+function unchanged(targetManifest) {
+  return {
+    targetManifest,
+    contentOverrides: new Map,
+    forceUpdates: new Set,
+    forcePreserves: new Set,
+    conflicts: []
+  };
+}
+async function readJournals(input) {
+  try {
+    const [base, project, target] = await Promise.all([
+      readJson(join14(input.baseDirectory, journalPath)),
+      readJson(join14(input.projectDirectory, journalPath)),
+      readJson(join14(input.targetDirectory, journalPath))
+    ]);
+    return { base, project, target };
+  } catch (error) {
+    if (isMissing4(error))
+      return;
+    throw error;
+  }
+}
+async function preservePublishedHistory(manifest, projectDirectory, overrides) {
+  const entries = manifest.files.filter(({ path: path2 }) => isMigrationArtifact(path2) && path2 !== journalPath);
+  await Promise.all(entries.map(async ({ path: path2 }) => {
+    overrides.set(path2, await readFile13(join14(projectDirectory, path2)));
+  }));
+  return entries;
+}
+async function readLatestSnapshot(root, journal) {
+  const latest = journal.entries.at(-1);
+  if (!latest)
+    throw new Error(`${journalPath}：当前项目没有 migration`);
+  return await readSnapshot(root, latest.tag);
+}
+async function readSnapshot(root, tag) {
+  const match = migrationPattern.exec(tag);
+  if (!match)
+    throw new Error(`${journalPath}：migration tag 格式无效：${tag}`);
+  return await readJson(join14(root, `${drizzleRoot}/meta/${match[1]}_snapshot.json`));
+}
+function validateUniqueNames(journal, label, conflicts) {
+  const seen = new Set;
+  for (const { tag } of journal.entries) {
+    const name = stableName(tag);
+    if (seen.has(name)) {
+      conflicts.push(`${journalPath}：${label}存在重复 migration 名称 ${name}`);
+    }
+    seen.add(name);
+  }
+}
+function stableName(tag) {
+  return migrationPattern.exec(tag)?.[2] ?? tag;
+}
+function highestPrefix(journal) {
+  return Math.max(-1, ...journal.entries.map(({ tag }) => Number(migrationPattern.exec(tag)?.[1] ?? -1)));
+}
+function highestIndex(journal) {
+  return Math.max(-1, ...journal.entries.map(({ idx }) => idx));
+}
+function isDrizzleHistoryPath(path2) {
+  return path2 === journalPath || isMigrationArtifact(path2);
+}
+function isMigrationArtifact(path2) {
+  return isSqlMigration(path2) || new RegExp(`^${drizzleRoot}/meta/\\d{4}_snapshot\\.json$`).test(path2);
+}
+function isSqlMigration(path2) {
+  return new RegExp(`^${drizzleRoot}/\\d{4}_.+\\.sql$`).test(path2);
+}
+function managedEntry(path2, content) {
+  return { path: path2, ownership: "windy-managed", hash: hashContent(content) };
+}
+function deduplicate(files) {
+  return [...new Map(files.map((entry) => [entry.path, entry])).values()];
+}
+function encodeJson(value) {
+  return new TextEncoder().encode(`${JSON.stringify(value, null, 2)}
+`);
+}
+async function readJson(path2) {
+  return JSON.parse(await readFile13(path2, "utf8"));
+}
+function isMissing4(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
 
 // src/update/package-merge.ts
 function mergePackageJson(base, ours, theirs) {
@@ -4234,10 +4675,18 @@ async function createUpdatePlan(request, artifacts) {
     throw new Error(`当前 CLI 只能更新到 ${targetProvenance.generatorVersion}，请运行 create-windy@${targetVersion}`);
   }
   const recipes2 = resolveRecipeChain(provenance.windyVersion, targetVersion);
-  const [sourceManifest, targetManifest] = await Promise.all([
+  const [sourceManifest, generatedTargetManifest] = await Promise.all([
     readManagedFilesManifest(request.projectDirectory),
     readManagedFilesManifest(artifactSet.targetDirectory)
   ]);
+  const migrations = await reconcileDrizzleMigrations({
+    projectDirectory: request.projectDirectory,
+    baseDirectory: artifactSet.baseDirectory,
+    targetDirectory: artifactSet.targetDirectory,
+    sourceManifest,
+    targetManifest: generatedTargetManifest
+  });
+  const targetManifest = migrations.targetManifest;
   targetProvenance.appliedRecipes = [
     ...provenance.appliedRecipes,
     ...recipes2.map(({ id }) => id)
@@ -4250,7 +4699,9 @@ async function createUpdatePlan(request, artifacts) {
   for (const path2 of [...paths].sort()) {
     if (metadataPaths.has(path2))
       continue;
-    const file = await planFile(path2, request.projectDirectory, artifactSet.baseDirectory, artifactSet.targetDirectory, sourceEntries.get(path2), targetEntries.get(path2), provenance);
+    const forcedContent = migrations.forceUpdates.has(path2) ? migrations.contentOverrides.get(path2) : undefined;
+    const forcePreserve = migrations.forcePreserves.has(path2);
+    const file = forcePreserve ? ready(path2, sourceEntries.get(path2)?.ownership ?? classifyOwnership(path2), "preserve", "保留项目已发布 migration 历史") : forcedContent ? ready(path2, targetEntries.get(path2)?.ownership ?? sourceEntries.get(path2)?.ownership ?? classifyOwnership(path2), "update", "合并平台与下游 migration 历史", forcedContent) : await planFile(path2, request.projectDirectory, artifactSet.baseDirectory, artifactSet.targetDirectory, sourceEntries.get(path2), targetEntries.get(path2), provenance, migrations.contentOverrides.get(path2));
     if (oxcManagedPaths.has(path2) && file.reason === "客户已修改") {
       file.action = "preserve";
       delete file.conflict;
@@ -4258,7 +4709,10 @@ async function createUpdatePlan(request, artifacts) {
     }
     files.push(file);
   }
-  const conflicts = files.flatMap((file) => file.conflict ? [`${file.path}：${file.conflict}`] : []);
+  const conflicts = [
+    ...migrations.conflicts,
+    ...files.flatMap((file) => file.conflict ? [`${file.path}：${file.conflict}`] : [])
+  ];
   return {
     id: createUpdateId(provenance.windyVersion, targetVersion),
     projectDirectory: request.projectDirectory,
@@ -4273,11 +4727,11 @@ async function createUpdatePlan(request, artifacts) {
     temporaryRoot: artifactSet.temporaryRoot
   };
 }
-async function planFile(path2, project, baseRoot, targetRoot, source, target, provenance) {
+async function planFile(path2, project, baseRoot, targetRoot, source, target, provenance, targetContentOverride) {
   const [ours, base, theirs] = await Promise.all([
-    readOptional(join14(project, path2)),
-    readOptional(join14(baseRoot, path2)),
-    readOptional(join14(targetRoot, path2))
+    readOptional(join15(project, path2)),
+    readOptional(join15(baseRoot, path2)),
+    targetContentOverride ? Promise.resolve(targetContentOverride) : readOptional(join15(targetRoot, path2))
   ]);
   const ownership = target?.ownership || source?.ownership || classifyOwnership(path2);
   const repaired = ours && theirs && provenance ? repairKnownDerivedFile({
@@ -4322,16 +4776,17 @@ async function planFile(path2, project, baseRoot, targetRoot, source, target, pr
     return conflict(path2, ownership, "文件状态不完整，不能安全推断");
   }
   const oursChanged = hashContent(ours) !== source.hash;
-  const targetChanged = target.hash !== source.hash;
+  const targetChanged = targetChangedSinceBase(source.hash, base, theirs);
+  const reconstructedBaseDrifted = !!base && hashContent(base) !== source.hash;
   if (!oursChanged && !targetChanged)
     return ready(path2, ownership, "preserve", "双方未修改");
-  if (!oursChanged)
+  if (!oursChanged && !reconstructedBaseDrifted)
     return ready(path2, ownership, "update", "仅 Windy 修改", theirs);
   if (!targetChanged)
     return ready(path2, ownership, "preserve", "客户已修改");
   if (hashContent(ours) === target.hash)
     return ready(path2, ownership, "preserve", "已包含目标内容");
-  if (path2 === "package.json" && base) {
+  if (path2.endsWith("package.json") && base) {
     const merged = mergePackageJson(base, ours, theirs);
     return merged.content ? ready(path2, ownership, "update", "package.json 字段级合并", merged.content) : conflict(path2, ownership, `字段冲突：${merged.conflicts.join("、")}`);
   }
@@ -4341,6 +4796,9 @@ async function planFile(path2, project, baseRoot, targetRoot, source, target, pr
   }
   return conflict(path2, ownership, "客户和 Windy 均已修改");
 }
+function targetChangedSinceBase(sourceHash, base, target) {
+  return base && target ? hashContent(base) !== hashContent(target) : !!target && hashContent(target) !== sourceHash;
+}
 function ready(path2, ownership, action, reason, content) {
   return { path: path2, ownership, action, reason, content };
 }
@@ -4355,7 +4813,7 @@ function conflict(path2, ownership, reason) {
 }
 async function readOptional(path2) {
   try {
-    return await readFile13(path2);
+    return await readFile14(path2);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return;
@@ -4363,15 +4821,15 @@ async function readOptional(path2) {
   }
 }
 async function assertGitClean(projectDirectory) {
-  const result = await captureProcess("git", ["status", "--porcelain"], projectDirectory);
-  if (result.code !== 0)
+  const result2 = await captureProcess("git", ["status", "--porcelain"], projectDirectory);
+  if (result2.code !== 0)
     throw new Error("更新要求当前目录是有效的 Git 仓库");
-  if (result.stdout.trim())
+  if (result2.stdout.trim())
     throw new Error("更新前请先提交或暂存之外妥善处理 Git 工作区改动");
 }
 async function assertNoPendingUpdate(projectDirectory) {
   try {
-    await access3(join14(projectDirectory, ".windy/update-state.json"));
+    await access3(join15(projectDirectory, ".windy/update-state.json"));
     throw new Error("检测到未完成更新，请先运行 bun run windy doctor --repair");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
@@ -4402,75 +4860,75 @@ class DefaultStarterUpdater {
       throw error;
     }
   }
-  async verify(result) {
+  async verify(result2) {
     const steps = [];
     try {
-      await this.#execute("bun", ["install", "--force"], result.plan.projectDirectory);
+      await this.#execute("bun", ["install", "--force"], result2.plan.projectDirectory);
       steps.push({ name: "bun install --force", status: "passed" });
-      const packageJson = JSON.parse(await readFile14(join15(result.plan.projectDirectory, "package.json"), "utf8"));
+      const packageJson = JSON.parse(await readFile15(join16(result2.plan.projectDirectory, "package.json"), "utf8"));
       for (const name of ["lint", "typecheck", "test", "build"]) {
         if (!packageJson.scripts?.[name]) {
           steps.push({ name: `bun run ${name}`, status: "skipped" });
           continue;
         }
-        await this.#execute("bun", ["run", name], result.plan.projectDirectory);
+        await this.#execute("bun", ["run", name], result2.plan.projectDirectory);
         steps.push({ name: `bun run ${name}`, status: "passed" });
       }
-      await finalize(result);
-      const reportPath = `.windy/reports/${result.plan.id}.md`;
-      await writeReport(result, steps, reportPath);
-      await clearUpdateState(result.plan.projectDirectory);
-      await rm7(result.plan.temporaryRoot, { recursive: true, force: true });
-      return { updateId: result.plan.id, status: "passed", steps, reportPath };
+      await finalize(result2);
+      const reportPath = `.windy/reports/${result2.plan.id}.md`;
+      await writeReport(result2, steps, reportPath);
+      await clearUpdateState(result2.plan.projectDirectory);
+      await rm7(result2.plan.temporaryRoot, { recursive: true, force: true });
+      return { updateId: result2.plan.id, status: "passed", steps, reportPath };
     } catch (error) {
-      await restoreUpdateState(result.plan.projectDirectory, {
+      await restoreUpdateState(result2.plan.projectDirectory, {
         schemaVersion: 1,
-        updateId: result.plan.id,
-        backupDirectory: result.backupDirectory,
-        entries: result.backupEntries
+        updateId: result2.plan.id,
+        backupDirectory: result2.backupDirectory,
+        entries: result2.backupEntries
       });
-      await rm7(result.plan.temporaryRoot, { recursive: true, force: true });
-      throw new Error(`更新验证失败，项目已回滚到 ${result.plan.sourceVersion}：${error instanceof Error ? error.message : String(error)}`, { cause: error });
+      await rm7(result2.plan.temporaryRoot, { recursive: true, force: true });
+      throw new Error(`更新验证失败，项目已回滚到 ${result2.plan.sourceVersion}：${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
   }
 }
-async function finalize(result) {
-  const root = result.plan.projectDirectory;
-  const generationContent = `${JSON.stringify(result.plan.targetProvenance, null, 2)}
+async function finalize(result2) {
+  const root = result2.plan.projectDirectory;
+  const generationContent = `${JSON.stringify(result2.plan.targetProvenance, null, 2)}
 `;
-  await writeFile11(join15(root, ".windy/generation.json"), generationContent);
+  await writeFile11(join16(root, ".windy/generation.json"), generationContent);
   const refreshedPaths = new Set([
     ".windy/generation.json",
-    ...result.plan.files.filter(({ action }) => action === "create" || action === "update").map(({ path: path2 }) => path2)
+    ...result2.plan.files.filter(({ action }) => action === "create" || action === "update").map(({ path: path2 }) => path2)
   ]);
-  const refreshedHashes = new Map(await Promise.all([...refreshedPaths].map(async (path2) => [path2, hashContent(await readFile14(join15(root, path2)))])));
+  const refreshedHashes = new Map(await Promise.all([...refreshedPaths].map(async (path2) => [path2, hashContent(await readFile15(join16(root, path2)))])));
   const targetManifest = {
-    ...result.plan.targetManifest,
-    files: result.plan.targetManifest.files.map((entry) => ({
+    ...result2.plan.targetManifest,
+    files: result2.plan.targetManifest.files.map((entry) => ({
       ...entry,
       hash: refreshedHashes.get(entry.path) ?? entry.hash
     }))
   };
-  await writeFile11(join15(root, ".windy/files.json"), `${JSON.stringify(targetManifest, null, 2)}
+  await writeFile11(join16(root, ".windy/files.json"), `${JSON.stringify(targetManifest, null, 2)}
 `);
 }
-async function writeReport(result, steps, relativePath2) {
-  const path2 = join15(result.plan.projectDirectory, relativePath2);
+async function writeReport(result2, steps, relativePath2) {
+  const path2 = join16(result2.plan.projectDirectory, relativePath2);
   await mkdir7(dirname4(path2), { recursive: true });
   const lines = [
-    `# Windy 更新报告 ${result.plan.id}`,
+    `# Windy 更新报告 ${result2.plan.id}`,
     "",
-    `- 来源版本：${result.plan.sourceVersion}`,
-    `- 目标版本：${result.plan.targetVersion}`,
-    `- Recipe：${result.plan.recipes.join("、") || "无"}`,
-    `- 修改文件：${result.changedFiles.length}`,
-    `- Oxc 代管：${result.plan.detachedToolchain ? "已检测到客户接管并保留" : "保持"}`,
+    `- 来源版本：${result2.plan.sourceVersion}`,
+    `- 目标版本：${result2.plan.targetVersion}`,
+    `- Recipe：${result2.plan.recipes.join("、") || "无"}`,
+    `- 修改文件：${result2.changedFiles.length}`,
+    `- Oxc 代管：${result2.plan.detachedToolchain ? "已检测到客户接管并保留" : "保持"}`,
     "",
     "## 验证",
     "",
     ...steps.map(({ name, status }) => `- ${name}：${status}`),
     "",
-    `备份保留在 \`.windy/backups/${result.plan.id}\`，确认稳定后可人工删除。`,
+    `备份保留在 \`.windy/backups/${result2.plan.id}\`，确认稳定后可人工删除。`,
     ""
   ];
   await writeFile11(path2, lines.join(`
@@ -4482,7 +4940,7 @@ async function runLifecycleCommand(args) {
   const command = args[0];
   if (command !== "doctor" && command !== "update")
     return false;
-  const projectDirectory = resolve4(readValue2(args, "--cwd") || process.cwd());
+  const projectDirectory = resolve5(readValue2(args, "--cwd") || process.cwd());
   if (command === "doctor") {
     const report = await diagnoseProject(projectDirectory, args.includes("--repair"));
     printDoctor(report);
@@ -4534,8 +4992,8 @@ async function runUpdate(args, projectDirectory) {
     await rm8(plan.temporaryRoot, { recursive: true, force: true });
     throw new Error("存在更新冲突；请按上方清单处理后重新运行，项目未被修改");
   }
-  const result = await updater.apply(plan);
-  const report = await updater.verify(result);
+  const result2 = await updater.apply(plan);
+  const report = await updater.verify(result2);
   console.log(`
 更新完成：${plan.sourceVersion} → ${plan.targetVersion}`);
   console.log(`报告：${report.reportPath}`);