@shapeshift-labs/frontier-lang-compiler 0.2.41 → 0.2.43

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

@@ -0,0 +1,60 @@
+import{maxSemanticMergeReadiness,uniqueStrings}from'../../native-import-utils.js';
+import{getNativeImportFeatureEvidencePolicy}from'./getNativeImportFeatureEvidencePolicy.js';import{nativeFeatureEvidenceRiskRank}from'./nativeFeatureEvidenceRiskRank.js';import{nativeImportFeatureEvidenceHasKey}from'./nativeImportFeatureEvidenceHasKey.js';import{nativeImportFeatureEvidenceIds}from'./nativeImportFeatureEvidenceIds.js';import{nativeImportFeatureEvidenceReasons}from'./nativeImportFeatureEvidenceReasons.js';import{normalizeNativeLossRecords}from'./normalizeNativeLossRecords.js';
+export function summarizeNativeImportFeatureEvidence(losses = [], options = {}) {
+  const normalizedLosses = normalizeNativeLossRecords(losses);
+  const evidence = options.evidence ?? [];
+  const issues = [];
+  const byKind = {};
+  const byRisk = {};
+  const policyKinds = [];
+  let highestRisk = 'low';
+  let semanticMergeReadiness = 'ready';
+
+  for (const loss of normalizedLosses) {
+    const policy = getNativeImportFeatureEvidencePolicy(loss.kind);
+    if (!policy) continue;
+    byKind[policy.kind] = (byKind[policy.kind] ?? 0) + 1;
+    byRisk[policy.risk] = (byRisk[policy.risk] ?? 0) + 1;
+    if ((nativeFeatureEvidenceRiskRank[policy.risk] ?? 0) > (nativeFeatureEvidenceRiskRank[highestRisk] ?? 0)) {
+      highestRisk = policy.risk;
+    }
+    policyKinds.push(policy.kind);
+    semanticMergeReadiness = maxSemanticMergeReadiness(semanticMergeReadiness, policy.minimumReadiness);
+    const missingRequiredEvidence = policy.requiredEvidenceKeys.filter((key) => !nativeImportFeatureEvidenceHasKey(loss, evidence, key));
+    const presentRequiredEvidence = policy.requiredEvidenceKeys.filter((key) => !missingRequiredEvidence.includes(key));
+    const presentRecommendedEvidence = policy.recommendedEvidenceKeys.filter((key) => nativeImportFeatureEvidenceHasKey(loss, evidence, key));
+    if (missingRequiredEvidence.length) {
+      semanticMergeReadiness = maxSemanticMergeReadiness(semanticMergeReadiness, policy.missingEvidenceReadiness);
+    }
+    issues.push({
+      lossId: loss.id,
+      kind: loss.kind,
+      policyKind: policy.kind,
+      risk: policy.risk,
+      category: policy.category,
+      readiness: missingRequiredEvidence.length ? policy.missingEvidenceReadiness : policy.minimumReadiness,
+      missingRequiredEvidence,
+      presentRequiredEvidence,
+      presentRecommendedEvidence,
+      evidenceIds: nativeImportFeatureEvidenceIds(loss, evidence, policy)
+    });
+  }
+
+  const missingRequiredEvidence = issues.flatMap((issue) => issue.missingRequiredEvidence.map((key) => ({
+    lossId: issue.lossId,
+    kind: issue.kind,
+    policyKind: issue.policyKind,
+    evidenceKey: key
+  })));
+  return {
+    total: issues.length,
+    policyKinds: uniqueStrings(policyKinds),
+    byKind,
+    byRisk,
+    highestRisk: issues.length ? highestRisk : 'low',
+    semanticMergeReadiness,
+    missingRequiredEvidence,
+    issues,
+    reasons: nativeImportFeatureEvidenceReasons(issues)
+  };
+}

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

