@logbrew/react-native 0.1.0 → 0.1.2

package/native-bridge.js

@@ -0,0 +1,125 @@
+import { SdkError } from "@logbrew/sdk";
+import {
+  getActiveLogBrewTrace,
+  getReactNativeTraceMetadata
+} from "./index.js";
+
+const DEFAULT_SCOPE_SOURCE = "react-native.native_bridge";
+const RESERVED_TRACE_METADATA_KEYS = new Set([
+  "parentSpanId",
+  "spanId",
+  "traceFlags",
+  "traceId",
+  "traceSampled",
+  "traceparent"
+]);
+
+export function createLogBrewNativeBridgeScope({
+  logger,
+  metadata = {},
+  screen,
+  sessionId,
+  source = DEFAULT_SCOPE_SOURCE,
+  trace = getActiveLogBrewTrace()
+} = {}) {
+  const traceMetadata = getReactNativeTraceMetadata(trace);
+  return {
+    trace: Object.keys(traceMetadata).length === 0 ? undefined : {
+      parentSpanId: traceMetadata.parentSpanId,
+      spanId: traceMetadata.spanId,
+      traceFlags: traceMetadata.traceFlags,
+      traceId: traceMetadata.traceId,
+      traceSampled: traceMetadata.traceSampled
+    },
+    metadata: compactMetadata({
+      ...metadata,
+      logger,
+      screen,
+      sessionId,
+      source
+    })
+  };
+}
+
+export function syncLogBrewNativeBridgeScope(nativeBridge, options = {}) {
+  const payload = createLogBrewNativeBridgeScope(options);
+  bridgeSync(nativeBridge)(payload);
+  return payload;
+}
+
+export function clearLogBrewNativeBridgeScope(nativeBridge) {
+  bridgeClear(nativeBridge)();
+}
+
+export function withLogBrewNativeBridgeScope(nativeBridge, options, callback) {
+  const resolvedOptions = typeof options === "function" ? {} : options ?? {};
+  const resolvedCallback = typeof options === "function" ? options : callback;
+  if (typeof resolvedCallback !== "function") {
+    throw new SdkError("configuration_error", "withLogBrewNativeBridgeScope requires a callback");
+  }
+
+  const payload = syncLogBrewNativeBridgeScope(nativeBridge, resolvedOptions);
+  try {
+    const result = resolvedCallback(payload);
+    if (result && typeof result.then === "function") {
+      return Promise.resolve(result).finally(() => clearLogBrewNativeBridgeScope(nativeBridge));
+    }
+    clearLogBrewNativeBridgeScope(nativeBridge);
+    return result;
+  } catch (error) {
+    clearLogBrewNativeBridgeScope(nativeBridge);
+    throw error;
+  }
+}
+
+function bridgeSync(nativeBridge) {
+  if (typeof nativeBridge === "function") {
+    return nativeBridge;
+  }
+  if (nativeBridge && typeof nativeBridge.setLogBrewScope === "function") {
+    return nativeBridge.setLogBrewScope.bind(nativeBridge);
+  }
+  if (nativeBridge && typeof nativeBridge.syncLogBrewScope === "function") {
+    return nativeBridge.syncLogBrewScope.bind(nativeBridge);
+  }
+  throw new SdkError(
+    "configuration_error",
+    "LogBrew native bridge scope sync requires a function, setLogBrewScope, or syncLogBrewScope"
+  );
+}
+
+function bridgeClear(nativeBridge) {
+  if (nativeBridge && typeof nativeBridge.clearLogBrewScope === "function") {
+    return nativeBridge.clearLogBrewScope.bind(nativeBridge);
+  }
+  if (nativeBridge && typeof nativeBridge.clearLogBrewTraceContext === "function") {
+    return nativeBridge.clearLogBrewTraceContext.bind(nativeBridge);
+  }
+  if (typeof nativeBridge === "function") {
+    return () => nativeBridge(undefined);
+  }
+  return () => {};
+}
+
+function compactMetadata(metadata) {
+  const compacted = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    if (value === undefined) {
+      continue;
+    }
+    if (RESERVED_TRACE_METADATA_KEYS.has(key)) {
+      continue;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+      compacted[key] = value;
+    }
+  }
+  return compacted;
+}
+
+export default {
+  clearLogBrewNativeBridgeScope,
+  createLogBrewNativeBridgeScope,
+  syncLogBrewNativeBridgeScope,
+  withLogBrewNativeBridgeScope
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@logbrew/react-native",
-  "version": "0.1.0",
-  "description": "React Native helpers for the public LogBrew JavaScript SDK.",
+  "version": "0.1.2",
+  "description": "React Native screen, error, trace, action, and network timeline helpers for LogBrew.",
   "type": "module",
   "main": "./index.cjs",
   "module": "./index.js",
@@ -19,6 +19,94 @@
         "default": "./index.cjs"
       },
       "default": "./index.js"
