@shapeshift-labs/frontier-lang-compiler 0.2.105 → 0.2.107

package/README.md

@@ -176,6 +176,17 @@ edit conflicts. Fixture failures include the fixture id and the actual
 reason-code or gate values so distributed swarm evidence can point at a stable
 case instead of an agent transcript.
 
+Successful `safeMergeJsTsImportsAndDeclarations` and `safeMergeJsTsSource`
+results also include `semanticArtifacts`. These artifacts convert the
+JS/TS ledger-approved head-to-merged source edits into a semantic edit script,
+projection, replay, and already-applied replay. This is intentionally different
+from asking the generic three-way edit classifier to bless every JS/TS case:
+simultaneous import specifier additions are safe only because the JS/TS ledger
+gates proved independent additions, stable anchors, and source replay. The
+artifacts keep `autoMergeClaim: false` and `semanticEquivalenceClaim: false`,
+but give coordinators machine-readable proof that the projected source matches
+the merge output and that applying the same projection again is a no-op.
+
 High-risk native features also have explicit evidence policies. These policies are advisory in this package: they tell a swarm or admission queue what evidence is missing without silently changing the existing readiness classification.
 
 ```js

package/dist/declarations/import-adapter-options-native.d.ts

@@ -76,6 +76,9 @@ export interface TypeScriptCompilerNativeImporterAdapterOptions {
   readonly diagnostics?: readonly NativeImporterAdapterDiagnostic[];
   readonly typescript?: unknown;
   readonly ts?: unknown;
+  readonly program?: { readonly getTypeChecker?: () => unknown } | unknown;
+  readonly typeChecker?: unknown;
+  readonly checker?: unknown;
   readonly sourceFile?: unknown;
   readonly createSourceFile?: (input: NativeImporterAdapterParseInput, typescript?: unknown) => unknown;
   readonly scriptTarget?: unknown;

package/dist/declarations/js-ts-safe-merge.d.ts

@@ -1,4 +1,5 @@
 import type { FrontierSourceLanguage } from '@shapeshift-labs/frontier-lang-kernel';
+import type { SemanticEditProjection, SemanticEditReplay, SemanticEditScript } from './semantic-edit-script.js';
 import type {
   JsTsSafeMemberMergePolicy,
   JsTsSafeMemberMergePolicyRegion
@@ -110,6 +111,40 @@ export interface JsTsSafeMergeSummary {
   readonly composedPhases?: number;
 }
 
+export interface JsTsSafeMergeSemanticArtifacts {
+  readonly kind: 'frontier.lang.jsTsSafeMergeSemanticArtifacts';
+  readonly version: 1;
+  readonly schema: 'frontier.lang.jsTsSafeMergeSemanticArtifacts.v1';
+  readonly id: string;
+  readonly hash: string;
+  readonly sourcePath?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly status: 'verified' | 'blocked' | string;
+  readonly script?: SemanticEditScript;
+  readonly projection?: SemanticEditProjection;
+  readonly replay?: SemanticEditReplay;
+  readonly alreadyAppliedReplay?: SemanticEditReplay;
+  readonly admission: {
+    readonly status: 'auto-merge-candidate' | 'blocked' | string;
+    readonly action: 'apply' | 'human-review' | string;
+    readonly reviewRequired: boolean;
+    readonly autoApplyCandidate: boolean;
+    readonly autoMergeClaim: false;
+    readonly semanticEquivalenceClaim: false;
+    readonly reasonCodes: readonly string[];
+  };
+  readonly summary: {
+    readonly operations: number;
+    readonly edits: number;
+    readonly replayStatus?: string;
+    readonly alreadyAppliedReplayStatus?: string;
+    readonly projectedSourceMatchesMerged: boolean;
+    readonly replayOutputMatchesMerged: boolean;
+  };
+  readonly evidence?: readonly unknown[];
+  readonly metadata?: Record<string, unknown>;
+}
+
 export interface JsTsSafeMergeResult {
   readonly kind: 'frontier.lang.jsTsSafeMerge';
   readonly version: 1;
@@ -124,6 +159,7 @@ export interface JsTsSafeMergeResult {
   readonly gates: readonly JsTsSafeMergeGate[];
   readonly admission: JsTsSafeMergeAdmission;
   readonly summary: JsTsSafeMergeSummary;
+  readonly semanticArtifacts?: JsTsSafeMergeSemanticArtifacts;
   readonly metadata?: Record<string, unknown>;
 }
 

package/dist/declarations/native-project.d.ts

@@ -77,6 +77,114 @@ export interface ImportNativeProjectOptions {
   readonly sources: readonly NativeProjectSourceInput[];
 }
 
+export type NativeProjectSymbolGraphRemainingField =
+  | 'moduleEdges[].resolvedModulePath'
+  | 'moduleEdges[].targetDocumentId'
+  | 'moduleEdges[].resolvedTargetSymbolId'
+  | 'moduleEdges[].resolutionKind'
+  | 'moduleEdges[].packageName'
+  | 'moduleEdges[].packageExportCondition'
+  | 'reExportIdentities[].originSymbolId'
+  | 'reExportIdentities[].exportedSymbolId'
+  | 'reExportIdentities[].localSymbolId'
+  | 'publicContractRegions[].apiSurfaceKind'
+  | 'publicContractRegions[].signatureHash'
+  | 'publicContractRegions[].contractHash'
+  | string;
+
+export interface NativeProjectSymbolGraphFileHashRecord {
+  readonly id: string;
+  readonly documentId: string;
+  readonly sourcePath?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourceHash: string;
+  readonly algorithm?: string;
+  readonly value: string;
+  readonly factId?: string;
+}
+
+export interface NativeProjectSymbolGraphModuleEdgeRecord {
+  readonly id: string;
+  readonly sourceDocumentId: string;
+  readonly targetSymbolId: string;
+  readonly predicate: 'imports' | 'exports' | string;
+  readonly edgeKind?: 'import' | 'export' | 're-export' | string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly moduleSpecifier?: string;
+  readonly importKind?: string;
+  readonly exportKind?: string;
+  readonly importedName?: string;
+  readonly exportedName?: string;
+  readonly localName?: string;
+  readonly namespace?: string;
+  readonly isTypeOnly?: boolean;
+  readonly isReExport?: boolean;
+  readonly publicContract?: boolean;
+  readonly evidenceIds?: readonly string[];
+}
+
+export interface NativeProjectSymbolGraphReExportIdentityRecord {
+  readonly kind?: 'frontier.lang.reExportIdentity' | string;
+  readonly version?: 1;
+  readonly id: string;
+  readonly sourceDocumentId?: string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly moduleSpecifier?: string;
+  readonly exportedName?: string;
+  readonly importedName?: string;
+  readonly localName?: string;
+  readonly namespace?: string;
+  readonly isTypeOnly?: boolean;
+  readonly symbolId?: string;
+  readonly relationId?: string;
+  readonly ownershipRegionId?: string;
+  readonly ownershipRegionKey?: string;
+  readonly publicContract?: boolean;
+  readonly factId?: string;
+}
+
+export interface NativeProjectSymbolGraphPublicContractRegionRecord {
+  readonly id: string;
+  readonly key?: string;
+  readonly regionKind?: string;
+  readonly granularity?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly documentId?: string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly symbolId?: string;
+  readonly symbolName?: string;
+  readonly symbolKind?: string;
+  readonly nativeAstNodeId?: string;
+  readonly sourceSpan?: SourceSpan;
+  readonly precision?: string;
+  readonly publicContract?: boolean;
+  readonly exportedName?: string;
+  readonly moduleSpecifier?: string;
+  readonly edgeKind?: string;
+  readonly factId?: string;
+}
+
+export interface NativeProjectSymbolGraphSummary {
+  readonly kind: 'frontier.lang.projectSymbolGraph';
+  readonly version: 1;
+  readonly projectRoot?: string;
+  readonly sourceCount: number;
+  readonly documentCount: number;
+  readonly symbolCount: number;
+  readonly occurrenceCount: number;
+  readonly relationCount: number;
+  readonly factCount: number;
+  readonly fileHashes: readonly NativeProjectSymbolGraphFileHashRecord[];
+  readonly importEdges: readonly NativeProjectSymbolGraphModuleEdgeRecord[];
+  readonly exportEdges: readonly NativeProjectSymbolGraphModuleEdgeRecord[];
+  readonly reExportIdentities: readonly NativeProjectSymbolGraphReExportIdentityRecord[];
+  readonly publicContractRegions: readonly NativeProjectSymbolGraphPublicContractRegionRecord[];
+  readonly remainingFields: readonly NativeProjectSymbolGraphRemainingField[];
+}
+
 export interface NativeProjectImportResultMetadata extends Record<string, unknown> {
   readonly importResultContract?: NativeImportResultContract;
   readonly projectAdmission?: NativeProjectImportAdmission;
@@ -84,6 +192,7 @@ export interface NativeProjectImportResultMetadata extends Record<string, unknow
   readonly nativeImportLossSummary?: NativeImportLossSummary;
   readonly semanticMergeReadiness?: SemanticMergeReadiness;
   readonly readinessReasons?: readonly string[];
+  readonly projectSymbolGraph?: NativeProjectSymbolGraphSummary;
 }
 
 export interface NativeProjectImportResult {
@@ -102,6 +211,7 @@ export interface NativeProjectImportResult {
   readonly losses: readonly NativeAstLossRecord[];
   readonly evidence: readonly EvidenceRecord[];
   readonly mergeCandidates: readonly SemanticMergeCandidateRecord[];
+  readonly projectSymbolGraph?: NativeProjectSymbolGraphSummary;
   readonly metadata?: NativeProjectImportResultMetadata;
 }
 

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

@@ -4,7 +4,15 @@ export function createNativeProjectImportResult(input, imports) {
   const idPart = idFragment(input.id ?? input.projectRoot ?? 'native_project');
   const nodes = {};
   const rootIds = [];
-  const semanticIndex = mergeSemanticIndexes(imports, input, idPart);
+  const mergedSemanticIndex = mergeSemanticIndexes(imports, input, idPart);
+  const projectSymbolGraph = createProjectSymbolGraphSummary(mergedSemanticIndex, imports, input);
+  const semanticIndex = mergedSemanticIndex ? {
+    ...mergedSemanticIndex,
+    metadata: {
+      ...mergedSemanticIndex.metadata,
+      projectSymbolGraph
+    }
+  } : mergedSemanticIndex;
   const nativeSources = [];
   const sourceMaps = [];
   const losses = [];
@@ -43,6 +51,7 @@ export function createNativeProjectImportResult(input, imports) {
       sourceCount: imports.length,
       nativeImportLossSummary,
       sourcePreservationSummary,
+      projectSymbolGraph,
       ...input.documentMetadata
     }
   });
@@ -60,6 +69,7 @@ export function createNativeProjectImportResult(input, imports) {
       sourceCount: imports.length,
       nativeImportLossSummary,
       sourcePreservationSummary,
+      projectSymbolGraph,
       ...input.universalAstMetadata
     }
   });
@@ -75,7 +85,8 @@ export function createNativeProjectImportResult(input, imports) {
       sourceMapIds: sourceMaps.map((sourceMap) => sourceMap.id),
       sourceCount: imports.length,
       nativeImportLossSummary,
-      sourcePreservationSummary
+      sourcePreservationSummary,
+      projectSymbolGraph
     }
   });
   const projectResult = {
@@ -94,11 +105,13 @@ export function createNativeProjectImportResult(input, imports) {
     losses: uniqueLosses,
     evidence: uniqueEvidence,
     mergeCandidates,
+    projectSymbolGraph,
     metadata: {
       sourceCount: imports.length,
       sourcePaths: imports.map((result) => result.sourcePath).filter(Boolean),
       nativeImportLossSummary,
       sourcePreservationSummary,
+      projectSymbolGraph,
       ...input.metadata
     }
   };
@@ -120,7 +133,168 @@ export function createNativeProjectImportResult(input, imports) {
       readinessReasons: importResultContract.readiness.reasons,
       regionSummary: importResultContract.regions,
       sourceMapSummary: importResultContract.sourceMaps,
-      adapterCoverageSummary: importResultContract.adapterCoverage
+      adapterCoverageSummary: importResultContract.adapterCoverage,
+      projectSymbolGraph
     }
   };
 }
+
+const PROJECT_SYMBOL_GRAPH_REMAINING_FIELDS = Object.freeze([
+  'moduleEdges[].resolvedModulePath',
+  'moduleEdges[].targetDocumentId',
+  'moduleEdges[].resolvedTargetSymbolId',
+  'moduleEdges[].resolutionKind',
+  'moduleEdges[].packageName',
+  'moduleEdges[].packageExportCondition',
+  'reExportIdentities[].originSymbolId',
+  'reExportIdentities[].exportedSymbolId',
+  'reExportIdentities[].localSymbolId',
+  'publicContractRegions[].apiSurfaceKind',
+  'publicContractRegions[].signatureHash',
+  'publicContractRegions[].contractHash'
+]);
+
+function createProjectSymbolGraphSummary(semanticIndex, imports, input) {
+  const documents = semanticIndex?.documents ?? [];
+  const symbolsById = new Map((semanticIndex?.symbols ?? []).map((symbol) => [symbol.id, symbol]));
+  const documentsById = new Map(documents.map((document) => [document.id, document]));
+  const facts = semanticIndex?.facts ?? [];
+  const moduleEdgeFacts = facts.filter((fact) => fact.predicate === 'moduleEdge');
+  const moduleEdgeByRelation = new Map(moduleEdgeFacts.map((fact) => [fact.subjectId, fact]));
+  const relations = semanticIndex?.relations ?? [];
+  const importEdges = relations
+    .filter((relation) => relation.predicate === 'imports')
+    .map((relation) => moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documentsById));
+  const exportEdges = relations
+    .filter((relation) => relation.predicate === 'exports')
+    .map((relation) => moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documentsById));
+  const reExportIdentities = uniqueRecords([
+    ...facts
+      .filter((fact) => fact.predicate === 'reExportIdentity' && fact.value)
+      .map((fact) => ({ ...objectValue(fact.value), factId: fact.id })),
+    ...exportEdges
+      .filter((edge) => edge.isReExport)
+      .map((edge) => compactRecord({
+        id: `reexport_${idFragment(edge.id)}`,
+        sourceDocumentId: edge.sourceDocumentId,
+        sourcePath: edge.sourcePath,
+        sourceHash: edge.sourceHash,
+        moduleSpecifier: edge.moduleSpecifier,
+        symbolId: edge.targetSymbolId,
+        relationId: edge.id,
+        publicContract: edge.publicContract
+      }))
+  ]);
+  const publicContractRegions = uniqueRecords(facts
+    .filter((fact) => fact.predicate === 'publicContractRegion' && fact.value)
+    .map((fact) => ({ ...objectValue(fact.value), factId: fact.id, symbolId: fact.subjectId })));
+  const fileHashes = uniqueRecords([
+    ...documents.map((document) => fileHashRecord(document)),
+    ...facts
+      .filter((fact) => fact.predicate === 'fileHash' && fact.value)
+      .map((fact) => ({ ...objectValue(fact.value), id: `file_hash_${idFragment(fact.subjectId)}`, factId: fact.id, documentId: fact.subjectId }))
+  ].filter(Boolean));
+  return {
+    kind: 'frontier.lang.projectSymbolGraph',
+    version: 1,
+    projectRoot: input.projectRoot,
+    sourceCount: imports.length,
+    documentCount: documents.length,
+    symbolCount: semanticIndex?.symbols?.length ?? 0,
+    occurrenceCount: semanticIndex?.occurrences?.length ?? 0,
+    relationCount: relations.length,
+    factCount: facts.length,
+    fileHashes,
+    importEdges,
+    exportEdges,
+    reExportIdentities,
+    publicContractRegions,
+    remainingFields: PROJECT_SYMBOL_GRAPH_REMAINING_FIELDS
+  };
+}
+
+function moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documentsById) {
+  const fact = moduleEdgeByRelation.get(relation.id);
+  const value = objectValue(fact?.value);
+  const metadata = objectValue(relation.metadata);
+  const moduleEdge = objectValue(metadata.moduleEdge);
+  const symbol = symbolsById.get(relation.targetId);
+  const symbolMetadata = objectValue(symbol?.metadata);
+  const document = documentsById.get(relation.sourceId);
+  const moduleSpecifier = firstString(
+    moduleEdge.moduleSpecifier,
+    value.moduleSpecifier,
+    metadata.moduleSpecifier,
+    symbolMetadata.moduleSpecifier,
+    symbol?.kind === 'module' ? symbol.name : undefined
+  );
+  return compactRecord({
+    id: relation.id,
+    sourceDocumentId: relation.sourceId,
+    targetSymbolId: relation.targetId,
+    predicate: relation.predicate,
+    edgeKind: firstString(moduleEdge.edgeKind, value.edgeKind, relation.predicate === 'imports' ? 'import' : moduleSpecifier ? 're-export' : 'export'),
+    sourcePath: document?.path,
+    sourceHash: document?.sourceHash,
+    moduleSpecifier,
+    importKind: firstString(moduleEdge.importKind, value.importKind),
+    exportKind: firstString(moduleEdge.exportKind, value.exportKind),
+    importedName: firstString(moduleEdge.importedName, value.importedName),
+    exportedName: firstString(moduleEdge.exportedName, value.exportedName),
+    localName: firstString(moduleEdge.localName, value.localName),
+    namespace: firstString(moduleEdge.namespace, value.namespace),
+    isTypeOnly: firstBoolean(moduleEdge.isTypeOnly, value.isTypeOnly),
+    isReExport: firstBoolean(moduleEdge.isReExport, value.isReExport) ?? (relation.predicate === 'exports' && Boolean(moduleSpecifier)),
+    publicContract: firstBoolean(moduleEdge.publicContract, value.publicContract, metadata.publicContract),
+    evidenceIds: uniqueStrings([...(relation.evidenceIds ?? []), ...(fact?.evidenceIds ?? [])])
+  });
+}
+
+function fileHashRecord(document) {
+  if (!document?.sourceHash) return undefined;
+  const sourceHash = String(document.sourceHash);
+  const separator = sourceHash.indexOf(':');
+  return compactRecord({
+    id: `file_hash_${idFragment(document.id)}`,
+    documentId: document.id,
+    sourcePath: document.path,
+    language: document.language,
+    sourceHash,
+    algorithm: separator > 0 ? sourceHash.slice(0, separator) : undefined,
+    value: separator > 0 ? sourceHash.slice(separator + 1) : sourceHash
+  });
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+
+function uniqueRecords(records) {
+  const seen = new Set();
+  const result = [];
+  for (const record of records) {
+    const key = record.id ?? record.factId ?? JSON.stringify(record);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(record);
+  }
+  return result;
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (value !== undefined && value !== null && String(value)) return String(value);
+  }
+  return undefined;
+}
+
+function firstBoolean(...values) {
+  for (const value of values) {
+    if (typeof value === 'boolean') return value;
+  }
+  return undefined;
+}

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

@@ -25,6 +25,8 @@ export function createTypeScriptCompilerNativeImporterAdapter(options = {}) {
     diagnostics: options.diagnostics,
     parse(input) {
       const ts = options.typescript ?? options.ts ?? input.options?.typescript ?? input.options?.ts;
+      const program = options.program ?? input.options?.program;
+      const typeChecker = options.typeChecker ?? options.checker ?? input.options?.typeChecker ?? input.options?.checker ?? program?.getTypeChecker?.();
       const sourceFile = input.options?.sourceFile ?? input.options?.ast ?? options.sourceFile ?? createTypeScriptSourceFile(ts, input, options);
       if (!sourceFile) {
         return missingInjectedParserResult(input, {
@@ -37,6 +39,8 @@ export function createTypeScriptCompilerNativeImporterAdapter(options = {}) {
         parser: options.parser ?? 'typescript-compiler-api',
         astFormat: 'typescript-compiler-api',
         ts,
+        program,
+        typeChecker,
         maxNodes: options.maxNodes,
         includeTokens: options.includeTokens
       });

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

@@ -207,7 +207,7 @@ function currentSymbolRangeLabel(edit) {
 }
 
 function replayStatus(reasonCodes, edits, projection) {
-  if (reasonCodes.some((reason) => reason !== 'current-source-hash-mismatch')) return 'blocked';
+  if (reasonCodes.length) return 'blocked';
   if (!edits.length && !(projection.edits ?? []).length) return 'evidence-only';
   if (edits.some((edit) => edit.status === 'blocked')) return 'blocked';
   if (edits.some((edit) => edit.status === 'conflict')) return 'conflict';