@iyowei/sweep-node-modules 0.5.1 → 1.1.0

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/index.js CHANGED
@@ -7,7 +7,7 @@ import { homedir } from "node:os";
7
7
  import { posix, win32 } from "node:path";
8
8
 
9
9
  // src/errors.ts
10
- var SWEEP_ERROR_CODES = new Set([
10
+ var SWEEP_ERROR_CODES = /* @__PURE__ */ new Set([
11
11
  "CONFIG_READ_FAILED",
12
12
  "CONFIG_CORRUPT_JSON",
13
13
  "CONFIG_CORRUPT_SHAPE",
@@ -20,8 +20,8 @@ class SweepError extends Error {
20
20
  name = "SweepError";
21
21
  code;
22
22
  details;
23
- constructor(code, message, details) {
24
- super(message);
23
+ constructor(code, message, details, options) {
24
+ super(message, options);
25
25
  this.code = code;
26
26
  this.details = details;
27
27
  }
@@ -30,11 +30,14 @@ function isSweepError(value) {
30
30
  if (typeof value !== "object" || value === null)
31
31
  return false;
32
32
  const candidate = value;
33
- return candidate.name === "SweepError" && typeof candidate.code === "string" && SWEEP_ERROR_CODES.has(candidate.code);
33
+ return candidate.name === "SweepError" && typeof candidate.message === "string" && typeof candidate.code === "string" && SWEEP_ERROR_CODES.has(candidate.code);
34
+ }
35
+ function isSweepErrorCode(value, code) {
36
+ return isSweepError(value) && value.code === code;
34
37
  }
35
38
 
36
39
  // src/config.ts
37
- var DEFAULT_EXCLUDE = [
40
+ var DEFAULT_EXCLUDE = Object.freeze([
38
41
  ".bun",
39
42
  ".npm",
40
43
  ".pnpm-store",
@@ -55,7 +58,7 @@ var DEFAULT_EXCLUDE = [
55
58
  ".config",
56
59
  ".cache",
57
60
  ".claude"
58
- ];
61
+ ]);
59
62
  function platformDefaultPath(platform, env, home) {
60
63
  if (platform === "win32") {
61
64
  const roaming = env.APPDATA || win32.join(env.USERPROFILE || home, "AppData", "Roaming");
@@ -105,6 +108,15 @@ function fieldError(container, field, optional) {
105
108
  message: `${field} 第 ${badIndex + 1} 项应为字符串 (实际: ${describeActual(value[badIndex])})`
106
109
  };
107
110
  }
111
+ if (field === "roots") {
112
+ const emptyIndex = value.findIndex((item) => item === "");
113
+ if (emptyIndex !== -1) {
114
+ return {
115
+ field,
116
+ message: `${field} 第 ${emptyIndex + 1} 项不能为空字符串`
117
+ };
118
+ }
119
+ }
108
120
  return null;
109
121
  }
110
122
  function shapeError(value) {
@@ -130,13 +142,13 @@ async function loadConfig(path) {
130
142
  } catch (error) {
131
143
  if (error.code === "ENOENT")
132
144
  return { state: "absent" };
133
- throw new SweepError("CONFIG_READ_FAILED", `配置读取失败 (${path}): ${error.message}`, { path, errno: error.code });
145
+ throw new SweepError("CONFIG_READ_FAILED", `配置读取失败 (${path}): ${error.message}`, { path, errno: error.code }, { cause: error });
134
146
  }
135
147
  let data;
136
148
  try {
137
149
  data = JSON.parse(text);
138
150
  } catch (error) {
139
- throw new SweepError("CONFIG_CORRUPT_JSON", `配置损坏 (${path}): JSON 解析失败: ${error.message}`, { path });
151
+ throw new SweepError("CONFIG_CORRUPT_JSON", `配置损坏 (${path}): JSON 解析失败: ${error.message}`, { path }, { cause: error });
140
152
  }
141
153
  const problem = shapeError(data);
142
154
  if (problem !== null) {
@@ -167,16 +179,16 @@ function mergeNames(configNames, cliNames) {
167
179
  import { lstat, realpath, stat } from "node:fs/promises";
168
180
  import { homedir as homedir2 } from "node:os";
169
181
  import { posix as posix2, win32 as win322 } from "node:path";
170
- var POSIX_STYLE = {
182
+ var POSIX_STYLE = Object.freeze({
171
183
  name: "posix",
172
184
  ops: posix2,
173
185
  caseInsensitive: false
174
- };
175
- var WIN32_STYLE = {
186
+ });
187
+ var WIN32_STYLE = Object.freeze({
176
188
  name: "win32",
177
189
  ops: win322,
178
190
  caseInsensitive: true
179
- };
191
+ });
180
192
  function nativeStyle() {
181
193
  return process.platform === "win32" ? WIN32_STYLE : POSIX_STYLE;
182
194
  }
@@ -190,7 +202,11 @@ function hasNodeModulesLeaf(target, style) {
190
202
  return fold(style.ops.basename(target), style) === "node_modules";
191
203
  }
192
204
  function insideAnyRoot(realPath, roots, style) {
205
+ if (realPath === "")
206
+ return false;
193
207
  return roots.some((root) => {
208
+ if (root === "")
209
+ return false;
194
210
  const rel = style.ops.relative(fold(root, style), fold(realPath, style));
195
211
  if (rel === "" || style.ops.isAbsolute(rel))
196
212
  return false;
@@ -198,10 +214,16 @@ function insideAnyRoot(realPath, roots, style) {
198
214
  });
199
215
  }
200
216
  function isFilesystemRootBody(realPath, style) {
201
- return fold(style.ops.parse(realPath).root, style) === fold(realPath, style);
217
+ if (realPath === "")
218
+ return false;
219
+ const normalized = style.ops.normalize(realPath);
220
+ const root = style.ops.parse(normalized).root;
221
+ return root !== "" && fold(root, style) === fold(normalized, style);
202
222
  }
203
223
  function isHomeBody(realPath, home, style) {
204
- return home !== null && dedupeKey(realPath, style) === dedupeKey(home, style);
224
+ if (home === null || home === "" || realPath === "")
225
+ return false;
226
+ return style.ops.relative(fold(home, style), fold(realPath, style)) === "";
205
227
  }
206
228
  function firstSymlinkOnAnchor(links) {
207
229
  for (const link of links) {
@@ -211,11 +233,13 @@ function firstSymlinkOnAnchor(links) {
211
233
  return null;
212
234
  }
213
235
  function anchorChainPaths(root, style) {
214
- const absolute = style.ops.isAbsolute(root) ? root : style.ops.resolve(root);
236
+ const absolute = style.ops.isAbsolute(root) ? style.ops.normalize(root) : style.ops.resolve(root);
215
237
  const prefix = style.ops.parse(absolute).root;
238
+ const tail = absolute.slice(prefix.length);
239
+ const parts = style.name === "win32" ? tail.split(/[\\/]+/) : tail.split(style.ops.sep);
216
240
  const chain = [];
217
241
  let cursor = prefix;
218
- for (const part of absolute.slice(prefix.length).split(style.ops.sep)) {
242
+ for (const part of parts) {
219
243
  if (part === "")
220
244
  continue;
221
245
  cursor = style.ops.join(cursor, part);
@@ -246,6 +270,11 @@ async function firstSymlinkOnRoot(root) {
246
270
  return firstSymlinkOnTarget(root);
247
271
  }
248
272
  async function validateTargets(targets, options) {
273
+ if (options.signal?.aborted) {
274
+ throw new SweepError("CANCELLED", "安全闸校验在逐目标检查点被取消", {
275
+ phase: "validate"
276
+ });
277
+ }
249
278
  const style = options.style ?? nativeStyle();
250
279
  const homeOption = options.home === undefined ? homedir2() : options.home;
251
280
  const anchors = [];
@@ -372,7 +401,7 @@ function owningRoot(target, roots, style) {
372
401
  for (const root of roots) {
373
402
  if (!insideAnyRoot(target, [root], style))
374
403
  continue;
375
- if (best === null || root.length > best.length)
404
+ if (best === null || insideAnyRoot(root, [best], style))
376
405
  best = root;
377
406
  }
378
407
  return best;
@@ -407,11 +436,12 @@ function crossDeviceIndex(entries) {
407
436
 
408
437
  // src/classify.ts
409
438
  var fold2 = (text, style) => style.caseInsensitive ? text.toLowerCase() : text;
410
- var INSTALL_TREE_SEGMENTS = new Set([...DEFAULT_EXCLUDE, "extensions", "_npx"].map((name) => name.toLowerCase()));
439
+ var INSTALL_TREE_SEGMENTS = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDE, "extensions", "_npx"].map((name) => name.toLowerCase()));
411
440
  function classifyTarget(target, options = {}) {
412
441
  const style = options.style ?? nativeStyle();
413
442
  const homeOption = options.home === undefined ? homedir3() : options.home;
414
- const parts = target.split(style.ops.sep).filter((part) => part !== "");
443
+ const normalizedTarget = style.ops.normalize(target);
444
+ const parts = (style.name === "win32" ? normalizedTarget.split(/[\\/]+/) : normalizedTarget.split(style.ops.sep)).filter((part) => part !== "");
415
445
  const ancestors = parts.slice(0, -1);
416
446
  for (const segment of ancestors) {
417
447
  if (INSTALL_TREE_SEGMENTS.has(segment.toLowerCase()))
@@ -426,9 +456,9 @@ function classifyTarget(target, options = {}) {
426
456
  kind: "suspect-install-tree",
427
457
  reason: "父目录为 lib, 形如版本管理器的 node 安装树"
428
458
  };
429
- if (homeOption !== null) {
430
- const relative = style.ops.relative(fold2(homeOption, style), fold2(target, style));
431
- const [first] = relative.split(style.ops.sep);
459
+ if (homeOption !== null && homeOption !== "") {
460
+ const relative = style.ops.relative(fold2(homeOption, style), fold2(normalizedTarget, style));
461
+ const [first] = style.name === "win32" ? relative.split(/[\\/]+/) : relative.split(style.ops.sep);
432
462
  if (first !== undefined && first !== ".." && first !== "." && first.startsWith(".") && !style.ops.isAbsolute(relative))
433
463
  return {
434
464
  kind: "suspect-install-tree",
@@ -438,8 +468,10 @@ function classifyTarget(target, options = {}) {
438
468
  return { kind: "project" };
439
469
  }
440
470
  // src/delete.ts
441
- import { lstat as lstat2, realpath as realpath2, rm } from "node:fs/promises";
442
- import { isAbsolute, join, relative, sep } from "node:path";
471
+ import { lstat as lstat3, realpath as realpath2, rm } from "node:fs/promises";
472
+
473
+ // src/delete-review.ts
474
+ import { lstat as lstat2 } from "node:fs/promises";
443
475
  var ERROR_HINTS = {
444
476
  EACCES: "权限不足, 拒绝删除",
445
477
  EPERM: "操作不被允许",
@@ -447,7 +479,6 @@ var ERROR_HINTS = {
447
479
  ENOTEMPTY: "目录非空",
448
480
  EROFS: "目标位于只读文件系统"
449
481
  };
450
- var PARTIAL_DELETION_HINT = "注意: 目录内容可能已被部分或全部删除, 请复查";
451
482
  function describeCode(error) {
452
483
  const fsError = error;
453
484
  const code = fsError?.code;
@@ -456,48 +487,51 @@ function describeCode(error) {
456
487
  }
457
488
  return `${code}: ${ERROR_HINTS[code] ?? "删除未成功"}`;
458
489
  }
459
- function describeRemovalError(target, error) {
460
- return `${describeCode(error)} (目标: ${target}; ${PARTIAL_DELETION_HINT})`;
461
- }
462
490
  function describeReviewError(target, path, error) {
463
491
  return `安全复核未完成 (${describeCode(error)}) (目标: ${target}; 组件: ${path}; 未执行删除)`;
464
492
  }
465
493
  function describeVanishedReview(target, path) {
466
494
  return `安全复核未完成 (ENOENT: 路径组件消失) (目标: ${target}; 组件: ${path}; 请复查目标是否仍存在; 未执行删除; 若目标确已不存在, 可忽略此条)`;
467
495
  }
468
- async function checkGone(path) {
469
- try {
470
- await lstat2(path);
471
- return "present";
472
- } catch (error) {
473
- return error?.code === "ENOENT" ? "gone" : "unknown";
474
- }
475
- }
476
- function describeSurvivor(target, state) {
477
- const review = state === "present" ? "复核确认目标仍存在" : "目标是否仍存在未能核验";
478
- return `ENOENT: 删除中途失败 (${review}) (目标: ${target}; ${PARTIAL_DELETION_HINT})`;
479
- }
480
- function isUnder(root, target) {
481
- const rel = relative(root, target);
482
- if (rel === "" || isAbsolute(rel))
483
- return false;
484
- return rel !== ".." && !rel.startsWith(`..${sep}`);
485
- }
486
- function componentChain(root, target) {
496
+ function componentChain(root, target, style) {
497
+ const fold = (p) => style.caseInsensitive ? p.toLowerCase() : p;
498
+ const rel = style.ops.relative(fold(root), fold(target));
487
499
  const chain = [root];
488
500
  let cursor = root;
489
- for (const part of relative(root, target).split(sep).slice(0, -1)) {
490
- cursor = join(cursor, part);
501
+ for (const part of rel.split(style.ops.sep).slice(0, -1)) {
502
+ cursor = style.ops.join(cursor, part);
491
503
  chain.push(cursor);
492
504
  }
493
505
  return chain;
494
506
  }
495
- async function isSymlinkHead(path) {
496
- try {
497
- return (await lstat2(path)).isSymbolicLink();
498
- } catch {
499
- return false;
507
+ function targetShapeViolation(target, style) {
508
+ if (target.endsWith("/") || target.endsWith("\\")) {
509
+ return `安全复核失败 (目标路径不得含尾分隔符): ${target}`;
500
510
  }
511
+ const segments = style.name === "win32" ? target.split(/[\\/]+/) : target.split("/");
512
+ if (segments.some((segment) => segment === "." || segment === "..")) {
513
+ return `安全复核失败 (目标路径不得含相对段 . 或 ..): ${target}`;
514
+ }
515
+ if (!hasNodeModulesLeaf(target, style)) {
516
+ return `安全复核失败 (路径末段不是 node_modules): ${target}`;
517
+ }
518
+ return null;
519
+ }
520
+ function rootAncestorChain(root, style) {
521
+ const chain = [];
522
+ const seen = new Set;
523
+ const append = (raw) => {
524
+ for (const step of anchorChainPaths(raw, style)) {
525
+ const key = dedupeKey(step, style);
526
+ if (seen.has(key))
527
+ continue;
528
+ seen.add(key);
529
+ chain.push(step);
530
+ }
531
+ };
532
+ append(root.configured);
533
+ append(root.real);
534
+ return chain;
501
535
  }
502
536
  async function reviewComponents(chain) {
503
537
  for (const path of chain) {
@@ -514,9 +548,183 @@ async function reviewComponents(chain) {
514
548
  }
515
549
  return null;
516
550
  }
551
+ function toReviewFailure(target, finding) {
552
+ if (finding.kind === "vanished") {
553
+ return {
554
+ target,
555
+ code: "REVIEW_COMPONENT_VANISHED",
556
+ errno: "ENOENT",
557
+ message: describeVanishedReview(target, finding.path),
558
+ partialRisk: false
559
+ };
560
+ }
561
+ return {
562
+ target,
563
+ code: "REVIEW_UNVERIFIED",
564
+ errno: finding.error?.code,
565
+ message: describeReviewError(target, finding.path, finding.error),
566
+ partialRisk: false
567
+ };
568
+ }
569
+ function resolveTargetRootSync(target, roots, style) {
570
+ const violation = targetShapeViolation(target, style);
571
+ if (violation !== null) {
572
+ return {
573
+ kind: "aborted",
574
+ aborted: {
575
+ target,
576
+ code: "REVIEW_NOT_UNDER_ANY_ROOT",
577
+ message: violation,
578
+ path: target
579
+ }
580
+ };
581
+ }
582
+ const root = roots.find((candidate) => insideAnyRoot(target, [candidate.real], style));
583
+ if (root === undefined) {
584
+ return {
585
+ kind: "aborted",
586
+ aborted: {
587
+ target,
588
+ code: "REVIEW_NOT_UNDER_ANY_ROOT",
589
+ message: `安全复核失败 (目标不在任何 roots 之下): ${target}`,
590
+ path: target
591
+ }
592
+ };
593
+ }
594
+ return { kind: "ok", root };
595
+ }
596
+ async function reviewPathOnDisk(target, root, style) {
597
+ const headFinding = await reviewComponents(rootAncestorChain(root, style));
598
+ if (headFinding !== null) {
599
+ if (headFinding.kind === "unsafe") {
600
+ const location = headFinding.path === root.configured ? root.configured : `${headFinding.path} (根: ${root.configured})`;
601
+ return {
602
+ kind: "aborted",
603
+ aborted: {
604
+ target,
605
+ code: "REVIEW_HEAD_SYMLINK",
606
+ message: `安全复核失败 (根被替换为符号链接): ${location}`,
607
+ path: headFinding.path
608
+ }
609
+ };
610
+ }
611
+ return { kind: "failed", failure: toReviewFailure(target, headFinding) };
612
+ }
613
+ const finding = await reviewComponents(componentChain(root.real, target, style));
614
+ if (finding !== null) {
615
+ if (finding.kind === "unsafe") {
616
+ return {
617
+ kind: "aborted",
618
+ aborted: {
619
+ target,
620
+ code: "REVIEW_COMPONENT_REPLACED",
621
+ message: `安全复核失败 (路径组件被替换): ${finding.path}`,
622
+ path: finding.path
623
+ }
624
+ };
625
+ }
626
+ return { kind: "failed", failure: toReviewFailure(target, finding) };
627
+ }
628
+ return { kind: "ok" };
629
+ }
630
+
631
+ // src/stale.ts
632
+ function splitStaleRejections(rejected, staleTargets) {
633
+ if (staleTargets !== "missing")
634
+ return { rejected, stale: [] };
635
+ const rest = [];
636
+ const stale = [];
637
+ for (const item of rejected) {
638
+ if (item.code === "GUARD_TARGET_MISSING")
639
+ stale.push(item.target);
640
+ else
641
+ rest.push(item);
642
+ }
643
+ return { rejected: rest, stale };
644
+ }
645
+
646
+ // src/delete.ts
647
+ var PARTIAL_DELETION_HINT = "注意: 目录内容可能已被部分或全部删除, 请复查";
648
+ function describeRemovalError(target, error) {
649
+ return `${describeCode(error)} (目标: ${target}; ${PARTIAL_DELETION_HINT})`;
650
+ }
651
+ async function checkGone(path) {
652
+ try {
653
+ await lstat3(path);
654
+ return "present";
655
+ } catch (error) {
656
+ return error?.code === "ENOENT" ? "gone" : "unknown";
657
+ }
658
+ }
659
+ function describeSurvivor(target, state) {
660
+ const review = state === "present" ? "复核确认目标仍存在" : "目标是否仍存在未能核验";
661
+ return `ENOENT: 删除中途失败 (${review}) (目标: ${target}; ${PARTIAL_DELETION_HINT})`;
662
+ }
517
663
  var REMOVAL_CONCURRENCY = 4;
664
+ async function executeRm(target) {
665
+ try {
666
+ await rm(target, { recursive: true, force: false });
667
+ return { kind: "removed", target };
668
+ } catch (error) {
669
+ if (error?.code === "ENOENT") {
670
+ const state = await checkGone(target);
671
+ if (state === "gone")
672
+ return { kind: "missing", target };
673
+ return {
674
+ kind: "failed",
675
+ failure: {
676
+ target,
677
+ code: "REMOVE_ENOENT_SURVIVOR",
678
+ errno: "ENOENT",
679
+ message: describeSurvivor(target, state),
680
+ partialRisk: true
681
+ }
682
+ };
683
+ }
684
+ return {
685
+ kind: "failed",
686
+ failure: {
687
+ target,
688
+ code: "REMOVE_FAILED",
689
+ errno: error?.code,
690
+ message: describeRemovalError(target, error),
691
+ partialRisk: true
692
+ }
693
+ };
694
+ }
695
+ }
696
+ function assembleRemovalResult(slots, aborted) {
697
+ const result = { removed: [], missing: [], failed: [] };
698
+ for (const slot of slots) {
699
+ if (slot === undefined)
700
+ continue;
701
+ switch (slot.kind) {
702
+ case "removed":
703
+ result.removed.push(slot.target);
704
+ break;
705
+ case "missing":
706
+ result.missing.push(slot.target);
707
+ break;
708
+ case "failed":
709
+ result.failed.push(slot.failure);
710
+ break;
711
+ case "aborted":
712
+ break;
713
+ }
714
+ }
715
+ if (aborted !== undefined)
716
+ result.aborted = aborted;
717
+ return result;
718
+ }
518
719
  async function removeTargets(targets, options) {
720
+ if (options?.signal?.aborted) {
721
+ throw new SweepError("CANCELLED", "删除在条目间检查点被取消", {
722
+ phase: "remove",
723
+ partial: { removed: [], missing: [], failed: [] }
724
+ });
725
+ }
519
726
  const roots = options?.roots ?? [];
727
+ const style = options?.style ?? nativeStyle();
520
728
  const signal = options?.signal;
521
729
  const emit = options?.onProgress;
522
730
  const slots = Array.from({
@@ -538,7 +746,7 @@ async function removeTargets(targets, options) {
538
746
  const drained = new Promise((resolve) => {
539
747
  resolveDrained = resolve;
540
748
  });
541
- const halted = () => cancelled || aborted !== undefined;
749
+ const halted = () => cancelled || aborted !== undefined || failures.length > 0;
542
750
  function pump() {
543
751
  while (active < REMOVAL_CONCURRENCY && next < targets.length && !halted()) {
544
752
  const index = next;
@@ -561,98 +769,26 @@ async function removeTargets(targets, options) {
561
769
  cancelled = true;
562
770
  return;
563
771
  }
564
- const root = roots.find((candidate) => isUnder(candidate.real, target));
565
- if (root === undefined) {
566
- const info = {
567
- target,
568
- code: "REVIEW_NOT_UNDER_ANY_ROOT",
569
- message: `安全复核失败 (目标不在任何 roots 之下): ${target}`,
570
- path: target
571
- };
572
- recordAbort(index, info);
772
+ const syncCheck = resolveTargetRootSync(target, roots, style);
773
+ if (syncCheck.kind === "aborted") {
774
+ recordAbort(index, syncCheck.aborted);
573
775
  slots[index] = { kind: "aborted" };
574
- emit?.({ kind: "aborted", aborted: info });
575
776
  return;
576
777
  }
577
- if (await isSymlinkHead(root.configured)) {
578
- const info = {
579
- target,
580
- code: "REVIEW_HEAD_SYMLINK",
581
- message: `安全复核失败 (根被替换为符号链接): ${root.configured}`,
582
- path: root.configured
583
- };
584
- recordAbort(index, info);
778
+ const review = await reviewPathOnDisk(target, syncCheck.root, style);
779
+ if (review.kind === "aborted") {
780
+ recordAbort(index, review.aborted);
585
781
  slots[index] = { kind: "aborted" };
586
- emit?.({ kind: "aborted", aborted: info });
587
782
  return;
588
783
  }
589
- const finding = await reviewComponents(componentChain(root.real, target));
590
- if (finding !== null) {
591
- if (finding.kind === "vanished") {
592
- const vanished = {
593
- target,
594
- code: "REVIEW_COMPONENT_VANISHED",
595
- message: describeVanishedReview(target, finding.path),
596
- partialRisk: false
597
- };
598
- slots[index] = { kind: "failed", failure: vanished };
599
- emit?.({ kind: "failed", failure: vanished });
600
- return;
601
- }
602
- if (finding.kind === "unsafe") {
603
- const info = {
604
- target,
605
- code: "REVIEW_COMPONENT_REPLACED",
606
- message: `安全复核失败 (路径组件被替换): ${finding.path}`,
607
- path: finding.path
608
- };
609
- recordAbort(index, info);
610
- slots[index] = { kind: "aborted" };
611
- emit?.({ kind: "aborted", aborted: info });
612
- return;
613
- }
614
- const unverified = {
615
- target,
616
- code: "REVIEW_UNVERIFIED",
617
- message: describeReviewError(target, finding.path, finding.error),
618
- partialRisk: false
619
- };
620
- slots[index] = { kind: "failed", failure: unverified };
621
- emit?.({ kind: "failed", failure: unverified });
784
+ if (review.kind === "failed") {
785
+ slots[index] = { kind: "failed", failure: review.failure };
786
+ emit?.({ kind: "failed", failure: review.failure });
622
787
  return;
623
788
  }
624
- try {
625
- await rm(target, { recursive: true, force: false });
626
- slots[index] = { kind: "removed", target };
627
- emit?.({ kind: "removed", target });
628
- } catch (error) {
629
- if (error?.code === "ENOENT") {
630
- const state = await checkGone(target);
631
- if (state === "gone") {
632
- slots[index] = { kind: "missing", target };
633
- emit?.({ kind: "missing", target });
634
- return;
635
- }
636
- const survivor = {
637
- target,
638
- code: "REMOVE_ENOENT_SURVIVOR",
639
- message: describeSurvivor(target, state),
640
- partialRisk: true
641
- };
642
- slots[index] = { kind: "failed", failure: survivor };
643
- emit?.({ kind: "failed", failure: survivor });
644
- return;
645
- }
646
- const failure = {
647
- target,
648
- code: "REMOVE_FAILED",
649
- errno: error?.code,
650
- message: describeRemovalError(target, error),
651
- partialRisk: true
652
- };
653
- slots[index] = { kind: "failed", failure };
654
- emit?.({ kind: "failed", failure });
655
- }
789
+ const outcome = await executeRm(target);
790
+ slots[index] = outcome;
791
+ emit?.(outcome);
656
792
  } catch (error) {
657
793
  if (failures.length === 0)
658
794
  failures.push(error);
@@ -667,26 +803,9 @@ async function removeTargets(targets, options) {
667
803
  await drained;
668
804
  if (failures.length > 0)
669
805
  throw failures[0];
670
- const result = { removed: [], missing: [], failed: [] };
671
- for (const slot of slots) {
672
- if (slot === undefined)
673
- continue;
674
- switch (slot.kind) {
675
- case "removed":
676
- result.removed.push(slot.target);
677
- break;
678
- case "missing":
679
- result.missing.push(slot.target);
680
- break;
681
- case "failed":
682
- result.failed.push(slot.failure);
683
- break;
684
- case "aborted":
685
- break;
686
- }
687
- }
806
+ const result = assembleRemovalResult(slots, aborted);
688
807
  if (aborted !== undefined)
689
- result.aborted = aborted;
808
+ emit?.({ kind: "aborted", aborted });
690
809
  if (cancelled) {
691
810
  throw new SweepError("CANCELLED", "删除在条目间检查点被取消", {
692
811
  phase: "remove",
@@ -701,19 +820,6 @@ async function toTrustRoots(roots) {
701
820
  real: await realpath2(root).catch(() => null) ?? root
702
821
  })));
703
822
  }
704
- function splitStaleRejections(rejected, staleTargets) {
705
- if (staleTargets !== "missing")
706
- return { rejected, stale: [] };
707
- const rest = [];
708
- const stale = [];
709
- for (const item of rejected) {
710
- if (item.code === "GUARD_TARGET_MISSING")
711
- stale.push(item.target);
712
- else
713
- rest.push(item);
714
- }
715
- return { rejected: rest, stale };
716
- }
717
823
  async function removeBatch(targets, options) {
718
824
  const validation = await validateTargets(targets, {
719
825
  roots: options.roots,
@@ -727,6 +833,7 @@ async function removeBatch(targets, options) {
727
833
  }
728
834
  const removal = await removeTargets(validation.accepted, {
729
835
  roots: await toTrustRoots(options.roots),
836
+ style: options.style,
730
837
  signal: options.signal,
731
838
  onProgress: options.onProgress
732
839
  });
@@ -758,7 +865,7 @@ var sanitizeOutputLine = (text) => {
758
865
  };
759
866
  // src/scan-parallel.ts
760
867
  import { readdir, realpath as realpath3, stat as stat2 } from "node:fs/promises";
761
- import { join as join2 } from "node:path";
868
+ import { join } from "node:path";
762
869
  var NODE_MODULES = "node_modules";
763
870
  var GIT_DIR = ".git";
764
871
  var CONCURRENCY = 32;
@@ -814,7 +921,6 @@ async function walkRoot(root, ctx) {
814
921
  onProgress
815
922
  } = ctx;
816
923
  const stack = [{ dir: root, included: include.size === 0 }];
817
- let outstanding = 1;
818
924
  let active = 0;
819
925
  const failures = [];
820
926
  let resolveDrained = null;
@@ -822,12 +928,13 @@ async function walkRoot(root, ctx) {
822
928
  resolveDrained = resolve;
823
929
  });
824
930
  function pump() {
825
- while (active < CONCURRENCY && stack.length > 0) {
931
+ while (active < CONCURRENCY && stack.length > 0 && failures.length === 0 && !signal?.aborted) {
826
932
  const next = stack.pop();
827
933
  active += 1;
828
934
  visit(next.dir, next.included);
829
935
  }
830
- if (outstanding === 0 && resolveDrained !== null) {
936
+ const stopped = failures.length > 0 || signal?.aborted === true;
937
+ if (active === 0 && (stack.length === 0 || stopped) && resolveDrained !== null) {
831
938
  const resolve = resolveDrained;
832
939
  resolveDrained = null;
833
940
  resolve();
@@ -843,11 +950,13 @@ async function walkRoot(root, ctx) {
843
950
  let entries;
844
951
  try {
845
952
  entries = await readdir(dir, { withFileTypes: true });
846
- } catch {
953
+ } catch (error) {
954
+ const errno = error?.code;
847
955
  warnings.push({
848
956
  code: "SCAN_DIR_UNREADABLE",
849
957
  message: `目录不可读, 已跳过: ${dir}`,
850
- path: dir
958
+ path: dir,
959
+ ...typeof errno === "string" ? { errno } : {}
851
960
  });
852
961
  return;
853
962
  }
@@ -858,7 +967,7 @@ async function walkRoot(root, ctx) {
858
967
  if (name === NODE_MODULES) {
859
968
  if (!included)
860
969
  continue;
861
- const target = join2(dir, name);
970
+ const target = join(dir, name);
862
971
  const key = dedupeKey(await realpath3(target).catch(() => target), style);
863
972
  if (!hits.has(key)) {
864
973
  const hit = { project: dir, target, root };
@@ -877,15 +986,13 @@ async function walkRoot(root, ctx) {
877
986
  excludeCounts.set(name, (excludeCounts.get(name) ?? 0) + 1);
878
987
  continue;
879
988
  }
880
- stack.push({ dir: join2(dir, name), included: childIncluded });
881
- outstanding += 1;
989
+ stack.push({ dir: join(dir, name), included: childIncluded });
882
990
  }
883
991
  } catch (error) {
884
992
  if (failures.length === 0)
885
993
  failures.push(error);
886
994
  } finally {
887
995
  active -= 1;
888
- outstanding -= 1;
889
996
  pump();
890
997
  }
891
998
  }
@@ -893,11 +1000,21 @@ async function walkRoot(root, ctx) {
893
1000
  await drained;
894
1001
  if (failures.length > 0)
895
1002
  throw failures[0];
1003
+ if (signal?.aborted) {
1004
+ throw new SweepError("CANCELLED", "扫描在遍历任务检查点被取消", {
1005
+ phase: "scan"
1006
+ });
1007
+ }
896
1008
  }
897
1009
  function createParallelScanner() {
898
1010
  return {
899
1011
  name: "parallel",
900
1012
  async scan(options) {
1013
+ if (options.signal?.aborted) {
1014
+ throw new SweepError("CANCELLED", "扫描在根预检阶段被取消", {
1015
+ phase: "scan"
1016
+ });
1017
+ }
901
1018
  const warnings = [];
902
1019
  const exclude = new Set(options.exclude);
903
1020
  const excludeCounts = new Map;
@@ -916,6 +1033,11 @@ function createParallelScanner() {
916
1033
  const seenRoots = new Set;
917
1034
  const roots = [];
918
1035
  for (const root of options.roots) {
1036
+ if (options.signal?.aborted) {
1037
+ throw new SweepError("CANCELLED", "扫描在根预检阶段被取消", {
1038
+ phase: "scan"
1039
+ });
1040
+ }
919
1041
  let key;
920
1042
  try {
921
1043
  const resolved = await realpath3(root);
@@ -964,13 +1086,178 @@ function createParallelScanner() {
964
1086
  }
965
1087
  };
966
1088
  }
1089
+
1090
+ // src/scan.ts
1091
+ function createScanner() {
1092
+ return createParallelScanner();
1093
+ }
967
1094
  // src/size-du.ts
968
1095
  import { spawn } from "node:child_process";
969
1096
  import { accessSync, constants } from "node:fs";
1097
+
1098
+ // src/size-du-parse.ts
1099
+ var PROG_PREFIX_RE = /^(?:\/[^\s:]*)?[a-z][a-z0-9_-]*:\s+/;
1100
+ function describeDuFailure(detail) {
1101
+ if (/no such file or directory/i.test(detail))
1102
+ return { missing: true, reason: "不存在" };
1103
+ if (/permission denied/i.test(detail))
1104
+ return {
1105
+ missing: false,
1106
+ code: "SIZE_UNMEASURED_PERMISSION",
1107
+ reason: "权限不足, 无法读取"
1108
+ };
1109
+ if (/not a directory/i.test(detail))
1110
+ return {
1111
+ missing: false,
1112
+ code: "SIZE_UNMEASURED_NOT_DIR",
1113
+ reason: "不是目录"
1114
+ };
1115
+ if (/too many levels of symbolic links/i.test(detail)) {
1116
+ return {
1117
+ missing: false,
1118
+ code: "SIZE_UNMEASURED_LOOP",
1119
+ reason: "符号链接层级过深"
1120
+ };
1121
+ }
1122
+ return {
1123
+ missing: false,
1124
+ code: "SIZE_UNMEASURED_OTHER",
1125
+ reason: `读取失败 (${detail})`
1126
+ };
1127
+ }
1128
+ var ANSI_C_ESCAPES = {
1129
+ "\\": 92,
1130
+ "'": 39,
1131
+ '"': 34,
1132
+ a: 7,
1133
+ b: 8,
1134
+ f: 12,
1135
+ n: 10,
1136
+ r: 13,
1137
+ t: 9,
1138
+ v: 11,
1139
+ e: 27,
1140
+ E: 27
1141
+ };
1142
+ function pushUtf8(bytes, text) {
1143
+ for (const byte of Buffer.from(text, "utf8"))
1144
+ bytes.push(byte);
1145
+ }
1146
+ function decodeAnsiCEscape(raw, index, bytes) {
1147
+ const ch = raw[index];
1148
+ if (ch === undefined)
1149
+ return index;
1150
+ const mapped = ANSI_C_ESCAPES[ch];
1151
+ if (mapped !== undefined) {
1152
+ bytes.push(mapped);
1153
+ return index + 1;
1154
+ }
1155
+ const oct = /^[0-7]{1,3}/.exec(raw.slice(index));
1156
+ if (oct !== null) {
1157
+ bytes.push(Number.parseInt(oct[0], 8) % 256);
1158
+ return index + oct[0].length;
1159
+ }
1160
+ if (ch === "x") {
1161
+ const hex = /^[0-9a-fA-F]{1,2}/.exec(raw.slice(index + 1));
1162
+ if (hex !== null) {
1163
+ bytes.push(Number.parseInt(hex[0], 16));
1164
+ return index + 1 + hex[0].length;
1165
+ }
1166
+ }
1167
+ pushUtf8(bytes, ch);
1168
+ return index + 1;
1169
+ }
1170
+ function consumeAnsiCSegment(raw, start, bytes) {
1171
+ let index = start;
1172
+ while (index < raw.length) {
1173
+ const inner = raw[index];
1174
+ if (inner === "'")
1175
+ return index + 1;
1176
+ if (inner === "\\") {
1177
+ index = decodeAnsiCEscape(raw, index + 1, bytes);
1178
+ continue;
1179
+ }
1180
+ pushUtf8(bytes, inner ?? "");
1181
+ index += 1;
1182
+ }
1183
+ return -1;
1184
+ }
1185
+ function consumeDoubleQuoted(raw, start, bytes) {
1186
+ let index = start;
1187
+ while (index < raw.length) {
1188
+ const inner = raw[index];
1189
+ if (inner === '"')
1190
+ return index + 1;
1191
+ if (inner === "\\" && index + 1 < raw.length && '"\\$`'.includes(raw[index + 1] ?? "")) {
1192
+ pushUtf8(bytes, raw[index + 1] ?? "");
1193
+ index += 2;
1194
+ continue;
1195
+ }
1196
+ pushUtf8(bytes, inner ?? "");
1197
+ index += 1;
1198
+ }
1199
+ return -1;
1200
+ }
1201
+ function unescapeGnuShellQuoted(raw) {
1202
+ const bytes = [];
1203
+ let index = 0;
1204
+ while (index < raw.length) {
1205
+ const ch = raw[index];
1206
+ if (ch === "$" && raw[index + 1] === "'") {
1207
+ index = consumeAnsiCSegment(raw, index + 2, bytes);
1208
+ if (index === -1)
1209
+ return raw;
1210
+ continue;
1211
+ }
1212
+ if (ch === "'") {
1213
+ const end = raw.indexOf("'", index + 1);
1214
+ if (end === -1)
1215
+ return raw;
1216
+ pushUtf8(bytes, raw.slice(index + 1, end));
1217
+ index = end + 1;
1218
+ continue;
1219
+ }
1220
+ if (ch === '"') {
1221
+ index = consumeDoubleQuoted(raw, index + 1, bytes);
1222
+ if (index === -1)
1223
+ return raw;
1224
+ continue;
1225
+ }
1226
+ if (ch === "\\" && index + 1 < raw.length) {
1227
+ pushUtf8(bytes, raw[index + 1] ?? "");
1228
+ index += 2;
1229
+ continue;
1230
+ }
1231
+ pushUtf8(bytes, ch ?? "");
1232
+ index += 1;
1233
+ }
1234
+ return Buffer.from(bytes).toString("utf8");
1235
+ }
1236
+ function parseDuErrorLine(line) {
1237
+ const body = line.replace(PROG_PREFIX_RE, "");
1238
+ const gnu = /^cannot\s+(?:access|read directory|stat|open)\s+(.+):\s+(.+)$/.exec(body);
1239
+ if (gnu !== null) {
1240
+ const rawPath = gnu[1];
1241
+ const detail = gnu[2];
1242
+ if (rawPath !== undefined && detail !== undefined) {
1243
+ const path = rawPath.startsWith("'") || rawPath.startsWith('"') || rawPath.startsWith("$'") ? unescapeGnuShellQuoted(rawPath) : rawPath;
1244
+ return { path, detail };
1245
+ }
1246
+ }
1247
+ const match = /^(.+):\s+(.+)$/.exec(body);
1248
+ if (match === null)
1249
+ return null;
1250
+ const path = match[1];
1251
+ const detail = match[2];
1252
+ if (path === undefined || detail === undefined)
1253
+ return null;
1254
+ return { path, detail };
1255
+ }
1256
+
1257
+ // src/size-du.ts
970
1258
  var DU_PROBES = ["/usr/bin/du", "/bin/du"];
971
1259
  var hasControlChar = (target) => target.includes(`
972
1260
  `) || target.includes("\r");
973
- var PROG_PREFIX_RE = /^(?:\/[^\s:]*)?[a-z][a-z0-9_-]*:\s+/;
974
1261
  function findDu(platform = process.platform) {
975
1262
  if (platform === "win32")
976
1263
  return null;
@@ -982,13 +1269,45 @@ function findDu(platform = process.platform) {
982
1269
  }
983
1270
  return null;
984
1271
  }
1272
+ var DU_BATCH_MAX_BYTES = 128 * 1024;
1273
+ function chunkTargetsByBytes(targets, maxBytes = DU_BATCH_MAX_BYTES) {
1274
+ const batches = [];
1275
+ let current = [];
1276
+ let currentBytes = 0;
1277
+ for (const target of targets) {
1278
+ const size = Buffer.byteLength(target, "utf8") + 1;
1279
+ if (current.length > 0 && currentBytes + size > maxBytes) {
1280
+ batches.push(current);
1281
+ current = [];
1282
+ currentBytes = 0;
1283
+ }
1284
+ current.push(target);
1285
+ currentBytes += size;
1286
+ }
1287
+ if (current.length > 0)
1288
+ batches.push(current);
1289
+ return batches;
1290
+ }
985
1291
  function runDu(bin, targets) {
986
1292
  return new Promise((resolve) => {
1293
+ const env = { ...process.env, LC_ALL: "C", LANG: "C" };
1294
+ delete env.QUOTING_STYLE;
1295
+ delete env.LANGUAGE;
987
1296
  const child = spawn(bin, ["-sk", "--", ...targets], {
988
- stdio: ["ignore", "pipe", "pipe"]
1297
+ stdio: ["ignore", "pipe", "pipe"],
1298
+ env
989
1299
  });
1300
+ child.stdout.setEncoding("utf8");
1301
+ child.stderr.setEncoding("utf8");
990
1302
  let stdout = "";
991
1303
  let stderr = "";
1304
+ let settled = false;
1305
+ const finish = (result) => {
1306
+ if (settled)
1307
+ return;
1308
+ settled = true;
1309
+ resolve(result);
1310
+ };
992
1311
  child.stdout.on("data", (chunk) => {
993
1312
  stdout += chunk;
994
1313
  });
@@ -996,9 +1315,17 @@ function runDu(bin, targets) {
996
1315
  stderr += chunk;
997
1316
  });
998
1317
  child.on("error", (error) => {
999
- resolve({ stdout, stderr: `${stderr}${String(error)}` });
1318
+ finish({
1319
+ stdout,
1320
+ stderr,
1321
+ exitCode: null,
1322
+ signal: null,
1323
+ spawnError: error
1324
+ });
1325
+ });
1326
+ child.on("close", (exitCode, signal) => {
1327
+ finish({ stdout, stderr, exitCode, signal, spawnError: null });
1000
1328
  });
1001
- child.on("close", () => resolve({ stdout, stderr }));
1002
1329
  });
1003
1330
  }
1004
1331
  function parseDuSizes(stdout) {
@@ -1045,58 +1372,105 @@ function describeAnomaly(assessment) {
1045
1372
  shapes.push("行数与输入不符");
1046
1373
  return shapes.join(" / ");
1047
1374
  }
1048
- function describeDuFailure(detail) {
1049
- if (/no such file or directory/i.test(detail))
1050
- return { missing: true, reason: "不存在" };
1051
- if (/permission denied/i.test(detail))
1052
- return {
1053
- missing: false,
1054
- code: "SIZE_UNMEASURED_PERMISSION",
1055
- reason: "权限不足, 无法读取"
1056
- };
1057
- if (/not a directory/i.test(detail))
1058
- return {
1059
- missing: false,
1060
- code: "SIZE_UNMEASURED_NOT_DIR",
1061
- reason: "不是目录"
1062
- };
1063
- if (/too many levels of symbolic links/i.test(detail)) {
1064
- return {
1065
- missing: false,
1066
- code: "SIZE_UNMEASURED_LOOP",
1067
- reason: "符号链接层级过深"
1068
- };
1069
- }
1070
- return {
1071
- missing: false,
1072
- code: "SIZE_UNMEASURED_OTHER",
1073
- reason: `读取失败 (${detail})`
1074
- };
1075
- }
1076
- function parseDuErrorLine(line) {
1077
- const body = line.replace(PROG_PREFIX_RE, "");
1078
- const gnu = /^cannot\s+(?:access|read directory|stat|open)\s+'(.*)':\s+(.+)$/.exec(body);
1079
- if (gnu !== null) {
1080
- const path = gnu[1];
1081
- const detail = gnu[2];
1082
- if (path !== undefined && detail !== undefined)
1083
- return { path, detail };
1375
+ async function measureDuBatches(bin, safeTargets, maxBatchBytes, signal) {
1376
+ const sizes = new Map;
1377
+ const failures = new Map;
1378
+ const degraded = new Set;
1379
+ const warnings = [];
1380
+ for (const batch of chunkTargetsByBytes(safeTargets, maxBatchBytes)) {
1381
+ if (signal?.aborted) {
1382
+ throw new SweepError("CANCELLED", "体积统计在批量统计前被取消", {
1383
+ phase: "measure"
1384
+ });
1385
+ }
1386
+ const run = await runDu(bin, batch);
1387
+ if (run.spawnError !== null || run.signal !== null) {
1388
+ for (const target of batch)
1389
+ degraded.add(target);
1390
+ const errno = run.spawnError?.code;
1391
+ const reason = run.spawnError !== null ? `du 执行失败 (${run.spawnError.message})` : `du 被信号 ${run.signal} 中止`;
1392
+ warnings.push({
1393
+ code: "SIZE_DU_UNAVAILABLE",
1394
+ message: `${reason}: 本批 ${batch.length} 个目标的体积均未采信`,
1395
+ ...typeof errno === "string" ? { errno } : {}
1396
+ });
1397
+ continue;
1398
+ }
1399
+ const { stdout, stderr } = run;
1400
+ const batchSet = new Set(batch);
1401
+ const assessment = assessDuOutput(stdout, batch);
1402
+ if (!assessment.intact) {
1403
+ for (const target of batch)
1404
+ degraded.add(target);
1405
+ warnings.push({
1406
+ code: "SIZE_DU_OUTPUT_MISMATCH",
1407
+ message: `du 输出与输入集合不符 (${describeAnomaly(assessment)}): 本批 ${batch.length} 个目标的体积均未采信`
1408
+ });
1409
+ } else {
1410
+ for (const [path, bytes] of assessment.sizes)
1411
+ sizes.set(path, bytes);
1412
+ }
1413
+ for (const line of stderr.split(`
1414
+ `)) {
1415
+ if (line.trim() === "")
1416
+ continue;
1417
+ const errorLine = parseDuErrorLine(line);
1418
+ if (errorLine === null) {
1419
+ warnings.push({
1420
+ code: "SIZE_DU_LINE_UNATTRIBUTED",
1421
+ message: `体积统计失败 (未归因): ${line.replace(PROG_PREFIX_RE, "").trim()}`
1422
+ });
1423
+ continue;
1424
+ }
1425
+ const failure = describeDuFailure(errorLine.detail);
1426
+ if (!batchSet.has(errorLine.path)) {
1427
+ warnings.push({
1428
+ code: "SIZE_SUBPATH_FAILED",
1429
+ message: `体积统计失败 (${failure.reason}): ${errorLine.path}`,
1430
+ path: errorLine.path
1431
+ });
1432
+ continue;
1433
+ }
1434
+ failures.set(errorLine.path, failure);
1435
+ }
1084
1436
  }
1085
- const match = /^(.+):\s+(.+)$/.exec(body);
1086
- if (match === null)
1087
- return null;
1088
- const path = match[1];
1089
- const detail = match[2];
1090
- if (path === undefined || detail === undefined)
1091
- return null;
1092
- return { path, detail };
1437
+ for (const path of failures.keys())
1438
+ sizes.delete(path);
1439
+ return { sizes, failures, degraded, warnings };
1093
1440
  }
1094
- function createDuSizer(bin = findDu()) {
1441
+ function createDuSizer(bin = findDu(), maxBatchBytes = DU_BATCH_MAX_BYTES) {
1095
1442
  return {
1096
1443
  name: "du",
1097
1444
  basis: "disk-usage",
1098
1445
  async measure(targets, options) {
1446
+ if (options?.signal?.aborted) {
1447
+ throw new SweepError("CANCELLED", "体积统计在批量统计前被取消", {
1448
+ phase: "measure"
1449
+ });
1450
+ }
1451
+ const sorted = [...new Set(targets)].sort();
1452
+ const emit = options?.onProgress;
1099
1453
  if (bin === null) {
1454
+ const unmeasured = [];
1455
+ const reason = "du 候选不可用";
1456
+ for (const target of sorted) {
1457
+ if (options?.signal?.aborted) {
1458
+ throw new SweepError("CANCELLED", "体积统计在逐目标检查点被取消", {
1459
+ phase: "measure"
1460
+ });
1461
+ }
1462
+ unmeasured.push({
1463
+ target,
1464
+ code: "SIZE_UNMEASURED_OTHER",
1465
+ reason
1466
+ });
1467
+ emit?.({
1468
+ kind: "unmeasured",
1469
+ target,
1470
+ code: "SIZE_UNMEASURED_OTHER",
1471
+ reason
1472
+ });
1473
+ }
1100
1474
  return {
1101
1475
  entries: [],
1102
1476
  basis: "disk-usage",
@@ -1106,11 +1480,11 @@ function createDuSizer(bin = findDu()) {
1106
1480
  message: "du 候选不可用: /usr/bin/du 与 /bin/du 均不存在, 本候选跳过体积统计"
1107
1481
  }
1108
1482
  ],
1109
- unmeasured: [],
1483
+ unmeasured,
1110
1484
  gone: []
1111
1485
  };
1112
1486
  }
1113
- if (targets.length === 0) {
1487
+ if (sorted.length === 0) {
1114
1488
  return {
1115
1489
  entries: [],
1116
1490
  basis: "disk-usage",
@@ -1119,60 +1493,16 @@ function createDuSizer(bin = findDu()) {
1119
1493
  gone: []
1120
1494
  };
1121
1495
  }
1122
- const sorted = [...targets].sort();
1123
- const warnings = [];
1124
1496
  const entries = [];
1125
1497
  const unmeasured = [];
1126
1498
  const gone = [];
1127
- const emit = options?.onProgress;
1128
1499
  const safeTargets = sorted.filter((target) => !hasControlChar(target));
1129
- const safeSet = new Set(safeTargets);
1130
- const sizes = new Map;
1131
- const failures = new Map;
1132
- let intact = true;
1133
- if (safeTargets.length > 0) {
1134
- if (options?.signal?.aborted) {
1135
- throw new SweepError("CANCELLED", "体积统计在批量统计前被取消", {
1136
- phase: "measure"
1137
- });
1138
- }
1139
- const { stdout, stderr } = await runDu(bin, safeTargets);
1140
- const assessment = assessDuOutput(stdout, safeTargets);
1141
- intact = assessment.intact;
1142
- if (!intact) {
1143
- warnings.push({
1144
- code: "SIZE_DU_OUTPUT_MISMATCH",
1145
- message: `du 输出与输入集合不符 (${describeAnomaly(assessment)}): 本批 ${safeTargets.length} 个目标的体积均未采信`
1146
- });
1147
- }
1148
- for (const [path, bytes] of assessment.sizes)
1149
- sizes.set(path, bytes);
1150
- for (const line of stderr.split(`
1151
- `)) {
1152
- if (line.trim() === "")
1153
- continue;
1154
- const errorLine = parseDuErrorLine(line);
1155
- if (errorLine === null) {
1156
- warnings.push({
1157
- code: "SIZE_DU_LINE_UNATTRIBUTED",
1158
- message: `体积统计失败 (未归因): ${line.replace(PROG_PREFIX_RE, "").trim()}`
1159
- });
1160
- continue;
1161
- }
1162
- const failure = describeDuFailure(errorLine.detail);
1163
- if (!safeSet.has(errorLine.path)) {
1164
- warnings.push({
1165
- code: "SIZE_SUBPATH_FAILED",
1166
- message: `体积统计失败 (${failure.reason}): ${errorLine.path}`,
1167
- path: errorLine.path
1168
- });
1169
- continue;
1170
- }
1171
- failures.set(errorLine.path, failure);
1172
- }
1173
- for (const path of failures.keys())
1174
- sizes.delete(path);
1175
- }
1500
+ const { sizes, failures, degraded, warnings } = safeTargets.length > 0 ? await measureDuBatches(bin, safeTargets, maxBatchBytes, options?.signal) : {
1501
+ sizes: new Map,
1502
+ failures: new Map,
1503
+ degraded: new Set,
1504
+ warnings: []
1505
+ };
1176
1506
  const pushUnmeasured = (target, code, reason) => {
1177
1507
  unmeasured.push({ target, code, reason });
1178
1508
  emit?.({ kind: "unmeasured", target, code, reason });
@@ -1187,7 +1517,7 @@ function createDuSizer(bin = findDu()) {
1187
1517
  pushUnmeasured(target, "SIZE_UNMEASURED_CONTROL_CHAR", "路径含控制字符");
1188
1518
  continue;
1189
1519
  }
1190
- if (!intact) {
1520
+ if (degraded.has(target)) {
1191
1521
  pushUnmeasured(target, "SIZE_UNMEASURED_UNPARSEABLE", "输出不可解析");
1192
1522
  continue;
1193
1523
  }
@@ -1220,8 +1550,8 @@ function createDuSizer(bin = findDu()) {
1220
1550
  }
1221
1551
 
1222
1552
  // src/size-js.ts
1223
- import { readdir as readdir2, stat as stat3 } from "node:fs/promises";
1224
- import { join as join3 } from "node:path";
1553
+ import { lstat as lstat4, readdir as readdir2 } from "node:fs/promises";
1554
+ import { join as join2 } from "node:path";
1225
1555
  function describeFailure(code) {
1226
1556
  switch (code) {
1227
1557
  case "ENOENT":
@@ -1256,34 +1586,90 @@ function describeFailure(code) {
1256
1586
  function errorCode(error) {
1257
1587
  return error?.code;
1258
1588
  }
1259
- async function sumEntries(dirents, dir, warnings) {
1260
- let total = 0;
1589
+ var SIZE_CONCURRENCY = 32;
1590
+ function pushSubpathWarning(warnings, path, error) {
1591
+ const errno = errorCode(error);
1592
+ warnings.push({
1593
+ code: "SIZE_SUBPATH_FAILED",
1594
+ message: `体积统计失败 (${describeFailure(errno).reason}): ${path}`,
1595
+ path,
1596
+ ...errno !== undefined ? { errno } : {}
1597
+ });
1598
+ }
1599
+ function enqueueDirents(stack, dir, dirents) {
1261
1600
  for (const dirent of dirents) {
1262
1601
  if (dirent.isSymbolicLink())
1263
1602
  continue;
1264
- const path = join3(dir, dirent.name);
1265
- if (dirent.isDirectory()) {
1266
- try {
1267
- total += await sumEntries(await readdir2(path, { withFileTypes: true }), path, warnings);
1268
- } catch (error) {
1269
- warnings.push({
1270
- code: "SIZE_SUBPATH_FAILED",
1271
- message: `体积统计失败 (${describeFailure(errorCode(error)).reason}): ${path}`,
1272
- path
1603
+ const path = join2(dir, dirent.name);
1604
+ if (dirent.isDirectory())
1605
+ stack.push({ kind: "dir", path });
1606
+ else if (dirent.isFile())
1607
+ stack.push({ kind: "file", path });
1608
+ }
1609
+ }
1610
+ async function sumEntries(dirents, dir, warnings, signal) {
1611
+ const stack = [];
1612
+ enqueueDirents(stack, dir, dirents);
1613
+ let total = 0;
1614
+ let active = 0;
1615
+ const failures = [];
1616
+ let resolveDrained = null;
1617
+ const drained = new Promise((resolve) => {
1618
+ resolveDrained = resolve;
1619
+ });
1620
+ function pump() {
1621
+ while (active < SIZE_CONCURRENCY && stack.length > 0 && failures.length === 0 && !signal?.aborted) {
1622
+ const item = stack.pop();
1623
+ active += 1;
1624
+ processItem(item);
1625
+ }
1626
+ const stopped = failures.length > 0 || signal?.aborted === true;
1627
+ if (active === 0 && (stack.length === 0 || stopped) && resolveDrained !== null) {
1628
+ const resolve = resolveDrained;
1629
+ resolveDrained = null;
1630
+ resolve();
1631
+ }
1632
+ }
1633
+ async function processItem(item) {
1634
+ try {
1635
+ if (signal?.aborted) {
1636
+ throw new SweepError("CANCELLED", "体积统计在目录遍历检查点被取消", {
1637
+ phase: "measure"
1273
1638
  });
1274
1639
  }
1275
- } else if (dirent.isFile()) {
1640
+ if (item.kind === "dir") {
1641
+ try {
1642
+ const children = await readdir2(item.path, { withFileTypes: true });
1643
+ enqueueDirents(stack, item.path, children);
1644
+ } catch (error) {
1645
+ pushSubpathWarning(warnings, item.path, error);
1646
+ }
1647
+ return;
1648
+ }
1276
1649
  try {
1277
- total += (await stat3(path)).size;
1650
+ const stats = await lstat4(item.path);
1651
+ if (stats.isFile())
1652
+ total += stats.size;
1278
1653
  } catch (error) {
1279
- warnings.push({
1280
- code: "SIZE_SUBPATH_FAILED",
1281
- message: `体积统计失败 (${describeFailure(errorCode(error)).reason}): ${path}`,
1282
- path
1283
- });
1654
+ pushSubpathWarning(warnings, item.path, error);
1284
1655
  }
1656
+ } catch (error) {
1657
+ if (failures.length === 0)
1658
+ failures.push(error);
1659
+ } finally {
1660
+ active -= 1;
1661
+ pump();
1285
1662
  }
1286
1663
  }
1664
+ pump();
1665
+ await drained;
1666
+ if (failures.length > 0)
1667
+ throw failures[0];
1668
+ if (signal?.aborted) {
1669
+ throw new SweepError("CANCELLED", "体积统计在目录遍历检查点被取消", {
1670
+ phase: "measure"
1671
+ });
1672
+ }
1287
1673
  return total;
1288
1674
  }
1289
1675
  function createJsSizer() {
@@ -1291,6 +1677,11 @@ function createJsSizer() {
1291
1677
  name: "js",
1292
1678
  basis: "logical-bytes",
1293
1679
  async measure(targets, options) {
1680
+ if (options?.signal?.aborted) {
1681
+ throw new SweepError("CANCELLED", "体积统计在逐目标检查点被取消", {
1682
+ phase: "measure"
1683
+ });
1684
+ }
1294
1685
  const warnings = [];
1295
1686
  const entries = [];
1296
1687
  const unmeasured = [];
@@ -1300,7 +1691,7 @@ function createJsSizer() {
1300
1691
  unmeasured.push({ target, code, reason });
1301
1692
  emit?.({ kind: "unmeasured", target, code, reason });
1302
1693
  };
1303
- for (const target of [...targets].sort()) {
1694
+ for (const target of [...new Set(targets)].sort()) {
1304
1695
  if (options?.signal?.aborted) {
1305
1696
  throw new SweepError("CANCELLED", "体积统计在逐目标检查点被取消", {
1306
1697
  phase: "measure"
@@ -1308,6 +1699,11 @@ function createJsSizer() {
1308
1699
  }
1309
1700
  let dirents;
1310
1701
  try {
1702
+ const st = await lstat4(target);
1703
+ if (st.isSymbolicLink()) {
1704
+ pushUnmeasured(target, "SIZE_UNMEASURED_NOT_DIR", "不是目录");
1705
+ continue;
1706
+ }
1311
1707
  dirents = await readdir2(target, { withFileTypes: true });
1312
1708
  } catch (error) {
1313
1709
  const failure = describeFailure(errorCode(error));
@@ -1324,7 +1720,7 @@ function createJsSizer() {
1324
1720
  }
1325
1721
  continue;
1326
1722
  }
1327
- const bytes = await sumEntries(dirents, target, warnings);
1723
+ const bytes = await sumEntries(dirents, target, warnings, options?.signal);
1328
1724
  entries.push({ target, bytes });
1329
1725
  emit?.({ kind: "measured", target, bytes, basis: "logical-bytes" });
1330
1726
  }
@@ -1335,7 +1731,8 @@ function createJsSizer() {
1335
1731
 
1336
1732
  // src/size.ts
1337
1733
  function createSizer() {
1338
- return findDu() !== null ? createDuSizer() : createJsSizer();
1734
+ const bin = findDu();
1735
+ return bin !== null ? createDuSizer(bin) : createJsSizer();
1339
1736
  }
1340
1737
  // src/skip.ts
1341
1738
  var SUSPECT_HINT = "已跳过 (加 --force 一并清理)";
@@ -1425,7 +1822,7 @@ function collectSkips(entries, crossDevice, policy) {
1425
1822
  return { entries: book, trailer, hints };
1426
1823
  }
1427
1824
  // src/summary.ts
1428
- var SUCCESS_KINDS = new Set([
1825
+ var SUCCESS_KINDS = /* @__PURE__ */ new Set([
1429
1826
  "removed",
1430
1827
  "missing",
1431
1828
  "stale"
@@ -1468,23 +1865,30 @@ function assertNameArray(value, field, required) {
1468
1865
  if (required && value.length === 0)
1469
1866
  throw invalidArgument(field, "不能为空数组");
1470
1867
  }
1868
+ var WIN32_ABS_ROOT_RE = /^(?:[A-Za-z]:[/\\]|[/\\]{2}[^/\\]+[/\\][^/\\]+)/;
1869
+ function isAbsoluteRoot(root, style) {
1870
+ return style.name === "win32" ? WIN32_ABS_ROOT_RE.test(root) : style.ops.isAbsolute(root);
1871
+ }
1471
1872
  function assertShape(options) {
1472
1873
  if (typeof options !== "object" || options === null)
1473
1874
  throw invalidArgument("options", "构造选项必须是对象");
1474
1875
  assertNameArray(options.roots, "roots", true);
1876
+ const style = options.style ?? nativeStyle();
1877
+ if (options.roots.some((root) => !isAbsoluteRoot(root, style)))
1878
+ throw invalidArgument("roots", "必须是绝对路径");
1475
1879
  assertNameArray(options.exclude, "exclude", false);
1476
1880
  assertNameArray(options.include, "include", false);
1477
- if (options.home !== undefined && options.home !== null && typeof options.home !== "string")
1478
- throw invalidArgument("home", "必须是字符串或 null");
1881
+ if (options.home !== undefined && options.home !== null && (typeof options.home !== "string" || options.home === ""))
1882
+ throw invalidArgument("home", "必须是非空字符串或 null");
1479
1883
  if (options.policy !== undefined && (typeof options.policy !== "object" || options.policy === null || typeof options.policy.releaseSuspects !== "boolean"))
1480
1884
  throw invalidArgument("policy", "releaseSuspects 必须是布尔值");
1481
1885
  }
1482
1886
  function resolveOptions(options) {
1483
1887
  assertShape(options);
1484
1888
  return Object.freeze({
1485
- roots: [...options.roots],
1486
- exclude: mergeNames(options.exclude ?? [...DEFAULT_EXCLUDE], []),
1487
- include: mergeNames(options.include ?? [], []),
1889
+ roots: Object.freeze([...options.roots]),
1890
+ exclude: Object.freeze(mergeNames(options.exclude ?? [...DEFAULT_EXCLUDE], [])),
1891
+ include: Object.freeze(mergeNames(options.include ?? [], [])),
1488
1892
  home: options.home === undefined ? homedir4() : options.home,
1489
1893
  style: options.style ?? nativeStyle(),
1490
1894
  policy: Object.freeze({
@@ -1509,12 +1913,12 @@ async function withPhase(phase, emit, signal, work) {
1509
1913
  }
1510
1914
  async function executePlan(resolved, options, signal) {
1511
1915
  const emit = options?.onProgress;
1512
- const roots = resolved.roots;
1916
+ const roots = [...resolved.roots];
1513
1917
  const scanResult = await withPhase("scan", emit, signal, async () => {
1514
- const result = await createParallelScanner().scan({
1515
- roots,
1516
- exclude: resolved.exclude,
1517
- include: resolved.include,
1918
+ const result = await createScanner().scan({
1919
+ roots: [...roots],
1920
+ exclude: [...resolved.exclude],
1921
+ include: [...resolved.include],
1518
1922
  signal,
1519
1923
  onProgress: (event) => emit?.(event)
1520
1924
  });
@@ -1603,11 +2007,12 @@ async function executePlan(resolved, options, signal) {
1603
2007
  roots: [...resolved.roots],
1604
2008
  exclude: [...resolved.exclude],
1605
2009
  include: [...resolved.include],
1606
- policy,
2010
+ policy: { releaseSuspects: policy.releaseSuspects },
1607
2011
  basis: entries.length > 0 ? sizeResult.basis : undefined,
1608
2012
  entries,
1609
2013
  batch,
1610
2014
  skipped: [...book.entries],
2015
+ trailer: [...book.trailer],
1611
2016
  warnings: [...scanResult.warnings, ...sizeResult.warnings],
1612
2017
  nameMatches: {
1613
2018
  exclude: scanResult.excludeMatches,
@@ -1616,9 +2021,17 @@ async function executePlan(resolved, options, signal) {
1616
2021
  };
1617
2022
  });
1618
2023
  }
1619
- function buildOutcomeEntries(plan, expectedSet, stale, rejected, removal) {
2024
+ function buildOutcomeEntries(plan, expectedSet, stale, rejected, mappings, removal) {
1620
2025
  const staleSet = new Set(stale);
1621
- const rejectedMap = rejected.length > 0 ? new Map(rejected.map((item) => [item.target, item])) : undefined;
2026
+ let rejectedMap;
2027
+ if (rejected.length > 0) {
2028
+ rejectedMap = new Map;
2029
+ for (const item of rejected) {
2030
+ if (!rejectedMap.has(item.target))
2031
+ rejectedMap.set(item.target, item);
2032
+ }
2033
+ }
2034
+ const realOf = new Map(mappings.map((item) => [item.original, item.real]));
1622
2035
  const removedSet = new Set(removal?.removed ?? []);
1623
2036
  const missingSet = new Set(removal?.missing ?? []);
1624
2037
  const failedMap = new Map((removal?.failed ?? []).map((item) => [
@@ -1632,13 +2045,16 @@ function buildOutcomeEntries(plan, expectedSet, stale, rejected, removal) {
1632
2045
  return { kind: "not-expected" };
1633
2046
  if (staleSet.has(entry.target))
1634
2047
  return { kind: "stale" };
1635
- if (rejectedMap !== undefined)
1636
- return { kind: "rejected", rejection: rejectedMap.get(entry.target) };
1637
- if (removedSet.has(entry.target))
2048
+ if (rejectedMap !== undefined) {
2049
+ const rejection = rejectedMap.get(entry.target);
2050
+ return rejection !== undefined ? { kind: "rejected", rejection } : { kind: "not-attempted", code: "BATCH_REJECTED" };
2051
+ }
2052
+ const realTarget = realOf.get(entry.target) ?? entry.target;
2053
+ if (removedSet.has(realTarget))
1638
2054
  return { kind: "removed" };
1639
- if (missingSet.has(entry.target))
2055
+ if (missingSet.has(realTarget))
1640
2056
  return { kind: "missing" };
1641
- const failure = failedMap.get(entry.target);
2057
+ const failure = failedMap.get(realTarget);
1642
2058
  if (failure !== undefined)
1643
2059
  return { kind: "failed", failure };
1644
2060
  return { kind: "not-attempted", code: removal.aborted.code };
@@ -1663,7 +2079,7 @@ async function executeRun(resolved, options, signal) {
1663
2079
  let rejected = [];
1664
2080
  if (face.length > 0) {
1665
2081
  const raw = await withPhase("validate", emit, signal, () => validateTargets(face, {
1666
- roots: resolved.roots,
2082
+ roots: [...resolved.roots],
1667
2083
  home: resolved.home,
1668
2084
  style: resolved.style,
1669
2085
  signal
@@ -1678,7 +2094,8 @@ async function executeRun(resolved, options, signal) {
1678
2094
  };
1679
2095
  if (rejected.length === 0) {
1680
2096
  removal = await withPhase("remove", emit, signal, async () => removeTargets(raw.accepted, {
1681
- roots: await toTrustRoots(resolved.roots),
2097
+ roots: await toTrustRoots([...resolved.roots]),
2098
+ style: resolved.style,
1682
2099
  signal,
1683
2100
  onProgress: (event) => {
1684
2101
  if (event.kind === "removed" || event.kind === "missing") {
@@ -1701,7 +2118,7 @@ async function executeRun(resolved, options, signal) {
1701
2118
  status = "rejected";
1702
2119
  else
1703
2120
  status = "executed";
1704
- const entries = buildOutcomeEntries(plan, expectedSet, stale, rejected, removal);
2121
+ const entries = buildOutcomeEntries(plan, expectedSet, stale, rejected, validation?.mappings ?? [], removal);
1705
2122
  const releasedBytes = entries.reduce((sum, entry) => isSuccessOutcome(entry.outcome) ? sum + (entry.bytes ?? 0) : sum, 0);
1706
2123
  const report = {
1707
2124
  status,
@@ -1743,7 +2160,7 @@ export {
1743
2160
  anchorChainPaths,
1744
2161
  classifyTarget,
1745
2162
  collectSkips,
1746
- createParallelScanner as createScanner,
2163
+ createScanner,
1747
2164
  createSizer,
1748
2165
  createSweeper,
1749
2166
  crossDeviceIndex,
@@ -1762,6 +2179,7 @@ export {
1762
2179
  isHomeBody,
1763
2180
  isSuccessOutcome,
1764
2181
  isSweepError,
2182
+ isSweepErrorCode,
1765
2183
  loadConfig,
1766
2184
  loadResolvedConfig,
1767
2185
  mergeNames,