+    },
+    "./lifecycle": {
+      "import": {
+        "types": "./lifecycle.d.ts",
+        "default": "./lifecycle.js"
+      },
+      "require": {
+        "types": "./lifecycle.d.cts",
+        "default": "./lifecycle.cjs"
+      },
+      "default": "./lifecycle.js"
+    },
+    "./global-errors": {
+      "import": {
+        "types": "./global-errors.d.ts",
+        "default": "./global-errors.js"
+      },
+      "require": {
+        "types": "./global-errors.d.cts",
+        "default": "./global-errors.cjs"
+      },
+      "default": "./global-errors.js"
+    },
+    "./instrumentation": {
+      "import": {
+        "types": "./instrumentation.d.ts",
+        "default": "./instrumentation.js"
+      },
+      "require": {
+        "types": "./instrumentation.d.cts",
+        "default": "./instrumentation.cjs"
+      },
+      "default": "./instrumentation.js"
+    },
+    "./native-bridge": {
+      "import": {
+        "types": "./native-bridge.d.ts",
+        "default": "./native-bridge.js"
+      },
+      "require": {
+        "types": "./native-bridge.d.cts",
+        "default": "./native-bridge.cjs"
+      },
+      "default": "./native-bridge.js"
+    },
+    "./apollo": {
+      "import": {
+        "types": "./apollo.d.ts",
+        "default": "./apollo.js"
+      },
+      "require": {
+        "types": "./apollo.d.cts",
+        "default": "./apollo.cjs"
+      },
+      "default": "./apollo.js"
+    },
+    "./resource-fetch": {
+      "import": {
+        "types": "./resource-fetch.d.ts",
+        "default": "./resource-fetch.js"
+      },
+      "require": {
+        "types": "./resource-fetch.d.cts",
+        "default": "./resource-fetch.cjs"
+      },
+      "default": "./resource-fetch.js"
+    },
+    "./release-artifacts": {
+      "import": {
+        "types": "./release-artifacts.d.ts",
+        "default": "./release-artifacts.js"
+      },
+      "require": {
+        "types": "./release-artifacts.d.cts",
+        "default": "./release-artifacts.cjs"
+      },
+      "default": "./release-artifacts.js"
+    },
+    "./metro": {
+      "import": {
+        "types": "./metro.d.ts",
+        "default": "./metro.js"
+      },
+      "require": {
+        "types": "./metro.d.cts",
+        "default": "./metro.cjs"
+      },
+      "default": "./metro.js"
     }
   },
   "files": [
@@ -27,6 +115,40 @@
     "index.native.js",
     "index.d.ts",
     "index.d.cts",
+    "apollo.cjs",
+    "apollo.js",
+    "apollo.d.ts",
+    "apollo.d.cts",
+    "instrumentation.cjs",
+    "instrumentation.js",
+    "instrumentation.d.ts",
+    "instrumentation.d.cts",
+    "lifecycle.cjs",
+    "lifecycle.js",
+    "lifecycle.d.ts",
+    "lifecycle.d.cts",
+    "global-errors.cjs",
+    "global-errors.js",
+    "global-errors.d.ts",
+    "global-errors.d.cts",
+    "metadata.cjs",
+    "metadata.js",
+    "native-bridge.cjs",
+    "native-bridge.js",
+    "native-bridge.d.ts",
+    "native-bridge.d.cts",
+    "resource-fetch.cjs",
+    "resource-fetch.js",
+    "resource-fetch.d.ts",
+    "resource-fetch.d.cts",
+    "release-artifacts.cjs",
+    "release-artifacts.js",
+    "release-artifacts.d.ts",
+    "release-artifacts.d.cts",
+    "metro.cjs",
+    "metro.js",
+    "metro.d.ts",
+    "metro.d.cts",
     "README.md",
     "examples"
   ],
