@xano/sdk 1.0.0

package/dist/chunk-4BW2SG2N.js

@@ -0,0 +1,46 @@
+// src/lock/store.ts
+var STORE_KEY = /* @__PURE__ */ Symbol.for("xanosdk.lock.overrides");
+var SOURCE_KEY = /* @__PURE__ */ Symbol.for("xanosdk.lock.source");
+function getStore() {
+  return globalThis[STORE_KEY];
+}
+function seedLockOverrides(lock) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const [key, entry] of Object.entries(lock.objects)) {
+    entries.set(key, { ...entry });
+  }
+  const source = lock[SOURCE_KEY];
+  globalThis[STORE_KEY] = {
+    entries,
+    ...typeof source === "string" ? { source } : {}
+  };
+}
+function tagLockSource(lock, path) {
+  Object.defineProperty(lock, SOURCE_KEY, { value: path, enumerable: false, configurable: true });
+}
+function seededLockSource() {
+  return getStore()?.source;
+}
+function resetLockOverrides() {
+  delete globalThis[STORE_KEY];
+}
+function isLockSeeded() {
+  return getStore() !== void 0;
+}
+function getLockedGuid(key) {
+  return getStore()?.entries.get(key)?.guid;
+}
+function getLockedCanonical(key) {
+  return getStore()?.entries.get(key)?.canonical;
+}
+
+export {
+  seedLockOverrides,
+  tagLockSource,
+  seededLockSource,
+  resetLockOverrides,
+  isLockSeeded,
+  getLockedGuid,
+  getLockedCanonical
+};
+//# sourceMappingURL=chunk-4BW2SG2N.js.map

package/dist/chunk-4KHEMC32.js

@@ -0,0 +1,79 @@
+// src/util/sent-writes.ts
+import { AsyncLocalStorage } from "async_hooks";
+var described = new AsyncLocalStorage();
+var inFlight = /* @__PURE__ */ new Set();
+function describeWrite(description, fn) {
+  const outer = described.getStore();
+  const merged = { ...outer };
+  for (const key of ["what", "resolveWith", "check"]) {
+    if (description[key] !== void 0) merged[key] = description[key];
+  }
+  return described.run(merged, fn);
+}
+var READ_POST = /\/(export|run)$/;
+function isWriteRequest(method, url) {
+  const verb = method.toUpperCase();
+  if (verb === "GET" || verb === "HEAD" || verb === "OPTIONS") return false;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  if (!parsed.pathname.includes("/api:meta/")) return false;
+  if (parsed.searchParams.get("dry_run") === "true") return false;
+  return !READ_POST.test(parsed.pathname.replace(/\/$/, ""));
+}
+function pendingWrite() {
+  let last;
+  for (const write of inFlight) last = write;
+  return last;
+}
+function trackingFetch(fetchImpl) {
+  return async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const method = init?.method ?? (typeof input === "object" && "method" in input ? input.method : "GET");
+    if (!isWriteRequest(method, url)) return fetchImpl(input, init);
+    const write = { host: new URL(url).origin, ...described.getStore() };
+    inFlight.add(write);
+    try {
+      return await fetchImpl(input, init);
+    } finally {
+      inFlight.delete(write);
+    }
+  };
+}
+var installed = false;
+function installSentWriteTracking() {
+  if (installed) return;
+  installed = true;
+  globalThis.fetch = trackingFetch(globalThis.fetch.bind(globalThis));
+}
+async function trackLocalWrite(description, fn) {
+  const write = { host: "this project", local: true, ...description };
+  inFlight.add(write);
+  try {
+    return await fn();
+  } finally {
+    inFlight.delete(write);
+  }
+}
+var landed;
+function noteLanded(step) {
+  landed = step;
+}
+function landedStep() {
+  return landed;
+}
+
+export {
+  describeWrite,
+  isWriteRequest,
+  pendingWrite,
+  trackingFetch,
+  installSentWriteTracking,
+  trackLocalWrite,
+  noteLanded,
+  landedStep
+};
+//# sourceMappingURL=chunk-4KHEMC32.js.map

package/dist/chunk-4POWHT2K.js

