create-windy 0.3.1 → 0.3.2

package/README.md

@@ -156,9 +156,13 @@ hash 的 missing tombstone 记住客户删除的 `project-owned` 路径；后续
 
 公网 `0.2.34` 的默认推荐模块项目也先对账到 `0.3.0`。该 profile 只有在 Project
 Lock、Oxfmt 配置、manifest 与来源 artifact 哈希全部精确命中时才启用专属 proof；
-未知 formatter 输出继续保持未决。真实两个默认项目名均为 12 个可证明、0 个未决，
+未知 formatter 输出继续保持未决。当前公网默认项目实测为 11 个可证明、0 个未决，
 而非默认的 sharp-sword 仍为 5 个可证明、2 个未决。
 
+发布后隔离回归确认全新 `0.3.1` 默认 Git/Oxc 项目 doctor 为 `0/0`，但真实
+`0.2.34` 经上述对账和更新后仍存在受管 hash 漂移。因此 `0.3.1` 暂不用于既有下游
+最终升级验收；等待后续补丁重新取得公开历史升级的 `0/0` 证据。
+
 本地 Web 默认使用 8746；如果该端口属于其它服务，会自动尝试 8747、8748 等端口。
 如果检测到同一个项目已启动，则直接复用现有地址。
 

package/dist/cli.js

@@ -1145,6 +1145,10 @@ packages/database/src/schema/governance.ts|8884f7abe27bc2f4d1217bd731c5d69909ed3
 packages/modules/src/system-module-catalog.test.ts|805545e8fb4f64e7ca737b5daa5b7025fc9ef689e93825e6bf6b76e42dffbc44|6d147dd812687626a756370b0cba7fbc411a2ddb74e467dca7a979f049bbb768
 packages/modules/src/system-modules.test.ts|d183047dbbb8575fae2509bd5bb35cd8120cb833eeb4e5f76f9514a292f34b31|9fd7167a54162a044dd3ced2f4194b8d4303b9fec1e1ffb3189b3dba642d3794
 packages/modules/src/system-modules.ts|31f2db476c7222f124c9b3cbb30f2ab2e0ed6402d780e2daed0e2b693f60f41b|515964c29005b3e9fd6df4f9c5913ed561bf6b04277df52debeabe427af75b51
