@astrale-os/cli 1.0.0-beta.3 → 1.0.0-beta.31

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

@@ -1,9 +1,9 @@
-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 { resolveApplicationEntry } from '../../../domain'
 import { defineSchemaCalls, schemaProject } from '../schema-definition'
 import {
   addSource,
@@ -44,27 +44,29 @@ export function buildSchemaViewSources(root: string, schemaDirName: string): Map
   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 }
+function defaultRoute(name: string): string {
+  return `/${name
+    .replace(/([a-z0-9])([A-Z])/gu, '$1-$2')
+    .replace(/[_\s]+/gu, '-')
+    .toLowerCase()}`
+}
+
+function frontendSource(input: Node, source: SourceFile): { externalOrigin?: string } {
+  const value = objectProperty(input, 'source', source)
+  if (!value || !Node.isCallExpression(value)) return {}
+  if (callName(value) !== 'external') return {}
+  const origin = literalString(value.getArguments()[0], source)
+  return origin === undefined ? {} : { externalOrigin: origin }
 }
 
-export function buildFrontendViews(root: string): ViewInfo[] {
+export function buildFrontendViews(
+  root: string,
+  canonicalViewNames: readonly 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])]
+  const application = resolveApplicationEntry(root)
+  const applicationFiles = application === null ? [] : [application]
+  const sources = [...new Set([...listSourceFiles(join(root, 'views')), ...applicationFiles])]
     .map((file) => addSource(project, file))
     .filter((source): source is SourceFile => source !== null)
   const views: ViewInfo[] = []
