@openfairygui/backend 0.2.0-alpha.1 → 0.2.0-alpha.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenFairyGUI Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_runtime = require("./runtime-BXbt135W.cjs");
+const require_runtime = require("./runtime-jKuQmcqM.cjs");
 exports.BACKEND_CAPABILITY_SCHEMA_VERSION = require_runtime.BACKEND_CAPABILITY_SCHEMA_VERSION;
 exports.BACKEND_COMPATIBILITY_POLICY = require_runtime.BACKEND_COMPATIBILITY_POLICY;
 exports.BACKEND_CONTRACT_VERSION = require_runtime.BACKEND_CONTRACT_VERSION;

package/dist/index.d.cts

@@ -1,2 +1,2 @@
-import { A as BackendSuccess, B as OpenProjectSessionInput, C as BackendJobProgress, D as BackendRuntime, E as BackendResult, F as GetEventsInput, G as BACKEND_CAPABILITY_SCHEMA_VERSION, H as SavePartialFailureError, I as GetEventsSnapshot, J as BackendDiagnostic, K as BACKEND_COMPATIBILITY_POLICY, L as GetJobInput, M as CancelJobInput, N as EventCursorInvalidError, O as BackendRuntimeOptions, P as GetCacheSnapshotInput, R as InProcessLockConflictError, S as BackendJobNotFoundError, T as BackendJobStatus, U as SessionNotFoundError, V as RefreshCacheInput, W as SessionStaleWriteError, X as BackendResponseMeta, Y as BackendMessage, Z as BackendStage, _ as BackendJobErrors, a as BackendCacheSnapshot, b as BackendJobListStatusFilter, c as BackendCapabilityUnavailableError, d as BackendEventKind, f as BackendFailure, g as BackendHostAdapter, h as BackendFileSystem, i as BackendCacheEntry, j as CacheRefreshFailedError, k as BackendSessionSnapshot, l as BackendError, m as BackendFileStat, n as ApplySessionTransactionInput, o as BackendCapabilities, p as BackendFileHandle, q as BACKEND_CONTRACT_VERSION, r as BackendArtifactBridgeCapability, s as BackendCapabilityManifest, t as AdvisoryLockConflictError, u as BackendEvent, v as BackendJobKind, w as BackendJobSnapshot, x as BackendJobNotCancellableError, y as BackendJobListSnapshot, z as ListJobsInput } from "./runtime-C5JY_kRI.cjs";
+import { A as BackendSuccess, B as OpenProjectSessionInput, C as BackendJobProgress, D as BackendRuntime, E as BackendResult, F as GetEventsInput, G as BACKEND_CAPABILITY_SCHEMA_VERSION, H as SavePartialFailureError, I as GetEventsSnapshot, J as BackendDiagnostic, K as BACKEND_COMPATIBILITY_POLICY, L as GetJobInput, M as CancelJobInput, N as EventCursorInvalidError, O as BackendRuntimeOptions, P as GetCacheSnapshotInput, R as InProcessLockConflictError, S as BackendJobNotFoundError, T as BackendJobStatus, U as SessionNotFoundError, V as RefreshCacheInput, W as SessionStaleWriteError, X as BackendResponseMeta, Y as BackendMessage, Z as BackendStage, _ as BackendJobErrors, a as BackendCacheSnapshot, b as BackendJobListStatusFilter, c as BackendCapabilityUnavailableError, d as BackendEventKind, f as BackendFailure, g as BackendHostAdapter, h as BackendFileSystem, i as BackendCacheEntry, j as CacheRefreshFailedError, k as BackendSessionSnapshot, l as BackendError, m as BackendFileStat, n as ApplySessionTransactionInput, o as BackendCapabilities, p as BackendFileHandle, q as BACKEND_CONTRACT_VERSION, r as BackendArtifactBridgeCapability, s as BackendCapabilityManifest, t as AdvisoryLockConflictError, u as BackendEvent, v as BackendJobKind, w as BackendJobSnapshot, x as BackendJobNotCancellableError, y as BackendJobListSnapshot, z as ListJobsInput } from "./runtime-IrXqqmko.cjs";
 export { type AdvisoryLockConflictError, type ApplySessionTransactionInput, BACKEND_CAPABILITY_SCHEMA_VERSION, BACKEND_COMPATIBILITY_POLICY, BACKEND_CONTRACT_VERSION, type BackendArtifactBridgeCapability, type BackendCacheEntry, type BackendCacheSnapshot, type BackendCapabilities, type BackendCapabilityManifest, type BackendCapabilityUnavailableError, type BackendDiagnostic, type BackendError, type BackendEvent, type BackendEventKind, type BackendFailure, type BackendFileHandle, type BackendFileStat, type BackendFileSystem, type BackendHostAdapter, type BackendJobErrors, type BackendJobKind, type BackendJobListSnapshot, type BackendJobListStatusFilter, type BackendJobNotCancellableError, type BackendJobNotFoundError, type BackendJobProgress, type BackendJobSnapshot, type BackendJobStatus, type BackendMessage, type BackendResponseMeta, type BackendResult, BackendRuntime, type BackendRuntimeOptions, type BackendSessionSnapshot, type BackendStage, type BackendSuccess, type CacheRefreshFailedError, type CancelJobInput, type EventCursorInvalidError, type GetCacheSnapshotInput, type GetEventsInput, type GetEventsSnapshot, type GetJobInput, type InProcessLockConflictError, type ListJobsInput, type OpenProjectSessionInput, type RefreshCacheInput, type SavePartialFailureError, type SessionNotFoundError, type SessionStaleWriteError };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { A as BackendSuccess, B as OpenProjectSessionInput, C as BackendJobProgress, D as BackendRuntime, E as BackendResult, F as GetEventsInput, G as BACKEND_CAPABILITY_SCHEMA_VERSION, H as SavePartialFailureError, I as GetEventsSnapshot, J as BackendDiagnostic, K as BACKEND_COMPATIBILITY_POLICY, L as GetJobInput, M as CancelJobInput, N as EventCursorInvalidError, O as BackendRuntimeOptions, P as GetCacheSnapshotInput, R as InProcessLockConflictError, S as BackendJobNotFoundError, T as BackendJobStatus, U as SessionNotFoundError, V as RefreshCacheInput, W as SessionStaleWriteError, X as BackendResponseMeta, Y as BackendMessage, Z as BackendStage, _ as BackendJobErrors, a as BackendCacheSnapshot, b as BackendJobListStatusFilter, c as BackendCapabilityUnavailableError, d as BackendEventKind, f as BackendFailure, g as BackendHostAdapter, h as BackendFileSystem, i as BackendCacheEntry, j as CacheRefreshFailedError, k as BackendSessionSnapshot, l as BackendError, m as BackendFileStat, n as ApplySessionTransactionInput, o as BackendCapabilities, p as BackendFileHandle, q as BACKEND_CONTRACT_VERSION, r as BackendArtifactBridgeCapability, s as BackendCapabilityManifest, t as AdvisoryLockConflictError, u as BackendEvent, v as BackendJobKind, w as BackendJobSnapshot, x as BackendJobNotCancellableError, y as BackendJobListSnapshot, z as ListJobsInput } from "./runtime-C5ZsWMnH.mjs";
