@playdrop/playdrop-cli 0.16.16 → 0.17.1

package/node_modules/@playdrop/config/package.json

@@ -6,26 +6,32 @@
   "types": "dist/src/index.d.ts",
   "exports": {
     ".": {
+      "development": "./src/index.ts",
       "types": "./dist/src/index.d.ts",
       "default": "./dist/src/index.js"
     },
     "./runtime-client-meta": {
+      "development": "./src/runtime-client-meta.ts",
       "types": "./dist/src/runtime-client-meta.d.ts",
       "default": "./dist/src/runtime-client-meta.js"
     },
     "./runtime-service-origins": {
+      "development": "./src/runtime-service-origins.ts",
       "types": "./dist/src/runtime-service-origins.d.ts",
       "default": "./dist/src/runtime-service-origins.js"
     },
     "./public-deployment": {
+      "development": "./src/public-deployment.ts",
       "types": "./dist/src/public-deployment.d.ts",
       "default": "./dist/src/public-deployment.js"
     },
     "./game-arena": {
+      "development": "./src/game-arena.ts",
       "types": "./dist/src/game-arena.d.ts",
       "default": "./dist/src/game-arena.js"
     },
     "./creator-plans": {
+      "development": "./src/creator-plans.ts",
       "types": "./dist/src/creator-plans.d.ts",
       "default": "./dist/src/creator-plans.js"
     }

package/node_modules/@playdrop/game-source-git/dist/src/archive.d.ts

@@ -0,0 +1,9 @@
+export interface SplitSourceArchive {
+    gitFiles: Map<string, Buffer>;
+    materialFiles: Map<string, Buffer>;
+    transcriptFiles: Map<string, Buffer>;
+    excludedPaths: string[];
+}
+export declare function splitSourceArchive(sourceZip: Buffer): Promise<SplitSourceArchive>;
+export declare function createDeterministicSourceZip(files: ReadonlyMap<string, Buffer>): Buffer;
+//# sourceMappingURL=archive.d.ts.map

package/node_modules/@playdrop/game-source-git/dist/src/archive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive.d.ts","sourceRoot":"","sources":["../../src/archive.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA0BvF;AAkBD,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAiDvF"}

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

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitSourceArchive = splitSourceArchive;
+exports.createDeterministicSourceZip = createDeterministicSourceZip;
+const node_zlib_1 = require("node:zlib");
+const jszip_1 = __importDefault(require("jszip"));
+const paths_js_1 = require("./paths.js");
+async function splitSourceArchive(sourceZip) {
+    let zip;
+    try {
+        zip = await jszip_1.default.loadAsync(sourceZip);
+    }
+    catch {
+        throw new Error("invalid_game_source_zip");
+    }
+    const result = {
+        gitFiles: new Map(),
+        materialFiles: new Map(),
+        transcriptFiles: new Map(),
+        excludedPaths: [],
+    };
+    const entries = Object.values(zip.files)
+        .filter((entry) => !entry.dir)
+        .sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+        const filePath = (0, paths_js_1.normalizeSourcePath)(entry.name);
+        const content = await entry.async("nodebuffer");
+        const classification = (0, paths_js_1.classifyGameSourceFile)(filePath, content);
+        if (classification === "git")
+            result.gitFiles.set(filePath, content);
+        else if (classification === "material")
+            result.materialFiles.set(filePath, content);
+        else if (classification === "transcript")
+            result.transcriptFiles.set(filePath, content);
+        else
+            result.excludedPaths.push(filePath);
+    }
+    return result;
+}
+const CRC32_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let index = 0; index < 256; index += 1) {
+        let crc = index;
+        for (let bit = 0; bit < 8; bit += 1)
+            crc = (crc & 1) !== 0 ? (crc >>> 1) ^ 0xedb88320 : crc >>> 1;
+        table[index] = crc >>> 0;
+    }
+    return table;
+})();
+function crc32(buffer) {
+    let crc = -1;
+    for (const byte of buffer)
+        crc = (crc >>> 8) ^ (CRC32_TABLE[(crc ^ byte) & 0xff] ?? 0);
+    return (crc ^ -1) >>> 0;
+}
+function createDeterministicSourceZip(files) {
+    const chunks = [];
+    const centralRecords = [];
+    let offset = 0;
+    for (const [rawPath, data] of [...files.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+        const filePath = (0, paths_js_1.normalizeSourcePath)(rawPath);
+        const fileName = Buffer.from(filePath, "utf8");
+        const compressed = (0, node_zlib_1.deflateRawSync)(data);
+        const checksum = crc32(data);
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(0x04034b50, 0);
+        local.writeUInt16LE(20, 4);
+        local.writeUInt16LE(0x0800, 6);
+        local.writeUInt16LE(8, 8);
+        local.writeUInt16LE(0, 10);
+        local.writeUInt16LE(0x0021, 12);
+        local.writeUInt32LE(checksum, 14);
+        local.writeUInt32LE(compressed.length, 18);
+        local.writeUInt32LE(data.length, 22);
+        local.writeUInt16LE(fileName.length, 26);
+        chunks.push(local, fileName, compressed);
+        const central = Buffer.alloc(46);
+        central.writeUInt32LE(0x02014b50, 0);
+        central.writeUInt16LE(0x031e, 4);
+        central.writeUInt16LE(20, 6);
+        central.writeUInt16LE(0x0800, 8);
+        central.writeUInt16LE(8, 10);
+        central.writeUInt16LE(0, 12);
+        central.writeUInt16LE(0x0021, 14);
+        central.writeUInt32LE(checksum, 16);
+        central.writeUInt32LE(compressed.length, 20);
+        central.writeUInt32LE(data.length, 24);
+        central.writeUInt16LE(fileName.length, 28);
+        central.writeUInt32LE((0o100644 << 16) >>> 0, 38);
+        central.writeUInt32LE(offset, 42);
+        centralRecords.push(Buffer.concat([central, fileName]));
+        offset += local.length + fileName.length + compressed.length;
+    }
+    const centralDirectory = Buffer.concat(centralRecords);
+    chunks.push(centralDirectory);
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0);
+    end.writeUInt16LE(files.size, 8);
+    end.writeUInt16LE(files.size, 10);
+    end.writeUInt32LE(centralDirectory.length, 12);
+    end.writeUInt32LE(offset, 16);
+    chunks.push(end);
+    return Buffer.concat(chunks);
+}