@@ -0,0 +1,65 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+import{lossSeverityRank}from'./lossSeverityRank.js';import{nativeImportCategoryForLossKind}from'./nativeImportCategoryForLossKind.js';import{NativeImportReadinessBySeverity}from'./NativeImportReadinessBySeverity.js';import{nativeImportReadinessReasons}from'./nativeImportReadinessReasons.js';import{normalizeNativeLossRecords}from'./normalizeNativeLossRecords.js';import{summarizeNativeImportFeatureEvidence}from'./summarizeNativeImportFeatureEvidence.js';
+export function summarizeNativeImportLosses(losses = [], options = {}) {
+  const normalizedLosses = normalizeNativeLossRecords(losses);
+  const bySeverity = { info: 0, warning: 0, error: 0 };
+  const byKind = {};
+  const blockingLossIds = [];
+  const reviewLossIds = [];
+  const informationalLossIds = [];
+  let highestSeverity = 'none';
+
+  for (const loss of normalizedLosses) {
+    bySeverity[loss.severity] += 1;
+    byKind[loss.kind] = (byKind[loss.kind] ?? 0) + 1;
+    if (lossSeverityRank[loss.severity] > lossSeverityRank[highestSeverity]) {
+      highestSeverity = loss.severity;
+    }
+    if (loss.severity === 'error') blockingLossIds.push(loss.id);
+    else if (loss.severity === 'warning') reviewLossIds.push(loss.id);
+    else informationalLossIds.push(loss.id);
+  }
+
+  const failedEvidenceIds = (options.evidence ?? [])
+    .filter((record) => record?.status === 'failed')
+    .map((record) => record.id)
+    .filter(Boolean);
+  const exactAst = Boolean(options.exactAst) && normalizedLosses.length === 0;
+  const categories = uniqueStrings([
+    ...(exactAst ? ['exactAstImport'] : []),
+    ...normalizedLosses.map((loss) => nativeImportCategoryForLossKind(loss.kind))
+  ]);
+  const semanticMergeReadiness = failedEvidenceIds.length
+    ? 'blocked'
+    : NativeImportReadinessBySeverity[highestSeverity];
+  const readinessReasons = nativeImportReadinessReasons({
+    exactAst,
+    failedEvidenceIds,
+    blockingLossIds,
+    reviewLossIds,
+    informationalLossIds
+  });
+  const featureEvidence = summarizeNativeImportFeatureEvidence(normalizedLosses, {
+    evidence: options.evidence
+  });
+
+  return {
+    total: normalizedLosses.length,
+    hasLosses: normalizedLosses.length > 0,
+    exactAst,
+    highestSeverity,
+    semanticMergeReadiness,
+    readinessReasons,
+    categories,
+    bySeverity,
+    byKind,
+    blockingLossIds,
+    reviewLossIds,
+    informationalLossIds,
+    failedEvidenceIds,
+    featureEvidence,
+    parser: options.parser,
+    scanKind: options.scanKind,
+    semanticStatus: options.semanticStatus
+  };
+}

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

@@ -0,0 +1,15 @@
+export function summarizeProjectSourcePreservation(imports) {
+  const records = imports
+    .map((result) => result.metadata?.sourcePreservation ?? result.nativeSource?.metadata?.sourcePreservation ?? result.nativeAst?.metadata?.sourcePreservation)
+    .filter(Boolean);
+  return {
+    total: records.length,
+    exactSourceAvailable: records.filter((record) => record.summary?.exactSourceAvailable).length,
+    sourceBytes: records.reduce((sum, record) => sum + (record.sourceBytes ?? 0), 0),
+    tokens: records.reduce((sum, record) => sum + (record.summary?.tokens ?? record.tokens?.length ?? 0), 0),
+    trivia: records.reduce((sum, record) => sum + (record.summary?.trivia ?? record.trivia?.length ?? 0), 0),
+    directives: records.reduce((sum, record) => sum + (record.summary?.directives ?? record.directives?.length ?? 0), 0),
+    truncated: records.some((record) => record.summary?.truncated === true),
+    ids: records.map((record) => record.id).filter(Boolean)
+  };
+}

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

@@ -0,0 +1,19 @@
+export function swiftEvidenceSummary(value) {
+  if (!value) return undefined;
+  if (Array.isArray(value)) return { entryCount: value.length };
+  if (typeof value === 'string') return { value };
+  if (typeof value === 'object') {
+    const summary = {};
+    if (typeof value.hash === 'string') summary.hash = value.hash;
+    if (typeof value.solver === 'string') summary.solver = value.solver;
+    if (Array.isArray(value.entries)) summary.entryCount = value.entries.length;
+    if (Array.isArray(value.symbols)) summary.symbolCount = value.symbols.length;
+    if (Array.isArray(value.references)) summary.referenceCount = value.references.length;
+    if (Array.isArray(value.types)) summary.typeCount = value.types.length;
+    if (Array.isArray(value.diagnostics)) summary.diagnosticCount = value.diagnostics.length;
+    if (Array.isArray(value.macros)) summary.macroCount = value.macros.length;
+    if (Array.isArray(value.packages)) summary.packageCount = value.packages.length;
+    return Object.keys(summary).length ? summary : { present: true };
+  }
+  return { present: true };
+}

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