+import { A as BackendSuccess, B as OpenProjectSessionInput, C as BackendJobProgress, D as BackendRuntime, E as BackendResult, F as GetEventsInput, G as BACKEND_CAPABILITY_SCHEMA_VERSION, H as SavePartialFailureError, I as GetEventsSnapshot, J as BackendDiagnostic, K as BACKEND_COMPATIBILITY_POLICY, L as GetJobInput, M as CancelJobInput, N as EventCursorInvalidError, O as BackendRuntimeOptions, P as GetCacheSnapshotInput, R as InProcessLockConflictError, S as BackendJobNotFoundError, T as BackendJobStatus, U as SessionNotFoundError, V as RefreshCacheInput, W as SessionStaleWriteError, X as BackendResponseMeta, Y as BackendMessage, Z as BackendStage, _ as BackendJobErrors, a as BackendCacheSnapshot, b as BackendJobListStatusFilter, c as BackendCapabilityUnavailableError, d as BackendEventKind, f as BackendFailure, g as BackendHostAdapter, h as BackendFileSystem, i as BackendCacheEntry, j as CacheRefreshFailedError, k as BackendSessionSnapshot, l as BackendError, m as BackendFileStat, n as ApplySessionTransactionInput, o as BackendCapabilities, p as BackendFileHandle, q as BACKEND_CONTRACT_VERSION, r as BackendArtifactBridgeCapability, s as BackendCapabilityManifest, t as AdvisoryLockConflictError, u as BackendEvent, v as BackendJobKind, w as BackendJobSnapshot, x as BackendJobNotCancellableError, y as BackendJobListSnapshot, z as ListJobsInput } from "./runtime-u1Bq_ysz.mjs";
 export { type AdvisoryLockConflictError, type ApplySessionTransactionInput, BACKEND_CAPABILITY_SCHEMA_VERSION, BACKEND_COMPATIBILITY_POLICY, BACKEND_CONTRACT_VERSION, type BackendArtifactBridgeCapability, type BackendCacheEntry, type BackendCacheSnapshot, type BackendCapabilities, type BackendCapabilityManifest, type BackendCapabilityUnavailableError, type BackendDiagnostic, type BackendError, type BackendEvent, type BackendEventKind, type BackendFailure, type BackendFileHandle, type BackendFileStat, type BackendFileSystem, type BackendHostAdapter, type BackendJobErrors, type BackendJobKind, type BackendJobListSnapshot, type BackendJobListStatusFilter, type BackendJobNotCancellableError, type BackendJobNotFoundError, type BackendJobProgress, type BackendJobSnapshot, type BackendJobStatus, type BackendMessage, type BackendResponseMeta, type BackendResult, BackendRuntime, type BackendRuntimeOptions, type BackendSessionSnapshot, type BackendStage, type BackendSuccess, type CacheRefreshFailedError, type CancelJobInput, type EventCursorInvalidError, type GetCacheSnapshotInput, type GetEventsInput, type GetEventsSnapshot, type GetJobInput, type InProcessLockConflictError, type ListJobsInput, type OpenProjectSessionInput, type RefreshCacheInput, type SavePartialFailureError, type SessionNotFoundError, type SessionStaleWriteError };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { i as BACKEND_CONTRACT_VERSION, n as BACKEND_CAPABILITY_SCHEMA_VERSION, r as BACKEND_COMPATIBILITY_POLICY, t as BackendRuntime } from "./runtime-DLWLghmH.mjs";
