@luciq/react-native 19.2.1 → 19.3.0

package/dist/models/CustomSpan.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Callback to unregister a span from tracking
+ */
+type UnregisterCallback = (span: CustomSpan) => void;
+/**
+ * Callback to sync span data to native SDK
+ */
+type SyncCallback = (name: string, startTimestamp: number, endTimestamp: number) => Promise<void>;
+/**
+ * Represents a custom span for performance tracking.
+ * A span measures the duration of an operation and reports it to the native SDK.
+ */
+export declare class CustomSpan {
+    private name;
+    private startTime;
+    private startMonotonic;
+    private endTime?;
+    private duration?;
+    private hasEnded;
+    private endPromise?;
+    private unregisterCallback;
+    private syncCallback;
+    /**
+     * Creates a new custom span. The span starts immediately upon creation.
+     * @internal - Use APM.startCustomSpan() instead
+     */
+    constructor(name: string, unregisterCallback: UnregisterCallback, syncCallback: SyncCallback);
+    /**
+     * Ends this custom span and reports it to the native SDK.
+     * This method is idempotent - calling it multiple times is safe.
+     * Subsequent calls will wait for the first call to complete.
+     */
+    end(): Promise<void>;
+    /**
+     * Get the span name
+     */
+    getName(): string;
+    /**
+     * Check if the span has ended
+     */
+    isEnded(): boolean;
+    /**
+     * Get the span duration in milliseconds (only available after end())
+     */
+    getDuration(): number | undefined;
+}
+export {};

package/dist/models/CustomSpan.js

@@ -0,0 +1,82 @@
+/**
+ * Represents a custom span for performance tracking.
+ * A span measures the duration of an operation and reports it to the native SDK.
+ */
+export class CustomSpan {
+    name;
+    startTime; // Date.now() in milliseconds
+    startMonotonic; // performance.now() in milliseconds
+    endTime;
+    duration;
+    hasEnded = false;
+    endPromise;
+    unregisterCallback;
+    syncCallback;
+    /**
+     * Creates a new custom span. The span starts immediately upon creation.
+     * @internal - Use APM.startCustomSpan() instead
+     */
+    constructor(name, unregisterCallback, syncCallback) {
+        this.name = name;
+        this.startTime = Date.now();
+        this.startMonotonic = performance.now();
+        this.unregisterCallback = unregisterCallback;
+        this.syncCallback = syncCallback;
+    }
+    /**
+     * Ends this custom span and reports it to the native SDK.
+     * This method is idempotent - calling it multiple times is safe.
+     * Subsequent calls will wait for the first call to complete.
+     */
+    async end() {
+        // Thread-safe check using Promise-based locking
+        if (this.hasEnded) {
+            if (this.endPromise) {
+                await this.endPromise;
+            }
+            return;
+        }
+        // Create lock and mark as ended
+        let resolveEnd;
+        this.endPromise = new Promise((resolve) => {
+            resolveEnd = resolve;
+        });
+        this.hasEnded = true;
+        try {
+            // Unregister from active spans
+            this.unregisterCallback(this);
+            // Calculate duration using monotonic clock
+            const endMonotonic = performance.now();
+            this.duration = endMonotonic - this.startMonotonic;
+            // Calculate end time using wall clock
+            this.endTime = this.startTime + this.duration;
+            // Convert to microseconds for native SDK
+            const startMicros = this.startTime * 1000;
+            const endMicros = this.endTime * 1000;
+            // Send to native SDK
+            await this.syncCallback(this.name, startMicros, endMicros);
+        }
+        finally {
+            // Release lock
+            resolveEnd();
+        }
+    }
+    /**
+     * Get the span name
+     */
+    getName() {
+        return this.name;
+    }
+    /**
+     * Check if the span has ended
+     */
+    isEnded() {
+        return this.hasEnded;
+    }
+    /**
+     * Get the span duration in milliseconds (only available after end())
+     */
+    getDuration() {
+        return this.duration;
+    }
+}

package/dist/modules/APM.d.ts

