@xano/sdk 1.0.0

package/dist/chunk-FXRQOWTE.js

@@ -0,0 +1,171 @@
+import {
+  hasString,
+  listAnswer
+} from "./chunk-6PBR37LN.js";
+import {
+  READ_AFTERMATH,
+  explainFetchFailure,
+  httpFailure,
+  readBodyText
+} from "./chunk-YLDALTWZ.js";
+import {
+  detail,
+  info,
+  warn
+} from "./chunk-PTHVMXZI.js";
+
+// src/deploy/microservice-status.ts
+var TIMEOUT_MS = 3e4;
+var MICROSERVICE_READ = "Microservice status read";
+var POLL_INTERVAL_MS = 2e3;
+var WAIT_DEADLINE_MS = 3e5;
+function asString(v) {
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+function asNumber(v) {
+  return typeof v === "number" ? v : void 0;
+}
+function classify(row) {
+  const status = row.status ?? "";
+  if (status === "disabled") return "disabled";
+  if ((row.tenantDeploy ?? "auto") === "manual") return "manual";
+  switch (status) {
+    case "ok": {
+      return "ready";
+    }
+    case "error": {
+      return "failed";
+    }
+    // `pending` is the state a freshly imported row sits in until the engine
+    // picks it up; both it and `deploying` mean "not serving yet, keep looking".
+    case "pending":
+    case "deploying": {
+      return "inFlight";
+    }
+    default: {
+      return "unknown";
+    }
+  }
+}
+function isAwaited(m) {
+  return m.disposition === "inFlight";
+}
+function project(row) {
+  const tenantDeploy = asString(row.tenant_deploy) ?? "auto";
+  const status = asString(row.status) ?? "";
+  return {
+    id: asNumber(row.id),
+    name: asString(row.name) ?? "",
+    kind: asString(row.kind),
+    tenantDeploy,
+    status,
+    statusDetail: asString(row.status_detail),
+    deployedAt: asString(row.deployed_at),
+    disposition: classify({ status, tenantDeploy })
+  };
+}
+var isMicroserviceRow = (row) => hasString(row, "name");
+async function listMicroservices(auth, target, opts = {}) {
+  const fetchFn = opts.fetchFn ?? fetch;
+  const root = `${target.baseUrl.replace(/\/$/, "")}/api:meta/workspace/${target.workspaceId}/microservice`;
+  const out = [];
+  let page = 1;
+  for (; ; ) {
+    const url = `${root}?page=${page}`;
+    let res;
+    try {
+      res = await fetchFn(url, {
+        method: "GET",
+        headers: { accept: "application/json", Authorization: `Bearer ${auth.access_token}` },
+        signal: AbortSignal.timeout(TIMEOUT_MS)
+      });
+    } catch (err) {
+      throw explainFetchFailure(err, { url, what: MICROSERVICE_READ, timeoutMs: TIMEOUT_MS, aftermath: READ_AFTERMATH });
+    }
+    const text = await readBodyText(res, MICROSERVICE_READ, { url, timeoutMs: TIMEOUT_MS });
+    if (!res.ok) {
+      throw new Error(httpFailure(MICROSERVICE_READ, res, text));
+    }
+    const { rows, envelope } = listAnswer(text, MICROSERVICE_READ, url, isMicroserviceRow);
+    out.push(...rows.map((r) => project(r)));
+    const next = envelope?.nextPage;
+    if (typeof next !== "number" || next <= page) return out;
+    page = next;
+  }
+}
+async function waitForMicroservices(auth, target, opts = {}) {
+  const now = opts.now ?? Date.now;
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const totalDeadlineMs = opts.totalDeadlineMs ?? WAIT_DEADLINE_MS;
+  const pollIntervalMs = opts.pollIntervalMs ?? POLL_INTERVAL_MS;
+  const start = now();
+  let microservices = [];
+  let sawAnyRead = false;
+  for (; ; ) {
+    try {
+      microservices = await listMicroservices(auth, target, opts);
+      sawAnyRead = true;
+      opts.onPoll?.(microservices);
+      if (!microservices.some((m) => isAwaited(m))) {
+        return { microservices, timedOut: false, hadFailure: microservices.some((m) => m.disposition === "failed") };
+      }
+    } catch (err) {
+      if (!sawAnyRead) throw err;
+    }
+    if (now() - start + pollIntervalMs > totalDeadlineMs) {
+      return {
+        microservices,
+        timedOut: true,
+        hadFailure: microservices.some((m) => m.disposition === "failed")
+      };
+    }
+    await sleep(pollIntervalMs);
+  }
+}
+
+// src/emit/microservice-view.ts
+async function readMicroservices(auth, baseUrl, workspaceId = 1) {
+  try {
+    return await listMicroservices(auth, { baseUrl, workspaceId });
+  } catch (err) {
+    warn(`Could not read microservices: ${err instanceof Error ? err.message : String(err)}`, "microservice.status-unreadable");
+    return null;
+  }
+}
+var DISPOSITION_LABEL = {
+  ready: { icon: "\u2713", why: "ready" },
+  inFlight: { icon: "\u2026", why: "starting" },
+  failed: { icon: "\u2717", why: "failed" },
+  manual: { icon: "\u2013", why: "not started \u2014 set to deploy manually" },
+  disabled: { icon: "\u2013", why: "disabled" },
+  unknown: { icon: "\u2013", why: "unrecognized state" }
+};
+function microserviceLine(m) {
+  const { icon, why } = DISPOSITION_LABEL[m.disposition];
+  const useDetail = m.disposition !== "manual" && m.disposition !== "disabled";
+  const reason = (useDetail ? m.statusDetail : void 0) ?? why;
+  return `${icon} ${m.name} \u2014 ${m.disposition === "unknown" ? `${why} (${m.status})` : reason}`;
+}
+function readyRatio(microservices) {
+  return {
+    ready: microservices.filter((m) => m.disposition === "ready").length,
+    // Rows the engine was never going to start don't belong in a readiness ratio.
+    startable: microservices.filter((m) => m.disposition !== "manual" && m.disposition !== "disabled").length
+  };
+}
+function printMicroserviceSection(microservices) {
+  if (microservices === null || microservices.length === 0) return;
+  const { ready, startable } = readyRatio(microservices);
+  info(startable === 0 ? "Microservices (none set to start):" : `Microservices (${ready}/${startable} ready):`);
+  for (const m of microservices) detail(microserviceLine(m));
+}
+
+export {
+  isAwaited,
+  waitForMicroservices,
+  readMicroservices,
+  microserviceLine,
+  readyRatio,
+  printMicroserviceSection
+};
+//# sourceMappingURL=chunk-FXRQOWTE.js.map

package/dist/chunk-G554NZNI.js

@@ -0,0 +1,210 @@
+import {
+  encodeInput,
+  f,
+  input
+} from "./chunk-N5GKCWE5.js";
+
+// src/kinds/trigger-inputs.ts
+var ERROR_EVENT_DESCRIPTION = `Which event fired the trigger. "new" fires on first capture and on every snapshot re-capture for non-ignored signatures (rate-limited by the ~5min snapshot dedup window). "regression" fires when a previously-fixed signature re-occurs (the fix didn't hold, or the same bug regressed back). "fixed" fires when a user marks a signature as fixed.`;
+function realtimeClientInput() {
+  return input.object(
+    {
+      extras: f.json(),
+      permissions: f.object({ dbo_id: f.int(), row_id: f.text() }, { required: true })
+    },
+    { required: true }
+  );
+}
+function encodeAll(map) {
+  return Object.entries(map).map(([name, d]) => encodeInput(name, d));
+}
+var CATALOG = {
+  // Database trigger — new/old rows, action op, datasource label.
+  database: () => ({
+    new: input.json(),
+    old: input.json(),
+    action: input.enum(["insert", "update", "delete", "truncate"], { required: true }),
+    // NOTE (Xano quirk, mirror don't fix): the engine stores `datasource`
+    // as `text` but copy-pastes the `action` enum into its `values`. We mirror
+    // the stored shape exactly rather than "correcting" it.
+    datasource: input.text({ required: true, values: ["insert", "update", "delete", "truncate"] })
+  }),
+  // Toolset trigger — the connected toolset + its tools. This is the AGENT
+  // shape; an MCP server's trigger adds `prompts`/`resources`
+  // (`mcpServerPrimitives`).
+  toolset: () => ({
+    toolset: input.object(
+      {
+        id: f.int({ description: "The toolset ID" }),
+        name: f.text({ description: "The toolset name", methods: ["trim"] }),
+        instructions: f.text({ description: "The toolset instructions", methods: ["trim"] })
+      },
+      { description: "The toolset being connected to" }
+    ),
+    tools: input.list(
+      input.object({
+        id: f.int({ description: "The tool ID" }),
+        name: f.text({ description: "The tool name", methods: ["trim"] }),
+        instructions: f.text({ description: "The tool instructions", methods: ["trim"] })
+      }),
+      { description: "The list of tools on the MCP Server" }
+    )
+  }),
+  // Workspace lifecycle trigger — branch action + the branches involved.
+  workspace: () => ({
+    to_branch: input.object({ id: f.int(), label: f.text({ methods: ["trim"] }) }),
+    from_branch: input.object({ id: f.int(), label: f.text({ methods: ["trim"] }) }),
+    action: input.enum(["branch_live", "branch_merge", "branch_new"], { required: true })
+  }),
+  // Realtime channel trigger — message/join action + channel/client/options/payload.
+  workspace_realtime_channel: () => ({
+    action: input.enum(["message", "join"], { required: true, default: "message" }),
+    channel: input.text({ required: true }),
+    client: input.object(
+      {
+        extras: f.json(),
+        permissions: f.object(
+          { dbo_id: f.int(), row_id: f.text() },
+          { required: true }
+        )
+      },
+      { required: true }
+    ),
+    options: input.object({ authenticated: f.bool(), channel: f.text() }),
+    payload: input.json({ required: true, nullable: true })
+  }),
+  // Realtime SERVER lifecycle trigger — connect/disconnect on a realtime server.
+  // Mirrors the engine's stored input array exactly: the action enum carries NO
+  // default (unlike the legacy channel trigger's `"message"`), and `client` is
+  // the same connecting-client object both realtime lifecycle types use.
+  realtime_server: () => ({
+    action: input.enum(["connect", "disconnect"], { required: true }),
+    realtime_server: input.text({ required: true }),
+    client: realtimeClientInput()
+  }),
+  // Realtime CHANNEL lifecycle trigger — join/leave/deliver on a channel. Same
+  // shape as the server type with the addressed channel path in place of the
+  // server name.
+  //
+  // The action enum carries all THREE actions the engine declares for this type,
+  // regardless of which ones a given trigger enables: the enum describes what
+  // `action` can hold at runtime, and the per-trigger selection lives in `meta`.
+  //
+  // `payload` IS declared, and it is what distinguishes this type from the server
+  // one above. It sits between `channel` and `client`, and it is the message body
+  // — optional (a join/leave carries none) and nullable, unlike the LEGACY
+  // channel trigger's required `payload`.
+  //
+  // A sweep of a current instance is unanimous: every channel trigger stores
+  // four entries in this order, and every realtime_server trigger stores three.
+  // Without this entry a pulled channel trigger would regenerate an input
+  // short, so `inp("payload")` would not resolve and re-deploying would drop an
+  // entry the engine supplies.
+  channel: () => ({
+    action: input.enum(["join", "leave", "deliver"], { required: true }),
+    channel: input.text({ required: true }),
+    payload: input.json({ nullable: true }),
+    client: realtimeClientInput()
+  }),
+  // Error trigger — the error signature schema (verbatim from the engine).
+  error: () => ({
+    event: input.enum(["new", "regression", "fixed"], { description: ERROR_EVENT_DESCRIPTION }),
+    id: input.int({
+      description: "The error signature row id. Use to build deep links into the error-logs UI."
+    }),
+    signature: input.text({ description: "Stable hash that identifies this error signature." }),
+    error: input.object(
+      {
+        code: f.text({ description: "Machine-readable error code." }),
+        message: f.text({ description: "Human-readable error message." })
+      },
+      { description: "Error code and message captured from the failing run." }
+    ),
+    caller: input.object(
+      {
+        type: f.text({
+          description: "Caller kind (api, function, task, middleware, trigger, unknown)."
+        }),
+        id: f.int({ description: "Caller object id." }),
+        name: f.text({ description: "Caller object name.", nullable: true })
+      },
+      { description: "Where the error originated. Null on 'fixed' events.", nullable: true }
+    ),
+    statement: input.object(
+      {
+        name: f.text({ description: "Statement name." }),
+        xsid: f.text({ description: "Statement xsid within the function stack." })
+      },
+      { description: "Failing statement. Null on 'fixed' events.", nullable: true }
+    ),
+    actor: input.object(
+      {
+        id: f.int({ description: "User id." }),
+        name: f.text({ description: "User name.", nullable: true })
+      },
+      {
+        description: "User who marked the error as fixed. Populated only for 'fixed' events.",
+        nullable: true
+      }
+    ),
+    count: input.object(
+      {
+        total: f.int({ description: "Total occurrences since first seen." }),
+        last_hour: f.int({ description: "Occurrences in the last hour." })
+      },
+      { description: "Occurrence counts for this signature." }
+    ),
+    first_seen: input.text({ description: "ISO-8601 UTC timestamp of the first occurrence." }),
+    last_seen: input.text({ description: "ISO-8601 UTC timestamp of the most recent occurrence." }),
+    fixed_at: input.text({
+      description: "ISO-8601 UTC timestamp the error was marked fixed. Null otherwise.",
+      nullable: true
+    })
+  })
+};
+function mcpServerPrimitives() {
+  const primitive = (kind, uri) => input.list(
+    input.object({
+      id: f.int({ description: `The ${kind} ID` }),
+      name: f.text({ description: `The ${kind} name`, methods: ["trim"] }),
+      description: f.text({ description: `The ${kind} description`, methods: ["trim"] }),
+      ...uri ? { uri: f.text({ description: "The resource URI or URI template", methods: ["trim"] }) } : {}
+    }),
+    { description: `The list of ${kind}s on the MCP Server` }
+  );
+  return { prompts: primitive("prompt", false), resources: primitive("resource", true) };
+}
+var MCP_TRIGGER_AUTH_DESCRIPTION = "The signed-in user {dbo, id, extras} when the MCP server requires sign-in, else null";
+function mcpServerAuthInput(toolset) {
+  return {
+    ...toolset,
+    name: "auth",
+    type: "json",
+    description: MCP_TRIGGER_AUTH_DESCRIPTION,
+    nullable: true,
+    default: null,
+    children: [],
+    methods: [],
+    style: { type: "single" }
+  };
+}
+function impliedInputs(objType, toolsetType = "mcp") {
+  if (!Object.hasOwn(CATALOG, objType)) {
+    throw new Error(`No implied trigger inputs for obj_type ${JSON.stringify(objType)}.`);
+  }
+  const map = CATALOG[objType]();
+  if (objType !== "toolset" || toolsetType !== "mcp") return encodeAll(map);
+  const inputs = encodeAll({ ...map, ...mcpServerPrimitives() });
+  const toolset = inputs.find((i) => i.name === "toolset");
+  if (!toolset) throw new Error("The toolset trigger implies no `toolset` input to derive `auth` from.");
+  return [...inputs, mcpServerAuthInput(toolset)];
+}
+function isTriggerObjType(value) {
+  return typeof value === "string" && Object.prototype.hasOwnProperty.call(CATALOG, value);
+}
+
+export {
+  impliedInputs,
+  isTriggerObjType
+};
+//# sourceMappingURL=chunk-G554NZNI.js.map

package/dist/chunk-GSGDWJB5.js

@@ -0,0 +1,13 @@
+// src/util/env-name.ts
+function isRepresentableName(name) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
+}
+function safeNames(names) {
+  return names.map((n) => n.replace(/[\u0000-\u001F\u007F]/g, "?")).join(", ");
+}
+
+export {
+  isRepresentableName,
+  safeNames
+};
+//# sourceMappingURL=chunk-GSGDWJB5.js.map