@@ -0,0 +1,321 @@
+import {
+  statementLabel
+} from "./chunk-YU4HSQW7.js";
+import {
+  PROTO_KEY,
+  describeEntry,
+  protoKeyed
+} from "./chunk-CIMQZRRE.js";
+import {
+  withArticle
+} from "./chunk-36JUQZVQ.js";
+
+// src/kinds/def-shape.ts
+var COMMON = {
+  name: "string",
+  guid: "string",
+  description: "string",
+  docs: "string",
+  tags: "string[]",
+  active: "boolean",
+  tests: "object[]",
+  input: "record",
+  middleware: "attach"
+};
+var BY_KIND = {
+  task: { schedule: "object[]", datasource: "string" },
+  query: { cache: "object" },
+  function: { cache: "object" },
+  table: { schema: "schema", index: "object[]", views: "object[]", autocomplete: "string[]" },
+  api_group: { canonical: "string", swagger: "boolean", cors: "object", documentation: "object" },
+  agent: { tools: "list", llm: "object" },
+  trigger: { datasources: "string[]", actions: "object" },
+  mcp_server: { tools: "list", canonical: "string" },
+  microservice: { configs: "object[]", volumes: "object[]", ingresses: "object[]", deployment: "object" },
+  workspace: {
+    env: "object",
+    history: "object",
+    realtime: "object",
+    documentation: "object",
+    defaults: "object",
+    preferences: "object",
+    settings: "object"
+  }
+};
+var AUTHOR_KIND_NAME = {
+  api_group: "apiGroup",
+  mcp_server: "mcpServer",
+  realtime_server: "realtimeServer",
+  channel: "realtimeChannel",
+  message: "realtimeMessage",
+  workflow_test: "workflowTest",
+  workspace: "workspaceConfig"
+};
+var EXPECTED = {
+  string: "a string",
+  boolean: "true or false",
+  "string[]": "a list of strings",
+  "object[]": "a list of objects",
+  list: "a list",
+  object: "a { \u2026 } object",
+  record: "a { name: descriptor } record",
+  schema: "a { column: f.*() } record (or a list of columns)",
+  attach: "a { pre?: [...], post?: [...] } object"
+};
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function assertDefShape(kindName, def) {
+  const label = AUTHOR_KIND_NAME[kindName] ?? kindName;
+  const owner = typeof def.name === "string" ? `${label} "${def.name}"` : label;
+  assertNoProtoKeys(owner, def);
+  if (kindName === "table" && (def.schema === void 0 || def.schema === null)) {
+    throw new Error(`${owner}: \`schema\` is required \u2014 a { column: f.*() } record (or a list of columns).`);
+  }
+  const fields = { ...COMMON, ...BY_KIND[kindName] };
+  for (const [field, shape] of Object.entries(fields)) {
+    const v = def[field];
+    if (v === void 0 || v === null) continue;
+    const bad = shapeProblem(shape, v, field);
+    if (bad !== void 0) {
+      throw new Error(`${owner}: \`${bad.at}\` must be ${bad.expected} \u2014 got ${describeEntry(bad.got)}.`);
+    }
+  }
+  if (kindName === "table" && Array.isArray(def.views)) {
+    def.views.forEach((view, i) => {
+      for (const key of ["name", "id"]) {
+        if (typeof view[key] === "string") continue;
+        throw new Error(
+          `${owner}: \`views[${i}].${key}\` is required \u2014 ` + (key === "id" ? "the view's stable uuid (`crypto.randomUUID()` once, then keep it)" : "the view's label") + ` \u2014 got ${describeEntry(view[key])}.`
+        );
+      }
+    });
+  }
+}
+function shapeProblem(shape, v, field) {
+  const whole = { at: field, expected: EXPECTED[shape], got: v };
+  switch (shape) {
+    case "string":
+      return typeof v === "string" ? void 0 : whole;
+    case "boolean":
+      return typeof v === "boolean" ? void 0 : whole;
+    case "object":
+      return isPlainObject(v) ? void 0 : whole;
+    case "list":
+      return Array.isArray(v) ? void 0 : whole;
+    case "string[]":
+    case "object[]": {
+      if (!Array.isArray(v)) return whole;
+      const want = shape === "string[]" ? "a string" : "an object";
+      const i = v.findIndex((e) => shape === "string[]" ? typeof e !== "string" : !isPlainObject(e));
+      return i === -1 ? void 0 : { at: `${field}[${i}]`, expected: want, got: v[i] };
+    }
+    case "record": {
+      if (!isPlainObject(v)) return whole;
+      const bad = Object.entries(v).find(([, d]) => !isPlainObject(d) && typeof d !== "function");
+      return bad === void 0 ? void 0 : { at: `${field}.${bad[0]}`, expected: "a descriptor object", got: bad[1] };
+    }
+    case "attach": {
+      if (!isPlainObject(v)) return whole;
+      for (const side of ["pre", "post"]) {
+        const list = v[side];
+        if (list !== void 0 && list !== null && !Array.isArray(list)) {
+          return { at: `${field}.${side}`, expected: "a list of middleware", got: list };
+        }
+      }
+      return void 0;
+    }
+    case "schema": {
+      if (Array.isArray(v)) {
+        const i = v.findIndex((e) => !isPlainObject(e) || typeof e.name !== "string" || typeof e.type !== "string");
+        return i === -1 ? void 0 : { at: `${field}[${i}]`, expected: "a column ({ name, type })", got: v[i] };
+      }
+      if (!isPlainObject(v)) return whole;
+      const bad = Object.entries(v).find(([, d]) => !isPlainObject(d) || typeof d.type !== "string");
+      return bad === void 0 ? void 0 : { at: `${field}.${bad[0]}`, expected: "a field (f.text(), f.int(), \u2026)", got: bad[1] };
+    }
+  }
+}
+function findProtoKeyed(root) {
+  const stack = [[root, ""]];
+  const seen = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const [node, path] = stack.pop();
+    if (node === null || typeof node !== "object" || seen.has(node)) continue;
+    seen.add(node);
+    if (protoKeyed(node)) return path;
+    if (Array.isArray(node)) {
+      for (let i = node.length - 1; i >= 0; i--) stack.push([node[i], `${path}[${i}]`]);
+      continue;
+    }
+    const proto = Object.getPrototypeOf(node);
+    if (proto !== Object.prototype && proto !== null) 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 assertNoProtoKeys(owner, def) {
+  const at = findProtoKeyed(def);
+  if (at === void 0) return;
+  throw new Error(
+    `${owner}: ${at === "" ? "the def" : `\`${at}\``} has a \`__proto__\` key that is not a member \u2014 ${PROTO_KEY}.`
+  );
+}
+
+// src/kinds/test-mocks.ts
+function mockBearingItem(node) {
+  if (node === null || typeof node !== "object" || Array.isArray(node)) return null;
+  const rec = node;
+  if (typeof rec.name !== "string") return null;
+  const mocks = rec.mocks;
+  if (mocks === null || typeof mocks !== "object" || Array.isArray(mocks)) return null;
+  if (Object.keys(mocks).length === 0) return null;
+  return rec;
+}
+function resolveMockKeys(run, tests, ownerKind, ownerName) {
+  const byName = new Map(tests.map((t) => [t.name, t.id]));
+  const rewrite = (item) => {
+    const resolved = {};
+    for (const [testName, entry] of Object.entries(item.mocks)) {
+      const id = byName.get(testName);
+      if (id === void 0) {
+        if (/^[0-9a-f]{32}$/.test(testName)) {
+          resolved[testName] = entry;
+          continue;
+        }
+        throw new Error(
+          `${ownerKind} "${ownerName}": a statement mocks a test named "${testName}", which this object does not declare. ` + (tests.length === 0 ? `It declares no tests at all \u2014 add one to \`tests\`, or drop the mock. ` : `Declared tests: ${tests.map((t) => `"${t.name}"`).join(", ")}. `) + `A mock is stored against a test's id, so a name that matches nothing would deploy clean and then never apply.`
+        );
+      }
+      resolved[id] = entry;
+    }
+    item.mocks = resolved;
+  };
+  const pending = [run];
+  while (pending.length > 0) {
+    const node = pending.pop();
+    if (Array.isArray(node)) {
+      for (const child of node) pending.push(child);
+      continue;
+    }
+    if (node === null || typeof node !== "object") continue;
+    const item = mockBearingItem(node);
+    if (item) rewrite(item);
+    for (const [key, child] of Object.entries(node)) {
+      if (key === "mocks") continue;
+      pending.push(child);
+    }
+  }
+}
+function assertMockKeysResolved(xdo, kindName) {
+  const kind = AUTHOR_KIND_NAME[kindName] ?? kindName;
+  const objectName = xdo?.name;
+  const owner = typeof objectName === "string" ? `${kind} "${objectName}"` : kind;
+  const pending = [xdo];
+  while (pending.length > 0) {
+    const node = pending.pop();
+    if (Array.isArray(node)) {
+      for (const child of node) pending.push(child);
+      continue;
+    }
+    if (node === null || typeof node !== "object") continue;
+    const item = mockBearingItem(node);
+    if (item) {
+      for (const key of Object.keys(item.mocks)) {
+        if (/^[0-9a-f]{32}$/.test(key)) continue;
+        const stored = node.name;
+        const step = typeof stored === "string" ? `\`${statementLabel(stored)}\`` : "a statement";
+        throw new Error(
+          `${owner}: ${step} carries \`mock: { "${key}": \u2026 }\`, but ${withArticle(kind)} does not store unit tests \u2014 only a query, function, or middleware does. A mock is stored against a test's id, so this one would deploy clean and never apply. Move the step into a function that declares the test, or drop the mock.`
+        );
+      }
+    }
+    for (const [key, child] of Object.entries(node)) {
+      if (key === "mocks") continue;
+      pending.push(child);
+    }
+  }
+}
+function assertTestIds(xdo, kindName) {
+  const tests = xdo?.test;
+  if (!Array.isArray(tests)) return;
+  const kind = AUTHOR_KIND_NAME[kindName] ?? kindName;
+  const owner = `${kind} "${String(xdo.name)}"`;
+  const byId = /* @__PURE__ */ new Map();
+  for (const t of tests) {
+    if (typeof t?.id !== "string" || !/^[0-9a-f]{32}$/.test(t.id)) {
+      throw new Error(
+        `${owner}: test "${String(t?.name)}" has \`id: ${JSON.stringify(t?.id)}\` \u2014 a test id is 32 lowercase hex characters, the form the engine stores. Omit \`id\` to derive one from the test name, or copy the stored id.`
+      );
+    }
+    if (byId.has(t.id)) {
+      throw new Error(`${owner}: tests "${String(byId.get(t.id))}" and "${String(t.name)}" share \`id: "${t.id}"\` \u2014 each test needs its own.`);
+    }
+    byId.set(t.id, t.name);
+  }
+}
+
+// src/kinds/kind.ts
+var kindRegistry = /* @__PURE__ */ new Map();
+function registerKind(kind) {
+  kindRegistry.set(kind.name, kind);
+}
+function isRegisteredKind(name) {
+  return kindRegistry.has(name);
+}
+function getKind(name) {
+  const kind = kindRegistry.get(name);
+  if (!kind) {
+    throw new Error(
+      `Unknown object kind "${name}". Registered: ${[...kindRegistry.keys()].join(", ") || "(none)"}`
+    );
+  }
+  return kind;
+}
+function encodeObject(name, def) {
+  const xdo = getKind(name).encode(def);
+  assertTestIds(xdo, name);
+  assertMockKeysResolved(xdo, name);
+  return xdo;
+}
+function registeredKinds() {
+  return [...kindRegistry.values()];
+}
+
+// src/kinds/common.ts
+function emptyMiddleware() {
+  return { pre_customize: false, post_customize: false, pre: [], post: [] };
+}
+function encodeTags(tags) {
+  return (tags ?? []).map((tag) => ({ tag }));
+}
+var HISTORY_DEFAULT_OFF = /* @__PURE__ */ new Set(["function", "middleware", "trigger", "message"]);
+function defaultHistory(objType, override) {
+  return {
+    inherit: override?.inherit ?? true,
+    enabled: override?.enabled ?? !HISTORY_DEFAULT_OFF.has(objType),
+    limit: override?.limit ?? 100
+  };
+}
+
+export {
+  AUTHOR_KIND_NAME,
+  assertDefShape,
+  assertNoProtoKeys,
+  resolveMockKeys,
+  assertMockKeysResolved,
+  assertTestIds,
+  registerKind,
+  isRegisteredKind,
+  getKind,
+  encodeObject,
+  registeredKinds,
+  emptyMiddleware,
+  encodeTags,
+  defaultHistory
+};
+//# sourceMappingURL=chunk-4POWHT2K.js.map

