@shapeshift-labs/frontier-lang-compiler 0.2.41 → 0.2.42

package/dist/internal/index-impl/treeSitterDeclaration.js

@@ -0,0 +1,24 @@
+import{declarationRecord}from'./declarationRecord.js';import{nativeNodeId}from'./nativeNodeId.js';import{shortNodeText}from'./shortNodeText.js';import{treeSitterFieldText}from'./treeSitterFieldText.js';
+export function treeSitterDeclaration(node, kind, nativeNodeId, input) {
+  if (/import|include|use/.test(kind)) {
+    const name = treeSitterFieldText(node, 'path') ?? treeSitterFieldText(node, 'source') ?? shortNodeText(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'module', 'import');
+  }
+  if (/function|method|fn_item|function_declaration/.test(kind)) {
+    const name = treeSitterFieldText(node, 'name');
+    if (name) return declarationRecord(input, nativeNodeId, name, 'function', 'definition');
+  }
+  if (/class/.test(kind)) {
+    const name = treeSitterFieldText(node, 'name');
+    if (name) return declarationRecord(input, nativeNodeId, name, 'class', 'definition');
+  }
+  if (/interface/.test(kind)) {
+    const name = treeSitterFieldText(node, 'name');
+    if (name) return declarationRecord(input, nativeNodeId, name, 'interface', 'definition');
+  }
+  if (/struct|enum|type/.test(kind)) {
+    const name = treeSitterFieldText(node, 'name');
+    if (name) return declarationRecord(input, nativeNodeId, name, 'type', 'definition');
+  }
+  return undefined;
+}

package/dist/internal/index-impl/treeSitterFieldText.js

@@ -0,0 +1,5 @@
+import{shortNodeText}from'./shortNodeText.js';
+export function treeSitterFieldText(node, field) {
+  if (typeof node.childForFieldName !== 'function') return undefined;
+  return shortNodeText(node.childForFieldName(field));
+}

package/dist/internal/index-impl/truncatedAstLoss.js

@@ -0,0 +1,16 @@
+import{idFragment}from'../../native-import-utils.js';
+export function truncatedAstLoss(input, context, options) {
+  return {
+    id: `loss_${idFragment(input.sourcePath ?? input.language)}_${idFragment(options.astFormat ?? options.parser)}_truncated`,
+    severity: 'warning',
+    phase: 'read',
+    sourceFormat: input.language,
+    kind: 'opaqueNative',
+    message: `Native AST normalization stopped after ${context.maxNodes} node(s).`,
+    metadata: {
+      parser: options.parser,
+      astFormat: options.astFormat,
+      maxNodes: context.maxNodes
+    }
+  };
+}

package/dist/internal/index-impl/typeScriptDeclaration.js

@@ -0,0 +1,14 @@
+import{declarationRecord}from'./declarationRecord.js';import{namedDeclaration}from'./namedDeclaration.js';import{nativeNodeId}from'./nativeNodeId.js';import{stringFromTsExpression}from'./stringFromTsExpression.js';
+export function typeScriptDeclaration(node, kind, nativeNodeId, input) {
+  if (kind === 'ImportDeclaration' || kind === 'ImportEqualsDeclaration') {
+    const name = stringFromTsExpression(node.moduleSpecifier) ?? stringFromTsExpression(node.externalModuleReference?.expression);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'module', 'import');
+  }
+  if (kind === 'FunctionDeclaration') return namedDeclaration(input, nativeNodeId, node.name, 'function');
+  if (kind === 'ClassDeclaration') return namedDeclaration(input, nativeNodeId, node.name, 'class');
+  if (kind === 'InterfaceDeclaration') return namedDeclaration(input, nativeNodeId, node.name, 'interface');
+  if (kind === 'TypeAliasDeclaration' || kind === 'EnumDeclaration') return namedDeclaration(input, nativeNodeId, node.name, 'type');
+  if (kind === 'VariableDeclaration') return namedDeclaration(input, nativeNodeId, node.name, 'variable');
+  if (kind === 'MethodDeclaration' || kind === 'MethodSignature') return namedDeclaration(input, nativeNodeId, node.name, 'method');
+  return undefined;
+}

package/dist/internal/index-impl/typeScriptKindName.js

@@ -0,0 +1,6 @@
+export function typeScriptKindName(node, ts) {
+  if (typeof node.kindName === 'string') return node.kindName;
+  if (ts?.SyntaxKind && node.kind !== undefined) return ts.SyntaxKind[node.kind] ?? `SyntaxKind${node.kind}`;
+  if (typeof node.kind === 'string') return node.kind;
+  return `SyntaxKind${node.kind ?? 'Unknown'}`;
+}

