@openfairygui/functions 0.2.0-alpha.13 → 0.2.0-alpha.15

package/README.md

@@ -22,7 +22,7 @@ const report = inspect(doc);
 await publishNode({ document: doc, output: './release' });
 ```
 
-`publishNode` owns the standard Node filesystem, Sharp raster backend, and project plugin discovery. The root `publish()` export remains the lower-level capability-injected core for custom hosts.
+`publishNode` owns the standard Node filesystem, Sharp raster backend, and project plugin discovery. It fails when a complete runtime artifact cannot be generated. The root `publish()` export remains the lower-level capability-injected core for custom hosts; it is layout-only only when no output directory is requested.
 
 ## Browser LayaBox publish
 
@@ -50,9 +50,9 @@ Publish plugins are documented in the repository guide:
 
 - https://github.com/OpenFairyGUI/OpenFairyGUI/blob/main/docs/publish-plugins.md
 
-## Phase A UAM authoring seam
+## UAM authoring seam
 
-`@openfairygui/functions` also exposes a thin stateless wrapper over the Phase A UAM
+`@openfairygui/functions` also exposes a thin stateless wrapper over the UAM
 transaction contract from `@openfairygui/core`.
 
 This seam:
@@ -63,6 +63,14 @@ This seam:
 - does not define a second selector / operation grammar
 - does not wrap `publish` or `restore`
 
+The transaction surface includes resource rename/move, byte-backed binary resource
+add/replace/remove, and add/update/remove for `display`, `display2`, `look`, `xy`,
+`size`, `color`, `animation`, `text`, `icon`, and `fontSize` gears. Resource
+rename/move/replace/remove requires `sourceBytes`; opt in with
+`ProjectReader.read(path, { hydrateResourceBytes: true })` before lifting a project to
+UAM. Source bytes are written back with the project, and stale source files are removed
+only after all replacement content succeeds.
+
 ```ts
 import {
 	type UamProject,
@@ -70,7 +78,7 @@ import {
 } from '@openfairygui/core';
 import { applyUamTransactionApp } from '@openfairygui/functions';
 
-const project: UamProject = /* ... */;
+const project: UamProject = /* project read and lifted with hydrateResourceBytes */;
 const operations: UamTransactionOperation[] = [
 	{
 		kind: 'renameResource',

package/dist/{codegen-C7PPZrB3.d.cts → codegen-B8ZM1F4j.d.cts}

@@ -19,7 +19,8 @@ interface PublishOptions {
   fileExtension?: string;
   /**
    * Raster backend for atlas image compositing.
-   * If not provided, atlas packing only computes layout (no PNGs generated).
+   * Required when a filesystem-backed publish has packable resources.
+   * Without a filesystem, publish remains an explicit layout-only transform.
    */
   encoder?: AtlasRasterBackend;
   /**
@@ -37,8 +38,9 @@ interface PublishOptions {
   packages?: string[];
   /**
    * FileSystem abstraction for writing output files.
-   * Required for actual file output. Without it, only the Document model
-   * is updated (atlas layout computed, sprite nodes created).
+   * Required for actual file output. Calling publish with a resolved output
+   * directory but no filesystem is rejected; omit output entirely for a
+   * layout-only transform.
    */
   fs?: PublishFileSystem;
   /**
@@ -89,18 +91,17 @@ declare function resolvePublishOptions(doc: Document, overrides?: ResolvePublish
  * `publishNode()` or `publishBrowser()` through their dedicated entries.
  *
  * ```ts
- * import sharp from 'sharp';
- * const io = new NodeIO();
- * const doc = await io.readProject('./project.fairy');
+ * import { NodeIO } from '@openfairygui/core/node';
+ * import { publishNode } from '@openfairygui/functions/node';
+ * const doc = await new NodeIO().readProject('./project.fairy');
  *
- * await doc.transform(publish({
+ * await publishNode({
+ *   document: doc,
  *   output: './release/',
  *   compressed: true,
- *   encoder: sharp,
- *   basePath: './assets/',
+ *   assetsPath: './assets/',
  *   fileExtension: 'bytes',
- *   fs: io.createFileSystem(),
- * }));
+ * });
  * ```
  */
 declare function publish(options: PublishOptions): Transform;

package/dist/{codegen-CEnmtjBP.d.ts → codegen-CfbDHuFt.d.ts}

@@ -19,7 +19,8 @@ interface PublishOptions {
   fileExtension?: string;
   /**
    * Raster backend for atlas image compositing.
-   * If not provided, atlas packing only computes layout (no PNGs generated).
+   * Required when a filesystem-backed publish has packable resources.
+   * Without a filesystem, publish remains an explicit layout-only transform.
    */
   encoder?: AtlasRasterBackend;
   /**
@@ -37,8 +38,9 @@ interface PublishOptions {
   packages?: string[];
   /**
    * FileSystem abstraction for writing output files.
-   * Required for actual file output. Without it, only the Document model
-   * is updated (atlas layout computed, sprite nodes created).
+   * Required for actual file output. Calling publish with a resolved output
+   * directory but no filesystem is rejected; omit output entirely for a
+   * layout-only transform.
    */
   fs?: PublishFileSystem;
   /**
@@ -89,18 +91,17 @@ declare function resolvePublishOptions(doc: Document, overrides?: ResolvePublish
  * `publishNode()` or `publishBrowser()` through their dedicated entries.
  *
  * ```ts
- * import sharp from 'sharp';
- * const io = new NodeIO();
- * const doc = await io.readProject('./project.fairy');
+ * import { NodeIO } from '@openfairygui/core/node';
+ * import { publishNode } from '@openfairygui/functions/node';
+ * const doc = await new NodeIO().readProject('./project.fairy');
  *
- * await doc.transform(publish({
+ * await publishNode({
+ *   document: doc,
  *   output: './release/',
  *   compressed: true,
- *   encoder: sharp,
- *   basePath: './assets/',
+ *   assetsPath: './assets/',
  *   fileExtension: 'bytes',
- *   fs: io.createFileSystem(),
- * }));
+ * });
  * ```
  */
 declare function publish(options: PublishOptions): Transform;

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_publish = require("./publish-CtCXsMdj.cjs");
+const require_publish = require("./publish-D7268_u4.cjs");
 const require_uam_transaction = require("./uam-transaction.cjs");
 let _openfairygui_core = require("@openfairygui/core");
 //#region src/inspect.ts
@@ -393,10 +393,16 @@ const TRANSPARENT_PNG_1X1 = Uint8Array.from([
 	96,
 	130
 ]);
+function assertSafeRestoreSegment(value, label) {
+	if (!value || value === "." || value === ".." || value.includes("\0") || /[\\/:]/u.test(value)) throw new Error(`restore: Invalid ${label} "${value}".`);
+}
 function normalizeVirtualPath(path) {
-	const normalized = (path ?? "").replace(/\\/g, "/").trim();
-	if (!normalized || normalized === "/") return "";
-	return normalized.replace(/^\/+/, "").replace(/\/+$/, "");
+	const raw = (path ?? "").trim();
+	if (!raw || raw === "/") return "";
+	if (raw.includes("\0") || raw.startsWith("\\") || raw.startsWith("//") || /^[a-z]:/iu.test(raw)) throw new Error(`restore: Invalid resource path "${raw}".`);
+	const segments = raw.replace(/\\/g, "/").split("/").filter(Boolean);
+	if (segments.some((segment) => segment === "." || segment === ".." || segment.includes(":"))) throw new Error(`restore: Invalid resource path "${raw}".`);
+	return segments.join("/");
 }
 function resourceFileName(resource) {
 	return resource.getFileName?.() || resource.getFile?.() || resource.getName?.() || "";
@@ -580,44 +586,40 @@ function normalizeComparablePath(value) {
 	const joined = segments.join("/");
 	return (drivePrefix ? `${drivePrefix}/${joined}`.replace(/\/$/, "") : hasRoot ? `/${joined}`.replace(/\/$/, "") : joined || ".").toLowerCase();
 }
-function dirname(filePath) {
-	return trimTrailingSlashes(filePath).match(/^(.*)[/\\][^/\\]+$/)?.[1] ?? "";
+function isPathWithin(root, candidate) {
+	const normalizedRoot = normalizeComparablePath(root);
+	return normalizeComparablePath(candidate).startsWith(`${normalizedRoot}/`);
 }
 function basename(filePath) {
 	return trimTrailingSlashes(filePath).match(/([^/\\]+)$/)?.[1] ?? "";
 }
-function resolveOutputProjectPath(output, fs) {
-	if (/\.fairy$/i.test(output)) return output;
-	const normalizedOutput = trimTrailingSlashes(output);
-	const projectName = basename(normalizedOutput) || "Restored";
-	return fs.join(normalizedOutput, `${projectName}.fairy`);
+function normalizeRestoreOutputDir(output) {
+	const normalized = trimTrailingSlashes(output);
+	const name = basename(normalized);
+	if (!normalized || /\.fairy$/i.test(normalized) || !name || name === "." || name === ".." || /^[a-z]:$/iu.test(name)) throw new Error("restore: Output must be a non-root project directory, not a .fairy file.");
+	return normalized;
 }
-async function prepareRestoreOutputDir(inputDir, outputDir, outputProjectPath, fs, force, outputIsProjectFile) {
-	const [resolvedInputDir, resolvedOutputDir] = await Promise.all([Promise.resolve(fs.resolvePath(inputDir)), Promise.resolve(fs.resolvePath(outputDir))]);
-	if (normalizeComparablePath(resolvedInputDir) === normalizeComparablePath(resolvedOutputDir)) throw new Error("Restore output directory must be different from the published input directory.");
-	if (outputIsProjectFile) {
-		if (!await fs.exists(outputDir)) {
-			await fs.mkdir(outputDir);
-			return;
-		}
-		try {
-			await fs.readdir(outputDir);
-		} catch {
-			throw new Error(`Restore output path is not a directory: ${outputDir}`);
-		}
-		if (!await fs.exists(outputProjectPath)) return;
-		if (!force) throw new Error(`Restore output file already exists: ${outputProjectPath}. Use --force to overwrite it.`);
-		if (!fs.rm) throw new Error("Restore output file already exists and the provided fs does not support rm(...).");
-		await fs.rm(outputProjectPath, {
-			recursive: true,
-			force: true
-		});
-		return;
-	}
-	if (!await fs.exists(outputDir)) {
-		await fs.mkdir(outputDir);
-		return;
+function resolveOutputProjectPath(outputDir, fs) {
+	return fs.join(outputDir, `${basename(outputDir)}.fairy`);
+}
+async function resolvePathForContainment(filePath, fs) {
+	const missingSegments = [];
+	let existingPath = filePath;
+	while (!await fs.exists(existingPath)) {
+		const parentPath = fs.dirname(existingPath);
+		if (!parentPath || parentPath === existingPath) return Promise.resolve(fs.resolvePath(filePath));
+		missingSegments.unshift(basename(existingPath));
+		existingPath = parentPath;
 	}
+	const resolvedExistingPath = await Promise.resolve(fs.resolvePath(existingPath));
+	return missingSegments.reduce((resolvedPath, segment) => fs.join(resolvedPath, segment), resolvedExistingPath);
+}
+async function assertRestoreOutputDir(inputDir, outputDir, fs, force) {
+	const [resolvedInputDir, resolvedOutputDir] = await Promise.all([resolvePathForContainment(inputDir, fs), resolvePathForContainment(outputDir, fs)]);
+	const normalizedInputDir = normalizeComparablePath(resolvedInputDir);
+	const normalizedOutputDir = normalizeComparablePath(resolvedOutputDir);
+	if (normalizedInputDir === normalizedOutputDir || isPathWithin(normalizedInputDir, normalizedOutputDir) || isPathWithin(normalizedOutputDir, normalizedInputDir)) throw new Error("Restore output directory must be independent from the published input directory.");
+	if (!await fs.exists(outputDir)) return;
 	let entries;
 	try {
 		entries = await fs.readdir(outputDir);
@@ -626,23 +628,63 @@ async function prepareRestoreOutputDir(inputDir, outputDir, outputProjectPath, f
 	}
 	if (entries.length === 0) return;
 	if (!force) throw new Error(`Restore output directory is not empty: ${outputDir}. Use --force to overwrite it.`);
-	if (!fs.rm) throw new Error("Restore output directory is not empty and the provided fs does not support rm(...).");
-	await fs.rm(outputDir, {
-		recursive: true,
-		force: true
-	});
-	await fs.mkdir(outputDir);
+}
+async function createRestoreStagingDir(outputDir, fs) {
+	const parentDir = fs.dirname(outputDir) || ".";
+	await fs.mkdir(parentDir);
+	for (let attempt = 0; attempt < 8; attempt += 1) {
+		const stagingDir = fs.join(parentDir, `.${basename(outputDir)}.restore-${(0, _openfairygui_core.generateId)()}`);
+		if (await fs.exists(stagingDir)) continue;
+		await fs.mkdir(stagingDir);
+		return stagingDir;
+	}
+	throw new Error(`restore: Could not allocate a staging directory beside ${outputDir}.`);
+}
+async function commitRestoreOutput(stagingDir, outputDir, fs) {
+	if (!await fs.exists(outputDir)) {
+		await fs.rename(stagingDir, outputDir);
+		return null;
+	}
+	const parentDir = fs.dirname(outputDir) || ".";
+	let backupDir = "";
+	for (let attempt = 0; attempt < 8; attempt += 1) {
+		const candidate = fs.join(parentDir, `.${basename(outputDir)}.restore-backup-${(0, _openfairygui_core.generateId)()}`);
+		if (!await fs.exists(candidate)) {
+			backupDir = candidate;
+			break;
+		}
+	}
+	if (!backupDir) throw new Error(`restore: Could not allocate a backup directory beside ${outputDir}.`);
+	await fs.rename(outputDir, backupDir);
+	try {
+		await fs.rename(stagingDir, outputDir);
+	} catch (error) {
+		await fs.rename(backupDir, outputDir);
+		throw error;
+	}
+	try {
+		await fs.rm(backupDir, {
+			recursive: true,
+			force: true
+		});
+		return null;
+	} catch {
+		return `restore: Previous output retained at ${backupDir}; remove it after checking the restored project.`;
+	}
 }
 async function restore(options) {
 	const sourceDir = trimTrailingSlashes(options.inputDir);
-	const outputIsProjectFile = /\.fairy$/i.test(options.output);
-	const outputProjectPath = resolveOutputProjectPath(options.output, options.fs);
-	await prepareRestoreOutputDir(sourceDir, dirname(outputProjectPath) || ".", outputProjectPath, options.fs, options.force === true, outputIsProjectFile);
+	const outputDir = normalizeRestoreOutputDir(options.output);
+	const outputProjectPath = resolveOutputProjectPath(outputDir, options.fs);
+	await assertRestoreOutputDir(sourceDir, outputDir, options.fs, options.force === true);
 	const packageFilter = options.packages?.length ? new Set(options.packages) : null;
-	const candidateBinaryPaths = (await options.fs.readdir(sourceDir)).filter((name) => isPublishedBinaryFile(name)).filter((name) => !packageFilter || packageFilter.has(inferPackageName(name))).map((name) => options.fs.join(sourceDir, name)).sort((left, right) => left.localeCompare(right));
+	const binaryNames = (await options.fs.readdir(sourceDir)).filter((name) => isPublishedBinaryFile(name)).filter((name) => !packageFilter || packageFilter.has(inferPackageName(name)));
+	for (const binaryName of binaryNames) assertSafeRestoreSegment(binaryName, "published binary file name");
+	const candidateBinaryPaths = binaryNames.map((name) => options.fs.join(sourceDir, name)).sort((left, right) => left.localeCompare(right));
 	const binaryPaths = (await Promise.all(candidateBinaryPaths.map(async (filePath) => await options.fs.isFile(filePath) ? filePath : null))).filter((filePath) => !!filePath).sort((left, right) => left.localeCompare(right));
 	if (binaryPaths.length === 0) throw new Error(`No FairyGUI published binary files found in ${sourceDir}.`);
-	return new RestoreWorkflow(options.fs).restore({
+	const restorer = new RestoreWorkflow(options.fs);
+	const document = await restorer.prepare({
 		binaryPaths,
 		sourceDir,
 		outputProjectPath,
@@ -650,18 +692,45 @@ async function restore(options) {
 		cropImage: options.cropImage,
 		extractImage: options.extractImage
 	});
+	const stagingDir = await createRestoreStagingDir(outputDir, options.fs);
+	const stagingProjectPath = options.fs.join(stagingDir, basename(outputProjectPath));
+	const warnings = [];
+	try {
+		await restorer.write(document, {
+			binaryPaths,
+			sourceDir,
+			outputProjectPath: stagingProjectPath,
+			projectType: options.projectType,
+			cropImage: options.cropImage,
+			extractImage: options.extractImage
+		}, warnings);
+		const cleanupWarning = await commitRestoreOutput(stagingDir, outputDir, options.fs);
+		if (cleanupWarning) warnings.push(cleanupWarning);
+	} catch (error) {
+		await options.fs.rm(stagingDir, {
+			recursive: true,
+			force: true
+		}).catch(() => void 0);
+		throw error;
+	}
+	return {
+		document,
+		projectPath: outputProjectPath,
+		warnings
+	};
 }
 var RestoreWorkflow = class {
 	_fs;
 	constructor(fs) {
 		this._fs = fs;
 	}
-	async restore(options) {
-		const warnings = [];
+	async prepare(options) {
 		const doc = await new _openfairygui_core.BinaryReader(this._fs).readMany(options.binaryPaths);
+		this._assertDocumentPaths(doc);
 		this._initializeProjectDefaults(doc, options.projectType);
 		this._initializeImageFileNames(doc);
 		this._initializeLooseResourceFileNames(doc);
+		this._assertDocumentPaths(doc);
 		await this._synthesizeLooseSkeletonResources(doc, options.sourceDir);
 		this._initializeRestoredResourceRelations(doc);
 		this._initializePublishedFontTextureIds(doc);
@@ -670,13 +739,27 @@ var RestoreWorkflow = class {
 		this._initializePublishedTextFontResources(doc);
 		this._initializeDisplayObjectFileNames(doc);
 		this._initializePublishedFontDefaults(doc);
+		this._assertDocumentPaths(doc);
+		return doc;
+	}
+	async write(doc, options, warnings) {
 		await new _openfairygui_core.ProjectWriter(this._fs).write(doc, options.outputProjectPath);
 		await this._restoreAssets(doc, options, warnings);
-		return {
-			document: doc,
-			projectPath: options.outputProjectPath,
-			warnings
-		};
+	}
+	_assertDocumentPaths(doc) {
+		for (const pkg of doc.getRoot().listPackages()) {
+			assertSafeRestoreSegment(pkg.getName(), "package name");
+			assertSafeRestoreSegment(pkg.getPublishName() || pkg.getName(), "package publish name");
+			for (const resource of pkg.listResources()) {
+				normalizeVirtualPath(resource.getPath?.());
+				const branch = resource.getBranch?.() ?? "";
+				if (branch) assertSafeRestoreSegment(branch, "branch name");
+				const fileName = resourceFileName(resource);
+				if (fileName) assertSafeRestoreSegment(fileName, "resource file name");
+				const publishedFileName = resourcePublishedFileName(resource);
+				if (publishedFileName) assertSafeRestoreSegment(publishedFileName, "published resource file name");
+			}
+		}
 	}
 	_initializeProjectDefaults(doc, projectType) {
 		doc.getRoot().setProjectId((0, _openfairygui_core.generateId)()).setProjectType(projectType ?? _openfairygui_core.ProjectType.Unity).setVersion("3.0").setSettings({
@@ -1110,27 +1193,40 @@ var RestoreWorkflow = class {
 	}
 	_sourceFileCandidates(pkg, fileName, outputFileName = fileName) {
 		const publishName = pkg.getPublishName() || pkg.getName();
-		return Array.from(new Set([
+		assertSafeRestoreSegment(publishName, "package publish name");
+		assertSafeRestoreSegment(fileName, "published source file name");
+		assertSafeRestoreSegment(outputFileName, "published source file name");
+		const candidates = Array.from(new Set([
 			`${publishName}_${fileName}`,
 			fileName,
 			`${publishName}_${outputFileName}`,
 			outputFileName
 		]));
+		for (const candidate of candidates) assertSafeRestoreSegment(candidate, "published source file name");
+		return candidates;
 	}
 	async _resolveLooseSourceFile(pkg, sourceDir, outputFileName) {
 		const candidates = outputFileName.endsWith(".atlas") ? this._sourceFileCandidates(pkg, `${outputFileName}.txt`, outputFileName) : outputFileName.endsWith(".skel") ? this._sourceFileCandidates(pkg, `${outputFileName}.bytes`, outputFileName) : this._sourceFileCandidates(pkg, outputFileName);
 		return this._resolveSourceFile(sourceDir, candidates);
 	}
 	async _resolveSourceFile(sourceDir, candidates) {
+		const resolvedSourceDir = await Promise.resolve(this._fs.resolvePath(sourceDir));
 		for (const candidate of candidates) {
+			assertSafeRestoreSegment(candidate, "published source file name");
 			const sourcePath = this._fs.join(sourceDir, candidate);
-			if (await this._fs.isFile(sourcePath)) return sourcePath;
+			if (!await this._fs.isFile(sourcePath)) continue;
+			const resolvedSourcePath = await Promise.resolve(this._fs.resolvePath(sourcePath));
+			if (!isPathWithin(resolvedSourceDir, resolvedSourcePath)) throw new Error(`restore: Published source file resolves outside the input directory: ${candidate}.`);
+			return resolvedSourcePath;
 		}
 		return null;
 	}
 	_resourceOutputPath(outputProjectPath, pkg, resource, fileName) {
 		const basePath = this._fs.dirname(outputProjectPath);
 		const branch = resource.getBranch?.() ?? "";
+		assertSafeRestoreSegment(pkg.getName(), "package name");
+		if (branch) assertSafeRestoreSegment(branch, "branch name");
+		assertSafeRestoreSegment(fileName, "resource file name");
 		const assetsDir = branch ? `assets_${branch}` : "assets";
 		const virtualPath = normalizeVirtualPath(resource.getPath?.());
 		const pkgDir = this._fs.join(basePath, assetsDir, pkg.getName());

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import { a as AtlasRasterInput, c as AtlasRasterResolvedBuffer, d as PublishSourceFileSystem, i as AtlasRasterCompositeInput, l as PublishFileSystem, n as atlas, o as AtlasRasterMetadata, r as AtlasRasterBackend, s as AtlasRasterPipeline, t as AtlasOptions, u as PublishOutputFileSystem } from "./atlas-CHsu2Y8i.cjs";
-import { A as ResolvedPublishAtlasOptions, C as HasOptionalFont, D as RootProjectSettings, E as PublishDependency, M as publish, N as resolvePublishOptions, O as PublishOptions, S as ExtrasMap, T as HasOptionalUrl, _ as PluginManifest, a as PublishCodeGenerationOptions, b as CliCodeGenerationSettings, c as decodeText, d as resolvePackageCodegenPlan, f as CodeWriter, g as Plugin, h as MaybePromise, i as CodegenReferencedComponent, j as ResolvedPublishOptions, k as ResolvePublishOptionsOverrides, l as encodeText, m as LoadedPlugin, n as CodegenClass, o as ResolvedPackageCodegenPlan, p as ICodeWriterConfig, r as CodegenMember, s as buildCodegenClasses, t as AUTO_GENERATED_CODE_MARK, u as publishCodeGeneration, v as PluginModule, w as HasOptionalSrc, x as CliPublishSettings, y as CliAtlasSettings } from "./codegen-C7PPZrB3.cjs";
+import { A as ResolvedPublishAtlasOptions, C as HasOptionalFont, D as RootProjectSettings, E as PublishDependency, M as publish, N as resolvePublishOptions, O as PublishOptions, S as ExtrasMap, T as HasOptionalUrl, _ as PluginManifest, a as PublishCodeGenerationOptions, b as CliCodeGenerationSettings, c as decodeText, d as resolvePackageCodegenPlan, f as CodeWriter, g as Plugin, h as MaybePromise, i as CodegenReferencedComponent, j as ResolvedPublishOptions, k as ResolvePublishOptionsOverrides, l as encodeText, m as LoadedPlugin, n as CodegenClass, o as ResolvedPackageCodegenPlan, p as ICodeWriterConfig, r as CodegenMember, s as buildCodegenClasses, t as AUTO_GENERATED_CODE_MARK, u as publishCodeGeneration, v as PluginModule, w as HasOptionalSrc, x as CliPublishSettings, y as CliAtlasSettings } from "./codegen-B8ZM1F4j.cjs";
 import { ApplyUamTransactionAppDiagnostic, ApplyUamTransactionAppError, ApplyUamTransactionAppInput, ApplyUamTransactionAppResult, applyUamTransactionApp } from "./uam-transaction.cjs";
 import { Document, FileSystem, Transform } from "@openfairygui/core";
 
@@ -194,10 +194,11 @@ interface RestoreFileSystem extends Pick<FileSystem, 'readFile' | 'readFileRaw'
   readdir(path: string): Promise<string[]>;
   isFile(path: string): Promise<boolean>;
   resolvePath(path: string): string | Promise<string>;
-  rm?: (path: string, options?: {
+  rm(path: string, options?: {
     recursive?: boolean;
     force?: boolean;
-  }) => Promise<void>;
+  }): Promise<void>;
+  rename(from: string, to: string): Promise<void>;
 }
 interface RestoreOptions {
   inputDir: string;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { a as AtlasRasterInput, c as AtlasRasterResolvedBuffer, d as PublishSourceFileSystem, i as AtlasRasterCompositeInput, l as PublishFileSystem, n as atlas, o as AtlasRasterMetadata, r as AtlasRasterBackend, s as AtlasRasterPipeline, t as AtlasOptions, u as PublishOutputFileSystem } from "./atlas-CDn6TirX.js";
-import { A as ResolvedPublishAtlasOptions, C as HasOptionalFont, D as RootProjectSettings, E as PublishDependency, M as publish, N as resolvePublishOptions, O as PublishOptions, S as ExtrasMap, T as HasOptionalUrl, _ as PluginManifest, a as PublishCodeGenerationOptions, b as CliCodeGenerationSettings, c as decodeText, d as resolvePackageCodegenPlan, f as CodeWriter, g as Plugin, h as MaybePromise, i as CodegenReferencedComponent, j as ResolvedPublishOptions, k as ResolvePublishOptionsOverrides, l as encodeText, m as LoadedPlugin, n as CodegenClass, o as ResolvedPackageCodegenPlan, p as ICodeWriterConfig, r as CodegenMember, s as buildCodegenClasses, t as AUTO_GENERATED_CODE_MARK, u as publishCodeGeneration, v as PluginModule, w as HasOptionalSrc, x as CliPublishSettings, y as CliAtlasSettings } from "./codegen-CEnmtjBP.js";
+import { A as ResolvedPublishAtlasOptions, C as HasOptionalFont, D as RootProjectSettings, E as PublishDependency, M as publish, N as resolvePublishOptions, O as PublishOptions, S as ExtrasMap, T as HasOptionalUrl, _ as PluginManifest, a as PublishCodeGenerationOptions, b as CliCodeGenerationSettings, c as decodeText, d as resolvePackageCodegenPlan, f as CodeWriter, g as Plugin, h as MaybePromise, i as CodegenReferencedComponent, j as ResolvedPublishOptions, k as ResolvePublishOptionsOverrides, l as encodeText, m as LoadedPlugin, n as CodegenClass, o as ResolvedPackageCodegenPlan, p as ICodeWriterConfig, r as CodegenMember, s as buildCodegenClasses, t as AUTO_GENERATED_CODE_MARK, u as publishCodeGeneration, v as PluginModule, w as HasOptionalSrc, x as CliPublishSettings, y as CliAtlasSettings } from "./codegen-CfbDHuFt.js";
 import { ApplyUamTransactionAppDiagnostic, ApplyUamTransactionAppError, ApplyUamTransactionAppInput, ApplyUamTransactionAppResult, applyUamTransactionApp } from "./uam-transaction.js";
 import { Document, FileSystem, Transform } from "@openfairygui/core";
 
@@ -194,10 +194,11 @@ interface RestoreFileSystem extends Pick<FileSystem, 'readFile' | 'readFileRaw'
   readdir(path: string): Promise<string[]>;
   isFile(path: string): Promise<boolean>;
   resolvePath(path: string): string | Promise<string>;
-  rm?: (path: string, options?: {
+  rm(path: string, options?: {
     recursive?: boolean;
     force?: boolean;
-  }) => Promise<void>;
+  }): Promise<void>;
+  rename(from: string, to: string): Promise<void>;
 }
 interface RestoreOptions {
   inputDir: string;