@wasmedia/wenblend 0.1.0

package/src/filesystem.ts

@@ -0,0 +1,85 @@
+/**
+ * MEMFS staging for N-input invocations.
+ *
+ * Enblend is N inputs to one output, so every call stages a set of files
+ * into a per-invocation directory and sweeps the whole directory
+ * afterwards. Nothing persists between calls.
+ */
+
+import type { WasmModule, InputImage } from "./types.js";
+
+let counter = 0;
+
+export function toBytes(data: Uint8Array | ArrayBuffer): Uint8Array {
+  return data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+}
+
+/** A fresh, unique work directory path. Unique naming ensures no collisions across invocations. */
+export function nextWorkDirName(): string {
+  return `/work-${Date.now().toString(36)}-${(counter++).toString(36)}`;
+}
+
+/** Create a unique work directory. */
+export function createWorkDir(module: WasmModule): string {
+  const dir = nextWorkDirName();
+  module.FS.mkdir(dir);
+  return dir;
+}
+
+/**
+ * Write each input into the work directory under its caller-chosen name.
+ *
+ * Returns the set of input names so `collectOutputs` can tell the tool's
+ * output from what we put there.
+ */
+export function stageInputs(
+  module: WasmModule,
+  workDir: string,
+  inputs: InputImage[],
+): Set<string> {
+  const names = new Set<string>();
+  for (const { name, data } of inputs) {
+    module.FS.writeFile(`${workDir}/${name}`, toBytes(data));
+    names.add(name);
+  }
+  return names;
+}
+
+/** Read back everything in the work directory that was not staged as an input. */
+export function collectOutputs(
+  module: WasmModule,
+  workDir: string,
+  inputNames: Set<string>,
+): Map<string, Uint8Array> {
+  const outputs = new Map<string, Uint8Array>();
+  for (const entry of module.FS.readdir(workDir)) {
+    if (entry === "." || entry === "..") continue;
+    if (inputNames.has(entry)) continue;
+    outputs.set(entry, module.FS.readFile(`${workDir}/${entry}`));
+  }
+  return outputs;
+}
+
+/** Remove every file in the work directory, then the directory itself. */
+export function cleanWorkDir(module: WasmModule, workDir: string): void {
+  for (const entry of module.FS.readdir(workDir)) {
+    if (entry === "." || entry === "..") continue;
+    const path = `${workDir}/${entry}`;
+    try {
+      module.FS.unlink(path);
+    } catch {
+      // Entry might be a directory. Attempt rmdir as fallback; continue
+      // either way to ensure the whole directory is swept as defense-in-depth.
+      try {
+        module.FS.rmdir(path);
+      } catch {
+        // Best effort: one bad entry must not abort the sweep.
+      }
+    }
+  }
+  try {
+    module.FS.rmdir(workDir);
+  } catch {
+    // Best effort: work directory cleanup failure does not abort.
+  }
+}

package/src/handler.ts

