ccgf-game-tool 1.0.21 → 1.0.23

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/main.js CHANGED
@@ -1,9 +1,46 @@
1
1
  "use strict";
2
+ var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
3
+ if (k2 === undefined) k2 = k;
4
+ var desc = Object.getOwnPropertyDescriptor(m, k);
5
+ if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
6
+ desc = { enumerable: true, get: function() { return m[k]; } };
7
+ }
8
+ Object.defineProperty(o, k2, desc);
9
+ }) : (function(o, m, k, k2) {
10
+ if (k2 === undefined) k2 = k;
11
+ o[k2] = m[k];
12
+ }));
13
+ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
14
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
15
+ }) : function(o, v) {
16
+ o["default"] = v;
17
+ });
18
+ var __importStar = (this && this.__importStar) || (function () {
19
+ var ownKeys = function(o) {
20
+ ownKeys = Object.getOwnPropertyNames || function (o) {
21
+ var ar = [];
22
+ for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
23
+ return ar;
24
+ };
25
+ return ownKeys(o);
26
+ };
27
+ return function (mod) {
28
+ if (mod && mod.__esModule) return mod;
29
+ var result = {};
30
+ if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
31
+ __setModuleDefault(result, mod);
32
+ return result;
33
+ };
34
+ })();
2
35
  var __importDefault = (this && this.__importDefault) || function (mod) {
3
36
  return (mod && mod.__esModule) ? mod : { "default": mod };
4
37
  };
5
38
  Object.defineProperty(exports, "__esModule", { value: true });
6
39
  exports.methods = void 0;
40
+ exports.createBundle = createBundle;
41
+ exports.queryBundles = queryBundles;
42
+ exports.setBundle = setBundle;
43
+ exports.deleteBundle = deleteBundle;
7
44
  exports.load = load;
8
45
  exports.unload = unload;
9
46
  // @ts-ignore
@@ -12,12 +49,15 @@ const child_process_1 = require("child_process");
12
49
  const fs_extra_1 = require("fs-extra");
13
50
  const path_1 = require("path");
14
51
  const constants_1 = require("./constants");
52
+ const bundle_1 = require("./bundle");
53
+ const log_1 = require("./log");
15
54
  const doctor_1 = require("./doctor");
16
55
  const naming_1 = require("./naming");
17
56
  const project_1 = require("./project");
18
57
  const registry_1 = require("./registry");
19
58
  const shared_1 = require("./shared");
20
59
  const templates_1 = require("./templates");
60
+ const tables_1 = require("./tables");
21
61
  /* ------------------------------- 文案 ------------------------------- */
