Factoring out intermediate/partial strings fails the build

[samreid]

@jessegreenberg @pixelzoom and I have all been recently affected by a constraint in or around chipper/js/grunt/getStringMap.ts that makes it impossible to factor out repeated string accesses. @pixelzoom described the problem in phetsims/calculus-grapher#375.

One problem is that the "No value for string" error doesn't mention anything about the cause of the problem.

Let's bring this to developer meeting to see how we could add better support for this, and if we want to prioritize it.

[pixelzoom]

An example of the benefits of factoring out part of the string identifier is ReferenceLineDescriber.ts, where CalculusGrapherFluent.a11y.referenceLine.accessibleObjectResponse appears 20 times. The code would be more readable and maintainable if this const could be factored out:

const ACCESSIBLE_OBJECT_RESPONSE_STRING = CalculusGrapherFluent.a11y.referenceLine.accessibleObjectResponse;

... but factoring out part of the identifer is what causes the build failure.

Also mentioning that I had applied this pattern (consistently) throughout calculus-grapher in phetsims/calculus-grapher@242e14d. Later I had to revert (some of it manually) in phetsims/calculus-grapher@fa23238. This affected 39 source files.

[samreid]

This patch works properly in my testing (only allows within-file (intrafile) references, and does not support inter-file references)

Details

Subject: [PATCH] Only play sound effect when vertex cuts, see https://github.com/phetsims/circuit-construction-kit-common/issues/1232
---
Index: chipper/js/grunt/resolveConstAliases.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/chipper/js/grunt/resolveConstAliases.ts b/chipper/js/grunt/resolveConstAliases.ts
new file mode 100644
--- /dev/null	(date 1771037229303)
+++ b/chipper/js/grunt/resolveConstAliases.ts	(date 1771037229303)
@@ -0,0 +1,117 @@
+// Copyright 2026, University of Colorado Boulder
+
+/**
+ * Resolves const aliases for *Strings and *Fluent property-access chains in comment-stripped source code, so that
+ * the string scanner in getStringMap.ts can detect string accesses even when the developer factors out a common
+ * prefix into a local constant.
+ *
+ * For example, this code:
+ *
+ *   const AOR = CalculusGrapherFluent.a11y.referenceLine.accessibleObjectResponse;
+ *   AOR.xPhrase.format( ... )
+ *
+ * is transformed (for scanning purposes only) into:
+ *
+ *   CalculusGrapherFluent.a11y.referenceLine.accessibleObjectResponse.xPhrase.format( ... )
+ *
+ * Supports transitive resolution, so chains of const aliases also work:
+ *
+ *   const A = CalculusGrapherFluent.a11y;
+ *   const B = A.referenceLine;
+ *   B.accessibleObjectResponse.xPhrase  =>  CalculusGrapherFluent.a11y.referenceLine.accessibleObjectResponse.xPhrase
+ *
+ * Only const declarations are resolved (not let or var) because const guarantees the binding cannot be reassigned,
+ * making the alias stable and safe to inline.
+ *
+ * Only aliases whose chain ultimately starts with a *Strings or *Fluent identifier are expanded. All other const
+ * declarations are left untouched.
+ *
+ * This function operates on a single file's content (intra-file only). It returns a new string suitable for
+ * string-access scanning — no source files are modified.
+ *
+ * @author Sam Reid (PhET Interactive Simulations)
+ */
+
+// Matches: const NAME = some.chain.of.identifiers;
+// Only simple property-access chains on the RHS — no function calls, destructuring, ternaries, etc.
+const CONST_ALIAS_PATTERN = /\bconst\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*([a-zA-Z_$][a-zA-Z0-9_$]*(?:\.[a-zA-Z_$][a-zA-Z0-9_$]*)+)\s*;/g;
+
+/**
+ * Expands const aliases for *Strings/*Fluent property-access chains in the given comment-stripped file content.
+ *
+ * @param fileContent - Comment-stripped source code of a single module
+ * @returns The file content with resolved const aliases expanded, ready for string-access scanning
+ */
+export default function resolveConstAliases( fileContent: string ): string {
+
+  // Collect all const alias declarations: name → property-access chain.
+  const aliases = new Map<string, string>();
+  const declarations = new Map<string, string>(); // alias name → full declaration text
+  let match;
+  while ( ( match = CONST_ALIAS_PATTERN.exec( fileContent ) ) !== null ) {
+    aliases.set( match[ 1 ], match[ 2 ] );
+    declarations.set( match[ 1 ], match[ 0 ] );
+  }
+
+  if ( aliases.size === 0 ) {
+    return fileContent;
+  }
+
+  // Resolve transitively: if the first segment of a chain is itself an alias, substitute it.
+  // Each pass resolves one level of indirection. At most aliases.size passes are needed (the longest possible
+  // chain of aliases). In valid code, const declarations cannot be circular (TDZ), so this always terminates.
+  for ( let i = 0; i < aliases.size; i++ ) {
+    let changed = false;
+    for ( const [ name, chain ] of aliases ) {
+      const dotIndex = chain.indexOf( '.' );
+      const firstSegment = dotIndex === -1 ? chain : chain.substring( 0, dotIndex );
+
+      if ( firstSegment !== name && aliases.has( firstSegment ) ) {
+        const rest = dotIndex === -1 ? '' : chain.substring( dotIndex );
+        aliases.set( name, aliases.get( firstSegment )! + rest );
+        changed = true;
+      }
+    }
+    if ( !changed ) {
+      break;
+    }
+  }
+
+  // Keep only aliases that:
+  // 1. Resolve to a chain starting with a *Fluent or *Strings identifier, AND
+  // 2. Are actually used with further property access (aliasName.something) in the file.
+  // Condition 2 filters out leaf-value extractions like:
+  //   const soundsLabelStringProperty = JoistFluent.preferences.tabs.audio.sounds.titleStringProperty;
+  // which are used standalone and already correctly detected by the existing scanner.
+  const resolvedAliases = new Map<string, string>();
+  for ( const [ name, chain ] of aliases ) {
+    const root = chain.split( '.' )[ 0 ];
+    const isFluentOrStrings = root.endsWith( 'Fluent' ) || root.endsWith( 'Strings' );
+    const isUsedWithPropertyAccess = new RegExp( `(?<!\\.)\\b${name}\\s*\\.` ).test( fileContent );
+    if ( isFluentOrStrings && isUsedWithPropertyAccess ) {
+      resolvedAliases.set( name, chain );
+    }
+  }
+
+  if ( resolvedAliases.size === 0 ) {
+    return fileContent;
+  }
+
+  let result = fileContent;
+
+  // Remove the const declaration lines for resolved aliases, so that intermediate paths
+  // (e.g. CalculusGrapherFluent.a11y.referenceLine.accessibleObjectResponse) are not falsely
+  // detected as leaf string keys by the scanner.
+  for ( const name of resolvedAliases.keys() ) {
+    result = result.replace( declarations.get( name )!, '' );
+  }
+
+  // Expand each alias to its fully-resolved chain. The negative lookbehind (?<!\.) ensures we only
+  // replace the alias when it appears as a standalone identifier (the start of an access chain), not
+  // when it appears as a property being accessed on another object (e.g. something.helpPatterns).
+  for ( const [ name, chain ] of resolvedAliases ) {
+    result = result.replace( new RegExp( `(?<!\\.)\\b${name}\\b`, 'g' ), chain );
+  }
+
+  return result;
+}
Index: chipper/js/grunt/getStringMap.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/chipper/js/grunt/getStringMap.ts b/chipper/js/grunt/getStringMap.ts
--- a/chipper/js/grunt/getStringMap.ts	(revision d000627a01d63233d74464960ccf217091bdc826)
+++ b/chipper/js/grunt/getStringMap.ts	(date 1771024637728)
@@ -21,6 +21,7 @@
 import ChipperStringUtils from '../common/ChipperStringUtils.js';
 import pascalCase from '../common/pascalCase.js';
 import { getFluentInternalReferences } from './modulify/getFluentInternalReferences.js';
