@shapeshift-labs/frontier-lang-compiler 0.2.104 → 0.2.106

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

@@ -6,24 +6,39 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
   const symbols = [];
   const occurrences = [];
   const relations = [];
-  const facts = [];
+  const facts = input.sourceHash ? [fileHashFact(documentId, input, evidenceId)] : [];
   const mappings = [];
   for (const declaration of declarations) {
     const symbolId = declaration.symbolId ?? `symbol:${input.language}:${declaration.role === 'import' ? 'import:' : ''}${caseSensitiveIdFragment(declaration.name)}`;
+    const normalizedDeclaration = {
+      ...declaration,
+      symbolId,
+      regionKind: declarationRegionKind(declaration)
+    };
     const occurrenceId = `occ_${idFragment(declaration.nativeNode.id)}_${declaration.role ?? 'definition'}`;
     const ownershipRegion = semanticOwnershipRegionForDeclaration(input, {
-      ...declaration,
+      ...normalizedDeclaration,
       nodeId: declaration.nativeNode.id,
       kind: declaration.nativeNode.kind,
       languageKind: declaration.nativeNode.languageKind,
       span: declaration.nativeNode.span,
       symbolId
     }, documentId);
+    const relationId = `rel_${idFragment(documentId)}_${idFragment(declaration.nativeNode.id)}`;
+    const moduleEdge = moduleEdgeForDeclaration(normalizedDeclaration, input, documentId, relationId, ownershipRegion);
+    const publicContractRegion = publicContractRegionForDeclaration(normalizedDeclaration, ownershipRegion, moduleEdge);
+    const reExportIdentity = reExportIdentityForDeclaration(normalizedDeclaration, input, documentId, relationId, ownershipRegion, moduleEdge);
+    const graphMetadata = {
+      ...(moduleEdge ? { moduleEdge } : {}),
+      ...(publicContractRegion ? { publicContract: true, publicContractRegionId: publicContractRegion.id } : {}),
+      ...(reExportIdentity ? { reExportIdentity } : {})
+    };
     declaration.nativeNode.metadata = {
       ...declaration.nativeNode.metadata,
       ownershipRegionId: ownershipRegion.id,
       ownershipRegionKey: ownershipRegion.key,
-      ownershipRegionKind: ownershipRegion.regionKind
+      ownershipRegionKind: ownershipRegion.regionKind,
+      ...graphMetadata
     };
     symbols.push({
       id: symbolId,
@@ -38,7 +53,8 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
         ...declaration.nativeNode.metadata,
         ownershipRegionId: ownershipRegion.id,
         ownershipRegionKey: ownershipRegion.key,
-        ownershipRegionKind: ownershipRegion.regionKind
+        ownershipRegionKind: ownershipRegion.regionKind,
+        ...graphMetadata
       }
     });
     occurrences.push({
@@ -47,13 +63,16 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
       symbolId,
       role: declaration.role ?? 'definition',
       span: declaration.nativeNode.span,
-      nativeAstNodeId: declaration.nativeNode.id
+      nativeAstNodeId: declaration.nativeNode.id,
+      ...(Object.keys(graphMetadata).length ? { metadata: graphMetadata } : {})
     });
     relations.push({
-      id: `rel_${idFragment(documentId)}_${idFragment(declaration.nativeNode.id)}`,
+      id: relationId,
       sourceId: documentId,
       predicate: relationPredicateForDeclaration(declaration),
-      targetId: symbolId
+      targetId: symbolId,
+      evidenceIds: [evidenceId],
+      ...(Object.keys(graphMetadata).length ? { metadata: graphMetadata } : {})
     });
     facts.push({
       id: `fact_${idFragment(declaration.nativeNode.id)}_kind`,
@@ -74,7 +93,7 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
         granularity: ownershipRegion.granularity,
         key: ownershipRegion.key
       }
-    });
+    }, ...projectSymbolGraphFacts({ moduleEdge, publicContractRegion, reExportIdentity, relationId, symbolId, evidenceId }));
     mappings.push({
       id: `map_${idFragment(declaration.nativeNode.id)}`,
       nativeAstNodeId: declaration.nativeNode.id,
@@ -95,12 +114,18 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
     status: 'passed',
     path: input.sourcePath,
     summary: `Normalized ${options.astFormat ?? options.parser} native AST with ${declarations.length} declaration(s).`,
-    metadata: {
-      parser: options.parser,
-      astFormat: options.astFormat,
-      language: input.language,
-      sourceHash: input.sourceHash
-    }
+      metadata: {
+        parser: options.parser,
+        astFormat: options.astFormat,
+        language: input.language,
+        sourceHash: input.sourceHash,
+        graphRecords: {
+          fileHashes: input.sourceHash ? 1 : 0,
+          moduleEdges: facts.filter((fact) => fact.predicate === 'moduleEdge').length,
+          reExportIdentities: facts.filter((fact) => fact.predicate === 'reExportIdentity').length,
+          publicContractRegions: facts.filter((fact) => fact.predicate === 'publicContractRegion').length
+        }
+      }
   }];
   return {
     semanticIndex: createSemanticIndexRecord({
@@ -119,10 +144,170 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
       metadata: {
         parser: options.parser,
         astFormat: options.astFormat,
-        coverage: 'native-ast-declarations'
+        coverage: 'native-ast-declarations',
+        graphCoverage: 'module-edge-declarations'
       }
     }),
     mappings,
     evidence
   };
 }