@@ -34,10 +156,12 @@
     "logbrew",
     "react-native",
     "mobile",
+    "metro",
     "observability",
     "logs",
     "traces",
-    "events"
+    "events",
+    "source-maps"
   ],
   "sideEffects": false,
   "engines": {
@@ -54,6 +178,6 @@
     "react-native": ">=0.72"
   },
   "scripts": {
-    "test": "node --check index.js && node --check index.cjs && node --check index.native.js && node --check examples/index.mjs && node --check examples/readme-example.mjs && node --check examples/real-user-smoke.mjs"
+    "test": "node --check index.js && node --check index.cjs && node --check index.native.js && node --check apollo.js && node --check apollo.cjs && node --check instrumentation.js && node --check instrumentation.cjs && node --check lifecycle.js && node --check lifecycle.cjs && node --check global-errors.js && node --check global-errors.cjs && node --check metadata.js && node --check metadata.cjs && node --check native-bridge.js && node --check native-bridge.cjs && node --check resource-fetch.js && node --check resource-fetch.cjs && node --check release-artifacts.js && node --check release-artifacts.cjs && node --check metro.js && node --check metro.cjs && node --check examples/index.mjs && node --check examples/apollo-link-spans.mjs && node --check examples/instrumentation-kit.mjs && node --check examples/lifecycle-spans.mjs && node --check examples/native-bridge-scope.mjs && node --check examples/navigation-resource-spans.mjs && node --check examples/readme-example.mjs && node --check examples/real-user-smoke.mjs && node --check examples/resource-fetch-spans.mjs && node --check examples/trace-correlation.mjs && node --test"
   }
 }

package/release-artifacts.cjs