+import resolveConstAliases from './resolveConstAliases.js';
 
 export type Locale = string;
 
@@ -120,7 +121,9 @@
 
   // Load the file contents of every single JS module that used any strings.
   // Strip out comments so we only find code usages of strings.
-  const usedFileContents = nonFluentModules.map( usedModule => fs.readFileSync( `../${usedModule}`, 'utf-8' ) ).map( fileContent => strip( fileContent ) );
+  const usedFileContents = nonFluentModules.map( usedModule => fs.readFileSync( `../${usedModule}`, 'utf-8' ) )
+    .map( fileContent => strip( fileContent ) )
+    .map( fileContent => resolveConstAliases( fileContent ) );
 
   // Compute which repositories contain one or more used strings (since we'll need to load string files for those
   // repositories).
Index: energy-skate-park/js/common/view/EnergyBarGraphAccordionBox.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/energy-skate-park/js/common/view/EnergyBarGraphAccordionBox.ts b/energy-skate-park/js/common/view/EnergyBarGraphAccordionBox.ts
--- a/energy-skate-park/js/common/view/EnergyBarGraphAccordionBox.ts	(revision bb66c8f3e155779e5597716d5328294faba0f4b2)
+++ b/energy-skate-park/js/common/view/EnergyBarGraphAccordionBox.ts	(date 1771025040929)
@@ -42,6 +42,7 @@
       excludeInvisible: false
     } );
 
+    const myAccordionBox = EnergySkateParkFluent.a11y.energyBarGraphAccordionBox;
     const options = optionize4<EnergyBarGraphAccordionBoxOptions, SelfOptions, AccordionBoxOptions>()( {}, {
       titleNode: titleContainer,
 
@@ -60,7 +61,7 @@
         sideLength: 19
       },
 
-      accessibleName: EnergySkateParkFluent.a11y.energyBarGraphAccordionBox.accessibleNameStringProperty,
+      accessibleName: myAccordionBox.accessibleNameStringProperty,
 
       tandem: tandem
     }, EnergySkateParkConstants.GRAPH_PANEL_OPTIONS, providedOptions );
@@ -73,7 +74,7 @@
       graphIcon.visible = !visible;
 
       // Show help text only when the accordion box is expanded (AccordionBox only supports collapsed help text natively)
-      this.accessibleHelpText = visible ? EnergySkateParkFluent.a11y.energyBarGraphAccordionBox.accessibleHelpTextExpandedStringProperty : null;
+      this.accessibleHelpText = visible ? myAccordionBox.accessibleHelpTextExpandedStringProperty : null;
     } );
   }
 }

[samreid]

From today's meeting, we would like @jonathanolson to review this problem and the proposed solution in the patch above.

[jonathanolson]

I'm a bit worried about the "sliding slope" with this (finding another method to handle string inclusion might be good), but this DOES seem practically useful for now.

The CONST_ALIAS_PATTERN looks like it diverges significantly from the regex used for that purpose in getStringMap, and I'm curious about the discrepancies or why we'd want something so different:

• It doesn't support cases where we need to escape characters, e.g. const Group = SomethingFluent.first[ 'needs-dash' ].third. That is likely required for strings that include dashes in keys (even if we're not adding more that have dashes). This will also need to be handled for the lookup in isUsedWithPropertyAccess..
• It doesn't support cases with keys that are only one character, e.g. SomethingFluent.a.

There are additional pitfalls like doing things in different scopes:

{
  const Strings = SomethingFluent.first;
  // uses Strings
}
{
  const Strings = SomethingFluent.second;
  // uses Strings
}

At the very least, we should ensure that we fail out on duplicate alias keys (but... only those that are used for strings, notably because that step picks up tons of NON-string aliases also, we'll want to not fail out on two const padding = in a file).

In the expression for isUsedWithPropertyAccess, it is handling cases where spaces are present before the . in a property access (e.g. JS allows object .value). I'm not handling this in getStringMap. Perhaps we should enable that? (Also this will need to generalize to arbitrary whitespace... newlines look like they can be inserted in those locations also).

Additionally, this is basically being run on every file. Instead of mapping it for every usedFileContents, can we only run it on the files that go through the matching of the import format first? If it has no imports of that type, we won't need to process it.

Also nice, I hadn't seen negative lookbehinds in JS regexps before, that was a helpful thing to review so I can use it in the future!

[samreid]

This idea uses the typescript AST for a more robust search:

Details

Subject: [PATCH] Add units 'A' for current, and remove unused processors, see https://github.com/phetsims/circuit-construction-kit-common/issues/1276
---
Index: chipper/js/grunt/getStringMap.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/chipper/js/grunt/getStringMap.ts b/chipper/js/grunt/getStringMap.ts
--- a/chipper/js/grunt/getStringMap.ts	(revision 445ac331b00ddfa96bc5f2dc72de2ae2b658118f)
+++ b/chipper/js/grunt/getStringMap.ts	(date 1772423407929)
@@ -20,6 +20,7 @@
 import ChipperConstants from '../common/ChipperConstants.js';
 import ChipperStringUtils from '../common/ChipperStringUtils.js';
 import pascalCase from '../common/pascalCase.js';
+import getStringAccessesFromFile from './getStringAccessesFromFile.js';
 import { getFluentInternalReferences } from './modulify/getFluentInternalReferences.js';
 
 export type Locale = string;
@@ -187,42 +188,25 @@
         // Only scan files where we can identify an import for it
         if ( fileContent.includes( `import ${prefix} from` ) ) {
 
-          // Look for normal matches, e.g. `JoistStrings.` followed by one or more chunks like:
-          // .somethingVaguely_alphaNum3r1c
-          // [ 'aStringInBracketsBecauseOfSpecialCharacters' ]
-          //
-          // It will also then end on anything that doesn't look like another one of those chunks
-          // [a-zA-Z_$][a-zA-Z0-9_$]* ---- this grabs things that looks like valid JS identifiers
-          // \\[ '[^']+' \\])+ ---- this grabs things like our second case above
-          // [^\\.\\[] ---- matches something at the end that is NOT either of those other two cases
-          // It is also generalized to support arbitrary whitespace and requires that ' match ' or " match ", since
-          // this must support JS code and minified TypeScript code
-          // Matches one final character that is not '.' or '[', since any valid string accesses should NOT have that
-          // after. NOTE: there are some degenerate cases that will break this, e.g.:
-          // - JoistStrings.someStringProperty[ 0 ]
-          // - JoistStrings.something[ 0 ]
-          // - JoistStrings.something[ 'length' ]
-          const matches = fileContent.match( new RegExp( `${prefix}(\\.[a-zA-Z_$][a-zA-Z0-9_$]*|\\[\\s*['"][^'"]+['"]\\s*\\])+[^\\.\\[]`, 'g' ) );
-          if ( matches ) {
-            stringAccesses.push( ...matches.map( match => {
-              return match
-                // We always have to strip off the last character - it's a character that shouldn't be in a string access
-                .slice( 0, match.length - 1 )
-                // Handle JoistStrings[ 'some-thingStringProperty' ].value => JoistStrings[ 'some-thing' ]
-                // -- Anything after StringProperty should go
-                // away, but we need to add the final '] to maintain the format
-                .replace( /StringProperty'\s?].*/, '\']' )
-                // Handle JoistStrings.somethingStringProperty.value => JoistStrings.something
-                .replace( /StringProperty.*/, '' )
-                // .format( ... )
-                .replace( /\.format.*/, '' )
-                // .createProperty( ... )
-                .replace( /\.createProperty.*/, '' )
-                // Normalize whitespace
-                .replace( /\[ '/g, '[\'' )
-                .replace( /' \]/g, '\']' );
-            } ) );
-          }
+          // Use AST-based scanner to find all string access chains, resolving const aliases.
+          // This replaces the previous regex-based scanner and correctly handles patterns like:
+          //   const AOR = CalculusGrapherFluent.a11y.referenceLine.accessibleObjectResponse;
+          //   AOR.xPhrase.format( ... )
+          const rawAccesses = getStringAccessesFromFile( fileContent, [ prefix ] );
+          stringAccesses.push( ...rawAccesses.map( match => {
+            return match
+              // Handle FooStrings[ 'some-thingStringProperty' ].value => FooStrings[ 'some-thing' ]
+              .replace( /StringProperty'\s?].*/, '\']' )
+              // Handle FooStrings.somethingStringProperty.value => FooStrings.something
+              .replace( /StringProperty.*/, '' )
+              // .format( ... )
+              .replace( /\.format.*/, '' )
+              // .createProperty( ... )
+              .replace( /\.createProperty.*/, '' )
+              // Normalize whitespace in bracket notation
+              .replace( /\[ '/g, '[\'' )
+              .replace( /' \]/g, '\']' );
+          } ) );
         }
       } );
     } );
@@ -233,6 +217,8 @@
       return prefixes.reduce( ( acc, pre ) => acc.startsWith( pre ) ? acc.slice( pre.length ) : acc, str );
     } );
 
