@xano/sdk 1.0.0

package/dist/chunk-AKNCFVKZ.js

@@ -0,0 +1,36 @@
+// src/responses/raw-response.ts
+var RAW_RESPONSE = /* @__PURE__ */ Symbol.for("xanosdk.response.rawEnvelope");
+var CANONICAL_KEYS = ["filters", "name", "tag", "value", "_xsid", "disabled"];
+function rawResponse(items) {
+  if (!Array.isArray(items)) {
+    throw new Error(
+      'rawResponse() expects an array of stored result[] entries, e.g. `[{ name: "", tag: "input", value: "x", filters: [] }]` \u2014 but received ' + (items === null ? "null" : typeof items)
+    );
+  }
+  const stored = items.map((item, i) => {
+    if (item == null || typeof item !== "object" || Array.isArray(item)) {
+      throw new Error(
+        `rawResponse() item ${i} is not a stored result envelope object \u2014 received ` + (item === null ? "null" : Array.isArray(item) ? "an array" : typeof item)
+      );
+    }
+    const out = {};
+    for (const key of CANONICAL_KEYS) {
+      if (Object.hasOwn(item, key)) out[key] = item[key];
+    }
+    for (const key of Object.keys(item)) {
+      if (!Object.hasOwn(out, key)) out[key] = item[key];
+    }
+    return out;
+  });
+  return { [RAW_RESPONSE]: stored };
+}
+function rawResponseItems(response) {
+  if (response == null || typeof response !== "object") return void 0;
+  return response[RAW_RESPONSE];
+}
+
+export {
+  rawResponse,
+  rawResponseItems
+};
+//# sourceMappingURL=chunk-AKNCFVKZ.js.map

package/dist/chunk-AM4FKL4J.js