package/dist/chunk-H2V3N23D.js

@@ -0,0 +1,66 @@
+// src/workspace/non-json.ts
+function nonJsonKind(value) {
+  switch (typeof value) {
+    case "function":
+      return "a function";
+    case "symbol":
+      return "a symbol";
+    case "bigint":
+      return `a bigint (${String(value)}n)`;
+    case "object": {
+      if (value === null || Array.isArray(value)) return void 0;
+      const proto = Object.getPrototypeOf(value);
+      if (proto === null || proto === Object.prototype) return void 0;
+      const name = value.constructor?.name;
+      if (typeof name !== "string" || name === "") return "a class instance";
+      return ["Date", "Map", "Set", "RegExp"].includes(name) ? `a ${name}` : `a ${name} instance`;
+    }
+    default:
+      return void 0;
+  }
+}
+function findNonJson(root) {
+  const stack = [[root, ""]];
+  const seen = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const [node, path] = stack.pop();
+    if (nonJsonKind(node) !== void 0) return { path, value: node };
+    if (node === null || typeof node !== "object" || seen.has(node)) continue;
+    seen.add(node);
+    if (Array.isArray(node)) {
+      for (let i = node.length - 1; i >= 0; i--) stack.push([node[i], `${path}[${i}]`]);
+      continue;
+    }
+    const keys = Object.keys(node);
+    for (let i = keys.length - 1; i >= 0; i--) {
+      const key = keys[i];
+      stack.push([node[key], path === "" ? key : `${path}.${key}`]);
+    }
+  }
+  return void 0;
+}
+function jsonFate(value) {
+  if (typeof value === "symbol") return ["JSON drops it", "a string"];
+  if (typeof value === "bigint") return ["`JSON.stringify` throws on it", "`Number(big)` or `String(big)`"];
+  if (value instanceof Date) return ["JSON rewrites it as an ISO string", "`date.toISOString()` or its epoch ms"];
+  if (value instanceof Map) return ["JSON writes it as `{}`", "`Object.fromEntries(map)`"];
+  if (value instanceof Set) return ["JSON writes it as `{}`", "`[...set]`"];
+  if (value instanceof RegExp) return ["JSON writes it as `{}`", "its `.source` string"];
+  return ["JSON keeps only its own enumerable fields", "a plain record"];
+}
+function nonJsonMessage(owner, location, value) {
+  if (location.startsWith(`${owner}, at `)) location = location.slice(owner.length + ", at ".length);
+  if (typeof value !== "function") {
+    const [fate, instead] = jsonFate(value);
+    return `${owner}: ${nonJsonKind(value) ?? "a value JSON cannot carry"} is stored at ${location}. ${fate}, so the bundle would not hold the value you wrote, and the next pull could not read it back. Write plain JSON there \u2014 ${instead}.`;
+  }
+  const tagged = typeof value.tag === "string" && Array.isArray(value.filters);
+  const input = value.value;
+  return `${owner}: ${tagged ? "a callable tagged value (a trigger input accessor such as `t.action`)" : "a function"} is stored as a function at ${location}. JSON writes a function as \`null\` (or drops it), so the bundle would carry a hole where the value was, and the next pull could not read it back.` + (tagged && typeof input === "string" ? ` Spell the input by name in this position \u2014 \`inp(${JSON.stringify(input)})\`.` : " Pass a tagged value (`c.*`, `ref()`, `inp()`, \u2026) or a plain JSON value instead.");
+}
+
+export {
+  findNonJson,
+  nonJsonMessage
+};
+//# sourceMappingURL=chunk-H2V3N23D.js.map

