@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/debugger/session/in-memory-replay-session-store.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryReplaySessionStore = void 0;
+const validation_error_js_1 = require("../../core/errors/validation-error.js");
+const replay_session_js_1 = require("./replay-session.js");
+const replay_step_advance_result_js_1 = require("./replay-step-advance-result.js");
+class InMemoryReplaySessionStore {
+    sessions = new Map();
+    put(session) {
+        this.sessions.set(session.sessionId, {
+            ...session,
+            currentStepIndex: session.currentStepIndex,
+        });
+        return this.toReplaySession(this.getRecordOrThrow(session.sessionId));
+    }
+    getSessionMetadataOrThrow(sessionId) {
+        return this.getRecordOrThrow(sessionId).metadata;
+    }
+    getCurrentStepOrThrow(sessionId) {
+        const record = this.getRecordOrThrow(sessionId);
+        return record.steps[record.currentStepIndex];
+    }
+    advanceIntoOrThrow(sessionId) {
+        const record = this.getRecordOrThrow(sessionId);
+        const nextIndex = Math.min(record.currentStepIndex + 1, record.steps.length - 1);
+        record.currentStepIndex = nextIndex;
+        return this.toAdvanceResult(record);
+    }
+    advanceBackOrThrow(sessionId) {
+        const record = this.getRecordOrThrow(sessionId);
+        record.currentStepIndex = Math.max(0, record.currentStepIndex - 1);
+        return this.toAdvanceResult(record);
+    }
+    advanceOverOrThrow(sessionId) {
+        const record = this.getRecordOrThrow(sessionId);
+        const currentStep = record.steps[record.currentStepIndex];
+        if (currentStep.phase !== "call") {
+            return this.advanceIntoOrThrow(sessionId);
+        }
+        record.currentStepIndex = this.findNextIndexOrCurrent(record, (step) => step.stackFrames.length < currentStep.stackFrames.length);
+        return this.toAdvanceResult(record);
+    }
+    advanceOutOrThrow(sessionId) {
+        const record = this.getRecordOrThrow(sessionId);
+        const currentStep = record.steps[record.currentStepIndex];
+        record.currentStepIndex = this.findNextIndexOrCurrent(record, (step) => step.stackFrames.length < currentStep.stackFrames.length);
+        return this.toAdvanceResult(record);
+    }
+    continueOrThrow(sessionId) {
+        const record = this.getRecordOrThrow(sessionId);
+        record.currentStepIndex = record.steps.length - 1;
+        return this.toAdvanceResult(record);
+    }
+    setCurrentStepByIdOrThrow(sessionId, stepId) {
+        const record = this.getRecordOrThrow(sessionId);
+        const nextIndex = record.steps.findIndex((step) => step.stepId === stepId);
+        if (nextIndex < 0) {
+            throw new validation_error_js_1.ValidationError(`unknown replay step '${stepId}'`);
+        }
+        record.currentStepIndex = nextIndex;
+        return this.toAdvanceResult(record);
+    }
+    getStackOrThrow(sessionId) {
+        return this.getCurrentStepOrThrow(sessionId).stackFrames;
+    }
+    getScopesOrThrow(sessionId, frameId) {
+        const currentStep = this.getCurrentStepOrThrow(sessionId);
+        const frame = currentStep.stackFrames.find((candidate) => candidate.frameId === frameId);
+        if (frame === undefined) {
+            return [];
+        }
+        return (this.getRecordOrThrow(sessionId).scopesByStep[this.getRecordOrThrow(sessionId).currentStepIndex] ?? []).filter((scope) => scope.frameId === frameId);
+    }
+    getTraceSliceOrThrow(sessionId, startIndex, endIndex) {
+        return this.getRecordOrThrow(sessionId).steps.slice(startIndex, endIndex);
+    }
+    dispose(sessionId) {
+        this.sessions.delete(sessionId);
+    }
+    getRecordOrThrow(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session === undefined) {
+            throw new validation_error_js_1.ValidationError(`replay session '${sessionId}' does not exist`);
+        }
+        return session;
+    }
+    toReplaySession(session) {
+        return new replay_session_js_1.ReplaySession({
+            sessionId: session.sessionId,
+            metadata: session.metadata,
+            currentStep: session.steps[session.currentStepIndex],
+        });
+    }
+    toAdvanceResult(session) {
+        return new replay_step_advance_result_js_1.ReplayStepAdvanceResult({
+            sessionId: session.sessionId,
+            step: session.steps[session.currentStepIndex],
+            isTerminal: session.currentStepIndex >= session.steps.length - 1,
+            nextStepIndex: session.currentStepIndex >= session.steps.length - 1
+                ? undefined
+                : session.currentStepIndex + 1,
+        });
+    }
+    findNextIndexOrCurrent(session, predicate) {
+        for (let index = session.currentStepIndex + 1; index < session.steps.length; index += 1) {
+            if (predicate(session.steps[index])) {
+                return index;
+            }
+        }
+        return session.steps.length - 1;
+    }
+}
+exports.InMemoryReplaySessionStore = InMemoryReplaySessionStore;

