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

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

@@ -0,0 +1,52 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+import{createNativeImportFromPythonAst}from'./createNativeImportFromPythonAst.js';import{declarationSemanticCoverage}from'./declarationSemanticCoverage.js';import{missingInjectedParserResult}from'./missingInjectedParserResult.js';import{nativeImporterAdapterCoverage}from'./nativeImporterAdapterCoverage.js';import{normalizeParserErrors}from'./normalizeParserErrors.js';import{parsePythonAstSource}from'./parsePythonAstSource.js';import{pythonAstRoot}from'./pythonAstRoot.js';
+export function createPythonAstNativeImporterAdapter(options = {}) {
+  return {
+    id: options.id ?? 'frontier.python-ast-native-importer',
+    language: options.language ?? 'python',
+    parser: options.parser ?? 'python-ast',
+    version: options.version,
+    capabilities: uniqueStrings(['nativeAst', 'semanticIndex', 'sourceMaps', 'diagnostics', ...(options.capabilities ?? [])]),
+    coverage: nativeImporterAdapterCoverage({
+      exactness: 'exact-parser-ast',
+      exactAst: true,
+      tokens: false,
+      trivia: false,
+      diagnostics: true,
+      sourceRanges: true,
+      generatedRanges: false,
+      semanticCoverage: declarationSemanticCoverage(),
+      notes: [
+        'Normalizes caller-owned Python stdlib ast trees into native AST nodes and declaration-level semantic index records.',
+        'Python ast does not preserve comments, whitespace, or concrete formatting; use LibCST/parso-style host evidence for round-trip trivia.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions ?? ['.py', '.pyi'],
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const parsed = input.options?.ast
+        ?? input.options?.nativeAst
+        ?? options.ast
+        ?? parsePythonAstSource(input, options);
+      const root = pythonAstRoot(parsed);
+      if (!root) {
+        return missingInjectedParserResult(input, {
+          parser: options.parser ?? 'python-ast',
+          adapterId: options.id ?? 'frontier.python-ast-native-importer',
+          message: 'createPythonAstNativeImporterAdapter requires an injected Python AST object, parserModule.parse function, parse function, or adapterOptions.ast.'
+        });
+      }
+      const parseDiagnostics = normalizeParserErrors(parsed?.errors ?? parsed?.diagnostics, input, {
+        parser: options.parser ?? 'python-ast'
+      });
+      return createNativeImportFromPythonAst(root, input, {
+        parser: options.parser ?? 'python-ast',
+        astFormat: 'python-ast',
+        maxNodes: options.maxNodes,
+        diagnostics: parseDiagnostics,
+        pythonVersion: options.pythonVersion ?? input.options?.pythonVersion ?? parsed?.pythonVersion,
+        includeAttributes: options.includeAttributes ?? input.options?.includeAttributes
+      });
+    }
+  };
+}

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

@@ -0,0 +1,56 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+import{createNativeImportFromRustSyn}from'./createNativeImportFromRustSyn.js';import{declarationSemanticCoverage}from'./declarationSemanticCoverage.js';import{missingInjectedParserResult}from'./missingInjectedParserResult.js';import{nativeImporterAdapterCoverage}from'./nativeImporterAdapterCoverage.js';import{normalizeParserErrors}from'./normalizeParserErrors.js';import{parseRustSynSource}from'./parseRustSynSource.js';import{rustSynAstRoot}from'./rustSynAstRoot.js';
+export function createRustSynNativeImporterAdapter(options = {}) {
+  return {
+    id: options.id ?? 'frontier.rust-syn-native-importer',
+    language: options.language ?? 'rust',
+    parser: options.parser ?? 'syn',
+    version: options.version,
+    capabilities: uniqueStrings(['nativeAst', 'semanticIndex', 'sourceMaps', 'diagnostics', ...(options.capabilities ?? [])]),
+    coverage: nativeImporterAdapterCoverage({
+      exactness: 'exact-parser-ast',
+      exactAst: true,
+      tokens: false,
+      trivia: false,
+      diagnostics: true,
+      sourceRanges: false,
+      generatedRanges: false,
+      semanticCoverage: declarationSemanticCoverage(),
+      notes: [
+        'Normalizes caller-owned syn-shaped Rust ASTs into native AST nodes and declaration-level semantic index records.',
+        'syn does not expand macros, resolve names, type-check, or preserve full concrete syntax/trivia; attach rust-analyzer/rustc evidence for those claims.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions ?? ['.rs'],
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const parsed = input.options?.ast
+        ?? input.options?.nativeAst
+        ?? input.options?.file
+        ?? input.options?.sourceFile
+        ?? options.ast
+        ?? options.file
+        ?? options.sourceFile
+        ?? parseRustSynSource(input, options);
+      const root = rustSynAstRoot(parsed);
+      if (!root) {
+        return missingInjectedParserResult(input, {
+          parser: options.parser ?? 'syn',
+          adapterId: options.id ?? 'frontier.rust-syn-native-importer',
+          message: 'createRustSynNativeImporterAdapter requires an injected syn-shaped AST object, parserModule.parse function, parse function, or adapterOptions.ast.'
+        });
+      }
+      const parseDiagnostics = normalizeParserErrors(parsed?.errors ?? parsed?.diagnostics, input, {
+        parser: options.parser ?? 'syn'
+      });
+      return createNativeImportFromRustSyn(root, input, {
+        parser: options.parser ?? 'syn',
+        astFormat: 'rust-syn',
+        maxNodes: options.maxNodes,
+        diagnostics: parseDiagnostics,
+        rustEdition: options.rustEdition ?? input.options?.rustEdition ?? parsed?.rustEdition,
+        includeAttributes: options.includeAttributes ?? input.options?.includeAttributes
+      });
+    }
+  };
+}

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

@@ -0,0 +1,105 @@
+import{idFragment,maxSemanticMergeReadiness,uniqueRecordsById}from'../../native-import-utils.js';import{summarizeSemanticImportSidecarParadigmSemantics,summarizeSemanticImportSidecarProofSpec,summarizeSemanticImportSidecarUniversalAstLayers}from'../../semantic-import-layers.js';import{semanticPatchHintForRegion,summarizeSemanticImportRegionTaxonomy}from'../../semantic-import-regions.js';import{semanticImportSidecarEntry}from'../../semantic-import-sidecar-entry.js';import{summarizeKernelSourcePreservation}from'../../semantic-import-source-preservation.js';
+import{createSemanticImportSidecarAdmission,createSemanticImportSidecarQuality}from'./createSemanticImportSidecarAdmission.js';
+import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
+export function createSemanticImportSidecar(importResult, options = {}) {
+  const imports = Array.isArray(importResult?.imports) ? importResult.imports : [importResult].filter(Boolean);
+  const importEntries = imports.map((imported, index) => semanticImportSidecarEntry(imported, index, options));
+  const symbols = importEntries.flatMap((entry) => entry.symbols);
+  const ownershipRegions = uniqueRecordsById(importEntries.flatMap((entry) => entry.ownershipRegions));
+  const sourceMaps = imports.flatMap((imported) => imported?.sourceMaps ?? imported?.universalAst?.sourceMaps ?? []);
+  const sourceMapMappings = sourceMaps.flatMap((sourceMap) => sourceMap?.mappings ?? []);
+  const losses = imports.flatMap((imported) => imported?.losses ?? []);
+  const evidence = uniqueRecordsById(imports.flatMap((imported) => imported?.evidence ?? []));
+  const mergeCandidates = imports.flatMap((imported) => imported?.mergeCandidates ?? []);
+  const lossSummary = summarizeNativeImportLosses(losses, { evidence });
+  const regionTaxonomy = summarizeSemanticImportRegionTaxonomy(ownershipRegions);
+  const sourcePreservation = summarizeKernelSourcePreservation(importResult, imports);
+  const universalAstLayers = summarizeSemanticImportSidecarUniversalAstLayers(importEntries);
+  const proofSpec = summarizeSemanticImportSidecarProofSpec(importEntries);
+  const paradigmSemantics = summarizeSemanticImportSidecarParadigmSemantics(importEntries);
+  const readiness = mergeCandidates.reduce(
+    (current, candidate) => maxSemanticMergeReadiness(current, candidate.readiness),
+    lossSummary.semanticMergeReadiness
+  );
+  const patchHints = ownershipRegions.map((region) => semanticPatchHintForRegion(region, readiness, options));
+  const quality = createSemanticImportSidecarQuality({
+    importEntries,
+    symbols,
+    ownershipRegions,
+    patchHints,
+    proofSpec,
+    evidence,
+    readiness
+  });
+  const admission = createSemanticImportSidecarAdmission(quality, readiness);
+  return {
+    kind: 'frontier.lang.semanticImportSidecar',
+    version: 1,
+    id: options.id ?? `semantic_import_${idFragment(importResult?.id ?? importResult?.projectRoot ?? imports[0]?.sourcePath ?? imports[0]?.language ?? 'source')}`,
+    generatedAt: options.generatedAt ?? Date.now(),
+    language: importResult?.language ?? (imports.length === 1 ? imports[0]?.language : 'mixed'),
+    projectRoot: importResult?.projectRoot,
+    imports: importEntries.map(({ ownershipRegions: _regions, symbols: _symbols, ...entry }) => entry),
+    symbols,
+    ownershipRegions,
+    sourceMaps: {
+      total: sourceMaps.length,
+      mappings: sourceMapMappings.length,
+      ids: sourceMaps.map((sourceMap) => sourceMap.id).filter(Boolean)
+    },
+    sourcePreservation,
+    universalAstLayers,
+    proofSpec,
+    paradigmSemantics,
+    patchHints,
+    quality,
+    admission,
+    mergeCandidates: mergeCandidates.map((candidate) => ({
+      id: candidate.id,
+      readiness: candidate.readiness,
+      reasons: candidate.reasons ?? [],
+      conflictClasses: (candidate.conflictClasses ?? candidate.metadata?.conflictClasses ?? []).map((record) => record.class).filter(Boolean),
+      conflictSummary: candidate.conflictSummary ?? candidate.metadata?.conflictSummary,
+      risk: candidate.risk,
+      operationCount: candidate.operations?.length ?? candidate.patch?.operations?.length ?? 0
+    })),
+    losses: {
+      total: losses.length,
+      byKind: lossSummary.byKind,
+      bySeverity: lossSummary.bySeverity,
+      categories: lossSummary.categories,
+      blockingLossIds: lossSummary.blockingLossIds,
+      reviewLossIds: lossSummary.reviewLossIds
+    },
+    regionTaxonomy,
+    evidence: {
+      total: evidence.length,
+      failed: evidence.filter((record) => record.status === 'failed').map((record) => record.id),
+      ids: evidence.map((record) => record.id)
+    },
+    summary: {
+      imports: imports.length,
+      symbols: symbols.length,
+      ownershipRegions: ownershipRegions.length,
+      regionKinds: regionTaxonomy.presentKinds.length,
+      sourceMapMappings: sourceMapMappings.length,
+      sourcePreservationRecords: sourcePreservation.total,
+      universalAstLayers: universalAstLayers.total,
+      universalAstLayerNames: universalAstLayers.names,
+      proofSpecRecords: proofSpec.total,
+      proofSpecObligations: proofSpec.obligations,
+      proofSpecFailedObligations: proofSpec.failed,
+      paradigmSemanticsRecords: paradigmSemantics.total,
+      paradigmSemanticsGroups: paradigmSemantics.groups.length,
+      paradigmSemanticsLoweringRecords: paradigmSemantics.loweringRecords,
+      patchHints: patchHints.length,
+      evidenceWarnings: quality.emptyEvidenceWarnings.length,
+      readiness,
+      emptySemanticIndex: symbols.length === 0
+    },
+    metadata: {
+      note: 'Sidecar is source-addressable semantic evidence for merge admission; lightweight scanner regions remain review-required unless exact parser evidence upgrades readiness.',
+      ...options.metadata
+    }
+  };
+}

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

@@ -0,0 +1,160 @@
+function sidecarSourcePaths(importEntries) {
+  return [...new Set(importEntries.map((entry) => entry.sourcePath).filter(Boolean))];
+}
+
+function sidecarQualityWarning(code, message, action, sourcePaths) {
+  return {
+    code,
+    severity: 'warning',
+    message,
+    action,
+    sourcePaths
+  };
+}
+
+export function createSemanticImportSidecarQuality(input) {
+  const { importEntries, symbols, ownershipRegions, patchHints, proofSpec, evidence, readiness } = input;
+  const sourcePaths = sidecarSourcePaths(importEntries);
+  const importCount = importEntries.length;
+  const warnings = [];
+  if (importCount === 0) warnings.push(sidecarQualityWarning(
+    'missing-imports',
+    'Semantic sidecar has no import entries; run native import before merge admission.',
+    'run-native-import',
+    sourcePaths
+  ));
+  if (importCount > 0 && symbols.length === 0) warnings.push(sidecarQualityWarning(
+    'empty-semantic-index',
+    'Semantic sidecar has import entries but no semantic symbols.',
+    'rerun-importer-with-semantic-index',
+    sourcePaths
+  ));
+  if (importCount > 0 && ownershipRegions.length === 0) warnings.push(sidecarQualityWarning(
+    'missing-ownership-regions',
+    'Semantic sidecar has no ownership regions for safe merge ownership.',
+    'rerun-sidecar-generation-with-ownership-regions',
+    sourcePaths
+  ));
+  if (importCount > 0 && patchHints.length === 0) warnings.push(sidecarQualityWarning(
+    'missing-patch-hints',
+    'Semantic sidecar has no patch hints.',
+    'generate-semantic-patch-hints',
+    sourcePaths
+  ));
+  if (importCount > 0 && evidence.length === 0) warnings.push(sidecarQualityWarning(
+    'empty-evidence',
+    'Semantic sidecar has no evidence records.',
+    'attach-semantic-import-evidence',
+    sourcePaths
+  ));
+  if (proofSpec.failed > 0) warnings.push(sidecarQualityWarning(
+    'failed-proof-obligations',
+    'Semantic sidecar has failed proof obligations.',
+    'resolve-failed-proof-obligations',
+    sourcePaths
+  ));
+  if (proofSpec.pending > 0) warnings.push(sidecarQualityWarning(
+    'pending-proof-obligations',
+    'Semantic sidecar has pending proof obligations.',
+    'review-pending-proof-obligations',
+    sourcePaths
+  ));
+  if (proofSpec.assumed > 0) warnings.push(sidecarQualityWarning(
+    'assumed-proof-obligations',
+    'Semantic sidecar has assumed proof obligations.',
+    'review-proof-assumptions',
+    sourcePaths
+  ));
+  if (proofSpec.externalToolRequired > 0) warnings.push(sidecarQualityWarning(
+    'external-tool-proof-obligations',
+    'Semantic sidecar has proof obligations requiring an external tool.',
+    'run-required-proof-tool',
+    sourcePaths
+  ));
+  if (proofSpec.unknown > 0) warnings.push(sidecarQualityWarning(
+    'unknown-proof-obligations',
+    'Semantic sidecar has proof obligations with unknown status.',
+    'classify-proof-obligations',
+    sourcePaths
+  ));
+  if (readiness === 'blocked') warnings.push(sidecarQualityWarning(
+    'blocked-readiness',
+    'Semantic sidecar readiness is blocked.',
+    'resolve-blocking-import-losses',
+    sourcePaths
+  ));
+  const emptyEvidenceWarnings = warnings.filter((warning) => (
+    warning.code === 'empty-evidence' ||
+    warning.code === 'empty-semantic-index' ||
+    warning.code === 'missing-ownership-regions' ||
+    warning.code === 'missing-patch-hints'
+  ));
+  const proofSummary = {
+    total: proofSpec.total,
+    obligations: proofSpec.obligations,
+    discharged: proofSpec.discharged,
+    pending: proofSpec.pending,
+    failed: proofSpec.failed,
+    assumed: proofSpec.assumed,
+    externalToolRequired: proofSpec.externalToolRequired,
+    open: proofSpec.open,
+    unknown: proofSpec.unknown,
+    empty: proofSpec.empty,
+    autoMergeProof: false
+  };
+  return {
+    schema: 'frontier.lang.semanticSidecarQuality.v1',
+    selected: importCount > 0,
+    eligible: importCount > 0 && emptyEvidenceWarnings.length === 0 && proofSpec.failed === 0 && readiness !== 'blocked',
+    imported: importCount > 0,
+    importCount,
+    symbolCount: symbols.length,
+    ownershipRegionCount: ownershipRegions.length,
+    patchHintCount: patchHints.length,
+    proofSummary,
+    evidenceCount: evidence.length,
+    warningCount: warnings.length,
+    warnings,
+    emptyEvidenceWarnings
+  };
+}
+
+export function createSemanticImportSidecarAdmission(quality, readiness) {
+  return {
+    schema: 'frontier.lang.semanticSidecarAdmission.v1',
+    selected: quality.selected,
+    eligible: quality.eligible,
+    imported: quality.imported,
+    importCount: quality.importCount,
+    readiness,
+    action: sidecarAdmissionAction(quality, readiness),
+    counts: {
+      symbols: quality.symbolCount,
+      ownershipRegions: quality.ownershipRegionCount,
+      patchHints: quality.patchHintCount,
+      evidence: quality.evidenceCount,
+      proofRecords: quality.proofSummary.total,
+      proofObligations: quality.proofSummary.obligations,
+      proofFailedObligations: quality.proofSummary.failed
+    },
+    proofSummary: quality.proofSummary,
+    warnings: quality.warnings,
+    emptyEvidenceWarnings: quality.emptyEvidenceWarnings
+  };
+}
+
+function sidecarAdmissionAction(quality, readiness) {
+  if (!quality.imported) return 'reject-missing-imports';
+  if (readiness === 'blocked') return 'reject-blocked';
+  if (quality.proofSummary.failed > 0) return 'reject-failed-proof';
+  if (quality.emptyEvidenceWarnings.length > 0) return 'reject-empty-evidence';
+  if (!quality.eligible) return 'reject-quality';
+  if (sidecarProofReviewObligations(quality.proofSummary) > 0) return 'review-proof-obligations';
+  if (readiness === 'needs-review') return 'review';
+  return 'admit';
+}
+
+function sidecarProofReviewObligations(proofSummary) {
+  return (proofSummary.pending ?? 0) + (proofSummary.assumed ?? 0) +
+    (proofSummary.externalToolRequired ?? 0) + (proofSummary.unknown ?? 0);
+}

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

@@ -0,0 +1,137 @@
+import{idFragment,uniqueStrings}from'../../native-import-utils.js';import{createSemanticMergeCandidateRecord}from'@shapeshift-labs/frontier-lang-kernel';
+import{createSemanticImportSidecar}from'./createSemanticImportSidecar.js';import{nativeNodeId}from'./nativeNodeId.js';import{readStringArray}from'./readStringArray.js';import{selectSemanticSliceRecords}from'./selectSemanticSliceRecords.js';import{semanticSliceContext}from'./semanticSliceContext.js';import{semanticSliceExpectedAssertions}from'./semanticSliceExpectedAssertions.js';import{semanticSliceReadiness}from'./semanticSliceReadiness.js';import{semanticSliceReasons}from'./semanticSliceReasons.js';import{semanticSliceRecords}from'./semanticSliceRecords.js';import{semanticSliceSourceFiles}from'./semanticSliceSourceFiles.js';import{semanticSliceSourceMapLinks}from'./semanticSliceSourceMapLinks.js';import{semanticSliceSourceSpans}from'./semanticSliceSourceSpans.js';import{semanticSliceTouchedSymbol}from'./semanticSliceTouchedSymbol.js';
+export function createSemanticSlice(input, options = {}) {
+  const context = semanticSliceContext(input, options);
+  const sidecar = context.sidecar ?? (context.importResult ? createSemanticImportSidecar(context.importResult, {
+    generatedAt: options.generatedAt,
+    regionPrefix: options.regionPrefix
+  }) : undefined);
+  const records = semanticSliceRecords(context, sidecar);
+  const entryRefs = uniqueStrings([
+    ...readStringArray(options.entryRefs),
+    ...readStringArray(options.semanticRefs),
+    ...readStringArray(options.refs),
+    ...(options.symbol ? [`symbol:${options.symbol}`] : []),
+    ...(options.region ? [`region:${options.region}`] : []),
+    ...(options.nativeNodeId ? [`native:${options.nativeNodeId}`] : []),
+    ...(options.sourcePath ? [`path:${options.sourcePath}`] : [])
+  ]);
+  const selection = selectSemanticSliceRecords(records, {
+    entryRefs,
+    includeDependencies: options.includeDependencies !== false,
+    maxDependencyDepth: Number.isFinite(options.maxDependencyDepth) ? Math.max(0, Math.floor(options.maxDependencyDepth)) : 2
+  });
+  const sourceSpans = semanticSliceSourceSpans(selection);
+  const sourceFiles = semanticSliceSourceFiles(sourceSpans, context, options);
+  const sourceMapLinks = semanticSliceSourceMapLinks(selection);
+  const conflictKeys = uniqueStrings([
+    ...selection.regions.map((region) => region.conflictKey),
+    ...selection.regions.map((region) => region.key ? `region:${region.key}` : region.id ? `region:${region.id}` : undefined),
+    ...selection.symbols.map((symbol) => symbol.metadata?.ownershipRegionKey ? `region:${symbol.metadata.ownershipRegionKey}` : undefined),
+    ...selection.symbols.map((symbol) => symbol.id ? `symbol:${symbol.id}` : undefined),
+    ...sourceFiles.map((file) => file.path ? `source:${file.path}` : undefined)
+  ].filter(Boolean));
+  const unresolvedEntryRefs = entryRefs.filter((entryRef) => !selection.matchedEntryRefs.includes(entryRef));
+  const readiness = semanticSliceReadiness(context, selection, unresolvedEntryRefs);
+  const reasons = semanticSliceReasons(context, selection, unresolvedEntryRefs, readiness);
+  const idPart = idFragment(options.id ?? entryRefs.join('_') ?? context.sourcePath ?? context.language ?? context.importResult?.id ?? context.universalAst?.id ?? 'semantic_slice');
+  const evidence = [{
+    id: options.evidenceId ?? `evidence_${idPart}_semantic_slice`,
+    kind: 'semantic-slice',
+    status: readiness === 'blocked' ? 'failed' : 'passed',
+    path: context.sourcePath,
+    summary: `Created semantic slice with ${selection.symbols.length} symbol(s), ${selection.regions.length} ownership region(s), and ${sourceMapLinks.length} source-map link(s).`,
+    metadata: {
+      entryRefs,
+      unresolvedEntryRefs,
+      importId: context.importResult?.id,
+      universalAstId: context.universalAst?.id,
+      semanticIndexId: context.semanticIndex?.id,
+      sidecarId: sidecar?.id
+    }
+  }];
+  const mergeCandidate = createSemanticMergeCandidateRecord({
+    id: options.mergeCandidateId ?? `merge_candidate_${idPart}_semantic_slice`,
+    importResultId: context.importResult?.id,
+    language: context.language,
+    sourcePath: context.sourcePath,
+    touchedSymbols: selection.symbols.map(semanticSliceTouchedSymbol),
+    touchedSemanticNodes: [],
+    nativeSpans: sourceSpans,
+    conflictKeys,
+    readiness,
+    reasons,
+    evidence,
+    metadata: {
+      kind: 'semantic-slice',
+      sidecarId: sidecar?.id,
+      sourceMapLinks: sourceMapLinks.length,
+      nativeNodeIds: selection.nativeNodes.map((node) => node.id),
+      dependencyRelationIds: selection.relations.map((relation) => relation.id).filter(Boolean),
+      autoMergeClaim: false
+    }
+  });
+  return {
+    kind: 'frontier.lang.semanticSlice',
+    version: 1,
+    id: options.id ?? `semantic_slice_${idPart}`,
+    generatedAt: options.generatedAt ?? Date.now(),
+    language: context.language,
+    sourcePath: context.sourcePath,
+    importId: context.importResult?.id,
+    universalAstId: context.universalAst?.id,
+    semanticIndexId: context.semanticIndex?.id,
+    sidecarId: sidecar?.id,
+    entryRefs,
+    matchedEntryRefs: selection.matchedEntryRefs,
+    unresolvedEntryRefs,
+    symbols: selection.symbols,
+    ownershipRegions: selection.regions,
+    nativeNodes: selection.nativeNodes,
+    relations: selection.relations,
+    occurrences: selection.occurrences,
+    sourceMapLinks,
+    sourceSpans,
+    sourceFiles,
+    losses: selection.losses,
+    evidence,
+    mergeCandidate,
+    verification: {
+      focusedCommands: readStringArray(options.focusedCommands),
+      fixtureHints: readStringArray(options.fixtureHints),
+      expectedAssertions: semanticSliceExpectedAssertions(selection, unresolvedEntryRefs)
+    },
+    summary: {
+      symbols: selection.symbols.length,
+      ownershipRegions: selection.regions.length,
+      nativeNodes: selection.nativeNodes.length,
+      relations: selection.relations.length,
+      occurrences: selection.occurrences.length,
+      sourceMapLinks: sourceMapLinks.length,
+      sourceFiles: sourceFiles.length,
+      losses: selection.losses.length,
+      conflictKeys: conflictKeys.length,
+      readiness,
+      unresolvedEntryRefs: unresolvedEntryRefs.length,
+      sourceTextAvailable: sourceFiles.some((file) => file.excerptCount > 0)
+    },
+    mergeAdmission: {
+      autoMergeClaim: false,
+      reviewRequired: readiness !== 'ready',
+      readiness,
+      reasons,
+      conflictKeys,
+      ownershipKeys: uniqueStrings(selection.regions.map((region) => region.key).filter(Boolean)),
+      sourceHashes: sourceFiles.map((file) => ({ path: file.path, sourceHash: file.sourceHash })).filter((file) => file.path || file.sourceHash),
+      staleCheck: {
+        mode: 'source-hash',
+        requiresCurrentSource: sourceFiles.some((file) => file.sourceHash),
+        sourceFiles: sourceFiles.length
+      }
+    },
+    metadata: {
+      note: 'Semantic slices are focused source-addressable evidence for agent isolation and merge admission; they are not correctness proofs.',
+      ...options.metadata
+    }
+  };
+}

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

@@ -0,0 +1,62 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+import{createNativeImportFromSwiftSyntax}from'./createNativeImportFromSwiftSyntax.js';import{declarationSemanticCoverage}from'./declarationSemanticCoverage.js';import{missingInjectedParserResult}from'./missingInjectedParserResult.js';import{nativeImporterAdapterCoverage}from'./nativeImporterAdapterCoverage.js';import{normalizeParserErrors}from'./normalizeParserErrors.js';import{parseSwiftSyntaxSource}from'./parseSwiftSyntaxSource.js';import{swiftGeneratedSourcePath}from'./swiftGeneratedSourcePath.js';import{swiftSyntaxRoot}from'./swiftSyntaxRoot.js';
+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
+      });
+    }
+  };
+}

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