@@ -0,0 +1,20 @@
+import{idFragment}from'../../native-import-utils.js';
+import{swiftEvidenceSummary}from'./swiftEvidenceSummary.js';
+export function swiftGeneratedCodeLoss(input, nodeId, span, options = {}, metadata = {}) {
+  return {
+    id: `loss_${idFragment(nodeId ?? input.sourcePath ?? 'swift')}_swift_generated_code`,
+    severity: 'warning',
+    phase: 'parse',
+    sourceFormat: input.language,
+    kind: 'generatedCode',
+    message: 'Swift generated-source marker was imported; generated member provenance and source ownership require host evidence.',
+    span,
+    nodeId,
+    metadata: {
+      parser: options.parser,
+      astFormat: options.astFormat,
+      macroExpansionEvidence: swiftEvidenceSummary(options.macroExpansionEvidence),
+      ...metadata
+    }
+  };
+}

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

@@ -0,0 +1,11 @@
+import{swiftGeneratedSourcePath}from'./swiftGeneratedSourcePath.js';import{swiftSyntaxDeclarationName}from'./swiftSyntaxDeclarationName.js';
+export function swiftGeneratedCodeMarker(node, kind) {
+  if (node.generated || node.isGenerated) return true;
+  const path = String(node.filePath ?? node.path ?? node.sourcePath ?? '');
+  if (swiftGeneratedSourcePath(path)) return true;
+  if (kind === 'Attribute') {
+    const name = swiftSyntaxDeclarationName(node);
+    if (name && /(^|\.)(Generated|CompilerGenerated|_spi)Attribute?$/.test(name)) return true;
+  }
+  return false;
+}

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

@@ -0,0 +1,3 @@
+export function swiftGeneratedSourcePath(path) {
+  return typeof path === 'string' && /\.(g|generated)\.swift$/i.test(path);
+}

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

@@ -0,0 +1,10 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+import{swiftSyntaxName}from'./swiftSyntaxName.js';
+export function swiftSyntaxAttributeNames(node) {
+  const attributes = node.attributes ?? node.attributeList;
+  if (!attributes) return [];
+  if (Array.isArray(attributes)) {
+    return uniqueStrings(attributes.map((entry) => typeof entry === 'string' ? entry : swiftSyntaxName(entry.attributeName ?? entry.name ?? entry)).filter(Boolean));
+  }
+  return [];
+}

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

@@ -0,0 +1,18 @@
+import{ignoredSwiftSyntaxField}from'./ignoredSwiftSyntaxField.js';import{isSwiftSyntaxNode}from'./isSwiftSyntaxNode.js';import{swiftSyntaxChildWithParent}from'./swiftSyntaxChildWithParent.js';import{swiftSyntaxKind}from'./swiftSyntaxKind.js';
+export function swiftSyntaxChildEntries(node, kind = swiftSyntaxKind(node)) {
+  const fieldNames = Object.keys(node).filter((key) => !ignoredSwiftSyntaxField(key));
+  const entries = [];
+  for (const field of fieldNames) {
+    const value = node[field];
+    if (Array.isArray(value)) {
+      entries.push([field, value.map((entry) => swiftSyntaxChildWithParent(entry, kind, field))]);
+      continue;
+    }
+    if (value && typeof value === 'object') {
+      entries.push([field, swiftSyntaxChildWithParent(value, kind, field)]);
+    }
+  }
+  return entries.filter(([, value]) => Array.isArray(value)
+    ? value.some(isSwiftSyntaxNode)
+    : isSwiftSyntaxNode(value));
+}

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

@@ -0,0 +1,6 @@
+import{isSwiftSyntaxNode}from'./isSwiftSyntaxNode.js';
+export function swiftSyntaxChildWithParent(entry, parentKind, parentField) {
+  if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return entry;
+  if (!isSwiftSyntaxNode(entry)) return entry;
+  return { parentKind, parentField, ...entry };
+}

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

