{"version":3,"file":"moduleShape.js","sources":["../../../src/vite/moduleShape.ts"],"sourcesContent":["import type { BaseNode, ProgramBody } from './transform';\n\n// ---------------------------------------------------------------------------\n// Minimal ESTree node shapes for structural Agent detection.\n// ---------------------------------------------------------------------------\n\ninterface IdentifierNode extends BaseNode {\n  name: string;\n}\n\ninterface ClassNode extends BaseNode {\n  id?: IdentifierNode | null;\n  superClass?: BaseNode | null;\n}\n\ninterface MemberExpressionNode extends BaseNode {\n  object?: { type: string; name?: string };\n  property?: { type: string; name?: string };\n}\n\ninterface ImportSpecifierNode {\n  type: string;\n  imported?: { type: string; name?: string };\n  local?: { type: string; name?: string };\n}\n\ninterface ImportDeclarationNode extends BaseNode {\n  source?: { value?: unknown };\n  specifiers?: ImportSpecifierNode[];\n}\n\ninterface ExportSpecifierNode {\n  type: string;\n  local?: { type: string; name?: string };\n  exported?: { type: string; name?: string };\n}\n\ninterface ExportNamedNode extends BaseNode {\n  declaration?: BaseNode | null;\n  source?: { value?: unknown } | null;\n  specifiers?: ExportSpecifierNode[];\n}\n\ninterface ExportDefaultNode extends BaseNode {\n  declaration: BaseNode;\n}\n\ninterface ExportAllNode extends BaseNode {\n  source?: { value?: unknown };\n  exported?: { type: string; name?: string } | null;\n}\n\n/** Binding name used for a module's default export. */\nexport const DEFAULT_EXPORT = 'default';\n\n/** A resolved superclass reference: a bare identifier or a `ns.Member` expression. */\nexport type SuperRef = { kind: 'identifier'; name: string } | { kind: 'member'; object: string; property: string };\n\n/** The declarations of a single module that binding resolution needs. */\nexport interface ModuleShape {\n  /** Top-level class names → their superclass reference (absent when the class has no `extends`). */\n  classes: Map<string, SuperRef | undefined>;\n  /** Local binding name → the import it came from (`imported` is `default` for a default import). */\n  imports: Map<string, { source: string; imported: string }>;\n  /** Local binding name → module specifier, for `import * as ns from '...'`. */\n  namespaces: Map<string, string>;\n  /** Exported name → the re-export it came from, for `export { x as y } from '...'`. */\n  reexports: Map<string, { source: string; imported: string }>;\n  /** Exported name → local binding name, for `export { x as y }` without a source. */\n  localExports: Map<string, string>;\n  /** Module specifiers of bare `export * from '...'` declarations. */\n  starExports: string[];\n  /** `export default <Identifier>` — the local name it refers to. */\n  defaultExportName?: string;\n  /** True when the module's default export is a class declaration/expression. */\n  defaultExportIsClass?: boolean;\n  /** Superclass of an anonymous `export default class extends X`. */\n  defaultExportSuper?: SuperRef;\n}\n\nfunction emptyShape(): ModuleShape {\n  return {\n    classes: new Map(),\n    imports: new Map(),\n    namespaces: new Map(),\n    reexports: new Map(),\n    localExports: new Map(),\n    starExports: [],\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Shape from a parsed AST (used for the entry module)\n// ---------------------------------------------------------------------------\n\n/** Collect the shape of a module from its parsed AST — used for the already-parsed entry module. */\nexport function shapeFromAst(ast: ProgramBody): ModuleShape {\n  const shape = emptyShape();\n\n  for (const node of ast.body) {\n    switch (node.type) {\n      case 'ClassDeclaration':\n        addAstClass(shape, node as ClassNode);\n        break;\n      case 'ImportDeclaration':\n        addAstImports(shape, node as ImportDeclarationNode);\n        break;\n      case 'ExportNamedDeclaration':\n        addAstNamedExport(shape, node as ExportNamedNode);\n        break;\n      case 'ExportDefaultDeclaration': {\n        const decl = (node as ExportDefaultNode).declaration;\n        if (decl.type === 'ClassDeclaration' || decl.type === 'ClassExpression') {\n          shape.defaultExportIsClass = true;\n          shape.defaultExportSuper = superRefFromNode((decl as ClassNode).superClass);\n          // `export default class Foo {}` also binds `Foo` locally.\n          addAstClass(shape, decl as ClassNode);\n        } else if (decl.type === 'Identifier') {\n          shape.defaultExportName = (decl as IdentifierNode).name;\n        }\n        break;\n      }\n      case 'ExportAllDeclaration': {\n        const starNode = node as ExportAllNode;\n        // `export * as ns from '...'` binds a namespace object, not the individual exports.\n        const source = starNode.exported ? undefined : asString(starNode.source?.value);\n        if (source) shape.starExports.push(source);\n        break;\n      }\n    }\n  }\n\n  return shape;\n}\n\nfunction superRefFromNode(superClass: BaseNode | null | undefined): SuperRef | undefined {\n  if (!superClass) return undefined;\n\n  if (superClass.type === 'Identifier') {\n    return { kind: 'identifier', name: (superClass as IdentifierNode).name };\n  }\n\n  if (superClass.type === 'MemberExpression') {\n    const member = superClass as MemberExpressionNode;\n    const object = member.object?.type === 'Identifier' ? member.object.name : undefined;\n    const property = member.property?.name;\n    if (object && property) return { kind: 'member', object, property };\n  }\n\n  return undefined;\n}\n\nfunction addAstClass(shape: ModuleShape, classNode: ClassNode): void {\n  if (classNode.id?.name) shape.classes.set(classNode.id.name, superRefFromNode(classNode.superClass));\n}\n\nfunction addAstImports(shape: ModuleShape, node: ImportDeclarationNode): void {\n  const source = asString(node.source?.value);\n  if (!source) return;\n\n  for (const specifier of node.specifiers ?? []) {\n    const local = specifier.local?.name;\n    if (!local) continue;\n\n    if (specifier.type === 'ImportSpecifier' && specifier.imported?.name) {\n      shape.imports.set(local, { source, imported: specifier.imported.name });\n    } else if (specifier.type === 'ImportDefaultSpecifier') {\n      shape.imports.set(local, { source, imported: DEFAULT_EXPORT });\n    } else if (specifier.type === 'ImportNamespaceSpecifier') {\n      shape.namespaces.set(local, source);\n    }\n  }\n}\n\nfunction addAstNamedExport(shape: ModuleShape, node: ExportNamedNode): void {\n  if (node.declaration?.type === 'ClassDeclaration') {\n    addAstClass(shape, node.declaration as ClassNode);\n    return;\n  }\n\n  const source = asString(node.source?.value);\n  for (const specifier of node.specifiers ?? []) {\n    const exported = specifier.exported?.name;\n    const local = specifier.local?.name;\n    if (!exported || !local) continue;\n\n    if (source) {\n      shape.reexports.set(exported, { source, imported: local });\n    } else {\n      shape.localExports.set(exported, local);\n    }\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Shape from raw source (used for sibling modules read off disk)\n// ---------------------------------------------------------------------------\n\n/**\n * Extract the module shape from **unprocessed source**.\n *\n * Sibling modules are read straight from disk (the plugin context's `load()` would deadlock inside a\n * transform hook), so they may still be TypeScript — which no JS parser will accept. Only\n * import/export statements and `class X extends Y` headers matter here, and those are\n * declaration-level syntax a scan can pick out reliably; class bodies, type annotations and generics\n * are irrelevant and simply skipped.\n */\nexport function shapeFromSource(rawCode: string): ModuleShape {\n  const code = stripComments(rawCode);\n  const shape = emptyShape();\n\n  // `class X extends Y {` / `class X<T> extends Y<T> {`, optionally exported and/or abstract.\n  const CLASS_RE = /\\b(?:export\\s+(?:default\\s+)?)?(?:abstract\\s+)?class\\s+([A-Za-z_$][\\w$]*)([^{]*)\\{/g;\n  for (const match of code.matchAll(CLASS_RE)) {\n    const className = match[1]!;\n    const isDefault = /\\bexport\\s+default\\b/.test(match[0]);\n    const superRef = superRefFromHeader(match[2] ?? '');\n\n    shape.classes.set(className, superRef);\n    if (isDefault) {\n      shape.defaultExportIsClass = true;\n      shape.defaultExportSuper = superRef;\n    }\n  }\n\n  // `export default Identifier;`\n  const defaultExprMatch = /\\bexport\\s+default\\s+([A-Za-z_$][\\w$]*)\\s*;/.exec(code);\n  if (defaultExprMatch && !shape.defaultExportIsClass) {\n    shape.defaultExportName = defaultExprMatch[1];\n  }\n\n  // `export * from '...'` (but not `export * as ns from '...'`).\n  for (const match of code.matchAll(/\\bexport\\s*\\*\\s*from\\s*['\"]([^'\"]+)['\"]/g)) {\n    if (match[1]) shape.starExports.push(match[1]);\n  }\n\n  // `export { a, b as c } from '...'` and `export { a, b as c }`.\n  for (const match of code.matchAll(/\\bexport\\s*\\{([^}]*)\\}\\s*(?:from\\s*['\"]([^'\"]+)['\"])?/g)) {\n    const source = match[2];\n    for (const { imported, local } of parseSpecifierList(match[1] ?? '')) {\n      // In an export clause the first name is local and the alias is the exported name.\n      if (source) {\n        shape.reexports.set(local, { source, imported });\n      } else {\n        shape.localExports.set(local, imported);\n      }\n    }\n  }\n\n  // `import Default, { a as b }, * as ns from '...'` in its various shapes.\n  for (const match of code.matchAll(/\\bimport\\s+([^'\";]+?)\\s+from\\s*['\"]([^'\"]+)['\"]/g)) {\n    addSourceImports(shape, match[1] ?? '', match[2]!);\n  }\n\n  return shape;\n}\n\n/** Pull the superclass out of the text between a class name and its body. */\nfunction superRefFromHeader(header: string): SuperRef | undefined {\n  // The header still carries the class's own generic parameter list (`<T extends S>`), whose\n  // constraint `extends` would otherwise be mistaken for the superclass clause. Strip a leading\n  // balanced `<...>` first, then read the (possibly dotted) base name. Trailing generic args on the\n  // base (`extends Agent<Env>`) stop the match naturally.\n  const withoutParams = stripLeadingGenerics(header);\n  const match = /\\bextends\\s+([A-Za-z_$][\\w$]*)\\s*(?:\\.\\s*([A-Za-z_$][\\w$]*))?/.exec(withoutParams);\n  if (!match) return undefined;\n\n  return match[2] ? { kind: 'member', object: match[1]!, property: match[2] } : { kind: 'identifier', name: match[1]! };\n}\n\n/**\n * Remove a leading `<...>` generic parameter list, honoring nesting (`<T extends Map<K, V>>`).\n * Anything after the balanced close — the superclass clause — is returned unchanged. When the\n * header doesn't start with `<` (no generics), it is returned as-is.\n */\nfunction stripLeadingGenerics(header: string): string {\n  const start = header.indexOf('<');\n  // Only treat it as a parameter list when `<` is the first meaningful token — a `<` appearing\n  // later is part of the superclass's own generic args and must be left alone.\n  if (start === -1 || header.slice(0, start).trim() !== '') return header;\n\n  let depth = 0;\n  for (let i = start; i < header.length; i++) {\n    const char = header[i];\n    if (char === '<') depth++;\n    else if (char === '>') {\n      depth--;\n      if (depth === 0) return header.slice(i + 1);\n    }\n  }\n  // Unbalanced `<` — fall back to the untouched header rather than dropping the superclass.\n  return header;\n}\n\n/** Parse `a, b as c` into `{ imported: 'b', local: 'c' }` pairs (type-only specifiers dropped). */\nfunction parseSpecifierList(clause: string): Array<{ imported: string; local: string }> {\n  const specifiers: Array<{ imported: string; local: string }> = [];\n\n  for (const rawPart of clause.split(',')) {\n    const part = rawPart.trim().replace(/^type\\s+/, '');\n    if (!part) continue;\n\n    const aliased = /^([A-Za-z_$][\\w$]*)\\s+as\\s+([A-Za-z_$][\\w$]*)$/.exec(part);\n    if (aliased) {\n      specifiers.push({ imported: aliased[1]!, local: aliased[2]! });\n    } else if (/^[A-Za-z_$][\\w$]*$/.test(part)) {\n      specifiers.push({ imported: part, local: part });\n    }\n  }\n\n  return specifiers;\n}\n\nfunction addSourceImports(shape: ModuleShape, clause: string, source: string): void {\n  // Type-only imports never contribute a runtime base class.\n  if (/^type\\s/.test(clause.trim())) return;\n\n  const namespaceMatch = /\\*\\s*as\\s+([A-Za-z_$][\\w$]*)/.exec(clause);\n  if (namespaceMatch) {\n    shape.namespaces.set(namespaceMatch[1]!, source);\n  }\n\n  const bracesMatch = /\\{([^}]*)\\}/.exec(clause);\n  if (bracesMatch) {\n    for (const { imported, local } of parseSpecifierList(bracesMatch[1] ?? '')) {\n      shape.imports.set(local, { source, imported });\n    }\n  }\n\n  // A leading bare identifier (before any brace/star) is the default import.\n  const defaultMatch = /^\\s*([A-Za-z_$][\\w$]*)\\s*(?:,|$)/.exec(clause);\n  if (defaultMatch) {\n    shape.imports.set(defaultMatch[1]!, { source, imported: DEFAULT_EXPORT });\n  }\n}\n\n/** Remove line and block comments, leaving string literals (module specifiers) intact. */\nfunction stripComments(code: string): string {\n  let result = '';\n  let index = 0;\n\n  while (index < code.length) {\n    const char = code[index]!;\n    const next = code[index + 1];\n\n    if (char === '/' && next === '/') {\n      while (index < code.length && code[index] !== '\\n') index++;\n      continue;\n    }\n\n    if (char === '/' && next === '*') {\n      index += 2;\n      while (index < code.length && !(code[index] === '*' && code[index + 1] === '/')) index++;\n      index += 2;\n      // Keep a separator so `*/class` doesn't fuse into one token.\n      result += ' ';\n      continue;\n    }\n\n    if (char === '\"' || char === \"'\" || char === '`') {\n      const quote = char;\n      result += char;\n      index++;\n      while (index < code.length) {\n        const inner = code[index]!;\n        result += inner;\n        index++;\n        if (inner === '\\\\') {\n          if (index < code.length) {\n            result += code[index]!;\n            index++;\n          }\n          continue;\n        }\n        if (inner === quote) break;\n      }\n      continue;\n    }\n\n    result += char;\n    index++;\n  }\n\n  return result;\n}\n\nfunction asString(value: unknown): string | undefined {\n  return typeof value === 'string' && value ? value : undefined;\n}\n"],"names":[],"mappings":"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"}