typescript 7.1.0-dev.20260917.1 → 7.1.0-dev.20260918.1

package/dist/api/sync/api.js

@@ -11,6 +11,7 @@ import { ModuleResolutionKind } from "#enums/moduleResolutionKind";
 import { NewLineKind } from "#enums/newLineKind";
 import { NodeBuilderFlags } from "#enums/nodeBuilderFlags";
 import { ObjectFlags } from "#enums/objectFlags";
+import { ScriptKind } from "#enums/scriptKind";
 import { SignatureFlags } from "#enums/signatureFlags";
 import { SignatureKind } from "#enums/signatureKind";
 import { SymbolFlags } from "#enums/symbolFlags";
@@ -23,28 +24,31 @@ import { encodeNode, uint8ArrayToBase64, } from "../node/encoder.js";
 import { decodeNode, getNodeId, parseNodeHandle, readParseOptionsKey, readSourceFileHash, RemoteSourceFile, } from "../node/node.js";
 import { Wtf8Decoder } from "../node/wtf8.js";
 import { createGetCanonicalFileName, toPath, } from "../path.js";
-import { resolveFileName, toUpdateSnapshotRequest, } from "../proto.js";
+import { resolveFileName, toCreateSnapshotRequest, } from "../proto.js";
 import { SourceFileCache } from "../sourceFileCache.js";
 import { Client, } from "./client.js";
 export { formatDiagnostics, formatDiagnosticsWithColorAndContext } from "../diagnosticFormatter.js";
 export { documentURIToFileName, fileNameToDocumentURI } from "../path.js";
-export { CheckFlags, CompletionItemKind, DiagnosticCategory, ElementFlags, EmitOnly, IndexKind, JsxEmit, ModifierFlags, ModuleKind, ModuleResolutionKind, NodeBuilderFlags, ObjectFlags, SignatureFlags, SignatureKind, SymbolFlags, TypeFlags, TypeFormatFlags, TypePredicateKind };
+export { CheckFlags, CompletionItemKind, DiagnosticCategory, ElementFlags, EmitOnly, IndexKind, JsxEmit, ModifierFlags, ModuleKind, ModuleResolutionKind, NodeBuilderFlags, ObjectFlags, ScriptKind, SignatureFlags, SignatureKind, SymbolFlags, TypeFlags, TypeFormatFlags, TypePredicateKind };
 export { all, defer } from "./generatorSupport.js";
