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

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

@@ -6,12 +6,12 @@ import { join } from 'node:path'
 import type { DomainHandle } from '../domain'
 
 import { buildBundle } from './bundle'
+import { buildCore } from './core'
 import { renderFingerprintOf } from './hash'
 import { admittedBundleRevision } from './revision'
-import { coreExtract, runtimeExtract } from './runtime'
+import { runtimeExtract } from './runtime'
 
 const roots: string[] = []
-
 afterEach(() => {
   while (roots.length > 0) rmSync(roots.pop()!, { recursive: true, force: true })
 })
@@ -22,254 +22,136 @@ function fixtureRoot(label: string): string {
   mkdirSync(join(root, 'schema'), { recursive: true })
   writeFileSync(join(root, 'package.json'), '{"type":"module"}\n')
   writeFileSync(join(root, 'astrale.config.ts'), 'export default {}\n')
-  return root
-}
-
-function linkCurrentSdk(root: string): void {
   const sdk = realpathSync(join(import.meta.dir, '../../../node_modules/@astrale-os/sdk'))
   const scope = join(root, 'node_modules', '@astrale-os')
   mkdirSync(scope, { recursive: true })
   symlinkSync(sdk, join(scope, 'sdk'), 'dir')
+  return root
 }
 
 function currentFixture(): DomainHandle {
   const root = fixtureRoot('canonical-runtime')
-  linkCurrentSdk(root)
-  const schemaIndex = join(root, 'schema', 'index.ts')
-  const domainFile = join(root, 'implementation.ts')
+  const schemaIndex = join(root, 'schema/index.ts')
+  const applicationFile = join(root, 'application.ts')
   writeFileSync(
     schemaIndex,
     `
-import {
-  bundle, defineSchema, domain, edge, edgeClass, fn, node, nodeClass,
-  nodeInterface, output, property, view,
-} from '@astrale-os/sdk/schema'
-
-const Named = nodeInterface()
-export const Directory = defineSchema('directory.runtime.test', {
-  interfaces: { Named },
-})
-
-const rename = fn({
-  input: {
-    type: 'object', properties: { title: { type: 'string' } },
-    required: ['title'], additionalProperties: false,
-  },
-  output: { type: 'boolean' },
-  auth: 'authenticated',
-})
-const Document = nodeClass({
-  implements: [Named],
-  properties: { title: property({ type: 'string' }, { required: true }) },
-  methods: { rename },
-})
-const owned_by = edgeClass.directed({
-  source: { as: 'document', accepts: [Document], outgoing: '0..*' },
-  target: { as: 'owner', accepts: [Document], incoming: '0..*' },
-})
-const welcome = node(Document, { title: 'Welcome' })
-
-export const schema = defineSchema('documents.runtime.test', {
-  dependencies: [Directory],
-  classes: { Document, owned_by },
-  functions: {
-    exportAll: fn({
-      input: { type: 'object', properties: {}, required: [], additionalProperties: false },
-      output: output.binary(),
-      auth: 'authenticated',
-    }),
-  },
-  views: { editor: view({ target: Document, auth: 'optional' }) },
-  core: {
-    nodes: { welcome },
-    edges: [edge(welcome, owned_by, domain(), {})],
-  },
-})
-export const installedBundle = bundle.create(schema)
-`,
+      import { bundle, core, defineSchema, nodeClass, view } from '@astrale-os/sdk/schema'
+      const Named = nodeClass({ properties: {} })
+      export const DirectorySchema = defineSchema('directory.runtime.test', {
+        classes: { Named },
+      })
+      const Document = nodeClass({ extends: [Named], properties: {} })
+      const welcome = core.node(Document, {})
+      export const schema = defineSchema('documents.runtime.test', {
+        dependencies: { directory: DirectorySchema },
+        classes: { Document },
+        views: { editor: view({ target: Document }) },
+        core: { nodes: { welcome } },
+      })
+      export const installedBundle = bundle.create(schema)
+    `,
   )
-  // Canonical core extraction must not import the effectful composition entry.
-  writeFileSync(domainFile, `throw new Error('composition entry was imported')\n`)
+  writeFileSync(applicationFile, `throw new Error('Application entry was imported')\n`)
   return {
     id: 'documents-runtime-test',
     root,
     configFile: join(root, 'astrale.config.ts'),
-    domainFile,
+    applicationFile,
     schemaDirName: 'schema',
     schemaDir: join(root, 'schema'),
     schemaIndex,
   }
 }
 
-describe('current SDK schema extractor', () => {
-  test('resolves the domain SDK, returns its raw root, and projects current members', async () => {
+describe('SDK V1 schema extractor', () => {
+  test('uses the authored SDK for admission and projects exact imported Classes', async () => {
     const handle = currentFixture()
     const result = await runtimeExtract(handle.schemaIndex, handle.root)
-
-    expect(result.ok).toBe(true)
-    expect(result.schemaMode).toBe('canonical-admitted')
-    expect(result.revision).toMatch(/^sha256:[0-9a-f]{64}$/)
-    expect(result.root).toMatchObject({
-      format: 'astrale.dsl',
-      version: 'v1',
-      origin: 'documents.runtime.test',
-    })
-    expect(result.ir).toMatchObject({
-      format: 'astrale.dsl',
-      domain: 'documents.runtime.test',
-      functions: {
-        exportAll: {
-          static: true,
-          inheritance: 'default',
-          output: { mode: 'binary' },
-        },
+    expect(result).toMatchObject({
+      ok: true,
+      schemaMode: 'canonical-admitted',
+      root: {
+        format: 'astrale.dsl',
+        version: 'v1',
+        origin: 'documents.runtime.test',
       },
-      views: {
-        editor: {
-          auth: 'optional',
-          target: { kind: 'definition' },
+      ir: {
+        domain: 'documents.runtime.test',
+        views: { editor: { target: { kind: 'definition' } } },
+        importsByKey: {
+          'directory.runtime.test:class.Named': {
+            ref: { origin: 'directory.runtime.test', kind: 'class', name: 'Named' },
+          },
         },
       },
     })
-    expect(result.importedInterfaces?.Named).toMatchObject({
-      name: 'Named',
-      origin: 'directory.runtime.test',
-    })
+    expect(result.revision).toMatch(/^sha256:[0-9a-f]{64}$/)
   })
 
-  test('transports the DSL revision and fingerprints the root only for rendering', async () => {
+  test('transports the DSL revision while keeping render identity separate', async () => {
     const handle = currentFixture()
     const extracted = await runtimeExtract(handle.schemaIndex, handle.root)
-    expect(extracted.ok).toBe(true)
-    if (extracted.revision === null) throw new Error('expected an admitted schema revision')
-
-    const bundle = await buildBundle(handle)
-    expect(bundle.schemaRoot).toEqual(extracted.root)
-    expect(bundle.schemaMode).toBe('canonical-admitted')
-    expect(bundle.schemaRevision).toBe(extracted.revision)
-    expect(bundle.renderFingerprint).toBe(renderFingerprintOf(extracted.root))
-    expect(bundle.renderFingerprint).not.toBe(renderFingerprintOf(extracted.ir))
+    if (extracted.revision === null) throw new Error('expected an admitted Schema revision')
+    const built = await buildBundle(handle)
+    expect(built.schemaRoot).toEqual(extracted.root)
+    expect(built.schemaRevision).toBe(extracted.revision)
+    expect(built.renderFingerprint).toBe(renderFingerprintOf(extracted.root))
+    expect(built.renderFingerprint).not.toBe(renderFingerprintOf(extracted.ir))
   })
 
-  test('re-admits installed Bundle JSON before comparing its DSL revision', async () => {
+  test('re-admits installed Bundle JSON before comparing its revision', async () => {
     const handle = currentFixture()
     const extracted = await runtimeExtract(handle.schemaIndex, handle.root)
-    if (extracted.revision === null) throw new Error('expected an admitted local schema revision')
+    if (extracted.revision === null) throw new Error('expected an admitted Schema revision')
     const fixture = (await import(handle.schemaIndex)) as { installedBundle: unknown }
     const installedWire = JSON.parse(JSON.stringify(fixture.installedBundle))
-
     expect(await admittedBundleRevision(handle.root, installedWire)).toBe(extracted.revision)
   })
 
-  test('renders a V1-shaped but unadmitted root only as a structural preview', async () => {
+  test('renders a V1-shaped root as preview when SDK admission fails', async () => {
     const root = fixtureRoot('canonical-preview')
-    linkCurrentSdk(root)
-    const schemaIndex = join(root, 'schema', 'index.ts')
+    const schemaIndex = join(root, 'schema/index.ts')
     writeFileSync(
       schemaIndex,
       `export const schema = {
         format: 'astrale.dsl', version: 'v1', origin: 'not an origin',
-        dependencies: [], types: {}, interfaces: {}, classes: {}, functions: {},
-        policies: {}, views: {}, core: { nodes: {}, edges: [] },
+        dependencies: {}, classes: {}, functions: {}, policies: {}, views: {},
+        core: { nodes: {}, edges: [] },
       }\n`,
     )
-
-    const result = await runtimeExtract(schemaIndex, root)
-    expect(result.ok).toBe(true)
-    expect(result.schemaMode).toBe('canonical-preview')
-    expect(result.revision).toBeNull()
-    expect(result.root).toMatchObject({ format: 'astrale.dsl', version: 'v1' })
-  })
-
-  test('extracts canonical core without importing implementation.ts', async () => {
-    const handle = currentFixture()
-    const result = await coreExtract(handle.schemaIndex, handle.domainFile, handle.root)
-
-    expect(result).toEqual({
+    expect(await runtimeExtract(schemaIndex, root)).toMatchObject({
       ok: true,
-      core: {
-        domain: 'documents.runtime.test',
-        nodes: [
-          {
-            path: '/:documents.runtime.test:core.welcome',
-            className: 'Document',
-            data: { 'documents.runtime.test:class.Document.property.title': 'Welcome' },
-          },
-        ],
-        edges: [
-          {
-            from: '/:documents.runtime.test:core.welcome',
-            to: '/:documents.runtime.test',
-            edgeName: 'owned_by',
-            data: {},
-          },
-        ],
-      },
+      schemaMode: 'canonical-preview',
+      revision: null,
     })
   })
-})
-
-test('runtime extractor preserves the legacy compiled-IR envelope', async () => {
-  const root = fixtureRoot('legacy-runtime')
-  const schemaIndex = join(root, 'schema', 'index.ts')
-  writeFileSync(
-    schemaIndex,
-    `export const D = { $: { ir: {
-      version: 'legacy', domain: 'legacy.runtime.test', types: {}, interfaces: {},
-      classes: {}, imports: {}, functions: {},
-    } } }\n`,
-  )
-
-  const result = await runtimeExtract(schemaIndex, root)
-  expect(result).toMatchObject({
-    ok: true,
-    schemaMode: 'legacy',
-    revision: null,
-    root: null,
-    ir: { domain: 'legacy.runtime.test', functions: {} },
-  })
-})
 
-test('core extractor preserves the legacy defineCore fallback', async () => {
-  const root = fixtureRoot('legacy-core')
-  const schemaIndex = join(root, 'schema', 'index.ts')
-  const domainFile = join(root, 'domain.ts')
-  writeFileSync(schemaIndex, `export const schema = { domain: 'legacy.runtime.test' }\n`)
-  writeFileSync(
-    domainFile,
-    `
-const Item = { config: { name: 'Item' } }
-const linked = { config: { name: 'linked' } }
-const schema = { interfaces: {}, classes: { Item, linked }, imports: [] }
-export const core = {
-  domain: 'legacy.runtime.test', schema,
-  __nodes: [
-    { path: '/legacy/left', def: Item, data: { name: 'Left' } },
-    { path: '/legacy/right', def: Item, data: { name: 'Right' } },
-  ],
-  __edges: [
-    { from: '/legacy/left', to: '/legacy/right', edge: linked, data: { order: 1 } },
-  ],
-}
-`,
-  )
-
-  expect(await coreExtract(schemaIndex, domainFile, root)).toEqual({
-    ok: true,
-    core: {
-      domain: 'legacy.runtime.test',
+  test('extracts Core through the pure Schema entry without importing Application', async () => {
+    const handle = currentFixture()
+    const bundle = await buildBundle(handle)
+    expect(buildCore(handle, bundle)).toMatchObject({
+      domain: 'documents.runtime.test',
       nodes: [
-        { path: '/legacy/left', className: 'Item', data: { name: 'Left' } },
-        { path: '/legacy/right', className: 'Item', data: { name: 'Right' } },
-      ],
-      edges: [
         {
-          from: '/legacy/left',
-          to: '/legacy/right',
-          edgeName: 'linked',
-          data: { order: 1 },
+          path: '/:documents.runtime.test:core.welcome',
+          className: 'Document',
+          data: {},
         },
       ],
-    },
+      edges: [],
+      error: null,
+    })
+  })
+})
+
+test('rejects the removed compiled-IR compatibility envelope', async () => {
+  const root = fixtureRoot('removed-runtime')
+  const schemaIndex = join(root, 'schema/index.ts')
+  writeFileSync(schemaIndex, `export const D = { $: { ir: { domain: 'legacy' } } }\n`)
+  expect(await runtimeExtract(schemaIndex, root)).toMatchObject({
+    ok: false,
+    schemaMode: 'unavailable',
+    revision: null,
   })
 })

package/studio/server/introspect/runtime.ts

@@ -5,29 +5,20 @@
  * render IR plus the raw canonical root (when present), or an error render-state
  * — never throws.
  */
-import type {
-  IrInterface,
-  SchemaIR,
-  SchemaRevision,
-  StudioCore,
-  StudioSchemaBundle,
-} from '../../shared/types'
+import type { SchemaIR, SchemaRevision, StudioSchemaBundle } from '../../shared/types'
 
 import { isSchemaRevision } from '../../shared/types'
 
 const EXTRACTOR = new URL('./extractor.ts', import.meta.url).pathname
-const CORE_EXTRACTOR = new URL('./core-extractor.ts', import.meta.url).pathname
 
 export interface RuntimeExtractResult {
   ok: boolean
   ir: SchemaIR | null
-  /** Portable canonical V1 document. Null for legacy domains and failures. */
+  /** Portable canonical V1 document. Null only for failures. */
   root: unknown | null
   schemaMode: StudioSchemaBundle['schemaMode']
-  /** Present only when the Domain cohort SDK admitted `root`. */
+  /** Present only when the Domain's installed SDK admitted `root`. */
   revision: SchemaRevision | null
-  /** member bodies of imported (kernel + cross-domain) interfaces, by name */
-  importedInterfaces?: Record<string, IrInterface>
   error?: { message: string }
 }
 
@@ -70,16 +61,10 @@ export async function runtimeExtract(
       }
     const schemaMode = parsed.schemaMode
     const revision = parsed.revision
-    const validMode =
-      schemaMode === 'canonical-admitted' ||
-      schemaMode === 'canonical-preview' ||
-      schemaMode === 'legacy'
+    const validMode = schemaMode === 'canonical-admitted' || schemaMode === 'canonical-preview'
     const validRevision =
       schemaMode === 'canonical-admitted' ? isSchemaRevision(revision) : revision == null
-    const validRoot =
-      schemaMode === 'legacy'
-        ? parsed.root == null
-        : parsed.root !== null && parsed.root !== undefined
+    const validRoot = parsed.root !== null && parsed.root !== undefined
     if (!validMode || !validRevision || !validRoot) {
       return {
         ok: false,
@@ -96,7 +81,6 @@ export async function runtimeExtract(
       root: parsed.root ?? null,
       schemaMode,
       revision: revision ?? null,
-      importedInterfaces: (parsed.importedInterfaces ?? {}) as Record<string, IrInterface>,
     }
   } catch (e: any) {
     return {
@@ -109,49 +93,3 @@ export async function runtimeExtract(
     }
   }
 }
-
-export interface CoreExtractResult {
-  ok: boolean
-  /** the resolved core graph, or null when the domain defines no core */
-  core: Pick<StudioCore, 'domain' | 'nodes' | 'edges'> | null
-  error?: { message: string }
-}
-
-/**
- * Spawn the core-extractor island over the pure schema entry first, retaining the
- * composition entry only as the legacy `defineCore` fallback. Returns the
- * resolved core graph or an error — never throws.
- */
-export async function coreExtract(
-  schemaIndexPath: string,
-  domainFile: string,
-  domainDir: string,
-  timeoutMs = 20000,
-): Promise<CoreExtractResult> {
-  try {
-    const proc = Bun.spawn(['bun', 'run', CORE_EXTRACTOR, schemaIndexPath, domainFile, domainDir], {
-      cwd: domainDir,
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
-    const timer = setTimeout(() => proc.kill(9), timeoutMs)
-    const out = await new Response(proc.stdout).text()
-    await proc.exited
-    clearTimeout(timer)
-
-    if (!out.trim()) {
-      const err = await new Response(proc.stderr).text()
-      return {
-        ok: false,
-        core: null,
-        error: { message: err.trim() || 'core extractor produced no output' },
-      }
-    }
-    const parsed = JSON.parse(out)
-    if (!parsed.ok)
-      return { ok: false, core: null, error: parsed.error ?? { message: 'core extraction failed' } }
-    return { ok: true, core: (parsed.core ?? null) as CoreExtractResult['core'] }
-  } catch (e: any) {
-    return { ok: false, core: null, error: { message: String(e?.message ?? e) } }
-  }
-}

package/studio/server/introspect/schema-ir-json.test.ts

@@ -0,0 +1,81 @@
+import { expect, test } from 'bun:test'
+
+import { decodeSchemaIR } from './schema-ir-json'
+
+function canonicalIr() {
+  return {
+    format: 'astrale.dsl',
+    version: 'v1',
+    domain: 'example.test',
+    classes: {
+      Document: {
+        type: 'node',
+        name: 'Document',
+        origin: 'example.test',
+        ref: { origin: 'example.test', kind: 'class', name: 'Document' },
+        properties: {},
+        methods: {
+          rename: {
+            name: 'rename',
+            input: { type: 'object', properties: {} },
+            output: { mode: 'value', schema: { type: 'boolean' } },
+            static: false,
+            inheritance: 'default',
+            auth: 'authorized',
+          },
+        },
+      },
+    },
+    importsByKey: {},
+    importedClassesByKey: {},
+    functions: {
+      search: {
+        name: 'search',
+        input: { type: 'object', properties: {} },
+        output: { mode: 'stream', item: { type: 'string' } },
+        auth: 'authenticated',
+      },
+    },
+    views: {
+      documents: {
+        name: 'documents',
+        target: { kind: 'domain' },
+      },
+    },
+    policies: {},
+    dependencies: [],
+    core: {},
+  }
+}
+
+test('admits the complete canonical Studio projection', () => {
+  expect(decodeSchemaIR(canonicalIr())).toMatchObject({
+    format: 'astrale.dsl',
+    domain: 'example.test',
+  })
+})
+
+test('rejects stale projections that lost canonical callable contracts', () => {
+  const input = canonicalIr()
+  const rename = input.classes.Document.methods.rename as Record<string, unknown>
+  delete rename.input
+  delete rename.output
+  Object.assign(rename, { params: {}, returns: { type: 'boolean' } })
+  expect(decodeSchemaIR(input)).toBeUndefined()
+})
+
+test('rejects projections that retain retired View auth metadata', () => {
+  const input = canonicalIr()
+  Object.assign(input.views.documents, { auth: 'required' })
+  expect(decodeSchemaIR(input)).toBeUndefined()
+})
+
+test('rejects unversioned and incomplete projection roots', () => {
+  const withoutFormat = canonicalIr() as Record<string, unknown>
+  delete withoutFormat.format
+  expect(decodeSchemaIR(withoutFormat)).toBeUndefined()
+
+  const withoutViews = canonicalIr() as Record<string, unknown>
+  delete withoutViews.views
+  expect(decodeSchemaIR(withoutViews)).toBeUndefined()
+})