package/dist/cjs/debugger/session/replay-phase.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayPhase = void 0;
+var ReplayPhase;
+(function (ReplayPhase) {
+    ReplayPhase["enterExpression"] = "enterExpression";
+    ReplayPhase["exitExpression"] = "exitExpression";
+    ReplayPhase["call"] = "call";
+    ReplayPhase["return"] = "return";
+    ReplayPhase["stateEffect"] = "stateEffect";
+})(ReplayPhase || (exports.ReplayPhase = ReplayPhase = {}));

package/dist/cjs/debugger/session/replay-scope.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayScope = void 0;
+class ReplayScope {
+    frameId;
+    name;
+    variables;
+    constructor(init) {
+        this.frameId = init?.frameId;
+        this.name = init?.name;
+        this.variables = init?.variables ?? [];
+    }
+}
+exports.ReplayScope = ReplayScope;

package/dist/cjs/debugger/session/replay-session-metadata.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplaySessionMetadata = void 0;
+class ReplaySessionMetadata {
+    sessionId;
+    offset;
+    stepCount;
+    constructor(init) {
+        this.sessionId = init?.sessionId;
+        this.offset = init?.offset;
+        this.stepCount = init?.stepCount;
+    }
+}
+exports.ReplaySessionMetadata = ReplaySessionMetadata;

package/dist/cjs/debugger/session/replay-session-request.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplaySessionRequest = void 0;
+const validation_error_js_1 = require("../../core/errors/validation-error.js");
+class ReplaySessionRequest {
+    offset;
+    constructor(init) {
+        if (!init.offset) {
+            throw new validation_error_js_1.ValidationError("replay session requests require an offset");
+        }
+        this.offset = init.offset;
+    }
+}
+exports.ReplaySessionRequest = ReplaySessionRequest;

package/dist/cjs/debugger/session/replay-session.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplaySession = void 0;
+class ReplaySession {
+    sessionId;
+    metadata;
+    currentStep;
+    constructor(init) {
+        this.sessionId = init?.sessionId;
+        this.metadata = init?.metadata;
+        this.currentStep = init?.currentStep;
+    }
+}
+exports.ReplaySession = ReplaySession;

package/dist/cjs/debugger/session/replay-source-location.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplaySourceLocation = void 0;
+class ReplaySourceLocation {
+    path;
+    startLine;
+    startColumn;
+    endLine;
+    endColumn;
+    precision;
+    constructor(init) {
+        this.path = init?.path;
+        this.startLine = init?.startLine;
+        this.startColumn = init?.startColumn;
+        this.endLine = init?.endLine;
+        this.endColumn = init?.endColumn;
+        this.precision = init.precision;
+    }
+}
+exports.ReplaySourceLocation = ReplaySourceLocation;

package/dist/cjs/debugger/session/replay-stack-frame.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayStackFrame = void 0;
+class ReplayStackFrame {
+    frameId;
+    name;
+    constructor(init) {
+        this.frameId = init?.frameId;
+        this.name = init?.name;
+    }
+}
+exports.ReplayStackFrame = ReplayStackFrame;