@@ -0,0 +1,58 @@
+import{idFragment,uniqueStrings}from'../../native-import-utils.js';
+import{createNativeImportFromTreeSitter}from'./createNativeImportFromTreeSitter.js';import{missingInjectedParserResult}from'./missingInjectedParserResult.js';import{nativeImporterAdapterCoverage}from'./nativeImporterAdapterCoverage.js';import{parseTreeSitterSource}from'./parseTreeSitterSource.js';
+export function createTreeSitterNativeImporterAdapter(options = {}) {
+  const parserName = treeSitterParserName(options);
+  return {
+    id: options.id ?? `frontier.tree-sitter-${idFragment(options.language ?? 'source')}-native-importer`,
+    language: options.language ?? 'source',
+    parser: parserName,
+    version: options.version,
+    capabilities: uniqueStrings(['nativeAst', 'nativeSyntaxEvidence', 'semanticIndex', 'sourceMaps', 'diagnostics', ...(options.capabilities ?? [])]),
+    coverage: nativeImporterAdapterCoverage({
+      exactness: 'parser-tree',
+      exactAst: true,
+      tokens: false,
+      trivia: false,
+      diagnostics: true,
+      sourceRanges: true,
+      generatedRanges: false,
+      semanticCoverage: {
+        level: 'native-ast',
+        declarations: false,
+        symbols: false,
+        references: false,
+        types: false,
+        controlFlow: false
+      },
+      notes: [
+        'Normalizes a caller-owned tree-sitter tree into native CST syntax evidence and native AST nodes.',
+        'Observed declaration symbols and source-map mappings are attached when recognizable declarations exist; syntax-only CST evidence is not semantic exactness.',
+        'The built-in wrapper walks concrete children when available; exact token/trivia streams and generated ranges require adapter-specific evidence.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions ?? [],
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const tree = input.options?.tree ?? options.tree ?? parseTreeSitterSource(input, options);
+      const root = tree?.rootNode ?? tree;
+      if (!root) {
+        return missingInjectedParserResult(input, {
+          parser: parserName,
+          adapterId: options.id ?? `frontier.tree-sitter-${idFragment(options.language ?? input.language)}-native-importer`,
+          message: 'createTreeSitterNativeImporterAdapter requires an injected tree-sitter parser/tree or adapterOptions.tree.'
+        });
+      }
+      return createNativeImportFromTreeSitter(root, input, {
+        parser: parserName,
+        astFormat: 'tree-sitter',
+        maxNodes: options.maxNodes
+      });
+    }
+  };
+}
+
+function treeSitterParserName(options) {
+  if (options.parserName) return String(options.parserName);
+  if (typeof options.parser === 'string') return options.parser;
+  return 'tree-sitter';
+}