@shapeshift-labs/frontier-lang-compiler 0.2.184 → 0.2.186

package/README.md

@@ -553,8 +553,9 @@ Current JS/TS semantic-merge status matrix:
 | HTML identity evidence | bounded-evidence | HTML identity proof uses `htmlIdentityEvidenceFiles`, explicit/path identity residual counters, duplicate identity counters, runtime/framework boundary counters, `htmlProofGapBlockedFiles`, and the `html-identity-evidence` proof status. Parser-backed stable identity can support later structural admission, while duplicate identity, runtime boundaries, framework boundaries, or missing proof gaps stay review/blocking evidence. |
 | CSS selector target evidence | bounded-evidence | CSS selector target proof uses `cssSelectorTargetEvidenceFiles`, selector target graph/specificity/move counters, selector conflict/rebase counters, and the `css-selector-target-evidence` proof status. Target evidence remains bounded to parser-backed selector/target/rebase facts and does not claim cascade or browser runtime equivalence. |
 | HTML structural merge admission | partial | HTML structural admission uses `html-structural-merge` proof statuses plus parser and identity evidence. It can admit bounded structural source merges when files merge cleanly and required identity/parser evidence is present; blocked files route to `admit-html-structural-merge` and browser/runtime proof remains a separate row. |
-| CSS cascade merge admission | partial | CSS cascade admission uses `css-cascade-merge` proof statuses plus parser, selector, scoped cascade, dependency, and CSS Module use-site evidence. It remains partial: generated class maps, bundler transform identity, source-map proof, scoped cascade proof, dependency proof, and dynamic use sites stay fail-closed when absent. |
-| CSS dependency graph evidence | bounded-evidence | CSS dependency graph proof uses `cssDependencySurfaceFiles`, `cssDependencyGraphEvidenceFiles`, missing-proof/blocker counters, and the `css-dependency-graph` proof status for custom property, `var()` fallback, animation, font, and asset dependency surfaces. It is absent when no dependency surface is present and does not claim cascade/browser equivalence. |
+| CSS cascade merge admission | partial | CSS cascade admission uses `css-cascade-merge` proof statuses plus parser, selector, shape-keyed scoped cascade, dependency, and CSS Module use-site evidence. It remains partial: generated class maps, bundler transform identity, source-map proof, source-bound scoped cascade proof with scope shape keys, dependency proof, and dynamic use sites stay fail-closed when absent. |
+| CSS dependency graph evidence | bounded-evidence | CSS dependency graph proof uses `cssDependencySurfaceFiles`, `cssDependencyGraphEvidenceFiles`, missing-proof/blocker counters, and the `css-dependency-graph` proof status for custom property, `var()` fallback, animation, font, asset, `@property`, and `@page` dependency surfaces. It is absent when no dependency surface is present and does not claim cascade/browser equivalence. |
+| CSS runtime descriptor evidence | bounded-evidence | CSS runtime descriptor proof uses `cssRuntimeDescriptorFiles`, `cssRuntimeDescriptorEvidenceFiles`, property/page descriptor counters, and the `css-runtime-descriptor-evidence` proof status for parser-backed `@property` syntax/inherits/initial-value evidence plus `@page` descriptor and margin-box records. It is source/shape-key evidence only; browser cascade, render, and runtime equivalence remain in the separate browser proof row. |
 | HTML/CSS browser runtime proof | bounded-evidence | HTML/CSS browser proof is an explicit separate row tracked by `htmlCssBrowserRuntimeProofs`, the `html-css-browser-runtime-proof` surface, and the `browser-runtime-proof` proof status. Structural source merges keep browser/render/cascade equivalence claims false unless a bounded browser proof bundle is attached; missing proof routes to `prove-html-css-browser-runtime`. |
 | Parser/source-span/trivia evidence | Partial | Source preservation, source hashes, runtime directive-prologue entries, directives, comments/trivia summaries, project `sourceFileRecords` / `sourceSpanRecords`, protected-span hashes, shebang file-entrypoint directive ownership anchors, `sourceMappingURL` and `sourceURL` generated-boundary source-map spans, deterministic source-map generated-boundary ownership keys from supplied exact source/generated spans and hashes, generated-boundary position conflict evidence, deterministic ownership anchors, source-span/trivia ownership blockers, exact parser-trivia ownership records for directive prologues plus leading/trailing comments and JSDoc/block-comment spans when parser evidence matches the source hash, TypeScript `SourceFile` compiler-scanner exact token/trivia source-preservation evidence for JS/TS/JSX/TSX imports, ESTree/Babel parser token/comment range evidence when the supplied AST covers every non-whitespace byte of the current source, fail-closed scanner/ledger spoof blockers, source-span delta conflicts, parser roundtrip proof records, failed source-span roundtrip proof admission blockers, project-merge stage parser-trivia evidence from supplied parser-backed imports for base/worker/head/output, metadata-only exactness blockers for scanner fallbacks, and fixture corpus checks. Parser-backed exactness also requires contiguous current-source token/comment/trivia coverage with no gaps, overlaps, truncation, or text mismatches; truncated coverage blocks exact token/comment ownership. Adapters without token/comment ranges remain approximate/caller evidence, not exact parser trivia. |
 | Scope/use-def graph | Partial | Lightweight lexical scope/use-def scans, destructuring alias binding records, object/array/nested/rest/default-initializer parameter binding evidence for function and arrow parameters, default import alias reads through re-export chains when a stable default-export local binding is observed, fail-closed `lexical-scope-import-alias-target-unresolved` records when an alias target cannot be tied to a lexical binding, namespace import dot and literal/static-template computed member-read evidence, blocked evidence for ambiguous computed namespace reads and namespace member writes, `this`/`super` receiver member read/write evidence including computed string and static-template members, optional chaining markers, and TypeScript checker-backed receiver-member reference proof for full `this`/`super` access spans including private identifiers, template-literal interpolation live-reference records with expression hashes plus tagged-template site/tag root/member metadata, caller-supplied ESTree/scope-manager structural evidence normalization, closure-capture depth/owner/reference hashes, binding-level closure capture hashes, project `scopeBindingRecords` / `scopeReferenceRecords`, public owner use hashes, public scope-use and reference-site delta conflicts with alias target route/use-hash evidence, TypeScript compiler reference relations when a checker is supplied, exact compiler reference-site proof hashes on scope reference records, fail-closed `typescript-compiler-reference-site-ambiguous`, `typescript-compiler-reference-lexical-binding-mismatch`, and `typescript-compiler-reference-import-alias-target-mismatch` records when compiler alias evidence cannot be reconciled with the lexical route or re-export/import target, and dependency-sensitive fixture coverage. Full whole-program binding/control-flow resolution is still caller/compiler-evidence bounded. |

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

