@lotics/app-sdk 0.100.1 → 0.101.1

package/dist/chunk-ARV5FAU5.js

@@ -0,0 +1,1132 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/url_params.ts
+function first(raw) {
+  return Array.isArray(raw) ? raw[0] : raw;
+}
+function valueEqual(a, b) {
+  if (a === b) return true;
+  if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((x, i) => valueEqual(x, b[i]));
+  }
+  return false;
+}
+function optional(base) {
+  return {
+    decode: base.decode,
+    encode: base.encode,
+    withDefault(fallback) {
+      return {
+        decode: (raw) => {
+          const v = base.decode(raw);
+          return v === void 0 ? fallback : v;
+        },
+        encode: (value) => valueEqual(value, fallback) ? void 0 : base.encode(value)
+      };
+    }
+  };
+}
+var stringCodec = optional({
+  decode: (raw) => raw === void 0 ? void 0 : first(raw),
+  encode: (v) => v
+});
+var numberCodec = optional({
+  decode: (raw) => {
+    const s = first(raw);
+    if (s === void 0 || s === "") return void 0;
+    const n = Number(s);
+    return Number.isFinite(n) ? n : void 0;
+  },
+  encode: (v) => v === void 0 ? void 0 : String(v)
+});
+var booleanCodec = optional({
+  decode: (raw) => {
+    const s = first(raw);
+    return s === "true" ? true : s === "false" ? false : void 0;
+  },
+  encode: (v) => v === void 0 ? void 0 : v ? "true" : "false"
+});
+var isoDateCodec = optional({
+  decode: (raw) => {
+    const s = first(raw);
+    if (s === void 0 || !/^\d{4}-\d{2}-\d{2}$/.test(s)) return void 0;
+    const d = /* @__PURE__ */ new Date(`${s}T00:00:00.000Z`);
+    return Number.isNaN(d.getTime()) ? void 0 : d;
+  },
+  encode: (v) => v === void 0 ? void 0 : v.toISOString().slice(0, 10)
+});
+function enumCodec(values) {
+  return optional({
+    decode: (raw) => {
+      const s = first(raw);
+      return s === void 0 ? void 0 : values.find((v) => v === s);
+    },
+    encode: (v) => v
+  });
+}
+function arrayOf(inner) {
+  return optional({
+    decode: (raw) => {
+      if (raw === void 0) return void 0;
+      const items = Array.isArray(raw) ? raw : [raw];
+      return items.map((x) => inner.decode(x)).filter((x) => x !== void 0);
+    },
+    encode: (value) => {
+      if (value === void 0 || value.length === 0) return void 0;
+      const out = value.map((x) => inner.encode(x)).filter((x) => typeof x === "string");
+      return out.length > 0 ? out : void 0;
+    }
+  });
+}
+var urlParam = {
+  string: stringCodec,
+  number: numberCodec,
+  boolean: booleanCodec,
+  isoDate: isoDateCodec,
+  enum: enumCodec,
+  arrayOf
+};
+function decodeAll(defs, params) {
+  const out = {};
+  for (const key of Object.keys(defs)) {
+    out[key] = defs[key].decode(params[key]);
+  }
+  return out;
+}
+function encodePatch(defs, values) {
+  const out = {};
+  for (const key of Object.keys(values)) {
+    const codec = defs[key];
+    if (codec) out[key] = codec.encode(values[key]);
+  }
+  return out;
+}
+function parseSearch(search) {
+  const sp = new URLSearchParams(search);
+  const out = {};
+  for (const key of sp.keys()) {
+    if (key in out) continue;
+    const all = sp.getAll(key);
+    out[key] = all.length > 1 ? all : all[0];
+  }
+  return out;
+}
+function serializeMerge(search, patch) {
+  const sp = new URLSearchParams(search);
+  for (const [key, value] of Object.entries(patch)) {
+    sp.delete(key);
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) sp.append(key, item);
+    } else {
+      sp.append(key, value);
+    }
+  }
+  return sp.toString();
+}
+function applyPatch(params, patch) {
+  const next = { ...params };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) delete next[key];
+    else next[key] = value;
+  }
+  return next;
+}
+function paramsEqual(a, b) {
+  const ak = Object.keys(a);
+  const bk = Object.keys(b);
+  if (ak.length !== bk.length) return false;
+  for (const key of ak) {
+    const av = a[key];
+    const bv = b[key];
+    if (Array.isArray(av) || Array.isArray(bv)) {
+      if (!Array.isArray(av) || !Array.isArray(bv)) return false;
+      if (av.length !== bv.length || !av.every((x, i) => x === bv[i])) return false;
+    } else if (av !== bv) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// ../shared/src/app_host/api_base_meta.ts
+var API_BASE_META_NAME = "lotics-api-base";
+
+// ../shared/src/transport_error.ts
+function gatewayErrorMessage(status) {
+  if (status === 524) {
+    return "The request took too long to finish (gateway timeout). It may still be running \u2014 check back in a moment, or try again.";
+  }
+  if (status >= 500) {
+    return "The service is temporarily unavailable. Please try again shortly.";
+  }
+  return "The service returned an unexpected response. Please try again.";
+}
+function transportErrorMessage(status, parsed) {
+  const jsonMessage = parsed && typeof parsed.message === "string" ? parsed.message : null;
+  if (jsonMessage === null) return gatewayErrorMessage(status);
+  const authored = typeof parsed.code === "string" && parsed.code.length > 0;
+  return status < 500 || authored ? jsonMessage : gatewayErrorMessage(status);
+}
+
+// src/upload/optimize.ts
+var DEFAULT_IMAGE_FIDELITY = "high";
+var IMAGE_POLICIES = {
+  standard: { maxDimensionPx: 1280, jpegQuality: 0.8 },
+  high: { maxDimensionPx: 1568, jpegQuality: 0.95 }
+};
+var CONVERTIBLE_EXTENSION_PATTERN = /\.(heic|heif|png|webp)$/i;
+async function optimizeImageForUpload(file, fidelity = DEFAULT_IMAGE_FIDELITY) {
+  if (fidelity === "original") return unchanged(file, "skipped_original");
+  const policy = IMAGE_POLICIES[fidelity];
+  const format = getOptimizableFormat(file);
+  const mimeType = format?.outputMimeType;
+  const unsupportedReason = getUnsupportedReason(mimeType);
+  if (unsupportedReason) return unchanged(file, unsupportedReason);
+  if (!mimeType || !format) return unchanged(file, "skipped_unsupported_format");
+  const loaded = await loadImage(file);
+  if (loaded.status === "decode_unavailable") return unchanged(file, "skipped_decode_unavailable");
+  const { source, width, height } = loaded;
+  if (width <= 0 || height <= 0) {
+    closeSource(source);
+    return unchanged(file, "skipped_invalid_dimensions");
+  }
+  if (Math.max(width, height) <= policy.maxDimensionPx) {
+    closeSource(source);
+    return unchanged(file, "skipped_small_dimensions", width, height);
+  }
+  const { width: targetWidth, height: targetHeight } = scale(width, height, policy.maxDimensionPx);
+  const canvas = document.createElement("canvas");
+  canvas.width = targetWidth;
+  canvas.height = targetHeight;
+  const ctx = canvas.getContext("2d");
+  if (!ctx || typeof canvas.toBlob !== "function") {
+    closeSource(source);
+    return unchanged(file, "skipped_canvas_unavailable", width, height);
+  }
+  try {
+    ctx.imageSmoothingEnabled = true;
+    ctx.imageSmoothingQuality = "high";
+    ctx.drawImage(source, 0, 0, targetWidth, targetHeight);
+  } finally {
+    closeSource(source);
+  }
+  const blob = await canvasToBlob(canvas, mimeType, policy.jpegQuality);
+  if (blob === null) return unchanged(file, "skipped_canvas_no_data", width, height, targetWidth, targetHeight);
+  if (blob.type !== mimeType) {
+    return unchanged(file, "skipped_canvas_type_mismatch", width, height, targetWidth, targetHeight);
+  }
+  return {
+    file: new File([blob], format.outputFilename, {
+      type: mimeType,
+      lastModified: file.lastModified
+    }),
+    optimized: true,
+    reason: "optimized",
+    originalSizeBytes: file.size,
+    optimizedSizeBytes: blob.size,
+    width,
+    height,
+    targetWidth,
+    targetHeight
+  };
+}
+function getUnsupportedReason(mimeType) {
+  if (mimeType === void 0) return "skipped_unsupported_format";
+  if (typeof window === "undefined" || typeof document === "undefined" || typeof document.createElement !== "function" || typeof URL.createObjectURL !== "function" || typeof URL.revokeObjectURL !== "function" || typeof Image === "undefined") {
+    return "skipped_environment_unsupported";
+  }
+  return void 0;
+}
+function getOptimizableFormat(file) {
+  const mimeType = normalizeMimeType(file.type);
+  if (!mimeType) return void 0;
+  if (mimeType === "image/jpeg") {
+    return { outputMimeType: "image/jpeg", outputFilename: file.name };
+  }
+  return { outputMimeType: "image/jpeg", outputFilename: replaceExtensionWithJpeg(file.name) };
+}
+function normalizeMimeType(mimeType) {
+  const m = mimeType.toLowerCase();
+  if (m === "image/jpeg" || m === "image/jpg") return "image/jpeg";
+  if (m === "image/heic" || m === "image/heif") return m;
+  if (m === "image/png" || m === "image/webp") return m;
+  return void 0;
+}
+function replaceExtensionWithJpeg(filename) {
+  if (CONVERTIBLE_EXTENSION_PATTERN.test(filename)) {
+    return filename.replace(CONVERTIBLE_EXTENSION_PATTERN, ".jpg");
+  }
+  return `${filename}.jpg`;
+}
+function unchanged(file, reason, width = 0, height = 0, targetWidth = width, targetHeight = height) {
+  return {
+    file,
+    optimized: false,
+    reason,
+    originalSizeBytes: file.size,
+    optimizedSizeBytes: file.size,
+    width,
+    height,
+    targetWidth,
+    targetHeight
+  };
+}
+function closeSource(source) {
+  if ("close" in source && typeof source.close === "function") source.close();
+}
+function scale(width, height, maxDimensionPx) {
+  const largest = Math.max(width, height);
+  if (largest <= maxDimensionPx) return { width, height };
+  const factor = maxDimensionPx / largest;
+  return {
+    width: Math.max(1, Math.round(width * factor)),
+    height: Math.max(1, Math.round(height * factor))
+  };
+}
+async function loadImage(file) {
+  if (typeof createImageBitmap === "function") {
+    try {
+      const bitmap = await createImageBitmap(file);
+      return { status: "decoded", source: bitmap, width: bitmap.width, height: bitmap.height };
+    } catch {
+    }
+  }
+  const objectUrl = URL.createObjectURL(file);
+  return new Promise((resolve) => {
+    const image = new Image();
+    const cleanup = () => {
+      image.onload = null;
+      image.onerror = null;
+      URL.revokeObjectURL(objectUrl);
+    };
+    image.onload = () => {
+      cleanup();
+      resolve({ status: "decoded", source: image, width: image.naturalWidth, height: image.naturalHeight });
+    };
+    image.onerror = () => {
+      cleanup();
+      resolve({ status: "decode_unavailable" });
+    };
+    image.src = objectUrl;
+  });
+}
+async function canvasToBlob(canvas, mimeType, jpegQuality) {
+  return new Promise((resolve) => {
+    canvas.toBlob(resolve, mimeType, jpegQuality);
+  });
+}
+
+// src/upload/transport.ts
+var UPLOAD_TIMEOUT_MS = 5 * 60 * 1e3;
+var UPLOAD_PUT_MAX_ATTEMPTS = 3;
+var UPLOAD_PUT_BACKOFF_BASE_MS = 1e3;
+var UploadTimeoutError = class extends Error {
+  constructor(url, timeoutMs) {
+    super(`Upload request to ${url} timed out after ${timeoutMs}ms`);
+    this.url = url;
+    this.timeoutMs = timeoutMs;
+  }
+  url;
+  timeoutMs;
+  name = "UploadTimeoutError";
+};
+var UploadAbortedError = class extends Error {
+  name = "UploadAbortedError";
+  constructor() {
+    super("Upload aborted");
+  }
+};
+async function fetchWithTimeout(url, init, timeoutMs) {
+  const controller = new AbortController();
+  let didTimeout = false;
+  const timeoutId = setTimeout(() => {
+    didTimeout = true;
+    controller.abort();
+  }, timeoutMs);
+  if (init.signal) {
+    if (init.signal.aborted) {
+      clearTimeout(timeoutId);
+      throw new UploadAbortedError();
+    }
+    init.signal.addEventListener("abort", () => controller.abort(), { once: true });
+  }
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } catch (err) {
+    if (didTimeout) throw new UploadTimeoutError(url, timeoutMs);
+    if (init.signal?.aborted) throw new UploadAbortedError();
+    throw err;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function putToStorageWithRetry(uploadUrl, file, signal) {
+  let lastError;
+  for (let attempt = 1; attempt <= UPLOAD_PUT_MAX_ATTEMPTS; attempt += 1) {
+    try {
+      const response = await fetchWithTimeout(
+        uploadUrl,
+        {
+          method: "PUT",
+          headers: { "Content-Type": file.type },
+          body: file,
+          signal
+        },
+        UPLOAD_TIMEOUT_MS
+      );
+      if (response.ok) return response;
+      if (response.status >= 400 && response.status < 500) return response;
+      lastError = new Error(`Storage PUT returned ${response.status}`);
+    } catch (err) {
+      if (err instanceof UploadAbortedError) throw err;
+      lastError = err;
+    }
+    if (attempt < UPLOAD_PUT_MAX_ATTEMPTS) {
+      const delayMs = UPLOAD_PUT_BACKOFF_BASE_MS * 2 ** (attempt - 1);
+      await sleep(delayMs, signal);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("Storage PUT failed");
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new UploadAbortedError());
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    const cleanup = () => {
+      clearTimeout(timeoutId);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(new UploadAbortedError());
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/upload/pipeline.ts
+async function runUploadPipeline(file, rpc2, options = {}) {
+  const { signal, fidelity = DEFAULT_IMAGE_FIDELITY } = options;
+  const { file: candidate } = await optimizeImageForUpload(file, fidelity);
+  if (signal?.aborted) throw new Error("Upload aborted");
+  const init = await rpc2.initUpload({
+    filename: candidate.name,
+    mime_type: candidate.type,
+    file_size: candidate.size
+  });
+  const putResponse = await putToStorageWithRetry(init.upload_url, candidate, signal);
+  if (!putResponse.ok) {
+    throw new Error(
+      `Storage upload failed (${putResponse.status}). Please check your connection and try again.`
+    );
+  }
+  const { file: uploaded } = await rpc2.completeUpload({
+    file_id: init.file_id,
+    file_storage_key: init.file_storage_key,
+    filename: candidate.name
+  });
+  return uploaded;
+}
+
+// src/recording_state.ts
+var IDLE_RECORDING = { phase: "idle" };
+var states = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Set();
+function emit() {
+  for (const listener of listeners) listener();
+}
+function subscribeRecordings(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function recordingStateOf(alias) {
+  return states.get(alias) ?? IDLE_RECORDING;
+}
+function anyRecordingLive() {
+  for (const state of states.values()) if (state.phase === "live") return true;
+  return false;
+}
+function applyRecordingChange(alias, state) {
+  if (state.phase === "idle") states.delete(alias);
+  else states.set(alias, state);
+  emit();
+}
+function replaceRecordings(snapshot) {
+  states.clear();
+  for (const [alias, state] of Object.entries(snapshot)) {
+    if (state.phase !== "idle") states.set(alias, state);
+  }
+  emit();
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readRecordingState(raw) {
+  if (!isRecord(raw)) return null;
+  if (raw.phase === "idle") return IDLE_RECORDING;
+  const inputs = raw.inputs;
+  if (!isRecord(inputs)) return null;
+  switch (raw.phase) {
+    case "live":
+    case "interrupted":
+      return typeof raw.elapsed_seconds === "number" ? { phase: raw.phase, elapsed_seconds: raw.elapsed_seconds, inputs } : null;
+    case "processing":
+      return { phase: "processing", inputs };
+    case "filed":
+      return typeof raw.execution_id === "string" ? { phase: "filed", execution_id: raw.execution_id, inputs } : null;
+    case "failed":
+      return typeof raw.message === "string" ? { phase: "failed", message: raw.message, inputs } : null;
+    default:
+      return null;
+  }
+}
+function readRecordingSnapshot(raw) {
+  if (!isRecord(raw)) return {};
+  const entries = Object.entries(raw).flatMap(([alias, value]) => {
+    const state = readRecordingState(value);
+    if (state === null) {
+      console.error(`The host's context carried a malformed recording for "${alias}"; it reads as idle.`, value);
+      return [];
+    }
+    return [[alias, state]];
+  });
+  return Object.fromEntries(entries);
+}
+
+// src/rpc.ts
+var hostOriginCache;
+function getHostOrigin() {
+  if (hostOriginCache === void 0) {
+    hostOriginCache = new URLSearchParams(window.location.search).get("lotics_host");
+  }
+  return hostOriginCache;
+}
+function isEmbedded() {
+  return Boolean(getHostOrigin());
+}
+function rpc(op, payload) {
+  const hostOrigin = getHostOrigin();
+  return hostOrigin ? rpcBridged(op, payload, hostOrigin) : rpcStandalone(op, payload);
+}
+function getUrlParams() {
+  return rpc("urlState.get", {});
+}
+function setUrlParams(patch) {
+  return rpc("urlState.set", { params: patch });
+}
+function peekUrlParams() {
+  return isEmbedded() ? {} : parseSearch(window.location.search);
+}
+function subscribeUrlParams(cb) {
+  if (isEmbedded()) {
+    ensureListener();
+    urlStateSubscribers.add(cb);
+    return () => {
+      urlStateSubscribers.delete(cb);
+    };
+  }
+  const handler = () => cb(parseSearch(window.location.search));
+  window.addEventListener("popstate", handler);
+  return () => window.removeEventListener("popstate", handler);
+}
+function postHostNotification(message) {
+  const hostOrigin = getHostOrigin();
+  if (!hostOrigin) return;
+  window.parent.postMessage(message, hostOrigin);
+}
+function subscribeQueriesChanged(cb) {
+  ensureListener();
+  refetchSubscribers.add(cb);
+  return () => {
+    refetchSubscribers.delete(cb);
+  };
+}
+var mountedAliases = /* @__PURE__ */ new Map();
+function notifyLocalWrite(reads) {
+  const aliases = reads === void 0 ? [...mountedAliases.keys()] : [...reads];
+  if (aliases.length === 0) return;
+  for (const cb of refetchSubscribers) cb(aliases);
+}
+var pending = /* @__PURE__ */ new Map();
+var streaming = /* @__PURE__ */ new Map();
+var urlStateSubscribers = /* @__PURE__ */ new Set();
+var refetchSubscribers = /* @__PURE__ */ new Set();
+var nextRpcId = 0;
+var listenerInstalled = false;
+function ensureListener() {
+  if (listenerInstalled) return;
+  listenerInstalled = true;
+  window.addEventListener("message", (event) => {
+    if (event.source !== window.parent || event.origin !== getHostOrigin()) return;
+    const msg = event.data;
+    if (!msg) return;
+    if (msg.type === "url-state" && msg.params && typeof msg.params === "object") {
+      for (const cb of urlStateSubscribers) cb(msg.params);
+      return;
+    }
+    if (msg.type === "queriesChanged" && Array.isArray(msg.aliases)) {
+      const aliases = msg.aliases.filter((a) => typeof a === "string");
+      for (const cb of refetchSubscribers) cb(aliases);
+      return;
+    }
+    if (msg.type === "recordingChanged") {
+      const state = readRecordingState(msg.state);
+      if (typeof msg.alias !== "string" || state === null) {
+        console.error("The host sent a malformed recordingChanged push; it is ignored.", msg);
+        return;
+      }
+      const before = recordingStateOf(msg.alias);
+      applyRecordingChange(msg.alias, state);
+      const newlyFiled = state.phase === "filed" && !(before.phase === "filed" && before.execution_id === state.execution_id);
+      if (newlyFiled) notifyLocalWrite();
+      return;
+    }
+    if (typeof msg.id !== "number") return;
+    const handler = pending.get(msg.id);
+    if (handler) {
+      pending.delete(msg.id);
+      if (msg.type === "result") handler.resolve(msg.data);
+      else handler.reject(new Error(msg.message ?? "RPC failed"));
+      return;
+    }
+    const stream = streaming.get(msg.id);
+    if (!stream) return;
+    if (msg.type === "run-id") {
+      if (typeof msg.runId === "string") stream.onRunId?.(msg.runId);
+    } else if (msg.type === "stream-chunk") {
+      if (typeof msg.chunk === "string") stream.onText(msg.chunk);
+    } else if (msg.type === "stream-end") {
+      streaming.delete(msg.id);
+      stream.resolve();
+    } else if (msg.type === "error") {
+      streaming.delete(msg.id);
+      stream.reject(new Error(msg.message ?? "Run failed"));
+    }
+  });
+}
+function rpcBridged(op, payload, host) {
+  ensureListener();
+  return new Promise((resolve, reject) => {
+    const id = nextRpcId++;
+    pending.set(id, { resolve, reject });
+    window.parent.postMessage({ id, op, payload }, host);
+  });
+}
+function rpcAgentRun(payload, onText, onRunId) {
+  const hostOrigin = getHostOrigin();
+  return hostOrigin ? agentRunBridged(payload, onText, hostOrigin, onRunId) : agentRunStandalone(payload, onText, onRunId);
+}
+function agentRunBridged(payload, onText, host, onRunId) {
+  ensureListener();
+  const id = nextRpcId++;
+  let settleDone = () => {
+  };
+  const done = new Promise((resolve, reject) => {
+    settleDone = resolve;
+    streaming.set(id, { onText, onRunId, resolve, reject });
+    window.parent.postMessage({ id, op: "agentRun", payload }, host);
+  });
+  return {
+    done,
+    abort: () => {
+      if (!streaming.has(id)) return;
+      streaming.delete(id);
+      window.parent.postMessage({ id, type: "abort" }, host);
+      settleDone();
+    }
+  };
+}
+function rpcAgentRunContinue(payload, onText) {
+  const hostOrigin = getHostOrigin();
+  if (hostOrigin) {
+    ensureListener();
+    const id = nextRpcId++;
+    let settleDone = () => {
+    };
+    const done2 = new Promise((resolve, reject) => {
+      settleDone = resolve;
+      streaming.set(id, { onText, resolve, reject });
+      window.parent.postMessage({ id, op: "agentRunContinue", payload }, hostOrigin);
+    });
+    return {
+      done: done2,
+      abort: () => {
+        if (!streaming.has(id)) return;
+        streaming.delete(id);
+        window.parent.postMessage({ id, type: "abort" }, hostOrigin);
+        settleDone();
+      }
+    };
+  }
+  const controller = new AbortController();
+  const done = (async () => {
+    const { app_id } = await boot();
+    const headers = { "content-type": "application/json" };
+    if (sessionToken) headers[APP_PUBLIC_SESSION_HEADER] = sessionToken;
+    const continueToken = runTokens.get(payload.run_id);
+    if (continueToken) headers[APP_AGENT_RUN_TOKEN_HEADER] = continueToken;
+    const res = await fetch(
+      `${apiBase()}/v1/apps/${app_id}/agent-runs/${encodeURIComponent(payload.run_id)}/continue`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ tool_call_id: payload.tool_call_id, output: payload.output }),
+        signal: controller.signal
+      }
+    );
+    if (!res.ok || !res.body) {
+      throw await streamStartError(res);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    try {
+      for (; ; ) {
+        const { value, done: streamDone } = await reader.read();
+        if (streamDone) break;
+        onText(decoder.decode(value, { stream: true }));
+      }
+      const tail = decoder.decode();
+      if (tail) onText(tail);
+    } catch (err) {
+      if (controller.signal.aborted) return;
+      throw err;
+    }
+  })();
+  return { done, abort: () => controller.abort() };
+}
+function agentRunStandalone(payload, onText, onRunId) {
+  const controller = new AbortController();
+  const done = (async () => {
+    const { app_id } = await boot();
+    const headers = { "content-type": "application/json" };
+    if (sessionToken) headers[APP_PUBLIC_SESSION_HEADER] = sessionToken;
+    const res = await fetch(`${apiBase()}/v1/apps/${app_id}/agents/${encodeURIComponent(payload.alias)}/runs`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ session_id: payload.session_id, input: payload.input }),
+      signal: controller.signal
+    });
+    if (!res.ok || !res.body) {
+      throw await streamStartError(res);
+    }
+    const runId = res.headers.get("x-app-agent-run-id");
+    if (runId) {
+      rememberRunToken(runId, res.headers.get(APP_AGENT_RUN_TOKEN_HEADER));
+      onRunId?.(runId);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    try {
+      for (; ; ) {
+        const { value, done: streamDone } = await reader.read();
+        if (streamDone) break;
+        onText(decoder.decode(value, { stream: true }));
+      }
+      const tail = decoder.decode();
+      if (tail) onText(tail);
+    } catch (err) {
+      if (controller.signal.aborted) return;
+      throw err;
+    }
+  })();
+  return { done, abort: () => controller.abort() };
+}
+var apiBaseCache = null;
+function apiBase() {
+  if (apiBaseCache !== null) return apiBaseCache;
+  const content = document.querySelector(`meta[name="${API_BASE_META_NAME}"]`)?.getAttribute("content")?.trim();
+  if (!content) {
+    throw new Error(
+      `This app has no API address. A standalone app reads it from <meta name="${API_BASE_META_NAME}"> in the page the app host serves, and this page carries none.`
+    );
+  }
+  apiBaseCache = content.replace(/\/+$/, "");
+  return apiBaseCache;
+}
+var PASSWORD_REQUIRED_CODE = "PASSWORD_REQUIRED";
+var bootPromise = null;
+var appInfoPromise = null;
+var sessionToken = null;
+var APP_PUBLIC_SESSION_HEADER = "x-lotics-app-session";
+var runTokens = /* @__PURE__ */ new Map();
+var MAX_TRACKED_RUN_TOKENS = 8;
+function rememberRunToken(runId, token) {
+  if (!token) return;
+  runTokens.set(runId, token);
+  while (runTokens.size > MAX_TRACKED_RUN_TOKENS) {
+    const oldest = runTokens.keys().next();
+    if (oldest.done) break;
+    runTokens.delete(oldest.value);
+  }
+}
+var APP_AGENT_RUN_TOKEN_HEADER = "x-app-agent-run-token";
+var SESSION_COOKIE = "lotics_app_session";
+function readSessionCookie() {
+  for (const part of document.cookie.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq < 0) continue;
+    if (part.slice(0, eq).trim() === SESSION_COOKIE) {
+      return decodeURIComponent(part.slice(eq + 1).trim()) || null;
+    }
+  }
+  return null;
+}
+function resolveAppInfo() {
+  if (appInfoPromise) return appInfoPromise;
+  const slug = window.location.hostname.split(".")[0];
+  const attempt = apiCall(
+    "GET",
+    `/v1/apps/by-subdomain/${encodeURIComponent(slug)}`
+  );
+  attempt.catch(() => {
+    if (appInfoPromise === attempt) appInfoPromise = null;
+  });
+  appInfoPromise = attempt;
+  return attempt;
+}
+async function boot() {
+  if (bootPromise) return bootPromise;
+  const attempt = (async () => {
+    const info = await resolveAppInfo();
+    if (info.requires_password) {
+      sessionToken = readSessionCookie();
+    }
+    return info;
+  })();
+  attempt.catch(() => {
+    if (bootPromise === attempt) bootPromise = null;
+  });
+  bootPromise = attempt;
+  return attempt;
+}
+var ApiRefusal = class extends Error {
+  constructor(message, field_errors) {
+    super(message);
+    this.field_errors = field_errors;
+  }
+  field_errors;
+};
+function readFieldErrors(parsed) {
+  if (parsed === null || typeof parsed !== "object" || !("field_errors" in parsed)) {
+    return void 0;
+  }
+  const raw = parsed.field_errors;
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const named = Object.entries(raw).filter(
+    (entry) => typeof entry[1] === "string"
+  );
+  return named.length > 0 ? Object.fromEntries(named) : void 0;
+}
+async function streamStartError(res) {
+  const text = await res.text().catch(() => "");
+  let parsed = null;
+  if (text) {
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+    }
+  }
+  return new Error(transportErrorMessage(res.status, parsed));
+}
+var API_TIMEOUT_MS = 3e4;
+async function apiCall(method, path, body, opts) {
+  const headers = {};
+  if (body) headers["content-type"] = "application/json";
+  if (sessionToken && !opts?.skipAuth) {
+    headers[APP_PUBLIC_SESSION_HEADER] = sessionToken;
+  }
+  if (opts?.runToken) {
+    headers[APP_AGENT_RUN_TOKEN_HEADER] = opts.runToken;
+  }
+  const controller = new AbortController();
+  let didTimeout = false;
+  const timeoutId = setTimeout(() => {
+    didTimeout = true;
+    controller.abort();
+  }, API_TIMEOUT_MS);
+  let res;
+  try {
+    res = await fetch(`${apiBase()}${path}`, {
+      method,
+      headers,
+      ...method === "POST" && body ? { body: JSON.stringify(body) } : {},
+      signal: controller.signal
+    });
+  } catch (err) {
+    if (didTimeout && err instanceof DOMException && err.name === "AbortError") {
+      throw new Error(gatewayErrorMessage(524));
+    }
+    throw err;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+  const text = await res.text();
+  let parsed = null;
+  if (text) {
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+    }
+  }
+  if (!res.ok) {
+    const errorBody = parsed;
+    if (res.status === 401 && errorBody?.error_code === PASSWORD_REQUIRED_CODE && !opts?.skipAuth) {
+      sessionToken = null;
+      window.location.assign("/__gate");
+      return new Promise(() => {
+      });
+    }
+    throw new ApiRefusal(transportErrorMessage(res.status, parsed), readFieldErrors(parsed));
+  }
+  return parsed ?? (text ? text : {});
+}
+function rpcStandalone(op, payload) {
+  switch (op) {
+    case "query":
+      return standaloneQuery(payload);
+    case "field_options":
+      return standaloneFieldOptions(payload);
+    case "workflow":
+      return standaloneWorkflow(payload);
+    case "agentRuns":
+      return standaloneAgentRuns(payload);
+    case "agentRun.get":
+      return standaloneAgentRunGet(payload);
+    case "agentRun.cancel":
+      return standaloneAgentRunCancel(payload);
+    case "upload":
+      return standaloneUpload(
+        payload.file,
+        payload.fidelity
+      );
+    case "file.rename":
+      return standaloneRename(payload);
+    case "members":
+      return standaloneMembers(payload);
+    case "context":
+      return standaloneContext();
+    case "write_model":
+      return standaloneWriteModel();
+    case "prediction_miss":
+      return standalonePredictionMiss(payload);
+    case "openExternal":
+      return standaloneOpenExternal(payload);
+    case "openApp":
+      return Promise.reject(
+        new Error("openApp needs the Lotics host: a standalone app has no sibling apps to open. Gate the control on isEmbedded().")
+      );
+    case "askAi":
+      return Promise.reject(new Error("askAi is only available when the app runs inside Lotics"));
+    case "urlState.get":
+      return Promise.resolve(parseSearch(window.location.search));
+    case "urlState.set":
+      return standaloneUrlStateSet(payload);
+    case "folder.get":
+      return standaloneFolderGet(payload);
+    case "folder.set":
+      return standaloneFolderSet(payload);
+    case "comments.list":
+    case "comments.create":
+    case "comments.update":
+    case "comments.delete":
+    case "comments.counts":
+      return rejectCommentsStandalone();
+    case "recording.start":
+    case "recording.stop":
+      return Promise.reject(
+        new Error("Recording needs the Lotics host and a signed-in member. Gate the control on useRecording's `available`.")
+      );
+  }
+}
+function folderTable(payload) {
+  const table = payload !== null && typeof payload === "object" ? Reflect.get(payload, "table_id") : void 0;
+  if (typeof table !== "string" || table === "") throw new Error("A folder op names the folder's table as `table_id`.");
+  return table;
+}
+var folderKey = (table) => `lotics.folder.${table}`;
+async function standaloneFolderGet(payload) {
+  const key = folderKey(folderTable(payload));
+  try {
+    return { record_id: localStorage.getItem(key) };
+  } catch (cause) {
+    console.warn(`The folder kept under ${key} could not be read`, cause);
+    return { record_id: null };
+  }
+}
+async function standaloneFolderSet(payload) {
+  const key = folderKey(folderTable(payload));
+  const id = payload !== null && typeof payload === "object" ? Reflect.get(payload, "record_id") : void 0;
+  if (id !== null && typeof id !== "string") throw new Error("`folder.set` keeps a record id, or `null` for none.");
+  try {
+    if (id === null) localStorage.removeItem(key);
+    else localStorage.setItem(key, id);
+  } catch (cause) {
+    console.warn(`The folder could not be kept under ${key}; it holds for this visit`, cause);
+  }
+}
+function rejectCommentsStandalone() {
+  return Promise.reject(
+    new Error("Comments are available only in embedded apps \u2014 a signed-in member is required.")
+  );
+}
+async function standaloneMembers(p) {
+  const { app_id } = await boot();
+  const qs = p.group ? `?group_id=${encodeURIComponent(p.group)}` : "";
+  const r = await apiCall("GET", `/v1/apps/${app_id}/members${qs}`, void 0, {
+    appId: app_id
+  });
+  return { members: r.members ?? [] };
+}
+function openValidatedUrl(url) {
+  if (typeof url !== "string") throw new Error("openExternal requires a url string");
+  const parsed = new URL(url);
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    throw new Error(`openExternal: unsupported URL scheme "${parsed.protocol}"`);
+  }
+  window.open(parsed.href, "_blank", "noopener,noreferrer");
+}
+async function standaloneOpenExternal(p) {
+  openValidatedUrl(p.url);
+}
+async function standaloneUrlStateSet(p) {
+  const search = serializeMerge(window.location.search, p.params ?? {});
+  const url = window.location.pathname + (search ? `?${search}` : "") + window.location.hash;
+  window.history.replaceState(null, "", url);
+}
+async function standaloneContext() {
+  const info = await resolveAppInfo();
+  return {
+    member_id: null,
+    comments_enabled: info.comments_enabled,
+    timezone: info.timezone,
+    default_currency: info.default_currency,
+    recording_enabled: false
+  };
+}
+async function standalonePredictionMiss(payload) {
+  const { app_id } = await boot();
+  return apiCall("POST", `/v1/apps/${app_id}/prediction_misses`, payload, { appId: app_id });
+}
+async function standaloneWriteModel() {
+  const { app_id } = await boot();
+  return apiCall("GET", `/v1/apps/${app_id}/write_model`, void 0, { appId: app_id });
+}
+async function standaloneQuery(payload) {
+  const { app_id } = await boot();
+  return apiCall("POST", `/v1/apps/${app_id}/query`, payload, { appId: app_id });
+}
+async function standaloneFieldOptions(p) {
+  const { app_id } = await boot();
+  return apiCall("POST", `/v1/apps/${app_id}/field-options`, { alias: p.alias }, { appId: app_id });
+}
+async function standaloneWorkflow(p) {
+  const { app_id } = await boot();
+  try {
+    return await apiCall(
+      "POST",
+      `/v1/apps/${app_id}/workflows/${encodeURIComponent(p.alias)}/execute`,
+      { inputs: p.inputs, ...p.minted_ids === void 0 ? {} : { minted_ids: p.minted_ids } },
+      { appId: app_id }
+    );
+  } catch (err) {
+    return {
+      status: "error",
+      message: err instanceof Error ? err.message : "The workflow failed to run.",
+      ...err instanceof ApiRefusal && err.field_errors ? { field_errors: err.field_errors } : {}
+    };
+  }
+}
+async function standaloneAgentRuns(p) {
+  const { app_id } = await boot();
+  const qs = new URLSearchParams({ session_id: p.session_id });
+  if (p.limit != null) qs.set("limit", String(p.limit));
+  if (p.offset != null) qs.set("offset", String(p.offset));
+  const r = await apiCall("GET", `/v1/apps/${app_id}/agent-runs?${qs.toString()}`, void 0, {
+    appId: app_id
+  });
+  return { runs: r.runs ?? [] };
+}
+async function standaloneAgentRunGet(p) {
+  const { app_id } = await boot();
+  const r = await apiCall("GET", `/v1/apps/${app_id}/agent-runs/${encodeURIComponent(p.run_id)}`, void 0, {
+    appId: app_id,
+    runToken: runTokens.get(p.run_id)
+  });
+  return { run: r.run };
+}
+async function standaloneAgentRunCancel(p) {
+  const { app_id } = await boot();
+  await apiCall("POST", `/v1/apps/${app_id}/agent-runs/${encodeURIComponent(p.run_id)}/cancel`, {}, {
+    appId: app_id,
+    runToken: runTokens.get(p.run_id)
+  });
+  return { ok: true };
+}
+async function standaloneRename(payload) {
+  const fileId = payload !== null && typeof payload === "object" ? Reflect.get(payload, "file_id") : void 0;
+  const filename = payload !== null && typeof payload === "object" ? Reflect.get(payload, "filename") : void 0;
+  if (typeof fileId !== "string" || typeof filename !== "string") throw new Error("A file.rename names the file as `file_id` and its new name as `filename`.");
+  const { app_id } = await boot();
+  const { file } = await apiCall("POST", `/v1/apps/${app_id}/files/${encodeURIComponent(fileId)}/rename`, { filename }, { appId: app_id });
+  return file;
+}
+async function standaloneUpload(file, fidelity) {
+  if (!(file instanceof File)) {
+    throw new Error("upload payload must include a File");
+  }
+  const { app_id } = await boot();
+  const uploaded = await runUploadPipeline(file, {
+    initUpload: (input) => apiCall(
+      "POST",
+      `/v1/apps/${app_id}/files/upload-url`,
+      input,
+      { appId: app_id }
+    ),
+    completeUpload: (input) => apiCall(
+      "POST",
+      `/v1/apps/${app_id}/files/complete`,
+      input,
+      { appId: app_id }
+    )
+  }, { fidelity });
+  return uploaded;
+}
+
+export {
+  __export,
+  DEFAULT_IMAGE_FIDELITY,
+  subscribeRecordings,
+  recordingStateOf,
+  anyRecordingLive,
+  replaceRecordings,
+  readRecordingSnapshot,
+  urlParam,
+  decodeAll,
+  encodePatch,
+  applyPatch,
+  paramsEqual,
+  isEmbedded,
+  rpc,
+  getUrlParams,
+  setUrlParams,
+  peekUrlParams,
+  subscribeUrlParams,
+  postHostNotification,
+  subscribeQueriesChanged,
+  rpcAgentRun,
+  rpcAgentRunContinue
+};