@xano/sdk 1.0.0

package/dist/chunk-5A2PLKZB.js

@@ -0,0 +1,70 @@
+import {
+  XANO_DIR
+} from "./chunk-AHJWCYQO.js";
+import {
+  projectRootFrom
+} from "./chunk-ROY4YAEQ.js";
+import {
+  relForwardSlash
+} from "./chunk-PTHVMXZI.js";
+
+// src/emit/backend-dir.ts
+import { existsSync, readdirSync } from "fs";
+import { basename, dirname, join, resolve } from "path";
+var DECODE_MARKER = ".xanosdk-codegen.json";
+function backendDirFor(entryFile) {
+  const dir = dirname(resolve(entryFile));
+  const root = projectRootFrom(dir);
+  for (let at = dir; ; at = dirname(at)) {
+    if (existsSync(join(at, DECODE_MARKER))) return at;
+    if (at === root || dirname(at) === at || !at.startsWith(root)) break;
+  }
+  const nested = nestedBackendDir(dir, root);
+  if (nested !== void 0) return nested;
+  const top = relForwardSlash(root, dir).split("/")[0] ?? "";
+  return join(root, top === "" ? XANO_DIR : top);
+}
+function nestedBackendDir(dir, root) {
+  const rel = relForwardSlash(root, dir);
+  if (rel === "" || !rel.includes("/")) return void 0;
+  const ancestors = [];
+  for (let at = dir; at !== root && dirname(at) !== at; at = dirname(at)) ancestors.push(at);
+  return ancestors.find((at) => basename(at) === XANO_DIR) ?? ancestors.find((at) => existsSync(join(at, "xano.lock"))) ?? dir;
+}
+function backendDirIn(projectRoot) {
+  const root = resolve(projectRoot);
+  const scaffolded = join(root, XANO_DIR);
+  if (existsSync(scaffolded)) return scaffolded;
+  let found;
+  let entries;
+  try {
+    entries = readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return scaffolded;
+  }
+  for (const name of entries) {
+    if (name === "node_modules" || name.startsWith(".")) continue;
+    const dir = join(root, name);
+    if (!existsSync(join(dir, "xano.lock")) || !existsSync(join(dir, "index.ts"))) continue;
+    if (found !== void 0) return scaffolded;
+    found = dir;
+  }
+  return found ?? scaffolded;
+}
+function resolveBackendDir(cwd, dir, refuse) {
+  if (dir === void 0) return relForwardSlash(cwd, backendDirIn(cwd)) || XANO_DIR;
+  const rel = relForwardSlash(cwd, resolve(cwd, dir));
+  if (rel === "") {
+    throw refuse(
+      `--backend-dir must name a directory inside this project, and "${dir}" is not one.`
+    );
+  }
+  return rel;
+}
+
+export {
+  backendDirFor,
+  backendDirIn,
+  resolveBackendDir
+};
+//# sourceMappingURL=chunk-5A2PLKZB.js.map

package/dist/chunk-5FBYXK5P.js

