@motiadev/core 0.2.2 → 0.3.0-beta.79

package/dist/src/helper/flows-helper.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFlow = void 0;
+const guards_1 = require("../guards");
+const crypto_1 = require("crypto");
+const get_step_language_1 = require("../get-step-language");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const getNodeComponentPath = (filePath) => {
+    const filePathWithoutExtension = filePath.replace(/\.[^/.]+$/, '');
+    const tsxPath = filePathWithoutExtension + '.tsx';
+    return fs_1.default.existsSync(tsxPath) ? tsxPath : undefined;
+};
+const getRelativePath = (filePath) => {
+    const baseDir = process.cwd();
+    return path_1.default.relative(baseDir, filePath);
+};
+const createEdge = (sourceId, targetId, topic, label, variant, conditional) => ({
+    id: `${sourceId}-${targetId}`,
+    source: sourceId,
+    target: targetId,
+    data: {
+        variant,
+        label,
+        topic,
+        labelVariant: conditional ? 'conditional' : 'default',
+    },
+});
+const processEmit = (emit) => {
+    const isString = typeof emit === 'string';
+    return {
+        topic: isString ? emit : emit.topic,
+        label: isString ? undefined : emit.label,
+        conditional: isString ? undefined : emit.conditional,
+    };
+};
+const createEdgesForEmits = (sourceStep, targetSteps, emits, variant) => {
+    const edges = [];
+    emits.forEach((emit) => {
+        const { topic, label, conditional } = processEmit(emit);
+        targetSteps.forEach((targetStep) => {
+            if (targetStep.subscribes?.includes(topic)) {
+                edges.push(createEdge(sourceStep.id, targetStep.id, topic, label, variant, conditional));
+            }
+        });
+    });
+    return edges;
+};
+const createBaseStepResponse = (step, id) => ({
+    id,
+    name: step.config.name,
+    description: step.config.description,
+    nodeComponentPath: getNodeComponentPath(step.filePath),
+    filePath: getRelativePath(step.filePath),
+    language: (0, get_step_language_1.getStepLanguage)(step.filePath),
+});
+const createApiStepResponse = (step, id) => {
+    if (!(0, guards_1.isApiStep)(step)) {
+        throw new Error('Attempted to create API step response with non-API step');
+    }
+    return {
+        ...createBaseStepResponse(step, id),
+        type: 'api',
+        emits: step.config.emits,
+        virtualEmits: step.config.virtualEmits ?? [],
+        subscribes: step.config.virtualSubscribes ?? undefined,
+        action: 'webhook',
+        webhookUrl: `${step.config.method} ${step.config.path}`,
+        bodySchema: step.config.bodySchema ?? undefined,
+    };
+};
+const createEventStepResponse = (step, id) => {
+    if (!(0, guards_1.isEventStep)(step)) {
+        throw new Error('Attempted to create Event step response with non-Event step');
+    }
+    return {
+        ...createBaseStepResponse(step, id),
+        type: 'event',
+        emits: step.config.emits,
+        virtualEmits: step.config.virtualEmits ?? [],
+        subscribes: step.config.subscribes,
+    };
+};
+const createNoopStepResponse = (step, id) => {
+    if (!(0, guards_1.isNoopStep)(step)) {
+        throw new Error('Attempted to create Noop step response with non-Noop step');
+    }
+    return {
+        ...createBaseStepResponse(step, id),
+        type: 'noop',
+        emits: [],
+        virtualEmits: step.config.virtualEmits,
+        subscribes: step.config.virtualSubscribes,
+    };
+};
+const createCronStepResponse = (step, id) => {
+    if (!(0, guards_1.isCronStep)(step)) {
+        throw new Error('Attempted to create Cron step response with non-Cron step');
+    }
+    return {
+        ...createBaseStepResponse(step, id),
+        type: 'cron',
+        emits: step.config.emits,
+        cronExpression: step.config.cron,
+    };
+};
+const createStepResponse = (step) => {
+    const id = (0, crypto_1.randomUUID)();
+    if ((0, guards_1.isApiStep)(step))
+        return createApiStepResponse(step, id);
+    if ((0, guards_1.isEventStep)(step))
+        return createEventStepResponse(step, id);
+    if ((0, guards_1.isNoopStep)(step))
+        return createNoopStepResponse(step, id);
+    if ((0, guards_1.isCronStep)(step))
+        return createCronStepResponse(step, id);
+    throw new Error(`Unknown step type for step: ${step.config.name}`);
+};
+const createEdgesForStep = (sourceStep, allSteps) => {
+    const regularEdges = createEdgesForEmits(sourceStep, allSteps, sourceStep.emits, 'event');
+    const virtualEdges = sourceStep.virtualEmits
+        ? createEdgesForEmits(sourceStep, allSteps, sourceStep.virtualEmits, 'virtual')
+        : [];
+    return [...regularEdges, ...virtualEdges];
+};
+const generateFlow = (flowId, flowSteps) => {
+    const steps = flowSteps.map(createStepResponse);
+    const edges = steps.flatMap((step) => createEdgesForStep(step, steps));
+    return { id: flowId, name: flowId, steps, edges };
+};
+exports.generateFlow = generateFlow;

