@autter/runtime-cli 0.0.0-stage → 1.0.0

package/dist/vite.cjs

@@ -0,0 +1,576 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/vite.ts
+var vite_exports = {};
+__export(vite_exports, {
+  autterSourceMaps: () => autterSourceMaps,
+  default: () => vite_default
+});
+module.exports = __toCommonJS(vite_exports);
+var import_node_path2 = require("path");
+
+// src/inject.ts
+var import_promises2 = require("fs/promises");
+
+// src/debug-id.ts
+var import_node_crypto = require("crypto");
+var DEBUG_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function normalizeDebugId(value) {
+  if (typeof value !== "string") return null;
+  const id = value.trim().toLowerCase();
+  return DEBUG_ID_RE.test(id) ? id : null;
+}
+function debugIdFor(bytes) {
+  const hash = (0, import_node_crypto.createHash)("sha256").update(bytes).digest();
+  hash[6] = hash[6] & 15 | 64;
+  hash[8] = hash[8] & 63 | 128;
+  const hex = hash.subarray(0, 16).toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+var DEBUG_ID_COMMENT_RE = /^\/\/# debugId=([0-9a-fA-F-]{36})[ \t]*\r?$/gm;
+function readDebugIdComment(code) {
+  let found = null;
+  for (const match of code.matchAll(DEBUG_ID_COMMENT_RE)) found = normalizeDebugId(match[1]) ?? found;
+  return found;
+}
+var DEBUG_ID_REGISTRY = "_autterDebugIds";
+function debugIdSnippet(id) {
+  return `;!function(){try{var g="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof self?self:{},s=(new g.Error).stack;s&&((g.${DEBUG_ID_REGISTRY}=g.${DEBUG_ID_REGISTRY}||{})[s]="${id}")}catch(e){}}();`;
+}
+var SNIPPET_RE = /\(g\._autterDebugIds=g\._autterDebugIds\|\|\{\}\)\[s\]="[0-9a-f]{8}-/;
+function hasDebugIdSnippet(code) {
+  return SNIPPET_RE.test(code);
+}
+
+// src/files.ts
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var BUNDLE_RE = /\.[cm]?js$/;
+var SOURCE_MAPPING_URL_RE = /^[ \t]*\/\/[#@] sourceMappingURL=([^\s'"]+)[ \t]*\r?$/gm;
+function readSourceMappingUrl(code) {
+  let found = null;
+  for (const match of code.matchAll(SOURCE_MAPPING_URL_RE)) found = match[1];
+  return found;
+}
+function stripSourceMappingUrl(code) {
+  const lines = code.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (line === "") continue;
+    if (/^\/\/[#@] sourceMappingURL=/.test(line)) {
+      lines.splice(i, 1);
+      return lines.join("\n");
+    }
+    if (!line.startsWith("//#")) break;
+  }
+  return code;
+}
+function mapPathFor(js, code) {
+  const url = readSourceMappingUrl(code);
+  if (url && !/^[a-z][\w+.-]*:/i.test(url) && !url.startsWith("/")) {
+    let decoded = url.split(/[?#]/)[0];
+    try {
+      decoded = decodeURIComponent(decoded);
+    } catch {
+    }
+    const candidate = (0, import_node_path.resolve)((0, import_node_path.dirname)(js), decoded);
+    if ((0, import_node_fs.existsSync)(candidate)) return candidate;
+  }
+  const sibling = `${js}.map`;
+  return (0, import_node_fs.existsSync)(sibling) ? sibling : null;
+}
+async function walk(dir, out) {
+  let entries;
+  try {
+    entries = await (0, import_promises.readdir)(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.name === "node_modules") continue;
+    const full = (0, import_node_path.join)(dir, entry.name);
+    if (entry.isDirectory()) await walk(full, out);
+    else if (entry.isFile() && BUNDLE_RE.test(entry.name)) out.push(full);
+  }
+}
+async function findBundles(dir, files) {
+  const root = (0, import_node_path.resolve)(dir);
+  const candidates = [];
+  if (files) {
+    for (const file of files) if (BUNDLE_RE.test(file)) candidates.push((0, import_node_path.resolve)(root, file));
+  } else {
+    await walk(root, candidates);
+  }
+  const bundles = [];
+  for (const js of [...new Set(candidates)].sort()) {
+    let code;
+    try {
+      code = await (0, import_promises.readFile)(js, "utf8");
+    } catch {
+      continue;
+    }
+    const map = mapPathFor(js, code);
+    if (map) bundles.push({ js, map, path: (0, import_node_path.relative)(root, js).split(import_node_path.sep).join("/") });
+  }
+  return bundles;
+}
+
+// src/inject.ts
+var SNIPPET_LINE_KEY = "x_autter_snippet_line";
+function snippetLine(code) {
+  let line = 0;
+  let i = 0;
+  if (code.startsWith("#!")) {
+    const nl = code.indexOf("\n");
+    if (nl < 0) return -1;
+    line = 1;
+    i = nl + 1;
+  }
+  for (; ; ) {
+    while (i < code.length && /\s/.test(code[i])) i++;
+    if (code.startsWith("//", i)) {
+      const nl = code.indexOf("\n", i);
+      if (nl < 0) return -1;
+      i = nl + 1;
+    } else if (code.startsWith("/*", i)) {
+      const end = code.indexOf("*/", i + 2);
+      if (end < 0) return -1;
+      i = end + 2;
+    } else {
+      break;
+    }
+  }
+  return code[i] === '"' || code[i] === "'" ? -1 : line;
+}
+function shiftMappings(mappings, at, count = 1) {
+  const lines = mappings.split(";");
+  while (lines.length < at) lines.push("");
+  lines.splice(at, 0, ...Array(count).fill(""));
+  return lines.join(";");
+}
+function insertBeforeTrailingComments(code, text) {
+  const lines = code.split("\n");
+  let at = lines.length;
+  while (at > 0) {
+    const line = lines[at - 1].trim();
+    if (line === "" || line.startsWith("//#") || line.startsWith("//@")) at--;
+    else break;
+  }
+  const head = lines.slice(0, at).join("\n");
+  const tail = lines.slice(at).join("\n");
+  return `${head}${head && !head.endsWith("\n") ? "\n" : ""}${text}${tail ? `
+${tail.replace(/^\n+/, "")}` : "\n"}`;
+}
+async function injectBundle(bundle, options = {}) {
+  const bytes = await (0, import_promises2.readFile)(bundle.js);
+  const code = bytes.toString("utf8");
+  const base = { path: bundle.path, js: bundle.js, map: bundle.map };
+  let map;
+  try {
+    map = JSON.parse(await (0, import_promises2.readFile)(bundle.map, "utf8"));
+    if (!map || typeof map !== "object") throw new Error("not an object");
+  } catch {
+    return { ...base, debugId: "", status: "invalid-map" };
+  }
+  const existing = readDebugIdComment(code);
+  const hasSnippet = hasDebugIdSnippet(code);
+  const debugId = existing ?? debugIdFor(bytes);
+  let out = code;
+  let mapDirty = false;
+  if (!hasSnippet) {
+    const shifted = typeof map[SNIPPET_LINE_KEY] === "number" ? map[SNIPPET_LINE_KEY] : null;
+    const line = shifted ?? snippetLine(code);
+    if (line >= 0 && (shifted !== null || typeof map.mappings === "string" && !("sections" in map))) {
+      let offset = 0;
+      for (let n = 0; n < line; n++) offset = out.indexOf("\n", offset) + 1;
+      out = `${out.slice(0, offset)}${debugIdSnippet(debugId)}
+${out.slice(offset)}`;
+      if (shifted === null) {
+        map.mappings = shiftMappings(map.mappings, line);
+        map[SNIPPET_LINE_KEY] = line;
+        mapDirty = true;
+      }
+    } else {
+      out = insertBeforeTrailingComments(out, debugIdSnippet(debugId));
+    }
+  }
+  if (!existing) out = `${out}${out.endsWith("\n") ? "" : "\n"}//# debugId=${debugId}
+`;
+  if (options.stripSourceMappingUrl) out = stripSourceMappingUrl(out);
+  if (map.debugId !== debugId) {
+    map.debugId = debugId;
+    mapDirty = true;
+  }
+  const changed = mapDirty || out !== code;
+  if (changed && !options.dryRun) {
+    if (mapDirty) await (0, import_promises2.writeFile)(bundle.map, JSON.stringify(map));
+    if (out !== code) await (0, import_promises2.writeFile)(bundle.js, out);
+  }
+  return { ...base, debugId, status: changed ? "injected" : "unchanged" };
+}
+async function injectDir(dir, options = {}) {
+  const results = [];
+  for (const bundle of await findBundles(dir, options.files)) results.push(await injectBundle(bundle, options));
+  return results;
+}
+
+// src/upload.ts
+var import_node_crypto2 = require("crypto");
+var import_promises3 = require("fs/promises");
+
+// src/release.ts
+var import_node_child_process = require("child_process");
+var RELEASE_RE = /^[a-zA-Z0-9._-]{1,200}$/;
+var RELEASE_ENV_VARS = [
+  "GITHUB_SHA",
+  "VERCEL_GIT_COMMIT_SHA",
+  "CF_PAGES_COMMIT_SHA",
+  "GIT_SHA"
+];
+function gitHead(cwd = process.cwd()) {
+  try {
+    const sha = (0, import_node_child_process.execFileSync)("git", ["rev-parse", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1e4
+    }).trim();
+    return /^[0-9a-f]{7,64}$/.test(sha) ? sha : null;
+  } catch {
+    return null;
+  }
+}
+function resolveRelease(explicit, env = process.env, cwd = process.cwd()) {
+  const candidates = [
+    ["--release", explicit],
+    ...RELEASE_ENV_VARS.map((name) => [name, env[name]])
+  ];
+  for (const [source, value] of candidates) {
+    const release = value?.trim();
+    if (!release) continue;
+    if (!RELEASE_RE.test(release)) {
+      throw new Error(
+        `release "${release}" (from ${source}) is not valid: use 1-200 letters, digits, ".", "_" or "-" (a commit SHA works)`
+      );
+    }
+    return { release, source };
+  }
+  const head = gitHead(cwd);
+  if (head) return { release: head, source: "git" };
+  throw new Error(
+    `no release: pass --release <release>, or set one of ${RELEASE_ENV_VARS.join(", ")}, or run inside a git checkout`
+  );
+}
+
+// src/upload.ts
+var DEFAULT_ENDPOINT = "https://otlp.autter.dev";
+var MAX_UPLOAD_BYTES = 5 * 1024 * 1024;
+var CHECK_BATCH = 500;
+var MAX_ATTEMPTS = 3;
+function resolveEndpoint(flag, env = process.env) {
+  const raw = flag || env.AUTTER_ENDPOINT || env.AUTTER_RUNTIME_ENDPOINT || env.OTEL_EXPORTER_OTLP_ENDPOINT || DEFAULT_ENDPOINT;
+  return raw.trim().replace(/\/+$/, "").replace(/\/v1\/[a-z-]+$/, "");
+}
+function servedFilename(urlPrefix, path) {
+  let prefix = (urlPrefix ?? "/").trim() || "/";
+  if (prefix.startsWith("~/")) prefix = prefix.slice(1);
+  if (!/^[a-z][\w+.-]*:\/\//i.test(prefix) && !prefix.startsWith("/")) prefix = `/${prefix}`;
+  return `${prefix.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+function storedMapJson(map) {
+  const { sourcesContent: _omitted, ...safe } = map;
+  return JSON.stringify(safe);
+}
+async function prepare(bundle, urlPrefix, release) {
+  let map;
+  try {
+    map = JSON.parse(await (0, import_promises3.readFile)(bundle.map, "utf8"));
+  } catch {
+    return { error: "map is not valid JSON" };
+  }
+  if (!map || map.version !== 3 || typeof map.mappings !== "string" || !Array.isArray(map.sources)) {
+    return { error: "not a version 3 source map with mappings and sources" };
+  }
+  const code = await (0, import_promises3.readFile)(bundle.js, "utf8");
+  const debugId = readDebugIdComment(code) ?? normalizeDebugId(map.debugId);
+  const json = storedMapJson(map);
+  const filename = servedFilename(urlPrefix, bundle.path);
+  const body = `{"release":${JSON.stringify(release)},"filename":${JSON.stringify(filename)},${debugId ? `"debugId":${JSON.stringify(debugId)},` : ""}"map":${json}}`;
+  return {
+    bundle,
+    body,
+    path: bundle.path,
+    filename,
+    debugId,
+    hash: (0, import_node_crypto2.createHash)("sha256").update(json).digest("hex"),
+    bytes: Buffer.byteLength(body)
+  };
+}
+var FatalUploadError = class extends Error {
+};
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+async function uploadDir(dir, options = {}) {
+  const env = options.env ?? process.env;
+  const log = options.log ?? (() => {
+  });
+  const doFetch = options.fetch ?? fetch;
+  const { release, source: releaseSource } = resolveRelease(options.release, env, options.cwd);
+  const endpoint = resolveEndpoint(options.endpoint, env);
+  const summary = {
+    release,
+    releaseSource,
+    endpoint,
+    dryRun: Boolean(options.dryRun),
+    uploaded: [],
+    skipped: [],
+    failed: [],
+    legacyIngester: false,
+    deletedMaps: []
+  };
+  const items = [];
+  for (const bundle of await findBundles(dir, options.files)) {
+    const prepared = await prepare(bundle, options.urlPrefix, release);
+    if ("error" in prepared) {
+      summary.failed.push({ path: bundle.path, filename: servedFilename(options.urlPrefix, bundle.path), error: prepared.error });
+    } else if (prepared.bytes > MAX_UPLOAD_BYTES) {
+      summary.failed.push({
+        path: prepared.path,
+        filename: prepared.filename,
+        error: `map is ${(prepared.bytes / 1048576).toFixed(1)} MB without sourcesContent; the ingester accepts up to 5 MB`
+      });
+    } else {
+      items.push(prepared);
+    }
+  }
+  if (options.dryRun) {
+    summary.uploaded = items.map(strip);
+    return summary;
+  }
+  const key = (options.key ?? env.AUTTER_RUNTIME_KEY ?? "").trim();
+  if (!key) throw new FatalUploadError("no ingest key: set AUTTER_RUNTIME_KEY to a server key (autter_rt_\u2026)");
+  if (key.startsWith("autter_rtc_")) {
+    throw new FatalUploadError("AUTTER_RUNTIME_KEY is a publishable client key (autter_rtc_\u2026); uploads need a server key (autter_rt_\u2026)");
+  }
+  const headers = { "content-type": "application/json", authorization: `Bearer ${key}` };
+  const skipped = /* @__PURE__ */ new Set();
+  for (let start = 0; start < items.length && !summary.legacyIngester; start += CHECK_BATCH) {
+    const batch = items.slice(start, start + CHECK_BATCH);
+    try {
+      const res = await doFetch(`${endpoint}/v1/sourcemaps/check`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          release,
+          files: batch.map((item) => ({ filename: item.filename, ...item.debugId ? { debugId: item.debugId } : {}, hash: item.hash }))
+        })
+      });
+      if (res.status === 404) {
+        summary.legacyIngester = true;
+        log(
+          "warning: this ingester predates 1.6.0, so it stores no debug ids and rejects .mjs/.cjs maps. Upgrade it: docker pull ghcr.io/autter-dev/otlp-ingester:latest"
+        );
+        break;
+      }
+      if (res.status === 401 || res.status === 403) {
+        throw new FatalUploadError(`the ingester rejected the key (${res.status}): ${(await res.text()).slice(0, 300)}`);
+      }
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const body = await res.json();
+      const present = new Set(Array.isArray(body.present) ? body.present : []);
+      batch.forEach((item, index) => {
+        if (present.has(index)) skipped.add(item);
+      });
+    } catch (err) {
+      if (err instanceof FatalUploadError) throw err;
+      log(`warning: could not check which maps the ingester already has (${err.message}); uploading all`);
+    }
+  }
+  const uploaded = [];
+  let fatal = null;
+  const uploadOne = async (item) => {
+    for (let attempt = 1; ; attempt++) {
+      if (fatal) return;
+      let status = 0;
+      let detail = "";
+      try {
+        const res = await doFetch(`${endpoint}/v1/sourcemaps`, { method: "POST", headers, body: item.body });
+        status = res.status;
+        if (res.ok) {
+          uploaded.push(item);
+          return;
+        }
+        detail = (await res.text()).slice(0, 300);
+      } catch (err) {
+        detail = err.message;
+      }
+      if (status === 401 || status === 403) {
+        fatal = new FatalUploadError(`the ingester rejected the key (${status}): ${detail}`);
+        return;
+      }
+      const retryable = status === 0 || status === 429 || status >= 500;
+      if (!retryable || attempt >= MAX_ATTEMPTS) {
+        summary.failed.push({ path: item.path, filename: item.filename, error: status ? `HTTP ${status}: ${detail}` : detail });
+        return;
+      }
+      await sleep(500 * 2 ** (attempt - 1));
+    }
+  };
+  const queue = items.filter((item) => !skipped.has(item));
+  const workers = Array.from({ length: Math.max(1, Math.min(options.concurrency ?? 8, queue.length)) }, async () => {
+    for (let item = queue.shift(); item; item = queue.shift()) await uploadOne(item);
+  });
+  await Promise.all(workers);
+  if (fatal) throw fatal;
+  const order = (a, b) => items.indexOf(a) - items.indexOf(b);
+  uploaded.sort(order);
+  if (options.deleteAfterUpload) {
+    for (const item of [...uploaded, ...skipped]) {
+      await (0, import_promises3.rm)(item.bundle.map, { force: true });
+      const code = await (0, import_promises3.readFile)(item.bundle.js, "utf8");
+      const stripped = stripSourceMappingUrl(code);
+      if (stripped !== code) await (0, import_promises3.writeFile)(item.bundle.js, stripped);
+      summary.deletedMaps.push(item.bundle.map);
+    }
+  }
+  summary.uploaded = uploaded.map(strip);
+  summary.skipped = [...skipped].sort(order).map(strip);
+  return summary;
+}
+function strip(item) {
+  const { path, filename, debugId, hash, bytes } = item;
+  return { path, filename, debugId, hash, bytes };
+}
+
+// src/build.ts
+function formatUploadSummary(summary) {
+  const lines = [];
+  const verb = summary.dryRun ? "would upload" : "uploaded";
+  for (const item of summary.uploaded) {
+    lines.push(`${verb} ${item.filename}${item.debugId ? ` (debug id ${item.debugId})` : ""}`);
+  }
+  for (const item of summary.skipped) lines.push(`skipped ${item.filename} (already uploaded)`);
+  for (const item of summary.failed) lines.push(`failed ${item.filename}: ${item.error}`);
+  lines.push(
+    `${summary.uploaded.length} ${verb}, ${summary.skipped.length} already uploaded, ${summary.failed.length} failed (release ${summary.release} from ${summary.releaseSource}, ${summary.endpoint})`
+  );
+  return lines;
+}
+async function processBuildOutput(input) {
+  const { options } = input;
+  const log = (line) => {
+    if (!options.silent) console.log(`[autter-runtime] ${line}`);
+  };
+  const result = { injected: [], upload: null };
+  try {
+    result.injected = await injectDir(input.dir, {
+      files: input.files,
+      dryRun: options.dryRun,
+      stripSourceMappingUrl: input.stripSourceMappingUrl
+    });
+    const changed = result.injected.filter((r) => r.status === "injected").length;
+    if (result.injected.length) {
+      log(`debug ids: ${changed} bundle(s) injected, ${result.injected.length - changed} already had one`);
+    }
+    for (const bad of result.injected.filter((r) => r.status === "invalid-map")) log(`skipped ${bad.path}: its map is not valid JSON`);
+    if (options.upload === false) return result;
+    const key = options.key ?? process.env.AUTTER_RUNTIME_KEY;
+    if (!key && !options.dryRun) {
+      if (result.injected.length) log("AUTTER_RUNTIME_KEY is not set: source maps were not uploaded");
+      return result;
+    }
+    if (!result.injected.some((r) => r.status !== "invalid-map")) return result;
+    result.upload = await uploadDir(input.dir, {
+      files: input.files,
+      release: options.release,
+      urlPrefix: options.urlPrefix ?? input.urlPrefix,
+      endpoint: options.endpoint,
+      key,
+      dryRun: options.dryRun,
+      concurrency: options.concurrency,
+      deleteAfterUpload: options.deleteAfterUpload ?? input.deleteAfterUpload,
+      log
+    });
+    for (const line of formatUploadSummary(result.upload)) log(line);
+    if (result.upload.failed.length && options.failOnError) {
+      throw new Error(`${result.upload.failed.length} source map upload(s) failed`);
+    }
+  } catch (err) {
+    const message = `source maps: ${err instanceof Error ? err.message : String(err)}`;
+    if (options.failOnError) throw new Error(`[autter-runtime] ${message}`);
+    if (!options.silent) console.warn(`[autter-runtime] ${message}`);
+  }
+  return result;
+}
+
+// src/vite.ts
+function autterSourceMaps(options = {}) {
+  let isVite = false;
+  let enabledMaps = false;
+  let ssr = false;
+  let base = "/";
+  return {
+    name: "autter-runtime-sourcemaps",
+    apply: "build",
+    enforce: "post",
+    config(config) {
+      isVite = true;
+      const current = config.build?.sourcemap;
+      if (current === void 0 || current === false) {
+        enabledMaps = true;
+        return { build: { sourcemap: "hidden" } };
+      }
+      return void 0;
+    },
+    configResolved(config) {
+      ssr = Boolean(config.build?.ssr);
+      if (config.base && /^(\/|[a-z][\w+.-]*:\/\/)/i.test(config.base)) base = config.base;
+      if (config.build?.sourcemap === "inline" && !options.silent) {
+        console.warn('[autter-runtime] build.sourcemap is "inline": there are no map files to upload; use "hidden"');
+      }
+    },
+    outputOptions(output) {
+      if (isVite || output.sourcemap !== void 0 && output.sourcemap !== false) return null;
+      enabledMaps = true;
+      return { ...output, sourcemap: "hidden" };
+    },
+    async writeBundle(output, bundle) {
+      const environment = this?.environment;
+      if (ssr || environment?.config?.consumer === "server") return;
+      const dir = output.dir ?? (output.file ? (0, import_node_path2.dirname)(output.file) : void 0);
+      if (!dir) return;
+      const files = Object.values(bundle).filter((file) => file.type === "chunk").map((file) => (0, import_node_path2.resolve)(dir, file.fileName));
+      await processBuildOutput({
+        dir,
+        files,
+        urlPrefix: base,
+        options,
+        deleteAfterUpload: enabledMaps
+      });
+    }
+  };
+}
+var vite_default = autterSourceMaps;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  autterSourceMaps
+});

package/dist/vite.d.cts

@@ -0,0 +1,54 @@
+import { A as AutterSourceMapsOptions } from './build-BXFh_jbP.cjs';
+
+type SourcemapSetting = boolean | "inline" | "hidden";
+/** The parts of Vite's / Rollup's types this plugin touches (structural, so
+ * neither bundler is a dependency). */
+interface UserConfigLike {
+    build?: {
+        sourcemap?: SourcemapSetting;
+        ssr?: boolean | string;
+    };
+}
+interface ResolvedConfigLike {
+    base?: string;
+    build?: {
+        sourcemap?: SourcemapSetting;
+        ssr?: boolean | string;
+    };
+}
+interface OutputOptionsLike {
+    dir?: string;
+    file?: string;
+    sourcemap?: SourcemapSetting;
+}
+interface OutputFileLike {
+    type: "chunk" | "asset";
+    fileName: string;
+}
+interface AutterSourceMapsPlugin {
+    name: string;
+    apply: "build";
+    enforce: "post";
+    config(config: UserConfigLike): {
+        build: {
+            sourcemap: "hidden";
+        };
+    } | undefined;
+    configResolved(config: ResolvedConfigLike): void;
+    outputOptions(options: OutputOptionsLike): OutputOptionsLike | null;
+    writeBundle(this: unknown, options: OutputOptionsLike, bundle: Record<string, OutputFileLike>): Promise<void>;
+}
+/**
+ * Vite and Rollup plugin: turns on hidden source maps, gives every emitted
+ * chunk a debug id after the bundle is written, and uploads the maps when
+ * AUTTER_RUNTIME_KEY (or `key`) is set.
+ *
+ * ```ts
+ * // vite.config.ts
+ * import { autterSourceMaps } from "@autter/runtime-cli/vite";
+ * export default defineConfig({ plugins: [autterSourceMaps()] });
+ * ```
+ */
+declare function autterSourceMaps(options?: AutterSourceMapsOptions): AutterSourceMapsPlugin;
+
+export { AutterSourceMapsOptions, type AutterSourceMapsPlugin, autterSourceMaps, autterSourceMaps as default };

package/dist/vite.d.ts

@@ -0,0 +1,54 @@
+import { A as AutterSourceMapsOptions } from './build-BXFh_jbP.js';
+
+type SourcemapSetting = boolean | "inline" | "hidden";
+/** The parts of Vite's / Rollup's types this plugin touches (structural, so
+ * neither bundler is a dependency). */
+interface UserConfigLike {
+    build?: {
+        sourcemap?: SourcemapSetting;
+        ssr?: boolean | string;
+    };
+}
+interface ResolvedConfigLike {
+    base?: string;
+    build?: {
+        sourcemap?: SourcemapSetting;
+        ssr?: boolean | string;
+    };
+}
+interface OutputOptionsLike {
+    dir?: string;
+    file?: string;
+    sourcemap?: SourcemapSetting;
+}
+interface OutputFileLike {
+    type: "chunk" | "asset";
+    fileName: string;
+}
+interface AutterSourceMapsPlugin {
+    name: string;
+    apply: "build";
+    enforce: "post";
+    config(config: UserConfigLike): {
+        build: {
+            sourcemap: "hidden";
+        };
+    } | undefined;
+    configResolved(config: ResolvedConfigLike): void;
+    outputOptions(options: OutputOptionsLike): OutputOptionsLike | null;
+    writeBundle(this: unknown, options: OutputOptionsLike, bundle: Record<string, OutputFileLike>): Promise<void>;
+}
+/**
+ * Vite and Rollup plugin: turns on hidden source maps, gives every emitted
+ * chunk a debug id after the bundle is written, and uploads the maps when
+ * AUTTER_RUNTIME_KEY (or `key`) is set.
+ *
+ * ```ts
+ * // vite.config.ts
+ * import { autterSourceMaps } from "@autter/runtime-cli/vite";
+ * export default defineConfig({ plugins: [autterSourceMaps()] });
+ * ```
+ */
+declare function autterSourceMaps(options?: AutterSourceMapsOptions): AutterSourceMapsPlugin;
+
+export { AutterSourceMapsOptions, type AutterSourceMapsPlugin, autterSourceMaps, autterSourceMaps as default };