@mrclrchtr/supi-code-intelligence 3.2.0 → 4.1.0

package/src/session/target-workflow.ts

@@ -1,332 +1,263 @@
 /**
- * Target workflow — session-owned deep module.
+ * Session-owned Target workflow.
  *
- * Turns public target input (targetId, anchored coordinates, symbol
- * query, file reference) into an immutable **resolved target** before
- * graph, impact, orientation, or refactor analysis begins.
- *
- * One policy-driven method. Small interface, deep implementation.
- * Two adapters (production capability adapter + test adapter) justify
- * the seam.
- *
- * @mrclrchtr/supi-code-intelligence — internal, not exported via api.ts
+ * Turns one exact target selector into immutable resolved-target facts before
+ * graph, Orientation, resolve, or refactor analysis begins.
  */
 
 import { existsSync } from "node:fs";
-import { normalizePath } from "../analysis/search/ripgrep.ts";
+import { normalizePath, resolveScope } from "../analysis/search/paths.ts";
 import { resolveAnchoredSymbolTarget } from "../analysis/target/anchored.ts";
-import { resolveFileTargetGroup } from "../analysis/target/file.ts";
+import { resolveFileTargetGroup, validateFileTargetDiscovery } from "../analysis/target/file.ts";
+import {
+  canonicalDeclarationKind,
+  refineTargetOutcomeIdentity,
+} from "../analysis/target/identity.ts";
 import { resolveSymbolTarget } from "../analysis/target/symbol.ts";
-import type { ResolvedTargetData, TargetOutcome } from "../analysis/target/types.ts";
-import type { CapabilityAdapter } from "./capability-adapter.ts";
 import type {
-  AnchorKind,
-  TargetLookupResult,
-  TargetRegistrationInput,
-  TargetRegistrationOutput,
-  TargetStoreEntry,
+  ResolvedTargetData,
+  ResolvedTargetGroupData,
+  TargetOutcome,
+} from "../analysis/target/types.ts";
+import type { CapabilityAdapter } from "./capability-adapter.ts";
+import { parseTargetInput } from "./input/common.ts";
+import { registerTargetCandidates, type TargetWorkflowCandidate } from "./target-candidates.ts";
+import type { TargetInput, TargetSymbolKind } from "./target-input.ts";
+import {
+  computeFileFingerprint,
+  type TargetLookupResult,
+  type TargetRegistrationInput,
+  type TargetRegistrationOutput,
+  type TargetStoreEntry,
 } from "./target-store.ts";
 
-// ── Input ─────────────────────────────────────────────────────────────
-
-/** Public target input shape — mirrors the union of code_* tool params. */
-export interface TargetWorkflowInput {
-  /** Resolved target handle from code_resolve. Wins over everything else. */
-  targetId?: string;
-  /** File path (absolute or workspace-relative). */
-  file?: string;
-  /** 1-based line for anchored resolution. */
-  line?: number;
-  /** 1-based UTF-16 column for anchored resolution. */
-  character?: number;
-  /** Symbol name for workspace symbol query resolution. */
-  symbol?: string;
-  /** Preferred symbol kind for disambiguation. */
-  kind?: string;
-  /** Only exported symbols. */
-  exportedOnly?: boolean;
-  /** Maximum candidates for disambiguation. */
-  maxResults?: number;
-}
-
-// ── Policy ────────────────────────────────────────────────────────────
+export type { TargetInput } from "./target-input.ts";
 
-/**
- * Target workflow policy — what the caller allows or requires.
- *
- * Each tool passes the policy that matches its public contract.
- */
+/** Target workflow policy selected by the intent-level session entry. */
 export interface TargetWorkflowPolicy {
-  /**
-   * Whether file-level targets (no line/character) are allowed.
-   * Disallowed → file-only input returns `invalid-input`.
-   */
-  fileLevelAllowed: boolean;
-
-  /**
-   * Whether the resolved target must carry a name anchor.
-   * Callee lookups and rename require this; references do not.
-   */
-  nameAnchorRequired: boolean;
-
-  /**
-   * Whether to wait for semantic (LSP) readiness before symbol-
-   * query or anchored resolution. Set false for tool paths that
-   * only need targetId expansion or file-level resolution.
-   */
-  waitForSemantic: boolean;
+  /** Whether a file-level selector is valid for this intent. */
+  readonly fileLevelAllowed: boolean;
+  /** Whether a strict name anchor is required. */
+  readonly nameAnchorRequired: boolean;
+  /** Maximum displayed disambiguation candidates. */
+  readonly maxResults?: number;
 }
 