package/dist/internal/index-impl/typeScriptNodeValue.js

@@ -0,0 +1,4 @@
+import{identifierName}from'./identifierName.js';import{stringFromTsExpression}from'./stringFromTsExpression.js';
+export function typeScriptNodeValue(node) {
+  return identifierName(node.name) ?? stringFromTsExpression(node.moduleSpecifier) ?? undefined;
+}

package/dist/internal/index-impl/uniqueNativeProjectionDeclarations.js

@@ -0,0 +1,9 @@
+export function uniqueNativeProjectionDeclarations(declarations) {
+  const seen = new Set();
+  return declarations.filter((declaration) => {
+    const key = `${declaration.kind}:${declaration.name}:${declaration.symbolId ?? declaration.nativeAstNodeId ?? ''}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}

package/dist/internal/index-impl/uniqueSemanticSliceNativeNodes.js

@@ -0,0 +1,11 @@
+export function uniqueSemanticSliceNativeNodes(nodes) {
+  const seen = new Set();
+  const result = [];
+  for (const node of nodes ?? []) {
+    const id = node?.id ?? node?.nodeId;
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    result.push({ ...node, id });
+  }
+  return result;
+}

package/dist/internal/index-impl/uniqueSemanticSliceRegions.js

@@ -0,0 +1,15 @@
+import{idFragment}from'../../native-import-utils.js';
+export function uniqueSemanticSliceRegions(regions) {
+  const seen = new Set();
+  const result = [];
+  for (const region of regions ?? []) {
+    if (!region) continue;
+    const id = region.id ?? `region_${idFragment(region.key ?? region.sourcePath ?? region.symbolId ?? result.length)}`;
+    const key = region.key ?? id;
+    const dedupeKey = `${id}:${key}`;
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    result.push({ ...region, id, key });
+  }
+  return result;
+}

package/dist/internal/index-impl/uniqueSemanticSliceSpans.js

@@ -0,0 +1,21 @@
+export function uniqueSemanticSliceSpans(spans) {
+  const seen = new Set();
+  const result = [];
+  for (const span of spans ?? []) {
+    if (!span) continue;
+    const key = [
+      span.path,
+      span.sourceId,
+      span.start,
+      span.end,
+      span.startLine,
+      span.startColumn,
+      span.endLine,
+      span.endColumn
+    ].join(':');
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(span);
+  }
+  return result;
+}

package/dist/internal/index-impl/unverifiedNativeAstLosses.js

@@ -0,0 +1,16 @@
+export function unverifiedNativeAstLosses(input, nativeAst, context) {
+  if (context.lightweight || context.exactAst || context.hasLosses) return [];
+  if (!(input?.nativeAst || input?.nodes)) return [];
+  return [{
+    id: `loss_${context.importIdPart}_unverified_native_ast`,
+    severity: 'warning',
+    kind: 'unverifiedNativeAst',
+    nodeId: nativeAst?.rootId,
+    message: 'Caller supplied native AST nodes without explicit exactAst or adapter coverage evidence.',
+    metadata: {
+      reason: 'missing-exact-ast-evidence',
+      nativeAstId: nativeAst?.id,
+      parser: nativeAst?.parser
+    }
+  }];
+}

package/dist/internal/index-impl/uriToPath.js

@@ -0,0 +1,11 @@
+export function uriToPath(uri) {
+  if (typeof uri !== 'string') return undefined;
+  if (uri.startsWith('file://')) {
+    try {
+      return decodeURIComponent(new URL(uri).pathname);
+    } catch {
+      return uri.replace(/^file:\/\//, '');
+    }
+  }
+  return uri;
+}

package/dist/internal/index-impl/visitCSharpRoslynNode.js

@@ -0,0 +1,87 @@
+import{idFragment}from'../../native-import-utils.js';
+import{csharpGeneratedCodeLoss}from'./csharpGeneratedCodeLoss.js';import{csharpGeneratedCodeMarker}from'./csharpGeneratedCodeMarker.js';import{csharpRoslynChildEntries}from'./csharpRoslynChildEntries.js';import{csharpRoslynDeclarations}from'./csharpRoslynDeclarations.js';import{csharpRoslynDirectiveKind}from'./csharpRoslynDirectiveKind.js';import{csharpRoslynKind}from'./csharpRoslynKind.js';import{csharpRoslynNodeValue}from'./csharpRoslynNodeValue.js';import{csharpRoslynPositionKind}from'./csharpRoslynPositionKind.js';import{csharpRoslynProblemNode}from'./csharpRoslynProblemNode.js';import{csharpRoslynRecoveredKind}from'./csharpRoslynRecoveredKind.js';import{isCSharpRoslynNode}from'./isCSharpRoslynNode.js';import{nativeNodeId}from'./nativeNodeId.js';import{numberOrUndefined}from'./numberOrUndefined.js';import{primitiveCSharpRoslynFields}from'./primitiveCSharpRoslynFields.js';import{spanFromCSharpRoslynNode}from'./spanFromCSharpRoslynNode.js';
+export function visitCSharpRoslynNode(node, context, propertyPath) {
+  if (!isCSharpRoslynNode(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 = csharpRoslynKind(node);
+  const span = spanFromCSharpRoslynNode(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 csharpRoslynChildEntries(node, kind)) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        const childId = visitCSharpRoslynNode(entry, context, `${propertyPath}.${field}[${index}]`);
+        if (childId) children.push(childId);
+      });
+    } else {
+      const childId = visitCSharpRoslynNode(value, context, `${propertyPath}.${field}`);
+      if (childId) children.push(childId);
+    }
+  }
+  const declarations = csharpRoslynDeclarations(node, kind, id, context.input);
+  const declaration = declarations[0];
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? csharpRoslynNodeValue(node),
+    fields: primitiveCSharpRoslynFields(node, kind),
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      rawKind: numberOrUndefined(node.rawKind ?? node.RawKind),
+      positionKind: csharpRoslynPositionKind(node),
+      parser: context.options.parser
+    }
+  };
+  context.nodes[id] = nativeNode;
+  for (const entry of declarations) {
+    context.declarations.push({ ...entry, nativeNode });
+  }
+  if (csharpRoslynRecoveredKind(kind) || csharpRoslynProblemNode(node, kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_csharp_roslyn_recovered_node`,
+      severity: 'error',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'unsupportedSyntax',
+      message: 'Roslyn reported skipped text, missing syntax, or syntax diagnostics; semantic import is partial until syntax errors are resolved.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        nodeKind: kind
+      }
+    });
+  }
+  if (csharpRoslynDirectiveKind(kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_csharp_preprocessor`,
+      severity: 'warning',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'preprocessor',
+      message: 'C# preprocessor directive was imported as syntax; conditional compilation state and inactive branches require host evidence.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        nodeKind: kind
+      }
+    });
+  }
+  if (csharpGeneratedCodeMarker(node, kind)) {
+    context.losses.push(csharpGeneratedCodeLoss(context.input, id, span, context.options, { nodeKind: kind }));
+  }
+  return id;
+}

package/dist/internal/index-impl/visitClangAstNode.js

@@ -0,0 +1,62 @@
+import{idFragment}from'../../native-import-utils.js';
+import{clangAstChildEntries}from'./clangAstChildEntries.js';import{clangAstDeclaration}from'./clangAstDeclaration.js';import{clangAstKind}from'./clangAstKind.js';import{clangAstNodeValue}from'./clangAstNodeValue.js';import{clangLocationKind}from'./clangLocationKind.js';import{clangPreprocessorKind}from'./clangPreprocessorKind.js';import{isClangAstNode}from'./isClangAstNode.js';import{nativeNodeId}from'./nativeNodeId.js';import{primitiveClangAstFields}from'./primitiveClangAstFields.js';import{spanFromClangAstNode}from'./spanFromClangAstNode.js';
+export function visitClangAstNode(node, context, propertyPath) {
+  if (!isClangAstNode(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 = clangAstKind(node);
+  const span = spanFromClangAstNode(node, context.input);
+  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 clangAstChildEntries(node)) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        const childId = visitClangAstNode(entry, context, `${propertyPath}.${field}[${index}]`);
+        if (childId) children.push(childId);
+      });
+    } else {
+      const childId = visitClangAstNode(value, context, `${propertyPath}.${field}`);
+      if (childId) children.push(childId);
+    }
+  }
+  const declaration = clangAstDeclaration(node, kind, id, context.input);
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? clangAstNodeValue(node),
+    fields: primitiveClangAstFields(node, kind),
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      clangId: typeof node.id === 'string' || typeof node.id === 'number' ? String(node.id) : undefined,
+      locationKind: clangLocationKind(node)
+    }
+  };
+  context.nodes[id] = nativeNode;
+  if (declaration) context.declarations.push({ ...declaration, nativeNode });
+  if (clangPreprocessorKind(kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_clang_preprocessor`,
+      severity: 'warning',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'preprocessor',
+      message: 'Clang AST preprocessor records were imported, but macro expansion, inactive branches, and compile-command provenance require host evidence.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat
+      }
+    });
+  }
+  return id;
+}

