@xano/sdk 1.0.0

package/dist/chunk-RTJRZFFY.js

@@ -0,0 +1,447 @@
+import {
+  parsePathParams,
+  pathSegment
+} from "./chunk-6IUMKYWI.js";
+
+// src/emit/routes-manifest.ts
+var RouteManifestError = class extends Error {
+};
+function routeKey(route) {
+  return `${route.verb} ${route.name}`;
+}
+function qualifiedRouteKey(route) {
+  return `${route.group}:${routeKey(route)}`;
+}
+function literal(value) {
+  return JSON.stringify(value);
+}
+function objectLiteral(rows) {
+  return rows.length === 0 ? "{}" : `{
+${rows.join("\n")}
+}`;
+}
+function overloadsFor(fn, rows) {
+  return rows.map(
+    (r) => r.params.length === 0 ? `export function ${fn}(name: ${literal(r.name)}): string;` : `export function ${fn}(name: ${literal(r.name)}, params: { ${r.params.map((p) => `${literal(p)}: string | number`).join("; ")} }): string;`
+  ).join("\n");
+}
+function renderRealtime(realtime) {
+  const servers = [...realtime.servers].sort((a, b) => a.name.localeCompare(b.name));
+  const known = new Map(servers.map((s) => [s.name, s]));
+  const seenServer = /* @__PURE__ */ new Set();
+  for (const server of servers) {
+    if (seenServer.has(server.name)) {
+      throw new RouteManifestError(
+        `Two realtime servers are both named "${server.name}". The manifest keys on the server name, so the names must be unique. Rename one.`
+      );
+    }
+    seenServer.add(server.name);
+  }
+  const holders = /* @__PURE__ */ new Map();
+  for (const channel of realtime.channels) holders.set(channel.name, (holders.get(channel.name) ?? 0) + 1);
+  const ambiguous = /* @__PURE__ */ new Map();
+  const seenChannel = /* @__PURE__ */ new Set();
+  const channels = [...realtime.channels].sort((a, b) => a.name.localeCompare(b.name) || a.server.localeCompare(b.server)).map((channel) => {
+    if (!known.has(channel.server)) {
+      throw new RouteManifestError(
+        `The channel "${channel.name}" names the realtime server "${channel.server}", which is not in this workspace. A channel's socket URL comes from its server's canonical, so the server must be registered too.`
+      );
+    }
+    const key = holders.get(channel.name) > 1 ? `${channel.server}:${channel.name}` : channel.name;
+    if (seenChannel.has(key)) {
+      throw new RouteManifestError(
+        `The realtime server "${channel.server}" has two channels both named "${channel.name}". Rename one.`
+      );
+    }
+    seenChannel.add(key);
+    if (key !== channel.name) ambiguous.set(channel.name, [...ambiguous.get(channel.name) ?? [], key]);
+    return { ...channel, key, params: parsePathParams(`channel "${key}"`, channel.name) };
+  });
+  const serverRows = servers.map(
+    (s) => `  ${literal(s.name)}: { canonical: ${literal(s.canonical)} },`
+  );
+  const channelRows = channels.map(
+    (c) => `  ${literal(c.key)}: { server: ${literal(c.server)}${c.key === c.name ? "" : `, path: ${literal(c.name)}`} },`
+  );
+  const ambiguousKeys = [...ambiguous.keys()].sort();
+  const ambiguousOverloads = ambiguousKeys.map((path) => {
+    const fix = `${path} is on more than one realtime server - use ${ambiguous.get(path).join(" or ")}`;
+    return `export function channelPath(name: ${literal(path)} & { readonly ${literal(fix)}: never }, params?: never): never;
+`;
+  }).join("");
+  const ambiguousSection = ambiguousKeys.length === 0 ? "" : `
+/** Channel paths on more than one realtime server. Each is keyed "<server>:<path>" in CHANNELS instead. */
+const AMBIGUOUS_CHANNELS: Record<string, readonly string[]> = ${objectLiteral(
+    ambiguousKeys.map((path) => `  ${literal(path)}: [${ambiguous.get(path).map(literal).join(", ")}],`)
+  )};
+`;
+  return `
+/** Every realtime server in this workspace, by name, with its resolved canonical. */
+export const REALTIME_SERVERS = ${objectLiteral(serverRows)} as const;
+
+/** Every realtime server name in this workspace. */
+export type RealtimeServerName = keyof typeof REALTIME_SERVERS;
+${ambiguousSection}
+/** Every realtime channel in this workspace, by path, with its owning server. */
+export const CHANNELS = ${objectLiteral(channelRows)} as const;
+
+/** Every realtime channel path in this workspace. */
+export type ChannelName = keyof typeof CHANNELS;
+
+${ambiguousOverloads}${overloadsFor("channelPath", channels.map((c) => ({ name: c.key, params: c.params })))}
+${realtimeImplementation(ambiguousKeys.length > 0)}`;
+}
+function renderRouteManifest(routes, realtime) {
+  const sorted = [...routes].sort(
+    (a, b) => a.canonical.localeCompare(b.canonical) || a.name.localeCompare(b.name) || a.verb.localeCompare(b.verb)
+  );
+  const holders = /* @__PURE__ */ new Map();
+  for (const route of sorted) holders.set(routeKey(route), (holders.get(routeKey(route)) ?? 0) + 1);
+  const ambiguous = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Map();
+  const rows = sorted.map((route) => {
+    const short = routeKey(route);
+    const group = route.group ?? route.canonical;
+    const key = holders.get(short) > 1 ? qualifiedRouteKey({ ...route, group }) : short;
+    const clash = seen.get(key);
+    if (clash !== void 0) {
+      throw new RouteManifestError(
+        `Two endpoints are both "${short}" in api groups named "${group}" \u2014 one whose canonical is "${clash}", one "${route.canonical}". The route manifest keys such an endpoint "<group>:<VERB> <name>", so the group names must differ. Rename one group or endpoint, or give it a different verb.`
+      );
+    }
+    seen.set(key, route.canonical);
+    if (key !== short) ambiguous.set(short, [...ambiguous.get(short) ?? [], key]);
+    const params = parsePathParams(`route "${key}"`, route.name);
+    const path = `/api:${route.canonical}/${route.name.replace(/^\/+/, "")}`;
+    return { ...route, key, params, path };
+  });
+  const entries = rows.map(
+    (r) => `  ${literal(r.key)}: { verb: ${literal(r.verb)}, path: ${literal(r.path)} },`
+  );
+  const ambiguousKeys = [...ambiguous.keys()].sort();
+  const ambiguousOverloads = ambiguousKeys.map((short) => {
+    const fix = `${short} is in more than one api group - use ${ambiguous.get(short).join(" or ")}`;
+    return `export function routePath(name: ${literal(short)} & { readonly ${literal(fix)}: never }, params?: never): never;`;
+  }).join("\n");
+  const ambiguousSection = ambiguousKeys.length === 0 ? "" : `
+/**
+ * Endpoints whose "<VERB> <name>" is in more than one api group. Each is keyed
+ * "<group>:<VERB> <name>" in ROUTES instead \u2014 e.g. ${literal(ambiguous.get(ambiguousKeys[0])[0])}.
+ */
+const AMBIGUOUS: Record<string, readonly string[]> = ${objectLiteral(
+    ambiguousKeys.map((short) => `  ${literal(short)}: [${ambiguous.get(short).map(literal).join(", ")}],`)
+  )};
+`;
+  const realtimeSection = realtime && (realtime.servers.length > 0 || realtime.channels.length > 0) ? renderRealtime(realtime) : "";
+  return `${HEADER}${FILL_PARAMS}${ambiguousSection}
+export const ROUTES = ${objectLiteral(entries)} as const;
+
+/**
+ * Every endpoint in this workspace, keyed \`"<VERB> <name>"\` (e.g. \`"GET listings"\`),
+ * or \`"<group>:<VERB> <name>"\` when that pair is in more than one api group.
+ */
+export type RouteName = keyof typeof ROUTES;
+${rows.length > 1 ? MANY_ROUTES : ""}
+${rows.length > 1 ? UNION_OVERLOAD : ""}${ambiguousOverloads ? `${ambiguousOverloads}
+` : ""}${overloadsFor("routePath", rows.map((r) => ({ name: r.key, params: r.params })))}
+${implementation(ambiguousKeys.length > 0)}${realtimeSection}`;
+}
+var UNION_OVERLOAD = `/** A union of route names (e.g. a \`key: RouteName\` parameter): params checked at runtime. */
+export function routePath<N extends RouteName>(name: ManyRoutes<N>, params?: Record<string, string | number>): string;
+`;
+var MANY_ROUTES = `
+/** \`N\` when it is a union of two or more route names, else \`never\`. */
+type ManyRoutes<N> = [(N extends unknown ? (x: N) => void : never) extends (x: infer I) => void ? I : never] extends [never] ? N : never;
+`;
+var HEADER = `/**
+ * GENERATED by \`xanosdk routes --emit\`. Do not edit.
+ *
+ * Plain data plus one interpolator \u2014 this file imports nothing, so a frontend
+ * gets the typed path/verb (and socket) contract without pulling the SDK runtime
+ * into its bundle. Regenerate after changing an endpoint's name, verb, or api
+ * group, or a realtime server's or channel's name.
+ */
+`;
+var FILL_PARAMS = `
+/**
+ * An own key only. Every lookup here is keyed by a caller's string, and a plain
+ * object answers \`toString\`, \`constructor\` or \`hasOwnProperty\` from its
+ * prototype \u2014 a name no route, channel or param carries would read as one.
+ */
+function own<T>(record: Record<string, T>, key: string): T | undefined {
+  return Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined;
+}
+
+function fillParams(
+  label: string,
+  noun: string,
+  template: string,
+  params?: Record<string, string | number>,
+  encode = false,
+): string {
+  const declared = [...template.matchAll(/\\{([^/{}]+)\\}/g)].map((m) => m[1]!);
+  for (const key of Object.keys(params ?? {})) {
+    if (!declared.includes(key)) {
+      throw new Error(
+        \`\${label}: \\\`\${key}\\\` is not a {param} of this \${noun}.\` +
+          (declared.length ? \` Expected: \${declared.join(", ")}.\` : \` This \${noun} is static.\`),
+      );
+    }
+  }
+  const raw: Record<string, string> = {};
+  const filled = template.replace(/\\{([^/{}]+)\\}/g, (_all, key: string) => {
+    const value = own(params ?? {}, key);
+    if (value === undefined || value === null || value === "") {
+      throw new Error(\`\${label}: missing a value for the path param \\\`\${key}\\\`.\`);
+    }
+    if (typeof value === "number" && !Number.isFinite(value)) {
+      throw new Error(\`\${label}: the path param \\\`\${key}\\\` is \${value}.\`);
+    }
+    const text = String(value);
+    if (text.includes("/")) {
+      throw new Error(
+        \`\${label}: the path param \\\`\${key}\\\` cannot contain "/" \u2014 \` +
+          \`it would address a different \${noun}.\`,
+      );
+    }
+    if (!encode) {
+      if (!/^[A-Za-z0-9_-]+$/.test(text)) {
+        throw new Error(
+          \`\${label}: the path param \\\`\${key}\\\` is "\${text}" \u2014 a \${noun} segment holds only \` +
+            \`letters, digits, "_" and "-".\`,
+        );
+      }
+      return text;
+    }
+    raw[key] = encodeURIComponent(text);
+    return raw[key];
+  });
+  // A "." or ".." SEGMENT is REMOVED before routing (and takes the segment
+  // before it), and the URL standard reads "%2e" as a dot for that check too.
+  // Judged on the segment as sent, values encoded.
+  if (encode) {
+    for (const segment of template.split("/")) {
+      if (!segment.includes("{")) continue;
+      const assembled = segment.replace(/\\{([^/{}]+)\\}/g, (_all, key: string) => raw[key] ?? "");
+      if (/^(\\.|%2e){1,2}$/i.test(assembled)) {
+        throw new Error(
+          \`\${label}: the path segment "\${segment}" cannot be "\${assembled}" \u2014 \` +
+            \`a "." or ".." segment addresses a different \${noun}.\`,
+        );
+      }
+    }
+  }
+  return filled;
+}
+`;
+function implementation(ambiguous) {
+  const params = ambiguous ? "params?: Record<string, string | number> | string" : "params?: Record<string, string | number>";
+  const hint = ambiguous ? `
+  const qualified = own(AMBIGUOUS, name);
+  if (qualified) {
+    throw new Error(
+      \`routePath: "\${String(name)}" is in more than one api group \u2014 use \${qualified.map((k) => \`"\${k}"\`).join(" or ")}.\`,
+    );
+  }` : "";
+  return `
+export function routePath(name: ${ambiguous ? "string" : "RouteName"}, ${params}): string {${hint}
+  // Read through a widened view: a workspace with no endpoints at all makes
+  // \`RouteName\` \`never\`, which cannot index the literal type.
+  const route = own(ROUTES as Record<string, { verb: string; path: string }>, name);
+  if (!route) {
+    throw new Error(
+      \`routePath: unknown route "\${String(name)}". Routes are keyed "<VERB> <name>", \` +
+        'e.g. "GET listings" \u2014 regenerate the manifest if the endpoint is new.',
+    );
+  }
+  return fillParams(\`routePath("\${String(name)}")\`, "route", route.path, params${ambiguous ? " as Record<string, string | number> | undefined" : ""}, true);
+}
+`;
+}
+function realtimeImplementation(ambiguous) {
+  if (!ambiguous) {
+    return `
+export function channelPath(name: ChannelName, params?: Record<string, string | number>): string {
+  if (!own(CHANNELS as Record<string, unknown>, name)) {
+    throw new Error(\`channelPath: unknown channel "\${String(name)}".\`);
+  }
+  return fillParams(\`channelPath("\${String(name)}")\`, "channel", String(name), params);
+}
+${REALTIME_IMPLEMENTATION}`;
+  }
+  return `
+export function channelPath(name: string, params?: Record<string, string | number>): string {
+  const qualified = own(AMBIGUOUS_CHANNELS, name);
+  if (qualified) {
+    throw new Error(
+      \`channelPath: "\${String(name)}" is on more than one realtime server \u2014 use \${qualified.map((k) => \`"\${k}"\`).join(" or ")}.\`,
+    );
+  }
+  const channel = own(CHANNELS as Record<string, { server: string; path?: string }>, name);
+  if (!channel) {
+    throw new Error(\`channelPath: unknown channel "\${String(name)}".\`);
+  }
+  return fillParams(\`channelPath("\${String(name)}")\`, "channel", channel.path ?? String(name), params);
+}
+${REALTIME_IMPLEMENTATION}`;
+}
+var REALTIME_IMPLEMENTATION = `
+/** Reject a tenant name that would break the \\\`<tenant>:<canonical>\\\` split. */
+function assertTenant(tenant: string): string {
+  if (!/^[A-Za-z0-9-]+$/.test(tenant)) {
+    throw new Error(
+      \`socketUrl: invalid \\\`tenant\\\` \${JSON.stringify(tenant)} \u2014 a tenant name is alphanumeric with \` +
+        \`dashes (e.g. "xxxx-xxxx-xxxx"). It rides as a "<tenant>:<canonical>" prefix, so ":" and "/" \` +
+        "cannot appear in it.",
+    );
+  }
+  return tenant;
+}
+
+/** The websocket PATH \u2014 \\\`/ws/<canonical>\\\`, or \\\`/ws/<tenant>:<canonical>\\\`. */
+export function socketPath(server: RealtimeServerName, opts?: { tenant?: string | undefined }): string {
+  const entry = own(REALTIME_SERVERS as Record<string, { canonical: string }>, server);
+  if (!entry) throw new Error(\`socketPath: unknown realtime server "\${String(server)}".\`);
+  const prefix = opts?.tenant ? \`\${assertTenant(opts.tenant)}:\` : "";
+  return \`/ws/\${prefix}\${entry.canonical}\`;
+}
+
+/** The absolute websocket URL \u2014 \\\`baseUrl\\\` + {@link socketPath}, scheme normalized to ws/wss. */
+export function socketUrl(
+  server: RealtimeServerName,
+  baseUrl: string,
+  opts?: { tenant?: string | undefined },
+): string {
+  if (!own(REALTIME_SERVERS as Record<string, unknown>, server)) {
+    throw new Error(\`socketUrl: unknown realtime server "\${String(server)}".\`);
+  }
+  const base = (baseUrl ?? "").trim().replace(/\\/+$/, "");
+  if (!base) throw new Error('socketUrl: needs a base URL (e.g. "https://x.dev.xano.io").');
+  const socketBase = /^wss?:\\/\\//i.test(base)
+    ? base
+    : /^https?:\\/\\//i.test(base)
+      ? base.replace(/^http/i, "ws")
+      : \`wss://\${base}\`;
+  // A base URL ending in \\\`/ws/<something>\\\` is this function's own output fed back
+  // in. Appending a second \\\`/ws/<canonical>\\\` is wrong twice: the extra segments
+  // join the connection hash, and the tenant is dropped (the first call already
+  // consumed the \\\`/tenant/<name>\\\` prefix). Refuse rather than dial a bad URL.
+  if (/\\/ws\\/[^/]+$/i.test(socketBase)) {
+    throw new Error(
+      \`socketUrl: \\\`baseUrl\\\` already carries a socket path (\${base}). Pass the http(s) \` +
+        "INSTANCE base URL, not the result of a previous socketUrl()/getUrl() \u2014 resolving twice " +
+        'appends a second "/ws/<canonical>" and drops the tenant.',
+    );
+  }
+  // A query, a fragment or an API group's \\\`/api:<\u2026>\\\` path is not an instance
+  // base: the socket path appended after it never reaches the server.
+  if (/[?#]/.test(base) || /\\/api:/i.test(base)) {
+    throw new Error(
+      \`socketUrl: \\\`baseUrl\\\` is not an instance base URL (\${base}). Pass "https://<host>" or \` +
+        '"https://<host>/tenant/<name>" \u2014 no query, fragment or /api:<\u2026> path.',
+    );
+  }
+  // A tenant base URL names its tenant as its own path segment; the socket glues
+  // it to the canonical inside one segment. Translate rather than concatenate \u2014
+  // the concatenated form never upgrades at all.
+  const lifted = /^(wss?:\\/\\/[^/]+)\\/tenant\\/([^/]+)(\\/.*)?$/i.exec(socketBase);
+  let origin = socketBase;
+  let tenant = opts?.tenant;
+  if (lifted) {
+    const fromBase = lifted[2]!;
+    if (tenant !== undefined && tenant !== fromBase) {
+      throw new Error(
+        \`socketUrl: given tenant \${JSON.stringify(tenant)} but the base URL names \` +
+          \`\${JSON.stringify(fromBase)} (".../tenant/\${fromBase}"). Refusing to guess which one you \` +
+          "meant \u2014 pass the matching tenant, or a base URL without the \\"/tenant/<name>\\" prefix.",
+      );
+    }
+    origin = \`\${lifted[1]!}\${lifted[3] ?? ""}\`;
+    tenant = assertTenant(fromBase);
+  }
+  return \`\${origin}\${socketPath(server, { tenant })}\`;
+}
+`;
+var ROUTES_MANIFEST_BASENAME = "routes.gen.ts";
+function planRouteManifest(payload, locked = () => void 0) {
+  const list = (key) => Array.isArray(payload[key]) ? payload[key].filter(
+    (r) => r !== null && typeof r === "object"
+  ) : [];
+  const text = (v) => typeof v === "string" && v !== "" ? v : void 0;
+  const ref = (v) => v !== null && typeof v === "object" ? text(v.id) : void 0;
+  const canonicalByGuid = /* @__PURE__ */ new Map();
+  const groupByGuid = /* @__PURE__ */ new Map();
+  for (const a of list("app")) {
+    const guid = text(a.guid);
+    if (guid === void 0) continue;
+    const name = text(a.name);
+    if (name !== void 0) groupByGuid.set(guid, name);
+    const resolved = text(a.canonical) ?? (name !== void 0 ? locked("app", name) : void 0);
+    if (resolved) canonicalByGuid.set(guid, resolved);
+  }
+  const rows = list("query").map((q) => {
+    const group = ref(q.app);
+    return {
+      verb: q.verb,
+      // already an uppercase HttpVerb in the bundle
+      // Match getPath(): the path segment drops any leading slash on the name.
+      name: pathSegment(typeof q.name === "string" ? q.name : ""),
+      canonical: group !== void 0 ? canonicalByGuid.get(group) : void 0,
+      ...group !== void 0 && groupByGuid.has(group) ? { group: groupByGuid.get(group) } : {}
+    };
+  });
+  rows.sort((a, b) => (a.canonical ?? "").localeCompare(b.canonical ?? "") || a.name.localeCompare(b.name));
+  const serverNameByGuid = /* @__PURE__ */ new Map();
+  const serverRows = list("realtime_server").flatMap((s) => {
+    const name = text(s.name);
+    if (name === void 0) return [];
+    const guid = text(s.guid);
+    if (guid !== void 0) serverNameByGuid.set(guid, name);
+    return [{ name, canonical: text(s.canonical) ?? locked("realtime_server", name) }];
+  });
+  const servers = serverRows.flatMap((s) => s.canonical ? [{ name: s.name, canonical: s.canonical }] : []);
+  const describable = new Set(servers.map((s) => s.name));
+  const channels = list("channel").flatMap((c) => {
+    const name = text(c.name);
+    if (name === void 0) return [];
+    const serverGuid = ref(c.server);
+    const server = serverGuid !== void 0 ? serverNameByGuid.get(serverGuid) : void 0;
+    if (server === void 0 || !describable.has(server)) return [];
+    return [{ name, server }];
+  });
+  return {
+    rows,
+    resolved: rows.flatMap(
+      (r) => r.canonical ? [{ name: r.name, verb: r.verb, canonical: r.canonical, ...r.group !== void 0 ? { group: r.group } : {} }] : []
+    ),
+    unresolved: rows.filter((r) => !r.canonical),
+    servers,
+    unresolvedServers: serverRows.filter((s) => !s.canonical).map((s) => s.name),
+    channels
+  };
+}
+function unresolvedCanonicalMessage(unresolved, entry) {
+  const names = unresolved.map((r) => `"${r.name}"`).join(", ");
+  const nul = process.platform === "win32" ? "NUL" : "/dev/null";
+  return `cannot resolve the api group's canonical URL token for ${unresolved.length === 1 ? "the query" : `${unresolved.length} queries`} ${names}. Set an explicit \`apiGroup({ canonical })\`, or run \`xanosdk export ${entry} --out ${nul}\` once (it mints a unique canonical and freezes it in xano.lock, and writes the bundle nowhere), then re-run \`xanosdk routes\`.`;
+}
+function renderPlannedManifest(plan, entry = "<entry>") {
+  if (plan.unresolved.length > 0) throw new RouteManifestError(unresolvedCanonicalMessage(plan.unresolved, entry));
+  if (plan.resolved.length === 0 && plan.servers.length === 0) return void 0;
+  return renderRouteManifest(
+    plan.resolved,
+    plan.servers.length > 0 ? { servers: plan.servers, channels: plan.channels } : void 0
+  );
+}
+
+export {
+  RouteManifestError,
+  routeKey,
+  qualifiedRouteKey,
+  renderRouteManifest,
+  ROUTES_MANIFEST_BASENAME,
+  planRouteManifest,
+  unresolvedCanonicalMessage,
+  renderPlannedManifest
+};
+//# sourceMappingURL=chunk-RTJRZFFY.js.map