+import { i as BACKEND_CONTRACT_VERSION, n as BACKEND_CAPABILITY_SCHEMA_VERSION, r as BACKEND_COMPATIBILITY_POLICY, t as BackendRuntime } from "./runtime-BG5qOVkJ.mjs";
 export { BACKEND_CAPABILITY_SCHEMA_VERSION, BACKEND_COMPATIBILITY_POLICY, BACKEND_CONTRACT_VERSION, BackendRuntime };

package/dist/node.cjs

@@ -21,7 +21,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-const require_runtime = require("./runtime-BXbt135W.cjs");
+const require_runtime = require("./runtime-jKuQmcqM.cjs");
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = __toESM(node_fs_promises);
 let node_path = require("node:path");

package/dist/node.d.cts

@@ -1,4 +1,4 @@
-import { D as BackendRuntime, O as BackendRuntimeOptions, g as BackendHostAdapter, h as BackendFileSystem, m as BackendFileStat, p as BackendFileHandle } from "./runtime-C5JY_kRI.cjs";
+import { D as BackendRuntime, O as BackendRuntimeOptions, g as BackendHostAdapter, h as BackendFileSystem, m as BackendFileStat, p as BackendFileHandle } from "./runtime-IrXqqmko.cjs";
 
 //#region src/node.d.ts
 declare function createNodeBackendFileSystem(): BackendFileSystem;

package/dist/node.d.mts

@@ -1,4 +1,4 @@
-import { D as BackendRuntime, O as BackendRuntimeOptions, g as BackendHostAdapter, h as BackendFileSystem, m as BackendFileStat, p as BackendFileHandle } from "./runtime-C5ZsWMnH.mjs";
+import { D as BackendRuntime, O as BackendRuntimeOptions, g as BackendHostAdapter, h as BackendFileSystem, m as BackendFileStat, p as BackendFileHandle } from "./runtime-u1Bq_ysz.mjs";
 
 //#region src/node.d.ts
 declare function createNodeBackendFileSystem(): BackendFileSystem;

package/dist/node.mjs

@@ -1,4 +1,4 @@
-import { t as BackendRuntime } from "./runtime-DLWLghmH.mjs";
+import { t as BackendRuntime } from "./runtime-BG5qOVkJ.mjs";
 import fs from "node:fs/promises";
 import path from "node:path";
 //#region src/node.ts

package/dist/{runtime-DLWLghmH.mjs → runtime-BG5qOVkJ.mjs}

