@xano/sdk 1.0.0

package/dist/chunk-6NNTNXN7.js

@@ -0,0 +1,157 @@
+import {
+  backendDirIn
+} from "./chunk-5A2PLKZB.js";
+import {
+  shellWord
+} from "./chunk-FWD7AL6N.js";
+import {
+  isHomeRelative
+} from "./chunk-EUUUMY7J.js";
+import {
+  pointerRootFor
+} from "./chunk-5FBYXK5P.js";
+import {
+  UsageError,
+  setTypedCwd
+} from "./chunk-PTHVMXZI.js";
+
+// src/emit/xanosdk-project.ts
+import { existsSync, realpathSync, statSync } from "fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "path";
+function isProjectDir(cwd) {
+  return existsSync(join(backendDirIn(cwd), "index.ts")) || existsSync(join(cwd, ".xano"));
+}
+function projectDirFrom(start) {
+  const root = pointerRootFor(start);
+  let dir = resolve(start);
+  for (; ; ) {
+    if (isProjectDir(dir)) return dir;
+    const parent = dirname(dir);
+    if (dir === root || parent === dir) return void 0;
+    dir = parent;
+  }
+}
+var RELATIVE_PATH_ARGS = ["out", "lockPath", "entryPath", "static", "bundle", "envFile", "secretsFile", "backendDir", "emit", "path"];
+var PATH_VARS = ["XANO_CONFIG", "XANO_GLOBAL_CONFIG", "XANO_CLIENT_FILE", "XANOSDK_UPDATE_CACHE", "XANOSDK_PROVE_DIFF", "XANOSDK_LOCAL_ENGINE_HOME", "XANOSDK_LOCAL_ENGINE_OVERRIDE"];
+function enterProjectRoot(args, cwd = process.cwd(), positional) {
+  const here = resolve(cwd);
+  const at = positional === "verb-path" ? 1 : 0;
+  const first = positional === void 0 ? void 0 : at === 1 ? args.positionals?.[1] : args.positionals?.[0] ?? args.file;
+  const typedEntry = positional === "entry" && first !== void 0 && first !== "-" && args.bundlePositional !== true ? first : args.entryPath;
+  const cwdRoot = projectDirFrom(here);
+  if (cwdRoot !== void 0 && typedEntry !== void 0) {
+    const owner = entryOwner(resolve(here, typedEntry), cwdRoot);
+    if (owner !== void 0 && owner !== cwdRoot) throw foreignEntryRefusal(args, here, cwdRoot, owner, typedEntry, first);
+  }
+  const root = cwdRoot ?? (typedEntry !== void 0 ? projectDirFrom(dirname(resolve(here, typedEntry))) : void 0);
+  if (root === void 0 || root === here) return void 0;
+  const fromRoot = (p) => {
+    if (p === void 0 || p === "-" || isAbsolute(p)) return p;
+    if (!existsSync(resolve(here, p)) && existsSync(resolve(root, p))) return p;
+    return relative(root, resolve(here, p)) || ".";
+  };
+  const next = { ...args };
+  for (const key of RELATIVE_PATH_ARGS) next[key] = fromRoot(args[key]);
+  if (first !== void 0 && (at === 0 || existsSync(resolve(here, first)))) {
+    const moved = fromRoot(first);
+    if (at === 0 && args.file === first) next.file = moved;
+    if (args.positionals !== void 0 && args.positionals.length > at) {
+      next.positionals = args.positionals.map((p, n) => n === at ? moved : p);
+    }
+  }
+  if (args.authFile !== void 0) next.authFile = resolve(here, args.authFile);
+  const engine = args.localEngineUrl;
+  if (engine !== void 0 && isRelativePath(engine)) next.localEngineUrl = fromRoot(engine);
+  const saved = PATH_VARS.map((name) => [name, process.env[name]]);
+  for (const [name, value] of saved) {
+    if (value !== void 0 && !isHomeRelative(value) && isRelativePath(value)) process.env[name] = resolve(here, value);
+  }
+  setTypedCwd(here);
+  process.chdir(root);
+  return {
+    args: next,
+    root,
+    restore: () => {
+      process.chdir(here);
+      setTypedCwd(void 0);
+      for (const [name, value] of saved) {
+        if (value === void 0) delete process.env[name];
+        else process.env[name] = value;
+      }
+    }
+  };
+}
+function ownsEntries(dir) {
+  return existsSync(join(backendDirIn(dir), "index.ts"));
+}
+function entryOwner(entry, cwdRoot) {
+  const root = realDir(cwdRoot);
+  let dir = realDir(isDirectory(entry) ? entry : dirname(entry));
+  const bound = realDir(pointerRootFor(dir));
+  for (; ; ) {
+    if (dir === root) return cwdRoot;
+    if (ownsEntries(dir)) return dir;
+    const parent = dirname(dir);
+    if (dir === bound || parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function realDir(dir) {
+  try {
+    return realpathSync(dir);
+  } catch {
+    const parent = dirname(dir);
+    return parent === dir ? dir : join(realDir(parent), basename(dir));
+  }
+}
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function foreignEntryRefusal(args, here, cwdRoot, owner, typedEntry, first) {
+  const shown = (dir) => {
+    const rel = relative(here, dir).split(sep).join("/") || ".";
+    return rel.split("/").filter((part) => part === "..").length > 2 ? dir : rel;
+  };
+  const rerunFrom = (dir) => {
+    const rebased = /* @__PURE__ */ new Map();
+    for (const value of [typedEntry, first, ...RELATIVE_PATH_ARGS.map((key) => args[key])]) {
+      if (value === void 0 || value === "-" || isAbsolute(value)) continue;
+      rebased.set(value, relative(dir, resolve(here, value)).split(sep).join("/") || ".");
+    }
+    const words = (args.argv ?? []).map((token) => {
+      const whole = rebased.get(token);
+      if (whole !== void 0) return whole;
+      const eq = token.indexOf("=");
+      if (token.startsWith("-") && eq !== -1) {
+        const value = rebased.get(token.slice(eq + 1));
+        if (value !== void 0) return `${token.slice(0, eq + 1)}${value}`;
+      }
+      return token;
+    });
+    return `cd ${shellWord(shown(dir))} && xanosdk ${words.map(shellWord).join(" ")}`;
+  };
+  let outside = dirname(cwdRoot);
+  while (outside !== void 0 && projectDirFrom(outside) !== void 0) {
+    const parent = dirname(outside);
+    outside = parent === outside ? void 0 : parent;
+  }
+  const ways = `Run it in that project: \`${rerunFrom(owner)}\`` + (outside === void 0 || args.argv === void 0 ? "." : `, or from a directory outside both: \`${rerunFrom(outside)}\`.`);
+  return new UsageError(
+    `${typedEntry} belongs to the project at ${owner}, not the one this command runs in (${cwdRoot}). A run uses one project for its credential, tracked backend, lock and landing record, so nothing was run. ${ways}`
+  );
+}
+function isRelativePath(value) {
+  return value !== "" && !isAbsolute(value) && !/^[a-z][a-z0-9+.-]*:\/\//i.test(value) && !/^v?\d+\.\d+\.\d+$/.test(value);
+}
+
+export {
+  isProjectDir,
+  projectDirFrom,
+  RELATIVE_PATH_ARGS,
+  enterProjectRoot
+};
+//# sourceMappingURL=chunk-6NNTNXN7.js.map

package/dist/chunk-6PBR37LN.js

@@ -0,0 +1,97 @@
+import {
+  SENT_AFTERMATH,
+  TransportError,
+  certificateFailureCode,
+  closeSentence,
+  lostAnswerHead,
+  markupSummary,
+  notJsonError,
+  parseJsonAnswer,
+  unexpectedAnswerError
+} from "./chunk-YLDALTWZ.js";
+
+// src/deploy/answer-shape.ts
+function isRecord(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function hasString(row, key) {
+  return typeof row[key] === "string" && row[key] !== "";
+}
+function refusalOpts(opts) {
+  return {
+    ...opts.safe === true ? { safe: true } : {},
+    ...opts.write === true ? { aftermath: SENT_AFTERMATH } : {}
+  };
+}
+function notTheAnswer(action, text, url, opts = {}) {
+  let parsed = true;
+  try {
+    JSON.parse(text);
+  } catch {
+    parsed = false;
+  }
+  return parsed || text.trim() === "" ? unexpectedAnswerError(action, text, url, refusalOpts(opts)) : notJsonError(action, text, url, refusalOpts(opts));
+}
+function parseAnswer(text, action, url, opts = {}) {
+  if (text.trim() === "") throw notTheAnswer(action, text, url, opts);
+  return parseJsonAnswer(text, action, url, refusalOpts(opts));
+}
+function recordAnswer(text, action, url, isAnswer, opts = {}) {
+  const data = parseAnswer(text, action, url, opts);
+  if (!isRecord(data) || !isAnswer(data)) throw notTheAnswer(action, text, url, opts);
+  return data;
+}
+function listAnswer(text, action, url, isRow, opts = {}) {
+  const data = parseAnswer(text, action, url, opts);
+  const envelope = isRecord(data) ? data : void 0;
+  const rows = Array.isArray(data) ? data : Array.isArray(envelope?.items) ? envelope.items : void 0;
+  if (rows === void 0 || !rows.every((r) => isRecord(r) && isRow(r))) throw notTheAnswer(action, text, url, opts);
+  return { rows, envelope };
+}
+function deleteAnswer(text, action, url, opts = {}) {
+  if (text.trim() === "null") return;
+  throw notTheAnswer(action, text, url, { ...opts, write: true });
+}
+function multidocAnswer(text, action, url) {
+  const refuse = () => notTheAnswer(action, text, url);
+  if (text.trim() === "" || markupSummary(text) !== void 0) throw refuse();
+  let isJson = true;
+  try {
+    JSON.parse(text);
+  } catch {
+    isJson = false;
+  }
+  if (isJson) throw unexpectedAnswerError(action, text, url);
+  const first = text.split("\n").map((l) => l.trim()).find((l) => l !== "" && !l.startsWith("//"));
+  if (first === void 0 || !/^[a-z][a-z_]*\s[^{]*\{/.test(first)) throw refuse();
+  return text;
+}
+var NOT_SENT = /* @__PURE__ */ new Set(["ECONNREFUSED", "ENOTFOUND", "EAI_AGAIN", "ENETUNREACH", "EHOSTUNREACH"]);
+function writeTransportFailure(err) {
+  if (!(err instanceof TransportError)) return err;
+  if (certificateFailureCode(err) !== void 0) return err;
+  if (/may or may not have taken effect|Nothing was (sent|changed)/.test(err.message)) {
+    if (!/Nothing was changed/.test(err.message)) return err;
+  }
+  const first = err.message.split("\n")[0];
+  const inner = err.cause?.cause;
+  const code = inner?.code;
+  const notSent = typeof code === "string" && NOT_SENT.has(code) || inner?.message === "bad port";
+  const head = closeSentence(notSent ? first : lostAnswerHead(first, err.cause));
+  const aftermath = notSent ? "Nothing was sent \u2014 retry." : SENT_AFTERMATH;
+  return new TransportError(`${head}
+${aftermath}`, err.timeout, { cause: err.cause });
+}
+
+export {
+  isRecord,
+  hasString,
+  notTheAnswer,
+  parseAnswer,
+  recordAnswer,
+  listAnswer,
+  deleteAnswer,
+  multidocAnswer,
+  writeTransportFailure
+};
+//# sourceMappingURL=chunk-6PBR37LN.js.map

package/dist/chunk-6QXLMMT3.js

@@ -0,0 +1,155 @@
+import {
+  NPM_RUN_TIMEOUT_MS,
+  isPeerConflict,
+  runNpmQuiet
+} from "./chunk-ZFDZKNGG.js";
+import {
+  shellWord
+} from "./chunk-FWD7AL6N.js";
+import {
+  isLocalSpecifier
+} from "./chunk-2GNFDZA2.js";
+import {
+  trackLocalWrite
+} from "./chunk-4KHEMC32.js";
+import {
+  addArgs,
+  installSite,
+  npmLockListsMember,
+  removeArgs,
+  yarnPlugAndPlayRoot
+} from "./chunk-WRBKLYSJ.js";
+import {
+  localPackageName,
+  localPathOf,
+  packageNameOf,
+  readInstalledManifestState
+} from "./chunk-3LDULPRE.js";
+import {
+  UsageError
+} from "./chunk-PTHVMXZI.js";
+
+// src/emit/project-dependency.ts
+import { existsSync, readFileSync } from "fs";
+import { isAbsolute, join, relative, resolve, sep } from "path";
+
+// src/emit/npm-install.ts
+async function installWithPeerRetry(specifier, cwd, opts = {}) {
+  const scope = opts.scope ?? [];
+  if (opts.manager !== void 0 && opts.manager !== "npm") {
+    const only = await runNpmQuiet([...addArgs(opts.manager, specifier), ...scope], cwd, { manager: opts.manager, ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {} });
+    return { ...only, peerConflict: null, retried: false };
+  }
+  const budget = opts.timeoutMs ?? NPM_RUN_TIMEOUT_MS;
+  const deadline = Date.now() + budget;
+  const first = await runNpmQuiet(["install", specifier, ...scope], cwd, { timeoutMs: budget });
+  if (first.status === 0 || !isPeerConflict(first.output)) {
+    return { ...first, peerConflict: null, retried: false };
+  }
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) return { ...first, peerConflict: first.output, retried: false };
+  opts.onRetry?.();
+  const second = await runNpmQuiet(["install", specifier, ...scope, "--legacy-peer-deps"], cwd, {
+    timeoutMs: remaining
+  });
+  return { ...second, peerConflict: first.output, retried: true };
+}
+
+// src/emit/project-dependency.ts
+function interruptedCheck(name, site, rerun) {
+  const ls = site.manager === "npm" ? ` (\`npm ls ${name}\`)` : "";
+  return `Check whether package.json lists ${name}${ls}, then re-run ${rerun === void 0 ? "the command" : `\`${rerun}\``} \u2014 it picks up what landed.`;
+}
+function refusePlugAndPlay(dir, rerun) {
+  const root = yarnPlugAndPlayRoot(dir);
+  if (root === void 0) return;
+  const rel = relative(process.cwd(), root).split(sep).join("/");
+  const rc = rel === "" ? ".yarnrc.yml" : `${rel}/.yarnrc.yml`;
+  const install = rel === "" ? "yarn install" : `(cd ${shellWord(rel)} && yarn install)`;
+  throw new UsageError(
+    `This project installs with Yarn Plug'n'Play, which Xano SDK does not support: the CLI, its modules and the scaffold's build read packages from node_modules. Add \`nodeLinker: node-modules\` to ${shellWord(rc)}, run \`${install}\`, then re-run \`${rerun}\`.`
+  );
+}
+function dependenciesOf(dir) {
+  const deps = /* @__PURE__ */ new Map();
+  try {
+    const manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+    for (const block of ["dependencies", "devDependencies", "optionalDependencies"]) {
+      for (const [name, range] of Object.entries(manifest[block] ?? {})) {
+        if (typeof range === "string") deps.set(name, range);
+      }
+    }
+  } catch {
+  }
+  return deps;
+}
+async function prepareInstallSite(dir, onLink) {
+  const site = installSite(dir);
+  const member = site.scope[0] === "-w" ? site.scope[1] : void 0;
+  if (member === void 0 || npmLockListsMember(site.cwd, member)) return { site, link: null };
+  onLink?.(member);
+  const link = await runNpmQuiet(["install", ...site.scope], site.cwd);
+  return {
+    site,
+    link: link.status === 0 ? link : { ...link, output: `Linking ${member} into the npm workspace at ${site.cwd} failed:
+${link.output}` }
+  };
+}
+async function addDependency(dir, specifier, opts = {}) {
+  const name = localPackageName(specifier, dir) ?? (isLocalSpecifier(specifier) ? specifier : packageNameOf(specifier));
+  const check = interruptedCheck(name, installSite(dir), opts.rerun);
+  return trackLocalWrite({ what: `the install of ${name}`, check }, async () => {
+    const { site, link } = await prepareInstallSite(dir, opts.onLink);
+    const installSpec = site.cwd === resolve(dir) ? specifier : rebaseSpec(specifier, dir, site.cwd);
+    if (link !== null && link.status !== 0) return { ...link, peerConflict: null, retried: false, site, installSpec };
+    const before = dependenciesOf(dir);
+    const result = await installWithPeerRetry(installSpec, site.cwd, {
+      ...opts.onRetry === void 0 ? {} : { onRetry: opts.onRetry },
+      scope: site.scope,
+      ...site.manager !== "npm" ? { manager: site.manager } : {}
+    });
+    if (result.status !== 0) return { ...result, site, installSpec };
+    const recorded = recordedDependency(dir, specifier, before);
+    const landed = recorded !== void 0 && readInstalledManifestState(dir, recorded).kind !== "absent" ? recorded : void 0;
+    return { ...result, site, installSpec, ...recorded === void 0 ? {} : { recorded }, ...landed === void 0 ? {} : { landed } };
+  });
+}
+async function removeDependency(dir, pkg, rerun) {
+  return trackLocalWrite({ what: `the removal of ${pkg}`, check: interruptedCheck(pkg, installSite(dir), rerun) }, async () => {
+    const { site, link } = await prepareInstallSite(dir);
+    if (link !== null && link.status !== 0) return { ...link, site, stillListed: true };
+    const args = [...removeArgs(site.manager, pkg), ...site.scope];
+    const result = await (site.manager === "npm" ? runNpmQuiet(args, site.cwd) : runNpmQuiet(args, site.cwd, { manager: site.manager }));
+    return { ...result, site, stillListed: result.status === 0 && dependenciesOf(dir).has(pkg) };
+  });
+}
+function recordedDependency(dir, specifier, before) {
+  const after = dependenciesOf(dir);
+  const known = localPackageName(specifier, dir) ?? (isLocalSpecifier(specifier) ? void 0 : packageNameOf(specifier));
+  const name = known ?? (() => {
+    const changed = [...after].filter(([n, range]) => before.get(n) !== range).map(([n]) => n);
+    if (changed.length === 1) return changed[0];
+    const same = [...after].filter(([, range]) => range === specifier).map(([n]) => n);
+    return same.length === 1 ? same[0] : void 0;
+  })();
+  return name !== void 0 && after.has(name) ? name : void 0;
+}
+function rebaseSpec(spec, from, to) {
+  const path = localPathOf(spec);
+  if (path === void 0 || isAbsolute(path)) return spec;
+  const abs = resolve(from, path);
+  if (!existsSync(abs)) return spec;
+  const rel = relative(resolve(to), abs).split(sep).join("/");
+  const rebased = rel.startsWith("..") ? rel : `./${rel}`;
+  return spec.startsWith("file:") ? `file:${rebased}` : rebased;
+}
+
+export {
+  refusePlugAndPlay,
+  dependenciesOf,
+  prepareInstallSite,
+  addDependency,
+  removeDependency,
+  recordedDependency
+};
+//# sourceMappingURL=chunk-6QXLMMT3.js.map

package/dist/chunk-6ZGJCBZS.js

@@ -0,0 +1,224 @@
+import {
+  assertNoFlagCollisions,
+  flagFor,
+  hostHelpTarget,
+  hostLabel,
+  questionSets,
+  resolvePluginAnswers
+} from "./chunk-H5C7MBCR.js";
+import {
+  gitattributesSpec
+} from "./chunk-DGWHAVRG.js";
+import {
+  UsageError,
+  warn
+} from "./chunk-PTHVMXZI.js";
+import {
+  withArticle
+} from "./chunk-36JUQZVQ.js";
+
+// src/emit/plugin-contributions.ts
+function assertContractShape(pkg, plugin, host) {
+  const shape = plugin;
+  if (typeof shape["files"] === "function" && shape["contributes"] === void 0) {
+    throw new UsageError(
+      `${pkg} declares a \`files\` hook and no \`contributes\`, so it was built against a \`@xano/sdk/plugin\` contract that no longer exists \u2014 \`${hostLabel(host)}\` would register it and apply nothing.`,
+      {
+        helpFor: hostHelpTarget(host),
+        suggestion: `That is the module's upgrade to make: rename \`files(answers)\` to \`contributes(answers)\`, which returns a \`ProjectContributions\`. Until it ships, remove ${pkg} or set \`"${pkg}": { "enabled": false }\` in this project's package.json "xanosdk" block.`
+      }
+    );
+  }
+}
+function assertUsableContributions(pkg, parts, host) {
+  if (parts["ciSteps"] !== void 0) {
+    throw new UsageError(
+      `${pkg} contributes \`ciSteps\`, a slot \`@xano/sdk\` no longer has, so \`${hostLabel(host)}\` would drop its CI step in silence.`,
+      {
+        helpFor: hostHelpTarget(host),
+        suggestion: `That is the module's upgrade to make: drop the \`ciSteps\` entry. A module's own check already runs under \`xanosdk export --frozen-lock\`, which fires \`onBundle\` with \`frozen\` set, so it needs no workflow step of its own.`
+      }
+    );
+  }
+  const config = parts.config;
+  if (config !== void 0 && (typeof config !== "object" || config === null || Array.isArray(config))) {
+    throw new UsageError(
+      `${pkg} contributes a \`config\` that is ${describeValue(config)} where that module's settings object is expected, so \`${hostLabel(host)}\` would write a "xanosdk" block every later run refuses to read.`,
+      {
+        helpFor: hostHelpTarget(host),
+        suggestion: `That is the module's bug to fix: return a plain object from the \`config\` slot, or omit the slot entirely.`
+      }
+    );
+  }
+  const { dialect } = gitattributesSpec(pkg);
+  const markers = [dialect.begin("").trim(), dialect.end("").trim()];
+  for (const entry of parts.gitattributes ?? []) {
+    for (const line of entry.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      const pattern = trimmed.split(/\s+/)[0] ?? "";
+      if (markers.some((marker) => trimmed.startsWith(marker))) {
+        throw new UsageError(
+          `${pkg} contributes a \`.gitattributes\` line that spells a xanosdk block marker (\`${trimmed}\`), which would leave the file with markers no run can balance.`,
+          {
+            helpFor: hostHelpTarget(host),
+            suggestion: `The markers are the SDK's: it writes them around whatever a module contributes. Contribute the rules alone.`
+          }
+        );
+      }
+      if (pattern === "*") {
+        throw new UsageError(
+          `${pkg} contributes a \`.gitattributes\` rule for \`*\`, which would override the line-ending rule every generated artifact is compared against.`,
+          {
+            helpFor: hostHelpTarget(host),
+            suggestion: `A module may only add rules for paths it owns.`
+          }
+        );
+      }
+      if (/\b(text|eol)\s*=/.test(line) || /\s-text\b/.test(line)) {
+        throw new UsageError(
+          `${pkg} contributes a \`.gitattributes\` rule that sets \`text\`/\`eol\` (\`${trimmed}\`). Line endings are the template's to set: a frozen check compares bytes, and a rule that reintroduces CRLF fails every run on a Windows checkout.`,
+          {
+            helpFor: hostHelpTarget(host),
+            suggestion: `Contribute display rules (\`linguist-*\`, \`diff\`) instead.`
+          }
+        );
+      }
+    }
+  }
+}
+function describeValue(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  return withArticle(typeof value);
+}
+function priorAnswers(loaded, host) {
+  const out = {};
+  for (const p of loaded) {
+    assertContractShape(p.pkg, p.plugin, host);
+    if (p.plugin.answersFromConfig === void 0) continue;
+    if (Object.keys(p.config).length === 0) continue;
+    const ids = new Set((p.plugin.questions ?? []).map((q) => q.id));
+    let read;
+    try {
+      read = p.plugin.answersFromConfig(
+        p.config
+      ) ?? {};
+    } catch (error) {
+      warn(
+        `${p.pkg} could not read its stored settings back; its defaults were used instead.`,
+        "module.settings-unreadable",
+        [error instanceof Error ? error.message : String(error)]
+      );
+      continue;
+    }
+    const kept = {};
+    for (const [id, value] of Object.entries(read)) {
+      if (!ids.has(id)) continue;
+      if (typeof value === "string" || typeof value === "boolean")
+        kept[id] = value;
+    }
+    if (Object.keys(kept).length > 0) out[p.pkg] = kept;
+  }
+  return out;
+}
+async function runPluginQuestionnaire(loaded, opts) {
+  const sets = questionSets(loaded);
+  assertNoFlagCollisions(sets, opts.host);
+  const prior = priorAnswers(loaded, opts.host);
+  const resolved = await resolvePluginAnswers(sets, {
+    host: opts.host,
+    unknownFlags: opts.unknownFlags,
+    prompter: opts.prompter,
+    prior
+  });
+  const answers = {};
+  const sources = {};
+  const flags = {};
+  const questionsFor = new Map(sets.map((s) => [s.pkg, s.questions]));
+  for (const [pkg, r] of Object.entries(resolved)) {
+    answers[pkg] = r.answers;
+    sources[pkg] = r.sources;
+    flags[pkg] = Object.fromEntries(
+      (questionsFor.get(pkg) ?? []).filter((q) => r.answers[q.id] !== void 0).map((q) => [q.id, flagFor(q)])
+    );
+    for (const gone of r.dropped) {
+      warn(
+        gone.why === "excluded" ? `${pkg}: \`${gone.id}\` is no longer asked, so its stored setting was dropped.` : `${pkg}: the stored setting for \`${gone.id}\` is no longer a value that question accepts, so the module's default was used.`,
+        "module.setting-dropped"
+      );
+    }
+  }
+  return { answers, sources, flags, prior };
+}
+function recordedConfig(outcome, stored) {
+  if (outcome.status === "failed") return void 0;
+  if (outcome.status === "none") return stored === void 0 ? {} : void 0;
+  const parts = outcome.parts ?? {};
+  if (parts.config !== void 0) return parts.config;
+  if ((parts.gitattributes ?? []).length > 0) return stored === void 0 ? {} : void 0;
+  return { enabled: false };
+}
+function assertContributionsShape(pkg, returned, host) {
+  if (returned === void 0 || returned === null) return {};
+  const thenable = typeof returned.then === "function";
+  if (typeof returned !== "object" || Array.isArray(returned) || thenable) {
+    throw new UsageError(
+      `${pkg}'s \`contributes\` returned ${thenable ? "a Promise" : describeValue(returned)} where a \`ProjectContributions\` object is expected, so \`${hostLabel(host)}\` would read it as a module that contributes nothing and record it as switched off.`,
+      {
+        helpFor: hostHelpTarget(host),
+        suggestion: `That is the module's bug to fix: return an object (\`{ gitattributes, config }\`), or nothing at all. \`contributes\` is synchronous \u2014 an \`async\` one returns a Promise, which is this same refusal.`
+      }
+    );
+  }
+  return returned;
+}
+function contributionOutcomes(loaded, answers, host) {
+  const out = [];
+  for (const p of loaded) {
+    assertContractShape(p.pkg, p.plugin, host);
+    if (p.plugin.contributes === void 0) {
+      out.push({ pkg: p.pkg, version: p.version, status: "none" });
+      continue;
+    }
+    try {
+      const parts = assertContributionsShape(
+        p.pkg,
+        p.plugin.contributes(answers[p.pkg] ?? {}),
+        host
+      );
+      assertUsableContributions(p.pkg, parts, host);
+      if (parts.config !== void 0) JSON.stringify(parts.config);
+      out.push({
+        pkg: p.pkg,
+        version: p.version,
+        status: "contributed",
+        parts
+      });
+    } catch (error) {
+      if (error instanceof UsageError) throw error;
+      warn(
+        `${p.pkg} could not describe what it contributes and was skipped.`,
+        "module.describe-failed",
+        [error instanceof Error ? error.message : String(error)]
+      );
+      out.push({ pkg: p.pkg, version: p.version, status: "failed" });
+    }
+  }
+  return out;
+}
+function resolveContributions(loaded, answers, host) {
+  return contributionOutcomes(loaded, answers, host).flatMap(
+    (o) => o.status === "contributed" ? [{ pkg: o.pkg, version: o.version, parts: o.parts }] : []
+  );
+}
+
+export {
+  assertContractShape,
+  assertUsableContributions,
+  priorAnswers,
+  runPluginQuestionnaire,
+  recordedConfig,
+  contributionOutcomes,
+  resolveContributions
+};
+//# sourceMappingURL=chunk-6ZGJCBZS.js.map