@pexip/media 17.2.0 → 17.4.0

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # @pexip/media
 
+## 17.4.0
+
+### Minor Changes
+
+- 4a1908a: Use tsc to build packages
+- fec1c90: Format following Prettier update
+- f2a5e0e: Move trackProcessor param to be a functionn
+
+### Patch Changes
+
+- 99e25d2: correct `isInitialPermissionsNotGranted` validator
+- Updated dependencies [4a1908a]
+- Updated dependencies [fec1c90]
+- Updated dependencies [ec134d1]
+- Updated dependencies [24fe7e1]
+  - @pexip/signal@16.7.0
+  - @pexip/utils@16.10.0
+  - @pexip/media-control@17.4.0
+  - @pexip/media-processor@17.4.0
+
+## 17.3.0
+
+### Minor Changes
+
+- 7abdb2332a: Allow force to applyChanges for preview controller
+- 7b29d953: Update babel/traverse related deps
+- acb51c1ee1: Resolution from the preview should not affect the main
+
+### Patch Changes
+
+- Updated dependencies [68c3ba1bb8]
+- Updated dependencies [7b29d953]
+- Updated dependencies [821d9a1ef8]
+- Updated dependencies [96f3ce8802]
+  - @pexip/media-processor@17.3.0
+  - @pexip/media-control@17.3.0
+  - @pexip/utils@16.9.0
+  - @pexip/signal@16.6.0
+
 ## 17.2.0
 
 ### Minor Changes

package/dist/audioMixingProcessor.d.ts

@@ -0,0 +1,18 @@
+import type { MediaDeviceRequest } from '@pexip/media-control';
+import type { AudioGraph, AudioNodeInit } from '@pexip/media-processor';
+import type { Process, Media } from './types';
+interface AudioStreamProcessorProps {
+    mixWithAdditionalMedia?: boolean;
+    merger?: AudioNodeInit<ChannelMergerNode, ChannelMergerNode>;
+    displaySource?: AudioNodeInit<MediaStreamAudioSourceNode, MediaStreamAudioSourceNode>;
+    audioGraph?: AudioGraph;
+}
+declare const FEATURE_KEYS: ['mixWithAdditionalMedia'];
+type FeaturePropKeys = (typeof FEATURE_KEYS)[number];
+type FeatureProps = Pick<AudioStreamProcessorProps, FeaturePropKeys>;
+export declare const updateFeatureProps: (constraints: MediaDeviceRequest['audio'], props: FeatureProps) => FeatureProps;
+/**
+ * Create a Audio Mixing Processor and will own the stream passed-in
+ */
+export declare const createAudioMixingProcess: (getCurrrentMedia: () => MediaStream | undefined, scope?: string) => Process<Promise<Media>>;
+export {};

package/dist/audioMixingProcessor.js