package/dist/cjs/debugger/session/replay-state-delta.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayStateDelta = void 0;
+class ReplayStateDelta {
+    kind;
+    eventOrdinal;
+    comparisonKey;
+    createdContractId;
+    targetContractId;
+    templateId;
+    choice;
+    choiceArgument;
+    payload;
+    consuming;
+    constructor(init) {
+        this.kind = init.kind;
+        this.eventOrdinal = init.eventOrdinal;
+        this.comparisonKey = init.comparisonKey;
+        this.createdContractId = init.createdContractId;
+        this.targetContractId = init.targetContractId;
+        this.templateId = init.templateId;
+        this.choice = init.choice;
+        this.choiceArgument = init.choiceArgument;
+        this.payload = init.payload;
+        this.consuming = init.consuming;
+    }
+}
+exports.ReplayStateDelta = ReplayStateDelta;

package/dist/cjs/debugger/session/replay-step-advance-result.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayStepAdvanceResult = void 0;
+const replay_step_js_1 = require("./replay-step.js");
+class ReplayStepAdvanceResult {
+    sessionId;
+    step;
+    isTerminal;
+    nextStepIndex;
+    constructor(init) {
+        this.sessionId = init.sessionId;
+        this.step =
+            init.step instanceof replay_step_js_1.ReplayStep
+                ? init.step
+                : new replay_step_js_1.ReplayStep(init.step);
+        this.isTerminal = init.isTerminal;
+        this.nextStepIndex = init.nextStepIndex;
+    }
+}
+exports.ReplayStepAdvanceResult = ReplayStepAdvanceResult;

package/dist/cjs/debugger/session/replay-step.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayStep = void 0;
+class ReplayStep {
+    stepId;
+    stepIndex;
+    phase;
+    stackFrames;
+    scopes;
+    locals;
+    arguments;
+    sourceLocation;
+    valuePreview;
+    stateDelta;
+    constructor(init) {
+        this.stepId = init.stepId ?? `step-${init.stepIndex}`;
+        this.stepIndex = init.stepIndex;
+        this.phase = init.phase;
+        this.stackFrames = init.stackFrames ?? [];
+        this.scopes = init.scopes ?? [];
+        this.locals = init.locals ?? [];
+        this.arguments = init.arguments ?? [];
+        this.sourceLocation = init.sourceLocation;
+        this.valuePreview = init.valuePreview;
+        this.stateDelta = init.stateDelta;
+    }
+}
+exports.ReplayStep = ReplayStep;

package/dist/cjs/debugger/session/replay-value-preview.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayValuePreview = void 0;
+const validation_error_js_1 = require("../../core/errors/validation-error.js");
+class ReplayValuePreview {
+    kind;
+    display;
+    constructor(init) {
+        if (!init.kind) {
+            throw new validation_error_js_1.ValidationError("replay value previews require a kind");
+        }
+        if (!init.display) {
+            throw new validation_error_js_1.ValidationError("replay value previews require a display value");
+        }
+        this.kind = init.kind;
+        this.display = init.display;
+    }
+}
+exports.ReplayValuePreview = ReplayValuePreview;

package/dist/cjs/debugger/source/daml-source-mapper.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlSourceMapper = void 0;
+class DamlSourceMapper {
+    indexedCompilation;
+    constructor(indexedCompilation) {
+        this.indexedCompilation = indexedCompilation;
+    }
+    getDefinitionSourceOrThrow(packageId, moduleName, definitionName) {
+        return this.indexedCompilation.getDefinitionSourceOrThrow(packageId, moduleName, definitionName);
+    }
+    getModuleSourceOrThrow(packageId, moduleName) {
+        return this.indexedCompilation.getModuleSourceOrThrow(packageId, moduleName);
+    }
+    getExpressionSource(expression) {
+        return this.indexedCompilation.getExpressionSource(expression);
+    }
+    getValueDefinitionOrThrow(packageId, moduleName, definitionName) {
+        return this.indexedCompilation.compilation.getValueDefinitionOrThrow(packageId, moduleName, definitionName);
+    }
+    findExecutableSourceAt(path, line, column) {
+        return this.indexedCompilation.findExecutableSourceAt(path, line, column);
+    }
+}
+exports.DamlSourceMapper = DamlSourceMapper;