@@ -0,0 +1,112 @@
+/**
+ * The worker's message handler and its scope test, with NO import-time
+ * side effects.
+ *
+ * This module is what the package's main entry (`src/index.ts`) re-exports.
+ * It must never register anything when imported: a consumer who writes
+ * their own Web Worker and does `import { blend } from "@wasmedia/wenblend"`
+ * inside it would otherwise get our `message` listener attached to THEIR
+ * worker, and any of their own messages carrying an `images` array would
+ * run a blend or fuse they never asked for. Registration lives only in
+ * `src/worker.ts`, the package's dedicated `./worker` entry.
+ */
+
+import type { BlendOptions, FuseOptions, FileInput, OutputDir, WrittenFile } from "./types.js";
+import { runOperation, type ImageInput } from "./operations.js";
+import { isFileInput } from "./staging.js";
+
+export interface WorkerRequest {
+  id: string;
+  op: "blend" | "fuse";
+  images: ImageInput[] | FileInput[];
+  options?: (BlendOptions | FuseOptions) & { outputDir?: OutputDir };
+  /** Where file mode loads @wasmedia/wopfs from; see LoaderOptions.wopfsPath. */
+  wopfsPath?: string;
+}
+
+export interface WorkerResponse {
+  id: string;
+  ok: boolean;
+  result?: Uint8Array | WrittenFile;
+  error?: { name: string; message: string; stderr?: string; exitCode?: number };
+}
+
+const OPS = { blend: "enblend", fuse: "enfuse" } as const;
+
+/**
+ * Handle one request. Never throws and never rejects: worker.ts posts
+ * whatever this resolves to, so a throw would leave the caller waiting for a
+ * reply that never comes. Messages arrive untyped at runtime, so nothing
+ * about `request` is trusted — not its shape, not its `op`.
+ */
+export async function handleMessage(request: WorkerRequest): Promise<WorkerResponse> {
+  // Echo the caller's id unchanged, whatever its runtime type: it exists only
+  // so the caller can correlate the reply. Plain-JS callers may use numbers.
+  const id = typeof request === "object" && request !== null ? request.id : "";
+  try {
+    if (typeof request !== "object" || request === null) {
+      return { id, ok: false, error: { name: "Error", message: "invalid request" } };
+    }
+    // Route only the two ops we know; anything else is rejected rather than
+    // quietly run as one of the tools. Only a string can name one, so a
+    // non-string op (which could carry a throwing toString) never reaches
+    // the lookup.
+    const opName = request.op;
+    const op = typeof opName === "string" && Object.hasOwn(OPS, opName) ? OPS[opName] : undefined;
+    if (!op) {
+      const shown = typeof opName === "string" ? `"${opName}"` : typeof opName;
+      return { id, ok: false, error: { name: "Error", message: `unknown op ${shown}` } };
+    }
+    if (request.wopfsPath !== undefined && typeof request.wopfsPath !== "string") {
+      return { id, ok: false, error: { name: "Error", message: "wopfsPath must be a string" } };
+    }
+    // Check if file mode is requested: all images are FileInputs
+    const imagesArray = Array.isArray(request.images) ? request.images : [];
+    const isFileMode = imagesArray.length > 0 && imagesArray.every(isFileInput);
+    if (isFileMode && !request.options?.outputDir) {
+      return { id, ok: false, error: { name: "Error", message: "file mode requires options.outputDir" } };
+    }
+    const result = await runOperation(op, request.images, request.options, { wopfsPath: request.wopfsPath });
+    return { id, ok: true, result };
+  } catch (e: unknown) {
+    const { stderr, exitCode } = (e ?? {}) as { stderr?: unknown; exitCode?: unknown };
+    return {
+      id,
+      ok: false,
+      error: {
+        name: e instanceof Error ? e.name : "Error",
+        message: e instanceof Error ? e.message : String(e),
+        stderr: typeof stderr === "string" ? stderr : undefined,
+        // Error instances do not survive postMessage as themselves, so the
+        // exit code has to travel as plain data or the caller loses it.
+        exitCode: typeof exitCode === "number" ? exitCode : undefined,
+      },
+    };
+  }
+}
+
+/**
+ * True only inside an actual dedicated/shared/service worker.
+ *
+ * `typeof self !== "undefined"` is NOT a worker test: on a browser main
+ * thread `self === window`, and `window.postMessage` is a perfectly
+ * ordinary function, so a guard built on those two checks alone is true
+ * on every web page, not just inside a worker. Importing the dedicated
+ * `./worker` entry (`src/worker.ts`) would then attach a `message`
+ * listener to `window` on any ordinary page and treat arbitrary
+ * postMessage traffic (other scripts, extensions, iframes) as a
+ * WorkerRequest.
+ *
+ * `WorkerGlobalScope` only exists as a global inside a worker context,
+ * and `self` is an instance of it there. Both `typeof` checks are
+ * ordered so the `instanceof` is only reached once both globals are
+ * confirmed to exist, so this can never throw — including in plain
+ * Node, which has neither global.
+ */
+export function isWorkerScope(): boolean {
+  return (
+    typeof WorkerGlobalScope !== "undefined" &&
+    typeof self !== "undefined" &&
+    self instanceof WorkerGlobalScope
+  );
+}

package/src/index.ts