@@ -1,5 +1,6 @@
-import { ProjectReader, ProjectWriter, UAM_SUPPORTED_MATERIALIZATION_SCOPE, liftDocumentToUamProject, materializeUamProject, normalizeUamProject } from "@openfairygui/core";
-import { applyUamTransactionApp } from "@openfairygui/functions";
+import { UAM_SUPPORTED_MATERIALIZATION_SCOPE, UAM_SUPPORTED_TRANSACTION_SCOPE, liftDocumentToUamProject, materializeUamProject, normalizeUamProject } from "@openfairygui/core/uam";
+import { ProjectReader, ProjectWriter } from "@openfairygui/core/project-io";
+import { applyUamTransactionApp } from "@openfairygui/functions/uam";
 //#region src/contracts.ts
 const BACKEND_CONTRACT_VERSION = "1.1.0-p2";
 const BACKEND_CAPABILITY_SCHEMA_VERSION = 2;
@@ -1049,6 +1050,11 @@ function createCapabilities() {
 			resourceKinds: [...UAM_SUPPORTED_MATERIALIZATION_SCOPE.resourceKinds],
 			nodeKinds: [...UAM_SUPPORTED_MATERIALIZATION_SCOPE.nodeKinds],
 			gearKinds: [...UAM_SUPPORTED_MATERIALIZATION_SCOPE.gearKinds],
+			transactionScope: {
+				resourceKinds: [...UAM_SUPPORTED_TRANSACTION_SCOPE.resourceKinds],
+				nodeKinds: [...UAM_SUPPORTED_TRANSACTION_SCOPE.nodeKinds],
+				gearKinds: [...UAM_SUPPORTED_TRANSACTION_SCOPE.gearKinds]
+			},
 			unsupported: ["artifact.publish", "artifact.restore"]
 		},
 		artifact: createArtifactCapabilities(),

package/dist/{runtime-C5JY_kRI.d.cts → runtime-IrXqqmko.d.cts}

@@ -1,5 +1,5 @@
-import { UamProject, UamTransactionOperation } from "@openfairygui/core";
-import { ApplyUamTransactionAppError } from "@openfairygui/functions";
+import { UamProject, UamTransactionOperation } from "@openfairygui/core/uam";
+import { ApplyUamTransactionAppError } from "@openfairygui/functions/uam";
 
 //#region src/contracts.d.ts
 declare const BACKEND_CONTRACT_VERSION: "1.1.0-p2";
@@ -122,6 +122,11 @@ interface BackendCapabilities {
     resourceKinds: readonly string[];
     nodeKinds: readonly string[];
     gearKinds: readonly string[];
+    transactionScope: {
+      resourceKinds: readonly string[];
+      nodeKinds: readonly string[];
+      gearKinds: readonly string[];
+    };
     unsupported: readonly ['artifact.publish', 'artifact.restore'];
   };
   artifact: {

package/dist/{runtime-BXbt135W.cjs → runtime-jKuQmcqM.cjs}

@@ -1,6 +1,7 @@
 require("./node.cjs");
-let _openfairygui_core = require("@openfairygui/core");
-let _openfairygui_functions = require("@openfairygui/functions");
+let _openfairygui_core_uam = require("@openfairygui/core/uam");
+let _openfairygui_core_project_io = require("@openfairygui/core/project-io");
+let _openfairygui_functions_uam = require("@openfairygui/functions/uam");
 //#region src/contracts.ts
 const BACKEND_CONTRACT_VERSION = "1.1.0-p2";
 const BACKEND_CAPABILITY_SCHEMA_VERSION = 2;
@@ -276,7 +277,7 @@ var AuthoringService = class {
 				revision: session.revision
 			});
 		}
-		const result = (0, _openfairygui_functions.applyUamTransactionApp)({
+		const result = (0, _openfairygui_functions_uam.applyUamTransactionApp)({
 			project: session.project,
 			operations: input.operations
 		});
@@ -355,7 +356,7 @@ var AuthoringService = class {
 			revision: session.revision
 		});
 		try {
-			await new _openfairygui_core.ProjectWriter(createWriterFileSystem(fileSystem, committedPaths, failedPaths)).write((0, _openfairygui_core.materializeUamProject)(session.project), session.fairyPath);
+			await new _openfairygui_core_project_io.ProjectWriter(createWriterFileSystem(fileSystem, committedPaths, failedPaths)).write((0, _openfairygui_core_uam.materializeUamProject)(session.project), session.fairyPath);
 			session.lastSavedRevision = session.revision;
 			session.dirty = false;
 			const cacheEntry = this.cacheService.refreshSession(session);
@@ -892,7 +893,7 @@ var RuntimeService = class {
 				canonicalPathKey
 			}));
 			await advisoryLock.close();
