@logbrew/sdk 0.1.2 → 0.1.4

package/support-ticket.cjs

@@ -0,0 +1,175 @@
+const SUPPORT_TICKET_SOURCES = new Set(["cli", "sdk", "website", "docs", "mobile"]);
+const SUPPORT_TICKET_CATEGORIES = new Set([
+  "sdk_install_failure",
+  "ingest_failure",
+  "auth_failure",
+  "project_setup",
+  "dashboard_issue",
+  "docs_confusion",
+  "cli_issue",
+  "mobile_issue",
+  "billing_question",
+  "other"
+]);
+const SUPPORT_DIAGNOSTICS_MAX_DEPTH = 5;
+const SUPPORT_DIAGNOSTICS_MAX_ARRAY_LENGTH = 20;
+const SUPPORT_DIAGNOSTICS_MAX_STRING_LENGTH = 500;
+
+function buildCreateSupportTicketDraft({ SdkError, requireAllowedValue, requireNonEmpty, requireTraceId }) {
+  return function createSupportTicketDraft(input) {
+    if (!input || Array.isArray(input) || typeof input !== "object") {
+      throw new SdkError("validation_error", "support ticket draft input must be an object");
+    }
+
+    requireAllowedValue("support ticket source", input.source, SUPPORT_TICKET_SOURCES);
+    requireAllowedValue("support ticket category", input.category, SUPPORT_TICKET_CATEGORIES);
+    const draft = {
+      source: input.source,
+      category: input.category,
+      title: requiredSupportString(requireNonEmpty, "support ticket title", input.title),
+      description: requiredSupportString(requireNonEmpty, "support ticket description", input.description)
+    };
+
+    addOptionalSupportString(draft, "project_id", "support ticket projectId", input.projectId, requireNonEmpty);
+    addOptionalSupportString(draft, "environment", "support ticket environment", input.environment, requireNonEmpty);
+    addOptionalSupportString(draft, "runtime", "support ticket runtime", input.runtime, requireNonEmpty);
+    addOptionalSupportString(draft, "framework", "support ticket framework", input.framework, requireNonEmpty);
+    addOptionalSupportString(draft, "sdk_package", "support ticket sdkPackage", input.sdkPackage, requireNonEmpty);
+    addOptionalSupportString(draft, "sdk_version", "support ticket sdkVersion", input.sdkVersion, requireNonEmpty);
+    addOptionalSupportString(draft, "release", "support ticket release", input.release, requireNonEmpty);
+    if (input.traceId !== undefined) {
+      requireTraceId(input.traceId);
+      draft.trace_id = input.traceId.toLowerCase();
+    }
+    addOptionalSupportString(draft, "event_id", "support ticket eventId", input.eventId, requireNonEmpty);
+    if (input.diagnostics !== undefined) {
+      draft.diagnostics = sanitizeSupportDiagnostics(input.diagnostics, SdkError);
+    }
+
+    return draft;
+  };
+}
+
+function requiredSupportString(requireNonEmpty, label, value) {
+  requireNonEmpty(label, value);
+  return value.trim();
+}
+
+function addOptionalSupportString(target, key, label, value, requireNonEmpty) {
+  if (value === undefined) {
+    return;
+  }
+  target[key] = requiredSupportString(requireNonEmpty, label, value);
+}
+
+function sanitizeSupportDiagnostics(diagnostics, SdkError) {
+  if (!diagnostics || Array.isArray(diagnostics) || typeof diagnostics !== "object") {
+    throw new SdkError("validation_error", "support ticket diagnostics must be an object");
+  }
+  return sanitizeSupportDiagnosticValue(diagnostics, 0, "");
+}
+
+function sanitizeSupportDiagnosticValue(value, depth, key) {
+  if (isSensitiveSupportKey(key)) {
+    return "[redacted]";
+  }
+  if (value instanceof Error) {
+    return { name: value.name || "Error" };
+  }
+  if (value === null || typeof value === "number" && Number.isFinite(value) || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return sanitizeSupportDiagnosticString(value);
+  }
+  if (Array.isArray(value)) {
+    if (depth >= SUPPORT_DIAGNOSTICS_MAX_DEPTH) {
+      return "[max-depth]";
+    }
+    return value
+      .slice(0, SUPPORT_DIAGNOSTICS_MAX_ARRAY_LENGTH)
+      .map((item) => sanitizeSupportDiagnosticValue(item, depth + 1, ""));
+  }
+  if (value && typeof value === "object") {
+    if (depth >= SUPPORT_DIAGNOSTICS_MAX_DEPTH) {
+      return "[max-depth]";
+    }
+    const safe = {};
+    for (const [childKey, childValue] of Object.entries(value)) {
+      const sanitized = sanitizeSupportDiagnosticValue(childValue, depth + 1, childKey);
+      if (sanitized !== undefined) {
+        safe[childKey] = sanitized;
+      }
+    }
+    return safe;
+  }
+  return undefined;
+}
+
+function isSensitiveSupportKey(key) {
+  if (typeof key !== "string" || key === "") {
+    return false;
+  }
+  const normalized = key.replace(/[^a-z0-9]/giu, "").toLowerCase();
+  return [
+    "apikey",
+    "auth",
+    "authorization",
+    "authtoken",
+    "bearer",
+    "clientsecret",
+    "connectionstring",
+    "cookie",
+    "credential",
+    "dsn",
+    "email",
+    "password",
+    "passwd",
+    "privatekey",
+    "refreshtoken",
+    "secret",
+    "session",
+    "setcookie",
+    "token"
+  ].some((needle) => normalized.includes(needle));
+}
+
+function sanitizeSupportDiagnosticString(value) {
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return "";
+  }
+  if (isSensitiveSupportString(trimmed)) {
+    return "[redacted]";
+  }
+  const pathRedacted = redactLocalPath(trimmed);
+  const urlRedacted = redactUrl(pathRedacted);
+  return urlRedacted.length > SUPPORT_DIAGNOSTICS_MAX_STRING_LENGTH
+    ? `${urlRedacted.slice(0, SUPPORT_DIAGNOSTICS_MAX_STRING_LENGTH)}...`
+    : urlRedacted;
+}
+
+function isSensitiveSupportString(value) {
+  return /(?:authorization|api[_-]?key|token|secret|password|passwd|cookie)\s*[:=]/iu.test(value)
+    || /\bBearer\s+[A-Za-z0-9._~+/-]+=*/iu.test(value)
+    || /\blbw_(?:ingest|client|api)_[A-Za-z0-9._-]+/iu.test(value)
+    || /\b(?:github_pat|ghp|gho|npm|pypi|sk_live|sk_test|xox[baprs]|AKIA)[A-Za-z0-9._-]+/u.test(value);
+}
+
+function redactLocalPath(value) {
+  if (/^(?:\/Users\/|\/home\/|\/var\/folders\/|[A-Za-z]:\\)/u.test(value)) {
+    return "[redacted-path]";
+  }
+  return value;
+}
+
+function redactUrl(value) {
+  try {
+    const url = new URL(value);
+    return `[redacted-url]${url.pathname || "/"}`;
+  } catch {
+    return value.split(/[?#]/u)[0];
+  }
+}
+
+module.exports = { buildCreateSupportTicketDraft };

package/trace-context.cjs

@@ -0,0 +1,217 @@
+const MAX_TRACESTATE_ENTRIES = 32;
+const MAX_TRACESTATE_LENGTH = 512;
+const MAX_BAGGAGE_ENTRIES = 64;
+const MAX_BAGGAGE_LENGTH = 8192;
+const TRACESTATE_SIMPLE_KEY_PATTERN = /^[a-z0-9][a-z0-9_\-*/]{0,255}$/u;
+const TRACESTATE_TENANT_KEY_PATTERN = /^[a-z0-9][a-z0-9_\-*/]{0,240}@[a-z][a-z0-9_\-*/]{0,13}$/u;
+const TRACESTATE_VALUE_PATTERN = /^[\x20-\x2B\x2D-\x3C\x3E-\x7E]*[\x21-\x2B\x2D-\x3C\x3E-\x7E]$/u;
+const BAGGAGE_KEY_PATTERN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/u;
+const BAGGAGE_PROPERTY_PATTERN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+(?:=[!#$%&'*+\-.^_`|~0-9A-Za-z]*)?$/u;
+
+function buildTraceContextHelpers({ SdkError, createTraceparent }) {
+  function parseTracestate(tracestate) {
+    if (typeof tracestate !== "string" || tracestate.trim() === "") {
+      throw new SdkError("validation_error", "tracestate must be non-empty");
+    }
+    return normalizeTracestateEntries(
+      tracestate.split(",")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry !== "")
+        .map((entry) => {
+          const separator = entry.indexOf("=");
+          if (separator <= 0) {
+            throw new SdkError("validation_error", "tracestate entries must use key=value");
+          }
+          return {
+            key: entry.slice(0, separator).trim(),
+            value: entry.slice(separator + 1).trim()
+          };
+        })
+    );
+  }
+
+  function createTracestate(entries) {
+    return serializeTracestate(normalizeTracestateEntries(entries));
+  }
+
+  function parseBaggage(baggage) {
+    if (typeof baggage !== "string" || baggage.trim() === "") {
+      throw new SdkError("validation_error", "baggage must be non-empty");
+    }
+    return normalizeBaggageEntries(
+      baggage.split(",")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry !== "")
+        .map((entry) => {
+          const [pair, ...rawProperties] = entry.split(";");
+          const separator = pair.indexOf("=");
+          if (separator <= 0) {
+            throw new SdkError("validation_error", "baggage entries must use key=value");
+          }
+          return {
+            key: pair.slice(0, separator).trim(),
+            value: decodeBaggageValue(pair.slice(separator + 1).trim()),
+            properties: rawProperties.map((property) => property.trim()).filter((property) => property !== "")
+          };
+        })
+    );
+  }
+
+  function createBaggage(entries) {
+    return serializeBaggage(normalizeBaggageEntries(entries));
+  }
+
+  function createTraceContextHeaders(input) {
+    if (!input || Array.isArray(input) || typeof input !== "object") {
+      throw new SdkError("validation_error", "trace context input must be an object");
+    }
+    const headers = { traceparent: createTraceparent(input) };
+    if (input.tracestate !== undefined) {
+      const tracestate = typeof input.tracestate === "string"
+        ? createTracestate(parseTracestate(input.tracestate))
+        : createTracestate(input.tracestate);
+      if (tracestate !== "") {
+        headers.tracestate = tracestate;
+      }
+    }
+    if (input.baggage !== undefined) {
+      const baggage = typeof input.baggage === "string"
+        ? createBaggage(parseBaggage(input.baggage))
+        : createBaggage(input.baggage);
+      if (baggage !== "") {
+        headers.baggage = baggage;
+      }
+    }
+    return headers;
+  }
+
+  function normalizeTracestateEntries(entries) {
+    if (!Array.isArray(entries)) {
+      throw new SdkError("validation_error", "tracestate entries must be an array");
+    }
+    if (entries.length > MAX_TRACESTATE_ENTRIES) {
+      throw new SdkError("validation_error", `tracestate must contain at most ${MAX_TRACESTATE_ENTRIES} entries`);
+    }
+    const seenKeys = new Set();
+    const normalized = entries.map((entry) => {
+      if (!entry || Array.isArray(entry) || typeof entry !== "object") {
+        throw new SdkError("validation_error", "tracestate entry must be an object");
+      }
+      const key = validateTracestateKey(entry.key);
+      if (seenKeys.has(key)) {
+        throw new SdkError("validation_error", "tracestate keys must be unique");
+      }
+      seenKeys.add(key);
+      return {
+        key,
+        value: validateTracestateValue(entry.value)
+      };
+    });
+    const serialized = serializeTracestate(normalized);
+    if (serialized.length > MAX_TRACESTATE_LENGTH) {
+      throw new SdkError("validation_error", `tracestate must be at most ${MAX_TRACESTATE_LENGTH} characters`);
+    }
+    return normalized;
+  }
+
+  function normalizeBaggageEntries(entries) {
+    if (!Array.isArray(entries)) {
+      throw new SdkError("validation_error", "baggage entries must be an array");
+    }
+    if (entries.length > MAX_BAGGAGE_ENTRIES) {
+      throw new SdkError("validation_error", `baggage must contain at most ${MAX_BAGGAGE_ENTRIES} entries`);
+    }
+    const normalized = entries.map((entry) => {
+      if (!entry || Array.isArray(entry) || typeof entry !== "object") {
+        throw new SdkError("validation_error", "baggage entry must be an object");
+      }
+      return {
+        key: validateBaggageKey(entry.key),
+        value: validateBaggageValue(entry.value),
+        ...normalizeBaggageProperties(entry.properties)
+      };
+    });
+    const serialized = serializeBaggage(normalized);
+    if (serialized.length > MAX_BAGGAGE_LENGTH) {
+      throw new SdkError("validation_error", `baggage must be at most ${MAX_BAGGAGE_LENGTH} characters`);
+    }
+    return normalized;
+  }
+
+  function validateTracestateKey(key) {
+    if (typeof key !== "string" || key.trim() === "") {
+      throw new SdkError("validation_error", "tracestate key must be non-empty");
+    }
+    const normalized = key.trim();
+    if (!TRACESTATE_SIMPLE_KEY_PATTERN.test(normalized) && !TRACESTATE_TENANT_KEY_PATTERN.test(normalized)) {
+      throw new SdkError("validation_error", "tracestate key must be lowercase W3C tracestate key");
+    }
+    return normalized;
+  }
+
+  function validateTracestateValue(value) {
+    if (typeof value !== "string" || value === "" || value.length > 256 || !TRACESTATE_VALUE_PATTERN.test(value)) {
+      throw new SdkError("validation_error", "tracestate value must be printable ASCII without comma or equals");
+    }
+    return value;
+  }
+
+  function validateBaggageKey(key) {
+    if (typeof key !== "string" || !BAGGAGE_KEY_PATTERN.test(key)) {
+      throw new SdkError("validation_error", "baggage key must use RFC header-name characters");
+    }
+    return key;
+  }
+
+  function validateBaggageValue(value) {
+    if (typeof value !== "string") {
+      throw new SdkError("validation_error", "baggage value must be a string");
+    }
+    return value;
+  }
+
+  function normalizeBaggageProperties(properties) {
+    if (properties === undefined) {
+      return {};
+    }
+    if (!Array.isArray(properties)) {
+      throw new SdkError("validation_error", "baggage properties must be an array");
+    }
+    const safeProperties = properties.map((property) => {
+      if (typeof property !== "string" || !BAGGAGE_PROPERTY_PATTERN.test(property)) {
+        throw new SdkError("validation_error", "baggage property must use RFC header-name characters");
+      }
+      return property;
+    });
+    return safeProperties.length > 0 ? { properties: safeProperties } : {};
+  }
+
+  function decodeBaggageValue(value) {
+    try {
+      return decodeURIComponent(value);
+    } catch {
+      throw new SdkError("validation_error", "baggage value must use valid percent encoding");
+    }
+  }
+
+  return {
+    createBaggage,
+    createTraceContextHeaders,
+    createTracestate,
+    parseBaggage,
+    parseTracestate
+  };
+}
+
+function serializeTracestate(entries) {
+  return entries.map((entry) => `${entry.key}=${entry.value}`).join(",");
+}
+
+function serializeBaggage(entries) {
+  return entries.map((entry) => {
+    const properties = entry.properties ? `;${entry.properties.join(";")}` : "";
+    return `${entry.key}=${encodeURIComponent(entry.value)}${properties}`;
+  }).join(",");
+}
+
+module.exports = { buildTraceContextHelpers };

package/vite-release-artifacts.cjs

@@ -0,0 +1,152 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const {
+  createReleaseArtifactUploadArgs,
+  formatReleaseArtifactUploadSummary,
+  normalizeReleaseArtifactProjectId,
+  normalizeReleaseArtifactUploadOptions,
+  runReleaseArtifactCli,
+} = require("./release-artifacts-build.cjs");
+
+const PACKAGE_DIR = path.dirname(require.resolve("./package.json"));
+const CLI_PATH = path.join(PACKAGE_DIR, "release-artifacts.js");
+const DEFAULT_MANIFEST_NAME = "logbrew-release-artifacts.json";
+
+function requiredString(options, name) {
+  const value = options?.[name];
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`LogBrew Vite release-artifact plugin requires ${name}`);
+  }
+  return value.trim();
+}
+
+function optionalString(options, name) {
+  const value = options?.[name];
+  if (value === undefined || value === null) {
+    return null;
+  }
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`LogBrew Vite release-artifact plugin option ${name} must be a non-empty string`);
+  }
+  return value.trim();
+}
+
+function normalizeStringArray(value, name) {
+  if (value === undefined || value === null) {
+    return [];
+  }
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.trim() === "")) {
+    throw new Error(`LogBrew Vite release-artifact plugin option ${name} must be an array of non-empty strings`);
+  }
+  return value.map((item) => item.trim());
+}
+
+function resolvePathFromRoot(root, value) {
+  return path.isAbsolute(value) ? path.resolve(value) : path.resolve(root, value);
+}
+
+function resolveBuildDir(root, outDir, explicitBuildDir) {
+  if (explicitBuildDir) {
+    return resolvePathFromRoot(root, explicitBuildDir);
+  }
+  return resolvePathFromRoot(root, outDir || "dist");
+}
+
+function resolveManifestPath(root, buildDir, explicitManifestPath) {
+  if (explicitManifestPath) {
+    return resolvePathFromRoot(root, explicitManifestPath);
+  }
+  return path.join(buildDir, DEFAULT_MANIFEST_NAME);
+}
+
+function createLogBrewViteReleaseArtifactsPlugin(options) {
+  const release = requiredString(options, "release");
+  const environment = requiredString(options, "environment");
+  const service = requiredString(options, "service");
+  const projectId = normalizeReleaseArtifactProjectId(options?.projectId, "Vite");
+  const minifiedPathPrefix = requiredString(options, "minifiedPathPrefix");
+  const repositoryUrl = optionalString(options, "repositoryUrl");
+  const commitSha = optionalString(options, "commitSha");
+  const explicitBuildDir = optionalString(options, "buildDir");
+  const explicitManifestPath = optionalString(options, "manifestPath");
+  const stripSourcesContent = options?.stripSourcesContent !== false;
+  const enableSourceMaps = options?.enableSourceMaps !== false;
+  const userSourcePrefixes = normalizeStringArray(options?.stripSourcePrefix, "stripSourcePrefix");
+  const upload = normalizeReleaseArtifactUploadOptions(options?.upload, { integration: "Vite", projectId });
+  let viteRoot = process.cwd();
+  let viteOutDir = "dist";
+  let viteLogger = null;
+
+  return {
+    name: "logbrew-vite-release-artifacts",
+    apply: "build",
+    enforce: "post",
+    config(config = {}) {
+      if (!enableSourceMaps || config.build?.sourcemap !== undefined) {
+        return null;
+      }
+      return { build: { sourcemap: "hidden" } };
+    },
+    configResolved(config) {
+      viteRoot = config?.root ? path.resolve(config.root) : process.cwd();
+      viteOutDir = config?.build?.outDir || "dist";
+      viteLogger = config?.logger && typeof config.logger.info === "function" ? config.logger : null;
+    },
+    async closeBundle() {
+      const buildDir = resolveBuildDir(viteRoot, viteOutDir, explicitBuildDir);
+      const manifestPath = resolveManifestPath(viteRoot, buildDir, explicitManifestPath);
+      const sourcePrefixes = userSourcePrefixes.length > 0 ? userSourcePrefixes : [viteRoot];
+      const prepareArgs = ["--build-dir", buildDir, "--write"];
+      if (stripSourcesContent) {
+        prepareArgs.push("--strip-sources-content");
+      }
+      for (const prefix of sourcePrefixes) {
+        prepareArgs.push("--strip-source-prefix", prefix);
+      }
+
+      runReleaseArtifactCli(CLI_PATH, "prepare-js", prepareArgs);
+
+      const manifestArgs = [
+        "--build-dir",
+        buildDir,
+        "--release",
+        release,
+        "--environment",
+        environment,
+        "--service",
+        service,
+        "--minified-path-prefix",
+        minifiedPathPrefix
+      ];
+      if (repositoryUrl) {
+        manifestArgs.push("--repository-url", repositoryUrl);
+      }
+      if (commitSha) {
+        manifestArgs.push("--commit-sha", commitSha);
+      }
+      if (projectId) {
+        manifestArgs.push("--project-id", projectId);
+      }
+
+      const { stdout } = runReleaseArtifactCli(CLI_PATH, "manifest-js", manifestArgs);
+      fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+      fs.writeFileSync(manifestPath, stdout, "utf8");
+      if (upload) {
+        const { report } = runReleaseArtifactCli(
+          CLI_PATH,
+          "upload-js",
+          createReleaseArtifactUploadArgs(buildDir, manifestPath, upload)
+        );
+        viteLogger?.info(formatReleaseArtifactUploadSummary(report));
+      }
+    }
+  };
+}
+
+module.exports = {
+  createLogBrewViteReleaseArtifactsPlugin,
+  default: createLogBrewViteReleaseArtifactsPlugin
+};