+import { sourceFileResponseToUint8Array } from "../node/encoder.js";
 import { executeRequestGenerators, } from "./generatorSupport.js";
 export class API {
     client;
     sourceFileCache;
     toPath;
     currentDirectory;
+    decoder = new Wtf8Decoder();
     getCanonicalFileNameWorker;
     initialized = false;
     initializing;
     activeSnapshots = new Set();
-    latestSnapshot;
+    printer;
     internal;
     constructor(options = {}) {
         this.client = new Client(options);
         this.sourceFileCache = new SourceFileCache();
+        this.printer = new Printer(this.client);
         this.internal = new InternalAPI(this.client, this.ensureInitialized);
     }
     /**
@@ -165,6 +169,42 @@ export class API {
             return yield* apiRequest("parseJsonConfigFileContent", { json, ...options });
         });
     }
+    get createSourceFile() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "createSourceFile", function (fileName, sourceText, options = {}) {
+            owner.ensureInitialized();
+            const data = owner.client.apiRequestBinary("createSourceFile", { fileName, sourceText, options });
+            if (!data) {
+                throw new Error("createSourceFile returned no source file");
+            }
+            return new RemoteSourceFile(data, owner.decoder, owner.client.getTimingCollector());
+        }, function* (fileName, sourceText, options = {}) {
+            yield* owner.ensureInitialized.gen();
+            const data = sourceFileResponseToUint8Array(yield* apiRequest("createSourceFile", { fileName, sourceText, options }));
+            if (!data) {
+                throw new Error("createSourceFile returned no source file");
+            }
+            return new RemoteSourceFile(data, owner.decoder, owner.client.getTimingCollector());
+        });
+    }
+    get createSourceFileFromFile() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "createSourceFileFromFile", function (file, options = {}) {
+            owner.ensureInitialized();
+            const data = owner.client.apiRequestBinary("createSourceFileFromFile", { fileName: resolveFileName(file), options });
+            if (!data) {
+                throw new Error("createSourceFileFromFile returned no source file");
+            }
+            return new RemoteSourceFile(data, owner.decoder, owner.client.getTimingCollector());
+        }, function* (file, options = {}) {
+            yield* owner.ensureInitialized.gen();
+            const data = sourceFileResponseToUint8Array(yield* apiRequest("createSourceFileFromFile", { fileName: resolveFileName(file), options }));
+            if (!data) {
+                throw new Error("createSourceFileFromFile returned no source file");
+            }
+            return new RemoteSourceFile(data, owner.decoder, owner.client.getTimingCollector());
+        });
+    }
     get transpileModule() {
         const owner = this;
         return cacheGeneratorMethod(owner, "transpileModule", function (input, options = {}) {
@@ -205,82 +245,125 @@ export class API {
             return yield* apiRequest("transpileDeclarationFromFile", { fileName: resolveFileName(file), options });
         });
     }
-    get updateSnapshot() {
+    get createSnapshot() {
         const owner = this;
-        return cacheGeneratorMethod(owner, "updateSnapshot", function (params) {
-            return owner.updateSnapshotWorker(params);
-        }, function* (params) {
-            return yield* owner.updateSnapshotWorker.gen(params);
-        });
+        function createSnapshot(params) {
+            owner.ensureInitialized();
+            const requestParams = toCreateSnapshotRequest(params);
+            const data = owner.client.apiRequest("createSnapshot", requestParams);
+            const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
+                owner.activeSnapshots.delete(snapshot);
+                owner.sourceFileCache.releaseSnapshot(snapshot.id);
+            }, owner.createSnapshotUpdater(() => snapshot), undefined);
+            owner.activeSnapshots.add(snapshot);
+            return snapshot;
+        }
+        function* gen(params) {
+            yield* owner.ensureInitialized.gen();
+            const requestParams = toCreateSnapshotRequest(params);
+            const data = yield* apiRequest("createSnapshot", requestParams);
+            const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
+                owner.activeSnapshots.delete(snapshot);
+                owner.sourceFileCache.releaseSnapshot(snapshot.id);
+            }, owner.createSnapshotUpdater(() => snapshot), undefined);
+            owner.activeSnapshots.add(snapshot);
+            return snapshot;
+        }
+        return cacheGeneratorMethod(owner, "createSnapshot", createSnapshot, gen);
     }
-    /** @internal */
-    get updateSnapshotFrom() {
+    get updateSnapshot() {
         const owner = this;
-        return cacheGeneratorMethod(owner, "updateSnapshotFrom", function (baseSnapshot, params) {
+        return cacheGeneratorMethod(owner, "updateSnapshot", function (baseSnapshot, params) {
+            owner.ensureInitialized();
             if (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
                 throw new Error("Cannot update an inactive snapshot");
             }
-            if (baseSnapshot !== owner.latestSnapshot) {
-                // TODO: Support forking active memory/cache snapshots once the server-side
-                // ownership, project state, and cache semantics have been worked out.
-                throw new Error("Snapshot.update can only update the latest snapshot");
-            }
-            return owner.updateSnapshotWorker(params, baseSnapshot);
+            const data = owner.client.apiRequest("updateSnapshot", {
+                snapshot: baseSnapshot.id,
+                changes: toCreateSnapshotRequest(params),
+            });
+            owner.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
+            const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
+                owner.activeSnapshots.delete(snapshot);
+                owner.sourceFileCache.releaseSnapshot(snapshot.id);
+            }, owner.createSnapshotUpdater(() => snapshot), baseSnapshot);
+            owner.activeSnapshots.add(snapshot);
+            return snapshot;
         }, function* (baseSnapshot, params) {
+            yield* owner.ensureInitialized.gen();
             if (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
                 throw new Error("Cannot update an inactive snapshot");
             }
-            if (baseSnapshot !== owner.latestSnapshot) {
-                // TODO: Support forking active memory/cache snapshots once the server-side
-                // ownership, project state, and cache semantics have been worked out.
-                throw new Error("Snapshot.update can only update the latest snapshot");
-            }
-            return yield* owner.updateSnapshotWorker.gen(params, baseSnapshot);
+            const data = yield* apiRequest("updateSnapshot", {
+                snapshot: baseSnapshot.id,
+                changes: toCreateSnapshotRequest(params),
+            });
+            owner.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
+            const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
+                owner.activeSnapshots.delete(snapshot);
+                owner.sourceFileCache.releaseSnapshot(snapshot.id);
+            }, owner.createSnapshotUpdater(() => snapshot), baseSnapshot);
+            owner.activeSnapshots.add(snapshot);
+            return snapshot;
         });
     }