@@ -10,7 +10,7 @@ export interface JsTsProjectSafeMergeSummary {
   readonly htmlFiles:number; readonly cssFiles:number; readonly htmlCssFiles:number; readonly htmlMergedFiles:number; readonly cssMergedFiles:number; readonly htmlCssMergedFiles:number; readonly htmlBlockedFiles:number; readonly cssBlockedFiles:number; readonly htmlCssBlockedFiles:number; readonly htmlCssBrowserRuntimeProofs:number;
   readonly htmlParserEvidenceFiles:number; readonly cssParserEvidenceFiles:number; readonly htmlCssParserEvidenceFiles:number; readonly htmlParserEvidenceFailedFiles:number; readonly cssParserEvidenceFailedFiles:number; readonly htmlCssParserEvidenceFailedFiles:number;
   readonly htmlIdentityEvidenceFiles:number; readonly cssSelectorTargetEvidenceFiles:number; readonly htmlCssStructuralTargetEvidenceFiles:number; readonly cssSelectorTargetGraphEvidenceFiles:number; readonly cssSelectorSpecificityEvidenceFiles:number; readonly cssSelectorTargetMoveFiles:number; readonly htmlExplicitIdentityEvidenceFiles:number; readonly htmlPathOnlyIdentityResidualFiles:number; readonly htmlDuplicateIdentityEvidenceFiles:number; readonly htmlDuplicateIdentityKeys:number; readonly htmlRuntimeBoundaryEvidenceFiles:number; readonly htmlFrameworkBoundaryEvidenceFiles:number; readonly htmlProofGapBlockedFiles:number; readonly htmlIdentityEvidenceFailedFiles:number; readonly cssSelectorTargetConflictFiles:number; readonly htmlCssStructuralTargetEvidenceFailedFiles:number; readonly cssSelectorTargetRebasedFiles:number;
-  readonly cssScopedCascadeFiles:number; readonly cssScopedCascadeEvidenceFiles:number; readonly cssScopedCascadeBlockedFiles:number; readonly cssDuplicateCascadeKeyBlockedFiles:number; readonly cssShorthandExpansionEvidenceFiles:number; readonly cssDeterministicShorthandExpansionFiles:number; readonly cssShorthandExpansionBlockedFiles:number; readonly cssDependencySurfaceFiles:number; readonly cssDependencyGraphEvidenceFiles:number; readonly cssDependencyGraphMissingProofFiles:number; readonly cssDependencyGraphBlockedFiles:number;
+  readonly cssScopedCascadeFiles:number; readonly cssScopedCascadeEvidenceFiles:number; readonly cssScopedCascadeShapeEvidenceFiles:number; readonly cssScopedCascadeBlockedFiles:number; readonly cssDuplicateCascadeKeyBlockedFiles:number; readonly cssShorthandExpansionEvidenceFiles:number; readonly cssDeterministicShorthandExpansionFiles:number; readonly cssShorthandExpansionBlockedFiles:number; readonly cssDependencySurfaceFiles:number; readonly cssDependencyGraphEvidenceFiles:number; readonly cssDependencyGraphMissingProofFiles:number; readonly cssDependencyGraphBlockedFiles:number; readonly cssRuntimeDescriptorFiles:number; readonly cssRuntimeDescriptorEvidenceFiles:number; readonly cssRuntimeDescriptorBlockedFiles:number; readonly cssPropertyDescriptorFiles:number; readonly cssPropertyDescriptorEvidenceFiles:number; readonly cssPageDescriptorFiles:number; readonly cssPageDescriptorEvidenceFiles:number;
   readonly projectGraphConflicts: number; readonly projectGraphDeltaEvidenceIncluded: number; readonly projectGraphEvidenceIncluded: number; readonly outputProjectGraphConflicts:number; readonly projectGraphCssModuleUseSiteConflicts:number; readonly projectGraphDeltaConflicts: number; readonly projectGraphCssModuleUseSiteBlockers:number; readonly projectGraphLimitConflicts: number; readonly projectGraphCssModuleUseSiteGraphs:number; readonly projectGraphCssModuleUseSites:number; readonly projectGraphCssModuleImportBindings:number; readonly projectGraphPublicContractConflicts: number; readonly projectGraphSourceSpanConflicts: number;
   readonly projectGraphCompilerTypeConflicts: number; readonly projectGraphRuntimeRegionConflicts: number; readonly projectGraphScopeUseDefConflicts: number; readonly projectGraphJsxPropConflicts: number; readonly projectGraphJsxRenderRiskConflicts: number; readonly projectGraphReExportIdentityConflicts: number; readonly projectGraphModuleDeclarationShapeConflicts: number; readonly projectGraphExportAssignmentShapeConflicts: number;
   readonly projectGraphImportAttributeConflicts: number; readonly projectGraphImportTargetConflicts: number; readonly outputDiagnostics: number; readonly outputDiagnosticConflicts: number; readonly outputDiagnosticErrors: number; readonly outputDiagnosticWarnings: number; readonly outputDeclarations: number; readonly outputDeclarationBytes: number; readonly outputDeclarationConflicts: number; readonly outputDeclarationDiagnosticErrors: number; readonly outputQualityGates: number; readonly outputQualityGateConflicts: number;

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

@@ -6,6 +6,7 @@ const HtmlCssProjectMergeMissingSignals = Object.freeze({
   htmlStructuralMerge: 'html-structural-merge-proof-blocked',
   cssCascadeMerge: 'css-cascade-merge-proof-blocked',
   cssDependencyGraphEvidence: 'css-dependency-graph-evidence-missing',
+  cssRuntimeDescriptorEvidence: 'css-runtime-descriptor-evidence-missing',
   htmlCssBrowserRuntimeProof: 'html-css-browser-runtime-proof-not-available'
 });
 
@@ -16,8 +17,9 @@ function htmlCssProjectMergeMissingEvidenceRoutes(route, signals) {
     [signals.htmlIdentityEvidence]: route('prove-html-identity-evidence', 'layout-markup-identity', 'supply-stable-element-identity-and-structural-addressability-evidence'),
     [signals.cssSelectorTargetEvidence]: route('prove-css-selector-target-evidence', 'layout-style-targets', 'supply-selector-target-graph-and-rebase-evidence'),
     [signals.htmlStructuralMerge]: route('admit-html-structural-merge', 'layout-markup-graph', 'attach-source-bound-html-runtime-proof-or-fix-duplicate-identity'),
-    [signals.cssCascadeMerge]: route('admit-css-cascade-merge', 'layout-style-graph', 'supply-source-bound-css-scoped-cascade-proof'),
+    [signals.cssCascadeMerge]: route('admit-css-cascade-merge', 'layout-style-graph', 'supply-source-bound-css-shape-scoped-cascade-proof'),
     [signals.cssDependencyGraphEvidence]: route('prove-css-dependency-graph', 'layout-style-graph', 'supply-css-custom-property-animation-font-and-asset-dependency-graph'),
+    [signals.cssRuntimeDescriptorEvidence]: route('prove-css-runtime-descriptor-evidence', 'layout-style-descriptors', 'supply-property-page-typed-descriptor-source-evidence'),
     [signals.htmlCssBrowserRuntimeProof]: route('prove-html-css-browser-runtime', 'browser-proof', 'attach-source-bound-html-css-browser-runtime-proof-bundle')
   };
 }