+    console.log( stringAccesses );
+
     // Search for any string accesses that are in used fluent patterns. They are not used direcly in simulation code,
     // but are used, so they need to be in the string map.
     const englishStringContents = stringFilesContents[ repo ][ ChipperConstants.FALLBACK_LOCALE ];
Index: perennial-alias/js/npm-dependencies/typescript.js
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/perennial-alias/js/npm-dependencies/typescript.js b/perennial-alias/js/npm-dependencies/typescript.js
new file mode 100644
--- /dev/null	(date 1772422612172)
+++ b/perennial-alias/js/npm-dependencies/typescript.js	(date 1772422612172)
@@ -0,0 +1,10 @@
+// Copyright 2026, University of Colorado Boulder
+
+/**
+ * To be used when trying to import typescript from other repos.
+ * @author Sam Reid (PhET Interactive Simulations)
+ */
+
+import ts from 'typescript';
+
+export default ts;
Index: chipper/js/grunt/getStringAccessesFromFile.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/chipper/js/grunt/getStringAccessesFromFile.ts b/chipper/js/grunt/getStringAccessesFromFile.ts
new file mode 100644
--- /dev/null	(date 1772423158392)
+++ b/chipper/js/grunt/getStringAccessesFromFile.ts	(date 1772423158392)
@@ -0,0 +1,253 @@
+// Copyright 2026, University of Colorado Boulder
+
+/* eslint-disable no-undef */
+// eslint-disable-next-line phet/bad-typescript-text
+// @ts-nocheck
+
+/**
+ * Uses TypeScript's AST parser to extract string access chains from a source file, resolving const aliases.
+ * This replaces the regex-based string access scanner in getStringMap.ts, providing correct handling of:
+ *
+ *  - Const aliases: const AOR = CalculusGrapherFluent.a11y.referenceLine.accessibleObjectResponse; AOR.xPhrase
+ *  - Transitive aliases: const A = FooFluent.a; const B = A.b; B.c
+ *  - Bracket notation: FooFluent['some-key'].x
+ *  - Single-character keys: FooFluent.a.b
+ *  - Scoping safety: duplicate alias names in different scopes are conservatively skipped
+ *
+ * The output format matches the previous regex scanner's output (before post-processing), so all downstream
+ * processing in getStringMap.ts (StringProperty stripping, .format removal, etc.) works unchanged.
+ *
+ * @author Sam Reid (PhET Interactive Simulations)
+ */
+
+import typescript from '../../../perennial-alias/js/npm-dependencies/typescript.js';
+const ts = typescript;
+
+/**
+ * Resolves a property-access chain from an AST node into a dot/bracket string representation.
+ * Returns null if the chain does not root at a known prefix or alias.
+ */
+function resolveChain(
+  node: ts.Expression,
+  prefixes: string[],
+  aliases: Map<string, string>,
+  ambiguousAliases: Set<string>
+): string | null {
+
+  // Identifier: check if it's a known prefix or alias
+  if ( ts.isIdentifier( node ) ) {
+    const name = node.text;
+    if ( prefixes.includes( name ) ) {
+      return name;
+    }
+    if ( !ambiguousAliases.has( name ) && aliases.has( name ) ) {
+      return aliases.get( name )!;
+    }
+    return null;
+  }
+
+  // PropertyAccessExpression: expr.name
+  if ( ts.isPropertyAccessExpression( node ) ) {
+    const base = resolveChain( node.expression, prefixes, aliases, ambiguousAliases );
+    if ( base !== null ) {
+      return base + '.' + node.name.text;
+    }
+    return null;
+  }
+
+  // ElementAccessExpression: expr['key']
+  if ( ts.isElementAccessExpression( node ) ) {
+    const base = resolveChain( node.expression, prefixes, aliases, ambiguousAliases );
+    if ( base !== null && ts.isStringLiteral( node.argumentExpression ) ) {
+      return base + '[\'' + node.argumentExpression.text + '\']';
+    }
+    return null;
+  }
+
+  // Everything else (CallExpression, BinaryExpression, etc.) terminates the chain
+  return null;
+}
+
+/**
+ * Returns true if the parent node extends this node's property chain further, meaning we should skip
+ * capturing at this node and let the parent capture the longer chain.
+ */
+function parentExtendsChain( node: ts.Node ): boolean {
+  const parent = node.parent;
+  return (
+    ( ts.isPropertyAccessExpression( parent ) && parent.expression === node ) ||
+    ( ts.isElementAccessExpression( parent ) && parent.expression === node )
+  );
+}
+
+/**
+ * Extracts string access chains from comment-stripped file content using TypeScript's AST parser.
+ *
+ * @param fileContent - Comment-stripped source code of a single module
+ * @param prefixes - String module prefixes to look for, e.g. ['JoistStrings', 'JoistFluent']
+ * @returns Array of raw chain strings like 'JoistStrings.ResetAllButton.nameStringProperty'
+ */
+export default function getStringAccessesFromFile( fileContent: string, prefixes: string[] ): string[] {
+
+  const sourceFile = ts.createSourceFile( 'file.js', fileContent, ts.ScriptTarget.Latest, true );
+
+  // Map: alias name → resolved chain string
+  const aliases = new Map<string, string>();
+
+  // Alias names that appear in multiple const declarations (different scopes) — skip these
+  const ambiguousAliases = new Set<string>();
+
+  // Map: alias name → resolved chain string of the initializer (for post-filtering)
+  const aliasInitializerChains = new Map<string, string>();
+
+  // Track which aliases were used as the root of a further property chain
+  const aliasUsedAsChainRoot = new Set<string>();
+
+  // Track which aliases were used standalone (so we don't filter their initializer chains)
+  const aliasUsedStandalone = new Set<string>();
+
+  // Collected string access chains
+  const accesses: string[] = [];
+
+  // --- Pass 1: Collect const alias declarations ---
+
+  function collectAliases( node: ts.Node ): void {
+
+    if ( ts.isVariableStatement( node ) ) {
+      const declList = node.declarationList;
+
+      // eslint-disable-next-line no-bitwise
+      if ( declList.flags & ts.NodeFlags.Const ) {
+        for ( const decl of declList.declarations ) {
+          if ( decl.initializer && ts.isIdentifier( decl.name ) ) {
+            const chain = resolveChain( decl.initializer, prefixes, aliases, ambiguousAliases );
+            if ( chain !== null ) {
+              const name = decl.name.text;
+
+              if ( aliases.has( name ) ) {
+
+                // Duplicate name — mark as ambiguous, remove from tracking
+                ambiguousAliases.add( name );
+                aliases.delete( name );
+                aliasInitializerChains.delete( name );
+              }
+              else {
+                aliases.set( name, chain );
+                aliasInitializerChains.set( name, chain );
+              }
+            }
+          }
+        }
+      }
+    }
+
+    ts.forEachChild( node, collectAliases );
+  }
+
+  collectAliases( sourceFile );
+
+  // --- Pass 2: Collect string accesses ---
+
+  function collectAccesses( node: ts.Node ): void {
+
+    // PropertyAccessExpression or ElementAccessExpression: try to resolve as string chain
+    if ( ts.isPropertyAccessExpression( node ) || ts.isElementAccessExpression( node ) ) {
+      const chain = resolveChain( node, prefixes, aliases, ambiguousAliases );
+      if ( chain !== null ) {
+
+        // Only capture if the parent doesn't extend this chain further
+        if ( !parentExtendsChain( node ) ) {
+          accesses.push( chain );
+
+          // Track which alias was at the root (if any)
+          trackAliasUsage( node );
+        }
+
+        // Don't recurse into children — they are part of this chain
+        return;
+      }
+    }
+
+    // CallExpression: check if the callee is a string chain (handles .format(), .createProperty(), etc.)
+    if ( ts.isCallExpression( node ) ) {
+      const chain = resolveChain( node.expression, prefixes, aliases, ambiguousAliases );
+      if ( chain !== null ) {
+        accesses.push( chain );
+
+        // Track which alias was at the root (if any)
+        trackAliasUsage( node.expression );
+
+        // Recurse into arguments only (not the callee — already captured)
+        for ( const arg of node.arguments ) {
+          collectAccesses( arg );
+        }
+        return;
+      }
+    }
+
+    // Identifier: check if it's a known alias used standalone (not as part of a chain or declaration)
+    if ( ts.isIdentifier( node ) ) {
+      const name = node.text;
+      if ( !ambiguousAliases.has( name ) && aliases.has( name ) ) {
+
+        const parent = node.parent;
+
+        // Skip when this identifier is the .expression of a property chain (handled above)
+        const isChainExpression =
+          ( ts.isPropertyAccessExpression( parent ) && parent.expression === node ) ||
+          ( ts.isElementAccessExpression( parent ) && parent.expression === node );
+
+        // Skip when it's the name of a variable declaration (e.g. the "AOR" in "const AOR = ...")
+        const isDeclarationName = ts.isVariableDeclaration( parent ) && parent.name === node;
+
+        if ( !isChainExpression && !isDeclarationName ) {
+          // Standalone usage of an alias — add the resolved chain
+          accesses.push( aliases.get( name )! );
+          aliasUsedStandalone.add( name );
+        }
+      }
+    }
+
+    ts.forEachChild( node, collectAccesses );
+  }
+
+  /**
+   * Given a node in a resolved chain, find which alias (if any) is at its root and mark it as used
+   * as a chain root. This is used to determine which alias initializers to filter out later.
+   */
+  function trackAliasUsage( node: ts.Node ): void {
+    if ( ts.isIdentifier( node ) ) {
+      const name = node.text;
+      if ( aliases.has( name ) ) {
+        aliasUsedAsChainRoot.add( name );
+      }
+    }
+    else if ( ts.isPropertyAccessExpression( node ) ) {
+      trackAliasUsage( node.expression );
+    }
+    else if ( ts.isElementAccessExpression( node ) ) {
+      trackAliasUsage( node.expression );
+    }
+  }
+
+  collectAccesses( sourceFile );
+
+  // --- Post-filtering: Remove intermediate alias initializer chains ---
+  // For aliases that were used ONLY as the root of a further property chain (e.g. AOR.d.e),
+  // the initializer path (e.g. FooFluent.a.b.c) is an intermediate namespace path that would
+  // cause "no value for string" errors. Remove it from the results.
+  // If the alias was ALSO used standalone, keep the initializer (it's needed for the standalone usage).
+  // Aliases that were NOT used as chain roots keep their initializer (it's a direct leaf access).
+  const initializerChainsToRemove = new Set<string>();
+  for ( const name of aliasUsedAsChainRoot ) {
+    if ( aliasInitializerChains.has( name ) && !aliasUsedStandalone.has( name ) ) {
+      initializerChainsToRemove.add( aliasInitializerChains.get( name )! );
+    }
+  }
+
+  const filtered = initializerChainsToRemove.size > 0
+    ? accesses.filter( access => !initializerChainsToRemove.has( access ) )
+    : accesses;
+
+  return [ ...new Set( filtered ) ];
+}
Index: chipper/js/test/chipper-tests.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/chipper/js/test/chipper-tests.ts b/chipper/js/test/chipper-tests.ts
--- a/chipper/js/test/chipper-tests.ts	(revision 445ac331b00ddfa96bc5f2dc72de2ae2b658118f)
+++ b/chipper/js/test/chipper-tests.ts	(date 1772422723961)
@@ -15,5 +15,6 @@
 
 
 import '../common/ChipperStringUtilTests.js';
