@xano/sdk 1.0.0

package/dist/chunk-D53J55C5.js

@@ -0,0 +1,106 @@
+import {
+  registeredModules,
+  withoutComments
+} from "./chunk-5HVXPTU4.js";
+import {
+  pastePath,
+  warn
+} from "./chunk-PTHVMXZI.js";
+import {
+  shellQuote
+} from "./chunk-5ZSO4T2G.js";
+
+// src/emit/pull-superseded.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+function factoriesOf(incoming) {
+  const out = /* @__PURE__ */ new Set();
+  for (const text of incoming.values()) {
+    for (const m of withoutComments(text).matchAll(/(?<![\w$.])([A-Za-z_$][\w$]*)\s*\(\s*\{\s*name\s*:\s*["'`]/g)) out.add(m[1]);
+  }
+  return out;
+}
+function declaredDefs(text, factories) {
+  if (factories.size === 0) return [];
+  const code = withoutComments(text);
+  const call = new RegExp(`(?<![\\w$.])(${[...factories].map((f) => f.replace(/\$/g, "\\$")).join("|")})\\s*\\(\\s*\\{`, "g");
+  const starts = [...code.matchAll(call)].map((m) => ({ at: m.index, kind: m[1] }));
+  const out = [];
+  starts.forEach(({ at, kind }, i) => {
+    const chunk = code.slice(at, starts[i + 1]?.at ?? code.length);
+    const name = /\bname\s*:\s*(["'`])([^"'`]+)\1/.exec(chunk)?.[2];
+    if (name === void 0) return;
+    const verb = /\bverb\s*:\s*(["'`])([A-Za-z]+)\1/.exec(chunk)?.[2];
+    out.push({ kind, name, ...verb === void 0 ? {} : { verb: verb.toUpperCase() } });
+  });
+  return out;
+}
+var keyOf = (d) => `${d.kind}\0${d.name}\0${d.verb ?? ""}`;
+function read(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function keptDuplicates(dirAbs, incoming, kept, backendDir) {
+  const factories = factoriesOf(incoming);
+  const pulled = /* @__PURE__ */ new Map();
+  for (const [p, text] of incoming) {
+    for (const d of declaredDefs(text, factories)) if (!pulled.has(keyOf(d))) pulled.set(keyOf(d), `${backendDir}/${p}`);
+  }
+  const out = [];
+  for (const p of kept) {
+    const text = read(join(dirAbs, p));
+    if (text === void 0) continue;
+    const defs = declaredDefs(text, factories);
+    const objects = defs.flatMap((d) => {
+      const into = pulled.get(keyOf(d));
+      return into === void 0 ? [] : [{ ...d, into }];
+    });
+    if (objects.length > 0) out.push({ file: `${backendDir}/${p}`, objects, only: objects.length === defs.length });
+  }
+  return out;
+}
+function replacedRegistrations(dirAbs, incoming, rewritten, backendDir) {
+  const out = [];
+  for (const p of rewritten) {
+    const current = read(join(dirAbs, p));
+    if (current === void 0) continue;
+    const after = new Set(registeredModules(withoutComments(incoming.get(p) ?? "")).map((r) => `${r.pkg}\0${r.register}`));
+    for (const r of registeredModules(withoutComments(current))) {
+      if (!after.has(`${r.pkg}\0${r.register}`)) out.push({ file: `${backendDir}/${p}`, ...r });
+    }
+  }
+  return out;
+}
+var label = (o) => `${o.kind} "${o.name}"${o.verb === void 0 ? "" : ` (${o.verb})`}`;
+function reportSuperseded(duplicates, replaced, backendDir, inCleanGit) {
+  if (duplicates.length > 0) {
+    const one = duplicates.length === 1;
+    const lines = duplicates.map(
+      (d) => `${pastePath(d.file)}: ${d.objects.map((o) => `${label(o)} \u2192 ${pastePath(o.into)}`).join(", ")}` + (d.only ? "" : ` \u2014 it declares more than that, so move the rest into the decoded tree before deleting it`)
+    );
+    const removable = duplicates.filter((d) => d.only).map((d) => shellQuote(pastePath(d.file)));
+    warn(
+      `${duplicates.length} kept file${one ? " defines" : "s define"} objects the decoded tree declares too. ${pastePath(`${backendDir}/index.ts`)} registers the decoded copies, so ${one ? "that file is" : "those files are"} no longer part of the project and editing ${one ? "it" : "them"} changes nothing:`,
+      "pull.kept-duplicates",
+      [...lines, ...removable.length > 0 ? [`Once the new tree is written, delete the duplicates: \`rm ${removable.join(" ")}\``] : []]
+    );
+  }
+  for (const r of replaced) {
+    const back = inCleanGit ? `To keep the module registered instead, undo the replace right after it lands: \`git checkout HEAD -- ${shellQuote(pastePath(backendDir))} && git clean -fd -- ${shellQuote(pastePath(backendDir))}\`` : `To keep the module registered instead, re-add its import and \`${r.register}(\u2026)\` call to ${pastePath(r.file)} and drop the decoded copies of its objects from the register lists there`;
+    warn(
+      `${pastePath(r.file)} registers ${r.pkg} (\`${r.register}\`), and the decoded entry registers plain copies of the objects it contributed instead \u2014 a later ${r.pkg} upgrade no longer reaches them.`,
+      "pull.module-replaced",
+      [back]
+    );
+  }
+}
+
+export {
+  keptDuplicates,
+  replacedRegistrations,
+  reportSuperseded
+};
+//# sourceMappingURL=chunk-D53J55C5.js.map

package/dist/chunk-D7VGG3WS.js

@@ -0,0 +1,90 @@
+import {
+  compareSemver,
+  parseSemver
+} from "./chunk-2TFRR6JV.js";
+import {
+  shellWord
+} from "./chunk-FWD7AL6N.js";
+import {
+  installedCliAt,
+  pathsShownFrom
+} from "./chunk-PTHVMXZI.js";
+
+// src/emit/project-sdk.ts
+import { existsSync, readFileSync, realpathSync } from "fs";
+import { createRequire } from "module";
+import { basename, dirname, join, relative, resolve, sep } from "path";
+var PACKAGE = "@xano/sdk";
+function projectSdkVersion(dir) {
+  try {
+    const pkg = JSON.parse(readFileSync(createRequire(join(dir, "package.json")).resolve(`${PACKAGE}/package.json`), "utf8"));
+    return typeof pkg.version === "string" ? pkg.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function versionAt(pkgJson) {
+  try {
+    const v = JSON.parse(readFileSync(pkgJson, "utf8")).version;
+    return typeof v === "string" ? v : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function installedSdk(dir) {
+  let selfChecked = false;
+  for (let d = resolve(dir); ; d = dirname(d)) {
+    const own = join(d, "package.json");
+    if (!selfChecked && existsSync(own)) {
+      selfChecked = true;
+      try {
+        if (JSON.parse(readFileSync(own, "utf8")).name === PACKAGE) {
+          const version = versionAt(own);
+          if (version !== void 0) return { version, root: d };
+        }
+      } catch {
+      }
+    }
+    const installed = join(d, "node_modules", ...PACKAGE.split("/"), "package.json");
+    if (existsSync(installed)) {
+      const version = versionAt(installed);
+      return version === void 0 ? void 0 : { version, root: d };
+    }
+    if (dirname(d) === d) return void 0;
+  }
+}
+function skewedProjectSdk(dir, running) {
+  const installed = installedSdk(dir);
+  if (installed === void 0) return void 0;
+  const a = parseSemver(installed.version);
+  const b = parseSemver(running);
+  return a && b && compareSemver(a, b) !== 0 ? installed : void 0;
+}
+function installedCliCommand(root, tail) {
+  const home = real(root);
+  const typed = real(pathsShownFrom() ?? process.cwd());
+  const spelled = (from, to) => shellWord(relative(from, to).split(sep).join("/") || ".");
+  const command = `${installedCliAt(home)} ${tail((p) => spelled(home, real(p)))}`;
+  return typed === home ? command : `cd ${spelled(typed, home)} && ${command}`;
+}
+function real(path) {
+  const absolute = resolve(path);
+  try {
+    return realpathSync(absolute);
+  } catch {
+    const parent = dirname(absolute);
+    return parent === absolute ? absolute : join(real(parent), basename(absolute));
+  }
+}
+function skewNote(what, running, installed, command) {
+  return `Left ${what} as it is: this CLI is @xano/sdk ${running} and the project has ${installed} installed, whose wording \`npm run xano:check\` compares against. Run \`${command}\` to render it with the installed CLI.`;
+}
+
+export {
+  projectSdkVersion,
+  installedSdk,
+  skewedProjectSdk,
+  installedCliCommand,
+  skewNote
+};
+//# sourceMappingURL=chunk-D7VGG3WS.js.map

package/dist/chunk-DAD3ONIS.js

@@ -0,0 +1,245 @@
+import {
+  backendDirFor,
+  backendDirIn
+} from "./chunk-5A2PLKZB.js";
+import {
+  XANO_DIR
+} from "./chunk-AHJWCYQO.js";
+import {
+  projectRootFrom
+} from "./chunk-ROY4YAEQ.js";
+import {
+  LocalFileNotFoundError,
+  UsageError,
+  displayPath
+} from "./chunk-PTHVMXZI.js";
+import {
+  isRepresentableName
+} from "./chunk-GSGDWJB5.js";
+
+// src/emit/workspace-env.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var WORKSPACE_ENV_BASENAME = ".env";
+var WORKSPACE_ENV_EXAMPLE_BASENAME = ".env.example";
+var WORKSPACE_ENV_FILE = `${XANO_DIR}/${WORKSPACE_ENV_BASENAME}`;
+var WORKSPACE_ENV_EXAMPLE_FILE = `${XANO_DIR}/${WORKSPACE_ENV_EXAMPLE_BASENAME}`;
+function workspaceEnvPathIn(cwd) {
+  return join(backendDirIn(projectRootFrom(cwd)), ".env");
+}
+function defaultWorkspaceEnvPath(file) {
+  return join(backendDirFor(file), ".env");
+}
+function declaredEnv(settings) {
+  const env = settings.env;
+  if (!Array.isArray(env)) return [];
+  return env.map((e) => e).filter((e) => typeof e.name === "string" && e.name !== "").map((e) => ({ name: e.name, value: typeof e.value === "string" ? e.value : "" }));
+}
+function isRepresentable(value) {
+  return isRepresentableValue(value);
+}
+function isRepresentableValue(value) {
+  return valueProblem(value) === void 0;
+}
+function valueProblem(value) {
+  if (/[\n\r]/.test(value)) return "newline";
+  if (value !== value.trim()) return "edge-whitespace";
+  return isQuoted(value) ? "quoted" : void 0;
+}
+var VALUE_PROBLEM_WORDS = {
+  newline: "carries a newline",
+  "edge-whitespace": "has leading or trailing whitespace",
+  quoted: "is wrapped in a matching quote pair that reading the file would strip"
+};
+function isQuoted(value) {
+  const quote = value[0];
+  return (quote === '"' || quote === "'") && value.length > 1 && value.endsWith(quote);
+}
+function classifyEnv(args) {
+  const values = Object.assign(/* @__PURE__ */ Object.create(null), args.fileValues, args.flagValues);
+  const supplied = new Set(Object.keys(values));
+  const declared = new Set(args.declaredNames);
+  const declaredValues = args.declaredValues ?? {};
+  return {
+    values,
+    clearing: args.declaredNames.filter(
+      (n) => !supplied.has(n) && (Object.hasOwn(declaredValues, n) ? declaredValues[n] : "") === ""
+    ),
+    additions: Object.keys(values).filter((n) => !declared.has(n))
+  };
+}
+function parseEnvFile(path, label = "--backend-env-file") {
+  let source;
+  try {
+    source = readFileSync(path, "utf8");
+  } catch (err) {
+    const missing = err.code === "ENOENT";
+    throw new (!label.startsWith("--") ? Error : missing ? LocalFileNotFoundError : UsageError)(
+      `${label}: could not read ${displayPath(path)}. Check the path, and make sure the file is present wherever this runs (a CI secret mounted at deploy time, not a file committed to the repo).`
+    );
+  }
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [n, raw] of source.split("\n").entries()) {
+    const line = raw.trim();
+    if (line === "" || line.startsWith("#")) continue;
+    const body = line.startsWith("export ") ? line.slice("export ".length).trim() : line;
+    const eq = body.indexOf("=");
+    if (eq <= 0) {
+      throw new Error(
+        `${label}: ${displayPath(path)} line ${n + 1} is not KEY=VALUE. Comments start with "#"; blank lines are ignored.`
+      );
+    }
+    const key = body.slice(0, eq).trim();
+    let value = body.slice(eq + 1).trim();
+    if (isQuoted(value)) value = value.slice(1, -1);
+    out[key] = value;
+  }
+  return out;
+}
+function readWorkspaceEnvFile(path) {
+  if (!existsSync(path)) return void 0;
+  return parseEnvFile(path, WORKSPACE_ENV_FILE);
+}
+function commentSafe(name) {
+  return name.replace(/[\u0000-\u001F\u007F]/g, "?");
+}
+function envFileLabels(backendDir) {
+  return {
+    env: `${backendDir}/${WORKSPACE_ENV_BASENAME}`,
+    example: `${backendDir}/${WORKSPACE_ENV_EXAMPLE_BASENAME}`
+  };
+}
+function renderWorkspaceEnvExample(names, backendDir = XANO_DIR) {
+  const { env: envFile, example: exampleFile } = envFileLabels(backendDir);
+  const header = `# ${exampleFile} \u2014 the template for ${envFile}.
+#
+# ${backendDir}/ is COMMITTED in full: the source, the lock, and this file. Two
+# files are ignored on purpose, and which secret goes in which is decided by how
+# that secret is ADDRESSED. Do not "tidy" this up by ignoring ${backendDir}/
+# wholesale: the source is the review surface.
+#
+#   - ${envFile} \u2014 BACKEND variables, addressed by NAME. Declared by
+#     \`workspaceConfig({ env })\` and read at request time with \`env("NAME")\`.
+#     Those names are listed below; the values are yours to fill in.
+#   - ${backendDir}/.secrets.json \u2014 DOCUMENTATION tokens, addressed by the OBJECT
+#     that holds them (the workspace, or an API group). They have no name of
+#     their own, so they are not listed here at all. \`npx xanosdk pull\` writes that
+#     file and every build reads it back; nobody edits it by hand. They are NOT
+#     backend variables: they never reach the workspace's env, and
+#     \`env("NAME")\` does not read them.
+#
+# To fill it in:
+#
+#   cp ${exampleFile} ${envFile}   # then edit in the values
+#   npx xanosdk env pull                        # or fetch them from a running backend
+#
+# Every command that compiles a bundle (deploy, export, preflight) reads
+# ${envFile} by default. CI does not have it \u2014 the file is ignored \u2014 so an
+# automated deploy mounts its own and passes \`--backend-env-file <path>\`, or supplies
+# names one at a time with \`--env-var KEY=VALUE\`.
+#
+# A deploy REPLACES the backend's env set. A name declared in
+# \`workspaceConfig({ env })\` with no line in ${envFile} therefore REFUSES the
+# deploy rather than clearing the live value; \`--allow-empty-env=NAME\` opts one
+# name out of that. The refusal is part of the compile, so a pre-built bundle
+# (\`deploy --bundle <path>\`) ships whatever env it was built with \u2014 resolve the
+# values on the \`export\` that builds it.
+#
+# A documentation token follows the same discipline in its own file, with
+# \`--allow-empty-doc-token=<scope>\` as its opt-out \u2014 but an UNSUPPLIED one emits
+# no \`documentation\` block at all, so a bundle built without it leaves the
+# target's gate alone rather than clearing it. Only the opt-out clears a gate,
+# and clearing one makes that doc site publicly readable.
+#
+# This file is generated. Every pull, and every export, rewrites it from the
+# names the backend declares. ${envFile} is yours: neither touches it. Only
+# \`npx xanosdk env pull\` (which asks before replacing it), and \`npx xanosdk init --from\`
+# or \`npx xanosdk generate\` on a bundle that carries values, write it.
+`;
+  if (names.length === 0) {
+    return `${header}#
+# This backend declares no env vars. Add them with \`workspaceConfig({ env })\`
+# and the next export or pull will list them here. (Documentation tokens are never listed
+# here \u2014 they live in ${backendDir}/.secrets.json, keyed by the object they gate.)
+`;
+  }
+  const lines = names.map(
+    ({ name, representable, problem }) => representable ? `# ${commentSafe(name)}=` : problem === "name" ? (
+      // No `NAME=` shape: the line must not parse back as a declared name, and
+      // no flag can supply a name `--env-var` refuses.
+      `# "${commentSafe(name)}"   (not a usable env var name \u2014 letters, digits and _, not starting
+#   with a digit \u2014 so no file or flag can supply it. Rename it in \`workspaceConfig({ env })\`.)`
+    ) : `# ${commentSafe(name)}=   (this value cannot be written here \u2014 it ${VALUE_PROBLEM_WORDS[problem ?? "newline"]},
+#   so the dotenv format cannot carry it. Pass it with
+#   \`--env-var ${commentSafe(name)}=...\` instead.)`
+  );
+  return `${header}#
+# One line per declared name. Uncomment and fill in the ones you need.
+
+${lines.join("\n")}
+`;
+}
+function namesInEnvExample(path) {
+  if (!existsSync(path)) return [];
+  const out = [];
+  for (const raw of readFileSync(path, "utf8").split("\n")) {
+    const m = /^#?\s*([A-Za-z_][A-Za-z0-9_]*)=/.exec(raw.trim());
+    if (m) out.push(m[1]);
+  }
+  return out;
+}
+function renderWorkspaceEnvFile(values, provenance, backendDir = XANO_DIR, exampleExists = true, writer = "xanosdk env pull") {
+  const { env: envFile, example: exampleFile } = envFileLabels(backendDir);
+  const omitted = [];
+  const lines = [];
+  for (const [name, value] of Object.entries(values)) {
+    if (isRepresentableName(name) && isRepresentableValue(value)) lines.push(`${name}=${value}`);
+    else omitted.push(name);
+  }
+  const badNames = omitted.filter((n) => !isRepresentableName(n));
+  const badValues = omitted.filter((n) => isRepresentableName(n));
+  const header = `# ${envFile} \u2014 backend env values. NOT committed${exampleExists ? ` (see ${exampleFile})` : ""}.
+#
+# Written by \`${writer}\` from: ${provenance.source}
+# at ${provenance.at}
+#
+# Every command that compiles a bundle reads this file by default. Re-running
+# \`npx xanosdk env pull\` REPLACES it wholesale.
+${// A NAME no env var can have is said as the name's fault: blaming its value
+  // ("no newlines or edge whitespace") sent the reader to a value that was fine.
+  badValues.length === 0 ? "" : `#
+# NOT written, because the dotenv format cannot carry ${badValues.length === 1 ? "its value" : "their values"}
+# (a newline, edge whitespace, or a wrapping quote pair): ${badValues.map(commentSafe).join(", ")}.
+# Pass ${badValues.length === 1 ? "it" : "each"} at deploy time with \`--env-var NAME=...\` instead.
+`}${badNames.length === 0 ? "" : `#
+# NOT written, because ${badNames.length === 1 ? "it is not a usable env var name" : "they are not usable env var names"}
+# (letters, digits and _, not starting with a digit): ${badNames.map((n) => `"${commentSafe(n)}"`).join(", ")}.
+`}`;
+  return {
+    content: lines.length === 0 ? `${header}#
+# This backend declares no env vars, so there is nothing to fill in.
+` : `${header}
+${lines.join("\n")}
+`,
+    omitted
+  };
+}
+
+export {
+  WORKSPACE_ENV_BASENAME,
+  WORKSPACE_ENV_EXAMPLE_BASENAME,
+  WORKSPACE_ENV_FILE,
+  WORKSPACE_ENV_EXAMPLE_FILE,
+  workspaceEnvPathIn,
+  defaultWorkspaceEnvPath,
+  declaredEnv,
+  isRepresentable,
+  valueProblem,
+  classifyEnv,
+  parseEnvFile,
+  readWorkspaceEnvFile,
+  renderWorkspaceEnvExample,
+  namesInEnvExample,
+  renderWorkspaceEnvFile
+};
+//# sourceMappingURL=chunk-DAD3ONIS.js.map

package/dist/chunk-DGWHAVRG.js

@@ -0,0 +1,162 @@
+// src/emit/managed-blocks.ts
+var HASH_DIALECT = {
+  begin: (pkg) => `# xanosdk:begin ${pkg}`,
+  end: (pkg) => `# xanosdk:end ${pkg}`,
+  stamp: (version) => `# xanosdk ${version} \u2014 generated; edits inside this block are overwritten`,
+  parseStamp: (block) => /^# xanosdk (\S+) — generated/m.exec(block)?.[1] ?? null
+};
+var CONFLICT_MARKERS = ["<<<<<<<", ">>>>>>>"];
+function composeBlock(spec, lines, version) {
+  const body = trimBlankEdges(lines.flatMap((line) => line.split(/\r?\n/)));
+  if (body.length === 0) return "";
+  const { dialect, pkg } = spec;
+  assertNoForgedMarkers(body, spec);
+  return [dialect.begin(pkg), dialect.stamp(version), "", ...body, dialect.end(pkg)].join("\n");
+}
+function assertNoForgedMarkers(body, spec) {
+  const { dialect, pkg } = spec;
+  const where = spec.file === void 0 ? "" : ` in ${spec.file}`;
+  const markers = [dialect.begin("").trim(), dialect.end("").trim()];
+  for (const line of body) {
+    const trimmed = line.trim();
+    if (!markers.some((marker) => trimmed.startsWith(marker))) continue;
+    throw new Error(
+      `xanosdk managed block for ${pkg}${where} would contain a line that spells a block marker (${trimmed}). Writing it would leave the file with markers no run can balance, and every command that could repair it reads the same count.`
+    );
+  }
+}
+function gitattributesSpec(pkg) {
+  return { dialect: HASH_DIALECT, pkg, file: ".gitattributes" };
+}
+function linesOutsideBlocks(text, dialect) {
+  const begin = dialect.begin("");
+  const end = dialect.end("");
+  const out = [];
+  let inside = false;
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith(begin)) inside = true;
+    else if (trimmed.startsWith(end)) inside = false;
+    else if (!inside && trimmed !== "") out.push(trimmed);
+  }
+  return out;
+}
+function blockPackages(text, dialect) {
+  const begin = dialect.begin("");
+  const out = [];
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith(begin)) continue;
+    const pkg = trimmed.slice(begin.length).trim();
+    if (pkg !== "" && !out.includes(pkg)) out.push(pkg);
+  }
+  return out;
+}
+function findBlock(text, spec) {
+  return locate(text, spec);
+}
+function blockVersion(text, spec) {
+  const span = locate(text, spec);
+  return span === null ? null : spec.dialect.parseStamp(span.text);
+}
+function upsertBlock(existing, spec, block) {
+  const before = existing ?? "";
+  if (block.trim().length === 0) return removeBlock(before, spec);
+  const eol = detectEol(before);
+  const rendered = block.replace(/\r?\n/g, eol);
+  const span = locate(before, spec);
+  if (span !== null) {
+    return settle(before, before.slice(0, span.start) + rendered + before.slice(span.end));
+  }
+  if (before.trim().length === 0) return settle(before, rendered + eol);
+  const tail = trailingNewlines(before);
+  return settle(before, trimEndLines(before) + eol + eol + rendered + (tail === "" ? eol : tail));
+}
+function removeBlock(existing, spec) {
+  const before = existing ?? "";
+  const span = locate(before, spec);
+  if (span === null) return { text: before, changed: false };
+  const eol = detectEol(before);
+  const tail = trailingNewlines(before);
+  const head = trimEndLines(before.slice(0, span.start));
+  const rest = trimStartLines(before.slice(span.end));
+  let out = head === "" || rest === "" ? head + rest : head + eol + eol + rest;
+  if (out !== "" && tail !== "" && !/\r?\n$/.test(out)) out += tail;
+  return settle(before, out);
+}
+function locate(text, spec) {
+  const { dialect, pkg } = spec;
+  const where = spec.file === void 0 ? "" : ` in ${spec.file}`;
+  const begins = lineOccurrences(text, dialect.begin(pkg));
+  const ends = lineOccurrences(text, dialect.end(pkg));
+  if (begins.length === 0 && ends.length === 0) return null;
+  if (begins.length > 1 || ends.length > 1) {
+    throw new Error(
+      `unbalanced xanosdk managed block for ${pkg}${where}: found ${begins.length} BEGIN and ${ends.length} END markers where at most one of each is valid \u2014 usually the residue of a merge. Keep the copy you want and delete the rest by hand; rewriting it automatically would strand whichever copy we did not pick.`
+    );
+  }
+  if (begins.length === 0 || ends.length === 0 || ends[0] < begins[0]) {
+    throw new Error(
+      `unbalanced xanosdk managed block for ${pkg}${where}: found ${begins.length === 0 ? "no" : "a"} BEGIN and ${ends.length === 0 ? "no" : "an"} END marker. Repair or remove the block by hand \u2014 rewriting it automatically would risk destroying whatever is between them.`
+    );
+  }
+  const start = begins[0];
+  const end = ends[0] + dialect.end(pkg).length;
+  const block = text.slice(start, end);
+  if (CONFLICT_MARKERS.some((marker) => hasLineStarting(block, marker))) {
+    throw new Error(
+      `xanosdk managed block for ${pkg}${where} contains git conflict markers. Resolve the conflict by hand, then re-run \u2014 rewriting a conflicted block would silently discard one side of it.`
+    );
+  }
+  return { start, end, text: block };
+}
+function lineOccurrences(text, marker) {
+  const hits = [];
+  for (let i = text.indexOf(marker); i !== -1; i = text.indexOf(marker, i + marker.length)) {
+    if (i !== 0 && text[i - 1] !== "\n") continue;
+    let j = i + marker.length;
+    while (text[j] === " " || text[j] === "	") j++;
+    if (text[j] === "\r") j++;
+    if (j === text.length || text[j] === "\n") hits.push(i);
+  }
+  return hits;
+}
+function hasLineStarting(text, marker) {
+  return text.startsWith(marker) || text.includes(`
+${marker}`);
+}
+function detectEol(text) {
+  return text.includes("\r\n") ? "\r\n" : "\n";
+}
+function trailingNewlines(text) {
+  return /(?:\r?\n)*$/.exec(text)?.[0] ?? "";
+}
+function trimEndLines(text) {
+  return text.replace(/[ \t]*(?:\r?\n[ \t]*)*$/, "");
+}
+function trimStartLines(text) {
+  return text.replace(/^[ \t]*(?:\r?\n[ \t]*)*/, "");
+}
+function trimBlankEdges(lines) {
+  let start = 0;
+  let end = lines.length;
+  while (start < end && lines[start].trim() === "") start++;
+  while (end > start && lines[end - 1].trim() === "") end--;
+  return lines.slice(start, end);
+}
+function settle(before, after) {
+  return { text: after, changed: after !== before };
+}
+
+export {
+  HASH_DIALECT,
+  composeBlock,
+  gitattributesSpec,
+  linesOutsideBlocks,
+  blockPackages,
+  findBlock,
+  blockVersion,
+  upsertBlock,
+  removeBlock
+};
+//# sourceMappingURL=chunk-DGWHAVRG.js.map