@@ -1,3 +1,4 @@
+import type { CustomSpan } from '../models/CustomSpan';
 /**
  * Enables or disables APM
  * @param isEnabled
@@ -80,3 +81,60 @@ export declare const _lcqSleep: () => void;
  * @param isEnabled
  */
 export declare const setScreenRenderingEnabled: (isEnabled: boolean) => void;
+/**
+ * Starts a custom span for performance tracking.
+ *
+ * A custom span measures the duration of an arbitrary operation that is not
+ * automatically tracked by the SDK. The span must be manually ended by calling
+ * the `end()` method on the returned span object.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ *
+ * @returns Promise<CustomSpan | null> - The span object to end later, or null if:
+ *   - Name is empty after trimming
+ *   - SDK is not initialized
+ *   - APM is disabled
+ *   - Custom spans feature is disabled
+ *   - Maximum concurrent spans limit (100) reached
+ *
+ * @example
+ * ```typescript
+ * const span = await APM.startCustomSpan('Load User Profile');
+ * if (span) {
+ *   try {
+ *     // ... perform operation ...
+ *   } finally {
+ *     await span.end();
+ *   }
+ * }
+ * ```
+ */
+export declare const startCustomSpan: (name: string) => Promise<CustomSpan | null>;
+/**
+ * Records a completed custom span with pre-recorded timestamps.
+ *
+ * Use this method when you have already recorded the start and end times
+ * of an operation and want to report it retroactively.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ * @param startDate - The start time of the operation
+ * @param endDate - The end time of the operation (must be after startDate)
+ *
+ * @returns Promise<void> - Resolves when the span has been recorded, or logs error if:
+ *   - Name is empty after trimming
+ *   - End date is not after start date
+ *   - SDK is not initialized
+ *   - APM is disabled
+ *   - Custom spans feature is disabled
+ *
+ * @example
+ * ```typescript
+ * const start = new Date();
+ * // ... operation already completed ...
+ * const end = new Date();
+ * await APM.addCompletedCustomSpan('Cache Lookup', start, end);
+ * ```
+ */
+export declare const addCompletedCustomSpan: (name: string, startDate: Date, endDate: Date) => Promise<void>;

package/dist/modules/APM.js

@@ -1,6 +1,7 @@
 import { Platform } from 'react-native';
 import { NativeAPM } from '../native/NativeAPM';
 import { NativeLuciq } from '../native/NativeLuciq';
+import { startCustomSpan as startCustomSpanInternal, addCompletedCustomSpan as addCompletedCustomSpanInternal, } from '../utils/CustomSpansManager';
 /**
  * Enables or disables APM
  * @param isEnabled
@@ -109,3 +110,64 @@ export const _lcqSleep = () => {
 export const setScreenRenderingEnabled = (isEnabled) => {
     NativeAPM.setScreenRenderingEnabled(isEnabled);
 };
+/**
+ * Starts a custom span for performance tracking.
+ *
+ * A custom span measures the duration of an arbitrary operation that is not
+ * automatically tracked by the SDK. The span must be manually ended by calling
+ * the `end()` method on the returned span object.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ *
+ * @returns Promise<CustomSpan | null> - The span object to end later, or null if:
+ *   - Name is empty after trimming
+ *   - SDK is not initialized
+ *   - APM is disabled
+ *   - Custom spans feature is disabled
+ *   - Maximum concurrent spans limit (100) reached
+ *
+ * @example
+ * ```typescript
+ * const span = await APM.startCustomSpan('Load User Profile');
+ * if (span) {
+ *   try {
+ *     // ... perform operation ...
+ *   } finally {
+ *     await span.end();
+ *   }
+ * }
+ * ```
+ */
+export const startCustomSpan = async (name) => {
+    return startCustomSpanInternal(name);
+};
+/**
+ * Records a completed custom span with pre-recorded timestamps.
+ *
+ * Use this method when you have already recorded the start and end times
+ * of an operation and want to report it retroactively.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ * @param startDate - The start time of the operation
+ * @param endDate - The end time of the operation (must be after startDate)
+ *
+ * @returns Promise<void> - Resolves when the span has been recorded, or logs error if:
+ *   - Name is empty after trimming
+ *   - End date is not after start date
+ *   - SDK is not initialized
+ *   - APM is disabled
+ *   - Custom spans feature is disabled
+ *
+ * @example
+ * ```typescript
+ * const start = new Date();
+ * // ... operation already completed ...
+ * const end = new Date();
+ * await APM.addCompletedCustomSpan('Cache Lookup', start, end);
+ * ```
+ */
+export const addCompletedCustomSpan = async (name, startDate, endDate) => {
+    return addCompletedCustomSpanInternal(name, startDate, endDate);
+};