@@ -31,6 +33,7 @@ function htmlCssProjectMergeAdmissionMatrixRows(matrixRow, signals) {
     matrixRow('html-structural-merge-admission', 'partial', ['html-structural-merge'], [signals.htmlStructuralMerge]),
     matrixRow('css-cascade-merge-admission', 'partial', ['css-cascade-merge'], [signals.cssCascadeMerge]),
     matrixRow('css-dependency-graph-evidence', 'bounded-evidence', ['css-dependency-graph'], [signals.cssDependencyGraphEvidence]),
+    matrixRow('css-runtime-descriptor-evidence', 'bounded-evidence', ['css-runtime-descriptor-evidence'], [signals.cssRuntimeDescriptorEvidence]),
     matrixRow('html-css-browser-runtime-proof', 'bounded-evidence', ['browser-runtime-proof'], [signals.htmlCssBrowserRuntimeProof])
   ];
 }
@@ -42,8 +45,9 @@ function htmlCssProjectMergeMissingEvidenceItems(summary, signals, missingEviden
   if (summary.htmlFiles && summary.htmlIdentityEvidenceFiles !== summary.htmlFiles) items.push(missingEvidenceItem({ code: signals.htmlIdentityEvidence, scope: 'layout-markup-identity', kind: 'html-identity-evidence', proofLevel: 'html-identity-evidence', action: 'review', summary: `HTML project merge has structural identity evidence for ${summary.htmlIdentityEvidenceFiles}/${summary.htmlFiles} file(s) with ${summary.htmlDuplicateIdentityEvidenceFiles ?? 0} duplicate identity evidence file(s); require parser-backed structural spans, unique explicit identity keys, and stable explicit/path identity accounting before structural admission.` }));
   if (summary.cssFiles && (summary.cssSelectorTargetEvidenceFiles !== summary.cssFiles || summary.cssSelectorTargetConflictFiles)) items.push(missingEvidenceItem({ code: signals.cssSelectorTargetEvidence, scope: 'layout-style-targets', kind: 'css-selector-target-evidence', proofLevel: 'css-selector-target-evidence', action: 'review', summary: `CSS project merge has selector-target evidence for ${summary.cssSelectorTargetEvidenceFiles}/${summary.cssFiles} file(s) with ${summary.cssSelectorTargetConflictFiles} selector target conflict(s); require selector target graph and proven rebase before target-moving merges.` }));
   if (summary.htmlBlockedFiles) items.push(missingEvidenceItem({ code: signals.htmlStructuralMerge, scope: 'layout-markup-graph', kind: 'html-structural-merge-proof', proofLevel: 'html-structural-merge', action: 'review', summary: `HTML project merge has ${summary.htmlBlockedFiles} blocked file(s); for runtime-boundary changes attach htmlRuntimeBoundaryProofsByPath[sourcePath] with exact base/worker/head/output binding, and for duplicate identity keys make explicit HTML identities unique before admission.`, suggestedInput: { htmlRuntimeBoundaryProofsByPath: true, htmlUniqueExplicitIdentityKeys: true } }));
-  if (summary.cssBlockedFiles) items.push(missingEvidenceItem({ code: signals.cssCascadeMerge, scope: 'layout-style-graph', kind: 'css-cascade-merge-proof', proofLevel: 'css-cascade-merge', action: 'review', summary: `CSS project merge has ${summary.cssBlockedFiles} blocked file(s), including ${summary.cssDuplicateCascadeKeyBlockedFiles ?? 0} duplicate cascade-key blocker(s), ${summary.cssShorthandExpansionBlockedFiles ?? 0} shorthand expansion blocker(s), and ${summary.cssScopedCascadeBlockedFiles} scoped cascade proof block(s); supply parser/cascade/scope evidence, require deterministic shorthand expansion evidence for changed box shorthands, require ordered cascade occurrence evidence for duplicate same-property declarations, require source-bound scoped cascade proofs with exact base/worker/head/output hashes for changed declarations under @media/@supports/@container/@layer/@scope or nested scopes, and keep browser claims false until runtime proof passes.` }));
-  if (summary.cssDependencySurfaceFiles && (summary.cssDependencyGraphEvidenceFiles !== summary.cssDependencySurfaceFiles || summary.cssDependencyGraphMissingProofFiles || summary.cssDependencyGraphBlockedFiles)) items.push(missingEvidenceItem({ code: signals.cssDependencyGraphEvidence, scope: 'layout-style-graph', kind: 'css-dependency-graph-evidence', proofLevel: 'css-dependency-graph', action: 'review', summary: `CSS project merge has dependency graph evidence for ${summary.cssDependencyGraphEvidenceFiles}/${summary.cssDependencySurfaceFiles} dependency-surface file(s), ${summary.cssDependencyGraphMissingProofFiles} missing dependency graph proof(s), and ${summary.cssDependencyGraphBlockedFiles} dependency blocker(s); require custom property, var() fallback, @keyframes/animation-name, @font-face, and url() asset graph evidence before cascade/browser equivalence claims.`, suggestedInput: { cssDependencyGraphEvidence: true } }));
+  if (summary.cssBlockedFiles) items.push(missingEvidenceItem({ code: signals.cssCascadeMerge, scope: 'layout-style-graph', kind: 'css-cascade-merge-proof', proofLevel: 'css-cascade-merge', action: 'review', summary: `CSS project merge has ${summary.cssBlockedFiles} blocked file(s), including ${summary.cssDuplicateCascadeKeyBlockedFiles ?? 0} duplicate cascade-key blocker(s), ${summary.cssShorthandExpansionBlockedFiles ?? 0} shorthand expansion blocker(s), ${summary.cssScopedCascadeBlockedFiles} scoped cascade proof block(s), and ${summary.cssScopedCascadeShapeEvidenceFiles ?? 0} shape-keyed scoped proof file(s); supply parser/cascade/scope evidence, require deterministic shorthand expansion evidence for changed box shorthands, require ordered cascade occurrence evidence for duplicate same-property declarations, require source-bound scoped cascade proofs with exact scope shape keys and base/worker/head/output hashes for changed declarations under @media/@supports/@container/@layer/@scope or nested scopes, and keep browser claims false until runtime proof passes.` }));
+  if (summary.cssDependencySurfaceFiles && (summary.cssDependencyGraphEvidenceFiles !== summary.cssDependencySurfaceFiles || summary.cssDependencyGraphMissingProofFiles || summary.cssDependencyGraphBlockedFiles)) items.push(missingEvidenceItem({ code: signals.cssDependencyGraphEvidence, scope: 'layout-style-graph', kind: 'css-dependency-graph-evidence', proofLevel: 'css-dependency-graph', action: 'review', summary: `CSS project merge has dependency graph evidence for ${summary.cssDependencyGraphEvidenceFiles}/${summary.cssDependencySurfaceFiles} dependency-surface file(s), ${summary.cssDependencyGraphMissingProofFiles} missing dependency graph proof(s), and ${summary.cssDependencyGraphBlockedFiles} dependency blocker(s); require custom property, var() fallback, @keyframes/animation-name, @font-face, @property, @page, and url() asset graph evidence before cascade/browser equivalence claims.`, suggestedInput: { cssDependencyGraphEvidence: true } }));
+  if (summary.cssRuntimeDescriptorFiles && (summary.cssRuntimeDescriptorEvidenceFiles !== summary.cssRuntimeDescriptorFiles || summary.cssRuntimeDescriptorBlockedFiles)) items.push(missingEvidenceItem({ code: signals.cssRuntimeDescriptorEvidence, scope: 'layout-style-descriptors', kind: 'css-runtime-descriptor-evidence', proofLevel: 'css-runtime-descriptor-evidence', action: 'review', summary: `CSS project merge has typed descriptor evidence for ${summary.cssRuntimeDescriptorEvidenceFiles}/${summary.cssRuntimeDescriptorFiles} runtime descriptor file(s), including ${summary.cssPropertyDescriptorEvidenceFiles}/${summary.cssPropertyDescriptorFiles} @property file(s) and ${summary.cssPageDescriptorEvidenceFiles}/${summary.cssPageDescriptorFiles} @page file(s); require parser-backed descriptor records, descriptor source spans, typed @property syntax/inherits/initial-value evidence, @page descriptor records, and stable at-rule shape keys before descriptor admission. Browser equivalence still requires separate cssCascadeRuntimeProofs.`, suggestedInput: { cssRuntimeDescriptorEvidence: true } }));
   if (summary.htmlCssMergedFiles && !summary.htmlCssBrowserRuntimeProofs) items.push(missingEvidenceItem({ code: signals.htmlCssBrowserRuntimeProof, scope: 'browser-proof', kind: 'browser-runtime-proof', proofLevel: 'browser-runtime-proof', action: 'review', summary: 'HTML/CSS structural source merge was available, but browser DOM/cascade/layout/runtime proof was not attached; attach htmlRuntimeBoundaryProofsByPath for HTML runtime boundaries or cssCascadeRuntimeProofs for CSS runtime at-rules such as @keyframes, @property, and @page, and keep browser equivalence claims false until proof passes.', suggestedInput: { browserRuntimeProof: true } }));
   return items;
 }