+apps/server/src/system/routes.ts|ac853ab1327141ce9b320405b761f78fa574cc1ae18a137c4fecb5c35d3103f1|5a3d774a40621cb525c9069bd486e8bd31f66866451c8282902dae91811de78d
+apps/web/src/pages/system/components/SystemResourcePage.vue|0a338f3280fcbdef8467c769d0a7ea412fdd114e7a7b392e77db5694a6d2f54b|abe1925fb2ab1560f219e04b0a8839f6d9fa8a65949a054b543e7b119f2960d2
+packages/modules/src/system-modules.test.ts|e1d3c926db7207e6c3681af308cbde5339046c28c40e6595c0d60ad4cfe36ba5|a704820000bc66be16f7c27be3643724abee5f787b3cb57fac46d78c8d65e511
+packages/modules/src/system-modules.ts|377c9df768c0a8a44ee1aa1806b7499d5db9ff991bdc2f7f44511fa92786ee80|a12cab4500642d5408cab2e736f591c6a3552cb1e3d328826eacdf8311cfdf2c
 `.trim().split(`
 `).map((line) => line.split("|"));
 var createWindy030ManagedFormatProofs = Object.freeze(formattedEntries2.map(([path, artifactHash, currentHash]) => Object.freeze({
@@ -1160,6 +1164,41 @@ var createWindy030ManagedFormatProofs = Object.freeze(formattedEntries2.map(([pa
   cause: "post-manifest-oxfmt"
 })));
 
+// src/reconcile/proof-catalog-0234-core.ts
+var createWindy0234CoreProfileId = "0.2.34-core-oxfmt-0.59";
+var formattedEntries3 = `
+apps/server/src/system/drizzle-system.ts|68bc34e374a90860a541d2e6b5210ff8a8a8a33fe50741238f56614033636d35|4edf6bbec9bd9c36e97aa0b1d4ae57b5711c2b06d600e424166688432633d929|b070a7bf7c9ce6351b250ea25f01be9dfc150a6f56147a2885ef1e4f8c7d23aa
+apps/server/src/system/routes.test.ts|16448fa8148fbaddd580f4be3e5e8dfd499609f5b7af314c183dc9e89d8f2d97|fc1b138ca6c226ac520b170b445e22aa1cc50f7249f4b3de28bb93760e28a98c|0ab1189ddedfe718f66efba91773285ab71850ec0caca72754dd98eb01edb4b2
+apps/server/src/system/routes.ts|c350189c46c7e4716ba8a4e37c695c823e856ac87333a2475ecd1bbddfb395bb|2efe876f5544fd0fa4b6a6c1c40503f22637e6f3f0222d0345d422b1ab430965|ac853ab1327141ce9b320405b761f78fa574cc1ae18a137c4fecb5c35d3103f1
+apps/web/src/composables/usePlatformSettings.ts|68e2959ac0b5d1fe3fb3611d1875d62b9e64694472093a1662c5350f7c776a86|c3d9b1d7c8f2d59563f7ed647b59b4e115c3a448f2b3717aadacbfe1e9533f1b|9a0bc4d8dff0bd1212b8c15b1f4e3dbbecce48c099bbd20d5d7ec6f2a097d937
+apps/web/src/pages/system/components/SystemResourceFilters.vue|45508adf2cb741d7f5b718b91272e9521a2630562512c9ce4c4aaaeb42488723|d82b8b8497b5378d22f40ef276cf37840d8daed823223d094b675980a2e49b13|989bf1117fc84d4e8ea769954b12340f609a8653c4529cc70cd690df2d1904de
+apps/web/src/pages/system/components/SystemResourcePage.vue|7ff844cd24170002b79ed5b7082dd8a0531f0c3927a00c3394496bc7b0c4179d|8df16b98beac92d4de712a3b1b36ea4c788bc9d2a4b7f623c4dc6cf239a18b1e|0a338f3280fcbdef8467c769d0a7ea412fdd114e7a7b392e77db5694a6d2f54b
+apps/web/src/pages/system/components/SystemResourcePage.webtest.ts|4b2e76b3042f1023cbc187e6f960127b0c157fdcebf1524eddcfa742db4b69ff|fbcebcb2ea2962fc4633a43b3c2bbcc36535f9dd0dbd8775665902017e568150|bfaeb5b1d6ea209603fc2946b3f0d70bf029d182cfd06d769c3c10482f2d9e6b
+apps/web/src/pages/system/resource-config.ts|e8ee83d2ce377dc6cfb41675f55a9093b0f2336179d7760c2acac61220c64d99|a7e76a44a1757483b626d4639ed0c64cca2e296ae4c6444756e42d0798bc0a55|cfb0fffb9cbbecd8d4fa630df6e5ddf2218181a8bf5b3535fd17bb36095890dd
+docs/platform/system-crud-api.md|3558368ac2ec7ab22423d34dc450666bf0983671422cb5b8d781e7716a390243|4aa4924ee0cbce3e488e350a1dfe73910d4eab4015d31899f93d238cc74e894a|86c485333ace7162a7dbd190ee1632215e04bd21627b57e4e308433b0cc0d38c
+packages/modules/src/system-modules.test.ts|887a23c30de141efe157b2cd70ee241965b766e5483975ac66981d9e2f818d02|5379d9ab37ca82393ff571e029ee91c233067c0fc57ee24820e63c25ffaa0f35|e1d3c926db7207e6c3681af308cbde5339046c28c40e6595c0d60ad4cfe36ba5
+packages/modules/src/system-modules.ts|377c9df768c0a8a44ee1aa1806b7499d5db9ff991bdc2f7f44511fa92786ee80|a12cab4500642d5408cab2e736f591c6a3552cb1e3d328826eacdf8311cfdf2c|377c9df768c0a8a44ee1aa1806b7499d5db9ff991bdc2f7f44511fa92786ee80
+`.trim().split(`
+`).map((line) => line.split("|"));
+var createWindy0234CoreProofs = Object.freeze(formattedEntries3.map(([path, artifactHash, currentHash, targetHash]) => Object.freeze({
+  id: `${createWindy0234CoreProfileId}:${path}`,
+  profileId: createWindy0234CoreProfileId,
+  path,
+  sourceVersion: "0.2.34",
+  sourceIntegrity: createWindy0234Integrity,
+  targetVersion: "0.3.0",
+  targetIntegrity: createWindy030Integrity,
+  artifactHash,
+  currentHash,
+  targetHash,
+  cause: "post-manifest-oxfmt"
+})));
+var createWindy0234CoreProfile = Object.freeze({
+  ...createWindy0234DefaultProfile,
+  id: createWindy0234CoreProfileId,
+  generationHash: "d813160ddf27c1acf81e4518e3b576488201dcf30a2b7d4c9e7e533687e90c92"
+});
+
 // src/reconcile/proof-catalog.ts
 var source0234Integrity = "sha512-Gx1usyfuMKVwzybfuqWSAzxPJrI01tl4rW6MX5lJ4Q3wPHZm7nbSeCjrLYzWGtlZUM9THCryC4M49rFnph/8Ew==";
 var target030Integrity = "sha512-iCEnmaRuxiB+P/ZK3tgBZCQ+q17fNl9lqJPjC68JgF+QEGywo+twjEb93vx++cfAaamVkMbec4MmsY3pyOK+NA==";
@@ -1173,6 +1212,7 @@ var legacyManagedFormatProofs = Object.freeze([
 var releasedManagedFormatProofs = Object.freeze([
   ...legacyManagedFormatProofs,
   ...createWindy0234DefaultProofs,
+  ...createWindy0234CoreProofs,
   ...createWindy030ManagedFormatProofs
 ]);
 function resolveProofIdentity(proofs, sourceVersion, targetVersion) {
@@ -1656,10 +1696,13 @@ var canonicalHashes = Object.freeze({
   current: "72eb9e6c1f0763a151d6d8a8902ca65529dd035304c065eae3d15c8a8a29dc75"
 });
 var wideCharacter = /[\u1100-\u115f\u2329\u232a\u2e80-\ua4cf\uac00-\ud7a3\uf900-\ufaff\ufe10-\ufe19\ufe30-\ufe6f\uff00-\uff60\uffe0-\uffe6]/;
-async function resolveCreateWindy0234ReadmeProof(projectDirectory) {
+async function resolveCreateWindy0234ReadmeProof(projectDirectory, profileId = createWindy0234DefaultProfileId) {
   const projectName = await readProjectName2(projectDirectory);
   if (!projectName)
     return;
+  if (profileId === createWindy0234CoreProfileId) {
+    return createCoreReadmeProof(projectName);
+  }
   const source = readme_template_0234_default.replaceAll(projectNamePlaceholder2, projectName);
   const current = formatKnownMarkdown(source);
   if (hash2(readme_template_0234_default) !== canonicalHashes.source || hash2(formatKnownMarkdown(readme_template_0234_default)) !== canonicalHashes.current) {
@@ -1682,6 +1725,36 @@ async function resolveCreateWindy0234ReadmeProof(projectDirectory) {
     cause: "post-manifest-oxfmt"
   });
 }
+function createCoreReadmeProof(projectName) {
+  const source = coreModuleSelection(readme_template_0234_default).replaceAll(projectNamePlaceholder2, projectName);
+  const current = formatKnownMarkdown(source);
+  const targetCurrent = coreModuleSelection(readme_template_030_default).replaceAll("WINDYPROJECTNAMEPLACEHOLDER030", projectName);
+  const target = reverseKnownOxfmtChanges(targetCurrent);
+  return Object.freeze({
+    id: `${createWindy0234CoreProfileId}:README.md`,
+    profileId: createWindy0234CoreProfileId,
+    path: "README.md",
+    sourceVersion: "0.2.34",
+    sourceIntegrity: createWindy0234Integrity,
+    targetVersion: "0.3.0",
+    targetIntegrity: createWindy030Integrity,
+    artifactHash: hash2(source),
+    currentHash: hash2(current),
+    targetHash: hash2(target),
+    cause: "post-manifest-oxfmt"
+  });
+}
+function coreModuleSelection(content) {
+  const coreOptionalModules = new Set([
+    "system.settings",
+    "system.configuration",
+    "system.audit",
+    "system.operations"
+  ]);
+  return content.split(`
+`).map((line) => [...coreOptionalModules].some((name) => line.startsWith(`| \`${name}\``)) ? line.replace("\u5DF2\u5305\u542B", "\u672A\u5305\u542B") : line).join(`
+`);
+}
 function formatKnownMarkdown(content) {
   const lines = content.replace(`
 
@@ -1880,16 +1953,19 @@ async function readManagedFilesManifest(targetDirectory, trustedProofs = release
   return (await readManagedFilesManifestSnapshot(targetDirectory, trustedProofs)).manifest;
 }
 async function readManagedFilesManifestSnapshot(targetDirectory, trustedProofs = releasedManagedFormatProofs) {
-  const [content, readmeProof030, readmeProof0234] = await Promise.all([
+  const [content, readmeProof030, readmeProof0234, readmeProof0234Core] = await Promise.all([
     readFile4(join4(targetDirectory, managedFilesManifestPath)),
     resolveCreateWindy030ReadmeProof(targetDirectory),
-    resolveCreateWindy0234ReadmeProof(targetDirectory)
+    resolveCreateWindy0234ReadmeProof(targetDirectory),
+    resolveCreateWindy0234ReadmeProof(targetDirectory, createWindy0234CoreProfileId)
   ]);
   const effectiveProofs = [...trustedProofs];
   if (readmeProof030)
     effectiveProofs.push(readmeProof030);
   if (readmeProof0234)
     effectiveProofs.push(readmeProof0234);
+  if (readmeProof0234Core)
+    effectiveProofs.push(readmeProof0234Core);
   return {
     content,
     hash: hashContent(content),
@@ -5881,8 +5957,8 @@ function sentenceWithoutStop(value) {
 }
 
 // src/update/cli.ts
-import { rm as rm9 } from "fs/promises";
-import { resolve as resolve6 } from "path";
+import { rm as rm10 } from "fs/promises";
+import { resolve as resolve7 } from "path";
 
 // src/reconcile/managed-reconciler.ts
 import { rm as rm6 } from "fs/promises";
@@ -8556,7 +8632,8 @@ var recipes = [
   { id: "starter-0.2.32-to-0.2.33", from: "0.2.32", to: "0.2.33" },
   { id: "starter-0.2.33-to-0.2.34", from: "0.2.33", to: "0.2.34" },
   { id: "starter-0.2.34-to-0.3.0", from: "0.2.34", to: "0.3.0" },
-  { id: "starter-0.3.0-to-0.3.1", from: "0.3.0", to: "0.3.1" }
+  { id: "starter-0.3.0-to-0.3.1", from: "0.3.0", to: "0.3.1" },
+  { id: "starter-0.3.1-to-0.3.2", from: "0.3.1", to: "0.3.2" }
 ];
 function resolveRecipeChain(sourceVersion, targetVersion) {
   if (sourceVersion === targetVersion)
@@ -8771,7 +8848,7 @@ function createReconcileId(sourceVersion, targetVersion) {
 }
 
 // src/reconcile/proof-profile.ts
-var releasedManagedProofProfiles = Object.freeze([createWindy0234DefaultProfile]);
+var releasedManagedProofProfiles = Object.freeze([createWindy0234DefaultProfile, createWindy0234CoreProfile]);
 async function resolveManagedProofProfile(input) {
   const candidates = (input.profiles ?? releasedManagedProofProfiles).filter((profile) => profile.sourceVersion === input.sourceVersion && profile.sourceIntegrity === input.sourceIntegrity && profile.targetVersion === input.targetVersion && profile.targetIntegrity === input.targetIntegrity && profile.generationHash === input.generationHash);
   const matches2 = [];
@@ -8807,7 +8884,7 @@ async function resolveReconcileProofContext(input) {
   const profileId = await resolveManagedProofProfile(input);
   const [readme030, readme0234] = await Promise.all([
     resolveCreateWindy030ReadmeProof(input.projectDirectory),
-    profileId ? resolveCreateWindy0234ReadmeProof(input.projectDirectory) : null
+    profileId ? resolveCreateWindy0234ReadmeProof(input.projectDirectory, profileId) : null
   ]);
   const effectiveProofs = input.proofs.filter((proof2) => !proof2.profileId || proof2.profileId === profileId);
   if (readme030)
@@ -9174,14 +9251,14 @@ class PublicReconcileArtifactProvider {
     const temporaryRoot = await mkdtemp2(join26(tmpdir2(), "windy-reconcile-"));
     try {
       const provenance = await readGenerationProvenance(input.projectDirectory);
-      const sourceArtifact = await downloadArtifact(temporaryRoot, "source", input.sourceVersion, input.sourceIntegrity, this.#fetch);
+      const sourceArtifact = await downloadPublicArtifact(temporaryRoot, "source", input.sourceVersion, input.sourceIntegrity, this.#fetch);
       if (sourceArtifact.identity.templateCommit !== provenance.templateCommit) {
         throw new Error("Project Lock \u4E0E\u6765\u6E90 artifact \u7684 template commit \u4E0D\u4E00\u81F4");
       }
-      const targetArtifact = await downloadArtifact(temporaryRoot, "target", input.targetVersion, input.targetIntegrity, this.#fetch);
+      const targetArtifact = await downloadPublicArtifact(temporaryRoot, "target", input.targetVersion, input.targetIntegrity, this.#fetch);
       const projectName = await readArtifactProjectName(input.projectDirectory);
-      const sourceDirectory = await generateArtifactProject(temporaryRoot, "source-project", projectName, sourceArtifact.root, provenance);
-      const targetDirectory = await generateArtifactProject(temporaryRoot, "target-project", projectName, targetArtifact.root, provenance);
+      const sourceDirectory = await generatePublicArtifactProject(temporaryRoot, "source-project", projectName, sourceArtifact.root, provenance);
+      const targetDirectory = await generatePublicArtifactProject(temporaryRoot, "target-project", projectName, targetArtifact.root, provenance);
       return {
         temporaryRoot,
         sourceDirectory,
@@ -9195,9 +9272,9 @@ class PublicReconcileArtifactProvider {
     }
   }
 }
-async function downloadArtifact(temporaryRoot, label, version, expectedIntegrity, fetcher) {
+async function downloadPublicArtifact(temporaryRoot, label, version, expectedIntegrity, fetcher) {
   const metadata = await fetchRegistryMetadata(version, fetcher);
-  if (metadata.dist.integrity !== expectedIntegrity) {
+  if (expectedIntegrity !== undefined && metadata.dist.integrity !== expectedIntegrity) {
     throw new Error(`create-windy@${version} registry integrity \u4E0E\u4E0D\u53EF\u53D8 proof \u4E0D\u4E00\u81F4`);
   }
   const response = await fetchTrustedArtifact(metadata.dist.tarball, fetcher);
@@ -9347,7 +9424,7 @@ function verifyArchive(metadata, archive) {
     throw new Error(`create-windy@${metadata.version} artifact \u5B8C\u6574\u6027\u6821\u9A8C\u5931\u8D25`);
   }
 }
-async function generateArtifactProject(temporaryRoot, label, projectName, packageRoot2, provenance) {
+async function generatePublicArtifactProject(temporaryRoot, label, projectName, packageRoot2, provenance) {
   const parent = join26(temporaryRoot, label);
   await mkdir6(parent, { recursive: true });
   const args = [
@@ -9437,20 +9514,28 @@ async function diagnoseProject(projectDirectory, repair = false) {
 }
 
 // src/update/updater.ts
-import { readFile as readFile22, rm as rm8 } from "fs/promises";
-import { join as join29 } from "path";
+import { readFile as readFile23, rm as rm9 } from "fs/promises";
+import { join as join30 } from "path";
 
 // src/update/artifacts.ts
-import { mkdir as mkdir7, mkdtemp as mkdtemp3, readFile as readFile21 } from "fs/promises";
+import { mkdtemp as mkdtemp3, readFile as readFile21 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
 import { basename as basename8, join as join28 } from "path";
 class PublishedArtifactProvider {
+  #fetch;
+  constructor(fetcher = globalThis.fetch) {
+    this.#fetch = fetcher;
+  }
   async prepare(projectDirectory, provenance) {
     const temporaryRoot = await mkdtemp3(join28(tmpdir3(), "windy-update-"));
     const projectName = await readProjectName3(projectDirectory);
     const baseDirectory = join28(temporaryRoot, "base", projectName);
     const targetDirectory = join28(temporaryRoot, "target", projectName);
-    await generatePublishedBase(temporaryRoot, projectName, provenance, baseDirectory);
+    const baseArtifact = await downloadPublicArtifact(temporaryRoot, "base", provenance.generatorVersion, undefined, this.#fetch);
+    if (baseArtifact.identity.templateCommit !== provenance.templateCommit) {
+      throw new Error("Project Lock \u4E0E\u6765\u6E90 registry artifact \u7684 template commit \u4E0D\u4E00\u81F4");
+    }
+    await generatePublicArtifactProject(temporaryRoot, "base", projectName, baseArtifact.root, provenance);
     await generateProject({
       sourceRoot: await resolveTemplateRoot(),
       targetDirectory,
@@ -9465,42 +9550,13 @@ class PublishedArtifactProvider {
     return { temporaryRoot, baseDirectory, targetDirectory };
   }
 }
-async function generatePublishedBase(temporaryRoot, projectName, provenance, expectedDirectory) {
-  const parent = join28(temporaryRoot, "base");
-  await mkdir7(parent, { recursive: true });
-  const args = [
-    "--bun",
-    `create-windy@${provenance.generatorVersion}`,
-    projectName,
-    "--yes",
-    "--skip-install",
-    "--no-git",
-    "--no-optional-modules",
-    "--license",
-    provenance.legalLicense
-  ];
-  if (!provenance.choices.includeOxc)
-    args.push("--no-oxc");
-  if (provenance.legalLicense === "MIT") {
-    args.push("--license-holder", "Windy project owner");
-  }
-  for (const { name } of provenance.modules) {
-    if (!requiredModuleNames.includes(name)) {
-      args.push("--module", name);
-    }
-  }
-  await assertProcess("bunx", args, parent);
-  if (join28(parent, projectName) !== expectedDirectory) {
-    throw new Error("\u5386\u53F2 artifact \u751F\u6210\u76EE\u5F55\u5F02\u5E38");
-  }
-}
 async function readProjectName3(projectDirectory) {
   const source = JSON.parse(await readFile21(join28(projectDirectory, "package.json"), "utf8"));
   return source.name || basename8(projectDirectory);
 }
 
 // src/update/updater-final-manifest.ts
-function buildFinalManagedManifest(plan, generationContent) {
+function buildFinalManagedManifest(plan, generationContent, finalizedHashes = new Map) {
   const source = new Map(plan.sourceManifest.files.map((entry) => [entry.path, entry]));
   const target = new Map(plan.targetManifest.files.map((entry) => [entry.path, entry]));
   const filePlans = new Map(plan.files.map((file) => [file.path, file]));
@@ -9536,7 +9592,7 @@ function buildFinalManagedManifest(plan, generationContent) {
       files.push({
         path: path2,
         ownership: "project-owned",
-        hash: frozenManifestHash(file)
+        hash: frozenManifestHash(file, finalizedHashes)
       });
       continue;
     }
@@ -9544,16 +9600,16 @@ function buildFinalManagedManifest(plan, generationContent) {
     if (isMissingManagedFile(clean)) {
       throw new Error(`\u6700\u7EC8\u53D7\u7BA1\u6E05\u5355\u4E0D\u80FD\u4E3A\u7F3A\u5931\u8DEF\u5F84\u5199\u5165 hash\uFF1A${path2}`);
     }
-    clean.hash = frozenManifestHash(file);
+    clean.hash = frozenManifestHash(file, finalizedHashes);
     files.push(clean);
   }
   return { ...plan.targetManifest, schemaVersion: 3, files };
 }
-function frozenManifestHash(file) {
+function frozenManifestHash(file, finalizedHashes) {
   if (file.action === "create" || file.action === "update") {
     if (!file.content)
       throw new Error(`\u66F4\u65B0\u8BA1\u5212\u7F3A\u5C11\u6587\u4EF6\u5185\u5BB9\uFF1A${file.path}`);
-    return hashContent(file.content);
+    return finalizedHashes.get(file.path) ?? hashContent(file.content);
   }
   if (file.expectedProjectContent.kind !== "hash") {
     throw new Error(`\u4FDD\u7559\u8DEF\u5F84\u7F3A\u5C11\u51BB\u7ED3\u6B63\u6587\uFF1A${file.path}`);
@@ -9561,6 +9617,103 @@ function frozenManifestHash(file) {
   return file.expectedProjectContent.value;
 }
 
+// src/update/format-stabilizer.ts
+import { mkdir as mkdir7, mkdtemp as mkdtemp4, readFile as readFile22, rm as rm8, writeFile as writeFile11 } from "fs/promises";
+import { tmpdir as tmpdir4 } from "os";
+import { dirname as dirname7, extname as extname4, join as join29, resolve as resolve6, sep as sep4 } from "path";
+var formattedExtensions = new Set([
+  ".cjs",
+  ".css",
+  ".cts",
+  ".html",
+  ".js",
+  ".json",
+  ".jsonc",
+  ".jsx",
+  ".less",
+  ".md",
+  ".mdx",
+  ".mjs",
+  ".mts",
+  ".scss",
+  ".ts",
+  ".tsx",
+  ".vue",
+  ".yaml",
+  ".yml"
+]);
+async function stabilizeManagedContent(result2, execute, writeProjectFile) {
+  const generationContent = `${JSON.stringify(result2.plan.targetProvenance, null, 2)}
+`;
+  if (result2.plan.detachedToolchain || !result2.plan.targetProvenance.choices.includeOxc) {
+    return {
+      generationContent,
+      hashes: plannedContentHashes(result2),
+      status: "skipped"
+    };
+  }
+  const inputs = new Map;
+  for (const file of result2.plan.files) {
+    if ((file.action === "create" || file.action === "update") && file.content && formattedExtensions.has(extname4(file.path))) {
+      inputs.set(file.path, file.content);
+    }
+  }
+  inputs.set(".windy/generation.json", new TextEncoder().encode(generationContent));
+  const temporaryRoot = await mkdtemp4(join29(tmpdir4(), "windy-update-format-"));
+  try {
+    const stagedPaths = await stageInputs(temporaryRoot, inputs);
+    for (let offset = 0;offset < stagedPaths.length; offset += 80) {
+      await execute("bun", [
+        "x",
+        "oxfmt",
+        "--write",
+        `--config=${join29(result2.plan.projectDirectory, ".oxfmtrc.json")}`,
+        ...stagedPaths.slice(offset, offset + 80)
+      ], result2.plan.projectDirectory);
+    }
+    const hashes = plannedContentHashes(result2);
+    let formattedGeneration = generationContent;
+    for (const [path2, original] of inputs) {
+      const formatted = await readFile22(safeTemporaryPath(temporaryRoot, path2));
+      if (path2 === ".windy/generation.json") {
+        formattedGeneration = formatted.toString();
+        continue;
+      }
+      hashes.set(path2, hashContent(formatted));
+      if (hashContent(formatted) !== hashContent(original)) {
+        await writeProjectFile(path2, formatted);
+      }
+    }
+    return {
+      generationContent: formattedGeneration,
+      hashes,
+      status: "passed"
+    };
+  } finally {
+    await rm8(temporaryRoot, { recursive: true, force: true });
+  }
+}
+function plannedContentHashes(result2) {
+  return new Map(result2.plan.files.flatMap((file) => (file.action === "create" || file.action === "update") && file.content ? [[file.path, hashContent(file.content)]] : []));
+}
+async function stageInputs(temporaryRoot, inputs) {
+  const paths = [];
+  for (const [path2, content] of inputs) {
+    const target = safeTemporaryPath(temporaryRoot, path2);
+    await mkdir7(dirname7(target), { recursive: true });
+    await writeFile11(target, content);
+    paths.push(target);
+  }
+  return paths;
+}
+function safeTemporaryPath(root, path2) {
+  const target = resolve6(root, path2);
+  if (!target.startsWith(`${resolve6(root)}${sep4}`)) {
+    throw new Error(`\u683C\u5F0F\u5316\u8DEF\u5F84\u8D8A\u51FA\u4E34\u65F6\u76EE\u5F55\uFF1A${path2}`);
+  }
+  return target;
+}
+
 // src/update/updater.ts
 class DefaultStarterUpdater {
   #artifacts;
@@ -9583,7 +9736,7 @@ class DefaultStarterUpdater {
       }
       return await applyTransaction(plan);
     } catch (error) {
-      await rm8(plan.temporaryRoot, { recursive: true, force: true });
+      await rm9(plan.temporaryRoot, { recursive: true, force: true });
       throw error;
     }
   }
@@ -9601,6 +9754,14 @@ class DefaultStarterUpdater {
       });
       await this.#execute("bun", ["install", "--force"], result2.plan.projectDirectory);
       steps.push({ name: "bun install --force", status: "passed" });
+      const stabilized = await stabilizeManagedContent(result2, this.#execute, async (path2, content) => {
+        await writeOwnedTransactionFile(result2.plan.projectDirectory, path2, content, expectedForPath(result2, path2));
+        replaceExpectations(result2, [expectationForContent(path2, content)]);
+      });
+      steps.push({
+        name: "\u7A33\u5B9A Oxfmt \u4E0E\u53D7\u7BA1\u6587\u4EF6\u6E05\u5355",
+        status: stabilized.status
+      });
       const verificationSnapshot = await captureOwnedTransactionExpectations(result2.plan.projectDirectory, result2.transactionOwnerToken, result2.backupEntries.map(({ path: path2 }) => path2));
       const metadataPaths2 = new Set([
         ".windy/generation.json",
@@ -9610,7 +9771,7 @@ class DefaultStarterUpdater {
       const plannedPaths = new Set(result2.plan.files.map(({ path: path2 }) => path2));
       replaceExpectations(result2, verificationSnapshot.filter(({ path: path2 }) => !metadataPaths2.has(path2) && !plannedPaths.has(path2)));
       verificationExpectationsFrozen = true;
-      const packageJson = JSON.parse(await readFile22(join29(result2.plan.projectDirectory, "package.json"), "utf8"));
+      const packageJson = JSON.parse(await readFile23(join30(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" });
@@ -9619,11 +9780,11 @@ class DefaultStarterUpdater {
         await this.#execute("bun", ["run", name], result2.plan.projectDirectory);
         steps.push({ name: `bun run ${name}`, status: "passed" });
       }
-      const metadataExpectations = await finalize(result2);
+      const metadataExpectations = await finalize(result2, stabilized);
       const reportPath = `.windy/reports/${result2.plan.id}.md`;
       const reportExpectation = await writeReport(result2, steps, reportPath);
       replaceExpectations(result2, [...metadataExpectations, reportExpectation]);
-      await rm8(result2.plan.temporaryRoot, { recursive: true, force: true });
+      await rm9(result2.plan.temporaryRoot, { recursive: true, force: true });
       await this.#beforeTransactionFinalize?.({ result: result2, reportPath });
       await this.#finalizeTransaction({
         projectDirectory: result2.plan.projectDirectory,
@@ -9633,7 +9794,7 @@ class DefaultStarterUpdater {
       });
       return { updateId: result2.plan.id, status: "passed", steps, reportPath };
     } catch (error) {
-      await rm8(result2.plan.temporaryRoot, { recursive: true, force: true });
+      await rm9(result2.plan.temporaryRoot, { recursive: true, force: true });
       if (error instanceof TransactionCommittedCleanupPendingError) {
         throw error;
       }
@@ -9659,16 +9820,15 @@ class DefaultStarterUpdater {
     }
   }
 }
-async function finalize(result2) {
+async function finalize(result2, stabilized) {
   const root = result2.plan.projectDirectory;
-  const generationContent = `${JSON.stringify(result2.plan.targetProvenance, null, 2)}
-`;
+  const generationContent = stabilized.generationContent;
   const generationExpectation = expectedForPath(result2, ".windy/generation.json");
   await writeOwnedTransactionFile(root, ".windy/generation.json", generationContent, generationExpectation);
   replaceExpectations(result2, [
     expectationForContent(".windy/generation.json", generationContent)
   ]);
-  const targetManifest = buildFinalManagedManifest(result2.plan, generationContent);
+  const targetManifest = buildFinalManagedManifest(result2.plan, generationContent, stabilized.hashes);
   await writeOwnedTransactionFile(root, ".windy/files.json", `${JSON.stringify(targetManifest, null, 2)}
 `, expectedForPath(result2, ".windy/files.json"));
   const manifestExpectation = expectationForContent(".windy/files.json", `${JSON.stringify(targetManifest, null, 2)}
@@ -9723,7 +9883,7 @@ async function runLifecycleCommand(args) {
   if (command !== "doctor" && command !== "update" && command !== "reconcile" && command !== "sync-docker") {
     return false;
   }
-  const projectDirectory = resolve6(readValue2(args, "--cwd") || process.cwd());
+  const projectDirectory = resolve7(readValue2(args, "--cwd") || process.cwd());
   if (command === "sync-docker") {
     const result2 = await planWebDockerfileInProject(projectDirectory, {
       requireAnchors: true
@@ -9790,7 +9950,7 @@ async function runReconcile(args, projectDirectory) {
     console.log(`  unresolved ${item.path}\uFF08${item.reason}\uFF09`);
   }
   if (!args.includes("--apply")) {
-    await rm9(plan.temporaryRoot, { recursive: true, force: true });
+    await rm10(plan.temporaryRoot, { recursive: true, force: true });
     console.log(`
 \u6F14\u7EC3\u5B8C\u6210\uFF1A\u672A\u5199\u5165\u9879\u76EE\u6587\u4EF6\uFF1B\u4F7F\u7528 --apply \u4EC5\u63D0\u4EA4\u5BF9\u8D26\u5143\u6570\u636E`);
     return;
@@ -9801,7 +9961,7 @@ async function runReconcile(args, projectDirectory) {
 \u5BF9\u8D26\u5B8C\u6210\uFF1AProject Lock \u4ECD\u4E3A ${plan.sourceVersion}`);
     console.log(`\u62A5\u544A\uFF1A${result2.reportPath}`);
   } finally {
-    await rm9(plan.temporaryRoot, { recursive: true, force: true });
+    await rm10(plan.temporaryRoot, { recursive: true, force: true });
   }
 }
 async function runUpdate(args, projectDirectory) {
@@ -9836,13 +9996,13 @@ async function runUpdate(args, projectDirectory) {
   const plan = await updater.plan({ projectDirectory, targetVersion: target });
   printPlan(plan);
   if (args.includes("--dry-run")) {
-    await rm9(plan.temporaryRoot, { recursive: true, force: true });
+    await rm10(plan.temporaryRoot, { recursive: true, force: true });
     console.log(`
 \u6F14\u7EC3\u5B8C\u6210\uFF1A\u672A\u5199\u5165\u9879\u76EE\u6587\u4EF6`);
     return;
   }
   if (plan.conflicts.length) {
-    await rm9(plan.temporaryRoot, { recursive: true, force: true });
+    await rm10(plan.temporaryRoot, { recursive: true, force: true });
     throw new Error("\u5B58\u5728\u66F4\u65B0\u51B2\u7A81\uFF1B\u8BF7\u6309\u4E0A\u65B9\u6E05\u5355\u5904\u7406\u540E\u91CD\u65B0\u8FD0\u884C\uFF0C\u9879\u76EE\u672A\u88AB\u4FEE\u6539");
   }
   const result2 = await updater.apply(plan);
@@ -9927,28 +10087,28 @@ function compareVersions2(left, right) {
 }
 
 // src/module-schema/cli.ts
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 
 // src/module-schema/handoff.ts
 import {
   access as access2,
   cp,
   mkdir as mkdir8,
-  mkdtemp as mkdtemp4,
-  readFile as readFile24,
+  mkdtemp as mkdtemp5,
+  readFile as readFile25,
   readdir as readdir8,
   rename,
-  rm as rm10,
-  writeFile as writeFile11
+  rm as rm11,
+  writeFile as writeFile12
 } from "fs/promises";
-import { dirname as dirname7, join as join30, relative as relative5 } from "path";
+import { dirname as dirname8, join as join31, relative as relative5 } from "path";
 
 // src/module-schema/config.ts
-import { readFile as readFile23 } from "fs/promises";
-import { isAbsolute as isAbsolute2, relative as relative4, resolve as resolve7 } from "path";
+import { readFile as readFile24 } from "fs/promises";
+import { isAbsolute as isAbsolute2, relative as relative4, resolve as resolve8 } from "path";
 async function readModuleSchemaLineageConfig(projectDirectory, configPath) {
   const absolutePath = resolveProjectPath(projectDirectory, configPath);
-  const parsed = JSON.parse(await readFile23(absolutePath, "utf8"));
+  const parsed = JSON.parse(await readFile24(absolutePath, "utf8"));
   if (!isConfig(parsed)) {
     throw new Error("Module schema lineage \u914D\u7F6E\u65E0\u6548");
   }
@@ -9962,7 +10122,7 @@ async function readModuleSchemaLineageConfig(projectDirectory, configPath) {
 function resolveProjectPath(projectDirectory, path2) {
   if (isAbsolute2(path2))
     throw new Error(`\u8DEF\u5F84\u5FC5\u987B\u76F8\u5BF9\u9879\u76EE\u6839\u76EE\u5F55\uFF1A${path2}`);
-  const resolved = resolve7(projectDirectory, path2);
+  const resolved = resolve8(projectDirectory, path2);
   const projectRelative = relative4(projectDirectory, resolved);
   if (projectRelative.startsWith("..") || isAbsolute2(projectRelative)) {
     throw new Error(`\u8DEF\u5F84\u8D8A\u51FA\u9879\u76EE\u6839\u76EE\u5F55\uFF1A${path2}`);
@@ -10072,7 +10232,7 @@ async function handoffModuleSchemaLineages(options) {
     const stagedPlatform = await stagePlatformLineage(project, temporaryRoot, config, execute);
     await installStagedLineages(project, temporaryRoot, config, stagedModules, stagedPlatform);
   } finally {
-    await rm10(temporaryRoot, { recursive: true, force: true });
+    await rm11(temporaryRoot, { recursive: true, force: true });
   }
   return {
     moduleCount: config.modules.length,
@@ -10082,17 +10242,17 @@ async function handoffModuleSchemaLineages(options) {
 async function stageModuleLineages(project, temporaryRoot, config, execute) {
   const outputs = [];
   for (const [index, module3] of config.modules.entries()) {
-    const output = join30(temporaryRoot, `module-${index}`);
+    const output = join31(temporaryRoot, `module-${index}`);
     await mkdir8(output, { recursive: true });
-    const generatedConfig = join30(temporaryRoot, `module-${index}.config.ts`);
+    const generatedConfig = join31(temporaryRoot, `module-${index}.config.ts`);
     await writeDrizzleConfig(generatedConfig, project, module3.schema, relative5(temporaryRoot, output));
     await execute(generatedConfig, temporaryRoot);
     const sqlFiles = await listSqlFiles(output);
     if (sqlFiles.length !== 1) {
       throw new Error(`${module3.key} baseline \u5FC5\u987B\u6070\u597D\u751F\u6210\u4E00\u4E2A migration`);
     }
-    await writeFile11(join30(output, sqlFiles[0]), metadataOnlySql("module"));
-    await writeFile11(join30(output, "lineage.json"), `${JSON.stringify({
+    await writeFile12(join31(output, sqlFiles[0]), metadataOnlySql("module"));
+    await writeFile12(join31(output, "lineage.json"), `${JSON.stringify({
       schemaVersion: 1,
       moduleKey: module3.key,
       schema: module3.schema,
@@ -10106,25 +10266,25 @@ async function stageModuleLineages(project, temporaryRoot, config, execute) {
 }
 async function stagePlatformLineage(project, temporaryRoot, config, execute) {
   const source = resolveProjectPath(project, config.platform.out);
-  const output = join30(temporaryRoot, "platform");
+  const output = join31(temporaryRoot, "platform");
   await cp(source, output, { recursive: true });
   const before = new Set(await listSqlFiles(output));
-  const generatedConfig = join30(temporaryRoot, "platform.config.ts");
+  const generatedConfig = join31(temporaryRoot, "platform.config.ts");
   await writeDrizzleConfig(generatedConfig, project, config.platform.schema, relative5(temporaryRoot, output));
   await execute(generatedConfig, temporaryRoot);
   const created = (await listSqlFiles(output)).filter((path2) => !before.has(path2));
   if (created.length !== 1) {
     throw new Error("\u5E73\u53F0 lineage handoff \u5FC5\u987B\u6070\u597D\u751F\u6210\u4E00\u4E2A migration");
   }
-  const sqlPath = join30(output, created[0]);
+  const sqlPath = join31(output, created[0]);
   const allowed = config.modules.flatMap(({ legacyPlatformTables }) => legacyPlatformTables);
-  validatePlatformHandoffSql(await readFile24(sqlPath, "utf8"), allowed);
-  await writeFile11(sqlPath, metadataOnlySql("platform"));
+  validatePlatformHandoffSql(await readFile25(sqlPath, "utf8"), allowed);
+  await writeFile12(sqlPath, metadataOnlySql("platform"));
   return output;
 }
 async function installStagedLineages(project, temporaryRoot, config, stagedModules, stagedPlatform) {
   const platform = resolveProjectPath(project, config.platform.out);
-  const backup = join30(temporaryRoot, "platform-backup");
+  const backup = join31(temporaryRoot, "platform-backup");
   const installed = [];
   await rename(platform, backup);
   try {
@@ -10134,21 +10294,21 @@ async function installStagedLineages(project, temporaryRoot, config, stagedModul
       if (await exists(output)) {
         throw new Error(`${module3.key} lineage \u8F93\u51FA\u5DF2\u5B58\u5728\uFF0C\u7981\u6B62\u8986\u76D6`);
       }
-      await mkdir8(dirname7(output), { recursive: true });
+      await mkdir8(dirname8(output), { recursive: true });
       await rename(stagedModules[index], output);
       installed.push(output);
     }
   } catch (error) {
-    await rm10(platform, { recursive: true, force: true });
+    await rm11(platform, { recursive: true, force: true });
     await rename(backup, platform);
     for (const output of installed)
-      await rm10(output, { recursive: true, force: true });
+      await rm11(output, { recursive: true, force: true });
     throw error;
   }
 }
 async function writeDrizzleConfig(path2, project, schemas, out) {
   const absoluteSchemas = schemas.map((schema) => resolveProjectPath(project, schema));
-  await writeFile11(path2, `import { defineConfig } from "drizzle-kit";
+  await writeFile12(path2, `import { defineConfig } from "drizzle-kit";
 export default defineConfig(${JSON.stringify({
     dialect: "postgresql",
     schema: absoluteSchemas,
@@ -10171,9 +10331,9 @@ async function validateSchemaSources(project, config) {
   }
 }
 async function createTemporaryRoot(project) {
-  const windy = join30(project, ".windy");
+  const windy = join31(project, ".windy");
   await mkdir8(windy, { recursive: true });
-  return await mkdtemp4(join30(windy, "module-schema-handoff-"));
+  return await mkdtemp5(join31(windy, "module-schema-handoff-"));
 }
 async function listSqlFiles(root) {
   return (await readdir8(root)).filter((path2) => path2.endsWith(".sql")).sort();
@@ -10203,7 +10363,7 @@ async function runModuleSchemaCommand(args) {
   if (args[1] !== "handoff") {
     throw new Error("\u5F53\u524D schema \u547D\u4EE4\u53EA\u652F\u6301 handoff");
   }
-  const projectDirectory = resolve8(readValue3(args, "--cwd") || process.cwd());
+  const projectDirectory = resolve9(readValue3(args, "--cwd") || process.cwd());
   const result2 = await handoffModuleSchemaLineages({
     projectDirectory,
     configPath: readValue3(args, "--config")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-windy",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "创建单组织、单租户、私有部署优先的 Windy 企业 Dashboard Starter",
   "type": "module",
   "bin": {

package/template/.windy-template.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "templateCommit": "74bc602b85aa40bdd11761507d8d9821ecd5bb50",
-  "generatorVersion": "0.3.1",
+  "templateCommit": "cb75f345710c9db90091819fd917d999cca88d05",
+  "generatorVersion": "0.3.2",
   "modules": [
     {
       "name": "system",