package/dist/cjs/debugger/source/dar-source-map-metadata.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DarSourceMapMetadata = void 0;
+class DarSourceMapMetadata {
+    packageId;
+    importedPackages;
+    executables;
+    constructor(init) {
+        this.packageId = init?.packageId;
+        this.importedPackages = init?.importedPackages ?? [];
+        this.executables = init?.executables ?? [];
+    }
+}
+exports.DarSourceMapMetadata = DarSourceMapMetadata;

package/dist/cjs/debugger/source/source-coverage-validator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceCoverageValidator = void 0;
+const replay_source_map_exception_js_1 = require("../errors/replay-source-map.exception.js");
+class SourceCoverageValidator {
+    static validateOrThrow(indexedCompilation, requiredSymbols) {
+        for (const symbol of requiredSymbols) {
+            try {
+                indexedCompilation.getDefinitionSourceOrThrow(symbol.packageId, symbol.moduleName, symbol.definitionName);
+            }
+            catch (error) {
+                if (error instanceof replay_source_map_exception_js_1.ReplaySourceMapException) {
+                    throw error;
+                }
+                throw new replay_source_map_exception_js_1.ReplaySourceMapException(`failed to validate source coverage for '${symbol.packageId}::${symbol.moduleName}::${symbol.definitionName}'`);
+            }
+        }
+    }
+}
+exports.SourceCoverageValidator = SourceCoverageValidator;