package/node_modules/@playdrop/game-source-git/dist/src/bundle-storage.d.ts

@@ -0,0 +1,29 @@
+export interface CanonicalBundleObjectMetadata {
+    generation: string;
+    sizeBytes: number;
+    contentType: string | null;
+    customMetadata: Record<string, string>;
+}
+export interface CanonicalBundleStorage {
+    getPrivateObjectMetadata(key: string): Promise<CanonicalBundleObjectMetadata | null>;
+    putPrivateObject(key: string, content: Buffer, options: {
+        contentType: string;
+        ifGenerationMatch: string;
+        sha256: string;
+        metadata?: Record<string, string>;
+    }): Promise<CanonicalBundleObjectMetadata>;
+    copyPrivateObject(sourceKey: string, destinationKey: string, options: {
+        sourceGeneration: string;
+        ifGenerationMatch: string;
+        metadata?: Record<string, string>;
+    }): Promise<CanonicalBundleObjectMetadata>;
+}
+export declare function persistCanonicalBundle(input: {
+    storage: CanonicalBundleStorage;
+    currentKey: string;
+    previousKey: string;
+    bundle: Buffer;
+    baseGeneration: string | null;
+    metadata: Record<string, string>;
+}): Promise<CanonicalBundleObjectMetadata>;
+//# sourceMappingURL=bundle-storage.d.ts.map

