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

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

@@ -1,72 +1,44 @@
 import { expect, test } from 'bun:test'
 
-import type { SchemaIR } from '../../shared/types'
+import type { IrClassKey, SchemaIR } from '../../shared/types'
 
 import { buildOverlay } from './overlay'
 
-test('preserves homonymous and cross-kind imports from the exact index', () => {
+function descriptor(origin: string, name: string) {
+  const key = `${origin}:class.${name}` as IrClassKey
+  return { origin, ref: { origin, kind: 'class' as const, name }, key }
+}
+
+test('preserves homonymous Classes through exact import identity', () => {
+  const first = descriptor('a.example', 'Shared')
+  const second = descriptor('b.example', 'Shared')
+  const kernel = descriptor('kernel.astrale.ai', 'Identity')
   const ir = {
     version: 'v1',
+    format: 'astrale.dsl',
     domain: 'app.example',
-    types: {},
-    interfaces: {},
     classes: {},
     functions: {},
-    imports: {},
     importsByKey: {
-      'a.example:interface.Shared': {
-        origin: 'a.example',
-        definition: 'interface',
-        ref: { origin: 'a.example', kind: 'interface', name: 'Shared' },
-        key: 'a.example:interface.Shared',
-      },
-      'b.example:interface.Shared': {
-        origin: 'b.example',
-        definition: 'interface',
-        ref: { origin: 'b.example', kind: 'interface', name: 'Shared' },
-        key: 'b.example:interface.Shared',
-      },
-      'a.example:class.Shared': {
-        origin: 'a.example',
-        definition: 'class',
-        ref: { origin: 'a.example', kind: 'class', name: 'Shared' },
-        key: 'a.example:class.Shared',
-      },
-      'kernel.astrale.ai:interface.Identity': {
-        origin: 'kernel.astrale.ai',
-        definition: 'interface',
-        ref: { origin: 'kernel.astrale.ai', kind: 'interface', name: 'Identity' },
-        key: 'kernel.astrale.ai:interface.Identity',
-      },
+      [first.key]: first,
+      [second.key]: second,
+      [kernel.key]: kernel,
     },
+    importedClassesByKey: {},
+    views: {},
+    policies: {},
+    dependencies: [
+      { origin: first.origin, revision: `sha256:${'a'.repeat(64)}` },
+      { origin: second.origin, revision: `sha256:${'b'.repeat(64)}` },
+    ],
+    core: {},
   } satisfies SchemaIR
 
   const overlay = buildOverlay({ ir, domainRoot: '', schemaDir: '' })
-
   expect(overlay.crossDomainImports).toEqual([
-    { name: 'Shared', origin: 'a.example', definition: 'interface' },
-    { name: 'Shared', origin: 'b.example', definition: 'interface' },
-    { name: 'Shared', origin: 'a.example', definition: 'class' },
-  ])
-  expect(overlay.mixins).toEqual([
-    { name: 'Identity', origin: 'kernel.astrale.ai', definition: 'interface' },
-  ])
-})
-
-test('retains the legacy short-name import fallback', () => {
-  const ir = {
-    version: 'legacy',
-    domain: 'app.example',
-    types: {},
-    interfaces: {},
-    classes: {},
-    functions: {},
-    imports: {
-      Identity: { origin: 'kernel.astrale.ai', definition: 'interface' },
-    },
-  } satisfies SchemaIR
-
-  expect(buildOverlay({ ir, domainRoot: '', schemaDir: '' }).mixins).toEqual([
-    { name: 'Identity', origin: 'kernel.astrale.ai', definition: 'interface' },
+    { name: 'Shared', origin: first.origin, ref: first.ref },
+    { name: 'Shared', origin: second.origin, ref: second.ref },
   ])
+  expect(overlay.mixins).toEqual([{ name: 'Identity', origin: kernel.origin, ref: kernel.ref }])
+  expect(overlay.requires).toEqual(['a.example', 'b.example'])
 })

package/studio/server/introspect/overlay.ts

@@ -1,13 +1,9 @@
 /**
  * overlay.ts — the Studio overlay over the DSL IR. Computes what the IR cannot
- * carry. The imports split + requires/postInstall are done here (pure / light
+ * carry. The import split and dependency list are computed here; handlerLinks,
  * static parse). handlerLinks, sourceSpans (+JSDoc) and annotations are filled
- * by a ts-morph pass over the current implementation/schema files, with legacy
- * domain.ts and runtime/index.ts support retained.
+ * by a ts-morph pass over current Schema, Runtime, Action, and Workflow files.
  */
-import { existsSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
-
 import type { CrossDomainImport, SchemaIR, SchemaOverlay } from '../../shared/types'
 
 import { buildHandlerLinks, buildSchemaAnnotations, buildSourceSpans } from './overlay-tsmorph'
@@ -22,46 +18,23 @@ export function buildOverlay({ ir, domainRoot, schemaDir }: OverlayArgs): Schema
   const origin = ir?.domain ?? ''
   const mixins: CrossDomainImport[] = []
   const crossDomainImports: CrossDomainImport[] = []
-  const imports =
-    ir?.importsByKey !== undefined
-      ? Object.values(ir.importsByKey).flatMap((descriptor) =>
-          descriptor.ref ? [[descriptor.ref.name, descriptor] as const] : [],
-        )
-      : Object.entries(ir?.imports ?? {})
-  for (const [name, d] of imports) {
-    const entry: CrossDomainImport = { name, origin: d.origin, definition: d.definition }
-    if (d.origin === 'kernel.astrale.ai') mixins.push(entry)
+  for (const descriptor of Object.values(ir?.importsByKey ?? {})) {
+    const entry: CrossDomainImport = {
+      name: descriptor.ref.name,
+      origin: descriptor.origin,
+      ref: descriptor.ref,
+    }
+    if (descriptor.origin === 'kernel.astrale.ai') mixins.push(entry)
     else crossDomainImports.push(entry)
   }
 
-  const { requires, postInstall } = parseCompositionEntry(domainRoot, origin)
-
   return {
     origin,
-    requires,
+    requires: (ir?.dependencies ?? []).map(({ origin }) => origin),
     crossDomainImports,
     mixins,
-    postInstall,
     handlerLinks: buildHandlerLinks({ ir, domainRoot }),
     sourceSpans: buildSourceSpans({ ir, schemaDir }),
     annotations: buildSchemaAnnotations({ ir }),
   }
 }
-
-function parseCompositionEntry(
-  root: string,
-  origin: string,
-): { requires: string[]; postInstall?: string } {
-  const f = ['implementation.ts', 'domain.ts'].map((file) => join(root, file)).find(existsSync)
-  let requires: string[] = []
-  let postInstall: string | undefined
-  if (f) {
-    const src = readFileSync(f, 'utf8')
-    const rm = src.match(/requires\s*:\s*\[([^\]]*)\]/)
-    if (rm) requires = [...rm[1].matchAll(/['"`]([^'"`]+)['"`]/g)].map((x) => x[1])
-    const pm = src.match(/postInstall\s*:\s*[`'"]([^`'"]+)[`'"]/)
-    if (pm)
-      postInstall = pm[1].replace(/\$\{schema\.domain\}/g, origin).replace(/\$\{[^}]+\}/g, origin)
-  }
-  return { requires, postInstall }
-}

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

@@ -0,0 +1,54 @@
+import { describe, expect, test } from 'bun:test'
+
+import { admittedBundleRevisionFromSdk } from './revision'
+
+const REVISION = `sha256:${'a'.repeat(64)}` as const
+
+describe('installed Bundle revision', () => {
+  test('uses bundle admission before asking the installed schema owner for its revision', () => {
+    const calls: string[] = []
+    const root = { format: 'astrale.dsl', version: 'v1', origin: 'notes.example.dev' }
+    const input = { wire: true }
+    const sdk = {
+      bundle: {
+        accept(value: unknown) {
+          calls.push('bundle.accept')
+          expect(value).toBe(input)
+          return { root, closure: [] }
+        },
+      },
+      schema: {
+        revision(value: unknown) {
+          calls.push('schema.revision')
+          expect(value).toBe(root)
+          return REVISION
+        },
+      },
+    }
+
+    expect(admittedBundleRevisionFromSdk(sdk, input)).toBe(REVISION)
+    expect(calls).toEqual(['bundle.accept', 'schema.revision'])
+  })
+
+  test('fails closed when bundle admission or the returned revision is invalid', () => {
+    expect(
+      admittedBundleRevisionFromSdk(
+        { bundle: { accept: () => ({ root: {} }) }, schema: { revision: () => 'sha-short' } },
+        {},
+      ),
+    ).toBeNull()
+    expect(
+      admittedBundleRevisionFromSdk(
+        {
+          bundle: {
+            accept: () => {
+              throw new Error('invalid bundle')
+            },
+          },
+          schema: { revision: () => REVISION },
+        },
+        {},
+      ),
+    ).toBeNull()
+  })
+})

package/studio/server/introspect/revision.ts

@@ -0,0 +1,49 @@
+import type { SchemaRevision } from '../../shared/types'
+
+import { isSchemaRevision } from '../../shared/types'
+
+type AnyRecord = Record<string, unknown>
+
+/**
+ * Cross the installed-bundle JSON boundary through the Domain's installed SDK, then
+ * ask the DSL owner for the root revision. Invalid/unavailable bundles return
+ * null so Studio reports unknown drift instead of inventing an identity.
+ */
+export function admittedBundleRevisionFromSdk(
+  sdkModule: Record<string, unknown>,
+  input: unknown,
+): SchemaRevision | null {
+  const bundleApi = asRecord(sdkModule.bundle)
+  const schemaApi = asRecord(sdkModule.schema)
+  if (typeof bundleApi?.accept !== 'function' || typeof schemaApi?.revision !== 'function') {
+    return null
+  }
+  try {
+    const accepted = asRecord(Reflect.apply(bundleApi.accept, bundleApi, [input]))
+    if (!accepted || !Object.prototype.hasOwnProperty.call(accepted, 'root')) return null
+    const revision = Reflect.apply(schemaApi.revision, schemaApi, [accepted.root])
+    return isSchemaRevision(revision) ? revision : null
+  } catch {
+    return null
+  }
+}
+
+export async function admittedBundleRevision(
+  domainRoot: string,
+  input: unknown,
+): Promise<SchemaRevision | null> {
+  try {
+    const sdkModule: Record<string, unknown> = await import(
+      Bun.resolveSync('@astrale-os/sdk/schema', domainRoot)
+    )
+    return admittedBundleRevisionFromSdk(sdkModule, input)
+  } catch {
+    return null
+  }
+}
+
+function asRecord(value: unknown): AnyRecord | null {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? (value as AnyRecord)
+    : null
+}

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

@@ -6,11 +6,11 @@ import { join } from 'node:path'
 import type { DomainHandle } from '../domain'
 
 import { buildBundle } from './bundle'
-import { schemaHashOf } from './hash'
+import { renderFingerprintOf } from './hash'
+import { admittedBundleRevision } from './revision'
 import { coreExtract, runtimeExtract } from './runtime'
 
 const roots: string[] = []
-
 afterEach(() => {
   while (roots.length > 0) rmSync(roots.pop()!, { recursive: true, force: true })
 })
@@ -21,134 +21,114 @@ 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 {
-  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(), {})],
-  },
-})
-`,
+      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.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: { auth: 'required', 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('hashes the raw canonical root instead of the render projection', 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)
-
-    const bundle = await buildBundle(handle)
-    expect(bundle.schemaRoot).toEqual(extracted.root)
-    expect(bundle.schemaHash).toBe(schemaHashOf(extracted.root))
-    expect(bundle.schemaHash).not.toBe(schemaHashOf(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('extracts canonical core without importing implementation.ts', async () => {
+  test('re-admits installed Bundle JSON before comparing its revision', async () => {
     const handle = currentFixture()
-    const result = await coreExtract(handle.schemaIndex, handle.domainFile, handle.root)
+    const extracted = await runtimeExtract(handle.schemaIndex, handle.root)
+    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)
+  })
 
-    expect(result).toEqual({
+  test('renders a V1-shaped root as preview when SDK admission fails', async () => {
+    const root = fixtureRoot('canonical-preview')
+    const schemaIndex = join(root, 'schema/index.ts')
+    writeFileSync(
+      schemaIndex,
+      `export const schema = {
+        format: 'astrale.dsl', version: 'v1', origin: 'not an origin',
+        dependencies: {}, classes: {}, functions: {}, policies: {}, views: {},
+        core: { nodes: {}, edges: [] },
+      }\n`,
+    )
+    expect(await runtimeExtract(schemaIndex, root)).toMatchObject({
+      ok: true,
+      schemaMode: 'canonical-preview',
+      revision: null,
+    })
+  })
+
+  test('extracts Core through the pure Schema entry without importing Application', async () => {
+    const handle = currentFixture()
+    expect(await coreExtract(handle.schemaIndex, handle.root)).toEqual({
       ok: true,
       core: {
         domain: 'documents.runtime.test',
@@ -156,62 +136,22 @@ describe('current SDK schema extractor', () => {
           {
             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: {},
           },
         ],
+        edges: [],
       },
     })
   })
 })
 
-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',
-      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 },
-        },
-      ],
-    },
+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,7 +5,9 @@
  * render IR plus the raw canonical root (when present), or an error render-state
  * — never throws.
  */
-import type { IrInterface, SchemaIR, StudioCore } from '../../shared/types'
+import type { SchemaIR, SchemaRevision, StudioCore, 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
@@ -13,10 +15,11 @@ const CORE_EXTRACTOR = new URL('./core-extractor.ts', import.meta.url).pathname
 export interface RuntimeExtractResult {
   ok: boolean
   ir: SchemaIR | null
-  /** Exact canonical V1 root. Null for legacy `D.$.ir` domains and failures. */
+  /** Portable canonical V1 document. Null only for failures. */
   root: unknown | null
-  /** member bodies of imported (kernel + cross-domain) interfaces, by name */
-  importedInterfaces?: Record<string, IrInterface>
+  schemaMode: StudioSchemaBundle['schemaMode']
+  /** Present only when the Domain's installed SDK admitted `root`. */
+  revision: SchemaRevision | null
   error?: { message: string }
 }
 
@@ -42,6 +45,8 @@ export async function runtimeExtract(
         ok: false,
         ir: null,
         root: null,
+        schemaMode: 'unavailable',
+        revision: null,
         error: { message: err.trim() || 'extractor produced no output' },
       }
     }
@@ -51,16 +56,42 @@ export async function runtimeExtract(
         ok: false,
         ir: null,
         root: null,
+        schemaMode: 'unavailable',
+        revision: null,
         error: parsed.error ?? { message: 'extraction failed' },
       }
+    const schemaMode = parsed.schemaMode
+    const revision = parsed.revision
+    const validMode = schemaMode === 'canonical-admitted' || schemaMode === 'canonical-preview'
+    const validRevision =
+      schemaMode === 'canonical-admitted' ? isSchemaRevision(revision) : revision == null
+    const validRoot = parsed.root !== null && parsed.root !== undefined
+    if (!validMode || !validRevision || !validRoot) {
+      return {
+        ok: false,
+        ir: null,
+        root: null,
+        schemaMode: 'unavailable',
+        revision: null,
+        error: { message: 'extractor produced an invalid schema admission envelope' },
+      }
+    }
     return {
       ok: true,
       ir: parsed.ir as SchemaIR,
       root: parsed.root ?? null,
-      importedInterfaces: (parsed.importedInterfaces ?? {}) as Record<string, IrInterface>,
+      schemaMode,
+      revision: revision ?? null,
     }
   } catch (e: any) {
-    return { ok: false, ir: null, root: null, error: { message: String(e?.message ?? e) } }
+    return {
+      ok: false,
+      ir: null,
+      root: null,
+      schemaMode: 'unavailable',
+      revision: null,
+      error: { message: String(e?.message ?? e) },
+    }
   }
 }
 
@@ -72,18 +103,16 @@ export interface CoreExtractResult {
 }
 
 /**
- * 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.
+ * Spawn the Core extractor over the pure Schema entry. Returns the projected
+ * graph or an error and never imports Application or Runtime modules.
  */
 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], {
+    const proc = Bun.spawn(['bun', 'run', CORE_EXTRACTOR, schemaIndexPath, domainDir], {
       cwd: domainDir,
       stdout: 'pipe',
       stderr: 'pipe',