@tscomfy/client 0.0.0-stage → 0.1.2

package/src/channel.ts

@@ -0,0 +1,334 @@
+import { type JsonObject, parse, stringify } from "@tscomfy/core";
+import { ClientError } from "./client-error.ts";
+import type { Connection } from "./connection.ts";
+import { decodeFrame, type PreviewFrame, type TextFrame } from "./frames.ts";
+import { isObject, readObject, send } from "./http.ts";
+import type { Server } from "./server.ts";
+import { abortable, sleep } from "./timers.ts";
+import { baseUrl, endpoint, shownUrl } from "./url.ts";
+
+/** Connections and the channels behind them. */
+const channels = new WeakMap<Connection, Channel>();
+
+/** Ties a connection to its channel. */
+export function attach(connection: Connection, channel: Channel): void {
+  channels.set(connection, channel);
+}
+
+/** The channel behind a connection. Throws a `TypeError` for anything `connect` didn't return. */
+export function channelOf(connection: Connection): Channel {
+  const channel = channels.get(connection);
+  if (channel === undefined) {
+    throw new TypeError("Expected a connection returned by connect()");
+  }
+  return channel;
+}
+
+/** What a job hears from the channel. */
+export interface JobListener {
+  readonly id: string;
+  /** A JSON event carrying this job's prompt id. */
+  message(type: string, data: JsonObject): void;
+  /** A preview or progress text of this job. */
+  frame(frame: PreviewFrame | TextFrame): void;
+  /** The server's queue changed (a `status` broadcast). */
+  queueChanged(): void;
+  /** The websocket reopened after a drop: events may have been lost. */
+  reconnected(): void;
+  /** The channel is gone for good: closed, or the server stayed unreachable. */
+  fail(error: ClientError): void;
+}
+
+/** How long the server gets to answer the feature flags. */
+const HANDSHAKE_MS = 10_000;
+
+/** Delays between reconnect attempts, before jitter: about two minutes in all. */
+const BACKOFF_MS = [250, 500, 1000, 2000, 4000, 8000, 15_000, 30_000, 30_000, 30_000];
+
+/** The lowest server version the client supports: the per-job cancel came in 0.26.0. */
+const MIN_VERSION = [0, 26, 0] as const;
+
+/**
+ * The flags the client announces as its first message: previews and progress text that say
+ * which prompt they belong to, as the frontend announces them.
+ */
+const CLIENT_FLAGS = { supports_preview_metadata: true, supports_progress_text_metadata: true };
+
+/** A websocket's `readyState` once closed; the global `WebSocket` may not exist. */
+const CLOSED = 3;
+
+const closedError = (): ClientError => new ClientError("The connection is closed");
+
+/**
+ * One websocket and the jobs listening on it. Opens one socket at a time, shared by every
+ * caller; reconnects only while jobs are open, after the old socket has closed (two live sockets
+ * with one client id lose events on the server), and re-sends the feature flags first. `close()`
+ * stops everything it started: sockets, handshakes, backoff waits.
+ */
+export class Channel {
+  readonly server: Server;
+  readonly clientId: string;
+  features: JsonObject = {};
+  readonly #jobs = new Map<string, JobListener>();
+  /** Every socket this channel opened and that hasn't closed yet. */
+  readonly #sockets = new Set<WebSocket>();
+  /** Aborted by `close()`: ends handshakes and backoff waits. */
+  readonly #life = new AbortController();
+  #socket: WebSocket | undefined;
+  #opening: Promise<void> | undefined;
+  #reconnecting: Promise<void> | undefined;
+  #closing: Promise<void> | undefined;
+  /** The job whose prompt the server is running, for progress text without a prompt id. */
+  #running: JobListener | undefined;
+
+  constructor(server: Server, clientId: string) {
+    this.server = server;
+    this.clientId = clientId;
+  }
+
+  /** Whether `close()` was called. */
+  get closed(): boolean {
+    return this.#life.signal.aborted;
+  }
+
+  /**
+   * Waits until the websocket is open, opening it (once, for every caller) if it isn't. Rejects
+   * with the signal's reason when `signal` aborts, and with a {@link ClientError} when the
+   * channel is closed or the socket can't be opened.
+   */
+  async ready(signal?: AbortSignal): Promise<void> {
+    for (;;) {
+      if (this.closed) throw closedError();
+      if (this.#reconnecting !== undefined) {
+        // oxlint-disable-next-line no-await-in-loop -- the state changes while it waits
+        await abortable(this.#reconnecting, signal);
+        continue;
+      }
+      if (this.#socket !== undefined) return;
+      this.#opening ??= this.#open().finally(() => {
+        this.#opening = undefined;
+      });
+      // oxlint-disable-next-line no-await-in-loop -- the state changes while it waits
+      await abortable(this.#opening, signal);
+    }
+  }
+
+  /**
+   * Checks that the server is one the client supports: ComfyUI 0.26 or later by its version
+   * (when it reports one it can parse), and with the job API. Rejects with a {@link ClientError}.
+   */
+  async checkServer(signal?: AbortSignal): Promise<void> {
+    const stats = await send(this.server, { method: "GET", path: "system_stats", signal });
+    if (stats.ok) {
+      const body = await readObject(stats).catch(() => undefined);
+      const system = body?.["system"];
+      const version = isObject(system) ? system["comfyui_version"] : undefined;
+      if (typeof version === "string" && isOlder(version, MIN_VERSION)) {
+        throw new ClientError(
+          `The server runs ComfyUI ${version}; @tscomfy/client needs ComfyUI ${MIN_VERSION.join(".")} or later`,
+        );
+      }
+    } else {
+      await stats.body?.cancel();
+    }
+    const jobs = await send(this.server, {
+      method: "GET",
+      path: "api/jobs",
+      query: { limit: "1" },
+      signal,
+    });
+    await jobs.body?.cancel();
+    if (!jobs.ok) {
+      throw new ClientError(
+        `The server has no job API (GET /api/jobs answered ${String(jobs.status)}); @tscomfy/client needs ComfyUI ${MIN_VERSION.join(".")} or later`,
+        { status: jobs.status },
+      );
+    }
+  }
+
+  register(job: JobListener): void {
+    if (this.closed) throw closedError();
+    this.#jobs.set(job.id, job);
+  }
+
+  unregister(job: JobListener): void {
+    if (this.#jobs.get(job.id) === job) this.#jobs.delete(job.id);
+    if (this.#running === job) this.#running = undefined;
+  }
+
+  /** Closes every socket and fails every open job; waits until the sockets have closed. */
+  close(): Promise<void> {
+    this.#closing ??= this.#close();
+    return this.#closing;
+  }
+
+  async #close(): Promise<void> {
+    this.#life.abort(closedError());
+    this.#socket = undefined;
+    const jobs = [...this.#jobs.values()];
+    this.#jobs.clear();
+    for (const job of jobs) job.fail(new ClientError("The connection was closed"));
+    await Promise.all([...this.#sockets].map((socket) => closeSocket(socket)));
+  }
+
+  /** Opens a socket and negotiates the feature flags; the socket becomes the channel's. */
+  async #open(): Promise<void> {
+    const url = endpoint(baseUrl(this.server), "ws", { clientId: this.clientId });
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    const shown = shownUrl(url);
+    const life = this.#life.signal;
+    const socket = this.server.webSocket?.(url.href) ?? new WebSocket(url.href);
+    socket.binaryType = "arraybuffer";
+    this.#sockets.add(socket);
+    socket.addEventListener("close", () => {
+      this.#sockets.delete(socket);
+      this.#dropped(socket);
+    });
+    await new Promise<void>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        fail(new ClientError(`${shown} didn't answer the websocket handshake in time`));
+      }, HANDSHAKE_MS);
+      const done = (): void => {
+        clearTimeout(timer);
+        life.removeEventListener("abort", aborted);
+        socket.removeEventListener("close", closed);
+      };
+      const fail = (error: unknown): void => {
+        done();
+        socket.close();
+        reject(error);
+      };
+      const aborted = (): void => {
+        fail(closedError());
+      };
+      const closed = (): void => {
+        fail(new ClientError(`Could not open a websocket to ${shown}`));
+      };
+      if (life.aborted) {
+        aborted();
+        return;
+      }
+      life.addEventListener("abort", aborted, { once: true });
+      socket.addEventListener("close", closed);
+      socket.addEventListener("open", () => {
+        socket.send(stringify({ type: "feature_flags", data: CLIENT_FLAGS }));
+      });
+      let negotiated = false;
+      socket.addEventListener("message", (event: MessageEvent) => {
+        if (!negotiated && typeof event.data === "string") {
+          const message = readMessage(event.data);
+          if (message?.type === "feature_flags") {
+            negotiated = true;
+            done();
+            this.features = message.data;
+            this.#socket = socket;
+            resolve();
+            return;
+          }
+        }
+        this.#receive(event.data);
+      });
+    });
+  }
+
+  #receive(data: unknown): void {
+    if (typeof data === "string") {
+      const message = readMessage(data);
+      if (message !== undefined) this.#dispatch(message.type, message.data);
+      return;
+    }
+    if (!(data instanceof ArrayBuffer)) return;
+    const frame = decodeFrame(data, this.features["supports_progress_text_metadata"] === true);
+    if (frame === undefined) return;
+    const job = frame.promptId === undefined ? this.#running : this.#jobs.get(frame.promptId);
+    job?.frame(frame);
+  }
+
+  #dispatch(type: string, data: JsonObject): void {
+    if (type === "status") {
+      for (const job of this.#jobs.values()) job.queueChanged();
+      return;
+    }
+    const promptId = data["prompt_id"];
+    if (typeof promptId !== "string") return;
+    const job = this.#jobs.get(promptId);
+    if (job === undefined) {
+      // Another client's prompt, or one of ours that settled: it isn't running ours.
+      if (type === "execution_start") this.#running = undefined;
+      return;
+    }
+    if (type === "execution_start") this.#running = job;
+    if (type === "executing" && data["node"] === null && this.#running === job) {
+      this.#running = undefined;
+    }
+    job.message(type, data);
+  }
+
+  #dropped(socket: WebSocket): void {
+    if (this.#socket !== socket) return;
+    this.#socket = undefined;
+    this.#running = undefined;
+    // With no job open, the next submit reopens it.
+    if (this.closed || this.#jobs.size === 0) return;
+    this.#reconnecting = this.#reconnect().finally(() => {
+      this.#reconnecting = undefined;
+    });
+  }
+
+  async #reconnect(): Promise<void> {
+    const life = this.#life.signal;
+    for (const delay of BACKOFF_MS) {
+      // oxlint-disable-next-line no-await-in-loop -- attempts are sequential, with growing waits
+      await sleep(delay * (0.5 + Math.random() / 2), life);
+      if (life.aborted) return;
+      try {
+        // oxlint-disable-next-line no-await-in-loop -- attempts are sequential, with growing waits
+        await this.#open();
+        for (const job of this.#jobs.values()) job.reconnected();
+        return;
+      } catch {
+        // The next attempt, after a longer wait; none after close().
+      }
+    }
+    const error = new ClientError(
+      `Lost the websocket to ${shownUrl(baseUrl(this.server))} and couldn't reopen it`,
+    );
+    const jobs = [...this.#jobs.values()];
+    this.#jobs.clear();
+    for (const job of jobs) job.fail(error);
+  }
+}
+
+/** Closes a socket and waits for its close, a second at most. */
+function closeSocket(socket: WebSocket): Promise<void> {
+  if (socket.readyState === CLOSED) return Promise.resolve();
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, 1000);
+    socket.addEventListener("close", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+    socket.close();
+  });
+}
+
+/** Whether a `major.minor.patch` version (anything after it ignored) is below `minimum`. */
+function isOlder(version: string, minimum: readonly [number, number, number]): boolean {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)/.exec(version);
+  if (match === null) return false;
+  const parts = [Number(match[1]), Number(match[2]), Number(match[3])];
+  for (const [index, part] of parts.entries()) {
+    const least = minimum[index] ?? 0;
+    if (part !== least) return part < least;
+  }
+  return false;
+}
+
+/** A JSON message `{ type, data }`, read losslessly; anything else is ignored. */
+function readMessage(
+  text: string,
+): { readonly type: string; readonly data: JsonObject } | undefined {
+  const value = parse(text).value;
+  if (!isObject(value) || typeof value["type"] !== "string") return undefined;
+  return { type: value["type"], data: isObject(value["data"]) ? value["data"] : {} };
+}