package/dist/native/NativeAPM.d.ts

@@ -14,6 +14,9 @@ export interface ApmNativeModule extends NativeModule {
     endUITrace(): void;
     lcqSleep(): void;
     setScreenRenderingEnabled(isEnabled: boolean): void;
+    syncCustomSpan(name: string, startTimestamp: number, endTimestamp: number): Promise<void>;
+    isCustomSpanEnabled(): Promise<boolean>;
+    isAPMEnabled(): Promise<boolean>;
 }
 export declare const NativeAPM: ApmNativeModule;
 export declare const emitter: NativeEventEmitter;

package/dist/native/NativeLuciq.d.ts

@@ -8,6 +8,7 @@ import type { ThemeConfig } from '../models/ThemeConfig';
 export interface LuciqNativeModule extends NativeModule {
     getConstants(): NativeConstants;
     setEnabled(isEnabled: boolean): void;
+    isBuilt(): Promise<boolean>;
     init(token: string, invocationEvents: InvocationEvent[], debugLogsLevel: LogLevel, useNativeNetworkInterception: boolean, codePushVersion?: string, appVariant?: string, options?: {
         ignoreAndroidSecureFlag?: boolean;
     }, overAirVersion?: OverAirUpdate): void;

package/dist/utils/CustomSpansManager.d.ts

@@ -0,0 +1,38 @@
+import { CustomSpan } from '../models/CustomSpan';
+/**
+ * Starts a custom span for performance tracking.
+ *
+ * A custom span measures the duration of an arbitrary operation that is not
+ * automatically tracked by the SDK. The span must be manually ended by calling
+ * the `end()` method on the returned span object.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ *
+ * @returns Promise<CustomSpan | null> - The span object to end later, or null if:
+ *   - Name is empty after trimming
+ *   - SDK is not initialized
+ *   - APM is disabled
+ *   - Custom spans feature is disabled
+ *   - Maximum concurrent spans limit (100) reached
+ */
+export declare const startCustomSpan: (name: string) => Promise<CustomSpan | null>;
+/**
+ * Records a completed custom span with pre-recorded timestamps.
+ *
+ * Use this method when you have already recorded the start and end times
+ * of an operation and want to report it retroactively.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ * @param startDate - The start time of the operation
+ * @param endDate - The end time of the operation (must be after startDate)
+ *
+ * @returns Promise<void>
+ */
+export declare const addCompletedCustomSpan: (name: string, startDate: Date, endDate: Date) => Promise<void>;
+/**
+ * Test-only helper to clear active spans between tests.
+ * @internal
+ */
+export declare const __resetCustomSpansForTests: () => void;

package/dist/utils/CustomSpansManager.js

@@ -0,0 +1,173 @@
+import { NativeAPM } from '../native/NativeAPM';
+import { NativeLuciq } from '../native/NativeLuciq';
+import { CustomSpan } from '../models/CustomSpan';
+import { LuciqStrings } from '../constants/Strings';
+/**
+ * Tracks currently active custom spans
+ * @internal
+ */
+const activeSpans = new Set();
+/**
+ * Maximum concurrent custom spans allowed at any time
+ * @internal
+ */
+const MAX_CONCURRENT_SPANS = 100;
+/**
+ * Internal: unregister a span from active tracking
+ * @internal
+ */
+const unregisterSpan = (span) => {
+    activeSpans.delete(span);
+};
+/**
+ * Internal: sync custom span data to native SDK
+ * @internal
+ */
+const syncCustomSpan = async (name, startTimestamp, endTimestamp) => {
+    // Validate inputs (safety net)
+    if (!name || name.trim().length === 0) {
+        console.error(LuciqStrings.customSpanNameEmpty);
+        return;
+    }
+    if (endTimestamp <= startTimestamp) {
+        console.error(LuciqStrings.customSpanEndTimeBeforeStartTime);
+        return;
+    }
+    // Truncate name if needed (safety net)
+    let spanName = name.trim();
+    if (spanName.length > 150) {
+        spanName = spanName.substring(0, 150);
+    }
+    await NativeAPM.syncCustomSpan(spanName, startTimestamp, endTimestamp);
+};
+/**
+ * Starts a custom span for performance tracking.
+ *
+ * A custom span measures the duration of an arbitrary operation that is not
+ * automatically tracked by the SDK. The span must be manually ended by calling
+ * the `end()` method on the returned span object.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ *
+ * @returns Promise<CustomSpan | null> - The span object to end later, or null if:
+ *   - Name is empty after trimming
+ *   - SDK is not initialized
+ *   - APM is disabled
+ *   - Custom spans feature is disabled
+ *   - Maximum concurrent spans limit (100) reached
+ */
+export const startCustomSpan = async (name) => {
+    try {
+        // Validate name
+        const trimmedName = name.trim();
+        if (trimmedName.length === 0) {
+            console.error(LuciqStrings.customSpanNameEmpty);
+            return null;
+        }
+        // Check SDK initialization
+        const isInitialized = await NativeLuciq.isBuilt();
+        if (!isInitialized) {
+            console.error(LuciqStrings.customSpanSDKNotInitializedMessage);
+            return null;
+        }
+        // Check APM enabled
+        const isAPMEnabled = await NativeAPM.isAPMEnabled();
+        if (!isAPMEnabled) {
+            console.log(LuciqStrings.customSpanAPMDisabledMessage);
+            return null;
+        }
+        // Check custom spans enabled
+        const isCustomSpanEnabled = await NativeAPM.isCustomSpanEnabled();
+        if (!isCustomSpanEnabled) {
+            console.log(LuciqStrings.customSpanDisabled);
+            return null;
+        }
+        // Check concurrent span limit
+        if (activeSpans.size >= MAX_CONCURRENT_SPANS) {
+            console.error(LuciqStrings.customSpanLimitReached);
+            return null;
+        }
+        // Truncate name if needed
+        let spanName = trimmedName;
+        if (spanName.length > 150) {
+            spanName = spanName.substring(0, 150);
+            console.log(LuciqStrings.customSpanNameTruncated);
+        }
+        // Create and register span with callbacks
+        const span = new CustomSpan(spanName, unregisterSpan, syncCustomSpan);
+        activeSpans.add(span);
+        return span;
+    }
+    catch (error) {
+        console.error('[CustomSpan] Error starting span:', error);
+        return null;
+    }
+};
+/**
+ * Records a completed custom span with pre-recorded timestamps.
+ *
+ * Use this method when you have already recorded the start and end times
+ * of an operation and want to report it retroactively.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ * @param startDate - The start time of the operation
+ * @param endDate - The end time of the operation (must be after startDate)
+ *
+ * @returns Promise<void>
+ */
+export const addCompletedCustomSpan = async (name, startDate, endDate) => {
+    try {
+        // Validate name
+        const trimmedName = name.trim();
+        if (trimmedName.length === 0) {
+            console.error(LuciqStrings.customSpanNameEmpty);
+            return;
+        }
+        // Validate timestamps
+        if (endDate <= startDate) {
+            console.error(LuciqStrings.customSpanEndTimeBeforeStartTime);
+            return;
+        }
+        // Check SDK initialization
+        const isInitialized = await NativeLuciq.isBuilt();
+        if (!isInitialized) {
+            console.error(LuciqStrings.customSpanSDKNotInitializedMessage);
+            return;
+        }
+        // Check APM enabled
+        const isAPMEnabled = await NativeAPM.isAPMEnabled();
+        if (!isAPMEnabled) {
+            console.log(LuciqStrings.customSpanAPMDisabledMessage);
+            return;
+        }
+        // Check custom spans enabled
+        const isCustomSpanEnabled = await NativeAPM.isCustomSpanEnabled();
+        if (!isCustomSpanEnabled) {
+            console.log(LuciqStrings.customSpanDisabled);
+            return;
+        }
+        // Truncate name if needed
+        let spanName = trimmedName;
+        if (spanName.length > 150) {
+            spanName = spanName.substring(0, 150);
+            console.log(LuciqStrings.customSpanNameTruncated);
+        }
+        // Convert to microseconds
+        const startMicros = startDate.getTime() * 1000;
+        const endMicros = endDate.getTime() * 1000;
+        // Send to native SDK
+        await syncCustomSpan(spanName, startMicros, endMicros);
+    }
+    catch (error) {
+        console.error('[CustomSpan] Error adding completed span:', error);
+    }
+};
+/**
+ * Test-only helper to clear active spans between tests.
+ * @internal
+ */
+export const __resetCustomSpansForTests = () => {
+    activeSpans.clear();
+};

package/ios/RNLuciq/LuciqAPMBridge.h

@@ -23,4 +23,17 @@
 
 - (void)setScreenRenderingEnabled:(BOOL)isEnabled;
 
+// Custom Span methods
+- (void)syncCustomSpan:(NSString *)name
+        startTimestamp:(double)startTimestamp
+          endTimestamp:(double)endTimestamp
+              resolver:(RCTPromiseResolveBlock)resolve
+              rejecter:(RCTPromiseRejectBlock)reject;
+
+- (void)isCustomSpanEnabled:(RCTPromiseResolveBlock)resolve
+                   rejecter:(RCTPromiseRejectBlock)reject;
+
+- (void)isAPMEnabled:(RCTPromiseResolveBlock)resolve
+            rejecter:(RCTPromiseRejectBlock)reject;
+
 @end

package/ios/RNLuciq/LuciqAPMBridge.m

@@ -90,6 +90,61 @@ RCT_EXPORT_METHOD(setScreenRenderingEnabled:(BOOL)isEnabled) {
     LCQAPM.screenRenderingEnabled = isEnabled;
 }
 
+// Syncs a custom span to the native SDK (currently logs only)
+RCT_EXPORT_METHOD(syncCustomSpan:(NSString *)name
+                  startTimestamp:(double)startTimestamp
+                  endTimestamp:(double)endTimestamp
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    @try {
+        // Convert microseconds → seconds (NSDate uses seconds)
+        NSTimeInterval startSeconds = startTimestamp / 1e6;
+        NSTimeInterval endSeconds   = endTimestamp / 1e6;
+
+        NSDate *startDate = [NSDate dateWithTimeIntervalSince1970:startSeconds];
+        NSDate *endDate   = [NSDate dateWithTimeIntervalSince1970:endSeconds];
+
+        // Add completed span to APM
+        [LCQAPM addCompletedCustomSpanWithName:name
+                                     startDate:startDate
+                                       endDate:endDate];
+
+        resolve(@YES);
+    }
+    @catch (NSException *exception) {
+        reject(
+            @"SYNC_CUSTOM_SPAN_ERROR",
+            exception.reason ?: @"Failed to sync custom span",
+            nil
+        );
+    }
+}
+
+// Checks if custom spans feature is enabled
+RCT_EXPORT_METHOD(isCustomSpanEnabled:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        BOOL enabled = LCQAPM.customSpansEnabled;
+        resolve(@(enabled));
+    } @catch (NSException *exception) {
+        NSLog(@"[CustomSpan] Error checking feature flag: %@", exception);
+        resolve(@NO);
+    }
+}
+
+// Checks if APM is enabled
+RCT_EXPORT_METHOD(isAPMEnabled:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        BOOL enabled = LCQAPM.enabled;
+        resolve(@(enabled));
+    } @catch (NSException *exception) {
+        NSLog(@"[CustomSpan] Error checking APM enabled: %@", exception);
+        resolve(@NO);
+    }
+}
+
 
 
 @synthesize description;

