@astrale-os/cli 0.8.1-alpha.7 → 1.0.0-beta.0

package/studio/server/introspect/core-extractor.ts

@@ -1,11 +1,12 @@
 /**
  * core-extractor.ts — the Bun-executed island for a domain's CORE (genesis) data.
  * Spawned as a short-lived subprocess by runtime.ts (cwd = domain dir, so the
- * domain's own node_modules resolve @astrale-os/*). It imports the domain's
- * worker-safe `domain.ts`, finds the `defineCore(schema, { nodes, edges })`
- * output wired in as `domain.core`, and prints its resolved nodes/edges as JSON.
+ * domain's own node_modules resolve @astrale-os/*). It imports the pure schema
+ * entry and reads canonical V1 `schema.core` directly. Importing the composition
+ * entry and discovering legacy `defineCore(...)` output is retained only as a
+ * fallback.
  *
- *   bun core-extractor.ts <domainFile> <domainDir>
+ *   bun core-extractor.ts <schemaIndexPath> <domainFile> <domainDir>
  *
  * Contract mirrors extractor.ts exactly: NEVER crash. A thrown error prints
  * { ok:false } and exits 0 — the driver treats it as a render state. A domain
@@ -24,11 +25,13 @@
 export {} // module marker — see header note
 import { isAbsolute, resolve } from 'node:path'
 
-const domainDir = process.argv[3] ?? process.cwd()
-// the driver passes an absolute path; resolve a relative one against the domain dir
-// (a bare relative path would otherwise resolve against THIS script's location).
-const rawFile = process.argv[2]
-const domainFile = rawFile && !isAbsolute(rawFile) ? resolve(domainDir, rawFile) : rawFile
+import { findCanonicalDomainSchemaExport, projectCanonicalCore } from './canonical-schema'
+
+const domainDir = process.argv[4] ?? process.cwd()
+const resolveInput = (file: string | undefined): string | undefined =>
+  file && !isAbsolute(file) ? resolve(domainDir, file) : file
+const schemaFile = resolveInput(process.argv[2])
+const domainFile = resolveInput(process.argv[3])
 
 type AnyRec = Record<string, any>
 
@@ -72,7 +75,24 @@ function classNameMap(schema: AnyRec): Map<any, string> {
 }
 
 async function main() {
-  if (!domainFile) throw new Error('core-extractor: missing <domainFile>')
+  if (!schemaFile) throw new Error('core-extractor: missing <schemaIndexPath>')
+
+  // Current SDK roots embed genesis data in the canonical, portable schema.
+  // Do not import implementation.ts/domain.ts when that source of truth exists.
+  try {
+    const schemaModule: AnyRec = await import(schemaFile)
+    const canonical = findCanonicalDomainSchemaExport(schemaModule)
+    if (canonical) {
+      const core = projectCanonicalCore(canonical)
+      const empty = core.nodes.length === 0 && core.edges.length === 0
+      process.stdout.write(JSON.stringify({ ok: true, core: empty ? null : core }))
+      return
+    }
+  } catch {
+    // A legacy composition entry may still expose a valid defineCore result.
+  }
+
+  if (!domainFile) throw new Error('core-extractor: missing <domainFile> legacy fallback')
   const mod: AnyRec = await import(domainFile)
   const core = findCore(mod)
   if (!core) {

package/studio/server/introspect/core.ts

@@ -1,7 +1,8 @@
 /**
  * core.ts — assembles a domain's StudioCore: the genesis node/edge graph
- * extracted from `defineCore`, gated on installed deps. Never throws; a failed
- * import or a domain with no core both become a well-formed (empty) render state.
+ * extracted from canonical `schema.core` (or legacy `defineCore` fallback), gated
+ * on installed deps. Never throws; a failed import or a domain with no core both
+ * become a well-formed (empty) render state.
  */
 import type { StudioCore } from '../../shared/types'
 