package/node_modules/@playdrop/game-source-git/dist/src/bundle-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-storage.d.ts","sourceRoot":"","sources":["../../src/bundle-storage.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,6BAA6B;IAC5C,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC;AAED,MAAM,WAAW,sBAAsB;IACrC,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,6BAA6B,GAAG,IAAI,CAAC,CAAC;IACrF,gBAAgB,CACd,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;QACP,WAAW,EAAE,MAAM,CAAC;QACpB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACnC,GACA,OAAO,CAAC,6BAA6B,CAAC,CAAC;IAC1C,iBAAiB,CACf,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE;QAAE,gBAAgB,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,GAClG,OAAO,CAAC,6BAA6B,CAAC,CAAC;CAC3C;AAiBD,wBAAsB,sBAAsB,CAAC,KAAK,EAAE;IAClD,OAAO,EAAE,sBAAsB,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC,GAAG,OAAO,CAAC,6BAA6B,CAAC,CAmDzC"}

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.persistCanonicalBundle = persistCanonicalBundle;
+const paths_js_1 = require("./paths.js");
+const BUNDLE_CONTENT_TYPE = "application/x-git-bundle";
+function assertStoredBundle(metadata, expected) {
+    if (metadata.sizeBytes !== expected.bytes ||
+        metadata.customMetadata["sha256"] !== expected.sha256 ||
+        Object.entries(expected.customMetadata).some(([key, value]) => metadata.customMetadata[key] !== value)) {
+        throw new Error("canonical_bundle_metadata_mismatch");
+    }
+}
+async function persistCanonicalBundle(input) {
+    const bundleSha = (0, paths_js_1.sha256)(input.bundle);
+    const customMetadata = { ...input.metadata, sha256: bundleSha };
+    const currentMetadata = await input.storage.getPrivateObjectMetadata(input.currentKey);
+    const previousMetadata = await input.storage.getPrivateObjectMetadata(input.previousKey);
+    if (input.baseGeneration === null) {
+        if (currentMetadata) {
+            assertStoredBundle(currentMetadata, { sha256: bundleSha, bytes: input.bundle.length, customMetadata });
+        }
+        const current = currentMetadata ?? await input.storage.putPrivateObject(input.currentKey, input.bundle, {
+            contentType: BUNDLE_CONTENT_TYPE,
+            ifGenerationMatch: "0",
+            sha256: bundleSha,
+            metadata: customMetadata,
+        });
+        assertStoredBundle(current, { sha256: bundleSha, bytes: input.bundle.length, customMetadata });
+        const initialPreviousMetadata = { ...customMetadata, copy: "initial" };
+        const previous = previousMetadata ?? await input.storage.putPrivateObject(input.previousKey, input.bundle, {
+            contentType: BUNDLE_CONTENT_TYPE,
+            ifGenerationMatch: "0",
+            sha256: bundleSha,
+            metadata: initialPreviousMetadata,
+        });
+        assertStoredBundle(previous, {
+            sha256: bundleSha,
+            bytes: input.bundle.length,
+            customMetadata: initialPreviousMetadata,
+        });
+        return current;
+    }
+    if (!currentMetadata || currentMetadata.generation !== input.baseGeneration || !previousMetadata) {
+        throw new Error("canonical_bundle_generation_mismatch");
+    }
+    const rotated = await input.storage.copyPrivateObject(input.currentKey, input.previousKey, {
+        sourceGeneration: currentMetadata.generation,
+        ifGenerationMatch: previousMetadata.generation,
+        metadata: { ...currentMetadata.customMetadata, copy: "rotation" },
+    });
+    assertStoredBundle(rotated, {
+        sha256: currentMetadata.customMetadata["sha256"] ?? "",
+        bytes: currentMetadata.sizeBytes,
+        customMetadata: { ...currentMetadata.customMetadata, copy: "rotation" },
+    });
+    const current = await input.storage.putPrivateObject(input.currentKey, input.bundle, {
+        contentType: BUNDLE_CONTENT_TYPE,
+        ifGenerationMatch: currentMetadata.generation,
+        sha256: bundleSha,
+        metadata: customMetadata,
+    });
+    assertStoredBundle(current, { sha256: bundleSha, bytes: input.bundle.length, customMetadata });
+    return current;
+}

package/node_modules/@playdrop/game-source-git/dist/src/export.d.ts

@@ -0,0 +1,8 @@
+import { type GitRunner } from "./git.js";
+export declare function exportGameSourceZip(input: {
+    repoPath: string;
+    commitSha: string;
+    loadMaterial: (key: string) => Promise<Buffer>;
+    runner?: GitRunner;
+}): Promise<Buffer>;
+//# sourceMappingURL=export.d.ts.map

