@shapeshift-labs/frontier-lang-compiler 0.2.124 → 0.2.126

package/README.md

@@ -308,9 +308,13 @@ On a local Node v26.1.0 smoke fixture with 10 small JS/TS files and 36 scanned
 stage files for the delta case, baseline project merge JSON was 115 KB at a
 21.6 ms median. `includeOutputProjectSymbolGraph` raised the returned JSON to
 17.8 MB at a 303.1 ms median, and `includeProjectGraphDelta` raised it to
-83.0 MB at a 1,466.8 ms median. Keep these paths behind admission-queue caps
-for file count, total source bytes, graph edge count, and serialized artifact
-bytes, or expose summary/lazy graph materialization before using them broadly.
+83.0 MB at a 1,466.8 ms median. Pass `projectGraphLimits` for admission queues:
+`maxFiles`, `maxSourceBytes`, `maxImportEdges`, `maxExportEdges`, and
+`maxSerializedBytes` produce `project-graph-limit-exceeded` conflicts with the
+stage, limit kind, actual value, and configured limit. Limit failures block
+admission and omit oversized project graph artifacts from the returned result.
+Invalid limits such as negative numbers, `NaN`, or infinity fail closed with
+`project-graph-limit-invalid`.
 
 High-risk native features also have explicit evidence policies. These policies are advisory in this package: they tell a swarm or admission queue what evidence is missing without silently changing the existing readiness classification.
 

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

@@ -53,6 +53,22 @@ export type JsTsProjectSafeMergeOutputProjectImports =
 
 export type JsTsProjectGraphStageName = 'base' | 'worker' | 'head' | 'output' | string;
 