22
62
  /**
23
63
  * 扩展自带的中文文案表。
@@ -30,6 +70,197 @@ const ZH_STRINGS = require('../i18n/zh.js');
30
70
  function projectPath() {
31
71
  return Editor.Project.path;
32
72
  }
73
+ /** 数据表错误 -> 面板可显示的一行文本(带表/行/字段) */
74
+ function tableErrorText(e, fallback = '') {
75
+ if (e instanceof tables_1.TableToolError) {
76
+ return e.format();
77
+ }
78
+ const message = e instanceof Error ? e.message : String(e);
79
+ return fallback ? `${fallback}:${message}` : message;
80
+ }
81
+ /** Bundle 增删后通知已打开的数据表工具刷新目录(没有面板监听也无害) */
82
+ function notifyTableDirsChanged() {
83
+ try {
84
+ Editor.Message.broadcast('ccgf-game-tool:table-dirs-changed');
85
+ }
86
+ catch (e) {
87
+ /* 编辑器版本不支持广播时忽略;刷新按钮兜底 */
88
+ }
89
+ }
90
+ /**
91
+ * 目标写在 bundles/<name>/... 时,先确认 bundle 目录真的存在。
92
+ *
93
+ * 否则我们会先在 assets/bundles/<name> 下写出一个没有 Bundle 配置的目录,
94
+ * 再让 asset-db 去刷新它,正好触发
95
+ * `Can not change the asset "db://assets/bundles/<name>", because the original asset is not exist`。
96
+ */
97
+ function assertBundleTarget(project, relativeCsv) {
98
+ const match = /^bundles\/([^/]+)\//.exec(relativeCsv);
99
+ if (!match) {
100
+ return;
101
+ }
102
+ const bundleName = match[1];
103
+ if (!(0, fs_extra_1.existsSync)((0, path_1.join)(project, 'assets', 'bundles', bundleName))) {
104
+ throw new tables_1.TableToolError(`目标 bundle 不存在:assets/bundles/${bundleName}。请先在扩展里新建 Bundle,再导出到它。`);
105
+ }
106
+ }
107
+ /**
108
+ * 把构建好的 .bin 交给 asset-db。
109
+ *
110
+ * 关键:**新文件不要先落盘再 refresh**——asset-db 对磁盘上已存在、但自己没索引的文件
111
+ * 会报 `Can not change the asset "...", because the original asset is not exist`。
112
+ * 正确做法是新文件直接 `create-asset(url, Buffer)`,让 asset-db 自己写盘并建索引;
113
+ * 只有已经认识的文件才用 fs 覆盖 + `refresh-asset(file)`。
114
+ */
115
+ async function ensureAssetDir(project, dirRelative) {
116
+ const rel = dirRelative.replace(/\\/g, '/');
117
+ if (!rel || rel === '.') {
118
+ return;
119
+ }
120
+ const abs = (0, path_1.join)(project, 'assets', rel);
121
+ if ((0, fs_extra_1.existsSync)(abs)) {
122
+ return;
123
+ }
124
+ // 目录不存在时先让 asset-db 创建目录(会发“新增资源”事件,资源管理器才认)
125
+ const made = await Editor.Message.request('asset-db', 'create-asset', `db://assets/${rel}`, null, { overwrite: false }).catch(() => null);
126
+ if (!made) {
127
+ (0, fs_extra_1.mkdirSync)(abs, { recursive: true });
128
+ }
129
+ }
130
+ async function writeTableAsset(project, built) {
131
+ const binRelative = built.binRelative;
132
+ const abs = (0, path_1.join)(project, 'assets', binRelative);
133
+ const url = `db://assets/${binRelative}`;
134
+ await ensureAssetDir(project, (0, path_1.dirname)(binRelative));
135
+ const known = await Editor.Message.request('asset-db', 'query-asset-info', url).catch(() => null);
136
+ if (known) {
137
+ try {
138
+ (0, fs_extra_1.writeFileSync)(abs, built.buffer);
139
+ await Editor.Message.request('asset-db', 'refresh-asset', url);
140
+ return null;
141
+ }
142
+ catch (e) {
143
+ return `覆盖已有文件失败:${url}(${e instanceof Error ? e.message : String(e)})`;
144
+ }
145
+ }
146
+ // 磁盘上已有同名文件但资源库没有索引:先删掉旧文件,再走 create-asset。
147
+ // 否则 create-asset 会弹「文件已存在,是否覆盖?」;旧文件是我们自己生成的,可以重建。
148
+ if ((0, fs_extra_1.existsSync)(abs)) {
149
+ try {
150
+ (0, fs_extra_1.removeSync)(abs);
151
+ if ((0, fs_extra_1.existsSync)(abs + '.meta')) {
152
+ (0, fs_extra_1.removeSync)(abs + '.meta');
153
+ }
154
+ }
155
+ catch (e) {
156
+ (0, fs_extra_1.writeFileSync)(abs, built.buffer);
157
+ return `旧文件无法删除,资源库也没导入 ${url},请手动刷新所在目录`;
158
+ }
159
+ }
160
+ try {
161
+ const created = await Editor.Message.request('asset-db', 'create-asset', url, built.buffer, { overwrite: false }).catch(() => null);
162
+ if (created) {
163
+ return null;
164
+ }
165
+ }
166
+ catch (e) {
167
+ // 走下面的 fallback warning
168
+ }
169
+ (0, fs_extra_1.writeFileSync)(abs, built.buffer);
170
+ return `资源库没有导入 ${url},请手动刷新所在目录`;
171
+ }
172
+ /** 写生成出的 TableTypes.ts;逻辑与 .bin 一致,新文件走 create-asset */
173
+ async function writeTextAsset(project, assetRelative, content) {
174
+ const abs = (0, path_1.join)(project, 'assets', assetRelative);
175
+ const url = `db://assets/${assetRelative}`;
176
+ await ensureAssetDir(project, (0, path_1.dirname)(assetRelative));
177
+ const known = await Editor.Message.request('asset-db', 'query-asset-info', url).catch(() => null);
178
+ if (known) {
179
+ try {
180
+ (0, fs_extra_1.writeFileSync)(abs, content, 'utf8');
181
+ await Editor.Message.request('asset-db', 'refresh-asset', url);
182
+ return null;
183
+ }
184
+ catch (e) {
185
+ return `覆盖失败:${url}(${e instanceof Error ? e.message : String(e)})`;
186
+ }
187
+ }
188
+ if ((0, fs_extra_1.existsSync)(abs)) {
189
+ try {
190
+ (0, fs_extra_1.removeSync)(abs);
191
+ if ((0, fs_extra_1.existsSync)(abs + '.meta')) {
192
+ (0, fs_extra_1.removeSync)(abs + '.meta');
193
+ }
194
+ }
195
+ catch (e) {
196
+ (0, fs_extra_1.writeFileSync)(abs, content, 'utf8');
197
+ return `旧文件无法删除,资源库也没导入 ${url}`;
198
+ }
199
+ }
200
+ try {
201
+ const created = await Editor.Message.request('asset-db', 'create-asset', url, content, { overwrite: false }).catch(() => null);
202
+ if (created) {
203
+ return null;
204
+ }
205
+ }
206
+ catch (e) {
207
+ // fallback
208
+ }
209
+ (0, fs_extra_1.writeFileSync)(abs, content, 'utf8');
210
+ return `资源库没有导入 ${url},请手动刷新所在目录`;
211
+ }
212
+ /** 生成的 TableTypes.ts 里,ITableRow 的 import 路径 */
213
+ function tableTypeImportPath(typeRelative) {
214
+ if (frameworkImportMode() === 'package') {
215
+ return '@ccgf/framework';
216
+ }
217
+ const fromDir = (0, path_1.dirname)((0, path_1.join)(projectPath(), 'assets', typeRelative));
218
+ const framework = (0, path_1.join)(projectPath(), 'assets/scripts/framework/core/table/TableTypes');
219
+ let rel = (0, path_1.relative)(fromDir, framework).replace(/\\/g, '/');
220
+ if (!rel.startsWith('.')) {
221
+ rel = `./${rel}`;
222
+ }
223
+ return rel;
224
+ }
225
+ /**
226
+ * 为每个包生成一份 TableTypes.ts:
227
+ * - 主包 -> assets/scripts/table/TableTypes.ts
228
+ * - 子包 -> assets/bundles/<bundle>/scripts/table/TableTypes.ts
229
+ *
230
+ * 用全部可解析的表生成,而不是只导出选中的几张;否则“导出选中”会删掉其它表的类型。
231
+ */
232
+ async function generateTableTypes(project, files) {
233
+ var _a, _b, _c;
234
+ const groups = new Map();
235
+ for (const file of files) {
236
+ if (file.error) {
237
+ continue;
238
+ }
239
+ const bundleName = (_b = (_a = /^bundles\/([^/]+)\//.exec(file.relative)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : '';
240
+ if (bundleName && !(0, fs_extra_1.existsSync)((0, path_1.join)(project, 'assets', 'bundles', bundleName))) {
241
+ continue;
242
+ }
243
+ try {
244
+ const data = (0, tables_1.readTableCsv)(project, file.relative);
245
+ const typeRelative = (0, tables_1.tableTypeFilePath)(file.binRelative);
246
+ const sources = (_c = groups.get(typeRelative)) !== null && _c !== void 0 ? _c : [];
247
+ sources.push({ data, source: file.relative });
248
+ groups.set(typeRelative, sources);
249
+ }
250
+ catch (e) {
251
+ // 单张表解析失败:跳过类型,导出错误列表里已经会显示
252
+ }
253
+ }
254
+ const warnings = [];
255
+ for (const [typeRelative, sources] of groups) {
256
+ const content = (0, tables_1.renderTableTypes)(sources, tableTypeImportPath(typeRelative));
257
+ const warning = await writeTextAsset(project, typeRelative, content);
258
+ if (warning) {
259
+ warnings.push(`${typeRelative}:${warning}`);
260
+ }
261
+ }
262
+ return warnings;
263
+ }
33
264
  /**
34
265
  * 这个工程引用框架该用哪种写法:
35
266
  * - 开发工作区(仓库里,框架源码在 assets/scripts/framework 下) -> 相对路径
@@ -77,8 +308,25 @@ function readSharedSources() {
77
308
  walk(base, '');
78
309
  return out;
79
310
  }
311
+ /**
312
+ * 当前目标包的快照扫描根。
313
+ *
314
+ * 主包用默认值(assets/scripts + assets/resources);子包把"模块/预制体"两项换成
315
+ * 子包自己的目录 —— 这样模块列表、View 列表、体检都会跟着下拉框走,而不是永远看主包。
316
+ */
317
+ function snapshotRoots() {
318
+ const bundle = (0, bundle_1.getTargetBundle)();
319
+ if (!bundle) {
320
+ return undefined;
321
+ }
322
+ return {
323
+ moduleRoot: (0, bundle_1.scriptsRoot)(),
324
+ prefabRoot: (0, bundle_1.prefabRoot)(),
325
+ prefabKeyRoot: (0, bundle_1.prefabKeyRoot)(),
326
+ };
327
+ }
80
328
  function snapshot() {
81
- const s = (0, project_1.collectSnapshot)(projectPath(), compressUuid);
329
+ const s = (0, project_1.collectSnapshot)(projectPath(), compressUuid, snapshotRoots());
82
330
  // 只在"框架包被装进工程 node_modules"这件事上补一个事实:
83
331
  // 是不是"两份框架"要由 doctor 结合"assets 下有没有框架源码"一起判。
84
332
  return Object.assign(Object.assign({}, s), { frameworkInNodeModules: (0, fs_extra_1.existsSync)((0, path_1.join)(projectPath(), 'node_modules', '@ccgf', 'framework')), sharedSources: readSharedSources() });
@@ -412,12 +660,23 @@ function assetExists(url) {
412
660
  }
413
661
  /**
414
662
  * 确保目录存在,不存在则创建
663
+ *
664
+ * ⚠️ 目录在磁盘上、只是编辑器还没导入时**不能用 create-asset**:
665
+ * 编辑器会弹「文件已存在,是否覆盖?」模态框(实测)。这种情况下刷新父目录即可。
415
666
  */
416
667
  async function ensureDir(dirUrl) {
417
668
  const info = await Editor.Message.request('asset-db', 'query-asset-info', dirUrl);
418
- if (!info) {
419
- await Editor.Message.request('asset-db', 'create-asset', dirUrl, null);
669
+ if (info) {
670
+ return;
671
+ }
672
+ const rel = dirUrl.replace(/^db:\/\//, '');
673
+ if ((0, fs_extra_1.existsSync)((0, path_1.join)(projectPath(), rel))) {
674
+ const slash = rel.lastIndexOf('/');
675
+ const parentUrl = slash > 0 ? `db://${rel.slice(0, slash)}` : 'db://assets';
676
+ await Editor.Message.request('asset-db', 'refresh-asset', parentUrl);
677
+ return;
420
678
  }
679
+ await Editor.Message.request('asset-db', 'create-asset', dirUrl, null);
421
680
  }
422
681
  /** 目录不存在则建,空目录则删掉(生成/删除后清理用) */
423
682
  async function pruneEmptyDir(absDir) {
@@ -480,26 +739,357 @@ function syncExtension(name) {
480
739
  */
481
740
  async function ensureScaffoldAssets(pkgName) {
482
741
  const made = [];
483
- // 目前只有红点需要;以后别的模块要带资源,在这里加一条
484
- if (pkgName !== '@ccgf/red-dot')
742
+ // 模块 -> 安装时要生成到 resources 下的资源(路径不含扩展名)
743
+ const SCAFFOLD = {
744
+ '@ccgf/red-dot': { path: 'reddot/default', build: () => (0, templates_1.buildRedDotPrefab)('default') },
745
+ '@ccgf/guide': { path: 'views/guide/GuideMaskView', build: () => (0, templates_1.buildGuideMaskPrefab)('GuideMaskView') },
746
+ };
747
+ // 传进来的可能是 `@ccgf/guide` 也可能是 `@ccgf/guide@0.1.0` —— 按前缀匹配包名 ✓
748
+ // (之前直接 SCAFFOLD[wanted] 查不到,所以装了 guide 却没生成预制体 ✗)
749
+ const wanted = String(pkgName);
750
+ const key = Object.keys(SCAFFOLD).find((k) => wanted === k || wanted.startsWith(`${k}@`));
751
+ const spec = key ? SCAFFOLD[key] : undefined;
752
+ if (!spec)
485
753
  return made;
486
- const dirUrl = `db://${constants_1.RESOURCES_DIR}/reddot`;
487
- const url = `${dirUrl}/default.prefab`;
488
- if (await assetExists(url)) {
489
- return made; // 已经有了就不覆盖(用户可能自己调过样式)
490
- }
754
+ const parts = spec.path.split('/');
755
+ const dirPath = parts.slice(0, -1).join('/');
756
+ const dirUrl = `db://${constants_1.RESOURCES_DIR}/${dirPath}`;
757
+ const url = `db://${constants_1.RESOURCES_DIR}/${spec.path}.prefab`;
758
+ if (await assetExists(url))
759
+ return made; // 已有就不覆盖(用户可能自己调过)
491
760
  await ensureDir(dirUrl);
492
- const content = JSON.stringify((0, templates_1.buildRedDotPrefab)('default'));
761
+ const content = JSON.stringify(spec.build());
493
762
  const asset = await Editor.Message.request('asset-db', 'create-asset', url, content, { overwrite: false });
494
763
  if (!asset) {
495
- console.warn(`[ccgf] 生成默认红点样式失败:${url}`);
764
+ (0, log_1.logToEditor)('warn', `[ccgf] 生成默认资源失败:${url}`);
496
765
  return made;
497
766
  }
498
767
  await Editor.Message.request('asset-db', 'refresh-asset', dirUrl);
499
- made.push(`${constants_1.RESOURCES_DIR}/reddot/default.prefab`);
768
+ made.push(`${constants_1.RESOURCES_DIR}/${spec.path}.prefab`);
500
769
  return made;
501
770
  }
771
+ /**
772
+ * 让资源库导入 assets/bundles 下新出现的目录树。
773
+ *
774
+ * ⚠️ **绝不能对"磁盘上已存在"的目录调 create-asset**:
775
+ * 编辑器会弹「文件已存在,是否覆盖?」的模态框(实测,按钮是 覆盖/重命名/取消),
776
+ * 整个创建流程卡在那里。目录是我们自己 mkdir 出来的,只需要 refresh 去导入。
777
+ *
778
+ * - asset-db 认识 assets/bundles → 刷新它;
779
+ * - 不认识(目录在磁盘上、还没导入)→ 刷新父目录 db://assets,让它整棵扫进来。
780
+ */
781
+ async function refreshBundlesRoot() {
782
+ const rootUrl = `db://${constants_1.BUNDLES_ROOT}`;
783
+ const known = await Editor.Message.request('asset-db', 'query-asset-info', rootUrl).catch(() => null);
784
+ await Editor.Message.request('asset-db', 'refresh-asset', known ? rootUrl : 'db://assets');
785
+ }
786
+ /** asset-db 是否已经认识这两个子目录(磁盘上有 ≠ 编辑器见过) */
787
+ async function bundleSubdirsImported(rel) {
788
+ for (const dir of [constants_1.BUNDLE_SCRIPTS_SUBDIR, constants_1.VIEWS_SUBDIR]) {
789
+ const info = await Editor.Message.request('asset-db', 'query-asset-info', `db://${rel}/${dir}`)
790
+ .catch(() => null);
791
+ if (!info) {
792
+ return false;
793
+ }
794
+ }
795
+ return true;
796
+ }
797
+ /**
798
+ * 这个子包目录现在是什么状态(用来区分"真的重复创建"和"上次失败留下的空壳")。
799
+ *
800
+ * `existsSync(abs)` 只能说明**磁盘上有个目录**;而"子包存在"应该是**结构齐全且已标记**。
801
+ * 混为一谈时的表现:编辑器里看不到它(没导入/没标 Bundle)却提示"已存在",用户没法继续。
802
+ */
803
+ function bundleState(abs) {
804
+ var _a;
805
+ const missingDirs = [constants_1.BUNDLE_SCRIPTS_SUBDIR, constants_1.VIEWS_SUBDIR]
806
+ .filter((dir) => !(0, fs_extra_1.existsSync)((0, path_1.join)(abs, dir)));
807
+ let marked = false;
808
+ try {
809
+ const meta = JSON.parse((0, fs_extra_1.readFileSync)(abs + '.meta', 'utf8'));
810
+ marked = ((_a = meta === null || meta === void 0 ? void 0 : meta.userData) === null || _a === void 0 ? void 0 : _a.isBundle) === true;
811
+ }
812
+ catch (_b) {
813
+ marked = false; // 没有 meta / meta 坏了 -> 编辑器眼里它还不是 bundle
814
+ }
815
+ return { missingDirs, marked };
816
+ }
817
+ /** 占位文件名:空目录在资源管理器里不显示,必须放个文件进去 */
818
+ const BUNDLE_README = 'README.md';
819
+ /** 子目录里的占位说明(同时告诉人这里该放什么) */
820
+ function bundleReadme(dir, bundle) {
821
+ if (dir === constants_1.BUNDLE_SCRIPTS_SUBDIR) {
822
+ return `# ${bundle}/scripts
823
+
824
+ 本子包的模块脚本放在这里:
825
+
826
+ assets/bundles/${bundle}/scripts/<模块名>/<前缀>Module.ts
827
+
828
+ 这个文件只是占位(别删):资源的空目录不会被导入,放一个文件进来,
829
+ scripts/ 才会出现在资源管理器里。
830
+ `;
831
+ }
832
+ return `# ${bundle}/views
833
+
834
+ 本子包的 View 预制体放在这里:
835
+
836
+ assets/bundles/${bundle}/views/<模块名>/<类名>.prefab
837
+
838
+ 这个文件只是占位(别删):资源的空目录不会被导入,放一个文件进来,
839
+ views/ 才会出现在资源管理器里。
840
+ `;
841
+ }
842
+ /**
843
+ * 建好 scripts/ + views/,并在里面各放一个占位 README(已有文件不覆盖)。
844
+ *
845
+ * 为什么要放文件:**空目录不会被资源库导入**,资源管理器里就看不到(实测)。
846
+ * 文件优先走 create-asset —— 编辑器发出的才是"新增文件"事件,面板才会认。
847
+ * 返回错误文案;成功为 null。
848
+ */
849
+ async function ensureBundleLayout(abs, name, rel) {
850
+ try {
851
+ const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
852
+ for (const dir of [constants_1.BUNDLE_SCRIPTS_SUBDIR, constants_1.VIEWS_SUBDIR]) {
853
+ const dirAbs = (0, path_1.join)(abs, dir);
854
+ await fs.mkdir(dirAbs, { recursive: true });
855
+ const readmeAbs = (0, path_1.join)(dirAbs, BUNDLE_README);
856
+ if ((0, fs_extra_1.existsSync)(readmeAbs)) {
857
+ continue;
858
+ }
859
+ const made = await Editor.Message.request('asset-db', 'create-asset', `db://${rel}/${dir}/${BUNDLE_README}`, bundleReadme(dir, name), { overwrite: false }).catch(() => null);
860
+ if (!made) {
861
+ // 编辑器建不了(父目录还没导入等)就落盘,后面 refresh 会补上
862
+ await fs.writeFile(readmeAbs, bundleReadme(dir, name), { flag: 'wx' })
863
+ .catch(() => undefined);
864
+ }
865
+ }
866
+ return null;
867
+ }
868
+ catch (e) {
869
+ return `创建目录失败:${abs}(${(e === null || e === void 0 ? void 0 : e.message) || e})`;
870
+ }
871
+ }
872
+ /**
873
+ * 建(或补齐)一个子包:目录树 -> refresh 导入 -> 标 Bundle -> 确认子目录被编辑器认到。
874
+ *
875
+ * @param repairing 目录本来就存在(上次失败留下的壳)—— 只补缺的,不覆盖任何东西
876
+ */
877
+ async function buildBundle(name, rel, abs, repairing) {
878
+ // 1) 目录优先用**编辑器自己的 create-asset** 创建。
879
+ // 为什么:资源管理器面板只认 create-asset 发出的 "新增资源" 事件;先 fs.mkdir
880
+ // 再用 refresh 导入时,asset-db 会有记录、面板却没有 —— 之后任何 change 事件都会
881
+ // 报 "Can not change the asset ... original asset is not exist"(实测)。
882
+ // 磁盘上已存在的目录不能走 create-asset(会弹「是否覆盖」),只能记下来走 refresh。
883
+ let needRefresh = false;
884
+ for (const dirRel of [
885
+ constants_1.BUNDLES_ROOT,
886
+ rel,
887
+ `${rel}/${constants_1.BUNDLE_SCRIPTS_SUBDIR}`,
888
+ `${rel}/${constants_1.VIEWS_SUBDIR}`,
889
+ ]) {
890
+ const url = `db://${dirRel}`;
891
+ const absDir = (0, path_1.join)(projectPath(), dirRel);
892
+ if ((0, fs_extra_1.existsSync)(absDir)) {
893
+ // 磁盘上已有目录:不能 create-asset。DB 不认识的只能 refresh。
894
+ const known = await Editor.Message.request('asset-db', 'query-asset-info', url).catch(() => null);
895
+ if (!known) {
896
+ needRefresh = true;
897
+ }
898
+ continue;
899
+ }
900
+ // 磁盘上没有 -> 一律走 create-asset。
901
+ // ⚠️ 这里**不能先看 query-asset-info**:编辑器重启/删改后 DB 可能留着旧记录,
902
+ // "DB 说有、磁盘没有"时若跳过 create-asset,就只剩后面的 fs.mkdir,
903
+ // 面板永远收不到新增事件(实测:18:22 那次就是这样)。
904
+ const made = await Editor.Message.request('asset-db', 'create-asset', url, null).catch(() => null);
905
+ if (!made) {
906
+ needRefresh = true;
907
+ }
908
+ }
909
+ // 2) 磁盘上补齐(编辑器没建成/旧状态时兜底):目录 + 占位 README
910
+ const layoutError = await ensureBundleLayout(abs, name, rel);
911
+ if (layoutError) {
912
+ return { ok: false, message: layoutError };
913
+ }
914
+ // 3) 让编辑器导入这棵树(才有 .meta 可写)
915
+ try {
916
+ if (needRefresh) {
917
+ await refreshBundlesRoot();
918
+ }
919
+ }
920
+ catch (e) {
921
+ return {
922
+ ok: false,
923
+ message: `已创建 ${rel},但资源库刷新失败:${(e === null || e === void 0 ? void 0 : e.message) || e};请在资源管理器里刷新一次再重试`,
924
+ };
925
+ }
926
+ // 4) 自动勾上「配置为 Bundle」:3.8 没有公开的 asset-db 消息,只能改 .meta 的 userData
927
+ const marked = await (0, bundle_1.markAsBundle)(name);
928
+ if (marked) {
929
+ // 让编辑器重新读一遍 meta —— 否则它内存里还是 userData:{}
930
+ await Editor.Message.request('asset-db', 'refresh-asset', `db://${rel}`).catch(() => undefined);
931
+ }
932
+ // 5) 确认两个子目录进了 asset-db;没有就再刷一次(老状态兜底)
933
+ for (let attempt = 0; attempt < 2; attempt++) {
934
+ if (await bundleSubdirsImported(rel)) {
935
+ break;
936
+ }
937
+ const url = attempt === 0 ? `db://${constants_1.BUNDLES_ROOT}` : 'db://assets';
938
+ await Editor.Message.request('asset-db', 'refresh-asset', url).catch(() => undefined);
939
+ }
940
+ // 6) 磁盘结构自检:别让"空包"再静默发生
941
+ const missing = [constants_1.BUNDLE_SCRIPTS_SUBDIR, constants_1.VIEWS_SUBDIR].filter((dir) => !(0, fs_extra_1.existsSync)((0, path_1.join)(abs, dir)));
942
+ if (missing.length) {
943
+ return { ok: false, message: `目录结构不完整:${rel} 缺 ${missing.join(' / ')}` };
944
+ }
945
+ await (0, bundle_1.setTargetBundle)(name);
946
+ const verb = repairing ? '已补齐' : '已创建';
947
+ notifyTableDirsChanged();
948
+ return {
949
+ ok: true,
950
+ bundle: name,
951
+ dir: rel,
952
+ marked,
953
+ repaired: repairing,
954
+ message: marked
955
+ ? `${verb} ${rel}(scripts/ + views/),并已标记为 Bundle;目标包切到 ${name}。`
956
+ : `${verb} ${rel}(scripts/ + views/),目标包切到 ${name};`
957
+ + '但 .meta 里没能写上 isBundle,请在资源管理器里手动勾选「配置为 Bundle」。',
958
+ };
959
+ }
960
+ /**
961
+ * 新建子包:建预设目录树 -> 自动标记为 Asset Bundle -> 切当前目标包 ✓
962
+ *
963
+ * ⚠️ 目录**直接落盘**,不用 asset-db 的 create-asset 逐层建:
964
+ * 实测那样建出来的新包是空的(子目录的 create-asset 静默返回 null,不报错)。
965
+ * 落盘后再 refresh-asset 让编辑器导入,导入时会补上各级 .meta。
966
+ */
967
+ async function createBundle(bundleName) {
968
+ const name = (bundleName || '').trim();
969
+ if (!/^[a-z][a-z0-9_]*$/.test(name)) {
970
+ return { ok: false, message: '子包名只能用小写字母/数字/下划线,且字母开头' };
971
+ }
972
+ const rel = `${constants_1.BUNDLES_ROOT}/${name}`;
973
+ const abs = (0, path_1.join)(projectPath(), rel);
974
+ if (!(0, fs_extra_1.existsSync)(abs)) {
975
+ return await buildBundle(name, rel, abs, false);
976
+ }
977
+ // 目录已存在 ≠ 子包已存在:要么是真的重复创建(结构齐全 + 已标 Bundle),
978
+ // 要么只是上次失败留下的空壳(没 scripts/ views/、没 isBundle)。后者直接补齐。
979
+ const state = bundleState(abs);
980
+ if (state.missingDirs.length === 0 && state.marked) {
981
+ // 幂等:再点一次"创建"不该报错。当成"选中它";顺手补占位文件并 refresh,
982
+ // 让磁盘上没有 README 的旧包也能在资源管理器里显示出来。
983
+ const layoutError = await ensureBundleLayout(abs, name, rel);
984
+ if (layoutError) {
985
+ return { ok: false, message: layoutError };
986
+ }
987
+ await (0, bundle_1.setTargetBundle)(name);
988
+ await refreshBundlesRoot().catch(() => undefined);
989
+ await Editor.Message.request('asset-db', 'refresh-asset', `db://${rel}`).catch(() => undefined);
990
+ notifyTableDirsChanged();
991
+ return {
992
+ ok: true,
993
+ bundle: name,
994
+ dir: rel,
995
+ marked: true,
996
+ existed: true,
997
+ message: `子包已存在:${rel}(scripts/ + views/ 齐全,已标记 Bundle);目标包已切到 ${name}。`,
998
+ };
999
+ }
1000
+ return await buildBundle(name, rel, abs, true);
1001
+ }
1002
+ /** 列出所有子包 */
1003
+ async function queryBundles() {
1004
+ await (0, bundle_1.ensureTargetBundleLoaded)();
1005
+ const list = await (0, bundle_1.listBundles)();
1006
+ const current = (0, bundle_1.getTargetBundle)();
1007
+ // Profile 里记着的包可能已经不在了(改名/删目录/换工程):
1008
+ // 退回主包并落盘,否则创建类命令会悄悄落到一个没人认识的目录里
1009
+ if (current && !list.includes(current)) {
1010
+ await (0, bundle_1.setTargetBundle)('');
1011
+ return { current: '', list };
1012
+ }
1013
+ return { current, list };
1014
+ }
1015
+ /**
1016
+ * 切换"当前目标包"('' = 主包)。
1017
+ *
1018
+ * 名字必须真的在 assets/bundles 下:否则 create-module / create-view 会落到一个
1019
+ * 编辑器不认识、下拉里也看不到的幽灵目录。
1020
+ */
1021
+ async function setBundle(bundleName) {
1022
+ const name = (bundleName || '').trim();
1023
+ if (name) {
1024
+ const known = await (0, bundle_1.listBundles)();
1025
+ if (!known.includes(name)) {
1026
+ throw new Error(`子包不存在:${name}(assets/bundles 下没有这个目录)`);
1027
+ }
1028
+ }
1029
+ await (0, bundle_1.setTargetBundle)(name);
1030
+ return { current: (0, bundle_1.getTargetBundle)() };
1031
+ }
1032
+ /**
1033
+ * 删除一个子包(连同 scripts/ views/ 下的全部内容)。
1034
+ *
1035
+ * 优先走 asset-db 的 `delete-asset`:它会同时删磁盘、清索引并通知资源管理器,
1036
+ * 不会留下"磁盘删了、编辑器还记着"的错位。编辑器不认识这个目录时才直接删盘 + refresh。
1037
+ *
1038
+ * 如果删的正是当前目标包,删完自动切回主包(绝不把目标留在不存在的目录上)。
1039
+ */
1040
+ async function deleteBundle(bundleName) {
1041
+ const name = (bundleName || '').trim();
1042
+ if (!name) {
1043
+ return { ok: false, message: '不能删除主包' };
1044
+ }
1045
+ if (!/^[a-z][a-z0-9_]*$/.test(name)) {
1046
+ return { ok: false, message: `非法的子包名: "${name}"` };
1047
+ }
1048
+ const rel = `${constants_1.BUNDLES_ROOT}/${name}`;
1049
+ const abs = (0, path_1.join)(projectPath(), rel);
1050
+ if (!(0, fs_extra_1.existsSync)(abs)) {
1051
+ return { ok: false, message: `子包不存在:${rel}` };
1052
+ }
1053
+ const url = `db://${rel}`;
1054
+ const info = await Editor.Message.request('asset-db', 'query-asset-info', url).catch(() => null);
1055
+ if (info) {
1056
+ await Editor.Message.request('asset-db', 'delete-asset', url);
1057
+ }
1058
+ // 编辑器没删干净(或它根本不认识这个目录)时直接删盘
1059
+ if ((0, fs_extra_1.existsSync)(abs)) {
1060
+ (0, fs_extra_1.removeSync)(abs);
1061
+ }
1062
+ if ((0, fs_extra_1.existsSync)(abs)) {
1063
+ return { ok: false, message: `删除失败:${rel}(可能被占用,关掉打开它的窗口再试)` };
1064
+ }
1065
+ await refreshBundlesRoot().catch(() => undefined);
1066
+ if ((0, bundle_1.getTargetBundle)() === name) {
1067
+ await (0, bundle_1.setTargetBundle)('');
1068
+ }
1069
+ notifyTableDirsChanged();
1070
+ return { ok: true, name, current: (0, bundle_1.getTargetBundle)(), message: `已删除子包:${rel}` };
1071
+ }
1072
+ /**
1073
+ * 生成脚本里到 `framework/` 的相对前缀(只对 workspace 模式有意义)。
1074
+ *
1075
+ * 主包模块在 `assets/scripts/gameplay/<m>`,回 `assets/scripts` 是 2/3 层 —— 返回 '' 用模板默认值。
1076
+ *
1077
+ * 子包模块在 `assets/bundles/<n>/scripts/<m>`:上到 `assets` 之后**不在 scripts 里**,
1078
+ * 还要再进一层 `scripts/`,所以是"4/5 层 + scripts/",**不是**主包基础上多几个 `../`。
1079
+ * (模块 4 层、View 5 层;写错过一次,集成测试盯着生成结果。)
1080
+ */
1081
+ function frameworkBase(kind) {
1082
+ if (!(0, bundle_1.getTargetBundle)()) {
1083
+ return '';
1084
+ }
1085
+ const up = kind === 'view' ? 5 : 4;
1086
+ return '../'.repeat(up) + 'scripts/';
1087
+ }
502
1088
  exports.methods = {
1089
+ createBundle,
1090
+ queryBundles,
1091
+ setBundle,
1092
+ deleteBundle,
503
1093
  /** 更新框架:直接按 spec 装,不进公共模块列表 */
504
1094
  async updateFrameworkPackage() {
505
1095
  return installProjectPackage('@ccgf/framework@latest');
@@ -558,6 +1148,139 @@ exports.methods = {
558
1148
  openWorkbench() {
559
1149
  Editor.Panel.open(`${package_json_1.default.name}.workbench`);
560
1150
  },
1151
+ /** 独立的数据表工具面板(与工作台完全分开) */
1152
+ openTableTool() {
1153
+ Editor.Panel.open(`${package_json_1.default.name}.table-tool`);
1154
+ },
1155
+ /** 扫描工程根目录 tables/ 下的 CSV */
1156
+ queryTables() {
1157
+ try {
1158
+ const files = (0, tables_1.scanTables)(projectPath());
1159
+ const duplicates = (0, tables_1.findDuplicateTableNames)(files).map((d) => `表名 "${d.name}" 重复:${d.files.join(' / ')}`);
1160
+ // 建表时的目录候选:resources/tables + 每个 bundle 的 tables + 已有 CSV 的目录
1161
+ const dirs = new Set(['resources/tables']);
1162
+ const bundles = new Set();
1163
+ const bundlesRoot = (0, path_1.join)(projectPath(), 'assets', 'bundles');
1164
+ if ((0, fs_extra_1.existsSync)(bundlesRoot)) {
1165
+ for (const entry of (0, fs_extra_1.readdirSync)(bundlesRoot, { withFileTypes: true })) {
1166
+ if (entry.isDirectory()) {
1167
+ bundles.add(entry.name);
1168
+ dirs.add(`bundles/${entry.name}/tables`);
1169
+ }
1170
+ }
1171
+ }
1172
+ const bundleNameOf = (rel) => {
1173
+ const match = /^bundles\/([^/]+)\//.exec(rel);
1174
+ return match ? match[1] : '';
1175
+ };
1176
+ const bundleExists = (name) => !name || (0, fs_extra_1.existsSync)((0, path_1.join)(projectPath(), 'assets', 'bundles', name));
1177
+ for (const file of files) {
1178
+ const dir = (0, path_1.dirname)(file.relative).replace(/\\/g, '/');
1179
+ const bundleName = bundleNameOf(file.relative);
1180
+ if (dir && dir !== '.' && bundleExists(bundleName)) {
1181
+ if (bundleName)
1182
+ bundles.add(bundleName);
1183
+ dirs.add(dir);
1184
+ }
1185
+ }
1186
+ return {
1187
+ ok: true,
1188
+ root: 'tables',
1189
+ dirs: [...dirs].sort(),
1190
+ bundles: [...bundles].sort(),
1191
+ tables: files.map((f) => {
1192
+ const bundleName = bundleNameOf(f.relative);
1193
+ const missingBundle = !bundleExists(bundleName);
1194
+ return {
1195
+ relative: f.relative,
1196
+ binRelative: f.binRelative,
1197
+ absolute: f.absolute,
1198
+ tableName: f.tableName,
1199
+ note: f.note,
1200
+ error: f.error || (missingBundle
1201
+ ? `目标 bundle 不存在:assets/bundles/${bundleName}(请先新建 Bundle)`
1202
+ : undefined),
1203
+ };
1204
+ }),
1205
+ duplicates,
1206
+ };
1207
+ }
1208
+ catch (e) {
1209
+ return { ok: false, error: tableErrorText(e), dirs: [], bundles: [], tables: [], duplicates: [] };
1210
+ }
1211
+ },
1212
+ /**
1213
+ * 新建表骨架(只有 ID 一列)。
1214
+ * @param payload { dir: 相对 tables/ 的目录;fileName: 表名_备注 }
1215
+ */
1216
+ createTableFile(payload = {}) {
1217
+ var _a, _b;
1218
+ const dir = ((_a = payload.dir) !== null && _a !== void 0 ? _a : '').trim();
1219
+ const fileName = ((_b = payload.fileName) !== null && _b !== void 0 ? _b : '').trim();
1220
+ if (!dir)
1221
+ return { ok: false, error: '目录不能为空' };
1222
+ if (!fileName)
1223
+ return { ok: false, error: '文件名不能为空' };
1224
+ try {
1225
+ const info = (0, tables_1.createTable)(projectPath(), dir, fileName);
1226
+ return { ok: true, info };
1227
+ }
1228
+ catch (e) {
1229
+ return { ok: false, error: tableErrorText(e) };
1230
+ }
1231
+ },
1232
+ /**
1233
+ * 导出数据表:paths 为空 = 全部;否则只导出指定相对路径。
1234
+ * 导出成功后自动 refresh asset-db。
1235
+ */
1236
+ async exportTables(payload = {}) {
1237
+ try {
1238
+ const project = projectPath();
1239
+ const files = (0, tables_1.scanTables)(project);
1240
+ (0, tables_1.assertUniqueTableNames)(files);
1241
+ const wanted = Array.isArray(payload.paths) ? payload.paths : [];
1242
+ const targets = wanted.length > 0
1243
+ ? files.filter((f) => wanted.includes(f.relative))
1244
+ : files;
1245
+ if (targets.length === 0) {
1246
+ return { ok: false, error: '没有可导出的表', results: [], errors: [] };
1247
+ }
1248
+ const results = [];
1249
+ const errors = [];
1250
+ const warnings = [];
1251
+ for (const file of targets) {
1252
+ try {
1253
+ assertBundleTarget(project, file.relative);
1254
+ const built = (0, tables_1.buildTable)(project, file.relative);
1255
+ const warning = await writeTableAsset(project, built);
1256
+ results.push({
1257
+ relative: file.relative,
1258
+ binRelative: built.binRelative,
1259
+ tableName: built.name,
1260
+ bytes: built.buffer.length,
1261
+ });
1262
+ if (warning) {
1263
+ warnings.push(`${built.binRelative}:${warning}`);
1264
+ }
1265
+ }
1266
+ catch (e) {
1267
+ errors.push(tableErrorText(e, file.relative));
1268
+ }
1269
+ }
1270
+ if (results.length > 0) {
1271
+ try {
1272
+ warnings.push(...await generateTableTypes(project, files));
1273
+ }
1274
+ catch (e) {
1275
+ warnings.push(`TableTypes.ts 生成失败:${e instanceof Error ? e.message : String(e)}`);
1276
+ }
1277
+ }
1278
+ return { ok: errors.length === 0, results, errors, warnings };
1279
+ }
1280
+ catch (e) {
1281
+ return { ok: false, error: tableErrorText(e), results: [], errors: [], warnings: [] };
1282
+ }
1283
+ },
561
1284
  /** 面板的层级下拉由主进程下发,避免扩展里出现第二份层级列表 */
562
1285
  queryLayers() {
563
1286
  return [...constants_1.LAYERS];
@@ -593,6 +1316,7 @@ exports.methods = {
593
1316
  * 与体检共用 doctor.listModules,保证面板显示和体检判定一致。
594
1317
  */
595
1318
  async queryModules() {
1319
+ await (0, bundle_1.ensureTargetBundleLoaded)();
596
1320
  const snap = snapshot();
597
1321
  return (0, doctor_1.listModules)(snap).map((m) => {
598
1322
  var _a;
@@ -610,6 +1334,7 @@ exports.methods = {
610
1334
  },
611
1335
  /** 启动顺序预览 + 层级占用(开发辅助) */
612
1336
  async queryOverview() {
1337
+ await (0, bundle_1.ensureTargetBundleLoaded)();
613
1338
  const snap = snapshot();
614
1339
  const views = (0, doctor_1.listViews)(snap);
615
1340
  const usage = constants_1.LAYERS.map((layer) => ({
@@ -628,6 +1353,7 @@ exports.methods = {
628
1353
  /** 一键体检 */
629
1354
  async runDoctor() {
630
1355
  var _a;
1356
+ await (0, bundle_1.ensureTargetBundleLoaded)();
631
1357
  const findings = (0, doctor_1.runDoctor)(snapshot(), constants_1.LAYERS);
632
1358
  const summary = { error: 0, warn: 0, info: 0 };
633
1359
  for (const f of findings) {
@@ -644,6 +1370,7 @@ exports.methods = {
644
1370
  if (!moduleName || !naming_1.IDENTIFIER_RE.test(moduleName)) {
645
1371
  throw new Error(`非法的模块名: "${moduleName}"`);
646
1372
  }
1373
+ await (0, bundle_1.ensureTargetBundleLoaded)();
647
1374
  const moduleDir = (0, naming_1.normalizeModule)(moduleName).dir;
648
1375
  const snap = snapshot();
649
1376
  return (0, doctor_1.listViews)(snap)
@@ -653,7 +1380,7 @@ exports.methods = {
653
1380
  return ({
654
1381
  name: v.className,
655
1382
  scriptUrl: dbUrl(v.scriptFile),
656
- prefabUrl: v.registeredPath ? dbUrl(`${constants_1.RESOURCES_DIR}/${v.registeredPath}.prefab`) : '',
1383
+ prefabUrl: v.registeredPath ? dbUrl(`${(0, bundle_1.prefabKeyRoot)()}/${v.registeredPath}.prefab`) : '',
657
1384
  prefabExists: v.registeredPath ? snap.prefabsByResourcePath[v.registeredPath] !== undefined : false,
658
1385
  layer: (_a = v.registeredLayer) !== null && _a !== void 0 ? _a : '',
659
1386
  });
@@ -745,11 +1472,12 @@ exports.methods = {
745
1472
  if (!moduleName || !naming_1.IDENTIFIER_RE.test(moduleName)) {
746
1473
  throw new Error(`非法的模块名: "${moduleName}"`);
747
1474
  }
1475
+ await (0, bundle_1.ensureTargetBundleLoaded)();
748
1476
  const moduleDir = (0, naming_1.normalizeModule)(moduleName).dir;
749
1477
  const snap = snapshot();
750
1478
  const views = (0, doctor_1.listViews)(snap).filter((v) => v.moduleDir === moduleDir);
751
1479
  const cids = views.map((v) => snap.scriptCids[v.scriptFile]).filter(Boolean);
752
- const moduleCid = snap.scriptCids[`${constants_1.GAMEPLAY_DIR}/${moduleDir}/${(0, naming_1.normalizeModule)(moduleName).moduleClass}.ts`];
1480
+ const moduleCid = snap.scriptCids[`${(0, bundle_1.scriptsRoot)()}/${moduleDir}/${(0, naming_1.normalizeModule)(moduleName).moduleClass}.ts`];
753
1481
  const allCids = moduleCid ? cids.concat([moduleCid]) : cids;
754
1482
  return {
755
1483
  views: views.map((v) => v.className),
@@ -776,6 +1504,7 @@ exports.methods = {
776
1504
  * @param order 模块启动顺序
777
1505
  */
778
1506
  async createModule(moduleName, order) {
1507
+ await (0, bundle_1.ensureTargetBundleLoaded)();
779
1508
  if (!moduleName || !naming_1.IDENTIFIER_RE.test(moduleName)) {
780
1509
  throw new Error(`非法的模块名: "${moduleName}",请使用合法的标识符`);
781
1510
  }
@@ -783,7 +1512,7 @@ exports.methods = {
783
1512
  throw new Error(`非法的 order: ${order}`);
784
1513
  }
785
1514
  const naming = (0, naming_1.normalizeModule)(moduleName);
786
- const moduleDirUrl = `db://${constants_1.GAMEPLAY_DIR}/${naming.dir}`;
1515
+ const moduleDirUrl = `db://${(0, bundle_1.scriptsRoot)()}/${naming.dir}`;
787
1516
  // 先查存在性,给出明确原因(旧版只在 create-asset 返回空时说“可能已存在”)
788
1517
  const moduleUrl = `${moduleDirUrl}/${naming.moduleClass}.ts`;
789
1518
  const modelUrl = `${moduleDirUrl}/${naming.modelClass}.ts`;
@@ -812,8 +1541,8 @@ exports.methods = {
812
1541
  }
813
1542
  created.push(url);
814
1543
  };
815
- await createOrRollback(moduleUrl, (0, templates_1.buildModuleScript)(naming.moduleClass, naming.modelClass, order, frameworkImportMode()), '模块');
816
- await createOrRollback(modelUrl, (0, templates_1.buildModelScript)(naming.modelClass, frameworkImportMode()), '模型');
1544
+ await createOrRollback(moduleUrl, (0, templates_1.buildModuleScript)(naming.moduleClass, naming.modelClass, order, frameworkImportMode(), frameworkBase('module'), (0, bundle_1.getTargetBundle)()), '模块');
1545
+ await createOrRollback(modelUrl, (0, templates_1.buildModelScript)(naming.modelClass, frameworkImportMode(), frameworkBase('module')), '模型');
817
1546
  await createOrRollback(eventsUrl, (0, templates_1.buildEventsScript)(naming.dir, naming.moduleClass), '事件声明');
818
1547
  await Editor.Message.request('asset-db', 'refresh-asset', moduleDirUrl);
819
1548
  return {
@@ -836,7 +1565,7 @@ exports.methods = {
836
1565
  throw new Error(`非法的 order: ${order}`);
837
1566
  }
838
1567
  const moduleDir = (0, naming_1.normalizeModule)(moduleName).dir;
839
- const moduleDirPath = (0, path_1.join)(projectPath(), constants_1.GAMEPLAY_DIR, moduleDir);
1568
+ const moduleDirPath = (0, path_1.join)(projectPath(), (0, bundle_1.scriptsRoot)(), moduleDir);
840
1569
  let files = [];
841
1570
  try {
842
1571
  files = (0, fs_extra_1.readdirSync)(moduleDirPath);
@@ -855,7 +1584,7 @@ exports.methods = {
855
1584
  throw new Error(`未在 ${moduleFile} 中找到 order 字段`);
856
1585
  }
857
1586
  (0, fs_extra_1.writeFileSync)(fullPath, newContent);
858
- await Editor.Message.request('asset-db', 'refresh-asset', dbUrl(`${constants_1.GAMEPLAY_DIR}/${moduleDir}`));
1587
+ await Editor.Message.request('asset-db', 'refresh-asset', dbUrl(`${(0, bundle_1.scriptsRoot)()}/${moduleDir}`));
859
1588
  return { moduleName: moduleDir, order };
860
1589
  },
861
1590
  /**
@@ -863,6 +1592,7 @@ exports.methods = {
863
1592
  * @param template 预制体模板,见 constants.PREFAB_TEMPLATES
864
1593
  */
865
1594
  async createView(moduleName, viewName, layer, template = 'empty') {
1595
+ await (0, bundle_1.ensureTargetBundleLoaded)();
866
1596
  if (!moduleName || !naming_1.IDENTIFIER_RE.test(moduleName)) {
867
1597
  throw new Error(`非法的模块名: "${moduleName}"`);
868
1598
  }
@@ -885,18 +1615,18 @@ exports.methods = {
885
1615
  throw new Error(`View 名字 "${className}" 已被模块 "${clash.moduleDir}" 占用;` +
886
1616
  `框架按类名全局查找,重名会加载错预制体,请换个名字`);
887
1617
  }
888
- const viewsDirUrl = `db://${constants_1.GAMEPLAY_DIR}/${moduleDir}/${constants_1.VIEWS_SUBDIR}`;
1618
+ const viewsDirUrl = `db://${(0, bundle_1.scriptsRoot)()}/${moduleDir}/${constants_1.VIEWS_SUBDIR}`;
889
1619
  await ensureDir(viewsDirUrl);
890
1620
  const scriptUrl = `${viewsDirUrl}/${className}.ts`;
891
1621
  if (await assetExists(scriptUrl)) {
892
1622
  throw new Error(`View 脚本已存在:${className}.ts(如需重建,请先删除该 View)`);
893
1623
  }
894
- const scriptContent = (0, templates_1.buildViewScript)(className, prefabPath, layer, frameworkImportMode());
1624
+ const scriptContent = (0, templates_1.buildViewScript)(className, prefabPath, layer, frameworkImportMode(), frameworkBase('view'), (0, bundle_1.getTargetBundle)());
895
1625
  const scriptAsset = await Editor.Message.request('asset-db', 'create-asset', scriptUrl, scriptContent, { overwrite: false });
896
1626
  if (!scriptAsset) {
897
1627
  throw new Error(`创建脚本失败: ${scriptUrl}`);
898
1628
  }
899
- const prefabDirUrl = `db://${constants_1.RESOURCES_DIR}/views/${moduleDir}`;
1629
+ const prefabDirUrl = `db://${(0, bundle_1.prefabRoot)()}/${moduleDir}`;
900
1630
  const prefabUrl = `${prefabDirUrl}/${className}.prefab`;
901
1631
  await ensureDir(prefabDirUrl);
902
1632
  if (await assetExists(prefabUrl)) {
@@ -933,8 +1663,8 @@ exports.methods = {
933
1663
  }
934
1664
  const moduleDir = (0, naming_1.normalizeModule)(moduleName).dir;
935
1665
  const className = (0, naming_1.normalizeViewName)(viewName);
936
- const prefabUrl = `db://${constants_1.RESOURCES_DIR}/views/${moduleDir}/${className}.prefab`;
937
- const scriptUrl = `db://${constants_1.GAMEPLAY_DIR}/${moduleDir}/${constants_1.VIEWS_SUBDIR}/${className}.ts`;
1666
+ const prefabUrl = `db://${(0, bundle_1.prefabRoot)()}/${moduleDir}/${className}.prefab`;
1667
+ const scriptUrl = `db://${(0, bundle_1.scriptsRoot)()}/${moduleDir}/${constants_1.VIEWS_SUBDIR}/${className}.ts`;
938
1668
  const deleted = [];
939
1669
  for (const url of [prefabUrl, scriptUrl]) {
940
1670
  const info = await Editor.Message.request('asset-db', 'query-asset-info', url);
@@ -944,9 +1674,9 @@ exports.methods = {
944
1674
  }
945
1675
  }
946
1676
  // 清理空目录(旧版会留下 resources/views/<模块> 这种空壳)
947
- await pruneEmptyDir((0, path_1.join)(projectPath(), constants_1.RESOURCES_DIR, 'views', moduleDir));
948
- await Editor.Message.request('asset-db', 'refresh-asset', `db://${constants_1.RESOURCES_DIR}/views/${moduleDir}`);
949
- await Editor.Message.request('asset-db', 'refresh-asset', dbUrl(`${constants_1.GAMEPLAY_DIR}/${moduleDir}/${constants_1.VIEWS_SUBDIR}`));
1677
+ await pruneEmptyDir((0, path_1.join)(projectPath(), (0, bundle_1.prefabRoot)(), moduleDir));
1678
+ await Editor.Message.request('asset-db', 'refresh-asset', `db://${(0, bundle_1.prefabRoot)()}/${moduleDir}`);
1679
+ await Editor.Message.request('asset-db', 'refresh-asset', dbUrl(`${(0, bundle_1.scriptsRoot)()}/${moduleDir}/${constants_1.VIEWS_SUBDIR}`));
950
1680
  return { className, moduleDir, deleted };
951
1681
  },
952
1682
  /**
@@ -957,8 +1687,8 @@ exports.methods = {
957
1687
  throw new Error(`非法的模块名: "${moduleName}"`);
958
1688
  }
959
1689
  const moduleDir = (0, naming_1.normalizeModule)(moduleName).dir;
960
- const moduleDirPath = (0, path_1.join)(projectPath(), constants_1.GAMEPLAY_DIR, moduleDir);
961
- const prefabDirPath = (0, path_1.join)(projectPath(), constants_1.RESOURCES_DIR, 'views', moduleDir);
1690
+ const moduleDirPath = (0, path_1.join)(projectPath(), (0, bundle_1.scriptsRoot)(), moduleDir);
1691
+ const prefabDirPath = (0, path_1.join)(projectPath(), (0, bundle_1.prefabRoot)(), moduleDir);
962
1692
  const removed = [];
963
1693
  for (const p of [prefabDirPath, moduleDirPath]) {
964
1694
  try {
@@ -971,8 +1701,8 @@ exports.methods = {
971
1701
  /* 不存在则跳过 */
972
1702
  }
973
1703
  }
974
- await Editor.Message.request('asset-db', 'refresh-asset', `db://${constants_1.RESOURCES_DIR}/views`);
975
- await Editor.Message.request('asset-db', 'refresh-asset', dbUrl(constants_1.GAMEPLAY_DIR));
1704
+ await Editor.Message.request('asset-db', 'refresh-asset', `db://${(0, bundle_1.prefabRoot)()}`);
1705
+ await Editor.Message.request('asset-db', 'refresh-asset', dbUrl((0, bundle_1.scriptsRoot)()));
976
1706
  return { moduleDir, removed };
977
1707
  },
978
1708
  /* ------------------------------ 公共模块 ------------------------------ */
@@ -993,9 +1723,8 @@ exports.methods = {
993
1723
  // 这里只做一件事:装完之后补上这个模块需要的工程资源,然后原样透传。
994
1724
  const r = await runSharedAction('install', wanted);
995
1725
  const made = await ensureScaffoldAssets(String(wanted));
996
- if (made.length > 0) {
997
- console.log(`[ccgf] 已生成默认红点样式:${made.join(', ')}(默认样式路径:reddot/default)`);
998
- }
1726
+ if (made.length > 0)
1727
+ (0, log_1.log)(`[ccgf] 已生成模块资源:${made.join(', ')}`);
999
1728
  return r;
1000
1729
  },
1001
1730
  /** 卸载一个公共模块:直接代跑 `npm uninstall` */
@@ -1007,10 +1736,13 @@ exports.methods = {
1007
1736
  * @en Method Triggered on Extension Startup
1008
1737
  * @zh 扩展启动时触发的方法
1009
1738
  */
1010
- function load() { }
1739
+ function load() {
1740
+ // 「上次选的目标包」存在 Profile 里:异步读,这里只点火,不阻塞扩展启动
1741
+ void (0, bundle_1.ensureTargetBundleLoaded)();
1742
+ }
1011
1743
  /**
1012
1744
  * @en Method triggered when uninstalling the extension
1013
1745
  * @zh 卸载扩展时触发的方法
1014
1746
  */
1015
1747
  function unload() { }
1016
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"main.js","sourceRoot":"","sources":["../source/main.ts"],"names":[],"mappings":";;;;;;AAyoCA,oBAA0B;AAM1B,wBAA4B;AA/oC5B,aAAa;AACb,mEAA0C;AAC1C,iDAAiD;AACjD,uCAAgH;AAChH,+BAA4B;AAC5B,2CAUqB;AACrB,qCAA2F;AAC3F,qCAMkB;AAClB,uCAMmB;AACnB,yCAKoB;AACpB,qCAckB;AAClB,2CAS0C;AAG1C,wEAAwE;AAExE;;;GAGG;AACH,8DAA8D;AAC9D,MAAM,UAAU,GAA2B,OAAO,CAAC,eAAe,CAAC,CAAC;AAEpE,yEAAyE;AAEzE,YAAY;AACZ,SAAS,WAAW;IAChB,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC;AAC/B,CAAC;AAED;;;;;;GAMG;AACH,SAAS,mBAAmB;IACxB,OAAO,IAAA,qBAAU,EAAC,IAAA,WAAI,EAAC,WAAW,EAAE,EAAE,0BAA0B,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;AACjG,CAAC;AAED,2BAA2B;AAC3B,SAAS,KAAK,CAAC,GAAW;IACtB,OAAO,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;AAC7C,CAAC;AAED,iCAAiC;AACjC,SAAS,YAAY,CAAC,IAAY;IAC9B,OAAO,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AACvD,CAAC;AAED,6CAA6C;AAC7C,iEAAiE;AACjE,SAAS,iBAAiB;IACtB,MAAM,GAAG,GAA2B,EAAE,CAAC;IACvC,MAAM,IAAI,GAAG,IAAA,WAAI,EAAC,WAAW,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;IAChE,MAAM,IAAI,GAAG,CAAC,GAAW,EAAE,GAAW,EAAE,EAAE;QACtC,IAAI,OAAc,CAAC;QACnB,IAAI,CAAC;YAAC,OAAO,GAAG,IAAA,sBAAW,EAAC,GAAG,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;QAAC,CAAC;QAAC,WAAM,CAAC;YAAC,OAAO;QAAC,CAAC;QAC9E,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;YACtB,MAAM,CAAC,GAAG,IAAA,WAAI,EAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;YAAC,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YACzE,IAAI,CAAC,CAAC,WAAW,EAAE;gBAAE,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;iBAC3B,IAAI,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC5C,IAAI,CAAC;oBAAC,GAAG,CAAC,wBAAwB,GAAG,CAAC,CAAC,GAAG,IAAA,uBAAY,EAAC,CAAC,EAAE,MAAM,CAAC,CAAC;gBAAC,CAAC;gBAAC,QAAQ,YAAY,IAAd,CAAC,CAAC,YAAY,CAAC,CAAC;YAC/F,CAAC;QACL,CAAC;IACL,CAAC,CAAC;IACF,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IACf,OAAO,GAAG,CAAC;AACf,CAAC;AAED,SAAS,QAAQ;IACb,MAAM,CAAC,GAAG,IAAA,yBAAe,EAAC,WAAW,EAAE,EAAE,YAAY,CAAC,CAAC;IACvD,sCAAsC;IACtC,6CAA6C;IAC7C,uCACO,CAAC,KACJ,sBAAsB,EAAE,IAAA,qBAAU,EAAC,IAAA,WAAI,EAAC,WAAW,EAAE,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC,EAC7F,aAAa,EAAE,iBAAiB,EAAE,IACpC;AACN,CAAC;AAED,wEAAwE;AAExE;;;;;GAKG;AACH,IAAI,aAAa,GAAgF,IAAI,CAAC;AAEtG;;;;;;;;;;;;GAYG;AACH;;;;;;GAMG;AACH;;;;;GAKG;AACH,MAAM,yBAAyB,GAAG,KAAK,CAAC;AAExC,wCAAwC;AACxC,IAAI,kBAAkB,GAAG,KAAK,CAAC;AAE/B,SAAS,WAAW,CAChB,OAAe,EACf,SAAkF,EAClF,GAAW,EACX,YAAoB,uBAAc;IAElC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;;QAC3B,MAAM,MAAM,GAAa,EAAE,CAAC;QAC5B,MAAM,SAAS,GAAa,EAAE,CAAC;QAC/B,IAAI,KAAU,CAAC;QACf,MAAM,MAAM,GAAG,CAAC,QAAuB,EAAE,UAAqD,EAAE,EAAE;YAC9F,MAAM,MAAM,GAAG,IAAA,4BAAmB,EAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;YAC1D,OAAO,CAAC;gBACJ,MAAM,EAAE,IAAA,uBAAc,EAAC;oBACnB,OAAO;oBACP,QAAQ;oBACR,MAAM;oBACN,MAAM,EAAE,IAAA,4BAAmB,EAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;oBACrD,UAAU;iBACb,CAAC;gBACF,MAAM;aACT,CAAC,CAAC;QACP,CAAC,CAAC;QACF,IAAI,CAAC;YACD,KAAK,GAAG,IAAA,qBAAK,EAAC,SAAS,CAAC,OAAO,EAAE,SAAS,CAAC,IAAI,EAAE;gBAC7C,GAAG;gBACH,WAAW,EAAE,IAAI;gBACjB,wBAAwB,EAAE,SAAS,CAAC,wBAAwB;aAC/D,CAAC,CAAC;QACP,CAAC;QAAC,OAAO,GAAQ,EAAE,CAAC;YAChB,MAAM,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,CAAA,GAAG,aAAH,GAAG,uBAAH,GAAG,CAAE,OAAO,EAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC5E,OAAO;QACX,CAAC;QACD,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;YAAC,KAAK,CAAC,IAAI,EAAE,CAAC;QAAC,CAAC;QAAC,QAAQ,UAAU,IAAZ,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;QAC1F,MAAA,KAAK,CAAC,MAAM,0CAAE,EAAE,CAAC,MAAM,EAAE,CAAC,CAAS,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QACxD,MAAA,KAAK,CAAC,MAAM,0CAAE,EAAE,CAAC,MAAM,EAAE,CAAC,CAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3D,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAQ,EAAE,EAAE;YAC3B,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,MAAM,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,GAAG,aAAH,GAAG,uBAAH,GAAG,CAAE,IAAI,EAAE,OAAO,EAAE,CAAA,GAAG,aAAH,GAAG,uBAAH,GAAG,CAAE,OAAO,EAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACjG,CAAC,CAAC,CAAC;QACH,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,IAAmB,EAAE,EAAE;YACtC,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,IAAI,KAAK,KAAK,IAAI;gBAAE,OAAO;YAC3B,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACvB,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;AACP,CAAC;AACD;;;;;;;;;;GAUG;AACH,SAAS,aAAa,CAAC,KAAc;IACjC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACvB,MAAM,KAAK,GAAG,aAAa,IAAI,GAAG,GAAG,aAAa,CAAC,EAAE,GAAG,6BAAiB,CAAC;IAE1E,IAAI,CAAC,KAAK,IAAI,KAAK,EAAE,CAAC;QAClB,OAAO,EAAE,OAAO,EAAE,aAAc,CAAC,OAAO,EAAE,KAAK,EAAE,aAAc,CAAC,KAAK,EAAE,CAAC;IAC5E,CAAC;IAED,kBAAkB;IAClB,KAAK,eAAe,EAAE,CAAC;IAEvB,IAAI,aAAa,EAAE,CAAC;QAChB,OAAO,EAAE,OAAO,EAAE,aAAa,CAAC,OAAO,EAAE,KAAK,EAAE,aAAa,CAAC,KAAK,EAAE,CAAC;IAC1E,CAAC;IACD,OAAO;QACH,OAAO,EAAE,EAAE;QACX,KAAK,EAAE,kBAAkB,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,iBAAiB;KAC9D,CAAC;AACN,CAAC;AAED,gCAAgC;AAChC,KAAK,UAAU,eAAe;;IAC1B,IAAI,kBAAkB;QAAE,OAAO;IAC/B,kBAAkB,GAAG,IAAI,CAAC;IAC1B,IAAI,CAAC;QACD,MAAM,OAAO,GAA0B,EAAE,CAAC;QAC1C,MAAM,QAAQ,GAAa,EAAE,CAAC;QAE9B,KAAK,MAAM,IAAI,IAAI,yBAAc,EAAE,CAAC;YAChC,MAAM,OAAO,GAAG,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC;YAC/C,MAAM,SAAS,GAAG,IAAA,qBAAY,EAC1B,CAAC,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,EAAE,GAAG,IAAA,mBAAQ,EAAC,IAAI,CAAC,CAAC,CACxE,CAAC;YACF,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,WAAW,CAAC,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,EAAE,yBAAyB,CAAC,CAAC;YAC3G,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC;gBACb,QAAQ,CAAC,IAAI,CAAC,IAAI,GAAG,GAAG,GAAG,CAAC,MAAA,MAAM,CAAC,IAAI,mCAAI,CAAC,SAAS,GAAG,CAAC,MAAA,MAAM,CAAC,QAAQ,mCAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;gBACrF,SAAS;YACb,CAAC;YACD,MAAM,KAAK,GAAG,IAAA,0BAAe,EAAC,MAAM,CAAC,CAAC;YACtC,IAAI,KAAK;gBAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;;gBAC1B,QAAQ,CAAC,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC,CAAC;QACpD,CAAC;QAED,gCAAgC;QAChC,8CAA8C;QAC9C,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,aAAa,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAChF,aAAa,GAAG,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IACvD,CAAC;YAAS,CAAC;QACP,kBAAkB,GAAG,KAAK,CAAC;IAC/B,CAAC;AACL,CAAC;AAED;;;;;;;;;;;GAWG;AACH,KAAK,UAAU,gBAAgB,CAAC,aAAa,GAAG,KAAK;;IACjD,MAAM,IAAI,GAAG,WAAW,EAAE,CAAC;IAC3B,MAAM,QAAQ,GAAG,IAAA,6BAAmB,EAAC,IAAI,CAAC,CAAC;IAC3C,MAAM,mBAAmB,mCAClB,CAAC,MAAA,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAE,YAAY,mCAAI,EAAE,CAAC,GAC9B,CAAC,MAAA,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAE,eAAe,mCAAI,EAAE,CAAC,CACvC,CAAC;IAEF,MAAM,SAAS,GAAG,IAAA,2CAAiC,EAAC,IAAI,CAAC,CAAC;IAC1D,MAAM,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,IAAA,0BAAgB,EAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAEjE,MAAM,eAAe,GAA0B,EAAE,CAAC;IAClD,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,EAAE,CAAC;QAClD,MAAM,GAAG,GAAG,IAAA,8BAAoB,EAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAC7C,IAAI,GAAG,CAAC,SAAS,IAAI,IAAA,+BAAsB,EAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YACxD,eAAe,CAAC,IAAI,CAAC,IAAA,kCAAyB,EAAC,IAAI,EAAE,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;QACrF,CAAC;IACL,CAAC;IAED,MAAM,QAAQ,GAAG,MAAM,aAAa,CAAC,aAAa,CAAC,CAAC;IACpD,qDAAqD;IACrD,8BAA8B;IAC9B,MAAM,UAAU,GAAG,CAAC,CAAsB,EAAE,EAAE,CAAC,IAAA,gCAAqB,EAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC7E,MAAM,OAAO,GAAG,IAAA,qBAAY,EACxB,IAAA,qBAAY,EAAC,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,EACxD,eAAe,CAAC,MAAM,CAAC,UAAU,CAAC,CACrC,CAAC;IAEF,qDAAqD;IACrD,yBAAyB;IACzB,MAAM,gBAAgB,GAA2B,EAAE,CAAC;IACpD,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;QACnC,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC;IACjD,CAAC;IAED,6BAA6B;IAC7B,oCAAoC;IACpC,MAAM,MAAM,GAAG,IAAI,GAAG,EAAU,CAAC;IACjC,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC1B,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACvB,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,EAAE,CAAC;YACxD,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpB,CAAC;IACL,CAAC;IACD,MAAM,iBAAiB,GAA0C,EAAE,CAAC;IACpE,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,CAAC;QACxB,MAAM,GAAG,GAAG,IAAA,8BAAoB,EAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAC7C,iBAAiB,CAAC,IAAI,CAAC,GAAG;YACtB,SAAS,EAAE,GAAG,CAAC,SAAS;YACxB,OAAO,EAAE,GAAG,CAAC,OAAO;YACpB,cAAc,EAAE,IAAA,+BAAsB,EAAC,GAAG,CAAC,QAAQ,CAAC;SACvD,CAAC;IACN,CAAC;IAED,MAAM,IAAI,GAAG,QAAQ,EAAE,CAAC;IACxB,MAAM,OAAO,mCAAQ,IAAI,CAAC,eAAe,GAAK,IAAI,CAAC,cAAc,CAAE,CAAC;IAEpE,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,0BAAiB,EAAC,KAAK,EAAE;QAC5D,mBAAmB;QACnB,iBAAiB;QACjB,UAAU,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,IAAA,wBAAe,EAAC,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE;QAClE,OAAO;QACP,gBAAgB;KACnB,CAAC,CAAC,CAAC;IAEJ,OAAO;QACH,OAAO;QACP,qDAAqD;QACrD,WAAW,EAAE,SAAS;QACtB,4BAA4B;QAC5B,WAAW,EAAE,QAAQ,KAAK,IAAI;QAC9B,yCAAyC;QACzC,aAAa,EAAE,QAAQ,CAAC,KAAK;KAChC,CAAC;AACN,CAAC;AAED;;;;;GAKG;AACH,SAAS,MAAM,CAAC,MAA+B,EAAE,KAAe;IAC5D,MAAM,SAAS,GAAG,IAAA,qBAAY,EAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC9C,IAAI,CAAC;QACD,4DAA4D;QAC5D,iEAAiE;QACjE,yDAAyD;QACzD,sDAAsD;QACtD,MAAM,OAAO,GAAG,IAAA,yBAAS,EAAC,SAAS,CAAC,OAAO,EAAE,SAAS,CAAC,IAAI,EAAE;YACzD,GAAG,EAAE,WAAW,EAAE;YAClB,OAAO,EAAE,uBAAc;YACvB,WAAW,EAAE,IAAI;YACjB,SAAS,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI;YAC3B,wBAAwB,EAAE,SAAS,CAAC,wBAAwB;SAC/D,CAAC,CAAC;QACH,OAAO,IAAA,uBAAc,EAAC;YAClB,OAAO,EAAE,IAAA,yBAAgB,EAAC,MAAM,EAAE,KAAK,CAAC;YACxC,QAAQ,EAAE,OAAO,OAAO,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI;YACpE,MAAM,EAAE,IAAA,4BAAmB,EAAC,OAAO,CAAC,MAAM,CAAC;YAC3C,MAAM,EAAE,IAAA,4BAAmB,EAAC,OAAO,CAAC,MAAM,CAAC;YAC3C,UAAU,EAAE,OAAO,CAAC,KAAK;gBACrB,CAAC,CAAC;oBACE,IAAI,EAAG,OAAO,CAAC,KAA+B,CAAC,IAAI;oBACnD,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO;iBACjC;gBACD,CAAC,CAAC,IAAI;SACb,CAAC,CAAC;IACP,CAAC;IAAC,OAAO,GAAQ,EAAE,CAAC;QAChB,OAAO,IAAA,uBAAc,EAAC;YAClB,OAAO,EAAE,IAAA,yBAAgB,EAAC,MAAM,EAAE,KAAK,CAAC;YACxC,QAAQ,EAAE,IAAI;YACd,MAAM,EAAE,EAAE;YACV,MAAM,EAAE,EAAE;YACV,UAAU,EAAE,EAAE,OAAO,EAAE,CAAA,GAAG,aAAH,GAAG,uBAAH,GAAG,CAAE,OAAO,EAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE;SAC5E,CAAC,CAAC;IACP,CAAC;AACL,CAAC;AAED;;;;GAIG;AACH;;;;;;;GAOG;AACH,KAAK,UAAU,qBAAqB,CAAC,IAAY;;IAC7C,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC;IAC/D,MAAM,IAAI,GAAG,WAAW,EAAE,CAAC;IAC3B,MAAM,OAAO,GAAG,cAAc,GAAG,IAAI,CAAC;IACtC,MAAM,SAAS,GAAG,IAAA,qBAAY,EAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;IAClD,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,WAAW,CAAC,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,uBAAc,CAAC,CAAC;IAC/E,OAAO;QACH,EAAE,EAAE,MAAM,CAAC,EAAE;QACb,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAA,MAAM,CAAC,IAAI,mCAAI,CAAC,UAAU,GAAG,CAAC,MAAA,MAAM,CAAC,QAAQ,mCAAI,IAAI,CAAC,CAAC,CAAC;QACrF,OAAO,EAAE,IAAI;KAChB,CAAC;AACN,CAAC;AAED,KAAK,UAAU,eAAe,CAAC,MAA+B,EAAE,WAA8B;IAC1F,+BAA+B;IAC/B,0BAA0B;IAC1B,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAE,WAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;IAClF,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;QACxC,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC;IAC5B,CAAC;IAED,MAAM,MAAM,GAAG,MAAM,gBAAgB,EAAE,CAAC;IACxC,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC;IAC5D,IAAI,CAAC,KAAK,EAAE,CAAC;QACT,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAChD,MAAM,IAAI,KAAK,CACX,cAAc,MAAM,EAAE;cACpB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,CAC/D,CAAC;IACN,CAAC;IAED,qDAAqD;IACrD,iCAAiC;IACjC,mCAAmC;IACnC,MAAM,KAAK,GAAG,MAAM,KAAK,WAAW;QAChC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC;QACd,CAAC,CAAC,IAAA,4BAAmB,EAAC,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;IACjD,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAErC,mCAAmC;IACnC,MAAM,KAAK,GAAG,MAAM,gBAAgB,EAAE,CAAC;IAEvC;QACI;;;WAGG;QACH,EAAE,EAAE,MAAM,CAAC,EAAE,EACb,MAAM;QACN;;;WAGG;QACH,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAA,4BAAmB,EAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,IAKpE,KAAK,EACV;AACN,CAAC;AAED,aAAa;AACb,SAAS,WAAW,CAAC,GAAW;IAC5B,OAAO,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,kBAAkB,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,IAAa,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AACvG,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,SAAS,CAAC,MAAc;IACnC,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,kBAAkB,EAAE,MAAM,CAAC,CAAC;IAClF,IAAI,CAAC,IAAI,EAAE,CAAC;QACR,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,cAAc,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IAC3E,CAAC;AACL,CAAC;AAED,gCAAgC;AAChC,KAAK,UAAU,aAAa,CAAC,MAAc;IACvC,IAAI,CAAC;QACD,IAAI,IAAA,mBAAQ,EAAC,MAAM,CAAC,CAAC,WAAW,EAAE,IAAI,IAAA,sBAAW,EAAC,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACrE,IAAA,qBAAU,EAAC,MAAM,CAAC,CAAC;QACvB,CAAC;IACL,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACT,YAAY;IAChB,CAAC;AACL,CAAC;AAED,4BAA4B;AAC5B,SAAS,aAAa,CAAC,IAAsB,EAAE,IAAc;IACzD,MAAM,IAAI,GAAa,EAAE,CAAC;IAC1B,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;QACf,OAAO,IAAI,CAAC;IAChB,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;QAC7C,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;YACzC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACnB,CAAC;IACL,CAAC;IACD,OAAO,IAAI,CAAC;AAChB,CAAC;AAED,0EAA0E;AAE1E;;;;;GAKG;AACH,SAAS,aAAa,CAAC,IAAY;;IAC/B,MAAM,IAAI,GAAG,WAAW,EAAE,CAAC;IAC3B,MAAM,IAAI,GAAG,IAAA,WAAI,EAAC,IAAI,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC;IAC9C,IAAI,CAAC,IAAA,qBAAU,EAAC,IAAI,CAAC,EAAE,CAAC;QACpB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI,GAAG,SAAS,EAAE,CAAC;IAC1E,CAAC;IACD,MAAM,EAAE,GAAG,IAAA,WAAI,EAAC,IAAI,EAAE,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAY,CAAC,CAAC;IACrE,IAAA,qBAAU,EAAC,EAAE,CAAC,CAAC;IACf,IAAA,mBAAQ,EAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IACnB,kDAAkD;IAClD,IAAI,OAAO,GAAkB,IAAI,CAAC;IAClC,IAAI,CAAC;QACD,OAAO,GAAG,MAAA,IAAI,CAAC,KAAK,CAAC,IAAA,uBAAY,EAAC,IAAA,WAAI,EAAC,EAAE,EAAE,cAAc,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO,mCAAI,IAAI,CAAC;IACzF,CAAC;IAAC,QAAQ,iBAAiB,IAAnB,CAAC,CAAC,iBAAiB,CAAC,CAAC;IAC7B,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC;AAC3C,CAAC;AAED;;;;;;;;GAQG;AACH,KAAK,UAAU,oBAAoB,CAAC,OAAe;IAC/C,MAAM,IAAI,GAAa,EAAE,CAAC;IAC1B,6BAA6B;IAC7B,IAAI,OAAO,KAAK,eAAe;QAAE,OAAO,IAAI,CAAC;IAE7C,MAAM,MAAM,GAAG,QAAQ,yBAAa,SAAS,CAAC;IAC9C,MAAM,GAAG,GAAG,GAAG,MAAM,iBAAiB,CAAC;IACvC,IAAI,MAAM,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC;QACzB,OAAO,IAAI,CAAC,CAAG,uBAAuB;IAC1C,CAAC;IACD,MAAM,SAAS,CAAC,MAAM,CAAC,CAAC;IACxB,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,IAAA,6BAAiB,EAAC,SAAS,CAAC,CAAC,CAAC;IAC7D,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,cAAc,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;IAC3G,IAAI,CAAC,KAAK,EAAE,CAAC;QACT,OAAO,CAAC,IAAI,CAAC,qBAAqB,GAAG,EAAE,CAAC,CAAC;QACzC,OAAO,IAAI,CAAC;IAChB,CAAC;IACD,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,MAAM,CAAC,CAAC;IAClE,IAAI,CAAC,IAAI,CAAC,GAAG,yBAAa,wBAAwB,CAAC,CAAC;IACpD,OAAO,IAAI,CAAC;AAChB,CAAC;AAEY,QAAA,OAAO,GAA4C;IAC5D,+BAA+B;IAC/B,KAAK,CAAC,sBAAsB;QACxB,OAAO,qBAAqB,CAAC,wBAAwB,CAAC,CAAC;IAC3D,CAAC;IAED,4DAA4D;IAC5D,KAAK,CAAC,sBAAsB;;QACxB,MAAM,CAAC,GAAG,MAAM,qBAAqB,CAAC,uBAAuB,CAAC,CAAC;QAC/D,IAAI,CAAC,CAAC,CAAC,EAAE;YAAE,OAAO,CAAC,CAAC;QACpB,MAAM,CAAC,GAAG,aAAa,CAAC,gBAAgB,CAAC,CAAC;QAC1C,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,EAAE,OAAO,EAAE,MAAA,CAAC,CAAC,OAAO,mCAAI,IAAI,EAAE,OAAO,EAAE,MAAA,CAAC,CAAC,OAAO,mCAAI,IAAI,EAAE,CAAC;IAC1F,CAAC;IAED;;;;;;OAMG;IACH;;;;;;OAMG;IACH,aAAa;IAEb,KAAK,CAAC,aAAa,CAAC,aAAa,GAAG,KAAK;QACrC,MAAM,IAAI,GAAG,WAAW,EAAE,CAAC;QAC3B,MAAM,QAAQ,GAAG,MAAM,aAAa,CAAC,aAAa,CAAC,CAAC;QACpD,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAiB,EAAE;YAC7C,MAAM,GAAG,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;YAClE,OAAO,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;QACpC,CAAC,CAAC;QAEF,MAAM,aAAa,GAAG,iBAAiB,CAAC;QACxC,MAAM,SAAS,GAAG,IAAA,8BAAoB,EAAC,IAAI,EAAE,aAAa,CAAC,CAAC;QAE5D,8CAA8C;QAC9C,MAAM,WAAW,GAAG,IAAA,qBAAU,EAAC,IAAA,WAAI,EAAC,IAAI,EAAE,0BAA0B,CAAC,CAAC,CAAC;QAEvE,OAAO;YACH,SAAS,EAAE;gBACP,IAAI,EAAE,aAAa;gBACnB,SAAS,EAAE,SAAS,CAAC,SAAS;gBAC9B,SAAS,EAAE,WAAW;gBACtB,OAAO,EAAE,SAAS,CAAC,OAAO;gBAC1B,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC;aAClC;YACD,SAAS,EAAE;gBACP,IAAI,EAAE,sBAAW,CAAC,IAAI;gBACtB,OAAO,EAAE,sBAAW,CAAC,OAAO;gBAC5B,SAAS,EAAE,WAAW;gBACtB,MAAM,EAAE,QAAQ,CAAC,sBAAW,CAAC,IAAI,CAAC;aACrC;SACJ,CAAC;IACN,CAAC;IACD,aAAa;QACT,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,sBAAW,CAAC,IAAI,YAAY,CAAC,CAAC;IACvD,CAAC;IAED,mCAAmC;IACnC,WAAW;QACP,OAAO,CAAC,GAAG,kBAAM,CAAC,CAAC;IACvB,CAAC;IAED;;;OAGG;IACH,SAAS;QACL,MAAM,KAAK,GAA2B,EAAE,CAAC;QACzC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACxC,MAAM,IAAI,GAAG,GAAG,sBAAW,CAAC,IAAI,IAAI,GAAG,EAAE,CAAC;YAC1C,IAAI,IAAI,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;YAC3B,IAAI,CAAC;gBACD,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;gBAChC,IAAI,GAAG,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;oBACtB,IAAI,GAAG,GAAG,CAAC;gBACf,CAAC;YACL,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACT,uBAAuB;YAC3B,CAAC;YACD,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;QACtB,CAAC;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,qBAAqB;IACrB,cAAc;QACV,OAAO,4BAAgB,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,kCAAsB,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACrF,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,YAAY;QACd,MAAM,IAAI,GAAG,QAAQ,EAAE,CAAC;QACxB,OAAO,IAAA,oBAAW,EAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;;YAAC,OAAA,CAAC;gBACjC,IAAI,EAAE,CAAC,CAAC,GAAG;gBACX,KAAK,EAAE,MAAA,CAAC,CAAC,KAAK,mCAAI,CAAC;gBACnB,QAAQ,EAAE,CAAC,CAAC,SAAS,KAAK,IAAI;gBAC9B,SAAS,EAAE,IAAI;gBACf,6CAA6C;gBAC7C,UAAU,EAAE,CAAC,CAAC,UAAU;gBACxB,SAAS,EAAE,CAAC,CAAC,SAAS;gBACtB,UAAU,EAAE,CAAC,CAAC,UAAU;aAC3B,CAAC,CAAA;SAAA,CAAC,CAAC;IACR,CAAC;IAED,0BAA0B;IAC1B,KAAK,CAAC,aAAa;QACf,MAAM,IAAI,GAAG,QAAQ,EAAE,CAAC;QACxB,MAAM,KAAK,GAAG,IAAA,kBAAS,EAAC,IAAI,CAAC,CAAC;QAC9B,MAAM,KAAK,GAAG,kBAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YACjC,KAAK;YACL,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,eAAe,KAAK,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;SAClF,CAAC,CAAC,CAAC;QACJ,MAAM,OAAO,GAAG,IAAA,oBAAW,EAAC,IAAI,CAAC,CAAC;QAClC,OAAO;YACH,KAAK,EAAE,IAAA,uBAAc,EAAC,IAAI,CAAC;YAC3B,MAAM,EAAE,KAAK;YACb,WAAW,EAAE,OAAO,CAAC,MAAM;YAC3B,YAAY,EAAE,IAAA,qBAAY,EAAC,IAAI,CAAC,CAAC,MAAM;YACvC,SAAS,EAAE,KAAK,CAAC,MAAM;SAC1B,CAAC;IACN,CAAC;IAED,WAAW;IACX,KAAK,CAAC,SAAS;;QACX,MAAM,QAAQ,GAAG,IAAA,kBAAS,EAAC,QAAQ,EAAE,EAAE,kBAAM,CAAC,CAAC;QAC/C,MAAM,OAAO,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;QAC/C,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;YACvB,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAA,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,mCAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACzD,CAAC;QACD,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;IACjC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,UAAU,CAAC,UAAkB;QAC/B,IAAI,CAAC,UAAU,IAAI,CAAC,sBAAa,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,YAAY,UAAU,GAAG,CAAC,CAAC;QAC/C,CAAC;QACD,MAAM,SAAS,GAAG,IAAA,wBAAe,EAAC,UAAU,CAAC,CAAC,GAAG,CAAC;QAClD,MAAM,IAAI,GAAG,QAAQ,EAAE,CAAC;QACxB,OAAO,IAAA,kBAAS,EAAC,IAAI,CAAC;aACjB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC;aACxC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;;YAAC,OAAA,CAAC;gBACT,IAAI,EAAE,CAAC,CAAC,SAAS;gBACjB,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC;gBAC9B,SAAS,EAAE,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,yBAAa,IAAI,CAAC,CAAC,cAAc,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE;gBACvF,YAAY,EAAE,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,cAAc,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK;gBACnG,KAAK,EAAE,MAAA,CAAC,CAAC,eAAe,mCAAI,EAAE;aACjC,CAAC,CAAA;SAAA,CAAC,CAAC;IACZ,CAAC;IAED,2EAA2E;IAE3E,0DAA0D;IAC1D,KAAK,CAAC,aAAa;QACf,OAAO,IAAA,qBAAY,EAAC,QAAQ,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACxC,IAAI,EAAE,CAAC,CAAC,SAAS;YACjB,IAAI,EAAE,CAAC,CAAC,UAAU;YAClB,gBAAgB,EAAE,CAAC,CAAC,gBAAgB;YACpC,SAAS,EAAE,CAAC,CAAC,SAAS;YACtB,KAAK,EAAE,CAAC,CAAC,KAAK;SACjB,CAAC,CAAC,CAAC;IACR,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,aAAa,CAAC,WAAmB,EAAE,QAAgB,EAAE;QACvD,IAAI,CAAC,WAAW,IAAI,CAAC,sBAAa,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YACnD,MAAM,IAAI,KAAK,CAAC,mBAAmB,WAAW,aAAa,CAAC,CAAC;QACjE,CAAC;QACD,MAAM,SAAS,GAAG,IAAA,6BAAoB,EAAC,WAAW,CAAC,CAAC;QACpD,4CAA4C;QAC5C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACpE,MAAM,IAAI,KAAK,CAAC,cAAc,KAAK,EAAE,CAAC,CAAC;QAC3C,CAAC;QACD,MAAM,MAAM,GAAG,QAAQ,uBAAW,EAAE,CAAC;QACrC,MAAM,SAAS,CAAC,MAAM,CAAC,CAAC;QAExB,MAAM,SAAS,GAAG,GAAG,MAAM,IAAI,SAAS,KAAK,CAAC;QAC9C,IAAI,MAAM,WAAW,CAAC,SAAS,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAI,KAAK,CAAC,eAAe,SAAS,iBAAiB,CAAC,CAAC;QAC/D,CAAC;QAED,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CACtC,UAAU,EAAE,cAAc,EAAE,SAAS,EAAE,IAAA,8BAAkB,EAAC,SAAS,EAAE,mBAAmB,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAC3H,CAAC;QACF,IAAI,CAAC,KAAK,EAAE,CAAC;YACT,MAAM,IAAI,KAAK,CAAC,kBAAkB,SAAS,EAAE,CAAC,CAAC;QACnD,CAAC;QAED,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,MAAM,CAAC,CAAC;QAClE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,uBAAW,IAAI,SAAS,KAAK,EAAE,CAAC;IAC5E,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,kBAAkB,CAAC,WAAmB,EAAE,KAAa;QACvD,IAAI,CAAC,WAAW,IAAI,CAAC,sBAAa,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YACnD,MAAM,IAAI,KAAK,CAAC,mBAAmB,WAAW,aAAa,CAAC,CAAC;QACjE,CAAC;QACD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACpE,MAAM,IAAI,KAAK,CAAC,cAAc,KAAK,EAAE,CAAC,CAAC;QAC3C,CAAC;QACD,MAAM,SAAS,GAAG,IAAA,6BAAoB,EAAC,WAAW,CAAC,CAAC;QACpD,MAAM,OAAO,GAAG,GAAG,uBAAW,IAAI,SAAS,KAAK,CAAC;QACjD,MAAM,GAAG,GAAG,IAAA,WAAI,EAAC,WAAW,EAAE,EAAE,OAAO,CAAC,CAAC;QACzC,IAAI,CAAC,IAAA,qBAAU,EAAC,GAAG,CAAC,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CAAC,kBAAkB,OAAO,EAAE,CAAC,CAAC;QACjD,CAAC;QACD,MAAM,OAAO,GAAG,IAAA,uBAAY,EAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QAC1C,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,MAAM,OAAO,kDAAkD,CAAC,CAAC;QACrF,CAAC;QACD,IAAA,wBAAa,EAAC,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,iBAAiB,EAAE,UAAU,KAAK,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;QAClF,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,QAAQ,uBAAW,EAAE,CAAC,CAAC;QACjF,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC/C,CAAC;IACD,oBAAoB;IACpB,KAAK,CAAC,aAAa,CAAC,WAAmB;QACnC,IAAI,CAAC,WAAW,IAAI,CAAC,sBAAa,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YACnD,MAAM,IAAI,KAAK,CAAC,mBAAmB,WAAW,GAAG,CAAC,CAAC;QACvD,CAAC;QACD,MAAM,SAAS,GAAG,IAAA,6BAAoB,EAAC,WAAW,CAAC,CAAC;QACpD,MAAM,SAAS,GAAG,QAAQ,uBAAW,IAAI,SAAS,KAAK,CAAC;QAExD,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,kBAAkB,EAAE,SAAS,CAAC,CAAC;QACrF,IAAI,CAAC,IAAI,EAAE,CAAC;YACR,MAAM,IAAI,KAAK,CAAC,kBAAkB,SAAS,KAAK,CAAC,CAAC;QACtD,CAAC;QACD,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,cAAc,EAAE,SAAS,CAAC,CAAC;QACpE,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,QAAQ,uBAAW,EAAE,CAAC,CAAC;QACjF,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;IAC7C,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,eAAe,CAAC,UAAkB;QACpC,IAAI,CAAC,UAAU,IAAI,CAAC,sBAAa,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,YAAY,UAAU,GAAG,CAAC,CAAC;QAC/C,CAAC;QACD,MAAM,SAAS,GAAG,IAAA,wBAAe,EAAC,UAAU,CAAC,CAAC,GAAG,CAAC;QAClD,MAAM,IAAI,GAAG,QAAQ,EAAE,CAAC;QACxB,MAAM,KAAK,GAAG,IAAA,kBAAS,EAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC;QACvE,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC7E,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,wBAAY,IAAI,SAAS,IAAI,IAAA,wBAAe,EAAC,UAAU,CAAC,CAAC,WAAW,KAAK,CAAC,CAAC;QAChH,MAAM,OAAO,GAAG,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAC5D,OAAO;YACH,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;YACpC,YAAY,EAAE,aAAa,CAAC,IAAI,EAAE,OAAO,CAAC;SAC7C,CAAC;IACN,CAAC;IAED,mCAAmC;IACnC,KAAK,CAAC,UAAU,CAAC,OAAe;QAC5B,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,WAAW,OAAO,GAAG,CAAC,CAAC;QAC3C,CAAC;QACD,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;QAC3B,gCAAgC;QAChC,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,kBAAkB,EAAE,GAAG,CAAC,CAAC;QAC/E,IAAI,CAAC,IAAI,EAAE,CAAC;YACR,MAAM,IAAI,KAAK,CAAC,kBAAkB,OAAO,EAAE,CAAC,CAAC;QACjD,CAAC;QACD,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,YAAY,EAAE,GAAG,CAAC,CAAC;QAC5D,OAAO,EAAE,GAAG,EAAE,CAAC;IACnB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,YAAY,CAAC,UAAkB,EAAE,KAAa;QAChD,IAAI,CAAC,UAAU,IAAI,CAAC,sBAAa,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,YAAY,UAAU,aAAa,CAAC,CAAC;QACzD,CAAC;QACD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACpE,MAAM,IAAI,KAAK,CAAC,cAAc,KAAK,EAAE,CAAC,CAAC;QAC3C,CAAC;QAED,MAAM,MAAM,GAAG,IAAA,wBAAe,EAAC,UAAU,CAAC,CAAC;QAC3C,MAAM,YAAY,GAAG,QAAQ,wBAAY,IAAI,MAAM,CAAC,GAAG,EAAE,CAAC;QAE1D,+CAA+C;QAC/C,MAAM,SAAS,GAAG,GAAG,YAAY,IAAI,MAAM,CAAC,WAAW,KAAK,CAAC;QAC7D,MAAM,QAAQ,GAAG,GAAG,YAAY,IAAI,MAAM,CAAC,UAAU,KAAK,CAAC;QAC3D,MAAM,SAAS,GAAG,GAAG,YAAY,IAAI,MAAM,CAAC,UAAU,KAAK,CAAC;QAC5D,IAAI,MAAM,WAAW,CAAC,SAAS,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAI,KAAK,CAAC,SAAS,MAAM,CAAC,WAAW,mBAAmB,CAAC,CAAC;QACpE,CAAC;QACD,IAAI,MAAM,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,SAAS,MAAM,CAAC,UAAU,mBAAmB,CAAC,CAAC;QACnE,CAAC;QACD,IAAI,MAAM,WAAW,CAAC,SAAS,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAI,KAAK,CAAC,WAAW,MAAM,CAAC,UAAU,mBAAmB,CAAC,CAAC;QACrE,CAAC;QAED,MAAM,SAAS,CAAC,YAAY,CAAC,CAAC;QAE9B,mCAAmC;QACnC,MAAM,OAAO,GAAa,EAAE,CAAC;QAC7B,MAAM,gBAAgB,GAAG,KAAK,EAAE,GAAW,EAAE,OAAe,EAAE,KAAa,EAAiB,EAAE;YAC1F,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CACtC,UAAU,EAAE,cAAc,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CACjE,CAAC;YACF,IAAI,CAAC,KAAK,EAAE,CAAC;gBACT,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC;gBAC7B,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;oBACnC,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;gBAC1F,CAAC;gBACD,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,YAAY,CAAC,CAAC;gBACxE,MAAM,IAAI,KAAK,CACX,KAAK,KAAK,OAAO,GAAG,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CACjE,CAAC;YACN,CAAC;YACD,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACtB,CAAC,CAAC;QAEF,MAAM,gBAAgB,CAClB,SAAS,EAAE,IAAA,6BAAiB,EAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,UAAU,EAAE,KAAK,EAAE,mBAAmB,EAAE,CAAC,EAAE,IAAI,CAC1G,CAAC;QACF,MAAM,gBAAgB,CAAC,QAAQ,EAAE,IAAA,4BAAgB,EAAC,MAAM,CAAC,UAAU,EAAE,mBAAmB,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;QACnG,MAAM,gBAAgB,CAAC,SAAS,EAAE,IAAA,6BAAiB,EAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,CAAC;QAE7F,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,YAAY,CAAC,CAAC;QAExE,OAAO;YACH,OAAO,EAAE,MAAM,CAAC,GAAG;YACnB,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,SAAS;YACT,QAAQ;YACR,SAAS;YACT,KAAK;SACR,CAAC;IACN,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,iBAAiB,CAAC,UAAkB,EAAE,KAAa;QACrD,IAAI,CAAC,UAAU,IAAI,CAAC,sBAAa,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,YAAY,UAAU,GAAG,CAAC,CAAC;QAC/C,CAAC;QACD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACpE,MAAM,IAAI,KAAK,CAAC,cAAc,KAAK,EAAE,CAAC,CAAC;QAC3C,CAAC;QAED,MAAM,SAAS,GAAG,IAAA,wBAAe,EAAC,UAAU,CAAC,CAAC,GAAG,CAAC;QAClD,MAAM,aAAa,GAAG,IAAA,WAAI,EAAC,WAAW,EAAE,EAAE,wBAAY,EAAE,SAAS,CAAC,CAAC;QAEnE,IAAI,KAAK,GAAa,EAAE,CAAC;QACzB,IAAI,CAAC;YACD,KAAK,GAAG,IAAA,sBAAW,EAAC,aAAa,CAAC,CAAC;QACvC,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,MAAM,IAAI,KAAK,CAAC,YAAY,SAAS,EAAE,CAAC,CAAC;QAC7C,CAAC;QACD,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC;QAC9D,IAAI,CAAC,UAAU,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CAAC,YAAY,SAAS,EAAE,CAAC,CAAC;QAC7C,CAAC;QAED,MAAM,QAAQ,GAAG,IAAA,WAAI,EAAC,aAAa,EAAE,UAAU,CAAC,CAAC;QACjD,MAAM,OAAO,GAAG,IAAA,uBAAY,EAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QAChD,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,EAAE,UAAU,KAAK,EAAE,CAAC,CAAC;QACzE,IAAI,UAAU,KAAK,OAAO,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,MAAM,UAAU,eAAe,CAAC,CAAC;QACrD,CAAC;QACD,IAAA,wBAAa,EAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QAEpC,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,KAAK,CAAC,GAAG,wBAAY,IAAI,SAAS,EAAE,CAAC,CAAC,CAAC;QAEjG,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;IAC5C,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,UAAU,CAAC,UAAkB,EAAE,QAAgB,EAAE,KAAa,EAAE,WAAmB,OAAO;QAC5F,IAAI,CAAC,UAAU,IAAI,CAAC,sBAAa,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,YAAY,UAAU,GAAG,CAAC,CAAC;QAC/C,CAAC;QACD,IAAI,CAAC,QAAQ,IAAI,CAAC,sBAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC7C,MAAM,IAAI,KAAK,CAAC,YAAY,QAAQ,aAAa,CAAC,CAAC;QACvD,CAAC;QACD,IAAI,CAAC,kBAAM,CAAC,QAAQ,CAAC,KAAY,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,WAAW,KAAK,SAAS,kBAAM,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACnE,CAAC;QACD,IAAI,CAAC,IAAA,4BAAgB,EAAC,QAAQ,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,cAAc,QAAQ,SAAS,4BAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACnF,CAAC;QAED,MAAM,SAAS,GAAG,IAAA,wBAAe,EAAC,UAAU,CAAC,CAAC,GAAG,CAAC;QAClD,MAAM,SAAS,GAAG,IAAA,0BAAiB,EAAC,QAAQ,CAAC,CAAC;QAC9C,MAAM,UAAU,GAAG,IAAA,uBAAc,EAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QAExD,yCAAyC;QACzC,MAAM,IAAI,GAAG,QAAQ,EAAE,CAAC;QACxB,MAAM,KAAK,GAAG,IAAA,kBAAS,EAAC,IAAI,CAAC,CAAC,IAAI,CAC9B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,SAAS,IAAI,CAAC,CAAC,SAAS,KAAK,SAAS,CAChE,CAAC;QACF,IAAI,KAAK,EAAE,CAAC;YACR,MAAM,IAAI,KAAK,CACX,YAAY,SAAS,WAAW,KAAK,CAAC,SAAS,OAAO;gBACtD,2BAA2B,CAC9B,CAAC;QACN,CAAC;QAED,MAAM,WAAW,GAAG,QAAQ,wBAAY,IAAI,SAAS,IAAI,wBAAY,EAAE,CAAC;QACxE,MAAM,SAAS,CAAC,WAAW,CAAC,CAAC;QAE7B,MAAM,SAAS,GAAG,GAAG,WAAW,IAAI,SAAS,KAAK,CAAC;QACnD,IAAI,MAAM,WAAW,CAAC,SAAS,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAI,KAAK,CAAC,cAAc,SAAS,sBAAsB,CAAC,CAAC;QACnE,CAAC;QAED,MAAM,aAAa,GAAG,IAAA,2BAAe,EAAC,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,mBAAmB,EAAE,CAAC,CAAC;QAC3F,MAAM,WAAW,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAC5C,UAAU,EAAE,cAAc,EAAE,SAAS,EAAE,aAAa,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAC7E,CAAC;QACF,IAAI,CAAC,WAAW,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,WAAW,SAAS,EAAE,CAAC,CAAC;QAC5C,CAAC;QAED,MAAM,YAAY,GAAG,QAAQ,yBAAa,UAAU,SAAS,EAAE,CAAC;QAChE,MAAM,SAAS,GAAG,GAAG,YAAY,IAAI,SAAS,SAAS,CAAC;QACxD,MAAM,SAAS,CAAC,YAAY,CAAC,CAAC;QAE9B,IAAI,MAAM,WAAW,CAAC,SAAS,CAAC,EAAE,CAAC;YAC/B,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,cAAc,EAAE,SAAS,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YAC3F,MAAM,IAAI,KAAK,CAAC,UAAU,SAAS,+BAA+B,CAAC,CAAC;QACxE,CAAC;QAED,IAAI,CAAC;YACD,MAAM,cAAc,GAAG,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YACtD,MAAM,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,IAAA,2BAAe,EAAC,SAAS,EAAE,cAAc,EAAE,QAAQ,CAAC,CAAC,CAAC;YAC3F,MAAM,WAAW,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAC5C,UAAU,EAAE,cAAc,EAAE,SAAS,EAAE,aAAa,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAC7E,CAAC;YACF,IAAI,CAAC,WAAW,EAAE,CAAC;gBACf,MAAM,IAAI,KAAK,CAAC,YAAY,SAAS,EAAE,CAAC,CAAC;YAC7C,CAAC;QACL,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,yBAAyB;YACzB,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,cAAc,EAAE,SAAS,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YAC3F,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,WAAW,CAAC,CAAC;YACvE,MAAM,CAAC,CAAC;QACZ,CAAC;QAED,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,YAAY,CAAC,CAAC;QACxE,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,WAAW,CAAC,CAAC;QAEvE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;IACvF,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,UAAU,CAAC,UAAkB,EAAE,QAAgB;QACjD,IAAI,CAAC,UAAU,IAAI,CAAC,sBAAa,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,YAAY,UAAU,GAAG,CAAC,CAAC;QAC/C,CAAC;QACD,IAAI,CAAC,QAAQ,IAAI,CAAC,sBAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC7C,MAAM,IAAI,KAAK,CAAC,YAAY,QAAQ,GAAG,CAAC,CAAC;QAC7C,CAAC;QAED,MAAM,SAAS,GAAG,IAAA,wBAAe,EAAC,UAAU,CAAC,CAAC,GAAG,CAAC;QAClD,MAAM,SAAS,GAAG,IAAA,0BAAiB,EAAC,QAAQ,CAAC,CAAC;QAC9C,MAAM,SAAS,GAAG,QAAQ,yBAAa,UAAU,SAAS,IAAI,SAAS,SAAS,CAAC;QACjF,MAAM,SAAS,GAAG,QAAQ,wBAAY,IAAI,SAAS,IAAI,wBAAY,IAAI,SAAS,KAAK,CAAC;QAEtF,MAAM,OAAO,GAAa,EAAE,CAAC;QAC7B,KAAK,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC;YACvC,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,kBAAkB,EAAE,GAAG,CAAC,CAAC;YAC/E,IAAI,IAAI,EAAE,CAAC;gBACP,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,cAAc,EAAE,GAAG,CAAC,CAAC;gBAC9D,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACtB,CAAC;QACL,CAAC;QAED,yCAAyC;QACzC,MAAM,aAAa,CAAC,IAAA,WAAI,EAAC,WAAW,EAAE,EAAE,yBAAa,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC;QAE5E,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,QAAQ,yBAAa,UAAU,SAAS,EAAE,CAAC,CAAC;QACtG,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,KAAK,CAAC,GAAG,wBAAY,IAAI,SAAS,IAAI,wBAAY,EAAE,CAAC,CAAC,CAAC;QAEjH,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,YAAY,CAAC,UAAkB;QACjC,IAAI,CAAC,UAAU,IAAI,CAAC,sBAAa,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,YAAY,UAAU,GAAG,CAAC,CAAC;QAC/C,CAAC;QACD,MAAM,SAAS,GAAG,IAAA,wBAAe,EAAC,UAAU,CAAC,CAAC,GAAG,CAAC;QAElD,MAAM,aAAa,GAAG,IAAA,WAAI,EAAC,WAAW,EAAE,EAAE,wBAAY,EAAE,SAAS,CAAC,CAAC;QACnE,MAAM,aAAa,GAAG,IAAA,WAAI,EAAC,WAAW,EAAE,EAAE,yBAAa,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;QAE7E,MAAM,OAAO,GAAa,EAAE,CAAC;QAC7B,KAAK,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,aAAa,CAAC,EAAE,CAAC;YAC7C,IAAI,CAAC;gBACD,IAAI,IAAA,mBAAQ,EAAC,CAAC,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC;oBAC5B,IAAA,qBAAU,EAAC,CAAC,CAAC,CAAC;oBACd,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBACpB,CAAC;YACL,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACT,YAAY;YAChB,CAAC;QACL,CAAC;QAED,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,QAAQ,yBAAa,QAAQ,CAAC,CAAC;QACzF,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,KAAK,CAAC,wBAAY,CAAC,CAAC,CAAC;QAE/E,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;IAClC,CAAC;IAED,wEAAwE;IAExE;;;OAGG;IACH,KAAK,CAAC,kBAAkB,CAAC,KAAe;QACpC,OAAO,MAAM,gBAAgB,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC;IAClD,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,mBAAmB,CAAC,MAAc;QACpC,gDAAgD;QAChD,4DAA4D;QAC5D,uCAAuC;QACvC,MAAM,CAAC,GAAG,MAAM,eAAe,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACnD,MAAM,IAAI,GAAG,MAAM,oBAAoB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;QACxD,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAClB,OAAO,CAAC,GAAG,CAAC,oBAAoB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC;QAC9E,CAAC;QACD,OAAO,CAAC,CAAC;IACb,CAAC;IAED,oCAAoC;IACpC,KAAK,CAAC,qBAAqB,CAAC,MAAc;QACtC,OAAO,eAAe,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;IAChD,CAAC;CACJ,CAAC;AAEF;;;GAGG;AACH,SAAgB,IAAI,KAAK,CAAC;AAE1B;;;GAGG;AACH,SAAgB,MAAM,KAAK,CAAC","sourcesContent":["// @ts-ignore\r\nimport packageJSON from '../package.json';\r\nimport { spawn, spawnSync } from 'child_process';\r\nimport { copySync, existsSync, readdirSync, readFileSync, removeSync, statSync, writeFileSync } from 'fs-extra';\r\nimport { join } from 'path';\r\nimport {\r\n    GAMEPLAY_DIR,\r\n    LAYERS,\r\n    MANAGER_DIR,\r\n    PREFAB_TEMPLATES,\r\n    PREFAB_TEMPLATE_LABELS,\r\n    REGISTRY_CACHE_MS,\r\n    RESOURCES_DIR,\r\n    TPrefabTemplate,\r\n    VIEWS_SUBDIR,\r\n} from './constants';\r\nimport { buildOrderPlan, listManagers, listModules, listViews, runDoctor } from './doctor';\r\nimport {\r\n    IDENTIFIER_RE,\r\n    normalizeManagerName,\r\n    normalizeModule,\r\n    normalizeViewName,\r\n    viewPrefabPath,\r\n} from './naming';\r\nimport {\r\n    collectSnapshot,\r\n    findDevWorkspaceSharedPackagesDir,\r\n    listLocalCatalog,\r\n    readInstalledPackage,\r\n    readProjectManifest,\r\n} from './project';\r\nimport {\r\n    isSharedModulePackage,\r\n    KNOWN_PACKAGES,\r\n    parseViewResult,\r\n    viewArgv,\r\n} from './registry';\r\nimport {\r\n    NPM_TIMEOUT_MS,\r\n    buildNpmResult,\r\n    buildSharedStatus,\r\n    catalogEntryFromInstalled,\r\n    collectInstallSpecs,\r\n    decodeProcessOutput,\r\n    findPackageRefs,\r\n    formatNpmCommand,\r\n    isSharedModuleManifest,\r\n    mergeCatalog,\r\n    npmSpawnSpec,\r\n    spawnSpecFor,\r\n    summarizeNpmFailure,\r\n} from './shared';\r\nimport {\r\n    buildRedDotPrefab,\n    buildManagerScript,\r\n    buildEventsScript,\r\n    buildModelScript,\r\n    buildModuleScript,\r\n    buildViewPrefab,\r\n    buildViewScript,\r\n    isPrefabTemplate,\r\n    TFrameworkImport,} from './templates';\r\nimport { IFinding, INpmRunResult, IInstalledPackageView, IProjectSnapshot, ISharedCatalogEntry } from './types';\r\n\r\n/* ------------------------------- 文案 ------------------------------- */\r\n\r\n/**\r\n * 扩展自带的中文文案表。\r\n * 它既是「key 全集」的来源，也是编辑器 i18n 拿不到时的兜底。\r\n */\r\n// eslint-disable-next-line @typescript-eslint/no-var-requires\r\nconst ZH_STRINGS: Record<string, string> = require('../i18n/zh.js');\r\n\r\n/* ------------------------------- 小工具 ------------------------------- */\r\n\r\n/** 工程根目录 */\r\nfunction projectPath(): string {\r\n    return Editor.Project.path;\r\n}\r\n\r\n/**\r\n * 这个工程引用框架该用哪种写法:\r\n * - 开发工作区(仓库里,框架源码在 assets/scripts/framework 下) -> 相对路径\r\n * - 装成 npm 包的新工程 -> 包名 @ccgf/framework\r\n *\r\n * 判据是\"框架源码在不在\",与 constants.ts 的 FRAMEWORK_DEV_DIR 同一个值。\r\n */\r\nfunction frameworkImportMode(): TFrameworkImport {\r\n    return existsSync(join(projectPath(), 'assets/scripts/framework')) ? 'workspace' : 'package';\r\n}\r\n\r\n/** 相对路径 -> db:// 资源 url */\r\nfunction dbUrl(rel: string): string {\r\n    return 'db://' + rel.replace(/\\\\/g, '/');\r\n}\r\n\r\n/** uuid -> 预制体里脚本组件的 __type__ */\r\nfunction compressUuid(uuid: string): string {\r\n    return Editor.Utils.UUID.compressUUID(uuid, false);\r\n}\r\n\r\n/** 取一份工程快照（体检、列表都基于它，保证面板看到的和体检看到的是同一份数据） */\r\n/** 读 assets/scripts/shared/** 下的 .ts 原文(体检要扫它们:那里面按包名引 = 第二份) */\nfunction readSharedSources(): Record<string, string> {\n    const out: Record<string, string> = {};\n    const base = join(projectPath(), 'assets', 'scripts', 'shared');\n    const walk = (abs: string, rel: string) => {\n        let entries: any[];\n        try { entries = readdirSync(abs, { withFileTypes: true }); } catch { return; }\n        for (const e of entries) {\n            const a = join(abs, e.name); const r = rel ? rel + '/' + e.name : e.name;\n            if (e.isDirectory()) walk(a, r);\n            else if (e.isFile() && e.name.endsWith('.ts')) {\n                try { out['assets/scripts/shared/' + r] = readFileSync(a, 'utf8'); } catch { /* 读不到就跳过 */ }\n            }\n        }\n    };\n    walk(base, '');\n    return out;\n}\n\nfunction snapshot(): IProjectSnapshot {\r\n    const s = collectSnapshot(projectPath(), compressUuid);\r\n    // 只在\"框架包被装进工程 node_modules\"这件事上补一个事实:\r\n    // 是不是\"两份框架\"要由 doctor 结合\"assets 下有没有框架源码\"一起判。\r\n    return {\r\n        ...s,\r\n        frameworkInNodeModules: existsSync(join(projectPath(), 'node_modules', '@ccgf', 'framework')),\n        sharedSources: readSharedSources(),\r\n    };\r\n}\r\n\r\n/* ------------------------------ 公共模块 ------------------------------ */\r\n\r\n/**\r\n * registry 搜索结果的缓存。\r\n *\r\n * 一次搜索实测 1~4 秒 —— 而面板切页、装完刷新都会调用查询，不能每次都去搜。\r\n * 显式点「刷新」时用 `force` 绕过它。\r\n */\r\nlet registryCache: { at: number; entries: ISharedCatalogEntry[]; error: string | null } | null = null;\r\n\r\n/**\r\n * **失败不抛异常,也不让面板空着装作\"没有模块\"**:把原因一起回传,面板显示成提示 ——\r\n * 这是最初就定下的要求(\"没有网络就提示就行了\")。\r\n *\r\n * 远程信息的来源:**逐个 `npm view <name> --json` 精确查询**。\r\n *\r\n * 曾经用 `npm search` + 关键词,已废弃 —— 搜索对 scoped 包(`@ccgf/*`)很不可靠,\r\n * 常常搜不到,于是\"公共模块远程列表\"和\"最新版本\"都会是空的(实测踩过)。\r\n * 代价:包名要维护在 registry.ts 的 KNOWN_PACKAGES 里,新增包时加一行。\r\n *\r\n * 之所以用 npm 命令而不是自己发 HTTPS 请求:npm 会自动带上工程的 `.npmrc`\r\n * (私有源、镜像、代理等配置都跟着走),不用我们重复实现一遍。\r\n */\r\n/**\r\n * **异步**跑一次 npm。\r\n *\r\n * 为什么不能继续用 spawnSync:这个函数在**编辑器主进程**里被调用,spawnSync 会把主循环\r\n * 整个占住 —— 每查一个包几百毫秒,几个包下来编辑器 UI 就卡住、点别处没反应(实测)。\r\n * 换成 spawn + Promise:同样等结果,但中间让出事件循环,编辑器不冻结。\r\n */\r\n/**\r\n * 查远程信息用的**短**超时。\r\n *\r\n * 不能用 NPM_TIMEOUT_MS(120 秒):那是给\"安装\"用的,用户可以等;\r\n * 而\"查一下最新版本\"要是等两分钟,那一页就等于废了。\r\n */\r\nconst REGISTRY_QUERY_TIMEOUT_MS = 25000;\r\n\r\n/** 同一时刻只允许一个后台刷新在跑,否则每次切页签都会再起一轮 npm */\r\nlet registryRefreshing = false;\r\n\r\nfunction runNpmAsync(\r\n    command: string,\r\n    spawnSpec: { command: string; args: string[]; windowsVerbatimArguments?: boolean },\r\n    cwd: string,\r\n    timeoutMs: number = NPM_TIMEOUT_MS,\r\n): Promise<{ result: INpmRunResult; stdout: string }> {\r\n    return new Promise((resolve) => {\r\n        const chunks: Buffer[] = [];\r\n        const errChunks: Buffer[] = [];\r\n        let child: any;\r\n        const finish = (exitCode: number | null, spawnError: { code?: string; message: string } | null) => {\r\n            const stdout = decodeProcessOutput(Buffer.concat(chunks));\r\n            resolve({\r\n                result: buildNpmResult({\r\n                    command,\r\n                    exitCode,\r\n                    stdout,\r\n                    stderr: decodeProcessOutput(Buffer.concat(errChunks)),\r\n                    spawnError,\r\n                }),\r\n                stdout,\r\n            });\r\n        };\r\n        try {\r\n            child = spawn(spawnSpec.command, spawnSpec.args, {\r\n                cwd,\r\n                windowsHide: true,\r\n                windowsVerbatimArguments: spawnSpec.windowsVerbatimArguments,\r\n            });\r\n        } catch (err: any) {\r\n            finish(null, { message: err?.message ? String(err.message) : String(err) });\r\n            return;\r\n        }\r\n        const timer = setTimeout(() => { try { child.kill(); } catch { /* 已经退了 */ } }, timeoutMs);\r\n        child.stdout?.on('data', (d: Buffer) => chunks.push(d));\r\n        child.stderr?.on('data', (d: Buffer) => errChunks.push(d));\r\n        child.on('error', (err: any) => {\r\n            clearTimeout(timer);\r\n            finish(null, { code: err?.code, message: err?.message ? String(err.message) : String(err) });\r\n        });\r\n        child.on('close', (code: number | null) => {\r\n            clearTimeout(timer);\r\n            if (timer === null) return;\r\n            finish(code, null);\r\n        });\r\n    });\r\n}\r\n/**\r\n * 远程信息(带缓存)。**这个函数永远不阻塞、永远不 await 外部进程**。\r\n *\r\n * 为什么这么设计:它跑在编辑器主进程里,而 npm 每个进程要 1~3 秒,网络坏了还可能一直不返回。\r\n * 早先用同步 spawn + 逐个查,表现就是\"点开这一页,编辑器别处也没反应\"。\r\n * 现在:命中缓存立刻返回;过期则**先返回旧值**,同时后台刷新(不 await);\r\n * 从没成功过时返回明确的提示文案,而不是让调用方干等。\r\n *\r\n * 失败不抛异常,也不让面板空着装作\"没有模块\":把原因一起回传,面板显示成提示 ——\r\n * 这是最初就定下的要求(\"没有网络就提示就行了\")。\r\n */\r\nfunction queryRegistry(force: boolean): { entries: ISharedCatalogEntry[]; error: string | null } {\r\n    const now = Date.now();\r\n    const fresh = registryCache && now - registryCache.at < REGISTRY_CACHE_MS;\r\n\r\n    if (!force && fresh) {\r\n        return { entries: registryCache!.entries, error: registryCache!.error };\r\n    }\r\n\r\n    // 需要更新:后台去刷,不在这里等\r\n    void refreshRegistry();\r\n\r\n    if (registryCache) {\r\n        return { entries: registryCache.entries, error: registryCache.error };\r\n    }\r\n    return {\r\n        entries: [],\r\n        error: registryRefreshing ? '正在获取远程信息…' : '远程信息暂不可用(离线或超时)',\r\n    };\r\n}\r\n\r\n/** 真正的拉取:异步、有并发闸、单包失败不拖垮整份列表 */\r\nasync function refreshRegistry(): Promise<void> {\r\n    if (registryRefreshing) return;\r\n    registryRefreshing = true;\r\n    try {\r\n        const entries: ISharedCatalogEntry[] = [];\r\n        const failures: string[] = [];\r\n\r\n        for (const name of KNOWN_PACKAGES) {\r\n            const command = 'npm view ' + name + ' --json';\r\n            const spawnSpec = spawnSpecFor(\r\n                [process.platform === 'win32' ? 'npm.cmd' : 'npm', ...viewArgv(name)],\r\n            );\r\n            const { result, stdout } = await runNpmAsync(command, spawnSpec, projectPath(), REGISTRY_QUERY_TIMEOUT_MS);\r\n            if (!result.ok) {\r\n                failures.push(name + ':' + (result.hint ?? ('超时或退出码 ' + (result.exitCode ?? '未知'))));\r\n                continue;\r\n            }\r\n            const entry = parseViewResult(stdout);\r\n            if (entry) entries.push(entry);\r\n            else failures.push(name + ':返回内容不是预期的 JSON 形状');\r\n        }\r\n\r\n        // **部分**失败也要报出来:早先只在\"全部失败\"时才回传,\r\n        // 结果\"3 个查到 + 1 个超时\"完全静默 —— 面板显示\"无法确认\"却不给任何原因。\r\n        const error = failures.length > 0 ? ('部分远程信息获取失败:' + failures.join(';')) : null;\r\n        registryCache = { at: Date.now(), entries, error };\r\n    } finally {\r\n        registryRefreshing = false;\r\n    }\r\n}\r\n\r\n/**\r\n * 组装公共模块的完整状态。\r\n *\r\n * 三个来源合起来才是完整列表：\r\n * 1. 本框架**开发工作区**里的 `packages/shared/*`（只有本仓库才认，见\r\n *    `findDevWorkspaceSharedPackagesDir`）—— 能给出 `file:` 安装说明符；\r\n * 2. `node_modules` 里已经装了的（靠包清单里的标记认出来）；\r\n * 3. **远程 registry**（按发现关键词搜索）—— 覆盖\"还没装、但可以装\"的那些。\r\n *\r\n * 刻意**不**靠包名匹配来识别公共模块：scope 还没定（见 ROADMAP 的 S1a），\r\n * 换个 scope 就认不出来了。\r\n */\r\nasync function querySharedState(forceRegistry = false) {\r\n    const root = projectPath();\r\n    const manifest = readProjectManifest(root);\r\n    const projectDependencies: Record<string, string> = {\r\n        ...(manifest?.dependencies ?? {}),\r\n        ...(manifest?.devDependencies ?? {}),\r\n    };\r\n\r\n    const sharedDir = findDevWorkspaceSharedPackagesDir(root);\r\n    const local = sharedDir ? listLocalCatalog(sharedDir, root) : [];\r\n\r\n    const installedShared: ISharedCatalogEntry[] = [];\r\n    for (const name of Object.keys(projectDependencies)) {\r\n        const pkg = readInstalledPackage(root, name);\r\n        if (pkg.installed && isSharedModuleManifest(pkg.manifest)) {\r\n            installedShared.push(catalogEntryFromInstalled(name, pkg.manifest, pkg.version));\r\n        }\r\n    }\r\n\r\n    const registry = await queryRegistry(forceRegistry);\r\n    // 框架与扩展不是公共模块,虽然它们也装着、也在 KNOWN_PACKAGES 里 —— 两处都要滤掉,\r\n    // 否则使用者的\"公共模块\"列表里会冒出框架和编辑器扩展。\r\n    const sharedOnly = (e: ISharedCatalogEntry) => isSharedModulePackage(e.name);\r\n    const catalog = mergeCatalog(\r\n        mergeCatalog(local, registry.entries.filter(sharedOnly)),\r\n        installedShared.filter(sharedOnly),\r\n    );\r\n\r\n    // \"可更新\"要靠远程的最新版本号，而 mergeCatalog 让本地项优先（同名的远程项会被盖掉），\r\n    // 所以这里单独留一份包名 -> 远程最新版本。\r\n    const registryVersions: Record<string, string> = {};\r\n    for (const entry of registry.entries) {\r\n        registryVersions[entry.name] = entry.version;\r\n    }\r\n\r\n    // 要查实时状态的包 = 列表里的 + 它们声明的依赖。\r\n    // 依赖可能不在列表里（普通 npm 包），但它装没装同样要显示出来。\r\n    const wanted = new Set<string>();\r\n    for (const entry of catalog) {\r\n        wanted.add(entry.name);\r\n        for (const dep of Object.keys(entry.declaredDependencies)) {\r\n            wanted.add(dep);\r\n        }\r\n    }\r\n    const installedPackages: Record<string, IInstalledPackageView> = {};\r\n    for (const name of wanted) {\r\n        const pkg = readInstalledPackage(root, name);\r\n        installedPackages[name] = {\r\n            installed: pkg.installed,\r\n            version: pkg.version,\r\n            isSharedModule: isSharedModuleManifest(pkg.manifest),\r\n        };\r\n    }\r\n\r\n    const snap = snapshot();\r\n    const sources = { ...snap.gameplaySources, ...snap.managerSources };\r\n\r\n    const modules = catalog.map((entry) => buildSharedStatus(entry, {\r\n        projectDependencies,\r\n        installedPackages,\r\n        references: { [entry.name]: findPackageRefs(sources, entry.name) },\r\n        catalog,\r\n        registryVersions,\r\n    }));\r\n\r\n    return {\r\n        modules,\r\n        /** 本地安装源；**只有本框架的开发仓库里才非 null**（面向用户的工程里永远是 null） */\r\n        localSource: sharedDir,\r\n        /** 工程有可读的 package.json 吗 */\r\n        hasManifest: manifest !== null,\r\n        /** 远程列表拉取失败的原因；为 null 表示这次是成功的（或用了缓存） */\r\n        registryError: registry.error,\r\n    };\r\n}\r\n\r\n/**\r\n * 跑一次 npm。\r\n *\r\n * 全程**不抛异常**：退出码、stdout、stderr、以及 spawn 自身的失败都收进 INpmRunResult\r\n * 回传给面板 —— 用户要看的是 npm 自己说的话，而不是一句转述的\"安装失败\"。\r\n */\r\nfunction runNpm(action: 'install' | 'uninstall', specs: string[]): INpmRunResult {\r\n    const spawnSpec = npmSpawnSpec(action, specs);\r\n    try {\r\n        // 1. **不指定 encoding**：拿到原始 Buffer 自己解码，否则 cmd 的 GBK 消息会变乱码；\r\n        // 2. **windowsVerbatimArguments 必须来自 spawnSpec**：少了它，Node 会把我加好的\r\n        //    引号再转义一遍，cmd 收到 `\\\"npm.cmd install ...\\\"`，于是整行被当成命令名\r\n        //    （报\"'npm.cmd install ...' 不是内部或外部命令\"，npm 根本没被启动）。\r\n        const spawned = spawnSync(spawnSpec.command, spawnSpec.args, {\r\n            cwd: projectPath(),\r\n            timeout: NPM_TIMEOUT_MS,\r\n            windowsHide: true,\r\n            maxBuffer: 16 * 1024 * 1024,\r\n            windowsVerbatimArguments: spawnSpec.windowsVerbatimArguments,\r\n        });\r\n        return buildNpmResult({\r\n            command: formatNpmCommand(action, specs),\r\n            exitCode: typeof spawned.status === 'number' ? spawned.status : null,\r\n            stdout: decodeProcessOutput(spawned.stdout),\r\n            stderr: decodeProcessOutput(spawned.stderr),\r\n            spawnError: spawned.error\r\n                ? {\r\n                    code: (spawned.error as NodeJS.ErrnoException).code,\r\n                    message: spawned.error.message,\r\n                }\r\n                : null,\r\n        });\r\n    } catch (err: any) {\r\n        return buildNpmResult({\r\n            command: formatNpmCommand(action, specs),\r\n            exitCode: null,\r\n            stdout: '',\r\n            stderr: '',\r\n            spawnError: { message: err?.message ? String(err.message) : String(err) },\r\n        });\r\n    }\r\n}\r\n\r\n/**\r\n * 代跑 npm 装 / 卸一个公共模块，然后回一份刷新过的状态。\r\n *\r\n * 只接受 catalog 里存在的包名 —— 不把扩展变成\"任意 npm 命令执行器\"。\r\n */\r\n/**\r\n * 装一个**不属于公共模块**的包(框架、编辑器扩展自己)。\r\n *\r\n * 为什么不复用 runSharedAction:那条路的语义是\"从公共模块列表里装一个\",\r\n * 会先在 catalog 里查名字 —— 而框架与扩展**本来就被排除在公共模块列表之外**\r\n * (它们不该出现在使用者的公共模块页里),于是必然报\"不在可安装列表里的包\"。\r\n * 两件事的合法包集合不同,就不该共用一个入口。\r\n */\r\nasync function installProjectPackage(spec: string): Promise<{ ok: boolean; message: string | null; version: string | null }> {\r\n    if (!spec || typeof spec !== 'string') throw new Error('缺少包名');\r\n    const root = projectPath();\r\n    const command = 'npm install ' + spec;\r\n    const spawnSpec = npmSpawnSpec('install', [spec]);\r\n    const { result } = await runNpmAsync(command, spawnSpec, root, NPM_TIMEOUT_MS);\r\n    return {\r\n        ok: result.ok,\r\n        message: result.ok ? null : (result.hint ?? ('npm 退出码 ' + (result.exitCode ?? '未知'))),\r\n        version: null,\r\n    };\r\n}\r\n\r\nasync function runSharedAction(action: 'install' | 'uninstall', packageName: string | string[]) {\r\n    // 面板可能传字符串,也可能不小心包成数组 —— 两种都收,\r\n    // 别让\"少一个括号\"变成用户看到的\"缺少包名\"。\r\n    const wanted = Array.isArray(packageName) ? (packageName as any)[0] : packageName;\r\n    if (!wanted || typeof wanted !== 'string') {\r\n        throw new Error('缺少包名');\r\n    }\r\n\r\n    const before = await querySharedState();\r\n    const entry = before.modules.find((m) => m.name === wanted);\r\n    if (!entry) {\r\n        const known = before.modules.map((m) => m.name);\r\n        throw new Error(\r\n            `不在可安装列表里的包：${wanted}`\r\n            + (known.length ? `（当前列表：${known.join(', ')}）` : '（当前列表为空）'),\r\n        );\r\n    }\r\n\r\n    // 安装要把**本地能解析到的依赖一起带上**：只装它一个的话，npm 会去 registry 找依赖，\r\n    // 而本地源里的依赖并没有发布 —— 必然 E404（实测过）。\r\n    // 卸载按**包名**（npm 认包名，不认 file: 说明符）。\r\n    const specs = action === 'uninstall'\r\n        ? [entry.name]\r\n        : collectInstallSpecs(entry, before.modules);\r\n    const result = runNpm(action, specs);\r\n\r\n    // 装完立刻回一份新状态,面板不用再跑一次查询(注意 await!)\r\n    const after = await querySharedState();\r\n\r\n    return {\r\n        /**\r\n         * 失败**不抛异常**：面板需要拿到结构化的结果（命令、退出码、原始输出），\r\n         * 才能在弹窗里原样展示 npm 自己说的话。非法输入仍然抛 —— 那是调用方写错了。\r\n         */\r\n        ok: result.ok,\r\n        result,\r\n        /**\r\n         * 失败时一句**单行**摘要（面板消息区用）。完整输出在 `result` 里，由弹窗展示 ——\r\n         * 之前把整段 npm 输出塞进消息区，会把右栏挤变形并和消息叠在一起。\r\n         */\r\n        message: result.ok ? null : summarizeNpmFailure(action, wanted, result),\r\n        // ⚠️ querySharedState() 是 async —— 必须**先 await 再展开**。\r\n        //    写成 ...querySharedState() 展开的是 Promise(也就是 {}),返回对象里没有 modules,\r\n        //    面板 applySharedState 拿到 undefined -> **模块列表被清空**;而 ok/message 是字面量,\r\n        //    所以成功提示照常显示,看起来像\"装成功了但列表没了\",刷新一次才恢复(实测症状)。\r\n        ...after,\r\n    };\r\n}\r\n\r\n/** 资源是否存在 */\r\nfunction assetExists(url: string): Promise<boolean> {\r\n    return Editor.Message.request('asset-db', 'query-asset-info', url).then((info: unknown) => !!info);\r\n}\r\n\r\n/**\r\n * 确保目录存在，不存在则创建\r\n */\r\nasync function ensureDir(dirUrl: string): Promise<void> {\r\n    const info = await Editor.Message.request('asset-db', 'query-asset-info', dirUrl);\r\n    if (!info) {\r\n        await Editor.Message.request('asset-db', 'create-asset', dirUrl, null);\r\n    }\r\n}\r\n\r\n/** 目录不存在则建，空目录则删掉（生成/删除后清理用） */\r\nasync function pruneEmptyDir(absDir: string): Promise<void> {\r\n    try {\r\n        if (statSync(absDir).isDirectory() && readdirSync(absDir).length === 0) {\r\n            removeSync(absDir);\r\n        }\r\n    } catch (e) {\r\n        /* 不存在就算了 */\r\n    }\r\n}\r\n\r\n/** 找出引用了指定 cid 集合的已序列化资源 */\r\nfunction findAssetRefs(snap: IProjectSnapshot, cids: string[]): string[] {\r\n    const hits: string[] = [];\r\n    if (!cids.length) {\r\n        return hits;\r\n    }\r\n    for (const rel of Object.keys(snap.serialized)) {\r\n        const text = snap.serialized[rel];\r\n        if (cids.some((cid) => text.includes(cid))) {\r\n            hits.push(rel);\r\n        }\r\n    }\r\n    return hits;\r\n}\r\n\r\n/* -------------------------------- 方法 -------------------------------- */\r\n\r\n/**\r\n * 把 node_modules 里的扩展拷进 extensions/。\r\n *\r\n * ⚠️ 必须是**模块级函数**,不能是 methods 里的方法:编辑器派发消息时不保证以 methods\r\n *    对象为 this,所以方法内部写 this.syncExtension(...) 会报 \"is not a function\"(实测就是这个 bug)。\r\n */\r\nfunction syncExtension(name: string) {\r\n    const root = projectPath();\r\n    const from = join(root, \"node_modules\", name);\r\n    if (!existsSync(from)) {\r\n        return { ok: false, message: \"node_modules 里没有 \" + name + \",先安装再落盘\" };\r\n    }\r\n    const to = join(root, \"extensions\", name.split(\"/\").pop() as string);\r\n    removeSync(to);\r\n    copySync(from, to);\r\n    // 回报**实际拷过去的版本**:这样面板能说\"已更新到 x.y.z\"而不是拿 latest 猜。\r\n    let version: string | null = null;\r\n    try {\r\n        version = JSON.parse(readFileSync(join(to, 'package.json'), 'utf8')).version ?? null;\r\n    } catch { /* 读不到就算了,不编一个 */ }\r\n    return { ok: true, path: to, version };\r\n}\r\n\r\n/**\n * 某些公共模块需要往工程里放一点资源(@ccgf/red-dot 的默认红点样式就是)。\n *\n * 为什么由扩展生成、而不是随模板发:模板属于\"每个新工程都有\"的东西,\n * 而公共模块是**可选安装**的 —— 给一个根本没装红点的工程带一个红点预制体才叫怪异。\n *\n * ⚠️ 刻意写成**模块级函数**而不是 methods 里的方法:它不是编辑器消息,\n *    放进 methods 会被\"没有注册的方法\"那条契约测试拦下来(而且那个测试是对的)。\n */\nasync function ensureScaffoldAssets(pkgName: string): Promise<string[]> {\n    const made: string[] = [];\n    // 目前只有红点需要;以后别的模块要带资源,在这里加一条\n    if (pkgName !== '@ccgf/red-dot') return made;\n\n    const dirUrl = `db://${RESOURCES_DIR}/reddot`;\n    const url = `${dirUrl}/default.prefab`;\n    if (await assetExists(url)) {\n        return made;   // 已经有了就不覆盖(用户可能自己调过样式)\n    }\n    await ensureDir(dirUrl);\n    const content = JSON.stringify(buildRedDotPrefab('default'));\n    const asset = await Editor.Message.request('asset-db', 'create-asset', url, content, { overwrite: false });\n    if (!asset) {\n        console.warn(`[ccgf] 生成默认红点样式失败:${url}`);\n        return made;\n    }\n    await Editor.Message.request('asset-db', 'refresh-asset', dirUrl);\n    made.push(`${RESOURCES_DIR}/reddot/default.prefab`);\n    return made;\n}\n\nexport const methods: { [key: string]: (...any: any) => any } = {\r\n    /** 更新框架:直接按 spec 装,不进公共模块列表 */\r\n    async updateFrameworkPackage() {\r\n        return installProjectPackage('@ccgf/framework@latest');\r\n    },\r\n\r\n    /** 更新扩展:装到 node_modules 后**必须**落到 extensions/ —— 编辑器只认那里 */\r\n    async updateExtensionPackage() {\r\n        const r = await installProjectPackage('ccgf-game-tool@latest');\r\n        if (!r.ok) return r;\r\n        const s = syncExtension('ccgf-game-tool');\r\n        return { ok: s.ok !== false, message: s.message ?? null, version: s.version ?? null };\r\n    },\r\n\r\n    /**\r\n     * 框架与扩展各自的版本信息(本地 + npm 最新)。\r\n     *\r\n     * 扩展自身版本读它自己的 package.json;框架版本读工程 node_modules 里的那份 ——\r\n     * 两者都是\"实际装了什么\"的事实,不是配置里写了什么。\r\n     * 有没有新版交给面板比较 version 与 latest,这里不替它判断(免得两边各写一套)。\r\n     */\r\n    /**\r\n     * 把 node_modules 里的扩展拷进 extensions/。\r\n     *\r\n     * 编辑器**只从工程的 extensions/ 加载扩展**,所以 npm install 完必须落这一盘,\r\n     * 否则\"更新成功\"只发生在 node_modules 里,编辑器里一点变化都没有。\r\n     * 落盘之后需要重启编辑器才生效 —— 这一点由面板文案告知,这里不假装热更新。\r\n     */\r\n    syncExtension,\r\n\r\n    async queryVersions(forceRegistry = false) {\r\n        const root = projectPath();\r\n        const registry = await queryRegistry(forceRegistry);\r\n        const latestOf = (name: string): string | null => {\r\n            const hit = registry.entries.find((entry) => entry.name === name);\r\n            return hit ? hit.version : null;\r\n        };\r\n\r\n        const frameworkName = '@ccgf/framework';\r\n        const framework = readInstalledPackage(root, frameworkName);\r\n\r\n        /** 本仓库的开发工作区:框架是源码、扩展就是这一份 —— 面板据此改称呼并禁用更新 */\r\n        const inWorkspace = existsSync(join(root, 'assets/scripts/framework'));\r\n\r\n        return {\r\n            framework: {\r\n                name: frameworkName,\r\n                installed: framework.installed,\r\n                workspace: inWorkspace,\r\n                version: framework.version,\r\n                latest: latestOf(frameworkName),\r\n            },\r\n            extension: {\r\n                name: packageJSON.name,\r\n                version: packageJSON.version,\r\n                workspace: inWorkspace,\r\n                latest: latestOf(packageJSON.name),\r\n            },\r\n        };\r\n    },\r\n    openWorkbench() {\r\n        Editor.Panel.open(`${packageJSON.name}.workbench`);\r\n    },\r\n\r\n    /** 面板的层级下拉由主进程下发，避免扩展里出现第二份层级列表 */\r\n    queryLayers(): string[] {\r\n        return [...LAYERS];\r\n    },\r\n\r\n    /**\r\n     * 面板文案：以 i18n/zh.js 的 key 全集为准，逐个交给编辑器 i18n 解析当前语言。\r\n     * 这样面板侧不需要判断语言，也不依赖 Editor.I18n 是否存在于面板上下文里。\r\n     */\r\n    queryI18n(): Record<string, string> {\r\n        const table: Record<string, string> = {};\r\n        for (const key of Object.keys(ZH_STRINGS)) {\r\n            const full = `${packageJSON.name}.${key}`;\r\n            let text = ZH_STRINGS[key];\r\n            try {\r\n                const hit = Editor.I18n.t(full);\r\n                if (hit && hit !== full) {\r\n                    text = hit;\r\n                }\r\n            } catch (e) {\r\n                /* 编辑器 i18n 不可用就保留中文 */\r\n            }\r\n            table[key] = text;\r\n        }\r\n        return table;\r\n    },\r\n\r\n    /** 预制体模板列表（供面板下拉） */\r\n    queryTemplates(): Array<{ id: string; label: string }> {\r\n        return PREFAB_TEMPLATES.map((id) => ({ id, label: PREFAB_TEMPLATE_LABELS[id] }));\r\n    },\r\n\r\n    /**\r\n     * 查询 gameplay 下已有的模块列表（含 order）。\r\n     * 与体检共用 doctor.listModules，保证面板显示和体检判定一致。\r\n     */\r\n    async queryModules() {\r\n        const snap = snapshot();\r\n        return listModules(snap).map((m) => ({\r\n            name: m.dir,\r\n            order: m.order ?? 0,\r\n            hasModel: m.modelFile !== null,\r\n            hasModule: true,\r\n            // 面板用这三个路径做「一键打开脚本」；eventsFile 可能为 null（老模块）\r\n            moduleFile: m.moduleFile,\r\n            modelFile: m.modelFile,\r\n            eventsFile: m.eventsFile,\r\n        }));\r\n    },\r\n\r\n    /** 启动顺序预览 + 层级占用（开发辅助） */\r\n    async queryOverview() {\r\n        const snap = snapshot();\r\n        const views = listViews(snap);\r\n        const usage = LAYERS.map((layer) => ({\r\n            layer,\r\n            views: views.filter((v) => v.registeredLayer === layer).map((v) => v.className),\r\n        }));\r\n        const modules = listModules(snap);\r\n        return {\r\n            order: buildOrderPlan(snap),\r\n            layers: usage,\r\n            moduleCount: modules.length,\r\n            managerCount: listManagers(snap).length,\r\n            viewCount: views.length,\r\n        };\r\n    },\r\n\r\n    /** 一键体检 */\r\n    async runDoctor(): Promise<{ findings: IFinding[]; summary: Record<string, number> }> {\r\n        const findings = runDoctor(snapshot(), LAYERS);\r\n        const summary = { error: 0, warn: 0, info: 0 };\r\n        for (const f of findings) {\r\n            summary[f.severity] = (summary[f.severity] ?? 0) + 1;\r\n        }\r\n        return { findings, summary };\r\n    },\r\n\r\n    /**\r\n     * 查询某模块的 View 列表。\r\n     * 比旧实现多了 prefabExists —— 旧版按约定拼 URL 却从不查盘，\r\n     * 于是“脚本在、预制体丢了”的 View 也会被列出来，点了才失败。\r\n     */\r\n    async queryViews(moduleName: string) {\r\n        if (!moduleName || !IDENTIFIER_RE.test(moduleName)) {\r\n            throw new Error(`非法的模块名: \"${moduleName}\"`);\r\n        }\r\n        const moduleDir = normalizeModule(moduleName).dir;\r\n        const snap = snapshot();\r\n        return listViews(snap)\r\n            .filter((v) => v.moduleDir === moduleDir)\r\n            .map((v) => ({\r\n                name: v.className,\r\n                scriptUrl: dbUrl(v.scriptFile),\r\n                prefabUrl: v.registeredPath ? dbUrl(`${RESOURCES_DIR}/${v.registeredPath}.prefab`) : '',\r\n                prefabExists: v.registeredPath ? snap.prefabsByResourcePath[v.registeredPath] !== undefined : false,\r\n                layer: v.registeredLayer ?? '',\r\n            }));\r\n    },\r\n\r\n    /* ------------------------------ manager ------------------------------ */\r\n\r\n    /** manager 列表（assets/scripts/manager 下直属的 *Manager.ts） */\r\n    async queryManagers() {\r\n        return listManagers(snapshot()).map((m) => ({\r\n            name: m.className,\r\n            file: m.scriptFile,\r\n            extendsSingleton: m.extendsSingleton,\r\n            baseClass: m.baseClass,\r\n            order: m.order,\r\n        }));\r\n    },\r\n\r\n    /**\r\n     * 创建 manager：生成一个继承框架 ASingleton 的全局单例脚本。\r\n     * @param managerName 名字，如 \"config\" / \"Config\" / \"ConfigManager\"\r\n     */\r\n    async createManager(managerName: string, order: number = 40) {\r\n        if (!managerName || !IDENTIFIER_RE.test(managerName)) {\r\n            throw new Error(`非法的 manager 名: \"${managerName}\"，请使用合法的标识符`);\r\n        }\r\n        const className = normalizeManagerName(managerName);\r\n        // 和 createModule 一样先校验 order：非法值不该写进生成出来的代码\r\n        if (typeof order !== 'number' || !Number.isFinite(order) || order < 0) {\r\n            throw new Error(`非法的 order: ${order}`);\r\n        }\r\n        const dirUrl = `db://${MANAGER_DIR}`;\r\n        await ensureDir(dirUrl);\r\n\r\n        const scriptUrl = `${dirUrl}/${className}.ts`;\r\n        if (await assetExists(scriptUrl)) {\r\n            throw new Error(`manager 已存在：${className}.ts（如需重建，请先删除它）`);\r\n        }\r\n\r\n        const asset = await Editor.Message.request(\r\n            'asset-db', 'create-asset', scriptUrl, buildManagerScript(className, frameworkImportMode(), order), { overwrite: false },\r\n        );\r\n        if (!asset) {\r\n            throw new Error(`创建 manager 失败: ${scriptUrl}`);\r\n        }\r\n\r\n        await Editor.Message.request('asset-db', 'refresh-asset', dirUrl);\r\n        return { className, scriptUrl, file: `${MANAGER_DIR}/${className}.ts` };\r\n    },\r\n\r\n    /**\r\n     * 更新 manager 的 order：写回脚本里的 @RegisterManager({order: N})。\r\n     *\r\n     * 和模块一样**直接改源文件** —— 不引入第二份真相（改完在编辑器里看得见）。\r\n     */\r\n    async updateManagerOrder(managerName: string, order: number) {\r\n        if (!managerName || !IDENTIFIER_RE.test(managerName)) {\r\n            throw new Error(`非法的 manager 名: \"${managerName}\"，请使用合法的标识符`);\r\n        }\r\n        if (typeof order !== 'number' || !Number.isFinite(order) || order < 0) {\r\n            throw new Error(`非法的 order: ${order}`);\r\n        }\r\n        const className = normalizeManagerName(managerName);\r\n        const relFile = `${MANAGER_DIR}/${className}.ts`;\r\n        const abs = join(projectPath(), relFile);\r\n        if (!existsSync(abs)) {\r\n            throw new Error(`找不到 manager 脚本：${relFile}`);\r\n        }\r\n        const content = readFileSync(abs, 'utf8');\r\n        if (!/order\\s*:\\s*\\d+/.test(content)) {\r\n            throw new Error(`未在 ${relFile} 中找到 order 字段（应为 @RegisterManager({ order: N })）`);\r\n        }\r\n        writeFileSync(abs, content.replace(/order\\s*:\\s*\\d+/, `order: ${order}`), 'utf8');\r\n        await Editor.Message.request('asset-db', 'refresh-asset', `db://${MANAGER_DIR}`);\r\n        return { className, file: relFile, order };\r\n    },\r\n    /** 删除 manager 脚本 */\r\n    async deleteManager(managerName: string) {\r\n        if (!managerName || !IDENTIFIER_RE.test(managerName)) {\r\n            throw new Error(`非法的 manager 名: \"${managerName}\"`);\r\n        }\r\n        const className = normalizeManagerName(managerName);\r\n        const scriptUrl = `db://${MANAGER_DIR}/${className}.ts`;\r\n\r\n        const info = await Editor.Message.request('asset-db', 'query-asset-info', scriptUrl);\r\n        if (!info) {\r\n            throw new Error(`找不到 manager 脚本：${className}.ts`);\r\n        }\r\n        await Editor.Message.request('asset-db', 'delete-asset', scriptUrl);\r\n        await Editor.Message.request('asset-db', 'refresh-asset', `db://${MANAGER_DIR}`);\r\n        return { className, removed: scriptUrl };\r\n    },\r\n\r\n    /**\r\n     * 删除模块前的引用检查：哪些资源引用了该模块的脚本。\r\n     * 面板在确认框里展示，避免删完留下悬空引用。\r\n     */\r\n    async queryModuleRefs(moduleName: string) {\r\n        if (!moduleName || !IDENTIFIER_RE.test(moduleName)) {\r\n            throw new Error(`非法的模块名: \"${moduleName}\"`);\r\n        }\r\n        const moduleDir = normalizeModule(moduleName).dir;\r\n        const snap = snapshot();\r\n        const views = listViews(snap).filter((v) => v.moduleDir === moduleDir);\r\n        const cids = views.map((v) => snap.scriptCids[v.scriptFile]).filter(Boolean);\r\n        const moduleCid = snap.scriptCids[`${GAMEPLAY_DIR}/${moduleDir}/${normalizeModule(moduleName).moduleClass}.ts`];\r\n        const allCids = moduleCid ? cids.concat([moduleCid]) : cids;\r\n        return {\r\n            views: views.map((v) => v.className),\r\n            referencedBy: findAssetRefs(snap, allCids),\r\n        };\r\n    },\r\n\r\n    /** 在编辑器里打开某个工程内文件（体检结果/概览点击定位用） */\r\n    async openSource(relPath: string) {\r\n        if (!relPath || relPath.includes('..')) {\r\n            throw new Error(`非法的路径: \"${relPath}\"`);\r\n        }\r\n        const url = dbUrl(relPath);\r\n        // 先确认资源存在且已被编辑器导入，再谈打开；否则给出明确原因\r\n        const info = await Editor.Message.request('asset-db', 'query-asset-info', url);\r\n        if (!info) {\r\n            throw new Error(`资源不存在或未被编辑器导入: ${relPath}`);\r\n        }\r\n        await Editor.Message.request('asset-db', 'open-asset', url);\r\n        return { url };\r\n    },\r\n\r\n    /**\r\n     * 创建模块：生成 Module + Model + 事件声明 三个脚本。\r\n     * @param moduleName 模块名，如 \"bag\" / \"Bag\" / \"BagModule\"\r\n     * @param order      模块启动顺序\r\n     */\r\n    async createModule(moduleName: string, order: number) {\r\n        if (!moduleName || !IDENTIFIER_RE.test(moduleName)) {\r\n            throw new Error(`非法的模块名: \"${moduleName}\"，请使用合法的标识符`);\r\n        }\r\n        if (typeof order !== 'number' || !Number.isFinite(order) || order < 0) {\r\n            throw new Error(`非法的 order: ${order}`);\r\n        }\r\n\r\n        const naming = normalizeModule(moduleName);\r\n        const moduleDirUrl = `db://${GAMEPLAY_DIR}/${naming.dir}`;\r\n\r\n        // 先查存在性，给出明确原因（旧版只在 create-asset 返回空时说“可能已存在”）\r\n        const moduleUrl = `${moduleDirUrl}/${naming.moduleClass}.ts`;\r\n        const modelUrl = `${moduleDirUrl}/${naming.modelClass}.ts`;\r\n        const eventsUrl = `${moduleDirUrl}/${naming.eventsName}.ts`;\r\n        if (await assetExists(moduleUrl)) {\r\n            throw new Error(`模块已存在：${naming.moduleClass}.ts（如需重建，请先删除该模块）`);\r\n        }\r\n        if (await assetExists(modelUrl)) {\r\n            throw new Error(`模型已存在：${naming.modelClass}.ts（如需重建，请先删除该模块）`);\r\n        }\r\n        if (await assetExists(eventsUrl)) {\r\n            throw new Error(`事件声明已存在：${naming.eventsName}.ts（如需重建，请先删除该模块）`);\r\n        }\r\n\r\n        await ensureDir(moduleDirUrl);\r\n\r\n        /** 已创建成功的资源；任一步失败时按逆序回滚，避免留下半成品 */\r\n        const created: string[] = [];\r\n        const createOrRollback = async (url: string, content: string, label: string): Promise<void> => {\r\n            const asset = await Editor.Message.request(\r\n                'asset-db', 'create-asset', url, content, { overwrite: false },\r\n            );\r\n            if (!asset) {\r\n                const count = created.length;\r\n                for (const done of created.reverse()) {\r\n                    await Editor.Message.request('asset-db', 'delete-asset', done).catch(() => undefined);\r\n                }\r\n                await Editor.Message.request('asset-db', 'refresh-asset', moduleDirUrl);\r\n                throw new Error(\r\n                    `创建${label}失败: ${url}${count > 0 ? `（已回滚 ${count} 个文件）` : ''}`,\r\n                );\r\n            }\r\n            created.push(url);\r\n        };\r\n\r\n        await createOrRollback(\r\n            moduleUrl, buildModuleScript(naming.moduleClass, naming.modelClass, order, frameworkImportMode()), '模块',\r\n        );\r\n        await createOrRollback(modelUrl, buildModelScript(naming.modelClass, frameworkImportMode()), '模型');\r\n        await createOrRollback(eventsUrl, buildEventsScript(naming.dir, naming.moduleClass), '事件声明');\r\n\r\n        await Editor.Message.request('asset-db', 'refresh-asset', moduleDirUrl);\r\n\r\n        return {\r\n            dirName: naming.dir,\r\n            prefix: naming.prefix,\r\n            moduleUrl,\r\n            modelUrl,\r\n            eventsUrl,\r\n            order,\r\n        };\r\n    },\r\n\r\n    /**\r\n     * 更新模块的 order：写回 Module 脚本的 @RegisterModule({order})。\r\n     */\r\n    async updateModuleOrder(moduleName: string, order: number) {\r\n        if (!moduleName || !IDENTIFIER_RE.test(moduleName)) {\r\n            throw new Error(`非法的模块名: \"${moduleName}\"`);\r\n        }\r\n        if (typeof order !== 'number' || !Number.isFinite(order) || order < 0) {\r\n            throw new Error(`非法的 order: ${order}`);\r\n        }\r\n\r\n        const moduleDir = normalizeModule(moduleName).dir;\r\n        const moduleDirPath = join(projectPath(), GAMEPLAY_DIR, moduleDir);\r\n\r\n        let files: string[] = [];\r\n        try {\r\n            files = readdirSync(moduleDirPath);\r\n        } catch (e) {\r\n            throw new Error(`找不到模块目录: ${moduleDir}`);\r\n        }\r\n        const moduleFile = files.find((f) => f.endsWith('Module.ts'));\r\n        if (!moduleFile) {\r\n            throw new Error(`找不到模块脚本: ${moduleDir}`);\r\n        }\r\n\r\n        const fullPath = join(moduleDirPath, moduleFile);\r\n        const content = readFileSync(fullPath, 'utf-8');\r\n        const newContent = content.replace(/order\\s*:\\s*\\d+/, `order: ${order}`);\r\n        if (newContent === content) {\r\n            throw new Error(`未在 ${moduleFile} 中找到 order 字段`);\r\n        }\r\n        writeFileSync(fullPath, newContent);\r\n\r\n        await Editor.Message.request('asset-db', 'refresh-asset', dbUrl(`${GAMEPLAY_DIR}/${moduleDir}`));\r\n\r\n        return { moduleName: moduleDir, order };\r\n    },\r\n\r\n    /**\r\n     * 创建 View：在指定模块下生成脚本 + 预制体，并把脚本挂载到预制体根节点。\r\n     * @param template 预制体模板，见 constants.PREFAB_TEMPLATES\r\n     */\r\n    async createView(moduleName: string, viewName: string, layer: string, template: string = 'empty') {\r\n        if (!moduleName || !IDENTIFIER_RE.test(moduleName)) {\r\n            throw new Error(`非法的模块名: \"${moduleName}\"`);\r\n        }\r\n        if (!viewName || !IDENTIFIER_RE.test(viewName)) {\r\n            throw new Error(`非法的视图名: \"${viewName}\"，请使用合法的标识符`);\r\n        }\r\n        if (!LAYERS.includes(layer as any)) {\r\n            throw new Error(`非法的层级: \"${layer}\"（合法值：${LAYERS.join(', ')}）`);\r\n        }\r\n        if (!isPrefabTemplate(template)) {\r\n            throw new Error(`非法的预制体模板: \"${template}\"（合法值：${PREFAB_TEMPLATES.join(', ')}）`);\r\n        }\r\n\r\n        const moduleDir = normalizeModule(moduleName).dir;\r\n        const className = normalizeViewName(viewName);\r\n        const prefabPath = viewPrefabPath(moduleDir, className);\r\n\r\n        // 跨模块重名会加载错预制体（ViewManager 按类名全局查找），提前挡住\r\n        const snap = snapshot();\r\n        const clash = listViews(snap).find(\r\n            (v) => v.className === className && v.moduleDir !== moduleDir,\r\n        );\r\n        if (clash) {\r\n            throw new Error(\r\n                `View 名字 \"${className}\" 已被模块 \"${clash.moduleDir}\" 占用；` +\r\n                `框架按类名全局查找，重名会加载错预制体，请换个名字`,\r\n            );\r\n        }\r\n\r\n        const viewsDirUrl = `db://${GAMEPLAY_DIR}/${moduleDir}/${VIEWS_SUBDIR}`;\r\n        await ensureDir(viewsDirUrl);\r\n\r\n        const scriptUrl = `${viewsDirUrl}/${className}.ts`;\r\n        if (await assetExists(scriptUrl)) {\r\n            throw new Error(`View 脚本已存在：${className}.ts（如需重建，请先删除该 View）`);\r\n        }\r\n\r\n        const scriptContent = buildViewScript(className, prefabPath, layer, frameworkImportMode());\r\n        const scriptAsset = await Editor.Message.request(\r\n            'asset-db', 'create-asset', scriptUrl, scriptContent, { overwrite: false },\r\n        );\r\n        if (!scriptAsset) {\r\n            throw new Error(`创建脚本失败: ${scriptUrl}`);\r\n        }\r\n\r\n        const prefabDirUrl = `db://${RESOURCES_DIR}/views/${moduleDir}`;\r\n        const prefabUrl = `${prefabDirUrl}/${className}.prefab`;\r\n        await ensureDir(prefabDirUrl);\r\n\r\n        if (await assetExists(prefabUrl)) {\r\n            await Editor.Message.request('asset-db', 'delete-asset', scriptUrl).catch(() => undefined);\r\n            throw new Error(`预制体已存在：${className}.prefab（已回滚脚本，如需重建请先删除该 View）`);\r\n        }\r\n\r\n        try {\r\n            const compressedUuid = compressUuid(scriptAsset.uuid);\r\n            const prefabContent = JSON.stringify(buildViewPrefab(className, compressedUuid, template));\r\n            const prefabAsset = await Editor.Message.request(\r\n                'asset-db', 'create-asset', prefabUrl, prefabContent, { overwrite: false },\r\n            );\r\n            if (!prefabAsset) {\r\n                throw new Error(`创建预制体失败: ${prefabUrl}`);\r\n            }\r\n        } catch (e) {\r\n            // 回滚脚本，避免留下“有脚本没预制体”的半成品\r\n            await Editor.Message.request('asset-db', 'delete-asset', scriptUrl).catch(() => undefined);\r\n            await Editor.Message.request('asset-db', 'refresh-asset', viewsDirUrl);\r\n            throw e;\r\n        }\r\n\r\n        await Editor.Message.request('asset-db', 'refresh-asset', prefabDirUrl);\r\n        await Editor.Message.request('asset-db', 'refresh-asset', viewsDirUrl);\r\n\r\n        return { className, moduleDir, scriptUrl, prefabUrl, prefabPath, layer, template };\r\n    },\r\n\r\n    /**\r\n     * 删除 view：只删自身（脚本 + 预制体 + 各自 meta），不碰其他资源。\r\n     */\r\n    async deleteView(moduleName: string, viewName: string) {\r\n        if (!moduleName || !IDENTIFIER_RE.test(moduleName)) {\r\n            throw new Error(`非法的模块名: \"${moduleName}\"`);\r\n        }\r\n        if (!viewName || !IDENTIFIER_RE.test(viewName)) {\r\n            throw new Error(`非法的视图名: \"${viewName}\"`);\r\n        }\r\n\r\n        const moduleDir = normalizeModule(moduleName).dir;\r\n        const className = normalizeViewName(viewName);\r\n        const prefabUrl = `db://${RESOURCES_DIR}/views/${moduleDir}/${className}.prefab`;\r\n        const scriptUrl = `db://${GAMEPLAY_DIR}/${moduleDir}/${VIEWS_SUBDIR}/${className}.ts`;\r\n\r\n        const deleted: string[] = [];\r\n        for (const url of [prefabUrl, scriptUrl]) {\r\n            const info = await Editor.Message.request('asset-db', 'query-asset-info', url);\r\n            if (info) {\r\n                await Editor.Message.request('asset-db', 'delete-asset', url);\r\n                deleted.push(url);\r\n            }\r\n        }\r\n\r\n        // 清理空目录（旧版会留下 resources/views/<模块> 这种空壳）\r\n        await pruneEmptyDir(join(projectPath(), RESOURCES_DIR, 'views', moduleDir));\r\n\r\n        await Editor.Message.request('asset-db', 'refresh-asset', `db://${RESOURCES_DIR}/views/${moduleDir}`);\r\n        await Editor.Message.request('asset-db', 'refresh-asset', dbUrl(`${GAMEPLAY_DIR}/${moduleDir}/${VIEWS_SUBDIR}`));\r\n\r\n        return { className, moduleDir, deleted };\r\n    },\r\n\r\n    /**\r\n     * 删除模块：删 gameplay/<模块>/ 与 resources/views/<模块>/ 两个目录（连同 meta）。\r\n     */\r\n    async deleteModule(moduleName: string) {\r\n        if (!moduleName || !IDENTIFIER_RE.test(moduleName)) {\r\n            throw new Error(`非法的模块名: \"${moduleName}\"`);\r\n        }\r\n        const moduleDir = normalizeModule(moduleName).dir;\r\n\r\n        const moduleDirPath = join(projectPath(), GAMEPLAY_DIR, moduleDir);\r\n        const prefabDirPath = join(projectPath(), RESOURCES_DIR, 'views', moduleDir);\r\n\r\n        const removed: string[] = [];\r\n        for (const p of [prefabDirPath, moduleDirPath]) {\r\n            try {\r\n                if (statSync(p).isDirectory()) {\r\n                    removeSync(p);\r\n                    removed.push(p);\r\n                }\r\n            } catch (e) {\r\n                /* 不存在则跳过 */\r\n            }\r\n        }\r\n\r\n        await Editor.Message.request('asset-db', 'refresh-asset', `db://${RESOURCES_DIR}/views`);\r\n        await Editor.Message.request('asset-db', 'refresh-asset', dbUrl(GAMEPLAY_DIR));\r\n\r\n        return { moduleDir, removed };\r\n    },\r\n\r\n    /* ------------------------------ 公共模块 ------------------------------ */\r\n\r\n    /**\r\n     * 查询公共模块：本地工作区 + 已安装 + 远程 registry。\r\n     * @param force 强制重新拉取远程列表（面板的「刷新」用）\r\n     */\r\n    async querySharedModules(force?: boolean) {\r\n        return await querySharedState(force === true);\r\n    },\r\n\r\n    /**\r\n     * 安装一个公共模块：**直接代跑 `npm install`**。\r\n     * 失败时抛出的错误里带着 npm 的原始输出，面板会原样展示。\r\n     */\r\n    async installSharedModule(wanted: string) {\r\n        // ⚠️ 不要动 runSharedAction 的返回值:它的形状是\"刷新后的公共模块列表\"\n        //    (我一开始猜成 {ok, message} 并去读 r.ok/r.message,编译器当场就把我拦住了)。\n        //    这里只做一件事:装完之后补上这个模块需要的工程资源,然后原样透传。\n        const r = await runSharedAction('install', wanted);\n        const made = await ensureScaffoldAssets(String(wanted));\n        if (made.length > 0) {\n            console.log(`[ccgf] 已生成默认红点样式:${made.join(', ')}(默认样式路径:reddot/default)`);\n        }\n        return r;\r\n    },\r\n\r\n    /** 卸载一个公共模块：直接代跑 `npm uninstall` */\r\n    async uninstallSharedModule(wanted: string) {\r\n        return runSharedAction('uninstall', wanted);\r\n    },\r\n};\r\n\r\n/**\r\n * @en Method Triggered on Extension Startup\r\n * @zh 扩展启动时触发的方法\r\n */\r\nexport function load() { }\r\n\r\n/**\r\n * @en Method triggered when uninstalling the extension\r\n * @zh 卸载扩展时触发的方法\r\n */\r\nexport function unload() { }\r\n"]}
1748
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"main.js","sourceRoot":"","sources":["../source/main.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-ignore\nimport packageJSON from '../package.json';\nimport { spawn, spawnSync } from 'child_process';\nimport { copySync, existsSync, mkdirSync, readdirSync, readFileSync, removeSync, statSync, writeFileSync } from 'fs-extra';\nimport { join, dirname, relative } from 'path';\nimport {\n    GAMEPLAY_DIR,\n  BUNDLES_ROOT,\n    BUNDLE_SCRIPTS_SUBDIR,\n    LAYERS,\n    MANAGER_DIR,\n    PREFAB_TEMPLATES,\n    PREFAB_TEMPLATE_LABELS,\n    REGISTRY_CACHE_MS,\n    RESOURCES_DIR,\n    TPrefabTemplate,\n    VIEWS_SUBDIR,\n} from './constants';\nimport {\n    ensureTargetBundleLoaded,\n    getTargetBundle,\n    listBundles,\n    markAsBundle,\n    prefabKeyRoot,\n    prefabRoot,\n    scriptsRoot,\n    setTargetBundle,\n} from './bundle';\nimport { log, logToEditor, warnLog } from './log';\nimport { buildOrderPlan, listManagers, listModules, listViews, runDoctor } from './doctor';\nimport {\n    IDENTIFIER_RE,\n    normalizeManagerName,\n    normalizeModule,\n    normalizeViewName,\n    viewPrefabPath,\n} from './naming';\nimport {\n    collectSnapshot,\n    findDevWorkspaceSharedPackagesDir,\n    listLocalCatalog,\n    readInstalledPackage,\n    readProjectManifest,\n} from './project';\nimport {\n    isSharedModulePackage,\n    KNOWN_PACKAGES,\n    parseViewResult,\n    viewArgv,\n} from './registry';\nimport {\n    NPM_TIMEOUT_MS,\n    buildNpmResult,\n    buildSharedStatus,\n    catalogEntryFromInstalled,\n    collectInstallSpecs,\n    decodeProcessOutput,\n    findPackageRefs,\n    formatNpmCommand,\n    isSharedModuleManifest,\n    mergeCatalog,\n    npmSpawnSpec,\n    spawnSpecFor,\n    summarizeNpmFailure,\n} from './shared';\nimport {\n    buildGuideMaskPrefab,\n    buildRedDotPrefab,\n    buildManagerScript,\n    buildEventsScript,\n    buildModelScript,\n    buildModuleScript,\n    buildViewPrefab,\n    buildViewScript,\n    isPrefabTemplate,\n    TFrameworkImport,} from './templates';\nimport {\n    assertUniqueTableNames,\n    buildTable,\n    createTable as createTableOnDisk,\n    findDuplicateTableNames,\n    readTableCsv,\n    renderTableTypes,\n    scanTables,\n    tableTypeFilePath,\n    TableToolError,\n} from './tables';\nimport type { ITableBuildResult, ITableFileInfo, ITableTypeSource } from './tables';\nimport {\n    IFinding, INpmRunResult, IInstalledPackageView, IProjectSnapshot, ISharedCatalogEntry } from './types';\n\n/* ------------------------------- 文案 ------------------------------- */\n\n/**\n * 扩展自带的中文文案表。\n * 它既是「key 全集」的来源，也是编辑器 i18n 拿不到时的兜底。\n */\n// eslint-disable-next-line @typescript-eslint/no-var-requires\nconst ZH_STRINGS: Record<string, string> = require('../i18n/zh.js');\n\n/* ------------------------------- 小工具 ------------------------------- */\n\n/** 工程根目录 */\nfunction projectPath(): string {\n    return Editor.Project.path;\n}\n\n/** 数据表错误 -> 面板可显示的一行文本（带表/行/字段） */\nfunction tableErrorText(e: unknown, fallback = ''): string {\n    if (e instanceof TableToolError) {\n        return e.format();\n    }\n    const message = e instanceof Error ? e.message : String(e);\n    return fallback ? `${fallback}：${message}` : message;\n}\n\n/** Bundle 增删后通知已打开的数据表工具刷新目录（没有面板监听也无害） */\nfunction notifyTableDirsChanged(): void {\n    try {\n        (Editor.Message as any).broadcast('ccgf-game-tool:table-dirs-changed');\n    } catch (e) {\n        /* 编辑器版本不支持广播时忽略；刷新按钮兜底 */\n    }\n}\n\n/**\n * 目标写在 bundles/<name>/... 时，先确认 bundle 目录真的存在。\n *\n * 否则我们会先在 assets/bundles/<name> 下写出一个没有 Bundle 配置的目录，\n * 再让 asset-db 去刷新它，正好触发\n * `Can not change the asset \"db://assets/bundles/<name>\", because the original asset is not exist`。\n */\nfunction assertBundleTarget(project: string, relativeCsv: string): void {\n    const match = /^bundles\\/([^/]+)\\//.exec(relativeCsv);\n    if (!match) {\n        return;\n    }\n    const bundleName = match[1];\n    if (!existsSync(join(project, 'assets', 'bundles', bundleName))) {\n        throw new TableToolError(\n            `目标 bundle 不存在：assets/bundles/${bundleName}。请先在扩展里新建 Bundle，再导出到它。`,\n        );\n    }\n}\n\n/**\n * 把构建好的 .bin 交给 asset-db。\n *\n * 关键：**新文件不要先落盘再 refresh**——asset-db 对磁盘上已存在、但自己没索引的文件\n * 会报 `Can not change the asset \"...\", because the original asset is not exist`。\n * 正确做法是新文件直接 `create-asset(url, Buffer)`，让 asset-db 自己写盘并建索引；\n * 只有已经认识的文件才用 fs 覆盖 + `refresh-asset(file)`。\n */\nasync function ensureAssetDir(project: string, dirRelative: string): Promise<void> {\n    const rel = dirRelative.replace(/\\\\/g, '/');\n    if (!rel || rel === '.') {\n        return;\n    }\n    const abs = join(project, 'assets', rel);\n    if (existsSync(abs)) {\n        return;\n    }\n\n    // 目录不存在时先让 asset-db 创建目录（会发“新增资源”事件，资源管理器才认）\n    const made = await Editor.Message.request(\n        'asset-db', 'create-asset', `db://assets/${rel}`, null, { overwrite: false },\n    ).catch(() => null);\n    if (!made) {\n        mkdirSync(abs, { recursive: true });\n    }\n}\n\nasync function writeTableAsset(project: string, built: ITableBuildResult): Promise<string | null> {\n    const binRelative = built.binRelative;\n    const abs = join(project, 'assets', binRelative);\n    const url = `db://assets/${binRelative}`;\n\n    await ensureAssetDir(project, dirname(binRelative));\n\n    const known = await Editor.Message.request('asset-db', 'query-asset-info', url).catch(() => null);\n    if (known) {\n        try {\n            writeFileSync(abs, built.buffer);\n            await Editor.Message.request('asset-db', 'refresh-asset', url);\n            return null;\n        } catch (e) {\n            return `覆盖已有文件失败：${url}（${e instanceof Error ? e.message : String(e)}）`;\n        }\n    }\n\n    // 磁盘上已有同名文件但资源库没有索引：先删掉旧文件，再走 create-asset。\n    // 否则 create-asset 会弹「文件已存在，是否覆盖？」；旧文件是我们自己生成的，可以重建。\n    if (existsSync(abs)) {\n        try {\n            removeSync(abs);\n            if (existsSync(abs + '.meta')) {\n                removeSync(abs + '.meta');\n            }\n        } catch (e) {\n            writeFileSync(abs, built.buffer);\n            return `旧文件无法删除，资源库也没导入 ${url}，请手动刷新所在目录`;\n        }\n    }\n\n    try {\n        const created = await Editor.Message.request(\n            'asset-db', 'create-asset', url, built.buffer, { overwrite: false },\n        ).catch(() => null);\n        if (created) {\n            return null;\n        }\n    } catch (e) {\n        // 走下面的 fallback warning\n    }\n\n    writeFileSync(abs, built.buffer);\n    return `资源库没有导入 ${url}，请手动刷新所在目录`;\n}\n\n/** 写生成出的 TableTypes.ts；逻辑与 .bin 一致，新文件走 create-asset */\nasync function writeTextAsset(project: string, assetRelative: string, content: string): Promise<string | null> {\n    const abs = join(project, 'assets', assetRelative);\n    const url = `db://assets/${assetRelative}`;\n\n    await ensureAssetDir(project, dirname(assetRelative));\n\n    const known = await Editor.Message.request('asset-db', 'query-asset-info', url).catch(() => null);\n    if (known) {\n        try {\n            writeFileSync(abs, content, 'utf8');\n            await Editor.Message.request('asset-db', 'refresh-asset', url);\n            return null;\n        } catch (e) {\n            return `覆盖失败：${url}（${e instanceof Error ? e.message : String(e)}）`;\n        }\n    }\n\n    if (existsSync(abs)) {\n        try {\n            removeSync(abs);\n            if (existsSync(abs + '.meta')) {\n                removeSync(abs + '.meta');\n            }\n        } catch (e) {\n            writeFileSync(abs, content, 'utf8');\n            return `旧文件无法删除，资源库也没导入 ${url}`;\n        }\n    }\n\n    try {\n        const created = await Editor.Message.request(\n            'asset-db', 'create-asset', url, content, { overwrite: false },\n        ).catch(() => null);\n        if (created) {\n            return null;\n        }\n    } catch (e) {\n        // fallback\n    }\n\n    writeFileSync(abs, content, 'utf8');\n    return `资源库没有导入 ${url}，请手动刷新所在目录`;\n}\n\n/** 生成的 TableTypes.ts 里，ITableRow 的 import 路径 */\nfunction tableTypeImportPath(typeRelative: string): string {\n    if (frameworkImportMode() === 'package') {\n        return '@ccgf/framework';\n    }\n    const fromDir = dirname(join(projectPath(), 'assets', typeRelative));\n    const framework = join(projectPath(), 'assets/scripts/framework/core/table/TableTypes');\n    let rel = relative(fromDir, framework).replace(/\\\\/g, '/');\n    if (!rel.startsWith('.')) {\n        rel = `./${rel}`;\n    }\n    return rel;\n}\n\n/**\n * 为每个包生成一份 TableTypes.ts：\n * - 主包 -> assets/scripts/table/TableTypes.ts\n * - 子包 -> assets/bundles/<bundle>/scripts/table/TableTypes.ts\n *\n * 用全部可解析的表生成，而不是只导出选中的几张；否则“导出选中”会删掉其它表的类型。\n */\nasync function generateTableTypes(project: string, files: ITableFileInfo[]): Promise<string[]> {\n    const groups = new Map<string, ITableTypeSource[]>();\n\n    for (const file of files) {\n        if (file.error) {\n            continue;\n        }\n        const bundleName = /^bundles\\/([^/]+)\\//.exec(file.relative)?.[1] ?? '';\n        if (bundleName && !existsSync(join(project, 'assets', 'bundles', bundleName))) {\n            continue;\n        }\n\n        try {\n            const data = readTableCsv(project, file.relative);\n            const typeRelative = tableTypeFilePath(file.binRelative);\n            const sources = groups.get(typeRelative) ?? [];\n            sources.push({ data, source: file.relative });\n            groups.set(typeRelative, sources);\n        } catch (e) {\n            // 单张表解析失败：跳过类型，导出错误列表里已经会显示\n        }\n    }\n\n    const warnings: string[] = [];\n    for (const [typeRelative, sources] of groups) {\n        const content = renderTableTypes(sources, tableTypeImportPath(typeRelative));\n        const warning = await writeTextAsset(project, typeRelative, content);\n        if (warning) {\n            warnings.push(`${typeRelative}：${warning}`);\n        }\n    }\n    return warnings;\n}\n\n/**\n * 这个工程引用框架该用哪种写法:\n * - 开发工作区(仓库里,框架源码在 assets/scripts/framework 下) -> 相对路径\n * - 装成 npm 包的新工程 -> 包名 @ccgf/framework\n *\n * 判据是\"框架源码在不在\",与 constants.ts 的 FRAMEWORK_DEV_DIR 同一个值。\n */\nfunction frameworkImportMode(): TFrameworkImport {\n    return existsSync(join(projectPath(), 'assets/scripts/framework')) ? 'workspace' : 'package';\n}\n\n/** 相对路径 -> db:// 资源 url */\nfunction dbUrl(rel: string): string {\n    return 'db://' + rel.replace(/\\\\/g, '/');\n}\n\n/** uuid -> 预制体里脚本组件的 __type__ */\nfunction compressUuid(uuid: string): string {\n    return Editor.Utils.UUID.compressUUID(uuid, false);\n}\n\n/** 取一份工程快照（体检、列表都基于它，保证面板看到的和体检看到的是同一份数据） */\n/** 读 assets/scripts/shared/** 下的 .ts 原文(体检要扫它们:那里面按包名引 = 第二份) */\nfunction readSharedSources(): Record<string, string> {\n    const out: Record<string, string> = {};\n    const base = join(projectPath(), 'assets', 'scripts', 'shared');\n    const walk = (abs: string, rel: string) => {\n        let entries: any[];\n        try { entries = readdirSync(abs, { withFileTypes: true }); } catch { return; }\n        for (const e of entries) {\n            const a = join(abs, e.name); const r = rel ? rel + '/' + e.name : e.name;\n            if (e.isDirectory()) walk(a, r);\n            else if (e.isFile() && e.name.endsWith('.ts')) {\n                try { out['assets/scripts/shared/' + r] = readFileSync(a, 'utf8'); } catch { /* 读不到就跳过 */ }\n            }\n        }\n    };\n    walk(base, '');\n    return out;\n}\n\n/**\n * 当前目标包的快照扫描根。\n *\n * 主包用默认值(assets/scripts + assets/resources);子包把\"模块/预制体\"两项换成\n * 子包自己的目录 —— 这样模块列表、View 列表、体检都会跟着下拉框走，而不是永远看主包。\n */\nfunction snapshotRoots(): { moduleRoot: string; prefabRoot: string; prefabKeyRoot: string } | undefined {\n    const bundle = getTargetBundle();\n    if (!bundle) {\n        return undefined;\n    }\n    return {\n        moduleRoot: scriptsRoot(),\n        prefabRoot: prefabRoot(),\n        prefabKeyRoot: prefabKeyRoot(),\n    };\n}\n\nfunction snapshot(): IProjectSnapshot {\n    const s = collectSnapshot(projectPath(), compressUuid, snapshotRoots());\n    // 只在\"框架包被装进工程 node_modules\"这件事上补一个事实:\n    // 是不是\"两份框架\"要由 doctor 结合\"assets 下有没有框架源码\"一起判。\n    return {\n        ...s,\n        frameworkInNodeModules: existsSync(join(projectPath(), 'node_modules', '@ccgf', 'framework')),\n        sharedSources: readSharedSources(),\n    };\n}\n\n/* ------------------------------ 公共模块 ------------------------------ */\n\n/**\n * registry 搜索结果的缓存。\n *\n * 一次搜索实测 1~4 秒 —— 而面板切页、装完刷新都会调用查询，不能每次都去搜。\n * 显式点「刷新」时用 `force` 绕过它。\n */\nlet registryCache: { at: number; entries: ISharedCatalogEntry[]; error: string | null } | null = null;\n\n/**\n * **失败不抛异常,也不让面板空着装作\"没有模块\"**:把原因一起回传,面板显示成提示 ——\n * 这是最初就定下的要求(\"没有网络就提示就行了\")。\n *\n * 远程信息的来源:**逐个 `npm view <name> --json` 精确查询**。\n *\n * 曾经用 `npm search` + 关键词,已废弃 —— 搜索对 scoped 包(`@ccgf/*`)很不可靠,\n * 常常搜不到,于是\"公共模块远程列表\"和\"最新版本\"都会是空的(实测踩过)。\n * 代价:包名要维护在 registry.ts 的 KNOWN_PACKAGES 里,新增包时加一行。\n *\n * 之所以用 npm 命令而不是自己发 HTTPS 请求:npm 会自动带上工程的 `.npmrc`\n * (私有源、镜像、代理等配置都跟着走),不用我们重复实现一遍。\n */\n/**\n * **异步**跑一次 npm。\n *\n * 为什么不能继续用 spawnSync:这个函数在**编辑器主进程**里被调用,spawnSync 会把主循环\n * 整个占住 —— 每查一个包几百毫秒,几个包下来编辑器 UI 就卡住、点别处没反应(实测)。\n * 换成 spawn + Promise:同样等结果,但中间让出事件循环,编辑器不冻结。\n */\n/**\n * 查远程信息用的**短**超时。\n *\n * 不能用 NPM_TIMEOUT_MS(120 秒):那是给\"安装\"用的,用户可以等;\n * 而\"查一下最新版本\"要是等两分钟,那一页就等于废了。\n */\nconst REGISTRY_QUERY_TIMEOUT_MS = 25000;\n\n/** 同一时刻只允许一个后台刷新在跑,否则每次切页签都会再起一轮 npm */\nlet registryRefreshing = false;\n\nfunction runNpmAsync(\n    command: string,\n    spawnSpec: { command: string; args: string[]; windowsVerbatimArguments?: boolean },\n    cwd: string,\n    timeoutMs: number = NPM_TIMEOUT_MS,\n): Promise<{ result: INpmRunResult; stdout: string }> {\n    return new Promise((resolve) => {\n        const chunks: Buffer[] = [];\n        const errChunks: Buffer[] = [];\n        let child: any;\n        const finish = (exitCode: number | null, spawnError: { code?: string; message: string } | null) => {\n            const stdout = decodeProcessOutput(Buffer.concat(chunks));\n            resolve({\n                result: buildNpmResult({\n                    command,\n                    exitCode,\n                    stdout,\n                    stderr: decodeProcessOutput(Buffer.concat(errChunks)),\n                    spawnError,\n                }),\n                stdout,\n            });\n        };\n        try {\n            child = spawn(spawnSpec.command, spawnSpec.args, {\n                cwd,\n                windowsHide: true,\n                windowsVerbatimArguments: spawnSpec.windowsVerbatimArguments,\n            });\n        } catch (err: any) {\n            finish(null, { message: err?.message ? String(err.message) : String(err) });\n            return;\n        }\n        const timer = setTimeout(() => { try { child.kill(); } catch { /* 已经退了 */ } }, timeoutMs);\n        child.stdout?.on('data', (d: Buffer) => chunks.push(d));\n        child.stderr?.on('data', (d: Buffer) => errChunks.push(d));\n        child.on('error', (err: any) => {\n            clearTimeout(timer);\n            finish(null, { code: err?.code, message: err?.message ? String(err.message) : String(err) });\n        });\n        child.on('close', (code: number | null) => {\n            clearTimeout(timer);\n            if (timer === null) return;\n            finish(code, null);\n        });\n    });\n}\n/**\n * 远程信息(带缓存)。**这个函数永远不阻塞、永远不 await 外部进程**。\n *\n * 为什么这么设计:它跑在编辑器主进程里,而 npm 每个进程要 1~3 秒,网络坏了还可能一直不返回。\n * 早先用同步 spawn + 逐个查,表现就是\"点开这一页,编辑器别处也没反应\"。\n * 现在:命中缓存立刻返回;过期则**先返回旧值**,同时后台刷新(不 await);\n * 从没成功过时返回明确的提示文案,而不是让调用方干等。\n *\n * 失败不抛异常,也不让面板空着装作\"没有模块\":把原因一起回传,面板显示成提示 ——\n * 这是最初就定下的要求(\"没有网络就提示就行了\")。\n */\nfunction queryRegistry(force: boolean): { entries: ISharedCatalogEntry[]; error: string | null } {\n    const now = Date.now();\n    const fresh = registryCache && now - registryCache.at < REGISTRY_CACHE_MS;\n\n    if (!force && fresh) {\n        return { entries: registryCache!.entries, error: registryCache!.error };\n    }\n\n    // 需要更新:后台去刷,不在这里等\n    void refreshRegistry();\n\n    if (registryCache) {\n        return { entries: registryCache.entries, error: registryCache.error };\n    }\n    return {\n        entries: [],\n        error: registryRefreshing ? '正在获取远程信息…' : '远程信息暂不可用(离线或超时)',\n    };\n}\n\n/** 真正的拉取:异步、有并发闸、单包失败不拖垮整份列表 */\nasync function refreshRegistry(): Promise<void> {\n    if (registryRefreshing) return;\n    registryRefreshing = true;\n    try {\n        const entries: ISharedCatalogEntry[] = [];\n        const failures: string[] = [];\n\n        for (const name of KNOWN_PACKAGES) {\n            const command = 'npm view ' + name + ' --json';\n            const spawnSpec = spawnSpecFor(\n                [process.platform === 'win32' ? 'npm.cmd' : 'npm', ...viewArgv(name)],\n            );\n            const { result, stdout } = await runNpmAsync(command, spawnSpec, projectPath(), REGISTRY_QUERY_TIMEOUT_MS);\n            if (!result.ok) {\n                failures.push(name + ':' + (result.hint ?? ('超时或退出码 ' + (result.exitCode ?? '未知'))));\n                continue;\n            }\n            const entry = parseViewResult(stdout);\n            if (entry) entries.push(entry);\n            else failures.push(name + ':返回内容不是预期的 JSON 形状');\n        }\n\n        // **部分**失败也要报出来:早先只在\"全部失败\"时才回传,\n        // 结果\"3 个查到 + 1 个超时\"完全静默 —— 面板显示\"无法确认\"却不给任何原因。\n        const error = failures.length > 0 ? ('部分远程信息获取失败:' + failures.join(';')) : null;\n        registryCache = { at: Date.now(), entries, error };\n    } finally {\n        registryRefreshing = false;\n    }\n}\n\n/**\n * 组装公共模块的完整状态。\n *\n * 三个来源合起来才是完整列表：\n * 1. 本框架**开发工作区**里的 `packages/shared/*`（只有本仓库才认，见\n *    `findDevWorkspaceSharedPackagesDir`）—— 能给出 `file:` 安装说明符；\n * 2. `node_modules` 里已经装了的（靠包清单里的标记认出来）；\n * 3. **远程 registry**（按发现关键词搜索）—— 覆盖\"还没装、但可以装\"的那些。\n *\n * 刻意**不**靠包名匹配来识别公共模块：scope 还没定（见 ROADMAP 的 S1a），\n * 换个 scope 就认不出来了。\n */\nasync function querySharedState(forceRegistry = false) {\n    const root = projectPath();\n    const manifest = readProjectManifest(root);\n    const projectDependencies: Record<string, string> = {\n        ...(manifest?.dependencies ?? {}),\n        ...(manifest?.devDependencies ?? {}),\n    };\n\n    const sharedDir = findDevWorkspaceSharedPackagesDir(root);\n    const local = sharedDir ? listLocalCatalog(sharedDir, root) : [];\n\n    const installedShared: ISharedCatalogEntry[] = [];\n    for (const name of Object.keys(projectDependencies)) {\n        const pkg = readInstalledPackage(root, name);\n        if (pkg.installed && isSharedModuleManifest(pkg.manifest)) {\n            installedShared.push(catalogEntryFromInstalled(name, pkg.manifest, pkg.version));\n        }\n    }\n\n    const registry = await queryRegistry(forceRegistry);\n    // 框架与扩展不是公共模块,虽然它们也装着、也在 KNOWN_PACKAGES 里 —— 两处都要滤掉,\n    // 否则使用者的\"公共模块\"列表里会冒出框架和编辑器扩展。\n    const sharedOnly = (e: ISharedCatalogEntry) => isSharedModulePackage(e.name);\n    const catalog = mergeCatalog(\n        mergeCatalog(local, registry.entries.filter(sharedOnly)),\n        installedShared.filter(sharedOnly),\n    );\n\n    // \"可更新\"要靠远程的最新版本号，而 mergeCatalog 让本地项优先（同名的远程项会被盖掉），\n    // 所以这里单独留一份包名 -> 远程最新版本。\n    const registryVersions: Record<string, string> = {};\n    for (const entry of registry.entries) {\n        registryVersions[entry.name] = entry.version;\n    }\n\n    // 要查实时状态的包 = 列表里的 + 它们声明的依赖。\n    // 依赖可能不在列表里（普通 npm 包），但它装没装同样要显示出来。\n    const wanted = new Set<string>();\n    for (const entry of catalog) {\n        wanted.add(entry.name);\n        for (const dep of Object.keys(entry.declaredDependencies)) {\n            wanted.add(dep);\n        }\n    }\n    const installedPackages: Record<string, IInstalledPackageView> = {};\n    for (const name of wanted) {\n        const pkg = readInstalledPackage(root, name);\n        installedPackages[name] = {\n            installed: pkg.installed,\n            version: pkg.version,\n            isSharedModule: isSharedModuleManifest(pkg.manifest),\n        };\n    }\n\n    const snap = snapshot();\n    const sources = { ...snap.gameplaySources, ...snap.managerSources };\n\n    const modules = catalog.map((entry) => buildSharedStatus(entry, {\n        projectDependencies,\n        installedPackages,\n        references: { [entry.name]: findPackageRefs(sources, entry.name) },\n        catalog,\n        registryVersions,\n    }));\n\n    return {\n        modules,\n        /** 本地安装源；**只有本框架的开发仓库里才非 null**（面向用户的工程里永远是 null） */\n        localSource: sharedDir,\n        /** 工程有可读的 package.json 吗 */\n        hasManifest: manifest !== null,\n        /** 远程列表拉取失败的原因；为 null 表示这次是成功的（或用了缓存） */\n        registryError: registry.error,\n    };\n}\n\n/**\n * 跑一次 npm。\n *\n * 全程**不抛异常**：退出码、stdout、stderr、以及 spawn 自身的失败都收进 INpmRunResult\n * 回传给面板 —— 用户要看的是 npm 自己说的话，而不是一句转述的\"安装失败\"。\n */\nfunction runNpm(action: 'install' | 'uninstall', specs: string[]): INpmRunResult {\n    const spawnSpec = npmSpawnSpec(action, specs);\n    try {\n        // 1. **不指定 encoding**：拿到原始 Buffer 自己解码，否则 cmd 的 GBK 消息会变乱码；\n        // 2. **windowsVerbatimArguments 必须来自 spawnSpec**：少了它，Node 会把我加好的\n        //    引号再转义一遍，cmd 收到 `\\\"npm.cmd install ...\\\"`，于是整行被当成命令名\n        //    （报\"'npm.cmd install ...' 不是内部或外部命令\"，npm 根本没被启动）。\n        const spawned = spawnSync(spawnSpec.command, spawnSpec.args, {\n            cwd: projectPath(),\n            timeout: NPM_TIMEOUT_MS,\n            windowsHide: true,\n            maxBuffer: 16 * 1024 * 1024,\n            windowsVerbatimArguments: spawnSpec.windowsVerbatimArguments,\n        });\n        return buildNpmResult({\n            command: formatNpmCommand(action, specs),\n            exitCode: typeof spawned.status === 'number' ? spawned.status : null,\n            stdout: decodeProcessOutput(spawned.stdout),\n            stderr: decodeProcessOutput(spawned.stderr),\n            spawnError: spawned.error\n                ? {\n                    code: (spawned.error as NodeJS.ErrnoException).code,\n                    message: spawned.error.message,\n                }\n                : null,\n        });\n    } catch (err: any) {\n        return buildNpmResult({\n            command: formatNpmCommand(action, specs),\n            exitCode: null,\n            stdout: '',\n            stderr: '',\n            spawnError: { message: err?.message ? String(err.message) : String(err) },\n        });\n    }\n}\n\n/**\n * 代跑 npm 装 / 卸一个公共模块，然后回一份刷新过的状态。\n *\n * 只接受 catalog 里存在的包名 —— 不把扩展变成\"任意 npm 命令执行器\"。\n */\n/**\n * 装一个**不属于公共模块**的包(框架、编辑器扩展自己)。\n *\n * 为什么不复用 runSharedAction:那条路的语义是\"从公共模块列表里装一个\",\n * 会先在 catalog 里查名字 —— 而框架与扩展**本来就被排除在公共模块列表之外**\n * (它们不该出现在使用者的公共模块页里),于是必然报\"不在可安装列表里的包\"。\n * 两件事的合法包集合不同,就不该共用一个入口。\n */\nasync function installProjectPackage(spec: string): Promise<{ ok: boolean; message: string | null; version: string | null }> {\n    if (!spec || typeof spec !== 'string') throw new Error('缺少包名');\n    const root = projectPath();\n    const command = 'npm install ' + spec;\n    const spawnSpec = npmSpawnSpec('install', [spec]);\n    const { result } = await runNpmAsync(command, spawnSpec, root, NPM_TIMEOUT_MS);\n    return {\n        ok: result.ok,\n        message: result.ok ? null : (result.hint ?? ('npm 退出码 ' + (result.exitCode ?? '未知'))),\n        version: null,\n    };\n}\n\nasync function runSharedAction(action: 'install' | 'uninstall', packageName: string | string[]) {\n    // 面板可能传字符串,也可能不小心包成数组 —— 两种都收,\n    // 别让\"少一个括号\"变成用户看到的\"缺少包名\"。\n    const wanted = Array.isArray(packageName) ? (packageName as any)[0] : packageName;\n    if (!wanted || typeof wanted !== 'string') {\n        throw new Error('缺少包名');\n    }\n\n    const before = await querySharedState();\n    const entry = before.modules.find((m) => m.name === wanted);\n    if (!entry) {\n        const known = before.modules.map((m) => m.name);\n        throw new Error(\n            `不在可安装列表里的包：${wanted}`\n            + (known.length ? `（当前列表：${known.join(', ')}）` : '（当前列表为空）'),\n        );\n    }\n\n    // 安装要把**本地能解析到的依赖一起带上**：只装它一个的话，npm 会去 registry 找依赖，\n    // 而本地源里的依赖并没有发布 —— 必然 E404（实测过）。\n    // 卸载按**包名**（npm 认包名，不认 file: 说明符）。\n    const specs = action === 'uninstall'\n        ? [entry.name]\n        : collectInstallSpecs(entry, before.modules);\n    const result = runNpm(action, specs);\n\n    // 装完立刻回一份新状态,面板不用再跑一次查询(注意 await!)\n    const after = await querySharedState();\n\n    return {\n        /**\n         * 失败**不抛异常**：面板需要拿到结构化的结果（命令、退出码、原始输出），\n         * 才能在弹窗里原样展示 npm 自己说的话。非法输入仍然抛 —— 那是调用方写错了。\n         */\n        ok: result.ok,\n        result,\n        /**\n         * 失败时一句**单行**摘要（面板消息区用）。完整输出在 `result` 里，由弹窗展示 ——\n         * 之前把整段 npm 输出塞进消息区，会把右栏挤变形并和消息叠在一起。\n         */\n        message: result.ok ? null : summarizeNpmFailure(action, wanted, result),\n        // ⚠️ querySharedState() 是 async —— 必须**先 await 再展开**。\n        //    写成 ...querySharedState() 展开的是 Promise(也就是 {}),返回对象里没有 modules,\n        //    面板 applySharedState 拿到 undefined -> **模块列表被清空**;而 ok/message 是字面量,\n        //    所以成功提示照常显示,看起来像\"装成功了但列表没了\",刷新一次才恢复(实测症状)。\n        ...after,\n    };\n}\n\n/** 资源是否存在 */\nfunction assetExists(url: string): Promise<boolean> {\n    return Editor.Message.request('asset-db', 'query-asset-info', url).then((info: unknown) => !!info);\n}\n\n/**\n * 确保目录存在，不存在则创建\n *\n * ⚠️ 目录在磁盘上、只是编辑器还没导入时**不能用 create-asset**：\n *    编辑器会弹「文件已存在，是否覆盖?」模态框（实测）。这种情况下刷新父目录即可。\n */\nasync function ensureDir(dirUrl: string): Promise<void> {\n    const info = await Editor.Message.request('asset-db', 'query-asset-info', dirUrl);\n    if (info) {\n        return;\n    }\n\n    const rel = dirUrl.replace(/^db:\\/\\//, '');\n    if (existsSync(join(projectPath(), rel))) {\n        const slash = rel.lastIndexOf('/');\n        const parentUrl = slash > 0 ? `db://${rel.slice(0, slash)}` : 'db://assets';\n        await Editor.Message.request('asset-db', 'refresh-asset', parentUrl);\n        return;\n    }\n\n    await Editor.Message.request('asset-db', 'create-asset', dirUrl, null);\n}\n\n/** 目录不存在则建，空目录则删掉（生成/删除后清理用） */\nasync function pruneEmptyDir(absDir: string): Promise<void> {\n    try {\n        if (statSync(absDir).isDirectory() && readdirSync(absDir).length === 0) {\n            removeSync(absDir);\n        }\n    } catch (e) {\n        /* 不存在就算了 */\n    }\n}\n\n/** 找出引用了指定 cid 集合的已序列化资源 */\nfunction findAssetRefs(snap: IProjectSnapshot, cids: string[]): string[] {\n    const hits: string[] = [];\n    if (!cids.length) {\n        return hits;\n    }\n    for (const rel of Object.keys(snap.serialized)) {\n        const text = snap.serialized[rel];\n        if (cids.some((cid) => text.includes(cid))) {\n            hits.push(rel);\n        }\n    }\n    return hits;\n}\n\n/* -------------------------------- 方法 -------------------------------- */\n\n/**\n * 把 node_modules 里的扩展拷进 extensions/。\n *\n * ⚠️ 必须是**模块级函数**,不能是 methods 里的方法:编辑器派发消息时不保证以 methods\n *    对象为 this,所以方法内部写 this.syncExtension(...) 会报 \"is not a function\"(实测就是这个 bug)。\n */\nfunction syncExtension(name: string) {\n    const root = projectPath();\n    const from = join(root, \"node_modules\", name);\n    if (!existsSync(from)) {\n        return { ok: false, message: \"node_modules 里没有 \" + name + \",先安装再落盘\" };\n    }\n    const to = join(root, \"extensions\", name.split(\"/\").pop() as string);\n    removeSync(to);\n    copySync(from, to);\n    // 回报**实际拷过去的版本**:这样面板能说\"已更新到 x.y.z\"而不是拿 latest 猜。\n    let version: string | null = null;\n    try {\n        version = JSON.parse(readFileSync(join(to, 'package.json'), 'utf8')).version ?? null;\n    } catch { /* 读不到就算了,不编一个 */ }\n    return { ok: true, path: to, version };\n}\n\n/**\n * 某些公共模块需要往工程里放一点资源(@ccgf/red-dot 的默认红点样式就是)。\n *\n * 为什么由扩展生成、而不是随模板发:模板属于\"每个新工程都有\"的东西,\n * 而公共模块是**可选安装**的 —— 给一个根本没装红点的工程带一个红点预制体才叫怪异。\n *\n * ⚠️ 刻意写成**模块级函数**而不是 methods 里的方法:它不是编辑器消息,\n *    放进 methods 会被\"没有注册的方法\"那条契约测试拦下来(而且那个测试是对的)。\n */\nasync function ensureScaffoldAssets(pkgName: string): Promise<string[]> {\n    const made: string[] = [];\n\n    // 模块 -> 安装时要生成到 resources 下的资源(路径不含扩展名)\n    const SCAFFOLD: Record<string, { path: string; build: () => any[] }> = {\n        '@ccgf/red-dot': { path: 'reddot/default', build: () => buildRedDotPrefab('default') },\n        '@ccgf/guide': { path: 'views/guide/GuideMaskView', build: () => buildGuideMaskPrefab('GuideMaskView') },\n    };\n\n    // 传进来的可能是 `@ccgf/guide` 也可能是 `@ccgf/guide@0.1.0` —— 按前缀匹配包名 ✓\n    // (之前直接 SCAFFOLD[wanted] 查不到,所以装了 guide 却没生成预制体 ✗)\n    const wanted = String(pkgName);\n    const key = Object.keys(SCAFFOLD).find((k) => wanted === k || wanted.startsWith(`${k}@`));\n    const spec = key ? SCAFFOLD[key] : undefined;\n    if (!spec) return made;\n\n    const parts = spec.path.split('/');\n    const dirPath = parts.slice(0, -1).join('/');\n    const dirUrl = `db://${RESOURCES_DIR}/${dirPath}`;\n    const url = `db://${RESOURCES_DIR}/${spec.path}.prefab`;\n\n    if (await assetExists(url)) return made;   // 已有就不覆盖(用户可能自己调过)\n\n    await ensureDir(dirUrl);\n    const content = JSON.stringify(spec.build());\n    const asset = await Editor.Message.request('asset-db', 'create-asset', url, content, { overwrite: false });\n    if (!asset) {\n        logToEditor('warn', `[ccgf] 生成默认资源失败:${url}`);\n        return made;\n    }\n    await Editor.Message.request('asset-db', 'refresh-asset', dirUrl);\n    made.push(`${RESOURCES_DIR}/${spec.path}.prefab`);\n    return made;\n}\n\n/**\n * 让资源库导入 assets/bundles 下新出现的目录树。\n *\n * ⚠️ **绝不能对\"磁盘上已存在\"的目录调 create-asset**：\n *    编辑器会弹「文件已存在，是否覆盖?」的模态框（实测,按钮是 覆盖/重命名/取消），\n *    整个创建流程卡在那里。目录是我们自己 mkdir 出来的，只需要 refresh 去导入。\n *\n * - asset-db 认识 assets/bundles → 刷新它；\n * - 不认识（目录在磁盘上、还没导入）→ 刷新父目录 db://assets，让它整棵扫进来。\n */\nasync function refreshBundlesRoot(): Promise<void> {\n    const rootUrl = `db://${BUNDLES_ROOT}`;\n    const known = await Editor.Message.request('asset-db', 'query-asset-info', rootUrl).catch(() => null);\n    await Editor.Message.request('asset-db', 'refresh-asset', known ? rootUrl : 'db://assets');\n}\n\n/** asset-db 是否已经认识这两个子目录（磁盘上有 ≠ 编辑器见过） */\nasync function bundleSubdirsImported(rel: string): Promise<boolean> {\n    for (const dir of [BUNDLE_SCRIPTS_SUBDIR, VIEWS_SUBDIR]) {\n        const info = await Editor.Message.request('asset-db', 'query-asset-info', `db://${rel}/${dir}`)\n            .catch(() => null);\n        if (!info) {\n            return false;\n        }\n    }\n    return true;\n}\n\n/**\n * 这个子包目录现在是什么状态（用来区分\"真的重复创建\"和\"上次失败留下的空壳\"）。\n *\n * `existsSync(abs)` 只能说明**磁盘上有个目录**；而\"子包存在\"应该是**结构齐全且已标记**。\n * 混为一谈时的表现：编辑器里看不到它（没导入/没标 Bundle）却提示\"已存在\"，用户没法继续。\n */\nfunction bundleState(abs: string): { missingDirs: string[]; marked: boolean } {\n    const missingDirs = [BUNDLE_SCRIPTS_SUBDIR, VIEWS_SUBDIR]\n        .filter((dir) => !existsSync(join(abs, dir)));\n    let marked = false;\n    try {\n        const meta = JSON.parse(readFileSync(abs + '.meta', 'utf8'));\n        marked = meta?.userData?.isBundle === true;\n    } catch {\n        marked = false;   // 没有 meta / meta 坏了 -> 编辑器眼里它还不是 bundle\n    }\n    return { missingDirs, marked };\n}\n\n/** 占位文件名：空目录在资源管理器里不显示，必须放个文件进去 */\nconst BUNDLE_README = 'README.md';\n\n/** 子目录里的占位说明（同时告诉人这里该放什么） */\nfunction bundleReadme(dir: string, bundle: string): string {\n    if (dir === BUNDLE_SCRIPTS_SUBDIR) {\n        return `# ${bundle}/scripts\n\n本子包的模块脚本放在这里：\n\n    assets/bundles/${bundle}/scripts/<模块名>/<前缀>Module.ts\n\n这个文件只是占位（别删）：资源的空目录不会被导入，放一个文件进来，\nscripts/ 才会出现在资源管理器里。\n`;\n    }\n    return `# ${bundle}/views\n\n本子包的 View 预制体放在这里：\n\n    assets/bundles/${bundle}/views/<模块名>/<类名>.prefab\n\n这个文件只是占位（别删）：资源的空目录不会被导入，放一个文件进来，\nviews/ 才会出现在资源管理器里。\n`;\n}\n\n/**\n * 建好 scripts/ + views/，并在里面各放一个占位 README（已有文件不覆盖）。\n *\n * 为什么要放文件：**空目录不会被资源库导入**，资源管理器里就看不到（实测）。\n * 文件优先走 create-asset —— 编辑器发出的才是\"新增文件\"事件，面板才会认。\n * 返回错误文案；成功为 null。\n */\nasync function ensureBundleLayout(abs: string, name: string, rel: string): Promise<string | null> {\n    try {\n        const fs = await import('fs/promises');\n        for (const dir of [BUNDLE_SCRIPTS_SUBDIR, VIEWS_SUBDIR]) {\n            const dirAbs = join(abs, dir);\n            await fs.mkdir(dirAbs, { recursive: true });\n\n            const readmeAbs = join(dirAbs, BUNDLE_README);\n            if (existsSync(readmeAbs)) {\n                continue;\n            }\n            const made = await Editor.Message.request(\n                'asset-db', 'create-asset', `db://${rel}/${dir}/${BUNDLE_README}`,\n                bundleReadme(dir, name), { overwrite: false },\n            ).catch(() => null);\n            if (!made) {\n                // 编辑器建不了(父目录还没导入等)就落盘,后面 refresh 会补上\n                await fs.writeFile(readmeAbs, bundleReadme(dir, name), { flag: 'wx' })\n                    .catch(() => undefined);\n            }\n        }\n        return null;\n    } catch (e: any) {\n        return `创建目录失败:${abs}(${e?.message || e})`;\n    }\n}\n\n/**\n * 建（或补齐）一个子包：目录树 -> refresh 导入 -> 标 Bundle -> 确认子目录被编辑器认到。\n *\n * @param repairing 目录本来就存在（上次失败留下的壳）—— 只补缺的，不覆盖任何东西\n */\nasync function buildBundle(name: string, rel: string, abs: string, repairing: boolean): Promise<{\n    ok: boolean;\n    message: string;\n    bundle?: string;\n    dir?: string;\n    marked?: boolean;\n    repaired?: boolean;\n    existed?: boolean;\n}> {\n    // 1) 目录优先用**编辑器自己的 create-asset** 创建。\n    //    为什么:资源管理器面板只认 create-asset 发出的 \"新增资源\" 事件;先 fs.mkdir\n    //    再用 refresh 导入时,asset-db 会有记录、面板却没有 —— 之后任何 change 事件都会\n    //    报 \"Can not change the asset ... original asset is not exist\"(实测)。\n    //    磁盘上已存在的目录不能走 create-asset(会弹「是否覆盖」),只能记下来走 refresh。\n    let needRefresh = false;\n    for (const dirRel of [\n        BUNDLES_ROOT,\n        rel,\n        `${rel}/${BUNDLE_SCRIPTS_SUBDIR}`,\n        `${rel}/${VIEWS_SUBDIR}`,\n    ]) {\n        const url = `db://${dirRel}`;\n        const absDir = join(projectPath(), dirRel);\n\n        if (existsSync(absDir)) {\n            // 磁盘上已有目录:不能 create-asset。DB 不认识的只能 refresh。\n            const known = await Editor.Message.request('asset-db', 'query-asset-info', url).catch(() => null);\n            if (!known) {\n                needRefresh = true;\n            }\n            continue;\n        }\n\n        // 磁盘上没有 -> 一律走 create-asset。\n        // ⚠️ 这里**不能先看 query-asset-info**:编辑器重启/删改后 DB 可能留着旧记录,\n        //    \"DB 说有、磁盘没有\"时若跳过 create-asset,就只剩后面的 fs.mkdir,\n        //    面板永远收不到新增事件(实测:18:22 那次就是这样)。\n        const made = await Editor.Message.request('asset-db', 'create-asset', url, null).catch(() => null);\n        if (!made) {\n            needRefresh = true;\n        }\n    }\n\n    // 2) 磁盘上补齐(编辑器没建成/旧状态时兜底):目录 + 占位 README\n    const layoutError = await ensureBundleLayout(abs, name, rel);\n    if (layoutError) {\n        return { ok: false, message: layoutError };\n    }\n\n    // 3) 让编辑器导入这棵树(才有 .meta 可写)\n    try {\n        if (needRefresh) {\n            await refreshBundlesRoot();\n        }\n    } catch (e: any) {\n        return {\n            ok: false,\n            message: `已创建 ${rel},但资源库刷新失败:${e?.message || e};请在资源管理器里刷新一次再重试`,\n        };\n    }\n\n    // 4) 自动勾上「配置为 Bundle」:3.8 没有公开的 asset-db 消息,只能改 .meta 的 userData\n    const marked = await markAsBundle(name);\n    if (marked) {\n        // 让编辑器重新读一遍 meta —— 否则它内存里还是 userData:{}\n        await Editor.Message.request('asset-db', 'refresh-asset', `db://${rel}`).catch(() => undefined);\n    }\n\n    // 5) 确认两个子目录进了 asset-db;没有就再刷一次(老状态兜底)\n    for (let attempt = 0; attempt < 2; attempt++) {\n        if (await bundleSubdirsImported(rel)) {\n            break;\n        }\n        const url = attempt === 0 ? `db://${BUNDLES_ROOT}` : 'db://assets';\n        await Editor.Message.request('asset-db', 'refresh-asset', url).catch(() => undefined);\n    }\n\n    // 6) 磁盘结构自检:别让\"空包\"再静默发生\n    const missing = [BUNDLE_SCRIPTS_SUBDIR, VIEWS_SUBDIR].filter((dir) => !existsSync(join(abs, dir)));\n    if (missing.length) {\n        return { ok: false, message: `目录结构不完整:${rel} 缺 ${missing.join(' / ')}` };\n    }\n\n    await setTargetBundle(name);\n\n    const verb = repairing ? '已补齐' : '已创建';\n    notifyTableDirsChanged();\n    return {\n        ok: true,\n        bundle: name,\n        dir: rel,\n        marked,\n        repaired: repairing,\n        message: marked\n            ? `${verb} ${rel}(scripts/ + views/),并已标记为 Bundle;目标包切到 ${name}。`\n            : `${verb} ${rel}(scripts/ + views/),目标包切到 ${name};`\n                + '但 .meta 里没能写上 isBundle,请在资源管理器里手动勾选「配置为 Bundle」。',\n    };\n}\n\n/**\n * 新建子包:建预设目录树 -> 自动标记为 Asset Bundle -> 切当前目标包 ✓\n *\n * ⚠️ 目录**直接落盘**,不用 asset-db 的 create-asset 逐层建：\n *    实测那样建出来的新包是空的（子目录的 create-asset 静默返回 null，不报错）。\n *    落盘后再 refresh-asset 让编辑器导入，导入时会补上各级 .meta。\n */\nexport async function createBundle(bundleName: string): Promise<{\n    ok: boolean;\n    message: string;\n    bundle?: string;\n    dir?: string;\n    marked?: boolean;\n    repaired?: boolean;\n    existed?: boolean;\n}> {\n    const name = (bundleName || '').trim();\n    if (!/^[a-z][a-z0-9_]*$/.test(name)) {\n        return { ok: false, message: '子包名只能用小写字母/数字/下划线,且字母开头' };\n    }\n\n    const rel = `${BUNDLES_ROOT}/${name}`;\n    const abs = join(projectPath(), rel);\n\n    if (!existsSync(abs)) {\n        return await buildBundle(name, rel, abs, false);\n    }\n\n    // 目录已存在 ≠ 子包已存在:要么是真的重复创建(结构齐全 + 已标 Bundle),\n    // 要么只是上次失败留下的空壳(没 scripts/ views/、没 isBundle)。后者直接补齐。\n    const state = bundleState(abs);\n    if (state.missingDirs.length === 0 && state.marked) {\n        // 幂等:再点一次\"创建\"不该报错。当成\"选中它\";顺手补占位文件并 refresh，\n        // 让磁盘上没有 README 的旧包也能在资源管理器里显示出来。\n        const layoutError = await ensureBundleLayout(abs, name, rel);\n        if (layoutError) {\n            return { ok: false, message: layoutError };\n        }\n        await setTargetBundle(name);\n        await refreshBundlesRoot().catch(() => undefined);\n        await Editor.Message.request('asset-db', 'refresh-asset', `db://${rel}`).catch(() => undefined);\n        notifyTableDirsChanged();\n        return {\n            ok: true,\n            bundle: name,\n            dir: rel,\n            marked: true,\n            existed: true,\n            message: `子包已存在:${rel}(scripts/ + views/ 齐全,已标记 Bundle);目标包已切到 ${name}。`,\n        };\n    }\n    return await buildBundle(name, rel, abs, true);\n}\n\n/** 列出所有子包 */\nexport async function queryBundles(): Promise<{ current: string; list: string[] }> {\n    await ensureTargetBundleLoaded();\n    const list = await listBundles();\n    const current = getTargetBundle();\n\n    // Profile 里记着的包可能已经不在了(改名/删目录/换工程):\n    // 退回主包并落盘,否则创建类命令会悄悄落到一个没人认识的目录里\n    if (current && !list.includes(current)) {\n        await setTargetBundle('');\n        return { current: '', list };\n    }\n\n    return { current, list };\n}\n\n/**\n * 切换\"当前目标包\"('' = 主包)。\n *\n * 名字必须真的在 assets/bundles 下:否则 create-module / create-view 会落到一个\n * 编辑器不认识、下拉里也看不到的幽灵目录。\n */\nexport async function setBundle(bundleName: string): Promise<{ current: string }> {\n    const name = (bundleName || '').trim();\n    if (name) {\n        const known = await listBundles();\n        if (!known.includes(name)) {\n            throw new Error(`子包不存在:${name}(assets/bundles 下没有这个目录)`);\n        }\n    }\n    await setTargetBundle(name);\n    return { current: getTargetBundle() };\n}\n\n/**\n * 删除一个子包(连同 scripts/ views/ 下的全部内容)。\n *\n * 优先走 asset-db 的 `delete-asset`:它会同时删磁盘、清索引并通知资源管理器,\n * 不会留下\"磁盘删了、编辑器还记着\"的错位。编辑器不认识这个目录时才直接删盘 + refresh。\n *\n * 如果删的正是当前目标包,删完自动切回主包(绝不把目标留在不存在的目录上)。\n */\nexport async function deleteBundle(bundleName: string): Promise<{\n    ok: boolean;\n    message: string;\n    name?: string;\n    current?: string;\n}> {\n    const name = (bundleName || '').trim();\n    if (!name) {\n        return { ok: false, message: '不能删除主包' };\n    }\n    if (!/^[a-z][a-z0-9_]*$/.test(name)) {\n        return { ok: false, message: `非法的子包名: \"${name}\"` };\n    }\n\n    const rel = `${BUNDLES_ROOT}/${name}`;\n    const abs = join(projectPath(), rel);\n    if (!existsSync(abs)) {\n        return { ok: false, message: `子包不存在:${rel}` };\n    }\n\n    const url = `db://${rel}`;\n    const info = await Editor.Message.request('asset-db', 'query-asset-info', url).catch(() => null);\n    if (info) {\n        await Editor.Message.request('asset-db', 'delete-asset', url);\n    }\n\n    // 编辑器没删干净(或它根本不认识这个目录)时直接删盘\n    if (existsSync(abs)) {\n        removeSync(abs);\n    }\n    if (existsSync(abs)) {\n        return { ok: false, message: `删除失败:${rel}(可能被占用,关掉打开它的窗口再试)` };\n    }\n\n    await refreshBundlesRoot().catch(() => undefined);\n\n    if (getTargetBundle() === name) {\n        await setTargetBundle('');\n    }\n\n    notifyTableDirsChanged();\n    return { ok: true, name, current: getTargetBundle(), message: `已删除子包:${rel}` };\n}\n\n/**\n * 生成脚本里到 `framework/` 的相对前缀(只对 workspace 模式有意义)。\n *\n * 主包模块在 `assets/scripts/gameplay/<m>`,回 `assets/scripts` 是 2/3 层 —— 返回 '' 用模板默认值。\n *\n * 子包模块在 `assets/bundles/<n>/scripts/<m>`:上到 `assets` 之后**不在 scripts 里**,\n * 还要再进一层 `scripts/`,所以是\"4/5 层 + scripts/\",**不是**主包基础上多几个 `../`。\n * (模块 4 层、View 5 层;写错过一次,集成测试盯着生成结果。)\n */\nfunction frameworkBase(kind: 'module' | 'view'): string {\n    if (!getTargetBundle()) {\n        return '';\n    }\n    const up = kind === 'view' ? 5 : 4;\n    return '../'.repeat(up) + 'scripts/';\n}\n\nexport const methods: { [key: string]: (...any: any) => any } = {\n    createBundle,\n    queryBundles,\n    setBundle,\n    deleteBundle,\n    /** 更新框架:直接按 spec 装,不进公共模块列表 */\n    async updateFrameworkPackage() {\n        return installProjectPackage('@ccgf/framework@latest');\n    },\n\n    /** 更新扩展:装到 node_modules 后**必须**落到 extensions/ —— 编辑器只认那里 */\n    async updateExtensionPackage() {\n        const r = await installProjectPackage('ccgf-game-tool@latest');\n        if (!r.ok) return r;\n        const s = syncExtension('ccgf-game-tool');\n        return { ok: s.ok !== false, message: s.message ?? null, version: s.version ?? null };\n    },\n\n    /**\n     * 框架与扩展各自的版本信息(本地 + npm 最新)。\n     *\n     * 扩展自身版本读它自己的 package.json;框架版本读工程 node_modules 里的那份 ——\n     * 两者都是\"实际装了什么\"的事实,不是配置里写了什么。\n     * 有没有新版交给面板比较 version 与 latest,这里不替它判断(免得两边各写一套)。\n     */\n    /**\n     * 把 node_modules 里的扩展拷进 extensions/。\n     *\n     * 编辑器**只从工程的 extensions/ 加载扩展**,所以 npm install 完必须落这一盘,\n     * 否则\"更新成功\"只发生在 node_modules 里,编辑器里一点变化都没有。\n     * 落盘之后需要重启编辑器才生效 —— 这一点由面板文案告知,这里不假装热更新。\n     */\n    syncExtension,\n\n    async queryVersions(forceRegistry = false) {\n        const root = projectPath();\n        const registry = await queryRegistry(forceRegistry);\n        const latestOf = (name: string): string | null => {\n            const hit = registry.entries.find((entry) => entry.name === name);\n            return hit ? hit.version : null;\n        };\n\n        const frameworkName = '@ccgf/framework';\n        const framework = readInstalledPackage(root, frameworkName);\n\n        /** 本仓库的开发工作区:框架是源码、扩展就是这一份 —— 面板据此改称呼并禁用更新 */\n        const inWorkspace = existsSync(join(root, 'assets/scripts/framework'));\n\n        return {\n            framework: {\n                name: frameworkName,\n                installed: framework.installed,\n                workspace: inWorkspace,\n                version: framework.version,\n                latest: latestOf(frameworkName),\n            },\n            extension: {\n                name: packageJSON.name,\n                version: packageJSON.version,\n                workspace: inWorkspace,\n                latest: latestOf(packageJSON.name),\n            },\n        };\n    },\n    openWorkbench() {\n        Editor.Panel.open(`${packageJSON.name}.workbench`);\n    },\n\n    /** 独立的数据表工具面板（与工作台完全分开） */\n    openTableTool() {\n        Editor.Panel.open(`${packageJSON.name}.table-tool`);\n    },\n\n    /** 扫描工程根目录 tables/ 下的 CSV */\n    queryTables() {\n        try {\n            const files = scanTables(projectPath());\n            const duplicates = findDuplicateTableNames(files).map(\n                (d) => `表名 \"${d.name}\" 重复：${d.files.join(' / ')}`,\n            );\n\n            // 建表时的目录候选：resources/tables + 每个 bundle 的 tables + 已有 CSV 的目录\n            const dirs = new Set<string>(['resources/tables']);\n            const bundles = new Set<string>();\n            const bundlesRoot = join(projectPath(), 'assets', 'bundles');\n            if (existsSync(bundlesRoot)) {\n                for (const entry of readdirSync(bundlesRoot, { withFileTypes: true })) {\n                    if (entry.isDirectory()) {\n                        bundles.add(entry.name);\n                        dirs.add(`bundles/${entry.name}/tables`);\n                    }\n                }\n            }\n\n            const bundleNameOf = (rel: string): string => {\n                const match = /^bundles\\/([^/]+)\\//.exec(rel);\n                return match ? match[1] : '';\n            };\n            const bundleExists = (name: string): boolean =>\n                !name || existsSync(join(projectPath(), 'assets', 'bundles', name));\n\n            for (const file of files) {\n                const dir = dirname(file.relative).replace(/\\\\/g, '/');\n                const bundleName = bundleNameOf(file.relative);\n                if (dir && dir !== '.' && bundleExists(bundleName)) {\n                    if (bundleName) bundles.add(bundleName);\n                    dirs.add(dir);\n                }\n            }\n\n            return {\n                ok: true,\n                root: 'tables',\n                dirs: [...dirs].sort(),\n                bundles: [...bundles].sort(),\n                tables: files.map((f) => {\n                    const bundleName = bundleNameOf(f.relative);\n                    const missingBundle = !bundleExists(bundleName);\n                    return {\n                        relative: f.relative,\n                        binRelative: f.binRelative,\n                        absolute: f.absolute,\n                        tableName: f.tableName,\n                        note: f.note,\n                        error: f.error || (missingBundle\n                            ? `目标 bundle 不存在：assets/bundles/${bundleName}（请先新建 Bundle）`\n                            : undefined),\n                    };\n                }),\n                duplicates,\n            };\n        } catch (e) {\n            return { ok: false, error: tableErrorText(e), dirs: [], bundles: [], tables: [], duplicates: [] };\n        }\n    },\n\n    /**\n     * 新建表骨架（只有 ID 一列）。\n     * @param payload { dir: 相对 tables/ 的目录；fileName: 表名_备注 }\n     */\n    createTableFile(payload: { dir?: string; fileName?: string } = {}) {\n        const dir = (payload.dir ?? '').trim();\n        const fileName = (payload.fileName ?? '').trim();\n        if (!dir) return { ok: false, error: '目录不能为空' };\n        if (!fileName) return { ok: false, error: '文件名不能为空' };\n\n        try {\n            const info = createTableOnDisk(projectPath(), dir, fileName);\n            return { ok: true, info };\n        } catch (e) {\n            return { ok: false, error: tableErrorText(e) };\n        }\n    },\n\n    /**\n     * 导出数据表：paths 为空 = 全部；否则只导出指定相对路径。\n     * 导出成功后自动 refresh asset-db。\n     */\n    async exportTables(payload: { paths?: string[] } = {}) {\n        try {\n            const project = projectPath();\n            const files = scanTables(project);\n            assertUniqueTableNames(files);\n\n            const wanted = Array.isArray(payload.paths) ? payload.paths : [];\n            const targets = wanted.length > 0\n                ? files.filter((f) => wanted.includes(f.relative))\n                : files;\n\n            if (targets.length === 0) {\n                return { ok: false, error: '没有可导出的表', results: [], errors: [] };\n            }\n\n            const results: Array<{ relative: string; binRelative: string; tableName: string; bytes: number }> = [];\n            const errors: string[] = [];\n            const warnings: string[] = [];\n            for (const file of targets) {\n                try {\n                    assertBundleTarget(project, file.relative);\n                    const built = buildTable(project, file.relative);\n                    const warning = await writeTableAsset(project, built);\n                    results.push({\n                        relative: file.relative,\n                        binRelative: built.binRelative,\n                        tableName: built.name,\n                        bytes: built.buffer.length,\n                    });\n                    if (warning) {\n                        warnings.push(`${built.binRelative}：${warning}`);\n                    }\n                } catch (e) {\n                    errors.push(tableErrorText(e, file.relative));\n                }\n            }\n\n            if (results.length > 0) {\n                try {\n                    warnings.push(...await generateTableTypes(project, files));\n                } catch (e) {\n                    warnings.push(`TableTypes.ts 生成失败：${e instanceof Error ? e.message : String(e)}`);\n                }\n            }\n\n            return { ok: errors.length === 0, results, errors, warnings };\n        } catch (e) {\n            return { ok: false, error: tableErrorText(e), results: [], errors: [], warnings: [] };\n        }\n    },\n\n    /** 面板的层级下拉由主进程下发，避免扩展里出现第二份层级列表 */\n    queryLayers(): string[] {\n        return [...LAYERS];\n    },\n\n    /**\n     * 面板文案：以 i18n/zh.js 的 key 全集为准，逐个交给编辑器 i18n 解析当前语言。\n     * 这样面板侧不需要判断语言，也不依赖 Editor.I18n 是否存在于面板上下文里。\n     */\n    queryI18n(): Record<string, string> {\n        const table: Record<string, string> = {};\n        for (const key of Object.keys(ZH_STRINGS)) {\n            const full = `${packageJSON.name}.${key}`;\n            let text = ZH_STRINGS[key];\n            try {\n                const hit = Editor.I18n.t(full);\n                if (hit && hit !== full) {\n                    text = hit;\n                }\n            } catch (e) {\n                /* 编辑器 i18n 不可用就保留中文 */\n            }\n            table[key] = text;\n        }\n        return table;\n    },\n\n    /** 预制体模板列表（供面板下拉） */\n    queryTemplates(): Array<{ id: string; label: string }> {\n        return PREFAB_TEMPLATES.map((id) => ({ id, label: PREFAB_TEMPLATE_LABELS[id] }));\n    },\n\n    /**\n     * 查询 gameplay 下已有的模块列表（含 order）。\n     * 与体检共用 doctor.listModules，保证面板显示和体检判定一致。\n     */\n    async queryModules() {\n        await ensureTargetBundleLoaded();\n        const snap = snapshot();\n        return listModules(snap).map((m) => ({\n            name: m.dir,\n            order: m.order ?? 0,\n            hasModel: m.modelFile !== null,\n            hasModule: true,\n            // 面板用这三个路径做「一键打开脚本」；eventsFile 可能为 null（老模块）\n            moduleFile: m.moduleFile,\n            modelFile: m.modelFile,\n            eventsFile: m.eventsFile,\n        }));\n    },\n\n    /** 启动顺序预览 + 层级占用（开发辅助） */\n    async queryOverview() {\n        await ensureTargetBundleLoaded();\n        const snap = snapshot();\n        const views = listViews(snap);\n        const usage = LAYERS.map((layer) => ({\n            layer,\n            views: views.filter((v) => v.registeredLayer === layer).map((v) => v.className),\n        }));\n        const modules = listModules(snap);\n        return {\n            order: buildOrderPlan(snap),\n            layers: usage,\n            moduleCount: modules.length,\n            managerCount: listManagers(snap).length,\n            viewCount: views.length,\n        };\n    },\n\n    /** 一键体检 */\n    async runDoctor(): Promise<{ findings: IFinding[]; summary: Record<string, number> }> {\n        await ensureTargetBundleLoaded();\n        const findings = runDoctor(snapshot(), LAYERS);\n        const summary = { error: 0, warn: 0, info: 0 };\n        for (const f of findings) {\n            summary[f.severity] = (summary[f.severity] ?? 0) + 1;\n        }\n        return { findings, summary };\n    },\n\n    /**\n     * 查询某模块的 View 列表。\n     * 比旧实现多了 prefabExists —— 旧版按约定拼 URL 却从不查盘，\n     * 于是“脚本在、预制体丢了”的 View 也会被列出来，点了才失败。\n     */\n    async queryViews(moduleName: string) {\n        if (!moduleName || !IDENTIFIER_RE.test(moduleName)) {\n            throw new Error(`非法的模块名: \"${moduleName}\"`);\n        }\n        await ensureTargetBundleLoaded();\n        const moduleDir = normalizeModule(moduleName).dir;\n        const snap = snapshot();\n        return listViews(snap)\n            .filter((v) => v.moduleDir === moduleDir)\n            .map((v) => ({\n                name: v.className,\n                scriptUrl: dbUrl(v.scriptFile),\n                prefabUrl: v.registeredPath ? dbUrl(`${prefabKeyRoot()}/${v.registeredPath}.prefab`) : '',\n                prefabExists: v.registeredPath ? snap.prefabsByResourcePath[v.registeredPath] !== undefined : false,\n                layer: v.registeredLayer ?? '',\n            }));\n    },\n\n    /* ------------------------------ manager ------------------------------ */\n\n    /** manager 列表（assets/scripts/manager 下直属的 *Manager.ts） */\n    async queryManagers() {\n        return listManagers(snapshot()).map((m) => ({\n            name: m.className,\n            file: m.scriptFile,\n            extendsSingleton: m.extendsSingleton,\n            baseClass: m.baseClass,\n            order: m.order,\n        }));\n    },\n\n    /**\n     * 创建 manager：生成一个继承框架 ASingleton 的全局单例脚本。\n     * @param managerName 名字，如 \"config\" / \"Config\" / \"ConfigManager\"\n     */\n    async createManager(managerName: string, order: number = 40) {\n        if (!managerName || !IDENTIFIER_RE.test(managerName)) {\n            throw new Error(`非法的 manager 名: \"${managerName}\"，请使用合法的标识符`);\n        }\n        const className = normalizeManagerName(managerName);\n        // 和 createModule 一样先校验 order：非法值不该写进生成出来的代码\n        if (typeof order !== 'number' || !Number.isFinite(order) || order < 0) {\n            throw new Error(`非法的 order: ${order}`);\n        }\n        const dirUrl = `db://${MANAGER_DIR}`;\n        await ensureDir(dirUrl);\n\n        const scriptUrl = `${dirUrl}/${className}.ts`;\n        if (await assetExists(scriptUrl)) {\n            throw new Error(`manager 已存在：${className}.ts（如需重建，请先删除它）`);\n        }\n\n        const asset = await Editor.Message.request(\n            'asset-db', 'create-asset', scriptUrl, buildManagerScript(className, frameworkImportMode(), order), { overwrite: false },\n        );\n        if (!asset) {\n            throw new Error(`创建 manager 失败: ${scriptUrl}`);\n        }\n\n        await Editor.Message.request('asset-db', 'refresh-asset', dirUrl);\n        return { className, scriptUrl, file: `${MANAGER_DIR}/${className}.ts` };\n    },\n\n    /**\n     * 更新 manager 的 order：写回脚本里的 @RegisterManager({order: N})。\n     *\n     * 和模块一样**直接改源文件** —— 不引入第二份真相（改完在编辑器里看得见）。\n     */\n    async updateManagerOrder(managerName: string, order: number) {\n        if (!managerName || !IDENTIFIER_RE.test(managerName)) {\n            throw new Error(`非法的 manager 名: \"${managerName}\"，请使用合法的标识符`);\n        }\n        if (typeof order !== 'number' || !Number.isFinite(order) || order < 0) {\n            throw new Error(`非法的 order: ${order}`);\n        }\n        const className = normalizeManagerName(managerName);\n        const relFile = `${MANAGER_DIR}/${className}.ts`;\n        const abs = join(projectPath(), relFile);\n        if (!existsSync(abs)) {\n            throw new Error(`找不到 manager 脚本：${relFile}`);\n        }\n        const content = readFileSync(abs, 'utf8');\n        if (!/order\\s*:\\s*\\d+/.test(content)) {\n            throw new Error(`未在 ${relFile} 中找到 order 字段（应为 @RegisterManager({ order: N })）`);\n        }\n        writeFileSync(abs, content.replace(/order\\s*:\\s*\\d+/, `order: ${order}`), 'utf8');\n        await Editor.Message.request('asset-db', 'refresh-asset', `db://${MANAGER_DIR}`);\n        return { className, file: relFile, order };\n    },\n    /** 删除 manager 脚本 */\n    async deleteManager(managerName: string) {\n        if (!managerName || !IDENTIFIER_RE.test(managerName)) {\n            throw new Error(`非法的 manager 名: \"${managerName}\"`);\n        }\n        const className = normalizeManagerName(managerName);\n        const scriptUrl = `db://${MANAGER_DIR}/${className}.ts`;\n\n        const info = await Editor.Message.request('asset-db', 'query-asset-info', scriptUrl);\n        if (!info) {\n            throw new Error(`找不到 manager 脚本：${className}.ts`);\n        }\n        await Editor.Message.request('asset-db', 'delete-asset', scriptUrl);\n        await Editor.Message.request('asset-db', 'refresh-asset', `db://${MANAGER_DIR}`);\n        return { className, removed: scriptUrl };\n    },\n\n    /**\n     * 删除模块前的引用检查：哪些资源引用了该模块的脚本。\n     * 面板在确认框里展示，避免删完留下悬空引用。\n     */\n    async queryModuleRefs(moduleName: string) {\n        if (!moduleName || !IDENTIFIER_RE.test(moduleName)) {\n            throw new Error(`非法的模块名: \"${moduleName}\"`);\n        }\n        await ensureTargetBundleLoaded();\n        const moduleDir = normalizeModule(moduleName).dir;\n        const snap = snapshot();\n        const views = listViews(snap).filter((v) => v.moduleDir === moduleDir);\n        const cids = views.map((v) => snap.scriptCids[v.scriptFile]).filter(Boolean);\n        const moduleCid = snap.scriptCids[`${scriptsRoot()}/${moduleDir}/${normalizeModule(moduleName).moduleClass}.ts`];\n        const allCids = moduleCid ? cids.concat([moduleCid]) : cids;\n        return {\n            views: views.map((v) => v.className),\n            referencedBy: findAssetRefs(snap, allCids),\n        };\n    },\n\n    /** 在编辑器里打开某个工程内文件（体检结果/概览点击定位用） */\n    async openSource(relPath: string) {\n        if (!relPath || relPath.includes('..')) {\n            throw new Error(`非法的路径: \"${relPath}\"`);\n        }\n        const url = dbUrl(relPath);\n        // 先确认资源存在且已被编辑器导入，再谈打开；否则给出明确原因\n        const info = await Editor.Message.request('asset-db', 'query-asset-info', url);\n        if (!info) {\n            throw new Error(`资源不存在或未被编辑器导入: ${relPath}`);\n        }\n        await Editor.Message.request('asset-db', 'open-asset', url);\n        return { url };\n    },\n\n    /**\n     * 创建模块：生成 Module + Model + 事件声明 三个脚本。\n     * @param moduleName 模块名，如 \"bag\" / \"Bag\" / \"BagModule\"\n     * @param order      模块启动顺序\n     */\n    async createModule(moduleName: string, order: number) {\n        await ensureTargetBundleLoaded();\n        if (!moduleName || !IDENTIFIER_RE.test(moduleName)) {\n            throw new Error(`非法的模块名: \"${moduleName}\"，请使用合法的标识符`);\n        }\n        if (typeof order !== 'number' || !Number.isFinite(order) || order < 0) {\n            throw new Error(`非法的 order: ${order}`);\n        }\n\n        const naming = normalizeModule(moduleName);\n        const moduleDirUrl = `db://${scriptsRoot()}/${naming.dir}`;\n\n        // 先查存在性，给出明确原因（旧版只在 create-asset 返回空时说“可能已存在”）\n        const moduleUrl = `${moduleDirUrl}/${naming.moduleClass}.ts`;\n        const modelUrl = `${moduleDirUrl}/${naming.modelClass}.ts`;\n        const eventsUrl = `${moduleDirUrl}/${naming.eventsName}.ts`;\n        if (await assetExists(moduleUrl)) {\n            throw new Error(`模块已存在：${naming.moduleClass}.ts（如需重建，请先删除该模块）`);\n        }\n        if (await assetExists(modelUrl)) {\n            throw new Error(`模型已存在：${naming.modelClass}.ts（如需重建，请先删除该模块）`);\n        }\n        if (await assetExists(eventsUrl)) {\n            throw new Error(`事件声明已存在：${naming.eventsName}.ts（如需重建，请先删除该模块）`);\n        }\n\n        await ensureDir(moduleDirUrl);\n\n        /** 已创建成功的资源；任一步失败时按逆序回滚，避免留下半成品 */\n        const created: string[] = [];\n        const createOrRollback = async (url: string, content: string, label: string): Promise<void> => {\n            const asset = await Editor.Message.request(\n                'asset-db', 'create-asset', url, content, { overwrite: false },\n            );\n            if (!asset) {\n                const count = created.length;\n                for (const done of created.reverse()) {\n                    await Editor.Message.request('asset-db', 'delete-asset', done).catch(() => undefined);\n                }\n                await Editor.Message.request('asset-db', 'refresh-asset', moduleDirUrl);\n                throw new Error(\n                    `创建${label}失败: ${url}${count > 0 ? `（已回滚 ${count} 个文件）` : ''}`,\n                );\n            }\n            created.push(url);\n        };\n\n        await createOrRollback(\n            moduleUrl, buildModuleScript(naming.moduleClass, naming.modelClass, order, frameworkImportMode(), frameworkBase('module'), getTargetBundle()), '模块',\n        );\n        await createOrRollback(modelUrl, buildModelScript(naming.modelClass, frameworkImportMode(), frameworkBase('module')), '模型');\n        await createOrRollback(eventsUrl, buildEventsScript(naming.dir, naming.moduleClass), '事件声明');\n\n        await Editor.Message.request('asset-db', 'refresh-asset', moduleDirUrl);\n\n        return {\n            dirName: naming.dir,\n            prefix: naming.prefix,\n            moduleUrl,\n            modelUrl,\n            eventsUrl,\n            order,\n        };\n    },\n\n    /**\n     * 更新模块的 order：写回 Module 脚本的 @RegisterModule({order})。\n     */\n    async updateModuleOrder(moduleName: string, order: number) {\n        if (!moduleName || !IDENTIFIER_RE.test(moduleName)) {\n            throw new Error(`非法的模块名: \"${moduleName}\"`);\n        }\n        if (typeof order !== 'number' || !Number.isFinite(order) || order < 0) {\n            throw new Error(`非法的 order: ${order}`);\n        }\n\n        const moduleDir = normalizeModule(moduleName).dir;\n        const moduleDirPath = join(projectPath(), scriptsRoot(), moduleDir);\n\n        let files: string[] = [];\n        try {\n            files = readdirSync(moduleDirPath);\n        } catch (e) {\n            throw new Error(`找不到模块目录: ${moduleDir}`);\n        }\n        const moduleFile = files.find((f) => f.endsWith('Module.ts'));\n        if (!moduleFile) {\n            throw new Error(`找不到模块脚本: ${moduleDir}`);\n        }\n\n        const fullPath = join(moduleDirPath, moduleFile);\n        const content = readFileSync(fullPath, 'utf-8');\n        const newContent = content.replace(/order\\s*:\\s*\\d+/, `order: ${order}`);\n        if (newContent === content) {\n            throw new Error(`未在 ${moduleFile} 中找到 order 字段`);\n        }\n        writeFileSync(fullPath, newContent);\n\n        await Editor.Message.request('asset-db', 'refresh-asset', dbUrl(`${scriptsRoot()}/${moduleDir}`));\n\n        return { moduleName: moduleDir, order };\n    },\n\n    /**\n     * 创建 View：在指定模块下生成脚本 + 预制体，并把脚本挂载到预制体根节点。\n     * @param template 预制体模板，见 constants.PREFAB_TEMPLATES\n     */\n    async createView(moduleName: string, viewName: string, layer: string, template: string = 'empty') {\n        await ensureTargetBundleLoaded();\n        if (!moduleName || !IDENTIFIER_RE.test(moduleName)) {\n            throw new Error(`非法的模块名: \"${moduleName}\"`);\n        }\n        if (!viewName || !IDENTIFIER_RE.test(viewName)) {\n            throw new Error(`非法的视图名: \"${viewName}\"，请使用合法的标识符`);\n        }\n        if (!LAYERS.includes(layer as any)) {\n            throw new Error(`非法的层级: \"${layer}\"（合法值：${LAYERS.join(', ')}）`);\n        }\n        if (!isPrefabTemplate(template)) {\n            throw new Error(`非法的预制体模板: \"${template}\"（合法值：${PREFAB_TEMPLATES.join(', ')}）`);\n        }\n\n        const moduleDir = normalizeModule(moduleName).dir;\n        const className = normalizeViewName(viewName);\n        const prefabPath = viewPrefabPath(moduleDir, className);\n\n        // 跨模块重名会加载错预制体（ViewManager 按类名全局查找），提前挡住\n        const snap = snapshot();\n        const clash = listViews(snap).find(\n            (v) => v.className === className && v.moduleDir !== moduleDir,\n        );\n        if (clash) {\n            throw new Error(\n                `View 名字 \"${className}\" 已被模块 \"${clash.moduleDir}\" 占用；` +\n                `框架按类名全局查找，重名会加载错预制体，请换个名字`,\n            );\n        }\n\n        const viewsDirUrl = `db://${scriptsRoot()}/${moduleDir}/${VIEWS_SUBDIR}`;\n        await ensureDir(viewsDirUrl);\n\n        const scriptUrl = `${viewsDirUrl}/${className}.ts`;\n        if (await assetExists(scriptUrl)) {\n            throw new Error(`View 脚本已存在：${className}.ts（如需重建，请先删除该 View）`);\n        }\n\n        const scriptContent = buildViewScript(className, prefabPath, layer, frameworkImportMode(), frameworkBase('view'), getTargetBundle());\n        const scriptAsset = await Editor.Message.request(\n            'asset-db', 'create-asset', scriptUrl, scriptContent, { overwrite: false },\n        );\n        if (!scriptAsset) {\n            throw new Error(`创建脚本失败: ${scriptUrl}`);\n        }\n\n        const prefabDirUrl = `db://${prefabRoot()}/${moduleDir}`;\n        const prefabUrl = `${prefabDirUrl}/${className}.prefab`;\n        await ensureDir(prefabDirUrl);\n\n        if (await assetExists(prefabUrl)) {\n            await Editor.Message.request('asset-db', 'delete-asset', scriptUrl).catch(() => undefined);\n            throw new Error(`预制体已存在：${className}.prefab（已回滚脚本，如需重建请先删除该 View）`);\n        }\n\n        try {\n            const compressedUuid = compressUuid(scriptAsset.uuid);\n            const prefabContent = JSON.stringify(buildViewPrefab(className, compressedUuid, template));\n            const prefabAsset = await Editor.Message.request(\n                'asset-db', 'create-asset', prefabUrl, prefabContent, { overwrite: false },\n            );\n            if (!prefabAsset) {\n                throw new Error(`创建预制体失败: ${prefabUrl}`);\n            }\n        } catch (e) {\n            // 回滚脚本，避免留下“有脚本没预制体”的半成品\n            await Editor.Message.request('asset-db', 'delete-asset', scriptUrl).catch(() => undefined);\n            await Editor.Message.request('asset-db', 'refresh-asset', viewsDirUrl);\n            throw e;\n        }\n\n        await Editor.Message.request('asset-db', 'refresh-asset', prefabDirUrl);\n        await Editor.Message.request('asset-db', 'refresh-asset', viewsDirUrl);\n\n        return { className, moduleDir, scriptUrl, prefabUrl, prefabPath, layer, template };\n    },\n\n    /**\n     * 删除 view：只删自身（脚本 + 预制体 + 各自 meta），不碰其他资源。\n     */\n    async deleteView(moduleName: string, viewName: string) {\n        if (!moduleName || !IDENTIFIER_RE.test(moduleName)) {\n            throw new Error(`非法的模块名: \"${moduleName}\"`);\n        }\n        if (!viewName || !IDENTIFIER_RE.test(viewName)) {\n            throw new Error(`非法的视图名: \"${viewName}\"`);\n        }\n\n        const moduleDir = normalizeModule(moduleName).dir;\n        const className = normalizeViewName(viewName);\n        const prefabUrl = `db://${prefabRoot()}/${moduleDir}/${className}.prefab`;\n        const scriptUrl = `db://${scriptsRoot()}/${moduleDir}/${VIEWS_SUBDIR}/${className}.ts`;\n\n        const deleted: string[] = [];\n        for (const url of [prefabUrl, scriptUrl]) {\n            const info = await Editor.Message.request('asset-db', 'query-asset-info', url);\n            if (info) {\n                await Editor.Message.request('asset-db', 'delete-asset', url);\n                deleted.push(url);\n            }\n        }\n\n        // 清理空目录（旧版会留下 resources/views/<模块> 这种空壳）\n        await pruneEmptyDir(join(projectPath(), prefabRoot(), moduleDir));\n\n        await Editor.Message.request('asset-db', 'refresh-asset', `db://${prefabRoot()}/${moduleDir}`);\n        await Editor.Message.request('asset-db', 'refresh-asset', dbUrl(`${scriptsRoot()}/${moduleDir}/${VIEWS_SUBDIR}`));\n\n        return { className, moduleDir, deleted };\n    },\n\n    /**\n     * 删除模块：删 gameplay/<模块>/ 与 resources/views/<模块>/ 两个目录（连同 meta）。\n     */\n    async deleteModule(moduleName: string) {\n        if (!moduleName || !IDENTIFIER_RE.test(moduleName)) {\n            throw new Error(`非法的模块名: \"${moduleName}\"`);\n        }\n        const moduleDir = normalizeModule(moduleName).dir;\n\n        const moduleDirPath = join(projectPath(), scriptsRoot(), moduleDir);\n        const prefabDirPath = join(projectPath(), prefabRoot(), moduleDir);\n\n        const removed: string[] = [];\n        for (const p of [prefabDirPath, moduleDirPath]) {\n            try {\n                if (statSync(p).isDirectory()) {\n                    removeSync(p);\n                    removed.push(p);\n                }\n            } catch (e) {\n                /* 不存在则跳过 */\n            }\n        }\n\n        await Editor.Message.request('asset-db', 'refresh-asset', `db://${prefabRoot()}`);\n        await Editor.Message.request('asset-db', 'refresh-asset', dbUrl(scriptsRoot()));\n\n        return { moduleDir, removed };\n    },\n\n    /* ------------------------------ 公共模块 ------------------------------ */\n\n    /**\n     * 查询公共模块：本地工作区 + 已安装 + 远程 registry。\n     * @param force 强制重新拉取远程列表（面板的「刷新」用）\n     */\n    async querySharedModules(force?: boolean) {\n        return await querySharedState(force === true);\n    },\n\n    /**\n     * 安装一个公共模块：**直接代跑 `npm install`**。\n     * 失败时抛出的错误里带着 npm 的原始输出，面板会原样展示。\n     */\n    async installSharedModule(wanted: string) {\n        // ⚠️ 不要动 runSharedAction 的返回值:它的形状是\"刷新后的公共模块列表\"\n        //    (我一开始猜成 {ok, message} 并去读 r.ok/r.message,编译器当场就把我拦住了)。\n        //    这里只做一件事:装完之后补上这个模块需要的工程资源,然后原样透传。\n        const r = await runSharedAction('install', wanted);\n        const made = await ensureScaffoldAssets(String(wanted));\n        if (made.length > 0) log(`[ccgf] 已生成模块资源:${made.join(', ')}`);\n        return r;\n    },\n\n    /** 卸载一个公共模块：直接代跑 `npm uninstall` */\n    async uninstallSharedModule(wanted: string) {\n        return runSharedAction('uninstall', wanted);\n    },\n};\n\n/**\n * @en Method Triggered on Extension Startup\n * @zh 扩展启动时触发的方法\n */\nexport function load() {\n    // 「上次选的目标包」存在 Profile 里:异步读,这里只点火,不阻塞扩展启动\n    void ensureTargetBundleLoaded();\n}\n\n/**\n * @en Method triggered when uninstalling the extension\n * @zh 卸载扩展时触发的方法\n */\nexport function unload() { }\n"]}