package/dist/chunk-4Q2GN7NW.js

@@ -0,0 +1,192 @@
+import {
+  satisfiesRange
+} from "./chunk-2TFRR6JV.js";
+import {
+  configuredPackages,
+  declaredDependencies,
+  readProjectManifest,
+  readToolchainConfig
+} from "./chunk-JTUKLCXS.js";
+import {
+  fileInPackage,
+  loadFile,
+  moduleKind,
+  readInstalledManifestState
+} from "./chunk-3LDULPRE.js";
+import {
+  UsageError,
+  warn
+} from "./chunk-PTHVMXZI.js";
+
+// src/emit/toolchain-modules.ts
+var UNKNOWN_MODULE_VERSION = "unknown";
+function isEnabled(config) {
+  return config?.["enabled"] !== false;
+}
+function declaredToolchainPlugins(projectDir) {
+  const projectManifest = readProjectManifest(projectDir);
+  if (projectManifest === null) return [];
+  const declared = [];
+  const configured = new Set(configuredPackages(projectDir, projectManifest));
+  for (const pkg of declaredDependencies(projectManifest)) {
+    const state = readInstalledManifestState(projectDir, pkg);
+    if (state.kind === "absent") {
+      if (configured.has(pkg)) {
+        declared.push({
+          pkg,
+          version: UNKNOWN_MODULE_VERSION,
+          config: null,
+          pluginFile: null,
+          sdkPeerRange: null,
+          unreadable: `it is configured in this project's package.json but is not installed`
+        });
+      }
+      continue;
+    }
+    if (state.kind === "unreadable") {
+      declared.push({
+        pkg,
+        version: UNKNOWN_MODULE_VERSION,
+        config: null,
+        pluginFile: null,
+        sdkPeerRange: null,
+        unreadable: state.why
+      });
+      continue;
+    }
+    const manifest = state.manifest;
+    let kind;
+    try {
+      kind = moduleKind(pkg, manifest);
+    } catch (error) {
+      warn(
+        `${pkg} does not declare a module kind we recognize, so it is read as an ordinary package.`,
+        "module.kind-unknown",
+        [error instanceof Error ? error.message : String(error)]
+      );
+      continue;
+    }
+    if (kind !== "toolchain") continue;
+    const field = manifest["xanosdk"];
+    const declaredPath = field["plugin"];
+    const config = readToolchainConfig(projectDir, pkg, projectManifest);
+    declared.push({
+      pkg,
+      version: manifestVersion(manifest),
+      config,
+      pluginFile: typeof declaredPath === "string" && declaredPath !== "" ? fileInPackage(projectDir, pkg, declaredPath) : null,
+      sdkPeerRange: declaredSdkPeerRange(manifest)
+    });
+  }
+  return declared;
+}
+function declaredSdkPeerRange(manifest) {
+  const peers = manifest["peerDependencies"];
+  if (typeof peers !== "object" || peers === null) return null;
+  const range = peers["@xano/sdk"];
+  return typeof range === "string" && range.trim() !== "" ? range : null;
+}
+function sdkPeerSkew(manifest, sdkVersion) {
+  const range = declaredSdkPeerRange(manifest);
+  if (range === null) return null;
+  return satisfiesRange(sdkVersion, range) === false ? range : null;
+}
+function manifestVersion(manifest) {
+  const version = manifest["version"];
+  return typeof version === "string" && version !== "" ? version : UNKNOWN_MODULE_VERSION;
+}
+function assertSdkInPeerRange(declared, sdkVersion) {
+  const range = declared.sdkPeerRange;
+  if (range === null) return;
+  if (satisfiesRange(sdkVersion, range) !== false) return;
+  throw new UsageError(
+    `${declared.pkg} requires \`@xano/sdk\` ${range}, and this is ${sdkVersion} \u2014 so it would load, register, and apply nothing, which reads exactly like a module that had nothing to add.`,
+    {
+      suggestion: `Upgrade the SDK with \`npm install @xano/sdk@latest\`, or install a ${declared.pkg} built for this one. To carry on without it, set \`"${declared.pkg}": { "enabled": false }\` in this project's package.json "xanosdk" block, or run \`xanosdk marketplace remove ${declared.pkg}\` to drop it and its settings together.`
+    }
+  );
+}
+async function discoverToolchainPlugins(projectDir, opts) {
+  const loaded = [];
+  const skipped = [];
+  const unconfigured = [];
+  let sdkVersion = opts.sdkVersion;
+  const runningSdkVersion = async () => sdkVersion ??= (await import("./cli.js")).readVersion();
+  for (const declared of declaredToolchainPlugins(projectDir)) {
+    const override = opts.configOverride?.[declared.pkg];
+    const config = override === void 0 ? declared.config : { ...declared.config ?? {}, ...override };
+    if (!isEnabled(config)) continue;
+    if (declared.unreadable !== void 0) {
+      skipped.push({ pkg: declared.pkg, why: declared.unreadable });
+      continue;
+    }
+    if (declared.sdkPeerRange !== null) {
+      assertSdkInPeerRange(declared, await runningSdkVersion());
+    }
+    if (declared.pluginFile === null) {
+      skipped.push({
+        pkg: declared.pkg,
+        why: `its package.json names no "xanosdk": { "plugin": \u2026 } file we could find on disk`
+      });
+      continue;
+    }
+    const entry = await loadFile(declared.pluginFile);
+    if (entry.kind !== "loaded") {
+      skipped.push({ pkg: declared.pkg, why: entry.why });
+      continue;
+    }
+    const candidate = entry.exports["default"];
+    if (typeof candidate !== "object" || candidate === null) {
+      skipped.push({ pkg: declared.pkg, why: "its plugin file has no default export" });
+      continue;
+    }
+    if (candidate.kind !== "toolchain") {
+      skipped.push({
+        pkg: declared.pkg,
+        why: `its default export does not declare kind: "toolchain", but its package.json does`
+      });
+      continue;
+    }
+    if (declared.config === null) unconfigured.push(declared.pkg);
+    loaded.push({
+      pkg: declared.pkg,
+      version: declared.version,
+      plugin: candidate,
+      config: config ?? {}
+    });
+  }
+  if (skipped.length > 0) reportSkipped(skipped, opts.frozen);
+  if (opts.configuring !== true) reportUnconfigured(unconfigured);
+  return { loaded, skipped, unconfigured };
+}
+function reportUnconfigured(unconfigured) {
+  if (unconfigured.length === 0) return;
+  warn(
+    `${unconfigured.length === 1 ? "A toolchain module is" : `${unconfigured.length} toolchain modules are`} installed but never configured, so ${unconfigured.length === 1 ? "it runs on its" : "they run on their"} own defaults with nothing this project chose.`,
+    "module.unconfigured",
+    unconfigured.map((pkg) => `${pkg} \u2014 configure it with \`xanosdk marketplace install ${pkg}\``)
+  );
+}
+function reportSkipped(skipped, frozen) {
+  if (frozen) {
+    throw new UsageError(
+      `${skipped.length === 1 ? "A toolchain module" : `${skipped.length} toolchain modules`} could not be loaded, so whatever ${skipped.length === 1 ? "it checks was" : "they check were"} not checked \u2014 and this run was asked to verify, not to write:
+` + skipped.map((s) => `  ${s.pkg} \u2014 ${s.why}`).join("\n") + `
+
+Run \`xanosdk marketplace reinstall <package>\` to repair one that should still be here, or \`xanosdk marketplace remove <package>\` to drop it and its settings together. A plain \`npm uninstall\` leaves the settings behind, and a module this project still configures but no longer has installed is exactly what fails a frozen run.`
+    );
+  }
+  warn(
+    `${skipped.length === 1 ? "A toolchain module" : `${skipped.length} toolchain modules`} could not be loaded and ${skipped.length === 1 ? "was" : "were"} skipped.`,
+    "toolchain.load-failed",
+    skipped.map((s) => `${s.pkg} \u2014 ${s.why}`)
+  );
+}
+
+export {
+  UNKNOWN_MODULE_VERSION,
+  declaredToolchainPlugins,
+  sdkPeerSkew,
+  discoverToolchainPlugins
+};
+//# sourceMappingURL=chunk-4Q2GN7NW.js.map