package/vite-release-artifacts.d.cts

@@ -0,0 +1,44 @@
+export interface LogBrewViteReleaseArtifactUploadOptions {
+  endpoint: string;
+  allowHostedUpload?: boolean;
+  tokenEnv?: string;
+  dryRun?: boolean;
+  maxRetries?: number;
+  retryDelay?: number;
+  timeout?: number;
+}
+
+export interface LogBrewViteReleaseArtifactsPluginOptions {
+  release: string;
+  environment: string;
+  service: string;
+  projectId?: string;
+  minifiedPathPrefix: string;
+  buildDir?: string;
+  manifestPath?: string;
+  repositoryUrl?: string;
+  commitSha?: string;
+  stripSourcesContent?: boolean;
+  stripSourcePrefix?: string[];
+  enableSourceMaps?: boolean;
+  upload?: LogBrewViteReleaseArtifactUploadOptions;
+}
+
+export interface LogBrewViteReleaseArtifactsPlugin {
+  name: "logbrew-vite-release-artifacts";
+  apply: "build";
+  enforce: "post";
+  config(config?: { build?: { sourcemap?: unknown } }): null | { build: { sourcemap: "hidden" } };
+  configResolved(config: {
+    root?: string;
+    build?: { outDir?: string };
+    logger?: { info(message: string): void };
+  }): void;
+  closeBundle(): Promise<void>;
+}
+
+export declare function createLogBrewViteReleaseArtifactsPlugin(
+  options: LogBrewViteReleaseArtifactsPluginOptions
+): LogBrewViteReleaseArtifactsPlugin;
+
+export default createLogBrewViteReleaseArtifactsPlugin;

