@xano/sdk 1.0.0

package/dist/test-command-TIKZMDPZ.js

@@ -0,0 +1,476 @@
+import {
+  listTests,
+  objectQualifiedName,
+  qualifiedName,
+  runTest
+} from "./chunk-73IVBKMA.js";
+import {
+  memoCredential,
+  resolveBackend
+} from "./chunk-HHN734BU.js";
+import "./chunk-LPECSJ2J.js";
+import "./chunk-6NNTNXN7.js";
+import {
+  actualKind,
+  describeBackend,
+  isRateLimited,
+  rateLimitedCause
+} from "./chunk-QCNYHBL7.js";
+import "./chunk-2ZUEE4EK.js";
+import "./chunk-AN6BL47T.js";
+import {
+  getAccessToken
+} from "./chunk-ET4Y4XCB.js";
+import "./chunk-SWBF2LTK.js";
+import "./chunk-UZ6QQWJT.js";
+import "./chunk-A3UDOZB6.js";
+import "./chunk-2MNLRIOX.js";
+import "./chunk-3M4LFYNQ.js";
+import "./chunk-AM4FKL4J.js";
+import {
+  requireBackendSlot
+} from "./chunk-STSFNCY4.js";
+import "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-7G3CTU7I.js";
+import "./chunk-6PBR37LN.js";
+import "./chunk-T5KELPAR.js";
+import "./chunk-622HUCZT.js";
+import {
+  contextFlags
+} from "./chunk-NAQDMEHV.js";
+import "./chunk-5A2PLKZB.js";
+import "./chunk-AHJWCYQO.js";
+import "./chunk-DX4QR4B2.js";
+import "./chunk-6QXLMMT3.js";
+import "./chunk-ZFDZKNGG.js";
+import "./chunk-FWD7AL6N.js";
+import "./chunk-2GNFDZA2.js";
+import "./chunk-JTUKLCXS.js";
+import "./chunk-4KHEMC32.js";
+import "./chunk-ROY4YAEQ.js";
+import "./chunk-TLQE7ZN3.js";
+import "./chunk-WRBKLYSJ.js";
+import "./chunk-3LDULPRE.js";
+import "./chunk-XW6KISBB.js";
+import "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import {
+  TransportError,
+  lastRateLimitRetryAfter
+} from "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-UCQ2VUTG.js";
+import "./chunk-DGWHAVRG.js";
+import {
+  UsageError,
+  blank,
+  detail,
+  isMachineOutput,
+  stderrStyle,
+  step,
+  success,
+  terminalText,
+  unknownSubcommand,
+  warn,
+  writeJson
+} from "./chunk-PTHVMXZI.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-6MR5TI5V.js";
+import {
+  shellQuote
+} from "./chunk-5ZSO4T2G.js";
+import "./chunk-XNCP4KYO.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-NZOWWHU5.js";
+import "./chunk-4BW2SG2N.js";
+import "./chunk-CIMQZRRE.js";
+import "./chunk-OHX6MIUZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/emit/test-command.ts
+var EXIT_TESTS_FAILED = 5;
+async function mapWithConcurrency(items, limit, work) {
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    for (; ; ) {
+      const index = next++;
+      if (index >= items.length) return;
+      results[index] = await work(items[index], index);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(Math.max(1, limit), items.length) }, worker));
+  return results;
+}
+function sameBackend(args) {
+  const on = args.on ? ` --on ${shellQuote(args.on)}` : "";
+  return args.on !== void 0 && /^local-engine\b/.test(args.on) ? on : `${on}${contextFlags(args)}`;
+}
+function describe(handle) {
+  const object = handle.object;
+  if (object === void 0) return "[workflow]";
+  return object.verb === void 0 ? `[unit: ${object.type} ${object.name}]` : `[unit: ${object.type} ${object.verb} ${object.name}${object.group === void 0 ? "" : ` in ${object.group}`}]`;
+}
+function renderOutcome(outcome, width) {
+  const s = stderrStyle();
+  const verdict = outcome.status === "pass" ? s.green("PASS") : s.red("FAIL");
+  const timing = outcome.timing === void 0 ? "" : s.dim(`  ${outcome.timing.toFixed(3)}s`);
+  process.stderr.write(terminalText(`  ${verdict}  ${outcome.name.padEnd(width)}  ${s.dim(describe(outcome))}${timing}
+`));
+  if (outcome.status !== "fail") return;
+  const failures = (outcome.expectations ?? []).filter((e) => e.status === "fail" && e.message !== void 0);
+  if (failures.length > 1) {
+    const total = outcome.expectations.length;
+    for (const e of failures) process.stderr.write(terminalText(`        ${s.dim(`expectation ${e.index + 1} of ${total}:  ${e.message}`)}
+`));
+  } else if (outcome.message !== void 0) {
+    process.stderr.write(terminalText(`        ${s.dim(outcome.message)}
+`));
+  }
+}
+function summarize(ran, outcomes, unreachable = []) {
+  return {
+    kind: ran.kind,
+    env: ran.env,
+    name: ran.name,
+    display: ran.display,
+    ...suiteCounts(outcomes, unreachable),
+    tests: outcomes.map(testRow)
+  };
+}
+function testRow(o) {
+  return {
+    kind: o.kind,
+    name: o.name,
+    // The same key `test list` carries, so a name read from a run feeds `test run`.
+    qualified: qualifiedName(o),
+    object: o.object,
+    status: o.status,
+    message: o.message,
+    expectations: o.expectations,
+    timing: o.timing
+  };
+}
+function suiteCounts(outcomes, unreachable = []) {
+  const passed = outcomes.filter((o) => o.status === "pass").length;
+  const failed = outcomes.length - passed;
+  return {
+    total: outcomes.length + unreachable.length,
+    passed,
+    failed,
+    notRun: unreachable.length,
+    ...unreachable.length > 0 ? { unreachable: [...unreachable] } : {}
+  };
+}
+function report(args, ran, outcomes, empty = "No tests found.") {
+  const summary = summarize(ran, outcomes);
+  if (isMachineOutput(args)) writeJson(summary);
+  if (outcomes.length === 0) {
+    detail(empty);
+  } else {
+    blank();
+    printTally(summary.passed, summary.failed);
+  }
+  if (summary.failed > 0) process.exitCode = EXIT_TESTS_FAILED;
+}
+function printTally(passed, failed, notRun = 0) {
+  const line = `${passed} passed, ${failed} failed${notRun > 0 ? `, ${notRun} not run` : ""}`;
+  if (failed > 0) process.stderr.write(terminalText(`  ${stderrStyle().red(line)}
+`));
+  else if (notRun > 0) process.stderr.write(terminalText(`  ${line}
+`));
+  else success(line);
+}
+async function resolveOn(args, subcommand) {
+  const slot = requireBackendSlot("test", subcommand, "on");
+  const resolved = await resolveBackend(slot, args.on, {
+    credential: memoCredential(() => getAccessToken(args)),
+    profile: args.profile
+  });
+  return {
+    ran: {
+      // The target's ACTUAL kind: `--on tenant:<name>` can name an ephemeral.
+      kind: actualKind(resolved),
+      // The resolver reports the env name as its own field; `label` is
+      // human-facing prose and is not a machine value to parse back out of.
+      env: resolved.target.env ?? null,
+      // The backend's own name whatever its kind, and its display name — the
+      // same pair `tables --json` reports, so the two documents agree.
+      name: resolved.backend.kind === "local" ? resolved.backend.engine.name : resolved.target.env ?? null,
+      display: resolved.target.display ?? null
+    },
+    bearer: resolved.bearer,
+    // The human lines name the backend with its kind and display name — an
+    // ephemeral's bare server name is a handle nobody recognises.
+    target: { ...resolved.target, label: describeBackend(resolved) }
+  };
+}
+async function collect(auth, target, kind) {
+  return listTests(auth, target, {
+    kind,
+    onTruncate: (collected) => warn(`Stopped after ${collected} tests \u2014 the list did not terminate, so some may not have run.`, "test.list-truncated")
+  });
+}
+function nameWidth(handles) {
+  return Math.max(0, ...handles.map((h) => h.name.length));
+}
+async function runList(args) {
+  const { ran, bearer, target } = await resolveOn(args, "list");
+  const handles = await collect(bearer, target, args.kind).catch(async (err) => {
+    const { unansweredRead } = await import("./source-resolve-S2XA3XZF.js");
+    throw unansweredRead(err, `list the tests on ${target.label}`, ran.kind);
+  });
+  if (isMachineOutput(args)) {
+    writeJson({
+      kind: ran.kind,
+      env: ran.env,
+      name: ran.name,
+      display: ran.display,
+      total: handles.length,
+      tests: handles.map((h) => ({
+        kind: h.kind,
+        name: h.name,
+        qualified: qualifiedName(h),
+        object: h.object,
+        // Only a named one: `""` is the empty (recommended) datasource, which
+        // printed as `"datasource": ""` on every workflow test — a key whose
+        // value says there is nothing. Absent means the same.
+        ...h.datasource === void 0 || h.datasource === "" ? {} : { datasource: h.datasource }
+      }))
+    });
+    return;
+  }
+  if (handles.length === 0) {
+    detail(await noTestsFound(bearer, target, args.kind));
+    return;
+  }
+  const s = stderrStyle();
+  step(`${handles.length} test${handles.length === 1 ? "" : "s"} in ${target.label}`);
+  const width = nameWidth(handles);
+  for (const handle of handles) {
+    const ds = handle.datasource === void 0 || handle.datasource === "" ? "" : s.yellow(`  datasource: ${handle.datasource}`);
+    process.stderr.write(terminalText(`  ${handle.name.padEnd(width)}  ${s.dim(describe(handle))}${ds}
+`));
+  }
+}
+function match(handles, needle) {
+  const qualified = handles.filter((h) => qualifiedName(h) === needle);
+  if (qualified.length > 0) return qualified;
+  const byObject = handles.filter((h) => objectQualifiedName(h) === needle);
+  if (byObject.length > 0) return byObject;
+  return handles.filter((h) => h.name === needle);
+}
+var TestNotFoundError = class extends Error {
+  constructor(message, suggestion, suggestions) {
+    super(message);
+    this.suggestion = suggestion;
+    this.suggestions = suggestions;
+  }
+  suggestion;
+  suggestions;
+  name = "TestNotFoundError";
+  exitCode = 8;
+  code = "SDK_ERROR";
+};
+async function runOne(args, name) {
+  const { ran, bearer, target } = await resolveOn(args, "run");
+  const handles = await reaching(ran, target, args, "run", () => collect(bearer, target, args.kind));
+  const found = match(handles, name);
+  if (found.length === 0) {
+    const { suggestAll, orNames } = await import("./suggest-6FOOYKHG.js");
+    const near = suggestAll(name, [...new Set(handles.map((h) => h.name))]);
+    const nearest = near[0];
+    const offer = nearest === void 0 ? "" : near.length === 1 ? ` Did you mean "${nearest}"? \`xanosdk test run ${shellQuote(nearest)}${sameBackend(args)}\` runs it.` : ` Did you mean ${orNames(near)}?`;
+    throw new TestNotFoundError(
+      `No test named "${name}" in ${target.label}.${offer} \`xanosdk test list${sameBackend(args)}\` shows the ones that exist.`,
+      nearest,
+      near.length > 1 ? near : void 0
+    );
+  }
+  if (found.length > 1) {
+    const forms = found.map((h) => qualifiedName(h));
+    const distinct = [...new Set(forms)];
+    if (distinct.length < forms.length || distinct.includes(name)) {
+      throw new Error(
+        `"${name}" names ${found.length} tests in ${target.label} that no qualified form tells apart (${distinct.map((f) => `"${f}"`).join(", ")}). Rename one of them, then run it by its new name.`
+      );
+    }
+    throw new Error(
+      `"${name}" names ${found.length} tests in ${target.label}. Use the qualified form:
+` + forms.map((f) => `  xanosdk test run ${shellQuote(f)}${sameBackend(args)}`).join("\n")
+    );
+  }
+  const handle = found[0];
+  step(`Running ${handle.name} in ${target.label}`);
+  const outcome = await reaching(ran, target, args, "run", () => runTest(bearer, target, handle));
+  renderOutcome(outcome, handle.name.length);
+  report(args, ran, [outcome]);
+}
+async function runSuite(auth, target, opts = {}) {
+  const handles = await collect(auth, target, opts.kind);
+  if (handles.length === 0) return [];
+  const units = handles.filter((h) => h.kind === "unit").length;
+  const flows = handles.length - units;
+  step(
+    `Running ${handles.length} test${handles.length === 1 ? "" : "s"} against ${target.label} (${units} unit, ${flows} workflow)`
+  );
+  blank();
+  const width = nameWidth(handles);
+  let emitted = 0;
+  const settled = new Array(handles.length);
+  const flush = () => {
+    while (emitted < settled.length && settled[emitted] !== void 0) {
+      const outcome = settled[emitted];
+      if (outcome !== null && outcome !== void 0) renderOutcome(outcome, width);
+      emitted++;
+    }
+  };
+  let stopped;
+  const outcomes = await mapWithConcurrency(handles, opts.concurrency ?? 1, async (handle, index) => {
+    let outcome;
+    if (stopped !== void 0 && opts.onUnreachable !== void 0) {
+      opts.onUnreachable(handle, stopped);
+      outcome = null;
+    } else {
+      try {
+        outcome = await runTest(auth, target, handle);
+      } catch (err) {
+        if (opts.onUnreachable === void 0 || !isSuiteUnreachable(err)) throw err;
+        stopped ??= err;
+        opts.onUnreachable(handle, err);
+        outcome = null;
+      }
+    }
+    settled[index] = outcome;
+    if (outcome !== null) opts.onOutcome?.(outcome);
+    flush();
+    return outcome;
+  });
+  return outcomes.filter((o) => o !== null);
+}
+async function runAll(args) {
+  const { ran, bearer, target } = await resolveOn(args, "run-all");
+  const unreachable = [];
+  const outcomes = await reaching(
+    ran,
+    target,
+    args,
+    "run-all",
+    () => runSuite(bearer, target, {
+      kind: args.kind,
+      concurrency: args.concurrency,
+      onUnreachable: (handle, err) => void unreachable.push({ handle, err })
+    })
+  );
+  if (unreachable.length > 0) throw partialRunError(ran, target, args, outcomes, unreachable);
+  report(args, ran, outcomes, outcomes.length === 0 ? await noTestsFound(bearer, target, args.kind) : void 0);
+}
+function partialRunError(ran, target, args, outcomes, unreachable) {
+  const names = unreachable.map((u) => qualifiedName(u.handle));
+  const results = summarize(ran, outcomes, names);
+  if (outcomes.length > 0) {
+    blank();
+    printTally(results.passed, results.failed, unreachable.length);
+  }
+  const first = unreachable[0].err;
+  const head = first.message.split("\n")[0] ?? first.message;
+  const n = names.length;
+  const read = outcomes.length === 0 ? "no result was read" : `${outcomes.length} ${outcomes.length === 1 ? "result was" : "results were"} read (${results.passed} passed, ${results.failed} failed)`;
+  const again = `xanosdk test run-all${args.kind !== void 0 ? ` --kind ${args.kind}` : ""}${sameBackend(args)}`;
+  return new TestsUnreachableError(
+    `${head}
+The tests on ${target.label} stopped answering: ${n} ${n === 1 ? "test" : "tests"} could not be run (${names.join(", ")}), and ${read}. ${unreachableCheck(first, ran, args)}, then run \`${again}\` again.`,
+    { cause: first, details: { results, unreachable: names } }
+  );
+}
+async function noTestsFound(auth, target, kind, where = "") {
+  if (kind === void 0) return `No tests found${where}.`;
+  const other = kind === "unit" ? "workflow" : "unit";
+  const n = await listTests(auth, target, { kind: other }).then(
+    (h) => h.length,
+    () => void 0
+  );
+  if (n === 0) return `No tests found${where}.`;
+  if (n === void 0) return `No ${kind} tests found${where}.`;
+  return `No ${kind} tests found${where} (${n} ${other} test${n === 1 ? " exists" : "s exist"}; drop --kind or use --kind ${other}).`;
+}
+var EXIT_TESTS_UNREACHABLE = 6;
+var TestsUnreachableError = class extends Error {
+  name = "TestsUnreachableError";
+  exitCode = EXIT_TESTS_UNREACHABLE;
+  /** The failure document's code — `SDK_ERROR`, as before, so `details` travels with it. */
+  code = "SDK_ERROR";
+  /** A run stopped part-way: `{ results, unreachable }` (see `partialRunError`). */
+  details;
+  constructor(message, opts = {}) {
+    super(message, opts.cause === void 0 ? void 0 : { cause: opts.cause });
+    this.details = opts.details;
+  }
+};
+function isSuiteUnreachable(err) {
+  return err instanceof TransportError || err instanceof Error && err.name === "TestRunUnansweredError";
+}
+function suiteUnreachableCheck(ran, args) {
+  return ran.kind === "local-engine" ? "Check that the local engine is still running (`xanosdk local-engine list`)" : ran.kind === "ephemeral" && ran.env !== null ? `Check that it is still up with \`xanosdk ephemeral get ${shellQuote(ran.env)}${contextFlags(args)}\` \u2014 an ephemeral expires \u2014 and that this machine reaches the instance` : "Check that this machine reaches the instance (network, VPN or proxy)";
+}
+function unreachableCheck(err, ran, args) {
+  if (!isRateLimited(err)) return suiteUnreachableCheck(ran, args);
+  const wait = lastRateLimitRetryAfter() === void 0 ? "Wait a moment" : "Wait that long";
+  return `${rateLimitedCause()}: the instance turned the request away before acting on it. ${wait}`;
+}
+async function reaching(ran, target, args, verb, work) {
+  try {
+    return await work();
+  } catch (err) {
+    if (!isSuiteUnreachable(err)) throw err;
+    const head = err.message.split("\n")[0] ?? err.message;
+    const again = `xanosdk test ${verb}${verb === "run" && args.positionals[0] !== void 0 ? ` ${shellQuote(args.positionals[0])}` : ""}${args.kind !== void 0 ? ` --kind ${args.kind}` : ""}${sameBackend(args)}`;
+    throw new TestsUnreachableError(
+      `${head}
+The tests on ${target.label} could not be reached, so no result was read. ${unreachableCheck(err, ran, args)}, then run \`${again}\` again.`,
+      { cause: err }
+    );
+  }
+}
+async function runTestCommand(args) {
+  switch (args.subcommand) {
+    case "list":
+      return runList(args);
+    case "run": {
+      const name = args.positionals[0];
+      if (name === void 0 || name === "") {
+        throw new UsageError(`\`xanosdk test run\` needs a test name: \`xanosdk test run "<name>"${sameBackend(args)}\`.`, {
+          hintFor: { command: "test", subcommand: "run" }
+        });
+      }
+      return runOne(args, name);
+    }
+    case "run-all":
+      return runAll(args);
+    default:
+      throw unknownSubcommand("test", args.subcommand);
+  }
+}
+export {
+  EXIT_TESTS_FAILED,
+  EXIT_TESTS_UNREACHABLE,
+  TestNotFoundError,
+  TestsUnreachableError,
+  isSuiteUnreachable,
+  noTestsFound,
+  printTally,
+  runSuite,
+  runTestCommand,
+  suiteCounts,
+  suiteUnreachableCheck,
+  testRow
+};
+//# sourceMappingURL=test-command-TIKZMDPZ.js.map