package/dist/chunk-H5C7MBCR.js

@@ -0,0 +1,159 @@
+import {
+  UsageError,
+  flagNames,
+  unknownFlag
+} from "./chunk-PTHVMXZI.js";
+
+// src/emit/plugin-questions.ts
+function hostLabel(host) {
+  return host === "init" ? "xanosdk init" : `xanosdk marketplace ${host}`;
+}
+function hostHelpTarget(host) {
+  return host === "init" ? { command: "init" } : { command: "marketplace", subcommand: host };
+}
+function isRegistryFlag(flag) {
+  return flagNames().includes(flag);
+}
+function flagFor(question) {
+  return question.flag ?? question.id;
+}
+function questionSets(plugins) {
+  return plugins.filter((p) => p.plugin.questions !== void 0 && p.plugin.questions.length > 0).map((p) => ({ pkg: p.pkg, questions: p.plugin.questions }));
+}
+function assertNoFlagCollisions(sets, host) {
+  const claimed = /* @__PURE__ */ new Map();
+  for (const set of sets) {
+    for (const question of set.questions) {
+      const flag = flagFor(question);
+      if (isRegistryFlag(flag)) {
+        throw new UsageError(
+          `${set.pkg} asks a question whose flag \`--${flag}\` is already a \`${hostLabel(host)}\` flag, so it could never be answered \u2014 the CLI would consume it first.`,
+          {
+            helpFor: hostHelpTarget(host),
+            suggestion: `That is the module's bug to fix: its question \`${question.id}\` should declare a distinct \`flag\` (for example \`--${set.pkg.replace(/^@[^/]+\//, "")}-${flag}\`). Report it, or disable the module in this project's package.json "xanosdk" block.`
+          }
+        );
+      }
+      const owner = claimed.get(flag);
+      if (owner !== void 0) {
+        throw new UsageError(
+          `${set.pkg} and ${owner} both derive the flag \`--${flag}\`, so only one of them could ever be answered by it during \`${hostLabel(host)}\`.`,
+          {
+            helpFor: hostHelpTarget(host),
+            suggestion: `One of the two must declare a distinct \`flag\` on that question.`
+          }
+        );
+      }
+      claimed.set(flag, set.pkg);
+    }
+  }
+}
+function answerFromFlags(question, remaining) {
+  const name = flagFor(question);
+  const long = `--${name}`;
+  const negated = `--no-${name}`;
+  for (let i = 0; i < remaining.length; i++) {
+    const arg = remaining[i];
+    if (question.type === "boolean" && arg === negated) {
+      remaining.splice(i, 1);
+      return { given: true, value: false };
+    }
+    if (arg === long) {
+      if (question.type === "boolean") {
+        remaining.splice(i, 1);
+        return { given: true, value: true };
+      }
+      throw new UsageError(
+        `${long} takes its value with an equals sign: \`${long}=<value>\`.`,
+        {
+          suggestion: `Flags contributed by an installed module are not known to the parser until the module loads, so it cannot tell \`${long} value\` from a flag followed by a positional argument.`
+        }
+      );
+    }
+    if (arg.startsWith(`${long}=`)) {
+      const value = arg.slice(long.length + 1);
+      remaining.splice(i, 1);
+      if (question.type === "boolean") return { given: true, value: value !== "false" };
+      return { given: true, value };
+    }
+  }
+  return { given: false };
+}
+function assertChoice(pkg, question, value, host) {
+  if (question.type !== "choice") return;
+  const choices = question.choices ?? [];
+  if (!choices.includes(String(value))) {
+    throw new UsageError(
+      `${pkg}: --${flagFor(question)} expects one of ${choices.map((c) => `\`${c}\``).join(", ")}, not \`${String(value)}\`.`,
+      { helpFor: hostHelpTarget(host) }
+    );
+  }
+}
+function priorIsUsable(question, value) {
+  if (question.type === "boolean") return typeof value === "boolean";
+  if (typeof value !== "string") return false;
+  if (question.type === "choice") return (question.choices ?? []).includes(value);
+  return true;
+}
+async function resolvePluginAnswers(sets, opts) {
+  const remaining = [...opts.unknownFlags];
+  const byPackage = {};
+  for (const set of sets) {
+    const stored = opts.prior?.[set.pkg] ?? {};
+    const answers = {};
+    const sources = {};
+    const dropped = [];
+    for (const question of set.questions) {
+      if (question.when !== void 0 && !question.when(answers)) {
+        if (stored[question.id] !== void 0) dropped.push({ id: question.id, why: "excluded" });
+        continue;
+      }
+      const fromFlag = answerFromFlags(question, remaining);
+      if (fromFlag.given) {
+        assertChoice(set.pkg, question, fromFlag.value, opts.host);
+        answers[question.id] = fromFlag.value;
+        sources[question.id] = "flag";
+        continue;
+      }
+      const raw = stored[question.id];
+      let prior;
+      if (raw !== void 0) {
+        if (priorIsUsable(question, raw)) prior = raw;
+        else dropped.push({ id: question.id, why: "unusable" });
+      }
+      const asked = await opts.prompter.ask(set.pkg, question, prior ?? question.default);
+      if (asked !== void 0) {
+        assertChoice(set.pkg, question, asked, opts.host);
+        answers[question.id] = asked;
+        sources[question.id] = "prompt";
+        continue;
+      }
+      if (prior !== void 0) {
+        answers[question.id] = prior;
+        sources[question.id] = "config";
+        continue;
+      }
+      answers[question.id] = question.default;
+      sources[question.id] = "default";
+    }
+    byPackage[set.pkg] = { answers, sources, dropped };
+  }
+  if (remaining.length > 0) {
+    throw unknownFlag(
+      remaining,
+      hostHelpTarget(opts.host),
+      sets.flatMap((s) => s.questions.map(flagFor))
+    );
+  }
+  return byPackage;
+}
+
+export {
+  hostLabel,
+  hostHelpTarget,
+  flagFor,
+  questionSets,
+  assertNoFlagCollisions,
+  resolvePluginAnswers
+};
+//# sourceMappingURL=chunk-H5C7MBCR.js.map