@shapeshift-labs/frontier-lang-compiler 0.2.57 → 0.2.58

package/README.md

@@ -455,15 +455,20 @@ console.log(rustCandidate.sourceMap.mappings[0]?.semanticSymbolId); // generated
 
 `compileNativeSource` returns the import result, projection, target loss matrix cell, combined losses, readiness, evidence, output hash, and generated-output source maps. Same-language preserved output uses exact source mappings when the hash matches; generated stubs use declaration-level spans; adapter output uses adapter-supplied maps when present and otherwise gets an estimated fallback. Admission queues should treat `ok` as "code was emitted", not as merge approval; `readiness`, `targetCoverage`, and source-map precision carry the merge signal.
 
-Native projections and compile results also carry a `frontier.lang.nativeRoundtripEvidence` record under `evidence[].metadata.roundtripEvidence` and `metadata.roundtripEvidence`. That payload records import readiness/loss counts, universal AST validation and source-map precision, projection mode/hash verification, target adapter identity, target coverage, output source-map precision, and blocking/review loss ids in one coordinator-sortable JSON shape:
+Native projections and compile results also carry a `frontier.lang.nativeRoundtripEvidence` record under `evidence[].metadata.roundtripEvidence` and `metadata.roundtripEvidence`. That payload records import readiness/loss counts, universal AST validation and source-map precision, projection mode/hash verification, target adapter identity, target coverage, output source-map precision, blocking/review loss ids, and a compact audit signal in one coordinator-sortable JSON shape:
 
 ```js
 const roundtrip = rustCandidate.metadata.roundtripEvidence;
 console.log(roundtrip.status); // "blocked", "stub-only", "preserved-source", or "target-adapter"
+console.log(roundtrip.audit.disposition); // "reversible", "preserved-source", "stub-only", or "adapter-projected"
+console.log(roundtrip.audit.claim); // bounded evidence label, not a semantic equivalence proof
+console.log(roundtrip.audit.semanticEquivalenceClaim); // false
 console.log(roundtrip.output.sourceMaps.precision); // "exact", "declaration", "estimated", or "none"
 console.log(roundtrip.losses.blockingLossIds);
 ```
 
