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

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

@@ -1,14 +1,34 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { JsTsSafeMergeConflictCodes, identifierRegExp } from './js-ts-safe-merge-constants.js';
 
 export function classifyStatement(text, start, end) {
+  const directiveInfo = parseDirectiveInfo(text);
+  const textHash = hashSemanticValue(text);
+  if (directiveInfo) {
+    const key = directiveLedgerKey(directiveInfo);
+    return {
+      kind: 'directive',
+      key,
+      text,
+      start,
+      end,
+      textHash,
+      ownershipAnchor: topLevelStatementOwnershipAnchor({ kind: 'directive', key, textHash, start, end, directiveInfo }),
+      directiveInfo,
+      names: []
+    };
+  }
   const importInfo = parseImportInfo(text);
   if (importInfo) {
+    const key = importLedgerKey(importInfo);
     return {
       kind: 'import',
-      key: importLedgerKey(importInfo),
+      key,
       text,
       start,
       end,
+      textHash,
+      ownershipAnchor: topLevelStatementOwnershipAnchor({ kind: 'import', key, textHash, start, end }),
       importInfo,
       names: importInfo.specifiers.map((specifier) => specifier.localName).filter(Boolean)
     };
@@ -17,12 +37,15 @@ export function classifyStatement(text, start, end) {
   if (declarationInfo) {
     const unsupported = unsupportedDeclarationPolicy(text, declarationInfo);
     if (unsupported) return { unsupported, text, start, end };
+    const key = declarationLedgerKey(declarationInfo);
     return {
       kind: declarationInfo.kind,
-      key: declarationLedgerKey(declarationInfo),
+      key,
       text,
       start,
       end,
+      textHash,
+      ownershipAnchor: topLevelStatementOwnershipAnchor({ kind: declarationInfo.kind, key, textHash, start, end }),
       declarationInfo,
       names: declarationInfo.names
     };
@@ -30,6 +53,17 @@ export function classifyStatement(text, start, end) {
   return undefined;
 }
 
+function parseDirectiveInfo(text) {
+  const trimmed = text.trim();
+  const match = trimmed.match(/^(['"])(use\s+(?:strict|client|server))\1\s*;?$/);
+  if (!match) return undefined;
+  return { kind: 'runtime-directive', value: match[2], quote: match[1] };
+}
+
+function directiveLedgerKey(directiveInfo) {
+  return ['directive', directiveInfo.kind, directiveInfo.value].join(':');
+}
+
 function parseImportInfo(text) {
   const trimmed = text.trim();
   const sideEffect = trimmed.match(/^import\s+(['"])([^'"]+)\1\s*;?$/s);
@@ -271,6 +305,16 @@ function importLedgerKey(importInfo) {
   ].join(':');
 }
 
+function topLevelStatementOwnershipAnchor(input) {
+  const identityAnchor = input.kind === 'directive' && input.directiveInfo?.kind === 'runtime-directive' ? 'runtime-directive-prologue' : input.key;
+  return {
+    schema: 'frontier.lang.jsTsTopLevelStatementOwnershipAnchor.v1', version: 1, mode: 'top-level-ledger-entry',
+    key: ['js-ts-top-level', input.kind, identityAnchor].join('#'), identityAnchor, statementKind: input.kind,
+    start: input.start, end: input.end, textHash: input.textHash, losslessCst: false,
+    parserEvidence: 'frontier-js-ts-narrow-top-level-ledger', reasonCodes: ['top-level-ledger-statement-boundary', 'lossless-cst-unavailable']
+  };
+}
+
 export function importSpecifierCanonical(specifier) {
   return `${specifier.typeOnly ? 'type ' : ''}${specifier.importedName}${specifier.localName === specifier.importedName ? '' : ` as ${specifier.localName}`}`;
 }

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

@@ -3,6 +3,10 @@ export function skipTopLevelTrivia(sourceText, offset) {
   while (index < sourceText.length) {
     const char = sourceText[index];
     const next = sourceText[index + 1];
+    if (char === '#' && next === '!' && isHashbangAtFileStart(sourceText, index)) {
+      index = consumeLineComment(sourceText, index + 2);
+      continue;
+    }
     if (/\s/.test(char)) {
       index += 1;
       continue;
@@ -22,6 +26,10 @@ export function skipTopLevelTrivia(sourceText, offset) {
   return { offset: index };
 }
 
+function isHashbangAtFileStart(sourceText, offset) {
+  return offset === 0 || (offset === 1 && sourceText.charCodeAt(0) === 0xfeff);
+}
+
 function consumeLineComment(sourceText, offset) {
   const lineEnd = sourceText.indexOf('\n', offset);
   return lineEnd === -1 ? sourceText.length : lineEnd + 1;

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

@@ -225,11 +225,13 @@ function renderImportStatement(importInfo, specifiers) {
   const clause = [];
   if (importInfo.defaultLocalName) clause.push(importInfo.defaultLocalName);
   if (importInfo.namespaceLocalName) clause.push(`* as ${importInfo.namespaceLocalName}`);
-  if (specifiers.length) clause.push(`{ ${specifiers.map(importSpecifierCanonical).join(', ')} }`);
+  if (specifiers.length) clause.push(`{ ${specifiers.map((specifier) => renderImportSpecifier(specifier, importInfo)).join(', ')} }`);
   const importType = importInfo.typeOnly ? 'type ' : '';
   return `import ${importType}${clause.join(', ')} from ${importInfo.quote}${importInfo.moduleSpecifier}${importInfo.quote};`;
 }
 
+const renderImportSpecifier = (specifier, importInfo) => importSpecifierCanonical(importInfo.typeOnly ? { ...specifier, typeOnly: false } : specifier);
+
 function importInsertionText(entries, lineEnding) {
   return entries
     .map((entry) => normalizeLineEndings(entry.text.trimEnd(), lineEnding))

package/dist/js-ts-safe-merge-semantic-edit-fallback.js

@@ -1,3 +1,4 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { createSemanticEditScript } from './internal/index-impl/semanticEditScripts.js';
 import { projectSemanticEditScriptToSource } from './internal/index-impl/projectSemanticEditScriptToSource.js';
 import { replaySemanticEditProjection } from './internal/index-impl/replaySemanticEditProjection.js';
@@ -28,6 +29,14 @@ function semanticEditFallbackResult(input, topLevelResult) {
   if (independentDeletionResult) return independentDeletionResult;
   const topLevelRenameAdmission = analyzeTopLevelRenameAdmission(input, topLevelResult);
   if (topLevelRenameAdmission?.status === 'blocked') {
+    if (shouldDeferTopLevelRenamePublicContract(input, topLevelRenameAdmission)) {
+      const deferredAdmission = deferredTopLevelRenameAdmission(topLevelRenameAdmission);
+      const artifacts = createSemanticEditFallbackArtifacts(input, topLevelResult);
+      if (artifacts.status !== 'verified') {
+        return semanticEditFallbackBlockedResult(input, topLevelResult, artifacts, deferredAdmission);
+      }
+      return semanticEditFallbackMergedResult(input, topLevelResult, undefined, artifacts, deferredAdmission);
+    }
     return topLevelRenameBlockedResult(input, topLevelResult, topLevelRenameAdmission);
   }
   if (topLevelRenameAdmission?.status === 'candidate') {
@@ -142,6 +151,9 @@ function createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallba
         projection,
         currentSourceText: replayCurrentSourceText,
         currentSourcePath: sourcePath,
+        currentSourceHash: typeof replayCurrentSourceText === 'string' ? hashSemanticValue(replayCurrentSourceText) : undefined,
+        expectedOutputSourceText: projection.sourceText,
+        expectedOutputHash: projection.projectedHash,
         language,
         parser: input.parser,
         metadata: stagedFallback?.metadata
@@ -215,4 +227,41 @@ function semanticEditFallbackBlockedResult(input, topLevelResult, artifacts) {
   };
 }
 
+function shouldDeferTopLevelRenamePublicContract(input, admission) {
+  if (input.deferTopLevelRenamePublicExportContractToProjectGraph !== true
+    || admission.reasonCodes?.length !== 1
+    || !admission.reasonCodes.includes('top-level-rename-public-export-contract')) {
+    return false;
+  }
+  if (admission.summary?.exported === true) {
+    return input.deferDirectExportRenamePublicContractToProjectSymbolRename === true;
+  }
+  return workerPreservesRenamedExportAlias(input.workerSourceText, admission.summary);
+}
+
+function deferredTopLevelRenameAdmission(admission) {
+  return {
+    ...admission,
+    status: 'candidate',
+    reasonCodes: ['top-level-rename-public-export-contract-deferred-to-project-graph'],
+    summary: {
+      ...admission.summary,
+      deferredToProjectGraph: true,
+      reasonCodes: ['top-level-rename-public-export-contract-deferred-to-project-graph']
+    }
+  };
+}
+
+function workerPreservesRenamedExportAlias(sourceText, summary) {
+  const fromName = summary?.fromName;
+  const toName = summary?.toName;
+  if (typeof sourceText !== 'string' || !fromName || !toName) return false;
+  const exportListPattern = new RegExp(`export\\s*\\{[^}]*\\b${escapeRegExp(toName)}\\s+as\\s+${escapeRegExp(fromName)}\\b[^}]*\\}`);
+  return exportListPattern.test(sourceText);
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 export { semanticEditFallbackResult };

package/dist/js-ts-safe-merge-source-shape-fallbacks.js

@@ -1,9 +1,13 @@
 import { createEnumMemberSemanticFallbackResult } from './js-ts-safe-merge-enum-member-fallback.js';
+import { createJsxAttributeSemanticFallbackResult } from './js-ts-safe-merge-jsx-attribute-fallback.js';
+import { createJsxChildExpressionSemanticFallbackResult } from './js-ts-safe-merge-jsx-child-expression-fallback.js';
 import { createVariableDeclaratorSemanticFallbackResult } from './js-ts-safe-merge-variable-declarator-fallback.js';
 
 function createSourceShapeSemanticFallbackResult(input, topLevelResult, stagedFallback) {
   return createVariableDeclaratorSemanticFallbackResult(input, topLevelResult, stagedFallback)
-    ?? createEnumMemberSemanticFallbackResult(input, topLevelResult, stagedFallback);
+    ?? createEnumMemberSemanticFallbackResult(input, topLevelResult, stagedFallback)
+    ?? createJsxAttributeSemanticFallbackResult(input, topLevelResult, stagedFallback)
+    ?? createJsxChildExpressionSemanticFallbackResult(input, topLevelResult, stagedFallback);
 }
 
 export { createSourceShapeSemanticFallbackResult };

package/dist/js-ts-safe-merge-top-level-rename-fallback.js

@@ -1,6 +1,7 @@
 import { JsTsSafeMergeConflictCodes } from './js-ts-safe-merge-constants.js';
 import { createMergeContext, sameStatementText } from './js-ts-safe-merge-context.js';
 import { scanJsTsTopLevelLedger, validateLedgerUniqueness } from './js-ts-safe-merge-ledger.js';
+import { analyzeTopLevelRenameUseDefEvidence, LexicalUseDefReasonCodes } from './js-ts-semantic-scope-use-def.js';
 import { uniqueStrings } from './native-import-utils.js';
 
 const supportedRenameDeclarationKinds = new Set(['function', 'class', 'type']);
@@ -29,19 +30,42 @@ function analyzeTopLevelRenameAdmission(input, topLevelResult) {
   if (!candidate) return undefined;
 
   const publicContractReasonCodes = publicContractRenameReasonCodes(base, worker, head, candidate);
+  const lexicalUseDefEvidence = analyzeTopLevelRenameUseDefEvidence({
+    sourcePath: input.sourcePath,
+    baseSourceText: input.baseSourceText,
+    workerSourceText: input.workerSourceText,
+    headSourceText: input.headSourceText,
+    ...candidate
+  });
   if (publicContractReasonCodes.length) {
     return {
       status: 'blocked',
       reasonCodes: publicContractReasonCodes,
-      summary: candidateSummary(candidate, publicContractReasonCodes),
+      summary: candidateSummary(candidate, publicContractReasonCodes, lexicalUseDefEvidence),
       ledgers: { base, worker, head }
     };
   }
 
+  const lexicalBlockerReasonCodes = lexicalUseDefEvidence.reasonCodes
+    .filter((code) => code !== LexicalUseDefReasonCodes.noLiveReferences);
+  if (lexicalBlockerReasonCodes.length) {
+    const reasonCodes = uniqueStrings([...publicContractReasonCodes, ...lexicalBlockerReasonCodes]);
+    return {
+      status: 'blocked',
+      reasonCodes,
+      summary: candidateSummary(candidate, reasonCodes, lexicalUseDefEvidence),
+      ledgers: { base, worker, head }
+    };
+  }
+
+  const candidateReasonCodes = [
+    'top-level-rename-source-shape-matches',
+    LexicalUseDefReasonCodes.noLiveReferences
+  ];
   return {
     status: 'candidate',
-    reasonCodes: ['top-level-rename-source-shape-matches'],
-    summary: candidateSummary(candidate, ['top-level-rename-source-shape-matches']),
+    reasonCodes: candidateReasonCodes,
+    summary: candidateSummary(candidate, candidateReasonCodes, lexicalUseDefEvidence),
     ledgers: { base, worker, head }
   };
 }
@@ -79,6 +103,7 @@ function topLevelRenameCandidate(base, worker, head) {
   return {
     fromEntry,
     toEntry,
+    headEntry: entriesByKey(head.entries).get(fromEntry.key),
     fromName,
     toName,
     declarationKind: fromEntry.declarationInfo.declarationKind
@@ -124,13 +149,14 @@ function renameDeclarationText(text, declarationKind, fromName, toName) {
   return undefined;
 }
 
-function candidateSummary(candidate, reasonCodes) {
+function candidateSummary(candidate, reasonCodes, lexicalUseDefEvidence) {
   return {
     fromName: candidate.fromName,
     toName: candidate.toName,
     declarationKind: candidate.declarationKind,
     exported: candidate.fromEntry.declarationInfo?.exported === true || candidate.toEntry.declarationInfo?.exported === true,
-    reasonCodes: uniqueStrings(reasonCodes)
+    reasonCodes: uniqueStrings(reasonCodes),
+    lexicalUseDefEvidence
   };
 }
 

package/dist/js-ts-safe-merge-top-level-rename-result.js

@@ -6,10 +6,15 @@ function topLevelRenameBlockedResult(input, topLevelResult, topLevelRenameAdmiss
     ...(topLevelResult.admission?.reasonCodes ?? []),
     ...(topLevelRenameAdmission.reasonCodes ?? [])
   ]);
+  const primaryReasonCode = topLevelRenameAdmission.reasonCodes?.[0] ?? JsTsSafeMergeConflictCodes.topLevelRenamePublicExportContract;
+  const publicContractBlock = topLevelRenameAdmission.reasonCodes
+    ?.includes(JsTsSafeMergeConflictCodes.topLevelRenamePublicExportContract);
   const conflict = {
-    code: JsTsSafeMergeConflictCodes.topLevelRenamePublicExportContract,
+    code: publicContractBlock ? JsTsSafeMergeConflictCodes.topLevelRenamePublicExportContract : primaryReasonCode,
     gateId: JsTsSafeMergeGateIds.stableExistingDeclarations,
-    message: 'Top-level rename changes a public export contract without project-level evidence.',
+    message: publicContractBlock
+      ? 'Top-level rename changes a public export contract without project-level evidence.'
+      : 'Top-level rename requires lexical use-def evidence before automatic merge.',
     side: 'worker',
     sourcePath: input.sourcePath ?? topLevelResult.sourcePath,
     details: {

package/dist/js-ts-safe-merge-variable-declarator-fallback.js

@@ -16,8 +16,13 @@ function createVariableDeclaratorSemanticFallbackResult(input, topLevelResult, s
     headSourceText: input.headSourceText,
     currentSourceText
   });
-  if (!merge.ok || merge.sourceText === currentSourceText) return undefined;
   const resultBase = stagedFallback?.stagedTopLevelResult ?? topLevelResult;
+  if (!merge.ok) {
+    return merge.sourceShapeBlocked
+      ? variableDeclaratorBlockedResult(input, topLevelResult, resultBase, stagedFallback, merge)
+      : undefined;
+  }
+  if (merge.sourceText === currentSourceText) return undefined;
   const language = input.language ?? topLevelResult.language ?? 'typescript';
   const sourcePath = input.sourcePath ?? topLevelResult.sourcePath ?? 'inline.ts';
   const phase = stagedFallback
@@ -142,17 +147,28 @@ function mergeVariableStatement(base, worker, head, current) {
     const workerDeclarator = worker.declarators[index];
     const headDeclarator = head.declarators[index];
     const currentDeclarator = current.declarators[index];
-    if (![workerDeclarator, headDeclarator, currentDeclarator].every((entry) => entry?.name === baseDeclarator.name)) {
-      return blockedStatement('variable-declarator-name-order-changed');
+    const bindingPatternReasonCodes = classifyDeclaratorBindingPattern(baseDeclarator, workerDeclarator, headDeclarator, currentDeclarator);
+    if (bindingPatternReasonCodes.length) return blockedStatement(...bindingPatternReasonCodes);
+    if (![workerDeclarator, headDeclarator, currentDeclarator].every((entry) => entry?.key === baseDeclarator.key)) {
+      return blockedStatement(
+        ...declaratorKeyChangeReasonCodes(baseDeclarator, workerDeclarator, headDeclarator, currentDeclarator),
+        'variable-declarator-name-order-changed'
+      );
     }
     const workerChanged = !sameVariableDeclaratorText(baseDeclarator.text, workerDeclarator.text);
     const headChanged = !sameVariableDeclaratorText(baseDeclarator.text, headDeclarator.text);
     if (workerChanged && headChanged && !sameVariableDeclaratorText(workerDeclarator.text, headDeclarator.text)) {
-      return blockedStatement('variable-declarator-conflict');
+      return blockedStatement(
+        ...bindingDeclaratorConflictReasonCodes(baseDeclarator),
+        'variable-declarator-conflict'
+      );
     }
     if (!sameVariableDeclaratorText(currentDeclarator.text, headDeclarator.text)
       && !sameVariableDeclaratorText(currentDeclarator.text, workerDeclarator.text)) {
-      return blockedStatement('variable-declarator-current-diverged');
+      return blockedStatement(
+        ...bindingDeclaratorConflictReasonCodes(baseDeclarator),
+        'variable-declarator-current-diverged'
+      );
     }
     const replacement = workerChanged ? workerDeclarator.text : currentDeclarator.text;
     if (!sameVariableDeclaratorText(replacement, currentDeclarator.text)) changed = true;
@@ -164,6 +180,46 @@ function mergeVariableStatement(base, worker, head, current) {
   };
 }
 
+function classifyDeclaratorBindingPattern(base, worker, head, current) {
+  const declarators = [base, worker, head, current].filter(Boolean);
+  if (!declarators.some((entry) => entry.binding?.kind === 'binding-pattern')) return [];
+  const reasonCodes = uniqueStrings(declarators.flatMap((entry) => entry.binding?.reasonCodes ?? []));
+  if (reasonCodes.length) return reasonCodes;
+  if (!declarators.every((entry) => entry.binding?.kind === base.binding?.kind && entry.binding?.patternKind === base.binding?.patternKind)) {
+    return [
+      'binding-pattern-kind-changed',
+      'binding-pattern-merge-requires-binding-use-evidence'
+    ];
+  }
+  const patternTexts = declarators.map((entry) => entry.binding?.patternText);
+  if (patternTexts.some((text) => !sameVariableDeclaratorText(text, patternTexts[0]))) {
+    return [
+      'binding-pattern-shape-changed',
+      'binding-pattern-merge-requires-binding-use-evidence'
+    ];
+  }
+  const bindingNames = declarators.map((entry) => (entry.binding?.bindingNames ?? []).join('\0'));
+  if (bindingNames.some((names) => names !== bindingNames[0])) {
+    return [
+      'binding-pattern-binding-set-changed',
+      'binding-pattern-merge-requires-binding-use-evidence'
+    ];
+  }
+  return [];
+}
+
+function declaratorKeyChangeReasonCodes(base, worker, head, current) {
+  return [base, worker, head, current].some((entry) => entry?.binding?.kind === 'binding-pattern')
+    ? ['binding-pattern-kind-changed', 'binding-pattern-merge-requires-binding-use-evidence']
+    : [];
+}
+
+function bindingDeclaratorConflictReasonCodes(base) {
+  return base?.binding?.kind === 'binding-pattern'
+    ? ['binding-pattern-merge-requires-binding-use-evidence']
+    : [];
+}
+
 function semanticArtifactGates(artifacts) {
   return [
     gate('semantic-edit-script', artifacts.script?.admission?.status === 'auto-merge-candidate', artifacts.script?.admission?.reasonCodes),
@@ -177,8 +233,70 @@ function gate(id, passed, reasonCodes = []) {
   return { id, status: passed ? 'passed' : 'blocked', reasonCodes: passed ? [] : uniqueStrings(reasonCodes) };
 }
 
+function variableDeclaratorBlockedResult(input, topLevelResult, resultBase, stagedFallback, merge) {
+  const reasonCodes = merge.reasonCodes;
+  const language = input.language ?? topLevelResult.language ?? 'typescript';
+  const sourcePath = input.sourcePath ?? topLevelResult.sourcePath ?? 'inline.ts';
+  return {
+    ...resultBase,
+    id: String(input.id ?? resultBase.id ?? topLevelResult.id),
+    status: JsTsSafeMergeStatuses.blocked,
+    mergedSourceText: undefined,
+    outputSourceText: undefined,
+    conflicts: [{
+      code: reasonCodes[0] ?? 'binding-pattern-merge-blocked',
+      gateId: 'variable-declarator-binding-pattern',
+      message: 'JS/TS variable declarator binding pattern requires binding/use evidence before automatic merge.',
+      side: 'worker',
+      sourcePath,
+      details: {
+        reasonCodes,
+        originalReasonCodes: topLevelResult.admission?.reasonCodes ?? []
+      }
+    }],
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes
+    },
+    summary: {
+      ...resultBase.summary,
+      changedExistingDeclarations: semanticFallbackChangedExistingDeclarations(topLevelResult, resultBase, stagedFallback),
+      conflicts: 1,
+      variableDeclaratorBindingPatternBlocks: 1,
+      composedPhases: stagedFallback ? 2 : 1
+    },
+    metadata: {
+      ...resultBase.metadata,
+      composed: {
+        phase: stagedFallback
+          ? 'staged-top-level-variable-declarator-binding-pattern-classification'
+          : 'variable-declarator-binding-pattern-classification',
+        phases: stagedFallback
+          ? ['top-level-neutralization', 'top-level-ledger', 'variable-declarator-binding-pattern']
+          : ['top-level-ledger', 'variable-declarator-binding-pattern'],
+        originalReasonCodes: topLevelResult.admission?.reasonCodes ?? [],
+        stagedTopLevelSummary: stagedFallback?.stagedTopLevelResult?.summary,
+        neutralization: stagedFallback?.neutralization?.summary,
+        variableDeclaratorFallback: merge.summary,
+        language
+      }
+    }
+  };
+}
+
 function blocked(...reasonCodes) {
-  return { ok: false, reasonCodes: uniqueStrings(reasonCodes) };
+  const normalized = uniqueStrings(reasonCodes);
+  return {
+    ok: false,
+    reasonCodes: normalized,
+    sourceShapeBlocked: normalized.some((reasonCode) => reasonCode.startsWith('binding-pattern-')),
+    summary: { reasonCodes: normalized }
+  };
 }
 
 function blockedStatement(...reasonCodes) {

package/dist/js-ts-safe-merge-variable-declarator-parser.js

@@ -1,3 +1,7 @@
+import {
+  analyzeJsTsBindingPattern,
+  leadingJsTsBindingPatternText
+} from './js-ts-safe-merge-binding-patterns.js';
 import { normalizeLineEndings, uniqueStrings } from './js-ts-safe-merge-context.js';
 
 function variableStatementsByKey(sourceText) {
@@ -27,14 +31,14 @@ function parseVariableStatement(statement) {
   const declaratorText = text.slice(prefixEnd, suffixStart);
   if (/[\r\n]/.test(declaratorText)) return undefined;
   const declarators = splitDeclarators(declaratorText, prefixEnd);
-  if (declarators.length < 2 || declarators.some((entry) => !entry.name)) return undefined;
+  if (declarators.length < 2 || declarators.some((entry) => !entry.key)) return undefined;
   return {
     start: statement.start,
     end: statement.end,
     text,
     prefix: text.slice(0, prefixEnd),
     suffix: text.slice(suffixStart),
-    names: declarators.map((entry) => entry.name),
+    names: declarators.map((entry) => entry.key),
     declarators
   };
 }
@@ -104,15 +108,41 @@ function declaratorPart(text, start, end, offset) {
   while (localStart < localEnd && /\s/u.test(text[localStart])) localStart += 1;
   while (localEnd > localStart && /\s/u.test(text[localEnd - 1])) localEnd -= 1;
   const value = text.slice(localStart, localEnd);
-  const name = /^[A-Za-z_$][\w$]*/u.exec(value)?.[0];
+  const binding = declaratorBinding(value);
   return {
-    name: name && value[name.length] !== '?' ? name : undefined,
+    name: binding?.name,
+    key: binding?.key,
+    binding,
     text: value,
     start: offset + localStart,
     end: offset + localEnd
   };
 }
 
+function declaratorBinding(value) {
+  const identifier = /^[A-Za-z_$][\w$]*/u.exec(value)?.[0];
+  if (identifier && value[identifier.length] !== '?') {
+    return { kind: 'identifier', patternKind: 'identifier', name: identifier, key: identifier, reasonCodes: [] };
+  }
+  let start = 0;
+  while (start < value.length && /\s/u.test(value[start])) start += 1;
+  const open = value[start];
+  if (open !== '{' && open !== '[') return undefined;
+  const patternKind = open === '{' ? 'object' : 'array';
+  const patternText = leadingJsTsBindingPatternText(value.slice(start), patternKind);
+  if (!patternText) return undefined;
+  const pattern = analyzeJsTsBindingPattern(patternText, patternKind);
+  return {
+    kind: 'binding-pattern',
+    patternKind: pattern.patternKind,
+    name: `binding-pattern:${pattern.patternKind}`,
+    key: `binding-pattern:${pattern.patternKind}`,
+    patternText,
+    bindingNames: pattern.bindingNames,
+    reasonCodes: pattern.reasonCodes
+  };
+}
+
 function topLevelStatements(sourceText) {
   const statements = [];
   let start = 0;