@distrohelena/canton-typescript-sdk 0.1.4 → 0.1.6

package/dist/debugger/index.js

@@ -0,0 +1,31 @@
+export { LedgerReplayDebuggerClient } from "./ledger-replay-debugger-client.js";
+export { ReplayDeterminismException } from "./errors/replay-determinism.exception.js";
+export { ReplayMissingPackageException } from "./errors/replay-missing-package.exception.js";
+export { ReplayMissingSourceException } from "./errors/replay-missing-source.exception.js";
+export { ReplaySourceMapException } from "./errors/replay-source-map.exception.js";
+export { ReplayStateHydrationException } from "./errors/replay-state-hydration.exception.js";
+export { ReplayUnsupportedLfConstructException } from "./errors/replay-unsupported-lf-construct.exception.js";
+export { ReplayUnsupportedUpdateException } from "./errors/replay-unsupported-update.exception.js";
+export { LedgerReplaySessionLoader } from "./replay/ledger-replay-session-loader.js";
+export { LedgerReplayEnvironmentBuilder } from "./replay/ledger-replay-environment-builder.js";
+export { ReplayArtifactResolver } from "./replay/replay-artifact-resolver.js";
+export { ReplayDeterminismValidator } from "./replay/replay-determinism-validator.js";
+export { ReplayEntrypointDefinitionResolver } from "./replay/replay-entrypoint-definition-resolver.js";
+export { ReplayEntrypoint } from "./replay/replay-entrypoint.js";
+export { ReplayUpdateLoader } from "./replay/replay-update-loader.js";
+export { ReplayPhase } from "./session/replay-phase.js";
+export { InMemoryReplaySessionStore } from "./session/in-memory-replay-session-store.js";
+export { ReplaySession } from "./session/replay-session.js";
+export { ReplaySessionMetadata } from "./session/replay-session-metadata.js";
+export { ReplaySessionRequest } from "./session/replay-session-request.js";
+export { ReplaySourceLocation } from "./session/replay-source-location.js";
+export { ReplayScope } from "./session/replay-scope.js";
+export { ReplayStackFrame } from "./session/replay-stack-frame.js";
+export { ReplayStateDelta } from "./session/replay-state-delta.js";
+export { ReplayStep } from "./session/replay-step.js";
+export { ReplayStepAdvanceResult } from "./session/replay-step-advance-result.js";
+export { ReplayValuePreview } from "./session/replay-value-preview.js";
+export { DamlSourceMapper } from "./source/daml-source-mapper.js";
+export { DarSourceMapMetadata } from "./source/dar-source-map-metadata.js";
+export { SourceMappingPrecision, } from "./source/source-mapping-precision.js";
+export { SourceIndexedCompilation, } from "./source/source-indexed-compilation.js";

package/dist/debugger/ledger-replay-debugger-client.d.ts

@@ -0,0 +1,31 @@
+import { ReplaySession } from "./session/replay-session.js";
+import { ReplaySessionMetadata } from "./session/replay-session-metadata.js";
+import { ReplaySessionRequest } from "./session/replay-session-request.js";
+import { ReplayScope } from "./session/replay-scope.js";
+import { ReplayStackFrame } from "./session/replay-stack-frame.js";
+import { ReplayStep } from "./session/replay-step.js";
+import { ReplayStepAdvanceResult } from "./session/replay-step-advance-result.js";
+import { InMemoryReplaySessionStore } from "./session/in-memory-replay-session-store.js";
+import { LedgerReplaySessionLoader } from "./replay/ledger-replay-session-loader.js";
+export declare class LedgerReplayDebuggerClient {
+    private readonly dependencies;
+    private readonly sessionStore;
+    constructor(dependencies: {
+        sessionLoader: LedgerReplaySessionLoader;
+        sessionStore?: InMemoryReplaySessionStore;
+    });
+    loadSessionAsync(request: ReplaySessionRequest): Promise<ReplaySession>;
+    getSessionMetadataAsync(sessionId: string): Promise<ReplaySessionMetadata>;
+    getCurrentStepAsync(sessionId: string): Promise<ReplayStep>;
+    stepIntoAsync(sessionId: string): Promise<ReplayStepAdvanceResult>;
+    stepBackAsync(sessionId: string): Promise<ReplayStepAdvanceResult>;
+    stepOverAsync(sessionId: string): Promise<ReplayStepAdvanceResult>;
+    stepOutAsync(sessionId: string): Promise<ReplayStepAdvanceResult>;
+    continueAsync(sessionId: string): Promise<ReplayStepAdvanceResult>;
+    jumpToStepAsync(sessionId: string, stepId: string): Promise<ReplayStepAdvanceResult>;
+    getStackAsync(sessionId: string): Promise<readonly ReplayStackFrame[]>;
+    getScopesAsync(sessionId: string, frameId: string): Promise<readonly ReplayScope[]>;
+    getTraceSliceAsync(sessionId: string, startIndex: number, endIndex: number): Promise<readonly ReplayStep[]>;
+    disposeSessionAsync(sessionId: string): Promise<void>;
+    private getStore;
+}