@@ -0,0 +1,41 @@
+/**
+ * wenblend — Enblend and Enfuse compiled to WebAssembly.
+ *
+ * @example
+ * ```typescript
+ * import { blend } from "@wasmedia/wenblend";
+ *
+ * // Inputs must be RGBA TIFFs carrying correct XPosition/YPosition tags.
+ * const panorama = await blend([left, right]);
+ * ```
+ */
+
+export { blend, fuse, normalizeInputs, runOperation, type ImageInput } from "./operations.js";
+export { enblend, enfuse, runTool } from "./cli.js";
+export {
+  createInstance,
+  loadFactory,
+  type Tool,
+  type ModuleFactory,
+  type InstanceHooks,
+} from "./loader.js";
+export { handleMessage, isWorkerScope, type WorkerRequest, type WorkerResponse } from "./handler.js";
+export {
+  EnblendError,
+  OutOfMemoryError,
+  type WasmModule,
+  type EmscriptenFS,
+  type FSStat,
+  type CLIResult,
+  type FileInput,
+  type OutputDir,
+  type WrittenFile,
+  type CLIFileResult,
+  type FileModeOptions,
+  type InputImage,
+  type BlendOptions,
+  type FuseOptions,
+  type CommonOptions,
+  type LoaderOptions,
+  type LoadPhase,
+} from "./types.js";

package/src/loader.ts