package/dist/chunk-SAVJUS2X.js

@@ -0,0 +1,128 @@
+import {
+  ensureExportGitignored
+} from "./chunk-YHEFQUQB.js";
+import {
+  andList
+} from "./chunk-622HUCZT.js";
+import {
+  UsageError,
+  warn
+} from "./chunk-PTHVMXZI.js";
+
+// src/emit/output-target.ts
+import { accessSync, chmodSync, constants, mkdirSync, statSync, writeFileSync } from "fs";
+import { dirname, isAbsolute, join, resolve, sep } from "path";
+function resolveOutputTarget(opts) {
+  const { path, name, ext } = opts;
+  if (path === "-") return { kind: "stdout" };
+  if (path === void 0 || path === "") {
+    return { kind: "file", path: resolve(deriveExportBasename(name, ext)) };
+  }
+  const endsWithSep = path.endsWith("/") || path.endsWith("\\");
+  const isDir = statSync(path, { throwIfNoEntry: false })?.isDirectory() ?? false;
+  if (endsWithSep || isDir) {
+    return { kind: "file", path: resolve(join(path, deriveExportBasename(name, ext))) };
+  }
+  return { kind: "file", path: resolve(path) };
+}
+function deriveExportBasename(name, ext) {
+  if (name.trim() === "") {
+    throw new UsageError(
+      `An export derives its filename from the name it was given, and this one is empty.
+The file would be written as \`.${ext}\` \u2014 a dotfile with no name at all, in a directory the reader is not looking at it in.
+Name the export, or pass \`--path <file>\` to write to a filename of your choosing.`
+    );
+  }
+  if (name.includes("/") || name.includes("\\") || name.includes(":")) {
+    throw new UsageError(
+      `"${name}" is a path, not a name \u2014 an export derives its filename from it.
+\`/\`, \`\\\` and \`:\` each address a LOCATION rather than name a file, so writing this as given would land the file somewhere the command was never pointed at: outside the invocation directory when the name traverses up, and on another drive entirely when it begins \`C:\` on Windows.
+To write somewhere else on purpose, pass \`--path <file>\` naming the file. A \`--path\` that names a DIRECTORY derives this same basename inside it, so it does not sidestep this.`
+    );
+  }
+  if (name.startsWith(".")) {
+    throw new UsageError(
+      `"${name}" begins with a dot, so an export would derive a filename from it that addresses a directory (\`.\`, \`..\`) or hides the file from the reader who asked for it.
+Pass \`--path <file>\` to write to a dotted filename on purpose.`
+    );
+  }
+  const file = `${name}.${ext}`;
+  if (Buffer.byteLength(file, "utf8") > MAX_BASENAME_BYTES) {
+    throw new UsageError(
+      `"${name.length > 40 ? `${name.slice(0, 40)}\u2026` : name}" is too long to be a filename (${Buffer.byteLength(file, "utf8")} bytes; a filesystem allows ${MAX_BASENAME_BYTES}).
+Pass \`--path <file>\` to write it under a shorter name.`
+    );
+  }
+  return file;
+}
+var MAX_BASENAME_BYTES = 255;
+function writeExportFile(path, content, secrets = [], flag = "--path", written = "Nothing was written") {
+  let regular = true;
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    if (secrets.length > 0) {
+      writeFileSync(path, content, { encoding: "utf8", mode: 384 });
+      regular = statSync(path).isFile();
+      if (regular) chmodSync(path, 384);
+    } else {
+      writeFileSync(path, content, "utf8");
+    }
+  } catch (err) {
+    throw unwritable(path, err, flag, written);
+  }
+  if (secrets.length > 0 && regular) {
+    const notice = `${path} carries ${secretsPhrase(secrets)} in cleartext \u2014 written owner-only (0600); do not commit it.`;
+    warn(notice, "secrets.cleartext-export");
+    ensureExportGitignored(path);
+  }
+}
+function secretsPhrase(secrets) {
+  return andList(secrets.map((s) => s === "documentation token" ? "a documentation token" : s));
+}
+function assertWritableTarget(path, flag = "--path") {
+  const target = isAbsolute(path) ? path : process.cwd() + sep + path;
+  try {
+    const existing = statOrUndefined(target);
+    if (existing !== void 0) {
+      if (existing.isDirectory()) throw Object.assign(new Error("EISDIR"), { code: "EISDIR" });
+      accessSync(target, constants.W_OK);
+      return;
+    }
+    let dir = dirname(target);
+    for (; ; ) {
+      const st = statOrUndefined(dir);
+      if (st !== void 0) {
+        if (!st.isDirectory()) throw Object.assign(new Error("ENOTDIR"), { code: "ENOTDIR" });
+        accessSync(dir, constants.W_OK);
+        return;
+      }
+      const parent = dirname(dir);
+      if (parent === dir) return;
+      dir = parent;
+    }
+  } catch (err) {
+    throw unwritable(path, err, flag);
+  }
+}
+function statOrUndefined(path) {
+  try {
+    return statSync(path);
+  } catch (err) {
+    if (err.code === "ENOENT") return void 0;
+    throw err;
+  }
+}
+function unwritable(path, err, flag, written = "Nothing was written") {
+  const code = err?.code;
+  const why = code === "EEXIST" || code === "ENOTDIR" ? "a FILE sits where one of its parent directories would have to be" : code === "EISDIR" ? "it is a directory" : code === "ENAMETOOLONG" ? "the path is longer than the filesystem allows" : code === "EACCES" || code === "EPERM" ? "this user may not write there" : code === "EROFS" ? "the filesystem there is read-only" : code === "ENOENT" ? "its parent directory does not exist and cannot be created there" : void 0;
+  if (why === void 0) return err;
+  return new UsageError(`Cannot write ${path}: ${why}. ${written}. Pass a different \`${flag}\`.`);
+}
+
+export {
+  resolveOutputTarget,
+  writeExportFile,
+  secretsPhrase,
+  assertWritableTarget
+};
+//# sourceMappingURL=chunk-SAVJUS2X.js.map