package/ios/RNLuciq/LuciqReactBridge.m

@@ -545,4 +545,16 @@ RCT_EXPORT_METHOD(setNetworkLogBodyEnabled:(BOOL)isEnabled) {
     LCQNetworkLogger.logBodyEnabled = isEnabled;
 }
 
+// Checks if Luciq SDK is initialized
+RCT_EXPORT_METHOD(isBuilt:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        BOOL isBuilt = YES;
+        resolve(@(isBuilt));
+    } @catch (NSException *exception) {
+        NSLog(@"[Luciq] Error checking if SDK is built: %@", exception);
+        resolve(@NO);
+    }
+}
+
 @end

package/ios/RNLuciq/Util/LCQAPM+PrivateAPIs.h

@@ -11,5 +11,6 @@
 
 @property (class, atomic, assign) BOOL networkEnabled;
 
++ (BOOL)customSpansEnabled;
 
 @end

package/ios/native.rb

@@ -1,4 +1,4 @@
-$luciq= { :version => '19.4.0' }
+$luciq= { :version => '19.5.0' }
 
 def use_luciq! (spec = nil)
   version = $luciq[:version]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@luciq/react-native",
   "description": "Luciq is the Agentic Observability Platform built for Mobile.",
-  "version": "19.2.1",
+  "version": "19.3.0",
   "author": "Luciq (https://luciq.ai)",
   "repository": "github:luciqai/luciq-reactnative-sdk",
   "homepage": "https://www.luciq.ai/platforms/react-native",

