@xanots/sdk 0.0.1

package/dist/chunk-YGPIY3WT.js

@@ -0,0 +1,1146 @@
+import {
+  UsageError,
+  extraArguments,
+  missingArgument,
+  removedSubcommand,
+  renderGlobalHelp,
+  renderHelpFor,
+  unknownCommand,
+  unknownFlag,
+  unknownHelpTopic,
+  unknownSubcommand
+} from "./chunk-IZW6MK3U.js";
+import {
+  detail,
+  info,
+  stdoutStyle,
+  warn
+} from "./chunk-EZG76F7R.js";
+import {
+  Xano,
+  assertSeedIds,
+  coerceSeedRowValues
+} from "./chunk-3DUAGYGP.js";
+import {
+  getCommand,
+  getSubcommand,
+  isCommand,
+  suggest
+} from "./chunk-YYRDLFSJ.js";
+import {
+  FILTER_NAMES,
+  SEED_FILE,
+  buildContentEnvelope,
+  emit,
+  emitBundle,
+  isQueryExpressionFilter,
+  isSeedFileSource,
+  pathSegment,
+  serializeBundle,
+  tableColumns
+} from "./chunk-EMCAWMHC.js";
+import {
+  readLockFile,
+  writeLockFile
+} from "./chunk-HJPTWBLH.js";
+import {
+  WORKSPACE_KEY,
+  createLockContext,
+  emptyLock,
+  lockKey,
+  mergeObserved,
+  resetLockOverrides,
+  resolveRef,
+  seedLockOverrides,
+  serializeLock,
+  validateLockModel
+} from "./chunk-4HT3BNZ7.js";
+
+// src/emit/cli.ts
+import { pathToFileURL as pathToFileURL2, fileURLToPath as fileURLToPath2 } from "url";
+import { existsSync, readdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename, dirname, join, relative, resolve } from "path";
+import { createRequire } from "module";
+
+// src/workspace/seed.ts
+import { createHash } from "crypto";
+import { readFileSync } from "fs";
+import { fileURLToPath, pathToFileURL } from "url";
+var SEED_PAGE_TARGET_BYTES = 512 * 1024;
+async function resolveSeedRows(source) {
+  if (isSeedFileSource(source)) return readSeedFile(source[SEED_FILE]);
+  const resolved = typeof source === "function" ? await source() : source;
+  const rows = Array.isArray(resolved) ? resolved : unwrapDefaultExport(resolved);
+  if (!Array.isArray(rows)) {
+    throw new Error(`seed source did not resolve to an array of rows (got ${typeof resolved}).`);
+  }
+  return rows;
+}
+function readSeedFile(ref) {
+  const where = `seedFile("${ref.path}")`;
+  const base = /^[a-z][a-z0-9+.-]*:/i.test(ref.base) ? ref.base : pathToFileURL(ref.base).href;
+  const file = fileURLToPath(new URL(ref.path, base));
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch (cause) {
+    throw new Error(
+      `${where}: cannot read "${file}". The path is resolved relative to the module that declares the table (the \`import.meta.url\` you passed as \`base\`).`,
+      { cause }
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (cause) {
+    throw new Error(`${where}: "${file}" is not valid JSON \u2014 ${cause.message}`, {
+      cause
+    });
+  }
+  const rows = Array.isArray(parsed) ? parsed : unwrapDefaultExport(parsed);
+  if (!Array.isArray(rows)) {
+    throw new Error(
+      `${where}: "${file}" must hold an array of seed rows (got ${typeof parsed}).`
+    );
+  }
+  return rows;
+}
+function unwrapDefaultExport(value) {
+  if (value === null || typeof value !== "object") return value;
+  const fallback = value.default;
+  return Array.isArray(fallback) ? fallback : value;
+}
+function coerceSeedRows(tableName, columns, rows) {
+  const coerced = coerceSeedRowValues(tableName, columns, rows);
+  assignPrimaryKeys(tableName, columns, coerced);
+  return coerced;
+}
+function assignPrimaryKeys(tableName, columns, rows) {
+  if (!assertSeedIds(tableName, columns, rows)) return;
+  const idType = columns.find((c) => c.name === "id")?.type;
+  rows.forEach((r, i) => {
+    r.id = idType === "int" ? i + 1 : seedUuid(tableName, i);
+  });
+}
+function seedUuid(tableName, index) {
+  const h = createHash("sha256").update(`xanots:seed-id:${tableName}:${index}`).digest("hex");
+  const version5 = `5${h.slice(13, 16)}`;
+  const variant = (parseInt(h.slice(16, 17), 16) & 3 | 8).toString(16) + h.slice(17, 20);
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${version5}-${variant}-${h.slice(20, 32)}`;
+}
+function paginateRows(rows, budgetBytes = SEED_PAGE_TARGET_BYTES) {
+  const pages = [];
+  let page = [];
+  let size = 0;
+  for (const row of rows) {
+    const rowBytes = Buffer.byteLength(JSON.stringify(row), "utf8");
+    if (page.length > 0 && size + rowBytes > budgetBytes) {
+      pages.push(page);
+      page = [];
+      size = 0;
+    }
+    page.push(row);
+    size += rowBytes;
+  }
+  if (page.length > 0) pages.push(page);
+  return pages;
+}
+async function buildSeedContentFiles(tableDefs) {
+  const files = [];
+  for (const def of tableDefs) {
+    if (def.seed === void 0) continue;
+    const rows = await resolveSeedRows(def.seed);
+    if (rows.length === 0) continue;
+    const coerced = coerceSeedRows(def.name, tableColumns(def), rows);
+    const guid = resolveRef("dbo", def);
+    const pages = paginateRows(coerced);
+    pages.forEach((page, i) => {
+      files.push({ name: `content/${guid}-${i + 1}.json`, content: JSON.stringify(buildContentEnvelope(page)) });
+    });
+  }
+  return files;
+}
+var MIN_SCANNABLE_LENGTH = 6;
+async function collectNonPublicSeedValues(tableDefs) {
+  const found = [];
+  for (const def of tableDefs) {
+    if (def.seed === void 0) continue;
+    const guarded = tableColumns(def).filter(
+      (col) => col.access === "internal" || col.sensitive === true
+    );
+    if (guarded.length === 0) continue;
+    const rows = await resolveSeedRows(def.seed);
+    for (const row of rows) {
+      for (const col of guarded) {
+        const value = row[col.name];
+        if (value === void 0 || value === null) continue;
+        const scannable = typeof value === "string" && value.length >= MIN_SCANNABLE_LENGTH;
+        found.push({ table: def.name, column: col.name, value: String(value), scannable });
+      }
+    }
+  }
+  return found;
+}
+
+// src/emit/write.ts
+import { writeFileSync } from "fs";
+function writeArtifact(fn, path, opts = {}) {
+  writeFileSync(path, emit(fn, opts) + "\n", "utf8");
+}
+function writeBundle(xano, path, opts = {}) {
+  writeFileSync(path, emitBundle(xano, opts) + "\n", "utf8");
+}
+
+// src/validate/filter-names.ts
+var RESOLVABLE = new Set(FILTER_NAMES);
+var QUERY_EXPRESSION_KEYS = /* @__PURE__ */ new Set(["eval", "search", "sort", "aggregate"]);
+function editDistance(a, b) {
+  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const curr = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+    }
+    prev = curr;
+  }
+  return prev[b.length];
+}
+function suggestFilterNames(name) {
+  const AFFIX_MAX = 6;
+  const affix = (long, short) => (long.startsWith(short) || long.endsWith(short)) && long.length - short.length <= AFFIX_MAX;
+  const substr = FILTER_NAMES.filter(
+    (r) => name.length >= r.length ? affix(name, r) : affix(r, name)
+  ).sort((a, b) => Math.abs(a.length - name.length) - Math.abs(b.length - name.length));
+  if (substr.length) return substr.slice(0, 2);
+  const near = (d) => d === 1 || d === 2 && name.length >= 6;
+  return FILTER_NAMES.map((r) => ({ r, d: editDistance(name, r) })).filter((x) => near(x.d)).sort((a, b) => a.d - b.d).slice(0, 2).map((x) => x.r);
+}
+function findUnresolvableFilters(bundle) {
+  const findings = [];
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (node, context, inQuery = false) => {
+    if (Array.isArray(node)) {
+      for (const item of node) walk(item, context, inQuery);
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const obj = node;
+    const nm = obj.name;
+    const nextContext = typeof nm === "string" && nm !== "" && !nm.includes(":") ? nm : context;
+    const filters = obj.filters;
+    if (Array.isArray(filters)) {
+      for (const f of filters) {
+        const fname = f?.name;
+        const resolvable = typeof fname === "string" && (RESOLVABLE.has(fname) || inQuery && isQueryExpressionFilter(fname));
+        if (typeof fname === "string" && fname !== "" && !resolvable) {
+          const key = `${fname}@${nextContext}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            findings.push({ name: fname, location: nextContext || "(unknown)", suggestions: suggestFilterNames(fname) });
+          }
+        }
+      }
+    }
+    for (const [key, value] of Object.entries(obj)) {
+      walk(value, nextContext, inQuery || QUERY_EXPRESSION_KEYS.has(key));
+    }
+  };
+  walk(bundle, "");
+  return findings;
+}
+
+// src/emit/cli.ts
+function parsePort(raw) {
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 0 || n > 65535) {
+    throw new Error(`--port must be an integer 0-65535 (got "${raw ?? ""}").`);
+  }
+  return n;
+}
+var NOUN_COMMANDS = /* @__PURE__ */ new Set(["sandbox", "profile", "ephemeral", "workspace", "marketplace", "test"]);
+function helpTargetFor(command, subcommand) {
+  if (command === void 0 || !isCommand(command)) return void 0;
+  return subcommand !== void 0 && getSubcommand(command, subcommand) !== void 0 ? { command, subcommand } : { command };
+}
+function maxPositionals(args) {
+  if (args === void 0) return 0;
+  return args.some((a) => a.variadic === true) ? Number.POSITIVE_INFINITY : args.length;
+}
+function positionalBudget(command, subcommand, positionals) {
+  const spec = getCommand(command);
+  if (spec === void 0 || spec.removed !== void 0) return void 0;
+  if (spec.subcommands === void 0) {
+    return { max: maxPositionals(spec.args), given: positionals, offset: 0, target: { command } };
+  }
+  const offset = command === "lock" ? 1 : 0;
+  const verb = offset === 1 ? positionals[0] : subcommand;
+  if (verb === void 0) return void 0;
+  const sub = getSubcommand(command, verb);
+  if (sub === void 0 || sub.removed !== void 0) return void 0;
+  return {
+    max: maxPositionals(sub.args),
+    given: positionals.slice(offset),
+    offset,
+    target: { command, subcommand: verb }
+  };
+}
+function parseArgs(argv) {
+  const [command, ...afterCommand] = argv;
+  let subcommand;
+  let rest = afterCommand;
+  if (command !== void 0 && NOUN_COMMANDS.has(command)) {
+    subcommand = afterCommand[0];
+    rest = afterCommand.slice(1);
+  }
+  let out;
+  let lock = false;
+  let lockPath;
+  let entryPath;
+  let frozenLock = false;
+  let strict = false;
+  let yes = false;
+  let bundle;
+  let reset = false;
+  let dest;
+  let kind;
+  let concurrency;
+  let test = false;
+  let expiresHours;
+  let staticDir;
+  let staticHost;
+  let staticRouting;
+  const staticEnv = {};
+  let authHost;
+  let authFile;
+  let useLocal = false;
+  let allWorkspaces = false;
+  let guest = false;
+  let urlOnly = false;
+  let prompt = false;
+  let port;
+  let scope;
+  let runtime = false;
+  let capture = false;
+  let verbose = false;
+  let instance;
+  let format;
+  let path;
+  let name;
+  const ai = [];
+  let framework;
+  let force = false;
+  let noInstall = false;
+  let noVerify = false;
+  let requireMicroservices = false;
+  let report;
+  let allowSeedInStatic = false;
+  let dryRun = false;
+  let prune = false;
+  let resetData = false;
+  let seed = false;
+  let replace = false;
+  let emit2;
+  let json = false;
+  let open = false;
+  const positionals = [];
+  const positionalAt = [];
+  const unknownFlags = [];
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === "--out" || arg === "-o") {
+      out = rest[++i];
+    } else if (arg === "--emit") {
+      emit2 = rest[++i];
+    } else if (arg.startsWith("--emit=")) {
+      emit2 = arg.slice("--emit=".length);
+    } else if (arg === "--lock") {
+      lock = true;
+    } else if (arg.startsWith("--lock=")) {
+      lock = true;
+      lockPath = arg.slice("--lock=".length);
+    } else if (arg === "--entry") {
+      entryPath = rest[++i];
+    } else if (arg.startsWith("--entry=")) {
+      entryPath = arg.slice("--entry=".length);
+    } else if (arg === "--frozen-lock") {
+      frozenLock = true;
+    } else if (arg === "--strict") {
+      strict = true;
+    } else if (arg === "--yes" || arg === "-y") {
+      yes = true;
+    } else if (arg === "--bundle") {
+      bundle = rest[++i];
+    } else if (arg.startsWith("--bundle=")) {
+      bundle = arg.slice("--bundle=".length);
+    } else if (arg === "--reset") {
+      reset = true;
+    } else if (arg === "--dest") {
+      dest = parseDest(rest[++i]);
+    } else if (arg.startsWith("--dest=")) {
+      dest = parseDest(arg.slice("--dest=".length));
+    } else if (arg === "--kind") {
+      kind = parseKind(rest[++i]);
+    } else if (arg.startsWith("--kind=")) {
+      kind = parseKind(arg.slice("--kind=".length));
+    } else if (arg === "--concurrency") {
+      concurrency = parseConcurrency(rest[++i]);
+    } else if (arg.startsWith("--concurrency=")) {
+      concurrency = parseConcurrency(arg.slice("--concurrency=".length));
+    } else if (arg === "--test") {
+      test = true;
+    } else if (arg === "--expires-hours") {
+      expiresHours = parseExpiresHours(rest[++i]);
+    } else if (arg.startsWith("--expires-hours=")) {
+      expiresHours = parseExpiresHours(arg.slice("--expires-hours=".length));
+    } else if (arg === "--static-env" || arg.startsWith("--static-env=")) {
+      const kv = arg === "--static-env" ? rest[++i] : arg.slice("--static-env=".length);
+      const eq = kv?.indexOf("=") ?? -1;
+      if (kv === void 0 || eq <= 0) {
+        throw new Error(`--static-env expects KEY=VALUE (got "${kv ?? ""}").`);
+      }
+      staticEnv[kv.slice(0, eq)] = kv.slice(eq + 1);
+    } else if (arg === "--static-host") {
+      staticHost = rest[++i];
+    } else if (arg.startsWith("--static-host=")) {
+      staticHost = arg.slice("--static-host=".length);
+    } else if (arg === "--static-routing" || arg.startsWith("--static-routing=")) {
+      const v = arg === "--static-routing" ? rest[++i] : arg.slice("--static-routing=".length);
+      if (v !== "spa" && v !== "multipage") {
+        throw new Error(`--static-routing expects "spa" or "multipage" (got "${v ?? ""}").`);
+      }
+      staticRouting = v;
+    } else if (arg === "--static") {
+      staticDir = rest[++i];
+    } else if (arg.startsWith("--static=")) {
+      staticDir = arg.slice("--static=".length);
+    } else if (arg === "--origin") {
+      authHost = rest[++i];
+    } else if (arg.startsWith("--origin=")) {
+      authHost = arg.slice("--origin=".length);
+    } else if (arg === "--config") {
+      authFile = rest[++i];
+    } else if (arg.startsWith("--config=")) {
+      authFile = arg.slice("--config=".length);
+    } else if (arg === "--local") {
+      useLocal = true;
+    } else if (arg === "--all-workspaces") {
+      allWorkspaces = true;
+    } else if (arg === "--guest" || arg === "-g") {
+      guest = true;
+    } else if (arg === "--url-only" || arg === "-u") {
+      urlOnly = true;
+    } else if (arg === "--prompt") {
+      prompt = true;
+    } else if (arg === "--port") {
+      port = parsePort(rest[++i]);
+    } else if (arg.startsWith("--port=")) {
+      port = parsePort(arg.slice("--port=".length));
+    } else if (arg === "--scope") {
+      scope = rest[++i];
+    } else if (arg.startsWith("--scope=")) {
+      scope = arg.slice("--scope=".length);
+    } else if (arg === "--runtime") {
+      runtime = true;
+    } else if (arg === "--capture") {
+      capture = true;
+    } else if (arg === "--verbose") {
+      verbose = true;
+    } else if (arg === "--instance") {
+      instance = rest[++i];
+    } else if (arg.startsWith("--instance=")) {
+      instance = arg.slice("--instance=".length);
+    } else if (arg === "--format") {
+      format = parseFormat(rest[++i]);
+    } else if (arg.startsWith("--format=")) {
+      format = parseFormat(arg.slice("--format=".length));
+    } else if (arg === "--path") {
+      path = rest[++i];
+    } else if (arg.startsWith("--path=")) {
+      path = arg.slice("--path=".length);
+    } else if (arg === "--report") {
+      report = rest[++i];
+    } else if (arg.startsWith("--report=")) {
+      report = arg.slice("--report=".length);
+    } else if (arg === "--name") {
+      name = rest[++i];
+    } else if (arg.startsWith("--name=")) {
+      name = arg.slice("--name=".length);
+    } else if (arg === "--framework") {
+      framework = rest[++i];
+    } else if (arg.startsWith("--framework=")) {
+      framework = arg.slice("--framework=".length);
+    } else if (arg === "--ai" || arg.startsWith("--ai=")) {
+      const raw = arg === "--ai" ? rest[++i] : arg.slice("--ai=".length);
+      for (const p of (raw ?? "").split(",")) {
+        const preset = p.trim();
+        if (preset !== "") ai.push(preset);
+      }
+    } else if (arg === "--force") {
+      force = true;
+    } else if (arg === "--no-install") {
+      noInstall = true;
+    } else if (arg === "--allow-seed-in-static") {
+      allowSeedInStatic = true;
+    } else if (arg === "--no-verify") {
+      noVerify = true;
+    } else if (arg === "--require-microservices") {
+      requireMicroservices = true;
+    } else if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (arg === "--prune" && command === "release") {
+      prune = true;
+    } else if (arg === "--reset-data") {
+      resetData = true;
+    } else if (arg === "--seed") {
+      seed = true;
+    } else if (arg === "--replace") {
+      replace = true;
+    } else if (arg === "--json") {
+      json = true;
+    } else if (arg === "--open") {
+      open = true;
+    } else if (arg === "--profile" || arg.startsWith("--profile=")) {
+      throw new UsageError(
+        `\`--profile\` was removed \u2014 deploy now authenticates via OAuth. Run \`xanots login\` once (or set XANO_REFRESH_TOKEN for CI).`,
+        { helpFor: helpTargetFor(command, subcommand) }
+      );
+    } else if (arg === "--workspace" || arg.startsWith("--workspace=")) {
+      throw new UsageError(
+        `\`--workspace\` was removed. Every command acts on the workspace its credential is bound to \u2014 pinned at \`xanots login\`, or set as \`workspace_id\` in a meta API token credential. Run \`xanots workspace details\` to see which one that is.`,
+        { helpFor: helpTargetFor(command, subcommand) }
+      );
+    } else if (arg === "--prune" || arg === "--confirm-workspace" || arg.startsWith("--confirm-workspace=") || arg === "--adopt-workspace") {
+      const flag = arg.split("=")[0];
+      throw new UsageError(
+        `\`${flag}\` was removed along with \`xanots workspace deploy\` \u2014 deploy targets are selected with \`xanots deploy --dest <ephemeral|sandbox>\`.`,
+        { helpFor: helpTargetFor(command, subcommand) }
+      );
+    } else if (arg === "--help" || arg === "-h") {
+      continue;
+    } else if (arg.startsWith("-") && arg !== "-") {
+      unknownFlags.push(arg);
+    } else {
+      positionals.push(arg);
+      positionalAt.push(i);
+    }
+  }
+  if (unknownFlags.length > 0) {
+    throw unknownFlag(unknownFlags, helpTargetFor(command, subcommand));
+  }
+  const budget = command === void 0 ? void 0 : positionalBudget(command, subcommand, positionals);
+  if (budget !== void 0 && budget.given.length > budget.max) {
+    const lockValue = positionals.findIndex((_, n) => rest[(positionalAt[n] ?? 0) - 1] === "--lock");
+    const extras = lockValue >= budget.offset ? [positionals[lockValue]] : budget.given.slice(budget.max);
+    throw extraArguments(extras, budget.target, budget.max, lockValue >= budget.offset ? "--lock" : void 0);
+  }
+  return {
+    command,
+    subcommand,
+    file: positionals[0],
+    out,
+    positionals,
+    lock,
+    lockPath,
+    entryPath,
+    frozenLock,
+    strict,
+    yes,
+    bundle,
+    reset,
+    dest,
+    kind,
+    concurrency,
+    test,
+    expiresHours,
+    static: staticDir,
+    staticHost,
+    staticRouting,
+    staticEnv,
+    authHost,
+    authFile,
+    local: useLocal,
+    allWorkspaces,
+    guest,
+    urlOnly,
+    prompt,
+    port,
+    scope,
+    runtime,
+    capture,
+    verbose,
+    instance,
+    format,
+    path,
+    name,
+    ai,
+    force,
+    noInstall,
+    framework,
+    noVerify,
+    requireMicroservices,
+    report,
+    allowSeedInStatic,
+    dryRun,
+    prune,
+    resetData,
+    seed,
+    replace,
+    emit: emit2,
+    json,
+    open,
+    unknownFlags
+  };
+}
+function resolveHelpRequest(argv) {
+  const asVerb = argv[0] === "help";
+  if (!asVerb && !argv.some((a) => a === "--help" || a === "-h")) return void 0;
+  const tokens = (asVerb ? argv.slice(1) : argv).filter((a) => !a.startsWith("-"));
+  const command = tokens[0];
+  if (command === void 0 || !isCommand(command)) {
+    return asVerb && command !== void 0 ? { unknownTopic: command } : {};
+  }
+  const sub = tokens[1];
+  return sub !== void 0 && getSubcommand(command, sub) !== void 0 ? { command, subcommand: sub } : { command };
+}
+function parseFormat(raw) {
+  if (raw === "json" || raw === "multidoc") return raw;
+  throw new Error(`--format must be "json" or "multidoc" (got "${raw ?? ""}").`);
+}
+function parseDest(raw) {
+  if (raw === "sandbox" || raw === "ephemeral" || raw === "workspace") return raw;
+  throw new Error(`--dest must be "ephemeral", "sandbox" or "workspace" (got "${raw ?? ""}").`);
+}
+function parseKind(raw) {
+  if (raw === "unit" || raw === "workflow") return raw;
+  throw new Error(`--kind must be "unit" or "workflow" (got "${raw ?? ""}").`);
+}
+function parseConcurrency(raw) {
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1 || n > 32) {
+    throw new Error(`--concurrency must be a whole number from 1 to 32 (got "${raw ?? ""}").`);
+  }
+  return n;
+}
+function parseExpiresHours(raw) {
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1 || n > 72) {
+    throw new Error(`--expires-hours must be an integer 1\u201372 (got "${raw ?? ""}").`);
+  }
+  return n;
+}
+async function importTsxApi(file) {
+  try {
+    const requireFromEntry = createRequire(pathToFileURL2(resolve(file)));
+    const apiPath = requireFromEntry.resolve("tsx/esm/api");
+    return await import(pathToFileURL2(apiPath).href);
+  } catch {
+    return await import("tsx/esm/api");
+  }
+}
+async function tryImportTsxApi(file) {
+  try {
+    return await importTsxApi(file);
+  } catch {
+    return void 0;
+  }
+}
+function entryIsCommonJs(file) {
+  const path = resolve(file);
+  if (/\.mts$/.test(path)) return false;
+  if (/\.cts$/.test(path)) return true;
+  let dir = dirname(path);
+  for (; ; ) {
+    const manifest = join(dir, "package.json");
+    if (existsSync(manifest)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(manifest, "utf8"));
+        return pkg.type !== "module";
+      } catch {
+        return false;
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return false;
+    dir = parent;
+  }
+}
+function commonJsEntryError(file, cause) {
+  return new Error(
+    `Cannot load "${file}": it is being evaluated as CommonJS, but xanots workspace files are ES modules. Add \`"type": "module"\` to the nearest package.json, or rename the entry to \`.mts\`.`,
+    cause !== void 0 ? { cause } : void 0
+  );
+}
+function suggestSiblingFile(path) {
+  try {
+    return suggest(basename(path), readdirSync(dirname(path)));
+  } catch {
+    return void 0;
+  }
+}
+async function loadDefault(file) {
+  const path = resolve(file);
+  if (!existsSync(path)) {
+    throw new UsageError(`Cannot find entry file "${file}" (resolved to ${path}).`, {
+      suggestion: suggestSiblingFile(path)
+    });
+  }
+  const url = pathToFileURL2(path).href;
+  const isTypeScript = /\.[mc]?ts$/.test(file);
+  if (isTypeScript) {
+    if (entryIsCommonJs(file)) throw commonJsEntryError(file);
+    const tsx = await tryImportTsxApi(file);
+    if (tsx) {
+      const unregister = tsx.register();
+      try {
+        const mod = await import(url);
+        return mod.default;
+      } finally {
+        unregister();
+      }
+    }
+  }
+  try {
+    const mod = await import(url);
+    return mod.default;
+  } catch (err) {
+    if (!isTypeScript) throw err;
+    const code = err?.code;
+    if (code === "ERR_UNKNOWN_FILE_EXTENSION" || code === "ERR_MODULE_NOT_FOUND") {
+      throw new Error(
+        `Loading a TypeScript entry ("${file}") requires \`tsx\`. Install it in your project (\`npm i -D tsx\`) or precompile the file to .js first.`,
+        { cause: err }
+      );
+    }
+    if (err instanceof SyntaxError && /import statement outside a module/.test(err.message)) {
+      throw commonJsEntryError(file, err);
+    }
+    throw err;
+  }
+}
+function readVersion() {
+  let dir = dirname(fileURLToPath2(import.meta.url));
+  for (let i = 0; i < 6; i++) {
+    const p = join(dir, "package.json");
+    if (existsSync(p)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(p, "utf8"));
+        if (pkg.name === "@xanots/sdk" && typeof pkg.version === "string") return pkg.version;
+      } catch {
+      }
+    }
+    const up = dirname(dir);
+    if (up === dir) break;
+    dir = up;
+  }
+  return "unknown";
+}
+function printHelp() {
+  process.stdout.write(renderGlobalHelp(stdoutStyle(), readVersion()));
+}
+function shellName(name) {
+  return /[^\w.@/-]/.test(name) ? JSON.stringify(name) : name;
+}
+function warnOrphans(orphans, dropped, cededCanonicals, previous, observed) {
+  for (const key of orphans) {
+    if (key === WORKSPACE_KEY) {
+      warn(
+        `xano.lock entry "${key}" matched nothing this export (no workspace canonical emitted). Run \`xanots lock prune\` if that is intentional.`
+      );
+      continue;
+    }
+    const sep = key.indexOf(":");
+    const payloadKey = key.slice(0, sep);
+    const name = key.slice(sep + 1);
+    const newcomers = Object.keys(observed).filter((k) => k.startsWith(`${payloadKey}:`) && !(k in previous.objects)).map((k) => k.slice(payloadKey.length + 1));
+    const hint = newcomers.length > 0 ? ` (new ${payloadKey} names this export: ${newcomers.join(", ")})` : "";
+    warn(
+      `xano.lock entry "${key}" matches no exported object \u2014 if this was a rename, the next sync would delete+create unless the entry moves with it.`
+    );
+    detail(`renamed? run: xanots lock rename ${payloadKey} ${shellName(name)} <new-name>${hint}`);
+    detail("deleted? run: xanots lock prune");
+  }
+  for (const key of dropped) {
+    warn(
+      `Dropped stale lock entry "${key}" \u2014 its identity reappeared under a live name (a reverted rename).`
+    );
+  }
+  for (const key of cededCanonicals) {
+    warn(
+      `Lock entry "${key}" kept its guid but ceded its canonical to a live object that now emits it (an explicit in-code canonical). If "${key}" was renamed, run the \`xanots lock rename\` fix-up shown above.`
+    );
+  }
+}
+async function run(argv) {
+  const helpRequest = resolveHelpRequest(argv);
+  if (helpRequest) {
+    if (helpRequest.unknownTopic !== void 0) throw unknownHelpTopic(helpRequest.unknownTopic);
+    process.stdout.write(renderHelpFor(helpRequest, stdoutStyle(), readVersion()));
+    return;
+  }
+  const args = parseArgs(argv);
+  const { command, out } = args;
+  if (command === void 0) {
+    printHelp();
+    return;
+  }
+  if (command === "version" || command === "--version" || command === "-v") {
+    process.stdout.write(`${readVersion()}
+`);
+    return;
+  }
+  if (command === "init") {
+    const { runInitCommand } = await import("./init-command-R6H7ZXW5.js");
+    return runInitCommand(args);
+  }
+  if (command === "completion") {
+    const { isCompletionShell, runCompletionCommand, COMPLETION_SHELLS } = await import("./completion-TIPPZN7H.js");
+    const shell = args.positionals[0];
+    if (shell === void 0 || !isCompletionShell(shell)) {
+      throw new UsageError(
+        shell === void 0 ? `\`xanots completion\`: missing required <shell>.` : `\`xanots completion\`: unknown shell "${shell}". Supported: ${COMPLETION_SHELLS.join(", ")}.`,
+        { helpFor: { command: "completion" }, suggestion: suggest(shell ?? "", COMPLETION_SHELLS) }
+      );
+    }
+    return runCompletionCommand(shell);
+  }
+  if (command === "lock") {
+    const { runLockCommand } = await import("./lock-commands-XTR2YKLY.js");
+    return runLockCommand(args);
+  }
+  if (command === "login") {
+    const { runLoginCommand } = await import("./login-command-ACJF6KWQ.js");
+    return runLoginCommand(args);
+  }
+  if (command === "logout") {
+    const { runLogoutCommand } = await import("./logout-command-MX3MJS5U.js");
+    return runLogoutCommand(args);
+  }
+  if (command === "deploy") {
+    const { runDeployCommand } = await import("./deploy-command-4EQ7XX5G.js");
+    return runDeployCommand(args);
+  }
+  if (command === "ephemeral") {
+    const { runEphemeralCommand } = await import("./ephemeral-command-3X3I4ULC.js");
+    return runEphemeralCommand(args);
+  }
+  if (command === "release") {
+    const { runReleaseCommand } = await import("./release-command-VV5UVZKL.js");
+    return runReleaseCommand(args);
+  }
+  if (command === "sandbox") {
+    if (args.subcommand === "deploy") {
+      throw removedSubcommand("sandbox", "deploy");
+    }
+    if (args.subcommand === "details") {
+      const { runSandboxDetailsCommand } = await import("./sandbox-details-command-HJE5SPVG.js");
+      return runSandboxDetailsCommand(args);
+    }
+    if (args.subcommand === "export") {
+      const { runSandboxExportCommand } = await import("./sandbox-export-command-QCJY4GMV.js");
+      return runSandboxExportCommand(args);
+    }
+    if (args.subcommand === "codegen") {
+      const { runCodegenCommand } = await import("./codegen-command-OOKK6AZK.js");
+      return runCodegenCommand(args, { kind: "sandbox" });
+    }
+    throw unknownSubcommand("sandbox", args.subcommand);
+  }
+  if (command === "test") {
+    const { runTestCommand } = await import("./test-command-TSPBQHBM.js");
+    return runTestCommand(args);
+  }
+  if (command === "workspace") {
+    const { runWorkspaceCommand } = await import("./workspace-command-OF23DPNI.js");
+    return runWorkspaceCommand(args);
+  }
+  if (command === "codegen") {
+    const { runCodegenCommand } = await import("./codegen-command-OOKK6AZK.js");
+    return runCodegenCommand(args, { kind: "file" });
+  }
+  if (command === "profile") {
+    if (args.subcommand !== "me") {
+      throw unknownSubcommand("profile", args.subcommand);
+    }
+    const { runProfileCommand } = await import("./profile-command-SWJ3SPKR.js");
+    return runProfileCommand(args);
+  }
+  if (command === "whoami") {
+    const { runProfileCommand } = await import("./profile-command-SWJ3SPKR.js");
+    return runProfileCommand(args);
+  }
+  if (command === "marketplace") {
+    if (!["list", "search", "details", "install"].includes(args.subcommand ?? "")) {
+      throw unknownSubcommand("marketplace", args.subcommand);
+    }
+    const marketplace = await import("./marketplace-command-RATXTKXN.js");
+    if (args.subcommand === "list") return marketplace.runMarketplaceListCommand(args);
+    if (args.subcommand === "search") return marketplace.runMarketplaceSearchCommand(args);
+    if (args.subcommand === "details") return marketplace.runMarketplaceDetailsCommand(args);
+    return marketplace.runMarketplaceInstallCommand(args);
+  }
+  if (command === "push") {
+    throw unknownCommand("push");
+  }
+  if (command === "validate") {
+    const { runValidateCommand } = await import("./validate-command-4ERHJSCO.js");
+    return runValidateCommand(args);
+  }
+  if (command !== "compile" && command !== "export" && command !== "paths" && command !== "routes") {
+    throw unknownCommand(command);
+  }
+  if (!args.file) {
+    throw missingArgument("file", { command });
+  }
+  if (command === "compile") {
+    return runCompile(args);
+  }
+  if (command === "paths" || command === "routes") {
+    return runPaths(args);
+  }
+  const { bundle: json, omittedSeedTables } = await compileBundle(args);
+  if (omittedSeedTables.length > 0) {
+    const names = omittedSeedTables.map((n) => `"${n}"`).join(", ");
+    info(
+      `Exported bundle omits seed rows for ${omittedSeedTables.length} table(s): ${names}. Seed is applied only by \`xanots deploy <entry>\` \u2014 deploying this bundle via \`--bundle\` ships schema without seed data.`
+    );
+  }
+  if (out) {
+    writeFileSync2(out, json + "\n", "utf8");
+    process.stdout.write(`Wrote ${out}
+`);
+  } else {
+    process.stdout.write(json + "\n");
+  }
+}
+async function refreshAgentGuidance() {
+  try {
+    const { refreshAgentFiles } = await import("./agent-file-refresh-7XCACU34.js");
+    const refreshed = refreshAgentFiles({
+      projectDir: process.cwd(),
+      sdkVersion: readVersion()
+    });
+    for (const path of refreshed) {
+      process.stderr.write(`Refreshed ${path} for @xanots/sdk ${readVersion()}.
+`);
+    }
+  } catch {
+  }
+}
+function resolveLockPath(args, file) {
+  return args.lockPath !== void 0 ? resolve(args.lockPath) : join(dirname(resolve(file)), "xano.lock");
+}
+function describeDefaultExport(def) {
+  if (def === void 0) return "no default export";
+  if (def === null) return "null";
+  if (Array.isArray(def)) return "an array (export one def, not a list)";
+  if (typeof def !== "object") return `a ${typeof def}`;
+  return "an object with no `name`";
+}
+async function runCompile(args) {
+  const file = args.file;
+  const lockPath = resolveLockPath(args, file);
+  resetLockOverrides();
+  if (existsSync(lockPath)) {
+    seedLockOverrides(readLockFile(lockPath));
+  }
+  const def = await loadDefault(file);
+  if (Xano.isXano(def)) {
+    throw new Error(
+      `Module "${file}" default-exports a workspace \u2014 use \`xanots export\` (or \`xanots paths\`) for a workspace entry. \`compile\` takes a single object def (a query, function, table, \u2026) and prints its JSON artifact.`
+    );
+  }
+  if (!def || typeof def !== "object" || typeof def.name !== "string") {
+    throw new Error(
+      `Module "${file}" must default-export a single object def (a query, function, table, \u2026) \u2014 one object with a \`name\`. Got: ${describeDefaultExport(def)}.`
+    );
+  }
+  const fn = def;
+  if (args.out) {
+    writeArtifact(fn, args.out);
+    process.stdout.write(`Wrote ${args.out}
+`);
+  } else {
+    process.stdout.write(emit(fn) + "\n");
+  }
+}
+async function runPaths(args) {
+  const file = args.file;
+  const lockPath = resolveLockPath(args, file);
+  resetLockOverrides();
+  const lockModel = existsSync(lockPath) ? readLockFile(lockPath) : void 0;
+  const def = await loadDefault(file);
+  if (!Xano.isXano(def)) {
+    throw new Error(`Module "${file}" must default-export a Xano registry for \`paths\`.`);
+  }
+  const bundle = def.export({ strict: args.strict });
+  const payload = bundle.payload;
+  const queries = payload.query ?? [];
+  const apps = payload.app ?? [];
+  const realtimeServers = payload.realtime_server ?? [];
+  const channels = payload.channel ?? [];
+  const canonicalByGuid = /* @__PURE__ */ new Map();
+  for (const a of apps) {
+    if (typeof a.guid !== "string") continue;
+    const inCode = typeof a.canonical === "string" && a.canonical !== "" ? a.canonical : void 0;
+    const locked = typeof a.name === "string" ? lockModel?.objects[lockKey("app", a.name)]?.canonical : void 0;
+    const resolved2 = inCode ?? locked;
+    if (resolved2) canonicalByGuid.set(a.guid, resolved2);
+  }
+  if (queries.length === 0 && !(args.emit !== void 0 && realtimeServers.length > 0)) {
+    info("No API queries registered in this workspace.");
+    return;
+  }
+  const rows = queries.map((q) => ({
+    verb: q.verb,
+    // already an uppercase HttpVerb in the bundle
+    // Match getPath(): the path segment drops any leading slash on the name.
+    name: pathSegment(q.name),
+    canonical: q.app?.id ? canonicalByGuid.get(q.app.id) : void 0
+  }));
+  rows.sort((a, b) => (a.canonical ?? "").localeCompare(b.canonical ?? "") || a.name.localeCompare(b.name));
+  const unresolved = rows.filter((r) => !r.canonical);
+  const resolved = rows.filter((r) => r.canonical);
+  if (args.emit !== void 0) {
+    const serverNameByGuid = /* @__PURE__ */ new Map();
+    const serverRows = realtimeServers.flatMap((s) => {
+      if (typeof s.name !== "string" || s.name === "") return [];
+      if (typeof s.guid === "string") serverNameByGuid.set(s.guid, s.name);
+      const inCode = typeof s.canonical === "string" && s.canonical !== "" ? s.canonical : void 0;
+      const locked = lockModel?.objects[lockKey("realtime_server", s.name)]?.canonical;
+      return [{ name: s.name, canonical: inCode ?? locked }];
+    });
+    const describable = new Set(serverRows.filter((s) => s.canonical).map((s) => s.name));
+    const unresolvedServers = serverRows.filter((s) => !s.canonical);
+    const channelRows = channels.flatMap((c) => {
+      if (typeof c.name !== "string" || c.name === "") return [];
+      const server = c.server?.id ? serverNameByGuid.get(c.server.id) : void 0;
+      if (server === void 0 || !describable.has(server)) return [];
+      return [{ name: c.name, server }];
+    });
+    if (unresolvedServers.length > 0) {
+      warn(
+        `${args.emit}: leaving out ${unresolvedServers.length} realtime server(s) \u2014 ${unresolvedServers.map((s) => `"${s.name}"`).join(", ")} \u2014 whose canonical URL token resolves nowhere, along with their channels. Set an explicit \`realtimeServer({ canonical })\`, or run \`xanots export ${file} --lock\` once (it mints a unique canonical and freezes it in xano.lock) beside the entry, then re-run to include them.`
+      );
+    }
+    const describableServers = serverRows.flatMap(
+      (s) => s.canonical ? [{ name: s.name, canonical: s.canonical }] : []
+    );
+    if (resolved.length === 0 && describableServers.length === 0) {
+      info(`Nothing to write to ${args.emit} yet.`);
+      return;
+    }
+    if (unresolved.length === 0) {
+      const { renderRouteManifest } = await import("./routes-manifest-SP3ZXLMR.js");
+      const source = renderRouteManifest(
+        resolved.map((r) => ({ name: r.name, verb: r.verb, canonical: r.canonical })),
+        describableServers.length > 0 ? { servers: describableServers, channels: channelRows } : void 0
+      );
+      const routeCount = resolved.length === 1 ? "1 route" : `${resolved.length} routes`;
+      const channelCount = channelRows.length === 1 ? "1 channel" : `${channelRows.length} channels`;
+      const count = describableServers.length > 0 ? `${routeCount}, ${channelCount}` : routeCount;
+      if (args.strict) {
+        const current = existsSync(args.emit) ? readFileSync2(args.emit, "utf8") : void 0;
+        if (current !== source) {
+          throw new Error(
+            `--strict: ${args.emit} is ${current === void 0 ? "missing" : "out of date"}. Run \`xanots paths <entry> --emit ${args.emit}\` and commit the result \u2014 a stale route manifest keeps compiling while the endpoints have moved.`
+          );
+        }
+        info(`${args.emit} is up to date (${count}).`);
+      } else {
+        writeFileSync2(args.emit, source, "utf8");
+        info(`Wrote ${args.emit} (${count}).`);
+      }
+    }
+  } else {
+    const verbWidth = Math.max(0, ...resolved.map((r) => r.verb.length));
+    for (const r of resolved) {
+      const path = `/api:${r.canonical}/${r.name}`;
+      process.stdout.write(`${r.verb.padEnd(verbWidth)}  ${path}  api:${r.canonical}/${r.name}
+`);
+    }
+  }
+  if (unresolved.length > 0) {
+    const names = unresolved.map((r) => `"${r.name}"`).join(", ");
+    throw new Error(
+      `paths: cannot resolve the api group's canonical URL token for ${unresolved.length} query(ies): ${names}. Set an explicit \`apiGroup({ canonical })\`, or run \`xanots export ${file} --lock\` once (it mints a unique canonical and freezes it in xano.lock) beside the entry, then re-run \`xanots paths\`.`
+    );
+  }
+}
+async function exportBundleJson(args) {
+  return (await compileBundle(args)).bundle;
+}
+async function compileBundle(args, opts = {}) {
+  const file = args.file;
+  const lockPath = resolveLockPath(args, file);
+  const lockExists = existsSync(lockPath);
+  resetLockOverrides();
+  let lockCtx;
+  let originalSerialized;
+  if (lockExists || args.lock) {
+    const lockModel = lockExists ? readLockFile(lockPath) : emptyLock();
+    if (lockExists) originalSerialized = serializeLock(lockModel);
+    seedLockOverrides(lockModel);
+    lockCtx = createLockContext(lockModel);
+  } else if (args.frozenLock) {
+    throw new Error(
+      `--frozen-lock: no xano.lock found at ${lockPath}. Create one with \`xanots export ${file} --lock\` and commit it.`
+    );
+  }
+  await refreshAgentGuidance();
+  const def = await loadDefault(file);
+  if (!Xano.isXano(def)) {
+    throw new Error(`Module "${file}" must default-export a Xano registry for \`export\`.`);
+  }
+  const bundle = def.export({ ...lockCtx ? { lock: lockCtx } : {}, strict: args.strict });
+  if (lockCtx) {
+    const { lock: merged, orphans, dropped, cededCanonicals } = mergeObserved(
+      lockCtx.lock,
+      lockCtx.observed
+    );
+    validateLockModel(merged, lockPath);
+    const changed = originalSerialized === void 0 || serializeLock(merged) !== originalSerialized;
+    if (args.frozenLock && changed) {
+      throw new Error(
+        `--frozen-lock: this export would ${lockExists ? "change" : "create"} ${lockPath}. Run \`xanots export\` locally, commit the updated xano.lock, and retry \u2014 a canonical minted here would be discarded, permanently diverging public URLs.`
+      );
+    }
+    writeLockFile(lockPath, merged);
+    if (!lockExists) info(`Wrote ${relative(process.cwd(), lockPath) || lockPath} (commit this).`);
+    warnOrphans(orphans, dropped, cededCanonicals, lockCtx.lock, lockCtx.observed);
+  }
+  checkFilterNames(bundle, args.strict);
+  const resolvedContent = await buildSeedContentFiles(def.tables());
+  const content = opts.seed ? resolvedContent : [];
+  const nonPublicSeedValues = opts.seed ? await collectNonPublicSeedValues(def.tables()) : [];
+  const omittedSeedTables = opts.seed ? [] : def.tables().filter((t) => t.seed !== void 0).map((t) => t.name);
+  return { bundle: serializeBundle(bundle), content, omittedSeedTables, nonPublicSeedValues };
+}
+function checkFilterNames(bundle, strict) {
+  const findings = findUnresolvableFilters(bundle);
+  if (findings.length === 0) return;
+  for (const f of findings) {
+    const hint = f.suggestions.length ? ` \u2014 did you mean ${f.suggestions.map((s) => `\`${s}\``).join(" or ")}?` : "";
+    warn(`Filter "${f.name}" (in ${f.location}) is not engine-resolvable and will 500 at runtime${hint}`);
+  }
+  if (strict) {
+    throw new Error(
+      `--strict: ${findings.length} unresolvable filter name(s). Replace them with resolvable names (see \`fl.*\` / llms.txt) or drop the raw \`filter()\` call.`
+    );
+  }
+}
+
+export {
+  writeArtifact,
+  writeBundle,
+  parseArgs,
+  resolveHelpRequest,
+  loadDefault,
+  readVersion,
+  printHelp,
+  run,
+  resolveLockPath,
+  exportBundleJson,
+  compileBundle
+};
+//# sourceMappingURL=chunk-YGPIY3WT.js.map