@@ -0,0 +1,3 @@
+export function swiftSyntaxConditionalCompilationKind(kind) {
+  return /IfConfig|ConditionalCompilation|PoundIf|PoundElse|PoundElseif|PoundEndif/i.test(String(kind));
+}

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

@@ -0,0 +1,19 @@
+import{swiftSyntaxKind}from'./swiftSyntaxKind.js';import{swiftSyntaxName}from'./swiftSyntaxName.js';import{swiftSyntaxOperatorName}from'./swiftSyntaxOperatorName.js';import{swiftSyntaxPatternName}from'./swiftSyntaxPatternName.js';import{swiftSyntaxTypeName}from'./swiftSyntaxTypeName.js';
+export function swiftSyntaxDeclarationName(node, kind = swiftSyntaxKind(node)) {
+  if (!node || typeof node !== 'object') return undefined;
+  if (kind === 'InitializerDecl') return 'init';
+  if (kind === 'DeinitializerDecl') return 'deinit';
+  if (kind === 'SubscriptDecl') return 'subscript';
+  if (kind === 'ExtensionDecl') {
+    const extended = swiftSyntaxTypeName(node.extendedType ?? node.type ?? node.name);
+    return extended ? `extension ${extended}` : undefined;
+  }
+  if (kind === 'OperatorDecl') return swiftSyntaxOperatorName(node, kind);
+  for (const key of ['identifier', 'name', 'simpleName', 'typeName', 'id']) {
+    const name = swiftSyntaxName(node[key]);
+    if (name) return name;
+  }
+  const patternName = swiftSyntaxPatternName(node.pattern);
+  if (patternName) return patternName;
+  return undefined;
+}

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

@@ -0,0 +1,38 @@
+import{declarationRecord}from'./declarationRecord.js';import{nativeNodeId}from'./nativeNodeId.js';import{swiftSyntaxDeclarationName}from'./swiftSyntaxDeclarationName.js';import{swiftSyntaxEnumCaseNames}from'./swiftSyntaxEnumCaseNames.js';import{swiftSyntaxFunctionLikeKind}from'./swiftSyntaxFunctionLikeKind.js';import{swiftSyntaxHasBody}from'./swiftSyntaxHasBody.js';import{swiftSyntaxImportPath}from'./swiftSyntaxImportPath.js';import{swiftSyntaxOperatorName}from'./swiftSyntaxOperatorName.js';import{swiftSyntaxTypeDeclarationKind}from'./swiftSyntaxTypeDeclarationKind.js';import{swiftSyntaxTypeDeclarationSymbolKind}from'./swiftSyntaxTypeDeclarationSymbolKind.js';import{swiftSyntaxVariableNames}from'./swiftSyntaxVariableNames.js';
+export function swiftSyntaxDeclarations(node, kind, nativeNodeId, input) {
+  if (kind === 'ImportDecl') {
+    const name = swiftSyntaxImportPath(node);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'module', 'import')] : [];
+  }
+  if (swiftSyntaxTypeDeclarationKind(kind)) {
+    const name = swiftSyntaxDeclarationName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, swiftSyntaxTypeDeclarationSymbolKind(kind), 'definition')] : [];
+  }
+  if (kind === 'ExtensionDecl') {
+    const name = swiftSyntaxDeclarationName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'type', 'definition')] : [];
+  }
+  if (kind === 'TypeAliasDecl' || kind === 'AssociatedTypeDecl') {
+    const name = swiftSyntaxDeclarationName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'type', 'definition')] : [];
+  }
+  if (swiftSyntaxFunctionLikeKind(kind)) {
+    const name = swiftSyntaxDeclarationName(node, kind) ?? swiftSyntaxOperatorName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, kind === 'FunctionDecl' ? 'function' : 'method', swiftSyntaxHasBody(node) ? 'definition' : 'declaration')] : [];
+  }
+  if (kind === 'VariableDecl') {
+    return swiftSyntaxVariableNames(node).map((name) => declarationRecord(input, nativeNodeId, name, 'property', 'definition'));
+  }
+  if (kind === 'PatternBinding' && node.parentKind === 'VariableDecl') {
+    const name = swiftSyntaxDeclarationName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'property', 'definition')] : [];
+  }
+  if (kind === 'EnumCaseDecl') {
+    return swiftSyntaxEnumCaseNames(node).map((name) => declarationRecord(input, nativeNodeId, name, 'enumMember', 'definition'));
+  }
+  if (kind === 'EnumCaseElement') {
+    const name = swiftSyntaxDeclarationName(node, kind);
+    return name ? [declarationRecord(input, nativeNodeId, name, 'enumMember', 'definition')] : [];
+  }
+  return [];
+}

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