@@ -0,0 +1,223 @@
+/**
+ * Per-tool wasm module loading.
+ *
+ * Two facts drive this file:
+ *
+ *   1. Each tool is its own ~3 MB module. A page that only blends must
+ *      not pay for the fuse module, so the import is per-tool and lazy.
+ *   2. Both tools keep state in C++ globals and neither resets it, so a
+ *      module INSTANCE is never reused across invocations.
+ *
+ * So two things are cached per tool and one is not:
+ *
+ *   - the JS glue's factory (the dynamic import), and
+ *   - the COMPILED `WebAssembly.Module`, fetched and compiled once and
+ *     handed to every later factory call through Emscripten's
+ *     `instantiateWasm` hook, so a new instance costs an instantiate,
+ *     not a re-download and re-compile of ~3 MB;
+ *   - never the instance itself.
+ *
+ * Without the hook, each factory call runs the glue's own createWasm,
+ * which fetches and compiles the .wasm from scratch every time.
+ */
+
+import type { WasmModule, LoaderOptions } from "./types.js";
+
+export type Tool = "enblend" | "enfuse";
+
+/**
+ * Output hooks, bound at construction.
+ *
+ * Emscripten reads `Module["print"]`/`Module["printErr"]` exactly once,
+ * inside the factory body, and binds them into module-local variables
+ * before the factory's promise resolves. Assigning `module.print` after
+ * `await factory(...)` returns is inert. Callers that want to capture
+ * output must build their closures first and pass them into
+ * `createInstance`.
+ */
+export type InstanceHooks = Pick<WasmModule, "print" | "printErr">;
+
+/** A tool's Emscripten module factory: the default export of its `.js` glue. */
+export type ModuleFactory = (config?: Record<string, unknown>) => Promise<WasmModule>;
+type FactoryLoader = (tool: Tool, options?: LoaderOptions) => Promise<ModuleFactory>;
+
+const MODULE_FILE: Record<Tool, string> = {
+  enblend: "wenblend.js",
+  enfuse: "wenfuse.js",
+};
+
+const WASM_FILE: Record<Tool, string> = {
+  enblend: "wenblend.wasm",
+  enfuse: "wenfuse.wasm",
+};
+
+// Both caches are keyed on the tool AND the absolute glue URL, so a second
+// call with a different `wasmPath` loads that module instead of silently
+// reusing the first. Relative and absolute spellings of one location resolve
+// to the same key.
+const factories = new Map<string, Promise<ModuleFactory>>();
+const compiled = new Map<string, Promise<WebAssembly.Module>>();
+
+function glueUrl(tool: Tool, options?: LoaderOptions): string {
+  return options?.wasmPath
+    ?? new URL(`../dist/${MODULE_FILE[tool]}`, import.meta.url).href;
+}
+
+/**
+ * The glue's absolute URL. `new URL` needs an absolute base, but `wasmPath`
+ * may be relative (what bundlers hand out, e.g. Vite's `?url`), so it is
+ * resolved against this module — the same base `import()` uses for the glue.
+ */
+function resolvedGlueUrl(tool: Tool, options?: LoaderOptions): URL {
+  return new URL(glueUrl(tool, options), import.meta.url);
+}
+
+function cacheKey(tool: Tool, options?: LoaderOptions): string {
+  return `${tool} ${resolvedGlueUrl(tool, options).href}`;
+}
+
+async function importFactory(tool: Tool, options?: LoaderOptions): Promise<ModuleFactory> {
+  const mod = await import(/* webpackIgnore: true */ glueUrl(tool, options));
+  return (mod.default ?? mod) as ModuleFactory;
+}
+
+/**
+ * Fetch and compile a tool's .wasm.
+ *
+ * The URL is the one the glue itself would use: its `locateFile` default
+ * resolves the .wasm name against the glue's own directory. `file:` URLs
+ * (Node) are read from disk, because Node's fetch does not do `file:`;
+ * everything else is fetched, streaming-compiled where the server's MIME
+ * type allows and compiled from bytes where it does not — the same
+ * fallback the glue performs.
+ */
+async function compileWasm(tool: Tool, options?: LoaderOptions): Promise<WebAssembly.Module> {
+  const url = new URL(WASM_FILE[tool], resolvedGlueUrl(tool, options));
+  if (url.protocol === "file:") {
+    // A variable specifier keeps bundlers from trying to resolve a Node
+    // builtin into browser code; this branch only runs under Node.
+    const fsSpec = "node:fs/promises";
+    const urlSpec = "node:url";
+    const { readFile } = await import(/* webpackIgnore: true */ /* @vite-ignore */ fsSpec);
+    const { fileURLToPath } = await import(/* webpackIgnore: true */ /* @vite-ignore */ urlSpec);
+    return WebAssembly.compile(await readFile(fileURLToPath(url)));
+  }
+  const response = fetch(url.href, { credentials: "same-origin" });
+  if (typeof WebAssembly.compileStreaming === "function") {
+    try {
+      return await WebAssembly.compileStreaming(response);
+    } catch {
+      // Wrong MIME type, most often. Fall through to compiling bytes.
+    }
+  }
+  const res = await response;
+  if (!res.ok) throw new Error(`failed to fetch ${url.href}: HTTP ${res.status}`);
+  return WebAssembly.compile(await res.arrayBuffer());
+}
+
+let compileWasmImpl: (tool: Tool, options?: LoaderOptions) => Promise<WebAssembly.Module> = compileWasm;
+
+/**
+ * The compiled module for a tool, compiled at most once per resolved URL.
+ *
+ * A promise is cached, so concurrent first calls share one compile. A
+ * failed compile is evicted, so a transient network error is retried on
+ * the next call rather than poisoning the cache for the page's lifetime.
+ */
+async function loadCompiled(tool: Tool, options?: LoaderOptions): Promise<WebAssembly.Module> {
+  const key = cacheKey(tool, options);
+  let existing = compiled.get(key);
+  if (!existing) {
+    existing = compileWasmImpl(tool, options).catch((err) => {
+      compiled.delete(key);
+      throw err;
+    });
+    compiled.set(key, existing);
+  }
+  return existing;
+}
+
+let loadFactoryImpl: FactoryLoader = importFactory;
+
+/** Test seam: replace the dynamic import. */
+export function __setFactoryLoader(fn: FactoryLoader): void {
+  loadFactoryImpl = fn;
+}
+
+/** Test seam: replace the wasm fetch-and-compile step. */
+export function __setWasmCompiler(
+  fn: (tool: Tool, options?: LoaderOptions) => Promise<WebAssembly.Module>,
+): void {
+  compileWasmImpl = fn;
+}
+
+/** Test seam: drop cached factories and compiled modules. */
+export function resetFactoryCache(): void {
+  factories.clear();
+  compiled.clear();
+  loadFactoryImpl = importFactory;
+  compileWasmImpl = compileWasm;
+}
+
+/**
+ * Import a tool's JS glue and return its module factory. Cached per tool and resolved glue URL.
+ *
+ * Calling the returned factory directly compiles the .wasm afresh on every
+ * call; `createInstance` is what supplies the cached compiled module.
+ *
+ * `async` so that a `wasmPath` that is not a valid URL rejects rather than
+ * throwing synchronously. The cache lookup still happens before the first
+ * `await`, so concurrent first calls share one import.
+ */
+export async function loadFactory(tool: Tool, options?: LoaderOptions): Promise<ModuleFactory> {
+  const key = cacheKey(tool, options);
+  let existing = factories.get(key);
+  if (!existing) {
+    existing = loadFactoryImpl(tool, options).catch((err) => {
+      factories.delete(key);
+      throw err;
+    });
+    factories.set(key, existing);
+  }
+  return existing;
+}
+
+/**
+ * Build a fresh module instance.
+ *
+ * Never cache the result. See the file header.
+ *
+ * `hooks` is passed straight into the factory's config object, since that
+ * is the only point at which `print`/`printErr` can take effect (see
+ * `InstanceHooks`).
+ *
+ * The compiled module reaches the glue through `instantiateWasm`: the glue
+ * calls it with its import object in place of its own fetch-and-compile,
+ * and waits for `receiveInstance`. That wait has no rejection path — the
+ * glue wraps the hook in a promise whose `reject` it never calls — so a
+ * compile or instantiate failure is raced against the factory here, or
+ * the call would hang forever instead of rejecting.
+ */
+export async function createInstance(
+  tool: Tool,
+  options?: LoaderOptions,
+  hooks?: Partial<InstanceHooks>,
+): Promise<WasmModule> {
+  options?.onProgress?.("loading");
+  const factory = await loadFactory(tool, options);
+  options?.onProgress?.("initializing");
+  let fail!: (err: unknown) => void;
+  const failed = new Promise<never>((_, reject) => { fail = reject; });
+  const instantiateWasm = (
+    imports: WebAssembly.Imports,
+    receiveInstance: (instance: WebAssembly.Instance, module: WebAssembly.Module) => void,
+  ): Record<string, never> => {
+    loadCompiled(tool, options)
+      .then(async (module) => receiveInstance(await WebAssembly.instantiate(module, imports), module))
+      .catch(fail);
+    return {};
+  };
+  const instance = await Promise.race([factory({ ...hooks, instantiateWasm }), failed]);
+  options?.onProgress?.("ready");
+  return instance;
+}