package/dist/debugger/ledger-replay-debugger-client.js

@@ -0,0 +1,53 @@
+import { InMemoryReplaySessionStore } from "./session/in-memory-replay-session-store.js";
+export class LedgerReplayDebuggerClient {
+    dependencies;
+    sessionStore;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+        this.sessionStore =
+            this.dependencies.sessionStore ?? new InMemoryReplaySessionStore();
+    }
+    async loadSessionAsync(request) {
+        const loadedSession = await this.dependencies.sessionLoader.loadOrThrowAsync(request);
+        return this.getStore().put(loadedSession);
+    }
+    async getSessionMetadataAsync(sessionId) {
+        return this.getStore().getSessionMetadataOrThrow(sessionId);
+    }
+    async getCurrentStepAsync(sessionId) {
+        return this.getStore().getCurrentStepOrThrow(sessionId);
+    }
+    async stepIntoAsync(sessionId) {
+        return this.getStore().advanceIntoOrThrow(sessionId);
+    }
+    async stepBackAsync(sessionId) {
+        return this.getStore().advanceBackOrThrow(sessionId);
+    }
+    async stepOverAsync(sessionId) {
+        return this.getStore().advanceOverOrThrow(sessionId);
+    }
+    async stepOutAsync(sessionId) {
+        return this.getStore().advanceOutOrThrow(sessionId);
+    }
+    async continueAsync(sessionId) {
+        return this.getStore().continueOrThrow(sessionId);
+    }
+    async jumpToStepAsync(sessionId, stepId) {
+        return this.getStore().setCurrentStepByIdOrThrow(sessionId, stepId);
+    }
+    async getStackAsync(sessionId) {
+        return this.getStore().getStackOrThrow(sessionId);
+    }
+    async getScopesAsync(sessionId, frameId) {
+        return this.getStore().getScopesOrThrow(sessionId, frameId);
+    }
+    async getTraceSliceAsync(sessionId, startIndex, endIndex) {
+        return this.getStore().getTraceSliceOrThrow(sessionId, startIndex, endIndex);
+    }
+    async disposeSessionAsync(sessionId) {
+        this.getStore().dispose(sessionId);
+    }
+    getStore() {
+        return this.sessionStore;
+    }
+}

package/dist/debugger/replay/ledger-replay-environment-builder.d.ts