@@ -0,0 +1,237 @@
+import {
+  readEnvVar
+} from "./chunk-X2NL4KUO.js";
+
+// src/deploy/local-engine-config.ts
+import { existsSync, readdirSync } from "fs";
+import { homedir } from "os";
+import { isAbsolute, join, resolve } from "path";
+
+// src/deploy/local-engine-handshake.ts
+var LOOPBACK_HOSTS = ["127.0.0.1", "::1", "localhost"];
+var ALLOWED_PROTOCOLS = ["http:", "https:"];
+function isLoopbackUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  if (!ALLOWED_PROTOCOLS.includes(parsed.protocol)) return false;
+  const host = parsed.hostname.replace(/^\[|\]$/g, "");
+  if (!LOOPBACK_HOSTS.includes(host)) return false;
+  return /^[0-9]+$/.test(parsed.port);
+}
+function assertLoopbackUrl(url, what) {
+  if (isLoopbackUrl(url)) return;
+  throw new Error(
+    `${what} reports a url this SDK will not send a token to: ${url}
+A local engine has to serve loopback over http on a port of its own \u2014 ${LOOPBACK_HOSTS.join(", ")} \u2014 and anything else is reachable from off this machine. Stop that engine and start a fresh one without binding it to all interfaces.`
+  );
+}
+function requireString(raw, key, source) {
+  const value = raw[key];
+  if (typeof value !== "string" || value === "") {
+    throw new Error(
+      `${source} is missing \`${key}\`, or gave it as something other than text.
+That is not an engine this SDK knows how to drive \u2014 the engine on this machine is older or newer than the one it was built against. Move to a current one with \`xanosdk local-engine update\`.`
+    );
+  }
+  return value;
+}
+function requireNumber(raw, key, source) {
+  const value = raw[key];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(
+      `${source} is missing \`${key}\`, or gave it as something other than a number.
+That is not an engine this SDK knows how to drive \u2014 the engine on this machine is older or newer than the one it was built against. Move to a current one with \`xanosdk local-engine update\`.`
+    );
+  }
+  return value;
+}
+function readEngine(value, source) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(
+      `${source} did not print an engine description.
+Re-run, and if it happens again fetch a fresh copy with \`xanosdk local-engine cache clear\`, then \`xanosdk deploy --local-engine\`.`
+    );
+  }
+  const raw = value;
+  return {
+    name: requireString(raw, "name", source),
+    url: requireString(raw, "url", source),
+    workspaceId: requireNumber(raw, "workspace_id", source),
+    token: requireString(raw, "access_token", source),
+    pid: requireNumber(raw, "pid", source),
+    signInUrl: requireString(raw, "sign_in_url", source),
+    loginLinkEndpoint: requireString(raw, "login_link_endpoint", source),
+    logPath: requireString(raw, "log", source)
+  };
+}
+var HANDSHAKE_SOURCE = "The engine's start handshake";
+var LISTING_SOURCE = "The engine's list of running engines";
+function parseEngineHandshake(stdout) {
+  let value;
+  try {
+    value = JSON.parse(stdout.trim());
+  } catch {
+    throw new Error(
+      `${HANDSHAKE_SOURCE} did not print an engine description.
+Re-run, and if it happens again fetch a fresh copy with \`xanosdk local-engine cache clear\`, then \`xanosdk deploy --local-engine\`.`
+    );
+  }
+  const engine = readEngine(value, HANDSHAKE_SOURCE);
+  assertLoopbackUrl(engine.url, "The engine that just started");
+  return engine;
+}
+function parseEngineListing(stdout) {
+  const text = stdout.trim();
+  if (text === "") return [];
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new Error(
+      `${LISTING_SOURCE} was not readable.
+Re-run, and if it happens again fetch a fresh copy with \`xanosdk local-engine cache clear\`, then \`xanosdk deploy --local-engine\`.`
+    );
+  }
+  if (!Array.isArray(value)) {
+    throw new Error(
+      `${LISTING_SOURCE} was not a list.
+Re-run, and if it happens again fetch a fresh copy with \`xanosdk local-engine cache clear\`, then \`xanosdk deploy --local-engine\`.`
+    );
+  }
+  return value.filter((entry) => !isForeignEngine(entry)).map((entry) => readEngine(entry, LISTING_SOURCE));
+}
+function isForeignEngine(entry) {
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return false;
+  const raw = entry;
+  return raw.workspace_id === void 0 && raw.access_token === void 0;
+}
+
+// src/deploy/local-engine-config.ts
+var SUPPORTED_PLATFORMS = [
+  "darwin-arm64",
+  "linux-x64",
+  "linux-arm64"
+];
+function resolveEnginePlatform(platform = process.platform, arch = process.arch) {
+  const pair = `${platform}-${arch}`;
+  return SUPPORTED_PLATFORMS.find((p) => p === pair);
+}
+var LOCAL_ENGINE_HOME_ENV = "XANOSDK_LOCAL_ENGINE_HOME";
+function localEngineHome(env = process.env) {
+  return readEnvVar(LOCAL_ENGINE_HOME_ENV, env) ?? join(homedir(), ".xanosdk", "local-engine");
+}
+function engineRunHome(env = process.env) {
+  return join(localEngineHome(env), "engine");
+}
+function engineCacheDir(env = process.env, platform = process.platform) {
+  return join(engineRunHome(env), ...platform === "darwin" ? ["Library", "Caches"] : [".cache"]);
+}
+function legacyRuntimeDirs(env = process.env, platform = process.platform) {
+  const home = env.HOME !== void 0 && env.HOME !== "" ? env.HOME : homedir();
+  const cache = join(home, ...platform === "darwin" ? ["Library", "Caches"] : [".cache"]);
+  if (resolve(cache) === resolve(engineCacheDir(env, platform))) return [];
+  let names;
+  try {
+    names = readdirSync(cache, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+  return names.map((name) => join(cache, name)).filter((dir) => ["dist", "instances", "logs"].every((sub) => existsSync(join(dir, sub))));
+}
+function localEngineBinDir(env = process.env) {
+  return join(localEngineHome(env), "bin");
+}
+var LOCAL_ENGINE_OVERRIDE_ENV = "XANOSDK_LOCAL_ENGINE_OVERRIDE";
+var OVERRIDE_VERSION = /^v?\d+\.\d+\.\d+$/;
+function overrideSpec(value) {
+  if (OVERRIDE_VERSION.test(value)) {
+    return { kind: "release", version: value.startsWith("v") ? value : `v${value}` };
+  }
+  return { kind: "override", source: value };
+}
+function isTrustedEngineUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return true;
+  }
+  if (url.protocol === "https:") return true;
+  return url.protocol === "http:" && LOOPBACK_HOSTS.includes(url.hostname.replace(/^\[|\]$/g, ""));
+}
+function expandArchivePath(source, env = process.env) {
+  const home = env["HOME"] ?? homedir();
+  const expanded = source === "~" ? home : source.startsWith("~/") ? home + source.slice(1) : source;
+  return isAbsolute(expanded) ? expanded : resolve(expanded);
+}
+var ARCHIVE_SUFFIX = /\.(tar\.gz|tgz|gz|tar|zip)$/i;
+function engineOverrideRefusal(value, where, env = process.env) {
+  if (/^https?:\/\//i.test(value)) {
+    if (isTrustedEngineUrl(value)) return void 0;
+    return `${where} names an engine over plain http on a host that is not this machine. An engine is a program this command runs, so fetched that way anyone on the network path could swap it (and read XANOSDK_LOCAL_ENGINE_TOKEN if it is set). Nothing was requested.
+Serve the archive over https://, or over http:// from 127.0.0.1, ::1 or localhost.`;
+  }
+  const scheme = /^([a-z][a-z0-9+.-]*):\/\//i.exec(value);
+  if (scheme !== null) {
+    return `${where} names a URL with the ${scheme[1].toLowerCase()}:// scheme, and an engine is fetched only over https:// (or http:// from this machine). Nothing was requested.
+Pass ${where} an https:// URL, a version like v0.1.5, or the path to an engine archive.`;
+  }
+  if (OVERRIDE_VERSION.test(value)) return void 0;
+  const looksLikeVersion = !/[\\/~]/.test(value) && !ARCHIVE_SUFFIX.test(value) && (/^v[0-9a-z.+-]*$/i.test(value) || /^\d+(\.[0-9a-z+-]*)*$/i.test(value));
+  if (looksLikeVersion && !existsSync(value)) {
+    return `"${value}" is not an engine version \u2014 they are written vMAJOR.MINOR.PATCH, like v0.1.5 \u2014 and no archive file has that name here.
+Pass ${where} a version in that form, an https:// URL, or the path to an engine archive.`;
+  }
+  const path = expandArchivePath(value, env);
+  if (!existsSync(path)) {
+    return `${MISSING_ARCHIVE} ${path}.
+Check the path \u2014 ${where} is read exactly as passed, with \`~\` and relative paths resolved from where the command ran.`;
+  }
+  return void 0;
+}
+var MISSING_ARCHIVE = "There is no engine archive to read at";
+function engineSourceRefusal(flagValue, env = process.env) {
+  if (flagValue !== void 0 && flagValue !== "") return engineOverrideRefusal(flagValue, "`--local-engine`", env);
+  const fromEnv = readEnvVar(LOCAL_ENGINE_OVERRIDE_ENV, env)?.trim();
+  if (fromEnv === void 0) return void 0;
+  return engineOverrideRefusal(fromEnv, LOCAL_ENGINE_OVERRIDE_ENV, env);
+}
+function engineOverrideFromEnv(env = process.env) {
+  const value = readEnvVar(LOCAL_ENGINE_OVERRIDE_ENV, env)?.trim();
+  return value === void 0 ? void 0 : overrideSpec(value);
+}
+function resolveEngineSource(flagValue, env = process.env, pinned) {
+  if (flagValue !== void 0 && flagValue !== "") return overrideSpec(flagValue);
+  const fromEnv = engineOverrideFromEnv(env);
+  if (fromEnv !== void 0) return fromEnv;
+  return pinned === void 0 ? { kind: "release" } : { kind: "release", version: pinned };
+}
+
+export {
+  LOOPBACK_HOSTS,
+  isLoopbackUrl,
+  assertLoopbackUrl,
+  parseEngineHandshake,
+  parseEngineListing,
+  SUPPORTED_PLATFORMS,
+  resolveEnginePlatform,
+  LOCAL_ENGINE_HOME_ENV,
+  localEngineHome,
+  engineRunHome,
+  engineCacheDir,
+  legacyRuntimeDirs,
+  localEngineBinDir,
+  LOCAL_ENGINE_OVERRIDE_ENV,
+  isTrustedEngineUrl,
+  expandArchivePath,
+  engineOverrideRefusal,
+  MISSING_ARCHIVE,
+  engineSourceRefusal,
+  engineOverrideFromEnv,
+  resolveEngineSource
+};
+//# sourceMappingURL=chunk-AM4FKL4J.js.map

