@playdrop/playdrop-cli 0.16.12 → 0.17.0

package/node_modules/@playdrop/game-source-git/dist/src/repository.js

@@ -0,0 +1,213 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncAuthoritativeListing = syncAuthoritativeListing;
+exports.initializeGameSourceRepository = initializeGameSourceRepository;
+exports.fastForwardTaskBranch = fastForwardTaskBranch;
+exports.importAdditionalSourceVersions = importAdditionalSourceVersions;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const archive_js_1 = require("./archive.js");
+const git_js_1 = require("./git.js");
+const ignore_js_1 = require("./ignore.js");
+const lock_js_1 = require("./lock.js");
+const paths_js_1 = require("./paths.js");
+function updateCatalogueListing(content, listing) {
+    let root;
+    try {
+        root = JSON.parse(content.toString("utf8"));
+    }
+    catch {
+        throw new Error("game_source_catalogue_invalid");
+    }
+    if (!root || typeof root !== "object" || Array.isArray(root))
+        throw new Error("game_source_catalogue_invalid");
+    const record = root;
+    const app = Array.isArray(record["apps"])
+        ? record["apps"].find((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry))
+        : record;
+    if (!app)
+        throw new Error("game_source_catalogue_app_missing");
+    app["version"] = listing.version;
+    const assignOptional = (key, value) => {
+        if (value === null)
+            delete app[key];
+        else
+            app[key] = value;
+    };
+    assignOptional("displayName", listing.displayName);
+    assignOptional("subtitle", listing.subtitle);
+    assignOptional("description", listing.description);
+    const media = {};
+    const assignPath = (key, value) => {
+        if (value)
+            media[key] = value;
+    };
+    assignPath("icon", listing.iconPath);
+    assignPath("heroPortrait", listing.heroPortraitPath);
+    assignPath("heroLandscape", listing.heroLandscapePath);
+    assignPath("socialLandscape", listing.socialLandscapePath);
+    if (listing.screenshotsPortrait.length > 0)
+        media["screenshotsPortrait"] = [...listing.screenshotsPortrait];
+    if (listing.screenshotsLandscape.length > 0)
+        media["screenshotsLandscape"] = [...listing.screenshotsLandscape];
+    if (listing.videosPortrait.length > 0)
+        media["videosPortrait"] = [...listing.videosPortrait];
+    if (listing.videosLandscape.length > 0)
+        media["videosLandscape"] = [...listing.videosLandscape];
+    app["listing"] = media;
+    return Buffer.from(`${JSON.stringify(root, null, 2)}\n`, "utf8");
+}
+async function syncAuthoritativeListing(input) {
+    const runner = input.runner ?? (0, git_js_1.createGitRunner)();
+    const cataloguePath = node_path_1.default.join(input.repoPath, "catalogue.json");
+    const lockPath = node_path_1.default.join(input.repoPath, paths_js_1.GAME_SOURCE_LOCK_PATH);
+    const previousLock = (0, lock_js_1.parseGameSourceLock)(await (0, promises_1.readFile)(lockPath));
+    const listingLock = (0, lock_js_1.createGameSourceLock)(input.listing.files);
+    for (const [filePath, entry] of Object.entries(listingLock.files)) {
+        const content = input.listing.files.get(filePath);
+        if (!content)
+            throw new Error(`game_source_material_missing:${filePath}`);
+        await input.putImmutableFile(entry.key, content, entry.sha256);
+    }
+    const files = Object.fromEntries(Object.entries(previousLock.files).filter(([filePath]) => !filePath.startsWith("listing/")));
+    Object.assign(files, listingLock.files);
+    await (0, promises_1.rm)(node_path_1.default.join(input.repoPath, "listing"), { recursive: true, force: true });
+    await (0, promises_1.writeFile)(lockPath, (0, lock_js_1.serializeGameSourceLock)({ version: 1, files }));
+    await (0, promises_1.writeFile)(cataloguePath, updateCatalogueListing(await (0, promises_1.readFile)(cataloguePath), input.listing));
+    await runner.run(["add", "-u", "--", "."], input.repoPath);
+    await runner.run(["add", "--force", "--", "catalogue.json", paths_js_1.GAME_SOURCE_LOCK_PATH], input.repoPath);
+    const status = (await runner.run(["status", "--porcelain"], input.repoPath)).toString("utf8").trim();
+    if (!status)
+        return (await runner.run(["rev-parse", "HEAD"], input.repoPath)).toString("utf8").trim();
+    await runner.run([
+        "-c",
+        "user.name=Playdrop Game Source",
+        "-c",
+        "user.email=game-source@playdrop.invalid",
+        "commit",
+        ...(input.listing.updatedAt ? [`--date=${input.listing.updatedAt.toISOString()}`] : []),
+        "-m",
+        "Sync authoritative listing",
+    ], input.repoPath);
+    return (await runner.run(["rev-parse", "HEAD"], input.repoPath)).toString("utf8").trim();
+}
+function compareVersions(left, right) {
+    return (left.version.major - right.version.major ||
+        left.version.minor - right.version.minor ||
+        left.version.patch - right.version.patch ||
+        left.id - right.id);
+}
+async function clearWorkingTree(repoPath) {
+    for (const entry of await (0, promises_1.readdir)(repoPath)) {
+        if (entry === ".git" || entry === "tasks")
+            continue;
+        await (0, promises_1.rm)(node_path_1.default.join(repoPath, entry), { recursive: true, force: true });
+    }
+}
+async function writeRepoFile(repoPath, filePath, content) {
+    const normalized = (0, paths_js_1.normalizeSourcePath)(filePath);
+    const destination = node_path_1.default.join(repoPath, normalized);
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(destination), { recursive: true });
+    await (0, promises_1.writeFile)(destination, content);
+}
+async function commitSnapshot(repoPath, message, createdAt, runner) {
+    await runner.run(["add", "--all", "--force", "--", "."], repoPath);
+    await runner.run([
+        "-c",
+        "user.name=Playdrop Game Source",
+        "-c",
+        "user.email=game-source@playdrop.invalid",
+        "commit",
+        "--allow-empty",
+        ...(createdAt ? [`--date=${createdAt.toISOString()}`] : []),
+        "-m",
+        message,
+    ], repoPath);
+    return (await runner.run(["rev-parse", "HEAD"], repoPath)).toString("utf8").trim();
+}
+async function initializeGameSourceRepository(input) {
+    if (input.versions.length === 0)
+        throw new Error("game_source_versions_required");
+    const runner = input.runner ?? (0, git_js_1.createGitRunner)();
+    await (0, promises_1.mkdir)(input.repoPath, { recursive: true });
+    await runner.run(["init", "-b", "main"], input.repoPath);
+    const imported = [];
+    for (const snapshot of [...input.versions].sort(compareVersions)) {
+        await clearWorkingTree(input.repoPath);
+        const split = await (0, archive_js_1.splitSourceArchive)(snapshot.sourceZip);
+        const lock = (0, lock_js_1.createGameSourceLock)(split.materialFiles);
+        for (const [filePath, entry] of Object.entries(lock.files)) {
+            const content = split.materialFiles.get(filePath);
+            if (!content)
+                throw new Error(`game_source_material_missing:${filePath}`);
+            await input.putImmutableFile(entry.key, content, entry.sha256);
+        }
+        for (const [filePath, content] of split.gitFiles)
+            await writeRepoFile(input.repoPath, filePath, content);
+        await writeRepoFile(input.repoPath, paths_js_1.GAME_SOURCE_LOCK_PATH, (0, lock_js_1.serializeGameSourceLock)(lock));
+        let existingGitignore = "";
+        try {
+            existingGitignore = await (0, promises_1.readFile)(node_path_1.default.join(input.repoPath, ".gitignore"), "utf8");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        await writeRepoFile(input.repoPath, ".gitignore", (0, ignore_js_1.updateManagedGitignore)(existingGitignore));
+        if (snapshot.taskId && snapshot.taskSummary?.trim()) {
+            await writeRepoFile(input.repoPath, `tasks/${snapshot.taskId}.md`, `${snapshot.taskSummary.trim()}\n`);
+        }
+        const commitSha = await commitSnapshot(input.repoPath, `Import v${snapshot.version.major}.${snapshot.version.minor}.${snapshot.version.patch}`, snapshot.createdAt, runner);
+        await runner.run(["tag", (0, git_js_1.versionTagRef)(snapshot.version).slice("refs/tags/".length), commitSha], input.repoPath);
+        imported.push({ id: snapshot.id, version: snapshot.version, commitSha });
+    }
+    const headSha = (await runner.run(["rev-parse", "HEAD"], input.repoPath)).toString("utf8").trim();
+    return { headSha, versions: imported };
+}
+async function fastForwardTaskBranch(input) {
+    const runner = input.runner ?? (0, git_js_1.createGitRunner)();
+    const currentHead = (await runner.run(["rev-parse", "refs/heads/main"], input.repoPath)).toString("utf8").trim();
+    if (currentHead !== input.expectedHeadSha)
+        throw new Error("game_source_base_head_mismatch");
+    const taskHead = (await runner.run(["rev-parse", input.branchRef], input.repoPath)).toString("utf8").trim();
+    await runner.run(["merge-base", "--is-ancestor", currentHead, taskHead], input.repoPath);
+    await runner.run(["update-ref", "refs/heads/main", taskHead, currentHead], input.repoPath);
+    return taskHead;
+}
+async function importAdditionalSourceVersions(input) {
+    const runner = input.runner ?? (0, git_js_1.createGitRunner)();
+    const imported = [];
+    for (const snapshot of input.versions) {
+        await clearWorkingTree(input.repoPath);
+        const split = await (0, archive_js_1.splitSourceArchive)(snapshot.sourceZip);
+        const lock = (0, lock_js_1.createGameSourceLock)(split.materialFiles);
+        for (const [filePath, entry] of Object.entries(lock.files)) {
+            const content = split.materialFiles.get(filePath);
+            if (!content)
+                throw new Error(`game_source_material_missing:${filePath}`);
+            await input.putImmutableFile(entry.key, content, entry.sha256);
+        }
+        for (const [filePath, content] of split.gitFiles)
+            await writeRepoFile(input.repoPath, filePath, content);
+        await writeRepoFile(input.repoPath, paths_js_1.GAME_SOURCE_LOCK_PATH, (0, lock_js_1.serializeGameSourceLock)(lock));
+        let existingGitignore = "";
+        try {
+            existingGitignore = await (0, promises_1.readFile)(node_path_1.default.join(input.repoPath, ".gitignore"), "utf8");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        await writeRepoFile(input.repoPath, ".gitignore", (0, ignore_js_1.updateManagedGitignore)(existingGitignore));
+        if (snapshot.taskId && snapshot.taskSummary?.trim()) {
+            await writeRepoFile(input.repoPath, `tasks/${snapshot.taskId}.md`, `${snapshot.taskSummary.trim()}\n`);
+        }
+        const commitSha = await commitSnapshot(input.repoPath, `Import v${snapshot.version.major}.${snapshot.version.minor}.${snapshot.version.patch}`, snapshot.createdAt, runner);
+        await runner.run(["tag", (0, git_js_1.versionTagRef)(snapshot.version).slice("refs/tags/".length), commitSha], input.repoPath);
+        imported.push({ id: snapshot.id, version: snapshot.version, commitSha });
+    }
+    return imported;
+}

package/node_modules/@playdrop/game-source-git/dist/test/core.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=core.test.d.ts.map

package/node_modules/@playdrop/game-source-git/dist/test/core.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.test.d.ts","sourceRoot":"","sources":["../../test/core.test.ts"],"names":[],"mappings":""}

package/node_modules/@playdrop/game-source-git/dist/test/core.test.js

@@ -0,0 +1,441 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_test_1 = __importDefault(require("node:test"));
+const node_util_1 = require("node:util");
+const jszip_1 = __importDefault(require("jszip"));
+const index_js_1 = require("../src/index.js");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+async function git(cwd, ...args) {
+    const result = await execFileAsync("git", args, {
+        cwd,
+        encoding: "utf8",
+        env: {
+            ...process.env,
+            GIT_AUTHOR_NAME: "Playdrop Test",
+            GIT_AUTHOR_EMAIL: "test@playdrop.invalid",
+            GIT_COMMITTER_NAME: "Playdrop Test",
+            GIT_COMMITTER_EMAIL: "test@playdrop.invalid",
+        },
+    });
+    return result.stdout.trim();
+}
+async function createRepo() {
+    const directory = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "playdrop-game-source-git-"));
+    await git(directory, "init", "-b", "main");
+    await (0, promises_1.writeFile)(node_path_1.default.join(directory, "index.html"), "<main>game</main>\n");
+    await git(directory, "add", "--force", "index.html");
+    await git(directory, "commit", "-m", "Initial game");
+    const head = await git(directory, "rev-parse", "HEAD");
+    return { directory, head };
+}
+(0, node_test_1.default)("private object keys and file classification are canonical", () => {
+    strict_1.default.deepEqual((0, index_js_1.buildGameSourceRepoKeys)(42), {
+        current: "game-source/repos/42/current.bundle",
+        previous: "game-source/repos/42/previous.bundle",
+    });
+    const digest = (0, index_js_1.sha256)(Buffer.from("asset"));
+    strict_1.default.equal((0, index_js_1.buildGameSourceCandidateBundleKey)(42, 91, digest), `game-source/repos/42/candidates/task-91/${digest}.bundle`);
+    strict_1.default.equal((0, index_js_1.buildImmutableFileKey)(digest), `game-source/files/sha256/${digest.slice(0, 2)}/${digest}`);
+    strict_1.default.equal((0, index_js_1.buildTranscriptObjectKey)(19, 2), "agent-task-transcripts/19/attempt-2.jsonl");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)("src/game.ts", Buffer.from("export {};\n")), "git");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)("ignored.ts", Buffer.from("export {};\n")), "git");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)("assets/ship.png", Buffer.from("png")), "material");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)("vendor/sdk.tgz", Buffer.from("archive")), "material");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)("mystery.dat", Buffer.from([0, 1, 2])), "material");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)("transcripts/a.jsonl", Buffer.from("{}\n")), "transcript");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)("node_modules/x.js", Buffer.from("x")), "excluded");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)("remix-source/original/index.html", Buffer.from("old")), "excluded");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)(".scratch/cat.png", Buffer.from("temporary")), "excluded");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)(".art-brief.md", Buffer.from("internal art prompt")), "excluded");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)(".art-manifest.txt", Buffer.from("internal art output")), "excluded");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)(".art-output/manifest.txt", Buffer.from("internal art output")), "excluded");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)(".art-output/preview.png", Buffer.from("internal art preview")), "excluded");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)(".playdrop.json", Buffer.from("{}")), "excluded");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)("evidence/playtest.png", Buffer.from("proof")), "excluded");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)("platform-feedback.md", Buffer.from("internal")), "excluded");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)("next-steps.json", Buffer.from("{}")), "excluded");
+    strict_1.default.equal((0, index_js_1.classifyGameSourceFile)("player-feedback.md", Buffer.from("feedback")), "excluded");
+});
+(0, node_test_1.default)("lock serialization is deterministic and validates immutable keys", () => {
+    const files = new Map([
+        ["listing/hero.png", Buffer.from("hero")],
+        ["assets/ship.glb", Buffer.from("ship")],
+    ]);
+    const lock = (0, index_js_1.createGameSourceLock)(files);
+    const serialized = (0, index_js_1.serializeGameSourceLock)(lock);
+    strict_1.default.deepEqual((0, index_js_1.parseGameSourceLock)(serialized), lock);
+    strict_1.default.ok(serialized.indexOf("assets/ship.glb") < serialized.indexOf("listing/hero.png"));
+    const tampered = JSON.parse(serialized.toString("utf8"));
+    tampered.files["assets/ship.glb"].key = "wrong";
+    strict_1.default.throws(() => (0, index_js_1.parseGameSourceLock)(JSON.stringify(tampered)), /invalid_game_source_lock_key/);
+});
+(0, node_test_1.default)("managed gitignore block preserves creator rules and replaces itself", () => {
+    const first = (0, index_js_1.updateManagedGitignore)("custom.tmp\n");
+    strict_1.default.match(first, /^custom\.tmp\n\n# >>> PLAYDROP/);
+    strict_1.default.match(first, /^\.playdrop\.json$/m);
+    strict_1.default.match(first, /^\.art-\*$/m);
+    strict_1.default.match(first, /^\.playdrop\/$/m);
+    strict_1.default.match(first, /^evidence\/$/m);
+    strict_1.default.match(first, /^\*\.tgz$/m);
+    const second = (0, index_js_1.updateManagedGitignore)(first.replace("assets/", "old-assets/"));
+    strict_1.default.equal(second, first);
+});
+(0, node_test_1.default)("source archive split ignores creator rules and deterministic zip round-trips", async () => {
+    const input = new jszip_1.default();
+    input.file("src/game.ts", "export const game = true;\n");
+    input.file("assets/sound.mp3", Buffer.from("audio"));
+    input.file("transcripts/live.jsonl", "{}\n");
+    input.file("PLAYDROP_TASK.md", "task");
+    const source = await input.generateAsync({ type: "nodebuffer" });
+    const split = await (0, index_js_1.splitSourceArchive)(source);
+    strict_1.default.deepEqual([...split.gitFiles.keys()], ["src/game.ts"]);
+    strict_1.default.deepEqual([...split.materialFiles.keys()], ["assets/sound.mp3"]);
+    strict_1.default.deepEqual([...split.transcriptFiles.keys()], ["transcripts/live.jsonl"]);
+    strict_1.default.deepEqual(split.excludedPaths, ["PLAYDROP_TASK.md"]);
+    const deterministic = (0, index_js_1.createDeterministicSourceZip)(new Map([
+        ["z.txt", Buffer.from("z")],
+        ["a.txt", Buffer.from("a")],
+    ]));
+    const restored = await jszip_1.default.loadAsync(deterministic);
+    strict_1.default.equal(await restored.file("a.txt")?.async("string"), "a");
+    strict_1.default.equal(await restored.file("z.txt")?.async("string"), "z");
+    strict_1.default.deepEqual(deterministic, (0, index_js_1.createDeterministicSourceZip)(new Map([
+        ["a.txt", Buffer.from("a")],
+        ["z.txt", Buffer.from("z")],
+    ])));
+});
+(0, node_test_1.default)("canonical bundle contains exactly main and authoritative version tags", async (context) => {
+    const repo = await createRepo();
+    context.after(async () => (0, promises_1.rm)(repo.directory, { recursive: true, force: true }));
+    await git(repo.directory, "tag", "v1.0.0", repo.head);
+    const expected = {
+        headSha: repo.head,
+        versions: [{ version: { major: 1, minor: 0, patch: 0 }, commitSha: repo.head }],
+    };
+    strict_1.default.deepEqual((0, index_js_1.deriveCanonicalRefs)(expected.versions), ["refs/heads/main", "refs/tags/v1.0.0"]);
+    await (0, index_js_1.validateCanonicalRefTargets)(repo.directory, expected);
+    const bundlePath = node_path_1.default.join(repo.directory, "canonical.bundle");
+    await (0, index_js_1.createCanonicalBundle)({ repoPath: repo.directory, outputPath: bundlePath, expected });
+    await (0, index_js_1.validateBundleHeads)(bundlePath, expected);
+    strict_1.default.ok((await (0, promises_1.readFile)(bundlePath)).length > 0);
+});
+(0, node_test_1.default)("bundle intake permits only stale semantic tags needed for deletion self-heal", async (context) => {
+    const repo = await createRepo();
+    context.after(async () => (0, promises_1.rm)(repo.directory, { recursive: true, force: true }));
+    await git(repo.directory, "tag", "v1.0.0", repo.head);
+    await git(repo.directory, "tag", "v1.0.1", repo.head);
+    const expected = {
+        headSha: repo.head,
+        versions: [{ version: { major: 1, minor: 0, patch: 0 }, commitSha: repo.head }],
+    };
+    const staleTagBundle = node_path_1.default.join(repo.directory, "stale-tag.bundle");
+    await git(repo.directory, "bundle", "create", "--version=2", staleTagBundle, "refs/heads/main", "refs/tags/v1.0.0", "refs/tags/v1.0.1");
+    await (0, index_js_1.validateBundleHeadsForSelfHeal)(staleTagBundle, expected);
+    await strict_1.default.rejects(() => (0, index_js_1.validateBundleHeads)(staleTagBundle, expected), /game_source_bundle_refs_mismatch/);
+    await git(repo.directory, "branch", "unexpected", repo.head);
+    const unexpectedBranchBundle = node_path_1.default.join(repo.directory, "unexpected-branch.bundle");
+    await git(repo.directory, "bundle", "create", "--version=2", unexpectedBranchBundle, "refs/heads/main", "refs/heads/unexpected", "refs/tags/v1.0.0");
+    await strict_1.default.rejects(() => (0, index_js_1.validateBundleHeadsForSelfHeal)(unexpectedBranchBundle, expected), /game_source_bundle_unexpected_ref/);
+});
+(0, node_test_1.default)("bundle command order is pinned for Apple Git", async () => {
+    const calls = [];
+    const head = "a".repeat(40);
+    const runner = {
+        async run(args) {
+            calls.push([...args]);
+            if (args[0] === "show-ref")
+                return Buffer.from(`${head} refs/heads/main\n`);
+            if (args[0] === "bundle" && args[1] === "list-heads")
+                return Buffer.from(`${head} refs/heads/main\n`);
+            return Buffer.alloc(0);
+        },
+    };
+    await (0, index_js_1.createCanonicalBundle)({ repoPath: "/repo", outputPath: "/tmp/current.bundle", expected: { headSha: head, versions: [] } }, runner);
+    strict_1.default.deepEqual(calls[1], [
+        "bundle",
+        "create",
+        "--version=2",
+        "/tmp/current.bundle",
+        "refs/heads/main",
+    ]);
+});
+(0, node_test_1.default)("outgoing object scan rejects media, generated files, oversized blobs, and gitlinks", async (context) => {
+    const mediaRepo = await createRepo();
+    context.after(async () => (0, promises_1.rm)(mediaRepo.directory, { recursive: true, force: true }));
+    await (0, promises_1.writeFile)(node_path_1.default.join(mediaRepo.directory, "bad.png"), "not really png");
+    await git(mediaRepo.directory, "add", "--force", "bad.png");
+    await git(mediaRepo.directory, "commit", "-m", "Bad media");
+    await strict_1.default.rejects(() => (0, index_js_1.scanOutgoingObjects)({ repoPath: mediaRepo.directory, proposedRefs: ["refs/heads/main"] }), /game_source_binary_path_rejected:bad\.png/);
+    const cleanRepo = await createRepo();
+    context.after(async () => (0, promises_1.rm)(cleanRepo.directory, { recursive: true, force: true }));
+    await (0, index_js_1.scanOutgoingObjects)({ repoPath: cleanRepo.directory, proposedRefs: ["refs/heads/main"] });
+    await strict_1.default.rejects(() => (0, index_js_1.scanOutgoingObjects)({ repoPath: cleanRepo.directory, proposedRefs: ["refs/heads/main"], maxBlobBytes: 2 }), /game_source_blob_too_large:index\.html/);
+});
+(0, node_test_1.default)("materialization verifies cache and destination while using the clone operation", async (context) => {
+    const root = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "playdrop-materialized-"));
+    const cache = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "playdrop-blob-cache-"));
+    context.after(async () => Promise.all([
+        (0, promises_1.rm)(root, { recursive: true, force: true }),
+        (0, promises_1.rm)(cache, { recursive: true, force: true }),
+    ]));
+    const content = Buffer.from("ship");
+    const lock = (0, index_js_1.createGameSourceLock)(new Map([["assets/ship.glb", content]]));
+    let cloneCount = 0;
+    await (0, index_js_1.materializeGameSourceLock)({
+        rootDir: root,
+        blobCacheDir: cache,
+        lock,
+        download: async () => content,
+        cloneFile: async (source, destination) => {
+            cloneCount += 1;
+            await (0, promises_1.writeFile)(destination, await (0, promises_1.readFile)(source));
+        },
+    });
+    strict_1.default.equal(cloneCount, 1);
+    strict_1.default.deepEqual(await (0, promises_1.readFile)(node_path_1.default.join(root, "assets/ship.glb")), content);
+});
+(0, node_test_1.default)("materialization uses the macOS clonefile path on the worker filesystem", { skip: process.platform !== "darwin" }, async (context) => {
+    const root = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "playdrop-materialized-clone-"));
+    const cache = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "playdrop-blob-cache-clone-"));
+    context.after(async () => Promise.all([
+        (0, promises_1.rm)(root, { recursive: true, force: true }),
+        (0, promises_1.rm)(cache, { recursive: true, force: true }),
+    ]));
+    const content = Buffer.from("clone me");
+    const lock = (0, index_js_1.createGameSourceLock)(new Map([["assets/clone.glb", content]]));
+    await (0, index_js_1.materializeGameSourceLock)({
+        rootDir: root,
+        blobCacheDir: cache,
+        lock,
+        download: async () => content,
+    });
+    strict_1.default.deepEqual(await (0, promises_1.readFile)(node_path_1.default.join(root, "assets/clone.glb")), content);
+});
+(0, node_test_1.default)("backfill imports semantic versions, preserves summaries, and reconstructs source from Git plus immutable files", async (context) => {
+    const repoPath = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "playdrop-backfill-"));
+    context.after(async () => (0, promises_1.rm)(repoPath, { recursive: true, force: true }));
+    const makeSource = async (code, asset) => {
+        const zip = new jszip_1.default();
+        zip.file("src/game.ts", code);
+        zip.file("catalogue.json", "{}\n");
+        zip.file("assets/ship.glb", Buffer.concat([Buffer.from([0]), Buffer.from(asset)]));
+        return zip.generateAsync({ type: "nodebuffer" });
+    };
+    const sourceV1 = await makeSource("export const version = 1;\n", "one");
+    const sourceV2 = await makeSource("export const version = 2;\n", "two");
+    const immutable = new Map();
+    const initialized = await (0, index_js_1.initializeGameSourceRepository)({
+        repoPath,
+        versions: [
+            {
+                id: 2,
+                version: { major: 1, minor: 1, patch: 0 },
+                sourceZip: sourceV2,
+                taskId: 20,
+                taskSummary: "Updated play",
+            },
+            {
+                id: 1,
+                version: { major: 1, minor: 0, patch: 0 },
+                sourceZip: sourceV1,
+                taskId: 10,
+                taskSummary: "Created game",
+            },
+        ],
+        putImmutableFile: async (key, content) => {
+            const previous = immutable.get(key);
+            if (previous)
+                strict_1.default.deepEqual(previous, content);
+            else
+                immutable.set(key, Buffer.from(content));
+        },
+    });
+    strict_1.default.equal(initialized.versions.length, 2);
+    strict_1.default.equal(await git(repoPath, "rev-parse", "refs/tags/v1.0.0"), initialized.versions[0]?.commitSha);
+    strict_1.default.equal(await git(repoPath, "rev-parse", "refs/tags/v1.1.0"), initialized.versions[1]?.commitSha);
+    strict_1.default.equal(await git(repoPath, "show", `${initialized.headSha}:tasks/10.md`), "Created game");
+    strict_1.default.equal(await git(repoPath, "show", `${initialized.headSha}:tasks/20.md`), "Updated play");
+    strict_1.default.equal((await git(repoPath, "ls-tree", "-r", "--name-only", initialized.headSha)).includes("assets/ship.glb"), false);
+    const exported = await (0, index_js_1.exportGameSourceZip)({
+        repoPath,
+        commitSha: initialized.versions[0]?.commitSha ?? "",
+        loadMaterial: async (key) => {
+            const content = immutable.get(key);
+            if (!content)
+                throw new Error("missing immutable");
+            return content;
+        },
+    });
+    const originalFiles = await jszip_1.default.loadAsync(sourceV1);
+    const exportedFiles = await jszip_1.default.loadAsync(exported);
+    for (const filePath of ["src/game.ts", "catalogue.json", "assets/ship.glb"]) {
+        strict_1.default.deepEqual(await exportedFiles.file(filePath)?.async("nodebuffer"), await originalFiles.file(filePath)?.async("nodebuffer"));
+    }
+});
+(0, node_test_1.default)("canonical bundle persistence initializes both copies and fences later rotation", async () => {
+    const objects = new Map();
+    const writes = [];
+    let nextGeneration = 1;
+    const storage = {
+        async getPrivateObjectMetadata(key) {
+            return objects.get(key)?.metadata ?? null;
+        },
+        async putPrivateObject(key, content, options) {
+            writes.push(key);
+            const previous = objects.get(key);
+            if ((options.ifGenerationMatch === "0" && previous) ||
+                (options.ifGenerationMatch !== "0" && previous?.metadata.generation !== options.ifGenerationMatch)) {
+                throw Object.assign(new Error("conflict"), { code: 412 });
+            }
+            const metadata = {
+                generation: String(nextGeneration++),
+                sizeBytes: content.length,
+                contentType: options.contentType,
+                customMetadata: { ...options.metadata, sha256: options.sha256 },
+            };
+            objects.set(key, { content: Buffer.from(content), metadata });
+            return metadata;
+        },
+        async copyPrivateObject(sourceKey, destinationKey, options) {
+            const source = objects.get(sourceKey);
+            const destination = objects.get(destinationKey);
+            if (!source || source.metadata.generation !== options.sourceGeneration ||
+                destination?.metadata.generation !== options.ifGenerationMatch)
+                throw new Error("conflict");
+            const metadata = {
+                generation: String(nextGeneration++),
+                sizeBytes: source.content.length,
+                contentType: source.metadata.contentType,
+                customMetadata: { ...source.metadata.customMetadata, ...options.metadata },
+            };
+            objects.set(destinationKey, { content: Buffer.from(source.content), metadata });
+            return metadata;
+        },
+    };
+    const first = await (0, index_js_1.persistCanonicalBundle)({
+        storage,
+        currentKey: "current",
+        previousKey: "previous",
+        bundle: Buffer.from("first"),
+        baseGeneration: null,
+        metadata: { task: "1", head: "a".repeat(40) },
+    });
+    strict_1.default.deepEqual(writes.slice(0, 2), ["current", "previous"]);
+    strict_1.default.deepEqual(objects.get("current")?.content, objects.get("previous")?.content);
+    objects.delete("previous");
+    const repaired = await (0, index_js_1.persistCanonicalBundle)({
+        storage,
+        currentKey: "current",
+        previousKey: "previous",
+        bundle: Buffer.from("first"),
+        baseGeneration: null,
+        metadata: { task: "1", head: "a".repeat(40) },
+    });
+    strict_1.default.equal(repaired.generation, first.generation);
+    strict_1.default.deepEqual(objects.get("current")?.content, objects.get("previous")?.content);
+    const second = await (0, index_js_1.persistCanonicalBundle)({
+        storage,
+        currentKey: "current",
+        previousKey: "previous",
+        bundle: Buffer.from("second"),
+        baseGeneration: first.generation,
+        metadata: { task: "2", head: "b".repeat(40) },
+    });
+    strict_1.default.deepEqual(objects.get("previous")?.content, Buffer.from("first"));
+    strict_1.default.deepEqual(objects.get("current")?.content, Buffer.from("second"));
+    await strict_1.default.rejects(() => (0, index_js_1.persistCanonicalBundle)({
+        storage,
+        currentKey: "current",
+        previousKey: "previous",
+        bundle: Buffer.from("stale"),
+        baseGeneration: first.generation,
+        metadata: { task: "3", head: "c".repeat(40) },
+    }), /canonical_bundle_generation_mismatch/);
+    strict_1.default.notEqual(second.generation, first.generation);
+});
+(0, node_test_1.default)("self-heal and listing sync keep every material byte out of Git", async (context) => {
+    const repoPath = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "playdrop-self-heal-"));
+    context.after(async () => (0, promises_1.rm)(repoPath, { recursive: true, force: true }));
+    const source = new jszip_1.default();
+    source.file("catalogue.json", JSON.stringify({ apps: [{ name: "game", version: "1.0.0" }] }));
+    source.file("index.html", "<main>game</main>");
+    source.file("assets/ship.glb", Buffer.from([0, 1, 2]));
+    const immutable = new Map();
+    const putImmutableFile = async (key, content) => {
+        immutable.set(key, Buffer.from(content));
+    };
+    const initialized = await (0, index_js_1.initializeGameSourceRepository)({
+        repoPath,
+        versions: [{ id: 1, version: { major: 1, minor: 0, patch: 0 }, sourceZip: await source.generateAsync({ type: "nodebuffer" }) }],
+        putImmutableFile,
+    });
+    const healed = await (0, index_js_1.importAdditionalSourceVersions)({
+        repoPath,
+        versions: [{ id: 2, version: { major: 1, minor: 0, patch: 1 }, sourceZip: await source.generateAsync({ type: "nodebuffer" }) }],
+        putImmutableFile,
+    });
+    strict_1.default.equal((await git(repoPath, "ls-tree", "-r", "--name-only", healed[0].commitSha)).includes("assets/ship.glb"), false);
+    const hero = Buffer.from([0, 4, 5]);
+    const listingHead = await (0, index_js_1.syncAuthoritativeListing)({
+        repoPath,
+        listing: {
+            version: "1.0.1",
+            displayName: "Game",
+            subtitle: null,
+            description: "Updated listing",
+            iconPath: null,
+            heroPortraitPath: null,
+            heroLandscapePath: "listing/hero.png",
+            socialLandscapePath: "listing/social.png",
+            screenshotsPortrait: [],
+            screenshotsLandscape: [],
+            videosPortrait: [],
+            videosLandscape: [],
+            files: new Map([
+                ["listing/hero.png", hero],
+                ["listing/social.png", hero],
+            ]),
+        },
+        putImmutableFile,
+    });
+    strict_1.default.notEqual(listingHead, initialized.headSha);
+    strict_1.default.equal((await git(repoPath, "ls-tree", "-r", "--name-only", listingHead)).includes("listing/hero.png"), false);
+    strict_1.default.match(await git(repoPath, "show", `${listingHead}:catalogue.json`), /Updated listing/);
+    strict_1.default.match(await git(repoPath, "show", `${listingHead}:catalogue.json`), /socialLandscape/);
+    const lock = (0, index_js_1.parseGameSourceLock)(Buffer.from(await git(repoPath, "show", `${listingHead}:.playdrop/files.lock`)));
+    strict_1.default.equal(lock.files["listing/hero.png"]?.sha256, (0, index_js_1.sha256)(hero));
+});
+(0, node_test_1.default)("self-heal preserves caller order so the selected base can be imported last", async (context) => {
+    const repoPath = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "playdrop-self-heal-order-"));
+    context.after(async () => (0, promises_1.rm)(repoPath, { recursive: true, force: true }));
+    const source = async (version) => {
+        const zip = new jszip_1.default();
+        zip.file("catalogue.json", JSON.stringify({ apps: [{ name: "game", version }] }));
+        zip.file("index.html", `<main>${version}</main>`);
+        return await zip.generateAsync({ type: "nodebuffer" });
+    };
+    await (0, index_js_1.initializeGameSourceRepository)({
+        repoPath,
+        versions: [{ id: 1, version: { major: 1, minor: 0, patch: 0 }, sourceZip: await source("1.0.0") }],
+        putImmutableFile: async () => undefined,
+    });
+    const imported = await (0, index_js_1.importAdditionalSourceVersions)({
+        repoPath,
+        versions: [
+            { id: 3, version: { major: 2, minor: 0, patch: 0 }, sourceZip: await source("2.0.0") },
+            { id: 2, version: { major: 1, minor: 5, patch: 0 }, sourceZip: await source("1.5.0") },
+        ],
+        putImmutableFile: async () => undefined,
+    });
+    strict_1.default.deepEqual(imported.map((entry) => entry.id), [3, 2]);
+    strict_1.default.equal(await git(repoPath, "rev-parse", "HEAD"), imported[1]?.commitSha);
+    strict_1.default.equal(await git(repoPath, "show", "HEAD:index.html"), "<main>1.5.0</main>");
+});