@@ -0,0 +1,95 @@
+import { GetContractRequest } from "../../core/types/requests/get-contract-request.js";
+import { GetEventsByContractIdRequest } from "../../core/types/requests/get-events-by-contract-id-request.js";
+import { GetContractResponse } from "../../core/types/responses/get-contract-response.js";
+import { GetEventsByContractIdResponse } from "../../core/types/responses/get-events-by-contract-id-response.js";
+import { ReplayEntrypoint } from "./replay-entrypoint.js";
+interface IReplayContractService {
+    getContractAsync(request: GetContractRequest): Promise<GetContractResponse>;
+}
+interface IReplayEventQueryService {
+    getEventsByContractIdAsync(request: GetEventsByContractIdRequest): Promise<GetEventsByContractIdResponse>;
+}
+interface IReplayIdentifier {
+    packageId?: string;
+    moduleName?: string;
+    entityName?: string;
+}
+interface IReplayCreatedEvent {
+    contractId?: string;
+    templateId?: IReplayIdentifier;
+    createArguments?: unknown;
+}
+interface IReplayExercisedEvent {
+    contractId?: string;
+    templateId?: IReplayIdentifier;
+    choice?: string;
+    choiceArgument?: unknown;
+}
+interface IReplayArchivedEvent {
+    contractId?: string;
+    templateId?: IReplayIdentifier;
+}
+interface IReplayTransactionEvent {
+    event?: {
+        oneofKind?: string;
+        created?: IReplayCreatedEvent;
+        exercised?: IReplayExercisedEvent;
+        archived?: IReplayArchivedEvent;
+    };
+}
+export interface IReplayTransactionSnapshot {
+    readonly kind: "transaction";
+    readonly offset: string;
+    readonly updateId?: string;
+    readonly actAs?: readonly string[];
+    readonly readAs?: readonly string[];
+    readonly events: readonly IReplayTransactionEvent[];
+    readonly entrypoint: ReplayEntrypoint;
+}
+export interface IHydratedReplayHistoryEntry {
+    readonly contractId?: string;
+    readonly templateId?: IReplayIdentifier;
+    readonly payload?: unknown;
+    readonly rawEvent?: unknown;
+}
+export interface IHydratedReplayContract {
+    readonly contractId: string;
+    readonly templateId?: IReplayIdentifier;
+    readonly payload: unknown;
+    readonly rawCreatedEvent?: unknown;
+    readonly synchronizerId?: string;
+    readonly history: {
+        readonly created?: IHydratedReplayHistoryEntry;
+        readonly archived?: IHydratedReplayHistoryEntry;
+    };
+}
+export interface ILedgerReplayEnvironment {
+    readonly kind: "transaction";
+    readonly offset: string;
+    readonly updateId?: string;
+    readonly actAs: readonly string[];
+    readonly readAs: readonly string[];
+    readonly entrypoint: ReplayEntrypoint;
+    readonly contracts: ReadonlyMap<string, IHydratedReplayContract>;
+    readonly packageIds: readonly string[];
+}
+export declare class LedgerReplayEnvironmentBuilder {
+    private readonly dependencies;
+    constructor(dependencies: {
+        contractService: IReplayContractService;
+        eventQueryService: IReplayEventQueryService;
+        queryingParties?: readonly string[];
+    });
+    buildOrThrowAsync(snapshot: IReplayTransactionSnapshot): Promise<ILedgerReplayEnvironment>;
+    private getVisibleCreatedContracts;
+    private getRequiredContractIds;
+    private addReferencedContractIds;
+    private hydrateContractOrThrowAsync;
+    private getQueryingParties;
+    private addPackageId;
+    private asCreatedEvent;
+    private asArchivedEvent;
+    private readObjectProperty;
+    private readObjectString;
+}
+export {};

package/dist/debugger/replay/ledger-replay-environment-builder.js

