@origingame/origin-asset 0.12.0

package/dist/index.js

@@ -0,0 +1,1449 @@
+// src/generate.ts
+function copyParams(params) {
+  if (!params) {
+    return void 0;
+  }
+  return { ...params };
+}
+function mergeParams(base, extra) {
+  const merged = {
+    ...base ?? {},
+    ...extra ?? {}
+  };
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function resolveAssetUrl(baseUrl, value) {
+  if (!value) {
+    return null;
+  }
+  try {
+    return new URL(value, ensureTrailingSlash(baseUrl)).toString();
+  } catch {
+    return value;
+  }
+}
+function normalizeGenerateResponse(baseUrl, response) {
+  const outputUrl = resolveAssetUrl(baseUrl, response.output_url);
+  return {
+    ...response,
+    output_url: outputUrl,
+    output_files: response.output_files?.map((file) => ({
+      ...file,
+      url: resolveAssetUrl(baseUrl, file.url) ?? file.url
+    })),
+    url: outputUrl
+  };
+}
+function normalizeBatchResponse(baseUrl, response) {
+  return {
+    ...response,
+    frames: response.frames.map((frame) => normalizeBatchFrame(baseUrl, frame))
+  };
+}
+function normalizeBatchFrame(baseUrl, frame) {
+  const outputUrl = resolveAssetUrl(baseUrl, frame.output_url);
+  return {
+    ...frame,
+    output_url: outputUrl,
+    url: outputUrl
+  };
+}
+function normalizeUploadResult(baseUrl, response) {
+  return {
+    ...response,
+    url: resolveAssetUrl(baseUrl, response.url) ?? response.url
+  };
+}
+function normalizeAssetFile(baseUrl, file) {
+  return {
+    ...file,
+    url: resolveAssetUrl(baseUrl, file.url) ?? file.url
+  };
+}
+function normalizeMaybeGenerateResponse(baseUrl, value) {
+  if (!isRecord(value)) {
+    return value;
+  }
+  const outputUrl = typeof value.output_url === "string" ? resolveAssetUrl(baseUrl, value.output_url) : null;
+  if (!outputUrl) {
+    return value;
+  }
+  return {
+    ...value,
+    output_url: outputUrl,
+    output_files: Array.isArray(value.output_files) ? value.output_files.map((file) => {
+      if (!isRecord(file) || typeof file.url !== "string") {
+        return file;
+      }
+      return { ...file, url: resolveAssetUrl(baseUrl, file.url) ?? file.url };
+    }) : value.output_files,
+    url: outputUrl
+  };
+}
+function buildImageRequest(prompt, options = {}) {
+  const request = {
+    asset_type: "image",
+    prompt
+  };
+  if (options.provider) request.provider = options.provider;
+  if (options.model) request.model = options.model;
+  if (options.size) request.size = options.size;
+  if (options.transparent !== void 0) request.transparent = options.transparent;
+  if (options.input) request.input_file = options.input;
+  if (options.reference_images?.length) request.reference_images = options.reference_images;
+  if (options.edit_mode) request.edit_mode = options.edit_mode;
+  if (options.session_id) request.session_id = options.session_id;
+  const params = mergeParams(options.params, {
+    ...options.quality ? { quality: options.quality } : {},
+    ...options.background ? { background: options.background } : {},
+    ...options.output_format ? { output_format: options.output_format } : {},
+    ...options.n !== void 0 ? { n: options.n } : {},
+    ...options.preset ? { preset: options.preset } : {},
+    ...options.mask ? { mask: options.mask } : {},
+    ...options.mask_url ? { mask_url: options.mask_url } : {}
+  });
+  if (params) request.params = params;
+  return request;
+}
+function buildGeneratedAssetRequest(assetType, prompt, options = {}) {
+  const params = mergeParams(options.params, {
+    ...assetType === "skybox" ? { preset_hint: "skybox_equirect" } : {},
+    ...assetType === "decal" ? { preset_hint: "decal_transparent" } : {},
+    ...assetType === "heightmap" ? { preset_hint: "heightmap_grayscale" } : {},
+    ...options.quality ? { quality: options.quality } : {},
+    ...options.background ? { background: options.background } : {},
+    ...options.output_format ? { output_format: options.output_format } : {},
+    ...options.n !== void 0 ? { n: options.n } : {},
+    ...options.preset ? { preset: options.preset } : {}
+  });
+  return {
+    asset_type: assetType,
+    prompt,
+    provider: options.provider,
+    model: options.model,
+    input_file: options.input,
+    size: options.size,
+    transparent: options.transparent,
+    params
+  };
+}
+function buildVideoRequest(prompt, options = {}) {
+  const request = {
+    asset_type: "video",
+    prompt
+  };
+  if (options.provider) request.provider = options.provider;
+  if (options.model) request.model = options.model;
+  if (options.size) request.size = options.size;
+  if (options.reference_images?.length) request.reference_images = options.reference_images;
+  const params = copyParams(options.params);
+  if (options.ratio) {
+    request.params = { ...params, ratio: options.ratio };
+  } else if (params) {
+    request.params = params;
+  }
+  return request;
+}
+function buildAudioRequest(prompt, options = {}) {
+  return {
+    asset_type: "audio",
+    prompt,
+    provider: options.provider,
+    model: options.model,
+    params: mergeParams(options.params, {
+      ...options.type ? { audio_type: options.type } : {},
+      ...options.duration !== void 0 ? { duration_seconds: options.duration } : {}
+    })
+  };
+}
+function buildMusicRequest(prompt, options = {}) {
+  return {
+    asset_type: "music",
+    prompt,
+    provider: options.provider,
+    model: options.model,
+    params: mergeParams(options.params, {
+      ...options.duration !== void 0 ? { duration_seconds: options.duration } : {},
+      ...options.force_instrumental ? { force_instrumental: true } : {},
+      ...options.output_format ? { output_format: options.output_format } : {}
+    })
+  };
+}
+function buildTtsRequest(prompt, options = {}) {
+  const context = options.context ?? options.instructions;
+  return {
+    asset_type: "tts",
+    prompt,
+    provider: options.provider,
+    model: options.model,
+    params: mergeParams(options.params, {
+      ...options.voice ? { voice: options.voice } : {},
+      ...options.voice_id ? { voice_id: options.voice_id } : {},
+      ...context ? { context } : {},
+      ...options.style ? { style: options.style } : {},
+      ...options.language ? { language_type: options.language } : {},
+      ...options.instructions ? { instructions: options.instructions } : {}
+    })
+  };
+}
+function buildModel3dRequest(prompt, options = {}) {
+  return {
+    asset_type: "model3d",
+    prompt,
+    provider: options.provider,
+    model: options.model,
+    input_file: options.input,
+    params: mergeParams(options.params, {
+      ...options.ai_model ? { ai_model: options.ai_model } : {},
+      ...options.polycount !== void 0 ? { target_polycount: options.polycount } : {},
+      ...options.pbr ? { pbr: true } : {},
+      ...options.hd_texture ? { hd_texture: true } : {},
+      ...options.auto_size ? { auto_size: true } : {},
+      ...options.pose_mode ? { pose_mode: options.pose_mode } : {},
+      ...options.texture_prompt ? { texture_prompt: options.texture_prompt } : {},
+      ...options.format ? { format: options.format } : {},
+      ...options.images?.length ? { images: options.images } : {}
+    })
+  };
+}
+function buildCharacterRequest(prompt, options = {}) {
+  return {
+    asset_type: "character",
+    prompt,
+    provider: options.provider,
+    model: options.model,
+    input_file: options.input,
+    params: mergeParams(options.params, {
+      ...options.format ? { format: options.format } : {},
+      ...options.polycount !== void 0 ? { target_polycount: options.polycount } : {},
+      ...options.pbr ? { pbr: true } : {},
+      ...options.hd_texture ? { hd_texture: true } : {},
+      ...options.pose_mode ? { pose_mode: options.pose_mode } : {},
+      ...options.ai_model ? { ai_model: options.ai_model } : {},
+      ...options.auto_size ? { auto_size: true } : {},
+      ...options.texture_prompt ? { texture_prompt: options.texture_prompt } : {},
+      ...options.images?.length ? { images: options.images } : {}
+    })
+  };
+}
+function buildPropRequest(prompt, options = {}) {
+  return {
+    asset_type: "prop",
+    prompt,
+    provider: options.provider,
+    model: options.model,
+    input_file: options.input,
+    params: mergeParams(options.params, {
+      ...options.format ? { format: options.format } : {},
+      ...options.polycount !== void 0 ? { target_polycount: options.polycount } : {},
+      ...options.pbr ? { pbr: true } : {},
+      ...options.hd_texture ? { hd_texture: true } : {},
+      ...options.ai_model ? { ai_model: options.ai_model } : {},
+      ...options.auto_size ? { auto_size: true } : {},
+      ...options.texture_prompt ? { texture_prompt: options.texture_prompt } : {},
+      ...options.symmetry_mode ? { symmetry_mode: options.symmetry_mode } : {},
+      ...options.images?.length ? { images: options.images } : {}
+    })
+  };
+}
+function buildSpriteRequest(prompt, options = {}) {
+  return {
+    asset_type: "sprite",
+    prompt,
+    provider: options.provider,
+    model: options.model,
+    input_file: options.input,
+    params: mergeParams(options.params, {
+      animation_type: options.animation_type ?? "walk",
+      direction: options.direction ?? "right",
+      duration: options.duration ?? 2,
+      output_format: options.output_format ?? "spritesheet",
+      ...options.fps !== void 0 ? { fps: options.fps } : {},
+      ...options.style ? { style: options.style } : {}
+    })
+  };
+}
+function buildWorldRequest(prompt, options = {}) {
+  return {
+    asset_type: "world",
+    prompt,
+    provider: options.provider,
+    model: options.model,
+    input_file: options.input ?? options.image_url,
+    params: mergeParams(options.params, {
+      ...options.display_name ? { display_name: options.display_name } : {},
+      ...options.image_url ? { image_url: options.image_url } : {},
+      ...options.panorama_url ? { panorama_url: options.panorama_url } : {},
+      ...options.video_url ? { video_url: options.video_url } : {},
+      ...options.multi_image_url?.length ? { multi_image_url: options.multi_image_url } : {},
+      ...options.quality ? { quality: options.quality } : {}
+    })
+  };
+}
+function buildTextRequest(prompt, options = {}) {
+  return {
+    asset_type: "text",
+    prompt,
+    provider: options.provider,
+    model: options.model,
+    params: mergeParams(options.params, {
+      ...options.max_tokens !== void 0 ? { max_tokens: options.max_tokens } : {}
+    })
+  };
+}
+function ensureTrailingSlash(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/types.ts
+var AssetForgeError = class extends Error {
+  code;
+  status;
+  command;
+  details;
+  constructor(message, options = {}) {
+    super(message, options.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "AssetForgeError";
+    this.code = options.code ?? "ASSETFORGE_ERROR";
+    this.status = options.status;
+    this.command = options.command;
+    this.details = options.details;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+function toAssetForgeError(error) {
+  if (error instanceof AssetForgeError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    return new AssetForgeError(error.message, {
+      code: "INTERNAL_ERROR",
+      cause: error
+    });
+  }
+  return new AssetForgeError(String(error), { code: "INTERNAL_ERROR" });
+}
+
+// src/stream.ts
+function subscribeJob(jobId, handler, options = {}) {
+  return subscribeSse(`/api/jobs/${encodeURIComponent(jobId)}/events`, handler, options);
+}
+function subscribeAllJobs(handler, options = {}) {
+  return subscribeSse("/api/jobs/events", handler, options);
+}
+var AssetForgeStreamNamespace = class {
+  constructor(forge) {
+    this.forge = forge;
+  }
+  forge;
+  job(jobId, handler, options = {}) {
+    return subscribeJob(jobId, handler, this.options(options));
+  }
+  all(handler, options = {}) {
+    return subscribeAllJobs(handler, this.options(options));
+  }
+  options(options) {
+    return {
+      ...options,
+      baseUrl: this.forge.baseUrl,
+      apiKey: this.forge.apiKey
+    };
+  }
+};
+function subscribeSse(path, handler, options) {
+  const controller = new AbortController();
+  linkAbortSignals(options.signal, controller);
+  const result = runSse(path, handler, options, controller.signal);
+  void result.catch(() => void 0);
+  return {
+    signal: controller.signal,
+    result,
+    close: (reason = "closed") => controller.abort(reason)
+  };
+}
+async function runSse(path, handler, options, signal) {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new AssetForgeError("Global fetch is unavailable in this runtime", {
+      code: "FETCH_UNAVAILABLE"
+    });
+  }
+  const headers = new Headers(options.headers);
+  headers.set("accept", "text/event-stream");
+  if (options.apiKey) {
+    headers.set("authorization", `Bearer ${options.apiKey}`);
+  }
+  const response = await fetchImpl(new URL(path, ensureTrailingSlash2(options.baseUrl ?? DEFAULT_BASE_URL)), {
+    method: "GET",
+    headers,
+    signal
+  });
+  if (!response.ok) {
+    throw new AssetForgeError(`SSE subscription failed (${response.status})`, {
+      code: defaultErrorCode(response.status),
+      status: response.status
+    });
+  }
+  if (!response.body) {
+    throw new AssetForgeError("SSE response body is unavailable", { code: "STREAM_UNAVAILABLE" });
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (!signal.aborted) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    buffer += decoder.decode(value, { stream: true });
+    buffer = drainFrames(buffer, handler);
+  }
+  const finalText = decoder.decode();
+  if (finalText) {
+    buffer += finalText;
+  }
+  drainFrames(`${buffer}
+
+`, handler);
+}
+function drainFrames(buffer, handler) {
+  let normalized = buffer.replace(/\r\n/g, "\n");
+  let boundary = normalized.indexOf("\n\n");
+  while (boundary !== -1) {
+    const frame = normalized.slice(0, boundary);
+    normalized = normalized.slice(boundary + 2);
+    const parsed = parseFrame(frame);
+    if (parsed) {
+      handler(normalizeJobEvent(parsed.event, parsed.data));
+    }
+    boundary = normalized.indexOf("\n\n");
+  }
+  return normalized;
+}
+function parseFrame(frame) {
+  let event = "message";
+  const data = [];
+  for (const line of frame.split("\n")) {
+    if (!line || line.startsWith(":")) {
+      continue;
+    }
+    const separator = line.indexOf(":");
+    const field = separator === -1 ? line : line.slice(0, separator);
+    const value = separator === -1 ? "" : line.slice(separator + 1).replace(/^ /, "");
+    if (field === "event") {
+      event = value;
+    } else if (field === "data") {
+      data.push(value);
+    }
+  }
+  return data.length ? { event, data: data.join("\n") } : null;
+}
+function normalizeJobEvent(eventName, data) {
+  const raw = parseJson(data);
+  const record = isRecord2(raw) ? raw : {};
+  const kind = eventName === "snapshot" || eventName === "progress" || eventName === "update" ? eventName : "update";
+  return {
+    kind,
+    job_id: stringField(record.job_id) ?? stringField(record.id) ?? "",
+    status: stringField(record.status) ?? "unknown",
+    progress: extractProgress(record),
+    output_url: stringField(record.output_url),
+    error_message: stringField(record.error_message),
+    timestamp: stringField(record.timestamp) ?? (/* @__PURE__ */ new Date()).toISOString(),
+    raw
+  };
+}
+function extractProgress(record) {
+  const nested = isRecord2(record.progress) ? record.progress : void 0;
+  const progress = {
+    ...nested ?? {}
+  };
+  if (typeof record.progress === "number") progress.progress = record.progress;
+  if (typeof record.current_step === "string") progress.current_step = record.current_step;
+  if (typeof record.step_index === "number") progress.step_index = record.step_index;
+  if (typeof record.step_count === "number") progress.step_count = record.step_count;
+  if (typeof record.message === "string") progress.message = record.message;
+  if (record.details !== void 0) progress.details = record.details;
+  return Object.keys(progress).length > 0 ? progress : void 0;
+}
+function parseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function stringField(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function linkAbortSignals(source, controller) {
+  if (!source) {
+    return;
+  }
+  if (source.aborted) {
+    controller.abort(source.reason);
+    return;
+  }
+  const onAbort = () => {
+    controller.abort(source.reason);
+    source.removeEventListener("abort", onAbort);
+  };
+  source.addEventListener("abort", onAbort, { once: true });
+}
+function ensureTrailingSlash2(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+function defaultErrorCode(status) {
+  if (status === 401) return "UNAUTHORIZED";
+  if (status === 403) return "FORBIDDEN";
+  if (status === 404) return "NOT_FOUND";
+  if (status === 409) return "CONFLICT";
+  return "API_ERROR";
+}
+
+// src/jobs.ts
+var AssetForgeJobs = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async list(query = {}, options = {}) {
+    return this.transport.request("GET", "/api/jobs", {
+      query: {
+        job_kind: query.job_kind,
+        status: query.status,
+        asset_type: query.asset_type,
+        provider_id: query.provider_id,
+        since: query.since,
+        provider_task_id: query.provider_task_id,
+        limit: query.limit,
+        offset: query.offset
+      },
+      signal: options.signal,
+      headers: options.headers
+    });
+  }
+  async status(id, options = {}) {
+    const job = await this.transport.request(
+      "GET",
+      `/api/jobs/${encodeURIComponent(id)}`,
+      {
+        signal: options.signal,
+        headers: options.headers
+      }
+    );
+    return {
+      ...job,
+      response: job.response !== void 0 && job.response !== null ? normalizeMaybeGenerateResponse(this.transport.baseUrl, job.response) : job.response
+    };
+  }
+  async cancel(id, options = {}) {
+    return this.transport.request(
+      "POST",
+      `/api/jobs/${encodeURIComponent(id)}/cancel`,
+      {
+        signal: options.signal,
+        headers: options.headers
+      }
+    );
+  }
+  async wait(id, options = {}) {
+    const intervalMs = Math.max(250, options.intervalMs ?? options.interval_ms ?? 1e3);
+    const deadline = options.timeoutMs !== void 0 ? Date.now() + options.timeoutMs : void 0;
+    try {
+      return await this.waitWithSse(id, options);
+    } catch (error) {
+      if (error instanceof AssetForgeError && error.code === "JOB_WAIT_TIMEOUT") {
+        throw error;
+      }
+      if (options.signal?.aborted) {
+        throw new AssetForgeError("Job wait aborted", { code: "ABORTED", cause: error });
+      }
+    }
+    while (true) {
+      if (options.signal?.aborted) {
+        throw new AssetForgeError("Job wait aborted", { code: "ABORTED" });
+      }
+      if (deadline !== void 0 && Date.now() >= deadline) {
+        throw new AssetForgeError(`Timed out waiting for job ${id}`, { code: "JOB_WAIT_TIMEOUT" });
+      }
+      const job = await this.status(id, options);
+      if (isTerminalStatus(job.status)) {
+        return assertSuccessfulJob(job);
+      }
+      const sleepMs = deadline === void 0 ? intervalMs : Math.min(intervalMs, Math.max(0, deadline - Date.now()));
+      await sleep(sleepMs, options.signal);
+    }
+  }
+  waitWithSse(id, options) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let timeout;
+      const subscription = subscribeJob(
+        id,
+        (event) => {
+          if (!isTerminalStatus(event.status) || settled) {
+            return;
+          }
+          settled = true;
+          if (timeout) clearTimeout(timeout);
+          subscription.close("terminal");
+          void this.status(id, options).then(
+            (job) => {
+              try {
+                resolve(assertSuccessfulJob(job));
+              } catch (error) {
+                reject(error);
+              }
+            },
+            () => reject(errorFromEvent(event))
+          );
+        },
+        {
+          baseUrl: this.transport.baseUrl,
+          apiKey: this.transport.apiKey,
+          signal: options.signal,
+          headers: options.headers
+        }
+      );
+      if (options.timeoutMs !== void 0) {
+        timeout = setTimeout(() => {
+          if (!settled) {
+            settled = true;
+            subscription.close("timeout");
+            reject(new AssetForgeError(`Timed out waiting for job ${id}`, { code: "JOB_WAIT_TIMEOUT" }));
+          }
+        }, options.timeoutMs);
+      }
+      void subscription.result.then(
+        () => {
+          if (!settled) {
+            if (timeout) clearTimeout(timeout);
+            reject(new AssetForgeError("SSE stream ended before job completed", { code: "STREAM_ENDED" }));
+          }
+        },
+        (error) => {
+          if (!settled) {
+            if (timeout) clearTimeout(timeout);
+            reject(error);
+          }
+        }
+      );
+    });
+  }
+};
+function isTerminalStatus(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+function assertSuccessfulJob(job) {
+  if (job.status === "cancelled") {
+    throw new AssetForgeError(job.error_message ?? "Job cancelled", {
+      code: "JOB_CANCELLED",
+      details: job
+    });
+  }
+  if (job.status === "failed") {
+    throw new AssetForgeError(job.error_message ?? "Job failed", {
+      code: "JOB_FAILED",
+      details: job
+    });
+  }
+  return job;
+}
+function errorFromEvent(event) {
+  if (event.status === "cancelled") {
+    return new AssetForgeError(event.error_message ?? "Job cancelled", {
+      code: "JOB_CANCELLED",
+      details: event.raw
+    });
+  }
+  return new AssetForgeError(event.error_message ?? `Job ${event.status}`, {
+    code: event.status === "failed" ? "JOB_FAILED" : "API_ERROR",
+    details: event.raw
+  });
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new AssetForgeError("Operation aborted", { code: "ABORTED" }));
+      return;
+    }
+    const timeout = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timeout);
+      cleanup();
+      reject(new AssetForgeError("Operation aborted", { code: "ABORTED" }));
+    };
+    const cleanup = () => signal?.removeEventListener("abort", onAbort);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/library.ts
+var AssetForgeLibrary = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async search(query = {}, options = {}) {
+    return this.transport.request("GET", "/api/library/search", {
+      query: {
+        q: query.q ?? query.query,
+        type: query.type,
+        tags: query.tags,
+        source: query.source,
+        pack_id: query.pack_id,
+        mode: query.mode,
+        style: query.style,
+        composition: query.composition,
+        lighting: query.lighting,
+        color_tone: query.color_tone,
+        mood: query.mood,
+        theme: query.theme,
+        era: query.era,
+        gameplay_role: query.gameplay_role,
+        ui_element: query.ui_element,
+        ui_state: query.ui_state,
+        ui_theme_pack: query.ui_theme_pack,
+        nine_slice: query.nine_slice,
+        size_class: query.size_class,
+        rig_name: query.rig_name,
+        compatible_rig: query.compatible_rig,
+        enrichment_status: query.enrichment_status,
+        min_long_edge_px: query.min_long_edge_px,
+        min_width_px: query.min_width_px,
+        min_height_px: query.min_height_px,
+        max_file_size_bytes: query.max_file_size_bytes,
+        license: query.license,
+        rerank: query.rerank,
+        limit: query.limit,
+        offset: query.offset
+      },
+      signal: options.signal,
+      headers: options.headers
+    });
+  }
+  async related(id, query = {}, options = {}) {
+    return this.transport.request(
+      "GET",
+      `/api/library/${encodeURIComponent(id)}/related`,
+      {
+        query: {
+          type: query.type,
+          limit: query.limit
+        },
+        signal: options.signal,
+        headers: options.headers
+      }
+    );
+  }
+  async bundle(request, options = {}) {
+    const url = new URL("/api/library/bundle", ensureTrailingSlash3(this.transport.baseUrl));
+    const headers = new Headers(options.headers);
+    if (this.transport.apiKey) {
+      headers.set("authorization", `Bearer ${this.transport.apiKey}`);
+    }
+    headers.set("content-type", "application/json");
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request),
+      signal: options.signal
+    });
+    if (!response.ok) {
+      throw await bundleError(response);
+    }
+    return response.blob();
+  }
+  async ingest(request, options = {}) {
+    return this.transport.request("POST", "/api/library/ingest", {
+      body: request,
+      signal: options.signal,
+      headers: options.headers
+    });
+  }
+  async ingestSync(request, options = {}) {
+    return this.transport.request("POST", "/api/library/ingest/sync", {
+      body: request,
+      signal: options.signal,
+      headers: options.headers
+    });
+  }
+  async ingestStatus(jobId, options = {}) {
+    return this.transport.request(
+      "GET",
+      `/api/library/ingest/${encodeURIComponent(jobId)}`,
+      {
+        signal: options.signal,
+        headers: options.headers
+      }
+    );
+  }
+  async ingestWait(jobId, opts = {}) {
+    const intervalMs = Math.max(opts.intervalMs ?? 1e3, 250);
+    for (; ; ) {
+      const job = await this.ingestStatus(jobId, opts);
+      if (job.status === "completed") {
+        return ingestResultFromJob(job);
+      }
+      if (job.status === "failed" || job.status === "cancelled") {
+        throw new AssetForgeError(job.error_message ?? `Library ingest job ${jobId} ${job.status}`, {
+          code: job.status === "cancelled" ? "JOB_CANCELLED" : "API_ERROR",
+          details: job
+        });
+      }
+      await sleep2(intervalMs, opts.signal);
+    }
+  }
+  async packs(options = {}) {
+    return this.transport.request("GET", "/api/library/packs", {
+      signal: options.signal,
+      headers: options.headers
+    });
+  }
+  async packsInstall(request, options = {}) {
+    return this.transport.request("POST", "/api/library/packs/install", {
+      body: request,
+      signal: options.signal,
+      headers: options.headers
+    });
+  }
+  async packsDelete(id, options = {}) {
+    return this.transport.request(
+      "DELETE",
+      `/api/library/packs/${encodeURIComponent(id)}`,
+      {
+        signal: options.signal,
+        headers: options.headers
+      }
+    );
+  }
+  async packsRefresh(id, options = {}) {
+    return this.transport.request(
+      "POST",
+      `/api/library/packs/${encodeURIComponent(id)}/refresh`,
+      {
+        body: {},
+        signal: options.signal,
+        headers: options.headers
+      }
+    );
+  }
+  async add(request, options = {}) {
+    return this.transport.request(
+      "POST",
+      "/api/library",
+      {
+        body: request,
+        signal: options.signal,
+        headers: options.headers
+      }
+    );
+  }
+  async get(id, options = {}) {
+    return this.transport.request(
+      "GET",
+      `/api/library/${encodeURIComponent(id)}`,
+      {
+        signal: options.signal,
+        headers: options.headers
+      }
+    );
+  }
+  async delete(id, options = {}) {
+    return this.transport.request(
+      "DELETE",
+      `/api/library/${encodeURIComponent(id)}`,
+      {
+        signal: options.signal,
+        headers: options.headers
+      }
+    );
+  }
+  async catalogJobs(request = {}, options = {}) {
+    return this.transport.request("POST", "/api/library/catalog-jobs", {
+      body: request,
+      signal: options.signal,
+      headers: options.headers
+    });
+  }
+  async backfill(request = {}, options = {}) {
+    return this.transport.request("POST", "/api/library/admin/backfill", {
+      body: request,
+      signal: options.signal,
+      headers: options.headers
+    });
+  }
+  async reenrich(request = {}, options = {}) {
+    return this.transport.request("POST", "/api/library/admin/reenrich", {
+      body: request,
+      signal: options.signal,
+      headers: options.headers
+    });
+  }
+};
+function ingestResultFromJob(job) {
+  const response = job.response;
+  if (isIngestResult(response)) {
+    return response;
+  }
+  throw new AssetForgeError(`Library ingest job ${job.id} completed without an ingest result`, {
+    code: "API_ERROR",
+    details: job
+  });
+}
+function isIngestResult(value) {
+  return typeof value === "object" && value !== null && typeof value.library_id === "string" && typeof value.skipped === "boolean" && typeof value.embedding_dim === "number";
+}
+function ensureTrailingSlash3(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+async function bundleError(response) {
+  const text = await response.text();
+  let payload = text;
+  try {
+    payload = JSON.parse(text);
+  } catch {
+  }
+  const message = extractErrorMessage(payload) ?? `AssetForge API error (${response.status})`;
+  return new AssetForgeError(message, {
+    code: response.status === 404 ? "NOT_FOUND" : "API_ERROR",
+    status: response.status,
+    details: payload
+  });
+}
+function extractErrorMessage(payload) {
+  if (typeof payload === "string") {
+    return payload || void 0;
+  }
+  if (typeof payload !== "object" || payload === null) {
+    return void 0;
+  }
+  const error = payload.error;
+  if (typeof error === "string") {
+    return error;
+  }
+  if (typeof error === "object" && error !== null) {
+    const message = error.message;
+    return typeof message === "string" ? message : void 0;
+  }
+  return void 0;
+}
+function sleep2(ms, signal) {
+  if (signal?.aborted) {
+    return Promise.reject(new AssetForgeError("The operation was aborted", { code: "ABORTED" }));
+  }
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(new AssetForgeError("The operation was aborted", { code: "ABORTED" }));
+      },
+      { once: true }
+    );
+  });
+}
+
+// src/providers.ts
+var AssetForgeProviders = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async list(options = {}) {
+    return this.transport.request("GET", "/api/providers", {
+      signal: options.signal,
+      headers: options.headers
+    });
+  }
+  async health(idOrOptions, maybeOptions = {}) {
+    if (typeof idOrOptions === "string") {
+      return this.transport.request(
+        "GET",
+        `/api/providers/${encodeURIComponent(idOrOptions)}/health`,
+        {
+          signal: maybeOptions.signal,
+          headers: maybeOptions.headers
+        }
+      );
+    }
+    const options = idOrOptions ?? {};
+    return this.transport.request("GET", "/api/providers/health", {
+      signal: options.signal,
+      headers: options.headers
+    });
+  }
+};
+
+// src/upload.ts
+var AssetForgeAssets = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async upload(input, options = {}) {
+    const form = new FormData();
+    const { blob, filename } = normalizeUploadInput(input, options);
+    form.append("file", blob, filename);
+    const result = await this.transport.request("POST", "/api/assets/upload", {
+      form,
+      signal: options.signal,
+      headers: options.headers
+    });
+    return normalizeUploadResult(this.transport.baseUrl, result);
+  }
+  async list(options = {}) {
+    const result = await this.transport.request("GET", "/api/assets", {
+      signal: options.signal,
+      headers: options.headers
+    });
+    return {
+      ...result,
+      files: result.files.map((file) => normalizeAssetFile(this.transport.baseUrl, file))
+    };
+  }
+  async delete(filename, options = {}) {
+    return this.transport.request(
+      "DELETE",
+      `/api/assets/${encodeURIComponent(filename)}`,
+      {
+        signal: options.signal,
+        headers: options.headers
+      }
+    );
+  }
+};
+function normalizeUploadInput(input, options) {
+  if (typeof File !== "undefined" && input instanceof File) {
+    return {
+      blob: input,
+      filename: options.filename ?? input.name
+    };
+  }
+  if (input instanceof Blob) {
+    return {
+      blob: input,
+      filename: options.filename ?? inferFilename(input.type, "upload")
+    };
+  }
+  if (input instanceof ArrayBuffer) {
+    return {
+      blob: new Blob([input], { type: options.type ?? "application/octet-stream" }),
+      filename: options.filename ?? inferFilename(options.type, "upload")
+    };
+  }
+  if (input instanceof Uint8Array) {
+    const arrayBuffer = new Uint8Array(input).buffer;
+    return {
+      blob: new Blob([arrayBuffer], { type: options.type ?? "application/octet-stream" }),
+      filename: options.filename ?? inferFilename(options.type, "upload")
+    };
+  }
+  if (typeof input === "object" && input !== null && "data" in input) {
+    if (!input.filename.trim()) {
+      throw new AssetForgeError("Upload filename cannot be empty", {
+        code: "INVALID_UPLOAD_INPUT"
+      });
+    }
+    return {
+      blob: new Blob(Array.isArray(input.data) ? input.data : [input.data], {
+        type: input.type ?? options.type ?? "application/octet-stream"
+      }),
+      filename: options.filename ?? input.filename
+    };
+  }
+  throw new AssetForgeError("Unsupported upload input", {
+    code: "INVALID_UPLOAD_INPUT"
+  });
+}
+function inferFilename(contentType, basename) {
+  const extension = mimeToExtension(contentType);
+  return extension ? `${basename}.${extension}` : `${basename}.bin`;
+}
+function mimeToExtension(contentType) {
+  switch (contentType) {
+    case "image/png":
+      return "png";
+    case "image/jpeg":
+      return "jpg";
+    case "image/webp":
+      return "webp";
+    case "video/mp4":
+      return "mp4";
+    case "audio/mpeg":
+      return "mp3";
+    case "audio/wav":
+      return "wav";
+    case "model/gltf-binary":
+      return "glb";
+    default:
+      return null;
+  }
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://asset.origingame.dev";
+var AssetForge = class {
+  baseUrl;
+  job;
+  library;
+  providers;
+  assets;
+  stream;
+  voice;
+  apiKey;
+  fetchImpl;
+  defaultHeaders;
+  constructor(options) {
+    if (!options.apiKey.trim()) {
+      throw new AssetForgeError("AssetForge apiKey cannot be empty", {
+        code: "CONFIG_ERROR"
+      });
+    }
+    if (typeof fetch !== "function" && !options.fetch) {
+      throw new AssetForgeError("Global fetch is unavailable in this runtime", {
+        code: "FETCH_UNAVAILABLE"
+      });
+    }
+    this.apiKey = options.apiKey.trim();
+    this.baseUrl = options.baseUrl?.trim() || DEFAULT_BASE_URL;
+    this.fetchImpl = options.fetch ?? fetch;
+    this.defaultHeaders = options.headers ?? {};
+    this.job = new AssetForgeJobs(this);
+    this.library = new AssetForgeLibrary(this);
+    this.providers = new AssetForgeProviders(this);
+    this.assets = new AssetForgeAssets(this);
+    this.stream = new AssetForgeStreamNamespace(this);
+    const cloneVoice = ((request, reqOptions = {}) => this.submitAndMaybeWait(
+      "/api/voice/clone",
+      request,
+      reqOptions
+    ));
+    this.voice = {
+      clone: cloneVoice,
+      design: (request, reqOptions = {}) => this.request("POST", "/api/voice/design", {
+        body: request,
+        signal: reqOptions.signal,
+        headers: reqOptions.headers
+      }),
+      list: (query = {}) => this.request("GET", "/api/voice/list", {
+        query: {
+          type: query.type,
+          page: query.page,
+          page_size: query.page_size
+        },
+        signal: query.signal,
+        headers: query.headers
+      }),
+      delete: (voiceId, query = {}) => this.request("DELETE", `/api/voice/${encodeURIComponent(voiceId)}`, {
+        query: { type: query.type },
+        signal: query.signal,
+        headers: query.headers
+      })
+    };
+  }
+  async login(token = this.apiKey, options = {}) {
+    return this.request("POST", "/auth/login", {
+      body: { token },
+      signal: options.signal,
+      headers: options.headers
+    });
+  }
+  async generate(request, options = {}) {
+    return this.submitAndMaybeWait(
+      "/api/generate",
+      request,
+      options,
+      (response) => normalizeGenerateResponse(this.baseUrl, response)
+    );
+  }
+  async batch(request, options = {}) {
+    return this.submitAndMaybeWait(
+      "/api/generate/batch",
+      request,
+      options,
+      (response) => normalizeBatchResponse(this.baseUrl, response)
+    );
+  }
+  async process(request, options = {}) {
+    return this.submitAndMaybeWait("/api/process", request, options);
+  }
+  async process3d(request, options = {}) {
+    return this.submitAndMaybeWait("/api/process3d", request, options);
+  }
+  async upload(input, options = {}) {
+    return this.assets.upload(input, options);
+  }
+  image(prompt, options = {}) {
+    const { signal, headers, async: asyncMode, idempotencyKey, ...rest } = options;
+    return this.generate(buildImageRequest(prompt, rest), { signal, headers, async: asyncMode, idempotencyKey });
+  }
+  animation(prompt, options = {}) {
+    const { signal, headers, async: asyncMode, idempotencyKey, ...rest } = options;
+    return this.generate(buildGeneratedAssetRequest("animation", prompt, rest), { signal, headers, async: asyncMode, idempotencyKey });
+  }
+  material(_prompt, _options = {}) {
+    return Promise.resolve(packOnlyResponse("material"));
+  }
+  hdri(_prompt, _options = {}) {
+    return Promise.resolve(packOnlyResponse("hdri"));
+  }
+  vfx(_prompt, _options = {}) {
+    return Promise.resolve(packOnlyResponse("vfx"));
+  }
+  lut(_prompt, _options = {}) {
+    return Promise.resolve(packOnlyResponse("lut"));
+  }
+  shader(_prompt, _options = {}) {
+    return Promise.resolve(packOnlyResponse("shader"));
+  }
+  fontTypeface(_prompt, _options = {}) {
+    return Promise.resolve(packOnlyResponse("font_typeface"));
+  }
+  skybox(prompt, options = {}) {
+    const { signal, headers, async: asyncMode, idempotencyKey, ...rest } = options;
+    return this.generate(buildGeneratedAssetRequest("skybox", prompt, rest), { signal, headers, async: asyncMode, idempotencyKey });
+  }
+  decal(prompt, options = {}) {
+    const { signal, headers, async: asyncMode, idempotencyKey, ...rest } = options;
+    return this.generate(buildGeneratedAssetRequest("decal", prompt, rest), { signal, headers, async: asyncMode, idempotencyKey });
+  }
+  heightmap(prompt, options = {}) {
+    const { signal, headers, async: asyncMode, idempotencyKey, ...rest } = options;
+    return this.generate(buildGeneratedAssetRequest("heightmap", prompt, rest), { signal, headers, async: asyncMode, idempotencyKey });
+  }
+  video(promptOrRequest, options = {}) {
+    if (typeof promptOrRequest === "string") {
+      const { signal: signal2, headers: headers2, async: asyncMode2, idempotencyKey: idempotencyKey2, ...rest2 } = options;
+      return this.generate(buildVideoRequest(promptOrRequest, rest2), { signal: signal2, headers: headers2, async: asyncMode2, idempotencyKey: idempotencyKey2 });
+    }
+    const { prompt, signal, headers, async: asyncMode, idempotencyKey, ...rest } = promptOrRequest;
+    return this.generate(buildVideoRequest(prompt, rest), { signal, headers, async: asyncMode, idempotencyKey });
+  }
+  audio(prompt, options = {}) {
+    const { signal, headers, async: asyncMode, idempotencyKey, ...rest } = options;
+    return this.generate(buildAudioRequest(prompt, rest), { signal, headers, async: asyncMode, idempotencyKey });
+  }
+  music(prompt, options = {}) {
+    const { signal, headers, async: asyncMode, idempotencyKey, ...rest } = options;
+    return this.generate(buildMusicRequest(prompt, rest), { signal, headers, async: asyncMode, idempotencyKey });
+  }
+  tts(prompt, options = {}) {
+    const { signal, headers, async: asyncMode, idempotencyKey, ...rest } = options;
+    return this.generate(buildTtsRequest(prompt, rest), { signal, headers, async: asyncMode, idempotencyKey });
+  }
+  model3d(prompt, options = {}) {
+    const { signal, headers, async: asyncMode, idempotencyKey, ...rest } = options;
+    return this.generate(buildModel3dRequest(prompt, rest), { signal, headers, async: asyncMode, idempotencyKey });
+  }
+  character(prompt, options = {}) {
+    const { signal, headers, async: asyncMode, idempotencyKey, ...rest } = options;
+    return this.generate(buildCharacterRequest(prompt, rest), { signal, headers, async: asyncMode, idempotencyKey });
+  }
+  prop(prompt, options = {}) {
+    const { signal, headers, async: asyncMode, idempotencyKey, ...rest } = options;
+    return this.generate(buildPropRequest(prompt, rest), { signal, headers, async: asyncMode, idempotencyKey });
+  }
+  sprite(prompt, options = {}) {
+    const { signal, headers, async: asyncMode, idempotencyKey, ...rest } = options;
+    return this.generate(buildSpriteRequest(prompt, rest), { signal, headers, async: asyncMode, idempotencyKey });
+  }
+  world(prompt, options = {}) {
+    const { signal, headers, async: asyncMode, idempotencyKey, ...rest } = options;
+    return this.generate(buildWorldRequest(prompt, rest), { signal, headers, async: asyncMode, idempotencyKey });
+  }
+  text(prompt, options = {}) {
+    const { signal, headers, async: asyncMode, idempotencyKey, ...rest } = options;
+    return this.generate(buildTextRequest(prompt, rest), { signal, headers, async: asyncMode, idempotencyKey });
+  }
+  async request(method, path, options = {}) {
+    const url = new URL(path, ensureTrailingSlash4(this.baseUrl));
+    appendQuery(url, options.query);
+    const headers = new Headers(this.defaultHeaders);
+    headers.set("authorization", `Bearer ${this.apiKey}`);
+    applyHeaders(headers, options.headers);
+    let body;
+    if (options.form) {
+      body = options.form;
+    } else if (options.body !== void 0) {
+      headers.set("content-type", "application/json");
+      body = JSON.stringify(options.body);
+    }
+    let response;
+    try {
+      response = await this.fetchImpl(url.toString(), {
+        method,
+        headers,
+        body,
+        signal: options.signal
+      });
+    } catch (error) {
+      throw new AssetForgeError(
+        error instanceof Error ? error.message : String(error),
+        {
+          code: options.signal?.aborted ? "ABORTED" : "NETWORK_ERROR",
+          cause: error
+        }
+      );
+    }
+    const text = await response.text();
+    const payload = parseJson2(text);
+    const envelope = isEnvelope(payload) ? payload : null;
+    if (envelope?.ok) {
+      return envelope.data;
+    }
+    if (!response.ok || envelope?.ok === false) {
+      throw createApiError(response.status, envelope?.command, envelope?.ok === false ? envelope.error : payload);
+    }
+    return payload;
+  }
+  async submitAndMaybeWait(path, body, options, normalize) {
+    const ack = await this.request("POST", path, {
+      body,
+      signal: options.signal,
+      headers: submitHeaders({ ...options, async: true })
+    });
+    if (options.async) {
+      return ack;
+    }
+    const job = await this.job.wait(ack.job_id, {
+      signal: options.signal,
+      headers: options.headers
+    });
+    if (job.response === void 0 || job.response === null) {
+      throw new AssetForgeError(`Completed job ${ack.job_id} is missing response payload`, {
+        code: "JOB_RESPONSE_MISSING",
+        details: job
+      });
+    }
+    const response = job.response;
+    return normalize ? normalize(response) : response;
+  }
+};
+function createApiError(status, command, error) {
+  if (typeof error === "string") {
+    return new AssetForgeError(error, {
+      code: defaultErrorCode2(status),
+      status,
+      command,
+      details: error
+    });
+  }
+  if (isApiErrorPayload(error)) {
+    return new AssetForgeError(error.message ?? `AssetForge API error (${status})`, {
+      code: error.code ?? defaultErrorCode2(status),
+      status,
+      command,
+      details: error
+    });
+  }
+  return new AssetForgeError(
+    typeof error === "object" && error !== null ? JSON.stringify(error) : `AssetForge API error (${status})`,
+    {
+      code: defaultErrorCode2(status),
+      status,
+      command,
+      details: error
+    }
+  );
+}
+function defaultErrorCode2(status) {
+  if (status === 401) return "UNAUTHORIZED";
+  if (status === 403) return "FORBIDDEN";
+  if (status === 404) return "NOT_FOUND";
+  if (status === 409) return "CONFLICT";
+  return "API_ERROR";
+}
+function appendQuery(url, query) {
+  if (!query) {
+    return;
+  }
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    url.searchParams.set(key, String(value));
+  }
+}
+function applyHeaders(target, source) {
+  if (!source) {
+    return;
+  }
+  const extra = new Headers(source);
+  extra.forEach((value, key) => {
+    target.set(key, value);
+  });
+}
+function submitHeaders(options) {
+  const headers = new Headers(options.headers);
+  if (options.async) {
+    headers.set("prefer", "respond-async");
+  }
+  if (options.idempotencyKey) {
+    headers.set("idempotency-key", options.idempotencyKey);
+  }
+  return headers;
+}
+function ensureTrailingSlash4(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+function parseJson2(text) {
+  if (!text) {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function isEnvelope(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "ok" in value;
+}
+function isApiErrorPayload(value) {
+  return typeof value === "object" && value !== null && ("message" in value || "code" in value);
+}
+function packOnlyResponse(assetType) {
+  return {
+    ok: false,
+    pack_only: true,
+    asset_type: assetType,
+    message: "use library packs"
+  };
+}
+export {
+  AssetForge,
+  AssetForgeAssets,
+  AssetForgeError,
+  AssetForgeJobs,
+  AssetForgeLibrary,
+  AssetForgeProviders,
+  AssetForgeStreamNamespace,
+  DEFAULT_BASE_URL,
+  buildAudioRequest,
+  buildCharacterRequest,
+  buildImageRequest,
+  buildModel3dRequest,
+  buildMusicRequest,
+  buildPropRequest,
+  buildSpriteRequest,
+  buildTextRequest,
+  buildTtsRequest,
+  buildVideoRequest,
+  buildWorldRequest,
+  normalizeGenerateResponse,
+  subscribeAllJobs,
+  subscribeJob,
+  toAssetForgeError
+};