@xano/sdk 1.0.0

package/dist/chunk-C6RIMRU4.js

@@ -0,0 +1,187 @@
+import {
+  hasString,
+  listAnswer,
+  notTheAnswer,
+  writeTransportFailure
+} from "./chunk-6PBR37LN.js";
+import {
+  SENT_AFTERMATH,
+  fetchOrExplain,
+  readBodyText,
+  safeHttpFailure,
+  withWriteStatusAftermath
+} from "./chunk-YLDALTWZ.js";
+import {
+  isNonPublicColumn
+} from "./chunk-HVRUQXGD.js";
+
+// src/deploy/table.ts
+var TIMEOUT_MS = 3e4;
+function asString(v) {
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+function asNumber(v) {
+  return typeof v === "number" ? v : void 0;
+}
+function projectTable(raw) {
+  const id = asNumber(raw.id);
+  const name = asString(raw.name);
+  const guid = asString(raw.guid);
+  if (id === void 0 || name === void 0 || guid === void 0) return [];
+  return [{ id, name, guid, guardedColumns: guardedIn(raw.schema) }];
+}
+function guardedIn(schema, prefix = "") {
+  if (!Array.isArray(schema)) return [];
+  return schema.flatMap((col) => {
+    if (col === null || typeof col !== "object") return [];
+    const c = col;
+    const colName = asString(c.name);
+    if (colName === void 0) return [];
+    const path = `${prefix}${colName}`;
+    return isNonPublicColumn(c) ? [path] : guardedIn(c.children, `${path}.`);
+  });
+}
+function base(workspaceId) {
+  return `/api:meta/workspace/${workspaceId}/table`;
+}
+var PER_PAGE = 1e3;
+var isTableRow = (row) => typeof row.id === "number" && hasString(row, "name") && hasString(row, "guid");
+async function listTables(auth, opts) {
+  const out = [];
+  for (let page = 1; ; page++) {
+    const path = `${base(opts.workspaceId)}?page=${page}&per_page=${PER_PAGE}`;
+    const res = await metaFetch(auth, path, "list tables", { method: "GET" }, opts.base);
+    const text = await readText(res, "list tables", opts.binding);
+    const { rows } = listAnswer(text, "list tables", routeUrl(auth, path, opts.base).href, isTableRow, { safe: true });
+    for (const r of rows) out.push(...projectTable(r));
+    if (rows.length < PER_PAGE) return out;
+  }
+}
+async function someTableRow(auth, opts, match) {
+  for (let page = 1; ; page++) {
+    const path = `${base(opts.workspaceId)}/${opts.tableId}/content?page=${page}&per_page=${PER_PAGE}`;
+    const res = await metaFetch(auth, path, "read table rows", { method: "GET" }, opts.base);
+    const text = await readText(res, "read table rows", opts.binding);
+    const { rows } = listAnswer(text, "read table rows", routeUrl(auth, path, opts.base).href, () => true, { safe: true });
+    if (rows.some(match)) return true;
+    if (rows.length < PER_PAGE) return false;
+  }
+}
+async function tableRowIds(auth, opts) {
+  const ids = /* @__PURE__ */ new Set();
+  for (let page = 1; ; page++) {
+    const path = `${base(opts.workspaceId)}/${opts.tableId}/content?page=${page}&per_page=${PER_PAGE}`;
+    const res = await metaFetch(auth, path, "read table rows", { method: "GET" }, opts.base);
+    const text = await readText(res, "read table rows", opts.binding);
+    const { rows } = listAnswer(text, "read table rows", routeUrl(auth, path, opts.base).href, () => true, { safe: true });
+    for (const row of rows) if (row.id !== void 0 && row.id !== null) ids.add(String(row.id));
+    if (rows.length < PER_PAGE) return ids;
+  }
+}
+async function countTableRows(auth, opts) {
+  const path = `${base(opts.workspaceId)}/${opts.tableId}/content?page=1&per_page=1`;
+  const res = await metaFetch(auth, path, "count table rows", { method: "GET" }, opts.base);
+  const text = await readText(res, "count table rows", opts.binding);
+  const { envelope } = listAnswer(text, "count table rows", routeUrl(auth, path, opts.base).href, () => true, { safe: true });
+  const total = envelope?.itemsTotal;
+  return typeof total === "number" && Number.isInteger(total) && total >= 0 ? total : void 0;
+}
+function tableRowCounter(auth, opts) {
+  let listed;
+  return async ({ name, guid }) => {
+    listed ??= listTables(auth, opts).catch(() => void 0);
+    const tables = await listed;
+    const here = (guid === void 0 ? void 0 : tables?.find((t) => t.guid === guid)) ?? tables?.find((t) => t.name === name);
+    if (here === void 0) return void 0;
+    return countTableRows(auth, { ...opts, tableId: here.id }).catch(() => void 0);
+  };
+}
+async function truncateTable(auth, opts) {
+  const path = `${base(opts.workspaceId)}/${opts.tableId}/truncate?reset=true`;
+  const res = await metaFetch(auth, path, "truncate table", { method: "DELETE" }, opts.base);
+  const text = await readBodyText(res, "truncate table", { aftermath: SENT_AFTERMATH });
+  if (!res.ok) {
+    const head = safeHttpFailure("truncate table", res, text, binding(auth, opts.workspaceId, opts.base));
+    throw new Error(withWriteStatusAftermath(head, res.status));
+  }
+  writeAcknowledged(text, "truncate table", routeUrl(auth, path, opts.base).href);
+}
+function writeAcknowledged(text, action, url) {
+  if (text.trim() === "") return;
+  try {
+    JSON.parse(text);
+  } catch {
+    throw notTheAnswer(action, text, url, { safe: true, write: true });
+  }
+}
+async function insertTableRows(auth, opts) {
+  if (opts.rows.length === 0) return;
+  const path = `${base(opts.workspaceId)}/${opts.tableId}/content/bulk`;
+  const res = await metaFetch(
+    auth,
+    path,
+    "insert table rows",
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ items: opts.rows })
+    },
+    opts.base
+  );
+  if (!res.ok) {
+    await readBodyText(res, "insert table rows", { aftermath: SENT_AFTERMATH });
+    const head = safeHttpFailure("insert table rows", res, "", binding(auth, opts.workspaceId, opts.base));
+    throw new Error(withWriteStatusAftermath(head, res.status));
+  }
+  writeAcknowledged(await readBodyText(res, "insert table rows", { aftermath: SENT_AFTERMATH }), "insert table rows", routeUrl(auth, path, opts.base).href);
+}
+function routeUrl(auth, path, base2) {
+  return base2 !== void 0 ? new URL(`${base2.replace(/\/$/, "")}${path}`) : new URL(path, auth.instance);
+}
+async function metaFetch(auth, path, action, init, base2) {
+  const url = routeUrl(auth, path, base2);
+  return fetchOrExplain(
+    url.href,
+    {
+      ...init,
+      headers: {
+        accept: "application/json",
+        Authorization: `Bearer ${auth.access_token}`,
+        ...init?.headers ?? {}
+      },
+      signal: AbortSignal.timeout(TIMEOUT_MS)
+    },
+    action,
+    TIMEOUT_MS
+  ).catch((err) => {
+    throw (init?.method ?? "GET").toUpperCase() !== "GET" ? writeTransportFailure(err) : err;
+  });
+}
+function binding(auth, workspaceId, base2) {
+  return {
+    boundWorkspaceId: auth.workspaceId,
+    instance: auth.instance,
+    profile: auth.profile,
+    addressedWorkspaceId: workspaceId,
+    credentialType: auth.credentialType,
+    tenantHost: base2 !== void 0
+  };
+}
+async function readText(res, action, bind) {
+  const text = await readBodyText(res, action);
+  if (!res.ok) throw Object.assign(new Error(safeHttpFailure(action, res, text, bind)), { status: res.status });
+  return text;
+}
+
+export {
+  projectTable,
+  guardedIn,
+  listTables,
+  someTableRow,
+  tableRowIds,
+  countTableRows,
+  tableRowCounter,
+  truncateTable,
+  insertTableRows
+};
+//# sourceMappingURL=chunk-C6RIMRU4.js.map