@@ -56,6 +60,7 @@ function htmlCssProjectMergeMatrixProofStatus(level, summary) {
   if (level === 'html-structural-merge') return summary.htmlFiles ? (summary.htmlBlockedFiles ? 'failed' : summary.htmlMergedFiles ? 'passed' : 'missing') : 'absent';
   if (level === 'css-cascade-merge') return summary.cssFiles ? (summary.cssBlockedFiles ? 'failed' : summary.cssMergedFiles ? 'passed' : 'missing') : 'absent';
   if (level === 'css-dependency-graph') return summary.cssDependencySurfaceFiles ? (summary.cssDependencyGraphBlockedFiles ? 'failed' : summary.cssDependencyGraphEvidenceFiles === summary.cssDependencySurfaceFiles ? 'passed' : 'missing') : 'absent';
+  if (level === 'css-runtime-descriptor-evidence') return summary.cssRuntimeDescriptorFiles ? (summary.cssRuntimeDescriptorBlockedFiles ? 'failed' : summary.cssRuntimeDescriptorEvidenceFiles === summary.cssRuntimeDescriptorFiles ? 'passed' : 'missing') : 'absent';
   if (level === 'browser-runtime-proof') return summary.htmlCssFiles ? (summary.htmlCssBrowserRuntimeProofs ? 'passed' : 'missing') : 'absent';
   return undefined;
 }

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