+import '../grunt/getStringAccessesFromFileTests.js';
 import '../phet-io/phetioCompareAPIsTests.js';
 import '../phet-io/isInitialStateCompatibleTests.js';
\ No newline at end of file
Index: chipper/js/grunt/getStringAccessesFromFileTests.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/chipper/js/grunt/getStringAccessesFromFileTests.ts b/chipper/js/grunt/getStringAccessesFromFileTests.ts
new file mode 100644
--- /dev/null	(date 1772422806671)
+++ b/chipper/js/grunt/getStringAccessesFromFileTests.ts	(date 1772422806671)
@@ -0,0 +1,186 @@
+// Copyright 2026, University of Colorado Boulder
+
+// eslint-disable-next-line phet/bad-typescript-text
+// @ts-nocheck
+
+/**
+ * Tests for getStringAccessesFromFile — the AST-based string access scanner.
+ * @author Sam Reid (PhET Interactive Simulations)
+ */
+
+import qunit from '../../../perennial-alias/js/npm-dependencies/qunit.js';
+import getStringAccessesFromFile from './getStringAccessesFromFile.js';
+
+qunit.module( 'getStringAccessesFromFile' );
+
+qunit.test( 'direct property access', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const x = FooStrings.bar.baz;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.ok( result.includes( 'FooStrings.bar.baz' ), 'should find direct access FooStrings.bar.baz' );
+} );
+
+qunit.test( 'const alias with further property access', assert => {
+  const code = `
+    import FooFluent from './FooFluent.js';
+    const AOR = FooFluent.a.b.c;
+    AOR.d.e;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooFluent' ] );
+  assert.ok( result.includes( 'FooFluent.a.b.c.d.e' ), 'should resolve alias AOR to FooFluent.a.b.c.d.e' );
+
+  // The intermediate path (FooFluent.a.b.c) should NOT be captured since the alias is used with further access
+  assert.ok( !result.includes( 'FooFluent.a.b.c' ), 'should NOT capture intermediate alias initializer' );
+} );
+
+qunit.test( 'transitive alias', assert => {
+  const code = `
+    import FooFluent from './FooFluent.js';
+    const A = FooFluent.a;
+    const B = A.b;
+    B.c;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooFluent' ] );
+  assert.ok( result.includes( 'FooFluent.a.b.c' ), 'should resolve transitive alias chain' );
+} );
+
+qunit.test( 'bracket notation', assert => {
+  const code = `
+    import FooFluent from './FooFluent.js';
+    FooFluent['some-key'].x;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooFluent' ] );
+  assert.ok( result.includes( 'FooFluent[\'some-key\'].x' ), 'should handle bracket notation with dashes' );
+} );
+
+qunit.test( 'single-character key', assert => {
+  const code = `
+    import FooFluent from './FooFluent.js';
+    FooFluent.a.b;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooFluent' ] );
+  assert.ok( result.includes( 'FooFluent.a.b' ), 'should handle single-character keys' );
+} );
+
+qunit.test( '.format() call', assert => {
+  const code = `
+    import FooFluent from './FooFluent.js';
+    FooFluent.a11y.something.format( { x: 1 } );
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooFluent' ] );
+  assert.ok( result.includes( 'FooFluent.a11y.something.format' ), 'should capture callee chain including .format' );
+} );
+
+qunit.test( '.createProperty() call', assert => {
+  const code = `
+    import FooFluent from './FooFluent.js';
+    FooFluent.a11y.something.createProperty( { x: prop } );
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooFluent' ] );
+  assert.ok( result.includes( 'FooFluent.a11y.something.createProperty' ), 'should capture callee chain including .createProperty' );
+} );
+
+qunit.test( '.getDependentProperties() call', assert => {
+  const code = `
+    import FooFluent from './FooFluent.js';
+    const deps = FooFluent.a11y.something.getDependentProperties();
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooFluent' ] );
+  assert.ok( result.includes( 'FooFluent.a11y.something.getDependentProperties' ), 'should capture .getDependentProperties callee' );
+} );
+
+qunit.test( 'leaf alias used standalone', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const titleStringProperty = FooStrings.a.titleStringProperty;
+    node.text = titleStringProperty;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.ok( result.includes( 'FooStrings.a.titleStringProperty' ), 'should capture leaf alias used standalone' );
+} );
+
+qunit.test( 'non-string const should be ignored', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const x = 5;
+    const y = someOtherThing.a.b;
+    FooStrings.bar.baz;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.equal( result.length, 1, 'should only find one access' );
+  assert.ok( result.includes( 'FooStrings.bar.baz' ), 'should find the direct access' );
+} );
+
+qunit.test( 'alias with bracket notation', assert => {
+  const code = `
+    import FooFluent from './FooFluent.js';
+    const X = FooFluent['a-b'];
+    X.c;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooFluent' ] );
+  assert.ok( result.includes( 'FooFluent[\'a-b\'].c' ), 'should resolve alias through bracket notation' );
+} );
+
+qunit.test( 'multiple prefixes', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    import FooFluent from './FooFluent.js';
+    FooStrings.bar.baz;
+    FooFluent.a11y.something;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings', 'FooFluent' ] );
+  assert.ok( result.includes( 'FooStrings.bar.baz' ), 'should find FooStrings access' );
+  assert.ok( result.includes( 'FooFluent.a11y.something' ), 'should find FooFluent access' );
+} );
+
+qunit.test( 'alias used both standalone and with further access', assert => {
+  const code = `
+    import FooFluent from './FooFluent.js';
+    const obj = FooFluent.a11y.something;
+    use( obj );
+    obj.child.format( {} );
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooFluent' ] );
+  assert.ok( result.includes( 'FooFluent.a11y.something.child.format' ), 'should capture further access' );
+  assert.ok( result.includes( 'FooFluent.a11y.something' ), 'should capture standalone alias usage' );
+} );
+
+qunit.test( 'alias with .format() call', assert => {
+  const code = `
+    import CalcFluent from './CalcFluent.js';
+    const AOR = CalcFluent.a11y.referenceLine.accessibleObjectResponse;
+    AOR.xPhrase.format( { x: 1 } );
+    AOR.yPhrase.format( { y: 2 } );
+  `;
+  const result = getStringAccessesFromFile( code, [ 'CalcFluent' ] );
+  assert.ok(
+    result.includes( 'CalcFluent.a11y.referenceLine.accessibleObjectResponse.xPhrase.format' ),
+    'should resolve alias + .format for xPhrase'
+  );
+  assert.ok(
+    result.includes( 'CalcFluent.a11y.referenceLine.accessibleObjectResponse.yPhrase.format' ),
+    'should resolve alias + .format for yPhrase'
+  );
+} );
+
+qunit.test( 'prefix used as standalone identifier (not a chain)', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    console.log( FooStrings );
+  `;
+
+  // FooStrings alone (without .something) should NOT be captured
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.equal( result.length, 0, 'bare prefix without property access should not be captured' );
+} );
+
+qunit.test( 'StringProperty access chain', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    FooStrings.bar.bazStringProperty.value;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.ok( result.includes( 'FooStrings.bar.bazStringProperty.value' ), 'should capture full chain including StringProperty.value' );
+} );