@@ -0,0 +1,159 @@
+import {
+  atomicWrite
+} from "./chunk-LLNZGEFK.js";
+import {
+  assertValidProfileName
+} from "./chunk-QXTKSOFI.js";
+import {
+  UsageError
+} from "./chunk-PTHVMXZI.js";
+import {
+  shellQuote
+} from "./chunk-5ZSO4T2G.js";
+
+// src/auth/profile-pointer.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { homedir } from "os";
+var POINTER_FILE = "xano.profile.json";
+var TOKEN_BEARING = [
+  "access_token",
+  "refresh_token",
+  "meta_api_token",
+  "token",
+  "secret",
+  "client_secret",
+  "password",
+  "api_key",
+  "apikey",
+  "authorization",
+  "bearer",
+  "access_key",
+  "private_key"
+];
+var MAX_SCAN_DEPTH = 6;
+function leakedKeys(value, path = [], depth = 0) {
+  if (depth > MAX_SCAN_DEPTH || typeof value !== "object" || value === null) return [];
+  if (Array.isArray(value)) {
+    return value.flatMap((item, i) => leakedKeys(item, [...path, String(i)], depth + 1));
+  }
+  return Object.entries(value).flatMap(([key, child]) => {
+    const here = [...path, key];
+    if (TOKEN_BEARING.includes(key.toLowerCase())) return [here.join(".")];
+    return leakedKeys(child, here, depth + 1);
+  });
+}
+function findPointerFile(startDir) {
+  return walkUp(startDir).pointer;
+}
+function walkUp(startDir) {
+  const start = resolve(startDir);
+  const home = resolve(homedir());
+  let dir = start;
+  for (; ; ) {
+    const candidate = join(dir, POINTER_FILE);
+    if (existsSync(candidate)) return { pointer: candidate, root: dir, bounded: true };
+    if (existsSync(join(dir, "package.json"))) return { root: dir, bounded: true };
+    if (existsSync(join(dir, ".git"))) return { root: dir, bounded: true };
+    const parent = dirname(dir);
+    if (parent === dir || dir === home) return { root: start, bounded: false };
+    dir = parent;
+  }
+}
+function readPointerFile(path) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8").replace(/^\uFEFF/, "");
+  } catch (err) {
+    throw pointerFsFailure(err, path, "read");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new UsageError(
+      `${path} is not valid JSON. It names the credential profile this project uses, e.g. {"profile": "prod"} \u2014 or delete it to fall back to the default profile.`
+    );
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw pointerWithoutProfile(path, `holds ${jsonKind(parsed)}, not an object`);
+  }
+  const record = parsed;
+  const leaked = leakedKeys(record);
+  if (leaked.length > 0) {
+    throw new Error(
+      `${path} contains ${leaked.map((k) => `\`${k}\``).join(", ")}. This file is committed to version control and must never hold credentials \u2014 it names a profile and nothing else. Remove ${leaked.length === 1 ? "that key" : "those keys"}, and treat the value as leaked: run \`xanosdk logout\` for the affected profile and sign in again.`
+    );
+  }
+  const name = record.profile;
+  if (name === void 0) throw pointerWithoutProfile(path, "has no `profile` key");
+  if (typeof name !== "string") {
+    throw pointerWithoutProfile(path, `has a \`profile\` that is ${jsonKind(name)}, not a name`);
+  }
+  assertValidProfileName(name, path);
+  return name;
+}
+function jsonKind(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  return typeof value === "object" ? "an object" : `a ${typeof value}`;
+}
+function pointerWithoutProfile(path, what) {
+  return new UsageError(
+    `${path} ${what}. It names the credential profile this project uses, e.g. {"profile": "prod"} \u2014 rewrite it with \`xanosdk profile use <name>\`, or delete it to fall back to the default profile.`
+  );
+}
+function resolveProjectProfile(startDir) {
+  return findProjectPointer(startDir)?.profile;
+}
+function findProjectPointer(startDir) {
+  const path = findPointerFile(startDir);
+  if (path === void 0) return void 0;
+  return { path, profile: readPointerFile(path) };
+}
+function writePointerFile(dir, profile) {
+  assertValidProfileName(profile);
+  const path = join(resolve(dir), POINTER_FILE);
+  try {
+    atomicWrite(path, JSON.stringify({ profile }, null, 2) + "\n");
+  } catch (err) {
+    throw pointerFsFailure(err, path, "write");
+  }
+  return path;
+}
+function pointerFsFailure(err, path, op) {
+  const code = err?.code;
+  const pin = `It holds the project's profile pin, e.g. {"profile": "prod"}`;
+  switch (code) {
+    case "EISDIR":
+      return new UsageError(`${path} is a directory, not a file. ${pin}: remove or rename the directory, then run the command again.`);
+    case "ELOOP":
+      return new UsageError(`${path} is a symbolic link that loops back on itself (ELOOP). ${pin}: point it at a real file or remove it, then run the command again.`);
+    case "EACCES":
+    case "EPERM":
+    case "EROFS":
+      if (op === "read") return new UsageError(`${path} cannot be read by this user (${code}). Restore access with \`chmod u+r ${shellQuote(path)}\`, then run the command again.`);
+      return new UsageError(`${path} cannot be written: ${dirname(path)} is not writable here (${code}). Make it writable, then run the command again.`);
+    default:
+      return err;
+  }
+}
+function pointerRootFor(startDir) {
+  return walkUp(startDir).root;
+}
+function projectRootFor(startDir) {
+  const { root, bounded } = walkUp(startDir);
+  return bounded && resolve(root) !== resolve(homedir()) ? root : void 0;
+}
+
+export {
+  POINTER_FILE,
+  findPointerFile,
+  readPointerFile,
+  resolveProjectProfile,
+  findProjectPointer,
+  writePointerFile,
+  pointerRootFor,
+  projectRootFor
+};
+//# sourceMappingURL=chunk-5FBYXK5P.js.map

