@openfairygui/backend 0.2.0-alpha.9 → 0.2.0

package/src/services/authoring-service.ts

@@ -1,9 +1,16 @@
-import { ProjectWriter, type FileSystem } from '@openfairygui/core/project-io';
-import { materializeUamProject, validateUamProject } from '@openfairygui/core/uam';
-import { applyUamTransactionApp, type ApplyUamTransactionAppError } from '@openfairygui/functions/uam';
-import type { CacheService } from './cache-service.js';
-import { failure, success, type BackendContext } from './context.js';
-import type { EventService } from './event-service.js';
+import type { ProjectBranchDirectory, ProjectResourceFolder, ProjectSourceFile } from '@openfairygui/core/project-io';
+import {
+	commitUamProjectSourcePaths,
+	materializeUamProject,
+	staleBranchDirectories,
+	staleResourceFolders,
+	staleSourceFiles,
+	type UamProject,
+	validateUamProject,
+} from '@openfairygui/core/uam';
+import { type ApplyUamTransactionAppError, applyUamTransactionAppAsync } from '@openfairygui/functions/uam';
+import type { BackendDiagnostic } from '../contracts.js';
+import { normalizeComparablePath, type PathPolicyViolationError, validateSaveTarget } from '../path-policy.js';
 import type {
 	ApplySessionTransactionInput,
 	BackendCapabilityUnavailableError,
@@ -15,86 +22,69 @@ import type {
 	MaterializeSessionSnapshot,
 	MaterializeValidationFailedError,
 	MaterializeWriteFailedError,
-	SaveSessionInput,
 	SavePartialFailureError,
+	SaveSessionInput,
 	SessionNotFoundError,
 	SessionStaleWriteError,
+	UamFidelityUnsupportedError,
 } from '../runtime.js';
-import type { BackendDiagnostic } from '../contracts.js';
-import { normalizeComparablePath, validateSaveTarget, type PathPolicyViolationError } from '../path-policy.js';
+import type { CacheService } from './cache-service.js';
+import { type BackendContext, failure, success } from './context.js';
+import type { EventService } from './event-service.js';
+import { writeSessionProject } from './session-project-writer.js';
 import { createSessionNotFoundError, createStaleWriteError, toSessionSnapshot } from './session-utils.js';
 
-function createWriterFileSystem(
-	fileSystem: BackendFileSystem,
-	committedPaths: string[],
-	failedPaths: string[],
-): FileSystem {
-	async function trackWrite<T>(targetPath: string, fn: () => Promise<T>): Promise<T> {
-		try {
-			const result = await fn();
-			committedPaths.push(targetPath);
-			return result;
-		} catch (error) {
-			failedPaths.push(targetPath);
-			throw error;
-		}
-	}
+function sourceFileKey(source: ProjectSourceFile): string {
+	return [source.branch, source.packageName, source.path, source.fileName].join('\0');
+}
 
-	return {
-		async readFile(filePath: string): Promise<string> {
-			return fileSystem.readFile(filePath);
-		},
-		async readFileRaw(filePath: string): Promise<Uint8Array> {
-			return fileSystem.readFileRaw(filePath);
-		},
-		async writeFile(filePath: string, content: string): Promise<void> {
-			await trackWrite(filePath, async () => {
-				await fileSystem.mkdir(fileSystem.dirname(filePath), { recursive: true });
-				await fileSystem.writeFile(filePath, content);
-			});
-		},
-		async writeFileRaw(filePath: string, data: Uint8Array): Promise<void> {
-			await trackWrite(filePath, async () => {
-				await fileSystem.mkdir(fileSystem.dirname(filePath), { recursive: true });
-				await fileSystem.writeFileRaw(filePath, data);
-			});
-		},
-		async mkdir(dirPath: string): Promise<void> {
-			await fileSystem.mkdir(dirPath, { recursive: true });
-		},
-		async readdir(dirPath: string): Promise<string[]> {
-			return fileSystem.readdir(dirPath);
-		},
-		async exists(filePath: string): Promise<boolean> {
-			try {
-				await fileSystem.stat(filePath);
-				return true;
-			} catch {
-				return false;
-			}
-		},
-		join(...paths: string[]): string {
-			return fileSystem.join(...paths);
-		},
-		dirname(filePath: string): string {
-			return fileSystem.dirname(filePath);
-		},
-	};
+function resourceFolderKey(folder: ProjectResourceFolder): string {
+	return [folder.branch, folder.packageName, folder.path].join('\0');
+}
+
+function branchDirectoryKey(directory: ProjectBranchDirectory): string {
+	return [directory.branch, directory.packageName ?? ''].join('\0');
+}
+
+function recordStaleProjectFiles(
+	session: Parameters<typeof toSessionSnapshot>[0],
+	previousProject: UamProject,
+	nextProject: UamProject,
+): void {
+	if (!session.fileSystem) return;
+	for (const source of staleSourceFiles(previousProject, nextProject)) {
+		session.pendingStaleSourceFiles.set(sourceFileKey(source), source);
+	}
+	for (const source of staleSourceFiles(nextProject, previousProject)) {
+		session.pendingStaleSourceFiles.delete(sourceFileKey(source));
+	}
+	for (const folder of staleResourceFolders(previousProject, nextProject)) {
+		session.pendingStaleResourceFolders.set(resourceFolderKey(folder), folder);
+	}
+	for (const folder of staleResourceFolders(nextProject, previousProject)) {
+		session.pendingStaleResourceFolders.delete(resourceFolderKey(folder));
+	}
+	for (const directory of staleBranchDirectories(previousProject, nextProject)) {
+		session.pendingStaleBranchDirectories.set(branchDirectoryKey(directory), directory);
+	}
+	for (const directory of staleBranchDirectories(nextProject, previousProject)) {
+		session.pendingStaleBranchDirectories.delete(branchDirectoryKey(directory));
+	}
 }
 
 function toBackendDiagnostics(error: ApplyUamTransactionAppError): BackendDiagnostic[] {
 	return error.diagnostics.length > 0
 		? error.diagnostics.map((diagnostic) => ({ ...diagnostic }))
 		: [
-			{
-				code: error.code,
-				message: error.message,
-				severity: 'error',
-				operationKind: error.operationKind,
-				opIndex: error.opIndex,
-				opId: error.opId,
-			},
-		];
+				{
+					code: error.code,
+					message: error.message,
+					severity: 'error',
+					operationKind: error.operationKind,
+					opIndex: error.opIndex,
+					opId: error.opId,
+				},
+			];
 }
 
 function createCapabilityUnavailableError(message: string): BackendCapabilityUnavailableError {
@@ -106,6 +96,17 @@ function createCapabilityUnavailableError(message: string): BackendCapabilityUna
 	};
 }
 