package/dist/internal/index-impl/visitGoAstNode.js

@@ -0,0 +1,99 @@
+import{idFragment}from'../../native-import-utils.js';
+import{goAstChildEntries}from'./goAstChildEntries.js';import{goAstDeclarations}from'./goAstDeclarations.js';import{goAstKind}from'./goAstKind.js';import{goAstNodeValue}from'./goAstNodeValue.js';import{goAstPositionKind}from'./goAstPositionKind.js';import{goBadAstKind}from'./goBadAstKind.js';import{goGeneratedCodeMarker}from'./goGeneratedCodeMarker.js';import{goReceiverFieldCount}from'./goReceiverFieldCount.js';import{isGoAstNode}from'./isGoAstNode.js';import{nativeNodeId}from'./nativeNodeId.js';import{primitiveGoAstFields}from'./primitiveGoAstFields.js';import{spanFromGoAstNode}from'./spanFromGoAstNode.js';
+export function visitGoAstNode(node, context, propertyPath) {
+  if (!isGoAstNode(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 = goAstKind(node);
+  const span = spanFromGoAstNode(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 goAstChildEntries(node)) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        const childId = visitGoAstNode(entry, context, `${propertyPath}.${field}[${index}]`);
+        if (childId) children.push(childId);
+      });
+    } else {
+      const childId = visitGoAstNode(value, context, `${propertyPath}.${field}`);
+      if (childId) children.push(childId);
+    }
+  }
+  const declarations = goAstDeclarations(node, kind, id, context.input);
+  const declaration = declarations[0];
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? goAstNodeValue(node),
+    fields: primitiveGoAstFields(node, kind),
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      positionKind: goAstPositionKind(node),
+      packageName: context.options.packageName
+    }
+  };
+  context.nodes[id] = nativeNode;
+  for (const entry of declarations) {
+    context.declarations.push({ ...entry, nativeNode });
+  }
+  if (goBadAstKind(kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_go_bad_node`,
+      severity: 'error',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'unsupportedSyntax',
+      message: 'Go parser recovered a BadDecl/BadExpr/BadStmt 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 (kind === 'FuncDecl' && goReceiverFieldCount(node) > 1) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_go_multiple_receivers`,
+      severity: 'warning',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'unsupportedSyntax',
+      message: 'Go parser accepted multiple receiver fields; valid method ownership requires a single receiver.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        receiverFieldCount: goReceiverFieldCount(node)
+      }
+    });
+  }
+  if (goGeneratedCodeMarker(node, kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_go_generated_code`,
+      severity: 'warning',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'generatedCode',
+      message: 'Go generated-code marker was imported; regeneration provenance and source ownership require host evidence.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat
+      }
+    });
+  }
+  return id;
+}

package/dist/internal/index-impl/visitJavaAstNode.js

@@ -0,0 +1,73 @@
+import{idFragment}from'../../native-import-utils.js';
+import{isJavaAstNode}from'./isJavaAstNode.js';import{javaAstChildEntries}from'./javaAstChildEntries.js';import{javaAstDeclarations}from'./javaAstDeclarations.js';import{javaAstKind}from'./javaAstKind.js';import{javaAstNodeValue}from'./javaAstNodeValue.js';import{javaAstPositionKind}from'./javaAstPositionKind.js';import{javaGeneratedCodeLoss}from'./javaGeneratedCodeLoss.js';import{javaGeneratedCodeMarker}from'./javaGeneratedCodeMarker.js';import{javaLombokAnnotationMarker}from'./javaLombokAnnotationMarker.js';import{javaProblemNode}from'./javaProblemNode.js';import{javaRecoveredAstKind}from'./javaRecoveredAstKind.js';import{nativeNodeId}from'./nativeNodeId.js';import{primitiveJavaAstFields}from'./primitiveJavaAstFields.js';import{spanFromJavaAstNode}from'./spanFromJavaAstNode.js';
+export function visitJavaAstNode(node, context, propertyPath) {
+  if (!isJavaAstNode(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 = javaAstKind(node);
+  const span = spanFromJavaAstNode(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 javaAstChildEntries(node, kind)) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        const childId = visitJavaAstNode(entry, context, `${propertyPath}.${field}[${index}]`);
+        if (childId) children.push(childId);
+      });
+    } else {
+      const childId = visitJavaAstNode(value, context, `${propertyPath}.${field}`);
+      if (childId) children.push(childId);
+    }
+  }
+  const declarations = javaAstDeclarations(node, kind, id, context.input);
+  const declaration = declarations[0];
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? javaAstNodeValue(node),
+    fields: primitiveJavaAstFields(node, kind),
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      positionKind: javaAstPositionKind(node),
+      parser: context.options.parser
+    }
+  };
+  context.nodes[id] = nativeNode;
+  for (const entry of declarations) {
+    context.declarations.push({ ...entry, nativeNode });
+  }
+  if (javaRecoveredAstKind(kind) || javaProblemNode(node, kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_java_recovered_node`,
+      severity: 'error',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'unsupportedSyntax',
+      message: 'Java parser reported a recovered, erroneous, malformed, or problem 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 (javaGeneratedCodeMarker(node, kind) || javaLombokAnnotationMarker(node, kind)) {
+    context.losses.push(javaGeneratedCodeLoss(context.input, id, span, context.options, {
+      nodeKind: kind,
+      generatedMarker: javaGeneratedCodeMarker(node, kind),
+      lombokMarker: javaLombokAnnotationMarker(node, kind)
+    }));
+  }
+  return id;
+}

