@sfmc-bds/bds-tools 0.2.0-beta.0 → 0.2.0-beta.10

package/dist/world-packs.test.js

@@ -0,0 +1,676 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { after, before, describe, it } from "node:test";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+const CLI = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "dist", "cli-pack-manager.js");
+function run(args) {
+  const r = spawnSync(process.execPath, [CLI, ...args], { encoding: "utf8" });
+  return { status: r.status, out: r.stdout ?? "", err: r.stderr ?? "" };
+}
+function writeManifest(dir, { name, uuid, version, type }) {
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(
+    path.join(dir, "manifest.json"),
+    JSON.stringify(
+      {
+        format_version: 2,
+        header: { name, uuid, version, description: "test" },
+        modules: [{ type, uuid: cryptoRandom(), version }]
+      },
+      null,
+      2
+    )
+  );
+}
+function cryptoRandom() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+describe("world-packs primitives", () => {
+  let tmp;
+  before(() => {
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), "sfmc-wp-"));
+  });
+  after(() => {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  });
+  it("formatWorldPackFolderName \u53BB\u683C\u5F0F\u7801/\u540E\u7F00\u5E76\u52A0\u524D\u7F00", async () => {
+    const { formatWorldPackFolderName, isGenericPackFolderStem } = await import("./world-packs.js");
+    assert.equal(formatWorldPackFolderName("\xA7aCool\xA7l Textures.mcpack", "resource"), "[RP] Cool Textures");
+    assert.equal(formatWorldPackFolderName("My BP.zip", "behavior"), "[BP] My BP");
+    assert.equal(formatWorldPackFolderName("[RP] Already", "resource"), "[RP] Already");
+    assert.equal(isGenericPackFolderStem("B"), true);
+    assert.equal(isGenericPackFolderStem("[RP] R"), true);
+    assert.equal(isGenericPackFolderStem("Slash Blade"), false);
+  });
+  it("discoverPackRoots maxDepth=2", async () => {
+    const { discoverPackRoots } = await import("./world-packs.js");
+    const root = path.join(tmp, "discover");
+    const nested = path.join(root, "outer", "inner-pack");
+    writeManifest(nested, {
+      name: "Inner",
+      uuid: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+      version: [1, 0, 0],
+      type: "resources"
+    });
+    const found = discoverPackRoots(root, { maxDepth: 2 });
+    assert.ok(found.some((p) => path.resolve(p) === path.resolve(nested)));
+  });
+  it("resolvePackRoots\uFF1A\u6241\u5E73\u76EE\u5F55 / \u5B50\u76EE\u5F55 BP+RP", async () => {
+    const { resolvePackRoots, readPackManifestInfo } = await import("./world-packs.js");
+    const flat = path.join(tmp, "flat-pack");
+    writeManifest(flat, {
+      name: "FlatBP",
+      uuid: "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
+      version: [1, 0, 0],
+      type: "data"
+    });
+    const flatRes = await resolvePackRoots(flat);
+    try {
+      assert.equal(flatRes.roots.length, 1);
+      assert.equal(readPackManifestInfo(flatRes.roots[0])?.name, "FlatBP");
+    } finally {
+      flatRes.dispose();
+    }
+    const nest = path.join(tmp, "nest-dir");
+    writeManifest(path.join(nest, "BP"), {
+      name: "NestBP",
+      uuid: "cccccccc-cccc-cccc-cccc-cccccccccccc",
+      version: [1, 0, 0],
+      type: "data"
+    });
+    writeManifest(path.join(nest, "RP"), {
+      name: "NestRP",
+      uuid: "dddddddd-dddd-dddd-dddd-dddddddddddd",
+      version: [1, 0, 0],
+      type: "resources"
+    });
+    const nestRes = await resolvePackRoots(nest);
+    try {
+      assert.equal(nestRes.roots.length, 2);
+      const kinds = nestRes.roots.map((r) => readPackManifestInfo(r)?.kind).sort();
+      assert.deepEqual(kinds, ["behavior", "resource"]);
+    } finally {
+      nestRes.dispose();
+    }
+  });
+  it("resolvePackRoots\uFF1Amcaddon \u5185\u5D4C mcpack + zip \u5957\u5A03", async () => {
+    const JSZip = (await import("jszip")).default;
+    const { resolvePackRoots, readPackManifestInfo } = await import("./world-packs.js");
+    async function zipDirAsArchive(entries, outFile) {
+      const zip2 = new JSZip();
+      for (const [name, content] of entries) {
+        zip2.file(name, content);
+      }
+      const buf = await zip2.generateAsync({ type: "nodebuffer" });
+      fs.mkdirSync(path.dirname(outFile), { recursive: true });
+      fs.writeFileSync(outFile, buf);
+    }
+    function manifestJson({ name, uuid, version, type }) {
+      return JSON.stringify({
+        format_version: 2,
+        header: { name, uuid, version, description: "test" },
+        modules: [{ type, uuid: cryptoRandom(), version }]
+      });
+    }
+    const rpMcpack = path.join(tmp, "nested-build", "inner-rp.mcpack");
+    await zipDirAsArchive(
+      [
+        [
+          "manifest.json",
+          manifestJson({
+            name: "InnerRP",
+            uuid: "eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee",
+            version: [1, 0, 0],
+            type: "resources"
+          })
+        ]
+      ],
+      rpMcpack
+    );
+    const bpManifest = manifestJson({
+      name: "OuterBP",
+      uuid: "ffffffff-ffff-ffff-ffff-ffffffffffff",
+      version: [1, 0, 0],
+      type: "data"
+    });
+    const addon = path.join(tmp, "nested-build", "bundle.mcaddon");
+    const zip = new JSZip();
+    zip.file("BP/manifest.json", bpManifest);
+    zip.file("inner-rp.mcpack", fs.readFileSync(rpMcpack));
+    fs.writeFileSync(addon, await zip.generateAsync({ type: "nodebuffer" }));
+    const addonRes = await resolvePackRoots(addon);
+    try {
+      assert.equal(addonRes.roots.length, 2, `roots=${JSON.stringify(addonRes.roots)}`);
+      const names = addonRes.roots.map((r) => readPackManifestInfo(r)?.name).sort();
+      assert.deepEqual(names, ["InnerRP", "OuterBP"]);
+    } finally {
+      addonRes.dispose();
+    }
+    const leafMcpack = path.join(tmp, "nested-build", "leaf.mcpack");
+    await zipDirAsArchive(
+      [
+        [
+          "manifest.json",
+          manifestJson({
+            name: "LeafPack",
+            uuid: "12121212-1212-1212-1212-121212121212",
+            version: [2, 0, 0],
+            type: "data"
+          })
+        ]
+      ],
+      leafMcpack
+    );
+    const outerZip = path.join(tmp, "nested-build", "outer.zip");
+    const z2 = new JSZip();
+    z2.file("leaf.mcpack", fs.readFileSync(leafMcpack));
+    fs.writeFileSync(outerZip, await z2.generateAsync({ type: "nodebuffer" }));
+    const zipRes = await resolvePackRoots(outerZip);
+    try {
+      assert.equal(zipRes.roots.length, 1);
+      assert.equal(readPackManifestInfo(zipRes.roots[0])?.name, "LeafPack");
+    } finally {
+      zipRes.dispose();
+    }
+  });
+  it("bumpPackPatchVersion \u540C\u6B65 header \u4E0E modules", async () => {
+    const { bumpPackPatchVersion, readPackManifestInfo } = await import("./world-packs.js");
+    const dir = path.join(tmp, "bump-rp");
+    writeManifest(dir, {
+      name: "BumpMe",
+      uuid: "11111111-2222-3333-4444-555555555555",
+      version: [1, 2, 3],
+      type: "resources"
+    });
+    const next = bumpPackPatchVersion(dir);
+    assert.deepEqual(next, [1, 2, 4]);
+    const info = readPackManifestInfo(dir);
+    assert.deepEqual(info?.version, [1, 2, 4]);
+    const raw = JSON.parse(fs.readFileSync(path.join(dir, "manifest.json"), "utf8"));
+    assert.deepEqual(raw.modules[0].version, [1, 2, 4]);
+  });
+  it("ensureVersionGreaterThan / nextEnabledVersion\uFF1Abump(max(\u65B0\u5305, \u65E7\u7248))", async () => {
+    const { ensureVersionGreaterThan, nextEnabledVersion, readPackManifestInfo } = await import("./world-packs.js");
+    assert.deepEqual(nextEnabledVersion([1, 0, 0], [1, 21, 100], "patch"), [1, 21, 101]);
+    const dir = path.join(tmp, "bump-floor");
+    writeManifest(dir, {
+      name: "SlashRp",
+      uuid: "8b450660-c968-3d5e-696e-b7f14c03388a",
+      version: [1, 0, 0],
+      type: "resources"
+    });
+    const next = ensureVersionGreaterThan(dir, [1, 21, 100], "patch");
+    assert.deepEqual(next, [1, 21, 101]);
+    assert.deepEqual(readPackManifestInfo(dir)?.version, [1, 21, 101]);
+  });
+  it("list-installed CLI + listInstalledWorldPacks", async () => {
+    const { listInstalledWorldPacks } = await import("./world-packs.js");
+    const bds = path.join(tmp, "bds");
+    const level = "Bedrock level";
+    const rpDir = path.join(bds, "worlds", level, "resource_packs", "[RP] Tex");
+    writeManifest(rpDir, {
+      name: "Tex",
+      uuid: "99999999-8888-7777-6666-555555555555",
+      version: [0, 1, 0],
+      type: "resources"
+    });
+    fs.mkdirSync(path.join(bds, "worlds", level), { recursive: true });
+    fs.writeFileSync(
+      path.join(bds, "worlds", level, "world_resource_packs.json"),
+      JSON.stringify([{ pack_id: "99999999-8888-7777-6666-555555555555", version: [0, 1, 0] }])
+    );
+    const list = listInstalledWorldPacks(bds, level);
+    assert.equal(list.length, 1);
+    assert.equal(list[0].enabled, true);
+    assert.equal(list[0].kind, "resource");
+    const cli = run(["list-installed", "--bds-root", bds, "--level", level]);
+    assert.equal(cli.status, 0, cli.err || cli.out);
+    const parsed = JSON.parse(cli.out.trim());
+    assert.equal(parsed.length, 1);
+  });
+  it("bump-version CLI", async () => {
+    const dir = path.join(tmp, "cli-bump");
+    writeManifest(dir, {
+      name: "CliBump",
+      uuid: "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
+      version: [2, 0, 0],
+      type: "resources"
+    });
+    const cli = run(["bump-version", "--pack-dir", dir]);
+    assert.equal(cli.status, 0, cli.err || cli.out);
+    const { version } = JSON.parse(cli.out.trim());
+    assert.deepEqual(version, [2, 0, 1]);
+  });
+  it("scanDestOccupancy / readPackDirOccupancy\uFF1A\u5B8C\u6574\u4E0E\u6B8B\u7F3A manifest", async () => {
+    const { scanDestOccupancy, readPackDirOccupancy, formatWorldPackFolderName } = await import("./world-packs.js");
+    const parent = path.join(tmp, "occupancy-scan");
+    const fullName = formatWorldPackFolderName("Full", "resource");
+    const brokenName = formatWorldPackFolderName("Broken", "behavior");
+    const fullDir = path.join(parent, fullName);
+    const brokenDir = path.join(parent, brokenName);
+    writeManifest(fullDir, {
+      name: "Full Pack",
+      uuid: "11111111-1111-1111-1111-111111111111",
+      version: [2, 3, 4],
+      type: "resources"
+    });
+    fs.mkdirSync(brokenDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(brokenDir, "manifest.json"),
+      JSON.stringify({
+        format_version: 2,
+        header: {
+          name: "Broken Pack",
+          uuid: "22222222-2222-2222-2222-222222222222",
+          version: [9, 0, 1]
+        },
+        modules: []
+      })
+    );
+    const fullFacts = readPackDirOccupancy(fullDir);
+    assert.equal(fullFacts?.uuid, "11111111-1111-1111-1111-111111111111");
+    assert.deepEqual(fullFacts?.version, [2, 3, 4]);
+    assert.equal(fullFacts?.kind, "resource");
+    const brokenFacts = readPackDirOccupancy(brokenDir);
+    assert.equal(brokenFacts?.uuid, "22222222-2222-2222-2222-222222222222");
+    assert.deepEqual(brokenFacts?.version, [9, 0, 1]);
+    assert.equal(brokenFacts?.kind, void 0);
+    const occ = scanDestOccupancy(parent);
+    assert.equal(occ.length, 2);
+    const byFolder = Object.fromEntries(occ.map((o) => [o.folderName, o]));
+    assert.equal(byFolder[fullName]?.uuid, "11111111-1111-1111-1111-111111111111");
+    assert.equal(byFolder[fullName]?.kind, "resource");
+    assert.equal(byFolder[brokenName]?.uuid, "22222222-2222-2222-2222-222222222222");
+    assert.equal(byFolder[brokenName]?.kind, void 0);
+  });
+  it("decidePackInstallPlan \u8868\u9A71\u52A8", async () => {
+    const { decidePackInstallPlan, formatWorldPackFolderName } = await import("./world-packs.js");
+    const uuidA = "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa";
+    const uuidB = "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb";
+    const mk = (over) => ({
+      name: "Foo",
+      uuid: uuidB,
+      version: [1, 0, 0],
+      kind: "behavior",
+      ...over
+    });
+    const cases = [
+      {
+        title: "\u7A7A\u5360\u7528 + hint B \u2192 fresh \u7528 manifest \u540D",
+        incoming: mk({ name: "Foo", uuid: uuidB }),
+        hint: "B",
+        occupancy: [],
+        force: false,
+        expectKind: "fresh",
+        expectFolder: "[BP] Foo"
+      },
+      {
+        title: "\u5DF2\u6709 [BP] B uuidA + \u65B0 uuidB hint B \u2192 fresh \u4E14\u4E0D\u5360\u7528 B",
+        incoming: mk({ name: "pack.name", uuid: uuidB, version: [5, 0, 4] }),
+        hint: "B",
+        occupancy: [
+          {
+            folderName: "[BP] B",
+            dir: "/x/[BP] B",
+            uuid: uuidA,
+            version: [1, 0, 0],
+            name: "Slash"
+          }
+        ],
+        force: false,
+        expectKind: "fresh",
+        expectFolderNot: "[BP] B"
+      },
+      {
+        title: "\u540C uuid \u7248\u672C\u66F4\u9AD8 !force \u2192 overwriteInPlace",
+        incoming: mk({ name: "Slash v2", uuid: uuidA, version: [1, 2, 0] }),
+        hint: "Other",
+        occupancy: [
+          {
+            folderName: "[BP] B",
+            dir: "/x/[BP] B",
+            uuid: uuidA,
+            version: [1, 1, 0],
+            name: "Slash"
+          }
+        ],
+        force: false,
+        expectKind: "overwriteInPlace",
+        expectFolder: "[BP] B"
+      },
+      {
+        title: "\u540C uuid \u7248\u672C\u76F8\u7B49 !force \u2192 needConfirm",
+        incoming: mk({ name: "Slash", uuid: uuidA, version: [1, 1, 0] }),
+        hint: "Other",
+        occupancy: [
+          {
+            folderName: "[BP] B",
+            dir: "/x/[BP] B",
+            uuid: uuidA,
+            version: [1, 1, 0],
+            name: "Slash"
+          }
+        ],
+        force: false,
+        expectKind: "needConfirm",
+        expectFolder: "[BP] B"
+      },
+      {
+        title: "\u540C uuid \u7248\u672C\u66F4\u4F4E !force \u2192 needConfirm",
+        incoming: mk({ name: "Slash", uuid: uuidA, version: [1, 0, 0] }),
+        hint: "Other",
+        occupancy: [
+          {
+            folderName: "[BP] B",
+            dir: "/x/[BP] B",
+            uuid: uuidA,
+            version: [1, 1, 0],
+            name: "Slash"
+          }
+        ],
+        force: false,
+        expectKind: "needConfirm",
+        expectFolder: "[BP] B"
+      },
+      {
+        title: "\u540C uuid \u964D\u7EA7 + force \u2192 overwriteInPlace",
+        incoming: mk({ name: "Slash old", uuid: uuidA, version: [1, 0, 0] }),
+        hint: "Other",
+        occupancy: [
+          {
+            folderName: "[BP] B",
+            dir: "/x/[BP] B",
+            uuid: uuidA,
+            version: [1, 1, 0],
+            name: "Slash"
+          }
+        ],
+        force: true,
+        expectKind: "overwriteInPlace",
+        expectFolder: "[BP] B"
+      },
+      {
+        title: "\u4E24\u4EBA\u540D\u649E\u8F66 \u2192 fresh \u5E26 uuid \u540E\u7F00",
+        incoming: mk({ name: "Cool", uuid: uuidB, version: [1, 0, 0] }),
+        hint: "Cool",
+        occupancy: [
+          {
+            folderName: formatWorldPackFolderName("Cool", "behavior"),
+            dir: "/x/a",
+            uuid: uuidA,
+            version: [1, 0, 0]
+          }
+        ],
+        force: false,
+        expectKind: "fresh",
+        expectFolder: formatWorldPackFolderName(`Cool ${uuidB.slice(0, 8)}`, "behavior")
+      }
+    ];
+    for (const c of cases) {
+      const plan = decidePackInstallPlan({
+        incoming: c.incoming,
+        hint: c.hint,
+        occupancy: c.occupancy,
+        force: c.force
+      });
+      assert.equal(plan.kind, c.expectKind, c.title);
+      if (c.expectFolder) assert.equal(plan.folderName, c.expectFolder, c.title);
+      if (c.expectFolderNot) assert.notEqual(plan.folderName, c.expectFolderNot, c.title);
+      if (plan.kind === "overwriteInPlace" || plan.kind === "needConfirm") {
+        assert.equal(plan.folderName, c.occupancy[0].folderName, `${c.title}: \u5FC5\u987B\u539F\u5730`);
+      }
+    }
+  });
+  it("installPackDirectory FS\uFF1A\u5F02 uuid \u6362\u540D\uFF1B\u7248\u672C\u5347\u7EA7\u9759\u9ED8\u8986\u76D6\uFF1B\u540C\u7248\u9700 force", async () => {
+    const { installPackDirectory, formatWorldPackFolderName, readPackManifestInfo } = await import("./world-packs.js");
+    const dest = path.join(tmp, "conflict-parent");
+    const existingB = path.join(dest, formatWorldPackFolderName("B", "behavior"));
+    writeManifest(existingB, {
+      name: "Slash Blade",
+      uuid: "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
+      version: [1, 0, 0],
+      type: "data"
+    });
+    const src = path.join(tmp, "incoming-bp");
+    writeManifest(src, {
+      name: "pack.name",
+      uuid: "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
+      version: [5, 0, 4],
+      type: "data"
+    });
+    const r = await installPackDirectory({
+      srcDir: src,
+      destParent: dest,
+      folderName: "B",
+      force: false
+    });
+    assert.equal(r.ok, true, r.reason);
+    assert.notEqual(path.basename(r.destDir), path.basename(existingB));
+    assert.equal(readPackManifestInfo(existingB)?.uuid, "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa");
+    const srcUp = path.join(tmp, "incoming-upgrade");
+    writeManifest(srcUp, {
+      name: "Slash Blade v2",
+      uuid: "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
+      version: [2, 0, 0],
+      type: "data"
+    });
+    const up = await installPackDirectory({
+      srcDir: srcUp,
+      destParent: dest,
+      folderName: "Totally Different Hint",
+      force: false
+    });
+    assert.equal(up.ok, true, up.reason);
+    assert.equal(up.conflict, void 0);
+    assert.equal(up.destDir && path.basename(up.destDir), path.basename(existingB));
+    assert.equal(readPackManifestInfo(existingB)?.version.join("."), "2.0.0");
+    assert.equal(fs.readdirSync(dest).filter((n) => n.startsWith("[BP]")).length, 2);
+    const srcSame = path.join(tmp, "incoming-same-ver");
+    writeManifest(srcSame, {
+      name: "Slash Blade v2b",
+      uuid: "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
+      version: [2, 0, 0],
+      type: "data"
+    });
+    const c = await installPackDirectory({
+      srcDir: srcSame,
+      destParent: dest,
+      force: false
+    });
+    assert.equal(c.ok, false);
+    assert.equal(c.reason, "conflict");
+    const forced = await installPackDirectory({
+      srcDir: srcSame,
+      destParent: dest,
+      force: true
+    });
+    assert.equal(forced.ok, true, forced.reason);
+    assert.equal(forced.destDir && path.basename(forced.destDir), path.basename(existingB));
+    assert.equal(readPackManifestInfo(existingB)?.name, "Slash Blade v2b");
+  });
+  it("installPackDirectory\uFF1A\u6B8B\u7F3A manifest \u5360\u7528\u76EE\u5F55\u65F6\u6362\u540D\u800C\u975E\u8986\u76D6", async () => {
+    const { installPackDirectory, formatWorldPackFolderName } = await import("./world-packs.js");
+    const dest = path.join(tmp, "broken-parent");
+    const folderName = formatWorldPackFolderName("Broken", "resource");
+    const existingDir = path.join(dest, folderName);
+    fs.mkdirSync(existingDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(existingDir, "manifest.json"),
+      JSON.stringify({
+        format_version: 2,
+        header: {
+          name: "Broken",
+          uuid: "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
+          version: [1, 0, 0]
+        },
+        modules: []
+      })
+    );
+    const src = path.join(tmp, "incoming-rp");
+    writeManifest(src, {
+      name: "Incoming",
+      uuid: "cccccccc-cccc-cccc-cccc-cccccccccccc",
+      version: [1, 0, 0],
+      type: "resources"
+    });
+    const r = await installPackDirectory({
+      srcDir: src,
+      destParent: dest,
+      folderName: "Broken",
+      force: false
+    });
+    assert.equal(r.ok, true, r.reason);
+    assert.notEqual(r.destDir && path.basename(r.destDir), folderName);
+    const still = JSON.parse(fs.readFileSync(path.join(existingDir, "manifest.json"), "utf8"));
+    assert.equal(still.header.uuid, "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb");
+  });
+  it("installPackDirectory\uFF1A\u6B8B\u7F3A manifest \u540C uuid \u2192 \u6309\u7248\u672C\u51B3\u7B56\uFF08\u975E\u65C1\u8DEF\u65B0\u76EE\u5F55\uFF09", async () => {
+    const { installPackDirectory, formatWorldPackFolderName, readPackManifestInfo } = await import("./world-packs.js");
+    const dest = path.join(tmp, "broken-same-uuid");
+    const folderName = formatWorldPackFolderName("Legacy", "behavior");
+    const existingDir = path.join(dest, folderName);
+    fs.mkdirSync(existingDir, { recursive: true });
+    const uuid = "eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee";
+    fs.writeFileSync(
+      path.join(existingDir, "manifest.json"),
+      JSON.stringify({
+        format_version: 2,
+        header: { name: "Legacy", uuid, version: [1, 0, 0] },
+        modules: []
+      })
+    );
+    const srcSame = path.join(tmp, "incoming-same-broken");
+    writeManifest(srcSame, {
+      name: "Fixed",
+      uuid,
+      version: [1, 0, 0],
+      type: "data"
+    });
+    const c = await installPackDirectory({
+      srcDir: srcSame,
+      destParent: dest,
+      folderName: "OtherHint",
+      force: false
+    });
+    assert.equal(c.ok, false);
+    assert.equal(c.reason, "conflict");
+    assert.equal(c.conflict?.existing.dir, existingDir);
+    const srcUp = path.join(tmp, "incoming-up-broken");
+    writeManifest(srcUp, {
+      name: "Fixed v2",
+      uuid,
+      version: [1, 1, 0],
+      type: "data"
+    });
+    const up = await installPackDirectory({
+      srcDir: srcUp,
+      destParent: dest,
+      folderName: "OtherHint",
+      force: false
+    });
+    assert.equal(up.ok, true, up.reason);
+    assert.equal(up.destDir, existingDir);
+    assert.equal(readPackManifestInfo(existingDir)?.version.join("."), "1.1.0");
+  });
+  it("uninstallInstalledPack\uFF1A\u56DE\u6536\u7AD9 / purge / \u76EE\u5F55\u7F3A\u5931", async () => {
+    const { uninstallInstalledPack, listInstalledWorldPacks } = await import("./world-packs.js");
+    const bds = path.join(tmp, "uninstall-bds");
+    const level = "Bedrock level";
+    const folder = "[BP] Gone";
+    const uuid = "dddddddd-dddd-dddd-dddd-dddddddddddd";
+    const packDir = path.join(bds, "worlds", level, "behavior_packs", folder);
+    writeManifest(packDir, {
+      name: "Gone",
+      uuid,
+      version: [1, 0, 0],
+      type: "data"
+    });
+    fs.mkdirSync(path.join(bds, "worlds", level), { recursive: true });
+    fs.writeFileSync(
+      path.join(bds, "worlds", level, "world_behavior_packs.json"),
+      JSON.stringify([{ pack_id: uuid, version: [1, 0, 0] }])
+    );
+    const packs = listInstalledWorldPacks(bds, level);
+    assert.equal(packs.length, 1);
+    const trash = path.join(tmp, "trash-bin");
+    const trashed = await uninstallInstalledPack({
+      bdsRoot: bds,
+      levelName: level,
+      pack: packs[0],
+      trashDir: trash
+    });
+    assert.equal(trashed.action, "trashed");
+    assert.ok(trashed.dest && fs.existsSync(trashed.dest));
+    assert.equal(fs.existsSync(packDir), false);
+    const enable = JSON.parse(
+      fs.readFileSync(path.join(bds, "worlds", level, "world_behavior_packs.json"), "utf8")
+    );
+    assert.equal(enable.length, 0);
+    const phantom = {
+      ...packs[0],
+      dir: path.join(bds, "worlds", level, "behavior_packs", "no-such"),
+      enabled: false
+    };
+    const missing = await uninstallInstalledPack({
+      bdsRoot: bds,
+      levelName: level,
+      pack: phantom,
+      trashDir: trash
+    });
+    assert.equal(missing.action, "missing");
+    const folder2 = "[BP] PurgeMe";
+    const uuid2 = "eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee";
+    const packDir2 = path.join(bds, "worlds", level, "behavior_packs", folder2);
+    writeManifest(packDir2, {
+      name: "PurgeMe",
+      uuid: uuid2,
+      version: [1, 0, 0],
+      type: "data"
+    });
+    fs.writeFileSync(
+      path.join(bds, "worlds", level, "world_behavior_packs.json"),
+      JSON.stringify([{ pack_id: uuid2, version: [1, 0, 0] }])
+    );
+    const packs2 = listInstalledWorldPacks(bds, level);
+    const purged = await uninstallInstalledPack({
+      bdsRoot: bds,
+      levelName: level,
+      pack: packs2.find((p) => p.uuid === uuid2),
+      trashDir: null
+    });
+    assert.equal(purged.action, "deleted");
+    assert.equal(fs.existsSync(packDir2), false);
+  });
+  it("readPackManifestInfo \u9047 UTF-8 BOM \u4ECD\u53EF\u8BFB\u51FA uuid/name\uFF08\u5265\u79BB\u517C\u5BB9\uFF09", async () => {
+    const { readPackManifestInfo } = await import("./world-packs.js");
+    const dir = path.join(tmp, "bom-rp");
+    fs.mkdirSync(dir, { recursive: true });
+    const body = JSON.stringify(
+      {
+        format_version: 2,
+        header: {
+          name: "\xA7l\xA7a\u795E\u91D1",
+          uuid: "2b6de4b1-1f74-4c6e-937b-77f5e9c1f199",
+          version: [1, 0, 4]
+        },
+        modules: [{ type: "resources", uuid: "1c710355-15e2-4293-8574-788eec05d35f", version: [1, 0, 4] }]
+      },
+      null,
+      2
+    );
+    fs.writeFileSync(path.join(dir, "manifest.json"), `\uFEFF${body}`, "utf8");
+    const info = readPackManifestInfo(dir);
+    assert.ok(info);
+    assert.equal(info.uuid, "2b6de4b1-1f74-4c6e-937b-77f5e9c1f199");
+    assert.equal(info.name, "\xA7l\xA7a\u795E\u91D1");
+    assert.equal(info.kind, "resource");
+  });
+});
+//# sourceMappingURL=world-packs.test.js.map