ima2-gen 1.1.6 → 1.1.8

package/lib/canvasVersionStore.js

@@ -0,0 +1,181 @@
+import { mkdir, writeFile, access, readFile } from "fs/promises";
+import { constants } from "fs";
+import { basename, join, normalize, parse } from "path";
+import { randomBytes } from "crypto";
+import { embedImageMetadataBestEffort } from "./imageMetadataStore.js";
+
+const PNG_SIGNATURE = "89504e470d0a1a0a";
+
+function assertPngBuffer(buffer) {
+  if (!Buffer.isBuffer(buffer) || buffer.length === 0) {
+    const err = new Error("PNG body is required");
+    err.status = 400;
+    err.code = "EMPTY_CANVAS_VERSION";
+    throw err;
+  }
+  if (buffer.subarray(0, 8).toString("hex") !== PNG_SIGNATURE) {
+    const err = new Error("Canvas version body must be a PNG image");
+    err.status = 400;
+    err.code = "CANVAS_VERSION_NOT_PNG";
+    throw err;
+  }
+}
+
+function assertSafeFilename(filename) {
+  if (
+    typeof filename !== "string" ||
+    filename.length === 0 ||
+    filename !== basename(filename) ||
+    filename.includes("..") ||
+    !/^canvas-[a-zA-Z0-9._-]+\.png$/.test(filename)
+  ) {
+    const err = new Error("Invalid canvas version filename");
+    err.status = 400;
+    err.code = "INVALID_CANVAS_VERSION_FILENAME";
+    throw err;
+  }
+}
+
+function safeSourceBase(sourceFilename) {
+  const parsed = parse(basename(String(sourceFilename || "image")));
+  return parsed.name.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "image";
+}
+
+function ensureInsideGeneratedDir(generatedDir, filename) {
+  const full = normalize(join(generatedDir, filename));
+  const root = normalize(generatedDir);
+  if (!full.startsWith(root)) {
+    const err = new Error("Canvas version path escapes generated directory");
+    err.status = 400;
+    err.code = "CANVAS_VERSION_PATH_ESCAPE";
+    throw err;
+  }
+  return full;
+}
+
+function makeCanvasFilename(sourceFilename) {
+  const stamp = new Date().toISOString().slice(0, 19).replace(/[-:T]/g, "");
+  const rand = randomBytes(3).toString("hex");
+  return `canvas-${safeSourceBase(sourceFilename)}-${stamp}-${rand}.png`;
+}
+
+async function writeCanvasPng(ctx, filename, buffer, meta) {
+  await mkdir(ctx.config.storage.generatedDir, { recursive: true });
+  const full = ensureInsideGeneratedDir(ctx.config.storage.generatedDir, filename);
+  const embedded = await embedImageMetadataBestEffort(buffer, "png", meta, {
+    version: ctx.packageVersion,
+  });
+  await writeFile(full, embedded.buffer);
+  await writeFile(`${full}.json`, JSON.stringify(meta)).catch(() => {});
+}
+
+async function readGeneratedMetadata(ctx, filename) {
+  if (!filename) return null;
+  try {
+    const full = ensureInsideGeneratedDir(ctx.config.storage.generatedDir, basename(filename));
+    return JSON.parse(await readFile(`${full}.json`, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function firstString(...values) {
+  return values.find((value) => typeof value === "string" && value.trim().length > 0) ?? null;
+}
+
+function toGenerateItem(filename, meta) {
+  const url = `/generated/${encodeURIComponent(filename)}`;
+  return {
+    image: url,
+    url,
+    thumb: url,
+    filename,
+    prompt: meta.prompt || undefined,
+    userPrompt: meta.userPrompt || meta.prompt || null,
+    revisedPrompt: null,
+    promptMode: meta.promptMode || "direct",
+    provider: meta.provider || "canvas",
+    quality: meta.quality || null,
+    size: meta.size || null,
+    format: "png",
+    moderation: meta.moderation || null,
+    model: meta.model || null,
+    usage: null,
+    createdAt: meta.createdAt,
+    kind: "edit",
+    canvasMergedAt: meta.canvasMergedAt,
+    canvasVersion: true,
+    canvasSourceFilename: meta.canvasSourceFilename || null,
+    canvasEditableFilename: filename,
+  };
+}
+
+export async function createCanvasVersion(ctx, input) {
+  assertPngBuffer(input.buffer);
+  const sourceFilename = basename(String(input.sourceFilename || ""));
+  if (!sourceFilename) {
+    const err = new Error("sourceFilename is required");
+    err.status = 400;
+    err.code = "CANVAS_SOURCE_REQUIRED";
+    throw err;
+  }
+  const filename = makeCanvasFilename(sourceFilename);
+  const now = Date.now();
+  const sourceMeta = await readGeneratedMetadata(ctx, sourceFilename);
+  const prompt = firstString(input.prompt, sourceMeta?.userPrompt, sourceMeta?.prompt);
+  const meta = {
+    kind: "edit",
+    provider: "canvas",
+    format: "png",
+    prompt,
+    userPrompt: prompt,
+    promptMode: sourceMeta?.promptMode || "direct",
+    createdAt: now,
+    canvasMergedAt: now,
+    canvasVersion: true,
+    canvasSourceFilename: sourceFilename,
+    canvasEditableFilename: filename,
+  };
+  await writeCanvasPng(ctx, filename, input.buffer, meta);
+  return toGenerateItem(filename, meta);
+}
+
+export async function updateCanvasVersion(ctx, filename, input) {
+  assertSafeFilename(filename);
+  assertPngBuffer(input.buffer);
+  const full = ensureInsideGeneratedDir(ctx.config.storage.generatedDir, filename);
+  await access(full, constants.F_OK).catch(() => {
+    const err = new Error("Canvas version not found");
+    err.status = 404;
+    err.code = "CANVAS_VERSION_NOT_FOUND";
+    throw err;
+  });
+  const now = Date.now();
+  const sourceFilename = typeof input.sourceFilename === "string"
+    ? basename(input.sourceFilename)
+    : null;
+  const sourceMeta = await readGeneratedMetadata(ctx, sourceFilename);
+  const previousMeta = await readGeneratedMetadata(ctx, filename);
+  const prompt = firstString(
+    input.prompt,
+    sourceMeta?.userPrompt,
+    sourceMeta?.prompt,
+    previousMeta?.userPrompt,
+    previousMeta?.prompt,
+  );
+  const meta = {
+    kind: "edit",
+    provider: "canvas",
+    format: "png",
+    prompt,
+    userPrompt: prompt,
+    promptMode: sourceMeta?.promptMode || previousMeta?.promptMode || "direct",
+    createdAt: now,
+    canvasMergedAt: now,
+    canvasVersion: true,
+    canvasSourceFilename: sourceFilename,
+    canvasEditableFilename: filename,
+  };
+  await writeCanvasPng(ctx, filename, input.buffer, meta);
+  return toGenerateItem(filename, meta);
+}

package/lib/cardNewsPlannerClient.js

@@ -20,7 +20,7 @@ function extractText(json) {
   return "";
 }
 
-async function requestJson({ oauthUrl, model, messages, timeoutMs, structured }) {
+async function requestJson({ oauthUrl, model, messages, timeoutMs, structured, reasoningEffort }) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
@@ -28,6 +28,7 @@ async function requestJson({ oauthUrl, model, messages, timeoutMs, structured })
       model,
       input: messages,
       stream: false,
+      ...(reasoningEffort ? { reasoning: { effort: reasoningEffort } } : {}),
       ...(structured
         ? {
             text: {
@@ -95,10 +96,11 @@ export async function requestCardNewsPlannerJson(input, options = {}) {
   const oauthUrl = options.oauthUrl || `http://127.0.0.1:${config.oauth.proxyPort}`;
   const model = options.model || config.cardNewsPlanner.model;
   const timeoutMs = options.timeoutMs || config.cardNewsPlanner.timeoutMs;
+  const reasoningEffort = options.reasoningEffort || config.imageModels?.reasoningEffort || "medium";
   let text = "";
   let mode = "structured-output";
   try {
-    text = await requestJson({ oauthUrl, model, messages: input.messages, timeoutMs, structured: true });
+    text = await requestJson({ oauthUrl, model, messages: input.messages, timeoutMs, structured: true, reasoningEffort });
   } catch (err) {
     if (err.code !== "PLANNER_UPSTREAM_FAILED") throw err;
     mode = "json-mode";

package/lib/comfyBridge.js

@@ -0,0 +1,214 @@
+import { constants as fsConstants } from "node:fs";
+import { access, readFile, realpath, stat } from "node:fs/promises";
+import { basename, extname, isAbsolute, join, relative } from "node:path";
+
+export const COMFY_ERROR = {
+  URL_NOT_LOCAL: "COMFY_URL_NOT_LOCAL",
+  IMAGE_INVALID: "COMFY_IMAGE_INVALID",
+  IMAGE_NOT_FOUND: "COMFY_IMAGE_NOT_FOUND",
+  UPLOAD_FAILED: "COMFY_UPLOAD_FAILED",
+};
+
+const LOCAL_HOSTS = new Set(["127.0.0.1", "localhost", "[::1]"]);
+
+class ComfyBridgeError extends Error {
+  constructor(code, message, status) {
+    super(message);
+    this.name = "ComfyBridgeError";
+    this.code = code;
+    this.status = status;
+  }
+}
+
+function bridgeError(code, message, status) {
+  return new ComfyBridgeError(code, message, status);
+}
+
+export function isComfyBridgeError(error) {
+  return error instanceof ComfyBridgeError;
+}
+
+export function normalizeComfyOrigin(rawUrl) {
+  if (typeof rawUrl !== "string" || !rawUrl.trim()) {
+    throw bridgeError(COMFY_ERROR.URL_NOT_LOCAL, "ComfyUI URL is not configured.", 400);
+  }
+  const trimmed = rawUrl.trim();
+  const rawHost = trimmed.match(/^http:\/\/(?:[^@/]+@)?(\[[^\]]+\]|[^/:?#]+)/i)?.[1] ?? "";
+  if (
+    rawHost === "localhost." ||
+    /^\d+$/.test(rawHost) ||
+    /^0x/i.test(rawHost) ||
+    /^0[0-9]+/.test(rawHost) ||
+    (/^[0-9.]+$/.test(rawHost) && rawHost.split(".").length !== 4) ||
+    rawHost.split(".").some((part) => part.length > 1 && part.startsWith("0"))
+  ) {
+    throw bridgeError(COMFY_ERROR.URL_NOT_LOCAL, "ComfyUI URL is not local.", 400);
+  }
+  let url;
+  try {
+    url = new URL(trimmed);
+  } catch {
+    throw bridgeError(COMFY_ERROR.URL_NOT_LOCAL, "ComfyUI URL is invalid.", 400);
+  }
+  if (url.protocol !== "http:") {
+    throw bridgeError(COMFY_ERROR.URL_NOT_LOCAL, "ComfyUI URL must use HTTP.", 400);
+  }
+  if (url.username || url.password || !url.port) {
+    throw bridgeError(COMFY_ERROR.URL_NOT_LOCAL, "ComfyUI URL is not local.", 400);
+  }
+  if (!LOCAL_HOSTS.has(url.hostname)) {
+    throw bridgeError(COMFY_ERROR.URL_NOT_LOCAL, "ComfyUI URL is not local.", 400);
+  }
+  if (url.pathname !== "/" || url.search || url.hash) {
+    throw bridgeError(COMFY_ERROR.URL_NOT_LOCAL, "ComfyUI URL must be an origin.", 400);
+  }
+  return url.origin;
+}
+
+function hasEncodedSeparator(filename) {
+  try {
+    const decoded = decodeURIComponent(filename);
+    return decoded.includes("/") || decoded.includes("\\");
+  } catch {
+    return true;
+  }
+}
+
+function validateFilename(filename) {
+  if (typeof filename !== "string" || !filename.trim()) {
+    throw bridgeError(COMFY_ERROR.IMAGE_INVALID, "A generated filename is required.", 400);
+  }
+  if (
+    isAbsolute(filename) ||
+    filename !== basename(filename) ||
+    filename.includes("/") ||
+    filename.includes("\\") ||
+    filename.includes("..") ||
+    /^[a-z][a-z0-9+.-]*:/i.test(filename) ||
+    hasEncodedSeparator(filename)
+  ) {
+    throw bridgeError(COMFY_ERROR.IMAGE_INVALID, "Generated filename is invalid.", 400);
+  }
+  return filename;
+}
+
+function isInsideDirectory(parent, candidate) {
+  const rel = relative(parent, candidate);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+
+function sniffImage(buffer) {
+  if (
+    buffer.length >= 8 &&
+    buffer[0] === 0x89 &&
+    buffer[1] === 0x50 &&
+    buffer[2] === 0x4e &&
+    buffer[3] === 0x47 &&
+    buffer[4] === 0x0d &&
+    buffer[5] === 0x0a &&
+    buffer[6] === 0x1a &&
+    buffer[7] === 0x0a
+  ) {
+    return { ext: "png", mime: "image/png" };
+  }
+  if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
+    return { ext: "jpg", mime: "image/jpeg" };
+  }
+  if (
+    buffer.length >= 12 &&
+    buffer.subarray(0, 4).toString("ascii") === "RIFF" &&
+    buffer.subarray(8, 12).toString("ascii") === "WEBP"
+  ) {
+    return { ext: "webp", mime: "image/webp" };
+  }
+  throw bridgeError(COMFY_ERROR.IMAGE_INVALID, "Generated file is not a supported image.", 400);
+}
+
+function sanitizeBaseName(filename) {
+  const raw = basename(filename, extname(filename));
+  const safe = raw.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "");
+  return safe || "image";
+}
+
+async function readGeneratedImage(ctx, filename) {
+  const safeFilename = validateFilename(filename);
+  const generatedDir = await realpath(ctx.config.storage.generatedDir);
+  const candidatePath = join(ctx.config.storage.generatedDir, safeFilename);
+  try {
+    await access(candidatePath, fsConstants.F_OK);
+  } catch {
+    throw bridgeError(COMFY_ERROR.IMAGE_NOT_FOUND, "Generated image was not found.", 404);
+  }
+  let candidateReal;
+  try {
+    candidateReal = await realpath(candidatePath);
+  } catch {
+    throw bridgeError(COMFY_ERROR.IMAGE_NOT_FOUND, "Generated image was not found.", 404);
+  }
+  if (!isInsideDirectory(generatedDir, candidateReal)) {
+    throw bridgeError(COMFY_ERROR.IMAGE_INVALID, "Generated filename is invalid.", 400);
+  }
+  const info = await stat(candidateReal);
+  if (!info.isFile()) {
+    throw bridgeError(COMFY_ERROR.IMAGE_INVALID, "Generated filename is invalid.", 400);
+  }
+  if (info.size > ctx.config.comfy.maxUploadBytes) {
+    throw bridgeError(COMFY_ERROR.IMAGE_INVALID, "Generated image is too large.", 400);
+  }
+  const buffer = await readFile(candidateReal);
+  const imageType = sniffImage(buffer);
+  return {
+    buffer,
+    imageType,
+    sourceFilename: safeFilename,
+    uploadFilename: `ima2_${Date.now()}_${sanitizeBaseName(safeFilename)}.${imageType.ext}`,
+  };
+}
+
+async function postToComfy(origin, image, timeoutMs, fetchImpl = fetch) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const form = new FormData();
+    form.append("image", new Blob([image.buffer], { type: image.imageType.mime }), image.uploadFilename);
+    form.append("type", "input");
+    const res = await fetchImpl(`${origin}/upload/image`, {
+      method: "POST",
+      body: form,
+      redirect: "manual",
+      signal: controller.signal,
+    });
+    if (res.status >= 300 && res.status < 400) {
+      throw bridgeError(COMFY_ERROR.UPLOAD_FAILED, "Could not upload image to ComfyUI.", 502);
+    }
+    if (!res.ok) {
+      throw bridgeError(COMFY_ERROR.UPLOAD_FAILED, "Could not upload image to ComfyUI.", 502);
+    }
+    const data = await res.json().catch(() => null);
+    if (!data || typeof data.name !== "string" || !data.name.trim()) {
+      throw bridgeError(COMFY_ERROR.UPLOAD_FAILED, "Could not upload image to ComfyUI.", 502);
+    }
+    return data.name;
+  } catch (error) {
+    if (isComfyBridgeError(error)) throw error;
+    throw bridgeError(COMFY_ERROR.UPLOAD_FAILED, "Could not upload image to ComfyUI.", 502);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function exportImageToComfy(ctx, input, options = {}) {
+  const origin = normalizeComfyOrigin(options.comfyUrl ?? ctx.config.comfy.defaultUrl);
+  const image = await readGeneratedImage(ctx, input.filename);
+  const uploadedFilename = await postToComfy(
+    origin,
+    image,
+    ctx.config.comfy.uploadTimeoutMs,
+    options.fetchImpl,
+  );
+  return {
+    ok: true,
+    sourceFilename: image.sourceFilename,
+    uploadedFilename,
+  };
+}

package/lib/db.js

@@ -129,6 +129,20 @@ function migrate(database) {
       UNIQUE(browser_id, filename)
     );
 
+    CREATE TABLE IF NOT EXISTS image_annotations (
+      id             TEXT PRIMARY KEY,
+      browser_id     TEXT NOT NULL,
+      filename       TEXT NOT NULL,
+      payload        TEXT NOT NULL,
+      schema_version INTEGER NOT NULL DEFAULT 1,
+      created_at     INTEGER NOT NULL DEFAULT (unixepoch()),
+      updated_at     INTEGER NOT NULL DEFAULT (unixepoch()),
+      UNIQUE(browser_id, filename)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_image_annotations_filename
+      ON image_annotations(filename);
+
     INSERT OR IGNORE INTO prompt_folders (id, parent_id, name) VALUES
       ('__root__', '__root__', '__root__'),
       ('__trash__', '__root__', '__trash__');

package/lib/historyList.js

@@ -51,6 +51,10 @@ export async function listHistoryRows(baseDir = config.storage.generatedDir) {
       clientNodeId: meta?.clientNodeId || null,
       requestId: meta?.requestId || null,
       kind: meta?.kind || null,
+      canvasVersion: Boolean(meta?.canvasVersion),
+      canvasSourceFilename: meta?.canvasSourceFilename || null,
+      canvasEditableFilename: meta?.canvasEditableFilename || null,
+      canvasMergedAt: Number.isFinite(meta?.canvasMergedAt) ? meta.canvasMergedAt : null,
       setId: meta?.setId || null,
       cardId: meta?.cardId || null,
       cardOrder: Number.isFinite(meta?.cardOrder) ? meta.cardOrder : null,

package/lib/imageMetadata.js

@@ -39,6 +39,10 @@ export function buildIma2MetadataPayload(meta = {}, context = {}) {
     version: stringOrNull(context.version, 80) || null,
     createdAt: numberOrNull(meta.createdAt) || Date.now(),
     kind: stringOrNull(meta.kind, 80),
+    canvasVersion: Boolean(meta.canvasVersion),
+    canvasSourceFilename: stringOrNull(meta.canvasSourceFilename, 240),
+    canvasEditableFilename: stringOrNull(meta.canvasEditableFilename, 240),
+    canvasMergedAt: numberOrNull(meta.canvasMergedAt),
     prompt: stringOrNull(meta.prompt),
     userPrompt: stringOrNull(meta.userPrompt) || stringOrNull(meta.prompt),
     revisedPrompt: stringOrNull(meta.revisedPrompt),

package/lib/imageModels.js

@@ -1,6 +1,26 @@
 const FALLBACK_IMAGE_MODEL = "gpt-5.4-mini";
 const VALID_IMAGE_MODELS = new Set(["gpt-5.5", "gpt-5.4", "gpt-5.4-mini"]);
 const UNSUPPORTED_IMAGE_MODELS = new Set(["gpt-5.3-codex-spark"]);
+const FALLBACK_REASONING_EFFORT = "medium";
+const VALID_REASONING_EFFORTS = new Set(["low", "medium", "high", "xhigh"]);
+
+export function normalizeReasoningEffort(ctx, rawEffort) {
+  const configured = ctx?.config?.imageModels;
+  const fallback = configured?.reasoningEffort ?? FALLBACK_REASONING_EFFORT;
+  const valid = configured?.validReasoningEfforts ?? VALID_REASONING_EFFORTS;
+
+  if (typeof rawEffort !== "string" || rawEffort.length === 0) {
+    return { effort: valid.has(fallback) ? fallback : FALLBACK_REASONING_EFFORT };
+  }
+  if (!valid.has(rawEffort)) {
+    return {
+      error: "reasoningEffort must be one of: low, medium, high, xhigh",
+      code: "INVALID_REASONING_EFFORT",
+      status: 400,
+    };
+  }
+  return { effort: rawEffort };
+}
 
 export function normalizeImageModel(ctx, rawModel) {
   const configured = ctx?.config?.imageModels;

package/lib/localImportStore.js

@@ -0,0 +1,111 @@
+import { mkdir, writeFile } from "fs/promises";
+import { basename, join, normalize } from "path";
+import { randomBytes } from "crypto";
+import { embedImageMetadataBestEffort } from "./imageMetadataStore.js";
+
+const PNG_SIGNATURE_HEX = "89504e470d0a1a0a";
+const JPEG_SIGNATURE_HEX = "ffd8ff";
+const WEBP_RIFF_HEAD = "52494646";
+const WEBP_VP_TAIL = "57454250";
+
+function detectFormat(buffer) {
+  if (!Buffer.isBuffer(buffer) || buffer.length < 12) return null;
+  const head8 = buffer.subarray(0, 8).toString("hex");
+  if (head8 === PNG_SIGNATURE_HEX) return "png";
+  if (head8.startsWith(JPEG_SIGNATURE_HEX)) return "jpeg";
+  if (
+    buffer.subarray(0, 4).toString("hex") === WEBP_RIFF_HEAD &&
+    buffer.subarray(8, 12).toString("hex") === WEBP_VP_TAIL
+  ) {
+    return "webp";
+  }
+  return null;
+}
+
+function ensureInsideGeneratedDir(generatedDir, filename) {
+  const full = normalize(join(generatedDir, filename));
+  const root = normalize(generatedDir);
+  if (!full.startsWith(root)) {
+    const err = new Error("Imported path escapes generated directory");
+    err.status = 400;
+    err.code = "IMPORT_PATH_ESCAPE";
+    throw err;
+  }
+  return full;
+}
+
+function makeImportedFilename(format) {
+  const stamp = new Date().toISOString().slice(0, 19).replace(/[-:T]/g, "");
+  const rand = randomBytes(3).toString("hex");
+  return `imported-${stamp}-${rand}.${format}`;
+}
+
+function safeOriginalName(input) {
+  if (typeof input !== "string" || !input) return null;
+  const trimmed = input.slice(0, 200);
+  return basename(trimmed);
+}
+
+export async function createLocalImport(ctx, { buffer, originalFilename }) {
+  if (!Buffer.isBuffer(buffer) || buffer.length === 0) {
+    const err = new Error("Image body is required");
+    err.status = 400;
+    err.code = "EMPTY_IMPORT";
+    throw err;
+  }
+  const format = detectFormat(buffer);
+  if (!format) {
+    const err = new Error("Only PNG, JPEG, or WebP is supported");
+    err.status = 400;
+    err.code = "IMPORT_BAD_FORMAT";
+    throw err;
+  }
+  const filename = makeImportedFilename(format);
+  const fullPath = ensureInsideGeneratedDir(ctx.config.storage.generatedDir, filename);
+  await mkdir(ctx.config.storage.generatedDir, { recursive: true });
+
+  const meta = {
+    schema: "ima2.generation.v1",
+    app: "ima2-gen",
+    version: ctx.packageVersion,
+    createdAt: Date.now(),
+    kind: "imported",
+    canvasVersion: false,
+    originalFilename: safeOriginalName(originalFilename),
+    format,
+  };
+  const embedded = await embedImageMetadataBestEffort(buffer, format, meta, {
+    version: ctx.packageVersion,
+  });
+  await writeFile(fullPath, embedded.buffer);
+  await writeFile(`${fullPath}.json`, JSON.stringify(meta)).catch(() => {});
+
+  const url = `/generated/${encodeURIComponent(filename)}`;
+  return {
+    filename,
+    url,
+    image: url,
+    thumb: url,
+    createdAt: meta.createdAt,
+    format,
+    kind: "imported",
+    canvasVersion: false,
+    canvasSourceFilename: null,
+    canvasEditableFilename: null,
+    prompt: null,
+    userPrompt: null,
+    revisedPrompt: null,
+    promptMode: null,
+    quality: null,
+    size: null,
+    model: null,
+    provider: null,
+    usage: null,
+    webSearchCalls: 0,
+    sessionId: null,
+    nodeId: null,
+    parentNodeId: null,
+    refsCount: 0,
+    isFavorite: false,
+  };
+}