package/dist/cjs/debugger/source/source-indexed-compilation.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceIndexedCompilation = void 0;
+const daml_lf_expression_path_js_1 = require("../../daml-lf/model/daml-lf-expression-path.js");
+const replay_source_map_exception_js_1 = require("../errors/replay-source-map.exception.js");
+const source_mapping_precision_js_1 = require("./source-mapping-precision.js");
+class SourceIndexedCompilation {
+    compilation;
+    definitionSources = new Map();
+    moduleSources = new Map();
+    expressionSources = new Map();
+    constructor(compilation) {
+        this.compilation = compilation;
+    }
+    static createOrThrow(compilation, sourceBundles) {
+        const indexed = new SourceIndexedCompilation(compilation);
+        for (const bundle of sourceBundles) {
+            for (const executable of bundle.metadata.executables) {
+                const source = {
+                    packageId: executable.packageId,
+                    moduleName: executable.moduleName,
+                    definitionName: executable.definitionName,
+                    path: executable.path,
+                    startLine: executable.startLine,
+                    startColumn: executable.startColumn,
+                    endLine: executable.endLine,
+                    endColumn: executable.endColumn,
+                    precision: executable.precision
+                        ?? source_mapping_precision_js_1.SourceMappingPrecision.fallback,
+                    entrypointKind: executable.entrypointKind,
+                    templateName: executable.templateName,
+                    choiceName: executable.choiceName,
+                    choiceArgumentFieldName: executable.choiceArgumentFieldName,
+                };
+                indexed.definitionSources.set(SourceIndexedCompilation.createDefinitionKey(executable.packageId, executable.moduleName, executable.definitionName), source);
+                indexed.moduleSources.set(SourceIndexedCompilation.createModuleKey(executable.packageId, executable.moduleName), source);
+            }
+            for (const expressionLocation of bundle.metadata.expressionLocations) {
+                if (!Array.isArray(expressionLocation.expressionPath)) {
+                    throw new replay_source_map_exception_js_1.ReplaySourceMapException(`expression source mapping for '${expressionLocation.packageId}::${expressionLocation.moduleName}::${expressionLocation.definitionName}' is missing its expression path`);
+                }
+                const definition = compilation.getValueDefinitionOrThrow(expressionLocation.packageId, expressionLocation.moduleName, expressionLocation.definitionName);
+                const expression = (0, daml_lf_expression_path_js_1.getDamlLfExpressionAtPath)(definition.expression, expressionLocation.expressionPath);
+                if (expression === undefined) {
+                    throw new replay_source_map_exception_js_1.ReplaySourceMapException(`invalid expression path for '${expressionLocation.packageId}::${expressionLocation.moduleName}::${expressionLocation.definitionName}'`);
+                }
+                indexed.expressionSources.set(expression, {
+                    path: expressionLocation.path,
+                    startLine: expressionLocation.startLine,
+                    startColumn: expressionLocation.startColumn,
+                    endLine: expressionLocation.endLine,
+                    endColumn: expressionLocation.endColumn,
+                });
+            }
+        }
+        return indexed;
+    }
+    getDefinitionSourceOrThrow(packageId, moduleName, definitionName) {
+        const source = this.definitionSources.get(SourceIndexedCompilation.createDefinitionKey(packageId, moduleName, definitionName));
+        if (source === undefined) {
+            throw new replay_source_map_exception_js_1.ReplaySourceMapException(`missing source mapping for '${packageId}::${moduleName}::${definitionName}'`);
+        }
+        return source;
+    }
+    getModuleSourceOrThrow(packageId, moduleName) {
+        const source = this.moduleSources.get(SourceIndexedCompilation.createModuleKey(packageId, moduleName));
+        if (source === undefined) {
+            throw new replay_source_map_exception_js_1.ReplaySourceMapException(`missing source mapping for module '${packageId}::${moduleName}'`);
+        }
+        return source;
+    }
+    getExecutableSources() {
+        return [...this.definitionSources.values()];
+    }
+    findExecutableSourceAt(path, line, column) {
+        return this.getExecutableSources()
+            .filter((source) => source.path === path
+            && this.containsSourceLocation(source, line, column))
+            .sort((left, right) => this.compareSourceSpecificity(left, right))
+            .at(0);
+    }
+    getExpressionSource(expression) {
+        return this.expressionSources.get(expression);
+    }
+    containsSourceLocation(source, line, column) {
+        const startsBeforeOrAt = source.startLine < line
+            || (source.startLine === line && source.startColumn <= column);
+        const endsAfterOrAt = source.endLine > line
+            || (source.endLine === line && source.endColumn >= column);
+        return startsBeforeOrAt && endsAfterOrAt;
+    }
+    compareSourceSpecificity(left, right) {
+        if (left.startLine !== right.startLine) {
+            return right.startLine - left.startLine;
+        }
+        if (left.startColumn !== right.startColumn) {
+            return right.startColumn - left.startColumn;
+        }
+        if (left.endLine !== right.endLine) {
+            return left.endLine - right.endLine;
+        }
+        if (left.endColumn !== right.endColumn) {
+            return left.endColumn - right.endColumn;
+        }
+        return 0;
+    }
+    static createDefinitionKey(packageId, moduleName, definitionName) {
+        return `${packageId}::${moduleName}::${definitionName}`;
+    }
+    static createModuleKey(packageId, moduleName) {
+        return `${packageId}::${moduleName}`;
+    }
+}
+exports.SourceIndexedCompilation = SourceIndexedCompilation;

package/dist/cjs/debugger/source/source-mapping-precision.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceMappingPrecision = void 0;
+exports.SourceMappingPrecision = {
+    exact: "exact",
+    fallback: "fallback",
+};

package/dist/cjs/grpc/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcTransport = exports.GrpcLedgerClient = void 0;
+var grpc_ledger_client_js_1 = require("../transports/grpc/grpc-ledger-client.js");
+Object.defineProperty(exports, "GrpcLedgerClient", { enumerable: true, get: function () { return grpc_ledger_client_js_1.GrpcLedgerClient; } });
+var grpc_transport_js_1 = require("../transports/grpc/grpc-transport.js");
+Object.defineProperty(exports, "GrpcTransport", { enumerable: true, get: function () { return grpc_transport_js_1.GrpcTransport; } });