@sfmc-bds/bds-tools 0.2.0-beta.16 → 0.2.0-beta.18

package/dist/world-packs.test.js

@@ -1,698 +0,0 @@
-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");
-  });
-  it("readPackManifestInfo \u5C06 pack.name \u89E3\u6790\u4E3A\u8BED\u8A00\u5305\u540D\u79F0\uFF0C\u5E76\u5728\u5217\u8868\u4E2D\u4FDD\u7559\u771F\u5B9E\u6587\u4EF6\u5939\u540D", async () => {
-    const { listInstalledWorldPacks, readPackManifestInfo } = await import("./world-packs.js");
-    const bds = path.join(tmp, "localized-bds");
-    const level = "LocalizedWorld";
-    const folderName = "[RP] \u539F\u59CB\u8D44\u6E90\u5305\u6587\u4EF6\u5939";
-    const dir = path.join(bds, "worlds", level, "resource_packs", folderName);
-    const uuid = "ce6a8b4f-f349-47e5-b196-9b4249870a6a";
-    writeManifest(dir, { name: "pack.name", uuid, version: [1, 2, 3], type: "resources" });
-    fs.mkdirSync(path.join(dir, "texts"), { recursive: true });
-    fs.writeFileSync(path.join(dir, "texts", "languages.json"), JSON.stringify(["zh_CN", "en_US"]));
-    fs.writeFileSync(
-      path.join(dir, "texts", "zh_CN.lang"),
-      "\uFEFF# \u8D44\u6E90\u5305\u672C\u5730\u5316\npack.name=\u795E\u5947\u8D44\u6E90\u5305\npack.description=\u8BF4\u660E=\u53EF\u4EE5\u5305\u542B\u7B49\u53F7\n",
-      "utf8"
-    );
-    fs.writeFileSync(path.join(dir, "texts", "en_US.lang"), "pack.name=Amazing Resource Pack\n", "utf8");
-    assert.equal(readPackManifestInfo(dir)?.name, "\u795E\u5947\u8D44\u6E90\u5305");
-    const listed = listInstalledWorldPacks(bds, level);
-    assert.equal(listed.length, 1);
-    assert.equal(listed[0]?.folderName, folderName);
-    assert.equal(listed[0]?.name, "\u795E\u5947\u8D44\u6E90\u5305");
-  });
-});
-//# sourceMappingURL=world-packs.test.js.map