@xano/sdk 1.0.0

package/dist/chunk-WQFNASK4.js

@@ -0,0 +1,560 @@
+import {
+  readArchiveEntries
+} from "./chunk-3DRXWLJ5.js";
+import {
+  tarGz
+} from "./chunk-X4DVXBFY.js";
+import {
+  ImportHttpError
+} from "./chunk-AN6BL47T.js";
+import {
+  describeWrite
+} from "./chunk-4KHEMC32.js";
+import {
+  TransportError,
+  certificateFailureCode,
+  closeSentence,
+  debugEnabled,
+  describeTransportFailure,
+  explainBodyFailure,
+  isTimeoutError,
+  lostAnswerHead,
+  notJsonError,
+  noteMetaAnswer,
+  noteRateLimit,
+  serverMessage,
+  statusLabel,
+  transportTarget,
+  writeStatusAftermath
+} from "./chunk-YLDALTWZ.js";
+import {
+  calcSignatureJson,
+  signatureHolds
+} from "./chunk-LQCMKAJ7.js";
+import {
+  HOSTED_FILE_SCHEME,
+  HOSTED_ICON_KINDS,
+  HOSTED_ROW_PATH_PREFIX
+} from "./chunk-XNCP4KYO.js";
+
+// src/deploy/xanosdk-import.ts
+var IMPORT_TIMEOUT_MS = 12e4;
+var PROBE_TIMEOUT_MS = 15e3;
+var READ_ATTEMPTS = 3;
+var READ_BACKOFF_MS = 400;
+var XANOSDK_IMPORT_CONFLICT_CODE = "conflict";
+var XANOSDK_IMPORT_IN_PROGRESS_CODE = "import_in_progress";
+var XANOSDK_IMPORT_UNIQUENESS_CODE = "uniqueness_violation";
+var XANOSDK_IMPORT_UNRESOLVED_FILE_CODE = "unresolved_hosted_file";
+var CANONICAL_OUTCOMES = ["honored", "kept", "minted", "conflict"];
+var ImportNotSentError = class extends TransportError {
+};
+var XanoSdkImportRefusal = class extends Error {
+  constructor(status, code, reason, conflicts, canonicals, raw, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.reason = reason;
+    this.conflicts = conflicts;
+    this.canonicals = canonicals;
+    this.raw = raw;
+    this.name = "XanoSdkImportRefusal";
+  }
+  status;
+  code;
+  reason;
+  conflicts;
+  canonicals;
+  raw;
+  /**
+   * True only for the in-progress refusal — a second caller that lost the race
+   * for the instance-wide lock. Every other refusal names something the project
+   * has to change, so retrying it unchanged would just refuse again.
+   */
+  get retryable() {
+    return this.code === XANOSDK_IMPORT_IN_PROGRESS_CODE;
+  }
+};
+function endpoint(target, qs = "") {
+  return `${target.baseUrl.replace(/\/$/, "")}/api:meta/workspace/${target.workspaceId}/xanosdk/import${qs}`;
+}
+function query(opts) {
+  const params = new URLSearchParams();
+  if (opts.mode !== void 0) params.set("mode", opts.mode);
+  if (opts.prune !== void 0) params.set("delete", String(opts.prune));
+  if (opts.records !== void 0) params.set("records", String(opts.records));
+  if (opts.truncate !== void 0) params.set("truncate", String(opts.truncate));
+  if (opts.branch !== void 0) params.set("branch", opts.branch);
+  if (opts.preserveGuids !== void 0) params.set("preserve_guids", String(opts.preserveGuids));
+  params.set("dry_run", String(opts.dryRun));
+  for (const guid of opts.pinned ?? []) params.append("pinned[]", guid);
+  return `?${params.toString()}`;
+}
+function body(archive) {
+  const form = new FormData();
+  form.append("file", new Blob([archive], { type: "application/gzip" }), "workspace.gz");
+  return form;
+}
+var detectionByBaseUrl = /* @__PURE__ */ new Map();
+function detectionKey(baseUrl) {
+  return baseUrl.replace(/\/$/, "");
+}
+function resetXanoSdkImportDetection(baseUrl) {
+  if (baseUrl === void 0) detectionByBaseUrl.clear();
+  else detectionByBaseUrl.delete(detectionKey(baseUrl));
+}
+function undecidable(baseUrl, why, status) {
+  const err = new Error(
+    `Could not determine whether this instance supports a merging deploy: ${why}
+  instance: ${baseUrl}
+Only a 404 means the route is absent. Every other answer leaves the question open, and guessing either way would decide how this deploy writes on no evidence.
+Nothing was deployed \u2014 fix the access or reachability problem, then retry the deploy.`
+  );
+  if (status !== void 0) Object.defineProperty(err, "status", { value: status, enumerable: false });
+  return err;
+}
+async function detectXanoSdkImportRoute(auth, target) {
+  const key = detectionKey(target.baseUrl);
+  const cached = detectionByBaseUrl.get(key);
+  if (cached !== void 0) return cached;
+  const probe = probeXanoSdkImportRoute(auth, target);
+  detectionByBaseUrl.set(key, probe);
+  probe.catch(() => detectionByBaseUrl.delete(key));
+  return probe;
+}
+async function probeXanoSdkImportRoute(auth, target) {
+  const fetchFn = target.fetchFn ?? fetch;
+  let res;
+  try {
+    res = await fetchFn(endpoint(target, "?dry_run=true"), {
+      method: "POST",
+      headers: { accept: "application/json", Authorization: `Bearer ${auth.access_token}` },
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
+    });
+    await noteMetaAnswer(endpoint(target, ""), res);
+    noteRateLimit(res);
+  } catch (err) {
+    throw undecidable(target.baseUrl, `could not reach it (${describeTransportFailure(err)}).`);
+  }
+  if (res.status === 404) return false;
+  if (res.ok || res.status === 400 || res.status === 422) return true;
+  const text = await res.text().catch(() => "");
+  const detail = serverMessage(text);
+  throw undecidable(
+    target.baseUrl,
+    // `statusLabel`: an empty statusText left "answered 503 : injected" (E2E pass 28).
+    `the probe answered ${statusLabel(res)}${detail !== void 0 ? `: ${detail}` : "."}`,
+    res.status
+  );
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function malformed(field, why, ctx) {
+  const target = ctx.target;
+  const Target = target.charAt(0).toUpperCase() + target.slice(1);
+  const detail = `(no usable \`${field}\`: ${why})`;
+  const head = ctx.answer === "refusal" ? `${Target} refused the ${ctx.verb} with a detail that could not be read ${detail}.` : ctx.answer === "preview" ? `${Target} answered the ${ctx.verb} with something that isn't a preview result ${detail}. A dry run writes nothing, so ${target} is untouched.` : `${Target} answered the ${ctx.verb} with something that isn't a ${ctx.verb} result ${detail} \u2014 it may or may not have landed; check ${target} before retrying.`;
+  return new Error(debugEnabled() && ctx.raw.trim() !== "" ? `${head}
+${ctx.raw}` : head);
+}
+function kindOf(value) {
+  if (value === void 0) return "the field is not present";
+  if (value === null) return "got null";
+  if (typeof value === "boolean") return `got ${value}`;
+  if (Array.isArray(value)) return "got a list";
+  if (typeof value === "object") return "got an object";
+  return `got a ${typeof value}`;
+}
+function requiredString(value, field, raw) {
+  if (typeof value !== "string" || value === "") {
+    throw malformed(field, kindOf(value), raw);
+  }
+  return value;
+}
+function optionalString(value) {
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function decodeConflict(entry, index, raw) {
+  const field = `conflicts[${index}]`;
+  if (!isRecord(entry)) throw malformed(field, kindOf(entry), raw);
+  const owner = entry.owner;
+  if (!isRecord(owner)) throw malformed(`${field}.owner`, "a conflict must name the object that already holds the identity", raw);
+  const workspaceId = owner.workspace_id;
+  if (typeof workspaceId !== "number") {
+    throw malformed(`${field}.owner.workspace_id`, kindOf(workspaceId), raw);
+  }
+  return {
+    kind: requiredString(entry.kind, `${field}.kind`, raw),
+    identity: requiredString(entry.identity, `${field}.identity`, raw),
+    archiveGuid: optionalString(entry.archive_guid),
+    owner: {
+      workspaceId,
+      // The descriptive half degrades to "unknown" without changing any
+      // decision, so it is read liberally: which workspace owns it is the fact
+      // the remedy turns on, and that one is checked above.
+      workspaceName: optionalString(owner.workspace_name),
+      guid: optionalString(owner.guid),
+      branch: optionalString(owner.branch),
+      deleted: owner.deleted === true
+    }
+  };
+}
+function decodeCanonical(entry, index, raw) {
+  const field = `canonicals[${index}]`;
+  if (!isRecord(entry)) throw malformed(field, kindOf(entry), raw);
+  const outcome = entry.outcome;
+  if (typeof outcome !== "string" || !CANONICAL_OUTCOMES.includes(outcome)) {
+    throw malformed(
+      `${field}.outcome`,
+      `${kindOf(outcome)}${typeof outcome === "string" ? " this CLI does not know" : ""}, expected one of ${CANONICAL_OUTCOMES.map((o) => JSON.stringify(o)).join(", ")}`,
+      raw
+    );
+  }
+  return {
+    kind: requiredString(entry.kind, `${field}.kind`, raw),
+    name: requiredString(entry.name, `${field}.name`, raw),
+    guid: optionalString(entry.guid),
+    requested: optionalString(entry.requested),
+    served: optionalString(entry.served),
+    outcome
+  };
+}
+function decodePlan(value, raw) {
+  if (!isRecord(value)) throw malformed("plan", kindOf(value), raw);
+  if (!isRecord(value.summary)) throw malformed("plan.summary", kindOf(value.summary), raw);
+  if (!Array.isArray(value.operations)) {
+    throw malformed("plan.operations", kindOf(value.operations), raw);
+  }
+  const operations = value.operations.map((entry) => {
+    const op = isRecord(entry) ? entry : {};
+    return {
+      type: typeof op.type === "string" ? op.type : "",
+      name: typeof op.name === "string" ? op.name : "",
+      action: typeof op.action === "string" ? op.action : "",
+      ...typeof op.details === "string" ? { details: op.details } : {},
+      ...typeof op.reason === "string" ? { reason: op.reason } : {}
+    };
+  });
+  return {
+    summary: value.summary,
+    operations,
+    hasRecords: value.has_records === true,
+    hasEnv: value.has_env === true
+  };
+}
+function decodeResponse(text, dryRun, where) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    const head = notJsonError(where.action, text, where.baseUrl).message;
+    const target = where.label ?? "the target";
+    throw new Error(
+      `${head}
+` + (dryRun ? `A dry run writes nothing, so ${target} is untouched.` : `Whether the import ran cannot be read from that answer \u2014 it may or may not have landed, in whole or in part. Check ${target} before retrying.`)
+    );
+  }
+  const raw = {
+    raw: text,
+    target: where.label ?? "the target",
+    verb: "deploy",
+    answer: dryRun ? "preview" : "write"
+  };
+  if (!isRecord(parsed)) throw malformed("response", kindOf(parsed), raw);
+  if (typeof parsed.applied !== "boolean") {
+    throw malformed("applied", kindOf(parsed.applied), raw);
+  }
+  if (parsed.applied !== !dryRun) {
+    throw malformed(
+      "applied",
+      dryRun ? `a dry run must not report \`applied: true\` \u2014 something may have been written` : `an import reported \`applied: false\` with a success status, so it is not knowable whether anything landed`,
+      // A preview that says it applied is no longer a preview: it may have written.
+      { ...raw, answer: "write" }
+    );
+  }
+  if (!Array.isArray(parsed.conflicts)) throw malformed("conflicts", kindOf(parsed.conflicts), raw);
+  if (!Array.isArray(parsed.canonicals)) throw malformed("canonicals", kindOf(parsed.canonicals), raw);
+  const workspace = isRecord(parsed.workspace) ? parsed.workspace : {};
+  return {
+    workspace: {
+      id: typeof workspace.id === "number" ? workspace.id : void 0,
+      name: optionalString(workspace.name)
+    },
+    branch: requiredString(parsed.branch, "branch", raw),
+    applied: parsed.applied,
+    plan: decodePlan(parsed.plan, raw),
+    conflicts: parsed.conflicts.map((entry, i) => decodeConflict(entry, i, raw)),
+    canonicals: parsed.canonicals.map((entry, i) => decodeCanonical(entry, i, raw)),
+    ...decodeHostedFiles(parsed.hosted_files),
+    raw: text
+  };
+}
+function decodeHostedFiles(value) {
+  if (!isRecord(value)) return {};
+  const { resolved, unresolved } = value;
+  if (!Number.isInteger(resolved) || !Number.isInteger(unresolved)) return {};
+  return { hostedFiles: { resolved, unresolved } };
+}
+function hostedReferencesOf(archive) {
+  const entries = readArchiveEntries(archive);
+  const referenced = /* @__PURE__ */ new Map();
+  const carried = /* @__PURE__ */ new Set();
+  let icons = 0;
+  for (const name of Object.keys(entries)) {
+    const m = /^vault\/([^/]+)\//.exec(name);
+    if (m) carried.add(m[1]);
+  }
+  const parse = (raw) => {
+    if (raw === void 0) return void 0;
+    try {
+      return JSON.parse(raw.toString("utf8")).payload;
+    } catch {
+      return void 0;
+    }
+  };
+  const payload = parse(entries["workspace.json"]);
+  if (isRecord(payload)) {
+    for (const key of HOSTED_ICON_KINDS) {
+      const objects = payload[key];
+      if (!Array.isArray(objects)) continue;
+      for (const obj of objects) {
+        const list = isRecord(obj) ? obj.icons : void 0;
+        if (!Array.isArray(list)) continue;
+        for (const icon of list) {
+          if (!isRecord(icon) || typeof icon.src !== "string" || !icon.src.startsWith(HOSTED_FILE_SCHEME)) continue;
+          icons++;
+          const [canonical = "", file = ""] = icon.src.slice(HOSTED_FILE_SCHEME.length).split("/");
+          referenced.set(canonical, decodeURIComponent(file));
+        }
+      }
+    }
+  }
+  const noteRowValue = (value) => {
+    const path = isRecord(value) ? value.path : void 0;
+    if (typeof path !== "string" || !path.startsWith(HOSTED_ROW_PATH_PREFIX)) return;
+    const [canonical = "", , file = ""] = path.slice(HOSTED_ROW_PATH_PREFIX.length).split("/");
+    referenced.set(canonical, decodeURIComponent(file));
+  };
+  for (const [name, raw] of Object.entries(entries)) {
+    if (!name.startsWith("content/")) continue;
+    const rows = parse(raw);
+    if (!Array.isArray(rows)) continue;
+    for (const row of rows) {
+      if (!isRecord(row)) continue;
+      for (const value of Object.values(row)) {
+        if (Array.isArray(value)) value.forEach(noteRowValue);
+        else noteRowValue(value);
+      }
+    }
+  }
+  return { icons, referenced, carried };
+}
+function hostedReferencesIn(archive) {
+  return hostedReferencesOf(archive).icons;
+}
+function assertHostedFilesCarried(archive, where) {
+  const { referenced, carried } = hostedReferencesOf(archive);
+  const missing = [...referenced].filter(([canonical]) => !carried.has(canonical)).map(([, name]) => name || "(unnamed)");
+  if (missing.length === 0) return;
+  throw new ImportNotSentError(
+    `This archive references ${missing.length === 1 ? "a hostedFile()" : `${missing.length} hostedFile()s`} it does not carry (${[...new Set(missing)].join(", ")}), so ${where.label ?? "the target"} would store fields pointing at nothing. A bundle written by \`xanosdk export\` or built in a browser carries no hosted files: deploy from an entry file that reads each with \`hostedFile("./<file>", import.meta.url)\`, so the bytes ship with it \u2014 a literal \`xanosdk-file://\` src in source carries none, so save the image in the repo and write the hostedFile() line in its place. Nothing was sent.`,
+    false
+  );
+}
+var HostedFilesUnresolvedError = class extends Error {
+  constructor(message, applied) {
+    super(message);
+    this.applied = applied;
+    this.name = "HostedFilesUnresolvedError";
+  }
+  applied;
+};
+function assertHostedFilesResolved(res, expected, where) {
+  if (expected === 0) return;
+  const target = where.label ?? "the target";
+  const done = res.applied ? "The import has already been applied" : "This preview wrote nothing";
+  if (res.hostedFiles === void 0) {
+    throw new HostedFilesUnresolvedError(
+      `${target} did not report \`hosted_files\` for an archive carrying ${expected} hostedFile() reference${expected === 1 ? "" : "s"}, so it cannot be shown that any of them point at a file there. This instance does not support hostedFile() yet. ${done}${res.applied ? "; redeploy once the instance is updated, or remove the hostedFile() references" : ""}.`,
+      res.applied
+    );
+  }
+  if (res.hostedFiles.resolved < expected || res.hostedFiles.unresolved > 0) {
+    throw new HostedFilesUnresolvedError(
+      `${target} resolved ${res.hostedFiles.resolved} of the ${expected} hostedFile() references in this archive (${res.hostedFiles.unresolved} unresolved), so a field would point at nothing. ${done}.`,
+      res.applied
+    );
+  }
+}
+function decodeRefusal(status, raw, baseUrl, label) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(parsed)) return void 0;
+  const payload = isRecord(parsed.payload) ? parsed.payload : {};
+  const code = optionalString(payload.reason);
+  if (code === void 0) return void 0;
+  const reason = optionalString(parsed.message) ?? code;
+  let conflicts = [];
+  let canonicals = [];
+  let undecoded;
+  const ctx = { raw, target: label ?? "the target", verb: "deploy", answer: "refusal" };
+  try {
+    conflicts = Array.isArray(payload.conflicts) ? payload.conflicts.map((e, i) => decodeConflict(e, i, ctx)) : [];
+    canonicals = Array.isArray(payload.canonicals) ? payload.canonicals.map((e, i) => decodeCanonical(e, i, ctx)) : [];
+  } catch (err) {
+    conflicts = [];
+    canonicals = [];
+    undecoded = err instanceof Error ? err.message : String(err);
+  }
+  const detail = undecoded === void 0 ? "" : `
+The refusal's detail could not be decoded, so it is not listed below:
+${undecoded}`;
+  return new XanoSdkImportRefusal(
+    status,
+    code,
+    reason,
+    conflicts,
+    canonicals,
+    raw,
+    `The instance refused this import (${status} ${code}): ${reason}
+  instance: ${baseUrl}
+The route computes every conflict BEFORE it writes, so nothing was applied.${detail}`
+  );
+}
+async function post(auth, url, opts, action) {
+  const fetchFn = opts.fetchFn ?? fetch;
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const writes = !opts.dryRun;
+  const attempts = writes ? 1 : READ_ATTEMPTS;
+  let res;
+  let failure;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    try {
+      const send = () => fetchFn(url, {
+        method: "POST",
+        headers: { accept: "application/json", Authorization: `Bearer ${auth.access_token}` },
+        body: body(opts.archive),
+        signal: AbortSignal.timeout(IMPORT_TIMEOUT_MS)
+      });
+      res = writes ? await describeWrite(
+        {
+          ...opts.label === void 0 ? {} : { what: `the ${opts.mode === "merge" ? "merge" : "import"} into ${opts.label}` },
+          ...opts.stateCheck === void 0 ? {} : { check: opts.stateCheck }
+        },
+        send
+      ) : await send();
+      await noteMetaAnswer(url, res);
+      noteRateLimit(res);
+      break;
+    } catch (err) {
+      failure = err;
+      if (isTimeoutError(err) || attempt === attempts - 1) break;
+      await sleep(READ_BACKOFF_MS * 2 ** attempt);
+    }
+  }
+  const target = opts.label ?? "the target";
+  const aftermath = !writes ? `A dry run writes nothing, so ${target} is untouched. Retry when the instance is reachable.` : opts.mode === "replace" ? `The request did not complete, so the import may or may not have landed, in whole or in part. A replace rewrites all of ${target}, so it is safe to run again once the instance is reachable.` : `The request did not complete, so the import may or may not have landed, in whole or in part.` + (opts.stateCheck !== void 0 ? ` ${opts.stateCheck}` : "");
+  const where = `${transportTarget(url)}${opts.label !== void 0 ? ` (${opts.label})` : ""}`;
+  if (res === void 0) {
+    const { classifyFailure } = await import("./operation-outcome-TZSESNC7.js");
+    if (writes && !isTimeoutError(failure) && classifyFailure(failure, { writeSent: true }) === "no") {
+      const untrusted = certificateFailureCode(failure) !== void 0;
+      throw new ImportNotSentError(
+        `${closeSentence(`${action} could not reach ${where}: ${describeTransportFailure(failure)}`)}
+Nothing was sent, so ${target} is untouched${untrusted ? "." : " \u2014 retry once the instance is reachable."}`,
+        false,
+        { cause: failure }
+      );
+    }
+    const head = `${action} could not reach ${where}: ${describeTransportFailure(failure)}`;
+    throw new TransportError(`${closeSentence(writes ? lostAnswerHead(head, failure) : head)}
+${aftermath}`, isTimeoutError(failure), {
+      cause: failure
+    });
+  }
+  let text;
+  try {
+    text = await res.text();
+  } catch (err) {
+    const lost = explainBodyFailure(err, { url, what: action, timeoutMs: IMPORT_TIMEOUT_MS, aftermath, display: where });
+    throw lost;
+  }
+  if (!res.ok) {
+    const refusal = decodeRefusal(res.status, text, opts.baseUrl, opts.label);
+    if (refusal !== void 0) throw refusal;
+    throw new ImportHttpError(
+      res.status,
+      action,
+      res.statusText,
+      text,
+      writes ? writeStatusAftermath(res.status, aftermath, { atomic: opts.mode === void 0 || opts.mode === "replace" }) : void 0
+    );
+  }
+  return text;
+}
+function assertXanoSdkBranchHonored(res, requested, baseUrl) {
+  if (res.branch === requested) return;
+  throw new Error(
+    `Refusing to deploy to branch "${requested}": the instance planned against "${res.branch}".
+  instance: ${baseUrl}
+A deploy that looked staged would have written to a different branch, which is not recoverable \u2014 so it is not attempted against an instance that has not confirmed the target.`
+  );
+}
+var DEFAULT_BRANCH_ID = 0;
+function withDefaultBranchPointer(archive) {
+  const entries = readArchiveEntries(archive);
+  const raw = entries["workspace.json"];
+  if (raw === void 0) return archive;
+  const envelope = JSON.parse(raw.toString("utf8"));
+  const payload = envelope.payload;
+  const workspace = payload?.workspace;
+  if (payload === void 0 || workspace === void 0) return archive;
+  const branch = workspace.branch;
+  if (branch?.id === DEFAULT_BRANCH_ID) return archive;
+  const held = signatureHolds(raw.toString("utf8"));
+  const { sig: stored, ...unsigned } = envelope;
+  const pinned = {
+    ...unsigned,
+    payload: { ...payload, workspace: { ...workspace, branch: { id: DEFAULT_BRANCH_ID } } }
+  };
+  const signed = held === void 0 ? pinned : { ...pinned, sig: held ? calcSignatureJson(pinned) : stored };
+  const files = [{ name: "workspace.json", data: Buffer.from(JSON.stringify(signed), "utf8") }];
+  for (const [name, data] of Object.entries(entries)) {
+    if (name !== "workspace.json") files.push({ name, data });
+  }
+  return tarGz(files);
+}
+async function xanosdkImport(auth, opts) {
+  const action = opts.dryRun ? "The deploy preview" : "The deploy";
+  const replaces = opts.mode === void 0 || opts.mode === "replace";
+  const sent = replaces ? { ...opts, archive: withDefaultBranchPointer(opts.archive) } : opts;
+  assertHostedFilesCarried(sent.archive, { label: opts.label });
+  const text = await post(auth, endpoint(sent, query(sent)), sent, action);
+  const decoded = decodeResponse(text, opts.dryRun, { action, baseUrl: opts.baseUrl, label: opts.label });
+  if (opts.branch !== void 0) assertXanoSdkBranchHonored(decoded, opts.branch, opts.baseUrl);
+  assertHostedFilesResolved(decoded, hostedReferencesIn(opts.archive), { label: opts.label });
+  return decoded;
+}
+
+export {
+  XANOSDK_IMPORT_CONFLICT_CODE,
+  XANOSDK_IMPORT_IN_PROGRESS_CODE,
+  XANOSDK_IMPORT_UNIQUENESS_CODE,
+  XANOSDK_IMPORT_UNRESOLVED_FILE_CODE,
+  ImportNotSentError,
+  XanoSdkImportRefusal,
+  resetXanoSdkImportDetection,
+  detectXanoSdkImportRoute,
+  hostedReferencesOf,
+  hostedReferencesIn,
+  HostedFilesUnresolvedError,
+  assertXanoSdkBranchHonored,
+  withDefaultBranchPointer,
+  xanosdkImport
+};
+//# sourceMappingURL=chunk-WQFNASK4.js.map