@xano/sdk 1.0.0

package/dist/chunk-QCNYHBL7.js

@@ -0,0 +1,601 @@
+import {
+  findRelease,
+  listReleases
+} from "./chunk-2ZUEE4EK.js";
+import {
+  isSignatureRefusal
+} from "./chunk-AN6BL47T.js";
+import {
+  resolveEphemeralName
+} from "./chunk-SWBF2LTK.js";
+import {
+  displayNameHint,
+  displayNameOwner,
+  isShared,
+  nearBackendLines,
+  nearBackendName,
+  selectorFix,
+  sentenceCase,
+  sharedDisplayHint
+} from "./chunk-UZ6QQWJT.js";
+import {
+  getTenant,
+  tenantHasWorkspace
+} from "./chunk-A3UDOZB6.js";
+import {
+  clearEngineRecordsNamed,
+  getEngineRecord,
+  listEngineRecords
+} from "./chunk-3M4LFYNQ.js";
+import {
+  assertLoopbackUrl
+} from "./chunk-AM4FKL4J.js";
+import {
+  clearEnvironment,
+  getEnvironment,
+  readEphemeralState
+} from "./chunk-5QU2P5CA.js";
+import {
+  getEphemeral,
+  isExpired
+} from "./chunk-7G3CTU7I.js";
+import {
+  pipedYes
+} from "./chunk-T5KELPAR.js";
+import {
+  contextFlags
+} from "./chunk-NAQDMEHV.js";
+import {
+  TransportError,
+  UNTRUSTED_CERTIFICATE,
+  bindingFor,
+  certificateFailureCode,
+  isTimeoutError,
+  lastRateLimitRetryAfter
+} from "./chunk-YLDALTWZ.js";
+import {
+  CliError,
+  EXIT_SOURCE_UNRESOLVABLE,
+  safeText
+} from "./chunk-PTHVMXZI.js";
+import {
+  suggest,
+  suggestAll
+} from "./chunk-UTI5G6OJ.js";
+import {
+  shellQuote
+} from "./chunk-5ZSO4T2G.js";
+
+// src/emit/name-normalisation.ts
+function differOnlyInNormalisation(a, b) {
+  return a !== b && a.normalize("NFC") === b.normalize("NFC");
+}
+function differingCodePoints(a, b) {
+  const x = [...a];
+  const y = [...b];
+  let start = 0;
+  while (start < x.length && start < y.length && x[start] === y[start]) start++;
+  let end = 0;
+  while (end < x.length - start && end < y.length - start && x[x.length - 1 - end] === y[y.length - 1 - end]) end++;
+  const points = (chars) => chars.slice(start, chars.length - end).map((c) => `U+${c.codePointAt(0).toString(16).toUpperCase().padStart(4, "0")}`).join(" ");
+  return [points(x), points(y)];
+}
+function normalisationNote(typed, candidate) {
+  if (!differOnlyInNormalisation(typed, candidate)) return "";
+  const [here, there] = differingCodePoints(candidate, typed);
+  return ` (it differs from what was typed only in Unicode normalisation: ${here} there, ${there} typed)`;
+}
+function orNamesNoted(typed, names) {
+  const q = names.map((n) => `"${safeText(n)}"${normalisationNote(typed, n)}`);
+  return q.length <= 1 ? q[0] ?? "" : `${q.slice(0, -1).join(", ")} or ${q[q.length - 1]}`;
+}
+
+// src/emit/source-resolve.ts
+var SourceError = class extends Error {
+  constructor(message, liveness, kind, suggestion, suggestions) {
+    super(message);
+    this.liveness = liveness;
+    this.kind = kind;
+    this.suggestion = suggestion;
+    this.suggestions = suggestions;
+    this.name = "SourceError";
+  }
+  liveness;
+  kind;
+  suggestion;
+  suggestions;
+  exitCode = EXIT_SOURCE_UNRESOLVABLE;
+};
+var NO_CREDENTIAL = () => Promise.reject(new Error("Internal: a hosted source was resolved without a credential provider."));
+function actualKind(resolved) {
+  return resolved.kind === "tenant" && resolved.target.tenantType === "ephemeral" ? "ephemeral" : resolved.kind;
+}
+function describeBackend(resolved) {
+  const kind = actualKind(resolved);
+  const { label, display } = resolved.target;
+  const shown = display !== void 0 && display !== "" && display !== label ? ` (${JSON.stringify(display)})` : "";
+  switch (kind) {
+    case "ephemeral":
+    case "tenant":
+      return `${kind} ${JSON.stringify(label)}${shown}`;
+    case "workspace":
+      return "your workspace";
+    case "local-engine":
+      return resolved.provenance === "local-engine" ? "your local engine" : `local engine ${JSON.stringify(label)}`;
+    default:
+      return label;
+  }
+}
+function isTransportFailure(err) {
+  if (err instanceof TransportError) return true;
+  if (isTimeoutError(err) || isTimeoutError(err?.cause)) return true;
+  if (!(err instanceof Error)) return false;
+  return /could not reach|did not answer|timed out|network|ECONNREFUSED|ENOTFOUND|fetch failed/i.test(
+    err.message
+  ) || err.name === "TimeoutError" || err.name === "AbortError";
+}
+function isServerError(err) {
+  if (isSignatureRefusal(err)) return false;
+  const status = err?.status;
+  return typeof status === "number" && (status >= 500 && status < 600 || status === RATE_LIMITED);
+}
+var RATE_LIMITED = 429;
+function isRateLimited(err) {
+  if (err?.status === RATE_LIMITED) return true;
+  const first = err instanceof Error ? err.message.split("\n")[0] ?? "" : "";
+  return /\bfailed \(429\b/.test(first);
+}
+function rateLimitedCause() {
+  const after = lastRateLimitRetryAfter();
+  return `Rate limited${after === void 0 ? "" : ` \u2014 retry after ${after}s`}`;
+}
+function unansweredCause(err) {
+  if (certificateFailureCode(err) !== void 0) return "A certificate problem";
+  if (isTransportFailure(err)) return "A network failure";
+  if (isRateLimited(err)) return rateLimitedCause();
+  return "A server error";
+}
+function rateLimitedFailure(err) {
+  if (!(err instanceof Error) || err instanceof SourceError || !isRateLimited(err)) return err;
+  if (err.exitCode !== void 0 || err.code === "SDK_USAGE") return err;
+  const [first = "", ...rest] = err.message.trim().split("\n");
+  const failed = new LookupFailedError(
+    `${first.trim().replace(/[.:]$/, "")}. ${rateLimitedCause()}: the instance turned this request away before acting on it, so it changed nothing`,
+    "unreachable",
+    "workspace",
+    void 0,
+    "Once the wait is over"
+  );
+  if (rest.length > 0) {
+    failed.trailer = `
+${rest.join("\n")}`;
+    failed.message += failed.trailer;
+  }
+  failed.cause = err;
+  return failed;
+}
+function unansweredRead(err, what, kind) {
+  if (err instanceof LookupFailedError) return err;
+  const transport = isTransportFailure(err);
+  if (!transport && !isServerError(err)) return err;
+  const message = (err instanceof Error ? err.message : String(err)).trim();
+  const head = (message.split("\n")[0] ?? message).trim().replace(/[.:]$/, "");
+  const failed = new LookupFailedError(
+    `Could not ${what} \u2014 ${head}. ${unansweredCause(err)} \u2014 nothing was changed`,
+    "unreachable",
+    kind
+  );
+  failed.cause = err;
+  return failed;
+}
+function isUnansweredLookup(err) {
+  return isTransportFailure(err) || isServerError(err);
+}
+function clearStale(auth, name, cwd) {
+  const tracked = getEnvironment(readEphemeralState(cwd), auth);
+  if (tracked?.name === name) return clearEnvironment(cwd, auth);
+  return false;
+}
+function listHint(kind) {
+  switch (kind) {
+    // With this run's credential flags: the list a bare command reads is the
+    // machine default account's, not the one this run looked in.
+    case "ephemeral":
+      return `\`xanosdk ephemeral list${contextFlags()}\` shows the ones that exist`;
+    // `tenant:<name>` reaches both kinds, and `tenant list` shows only the
+    // standard ones — so a miss names both lists.
+    case "tenant":
+      return `\`xanosdk tenant list${contextFlags()}\` and \`xanosdk ephemeral list${contextFlags()}\` show the ones that exist`;
+    case "release":
+      return `\`xanosdk release list${contextFlags()}\` shows the ones that exist`;
+    case "local-engine":
+      return "`xanosdk local-engine list` shows the ones that are running";
+    default:
+      return "";
+  }
+}
+function gone(kind, name) {
+  return new SourceError(`No ${kind} named "${name}". ${listHint(kind)}.`, "gone", kind);
+}
+var LookupFailedError = class _LookupFailedError extends SourceError {
+  constructor(head, liveness, kind, rerun = "run this command again", when = head.includes(UNTRUSTED_CERTIFICATE) ? "Once the certificate is trusted" : "Once it is reachable") {
+    super(`${head}, and this run exits 8. ${when}, ${rerun}.`, liveness, kind);
+    this.head = head;
+    this.when = when;
+  }
+  head;
+  when;
+  /** Lines below the rerun sentence, carried into {@link withRerun}'s message. */
+  trailer = "";
+  /** The same failure naming `command` (with `tail`, e.g. " as you ran it") as the rerun. */
+  withRerun(command, tail = "", note = "") {
+    const next = new _LookupFailedError(this.head, this.liveness, this.kind, `run \`${command}\` again${tail}`, this.when);
+    next.message += `${note}${this.trailer}`;
+    next.trailer = this.trailer;
+    return next;
+  }
+};
+function lookupFailed(kind, name, err) {
+  const message = (err instanceof Error ? err.message : String(err)).trim();
+  const head = err instanceof TransportError ? message.split("\n")[0] ?? message : message;
+  const detail = head.trim().replace(/[.:]$/, "");
+  return new LookupFailedError(
+    `Could not look up ${kind} "${name}": ${detail}. ${unansweredCause(err)}, not a missing ${kind} \u2014 nothing was created or changed`,
+    "unreachable",
+    kind
+  );
+}
+async function lookupEphemeral(auth, name) {
+  try {
+    return await getEphemeral(auth, { parentWorkspaceId: auth.workspaceId, name });
+  } catch (err) {
+    if (isUnansweredLookup(err)) throw lookupFailed("ephemeral", name, err);
+    throw err;
+  }
+}
+function unreachable(kind, name, detail) {
+  return new SourceError(
+    `The ${kind} "${name}" exists but is not answering: ${detail} Nothing was created \u2014 retry, or check the instance.`,
+    "unreachable",
+    kind
+  );
+}
+async function goneWithHint(err, auth, kind, name, deps) {
+  const replaced = kind === "tenant" ? deps.getTenant !== void 0 : deps.getEphemeral !== void 0;
+  const lookup = deps.displayNameOf ?? (replaced ? void 0 : displayNameOwner);
+  const spell = deps.displayNameFix ?? selectorFix;
+  const kinds = kind === "tenant" ? ["tenant", "ephemeral"] : [kind];
+  const rows = [];
+  if (lookup !== void 0) {
+    for (const k of kinds) rows.push(...ownerRows(k, await lookup(auth, k, name).catch(() => void 0)));
+  }
+  const fixKind = (row) => kind === "tenant" ? "tenant" : row.kind;
+  if (rows.length > 1) return sharedDisplayError(err, name, { owners: rows }, (row) => spell(fixKind(row), row.name, true));
+  const only = rows[0];
+  if (only !== void 0) {
+    const fix2 = spell(fixKind(only), only.name);
+    return new SourceError(`${err.message}
+${displayNameHint(only.kind, name, only.name, fix2)}`, err.liveness, err.kind, only.name);
+  }
+  const nearOf = deps.nearNameOf ?? (lookup === displayNameOwner ? nearBackendName : void 0);
+  const near = nearOf === void 0 ? void 0 : await nearOf(auth, kind === "tenant" ? ["tenant", "ephemeral"] : [kind], name).catch(() => void 0);
+  if (near === void 0) return err;
+  const fix = (n) => sentenceCase(spell(kind === "tenant" ? "tenant" : near.kind, n, true));
+  return new SourceError(`${err.message}${nearBackendLines(near, fix)}`, err.liveness, err.kind, near.name, near.names);
+}
+function ownerRows(kind, owner) {
+  if (owner === void 0) return [];
+  return isShared(owner) ? [...owner.owners] : [{ kind, name: owner, detail: "" }];
+}
+function sharedDisplayError(err, display, shared, fix) {
+  const names = shared.owners.map((o) => o.name);
+  return new SourceError(`${err.message}
+${sharedDisplayHint(display, shared, fix)}`, err.liveness, err.kind, names[0], names);
+}
+async function releaseGone(auth, name, deps) {
+  const err = gone("release", name);
+  const namesOf = deps.releaseNamesOf ?? (deps.findRelease === void 0 ? releaseNames : void 0);
+  if (namesOf === void 0) return err;
+  const near = suggestAll(name, (await namesOf(auth).catch(() => [])).filter((n) => n !== name));
+  return near.length === 0 ? err : new SourceError(`${err.message}
+Did you mean ${orNamesNoted(name, near)}?`, err.liveness, err.kind, near[0], near);
+}
+async function refuseWorkspaceless(resolved, mode, hasWorkspace = tenantHasWorkspace) {
+  if (resolved.kind !== "tenant" || resolved.target.tenantType === "ephemeral" || resolved.backend?.kind !== "hosted") return;
+  if (await hasWorkspace(resolved.backend.auth, resolved.target.base)) return;
+  throw tenantNoWorkspace(resolved.target.env ?? resolved.target.label, resolved.target.display, mode);
+}
+function tenantNoWorkspace(tenant, display, mode) {
+  const flags = contextFlags();
+  const t = shellQuote(tenant);
+  const shown = display !== void 0 && display !== "" && display !== tenant ? ` (${JSON.stringify(display)})` : "";
+  const named = `Tenant ${JSON.stringify(tenant)}${shown}`;
+  const why = `a tenant on its own domain gets its workspace when its first release lands`;
+  const land = `\`xanosdk tenant deploy ${t} <release>${pipedYes()}${flags}\` (\`xanosdk release list${flags}\` names them)`;
+  if (mode === "read") {
+    return new SourceError(
+      `${named} has no workspace yet, so there is nothing to read: ${why}. Land one first: ${land}.`,
+      "gone",
+      "tenant"
+    );
+  }
+  return new CliError(
+    "SDK_USAGE",
+    `${named} has no workspace yet, so there is nothing to write to: ${why}. Nothing was written.
+Land a release on it first: ${land}, then run this again.`,
+    { details: { reason: "tenant-has-no-workspace", tenant } }
+  );
+}
+async function releaseNames(auth) {
+  return (await listReleases(auth, { workspaceId: auth.workspaceId })).map((r) => r.name);
+}
+async function resolveSource(source, credential, deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  if (source.kind === "local-engine") return resolveLocalEngine(source.name, cwd, deps);
+  const auth = await credential();
+  const hosted = await resolveHosted(auth, source, cwd, deps);
+  return {
+    ...hosted,
+    backend: {
+      kind: "hosted",
+      auth,
+      // An ephemeral and a tenant are each their own host, where workspace 1
+      // never matches the credential's and so proves nothing about the binding.
+      // A release is an object on the parent, addressed like the workspace.
+      binding: bindingFor(auth, hosted.target.workspaceId, hosted.kind === "ephemeral" || hosted.kind === "tenant")
+    },
+    bearer: auth
+  };
+}
+async function resolveHosted(auth, source, cwd, deps) {
+  const get = deps.getEphemeral ?? getEphemeral;
+  const tenant = deps.getTenant ?? getTenant;
+  const release = deps.findRelease ?? findRelease;
+  switch (source.kind) {
+    case "workspace":
+      return {
+        kind: "workspace",
+        provenance: "workspace",
+        target: {
+          base: auth.instance.replace(/\/$/, ""),
+          workspaceId: auth.workspaceId,
+          label: "your workspace"
+        }
+      };
+    case "ephemeral": {
+      const name = await resolveEphemeralName(auth, source.name, cwd);
+      let summary;
+      try {
+        summary = await get(auth, { parentWorkspaceId: auth.workspaceId, name });
+      } catch (err) {
+        if (isUnansweredLookup(err)) {
+          throw lookupFailed("ephemeral", name, err);
+        }
+        throw err;
+      }
+      if (summary === null) {
+        const cleared = clearStale(auth, name, cwd);
+        if (cleared) {
+          throw new SourceError(
+            `No ephemeral named "${name}" \u2014 this project's ephemeral was deleted (cleared this project's record of it). Run \`xanosdk deploy${contextFlags()}\` to create a fresh one.`,
+            "gone",
+            "ephemeral"
+          );
+        }
+        throw await goneWithHint(
+          new SourceError(
+            `No ephemeral named "${name}". ${listHint("ephemeral")}${cleared ? " (cleared this project's record of it)" : ""}.`,
+            "gone",
+            "ephemeral"
+          ),
+          auth,
+          "ephemeral",
+          name,
+          deps
+        );
+      }
+      if (isExpired(summary.expiresAt)) {
+        const cleared = clearStale(auth, name, cwd);
+        throw new SourceError(
+          `Ephemeral "${name}" has expired. Run \`xanosdk deploy${contextFlags()}\` to create a fresh one${cleared ? " (cleared this project's record of it)" : ""}.`,
+          "expired",
+          "ephemeral"
+        );
+      }
+      if (summary.url === void 0) {
+        throw unreachable("ephemeral", name, "it reports no URL.");
+      }
+      return {
+        kind: "ephemeral",
+        provenance: `ephemeral:${name}`,
+        // An env's own internal workspace id is always 1, addressed at its own
+        // base — which may carry a path prefix, so callers append to it.
+        target: {
+          base: summary.url.replace(/\/$/, ""),
+          workspaceId: 1,
+          label: name,
+          env: name,
+          ...summary.display !== void 0 ? { display: summary.display } : {}
+        }
+      };
+    }
+    case "tenant": {
+      let summary;
+      try {
+        summary = await tenant(auth, { workspaceId: auth.workspaceId, name: source.name });
+      } catch (err) {
+        if (isUnansweredLookup(err)) throw lookupFailed("tenant", source.name, err);
+        throw err;
+      }
+      if (summary === null) throw await goneWithHint(gone("tenant", source.name), auth, "tenant", source.name, deps);
+      if (summary.state !== void 0 && !/^(ok|active|ready|running)$/i.test(summary.state)) {
+        throw unreachable("tenant", source.name, `its state is "${summary.state}".`);
+      }
+      if (summary.url === void 0) throw unreachable("tenant", source.name, "it reports no URL.");
+      const tenantBase = summary.url.replace(/\/$/, "");
+      const mode = deps.workspaceless ?? "read";
+      const hasWorkspace = deps.hasWorkspace ?? (deps.getTenant === void 0 ? tenantHasWorkspace : void 0);
+      if (mode !== "any" && summary.type !== "ephemeral" && hasWorkspace !== void 0 && !await hasWorkspace(auth, tenantBase)) {
+        throw tenantNoWorkspace(source.name, summary.display, mode);
+      }
+      return {
+        kind: "tenant",
+        provenance: `tenant:${source.name}`,
+        target: {
+          base: tenantBase,
+          workspaceId: 1,
+          label: source.name,
+          env: source.name,
+          tenantType: summary.type,
+          ...summary.display !== void 0 ? { display: summary.display } : {}
+        }
+      };
+    }
+    case "release": {
+      let found;
+      try {
+        found = await release(auth, { workspaceId: auth.workspaceId, name: source.name });
+      } catch (err) {
+        if (isUnansweredLookup(err))
+          throw lookupFailed("release", source.name, err);
+        throw err;
+      }
+      if (found === null) throw await releaseGone(auth, source.name, deps);
+      if (!found.hasResource) {
+        throw new SourceError(
+          `Release "${source.name}" exists but its stored contents are missing. Cut it again from a live environment.`,
+          "gone",
+          "release"
+        );
+      }
+      return {
+        kind: "release",
+        provenance: `release:${source.name}`,
+        // A release is an object on the parent, not a place to send calls.
+        target: {
+          base: auth.instance.replace(/\/$/, ""),
+          workspaceId: auth.workspaceId,
+          label: source.name
+        },
+        release: found
+      };
+    }
+  }
+}
+async function resolveLocalEngine(named, cwd, deps) {
+  const env = deps.env ?? process.env;
+  const name = named !== void 0 && named !== "" ? named : getEngineRecord(cwd, env)?.name;
+  if (name === void 0) {
+    throw new SourceError(
+      `No local engine is recorded for this project, and no name was given.
+Run \`xanosdk deploy --local-engine\` to stand one up, or name one from \`xanosdk local-engine list\`.` + (deps.deployFallback !== false ? ` Meanwhile \`xanosdk deploy${contextFlags()}\` still deploys to an ephemeral.` : ""),
+      "gone",
+      "local-engine"
+    );
+  }
+  const running = await (deps.listEngines ?? defaultEnumeration(env, cwd))();
+  if (running === void 0) {
+    throw new SourceError(
+      `No engine is cached on this machine, so nothing here can find "${name}".
+Run \`xanosdk deploy --local-engine\` to fetch one.` + (deps.deployFallback !== false ? ` Meanwhile \`xanosdk deploy${contextFlags()}\` still deploys to an ephemeral.` : ""),
+      "gone",
+      "local-engine"
+    );
+  }
+  const stale = !running.some((e) => e.name === name) && listEngineRecords(env).some((r) => r.name === name);
+  const sweep = deps.sweepOrphans ?? (deps.listEngines === void 0 ? defaultSweep(env) : void 0);
+  const swept = stale && sweep !== void 0 ? await sweep() : [];
+  const engine = liveEngine(name, running, env, deps.deployFallback !== false, swept, deps.bareName === true);
+  return {
+    kind: "local-engine",
+    provenance: named !== void 0 && named !== "" ? `local-engine:${name}` : "local-engine",
+    target: {
+      base: engine.url.replace(/\/$/, ""),
+      workspaceId: engine.workspaceId,
+      label: named !== void 0 && named !== "" ? name : "your local engine"
+    },
+    backend: { kind: "local", engine },
+    // The ENUMERATION's url and token, never a record's: a restarted engine
+    // binds a fresh port and re-mints its bearer.
+    bearer: { access_token: engine.token, instance: engine.url }
+  };
+}
+function liveEngine(name, running, env, deployFallback, swept = [], bareName = false) {
+  const recorded = listEngineRecords(env).some((r) => r.name === name);
+  const engine = running.find((e) => e.name === name);
+  if (engine === void 0) {
+    const near = suggest(name, running.map((e) => e.name));
+    throw engineNotRunning(
+      name,
+      recorded ? clearEngineRecordsNamed(name, env).length : 0,
+      deployFallback,
+      near === void 0 || bareName ? near : `local-engine:${near}`,
+      swept
+    );
+  }
+  try {
+    assertLoopbackUrl(
+      engine.url,
+      recorded ? "The engine recorded for this project" : `The engine named "${name}"`
+    );
+  } catch (err) {
+    throw new SourceError(err.message, "unreachable", "local-engine");
+  }
+  return engine;
+}
+function engineNotRunning(name, clearedProjects, deployFallback = true, nearest, swept = []) {
+  const said = [
+    ...clearedProjects === 0 ? [] : [clearedProjects === 1 ? "cleared its local record" : `cleared its record in ${clearedProjects} projects`],
+    ...swept.length === 0 ? [] : [`stopped ${swept.length === 1 ? "a process" : `${swept.length} processes`} it left running (pid ${swept.join(", ")})`]
+  ];
+  const tail = said.length === 0 ? "" : ` (${said.join("; ")})`;
+  return new SourceError(
+    `Local engine "${name}" is not running${tail}.
+` + // A one-letter slip on a name nobody types by hand — say which one runs.
+    (nearest !== void 0 ? `Did you mean \`${nearest}\`? It is running.
+` : "") + `${listHint("local-engine")}, and \`xanosdk deploy --local-engine\` stands one up.` + (deployFallback ? ` Meanwhile \`xanosdk deploy${contextFlags()}\` still deploys to an ephemeral.` : ""),
+    "gone",
+    "local-engine",
+    nearest
+  );
+}
+function defaultSweep(env) {
+  return async () => {
+    const { stopOrphanedEngineProcesses } = await import("./local-engine-process-EHTE5LLU.js");
+    return stopOrphanedEngineProcesses({ env }).stopped;
+  };
+}
+function defaultEnumeration(env, cwd) {
+  return async () => {
+    const { cachedEngineEntry, listEngines } = await import("./local-engine-process-EHTE5LLU.js");
+    const entry = cachedEngineEntry(env, cwd);
+    return entry === void 0 ? void 0 : listEngines({ entry, env });
+  };
+}
+
+export {
+  differOnlyInNormalisation,
+  differingCodePoints,
+  normalisationNote,
+  orNamesNoted,
+  SourceError,
+  NO_CREDENTIAL,
+  actualKind,
+  describeBackend,
+  isTransportFailure,
+  isServerError,
+  isRateLimited,
+  rateLimitedCause,
+  unansweredCause,
+  rateLimitedFailure,
+  unansweredRead,
+  isUnansweredLookup,
+  LookupFailedError,
+  lookupFailed,
+  lookupEphemeral,
+  refuseWorkspaceless,
+  tenantNoWorkspace,
+  releaseNames,
+  resolveSource
+};
+//# sourceMappingURL=chunk-QCNYHBL7.js.map