package/dist/chunk-AN6BL47T.js

@@ -0,0 +1,26 @@
+import {
+  httpFailure
+} from "./chunk-YLDALTWZ.js";
+
+// src/deploy/import.ts
+var ImportHttpError = class extends Error {
+  constructor(status, action, statusText, body, aftermath) {
+    const head = httpFailure(action, { status, statusText }, body);
+    super(aftermath === void 0 ? head : `${head}
+${aftermath}`);
+    this.status = status;
+    this.body = body;
+    this.name = "ImportHttpError";
+  }
+  status;
+  body;
+};
+function isSignatureRefusal(err) {
+  return err instanceof ImportHttpError && /invalid workspace signature/i.test(err.body);
+}
+
+export {
+  ImportHttpError,
+  isSignatureRefusal
+};
+//# sourceMappingURL=chunk-AN6BL47T.js.map

package/dist/chunk-AOSYVMUS.js

@@ -0,0 +1,147 @@
+import {
+  exportWorkspaceBundle
+} from "./chunk-CJHQKJU4.js";
+import {
+  encodeWorkspaceArchive,
+  readArchiveEntries
+} from "./chunk-3DRXWLJ5.js";
+import {
+  tarGz
+} from "./chunk-X4DVXBFY.js";
+import {
+  resolveSource
+} from "./chunk-QCNYHBL7.js";
+import {
+  downloadRelease
+} from "./chunk-2ZUEE4EK.js";
+import {
+  backendDirIn
+} from "./chunk-5A2PLKZB.js";
+import {
+  BARE,
+  UsageError,
+  isKindShaped,
+  parseSource,
+  relForwardSlash
+} from "./chunk-PTHVMXZI.js";
+import {
+  calcSignatureJson
+} from "./chunk-LQCMKAJ7.js";
+
+// src/emit/deploy-source.ts
+import { existsSync } from "fs";
+import { join } from "path";
+var DEPLOY_SOURCE_KINDS = [
+  "release",
+  "ephemeral",
+  "tenant",
+  "workspace",
+  "local-engine"
+];
+var ENTRY_FILE = "index.ts";
+function looksLikeSource(raw) {
+  return isKindShaped(raw) || BARE.includes(raw);
+}
+function resolveProjectEntry(cwd) {
+  const entry = join(backendDirIn(cwd), ENTRY_FILE);
+  if (!existsSync(entry)) return void 0;
+  return `./${relForwardSlash(cwd, entry)}`;
+}
+async function fetchSourceArchive(credential, raw, cwd = process.cwd(), deps = {}) {
+  const source = parseSource(raw, DEPLOY_SOURCE_KINDS, { command: "deploy" });
+  const resolved = await resolveSource(source, credential, { ...deps, cwd });
+  if (resolved.kind === "release" && resolved.backend.kind === "hosted") {
+    const { auth } = resolved.backend;
+    const release = resolved.release;
+    if (release?.id === void 0) {
+      throw new UsageError(`Release "${raw}" carries no id, so it cannot be deployed.`, {
+        helpFor: { command: "deploy" }
+      });
+    }
+    return {
+      archive: asWorkspaceArchive(
+        await downloadRelease(auth, { workspaceId: auth.workspaceId, id: release.id }),
+        release.name
+      ),
+      provenance: resolved.provenance,
+      label: release.name
+    };
+  }
+  const exported = await exportWorkspaceBundle(resolved.bearer, resolved.target);
+  const display = resolved.target.display;
+  return {
+    archive: encodeWorkspaceArchive(JSON.stringify(exported)),
+    provenance: resolved.provenance,
+    label: resolved.target.label,
+    ...display !== void 0 && display !== "" && display !== resolved.target.label ? { display } : {}
+  };
+}
+var WORKSPACE_JSON = "workspace.json";
+function passwordSeedColumns(archive) {
+  const entries = readArchiveEntries(archive);
+  const raw = entries[WORKSPACE_JSON];
+  if (raw === void 0) return [];
+  const payload = JSON.parse(raw.toString("utf8")).payload;
+  const tables = Array.isArray(payload?.dbo) ? payload.dbo : [];
+  const out = [];
+  for (const table of tables) {
+    const { guid, name, schema } = table;
+    if (typeof guid !== "string" || typeof name !== "string" || !Array.isArray(schema)) continue;
+    const columns = schema.filter((c) => c.type === "password" && typeof c.name === "string").map((c) => c.name);
+    if (columns.length === 0) continue;
+    const rows = Object.entries(entries).filter(([file]) => file.startsWith(`content/${guid}-`)).flatMap(([, data]) => {
+      const rowsIn = JSON.parse(data.toString("utf8")).payload;
+      return Array.isArray(rowsIn) ? rowsIn : [];
+    });
+    for (const column of columns) {
+      if (rows.some((r) => typeof r[column] === "string" && r[column] !== "")) out.push(`${name}.${column}`);
+    }
+  }
+  return out;
+}
+function archiveSeedContent(archive) {
+  return Object.entries(readArchiveEntries(archive)).filter(([name]) => name.startsWith("content/") && name.endsWith(".json")).map(([name, data]) => ({ name, content: data.toString("utf8") }));
+}
+function gatedApiGroups(bundle) {
+  const rows = bundle?.payload?.app;
+  if (!Array.isArray(rows)) return [];
+  const out = [];
+  for (const row of rows) {
+    if (row === null || typeof row !== "object") continue;
+    const group = row;
+    const doc = group.documentation;
+    const gated = group.swagger === true && doc?.require_token === true && typeof doc.token === "string" && doc.token !== "";
+    if (gated && typeof group.name === "string") out.push(group.name);
+  }
+  return out;
+}
+function asWorkspaceArchive(archive, label) {
+  const entries = readArchiveEntries(archive);
+  const raw = entries[WORKSPACE_JSON];
+  if (raw === void 0) {
+    throw new Error(`Release "${label}" has no ${WORKSPACE_JSON}, so it cannot be deployed.`);
+  }
+  const envelope = JSON.parse(raw.toString("utf8"));
+  if (envelope.type === "workspace") return archive;
+  const { sig: _stored, ...unsigned } = envelope;
+  const retyped = { ...unsigned, type: "workspace" };
+  const files = [
+    { name: WORKSPACE_JSON, data: Buffer.from(JSON.stringify({ ...retyped, sig: calcSignatureJson(retyped) }), "utf8") }
+  ];
+  for (const [name, data] of Object.entries(entries)) {
+    if (name !== WORKSPACE_JSON) files.push({ name, data });
+  }
+  return tarGz(files);
+}
+
+export {
+  DEPLOY_SOURCE_KINDS,
+  looksLikeSource,
+  resolveProjectEntry,
+  fetchSourceArchive,
+  passwordSeedColumns,
+  archiveSeedContent,
+  gatedApiGroups,
+  asWorkspaceArchive
+};
+//# sourceMappingURL=chunk-AOSYVMUS.js.map