@@ -0,0 +1,173 @@
+import { muteStreamTrack, stopMediaStream, extractConstraintsWithKeys, } from '@pexip/media-control';
+import { isEmpty } from '@pexip/utils';
+import { createAudioGraph, createAudioGraphProxy, createChannelMergerGraphNode, createStreamDestinationGraphNode, createStreamSourceGraphNode, resumeAudioOnUnmute, } from '@pexip/media-processor';
+import { logger } from './logger';
+import { applyExtendedConstraints, shallowCopy, wrapToJSON } from './utils';
+const FEATURE_KEYS = ['mixWithAdditionalMedia'];
+const getAudioConstraints = extractConstraintsWithKeys(FEATURE_KEYS);
+export const updateFeatureProps = (constraints, props) => {
+    const extracted = getAudioConstraints(constraints);
+    return FEATURE_KEYS.reduce((accm, key) => {
+        const [feature] = extracted[key];
+        if (feature !== undefined && props[key] !== feature) {
+            props[key] = feature;
+            return { ...accm, [key]: feature };
+        }
+        return accm;
+    }, {});
+};
+/**
+ * Create a Audio Mixing Processor and will own the stream passed-in
+ */
+export const createAudioMixingProcess = (getCurrrentMedia, scope = 'mixer') => {
+    const props = {};
+    return async (mediaP) => {
+        const media = await mediaP;
+        updateFeatureProps(media.constraints?.audio, props);
+        const [mainTrack] = media.stream?.getAudioTracks() ?? [];
+        const displayStream = getCurrrentMedia();
+        const [displayTrack] = displayStream?.getAudioTracks?.() ?? [];
+        const applyConstraints = applyExtendedConstraints(media, async (constraints) => {
+            if (isEmpty(constraints.audio)) {
+                return;
+            }
+            const features = updateFeatureProps(constraints.audio, props);
+            logger.debug({ scope, constraints: constraints.audio, features }, 'apply audio mixing constraints');
+            if (isEmpty(features) ||
+                (props.audioGraph &&
+                    ['closed', 'closing'].includes(props.audioGraph.state))) {
+                return;
+            }
+            if (features.mixWithAdditionalMedia) {
+                const newStream = getCurrrentMedia();
+                const [newTrack] = getCurrrentMedia()?.getAudioTracks() ?? [];
+                if (!newTrack) {
+                    return;
+                }
+                if (!props.audioGraph || !props.merger) {
+                    // TODO: Should update the media stream directly
+                    // return replace(media.stream, newTrack);
+                    logger.debug({ scope }, 'Should update the media stream directly');
+                    return;
+                }
+                if (props.displaySource && props.merger) {
+                    if (newStream ===
+                        props.displaySource.audioNode?.mediaStream) {
+                        return;
+                    }
+                    props.audioGraph.disconnect([
+                        props.displaySource,
+                        props.merger,
+                    ]);
+                }
+                if (newStream) {
+                    props.displaySource =
+                        createStreamSourceGraphNode(newStream);
+                    props.audioGraph.connect([
+                        props.displaySource,
+                        props.merger,
+                    ]);
+                }
+            }
+            else if (features.mixWithAdditionalMedia === false) {
+                // Unmixing
+                if (props.displaySource) {
+                    props.displaySource.release();
+                    props.audioGraph?.disconnect([props.displaySource]);
+                    props.displaySource = undefined;
+                }
+            }
+            return Promise.resolve();
+        });
+        if (!media.stream || (!mainTrack && !displayTrack)) {
+            return media;
+        }
+        if (!mainTrack && displayTrack) {
+            media.stream?.addTrack(displayTrack);
+            return shallowCopy(media, {
+                muteAudio: () => {
+                    /* Do Nothing */
+                },
+                applyConstraints,
+            });
+        }
+        try {
+            const mainSource = createStreamSourceGraphNode(media.stream);
+            props.displaySource =
+                displayStream && createStreamSourceGraphNode(displayStream);
+            props.merger = createChannelMergerGraphNode();
+            const destination = createStreamDestinationGraphNode({
+                channelCount: 1,
+                channelCountMode: 'explicit',
+            });
+            const initialAudioNodeConnection = [
+                [mainSource, props.merger],
+                [props.merger, destination],
+            ];
+            logger.debug({ initialAudioNodeConnection, scope }, 'Initial AudioNodeConnection');
+            const audioGraph = createAudioGraphProxy(createAudioGraph(initialAudioNodeConnection), {
+                connect: (target, args) => {
+                    logger.debug({ scope, target, args }, 'connect nodes');
+                },
+                disconnect: (target, args) => {
+                    logger.debug({ scope, target, args }, 'disconnect nodes');
+                },
+            });
+            props.audioGraph = audioGraph;
+            const unsubscribes = media.rawStream
+                ?.getAudioTracks()
+                .map(resumeAudioOnUnmute(audioGraph.context));
+            if (props.displaySource) {
+                props.audioGraph.connect([props.displaySource, props.merger]);
+            }
+            const tracks = [
+                ...(destination?.node?.stream.getAudioTracks() ?? []),
+                ...(media.stream?.getVideoTracks() ?? []),
+            ];
+            const stream = new MediaStream(tracks);
+            const release = async () => {
+                logger.debug({ scope }, 'Release Media');
+                unsubscribes?.forEach(unsubscribe => unsubscribe());
+                stopMediaStream(stream);
+                // Release Props
+                await props.audioGraph?.release();
+                await media.release();
+                props.audioGraph = undefined;
+                props.merger = undefined;
+                props.displaySource = undefined;
+            };
+            const muteAudio = (mute) => {
+                media.muteAudio(mute);
+                // TODO: dbl check if this is safe
+                muteStreamTrack(mainSource.audioNode?.mediaStream)(mute, 'audio');
+            };
+            const prevGetSettings = media.getSettings;
+            return wrapToJSON(shallowCopy(media, {
+                stream,
+                applyConstraints,
+                muteAudio,
+                release,
+                getSettings: () => {
+                    const { audio, video } = prevGetSettings();
+                    const mixWithAdditionalMedia = !!props.mixWithAdditionalMedia;
+                    const audioSettings = {
+                        mixWithAdditionalMedia,
+                    };
+                    const settings = {
+                        audio: audio.map(settings => ({
+                            ...settings,
+                            ...audioSettings,
+                        })),
+                        video,
+                    };
+                    logger.debug({ scope, settings: audioSettings }, 'get audio mixing processor settings');
+                    return settings;
+                },
+            }));
+        }
+        catch (error) {
+            logger.error({ scope, error }, 'Unable to use WebAudio, return the raw media instead');
+            return media;
+        }
+    };
+};