@@ -0,0 +1,7 @@
+import{swiftSyntaxDeclarationName}from'./swiftSyntaxDeclarationName.js';
+export function swiftSyntaxEnumCaseNames(node) {
+  const elements = node.elements ?? node.caseElements ?? node.cases;
+  if (Array.isArray(elements)) return elements.map((entry) => swiftSyntaxDeclarationName(entry, 'EnumCaseElement')).filter(Boolean);
+  const name = swiftSyntaxDeclarationName(node);
+  return name ? [name] : [];
+}

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

@@ -0,0 +1,8 @@
+export function swiftSyntaxFunctionLikeKind(kind) {
+  return kind === 'FunctionDecl'
+    || kind === 'InitializerDecl'
+    || kind === 'DeinitializerDecl'
+    || kind === 'SubscriptDecl'
+    || kind === 'OperatorDecl'
+    || kind === 'PrecedenceGroupDecl';
+}

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

@@ -0,0 +1,3 @@
+export function swiftSyntaxHasBody(node) {
+  return Boolean(node.body || node.accessorBlock || node.memberBlock || Array.isArray(node.statements));
+}

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

@@ -0,0 +1,14 @@
+import{swiftSyntaxName}from'./swiftSyntaxName.js';
+export function swiftSyntaxImportPath(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const path = node.importPath ?? node.path ?? node.modulePath ?? node.name;
+  if (typeof path === 'string') return path;
+  if (Array.isArray(path)) {
+    return path.map((entry) => swiftSyntaxName(entry.name ?? entry.identifier ?? entry)).filter(Boolean).join('.');
+  }
+  if (path && typeof path === 'object') {
+    if (Array.isArray(path.components)) return path.components.map((entry) => swiftSyntaxName(entry.name ?? entry.identifier ?? entry)).filter(Boolean).join('.');
+    return swiftSyntaxName(path);
+  }
+  return undefined;
+}

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

@@ -0,0 +1,11 @@
+import{normalizeSwiftSyntaxKind}from'./normalizeSwiftSyntaxKind.js';
+export function swiftSyntaxKind(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const declared = node.kind ?? node.syntaxKind ?? node.SyntaxKind ?? node._syntaxKind ?? node._type ?? node.type ?? node.nodeType;
+  if (typeof declared === 'string') return normalizeSwiftSyntaxKind(declared);
+  if (Array.isArray(node.statements) || Array.isArray(node.members) || Array.isArray(node.declarations)) return 'SourceFile';
+  if (node.identifier && (node.memberBlock || node.members || node.genericParameterClause || node.inheritanceClause)) return 'ClassDecl';
+  if (node.signature && node.body) return 'FunctionDecl';
+  if (node.importPath || node.path) return 'ImportDecl';
+  return undefined;
+}

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

@@ -0,0 +1,5 @@
+export function swiftSyntaxLiteralValue(node) {
+  const value = node.value ?? node.literal;
+  if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;
+  return undefined;
+}

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

@@ -0,0 +1,3 @@
+export function swiftSyntaxMacroKind(kind) {
+  return /Macro/i.test(String(kind));
+}

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

@@ -0,0 +1,16 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+import{swiftSyntaxName}from'./swiftSyntaxName.js';
+export function swiftSyntaxModifierNames(node) {
+  const modifiers = node.modifiers ?? node.Modifiers;
+  if (!modifiers) return [];
+  if (Array.isArray(modifiers)) {
+    return uniqueStrings(modifiers.map((entry) => typeof entry === 'string' ? entry : swiftSyntaxName(entry.name ?? entry.modifier ?? entry)).filter(Boolean));
+  }
+  if (typeof modifiers === 'string') return uniqueStrings(modifiers.split(/\s+/).filter(Boolean));
+  if (typeof modifiers === 'object') {
+    return uniqueStrings(Object.entries(modifiers)
+      .filter(([, enabled]) => enabled === true)
+      .map(([key]) => key));
+  }
+  return [];
+}

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