+
+function fileHashFact(documentId, input, evidenceId) {
+  return {
+    id: `fact_${idFragment(documentId)}_file_hash`,
+    predicate: 'fileHash',
+    subjectId: documentId,
+    value: { ...hashParts(input.sourceHash), sourcePath: input.sourcePath, language: input.language },
+    evidenceIds: [evidenceId]
+  };
+}
+
+function declarationRegionKind(declaration) {
+  if (declaration.regionKind) return declaration.regionKind;
+  if (declaration.role === 'import' || declaration.importPath) return 'import';
+  if (declaration.role === 'export' || declaration.exported || declaration.reExport) return 'export';
+  if (declaration.publicContract || declaration.metadata?.publicContract) return 'export';
+  return undefined;
+}
+
+function moduleEdgeForDeclaration(declaration, input, documentId, relationId, ownershipRegion) {
+  const role = declaration.role;
+  if (role !== 'import' && role !== 'export') return undefined;
+  const moduleSpecifier = moduleSpecifierForDeclaration(declaration);
+  const edgeKind = role === 'import' ? 'import' : moduleSpecifier || declaration.reExport ? 're-export' : 'export';
+  return compactRecord({
+    kind: 'frontier.lang.moduleEdge',
+    version: 1,
+    id: relationId,
+    edgeKind,
+    role,
+    sourceDocumentId: documentId,
+    sourcePath: input.sourcePath,
+    sourceHash: input.sourceHash,
+    moduleSpecifier,
+    symbolId: declaration.symbolId,
+    relationId,
+    ownershipRegionId: ownershipRegion.id,
+    ownershipRegionKey: ownershipRegion.key,
+    importKind: declaration.importKind ?? declaration.metadata?.importKind,
+    exportKind: declaration.exportKind ?? declaration.metadata?.exportKind,
+    importedName: declaration.importedName ?? declaration.metadata?.importedName,
+    exportedName: declaration.exportedName ?? declaration.metadata?.exportedName,
+    localName: declaration.localName ?? declaration.metadata?.localName,
+    namespace: declaration.namespace ?? declaration.metadata?.namespace,
+    isTypeOnly: declaration.isTypeOnly ?? declaration.metadata?.isTypeOnly,
+    isReExport: edgeKind === 're-export',
+    publicContract: publicContractForDeclaration(declaration, edgeKind)
+  });
+}
+
+function moduleSpecifierForDeclaration(declaration) {
+  return firstString(
+    declaration.moduleSpecifier,
+    declaration.importPath,
+    declaration.exportPath,
+    declaration.source,
+    declaration.metadata?.moduleSpecifier,
+    declaration.metadata?.importPath,
+    declaration.metadata?.exportPath,
+    declaration.metadata?.source,
+    declaration.symbolKind === 'module' ? declaration.name : undefined
+  );
+}
+
+function publicContractForDeclaration(declaration, edgeKind) {
+  return Boolean(
+    declaration.publicContract
+    || declaration.exported
+    || declaration.metadata?.publicContract
+    || declaration.metadata?.publicContractRegion
+    || declaration.role === 'export'
+    || edgeKind === 'export'
+    || edgeKind === 're-export'
+  );
+}
+
+function publicContractRegionForDeclaration(declaration, ownershipRegion, moduleEdge) {
+  if (!publicContractForDeclaration(declaration, moduleEdge?.edgeKind)) return undefined;
+  return {
+    ...ownershipRegion,
+    regionKind: declaration.publicContractRegionKind ?? declaration.metadata?.publicContractRegionKind ?? ownershipRegion.regionKind,
+    publicContract: true,
+    exportedName: declaration.exportedName ?? declaration.metadata?.exportedName,
+    moduleSpecifier: moduleEdge?.moduleSpecifier,
+    edgeKind: moduleEdge?.edgeKind
+  };
+}
+
+function reExportIdentityForDeclaration(declaration, input, documentId, relationId, ownershipRegion, moduleEdge) {
+  if (!moduleEdge?.isReExport && !declaration.reExport) return undefined;
+  return compactRecord({
+    kind: 'frontier.lang.reExportIdentity',
+    version: 1,
+    id: `reexport_${idFragment(relationId)}`,
+    sourceDocumentId: documentId,
+    sourcePath: input.sourcePath,
+    sourceHash: input.sourceHash,
+    moduleSpecifier: moduleEdge?.moduleSpecifier,
+    exportedName: declaration.exportedName ?? declaration.metadata?.exportedName,
+    importedName: declaration.importedName ?? declaration.metadata?.importedName,
+    localName: declaration.localName ?? declaration.metadata?.localName,
+    namespace: declaration.namespace ?? declaration.metadata?.namespace,
+    isTypeOnly: declaration.isTypeOnly ?? declaration.metadata?.isTypeOnly,
+    symbolId: declaration.symbolId,
+    relationId,
+    ownershipRegionId: ownershipRegion.id,
+    ownershipRegionKey: ownershipRegion.key,
+    publicContract: true
+  });
+}
+
+function projectSymbolGraphFacts({ moduleEdge, publicContractRegion, reExportIdentity, relationId, symbolId, evidenceId }) {
+  return [
+    moduleEdge ? {
+      id: `fact_${idFragment(relationId)}_module_edge`,
+      predicate: 'moduleEdge',
+      subjectId: relationId,
+      objectId: symbolId,
+      value: moduleEdge,
+      evidenceIds: [evidenceId]
+    } : undefined,
+    reExportIdentity ? {
+      id: `fact_${idFragment(relationId)}_re_export_identity`,
+      predicate: 'reExportIdentity',
+      subjectId: symbolId,
+      objectId: relationId,
+      value: reExportIdentity,
+      evidenceIds: [evidenceId]
+    } : undefined,
+    publicContractRegion ? {
+      id: `fact_${idFragment(symbolId)}_public_contract_region`,
+      predicate: 'publicContractRegion',
+      subjectId: symbolId,
+      objectId: publicContractRegion.id,
+      value: publicContractRegion,
+      evidenceIds: [evidenceId]
+    } : undefined
+  ].filter(Boolean);
+}
+
+function hashParts(sourceHash) {
+  const text = String(sourceHash);
+  const separator = text.indexOf(':');
+  return {
+    sourceHash: text,
+    ...(separator > 0 ? { algorithm: text.slice(0, separator), value: text.slice(separator + 1) } : { value: text })
+  };
+}
+
+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/dist/js-ts-safe-member-merge.js

