@openfairygui/backend 0.2.0-alpha.14 → 0.2.0-alpha.16

package/dist/{runtime-DqApG30C.cjs → runtime-P0Nhxk2f.cjs}

@@ -180,6 +180,7 @@ function toSessionSnapshot(session, capabilities) {
 		revision: session.revision,
 		lastSavedRevision: session.lastSavedRevision,
 		dirty: session.dirty,
+		uamFidelity: session.uamFidelity,
 		lockHeld: session.lockHeld,
 		capabilities: cloneCapabilitiesSnapshot(capabilities)
 	};
@@ -258,17 +259,32 @@ function createWriterFileSystem(fileSystem, committedPaths, failedPaths) {
 		}
 	};
 }
-function projectAssetSourceFiles(project) {
+function projectSourceFiles(project) {
 	const result = /* @__PURE__ */ new Map();
-	for (const pkg of project.packages) for (const resource of pkg.resources) {
-		if (resource.kind === "component") continue;
-		const fileName = resource.fileName ?? resource.file ?? "";
-		if (!fileName) continue;
-		result.set(`${pkg.id}/${resource.id}`, {
+	for (const pkg of project.packages) {
+		result.set(`${pkg.id}/package.xml`, {
 			packageName: pkg.name,
-			branch: resource.branch,
-			path: resource.path,
-			fileName
+			branch: "",
+			path: "",
+			fileName: "package.xml"
+		});
+		const branches = /* @__PURE__ */ new Set();
+		for (const resource of pkg.resources) {
+			if (resource.branch) branches.add(resource.branch);
+			const fileName = resource.kind === "component" ? `${resource.name}.xml` : resource.fileName ?? 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;
@@ -281,10 +297,10 @@ function sourceFileKey(source) {
 		source.fileName
 	].join("\0");
 }
-function recordStaleResourceSources(session, previousProject, nextProject) {
+function recordStaleProjectFiles(session, previousProject, nextProject) {
 	if (!session.fileSystem) return;
-	const previousSources = projectAssetSourceFiles(previousProject);
-	const nextSourceKeys = new Set([...projectAssetSourceFiles(nextProject).values()].map(sourceFileKey));
+	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);
@@ -309,6 +325,14 @@ function createCapabilityUnavailableError$1(message) {
 		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 (0, _openfairygui_core_uam.validateUamProject)(sessionProject).map((issue) => ({
 		code: "materialize_validation_failed",
@@ -340,12 +364,32 @@ function storageCanonicalTarget(input) {
 	};
 }
 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));
@@ -380,7 +424,7 @@ var AuthoringService = class {
 				diagnostics
 			});
 		}
-		recordStaleResourceSources(session, session.project, result.project);
+		recordStaleProjectFiles(session, session.project, result.project);
 		session.project = result.project;
 		session.revision += 1;
 		session.dirty = true;
@@ -412,6 +456,9 @@ var AuthoringService = class {
 			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));
@@ -433,6 +480,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({
@@ -491,6 +542,9 @@ 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));
@@ -523,6 +577,10 @@ var AuthoringService = class {
 				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",
@@ -1101,6 +1159,68 @@ function createProjectReaderFileSystem(fileSystem) {
 		}
 	};
 }
+function createCaptureFileSystem(files) {
+	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() {},
+		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;
+}
+async function hasFullUamFidelity(document, project) {
+	const sourceFiles = /* @__PURE__ */ new Map();
+	const materializedFiles = /* @__PURE__ */ new Map();
+	try {
+		await Promise.all([new _openfairygui_core_project_io.ProjectWriter(createCaptureFileSystem(sourceFiles)).write(document, "Project.fairy"), new _openfairygui_core_project_io.ProjectWriter(createCaptureFileSystem(materializedFiles)).write((0, _openfairygui_core_uam.materializeUamProject)(project), "Project.fairy")]);
+	} catch {
+		return false;
+	}
+	return capturedFilesEqual(sourceFiles, materializedFiles);
+}
 var RuntimeService = class {
 	constructor(context, cacheService, eventService, jobService) {
 		this.context = context;
@@ -1135,7 +1255,8 @@ var RuntimeService = class {
 				canonicalPathKey
 			}));
 			await advisoryLock.close();
-			const project = (0, _openfairygui_core_uam.liftDocumentToUamProject)(await new _openfairygui_core_project_io.ProjectReader(createProjectReaderFileSystem(fileSystem)).read(fairyPath, { hydrateResourceBytes: true }));
+			const document = await new _openfairygui_core_project_io.ProjectReader(createProjectReaderFileSystem(fileSystem)).read(fairyPath, { hydrateResourceBytes: true });
+			const project = (0, _openfairygui_core_uam.liftDocumentToUamProject)(document);
 			const sessionId = randomId();
 			const session = {
 				sessionId,
@@ -1145,6 +1266,7 @@ var RuntimeService = class {
 				lockFilePath,
 				fileSystem,
 				project,
+				uamFidelity: await hasFullUamFidelity(document, project) ? "full" : "unsupported",
 				revision: 0,
 				lastSavedRevision: 0,
 				pendingStaleSourceFiles: /* @__PURE__ */ new Map(),
@@ -1203,6 +1325,7 @@ var RuntimeService = class {
 			lockFilePath: "",
 			fileSystem: storage?.fileSystem,
 			project: (0, _openfairygui_core_uam.normalizeUamProject)(input.project),
+			uamFidelity: "full",
 			revision: 0,
 			lastSavedRevision: 0,
 			pendingStaleSourceFiles: /* @__PURE__ */ new Map(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfairygui/backend",
-  "version": "0.2.0-alpha.14",
+  "version": "0.2.0-alpha.16",
   "description": "FairyGUI Headless Authoring SDK — stateful backend runtime and session services.",
   "author": "OpenFairyGUI Contributors",
   "license": "MIT",
@@ -52,8 +52,8 @@
     "runtime"
   ],
   "dependencies": {
-    "@openfairygui/functions": "0.2.0-alpha.14",
-    "@openfairygui/core": "0.2.0-alpha.14"
+    "@openfairygui/functions": "0.2.0-alpha.16",
+    "@openfairygui/core": "0.2.0-alpha.16"
   },
   "devDependencies": {
     "ava": "^7.0.0",

package/src/index.ts

@@ -1,13 +1,21 @@
 export {
-	BackendRuntime,
+	BACKEND_CAPABILITY_SCHEMA_VERSION,
+	BACKEND_COMPATIBILITY_POLICY,
+	BACKEND_CONTRACT_VERSION,
+	type BackendDiagnostic,
+	type BackendMessage,
+	type BackendResponseMeta,
+	type BackendStage,
+} from './contracts.js';
+export {
 	type AdvisoryLockConflictError,
 	type ApplySessionTransactionInput,
 	type BackendArtifactBridgeCapability,
 	type BackendCacheEntry,
 	type BackendCacheSnapshot,
+	type BackendCapabilities,
 	type BackendCapabilityManifest,
 	type BackendCapabilityUnavailableError,
-	type BackendCapabilities,
 	type BackendError,
 	type BackendEvent,
 	type BackendEventKind,
@@ -16,6 +24,7 @@ export {
 	type BackendFileStat,
 	type BackendFileSystem,
 	type BackendHostAdapter,
+	type BackendJobErrors,
 	type BackendJobKind,
 	type BackendJobListSnapshot,
 	type BackendJobListStatusFilter,
@@ -24,11 +33,12 @@ export {
 	type BackendJobProgress,
 	type BackendJobSnapshot,
 	type BackendJobStatus,
-	type BackendJobErrors,
+	type BackendProjectSessionStorage,
 	type BackendResult,
+	BackendRuntime,
+	type BackendRuntimeOptions,
 	type BackendSessionSnapshot,
 	type BackendSuccess,
-	type BackendRuntimeOptions,
 	type CacheRefreshFailedError,
 	type CancelJobInput,
 	type EventCursorInvalidError,
@@ -43,25 +53,16 @@ export {
 	type MaterializeValidationFailedError,
 	type MaterializeWriteFailedError,
 	type OpenProjectSessionInput,
-	type BackendProjectSessionStorage,
 	type RefreshCacheInput,
-	type SaveSessionInput,
 	type SavePartialFailureError,
+	type SaveSessionInput,
 	type SessionNotFoundError,
 	type SessionStaleWriteError,
+	type UamFidelityUnsupportedError,
 } from './runtime.js';
 export {
-	createBackendStorageFileSystem,
 	type BackendAsyncStorageAdapter,
 	type BackendStorageFileSystem,
 	type BackendStorageStatLike,
+	createBackendStorageFileSystem,
 } from './storage.js';
-export {
-	type BackendDiagnostic,
-	type BackendMessage,
-	type BackendResponseMeta,
-	type BackendStage,
-	BACKEND_CAPABILITY_SCHEMA_VERSION,
-	BACKEND_COMPATIBILITY_POLICY,
-	BACKEND_CONTRACT_VERSION,
-} from './contracts.js';

package/src/runtime.ts

@@ -181,6 +181,7 @@ export interface BackendSessionSnapshot {
 	revision: number;
 	lastSavedRevision: number;
 	dirty: boolean;
+	uamFidelity: 'full' | 'unsupported';
 	lockHeld: boolean;
 	capabilities: BackendCapabilities;
 }
@@ -255,6 +256,13 @@ export interface SavePartialFailureError {
 	diskMayBePartiallyUpdated: true;
 }
 
+export interface UamFidelityUnsupportedError {
+	code: 'uam_fidelity_unsupported';
+	message: string;
+	sessionId: string;
+	canonicalPathKey: string;
+}
+
 export interface MaterializeValidationFailedError {
 	code: 'materialize_validation_failed';
 	message: string;
@@ -458,6 +466,7 @@ export type BackendError =
 	| InProcessLockConflictError
 	| AdvisoryLockConflictError
 	| SavePartialFailureError
+	| UamFidelityUnsupportedError
 	| MaterializeValidationFailedError
 	| MaterializeWriteFailedError
 	| PathPolicyViolationError
@@ -704,12 +713,15 @@ export class BackendRuntime {
 		return this.authoringService.applyTransaction(input);
 	}
 
-	public async saveSession(input: SaveSessionInput): Promise<
+	public async saveSession(
+		input: SaveSessionInput,
+	): Promise<
 		BackendResult<
 			BackendSessionSnapshot | MaterializeSessionSnapshot,
 			| SessionNotFoundError
 			| SessionStaleWriteError
 			| SavePartialFailureError
+			| UamFidelityUnsupportedError
 			| MaterializeValidationFailedError
 			| MaterializeWriteFailedError
 			| PathPolicyViolationError
@@ -720,11 +732,14 @@ export class BackendRuntime {
 		return this.authoringService.saveSession(input);
 	}
 
-	public async materializeSession(input: MaterializeSessionInput): Promise<
+	public async materializeSession(
+		input: MaterializeSessionInput,
+	): Promise<
 		BackendResult<
 			MaterializeSessionSnapshot,
 			| SessionNotFoundError
 			| SessionStaleWriteError
+			| UamFidelityUnsupportedError
 			| MaterializeValidationFailedError
 			| MaterializeWriteFailedError
 			| PathPolicyViolationError