[samreid]

This one uses ts-morph to detect string usages:

Details

Subject: [PATCH] Add yaml frontmatter, see https://github.com/phetsims/totality/issues/9
---
Index: perennial-alias/js/npm-dependencies/ts-morph.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/perennial-alias/js/npm-dependencies/ts-morph.ts b/perennial-alias/js/npm-dependencies/ts-morph.ts
new file mode 100644
--- /dev/null	(date 1772478071817)
+++ b/perennial-alias/js/npm-dependencies/ts-morph.ts	(date 1772478071817)
@@ -0,0 +1,8 @@
+// Copyright 2026, University of Colorado Boulder
+
+/**
+ * To be used when trying to import ts-morph from other repos.
+ * @author Sam Reid (PhET Interactive Simulations)
+ */
+
+export { Node, Project, SyntaxKind } from 'ts-morph';
Index: chipper/js/grunt/getStringMap.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/chipper/js/grunt/getStringMap.ts b/chipper/js/grunt/getStringMap.ts
--- a/chipper/js/grunt/getStringMap.ts	(revision cfa59f86c25119552a6130708f11b38da595b978)
+++ b/chipper/js/grunt/getStringMap.ts	(date 1772478071817)
@@ -20,6 +20,7 @@
 import ChipperConstants from '../common/ChipperConstants.js';
 import ChipperStringUtils from '../common/ChipperStringUtils.js';
 import pascalCase from '../common/pascalCase.js';