package/node_modules/@playdrop/game-source-git/dist/src/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../src/export.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,UAAU,CAAC;AAI3D,wBAAsB,mBAAmB,CAAC,KAAK,EAAE;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/C,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB,GAAG,OAAO,CAAC,MAAM,CAAC,CAgBlB"}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportGameSourceZip = exportGameSourceZip;
+const archive_js_1 = require("./archive.js");
+const git_js_1 = require("./git.js");
+const paths_js_1 = require("./paths.js");
+const lock_js_1 = require("./lock.js");
+async function exportGameSourceZip(input) {
+    const files = await (0, git_js_1.readCommitFiles)(input.repoPath, input.commitSha, input.runner);
+    const lockContent = files.get(paths_js_1.GAME_SOURCE_LOCK_PATH);
+    if (!lockContent)
+        throw new Error("game_source_lock_missing");
+    const lock = (0, lock_js_1.parseGameSourceLock)(lockContent);
+    for (const [filePath, entry] of Object.entries(lock.files)) {
+        const content = await input.loadMaterial(entry.key);
+        (0, lock_js_1.verifyLockedFile)(filePath, content, entry);
+        files.set(filePath, content);
+    }
+    for (const filePath of [...files.keys()]) {
+        if (filePath === paths_js_1.GAME_SOURCE_LOCK_PATH || filePath.startsWith("tasks/") || (0, paths_js_1.isTranscriptPath)(filePath)) {
+            files.delete(filePath);
+        }
+    }
+    return (0, archive_js_1.createDeterministicSourceZip)(files);
+}

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