package/dist/tests-BGGIOK3L.js

@@ -0,0 +1,26 @@
+import {
+  TestRunUnansweredError,
+  listTests,
+  objectQualifiedName,
+  qualifiedName,
+  runTest
+} from "./chunk-73IVBKMA.js";
+import "./chunk-6PBR37LN.js";
+import "./chunk-YLDALTWZ.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-PTHVMXZI.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  TestRunUnansweredError,
+  listTests,
+  objectQualifiedName,
+  qualifiedName,
+  runTest
+};
+//# sourceMappingURL=tests-BGGIOK3L.js.map

package/dist/token-NICJUTMT.js

@@ -0,0 +1,72 @@
+import {
+  ENV_INSTANCE,
+  ENV_META_TOKEN,
+  ENV_WORKSPACE,
+  NotSignedInError,
+  ProfileNotFoundError,
+  StoredCredentialError,
+  assertStoredAuthHost,
+  credentialRejected,
+  credentialWarning,
+  describeRefreshAnswer,
+  describeRefreshFailure,
+  envMetaCredentialVarsSet,
+  environmentCredentialVars,
+  getAccessToken,
+  isTransientRefreshError,
+  notSignedIn,
+  readEnvMetaCredential,
+  refusedRefreshCredential,
+  resolveNamedProfile,
+  warnIfReadableByOthers
+} from "./chunk-ET4Y4XCB.js";
+import "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-FWD7AL6N.js";
+import "./chunk-TLQE7ZN3.js";
+import "./chunk-XW6KISBB.js";
+import "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-PTHVMXZI.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-6MR5TI5V.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-XNCP4KYO.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-NZOWWHU5.js";
+import "./chunk-4BW2SG2N.js";
+import "./chunk-CIMQZRRE.js";
+import "./chunk-OHX6MIUZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  ENV_INSTANCE,
+  ENV_META_TOKEN,
+  ENV_WORKSPACE,
+  NotSignedInError,
+  ProfileNotFoundError,
+  StoredCredentialError,
+  assertStoredAuthHost,
+  credentialRejected,
+  credentialWarning,
+  describeRefreshAnswer,
+  describeRefreshFailure,
+  envMetaCredentialVarsSet,
+  environmentCredentialVars,
+  getAccessToken,
+  isTransientRefreshError,
+  notSignedIn,
+  readEnvMetaCredential,
+  refusedRefreshCredential,
+  resolveNamedProfile,
+  warnIfReadableByOthers
+};
+//# sourceMappingURL=token-NICJUTMT.js.map

