@openfairygui/functions 0.2.0-alpha.19 → 0.2.0-alpha.20

package/dist/{codegen-CfbDHuFt.d.ts → restore-Dh0-Nvms.d.ts}

@@ -1,7 +1,7 @@
-import { l as PublishFileSystem, r as AtlasRasterBackend, t as AtlasOptions } from "./atlas-CDn6TirX.js";
-import { Component, Document, Package, ProjectSettings, PublishSettings, Transform } from "@openfairygui/core";
+import { l as PublishFileSystem, r as AtlasRasterBackend, t as AtlasOptions } from "./atlas-C6tbl7nn.js";
+import { Component, Document, FileSystem, Package, ProjectSettings, PublishSettings, Transform } from "@openfairygui/core";
 
-//#region src/publish.d.ts
+//#region src/publish/options.d.ts
 interface PublishOptions {
   /**
    * Output directory override for published files (.fui + atlas PNGs).
@@ -79,6 +79,8 @@ interface ResolvedPublishOptions {
  * while callers still provide environment-specific concerns such as fs/encoder/basePath.
  */
 declare function resolvePublishOptions(doc: Document, overrides?: ResolvePublishOptionsOverrides): ResolvedPublishOptions;
+//#endregion
+//#region src/publish.d.ts
 /**
  * Publishes a FairyGUI project.
  *
@@ -239,4 +241,48 @@ declare function buildCodegenClasses(doc: Document, pkg: Package, plan: Resolved
 declare function encodeText(value: string): Uint8Array;
 declare function decodeText(value: Uint8Array): string;
 //#endregion
-export { ResolvedPublishAtlasOptions as A, HasOptionalFont as C, RootProjectSettings as D, PublishDependency as E, publish as M, resolvePublishOptions as N, PublishOptions as O, ExtrasMap as S, HasOptionalUrl as T, PluginManifest as _, PublishCodeGenerationOptions as a, CliCodeGenerationSettings as b, decodeText as c, resolvePackageCodegenPlan as d, CodeWriter as f, Plugin as g, MaybePromise as h, CodegenReferencedComponent as i, ResolvedPublishOptions as j, ResolvePublishOptionsOverrides as k, encodeText as l, LoadedPlugin as m, CodegenClass as n, ResolvedPackageCodegenPlan as o, ICodeWriterConfig as p, CodegenMember as r, buildCodegenClasses as s, AUTO_GENERATED_CODE_MARK as t, publishCodeGeneration as u, PluginModule as v, HasOptionalSrc as w, CliPublishSettings as x, CliAtlasSettings as y };
+//#region src/restore.d.ts
+interface RestoreImageCropInput {
+  sourcePath: string;
+  outputPath: string;
+  left: number;
+  top: number;
+  width: number;
+  height: number;
+  rotated: boolean;
+  offsetX: number;
+  offsetY: number;
+  expectedWidth: number;
+  expectedHeight: number;
+}
+type RestoreImageCropper = (input: RestoreImageCropInput) => Promise<void>;
+type RestoreImageExtractInput = Omit<RestoreImageCropInput, 'outputPath'>;
+type RestoreImageExtractor = (input: RestoreImageExtractInput) => Promise<Uint8Array>;
+interface RestoreResult {
+  document: Document;
+  projectPath: string;
+  warnings: string[];
+}
+interface RestoreFileSystem extends Pick<FileSystem, 'readFile' | 'readFileRaw' | 'writeFile' | 'writeFileRaw' | 'mkdir' | 'exists' | 'join' | 'dirname'> {
+  readdir(path: string): Promise<string[]>;
+  isFile(path: string): Promise<boolean>;
+  resolvePath(path: string): string | Promise<string>;
+  rm(path: string, options?: {
+    recursive?: boolean;
+    force?: boolean;
+  }): Promise<void>;
+  rename(from: string, to: string): Promise<void>;
+}
+interface RestoreOptions {
+  inputDir: string;
+  output: string;
+  fs: RestoreFileSystem;
+  packages?: string[];
+  force?: boolean;
+  projectType?: number;
+  cropImage?: RestoreImageCropper;
+  extractImage?: RestoreImageExtractor;
+}
+declare function restore(options: RestoreOptions): Promise<RestoreResult>;
+//#endregion
+export { ExtrasMap as A, ResolvedPublishOptions as B, MaybePromise as C, CliAtlasSettings as D, PluginModule as E, RootProjectSettings as F, publish as I, PublishOptions as L, HasOptionalSrc as M, HasOptionalUrl as N, CliCodeGenerationSettings as O, PublishDependency as P, ResolvePublishOptionsOverrides as R, LoadedPlugin as S, PluginManifest as T, resolvePublishOptions as V, encodeText as _, RestoreImageExtractor as a, CodeWriter as b, restore as c, CodegenMember as d, CodegenReferencedComponent as f, decodeText as g, buildCodegenClasses as h, RestoreImageExtractInput as i, HasOptionalFont as j, CliPublishSettings as k, AUTO_GENERATED_CODE_MARK as l, ResolvedPackageCodegenPlan as m, RestoreImageCropInput as n, RestoreOptions as o, PublishCodeGenerationOptions as p, RestoreImageCropper as r, RestoreResult as s, RestoreFileSystem as t, CodegenClass as u, publishCodeGeneration as v, Plugin as w, ICodeWriterConfig as x, resolvePackageCodegenPlan as y, ResolvedPublishAtlasOptions as z };

package/dist/web.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_publish = require("./publish-D7268_u4.cjs");
+const require_publish = require("./publish-xFWT9Slz.cjs");
 let _openfairygui_core = require("@openfairygui/core");
-//#region src/adapters/web/publish.ts
+//#region src/adapters/web/raster.ts
 function getBrowserContext(canvas) {
 	const context = canvas.getContext("2d");
 	if (!context) throw new Error("publishBrowser: a 2D canvas context is unavailable.");
@@ -169,6 +169,8 @@ function createBrowserImageEncoder(sourceFileSystem, outputFileSystem) {
 		return new BrowserImagePipeline(typeof input === "string" ? sourceFileSystem.readFileRaw(input).then((bytes) => decodeRaster(bytes, imageMimeType(input))) : input instanceof Uint8Array ? decode(input) : Promise.resolve(createRaster(input.create.width, input.create.height, input.create.background)), decode, outputFileSystem.writeFileRaw);
 	};
 }
+//#endregion
+//#region src/adapters/web/publish.ts
 function createTrackingFileSystem(fileSystem, files) {
 	return {
 		join: (...paths) => fileSystem.join(...paths),

package/dist/web.d.ts

@@ -1,4 +1,4 @@
-import { d as PublishSourceFileSystem, t as AtlasOptions, u as PublishOutputFileSystem } from "./atlas-CDn6TirX.js";
+import { d as PublishSourceFileSystem, t as AtlasOptions, u as PublishOutputFileSystem } from "./atlas-C6tbl7nn.js";
 import { Document } from "@openfairygui/core";
 
 //#region src/adapters/web/publish.d.ts

package/dist/web.js

@@ -1,6 +1,6 @@
-import { t as publish } from "./publish-DsPK0SJ1.js";
+import { t as publish } from "./publish-BJ_eelME.js";
 import { ProjectType } from "@openfairygui/core";
-//#region src/adapters/web/publish.ts
+//#region src/adapters/web/raster.ts
 function getBrowserContext(canvas) {
 	const context = canvas.getContext("2d");
 	if (!context) throw new Error("publishBrowser: a 2D canvas context is unavailable.");
@@ -168,6 +168,8 @@ function createBrowserImageEncoder(sourceFileSystem, outputFileSystem) {
 		return new BrowserImagePipeline(typeof input === "string" ? sourceFileSystem.readFileRaw(input).then((bytes) => decodeRaster(bytes, imageMimeType(input))) : input instanceof Uint8Array ? decode(input) : Promise.resolve(createRaster(input.create.width, input.create.height, input.create.background)), decode, outputFileSystem.writeFileRaw);
 	};
 }
+//#endregion
+//#region src/adapters/web/publish.ts
 function createTrackingFileSystem(fileSystem, files) {
 	return {
 		join: (...paths) => fileSystem.join(...paths),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfairygui/functions",
-  "version": "0.2.0-alpha.19",
+  "version": "0.2.0-alpha.20",
   "description": "FairyGUI Headless Authoring SDK — composable transform functions.",
   "author": "OpenFairyGUI Contributors",
   "license": "MIT",
@@ -74,7 +74,10 @@
   ],
   "dependencies": {
     "jiti": "^2.6.1",
-    "@openfairygui/core": "0.2.0-alpha.19"
+    "@openfairygui/core": "0.2.0-alpha.20"
+  },
+  "optionalDependencies": {
+    "sharp": ">=0.33.0"
   },
   "devDependencies": {
     "ava": "^7.0.0",

package/src/adapters/node/restore.ts

@@ -0,0 +1,187 @@
+import type {
+	RestoreFileSystem,
+	RestoreImageCropInput,
+	RestoreImageCropper,
+	RestoreImageExtractInput,
+	RestoreImageExtractor,
+	RestoreOptions,
+	RestoreResult,
+} from '../../restore.js';
+import { restore } from '../../restore.js';
+
+const importNative = new Function('id', 'return import(id)') as <T>(id: string) => Promise<T>;
+
+interface RestoreImageProcessors {
+	cropImage: RestoreImageCropper;
+	extractImage: RestoreImageExtractor;
+}
+
+export interface RestoreNodeOptions extends Omit<RestoreOptions, 'fs' | 'cropImage' | 'extractImage'> {}
+
+async function createNodeRestoreFileSystem(): Promise<RestoreFileSystem> {
+	const [fs, path] = await Promise.all([
+		importNative<typeof import('node:fs/promises')>('node:fs/promises'),
+		importNative<typeof import('node:path')>('node:path'),
+	]);
+	return {
+		async readFile(filePath: string): Promise<string> {
+			return fs.readFile(filePath, 'utf-8');
+		},
+		async readFileRaw(filePath: string): Promise<Uint8Array> {
+			const buffer = await fs.readFile(filePath);
+			return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+		},
+		async writeFile(filePath: string, content: string): Promise<void> {
+			await fs.mkdir(path.dirname(filePath), { recursive: true });
+			await fs.writeFile(filePath, content, 'utf-8');
+		},
+		async writeFileRaw(filePath: string, data: Uint8Array): Promise<void> {
+			await fs.mkdir(path.dirname(filePath), { recursive: true });
+			await fs.writeFile(filePath, data);
+		},
+		async mkdir(dirPath: string): Promise<void> {
+			await fs.mkdir(dirPath, { recursive: true });
+		},
+		async readdir(dirPath: string): Promise<string[]> {
+			return fs.readdir(dirPath);
+		},
+		async exists(filePath: string): Promise<boolean> {
+			try {
+				await fs.access(filePath);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		async isFile(filePath: string): Promise<boolean> {
+			try {
+				return (await fs.stat(filePath)).isFile();
+			} catch {
+				return false;
+			}
+		},
+		async resolvePath(filePath: string): Promise<string> {
+			try {
+				return await fs.realpath(filePath);
+			} catch {
+				return path.resolve(filePath);
+			}
+		},
+		async rm(targetPath: string, options?: { recursive?: boolean; force?: boolean }): Promise<void> {
+			await fs.rm(targetPath, {
+				recursive: options?.recursive ?? false,
+				force: options?.force ?? false,
+			});
+		},
+		async rename(from: string, to: string): Promise<void> {
+			await fs.rename(from, to);
+		},
+		join(...paths: string[]): string {
+			return path.join(...paths);
+		},
+		dirname(filePath: string): string {
+			return path.dirname(filePath);
+		},
+	};
+}
+
+async function createRestoreImageProcessors(): Promise<RestoreImageProcessors> {
+	let sharp: any;
+	try {
+		const loaded = await importNative<any>('sharp');
+		sharp = loaded.default ?? loaded;
+	} catch {
+		throw new Error('restoreNode: Sharp is required to crop atlas images. Install sharp before restoring.');
+	}
+
+	async function extractImage(input: RestoreImageExtractInput): Promise<Uint8Array> {
+		const targetPath = (input as RestoreImageCropInput).outputPath ?? input.sourcePath;
+		let image = sharp(input.sourcePath).extract({
+			left: input.left,
+			top: input.top,
+			width: input.width,
+			height: input.height,
+		});
+		if (input.rotated) image = image.rotate(90);
+		const { data, info } = await image.png().toBuffer({ resolveWithObject: true });
+		const needsOriginalCanvas =
+			input.expectedWidth > 0 &&
+			input.expectedHeight > 0 &&
+			(input.offsetX !== 0 ||
+				input.offsetY !== 0 ||
+				info.width !== input.expectedWidth ||
+				info.height !== input.expectedHeight);
+
+		if (needsOriginalCanvas) {
+			if (
+				input.offsetX < 0 ||
+				input.offsetY < 0 ||
+				input.offsetX + info.width > input.expectedWidth ||
+				input.offsetY + info.height > input.expectedHeight
+			) {
+				throw new Error(
+					`restore: Cropped image does not fit original canvas for ${targetPath}: ` +
+						`crop ${info.width}x${info.height} at ${input.offsetX},${input.offsetY}, ` +
+						`canvas ${input.expectedWidth}x${input.expectedHeight}`,
+				);
+			}
+			const composed = await sharp({
+				create: {
+					width: input.expectedWidth,
+					height: input.expectedHeight,
+					channels: 4,
+					background: { r: 0, g: 0, b: 0, alpha: 0 },
+				},
+			})
+				.composite([{ input: data, left: input.offsetX, top: input.offsetY }])
+				.png()
+				.toBuffer({ resolveWithObject: true });
+			if (
+				composed.info.width !== input.expectedWidth ||
+				composed.info.height !== input.expectedHeight
+			) {
+				throw new Error(
+					`restore: Cropped image size mismatch for ${targetPath}: ` +
+						`expected ${input.expectedWidth}x${input.expectedHeight}, ` +
+						`got ${composed.info.width}x${composed.info.height}`,
+				);
+			}
+			return composed.data;
+		}
+
+		if (
+			input.expectedWidth > 0 &&
+			input.expectedHeight > 0 &&
+			(info.width !== input.expectedWidth || info.height !== input.expectedHeight)
+		) {
+			throw new Error(
+				`restore: Cropped image size mismatch for ${targetPath}: ` +
+					`expected ${input.expectedWidth}x${input.expectedHeight}, got ${info.width}x${info.height}`,
+			);
+		}
+		return data;
+	}
+
+	const fs = await importNative<typeof import('node:fs/promises')>('node:fs/promises');
+	const path = await importNative<typeof import('node:path')>('node:path');
+	return {
+		extractImage,
+		cropImage: async (input: RestoreImageCropInput): Promise<void> => {
+			await fs.mkdir(path.dirname(input.outputPath), { recursive: true });
+			await fs.writeFile(input.outputPath, await extractImage(input));
+		},
+	};
+}
+
+/** Restore trusted local published artifacts through the standard Node host adapter. */
+export async function restoreNode(options: RestoreNodeOptions): Promise<RestoreResult> {
+	const [fs, imageProcessors] = await Promise.all([
+		createNodeRestoreFileSystem(),
+		createRestoreImageProcessors(),
+	]);
+	return restore({
+		...options,
+		fs,
+		...imageProcessors,
+	});
+}

package/src/adapters/web/publish.ts

@@ -2,14 +2,11 @@ import { type Document, type ILogger, ProjectType } from '@openfairygui/core';
 import type { AtlasOptions } from '../../atlas.js';
 import { publish } from '../../publish.js';
 import type {
-	AtlasRasterBackend,
-	AtlasRasterInput,
-	AtlasRasterPipeline,
-	AtlasRasterResolvedBuffer,
 	PublishFileSystem,
 	PublishOutputFileSystem,
 	PublishSourceFileSystem,
 } from '../../publish/contracts.js';
+import { assertBrowserImageSupport, createBrowserImageEncoder } from './raster.js';
 
 export type BrowserPublishProjectType = 'layabox';
 
@@ -58,249 +55,6 @@ export interface BrowserPublishResult {
 	diagnostics: BrowserPublishDiagnostic[];
 }
 
-type BrowserCanvas = OffscreenCanvas | HTMLCanvasElement;
-
-interface BrowserContext {
-	clearRect(x: number, y: number, width: number, height: number): void;
-	drawImage(image: CanvasImageSource, dx: number, dy: number): void;
-	drawImage(image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
-	drawImage(
-		image: CanvasImageSource,
-		sx: number,
-		sy: number,
-		sw: number,
-		sh: number,
-		dx: number,
-		dy: number,
-		dw: number,
-		dh: number,
-	): void;
-	fillRect(x: number, y: number, width: number, height: number): void;
-	getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
-	rotate(angle: number): void;
-	restore(): void;
-	save(): void;
-	translate(x: number, y: number): void;
-	fillStyle: string | CanvasGradient | CanvasPattern;
-}
-
-interface BrowserRaster {
-	canvas: BrowserCanvas;
-	width: number;
-	height: number;
-}
-
-function getBrowserContext(canvas: BrowserCanvas): BrowserContext {
-	const context = canvas.getContext('2d');
-	if (!context) throw new Error('publishBrowser: a 2D canvas context is unavailable.');
-	return context as unknown as BrowserContext;
-}
-
-function createBrowserCanvas(width: number, height: number): BrowserCanvas {
-	if (typeof OffscreenCanvas !== 'undefined') return new OffscreenCanvas(width, height);
-	if (typeof globalThis.document === 'undefined') {
-		throw new Error('publishBrowser: OffscreenCanvas or a DOM canvas is required for atlas PNG generation.');
-	}
-	const canvas = globalThis.document.createElement('canvas');
-	canvas.width = width;
-	canvas.height = height;
-	return canvas;
-}
-
-function assertBrowserImageSupport(): void {
-	if (typeof createImageBitmap !== 'function') {
-		throw new Error('publishBrowser: createImageBitmap is required for atlas PNG generation.');
-	}
-	if (typeof OffscreenCanvas === 'undefined' && typeof globalThis.document === 'undefined') {
-		throw new Error('publishBrowser: OffscreenCanvas or a DOM canvas is required for atlas PNG generation.');
-	}
-}
-
-function createRaster(
-	width: number,
-	height: number,
-	background?: { r: number; g: number; b: number; alpha: number },
-): BrowserRaster {
-	const canvas = createBrowserCanvas(width, height);
-	const context = getBrowserContext(canvas);
-	context.clearRect(0, 0, width, height);
-	if (background && background.alpha > 0) {
-		context.fillStyle = `rgba(${background.r}, ${background.g}, ${background.b}, ${background.alpha})`;
-		context.fillRect(0, 0, width, height);
-	}
-	return { canvas, width, height };
-}
-
-function imageMimeType(path: string): string {
-	if (/\.svg$/iu.test(path)) return 'image/svg+xml';
-	if (/\.jpe?g$/iu.test(path)) return 'image/jpeg';
-	if (/\.webp$/iu.test(path)) return 'image/webp';
-	if (/\.gif$/iu.test(path)) return 'image/gif';
-	return 'image/png';
-}
-
-function imageMimeTypeFromBytes(bytes: Uint8Array): string {
-	if (bytes[0] === 0xff && bytes[1] === 0xd8) return 'image/jpeg';
-	if (bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46) return 'image/gif';
-	if (bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x46) return 'image/webp';
-	return 'image/png';
-}
-
-async function canvasToPng(canvas: BrowserCanvas): Promise<Uint8Array> {
-	let blob: Blob;
-	if ('convertToBlob' in canvas && typeof canvas.convertToBlob === 'function') {
-		blob = await canvas.convertToBlob({ type: 'image/png' });
-	} else {
-		blob = await new Promise<Blob>((resolve, reject) => {
-			(canvas as HTMLCanvasElement).toBlob((value) => {
-				if (value) resolve(value);
-				else reject(new Error('publishBrowser: canvas PNG encoding failed.'));
-			}, 'image/png');
-		});
-	}
-	return new Uint8Array(await blob.arrayBuffer());
-}
-
-async function decodeRaster(bytes: Uint8Array, mimeType: string): Promise<BrowserRaster> {
-	if (typeof createImageBitmap !== 'function') {
-		throw new Error('publishBrowser: createImageBitmap is required for atlas PNG generation.');
-	}
-	const copy = bytes.slice();
-	const bitmap = await createImageBitmap(new Blob([copy.buffer as ArrayBuffer], { type: mimeType }));
-	try {
-		const raster = createRaster(bitmap.width, bitmap.height);
-		getBrowserContext(raster.canvas).drawImage(bitmap, 0, 0);
-		return raster;
-	} finally {
-		bitmap.close();
-	}
-}
-
-class BrowserImagePipeline implements AtlasRasterPipeline {
-	private rawOutput = false;
-
-	constructor(
-		private raster: Promise<BrowserRaster>,
-		private readonly decode: (bytes: Uint8Array) => Promise<BrowserRaster>,
-		private readonly write: (path: string, data: Uint8Array) => Promise<void>,
-	) {}
-
-	ensureAlpha(): this {
-		return this;
-	}
-
-	resize(options: { width: number; height: number; fit?: 'fill' }): this {
-		this.raster = this.raster.then((source) => {
-			const target = createRaster(options.width, options.height);
-			getBrowserContext(target.canvas).drawImage(source.canvas, 0, 0, options.width, options.height);
-			return target;
-		});
-		return this;
-	}
-
-	raw(): this {
-		this.rawOutput = true;
-		return this;
-	}
-
-	extract(options: { left: number; top: number; width: number; height: number }): this {
-		this.raster = this.raster.then((source) => {
-			const target = createRaster(options.width, options.height);
-			getBrowserContext(target.canvas).drawImage(
-				source.canvas,
-				options.left,
-				options.top,
-				options.width,
-				options.height,
-				0,
-				0,
-				options.width,
-				options.height,
-			);
-			return target;
-		});
-		return this;
-	}
-
-	png(): this {
-		this.rawOutput = false;
-		return this;
-	}
-
-	rotate(angle: number): this {
-		this.raster = this.raster.then((source) => {
-			if (angle % 180 === 0) return source;
-			const target = createRaster(source.height, source.width);
-			const context = getBrowserContext(target.canvas);
-			context.save();
-			if (angle === 270 || angle === -90) {
-				context.translate(0, source.width);
-				context.rotate(-Math.PI / 2);
-			} else {
-				context.translate(source.height, 0);
-				context.rotate(Math.PI / 2);
-			}
-			context.drawImage(source.canvas, 0, 0);
-			context.restore();
-			return target;
-		});
-		return this;
-	}
-
-	composite(inputs: Array<{ input: Uint8Array; left: number; top: number }>): this {
-		this.raster = this.raster.then(async (target) => {
-			const context = getBrowserContext(target.canvas);
-			for (const input of inputs) {
-				const source = await this.decode(input.input);
-				context.drawImage(source.canvas, input.left, input.top);
-			}
-			return target;
-		});
-		return this;
-	}
-
-	async metadata(): Promise<{ width: number; height: number; channels: number; hasAlpha: boolean }> {
-		const raster = await this.raster;
-		return { width: raster.width, height: raster.height, channels: 4, hasAlpha: true };
-	}
-
-	async toBuffer(options: { resolveWithObject: true }): Promise<AtlasRasterResolvedBuffer>;
-	async toBuffer(options?: { resolveWithObject?: false }): Promise<Uint8Array>;
-	async toBuffer(options?: { resolveWithObject?: boolean }): Promise<Uint8Array | AtlasRasterResolvedBuffer> {
-		const raster = await this.raster;
-		if (options?.resolveWithObject) {
-			const data = getBrowserContext(raster.canvas).getImageData(0, 0, raster.width, raster.height).data;
-			return { data: new Uint8Array(data), info: { width: raster.width, height: raster.height, channels: 4 } };
-		}
-		if (this.rawOutput)
-			return new Uint8Array(
-				getBrowserContext(raster.canvas).getImageData(0, 0, raster.width, raster.height).data,
-			);
-		return canvasToPng(raster.canvas);
-	}
-
-	async toFile(path: string): Promise<void> {
-		const raster = await this.raster;
-		await this.write(path, await canvasToPng(raster.canvas));
-	}
-}
-
-function createBrowserImageEncoder(
-	sourceFileSystem: BrowserPublishSourceFileSystem,
-	outputFileSystem: PublishFileSystem,
-): AtlasRasterBackend {
-	const decode = (bytes: Uint8Array) => decodeRaster(bytes, imageMimeTypeFromBytes(bytes));
-	return (input: AtlasRasterInput): BrowserImagePipeline => {
-		const raster =
-			typeof input === 'string'
-				? sourceFileSystem.readFileRaw(input).then((bytes) => decodeRaster(bytes, imageMimeType(input)))
-				: input instanceof Uint8Array
-					? decode(input)
-					: Promise.resolve(createRaster(input.create.width, input.create.height, input.create.background));
-		return new BrowserImagePipeline(raster, decode, outputFileSystem.writeFileRaw);
-	};
-}
-
 function createTrackingFileSystem(
 	fileSystem: BrowserPublishOutputFileSystem,
 	files: Map<string, number>,