@@ -0,0 +1,39 @@
+export interface GitRunner {
+    run(args: readonly string[], cwd?: string): Promise<Buffer>;
+}
+export declare function createGitRunner(): GitRunner;
+export interface AuthoritativeVersionRef {
+    version: {
+        major: number;
+        minor: number;
+        patch: number;
+    };
+    commitSha: string;
+}
+export declare function versionTagRef(version: {
+    major: number;
+    minor: number;
+    patch: number;
+}): string;
+export declare function deriveCanonicalRefs(versions: readonly AuthoritativeVersionRef[]): string[];
+export interface ExpectedCanonicalRefs {
+    headSha: string;
+    versions: readonly AuthoritativeVersionRef[];
+}
+export declare function readRefs(repoPath: string, refs: readonly string[], runner?: GitRunner): Promise<Map<string, string>>;
+export declare function validateCanonicalRefTargets(repoPath: string, expected: ExpectedCanonicalRefs, runner?: GitRunner): Promise<void>;
+export declare function createCanonicalBundle(input: {
+    repoPath: string;
+    outputPath: string;
+    expected: ExpectedCanonicalRefs;
+}, runner?: GitRunner): Promise<void>;
+export declare function validateBundleHeads(bundlePath: string, expected: ExpectedCanonicalRefs, runner?: GitRunner): Promise<void>;
+export declare function validateBundleHeadsForSelfHeal(bundlePath: string, expected: ExpectedCanonicalRefs, runner?: GitRunner): Promise<void>;
+export declare function scanOutgoingObjects(input: {
+    repoPath: string;
+    proposedRefs: readonly string[];
+    previousTargets?: readonly string[];
+    maxBlobBytes?: number;
+}, runner?: GitRunner): Promise<void>;
+export declare function readCommitFiles(repoPath: string, commitSha: string, runner?: GitRunner): Promise<Map<string, Buffer>>;
+//# sourceMappingURL=git.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../src/git.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,SAAS;IACxB,GAAG,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC7D;AAED,wBAAgB,eAAe,IAAI,SAAS,CAiB3C;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACzD,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAK9F;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,SAAS,uBAAuB,EAAE,GAAG,MAAM,EAAE,CAM1F;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,SAAS,uBAAuB,EAAE,CAAC;CAC9C;AAED,wBAAsB,QAAQ,CAC5B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,MAAM,GAAE,SAA6B,GACpC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAa9B;AAED,wBAAsB,2BAA2B,CAC/C,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,GAAE,SAA6B,GACpC,OAAO,CAAC,IAAI,CAAC,CAUf;AAED,wBAAsB,qBAAqB,CACzC,KAAK,EAAE;IACL,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,qBAAqB,CAAC;CACjC,EACD,MAAM,GAAE,SAA6B,GACpC,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,GAAE,SAA6B,GACpC,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED,wBAAsB,8BAA8B,CAClD,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,GAAE,SAA6B,GACpC,OAAO,CAAC,IAAI,CAAC,CAmBf;AAyBD,wBAAsB,mBAAmB,CACvC,KAAK,EAAE;IACL,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,EACD,MAAM,GAAE,SAA6B,GACpC,OAAO,CAAC,IAAI,CAAC,CAiCf;AAED,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,SAA6B,GACpC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAU9B"}

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

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGitRunner = createGitRunner;
+exports.versionTagRef = versionTagRef;
+exports.deriveCanonicalRefs = deriveCanonicalRefs;
+exports.readRefs = readRefs;
+exports.validateCanonicalRefTargets = validateCanonicalRefTargets;
+exports.createCanonicalBundle = createCanonicalBundle;
+exports.validateBundleHeads = validateBundleHeads;
+exports.validateBundleHeadsForSelfHeal = validateBundleHeadsForSelfHeal;
+exports.scanOutgoingObjects = scanOutgoingObjects;
+exports.readCommitFiles = readCommitFiles;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const paths_js_1 = require("./paths.js");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const GIT_MAX_BUFFER = 64 * 1024 * 1024;
+function createGitRunner() {
+    return {
+        async run(args, cwd) {
+            const result = await execFileAsync("git", [...args], {
+                cwd,
+                encoding: "buffer",
+                maxBuffer: GIT_MAX_BUFFER,
+                env: {
+                    ...process.env,
+                    GIT_CONFIG_NOSYSTEM: "1",
+                    GIT_TERMINAL_PROMPT: "0",
+                    LC_ALL: "C",
+                },
+            });
+            return Buffer.from(result.stdout);
+        },
+    };
+}
+function versionTagRef(version) {
+    for (const [label, value] of Object.entries(version)) {
+        if (!Number.isSafeInteger(value) || value < 0)
+            throw new Error(`invalid_version_${label}`);
+    }
+    return `refs/tags/v${version.major}.${version.minor}.${version.patch}`;
+}
+function deriveCanonicalRefs(versions) {
+    const tags = versions
+        .map((version) => versionTagRef(version.version))
+        .sort((left, right) => left.localeCompare(right));
+    if (new Set(tags).size !== tags.length)
+        throw new Error("duplicate_game_source_version_tag");
+    return ["refs/heads/main", ...tags];
+}
+async function readRefs(repoPath, refs, runner = createGitRunner()) {
+    if (refs.length === 0)
+        return new Map();
+    const output = await runner.run(["show-ref", "--verify", ...refs], repoPath);
+    const actual = new Map();
+    for (const line of output.toString("utf8").trim().split("\n").filter(Boolean)) {
+        const separator = line.indexOf(" ");
+        if (separator <= 0)
+            throw new Error("invalid_game_source_ref");
+        actual.set(line.slice(separator + 1), (0, paths_js_1.assertSha1)(line.slice(0, separator), "ref_sha"));
+    }
+    if (actual.size !== refs.length || refs.some((ref) => !actual.has(ref))) {
+        throw new Error("game_source_ref_count_mismatch");
+    }
+    return actual;
+}
+async function validateCanonicalRefTargets(repoPath, expected, runner = createGitRunner()) {
+    const refs = deriveCanonicalRefs(expected.versions);
+    const actual = await readRefs(repoPath, refs, runner);
+    const targets = new Map([["refs/heads/main", (0, paths_js_1.assertSha1)(expected.headSha, "head_sha")]]);
+    for (const version of expected.versions) {
+        targets.set(versionTagRef(version.version), (0, paths_js_1.assertSha1)(version.commitSha, "commit_sha"));
+    }
+    for (const ref of refs) {
+        if (actual.get(ref) !== targets.get(ref))
+            throw new Error(`game_source_ref_target_mismatch:${ref}`);
+    }
+}
+async function createCanonicalBundle(input, runner = createGitRunner()) {
+    await validateCanonicalRefTargets(input.repoPath, input.expected, runner);
+    const refs = deriveCanonicalRefs(input.expected.versions);
+    await runner.run(["bundle", "create", "--version=2", input.outputPath, ...refs], input.repoPath);
+    await validateBundleHeads(input.outputPath, input.expected, runner);
+}
+async function validateBundleHeads(bundlePath, expected, runner = createGitRunner()) {
+    const output = await runner.run(["bundle", "list-heads", bundlePath]);
+    const actual = new Map();
+    for (const line of output.toString("utf8").trim().split("\n").filter(Boolean)) {
+        const separator = line.indexOf(" ");
+        if (separator <= 0)
+            throw new Error("invalid_game_source_bundle_head");
+        actual.set(line.slice(separator + 1), (0, paths_js_1.assertSha1)(line.slice(0, separator), "bundle_sha"));
+    }
+    const refs = deriveCanonicalRefs(expected.versions);
+    if (actual.size !== refs.length || refs.some((ref) => !actual.has(ref))) {
+        throw new Error("game_source_bundle_refs_mismatch");
+    }
+    const expectedTargets = new Map([["refs/heads/main", (0, paths_js_1.assertSha1)(expected.headSha, "head_sha")]]);
+    for (const version of expected.versions)
+        expectedTargets.set(versionTagRef(version.version), version.commitSha);
+    for (const ref of refs) {
+        if (actual.get(ref) !== expectedTargets.get(ref))
+            throw new Error(`game_source_bundle_target_mismatch:${ref}`);
+    }
+}
+async function validateBundleHeadsForSelfHeal(bundlePath, expected, runner = createGitRunner()) {
+    const output = await runner.run(["bundle", "list-heads", bundlePath]);
+    const actual = new Map();
+    for (const line of output.toString("utf8").trim().split("\n").filter(Boolean)) {
+        const separator = line.indexOf(" ");
+        if (separator <= 0)
+            throw new Error("invalid_game_source_bundle_head");
+        const ref = line.slice(separator + 1);
+        if (ref !== "refs/heads/main" && !/^refs\/tags\/v(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)$/.test(ref)) {
+            throw new Error(`game_source_bundle_unexpected_ref:${ref}`);
+        }
+        actual.set(ref, (0, paths_js_1.assertSha1)(line.slice(0, separator), "bundle_sha"));
+    }
+    const expectedTargets = new Map([["refs/heads/main", (0, paths_js_1.assertSha1)(expected.headSha, "head_sha")]]);
+    for (const version of expected.versions) {
+        expectedTargets.set(versionTagRef(version.version), (0, paths_js_1.assertSha1)(version.commitSha, "commit_sha"));
+    }
+    for (const [ref, target] of expectedTargets) {
+        if (actual.get(ref) !== target)
+            throw new Error(`game_source_bundle_target_mismatch:${ref}`);
+    }
+}
+function parseLsTree(output) {
+    return output
+        .toString("utf8")
+        .split("\0")
+        .filter(Boolean)
+        .map((record) => {
+        const tab = record.indexOf("\t");
+        const metadata = record.slice(0, tab).split(" ");
+        return {
+            mode: metadata[0] ?? "",
+            type: metadata[1] ?? "",
+            sha: metadata[2] ?? "",
+            path: (0, paths_js_1.normalizeSourcePath)(record.slice(tab + 1)),
+        };
+    });
+}
+async function scanOutgoingObjects(input, runner = createGitRunner()) {
+    if (input.proposedRefs.length === 0)
+        throw new Error("game_source_scan_refs_required");
+    const previousTargets = (input.previousTargets ?? []).map((sha) => (0, paths_js_1.assertSha1)(sha, "previous_sha"));
+    const commitOutput = await runner.run(["rev-list", ...input.proposedRefs, ...(previousTargets.length > 0 ? ["--not", ...previousTargets] : [])], input.repoPath);
+    const commits = commitOutput.toString("utf8").trim().split("\n").filter(Boolean).map((sha) => (0, paths_js_1.assertSha1)(sha));
+    const blobs = new Map();
+    for (const commit of commits) {
+        const tree = parseLsTree(await runner.run(["ls-tree", "-r", "-z", "--long", commit], input.repoPath));
+        for (const entry of tree) {
+            if (entry.mode === "160000" || entry.type === "commit")
+                throw new Error(`game_source_gitlink_rejected:${entry.path}`);
+            if (entry.type !== "blob")
+                continue;
+            const sizeOutput = await runner.run(["cat-file", "-s", entry.sha], input.repoPath);
+            const size = Number(sizeOutput.toString("utf8").trim());
+            const uses = blobs.get(entry.sha) ?? [];
+            uses.push({ sha: entry.sha, path: entry.path, size });
+            blobs.set(entry.sha, uses);
+        }
+    }
+    const maxBlobBytes = input.maxBlobBytes ?? paths_js_1.MAX_GIT_SOURCE_FILE_BYTES;
+    for (const uses of blobs.values()) {
+        for (const blob of uses) {
+            if ((0, paths_js_1.isSourceExcludedGeneratedPath)(blob.path))
+                throw new Error(`game_source_generated_path_rejected:${blob.path}`);
+            if ((0, paths_js_1.isMediaOrBinaryPath)(blob.path))
+                throw new Error(`game_source_binary_path_rejected:${blob.path}`);
+            if (blob.size > maxBlobBytes)
+                throw new Error(`game_source_blob_too_large:${blob.path}`);
+        }
+        const representative = uses[0];
+        if (!representative)
+            continue;
+        const content = await runner.run(["cat-file", "blob", representative.sha], input.repoPath);
+        if (content.includes(0))
+            throw new Error(`game_source_binary_blob_rejected:${representative.path}`);
+    }
+}
+async function readCommitFiles(repoPath, commitSha, runner = createGitRunner()) {
+    const commit = (0, paths_js_1.assertSha1)(commitSha, "commit_sha");
+    const tree = parseLsTree(await runner.run(["ls-tree", "-r", "-z", commit], repoPath));
+    const files = new Map();
+    for (const entry of tree) {
+        if (entry.mode === "160000" || entry.type === "commit")
+            throw new Error(`game_source_gitlink_rejected:${entry.path}`);
+        if (entry.type !== "blob")
+            continue;
+        files.set(entry.path, await runner.run(["cat-file", "blob", entry.sha], repoPath));
+    }
+    return files;
+}