package/src/operations.ts

@@ -0,0 +1,147 @@
+/**
+ * High-level functional API.
+ *
+ * Enblend is invocation-oriented — N inputs plus flags produce one
+ * output — so this layer is a thin argv builder rather than the
+ * chainable object the single-image siblings expose.
+ */
+
+import type { InputImage, BlendOptions, FuseOptions, LoaderOptions, FileInput, OutputDir, WrittenFile } from "./types.js";
+import { EnblendError } from "./types.js";
+import { enblend, enfuse } from "./cli.js";
+import type { Tool } from "./loader.js";
+import { isFileInput } from "./staging.js";
+
+export type ImageInput = InputImage | Uint8Array | ArrayBuffer;
+
+const DEFAULT_OUTPUT = "output.tif";
+
+/**
+ * Give every input a name, auto-naming bare buffers positionally.
+ *
+ * Throws on a name collision rather than silently renaming: a caller who
+ * supplies an explicit name may reference it again in `options.args`
+ * (an `--exclude somefile.tif` flag, say), so renaming around a clash
+ * could silently break a working invocation in a new way. Two inputs
+ * sharing a name would otherwise stage to the same MEMFS path — the
+ * second overwriting the first — and the tool would run to completion
+ * on the wrong input set with no error, which is exactly the kind of
+ * silent corruption this port cannot afford another instance of.
+ */
+export function normalizeInputs(images: ImageInput[]): InputImage[];
+export function normalizeInputs(images: FileInput[]): FileInput[];
+export function normalizeInputs(images: ImageInput[] | FileInput[]): InputImage[] | FileInput[] {
+  const seen = new Set<string>();
+  return (images as Array<ImageInput | FileInput>).map((image, i) => {
+    const input = image instanceof Uint8Array || image instanceof ArrayBuffer
+      ? { name: `in${i}.tif`, data: image }
+      : image;
+    if (seen.has(input.name)) {
+      throw new Error(`normalizeInputs: duplicate input name "${input.name}"`);
+    }
+    seen.add(input.name);
+    return input;
+  }) as InputImage[] | FileInput[];
+}
+
+// Short options that take an argument in enblend or enfuse ("v" and "w" take
+// an optional one). getopt treats the rest of a cluster after any of these as
+// that argument, so scanning a cluster for "o" stops at the first of them.
+const SHORT_WITH_ARGUMENT = new Set(["b", "d", "f", "l", "m", "o", "v", "w"]);
+
+/** Whether getopt_long would read `arg` as the output option, as enblend and enfuse define it. */
+function isOutputOption(arg: string): boolean {
+  if (arg.startsWith("--")) {
+    // Any unambiguous prefix of a long option is accepted, so "--out" is
+    // "--output". "--o" is ambiguous in enblend (it has --optimize too) but
+    // means --output in enfuse; rejecting it costs nothing either way.
+    const name = arg.slice(2).split("=", 1)[0];
+    return name.startsWith("o") && "output".startsWith(name);
+  }
+  if (!arg.startsWith("-")) return false;
+  for (const c of arg.slice(1)) {
+    if (c === "o") return true;
+    if (SHORT_WITH_ARGUMENT.has(c)) return false;
+  }
+  return false;
+}
+
+/**
+ * Reject output settings that could only end in a confusing "produced no
+ * output file" after a full run. The tool writes into its per-invocation
+ * work directory, and the output is collected from there by name, so it
+ * must be a plain file name that no input shares, and set only once.
+ */
+function validateOutput(output: string, args: readonly string[], inputs: Array<{ name: string }>): void {
+  if (output === "" || output === "." || output === ".." || /[/\\]/.test(output)) {
+    throw new Error(`options.output must be a plain file name, got "${output}"`);
+  }
+  const setsOutput = args.find(isOutputOption);
+  if (setsOutput !== undefined) {
+    throw new Error(`set the output file with options.output, not "${setsOutput}" in args`);
+  }
+  if (inputs.some((i) => i.name === output)) {
+    throw new Error(`input name "${output}" collides with the output file name`);
+  }
+}
+
+export async function runOperation(
+  tool: Tool,
+  images: ImageInput[] | FileInput[],
+  options: (BlendOptions | FuseOptions) & { outputDir?: OutputDir } = {},
+  loaderOptions?: LoaderOptions,
+): Promise<Uint8Array | WrittenFile> {
+  if (images.length === 0) {
+    throw new Error(`${tool} requires at least one input image`);
+  }
+
+  const files = (images as unknown[]).every(isFileInput);
+  const inputs = normalizeInputs(images as never) as Array<InputImage | FileInput>;
+  const output = options.output ?? DEFAULT_OUTPUT;
+  validateOutput(output, options.args ?? [], inputs);
+  const argv = ["-o", output, ...(options.args ?? []), ...inputs.map((i) => i.name)];
+
+  const invoke = tool === "enblend" ? enblend : enfuse;
+  const result = files
+    ? await invoke(argv, inputs as FileInput[], { ...loaderOptions, outputDir: options.outputDir! })
+    : await invoke(argv, inputs as InputImage[], loaderOptions);
+
+  if (result.exitCode !== 0) {
+    throw new EnblendError(
+      `${tool} exited with code ${result.exitCode}${result.stderr ? `: ${result.stderr}` : ""}`,
+      result.exitCode,
+      result.stderr,
+    );
+  }
+
+  const produced = "written" in result ? result.written.get(output) : result.outputFiles.get(output);
+  if (!produced) {
+    throw new EnblendError(
+      `${tool} exited cleanly but produced no output file "${output}"`,
+      0,
+      result.stderr,
+    );
+  }
+  return produced;
+}
+
+/**
+ * Blend overlapping images into one.
+ *
+ * Enblend positions images by their TIFF XPosition/YPosition tags, not
+ * by any argument. Inputs without correct offsets — two unaligned
+ * JPEGs, say — produce a valid file containing a useless image. Use
+ * remapped output from a stitcher.
+ */
+export function blend(images: ImageInput[], options?: BlendOptions, loaderOptions?: LoaderOptions): Promise<Uint8Array>;
+export function blend(images: FileInput[], options: BlendOptions & { outputDir: OutputDir }, loaderOptions?: LoaderOptions): Promise<WrittenFile>;
+export function blend(images: ImageInput[] | FileInput[], options?: BlendOptions & { outputDir?: OutputDir }, loaderOptions?: LoaderOptions) {
+  return runOperation("enblend", images, options, loaderOptions);
+}
+
+/** Fuse a bracketed exposure series into one image. */
+export function fuse(images: ImageInput[], options?: FuseOptions, loaderOptions?: LoaderOptions): Promise<Uint8Array>;
+export function fuse(images: FileInput[], options: FuseOptions & { outputDir: OutputDir }, loaderOptions?: LoaderOptions): Promise<WrittenFile>;
+export function fuse(images: ImageInput[] | FileInput[], options?: FuseOptions & { outputDir?: OutputDir }, loaderOptions?: LoaderOptions) {
+  return runOperation("enfuse", images, options, loaderOptions);
+}