@xano/sdk 1.0.0

package/dist/bundle.js

@@ -0,0 +1,153 @@
+import {
+  linkedTableOf,
+  tableRefOf
+} from "./chunk-EHP3WPEG.js";
+import {
+  deepEqual,
+  normalize
+} from "./chunk-L5JYN3NM.js";
+import {
+  STATEMENT_SURFACES,
+  sPathOf
+} from "./chunk-Q7DGTQ5G.js";
+import "./chunk-G554NZNI.js";
+import "./chunk-N5GKCWE5.js";
+import "./chunk-OXA6PSZT.js";
+import "./chunk-VAX3UZOY.js";
+import "./chunk-NZOWWHU5.js";
+import "./chunk-4BW2SG2N.js";
+import "./chunk-TTEIYD5P.js";
+import "./chunk-CIMQZRRE.js";
+import {
+  sha1Bytes
+} from "./chunk-OHX6MIUZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/bundle/catalog.ts
+var cached;
+function statementCatalog() {
+  if (cached) return cached;
+  const map = /* @__PURE__ */ new Map();
+  for (const [surface, storedName] of STATEMENT_SURFACES) {
+    const existing = map.get(storedName);
+    if (existing) {
+      map.set(storedName, { ...existing, surfaces: [...existing.surfaces, surface] });
+      continue;
+    }
+    map.set(storedName, {
+      storedName,
+      surface,
+      sPath: sPathOf(surface),
+      surfaces: [surface]
+    });
+  }
+  cached = map;
+  return map;
+}
+
+// src/bundle/walk.ts
+var SUB_STACK_KEYS = ["if", "elif", "else", "then", "run"];
+var SUB_STACK_LABELS = {
+  "mvp:conditional": { if: "then", elif: "elif", else: "else" },
+  "mvp:conditional_elif": { if: "then" },
+  "mvp:switch": { elif: "cases", else: "default" },
+  "mvp:switch_case": { if: "body" },
+  "mvp:try_catch": { if: "try", else: "catch", then: "finally" }
+};
+var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function runOf(value) {
+  if (!isRecord(value)) return null;
+  const run = value.run;
+  return Array.isArray(run) ? run : null;
+}
+function subStacks(raw) {
+  const context = raw?.context;
+  if (!isRecord(context)) return [];
+  const labels = (Object.hasOwn(SUB_STACK_LABELS, raw.name) ? SUB_STACK_LABELS[raw.name] : void 0) ?? {};
+  const found = [];
+  const push = (key, value) => {
+    const run = key === "run" ? Array.isArray(value) ? value : null : runOf(value);
+    if (!run) return;
+    found.push({ key, label: labels[key] ?? (key === "run" ? "body" : key), run });
+  };
+  for (const key of SUB_STACK_KEYS) {
+    if (Object.hasOwn(context, key)) push(key, context[key]);
+  }
+  for (const key of Object.keys(context)) {
+    if (!SUB_STACK_KEYS.includes(key)) push(key, context[key]);
+  }
+  return found;
+}
+function statementPath(segments) {
+  return segments.join(".");
+}
+function walk(run) {
+  const out = [];
+  const pending = [];
+  for (let i = run.length - 1; i >= 0; i--) {
+    pending.push({ raw: run[i], path: statementPath([i]), depth: 0 });
+  }
+  while (pending.length > 0) {
+    const frame = pending.pop();
+    out.push(frame);
+    const children = [];
+    for (const sub of subStacks(frame.raw)) {
+      for (let i = 0; i < sub.run.length; i++) {
+        children.push({
+          raw: sub.run[i],
+          path: statementPath([frame.path, sub.key, i]),
+          depth: frame.depth + 1
+        });
+      }
+    }
+    for (let i = children.length - 1; i >= 0; i--) pending.push(children[i]);
+  }
+  return out;
+}
+
+// src/bundle/hash.ts
+var isRecord2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function withoutIgnoredInputs(value) {
+  if (Array.isArray(value)) return value.map(withoutIgnoredInputs);
+  if (!isRecord2(value)) return value;
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [key, member] of Object.entries(value)) {
+    if (key === "input" && Array.isArray(member)) {
+      out[key] = member.filter((entry) => !(isRecord2(entry) && entry.ignore === true)).map(withoutIgnoredInputs);
+      continue;
+    }
+    out[key] = withoutIgnoredInputs(member);
+  }
+  return out;
+}
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (isRecord2(value)) {
+    const parts = Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`);
+    return `{${parts.join(",")}}`;
+  }
+  return value === void 0 ? "null" : JSON.stringify(value);
+}
+var HEX = "0123456789abcdef";
+function structuralHash(raw) {
+  const reduced = withoutIgnoredInputs(normalize(raw));
+  const bytes = sha1Bytes(canonicalJson(reduced));
+  let hex = "";
+  for (const byte of bytes) hex += HEX[byte >> 4] + HEX[byte & 15];
+  return hex;
+}
+export {
+  SUB_STACK_KEYS,
+  canonicalJson,
+  deepEqual,
+  linkedTableOf,
+  normalize,
+  statementCatalog,
+  statementPath,
+  structuralHash,
+  subStacks,
+  tableRefOf,
+  walk
+};
+//# sourceMappingURL=bundle.js.map

package/dist/capture-WAXPD7DR.js

@@ -0,0 +1,41 @@
+import {
+  fixtureDirForKind
+} from "./chunk-NWKXM5RD.js";
+import "./chunk-6MR5TI5V.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-XNCP4KYO.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/validate/capture.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { resolve as resolvePath, dirname } from "path";
+function captureFixtures(entries, outDir = "validate-out") {
+  const written = [];
+  const madeDirs = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry.fetched === void 0) continue;
+    const dir = fixtureDirForKind(entry.kind);
+    const path = dir === void 0 ? resolvePath(outDir, `${safeName(entry.name)}.json`) : resolvePath(outDir, dir, `${safeName(entry.name)}.json`);
+    const parent = dirname(path);
+    if (!madeDirs.has(parent)) {
+      mkdirSync(parent, { recursive: true });
+      madeDirs.add(parent);
+    }
+    writeFileSync(path, JSON.stringify(entry.fetched, null, 2) + "\n", "utf8");
+    written.push({ name: entry.name, path });
+  }
+  return written;
+}
+function safeName(name) {
+  const cleaned = name.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "");
+  return cleaned === "" ? "fixture" : cleaned;
+}
+export {
+  captureFixtures
+};
+//# sourceMappingURL=capture-WAXPD7DR.js.map

package/dist/chunk-27GWNP2I.js

@@ -0,0 +1,23 @@
+// src/statements/superseded.ts
+var SUPERSEDED_STATEMENTS = /* @__PURE__ */ new Map([
+  // Four crypto families, each phased forward with breaking changes between
+  // versions. The engine still registers a class for every one of them.
+  ["mvp:crypto_jwe_decode", "mvp:crypto_jwe_decode2"],
+  ["mvp:crypto_jwe_encode", "mvp:crypto_jwe_encode3"],
+  ["mvp:crypto_jwe_encode2", "mvp:crypto_jwe_encode3"],
+  ["mvp:crypto_jws_decode", "mvp:crypto_jws_decode2"],
+  ["mvp:crypto_jws_encode", "mvp:crypto_jws_encode2"],
+  // Retired outright — an old third-party log connector with no successor.
+  ["mvp:connect_ncscale_send_log", ""]
+]);
+function supersededBy(storedName, surfaceOf) {
+  const successor = SUPERSEDED_STATEMENTS.get(storedName);
+  if (successor === void 0 || successor === "") return null;
+  return surfaceOf(successor) ?? successor;
+}
+
+export {
+  SUPERSEDED_STATEMENTS,
+  supersededBy
+};
+//# sourceMappingURL=chunk-27GWNP2I.js.map

package/dist/chunk-2CMJZDCL.js

@@ -0,0 +1,177 @@
+import {
+  assertCanonical,
+  buildWorkspaceHistory,
+  encodeMiddlewareList
+} from "./chunk-5V5XU32D.js";
+import {
+  brandDef
+} from "./chunk-ERVIASGL.js";
+import {
+  registerKind
+} from "./chunk-4POWHT2K.js";
+import {
+  findNonJson,
+  nonJsonMessage
+} from "./chunk-H2V3N23D.js";
+import {
+  env
+} from "./chunk-OXA6PSZT.js";
+import {
+  describeEntry
+} from "./chunk-CIMQZRRE.js";
+
+// src/kinds/workspace-config.ts
+var LEGACY_REALTIME = {
+  hash: "",
+  mode: "",
+  enabled: false,
+  channels: []
+};
+var DEFAULT_DOCUMENTATION = {
+  token: "",
+  whitelist: {},
+  require_token: false
+};
+var DEFAULT_PREFERENCES = {
+  allow_push: false,
+  track_performance: true,
+  use_internal_docs: false
+};
+var DEFAULT_SETTINGS = {
+  ai_enabled: false,
+  ai_settings: {
+    providers: {
+      google: { model: "", api_key: "" },
+      openai: { model: "", api_key: "" },
+      anthropic: { model: "", api_key: "" },
+      "azure-openai": { model: "", api_key: "", base_url: "", api_version: "" }
+    },
+    default_provider: "free"
+  },
+  hide_xano_agent: false
+};
+function mergeOverDefaults(defaults, authored, field = "") {
+  return mergeOver(
+    defaults,
+    authored ?? {},
+    field
+  );
+}
+function mergeOver(base, over, path) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(over)) {
+    const under = out[key];
+    const at = path === "" ? key : `${path}.${key}`;
+    out[key] = isPlainRecord(under) && isPlainRecord(value) ? mergeOver(under, value, at) : plainClone(value, at);
+  }
+  return out;
+}
+function plainClone(value, at) {
+  const found = findNonJson(value);
+  if (found !== void 0) {
+    const path = found.path === "" ? at : found.path.startsWith("[") ? `${at}${found.path}` : `${at}.${found.path}`;
+    throw new Error(nonJsonMessage("workspaceConfig", path, found.value));
+  }
+  return structuredClone(value);
+}
+function isPlainRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function encodeWorkspaceEnv(env2) {
+  return Object.entries(env2).map(([name, value]) => {
+    if (value === void 0) value = "";
+    if (typeof value !== "string") {
+      throw new Error(
+        `workspaceConfig: env "${name}" is ${value === null ? "null" : typeof value}; an env value is a string. Write \`String(value)\`, or \`""\` to leave it for the backend's .env to supply.`
+      );
+    }
+    return { name, value, market_item: [] };
+  });
+}
+function encodeWorkspaceMiddleware(m) {
+  return {
+    function_pre: encodeMiddlewareList(m.function?.pre),
+    function_post: encodeMiddlewareList(m.function?.post),
+    query_pre: encodeMiddlewareList(m.query?.pre),
+    query_post: encodeMiddlewareList(m.query?.post),
+    task_pre: encodeMiddlewareList(m.task?.pre),
+    task_post: encodeMiddlewareList(m.task?.post),
+    tool_pre: encodeMiddlewareList(m.tool?.pre),
+    tool_post: encodeMiddlewareList(m.tool?.post)
+  };
+}
+function encodeWorkspaceDocumentation(doc) {
+  const { token, ...rest } = doc;
+  return typeof token === "string" && token !== "" ? { ...rest, token } : rest;
+}
+function encodeWorkspaceConfig(def) {
+  if (def.name === void 0 || def.name === null) {
+    throw new Error(
+      'workspace: no name. `workspaceConfig({ name })` is optional because the config inherits the name from `workspace("\u2026")` \u2014 so either start from `workspace("my-app")` or give this config an explicit `name`.'
+    );
+  }
+  assertCanonical(`workspace "${def.name}"`, def.canonical);
+  return {
+    name: def.name,
+    description: def.description ?? "",
+    canonical: def.canonical ?? "",
+    use_xdo: def.use_xdo ?? false,
+    preferences: mergeOverDefaults(DEFAULT_PREFERENCES, def.preferences, "preferences"),
+    // PRESENCE-ONLY, both of them. `?? DEFAULT` here is what made the wipe
+    // expressible: an author who deleted a secret-bearing block from source got
+    // `{token:"", whitelist:{}, require_token:false}` sent to the target, which
+    // is a Private doc site turned public with nothing said. Omission now means
+    // "leave the live block alone", which is what an author deleting it meant.
+    ...def.realtime !== void 0 ? { realtime: def.realtime } : {},
+    ...def.documentation !== void 0 ? { documentation: encodeWorkspaceDocumentation(def.documentation) } : {},
+    swagger: def.swagger ?? false,
+    ...def.middleware !== void 0 ? { middleware: encodeWorkspaceMiddleware(def.middleware) } : {},
+    ...def.history !== void 0 ? { history: buildWorkspaceHistory(def.history) } : {},
+    env: def.env ? encodeWorkspaceEnv(def.env) : [],
+    settings: mergeOverDefaults(DEFAULT_SETTINGS, def.settings, "settings"),
+    // Presence-preserving: each key is written only when the author set it, and
+    // each nested optional likewise, so a pulled workspace re-exports to its own
+    // bytes whether or not the engine happened to store the `?=` default.
+    ...def.use_custom_names !== void 0 ? { use_custom_names: def.use_custom_names } : {},
+    ...def.defaults !== void 0 ? { defaults: { ...def.defaults } } : {},
+    ...def.datasources !== void 0 ? { datasources: def.datasources.map((d) => ({ ...d })) } : {},
+    ...def.datasource_live !== void 0 ? { datasource_live: { ...def.datasource_live } } : {}
+  };
+}
+var workspaceKind = {
+  name: "workspace",
+  payloadKey: "workspace",
+  encode: encodeWorkspaceConfig
+};
+registerKind(workspaceKind);
+function workspaceConfig(def) {
+  return brandDef(def, "workspace");
+}
+function typedEnv(config) {
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    throw new Error(
+      `typedEnv() takes the workspaceConfig({ env }) it reads names from \u2014 got ${describeEntry(config)}.`
+    );
+  }
+  const declared = config.env;
+  if (declared !== void 0 && declared !== null && (typeof declared !== "object" || Array.isArray(declared))) {
+    throw new Error(`typedEnv(): the config's \`env\` must be a { NAME: value } record \u2014 got ${describeEntry(declared)}.`);
+  }
+  const out = {};
+  for (const name of Object.keys(config.env ?? {})) {
+    Object.defineProperty(out, name, { get: () => env(name), enumerable: true });
+  }
+  return out;
+}
+
+export {
+  LEGACY_REALTIME,
+  DEFAULT_DOCUMENTATION,
+  DEFAULT_PREFERENCES,
+  DEFAULT_SETTINGS,
+  encodeWorkspaceConfig,
+  workspaceKind,
+  workspaceConfig,
+  typedEnv
+};
+//# sourceMappingURL=chunk-2CMJZDCL.js.map