@@ -12,10 +12,13 @@ function htmlCssProjectSummary(files) {
     htmlRuntimeBoundaryEvidenceFiles: htmlFiles.filter(hasHtmlRuntimeBoundaryEvidence).length, htmlFrameworkBoundaryEvidenceFiles: htmlFiles.filter(hasHtmlFrameworkBoundaryEvidence).length, htmlProofGapBlockedFiles: htmlFiles.filter(hasHtmlProofGapBlockedConflict).length,
     htmlIdentityEvidenceFailedFiles: htmlFiles.filter(hasHtmlIdentityEvidenceFailure).length, cssSelectorTargetConflictFiles: cssFiles.filter(hasCssSelectorTargetConflict).length, htmlCssStructuralTargetEvidenceFailedFiles: htmlCssFiles.filter((file) => hasHtmlIdentityEvidenceFailure(file) || hasCssSelectorTargetConflict(file)).length,
     cssSelectorTargetRebasedFiles: cssFiles.filter(hasCssSelectorTargetRebase).length,
-    cssScopedCascadeFiles: cssFiles.filter(hasCssScopedCascadeScope).length, cssScopedCascadeEvidenceFiles: cssFiles.filter(hasCssScopedCascadeEvidence).length, cssScopedCascadeBlockedFiles: cssFiles.filter(hasCssScopedCascadeMissingProof).length,
+    cssScopedCascadeFiles: cssFiles.filter(hasCssScopedCascadeScope).length, cssScopedCascadeEvidenceFiles: cssFiles.filter(hasCssScopedCascadeEvidence).length, cssScopedCascadeShapeEvidenceFiles: cssFiles.filter(hasCssScopedCascadeShapeEvidence).length, cssScopedCascadeBlockedFiles: cssFiles.filter(hasCssScopedCascadeMissingProof).length,
     cssDuplicateCascadeKeyBlockedFiles: cssFiles.filter(hasCssDuplicateCascadeKeyConflict).length,
     cssShorthandExpansionEvidenceFiles: cssFiles.filter(hasCssShorthandExpansionEvidence).length, cssDeterministicShorthandExpansionFiles: cssFiles.filter(hasCssDeterministicShorthandExpansionEvidence).length, cssShorthandExpansionBlockedFiles: cssFiles.filter(hasCssShorthandExpansionBlockedConflict).length,
     cssDependencySurfaceFiles: cssFiles.filter(hasCssDependencySurface).length, cssDependencyGraphEvidenceFiles: cssFiles.filter((file) => hasCssDependencySurface(file) && hasCssDependencyGraphEvidence(file)).length, cssDependencyGraphMissingProofFiles: cssFiles.filter(hasCssDependencyGraphMissingProof).length, cssDependencyGraphBlockedFiles: cssFiles.filter(hasCssDependencyGraphBlockedConflict).length,
+    cssRuntimeDescriptorFiles: cssFiles.filter(hasCssRuntimeDescriptorSurface).length, cssRuntimeDescriptorEvidenceFiles: cssFiles.filter((file) => hasCssRuntimeDescriptorSurface(file) && hasCssRuntimeDescriptorEvidence(file)).length, cssRuntimeDescriptorBlockedFiles: cssFiles.filter(hasCssRuntimeDescriptorBlockedConflict).length,
+    cssPropertyDescriptorFiles: cssFiles.filter(hasCssPropertyDescriptorSurface).length, cssPropertyDescriptorEvidenceFiles: cssFiles.filter((file) => hasCssPropertyDescriptorSurface(file) && hasCssPropertyDescriptorEvidence(file)).length,
+    cssPageDescriptorFiles: cssFiles.filter(hasCssPageDescriptorSurface).length, cssPageDescriptorEvidenceFiles: cssFiles.filter((file) => hasCssPageDescriptorSurface(file) && hasCssPageDescriptorEvidence(file)).length,
     htmlCssBrowserRuntimeProofs: htmlCssFiles.filter(hasBrowserRuntimeProof).length
   };
 }
