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

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

@@ -1,6 +1,6 @@
-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 { UAM_SUPPORTED_MATERIALIZATION_SCOPE, UAM_SUPPORTED_TRANSACTION_SCOPE, commitUamProjectSourcePaths, liftDocumentToUamProject, materializeUamProject, normalizeUamProject, validateUamProject } from "@openfairygui/core/uam";
 import { applyUamTransactionApp } from "@openfairygui/functions/uam";
+import { ProjectReader, ProjectWriter } from "@openfairygui/core/project-io";
 //#region src/contracts.ts
 const BACKEND_CONTRACT_VERSION = "1.1.0-p2";
 const BACKEND_CAPABILITY_SCHEMA_VERSION = 2;
@@ -75,24 +75,6 @@ async function validateSaveTarget(fileSystem, openedFairyPath, targetPath) {
 	};
 }
 //#endregion
-//#region src/services/artifact-service.ts
-function createArtifactCapabilities() {
-	const bridge = {
-		available: false,
-		requiredHost: "node",
-		executionBoundary: "external-bridge",
-		bridgeEntrypoint: "@openfairygui/backend/node",
-		reason: "publish/restore require explicit Node-hosted filesystem and artifact execution."
-	};
-	return {
-		publish: false,
-		restore: false,
-		status: "bridge-required",
-		publishBridge: bridge,
-		restoreBridge: bridge
-	};
-}
-//#endregion
 //#region src/services/context.ts
 function diagnosticFromError(error) {
 	return {
@@ -137,6 +119,52 @@ function failure(stage, startedAt, error, session, options) {
 	};
 }
 //#endregion
+//#region src/services/session-project-writer.ts
+function createWriterFileSystem(fileSystem, writtenPaths, failedPaths) {
+	async function trackWrite(targetPath, write) {
+		try {
+			const result = await write();
+			writtenPaths.push(targetPath);
+			return result;
+		} catch (error) {
+			failedPaths.push(targetPath);
+			throw error;
+		}
+	}
+	return {
+		readFile: (path) => fileSystem.readFile(path),
+		readFileRaw: (path) => fileSystem.readFileRaw(path),
+		writeFile: (path, content) => trackWrite(path, async () => {
+			await fileSystem.mkdir(fileSystem.dirname(path), { recursive: true });
+			await fileSystem.writeFile(path, content);
+		}),
+		writeFileRaw: (path, data) => trackWrite(path, async () => {
+			await fileSystem.mkdir(fileSystem.dirname(path), { recursive: true });
+			await fileSystem.writeFileRaw(path, data);
+		}),
+		mkdir: (path) => fileSystem.mkdir(path, { recursive: true }),
+		readdir: (path) => fileSystem.readdir(path),
+		async exists(path) {
+			try {
+				await fileSystem.stat(path);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		join: (...paths) => fileSystem.join(...paths),
+		dirname: (path) => fileSystem.dirname(path),
+		unlink: (path) => trackWrite(path, () => fileSystem.unlink(path)),
+		rmdir: (path) => trackWrite(path, () => fileSystem.rmdir(path))
+	};
+}
+async function writeSessionProject(input) {
+	await new ProjectWriter(createWriterFileSystem(input.fileSystem, input.writtenPaths, input.failedPaths)).write(input.document, input.fairyPath, {
+		staleSourceFiles: input.staleSourceFiles,
+		staleResourceFolders: input.staleResourceFolders
+	});
+}
+//#endregion
 //#region src/services/snapshot-utils.ts
 function cloneJsonValue(value) {
 	if (value === void 0 || value === null) return value;
@@ -179,6 +207,7 @@ function toSessionSnapshot(session, capabilities) {
 		revision: session.revision,
 		lastSavedRevision: session.lastSavedRevision,
 		dirty: session.dirty,
+		uamFidelity: session.uamFidelity,
 		lockHeld: session.lockHeld,
 		capabilities: cloneCapabilitiesSnapshot(capabilities)
 	};
@@ -202,65 +231,161 @@ function createStaleWriteError(session, expectedRevision) {
 }
 //#endregion
 //#region src/services/authoring-service.ts
-function createWriterFileSystem(fileSystem, committedPaths, failedPaths) {
-	async function trackWrite(targetPath, fn) {
-		try {
-			const result = await fn();
-			committedPaths.push(targetPath);
-			return result;
-		} catch (error) {
-			failedPaths.push(targetPath);
-			throw error;
+function projectSourceFiles(project) {
+	const result = /* @__PURE__ */ new Map();
+	for (const pkg of project.packages) {
+		result.set(`${pkg.id}/package.xml`, {
+			packageName: pkg.name,
+			branch: "",
+			path: "",
+			fileName: "package.xml"
+		});
+		const branches = /* @__PURE__ */ new Set();
+		for (const folder of pkg.folders) if (folder.branch) branches.add(folder.branch);
+		for (const resource of pkg.resources) {
+			if (resource.branch) branches.add(resource.branch);
+			const fileName = resource.kind === "component" ? `${resource.name}.xml` : resource.fileName ?? (resource.kind === "image" ? "" : resource.file) ?? "";
+			if (!fileName) continue;
+			result.set(`${pkg.id}/${resource.id}`, {
+				packageName: pkg.name,
+				branch: resource.branch,
+				path: resource.path,
+				fileName
+			});
 		}
+		for (const branch of branches) result.set(`${pkg.id}/branch/${branch}`, {
+			packageName: pkg.name,
+			branch,
+			path: "",
+			fileName: "package_branch.xml"
+		});
 	}
+	return result;
+}
+function sourceFileKey(source) {
+	return [
+		source.branch,
+		source.packageName,
+		source.path,
+		source.fileName
+	].join("\0");
+}
+function projectResourceFolders(project) {
+	const result = /* @__PURE__ */ new Map();
+	for (const pkg of project.packages) for (const folder of pkg.folders) result.set(`${pkg.id}/${folder.branch}/${folder.path}`, {
+		packageName: pkg.name,
+		branch: folder.branch,
+		path: folder.path
+	});
+	return result;
+}
+function resourceFolderKey(folder) {
+	return [
+		folder.branch,
+		folder.packageName,
+		folder.path
+	].join("\0");
+}
+function recordStaleProjectFiles(session, previousProject, nextProject) {
+	if (!session.fileSystem) return;
+	const previousSources = projectSourceFiles(previousProject);
+	const nextSourceKeys = new Set([...projectSourceFiles(nextProject).values()].map(sourceFileKey));
+	for (const source of previousSources.values()) {
+		const key = sourceFileKey(source);
+		if (!nextSourceKeys.has(key)) session.pendingStaleSourceFiles.set(key, source);
+	}
+	for (const key of nextSourceKeys) session.pendingStaleSourceFiles.delete(key);
+	const previousFolders = projectResourceFolders(previousProject);
+	const nextFolderKeys = new Set([...projectResourceFolders(nextProject).values()].map(resourceFolderKey));
+	for (const folder of previousFolders.values()) {
+		const key = resourceFolderKey(folder);
+		if (!nextFolderKeys.has(key)) session.pendingStaleResourceFolders.set(key, folder);
+	}
+	for (const key of nextFolderKeys) session.pendingStaleResourceFolders.delete(key);
+}
+function toBackendDiagnostics(error) {
+	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
+	}];
+}
+function createCapabilityUnavailableError$1(message) {
 	return {
-		async readFile(filePath) {
-			return fileSystem.readFile(filePath);
-		},
-		async readFileRaw(filePath) {
-			return fileSystem.readFileRaw(filePath);
-		},
-		async writeFile(filePath, content) {
-			await trackWrite(filePath, async () => {
-				await fileSystem.mkdir(fileSystem.dirname(filePath), { recursive: true });
-				await fileSystem.writeFile(filePath, content);
-			});
-		},
-		async writeFileRaw(filePath, data) {
-			await trackWrite(filePath, async () => {
-				await fileSystem.mkdir(fileSystem.dirname(filePath), { recursive: true });
-				await fileSystem.writeFileRaw(filePath, data);
-			});
-		},
-		async mkdir(dirPath) {
-			await fileSystem.mkdir(dirPath, { recursive: true });
-		},
-		async readdir(dirPath) {
-			return fileSystem.readdir(dirPath);
-		},
-		async exists(filePath) {
-			try {
-				await fileSystem.stat(filePath);
-				return true;
-			} catch {
-				return false;
-			}
-		},
-		join(...paths) {
-			return fileSystem.join(...paths);
-		},
-		dirname(filePath) {
-			return fileSystem.dirname(filePath);
-		}
+		code: "capability_unavailable",
+		message,
+		capability: "fileSystem",
+		requiredAdapter: "BackendFileSystem"
+	};
+}
+function createUamFidelityUnsupportedError(session) {
+	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) {
+	return validateUamProject(sessionProject).map((issue) => ({
+		code: "materialize_validation_failed",
+		message: issue.message,
+		severity: "error",
+		path: issue.path,
+		operationKind: "materializeSession"
+	}));
+}
+function toMaterializeSnapshot(session, capabilities, input) {
+	return {
+		...toSessionSnapshot(session, capabilities),
+		mode: "fullProject",
+		reason: input.reason,
+		materializeRevision: session.revision,
+		saveRevision: session.lastSavedRevision,
+		writtenPaths: [...input.writtenPaths],
+		skippedPaths: [...input.skippedPaths],
+		diagnostics: input.diagnostics.map((diagnostic) => ({ ...diagnostic }))
+	};
+}
+function storageCanonicalTarget(input) {
+	const canonicalProjectPath = input.canonicalProjectPath ?? (input.fileSystem.dirname(input.fairyPath) || ".");
+	return {
+		fileSystem: input.fileSystem,
+		fairyPath: input.fairyPath,
+		canonicalProjectPath,
+		canonicalPathKey: input.canonicalPathKey ?? normalizeComparablePath(canonicalProjectPath)
 	};
 }
 var AuthoringService = class {
+	sessionOperations = /* @__PURE__ */ new Map();
 	constructor(context, cacheService, eventService) {
 		this.context = context;
 		this.cacheService = cacheService;
 		this.eventService = eventService;
 	}
+	async runSessionExclusive(sessionId, operation) {
+		const previous = this.sessionOperations.get(sessionId) ?? Promise.resolve();
+		let release = () => void 0;
+		const current = new Promise((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);
+		}
+	}
 	async applyTransaction(input) {
+		return this.runSessionExclusive(input.sessionId, () => this.applyTransactionExclusive(input));
+	}
+	async applyTransactionExclusive(input) {
 		const startedAt = Date.now();
 		const session = this.context.sessions.get(input.sessionId);
 		if (!session || session.closed) return failure("authoring", startedAt, createSessionNotFoundError(input.sessionId));
@@ -281,22 +406,21 @@ var AuthoringService = class {
 			operations: input.operations
 		});
 		if (result.ok === false) {
+			const diagnostics = toBackendDiagnostics(result.error);
 			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"
-				})) ?? []
+				diagnostics
 			});
 			return failure("authoring", startedAt, result.error, toSessionSnapshot(session, this.context.capabilities), {
 				sessionId: session.sessionId,
-				revision: session.revision
+				revision: session.revision,
+				diagnostics
 			});
 		}
+		recordStaleProjectFiles(session, session.project, result.project);
 		session.project = result.project;
 		session.revision += 1;
 		session.dirty = true;
@@ -320,15 +444,22 @@ var AuthoringService = class {
 		});
 	}
 	async saveSession(input) {
+		if (input.force === true || input.mode === "materializeCleanSession") return this.materializeSession({
+			sessionId: input.sessionId,
+			expectedRevision: input.expectedRevision,
+			targetPath: input.targetPath,
+			fileSystem: input.fileSystem,
+			mode: "fullProject",
+			reason: "force_save"
+		});
+		return this.runSessionExclusive(input.sessionId, () => this.saveSessionExclusive(input));
+	}
+	async saveSessionExclusive(input) {
 		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), {
+		const fileSystem = session.fileSystem ?? input.fileSystem ?? this.context.fileSystem;
+		if (!fileSystem) return failure("authoring", startedAt, createCapabilityUnavailableError$1("saveSession requires an injected BackendFileSystem adapter."), toSessionSnapshot(session, this.context.capabilities), {
 			sessionId: session.sessionId,
 			revision: session.revision
 		});
@@ -336,7 +467,6 @@ var AuthoringService = class {
 			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,
@@ -346,6 +476,10 @@ var AuthoringService = class {
 			sessionId: session.sessionId,
 			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 = [];
 		const failedPaths = [];
 		this.eventService.emit({
@@ -355,7 +489,19 @@ var AuthoringService = class {
 			revision: session.revision
 		});
 		try {
-			await new ProjectWriter(createWriterFileSystem(fileSystem, committedPaths, failedPaths)).write(materializeUamProject(session.project), session.fairyPath);
+			await writeSessionProject({
+				fileSystem,
+				document: materializeUamProject(session.project),
+				fairyPath: session.fairyPath,
+				staleSourceFiles: [...session.pendingStaleSourceFiles.values()],
+				staleResourceFolders: [...session.pendingStaleResourceFolders.values()],
+				writtenPaths: committedPaths,
+				failedPaths
+			});
+			session.fileSystem ??= fileSystem;
+			session.pendingStaleSourceFiles.clear();
+			session.pendingStaleResourceFolders.clear();
+			commitUamProjectSourcePaths(session.project);
 			session.lastSavedRevision = session.revision;
 			session.dirty = false;
 			const cacheEntry = this.cacheService.refreshSession(session);
@@ -400,6 +546,179 @@ var AuthoringService = class {
 			});
 		}
 	}
+	async materializeSession(input) {
+		return this.runSessionExclusive(input.sessionId, () => this.materializeSessionExclusive(input));
+	}
+	async materializeSessionExclusive(input) {
+		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 !== void 0 && input.expectedRevision !== session.revision) return failure("authoring", startedAt, createStaleWriteError(session, input.expectedRevision), toSessionSnapshot(session, this.context.capabilities), {
+			sessionId: session.sessionId,
+			revision: session.revision
+		});
+		const storageTarget = input.storage ? storageCanonicalTarget(input.storage) : null;
+		const fileSystem = storageTarget?.fileSystem ?? input.fileSystem ?? session.fileSystem ?? this.context.fileSystem;
+		if (!fileSystem) return failure("authoring", startedAt, createCapabilityUnavailableError$1("materializeSession requires an injected BackendFileSystem adapter."), toSessionSnapshot(session, this.context.capabilities), {
+			sessionId: session.sessionId,
+			revision: session.revision
+		});
+		const fairyPath = storageTarget?.fairyPath ?? session.fairyPath;
+		const targetViolation = await validateSaveTarget(fileSystem, fairyPath, input.targetPath);
+		if (targetViolation) return failure("authoring", startedAt, targetViolation, toSessionSnapshot(session, this.context.capabilities), {
+			sessionId: session.sessionId,
+			revision: session.revision
+		});
+		if (storageTarget) {
+			const holderSessionId = this.context.sessionsByPath.get(storageTarget.canonicalPathKey);
+			if (holderSessionId && holderSessionId !== session.sessionId) return failure("authoring", startedAt, {
+				code: "lock_conflict",
+				kind: "in_process_session_exists",
+				message: `Project is already open in this backend runtime: ${storageTarget.canonicalProjectPath}`,
+				canonicalPathKey: storageTarget.canonicalPathKey,
+				holderSessionId
+			}, toSessionSnapshot(session, this.context.capabilities), {
+				sessionId: session.sessionId,
+				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 diagnostics = validationDiagnostics(session.project);
+		if (diagnostics.length > 0) return failure("authoring", startedAt, {
+			code: "materialize_validation_failed",
+			message: `UAM materialize validation failed with ${diagnostics.length} issue(s).`,
+			sessionId: session.sessionId,
+			canonicalPathKey: session.canonicalPathKey,
+			issueCount: diagnostics.length,
+			diagnostics
+		}, toSessionSnapshot(session, this.context.capabilities), {
+			sessionId: session.sessionId,
+			revision: session.revision,
+			diagnostics
+		});
+		let document;
+		try {
+			document = materializeUamProject(session.project);
+		} catch (error) {
+			const diagnosticsFromError = [{
+				code: "materialize_validation_failed",
+				message: error instanceof Error ? error.message : String(error),
+				severity: "error",
+				operationKind: "materializeSession"
+			}];
+			return failure("authoring", startedAt, {
+				code: "materialize_validation_failed",
+				message: error instanceof Error ? error.message : String(error),
+				sessionId: session.sessionId,
+				canonicalPathKey: session.canonicalPathKey,
+				issueCount: diagnosticsFromError.length,
+				diagnostics: diagnosticsFromError
+			}, toSessionSnapshot(session, this.context.capabilities), {
+				sessionId: session.sessionId,
+				revision: session.revision,
+				diagnostics: diagnosticsFromError
+			});
+		}
+		const writtenPaths = [];
+		const failedPaths = [];
+		const skippedPaths = [];
+		this.eventService.emit({
+			kind: "save.started",
+			sessionId: session.sessionId,
+			canonicalPathKey: storageTarget?.canonicalPathKey ?? session.canonicalPathKey,
+			revision: session.revision
+		});
+		try {
+			const isSessionStorageTarget = fileSystem === session.fileSystem && fairyPath === session.fairyPath;
+			await writeSessionProject({
+				fileSystem,
+				document,
+				fairyPath,
+				staleSourceFiles: isSessionStorageTarget ? [...session.pendingStaleSourceFiles.values()] : [],
+				staleResourceFolders: isSessionStorageTarget ? [...session.pendingStaleResourceFolders.values()] : [],
+				writtenPaths,
+				failedPaths
+			});
+			if (isSessionStorageTarget) {
+				session.pendingStaleSourceFiles.clear();
+				session.pendingStaleResourceFolders.clear();
+			}
+			if (storageTarget && !isSessionStorageTarget) {
+				session.pendingStaleSourceFiles.clear();
+				session.pendingStaleResourceFolders.clear();
+			}
+			if (isSessionStorageTarget || storageTarget) commitUamProjectSourcePaths(session.project);
+			if (storageTarget) {
+				this.context.sessionsByPath.delete(session.canonicalPathKey);
+				session.fileSystem = storageTarget.fileSystem;
+				session.fairyPath = storageTarget.fairyPath;
+				session.canonicalProjectPath = storageTarget.canonicalProjectPath;
+				session.canonicalPathKey = storageTarget.canonicalPathKey;
+				this.context.sessionsByPath.set(session.canonicalPathKey, session.sessionId);
+			}
+			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
+			});
+			return success("authoring", startedAt, toMaterializeSnapshot(session, this.context.capabilities, {
+				reason: input.reason,
+				writtenPaths,
+				skippedPaths,
+				diagnostics: []
+			}), {
+				sessionId: session.sessionId,
+				revision: session.revision
+			});
+		} catch (error) {
+			const diagnosticsFromError = [{
+				code: "write_failed",
+				message: error instanceof Error ? error.message : String(error),
+				severity: "error",
+				path: failedPaths[0],
+				operationKind: "materializeSession"
+			}];
+			this.cacheService.invalidateSession(session);
+			this.eventService.emit({
+				kind: "save.failed",
+				sessionId: session.sessionId,
+				canonicalPathKey: session.canonicalPathKey,
+				revision: session.revision,
+				diagnostics: diagnosticsFromError
+			});
+			return failure("authoring", startedAt, {
+				code: "write_failed",
+				message: error instanceof Error ? error.message : String(error),
+				sessionId: session.sessionId,
+				canonicalPathKey: session.canonicalPathKey,
+				attemptedRevision: session.revision,
+				lastSavedRevision: session.lastSavedRevision,
+				writtenPaths,
+				failedPaths,
+				skippedPaths,
+				diagnostics: diagnosticsFromError,
+				diskMayBePartiallyUpdated: true
+			}, toSessionSnapshot(session, this.context.capabilities), {
+				sessionId: session.sessionId,
+				revision: session.revision,
+				diagnostics: diagnosticsFromError
+			});
+		}
+	}
 };
 //#endregion
 //#region src/services/cache-service.ts
@@ -858,6 +1177,75 @@ function createProjectReaderFileSystem(fileSystem) {
 		}
 	};
 }