@@ -0,0 +1,344 @@
+"use strict";
+
+const { spawnSync } = require("node:child_process");
+const fs = require("node:fs");
+const net = require("node:net");
+const path = require("node:path");
+
+const PACKAGE_DIR = path.dirname(require.resolve("./package.json"));
+const DEFAULT_MANIFEST_NAME = "logbrew-release-artifacts.json";
+const SUPPORTED_PLATFORMS = new Set(["android", "ios"]);
+const SOURCE_MAPPING_COMMENT_RE = /(?:\/\/#|\/\*#)\s*sourceMappingURL=[^\r\n]*/giu;
+
+function requiredString(options, name) {
+  const value = options?.[name];
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`LogBrew React Native release-artifact helper 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 React Native release-artifact helper option ${name} must be a non-empty string`);
+  }
+  return value.trim();
+}
+
+function optionalUploadScalar(options, name) {
+  const value = options?.[name];
+  if (value === undefined || value === null) {
+    return null;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new Error(`LogBrew React Native release-artifact helper option ${name} must be non-negative`);
+    }
+    return String(value);
+  }
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`LogBrew React Native release-artifact helper option ${name} must be a non-empty string or number`);
+  }
+  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 React Native release-artifact helper option ${name} must be an array of non-empty strings`);
+  }
+  return value.map((item) => item.trim());
+}
+
+function normalizePlatform(options) {
+  const platform = requiredString(options, "platform").toLowerCase();
+  if (!SUPPORTED_PLATFORMS.has(platform)) {
+    throw new Error("LogBrew React Native release-artifact helper option platform must be android or ios");
+  }
+  return platform;
+}
+
+function parseJson(stdout, command) {
+  try {
+    return JSON.parse(stdout);
+  } catch (error) {
+    throw new Error(`LogBrew release-artifact ${command} did not return JSON`, { cause: error });
+  }
+}
+
+function validationErrors(report) {
+  if (report?.validation && Array.isArray(report.validation.errors)) {
+    return report.validation.errors.filter((message) => typeof message === "string" && message.trim() !== "");
+  }
+  return [];
+}
+
+function resolveLogBrewReleaseArtifactsCli() {
+  try {
+    const sdkEntry = require.resolve("@logbrew/sdk", { paths: [PACKAGE_DIR, process.cwd()] });
+    return path.join(path.dirname(sdkEntry), "release-artifacts.js");
+  } catch {
+    const sourceTreeCli = path.resolve(PACKAGE_DIR, "../logbrew-js/release-artifacts.js");
+    if (fs.existsSync(sourceTreeCli)) {
+      return sourceTreeCli;
+    }
+    throw new Error("LogBrew React Native release-artifact helper requires @logbrew/sdk to be installed");
+  }
+}
+
+function parseUploadEndpoint(endpoint) {
+  let parsed;
+  try {
+    parsed = new URL(endpoint);
+  } catch (error) {
+    throw new Error(`upload endpoint is not a valid URL: ${error.message}`, { cause: error });
+  }
+  if (!["http:", "https:"].includes(parsed.protocol)) {
+    throw new Error("release artifact upload proof endpoint must use http or https");
+  }
+  return parsed;
+}
+
+function isLoopbackUploadEndpoint(parsed) {
+  const hostname = parsed.hostname.toLowerCase();
+  return (
+    hostname === "localhost" ||
+    hostname === "[::1]" ||
+    hostname === "::1" ||
+    (net.isIP(hostname) !== 0 && (hostname.startsWith("127.") || hostname === "::1"))
+  );
+}
+
+function requireUploadEndpoint(endpoint, allowHosted) {
+  const parsed = parseUploadEndpoint(endpoint);
+  if (isLoopbackUploadEndpoint(parsed)) {
+    return;
+  }
+  if (!allowHosted) {
+    throw new Error("release artifact hosted upload requires explicit allowHostedUpload; use loopback endpoints for local proof");
+  }
+  if (parsed.protocol !== "https:") {
+    throw new Error("hosted release artifact upload endpoints must use https");
+  }
+  if (parsed.username || parsed.password) {
+    throw new Error("hosted release artifact upload endpoints must not include embedded auth values");
+  }
+  if (parsed.search || parsed.hash) {
+    throw new Error("hosted release artifact upload endpoints must not include query strings or fragments");
+  }
+}
+
+function runReleaseArtifactCli(command, args) {
+  const result = spawnSync(process.execPath, [resolveLogBrewReleaseArtifactsCli(), command, ...args], {
+    cwd: process.cwd(),
+    encoding: "utf8",
+    windowsHide: true,
+  });
+  const report = result.stdout ? parseJson(result.stdout, command) : null;
+  if (result.status !== 0) {
+    const details = validationErrors(report).join("; ") || result.stderr.trim() || `exit code ${result.status}`;
+    throw new Error(`LogBrew release-artifact ${command} failed: ${details}`);
+  }
+  return { report, stdout: result.stdout };
+}
+
+function resolvePathFromRoot(root, value) {
+  return path.isAbsolute(value) ? path.resolve(value) : path.resolve(root, value);
+}
+
+function requireExistingFile(label, filePath) {
+  if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+    throw new Error(`LogBrew React Native release-artifact helper ${label} does not exist: ${filePath}`);
+  }
+}
+
+function ensureInsideBuildDir(label, filePath, buildDir) {
+  const relative = path.relative(buildDir, filePath);
+  if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error(`LogBrew React Native release-artifact helper ${label} must stay inside buildDir`);
+  }
+  return relative.split(path.sep).join("/");
+}
+
+function artifactForBundle(report, relativeBundlePath) {
+  return report?.artifacts?.find((artifact) => artifact?.path === relativeBundlePath) || null;
+}
+
+function sourceMapReferenceForBundle(bundlePath, sourcemapPath) {
+  return path.relative(path.dirname(bundlePath), sourcemapPath).split(path.sep).join("/");
+}
+
+function sourceWithSourceMappingUrl(source, reference) {
+  const comment = `//# sourceMappingURL=${reference}`;
+  const sourceWithoutMapComments = source.replace(SOURCE_MAPPING_COMMENT_RE, "").replace(/[ \t\r\n]*$/u, "");
+  return `${sourceWithoutMapComments}${sourceWithoutMapComments === "" ? "" : "\n"}${comment}\n`;
+}
+
+function applyExplicitSourceMapReference(bundlePath, sourcemapPath) {
+  const reference = sourceMapReferenceForBundle(bundlePath, sourcemapPath);
+  const source = fs.readFileSync(bundlePath, "utf8");
+  const updated = sourceWithSourceMappingUrl(source, reference);
+  if (updated !== source) {
+    fs.writeFileSync(bundlePath, updated, "utf8");
+  }
+}
+
+function defaultMinifiedPathPrefix(platform) {
+  return `app:///react-native/${platform}`;
+}
+
+function prepareLogBrewReactNativeReleaseArtifacts(options = {}) {
+  const release = requiredString(options, "release");
+  const environment = requiredString(options, "environment");
+  const service = requiredString(options, "service");
+  const projectId = optionalString(options, "projectId");
+  const platform = normalizePlatform(options);
+  const root = path.resolve(optionalString(options, "root") || process.cwd());
+  const bundlePath = resolvePathFromRoot(root, requiredString(options, "bundle"));
+  const sourcemapOption = optionalString(options, "sourcemap");
+  const sourcemapPath = sourcemapOption ? resolvePathFromRoot(root, sourcemapOption) : `${bundlePath}.map`;
+  const buildDirOption = optionalString(options, "buildDir");
+  const buildDir = buildDirOption ? resolvePathFromRoot(root, buildDirOption) : path.dirname(bundlePath);
+  const manifestPath = resolvePathFromRoot(
+    root,
+    optionalString(options, "manifestPath") || path.join(buildDir, DEFAULT_MANIFEST_NAME),
+  );
+  const minifiedPathPrefix = optionalString(options, "minifiedPathPrefix") || defaultMinifiedPathPrefix(platform);
+  const repositoryUrl = optionalString(options, "repositoryUrl");
+  const commitSha = optionalString(options, "commitSha");
+  const stripSourcesContent = options?.stripSourcesContent !== false;
+  const userSourcePrefixes = normalizeStringArray(options?.stripSourcePrefix, "stripSourcePrefix");
+  const sourcePrefixes = userSourcePrefixes.length > 0 ? userSourcePrefixes : [root];
+
+  requireExistingFile("bundle", bundlePath);
+  requireExistingFile("sourcemap", sourcemapPath);
+  const relativeBundlePath = ensureInsideBuildDir("bundle", bundlePath, buildDir);
+  const relativeSourceMapPath = ensureInsideBuildDir("sourcemap", sourcemapPath, buildDir);
+  applyExplicitSourceMapReference(bundlePath, sourcemapPath);
+
+  const prepareArgs = ["--build-dir", buildDir, "--write"];
+  if (stripSourcesContent) {
+    prepareArgs.push("--strip-sources-content");
+  }
+  for (const prefix of sourcePrefixes) {
+    prepareArgs.push("--strip-source-prefix", resolvePathFromRoot(root, prefix));
+  }
+
+  const { report: prepareReport } = runReleaseArtifactCli("prepare-js", prepareArgs);
+  const preparedArtifact = artifactForBundle(prepareReport, relativeBundlePath);
+  if (!preparedArtifact) {
+    throw new Error(`LogBrew React Native release-artifact helper did not find bundle: ${relativeBundlePath}`);
+  }
+  if (preparedArtifact.sourceMapPath !== relativeSourceMapPath) {
+    throw new Error(
+      `LogBrew React Native release-artifact helper expected source map ${relativeSourceMapPath} for ${relativeBundlePath}`,
+    );
+  }
+
+  const manifestArgs = [
+    "--build-dir",
+    buildDir,
+    "--release",
+    release,
+    "--environment",
+    environment,
+    "--service",
+    service,
+    "--minified-path-prefix",
+    minifiedPathPrefix,
+  ];
+  if (projectId) {
+    manifestArgs.push("--project-id", projectId);
+  }
+  if (repositoryUrl) {
+    manifestArgs.push("--repository-url", repositoryUrl);
+  }
+  if (commitSha) {
+    manifestArgs.push("--commit-sha", commitSha);
+  }
+
+  const { report: manifestReport, stdout } = runReleaseArtifactCli("manifest-js", manifestArgs);
+  const manifestArtifact = manifestReport?.artifacts?.find(
+    (artifact) => artifact?.minifiedSource?.path === relativeBundlePath,
+  );
+  if (!manifestArtifact) {
+    throw new Error(`LogBrew React Native release-artifact manifest did not include bundle: ${relativeBundlePath}`);
+  }
+
+  fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+  fs.writeFileSync(manifestPath, stdout, "utf8");
+
+  return {
+    buildDir,
+    bundlePath,
+    sourcemapPath,
+    manifestPath,
+    platform,
+    prepareReport,
+    manifestReport,
+  };
+}
+
+function uploadLogBrewReactNativeReleaseArtifacts(options = {}) {
+  const endpoint = requiredString(options, "endpoint");
+  const allowHostedUpload = options?.allowHostedUpload === true;
+  if (options?.allowHostedUpload !== undefined && typeof options.allowHostedUpload !== "boolean") {
+    throw new Error("LogBrew React Native release-artifact helper option allowHostedUpload must be a boolean");
+  }
+  requireUploadEndpoint(endpoint, allowHostedUpload);
+  const tokenEnv = optionalString(options, "tokenEnv");
+  const maxRetries = optionalUploadScalar(options, "maxRetries");
+  const retryDelay = optionalUploadScalar(options, "retryDelay");
+  const timeout = optionalUploadScalar(options, "timeout");
+  const dryRun = options?.dryRun;
+  if (dryRun !== undefined && typeof dryRun !== "boolean") {
+    throw new Error("LogBrew React Native release-artifact helper option dryRun must be a boolean");
+  }
+
+  const prepared = prepareLogBrewReactNativeReleaseArtifacts(options);
+  const uploadArgs = [
+    "--build-dir",
+    prepared.buildDir,
+    "--manifest",
+    prepared.manifestPath,
+    "--endpoint",
+    endpoint,
+  ];
+
+  if (tokenEnv) {
+    uploadArgs.push("--token-env", tokenEnv);
+  }
+  if (dryRun === true) {
+    uploadArgs.push("--dry-run");
+  }
+  if (allowHostedUpload) {
+    uploadArgs.push("--allow-hosted");
+  }
+  if (maxRetries) {
+    uploadArgs.push("--max-retries", maxRetries);
+  }
+  if (retryDelay) {
+    uploadArgs.push("--retry-delay", retryDelay);
+  }
+  if (timeout) {
+    uploadArgs.push("--timeout", timeout);
+  }
+
+  const { report: uploadReport } = runReleaseArtifactCli("upload-js", uploadArgs);
+  return {
+    ...prepared,
+    uploadReport,
+  };
+}
+
+module.exports = {
+  prepareLogBrewReactNativeReleaseArtifacts,
+  uploadLogBrewReactNativeReleaseArtifacts,
+  default: prepareLogBrewReactNativeReleaseArtifacts,
+};