+import getStringAccessesFromFile from './getStringAccessesFromFile.js';
 import { getFluentInternalReferences } from './modulify/getFluentInternalReferences.js';
 
 export type Locale = string;
@@ -187,42 +188,20 @@
         // Only scan files where we can identify an import for it
         if ( fileContent.includes( `import ${prefix} from` ) ) {
 
-          // Look for normal matches, e.g. `JoistStrings.` followed by one or more chunks like:
-          // .somethingVaguely_alphaNum3r1c
-          // [ 'aStringInBracketsBecauseOfSpecialCharacters' ]
-          //
-          // It will also then end on anything that doesn't look like another one of those chunks
-          // [a-zA-Z_$][a-zA-Z0-9_$]* ---- this grabs things that looks like valid JS identifiers
-          // \\[ '[^']+' \\])+ ---- this grabs things like our second case above
-          // [^\\.\\[] ---- matches something at the end that is NOT either of those other two cases
-          // It is also generalized to support arbitrary whitespace and requires that ' match ' or " match ", since
-          // this must support JS code and minified TypeScript code
-          // Matches one final character that is not '.' or '[', since any valid string accesses should NOT have that
-          // after. NOTE: there are some degenerate cases that will break this, e.g.:
-          // - JoistStrings.someStringProperty[ 0 ]
-          // - JoistStrings.something[ 0 ]
-          // - JoistStrings.something[ 'length' ]
-          const matches = fileContent.match( new RegExp( `${prefix}(\\.[a-zA-Z_$][a-zA-Z0-9_$]*|\\[\\s*['"][^'"]+['"]\\s*\\])+[^\\.\\[]`, 'g' ) );
-          if ( matches ) {
-            stringAccesses.push( ...matches.map( match => {
-              return match
-                // We always have to strip off the last character - it's a character that shouldn't be in a string access
-                .slice( 0, match.length - 1 )
-                // Handle JoistStrings[ 'some-thingStringProperty' ].value => JoistStrings[ 'some-thing' ]
-                // -- Anything after StringProperty should go
-                // away, but we need to add the final '] to maintain the format
-                .replace( /StringProperty'\s?].*/, '\']' )
-                // Handle JoistStrings.somethingStringProperty.value => JoistStrings.something
-                .replace( /StringProperty.*/, '' )
-                // .format( ... )
-                .replace( /\.format.*/, '' )
-                // .createProperty( ... )
-                .replace( /\.createProperty.*/, '' )
-                // Normalize whitespace
-                .replace( /\[ '/g, '[\'' )
-                .replace( /' \]/g, '\']' );
-            } ) );
-          }
+          // Use ts-morph AST scanner to find all property-access chains rooted at this prefix,
+          // resolving const aliases so that factored-out intermediate strings are followed correctly.
+          const matches = getStringAccessesFromFile( fileContent, [ prefix ] );
+          stringAccesses.push( ...matches.map( match => {
+            return match
+              // Handle FooStrings[ 'some-thingStringProperty' ].value => FooStrings[ 'some-thing' ]
+              .replace( /StringProperty'\s?].*/, '\']' )
+              // Handle FooStrings.somethingStringProperty.value => FooStrings.something
+              .replace( /StringProperty.*/, '' )
+              // .format( ... )
+              .replace( /\.format.*/, '' )
+              // .createProperty( ... )
+              .replace( /\.createProperty.*/, '' );
+          } ) );
         }
       } );
     } );
