deepline 0.1.156 → 0.1.158

package/dist/bundling-sources/shared_libs/plays/bundling/index.ts

@@ -12,7 +12,9 @@ import {
   resolve,
 } from 'node:path';
 import { builtinModules } from 'node:module';
-import { build, type Message, type Plugin } from 'esbuild';
+import { Parser } from 'acorn';
+import { tsPlugin } from 'acorn-typescript';
+import { build, transformSync, type Message, type Plugin } from 'esbuild';
 import {
   PLAY_ARTIFACT_KINDS,
   type PlayArtifactKind,
@@ -438,30 +440,6 @@ function findSourceImportReferences(
   );
 }
 
-function unquoteStringLiteral(literal: string): string | null {
-  const trimmed = literal.trim();
-  const quote = trimmed[0];
-  if (
-    (quote !== '"' && quote !== "'" && quote !== '`') ||
-    trimmed[trimmed.length - 1] !== quote
-  ) {
-    return null;
-  }
-  if (quote === '`') {
-    const value = trimmed.slice(1, -1);
-    return value.includes('${') ? null : value;
-  }
-  try {
-    return JSON.parse(
-      quote === '"'
-        ? trimmed
-        : `"${trimmed.slice(1, -1).replace(/"/g, '\\"')}"`,
-    );
-  } catch {
-    return trimmed.slice(1, -1);
-  }
-}
-
 function findMatchingBrace(source: string, openIndex: number): number {
   const structuralSource = maskSourceForStructure(source);
   let depth = 0;
@@ -476,262 +454,542 @@ function findMatchingBrace(source: string, openIndex: number): number {
   return -1;
 }
 
-function findMatchingParen(source: string, openIndex: number): number {
-  const structuralSource = maskSourceForStructure(source);
-  let depth = 0;
-  for (let index = openIndex; index < structuralSource.length; index += 1) {
-    const char = structuralSource[index]!;
-    if (char === '(') depth += 1;
-    if (char === ')') {
-      depth -= 1;
-      if (depth === 0) return index;
-    }
-  }
-  return -1;
-}
-
-function splitTopLevelArguments(source: string): string[] {
-  const args: string[] = [];
-  const structuralSource = maskSourceForStructure(source);
-  let start = 0;
-  let parenDepth = 0;
-  let braceDepth = 0;
-  let bracketDepth = 0;
-  for (let index = 0; index < structuralSource.length; index += 1) {
-    const char = structuralSource[index]!;
-    if (char === '(') parenDepth += 1;
-    if (char === ')') parenDepth -= 1;
-    if (char === '{') braceDepth += 1;
-    if (char === '}') braceDepth -= 1;
-    if (char === '[') bracketDepth += 1;
-    if (char === ']') bracketDepth -= 1;
-    if (
-      char === ',' &&
-      parenDepth === 0 &&
-      braceDepth === 0 &&
-      bracketDepth === 0
-    ) {
-      args.push(source.slice(start, index).trim());
-      start = index + 1;
-    }
-  }
-  const finalArg = source.slice(start).trim();
-  if (finalArg) args.push(finalArg);
-  return args;
-}
-
-function extractStringProperty(
-  objectSource: string,
-  propertyName: string,
-): string | null {
-  for (const entry of splitTopLevelArguments(objectSource)) {
-    const structuralEntry = stripCommentsToSpaces(entry).trim();
-    const match = structuralEntry.match(
-      new RegExp(
-        `^(?:${propertyName}|['"]${propertyName}['"])\\s*:\\s*((['"\`])(?:\\\\.|(?!\\2)[\\s\\S])*\\2)\\s*$`,
-      ),
-    );
-    const value = match?.[1] ? unquoteStringLiteral(match[1]) : null;
-    if (value?.trim()) return value.trim();
-  }
-  return null;
-}
-
 export function extractDefinedPlayName(sourceCode: string): string | null {
-  for (const call of findDefinePlayCalls(sourceCode)) {
-    const name = nameFromDefinePlayArguments(sourceCode, call.arguments);
-    if (name) return name;
-  }
-  return null;
+  return extractDefinedPlayMetadata(sourceCode, null)?.name ?? null;
 }
 
 export function extractDefinedPlayNameForExport(
   sourceCode: string,
   exportName: string,
 ): string | null {
-  return findDefinedPlayMetadata(
-    sourceCode,
-    exportName,
-    nameFromDefinePlayArguments,
-  );
+  return extractDefinedPlayMetadata(sourceCode, exportName)?.name ?? null;
 }
 
 export function extractDefinedPlayDescription(
   sourceCode: string,
 ): string | null {
-  return findDefinedPlayMetadata(
-    sourceCode,
-    null,
-    descriptionFromDefinePlayArguments,
-  );
+  return extractDefinedPlayMetadata(sourceCode, null)?.description ?? null;
 }
 
 export function extractDefinedPlayDescriptionForExport(
   sourceCode: string,
   exportName: string,
 ): string | null {
-  return findDefinedPlayMetadata(
-    sourceCode,
-    exportName,
-    descriptionFromDefinePlayArguments,
-  );
+  return extractDefinedPlayMetadata(sourceCode, exportName)?.description ?? null;
 }
 
-function findDefinedPlayMetadata(
-  sourceCode: string,
-  exportName: string | null,
-  getMetadata: (sourceCode: string, args: string[]) => string | null,
-): string | null {
-  const resolvedExportName =
-    exportName === 'default'
-      ? (findDefaultExportIdentifier(sourceCode) ?? exportName)
-      : exportName;
-  for (const call of findDefinePlayCalls(sourceCode)) {
-    if (resolvedExportName && call.exportName !== resolvedExportName) {
-      continue;
+type AstNode = {
+  type: string;
+  [key: string]: unknown;
+};
+
+type PlayMetadataExtractionContext = {
+  declarations: Map<string, AstNode | null>;
+  namedExports: Map<string, string>;
+  commonJsExports: Map<string, AstNode>;
+  defaultExport: AstNode | null;
+};
+
+type ExtractedPlayMetadata = {
+  name: string | null;
+  description: string | null;
+};
+
+const TypeScriptParser = Parser.extend(
+  tsPlugin({
+    allowSatisfies: true,
+    jsx: {
+      allowNamespaces: true,
+      allowNamespacedObjects: true,
+    },
+  }) as unknown as (BaseParser: typeof Parser) => typeof Parser,
+);
+
+function parsePlaySourceAst(sourceCode: string): AstNode | null {
+  try {
+    return TypeScriptParser.parse(sourceCode, {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+      allowHashBang: true,
+    }) as unknown as AstNode;
+  } catch {
+    try {
+      const transformed = transformSync(sourceCode, {
+        loader: 'ts',
+        format: 'esm',
+        target: 'esnext',
+        legalComments: 'none',
+        sourcemap: false,
+      }).code;
+      return Parser.parse(transformed, {
+        ecmaVersion: 'latest',
+        sourceType: 'module',
+        allowHashBang: true,
+      }) as unknown as AstNode;
+    } catch {
+      return null;
     }
-    const value = getMetadata(sourceCode, call.arguments);
-    if (value) return value;
   }
-  return null;
 }
 
-type DefinePlayCallMetadata = {
-  arguments: string[];
-  exportName: string | null;
-};
+function getIdentifierName(node: unknown): string | null {
+  return isAstNode(node) && node.type === 'Identifier'
+    ? typeof node.name === 'string'
+      ? node.name
+      : null
+    : null;
+}
 
-function findDefinePlayCalls(sourceCode: string): DefinePlayCallMetadata[] {
-  const source = maskSourceForStructure(sourceCode);
-  const callPattern =
-    /(?:\b[A-Za-z_$][\w$]*\s*\.\s*)?\b(?:definePlay|defineWorkflow)\s*\(/g;
-  const calls: DefinePlayCallMetadata[] = [];
-  for (const match of source.matchAll(callPattern)) {
-    const callStart = match.index!;
-    const openParen = callStart + match[0].length - 1;
-    const closeParen = findMatchingParen(sourceCode, openParen);
-    if (closeParen < 0) continue;
-    calls.push({
-      arguments: splitTopLevelArguments(
-        sourceCode.slice(openParen + 1, closeParen),
-      ),
-      exportName: exportNameForDefinePlayCall(sourceCode, callStart),
-    });
-  }
-  return calls;
+function isAstNode(value: unknown): value is AstNode {
+  return value !== null && typeof value === 'object' && 'type' in value;
 }
 
-function findDefaultExportIdentifier(sourceCode: string): string | null {
-  const source = maskSourceForStructure(sourceCode);
-  const pattern = /\bexport\s+default\s+([A-Za-z_$][\w$]*)/g;
-  for (const match of source.matchAll(pattern)) {
-    const afterIdentifier = match.index! + match[0].length;
-    const nextNonSpace = source.slice(afterIdentifier).match(/\S/)?.[0] ?? '';
-    if (nextNonSpace !== '(') return match[1] ?? null;
+function astArray(value: unknown): AstNode[] {
+  return Array.isArray(value) ? value.filter(isAstNode) : [];
+}
+
+function memberExpressionPath(node: AstNode | null | undefined): string[] | null {
+  const expression = unwrapStaticExpression(node);
+  if (!expression) return null;
+  if (expression.type === 'Identifier' && typeof expression.name === 'string') {
+    return [expression.name];
+  }
+  if (expression.type !== 'MemberExpression') return null;
+  const objectPath = memberExpressionPath(
+    isAstNode(expression.object) ? expression.object : null,
+  );
+  if (!objectPath) return null;
+  const property = isAstNode(expression.property) ? expression.property : null;
+  if (!property) return null;
+  if (!expression.computed && property.type === 'Identifier') {
+    return typeof property.name === 'string'
+      ? [...objectPath, property.name]
+      : null;
+  }
+  if (expression.computed && property.type === 'Literal') {
+    return typeof property.value === 'string'
+      ? [...objectPath, property.value]
+      : null;
   }
   return null;
 }
 
-function nameFromDefinePlayArguments(
-  sourceCode: string,
-  args: string[],
-): string | null {
-  const firstArg = args[0]?.trim();
-  if (!firstArg) return null;
-  if (/^(['"`])/.test(firstArg))
-    return unquoteStringLiteral(firstArg)?.trim() ?? null;
-  const objectSource = objectLiteralBodyFromArgument(sourceCode, firstArg);
-  if (objectSource) {
-    return extractStringProperty(objectSource, 'id');
+function commonJsExportName(left: AstNode | null | undefined): string | null {
+  const path = memberExpressionPath(left);
+  if (!path) return null;
+  if (path.length === 2 && path[0] === 'module' && path[1] === 'exports') {
+    return 'default';
+  }
+  if (path.length === 3 && path[0] === 'module' && path[1] === 'exports') {
+    return path[2] || null;
+  }
+  if (path.length === 2 && path[0] === 'exports') {
+    return path[1] || null;
   }
   return null;
 }
 
-function descriptionFromDefinePlayArguments(
-  sourceCode: string,
-  args: string[],
+function isDefinePlayCallExpression(node: AstNode | null | undefined): boolean {
+  if (!node || node.type !== 'CallExpression') return false;
+  const callee = isAstNode(node.callee) ? node.callee : null;
+  if (!callee) return false;
+  if (callee.type === 'Identifier') {
+    return callee.name === 'definePlay' || callee.name === 'defineWorkflow';
+  }
+  if (callee.type === 'MemberExpression' && isAstNode(callee.property)) {
+    const property = callee.property;
+    return (
+      !callee.computed &&
+      property.type === 'Identifier' &&
+      (property.name === 'definePlay' || property.name === 'defineWorkflow')
+    );
+  }
+  return false;
+}
+
+function canResolveDeclarationInitializer(
+  declarationKind: unknown,
+  initializer: AstNode | null,
+): boolean {
+  return declarationKind === 'const' || isDefinePlayCallExpression(initializer);
+}
+
+function buildPlayMetadataContext(ast: AstNode): PlayMetadataExtractionContext {
+  const declarations = new Map<string, AstNode | null>();
+  const namedExports = new Map<string, string>();
+  const commonJsExports = new Map<string, AstNode>();
+  let defaultExport: AstNode | null = null;
+
+  for (const statement of astArray(ast.body)) {
+    if (statement.type === 'VariableDeclaration') {
+      for (const declaration of astArray(statement.declarations)) {
+        const name = getIdentifierName(declaration.id);
+        if (!name) continue;
+        const initializer = isAstNode(declaration.init)
+          ? declaration.init
+          : null;
+        declarations.set(
+          name,
+          canResolveDeclarationInitializer(statement.kind, initializer)
+            ? initializer
+            : null,
+        );
+      }
+      continue;
+    }
+
+    if (statement.type === 'ExportDefaultDeclaration') {
+      defaultExport = isAstNode(statement.declaration)
+        ? statement.declaration
+        : null;
+      continue;
+    }
+
+    if (statement.type === 'TSExportAssignment') {
+      defaultExport = isAstNode(statement.expression)
+        ? statement.expression
+        : null;
+      continue;
+    }
+
+    if (statement.type === 'ExportNamedDeclaration') {
+      if (
+        isAstNode(statement.declaration) &&
+        statement.declaration.type === 'VariableDeclaration'
+      ) {
+        for (const declaration of astArray(statement.declaration.declarations)) {
+          const name = getIdentifierName(declaration.id);
+          if (!name) continue;
+          const initializer = isAstNode(declaration.init)
+            ? declaration.init
+            : null;
+          declarations.set(
+            name,
+            canResolveDeclarationInitializer(
+              statement.declaration.kind,
+              initializer,
+            )
+              ? initializer
+              : null,
+          );
+          namedExports.set(name, name);
+        }
+      }
+
+      for (const specifier of astArray(statement.specifiers)) {
+        const localName = getIdentifierName(specifier.local);
+        const exportedName =
+          getIdentifierName(specifier.exported) ??
+          (isAstNode(specifier.exported) &&
+          specifier.exported.type === 'Literal' &&
+          typeof specifier.exported.value === 'string'
+            ? specifier.exported.value
+            : null);
+        if (localName && exportedName) {
+          namedExports.set(exportedName, localName);
+        }
+      }
+    }
+
+    if (
+      statement.type === 'ExpressionStatement' &&
+      isAstNode(statement.expression) &&
+      statement.expression.type === 'AssignmentExpression'
+    ) {
+      const exportName = commonJsExportName(
+        isAstNode(statement.expression.left) ? statement.expression.left : null,
+      );
+      if (exportName && isAstNode(statement.expression.right)) {
+        commonJsExports.set(exportName, statement.expression.right);
+      }
+    }
+  }
+
+  return { declarations, namedExports, commonJsExports, defaultExport };
+}
+
+function unwrapStaticExpression(node: AstNode | null | undefined): AstNode | null {
+  let current = node ?? null;
+  while (
+    current &&
+    (current.type === 'TSAsExpression' ||
+      current.type === 'TSSatisfiesExpression' ||
+      current.type === 'TSTypeAssertion' ||
+      current.type === 'TSNonNullExpression' ||
+      current.type === 'ParenthesizedExpression')
+  ) {
+    current = isAstNode(current.expression) ? current.expression : null;
+  }
+  return current;
+}
+
+function staticStringFromExpression(
+  node: AstNode | null | undefined,
+  context: PlayMetadataExtractionContext,
+  seen = new Set<string>(),
+  trimResult = true,
 ): string | null {
-  const firstArgDescription = descriptionFromDefinePlayArgument(
-    sourceCode,
-    args[0],
-  );
-  if (firstArgDescription) return firstArgDescription;
-  for (let index = args.length - 1; index >= 2; index -= 1) {
-    const description = descriptionFromDefinePlayArgument(
-      sourceCode,
-      args[index],
+  const expression = unwrapStaticExpression(node);
+  if (!expression) return null;
+
+  if (expression.type === 'Literal') {
+    const value = expression.value;
+    if (typeof value !== 'string' || !value.trim()) return null;
+    return trimResult ? value.trim() : value;
+  }
+
+  if (
+    expression.type === 'TemplateLiteral' &&
+    astArray(expression.expressions).length === 0
+  ) {
+    const firstQuasi = astArray(expression.quasis)[0];
+    const cooked =
+      firstQuasi && typeof firstQuasi.value === 'object'
+        ? (firstQuasi.value as { cooked?: unknown }).cooked
+        : null;
+    if (typeof cooked !== 'string' || !cooked.trim()) return null;
+    return trimResult ? cooked.trim() : cooked;
+  }
+
+  if (expression.type === 'BinaryExpression' && expression.operator === '+') {
+    const left = staticStringFromExpression(
+      isAstNode(expression.left) ? expression.left : null,
+      context,
+      new Set(seen),
+      false,
     );
-    if (description) return description;
+    const right = staticStringFromExpression(
+      isAstNode(expression.right) ? expression.right : null,
+      context,
+      new Set(seen),
+      false,
+    );
+    const value = left !== null && right !== null ? `${left}${right}` : null;
+    if (!value?.trim()) return null;
+    return trimResult ? value.trim() : value;
+  }
+
+  const identifier = getIdentifierName(expression);
+  if (!identifier || seen.has(identifier)) return null;
+  seen.add(identifier);
+  return staticStringFromExpression(
+    context.declarations.get(identifier),
+    context,
+    seen,
+    trimResult,
+  );
+}
+
+function propertyNameFromKey(property: AstNode): string | null {
+  if (property.computed) return null;
+  const key = isAstNode(property.key) ? property.key : null;
+  if (!key) return null;
+  if (key.type === 'Identifier' && typeof key.name === 'string') {
+    return key.name;
+  }
+  if (key.type === 'Literal' && typeof key.value === 'string') {
+    return key.value;
   }
   return null;
 }
 
-function descriptionFromDefinePlayArgument(
-  sourceCode: string,
-  arg: string | undefined,
-): string | null {
-  const trimmed = arg?.trim();
-  if (!trimmed) return null;
-  const objectSource = objectLiteralBodyFromArgument(sourceCode, trimmed);
-  if (!objectSource) return null;
-  return extractStringProperty(objectSource, 'description');
+function objectExpressionFromNode(
+  node: AstNode | null | undefined,
+  context: PlayMetadataExtractionContext,
+  seen = new Set<string>(),
+): AstNode | null {
+  const expression = unwrapStaticExpression(node);
+  if (!expression) return null;
+  if (expression.type === 'ObjectExpression') return expression;
+
+  const identifier = getIdentifierName(expression);
+  if (!identifier || seen.has(identifier)) return null;
+  seen.add(identifier);
+  return objectExpressionFromNode(
+    context.declarations.get(identifier),
+    context,
+    seen,
+  );
 }
 
-function objectLiteralBodyFromArgument(
-  sourceCode: string,
-  arg: string,
+function stringPropertyFromObjectExpression(
+  node: AstNode | null | undefined,
+  propertyName: string,
+  context: PlayMetadataExtractionContext,
+  seenObjects = new Set<AstNode>(),
 ): string | null {
-  const trimmed = arg.trim();
-  if (trimmed.startsWith('{')) {
-    const closeBrace = findMatchingBrace(trimmed, 0);
-    return closeBrace >= 0 ? trimmed.slice(1, closeBrace) : trimmed.slice(1);
+  const object = objectExpressionFromNode(node, context);
+  if (!object || seenObjects.has(object)) return null;
+  seenObjects.add(object);
+
+  let value: string | null = null;
+  for (const property of astArray(object.properties)) {
+    if (property.type === 'SpreadElement') {
+      const spreadValue = stringPropertyFromObjectExpression(
+        isAstNode(property.argument) ? property.argument : null,
+        propertyName,
+        context,
+        seenObjects,
+      );
+      if (spreadValue) value = spreadValue;
+      continue;
+    }
+
+    if (property.type !== 'Property') continue;
+    if (propertyNameFromKey(property) !== propertyName) continue;
+    const propertyValue = property.shorthand
+      ? property.key
+      : property.value;
+    value = staticStringFromExpression(
+      isAstNode(propertyValue) ? propertyValue : null,
+      context,
+    );
   }
-  if (!/^[A-Za-z_$][\w$]*$/.test(trimmed)) return null;
-  return findTopLevelObjectLiteralBody(sourceCode, trimmed);
+  return value;
 }
 
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+function isDefinePlayCallee(node: AstNode | null | undefined): boolean {
+  const callee = unwrapStaticExpression(node);
+  if (!callee) return false;
+  if (
+    callee.type === 'Identifier' &&
+    (callee.name === 'definePlay' || callee.name === 'defineWorkflow')
+  ) {
+    return true;
+  }
+  if (callee.type === 'MemberExpression' && isAstNode(callee.property)) {
+    const property = callee.property;
+    return (
+      !callee.computed &&
+      property.type === 'Identifier' &&
+      (property.name === 'definePlay' || property.name === 'defineWorkflow')
+    );
+  }
+  return false;
 }
 
-function findTopLevelObjectLiteralBody(
-  sourceCode: string,
-  identifier: string,
-): string | null {
-  const source = maskSourceForStructure(sourceCode);
-  const pattern = new RegExp(
-    `(?:^|[;\\n])\\s*(?:export\\s+)?(?:const|let|var)\\s+${escapeRegExp(
-      identifier,
-    )}(?:\\s*:[^=;]+)?\\s*=\\s*{`,
-    'g',
-  );
-  for (const match of source.matchAll(pattern)) {
-    const openBrace = source.indexOf('{', match.index);
-    if (openBrace < 0) continue;
-    const closeBrace = findMatchingBrace(sourceCode, openBrace);
-    if (closeBrace < 0) continue;
-    return sourceCode.slice(openBrace + 1, closeBrace);
+function playMetadataFromDefinePlayCall(
+  node: AstNode | null | undefined,
+  context: PlayMetadataExtractionContext,
+): ExtractedPlayMetadata | null {
+  const expression = unwrapStaticExpression(node);
+  if (
+    !expression ||
+    expression.type !== 'CallExpression' ||
+    !isDefinePlayCallee(isAstNode(expression.callee) ? expression.callee : null)
+  ) {
+    return null;
+  }
+
+  const args = astArray(expression.arguments);
+  const firstArg = args[0] ?? null;
+  const objectName = stringPropertyFromObjectExpression(firstArg, 'id', context);
+  const name = objectName ?? staticStringFromExpression(firstArg, context);
+
+  let description =
+    stringPropertyFromObjectExpression(firstArg, 'description', context) ?? null;
+  for (let index = args.length - 1; !description && index >= 2; index -= 1) {
+    description = stringPropertyFromObjectExpression(
+      args[index],
+      'description',
+      context,
+    );
   }
+
+  if (!name && !description) return null;
+  return { name, description };
+}
+
+function resolveExportExpression(
+  exportName: string | null,
+  context: PlayMetadataExtractionContext,
+): AstNode | null {
+  if (exportName === 'default') {
+    const commonJsDefault = context.commonJsExports.get('default');
+    if (commonJsDefault) {
+      const commonJsDefaultIdentifier = getIdentifierName(
+        unwrapStaticExpression(commonJsDefault),
+      );
+      return commonJsDefaultIdentifier
+        ? (context.declarations.get(commonJsDefaultIdentifier) ??
+            commonJsDefault)
+        : commonJsDefault;
+    }
+    const defaultExpression = unwrapStaticExpression(context.defaultExport);
+    const defaultIdentifier = getIdentifierName(defaultExpression);
+    if (!defaultIdentifier) {
+      const defaultExportName = context.namedExports.get('default');
+      return defaultExportName
+        ? (context.declarations.get(defaultExportName) ?? null)
+        : defaultExpression;
+    }
+    return defaultIdentifier
+      ? (context.declarations.get(defaultIdentifier) ?? context.defaultExport)
+      : context.defaultExport;
+  }
+
+  if (exportName) {
+    const commonJsExport = context.commonJsExports.get(exportName);
+    if (commonJsExport) {
+      const commonJsExportIdentifier = getIdentifierName(
+        unwrapStaticExpression(commonJsExport),
+      );
+      return commonJsExportIdentifier
+        ? (context.declarations.get(commonJsExportIdentifier) ?? commonJsExport)
+        : commonJsExport;
+    }
+    const localName = context.namedExports.get(exportName) ?? exportName;
+    return context.declarations.get(localName) ?? null;
+  }
+
   return null;
 }
 
-function exportNameForDefinePlayCall(
+function extractDefinedPlayMetadata(
   sourceCode: string,
-  callStart: number,
-): string | null {
-  const source = maskSourceForStructure(sourceCode);
-  const structuralPrefix = source
-    .slice(Math.max(0, callStart - 500), callStart)
-    .trimEnd();
-  if (/\bexport\s+default\s*$/.test(structuralPrefix)) return 'default';
-  const variableMatch = structuralPrefix.match(
-    /\bexport\s+(?:declare\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)(?:\s*:[^=;]+)?\s*=\s*$/,
-  );
-  if (variableMatch?.[1]) return variableMatch[1];
-  const localVariableMatch = structuralPrefix.match(
-    /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)(?:\s*:[^=;]+)?\s*=\s*$/,
+  exportName: string | null,
+): ExtractedPlayMetadata | null {
+  const ast = parsePlaySourceAst(sourceCode);
+  if (!ast) return null;
+  const context = buildPlayMetadataContext(ast);
+
+  const exportedExpression = resolveExportExpression(exportName, context);
+  const exportedMetadata = playMetadataFromDefinePlayCall(
+    exportedExpression,
+    context,
   );
-  return localVariableMatch?.[1] ?? null;
+  if (exportedMetadata) return exportedMetadata;
+
+  if (exportName) return null;
+
+  if (context.defaultExport) {
+    const directDefaultMetadata = playMetadataFromDefinePlayCall(
+      context.defaultExport,
+      context,
+    );
+    if (directDefaultMetadata) return directDefaultMetadata;
+
+    const defaultIdentifier = getIdentifierName(context.defaultExport);
+    if (defaultIdentifier) {
+      const defaultMetadata = playMetadataFromDefinePlayCall(
+        context.declarations.get(defaultIdentifier),
+        context,
+      );
+      if (defaultMetadata) return defaultMetadata;
+    }
+  }
+
+  for (const expression of context.declarations.values()) {
+    const metadata = playMetadataFromDefinePlayCall(expression, context);
+    if (metadata) return metadata;
+  }
+
+  for (const expression of context.commonJsExports.values()) {
+    const metadata = playMetadataFromDefinePlayCall(expression, context);
+    if (metadata) return metadata;
+  }
+
+  return null;
 }
 
 function canonicalizeRootPlayNameForWorkersRuntimeHash(