@shapeshift-labs/frontier-lang-compiler 0.2.31 → 0.2.33

package/dist/index.js

@@ -439,6 +439,18 @@ export const NativeParserAstFormatProfiles = Object.freeze([
     supportsErrorRecovery: true,
     notes: ['Java compiler/parser ASTs expose package/import/type/member declarations and source ranges; classpath/module-path, bindings, annotation processors, generated sources, Lombok expansion, comments/trivia, and control-flow evidence remain host-owned.']
   }),
+  nativeParserAstFormatProfile('kotlin-psi', {
+    aliases: ['kotlin-compiler', 'kotlin-compiler-psi', 'intellij-psi', 'kt-psi', 'kotlin-ast'],
+    kind: 'compiler-ast',
+    languages: ['kotlin'],
+    parserAdapters: ['kotlin-compiler', 'kotlin-psi', 'intellij-psi'],
+    exactness: 'exact-parser-ast',
+    sourceRangeModel: 'text-range-line-column',
+    preservesTokens: true,
+    preservesTrivia: true,
+    supportsErrorRecovery: true,
+    notes: ['Kotlin PSI exposes source syntax and IntelliJ parser errors; Analysis API symbols, FIR/K2 types, expect/actual matching, compiler plugins, generated sources, scripts, and build variants remain host-owned evidence.']
+  }),
   nativeParserAstFormatProfile('roslyn-csharp', {
     aliases: ['roslyn', 'csharp-roslyn', 'c#-roslyn', 'microsoft-codeanalysis-csharp', 'csharp-syntax'],
     kind: 'compiler-ast',
@@ -452,6 +464,19 @@ export const NativeParserAstFormatProfiles = Object.freeze([
     supportsErrorRecovery: true,
     notes: ['Roslyn C# syntax trees expose immutable nodes, tokens, trivia, spans, diagnostics, directives, and skipped text; SemanticModel symbols, nullable analysis, generated sources, partial type stitching, analyzer results, and project references remain host-owned evidence.']
   }),
+  nativeParserAstFormatProfile('swift-syntax', {
+    aliases: ['swiftsyntax', 'swiftparser', 'swift-parser', 'swift-syntax-json'],
+    kind: 'concrete-syntax-tree',
+    languages: ['swift'],
+    parserAdapters: ['swift-syntax', 'swiftparser'],
+    exactness: 'parser-tree',
+    sourceRangeModel: 'absolute-position-source-location',
+    preservesTokens: true,
+    preservesTrivia: true,
+    supportsIncremental: false,
+    supportsErrorRecovery: true,
+    notes: ['SwiftSyntax exposes a source-accurate syntax tree with missing/unexpected nodes and token/trivia structure; SourceKit symbols, macro expansion, conditional compilation branch resolution, type checking, generated sources, and package/module dependency resolution remain host-owned evidence.']
+  }),
   nativeParserAstFormatProfile('tree-sitter', {
     kind: 'concrete-syntax-tree',
     languages: ['mixed'],
@@ -2945,6 +2970,78 @@ export function createJavaAstNativeImporterAdapter(options = {}) {
   };
 }
 
+export function createKotlinPsiNativeImporterAdapter(options = {}) {
+  return {
+    id: options.id ?? 'frontier.kotlin-psi-native-importer',
+    language: options.language ?? 'kotlin',
+    parser: options.parser ?? 'kotlin-psi',
+    version: options.version,
+    capabilities: uniqueStrings(['nativeAst', 'semanticIndex', 'sourceMaps', 'diagnostics', ...(options.capabilities ?? [])]),
+    coverage: nativeImporterAdapterCoverage({
+      exactness: 'exact-parser-ast',
+      exactAst: true,
+      tokens: true,
+      trivia: true,
+      diagnostics: true,
+      sourceRanges: true,
+      generatedRanges: false,
+      semanticCoverage: declarationSemanticCoverage(),
+      notes: [
+        'Normalizes caller-owned Kotlin PSI/KtFile-shaped syntax trees into native AST nodes and declaration-level semantic index records.',
+        'Kotlin PSI imports do not resolve Analysis API symbols, FIR/K2 types, overloads, nullability flow, expect/actual matching, compiler-plugin generated declarations, KSP/KAPT output, scripts, build variants, or control flow by themselves; attach host evidence for those claims.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions ?? ['.kt', '.kts'],
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const parsed = input.options?.ast
+        ?? input.options?.nativeAst
+        ?? input.options?.ktFile
+        ?? input.options?.file
+        ?? input.options?.sourceFile
+        ?? input.options?.root
+        ?? options.ast
+        ?? options.ktFile
+        ?? options.file
+        ?? options.sourceFile
+        ?? options.root
+        ?? parseKotlinPsiSource(input, options);
+      const root = kotlinPsiRoot(parsed);
+      if (!root) {
+        return missingInjectedParserResult(input, {
+          parser: options.parser ?? 'kotlin-psi',
+          adapterId: options.id ?? 'frontier.kotlin-psi-native-importer',
+          message: 'createKotlinPsiNativeImporterAdapter requires an injected Kotlin PSI KtFile-shaped object, parserModule.parse function, parse function, or adapterOptions.ast.'
+        });
+      }
+      const parseDiagnostics = normalizeParserErrors(parsed?.errors ?? parsed?.diagnostics ?? parsed?.parseDiagnostics, input, {
+        parser: options.parser ?? 'kotlin-psi'
+      });
+      return createNativeImportFromKotlinPsi(root, input, {
+        parser: options.parser ?? 'kotlin-psi',
+        astFormat: 'kotlin-psi',
+        maxNodes: options.maxNodes,
+        diagnostics: parseDiagnostics,
+        kotlinVersion: options.kotlinVersion ?? input.options?.kotlinVersion ?? parsed?.kotlinVersion,
+        languageVersion: options.languageVersion ?? input.options?.languageVersion ?? parsed?.languageVersion,
+        apiVersion: options.apiVersion ?? input.options?.apiVersion ?? parsed?.apiVersion,
+        script: input.options?.script ?? options.script ?? parsed?.script ?? /\.kts$/i.test(input.sourcePath ?? ''),
+        generated: input.options?.generated ?? options.generated ?? parsed?.generated ?? kotlinGeneratedSourcePath(input.sourcePath),
+        analysisApiEvidence: input.options?.analysisApiEvidence ?? options.analysisApiEvidence ?? parsed?.analysisApiEvidence,
+        firEvidence: input.options?.firEvidence ?? options.firEvidence ?? parsed?.firEvidence,
+        compilerPluginEvidence: input.options?.compilerPluginEvidence ?? options.compilerPluginEvidence ?? parsed?.compilerPluginEvidence,
+        kspEvidence: input.options?.kspEvidence ?? options.kspEvidence ?? parsed?.kspEvidence,
+        kaptEvidence: input.options?.kaptEvidence ?? options.kaptEvidence ?? parsed?.kaptEvidence,
+        multiplatformEvidence: input.options?.multiplatformEvidence ?? options.multiplatformEvidence ?? parsed?.multiplatformEvidence,
+        buildVariantEvidence: input.options?.buildVariantEvidence ?? options.buildVariantEvidence ?? parsed?.buildVariantEvidence,
+        positionResolver: input.options?.positionResolver ?? options.positionResolver,
+        lineMap: input.options?.lineMap ?? options.lineMap ?? parsed?.lineMap,
+        includeAnnotations: options.includeAnnotations ?? input.options?.includeAnnotations
+      });
+    }
+  };
+}
+
 export function createCSharpRoslynNativeImporterAdapter(options = {}) {
   return {
     id: options.id ?? 'frontier.csharp-roslyn-native-importer',
@@ -3012,6 +3109,67 @@ export function createCSharpRoslynNativeImporterAdapter(options = {}) {
   };
 }
 
+export function createSwiftSyntaxNativeImporterAdapter(options = {}) {
+  return {
+    id: options.id ?? 'frontier.swift-syntax-native-importer',
+    language: options.language ?? 'swift',
+    parser: options.parser ?? 'swift-syntax',
+    version: options.version,
+    capabilities: uniqueStrings(['nativeAst', 'semanticIndex', 'sourceMaps', 'diagnostics', ...(options.capabilities ?? [])]),
+    coverage: nativeImporterAdapterCoverage({
+      exactness: 'parser-tree',
+      exactAst: true,
+      tokens: true,
+      trivia: true,
+      diagnostics: true,
+      sourceRanges: true,
+      generatedRanges: false,
+      semanticCoverage: declarationSemanticCoverage(),
+      notes: [
+        'Normalizes caller-owned SwiftSyntax/SwiftParser-shaped SourceFileSyntax trees into native AST nodes and declaration-level semantic index records.',
+        'SwiftSyntax imports do not resolve SourceKit symbols, type checking, macro expansions, conditional compilation branches, Objective-C bridging, generated sources, package/module dependencies, or control flow by themselves; attach host evidence for those claims.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions ?? ['.swift'],
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const parsed = input.options?.ast
+        ?? input.options?.nativeAst
+        ?? input.options?.sourceFile
+        ?? input.options?.sourceFileSyntax
+        ?? input.options?.root
+        ?? options.ast
+        ?? options.sourceFile
+        ?? options.sourceFileSyntax
+        ?? options.root
+        ?? parseSwiftSyntaxSource(input, options);
+      const root = swiftSyntaxRoot(parsed);
+      if (!root) {
+        return missingInjectedParserResult(input, {
+          parser: options.parser ?? 'swift-syntax',
+          adapterId: options.id ?? 'frontier.swift-syntax-native-importer',
+          message: 'createSwiftSyntaxNativeImporterAdapter requires an injected SwiftSyntax SourceFileSyntax-shaped object, parserModule.parse function, parse function, or adapterOptions.ast.'
+        });
+      }
+      const parseDiagnostics = normalizeParserErrors(parsed?.errors ?? parsed?.diagnostics ?? parsed?.parseDiagnostics, input, {
+        parser: options.parser ?? 'swift-syntax'
+      });
+      return createNativeImportFromSwiftSyntax(root, input, {
+        parser: options.parser ?? 'swift-syntax',
+        astFormat: 'swift-syntax',
+        maxNodes: options.maxNodes,
+        diagnostics: parseDiagnostics,
+        swiftVersion: options.swiftVersion ?? input.options?.swiftVersion ?? parsed?.swiftVersion,
+        languageMode: options.languageMode ?? input.options?.languageMode ?? parsed?.languageMode,
+        generated: input.options?.generated ?? options.generated ?? parsed?.generated ?? swiftGeneratedSourcePath(input.sourcePath),
+        sourceKitEvidence: input.options?.sourceKitEvidence ?? options.sourceKitEvidence ?? parsed?.sourceKitEvidence,
+        macroExpansionEvidence: input.options?.macroExpansionEvidence ?? options.macroExpansionEvidence ?? parsed?.macroExpansionEvidence,
+        packageResolutionEvidence: input.options?.packageResolutionEvidence ?? options.packageResolutionEvidence ?? parsed?.packageResolutionEvidence
+      });
+    }
+  };
+}
+
 export function createTreeSitterNativeImporterAdapter(options = {}) {
   return {
     id: options.id ?? `frontier.tree-sitter-${idFragment(options.language ?? 'source')}-native-importer`,
@@ -7455,7 +7613,9 @@ function parserAstFormatIdForParser(parser) {
   if (text.includes('clang') || text.includes('libclang')) return 'clang-ast-json';
   if (text === 'go' || text.includes('go-parser') || text.includes('go-ast') || text.includes('go/parser') || text.includes('go/ast')) return 'go-ast';
   if (text === 'java' || text.includes('javac') || text.includes('jdt') || text.includes('javaparser') || text.includes('java-parser') || text.includes('java-ast')) return 'java-ast';
+  if (text === 'kotlin' || text === 'kt' || text.includes('kotlin-psi') || text.includes('kotlin-compiler') || text.includes('intellij-psi') || text.includes('kt-psi')) return 'kotlin-psi';
   if (text === 'csharp' || text === 'c#' || text === 'cs' || text.includes('roslyn') || text.includes('microsoft-codeanalysis-csharp') || text.includes('csharp-syntax')) return 'roslyn-csharp';
+  if (text.includes('swift-syntax') || text.includes('swiftsyntax') || text.includes('swiftparser') || text.includes('swift-parser')) return 'swift-syntax';
   if (text.includes('tree-sitter') || text.includes('treesitter')) return 'tree-sitter';
   if (text.includes('babel')) return 'babel';
   if (text.includes('estree')) return 'estree';
@@ -8554,6 +8714,23 @@ function parseJavaAstSource(input, options) {
   return parse(input.sourceText, parserOptions);
 }
 
+function parseKotlinPsiSource(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.kotlinPsi?.parse ?? options.kotlinCompiler?.parse ?? options.intellijPsi?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourcePath: input.sourcePath,
+    filename: input.sourcePath,
+    kotlinVersion: options.kotlinVersion ?? input.options?.kotlinVersion,
+    languageVersion: options.languageVersion ?? input.options?.languageVersion,
+    apiVersion: options.apiVersion ?? input.options?.apiVersion,
+    script: options.script ?? input.options?.script ?? /\.kts$/i.test(input.sourcePath ?? ''),
+    includeAnnotations: options.includeAnnotations ?? input.options?.includeAnnotations,
+    ...(options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}
+
 function parseCSharpRoslynSource(input, options) {
   const parse = options.parse ?? options.parserModule?.parse ?? options.roslyn?.parse ?? options.csharpRoslyn?.parse;
   if (typeof parse !== 'function') return undefined;
@@ -8570,6 +8747,22 @@ function parseCSharpRoslynSource(input, options) {
   return parse(input.sourceText, parserOptions);
 }
 
+function parseSwiftSyntaxSource(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.swiftSyntax?.parse ?? options.swiftParser?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourcePath: input.sourcePath,
+    filename: input.sourcePath,
+    swiftVersion: options.swiftVersion ?? input.options?.swiftVersion,
+    languageMode: options.languageMode ?? input.options?.languageMode,
+    enableBareSlashRegex: options.enableBareSlashRegex ?? input.options?.enableBareSlashRegex,
+    parseTransition: options.parseTransition ?? input.options?.parseTransition,
+    ...(options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}
+
 function createNativeImportFromSyntaxAst(ast, input, options) {
   const root = normalizeSyntaxAstRoot(ast, options.astFormat);
   if (!root) {
@@ -8800,6 +8993,53 @@ function createNativeImportFromJavaAst(root, input, options) {
   };
 }
 
+function createNativeImportFromKotlinPsi(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitKotlinPsiNode(root, context, 'root');
+  if (context.truncated) {
+    context.losses.push(truncatedAstLoss(input, context, options));
+  }
+  if (options.generated && !context.losses.some((loss) => loss.kind === 'generatedCode')) {
+    context.losses.push(kotlinGeneratedCodeLoss(input, context.rootId, undefined, options));
+  }
+  if (options.script && !context.losses.some((loss) => loss.metadata?.script === true)) {
+    context.losses.push(kotlinScriptLoss(input, context.rootId, undefined, options));
+  }
+  const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  return {
+    rootId: context.rootId,
+    nodes: context.nodes,
+    semanticIndex: semantic.semanticIndex,
+    mappings: semantic.mappings,
+    losses: mergeNativeLosses(context.losses, options.diagnostics?.map((diagnostic, index) => adapterDiagnosticToLoss(diagnostic, index, {
+      id: input.adapterId,
+      version: input.adapterVersion
+    }, input)) ?? []),
+    evidence: semantic.evidence,
+    diagnostics: options.diagnostics,
+    metadata: {
+      astFormat: options.astFormat,
+      parser: options.parser,
+      kotlinVersion: options.kotlinVersion,
+      languageVersion: options.languageVersion,
+      apiVersion: options.apiVersion,
+      script: Boolean(options.script),
+      generated: options.generated,
+      analysisApiEvidence: kotlinEvidenceSummary(options.analysisApiEvidence),
+      firEvidence: kotlinEvidenceSummary(options.firEvidence),
+      compilerPluginEvidence: kotlinEvidenceSummary(options.compilerPluginEvidence),
+      kspEvidence: kotlinEvidenceSummary(options.kspEvidence),
+      kaptEvidence: kotlinEvidenceSummary(options.kaptEvidence),
+      multiplatformEvidence: kotlinEvidenceSummary(options.multiplatformEvidence),
+      buildVariantEvidence: kotlinEvidenceSummary(options.buildVariantEvidence),
+      includeAnnotations: Boolean(options.includeAnnotations),
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      truncated: context.truncated
+    }
+  };
+}
+
 function createNativeImportFromCSharpRoslyn(root, input, options) {
   const context = createAstNormalizationContext(input, options);
   visitCSharpRoslynNode(root, context, 'root');
@@ -8839,6 +9079,43 @@ function createNativeImportFromCSharpRoslyn(root, input, options) {
   };
 }
 
+function createNativeImportFromSwiftSyntax(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitSwiftSyntaxNode(root, context, 'root');
+  if (context.truncated) {
+    context.losses.push(truncatedAstLoss(input, context, options));
+  }
+  if (options.generated && !context.losses.some((loss) => loss.kind === 'generatedCode')) {
+    context.losses.push(swiftGeneratedCodeLoss(input, context.rootId, undefined, options));
+  }
+  const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  return {
+    rootId: context.rootId,
+    nodes: context.nodes,
+    semanticIndex: semantic.semanticIndex,
+    mappings: semantic.mappings,
+    losses: mergeNativeLosses(context.losses, options.diagnostics?.map((diagnostic, index) => adapterDiagnosticToLoss(diagnostic, index, {
+      id: input.adapterId,
+      version: input.adapterVersion
+    }, input)) ?? []),
+    evidence: semantic.evidence,
+    diagnostics: options.diagnostics,
+    metadata: {
+      astFormat: options.astFormat,
+      parser: options.parser,
+      swiftVersion: options.swiftVersion,
+      languageMode: options.languageMode,
+      generated: options.generated,
+      sourceKitEvidence: swiftEvidenceSummary(options.sourceKitEvidence),
+      macroExpansionEvidence: swiftEvidenceSummary(options.macroExpansionEvidence),
+      packageResolutionEvidence: swiftEvidenceSummary(options.packageResolutionEvidence),
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      truncated: context.truncated
+    }
+  };
+}
+
 function createNativeImportFromTreeSitter(root, input, options) {
   const context = createAstNormalizationContext(input, options);
   visitTreeSitterNode(root, context, 'root');
@@ -9400,6 +9677,108 @@ function visitCSharpRoslynNode(node, context, propertyPath) {
   return id;
 }
 
+function visitSwiftSyntaxNode(node, context, propertyPath) {
+  if (!isSwiftSyntaxNode(node) || context.truncated) return undefined;
+  if (context.objectIds.has(node)) return context.objectIds.get(node);
+  if (context.counter >= context.maxNodes) {
+    context.truncated = true;
+    return undefined;
+  }
+  const kind = swiftSyntaxKind(node);
+  const span = spanFromSwiftSyntaxNode(node, context.input, context.options);
+  const id = nativeNodeId(context, kind, { start: { line: span?.startLine, column: span?.startColumn } }, propertyPath);
+  context.objectIds.set(node, id);
+  if (!context.rootId) context.rootId = id;
+  const children = [];
+  for (const [field, value] of swiftSyntaxChildEntries(node, kind)) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        const childId = visitSwiftSyntaxNode(entry, context, `${propertyPath}.${field}[${index}]`);
+        if (childId) children.push(childId);
+      });
+    } else {
+      const childId = visitSwiftSyntaxNode(value, context, `${propertyPath}.${field}`);
+      if (childId) children.push(childId);
+    }
+  }
+  const declarations = swiftSyntaxDeclarations(node, kind, id, context.input);
+  const declaration = declarations[0];
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? swiftSyntaxNodeValue(node),
+    fields: primitiveSwiftSyntaxFields(node, kind),
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      positionKind: swiftSyntaxPositionKind(node),
+      parser: context.options.parser
+    }
+  };
+  context.nodes[id] = nativeNode;
+  for (const entry of declarations) {
+    context.declarations.push({ ...entry, nativeNode });
+  }
+  if (swiftSyntaxRecoveredKind(kind) || swiftSyntaxProblemNode(node, kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_swift_syntax_recovered_node`,
+      severity: 'error',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'unsupportedSyntax',
+      message: 'SwiftSyntax reported missing, unexpected, skipped, or error syntax; semantic import is partial until syntax errors are resolved.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        nodeKind: kind
+      }
+    });
+  }
+  if (swiftSyntaxConditionalCompilationKind(kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_swift_conditional_compilation`,
+      severity: 'warning',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'conditionalCompilation',
+      message: 'Swift conditional compilation syntax was imported; active branch selection and inactive branch source ownership require host build-setting evidence.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        nodeKind: kind
+      }
+    });
+  }
+  if (swiftSyntaxMacroKind(kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_swift_macro_expansion`,
+      severity: 'warning',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'macroExpansion',
+      message: 'Swift macro syntax was imported, but expansion, generated declarations, and binding effects require host macro-expansion evidence.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        nodeKind: kind
+      }
+    });
+  }
+  if (swiftGeneratedCodeMarker(node, kind)) {
+    context.losses.push(swiftGeneratedCodeLoss(context.input, id, span, context.options, { nodeKind: kind }));
+  }
+  return id;
+}
+
 function visitTreeSitterNode(node, context, propertyPath) {
   if (!node || typeof node !== 'object' || context.truncated) return undefined;
   if (context.objectIds.has(node)) return context.objectIds.get(node);
@@ -12118,137 +12497,1281 @@ function javaBindingEvidenceSummary(value) {
   return Object.keys(summary).length ? summary : { present: true };
 }
 
-function csharpRoslynRoot(value) {
+function kotlinPsiRoot(value) {
   if (!value || typeof value !== 'object') return undefined;
-  if (isCSharpRoslynNode(value)) return value;
-  if (isCSharpRoslynNode(value.ast)) return value.ast;
-  if (isCSharpRoslynNode(value.root)) return value.root;
-  if (isCSharpRoslynNode(value.rootNode)) return value.rootNode;
-  if (isCSharpRoslynNode(value.compilationUnit)) return value.compilationUnit;
-  if (isCSharpRoslynNode(value.syntaxTree)) return csharpRoslynRoot(value.syntaxTree);
-  if (isCSharpRoslynNode(value.tree)) return csharpRoslynRoot(value.tree);
-  if (Array.isArray(value.members) || Array.isArray(value.usings) || Array.isArray(value.externs)) {
-    return { kind: 'CompilationUnit', ...value };
+  if (isKotlinPsiNode(value)) return value;
+  if (isKotlinPsiNode(value.ast)) return value.ast;
+  if (isKotlinPsiNode(value.root)) return value.root;
+  if (isKotlinPsiNode(value.rootNode)) return value.rootNode;
+  if (isKotlinPsiNode(value.ktFile)) return value.ktFile;
+  if (isKotlinPsiNode(value.file)) return value.file;
+  if (isKotlinPsiNode(value.sourceFile)) return value.sourceFile;
+  if (Array.isArray(value.declarations) || Array.isArray(value.imports) || value.packageDirective) {
+    return { kind: 'KtFile', ...value };
   }
   return undefined;
 }
 
-function isCSharpRoslynNode(value) {
-  return Boolean(value && typeof value === 'object' && typeof csharpRoslynKind(value) === 'string');
+function isKotlinPsiNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof kotlinPsiKind(value) === 'string');
 }
 
-function csharpRoslynKind(node) {
+function kotlinPsiKind(node) {
   if (!node || typeof node !== 'object') return undefined;
-  const declared = node.kind ?? node.Kind ?? node._type ?? node.type ?? node.nodeType ?? node.syntaxKind ?? node.SyntaxKind;
-  if (typeof declared === 'string') return normalizeCSharpRoslynKind(declared);
-  if (Array.isArray(node.members) || Array.isArray(node.usings) || Array.isArray(node.externs)) return 'CompilationUnit';
-  if (node.identifier && (node.members || node.baseList || node.parameterList || node.modifiers)) return 'ClassDeclaration';
-  if (node.declaration && (node.eventKeyword || node.eventField)) return 'EventFieldDeclaration';
-  if (node.declaration && Array.isArray(node.declaration.variables)) return 'FieldDeclaration';
+  const declared = node.kind ?? node.nodeType ?? node.elementType ?? node.psiKind ?? node._type ?? node.type;
+  if (typeof declared === 'string') return normalizeKotlinPsiKind(declared);
+  if (Array.isArray(node.declarations) || Array.isArray(node.imports) || node.packageDirective) return 'KtFile';
+  if (node.fqName || node.packageFqName) return 'KtPackageDirective';
+  if (node.importedFqName || node.importedReference) return 'KtImportDirective';
+  if (node.classKind || node.primaryConstructor || node.superTypeListEntries) return 'KtClass';
+  if (node.funKeyword || node.valueParameters || node.bodyExpression) return 'KtNamedFunction';
+  if (node.valOrVarKeyword || node.delegateExpression || node.initializer) return 'KtProperty';
   return undefined;
 }
 
-function normalizeCSharpRoslynKind(kind) {
+function normalizeKotlinPsiKind(kind) {
   const text = String(kind)
-    .replace(/^(?:Microsoft\.CodeAnalysis\.CSharp\.Syntax\.|Microsoft\.CodeAnalysis\.CSharp\.)/, '')
-    .replace(/Syntax$/, '');
+    .replace(/^org\.jetbrains\.kotlin\.psi\./, '')
+    .replace(/^KtNodeTypes\./, '')
+    .replace(/ElementType$/, '');
   const compact = text.replace(/[_\s.-]+/g, '').toLowerCase();
-  if (compact === 'compilationunit') return 'CompilationUnit';
-  if (compact === 'usingdirective') return 'UsingDirective';
-  if (compact === 'namespacedeclaration') return 'NamespaceDeclaration';
-  if (compact === 'filescopednamespacedeclaration') return 'FileScopedNamespaceDeclaration';
-  if (compact === 'classdeclaration') return 'ClassDeclaration';
-  if (compact === 'interfacedeclaration') return 'InterfaceDeclaration';
-  if (compact === 'structdeclaration') return 'StructDeclaration';
-  if (compact === 'recorddeclaration') return 'RecordDeclaration';
-  if (compact === 'recordstructdeclaration') return 'RecordStructDeclaration';
-  if (compact === 'enumdeclaration') return 'EnumDeclaration';
-  if (compact === 'methoddeclaration') return 'MethodDeclaration';
-  if (compact === 'constructordeclaration') return 'ConstructorDeclaration';
-  if (compact === 'destructordeclaration') return 'DestructorDeclaration';
-  if (compact === 'operatordeclaration') return 'OperatorDeclaration';
-  if (compact === 'conversionoperatordeclaration') return 'ConversionOperatorDeclaration';
-  if (compact === 'propertydeclaration') return 'PropertyDeclaration';
-  if (compact === 'indexerdeclaration') return 'IndexerDeclaration';
-  if (compact === 'fielddeclaration') return 'FieldDeclaration';
-  if (compact === 'variabledeclarator') return 'VariableDeclarator';
-  if (compact === 'eventdeclaration') return 'EventDeclaration';
-  if (compact === 'eventfielddeclaration') return 'EventFieldDeclaration';
-  if (compact === 'delegatedeclaration') return 'DelegateDeclaration';
-  if (compact === 'enummemberdeclaration') return 'EnumMemberDeclaration';
-  if (compact === 'attributelist') return 'AttributeList';
-  if (compact === 'attribute') return 'Attribute';
-  if (compact === 'parameter') return 'Parameter';
-  if (compact === 'incompletemember') return 'IncompleteMember';
-  if (compact === 'skippedtokenstrivia' || compact === 'skippedtokens') return 'SkippedTokensTrivia';
-  if (compact.endsWith('directivetrivia')) return `${upperFirst(compact.slice(0, -'directivetrivia'.length))}DirectiveTrivia`;
+  const known = {
+    kotlinfile: 'KtFile',
+    ktfile: 'KtFile',
+    file: 'KtFile',
+    script: 'KtScript',
+    ktscript: 'KtScript',
+    packagedirective: 'KtPackageDirective',
+    ktpackagedirective: 'KtPackageDirective',
+    importdirective: 'KtImportDirective',
+    ktimportdirective: 'KtImportDirective',
+    class: 'KtClass',
+    ktclass: 'KtClass',
+    classorobject: 'KtClassOrObject',
+    ktclassorobject: 'KtClassOrObject',
+    objectdeclaration: 'KtObjectDeclaration',
+    ktobjectdeclaration: 'KtObjectDeclaration',
+    enumentry: 'KtEnumEntry',
+    ktenumentry: 'KtEnumEntry',
+    namedfunction: 'KtNamedFunction',
+    ktnamedfunction: 'KtNamedFunction',
+    function: 'KtNamedFunction',
+    property: 'KtProperty',
+    ktproperty: 'KtProperty',
+    typealias: 'KtTypeAlias',
+    kttypealias: 'KtTypeAlias',
+    parameter: 'KtParameter',
+    ktparameter: 'KtParameter',
+    primaryconstructor: 'KtPrimaryConstructor',
+    ktprimaryconstructor: 'KtPrimaryConstructor',
+    secondaryconstructor: 'KtSecondaryConstructor',
+    ktsecondaryconstructor: 'KtSecondaryConstructor',
+    classinitializer: 'KtClassInitializer',
+    ktclassinitializer: 'KtClassInitializer',
+    annotationentry: 'KtAnnotationEntry',
+    ktannotationentry: 'KtAnnotationEntry',
+    contracteffect: 'KtContractEffect',
+    ktcontracteffect: 'KtContractEffect',
+    contractdescription: 'KtContractDescription',
+    ktcontractdescription: 'KtContractDescription',
+    error: 'PsiErrorElement',
+    psierror: 'PsiErrorElement',
+    psierrorelement: 'PsiErrorElement'
+  };
+  if (known[compact]) return known[compact];
+  if (/^[A-Z0-9_]+$/.test(text)) return text.toLowerCase().split('_').map(upperFirst).join('');
+  return text;
+}
+
+function ignoredKotlinPsiField(key) {
+  return key === '_type'
+    || key === 'type'
+    || key === 'kind'
+    || key === 'nodeType'
+    || key === 'elementType'
+    || key === 'psiKind'
+    || key === 'parent'
+    || key === 'parentKind'
+    || key === 'parentField'
+    || key === 'textRange'
+    || key === 'range'
+    || key === 'span'
+    || key === 'location'
+    || key === 'name'
+    || key === 'nameIdentifier'
+    || key === 'identifier'
+    || key === 'fqName'
+    || key === 'packageFqName'
+    || key === 'analysisSymbol'
+    || key === 'symbol'
+    || key === 'typeInfo'
+    || key === 'bindingContext'
+    || key === 'fir'
+    || key === 'ir';
+}
+
+function visitKotlinPsiNode(node, context, propertyPath) {
+  if (!isKotlinPsiNode(node) || context.truncated) return undefined;
+  if (context.objectIds.has(node)) return context.objectIds.get(node);
+  if (context.counter >= context.maxNodes) {
+    context.truncated = true;
+    return undefined;
+  }
+  const kind = kotlinPsiKind(node);
+  const span = spanFromKotlinPsiNode(node, context.input, context.options);
+  const id = nativeNodeId(context, kind, { start: { line: span?.startLine, column: span?.startColumn } }, propertyPath);
+  context.objectIds.set(node, id);
+  if (!context.rootId) context.rootId = id;
+  const children = [];
+  for (const [field, value] of kotlinPsiChildEntries(node, kind)) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        const childId = visitKotlinPsiNode(entry, context, `${propertyPath}.${field}[${index}]`);
+        if (childId) children.push(childId);
+      });
+    } else {
+      const childId = visitKotlinPsiNode(value, context, `${propertyPath}.${field}`);
+      if (childId) children.push(childId);
+    }
+  }
+  const declarations = kotlinPsiDeclarations(node, kind, id, context.input);
+  const declaration = declarations[0];
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? kotlinPsiNodeValue(node),
+    fields: primitiveKotlinPsiFields(node, kind),
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      positionKind: kotlinPsiPositionKind(node),
+      parser: context.options.parser
+    }
+  };
+  context.nodes[id] = nativeNode;
+  for (const entry of declarations) {
+    context.declarations.push({ ...entry, nativeNode });
+  }
+  if (kotlinPsiRecoveredKind(kind) || kotlinPsiProblemNode(node, kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_kotlin_psi_recovered_node`,
+      severity: 'error',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'unsupportedSyntax',
+      message: 'Kotlin PSI reported an error or recovered syntax node; semantic import is partial until syntax errors are resolved.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        nodeKind: kind
+      }
+    });
+  }
+  if (kotlinExpectActualNode(node, kind)) {
+    context.losses.push(kotlinUnsupportedSemanticLoss(context.input, id, span, context.options, {
+      nodeKind: kind,
+      feature: 'expect-actual',
+      message: 'Kotlin expect/actual syntax was imported; matching platform declarations requires multiplatform build evidence.'
+    }));
+  }
+  if (kotlinCoroutineNode(node, kind)) {
+    context.losses.push(kotlinUnsupportedSemanticLoss(context.input, id, span, context.options, {
+      nodeKind: kind,
+      feature: 'coroutine',
+      message: 'Kotlin coroutine syntax was imported; suspend lowering, scheduling, and effect semantics require host compiler/runtime evidence.'
+    }));
+  }
+  if (kotlinContractNode(kind)) {
+    context.losses.push(kotlinUnsupportedSemanticLoss(context.input, id, span, context.options, {
+      nodeKind: kind,
+      feature: 'contract',
+      message: 'Kotlin contract syntax was imported; data-flow effects require Analysis API or compiler evidence.'
+    }));
+  }
+  if (kotlinCompilerPluginAnnotationNode(node, kind) && !context.options.compilerPluginEvidence) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_kotlin_compiler_plugin_semantics`,
+      severity: 'warning',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'metaprogramming',
+      message: 'Kotlin compiler-plugin-style annotation was imported; generated declarations and transformed semantics require compiler plugin evidence.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        nodeKind: kind,
+        annotations: kotlinPsiAnnotationNames(node)
+      }
+    });
+  }
+  if (kotlinGeneratedCodeMarker(node, kind)) {
+    context.losses.push(kotlinGeneratedCodeLoss(context.input, id, span, context.options, { nodeKind: kind }));
+  }
+  return id;
+}
+
+function primitiveKotlinPsiFields(node, kind) {
+  const fields = { kind };
+  const name = kotlinPsiDeclarationName(node, kind);
+  if (name) fields.name = name;
+  const importPath = kotlinPsiImportPath(node);
+  if (importPath) fields.importPath = importPath;
+  const packageName = kotlinPsiPackageName(node);
+  if (packageName) fields.packageName = packageName;
+  const type = kotlinPsiTypeName(node.typeReference ?? node.returnTypeRef ?? node.returnType ?? node.type);
+  if (type) fields.type = type;
+  const receiver = kotlinPsiTypeName(node.receiverTypeReference ?? node.receiverTypeRef);
+  if (receiver) fields.receiverType = receiver;
+  const modifiers = kotlinPsiModifiers(node);
+  if (modifiers.length) fields.modifiers = modifiers.join(',');
+  const annotations = kotlinPsiAnnotationNames(node);
+  if (annotations.length) fields.annotations = annotations.join(',');
+  if (node.generated === true || node.isGenerated === true) fields.generated = true;
+  if (node.isScript === true || kind === 'KtScript') fields.script = true;
+  if (Array.isArray(node.typeParameters ?? node.typeParameterList?.parameters)) fields.typeParameterCount = (node.typeParameters ?? node.typeParameterList?.parameters).length;
+  if (Array.isArray(node.valueParameters ?? node.valueParameterList?.parameters ?? node.parameters)) fields.parameterCount = (node.valueParameters ?? node.valueParameterList?.parameters ?? node.parameters).length;
+  if (Array.isArray(node.superTypeListEntries ?? node.superTypes)) fields.superTypeCount = (node.superTypeListEntries ?? node.superTypes).length;
+  return fields;
+}
+
+function spanFromKotlinPsiNode(node, input, options = {}) {
+  const direct = spanFromKotlinLineFields(node, input);
+  if (direct) return direct;
+  const range = node.sourceRange ?? node.range ?? node.span ?? node.textRange;
+  const fromRange = spanFromKotlinRange(range, input);
+  if (fromRange) return fromRange;
+  const start = kotlinPsiPosition(node.start ?? node.startOffset ?? range?.startOffset ?? range?.start, options);
+  const end = kotlinPsiPosition(node.end ?? node.endOffset ?? range?.endOffset ?? range?.end, options);
+  if (!start) return undefined;
+  return {
+    sourceId: input.sourceHash,
+    path: start.path ?? end?.path ?? input.sourcePath,
+    startLine: start.line,
+    startColumn: start.column,
+    endLine: end?.line,
+    endColumn: end?.column
+  };
+}
+
+function spanFromKotlinLineFields(node, input) {
+  const startLine = node.startLine ?? node.line ?? node.beginLine;
+  if (typeof startLine !== 'number') return undefined;
+  return {
+    sourceId: input.sourceHash,
+    path: node.path ?? node.filePath ?? node.file ?? input.sourcePath,
+    startLine,
+    startColumn: node.startColumn ?? node.column ?? node.beginColumn,
+    endLine: node.endLine,
+    endColumn: node.endColumn
+  };
+}
+
+function spanFromKotlinRange(range, input) {
+  if (!range || typeof range !== 'object') return undefined;
+  const start = range.start ?? range.startPosition ?? range.lowerBound ?? range.begin;
+  const end = range.end ?? range.endPosition ?? range.upperBound;
+  const line = start?.line ?? start?.Line;
+  if (typeof line !== 'number') return undefined;
+  const column = start.column ?? start.character ?? start.offset ?? start.Column;
+  const endLine = end?.line ?? end?.Line;
+  const endColumn = end?.column ?? end?.character ?? end?.offset ?? end?.Column;
+  return {
+    sourceId: input.sourceHash,
+    path: range.path ?? range.filePath ?? range.file ?? input.sourcePath,
+    startLine: line,
+    startColumn: typeof column === 'number' ? column : undefined,
+    endLine: typeof endLine === 'number' ? endLine : undefined,
+    endColumn: typeof endColumn === 'number' ? endColumn : undefined
+  };
+}
+
+function kotlinPsiPosition(value, options = {}) {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value === 'object') {
+    const position = value.position ?? value.location ?? value;
+    const line = position.line ?? position.Line;
+    const column = position.column ?? position.character ?? position.Column;
+    if (typeof line === 'number') {
+      return {
+        path: position.path ?? position.filePath ?? position.file,
+        line,
+        column: typeof column === 'number' ? column : undefined
+      };
+    }
+  }
+  const resolver = typeof options.positionResolver === 'function'
+    ? options.positionResolver
+    : typeof options.lineMap?.position === 'function'
+      ? options.lineMap.position.bind(options.lineMap)
+      : typeof options.lineMap?.getLineAndColumn === 'function'
+        ? options.lineMap.getLineAndColumn.bind(options.lineMap)
+        : undefined;
+  if (resolver) {
+    const resolved = resolver(value);
+    if (resolved !== value) return kotlinPsiPosition(resolved, options);
+  }
+  return undefined;
+}
+
+function kotlinPsiPositionKind(node) {
+  if (node.textRange || node.range) return 'text-range';
+  if (typeof node.startOffset === 'number') return 'offset';
+  if (typeof node.startLine === 'number' || typeof node.line === 'number') return 'line-column-fields';
+  return undefined;
+}
+
+function kotlinPsiDeclarations(node, kind, nativeNodeId, input) {
+  if (kind === 'KtPackageDirective') {
+    const name = kotlinPsiPackageName(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'namespace', 'definition')] : [];
+  }
+  if (kind === 'KtImportDirective') {
+    const name = kotlinPsiImportPath(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'module', 'import')] : [];
+  }
+  if (kotlinPsiTypeDeclarationKind(kind)) {
+    const name = kotlinPsiDeclarationName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, kotlinPsiTypeDeclarationSymbolKind(node, kind), 'definition')] : [];
+  }
+  if (kind === 'KtTypeAlias') {
+    const name = kotlinPsiDeclarationName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'type', 'definition')] : [];
+  }
+  if (kind === 'KtNamedFunction') {
+    const name = kotlinPsiDeclarationName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, node.parentKind && kotlinPsiTypeDeclarationKind(node.parentKind) ? 'method' : 'function', kotlinPsiHasBody(node) ? 'definition' : 'declaration')] : [];
+  }
+  if (kind === 'KtProperty') {
+    return kotlinPsiVariableNames(node).map((name) => declarationRecord(input, nativeNodeId, name, 'property', 'definition'));
+  }
+  if (kind === 'KtParameter' && node.parentKind === 'KtPrimaryConstructor') {
+    return kotlinPsiVariableNames(node).map((name) => declarationRecord(input, nativeNodeId, name, 'property', 'definition'));
+  }
+  if (kind === 'KtPrimaryConstructor' || kind === 'KtSecondaryConstructor') {
+    return [declarationRecord(input, nativeNodeId, kotlinPsiDeclarationName(node, kind) ?? 'constructor', 'method', 'definition')];
+  }
+  if (kind === 'KtEnumEntry') {
+    const name = kotlinPsiDeclarationName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'enumMember', 'definition')] : [];
+  }
+  return [];
+}
+
+function kotlinPsiChildEntries(node, kind = kotlinPsiKind(node)) {
+  const fieldNames = Object.keys(node).filter((key) => !ignoredKotlinPsiField(key));
+  const entries = [];
+  for (const field of fieldNames) {
+    const value = node[field];
+    if (Array.isArray(value)) {
+      entries.push([field, value.map((entry) => kotlinPsiChildWithParent(entry, kind, field))]);
+      continue;
+    }
+    if (value && typeof value === 'object') {
+      entries.push([field, kotlinPsiChildWithParent(value, kind, field)]);
+    }
+  }
+  return entries.filter(([, value]) => Array.isArray(value)
+    ? value.some(isKotlinPsiNode)
+    : isKotlinPsiNode(value));
+}
+
+function kotlinPsiChildWithParent(entry, parentKind, parentField) {
+  if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return entry;
+  if (!isKotlinPsiNode(entry)) return entry;
+  return { parentKind, parentField, ...entry };
+}
+
+function kotlinPsiNodeValue(node) {
+  return kotlinPsiDeclarationName(node, kotlinPsiKind(node))
+    ?? kotlinPsiImportPath(node)
+    ?? kotlinPsiPackageName(node)
+    ?? kotlinPsiTypeName(node.typeReference ?? node.returnTypeRef ?? node.type);
+}
+
+function kotlinPsiDeclarationName(node, kind = kotlinPsiKind(node)) {
+  if (!node || typeof node !== 'object') return undefined;
+  if (kind === 'KtPrimaryConstructor' || kind === 'KtSecondaryConstructor') return 'constructor';
+  if (kind === 'KtClassInitializer') return 'init';
+  if (kind === 'KtObjectDeclaration' && node.isCompanion === true && !node.name && !node.nameIdentifier) return 'companion object';
+  for (const key of ['nameIdentifier', 'identifier', 'name', 'simpleName', 'classId', 'fqName', 'id']) {
+    const name = kotlinPsiName(node[key]);
+    if (name) return name;
+  }
+  const variable = kotlinPsiVariableNames(node)[0];
+  if (variable) return variable;
+  return undefined;
+}
+
+function kotlinPsiName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.asString === 'string') return value.asString;
+  if (typeof value.identifier === 'string') return value.identifier;
+  if (typeof value.name === 'string') return value.name;
+  if (typeof value.text === 'string') return value.text;
+  if (typeof value.value === 'string') return value.value;
+  if (typeof value.fqName === 'string') return value.fqName;
+  if (value.shortName && value.shortName !== value) return kotlinPsiName(value.shortName);
+  if (value.name && value.name !== value) return kotlinPsiName(value.name);
+  if (value.identifier && value.identifier !== value) return kotlinPsiName(value.identifier);
+  return undefined;
+}
+
+function kotlinPsiImportPath(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const path = node.importedFqName ?? node.importedReference ?? node.importPath ?? node.path ?? node.name;
+  if (typeof path === 'string') return path;
+  if (path && typeof path === 'object') return kotlinPsiName(path.fqName ?? path.name ?? path);
+  return undefined;
+}
+
+function kotlinPsiPackageName(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const value = node.packageFqName ?? node.fqName ?? node.qualifiedName ?? node.packageName;
+  if (typeof value === 'string') return value;
+  if (value && typeof value === 'object') return kotlinPsiName(value);
+  return undefined;
+}
+
+function kotlinPsiVariableNames(node) {
+  const variables = node.variables ?? node.entries ?? node.declarations;
+  if (Array.isArray(variables)) return variables.map(kotlinPsiDeclarationName).filter(Boolean);
+  const name = kotlinPsiName(node.nameIdentifier ?? node.identifier ?? node.name);
+  return name ? [name] : [];
+}
+
+function kotlinPsiTypeName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.text === 'string') return value.text.trim();
+  if (typeof value.name === 'string') return value.name;
+  if (typeof value.fqName === 'string') return value.fqName;
+  if (value.typeElement) return kotlinPsiTypeName(value.typeElement);
+  if (value.typeReference) return kotlinPsiTypeName(value.typeReference);
+  if (value.referencedName) return kotlinPsiName(value.referencedName);
+  if (value.constructorReferenceExpression) return kotlinPsiTypeName(value.constructorReferenceExpression);
+  if (Array.isArray(value.typeArguments) || Array.isArray(value.arguments)) {
+    const base = kotlinPsiName(value.name ?? value.referencedName ?? value.constructorReferenceExpression);
+    const args = (value.typeArguments ?? value.arguments).map((entry) => kotlinPsiTypeName(entry.typeReference ?? entry)).filter(Boolean);
+    return base ? `${base}<${args.join(', ')}>` : undefined;
+  }
+  return kotlinPsiName(value);
+}
+
+function kotlinPsiModifiers(node) {
+  const raw = node.modifiers ?? node.modifierList?.modifiers ?? node.modifierList?.children;
+  const names = [];
+  if (Array.isArray(raw)) {
+    for (const entry of raw) {
+      const name = typeof entry === 'string' ? entry : kotlinPsiName(entry) ?? entry?.keyword ?? entry?.tokenType ?? entry?.text;
+      if (name) names.push(String(name).toLowerCase());
+    }
+  } else if (typeof raw === 'string') {
+    names.push(...raw.split(/\s+/).filter(Boolean).map((entry) => entry.toLowerCase()));
+  } else if (raw && typeof raw === 'object') {
+    for (const [key, enabled] of Object.entries(raw)) {
+      if (enabled === true) names.push(key.toLowerCase());
+    }
+  }
+  for (const key of ['suspend', 'expect', 'actual', 'inline', 'operator', 'infix', 'tailrec', 'external', 'override', 'data', 'sealed', 'value']) {
+    if (node[key] === true || node[`is${upperFirst(key)}`] === true) names.push(key);
+  }
+  return uniqueStrings(names.map((entry) => entry.replace(/keyword$/i, '').replace(/_keyword$/i, '').replace(/[_\s-]+/g, '').toLowerCase()).filter(Boolean));
+}
+
+function kotlinPsiAnnotationNames(node) {
+  const entries = node.annotationEntries ?? node.annotations ?? node.modifierList?.annotationEntries;
+  if (!entries) return [];
+  if (Array.isArray(entries)) {
+    return uniqueStrings(entries.map((entry) => typeof entry === 'string' ? entry : kotlinPsiName(entry.shortName ?? entry.calleeExpression ?? entry.typeReference ?? entry.name ?? entry)).filter(Boolean));
+  }
+  return [];
+}
+
+function kotlinPsiTypeDeclarationKind(kind) {
+  return kind === 'KtClass'
+    || kind === 'KtClassOrObject'
+    || kind === 'KtObjectDeclaration';
+}
+
+function kotlinPsiTypeDeclarationSymbolKind(node, kind) {
+  const classKind = String(node.classKind ?? node.kindKeyword ?? '').toLowerCase();
+  if (kind === 'KtObjectDeclaration') return 'class';
+  if (classKind.includes('interface')) return 'interface';
+  if (classKind.includes('enum')) return 'enum';
+  if (classKind.includes('annotation')) return 'type';
+  return 'class';
+}
+
+function kotlinPsiHasBody(node) {
+  return Boolean(node.bodyExpression || node.bodyBlockExpression || node.body || Array.isArray(node.statements));
+}
+
+function kotlinPsiRecoveredKind(kind) {
+  return kind === 'PsiErrorElement'
+    || kind === 'KtErrorElement'
+    || /Error|Recovery|Incomplete|Missing|Skipped/.test(String(kind));
+}
+
+function kotlinPsiProblemNode(node, kind) {
+  return Boolean(
+    node.hasError
+    || node.containsDiagnostics
+    || node.containsSkippedText
+    || node.isMissing
+    || kind === 'PsiErrorElement'
+    || kind === 'KtErrorElement'
+  );
+}
+
+function kotlinExpectActualNode(node) {
+  const modifiers = kotlinPsiModifiers(node);
+  return modifiers.includes('expect') || modifiers.includes('actual');
+}
+
+function kotlinCoroutineNode(node, kind) {
+  const modifiers = kotlinPsiModifiers(node);
+  return modifiers.includes('suspend')
+    || /Coroutine|Suspend/i.test(String(kind))
+    || node.isSuspend === true
+    || node.suspend === true;
+}
+
+function kotlinContractNode(kind) {
+  return /Contract/i.test(String(kind));
+}
+
+function kotlinCompilerPluginAnnotationNode(node) {
+  const names = kotlinPsiAnnotationNames(node);
+  return names.some((name) => /^(Composable|Serializable|Parcelize|Entity|Immutable|Stable|AutoService|AssistedInject|Hilt|Inject|Room|KSerializable)$/i.test(name.replace(/^.*\./, '')));
+}
+
+function kotlinGeneratedCodeMarker(node) {
+  if (node.generated || node.isGenerated) return true;
+  const path = String(node.filePath ?? node.path ?? node.sourcePath ?? '');
+  return kotlinGeneratedSourcePath(path);
+}
+
+function kotlinGeneratedSourcePath(path) {
+  return typeof path === 'string' && (/(\.g|\.generated)\.kts?$/i.test(path) || /[\/\\](build|generated|ksp|kapt)[\/\\]/i.test(path));
+}
+
+function kotlinGeneratedCodeLoss(input, nodeId, span, options = {}, metadata = {}) {
+  return {
+    id: `loss_${idFragment(nodeId ?? input.sourcePath ?? 'kotlin')}_kotlin_generated_code`,
+    severity: 'warning',
+    phase: 'parse',
+    sourceFormat: input.language,
+    kind: 'generatedCode',
+    message: 'Kotlin generated-source marker was imported; generated member provenance and source ownership require host evidence.',
+    span,
+    nodeId,
+    metadata: {
+      parser: options.parser,
+      astFormat: options.astFormat,
+      kspEvidence: kotlinEvidenceSummary(options.kspEvidence),
+      kaptEvidence: kotlinEvidenceSummary(options.kaptEvidence),
+      compilerPluginEvidence: kotlinEvidenceSummary(options.compilerPluginEvidence),
+      ...metadata
+    }
+  };
+}
+
+function kotlinScriptLoss(input, nodeId, span, options = {}) {
+  return {
+    id: `loss_${idFragment(nodeId ?? input.sourcePath ?? 'kotlin')}_kotlin_script_semantics`,
+    severity: 'warning',
+    phase: 'parse',
+    sourceFormat: input.language,
+    kind: 'unsupportedSemantic',
+    message: 'Kotlin script source was imported; script templates, implicit receivers, dependencies, and host execution environment require build/runtime evidence.',
+    span,
+    nodeId,
+    metadata: {
+      parser: options.parser,
+      astFormat: options.astFormat,
+      feature: 'script',
+      unsupportedSemanticKind: 'kotlin.scriptContext',
+      script: true,
+      buildVariantEvidence: kotlinEvidenceSummary(options.buildVariantEvidence)
+    }
+  };
+}
+
+function kotlinUnsupportedSemanticLoss(input, nodeId, span, options = {}, metadata = {}) {
+  return {
+    id: `loss_${idFragment(nodeId ?? input.sourcePath ?? 'kotlin')}_kotlin_${idFragment(metadata.feature ?? 'semantic')}`,
+    severity: 'warning',
+    phase: 'parse',
+    sourceFormat: input.language,
+    kind: 'unsupportedSemantic',
+    message: metadata.message ?? 'Kotlin semantic feature requires host compiler evidence.',
+    span,
+    nodeId,
+    metadata: {
+      parser: options.parser,
+      astFormat: options.astFormat,
+      unsupportedSemanticKind: metadata.unsupportedSemanticKind ?? `kotlin.${idFragment(metadata.feature ?? 'semantic')}`,
+      analysisApiEvidence: kotlinEvidenceSummary(options.analysisApiEvidence),
+      firEvidence: kotlinEvidenceSummary(options.firEvidence),
+      multiplatformEvidence: kotlinEvidenceSummary(options.multiplatformEvidence),
+      ...metadata
+    }
+  };
+}
+
+function kotlinEvidenceSummary(value) {
+  if (!value) return undefined;
+  if (Array.isArray(value)) return { entryCount: value.length };
+  if (typeof value === 'string') return { value };
+  if (typeof value === 'object') {
+    const summary = {};
+    if (typeof value.hash === 'string') summary.hash = value.hash;
+    if (typeof value.solver === 'string') summary.solver = value.solver;
+    if (Array.isArray(value.entries)) summary.entryCount = value.entries.length;
+    if (Array.isArray(value.symbols)) summary.symbolCount = value.symbols.length;
+    if (Array.isArray(value.references)) summary.referenceCount = value.references.length;
+    if (Array.isArray(value.types)) summary.typeCount = value.types.length;
+    if (Array.isArray(value.diagnostics)) summary.diagnosticCount = value.diagnostics.length;
+    if (Array.isArray(value.plugins)) summary.pluginCount = value.plugins.length;
+    if (Array.isArray(value.generatedSources)) summary.generatedSourceCount = value.generatedSources.length;
+    if (Array.isArray(value.platforms)) summary.platformCount = value.platforms.length;
+    if (Array.isArray(value.variants)) summary.variantCount = value.variants.length;
+    return Object.keys(summary).length ? summary : { present: true };
+  }
+  return { present: true };
+}
+
+function csharpRoslynRoot(value) {
+  if (!value || typeof value !== 'object') return undefined;
+  if (isCSharpRoslynNode(value)) return value;
+  if (isCSharpRoslynNode(value.ast)) return value.ast;
+  if (isCSharpRoslynNode(value.root)) return value.root;
+  if (isCSharpRoslynNode(value.rootNode)) return value.rootNode;
+  if (isCSharpRoslynNode(value.compilationUnit)) return value.compilationUnit;
+  if (isCSharpRoslynNode(value.syntaxTree)) return csharpRoslynRoot(value.syntaxTree);
+  if (isCSharpRoslynNode(value.tree)) return csharpRoslynRoot(value.tree);
+  if (Array.isArray(value.members) || Array.isArray(value.usings) || Array.isArray(value.externs)) {
+    return { kind: 'CompilationUnit', ...value };
+  }
+  return undefined;
+}
+
+function isCSharpRoslynNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof csharpRoslynKind(value) === 'string');
+}
+
+function csharpRoslynKind(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const declared = node.kind ?? node.Kind ?? node._type ?? node.type ?? node.nodeType ?? node.syntaxKind ?? node.SyntaxKind;
+  if (typeof declared === 'string') return normalizeCSharpRoslynKind(declared);
+  if (Array.isArray(node.members) || Array.isArray(node.usings) || Array.isArray(node.externs)) return 'CompilationUnit';
+  if (node.identifier && (node.members || node.baseList || node.parameterList || node.modifiers)) return 'ClassDeclaration';
+  if (node.declaration && (node.eventKeyword || node.eventField)) return 'EventFieldDeclaration';
+  if (node.declaration && Array.isArray(node.declaration.variables)) return 'FieldDeclaration';
+  return undefined;
+}
+
+function normalizeCSharpRoslynKind(kind) {
+  const text = String(kind)
+    .replace(/^(?:Microsoft\.CodeAnalysis\.CSharp\.Syntax\.|Microsoft\.CodeAnalysis\.CSharp\.)/, '')
+    .replace(/Syntax$/, '');
+  const compact = text.replace(/[_\s.-]+/g, '').toLowerCase();
+  if (compact === 'compilationunit') return 'CompilationUnit';
+  if (compact === 'usingdirective') return 'UsingDirective';
+  if (compact === 'namespacedeclaration') return 'NamespaceDeclaration';
+  if (compact === 'filescopednamespacedeclaration') return 'FileScopedNamespaceDeclaration';
+  if (compact === 'classdeclaration') return 'ClassDeclaration';
+  if (compact === 'interfacedeclaration') return 'InterfaceDeclaration';
+  if (compact === 'structdeclaration') return 'StructDeclaration';
+  if (compact === 'recorddeclaration') return 'RecordDeclaration';
+  if (compact === 'recordstructdeclaration') return 'RecordStructDeclaration';
+  if (compact === 'enumdeclaration') return 'EnumDeclaration';
+  if (compact === 'methoddeclaration') return 'MethodDeclaration';
+  if (compact === 'constructordeclaration') return 'ConstructorDeclaration';
+  if (compact === 'destructordeclaration') return 'DestructorDeclaration';
+  if (compact === 'operatordeclaration') return 'OperatorDeclaration';
+  if (compact === 'conversionoperatordeclaration') return 'ConversionOperatorDeclaration';
+  if (compact === 'propertydeclaration') return 'PropertyDeclaration';
+  if (compact === 'indexerdeclaration') return 'IndexerDeclaration';
+  if (compact === 'fielddeclaration') return 'FieldDeclaration';
+  if (compact === 'variabledeclarator') return 'VariableDeclarator';
+  if (compact === 'eventdeclaration') return 'EventDeclaration';
+  if (compact === 'eventfielddeclaration') return 'EventFieldDeclaration';
+  if (compact === 'delegatedeclaration') return 'DelegateDeclaration';
+  if (compact === 'enummemberdeclaration') return 'EnumMemberDeclaration';
+  if (compact === 'attributelist') return 'AttributeList';
+  if (compact === 'attribute') return 'Attribute';
+  if (compact === 'parameter') return 'Parameter';
+  if (compact === 'incompletemember') return 'IncompleteMember';
+  if (compact === 'skippedtokenstrivia' || compact === 'skippedtokens') return 'SkippedTokensTrivia';
+  if (compact.endsWith('directivetrivia')) return `${upperFirst(compact.slice(0, -'directivetrivia'.length))}DirectiveTrivia`;
+  if (/^[A-Z0-9_]+$/.test(text)) return text.toLowerCase().split('_').map(upperFirst).join('');
+  return text;
+}
+
+function ignoredCSharpRoslynField(key) {
+  return key === '_type'
+    || key === 'type'
+    || key === 'kind'
+    || key === 'Kind'
+    || key === 'nodeType'
+    || key === 'syntaxKind'
+    || key === 'SyntaxKind'
+    || key === 'rawKind'
+    || key === 'RawKind'
+    || key === 'parent'
+    || key === 'parentKind'
+    || key === 'parentField'
+    || key === 'span'
+    || key === 'Span'
+    || key === 'fullSpan'
+    || key === 'FullSpan'
+    || key === 'lineSpan'
+    || key === 'location'
+    || key === 'locations'
+    || key === 'identifier'
+    || key === 'name'
+    || key === 'simpleName'
+    || key === 'qualifiedName'
+    || key === 'semanticModel'
+    || key === 'symbol'
+    || key === 'declaredSymbol'
+    || key === 'typeInfo'
+    || key === 'conversion'
+    || key === 'constantValue';
+}
+
+function primitiveCSharpRoslynFields(node, kind) {
+  const fields = { kind };
+  const name = csharpRoslynDeclarationName(node);
+  if (name) fields.name = name;
+  const importPath = csharpRoslynUsingPath(node);
+  if (importPath) fields.importPath = importPath;
+  const type = csharpRoslynTypeName(node.type ?? node.Type ?? node.returnType ?? node.ReturnType);
+  if (type) fields.type = type;
+  const modifiers = csharpRoslynModifierNames(node);
+  if (modifiers.length) fields.modifiers = modifiers.join(',');
+  const alias = csharpRoslynName(node.alias ?? node.Alias);
+  if (alias) fields.alias = alias;
+  if (node.static === true || node.isStatic === true) fields.static = true;
+  if (node.global === true || node.isGlobal === true) fields.global = true;
+  if (node.generated === true || node.Generated === true) fields.generated = true;
+  if (node.containsDiagnostics === true || node.ContainsDiagnostics === true) fields.containsDiagnostics = true;
+  if (node.containsSkippedText === true || node.ContainsSkippedText === true) fields.containsSkippedText = true;
+  if (node.isMissing === true || node.IsMissing === true) fields.isMissing = true;
+  if (Array.isArray(node.parameterList?.parameters ?? node.parameters)) fields.parameterCount = (node.parameterList?.parameters ?? node.parameters).length;
+  if (Array.isArray(node.attributeLists)) fields.attributeListCount = node.attributeLists.length;
+  return fields;
+}
+
+function spanFromCSharpRoslynNode(node, input, options = {}) {
+  const lineSpan = node.lineSpan ?? node.location?.lineSpan ?? node.location?.LineSpan ?? node.FileLinePositionSpan;
+  const fromLineSpan = spanFromCSharpLineSpan(lineSpan, input);
+  if (fromLineSpan) return fromLineSpan;
+  const direct = spanFromCSharpLineFields(node, input);
+  if (direct) return direct;
+  const start = csharpRoslynPosition(node.start ?? node.Start ?? node.span?.start ?? node.Span?.Start ?? node.position, options);
+  const end = csharpRoslynPosition(node.end ?? node.End ?? node.span?.end ?? node.Span?.End, options);
+  if (!start) return undefined;
+  return {
+    sourceId: input.sourceHash,
+    path: start.path ?? end?.path ?? input.sourcePath,
+    startLine: start.line,
+    startColumn: start.column,
+    endLine: end?.line,
+    endColumn: end?.column
+  };
+}
+
+function spanFromCSharpLineSpan(lineSpan, input) {
+  if (!lineSpan || typeof lineSpan !== 'object') return undefined;
+  const start = lineSpan.startLinePosition ?? lineSpan.StartLinePosition ?? lineSpan.start ?? lineSpan.Start;
+  const end = lineSpan.endLinePosition ?? lineSpan.EndLinePosition ?? lineSpan.end ?? lineSpan.End;
+  const line = start?.line ?? start?.Line;
+  if (typeof line !== 'number') return undefined;
+  const character = start.character ?? start.Character ?? start.column ?? start.Column;
+  const endLine = end?.line ?? end?.Line;
+  const endCharacter = end?.character ?? end?.Character ?? end?.column ?? end?.Column;
+  return {
+    sourceId: input.sourceHash,
+    path: lineSpan.path ?? lineSpan.filePath ?? lineSpan.FilePath ?? input.sourcePath,
+    startLine: line + 1,
+    startColumn: typeof character === 'number' ? character + 1 : undefined,
+    endLine: typeof endLine === 'number' ? endLine + 1 : undefined,
+    endColumn: typeof endCharacter === 'number' ? endCharacter + 1 : undefined
+  };
+}
+
+function spanFromCSharpLineFields(node, input) {
+  const startLine = node.startLine ?? node.line ?? node.beginLine;
+  if (typeof startLine !== 'number') return undefined;
+  return {
+    sourceId: input.sourceHash,
+    path: node.path ?? node.filePath ?? node.file ?? input.sourcePath,
+    startLine,
+    startColumn: node.startColumn ?? node.column ?? node.beginColumn,
+    endLine: node.endLine,
+    endColumn: node.endColumn
+  };
+}
+
+function csharpRoslynPosition(value, options = {}) {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value === 'object') {
+    const position = value.position ?? value.Position ?? value;
+    const line = position.line ?? position.Line;
+    const column = position.column ?? position.Column ?? position.character ?? position.Character;
+    if (typeof line === 'number') {
+      return {
+        path: position.path ?? position.filePath ?? position.FilePath ?? position.file,
+        line,
+        column: typeof column === 'number' ? column : undefined
+      };
+    }
+  }
+  const resolver = typeof options.positionResolver === 'function'
+    ? options.positionResolver
+    : typeof options.lineMap?.position === 'function'
+      ? options.lineMap.position.bind(options.lineMap)
+      : typeof options.lineMap?.getLinePosition === 'function'
+        ? options.lineMap.getLinePosition.bind(options.lineMap)
+        : undefined;
+  if (resolver) {
+    const resolved = resolver(value);
+    if (resolved !== value) return csharpRoslynPosition(resolved, options);
+  }
+  return undefined;
+}
+
+function csharpRoslynPositionKind(node) {
+  if (node.lineSpan || node.location?.lineSpan) return 'line-position-span';
+  if (node.span || node.Span) return 'text-span';
+  if (typeof node.startLine === 'number' || typeof node.line === 'number') return 'line-column-fields';
+  return undefined;
+}
+
+function csharpRoslynDeclarations(node, kind, nativeNodeId, input) {
+  if (kind === 'UsingDirective') {
+    const name = csharpRoslynUsingPath(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'module', 'import')] : [];
+  }
+  if (kind === 'NamespaceDeclaration' || kind === 'FileScopedNamespaceDeclaration') {
+    const name = csharpRoslynDeclarationName(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'namespace', 'definition')] : [];
+  }
+  if (csharpRoslynTypeDeclarationKind(kind)) {
+    const name = csharpRoslynDeclarationName(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, csharpRoslynTypeDeclarationSymbolKind(kind), 'definition')] : [];
+  }
+  if (kind === 'DelegateDeclaration') {
+    const name = csharpRoslynDeclarationName(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'type', 'definition')] : [];
+  }
+  if (csharpRoslynMethodLikeKind(kind)) {
+    const name = csharpRoslynDeclarationName(node) ?? csharpRoslynOperatorName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'method', csharpRoslynHasBody(node) ? 'definition' : 'declaration')] : [];
+  }
+  if (kind === 'PropertyDeclaration' || kind === 'IndexerDeclaration') {
+    const name = csharpRoslynDeclarationName(node) ?? (kind === 'IndexerDeclaration' ? 'this[]' : undefined);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'property', 'definition')] : [];
+  }
+  if (kind === 'FieldDeclaration') {
+    return csharpRoslynVariableNames(node).map((name) => declarationRecord(input, nativeNodeId, name, 'property', 'definition'));
+  }
+  if (kind === 'EventDeclaration') {
+    const name = csharpRoslynDeclarationName(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'event', 'definition')] : [];
+  }
+  if (kind === 'EventFieldDeclaration') {
+    return csharpRoslynVariableNames(node).map((name) => declarationRecord(input, nativeNodeId, name, 'event', 'definition'));
+  }
+  if (kind === 'VariableDeclarator') {
+    if (node.parentKind === 'FieldDeclaration') {
+      const name = csharpRoslynDeclarationName(node);
+      return name ? [declarationRecord(input, nativeNodeId, name, 'property', 'definition')] : [];
+    }
+    if (node.parentKind === 'EventFieldDeclaration') {
+      const name = csharpRoslynDeclarationName(node);
+      return name ? [declarationRecord(input, nativeNodeId, name, 'event', 'definition')] : [];
+    }
+    return [];
+  }
+  if (kind === 'EnumMemberDeclaration') {
+    const name = csharpRoslynDeclarationName(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'enumMember', 'definition')] : [];
+  }
+  return [];
+}
+
+function csharpRoslynChildEntries(node, kind = csharpRoslynKind(node)) {
+  const fieldNames = Object.keys(node).filter((key) => !ignoredCSharpRoslynField(key));
+  const entries = [];
+  for (const field of fieldNames) {
+    const value = node[field];
+    if (Array.isArray(value)) {
+      entries.push([field, value.map((entry) => csharpRoslynChildWithParent(entry, kind, field))]);
+      continue;
+    }
+    if (value && typeof value === 'object') {
+      entries.push([field, csharpRoslynChildWithParent(value, kind, field)]);
+    }
+  }
+  return entries.filter(([, value]) => Array.isArray(value)
+    ? value.some(isCSharpRoslynNode)
+    : isCSharpRoslynNode(value));
+}
+
+function csharpRoslynChildWithParent(entry, parentKind, parentField) {
+  if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return entry;
+  if (!isCSharpRoslynNode(entry)) return entry;
+  return { parentKind, parentField, ...entry };
+}
+
+function csharpRoslynNodeValue(node) {
+  return csharpRoslynDeclarationName(node)
+    ?? csharpRoslynUsingPath(node)
+    ?? csharpRoslynTypeName(node.type ?? node.returnType)
+    ?? csharpRoslynLiteralValue(node);
+}
+
+function csharpRoslynDeclarationName(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  for (const key of ['identifier', 'name', 'simpleName', 'qualifiedName', 'id']) {
+    const value = node[key];
+    const name = csharpRoslynName(value);
+    if (name) return name;
+  }
+  if (node.declaration && typeof node.declaration === 'object') return csharpRoslynDeclarationName(node.declaration);
+  return undefined;
+}
+
+function csharpRoslynName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.text === 'string') return value.text;
+  if (typeof value.valueText === 'string') return value.valueText;
+  if (typeof value.identifier === 'string') return value.identifier;
+  if (typeof value.name === 'string') return value.name;
+  if (typeof value.qualifiedName === 'string') return value.qualifiedName;
+  if (typeof value.value === 'string') return value.value;
+  if (value.identifier && value.identifier !== value) return csharpRoslynName(value.identifier);
+  if (value.name && value.name !== value) return csharpRoslynName(value.name);
+  return undefined;
+}
+
+function csharpRoslynUsingPath(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  return csharpRoslynName(node.name ?? node.Name ?? node.qualifiedName ?? node.path);
+}
+
+function csharpRoslynVariableNames(node) {
+  const variables = node.variables
+    ?? node.declaration?.variables
+    ?? node.Declaration?.Variables
+    ?? node.variableDeclarators;
+  if (Array.isArray(variables)) return variables.map(csharpRoslynDeclarationName).filter(Boolean);
+  const name = csharpRoslynDeclarationName(node);
+  return name ? [name] : [];
+}
+
+function csharpRoslynTypeName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.name === 'string') return value.name;
+  if (typeof value.text === 'string') return value.text;
+  if (typeof value.valueText === 'string') return value.valueText;
+  if (typeof value.qualifiedName === 'string') return value.qualifiedName;
+  if (value.elementType) {
+    const inner = csharpRoslynTypeName(value.elementType);
+    return inner ? `${inner}[]` : '[]';
+  }
+  if (Array.isArray(value.typeArgumentList?.arguments ?? value.typeArguments)) {
+    const base = csharpRoslynName(value.name) ?? csharpRoslynName(value);
+    const args = (value.typeArgumentList?.arguments ?? value.typeArguments).map(csharpRoslynTypeName).filter(Boolean);
+    return base ? `${base}<${args.join(', ')}>` : undefined;
+  }
+  return csharpRoslynName(value);
+}
+
+function csharpRoslynModifierNames(node) {
+  const modifiers = node.modifiers ?? node.Modifiers;
+  if (!modifiers) return [];
+  if (Array.isArray(modifiers)) {
+    return uniqueStrings(modifiers.map((entry) => typeof entry === 'string' ? entry : csharpRoslynName(entry) ?? entry.kind).filter(Boolean));
+  }
+  if (typeof modifiers === 'string') return uniqueStrings(modifiers.split(/\s+/).filter(Boolean));
+  if (typeof modifiers === 'object') {
+    return uniqueStrings(Object.entries(modifiers)
+      .filter(([, enabled]) => enabled === true)
+      .map(([key]) => key));
+  }
+  return [];
+}
+
+function csharpRoslynTypeDeclarationKind(kind) {
+  return kind === 'ClassDeclaration'
+    || kind === 'InterfaceDeclaration'
+    || kind === 'StructDeclaration'
+    || kind === 'RecordDeclaration'
+    || kind === 'RecordStructDeclaration'
+    || kind === 'EnumDeclaration';
+}
+
+function csharpRoslynTypeDeclarationSymbolKind(kind) {
+  if (kind === 'ClassDeclaration' || kind === 'RecordDeclaration') return 'class';
+  if (kind === 'InterfaceDeclaration') return 'interface';
+  return 'type';
+}
+
+function csharpRoslynMethodLikeKind(kind) {
+  return kind === 'MethodDeclaration'
+    || kind === 'ConstructorDeclaration'
+    || kind === 'DestructorDeclaration'
+    || kind === 'OperatorDeclaration'
+    || kind === 'ConversionOperatorDeclaration';
+}
+
+function csharpRoslynHasBody(node) {
+  return Boolean(node.body || node.expressionBody || node.accessorList || Array.isArray(node.statements));
+}
+
+function csharpRoslynOperatorName(node, kind) {
+  if (kind === 'ConstructorDeclaration') return csharpRoslynDeclarationName(node);
+  if (kind === 'DestructorDeclaration') return `~${csharpRoslynDeclarationName(node) ?? 'destructor'}`;
+  if (kind === 'OperatorDeclaration') return `operator ${csharpRoslynName(node.operatorToken) ?? csharpRoslynName(node.operatorKeyword) ?? 'operator'}`;
+  if (kind === 'ConversionOperatorDeclaration') return `operator ${csharpRoslynTypeName(node.type) ?? 'conversion'}`;
+  return undefined;
+}
+
+function csharpRoslynLiteralValue(node) {
+  const value = node.value ?? node.literal;
+  if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;
+  return undefined;
+}
+
+function csharpRoslynRecoveredKind(kind) {
+  return kind === 'IncompleteMember'
+    || kind === 'SkippedTokensTrivia'
+    || /Skipped|Missing|Bad|Incomplete/.test(String(kind));
+}
+
+function csharpRoslynProblemNode(node, kind) {
+  return Boolean(
+    node.containsDiagnostics
+    || node.ContainsDiagnostics
+    || node.containsSkippedText
+    || node.ContainsSkippedText
+    || node.isMissing
+    || node.IsMissing
+    || node.hasDiagnostics
+    || node.HasDiagnostics
+    || kind === 'IncompleteMember'
+    || kind === 'SkippedTokensTrivia'
+  );
+}
+
+function csharpRoslynDirectiveKind(kind) {
+  return /DirectiveTrivia$/.test(String(kind)) || /^(IfDirective|ElifDirective|ElseDirective|EndIfDirective|DefineDirective|UndefDirective|NullableDirective|RegionDirective|EndRegionDirective|PragmaWarningDirective|LineDirective|ErrorDirective|WarningDirective|LoadDirective|ReferenceDirective)/.test(String(kind));
+}
+
+function csharpGeneratedCodeMarker(node, kind) {
+  if (node.generated || node.Generated || node.isGenerated) return true;
+  const path = String(node.filePath ?? node.path ?? node.sourcePath ?? '');
+  if (csharpGeneratedSourcePath(path)) return true;
+  if (kind === 'Attribute') {
+    const name = csharpRoslynDeclarationName(node);
+    if (name && /(^|\.)(GeneratedCode|CompilerGenerated|DebuggerNonUserCode)Attribute?$/.test(name)) return true;
+  }
+  const attributes = node.attributeLists ?? node.attributes;
+  if (Array.isArray(attributes)) {
+    return JSON.stringify(attributes).includes('GeneratedCode')
+      || JSON.stringify(attributes).includes('CompilerGenerated');
+  }
+  return false;
+}
+
+function csharpGeneratedSourcePath(path) {
+  return typeof path === 'string' && /\.(g|generated|designer)\.cs$/i.test(path);
+}
+
+function csharpGeneratedCodeLoss(input, nodeId, span, options = {}, metadata = {}) {
+  return {
+    id: `loss_${idFragment(nodeId ?? input.sourcePath ?? 'csharp')}_csharp_generated_code`,
+    severity: 'warning',
+    phase: 'parse',
+    sourceFormat: input.language,
+    kind: 'generatedCode',
+    message: 'C# generated-source or source-generator marker was imported; generated member provenance and source ownership require host evidence.',
+    span,
+    nodeId,
+    metadata: {
+      parser: options.parser,
+      astFormat: options.astFormat,
+      sourceGeneratorEvidence: csharpEvidenceSummary(options.sourceGeneratorEvidence),
+      ...metadata
+    }
+  };
+}
+
+function csharpEvidenceSummary(value) {
+  if (!value) return undefined;
+  if (Array.isArray(value)) return { entryCount: value.length };
+  if (typeof value === 'string') return { value };
+  if (typeof value === 'object') {
+    const summary = {};
+    if (typeof value.hash === 'string') summary.hash = value.hash;
+    if (typeof value.solver === 'string') summary.solver = value.solver;
+    if (Array.isArray(value.entries)) summary.entryCount = value.entries.length;
+    if (Array.isArray(value.references)) summary.referenceCount = value.references.length;
+    if (Array.isArray(value.symbols)) summary.symbolCount = value.symbols.length;
+    if (Array.isArray(value.diagnostics)) summary.diagnosticCount = value.diagnostics.length;
+    if (Array.isArray(value.generators)) summary.generatorCount = value.generators.length;
+    if (Array.isArray(value.projects)) summary.projectCount = value.projects.length;
+    return Object.keys(summary).length ? summary : { present: true };
+  }
+  return { present: true };
+}
+
+function swiftSyntaxRoot(value) {
+  if (!value || typeof value !== 'object') return undefined;
+  if (isSwiftSyntaxNode(value)) return value;
+  if (isSwiftSyntaxNode(value.ast)) return value.ast;
+  if (isSwiftSyntaxNode(value.root)) return value.root;
+  if (isSwiftSyntaxNode(value.rootNode)) return value.rootNode;
+  if (isSwiftSyntaxNode(value.sourceFile)) return value.sourceFile;
+  if (isSwiftSyntaxNode(value.sourceFileSyntax)) return value.sourceFileSyntax;
+  if (isSwiftSyntaxNode(value.tree)) return swiftSyntaxRoot(value.tree);
+  if (Array.isArray(value.statements) || Array.isArray(value.members) || Array.isArray(value.declarations)) {
+    return { kind: 'SourceFile', ...value };
+  }
+  return undefined;
+}
+
+function isSwiftSyntaxNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof swiftSyntaxKind(value) === 'string');
+}
+
+function swiftSyntaxKind(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const declared = node.kind ?? node.syntaxKind ?? node.SyntaxKind ?? node._syntaxKind ?? node._type ?? node.type ?? node.nodeType;
+  if (typeof declared === 'string') return normalizeSwiftSyntaxKind(declared);
+  if (Array.isArray(node.statements) || Array.isArray(node.members) || Array.isArray(node.declarations)) return 'SourceFile';
+  if (node.identifier && (node.memberBlock || node.members || node.genericParameterClause || node.inheritanceClause)) return 'ClassDecl';
+  if (node.signature && node.body) return 'FunctionDecl';
+  if (node.importPath || node.path) return 'ImportDecl';
+  return undefined;
+}
+
+function normalizeSwiftSyntaxKind(kind) {
+  const text = String(kind)
+    .replace(/^SwiftSyntax\./, '')
+    .replace(/Syntax$/, '');
+  const compact = text.replace(/[_\s.-]+/g, '').toLowerCase();
+  const known = {
+    sourcefile: 'SourceFile',
+    importdecl: 'ImportDecl',
+    classdecl: 'ClassDecl',
+    structdecl: 'StructDecl',
+    enumdecl: 'EnumDecl',
+    protocoldecl: 'ProtocolDecl',
+    actordecl: 'ActorDecl',
+    extensiondecl: 'ExtensionDecl',
+    typealiasdecl: 'TypeAliasDecl',
+    associatedtypedecl: 'AssociatedTypeDecl',
+    functiondecl: 'FunctionDecl',
+    initializerdecl: 'InitializerDecl',
+    initdecl: 'InitializerDecl',
+    deinitializerdecl: 'DeinitializerDecl',
+    deinitdecl: 'DeinitializerDecl',
+    subscriptdecl: 'SubscriptDecl',
+    operatordecl: 'OperatorDecl',
+    precedencegroupdecl: 'PrecedenceGroupDecl',
+    variabledecl: 'VariableDecl',
+    patternbinding: 'PatternBinding',
+    enumcasedecl: 'EnumCaseDecl',
+    enumcaseelement: 'EnumCaseElement',
+    macrodecl: 'MacroDecl',
+    macroexpansiondecl: 'MacroExpansionDecl',
+    freestandingmacroexpansion: 'FreestandingMacroExpansion',
+    freestandingmacroexpansionsyntax: 'FreestandingMacroExpansion',
+    attributemacroexpansion: 'AttributeMacroExpansion',
+    ifconfigdecl: 'IfConfigDecl',
+    ifconfigexpr: 'IfConfigExpr',
+    unexpectednodes: 'UnexpectedNodes',
+    missingtoken: 'MissingToken',
+    skippedtoken: 'SkippedToken',
+    error: 'Error'
+  };
+  if (known[compact]) return known[compact];
   if (/^[A-Z0-9_]+$/.test(text)) return text.toLowerCase().split('_').map(upperFirst).join('');
   return text;
 }
 
-function ignoredCSharpRoslynField(key) {
+function ignoredSwiftSyntaxField(key) {
   return key === '_type'
     || key === 'type'
     || key === 'kind'
-    || key === 'Kind'
-    || key === 'nodeType'
     || key === 'syntaxKind'
     || key === 'SyntaxKind'
-    || key === 'rawKind'
-    || key === 'RawKind'
+    || key === '_syntaxKind'
+    || key === 'nodeType'
     || key === 'parent'
     || key === 'parentKind'
     || key === 'parentField'
-    || key === 'span'
-    || key === 'Span'
-    || key === 'fullSpan'
-    || key === 'FullSpan'
-    || key === 'lineSpan'
+    || key === 'position'
+    || key === 'absolutePosition'
+    || key === 'endPosition'
     || key === 'location'
-    || key === 'locations'
+    || key === 'sourceRange'
+    || key === 'range'
+    || key === 'span'
     || key === 'identifier'
     || key === 'name'
     || key === 'simpleName'
-    || key === 'qualifiedName'
+    || key === 'typeName'
+    || key === 'sourceKitSymbol'
     || key === 'semanticModel'
-    || key === 'symbol'
-    || key === 'declaredSymbol'
-    || key === 'typeInfo'
-    || key === 'conversion'
-    || key === 'constantValue';
+    || key === 'resolvedSymbol'
+    || key === 'typeInfo';
 }
 
-function primitiveCSharpRoslynFields(node, kind) {
+function primitiveSwiftSyntaxFields(node, kind) {
   const fields = { kind };
-  const name = csharpRoslynDeclarationName(node);
+  const name = swiftSyntaxDeclarationName(node, kind);
   if (name) fields.name = name;
-  const importPath = csharpRoslynUsingPath(node);
+  const importPath = swiftSyntaxImportPath(node);
   if (importPath) fields.importPath = importPath;
-  const type = csharpRoslynTypeName(node.type ?? node.Type ?? node.returnType ?? node.ReturnType);
+  const type = swiftSyntaxTypeName(node.type ?? node.typeAnnotation?.type ?? node.returnClause?.type ?? node.extendedType);
   if (type) fields.type = type;
-  const modifiers = csharpRoslynModifierNames(node);
+  const modifiers = swiftSyntaxModifierNames(node);
   if (modifiers.length) fields.modifiers = modifiers.join(',');
-  const alias = csharpRoslynName(node.alias ?? node.Alias);
-  if (alias) fields.alias = alias;
-  if (node.static === true || node.isStatic === true) fields.static = true;
-  if (node.global === true || node.isGlobal === true) fields.global = true;
-  if (node.generated === true || node.Generated === true) fields.generated = true;
-  if (node.containsDiagnostics === true || node.ContainsDiagnostics === true) fields.containsDiagnostics = true;
-  if (node.containsSkippedText === true || node.ContainsSkippedText === true) fields.containsSkippedText = true;
-  if (node.isMissing === true || node.IsMissing === true) fields.isMissing = true;
-  if (Array.isArray(node.parameterList?.parameters ?? node.parameters)) fields.parameterCount = (node.parameterList?.parameters ?? node.parameters).length;
-  if (Array.isArray(node.attributeLists)) fields.attributeListCount = node.attributeLists.length;
+  const attributes = swiftSyntaxAttributeNames(node);
+  if (attributes.length) fields.attributes = attributes.join(',');
+  if (node.generated === true || node.isGenerated === true) fields.generated = true;
+  if (node.isMissing === true || node.presence === 'missing') fields.isMissing = true;
+  if (node.hasError === true || node.containsDiagnostics === true) fields.hasError = true;
+  if (Array.isArray(node.genericParameterClause?.parameters ?? node.genericParameters)) fields.genericParameterCount = (node.genericParameterClause?.parameters ?? node.genericParameters).length;
+  if (Array.isArray(node.inheritanceClause?.inheritedTypes ?? node.inheritedTypes)) fields.inheritedTypeCount = (node.inheritanceClause?.inheritedTypes ?? node.inheritedTypes).length;
+  if (Array.isArray(node.signature?.parameterClause?.parameters ?? node.parameters)) fields.parameterCount = (node.signature?.parameterClause?.parameters ?? node.parameters).length;
   return fields;
 }
 
-function spanFromCSharpRoslynNode(node, input, options = {}) {
-  const lineSpan = node.lineSpan ?? node.location?.lineSpan ?? node.location?.LineSpan ?? node.FileLinePositionSpan;
-  const fromLineSpan = spanFromCSharpLineSpan(lineSpan, input);
-  if (fromLineSpan) return fromLineSpan;
-  const direct = spanFromCSharpLineFields(node, input);
+function spanFromSwiftSyntaxNode(node, input, options = {}) {
+  const direct = spanFromSwiftLineFields(node, input);
   if (direct) return direct;
-  const start = csharpRoslynPosition(node.start ?? node.Start ?? node.span?.start ?? node.Span?.Start ?? node.position, options);
-  const end = csharpRoslynPosition(node.end ?? node.End ?? node.span?.end ?? node.Span?.End, options);
+  const range = node.sourceRange ?? node.range ?? node.span;
+  const fromRange = spanFromSwiftRange(range, input);
+  if (fromRange) return fromRange;
+  const start = swiftSyntaxPosition(node.position ?? node.absolutePosition ?? node.start ?? range?.start, options);
+  const end = swiftSyntaxPosition(node.endPosition ?? node.end ?? range?.end, options);
   if (!start) return undefined;
   return {
     sourceId: input.sourceHash,
@@ -12260,26 +13783,7 @@ function spanFromCSharpRoslynNode(node, input, options = {}) {
   };
 }
 
-function spanFromCSharpLineSpan(lineSpan, input) {
-  if (!lineSpan || typeof lineSpan !== 'object') return undefined;
-  const start = lineSpan.startLinePosition ?? lineSpan.StartLinePosition ?? lineSpan.start ?? lineSpan.Start;
-  const end = lineSpan.endLinePosition ?? lineSpan.EndLinePosition ?? lineSpan.end ?? lineSpan.End;
-  const line = start?.line ?? start?.Line;
-  if (typeof line !== 'number') return undefined;
-  const character = start.character ?? start.Character ?? start.column ?? start.Column;
-  const endLine = end?.line ?? end?.Line;
-  const endCharacter = end?.character ?? end?.Character ?? end?.column ?? end?.Column;
-  return {
-    sourceId: input.sourceHash,
-    path: lineSpan.path ?? lineSpan.filePath ?? lineSpan.FilePath ?? input.sourcePath,
-    startLine: line + 1,
-    startColumn: typeof character === 'number' ? character + 1 : undefined,
-    endLine: typeof endLine === 'number' ? endLine + 1 : undefined,
-    endColumn: typeof endCharacter === 'number' ? endCharacter + 1 : undefined
-  };
-}
-
-function spanFromCSharpLineFields(node, input) {
+function spanFromSwiftLineFields(node, input) {
   const startLine = node.startLine ?? node.line ?? node.beginLine;
   if (typeof startLine !== 'number') return undefined;
   return {
@@ -12292,15 +13796,34 @@ function spanFromCSharpLineFields(node, input) {
   };
 }
 
-function csharpRoslynPosition(value, options = {}) {
+function spanFromSwiftRange(range, input) {
+  if (!range || typeof range !== 'object') return undefined;
+  const start = range.start ?? range.lowerBound ?? range.begin;
+  const end = range.end ?? range.upperBound;
+  const line = start?.line ?? start?.Line;
+  if (typeof line !== 'number') return undefined;
+  const column = start.column ?? start.character ?? start.utf8Column ?? start.Column;
+  const endLine = end?.line ?? end?.Line;
+  const endColumn = end?.column ?? end?.character ?? end?.utf8Column ?? end?.Column;
+  return {
+    sourceId: input.sourceHash,
+    path: range.path ?? range.filePath ?? range.file ?? input.sourcePath,
+    startLine: line,
+    startColumn: typeof column === 'number' ? column : undefined,
+    endLine: typeof endLine === 'number' ? endLine : undefined,
+    endColumn: typeof endColumn === 'number' ? endColumn : undefined
+  };
+}
+
+function swiftSyntaxPosition(value, options = {}) {
   if (value === undefined || value === null) return undefined;
   if (typeof value === 'object') {
-    const position = value.position ?? value.Position ?? value;
+    const position = value.position ?? value.location ?? value;
     const line = position.line ?? position.Line;
-    const column = position.column ?? position.Column ?? position.character ?? position.Character;
+    const column = position.column ?? position.character ?? position.utf8Column ?? position.Column;
     if (typeof line === 'number') {
       return {
-        path: position.path ?? position.filePath ?? position.FilePath ?? position.file,
+        path: position.path ?? position.filePath ?? position.file,
         line,
         column: typeof column === 'number' ? column : undefined
       };
@@ -12310,171 +13833,164 @@ function csharpRoslynPosition(value, options = {}) {
     ? options.positionResolver
     : typeof options.lineMap?.position === 'function'
       ? options.lineMap.position.bind(options.lineMap)
-      : typeof options.lineMap?.getLinePosition === 'function'
-        ? options.lineMap.getLinePosition.bind(options.lineMap)
+      : typeof options.sourceLocationConverter?.location === 'function'
+        ? options.sourceLocationConverter.location.bind(options.sourceLocationConverter)
         : undefined;
   if (resolver) {
     const resolved = resolver(value);
-    if (resolved !== value) return csharpRoslynPosition(resolved, options);
+    if (resolved !== value) return swiftSyntaxPosition(resolved, options);
   }
   return undefined;
 }
 
-function csharpRoslynPositionKind(node) {
-  if (node.lineSpan || node.location?.lineSpan) return 'line-position-span';
-  if (node.span || node.Span) return 'text-span';
+function swiftSyntaxPositionKind(node) {
+  if (node.sourceRange || node.range) return 'source-range';
+  if (node.position || node.absolutePosition) return 'absolute-position';
   if (typeof node.startLine === 'number' || typeof node.line === 'number') return 'line-column-fields';
   return undefined;
 }
 
-function csharpRoslynDeclarations(node, kind, nativeNodeId, input) {
-  if (kind === 'UsingDirective') {
-    const name = csharpRoslynUsingPath(node);
+function swiftSyntaxDeclarations(node, kind, nativeNodeId, input) {
+  if (kind === 'ImportDecl') {
+    const name = swiftSyntaxImportPath(node);
     return name ? [declarationRecord(input, nativeNodeId, name, 'module', 'import')] : [];
   }
-  if (kind === 'NamespaceDeclaration' || kind === 'FileScopedNamespaceDeclaration') {
-    const name = csharpRoslynDeclarationName(node);
-    return name ? [declarationRecord(input, nativeNodeId, name, 'namespace', 'definition')] : [];
-  }
-  if (csharpRoslynTypeDeclarationKind(kind)) {
-    const name = csharpRoslynDeclarationName(node);
-    return name ? [declarationRecord(input, nativeNodeId, name, csharpRoslynTypeDeclarationSymbolKind(kind), 'definition')] : [];
+  if (swiftSyntaxTypeDeclarationKind(kind)) {
+    const name = swiftSyntaxDeclarationName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, swiftSyntaxTypeDeclarationSymbolKind(kind), 'definition')] : [];
   }
-  if (kind === 'DelegateDeclaration') {
-    const name = csharpRoslynDeclarationName(node);
+  if (kind === 'ExtensionDecl') {
+    const name = swiftSyntaxDeclarationName(node, kind);
     return name ? [declarationRecord(input, nativeNodeId, name, 'type', 'definition')] : [];
   }
-  if (csharpRoslynMethodLikeKind(kind)) {
-    const name = csharpRoslynDeclarationName(node) ?? csharpRoslynOperatorName(node, kind);
-    return name ? [declarationRecord(input, nativeNodeId, name, 'method', csharpRoslynHasBody(node) ? 'definition' : 'declaration')] : [];
-  }
-  if (kind === 'PropertyDeclaration' || kind === 'IndexerDeclaration') {
-    const name = csharpRoslynDeclarationName(node) ?? (kind === 'IndexerDeclaration' ? 'this[]' : undefined);
-    return name ? [declarationRecord(input, nativeNodeId, name, 'property', 'definition')] : [];
+  if (kind === 'TypeAliasDecl' || kind === 'AssociatedTypeDecl') {
+    const name = swiftSyntaxDeclarationName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'type', 'definition')] : [];
   }
-  if (kind === 'FieldDeclaration') {
-    return csharpRoslynVariableNames(node).map((name) => declarationRecord(input, nativeNodeId, name, 'property', 'definition'));
+  if (swiftSyntaxFunctionLikeKind(kind)) {
+    const name = swiftSyntaxDeclarationName(node, kind) ?? swiftSyntaxOperatorName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, kind === 'FunctionDecl' ? 'function' : 'method', swiftSyntaxHasBody(node) ? 'definition' : 'declaration')] : [];
   }
-  if (kind === 'EventDeclaration') {
-    const name = csharpRoslynDeclarationName(node);
-    return name ? [declarationRecord(input, nativeNodeId, name, 'event', 'definition')] : [];
+  if (kind === 'VariableDecl') {
+    return swiftSyntaxVariableNames(node).map((name) => declarationRecord(input, nativeNodeId, name, 'property', 'definition'));
   }
-  if (kind === 'EventFieldDeclaration') {
-    return csharpRoslynVariableNames(node).map((name) => declarationRecord(input, nativeNodeId, name, 'event', 'definition'));
+  if (kind === 'PatternBinding' && node.parentKind === 'VariableDecl') {
+    const name = swiftSyntaxDeclarationName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'property', 'definition')] : [];
   }
-  if (kind === 'VariableDeclarator') {
-    if (node.parentKind === 'FieldDeclaration') {
-      const name = csharpRoslynDeclarationName(node);
-      return name ? [declarationRecord(input, nativeNodeId, name, 'property', 'definition')] : [];
-    }
-    if (node.parentKind === 'EventFieldDeclaration') {
-      const name = csharpRoslynDeclarationName(node);
-      return name ? [declarationRecord(input, nativeNodeId, name, 'event', 'definition')] : [];
-    }
-    return [];
+  if (kind === 'EnumCaseDecl') {
+    return swiftSyntaxEnumCaseNames(node).map((name) => declarationRecord(input, nativeNodeId, name, 'enumMember', 'definition'));
   }
-  if (kind === 'EnumMemberDeclaration') {
-    const name = csharpRoslynDeclarationName(node);
+  if (kind === 'EnumCaseElement') {
+    const name = swiftSyntaxDeclarationName(node, kind);
     return name ? [declarationRecord(input, nativeNodeId, name, 'enumMember', 'definition')] : [];
   }
   return [];
 }
 
-function csharpRoslynChildEntries(node, kind = csharpRoslynKind(node)) {
-  const fieldNames = Object.keys(node).filter((key) => !ignoredCSharpRoslynField(key));
+function swiftSyntaxChildEntries(node, kind = swiftSyntaxKind(node)) {
+  const fieldNames = Object.keys(node).filter((key) => !ignoredSwiftSyntaxField(key));
   const entries = [];
   for (const field of fieldNames) {
     const value = node[field];
     if (Array.isArray(value)) {
-      entries.push([field, value.map((entry) => csharpRoslynChildWithParent(entry, kind, field))]);
+      entries.push([field, value.map((entry) => swiftSyntaxChildWithParent(entry, kind, field))]);
       continue;
     }
     if (value && typeof value === 'object') {
-      entries.push([field, csharpRoslynChildWithParent(value, kind, field)]);
+      entries.push([field, swiftSyntaxChildWithParent(value, kind, field)]);
     }
   }
   return entries.filter(([, value]) => Array.isArray(value)
-    ? value.some(isCSharpRoslynNode)
-    : isCSharpRoslynNode(value));
+    ? value.some(isSwiftSyntaxNode)
+    : isSwiftSyntaxNode(value));
 }
 
-function csharpRoslynChildWithParent(entry, parentKind, parentField) {
+function swiftSyntaxChildWithParent(entry, parentKind, parentField) {
   if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return entry;
-  if (!isCSharpRoslynNode(entry)) return entry;
+  if (!isSwiftSyntaxNode(entry)) return entry;
   return { parentKind, parentField, ...entry };
 }
 
-function csharpRoslynNodeValue(node) {
-  return csharpRoslynDeclarationName(node)
-    ?? csharpRoslynUsingPath(node)
-    ?? csharpRoslynTypeName(node.type ?? node.returnType)
-    ?? csharpRoslynLiteralValue(node);
+function swiftSyntaxNodeValue(node) {
+  return swiftSyntaxDeclarationName(node, swiftSyntaxKind(node))
+    ?? swiftSyntaxImportPath(node)
+    ?? swiftSyntaxTypeName(node.type ?? node.returnClause?.type ?? node.extendedType)
+    ?? swiftSyntaxLiteralValue(node);
 }
 
-function csharpRoslynDeclarationName(node) {
+function swiftSyntaxDeclarationName(node, kind = swiftSyntaxKind(node)) {
   if (!node || typeof node !== 'object') return undefined;
-  for (const key of ['identifier', 'name', 'simpleName', 'qualifiedName', 'id']) {
-    const value = node[key];
-    const name = csharpRoslynName(value);
+  if (kind === 'InitializerDecl') return 'init';
+  if (kind === 'DeinitializerDecl') return 'deinit';
+  if (kind === 'SubscriptDecl') return 'subscript';
+  if (kind === 'ExtensionDecl') {
+    const extended = swiftSyntaxTypeName(node.extendedType ?? node.type ?? node.name);
+    return extended ? `extension ${extended}` : undefined;
+  }
+  if (kind === 'OperatorDecl') return swiftSyntaxOperatorName(node, kind);
+  for (const key of ['identifier', 'name', 'simpleName', 'typeName', 'id']) {
+    const name = swiftSyntaxName(node[key]);
     if (name) return name;
   }
-  if (node.declaration && typeof node.declaration === 'object') return csharpRoslynDeclarationName(node.declaration);
+  const patternName = swiftSyntaxPatternName(node.pattern);
+  if (patternName) return patternName;
   return undefined;
 }
 
-function csharpRoslynName(value) {
+function swiftSyntaxName(value) {
   if (!value) return undefined;
   if (typeof value === 'string') return value;
   if (typeof value.text === 'string') return value.text;
-  if (typeof value.valueText === 'string') return value.valueText;
+  if (typeof value.trimmedDescription === 'string') return value.trimmedDescription;
+  if (typeof value.description === 'string' && !value.description.includes('[object Object]')) return value.description.trim();
   if (typeof value.identifier === 'string') return value.identifier;
   if (typeof value.name === 'string') return value.name;
-  if (typeof value.qualifiedName === 'string') return value.qualifiedName;
   if (typeof value.value === 'string') return value.value;
-  if (value.identifier && value.identifier !== value) return csharpRoslynName(value.identifier);
-  if (value.name && value.name !== value) return csharpRoslynName(value.name);
+  if (value.tokenKind && typeof value.tokenKind === 'object') return swiftSyntaxName(value.tokenKind);
+  if (value.identifier && value.identifier !== value) return swiftSyntaxName(value.identifier);
+  if (value.name && value.name !== value) return swiftSyntaxName(value.name);
   return undefined;
 }
 
-function csharpRoslynUsingPath(node) {
+function swiftSyntaxImportPath(node) {
   if (!node || typeof node !== 'object') return undefined;
-  return csharpRoslynName(node.name ?? node.Name ?? node.qualifiedName ?? node.path);
-}
-
-function csharpRoslynVariableNames(node) {
-  const variables = node.variables
-    ?? node.declaration?.variables
-    ?? node.Declaration?.Variables
-    ?? node.variableDeclarators;
-  if (Array.isArray(variables)) return variables.map(csharpRoslynDeclarationName).filter(Boolean);
-  const name = csharpRoslynDeclarationName(node);
-  return name ? [name] : [];
+  const path = node.importPath ?? node.path ?? node.modulePath ?? node.name;
+  if (typeof path === 'string') return path;
+  if (Array.isArray(path)) {
+    return path.map((entry) => swiftSyntaxName(entry.name ?? entry.identifier ?? entry)).filter(Boolean).join('.');
+  }
+  if (path && typeof path === 'object') {
+    if (Array.isArray(path.components)) return path.components.map((entry) => swiftSyntaxName(entry.name ?? entry.identifier ?? entry)).filter(Boolean).join('.');
+    return swiftSyntaxName(path);
+  }
+  return undefined;
 }
 
-function csharpRoslynTypeName(value) {
+function swiftSyntaxTypeName(value) {
   if (!value) return undefined;
   if (typeof value === 'string') return value;
+  if (typeof value.trimmedDescription === 'string') return value.trimmedDescription;
+  if (typeof value.description === 'string' && !value.description.includes('[object Object]')) return value.description.trim();
   if (typeof value.name === 'string') return value.name;
   if (typeof value.text === 'string') return value.text;
-  if (typeof value.valueText === 'string') return value.valueText;
-  if (typeof value.qualifiedName === 'string') return value.qualifiedName;
-  if (value.elementType) {
-    const inner = csharpRoslynTypeName(value.elementType);
-    return inner ? `${inner}[]` : '[]';
+  if (value.baseType) {
+    const base = swiftSyntaxTypeName(value.baseType);
+    return base && value.name ? `${base}.${swiftSyntaxName(value.name)}` : base;
   }
-  if (Array.isArray(value.typeArgumentList?.arguments ?? value.typeArguments)) {
-    const base = csharpRoslynName(value.name) ?? csharpRoslynName(value);
-    const args = (value.typeArgumentList?.arguments ?? value.typeArguments).map(csharpRoslynTypeName).filter(Boolean);
+  if (value.argumentList && Array.isArray(value.argumentList)) {
+    const base = swiftSyntaxName(value.name) ?? swiftSyntaxTypeName(value.baseName);
+    const args = value.argumentList.map((entry) => swiftSyntaxTypeName(entry.type ?? entry)).filter(Boolean);
     return base ? `${base}<${args.join(', ')}>` : undefined;
   }
-  return csharpRoslynName(value);
+  return swiftSyntaxName(value);
 }
 
-function csharpRoslynModifierNames(node) {
+function swiftSyntaxModifierNames(node) {
   const modifiers = node.modifiers ?? node.Modifiers;
   if (!modifiers) return [];
   if (Array.isArray(modifiers)) {
-    return uniqueStrings(modifiers.map((entry) => typeof entry === 'string' ? entry : csharpRoslynName(entry) ?? entry.kind).filter(Boolean));
+    return uniqueStrings(modifiers.map((entry) => typeof entry === 'string' ? entry : swiftSyntaxName(entry.name ?? entry.modifier ?? entry)).filter(Boolean));
   }
   if (typeof modifiers === 'string') return uniqueStrings(modifiers.split(/\s+/).filter(Boolean));
   if (typeof modifiers === 'object') {
@@ -12485,112 +14001,142 @@ function csharpRoslynModifierNames(node) {
   return [];
 }
 
-function csharpRoslynTypeDeclarationKind(kind) {
-  return kind === 'ClassDeclaration'
-    || kind === 'InterfaceDeclaration'
-    || kind === 'StructDeclaration'
-    || kind === 'RecordDeclaration'
-    || kind === 'RecordStructDeclaration'
-    || kind === 'EnumDeclaration';
+function swiftSyntaxAttributeNames(node) {
+  const attributes = node.attributes ?? node.attributeList;
+  if (!attributes) return [];
+  if (Array.isArray(attributes)) {
+    return uniqueStrings(attributes.map((entry) => typeof entry === 'string' ? entry : swiftSyntaxName(entry.attributeName ?? entry.name ?? entry)).filter(Boolean));
+  }
+  return [];
 }
 
-function csharpRoslynTypeDeclarationSymbolKind(kind) {
-  if (kind === 'ClassDeclaration' || kind === 'RecordDeclaration') return 'class';
-  if (kind === 'InterfaceDeclaration') return 'interface';
+function swiftSyntaxVariableNames(node) {
+  const bindings = node.bindings ?? node.bindingSpecifier?.bindings ?? node.patternBindings;
+  if (Array.isArray(bindings)) return bindings.map((binding) => swiftSyntaxPatternName(binding.pattern ?? binding)).filter(Boolean);
+  const name = swiftSyntaxPatternName(node.pattern) ?? swiftSyntaxDeclarationName(node);
+  return name ? [name] : [];
+}
+
+function swiftSyntaxEnumCaseNames(node) {
+  const elements = node.elements ?? node.caseElements ?? node.cases;
+  if (Array.isArray(elements)) return elements.map((entry) => swiftSyntaxDeclarationName(entry, 'EnumCaseElement')).filter(Boolean);
+  const name = swiftSyntaxDeclarationName(node);
+  return name ? [name] : [];
+}
+
+function swiftSyntaxPatternName(pattern) {
+  if (!pattern) return undefined;
+  if (typeof pattern === 'string') return pattern;
+  return swiftSyntaxName(pattern.identifier ?? pattern.name ?? pattern.boundName ?? pattern.pattern ?? pattern);
+}
+
+function swiftSyntaxTypeDeclarationKind(kind) {
+  return kind === 'ClassDecl'
+    || kind === 'StructDecl'
+    || kind === 'EnumDecl'
+    || kind === 'ProtocolDecl'
+    || kind === 'ActorDecl';
+}
+
+function swiftSyntaxTypeDeclarationSymbolKind(kind) {
+  if (kind === 'ClassDecl') return 'class';
+  if (kind === 'StructDecl') return 'struct';
+  if (kind === 'EnumDecl') return 'enum';
+  if (kind === 'ProtocolDecl') return 'protocol';
+  if (kind === 'ActorDecl') return 'class';
   return 'type';
 }
 
-function csharpRoslynMethodLikeKind(kind) {
-  return kind === 'MethodDeclaration'
-    || kind === 'ConstructorDeclaration'
-    || kind === 'DestructorDeclaration'
-    || kind === 'OperatorDeclaration'
-    || kind === 'ConversionOperatorDeclaration';
+function swiftSyntaxFunctionLikeKind(kind) {
+  return kind === 'FunctionDecl'
+    || kind === 'InitializerDecl'
+    || kind === 'DeinitializerDecl'
+    || kind === 'SubscriptDecl'
+    || kind === 'OperatorDecl'
+    || kind === 'PrecedenceGroupDecl';
 }
 
-function csharpRoslynHasBody(node) {
-  return Boolean(node.body || node.expressionBody || node.accessorList || Array.isArray(node.statements));
+function swiftSyntaxHasBody(node) {
+  return Boolean(node.body || node.accessorBlock || node.memberBlock || Array.isArray(node.statements));
 }
 
-function csharpRoslynOperatorName(node, kind) {
-  if (kind === 'ConstructorDeclaration') return csharpRoslynDeclarationName(node);
-  if (kind === 'DestructorDeclaration') return `~${csharpRoslynDeclarationName(node) ?? 'destructor'}`;
-  if (kind === 'OperatorDeclaration') return `operator ${csharpRoslynName(node.operatorToken) ?? csharpRoslynName(node.operatorKeyword) ?? 'operator'}`;
-  if (kind === 'ConversionOperatorDeclaration') return `operator ${csharpRoslynTypeName(node.type) ?? 'conversion'}`;
-  return undefined;
+function swiftSyntaxOperatorName(node, kind) {
+  if (kind === 'PrecedenceGroupDecl') return swiftSyntaxDeclarationName(node) ?? 'precedencegroup';
+  const operatorToken = swiftSyntaxName(node.operatorIdentifier ?? node.operatorToken ?? node.name);
+  return operatorToken ? `operator ${operatorToken}` : undefined;
 }
 
-function csharpRoslynLiteralValue(node) {
+function swiftSyntaxLiteralValue(node) {
   const value = node.value ?? node.literal;
   if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;
   return undefined;
 }
 
-function csharpRoslynRecoveredKind(kind) {
-  return kind === 'IncompleteMember'
-    || kind === 'SkippedTokensTrivia'
-    || /Skipped|Missing|Bad|Incomplete/.test(String(kind));
+function swiftSyntaxRecoveredKind(kind) {
+  return kind === 'UnexpectedNodes'
+    || kind === 'MissingToken'
+    || kind === 'SkippedToken'
+    || kind === 'Error'
+    || /Unexpected|Missing|Skipped|Error/.test(String(kind));
 }
 
-function csharpRoslynProblemNode(node, kind) {
+function swiftSyntaxProblemNode(node, kind) {
   return Boolean(
-    node.containsDiagnostics
-    || node.ContainsDiagnostics
+    node.isMissing
+    || node.hasError
+    || node.containsDiagnostics
     || node.containsSkippedText
-    || node.ContainsSkippedText
-    || node.isMissing
-    || node.IsMissing
-    || node.hasDiagnostics
-    || node.HasDiagnostics
-    || kind === 'IncompleteMember'
-    || kind === 'SkippedTokensTrivia'
+    || node.presence === 'missing'
+    || kind === 'UnexpectedNodes'
+    || kind === 'MissingToken'
+    || kind === 'SkippedToken'
+    || kind === 'Error'
   );
 }
 
-function csharpRoslynDirectiveKind(kind) {
-  return /DirectiveTrivia$/.test(String(kind)) || /^(IfDirective|ElifDirective|ElseDirective|EndIfDirective|DefineDirective|UndefDirective|NullableDirective|RegionDirective|EndRegionDirective|PragmaWarningDirective|LineDirective|ErrorDirective|WarningDirective|LoadDirective|ReferenceDirective)/.test(String(kind));
+function swiftSyntaxConditionalCompilationKind(kind) {
+  return /IfConfig|ConditionalCompilation|PoundIf|PoundElse|PoundElseif|PoundEndif/i.test(String(kind));
 }
 
-function csharpGeneratedCodeMarker(node, kind) {
-  if (node.generated || node.Generated || node.isGenerated) return true;
+function swiftSyntaxMacroKind(kind) {
+  return /Macro/i.test(String(kind));
+}
+
+function swiftGeneratedCodeMarker(node, kind) {
+  if (node.generated || node.isGenerated) return true;
   const path = String(node.filePath ?? node.path ?? node.sourcePath ?? '');
-  if (csharpGeneratedSourcePath(path)) return true;
+  if (swiftGeneratedSourcePath(path)) return true;
   if (kind === 'Attribute') {
-    const name = csharpRoslynDeclarationName(node);
-    if (name && /(^|\.)(GeneratedCode|CompilerGenerated|DebuggerNonUserCode)Attribute?$/.test(name)) return true;
-  }
-  const attributes = node.attributeLists ?? node.attributes;
-  if (Array.isArray(attributes)) {
-    return JSON.stringify(attributes).includes('GeneratedCode')
-      || JSON.stringify(attributes).includes('CompilerGenerated');
+    const name = swiftSyntaxDeclarationName(node);
+    if (name && /(^|\.)(Generated|CompilerGenerated|_spi)Attribute?$/.test(name)) return true;
   }
   return false;
 }
 
-function csharpGeneratedSourcePath(path) {
-  return typeof path === 'string' && /\.(g|generated|designer)\.cs$/i.test(path);
+function swiftGeneratedSourcePath(path) {
+  return typeof path === 'string' && /\.(g|generated)\.swift$/i.test(path);
 }
 
-function csharpGeneratedCodeLoss(input, nodeId, span, options = {}, metadata = {}) {
+function swiftGeneratedCodeLoss(input, nodeId, span, options = {}, metadata = {}) {
   return {
-    id: `loss_${idFragment(nodeId ?? input.sourcePath ?? 'csharp')}_csharp_generated_code`,
+    id: `loss_${idFragment(nodeId ?? input.sourcePath ?? 'swift')}_swift_generated_code`,
     severity: 'warning',
     phase: 'parse',
     sourceFormat: input.language,
     kind: 'generatedCode',
-    message: 'C# generated-source or source-generator marker was imported; generated member provenance and source ownership require host evidence.',
+    message: 'Swift generated-source marker was imported; generated member provenance and source ownership require host evidence.',
     span,
     nodeId,
     metadata: {
       parser: options.parser,
       astFormat: options.astFormat,
-      sourceGeneratorEvidence: csharpEvidenceSummary(options.sourceGeneratorEvidence),
+      macroExpansionEvidence: swiftEvidenceSummary(options.macroExpansionEvidence),
       ...metadata
     }
   };
 }
 
-function csharpEvidenceSummary(value) {
+function swiftEvidenceSummary(value) {
   if (!value) return undefined;
   if (Array.isArray(value)) return { entryCount: value.length };
   if (typeof value === 'string') return { value };
@@ -12599,11 +14145,12 @@ function csharpEvidenceSummary(value) {
     if (typeof value.hash === 'string') summary.hash = value.hash;
     if (typeof value.solver === 'string') summary.solver = value.solver;
     if (Array.isArray(value.entries)) summary.entryCount = value.entries.length;
-    if (Array.isArray(value.references)) summary.referenceCount = value.references.length;
     if (Array.isArray(value.symbols)) summary.symbolCount = value.symbols.length;
+    if (Array.isArray(value.references)) summary.referenceCount = value.references.length;
+    if (Array.isArray(value.types)) summary.typeCount = value.types.length;
     if (Array.isArray(value.diagnostics)) summary.diagnosticCount = value.diagnostics.length;
-    if (Array.isArray(value.generators)) summary.generatorCount = value.generators.length;
-    if (Array.isArray(value.projects)) summary.projectCount = value.projects.length;
+    if (Array.isArray(value.macros)) summary.macroCount = value.macros.length;
+    if (Array.isArray(value.packages)) summary.packageCount = value.packages.length;
     return Object.keys(summary).length ? summary : { present: true };
   }
   return { present: true };