@shapeshift-labs/frontier-lang-compiler 0.2.150 → 0.2.151

package/dist/semantic-import-graph-layers.js

@@ -0,0 +1,224 @@
+import { countBy, uniqueStrings } from './native-import-utils.js';
+import { summarizeImportSourcePreservation } from './semantic-import-source-preservation.js';
+
+export const SemanticGraphLayerKinds = Object.freeze([
+  'parser-source-span-trivia',
+  'scope-use-def',
+  'module-export-import',
+  'type-public-api',
+  'control-flow-effect',
+  'generic-semantic-edit-admission'
+]);
+
+export function createSemanticGraphLayerSummary(input = {}) {
+  const imports = input.imports ?? [];
+  const symbols = input.symbols ?? [];
+  const ownershipRegions = input.ownershipRegions ?? [];
+  const dependencies = input.dependencies ?? {};
+  const sourceMaps = input.sourceMaps ?? [];
+  const sourceMapMappings = input.sourceMapMappings ?? [];
+  const sourcePreservationDetails = input.sourcePreservationDetails
+    ?? (imports.length ? summarizeImportSourcePreservation(input.importResult, imports) : emptySourcePreservationDetails());
+  const sourcePreservation = input.sourcePreservation ?? {};
+  const layers = {
+    parserSourceSpanTrivia: parserSourceSpanTriviaLayer({ sourcePreservation, sourcePreservationDetails, sourceMapMappings, sourceMaps, universalAstLayers: input.universalAstLayers }),
+    scopeUseDef: scopeUseDefLayer({ symbols, dependencies, paradigmSemantics: input.paradigmSemantics }),
+    moduleExportImport: moduleExportImportLayer({ symbols, dependencies }),
+    typePublicApi: typePublicApiLayer({ symbols, ownershipRegions, proofSpec: input.proofSpec }),
+    controlFlowEffect: controlFlowEffectLayer({ ownershipRegions, dependencies, paradigmSemantics: input.paradigmSemantics, semanticImpact: input.semanticImpact }),
+    genericSemanticEditAdmission: genericSemanticEditAdmissionLayer({ patchHints: input.patchHints, quality: input.quality, admission: input.admission, mergeCandidates: input.mergeCandidates, readiness: input.readiness })
+  };
+  const layerList = Object.values(layers);
+  const byStatus = countBy(layerList.map((layer) => layer.status));
+  return {
+    kind: 'frontier.lang.semanticGraphLayers',
+    version: 1,
+    schema: 'frontier.lang.semanticGraphLayers.v1',
+    status: summaryStatus(layerList),
+    layerKinds: SemanticGraphLayerKinds,
+    layers,
+    summary: {
+      total: layerList.length,
+      strong: byStatus.strong ?? 0,
+      partial: byStatus.partial ?? 0,
+      missing: byStatus.missing ?? 0,
+      blocked: byStatus.blocked ?? 0,
+      usable: layerList.filter((layer) => layer.status === 'strong' || layer.status === 'partial').length,
+      reasonCodes: uniqueStrings(layerList.flatMap((layer) => layer.reasonCodes ?? [])),
+      evidenceIds: uniqueStrings(layerList.flatMap((layer) => layer.evidenceIds ?? []))
+    },
+    metadata: {
+      note: 'Graph layers summarize available semantic evidence for admission. They are not semantic-equivalence proof.'
+    }
+  };
+}
+
+function parserSourceSpanTriviaLayer(input) {
+  const exact = input.sourcePreservation?.exact ?? 0;
+  const declaration = input.sourcePreservation?.declaration ?? 0;
+  const estimated = input.sourcePreservation?.estimated ?? 0;
+  const blocked = input.sourcePreservation?.blocked ?? 0;
+  const sourceMapMappings = input.sourceMapMappings?.length ?? input.sourcePreservation?.sourceMapMappingIds?.length ?? 0;
+  const trivia = input.sourcePreservationDetails?.trivia ?? 0;
+  const comments = input.sourcePreservationDetails?.comments ?? 0;
+  const directives = input.sourcePreservationDetails?.directives ?? 0;
+  return graphLayer({
+    id: 'parser-source-span-trivia',
+    title: 'Parser, source span, and trivia evidence',
+    status: blocked ? 'blocked' : exact && sourceMapMappings ? 'strong' : exact || declaration || estimated || sourceMapMappings || trivia ? 'partial' : 'missing',
+    summary: { exact, declaration, estimated, blocked, sourceMaps: input.sourceMaps?.length ?? 0, sourceMapMappings, trivia, comments, directives, universalAstLayers: input.universalAstLayers?.total ?? 0 },
+    reasonCodes: [
+      ...(!exact ? ['missing-exact-source-preservation'] : []),
+      ...(!sourceMapMappings ? ['missing-source-map-mappings'] : []),
+      ...(!trivia ? ['missing-token-trivia-evidence'] : []),
+      ...(blocked ? ['blocked-source-preservation'] : [])
+    ],
+    evidenceIds: input.sourcePreservation?.ids
+  });
+}
+
+function scopeUseDefLayer(input) {
+  const bindings = input.paradigmSemantics?.bindings ?? 0;
+  const bindingScopes = input.paradigmSemantics?.bindingScopes ?? 0;
+  const uses = input.dependencies?.uses ?? 0;
+  const references = input.dependencies?.references ?? 0;
+  const calls = input.dependencies?.calls ?? 0;
+  return graphLayer({
+    id: 'scope-use-def',
+    title: 'Scope and use-def graph evidence',
+    status: bindings && (uses || references || calls) ? 'strong' : bindings || bindingScopes || uses || references || calls ? 'partial' : 'missing',
+    summary: { bindingScopes, bindings, uses, references, calls, sourceSymbols: input.dependencies?.sourceSymbolIds?.length ?? 0, targetSymbols: input.dependencies?.targetSymbolIds?.length ?? 0, symbols: input.symbols?.length ?? 0 },
+    reasonCodes: [
+      ...(!bindings ? ['missing-binding-graph'] : []),
+      ...(!(uses || references || calls) ? ['missing-use-def-relations'] : [])
+    ],
+    evidenceIds: input.paradigmSemantics?.ids
+  });
+}
+
+function moduleExportImportLayer(input) {
+  const moduleSymbols = input.symbols.filter((symbol) => moduleSymbol(symbol));
+  const importSymbols = moduleSymbols.filter((symbol) => importSymbol(symbol));
+  const exportSymbols = moduleSymbols.filter((symbol) => exportSymbol(symbol));
+  const importEdges = input.dependencies?.imports ?? 0;
+  const requireEdges = input.dependencies?.requires ?? 0;
+  return graphLayer({
+    id: 'module-export-import',
+    title: 'Module, export, and import graph evidence',
+    status: (importEdges || requireEdges || importSymbols.length) && exportSymbols.length ? 'strong' : importEdges || requireEdges || moduleSymbols.length ? 'partial' : 'missing',
+    summary: { importEdges, requireEdges, moduleSymbols: moduleSymbols.length, importSymbols: importSymbols.length, exportSymbols: exportSymbols.length, predicates: input.dependencies?.predicates ?? [] },
+    reasonCodes: [
+      ...(!(importEdges || requireEdges || importSymbols.length) ? ['missing-import-graph'] : []),
+      ...(!exportSymbols.length ? ['missing-export-graph'] : [])
+    ],
+    evidenceIds: input.dependencies?.ids
+  });
+}
+
+function typePublicApiLayer(input) {
+  const typeSymbols = input.symbols.filter((symbol) => typeSymbol(symbol));
+  const publicSymbols = input.symbols.filter((symbol) => exportSymbol(symbol) || publicRegion(input.ownershipRegions, symbol));
+  const contracts = input.proofSpec?.contracts ?? 0;
+  const invariants = input.proofSpec?.invariants ?? 0;
+  return graphLayer({
+    id: 'type-public-api',
+    title: 'Type and public API graph evidence',
+    status: typeSymbols.length && (publicSymbols.length || contracts || invariants) ? 'strong' : typeSymbols.length || publicSymbols.length || contracts || invariants ? 'partial' : 'missing',
+    summary: { typeSymbols: typeSymbols.length, publicSymbols: publicSymbols.length, contracts, invariants, proofObligations: input.proofSpec?.obligations ?? 0, proofOpen: input.proofSpec?.open ?? 0 },
+    reasonCodes: [
+      ...(!typeSymbols.length ? ['missing-type-graph'] : []),
+      ...(!(publicSymbols.length || contracts || invariants) ? ['missing-public-api-contract-graph'] : [])
+    ],
+    evidenceIds: input.proofSpec?.ids
+  });
+}
+
+function controlFlowEffectLayer(input) {
+  const runtimeRegions = input.ownershipRegions.filter((region) => runtimeRegion(region));
+  const effectRegions = runtimeRegions.filter((region) => region.regionKind === 'effect').length + (input.paradigmSemantics?.effectRegions ?? 0);
+  const controlRegions = runtimeRegions.filter((region) => region.regionKind === 'controlFlow').length + (input.paradigmSemantics?.controlRegions ?? 0);
+  const mutationRegions = runtimeRegions.filter((region) => region.regionKind === 'mutation').length;
+  const callRegions = runtimeRegions.filter((region) => region.regionKind === 'call').length + (input.dependencies?.calls ?? 0);
+  const highRisk = input.semanticImpact?.summary?.byRisk?.high ?? 0;
+  return graphLayer({
+    id: 'control-flow-effect',
+    title: 'Control-flow and effect graph evidence',
+    status: runtimeRegions.length || effectRegions || controlRegions || mutationRegions || callRegions ? 'partial' : 'missing',
+    summary: { runtimeRegions: runtimeRegions.length, effectRegions, controlRegions, mutationRegions, callRegions, highRiskImpacts: highRisk },
+    reasonCodes: [
+      ...(!controlRegions ? ['missing-control-flow-graph'] : []),
+      ...(!effectRegions ? ['missing-effect-graph'] : [])
+    ],
+    evidenceIds: input.semanticImpact?.evidenceIds
+  });
+}
+
+function genericSemanticEditAdmissionLayer(input) {
+  const patchHints = input.patchHints?.length ?? 0;
+  const mergeCandidates = input.mergeCandidates?.length ?? 0;
+  const admissionStatus = input.admission?.status ?? input.quality?.record?.classification;
+  const blocked = String(input.admission?.action ?? '').startsWith('reject') || input.readiness === 'blocked';
+  return graphLayer({
+    id: 'generic-semantic-edit-admission',
+    title: 'Generic semantic edit admission evidence',
+    status: blocked ? 'blocked' : admissionStatus && patchHints ? 'strong' : admissionStatus || patchHints || mergeCandidates ? 'partial' : 'missing',
+    summary: { patchHints, mergeCandidates, admissionStatus, admissionAction: input.admission?.action, readiness: input.readiness, qualityClassification: input.quality?.record?.classification },
+    reasonCodes: uniqueStrings([
+      ...(!patchHints ? ['missing-semantic-patch-hints'] : []),
+      ...(!admissionStatus ? ['missing-admission-record'] : []),
+      ...(input.quality?.expectedMissingReasonCodes ?? [])
+    ]),
+    evidenceIds: input.admission?.evidenceIds
+  });
+}
+
+function graphLayer(input) {
+  return {
+    kind: 'frontier.lang.semanticGraphLayer',
+    version: 1,
+    id: input.id,
+    title: input.title,
+    status: input.status,
+    summary: input.summary ?? {},
+    reasonCodes: uniqueStrings(input.reasonCodes ?? []),
+    evidenceIds: uniqueStrings(input.evidenceIds ?? [])
+  };
+}
+
+function summaryStatus(layers) {
+  if (layers.some((layer) => layer.status === 'blocked')) return 'blocked';
+  if (layers.some((layer) => layer.status === 'strong' || layer.status === 'partial')) return 'partial';
+  return 'missing';
+}
+
+function emptySourcePreservationDetails() {
+  return { total: 0, trivia: 0, comments: 0, directives: 0 };
+}
+
+function symbolText(symbol) {
+  return `${symbol?.id ?? ''} ${symbol?.name ?? ''} ${symbol?.kind ?? ''} ${symbol?.ownershipRegionKind ?? ''}`.toLowerCase();
+}
+
+function moduleSymbol(symbol) {
+  return /\b(import|export|module|namespace|commonjs|require)\b/.test(symbolText(symbol));
+}
+
+function importSymbol(symbol) {
+  return /\b(import|require)\b/.test(symbolText(symbol));
+}
+
+function exportSymbol(symbol) {
+  return /\b(export|public)\b/.test(symbolText(symbol));
+}
+
+function typeSymbol(symbol) {
+  return /\b(type|interface|class|enum|namespace|module|alias|generic|constraint)\b/.test(symbolText(symbol));
+}
+
+function runtimeRegion(region) {
+  return ['call', 'controlFlow', 'effect', 'mutation'].includes(region?.regionKind);
+}
+
+function publicRegion(regions, symbol) {
+  return regions.some((region) => region.symbolId === symbol.id && /\b(export|public)\b/.test(`${region.key ?? ''} ${region.mergePolicy ?? ''}`.toLowerCase()));
+}