-			const project = (0, _openfairygui_core.liftDocumentToUamProject)(await new _openfairygui_core.ProjectReader(createProjectReaderFileSystem(fileSystem)).read(fairyPath));
+			const project = (0, _openfairygui_core_uam.liftDocumentToUamProject)(await new _openfairygui_core_project_io.ProjectReader(createProjectReaderFileSystem(fileSystem)).read(fairyPath));
 			const sessionId = randomId();
 			const session = {
 				sessionId,
@@ -954,7 +955,7 @@ var RuntimeService = class {
 			canonicalProjectPath,
 			canonicalPathKey,
 			lockFilePath: "",
-			project: (0, _openfairygui_core.normalizeUamProject)(input.project),
+			project: (0, _openfairygui_core_uam.normalizeUamProject)(input.project),
 			revision: 0,
 			lastSavedRevision: 0,
 			dirty: false,
@@ -1047,9 +1048,14 @@ function createCapabilities() {
 		authoring: {
 			applyTransaction: true,
 			saveSession: true,
-			resourceKinds: [..._openfairygui_core.UAM_SUPPORTED_MATERIALIZATION_SCOPE.resourceKinds],
-			nodeKinds: [..._openfairygui_core.UAM_SUPPORTED_MATERIALIZATION_SCOPE.nodeKinds],
-			gearKinds: [..._openfairygui_core.UAM_SUPPORTED_MATERIALIZATION_SCOPE.gearKinds],
+			resourceKinds: [..._openfairygui_core_uam.UAM_SUPPORTED_MATERIALIZATION_SCOPE.resourceKinds],
+			nodeKinds: [..._openfairygui_core_uam.UAM_SUPPORTED_MATERIALIZATION_SCOPE.nodeKinds],
+			gearKinds: [..._openfairygui_core_uam.UAM_SUPPORTED_MATERIALIZATION_SCOPE.gearKinds],
+			transactionScope: {
+				resourceKinds: [..._openfairygui_core_uam.UAM_SUPPORTED_TRANSACTION_SCOPE.resourceKinds],
+				nodeKinds: [..._openfairygui_core_uam.UAM_SUPPORTED_TRANSACTION_SCOPE.nodeKinds],
+				gearKinds: [..._openfairygui_core_uam.UAM_SUPPORTED_TRANSACTION_SCOPE.gearKinds]
+			},
 			unsupported: ["artifact.publish", "artifact.restore"]
 		},
 		artifact: createArtifactCapabilities(),

package/dist/{runtime-C5ZsWMnH.d.mts → runtime-u1Bq_ysz.d.mts}

@@ -1,5 +1,5 @@
-import { UamProject, UamTransactionOperation } from "@openfairygui/core";
-import { ApplyUamTransactionAppError } from "@openfairygui/functions";
+import { UamProject, UamTransactionOperation } from "@openfairygui/core/uam";
+import { ApplyUamTransactionAppError } from "@openfairygui/functions/uam";
 
 //#region src/contracts.d.ts
 declare const BACKEND_CONTRACT_VERSION: "1.1.0-p2";
@@ -122,6 +122,11 @@ interface BackendCapabilities {
     resourceKinds: readonly string[];
     nodeKinds: readonly string[];
     gearKinds: readonly string[];
+    transactionScope: {
+      resourceKinds: readonly string[];
+      nodeKinds: readonly string[];
+      gearKinds: readonly string[];
+    };
     unsupported: readonly ['artifact.publish', 'artifact.restore'];
   };
   artifact: {

package/package.json

@@ -1,66 +1,66 @@
 {
-	"name": "@openfairygui/backend",
-	"version": "0.2.0-alpha.1",
-	"description": "FairyGUI Headless Authoring SDK — stateful backend runtime and session services.",
-	"author": "OpenFairyGUI Contributors",
-	"license": "MIT",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/OpenFairyGUI/OpenFairyGUI.git",
-		"directory": "packages/backend"
-	},
-	"homepage": "https://github.com/OpenFairyGUI/OpenFairyGUI#readme",
-	"bugs": {
-		"url": "https://github.com/OpenFairyGUI/OpenFairYGUI/issues"
-	},
-	"type": "module",
-	"sideEffects": false,
-	"main": "./dist/index.cjs",
-	"module": "./dist/index.mjs",
-	"types": "./dist/index.d.mts",
-	"exports": {
-		".": {
-			"require": {
-				"types": "./dist/index.d.cts",
-				"default": "./dist/index.cjs"
-			},
-			"default": {
-				"types": "./dist/index.d.mts",
-				"default": "./dist/index.mjs"
-			}
-		},
-		"./node": {
-			"require": {
-				"types": "./dist/node.d.cts",
-				"default": "./dist/node.cjs"
-			},
-			"default": {
-				"types": "./dist/node.d.mts",
-				"default": "./dist/node.mjs"
-			}
-		}
-	},
-	"scripts": {
-		"build": "tsdown src/index.ts src/node.ts --format esm,cjs --platform node --external node:fs --external node:fs/promises --external node:path --env.PACKAGE_VERSION=$npm_package_version",
-		"build:watch": "tsdown src/index.ts src/node.ts --watch --format esm,cjs --platform node --external node:fs --external node:fs/promises --external node:path --env.PACKAGE_VERSION=$npm_package_version"
-	},
-	"files": [
-		"dist/",
-		"src/"
-	],
-	"keywords": [
-		"fairygui",
-		"backend",
-		"session",
-		"authoring",
-		"runtime"
-	],
-	"dependencies": {
-		"@openfairygui/core": "workspace:*",
-		"@openfairygui/functions": "workspace:*"
-	},
-	"devDependencies": {
-		"ava": "^7.0.0",
-		"tsx": "^4.0.0"
-	}
-}
+  "name": "@openfairygui/backend",
+  "version": "0.2.0-alpha.3",
+  "description": "FairyGUI Headless Authoring SDK — stateful backend runtime and session services.",
+  "author": "OpenFairyGUI Contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OpenFairyGUI/OpenFairyGUI.git",
+    "directory": "packages/backend"
+  },
+  "homepage": "https://github.com/OpenFairyGUI/OpenFairyGUI#readme",
+  "bugs": {
+    "url": "https://github.com/OpenFairyGUI/OpenFairYGUI/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "default": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
+    },
+    "./node": {
+      "require": {
+        "types": "./dist/node.d.cts",
+        "default": "./dist/node.cjs"
+      },
+      "default": {
+        "types": "./dist/node.d.mts",
+        "default": "./dist/node.mjs"
+      }
+    }
+  },
+  "files": [
+    "dist/",
+    "src/"
+  ],
+  "keywords": [
+    "fairygui",
+    "backend",
+    "session",
+    "authoring",
+    "runtime"
+  ],
+  "dependencies": {
+    "@openfairygui/core": "0.2.0-alpha.3",
+    "@openfairygui/functions": "0.2.0-alpha.3"
+  },
+  "devDependencies": {
+    "ava": "^7.0.0",
+    "tsx": "^4.0.0"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts src/node.ts --format esm,cjs --platform node --external node:fs --external node:fs/promises --external node:path --env.PACKAGE_VERSION=$npm_package_version",
+    "build:watch": "tsdown src/index.ts src/node.ts --watch --format esm,cjs --platform node --external node:fs --external node:fs/promises --external node:path --env.PACKAGE_VERSION=$npm_package_version"
+  }
+}

