@xano/sdk 1.0.0

package/dist/chunk-LRN4ZJCQ.js

@@ -0,0 +1,1145 @@
+import {
+  ROUTES_MANIFEST_BASENAME
+} from "./chunk-RTJRZFFY.js";
+import {
+  questionOrCancel
+} from "./chunk-65HWOMGV.js";
+import {
+  ensureWorkspaceEnvGitignored
+} from "./chunk-YHEFQUQB.js";
+import {
+  readVersion
+} from "./chunk-ETO6LGLD.js";
+import {
+  WORKSPACE_ENV_EXAMPLE_FILE,
+  renderWorkspaceEnvExample
+} from "./chunk-DAD3ONIS.js";
+import {
+  parseSlot,
+  requireBackendSlot
+} from "./chunk-STSFNCY4.js";
+import {
+  XANO_DIR,
+  changedOnDisk,
+  decideOverwrite,
+  isNonEmptyDir,
+  plannedAgentsMd,
+  scaffoldProject
+} from "./chunk-AHJWCYQO.js";
+import {
+  inProject,
+  installModules,
+  parseMarketplaceFlag,
+  preflightPackages,
+  rebaseLocalSpec,
+  renderXanoIndexWithModules
+} from "./chunk-DX4QR4B2.js";
+import {
+  npmViewVersion
+} from "./chunk-ZFDZKNGG.js";
+import {
+  shellWord
+} from "./chunk-FWD7AL6N.js";
+import {
+  isLocalSpecifier
+} from "./chunk-2GNFDZA2.js";
+import {
+  readToolchainBlock
+} from "./chunk-JTUKLCXS.js";
+import {
+  detectInstallRoot,
+  detectPackageManager,
+  installCommandFor,
+  userAgentVersion
+} from "./chunk-WRBKLYSJ.js";
+import {
+  localPackageName,
+  localPathOf,
+  packageNameOf,
+  readInstalledManifestState
+} from "./chunk-3LDULPRE.js";
+import {
+  statusLabel
+} from "./chunk-YLDALTWZ.js";
+import {
+  readEnvVar
+} from "./chunk-X2NL4KUO.js";
+import {
+  DEFAULT_FRAMEWORK,
+  FRAMEWORKS,
+  NODE_MIN,
+  allFrontendPresets,
+  checkJobDir,
+  checkWorkflowName,
+  checkWorkflowPath,
+  findFrontendPreset,
+  initLanding,
+  renderApiTs,
+  renderCheckWorkflow,
+  renderCnUtil,
+  renderEnvExample,
+  renderGitattributes,
+  renderGitignore,
+  renderIndexCss,
+  renderIndexHtml,
+  renderLambdaTsconfig,
+  renderPackageJson,
+  renderReadme,
+  renderThemeModule,
+  renderTsconfig,
+  renderViteConfig,
+  renderXanoExampleMd,
+  renderXanoIndex,
+  resolveFrameworkFlag,
+  sdkDep
+} from "./chunk-OPHB5ORL.js";
+import {
+  ICON_LIBRARIES,
+  resolveIconsFlag
+} from "./chunk-UCQ2VUTG.js";
+import {
+  UsageError,
+  blank,
+  cliPrefixAt,
+  detail,
+  displayPath,
+  error,
+  flagName,
+  flagNames,
+  info,
+  isMachineOutput,
+  projectFileCli,
+  projectSdkDir,
+  quotedNames,
+  spellProjectCli,
+  spellProjectSdkDir,
+  step,
+  style,
+  success,
+  unknownFlag,
+  warn,
+  writeJson
+} from "./chunk-PTHVMXZI.js";
+import {
+  suggest
+} from "./chunk-UTI5G6OJ.js";
+import {
+  shellQuote
+} from "./chunk-5ZSO4T2G.js";
+import {
+  ACCENTS,
+  BASE_COLORS,
+  DARK_MODES,
+  DEFAULT_DARK_MODE,
+  defaultThemeChoice,
+  findFont,
+  fontIdsFor,
+  normalizeRadius,
+  resolveDarkModeFlag,
+  resolveFontFlag,
+  resolveThemeFlag,
+  themeFromRegistryItem,
+  withRadius
+} from "./chunk-TFFGOFVZ.js";
+
+// src/emit/init-command.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
+import { spawnSync } from "child_process";
+import { basename, dirname, join, relative, resolve, sep } from "path";
+
+// src/emit/frontend-resolve.ts
+import { createInterface } from "readline/promises";
+
+// src/emit/theme-resolve.ts
+import { readFileSync } from "fs";
+import { resolve as resolvePath } from "path";
+function flagValue(raw, candidates, resolve2) {
+  try {
+    return resolve2();
+  } catch (err) {
+    if (!(err instanceof Error)) throw err;
+    const near = suggest(raw.trim().toLowerCase(), candidates);
+    throw new UsageError(err.message, near === void 0 ? {} : { suggestion: near });
+  }
+}
+function fontFlag(raw, slot) {
+  if (findFont(raw) !== void 0) {
+    try {
+      return resolveFontFlag(raw, slot);
+    } catch (err) {
+      throw err instanceof Error ? new UsageError(err.message) : err;
+    }
+  }
+  return flagValue(raw, fontIdsFor(slot), () => resolveFontFlag(raw, slot));
+}
+function themeIds() {
+  return BASE_COLORS.flatMap((b) => [b, ...ACCENTS.map((a) => `${b}-${a}`)]);
+}
+function isRegistryRef(value) {
+  return /^https?:\/\//i.test(value) || value.toLowerCase().endsWith(".json");
+}
+async function loadRegistryTheme(ref) {
+  if (/^https?:\/\//i.test(ref)) {
+    let res;
+    try {
+      res = await fetch(ref, { headers: { accept: "application/json" } });
+    } catch (err) {
+      throw new Error(
+        `Could not fetch the theme at ${ref}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (!res.ok) throw new Error(`Could not fetch the theme at ${ref}: ${statusLabel(res)}`);
+    const text2 = await res.text();
+    return themeFromRegistryItem(parseJson(text2, ref), ref);
+  }
+  const path = resolvePath(ref);
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (err) {
+    throw new Error(
+      `Could not read the theme file ${path}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return themeFromRegistryItem(parseJson(text, path), path);
+}
+function parseJson(text, source) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`${source} is not valid JSON \u2014 a registry theme is a JSON registry item.`);
+  }
+}
+async function themeFromFlag(raw) {
+  return isRegistryRef(raw.trim()) ? loadRegistryTheme(raw.trim()) : flagValue(raw, themeIds(), () => resolveThemeFlag(raw));
+}
+async function resolveThemeChoice(args) {
+  const dark = args.dark === void 0 || args.dark === "" ? DEFAULT_DARK_MODE : flagValue(args.dark, DARK_MODES, () => resolveDarkModeFlag(args.dark));
+  const fonts = {
+    ...args.font !== void 0 && args.font !== "" ? { sans: fontFlag(args.font, "sans") } : {},
+    ...args.fontMono !== void 0 && args.fontMono !== "" ? { mono: fontFlag(args.fontMono, "mono") } : {},
+    ...args.fontHeading !== void 0 && args.fontHeading !== "" ? { heading: fontFlag(args.fontHeading, "heading") } : {}
+  };
+  const icons = args.icons === void 0 || args.icons === "" ? void 0 : flagValue(args.icons, ICON_LIBRARIES, () => resolveIconsFlag(args.icons)).id;
+  let theme = args.theme !== void 0 && args.theme !== "" ? await themeFromFlag(args.theme) : defaultThemeChoice().theme;
+  if (args.radius !== void 0 && args.radius !== "") {
+    theme = withRadius(theme, flagValue(args.radius, [], () => normalizeRadius(args.radius)));
+  }
+  return {
+    theme,
+    dark,
+    ...Object.keys(fonts).length === 0 ? {} : { fonts },
+    ...icons === void 0 ? {} : { icons }
+  };
+}
+
+// src/emit/frontend-resolve.ts
+function defaultFrontendPreset() {
+  const preset = findFrontendPreset(DEFAULT_FRAMEWORK);
+  if (preset === void 0) {
+    throw new Error(`Default frontend preset "${DEFAULT_FRAMEWORK}" is missing from the table.`);
+  }
+  return preset;
+}
+async function promptFramework() {
+  const presets = allFrontendPresets();
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    process.stderr.write(
+      `
+Which frontend framework?
+` + presets.map((p, i) => `  ${i + 1}) ${p.label}${p.id === DEFAULT_FRAMEWORK ? " (default)" : ""}`).join("\n") + `
+`
+    );
+    const answer = await questionOrCancel(rl, `Enter a number or name, or leave blank for the default: `);
+    const token = answer.trim().toLowerCase();
+    if (token === "") return defaultFrontendPreset();
+    const byIndex = Number.parseInt(token, 10);
+    if (Number.isInteger(byIndex) && byIndex >= 1 && byIndex <= presets.length) {
+      return presets[byIndex - 1];
+    }
+    return findFrontendPreset(token) ?? defaultFrontendPreset();
+  } finally {
+    rl.close();
+  }
+}
+async function resolveFrontendPreset(flag) {
+  if (flag !== void 0 && flag !== "") return flagValue(flag, FRAMEWORKS, () => resolveFrameworkFlag(flag));
+  if (process.stdin.isTTY && process.stderr.isTTY) return promptFramework();
+  return defaultFrontendPreset();
+}
+
+// src/emit/init-command.ts
+function projectInstallOf(dir, env = process.env) {
+  const found = detectInstallRoot(dir, env);
+  const { manager, root } = found;
+  const member = relative(root, resolve(dir)).split(sep).join("/");
+  const needsVersion = !found.declared && (manager === "pnpm" || manager === "bun");
+  const version = needsVersion ? userAgentVersion(env.npm_config_user_agent, manager) ?? managerVersion(manager) : void 0;
+  return {
+    manager,
+    member,
+    declared: found.declared,
+    ...version === void 0 ? {} : { version },
+    ...found.ignoreWorkspace ? { ignoreWorkspace: true } : {},
+    ...repoDirOf(root)
+  };
+}
+function repoDirOf(root) {
+  if (existsSync(join(root, ".git"))) return {};
+  for (let d = dirname(root); ; d = dirname(d)) {
+    if (existsSync(join(d, ".git"))) return { repoDir: relative(d, root).split(sep).join("/") };
+    if (dirname(d) === d) return {};
+  }
+}
+function workflowPlacementNote(install, projectDir) {
+  const jobDir = checkJobDir(install);
+  if (jobDir === "") return "";
+  const file = checkWorkflowName(install);
+  return `GitHub runs workflows only from the repository root: move ${displayPath(join(projectDir, ".github", "workflows", file))} to ${displayPath(join(workflowRootDir(projectDir, jobDir), ".github", "workflows"))}/ (its steps already run in ${jobDir}).`;
+}
+function workflowMoveTarget(install, projectDir) {
+  const jobDir = checkJobDir(install);
+  if (jobDir === "") return void 0;
+  const target = join(workflowRootDir(projectDir, jobDir), ".github", "workflows", checkWorkflowName(install));
+  return existsSync(target) ? displayPath(target) : void 0;
+}
+function reportWorkflowPlacement(written, install, projectDir) {
+  if (!written.includes(checkWorkflowPath(install))) return;
+  const placement = workflowPlacementNote(install, projectDir);
+  if (placement !== "") info(placement);
+  const taken = workflowMoveTarget(install, projectDir);
+  if (taken !== void 0) {
+    warn(`${taken} already exists \u2014 moving the new workflow there replaces it.`, "init.workflow-exists", [
+      `Compare the two first, and keep whichever this project's CI should run.`
+    ]);
+  }
+}
+function workflowRootDir(projectDir, jobDir) {
+  return resolve(projectDir, ...jobDir.split("/").map(() => ".."));
+}
+function templateVarsFor(appName, dir, env = process.env) {
+  const install = projectInstallOf(dir, env);
+  return {
+    appName,
+    sdkVersion: readVersion(),
+    install,
+    cli: projectFileCli(dir, install.manager),
+    sdkDir: projectSdkDir(dir, install.manager)
+  };
+}
+function managerVersion(manager) {
+  const r = spawnSync(manager, ["--version"], { encoding: "utf8", timeout: 1e4, shell: process.platform === "win32" });
+  const v = r.status === 0 ? r.stdout.trim() : "";
+  return /^\d+\.\d+\.\d+/.test(v) ? v : void 0;
+}
+var TRANSLITERATED = {
+  \u0142: "l",
+  \u0141: "L",
+  \u00DF: "ss",
+  "\u1E9E": "SS",
+  \u00E6: "ae",
+  \u00C6: "AE",
+  \u00F8: "o",
+  \u00D8: "O",
+  \u0111: "d",
+  \u0110: "D",
+  \u00F0: "d",
+  \u00D0: "D",
+  \u00FE: "th",
+  \u00DE: "Th",
+  \u0153: "oe",
+  \u0152: "OE",
+  \u0127: "h",
+  \u0126: "H",
+  \u0131: "i",
+  \u0140: "l",
+  \u013F: "L",
+  \u0167: "t",
+  \u0166: "T"
+};
+function sanitizeAppName(raw) {
+  const name = raw.normalize("NFKD").replace(/\p{M}+/gu, "").replace(/\P{ASCII}/gu, (c) => TRANSLITERATED[c] ?? c).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return name === "" ? "app" : name;
+}
+function withXanoSdkBlock(rendered, xanosdk, existing) {
+  const merged = { ...existing, ...xanosdk };
+  if (Object.keys(merged).length === 0) return rendered;
+  const manifest = JSON.parse(rendered);
+  manifest["xanosdk"] = merged;
+  try {
+    return `${JSON.stringify(manifest, null, 2)}
+`;
+  } catch (error2) {
+    warn(
+      "A module's configuration could not be serialized and was left out of package.json.",
+      "init.module-config-dropped",
+      [error2 instanceof Error ? error2.message : String(error2)]
+    );
+    return rendered;
+  }
+}
+function projectShellFiles(vars, preset, parts, choice = defaultThemeChoice(), contributions = {}, existingXanoSdk) {
+  return spelledForProject(vars, [
+    {
+      path: "package.json",
+      // The plugin config block rides in the rendered manifest rather than
+      // being written after, so the scaffold has one file to reconcile instead
+      // of a second pass patching the one it just wrote. What the project
+      // already stored is folded in HERE rather than left to the scaffold's
+      // merge, because that merge only runs on the two-pass (`--marketplace`)
+      // path — a plain `init --force` writes this file once, and the block has
+      // to survive that too.
+      content: withXanoSdkBlock(
+        renderPackageJson(vars, preset, choice),
+        contributions.xanosdk,
+        existingXanoSdk
+      )
+    },
+    { path: "tsconfig.json", content: renderTsconfig(preset) },
+    { path: "xano/lambdas/tsconfig.json", content: renderLambdaTsconfig() },
+    { path: "vite.config.ts", content: renderViteConfig(preset) },
+    { path: ".gitignore", content: renderGitignore(preset) },
+    // The line-ending rule every generated artifact depends on. An installed
+    // toolchain module adds its own display rules below it, each inside a
+    // marked block keyed by the contributing package so a later reconcile can
+    // find, replace, or remove exactly that module's lines.
+    { path: ".gitattributes", content: renderGitattributes(contributions.gitattributes) },
+    // The job that keeps derived state honest. A module contributes no steps to
+    // it: its frozen check already rides on `npm run xano:check` through its
+    // `onBundle` hook, so there is nothing for a CI slot to add.
+    { path: checkWorkflowPath(vars.install), content: renderCheckWorkflow(vars.install) },
+    { path: ".env.example", content: renderEnvExample() },
+    { path: "README.md", content: parts.readme },
+    // Skipped when the framework supplies its own entry document — see
+    // FrontendPreset.ownsHtmlEntry. A second index.html beside SvelteKit's
+    // app.html would never be served and would still read as the entry point.
+    ...preset.ownsHtmlEntry === true ? [] : [{ path: "frontend/index.html", content: renderIndexHtml(vars, preset, choice) }],
+    // Shared across every framework: both UI kits resolve against the same
+    // Tailwind v4 semantic tokens and look for library code at
+    // frontend/src/lib/. Only the alias NAME pointing at that directory
+    // differs, and the preset owns that — as it does where `cn()` comes from.
+    { path: "frontend/src/index.css", content: renderIndexCss(choice) },
+    { path: "frontend/src/lib/api.ts", content: renderApiTs() },
+    { path: "frontend/src/lib/utils.ts", content: preset.libUtils ?? renderCnUtil(preset.libUtilsExtra) },
+    // The mode store behind `--dark toggle`, shared by both presets' toggles —
+    // it is plain DOM and localStorage, with nothing framework-shaped in it.
+    // `system` and `off` need no state, so nothing is written for them.
+    ...choice.dark === "toggle" ? [{ path: "frontend/src/lib/theme.ts", content: renderThemeModule() }] : [],
+    // The framework's own half: entry module, app component, vendored UI kit,
+    // and whatever tool config that kit's CLI reads.
+    ...preset.files(vars, parts.landing, choice)
+  ]);
+}
+function spelledForProject(vars, files) {
+  return files.map((f) => ({ ...f, content: spellProjectSdkDir(spellProjectCli(f.content, vars.cli), vars.sdkDir) }));
+}
+function buildFileSet(vars, preset, choice, contributions = {}, existingXanoSdk) {
+  return [
+    ...projectShellFiles(
+      vars,
+      preset,
+      { readme: renderReadme(vars, preset, choice), landing: initLanding(vars) },
+      choice,
+      contributions,
+      existingXanoSdk
+    ),
+    ...spelledForProject(vars, [
+      { path: "xano/index.ts", content: renderXanoIndex(vars) },
+      { path: "xano/EXAMPLE.md", content: renderXanoExampleMd(vars) }
+    ]),
+    // The BACKEND counterpart of `.env.example`, one directory down: the same
+    // pair, for the half of the project the engine runs. `xano/.env` itself is
+    // never written by a scaffold — only by the user, or by `xanosdk env pull`.
+    //
+    // Here rather than in `projectShellFiles`, which the PULL path also uses:
+    // `placeGeneratedFiles` emits this file with the names the source declares,
+    // and two entries for one path left the right one winning on array order
+    // alone. A bare `init` has no names, so it writes the empty template.
+    { path: WORKSPACE_ENV_EXAMPLE_FILE, content: renderWorkspaceEnvExample([]) }
+  ];
+}
+function resolveFromSource(raw) {
+  return parseSlot(requireBackendSlot("init", void 0, "from"), raw);
+}
+function rejectPullOnlyFlags(args) {
+  const passed = [
+    ...args.report !== void 0 ? ["--report"] : [],
+    ...args.skipRoundtrip ? ["--skip-roundtrip"] : [],
+    // Tokens are found by decoding a source; a plain init decodes nothing.
+    ...args.noSecrets ? ["--no-secrets"] : [],
+    // Confirms replacing a decoded `xano/` (`--from`), or the files an
+    // `init --force` over an existing project overwrites.
+    ...args.yes && !args.force ? ["--yes"] : [],
+    ...args.branch !== void 0 ? ["--branch"] : [],
+    // A plain init signs in to nothing, so an OAuth host has nowhere to go.
+    ...args.authHost !== void 0 ? ["--origin"] : []
+  ];
+  if (passed.length === 0) return;
+  if (passed.length === 1 && passed[0] === "--yes") {
+    throw new UsageError(
+      "`--yes` confirms what `--from` or `--force` replaces, so it does nothing without one of them. Add `--force` to scaffold over an existing project, or drop the flag.",
+      { helpFor: { command: "init" } }
+    );
+  }
+  throw new UsageError(
+    `${passed.join(" and ")} ${passed.length === 1 ? "describes" : "describe"} the pull that \`--from\` performs, so ${passed.length === 1 ? "it does" : "they do"} nothing without it. Add \`--from <source>\`, or drop ${passed.length === 1 ? "the flag" : "them"}.`,
+    { helpFor: { command: "init" } }
+  );
+}
+function decideScaffoldTarget(targetDir, force) {
+  const decided = decideOverwrite(targetDir, { force, regenerable: false });
+  if (decided === "refuse") {
+    throw new UsageError(
+      `Target directory ${targetDir} is not empty. ` + (process.stdin.isTTY === true ? `Re-run with --force to scaffold into it anyway.` : `Re-run with --force --yes to scaffold into it anyway (--yes confirms the overwrite, which cannot be asked without a terminal).`)
+    );
+  }
+  return decided;
+}
+function readLockEntryCount(targetDir) {
+  const path = join(targetDir, LOCK_REL);
+  if (!existsSync(path)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return parsed.objects !== null && typeof parsed.objects === "object" ? Object.keys(parsed.objects).length : 0;
+  } catch {
+    return 0;
+  }
+}
+async function confirmForcedOverwrite(targetDir, files, args, agents) {
+  const agentsMd = plannedAgentsMd(targetDir, {
+    agentsMd: !args.noAgentsMd,
+    appName: agents.appName,
+    regenerable: false,
+    sdkVersion: readVersion(),
+    frontend: agents.frontend,
+    theme: agents.theme
+  });
+  const changed = changedOnDisk(targetDir, agentsMd === void 0 ? files : [...files, agentsMd]);
+  if (changed.length === 0) return true;
+  warn(
+    `init --force overwrites ${changed.length} file${changed.length === 1 ? "" : "s"} already in ${targetDir}:`,
+    "init.overwrite",
+    [...changed.slice(0, 30), ...changed.length > 30 ? [`\u2026 and ${changed.length - 30} more`] : []]
+  );
+  if (args.yes === true) return true;
+  const { confirm } = await import("./prompt-II3F3LND.js");
+  const { yesRerun } = await import("./retry-command-AS5EVREX.js");
+  const { rerun, note } = yesRerun(args, "init");
+  const ok = await confirm(
+    `Overwrite ${changed.length === 1 ? "this file" : `these ${changed.length} files`} in ${targetDir}?`,
+    { flag: "--yes", refusal: { details: { written: false, files: changed }, rerun, note } }
+  );
+  if (!ok) info("Cancelled. Nothing was written.");
+  return ok;
+}
+function renderMinimalPackageJson(appName, sdkVersion) {
+  return `${JSON.stringify(
+    {
+      name: appName,
+      // yarn 1 ignores a workspace member with no version and then fails the
+      // add; the scaffold's own manifest carries the same one.
+      version: "0.1.0",
+      private: true,
+      type: "module",
+      // `sdkDep`, not `^version`: the scaffold's range is written out as
+      // `>=<version> <next major`, the same shape a module's peer range has, so
+      // every manifest this CLI writes or restores reads alike.
+      dependencies: { "@xano/sdk": sdkDep(sdkVersion) },
+      engines: { node: `>=${NODE_MIN}` }
+    },
+    null,
+    2
+  )}
+`;
+}
+var EXIT_MODULE_INSTALL_FAILED = 2;
+var PASS_ONE_REWRITES = ["package.json", "package-lock.json"];
+function snapshotForRollback(dir) {
+  if (!existsSync(dir)) return { dir, entries: void 0, saved: /* @__PURE__ */ new Map() };
+  const saved = /* @__PURE__ */ new Map();
+  for (const name of PASS_ONE_REWRITES) {
+    const path = join(dir, name);
+    if (existsSync(path)) saved.set(name, readFileSync2(path, "utf8"));
+  }
+  return { dir, entries: new Set(readdirSync(dir)), saved };
+}
+function rollBackPassOne(snap, err) {
+  let note;
+  try {
+    if (snap.entries === void 0) {
+      rmSync(snap.dir, { recursive: true, force: true });
+      note = `Nothing was left behind: ${snap.dir} was created by this run and has been removed.`;
+    } else {
+      for (const entry of readdirSync(snap.dir)) {
+        if (!snap.entries.has(entry)) rmSync(join(snap.dir, entry), { recursive: true, force: true });
+      }
+      for (const [name, text] of snap.saved) writeFileSync(join(snap.dir, name), text, "utf8");
+      note = snap.entries.has("node_modules") ? `What this run wrote into ${snap.dir} was undone, except node_modules, which already existed.` : `Nothing was left behind: what this run wrote into ${snap.dir} has been removed.`;
+    }
+  } catch (cleanup) {
+    note = `Cleaning up ${snap.dir} failed (${cleanup instanceof Error ? cleanup.message : String(cleanup)}); remove it before re-running.`;
+  }
+  if (err instanceof Error) err.message = `${err.message} ${note}`;
+}
+async function runInitCommand(args) {
+  if (args.from !== void 0) {
+    if (args.unknownFlags.length > 0) {
+      throw unknownFlag(args.unknownFlags, { command: "init" });
+    }
+    if (args.marketplace.length > 0) {
+      throw new UsageError(
+        "`--from` and `--marketplace` do not compose: `--from` writes a project around a backend that already exists. Scaffold it first, then add each package with `xanosdk marketplace install <package>`.",
+        { helpFor: { command: "init" } }
+      );
+    }
+    const source = resolveFromSource(args.from);
+    if (source.kind === "file") await refuseUnknownProfileFlag(args, resolve(args.positionals[0] ?? "."));
+    const { runInitFromCommand } = await import("./codegen-command-VR2GWR6C.js");
+    return runInitFromCommand(args, source);
+  }
+  rejectPullOnlyFlags(args);
+  const targetArg = args.positionals[0] ?? ".";
+  const targetDir = resolve(targetArg);
+  await refuseUnknownProfileFlag(args, targetDir);
+  const appName = sanitizeAppName(args.name ?? basename(targetDir));
+  const existingXanoSdk = readToolchainBlock(targetDir);
+  const typedModules = parseMarketplaceFlag(args.marketplace);
+  if (args.framework !== void 0) await resolveFrontendPreset(args.framework);
+  await resolveThemeChoice(args);
+  const unclaimable = args.unknownFlags.filter((f) => {
+    const name = flagName(f);
+    if (!name.startsWith("--")) return true;
+    const bare = name.slice(2);
+    return flagNames().includes(bare) || bare.startsWith("no-") && flagNames().includes(bare.slice(3));
+  });
+  if (unclaimable.length > 0) throw unknownFlag(unclaimable, { command: "init" });
+  const { refusePlugAndPlay } = await import("./project-dependency-KSH63ODT.js");
+  const { retryCommand } = await import("./retry-command-AS5EVREX.js");
+  refusePlugAndPlay(targetDir, retryCommand(args, { command: "init" }).command);
+  const { resolveMarketplaceSpecs, withCatalogueRerun } = await import("./marketplace-resolve-LY32JES5.js");
+  const resolvedModules = typedModules.length === 0 ? [] : await resolveMarketplaceSpecs(typedModules, "xanosdk init --marketplace").catch(async (err) => {
+    throw await withCatalogueRerun(err, args, "init");
+  });
+  const requestedModules = resolvedModules.map((spec) => rebaseLocalSpec(spec, process.cwd(), targetDir));
+  if (args.noInstall) for (const spec of requestedModules) deferredDependency(spec, targetDir);
+  if (requestedModules.length > 0) preflightPackages(requestedModules, targetDir);
+  const deferredModules = args.noInstall ? requestedModules : [];
+  const modules = args.noInstall ? [] : requestedModules;
+  let overwrite;
+  let moduleOutcome;
+  const forcedOver = args.force && isNonEmptyDir(targetDir);
+  const hadLock = readLockEntryCount(targetDir);
+  let earlyPreset;
+  let passOne;
+  if (modules.length > 0) {
+    overwrite = decideScaffoldTarget(targetDir, args.force);
+    if (forcedOver) {
+      earlyPreset = await resolveFrontendPreset(args.framework);
+      const earlyTheme = await resolveThemeChoice(args);
+      const provisional = buildFileSet(
+        { appName, sdkVersion: readVersion() },
+        earlyPreset,
+        earlyTheme,
+        { gitattributes: [], xanosdk: {} },
+        existingXanoSdk
+      );
+      const agents = { appName, frontend: earlyPreset, theme: earlyTheme };
+      if (!await confirmForcedOverwrite(targetDir, provisional, args, agents)) return;
+    }
+    passOne = snapshotForRollback(targetDir);
+    mkdirSync(targetDir, { recursive: true });
+    writeFileSync(
+      join(targetDir, "package.json"),
+      renderMinimalPackageJson(appName, readVersion()),
+      "utf8"
+    );
+    blank();
+    moduleOutcome = await installModules(targetDir, modules);
+  }
+  let scaffolded = false;
+  try {
+    const { discoverToolchainPlugins } = await import("./toolchain-modules-5EAZUONB.js");
+    const toolchain = await discoverToolchainPlugins(targetDir, { frozen: false, configuring: true });
+    const preset = earlyPreset ?? await resolveFrontendPreset(args.framework);
+    const choice = await resolveThemeChoice(args);
+    const { pluginPrompter } = await import("./plugin-prompt-4VA3B4FF.js");
+    const { contributionOutcomes, recordedConfig, runPluginQuestionnaire } = await import("./plugin-contributions-WRNY5ABG.js");
+    const { answers: pluginAnswers } = await runPluginQuestionnaire(toolchain.loaded, {
+      host: "init",
+      unknownFlags: args.unknownFlags,
+      // `init --json` answers with one document, so a question prompted under it
+      // would interleave with a stdout a script is about to parse.
+      prompter: pluginPrompter({ json: args.json })
+    });
+    const outcomes = contributionOutcomes(toolchain.loaded, pluginAnswers, "init");
+    const gitattributes = outcomes.flatMap((o) => {
+      const lines = o.parts?.gitattributes ?? [];
+      return lines.length === 0 ? [] : [{ pkg: o.pkg, version: o.version, lines }];
+    });
+    const pluginConfig = {};
+    for (const outcome of outcomes) {
+      const record = recordedConfig(outcome, existingXanoSdk?.[outcome.pkg]);
+      if (record !== void 0) pluginConfig[outcome.pkg] = record;
+    }
+    const vars = templateVarsFor(appName, targetDir);
+    overwrite ??= decideScaffoldTarget(targetDir, args.force);
+    const fileSet = buildFileSet(vars, preset, choice, { gitattributes, xanosdk: pluginConfig }, existingXanoSdk);
+    if (forcedOver && earlyPreset === void 0 && !await confirmForcedOverwrite(targetDir, fileSet, args, { appName, frontend: preset, theme: choice }))
+      return;
+    step(
+      `Scaffolding ${style.bold(appName)} (${preset.label}, ${choice.theme.label}) in ${targetDir}`
+    );
+    const pin = await planProfilePin(args, targetDir);
+    scaffolded = true;
+    const result = await scaffoldProject({
+      targetDir,
+      files: [...fileSet, ...pin.file === null ? [] : [pin.file]],
+      agentsMd: !args.noAgentsMd,
+      appName,
+      force: args.force,
+      noInstall: args.noInstall,
+      // An `init` project's `xano/` is hand-authored, never machine-written: it is
+      // not refreshable, and `--force` must not clear it.
+      regenerable: false,
+      overwrite,
+      // Only this path writes package.json twice, so only this path merges.
+      mergePackageJson: modules.length > 0,
+      // A project install failing for the reason an add-on's already did (the
+      // manifest they share names a range npm has no version for) is that one
+      // failure, already warned — not a second warning repeating npm's text.
+      reportedNpmFailures: moduleOutcome?.reported,
+      sdkVersion: readVersion(),
+      frontend: preset,
+      theme: choice
+    });
+    ensureWorkspaceEnvGitignored(targetDir);
+    if (vars.install?.ignoreWorkspace === true) {
+      info(
+        `${targetDir} is below a pnpm workspace that does not list it, so it installs on its own: \`${installCommandFor(targetDir)}\`. To make it a member instead, add its path to that workspace's pnpm-workspace.yaml.`
+      );
+    }
+    reportWorkflowPlacement(result.written, vars.install, targetDir);
+    pin.report();
+    const pinnedProfile = pin.name;
+    info(`Theme: ${choice.theme.label} \u2014 dark mode: ${choice.dark}`);
+    if (deferredModules.length > 0) {
+      recordDeferredModules(targetDir, deferredModules);
+      info(`Added to package.json, not installed (--no-install): ${deferredModules.join(", ")}.`);
+      const listed = deferredModules.filter((m) => !isLocalSpecifier(m)).map(packageNameOf);
+      const local = deferredModules.flatMap((m) => {
+        const name = localPackageName(m, targetDir);
+        return name === void 0 ? [] : [`${name} (${localPathOf(m)})`];
+      });
+      detail(
+        `Run \`${inProject(targetDir)}${installCommandFor(targetDir)}\`, then register ${deferredModules.length === 1 ? "it" : "each"} in xano/index.ts` + (listed.length === 0 ? "" : ` \u2014 ${listed.map((m) => `\`xanosdk marketplace details ${shellQuote(m)}\``).join(", ")} print${listed.length === 1 ? "s" : ""} the wiring`) + (local.length === 0 ? "" : `${listed.length === 0 ? " \u2014" : ";"} ${local.join(", ")}: see ${local.length === 1 ? "its" : "each one's"} README`) + `.`
+      );
+    }
+    let derived = [];
+    let entryFailed = false;
+    let addonEnv = [];
+    if (moduleOutcome !== void 0) {
+      const outcome = moduleOutcome;
+      if (outcome.installed.length > 0) {
+        writeFileSync(
+          join(targetDir, "xano", "index.ts"),
+          spellProjectCli(renderXanoIndexWithModules(appName, outcome.registered, outcome.unwired), vars.cli),
+          "utf8"
+        );
+      }
+      if (outcome.toolchain.length > 0) {
+        info(
+          `Extends the CLI (nothing to register): ${outcome.toolchain.join(", ")}. Configured in this project's package.json "xanosdk" block.`
+        );
+      }
+      if (outcome.registered.length > 0) {
+        info(`Registered in xano/index.ts: ${outcome.registered.map((m) => m.pkg).join(", ")}`);
+        if (result.install === "installed" && sdkResolves(targetDir)) {
+          const derivation = await writeDerivedFiles(
+            targetDir,
+            (env) => spellProjectCli(renderXanoIndexWithModules(appName, outcome.registered, outcome.unwired, env), vars.cli)
+          );
+          derived = derivation.written;
+          entryFailed = derivation.failed === true;
+          addonEnv = derivation.env;
+        }
+      }
+      for (const module of outcome.unwired) {
+        warn(
+          `${module.pkg} is installed but not registered \u2014 ${runFromHere(module.reason, targetDir)}.`,
+          "module.unregistered",
+          [`Import it in xano/index.ts and register it onto the workspace yourself.`]
+        );
+      }
+      if (outcome.failed.length > 0) {
+        process.exitCode = EXIT_MODULE_INSTALL_FAILED;
+      }
+      if (outcome.legacyPeer.length > 0) {
+        warn(
+          `Installed with --legacy-peer-deps: ${outcome.legacyPeer.join(", ")}. npm refused the tree on peer ranges, so this one is not the tree npm would build on its own.`,
+          "module.legacy-peer-deps"
+        );
+      }
+    }
+    if (result.install === "installed") {
+      const { skewedProjectSdk } = await import("./project-sdk-REPPOIBD.js");
+      const installedSdk = skewedProjectSdk(targetDir, readVersion());
+      if (installedSdk !== void 0) {
+        const { reconcileWithInstalled } = await import("./upgrade-command-QHNFWM7O.js");
+        const rendered = reconcileWithInstalled(targetDir);
+        if (rendered.length > 0) {
+          info(`Rendered ${rendered.join(", ")} with the installed @xano/sdk ${installedSdk.version} (this CLI is ${readVersion()}).`);
+        }
+      }
+    }
+    blank();
+    const shortBy = moduleOutcome?.failed.length ?? 0;
+    const manager = detectPackageManager(targetDir);
+    const installLine = installCommandFor(targetDir);
+    if (result.install === "failed") {
+      error(`Project scaffolded, but its dependencies are NOT installed \u2014 ${manager} install failed (its reason is above).`);
+      detail(`Fix what ${manager} reported, then run \`${installLine}\` in ${targetDir}. Nothing needs to be scaffolded again.`);
+      process.exitCode = EXIT_MODULE_INSTALL_FAILED;
+    } else if (entryFailed) {
+      error(`Project scaffolded, but it does not build yet \u2014 xano/index.ts fails to load (the reason is above).`);
+      detail(`Fix xano/index.ts, then run \`npm run xano:export\` in ${targetDir}. Nothing needs to be scaffolded again.`);
+      process.exitCode = EXIT_MODULE_INSTALL_FAILED;
+    } else {
+      success(
+        shortBy === 0 ? "Project ready." : `Project ready, without ${shortBy} add-on${shortBy === 1 ? "" : "s"}.`
+      );
+    }
+    if (moduleOutcome !== void 0 && shortBy > 0) {
+      const failed = moduleOutcome.failed;
+      detail(
+        `Not installed: ${failed.join(", ")} (${manager}'s reason is above). Add ${failed.length === 1 ? "it" : "them"} with ` + failed.map((pkg) => `\`${inProject(targetDir)}xanosdk marketplace install ${shellWord(pkg)}\``).join(", ") + ` once ${manager}'s error is fixed.`
+      );
+    }
+    const cdHint = targetDir === process.cwd() ? "" : `  cd ${shellWord(targetArg)}
+`;
+    detail(
+      `Next steps:
+` + cdHint + (result.install === "installed" || sdkResolves(targetDir) ? `` : `  ${installLine}
+`) + `  npm run dev            # run the frontend
+` + loginNextStep(pin, targetDir) + // A declared name with no line in xano/.env refuses the deploy, so the
+      // step that supplies it comes first.
+      (addonEnv.length > 0 ? `  cp xano/.env.example xano/.env   # then set ${addonEnv.join(", ")} \u2014 the add-ons read ${addonEnv.length === 1 ? "it" : "them"}
+` : ``) + `  npm run xano:deploy    # build the frontend, then deploy \u2192 live ephemeral URL
+
+` + (hadLock !== void 0 ? `xano/xano.lock was kept (${hadLock} ${hadLock === 1 ? "entry" : "entries"}). An entry the new xano/index.ts
+does not export fails \`npm run xano:check\`; once those objects are gone for good,
+\`${projectCli(targetDir)} lock prune ./xano/index.ts --yes\` drops them.` : (derived.includes(LOCK_REL) ? `xano/xano.lock was written for the add-ons' objects \u2014 commit it. It pins each
+` : `The first export or deploy writes xano/xano.lock \u2014 commit it. It pins each
+`) + `object's identity, so renaming one later renames it instead of deleting and
+recreating it. See "xano.lock \u2014 commit it" in the README.`) + (derived.includes(ROUTES_REL) ? `
+${ROUTES_REL} was written for the add-ons' endpoints \u2014 commit it too.` : "")
+    );
+    if (isMachineOutput(args)) {
+      writeJson({
+        dir: targetDir,
+        name: appName,
+        framework: preset.id,
+        theme: choice.theme.id,
+        dark: choice.dark,
+        install: result.install,
+        pinnedProfile,
+        // `--no-install` still names what it added: recorded in package.json,
+        // not installed, not wired.
+        ...moduleOutcome === void 0 && deferredModules.length > 0 ? {
+          marketplace: {
+            added: [...deferredModules],
+            installed: [],
+            failed: [],
+            registered: [],
+            unwired: [],
+            toolchain: []
+          }
+        } : {},
+        ...moduleOutcome === void 0 ? {} : {
+          marketplace: {
+            installed: moduleOutcome.installed,
+            failed: moduleOutcome.failed,
+            registered: moduleOutcome.registered.map((m) => m.pkg),
+            unwired: moduleOutcome.unwired.map((m) => m.pkg),
+            toolchain: moduleOutcome.toolchain
+          }
+        }
+      });
+    }
+  } catch (err) {
+    if (passOne !== void 0 && !scaffolded) rollBackPassOne(passOne, err);
+    throw err;
+  }
+}
+var LOCK_REL = `${XANO_DIR}/xano.lock`;
+var ROUTES_REL = `${XANO_DIR}/${ROUTES_MANIFEST_BASENAME}`;
+function recordDeferredModules(targetDir, specifiers) {
+  const path = join(targetDir, "package.json");
+  const pkg = JSON.parse(readFileSync2(path, "utf8"));
+  const deps = { ...pkg.dependencies ?? {} };
+  for (const specifier of specifiers) {
+    const local = deferredDependency(specifier, targetDir);
+    if (local !== void 0) {
+      deps[local.name] = local.spec;
+      continue;
+    }
+    const name = packageNameOf(specifier);
+    const pinned = specifier.length > name.length + 1 ? specifier.slice(name.length + 1) : void 0;
+    if (pinned !== void 0) {
+      deps[name] = pinned;
+      continue;
+    }
+    const view = npmViewVersion(name, targetDir);
+    deps[name] = view.ok ? `^${view.version}` : "latest";
+  }
+  pkg.dependencies = Object.fromEntries(Object.entries(deps).sort(([a], [b]) => a.localeCompare(b)));
+  writeFileSync(path, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+}
+function deferredDependency(specifier, targetDir) {
+  if (!isLocalSpecifier(specifier)) return void 0;
+  const name = localPackageName(specifier, targetDir);
+  if (name !== void 0) return { name, spec: `file:${localPathOf(specifier)}` };
+  throw new UsageError(
+    `\`--marketplace ${specifier}\` with \`--no-install\`: its package name is only known once it is installed, so it cannot be recorded in package.json. Drop --no-install, or add it once the project exists with \`${inProject(targetDir)}xanosdk marketplace install ${shellWord(specifier)}\`.`,
+    { helpFor: { command: "init" } }
+  );
+}
+async function writeDerivedFiles(targetDir, renderIndexWithEnv) {
+  const written = [];
+  let declaredEnv = [];
+  const lockPath = join(targetDir, LOCK_REL);
+  const routesPath = join(targetDir, ROUTES_REL);
+  try {
+    const { loadDefault, checkStandInTokens } = await import("./cli.js");
+    const { Xano } = await import("./xano-ICFUSPFR.js");
+    const { createLockContext, lockKey, mergeObserved } = await import("./lock-MRRHW5GS.js");
+    const { resetLockOverrides, seedLockOverrides } = await import("./store-6VNCD4D7.js");
+    const { readLockFile, writeLockFile } = await import("./io-RC56QSN5.js");
+    const { setDiagnosticSink } = await import("./diagnostics-UEAAHWVF.js");
+    const { planRouteManifest, renderPlannedManifest } = await import("./routes-manifest-SNWUVBT6.js");
+    const existing = existsSync(lockPath) ? readLockFile(lockPath) : void 0;
+    resetLockOverrides();
+    if (existing !== void 0) seedLockOverrides(existing);
+    const ctx = createLockContext(existing);
+    const { envNamesRead } = await import("./guards-4EBNCZDC.js");
+    const { refreshEnvExample } = await import("./env-example-refresh-ET5HMMDW.js");
+    const def = await loadDefault(join(targetDir, XANO_DIR, "index.ts"));
+    if (!Xano.isXano(def)) return { written, env: declaredEnv };
+    const previousSink = setDiagnosticSink(() => {
+    });
+    let payload;
+    try {
+      payload = def.export({ lock: ctx, documentationTokens: checkStandInTokens(def).values }).payload;
+    } finally {
+      setDiagnosticSink(previousSink);
+    }
+    const sections = {};
+    for (const [key, value] of Object.entries(payload)) if (Array.isArray(value)) sections[key] = value;
+    const env = envNamesRead(sections);
+    if (env.length > 0) {
+      writeFileSync(join(targetDir, XANO_DIR, "index.ts"), renderIndexWithEnv(env), "utf8");
+      refreshEnvExample(join(targetDir, XANO_DIR), Object.fromEntries(env.map((name) => [name, ""])));
+      declaredEnv = env;
+    }
+    const { lock } = mergeObserved(ctx.lock, ctx.observed);
+    if (existing === void 0 && Object.keys(lock.objects).length > 0) {
+      writeLockFile(lockPath, lock);
+      written.push(LOCK_REL);
+    }
+    const manifest = renderPlannedManifest(
+      planRouteManifest(payload, (kind, name) => lock.objects[lockKey(kind, name)]?.canonical)
+    );
+    if (manifest !== void 0) {
+      writeFileSync(routesPath, manifest, "utf8");
+      written.push(ROUTES_REL);
+    }
+  } catch (err) {
+    warn(
+      `xano/index.ts does not load yet, so ${LOCK_REL} and ${ROUTES_REL} were not written: ${err instanceof Error ? err.message : String(err)}`,
+      "init.lock-derive-failed",
+      [`Fix xano/index.ts, then run \`npm run xano:export\` \u2014 it writes both.`]
+    );
+    return { written, env: declaredEnv, failed: true };
+  }
+  return { written, env: declaredEnv };
+}
+async function refuseUnknownProfileFlag(args, targetDir) {
+  const { ENV_PROFILE } = await import("./profile-select-74TRDEPD.js");
+  const envRaw = readEnvVar(ENV_PROFILE)?.trim();
+  const fromEnv = args.profile === void 0 && envRaw !== void 0;
+  const name = args.profile ?? (fromEnv ? envRaw : void 0);
+  if (name === void 0) return;
+  if (fromEnv && targetDir !== void 0) {
+    const { POINTER_FILE } = await import("./profile-pointer-GRWJU3YD.js");
+    if (existsSync(join(targetDir, POINTER_FILE))) return;
+  }
+  const { readCredentialFile, resolveAuthFilePath, profileNames, loginHint } = await import("./store-ARM6VMO5.js");
+  const path = resolveAuthFilePath(args, "read");
+  const file = readCredentialFile(path);
+  const stored = file === null ? [] : profileNames(file);
+  if (stored.includes(name)) return;
+  const { ProfileNotFoundError } = await import("./token-NICJUTMT.js");
+  const have = stored.length === 0 ? "Nothing is signed in on this machine." : `Stored profiles: ${quotedNames(stored)}.`;
+  throw new ProfileNotFoundError(
+    `No credential profile "${name}" in ${path} (from ${fromEnv ? `$${ENV_PROFILE}` : "--profile"}), so there is nothing to pin this project to. ${have} Run ${loginHint(name)} to add it, or name a stored one${fromEnv ? ` (or unset ${ENV_PROFILE})` : ""}.`,
+    { name, source: fromEnv ? "env" : "flag" },
+    stored
+  );
+}
+async function envCredentialSet() {
+  const { envMetaCredentialVarsSet } = await import("./token-NICJUTMT.js");
+  return envMetaCredentialVarsSet().length > 0;
+}
+function loginNextStep(pin, projectDir) {
+  return pin.signedIn ? "" : `  ${projectCli(projectDir)} login       # authenticate with Xano
+`;
+}
+function projectCli(projectDir) {
+  const prefix = cliPrefixAt(projectDir);
+  return prefix === "xanosdk" || prefix === "npx @xano/sdk" ? "npx xanosdk" : prefix;
+}
+function runFromHere(text, targetDir) {
+  return text.replace(/`npx xanosdk /g, `\`${inProject(targetDir)}xanosdk `);
+}
+async function planProfilePin(args, targetDir, opts = {}) {
+  const { POINTER_FILE, readPointerFile } = await import("./profile-pointer-GRWJU3YD.js");
+  const { readCredentialFile, resolveAuthFilePath, profileNames, loginHint } = await import("./store-ARM6VMO5.js");
+  const credentialPath = resolveAuthFilePath(args, "read");
+  const file = readCredentialFile(credentialPath);
+  const signedIn = file !== null && profileNames(file).length > 0 || await envCredentialSet();
+  const pointerPath = join(targetDir, POINTER_FILE);
+  if (existsSync(pointerPath)) {
+    let pinned = null;
+    try {
+      pinned = readPointerFile(pointerPath) ?? null;
+    } catch {
+    }
+    const unknownPin = pinned !== null && !(file !== null && profileNames(file).includes(pinned)) && !await envCredentialSet();
+    return {
+      // What the project IS pinned to — `init --force` over a pinned target
+      // keeps the pin, so reporting null here said the opposite of the file.
+      name: pinned,
+      signedIn,
+      file: null,
+      report: () => {
+        detail(`Already pinned: ${POINTER_FILE} is left as it is.`);
+        if (unknownPin) {
+          warn(
+            `${POINTER_FILE} pins profile "${pinned}", which this machine does not have \u2014 commands here will fail until you run ${loginHint(pinned)}, or re-pin with \`${inProject(targetDir)}xanosdk profile use <name>\`.`,
+            "profile.pin-missing"
+          );
+        }
+      }
+    };
+  }
+  if (opts.credentialRead === true) {
+    const { environmentCredentialVars } = await import("./token-NICJUTMT.js");
+    const env = environmentCredentialVars();
+    if (env.complete) {
+      return {
+        name: null,
+        signedIn,
+        file: null,
+        report: () => detail(
+          `Not pinned: this read used the environment credential (${env.vars.join(", ")}), not a stored profile. To pin one, run \`${inProject(targetDir)}xanosdk profile use <name>\` \u2014 it writes ${POINTER_FILE}.`
+        )
+      };
+    }
+  }
+  const { resolveActiveProfile } = await import("./profile-select-74TRDEPD.js");
+  const selection = resolveActiveProfile({
+    flag: args.profile,
+    fileDefault: file?.default,
+    // Nothing is pinned yet — that is what this function is about to decide —
+    // so the pointer rung has nothing to contribute to its own creation.
+    readPointer: () => void 0
+  });
+  const stored = file === null ? [] : profileNames(file);
+  if (!stored.includes(selection.name)) {
+    const env = stored.length === 0 ? (await import("./token-NICJUTMT.js")).environmentCredentialVars() : void 0;
+    const storeEnv = env?.complete === true ? await storeEnvCredentialCommand(credentialPath, targetDir) : "";
+    return {
+      name: null,
+      signedIn,
+      file: null,
+      report: () => detail(
+        env?.complete === true ? `Not pinned: commands here use the environment credential (${env.vars.join(", ")}), not a stored profile. To pin it, store it as a profile and pin that: \`${storeEnv}\` \u2014 it writes ${POINTER_FILE}.` : stored.length === 0 ? `Not pinned: no signed-in profile to pin to yet. Run \`${inProject(targetDir)}xanosdk login && xanosdk profile use <name>\` to write ${POINTER_FILE}.` : `Not pinned: none of the signed-in profiles (${quotedNames(stored)}) is the default. Run \`${inProject(targetDir)}xanosdk profile use <name>\` to write ${POINTER_FILE}.`
+      )
+    };
+  }
+  if (selection.source === "file-default" || selection.source === "implicit") {
+    const elsewhere = await envAddressesElsewhere(file, selection.name, credentialPath);
+    if (elsewhere !== null) {
+      return {
+        name: null,
+        signedIn,
+        file: null,
+        report: () => detail(
+          `Not pinned: commands here use the environment credential (${elsewhere.env}), not the default profile "${selection.name}" (${elsewhere.stored}). To pin "${selection.name}" deliberately, run \`${inProject(targetDir)}xanosdk profile use ${shellWord(selection.name)}\` \u2014 it writes ${POINTER_FILE}.`
+        )
+      };
+    }
+  }
+  const { writePointerFile } = await import("./profile-pointer-GRWJU3YD.js");
+  return {
+    name: selection.name,
+    signedIn,
+    // The same bytes `writePointerFile` writes.
+    file: { path: POINTER_FILE, content: `${JSON.stringify({ profile: selection.name }, null, 2)}
+` },
+    report: () => {
+      if (!existsSync(join(targetDir, POINTER_FILE))) writePointerFile(targetDir, selection.name);
+      info(`Pinned to profile "${selection.name}" in ${POINTER_FILE} \u2014 commit it, so every clone deploys here.`);
+    }
+  };
+}
+async function envAddressesElsewhere(file, name, credentialPath) {
+  const instance = readEnvVar("XANO_INSTANCE_URL")?.trim();
+  const workspace = readEnvVar("XANO_WORKSPACE_ID")?.trim();
+  if (instance === void 0 || workspace === void 0 || readEnvVar("XANO_META_TOKEN") === void 0) return null;
+  const { readProfile, sameOriginAs } = await import("./store-ARM6VMO5.js");
+  let record;
+  try {
+    record = readProfile(file, name, credentialPath);
+  } catch {
+    return null;
+  }
+  if (record === null) return null;
+  const storedInstance = record.type === "token" ? record.instance_base_url : record.instance;
+  if (sameOriginAs(storedInstance, instance) && String(record.workspace_id) === workspace) return null;
+  return {
+    env: `workspace ${workspace} on ${instance}`,
+    stored: `workspace ${record.workspace_id} on ${storedInstance}`
+  };
+}
+async function storeEnvCredentialCommand(credentialPath, targetDir) {
+  const { credentialFileFlag, profileAddCommand } = await import("./store-ARM6VMO5.js");
+  const { DEFAULT_PROFILE } = await import("./profile-select-74TRDEPD.js");
+  const instance = readEnvVar("XANO_INSTANCE_URL");
+  const workspaceId = readEnvVar("XANO_WORKSPACE_ID");
+  const flag = credentialFileFlag(credentialPath);
+  const store = instance !== void 0 && workspaceId !== void 0 && readEnvVar("XANO_META_TOKEN") !== void 0 ? `printf %s "$XANO_META_TOKEN" | ${profileAddCommand(DEFAULT_PROFILE, { path: credentialPath, instance, workspaceId: workspaceId.trim() })}` : `xanosdk login${flag}`;
+  return `${inProject(targetDir)}${store} && xanosdk profile use ${DEFAULT_PROFILE}${flag}`;
+}
+function sdkResolves(dir) {
+  return readInstalledManifestState(dir, "@xano/sdk").kind !== "absent";
+}
+
+export {
+  resolveThemeChoice,
+  resolveFrontendPreset,
+  projectInstallOf,
+  workflowPlacementNote,
+  workflowMoveTarget,
+  reportWorkflowPlacement,
+  templateVarsFor,
+  sanitizeAppName,
+  projectShellFiles,
+  resolveFromSource,
+  runInitCommand,
+  loginNextStep,
+  projectCli,
+  planProfilePin
+};
+//# sourceMappingURL=chunk-LRN4ZJCQ.js.map