+function createUamFidelityUnsupportedError(
+	session: Parameters<typeof toSessionSnapshot>[0],
+): UamFidelityUnsupportedError {
+	return {
+		code: 'uam_fidelity_unsupported',
+		message: 'The source project contains formal properties that the current UAM cannot preserve.',
+		sessionId: session.sessionId,
+		canonicalPathKey: session.canonicalPathKey,
+	};
+}
+
 function validationDiagnostics(sessionProject: Parameters<typeof validateUamProject>[0]): BackendDiagnostic[] {
 	const issues = validateUamProject(sessionProject);
 	return issues.map((issue) => ({
@@ -154,13 +155,46 @@ function storageCanonicalTarget(input: NonNullable<MaterializeSessionInput['stor
 	};
 }
 
+function detachSharedByteViews(value: unknown, seen = new WeakSet<object>()): void {
+	if (!value || typeof value !== 'object' || seen.has(value)) return;
+	seen.add(value);
+	for (const [key, child] of Object.entries(value)) {
+		if (child instanceof Uint8Array) {
+			if (typeof SharedArrayBuffer !== 'undefined' && child.buffer instanceof SharedArrayBuffer) {
+				(value as Record<string, unknown>)[key] = new Uint8Array(child);
+			}
+			continue;
+		}
+		detachSharedByteViews(child, seen);
+	}
+}
+
 export class AuthoringService {
+	private readonly sessionOperations = new Map<string, Promise<void>>();
+
 	public constructor(
 		private readonly context: BackendContext,
 		private readonly cacheService: CacheService,
 		private readonly eventService: EventService,
 	) {}
 
+	private async runSessionExclusive<T>(sessionId: string, operation: () => Promise<T>): Promise<T> {
+		const previous = this.sessionOperations.get(sessionId) ?? Promise.resolve();
+		let release = (): void => undefined;
+		const current = new Promise<void>((resolve) => {
+			release = resolve;
+		});
+		const tail = previous.then(() => current);
+		this.sessionOperations.set(sessionId, tail);
+		await previous;
+		try {
+			return await operation();
+		} finally {
+			release();
+			if (this.sessionOperations.get(sessionId) === tail) this.sessionOperations.delete(sessionId);
+		}
+	}
+
 	public async applyTransaction(
 		input: ApplySessionTransactionInput,
 	): Promise<
@@ -168,6 +202,19 @@ export class AuthoringService {
 			BackendSessionSnapshot,
 			SessionNotFoundError | SessionStaleWriteError | ApplyUamTransactionAppError
 		>
+	> {
+		const queuedInput = structuredClone(input);
+		detachSharedByteViews(queuedInput);
+		return this.runSessionExclusive(queuedInput.sessionId, () => this.applyTransactionExclusive(queuedInput));
+	}
+
+	private async applyTransactionExclusive(
+		input: ApplySessionTransactionInput,
+	): Promise<
+		BackendResult<
+			BackendSessionSnapshot,
+			SessionNotFoundError | SessionStaleWriteError | ApplyUamTransactionAppError
+		>
 	> {
 		const startedAt = Date.now();
 		const session = this.context.sessions.get(input.sessionId);
@@ -193,10 +240,13 @@ export class AuthoringService {
 			);
 		}
 
-		const result = applyUamTransactionApp({
+		const result = await applyUamTransactionAppAsync({
 			project: session.project,
 			operations: input.operations,
 		});
+		if (this.context.sessions.get(input.sessionId) !== session || session.closed) {
+			return failure('authoring', startedAt, createSessionNotFoundError(input.sessionId));
+		}
 		if (result.ok === false) {
 			const diagnostics = toBackendDiagnostics(result.error);
 			this.eventService.emit({
@@ -219,6 +269,7 @@ export class AuthoringService {
 			);
 		}
 
+		recordStaleProjectFiles(session, session.project, result.project);
 		session.project = result.project;
 		session.revision += 1;
 		session.dirty = true;
@@ -243,12 +294,15 @@ export class AuthoringService {
 		});
 	}
 
-	public async saveSession(input: SaveSessionInput): Promise<
+	public async saveSession(
+		input: SaveSessionInput,
+	): Promise<
 		BackendResult<
 			BackendSessionSnapshot | MaterializeSessionSnapshot,
 			| SessionNotFoundError
 			| SessionStaleWriteError
 			| SavePartialFailureError
+			| UamFidelityUnsupportedError
 			| MaterializeValidationFailedError
 			| MaterializeWriteFailedError
 			| PathPolicyViolationError
@@ -266,19 +320,36 @@ export class AuthoringService {
 				reason: 'force_save',
 			});
 		}
+		return this.runSessionExclusive(input.sessionId, () => this.saveSessionExclusive(input));
+	}
+
+	private async saveSessionExclusive(
+		input: SaveSessionInput,
+	): Promise<
+		BackendResult<
+			BackendSessionSnapshot | MaterializeSessionSnapshot,
+			| SessionNotFoundError
+			| SessionStaleWriteError
+			| SavePartialFailureError
+			| UamFidelityUnsupportedError
+			| MaterializeValidationFailedError
+			| MaterializeWriteFailedError
+			| PathPolicyViolationError
+			| InProcessLockConflictError
+			| BackendCapabilityUnavailableError
+		>
+	> {
 		const startedAt = Date.now();
 		const session = this.context.sessions.get(input.sessionId);
 		if (!session || session.closed) {
 			return failure('authoring', startedAt, createSessionNotFoundError(input.sessionId));
 		}
-		const fileSystem = input.fileSystem ?? session.fileSystem ?? this.context.fileSystem;
+		const fileSystem = session.fileSystem ?? input.fileSystem ?? this.context.fileSystem;
 		if (!fileSystem) {
 			return failure(
 				'authoring',
 				startedAt,
-				createCapabilityUnavailableError(
-					'saveSession requires an injected BackendFileSystem adapter.',
-				),
+				createCapabilityUnavailableError('saveSession requires an injected BackendFileSystem adapter.'),
 				toSessionSnapshot(session, this.context.capabilities),
 				{
 					sessionId: session.sessionId,
@@ -317,6 +388,18 @@ export class AuthoringService {
 				revision: session.revision,
 			});
 		}
+		if (session.uamFidelity === 'unsupported') {
+			return failure(
+				'authoring',
+				startedAt,
+				createUamFidelityUnsupportedError(session),
+				toSessionSnapshot(session, this.context.capabilities),
+				{
+					sessionId: session.sessionId,
+					revision: session.revision,
+				},
+			);
+		}
 
 		const committedPaths: string[] = [];
 		const failedPaths: string[] = [];
@@ -327,8 +410,21 @@ export class AuthoringService {
 			revision: session.revision,
 		});
 		try {
-			const writer = new ProjectWriter(createWriterFileSystem(fileSystem, committedPaths, failedPaths));
-			await writer.write(materializeUamProject(session.project), session.fairyPath);
+			await writeSessionProject({
+				fileSystem,
+				document: materializeUamProject(session.project),
+				fairyPath: session.fairyPath,
+				staleSourceFiles: [...session.pendingStaleSourceFiles.values()],
+				staleResourceFolders: [...session.pendingStaleResourceFolders.values()],
+				staleBranchDirectories: [...session.pendingStaleBranchDirectories.values()],
+				writtenPaths: committedPaths,
+				failedPaths,
+			});
+			session.fileSystem ??= fileSystem;
+			session.pendingStaleSourceFiles.clear();
+			session.pendingStaleResourceFolders.clear();
+			session.pendingStaleBranchDirectories.clear();
+			commitUamProjectSourcePaths(session.project);
 			session.lastSavedRevision = session.revision;
 			session.dirty = false;
 			const cacheEntry = this.cacheService.refreshSession(session);
@@ -380,11 +476,32 @@ export class AuthoringService {
 		}
 	}
 
-	public async materializeSession(input: MaterializeSessionInput): Promise<
+	public async materializeSession(
+		input: MaterializeSessionInput,
+	): Promise<
 		BackendResult<
 			MaterializeSessionSnapshot,
 			| SessionNotFoundError
 			| SessionStaleWriteError
+			| UamFidelityUnsupportedError
+			| MaterializeValidationFailedError
+			| MaterializeWriteFailedError
+			| PathPolicyViolationError
+			| InProcessLockConflictError
+			| BackendCapabilityUnavailableError
+		>
+	> {
+		return this.runSessionExclusive(input.sessionId, () => this.materializeSessionExclusive(input));
+	}
+
+	private async materializeSessionExclusive(
+		input: MaterializeSessionInput,
+	): Promise<
+		BackendResult<
+			MaterializeSessionSnapshot,
+			| SessionNotFoundError
+			| SessionStaleWriteError
+			| UamFidelityUnsupportedError
 			| MaterializeValidationFailedError
 			| MaterializeWriteFailedError
 			| PathPolicyViolationError
@@ -411,14 +528,13 @@ export class AuthoringService {
 		}
 
 		const storageTarget = input.storage ? storageCanonicalTarget(input.storage) : null;
-		const fileSystem = storageTarget?.fileSystem ?? input.fileSystem ?? session.fileSystem ?? this.context.fileSystem;
+		const fileSystem =
+			storageTarget?.fileSystem ?? input.fileSystem ?? session.fileSystem ?? this.context.fileSystem;
 		if (!fileSystem) {
 			return failure(
 				'authoring',
 				startedAt,
-				createCapabilityUnavailableError(
-					'materializeSession requires an injected BackendFileSystem adapter.',
-				),
+				createCapabilityUnavailableError('materializeSession requires an injected BackendFileSystem adapter.'),
 				toSessionSnapshot(session, this.context.capabilities),
 				{
 					sessionId: session.sessionId,
@@ -464,6 +580,19 @@ export class AuthoringService {
 			}
 		}
 
+		if (session.uamFidelity === 'unsupported') {
+			return failure(
+				'authoring',
+				startedAt,
+				createUamFidelityUnsupportedError(session),
+				toSessionSnapshot(session, this.context.capabilities),
+				{
+					sessionId: session.sessionId,
+					revision: session.revision,
+				},
+			);
+		}
+
 		const diagnostics = validationDiagnostics(session.project);
 		if (diagnostics.length > 0) {
 			const error: MaterializeValidationFailedError = {
@@ -474,17 +603,11 @@ export class AuthoringService {
 				issueCount: diagnostics.length,
 				diagnostics,
 			};
-			return failure(
-				'authoring',
-				startedAt,
-				error,
-				toSessionSnapshot(session, this.context.capabilities),
-				{
-					sessionId: session.sessionId,
-					revision: session.revision,
-					diagnostics,
-				},
-			);
+			return failure('authoring', startedAt, error, toSessionSnapshot(session, this.context.capabilities), {
+				sessionId: session.sessionId,
+				revision: session.revision,
+				diagnostics,
+			});
 		}
 
 		let document: ReturnType<typeof materializeUamProject>;
@@ -529,8 +652,28 @@ export class AuthoringService {
 			revision: session.revision,
 		});
 		try {
-			const writer = new ProjectWriter(createWriterFileSystem(fileSystem, writtenPaths, failedPaths));
-			await writer.write(document, fairyPath);
+			const isSessionStorageTarget = fileSystem === session.fileSystem && fairyPath === session.fairyPath;
+			await writeSessionProject({
+				fileSystem,
+				document,
+				fairyPath,
+				staleSourceFiles: isSessionStorageTarget ? [...session.pendingStaleSourceFiles.values()] : [],
+				staleResourceFolders: isSessionStorageTarget ? [...session.pendingStaleResourceFolders.values()] : [],
+				staleBranchDirectories: isSessionStorageTarget ? [...session.pendingStaleBranchDirectories.values()] : [],
+				writtenPaths,
+				failedPaths,
+			});
+			if (isSessionStorageTarget) {
+				session.pendingStaleSourceFiles.clear();
+				session.pendingStaleResourceFolders.clear();
+				session.pendingStaleBranchDirectories.clear();
+			}
+			if (storageTarget && !isSessionStorageTarget) {
+				session.pendingStaleSourceFiles.clear();
+				session.pendingStaleResourceFolders.clear();
+				session.pendingStaleBranchDirectories.clear();
+			}
+			if (isSessionStorageTarget || storageTarget) commitUamProjectSourcePaths(session.project);
 			if (storageTarget) {
 				this.context.sessionsByPath.delete(session.canonicalPathKey);
 				session.fileSystem = storageTarget.fileSystem;

package/src/services/cache-service.ts

@@ -7,7 +7,6 @@ import type {
 	GetCacheSnapshotInput,
 	SessionNotFoundError,
 } from '../runtime.js';
-import { cloneCacheEntrySnapshot } from './snapshot-utils.js';
 
 function createCacheEntry(session: BackendSessionState, valid: boolean): BackendCacheEntry {
 	return {
@@ -38,7 +37,7 @@ export class CacheService {
 		const entry = this.context.cacheBySession.get(input.sessionId);
 		return success('read', startedAt, {
 			cacheRevision: entry?.revision ?? session.revision,
-			entries: entry ? [cloneCacheEntrySnapshot(entry)] : [],
+			entries: entry ? [structuredClone(entry)] : [],
 		}, { sessionId: session.sessionId, revision: session.revision });
 	}
 

package/src/services/context.ts

@@ -1,3 +1,11 @@
+import {
+	BACKEND_CAPABILITY_SCHEMA_VERSION,
+	BACKEND_CONTRACT_VERSION,
+	type BackendDiagnostic,
+	type BackendMessage,
+	type BackendResponseMeta,
+	type BackendStage,
+} from '../contracts.js';
 import type {
 	BackendCacheEntry,
 	BackendCapabilities,
@@ -7,17 +15,10 @@ import type {
 	BackendFileSystem,
 	BackendHostAdapter,
 	BackendJobSnapshot,
+	BackendSessionLock,
 	BackendSessionSnapshot,
 	BackendSuccess,
 } from '../runtime.js';
-import {
-	BACKEND_CAPABILITY_SCHEMA_VERSION,
-	BACKEND_CONTRACT_VERSION,
-	type BackendDiagnostic,
-	type BackendMessage,
-	type BackendResponseMeta,
-	type BackendStage,
-} from '../contracts.js';
 
 export interface BackendSessionState {
 	sessionId: string;
@@ -25,10 +26,18 @@ export interface BackendSessionState {
 	canonicalProjectPath: string;
 	canonicalPathKey: string;
 	lockFilePath: string;
+	sessionLock: BackendSessionLock | null;
 	fileSystem?: BackendFileSystem;
 	project: import('@openfairygui/core/uam').UamProject;
+	uamFidelity: 'full' | 'unsupported';
 	revision: number;
 	lastSavedRevision: number;
+	/** Package-controlled files deferred until a successful replacement project write. */
+	pendingStaleSourceFiles: Map<string, import('@openfairygui/core/project-io').ProjectSourceFile>;
+	/** Empty resource directories deferred until a successful replacement project write. */
+	pendingStaleResourceFolders: Map<string, import('@openfairygui/core/project-io').ProjectResourceFolder>;
+	/** Removed package-branch and root-branch directories deferred until controlled files are replaced. */
+	pendingStaleBranchDirectories: Map<string, import('@openfairygui/core/project-io').ProjectBranchDirectory>;
 	dirty: boolean;
 	lockHeld: boolean;
 	closed: boolean;

package/src/services/event-service.ts

@@ -8,7 +8,6 @@ import type {
 	GetEventsSnapshot,
 	SessionNotFoundError,
 } from '../runtime.js';
-import { cloneEventSnapshot } from './snapshot-utils.js';
 
 const DEFAULT_EVENT_RETENTION_LIMIT = 1000;
 
@@ -71,7 +70,7 @@ export class EventService {
 		const filtered = events.filter((event) => event.sequence > after);
 		const limit = input.limit === undefined ? filtered.length : Math.max(0, input.limit);
 		return success('runtime', startedAt, {
-			events: filtered.slice(0, limit).map(cloneEventSnapshot),
+			events: filtered.slice(0, limit).map((event) => structuredClone(event)),
 			oldestSequence,
 			currentSequence,
 			cursorExpired: false,

package/src/services/job-service.ts

@@ -2,7 +2,6 @@ import { failure, success, type BackendContext } from './context.js';
 import type { CacheService } from './cache-service.js';
 import type { EventService } from './event-service.js';
 import { createSessionNotFoundError } from './session-utils.js';
-import { cloneJobSnapshot } from './snapshot-utils.js';
 import type {
 	BackendJobListSnapshot,
 	BackendJobNotCancellableError,
@@ -76,7 +75,7 @@ export class JobService {
 		this.eventService.emit({ kind: 'job.created', sessionId: session.sessionId, canonicalPathKey: session.canonicalPathKey, revision: session.revision, jobId });
 		this.scheduleRefreshJob(session.sessionId, jobId);
 
-		return success('runtime', startedAt, cloneJobSnapshot(job), { sessionId: session.sessionId, revision: session.revision });
+		return success('runtime', startedAt, structuredClone(job), { sessionId: session.sessionId, revision: session.revision });
 	}
 
 	public getJob(input: GetJobInput): BackendResult<BackendJobSnapshot, SessionNotFoundError | BackendJobNotFoundError> {
@@ -92,7 +91,7 @@ export class JobService {
 				jobId: input.jobId,
 			}, undefined, { sessionId: session.sessionId, revision: session.revision });
 		}
-		return success('runtime', startedAt, cloneJobSnapshot(job), { sessionId: session.sessionId, revision: session.revision });
+		return success('runtime', startedAt, structuredClone(job), { sessionId: session.sessionId, revision: session.revision });
 	}
 
 	public listJobs(input: ListJobsInput): BackendResult<BackendJobListSnapshot, SessionNotFoundError> {
@@ -107,7 +106,7 @@ export class JobService {
 			else jobs = jobs.filter((job) => job.status === input.status);
 		}
 		if (input.limit !== undefined) jobs = jobs.slice(0, Math.max(0, input.limit));
-		return success('runtime', startedAt, { jobs: jobs.map(cloneJobSnapshot) }, { sessionId: session.sessionId, revision: session.revision });
+		return success('runtime', startedAt, { jobs: jobs.map((job) => structuredClone(job)) }, { sessionId: session.sessionId, revision: session.revision });
 	}
 
 	public cancelJob(input: CancelJobInput): BackendResult<BackendJobSnapshot, SessionNotFoundError | BackendJobNotFoundError | BackendJobNotCancellableError> {
@@ -135,7 +134,7 @@ export class JobService {
 		this.cancellationRequests.add(job.jobId);
 		this.eventService.emit({ kind: 'job.cancelRequested', sessionId: input.sessionId, canonicalPathKey: session.canonicalPathKey, revision: session.revision, jobId: job.jobId });
 		const cancelled = this.cancelRefreshJob(session.sessionId, job);
-		return success('runtime', startedAt, cloneJobSnapshot(cancelled), { sessionId: session.sessionId, revision: session.revision });
+		return success('runtime', startedAt, structuredClone(cancelled), { sessionId: session.sessionId, revision: session.revision });
 	}
 
 	public removeSession(sessionId: string): void {

package/src/services/read-service.ts

@@ -1,13 +1,12 @@
 import { failure, success, type BackendContext } from './context.js';
 import type { BackendCapabilities, BackendResult, BackendSessionSnapshot, SessionNotFoundError } from '../runtime.js';
 import { createSessionNotFoundError, toSessionSnapshot } from './session-utils.js';
-import { cloneCapabilitiesSnapshot } from './snapshot-utils.js';
 
 export class ReadService {
 	public constructor(private readonly context: BackendContext) {}
 
 	public getCapabilities(): BackendResult<BackendCapabilities> {
-		return success('read', Date.now(), cloneCapabilitiesSnapshot(this.context.capabilities));
+		return success('read', Date.now(), structuredClone(this.context.capabilities));
 	}
 
 	public getSession(input: { sessionId: string }): BackendResult<BackendSessionSnapshot, SessionNotFoundError> {