@shapeshift-labs/frontier-lang-compiler 0.2.190 → 0.2.192

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

@@ -110,6 +110,8 @@ export interface JsTsProjectSafeMergeInput {
   readonly globalAugmentationCompatibilityProofs?: readonly JsTsProjectGlobalAugmentationCompatibilityProof[]; readonly jsxRenderReturnBranchProof?: JsTsProjectJsxRenderReturnBranchProof; readonly jsxRenderReturnBranchProofs?: readonly JsTsProjectJsxRenderReturnBranchProof[]; readonly externalSemanticEquivalenceProof?: JsTsProjectSemanticEquivalenceProof; readonly semanticEquivalenceProof?: JsTsProjectSemanticEquivalenceProof;
   readonly htmlMergeOptions?: JsTsProjectHtmlCssMergeOptions; readonly markupMergeOptions?: JsTsProjectHtmlCssMergeOptions; readonly htmlMergeOptionsByPath?: Readonly<Record<string,JsTsProjectHtmlCssMergeOptions>>; readonly markupMergeOptionsByPath?: Readonly<Record<string,JsTsProjectHtmlCssMergeOptions>>;
   readonly cssMergeOptions?: JsTsProjectHtmlCssMergeOptions; readonly styleMergeOptions?: JsTsProjectHtmlCssMergeOptions; readonly cssMergeOptionsByPath?: Readonly<Record<string,JsTsProjectHtmlCssMergeOptions>>; readonly styleMergeOptionsByPath?: Readonly<Record<string,JsTsProjectHtmlCssMergeOptions>>;
+  readonly disableProjectCssDependencyGraphProofSynthesis?: boolean;
+  readonly disableProjectCssModuleProofSynthesis?: boolean;
   readonly moduleResolution?: NativeProjectModuleResolutionOptions;
   readonly tsconfig?: JsTsProjectTsconfigInput | NativeProjectModuleResolutionOptions;
   readonly projectReferences?: JsTsProjectReferencesInput;

package/dist/declarations/native-project-compiler-composite-types.d.ts

@@ -1,5 +1,41 @@
 export {};
 
+export interface NativeProjectSymbolGraphCompilerAdvancedTypeProofRequirement {
+  readonly kind: 'typescript-checker-public-api-advanced-type-shape-equivalence' | string;
+  readonly requiredEvidence?: 'typescript-checker-public-api-type-equivalence' | string;
+  readonly status?: 'requires-type-equivalence-proof' | 'missing-compiler-evidence' | 'requires-review' | string;
+  readonly requiredSignals?: readonly string[];
+  readonly missingSignals?: readonly string[];
+  readonly unsupportedSignals?: readonly string[];
+  readonly advancedTypeShapeCount?: number;
+  readonly advancedTypeShapeKinds?: readonly string[];
+  readonly conditionalTypeCount?: number;
+  readonly mappedTypeCount?: number;
+  readonly indexedAccessTypeCount?: number;
+  readonly keyofTypeOperatorCount?: number;
+  readonly templateLiteralTypeCount?: number;
+  readonly inferTypeCount?: number;
+  readonly unionTypeCount?: number;
+  readonly intersectionTypeCount?: number;
+  readonly tupleTypeCount?: number;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly sourceBound?: boolean;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+}
+
+export interface NativeProjectSymbolGraphCompilerAdvancedTypeMissingProof {
+  readonly kind: 'typescript-checker-public-api-advanced-type-shape-equivalence' | string;
+  readonly requiredEvidence?: 'typescript-checker-public-api-type-equivalence' | string;
+  readonly status?: 'missing-compiler-evidence' | 'requires-review' | string;
+  readonly reasonCode?: 'typescript-public-api-advanced-type-shape-proof-missing' | 'typescript-public-api-advanced-type-shape-proof-requires-review' | string;
+  readonly missingSignals?: readonly string[];
+  readonly unsupportedSignals?: readonly string[];
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+}
+
 declare module './native-project-compiler-scope.js' {
   interface NativeProjectSymbolGraphCompilerAdvancedTypeShapeRecord {
     readonly memberTypeTexts?: readonly string[];
@@ -11,8 +47,13 @@ declare module './native-project-compiler-scope.js' {
     readonly unionTypeSetHash?: string;
     readonly intersectionTypeSetHash?: string;
     readonly tupleTypeSetHash?: string;
+    readonly unionTypeCount?: number;
+    readonly intersectionTypeCount?: number;
+    readonly tupleTypeCount?: number;
   }
   interface NativeProjectSymbolGraphCompilerTypeRecord {
+    readonly advancedTypeProofRequirement?: NativeProjectSymbolGraphCompilerAdvancedTypeProofRequirement;
+    readonly advancedTypeMissingProof?: NativeProjectSymbolGraphCompilerAdvancedTypeMissingProof;
     readonly unionTypeCount?: number;
     readonly intersectionTypeCount?: number;
     readonly tupleTypeCount?: number;

package/dist/declarations/native-project-compiler-index-signature.d.ts

@@ -5,3 +5,15 @@ export interface NativeProjectSymbolGraphCompilerIndexSignatureRecord {
   readonly readonly?: boolean;
   readonly declarationText?: string;
 }
+
+declare module './native-project-compiler-scope.js' {
+  interface NativeProjectSymbolGraphCompilerTypeEquivalenceProof {
+    readonly indexSignatureSetHash?: string;
+    readonly indexSignatureCount?: number;
+    readonly indexSignatureReadonlyCount?: number;
+  }
+
+  interface NativeProjectSymbolGraphCompilerTypeRecord {
+    readonly indexSignatureReadonlyCount?: number;
+  }
+}

package/dist/declarations/native-project-compiler-public-api-source-binding.d.ts

@@ -4,5 +4,6 @@ declare module './native-project-compiler-scope.js' {
   interface NativeProjectSymbolGraphCompilerTypeEquivalenceProof {
     readonly sourcePath?: string;
     readonly sourceHash?: string;
+    readonly sourceBoundPublicApi?: boolean;
   }
 }

package/dist/js-ts-safe-project-merge-css-dependency-proofs.js

@@ -0,0 +1,106 @@
+import { hashText, safeId } from './js-ts-safe-project-merge-core.js';
+
+const CssDependencyGraphProofGap = 'css-dependency-graph-proof-unproved';
+const CssDependencyGraphConflict = 'css-dependency-graph-proof-blocked';
+const ProjectProofLevel = 'css-custom-property-dependency-graph-project-source-bound';
+const SourceBoundDependencyGraphProofKind = 'css-source-bound-dependency-graph-proof';
+const SynthesizableDependencyKinds = new Set(['custom-property-definition', 'custom-property-reference']);
+
+function projectCssDependencyProofOptionsForBlockedMerge(input) {
+  const { projectInput, sourcePath, firstResult, base, worker, head } = input;
+  if (projectInput?.disableProjectCssDependencyGraphProofSynthesis === true) return undefined;
+  if (firstResult?.status !== 'blocked' || typeof firstResult.candidateMergedSourceText !== 'string' || !firstResult.candidateMergedSourceHash) return undefined;
+  const evidence = firstResult.dependencyGraphEvidence;
+  const conflicts = dependencyGraphProofConflicts(firstResult);
+  if (!evidence?.changedDependencySurfaces?.length || !conflicts.length) return undefined;
+  const changesByKey = new Map(evidence.changedDependencySurfaces.map((change) => [dependencyChangeKey(change), change]));
+  const proofChanges = conflicts
+    .map((conflict) => changesByKey.get(dependencyConflictKey(conflict)) ?? dependencyChangeFromConflict(conflict))
+    .filter((change) => change?.reasonCode === CssDependencyGraphProofGap && canSynthesizeDependencyChange(change));
+  if (!proofChanges.length) return undefined;
+  return {
+    mergeOptions: {
+      cssDependencyGraphProofs: proofChanges.map((change, index) => projectCssDependencyGraphProof({ sourcePath, evidence, change, firstResult, base, worker, head, index }))
+    }
+  };
+}
+
+function dependencyGraphProofConflicts(result) {
+  return (result.conflicts ?? []).filter((conflict) => conflict.code === CssDependencyGraphConflict && conflict.details?.reasonCode === CssDependencyGraphProofGap);
+}
+
+function dependencyChangeFromConflict(conflict) {
+  const details = conflict?.details;
+  if (!details?.side || !details?.cascadeKey) return undefined;
+  return {
+    side: details.side,
+    cascadeKey: details.cascadeKey,
+    reasonCode: details.reasonCode,
+    changeKind: details.changeKind,
+    before: details.before,
+    after: details.after
+  };
+}
+
+function canSynthesizeDependencyChange(change) {
+  const kinds = uniqueStrings([...(change.before?.dependencyKinds ?? []), ...(change.after?.dependencyKinds ?? [])]);
+  return kinds.length > 0 && kinds.every((kind) => SynthesizableDependencyKinds.has(kind));
+}
+
+function projectCssDependencyGraphProof({ sourcePath, evidence, change, firstResult, base, worker, head, index }) {
+  return {
+    id: `project_css_dependency_graph_${safeId(sourcePath)}_${index}`,
+    kind: SourceBoundDependencyGraphProofKind,
+    status: 'passed',
+    proofLevel: ProjectProofLevel,
+    sourcePath,
+    reasonCode: change.reasonCode,
+    side: change.side,
+    cascadeKey: change.cascadeKey,
+    dependencyKinds: uniqueStrings([...(change.before?.dependencyKinds ?? []), ...(change.after?.dependencyKinds ?? [])]),
+    baseSourceHash: hashText(base),
+    workerSourceHash: hashText(worker),
+    headSourceHash: hashText(head),
+    outputSourceHash: firstResult.candidateMergedSourceHash,
+    dependencyGraphHashes: dependencyGraphHashes(evidence),
+    cssDependencyGraphHashes: cssDependencyGraphHashes(evidence),
+    browserCascadeEquivalenceClaim: false,
+    browserRenderEquivalenceClaim: false,
+    semanticEquivalenceClaim: false
+  };
+}
+
+function dependencyGraphHashes(evidence) {
+  return compactRecord({
+    base: evidence.sides?.base?.dependencyGraphHash,
+    worker: evidence.sides?.worker?.dependencyGraphHash,
+    head: evidence.sides?.head?.dependencyGraphHash
+  });
+}
+
+function cssDependencyGraphHashes(evidence) {
+  return compactRecord({
+    base: evidence.sides?.base?.cssDependencyGraphHash,
+    worker: evidence.sides?.worker?.cssDependencyGraphHash,
+    head: evidence.sides?.head?.cssDependencyGraphHash
+  });
+}
+
+function dependencyChangeKey(change) {
+  return `${change?.side ?? ''}#${change?.cascadeKey ?? ''}#${change?.reasonCode ?? ''}`;
+}
+
+function dependencyConflictKey(conflict) {
+  const details = conflict?.details ?? {};
+  return `${details.side ?? ''}#${details.cascadeKey ?? ''}#${details.reasonCode ?? ''}`;
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+
+export { projectCssDependencyProofOptionsForBlockedMerge };

package/dist/js-ts-safe-project-merge-html-css.js

@@ -2,6 +2,7 @@ import { safeMergeCssSource } from '@shapeshift-labs/frontier-lang-css';
 import { safeMergeHtmlSource } from '@shapeshift-labs/frontier-lang-html';
 import { compactRecord } from './js-ts-safe-merge-context.js';
 import { hashText, safeId, uniqueStrings } from './js-ts-safe-project-merge-core.js';
+import { projectCssDependencyProofOptionsForBlockedMerge } from './js-ts-safe-project-merge-css-dependency-proofs.js';
 import { projectCssModuleMergeOptionsForFile, projectCssModuleProofOptionsForBlockedMerge } from './js-ts-safe-project-merge-css-module-proofs.js';
 import { htmlRuntimeBoundaryChanges, htmlRuntimeBoundaryProofForChange, htmlRuntimeBoundaryProofRecord, htmlRuntimeBoundaryProvenResult } from './js-ts-safe-project-merge-html-runtime-boundaries.js';
 
@@ -22,10 +23,16 @@ function maybeMergeHtmlCssProjectFile(options) {
   const runtimeBoundaryProofs = language === 'html' ? htmlRuntimeBoundaryProofCandidates(input, file.sourcePath, mergeOptions) : [];
   const runtimeBoundaryMergeOptions = runtimeBoundaryProofs.length ? { htmlRuntimeBoundaryProofs: runtimeBoundaryProofs, htmlSourceBoundRuntimeBoundaryProofs: runtimeBoundaryProofs } : {};
   let result = merge({ ...sourceInput, ...mergeOptions, ...context, ...runtimeBoundaryMergeOptions, id: resultId, baseSourceText: base, workerSourceText: worker, headSourceText: head, includeBlockedMergeCandidate: language === 'css' || sourceInput.includeBlockedMergeCandidate === true });
+  if (language === 'css' && result.status === 'blocked') {
+    const proofOptions = projectCssDependencyProofOptionsForBlockedMerge({ projectInput: input, sourcePath: file.sourcePath, firstResult: result, base, worker, head });
+    if (proofOptions?.mergeOptions) {
+      result = merge({ ...sourceInput, ...mergeOptions, ...proofOptions.mergeOptions, ...context, id: resultId, baseSourceText: base, workerSourceText: worker, headSourceText: head, includeBlockedMergeCandidate: true });
+    }
+  }
   if (language === 'css' && result.status === 'blocked') {
     const proofOptions = projectCssModuleProofOptionsForBlockedMerge({ evidence: projectCssModuleMergeEvidence, sourcePath: file.sourcePath, mergeOptions, firstResult: result, base, worker, head });
     if (proofOptions?.mergeOptions) {
-      result = merge({ ...sourceInput, ...mergeOptions, ...proofOptions.mergeOptions, ...context, id: resultId, baseSourceText: base, workerSourceText: worker, headSourceText: head });
+      result = merge({ ...sourceInput, ...mergeOptions, ...proofOptions.mergeOptions, ...context, id: resultId, baseSourceText: base, workerSourceText: worker, headSourceText: head, includeBlockedMergeCandidate: true });
     } else if (proofOptions?.result) {
       result = proofOptions.result;
     }

package/package.json

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