package/release-artifacts.d.cts

@@ -0,0 +1,55 @@
+export type LogBrewReactNativeReleaseArtifactPlatform = "android" | "ios";
+
+export type LogBrewReactNativeReleaseArtifactsOptions = {
+  bundle: string;
+  platform: LogBrewReactNativeReleaseArtifactPlatform;
+  release: string;
+  environment: string;
+  service: string;
+  projectId?: string;
+  sourcemap?: string;
+  root?: string;
+  buildDir?: string;
+  manifestPath?: string;
+  minifiedPathPrefix?: string;
+  repositoryUrl?: string;
+  commitSha?: string;
+  stripSourcesContent?: boolean;
+  stripSourcePrefix?: string[];
+};
+
+export type LogBrewReactNativeReleaseArtifactsResult = {
+  buildDir: string;
+  bundlePath: string;
+  sourcemapPath: string;
+  manifestPath: string;
+  platform: LogBrewReactNativeReleaseArtifactPlatform;
+  prepareReport: Record<string, unknown>;
+  manifestReport: Record<string, unknown>;
+};
+
+export type LogBrewReactNativeReleaseArtifactUploadOptions = LogBrewReactNativeReleaseArtifactsOptions & {
+  endpoint: string;
+  allowHostedUpload?: boolean;
+  tokenEnv?: string;
+  dryRun?: boolean;
+  maxRetries?: string | number;
+  retryDelay?: string | number;
+  timeout?: string | number;
+};
+
+export type LogBrewReactNativeReleaseArtifactUploadResult = LogBrewReactNativeReleaseArtifactsResult & {
+  uploadReport: Record<string, unknown>;
+};
+
+export declare function prepareLogBrewReactNativeReleaseArtifacts(
+  options: LogBrewReactNativeReleaseArtifactsOptions
+): LogBrewReactNativeReleaseArtifactsResult;
+
+export declare function uploadLogBrewReactNativeReleaseArtifacts(
+  options: LogBrewReactNativeReleaseArtifactUploadOptions
+): LogBrewReactNativeReleaseArtifactUploadResult;
+
+declare const defaultExport: typeof prepareLogBrewReactNativeReleaseArtifacts;
+
+export default defaultExport;