@@ -72,30 +74,37 @@ export function buildFrontendViews(root: string): ViewInfo[] {
   for (const source of sources) {
     for (const call of source.getDescendantsOfKind(SyntaxKind.CallExpression)) {
       const frontendName = callName(call)
-      if (frontendName !== 'frontendArtifact' && frontendName !== 'reactFrontend') continue
+      if (frontendName !== 'defineFrontend') 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 declared = new Map<string, string>()
+      if (routes && Node.isObjectLiteralExpression(routes)) {
+        for (const property of routes.getProperties()) {
+          const slug = propertySlug(property)
+          const routeValue = propertyValue(property, source)
+          if (!slug || !routeValue) continue
+          const direct = literalString(routeValue, source)
+          const routeInput = objectValue(routeValue, source)
+          const path =
+            direct ??
+            (routeInput
+              ? literalString(objectProperty(routeInput, 'path', source) ?? undefined, source)
+              : undefined)
+          if (path) declared.set(slug, path)
+        }
+      }
+      const frontend = frontendSource(input, source)
 
-        const path = literalString(objectProperty(routeInput, 'path', source) ?? undefined, source)
-        const href = literalString(objectProperty(routeInput, 'href', source) ?? undefined, source)
+      for (const slug of canonicalViewNames) {
+        const path = declared.get(slug) ?? defaultRoute(slug)
+        const url = frontend.externalOrigin
+          ? new URL(path, `${frontend.externalOrigin}/`).toString()
+          : undefined
         views.push({
           slug,
-          kind: routeName === 'reactRoute' ? 'spa' : artifact.kind,
-          ...(href ? { url: href } : { url: undefined }),
-          ...(!href && (path || !artifact.external) ? { mount: path ?? `/ui/${slug}` } : {}),
+          kind: 'spa',
+          ...(url ? { url } : { mount: path }),
           file: relative(root, source.getFilePath()).replaceAll('\\', '/'),
         })
       }

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

@@ -1,6 +1,5 @@
 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 {
@@ -16,7 +15,6 @@ function canonicalViewInfo(slug: string, view: NonNullable<SchemaIR['views']>[st
   return {
     slug,
     kind: 'unknown',
-    auth: view.auth,
     ...(view.description ? { description: view.description } : {}),
     ...(targets.length === 1
       ? { viewFor: targets[0] }
@@ -29,8 +27,8 @@ function canonicalViewInfo(slug: string, view: NonNullable<SchemaIR['views']>[st
 /**
  * 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.
+ * cannot invent Views or override identity, target, or description.
+ * Without admitted canonical Views, Studio does not invent authoring semantics.
  */
 export function buildViews(
   root: string,
@@ -38,21 +36,17 @@ export function buildViews(
   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)
+  const admittedViews = canonicalViews ?? {}
+  for (const [slug, view] of Object.entries(admittedViews)) {
+    merged.set(slug, canonicalViewInfo(slug, view))
   }
-  for (const view of buildFrontendViews(root)) {
+  for (const [slug, file] of buildSchemaViewSources(root, _schemaDirName)) {
+    const current = merged.get(slug)
+    if (current) current.file = file
+  }
+  for (const view of buildFrontendViews(root, Object.keys(admittedViews))) {
     const current = merged.get(view.slug)
     if (current) mergeRoute(current, view)
-    else if (canonicalViews === undefined) merged.set(view.slug, view)
   }
   return [...merged.values()]
 }

package/studio/server/introspect/anatomy-extras.test.ts

@@ -46,7 +46,7 @@ test('reads the discovered client directory', () => {
   })
 })
 
-test('resolves views declared in the registry file itself', () => {
+test('does not treat a removed view registry as Schema authority', () => {
   const root = mkdtempSync(join(tmpdir(), 'studio-inline-view-registry-'))
   roots.push(root)
   const viewsDir = join(root, 'views')
@@ -55,12 +55,10 @@ test('resolves views declared in the registry file itself', () => {
     join(viewsDir, 'index.ts'),
     `import { defineView } from '@astrale-os/sdk'
 const services = defineView({
-  auth: 'required',
   mount: '/ui/services',
   description: 'Browse services.',
 })
 const service = defineView({
-  auth: 'required',
   mount: '/ui/service',
   viewFor: [selfOf(CloudflareWorker)],
 })
@@ -68,29 +66,10 @@ export const views = { services, service }
 `,
   )
 
-  expect(buildViews(root)).toEqual([
-    {
-      slug: 'services',
-      kind: 'spa',
-      url: undefined,
-      file: 'views/index.ts',
-      auth: 'required',
-      mount: '/ui/services',
-      description: 'Browse services.',
-    },
-    {
-      slug: 'service',
-      kind: 'spa',
-      url: undefined,
-      file: 'views/index.ts',
-      auth: 'required',
-      mount: '/ui/service',
-      viewFor: 'CloudflareWorker',
-    },
-  ])
+  expect(buildViews(root)).toEqual([])
 })
 
-test('joins canonical Bundle Views with reactFrontend route metadata', () => {
+test('joins canonical Bundle Views with defineFrontend route metadata', () => {
   const root = mkdtempSync(join(tmpdir(), 'studio-current-react-view-'))
   roots.push(root)
   mkdirSync(join(root, 'schema', 'application'), { recursive: true })
@@ -108,7 +87,6 @@ const schemaInput = {
   views: {
     issue: view({
       target: [Issue, Group],
-      auth: 'optional',
       description: 'Inspect an issue.',
     }),
   },
@@ -118,11 +96,13 @@ export const schema = defineSchema(ORIGIN, schemaInput)
   )
   writeFileSync(
     join(root, 'views', 'routes.ts'),
-    `import { reactFrontend, reactRoute } from '@astrale-os/sdk/react'
-const routes = {
-  issue: reactRoute({ path: '/ui/issues/:id', component: { module: './views/issue.tsx' } }),
-}
-export const frontend = reactFrontend({ schema, routes, entrypoint: 'issue' })
+    `import { defineFrontend, vite } from '@astrale-os/sdk/application'
+export const frontend = defineFrontend({
+  schema,
+  source: vite(),
+  routes: { issue: '/ui/issues/:id' },
+  entrypoint: 'issue',
+})
 `,
   )
 
@@ -131,13 +111,12 @@ export const frontend = reactFrontend({ schema, routes, entrypoint: 'issue' })
     buildViews(root, 'schema', {
       issue: {
         name: 'issue',
-        auth: 'optional',
         description: 'Inspect an issue.',
         target: {
           kind: 'definition',
           definitions: [
             { origin: 'issues.example.dev', kind: 'class', name: 'Issue' },
-            { origin: 'accounts.example.dev', kind: 'interface', name: 'Group' },
+            { origin: 'accounts.example.dev', kind: 'class', name: 'Group' },
           ],
         },
       },
@@ -146,7 +125,6 @@ export const frontend = reactFrontend({ schema, routes, entrypoint: 'issue' })
     {
       slug: 'issue',
       kind: 'spa',
-      auth: 'optional',
       mount: '/ui/issues/:id',
       url: undefined,
       viewFor: ['Issue', 'Group'],
@@ -156,7 +134,7 @@ export const frontend = reactFrontend({ schema, routes, entrypoint: 'issue' })
   ])
 })
 
-test('discovers generated frontend routes without deriving canonical View defaults', () => {
+test('discovers Vite frontend default routes from canonical View names', () => {
   const root = mkdtempSync(join(tmpdir(), 'studio-current-generated-view-'))
   roots.push(root)
   mkdirSync(join(root, 'schema'), { recursive: true })
@@ -170,11 +148,10 @@ test('discovers generated frontend routes without deriving canonical View defaul
   )
   writeFileSync(
     join(root, 'views', 'summary', 'index.ts'),
-    `const source = generatedFrontend({ files: [{ path: 'index.html', content: '<h1>Hi</h1>' }] })
-export const frontend = frontendArtifact({
+    `const source = vite()
+export const frontend = defineFrontend({
   schema,
   source,
-  routes: { summary: frontendRoute({}) },
   entrypoint: 'summary',
 })
 `,
@@ -184,16 +161,14 @@ export const frontend = frontendArtifact({
     buildViews(root, 'schema', {
       summary: {
         name: 'summary',
-        auth: 'required',
         target: { kind: 'domain' },
       },
     }),
   ).toEqual([
     {
       slug: 'summary',
-      kind: 'inline-html',
-      auth: 'required',
-      mount: '/ui/summary',
+      kind: 'spa',
+      mount: '/summary',
       url: undefined,
       file: 'views/summary/index.ts',
     },
@@ -208,19 +183,20 @@ test('canonical Bundle views reject static schema and route-only identities', ()
     join(root, 'schema', 'index.ts'),
     `export const schema = defineSchema('static.invalid', {
   views: {
-    account: view({ target: WrongTarget, auth: 'public', description: 'Static guess.' }),
-    sourceOnly: view({ target: WrongTarget, auth: 'public', description: 'Static guess.' }),
-    invented: view({ target: 'domain', auth: 'public' }),
+    account: view({ target: WrongTarget, description: 'Static guess.' }),
+    sourceOnly: view({ target: WrongTarget, description: 'Static guess.' }),
+    invented: view({ target: 'domain' }),
   },
 })`,
   )
   writeFileSync(
-    join(root, 'implementation.ts'),
-    `export const frontend = frontendArtifact({
-  source: externalFrontend({ href: 'https://shell.example.dev' }),
+    join(root, 'application.ts'),
+    `export const frontend = defineFrontend({
+  schema,
+  source: external('https://shell.example.dev'),
   routes: {
-    account: frontendRoute({ href: 'https://shell.example.dev/account' }),
-    routeOnly: frontendRoute({ href: 'https://shell.example.dev/route-only' }),
+    account: '/account',
+    routeOnly: '/route-only',
   },
 })`,
   )
@@ -229,7 +205,6 @@ test('canonical Bundle views reject static schema and route-only identities', ()
     buildViews(root, 'schema', {
       account: {
         name: 'account',
-        auth: 'required',
         description: 'Admitted account view.',
         target: {
           kind: 'definition',
@@ -238,7 +213,6 @@ test('canonical Bundle views reject static schema and route-only identities', ()
       },
       sourceOnly: {
         name: 'sourceOnly',
-        auth: 'optional',
         description: 'Admitted source-only view.',
         target: { kind: 'domain' },
       },
@@ -247,18 +221,17 @@ test('canonical Bundle views reject static schema and route-only identities', ()
     {
       slug: 'account',
       kind: 'spa',
-      auth: 'required',
       description: 'Admitted account view.',
       viewFor: 'Account',
       url: 'https://shell.example.dev/account',
-      file: 'implementation.ts',
+      file: 'application.ts',
     },
     {
       slug: 'sourceOnly',
-      kind: 'unknown',
-      auth: 'optional',
+      kind: 'spa',
       description: 'Admitted source-only view.',
-      file: 'schema/index.ts',
+      url: 'https://shell.example.dev/source-only',
+      file: 'application.ts',
     },
   ])
   expect(buildViews(root, 'schema', {})).toEqual([])

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

@@ -6,28 +6,36 @@ import { join } from 'node:path'
 import { buildAnatomy } from './anatomy'
 
 const roots: string[] = []
-
 afterEach(() => {
   for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true })
 })
 
-function project(entry: 'implementation.ts' | 'domain.ts') {
-  const root = mkdtempSync(join(tmpdir(), 'studio-anatomy-entry-'))
+function project(nested: boolean) {
+  const root = mkdtempSync(join(tmpdir(), 'studio-anatomy-application-'))
   roots.push(root)
-  mkdirSync(join(root, 'schema'), { recursive: true })
+  const owner = nested ? join(root, 'domain') : root
+  mkdirSync(join(owner, 'schema'), { recursive: true })
   writeFileSync(join(root, 'package.json'), '{}\n')
-  writeFileSync(join(root, 'astrale.config.ts'), 'export default {}\n')
-  writeFileSync(join(root, entry), 'export const domain = {}\n')
-  writeFileSync(join(root, 'schema/index.ts'), "defineSchema('example.astrale.ai', {})\n")
-  return root
+  writeFileSync(
+    join(root, 'astrale.config.ts'),
+    nested
+      ? "import application from './domain/application.js'\nexport default { application }\n"
+      : 'export default {}\n',
+  )
+  writeFileSync(join(owner, 'application.ts'), 'export const application = {}\n')
+  writeFileSync(
+    join(owner, 'schema/index.ts'),
+    "defineSchema('example.astrale.ai', { classes: {} })\n",
+  )
+  return { root, schemaDirName: nested ? 'domain/schema' : 'schema' }
 }
 
-test('overview anchors current projects to implementation.ts', () => {
-  const anatomy = buildAnatomy({ root: project('implementation.ts'), schemaDirName: 'schema' })
-  expect(anatomy.overview.compositionFile).toBe('implementation.ts')
+test('overview anchors a root Application', () => {
+  const input = project(false)
+  expect(buildAnatomy(input).overview.applicationFile).toBe('application.ts')
 })
 
-test('overview preserves domain.ts as the legacy composition entry', () => {
-  const anatomy = buildAnatomy({ root: project('domain.ts'), schemaDirName: 'schema' })
-  expect(anatomy.overview.compositionFile).toBe('domain.ts')
+test('overview preserves the config-imported nested Application path', () => {
+  const input = project(true)
+  expect(buildAnatomy(input).overview.applicationFile).toBe('domain/application.ts')
 })

package/studio/server/introspect/anatomy.ts

@@ -12,6 +12,7 @@ import { join, relative } from 'node:path'
 
 import type { DomainAnatomy, DomainOverview, SchemaIR } from '../../shared/types'
 
+import { resolveApplicationEntry } from '../domain'
 import { asJsonRecord, asString, parseJson } from '../json'
 import { readSettings } from '../state/settings'
 import { buildClientTree, buildEnvFields, buildViews, findSchemaDefinition } from './anatomy-extras'
@@ -59,15 +60,11 @@ function buildOverview(
 
   const config = readConfigPreview(root)
 
-  const compositionFile = existsSync(join(root, 'implementation.ts'))
-    ? 'implementation.ts'
-    : existsSync(join(root, 'domain.ts'))
-      ? 'domain.ts'
-      : undefined
-  const domainSrc = compositionFile ? readTextSafe(join(root, compositionFile)) : ''
+  const application = resolveApplicationEntry(root)
+  const applicationSrc = application === null ? '' : readTextSafe(application)
   const origin =
     schemaOrigin ??
-    domainSrc.match(/defineSchema\(\s*['"]([^'"]+)['"]/)?.[1] ??
+    applicationSrc.match(/defineSchema\(\s*['"]([^'"]+)['"]/)?.[1] ??
     readTextSafe(join(root, schemaDirName, 'index.ts')).match(
       /defineSchema\(\s*['"]([^'"]+)['"]/,
     )?.[1] ??
@@ -75,11 +72,11 @@ function buildOverview(
 
   return {
     origin,
-    compositionFile,
+    applicationFile:
+      application === null ? undefined : relative(root, application).replaceAll('\\', '/'),
     adapter: config.adapter,
     prodTarget: config.prodTarget,
     devSecrets: config.devSecrets,
-    postInstall: undefined,
     requires: [],
     packageName: pkg?.name,
     packageVersion: pkg?.version,

package/studio/server/introspect/bundle.ts

@@ -18,7 +18,6 @@ export async function buildBundle(handle: DomainHandle): Promise<StudioSchemaBun
   let schemaRoot: unknown | undefined
   let schemaMode: StudioSchemaBundle['schemaMode'] = 'unavailable'
   let schemaRevision: StudioSchemaBundle['schemaRevision']
-  let importedInterfaces: StudioSchemaBundle['importedInterfaces']
   let error: StudioSchemaBundle['error'] = null
   let extractedBy: StudioSchemaBundle['extractedBy'] = 'runtime-bun'
 
@@ -33,7 +32,6 @@ export async function buildBundle(handle: DomainHandle): Promise<StudioSchemaBun
       if (r.root !== null) schemaRoot = r.root
       schemaMode = r.schemaMode
       if (r.revision !== null) schemaRevision = r.revision
-      importedInterfaces = r.importedInterfaces
     } else {
       error = { message: r.error?.message ?? 'schema failed to compile' }
       extractedBy = 'static-tsmorph-fallback'
@@ -65,7 +63,6 @@ export async function buildBundle(handle: DomainHandle): Promise<StudioSchemaBun
     ir,
     ...(schemaRoot === undefined ? {} : { schemaRoot }),
     overlay,
-    importedInterfaces,
     error,
     extractedAt: new Date().toISOString(),
   }