package/dist/toolchain-hooks-GHKLUJOH.js

@@ -0,0 +1,96 @@
+import {
+  UsageError,
+  detail,
+  info,
+  warn
+} from "./chunk-PTHVMXZI.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/emit/toolchain-hooks.ts
+function redactEnvValues(payload) {
+  const env = payload["env"];
+  if (!Array.isArray(env)) return payload;
+  return {
+    ...payload,
+    env: env.map(
+      (entry) => typeof entry === "object" && entry !== null && "value" in entry ? { ...entry, value: "" } : entry
+    )
+  };
+}
+function report(pkg, result) {
+  if (result.message !== void 0 && result.message !== "") {
+    if (result.failed === true) warn(`${pkg} \u2014 ${result.message}`, "toolchain.failed");
+    else info(result.message);
+  }
+  for (const line of result.warnings ?? []) detail(line);
+}
+function handleThrow(pkg, error, frozen) {
+  const why = error instanceof Error ? error.message : String(error);
+  if (frozen) {
+    throw new UsageError(
+      `${pkg} failed while checking this bundle, so whatever it verifies was not verified \u2014 and this run was asked to verify, not to write:
+  ${why}`
+    );
+  }
+  warn(`${pkg} failed and was skipped.`, "toolchain.failed", [why]);
+}
+async function fireOnBundle(plugins, ctx) {
+  let failed = false;
+  const bundle = { ...ctx.bundle, payload: redactEnvValues(ctx.bundle.payload) };
+  for (const { pkg, plugin, config } of plugins) {
+    if (plugin.onBundle === void 0) continue;
+    try {
+      const result = await plugin.onBundle({ ...ctx, bundle, config });
+      report(pkg, result);
+      if (result.failed === true) failed = true;
+    } catch (error) {
+      handleThrow(pkg, error, ctx.frozen);
+    }
+  }
+  return { failed };
+}
+async function fireOnPreflight(plugins, ctx) {
+  let failed = false;
+  const payloads = {
+    exportedPayload: redactEnvValues(ctx.exportedPayload),
+    remappedPayload: redactEnvValues(ctx.remappedPayload)
+  };
+  for (const { pkg, plugin, config } of plugins) {
+    if (plugin.onPreflight === void 0) continue;
+    try {
+      const result = await plugin.onPreflight({ ...ctx, ...payloads, config });
+      report(pkg, result);
+      if (result.failed === true) failed = true;
+    } catch (error) {
+      const why = error instanceof Error ? error.message : String(error);
+      warn(`${pkg} could not complete its check.`, "toolchain.failed", [why]);
+      failed = true;
+    }
+  }
+  return { failed };
+}
+async function runBundleHooks(plugins, ctx, consequence) {
+  if (plugins.length === 0) return;
+  const outcome = await fireOnBundle(plugins, ctx);
+  if (outcome.failed) {
+    throw new UsageError(
+      `A toolchain module reported that its check did not pass${consequence}. See the report above.`
+    );
+  }
+}
+function anyDeclares(plugins, hook) {
+  return plugins.some((p) => p.plugin[hook] !== void 0);
+}
+export {
+  anyDeclares,
+  fireOnBundle,
+  fireOnPreflight,
+  redactEnvValues,
+  runBundleHooks
+};
+//# sourceMappingURL=toolchain-hooks-GHKLUJOH.js.map

package/dist/toolchain-modules-5EAZUONB.js

@@ -0,0 +1,24 @@
+import {
+  UNKNOWN_MODULE_VERSION,
+  declaredToolchainPlugins,
+  discoverToolchainPlugins,
+  sdkPeerSkew
+} from "./chunk-4Q2GN7NW.js";
+import "./chunk-2TFRR6JV.js";
+import "./chunk-JTUKLCXS.js";
+import "./chunk-3LDULPRE.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-PTHVMXZI.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  UNKNOWN_MODULE_VERSION,
+  declaredToolchainPlugins,
+  discoverToolchainPlugins,
+  sdkPeerSkew
+};
+//# sourceMappingURL=toolchain-modules-5EAZUONB.js.map