package/dist/chunk-CGVQZXYG.js

@@ -0,0 +1,263 @@
+import {
+  clearEphemeralLanding,
+  ephemeralLandedOn,
+  ephemeralStatePath,
+  recordEphemeralLanding
+} from "./chunk-5QU2P5CA.js";
+import {
+  contextFlags
+} from "./chunk-NAQDMEHV.js";
+import {
+  backendDirIn
+} from "./chunk-5A2PLKZB.js";
+import {
+  forgetPrunedInLockFile,
+  readLockFile,
+  recordLandingInLockFile,
+  writeLockFile
+} from "./chunk-P2HAGF6H.js";
+import {
+  destinationKey,
+  isEphemeralDestinationKey,
+  landedIdentities,
+  landedOn,
+  withStoredColumns,
+  withoutLanding
+} from "./chunk-TLQE7ZN3.js";
+import {
+  displayPath,
+  info,
+  warn
+} from "./chunk-PTHVMXZI.js";
+import {
+  displayLockKey
+} from "./chunk-6MR5TI5V.js";
+import {
+  shellQuote
+} from "./chunk-5ZSO4T2G.js";
+
+// src/emit/landing-record.ts
+import { resolve, dirname, join, basename } from "path";
+import { existsSync } from "fs";
+import { execFileSync } from "child_process";
+function landingLockPath(args, opts = {}) {
+  if (args.noLock) return void 0;
+  if (args.lockPath !== void 0) return resolve(args.lockPath);
+  if (opts.entryFile !== void 0) return join(dirname(resolve(opts.entryFile)), "xano.lock");
+  if (opts.fromProject === false) return void 0;
+  const lock = join(backendDirIn(process.cwd()), "xano.lock");
+  return existsSync(lock) ? lock : void 0;
+}
+function landedRecordFor(lockPath, destKey) {
+  if (isEphemeralDestinationKey(destKey)) {
+    const dir = process.cwd();
+    return { record: ephemeralLandedOn(dir, destKey), file: displayPath(ephemeralStatePath(dir)), local: true };
+  }
+  return { record: landedOn(readLockFile(lockPath), destKey), file: displayPath(lockPath), local: false };
+}
+function unvouchedIdentities(identities, lock, lockPath) {
+  const keys = Object.keys(identities);
+  if (lock === void 0 || keys.length === 0) return keys.map((k) => displayLockKey(k));
+  const exact = (key) => {
+    const entry = lock.objects[key];
+    if (entry?.guid !== identities[key].guid) return false;
+    return !key.startsWith("toolset:") || entry.type === "agent" === (identities[key].type === "agent");
+  };
+  const matched = keys.filter(exact);
+  if (matched.length === 0) return keys.map((k) => displayLockKey(k));
+  const rest = keys.filter((k) => !exact(k));
+  if (rest.length === 0) return [];
+  const held = /* @__PURE__ */ new Set([
+    ...Object.values(lock.objects).flatMap((e) => e.guid === void 0 ? [] : [e.guid]),
+    ...Object.values(lock.landed ?? {}).flatMap((record) => Object.values(record).map((e) => e.guid))
+  ]);
+  const inHistory = rest.length <= HISTORY_LOOKUPS && lockPath !== void 0 ? guidInLockHistory(lockPath) : void 0;
+  return rest.filter((k) => {
+    const guid = identities[k].guid;
+    return !held.has(guid) && inHistory?.(guid) !== true;
+  }).map((k) => displayLockKey(k));
+}
+var HISTORY_LOOKUPS = 25;
+function guidInLockHistory(lockPath) {
+  const git = (...argv) => execFileSync("git", argv, {
+    cwd: dirname(resolve(lockPath)),
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: 5e3,
+    encoding: "utf8"
+  }).trim();
+  const file = `./${basename(lockPath)}`;
+  try {
+    if (git("rev-parse", "--is-shallow-repository") === "true") return void 0;
+    if (git("log", "-1", "--format=%H", "--", file) === "") return void 0;
+  } catch {
+    return void 0;
+  }
+  return (guid) => {
+    try {
+      return git("log", "-1", "--format=%H", `-S${JSON.stringify(guid)}`, "--", file) !== "";
+    } catch {
+      return false;
+    }
+  };
+}
+function recordForeignLanding(opts) {
+  let lock;
+  if (opts.lockPath !== void 0 && existsSync(opts.lockPath)) {
+    try {
+      lock = readLockFile(opts.lockPath);
+    } catch {
+      lock = void 0;
+    }
+  } else if (opts.dest.kind !== "ephemeral") {
+    return null;
+  }
+  const identities = landedIdentities(opts.bundle);
+  const unvouched = unvouchedIdentities(identities, lock, opts.lockPath);
+  const ours = lock !== void 0 && Object.keys(identities).length > 0 && unvouched.length === 0;
+  if (!ours && opts.mode === "merge") return null;
+  const removed = ours ? { ...removedByGuid(lock, opts.removedGuids), ...opts.removed ?? {} } : {};
+  return recordLanding({
+    lockPath: opts.lockPath,
+    instance: opts.instance,
+    dest: opts.dest,
+    update: {
+      mode: opts.mode,
+      identities: ours ? withStoredColumns(identities, opts.stored) : {},
+      ...Object.keys(removed).length > 0 ? { removed } : {}
+    },
+    ...opts.removedBy !== void 0 ? { removedBy: opts.removedBy } : {},
+    foreign: !ours,
+    ...ours ? {} : { unmatched: unvouched },
+    ...opts.unreadable === true ? { unreadable: true } : {}
+  });
+}
+function removedByGuid(lock, guids) {
+  if (lock === void 0 || guids === void 0 || guids.length === 0) return {};
+  const gone = new Set(guids);
+  const out = {};
+  for (const [key, entry] of Object.entries(lock.objects)) {
+    if (entry.guid !== void 0 && gone.has(entry.guid)) out[key] = { guid: entry.guid };
+  }
+  return out;
+}
+function recordLanding(opts) {
+  const destination = destinationKey(opts.instance, opts.dest);
+  const cleared = opts.foreign === true && opts.update.mode === "replace";
+  const why = unmatchedPhrase(opts.unmatched);
+  const serves = opts.unreadable === true ? `objects this project cannot confirm as its own (the release archive could not be read back)` : `another source's objects${why}`;
+  const unmatched = opts.foreign === true ? [...opts.unmatched ?? []] : [];
+  if (opts.dest.kind === "ephemeral") {
+    const dir = process.cwd();
+    const shown2 = displayPath(ephemeralStatePath(dir));
+    try {
+      const result2 = recordEphemeralLanding(dir, destination, opts.update);
+      if (cleared && result2.changed) {
+        info(
+          `Cleared this project's landing record for ${destination} in ${shown2} \u2014 it now serves ${serves}. Until this project lands there again, a \`--keep-data\` deploy lists what it removes there as another source's, and \`xanosdk deploy --to tenant:${shellQuote(opts.dest.name)} --prune${contextFlags()}\` refuses to delete any of it.`
+        );
+      }
+      let lockDropped2 = [];
+      if (opts.lockPath !== void 0 && opts.update.removed !== void 0) {
+        try {
+          lockDropped2 = forgotPruned(displayPath(opts.lockPath), forgetPrunedInLockFile(opts.lockPath, opts.update), opts.removedBy);
+        } catch (err) {
+          unforgotten(displayPath(opts.lockPath), err);
+        }
+      }
+      return { destination, file: shown2, recorded: result2.recorded, changed: result2.changed, cleared, lockDropped: lockDropped2, unmatched };
+    } catch (err) {
+      unrecorded(shown2, err);
+      return null;
+    }
+  }
+  if (opts.lockPath === void 0) return null;
+  let result;
+  try {
+    result = recordLandingInLockFile(opts.lockPath, destination, opts.update);
+  } catch (err) {
+    unrecorded(displayPath(opts.lockPath), err);
+    return null;
+  }
+  if (result === void 0) return null;
+  const shown = displayPath(opts.lockPath);
+  if (result.changed) {
+    info(
+      cleared ? `Cleared this project's landing record for ${destination} in ${shown} \u2014 it now serves ${serves}, so \`--prune\` there deletes nothing until this project lands again. Commit it.` : `Recorded what this project landed on ${destination} in ${shown} \u2014 commit it: \`--prune\` deletes only what this record names.`
+    );
+  } else if (cleared) {
+    info(
+      `Recorded nothing for ${destination} in ${shown} \u2014 ` + (opts.unreadable === true ? `what landed could not be checked against this project's lock (the release archive could not be read back), so` : `what landed does not match this project's lock (another source's objects${why}), so`) + ` \`--prune\` from here deletes nothing there until this project lands again.`
+    );
+  }
+  const lockDropped = forgotPruned(shown, result.forgotten, opts.removedBy);
+  return { destination, file: shown, recorded: result.recorded, changed: result.changed, cleared, lockDropped, unmatched };
+}
+function unmatchedPhrase(unmatched) {
+  if (unmatched === void 0 || unmatched.length === 0) return "";
+  const SHOWN = 5;
+  const n = unmatched.length;
+  const listed = unmatched.slice(0, SHOWN).join(", ") + (n > SHOWN ? `, and ${n - SHOWN} more` : "");
+  return ` (${n === 1 ? "1 identity" : `${n} identities`} this project's lock does not know: ${listed})`;
+}
+function holdsLanding(lockPath, instance, dest) {
+  try {
+    const key = destinationKey(instance, dest);
+    if (dest.kind === "ephemeral") return ephemeralLandedOn(process.cwd(), key) !== void 0;
+    if (lockPath === void 0 || !existsSync(lockPath)) return false;
+    return landedOn(readLockFile(lockPath), key) !== void 0;
+  } catch {
+    return false;
+  }
+}
+function forgetLanding(lockPath, instance, dest) {
+  try {
+    if (dest.kind === "ephemeral") {
+      const dir = process.cwd();
+      return clearEphemeralLanding(dir, instance, dest.name) ? displayPath(ephemeralStatePath(dir)) : void 0;
+    }
+    if (lockPath === void 0 || !existsSync(lockPath)) return void 0;
+    const lock = readLockFile(lockPath);
+    const next = withoutLanding(lock, destinationKey(instance, dest));
+    if (next === lock || !writeLockFile(lockPath, next)) return void 0;
+    const shown = displayPath(lockPath);
+    info(`Removed its landing record from ${shown} \u2014 commit it.`);
+    return shown;
+  } catch {
+    return void 0;
+  }
+}
+function forgotPruned(shown, keys, by = "prune") {
+  const n = keys?.length ?? 0;
+  if (n === 0) return [];
+  info(
+    `Dropped the ${n === 1 ? "entry" : `${n} entries`} the ${by} deleted from ${shown}'s objects, so the next export does not read ${n === 1 ? "it" : "them"} as renamed or deleted \u2014 commit it.`
+  );
+  return keys.map((key) => displayLockKey(key));
+}
+function unforgotten(shown, err) {
+  warn(
+    `The prune landed, but ${shown} could not be updated: ${err instanceof Error ? err.message : String(err)}`,
+    "landing.record-failed",
+    ["The next export reads the deleted objects' entries as orphans; drop them with `xanosdk lock prune <entry-file>`."]
+  );
+}
+function unrecorded(shown, err) {
+  warn(
+    `The write landed, but it could not be recorded in ${shown}: ${err instanceof Error ? err.message : String(err)}`,
+    "landing.record-failed",
+    [
+      "A later `--prune` here deletes only what that record names, so it will refuse these objects until a landing is recorded."
+    ]
+  );
+}
+
+export {
+  landingLockPath,
+  landedRecordFor,
+  unvouchedIdentities,
+  recordForeignLanding,
+  recordLanding,
+  holdsLanding,
+  forgetLanding
+};
+//# sourceMappingURL=chunk-CGVQZXYG.js.map