package/src/client-error.ts

@@ -0,0 +1,19 @@
+/**
+ * The server couldn't be reached, or answered in a way the protocol doesn't allow. Thrown by the
+ * HTTP functions and used to reject a job's outcome; what the server decides about a job (a
+ * rejection, a failure) is data instead, in the {@link Outcome}. The underlying error, if any, is
+ * the `cause`.
+ */
+export class ClientError extends Error {
+  /** The HTTP status of the answer that caused it, when there was one. */
+  readonly status: number | undefined;
+
+  constructor(
+    message: string,
+    options: { readonly cause?: unknown; readonly status?: number } = {},
+  ) {
+    super(message, { cause: options.cause });
+    this.name = "ClientError";
+    this.status = options.status;
+  }
+}

package/src/connection.ts

@@ -0,0 +1,59 @@
+import type { JsonObject } from "@tscomfy/core";
+import { attach, Channel } from "./channel.ts";
+import type { Server } from "./server.ts";
+import { baseUrl } from "./url.ts";
+import { randomUuid } from "./uuid.ts";
+
+/**
+ * An open connection to a server: a {@link Server} with a websocket that delivers the events of
+ * the jobs submitted through it. Several jobs share it. Close it when done: an open websocket
+ * keeps a Node or Bun process running.
+ */
+export interface Connection extends Server {
+  /** The id the server sends this connection's events to; fresh for every connection. */
+  readonly clientId: string;
+  /** The server's feature flags, as it answered them when the connection opened. */
+  readonly features: JsonObject;
+  /**
+   * Closes the websocket. Jobs still open reject their outcome with a {@link ClientError}; they
+   * keep running on the server.
+   */
+  close(): Promise<void>;
+}
+
+/** Options for {@link connect}. */
+export interface ConnectOptions {
+  /** Aborts opening the connection; rejects with the signal's reason. */
+  readonly signal?: AbortSignal;
+}
+
+/**
+ * Opens a connection: a websocket with a fresh client id, which announces
+ * `supports_preview_metadata` (so previews say which job and node they belong to) and waits for
+ * the server's feature flags. Also checks that the server is ComfyUI 0.26 or later with the job
+ * API. Rejects with a {@link ClientError} when the server can't be reached or is too old, and
+ * with the signal's reason when `signal` aborts; either way nothing is left open. Throws a
+ * `TypeError` for an invalid `server.url`.
+ */
+export async function connect(server: Server, options: ConnectOptions = {}): Promise<Connection> {
+  baseUrl(server);
+  const channel = new Channel(server, randomUuid());
+  try {
+    await channel.ready(options.signal);
+    await channel.checkServer(options.signal);
+  } catch (error) {
+    await channel.close();
+    throw error;
+  }
+  const connection: Connection = Object.freeze({
+    url: server.url,
+    ...(server.headers === undefined ? {} : { headers: server.headers }),
+    ...(server.fetch === undefined ? {} : { fetch: server.fetch }),
+    ...(server.webSocket === undefined ? {} : { webSocket: server.webSocket }),
+    clientId: channel.clientId,
+    features: channel.features,
+    close: () => channel.close(),
+  });
+  attach(connection, channel);
+  return connection;
+}