Index: chipper/js/grunt/getStringAccessesFromFile.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/chipper/js/grunt/getStringAccessesFromFile.ts b/chipper/js/grunt/getStringAccessesFromFile.ts
new file mode 100644
--- /dev/null	(date 1772478071817)
+++ b/chipper/js/grunt/getStringAccessesFromFile.ts	(date 1772478071817)
@@ -0,0 +1,197 @@
+// Copyright 2026, University of Colorado Boulder
+
+/**
+ * Uses ts-morph to scan a TypeScript/JavaScript file for property-access chains
+ * rooted at specified prefixes (e.g., FooStrings, FooFluent). Resolves const
+ * aliases so that:
+ *   const AOR = FooStrings.a11y.response;
+ *   AOR.phrase
+ * correctly produces 'FooStrings.a11y.response.phrase'.
+ *
+ * @author Sam Reid (PhET Interactive Simulations)
+ */
+
+import { Node, Project, SyntaxKind } from '../../../perennial-alias/js/npm-dependencies/ts-morph.js';
+
+// Singleton project with in-memory filesystem — avoids recreating the compiler for every file.
+const project = new Project( { useInMemoryFileSystem: true } );
+
+type ChainResult = { chain: string; aliasName: string | null };
+
+/**
+ * Walk a property-access / element-access chain from tip to root, collecting
+ * text segments. Returns the full resolved chain string and which alias (if any)
+ * was resolved at the root; or null if the chain is not rooted at a known prefix
+ * or alias.
+ */
+function resolveChain( node: Node, prefixSet: Set<string>, aliasMap: Map<string, string> ): ChainResult | null {
+  const segments: string[] = [];
+  let current: Node = node;
+
+  while ( true ) {
+    if ( Node.isPropertyAccessExpression( current ) ) {
+      segments.unshift( '.' + current.getName() );
+      current = current.getExpression();
+    }
+    else if ( Node.isElementAccessExpression( current ) ) {
+      const arg = current.getArgumentExpression();
+      if ( arg && Node.isStringLiteral( arg ) ) {
+        segments.unshift( `['${arg.getLiteralText()}']` );
+      }
+      else {
+        return null; // dynamic / computed access — can't resolve statically
+      }
+      current = current.getExpression();
+    }
+    else if ( Node.isIdentifier( current ) ) {
+      const name = current.getText();
+      if ( prefixSet.has( name ) ) {
+        return { chain: name + segments.join( '' ), aliasName: null };
+      }
+      const resolved = aliasMap.get( name );
+      if ( resolved !== undefined ) {
+        return { chain: resolved + segments.join( '' ), aliasName: name };
+      }
+      return null;
+    }
+    else {
+      return null;
+    }
+  }
+}
+
+/**
+ * True when the node is NOT the object/expression part of a larger
+ * PropertyAccessExpression or ElementAccessExpression — i.e., it is the
+ * outermost (terminal) link of its access chain.
+ */
+function isTerminal( node: Node ): boolean {
+  const parent = node.getParent();
+  if ( !parent ) {
+    return true;
+  }
+  if ( Node.isPropertyAccessExpression( parent ) ) {
+    return parent.getExpression() !== node;
+  }
+  if ( Node.isElementAccessExpression( parent ) ) {
+    return parent.getExpression() !== node;
+  }
+  return true;
+}
+
+/**
+ * Scan file content for property-access chains rooted at any of the given
+ * prefixes. Resolves single-level and transitive const aliases.
+ *
+ * @param fileContent - full text of the source file
+ * @param prefixes - identifiers to treat as roots (e.g. ['FooStrings', 'FooFluent'])
+ * @returns deduplicated access strings (e.g. ['FooStrings.title', 'FooStrings.a11y.response.phrase'])
+ */
+export default function getStringAccessesFromFile( fileContent: string, prefixes: string[] ): string[] {
+
+  const sourceFile = project.createSourceFile( 'scan.ts', fileContent, { overwrite: true } );
+  const prefixSet = new Set( prefixes );
+
+  // Track which alias names are actually used as chain roots, so we can decide
+  // whether to capture or suppress their initializer chains.
+  const usedAliasNames = new Set<string>();
+
+  // ---- Pass 1: build alias map from const declarations ----
+  const aliasMap = new Map<string, string>();
+  const aliasInitializers = new Set<Node>();
+  const ambiguous = new Set<string>();
+
+  for ( const decl of sourceFile.getVariableDeclarations() ) {
+    const stmt = decl.getVariableStatement();
+    if ( !stmt || stmt.getDeclarationKind() !== 'const' ) {
+      continue;
+    }
+
+    const init = decl.getInitializer();
+    if ( !init ) {
+      continue;
+    }
+
+    const result = resolveChain( init, prefixSet, aliasMap );
+    if ( result === null ) {
+      continue;
+    }
+
+    // If this alias's initializer resolves through another alias, mark that alias as used.
+    if ( result.aliasName ) {
+      usedAliasNames.add( result.aliasName );
+    }
+
+    const name = decl.getName();
+    if ( aliasMap.has( name ) || ambiguous.has( name ) ) {
+      aliasMap.delete( name );
+      ambiguous.add( name );
+    }
+    else {
+      aliasMap.set( name, result.chain );
+      aliasInitializers.add( init );
+    }
+  }
+
+  // ---- Pass 2: collect all access chains ----
+  const results: string[] = [];
+
+  sourceFile.forEachDescendant( ( node, traversal ) => {
+
+    // Skip subtrees of alias initializers to avoid capturing intermediate paths.
+    if ( aliasInitializers.has( node ) ) {
+      traversal.skip();
+      return;
+    }
+
+    const kind = node.getKind();
+
+    // Terminal property-access or element-access chain
+    if ( ( kind === SyntaxKind.PropertyAccessExpression || kind === SyntaxKind.ElementAccessExpression ) && isTerminal( node ) ) {
+      const result = resolveChain( node, prefixSet, aliasMap );
+      if ( result !== null ) {
+        results.push( result.chain );
+        if ( result.aliasName ) {
+          usedAliasNames.add( result.aliasName );
+        }
+      }
+      return;
+    }
+
+    // Standalone identifier that is a known (non-ambiguous) alias
+    if ( kind === SyntaxKind.Identifier ) {
+      const parent = node.getParent();
+      if ( !parent ) {
+        return;
+      }
+      const pk = parent.getKind();
+      if ( pk === SyntaxKind.PropertyAccessExpression ||
+           pk === SyntaxKind.ElementAccessExpression ||
+           pk === SyntaxKind.VariableDeclaration ||
+           pk === SyntaxKind.ImportClause ||
+           pk === SyntaxKind.ImportSpecifier ) {
+        return;
+      }
+      const name = node.getText();
+      const resolved = aliasMap.get( name );
+
+      // Capture only if the alias has at least one access segment (not a bare prefix).
+      if ( resolved !== undefined && !prefixSet.has( resolved ) ) {
+        results.push( resolved );
+        usedAliasNames.add( name );
+      }
+    }
+  } );
+
+  // ---- Pass 3: capture unused alias initializer chains ----
+  // If an alias was declared but never referenced as a chain root (e.g.,
+  // `const x = FooStrings.title;` where x is never used further), the
+  // initializer IS the actual string access and needs to be captured.
+  for ( const [ name, chain ] of aliasMap ) {
+    if ( !usedAliasNames.has( name ) && !prefixSet.has( chain ) ) {
+      results.push( chain );
+    }
+  }
+
+  return [ ...new Set( results ) ];
+}
Index: chipper/js/grunt/getStringAccessesFromFileTests.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/chipper/js/grunt/getStringAccessesFromFileTests.ts b/chipper/js/grunt/getStringAccessesFromFileTests.ts
new file mode 100644
--- /dev/null	(date 1772478071817)
+++ b/chipper/js/grunt/getStringAccessesFromFileTests.ts	(date 1772478071817)
@@ -0,0 +1,228 @@
+// Copyright 2026, University of Colorado Boulder
+
+/**
+ * Tests for getStringAccessesFromFile
+ * @author Sam Reid (PhET Interactive Simulations)
+ */
+
+import qunit from '../../../perennial-alias/js/npm-dependencies/qunit.js';
+import getStringAccessesFromFile from './getStringAccessesFromFile.js';
+
+qunit.module( 'getStringAccessesFromFile' );
+
+qunit.test( 'direct access', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const x = FooStrings.title;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.deepEqual( result, [ 'FooStrings.title' ] );
+} );
+
+qunit.test( 'nested direct access', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const x = FooStrings.a11y.response.phrase;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.deepEqual( result, [ 'FooStrings.a11y.response.phrase' ] );
+} );
+
+qunit.test( 'const alias with further access', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const AOR = FooStrings.a11y.response;
+    const x = AOR.phrase;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.deepEqual( result, [ 'FooStrings.a11y.response.phrase' ] );
+} );
+
+qunit.test( 'transitive aliases', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const A = FooStrings.a11y;
+    const B = A.response;
+    const x = B.phrase;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.deepEqual( result, [ 'FooStrings.a11y.response.phrase' ] );
+} );
+
+qunit.test( 'bracket notation', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const x = FooStrings['special-key'].name;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.deepEqual( result, [ 'FooStrings[\'special-key\'].name' ] );
+} );
+
+qunit.test( 'single-char keys', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const x = FooStrings.a.b.c;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.deepEqual( result, [ 'FooStrings.a.b.c' ] );
+} );
+
+qunit.test( '.format() call', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const x = FooStrings.title.format({ a: 1 });
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.deepEqual( result, [ 'FooStrings.title.format' ] );
+} );
+
+qunit.test( '.format() call through alias', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const AOR = FooStrings.a11y.response;
+    const x = AOR.phrase.format({});
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.deepEqual( result, [ 'FooStrings.a11y.response.phrase.format' ] );
+} );
+
+qunit.test( '.createProperty() call', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const x = FooStrings.title.createProperty();
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.deepEqual( result, [ 'FooStrings.title.createProperty' ] );
+} );
+
+qunit.test( 'leaf alias standalone', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const leaf = FooStrings.a11y.response;
+    doSomething( leaf );
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.deepEqual( result, [ 'FooStrings.a11y.response' ] );
+} );
+
+qunit.test( 'alias used both ways (standalone and with further access)', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const AOR = FooStrings.a11y.response;
+    doSomething( AOR );
+    const x = AOR.phrase;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.ok( result.includes( 'FooStrings.a11y.response' ), 'standalone use captured' );
+  assert.ok( result.includes( 'FooStrings.a11y.response.phrase' ), 'further access captured' );
+} );
+
+qunit.test( 'multiple prefixes', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    import FooFluent from './FooFluent.js';
+    const x = FooStrings.title;
+    const y = FooFluent.description;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings', 'FooFluent' ] );
+  assert.ok( result.includes( 'FooStrings.title' ), 'first prefix captured' );
+  assert.ok( result.includes( 'FooFluent.description' ), 'second prefix captured' );
+} );
+
+qunit.test( 'non-string const ignored', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const x = FooStrings.title;
+    const unrelated = someOtherThing.property;
+    const num = 42;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.deepEqual( result, [ 'FooStrings.title' ] );
+} );
+
+qunit.test( 'bare prefix not captured', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    doSomething( FooStrings );
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.deepEqual( result, [], 'bare prefix without property access is not captured' );
+} );
+
+qunit.test( 'StringProperty chains', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    FooStrings.titleStringProperty.link( () => {} );
+    FooStrings.titleStringProperty.value;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.ok( result.includes( 'FooStrings.titleStringProperty.link' ), 'StringProperty.link captured' );
+  assert.ok( result.includes( 'FooStrings.titleStringProperty.value' ), 'StringProperty.value captured' );
+} );
+
+qunit.test( 'deduplicated results', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const a = FooStrings.title;
+    const b = FooStrings.title;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.deepEqual( result, [ 'FooStrings.title' ], 'duplicates are removed' );
+} );
+
+qunit.test( 'alias initializer not captured as access', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const AOR = FooStrings.a11y.response;
+    const x = AOR.phrase;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+
+  // The intermediate path FooStrings.a11y.response should NOT appear unless used standalone
+  assert.ok( !result.includes( 'FooStrings.a11y.response' ), 'alias initializer intermediate path not captured' );
+  assert.ok( !result.includes( 'FooStrings.a11y' ), 'inner chain of alias initializer not captured' );
+  assert.deepEqual( result, [ 'FooStrings.a11y.response.phrase' ] );
+} );
+
+qunit.test( 'let declarations are not treated as aliases', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    let AOR = FooStrings.a11y.response;
+    const x = AOR.phrase;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+
+  // AOR is let, not const, so it's not recognized as an alias.
+  // The initializer FooStrings.a11y.response IS captured as a direct access.
+  // AOR.phrase is NOT resolved because AOR is not an alias.
+  assert.ok( result.includes( 'FooStrings.a11y.response' ), 'let initializer captured as direct access' );
+  assert.ok( !result.includes( 'FooStrings.a11y.response.phrase' ), 'AOR.phrase not resolved since let is not aliased' );
+} );
+
+qunit.test( 'bracket notation with double quotes', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const x = FooStrings["special-key"].name;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.deepEqual( result, [ 'FooStrings[\'special-key\'].name' ] );
+} );
+
+qunit.test( 'mixed dot and bracket notation', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const x = FooStrings.a11y['special-key'].name;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.deepEqual( result, [ 'FooStrings.a11y[\'special-key\'].name' ] );
+} );
+
+qunit.test( 'alias to bracket notation', assert => {
+  const code = `
+    import FooStrings from './FooStrings.js';
+    const section = FooStrings['special-section'];
+    const x = section.name;
+  `;
+  const result = getStringAccessesFromFile( code, [ 'FooStrings' ] );
+  assert.deepEqual( result, [ 'FooStrings[\'special-section\'].name' ] );
+} );
Index: chipper/js/test/chipper-tests.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/chipper/js/test/chipper-tests.ts b/chipper/js/test/chipper-tests.ts
--- a/chipper/js/test/chipper-tests.ts	(revision cfa59f86c25119552a6130708f11b38da595b978)
+++ b/chipper/js/test/chipper-tests.ts	(date 1772478071817)
@@ -16,4 +16,5 @@
 
 import '../common/ChipperStringUtilTests.js';
 import '../phet-io/phetioCompareAPIsTests.js';