@@ -0,0 +1,249 @@
+import { GetContractRequest } from "../../core/types/requests/get-contract-request.js";
+import { GetEventsByContractIdRequest } from "../../core/types/requests/get-events-by-contract-id-request.js";
+import { ReplayStateHydrationException } from "../errors/replay-state-hydration.exception.js";
+import { attachReplayRecordId, collectReplayLedgerContractIds, normalizeReplayLedgerValue, } from "./replay-ledger-value-normalizer.js";
+import { ReplayEntrypoint } from "./replay-entrypoint.js";
+export class LedgerReplayEnvironmentBuilder {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async buildOrThrowAsync(snapshot) {
+        const packageIds = new Set();
+        const contracts = new Map();
+        const pendingContractIds = new Set(this.getRequiredContractIds(snapshot));
+        const normalizedEntrypointArgument = normalizeReplayLedgerValue(snapshot.entrypoint.argument);
+        for (const visibleContract of this.getVisibleCreatedContracts(snapshot)) {
+            this.addPackageId(packageIds, visibleContract.templateId?.packageId);
+            contracts.set(visibleContract.contractId, visibleContract);
+            this.addReferencedContractIds(pendingContractIds, visibleContract.payload);
+        }
+        this.addReferencedContractIds(pendingContractIds, normalizedEntrypointArgument);
+        while (pendingContractIds.size > 0) {
+            const contractId = pendingContractIds.values().next().value;
+            if (contractId === undefined) {
+                break;
+            }
+            pendingContractIds.delete(contractId);
+            if (contracts.has(contractId)) {
+                continue;
+            }
+            const hydratedContract = await this.hydrateContractOrThrowAsync(contractId, snapshot);
+            this.addPackageId(packageIds, hydratedContract.templateId?.packageId);
+            contracts.set(contractId, hydratedContract);
+            this.addReferencedContractIds(pendingContractIds, hydratedContract.payload);
+        }
+        this.addPackageId(packageIds, snapshot.entrypoint.templateId?.packageId);
+        return {
+            kind: snapshot.kind,
+            offset: snapshot.offset,
+            updateId: snapshot.updateId,
+            actAs: [...(snapshot.actAs ?? [])],
+            readAs: [...(snapshot.readAs ?? [])],
+            entrypoint: new ReplayEntrypoint({
+                kind: snapshot.entrypoint.kind,
+                templateId: snapshot.entrypoint.templateId,
+                contractId: snapshot.entrypoint.contractId,
+                choice: snapshot.entrypoint.choice,
+                argument: normalizedEntrypointArgument,
+            }),
+            contracts,
+            packageIds: [...packageIds].sort(),
+        };
+    }
+    getVisibleCreatedContracts(snapshot) {
+        return snapshot.events.flatMap((event) => {
+            if (event.event?.oneofKind !== "created"
+                || event.event.created?.contractId === undefined) {
+                return [];
+            }
+            return [
+                {
+                    contractId: event.event.created.contractId,
+                    templateId: event.event.created.templateId,
+                    payload: attachReplayRecordId(normalizeReplayLedgerValue(event.event.created.createArguments), event.event.created.templateId === undefined
+                        ? undefined
+                        : {
+                            packageId: event.event.created.templateId.packageId,
+                            moduleName: event.event.created.templateId.moduleName,
+                            entityName: event.event.created.templateId.entityName,
+                        }),
+                    rawCreatedEvent: event.event.created,
+                    history: {
+                        created: {
+                            contractId: event.event.created.contractId,
+                            templateId: event.event.created.templateId,
+                            payload: attachReplayRecordId(normalizeReplayLedgerValue(event.event.created.createArguments), event.event.created.templateId === undefined
+                                ? undefined
+                                : {
+                                    packageId: event.event.created.templateId.packageId,
+                                    moduleName: event.event.created.templateId.moduleName,
+                                    entityName: event.event.created.templateId.entityName,
+                                }),
+                            rawEvent: event.event.created,
+                        },
+                    },
+                },
+            ];
+        });
+    }
+    getRequiredContractIds(snapshot) {
+        const contractIds = new Set();
+        if (snapshot.entrypoint.kind === "exercise"
+            && snapshot.entrypoint.contractId !== undefined) {
+            contractIds.add(snapshot.entrypoint.contractId);
+        }
+        for (const event of snapshot.events) {
+            const contractId = event.event?.exercised?.contractId;
+            if (contractId !== undefined) {
+                contractIds.add(contractId);
+            }
+        }
+        return [...contractIds];
+    }
+    addReferencedContractIds(contractIds, value) {
+        for (const contractId of collectReplayLedgerContractIds(value)) {
+            if (contractId.length > 0) {
+                contractIds.add(contractId);
+            }
+        }
+    }
+    async hydrateContractOrThrowAsync(contractId, snapshot) {
+        const queryingParties = this.getQueryingParties(snapshot);
+        let contractResponse;
+        try {
+            contractResponse =
+                await this.dependencies.contractService.getContractAsync(new GetContractRequest({
+                    contractId,
+                    queryingParties,
+                }));
+        }
+        catch {
+            contractResponse = undefined;
+        }
+        const eventHistory = await this.dependencies.eventQueryService.getEventsByContractIdAsync(new GetEventsByContractIdRequest({
+            contractId,
+            eventFormat: createReplayEventFormat(queryingParties),
+        }));
+        const createdEvent = this.asCreatedEvent(contractResponse?.createdEvent);
+        const createdHistory = this.asCreatedEvent(eventHistory.created?.createdEvent);
+        const archivedHistory = this.asArchivedEvent(eventHistory.archived?.archivedEvent);
+        const materializedCreatedEvent = [
+            createdEvent,
+            createdHistory,
+        ].find((event) => event?.contractId !== undefined
+            && event.createArguments !== undefined);
+        if (materializedCreatedEvent?.contractId === undefined) {
+            throw new ReplayStateHydrationException(`could not hydrate contract '${contractId}' from the ledger`);
+        }
+        if (materializedCreatedEvent.createArguments === undefined) {
+            throw new ReplayStateHydrationException(`contract '${contractId}' did not expose a visible payload`);
+        }
+        return {
+            contractId,
+            templateId: materializedCreatedEvent.templateId,
+            payload: attachReplayRecordId(normalizeReplayLedgerValue(materializedCreatedEvent.createArguments), materializedCreatedEvent.templateId === undefined
+                ? undefined
+                : {
+                    packageId: materializedCreatedEvent.templateId.packageId,
+                    moduleName: materializedCreatedEvent.templateId.moduleName,
+                    entityName: materializedCreatedEvent.templateId.entityName,
+                }),
+            rawCreatedEvent: materializedCreatedEvent,
+            synchronizerId: eventHistory.created?.synchronizerId,
+            history: {
+                created: (createdHistory ?? materializedCreatedEvent) === undefined
+                    ? undefined
+                    : {
+                        contractId: (createdHistory ?? materializedCreatedEvent)
+                            .contractId,
+                        templateId: (createdHistory ?? materializedCreatedEvent)
+                            .templateId,
+                        payload: attachReplayRecordId(normalizeReplayLedgerValue((createdHistory ?? materializedCreatedEvent)
+                            .createArguments), (createdHistory ?? materializedCreatedEvent)
+                            .templateId === undefined
+                            ? undefined
+                            : {
+                                packageId: (createdHistory
+                                    ?? materializedCreatedEvent).templateId?.packageId,
+                                moduleName: (createdHistory
+                                    ?? materializedCreatedEvent).templateId?.moduleName,
+                                entityName: (createdHistory
+                                    ?? materializedCreatedEvent).templateId?.entityName,
+                            }),
+                        rawEvent: createdHistory ?? materializedCreatedEvent,
+                    },
+                archived: archivedHistory === undefined
+                    ? undefined
+                    : {
+                        contractId: archivedHistory.contractId,
+                        templateId: archivedHistory.templateId,
+                        rawEvent: archivedHistory,
+                    },
+            },
+        };
+    }
+    getQueryingParties(snapshot) {
+        const configuredParties = this.dependencies.queryingParties ?? [];
+        if (configuredParties.length > 0) {
+            return [...new Set(configuredParties)];
+        }
+        return [
+            ...new Set([...(snapshot.actAs ?? []), ...(snapshot.readAs ?? [])]),
+        ];
+    }
+    addPackageId(packageIds, packageId) {
+        if (packageId !== undefined && packageId.length > 0) {
+            packageIds.add(packageId);
+        }
+    }
+    asCreatedEvent(value) {
+        if (value === undefined || value === null || typeof value !== "object") {
+            return undefined;
+        }
+        return value;
+    }
+    asArchivedEvent(value) {
+        if (value === undefined || value === null || typeof value !== "object") {
+            return undefined;
+        }
+        return value;
+    }
+    readObjectProperty(value, propertyName) {
+        if (value === null || value === undefined || typeof value !== "object") {
+            return undefined;
+        }
+        return value[propertyName];
+    }
+    readObjectString(value, propertyName) {
+        const property = this.readObjectProperty(value, propertyName);
+        return typeof property === "string" ? property : "";
+    }
+}
+function createReplayEventFormat(visibleParties) {
+    const wildcardFilter = {
+        cumulative: [
+            {
+                identifierFilter: {
+                    oneofKind: "wildcardFilter",
+                    wildcardFilter: {
+                        includeCreatedEventBlob: true,
+                    },
+                },
+            },
+        ],
+    };
+    if (Array.isArray(visibleParties) && visibleParties.length > 0) {
+        return {
+            filtersByParty: Object.fromEntries([...new Set(visibleParties)]
+                .filter((party) => typeof party === "string" && party.length > 0)
+                .map((party) => [party, wildcardFilter])),
+            verbose: true,
+        };
+    }
+    return {
+        filtersByParty: {},
+        filtersForAnyParty: wildcardFilter,
+        verbose: true,
+    };
+}