package/dist/chunk-2EZ3ZJZZ.js

@@ -0,0 +1,302 @@
+// src/workspace/diagnostics.ts
+var ENV = "stack.env-undeclared";
+var MIXED = "condition.mixed";
+var DOCS_PUBLIC = "api-group.docs-public";
+var ELICIT = "mcp.write-before-elicit";
+var VALUES = [
+  "expression.ignore-empty-static-empty",
+  "value.interpolated-object",
+  "value.regex-operands-reversed",
+  "value.timezone-unknown",
+  "field.default-not-text",
+  "field.enum-default-not-a-value",
+  "field.email-default-invalid",
+  "field.input-default-invalid",
+  "value.obj-zero-based-numeric-keys",
+  "value.int-out-of-range"
+];
+var STACK = /* @__PURE__ */ (() => [
+  ENV,
+  MIXED,
+  "stack.blank-table",
+  "stack.inp-undeclared",
+  "stack.unbound-var",
+  "storage.stored-file-input",
+  "stack.password-input-double-hash",
+  "stack.zip-password-absent",
+  "stack.to-throw-isolated-var",
+  "statement.reserved-input-name",
+  "statement.omitted-input",
+  "db.bulk-update-partial-item",
+  "db.internal-column-read",
+  "db.query-output-mixed-roots",
+  "db.query-output-totals-off",
+  "db.query-output-joined-column",
+  "db.query-output-unknown-column",
+  "db.output-unknown-column",
+  "db.query-output-not-envelope-rooted",
+  "db.query-envelope-read-unpaged",
+  "db.safe-ref-match-arg",
+  "db.null-match-arg",
+  "db.filter-operand-invalid",
+  "search.request-only-filter",
+  "switch.missing-break",
+  "stack.expect-outside-test",
+  "realtime.publish-unknown-server",
+  "realtime.publish-unknown-channel",
+  "redis.ratelimit-no-error",
+  "agent.args-placeholder-unpassed",
+  ...VALUES
+])();
+var NO_CALLER = ["stack.auth-no-caller", "stack.auth-null-host"];
+var TEST_LIVE = "test.live-datasource";
+var TOOLSET = /* @__PURE__ */ (() => [ENV, MIXED, ...VALUES, "toolset.tool-reads-auth-ungated", "toolset.tool-ref-zero"])();
+var ALLOWABLE_WARNINGS = /* @__PURE__ */ (() => ({
+  query: [
+    "query.path-segment-candidate",
+    TEST_LIVE,
+    ...STACK,
+    ...NO_CALLER,
+    "query.auth-table-unflagged",
+    "query.input-name-mangled",
+    "middleware.post-merge-list",
+    "response.unbound-return",
+    "mcp.elicit-outside-mcp"
+  ],
+  function: [TEST_LIVE, ...STACK, "function.reserved-input-name", "response.unbound-return"],
+  task: [...STACK, ...NO_CALLER, "mcp.elicit-outside-mcp"],
+  middleware: [
+    TEST_LIVE,
+    ...STACK,
+    "middleware.input-never-bound",
+    "middleware.inp-unresolvable",
+    "middleware.auth-null-host",
+    "middleware.envelope-unnested",
+    "middleware.post-reads-request"
+  ],
+  trigger: [
+    ...STACK,
+    "stack.auth-no-caller",
+    "trigger.search-bare-column",
+    "trigger.search-unknown-column",
+    "trigger.no-action",
+    "trigger.unbound",
+    "realtime.gate-denies-everyone",
+    "realtime.deliver-falsy-return",
+    "realtime.join-deliver-object-response",
+    "realtime.deliver-without-per-recipient"
+  ],
+  tool: [...STACK, ELICIT, "mcp.elicit-duplicate-key", "tool.output-mismatch"],
+  prompt: [...STACK, ELICIT, "mcp.elicit-duplicate-key", "mcp.prompt-no-response"],
+  resource: [...STACK, ELICIT, "mcp.elicit-duplicate-key"],
+  agent: TOOLSET,
+  mcp_server: [...TOOLSET, "toolset.primitive-reads-auth-ungated"],
+  message: [...STACK, "realtime.deliver-explicit"],
+  workflow_test: ["workflow-test.live-datasource", ...STACK],
+  realtime_server: ["realtime.server-disabled"],
+  channel: ["realtime.conversation-no-limit", "realtime.per-recipient-without-deliver", ...VALUES],
+  microservice: [ENV],
+  api_group: [DOCS_PUBLIC, "api-group.cors-origin-unmatchable", "api-group.cors-no-origins", "api-group.cors-wildcard-origin", "api-group.cors-no-methods"],
+  table: [
+    "table.column-name-unusable",
+    ...VALUES,
+    "table.view-id-not-uuid",
+    "table.view-duplicate",
+    "table.view-unknown-column",
+    "table.reserved-column-name",
+    "field.vector-not-nullable"
+  ],
+  addon: [...VALUES, "search.request-only-filter", "db.filter-operand-invalid"],
+  knowledge: [
+    "knowledge.agents-md-mode",
+    "knowledge.newline",
+    "knowledge.empty-body",
+    "knowledge.refs-include-source",
+    "knowledge.refs-symlink-skipped"
+  ],
+  // The workspace config's allow accepts a code on EVERY def, so it offers only
+  // the two whose subject is the workspace's own declaration.
+  workspace: [ENV, DOCS_PUBLIC]
+}))();
+function allowableWarnings(kindName) {
+  return ALLOWABLE_WARNINGS[kindName] ?? [];
+}
+var ADVISORY_WARNINGS = [
+  "query.path-segment-candidate",
+  ENV,
+  MIXED,
+  ELICIT,
+  "workflow-test.live-datasource",
+  TEST_LIVE,
+  "statement.omitted-input",
+  "realtime.server-disabled",
+  DOCS_PUBLIC
+];
+var WORKSPACE_WIDE_WARNINGS = ["lock.same-name-siblings"];
+var consoleSink = (diagnostic) => {
+  console.warn(formatDiagnostic(diagnostic));
+};
+var SINK_KEY = /* @__PURE__ */ Symbol.for("xanosdk.diagnostics.sink");
+function sink(diagnostic) {
+  (globalThis[SINK_KEY] ?? consoleSink)(diagnostic);
+}
+function setDiagnosticSink(next) {
+  const slot = globalThis;
+  const previous = slot[SINK_KEY] ?? consoleSink;
+  slot[SINK_KEY] = next ?? consoleSink;
+  return previous;
+}
+function formatDiagnostic(diagnostic) {
+  return `xanosdk: ${diagnostic.message}`;
+}
+var DiagnosticError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+  }
+  details;
+  name = "DiagnosticError";
+  code = "SDK_EXPORT_INVALID";
+};
+function isDiagnosticError(err) {
+  if (err instanceof DiagnosticError) return true;
+  const e = err;
+  return err instanceof Error && e?.name === "DiagnosticError" && e.code === "SDK_EXPORT_INVALID" && Array.isArray(e.details);
+}
+function emitDiagnostic(diagnostic) {
+  if (diagnostic.severity === "error") throw new DiagnosticError(formatDiagnostic(diagnostic), [diagnostic]);
+  sink(diagnostic);
+}
+var DiagnosticBag = class {
+  /**
+   * `strict`: report every warning as an error, so the build fails instead of
+   * printing.
+   *
+   * Warnings here are the shapes that deploy clean and then do the wrong thing —
+   * a `bulk.update` zero-filling the columns an item omits, an `ignoreEmpty`
+   * that returns the whole table. They stay warnings by default because each has
+   * a legitimate use, and the author who means it should not have to work around
+   * a guard. But the audience for this SDK is largely an agent that never reads
+   * stderr, and CI has no way to notice a message nobody fails on. `strict`
+   * gives a pipeline one switch that turns "printed something" into "did not
+   * ship".
+   *
+   * Scope: the diagnostics an EXPORT collects. A guard that runs while a
+   * statement is being built ({@link emitDiagnostic}) has already had its say by
+   * then — those throw or warn on the spot, at the line that caused them.
+   */
+  constructor(strict = false) {
+    this.strict = strict;
+  }
+  strict;
+  items = [];
+  acceptedItems = [];
+  skippedCodes = /* @__PURE__ */ new Set();
+  add(diagnostic) {
+    this.items.push(diagnostic);
+  }
+  /** Record an error; `subject` (the encoded object it is about) names its def. An error is never accepted. */
+  error(code, message, subject) {
+    this.add({ severity: "error", code, message, ...this.about(subject) });
+  }
+  /**
+   * Record a warning. `subject` is the encoded object it is about; a warning the
+   * author accepted on that object's def (`diagnostics: { allow }`, see
+   * {@link DefDiagnostics}) is dropped here, at both settings.
+   */
+  warn(code, message, subject) {
+    if (this.isAccepted(code, () => message, subject)) return;
+    this.add({ severity: "warning", code, message, ...this.about(subject) });
+  }
+  /**
+   * Whether the author accepted `code` on `subject` — recorded in
+   * {@link accepted} when so. For a check that raises one warning for many
+   * defs: it asks per def, and leaves out the ones that accepted it. `message`
+   * is built only for an accepted finding.
+   */
+  isAccepted(code, message, subject) {
+    if (this.accepts?.(code, subject) !== true) return false;
+    this.acceptedItems.push({ severity: "warning", code, message: message(), ...this.about(subject) });
+    return true;
+  }
+  /** Whether the author accepted `code` on `subject`; set by the export that owns the defs, read through {@link isAccepted}. */
+  accepts;
+  /** The def an encoded `subject` was registered from; set by the export that owns the defs. */
+  describe;
+  about(subject) {
+    const described = subject === void 0 ? void 0 : this.describe?.(subject);
+    return described === void 0 ? {} : { subject: described };
+  }
+  /** The warnings an allow accepted, in the order they were found. */
+  accepted() {
+    return [...this.acceptedItems];
+  }
+  /**
+   * Record that the check behind `code` did not run in this export, so an
+   * allow naming it is not reported unused — it had nothing to accept here.
+   */
+  skipped(code) {
+    this.skippedCodes.add(code);
+  }
+  /** Whether the check behind `code` was {@link skipped}. */
+  wasSkipped(code) {
+    return this.skippedCodes.has(code);
+  }
+  /** Report something the author must know, which is not a defect. See the module note. */
+  notice(code, message) {
+    this.add({ severity: "notice", code, message });
+  }
+  /** Everything recorded so far, in the order it was found. */
+  all() {
+    return [...this.items];
+  }
+  /**
+   * Emit the warnings, then throw if anything was an error. Warnings are
+   * emitted first: an author fixing the error still wants to see the rest of
+   * what the build found. Under `strict` a warning IS an error — it is reported
+   * in the thrown failure only, since sinking it as well printed its text
+   * twice. A notice is printed at both settings and fails at neither.
+   */
+  flush() {
+    for (const item of this.items) {
+      if (item.severity === "notice" || item.severity === "warning" && !this.strict) sink(item);
+    }
+    const errors = this.items.filter(
+      (item) => item.severity === "error" || this.strict && item.severity === "warning"
+    );
+    if (errors.length === 0) return;
+    const promoted = errors.filter((item) => item.severity === "warning").length;
+    const strictNote = promoted > 0 ? " (`strict`: warnings are errors)" : "";
+    if (errors.length === 1) {
+      throw new DiagnosticError(`${formatDiagnostic(errors[0])}${strictNote}`, errors);
+    }
+    const total = problemCount(errors);
+    const hard = total - promoted;
+    const headline = promoted === 0 ? `export failed with ${total} errors` : `export stopped: ${total} findings fail \`strict\`` + (hard === 0 ? " (warnings are errors)" : ` (${hard} error${hard === 1 ? "" : "s"}; \`strict\` makes ${promoted === 1 ? "1 warning an error" : `${promoted} warnings errors`})`);
+    throw new DiagnosticError(`xanosdk: ${headline}.
+${numberedList(errors)}`, errors);
+  }
+};
+function problemCount(items) {
+  return items.reduce((n, item) => n + (item.unlisted ?? 1), 0);
+}
+function numberedList(items) {
+  let n = 0;
+  return items.map((item) => item.unlisted === void 0 ? `  ${++n}. ${item.message}` : `     ${item.message}`).join("\n");
+}
+
+export {
+  ALLOWABLE_WARNINGS,
+  allowableWarnings,
+  ADVISORY_WARNINGS,
+  WORKSPACE_WIDE_WARNINGS,
+  setDiagnosticSink,
+  formatDiagnostic,
+  DiagnosticError,
+  isDiagnosticError,
+  emitDiagnostic,
+  DiagnosticBag,
+  problemCount,
+  numberedList
+};
+//# sourceMappingURL=chunk-2EZ3ZJZZ.js.map