-    get updateSnapshotWorker() {
+    createSnapshotUpdater(getSnapshot) {
+        const update = ((params) => this.updateSnapshot(getSnapshot(), params));
+        const owner = this;
+        update.gen = function* (params) {
+            return yield* owner.updateSnapshot.gen(getSnapshot(), params);
+        };
+        return update;
+    }
+    /**
+     * Returns the language server's current canonical snapshot after atomically
+     * adopting any supplied API-driven changes. Only available on LSP-connected APIs.
+     */
+    get getCurrentLanguageServerSnapshot() {
         const owner = this;
-        return cacheGeneratorMethod(owner, "updateSnapshotWorker", function (params, baseSnapshot) {
+        function getCurrentLanguageServerSnapshot(...args) {
             owner.ensureInitialized();
-            const requestParams = toUpdateSnapshotRequest(params, baseSnapshot?.id);
-            const data = owner.client.apiRequest("updateSnapshot", requestParams);
-            // Retain cached source files from previous snapshot for unchanged files
-            if (owner.latestSnapshot) {
-                owner.sourceFileCache.retainForSnapshot(data.snapshot, owner.latestSnapshot.id, data.changes);
-                if (owner.latestSnapshot.isDisposed()) {
-                    owner.sourceFileCache.releaseSnapshot(owner.latestSnapshot.id);
-                }
+            const changes = args[0];
+            const baseSnapshot = args[1];
+            if (baseSnapshot && (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed())) {
+                throw new Error("Cannot use an inactive snapshot as a response base");
+            }
+            const data = owner.client.apiRequest("getCurrentLanguageServerSnapshot", {
+                ...(baseSnapshot ? { baseSnapshot: baseSnapshot.id } : {}),
+                ...(changes ? { changes } : {}),
+            });
+            if (baseSnapshot) {
+                owner.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
             }
             const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
                 owner.activeSnapshots.delete(snapshot);
-                if (snapshot !== owner.latestSnapshot) {
-                    owner.sourceFileCache.releaseSnapshot(snapshot.id);
-                }
-            });
-            owner.latestSnapshot = snapshot;
+                owner.sourceFileCache.releaseSnapshot(snapshot.id);
+            }, owner.createSnapshotUpdater(() => snapshot), baseSnapshot);
             owner.activeSnapshots.add(snapshot);
             return snapshot;
-        }, function* (params, baseSnapshot) {
+        }
+        function* gen(...args) {
             yield* owner.ensureInitialized.gen();
-            const requestParams = toUpdateSnapshotRequest(params, baseSnapshot?.id);
-            const data = yield* apiRequest("updateSnapshot", requestParams);
-            // Retain cached source files from previous snapshot for unchanged files
-            if (owner.latestSnapshot) {
-                owner.sourceFileCache.retainForSnapshot(data.snapshot, owner.latestSnapshot.id, data.changes);
-                if (owner.latestSnapshot.isDisposed()) {
-                    owner.sourceFileCache.releaseSnapshot(owner.latestSnapshot.id);
-                }
+            const changes = args[0];
+            const baseSnapshot = args[1];
+            if (baseSnapshot && (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed())) {
+                throw new Error("Cannot use an inactive snapshot as a response base");
+            }
+            const data = yield* apiRequest("getCurrentLanguageServerSnapshot", {
+                ...(baseSnapshot ? { baseSnapshot: baseSnapshot.id } : {}),
+                ...(changes ? { changes } : {}),
+            });
+            if (baseSnapshot) {
+                owner.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
             }
             const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
                 owner.activeSnapshots.delete(snapshot);
-                if (snapshot !== owner.latestSnapshot) {
-                    owner.sourceFileCache.releaseSnapshot(snapshot.id);
-                }
-            });
-            owner.latestSnapshot = snapshot;
+                owner.sourceFileCache.releaseSnapshot(snapshot.id);
+            }, owner.createSnapshotUpdater(() => snapshot), baseSnapshot);
             owner.activeSnapshots.add(snapshot);
             return snapshot;