package/dist/debugger/replay/ledger-replay-session-loader.d.ts

@@ -0,0 +1,78 @@
+import { DamlLfValueDefinition } from "../../daml-lf/model/daml-lf-value-definition.js";
+import { IDamlLfReplayEffect, IDamlLfTraceSink } from "../../daml-lf/interpreter/daml-lf-trace-sink.interface.js";
+import { IDamlLfReplayEnvironment, IDamlLfReplayEvaluationResult } from "../../daml-lf/interpreter/daml-lf-evaluator.js";
+import { ReplayScope } from "../session/replay-scope.js";
+import { ReplaySessionMetadata } from "../session/replay-session-metadata.js";
+import { ReplayStep } from "../session/replay-step.js";
+import { ILedgerReplayEnvironment, IReplayTransactionSnapshot } from "./ledger-replay-environment-builder.js";
+import { ResolvedReplayEntrypointDefinition } from "./replay-entrypoint-definition-resolver.js";
+import { ReplaySessionRequest } from "../session/replay-session-request.js";
+import { DamlSourceMapper } from "../source/daml-source-mapper.js";
+import { DamlLfTemplateId } from "../../daml-lf/model/daml-lf-template-id.js";
+interface IReplayUpdateLoader {
+    loadOrThrowAsync(offset: string): Promise<IReplayTransactionSnapshot>;
+}
+interface IReplayEnvironmentBuilder {
+    buildOrThrowAsync(snapshot: IReplayTransactionSnapshot): Promise<ILedgerReplayEnvironment>;
+}
+interface IReplayDefinitionResolver {
+    resolveEntrypointDefinitionOrThrow(entrypoint: IReplayTransactionSnapshot["entrypoint"]): ResolvedReplayEntrypointDefinition;
+    resolveChoiceDefinitionOrThrow?(templateId: DamlLfTemplateId, choiceName: string): ResolvedReplayEntrypointDefinition;
+}
+interface IReplayEvaluator {
+    evaluateReplayEntrypointOrThrow(definition: DamlLfValueDefinition, environment: IDamlLfReplayEnvironment, traceSink?: IDamlLfTraceSink): IDamlLfReplayEvaluationResult;
+}
+interface IReplayDeterminismValidator {
+    validateOrThrow(snapshot: IReplayTransactionSnapshot, replayedEffects: readonly IDamlLfReplayEffect[]): void;
+}
+export interface ILoadedReplaySession {
+    readonly sessionId: string;
+    readonly metadata: ReplaySessionMetadata;
+    readonly steps: readonly ReplayStep[];
+    readonly scopesByStep: readonly (readonly ReplayScope[])[];
+    readonly currentStepIndex: number;
+}
+export declare class LedgerReplaySessionLoader {
+    private readonly dependencies;
+    constructor(dependencies: {
+        updateLoader: IReplayUpdateLoader;
+        environmentBuilder: IReplayEnvironmentBuilder;
+        definitionResolver: IReplayDefinitionResolver;
+        sourceMapper?: DamlSourceMapper;
+        evaluator: IReplayEvaluator;
+        determinismValidator: IReplayDeterminismValidator;
+        sessionIdFactory?: () => string;
+    });
+    loadOrThrowAsync(request: ReplaySessionRequest): Promise<ILoadedReplaySession>;
+    private projectReplaySteps;
+    private projectRawReplaySteps;
+    private projectNavigableReplaySteps;
+    private createSourceLocationKey;
+    private createVisibleExpressionKey;
+    private shouldRetainDefinitionTransition;
+    private shouldRetainExpressionStep;
+    private hasVisibleLocalsChange;
+    private isMeaningfulDebuggerExpression;
+    private isMeaningfulDefinitionExpression;
+    private toReplayPhase;
+    private createValuePreview;
+    private createStateDelta;
+    private stringifyRuntimeValue;
+    private rememberFrameScope;
+    private createContractTypeIndex;
+    private rememberStateEffectContractType;
+    private resolveRuntimeValueContractType;
+    private formatTemplateType;
+    private prepareStackForStep;
+    private finalizeStackForStep;
+    private pushFrameIfMissing;
+    private popFrameIfTop;
+    private cloneScope;
+    private resolveFrameName;
+    private isGeneratedHelperDefinitionName;
+    private formatGeneratedHelperLabel;
+    private formatExecutableFrameLabel;
+    private formatReplayEffectFrameLabel;
+    private createSourceLocation;
+}
+export {};