narraeon 0.5.6 → 0.6.0

package/dist/node/runtime/archive/WorldArchives.js

@@ -0,0 +1,389 @@
+import { createHash, randomUUID } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { mkdir, open, readFile, readdir, rename, rm, stat, } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { worldArchiveFormat, worldArchiveLimits, } from "../../protocol/worldArchives.js";
+import { FileNativeArtifactStore } from "../artifact/FileNativeArtifactStore.js";
+import { PlayCallChain } from "../play/PlayCallChain.js";
+import { FileNativePromptCompiler } from "../prompt/FileNativePromptCompiler.js";
+import { FileNativeAuthorityV3 } from "../world/FileNativeAuthorityV3.js";
+import { FileNativeWorldStore, } from "../world/FileNativeWorldStore.js";
+import { archivePath, extractArchive, inventory, streamFile, writeArchive, WorldArchiveError, } from "./WorldArchiveZip.js";
+export class WorldArchives {
+    #dataRoot;
+    #root;
+    #limits;
+    #worlds;
+    #chains;
+    #appVersion = "";
+    constructor(input) {
+        this.#dataRoot = resolve(input.dataRoot);
+        this.#root = join(this.#dataRoot, "world-archives");
+        this.#worlds = input.worlds;
+        this.#chains = input.chains;
+        this.#limits = input.limits ?? worldArchiveLimits;
+    }
+    async initialize() {
+        this.#appVersion = await appVersion();
+        const worldsRoot = join(this.#dataRoot, "worlds-file-native");
+        const staged = await readdir(worldsRoot).catch(() => []);
+        for (const operationId of await readdir(join(this.#root, "quarantine")).catch(() => [])) {
+            const worldId = `world-${createHash("sha256").update(`import:${operationId}`).digest("hex").slice(0, 24)}`;
+            for (const entry of staged)
+                if (entry.startsWith(`.staging-${worldId}-`))
+                    await rm(join(worldsRoot, entry), { recursive: true, force: true });
+        }
+        for (const name of ["uploads", "quarantine", "exports"]) {
+            await rm(join(this.#root, name), { recursive: true, force: true });
+            await mkdir(join(this.#root, name), { recursive: true, mode: 0o700 });
+        }
+    }
+    async upload(source) {
+        const uploadId = randomUUID();
+        const path = this.#uploadPath(uploadId);
+        try {
+            await streamFile(source, path, this.#limits.archiveBytes);
+            await syncFile(path);
+            crashAt("upload");
+            return { uploadId };
+        }
+        catch (error) {
+            await rm(path, { force: true });
+            throw error;
+        }
+    }
+    async exportWorld(input) {
+        identity(input.operationId);
+        return this.#worlds.withArchiveExport(input.worldId, async () => {
+            const root = join(this.#root, "exports", input.operationId);
+            await rm(root, { recursive: true, force: true });
+            try {
+                const source = await this.#worlds.readWorldSummary(input.worldId);
+                if (!source)
+                    throw new WorldArchiveError("invalid_archive", "World does not exist");
+                const fork = await this.#chains.deriveWorld({
+                    operationId: input.operationId,
+                    sourceWorldId: input.worldId,
+                    sourceHead: "current",
+                    hostPresetId: "world-archive",
+                    targetName: source.title,
+                    publish: false,
+                    targetWorldRoot: join(root, "world"),
+                    requireMaterialized: true,
+                    resetPackageScriptPermissions: true,
+                    retainCompleteTimeline: true,
+                });
+                // A fork may create a local display cache; it is outside the portable closure.
+                await rm(join(fork.worldRoot, "runtime", "activity.json"), {
+                    force: true,
+                });
+                const files = await inventory(fork.worldRoot);
+                const manifest = {
+                    format: worldArchiveFormat,
+                    appVersion: this.#appVersion || (await appVersion()),
+                    exportedAt: new Date().toISOString(),
+                    worldName: source.title,
+                    archivedWorldId: fork.world.worldId,
+                    head: (await new FileNativeAuthorityV3(fork.worldRoot).readHead())
+                        .head,
+                    files,
+                };
+                await durableJson(join(root, "narraeon-world.json"), manifest);
+                const bytes = await writeArchive(root, files, join(root, "archive.zip"), this.#limits);
+                const fileName = `${archiveBaseName(source.title)}.narraeon-world.zip`;
+                const result = { archiveId: input.operationId, fileName, bytes };
+                await durableJson(join(root, "download.json"), result);
+                const expiry = setTimeout(() => {
+                    void stat(join(root, "download.json"))
+                        .then((value) => {
+                        if (Date.now() - value.mtimeMs >= 60 * 60 * 1000)
+                            return rm(root, { recursive: true, force: true });
+                    })
+                        .catch(() => undefined);
+                }, 60 * 60 * 1000);
+                expiry.unref();
+                return result;
+            }
+            catch (error) {
+                await rm(root, { recursive: true, force: true });
+                throw error;
+            }
+        });
+    }
+    async download(archiveId) {
+        identity(archiveId);
+        const root = join(this.#root, "exports", archiveId);
+        const metadata = JSON.parse(await readFile(join(root, "download.json"), "utf8"));
+        if (Date.now() - (await stat(join(root, "download.json"))).mtimeMs >=
+            60 * 60 * 1000) {
+            await rm(root, { recursive: true, force: true });
+            throw new WorldArchiveError("invalid_archive", "The download has expired; export the world again");
+        }
+        return {
+            metadata,
+            stream: createReadStream(join(root, "archive.zip")),
+            cleanup: () => rm(root, { recursive: true, force: true }),
+        };
+    }
+    async importWorld(input) {
+        identity(input.operationId);
+        identity(input.uploadId);
+        const digest = createHash("sha256")
+            .update(`import:${input.operationId}`)
+            .digest("hex")
+            .slice(0, 24);
+        return this.#worlds.operations.withExclusiveWorldStateMutation(`archive-import-${digest}`, async () => {
+            const worldId = `world-${digest}`;
+            const targetRoot = join(this.#dataRoot, "worlds-file-native", worldId);
+            const quarantine = join(this.#root, "quarantine", input.operationId);
+            const upload = this.#uploadPath(input.uploadId);
+            try {
+                // Publication is the durable commit point. A process may exit before writing its receipt or cleaning the upload.
+                let published = null;
+                try {
+                    published = JSON.parse(await readFile(join(targetRoot, "publication.json"), "utf8"));
+                }
+                catch (error) {
+                    if (!missing(error))
+                        throw error;
+                }
+                if (published) {
+                    if (published.operationId !== input.operationId ||
+                        published.worldId !== worldId)
+                        throw new WorldArchiveError("integrity_failed", "Import publication does not match its operation");
+                    await this.#worlds.ensureCurrentStorage(worldId);
+                    await durableJson(join(this.#dataRoot, "operations", `import-${createHash("sha256").update(input.operationId).digest("hex")}.json`), JSON.parse(await readFile(join(targetRoot, "publication.json"), "utf8")));
+                    const world = await this.#worlds.readWorldSummary(worldId);
+                    return { outcome: "imported", world };
+                }
+                await rm(quarantine, { recursive: true, force: true });
+                const worldsRoot = join(this.#dataRoot, "worlds-file-native");
+                for (const entry of await readdir(worldsRoot).catch(() => []))
+                    if (entry.startsWith(`.staging-${worldId}-`))
+                        await rm(join(worldsRoot, entry), {
+                            recursive: true,
+                            force: true,
+                        });
+                const extracted = join(quarantine, "extracted");
+                await mkdir(extracted, { recursive: true, mode: 0o700 });
+                crashAt("quarantine");
+                let actual;
+                try {
+                    actual = await extractArchive(upload, extracted, this.#limits);
+                }
+                catch (error) {
+                    if (missing(error))
+                        throw new WorldArchiveError("invalid_archive", "Upload is missing; upload the ZIP again");
+                    throw error;
+                }
+                crashAt("unpack");
+                if (!actual.has("narraeon-world.json"))
+                    throw new WorldArchiveError("invalid_archive", "Archive manifest is missing");
+                let value;
+                try {
+                    value = JSON.parse(await readFile(join(extracted, "narraeon-world.json"), "utf8"));
+                }
+                catch (error) {
+                    throw new WorldArchiveError("invalid_archive", "Archive manifest is invalid", { cause: error });
+                }
+                const manifest = validateManifest(value, this.#limits);
+                if (actual.size !== manifest.files.length + 1)
+                    throw new WorldArchiveError("integrity_failed", "Archive contains extra or missing files");
+                for (const file of manifest.files) {
+                    const found = actual.get(file.path);
+                    if (file.bytes !== found?.bytes || file.sha256 !== found?.sha256)
+                        throw new WorldArchiveError("integrity_failed", "Archive file digest does not match its manifest");
+                }
+                const sourceRoot = join(quarantine, "worlds-file-native", manifest.archivedWorldId);
+                await mkdir(dirname(sourceRoot), { recursive: true });
+                try {
+                    await rename(join(extracted, "world"), sourceRoot);
+                }
+                catch (error) {
+                    if (missing(error))
+                        throw new WorldArchiveError("invalid_archive", "Archive world directory is missing");
+                    throw error;
+                }
+                // Discard any incoming machine-local display cache before storage migration or reads.
+                await rm(join(sourceRoot, "runtime", "activity.json"), {
+                    force: true,
+                });
+                const sourceWorlds = new FileNativeWorldStore(quarantine);
+                try {
+                    const publication = JSON.parse(await readFile(join(sourceRoot, "publication.json"), "utf8"));
+                    if (publication?.worldId !== manifest.archivedWorldId)
+                        throw new Error("Archive world identity mismatch");
+                    await sourceWorlds.ensureCurrentStorage(manifest.archivedWorldId);
+                    const authority = new FileNativeAuthorityV3(sourceRoot);
+                    const history = await authority.readHistory();
+                    if (history.head !== manifest.head)
+                        throw new Error("Archive head mismatch");
+                    await authority.recover("genesis");
+                    for (const commit of history.commits)
+                        await authority.recover(commit.head);
+                }
+                catch (error) {
+                    throw new WorldArchiveError("integrity_failed", "Archive Authority failed its complete audit", { cause: error });
+                }
+                crashAt("audit");
+                const sourceChains = new PlayCallChain(sourceWorlds, new FileNativePromptCompiler(), new FileNativeArtifactStore(quarantine));
+                let result;
+                try {
+                    result = await sourceChains.deriveWorld({
+                        operationId: input.operationId,
+                        sourceWorldId: manifest.archivedWorldId,
+                        sourceHead: manifest.head,
+                        hostPresetId: "world-archive",
+                        targetDataRoot: this.#dataRoot,
+                        targetName: manifest.worldName,
+                        identityPrefix: "import",
+                        resetPackageScriptPermissions: true,
+                        retainCompleteTimeline: true,
+                    });
+                }
+                catch (error) {
+                    throw new WorldArchiveError("integrity_failed", "Archive world closure cannot be restored", { cause: error });
+                }
+                crashAt("publish");
+                return { outcome: "imported", world: result.world };
+            }
+            finally {
+                await rm(quarantine, { recursive: true, force: true });
+                await rm(upload, { force: true });
+                const worldsRoot = join(this.#dataRoot, "worlds-file-native");
+                for (const entry of await readdir(worldsRoot).catch(() => []))
+                    if (entry.startsWith(`.staging-${worldId}-`))
+                        await rm(join(worldsRoot, entry), {
+                            recursive: true,
+                            force: true,
+                        });
+            }
+        });
+    }
+    #uploadPath(uploadId) {
+        return join(this.#root, "uploads", `${uploadId}.zip`);
+    }
+}
+function validateManifest(value, limits) {
+    if (!record(value))
+        throw new WorldArchiveError("invalid_archive", "Archive manifest must be an object");
+    if (value.format !== worldArchiveFormat)
+        throw new WorldArchiveError("unsupported_format", "Unsupported world archive format");
+    if (Object.keys(value).sort().join() !==
+        [
+            "format",
+            "appVersion",
+            "exportedAt",
+            "worldName",
+            "archivedWorldId",
+            "head",
+            "files",
+        ]
+            .sort()
+            .join() ||
+        typeof value.appVersion !== "string" ||
+        typeof value.exportedAt !== "string" ||
+        !Number.isFinite(Date.parse(value.exportedAt)) ||
+        typeof value.worldName !== "string" ||
+        value.worldName.trim() === "" ||
+        Array.from(value.worldName).length > 160 ||
+        value.worldName.includes("\r") ||
+        value.worldName.includes("\n") ||
+        value.worldName.includes(String.fromCharCode(0)) ||
+        typeof value.archivedWorldId !== "string" ||
+        !/^[A-Za-z0-9][A-Za-z0-9._-]{0,255}$/u.test(value.archivedWorldId) ||
+        typeof value.head !== "string" ||
+        !/^(genesis|commit:[1-9][0-9]*)$/u.test(value.head) ||
+        !Array.isArray(value.files))
+        throw new WorldArchiveError("invalid_archive", "Archive manifest has invalid fields");
+    const seen = new Set();
+    if (value.files.length + 1 > limits.entries)
+        throw new WorldArchiveError("limit_exceeded", "Too many archive files");
+    for (const file of value.files) {
+        if (!record(file) ||
+            Object.keys(file).sort().join() !== "bytes,path,sha256" ||
+            typeof file.path !== "string" ||
+            !file.path.startsWith("world/") ||
+            typeof file.bytes !== "number" ||
+            !Number.isSafeInteger(file.bytes) ||
+            file.bytes < 0 ||
+            typeof file.sha256 !== "string" ||
+            !/^[a-f0-9]{64}$/u.test(file.sha256))
+            throw new WorldArchiveError("invalid_archive", "Invalid archive file manifest");
+        archivePath(file.path);
+        const key = file.path.normalize("NFKC").toLowerCase();
+        if (seen.has(key))
+            throw new WorldArchiveError("unsafe_path", "Duplicate manifest path");
+        seen.add(key);
+    }
+    return value;
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function identity(value) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,255}$/u.test(value))
+        throw new WorldArchiveError("unsafe_path", "Invalid archive operation identity");
+}
+function missing(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function archiveBaseName(name) {
+    return (name
+        .normalize("NFKC")
+        .replaceAll(/[^\p{L}\p{N}._-]+/gu, "-")
+        .replaceAll(/^[.-]+|[.-]+$/gu, "")
+        .slice(0, 80) || "world");
+}
+async function syncFile(path) {
+    const file = await open(path, "r");
+    try {
+        await file.sync();
+    }
+    finally {
+        await file.close();
+    }
+}
+async function durableJson(path, value) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    const file = await open(temporary, "wx", 0o600);
+    try {
+        await file.writeFile(JSON.stringify(value));
+        await file.sync();
+    }
+    finally {
+        await file.close();
+    }
+    await rename(temporary, path);
+    const directory = await open(dirname(path), "r");
+    try {
+        await directory.sync();
+    }
+    finally {
+        await directory.close();
+    }
+}
+async function appVersion() {
+    let directory = import.meta.dirname;
+    for (;;) {
+        try {
+            const value = JSON.parse(await readFile(join(directory, "package.json"), "utf8"));
+            if (value.name === "narraeon")
+                return value.version;
+        }
+        catch (error) {
+            if (!missing(error))
+                throw error;
+        }
+        const parent = dirname(directory);
+        if (parent === directory)
+            throw new Error("Application version is unavailable");
+        directory = parent;
+    }
+}
+function crashAt(edge) {
+    if (process.env.NODE_ENV === "test" &&
+        process.env.NARRAEON_INTERNAL_TEST_CRASH_AT_WORLD_ARCHIVE_EDGE === edge)
+        process.exit(89);
+}

package/dist/node/runtime/config/AppPreferencesStore.js

@@ -25,7 +25,7 @@ export class AppPreferencesStore {
                 throw new Error("Unsupported app preferences update");
             const current = toView(await this.#readDocument());
             const document = {
-                schemaVersion: 2,
+                schemaVersion: 3,
                 locale: update.locale ?? current.locale,
                 reading: structuredClone(update.reading ?? current.reading),
             };
@@ -59,7 +59,7 @@ export class AppPreferencesStore {
                 throw error;
         }
         return {
-            schemaVersion: 2,
+            schemaVersion: 3,
             locale: defaultAppLocale,
             reading: structuredClone(defaultAppReadingPreferences),
         };
@@ -95,19 +95,32 @@ function validateDocument(value) {
         Object.keys(value).every((key) => key === "schemaVersion" || key === "locale"))
         return { schemaVersion: 1, locale: value.locale };
     if ("schemaVersion" in value &&
-        value.schemaVersion === 2 &&
+        (value.schemaVersion === 2 || value.schemaVersion === 3) &&
         "locale" in value &&
         isAppLocale(value.locale) &&
         "reading" in value &&
-        isAppReadingPreferences(value.reading) &&
-        Object.keys(value).every((key) => key === "schemaVersion" || key === "locale" || key === "reading"))
-        return {
-            schemaVersion: 2,
-            locale: value.locale,
-            reading: structuredClone(value.reading),
-        };
+        Object.keys(value).every((key) => key === "schemaVersion" || key === "locale" || key === "reading")) {
+        const reading = value.schemaVersion === 2
+            ? isLegacyReadingPreferences(value.reading)
+                ? { ...value.reading, showTechnicalInfo: false }
+                : null
+            : value.reading;
+        if (isAppReadingPreferences(reading))
+            return {
+                schemaVersion: 3,
+                locale: value.locale,
+                reading: structuredClone(reading),
+            };
+    }
     throw new Error("App preferences file does not match a supported schema");
 }
+function isLegacyReadingPreferences(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.keys(value).length === 5 &&
+        isAppReadingPreferences({ ...value, showTechnicalInfo: false }));
+}
 function toView(document) {
     return {
         locale: document.locale,

package/dist/node/runtime/config/ProtagonistTemplateStore.js

@@ -0,0 +1,134 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, open, readFile, rename, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { isProtagonistTemplateContent, isProtagonistTemplateId, } from "../../protocol/protagonistTemplates.js";
+const fileName = "protagonist-templates-v1.json";
+export class ProtagonistTemplateStore {
+    #root;
+    #path;
+    #mutationTail = Promise.resolve();
+    constructor(configRoot) {
+        this.#root = configRoot;
+        this.#path = join(configRoot, fileName);
+    }
+    async view() {
+        await this.#mutationTail;
+        return this.#read();
+    }
+    save(input) {
+        return this.#mutate((templates) => {
+            if (!isProtagonistTemplateContent(input.name, input.body) ||
+                (input.id !== undefined && !isProtagonistTemplateId(input.id)))
+                throw new Error("Protagonist template requires a single-line name of 1–80 characters and a Markdown body of 1–16 KiB");
+            const template = {
+                id: input.id ?? `template-${randomUUID()}`,
+                name: input.name,
+                body: input.body,
+                updatedAt: Date.now(),
+            };
+            if (input.id === undefined)
+                templates.push(template);
+            else
+                templates[findTemplate(templates, input.id)] = template;
+        });
+    }
+    copy(id) {
+        return this.#mutate((templates) => {
+            const source = templates[findTemplate(templates, id)];
+            templates.push({
+                ...source,
+                id: `template-${randomUUID()}`,
+                updatedAt: Date.now(),
+            });
+        });
+    }
+    delete(id) {
+        return this.#mutate((templates) => {
+            templates.splice(findTemplate(templates, id), 1);
+        });
+    }
+    async #mutate(operation) {
+        const previous = this.#mutationTail;
+        let release = () => undefined;
+        this.#mutationTail = new Promise((resolve) => (release = resolve));
+        await previous;
+        try {
+            const view = await this.#read();
+            operation(view.templates);
+            await this.#write(view);
+            return view;
+        }
+        finally {
+            release();
+        }
+    }
+    async #read() {
+        let contents;
+        try {
+            contents = await readFile(this.#path, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return { templates: [] };
+            throw error;
+        }
+        try {
+            return validateDocument(JSON.parse(contents));
+        }
+        catch (error) {
+            throw new Error(`${fileName} is invalid: expected schemaVersion 1 with valid protagonist templates`, { cause: error });
+        }
+    }
+    async #write(view) {
+        await mkdir(this.#root, { recursive: true, mode: 0o700 });
+        const temporary = join(this.#root, `.${fileName}.${randomUUID()}.tmp`);
+        let handle;
+        try {
+            handle = await open(temporary, "wx", 0o600);
+            await handle.writeFile(`${JSON.stringify({ schemaVersion: 1, ...view }, null, 2)}\n`, "utf8");
+            await handle.sync();
+            await handle.close();
+            handle = undefined;
+            await rename(temporary, this.#path);
+        }
+        catch (error) {
+            await handle?.close().catch(() => undefined);
+            await unlink(temporary).catch(() => undefined);
+            throw error;
+        }
+    }
+}
+function findTemplate(templates, id) {
+    if (!isProtagonistTemplateId(id))
+        throw new Error("Invalid protagonist template id");
+    const index = templates.findIndex((template) => template.id === id);
+    if (index < 0)
+        throw new Error("Protagonist template was not found");
+    return index;
+}
+function validateDocument(value) {
+    if (!isRecord(value) ||
+        value.schemaVersion !== 1 ||
+        Object.keys(value).length !== 2 ||
+        !Array.isArray(value.templates))
+        throw new Error("Invalid template document");
+    const ids = new Set();
+    for (const template of value.templates) {
+        if (!isRecord(template) ||
+            Object.keys(template).length !== 4 ||
+            !isProtagonistTemplateId(template.id) ||
+            ids.has(template.id) ||
+            !isProtagonistTemplateContent(template.name, template.body) ||
+            typeof template.updatedAt !== "number" ||
+            !Number.isSafeInteger(template.updatedAt) ||
+            template.updatedAt < 0)
+            throw new Error("Invalid template");
+        ids.add(template.id);
+    }
+    return {
+        templates: structuredClone(value.templates),
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/node/runtime/content/ContentWorkspace.js

@@ -1,9 +1,11 @@
 import { isAbsolute, win32 } from "node:path";
 import { inflateRawSync } from "node:zlib";
 import { portableContentTreePathKey } from "../../protocol/contentTree.js";
+import { fictionGameplay, gameplayFile, parseGameplay, } from "../../protocol/gameplay.js";
 import { defaultAppLocale, } from "../../protocol/appPreferences.js";
 import { defaultContentWorkspaceLimits, maximumPortableContentArchiveBytes, } from "./ContentLimits.js";
 import { CurrentTreeContentLibrary, InvalidContentTreeError, normalizeCurrentContentTreeFiles, } from "./CurrentTreeContentLibrary.js";
+import { sampleContentPackageForLocale } from "../../shared/sample-packages/index.js";
 import { inspectContentPackageCurrentTree, isContentPackageWorldDocumentPath, worldDocumentTextRequirement, } from "./FileNativeContentTree.js";
 export { CurrentTreeContentPackageBusyError, CurrentTreeContentLibraryError, CurrentTreeContentPackageNotFoundError, InvalidContentTreeError, } from "./CurrentTreeContentLibrary.js";
 const portableTreeUtf8Decoder = new TextDecoder("utf-8", {
@@ -35,13 +37,21 @@ export class ContentWorkspace {
             ...options.currentTree,
         });
     }
-    createCurrentTreeContentPackage() {
+    createCurrentTreeContentPackage(gameplay = fictionGameplay) {
         const locale = this.#locale();
+        const chosen = parseGameplay(gameplay);
         return this.#currentTreeLibrary.createPackage({
             title: defaultContentPackageTitle(locale, "new"),
-            files: minimalFileNativeContentScaffold(locale),
+            files: [
+                ...minimalFileNativeContentScaffold(locale),
+                ...(chosen.mode === "tabletop" ? [gameplayFile(chosen)] : []),
+            ],
         });
     }
+    createSampleContentPackage(locale) {
+        const sample = sampleContentPackageForLocale(locale);
+        return this.#currentTreeLibrary.createPackage(sample);
+    }
     listCurrentTreeContentPackages() {
         return this.#currentTreeLibrary.listPackages();
     }
@@ -71,6 +81,9 @@ export class ContentWorkspace {
     replaceCurrentTreeContentPackage(localId, files, options = {}) {
         return this.#currentTreeLibrary.replaceCurrentTree(localId, files, options);
     }
+    setCurrentTreeContentGameplayScheme(localId, scheme, options = {}) {
+        return this.#currentTreeLibrary.setGameplayScheme(localId, scheme, options);
+    }
     importPortableContentPackageArchive(archive, options = {}) {
         return this.#mutate(async () => {
             const files = readPortableContentArchive(archive, this.#limits, options.signal);