@@ -0,0 +1,14 @@
+export function swiftSyntaxName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.text === 'string') return value.text;
+  if (typeof value.trimmedDescription === 'string') return value.trimmedDescription;
+  if (typeof value.description === 'string' && !value.description.includes('[object Object]')) return value.description.trim();
+  if (typeof value.identifier === 'string') return value.identifier;
+  if (typeof value.name === 'string') return value.name;
+  if (typeof value.value === 'string') return value.value;
+  if (value.tokenKind && typeof value.tokenKind === 'object') return swiftSyntaxName(value.tokenKind);
+  if (value.identifier && value.identifier !== value) return swiftSyntaxName(value.identifier);
+  if (value.name && value.name !== value) return swiftSyntaxName(value.name);
+  return undefined;
+}

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

@@ -0,0 +1,7 @@
+import{swiftSyntaxDeclarationName}from'./swiftSyntaxDeclarationName.js';import{swiftSyntaxImportPath}from'./swiftSyntaxImportPath.js';import{swiftSyntaxKind}from'./swiftSyntaxKind.js';import{swiftSyntaxLiteralValue}from'./swiftSyntaxLiteralValue.js';import{swiftSyntaxTypeName}from'./swiftSyntaxTypeName.js';
+export function swiftSyntaxNodeValue(node) {
+  return swiftSyntaxDeclarationName(node, swiftSyntaxKind(node))
+    ?? swiftSyntaxImportPath(node)
+    ?? swiftSyntaxTypeName(node.type ?? node.returnClause?.type ?? node.extendedType)
+    ?? swiftSyntaxLiteralValue(node);
+}

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

@@ -0,0 +1,6 @@
+import{swiftSyntaxDeclarationName}from'./swiftSyntaxDeclarationName.js';import{swiftSyntaxName}from'./swiftSyntaxName.js';
+export function swiftSyntaxOperatorName(node, kind) {
+  if (kind === 'PrecedenceGroupDecl') return swiftSyntaxDeclarationName(node) ?? 'precedencegroup';
+  const operatorToken = swiftSyntaxName(node.operatorIdentifier ?? node.operatorToken ?? node.name);
+  return operatorToken ? `operator ${operatorToken}` : undefined;
+}

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

@@ -0,0 +1,6 @@
+import{swiftSyntaxName}from'./swiftSyntaxName.js';
+export function swiftSyntaxPatternName(pattern) {
+  if (!pattern) return undefined;
+  if (typeof pattern === 'string') return pattern;
+  return swiftSyntaxName(pattern.identifier ?? pattern.name ?? pattern.boundName ?? pattern.pattern ?? pattern);
+}

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

@@ -0,0 +1,27 @@
+export function swiftSyntaxPosition(value, options = {}) {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value === 'object') {
+    const position = value.position ?? value.location ?? value;
+    const line = position.line ?? position.Line;
+    const column = position.column ?? position.character ?? position.utf8Column ?? position.Column;
+    if (typeof line === 'number') {
+      return {
+        path: position.path ?? position.filePath ?? position.file,
+        line,
+        column: typeof column === 'number' ? column : undefined
+      };
+    }
+  }
+  const resolver = typeof options.positionResolver === 'function'
+    ? options.positionResolver
+    : typeof options.lineMap?.position === 'function'
+      ? options.lineMap.position.bind(options.lineMap)
+      : typeof options.sourceLocationConverter?.location === 'function'
+        ? options.sourceLocationConverter.location.bind(options.sourceLocationConverter)
+        : undefined;
+  if (resolver) {
+    const resolved = resolver(value);
+    if (resolved !== value) return swiftSyntaxPosition(resolved, options);
+  }
+  return undefined;
+}

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

@@ -0,0 +1,6 @@
+export function swiftSyntaxPositionKind(node) {
+  if (node.sourceRange || node.range) return 'source-range';
+  if (node.position || node.absolutePosition) return 'absolute-position';
+  if (typeof node.startLine === 'number' || typeof node.line === 'number') return 'line-column-fields';
+  return undefined;
+}

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

@@ -0,0 +1,13 @@
+export function swiftSyntaxProblemNode(node, kind) {
+  return Boolean(
+    node.isMissing
+    || node.hasError
+    || node.containsDiagnostics
+    || node.containsSkippedText
+    || node.presence === 'missing'
+    || kind === 'UnexpectedNodes'
+    || kind === 'MissingToken'
+    || kind === 'SkippedToken'
+    || kind === 'Error'
+  );
+}

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

