@astrale-os/cli 1.0.0-beta.0 → 1.0.0-beta.2

package/studio/server/introspect/anatomy/env-fields.ts

@@ -0,0 +1,66 @@
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { InterfaceDeclaration, Node, Project } from 'ts-morph'
+
+import type { EnvField } from '../../../shared/types'
+
+import { makeProject } from './source'
+
+/** Strip the leading-JSDoc decorations to a single trimmed line of prose. */
+function cleanDoc(raw: string | undefined): string | undefined {
+  if (!raw) return undefined
+  const text = raw
+    .replace(/^\/\*\*?/, '')
+    .replace(/\*\/$/, '')
+    .split('\n')
+    .map((l) => l.replace(/^\s*\*\s?/, '').trimEnd())
+    .join('\n')
+    .trim()
+    .replace(/\s*\n\s*/g, ' ')
+    .trim()
+  return text.length ? text : undefined
+}
+
+// ───────────────────────────── 3) env fields ──────────────────────────────
+
+const KNOWN_INFRA_FIELDS = new Set(['WORKER_URL', 'ASSETS', 'SELF', 'VIEW_DEV_URL'])
+
+export function buildEnvFields(root: string): EnvField[] {
+  const envFile = join(root, 'env.ts')
+  if (!existsSync(envFile)) return []
+
+  let project: Project
+  let sf
+  try {
+    project = makeProject()
+    sf = project.addSourceFileAtPath(envFile)
+  } catch {
+    return []
+  }
+
+  const iface: InterfaceDeclaration | undefined =
+    sf.getInterface('Env') ?? sf.getInterfaces().find((i) => i.getName() === 'Env')
+  if (!iface) return []
+
+  const fields: EnvField[] = []
+  for (const member of iface.getMembers()) {
+    // Skip index signatures: `[key: string]: unknown`.
+    if (Node.isIndexSignatureDeclaration(member)) continue
+    if (!Node.isPropertySignature(member)) continue
+
+    const name = member.getName()
+    if (!name) continue
+
+    const optional = member.hasQuestionToken()
+    const doc = cleanDoc(member.getJsDocs()[0]?.getInnerText())
+
+    const isInfra = KNOWN_INFRA_FIELDS.has(name)
+    const secret = !isInfra
+
+    const field: EnvField = { name, optional, secret }
+    if (doc) field.doc = doc
+    fields.push(field)
+  }
+
+  return fields
+}

package/studio/server/introspect/anatomy/schema-definition.ts

@@ -0,0 +1,53 @@
+import { join } from 'node:path'
+import { Node, type SourceFile, SyntaxKind } from 'ts-morph'
+
+import { addSource, listSourceFiles, literalString, makeProject } from './source'
+
+// Canonical schema source discovery.
+
+export interface SchemaDefinitionLocation {
+  origin: string
+  file: string
+  line: number
+}
+
+export function schemaProject(root: string, schemaDirName: string): SourceFile[] {
+  const project = makeProject()
+  return listSourceFiles(join(root, schemaDirName))
+    .map((file) => addSource(project, file))
+    .filter((source): source is SourceFile => source !== null)
+}
+
+export function defineSchemaCalls(source: SourceFile) {
+  return source.getDescendantsOfKind(SyntaxKind.CallExpression).filter((call) => {
+    const expression = call.getExpression()
+    return (
+      (Node.isIdentifier(expression) && expression.getText() === 'defineSchema') ||
+      (Node.isPropertyAccessExpression(expression) && expression.getName() === 'defineSchema')
+    )
+  })
+}
+
+/**
+ * Find the accepted schema without importing it. Current project roots are
+ * barrels, so all authored schema modules are inspected and local origin
+ * constants such as `defineSchema(ORIGIN, ...)` are resolved.
+ */
+export function findSchemaDefinition(
+  root: string,
+  schemaDirName = 'schema',
+): SchemaDefinitionLocation | null {
+  for (const source of schemaProject(root, schemaDirName)) {
+    for (const call of defineSchemaCalls(source)) {
+      const origin = literalString(call.getArguments()[0], source)
+      if (!origin) continue
+      const statement = call.getFirstAncestorByKind(SyntaxKind.VariableStatement)
+      return {
+        origin,
+        file: source.getFilePath(),
+        line: statement?.getStartLineNumber() ?? call.getStartLineNumber(),
+      }
+    }
+  }
+  return null
+}