package/plugin/build/index.js

@@ -42044,9 +42044,16 @@ function addLuciqBuildPhase(xcodeProject, packageName) {
 // Inject source map export line into the shell script
 function injectSourceMapExport(script) {
     var exportLine = 'export SOURCEMAP_FILE="$DERIVED_FILE_DIR/main.jsbundle.map"';
-    var escapedLine = exportLine.replace(/\$/g, '\\$').replace(/"/g, '\\"');
+    var escapedLine = exportLine.replace(/"/g, '\\"');
     var injectedLine = "".concat(escapedLine, "\\n");
-    return script.includes(escapedLine) ? script : script.replace(/^"/, "\"".concat(injectedLine));
+    if (script.includes(escapedLine)) {
+        return script;
+    }
+    var buggyLine = exportLine.replace(/\$/g, '\\$').replace(/"/g, '\\"');
+    if (script.includes(buggyLine)) {
+        return script.split(buggyLine).join(escapedLine);
+    }
+    return script.replace(/^"/, "\"".concat(injectedLine));
 }
 
 var luciqPackage = require('../../package.json');

package/plugin/src/withLuciqIOS.ts

@@ -102,8 +102,15 @@ function addLuciqBuildPhase(xcodeProject: XcodeProject, packageName: string): vo
 // Inject source map export line into the shell script
 function injectSourceMapExport(script: string): string {
   const exportLine = 'export SOURCEMAP_FILE="$DERIVED_FILE_DIR/main.jsbundle.map"';
-  const escapedLine = exportLine.replace(/\$/g, '\\$').replace(/"/g, '\\"');
+  const escapedLine = exportLine.replace(/"/g, '\\"');
   const injectedLine = `${escapedLine}\\n`;
 
-  return script.includes(escapedLine) ? script : script.replace(/^"/, `"${injectedLine}`);
+  if (script.includes(escapedLine)) {
+    return script;
+  }
+  const buggyLine = exportLine.replace(/\$/g, '\\$').replace(/"/g, '\\"');
+  if (script.includes(buggyLine)) {
+    return script.split(buggyLine).join(escapedLine);
+  }
+  return script.replace(/^"/, `"${injectedLine}`);
 }

package/scripts/releases/changelog_to_slack_formatter.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+input=$(cat)
+
+input=$(sed -E \
+          -e 's/\[([^]]+)\]\(([^)]+)\)/<\2|\1>/g' \
+          -e 's/^#{1,6}[[:space:]]*([^[:space:]].*)$/\*\1\*/' \
+          -e 's/^- /• /' <<< "$input")
+
+echo "$input"