+export type JsTsProjectGraphLimitKind =
+  | 'source-files'
+  | 'source-bytes'
+  | 'import-edges'
+  | 'export-edges'
+  | 'serialized-bytes'
+  | string;
+
+export interface JsTsProjectGraphLimits {
+  readonly maxFiles?: number;
+  readonly maxSourceBytes?: number;
+  readonly maxImportEdges?: number;
+  readonly maxExportEdges?: number;
+  readonly maxSerializedBytes?: number;
+}
+
 export type JsTsProjectSafeMergeProjectGraphImportsByStage = Readonly<{
   base?: JsTsProjectSafeMergeOutputProjectImports;
   worker?: JsTsProjectSafeMergeOutputProjectImports;
@@ -72,6 +88,7 @@ export interface JsTsProjectSafeMergeInput {
   readonly allowFileDeletes?: boolean;
   readonly includeOutputProjectSymbolGraph?: boolean;
   readonly includeProjectGraphDelta?: boolean;
+  readonly projectGraphLimits?: JsTsProjectGraphLimits;
   readonly outputProjectImports?: JsTsProjectSafeMergeOutputProjectImports;
   readonly baseProjectImports?: JsTsProjectSafeMergeOutputProjectImports;
   readonly workerProjectImports?: JsTsProjectSafeMergeOutputProjectImports;
@@ -132,6 +149,7 @@ export interface JsTsProjectSafeMergeAdmission {
 export interface JsTsProjectGraphDeltaStageSummary {
   readonly stage: JsTsProjectGraphStageName;
   readonly sourceFiles: number;
+  readonly sourceBytes: number;
   readonly documents: number;
   readonly symbols: number;
   readonly fileHashes: number;
@@ -143,6 +161,8 @@ export interface JsTsProjectGraphDeltaStageSummary {
   readonly suppliedImports: number;
   readonly matchedSuppliedImports: number;
   readonly scannerFallbackImports: number;
+  readonly serializedBytes?: number;
+  readonly limitConflicts: number;
 }
 
 export interface JsTsProjectGraphDeltaStage {
@@ -152,6 +172,7 @@ export interface JsTsProjectGraphDeltaStage {
   readonly projectImport?: NativeProjectImportResult;
   readonly projectSymbolGraph?: NativeProjectSymbolGraphSummary;
   readonly summary: JsTsProjectGraphDeltaStageSummary;
+  readonly limitConflicts?: readonly JsTsSafeMergeConflict[];
 }
 
 export interface JsTsProjectGraphDeltaSummary {
@@ -165,6 +186,9 @@ export interface JsTsProjectGraphDeltaSummary {
   readonly suppliedImports: number;
   readonly matchedSuppliedImports: number;
   readonly scannerFallbackImports: number;
+  readonly sourceBytes: number;
+  readonly serializedBytes: number;
+  readonly limitConflicts: number;
   readonly conflicts: number;
   readonly publicContractConflicts: number;
   readonly reExportIdentityConflicts: number;
@@ -201,6 +225,7 @@ export interface JsTsProjectSafeMergeResult {
     readonly projectGraphConflicts: number;
     readonly outputProjectGraphConflicts: number;
     readonly projectGraphDeltaConflicts: number;
+    readonly projectGraphLimitConflicts: number;
     readonly projectGraphPublicContractConflicts: number;
     readonly projectGraphReExportIdentityConflicts: number;
     readonly projectGraphImportTargetConflicts: number;

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

@@ -200,6 +200,7 @@ function validateCrossSideAddedNames(workerPlan, headPlan, context) {
       const nameKey = `${entry.kind}:${name}`;
       const headEntry = headEntriesByName.get(nameKey);
       if (headEntry) {
+        if (shouldDeferReExportNameConflict(entry, headEntry, context)) continue;
         const typeAliasConflict = entry.declarationInfo?.declarationKind === 'type'
           || headEntry.declarationInfo?.declarationKind === 'type';
         addConflict(context, {
@@ -216,6 +217,16 @@ function validateCrossSideAddedNames(workerPlan, headPlan, context) {
   }
 }
 
+function shouldDeferReExportNameConflict(left, right, context) {
+  return context.deferReExportIdentityConflictsToProjectGraph === true
+    && isReExportEntry(left)
+    && isReExportEntry(right);
+}
+
+function isReExportEntry(entry) {
+  return entry?.kind === 'export' && entry.declarationInfo?.reExport === true;
+}
+
 function validateCrossSideImportAdditions(workerPlan, headPlan, context) {
   for (const [key, workerAdditions] of workerPlan.importAdditions) {
     const headAdditions = headPlan.importAdditions.get(key) ?? [];

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

@@ -5,6 +5,7 @@ export function createMergeContext(input) {
     id: String(input.id ?? 'js_ts_safe_merge'),
     sourcePath: input.sourcePath,
     language: input.language ?? 'typescript',
+    deferReExportIdentityConflictsToProjectGraph: input.deferReExportIdentityConflictsToProjectGraph === true,
     conflicts: [],
     blockedGateIds: new Set(),
     gateReasonCodes: new Map()

package/dist/js-ts-safe-merge-ledger-validation.js

@@ -24,6 +24,7 @@ export function validateLedgerUniqueness(ledger, context) {
       const nameKey = `${entry.kind}:${name}`;
       const existing = nameOwners.get(nameKey);
       if (existing) {
+        if (shouldDeferMergedReExportNameConflict(ledger, existing, entry, context)) continue;
         addConflict(context, {
           code: JsTsSafeMergeConflictCodes.duplicateName,
           gateId: JsTsSafeMergeGateIds.uniqueNames,
@@ -65,6 +66,17 @@ function validateUniqueImportSpecifiers(entry, side, context) {
   }
 }
 
+function shouldDeferMergedReExportNameConflict(ledger, left, right, context) {
+  return ledger.label === 'merged'
+    && context.deferReExportIdentityConflictsToProjectGraph === true
+    && isReExportEntry(left)
+    && isReExportEntry(right);
+}
+
+function isReExportEntry(entry) {
+  return entry?.kind === 'export' && entry.declarationInfo?.reExport === true;
+}
+
 export function indexBaseLedger(base, context) {
   const entriesByKey = new Map();
   for (const entry of base.entries) entriesByKey.set(entry.key, entry);

package/dist/js-ts-safe-merge-parse-declarations.js

@@ -19,7 +19,7 @@ export function classifyStatement(text, start, end) {
     if (unsupported) return { unsupported, text, start, end };
     return {
       kind: declarationInfo.kind,
-      key: `${declarationInfo.kind}:${declarationInfo.names.join('|')}`,
+      key: declarationLedgerKey(declarationInfo),
       text,
       start,
       end,
@@ -126,6 +126,50 @@ function parseDeclarationInfo(text) {
   const defaultClass = trimmed.match(/^export\s+default\s+(?:abstract\s+)?class(?:\s+([A-Za-z_$][\w$]*))?\b/);
   if (defaultClass) return { kind: 'declaration', names: ['default'], declarationKind: 'class', exported: true, defaultExport: true };
 
+  const namespaceReExport = trimmed.match(/^export\s+(type\s+)?\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s+(['"])([^'"]+)\3\s*;?$/);
+  if (namespaceReExport) {
+    return {
+      kind: 'export',
+      names: [namespaceReExport[2]],
+      declarationKind: 're-export-namespace',
+      exported: true,
+      typeOnly: Boolean(namespaceReExport[1]),
+      reExport: true,
+      moduleSpecifier: namespaceReExport[4],
+      namespace: namespaceReExport[2]
+    };
+  }
+
+  const starReExport = trimmed.match(/^export\s+(type\s+)?\*\s+from\s+(['"])([^'"]+)\2\s*;?$/);
+  if (starReExport) {
+    return {
+      kind: 'export',
+      names: [],
+      declarationKind: 're-export-star',
+      exported: true,
+      typeOnly: Boolean(starReExport[1]),
+      reExport: true,
+      moduleSpecifier: starReExport[3],
+      exportStar: true
+    };
+  }
+
+  const namedReExport = trimmed.match(/^export\s+(type\s+)?\{([\s\S]+)\}\s+from\s+(['"])([^'"]+)\3\s*;?$/);
+  if (namedReExport) {
+    const names = splitCommaList(namedReExport[2]).map((part) => parseExportSpecifierName(part)).filter(Boolean);
+    const expectedCount = splitCommaList(namedReExport[2]).filter((part) => part.trim()).length;
+    if (names.length !== expectedCount || names.length === 0) return undefined;
+    return {
+      kind: 'export',
+      names,
+      declarationKind: 're-export-list',
+      exported: true,
+      typeOnly: Boolean(namedReExport[1]),
+      reExport: true,
+      moduleSpecifier: namedReExport[4]
+    };
+  }
+
   const namedExport = trimmed.match(/^export\s+(type\s+)?\{([\s\S]+)\}\s*;?$/);
   if (namedExport) {
     const names = splitCommaList(namedExport[2]).map((part) => parseExportSpecifierName(part)).filter(Boolean);
@@ -154,6 +198,19 @@ function parseDeclarationInfo(text) {
   return undefined;
 }
 
+function declarationLedgerKey(declarationInfo) {
+  if (declarationInfo.reExport) {
+    return [
+      declarationInfo.kind,
+      declarationInfo.declarationKind,
+      declarationInfo.moduleSpecifier ?? '',
+      declarationInfo.typeOnly ? 'type' : 'value',
+      declarationInfo.exportStar ? '*' : declarationInfo.names.join('|')
+    ].join(':');
+  }
+  return `${declarationInfo.kind}:${declarationInfo.names.join('|')}`;
+}
+
 function unsupportedDeclarationPolicy(text, declarationInfo) {
   const trimmed = text.trim();
   if (/^\s*@/m.test(text)) {

package/dist/js-ts-safe-project-merge-graph-conflicts.js

@@ -2,6 +2,8 @@ import { compactRecord } from './js-ts-safe-merge-context.js';
 import { projectGraphDeltaConflicts } from './js-ts-safe-project-merge-graph-delta-conflicts.js';
 
 function outputProjectGraphConflicts(projectSymbolGraph) {
+  const limitConflicts = Array.isArray(projectSymbolGraph?.limitConflicts) ? projectSymbolGraph.limitConflicts : [];
+  projectSymbolGraph = projectSymbolGraph?.projectSymbolGraph ?? projectSymbolGraph;
   const importEdges = Array.isArray(projectSymbolGraph?.importEdges) ? projectSymbolGraph.importEdges : [];
   const missingModuleGroups = new Map();
   const missingSymbolGroups = new Map();
@@ -21,6 +23,7 @@ function outputProjectGraphConflicts(projectSymbolGraph) {
     }
   }
   return [
+    ...limitConflicts,
     ...[...missingModuleGroups.values()].map(projectGraphMissingImportConflict),
     ...[...missingSymbolGroups.values()].map(projectGraphMissingTargetConflict)
   ];

package/dist/js-ts-safe-project-merge-graph-delta-conflicts.js

@@ -2,12 +2,14 @@ import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { compactRecord } from './js-ts-safe-merge-context.js';
 
 function projectGraphDeltaConflicts(projectGraphDelta) {
+  const limitConflicts = projectGraphDeltaLimitConflicts(projectGraphDelta);
   const baseGraph = projectGraphDelta?.stages?.base?.projectSymbolGraph;
   const workerGraph = projectGraphDelta?.stages?.worker?.projectSymbolGraph;
   const headGraph = projectGraphDelta?.stages?.head?.projectSymbolGraph;
   const outputGraph = projectGraphDelta?.stages?.output?.projectSymbolGraph;
-  if (!baseGraph || !workerGraph || !headGraph) return [];
+  if (!baseGraph || !workerGraph || !headGraph) return limitConflicts;
   return [
+    ...limitConflicts,
     ...changedIdentityConflicts({
       code: 'project-public-contract-delta-conflict',
       label: 'public contract',
@@ -43,11 +45,16 @@ function addProjectGraphDeltaConflictSummary(projectGraphDelta, conflicts) {
       conflicts: conflicts.length,
       publicContractConflicts: conflicts.filter((conflict) => conflict.code === 'project-public-contract-delta-conflict').length,
       reExportIdentityConflicts: conflicts.filter((conflict) => conflict.code === 'project-re-export-identity-delta-conflict').length,
-      importTargetConflicts: conflicts.filter((conflict) => conflict.code === 'project-import-target-delta-conflict').length
+      importTargetConflicts: conflicts.filter((conflict) => conflict.code === 'project-import-target-delta-conflict').length,
+      limitConflicts: conflicts.filter((conflict) => conflict.code === 'project-graph-limit-exceeded').length
     }
   };
 }
 
+function projectGraphDeltaLimitConflicts(projectGraphDelta) {
+  return Object.values(projectGraphDelta?.stages ?? {}).flatMap((stage) => stage?.limitConflicts ?? []);
+}
+
 function changedIdentityConflicts(input) {
   const base = recordsByIdentityKey(input.baseRecords, input.identityKey);
   const worker = recordsByIdentityKey(input.workerRecords, input.identityKey);

package/dist/js-ts-safe-project-merge-graph-limits.js

@@ -0,0 +1,117 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+const encoder = typeof TextEncoder === 'function' ? new TextEncoder() : undefined;
+const PROJECT_GRAPH_LIMIT_CODE = 'project-graph-limit-exceeded';
+const PROJECT_GRAPH_INVALID_LIMIT_CODE = 'project-graph-limit-invalid';
+const LIMIT_FIELDS = [
+  ['maxFiles', 'source-files'],
+  ['maxSourceBytes', 'source-bytes'],
+  ['maxImportEdges', 'import-edges'],
+  ['maxExportEdges', 'export-edges'],
+  ['maxSerializedBytes', 'serialized-bytes']
+];
+
+function normalizeProjectGraphLimits(value) {
+  if (!value || typeof value !== 'object') return {};
+  const limits = {};
+  const invalidLimits = [];
+  for (const [field, limitKind] of LIMIT_FIELDS) {
+    if (!Object.prototype.hasOwnProperty.call(value, field) || value[field] === undefined) continue;
+    const normalized = normalizeLimit(value[field]);
+    if (normalized === undefined) invalidLimits.push({ field, limitKind, value: String(value[field]), valueType: typeof value[field] });
+    else limits[field] = normalized;
+  }
+  return compactRecord({ ...limits, invalidLimits: invalidLimits.length ? invalidLimits : undefined });
+}
+
+function projectGraphSourceStats(files) {
+  return {
+    sourceFiles: files.length,
+    sourceBytes: files.reduce((total, file) => total + utf8ByteLength(file?.sourceText ?? ''), 0)
+  };
+}
+
+function projectGraphSourceLimitConflicts(limits, stage, stats) {
+  return [
+    ...projectGraphInvalidLimitConflicts(limits, stage),
+    limitConflict(limits.maxFiles, stage, 'source-files', stats.sourceFiles),
+    limitConflict(limits.maxSourceBytes, stage, 'source-bytes', stats.sourceBytes)
+  ].filter(Boolean);
+}
+
+function projectGraphInvalidLimitConflicts(limits, stage) {
+  return (limits.invalidLimits ?? []).map((invalid) => ({
+    code: PROJECT_GRAPH_INVALID_LIMIT_CODE,
+    gateId: 'project-graph-limit',
+    message: `Project graph ${stage} stage received invalid ${invalid.limitKind} limit ${JSON.stringify(invalid.value)}.`,
+    details: compactRecord({
+      reasonCode: PROJECT_GRAPH_INVALID_LIMIT_CODE,
+      conflictKey: `project-graph-limit#${stage}#${invalid.limitKind}#invalid`,
+      stage,
+      limitKind: invalid.limitKind,
+      limitField: invalid.field,
+      limitValue: invalid.value,
+      limitValueType: invalid.valueType
+    })
+  }));
+}
+
+function projectGraphEdgeLimitConflicts(limits, stage, projectSymbolGraph) {
+  const importEdges = Array.isArray(projectSymbolGraph?.importEdges) ? projectSymbolGraph.importEdges.length : 0;
+  const exportEdges = Array.isArray(projectSymbolGraph?.exportEdges) ? projectSymbolGraph.exportEdges.length : 0;
+  return [
+    limitConflict(limits.maxImportEdges, stage, 'import-edges', importEdges),
+    limitConflict(limits.maxExportEdges, stage, 'export-edges', exportEdges)
+  ].filter(Boolean);
+}
+
+function projectGraphSerializedLimitConflict(limits, stage, artifact) {
+  const serializedBytes = serializedByteLength(artifact);
+  return {
+    serializedBytes,
+    conflict: limitConflict(limits.maxSerializedBytes, stage, 'serialized-bytes', serializedBytes)
+  };
+}
+
+function limitConflict(limit, stage, limitKind, actual) {
+  if (limit === undefined || actual <= limit) return undefined;
+  return {
+    code: PROJECT_GRAPH_LIMIT_CODE,
+    gateId: 'project-graph-limit',
+    message: `Project graph ${stage} stage exceeded ${limitKind} limit: ${actual} > ${limit}.`,
+    details: compactRecord({
+      reasonCode: PROJECT_GRAPH_LIMIT_CODE,
+      conflictKey: `project-graph-limit#${stage}#${limitKind}`,
+      stage,
+      limitKind,
+      actual,
+      limit
+    })
+  };
+}
+
+function normalizeLimit(value) {
+  if (value === null) return undefined;
+  const limit = Number(value);
+  return Number.isFinite(limit) && limit >= 0 ? Math.floor(limit) : undefined;
+}
+
+function serializedByteLength(value) {
+  return utf8ByteLength(JSON.stringify(value));
+}
+
+function utf8ByteLength(value) {
+  const text = String(value ?? '');
+  if (encoder) return encoder.encode(text).length;
+  return unescape(encodeURIComponent(text)).length;
+}
+
+export {
+  PROJECT_GRAPH_INVALID_LIMIT_CODE,
+  PROJECT_GRAPH_LIMIT_CODE,
+  normalizeProjectGraphLimits,
+  projectGraphEdgeLimitConflicts,
+  projectGraphSerializedLimitConflict,
+  projectGraphSourceLimitConflicts,
+  projectGraphSourceStats
+};

package/dist/js-ts-safe-project-merge-graph.js

@@ -3,6 +3,13 @@ import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { compactRecord } from './js-ts-safe-merge-context.js';
 import { createNativeProjectImportResult } from './internal/index-impl/createNativeProjectImportResult.js';
 import { importNativeSource } from './internal/index-impl/importNativeSource.js';
+import {
+  normalizeProjectGraphLimits,
+  projectGraphEdgeLimitConflicts,
+  projectGraphSerializedLimitConflict,
+  projectGraphSourceLimitConflicts,
+  projectGraphSourceStats
+} from './js-ts-safe-project-merge-graph-limits.js';
 
 function createJsTsProjectSafeMergeGraphArtifacts(input, outputFiles, mergeId) {
   return createProjectGraphStageArtifacts(input, outputFiles, mergeId, 'output', projectImportsForStage(input, 'output'));
@@ -32,12 +39,28 @@ function createJsTsProjectSafeMergeGraphDelta(input, files, outputFiles, mergeId
       suppliedImports: sumStageSummary(stageSummaries, 'suppliedImports'),
       matchedSuppliedImports: sumStageSummary(stageSummaries, 'matchedSuppliedImports'),
       scannerFallbackImports: sumStageSummary(stageSummaries, 'scannerFallbackImports'),
+      sourceBytes: sumStageSummary(stageSummaries, 'sourceBytes'),
+      serializedBytes: sumStageSummary(stageSummaries, 'serializedBytes'),
+      limitConflicts: sumStageSummary(stageSummaries, 'limitConflicts'),
       stageSummaries
     }
   };
 }
 
 function createProjectGraphStageArtifacts(input, files, mergeId, stageName, stageImports) {
+  const limits = normalizeProjectGraphLimits(input.projectGraphLimits);
+  const sourceStats = projectGraphSourceStats(files);
+  const sourceLimitConflicts = projectGraphSourceLimitConflicts(limits, stageName, sourceStats);
+  const suppliedImports = normalizeProjectImports(stageImports);
+  const projectGraphImportSource = {
+    stage: stageName,
+    suppliedImports: suppliedImports.length,
+    matchedSuppliedImports: 0,
+    scannerFallbackImports: 0
+  };
+  if (sourceLimitConflicts.length) {
+    return limitedProjectGraphStage(stageName, projectGraphImportSource, sourceStats, undefined, sourceLimitConflicts);
+  }
   const sources = files.map((file) => ({
     id: `${mergeId}_${stageName}_${idFragment(file.sourcePath)}`,
     language: file.language ?? input.language ?? languageForPath(file.sourcePath),
@@ -46,7 +69,6 @@ function createProjectGraphStageArtifacts(input, files, mergeId, stageName, stag
     sourceHash: file.sourceHash,
     metadata: { semanticImportExpected: true, projectSafeMergeStage: stageName, projectSafeMergeOutput: stageName === 'output' }
   }));
-  const suppliedImports = normalizeProjectImports(stageImports);
   const importSelections = sources.map((source) => {
     const suppliedImport = matchingProjectImport(source, suppliedImports);
     return {
@@ -55,12 +77,8 @@ function createProjectGraphStageArtifacts(input, files, mergeId, stageName, stag
     };
   });
   const imports = importSelections.map((selection) => selection.importResult);
-  const projectGraphImportSource = {
-    stage: stageName,
-    suppliedImports: suppliedImports.length,
-    matchedSuppliedImports: importSelections.filter((selection) => selection.sourceKind === `supplied-${stageName}-project-import`).length,
-    scannerFallbackImports: importSelections.filter((selection) => selection.sourceKind === `lightweight-${stageName}-project-scan`).length
-  };
+  projectGraphImportSource.matchedSuppliedImports = importSelections.filter((selection) => selection.sourceKind === `supplied-${stageName}-project-import`).length;
+  projectGraphImportSource.scannerFallbackImports = importSelections.filter((selection) => selection.sourceKind === `lightweight-${stageName}-project-scan`).length;
   const projectImport = createNativeProjectImportResult({
     id: `${mergeId}_${stageName}_project_import`,
     projectRoot: input.projectRoot,
@@ -74,13 +92,32 @@ function createProjectGraphStageArtifacts(input, files, mergeId, stageName, stag
       ...(stageName === 'output' ? { outputProjectImportSource: projectGraphImportSource } : {})
     }
   }, imports);
+  const edgeLimitConflicts = projectGraphEdgeLimitConflicts(limits, stageName, projectImport.projectSymbolGraph);
+  const serialized = projectGraphSerializedLimitConflict(limits, stageName, {
+    projectImport,
+    projectSymbolGraph: projectImport.projectSymbolGraph
+  });
+  const limitConflicts = [...edgeLimitConflicts, serialized.conflict].filter(Boolean);
+  if (limitConflicts.length) {
+    return limitedProjectGraphStage(stageName, projectGraphImportSource, sourceStats, projectImport.projectSymbolGraph, limitConflicts, serialized.serializedBytes);
+  }
   return {
     kind: 'frontier.lang.jsTsProjectGraphStage',
     version: 1,
     stage: stageName,
     projectImport,
     projectSymbolGraph: projectImport.projectSymbolGraph,
-    summary: projectGraphStageSummary(stageName, projectImport.projectSymbolGraph, projectGraphImportSource)
+    summary: projectGraphStageSummary(stageName, projectImport.projectSymbolGraph, projectGraphImportSource, sourceStats, serialized.serializedBytes, [])
+  };
+}
+
+function limitedProjectGraphStage(stageName, importSource, sourceStats, projectSymbolGraph, limitConflicts, serializedBytes) {
+  return {
+    kind: 'frontier.lang.jsTsProjectGraphStage',
+    version: 1,
+    stage: stageName,
+    summary: projectGraphStageSummary(stageName, projectSymbolGraph, importSource, sourceStats, serializedBytes, limitConflicts),
+    limitConflicts
   };
 }
 
@@ -113,11 +150,12 @@ function matchingProjectImport(source, imports) {
   });
 }
 
-function projectGraphStageSummary(stageName, projectSymbolGraph, importSource) {
+function projectGraphStageSummary(stageName, projectSymbolGraph, importSource, sourceStats, serializedBytes, limitConflicts) {
   const importEdges = Array.isArray(projectSymbolGraph?.importEdges) ? projectSymbolGraph.importEdges : [];
   return {
     stage: stageName,
-    sourceFiles: projectSymbolGraph?.sourceCount ?? 0,
+    sourceFiles: projectSymbolGraph?.sourceCount ?? sourceStats.sourceFiles,
+    sourceBytes: sourceStats.sourceBytes,
     documents: projectSymbolGraph?.documentCount ?? 0,
     symbols: projectSymbolGraph?.symbolCount ?? 0,
     fileHashes: projectSymbolGraph?.fileHashes?.length ?? 0,
@@ -128,7 +166,9 @@ function projectGraphStageSummary(stageName, projectSymbolGraph, importSource) {
     unresolvedImportEdges: importEdges.filter(isMissingProjectImportEdge).length,
     suppliedImports: importSource.suppliedImports,
     matchedSuppliedImports: importSource.matchedSuppliedImports,
-    scannerFallbackImports: importSource.scannerFallbackImports
+    scannerFallbackImports: importSource.scannerFallbackImports,
+    serializedBytes,
+    limitConflicts: limitConflicts.length
   };
 }
 

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

@@ -25,7 +25,7 @@ function safeMergeJsTsProject(input = {}) {
   const graphArtifacts = projectGraphDelta?.stages?.output ?? (blockedFiles.length === 0 && input.includeOutputProjectSymbolGraph
     ? createJsTsProjectSafeMergeGraphArtifacts(input, outputFiles, id)
     : undefined);
-  const outputGraphConflicts = outputProjectGraphConflicts(graphArtifacts?.projectSymbolGraph);
+  const outputGraphConflicts = outputProjectGraphConflicts(projectGraphDelta ? graphArtifacts?.projectSymbolGraph : graphArtifacts);
   const deltaGraphConflicts = projectGraphDeltaConflicts(projectGraphDelta);
   const projectGraphDeltaWithConflicts = addProjectGraphDeltaConflictSummary(projectGraphDelta, deltaGraphConflicts);
   const graphConflicts = [...outputGraphConflicts, ...deltaGraphConflicts];
@@ -60,7 +60,7 @@ function safeMergeJsTsProject(input = {}) {
       reasonCodes,
       conflictKeys
     },
-    summary: projectSummary(fileResults, graphConflicts),
+    summary: projectSummary(fileResults, graphConflicts, Boolean(projectGraphDelta)),
     metadata: compactRecord({
       workerChangeSetId: input.workerChangeSetId,
       headChangeSetId: input.headChangeSetId,
@@ -71,6 +71,7 @@ function safeMergeJsTsProject(input = {}) {
       projectGraphConflicts: graphConflicts.length || undefined,
       outputProjectGraphConflicts: outputGraphConflicts.length || undefined,
       projectGraphDeltaConflicts: deltaGraphConflicts.length || undefined,
+      projectGraphLimitConflicts: graphConflicts.filter((conflict) => conflict.gateId === 'project-graph-limit').length || undefined,
       autoMergeClaim: false,
       semanticEquivalenceClaim: false
     })
@@ -110,6 +111,7 @@ function mergeProjectFile(file, input, projectId) {
   const result = safeMergeJsTsSource({
     ...input,
     ...context,
+    deferReExportIdentityConflictsToProjectGraph: input.includeProjectGraphDelta === true,
     id: `${projectId}_${safeId(file.sourcePath)}`,
     baseSourceText: base,
     workerSourceText: worker,
@@ -254,18 +256,21 @@ function sourceLedgersForFile(input, sourcePath) {
   return byPath ?? (input.sourceLedgers?.base || input.sourceLedgers?.worker || input.sourceLedgers?.head ? input.sourceLedgers : undefined);
 }
 
-function projectSummary(files, graphConflicts = []) {
+function projectSummary(files, graphConflicts = [], hasProjectGraphDelta = false) {
   const byOperation = {};
   for (const file of files) byOperation[file.operation] = (byOperation[file.operation] ?? 0) + 1;
-  const deltaConflicts = graphConflicts.filter((conflict) => conflict.gateId === 'project-graph-delta');
+  const limitConflicts = graphConflicts.filter((conflict) => conflict.gateId === 'project-graph-limit');
+  const deltaConflicts = graphConflicts.filter((conflict) => conflict.gateId === 'project-graph-delta' || (hasProjectGraphDelta && conflict.gateId === 'project-graph-limit'));
+  const outputConflicts = graphConflicts.filter((conflict) => conflict.gateId === 'project-symbol-graph' || (!hasProjectGraphDelta && conflict.gateId === 'project-graph-limit'));
   return {
     files: files.length,
     mergedFiles: files.filter((file) => file.status === 'merged').length,
     blockedFiles: files.filter((file) => file.status === 'blocked').length,
     outputFiles: files.filter((file) => typeof file.outputSourceText === 'string').length,
     projectGraphConflicts: graphConflicts.length,
-    outputProjectGraphConflicts: graphConflicts.length - deltaConflicts.length,
+    outputProjectGraphConflicts: outputConflicts.length,
     projectGraphDeltaConflicts: deltaConflicts.length,
+    projectGraphLimitConflicts: limitConflicts.length,
     projectGraphPublicContractConflicts: deltaConflicts.filter((conflict) => conflict.code === 'project-public-contract-delta-conflict').length,
     projectGraphReExportIdentityConflicts: deltaConflicts.filter((conflict) => conflict.code === 'project-re-export-identity-delta-conflict').length,
     projectGraphImportTargetConflicts: deltaConflicts.filter((conflict) => conflict.code === 'project-import-target-delta-conflict').length,

package/package.json

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