package/studio/server/introspect/anatomy/source.ts

@@ -0,0 +1,181 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+import { Node, Project, type SourceFile } from 'ts-morph'
+
+export function readTextSafe(file: string): string {
+  try {
+    return existsSync(file) ? readFileSync(file, 'utf8') : ''
+  } catch {
+    return ''
+  }
+}
+
+export function listFiles(dir: string): string[] {
+  try {
+    return readdirSync(dir)
+      .filter((e) => {
+        try {
+          return statSync(join(dir, e)).isFile()
+        } catch {
+          return false
+        }
+      })
+      .sort()
+  } catch {
+    return []
+  }
+}
+
+export function listDirs(dir: string): string[] {
+  try {
+    return readdirSync(dir)
+      .filter((e) => {
+        try {
+          return statSync(join(dir, e)).isDirectory()
+        } catch {
+          return false
+        }
+      })
+      .sort()
+  } catch {
+    return []
+  }
+}
+
+const SOURCE_FILE = /\.[cm]?[jt]sx?$/
+const SKIP_SOURCE_DIRS = new Set(['__tests__', 'node_modules', '.git', '.astrale', '.dist', 'dist'])
+
+export function listSourceFiles(dir: string): string[] {
+  const files: string[] = []
+  const walk = (current: string) => {
+    let entries: string[]
+    try {
+      entries = readdirSync(current).sort()
+    } catch {
+      return
+    }
+    for (const entry of entries) {
+      if (SKIP_SOURCE_DIRS.has(entry)) continue
+      const file = join(current, entry)
+      let stat
+      try {
+        stat = statSync(file)
+      } catch {
+        continue
+      }
+      if (stat.isDirectory()) walk(file)
+      else if (
+        stat.isFile() &&
+        SOURCE_FILE.test(entry) &&
+        !entry.endsWith('.d.ts') &&
+        !/\.(?:test|spec)\.[cm]?[jt]sx?$/.test(entry)
+      ) {
+        files.push(file)
+      }
+    }
+  }
+  walk(dir)
+  return files
+}
+
+/** A throwaway in-memory ts-morph project (no tsconfig, no type-checking IO). */
+export function makeProject(): Project {
+  return new Project({
+    useInMemoryFileSystem: false,
+    skipAddingFilesFromTsConfig: true,
+    skipFileDependencyResolution: true,
+    skipLoadingLibFiles: true,
+    compilerOptions: { allowJs: true },
+  })
+}
+
+export function addSource(project: Project, file: string): SourceFile | null {
+  try {
+    return project.getSourceFile(file) ?? project.addSourceFileAtPath(file)
+  } catch {
+    return null
+  }
+}
+
+function unwrap(node: Node): Node {
+  let current = node
+  while (
+    Node.isAsExpression(current) ||
+    Node.isSatisfiesExpression(current) ||
+    Node.isParenthesizedExpression(current) ||
+    Node.isTypeAssertion(current) ||
+    Node.isNonNullExpression(current)
+  ) {
+    current = current.getExpression()
+  }
+  return current
+}
+
+export function localValue(
+  node: Node | undefined,
+  source: SourceFile,
+  seen = new Set<string>(),
+): Node | null {
+  if (!node) return null
+  const value = unwrap(node)
+  if (!Node.isIdentifier(value)) return value
+  const key = `${source.getFilePath()}:${value.getText()}`
+  if (seen.has(key)) return value
+  seen.add(key)
+  const init = source.getVariableDeclaration(value.getText())?.getInitializer()
+  return init ? localValue(init, source, seen) : value
+}
+
+export function objectValue(node: Node | undefined, source: SourceFile): Node | null {
+  const value = localValue(node, source)
+  return value && Node.isObjectLiteralExpression(value) ? value : null
+}
+
+export function objectProperty(object: Node, name: string, source: SourceFile): Node | null {
+  if (!Node.isObjectLiteralExpression(object)) return null
+  for (const property of object.getProperties()) {
+    if (Node.isPropertyAssignment(property) && property.getName() === name) {
+      return localValue(property.getInitializer(), source)
+    }
+    if (Node.isShorthandPropertyAssignment(property) && property.getName() === name) {
+      return localValue(property.getNameNode(), source)
+    }
+  }
+  return null
+}
+
+export function literalString(node: Node | undefined, source: SourceFile): string | undefined {
+  const value = localValue(node, source)
+  if (!value) return undefined
+  if (Node.isStringLiteral(value) || Node.isNoSubstitutionTemplateLiteral(value)) {
+    return value.getLiteralValue()
+  }
+  return undefined
+}
+
+export function callName(node: Node | null): string | undefined {
+  if (!node || !Node.isCallExpression(node)) return undefined
+  const expression = node.getExpression()
+  if (Node.isIdentifier(expression)) return expression.getText()
+  if (Node.isPropertyAccessExpression(expression)) return expression.getName()
+  return undefined
+}
+
+export function propertySlug(property: Node): string | undefined {
+  if (!Node.isPropertyAssignment(property) && !Node.isShorthandPropertyAssignment(property)) {
+    return undefined
+  }
+  const name = property.getNameNode()
+  if (Node.isStringLiteral(name) || Node.isNoSubstitutionTemplateLiteral(name)) {
+    return name.getLiteralValue()
+  }
+  return property.getName()
+}
+
+export function propertyValue(property: Node, source: SourceFile): Node | null {
+  if (Node.isPropertyAssignment(property)) return localValue(property.getInitializer(), source)
+  if (Node.isShorthandPropertyAssignment(property)) {
+    return localValue(property.getNameNode(), source)
+  }
+  return null
+}