package/vite-release-artifacts.d.ts

@@ -0,0 +1,44 @@
+export interface LogBrewViteReleaseArtifactUploadOptions {
+  endpoint: string;
+  allowHostedUpload?: boolean;
+  tokenEnv?: string;
+  dryRun?: boolean;
+  maxRetries?: number;
+  retryDelay?: number;
+  timeout?: number;
+}
+
+export interface LogBrewViteReleaseArtifactsPluginOptions {
+  release: string;
+  environment: string;
+  service: string;
+  projectId?: string;
+  minifiedPathPrefix: string;
+  buildDir?: string;
+  manifestPath?: string;
+  repositoryUrl?: string;
+  commitSha?: string;
+  stripSourcesContent?: boolean;
+  stripSourcePrefix?: string[];
+  enableSourceMaps?: boolean;
+  upload?: LogBrewViteReleaseArtifactUploadOptions;
+}
+
+export interface LogBrewViteReleaseArtifactsPlugin {
+  name: "logbrew-vite-release-artifacts";
+  apply: "build";
+  enforce: "post";
+  config(config?: { build?: { sourcemap?: unknown } }): null | { build: { sourcemap: "hidden" } };
+  configResolved(config: {
+    root?: string;
+    build?: { outDir?: string };
+    logger?: { info(message: string): void };
+  }): void;
+  closeBundle(): Promise<void>;
+}
+
+export declare function createLogBrewViteReleaseArtifactsPlugin(
+  options: LogBrewViteReleaseArtifactsPluginOptions
+): LogBrewViteReleaseArtifactsPlugin;
+
+export default createLogBrewViteReleaseArtifactsPlugin;

package/vite-release-artifacts.js

@@ -0,0 +1,6 @@
+import viteReleaseArtifacts from "./vite-release-artifacts.cjs";
+
+export const createLogBrewViteReleaseArtifactsPlugin =
+  viteReleaseArtifacts.createLogBrewViteReleaseArtifactsPlugin;
+
+export default createLogBrewViteReleaseArtifactsPlugin;