@@ -112,6 +115,10 @@ function hasCssScopedCascadeProof(file) {
   return [...(file?.result?.scopedCascadeProofs ?? []), ...(file?.result?.admission?.cssScopedCascadeProofs ?? file?.admission?.cssScopedCascadeProofs ?? [])]
     .some((proof) => proof?.status === 'passed' && ScopedCascadeMissingProofReasonCodes.has(proof.reasonCode));
 }
+function hasCssScopedCascadeShapeEvidence(file) {
+  return [...(file?.result?.scopedCascadeProofs ?? []), ...(file?.result?.admission?.cssScopedCascadeProofs ?? file?.admission?.cssScopedCascadeProofs ?? [])]
+    .some((proof) => proof?.status === 'passed' && ScopedCascadeMissingProofReasonCodes.has(proof.reasonCode) && typeof proof.scopedCascadeGraphShapeKey === 'string');
+}
 function cssScopedRuleCount(file) {
   const sides = Object.values(file?.result?.selectorTargetEvidence?.sides ?? {});
   return sides.reduce((count, side) => Math.max(count, side?.scopedRuleCount ?? 0), 0);
@@ -124,7 +131,7 @@ function hasCssDependencyGraphEvidence(file) {
 }
 function hasCssDependencyGraphMissingProof(file) { return hasCssDependencySurface(file) && !hasCssDependencyGraphEvidence(file); }
 function hasCssDependencyEvidenceSurface(file) {
-  return cssDependencyEvidenceRecords(file).some((evidence) => evidence.hasDependencySurface === true || (evidence.dependencySurfaceCount ?? 0) > 0 || (evidence.customPropertyDefinitions ?? 0) > 0 || (evidence.customPropertyReferences ?? 0) > 0 || (evidence.varReferences ?? 0) > 0 || (evidence.varFallbackReferences ?? 0) > 0 || (evidence.animationNameLinks ?? 0) > 0 || (evidence.keyframeLinks ?? 0) > 0 || (evidence.fontFaceLinks ?? 0) > 0 || (evidence.urlAssetReferences ?? 0) > 0);
+  return cssDependencyEvidenceRecords(file).some((evidence) => evidence.hasDependencySurface === true || (evidence.dependencySurfaceCount ?? 0) > 0 || (evidence.customPropertyDefinitions ?? 0) > 0 || (evidence.customPropertyReferences ?? 0) > 0 || (evidence.varReferences ?? 0) > 0 || (evidence.varFallbackReferences ?? 0) > 0 || (evidence.animationNameLinks ?? 0) > 0 || (evidence.keyframeLinks ?? 0) > 0 || (evidence.fontFaceLinks ?? 0) > 0 || (evidence.urlAssetReferences ?? 0) > 0 || cssDescriptorEvidenceCount(evidence) > 0);
 }
 function hasCssDependencyTextSurface(file) {
   const sourceText = cssDependencySourceText(file);
@@ -136,6 +143,26 @@ function hasCssDependencyConflictSurface(file) {
 function hasCssDependencyGraphBlockedConflict(file) {
   return cssFileConflicts(file).some((conflict) => isCssDependencyConflict(conflict) || CssDependencyMissingProofReasonCodes.has(conflict?.details?.reasonCode));
 }
+function hasCssRuntimeDescriptorSurface(file) { return hasCssPropertyDescriptorSurface(file) || hasCssPageDescriptorSurface(file); }
+function hasCssRuntimeDescriptorEvidence(file) { return hasCssPropertyDescriptorEvidence(file) || hasCssPageDescriptorEvidence(file); }
+function hasCssPropertyDescriptorSurface(file) {
+  return cssDependencyEvidenceRecords(file).some((evidence) => cssPropertyDescriptorEvidenceCount(evidence) > 0) || /@property\b/i.test(cssDependencySourceText(file));
+}
+function hasCssPageDescriptorSurface(file) {
+  return cssDependencyEvidenceRecords(file).some((evidence) => cssPageDescriptorEvidenceCount(evidence) > 0) || /@page\b/i.test(cssDependencySourceText(file));
+}
+function hasCssPropertyDescriptorEvidence(file) {
+  return cssDependencyEvidenceRecords(file).some((evidence) => (evidence.propertyRegistrations ?? 0) > 0 && (evidence.propertyRegistrationDescriptors ?? 0) > 0);
+}
+function hasCssPageDescriptorEvidence(file) {
+  return cssDependencyEvidenceRecords(file).some((evidence) => cssPageDescriptorEvidenceCount(evidence) > 0);
+}
+function hasCssRuntimeDescriptorBlockedConflict(file) {
+  return cssFileConflicts(file).some((conflict) => CssRuntimeDescriptorReasonCodes.has(conflict?.details?.reasonCode) || CssRuntimeDescriptorReasonCodes.has(conflict?.details?.proofGap?.code));
+}
+function cssDescriptorEvidenceCount(evidence) { return cssPropertyDescriptorEvidenceCount(evidence) + cssPageDescriptorEvidenceCount(evidence); }
+function cssPropertyDescriptorEvidenceCount(evidence) { return (evidence.propertyRegistrations ?? 0) + (evidence.propertyRegistrationDescriptors ?? 0); }
+function cssPageDescriptorEvidenceCount(evidence) { return (evidence.pageDescriptors ?? 0) + (evidence.pageMarginDescriptors ?? 0); }
 function cssDependencyEvidenceRecords(file) {
   const result = file?.result ?? {};
   return [result.dependencyEvidence, result.cssDependencyEvidence, result.dependencyGraphEvidence, result.cssDependencyGraphEvidence, result.parserEvidence?.dependencyEvidence, result.parserEvidence?.cssDependencyEvidence, result.parserEvidence?.dependencyGraphEvidence, result.parserEvidence?.cssDependencyGraphEvidence].filter(isPlainObject);
@@ -173,9 +200,10 @@ const ScopedCascadeMissingProofReasonCodes = new Set(['css-scoped-cascade-equiva
 const HtmlRuntimeBoundaryReasonCodes = new Set(['script-runtime-boundary', 'style-runtime-boundary', 'template-runtime-boundary', 'slot-runtime-boundary', 'custom-element-runtime-boundary', 'event-handler-runtime-boundary', 'inline-style-runtime-boundary', 'iframe-runtime-boundary', 'iframe-srcdoc-runtime-boundary', 'form-runtime-boundary', 'form-submitter-runtime-boundary', 'form-control-runtime-boundary', 'document-base-runtime-boundary', 'document-metadata-runtime-boundary', 'resource-loading-runtime-boundary']);
 const HtmlFrameworkBoundaryReasonCodes = new Set(['framework-directive-boundary', 'custom-element-runtime-boundary']);
 const CssDependencyMissingProofReasonCodes = new Set(['css-dependency-graph-evidence-missing', 'css-custom-property-dependency-graph-unproved', 'css-var-fallback-dependency-graph-unproved', 'css-animation-name-keyframes-graph-unproved', 'css-font-face-dependency-graph-unproved', 'css-url-asset-dependency-graph-unproved']);
-const CssDependencyAtRuleNames = new Set(['keyframes', 'font-face']);
-const CssDependencyCodeFragments = ['custom-property', 'var-fallback', 'variable-dependency', 'dependency-graph', 'keyframes', 'animation-name', 'font-face', 'url-asset', 'asset-dependency'];
-const CssDependencySurfacePatterns = [/(^|[;{\s])--[-_A-Za-z][\w-]*\s*:/, /\bvar\s*\(/i, /@(?:-[\w]+-)?keyframes\b/i, /(^|[;{\s])animation(?:-name)?\s*:/i, /@font-face\b/i, /\burl\s*\(/i];
+const CssDependencyAtRuleNames = new Set(['keyframes', 'font-face', 'property', 'page']);
+const CssDependencyCodeFragments = ['custom-property', 'var-fallback', 'variable-dependency', 'dependency-graph', 'keyframes', 'animation-name', 'font-face', 'url-asset', 'asset-dependency', 'property', 'page'];
+const CssRuntimeDescriptorReasonCodes = new Set(['css-runtime-descriptor-evidence-missing']);
+const CssDependencySurfacePatterns = [/(^|[;{\s])--[-_A-Za-z][\w-]*\s*:/, /\bvar\s*\(/i, /@(?:-[\w]+-)?keyframes\b/i, /(^|[;{\s])animation(?:-name)?\s*:/i, /@font-face\b/i, /@property\b/i, /@page\b/i, /\burl\s*\(/i];
 function isPlainObject(value) { return Boolean(value && typeof value === 'object' && !Array.isArray(value)); }
 
 export { htmlCssProjectSummary };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.184",
+  "version": "0.2.186",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",
@@ -63,7 +63,7 @@
   "dependencies": {
     "@shapeshift-labs/frontier-lang-c": "0.2.9",
     "@shapeshift-labs/frontier-lang-checker": "0.3.8",
-    "@shapeshift-labs/frontier-lang-css": "^0.1.22",
+    "@shapeshift-labs/frontier-lang-css": "^0.1.24",
     "@shapeshift-labs/frontier-lang-html": "^0.1.14",
     "@shapeshift-labs/frontier-lang-javascript": "0.2.9",
     "@shapeshift-labs/frontier-lang-kernel": "0.3.12",