+function createCaptureFileSystem(files, directories) {
+	const normalize = (filePath) => filePath.replace(/\\/g, "/").replace(/\/+/g, "/");
+	return {
+		async readFile(filePath) {
+			const value = files.get(normalize(filePath));
+			if (typeof value !== "string") throw new Error(`Captured text file was not found: ${filePath}`);
+			return value;
+		},
+		async readFileRaw(filePath) {
+			const value = files.get(normalize(filePath));
+			if (!(value instanceof Uint8Array)) throw new Error(`Captured binary file was not found: ${filePath}`);
+			return value.slice();
+		},
+		async writeFile(filePath, content) {
+			files.set(normalize(filePath), content);
+		},
+		async writeFileRaw(filePath, data) {
+			files.set(normalize(filePath), data.slice());
+		},
+		async mkdir(dirPath) {
+			directories.add(normalize(dirPath));
+		},
+		async readdir() {
+			return [];
+		},
+		async exists(filePath) {
+			return files.has(normalize(filePath));
+		},
+		join(...paths) {
+			return normalize(paths.filter(Boolean).join("/"));
+		},
+		dirname(filePath) {
+			const normalized = normalize(filePath);
+			const separator = normalized.lastIndexOf("/");
+			return separator < 0 ? "" : normalized.slice(0, separator);
+		},
+		async unlink(filePath) {
+			files.delete(normalize(filePath));
+		}
+	};
+}
+function capturedFilesEqual(left, right) {
+	if (left.size !== right.size) return false;
+	for (const [filePath, leftValue] of left) {
+		const rightValue = right.get(filePath);
+		if (typeof leftValue === "string") {
+			if (leftValue !== rightValue) return false;
+			continue;
+		}
+		if (!(rightValue instanceof Uint8Array) || leftValue.length !== rightValue.length) return false;
+		for (let index = 0; index < leftValue.length; index += 1) if (leftValue[index] !== rightValue[index]) return false;
+	}
+	return true;
+}
+function capturedDirectoriesEqual(left, right) {
+	return left.size === right.size && [...left].every((directory) => right.has(directory));
+}
+async function hasFullUamFidelity(document, project) {
+	const sourceFiles = /* @__PURE__ */ new Map();
+	const materializedFiles = /* @__PURE__ */ new Map();
+	const sourceDirectories = /* @__PURE__ */ new Set();
+	const materializedDirectories = /* @__PURE__ */ new Set();
+	try {
+		await Promise.all([new ProjectWriter(createCaptureFileSystem(sourceFiles, sourceDirectories)).write(document, "Project.fairy"), new ProjectWriter(createCaptureFileSystem(materializedFiles, materializedDirectories)).write(materializeUamProject(project), "Project.fairy")]);
+	} catch {
+		return false;
+	}
+	return capturedFilesEqual(sourceFiles, materializedFiles) && capturedDirectoriesEqual(sourceDirectories, materializedDirectories);
+}
 var RuntimeService = class {
 	constructor(context, cacheService, eventService, jobService) {
 		this.context = context;
@@ -892,7 +1280,8 @@ var RuntimeService = class {
 				canonicalPathKey
 			}));
 			await advisoryLock.close();