@@ -0,0 +1,7 @@
+export function swiftSyntaxRecoveredKind(kind) {
+  return kind === 'UnexpectedNodes'
+    || kind === 'MissingToken'
+    || kind === 'SkippedToken'
+    || kind === 'Error'
+    || /Unexpected|Missing|Skipped|Error/.test(String(kind));
+}

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

@@ -0,0 +1,15 @@
+import{isSwiftSyntaxNode}from'./isSwiftSyntaxNode.js';
+export function swiftSyntaxRoot(value) {
+  if (!value || typeof value !== 'object') return undefined;
+  if (isSwiftSyntaxNode(value)) return value;
+  if (isSwiftSyntaxNode(value.ast)) return value.ast;
+  if (isSwiftSyntaxNode(value.root)) return value.root;
+  if (isSwiftSyntaxNode(value.rootNode)) return value.rootNode;
+  if (isSwiftSyntaxNode(value.sourceFile)) return value.sourceFile;
+  if (isSwiftSyntaxNode(value.sourceFileSyntax)) return value.sourceFileSyntax;
+  if (isSwiftSyntaxNode(value.tree)) return swiftSyntaxRoot(value.tree);
+  if (Array.isArray(value.statements) || Array.isArray(value.members) || Array.isArray(value.declarations)) {
+    return { kind: 'SourceFile', ...value };
+  }
+  return undefined;
+}

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

@@ -0,0 +1,7 @@
+export function swiftSyntaxTypeDeclarationKind(kind) {
+  return kind === 'ClassDecl'
+    || kind === 'StructDecl'
+    || kind === 'EnumDecl'
+    || kind === 'ProtocolDecl'
+    || kind === 'ActorDecl';
+}

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

@@ -0,0 +1,8 @@
+export function swiftSyntaxTypeDeclarationSymbolKind(kind) {
+  if (kind === 'ClassDecl') return 'class';
+  if (kind === 'StructDecl') return 'struct';
+  if (kind === 'EnumDecl') return 'enum';
+  if (kind === 'ProtocolDecl') return 'protocol';
+  if (kind === 'ActorDecl') return 'class';
+  return 'type';
+}

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

@@ -0,0 +1,19 @@
+import{swiftSyntaxName}from'./swiftSyntaxName.js';
+export function swiftSyntaxTypeName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.trimmedDescription === 'string') return value.trimmedDescription;
+  if (typeof value.description === 'string' && !value.description.includes('[object Object]')) return value.description.trim();
+  if (typeof value.name === 'string') return value.name;
+  if (typeof value.text === 'string') return value.text;
+  if (value.baseType) {
+    const base = swiftSyntaxTypeName(value.baseType);
+    return base && value.name ? `${base}.${swiftSyntaxName(value.name)}` : base;
+  }
+  if (value.argumentList && Array.isArray(value.argumentList)) {
+    const base = swiftSyntaxName(value.name) ?? swiftSyntaxTypeName(value.baseName);
+    const args = value.argumentList.map((entry) => swiftSyntaxTypeName(entry.type ?? entry)).filter(Boolean);
+    return base ? `${base}<${args.join(', ')}>` : undefined;
+  }
+  return swiftSyntaxName(value);
+}

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

@@ -0,0 +1,7 @@
+import{swiftSyntaxDeclarationName}from'./swiftSyntaxDeclarationName.js';import{swiftSyntaxPatternName}from'./swiftSyntaxPatternName.js';
+export function swiftSyntaxVariableNames(node) {
+  const bindings = node.bindings ?? node.bindingSpecifier?.bindings ?? node.patternBindings;
+  if (Array.isArray(bindings)) return bindings.map((binding) => swiftSyntaxPatternName(binding.pattern ?? binding)).filter(Boolean);
+  const name = swiftSyntaxPatternName(node.pattern) ?? swiftSyntaxDeclarationName(node);
+  return name ? [name] : [];
+}

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