package/node_modules/@playdrop/game-source-git/dist/src/ignore.d.ts

@@ -0,0 +1,6 @@
+export declare function updateManagedGitignore(existing: string): string;
+export declare const PLAYDROP_GITIGNORE_MARKERS: {
+    readonly start: "# >>> PLAYDROP MANAGED GAME SOURCE >>>";
+    readonly end: "# <<< PLAYDROP MANAGED GAME SOURCE <<<";
+};
+//# sourceMappingURL=ignore.d.ts.map

package/node_modules/@playdrop/game-source-git/dist/src/ignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ignore.d.ts","sourceRoot":"","sources":["../../src/ignore.ts"],"names":[],"mappings":"AAiCA,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAc/D;AAED,eAAO,MAAM,0BAA0B;;;CAAoD,CAAC"}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLAYDROP_GITIGNORE_MARKERS = void 0;
+exports.updateManagedGitignore = updateManagedGitignore;
+const paths_js_1 = require("./paths.js");
+const START_MARKER = "# >>> PLAYDROP MANAGED GAME SOURCE >>>";
+const END_MARKER = "# <<< PLAYDROP MANAGED GAME SOURCE <<<";
+const MANAGED_RULES = [
+    ".next/",
+    ".art-*",
+    ".playdrop-task-events/",
+    ".playdrop/",
+    ".playdrop.json",
+    ".scratch/",
+    "AGENTS.md",
+    "CLAUDE.md",
+    "PLAYDROP_TASK.md",
+    "assets/",
+    "bin/playdrop",
+    "build/",
+    "coverage/",
+    "dist/",
+    "evidence/",
+    "listing/",
+    "next-steps.json",
+    "node_modules/",
+    "output/",
+    "player-feedback.md",
+    "platform-feedback.md",
+    "remix-source/",
+    "source.zip",
+    "tmp/",
+    "transcripts/",
+    ...(0, paths_js_1.gameSourceBinaryIgnoreRules)(),
+];
+function updateManagedGitignore(existing) {
+    const normalized = existing.replace(/\r\n/g, "\n");
+    const startIndex = normalized.indexOf(START_MARKER);
+    const endIndex = normalized.indexOf(END_MARKER);
+    if ((startIndex >= 0) !== (endIndex >= 0) || (startIndex >= 0 && endIndex < startIndex)) {
+        throw new Error("invalid_playdrop_gitignore_block");
+    }
+    let creatorRules = normalized;
+    if (startIndex >= 0 && endIndex >= 0) {
+        creatorRules = `${normalized.slice(0, startIndex)}${normalized.slice(endIndex + END_MARKER.length)}`;
+    }
+    creatorRules = creatorRules.replace(/^\n+|\n+$/g, "");
+    const managed = [START_MARKER, ...MANAGED_RULES, END_MARKER].join("\n");
+    return creatorRules.length > 0 ? `${creatorRules}\n\n${managed}\n` : `${managed}\n`;
+}
+exports.PLAYDROP_GITIGNORE_MARKERS = { start: START_MARKER, end: END_MARKER };