package/dist/src/locked-data.d.ts

@@ -9,18 +9,17 @@ type StreamWrapper<TData> = (streamName: string, factory: StreamFactory<TData>)
 export declare class LockedData {
     readonly baseDir: string;
     private readonly streamAdapter;
+    private readonly printer;
     flows: Record<string, Flow>;
     activeSteps: Step[];
     devSteps: Step[];
-    printer: Printer;
     private stepsMap;
     private handlers;
     private stepHandlers;
     private streamHandlers;
     private streams;
     private streamWrapper?;
-    constructor(baseDir: string, streamAdapter?: 'file' | 'memory');
-    disablePrinter(): void;
+    constructor(baseDir: string, streamAdapter: "file" | "memory" | undefined, printer: Printer);
     applyStreamWrapper<TData>(streamWrapper: StreamWrapper<TData>): void;
     saveTypes(): void;
     on(event: FlowEvent, handler: (flowName: string) => void): void;

package/dist/src/locked-data.js

@@ -7,20 +7,19 @@ exports.LockedData = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const guards_1 = require("./guards");
-const printer_1 = require("./printer");
 const step_validator_1 = require("./step-validator");
 const file_stream_adapter_1 = require("./streams/adapters/file-stream-adapter");
 const memory_stream_adapter_1 = require("./streams/adapters/memory-stream-adapter");
 const generate_types_1 = require("./types/generate-types");
 class LockedData {
-    constructor(baseDir, streamAdapter = 'file') {
+    constructor(baseDir, streamAdapter = 'file', printer) {
         this.baseDir = baseDir;
         this.streamAdapter = streamAdapter;
+        this.printer = printer;
         this.flows = {};
         this.activeSteps = [];
         this.devSteps = [];
         this.stepsMap = {};
-        this.printer = new printer_1.Printer(baseDir);
         this.handlers = {
             'flow-created': [],
             'flow-removed': [],
@@ -38,9 +37,6 @@ class LockedData {
         };
         this.streams = {};
     }
-    disablePrinter() {
-        this.printer = new printer_1.NoPrinter(this.baseDir);
-    }
     applyStreamWrapper(streamWrapper) {
         this.streamWrapper = streamWrapper;
     }
@@ -107,6 +103,7 @@ class LockedData {
         const addedFlows = newStep.config.flows?.filter((flowName) => !oldStep.config.flows?.includes(flowName)) ?? [];
         const removedFlows = oldStep.config.flows?.filter((flowName) => !newStep.config.flows?.includes(flowName)) ?? [];
         const untouchedFlows = oldStep.config.flows?.filter((flowName) => newStep.config.flows?.includes(flowName)) ?? [];
+        savedStep.config = newStep.config;
         untouchedFlows.forEach((flowName) => this.onFlowUpdated(flowName));
         for (const flowName of addedFlows) {
             if (!this.flows[flowName]) {
@@ -128,7 +125,6 @@ class LockedData {
                 this.onFlowUpdated(flowName);
             }
         }
-        savedStep.config = newStep.config;
         if (!options.disableTypeCreation) {
             this.saveTypes();
         }

package/dist/src/logger-factory.d.ts

@@ -6,7 +6,10 @@ type CreateLogger = {
     flows?: string[];
     stepName: string;
 };
-export declare class LoggerFactory {
+export interface LoggerFactory {
+    create: (args: CreateLogger) => Logger;
+}
+export declare class BaseLoggerFactory implements LoggerFactory {
     private readonly isVerbose;
     private readonly logStream;
     constructor(isVerbose: boolean, logStream: StreamAdapter<Log>);

package/dist/src/logger-factory.js

@@ -1,14 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoggerFactory = void 0;
+exports.BaseLoggerFactory = void 0;
+const crypto_1 = require("crypto");
 const logger_1 = require("./logger");
-class LoggerFactory {
+class BaseLoggerFactory {
     constructor(isVerbose, logStream) {
         this.isVerbose = isVerbose;
         this.logStream = logStream;
     }
     create({ stepName, traceId, flows }) {
-        return new logger_1.Logger(traceId, flows, stepName, this.isVerbose, this.logStream);
+        const streamListener = (level, msg, args) => {
+            const id = (0, crypto_1.randomUUID)();
+            this.logStream.set('default', id, {
+                id,
+                ...(args ?? {}),
+                level,
+                time: Date.now(),
+                msg,
+                traceId,
+                flows: flows ?? [],
+            });
+        };
+        return new logger_1.Logger(this.isVerbose, { traceId, flows, step: stepName }, [streamListener]);
     }
 }
-exports.LoggerFactory = LoggerFactory;
+exports.BaseLoggerFactory = BaseLoggerFactory;

package/dist/src/logger.d.ts

@@ -1,29 +1,26 @@
-import { Log } from './streams/logs-stream';
-import { StreamAdapter } from './streams/adapters/stream-adapter';
-export declare class BaseLogger {
+import { Step } from './types';
+export type LogListener = (level: string, msg: string, args?: unknown) => void;
+export declare class Logger {
     readonly isVerbose: boolean;
     private readonly meta;
-    constructor(isVerbose?: boolean, meta?: Record<string, unknown>);
-    child(meta?: Record<string, unknown>): this;
+    private readonly coreListeners;
+    /**
+     * Why do we need two level of listeners?
+     *
+     * Core listeners pass along to children loggers.
+     *
+     * However, base listeners do not pass along to children loggers.
+     * Those are specific to each logger in the hierarchy.
+     */
+    private readonly listeners;
+    constructor(isVerbose?: boolean, meta?: Record<string, unknown>, coreListeners?: LogListener[]);
+    child(step: Step): Logger;
     private _log;
     info(message: string, args?: unknown): void;
     error(message: string, args?: unknown): void;
     debug(message: string, args?: unknown): void;
     warn(message: string, args?: unknown): void;
     log(args: any): void;
+    addListener(listener: LogListener): void;
 }
-export declare class Logger extends BaseLogger {
-    private readonly traceId;
-    private readonly flows;
-    private readonly step;
-    private readonly logStream?;
-    private emitLog;
-    constructor(traceId: string, flows: string[] | undefined, step: string, isVerbose: boolean, logStream?: StreamAdapter<Log> | undefined);
-    child(meta?: Record<string, unknown>): this;
-    log(message: any): void;
-    info: (message: string, args?: unknown) => void;
-    error: (message: string, args?: unknown) => void;
-    debug: (message: string, args?: unknown) => void;
-    warn: (message: string, args?: unknown) => void;
-}
-export declare const globalLogger: BaseLogger;
+export declare const globalLogger: Logger;

package/dist/src/logger.js

@@ -1,24 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.globalLogger = exports.Logger = exports.BaseLogger = void 0;
-const crypto_1 = require("crypto");
+exports.globalLogger = exports.Logger = void 0;
 const pretty_print_1 = require("./pretty-print");
 const logLevel = process.env.LOG_LEVEL ?? 'info';
 const isDebugEnabled = logLevel === 'debug';
 const isInfoEnabled = ['info', 'debug'].includes(logLevel);
 const isWarnEnabled = ['warn', 'info', 'debug', 'trace'].includes(logLevel);
-class BaseLogger {
-    constructor(isVerbose = false, meta = {}) {
+class Logger {
+    constructor(isVerbose = false, meta = {}, coreListeners = []) {
         this.isVerbose = isVerbose;
         this.meta = meta;
-    }
-    child(meta = {}) {
-        return new BaseLogger(this.isVerbose, { ...this.meta, ...meta });
+        this.coreListeners = coreListeners;
+        /**
+         * Why do we need two level of listeners?
+         *
+         * Core listeners pass along to children loggers.
+         *
+         * However, base listeners do not pass along to children loggers.
+         * Those are specific to each logger in the hierarchy.
+         */
+        this.listeners = [];
+    }
+    child(step) {
+        return new Logger(this.isVerbose, { ...this.meta, step: step.config.name }, this.coreListeners);
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     _log(level, msg, args) {
         const time = Date.now();
-        (0, pretty_print_1.prettyPrint)({ level, time, msg, ...this.meta, ...(args ?? {}) }, !this.isVerbose);
+        const meta = { ...this.meta, ...(args ?? {}) };
+        (0, pretty_print_1.prettyPrint)({ level, time, msg, ...meta }, !this.isVerbose);
+        this.coreListeners.forEach((listener) => listener(level, msg, meta));
+        this.listeners.forEach((listener) => listener(level, msg, meta));
     }
     info(message, args) {
         if (isInfoEnabled) {
@@ -42,55 +54,9 @@ class BaseLogger {
     log(args) {
         this._log('info', args.msg, args);
     }
-}
-exports.BaseLogger = BaseLogger;
-class Logger extends BaseLogger {
-    constructor(traceId, flows, step, isVerbose, logStream) {
-        super(isVerbose, { traceId, flows, step });
-        this.traceId = traceId;
-        this.flows = flows;
-        this.step = step;
-        this.logStream = logStream;
-        this.info = (message, args) => {
-            super.info(message, args);
-            this.emitLog('info', message, args);
-        };
-        this.error = (message, args) => {
-            super.error(message, args);
-            this.emitLog('error', message, args);
-        };
-        this.debug = (message, args) => {
-            if (isDebugEnabled) {
-                super.debug(message, args);
-                this.emitLog('debug', message, args);
-            }
-        };
-        this.warn = (message, args) => {
-            super.warn(message, args);
-            this.emitLog('warn', message, args);
-        };
-        this.emitLog = (level, msg, args) => {
-            const id = (0, crypto_1.randomUUID)();
-            this.logStream?.set('default', id, {
-                id,
-                step: this.step,
-                ...(args ?? {}),
-                level,
-                time: Date.now(),
-                msg,
-                traceId: this.traceId,
-                flows: this.flows ?? [],
-            });
-        };
-    }
-    child(meta = {}) {
-        return new Logger(this.traceId, this.flows, meta.step, this.isVerbose, this.logStream);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    log(message) {
-        super.log(message);
-        this.emitLog(message.level, message.msg, message);
+    addListener(listener) {
+        this.listeners.push(listener);
     }
 }
 exports.Logger = Logger;
-exports.globalLogger = new BaseLogger();
+exports.globalLogger = new Logger();

package/dist/src/motia.d.ts

@@ -0,0 +1,13 @@
+import { Printer } from './printer';
+import { TracerFactory } from './observability';
+import { EventManager, InternalStateManager } from './types';
+import { LockedData } from './locked-data';
+import { LoggerFactory } from './logger-factory';
+export type Motia = {
+    loggerFactory: LoggerFactory;
+    eventManager: EventManager;
+    state: InternalStateManager;
+    lockedData: LockedData;
+    printer: Printer;
+    tracerFactory: TracerFactory;
+};

package/dist/src/motia.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/node/node-runner.js

@@ -25,6 +25,7 @@ function parseArgs(arg) {
     }
 }
 async function runTypescriptModule(filePath, event) {
+    const sender = new rpc_1.RpcSender(process);
     try {
         // eslint-disable-next-line @typescript-eslint/no-require-imports
         const module = require(path_1.default.resolve(filePath));
@@ -33,7 +34,6 @@ async function runTypescriptModule(filePath, event) {
             throw new Error(`Function handler not found in module ${filePath}`);
         }
         const { traceId, flows, contextInFirstArg } = event;
-        const sender = new rpc_1.RpcSender(process);
         const logger = new logger_1.Logger(traceId, flows, sender);
         const state = new rpc_state_manager_1.RpcStateManager(sender);
         const emit = async (data) => sender.send('emit', data);
@@ -58,10 +58,21 @@ async function runTypescriptModule(filePath, event) {
         await sender.send('result', result);
         await sender.close();
         process.exit(0);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
     }
-    catch (error) {
-        console.error('Error running TypeScript module:', error);
-        process.exit(1);
+    catch (err) {
+        const stack = err.stack?.split('\n') ?? [];
+        if (stack) {
+            const index = stack.findIndex((line) => line.includes('src/node/node-runner'));
+            stack.splice(index, stack.length - index);
+            stack.splice(0, 1); // remove first line which has the error message
+        }
+        const error = {
+            message: err.message || '',
+            code: err.code || null,
+            stack: stack.join('\n'),
+        };
+        sender.sendNoWait('close', error);
     }
 }
 const [, , filePath, arg] = process.argv;

package/dist/src/observability/create-trace.d.ts

@@ -0,0 +1,3 @@
+import { Step } from '../types';
+import { Trace, TraceGroup } from './types';
+export declare const createTrace: (traceGroup: TraceGroup, step: Step) => Trace;

package/dist/src/observability/create-trace.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTrace = void 0;
+const createTrace = (traceGroup, step) => {
+    const id = crypto.randomUUID();
+    const trace = {
+        id,
+        name: step.config.name,
+        correlationId: traceGroup.correlationId,
+        parentTraceId: traceGroup.id,
+        status: 'running',
+        startTime: Date.now(),
+        endTime: undefined,
+        entryPoint: { type: step.config.type, stepName: step.config.name },
+        events: [],
+    };
+    traceGroup.metadata.totalSteps++;
+    traceGroup.metadata.activeSteps++;
+    return trace;
+};
+exports.createTrace = createTrace;

package/dist/src/observability/index.d.ts

@@ -0,0 +1,13 @@
+import { Logger } from '../logger';
+import { Step } from '../types';
+import { StateOperation, StreamOperation, TraceError } from './types';
+export interface TracerFactory {
+    createTracer(traceId: string, step: Step, logger: Logger): Tracer;
+}
+export interface Tracer {
+    end(err?: TraceError): void;
+    stateOperation(operation: StateOperation, input: unknown): void;
+    emitOperation(topic: string, data: unknown, success: boolean): void;
+    streamOperation(streamName: string, operation: StreamOperation, input: unknown): void;
+    child(step: Step, logger: Logger): Tracer;
+}

package/dist/src/observability/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/observability/no-tracer.d.ts

@@ -0,0 +1,8 @@
+import { Tracer } from '.';
+export declare class NoTracer implements Tracer {
+    end(): void;
+    stateOperation(): void;
+    emitOperation(): void;
+    streamOperation(): void;
+    child(): this;
+}

package/dist/src/observability/no-tracer.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoTracer = void 0;
+class NoTracer {
+    end() { }
+    stateOperation() { }
+    emitOperation() { }
+    streamOperation() { }
+    child() {
+        return this;
+    }
+}
+exports.NoTracer = NoTracer;

package/dist/src/observability/stream-tracer.d.ts

@@ -0,0 +1,21 @@
+import { Tracer } from '.';
+import { Logger } from '../logger';
+import { Step } from '../types';
+import { TraceManager } from './trace-manager';
+import { StateOperation, StreamOperation, Trace, TraceError, TraceGroup } from './types';
+export declare class StreamTracer implements Tracer {
+    private readonly manager;
+    private readonly traceGroup;
+    private readonly trace;
+    constructor(manager: TraceManager, traceGroup: TraceGroup, trace: Trace, logger: Logger);
+    end(err?: TraceError): void;
+    stateOperation(operation: StateOperation, input: unknown): void;
+    emitOperation(topic: string, data: unknown, success: boolean): void;
+    streamOperation(streamName: string, operation: StreamOperation, input: {
+        groupId: string;
+        id: string;
+        data?: unknown;
+    }): void;
+    child(step: Step, logger: Logger): StreamTracer;
+    private addEvent;
+}

package/dist/src/observability/stream-tracer.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamTracer = void 0;
+const create_trace_1 = require("./create-trace");
+class StreamTracer {
+    constructor(manager, traceGroup, trace, logger) {
+        this.manager = manager;
+        this.traceGroup = traceGroup;
+        this.trace = trace;
+        logger.addListener((level, msg, args) => {
+            this.addEvent({
+                type: 'log',
+                timestamp: Date.now(),
+                level,
+                message: msg,
+                metadata: args,
+            });
+        });
+    }
+    end(err) {
+        if (this.trace.endTime) {
+            // avoiding updating twice
+            return;
+        }
+        this.trace.status = err ? 'failed' : 'completed';
+        this.trace.endTime = Date.now();
+        this.trace.error = err;
+        this.traceGroup.metadata.completedSteps++;
+        this.traceGroup.metadata.activeSteps--;
+        if (this.traceGroup.metadata.activeSteps === 0) {
+            if (this.traceGroup.status === 'running') {
+                this.traceGroup.status = 'completed';
+            }
+            this.traceGroup.endTime = Date.now();
+        }
+        if (err) {
+            this.traceGroup.status = 'failed';
+        }
+        this.manager.updateTrace();
+        this.manager.updateTraceGroup();
+    }
+    stateOperation(operation, input) {
+        this.addEvent({
+            type: 'state',
+            timestamp: Date.now(),
+            operation,
+            data: input,
+        });
+    }
+    emitOperation(topic, data, success) {
+        this.addEvent({
+            type: 'emit',
+            timestamp: Date.now(),
+            topic,
+            success,
+            data,
+        });
+    }
+    streamOperation(streamName, operation, input) {
+        if (operation === 'set') {
+            const lastEvent = this.trace.events[this.trace.events.length - 1];
+            if (lastEvent &&
+                lastEvent.type === 'stream' &&
+                lastEvent.streamName === streamName &&
+                lastEvent.data.groupId === input.groupId &&
+                lastEvent.data.id === input.id) {
+                lastEvent.calls++;
+                lastEvent.data.data = input.data;
+                lastEvent.maxTimestamp = Date.now();
+                this.traceGroup.lastActivity = lastEvent.maxTimestamp;
+                this.manager.updateTrace();
+                this.manager.updateTraceGroup();
+                return;
+            }
+        }
+        this.addEvent({
+            type: 'stream',
+            timestamp: Date.now(),
+            operation,
+            data: input,
+            streamName,
+            calls: 1,
+        });
+    }
+    child(step, logger) {
+        const trace = (0, create_trace_1.createTrace)(this.traceGroup, step);
+        const manager = this.manager.child(trace);
+        return new StreamTracer(manager, this.traceGroup, trace, logger);
+    }
+    addEvent(event) {
+        this.trace.events.push(event);
+        this.traceGroup.lastActivity = event.timestamp;
+        this.manager.updateTrace();
+        this.manager.updateTraceGroup();
+    }
+}
+exports.StreamTracer = StreamTracer;

package/dist/src/observability/trace-manager.d.ts

@@ -0,0 +1,12 @@
+import { MotiaStream } from '../types-stream';
+import { Trace, TraceGroup } from './types';
+export declare class TraceManager {
+    private readonly traceStream;
+    private readonly traceGroupStream;
+    private readonly traceGroup;
+    private readonly trace;
+    constructor(traceStream: MotiaStream<Trace>, traceGroupStream: MotiaStream<TraceGroup>, traceGroup: TraceGroup, trace: Trace);
+    updateTrace(): void;
+    updateTraceGroup(): void;
+    child(trace: Trace): TraceManager;
+}