@@ -0,0 +1,18 @@
+import{declarationRecord}from'./declarationRecord.js';import{namedDeclaration}from'./namedDeclaration.js';import{nativeNodeId}from'./nativeNodeId.js';
+export function syntaxDeclaration(node, nativeNodeId, input) {
+  const kind = String(node.type ?? node.kind ?? '');
+  if (kind === 'ImportDeclaration') {
+    const name = node.source?.value;
+    if (typeof name === 'string') return declarationRecord(input, nativeNodeId, name, 'module', 'import');
+  }
+  if (kind === 'ExportNamedDeclaration' || kind === 'ExportAllDeclaration') {
+    const name = node.source?.value;
+    if (typeof name === 'string') return declarationRecord(input, nativeNodeId, name, 'module', 'export');
+  }
+  if (kind === 'FunctionDeclaration') return namedDeclaration(input, nativeNodeId, node.id, 'function');
+  if (kind === 'ClassDeclaration') return namedDeclaration(input, nativeNodeId, node.id, 'class');
+  if (kind === 'TSInterfaceDeclaration' || kind === 'InterfaceDeclaration') return namedDeclaration(input, nativeNodeId, node.id, 'interface');
+  if (kind === 'TSTypeAliasDeclaration' || kind === 'TypeAliasDeclaration') return namedDeclaration(input, nativeNodeId, node.id, 'type');
+  if (kind === 'VariableDeclarator') return namedDeclaration(input, nativeNodeId, node.id, 'variable');
+  return undefined;
+}

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

@@ -0,0 +1,43 @@
+import{idFragment,maxSemanticMergeReadiness}from'../../native-import-utils.js';
+import{semanticSliceAssertion}from'./semanticSliceAssertion.js';import{semanticSliceSourceHashAssertions}from'./semanticSliceSourceHashAssertions.js';
+export function testSemanticSlice(slice, options = {}) {
+  const assertions = [];
+  assertions.push(semanticSliceAssertion('kind', slice?.kind === 'frontier.lang.semanticSlice', 'Input is a Frontier semantic slice.'));
+  assertions.push(semanticSliceAssertion('entryRefsResolved', (slice?.unresolvedEntryRefs?.length ?? 0) === 0, 'All requested semantic entry refs resolved.', {
+    unresolvedEntryRefs: slice?.unresolvedEntryRefs ?? []
+  }));
+  assertions.push(semanticSliceAssertion('nonEmptySelection', (slice?.symbols?.length ?? 0) + (slice?.ownershipRegions?.length ?? 0) + (slice?.nativeNodes?.length ?? 0) > 0, 'Slice selected at least one symbol, ownership region, or native node.'));
+  assertions.push(semanticSliceAssertion('sourceMapLinks', options.requireSourceMapLinks === false || (slice?.sourceMapLinks?.length ?? 0) > 0, 'Slice has source-map links or the requirement was disabled.'));
+  assertions.push(semanticSliceAssertion('conflictKeys', (slice?.mergeAdmission?.conflictKeys?.length ?? 0) > 0, 'Slice exposes merge-admission conflict keys.'));
+  const sourceHashAssertions = semanticSliceSourceHashAssertions(slice, options.currentSources);
+  assertions.push(...sourceHashAssertions);
+  const failed = assertions.filter((assertion) => assertion.status === 'failed');
+  const warnings = assertions.filter((assertion) => assertion.status === 'warning');
+  const readiness = failed.length
+    ? 'blocked'
+    : maxSemanticMergeReadiness(slice?.mergeAdmission?.readiness ?? slice?.summary?.readiness ?? 'ready', warnings.length ? 'needs-review' : 'ready');
+  return {
+    kind: 'frontier.lang.semanticSliceTestResult',
+    version: 1,
+    id: options.id ?? `semantic_slice_test_${idFragment(slice?.id ?? 'slice')}`,
+    generatedAt: options.generatedAt ?? Date.now(),
+    sliceId: slice?.id,
+    status: failed.length ? 'failed' : warnings.length ? 'needs-review' : 'passed',
+    readiness,
+    assertions,
+    summary: {
+      assertions: assertions.length,
+      passed: assertions.filter((assertion) => assertion.status === 'passed').length,
+      warnings: warnings.length,
+      failed: failed.length,
+      sourceHashChecks: sourceHashAssertions.length,
+      symbols: slice?.summary?.symbols ?? slice?.symbols?.length ?? 0,
+      ownershipRegions: slice?.summary?.ownershipRegions ?? slice?.ownershipRegions?.length ?? 0,
+      sourceMapLinks: slice?.summary?.sourceMapLinks ?? slice?.sourceMapLinks?.length ?? 0
+    },
+    metadata: {
+      sliceReadiness: slice?.mergeAdmission?.readiness ?? slice?.summary?.readiness,
+      ...options.metadata
+    }
+  };
+}