@openfairygui/backend 0.2.0-alpha.0 → 0.2.0-alpha.2

package/src/runtime.ts

@@ -1,11 +1,9 @@
 import {
 	UAM_SUPPORTED_MATERIALIZATION_SCOPE,
+	type UamProject,
 	type UamTransactionOperation,
-} from '@openfairygui/core';
-import type { ApplyUamTransactionAppError } from '@openfairygui/functions';
-import fs from 'node:fs/promises';
-import type { Stats } from 'node:fs';
-import path from 'node:path';
+} from '@openfairygui/core/uam';
+import type { ApplyUamTransactionAppError } from '@openfairygui/functions/uam';
 import {
 	BACKEND_CAPABILITY_SCHEMA_VERSION,
 	BACKEND_COMPATIBILITY_POLICY,
@@ -27,8 +25,13 @@ export interface BackendFileHandle {
 	close(): Promise<void>;
 }
 
+export interface BackendFileStat {
+	isFile(): boolean;
+	isDirectory(): boolean;
+}
+
 export interface BackendFileSystem {
-	stat(filePath: string): Promise<Stats>;
+	stat(filePath: string): Promise<BackendFileStat>;
 	readdir(dirPath: string): Promise<string[]>;
 	readFile(filePath: string): Promise<string>;
 	readFileRaw(filePath: string): Promise<Uint8Array>;
@@ -43,6 +46,44 @@ export interface BackendFileSystem {
 	resolve(...paths: string[]): string;
 }
 
+export interface BackendHostAdapter {
+	lockMetadata?(input: { canonicalPathKey: string; canonicalProjectPath: string; lockFilePath: string }): unknown;
+}
+
+export interface BackendArtifactBridgeCapability {
+	available: false;
+	requiredHost: 'node';
+	executionBoundary: 'external-bridge';
+	bridgeEntrypoint: '@openfairygui/backend/node';
+	reason: string;
+}
+
+export interface BackendCapabilityManifest {
+	browserSafe: true;
+	rootEntrypoint: '@openfairygui/backend';
+	nodeEntrypoint: '@openfairygui/backend/node';
+	adapters: {
+		fileSystem: {
+			injected: true;
+			requiredFor: readonly ['openSession', 'saveSession'];
+		};
+		host: {
+			injected: true;
+			requiredFor: readonly ['advisoryLockMetadata'];
+		};
+	};
+	executionBoundaries: {
+		projectSession: 'in-process-browser-safe';
+		fileBackedSession: 'adapter-backed';
+		artifactPublish: BackendArtifactBridgeCapability;
+		artifactRestore: BackendArtifactBridgeCapability;
+	};
+	diagnostics: {
+		stableCodes: true;
+		errorDiagnosticMirror: true;
+	};
+}
+
 export interface BackendCapabilities {
 	contractVersion: typeof BACKEND_CONTRACT_VERSION;
 	capabilitySchemaVersion: typeof BACKEND_CAPABILITY_SCHEMA_VERSION;
@@ -52,6 +93,7 @@ export interface BackendCapabilities {
 	methods: readonly [
 		'getCapabilities',
 		'openSession',
+		'openProjectSession',
 		'getSession',
 		'applyTransaction',
 		'saveSession',
@@ -78,8 +120,11 @@ export interface BackendCapabilities {
 	artifact: {
 		publish: false;
 		restore: false;
-		status: 'deferred';
+		status: 'bridge-required';
+		publishBridge: BackendArtifactBridgeCapability;
+		restoreBridge: BackendArtifactBridgeCapability;
 	};
+	manifest: BackendCapabilityManifest;
 	compatibilityPolicy: typeof BACKEND_COMPATIBILITY_POLICY;
 	runtime: {
 		sessionRuntime: true;
@@ -140,9 +185,7 @@ export interface BackendFailure<E extends BackendError = BackendError> {
 	session?: BackendSessionSnapshot;
 }
 
-export type BackendResult<T, E extends BackendError = BackendError> =
-	| BackendSuccess<T>
-	| BackendFailure<E>;
+export type BackendResult<T, E extends BackendError = BackendError> = BackendSuccess<T> | BackendFailure<E>;
 
 export interface SessionNotFoundError {
 	code: 'session_not_found';
@@ -319,6 +362,15 @@ export interface CacheRefreshFailedError {
 	causeCode?: string;
 }
 
+export interface BackendCapabilityUnavailableError {
+	code: 'capability_unavailable';
+	message: string;
+	capability: 'fileSystem' | 'artifact.publish' | 'artifact.restore';
+	requiredAdapter?: 'BackendFileSystem';
+	requiredHost?: 'node';
+	bridgeBoundary?: 'external-bridge';
+}
+
 export type BackendJobErrors =
 	| BackendJobNotFoundError
 	| BackendJobNotCancellableError
@@ -366,6 +418,7 @@ export type BackendError =
 	| BackendJobNotCancellableError
 	| BackendJobCancelledError
 	| CacheRefreshFailedError
+	| BackendCapabilityUnavailableError
 	| ApplyUamTransactionAppError;
 
 export interface ApplySessionTransactionInput {
@@ -374,13 +427,22 @@ export interface ApplySessionTransactionInput {
 	operations: UamTransactionOperation[];
 }
 
+export interface OpenProjectSessionInput {
+	project: UamProject;
+	sessionId?: string;
+	canonicalProjectPath?: string;
+	canonicalPathKey?: string;
+}
+
 export interface BackendRuntimeOptions {
 	fileSystem?: BackendFileSystem;
+	host?: BackendHostAdapter;
 }
 
 const BACKEND_METHODS = [
 	'getCapabilities',
 	'openSession',
+	'openProjectSession',
 	'getSession',
 	'applyTransaction',
 	'saveSession',
@@ -393,6 +455,14 @@ const BACKEND_METHODS = [
 	'refreshCache',
 ] as const;
 
+const ARTIFACT_BRIDGE_CAPABILITY = {
+	available: false,
+	requiredHost: 'node',
+	executionBoundary: 'external-bridge',
+	bridgeEntrypoint: '@openfairygui/backend/node',
+	reason: 'publish/restore require explicit Node-hosted filesystem and artifact execution.',
+} as const satisfies BackendArtifactBridgeCapability;
+
 function createCapabilities(): BackendCapabilities {
 	return {
 		contractVersion: BACKEND_CONTRACT_VERSION,
@@ -414,6 +484,31 @@ function createCapabilities(): BackendCapabilities {
 			unsupported: ['artifact.publish', 'artifact.restore'],
 		},
 		artifact: createArtifactCapabilities(),
+		manifest: {
+			browserSafe: true,
+			rootEntrypoint: '@openfairygui/backend',
+			nodeEntrypoint: '@openfairygui/backend/node',
+			adapters: {
+				fileSystem: {
+					injected: true,
+					requiredFor: ['openSession', 'saveSession'],
+				},
+				host: {
+					injected: true,
+					requiredFor: ['advisoryLockMetadata'],
+				},
+			},
+			executionBoundaries: {
+				projectSession: 'in-process-browser-safe',
+				fileBackedSession: 'adapter-backed',
+				artifactPublish: ARTIFACT_BRIDGE_CAPABILITY,
+				artifactRestore: ARTIFACT_BRIDGE_CAPABILITY,
+			},
+			diagnostics: {
+				stableCodes: true,
+				errorDiagnosticMirror: true,
+			},
+		},
 		compatibilityPolicy: BACKEND_COMPATIBILITY_POLICY,
 		runtime: {
 			sessionRuntime: true,
@@ -446,65 +541,8 @@ function createCapabilities(): BackendCapabilities {
 	};
 }
 
-export function createNodeBackendFileSystem(): BackendFileSystem {
-	return {
-		stat(filePath: string): Promise<Stats> {
-			return fs.stat(filePath);
-		},
-		readdir(dirPath: string): Promise<string[]> {
-			return fs.readdir(dirPath);
-		},
-		readFile(filePath: string): Promise<string> {
-			return fs.readFile(filePath, 'utf-8');
-		},
-		async readFileRaw(filePath: string): Promise<Uint8Array> {
-			const buffer = await fs.readFile(filePath);
-			return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-		},
-		writeFile(filePath: string, content: string): Promise<void> {
-			return fs.writeFile(filePath, content, 'utf-8');
-		},
-		writeFileRaw(filePath: string, data: Uint8Array): Promise<void> {
-			return fs.writeFile(filePath, data);
-		},
-		async mkdir(dirPath: string, options?: { recursive?: boolean }): Promise<void> {
-			await fs.mkdir(dirPath, { recursive: options?.recursive ?? false });
-		},
-		async resolvePath(filePath: string): Promise<string> {
-			try {
-				return await fs.realpath(filePath);
-			} catch {
-				return path.resolve(filePath);
-			}
-		},
-		async openExclusive(filePath: string): Promise<BackendFileHandle> {
-			const handle = await fs.open(filePath, 'wx');
-			return {
-				writeFile(content: string): Promise<void> {
-					return handle.writeFile(content, 'utf-8');
-				},
-				close(): Promise<void> {
-					return handle.close();
-				},
-			};
-		},
-		unlink(filePath: string): Promise<void> {
-			return fs.unlink(filePath);
-		},
-		join(...paths: string[]): string {
-			return path.join(...paths);
-		},
-		dirname(filePath: string): string {
-			return path.dirname(filePath);
-		},
-		resolve(...paths: string[]): string {
-			return path.resolve(...paths);
-		},
-	};
-}
-
 export class BackendRuntime {
-	private readonly fileSystem: BackendFileSystem;
+	private readonly fileSystem?: BackendFileSystem;
 	private readonly capabilities: BackendCapabilities;
 	private readonly sessions = new Map<string, BackendSessionState>();
 	private readonly sessionsByPath = new Map<string, string>();
@@ -521,10 +559,11 @@ export class BackendRuntime {
 	private readonly jobService: JobService;
 
 	public constructor(options: BackendRuntimeOptions = {}) {
-		this.fileSystem = options.fileSystem ?? createNodeBackendFileSystem();
+		this.fileSystem = options.fileSystem;
 		this.capabilities = createCapabilities();
 		this.context = {
 			fileSystem: this.fileSystem,
+			host: options.host,
 			capabilities: this.capabilities,
 			sessions: this.sessions,
 			sessionsByPath: this.sessionsByPath,
@@ -548,37 +587,68 @@ export class BackendRuntime {
 		return this.readService.getCapabilities() as BackendSuccess<BackendCapabilities>;
 	}
 
-	public async openSession(input: { projectPath: string }): Promise<BackendResult<BackendSessionSnapshot, InProcessLockConflictError | AdvisoryLockConflictError>> {
+	public async openSession(input: {
+		projectPath: string;
+	}): Promise<
+		BackendResult<
+			BackendSessionSnapshot,
+			InProcessLockConflictError | AdvisoryLockConflictError | BackendCapabilityUnavailableError
+		>
+	> {
 		return this.runtimeService.openSession(input);
 	}
 
+	public openProjectSession(input: OpenProjectSessionInput): BackendResult<BackendSessionSnapshot> {
+		return this.runtimeService.openProjectSession(input);
+	}
+
 	public getSession(input: { sessionId: string }): BackendResult<BackendSessionSnapshot, SessionNotFoundError> {
 		return this.readService.getSession(input);
 	}
 
 	public async applyTransaction(
 		input: ApplySessionTransactionInput,
-	): Promise<BackendResult<BackendSessionSnapshot, SessionNotFoundError | SessionStaleWriteError | ApplyUamTransactionAppError>> {
+	): Promise<
+		BackendResult<
+			BackendSessionSnapshot,
+			SessionNotFoundError | SessionStaleWriteError | ApplyUamTransactionAppError
+		>
+	> {
 		return this.authoringService.applyTransaction(input);
 	}
 
-	public async saveSession(
-		input: { sessionId: string; expectedRevision?: number; targetPath?: string },
-	): Promise<BackendResult<BackendSessionSnapshot, SessionNotFoundError | SessionStaleWriteError | SavePartialFailureError | PathPolicyViolationError>> {
+	public async saveSession(input: {
+		sessionId: string;
+		expectedRevision?: number;
+		targetPath?: string;
+	}): Promise<
+		BackendResult<
+			BackendSessionSnapshot,
+			| SessionNotFoundError
+			| SessionStaleWriteError
+			| SavePartialFailureError
+			| PathPolicyViolationError
+			| BackendCapabilityUnavailableError
+		>
+	> {
 		return this.authoringService.saveSession(input);
 	}
 
-	public async closeSession(
-		input: { sessionId: string },
-	): Promise<BackendResult<{ sessionId: string; closed: true }, SessionNotFoundError>> {
+	public async closeSession(input: {
+		sessionId: string;
+	}): Promise<BackendResult<{ sessionId: string; closed: true }, SessionNotFoundError>> {
 		return this.runtimeService.closeSession(input);
 	}
 
-	public getEvents(input: GetEventsInput): BackendResult<GetEventsSnapshot, SessionNotFoundError | EventCursorInvalidError> {
+	public getEvents(
+		input: GetEventsInput,
+	): BackendResult<GetEventsSnapshot, SessionNotFoundError | EventCursorInvalidError> {
 		return this.eventService.getEvents(input);
 	}
 
-	public getJob(input: GetJobInput): BackendResult<BackendJobSnapshot, SessionNotFoundError | BackendJobNotFoundError> {
+	public getJob(
+		input: GetJobInput,
+	): BackendResult<BackendJobSnapshot, SessionNotFoundError | BackendJobNotFoundError> {
 		return this.jobService.getJob(input);
 	}
 
@@ -586,7 +656,12 @@ export class BackendRuntime {
 		return this.jobService.listJobs(input);
 	}
 
-	public cancelJob(input: CancelJobInput): BackendResult<BackendJobSnapshot, SessionNotFoundError | BackendJobNotFoundError | BackendJobNotCancellableError> {
+	public cancelJob(
+		input: CancelJobInput,
+	): BackendResult<
+		BackendJobSnapshot,
+		SessionNotFoundError | BackendJobNotFoundError | BackendJobNotCancellableError
+	> {
 		return this.jobService.cancelJob(input);
 	}
 

package/src/services/artifact-service.ts

@@ -1,9 +1,19 @@
 import type { BackendCapabilities } from '../runtime.js';
 
 export function createArtifactCapabilities(): BackendCapabilities['artifact'] {
+	const bridge = {
+		available: false,
+		requiredHost: 'node',
+		executionBoundary: 'external-bridge',
+		bridgeEntrypoint: '@openfairygui/backend/node',
+		reason: 'publish/restore require explicit Node-hosted filesystem and artifact execution.',
+	} as const;
+
 	return {
 		publish: false,
 		restore: false,
-		status: 'deferred',
+		status: 'bridge-required',
+		publishBridge: bridge,
+		restoreBridge: bridge,
 	};
 }

package/src/services/authoring-service.ts

@@ -1,10 +1,12 @@
-import { materializeUamProject, ProjectWriter } from '@openfairygui/core';
-import { applyUamTransactionApp, type ApplyUamTransactionAppError } from '@openfairygui/functions';
+import { ProjectWriter, type FileSystem } from '@openfairygui/core/project-io';
+import { materializeUamProject } 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 {
 	ApplySessionTransactionInput,
+	BackendCapabilityUnavailableError,
 	BackendFileSystem,
 	BackendResult,
 	BackendSessionSnapshot,
@@ -19,7 +21,7 @@ function createWriterFileSystem(
 	fileSystem: BackendFileSystem,
 	committedPaths: string[],
 	failedPaths: string[],
-): import('@openfairygui/core').FileSystem {
+): FileSystem {
 	async function trackWrite<T>(targetPath: string, fn: () => Promise<T>): Promise<T> {
 		try {
 			const result = await fn();
@@ -82,18 +84,34 @@ export class AuthoringService {
 
 	public async applyTransaction(
 		input: ApplySessionTransactionInput,
-	): Promise<BackendResult<BackendSessionSnapshot, SessionNotFoundError | SessionStaleWriteError | ApplyUamTransactionAppError>> {
+	): Promise<
+		BackendResult<
+			BackendSessionSnapshot,
+			SessionNotFoundError | SessionStaleWriteError | ApplyUamTransactionAppError
+		>
+	> {
 		const startedAt = Date.now();
 		const session = this.context.sessions.get(input.sessionId);
 		if (!session || session.closed) {
 			return failure('authoring', startedAt, createSessionNotFoundError(input.sessionId));
 		}
 		if (input.expectedRevision !== session.revision) {
-			this.eventService.emit({ kind: 'transaction.rejected', sessionId: session.sessionId, canonicalPathKey: session.canonicalPathKey, revision: session.revision });
-			return failure('authoring', startedAt, createStaleWriteError(session, input.expectedRevision), toSessionSnapshot(session, this.context.capabilities), {
+			this.eventService.emit({
+				kind: 'transaction.rejected',
 				sessionId: session.sessionId,
+				canonicalPathKey: session.canonicalPathKey,
 				revision: session.revision,
 			});
+			return failure(
+				'authoring',
+				startedAt,
+				createStaleWriteError(session, input.expectedRevision),
+				toSessionSnapshot(session, this.context.capabilities),
+				{
+					sessionId: session.sessionId,
+					revision: session.revision,
+				},
+			);
 		}
 
 		const result = applyUamTransactionApp({
@@ -101,19 +119,47 @@ export class AuthoringService {
 			operations: input.operations,
 		});
 		if (result.ok === false) {
-			this.eventService.emit({ kind: 'transaction.rejected', sessionId: session.sessionId, canonicalPathKey: session.canonicalPathKey, revision: session.revision, diagnostics: result.error.issues?.map((issue) => ({ code: result.error.code, message: issue.message, severity: 'error' as const })) ?? [] });
-			return failure('authoring', startedAt, result.error, toSessionSnapshot(session, this.context.capabilities), {
+			this.eventService.emit({
+				kind: 'transaction.rejected',
 				sessionId: session.sessionId,
+				canonicalPathKey: session.canonicalPathKey,
 				revision: session.revision,
+				diagnostics:
+					result.error.issues?.map((issue) => ({
+						code: result.error.code,
+						message: issue.message,
+						severity: 'error' as const,
+					})) ?? [],
 			});
+			return failure(
+				'authoring',
+				startedAt,
+				result.error,
+				toSessionSnapshot(session, this.context.capabilities),
+				{
+					sessionId: session.sessionId,
+					revision: session.revision,
+				},
+			);
 		}
 
 		session.project = result.project;
 		session.revision += 1;
 		session.dirty = true;
 		const cacheEntry = this.cacheService.invalidateSession(session);
-		this.eventService.emit({ kind: 'transaction.applied', sessionId: session.sessionId, canonicalPathKey: session.canonicalPathKey, revision: session.revision });
-		this.eventService.emit({ kind: 'cache.invalidated', sessionId: session.sessionId, canonicalPathKey: session.canonicalPathKey, revision: session.revision, cacheRevision: cacheEntry.revision });
+		this.eventService.emit({
+			kind: 'transaction.applied',
+			sessionId: session.sessionId,
+			canonicalPathKey: session.canonicalPathKey,
+			revision: session.revision,
+		});
+		this.eventService.emit({
+			kind: 'cache.invalidated',
+			sessionId: session.sessionId,
+			canonicalPathKey: session.canonicalPathKey,
+			revision: session.revision,
+			cacheRevision: cacheEntry.revision,
+		});
 
 		return success('authoring', startedAt, toSessionSnapshot(session, this.context.capabilities), {
 			sessionId: session.sessionId,
@@ -121,26 +167,67 @@ export class AuthoringService {
 		});
 	}
 
-	public async saveSession(
-		input: { sessionId: string; expectedRevision?: number; targetPath?: string },
-	): Promise<BackendResult<BackendSessionSnapshot, SessionNotFoundError | SessionStaleWriteError | SavePartialFailureError | PathPolicyViolationError>> {
+	public async saveSession(input: {
+		sessionId: string;
+		expectedRevision?: number;
+		targetPath?: string;
+	}): Promise<
+		BackendResult<
+			BackendSessionSnapshot,
+			| SessionNotFoundError
+			| SessionStaleWriteError
+			| SavePartialFailureError
+			| PathPolicyViolationError
+			| BackendCapabilityUnavailableError
+		>
+	> {
 		const startedAt = Date.now();
 		const session = this.context.sessions.get(input.sessionId);
 		if (!session || session.closed) {
 			return failure('authoring', startedAt, createSessionNotFoundError(input.sessionId));
 		}
+		if (!this.context.fileSystem) {
+			return failure(
+				'authoring',
+				startedAt,
+				{
+					code: 'capability_unavailable',
+					message: 'saveSession requires an injected BackendFileSystem adapter.',
+					capability: 'fileSystem',
+					requiredAdapter: 'BackendFileSystem',
+				},
+				toSessionSnapshot(session, this.context.capabilities),
+				{
+					sessionId: session.sessionId,
+					revision: session.revision,
+				},
+			);
+		}
 		if (input.expectedRevision !== undefined && input.expectedRevision !== session.revision) {
-			return failure('authoring', startedAt, createStaleWriteError(session, input.expectedRevision), toSessionSnapshot(session, this.context.capabilities), {
-				sessionId: session.sessionId,
-				revision: session.revision,
-			});
+			return failure(
+				'authoring',
+				startedAt,
+				createStaleWriteError(session, input.expectedRevision),
+				toSessionSnapshot(session, this.context.capabilities),
+				{
+					sessionId: session.sessionId,
+					revision: session.revision,
+				},
+			);
 		}
-		const targetViolation = await validateSaveTarget(this.context.fileSystem, session.fairyPath, input.targetPath);
+		const fileSystem = this.context.fileSystem;
+		const targetViolation = await validateSaveTarget(fileSystem, session.fairyPath, input.targetPath);
 		if (targetViolation) {
-			return failure('authoring', startedAt, targetViolation, toSessionSnapshot(session, this.context.capabilities), {
-				sessionId: session.sessionId,
-				revision: session.revision,
-			});
+			return failure(
+				'authoring',
+				startedAt,
+				targetViolation,
+				toSessionSnapshot(session, this.context.capabilities),
+				{
+					sessionId: session.sessionId,
+					revision: session.revision,
+				},
+			);
 		}
 		if (!session.dirty) {
 			return success('authoring', startedAt, toSessionSnapshot(session, this.context.capabilities), {
@@ -151,36 +238,63 @@ export class AuthoringService {
 
 		const committedPaths: string[] = [];
 		const failedPaths: string[] = [];
-		this.eventService.emit({ kind: 'save.started', sessionId: session.sessionId, canonicalPathKey: session.canonicalPathKey, revision: session.revision });
+		this.eventService.emit({
+			kind: 'save.started',
+			sessionId: session.sessionId,
+			canonicalPathKey: session.canonicalPathKey,
+			revision: session.revision,
+		});
 		try {
-			const writer = new ProjectWriter(createWriterFileSystem(this.context.fileSystem, committedPaths, failedPaths));
+			const writer = new ProjectWriter(createWriterFileSystem(fileSystem, committedPaths, failedPaths));
 			await writer.write(materializeUamProject(session.project), session.fairyPath);
 			session.lastSavedRevision = session.revision;
 			session.dirty = false;
 			const cacheEntry = this.cacheService.refreshSession(session);
-			this.eventService.emit({ kind: 'save.completed', sessionId: session.sessionId, canonicalPathKey: session.canonicalPathKey, revision: session.revision });
-			this.eventService.emit({ kind: 'cache.updated', sessionId: session.sessionId, canonicalPathKey: session.canonicalPathKey, revision: session.revision, cacheRevision: cacheEntry.revision });
+			this.eventService.emit({
+				kind: 'save.completed',
+				sessionId: session.sessionId,
+				canonicalPathKey: session.canonicalPathKey,
+				revision: session.revision,
+			});
+			this.eventService.emit({
+				kind: 'cache.updated',
+				sessionId: session.sessionId,
+				canonicalPathKey: session.canonicalPathKey,
+				revision: session.revision,
+				cacheRevision: cacheEntry.revision,
+			});
 			return success('authoring', startedAt, toSessionSnapshot(session, this.context.capabilities), {
 				sessionId: session.sessionId,
 				revision: session.revision,
 			});
 		} catch (error) {
 			this.cacheService.invalidateSession(session);
-			this.eventService.emit({ kind: 'save.failed', sessionId: session.sessionId, canonicalPathKey: session.canonicalPathKey, revision: session.revision });
-			return failure('authoring', startedAt, {
-				code: 'save_partial_failure',
-				message: error instanceof Error ? error.message : String(error),
+			this.eventService.emit({
+				kind: 'save.failed',
 				sessionId: session.sessionId,
 				canonicalPathKey: session.canonicalPathKey,
-				attemptedRevision: session.revision,
-				lastSavedRevision: session.lastSavedRevision,
-				committedPaths,
-				failedPaths,
-				diskMayBePartiallyUpdated: true,
-			}, toSessionSnapshot(session, this.context.capabilities), {
-				sessionId: session.sessionId,
 				revision: session.revision,
 			});
+			return failure(
+				'authoring',
+				startedAt,
+				{
+					code: 'save_partial_failure',
+					message: error instanceof Error ? error.message : String(error),
+					sessionId: session.sessionId,
+					canonicalPathKey: session.canonicalPathKey,
+					attemptedRevision: session.revision,
+					lastSavedRevision: session.lastSavedRevision,
+					committedPaths,
+					failedPaths,
+					diskMayBePartiallyUpdated: true,
+				},
+				toSessionSnapshot(session, this.context.capabilities),
+				{
+					sessionId: session.sessionId,
+					revision: session.revision,
+				},
+			);
 		}
 	}
 }