package/dist/internal/index-impl/visitKotlinPsiNode.js

@@ -0,0 +1,108 @@
+import{idFragment}from'../../native-import-utils.js';
+import{isKotlinPsiNode}from'./isKotlinPsiNode.js';import{kotlinCompilerPluginAnnotationNode}from'./kotlinCompilerPluginAnnotationNode.js';import{kotlinContractNode}from'./kotlinContractNode.js';import{kotlinCoroutineNode}from'./kotlinCoroutineNode.js';import{kotlinExpectActualNode}from'./kotlinExpectActualNode.js';import{kotlinGeneratedCodeLoss}from'./kotlinGeneratedCodeLoss.js';import{kotlinGeneratedCodeMarker}from'./kotlinGeneratedCodeMarker.js';import{kotlinPsiAnnotationNames}from'./kotlinPsiAnnotationNames.js';import{kotlinPsiChildEntries}from'./kotlinPsiChildEntries.js';import{kotlinPsiDeclarations}from'./kotlinPsiDeclarations.js';import{kotlinPsiKind}from'./kotlinPsiKind.js';import{kotlinPsiNodeValue}from'./kotlinPsiNodeValue.js';import{kotlinPsiPositionKind}from'./kotlinPsiPositionKind.js';import{kotlinPsiProblemNode}from'./kotlinPsiProblemNode.js';import{kotlinPsiRecoveredKind}from'./kotlinPsiRecoveredKind.js';import{kotlinUnsupportedSemanticLoss}from'./kotlinUnsupportedSemanticLoss.js';import{nativeNodeId}from'./nativeNodeId.js';import{primitiveKotlinPsiFields}from'./primitiveKotlinPsiFields.js';import{spanFromKotlinPsiNode}from'./spanFromKotlinPsiNode.js';
+export 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;
+}