@@ -26,6 +27,7 @@ export async function buildCore(handle: DomainHandle): Promise<StudioCore> {
   }
 
   const r = await coreExtract(
+    handle.schemaIndex,
     handle.domainFile,
     handle.root,
     readSettings(handle.root).introspectTimeoutMs,

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

@@ -0,0 +1,124 @@
+import { describe, expect, test } from 'bun:test'
+
+import type { IrClass, IrFunction, SchemaIR } from '../../shared/types'
+
+import { classify, diffSchemas } from './diff'
+
+const callable = (returnsType = 'string'): IrFunction => ({
+  name: 'inspect',
+  input: { type: 'object', properties: {}, additionalProperties: false },
+  params: {},
+  output: { mode: 'value', schema: { type: returnsType } },
+  returns: { type: returnsType },
+  static: true,
+  inheritance: 'default',
+  auth: 'authenticated',
+})
+
+const schema = (functions: SchemaIR['functions']): SchemaIR => ({
+  version: 'v1',
+  domain: 'example.test',
+  types: {},
+  interfaces: {},
+  classes: {},
+  imports: {},
+  functions,
+})
+
+const withClass = (member: IrClass): SchemaIR => ({
+  ...schema({}),
+  classes: { [member.name]: member },
+})
+
+describe('canonical standalone Function diffs', () => {
+  test('classifies addition as additive and removal as breaking', () => {
+    const empty = schema({})
+    const populated = schema({ inspect: callable() })
+    expect(diffSchemas(empty, populated)).toEqual([
+      { kind: 'function-added', target: 'inspect', breaking: false },
+    ])
+    const removed = diffSchemas(populated, empty)
+    expect(removed).toEqual([{ kind: 'function-removed', target: 'inspect', breaking: true }])
+    expect(classify(removed)).toBe('breaking')
+  })
+
+  test('detects a standalone Function signature change', () => {
+    expect(
+      diffSchemas(schema({ inspect: callable() }), schema({ inspect: callable('number') })),
+    ).toEqual([{ kind: 'function-signature-changed', target: 'inspect', breaking: true }])
+  })
+
+  test('detects auth and output-mode changes in callable contracts', () => {
+    const before = callable()
+    const after: IrFunction = {
+      ...before,
+      auth: 'authorized',
+      output: { mode: 'stream', item: { type: 'string' } },
+    }
+
+    expect(diffSchemas(schema({ inspect: before }), schema({ inspect: after }))).toEqual([
+      { kind: 'function-signature-changed', target: 'inspect', breaking: true },
+    ])
+  })
+
+  test('uses canonical required membership and compares complete value schemas', () => {
+    const member = (required: string[], minLength: number): IrClass => ({
+      type: 'node',
+      name: 'Person',
+      properties: { name: { type: 'string', minLength } },
+      required,
+      methods: {},
+    })
+
+    expect(diffSchemas(withClass(member([], 1)), withClass(member(['name'], 2)))).toEqual([
+      {
+        kind: 'prop-schema-changed',
+        target: 'Person.name',
+        detail: 'value constraints changed',
+        breaking: true,
+      },
+      {
+        kind: 'prop-required-changed',
+        target: 'Person.name',
+        detail: 'optional → required',
+        breaking: true,
+      },
+    ])
+  })
+
+  test('tracks canonical views, policies, dependencies, topology, and Core', () => {
+    const before: SchemaIR = {
+      ...withClass({
+        type: 'edge',
+        name: 'owns',
+        properties: {},
+        required: [],
+        methods: {},
+        orientation: 'directed',
+        endpoints: [],
+      }),
+      views: { home: { name: 'home', target: { kind: 'domain' }, auth: 'public' } },
+      policies: { canRead: { anyOf: [] } },
+      dependencies: [{ origin: 'kernel.astrale.ai', revision: 'sha256:one' }],
+      core: { nodes: {}, edges: [] },
+    }
+    const after: SchemaIR = {
+      ...before,
+      classes: {
+        owns: { ...before.classes.owns, orientation: 'undirected' },
+      },
+      views: { home: { ...before.views!.home, auth: 'required' } },
+      policies: { canRead: { anyOf: [{ name: 'owner' }] } },
+      dependencies: [{ origin: 'kernel.astrale.ai', revision: 'sha256:two' }],
+      core: { nodes: { root: {} }, edges: [] },
+    }
+
+    expect(diffSchemas(before, after).map((change) => change.kind)).toEqual([
+      'edge-contract-changed',
+      'view-changed',
+      'policy-changed',
+      'dependency-changed',
+      'core-changed',
+    ])
+  })
+})

package/studio/server/introspect/diff.ts

@@ -2,12 +2,15 @@
  * diff.ts — structural diff of two Schema IRs + breaking/additive classification.
  * Shared by change tracking (baseline) and data versioning. Pure.
  *
- * Optionality is encoded in JSON Schema as a `type` array containing 'null'.
- * BREAKING: any removal/rename, prop type change, optional→required, method
- * signature change. ADDITIVE: only additions, or required→optional.
+ * Canonical V1 keeps optionality in the owning `required` arrays and nullability
+ * in each value schema. Legacy nullable projections remain supported. Contract
+ * changes are classified conservatively: removals, tightened value schemas,
+ * callable/auth/policy changes, topology changes, dependency revisions and Core
+ * changes are breaking; pure additions and descriptions are additive.
  */
 import type {
   IrClass,
+  IrFunction,
   IrInterface,
   IrMethod,
   JsonSchema,
@@ -31,23 +34,171 @@ export function baseType(s: JsonSchema | undefined): string {
   return s.enum ? `enum(${s.enum.join(',')})` : 'unknown'
 }
 
-function methodSig(m: IrMethod): string {
-  const params = Object.entries(m.params ?? {})
-    .map(([k, v]) => `${k}:${baseType(v)}${isOptional(v) ? '?' : ''}`)
-    .sort()
-    .join(',')
-  return `static=${m.static};in=${params};out=${baseType(m.returns)};inh=${m.inheritance}`
+function requiredParams(m: IrMethod | IrFunction): string[] {
+  return (
+    m.requiredParams ??
+    Object.entries(m.params ?? {}).flatMap(([name, schema]) => (isOptional(schema) ? [] : [name]))
+  )
+}
+
+function callableContract(m: IrMethod | IrFunction): unknown {
+  const required = requiredParams(m)
+  return {
+    input:
+      m.input ??
+      ({
+        type: 'object',
+        properties: m.params ?? {},
+        required,
+        additionalProperties: false,
+      } satisfies JsonSchema),
+    required,
+    output: m.output ?? { mode: 'value', schema: m.returns },
+    static: m.static,
+    inheritance: m.inheritance,
+    auth: m.auth,
+    policy: m.policy,
+  }
 }
 
 export function diffSchemas(prev: SchemaIR | null, next: SchemaIR | null): SchemaChange[] {
   const changes: SchemaChange[] = []
   if (!prev || !next) return changes
 
+  if (
+    !same(
+      { format: prev.format, version: prev.version, domain: prev.domain },
+      {
+        format: next.format,
+        version: next.version,
+        domain: next.domain,
+      },
+    )
+  ) {
+    changes.push({ kind: 'schema-metadata-changed', target: next.domain, breaking: true })
+  }
+
+  diffValueRecord(prev.types ?? {}, next.types ?? {}, 'type', changes)
+  diffValueRecord(
+    prev.importsByKey ?? prev.imports ?? {},
+    next.importsByKey ?? next.imports ?? {},
+    'import',
+    changes,
+  )
   diffMembers(prev.interfaces ?? {}, next.interfaces ?? {}, 'interface', changes)
   diffMembers(prev.classes ?? {}, next.classes ?? {}, 'class', changes)
+  diffFunctions(prev.functions ?? {}, next.functions ?? {}, changes)
+  diffViews(prev.views ?? {}, next.views ?? {}, changes)
+  diffValueRecord(prev.policies ?? {}, next.policies ?? {}, 'policy', changes)
+  diffDependencies(prev.dependencies ?? [], next.dependencies ?? [], changes)
+  if (!same(prev.core, next.core) && (prev.core !== undefined || next.core !== undefined)) {
+    changes.push({ kind: 'core-changed', target: next.domain, breaking: prev.core !== undefined })
+  }
   return changes
 }
 
+function diffValueRecord(
+  prev: Record<string, unknown>,
+  next: Record<string, unknown>,
+  scope: 'type' | 'import' | 'policy',
+  out: SchemaChange[],
+): void {
+  for (const name of sortedKeys(next)) {
+    if (!(name in prev)) {
+      out.push({ kind: `${scope}-added`, target: name, breaking: false })
+    }
+  }
+  for (const name of sortedKeys(prev)) {
+    if (!(name in next)) {
+      out.push({ kind: `${scope}-removed`, target: name, breaking: true })
+    } else if (!same(prev[name], next[name])) {
+      out.push({ kind: `${scope}-changed`, target: name, breaking: true })
+    }
+  }
+}
+
+function diffFunctions(
+  prev: Record<string, IrFunction>,
+  next: Record<string, IrFunction>,
+  out: SchemaChange[],
+): void {
+  for (const name of sortedKeys(next)) {
+    if (!prev[name]) out.push({ kind: 'function-added', target: name, breaking: false })
+  }
+  for (const name of sortedKeys(prev)) {
+    if (!next[name]) {
+      out.push({ kind: 'function-removed', target: name, breaking: true })
+      continue
+    }
+    if (!same(callableContract(prev[name]), callableContract(next[name]))) {
+      out.push({ kind: 'function-signature-changed', target: name, breaking: true })
+    }
+    if (prev[name].description !== next[name].description) {
+      out.push({ kind: 'function-metadata-changed', target: name, breaking: false })
+    }
+  }
+}
+
+function diffViews(
+  prev: NonNullable<SchemaIR['views']>,
+  next: NonNullable<SchemaIR['views']>,
+  out: SchemaChange[],
+): void {
+  for (const name of sortedKeys(next)) {
+    if (!(name in prev)) out.push({ kind: 'view-added', target: name, breaking: false })
+  }
+  for (const name of sortedKeys(prev)) {
+    if (!(name in next)) {
+      out.push({ kind: 'view-removed', target: name, breaking: true })
+      continue
+    }
+    if (
+      !same(
+        { target: prev[name].target, auth: prev[name].auth },
+        {
+          target: next[name].target,
+          auth: next[name].auth,
+        },
+      )
+    ) {
+      out.push({ kind: 'view-changed', target: name, breaking: true })
+    }
+    if (prev[name].description !== next[name].description) {
+      out.push({ kind: 'view-metadata-changed', target: name, breaking: false })
+    }
+  }
+}
+
+function diffDependencies(
+  prev: NonNullable<SchemaIR['dependencies']>,
+  next: NonNullable<SchemaIR['dependencies']>,
+  out: SchemaChange[],
+): void {
+  const before = Object.fromEntries(
+    prev.map((dependency) => [dependency.origin, dependency.revision]),
+  )
+  const after = Object.fromEntries(
+    next.map((dependency) => [dependency.origin, dependency.revision]),
+  )
+  for (const origin of sortedKeys(after)) {
+    if (!(origin in before)) {
+      out.push({ kind: 'dependency-added', target: origin, breaking: true })
+    }
+  }
+  for (const origin of sortedKeys(before)) {
+    if (!(origin in after)) {
+      out.push({ kind: 'dependency-removed', target: origin, breaking: true })
+    } else if (before[origin] !== after[origin]) {
+      out.push({
+        kind: 'dependency-changed',
+        target: origin,
+        detail: `${before[origin]} → ${after[origin]}`,
+        breaking: true,
+      })
+    }
+  }
+}
+
 function memberKind(m: IrClass | IrInterface): 'class' | 'edge' | 'interface' {
   if ((m as IrInterface).type === 'interface') return 'interface'
   return (m as IrClass).type === 'edge' ? 'edge' : 'class'
@@ -59,13 +210,13 @@ function diffMembers(
   _scope: 'class' | 'interface',
   out: SchemaChange[],
 ): void {
-  for (const name of Object.keys(next)) {
+  for (const name of sortedKeys(next)) {
     if (!prev[name]) {
       const k = memberKind(next[name])
       out.push({ kind: `${k}-added` as SchemaChange['kind'], target: name, breaking: false })
     }
   }
-  for (const name of Object.keys(prev)) {
+  for (const name of sortedKeys(prev)) {
     if (!next[name]) {
       const k = memberKind(prev[name])
       out.push({ kind: `${k}-removed` as SchemaChange['kind'], target: name, breaking: true })
@@ -83,24 +234,35 @@ function diffMemberBody(
 ): void {
   const pa = a.properties ?? {}
   const pb = b.properties ?? {}
-  for (const p of Object.keys(pb)) {
-    if (!pa[p]) out.push({ kind: 'prop-added', target: `${name}.${p}`, breaking: false })
+  for (const p of sortedKeys(pb)) {
+    if (!pa[p]) {
+      const required = propertyRequired(b, p)
+      out.push({
+        kind: 'prop-added',
+        target: `${name}.${p}`,
+        detail: required ? 'required' : 'optional',
+        breaking: required,
+      })
+    }
   }
-  for (const p of Object.keys(pa)) {
+  for (const p of sortedKeys(pa)) {
     if (!pb[p]) {
       out.push({ kind: 'prop-removed', target: `${name}.${p}`, breaking: true })
       continue
     }
-    if (baseType(pa[p]) !== baseType(pb[p])) {
+    if (!same(pa[p], pb[p])) {
+      const baseChanged = baseType(pa[p]) !== baseType(pb[p])
       out.push({
-        kind: 'prop-type-changed',
+        kind: baseChanged ? 'prop-type-changed' : 'prop-schema-changed',
         target: `${name}.${p}`,
-        detail: `${baseType(pa[p])} → ${baseType(pb[p])}`,
+        detail: baseChanged
+          ? `${baseType(pa[p])} → ${baseType(pb[p])}`
+          : 'value constraints changed',
         breaking: true,
       })
     }
-    const wasOpt = isOptional(pa[p])
-    const nowOpt = isOptional(pb[p])
+    const wasOpt = !propertyRequired(a, p)
+    const nowOpt = !propertyRequired(b, p)
     if (wasOpt !== nowOpt) {
       out.push({
         kind: 'prop-required-changed',
@@ -113,20 +275,87 @@ function diffMemberBody(
 
   const ma = a.methods ?? {}
   const mb = b.methods ?? {}
-  for (const m of Object.keys(mb)) {
-    if (!ma[m]) out.push({ kind: 'method-added', target: `${name}.${m}`, breaking: false })
+  for (const m of sortedKeys(mb)) {
+    if (!ma[m]) {
+      out.push({
+        kind: 'method-added',
+        target: `${name}.${m}`,
+        breaking: b.type === 'interface' && mb[m].inheritance === 'abstract',
+      })
+    }
   }
-  for (const m of Object.keys(ma)) {
+  for (const m of sortedKeys(ma)) {
     if (!mb[m]) {
       out.push({ kind: 'method-removed', target: `${name}.${m}`, breaking: true })
       continue
     }
-    if (methodSig(ma[m]) !== methodSig(mb[m])) {
+    if (!same(callableContract(ma[m]), callableContract(mb[m]))) {
       out.push({ kind: 'method-signature-changed', target: `${name}.${m}`, breaking: true })
     }
+    if (ma[m].description !== mb[m].description) {
+      out.push({ kind: 'method-metadata-changed', target: `${name}.${m}`, breaking: false })
+    }
+  }
+
+  const kind = memberKind(b)
+  if (!same(memberContract(a), memberContract(b))) {
+    out.push({
+      kind: `${kind}-contract-changed`,
+      target: name,
+      breaking: true,
+    })
+  }
+  if (!same(memberMetadata(a), memberMetadata(b))) {
+    out.push({ kind: 'definition-metadata-changed', target: name, breaking: false })
+  }
+}
+
+function propertyRequired(member: IrClass | IrInterface, name: string): boolean {
+  return member.required ? member.required.includes(name) : !isOptional(member.properties?.[name])
+}
+
+function memberContract(member: IrClass | IrInterface): unknown {
+  const cls = member as IrClass
+  const iface = member as IrInterface
+  return {
+    type: member.type,
+    origin: member.origin,
+    ref: member.ref,
+    family: iface.family,
+    extends: iface.extendsRefs ?? iface.extends,
+    implements: cls.implementsRefs ?? cls.implements,
+    endpoints: member.endpoints,
+    orientation: member.orientation,
+    constraints: member.constraints,
+    propertyMetadata: member.propertyMetadata,
+    data: member.data,
+    policies: cls.policies,
   }
 }
 
+function memberMetadata(member: IrClass | IrInterface): unknown {
+  return { description: member.description, icon: (member as IrClass).icon }
+}
+
+function sortedKeys(value: Record<string, unknown>): string[] {
+  return Object.keys(value).sort((left, right) => left.localeCompare(right))
+}
+
+function same(left: unknown, right: unknown): boolean {
+  return JSON.stringify(canonical(left)) === JSON.stringify(canonical(right))
+}
+
+function canonical(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(canonical)
+  if (value === null || typeof value !== 'object') return value
+  return Object.fromEntries(
+    Object.entries(value as Record<string, unknown>)
+      .filter(([, item]) => item !== undefined)
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([key, item]) => [key, canonical(item)]),
+  )
+}
+
 export function classify(changes: SchemaChange[]): 'none' | 'additive' | 'breaking' {
   if (changes.length === 0) return 'none'
   return changes.some((c) => c.breaking) ? 'breaking' : 'additive'

package/studio/server/introspect/extractor.ts

@@ -1,15 +1,22 @@
 /**
  * extractor.ts — the Bun-executed island. Spawned as a short-lived subprocess by
  * runtime.ts. It imports ONLY the domain's pure `schema/index.ts` module graph
- * (never astrale.config.ts or domain.ts → deps → integrations), reads the
- * compiled `D.$.ir`, and prints the SchemaIR as JSON to stdout.
+ * (never astrale.config.ts or the composition entry → integrations). Canonical
+ * DomainSchema V1 roots are projected directly; legacy `D.$.ir` / serialize
+ * domains retain their existing fallback.
  *
  *   bun extractor.ts <schemaIndexPath> <domainDir>
  *
- * `compileDomain`/`serialize` are PURE (no IO, no env), so importing the schema
- * is side-effect-free. A thrown error prints { ok:false } and exits 0 — the
- * driver treats it as a render state, never a crash.
+ * A thrown error prints { ok:false } and exits 0 — the driver treats it as a
+ * render state, never a crash.
  */
+import {
+  closureFromSdk,
+  findCanonicalDomainSchemaExport,
+  normalizeLegacySchemaIR,
+  projectCanonicalSchema,
+} from './canonical-schema'
+
 const schemaPath = process.argv[2]
 const domainDir = process.argv[3] ?? process.cwd()
 
@@ -17,18 +24,36 @@ async function main() {
   if (!schemaPath) throw new Error('extractor: missing <schemaIndexPath>')
   const mod: Record<string, any> = await import(schemaPath)
 
-  // Lazily resolve the domain's own kernel-dsl serializer (used by the fallback
-  // path AND to recover imported-interface bodies). Cached after first load.
-  let dsl: Record<string, any> | null = null
-  const loadDsl = async (): Promise<Record<string, any>> => {
-    if (dsl) return dsl
+  // Resolve through the DOMAIN's dependency graph. This prevents Studio's own
+  // SDK version from accepting or resolving a root authored by another cohort.
+  let sdk: Record<string, any> | null = null
+  const loadSdkSchema = async (): Promise<Record<string, any>> => {
+    if (sdk) return sdk
     const loaded: Record<string, any> = await import(
       Bun.resolveSync('@astrale-os/sdk/schema', domainDir)
     )
-    dsl = loaded
+    sdk = loaded
     return loaded
   }
 
+  const canonicalRoot = findCanonicalDomainSchemaExport(mod)
+  if (canonicalRoot) {
+    const domainSdk = await loadSdkSchema()
+    const projected = projectCanonicalSchema(
+      canonicalRoot,
+      closureFromSdk(domainSdk, canonicalRoot),
+    )
+    process.stdout.write(
+      JSON.stringify({
+        ok: true,
+        ir: projected.ir,
+        root: canonicalRoot,
+        importedInterfaces: projected.importedInterfaces,
+      }),
+    )
+    return
+  }
+
   // Prefer the conventional `D` (compiled), but accept a compiled domain exported
   // under ANY name — e.g. ai-gateway exports its `compileDomain(...)` result as
   // `Gateway`, not `D`. A compiled domain is recognized by shape (`.$.ir`).
@@ -56,7 +81,7 @@ async function main() {
         'schema entry exports no compiled domain (a `compileDomain(...)` value with `.$.ir`, e.g. `D`) nor a raw `schema`',
       )
     }
-    const d = await loadDsl()
+    const d = await loadSdkSchema()
     if (typeof d.serialize !== 'function') throw new Error('kernel-dsl.serialize unavailable')
     ir = d.serialize(schema)
   }
@@ -70,7 +95,7 @@ async function main() {
   const importSchemas: any[] = Array.isArray(mod?.schema?.imports) ? mod.schema.imports : []
   if (importSchemas.length > 0) {
     try {
-      const d = await loadDsl()
+      const d = await loadSdkSchema()
       if (typeof d.serialize === 'function') {
         for (const imp of importSchemas) {
           try {
@@ -88,7 +113,14 @@ async function main() {
     }
   }
 
-  process.stdout.write(JSON.stringify({ ok: true, ir, importedInterfaces }))
+  process.stdout.write(
+    JSON.stringify({
+      ok: true,
+      ir: normalizeLegacySchemaIR(ir),
+      root: null,
+      importedInterfaces,
+    }),
+  )
 }
 
 main().catch((err: any) => {