package/dist/chunk-5HVXPTU4.js

@@ -0,0 +1,323 @@
+import {
+  scanSource
+} from "./chunk-VAX3UZOY.js";
+
+// src/emit/register-calls.ts
+function withoutComments(src) {
+  let spans;
+  try {
+    spans = scanSource(src).spans;
+  } catch {
+    return src;
+  }
+  const out = src.split("");
+  for (const { kind, start, end } of spans) {
+    if (kind !== "comment") continue;
+    for (let i = start; i < end; i++) if (out[i] !== "\n") out[i] = " ";
+  }
+  return out.join("");
+}
+function literal(name) {
+  return name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function importsOf(code) {
+  const clause = `((?:(?!\\bfrom\\s*["'\`]|\\bimport\\b)[^;])*?)`;
+  const imports = new RegExp(
+    `(?<![\\w$.])import\\s+(?!type\\s*[{*]|type\\s+(?!from\\b)[\\w$])${clause}\\s*from\\s*(["'\`])([^"'\`\\n]+)\\2`,
+    "g"
+  );
+  const out = [];
+  for (const match of code.matchAll(imports)) {
+    const bound = match[1].trim();
+    const named = [];
+    const owners = [];
+    const brace = /\{([^}]*)\}/.exec(bound);
+    if (brace !== null) {
+      for (const part of brace[1].split(",")) {
+        const spec = /^\s*(type\s+)?([\w$]+|"[^"]*"|'[^']*')\s*(?:as\s+([\w$]+))?\s*$/.exec(part);
+        if (spec === null || spec[1] !== void 0) continue;
+        const imported = spec[2].replace(/^["']|["']$/g, "");
+        const local = spec[3] ?? imported;
+        if (imported === "default") owners.push(local);
+        else named.push({ imported, local });
+      }
+    }
+    const namespace = /\*\s*as\s+([\w$]+)/.exec(bound);
+    if (namespace !== null) owners.push(namespace[1]);
+    const head = /^([\w$]+)\s*(?:,|$)/.exec(bound);
+    if (head !== null) owners.push(head[1]);
+    out.push({ specifier: match[3], named, owners, start: match.index, end: match.index + match[0].length });
+  }
+  return out;
+}
+function codeOnly(code) {
+  try {
+    return scanSource(code).mask;
+  } catch {
+    return code;
+  }
+}
+function isPackage(specifier, pkg) {
+  return specifier === pkg || specifier.startsWith(`${pkg}/`);
+}
+function callsAny(mask, direct, owners, register) {
+  const out = { top: false, wrappers: [], opaque: false };
+  const alternatives = [
+    ...direct.length > 0 ? [`(${direct.map(literal).join("|")})`] : [],
+    ...owners.length > 0 ? [`(${owners.map(literal).join("|")})\\s*\\??\\.\\s*${literal(register)}`] : []
+  ];
+  if (alternatives.length === 0) return out;
+  const concise = conciseBodies(mask);
+  const exported = exportedWorkspace(mask);
+  for (const m of mask.matchAll(new RegExp(`(?<![\\w$.])(?:${alternatives.join("|")})\\s*(?:\\?\\.\\s*)?\\(`, "g"))) {
+    const name = m[1] ?? m[2];
+    const scopes = enclosingScopes(mask, m.index, concise);
+    let shadowed = false;
+    let wrapper;
+    const params = [];
+    for (let k = scopes.length - 1; k >= 0; k--) {
+      const header = scopes[k].header;
+      if (header === void 0) continue;
+      if (header.params.includes(name)) {
+        shadowed = true;
+        break;
+      }
+      params.push(...header.params);
+      if (k === 0 && header.name !== void 0) wrapper = header.name;
+    }
+    if (shadowed) continue;
+    const target = workspaceArgument(mask, m.index + m[0].length, exported, params);
+    if (target === "other") continue;
+    if (target === "unknown") out.opaque = true;
+    else if (scopes.length === 0) out.top = true;
+    else if (wrapper !== void 0) out.wrappers.push(wrapper);
+    else out.opaque = true;
+  }
+  return out;
+}
+function exportedWorkspace(mask) {
+  const named = /(?<![\w$.])export\s+default\s+(?!function\b|class\b|async\b|new\b)([\w$]+)\s*(?:;|$)/m.exec(mask) ?? /(?<![\w$.])export\s*\{[^}]*?(?<![\w$])([\w$]+)\s+as\s+default\b/.exec(mask);
+  if (named !== null) return { name: named[1] };
+  if (/(?<![\w$.])export\s+default\s+workspace\s*\(/.test(mask)) return "fresh";
+  return void 0;
+}
+function workspaceArgument(mask, at, exported, params) {
+  if (exported === void 0) return "same";
+  const arg = /^\s*([\w$]+)\s*[,)]/.exec(mask.slice(at))?.[1];
+  if (arg === void 0) return "same";
+  if (exported !== "fresh" && arg === exported.name) return "same";
+  if (params.includes(arg)) return "same";
+  const created = new RegExp(`(?<![\\w$])(?:const|let|var)\\s+${literal(arg)}\\s*(?::[^=]*)?=\\s*workspace\\s*\\(`).test(mask);
+  return created ? "other" : "unknown";
+}
+function conciseBodies(mask) {
+  const out = [];
+  for (const m of mask.matchAll(/=>/g)) {
+    let start = m.index + 2;
+    while (start < mask.length && /\s/.test(mask[start])) start++;
+    if (mask[start] === "{") continue;
+    let depth = 0;
+    let end = start;
+    for (; end < mask.length; end++) {
+      const c = mask[end];
+      if (c === "(" || c === "[" || c === "{") depth++;
+      else if (c === ")" || c === "]" || c === "}") {
+        if (depth === 0) break;
+        depth--;
+      } else if (depth === 0 && (c === "," || c === ";")) break;
+      else if (depth === 0 && c === "\n") {
+        const last = /(\S)\s*$/.exec(mask.slice(start, end))?.[1];
+        const next = /^\s*(\S)/.exec(mask.slice(end))?.[1];
+        const continued = last !== void 0 && /[=+\-*/%&|^!?:<>.~]/.test(last) || next !== void 0 && /[.?+\-*/%&|^:=<>]/.test(next);
+        if (!continued) break;
+      }
+    }
+    out.push({ start, end, header: functionHeader(mask.slice(Math.max(0, m.index - 500), m.index + 2)) });
+  }
+  return out;
+}
+function enclosingScopes(mask, at, concise) {
+  const scopes = openBraces(mask, at).map((b) => ({ start: b, header: functionHeader(mask.slice(Math.max(0, b - 500), b)) }));
+  for (const body of concise) if (body.start <= at && at < body.end) scopes.push({ start: body.start, header: body.header });
+  return scopes.sort((a, b) => a.start - b.start);
+}
+function openBraces(mask, at) {
+  const open = [];
+  for (let i = 0; i < at; i++) {
+    const c = mask[i];
+    if (c === "{") open.push(i);
+    else if (c === "}") open.pop();
+  }
+  return open;
+}
+function functionHeader(before) {
+  const declared = /(?<![\w$.])function\s*\*?\s*([\w$]+)?\s*(?:<[^>]*>)?\s*\(([^()]*)\)\s*(?::[^{}]*)?$/.exec(before);
+  const arrow = declared === null ? /(?:(?<![\w$])(?:const|let|var)\s+([\w$]+)\s*(?::[^=]*)?=\s*)?(?:async\s*)?(?:\(([^()]*)\)|([\w$]+))\s*(?::[^=]*)?=>\s*$/.exec(before) : null;
+  const m = declared ?? arrow;
+  if (m === null) return void 0;
+  let name = m[1];
+  if (declared !== null && name === void 0) {
+    name = /(?<![\w$])(?:const|let|var)\s+([\w$]+)\s*(?::[^=]*)?=\s*(?:async\s+)?function\s*\*?\s*(?:<[^>]*>)?\s*\([^()]*\)\s*(?::[^{}]*)?$/.exec(before)?.[1];
+  }
+  const list = m[2] ?? m[3] ?? "";
+  const params = [...list.replace(/:[^,=]*/g, "").matchAll(/[\w$]+/g)].map((p) => p[0]);
+  return { ...name === void 0 ? {} : { name }, params };
+}
+function callsAtTop(mask, names) {
+  if (names.length === 0) return false;
+  const concise = conciseBodies(mask);
+  for (const m of mask.matchAll(new RegExp(`(?<![\\w$.])(?:${names.map(literal).join("|")})\\s*\\(`, "g"))) {
+    if (/(?<![\w$])function\s*\*?\s*$/.test(mask.slice(Math.max(0, m.index - 30), m.index))) continue;
+    if (enclosingScopes(mask, m.index, concise).length === 0) return true;
+  }
+  return false;
+}
+function registerWrappers(code, pkg, register) {
+  return registerRead(code, pkg, register).wrappers;
+}
+function callsImportedAtTop(code, names) {
+  const locals = [];
+  for (const imp of importsOf(withoutComments(code))) {
+    if (!/^[./]/.test(imp.specifier)) continue;
+    for (const n of imp.named) if (names.includes(n.imported)) locals.push(n.local);
+  }
+  return callsAtTop(codeOnly(code), locals);
+}
+function destructured(pattern, register) {
+  for (const part of pattern.split(",")) {
+    const m = /^\s*([\w$]+)\s*(?::\s*([\w$]+))?\s*(?:=[^,]*)?$/.exec(part);
+    if (m !== null && m[1] === register) return m[2] ?? m[1];
+  }
+  return void 0;
+}
+function stringAt(code, at) {
+  const m = /^\s*(["'`])([^"'`\n\\$]*)\1/.exec(code.slice(at));
+  return m === null ? void 0 : { value: m[2], end: at + m[0].length };
+}
+function registerState(code, pkg, register) {
+  return registerRead(code, pkg, register).state;
+}
+function registerRead(code, pkg, register) {
+  const mask = codeOnly(code);
+  const direct = [];
+  const owners = [];
+  let unknown = false;
+  const importSpans = [];
+  for (const imp of importsOf(code)) {
+    if (!isPackage(imp.specifier, pkg)) continue;
+    for (const n of imp.named) if (n.imported === register) direct.push(n.local);
+    owners.push(...imp.owners);
+    importSpans.push([imp.start, imp.end]);
+  }
+  for (const m of mask.matchAll(/(?<![\w$.])import\s*\(/g)) {
+    const spec = stringAt(code, m.index + m[0].length);
+    if (spec === void 0 || !isPackage(spec.value, pkg)) continue;
+    const close = /^\s*\)/.exec(code.slice(spec.end));
+    if (close === null) {
+      unknown = true;
+      continue;
+    }
+    const after = spec.end + close[0].length;
+    const before = mask.slice(Math.max(0, m.index - 2e3), m.index);
+    const bound = /(?<![\w$])(?:const|let|var)(?:\s*\{([^}]*)\}|\s+([\w$]+))\s*=\s*(?:await\s+)?$/.exec(before);
+    if (bound !== null) {
+      if (bound[1] !== void 0) {
+        const local = destructured(bound[1], register);
+        if (local !== void 0) direct.push(local);
+      } else owners.push(bound[2]);
+      continue;
+    }
+    const member = new RegExp(`^\\s*\\)\\s*\\??\\.\\s*${literal(register)}\\s*(?:\\?\\.\\s*)?\\(`).exec(mask.slice(after));
+    if (/\(\s*await\s+$/.test(before) && member !== null) return { state: "yes", wrappers: [] };
+    unknown = true;
+  }
+  const reexport = new RegExp(`(?<![\\w$.])export\\s*(\\*|\\{[^}]*\\})[^;]*?\\bfrom\\s*(["'\`])([^"'\`\\n]+)\\2`, "g");
+  for (const m of code.matchAll(reexport)) {
+    if (isPackage(m[3], pkg) && (m[1] === "*" || new RegExp(`(?<![\\w$])${literal(register)}(?![\\w$])`).test(m[1]))) unknown = true;
+  }
+  for (const owner of owners) {
+    for (const m of mask.matchAll(new RegExp(`(?<![\\w$.])${literal(owner)}(?![\\w$])`, "g"))) {
+      if (importSpans.some(([s, e]) => m.index >= s && m.index < e)) continue;
+      const end = m.index + owner.length;
+      const rest = mask.slice(end);
+      const before = mask.slice(Math.max(0, m.index - 2e3), m.index);
+      if (/(?<![\w$])(?:const|let|var)\s+$/.test(before) && /^\s*=(?!=)/.test(rest)) continue;
+      if (/^\s*\??\.\s*[\w$]/.test(rest)) {
+        const alias = new RegExp(`(?<![\\w$])(?:const|let|var)\\s+([\\w$]+)\\s*=\\s*$`).exec(before);
+        if (alias !== null && new RegExp(`^\\s*\\??\\.\\s*${literal(register)}(?![\\w$])(?!\\s*[(?.[])`).test(rest)) direct.push(alias[1]);
+        continue;
+      }
+      const bracket = /^\s*(?:\?\.\s*)?\[/.exec(rest);
+      if (bracket !== null) {
+        const key = stringAt(code, end + bracket[0].length);
+        if (key === void 0 || !/^\s*\]/.test(code.slice(key.end))) {
+          unknown = true;
+          continue;
+        }
+        if (key.value !== register) continue;
+        const tail = mask.slice(key.end).replace(/^\s*\]/, "");
+        if (/^\s*(?:\?\.\s*)?\(/.test(tail)) return { state: "yes", wrappers: [] };
+        continue;
+      }
+      const pattern = /(?<![\w$])(?:const|let|var)\s*\{([^}]*)\}\s*=\s*$/.exec(before);
+      if (pattern !== null) {
+        const local = destructured(pattern[1], register);
+        if (local !== void 0) direct.push(local);
+        continue;
+      }
+      if (/^\s*\??\.\s*\(/.test(rest)) continue;
+      unknown = true;
+    }
+  }
+  for (const local of direct) {
+    for (const m of mask.matchAll(new RegExp(`(?<![\\w$.])${literal(local)}(?![\\w$])`, "g"))) {
+      if (importSpans.some(([s, e]) => m.index >= s && m.index < e)) continue;
+      const rest = mask.slice(m.index + local.length);
+      if (/^\s*(?:\?\.\s*)?\(/.test(rest)) continue;
+      const before = mask.slice(Math.max(0, m.index - 2e3), m.index);
+      if (/(?<![\w$])(?:const|let|var)\s+$/.test(before) || /(?<![\w$])(?:const|let|var)\s*\{[^}]*$/.test(before)) continue;
+      if (/(?<![\w$.])function\s*\*?\s*[\w$]*\s*(?:<[^>]*>)?\s*\([^()]*$/.test(before)) continue;
+      if (/\([^()]*$/.test(before) && /^[^()]*\)\s*(?::[^=]*)?=>/.test(rest)) continue;
+      unknown = true;
+    }
+  }
+  const calls = callsAny(mask, direct, owners, register);
+  if (calls.top || callsAtTop(mask, calls.wrappers)) return { state: "yes", wrappers: [] };
+  const nested = calls.opaque || calls.wrappers.length > 0;
+  return { state: unknown || nested ? "unknown" : "no", wrappers: [...new Set(calls.wrappers)] };
+}
+function callsRegister(code, pkg, register) {
+  return registerState(code, pkg, register) === "yes";
+}
+function packageOf(specifier) {
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function registeredModules(code) {
+  const mask = codeOnly(code);
+  const found = /* @__PURE__ */ new Map();
+  for (const imp of importsOf(code)) {
+    if (/^[./]/.test(imp.specifier) || /^[a-z]+:/i.test(imp.specifier)) continue;
+    const pkg = packageOf(imp.specifier);
+    if (pkg === "@xano/sdk") continue;
+    const candidates = new Set(imp.named.map((n) => n.imported).filter((n) => /^register[A-Z]/.test(n)));
+    for (const owner of imp.owners) {
+      for (const m of mask.matchAll(new RegExp(`(?<![\\w$.])${literal(owner)}\\s*\\??\\.\\s*(register[A-Z][\\w$]*)`, "g"))) {
+        candidates.add(m[1]);
+      }
+    }
+    for (const register of candidates) {
+      if (callsRegister(code, pkg, register)) found.set(`${pkg}\0${register}`, { pkg, register });
+    }
+  }
+  return [...found.values()];
+}
+
+export {
+  withoutComments,
+  registerWrappers,
+  callsImportedAtTop,
+  registerState,
+  registeredModules
+};
+//# sourceMappingURL=chunk-5HVXPTU4.js.map