-        });
+        }
+        return cacheGeneratorMethod(owner, "getCurrentLanguageServerSnapshot", getCurrentLanguageServerSnapshot, gen);
     }
     [globalThis.Symbol.dispose]() {
         this.close();
@@ -293,11 +376,6 @@ export class API {
                 for (const snapshot of [...owner.activeSnapshots]) {
                     snapshot.dispose();
                 }
-                // Release the latest snapshot's cache refs if still held
-                if (owner.latestSnapshot) {
-                    owner.sourceFileCache.releaseSnapshot(owner.latestSnapshot.id);
-                    owner.latestSnapshot = undefined;
-                }
                 owner.sourceFileCache.clear();
             }
             finally {
@@ -309,11 +387,6 @@ export class API {
                 for (const snapshot of [...owner.activeSnapshots]) {
                     yield* snapshot.dispose.gen();
                 }
-                // Release the latest snapshot's cache refs if still held
-                if (owner.latestSnapshot) {
-                    owner.sourceFileCache.releaseSnapshot(owner.latestSnapshot.id);
-                    owner.latestSnapshot = undefined;
-                }
                 owner.sourceFileCache.clear();
             }
             finally {
@@ -331,16 +404,13 @@ export class API {
             if (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
                 throw new Error("Cannot run a temporary file update on an inactive snapshot");
             }
-            const data = owner.client.apiRequest("updateTemporarySnapshot", { snapshot: baseSnapshot.id, file, newText });
-            // Retain cached source files from the base snapshot for files unchanged by
-            // the temporary update. The temporary snapshot is not the latest snapshot, so
-            // we never release the latest snapshot's cache here.
-            owner.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
-            const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
-                owner.activeSnapshots.delete(snapshot);
-                owner.sourceFileCache.releaseSnapshot(snapshot.id);
+            const snapshot = baseSnapshot.update({
+                fileSystem: {
+                    kind: "layer",
+                    files: { [resolveFileName(file)]: newText },
+                },
+                ensurePrograms: true,
             });
-            owner.activeSnapshots.add(snapshot);
             try {
                 cb(snapshot);
             }
@@ -352,16 +422,13 @@ export class API {
             if (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
                 throw new Error("Cannot run a temporary file update on an inactive snapshot");
             }
-            const data = yield* apiRequest("updateTemporarySnapshot", { snapshot: baseSnapshot.id, file, newText });
-            // Retain cached source files from the base snapshot for files unchanged by
-            // the temporary update. The temporary snapshot is not the latest snapshot, so
-            // we never release the latest snapshot's cache here.
-            owner.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
-            const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
-                owner.activeSnapshots.delete(snapshot);
-                owner.sourceFileCache.releaseSnapshot(snapshot.id);
+            const snapshot = yield* baseSnapshot.update.gen({
+                fileSystem: {
+                    kind: "layer",
+                    files: { [resolveFileName(file)]: newText },
+                },
+                ensurePrograms: true,
             });
-            owner.activeSnapshots.add(snapshot);
             try {
                 yield* (cb(snapshot) ?? []);
             }
@@ -398,69 +465,32 @@ export class API {
             return owner.client.resetTimingInfo();
         });
     }
-    isProgramActive(program) {
-        const project = program.getProject();
-        for (const snapshot of this.activeSnapshots) {
-            if (!snapshot.isDisposed() && snapshot.getProject(project.configFileName)?.program === program) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Creates a program from current filesystem state, or derives one from oldProgram after applying fileChanges.
-     */
+    /** Creates a program from current filesystem state. */
     get createProgram() {
         const owner = this;
-        return cacheGeneratorMethod(owner, "createProgram", function (rootFiles, createProgramOptions, oldProgram, fileChanges) {
+        return cacheGeneratorMethod(owner, "createProgram", function (rootFiles, createProgramOptions) {
             owner.ensureInitialized();
-            if (fileChanges && !oldProgram) {
-                throw new Error("fileChanges requires an oldProgram");
-            }
-            if (oldProgram && !owner.isProgramActive(oldProgram)) {
-                throw new Error("oldProgram must belong to this API instance and reference an active snapshot");
-            }
-            const data = owner.client.apiRequest("createProgram", {
-                rootFiles,
-                createProgramOptions,
-                oldProgram: oldProgram ? { snapshot: oldProgram.snapshotId, project: oldProgram.getProject().id } : undefined,
-                fileChanges,
+            const snapshot = owner.createSnapshot({
+                createPrograms: [{ rootFiles, options: createProgramOptions }],
             });
-            if (!data.project) {
+            const program = snapshot.operation.createdPrograms[0];
+            if (!program) {
+                snapshot.dispose();
                 throw new Error("createProgram did not return a project");
             }
-            const snapshot = new Snapshot({ snapshot: data.snapshot, projects: [data.project] }, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
-                owner.activeSnapshots.delete(snapshot);
-                owner.sourceFileCache.releaseSnapshot(snapshot.id);
-            });
-            const program = snapshot.getProjects()[0].program;
             program.setOwnedSnapshot(snapshot);
-            owner.activeSnapshots.add(snapshot);
             return program;
-        }, function* (rootFiles, createProgramOptions, oldProgram, fileChanges) {
+        }, function* (rootFiles, createProgramOptions) {
             yield* owner.ensureInitialized.gen();
-            if (fileChanges && !oldProgram) {
-                throw new Error("fileChanges requires an oldProgram");
-            }
-            if (oldProgram && !owner.isProgramActive(oldProgram)) {
-                throw new Error("oldProgram must belong to this API instance and reference an active snapshot");
-            }
-            const data = yield* apiRequest("createProgram", {
-                rootFiles,
-                createProgramOptions,
-                oldProgram: oldProgram ? { snapshot: oldProgram.snapshotId, project: oldProgram.getProject().id } : undefined,
-                fileChanges,
+            const snapshot = yield* owner.createSnapshot.gen({
+                createPrograms: [{ rootFiles, options: createProgramOptions }],
             });
-            if (!data.project) {
+            const program = snapshot.operation.createdPrograms[0];
+            if (!program) {
+                yield* snapshot.dispose.gen();
                 throw new Error("createProgram did not return a project");
             }
-            const snapshot = new Snapshot({ snapshot: data.snapshot, projects: [data.project] }, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
-                owner.activeSnapshots.delete(snapshot);
-                owner.sourceFileCache.releaseSnapshot(snapshot.id);
-            });
-            const program = snapshot.getProjects()[0].program;
             program.setOwnedSnapshot(snapshot);
-            owner.activeSnapshots.add(snapshot);
             return program;
         });
     }
@@ -510,37 +540,76 @@ export class InternalAPI {
 }
 export class Snapshot {
     id;
+    operation;
     projectMap;
     toPath;
     client;
     disposed = false;
     disposePromise;
     onDispose;
-    api;
     snapshotRegistry;
+    projectDataMap;
+    updateSnapshot;
     internal;
-    constructor(data, client, sourceFileCache, toPath, api, onDispose) {
+    constructor(data, client, sourceFileCache, toPath, formatDiagnosticsHost, onDispose, updateSnapshot, baseSnapshot) {
         this.id = data.snapshot;
         this.client = client;
         this.toPath = toPath;
-        this.api = api;
         this.onDispose = onDispose;
+        this.updateSnapshot = updateSnapshot;
         this.projectMap = new Map();
+        const projectDataMap = new Map(baseSnapshot?.projectDataMap);
+        for (const projectId of data.changes?.removedProjects ?? []) {
+            projectDataMap.delete(projectId);
+        }
+        for (const projectData of data.projects) {
+            projectDataMap.set(projectData.id, projectData);
+        }
+        this.projectDataMap = new Map([...projectDataMap].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
         this.snapshotRegistry = new SnapshotObjectRegistry(client, this.id, projectId => this.projectMap.get(projectId));
-        for (const projData of data.projects) {
-            const project = new Project(projData, this.id, client, sourceFileCache, toPath, api, this.snapshotRegistry);
-            this.projectMap.set(toPath(projData.configFileName), project);
+        for (const projData of this.projectDataMap.values()) {
+            const project = new Project(projData, this.id, client, sourceFileCache, toPath, formatDiagnosticsHost, this.snapshotRegistry);
+            this.projectMap.set(projData.id, project);
         }
+        this.operation = {
+            ...(data.operation.createdPrograms ? { createdPrograms: data.operation.createdPrograms.map(projectId => this.requireProject(projectId).program) } : {}),
+            ...(data.operation.openedFiles ? { openedFiles: data.operation.openedFiles.map(result => ({ project: this.requireProject(result.project) })) } : {}),
+        };
         this.internal = new SnapshotInternalAPI(this.id, client);
     }
     getProjects() {
         this.ensureNotDisposed();
         return [...this.projectMap.values()];
     }
-    getProject(configFileName) {
+    getConfiguredProject(configFileName) {
         this.ensureNotDisposed();
         return this.projectMap.get(this.toPath(configFileName));
     }
+    getProject(projectId) {
+        this.ensureNotDisposed();
+        return this.projectMap.get(projectId);
+    }
+    getProgram(projectId) {
+        return this.getProject(projectId)?.program;
+    }
+    get update() {
+        const owner = this;
+        function update(params) {
+            owner.ensureNotDisposed();
+            return owner.updateSnapshot(params);
+        }
+        function* gen(params) {
+            owner.ensureNotDisposed();
+            return yield* owner.updateSnapshot.gen(params);
+        }
+        return cacheGeneratorMethod(owner, "update", update, gen);
+    }
+    /**
+     * Gets the default project for a given file from the configured projects and
+     * inferred project already loaded in the snapshot. Synthetic projects are not
+     * considered. Files that have been opened with `openFiles` are guaranteed to
+     * have a result.
+     */
     get getDefaultProjectForFile() {
         const owner = this;
         return cacheGeneratorMethod(owner, "getDefaultProjectForFile", function (file) {
@@ -551,7 +620,7 @@ export class Snapshot {
             });
             if (!data)
                 return undefined;
-            return owner.projectMap.get(owner.toPath(data.configFileName));
+            return owner.projectMap.get(data.id);
         }, function* (file) {
             owner.ensureNotDisposed();
             const data = yield* apiRequest("getDefaultProjectForFile", {
@@ -560,21 +629,7 @@ export class Snapshot {
             });
             if (!data)
                 return undefined;
-            return owner.projectMap.get(owner.toPath(data.configFileName));
-        });
-    }
-    /**
-     * Creates the next snapshot, layering its filesystem over this snapshot's
-     * filesystem. This snapshot must still be active and be the latest snapshot.
-     */
-    get update() {
-        const owner = this;
-        return cacheGeneratorMethod(owner, "update", function (params) {
-            owner.ensureNotDisposed();
-            return owner.api.updateSnapshotFrom(owner, params);
-        }, function* (params) {
-            owner.ensureNotDisposed();
-            return yield* owner.api.updateSnapshotFrom.gen(owner, params);
+            return owner.projectMap.get(data.id);
         });
     }
     [globalThis.Symbol.dispose]() {
@@ -630,6 +685,13 @@ export class Snapshot {
             throw new Error("Snapshot is disposed");
         }
     }
+    requireProject(projectId) {
+        const project = this.projectMap.get(projectId);
+        if (!project) {
+            throw new Error(`Snapshot operation returned unknown project '${projectId}'`);
+        }
+        return project;
+    }
 }
 class SnapshotObjectRegistry {
     symbols = new Map();
@@ -641,7 +703,7 @@ class SnapshotObjectRegistry {
         this.snapshotId = snapshotId;
         this.resolveProject = resolveProject;
     }
-    /** Resolve a project id (a config file path) to its Project within this snapshot. */
+    /** Resolve a project ID to its Project within this snapshot. */
     getProject(projectId) {
         return this.resolveProject(projectId);
     }
@@ -1099,6 +1161,7 @@ export class Project {
     id;
     configFileName;
     currentDirectory;
+    dirty;
     parsedCommandLine;
     /** @deprecated Use `parsedCommandLine.options`. */
     compilerOptions;
@@ -1106,7 +1169,6 @@ export class Project {
     rootFiles;
     program;
     checker;
-    emitter;
     languageService;
     client;
     snapshotId;
@@ -1114,6 +1176,7 @@ export class Project {
         this.id = data.id;
         this.configFileName = data.configFileName;
         this.currentDirectory = data.currentDirectory;
+        this.dirty = data.dirty;
         if (!data.parsedCommandLine?.options) {
             throw new Error(`Project '${data.configFileName}' has no parsed command line`);
         }
@@ -1125,7 +1188,6 @@ export class Project {
         this.program = new Program(snapshotId, this, client, sourceFileCache, toPath, formatDiagnosticsHost);
         const objectRegistry = new ProjectObjectRegistry(client, snapshotId, this, snapshotRegistry);
         this.checker = new Checker(snapshotId, this, client, objectRegistry);
-        this.emitter = new Emitter(client);
         this.languageService = new LanguageService(snapshotId, this, client, objectRegistry);
     }
     /** @deprecated Use `languageService.getImportAdderEdits`. */
@@ -1339,6 +1401,7 @@ export class LanguageService {
 export class Program {
     /** @internal */
     snapshotId;
+    id;
     project;
     client;
     sourceFileCache;
@@ -1350,6 +1413,7 @@ export class Program {
     disposePromise;
     constructor(snapshotId, project, client, sourceFileCache, toPath, formatDiagnosticsHost) {
         this.snapshotId = snapshotId;
+        this.id = project.id;
         this.project = project;
         this.client = client;
         this.sourceFileCache = sourceFileCache;
@@ -1431,11 +1495,11 @@ export class Program {
                 return retained;
             }
             // Fetch from server
-            const binaryData = owner.client.apiRequestBinary("getSourceFile", {
+            const binaryData = sourceFileResponseToUint8Array(yield* apiRequest("getSourceFile", {
                 snapshot: owner.snapshotId,
                 project: owner.project.id,
                 file,
-            });
+            }));
             if (!binaryData) {
                 return undefined;
             }
@@ -1707,11 +1771,11 @@ export class Program {
             }
             return new RemoteSourceFile(binaryData, owner.decoder);
         }, function* (file) {
-            const binaryData = owner.client.apiRequestBinary("getConfigSourceFile", {
+            const binaryData = sourceFileResponseToUint8Array(yield* apiRequest("getConfigSourceFile", {
                 snapshot: owner.snapshotId,
                 project: owner.project.id,
                 file,
-            });
+            }));
             if (!binaryData) {
                 return undefined;
             }
@@ -2843,13 +2907,13 @@ export class Checker {
                 return undefined;
             return decodeNode(binaryData);
         }, function* (type, enclosingDeclaration, flags) {
-            const binaryData = owner.client.apiRequestBinary("typeToTypeNode", {
+            const binaryData = sourceFileResponseToUint8Array(yield* apiRequest("typeToTypeNode", {
                 snapshot: owner.snapshotId,
                 project: owner.project.id,
                 type: type.id,
                 location: enclosingDeclaration ? getNodeId(enclosingDeclaration) : undefined,
                 flags,
-            });
+            }));
             if (!binaryData)
                 return undefined;
             return decodeNode(binaryData);
@@ -2870,14 +2934,14 @@ export class Checker {
                 return undefined;
             return decodeNode(binaryData);
         }, function* (signature, kind, enclosingDeclaration, flags) {
-            const binaryData = owner.client.apiRequestBinary("signatureToSignatureDeclaration", {
+            const binaryData = sourceFileResponseToUint8Array(yield* apiRequest("signatureToSignatureDeclaration", {
                 snapshot: owner.snapshotId,
                 project: owner.project.id,
                 signature: signature.id,
                 kind,
                 location: enclosingDeclaration ? getNodeId(enclosingDeclaration) : undefined,
                 flags,
-            });
+            }));
             if (!binaryData)
                 return undefined;
             return decodeNode(binaryData);
@@ -3584,7 +3648,7 @@ export class Checker {
         });
     }
 }
-export class Emitter {
+export class Printer {
     client;
     constructor(client) {
         this.client = client;
@@ -3611,6 +3675,28 @@ export class Emitter {
             });
         });
     }
+    get printFile() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "printFile", function (sourceFile, options = {}) {
+            const encoded = encodeNode(sourceFile);
+            const base64 = uint8ArrayToBase64(encoded);
+            return owner.client.apiRequest("printNode", {
+                data: base64,
+                preserveSourceNewlines: options.preserveSourceNewlines,
+                neverAsciiEscape: options.neverAsciiEscape,
+                terminateUnterminatedLiterals: options.terminateUnterminatedLiterals,
+            });
+        }, function* (sourceFile, options = {}) {
+            const encoded = encodeNode(sourceFile);
+            const base64 = uint8ArrayToBase64(encoded);
+            return yield* apiRequest("printNode", {
+                data: base64,
+                preserveSourceNewlines: options.preserveSourceNewlines,
+                neverAsciiEscape: options.neverAsciiEscape,
+                terminateUnterminatedLiterals: options.terminateUnterminatedLiterals,
+            });
+        });
+    }
 }
 export class SnapshotInternalAPI {
     snapshotId;