package/dist/internal/index-impl/visitPythonAstNode.js

@@ -0,0 +1,47 @@
+import{isPythonAstNode}from'./isPythonAstNode.js';import{nativeNodeId}from'./nativeNodeId.js';import{numberOrUndefined}from'./numberOrUndefined.js';import{primitivePythonAstFields}from'./primitivePythonAstFields.js';import{pythonAstChildEntries}from'./pythonAstChildEntries.js';import{pythonAstDeclaration}from'./pythonAstDeclaration.js';import{pythonAstKind}from'./pythonAstKind.js';import{pythonAstNodeValue}from'./pythonAstNodeValue.js';import{spanFromPythonAstNode}from'./spanFromPythonAstNode.js';
+export function visitPythonAstNode(node, context, propertyPath) {
+  if (!isPythonAstNode(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 = pythonAstKind(node);
+  const span = spanFromPythonAstNode(node, context.input);
+  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 pythonAstChildEntries(node)) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        const childId = visitPythonAstNode(entry, context, `${propertyPath}.${field}[${index}]`);
+        if (childId) children.push(childId);
+      });
+    } else {
+      const childId = visitPythonAstNode(value, context, `${propertyPath}.${field}`);
+      if (childId) children.push(childId);
+    }
+  }
+  const declaration = pythonAstDeclaration(node, kind, id, context.input);
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? pythonAstNodeValue(node),
+    fields: primitivePythonAstFields(node, kind),
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      lineno: numberOrUndefined(node.lineno ?? node.line),
+      colOffset: numberOrUndefined(node.col_offset ?? node.colOffset),
+      endLineno: numberOrUndefined(node.end_lineno ?? node.endLine),
+      endColOffset: numberOrUndefined(node.end_col_offset ?? node.endColOffset)
+    }
+  };
+  context.nodes[id] = nativeNode;
+  if (declaration) context.declarations.push({ ...declaration, nativeNode });
+  return id;
+}