-			const project = liftDocumentToUamProject(await new ProjectReader(createProjectReaderFileSystem(fileSystem)).read(fairyPath));
+			const document = await new ProjectReader(createProjectReaderFileSystem(fileSystem)).read(fairyPath, { hydrateResourceBytes: true });
+			const project = liftDocumentToUamProject(document);
 			const sessionId = randomId();
 			const session = {
 				sessionId,
@@ -900,9 +1289,13 @@ var RuntimeService = class {
 				canonicalProjectPath,
 				canonicalPathKey,
 				lockFilePath,
+				fileSystem,
 				project,
+				uamFidelity: await hasFullUamFidelity(document, project) ? "full" : "unsupported",
 				revision: 0,
 				lastSavedRevision: 0,
+				pendingStaleSourceFiles: /* @__PURE__ */ new Map(),
+				pendingStaleResourceFolders: /* @__PURE__ */ new Map(),
 				dirty: false,
 				lockHeld: true,
 				closed: false
@@ -938,8 +1331,10 @@ var RuntimeService = class {
 	openProjectSession(input) {
 		const startedAt = Date.now();
 		const sessionId = input.sessionId ?? randomId();
-		const canonicalProjectPath = input.canonicalProjectPath ?? `memory://${sessionId}`;
-		const canonicalPathKey = input.canonicalPathKey ?? canonicalProjectPath.toLowerCase();
+		const storage = input.storage;
+		const memoryProjectPath = `memory://${sessionId}`;
+		const canonicalProjectPath = storage?.canonicalProjectPath ?? input.canonicalProjectPath ?? (storage ? storage.fileSystem.dirname(storage.fairyPath) || "." : memoryProjectPath);
+		const canonicalPathKey = storage?.canonicalPathKey ?? input.canonicalPathKey ?? (storage ? normalizeComparablePath(canonicalProjectPath) : canonicalProjectPath.toLowerCase());
 		const existingSessionId = this.context.sessionsByPath.get(canonicalPathKey);
 		if (existingSessionId) return failure("runtime", startedAt, {
 			code: "lock_conflict",
@@ -950,13 +1345,17 @@ var RuntimeService = class {
 		});
 		const session = {
 			sessionId,
-			fairyPath: canonicalProjectPath,
+			fairyPath: storage?.fairyPath ?? canonicalProjectPath,
 			canonicalProjectPath,
 			canonicalPathKey,
 			lockFilePath: "",
+			fileSystem: storage?.fileSystem,
 			project: normalizeUamProject(input.project),
+			uamFidelity: "full",
 			revision: 0,
 			lastSavedRevision: 0,
+			pendingStaleSourceFiles: /* @__PURE__ */ new Map(),
+			pendingStaleResourceFolders: /* @__PURE__ */ new Map(),
 			dirty: false,
 			lockHeld: false,
 			closed: false
@@ -1009,7 +1408,25 @@ var RuntimeService = class {
 	}
 };
 //#endregion
-//#region src/runtime.ts
+//#region src/services/artifact-service.ts
+function createArtifactCapabilities() {
+	const bridge = {
+		available: false,
+		requiredHost: "node",
+		executionBoundary: "external-bridge",
+		bridgeEntrypoint: "@openfairygui/backend/node",
+		reason: "publish/restore require explicit Node-hosted filesystem and artifact execution."
+	};
+	return {
+		publish: false,
+		restore: false,
+		status: "bridge-required",
+		publishBridge: bridge,
+		restoreBridge: bridge
+	};
+}
+//#endregion
+//#region src/runtime/capabilities.ts
 const BACKEND_METHODS = [
 	"getCapabilities",
 	"openSession",
@@ -1017,6 +1434,7 @@ const BACKEND_METHODS = [
 	"getSession",
 	"applyTransaction",
 	"saveSession",
+	"materializeSession",
 	"closeSession",
 	"getEvents",
 	"getJob",
@@ -1065,7 +1483,21 @@ function createCapabilities() {
 			adapters: {
 				fileSystem: {
 					injected: true,
-					requiredFor: ["openSession", "saveSession"]
+					requiredFor: [
+						"openSession",
+						"saveSession",
+						"materializeSession"
+					]
+				},
+				projectStorage: {
+					injected: true,
+					browserSafe: true,
+					requiredFor: [
+						"openProjectSession.writeback",
+						"saveSession",
+						"materializeSession"
+					],
+					adapterFactory: "createBackendStorageFileSystem"
 				},
 				host: {
 					injected: true,
@@ -1114,6 +1546,8 @@ function createCapabilities() {
 		}
 	};
 }
+//#endregion
+//#region src/runtime.ts
 var BackendRuntime = class {
 	fileSystem;
 	capabilities;
@@ -1172,6 +1606,9 @@ var BackendRuntime = class {
 	async saveSession(input) {
 		return this.authoringService.saveSession(input);
 	}
+	async materializeSession(input) {
+		return this.authoringService.materializeSession(input);
+	}
 	async closeSession(input) {
 		return this.runtimeService.closeSession(input);
 	}