@shapeshift-labs/frontier-lang-compiler 0.2.35 → 0.2.37

package/README.md

@@ -197,6 +197,7 @@ const sidecar = createSemanticImportSidecar(imported);
 console.log(sidecar.summary.emptySemanticIndex); // false when symbols were found
 console.log(sidecar.ownershipRegions[0].key); // source#src/runtime.ts#type#Runtime
 console.log(sidecar.patchHints[0].supportedOperations); // source-region patch operations
+console.log(sidecar.proofSpec.obligations); // proof/spec obligations when the import carries a universal AST proof layer
 ```
 
 The built-in JavaScript/TypeScript lightweight scanner also emits review-required ownership regions for clear route/config/content/property shapes in exported objects and arrays:

package/dist/index.d.ts

@@ -20,7 +20,9 @@ import type {
   SourceMapRecord,
   SourcePreservationLevel,
   SourcePreservationRecord,
-  SourceSpan
+  SourceSpan,
+  UniversalAstLayerMap,
+  UniversalAstLayerRecord
 } from '@shapeshift-labs/frontier-lang-kernel';
 import type { Diagnostic } from '@shapeshift-labs/frontier-lang-checker';
 import type { EmitTypeScriptOptions, TypeScriptAstModule, TypeScriptDocumentSourceMapResult, TypeScriptGeneratedSourceMapResult } from '@shapeshift-labs/frontier-lang-typescript';
@@ -963,6 +965,10 @@ export interface SemanticImportSidecarImportEntry {
   readonly sourceMapMappingCount: number;
   readonly sourcePreservationRecordCount: number;
   readonly sourcePreservationLevels: readonly SourcePreservationLevel[];
+  readonly universalAstLayerCount: number;
+  readonly universalAstLayerNames: readonly string[];
+  readonly universalAstLayerIds: readonly string[];
+  readonly proofSpec: SemanticImportSidecarProofSpecSummary;
   readonly readiness: SemanticMergeReadiness;
   readonly emptySemanticIndex: boolean;
   readonly regionTaxonomy?: SemanticImportRegionTaxonomySummary;
@@ -986,6 +992,40 @@ export interface SemanticImportSidecarSourcePreservationRecord {
   readonly reasons: readonly string[];
 }
 
+export interface SemanticImportSidecarUniversalAstLayerSummary {
+  readonly total: number;
+  readonly names: readonly string[];
+  readonly ids: readonly string[];
+  readonly byName: Readonly<Record<string, number>>;
+  readonly empty: boolean;
+}
+
+export interface SemanticImportSidecarProofSpecSummary {
+  readonly total: number;
+  readonly ids: readonly string[];
+  readonly contracts: number;
+  readonly refinements: number;
+  readonly invariants: number;
+  readonly termination: number;
+  readonly temporal: number;
+  readonly obligations: number;
+  readonly artifacts: number;
+  readonly assumptions: number;
+  readonly evidence: number;
+  readonly discharged: number;
+  readonly failed: number;
+  readonly open: number;
+  readonly unknown: number;
+  readonly stale: number;
+  readonly assumed: number;
+  readonly contractKinds: readonly string[];
+  readonly artifactKinds: readonly string[];
+  readonly byStatus: Readonly<Record<string, number>>;
+  readonly byContractKind: Readonly<Record<string, number>>;
+  readonly byArtifactKind: Readonly<Record<string, number>>;
+  readonly empty: boolean;
+}
+
 export interface SemanticImportSidecar {
   readonly kind: 'frontier.lang.semanticImportSidecar';
   readonly version: 1;
@@ -1014,6 +1054,8 @@ export interface SemanticImportSidecar {
     readonly sourceMapMappingIds: readonly string[];
     readonly records: readonly SemanticImportSidecarSourcePreservationRecord[];
   };
+  readonly universalAstLayers: SemanticImportSidecarUniversalAstLayerSummary;
+  readonly proofSpec: SemanticImportSidecarProofSpecSummary;
   readonly patchHints: readonly SemanticImportPatchHint[];
   readonly mergeCandidates: readonly {
     readonly id?: string;
@@ -1043,6 +1085,11 @@ export interface SemanticImportSidecar {
     readonly regionKinds: number;
     readonly sourceMapMappings: number;
     readonly sourcePreservationRecords: number;
+    readonly universalAstLayers: number;
+    readonly universalAstLayerNames: readonly string[];
+    readonly proofSpecRecords: number;
+    readonly proofSpecObligations: number;
+    readonly proofSpecFailedObligations: number;
     readonly readiness: SemanticMergeReadiness;
     readonly emptySemanticIndex: boolean;
   };
@@ -2190,9 +2237,13 @@ export declare function diffNativeSourceImports(input: DiffNativeSourceImportsOp
 export declare function importNativeProject(input: ImportNativeProjectOptions): Promise<NativeProjectImportResult>;
 export declare function createUniversalAstFromDocument(document: FrontierLangDocument, input?: {
   readonly id?: string;
+  readonly nativeSources?: readonly NativeSourceNode[];
   readonly semanticIndex?: SemanticIndexRecord;
   readonly sourceMaps?: readonly SourceMapRecord[];
+  readonly losses?: readonly NativeAstLossRecord[];
   readonly evidence?: readonly EvidenceRecord[];
+  readonly mergeCandidates?: readonly SemanticMergeCandidateRecord[];
+  readonly layers?: UniversalAstLayerMap | readonly UniversalAstLayerRecord[];
   readonly metadata?: Record<string, unknown>;
 }): FrontierUniversalAstEnvelope;
 export declare function readUniversalAstJson(source: string): FrontierUniversalAstEnvelope;

package/dist/index.js

@@ -2565,6 +2565,8 @@ export function createSemanticImportSidecar(importResult, options = {}) {
   const lossSummary = summarizeNativeImportLosses(losses, { evidence });
   const regionTaxonomy = summarizeSemanticImportRegionTaxonomy(ownershipRegions);
   const sourcePreservation = summarizeKernelSourcePreservation(importResult, imports);
+  const universalAstLayers = summarizeSemanticImportSidecarUniversalAstLayers(importEntries);
+  const proofSpec = summarizeSemanticImportSidecarProofSpec(importEntries);
   const readiness = mergeCandidates.reduce(
     (current, candidate) => maxSemanticMergeReadiness(current, candidate.readiness),
     lossSummary.semanticMergeReadiness
@@ -2586,6 +2588,8 @@ export function createSemanticImportSidecar(importResult, options = {}) {
       ids: sourceMaps.map((sourceMap) => sourceMap.id).filter(Boolean)
     },
     sourcePreservation,
+    universalAstLayers,
+    proofSpec,
     patchHints,
     mergeCandidates: mergeCandidates.map((candidate) => ({
       id: candidate.id,
@@ -2615,6 +2619,11 @@ export function createSemanticImportSidecar(importResult, options = {}) {
       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,
       readiness,
       emptySemanticIndex: symbols.length === 0
     },
@@ -8577,6 +8586,8 @@ function semanticImportSidecarEntry(imported, index, options) {
   const sourceMaps = imported?.sourceMaps ?? imported?.universalAst?.sourceMaps ?? [];
   const sourceMapMappings = sourceMaps.flatMap((sourceMap) => sourceMap?.mappings ?? []);
   const sourcePreservationRecords = collectKernelSourcePreservationFromImport(imported);
+  const universalAstLayers = summarizeUniversalAstLayers(imported?.universalAst);
+  const proofSpec = summarizeProofSpecLayer(imported?.universalAst?.proof ?? imported?.proof);
   const mappingsBySymbolId = new Map();
   for (const mapping of sourceMapMappings) {
     if (mapping.semanticSymbolId && !mappingsBySymbolId.has(mapping.semanticSymbolId)) {
@@ -8623,6 +8634,10 @@ function semanticImportSidecarEntry(imported, index, options) {
     sourceMapMappingCount: sourceMapMappings.length,
     sourcePreservationRecordCount: sourcePreservationRecords.length,
     sourcePreservationLevels: uniqueStrings(sourcePreservationRecords.map((record) => record.level).filter(Boolean)),
+    universalAstLayerCount: universalAstLayers.total,
+    universalAstLayerNames: universalAstLayers.names,
+    universalAstLayerIds: universalAstLayers.ids,
+    proofSpec,
     readiness: imported?.metadata?.semanticMergeReadiness ?? imported?.mergeCandidates?.[0]?.readiness ?? 'needs-review',
     emptySemanticIndex: symbols.length === 0,
     regionTaxonomy,
@@ -8631,6 +8646,167 @@ function semanticImportSidecarEntry(imported, index, options) {
   };
 }
 
+function summarizeSemanticImportSidecarProofSpec(importEntries) {
+  const byStatus = {};
+  const byContractKind = {};
+  const byArtifactKind = {};
+  const ids = [];
+  const contractKinds = [];
+  const artifactKinds = [];
+  const totals = {
+    total: 0,
+    contracts: 0,
+    refinements: 0,
+    invariants: 0,
+    termination: 0,
+    temporal: 0,
+    obligations: 0,
+    artifacts: 0,
+    assumptions: 0,
+    evidence: 0,
+    discharged: 0,
+    failed: 0,
+    open: 0,
+    unknown: 0,
+    stale: 0,
+    assumed: 0
+  };
+  for (const entry of importEntries) {
+    const proof = entry.proofSpec ?? summarizeProofSpecLayer();
+    ids.push(...(proof.ids ?? []));
+    contractKinds.push(...(proof.contractKinds ?? []));
+    artifactKinds.push(...(proof.artifactKinds ?? []));
+    for (const key of Object.keys(totals)) {
+      totals[key] += proof[key] ?? 0;
+    }
+    for (const [status, count] of Object.entries(proof.byStatus ?? {})) {
+      byStatus[status] = (byStatus[status] ?? 0) + count;
+    }
+    for (const [kind, count] of Object.entries(proof.byContractKind ?? {})) {
+      byContractKind[kind] = (byContractKind[kind] ?? 0) + count;
+    }
+    for (const [kind, count] of Object.entries(proof.byArtifactKind ?? {})) {
+      byArtifactKind[kind] = (byArtifactKind[kind] ?? 0) + count;
+    }
+  }
+  return {
+    ...totals,
+    ids: uniqueStrings(ids),
+    contractKinds: uniqueStrings(contractKinds),
+    artifactKinds: uniqueStrings(artifactKinds),
+    byStatus,
+    byContractKind,
+    byArtifactKind,
+    empty: totals.total === 0
+  };
+}
+
+function summarizeProofSpecLayer(proof = {}) {
+  const contracts = proof?.contracts ?? [];
+  const refinements = proof?.refinements ?? [];
+  const invariants = proof?.invariants ?? [];
+  const termination = proof?.termination ?? [];
+  const temporal = proof?.temporal ?? [];
+  const obligations = proof?.obligations ?? [];
+  const artifacts = proof?.artifacts ?? [];
+  const assumptions = proof?.assumptions ?? [];
+  const evidence = proof?.evidence ?? [];
+  const allContracts = [...contracts, ...refinements, ...invariants, ...termination, ...temporal];
+  const byStatus = {};
+  for (const obligation of obligations) {
+    const status = obligation?.status ?? 'unknown';
+    byStatus[status] = (byStatus[status] ?? 0) + 1;
+  }
+  const byContractKind = {};
+  for (const contract of allContracts) {
+    const kind = contract?.kind ?? 'unknown';
+    byContractKind[kind] = (byContractKind[kind] ?? 0) + 1;
+  }
+  const byArtifactKind = {};
+  for (const artifact of artifacts) {
+    const kind = artifact?.kind ?? 'unknown';
+    byArtifactKind[kind] = (byArtifactKind[kind] ?? 0) + 1;
+  }
+  const recordGroups = [allContracts, obligations, artifacts, assumptions];
+  const ids = uniqueStrings([
+    proof?.id,
+    ...recordGroups.flatMap((records) => records.map((record) => record?.id)),
+    ...evidence.map((record) => record?.id)
+  ].filter(Boolean));
+  const total = allContracts.length + obligations.length + artifacts.length + assumptions.length;
+  return {
+    total,
+    ids,
+    contracts: contracts.length,
+    refinements: refinements.length,
+    invariants: invariants.length,
+    termination: termination.length,
+    temporal: temporal.length,
+    obligations: obligations.length,
+    artifacts: artifacts.length,
+    assumptions: assumptions.length,
+    evidence: evidence.length,
+    discharged: byStatus.discharged ?? 0,
+    failed: byStatus.failed ?? 0,
+    open: byStatus.open ?? 0,
+    unknown: byStatus.unknown ?? 0,
+    stale: byStatus.stale ?? 0,
+    assumed: byStatus.assumed ?? 0,
+    contractKinds: uniqueStrings(allContracts.map((record) => record?.kind).filter(Boolean)),
+    artifactKinds: uniqueStrings(artifacts.map((record) => record?.kind).filter(Boolean)),
+    byStatus,
+    byContractKind,
+    byArtifactKind,
+    empty: total === 0
+  };
+}
+
+function summarizeSemanticImportSidecarUniversalAstLayers(importEntries) {
+  const names = [];
+  const ids = [];
+  const byName = {};
+  for (const entry of importEntries) {
+    names.push(...(entry.universalAstLayerNames ?? []));
+    ids.push(...(entry.universalAstLayerIds ?? []));
+    for (const name of entry.universalAstLayerNames ?? []) {
+      byName[name] = (byName[name] ?? 0) + 1;
+    }
+  }
+  const uniqueNames = uniqueStrings(names);
+  return {
+    total: ids.length,
+    names: uniqueNames,
+    ids: uniqueStrings(ids),
+    byName,
+    empty: ids.length === 0
+  };
+}
+
+function summarizeUniversalAstLayers(universalAst) {
+  const layers = collectUniversalAstLayerRecords(universalAst?.layers);
+  const names = uniqueStrings(layers.map((layer) => layer.layer).filter(Boolean));
+  const ids = uniqueStrings(layers.map((layer) => layer.id).filter(Boolean));
+  const byName = {};
+  for (const layer of layers) {
+    if (!layer?.layer) continue;
+    byName[layer.layer] = (byName[layer.layer] ?? 0) + 1;
+  }
+  return {
+    total: layers.length,
+    names,
+    ids,
+    byName,
+    empty: layers.length === 0
+  };
+}
+
+function collectUniversalAstLayerRecords(layers) {
+  if (!layers) return [];
+  if (Array.isArray(layers)) return layers.filter(Boolean);
+  if (typeof layers !== 'object') return [];
+  return Object.values(layers).flatMap((value) => Array.isArray(value) ? value : [value]).filter(Boolean);
+}
+
 function semanticOwnershipRegionForSymbol(imported, symbol, mapping, nativeNode, options = {}) {
   const sourcePath = mapping?.sourceSpan?.path ?? symbol.definitionSpan?.path ?? nativeNode?.span?.path ?? imported?.sourcePath ?? imported?.nativeSource?.sourcePath ?? imported?.nativeAst?.sourcePath;
   const language = symbol.language ?? imported?.language ?? imported?.nativeAst?.language ?? imported?.nativeSource?.language;
@@ -9359,9 +9535,13 @@ export function createUniversalAstFromDocument(document, input = {}) {
   return createUniversalAstEnvelope({
     id: input.id ?? `universal_ast_${idFragment(document.id)}`,
     document,
+    nativeSources: input.nativeSources,
     semanticIndex: input.semanticIndex,
     sourceMaps: input.sourceMaps ?? [],
+    losses: input.losses,
     evidence: input.evidence ?? [],
+    mergeCandidates: input.mergeCandidates,
+    layers: input.layers,
     metadata: input.metadata
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.35",
+  "version": "0.2.37",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",
@@ -59,7 +59,7 @@
     "@shapeshift-labs/frontier-lang-c": "0.2.5",
     "@shapeshift-labs/frontier-lang-checker": "0.3.4",
     "@shapeshift-labs/frontier-lang-javascript": "0.2.5",
-    "@shapeshift-labs/frontier-lang-kernel": "0.3.5",
+    "@shapeshift-labs/frontier-lang-kernel": "0.3.7",
     "@shapeshift-labs/frontier-lang-parser": "0.3.4",
     "@shapeshift-labs/frontier-lang-python": "0.2.5",
     "@shapeshift-labs/frontier-lang-rust": "0.2.5",