package/dist/semantic-import-runtime-conditional-evidence.js

@@ -0,0 +1,135 @@
+function conditionalExpressionEvidenceRecords(line, start, end) {
+  const text = String(line ?? '');
+  return conditionalExpressionPairs(text)
+    .map((pair) => conditionalExpressionRecord(text, pair, start, end))
+    .filter(Boolean)
+    .sort((left, right) => right.questionIndex - left.questionIndex)
+    .slice(0, 1)
+    .map(({ questionIndex: _questionIndex, ...record }) => record);
+}
+
+function conditionalExpressionPairs(text) {
+  const pairs = [];
+  const stack = [];
+  const state = scanState();
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (advanceIgnoredState(state, char, next)) { if (state.skipNext) { state.skipNext = false; index += 1; } continue; }
+    if (char === '(') { state.parenDepth += 1; continue; }
+    if (char === ')') { state.parenDepth = Math.max(0, state.parenDepth - 1); continue; }
+    if (char === '[') { state.bracketDepth += 1; continue; }
+    if (char === ']') { state.bracketDepth = Math.max(0, state.bracketDepth - 1); continue; }
+    if (char === '{') { state.braceDepth += 1; continue; }
+    if (char === '}') { state.braceDepth = Math.max(0, state.braceDepth - 1); continue; }
+    if (char === '?' && conditionalQuestionMark(text, index)) stack.push({ questionIndex: index, ...depthSnapshot(state) });
+    else if (char === ':') {
+      const stackIndex = lastMatchingQuestionIndex(stack, state);
+      if (stackIndex >= 0) pairs.push({ ...stack.splice(stackIndex, 1)[0], colonIndex: index });
+    }
+  }
+  return pairs;
+}
+
+function conditionalExpressionRecord(text, pair, start, end) {
+  const expressionEnd = conditionalExpressionEnd(text, pair.colonIndex);
+  const branch = conditionalBranch(pair, expressionEnd, start, end);
+  if (!branch) return undefined;
+  const guardStart = conditionalGuardStart(text, pair);
+  const guardText = normalizeConditionalGuardText(text.slice(guardStart, pair.questionIndex));
+  if (!guardText) return undefined;
+  return compactRecord({
+    kind: 'conditional-expression',
+    branch,
+    guardText,
+    text: normalizeOrderEvidenceText(text.slice(guardStart, expressionEnd)),
+    questionColumn: pair.questionIndex + 1,
+    colonColumn: pair.colonIndex + 1,
+    questionIndex: pair.questionIndex
+  });
+}
+
+function conditionalBranch(pair, expressionEnd, start, end) {
+  if (start >= pair.questionIndex + 1 && end <= pair.colonIndex) return 'consequent';
+  if (start >= pair.colonIndex + 1 && end <= expressionEnd) return 'alternate';
+  return undefined;
+}
+
+function conditionalGuardStart(text, pair) {
+  let start = 0;
+  const state = scanState();
+  for (let index = 0; index < pair.questionIndex; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (advanceIgnoredState(state, char, next)) { if (state.skipNext) { state.skipNext = false; index += 1; } continue; }
+    if (char === '(') { state.parenDepth += 1; if (sameDepth(state, pair)) start = index + 1; continue; }
+    if (char === '[') { state.bracketDepth += 1; if (sameDepth(state, pair)) start = index + 1; continue; }
+    if (char === '{') { state.braceDepth += 1; if (sameDepth(state, pair)) start = index + 1; continue; }
+    if (sameDepth(state, pair) && (char === ';' || char === ',' || char === ':')) start = index + 1;
+    if (sameDepth(state, pair) && char === '=' && assignmentBoundary(text, index)) start = index + 1;
+    if (char === ')') state.parenDepth = Math.max(0, state.parenDepth - 1);
+    else if (char === ']') state.bracketDepth = Math.max(0, state.bracketDepth - 1);
+    else if (char === '}') state.braceDepth = Math.max(0, state.braceDepth - 1);
+  }
+  return start;
+}
+
+function conditionalExpressionEnd(text, colonIndex) {
+  const semicolon = text.indexOf(';', colonIndex);
+  return semicolon === -1 ? text.length : semicolon + 1;
+}
+
+function advanceIgnoredState(state, char, next) {
+  if (state.lineComment) return true;
+  if (state.blockComment) {
+    if (char === '*' && next === '/') { state.blockComment = false; state.skipNext = true; }
+    return true;
+  }
+  if (state.quote) {
+    if (state.escaped) state.escaped = false;
+    else if (char === '\\') state.escaped = true;
+    else if (char === state.quote) state.quote = undefined;
+    return true;
+  }
+  if (char === '/' && next === '/') { state.lineComment = true; return true; }
+  if (char === '/' && next === '*') { state.blockComment = true; state.skipNext = true; return true; }
+  if (char === '\'' || char === '"' || char === '`') { state.quote = char; return true; }
+  return false;
+}
+
+function lastMatchingQuestionIndex(stack, state) {
+  for (let index = stack.length - 1; index >= 0; index -= 1) {
+    if (sameDepth(state, stack[index])) return index;
+  }
+  return -1;
+}
+
+function conditionalQuestionMark(text, index) {
+  return text[index - 1] !== '?' && text[index + 1] !== '?' && text[index + 1] !== '.';
+}
+
+function assignmentBoundary(text, index) {
+  return text[index - 1] !== '=' && text[index + 1] !== '=' && text[index - 1] !== '!'
+    && text[index - 1] !== '<' && text[index - 1] !== '>' && text[index + 1] !== '>'
+    && text[index - 1] !== '&' && text[index - 1] !== '|' && text[index - 1] !== '?';
+}
+
+function sameDepth(left, right) {
+  return left.parenDepth === right.parenDepth && left.bracketDepth === right.bracketDepth
+    && left.braceDepth === right.braceDepth;
+}
+
+function depthSnapshot(state) {
+  return { parenDepth: state.parenDepth, bracketDepth: state.bracketDepth, braceDepth: state.braceDepth };
+}
+
+function scanState() { return { parenDepth: 0, bracketDepth: 0, braceDepth: 0 }; }
+function normalizeConditionalGuardText(value) {
+  return normalizeOrderEvidenceText(String(value ?? '').replace(/^(?:return|throw|yield|await)\s+/, ''));
+}
+function normalizeOrderEvidenceText(value) { return String(value ?? '').replace(/\s+/g, ' ').trim(); }
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
+}
+
+export { conditionalExpressionEvidenceRecords };