package/node_modules/@playdrop/game-source-git/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./archive.js";
+export * from "./bundle-storage.js";
+export * from "./export.js";
+export * from "./git.js";
+export * from "./ignore.js";
+export * from "./lock.js";
+export * from "./materialize.js";
+export * from "./paths.js";
+export * from "./repository.js";
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@playdrop/game-source-git/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC"}

package/node_modules/@playdrop/{boxel-core/dist/src/humanoid/r15 → game-source-git/dist/src}/index.js

@@ -14,7 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types"), exports);
-__exportStar(require("./textured-builder"), exports);
-__exportStar(require("./voxel-builder"), exports);
-//# sourceMappingURL=index.js.map
+__exportStar(require("./archive.js"), exports);
+__exportStar(require("./bundle-storage.js"), exports);
+__exportStar(require("./export.js"), exports);
+__exportStar(require("./git.js"), exports);
+__exportStar(require("./ignore.js"), exports);
+__exportStar(require("./lock.js"), exports);
+__exportStar(require("./materialize.js"), exports);
+__exportStar(require("./paths.js"), exports);
+__exportStar(require("./repository.js"), exports);

package/node_modules/@playdrop/game-source-git/dist/src/lock.d.ts

@@ -0,0 +1,17 @@
+import { GAME_SOURCE_STORE } from "./paths.js";
+export interface GameSourceLockEntry {
+    sha256: string;
+    bytes: number;
+    store: typeof GAME_SOURCE_STORE;
+    key: string;
+}
+export interface GameSourceLockV1 {
+    version: 1;
+    files: Record<string, GameSourceLockEntry>;
+}
+export declare function normalizeGameSourceLock(input: GameSourceLockV1): GameSourceLockV1;
+export declare function parseGameSourceLock(content: Buffer | string): GameSourceLockV1;
+export declare function serializeGameSourceLock(input: GameSourceLockV1): Buffer;
+export declare function createGameSourceLock(materialFiles: ReadonlyMap<string, Buffer>): GameSourceLockV1;
+export declare function verifyLockedFile(filePath: string, content: Buffer, entry: GameSourceLockEntry): void;
+//# sourceMappingURL=lock.d.ts.map

package/node_modules/@playdrop/game-source-git/dist/src/lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../src/lock.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,iBAAiB,CAAC;IAChC,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,CAAC,CAAC;IACX,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;CAC5C;AAsBD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,gBAAgB,GAAG,gBAAgB,CAWjF;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,gBAAgB,CAQ9E;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAEvE;AAED,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,gBAAgB,CAajG;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAIpG"}