package/src/event-queue.ts

@@ -0,0 +1,70 @@
+import type { JobEvent } from "./events.ts";
+
+/**
+ * Events of these types are snapshots: a newer one of a node replaces its unread one. Progress
+ * text isn't: each says something different ("Downloading…", "Generating…").
+ */
+const COALESCED: ReadonlySet<JobEvent["type"]> = new Set(["progress", "preview"]);
+
+type Waiter = (result: IteratorResult<JobEvent, undefined>) => void;
+
+/**
+ * A job's events, for one consumer. Buffered from the start, so none is missed before the
+ * consumer starts reading; while it lags, a newer progress or preview of a node replaces the
+ * unread one where it stands, so the buffer stays bounded by the number of nodes and keeps its
+ * order.
+ */
+export class EventQueue implements AsyncIterable<JobEvent> {
+  readonly #buffer: JobEvent[] = [];
+  /** `next()` calls waiting for an event, in the order they were made. */
+  readonly #waiting: Waiter[] = [];
+  #ended = false;
+  #taken = false;
+
+  /** Adds an event, unless the queue has ended or its consumer stopped. */
+  push(event: JobEvent): void {
+    if (this.#ended) return;
+    const waiting = this.#waiting.shift();
+    if (waiting !== undefined) {
+      waiting({ done: false, value: event });
+      return;
+    }
+    if (COALESCED.has(event.type) && "node" in event) {
+      const stale = this.#buffer.findIndex(
+        (queued) => queued.type === event.type && "node" in queued && queued.node === event.node,
+      );
+      if (stale !== -1) {
+        this.#buffer[stale] = event;
+        return;
+      }
+    }
+    this.#buffer.push(event);
+  }
+
+  /** Ends the queue: the consumer reads what is buffered, then stops. */
+  end(): void {
+    this.#ended = true;
+    for (const waiting of this.#waiting.splice(0)) waiting({ done: true, value: undefined });
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<JobEvent, undefined> {
+    if (this.#taken) throw new TypeError("job.events can be iterated only once");
+    this.#taken = true;
+    return {
+      next: () => {
+        const event = this.#buffer.shift();
+        if (event !== undefined) return Promise.resolve({ done: false, value: event });
+        if (this.#ended) return Promise.resolve({ done: true, value: undefined });
+        return new Promise((resolve) => {
+          this.#waiting.push(resolve);
+        });
+      },
+      return: () => {
+        // The consumer stopped (`break`): drop the buffer and what comes later.
+        this.#buffer.length = 0;
+        this.end();
+        return Promise.resolve({ done: true, value: undefined });
+      },
+    };
+  }
+}

package/src/events.ts

@@ -0,0 +1,76 @@
+import type { NodeId } from "@tscomfy/core";
+import type { NodeOutput } from "./outputs.ts";
+
+/** The server started running the job. */
+export interface StartedEvent {
+  readonly type: "started";
+}
+
+/** Nodes whose cached results the run reuses instead of running them. */
+export interface CachedEvent {
+  readonly type: "cached";
+  readonly nodes: readonly NodeId[];
+}
+
+/** A node started running. */
+export interface ExecutingEvent {
+  readonly type: "executing";
+  readonly node: NodeId;
+}
+
+/** A running node's progress: `value` of `max` (sampler steps, say). */
+export interface ProgressEvent {
+  readonly type: "progress";
+  readonly node: NodeId;
+  readonly value: number;
+  readonly max: number;
+}
+
+/**
+ * A live preview from a running node: a sampler's latent preview (a JPEG at most 512 pixels on a
+ * side, sent when the job asks for previews with `previews` in {@link SubmitOptions}, or the
+ * server was started with `--preview-method`), or a `SaveImageWebsocket` image (a full-size PNG,
+ * always sent).
+ */
+export interface PreviewEvent {
+  readonly type: "preview";
+  readonly node: NodeId;
+  /** `image/jpeg` or `image/png`. */
+  readonly mime: string;
+  readonly bytes: Uint8Array<ArrayBuffer>;
+}
+
+/** A node finished and reported output (files, text). */
+export interface OutputEvent {
+  readonly type: "output";
+  readonly node: NodeId;
+  readonly output: NodeOutput;
+}
+
+/** Progress text from a running node (partner nodes report their status this way). */
+export interface TextEvent {
+  readonly type: "text";
+  readonly node: NodeId;
+  readonly text: string;
+}
+
+/**
+ * A node blocked execution with a message. The run continues without what depends on it; the
+ * outcome also lists it, as a `W_NODE_BLOCKED` diagnostic.
+ */
+export interface BlockedEvent {
+  readonly type: "blocked";
+  readonly node: NodeId;
+  readonly message: string;
+}
+
+/** What a job reports while it runs. Node ids are the prompt's (the builder's) ids. */
+export type JobEvent =
+  | StartedEvent
+  | CachedEvent
+  | ExecutingEvent
+  | ProgressEvent
+  | PreviewEvent
+  | OutputEvent
+  | TextEvent
+  | BlockedEvent;

package/src/files.ts

@@ -0,0 +1,119 @@
+import { ClientError } from "./client-error.ts";
+import { readObject, send, unexpected } from "./http.ts";
+import type { FileRef, FolderType } from "./outputs.ts";
+import { isFolderType } from "./read-outputs.ts";
+import type { Server } from "./server.ts";
+import { baseUrl, endpoint } from "./url.ts";
+
+/** A file to upload. */
+export interface UploadSource {
+  /** The file name to store it under. */
+  readonly name: string;
+  readonly bytes: Uint8Array;
+  /** Its media type, such as `image/png`. */
+  readonly mime?: string;
+}
+
+/** Options for {@link uploadFile}. */
+export interface UploadOptions {
+  /** A folder under the target directory. */
+  readonly subfolder?: string;
+  /** The directory: `input` (default), `temp` or `output`. */
+  readonly type?: FolderType;
+  /** Replace a file of the same name. Otherwise the server keeps both, renaming the new one. */
+  readonly overwrite?: boolean;
+  readonly signal?: AbortSignal;
+}
+
+/** An uploaded file, as the server stored it. */
+export interface UploadedFile extends FileRef {
+  /**
+   * The value a loader node's file input takes (`LoadImage`'s `image`): `subfolder/name`, with
+   * ` [temp]` or ` [output]` after it outside the input directory.
+   */
+  readonly value: string;
+}
+
+/**
+ * Uploads a file (an image, video or audio for a loader node) through `/upload/image`. The
+ * stored name can differ from `source.name`: without `overwrite`, the server renames a file whose
+ * name is taken by different content. Rejects with a {@link ClientError} if the server refuses.
+ */
+export async function uploadFile(
+  server: Server,
+  source: UploadSource,
+  options: UploadOptions = {},
+): Promise<UploadedFile> {
+  const form = new FormData();
+  const blob = new Blob([new Uint8Array(source.bytes)], { type: source.mime ?? "" });
+  form.append("image", blob, source.name);
+  form.append("type", options.type ?? "input");
+  if (options.subfolder !== undefined) form.append("subfolder", options.subfolder);
+  if (options.overwrite === true) form.append("overwrite", "true");
+  const response = await send(server, {
+    method: "POST",
+    path: "upload/image",
+    body: form,
+    signal: options.signal,
+  });
+  if (!response.ok) throw await unexpected(response);
+  const answer = await readObject(response);
+  const { name, subfolder, type } = answer;
+  if (typeof name !== "string" || !isFolderType(type)) {
+    throw new ClientError("The server's answer to an upload has no file name or folder");
+  }
+  const folder = typeof subfolder === "string" ? subfolder : "";
+  const path = folder === "" ? name : `${folder}/${name}`;
+  return Object.freeze({
+    filename: name,
+    subfolder: folder,
+    type,
+    value: type === "input" ? path : `${path} [${type}]`,
+  });
+}
+
+/** A downloaded file. */
+export interface FileData {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  /** The server's `Content-Type`; `application/octet-stream` when it sent none. */
+  readonly mime: string;
+}
+
+/** Options for {@link fetchFile}. */
+export interface FetchFileOptions {
+  readonly signal?: AbortSignal;
+}
+
+/**
+ * Downloads a file the server has, such as an output, through `/view`. Rejects with a
+ * {@link ClientError} if the server doesn't have it.
+ */
+export async function fetchFile(
+  server: Server,
+  file: FileRef,
+  options: FetchFileOptions = {},
+): Promise<FileData> {
+  const response = await send(server, {
+    method: "GET",
+    path: "view",
+    query: viewQuery(file),
+    signal: options.signal,
+  });
+  if (!response.ok) throw await unexpected(response);
+  return Object.freeze({
+    bytes: new Uint8Array(await response.arrayBuffer()),
+    mime: response.headers.get("content-type") ?? "application/octet-stream",
+  });
+}
+
+/**
+ * The URL `/view` serves a file at, for `<img src>` on a page the server allows (same origin, or
+ * `--enable-cors-header`). It carries the server URL's query, so a token in it is in the result.
+ */
+export function fileUrl(server: Server, file: FileRef): string {
+  return endpoint(baseUrl(server), "view", viewQuery(file)).href;
+}
+
+function viewQuery(file: FileRef): Record<string, string> {
+  return { filename: file.filename, subfolder: file.subfolder, type: file.type };
+}