package/dist/chunk-CIMQZRRE.js

@@ -0,0 +1,162 @@
+// src/statements/args.ts
+function argsOrEmpty(a) {
+  return a ?? {};
+}
+function assertArg(statement, name, v, opts) {
+  if (v === void 0 || v === null && !opts?.nullable)
+    throw new Error(
+      `Statement "${label(statement)}": required argument "${name}" is missing${v === null ? " (got null)" : ""}.`
+    );
+}
+function label(statement) {
+  return statement.replace(/^mvp:/, "");
+}
+var PROTO_KEY = 'a literal `__proto__:` key sets the object\'s prototype in JavaScript \u2014 write it computed: `["__proto__"]: \u2026`';
+function protoKeyed(v) {
+  const p = typeof v === "object" && v !== null ? Object.getPrototypeOf(v) : null;
+  return p !== null && p !== Object.prototype && !Object.hasOwn(p, "constructor");
+}
+function describeArg(v) {
+  if (v === null) return "null";
+  if (v === void 0) return "undefined";
+  if (Array.isArray(v)) return `a JS array (${v.length} item${v.length === 1 ? "" : "s"})`;
+  if (protoKeyed(v)) return `a record with a \`__proto__\` key (${PROTO_KEY})`;
+  if (isTaggedArg(v)) return `a tagged value (${valueSpelling(v.tag)})`;
+  if (typeof v === "function") return "a function";
+  if (typeof v === "object") {
+    const proto = Object.getPrototypeOf(v);
+    if (proto === null || proto === Object.prototype) return "a plain object";
+    const name = v.constructor?.name;
+    if (typeof name !== "string" || name === "") return "a class instance";
+    if (["Date", "Map", "Set", "WeakMap", "WeakSet", "RegExp", "Promise", "Error"].includes(name)) return `a ${name}`;
+    return `${/^[AEIOU]/.test(name) && !/^U(RL|RI|UID|int|ni|se)/.test(name) ? "an" : "a"} ${name} instance`;
+  }
+  return `a ${typeof v}`;
+}
+function valueSpelling(tag) {
+  if (tag.startsWith("const:")) return `c.${tag.slice("const:".length)}(\u2026)`;
+  const helper = { var: "ref", input: "inp", setting: "env", col: "col", auth: "auth", const: "c.text" };
+  return helper[tag] !== void 0 ? `${helper[tag]}(\u2026)` : `tag "${tag}"`;
+}
+function isTaggedArg(v) {
+  return (typeof v === "object" || typeof v === "function") && v !== null && typeof v.tag === "string" && "value" in v && Array.isArray(v.filters);
+}
+function assertValueArg(statement, name, v) {
+  assertArg(statement, name, v);
+  if (isTaggedArg(v)) return;
+  throw new Error(valueArgMessage(statement, name, v));
+}
+function presentValueArg(statement, name, v) {
+  if (v === void 0 || v === null) return false;
+  if (isTaggedArg(v)) return true;
+  throw new Error(valueArgMessage(statement, name, v));
+}
+function numberRemedy(v) {
+  if (!Number.isFinite(v)) return ` ${v} is not representable as a stored number \u2014 use a finite value, or \`c.null()\` for none.`;
+  if (Number.isSafeInteger(v)) return ` Wrap it: \`c.int(${v})\`.`;
+  if (Number.isInteger(v)) {
+    return ` It is past Number.MAX_SAFE_INTEGER, so the literal was already rounded \u2014 write the exact digits as \`c.int("<digits>")\` or \`c.int(<digits>n)\`.`;
+  }
+  return ` Wrap it: \`c.decimal(${v})\`.`;
+}
+function valueArgMessage(statement, name, v) {
+  const plain = Array.isArray(v) || typeof v === "object" && v !== null;
+  return `Statement "${label(statement)}": argument "${name}" must be a tagged value (\`c.*\`, \`ref()\`, \`inp()\`, \u2026) \u2014 got ${describeArg(v)}.` + (plain ? " A plain JS value stores an empty slot that deploys clean and then fails every request \u2014 an array of rows is `c.array([{ \u2026 }])` (plain JSON inside), a record is `c.obj({ \u2026 })`." : typeof v === "number" ? numberRemedy(v) : typeof v === "string" ? ` Wrap it: \`c.text(${JSON.stringify(v)})\`.` : typeof v === "boolean" ? ` Wrap it: \`c.bool(${v})\`.` : "");
+}
+function assertOneOf(statement, name, v, allowed) {
+  if (v === void 0) return;
+  if (typeof v === "string" && allowed.includes(v)) return;
+  throw new Error(
+    `Statement "${label(statement)}": argument "${name}" accepts only ${allowed.map((a) => JSON.stringify(a)).join(" | ")} \u2014 got ${typeof v === "string" ? JSON.stringify(v) : describeArg(v)}.`
+  );
+}
+function assertStatements(statement, name, v) {
+  assertArg(statement, name, v);
+  if (!Array.isArray(v)) {
+    throw new Error(
+      `Statement "${label(statement)}": argument "${name}" must be an array of statements \u2014 got ${describeArg(v)}.`
+    );
+  }
+  v.forEach((entry, i) => {
+    if (isStatementEntry(entry)) return;
+    throw new Error(
+      `Statement "${label(statement)}": argument "${name}[${i}]" must be a statement (\`s.*\`) \u2014 got ${describeStatementEntry(entry)}.${conditionalEntryHint(entry)}`
+    );
+  });
+}
+function assertListArg(statement, name, v, item) {
+  if (v === void 0 || v === null) return;
+  if (!Array.isArray(v)) {
+    throw new Error(
+      `Statement "${label(statement)}": argument "${name}" must be an array${item ? ` of ${item.want}` : ""} \u2014 got ${describeEntry(v)}.`
+    );
+  }
+  if (item === void 0) return;
+  v.forEach((entry, i) => {
+    if (item.test(entry)) return;
+    throw new Error(`Statement "${label(statement)}": argument "${name}[${i}]" must be ${item.want} \u2014 got ${describeEntry(entry)}.`);
+  });
+}
+function isRecordArg(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function conditionalEntryHint(entry) {
+  return entry === false || entry === void 0 ? " A `cond && s.x()` entry leaves false/undefined behind \u2014 spread it instead: `...(cond ? [s.x()] : [])`, or use `s.conditional` for a runtime condition." : "";
+}
+var RAW_ENVELOPE_KEY = /* @__PURE__ */ Symbol.for("xanosdk.statement.rawEnvelope");
+function isStatementEntry(v) {
+  if (typeof v !== "object" || v === null) return false;
+  if (v[RAW_ENVELOPE_KEY] !== void 0) return true;
+  return typeof v.name === "string";
+}
+function describeStatementEntry(v) {
+  return isTaggedArg(v) ? "a value (`c.*`/`ref()`), not a statement" : describeEntry(v);
+}
+function describeEntry(v) {
+  if (typeof v === "boolean" || typeof v === "number") return `${typeof v} ${String(v)}`;
+  if (typeof v === "bigint") return `bigint ${String(v)}n`;
+  if (typeof v === "string") return `the string ${JSON.stringify(v.length > 40 ? `${v.slice(0, 40)}\u2026` : v)}`;
+  return describeArg(v);
+}
+function assertVarName(statement, name, arg = "name") {
+  assertArg(statement, arg, name);
+  if (typeof name !== "string") {
+    throw new Error(`Statement "${statement}": argument "${arg}" must be the variable name as a string \u2014 got ${describeEntry(name)}.`);
+  }
+}
+var VAR_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function isVarName(name) {
+  return VAR_NAME.test(name);
+}
+function assertNewVarName(statement, name, arg = "name") {
+  assertVarName(statement, name, arg);
+  if (name === "") throw new Error(`Statement "${statement}": argument "${arg}" is empty \u2014 name the variable.`);
+  if (!VAR_NAME.test(name)) {
+    throw new Error(
+      `Statement "${statement}": ${JSON.stringify(name)} is not a variable name \u2014 use a letter or underscore, then letters, digits and underscores (e.g. "order_total").`
+    );
+  }
+}
+
+export {
+  argsOrEmpty,
+  assertArg,
+  PROTO_KEY,
+  protoKeyed,
+  describeArg,
+  isTaggedArg,
+  assertValueArg,
+  presentValueArg,
+  assertOneOf,
+  assertStatements,
+  assertListArg,
+  isRecordArg,
+  conditionalEntryHint,
+  isStatementEntry,
+  describeStatementEntry,
+  describeEntry,
+  assertVarName,
+  isVarName,
+  assertNewVarName
+};
+//# sourceMappingURL=chunk-CIMQZRRE.js.map