package/dist/chunk-APWXY5SL.js

@@ -0,0 +1,182 @@
+import {
+  LOOPBACK_HOSTS
+} from "./chunk-AM4FKL4J.js";
+import {
+  TransportError,
+  describeTransportFailure,
+  fetchOrExplain
+} from "./chunk-YLDALTWZ.js";
+import {
+  readEnvVar
+} from "./chunk-X2NL4KUO.js";
+
+// src/deploy/local-engine-releases.ts
+var DEFAULT_ENGINE_RELEASES_URL = "https://xo2z-4vn5-mdxv.dev.xano.io/api:engine-mirror";
+var ENGINE_RELEASES_URL_ENV = "XANOSDK_ENGINE_RELEASES_URL";
+function usesCustomReleaseManager(env = process.env) {
+  const raw = readEnvVar(ENGINE_RELEASES_URL_ENV, env);
+  if (raw === void 0) return false;
+  return raw.replace(/\/+$/, "") !== DEFAULT_ENGINE_RELEASES_URL;
+}
+var RELEASES_TIMEOUT_MS = 3e4;
+var MAX_LATEST_PAGES = 4;
+var VERSION_PATTERN = /^v?\d+\.\d+\.\d+$/;
+var SHA256_PATTERN = /^[0-9a-f]{64}$/;
+function normalizeEngineVersion(version) {
+  const trimmed = version.trim();
+  if (!VERSION_PATTERN.test(trimmed)) {
+    throw new Error(
+      `"${version}" is not an engine version \u2014 they are written vMAJOR.MINOR.PATCH, like v0.1.5.
+Pass a version in that form, or \`latest\`.`
+    );
+  }
+  return trimmed.startsWith("v") ? trimmed : `v${trimmed}`;
+}
+function isLoopback(url) {
+  return LOOPBACK_HOSTS.includes(url.hostname.replace(/^\[|\]$/g, ""));
+}
+function isTrustedUrl(url) {
+  return url.protocol === "https:" || url.protocol === "http:" && isLoopback(url);
+}
+function parseUrl(value) {
+  try {
+    return new URL(value);
+  } catch {
+    return void 0;
+  }
+}
+function releasesBase(env) {
+  const set = readEnvVar(ENGINE_RELEASES_URL_ENV, env);
+  const raw = set ?? DEFAULT_ENGINE_RELEASES_URL;
+  const url = parseUrl(raw);
+  if (url === void 0 || !isTrustedUrl(url)) {
+    throw new Error(
+      `${ENGINE_RELEASES_URL_ENV} must be an https URL, and is not \u2014 so no engine release was looked up.
+Set it to the release manager's https address, or unset it to use the default.`
+    );
+  }
+  const base = `${url.origin}${url.pathname}`.replace(/\/+$/, "");
+  return { base, display: base, fromEnv: set !== void 0 };
+}
+function unreachableRemedy(where) {
+  return where.fromEnv ? `Check the network, and ${ENGINE_RELEASES_URL_ENV} (set to ${where.display}), then re-run.` : "Check the network and re-run.";
+}
+function notListingRemedy(where) {
+  return where.fromEnv ? `${ENGINE_RELEASES_URL_ENV} is set to ${where.display} \u2014 check it addresses the release manager's API, or unset it for the default, then re-run.` : "Re-run in a moment; if it keeps failing, the release index is down.";
+}
+function pickAsset(body, platform) {
+  if (body === null || typeof body !== "object") return void 0;
+  const { version, assets } = body;
+  if (typeof version !== "string" || !VERSION_PATTERN.test(version) || !Array.isArray(assets)) return void 0;
+  for (const a of assets) {
+    if (a === null || typeof a !== "object") continue;
+    const { platform: p, filename, sha256, download_url } = a;
+    if (p !== platform) continue;
+    if (typeof filename !== "string" || filename === "") continue;
+    if (typeof sha256 !== "string" || !SHA256_PATTERN.test(sha256)) continue;
+    if (typeof download_url !== "string") continue;
+    const dl = parseUrl(download_url);
+    if (dl === void 0 || !isTrustedUrl(dl)) continue;
+    return { version: normalizeEngineVersion(version), filename, sha256, downloadUrl: download_url };
+  }
+  return void 0;
+}
+async function getJson(url, where, fetch) {
+  const { display } = where;
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "GET",
+      // No Authorization, deliberately: the index is public.
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(RELEASES_TIMEOUT_MS)
+    });
+  } catch (err) {
+    const reason = err instanceof TransportError && err.timeout ? `it did not answer within ${Math.round(RELEASES_TIMEOUT_MS / 1e3)}s` : describeTransportFailure(err instanceof TransportError && err.cause !== void 0 ? err.cause : err);
+    throw new Error(
+      `The engine release manager at ${display} could not be reached: ${reason.replace(/\.$/, "")}. Nothing was changed.
+` + unreachableRemedy(where),
+      { cause: err }
+    );
+  }
+  if (!res.ok) return { status: res.status, body: void 0 };
+  try {
+    return { status: res.status, body: await res.json() };
+  } catch {
+    throw new Error(
+      `The engine release manager at ${display} answered with something that is not a release listing.
+` + notListingRemedy(where)
+    );
+  }
+}
+var EngineReleaseNotFoundError = class extends Error {
+  name = "EngineReleaseNotFoundError";
+  exitCode = 8;
+};
+function failed(status, display) {
+  const err = new Error(
+    `The engine release manager at ${display} failed (HTTP ${status}).
+Re-run in a moment; if it keeps failing, the release index is down.`
+  );
+  if (status >= 500) Object.defineProperty(err, "exitCode", { value: 8, enumerable: true });
+  return err;
+}
+async function resolveEngineRelease(opts) {
+  const env = opts.env ?? process.env;
+  const { platform } = opts;
+  const wanted = opts.version === void 0 || opts.version === "latest" ? void 0 : normalizeEngineVersion(opts.version);
+  const where = releasesBase(env);
+  const { base, display } = where;
+  const fetch = opts.fetch ?? ((url, init) => fetchOrExplain(url, init, "resolve the engine release", RELEASES_TIMEOUT_MS, display));
+  if (wanted !== void 0) {
+    const { status, body } = await getJson(
+      `${base}/releases/${encodeURIComponent(wanted)}?product=engine`,
+      where,
+      fetch
+    );
+    if (status === 404) {
+      throw new EngineReleaseNotFoundError(
+        `There is no published engine release ${wanted}.
+Check the version, or run \`xanosdk local-engine update\` to move to the latest one.`
+      );
+    }
+    if (body === void 0) throw failed(status, display);
+    const asset = pickAsset(body, platform);
+    if (asset === void 0) {
+      throw new Error(
+        `Engine release ${wanted} has no archive for ${platform}, so nothing was downloaded.
+Run \`xanosdk local-engine update\` to move to a release built for ${platform}.`
+      );
+    }
+    return asset;
+  }
+  for (let pageNo = 1; pageNo <= MAX_LATEST_PAGES; pageNo++) {
+    const { status, body } = await getJson(`${base}/releases?product=engine&page=${pageNo}`, where, fetch);
+    if (body === void 0) throw failed(status, display);
+    const { items, nextPage } = body ?? {};
+    if (!Array.isArray(items)) {
+      throw new Error(
+        `The engine release manager at ${display} answered with something that is not a release listing.
+` + notListingRemedy(where)
+      );
+    }
+    for (const item of items) {
+      const asset = pickAsset(item, platform);
+      if (asset !== void 0) return asset;
+    }
+    if (typeof nextPage !== "number") break;
+  }
+  throw new Error(
+    `No published engine release has an archive for ${platform}, so nothing was downloaded.
+Deploy from a machine the engine is published for, or wait for a release built for ${platform}.`
+  );
+}
+
+export {
+  ENGINE_RELEASES_URL_ENV,
+  usesCustomReleaseManager,
+  normalizeEngineVersion,
+  EngineReleaseNotFoundError,
+  resolveEngineRelease
+};
+//# sourceMappingURL=chunk-APWXY5SL.js.map