@xano/sdk 1.0.0

package/dist/generate-command-AYEOLA26.js

@@ -0,0 +1,510 @@
+import {
+  pulledIdentities,
+  pulledLock,
+  reconcileLock
+} from "./chunk-K4WX6UUU.js";
+import "./chunk-D53J55C5.js";
+import "./chunk-5HVXPTU4.js";
+import "./chunk-W3HBUKFO.js";
+import {
+  carriedSeedRows,
+  decodeBundle,
+  fetchWorkspaceBundle,
+  placeGeneratedFiles,
+  readBundleFile,
+  refuseDuplicateSourceGuids,
+  reportSeedRows,
+  writeBundleEnvValues,
+  writeDocumentationTokens
+} from "./chunk-X677DMZM.js";
+import "./chunk-LRN4ZJCQ.js";
+import {
+  ROUTES_MANIFEST_BASENAME
+} from "./chunk-RTJRZFFY.js";
+import {
+  confirm
+} from "./chunk-65HWOMGV.js";
+import "./chunk-TPHWJ7UG.js";
+import {
+  fetchSourceArchive
+} from "./chunk-AOSYVMUS.js";
+import "./chunk-CJHQKJU4.js";
+import {
+  decodeWorkspaceArchive
+} from "./chunk-3DRXWLJ5.js";
+import "./chunk-X4DVXBFY.js";
+import "./chunk-TRJCALW3.js";
+import "./chunk-LIEOKXKD.js";
+import "./chunk-D7VGG3WS.js";
+import "./chunk-2TFRR6JV.js";
+import "./chunk-HRVBLCVJ.js";
+import {
+  ensureSecretPathGitignored
+} from "./chunk-YHEFQUQB.js";
+import {
+  readVersion
+} from "./chunk-ETO6LGLD.js";
+import "./chunk-ZIY7RNUT.js";
+import {
+  WORKSPACE_ENV_BASENAME
+} from "./chunk-DAD3ONIS.js";
+import {
+  memoCredential,
+  refuseProfileForLocal
+} from "./chunk-HHN734BU.js";
+import "./chunk-LPECSJ2J.js";
+import "./chunk-6NNTNXN7.js";
+import "./chunk-QCNYHBL7.js";
+import "./chunk-2ZUEE4EK.js";
+import "./chunk-AN6BL47T.js";
+import {
+  getAccessToken
+} from "./chunk-ET4Y4XCB.js";
+import "./chunk-SWBF2LTK.js";
+import "./chunk-UZ6QQWJT.js";
+import "./chunk-A3UDOZB6.js";
+import "./chunk-2MNLRIOX.js";
+import "./chunk-3M4LFYNQ.js";
+import "./chunk-AM4FKL4J.js";
+import "./chunk-Q325JKYB.js";
+import {
+  parseSlot,
+  requireBackendSlot,
+  slotValueMissing
+} from "./chunk-STSFNCY4.js";
+import "./chunk-I4F5TCJH.js";
+import "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-7G3CTU7I.js";
+import "./chunk-6PBR37LN.js";
+import {
+  yesRerun
+} from "./chunk-T5KELPAR.js";
+import "./chunk-622HUCZT.js";
+import {
+  contextFlags
+} from "./chunk-NAQDMEHV.js";
+import "./chunk-5A2PLKZB.js";
+import {
+  PRESERVED_ON_REFRESH,
+  containedWrites,
+  describeDecodeReplace,
+  filesUnder,
+  planDecodeReplace,
+  readDecodeRecord,
+  removeEmptiedDirs,
+  removeFiles
+} from "./chunk-AHJWCYQO.js";
+import "./chunk-DX4QR4B2.js";
+import "./chunk-6QXLMMT3.js";
+import "./chunk-ZFDZKNGG.js";
+import {
+  shellWord
+} from "./chunk-FWD7AL6N.js";
+import "./chunk-2GNFDZA2.js";
+import "./chunk-JTUKLCXS.js";
+import "./chunk-4KHEMC32.js";
+import "./chunk-U64O2MXY.js";
+import {
+  projectRootFrom
+} from "./chunk-ROY4YAEQ.js";
+import {
+  readLockFile,
+  writeLockFile
+} from "./chunk-P2HAGF6H.js";
+import "./chunk-TLQE7ZN3.js";
+import "./chunk-WRBKLYSJ.js";
+import "./chunk-3LDULPRE.js";
+import "./chunk-XW6KISBB.js";
+import "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-3KZCLN4Z.js";
+import "./chunk-FXFV3KU6.js";
+import "./chunk-OPHB5ORL.js";
+import {
+  decodeMarkerHead,
+  decodeMarkerWith
+} from "./chunk-UCQ2VUTG.js";
+import "./chunk-DGWHAVRG.js";
+import "./chunk-27GWNP2I.js";
+import "./chunk-3YW23UFH.js";
+import "./chunk-JGE7CAWB.js";
+import {
+  LocalFileNotFoundError,
+  UsageError,
+  detail,
+  info,
+  isMachineOutput,
+  relForwardSlash,
+  step,
+  success,
+  terminalText,
+  warn,
+  writeJson
+} from "./chunk-PTHVMXZI.js";
+import "./chunk-MXHSQOC4.js";
+import "./chunk-6IUMKYWI.js";
+import "./chunk-2CMJZDCL.js";
+import "./chunk-CTMO46PK.js";
+import "./chunk-ZDPP6RKB.js";
+import "./chunk-K5BBGTYZ.js";
+import "./chunk-LQCMKAJ7.js";
+import "./chunk-YGZHHAAB.js";
+import "./chunk-XVBGLISP.js";
+import "./chunk-6HO3NCSJ.js";
+import "./chunk-5V5XU32D.js";
+import {
+  safeNames
+} from "./chunk-GSGDWJB5.js";
+import "./chunk-HVRUQXGD.js";
+import "./chunk-ERVIASGL.js";
+import "./chunk-4POWHT2K.js";
+import "./chunk-H2V3N23D.js";
+import {
+  WORKSPACE_SECRETS_BASENAME
+} from "./chunk-3JDU4VRL.js";
+import "./chunk-WTPZRR4I.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-6MR5TI5V.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-XNCP4KYO.js";
+import "./chunk-AKNCFVKZ.js";
+import "./chunk-YU4HSQW7.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-EHP3WPEG.js";
+import "./chunk-L5JYN3NM.js";
+import "./chunk-Q7DGTQ5G.js";
+import "./chunk-G554NZNI.js";
+import "./chunk-N5GKCWE5.js";
+import "./chunk-OXA6PSZT.js";
+import "./chunk-VAX3UZOY.js";
+import "./chunk-NZOWWHU5.js";
+import "./chunk-4BW2SG2N.js";
+import "./chunk-TTEIYD5P.js";
+import "./chunk-CIMQZRRE.js";
+import "./chunk-OHX6MIUZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/emit/generate-command.ts
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { basename, dirname, isAbsolute, join, resolve, sep } from "path";
+var HINT = { hintFor: { command: "generate" } };
+var PRESERVED = /* @__PURE__ */ new Set([...PRESERVED_ON_REFRESH, ".gitignore"]);
+var DEFAULT_OUT = "xano";
+var CODEGEN_MARKER = ".xanosdk-codegen.json";
+function previousMarker(root) {
+  try {
+    const parsed = JSON.parse(readFileSync(join(root, CODEGEN_MARKER), "utf8"));
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+  } catch {
+  }
+  return {};
+}
+async function loadSource(args, raw, cwd) {
+  const slot = requireBackendSlot("generate", void 0, "subject");
+  const source = parseSlot(slot, raw);
+  if (source.kind === "file") {
+    if (args.branch !== void 0) {
+      throw new UsageError(
+        "`--branch` does not apply to a bundle file: it is one archive already exported from one branch. Re-export it with `xanosdk workspace export --branch <label>`, or generate from `workspace --branch <label>`.",
+        HINT
+      );
+    }
+    step(`Reading ${raw}`);
+    return { bundle: readBundleFile(source.path), label: raw, kind: "file" };
+  }
+  refuseProfileForLocal(args.profile, [source.kind], slot);
+  const credential = memoCredential(() => getAccessToken(args));
+  if (source.kind === "workspace" && args.branch !== void 0) {
+    return {
+      bundle: await fetchWorkspaceBundle(await credential(), args.branch),
+      label: `workspace branch "${args.branch}"`,
+      kind: "workspace",
+      backend: { selector: "workspace", workspaceId: (await credential()).workspaceId }
+    };
+  }
+  if (args.branch !== void 0) {
+    throw new UsageError(
+      `\`--branch\` applies to \`workspace\` only. "${raw}" carries the logic it was built from, not a branch to choose between.`,
+      HINT
+    );
+  }
+  step(`Reading ${raw}`);
+  const { projectDirFrom } = await import("./xanosdk-project-S6DXJONQ.js");
+  const fetched = await fetchSourceArchive(credential, raw, projectDirFrom(cwd) ?? cwd);
+  const bundle = decodeWorkspaceArchive(fetched.archive);
+  return {
+    bundle,
+    label: fetched.label,
+    kind: source.kind,
+    // The provenance is the selector of whatever backend was read; a release is not one.
+    backend: {
+      ...source.kind === "release" ? {} : { selector: fetched.provenance },
+      ...source.kind === "local-engine" ? {} : { workspaceId: (await credential()).workspaceId }
+    },
+    seed: {
+      rows: carriedSeedRows(fetched.archive, bundle.payload ?? {}),
+      provenance: fetched.provenance
+    }
+  };
+}
+function ignoreRootFor(root) {
+  const project = projectRootFrom(dirname(root));
+  const isProject = existsSync(join(project, "package.json")) || existsSync(join(project, ".git"));
+  return isProject ? project : root;
+}
+async function runGenerateCommand(args) {
+  const cwd = process.cwd();
+  const raw = args.positionals[0];
+  if (raw === void 0) {
+    throw slotValueMissing(requireBackendSlot("generate", void 0, "subject"));
+  }
+  if (args.out === "-") {
+    throw new UsageError("`generate` writes a tree of files, so `--out -` (stdout) has no meaning here \u2014 name a directory.", {
+      hintFor: { command: "generate" }
+    });
+  }
+  const typed = parseSlot(requireBackendSlot("generate", void 0, "subject"), raw);
+  if (typed.kind === "file" && !existsSync(resolve(cwd, typed.path))) {
+    throw new LocalFileNotFoundError(`No bundle file at "${resolve(cwd, typed.path)}".`);
+  }
+  const outArg = args.out ?? DEFAULT_OUT;
+  const root = resolve(cwd, outArg);
+  const shown = (isAbsolute(outArg) ? "" : relForwardSlash(cwd, root)) || root;
+  if (existsSync(root) && !statSync(root).isDirectory()) {
+    throw new UsageError(
+      `--out ${shown} is a file, not a directory. Nothing was written. Pick an empty or new directory with \`--out <dir>\`.`,
+      HINT
+    );
+  }
+  const existing = filesUnder(root);
+  const replaceable = existing.filter((p) => !PRESERVED.has(p));
+  if (replaceable.length > 0) {
+    const cwdWithin = cwd === root || cwd.startsWith(`${root}${sep}`);
+    if (cwdWithin || !existing.includes(CODEGEN_MARKER)) {
+      const why = cwdWithin ? `it is the working directory or above it, and generate never replaces the directory it runs in` + (existing.includes(CODEGEN_MARKER) ? "" : ` (and it holds no ${CODEGEN_MARKER})`) : `it is not a backend tree a decode wrote \u2014 no ${CODEGEN_MARKER}`;
+      throw new UsageError(
+        `${shown}/ is not empty and ${why}. Nothing was written. Pick an empty or new directory with \`--out <dir>\`${cwdWithin && existing.includes(CODEGEN_MARKER) ? `, or run from outside it` : ""}.`
+      );
+    }
+    if (args.force !== true) {
+      throw new UsageError(
+        `${shown}/ already holds a backend tree. Re-run with \`--force\` to replace it (${[...PRESERVED].join(", ")} are kept), or pick another directory with \`--out <dir>\`.`
+      );
+    }
+  }
+  const loaded = await loadSource(args, raw, cwd);
+  const project = decodeBundle(loaded.bundle, { secretsFile: `${shown}/${WORKSPACE_SECRETS_BASENAME}`, writesSecrets: args.noSecrets !== true });
+  refuseDuplicateSourceGuids(project);
+  const projectRelative = !isAbsolute(outArg) && !isAbsolute(shown) && shown !== ".." && !shown.startsWith("../");
+  const routesDeferred = [];
+  const decoded = placeGeneratedFiles(project, "", projectRelative ? shown : basename(root) || shown, {
+    entry: shellWord(`${shown}/index.ts`),
+    deferred: routesDeferred
+  }).map((f) => ({
+    path: f.path.replace(/^\//, ""),
+    content: f.content
+  }));
+  const markerHead = decodeMarkerHead(previousMarker(root), "generate", raw, readVersion(), project.report.toJson());
+  const markerFor = (wrote) => `${JSON.stringify(decodeMarkerWith(markerHead, wrote), null, 2)}
+`;
+  const files = [...decoded, { path: CODEGEN_MARKER, content: markerFor(decoded) }];
+  const planned = containedWrites(
+    root,
+    files,
+    (path) => new UsageError(
+      `${loaded.label} carries a file that would be written outside ${shown}/ ("${path}"). Nothing was written.`
+    )
+  );
+  const lockPath = join(root, "xano.lock");
+  const lock = existsSync(lockPath) ? readLockFile(lockPath) : void 0;
+  const reconciliation = lock === void 0 ? void 0 : reconcileLock(lock, pulledIdentities(loaded.bundle.payload));
+  const incoming = new Map(decoded.map((f) => [f.path, f.content]));
+  const plan = planDecodeReplace(
+    root,
+    incoming,
+    replaceable.filter((p) => p !== CODEGEN_MARKER),
+    readDecodeRecord(root, [])
+  );
+  const removed = plan.removals;
+  const kept = plan.kept;
+  if (plan.removedEdited.length > 0 || plan.edited.length > 0) {
+    describeDecodeReplace(plan, shown, loaded.label, (line, files2) => warn(line, "generate.replace", files2));
+    if (args.yes !== true) {
+      const files2 = [...plan.removedEdited, ...plan.edited].map((p) => `${shown}/${p}`);
+      const { rerun, note } = yesRerun(args, "generate");
+      const ok = await confirm(`Replace ${shown}/ from ${loaded.label}, losing those edits?`, {
+        flag: "--yes",
+        refusal: { details: { written: false, files: files2 }, rerun, note }
+      });
+      if (!ok) {
+        info("Generate cancelled. Nothing was written.");
+        if (isMachineOutput(args)) {
+          writeJson({
+            source: raw,
+            out: root,
+            declined: true,
+            files: 0,
+            removed: [],
+            removedEdited: [],
+            rewrittenEdited: [],
+            kept: []
+          });
+        }
+        return;
+      }
+    }
+  }
+  removeFiles(root, removed);
+  removeEmptiedDirs(root, removed);
+  step(`Writing ${shown}/ from ${loaded.label}`);
+  const marker = planned.at(-1);
+  const write = (file) => {
+    mkdirSync(dirname(file.full), { recursive: true });
+    writeFileSync(file.full, file.content, "utf8");
+  };
+  const unwritten = (file, err) => `${shown}/${relForwardSlash(root, file.full)} could not be written (${err?.code ?? (err instanceof Error ? err.message : String(err))})`;
+  write(marker);
+  const routesFull = join(root, ROUTES_MANIFEST_BASENAME);
+  for (const file of planned.slice(0, -1)) {
+    try {
+      write(file);
+    } catch (err) {
+      if (file.full === routesFull) {
+        warn(`${unwritten(file, err)}. The tree is complete without it; fix the path and run \`xanosdk routes ${shown}/index.ts --emit ${shown}/${ROUTES_MANIFEST_BASENAME}\`.`, "routes.not-written");
+        write({ full: marker.full, content: markerFor(decoded.filter((f) => f.path !== ROUTES_MANIFEST_BASENAME)) });
+        continue;
+      }
+      throw new UsageError(
+        `${unwritten(file, err)}. The tree is partial; fix the path and re-run with \`--force\` to replace it.`
+      );
+    }
+  }
+  if (lock !== void 0 && reconciliation !== void 0) {
+    writeLockFile(lockPath, pulledLock(lock, reconciliation, loaded.bundle.payload));
+  }
+  const ignoreRoot = ignoreRootFor(root);
+  const placement = (basename2) => ({
+    root: ignoreRoot,
+    label: `${shown}/${basename2}`
+  });
+  ensureSecretPathGitignored(join(root, WORKSPACE_ENV_BASENAME), placement(WORKSPACE_ENV_BASENAME));
+  writeDocumentationTokens(
+    root,
+    project.documentationTokens,
+    args,
+    loaded.label,
+    join(root, WORKSPACE_SECRETS_BASENAME),
+    placement(WORKSPACE_SECRETS_BASENAME)
+  );
+  const env = writeBundleEnvValues(root, project.env, args, loaded.label, loaded.kind, {
+    dir: root,
+    rel: `${shown}/${WORKSPACE_ENV_BASENAME}`,
+    command: "generate",
+    place: placement(WORKSPACE_ENV_BASENAME)
+  });
+  const valueless = env.declared.filter((n) => project.env[n] === "" && !env.written.includes(n));
+  if (valueless.length > 0) {
+    warn(
+      `${valueless.length} env var${valueless.length === 1 ? "" : "s"} declared with no value in the bundle (${safeNames(valueless)}) \u2014 see ${shown}/.env.example. Supply ${valueless.length === 1 ? "it" : "them"} in ${shown}/${WORKSPACE_ENV_BASENAME} or with \`--env-var\` at deploy.`,
+      "workspace-env.valueless"
+    );
+  }
+  if (kept.length > 0) {
+    warn(
+      `Kept ${kept.length} file${kept.length === 1 ? "" : "s"} no decode wrote \u2014 ${kept.length === 1 ? "it is" : "they are"} yours, and ${kept.length === 1 ? "it is" : "they are"} not part of the decoded tree:`,
+      "pull.kept-files",
+      [...kept.slice(0, 20).map((p) => `  ${shown}/${p}`), ...kept.length > 20 ? [`  \u2026 and ${kept.length - 20} more`] : []]
+    );
+  }
+  if (removed.length > 0) {
+    info(
+      `Removed ${removed.length} file${removed.length === 1 ? "" : "s"} the previous decode wrote and this one does not:`
+    );
+    for (const p of removed.slice(0, 20)) detail(`  ${shown}/${p}`);
+    if (removed.length > 20) detail(`  \u2026 and ${removed.length - 20} more`);
+  }
+  const routesNotes = () => {
+    if (routesDeferred.length === 0) return;
+    const bare = !existsSync(join(projectRootFrom(dirname(root)), "package.json"));
+    for (const line of routesDeferred) {
+      warn(
+        bare ? `${line} No package.json holds this tree, so that export cannot load \`@xano/sdk\` yet \u2014 run \`npm init -y && npm install @xano/sdk\` here first.` : line,
+        "routes.not-written"
+      );
+    }
+  };
+  const headline = project.report.headline();
+  const reportLine = () => {
+    if (headline === "") return;
+    const summary = project.report.summarize();
+    const line = `Decode report: ${headline} \u2014 listed in ${shown}/README.md.`;
+    if (summary.bySeverity.error + summary.bySeverity.warning > 0) warn(line, "decode.findings");
+    else info(line);
+    const notRecovered = project.report.renderCli({ categories: ["file-not-recovered"], fileBase: `${shown}/` });
+    if (notRecovered !== "") process.stderr.write(`${terminalText(notRecovered)}
+`);
+  };
+  const seedNote = () => {
+    if (loaded.seed !== void 0) reportSeedRows(loaded.seed.rows, loaded.label, loaded.seed.provenance, shown, contextFlags(args));
+  };
+  if (isMachineOutput(args)) {
+    routesNotes();
+    reportLine();
+    seedNote();
+    const under = (p) => `${shown}/${p}`;
+    writeJson({
+      source: raw,
+      ...loaded.backend,
+      out: root,
+      declined: false,
+      files: files.length,
+      removed: removed.map(under),
+      removedEdited: plan.removedEdited.map(under),
+      // The other half of "your edits were lost": files you edited that this
+      // decode REWROTE rather than removed. `--yes` answered for both.
+      rewrittenEdited: plan.edited.map(under),
+      kept: kept.map(under),
+      lockKept: reconciliation?.kept.length ?? 0,
+      lockDropped: reconciliation?.dropped.length ?? 0,
+      // Names only — a value never reaches stdout.
+      env: {
+        declared: env.declared,
+        written: env.written,
+        notWritten: [.../* @__PURE__ */ new Set([...env.notWritten, ...valueless])],
+        ...env.reason !== void 0 ? { declined: env.reason } : {}
+      },
+      report: project.report.toJson(),
+      seedRows: loaded.seed?.rows ?? []
+    });
+    return;
+  }
+  success(`Generated ${shown}/ from ${loaded.label}`);
+  detail(`${files.length} files written${removed.length > 0 ? `, ${removed.length} removed` : ""}`);
+  routesNotes();
+  reportLine();
+  seedNote();
+  if (reconciliation !== void 0) {
+    detail(`lock: ${reconciliation.kept.length} kept, ${reconciliation.dropped.length} dropped`);
+    if (reconciliation.disjoint) {
+      warn(
+        `None of xano.lock's entries appear in ${loaded.label}, so this tree now points at a different backend. Its lock was emptied rather than carried across.`,
+        "lock.repointed"
+      );
+    }
+  }
+}
+export {
+  CODEGEN_MARKER,
+  runGenerateCommand
+};
+//# sourceMappingURL=generate-command-AYEOLA26.js.map

package/dist/gitignore-3SJ3WNRG.js

@@ -0,0 +1,51 @@
+import {
+  ensureExportGitignored,
+  ensureGitignoredOrWarn,
+  ensureSecretPathGitignored,
+  ensureWorkspaceEnvGitignored,
+  refuseIfTracked,
+  requireSecretPathGitignored,
+  secretPathLabel
+} from "./chunk-YHEFQUQB.js";
+import "./chunk-DAD3ONIS.js";
+import "./chunk-5A2PLKZB.js";
+import "./chunk-AHJWCYQO.js";
+import "./chunk-DX4QR4B2.js";
+import "./chunk-6QXLMMT3.js";
+import "./chunk-ZFDZKNGG.js";
+import "./chunk-FWD7AL6N.js";
+import "./chunk-2GNFDZA2.js";
+import "./chunk-JTUKLCXS.js";
+import "./chunk-4KHEMC32.js";
+import "./chunk-ROY4YAEQ.js";
+import "./chunk-WRBKLYSJ.js";
+import "./chunk-3LDULPRE.js";
+import "./chunk-XW6KISBB.js";
+import "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-UCQ2VUTG.js";
+import "./chunk-DGWHAVRG.js";
+import "./chunk-PTHVMXZI.js";
+import "./chunk-GSGDWJB5.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-OHX6MIUZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  ensureExportGitignored,
+  ensureGitignoredOrWarn,
+  ensureSecretPathGitignored,
+  ensureWorkspaceEnvGitignored,
+  refuseIfTracked,
+  requireSecretPathGitignored,
+  secretPathLabel
+};
+//# sourceMappingURL=gitignore-3SJ3WNRG.js.map