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

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

@@ -0,0 +1,124 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { staticOptionalMemberReference } from './staticOptionalMemberReference.js';
+
+function hookEffectCallback(hookName, ordinal, callbackText) {
+  if (!isEffectHookName(hookName)) return undefined;
+  const callback = normalizedHookEffectText(callbackText);
+  if (!callback) return undefined;
+  const callbackEvidence = hookEffectExpressionEvidence(callback, 'callback');
+  const cleanupReturn = hookEffectCleanupReturnText(callback);
+  const cleanupEvidence = cleanupReturn ? hookEffectExpressionEvidence(cleanupReturn, 'cleanup') : undefined;
+  return {
+    proofStatus: callbackEvidence.proofStatus,
+    callbackKind: callbackEvidence.expressionKind,
+    callbackText: callbackEvidence.static ? callback : undefined,
+    dynamicCallbackText: callbackEvidence.static ? undefined : callback,
+    callbackHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxHookEffectCallback', hookName, ordinal, callback, callbackEvidence }),
+    callbackReferenceRoot: callbackEvidence.referenceRoot,
+    callbackReferencePath: callbackEvidence.referencePath,
+    callbackReferenceMemberPath: callbackEvidence.referenceMemberPath,
+    callbackOptionalReference: callbackEvidence.optionalReference,
+    callbackOptionalReferenceSegments: callbackEvidence.optionalReferenceSegments,
+    callbackOptionalReferenceSegmentIndexes: callbackEvidence.optionalReferenceSegmentIndexes,
+    callbackOptionalNullishBoundaryCount: callbackEvidence.optionalNullishBoundaryCount,
+    dynamicCallbackKind: callbackEvidence.dynamicExpressionKind,
+    dynamicCallbackBlockerReasonCode: callbackEvidence.dynamicBlockerReasonCode,
+    cleanupProofStatus: cleanupEvidence?.cleanupProofStatus,
+    cleanupReturnKind: cleanupEvidence?.expressionKind,
+    cleanupReturnText: cleanupEvidence?.static ? cleanupReturn : undefined,
+    dynamicCleanupReturnText: cleanupEvidence && !cleanupEvidence.static ? cleanupReturn : undefined,
+    cleanupReturnHash: cleanupReturn ? hashSemanticValue({ kind: 'frontier.lang.projectJsxHookEffectCleanupReturn', hookName, ordinal, cleanupReturn, cleanupEvidence }) : undefined,
+    cleanupReturnReferenceRoot: cleanupEvidence?.referenceRoot,
+    cleanupReturnReferencePath: cleanupEvidence?.referencePath,
+    cleanupReturnReferenceMemberPath: cleanupEvidence?.referenceMemberPath,
+    cleanupReturnOptionalReference: cleanupEvidence?.optionalReference,
+    cleanupReturnOptionalReferenceSegments: cleanupEvidence?.optionalReferenceSegments,
+    cleanupReturnOptionalReferenceSegmentIndexes: cleanupEvidence?.optionalReferenceSegmentIndexes,
+    cleanupReturnOptionalNullishBoundaryCount: cleanupEvidence?.optionalNullishBoundaryCount,
+    dynamicCleanupReturnKind: cleanupEvidence?.dynamicExpressionKind,
+    dynamicCleanupReturnBlockerReasonCode: cleanupEvidence?.dynamicBlockerReasonCode,
+    cleanupReturnPresent: cleanupReturn ? true : undefined,
+    runtimeEquivalenceClaim: false,
+    signatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxHookEffect',
+      hookName,
+      ordinal,
+      callback,
+      callbackEvidence,
+      cleanupReturn,
+      cleanupEvidence,
+      runtimeEquivalenceClaim: false
+    })
+  };
+}
+
+function hookEffectExpressionEvidence(text, role) {
+  const value = normalizedHookEffectText(text);
+  const staticKind = staticHookEffectExpressionKind(value);
+  if (staticKind) return { static: true, proofStatus: 'static-effect-callback-source-evidence', cleanupProofStatus: 'static-effect-cleanup-source-evidence', expressionKind: staticKind };
+  const optionalReference = staticOptionalMemberReference(value);
+  if (optionalReference) return staticOptionalReferenceEvidence(optionalReference);
+  const reference = staticHookEffectReference(value);
+  if (reference) return { static: true, proofStatus: 'static-effect-callback-source-evidence', cleanupProofStatus: 'static-effect-cleanup-source-evidence', expressionKind: 'reference', ...reference };
+  const dynamicExpressionKind = dynamicHookEffectExpressionKind(value);
+  return {
+    static: false,
+    proofStatus: 'dynamic-effect-callback-unsupported',
+    cleanupProofStatus: 'dynamic-effect-cleanup-unsupported',
+    dynamicExpressionKind,
+    dynamicBlockerReasonCode: `jsx-render-hook-effect-${role}-${dynamicExpressionKind}-unsupported`
+  };
+}
+
+function staticOptionalReferenceEvidence(reference) {
+  return {
+    static: true,
+    proofStatus: 'static-effect-callback-source-evidence',
+    cleanupProofStatus: 'static-effect-cleanup-source-evidence',
+    expressionKind: 'optional-reference',
+    referenceRoot: reference.root,
+    referencePath: reference.path,
+    referenceMemberPath: reference.memberPath,
+    optionalReference: true,
+    optionalReferenceSegments: reference.optionalSegments,
+    optionalReferenceSegmentIndexes: reference.optionalSegmentIndexes,
+    optionalNullishBoundaryCount: reference.optionalSegmentIndexes.length
+  };
+}
+
+function staticHookEffectExpressionKind(text) {
+  const value = normalizedHookEffectText(text);
+  if (!value) return undefined;
+  if (/^(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>[\s\S]+$/.test(value)) return 'arrow-function';
+  if (/^(?:async\s+)?function(?:\s+[A-Za-z_$][\w$]*)?\s*\([^)]*\)\s*\{[\s\S]*\}$/.test(value)) return 'function-expression';
+  return undefined;
+}
+
+function staticHookEffectReference(text) {
+  const value = normalizedHookEffectText(text);
+  if (!/^(?:this|[A-Za-z_$][\w$]*)(?:\s*\.\s*[A-Za-z_$][\w$]*)*$/.test(value)) return undefined;
+  const normalized = value.replace(/\s+/g, '');
+  const path = normalized.split('.');
+  return { referenceRoot: path[0], referencePath: path, referenceMemberPath: path.slice(1) };
+}
+
+function dynamicHookEffectExpressionKind(text) {
+  const value = normalizedHookEffectText(text);
+  if (/\[[\s\S]*\]/.test(value)) return 'computed-reference';
+  if (/\?\.\s*\(/.test(value) || /\b[A-Za-z_$][\w$]*(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)*\s*\(/.test(value)) return 'call-expression';
+  if (/\?\./.test(value)) return 'optional-reference';
+  return 'dynamic-expression';
+}
+
+function hookEffectCleanupReturnText(callbackText) {
+  const match = /\breturn\s+([\s\S]*?)(?:;|$)/.exec(callbackText);
+  return match ? normalizedHookEffectText(match[1]) : undefined;
+}
+
+function isEffectHookName(name) {
+  return name === 'useEffect' || name === 'useLayoutEffect' || name === 'useInsertionEffect';
+}
+
+function normalizedHookEffectText(text) { return String(text ?? '').trim().replace(/\s+/g, ' '); }
+
+export { hookEffectCallback };

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

@@ -0,0 +1,281 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { jsxContextTargetClassification } from './projectSymbolGraphJsxContextTargets.js';
+import { hookEffectCallback } from './projectSymbolGraphJsxHookEffects.js';
+import { staticOptionalMemberReference } from './staticOptionalMemberReference.js';
+
+function jsxHookCalls(sourceText) {
+  const hookCalls = [];
+  for (const match of String(sourceText ?? '').matchAll(/\b(?:React\s*\.\s*)?(use[A-Z0-9][A-Za-z0-9_$]*)\s*\(/g)) {
+    const openParen = match.index + match[0].lastIndexOf('(');
+    const closeParen = findMatchingDelimiter(sourceText, openParen, '(', ')');
+    const argsText = closeParen === undefined ? undefined : sourceText.slice(openParen + 1, closeParen);
+    const args = typeof argsText === 'string' ? splitTopLevel(argsText, ',') : [];
+    const ordinal = hookCalls.length + 1;
+    const dependencyArray = hookDependencyArray(args);
+    const effectCallback = hookEffectCallback(match[1], ordinal, args[0]);
+    const contextConsumer = hookContextConsumer(match[1], ordinal, args[0]);
+    hookCalls.push(compactRecord({
+      name: match[1],
+      ordinal,
+      offset: match.index,
+      dependencyTexts: dependencyArray?.items,
+      dependencyCount: dependencyArray?.items.length,
+      dependencyRecords: dependencyArray?.records,
+      dependencyProofStatus: dependencyArray?.proofStatus,
+      dynamicDependencyTexts: dependencyArray?.dynamicItems,
+      dynamicDependencyReasonCodes: dependencyArray?.dynamicReasonCodes,
+      dependencyArrayHash: dependencyArray?.arrayHash,
+      dependencySignatureHash: dependencyArray ? hashSemanticValue({
+        kind: 'frontier.lang.projectJsxHookDependencyArray',
+        hookName: match[1],
+        ordinal,
+        dependencyTexts: dependencyArray.items,
+        dependencyRecords: dependencyArray.records,
+        dependencyProofStatus: dependencyArray.proofStatus,
+        dynamicDependencyTexts: dependencyArray.dynamicItems,
+        dynamicDependencyReasonCodes: dependencyArray.dynamicReasonCodes,
+        dependencyArrayHash: dependencyArray.arrayHash
+      }) : undefined,
+      effectProofStatus: effectCallback?.proofStatus,
+      effectCallbackKind: effectCallback?.callbackKind,
+      effectCallbackText: effectCallback?.callbackText,
+      effectDynamicCallbackText: effectCallback?.dynamicCallbackText,
+      effectCallbackHash: effectCallback?.callbackHash,
+      effectCallbackReferenceRoot: effectCallback?.callbackReferenceRoot,
+      effectCallbackReferencePath: effectCallback?.callbackReferencePath,
+      effectCallbackReferenceMemberPath: effectCallback?.callbackReferenceMemberPath,
+      effectCallbackOptionalReference: effectCallback?.callbackOptionalReference,
+      effectCallbackOptionalReferenceSegments: effectCallback?.callbackOptionalReferenceSegments,
+      effectCallbackOptionalReferenceSegmentIndexes: effectCallback?.callbackOptionalReferenceSegmentIndexes,
+      effectCallbackOptionalNullishBoundaryCount: effectCallback?.callbackOptionalNullishBoundaryCount,
+      effectDynamicCallbackKind: effectCallback?.dynamicCallbackKind,
+      effectDynamicCallbackBlockerReasonCode: effectCallback?.dynamicCallbackBlockerReasonCode,
+      effectCleanupProofStatus: effectCallback?.cleanupProofStatus,
+      effectCleanupReturnKind: effectCallback?.cleanupReturnKind,
+      effectCleanupReturnText: effectCallback?.cleanupReturnText,
+      effectDynamicCleanupReturnText: effectCallback?.dynamicCleanupReturnText,
+      effectCleanupReturnHash: effectCallback?.cleanupReturnHash,
+      effectCleanupReturnReferenceRoot: effectCallback?.cleanupReturnReferenceRoot,
+      effectCleanupReturnReferencePath: effectCallback?.cleanupReturnReferencePath,
+      effectCleanupReturnReferenceMemberPath: effectCallback?.cleanupReturnReferenceMemberPath,
+      effectCleanupReturnOptionalReference: effectCallback?.cleanupReturnOptionalReference,
+      effectCleanupReturnOptionalReferenceSegments: effectCallback?.cleanupReturnOptionalReferenceSegments,
+      effectCleanupReturnOptionalReferenceSegmentIndexes: effectCallback?.cleanupReturnOptionalReferenceSegmentIndexes,
+      effectCleanupReturnOptionalNullishBoundaryCount: effectCallback?.cleanupReturnOptionalNullishBoundaryCount,
+      effectDynamicCleanupReturnKind: effectCallback?.dynamicCleanupReturnKind,
+      effectDynamicCleanupReturnBlockerReasonCode: effectCallback?.dynamicCleanupReturnBlockerReasonCode,
+      effectCleanupReturnPresent: effectCallback?.cleanupReturnPresent,
+      effectRuntimeEquivalenceClaim: effectCallback?.runtimeEquivalenceClaim,
+      effectSignatureHash: effectCallback?.signatureHash,
+      contextName: contextConsumer?.contextName,
+      contextExpressionText: contextConsumer?.expressionText,
+      contextExpressionHash: contextConsumer?.expressionHash,
+      contextConsumerProofStatus: contextConsumer?.proofStatus,
+      contextTargetKind: contextConsumer?.contextTargetKind,
+      contextTargetReasonCode: contextConsumer?.reasonCode,
+      contextTargetReferenceRoot: contextConsumer?.contextTargetReferenceRoot,
+      contextTargetReferencePath: contextConsumer?.contextTargetReferencePath,
+      contextTargetReferenceMemberPath: contextConsumer?.contextTargetReferenceMemberPath,
+      contextTargetOptionalReference: contextConsumer?.optionalReference,
+      contextTargetOptionalReferenceSegments: contextConsumer?.optionalReferenceSegments,
+      contextTargetOptionalReferenceSegmentIndexes: contextConsumer?.optionalReferenceSegmentIndexes,
+      contextTargetOptionalNullishBoundaryCount: contextConsumer?.optionalNullishBoundaryCount,
+      contextTargetDynamicKind: contextConsumer?.dynamicTargetKind,
+      contextTargetDynamicBlockerReasonCode: contextConsumer?.dynamicBlockerReasonCode,
+      contextConsumerSignatureHash: contextConsumer?.signatureHash,
+      contextConsumerDynamicTarget: contextConsumer?.dynamicTarget
+    }));
+  }
+  return hookCalls;
+}
+
+function hookDependencyArray(args) {
+  const candidate = [...args].reverse().find((arg) => String(arg ?? '').trim().startsWith('['));
+  const trimmed = String(candidate ?? '').trim();
+  if (!trimmed.startsWith('[')) return undefined;
+  const close = findMatchingDelimiter(trimmed, 0, '[', ']');
+  if (close !== trimmed.length - 1) return undefined;
+  const items = splitTopLevel(trimmed.slice(1, -1), ',').map(normalizedHookDependencyText).filter(Boolean);
+  const records = items.map((item, index) => hookDependencyItemRecord(item, index + 1));
+  const dynamicRecords = records.filter((record) => record.proofStatus === 'dynamic-hook-dependency-unsupported');
+  const dynamicItems = dynamicRecords.map((record) => record.dependencyText);
+  return {
+    items,
+    records,
+    proofStatus: dynamicItems.length ? 'dynamic-dependency-array-unsupported' : 'static-dependency-array-evidence',
+    dynamicItems: dynamicItems.length ? dynamicItems : undefined,
+    dynamicReasonCodes: dynamicRecords.length ? uniqueStrings(dynamicRecords.map((record) => record.dynamicBlockerReasonCode)) : undefined,
+    arrayHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxHookDependencyArrayText',
+      items,
+      records,
+      dynamicItems,
+      text: normalizedHookDependencyText(trimmed)
+    })
+  };
+}
+
+function hookDependencyItemRecord(item, ordinal) {
+  const literalKind = hookDependencyLiteralKind(item);
+  if (literalKind) return staticHookDependencyRecord(item, ordinal, literalKind);
+  const optionalReference = staticOptionalMemberReference(item);
+  if (optionalReference) return staticHookOptionalDependencyRecord(item, ordinal, optionalReference);
+  const reference = staticHookDependencyReference(item);
+  if (reference) return staticHookDependencyRecord(item, ordinal, 'reference', reference);
+  return dynamicHookDependencyRecord(item, ordinal);
+}
+
+function staticHookDependencyRecord(item, ordinal, valueKind, reference) {
+  return compactRecord({
+    ordinal,
+    proofStatus: 'static-hook-dependency-evidence',
+    reasonCode: 'jsx-render-hook-dependency-static-evidence',
+    valueKind,
+    dependencyText: reference?.text ?? normalizedHookDependencyText(item),
+    referenceRoot: reference?.root,
+    referencePath: reference?.path,
+    signatureHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxHookDependencyItem', ordinal, valueKind, dependencyText: reference?.text ?? normalizedHookDependencyText(item), referencePath: reference?.path })
+  });
+}
+
+function staticHookOptionalDependencyRecord(item, ordinal, reference) {
+  return {
+    ordinal,
+    proofStatus: 'static-hook-dependency-evidence',
+    reasonCode: 'jsx-render-hook-dependency-static-optional-reference-evidence',
+    valueKind: 'optional-reference',
+    dependencyText: reference.text,
+    referenceRoot: reference.root,
+    referencePath: reference.path,
+    optionalReference: true,
+    optionalReferenceSegments: reference.optionalSegments,
+    optionalReferenceSegmentIndexes: reference.optionalSegmentIndexes,
+    optionalNullishBoundaryCount: reference.optionalSegmentIndexes.length,
+    signatureHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxHookDependencyItem', ordinal, valueKind: 'optional-reference', dependencyText: reference.text, referencePath: reference.path, optionalReferenceSegmentIndexes: reference.optionalSegmentIndexes })
+  };
+}
+
+function dynamicHookDependencyRecord(item, ordinal) {
+  const dependencyText = normalizedHookDependencyText(item);
+  const dynamicDependencyKind = hookDependencyDynamicKind(dependencyText);
+  return {
+    ordinal,
+    proofStatus: 'dynamic-hook-dependency-unsupported',
+    reasonCode: 'jsx-render-hook-dependency-unsupported',
+    dependencyText,
+    dynamicDependencyKind,
+    dynamicBlockerReasonCode: `jsx-render-hook-dependency-${dynamicDependencyKind}-unsupported`,
+    signatureHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxHookDependencyItem', ordinal, dependencyText, dynamicDependencyKind })
+  };
+}
+
+function isStaticHookDependencyText(text) {
+  return hookDependencyItemRecord(text, 1).proofStatus === 'static-hook-dependency-evidence';
+}
+
+function hookDependencyLiteralKind(text) {
+  const value = normalizedHookDependencyText(text);
+  if (/^(?:true|false)$/.test(value)) return 'boolean';
+  if (/^(?:null|undefined)$/.test(value)) return value;
+  if (/^[-]?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(value)) return 'number';
+  if (/^"(?:[^"\\]|\\.)*"$/.test(value) || /^'(?:[^'\\]|\\.)*'$/.test(value)) return 'string';
+  return undefined;
+}
+
+function staticHookDependencyReference(text) {
+  const value = normalizedHookDependencyText(text);
+  if (!/^(?:this|[A-Za-z_$][\w$]*)(?:\s*\.\s*[A-Za-z_$][\w$]*)*$/.test(value)) return undefined;
+  const normalized = value.replace(/\s+/g, '');
+  const path = normalized.split('.');
+  return { text: normalized, root: path[0], path };
+}
+
+function hookDependencyDynamicKind(text) {
+  const value = normalizedHookDependencyText(text);
+  if (/\[[\s\S]*\]/.test(value)) return 'computed-reference';
+  if (/\?\.\s*\(/.test(value) || /\b[A-Za-z_$][\w$]*(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)*\s*\(/.test(value)) return 'call-expression';
+  if (/\?\./.test(value)) return 'optional-reference';
+  return 'dynamic-expression';
+}
+
+function hookContextConsumer(hookName, ordinal, contextText) {
+  if (hookName !== 'useContext') return undefined;
+  const expressionText = normalizedHookDependencyText(contextText);
+  if (!expressionText) return undefined;
+  const classification = jsxContextTargetClassification(expressionText);
+  return compactRecord({
+    ...classification,
+    expressionText,
+    expressionHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxContextConsumerExpression', expressionText }),
+    signatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxContextConsumer',
+      hookName,
+      ordinal,
+      expressionText,
+      classification
+    })
+  });
+}
+
+function splitTopLevel(text, delimiter) {
+  const result = [];
+  let start = 0;
+  let depth = 0;
+  let quote;
+  let escaped = false;
+  const value = String(text ?? '');
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '(' || char === '[' || char === '{') depth += 1;
+    else if (char === ')' || char === ']' || char === '}') depth = Math.max(0, depth - 1);
+    else if (char === delimiter && depth === 0) {
+      result.push(value.slice(start, index));
+      start = index + 1;
+    }
+  }
+  result.push(value.slice(start));
+  return result;
+}
+
+function findMatchingDelimiter(text, openIndex, open, close) {
+  const value = String(text ?? '');
+  if (value[openIndex] !== open) return undefined;
+  let depth = 0;
+  let quote;
+  let escaped = false;
+  for (let index = openIndex; index < value.length; index += 1) {
+    const char = value[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === open) depth += 1;
+    else if (char === close) {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return undefined;
+}
+
+function normalizedHookDependencyText(text) { return String(text ?? '').trim().replace(/\s+/g, ' '); }
+function uniqueStrings(values = []) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { jsxHookCalls };

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

@@ -0,0 +1,139 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+function jsxSameFileMemberComponentOwnerIndex(sourceText, componentOwners = new Map()) {
+  const result = new Map();
+  for (const binding of jsxStaticMemberComponentBindings(sourceText, componentOwners)) {
+    addMemberOwner(result, `${binding.objectName}.${binding.propertyName}`, binding.owner);
+  }
+  return result;
+}
+
+function jsxSameFileMemberComponentObjectIndex(sourceText, componentOwners = new Map()) {
+  const result = new Map();
+  for (const binding of jsxStaticMemberComponentBindings(sourceText, componentOwners)) {
+    const objectMembers = result.get(binding.objectName) ?? new Map();
+    objectMembers.set(binding.propertyName, [...(objectMembers.get(binding.propertyName) ?? []), binding.owner]);
+    result.set(binding.objectName, objectMembers);
+  }
+  return result;
+}
+
+function jsxStaticMemberComponentBindings(sourceText, componentOwners = new Map()) {
+  const result = [];
+  for (const binding of objectLiteralBindings(sourceText)) {
+    for (const member of objectLiteralComponentMembers(binding.body)) {
+      const owners = componentOwners.get(member.localName) ?? [];
+      if (owners.length !== 1) continue;
+      result.push({
+        objectName: binding.objectName,
+        propertyName: member.propertyName,
+        localName: member.localName,
+        owner: memberOwnerRecord(owners[0], binding, member)
+      });
+    }
+  }
+  return result;
+}
+
+function memberOwnerRecord(owner, binding, member) {
+  const componentCallMemberBindingHash = hashSemanticValue({
+    kind: 'frontier.lang.projectJsxSameFileMemberComponentBinding',
+    objectName: binding.objectName,
+    propertyName: member.propertyName,
+    localName: member.localName,
+    declarationKind: binding.declarationKind
+  });
+  return {
+    ...owner,
+    componentProviderLookupScope: 'same-file-member-component',
+    componentCallLookupStatus: 'same-file-member-component-target-evidence',
+    componentCallMemberObjectName: binding.objectName,
+    componentCallMemberPropertyName: member.propertyName,
+    componentCallMemberLocalName: member.localName,
+    componentCallMemberBindingKind: binding.declarationKind,
+    componentCallMemberBindingHash
+  };
+}
+
+function objectLiteralBindings(sourceText) {
+  const text = String(sourceText ?? '');
+  const bindings = [];
+  const pattern = /\b(const|let|var)\s+([A-Z][A-Za-z0-9_$]*)\s*=\s*\{/g;
+  let match;
+  while ((match = pattern.exec(text))) {
+    const open = pattern.lastIndex - 1;
+    const close = matchingBrace(text, open);
+    if (close === -1) continue;
+    bindings.push({
+      declarationKind: match[1],
+      objectName: match[2],
+      body: text.slice(open + 1, close)
+    });
+    pattern.lastIndex = close + 1;
+  }
+  return bindings;
+}
+
+function objectLiteralComponentMembers(body) {
+  return splitTopLevel(body, ',').flatMap((part) => {
+    const text = String(part ?? '').trim();
+    if (!text || text.startsWith('...') || /\(|\{|\[/.test(text)) return [];
+    const shorthand = /^([A-Z][A-Za-z0-9_$]*)$/.exec(text);
+    if (shorthand) return [{ propertyName: shorthand[1], localName: shorthand[1] }];
+    const pair = /^(?:([A-Z][A-Za-z0-9_$]*)|"([A-Z][A-Za-z0-9_$]*)"|'([A-Z][A-Za-z0-9_$]*)')\s*:\s*([A-Z][A-Za-z0-9_$]*)$/.exec(text);
+    return pair ? [{ propertyName: pair[1] ?? pair[2] ?? pair[3], localName: pair[4] }] : [];
+  });
+}
+
+function matchingBrace(text, open) {
+  let depth = 0;
+  let quote;
+  for (let index = open; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (quote) {
+      if (char === '\\') index += 1;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === '`') { quote = char; continue; }
+    if (char === '/' && next === '/') { index = text.indexOf('\n', index + 2); if (index === -1) return -1; continue; }
+    if (char === '/' && next === '*') { index = text.indexOf('*/', index + 2); if (index === -1) return -1; index += 1; continue; }
+    if (char === '{') depth += 1;
+    if (char === '}') {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
+function splitTopLevel(text, separator) {
+  const parts = [];
+  let start = 0;
+  let depth = 0;
+  let quote;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (quote) {
+      if (char === '\\') index += 1;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === '`') { quote = char; continue; }
+    if (char === '(' || char === '[' || char === '{') depth += 1;
+    if (char === ')' || char === ']' || char === '}') depth -= 1;
+    if (depth === 0 && char === separator) {
+      parts.push(text.slice(start, index));
+      start = index + 1;
+    }
+  }
+  parts.push(text.slice(start));
+  return parts;
+}
+
+function addMemberOwner(result, name, owner) {
+  result.set(name, [...(result.get(name) ?? []), owner]);
+}
+
+export { jsxSameFileMemberComponentObjectIndex, jsxSameFileMemberComponentOwnerIndex };