+`roundtrip.audit` separates what was emitted from whether it can be merged: hash-verified same-language output with exact generated source maps is marked `reversible`, preserved source without generated exact maps stays `preserved-source`, generated declarations are `stub-only`, and host-owned target adapters are `adapter-projected`. Blocked and needs-review readiness still flow through `status`, `semanticMergeReadiness`, `reviewRequired`, loss ids, and source-map precision; the audit signal always keeps `autoMergeClaim: false` and `semanticEquivalenceClaim: false`.
+
 Provide a target projection adapter when the host owns real native-to-target translation semantics:
 
 ```js

package/dist/declarations/roundtrip.d.ts

@@ -107,6 +107,20 @@ export type NativeRoundtripEvidenceStatus = NativeImportRoundtripReadinessStatus
 
 export type NativeRoundtripSourceMapPrecision = SourceMapMappingRecord['precision'] | 'line' | 'declaration' | 'estimated' | 'unknown' | 'none' | string;
 
+export type NativeRoundtripAuditDisposition =
+  | 'reversible'
+  | 'preserved-source'
+  | 'stub-only'
+  | 'adapter-projected'
+  | 'review-required';
+
+export type NativeRoundtripAuditClaim =
+  | 'source-text-reversible'
+  | 'source-preserved'
+  | 'declaration-stubs-only'
+  | 'host-adapter-projected'
+  | 'review-required';
+
 export interface NativeRoundtripSourceMapEvidence {
   readonly total: number;
   readonly ids: readonly string[];
@@ -120,6 +134,30 @@ export interface NativeRoundtripSourceMapEvidence {
   readonly targetPaths: readonly string[];
 }
 
+export interface NativeRoundtripAuditSignal {
+  readonly schema: 'frontier.lang.nativeRoundtripAuditSignal';
+  readonly version: 1;
+  readonly disposition: NativeRoundtripAuditDisposition;
+  readonly claim: NativeRoundtripAuditClaim;
+  readonly sourceLanguage?: FrontierSourceLanguage | string;
+  readonly target?: CompileTarget | string;
+  readonly sameLanguage: boolean;
+  readonly outputMode?: NativeSourceCompileOutputMode;
+  readonly projectionMode?: NativeSourceProjectionMode;
+  readonly sourceHashVerified: boolean;
+  readonly outputSourceMapPrecision: NativeRoundtripSourceMapPrecision;
+  readonly universalSourceMapPrecision: NativeRoundtripSourceMapPrecision;
+  readonly targetProjectionAdapterId?: string;
+  readonly targetCoverageLossClass?: ProjectionTargetLossClass | string;
+  readonly reviewRequired: boolean;
+  readonly semanticMergeReadiness: SemanticMergeReadiness;
+  readonly semanticEquivalenceClaim: false;
+  readonly autoMergeClaim: false;
+  readonly blockingLossCount: number;
+  readonly reviewLossCount: number;
+  readonly reasonCodes: readonly string[];
+}
+
 export interface NativeRoundtripEvidenceMetadata {
   readonly status: NativeRoundtripEvidenceStatus;
   readonly semanticMergeReadiness: SemanticMergeReadiness;
@@ -127,6 +165,7 @@ export interface NativeRoundtripEvidenceMetadata {
   readonly sourcePath?: string;
   readonly language?: FrontierSourceLanguage | string;
   readonly target?: CompileTarget | string;
+  readonly audit: NativeRoundtripAuditSignal;
   readonly import: {
     readonly id?: string;
     readonly readiness: SemanticMergeReadiness;

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

@@ -0,0 +1,134 @@
+import{createParadigmSemanticsLayer,createProofSpecLayer}from'@shapeshift-labs/frontier-lang-kernel';
+
+export function createLightweightSemanticLayers(input) {
+  const evidenceIds = (input.evidence ?? []).map((record) => record.id).filter(Boolean);
+  const symbols = input.semanticIndex?.symbols ?? [];
+  const mappings = (input.sourceMaps ?? []).flatMap((sourceMap) => sourceMap.mappings ?? []);
+  const lossIds = (input.losses ?? []).map((loss) => loss.id).filter(Boolean);
+  const firstSubject = symbols[0]?.id ?? input.nativeSource?.id ?? input.nativeAst?.id;
+  const firstSubjectKind = symbols[0]?.id ? 'semanticSymbol' : input.nativeSource?.id ? 'nativeSource' : 'nativeAst';
+  const proof = createProofSpecLayer({
+    id: `proof_lightweight_${input.importIdPart}`,
+    invariants: [proofInvariant(input, firstSubject, firstSubjectKind, evidenceIds, lossIds)],
+    obligations: proofObligations(input, firstSubject, firstSubjectKind, evidenceIds, lossIds),
+    artifacts: [{
+      id: `proof_artifact_review_${input.importIdPart}`,
+      kind: 'manualReview',
+      evidenceIds,
+      lossIds,
+      summary: 'Lightweight import requires host parser, checker, tests, or human review before semantic merge.'
+    }],
+    assumptions: [{
+      id: `proof_assumption_lightweight_${input.importIdPart}`,
+      scope: 'native-import',
+      subjectId: input.nativeSource?.id,
+      subjectKind: 'nativeSource',
+      evidenceIds,
+      statement: 'Native source text and scanner evidence are preserved, but executable semantics are not proven.'
+    }],
+    evidence: input.evidence ?? []
+  });
+  const paradigmSemantics = createParadigmSemanticsLayer({
+    id: `paradigm_lightweight_${input.importIdPart}`,
+    bindingScopes: [{
+      id: `binding_scope_${input.importIdPart}`,
+      kind: 'moduleScope',
+      nativeSourceId: input.nativeSource?.id,
+      evidenceIds,
+      sourcePath: input.sourcePath,
+      sourceHash: input.sourceHash
+    }],
+    bindings: symbols.slice(0, 40).map((symbol) => ({
+      id: `binding_${symbol.id}`,
+      kind: 'nativeDeclarationBinding',
+      bindingScopeId: `binding_scope_${input.importIdPart}`,
+      semanticSymbolId: symbol.id,
+      nativeSourceId: input.nativeSource?.id,
+      evidenceIds
+    })),
+    evaluationModels: [evaluationModel(input, evidenceIds)],
+    effectRegions: effectRegions(input, evidenceIds),
+    loweringRecords: mappings.slice(0, 40).map((mapping) => ({
+      id: `lowering_${mapping.id}`,
+      kind: 'nativeSourceToFrontierSemanticIndex',
+      sourceMapId: mapping.sourceMapId,
+      sourceMapMappingId: mapping.id,
+      semanticSymbolId: mapping.semanticSymbolId,
+      nativeAstNodeId: mapping.nativeAstNodeId,
+      evidenceIds,
+      lossIds
+    })),
+    macroExpansions: macroBoundaryRecords(input, evidenceIds, lossIds),
+    reflectionBoundaries: reflectionBoundaryRecords(input, evidenceIds, lossIds),
+    evidence: input.evidence ?? []
+  });
+  return { proof, paradigmSemantics };
+}
+
+function proofInvariant(input, subjectId, subjectKind, evidenceIds, lossIds) {
+  return {
+    id: `proof_invariant_source_hash_${input.importIdPart}`,
+    kind: 'sourceHashFreshness',
+    subjectId,
+    subjectKind,
+    evidenceIds,
+    lossIds,
+    statement: 'Semantic merge candidates must match the preserved source hash before admission.'
+  };
+}
+
+function proofObligations(input, subjectId, subjectKind, evidenceIds, lossIds) {
+  return [
+    {
+      id: `proof_obligation_review_${input.importIdPart}`,
+      kind: 'semanticMergeReview',
+      status: 'open',
+      subjectId,
+      subjectKind,
+      contractIds: [`proof_invariant_source_hash_${input.importIdPart}`],
+      evidenceIds,
+      lossIds,
+      statement: 'Review ownership, source maps, losses, and focused tests before applying this semantic patch.'
+    },
+    {
+      id: `proof_obligation_external_semantics_${input.importIdPart}`,
+      kind: 'externalSemanticEquivalence',
+      status: 'external-tool-required',
+      subjectId,
+      subjectKind,
+      evidenceIds,
+      lossIds,
+      statement: 'Cross-language executable equivalence requires a target checker, oracle, or proof artifact.'
+    }
+  ];
+}
+
+function evaluationModel(input, evidenceIds) {
+  const language = String(input.language ?? 'unknown').toLowerCase();
+  const kind = ['javascript', 'typescript', 'python', 'ruby', 'php', 'lua'].includes(language)
+    ? 'dynamicRuntime'
+    : ['rust', 'c', 'cpp', 'c++', 'zig'].includes(language)
+      ? 'compileTimeOwnershipRuntime'
+      : 'languageRuntime';
+  return { id: `evaluation_model_${input.importIdPart}`, kind, nativeSourceId: input.nativeSource?.id, evidenceIds };
+}
+
+function effectRegions(input, evidenceIds) {
+  const predicates = new Set((input.semanticIndex?.relations ?? []).map((relation) => relation.predicate));
+  return [...predicates].filter((predicate) => ['calls', 'imports', 'uses', 'requires'].includes(predicate)).map((predicate) => ({
+    id: `effect_region_${input.importIdPart}_${predicate}`,
+    kind: `${predicate}DependencyEffect`,
+    nativeSourceId: input.nativeSource?.id,
+    evidenceIds
+  }));
+}
+
+function macroBoundaryRecords(input, evidenceIds, lossIds) {
+  const hasMacroLoss = (input.losses ?? []).some((loss) => ['macroExpansion', 'preprocessor', 'metaprogramming'].includes(loss.kind));
+  return hasMacroLoss ? [{ id: `macro_boundary_${input.importIdPart}`, kind: 'reviewRequiredMacroBoundary', nativeSourceId: input.nativeSource?.id, evidenceIds, lossIds }] : [];
+}
+
+function reflectionBoundaryRecords(input, evidenceIds, lossIds) {
+  const hasReflectionLoss = (input.losses ?? []).some((loss) => ['dynamicRuntime', 'reflection', 'opaqueNative'].includes(loss.kind));
+  return hasReflectionLoss ? [{ id: `reflection_boundary_${input.importIdPart}`, kind: 'reviewRequiredDynamicBoundary', nativeSourceId: input.nativeSource?.id, evidenceIds, lossIds }] : [];
+}

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

@@ -24,7 +24,26 @@ export function createNativeRoundtripEvidence(importResult,options={}) {
   const outputMode=options.outputMode??options.targetProjection?.outputMode??projection?.mode;
   const sourceHashVerified=Boolean(projection?.sourceHash&&projection?.outputHash===projection.sourceHash)||projection?.metadata?.sourceHashVerified===true;
   const status=semanticMerge==='blocked'?'blocked':outputMode==='target-adapter'?'target-adapter':projection?.mode==='native-source-stubs'||outputMode==='target-stubs'?'stub-only':sourceHashVerified?'preserved-source':'needs-review';
+  const universalSourceMapEvidence=summarizeSourceMaps(universalSourceMaps);
   const sourceMapEvidence=summarizeSourceMaps(hasOutputSourceMaps?outputSourceMaps:universalSourceMaps);
+  const sourceLanguage=projection?.language??importResult.language;
+  const target=options.target??options.targetCoverage?.target??options.targetProjection?.target;
+  const audit=createRoundtripAudit({
+    status,
+    semanticMerge,
+    sourceLanguage,
+    target,
+    sameLanguage:Boolean(sourceLanguage&&target&&String(sourceLanguage)===String(target)),
+    outputMode,
+    projectionMode:projection?.mode,
+    sourceHashVerified,
+    hasOutputSourceMaps,
+    sourceMapEvidence,
+    universalSourceMapEvidence,
+    targetProjection:options.targetProjection,
+    targetCoverage:options.targetCoverage,
+    lossSummary
+  });
   const metadata={
     schema:'frontier.lang.nativeRoundtripEvidence',
     version:1,
@@ -33,8 +52,9 @@ export function createNativeRoundtripEvidence(importResult,options={}) {
       semanticMergeReadiness:semanticMerge,
       reviewRequired:semanticMerge!=='ready',
       sourcePath:projection?.sourcePath??importResult.sourcePath,
-      language:projection?.language??importResult.language,
-      target:options.target??options.targetCoverage?.target??options.targetProjection?.target,
+      language:sourceLanguage,
+      target,
+      audit,
       import:{
         id:importResult.id,
         readiness:importReadiness,
@@ -49,7 +69,7 @@ export function createNativeRoundtripEvidence(importResult,options={}) {
         issues:universalIssues,
         nativeSources:universalAst?.nativeSources?.length??importResult.nativeSources?.length??(importResult.nativeSource?1:0),
         semanticSymbols:(importResult.semanticIndex??universalAst?.semanticIndex)?.symbols?.length??0,
-        sourceMaps:summarizeSourceMaps(universalSourceMaps)
+        sourceMaps:universalSourceMapEvidence
       },
       projection:{
         id:projection?.id,
@@ -115,3 +135,55 @@ function summarizeSourceMaps(sourceMaps){
 }
 function normalizePrecision(value){const precision=String(value??'unknown');return Object.prototype.hasOwnProperty.call(precisionRank,precision)?precision:'unknown';}
 function worstPrecision(precisions){if(!precisions.length)return'none';return precisions.reduce((worst,next)=>precisionRank[next]>precisionRank[worst]?next:worst,'exact');}
+function createRoundtripAudit(input){
+  const disposition=roundtripAuditDisposition(input);
+  return{
+    schema:'frontier.lang.nativeRoundtripAuditSignal',
+    version:1,
+    disposition,
+    claim:roundtripAuditClaim(disposition),
+    sourceLanguage:input.sourceLanguage,
+    target:input.target,
+    sameLanguage:input.sameLanguage,
+    outputMode:input.outputMode,
+    projectionMode:input.projectionMode,
+    sourceHashVerified:input.sourceHashVerified,
+    outputSourceMapPrecision:input.sourceMapEvidence.precision,
+    universalSourceMapPrecision:input.universalSourceMapEvidence.precision,
+    targetProjectionAdapterId:input.targetProjection?.adapter?.id,
+    targetCoverageLossClass:input.targetCoverage?.lossClass,
+    reviewRequired:input.semanticMerge!=='ready',
+    semanticMergeReadiness:input.semanticMerge,
+    semanticEquivalenceClaim:false,
+    autoMergeClaim:false,
+    blockingLossCount:input.lossSummary.blockingLossIds.length,
+    reviewLossCount:input.lossSummary.reviewLossIds.length,
+    reasonCodes:uniqueStrings([
+      `status:${input.status}`,
+      `semantic:${input.semanticMerge}`,
+      `output:${input.outputMode??'unknown'}`,
+      `projection:${input.projectionMode??'unknown'}`,
+      input.sourceHashVerified?'source-hash:verified':'source-hash:unverified',
+      `output-source-map:${input.sourceMapEvidence.precision}`,
+      `universal-source-map:${input.universalSourceMapEvidence.precision}`,
+      input.targetCoverage?.lossClass?`target-loss:${input.targetCoverage.lossClass}`:undefined,
+      input.targetProjection?.adapter?.id?`target-adapter:${input.targetProjection.adapter.id}`:undefined,
+      input.lossSummary.blockingLossIds.length?'losses:blocking':undefined,
+      input.lossSummary.reviewLossIds.length?'losses:review':undefined
+    ])
+  };
+}
+function roundtripAuditDisposition(input){
+  if(input.outputMode==='target-adapter')return'adapter-projected';
+  if(input.projectionMode==='native-source-stubs'||input.outputMode==='target-stubs')return'stub-only';
+  if(input.sourceHashVerified&&input.outputMode==='preserved-source'&&input.hasOutputSourceMaps&&input.sourceMapEvidence.precision==='exact')return'reversible';
+  if(input.sourceHashVerified||input.projectionMode==='preserved-source')return'preserved-source';
+  return'review-required';
+}
+function roundtripAuditClaim(disposition){
+  if(disposition==='reversible')return'source-text-reversible';
+  if(disposition==='preserved-source')return'source-preserved';
+  if(disposition==='stub-only')return'declaration-stubs-only';
+  if(disposition==='adapter-projected')return'host-adapter-projected';
+  return'review-required';
+}

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

@@ -1,5 +1,6 @@
 import{commonGeneratedTargetPath,idFragment}from'../../native-import-utils.js';import{inferSourceMapMappings,normalizeSourceMapMappings,normalizeSourceMaps}from'../../native-source-maps.js';import{createKernelSourcePreservationRecords,summarizeKernelSourcePreservationRecords}from'../../semantic-import-source-preservation.js';import{createDocument,createImportResult,createNativeAstRecord,createPatch,createSourceMapRecord,createUniversalAstEnvelope,hashSemanticValue,nativeSourceNode}from'@shapeshift-labs/frontier-lang-kernel';
 import{attachInputUniversalDialectRegistry}from'../../universal-dialect-registry.js';
+import{createLightweightSemanticLayers}from'./createLightweightSemanticLayers.js';
 import{attachNativeImportLossSummary}from'./attachNativeImportLossSummary.js';import{createLightweightNativeImport}from'./createLightweightNativeImport.js';import{createNativeSourcePreservation}from'./createNativeSourcePreservation.js';import{hasNativeExactAstEvidence}from'./hasNativeExactAstEvidence.js';import{normalizeNativeLossRecords}from'./normalizeNativeLossRecords.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';import{unverifiedNativeAstLosses}from'./unverifiedNativeAstLosses.js';import{withNativeImportReadiness}from'./withNativeImportReadiness.js';
 export function importNativeSource(input) {
   const language = input.language ?? input.nativeAst?.language;
@@ -216,6 +217,7 @@ export function importNativeSource(input) {
   });
   const kernelSourcePreservationSummary = summarizeKernelSourcePreservationRecords(sourcePreservationRecords);
   const resultSourceMapMappings = sourceMaps.flatMap((sourceMap) => sourceMap.mappings ?? []);
+  const semanticLayers=input.semanticLayers??createLightweightSemanticLayers({importIdPart,language,sourcePath,sourceHash,nativeSource,nativeAst,semanticIndex,sourceMaps,losses,evidence,sourcePreservationRecords});
   let universalAst = createUniversalAstEnvelope({
     id: input.universalAstId ?? `universal_ast_${importIdPart}`,
     document,
@@ -224,6 +226,7 @@ export function importNativeSource(input) {
     sourceMaps,
     losses,
     evidence,
+    proof:input.proof??input.universalAstProof??semanticLayers.proof,paradigmSemantics:input.paradigmSemantics??input.universalAstParadigmSemantics??semanticLayers.paradigmSemantics,
     metadata: {
       sourceLanguage: language,
       sourcePath,

package/examples/js-frontier-rust-workbench-html.mjs

@@ -41,7 +41,9 @@ export function renderWorkbenchHtml(initialState) {
           <h2>TypeScript</h2>
           <span id="typescriptStatus">source</span>
         </div>
-        <textarea id="typescriptInput" spellcheck="false" aria-label="TypeScript source"></textarea>
+        <div class="paneBody editorBody">
+          <textarea id="typescriptInput" spellcheck="false" aria-label="TypeScript source"></textarea>
+        </div>
       </section>
 
       <section class="pane graphPane" data-view-panel="frontier">
@@ -52,8 +54,8 @@ export function renderWorkbenchHtml(initialState) {
             <button data-frontier-tab="json" aria-pressed="false">JSON</button>
           </div>
         </div>
-        <div id="graphView" class="graphView"></div>
-        <pre id="frontierJson" class="codeBlock" hidden></pre>
+        <div id="graphView" class="paneBody graphView"></div>
+        <pre id="frontierJson" class="paneBody codeBlock" hidden></pre>
       </section>
 
       <section class="pane outputPane" data-view-panel="rust">
@@ -61,7 +63,9 @@ export function renderWorkbenchHtml(initialState) {
           <h2>Rust</h2>
           <span id="rustStatus">target</span>
         </div>
-        <textarea id="rustInput" spellcheck="false" aria-label="Rust source"></textarea>
+        <div class="paneBody editorBody">
+          <textarea id="rustInput" spellcheck="false" aria-label="Rust source"></textarea>
+        </div>
       </section>
     </section>
   </main>

package/examples/js-frontier-rust-workbench-styles.mjs

@@ -25,6 +25,7 @@ export function workbenchStyles() {
 * { box-sizing: border-box; }
 html, body { height: 100%; margin: 0; }
 body {
+  width: 100%;
   background: var(--bg);
   color: var(--text);
   font-family: var(--ui);
@@ -33,6 +34,7 @@ body {
 
 .appShell {
   height: 100vh;
+  height: 100dvh;
   overflow: hidden;
 }
 
@@ -97,23 +99,37 @@ body {
   display: grid;
   grid-template-columns: repeat(4, minmax(0, 1fr));
   background: #0f1214;
+  overflow: hidden;
 }
 .statusStrip div {
   min-width: 0;
+  min-height: 0;
   padding: 8px 14px;
   border-right: 1px solid var(--line);
+  overflow: hidden;
 }
 .label {
   display: block;
   color: var(--faint);
   font-size: 10px;
+  line-height: 1.1;
   text-transform: uppercase;
 }
-.statusStrip strong { font-size: 13px; font-weight: 650; }
+.statusStrip strong {
+  display: block;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-size: 13px;
+  font-weight: 650;
+  line-height: 1.2;
+}
 
 .workspace {
   position: fixed;
   inset: var(--chrome-height) 0 0 0;
+  height: calc(100vh - var(--chrome-height));
+  height: calc(100dvh - var(--chrome-height));
   min-height: 0;
   display: grid;
   grid-template-columns: minmax(270px, 0.95fr) minmax(330px, 1.1fr) minmax(300px, 1fr);
@@ -131,6 +147,20 @@ body {
 }
 .pane:last-child { border-right: 0; }
 .pane.isSource .paneHeader { box-shadow: inset 0 -2px 0 var(--green); }
+.paneBody {
+  grid-row: 2;
+  grid-column: 1;
+  min-width: 0;
+  min-height: 0;
+  height: 100%;
+  max-height: 100%;
+  overflow: auto;
+  overscroll-behavior: contain;
+  scrollbar-gutter: stable;
+}
+.editorBody {
+  overflow: hidden;
+}
 .paneHeader {
   justify-content: space-between;
   padding: 0 12px;
@@ -140,6 +170,7 @@ body {
 .paneHeader span { color: var(--muted); font-size: 12px; font-family: var(--mono); }
 
 textarea, .codeBlock {
+  display: block;
   width: 100%;
   height: 100%;
   min-height: 0;
@@ -160,18 +191,10 @@ textarea, .codeBlock {
 }
 
 .graphView {
-  grid-row: 2;
-  grid-column: 1;
-  min-height: 0;
-  max-height: 100%;
-  overflow: auto;
-  overscroll-behavior: contain;
   padding: 12px;
 }
-#frontierJson {
-  grid-row: 2;
-  grid-column: 1;
-  min-width: 0;
+#graphView[hidden], #frontierJson[hidden] {
+  display: none;
 }
 .graphGrid {
   display: grid;

package/package.json

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