package/dist/semantic-import-runtime-effect-target-evidence.js

@@ -0,0 +1,145 @@
+function effectTargetOrderEvidence(line, lineNumber, group, start = 0, end = String(line ?? '').length, lines = []) {
+  if (group?.regionKind !== 'effect') return [];
+  const expression = String(line ?? '').slice(Math.max(0, start), Math.max(start, end));
+  const context = { literalBindings: sameScopeLiteralBindings(lines, lineNumber, line, start) };
+  const record = effectTargetRecord(expression, context) ?? effectTokenRecord(expression, context);
+  return record ? [compactRecord({
+    kind: 'effect-target',
+    effectKind: effectFactKind(group),
+    line: lineNumber,
+    ...record,
+    staticEffectTargetEvidence: true,
+    runtimeEquivalenceClaim: false,
+    semanticEquivalenceClaim: false
+  })] : [];
+}
+
+function effectTargetSignatureEvidence(record) {
+  return compactRecord({
+    effectKind: record?.effectKind,
+    targetText: record?.targetText,
+    targetRoot: record?.targetRoot,
+    receiverText: record?.receiverText,
+    taggedTemplate: record?.taggedTemplate,
+    calleeName: record?.calleeName,
+    constructorCall: record?.constructorCall,
+    optionalCall: record?.optionalCall,
+    computedProperty: record?.computedProperty,
+    computedPropertyKeys: record?.computedPropertyKeys,
+    computedPropertyStatic: record?.computedPropertyStatic,
+    computedPropertyDynamic: record?.computedPropertyDynamic,
+    computedPropertyBoundLiteral: record?.computedPropertyBoundLiteral,
+    computedPropertyBindingNames: record?.computedPropertyBindingNames,
+    computedPropertyBindingKinds: record?.computedPropertyBindingKinds
+  });
+}
+
+function effectTargetContextReasonCodes(record) {
+  return uniqueStrings([
+    'runtime-order-effect-target-merge-requires-effect-target-evidence',
+    record?.calleeName ? 'runtime-order-effect-target-merge-requires-callee-evidence' : undefined,
+    record?.taggedTemplate ? 'runtime-order-effect-target-merge-requires-tagged-template-target-evidence' : undefined,
+    record?.receiverText ? 'runtime-order-effect-target-merge-requires-receiver-evidence' : undefined,
+    record?.constructorCall ? 'runtime-order-effect-target-merge-requires-constructor-evidence' : undefined,
+    record?.computedPropertyBoundLiteral ? 'runtime-order-effect-target-merge-requires-bound-computed-literal-key-evidence' : undefined,
+    record?.computedPropertyStatic ? 'runtime-order-effect-target-merge-requires-computed-literal-key-evidence' : undefined,
+    record?.computedPropertyDynamic ? 'runtime-order-effect-target-merge-requires-dynamic-computed-key-evidence' : undefined,
+    record?.computedProperty ? 'runtime-order-effect-target-merge-requires-computed-key-evidence' : undefined,
+    record?.optionalCall ? 'runtime-order-effect-target-merge-requires-nullish-boundary-evidence' : undefined
+  ]);
+}
+
+function effectFactKind(group) { return (group?.factKinds ?? []).find(Boolean) ?? 'effect'; }
+
+function effectTargetRecord(expression, context = {}) {
+  const text = String(expression ?? '');
+  const tagged = taggedTemplateTarget(text, context);
+  if (tagged) return tagged;
+  const call = /\b(new\s+)?([A-Za-z_$][\w$]*(?:(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)|\s*(?:\?\.)?\[[^\]]+\])*)\s*(\?\.)?\s*\(/.exec(text);
+  if (!call) return undefined;
+  const targetText = normalizeTargetText(call[2]);
+  const parts = targetParts(targetText, context.literalBindings);
+  return targetRecord(statementText(text, call.index), targetText, {
+    calleeName: parts.calleeName,
+    receiverText: parts.receiverText,
+    constructorCall: Boolean(call[1]),
+    optionalCall: Boolean(call[3]) || /\?\./.test(targetText)
+  }, context);
+}
+
+function effectTokenRecord(expression, context = {}) {
+  const match = /\b(import\s*\.\s*meta|localStorage|sessionStorage|indexedDB|caches|cookie|console|process|Deno|Bun|document|window|navigator|location|history)(?:(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)|\s*(?:\?\.)?\[[^\]]+\])*/.exec(String(expression ?? ''));
+  return match ? targetRecord(statementText(expression, match.index), normalizeTargetText(match[0]), {}, context) : undefined;
+}
+
+function taggedTemplateTarget(expression, context = {}) {
+  const match = /([A-Za-z_$][\w$]*(?:(?:\s*\.\s*[A-Za-z_$][\w$]*)|\s*\[[^\]]+\])*)\s*`/.exec(String(expression ?? ''));
+  if (!match) return undefined;
+  const targetText = normalizeTargetText(match[1]);
+  const parts = targetParts(targetText, context.literalBindings);
+  return targetRecord(statementText(expression, match.index), targetText, {
+    taggedTemplate: true,
+    calleeName: parts.calleeName,
+    receiverText: parts.receiverText
+  }, context);
+}
+
+function targetRecord(text, targetText, extra = {}, context = {}) {
+  const computedProperties = computedPropertySegments(targetText, context.literalBindings);
+  const literalComputedProperties = computedProperties.filter((entry) => entry.static);
+  const boundLiteralComputedProperties = computedProperties.filter((entry) => entry.boundLiteral);
+  return compactRecord({
+    text: normalizeOrderEvidenceText(text),
+    targetText,
+    targetRoot: targetRoot(targetText),
+    computedProperty: computedProperties.length > 0 || undefined,
+    computedPropertyKeys: literalComputedProperties.map((entry) => entry.key),
+    computedPropertyStatic: computedProperties.length > 0 && literalComputedProperties.length === computedProperties.length || undefined,
+    computedPropertyDynamic: computedProperties.length > literalComputedProperties.length || undefined,
+    computedPropertyCount: computedProperties.length || undefined,
+    computedPropertyStaticCount: literalComputedProperties.length || undefined,
+    computedPropertyBoundLiteral: boundLiteralComputedProperties.length > 0 || undefined,
+    computedPropertyBindingNames: boundLiteralComputedProperties.map((entry) => entry.bindingName),
+    computedPropertyBindingKinds: uniqueStrings(boundLiteralComputedProperties.map((entry) => entry.bindingKind)),
+    computedPropertyRuntimeEquivalenceClaim: computedProperties.length > 0 ? false : undefined,
+    ...extra
+  });
+}
+
+function targetParts(targetText, literalBindings = new Map()) {
+  const normalized = String(targetText ?? '');
+  const computedTarget = /^(.*?)(?:\?\.)?\[([^\]]+)\]$/.exec(normalized);
+  if (computedTarget) return { calleeName: computedPropertyKey(computedTarget[2], literalBindings)?.key, receiverText: computedTarget[1] || undefined };
+  const memberTarget = /^(.*?)(?:\.|\?\.)?([A-Za-z_$][\w$]*)$/.exec(normalized);
+  return memberTarget ? { calleeName: memberTarget[2], receiverText: memberTarget[1] || undefined } : {};
+}
+
+function statementText(line, start) { return String(line ?? '').slice(Math.max(0, start), statementEnd(line, start)); }
+function statementEnd(line, start) { const semicolon = String(line ?? '').indexOf(';', start); return semicolon === -1 ? String(line ?? '').length : semicolon + 1; }
+function normalizeTargetText(value) { return normalizeOrderEvidenceText(String(value ?? '').replace(/\s*(?:\.|\?\.)\s*/g, (match) => match.includes('?.') ? '?.' : '.').replace(/\s*\[\s*/g, '[').replace(/\s*\]\s*/g, ']')); }
+function targetRoot(targetText) { return /^[A-Za-z_$][\w$]*/.exec(targetText)?.[0]; }
+function computedPropertySegments(targetText, literalBindings = new Map()) { return [...String(targetText ?? '').matchAll(/\[([^\]]+)\]/g)].map((match) => { const expression = normalizeOrderEvidenceText(match[1]); const key = computedPropertyKey(expression, literalBindings); return compactRecord({ expression, key: key?.key, static: key?.key !== undefined || undefined, boundLiteral: key?.boundLiteral, bindingName: key?.bindingName, bindingKind: key?.bindingKind }); }); }
+function computedPropertyKey(expression, literalBindings) { const literal = literalComputedPropertyKey(expression); if (literal !== undefined) return { key: literal }; const bound = literalBindings.get(expression); return bound ? { key: bound.value, boundLiteral: true, bindingName: expression, bindingKind: bound.kind } : undefined; }
+function literalComputedPropertyKey(expression) { const quoted = /^(['"`])((?:\\.|(?!\1)[\s\S])*)\1$/.exec(String(expression ?? '')); if (quoted && !quoted[2].includes('${')) return quoted[2].replace(/\\([\\'"`])/g, '$1'); return /^(?:0|[1-9]\d*)$/.test(expression) ? expression : undefined; }
+function sameScopeLiteralBindings(lines, lineNumber, line, start) {
+  const before = Array.isArray(lines) ? sameBlockPrefix(lines, lineNumber, line, start) : String(line ?? '').slice(0, start);
+  const bindings = new Map();
+  for (const match of before.matchAll(/\bconst\s+([A-Za-z_$][\w$]*)\s*=\s*(['"`])((?:\\.|(?!\2)[\s\S])*)\2\s*;?/g)) {
+    if (!match[3].includes('${')) bindings.set(match[1], { value: match[3].replace(/\\([\\'"`])/g, '$1'), kind: 'same-scope-const-literal' });
+  }
+  return bindings;
+}
+function sameBlockPrefix(lines, lineNumber, line, start) {
+  const prefix = [String(line ?? '').slice(0, start)];
+  for (let index = lineNumber - 2; index >= 0 && prefix.length < 20; index -= 1) {
+    const previous = String(lines[index] ?? '');
+    if (/^\s*}/.test(previous)) break;
+    prefix.unshift(previous);
+    if (previous.includes('{')) break;
+  }
+  return prefix.join('\n');
+}
+function normalizeOrderEvidenceText(value) { return String(value ?? '').replace(/\s+/g, ' ').trim(); }
+function uniqueStrings(values) { return [...new Set((values ?? []).filter(Boolean).map(String))]; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0))); }
+export { effectTargetContextReasonCodes, effectTargetOrderEvidence, effectTargetSignatureEvidence };

package/dist/semantic-import-runtime-exit-evidence.js

@@ -0,0 +1,32 @@
+function exitCompletionOrderEvidence(lines, lineNumber) {
+  if (!Array.isArray(lines) || !Number.isFinite(Number(lineNumber))) return [];
+  const line = String(lines[Number(lineNumber) - 1] ?? '');
+  const record = exitCompletionRecord(line, Number(lineNumber));
+  return record ? [record] : [];
+}
+
+function exitCompletionRecord(line, lineNumber) {
+  const match = /\b(return|yield)\b\s*(\*)?/.exec(String(line ?? ''));
+  if (!match) return undefined;
+  const text = normalizeOrderEvidenceText(line.slice(match.index, statementEnd(line, match.index)));
+  const expressionStart = match.index + match[0].length;
+  const delegated = match[1] === 'yield' && Boolean(match[2]);
+  const expressionText = normalizeOrderEvidenceText(line.slice(expressionStart, statementEnd(line, match.index)).replace(/;$/, ''));
+  return compactRecord({
+    kind: match[1],
+    line: lineNumber,
+    delegated: delegated || undefined,
+    delegationKind: delegated ? 'iterator-delegation' : undefined,
+    text,
+    expressionText,
+    delegatedIterableText: delegated ? expressionText : undefined,
+    iteratorProtocolEquivalenceClaim: delegated ? false : undefined,
+    delegatedCompletionPropagationClaim: delegated ? false : undefined
+  });
+}
+
+function normalizeOrderEvidenceText(value) { return String(value ?? '').replace(/\s+/g, ' ').trim(); }
+function statementEnd(line, start) { const semicolon = String(line ?? '').indexOf(';', start); return semicolon === -1 ? String(line ?? '').length : semicolon + 1; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && value !== '')); }
+
+export { exitCompletionOrderEvidence };

package/dist/semantic-import-runtime-import-meta-evidence.js

@@ -0,0 +1,33 @@
+import { uniqueStrings } from './native-import-utils.js';
+
+function importMetaHostContextEvidence(expressionText, evidence = {}) {
+  const importMetaHostContext = importMetaHostContextRecords(expressionText);
+  if (!importMetaHostContext.length) return evidence;
+  return compactRecord({
+    ...evidence,
+    hostContext: 'import.meta',
+    importMetaHostContext,
+    importMetaMemberNames: uniqueStrings(importMetaHostContext.map((record) => record.memberName))
+  });
+}
+
+function importMetaHostContextRecords(expressionText) {
+  return [...String(expressionText ?? '').matchAll(/\bimport\s*\.\s*meta((?:\s*\.\s*[A-Za-z_$][\w$]*)*)/g)]
+    .map((match, ordinal) => {
+      const memberPath = uniqueStrings([...String(match[1] ?? '').matchAll(/\.\s*([A-Za-z_$][\w$]*)/g)]
+        .map((item) => item[1]));
+      return compactRecord({
+        kind: 'import-meta',
+        ordinal: ordinal + 1,
+        text: match[0].replace(/\s+/g, ' ').trim(),
+        memberName: memberPath[0],
+        memberPath
+      });
+    });
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
+}
+
+export { importMetaHostContextEvidence, importMetaHostContextRecords };