+import '../grunt/getStringAccessesFromFileTests.js';
 import '../phet-io/isInitialStateCompatibleTests.js';
\ No newline at end of file

[samreid]

@jonathanolson identified several difficulties and corner cases with the proposed approach. Therefore I wanted to see if there was a more robust solution. I tried using the TypeScript AST to search for usages, and then tried ts-morph to search for usages. None of theses solutions met the balance of robust + correct + simple. So I would like to bring back to dev meeting see if this issue has a way forward.

[jessegreenberg]

Discussed during developer meeting 3/9/26:

SR: Why do we have to track what strings are used?
JO: It helps us determine what strings go into a build. Removing unused strings helps us keep builds smaller for simulations and scenerystack.
JO: scenerystack has a more robust way to do this, but applying that here would be a significant effort.
JB: This also is used for our "string maps" - which prune unused strings from the user interface in the translation utility.
MS: Can we apply a quick solution and apply a more robust solution later on?
JO: Our current way is inflexible, but reliable. The quick and easy ways are fragile and might break in a way that is difficult to assess.
SR: What would it take for each string to get its own module and be pruned with a tree shake?

• JO: Might not be too hard, but difficult to assess a systemic change.
• SR: Does it have to be one file per module?
• JO: Some bundlers are capable of doing that, I don't think we support that right now.
• SR: Would we regret having lots of string files?
• JO: It would be more annoying to add a unique import per string. Slightly increases size of view code. Otherwise, not really.
• JB: IDE collapses imports, so that isn't too bad.
• JO: Would need some kind of naming convention. Using dots probably wouldn't work.
• JO: This solution could be leveraged for the translation utility too.

1. leave as is
2. fragile solution (could still error during runtime in built version, might not be able to error loudly).
3. figuire out a more robust solution that uses our existing system (see Factoring out intermediate/partial strings fails the build #1661 (comment))
4. modify our string system so that we don't have this problem (using a different module for each string)

[jessegreenberg]

We voted on list 1-4 in #1661 (comment) to get a sense of how we feel.

1) leave as is
  JG
  JO: this is ok mainly to avoid the effort for the modulification change. If we spend time, I’d prefer (4)
  SR: I’d be ok with skipping, but would be nice to see if the modulify/webpack/treeshake one is “fast” like 2 hours or less
  JB +1 on this.
  MS: I’m okay with this too
  AV: Yeah lets go with this
  JB
2) fragile solution
  MS
3) figure out a more robust solution that uses our existing system
4) modify our string system by making each string one module so that we can use webpack treeshaking to see exactly which strings   are used
  SR: I’d be interested in a 2-hour minisprint to see the scope for this one
  JO

We voted on this in our project board and assigned it a value of 53. We thought about ways this could be easy to prototype but it seems challenging. Might take about a day to get working.