-// ── Outcome ───────────────────────────────────────────────────────────
-
-/** Typed outcome of the target workflow — no markdown, no mutated params. */
+/** Typed Target workflow outcome. */
 export type TargetWorkflowOutcome =
+  | { kind: "resolved"; entry: Readonly<TargetStoreEntry>; notes: readonly string[] }
   | {
-      kind: "resolved";
-      /** The stored target entry with handles. */
-      entry: TargetStoreEntry;
-      /**
-       * Display notes for the caller, e.g. "targetId took precedence
-       * over scope" or "resolved via declaration anchor snap."
-       */
-      notes: string[];
+      kind: "target-group";
+      file: string;
+      confidence: ResolvedTargetData["confidence"];
+      discoveryProvenance: ResolvedTargetGroupData["discoveryProvenance"];
+      targets: ReadonlyArray<Readonly<TargetStoreEntry>>;
+      totalCount: number;
+      omittedCount: number;
+      unknownNestingCount: number;
     }
   | {
       kind: "disambiguation";
-      candidates: Array<{
-        targetId: string;
-        name: string;
-        kind: string | null;
-        container: string | null;
-        file: string;
-        line: number;
-        character: number;
-        rank: number;
-        anchorKind: AnchorKind;
-      }>;
+      candidates: ReadonlyArray<TargetWorkflowCandidate>;
       omittedCount: number;
     }
   | {
-      kind: "invalid-input";
-      message: string;
-    }
-  | {
-      kind: "unavailable";
-      reason: string;
+      kind: "kind-mismatch";
+      requestedKind: TargetSymbolKind;
+      candidates: ReadonlyArray<TargetWorkflowCandidate>;
+      omittedCount: number;
     }
-  | {
-      /** No target input was provided. Caller decides fallback. */
-      kind: "no-target";
-    };
-
-// ── Dependencies ──────────────────────────────────────────────────────
+  | { kind: "invalid-input"; message: string }
+  | { kind: "unavailable"; reason: string };
 
+/** Dependencies hidden behind the Workspace code-intelligence session seam. */
 export interface TargetWorkflowDeps {
-  /** Workspace root. */
-  cwd: string;
-  /** Injected capability adapter (production or test). */
-  capability: CapabilityAdapter;
-  /** Session-scoped target store lookup. */
-  lookupTargetId: (targetId: string) => TargetLookupResult;
-  /** Session-scoped target registration. */
-  registerTarget: (input: TargetRegistrationInput) => TargetRegistrationOutput;
+  readonly cwd: string;
+  readonly capability: CapabilityAdapter;
+  readonly lookupTargetId: (targetId: string) => TargetLookupResult;
+  readonly registerTarget: (input: TargetRegistrationInput) => TargetRegistrationOutput;
 }
 