package/dist/audioProcessor.d.ts

@@ -0,0 +1,86 @@
+import type { AudioGraphOptions, AudioNodeInit, ThrottleOptions, DenoiseWorkletNodeInit, AnalyzerNodeInit, AudioGraph } from '@pexip/media-processor';
+import type { MediaDeviceRequest } from '@pexip/media-control';
+import type { Process, Media, DenoiseParams, AudioContentHint } from './types';
+type AudioNodeInits = AudioNodeInit[];
+/**
+ * A function to be called to create the AudioNodes needed for the graph
+ * creation
+ *
+ * @param media - Media to be used for the AudioGraph creation
+ */
+type CreateNodes = (media: Media) => AudioNodeInits;
+interface AudioProcessOptions {
+    /**
+     * An option is being passed to AnalyserNode creation when used
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/fftSize
+     *
+     * @defaultValue 2048
+     */
+    fftSize?: number;
+    /**
+     * Params needed for setting up noise suppression WebAssembly and
+     * AudioWorklet
+     */
+    denoiseParams?: DenoiseParams;
+    /**
+     * Update frequency for analyzer per second
+     *
+     * @defaultValue 0.5
+     */
+    analyzerUpdateFrequency?: number;
+    /**
+     * Audio Signal Detection duration in second
+     *
+     * @defaultValue 4.0
+     */
+    audioSignalDetectionDuration?: number;
+    /**
+     * Callback when Voice Activity detected
+     */
+    onVoiceActivityDetected?: () => void;
+    /**
+     * Callback when Audio Signal detected
+     */
+    onAudioSignalDetected?: (silent: boolean) => void;
+    /**
+     * @see AudioGraphOptions
+     */
+    audioGraphOptions?: AudioGraphOptions;
+    /**
+     * Whether or to enable this processor
+     */
+    shouldEnable: () => boolean;
+    /**
+     * Insert additional nodes between the source and destination
+     */
+    createNodes?: CreateNodes;
+    /**
+     * Silent threshold, how large the value of the sample is considered as
+     * silent in FFTed time domain
+     */
+    silentThreshold?: number;
+    scope?: string;
+}
+interface AudioStreamProcessorProps {
+    audioGraphOptions?: AudioGraphOptions;
+    denoiseWasm?: ArrayBuffer;
+    vad?: boolean;
+    asd?: boolean;
+    denoise?: boolean;
+    analyzerBuffer?: Float32Array;
+    denoiseNode?: DenoiseWorkletNodeInit;
+    additionalAudioSourceNode?: AudioNodeInit<MediaStreamAudioSourceNode, MediaStreamAudioSourceNode>;
+    mixerNode?: AudioNodeInit<ChannelMergerNode, ChannelMergerNode>;
+    analyzer?: AnalyzerNodeInit;
+    contentHint?: AudioContentHint;
+    audioGraph?: AudioGraph;
+}
+declare const FEATURE_KEYS: ['denoise', 'vad', 'asd', 'contentHint'];
+type FeaturePropKeys = (typeof FEATURE_KEYS)[number];
+type FeatureProps = Pick<AudioStreamProcessorProps, FeaturePropKeys>;
+export declare const updateFeatureProps: (constraints: MediaDeviceRequest['audio'], props: FeatureProps) => FeatureProps;
+/**
+ * Create a Audio Stream Processor and will own the stream passed-in
+ */
+export declare const createAudioStreamProcess: ({ analyzerUpdateFrequency, audioGraphOptions, audioSignalDetectionDuration, clock, createNodes, denoiseParams, fftSize, onAudioSignalDetected, onVoiceActivityDetected, shouldEnable, silentThreshold, throttleMs, scope, }: AudioProcessOptions & ThrottleOptions) => Process<Promise<Media>>;
+export {};