package/src/runtime.ts

@@ -1,9 +1,10 @@
 import {
 	UAM_SUPPORTED_MATERIALIZATION_SCOPE,
+	UAM_SUPPORTED_TRANSACTION_SCOPE,
 	type UamProject,
 	type UamTransactionOperation,
-} from '@openfairygui/core';
-import type { ApplyUamTransactionAppError } from '@openfairygui/functions';
+} from '@openfairygui/core/uam';
+import type { ApplyUamTransactionAppError } from '@openfairygui/functions/uam';
 import {
 	BACKEND_CAPABILITY_SCHEMA_VERSION,
 	BACKEND_COMPATIBILITY_POLICY,
@@ -47,11 +48,7 @@ export interface BackendFileSystem {
 }
 
 export interface BackendHostAdapter {
-	lockMetadata?(input: {
-		canonicalPathKey: string;
-		canonicalProjectPath: string;
-		lockFilePath: string;
-	}): unknown;
+	lockMetadata?(input: { canonicalPathKey: string; canonicalProjectPath: string; lockFilePath: string }): unknown;
 }
 
 export interface BackendArtifactBridgeCapability {
@@ -119,6 +116,11 @@ export interface BackendCapabilities {
 		resourceKinds: readonly string[];
 		nodeKinds: readonly string[];
 		gearKinds: readonly string[];
+		transactionScope: {
+			resourceKinds: readonly string[];
+			nodeKinds: readonly string[];
+			gearKinds: readonly string[];
+		};
 		unsupported: readonly ['artifact.publish', 'artifact.restore'];
 	};
 	artifact: {
@@ -189,9 +191,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';
@@ -446,10 +446,10 @@ export interface BackendRuntimeOptions {
 }
 
 const BACKEND_METHODS = [
-		'getCapabilities',
-		'openSession',
-		'openProjectSession',
-		'getSession',
+	'getCapabilities',
+	'openSession',
+	'openProjectSession',
+	'getSession',
 	'applyTransaction',
 	'saveSession',
 	'closeSession',
@@ -457,8 +457,8 @@ const BACKEND_METHODS = [
 	'getJob',
 	'listJobs',
 	'cancelJob',
-		'getCacheSnapshot',
-		'refreshCache',
+	'getCacheSnapshot',
+	'refreshCache',
 ] as const;
 
 const ARTIFACT_BRIDGE_CAPABILITY = {
@@ -487,6 +487,11 @@ function createCapabilities(): BackendCapabilities {
 			resourceKinds: [...UAM_SUPPORTED_MATERIALIZATION_SCOPE.resourceKinds],
 			nodeKinds: [...UAM_SUPPORTED_MATERIALIZATION_SCOPE.nodeKinds],
 			gearKinds: [...UAM_SUPPORTED_MATERIALIZATION_SCOPE.gearKinds],
+			transactionScope: {
+				resourceKinds: [...UAM_SUPPORTED_TRANSACTION_SCOPE.resourceKinds],
+				nodeKinds: [...UAM_SUPPORTED_TRANSACTION_SCOPE.nodeKinds],
+				gearKinds: [...UAM_SUPPORTED_TRANSACTION_SCOPE.gearKinds],
+			},
 			unsupported: ['artifact.publish', 'artifact.restore'],
 		},
 		artifact: createArtifactCapabilities(),
@@ -593,7 +598,14 @@ export class BackendRuntime {
 		return this.readService.getCapabilities() as BackendSuccess<BackendCapabilities>;
 	}
 
-	public async openSession(input: { projectPath: string }): Promise<BackendResult<BackendSessionSnapshot, InProcessLockConflictError | AdvisoryLockConflictError | BackendCapabilityUnavailableError>> {
+	public async openSession(input: {
+		projectPath: string;
+	}): Promise<
+		BackendResult<
+			BackendSessionSnapshot,
+			InProcessLockConflictError | AdvisoryLockConflictError | BackendCapabilityUnavailableError
+		>
+	> {
 		return this.runtimeService.openSession(input);
 	}
 
@@ -607,27 +619,47 @@ export class BackendRuntime {
 
 	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 | BackendCapabilityUnavailableError>> {
+	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);
 	}
 
@@ -635,7 +667,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/authoring-service.ts

@@ -1,5 +1,6 @@
-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';
@@ -20,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();
@@ -83,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({
@@ -102,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,
@@ -122,38 +167,67 @@ export class AuthoringService {
 		});
 	}
 
-	public async saveSession(
-		input: { sessionId: string; expectedRevision?: number; targetPath?: string },
-	): Promise<BackendResult<BackendSessionSnapshot, SessionNotFoundError | SessionStaleWriteError | SavePartialFailureError | PathPolicyViolationError | BackendCapabilityUnavailableError>> {
+	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,
-			});
+			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 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), {
@@ -164,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(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,
+				},
+			);
 		}
 	}
 }

package/src/services/context.ts

@@ -25,7 +25,7 @@ export interface BackendSessionState {
 	canonicalProjectPath: string;
 	canonicalPathKey: string;
 	lockFilePath: string;
-	project: import('@openfairygui/core').UamProject;
+	project: import('@openfairygui/core/uam').UamProject;
 	revision: number;
 	lastSavedRevision: number;
 	dirty: boolean;

package/src/services/runtime-service.ts

@@ -1,4 +1,5 @@
-import { ProjectReader, liftDocumentToUamProject, normalizeUamProject } from '@openfairygui/core';
+import { ProjectReader, type FileSystem } from '@openfairygui/core/project-io';
+import { liftDocumentToUamProject, normalizeUamProject } from '@openfairygui/core/uam';
 import { failure, success, type BackendContext, type BackendSessionState } from './context.js';
 import type { CacheService } from './cache-service.js';
 import type { EventService } from './event-service.js';
@@ -20,7 +21,9 @@ function randomId(): string {
 	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 }
 
-function createCapabilityUnavailableError(capability: BackendCapabilityUnavailableError['capability']): BackendCapabilityUnavailableError {
+function createCapabilityUnavailableError(
+	capability: BackendCapabilityUnavailableError['capability'],
+): BackendCapabilityUnavailableError {
 	const artifactCapability = capability === 'artifact.publish' || capability === 'artifact.restore';
 	return {
 		code: 'capability_unavailable',
@@ -34,7 +37,7 @@ function createCapabilityUnavailableError(capability: BackendCapabilityUnavailab
 	};
 }
 
-function createProjectReaderFileSystem(fileSystem: NonNullable<BackendContext['fileSystem']>): import('@openfairygui/core').FileSystem {
+function createProjectReaderFileSystem(fileSystem: NonNullable<BackendContext['fileSystem']>): FileSystem {
 	return {
 		readFile(filePath: string): Promise<string> {
 			return fileSystem.readFile(filePath);
@@ -79,7 +82,14 @@ export class RuntimeService {
 		private readonly jobService: JobService,
 	) {}
 
-	public async openSession(input: { projectPath: string }): Promise<BackendResult<BackendSessionSnapshot, InProcessLockConflictError | AdvisoryLockConflictError | BackendCapabilityUnavailableError>> {
+	public async openSession(input: {
+		projectPath: string;
+	}): Promise<
+		BackendResult<
+			BackendSessionSnapshot,
+			InProcessLockConflictError | AdvisoryLockConflictError | BackendCapabilityUnavailableError
+		>
+	> {
 		const startedAt = Date.now();
 		if (!this.context.fileSystem) {
 			return failure('runtime', startedAt, createCapabilityUnavailableError('fileSystem'));
@@ -104,14 +114,18 @@ export class RuntimeService {
 		let advisoryLock: BackendFileHandle | null = null;
 		try {
 			advisoryLock = await fileSystem.openExclusive(lockFilePath);
-			await advisoryLock.writeFile(JSON.stringify(this.context.host?.lockMetadata?.({
-				canonicalPathKey,
-				canonicalProjectPath,
-				lockFilePath,
-			}) ?? {
-				createdAt: new Date().toISOString(),
-				canonicalPathKey,
-			}));
+			await advisoryLock.writeFile(
+				JSON.stringify(
+					this.context.host?.lockMetadata?.({
+						canonicalPathKey,
+						canonicalProjectPath,
+						lockFilePath,
+					}) ?? {
+						createdAt: new Date().toISOString(),
+						canonicalPathKey,
+					},
+				),
+			);
 			await advisoryLock.close();
 
 			const reader = new ProjectReader(createProjectReaderFileSystem(fileSystem));
@@ -197,16 +211,21 @@ export class RuntimeService {
 		});
 	}
 
-	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>> {
 		const startedAt = Date.now();
 		const session = this.context.sessions.get(input.sessionId);
 		if (!session || session.closed) {
 			return failure('runtime', startedAt, createSessionNotFoundError(input.sessionId));
 		}
 
-		this.eventService.emit({ kind: 'session.closeRequested', sessionId: session.sessionId, canonicalPathKey: session.canonicalPathKey, revision: session.revision });
+		this.eventService.emit({
+			kind: 'session.closeRequested',
+			sessionId: session.sessionId,
+			canonicalPathKey: session.canonicalPathKey,
+			revision: session.revision,
+		});
 		if (this.context.fileSystem && session.lockFilePath) {
 			await this.context.fileSystem.unlink(session.lockFilePath).catch(() => undefined);
 		}
@@ -216,12 +235,22 @@ export class RuntimeService {
 		this.context.sessionsByPath.delete(session.canonicalPathKey);
 		this.cacheService.removeSession(session.sessionId);
 		this.jobService.removeSession(session.sessionId);
-		this.eventService.emit({ kind: 'session.closed', sessionId: session.sessionId, canonicalPathKey: session.canonicalPathKey, revision: session.revision });
+		this.eventService.emit({
+			kind: 'session.closed',
+			sessionId: session.sessionId,
+			canonicalPathKey: session.canonicalPathKey,
+			revision: session.revision,
+		});
 		this.eventService.removeSession(session.sessionId);
 
-		return success('runtime', startedAt, {
-			sessionId: session.sessionId,
-			closed: true,
-		}, { sessionId: session.sessionId, revision: session.revision });
+		return success(
+			'runtime',
+			startedAt,
+			{
+				sessionId: session.sessionId,
+				closed: true,
+			},
+			{ sessionId: session.sessionId, revision: session.revision },
+		);
 	}
 }