@distrohelena/canton-explorer 0.1.0 → 0.1.2

package/dist/src/debugger/debugger.service.js

@@ -0,0 +1,746 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebuggerService = void 0;
+const common_1 = require("@nestjs/common");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const grpc_client_factory_1 = require("../grpc/grpc-client.factory");
+const node_config_service_1 = require("../config/node-config.service");
+const package_cache_service_1 = require("../packages/package-cache.service");
+const package_sync_service_1 = require("../packages/package-sync.service");
+const pqs_summary_service_1 = require("../pqs/pqs-summary.service");
+let DebuggerService = class DebuggerService {
+    grpcClientFactory;
+    packageCacheService;
+    packageSyncService;
+    pqsSummaryService;
+    nodeConfigService;
+    sdkModulesPromise;
+    sessionStore = null;
+    sessionArtifacts = new Map();
+    constructor(grpcClientFactory, packageCacheService, packageSyncService, pqsSummaryService, nodeConfigService) {
+        this.grpcClientFactory = grpcClientFactory;
+        this.packageCacheService = packageCacheService;
+        this.packageSyncService = packageSyncService;
+        this.pqsSummaryService = pqsSummaryService;
+        this.nodeConfigService = nodeConfigService;
+    }
+    async createSession(nodeId, offset) {
+        const normalizedNodeId = nodeId.trim();
+        const normalizedOffset = offset.trim();
+        if (!normalizedNodeId) {
+            throw new common_1.BadRequestException('nodeId is required');
+        }
+        if (!normalizedOffset) {
+            throw new common_1.BadRequestException('offset is required');
+        }
+        const node = this.getNodeConfig(normalizedNodeId);
+        if (node.mode !== 'pqs_with_grpc') {
+            throw new common_1.BadRequestException(`Node ${node.id} does not support debugger replay without gRPC`);
+        }
+        const { debuggerSdk, damlLfSdk } = await this.loadSdkModules();
+        const sessionStore = await this.getSessionStore();
+        const client = (await this.grpcClientFactory.create(node));
+        const packageReadService = await this.createPackageReadService(client);
+        let stage = 'bootstrap';
+        try {
+            stage = 'load-update-detail';
+            const updateDetail = await this.pqsSummaryService.fetchUpdateDetail(node, normalizedOffset);
+            stage = 'resolve-replay-parties';
+            const replayAccess = await this.resolveReplayAccess(node, client, updateDetail);
+            stage = 'load-update';
+            const updateLoader = new debuggerSdk.ReplayUpdateLoader({
+                updateService: client.updateService,
+                visibleParties: replayAccess.updateVisibleParties,
+            });
+            const snapshot = await updateLoader.loadOrThrowAsync(normalizedOffset);
+            stage = 'build-environment';
+            const environmentBuilder = new debuggerSdk.LedgerReplayEnvironmentBuilder({
+                contractService: this.createReplayContractService(node, client),
+                eventQueryService: this.createReplayEventQueryService(node, client),
+                queryingParties: replayAccess.queryParties,
+            });
+            const environment = await environmentBuilder.buildOrThrowAsync(snapshot);
+            stage = 'resolve-artifacts';
+            const artifactResolver = new debuggerSdk.ReplayArtifactResolver({
+                participantPackageService: packageReadService,
+            });
+            const resolvedArtifacts = await artifactResolver.resolveAsync(environment.packageIds);
+            stage = 'sync-packages';
+            await this.packageSyncService.syncPackagesById(node, [...resolvedArtifacts.packageIds]);
+            stage = 'load-compilation';
+            const compilation = this.loadCompilationOrThrow(damlLfSdk, resolvedArtifacts.packageIds);
+            stage = 'load-source-bundles';
+            const sourceBundles = await this.loadSourceBundles(packageReadService, resolvedArtifacts.dars, damlLfSdk);
+            stage = 'index-sources';
+            const indexedCompilation = debuggerSdk.SourceIndexedCompilation.createOrThrow(compilation, sourceBundles);
+            stage = 'load-session';
+            const sessionLoader = new debuggerSdk.LedgerReplaySessionLoader({
+                updateLoader: {
+                    loadOrThrowAsync: async () => snapshot,
+                },
+                environmentBuilder: {
+                    buildOrThrowAsync: async () => environment,
+                },
+                definitionResolver: new debuggerSdk.ReplayEntrypointDefinitionResolver(indexedCompilation),
+                sourceMapper: new debuggerSdk.DamlSourceMapper(indexedCompilation),
+                evaluator: new damlLfSdk.DamlLfEvaluator(compilation),
+                determinismValidator: new debuggerSdk.ReplayDeterminismValidator(),
+            });
+            const debuggerClient = new debuggerSdk.LedgerReplayDebuggerClient({
+                sessionLoader,
+                sessionStore: sessionStore,
+            });
+            stage = 'create-session';
+            const session = await debuggerClient.loadSessionAsync(new debuggerSdk.ReplaySessionRequest({
+                offset: normalizedOffset,
+            }));
+            if (!session.sessionId) {
+                throw new Error('Replay session did not return a session id');
+            }
+            this.sessionArtifacts.set(session.sessionId, {
+                nodeId: node.id,
+                updateId: snapshot.updateId ?? null,
+                offset: snapshot.offset,
+                sourceFilesByPath: this.flattenSourceFiles(sourceBundles),
+                realEvents: updateDetail.events ?? [],
+            });
+            return this.getSession(session.sessionId);
+        }
+        catch (error) {
+            console.error('[DebuggerService] createSession failed at stage:', stage, error);
+            const message = error instanceof Error ? error.message : 'Debugger session bootstrap failed';
+            if (message.includes('debug/source-map.json')) {
+                throw new common_1.BadRequestException('Debugger requires DAR source maps, but the relevant DAR does not contain debug/source-map.json.');
+            }
+            if (message.includes('UPDATE_NOT_FOUND')) {
+                throw new common_1.NotFoundException('Update not found on this node, or not visible to the configured ledger user.');
+            }
+            throw new common_1.InternalServerErrorException(message);
+        }
+        finally {
+            await client.disposeAsync?.();
+        }
+    }
+    getSession(sessionId) {
+        const sessionStore = this.getSessionStoreSync();
+        const artifacts = this.sessionArtifacts.get(sessionId);
+        if (!artifacts) {
+            throw new common_1.NotFoundException(`Unknown debugger session: ${sessionId}`);
+        }
+        const metadata = sessionStore.getSessionMetadataOrThrow(sessionId);
+        const currentStep = sessionStore.getCurrentStepOrThrow(sessionId);
+        const sourceLocation = currentStep.sourceLocation;
+        const sourcePath = sourceLocation?.path ?? null;
+        const sourceContent = sourcePath ? artifacts.sourceFilesByPath.get(sourcePath) ?? null : null;
+        return {
+            sessionId,
+            nodeId: artifacts.nodeId,
+            updateId: artifacts.updateId,
+            offset: artifacts.offset,
+            stepCount: metadata.stepCount ?? 0,
+            currentStepIndex: currentStep.stepIndex,
+            isTerminal: typeof metadata.stepCount === 'number'
+                ? currentStep.stepIndex >= Math.max(0, metadata.stepCount - 1)
+                : false,
+            currentStep: this.mapStep(currentStep),
+            source: sourcePath && sourceContent !== null
+                ? {
+                    path: sourcePath,
+                    content: sourceContent,
+                    startLine: sourceLocation?.startLine ?? null,
+                    startColumn: sourceLocation?.startColumn ?? null,
+                    endLine: sourceLocation?.endLine ?? null,
+                    endColumn: sourceLocation?.endColumn ?? null,
+                }
+                : null,
+        };
+    }
+    listEvents(sessionId) {
+        const sessionStore = this.getSessionStoreSync();
+        const metadata = sessionStore.getSessionMetadataOrThrow(sessionId);
+        const currentStep = sessionStore.getCurrentStepOrThrow(sessionId);
+        const artifacts = this.sessionArtifacts.get(sessionId);
+        if (!artifacts) {
+            throw new common_1.NotFoundException(`Unknown debugger session: ${sessionId}`);
+        }
+        const trace = sessionStore.getTraceSliceOrThrow(sessionId, 0, metadata.stepCount ?? 0);
+        return {
+            sessionId,
+            currentStepId: currentStep.stepId ?? null,
+            realEvents: artifacts.realEvents.map((event) => this.mapRealEvent(event)),
+            replayEvents: trace
+                .filter((step) => step.stateDelta !== undefined)
+                .map((step) => this.mapEvent(step)),
+        };
+    }
+    stepInto(sessionId) {
+        this.getSessionStoreSync().advanceIntoOrThrow(sessionId);
+        return this.getSession(sessionId);
+    }
+    stepBack(sessionId) {
+        this.getSessionStoreSync().advanceBackOrThrow(sessionId);
+        return this.getSession(sessionId);
+    }
+    stepOver(sessionId) {
+        this.getSessionStoreSync().advanceOverOrThrow(sessionId);
+        return this.getSession(sessionId);
+    }
+    stepOut(sessionId) {
+        this.getSessionStoreSync().advanceOutOrThrow(sessionId);
+        return this.getSession(sessionId);
+    }
+    continue(sessionId) {
+        this.getSessionStoreSync().continueOrThrow(sessionId);
+        return this.getSession(sessionId);
+    }
+    jumpToStep(sessionId, stepId) {
+        this.getSessionStoreSync().setCurrentStepByIdOrThrow(sessionId, stepId);
+        return this.getSession(sessionId);
+    }
+    disposeSession(sessionId) {
+        this.getSessionStoreSync().dispose(sessionId);
+        this.sessionArtifacts.delete(sessionId);
+    }
+    async loadSdkModules() {
+        if (!this.sdkModulesPromise) {
+            this.sdkModulesPromise = Promise.all([
+                import('@distrohelena/canton-typescript-sdk'),
+                import('@distrohelena/canton-typescript-sdk/debugger'),
+                import('@distrohelena/canton-typescript-sdk/daml-lf'),
+            ]).then(([rootSdk, debuggerSdk, damlLfSdk]) => ({ rootSdk, debuggerSdk, damlLfSdk }));
+        }
+        return this.sdkModulesPromise;
+    }
+    async getSessionStore() {
+        if (!this.sessionStore) {
+            const { debuggerSdk } = await this.loadSdkModules();
+            this.sessionStore = new debuggerSdk.InMemoryReplaySessionStore();
+        }
+        return this.sessionStore;
+    }
+    getSessionStoreSync() {
+        if (!this.sessionStore) {
+            throw new common_1.NotFoundException('Debugger session store is not initialized');
+        }
+        return this.sessionStore;
+    }
+    getNodeConfig(id) {
+        const node = this.nodeConfigService?.list().find((candidate) => candidate.id === id);
+        if (!node) {
+            throw new common_1.NotFoundException(`Unknown node: ${id}`);
+        }
+        return node;
+    }
+    loadCompilationOrThrow(damlLfSdk, packageIds) {
+        const packageLoader = new damlLfSdk.DamlLfPackageLoader();
+        const packages = packageIds.map((packageId) => {
+            const cachedPackage = this.packageCacheService.getPackage(packageId);
+            if (!cachedPackage) {
+                throw new common_1.NotFoundException(`Missing cached package for debugger replay: ${packageId}`);
+            }
+            return packageLoader.loadPackageOrThrow(cachedPackage.data);
+        });
+        return damlLfSdk.DamlLfCompilation.createOrThrow(new damlLfSdk.DamlLfWorkspace(packages));
+    }
+    async loadSourceBundles(packageReadService, dars, damlLfSdk) {
+        const { rootSdk } = await this.loadSdkModules();
+        const sourceBundleLoader = new damlLfSdk.DarSourceBundleLoader();
+        const sourceBundles = [];
+        for (const dar of dars) {
+            const response = await packageReadService.getDarAsync(new rootSdk.GetDarRequest({
+                mainPackageId: dar.main,
+            }));
+            sourceBundles.push(await sourceBundleLoader.loadSourceBundleOrThrowAsync(response.payload));
+        }
+        return sourceBundles;
+    }
+    flattenSourceFiles(sourceBundles) {
+        const sourceFiles = new Map();
+        for (const bundle of sourceBundles) {
+            for (const sourceFile of bundle.sourceFiles) {
+                if (!sourceFiles.has(sourceFile.path)) {
+                    sourceFiles.set(sourceFile.path, sourceFile.content);
+                }
+            }
+        }
+        return sourceFiles;
+    }
+    createReplayContractService(node, client) {
+        return {
+            getContractAsync: async (request) => {
+                try {
+                    return await client.contractService.getContractAsync(request);
+                }
+                catch (error) {
+                    const fallback = await this.buildPqsReplayCreatedEvent(node, request);
+                    if (fallback) {
+                        return {
+                            createdEvent: fallback,
+                        };
+                    }
+                    throw error;
+                }
+            },
+        };
+    }
+    createReplayEventQueryService(node, client) {
+        return {
+            getEventsByContractIdAsync: async (request) => {
+                try {
+                    return await client.eventQueryService.getEventsByContractIdAsync(request);
+                }
+                catch (error) {
+                    const fallback = await this.buildPqsReplayCreatedEvent(node, request);
+                    if (fallback) {
+                        return {
+                            created: {
+                                createdEvent: fallback,
+                                synchronizerId: 'pqs-fallback',
+                            },
+                        };
+                    }
+                    throw error;
+                }
+            },
+        };
+    }
+    mapStep(step) {
+        return {
+            stepId: step.stepId ?? null,
+            stepIndex: step.stepIndex,
+            phase: step.phase,
+            stackFrames: (step.stackFrames ?? []).map((frame) => ({
+                frameId: frame.frameId ?? null,
+                name: frame.name ?? null,
+            })),
+            scopes: (step.scopes ?? []).map((scope) => this.mapScope(scope)),
+            locals: [...(step.locals ?? [])],
+            arguments: [...(step.arguments ?? [])],
+            sourceLocation: this.mapSourceLocation(step.sourceLocation),
+            valuePreview: step.valuePreview
+                ? {
+                    kind: step.valuePreview.kind,
+                    display: step.valuePreview.display,
+                }
+                : null,
+            stateDelta: this.mapStateDelta(step.stateDelta),
+        };
+    }
+    mapEvent(step) {
+        const stateDelta = this.mapStateDelta(step.stateDelta);
+        return {
+            stepId: step.stepId ?? null,
+            stepIndex: step.stepIndex,
+            phase: step.phase,
+            kind: stateDelta?.kind ?? null,
+            eventOrdinal: stateDelta?.eventOrdinal ?? null,
+            comparisonKey: stateDelta?.comparisonKey ?? null,
+            createdContractId: stateDelta?.createdContractId ?? null,
+            targetContractId: stateDelta?.targetContractId ?? null,
+            templateId: stateDelta?.templateId ?? null,
+            choice: stateDelta?.choice ?? null,
+            choiceArgument: stateDelta?.choiceArgument ?? null,
+            payload: stateDelta?.payload ?? null,
+            consuming: stateDelta?.consuming ?? null,
+            sourceLocation: this.mapSourceLocation(step.sourceLocation),
+        };
+    }
+    mapRealEvent(event) {
+        return {
+            eventId: event.eventId ?? null,
+            eventKind: event.eventKind,
+            contractId: event.contractId ?? null,
+            packageId: event.packageId ?? null,
+            templateId: event.templateId ?? null,
+            choice: event.choice ?? null,
+            witnesses: [...(event.witnesses ?? [])],
+            createData: event.createData?.status === 'decoded' ? event.createData.value : null,
+            exerciseArgument: event.exerciseData?.argument.status === 'decoded'
+                ? event.exerciseData.argument.value
+                : null,
+            exerciseResult: event.exerciseData?.result.status === 'decoded'
+                ? event.exerciseData.result.value
+                : null,
+        };
+    }
+    mapScope(scope) {
+        return {
+            frameId: scope.frameId ?? null,
+            name: scope.name ?? null,
+            variables: (scope.variables ?? []).map((variable) => ({
+                name: variable.name ?? null,
+                kind: variable.kind ?? null,
+                value: variable.value ?? null,
+            })),
+        };
+    }
+    mapStateDelta(stateDelta) {
+        if (!stateDelta) {
+            return null;
+        }
+        return {
+            kind: stateDelta.kind ?? null,
+            eventOrdinal: stateDelta.eventOrdinal ?? null,
+            comparisonKey: stateDelta.comparisonKey ?? null,
+            createdContractId: stateDelta.createdContractId ?? null,
+            targetContractId: stateDelta.targetContractId ?? null,
+            templateId: stateDelta.templateId
+                ? {
+                    packageId: stateDelta.templateId.packageId ?? null,
+                    moduleName: stateDelta.templateId.moduleName ?? null,
+                    entityName: stateDelta.templateId.entityName ?? null,
+                }
+                : null,
+            choice: stateDelta.choice ?? null,
+            choiceArgument: stateDelta.choiceArgument ?? null,
+            payload: stateDelta.payload ?? null,
+            consuming: stateDelta.consuming ?? null,
+        };
+    }
+    mapSourceLocation(sourceLocation) {
+        return sourceLocation
+            ? {
+                path: sourceLocation.path ?? null,
+                startLine: sourceLocation.startLine ?? null,
+                startColumn: sourceLocation.startColumn ?? null,
+                endLine: sourceLocation.endLine ?? null,
+                endColumn: sourceLocation.endColumn ?? null,
+            }
+            : null;
+    }
+    async buildPqsReplayCreatedEvent(node, request) {
+        const contractId = request && typeof request === 'object' && 'contractId' in request
+            ? request.contractId
+            : undefined;
+        if (typeof contractId !== 'string' || contractId.length === 0) {
+            return null;
+        }
+        let contractDetail;
+        try {
+            contractDetail = await this.pqsSummaryService.fetchContractDetail(node, contractId);
+        }
+        catch {
+            return null;
+        }
+        if (contractDetail.contractData?.status !== 'decoded') {
+            return null;
+        }
+        const templateId = this.parseTemplateIdentifier(contractDetail.packageId, contractDetail.templateId);
+        if (!templateId) {
+            return null;
+        }
+        return {
+            contractId,
+            templateId,
+            createArguments: this.toReplayLedgerValue(contractDetail.contractData),
+        };
+    }
+    parseTemplateIdentifier(packageId, templateId) {
+        if (!packageId || !templateId) {
+            return null;
+        }
+        const separatorIndex = templateId.lastIndexOf(':');
+        if (separatorIndex <= 0 || separatorIndex >= templateId.length - 1) {
+            return null;
+        }
+        return {
+            packageId,
+            moduleName: templateId.slice(0, separatorIndex),
+            entityName: templateId.slice(separatorIndex + 1),
+        };
+    }
+    toReplayLedgerValue(state) {
+        if (state.status !== 'decoded') {
+            return undefined;
+        }
+        return this.decodeNodeValue(state.value);
+    }
+    decodeNodeValue(value) {
+        if (typeof value === 'string'
+            || typeof value === 'number'
+            || typeof value === 'boolean') {
+            return value;
+        }
+        switch (value.kind) {
+            case 'contract_id':
+                return {
+                    sum: {
+                        oneofKind: 'contractId',
+                        contractId: value.value,
+                    },
+                };
+            case 'record':
+                return {
+                    fields: value.fields.map((field) => ({
+                        label: field.label,
+                        value: this.decodeNodeValue(field.value),
+                    })),
+                };
+            case 'variant':
+                return {
+                    sum: {
+                        oneofKind: 'variant',
+                        variant: {
+                            constructor: value.constructor,
+                            value: value.value === null ? undefined : this.decodeNodeValue(value.value),
+                        },
+                    },
+                };
+            case 'enum':
+                return {
+                    sum: {
+                        oneofKind: 'enum',
+                        enum: {
+                            constructor: value.constructor,
+                        },
+                    },
+                };
+            case 'list':
+                return {
+                    sum: {
+                        oneofKind: 'list',
+                        list: {
+                            elements: value.items.map((item) => this.decodeNodeValue(item)),
+                        },
+                    },
+                };
+            case 'optional':
+                return {
+                    sum: {
+                        oneofKind: 'optional',
+                        optional: value.value === null
+                            ? {}
+                            : {
+                                value: this.decodeNodeValue(value.value),
+                            },
+                    },
+                };
+            case 'text_map':
+                return {
+                    sum: {
+                        oneofKind: 'textMap',
+                        textMap: {
+                            entries: value.entries.map((entry) => ({
+                                key: entry.key,
+                                value: this.decodeNodeValue(entry.value),
+                            })),
+                        },
+                    },
+                };
+            case 'gen_map':
+                return {
+                    sum: {
+                        oneofKind: 'genMap',
+                        genMap: {
+                            entries: value.entries.map((entry) => ({
+                                key: this.decodeNodeValue(entry.key),
+                                value: this.decodeNodeValue(entry.value),
+                            })),
+                        },
+                    },
+                };
+            case 'unit':
+                return {
+                    sum: {
+                        oneofKind: 'unit',
+                    },
+                };
+            default:
+                return undefined;
+        }
+    }
+    collectVisibleParties(updateDetail) {
+        return [
+            ...new Set([
+                ...(updateDetail.parties ?? []),
+                ...updateDetail.events.flatMap((event) => event.witnesses ?? []),
+            ]),
+        ].filter((party) => typeof party === 'string' && party.length > 0);
+    }
+    async resolveReplayAccess(node, client, updateDetail) {
+        const grantedAccess = await this.fetchGrantedReplayAccess(node, client);
+        const detailParties = this.collectVisibleParties(updateDetail);
+        if (grantedAccess.canReadAsAnyParty) {
+            return {
+                updateVisibleParties: undefined,
+                queryParties: detailParties.length > 0 ? detailParties : undefined,
+            };
+        }
+        const grantedParties = grantedAccess.parties;
+        if (grantedParties.length === 0) {
+            return {
+                updateVisibleParties: detailParties.length > 0 ? detailParties : undefined,
+                queryParties: detailParties.length > 0 ? detailParties : undefined,
+            };
+        }
+        if (detailParties.length === 0) {
+            return {
+                updateVisibleParties: grantedParties,
+                queryParties: grantedParties,
+            };
+        }
+        const grantedPartySet = new Set(grantedParties);
+        const overlappingParties = detailParties.filter((party) => grantedPartySet.has(party));
+        const parties = overlappingParties.length > 0 ? overlappingParties : grantedParties;
+        return {
+            updateVisibleParties: parties,
+            queryParties: parties,
+        };
+    }
+    async fetchGrantedReplayAccess(node, client) {
+        const authConfig = node.grpc.auth;
+        if (!authConfig || authConfig.kind !== 'shared_secret_jwt') {
+            return {
+                parties: [],
+                canReadAsAnyParty: false,
+            };
+        }
+        const response = await client.userManagementService.listUserRightsAsync({
+            userId: authConfig.user,
+        });
+        const rights = response.rights ?? [];
+        return {
+            canReadAsAnyParty: rights.some((right) => right?.type === 'canReadAsAnyParty'),
+            parties: [
+                ...new Set(rights
+                    .filter((right) => typeof right?.type === 'string'
+                    && (right.type === 'canActAs' || right.type === 'canReadAs')
+                    && typeof right.party === 'string'
+                    && right.party.length > 0)
+                    .map((right) => right.party)),
+            ],
+        };
+    }
+    async createPackageReadService(client) {
+        const localDebugDars = await this.loadLocalDebugDars();
+        if (localDebugDars.size === 0) {
+            return client.participantPackageService;
+        }
+        return {
+            getPackageReferencesAsync: async (request) => {
+                const packageId = this.extractPackageId(request);
+                const localDar = packageId ? localDebugDars.get(packageId) : undefined;
+                if (localDar) {
+                    return {
+                        dars: [{ main: localDar.mainPackageId }],
+                    };
+                }
+                return client.participantPackageService.getPackageReferencesAsync(request);
+            },
+            getDarAsync: async (request) => {
+                const mainPackageId = this.extractMainPackageId(request);
+                const localDar = mainPackageId ? localDebugDars.get(mainPackageId) : undefined;
+                if (localDar) {
+                    return {
+                        payload: localDar.payload,
+                    };
+                }
+                return client.participantPackageService.getDarAsync(request);
+            },
+        };
+    }
+    async loadLocalDebugDars() {
+        const directory = this.getLocalDebugDarDirectory();
+        const entries = new Map();
+        if (!directory || !this.pathExists(directory, 'directory')) {
+            return entries;
+        }
+        const { damlLfSdk } = await this.loadSdkModules();
+        const archiveLoader = new damlLfSdk.DarArchiveLoader();
+        const packageLoader = new damlLfSdk.DamlLfPackageLoader();
+        const sourceBundleLoader = new damlLfSdk.DarSourceBundleLoader();
+        for (const filePath of this.listDarFiles(directory)) {
+            try {
+                const payload = (0, node_fs_1.readFileSync)(filePath);
+                await sourceBundleLoader.loadSourceBundleOrThrowAsync(payload);
+                const archive = await archiveLoader.loadDarOrThrowAsync(payload);
+                const mainPackage = packageLoader.loadPackageOrThrow(archive.mainPackageEntry.bytes);
+                entries.set(mainPackage.packageId, {
+                    mainPackageId: mainPackage.packageId,
+                    payload,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.warn(`[DebuggerService] Skipping local debug DAR ${filePath}: ${message}`);
+            }
+        }
+        return entries;
+    }
+    getLocalDebugDarDirectory() {
+        const configuredDirectory = this.nodeConfigService?.getDebuggerConfig().localDarDirectory?.trim();
+        if (configuredDirectory) {
+            return (0, node_path_1.resolve)(configuredDirectory);
+        }
+        const currentWorkingDirectoryPath = (0, node_path_1.resolve)(process.cwd(), 'debug-dars');
+        if (this.pathExists(currentWorkingDirectoryPath, 'directory')) {
+            return currentWorkingDirectoryPath;
+        }
+        const parentDirectoryPath = (0, node_path_1.resolve)(process.cwd(), '..', 'debug-dars');
+        if (this.pathExists(parentDirectoryPath, 'directory')) {
+            return parentDirectoryPath;
+        }
+        return currentWorkingDirectoryPath;
+    }
+    listDarFiles(rootDir) {
+        const files = [];
+        for (const entry of (0, node_fs_1.readdirSync)(rootDir, { withFileTypes: true })) {
+            const absolutePath = (0, node_path_1.resolve)(rootDir, entry.name);
+            if (entry.isDirectory()) {
+                files.push(...this.listDarFiles(absolutePath));
+                continue;
+            }
+            if (entry.isFile() && absolutePath.endsWith('.dar')) {
+                files.push(absolutePath);
+            }
+        }
+        return files.sort();
+    }
+    pathExists(candidatePath, kind) {
+        try {
+            const stats = (0, node_fs_1.statSync)(candidatePath);
+            return kind === 'directory' ? stats.isDirectory() : stats.isFile();
+        }
+        catch {
+            return false;
+        }
+    }
+    extractPackageId(request) {
+        if (!request || typeof request !== 'object') {
+            return null;
+        }
+        const candidate = request.packageId;
+        return typeof candidate === 'string' && candidate.length > 0 ? candidate : null;
+    }
+    extractMainPackageId(request) {
+        if (!request || typeof request !== 'object') {
+            return null;
+        }
+        const candidate = request.mainPackageId;
+        return typeof candidate === 'string' && candidate.length > 0 ? candidate : null;
+    }
+};
+exports.DebuggerService = DebuggerService;
+exports.DebuggerService = DebuggerService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(4, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [grpc_client_factory_1.GrpcClientFactory,
+        package_cache_service_1.PackageCacheService,
+        package_sync_service_1.PackageSyncService,
+        pqs_summary_service_1.PqsSummaryService,
+        node_config_service_1.NodeConfigService])
+], DebuggerService);
+//# sourceMappingURL=debugger.service.js.map