package/dist/audioProcessor.js

@@ -0,0 +1,310 @@
+import { stopMediaStream, extractConstraintsWithKeys, muteStreamTrack, } from '@pexip/media-control';
+import { createQueue, isEmpty } from '@pexip/utils';
+import { createAudioGraph, createAudioGraphProxy, createStreamSourceGraphNode, createStreamDestinationGraphNode, createAnalyzerSubscribableGraphNode, createDenoiseWorkletGraphNode, createAudioSignalDetector, createVADetector, createVoiceDetectorFromTimeData, createVoiceDetectorFromProbability, avg, } from '@pexip/media-processor';
+import { logger } from './logger';
+import { isAudioContentHint } from './typeGuard';
+import { shallowCopy, wrapToJSON, applyExtendedConstraints } from './utils';
+/**
+ * Fetch the wasm when it doesn't exist from the provided, otherwise do nothing
+ *
+ * @param denoiseWasm - The wasm if it exists
+ * @param wasmURL - The URL for the fetching
+ */
+const fetchDenoiseWasm = async (denoiseWasm, wasmURL) => {
+    if (!wasmURL || denoiseWasm) {
+        return denoiseWasm;
+    }
+    return await (await fetch(wasmURL)).arrayBuffer();
+};
+const FEATURE_KEYS = [
+    'denoise',
+    'vad',
+    'asd',
+    'contentHint',
+];
+const getAudioConstraints = extractConstraintsWithKeys(FEATURE_KEYS);
+export const updateFeatureProps = (constraints, props) => {
+    const extracted = getAudioConstraints(constraints);
+    return FEATURE_KEYS.reduce((accm, key) => {
+        switch (key) {
+            case 'contentHint': {
+                const [[feature] = []] = extracted[key];
+                if (isAudioContentHint(feature) && props[key] !== feature) {
+                    props[key] = feature;
+                    return { ...accm, [key]: feature };
+                }
+                return accm;
+            }
+            case 'denoise':
+            case 'asd':
+            case 'vad': {
+                const [feature] = extracted[key];
+                if (feature !== undefined && props[key] !== feature) {
+                    props[key] = feature;
+                    return { ...accm, [key]: feature };
+                }
+                return accm;
+            }
+            default:
+                return accm;
+        }
+    }, {});
+};
+/**
+ * Create a Audio Stream Processor and will own the stream passed-in
+ */
+export const createAudioStreamProcess = ({ analyzerUpdateFrequency = 0.5, // 0.5 Hz
+audioGraphOptions, audioSignalDetectionDuration = 4.0, // 4 seconds
+clock, createNodes, denoiseParams, fftSize = 2048, // FFT size
+onAudioSignalDetected, onVoiceActivityDetected, shouldEnable, silentThreshold = 10.0 / 32767, // At least one LSB 16-bit data (compare is on absolute value).
+throttleMs = 3000, // 3 seconds
+scope = 'media', }) => {
+    const props = {
+        audioGraphOptions,
+        vad: false,
+        asd: false,
+        denoise: false,
+    };
+    const detectAudio = onAudioSignalDetected &&
+        createAudioSignalDetector(() => !!props.asd, onAudioSignalDetected);
+    const detectVA = onVoiceActivityDetected &&
+        createVADetector(onVoiceActivityDetected, () => !!props.vad, {
+            throttleMs,
+            clock,
+        });
+    const detectVAFromTimeData = detectVA?.(createVoiceDetectorFromTimeData());
+    const createDenoiseNode = async (denoise) => {
+        if (!denoise) {
+            return undefined;
+        }
+        if (props.denoiseNode) {
+            return props.denoiseNode;
+        }
+        if (denoiseParams?.workletModule) {
+            try {
+                await props.audioGraph?.addWorklet(denoiseParams?.workletModule, denoiseParams?.workletOptions);
+            }
+            catch (error) {
+                logger.error({
+                    scope,
+                    error,
+                    moduleURL: denoiseParams?.workletModule,
+                    options: denoiseParams?.workletOptions,
+                }, 'Failed add worklet');
+                return undefined;
+            }
+        }
+        try {
+            props.denoiseWasm = await fetchDenoiseWasm(props.denoiseWasm, denoiseParams?.wasmURL);
+        }
+        catch (error) {
+            logger.error({
+                scope,
+                error,
+                url: denoiseParams?.wasmURL,
+                prevWasm: props.denoiseWasm,
+            }, 'Failed to fetch denoise wasm');
+            return undefined;
+        }
+        const detectVAFromProbability = detectVA?.(createVoiceDetectorFromProbability());
+        if (props.denoiseWasm) {
+            const denoise = createDenoiseWorkletGraphNode(props.denoiseWasm, vads => {
+                detectVAFromProbability?.(avg(vads));
+            });
+            props.denoiseNode = denoise;
+            return denoise;
+        }
+    };
+    const createAnalyzer = () => {
+        const shouldUseAnalyzer = () => !!((props.vad && !props.denoise) || props.asd) &&
+            (detectAudio || detectVA);
+        if (!shouldUseAnalyzer()) {
+            return;
+        }
+        if (props.analyzer) {
+            return props.analyzer;
+        }
+        const detectSilentAudio = detectAudio?.(createQueue(audioSignalDetectionDuration / analyzerUpdateFrequency), silentThreshold);
+        const analyzer = createAnalyzerSubscribableGraphNode({
+            updateFrequency: analyzerUpdateFrequency,
+            messageHandler: analyzer => {
+                if (shouldUseAnalyzer()) {
+                    if (!props.analyzerBuffer) {
+                        // Only Create the buffer when needed
+                        props.analyzerBuffer = new Float32Array(fftSize);
+                    }
+                    analyzer.getFloatTimeDomainData(props.analyzerBuffer);
+                    const data = Array.from(props.analyzerBuffer);
+                    detectSilentAudio?.(data);
+                    !props.denoise && detectVAFromTimeData?.(data);
+                }
+            },
+            fftSize,
+        });
+        props.analyzer = analyzer;
+        return analyzer;
+    };
+    return async (mediaP) => {
+        const media = await mediaP;
+        updateFeatureProps(media.constraints?.audio, props);
+        const shouldProcessAudio = shouldEnable() &&
+            !!media.stream?.getAudioTracks().length &&
+            (!!onVoiceActivityDetected ||
+                !!onAudioSignalDetected ||
+                props.asd ||
+                props.vad ||
+                props.denoise ||
+                !!createNodes);
+        if (!media.stream?.getAudioTracks().length || !shouldProcessAudio) {
+            return media;
+        }
+        try {
+            const source = createStreamSourceGraphNode(media.stream);
+            const destination = createStreamDestinationGraphNode();
+            const otherNodes = createNodes?.(media) ?? [];
+            const analyzer = createAnalyzer();
+            const initialAudioNodeConnection = [
+                [source, ...otherNodes, destination],
+                [source, analyzer],
+            ];
+            logger.debug({ initialAudioNodeConnection, scope }, 'Initial AudioNodeConnection');
+            const audioGraph = createAudioGraphProxy(createAudioGraph(initialAudioNodeConnection, props.audioGraphOptions), {
+                connect: (target, args) => {
+                    logger.debug({ scope, target, args }, 'connect nodes');
+                },
+                disconnect: (target, args) => {
+                    logger.debug({ scope, target, args }, 'disconnect nodes');
+                },
+            });
+            props.audioGraph = audioGraph;
+            const denoiseNode = await createDenoiseNode(props.denoise);
+            const connectDenoise = (node) => {
+                if (node) {
+                    audioGraph.disconnect([source, ...otherNodes, destination]);
+                    audioGraph.connect([
+                        source,
+                        node,
+                        ...otherNodes,
+                        destination,
+                    ]);
+                }
+            };
+            connectDenoise(denoiseNode);
+            const tracks = [
+                ...(destination?.node?.stream.getAudioTracks() ?? []),
+                ...(media.stream?.getVideoTracks().map(t => t.clone()) ?? []),
+            ];
+            const stream = new MediaStream(tracks);
+            const applyConstraints = applyExtendedConstraints(media, async (constraints) => {
+                if (isEmpty(constraints.audio)) {
+                    return;
+                }
+                const features = updateFeatureProps(constraints.audio, props);
+                logger.debug({ scope, constraints: constraints.audio, features }, 'apply audio constraints');
+                if (isEmpty(features) ||
+                    ['closed', 'closing'].includes(audioGraph.state)) {
+                    return;
+                }
+                try {
+                    const denoiseNode = await createDenoiseNode(props.denoise);
+                    if (denoiseNode) {
+                        if (!source.hasConnectedTo(denoiseNode)) {
+                            connectDenoise(denoiseNode);
+                        }
+                    }
+                    else {
+                        if (props.denoiseNode) {
+                            audioGraph.disconnect([
+                                source,
+                                props.denoiseNode,
+                                ...otherNodes,
+                                destination,
+                            ]);
+                            audioGraph.connect([
+                                source,
+                                ...otherNodes,
+                                destination,
+                            ]);
+                            audioGraph.releaseInit(props.denoiseNode);
+                            props.denoiseNode = undefined;
+                        }
+                    }
+                    const analyzer = createAnalyzer();
+                    if (analyzer) {
+                        audioGraph.connect([source, analyzer]);
+                    }
+                    else {
+                        if (props.analyzer) {
+                            audioGraph.disconnect([source, props.analyzer]);
+                            audioGraph.releaseInit(props.analyzer);
+                            props.analyzer = undefined;
+                        }
+                    }
+                }
+                catch (error) {
+                    if (error instanceof Error) {
+                        logger.error({
+                            scope,
+                            constraints: constraints.audio,
+                            features,
+                        }, 'failed to apply audio constraints');
+                    }
+                }
+            });
+            const release = async () => {
+                logger.debug({ scope }, 'Release Media');
+                stopMediaStream(stream);
+                // Release Props
+                await audioGraph.release();
+                await media.release();
+                props.denoiseNode = undefined;
+                props.analyzer = undefined;
+                props.audioGraph = undefined;
+            };
+            const muteAudio = (mute) => {
+                media.muteAudio(mute);
+                muteStreamTrack(stream)(mute, 'audio');
+            };
+            const muteVideo = (mute) => {
+                media.muteVideo(mute);
+                muteStreamTrack(stream)(mute, 'video');
+            };
+            const prevGetSettings = media.getSettings;
+            return wrapToJSON(shallowCopy(media, {
+                stream,
+                applyConstraints,
+                muteAudio,
+                muteVideo,
+                release,
+                getSettings: () => {
+                    const { audio, video } = prevGetSettings();
+                    const denoise = !!props.denoiseNode &&
+                        source.hasConnectedTo(props.denoiseNode);
+                    const asd = !!props.asd;
+                    const vad = !!props.vad;
+                    const contentHint = stream.getAudioTracks().at(0)
+                        ?.contentHint ?? '';
+                    const audioSettings = {
+                        denoise,
+                        asd,
+                        vad,
+                        contentHint,
+                    };
+                    const settings = {
+                        audio: audio.map(settings => ({
+                            ...settings,
+                            ...audioSettings,
+                        })),
+                        video,
+                    };
+                    logger.debug({ scope, settings: audioSettings }, 'get audio processor settings');
+                    return settings;
+                },
+            }));
+        }
+        catch (error) {
+            logger.error({ scope, error }, 'Unable to use WebAudio, return the raw media instead');
+            return media;
+        }
+    };
+};

package/dist/baseLogger.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Log meta and message with respective log level
+ */
+export type LogMethod = (meta: unknown, message?: string) => void;
+export declare enum LogLevels {
+    trace = 10,
+    debug = 20,
+    info = 30,
+    warn = 40,
+    error = 50,
+    fatal = 60,
+    silent
+}
+export type LogLevelsString = keyof typeof LogLevels;
+export type LogMethods = {
+    [key in LogLevelsString]: LogMethod;
+};
+/**
+ * Log Level from high to low, "fatal" | "error" | "warn" | "info" | "debug" | "trace"
+ * Typically, debug and trace logs are only valid for development, and not needed in production
+ */
+export interface Logger extends LogMethods {
+    /**
+     * Adds a value to the redaction set, which makes it replaced by [REDACTED] when logged to file.
+     *
+     * @remarks
+     * The redaction set is applied globally, and only applies to the log file, not console logs.
+     *
+     * @param value - the string to redact
+     */
+    redact(value: string): void;
+}
+/**
+ * Create a logger with console API, and map fatal to error, skipping trace
+ * and silent, and there is no redaction
+ */
+export declare function createConsoleLogger(): Readonly<Logger>;