package/studio/server/introspect/anatomy/views/legacy.ts

@@ -0,0 +1,232 @@
+import { existsSync, statSync } from 'node:fs'
+import { dirname, join, relative } from 'node:path'
+import { Node, Project, SyntaxKind } from 'ts-morph'
+
+import type { ViewInfo } from '../../../../shared/types'
+
+import { makeProject } from '../source'
+
+/**
+ * Resolve the relative `./welcome` / `../foo` import spec used in views/index.ts
+ * to an on-disk `.ts` file under the views dir. Returns absolute path or null.
+ */
+function resolveLocalModule(fromFile: string, spec: string): string | null {
+  if (!spec.startsWith('.')) return null
+  const base = join(dirname(fromFile), spec)
+  const candidates = [
+    base,
+    `${base}.ts`,
+    `${base}.tsx`,
+    join(base, 'index.ts'),
+    join(base, 'index.tsx'),
+  ]
+  for (const c of candidates) {
+    try {
+      if (existsSync(c) && statSync(c).isFile()) return c
+    } catch {
+      /* ignore */
+    }
+  }
+  return null
+}
+
+export function buildLegacyViews(root: string): ViewInfo[] {
+  const indexFile = join(root, 'views', 'index.ts')
+  if (!existsSync(indexFile)) return []
+
+  let project: Project
+  let index
+  try {
+    project = makeProject()
+    index = project.addSourceFileAtPath(indexFile)
+  } catch {
+    return []
+  }
+
+  // Map identifier name → imported module spec (e.g. `welcome` → './welcome').
+  const importSpecByName = new Map<string, string>()
+  for (const imp of index.getImportDeclarations()) {
+    const spec = imp.getModuleSpecifierValue()
+    for (const named of imp.getNamedImports()) {
+      importSpecByName.set(named.getAliasNode()?.getText() ?? named.getName(), spec)
+    }
+    const def = imp.getDefaultImport()
+    if (def) importSpecByName.set(def.getText(), spec)
+  }
+
+  // Find the exported `views` object literal: { welcome, 'ui-status-page': statusPage }.
+  const viewsDecl =
+    index.getVariableDeclaration('views') ??
+    index.getVariableDeclarations().find((d) => d.getName() === 'views')
+  const init = viewsDecl?.getInitializer()
+  if (!init || !Node.isObjectLiteralExpression(init)) return []
+
+  const views: ViewInfo[] = []
+  for (const prop of init.getProperties()) {
+    let slug: string | undefined
+    let refName: string | undefined
+    let inlineArg: Node | undefined // `slug: defineView({...})` declared right here (e.g. mcac)
+
+    if (Node.isShorthandPropertyAssignment(prop)) {
+      // `welcome,` → slug `welcome`, ref `welcome` (imported view file)
+      slug = prop.getName()
+      refName = prop.getName()
+    } else if (Node.isPropertyAssignment(prop)) {
+      const nameNode = prop.getNameNode()
+      slug = Node.isStringLiteral(nameNode) ? nameNode.getLiteralValue() : prop.getName()
+      const valueInit = prop.getInitializer()
+      if (
+        valueInit &&
+        Node.isCallExpression(valueInit) &&
+        valueInit.getExpression().getText() === 'defineView'
+      ) {
+        // `'ui-move': defineView({...})` — parsed in place
+        inlineArg = valueInit.getArguments()[0]
+      } else if (valueInit && Node.isIdentifier(valueInit)) {
+        // `'ui-status-page': statusPage` — resolved from an imported file
+        refName = valueInit.getText()
+      }
+    }
+
+    if (!slug) continue
+
+    const info: ViewInfo = { slug, kind: 'unknown', url: undefined }
+
+    if (inlineArg) {
+      // inline defineView (e.g. mcac) — the declaration lives in views/index.ts itself
+      info.file = relative(root, indexFile)
+      applyParsed(info, parseViewObject(inlineArg))
+    } else {
+      // A shorthand may reference a defineView declared earlier in this same
+      // registry file (services), or one imported from another module (ai-gateway).
+      const localInit = refName
+        ? index.getVariableDeclaration(refName)?.getInitializer()
+        : undefined
+      if (
+        localInit &&
+        Node.isCallExpression(localInit) &&
+        localInit.getExpression().getText() === 'defineView'
+      ) {
+        const arg = localInit.getArguments()[0]
+        if (arg) {
+          info.file = relative(root, indexFile)
+          applyParsed(info, parseViewObject(arg))
+        }
+      } else {
+        const spec = refName ? importSpecByName.get(refName) : undefined
+        const viewFile = spec ? resolveLocalModule(indexFile, spec) : null
+        if (viewFile) {
+          info.file = relative(root, viewFile)
+          try {
+            applyParsed(info, parseViewFile(project, viewFile))
+          } catch {
+            /* keep the unknown-kind stub */
+          }
+        }
+      }
+    }
+
+    views.push(info)
+  }
+
+  return views
+}
+
+interface ParsedView {
+  kind: ViewInfo['kind']
+  auth?: string
+  mount?: string
+  viewFor?: string | string[]
+  description?: string
+}
+
+/** Copy a ParsedView's set fields onto a ViewInfo. */
+function applyParsed(info: ViewInfo, parsed: ParsedView): void {
+  info.kind = parsed.kind
+  if (parsed.auth !== undefined) info.auth = parsed.auth
+  if (parsed.mount !== undefined) info.mount = parsed.mount
+  if (parsed.viewFor !== undefined) info.viewFor = parsed.viewFor
+  if (parsed.description !== undefined) info.description = parsed.description
+}
+
+/** Parse a referenced view module: find its defineView({...}) call + parse the literal. */
+function parseViewFile(project: Project, file: string): ParsedView {
+  const sf = project.addSourceFileAtPathIfExists(file) ?? project.addSourceFileAtPath(file)
+  for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+    if (call.getExpression().getText() === 'defineView') {
+      const arg = call.getArguments()[0]
+      if (arg) return parseViewObject(arg)
+    }
+  }
+  return { kind: 'unknown' }
+}
+
+/** Parse a `defineView({...})` object-literal argument into a ParsedView. */
+function parseViewObject(arg: Node): ParsedView {
+  const result: ParsedView = { kind: 'unknown' }
+  if (!Node.isObjectLiteralExpression(arg)) return result
+
+  let hasRender = false
+  let hasInlineHtml = false
+  let hasMount = false
+
+  for (const prop of arg.getProperties()) {
+    if (
+      !Node.isPropertyAssignment(prop) &&
+      !Node.isMethodDeclaration(prop) &&
+      !Node.isShorthandPropertyAssignment(prop)
+    ) {
+      continue
+    }
+    const key = prop.getName?.()
+    if (!key) continue
+
+    if (key === 'auth') {
+      if (Node.isPropertyAssignment(prop)) {
+        const v = prop.getInitializer()
+        if (v && Node.isStringLiteral(v)) result.auth = v.getLiteralValue()
+        else if (v) result.auth = v.getText().replace(/^['"`]|['"`]$/g, '')
+      }
+    } else if (key === 'mount') {
+      hasMount = true
+      if (Node.isPropertyAssignment(prop)) {
+        const v = prop.getInitializer()
+        if (v && Node.isStringLiteral(v)) result.mount = v.getLiteralValue()
+        else if (v) result.mount = v.getText().replace(/^['"`]|['"`]$/g, '')
+      }
+    } else if (key === 'render') {
+      hasRender = true
+      // Inline HTML if the render body references c.html(...) or returns an HTML string.
+      const text = prop.getText()
+      if (/\bc\s*\.\s*html\s*\(/.test(text) || /<!doctype html>|<html\b/i.test(text)) {
+        hasInlineHtml = true
+      }
+    } else if (key === 'viewFor') {
+      if (Node.isPropertyAssignment(prop)) {
+        const v = prop.getInitializer()
+        if (v) {
+          // selfOf(A) → 'A' ; [selfOf(A), selfOf(B)] → ['A','B'] ; else best-effort identifier.
+          const names = [...v.getText().matchAll(/selfOf\s*\(\s*([A-Za-z_$][\w$]*)\s*\)/g)].map(
+            (m) => m[1],
+          )
+          if (names.length > 1) result.viewFor = names
+          else if (names.length === 1) result.viewFor = names[0]
+          else if (Node.isIdentifier(v)) result.viewFor = v.getText()
+        }
+      }
+    } else if (key === 'description') {
+      if (Node.isPropertyAssignment(prop)) {
+        const v = prop.getInitializer()
+        if (v && Node.isStringLiteral(v)) result.description = v.getLiteralValue()
+      }
+    }
+  }
+
+  if (hasRender && (hasInlineHtml || !hasMount)) result.kind = 'inline-html'
+  else if (hasMount) result.kind = 'spa'
+  else result.kind = 'unknown'
+
+  return result
+}
+
+// ───────────────────────────── 2) client tree ─────────────────────────────

package/studio/server/introspect/anatomy/views/routes.ts

@@ -0,0 +1,105 @@
+import { existsSync } from 'node:fs'
+import { join, relative } from 'node:path'
+import { Node, type SourceFile, SyntaxKind } from 'ts-morph'
+
+import type { ViewInfo } from '../../../../shared/types'
+
+import { defineSchemaCalls, schemaProject } from '../schema-definition'
+import {
+  addSource,
+  callName,
+  listSourceFiles,
+  literalString,
+  makeProject,
+  objectProperty,
+  objectValue,
+  propertySlug,
+  propertyValue,
+} from '../source'
+
+/** Locate authored declarations for canonical View keys without projecting any semantics. */
+export function buildSchemaViewSources(root: string, schemaDirName: string): Map<string, string> {
+  const sources = new Map<string, string>()
+  for (const source of schemaProject(root, schemaDirName)) {
+    for (const call of defineSchemaCalls(source)) {
+      const input = objectValue(call.getArguments()[1], source)
+      const declared = input
+        ? objectValue(objectProperty(input, 'views', source) ?? undefined, source)
+        : null
+      if (!declared || !Node.isObjectLiteralExpression(declared)) continue
+      for (const property of declared.getProperties()) {
+        const slug = propertySlug(property)
+        const declaration = propertyValue(property, source)
+        if (
+          slug &&
+          declaration &&
+          Node.isCallExpression(declaration) &&
+          callName(declaration) === 'view'
+        ) {
+          sources.set(slug, relative(root, source.getFilePath()).replaceAll('\\', '/'))
+        }
+      }
+    }
+  }
+  return sources
+}
+
+function frontendKind(
+  frontendName: string,
+  input: Node,
+  source: SourceFile,
+): { kind: ViewInfo['kind']; external: boolean } {
+  if (frontendName === 'reactFrontend') return { kind: 'spa', external: false }
+  const sourceName = callName(objectProperty(input, 'source', source))
+  if (sourceName === 'generatedFrontend') return { kind: 'inline-html', external: false }
+  if (sourceName === 'viteFrontend' || sourceName === 'prebuiltFrontend') {
+    return { kind: 'spa', external: false }
+  }
+  if (sourceName === 'externalFrontend') return { kind: 'spa', external: true }
+  return { kind: 'unknown', external: false }
+}
+
+export function buildFrontendViews(root: string): ViewInfo[] {
+  const project = makeProject()
+  const compositionFiles = ['implementation.ts', 'domain.ts']
+    .map((file) => join(root, file))
+    .filter((file) => existsSync(file))
+  const sources = [...new Set([...listSourceFiles(join(root, 'views')), ...compositionFiles])]
+    .map((file) => addSource(project, file))
+    .filter((source): source is SourceFile => source !== null)
+  const views: ViewInfo[] = []
+
+  for (const source of sources) {
+    for (const call of source.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+      const frontendName = callName(call)
+      if (frontendName !== 'frontendArtifact' && frontendName !== 'reactFrontend') continue
+      const input = objectValue(call.getArguments()[0], source)
+      if (!input) continue
+      const routes = objectValue(objectProperty(input, 'routes', source) ?? undefined, source)
+      if (!routes || !Node.isObjectLiteralExpression(routes)) continue
+      const artifact = frontendKind(frontendName, input, source)
+
+      for (const property of routes.getProperties()) {
+        const slug = propertySlug(property)
+        const routeValue = propertyValue(property, source)
+        if (!slug || !routeValue) continue
+        const routeName = callName(routeValue)
+        const routeInput = Node.isCallExpression(routeValue)
+          ? objectValue(routeValue.getArguments()[0], source)
+          : objectValue(routeValue, source)
+        if (!routeInput) continue
+
+        const path = literalString(objectProperty(routeInput, 'path', source) ?? undefined, source)
+        const href = literalString(objectProperty(routeInput, 'href', source) ?? undefined, source)
+        views.push({
+          slug,
+          kind: routeName === 'reactRoute' ? 'spa' : artifact.kind,
+          ...(href ? { url: href } : { url: undefined }),
+          ...(!href && (path || !artifact.external) ? { mount: path ?? `/ui/${slug}` } : {}),
+          file: relative(root, source.getFilePath()).replaceAll('\\', '/'),
+        })
+      }
+    }
+  }
+  return views
+}

package/studio/server/introspect/anatomy/views.ts

@@ -0,0 +1,58 @@
+import type { SchemaIR, ViewInfo } from '../../../shared/types'
+
+import { buildLegacyViews } from './views/legacy'
+import { buildFrontendViews, buildSchemaViewSources } from './views/routes'
+
+function mergeRoute(target: ViewInfo, incoming: ViewInfo): void {
+  if (incoming.kind !== 'unknown') target.kind = incoming.kind
+  if (incoming.mount !== undefined) target.mount = incoming.mount
+  if (incoming.url !== undefined) target.url = incoming.url
+  if (incoming.file) target.file = incoming.file
+}
+
+function canonicalViewInfo(slug: string, view: NonNullable<SchemaIR['views']>[string]): ViewInfo {
+  const targets =
+    view.target.kind === 'definition' ? view.target.definitions.map((ref) => ref.name) : []
+  return {
+    slug,
+    kind: 'unknown',
+    auth: view.auth,
+    ...(view.description ? { description: view.description } : {}),
+    ...(targets.length === 1
+      ? { viewFor: targets[0] }
+      : targets.length > 1
+        ? { viewFor: targets }
+        : {}),
+  }
+}
+
+/**
+ * Join canonical View definitions with route/source metadata. Passing a
+ * canonical map (including an empty map) makes it authoritative: static routes
+ * cannot invent Views or override identity, target, auth, or description.
+ * Without it, the legacy defineView registry remains the compatibility source.
+ */
+export function buildViews(
+  root: string,
+  _schemaDirName = 'schema',
+  canonicalViews?: NonNullable<SchemaIR['views']>,
+): ViewInfo[] {
+  const merged = new Map<string, ViewInfo>()
+  if (canonicalViews !== undefined) {
+    for (const [slug, view] of Object.entries(canonicalViews)) {
+      merged.set(slug, canonicalViewInfo(slug, view))
+    }
+    for (const [slug, file] of buildSchemaViewSources(root, _schemaDirName)) {
+      const current = merged.get(slug)
+      if (current) current.file = file
+    }
+  } else {
+    for (const view of buildLegacyViews(root)) merged.set(view.slug, view)
+  }
+  for (const view of buildFrontendViews(root)) {
+    const current = merged.get(view.slug)
+    if (current) mergeRoute(current, view)
+    else if (canonicalViews === undefined) merged.set(view.slug, view)
+  }
+  return [...merged.values()]
+}