@@ -1,5 +1,6 @@
 import {
   applyMemberAdditions,
+  applyPreparedMemberAdditions,
   canonicalizeSourceBodies,
   findContainer,
   normalizeKind,
@@ -17,6 +18,54 @@ function safeMergeJsTsMembers(input = {}) {
 }
 
 function mergeJsTsSafeMemberAdditions(input = {}) {
+  const analysis = analyzeJsTsSafeMemberAdditions(input);
+  const uniqueReasons = uniqueStrings(analysis.reasonCodes);
+  if (uniqueReasons.length) {
+    return mergeResult('rejected', undefined, uniqueReasons, analysis.preparedRegions, input, analysis.explicitPolicy);
+  }
+  const sourceText = applyMemberAdditions(analysis.headSourceText, analysis.preparedRegions);
+  return mergeResult('merged', sourceText, [], analysis.preparedRegions, input, analysis.explicitPolicy);
+}
+
+function analyzeJsTsSafeMemberAdditions(input = {}) {
+  const analysis = prepareJsTsSafeMemberAdditions(input);
+  const reasonCodes = [...analysis.reasonCodes];
+  if (!input.allowNonPolicySourceChanges) {
+    reasonCodes.push(...nonPolicySourceChangeReasons(analysis));
+  }
+  return {
+    ...analysis,
+    reasonCodes: uniqueStrings(reasonCodes),
+    ok: reasonCodes.length === 0
+  };
+}
+
+function neutralizeJsTsSafeMemberMergeSources(input = {}) {
+  const analysis = analyzeJsTsSafeMemberAdditions({
+    ...input,
+    allowNonPolicySourceChanges: true
+  });
+  if (analysis.reasonCodes.length) {
+    return {
+      ok: false,
+      analysis,
+      result: mergeResult('rejected', undefined, analysis.reasonCodes, analysis.preparedRegions, input, analysis.explicitPolicy)
+    };
+  }
+  return {
+    ok: true,
+    analysis,
+    baseSourceText: analysis.baseSourceText,
+    workerSourceText: canonicalizeSourceBodies(analysis.workerSourceText, analysis.preparedRegions, 'worker'),
+    headSourceText: canonicalizeSourceBodies(analysis.headSourceText, analysis.preparedRegions, 'head')
+  };
+}
+
+function applyJsTsPreparedMemberAdditions(sourceText, preparedRegions, sides) {
+  return applyPreparedMemberAdditions(sourceText, preparedRegions, sides);
+}
+
+function prepareJsTsSafeMemberAdditions(input = {}) {
   const baseSourceText = input.baseSourceText;
   const workerSourceText = input.workerSourceText;
   const headSourceText = input.headSourceText;
@@ -36,6 +85,20 @@ function mergeJsTsSafeMemberAdditions(input = {}) {
     reasonCodes.push(...prepared.reasonCodes);
     if (prepared.ok) preparedRegions.push(prepared.value);
   }
+  const explicitPolicy = policyRegions.length > 0;
+  return {
+    baseSourceText,
+    workerSourceText,
+    headSourceText,
+    reasonCodes: uniqueStrings(reasonCodes),
+    preparedRegions,
+    explicitPolicy
+  };
+}
+
+function nonPolicySourceChangeReasons(analysis) {
+  const reasonCodes = [];
+  const { baseSourceText, workerSourceText, headSourceText, preparedRegions } = analysis;
   if (typeof baseSourceText === 'string' && typeof workerSourceText === 'string' && preparedRegions.length) {
     const canonicalWorker = canonicalizeSourceBodies(workerSourceText, preparedRegions, 'worker');
     if (canonicalWorker !== baseSourceText) reasonCodes.push('non-policy-source-change:worker');
@@ -44,11 +107,7 @@ function mergeJsTsSafeMemberAdditions(input = {}) {
     const canonicalHead = canonicalizeSourceBodies(headSourceText, preparedRegions, 'head');
     if (canonicalHead !== baseSourceText) reasonCodes.push('non-policy-source-change:head');
   }
-  const uniqueReasons = uniqueStrings(reasonCodes);
-  const explicitPolicy = policyRegions.length > 0;
-  if (uniqueReasons.length) return mergeResult('rejected', undefined, uniqueReasons, preparedRegions, input, explicitPolicy);
-  const sourceText = applyMemberAdditions(headSourceText, preparedRegions);
-  return mergeResult('merged', sourceText, [], preparedRegions, input, explicitPolicy);
+  return reasonCodes;
 }
 
 function normalizePolicyRegions(policy) {
@@ -125,7 +184,8 @@ function prepareRegion(input) {
       headMembers: headMembers.members,
       workerAddedKeys,
       headAddedKeys,
-      workerAddedMembers: workerMembers.members.filter((member) => workerAddedKeys.includes(member.key))
+      workerAddedMembers: workerMembers.members.filter((member) => workerAddedKeys.includes(member.key)),
+      headAddedMembers: headMembers.members.filter((member) => headAddedKeys.includes(member.key))
     }
   };
 }
@@ -197,6 +257,9 @@ function regionReason(region, reason) {
 }
 
 export {
+  analyzeJsTsSafeMemberAdditions,
+  applyJsTsPreparedMemberAdditions,
   mergeJsTsSafeMemberAdditions,
+  neutralizeJsTsSafeMemberMergeSources,
   safeMergeJsTsMembers
 };

package/dist/js-ts-safe-merge-composed.js

@@ -0,0 +1,175 @@
+import {
+  JsTsSafeMergeConflictCodes,
+  JsTsSafeMergeGateIds,
+  JsTsSafeMergeStatuses,
+  jsTsSafeMergeGateOrder
+} from './js-ts-safe-merge-constants.js';
+import { safeMergeJsTsImportsAndDeclarations } from './js-ts-safe-merge.js';
+import { createJsTsSafeMergeSemanticArtifacts } from './js-ts-safe-merge-semantic-artifacts.js';
+import {
+  applyJsTsPreparedMemberAdditions,
+  neutralizeJsTsSafeMemberMergeSources
+} from './js-ts-safe-member-merge.js';
+
+function safeMergeJsTsSource(input = {}) {
+  if (!hasMemberMergePolicy(input)) return safeMergeJsTsImportsAndDeclarations(input);
+
+  const memberNeutralization = neutralizeJsTsSafeMemberMergeSources(input);
+  if (!memberNeutralization.ok) {
+    return composedBlockedResult(input, 'member-analysis', memberNeutralization.result, memberNeutralization.analysis);
+  }
+
+  const topLevelResult = safeMergeJsTsImportsAndDeclarations({
+    ...input,
+    baseSourceText: memberNeutralization.baseSourceText,
+    workerSourceText: memberNeutralization.workerSourceText,
+    headSourceText: memberNeutralization.headSourceText
+  });
+  if (topLevelResult.status !== JsTsSafeMergeStatuses.merged) {
+    return composedBlockedResult(input, 'top-level', topLevelResult, memberNeutralization.analysis);
+  }
+
+  const memberApplication = applyJsTsPreparedMemberAdditions(
+    topLevelResult.mergedSourceText,
+    memberNeutralization.analysis.preparedRegions,
+    ['head', 'worker']
+  );
+  if (memberApplication.reasonCodes.length) {
+    return composedMemberApplicationBlockedResult(input, topLevelResult, memberNeutralization.analysis, memberApplication.reasonCodes);
+  }
+
+  const memberAdditions = memberNeutralization.analysis.preparedRegions.reduce((total, region) => (
+    total + region.workerAddedKeys.length + region.headAddedKeys.length
+  ), 0);
+  const result = {
+    ...topLevelResult,
+    id: String(input.id ?? topLevelResult.id),
+    mergedSourceText: memberApplication.sourceText,
+    outputSourceText: memberApplication.sourceText,
+    summary: {
+      ...topLevelResult.summary,
+      memberRegions: memberNeutralization.analysis.preparedRegions.length,
+      memberAdditions,
+      composedPhases: 2
+    },
+    metadata: {
+      ...topLevelResult.metadata,
+      composed: {
+        phases: ['top-level', 'member'],
+        memberRegions: memberNeutralization.analysis.preparedRegions.map((region) => ({
+          kind: region.kind,
+          name: region.name,
+          regionKind: region.policy.regionKind,
+          workerAddedKeys: region.workerAddedKeys,
+          headAddedKeys: region.headAddedKeys
+        }))
+      }
+    }
+  };
+  return {
+    ...result,
+    semanticArtifacts: createJsTsSafeMergeSemanticArtifacts(input, result)
+  };
+}
+
+function hasMemberMergePolicy(input) {
+  const policy = input.policy ?? input.mergePolicy ?? input;
+  const regions = Array.isArray(policy)
+    ? policy
+    : policy?.unorderedRegions
+      ?? policy?.unorderedMemberRegions
+      ?? policy?.safeList
+      ?? policy?.safeMembers
+      ?? [];
+  return Array.isArray(regions) && regions.length > 0;
+}
+
+function composedBlockedResult(input, phase, result, memberAnalysis) {
+  return {
+    kind: 'frontier.lang.jsTsSafeMerge',
+    version: 1,
+    schema: 'frontier.lang.jsTsSafeMerge.v1',
+    id: String(input.id ?? result.id ?? 'js_ts_safe_merge'),
+    status: JsTsSafeMergeStatuses.blocked,
+    sourcePath: input.sourcePath,
+    language: input.language ?? 'typescript',
+    conflicts: result.conflicts ?? [],
+    gates: result.gates ?? [],
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: result.admission?.reasonCodes ?? result.reasonCodes ?? []
+    },
+    summary: {
+      importSpecifierAdditions: 0,
+      topLevelDeclarationAdditions: 0,
+      changedExistingDeclarations: result.summary?.changedExistingDeclarations ?? 0,
+      conflicts: result.conflicts?.length ?? result.summary?.conflicts ?? 0,
+      gatesPassed: result.gates?.filter((gate) => gate.status === 'passed').length ?? 0,
+      memberRegions: memberAnalysis?.preparedRegions?.length ?? 0,
+      memberAdditions: 0,
+      composedPhases: phase === 'top-level' ? 2 : 1
+    },
+    metadata: {
+      composed: {
+        phase,
+        sourceKind: result.kind
+      }
+    }
+  };
+}
+
+function composedMemberApplicationBlockedResult(input, topLevelResult, memberAnalysis, reasonCodes) {
+  const conflicts = reasonCodes.map((reason) => ({
+    code: JsTsSafeMergeConflictCodes.parserLedgerLoss,
+    gateId: JsTsSafeMergeGateIds.parseLedger,
+    message: 'Composed member application could not find a stable target container.',
+    side: 'merged',
+    sourcePath: input.sourcePath,
+    details: { reason }
+  }));
+  return {
+    ...topLevelResult,
+    status: JsTsSafeMergeStatuses.blocked,
+    mergedSourceText: undefined,
+    outputSourceText: undefined,
+    conflicts,
+    gates: jsTsSafeMergeGateOrder.map((id, index) => ({
+      id,
+      status: index === 0 ? 'blocked' : 'skipped',
+      reasonCodes: index === 0 ? [JsTsSafeMergeConflictCodes.parserLedgerLoss] : []
+    })),
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: [JsTsSafeMergeConflictCodes.parserLedgerLoss]
+    },
+    summary: {
+      ...topLevelResult.summary,
+      conflicts: conflicts.length,
+      gatesPassed: 0,
+      memberRegions: memberAnalysis.preparedRegions.length,
+      memberAdditions: 0,
+      composedPhases: 2
+    },
+    metadata: {
+      ...topLevelResult.metadata,
+      composed: {
+        phase: 'member-application',
+        reasonCodes
+      }
+    }
+  };
+}
+
+export {
+  safeMergeJsTsSource
+};