@shapeshift-labs/frontier-lang-compiler 0.2.113 → 0.2.115

package/README.md

@@ -238,6 +238,13 @@ console.log(project.outputProjectSymbolGraph.importEdges[0].packageName); // "@p
 console.log(project.outputProjectSymbolGraph.importEdges[0].packageExportCondition); // "import"
 ```
 
+Named re-export identities also include symbol links when the project graph has
+enough evidence. For `export { thing as renamedThing } from './thing.js'`,
+`reExportIdentities[]` records the source module, imported/exported names,
+`originSymbolId`, `exportedSymbolId`, and `localSymbolId`.
+Public contract regions include `apiSurfaceKind`, `signatureHash`, and
+`contractHash`, giving merge admission a stable API surface fingerprint.
+
 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/native-project.d.ts

@@ -82,9 +82,6 @@ export type NativeProjectSymbolGraphRemainingField =
   | 'reExportIdentities[].originSymbolId'
   | 'reExportIdentities[].exportedSymbolId'
   | 'reExportIdentities[].localSymbolId'
-  | 'publicContractRegions[].apiSurfaceKind'
-  | 'publicContractRegions[].signatureHash'
-  | 'publicContractRegions[].contractHash'
   | string;
 
 export interface NativeProjectSymbolGraphFileHashRecord {
@@ -138,10 +135,10 @@ export interface NativeProjectSymbolGraphReExportIdentityRecord {
   readonly localName?: string;
   readonly namespace?: string;
   readonly isTypeOnly?: boolean;
-  readonly symbolId?: string;
+  readonly symbolId?: string; readonly originSymbolId?: string;
+  readonly exportedSymbolId?: string; readonly localSymbolId?: string;
   readonly relationId?: string;
-  readonly ownershipRegionId?: string;
-  readonly ownershipRegionKey?: string;
+  readonly ownershipRegionId?: string; readonly ownershipRegionKey?: string;
   readonly publicContract?: boolean;
   readonly factId?: string;
 }
@@ -158,6 +155,9 @@ export interface NativeProjectSymbolGraphPublicContractRegionRecord {
   readonly symbolId?: string;
   readonly symbolName?: string;
   readonly symbolKind?: string;
+  readonly apiSurfaceKind?: string;
+  readonly signatureHash?: string;
+  readonly contractHash?: string;
   readonly nativeAstNodeId?: string;
   readonly sourceSpan?: SourceSpan;
   readonly precision?: string;

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

@@ -1,6 +1,8 @@
 import{idFragment,uniqueByEvidenceId,uniqueByLossId,uniqueStrings}from'../../native-import-utils.js';import{createDocument,createPatch,createUniversalAstEnvelope}from'@shapeshift-labs/frontier-lang-kernel';
 import{createNativeImportResultContract}from'./createNativeImportResultContract.js';import{createProjectImportAdmissionRecord}from'./createProjectImportAdmissionRecord.js';import{mergeSemanticIndexes}from'./mergeSemanticIndexes.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';import{summarizeProjectSourcePreservation}from'./summarizeProjectSourcePreservation.js';
-import{createProjectModuleSymbolResolver,resolveProjectModule}from'./projectSymbolGraphModuleResolution.js';
+import{createProjectDocumentExportSymbolResolver,createProjectModuleSymbolResolver,resolveProjectModule}from'./projectSymbolGraphModuleResolution.js';
+import{publicContractRegionRecord}from'./projectSymbolGraphPublicContracts.js';
+import{isReExportImportEdge,reExportIdentityInputFromEdge,reExportIdentityRecord}from'./projectSymbolGraphReExports.js';
 export function createNativeProjectImportResult(input, imports) {
   const idPart = idFragment(input.id ?? input.projectRoot ?? 'native_project');
   const nodes = {};
@@ -143,10 +145,7 @@ export function createNativeProjectImportResult(input, imports) {
 const PROJECT_SYMBOL_GRAPH_REMAINING_FIELDS = Object.freeze([
   'reExportIdentities[].originSymbolId',
   'reExportIdentities[].exportedSymbolId',
-  'reExportIdentities[].localSymbolId',
-  'publicContractRegions[].apiSurfaceKind',
-  'publicContractRegions[].signatureHash',
-  'publicContractRegions[].contractHash'
+  'reExportIdentities[].localSymbolId'
 ]);
 
 function createProjectSymbolGraphSummary(semanticIndex, imports, input) {
@@ -156,6 +155,7 @@ function createProjectSymbolGraphSummary(semanticIndex, imports, input) {
   const documentsByPath = new Map(documents.filter((document) => document.path).map((document) => [document.path, document]));
   const moduleResolution = input.moduleResolution ?? input.tsconfig;
   const resolveTargetSymbolId = createProjectModuleSymbolResolver(semanticIndex?.symbols ?? [], documents);
+  const resolveDocumentExportSymbolId = createProjectDocumentExportSymbolResolver(semanticIndex?.symbols ?? [], documents);
   const facts = semanticIndex?.facts ?? [];
   const moduleEdgeFacts = facts.filter((fact) => fact.predicate === 'moduleEdge');
   const moduleEdgeByRelation = new Map(moduleEdgeFacts.map((fact) => [fact.subjectId, fact]));
@@ -166,26 +166,21 @@ function createProjectSymbolGraphSummary(semanticIndex, imports, input) {
   const exportEdges = relations
     .filter((relation) => relation.predicate === 'exports')
     .map((relation) => moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documentsById, documentsByPath, moduleResolution, resolveTargetSymbolId));
+  const moduleEdgeById = new Map([...importEdges, ...exportEdges].map((edge) => [edge.id, edge]));
   const reExportIdentities = uniqueRecords([
     ...facts
       .filter((fact) => fact.predicate === 'reExportIdentity' && fact.value)
-      .map((fact) => ({ ...objectValue(fact.value), factId: fact.id })),
+      .map((fact) => reExportIdentityRecord(objectValue(fact.value), moduleEdgeById.get(objectValue(fact.value).relationId ?? fact.objectId), resolveDocumentExportSymbolId, { 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
-      }))
+      .map((edge) => reExportIdentityRecord(reExportIdentityInputFromEdge(edge, `reexport_${idFragment(edge.id)}`), edge, resolveDocumentExportSymbolId)),
+    ...importEdges
+      .filter((edge) => isReExportImportEdge(edge))
+      .map((edge) => reExportIdentityRecord(reExportIdentityInputFromEdge(edge, `reexport_${idFragment(edge.id)}`), edge, resolveDocumentExportSymbolId))
   ]);
   const publicContractRegions = uniqueRecords(facts
     .filter((fact) => fact.predicate === 'publicContractRegion' && fact.value)
-    .map((fact) => ({ ...objectValue(fact.value), factId: fact.id, symbolId: fact.subjectId })));
+    .map((fact) => publicContractRegionRecord(objectValue(fact.value), fact, symbolsById.get(fact.subjectId))));
   const fileHashes = uniqueRecords([
     ...documents.map((document) => fileHashRecord(document)),
     ...facts

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

@@ -17,14 +17,7 @@ export function resolveProjectModule(sourcePath, moduleSpecifier, documentsByPat
 }
 
 export function createProjectModuleSymbolResolver(symbols, documents) {
-  const documentsByPath = new Map(documents.filter((document) => document.path).map((document) => [document.path, document]));
-  const exportedByDocumentAndName = new Map();
-  for (const symbol of symbols ?? []) {
-    if (symbol?.kind !== 'export' || !symbol.name) continue;
-    const document = documentsByPath.get(symbol.definitionSpan?.path);
-    if (!document) continue;
-    exportedByDocumentAndName.set(symbolKey(document.id, symbol.name), symbol);
-  }
+  const exportedByDocumentAndName = projectExportSymbolMap(symbols, documents);
   return function resolveProjectModuleSymbol(edge) {
     if (!edge?.targetDocumentId) return undefined;
     const targetName = targetExportName(edge);
@@ -33,6 +26,25 @@ export function createProjectModuleSymbolResolver(symbols, documents) {
   };
 }
 
+export function createProjectDocumentExportSymbolResolver(symbols, documents) {
+  const exportedByDocumentAndName = projectExportSymbolMap(symbols, documents);
+  return function resolveDocumentExportSymbol(documentId, name) {
+    if (!documentId || !name) return undefined;
+    return exportedByDocumentAndName.get(symbolKey(documentId, name))?.id;
+  };
+}
+
+function projectExportSymbolMap(symbols, documents) {
+  const documentsByPath = new Map(documents.filter((document) => document.path).map((document) => [document.path, document]));
+  const exportedByDocumentAndName = new Map();
+  for (const symbol of symbols ?? []) {
+    if (symbol?.kind !== 'export' || !symbol.name) continue;
+    const document = documentsByPath.get(symbol.definitionSpan?.path);
+    if (document) exportedByDocumentAndName.set(symbolKey(document.id, symbol.name), symbol);
+  }
+  return exportedByDocumentAndName;
+}
+
 function resolveConfiguredProjectModule(moduleSpecifier, documentsByPath, moduleResolution) {
   const packageInfo = packageSpecifierInfo(moduleSpecifier);
   const candidates = configuredModuleCandidates(moduleSpecifier, moduleResolution, packageInfo);

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

@@ -0,0 +1,41 @@
+import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+
+export function publicContractRegionRecord(value, fact, symbol) {
+  const record = {
+    ...value,
+    factId: fact.id,
+    symbolId: fact.subjectId,
+    apiSurfaceKind: value.apiSurfaceKind ?? apiSurfaceKind(value, symbol),
+    signatureHash: value.signatureHash ?? symbol?.signatureHash
+  };
+  return compactRecord({
+    ...record,
+    contractHash: value.contractHash ?? publicContractHash(record)
+  });
+}
+
+function apiSurfaceKind(region, symbol) {
+  if (region.edgeKind === 're-export') return 'module-re-export';
+  if (region.edgeKind === 'export') return 'module-export';
+  if (symbol?.kind === 'export') return 'named-export';
+  return region.symbolKind ?? symbol?.kind ?? region.regionKind;
+}
+
+function publicContractHash(region) {
+  return hashSemanticValue({
+    kind: 'frontier.lang.publicContractRegionHash',
+    sourceHash: region.sourceHash,
+    symbolId: region.symbolId,
+    symbolName: region.symbolName,
+    symbolKind: region.symbolKind,
+    signatureHash: region.signatureHash,
+    moduleSpecifier: region.moduleSpecifier,
+    exportedName: region.exportedName,
+    edgeKind: region.edgeKind,
+    apiSurfaceKind: region.apiSurfaceKind
+  });
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}

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

@@ -0,0 +1,43 @@
+export function reExportIdentityRecord(identity, edge, resolveDocumentExportSymbolId, extra = {}) {
+  const exportedName = firstString(identity.exportedName, edge?.exportedName, edge?.importedName === '*' ? undefined : (edge?.exportedName ?? edge?.importedName));
+  const importedName = firstString(identity.importedName, edge?.importedName);
+  const localName = firstString(identity.localName, edge?.localName, exportedName);
+  return compactRecord({
+    ...identity,
+    exportedName,
+    importedName,
+    localName,
+    originSymbolId: firstString(identity.originSymbolId, edge?.resolvedTargetSymbolId),
+    exportedSymbolId: firstString(identity.exportedSymbolId, resolveDocumentExportSymbolId(edge?.sourceDocumentId, exportedName), edge?.predicate === 'exports' ? edge?.targetSymbolId : undefined),
+    localSymbolId: firstString(identity.localSymbolId, edge?.targetSymbolId),
+    ...extra
+  });
+}
+
+export function isReExportImportEdge(edge) {
+  return edge.importKind === 'reexport' || edge.importKind === 'namespace-reexport';
+}
+
+export function reExportIdentityInputFromEdge(edge, id) {
+  return compactRecord({
+    id,
+    sourceDocumentId: edge.sourceDocumentId,
+    sourcePath: edge.sourcePath,
+    sourceHash: edge.sourceHash,
+    moduleSpecifier: edge.moduleSpecifier,
+    symbolId: edge.targetSymbolId,
+    relationId: edge.id,
+    publicContract: edge.publicContract
+  });
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (value !== undefined && value !== null && String(value)) return String(value);
+  }
+  return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.113",
+  "version": "0.2.115",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",