-// ── Entry point ───────────────────────────────────────────────────────
-
 /**
- * Execute the target workflow: resolve target input into an immutable
- * resolved target (or a typed failure outcome).
- *
- * Order of precedence:
- * 1. targetId (store lookup + freshness check)
- * 2. anchored coordinates (file + line + character → provider-backed)
- * 3. symbol query (workspace symbol → provider-backed)
- * 4. file-only (when policy.fileLevelAllowed)
+ * Resolve exactly one canonical selector into target facts or a typed failure.
+ * New and refined targets are always LSP-first; handle lookup deliberately
+ * bypasses readiness so existing handles can still serve structural consumers.
  */
 export async function resolveTargetWorkflow(
-  input: TargetWorkflowInput,
+  input: TargetInput,
   policy: TargetWorkflowPolicy,
   deps: TargetWorkflowDeps,
 ): Promise<TargetWorkflowOutcome> {
-  // ── 1. targetId lookup ──────────────────────────────────────────────
-  if (input.targetId) {
-    const result = deps.lookupTargetId(input.targetId);
-    if (result.kind === "unavailable") {
-      return { kind: "invalid-input", message: result.reason };
-    }
-    const entry = result.entry;
-
-    // Anchor policy: name-anchor-required tools must refuse declaration anchors
-    if (policy.nameAnchorRequired && entry.anchorKind === "declaration") {
-      return {
-        kind: "invalid-input",
-        message:
-          "The target resolved to a declaration anchor, not a name anchor. " +
-          "Re-resolve via `code_resolve` when the LSP has indexed the file, " +
-          "or pass `file` + `line` + `character` anchored on the identifier directly.",
-      };
-    }
+  const parsed = parseTargetInput(input, ["handle", "anchor", "symbol", "file"]);
+  if (parsed.kind === "invalid-input") return parsed;
+  const target = parsed.value;
 
-    const notes = inferTargetIdNotes(input);
-    return { kind: "resolved", entry, notes };
+  if ("handle" in target) {
+    return resolveHandle(target.handle, policy, deps);
   }
-
-  // ── 2. Anchored coordinates ────────────────────────────────────────
-  if (input.file && input.line != null && input.character != null) {
-    return resolveAnchoredWorkflow(input, policy, deps);
+  if ("anchor" in target) {
+    return resolveAnchoredWorkflow(target.anchor, policy, deps);
   }
-
-  // ── 3. Symbol query ────────────────────────────────────────────────
-  if (input.symbol) {
-    return resolveSymbolWorkflow(input, policy, deps);
+  if ("symbol" in target) {
+    return resolveSymbolWorkflow(target.symbol, policy, deps);
   }
-
-  // ── 4. File-only ───────────────────────────────────────────────────
-  if (input.file) {
-    if (!policy.fileLevelAllowed) {
-      return {
-        kind: "invalid-input",
-        message:
-          "File-level target resolution is not allowed for this tool. " +
-          "Provide anchored coordinates (`file`, `line`, `character`) or a `symbol`.",
-      };
-    }
-    return resolveFileOnlyWorkflow(input, deps);
+  if (!policy.fileLevelAllowed) {
+    return {
+      kind: "invalid-input",
+      message: "This workflow requires a handle, anchored point, or symbol target.",
+    };
   }
-
-  // ── 5. Nothing provided ────────────────────────────────────────────
-  return { kind: "no-target" };
+  return resolveFileOnlyWorkflow(target.file, policy.maxResults ?? 10, deps);
 }
 
-// ── Sub-routines ──────────────────────────────────────────────────────
+function resolveHandle(
+  handle: string,
+  policy: TargetWorkflowPolicy,
+  deps: TargetWorkflowDeps,
+): TargetWorkflowOutcome {
+  const result = deps.lookupTargetId(handle);
+  if (result.kind === "unavailable") {
+    return { kind: "invalid-input", message: result.reason };
+  }
+  if (policy.nameAnchorRequired && result.entry.anchorKind === "declaration") {
+    return {
+      kind: "invalid-input",
+      message:
+        "The target has a declaration anchor rather than the required name anchor. " +
+        "Resolve an identifier coordinate with code_resolve and retry.",
+    };
+  }
+  return { kind: "resolved", entry: immutableEntry(result.entry), notes: [] };
+}
 
 async function resolveAnchoredWorkflow(
-  input: TargetWorkflowInput,
+  anchor: { file: string; line: number; character: number },
   policy: TargetWorkflowPolicy,
   deps: TargetWorkflowDeps,
 ): Promise<TargetWorkflowOutcome> {
-  // biome-ignore lint/style/noNonNullAssertion: file is guaranteed non-null by caller guard branch
-  const file = normalizePath(input.file!, deps.cwd);
+  const file = normalizePath(anchor.file, deps.cwd);
   if (!existsSync(file)) {
-    return { kind: "invalid-input", message: `File not found: \`${input.file}\`` };
+    return { kind: "invalid-input", message: `File not found: \`${anchor.file}\`` };
   }
 
-  // Readiness gate
-  if (policy.waitForSemantic) {
-    const readiness = await deps.capability.ensureSemanticReadiness(deps.cwd, {
-      kind: "file",
-      file,
-    });
-    if (readiness.kind === "timeout") {
-      return {
-        kind: "unavailable",
-        reason: "LSP readiness timed out. Retry shortly or check `code_health`.",
-      };
-    }
-    if (readiness.kind === "unavailable") {
-      return { kind: "unavailable", reason: readiness.reason };
-    }
+  const readiness = await deps.capability.ensureSemanticReadiness(deps.cwd, {
+    kind: "file",
+    file,
+  });
+  if (readiness.kind === "timeout") {
+    return {
+      kind: "unavailable",
+      reason: "LSP readiness timed out. Retry shortly or inspect code_health.",
+    };
+  }
+  if (readiness.kind === "unavailable") {
+    return { kind: "unavailable", reason: readiness.reason };
   }
 
-  const provider = deps.capability.getProvider(deps.cwd);
-  // biome-ignore lint/style/noNonNullAssertion: line/character non-null by caller guard
-  const outcome = await resolveAnchoredSymbolTarget(file, input.line!, input.character!, provider);
-
-  return toWorkflowOutcome(outcome, policy, deps);
+  const outcome = await resolveAnchoredSymbolTarget(
+    file,
+    anchor.line,
+    anchor.character,
+    deps.capability.getProvider(deps.cwd),
+  );
+  return toWorkflowOutcome(
+    await refineTargetOutcomeIdentity(
+      outcome,
+      deps.cwd,
+      deps.capability.getStructuralProvider(deps.cwd) ?? undefined,
+    ),
+    policy,
+    deps,
+  );
 }
 
 async function resolveSymbolWorkflow(
-  input: TargetWorkflowInput,
+  symbol: { query: string; scope?: string; symbolKind?: TargetSymbolKind },
   policy: TargetWorkflowPolicy,
   deps: TargetWorkflowDeps,
 ): Promise<TargetWorkflowOutcome> {
-  const semantic = deps.capability.getSemanticProvider(deps.cwd);
-  if (!semantic) {
-    // Try to wait
-    if (policy.waitForSemantic) {
-      const readiness = await deps.capability.ensureSemanticReadiness(deps.cwd, {
-        kind: "workspace",
-      });
-      if (readiness.kind !== "ready") {
-        return {
-          kind: "unavailable",
-          reason:
-            "Symbol query requires an active LSP. Enable LSP and retry, or use anchored coordinates.",
-        };
-      }
-    } else {
-      return {
-        kind: "unavailable",
-        reason:
-          "Symbol query requires an active LSP. Enable LSP and retry, or use anchored coordinates.",
-      };
+  if (!symbol.query.trim()) {
+    return { kind: "invalid-input", message: "Symbol query must not be empty." };
+  }
+
+  let scope: string | undefined;
+  if (symbol.scope !== undefined) {
+    const resolved = resolveScope(symbol.scope, deps.cwd);
+    if (resolved.kind === "error") {
+      return { kind: "invalid-input", message: resolved.reason };
     }
+    scope = resolved.path;
+  }
+
+  const readiness = await deps.capability.ensureSemanticReadiness(deps.cwd, {
+    kind: "workspace",
+  });
+  if (readiness.kind === "timeout") {
+    return { kind: "unavailable", reason: "LSP readiness timed out. Retry shortly." };
+  }
+  if (readiness.kind === "unavailable") {
+    return { kind: "unavailable", reason: readiness.reason };
   }
 
-  // Re-read provider after potential wait
   const provider = deps.capability.getSemanticProvider(deps.cwd);
   if (!provider) {
     return {
       kind: "unavailable",
-      reason: "Symbol query requires an active LSP. Enable LSP and retry.",
+      reason: "Symbol resolution requires an active semantic provider.",
     };
   }
-  // biome-ignore lint/style/noNonNullAssertion: symbol non-null by caller guard
-  const outcome = await resolveSymbolTarget(input.symbol!, deps.cwd, provider, {
-    kind: input.kind,
-    exportedOnly: input.exportedOnly,
-    maxResults: input.maxResults,
-  });
 
-  return toWorkflowOutcome(outcome, policy, deps);
+  const outcome = await resolveSymbolTarget(symbol.query, deps.cwd, provider, {
+    path: scope,
+    kind: symbol.symbolKind,
+    maxResults: policy.maxResults,
+  });
+  return toWorkflowOutcome(
+    await refineTargetOutcomeIdentity(
+      outcome,
+      deps.cwd,
+      deps.capability.getStructuralProvider(deps.cwd) ?? undefined,
+    ),
+    policy,
+    deps,
+  );
 }
 
 async function resolveFileOnlyWorkflow(
-  input: TargetWorkflowInput,
+  requestedFile: string,
+  maxResults: number,
   deps: TargetWorkflowDeps,
 ): Promise<TargetWorkflowOutcome> {
-  // biome-ignore lint/style/noNonNullAssertion: file non-null by caller guard
-  const file = normalizePath(input.file!, deps.cwd);
-  if (!existsSync(file)) {
-    return { kind: "invalid-input", message: `File not found: \`${input.file}\`` };
+  const validation = validateFileTargetDiscovery(requestedFile, deps.cwd);
+  if (validation.kind === "invalid-input") return validation;
+  const file = validation.file;
+
+  const readiness = await deps.capability.ensureSemanticReadiness(deps.cwd, {
+    kind: "file",
+    file,
+  });
+  if (readiness.kind === "timeout") {
+    return { kind: "unavailable", reason: "LSP readiness timed out. Retry shortly." };
+  }
+  if (readiness.kind === "unavailable") {
+    return { kind: "unavailable", reason: readiness.reason };
   }
 
   const result = await resolveFileTargetGroup(file, deps.cwd, {
     semantic: deps.capability.getSemanticProvider(deps.cwd) ?? undefined,
     structural: deps.capability.getStructuralProvider(deps.cwd) ?? undefined,
   });
-  if (result.kind === "error") {
-    return { kind: "invalid-input", message: result.message };
+  if (result.kind === "invalid-input") return result;
+  if (result.kind === "unavailable") {
+    return { kind: "unavailable", reason: result.message };
   }
 
-  // Register the file-level target
-  const group = result.group;
-  const entry = deps.registerTarget({
-    file: group.file,
-    position: { line: 0, character: 0 },
-    displayLine: 1,
-    displayCharacter: 1,
-    name: group.displayName ?? null,
-    kind: null,
-    confidence: "structural",
-    provenance: "file-level",
-    anchorKind: "name",
-    container: null,
-  });
-
-  return { kind: "resolved", entry: entry.entry, notes: [] };
+  return registerTargetGroup(result.group, deps, maxResults);
 }
 
-// ── Outcome conversion ────────────────────────────────────────────────
-
-/**
- * Convert a raw {@link TargetOutcome} from analysis/target/* into a
- * {@link TargetWorkflowOutcome} with registered handles.
- */
 function toWorkflowOutcome(
   outcome: TargetOutcome,
-  _policy: TargetWorkflowPolicy,
+  policy: TargetWorkflowPolicy,
   deps: TargetWorkflowDeps,
 ): TargetWorkflowOutcome {
   if (outcome.kind === "error") {
@@ -334,97 +265,118 @@ function toWorkflowOutcome(
   }
 
   if (outcome.kind === "resolved") {
-    const entry = registerFromTargetData(outcome.target, deps);
+    if (policy.nameAnchorRequired && outcome.target.anchorKind === "declaration") {
+      return {
+        kind: "invalid-input",
+        message:
+          "The target resolved only to a declaration anchor. Resolve the identifier coordinate and retry.",
+      };
+    }
+    const registered = registerFromTargetData(outcome.target, deps);
     return {
       kind: "resolved",
-      entry: entry.entry,
+      entry: immutableEntry(registered.entry),
       notes: buildResolutionNotes(outcome.target),
     };
   }
 
-  if (outcome.kind === "disambiguation") {
-    const candidates = outcome.candidates.map((c, idx) => {
-      const registered = deps.registerTarget({
-        file: c.file,
-        position: { line: c.line - 1, character: c.character - 1 },
-        displayLine: c.line,
-        displayCharacter: c.character,
-        name: c.name,
-        kind: c.kind,
-        confidence: "semantic",
-        provenance: "symbol-query",
-        anchorKind: c.anchorKind ?? "declaration",
-        container: c.container,
-      });
-      return {
-        targetId: registered.targetId,
-        name: c.name,
-        kind: c.kind,
-        container: c.container,
-        file: c.file,
-        line: c.line,
-        character: c.character,
-        rank: idx + 1,
-        anchorKind: c.anchorKind ?? "declaration",
-      };
-    });
-    return { kind: "disambiguation", candidates, omittedCount: outcome.omittedCount };
+  if (outcome.kind === "group") {
+    return registerTargetGroup(outcome.group, deps, policy.maxResults ?? 10);
   }
 
-  // Unknown outcome kind — shouldn't happen with current resolvers
-  return { kind: "invalid-input", message: "Unexpected resolution outcome." };
+  const candidates = registerTargetCandidates(outcome.candidates, deps.registerTarget);
+  return outcome.kind === "kind-mismatch"
+    ? {
+        kind: "kind-mismatch",
+        requestedKind: outcome.requestedKind,
+        candidates,
+        omittedCount: outcome.omittedCount,
+      }
+    : {
+        kind: "disambiguation",
+        candidates,
+        omittedCount: outcome.omittedCount,
+      };
 }
 
-// ── Helpers ───────────────────────────────────────────────────────────
-
-/** Build notes for targetId precedence over other inputs. */
-function inferTargetIdNotes(input: TargetWorkflowInput): string[] {
-  const notes: string[] = [];
-  if (input.file || input.line != null || input.character != null) {
-    notes.push(
-      "_Note: `targetId` takes precedence over the supplied file/coordinates; " +
-        "file, line, and character were ignored._",
-    );
-  }
-  if (input.symbol) {
-    notes.push("_Note: `targetId` takes precedence over the supplied `symbol` parameter._");
-  }
-  return notes;
+function registerTargetGroup(
+  group: ResolvedTargetGroupData,
+  deps: TargetWorkflowDeps,
+  maxResults: number,
+): TargetWorkflowOutcome {
+  const totalCount = group.targets.length;
+  const visibleTargets = group.targets.slice(0, Math.max(0, maxResults));
+  const fingerprint = computeFileFingerprint(group.file);
+  const fileFingerprint = fingerprint.kind === "ok" ? fingerprint.fingerprint : "unfingerprinted";
+  const targets = visibleTargets.map((target) =>
+    immutableEntry(registerFromTargetData(target, deps, fileFingerprint).entry),
+  );
+  return Object.freeze({
+    kind: "target-group",
+    file: group.file,
+    confidence: group.confidence,
+    discoveryProvenance: Object.freeze([...group.discoveryProvenance]),
+    targets: Object.freeze(targets),
+    totalCount,
+    omittedCount: totalCount - targets.length,
+    unknownNestingCount: group.unknownNestingCount,
+  });
 }
 
-/** Build display notes for resolved anchored targets. */
-function buildResolutionNotes(target: ResolvedTargetData): string[] {
+function buildResolutionNotes(target: ResolvedTargetData): readonly string[] {
   const notes: string[] = [];
   if (target.resolution?.snapped) {
-    const src = target.resolution.source;
     notes.push(
-      `_Note: Resolved from a declaration header snap (${src}); the anchor was moved to the identifier._`,
+      `Resolved from a declaration header and snapped to the identifier (${target.resolution.source}).`,
     );
   }
   if (target.resolution?.source === "structural-identifier") {
-    notes.push(
-      "_Note: Resolved via tree-sitter structural evidence; semantic (LSP) symbols were unavailable._",
-    );
+    notes.push("Resolved from provider-backed structural identifier evidence.");
   }
-  return notes;
+  return Object.freeze(notes);
 }
 
-/** Register a ResolvedTargetData and return the store entry. */
 function registerFromTargetData(
   target: ResolvedTargetData,
   deps: TargetWorkflowDeps,
+  fileFingerprint?: string,
 ): TargetRegistrationOutput {
   return deps.registerTarget({
     file: target.file,
     position: target.position,
+    declarationPosition: {
+      line: target.declarationAnchor.line - 1,
+      character: target.declarationAnchor.character - 1,
+    },
+    declarationOccurrence: target.declarationOccurrence,
     displayLine: target.displayLine,
     displayCharacter: target.displayCharacter,
     name: target.name,
     kind: target.kind,
+    identityKind: target.identityKind ?? canonicalDeclarationKind(target.kind),
     confidence: target.confidence,
-    provenance: "target-workflow",
+    provenance: target.provenance,
     anchorKind: target.anchorKind,
     container: target.container,
     resolution: target.resolution,
+    fileFingerprint,
+  });
+}
+
+function immutableEntry(entry: TargetStoreEntry): Readonly<TargetStoreEntry> {
+  return Object.freeze({
+    ...entry,
+    position: Object.freeze({ ...entry.position }),
+    provenance: Object.freeze([...entry.provenance]),
+    declarationPosition: entry.declarationPosition
+      ? Object.freeze({ ...entry.declarationPosition })
+      : entry.declarationPosition,
+    resolution: entry.resolution
+      ? Object.freeze({
+          ...entry.resolution,
+          requested: Object.freeze({ ...entry.resolution.requested }),
+          resolved: Object.freeze({ ...entry.resolution.resolved }),
+        })
+      : undefined,
   });
 }