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

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

@@ -11,7 +11,6 @@ import { admittedBundleRevision } from './revision'
 import { coreExtract, runtimeExtract } from './runtime'
 
 const roots: string[] = []
-
 afterEach(() => {
   while (roots.length > 0) rmSync(roots.pop()!, { recursive: true, force: true })
 })
@@ -22,170 +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 {
-  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: { 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('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' })
+    expect(await runtimeExtract(schemaIndex, root)).toMatchObject({
+      ok: true,
+      schemaMode: 'canonical-preview',
+      revision: null,
+    })
   })
 
-  test('extracts canonical core without importing implementation.ts', async () => {
+  test('extracts Core through the pure Schema entry without importing Application', async () => {
     const handle = currentFixture()
-    const result = await coreExtract(handle.schemaIndex, handle.domainFile, handle.root)
-
-    expect(result).toEqual({
+    expect(await coreExtract(handle.schemaIndex, handle.root)).toEqual({
       ok: true,
       core: {
         domain: 'documents.runtime.test',
@@ -193,83 +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('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',
+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,
-    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',
-      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 },
-        },
-      ],
-    },
   })
 })

package/studio/server/introspect/runtime.ts

@@ -5,13 +5,7 @@
  * 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, StudioCore, StudioSchemaBundle } from '../../shared/types'
 
 import { isSchemaRevision } from '../../shared/types'
 
@@ -21,13 +15,11 @@ 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 +62,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 +82,6 @@ export async function runtimeExtract(
       root: parsed.root ?? null,
       schemaMode,
       revision: revision ?? null,
-      importedInterfaces: (parsed.importedInterfaces ?? {}) as Record<string, IrInterface>,
     }
   } catch (e: any) {
     return {
@@ -118,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',

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

@@ -0,0 +1,70 @@
+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: {},
+    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 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()
+})

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

@@ -1,8 +1,9 @@
 /** Structural admission for persisted Studio render IR. SDK admission is separate. */
 
 import type {
+  IrClass,
+  IrClassRef,
   IrFunction,
-  IrInterface,
   IrMethod,
   IrSchemaRef,
   JsonSchema,
@@ -11,10 +12,6 @@ import type {
 
 import { asJsonRecord, asStringArray } from '../json'
 
-function optional<T>(value: unknown, guard: (candidate: unknown) => candidate is T): boolean {
-  return value === undefined || guard(value)
-}
-
 function recordOf(value: unknown, guard: (candidate: unknown) => boolean): boolean {
   const record = asJsonRecord(value)
   return !!record && Object.values(record).every(guard)
@@ -29,14 +26,12 @@ function isSchemaRef(value: unknown): value is IrSchemaRef {
   return (
     typeof record?.origin === 'string' &&
     typeof record.name === 'string' &&
-    ['type', 'interface', 'class', 'function', 'policy', 'view', 'core'].includes(
-      String(record.kind),
-    )
+    ['class', 'function', 'policy', 'view', 'core'].includes(String(record.kind))
   )
 }
 
-function isSchemaRefArray(value: unknown): value is IrSchemaRef[] {
-  return Array.isArray(value) && value.every(isSchemaRef)
+function isClassRef(value: unknown): value is IrClassRef {
+  return isSchemaRef(value) && value.kind === 'class'
 }
 
 function isOutput(value: unknown): boolean {
@@ -52,20 +47,22 @@ function isMethod(value: unknown): value is IrMethod {
   const record = asJsonRecord(value)
   return (
     typeof record?.name === 'string' &&
-    recordOf(record.params, isJsonSchema) &&
-    isJsonSchema(record.returns) &&
+    isJsonSchema(record.input) &&
+    isOutput(record.output) &&
     typeof record.static === 'boolean' &&
-    ['default', 'abstract', 'sealed'].includes(String(record.inheritance)) &&
-    optional(record.input, isJsonSchema) &&
-    (record.requiredParams === undefined || asStringArray(record.requiredParams) !== undefined) &&
-    (record.output === undefined || isOutput(record.output))
+    ['default', 'abstract', 'sealed'].includes(String(record.inheritance))
   )
 }
 
 function isEndpoint(value: unknown): boolean {
   const record = asJsonRecord(value)
   if (!record || typeof record.name !== 'string' || !asStringArray(record.types)) return false
-  if (record.refs !== undefined && !isSchemaRefArray(record.refs)) return false
+  if (
+    record.refs !== undefined &&
+    (!Array.isArray(record.refs) || !record.refs.every(isSchemaRef))
+  ) {
+    return false
+  }
   if (record.cardinality !== undefined) {
     const cardinality = asJsonRecord(record.cardinality)
     if (
@@ -81,31 +78,19 @@ function isEndpoint(value: unknown): boolean {
   return true
 }
 
-function isInterface(value: unknown): value is IrInterface {
-  const record = asJsonRecord(value)
-  return (
-    record?.type === 'interface' &&
-    typeof record.name === 'string' &&
-    recordOf(record.properties, isJsonSchema) &&
-    recordOf(record.methods, isMethod) &&
-    (record.required === undefined || asStringArray(record.required) !== undefined) &&
-    (record.extends === undefined || asStringArray(record.extends) !== undefined) &&
-    (record.extendsRefs === undefined || isSchemaRefArray(record.extendsRefs)) &&
-    (record.endpoints === undefined ||
-      (Array.isArray(record.endpoints) && record.endpoints.every(isEndpoint)))
-  )
-}
-
-function isClass(value: unknown): boolean {
+function isClass(value: unknown): value is IrClass {
   const record = asJsonRecord(value)
   return (
     (record?.type === 'node' || record?.type === 'edge') &&
     typeof record.name === 'string' &&
+    typeof record.origin === 'string' &&
+    isClassRef(record.ref) &&
     recordOf(record.properties, isJsonSchema) &&
     recordOf(record.methods, isMethod) &&
     (record.required === undefined || asStringArray(record.required) !== undefined) &&
-    (record.implements === undefined || asStringArray(record.implements) !== undefined) &&
-    (record.implementsRefs === undefined || isSchemaRefArray(record.implementsRefs)) &&
+    (record.extends === undefined || asStringArray(record.extends) !== undefined) &&
+    (record.extendsRefs === undefined ||
+      (Array.isArray(record.extendsRefs) && record.extendsRefs.every(isClassRef))) &&
     (record.endpoints === undefined ||
       (Array.isArray(record.endpoints) && record.endpoints.every(isEndpoint)))
   )
@@ -113,24 +98,16 @@ function isClass(value: unknown): boolean {
 
 function isFunction(value: unknown): value is IrFunction {
   const record = asJsonRecord(value)
-  return (
-    typeof record?.name === 'string' &&
-    isJsonSchema(record.input) &&
-    recordOf(record.params, isJsonSchema) &&
-    (record.requiredParams === undefined || asStringArray(record.requiredParams) !== undefined) &&
-    isOutput(record.output) &&
-    isJsonSchema(record.returns) &&
-    record.static === true &&
-    record.inheritance === 'default'
-  )
+  return typeof record?.name === 'string' && isJsonSchema(record.input) && isOutput(record.output)
 }
 
 function isImport(value: unknown): boolean {
   const record = asJsonRecord(value)
   return (
     typeof record?.origin === 'string' &&
-    (record.definition === 'class' || record.definition === 'interface') &&
-    optional(record.ref, isSchemaRef)
+    isClassRef(record.ref) &&
+    typeof record.key === 'string' &&
+    record.key === `${record.ref.origin}:class.${record.ref.name}`
   )
 }
 
@@ -142,7 +119,9 @@ function isView(value: unknown): boolean {
     ['required', 'optional', 'public'].includes(String(record.auth)) &&
     !!target &&
     (target.kind === 'domain' ||
-      (target.kind === 'definition' && isSchemaRefArray(target.definitions)))
+      (target.kind === 'definition' &&
+        Array.isArray(target.definitions) &&
+        target.definitions.every(isSchemaRef)))
   )
 }
 
@@ -150,32 +129,23 @@ export function decodeSchemaIR(value: unknown): SchemaIR | undefined {
   const record = asJsonRecord(value)
   if (
     !record ||
+    record.format !== 'astrale.dsl' ||
     typeof record.version !== 'string' ||
     typeof record.domain !== 'string' ||
-    !recordOf(record.types, isJsonSchema) ||
-    !recordOf(record.interfaces, isInterface) ||
     !recordOf(record.classes, isClass) ||
-    !recordOf(record.imports, isImport) ||
     !recordOf(record.functions, isFunction) ||
-    (record.importsByKey !== undefined && !recordOf(record.importsByKey, isImport)) ||
-    (record.importedInterfacesByKey !== undefined &&
-      !recordOf(record.importedInterfacesByKey, isInterface)) ||
-    (record.views !== undefined && !recordOf(record.views, isView)) ||
-    (record.policies !== undefined && !asJsonRecord(record.policies)) ||
-    (record.dependencies !== undefined &&
-      (!Array.isArray(record.dependencies) ||
-        !record.dependencies.every((dependency) => {
-          const item = asJsonRecord(dependency)
-          return typeof item?.origin === 'string' && typeof item.revision === 'string'
-        })))
+    !recordOf(record.importsByKey, isImport) ||
+    !recordOf(record.importedClassesByKey, isClass) ||
+    !recordOf(record.views, isView) ||
+    !asJsonRecord(record.policies) ||
+    !Array.isArray(record.dependencies) ||
+    !record.dependencies.every((dependency) => {
+      const item = asJsonRecord(dependency)
+      return typeof item?.origin === 'string' && typeof item.revision === 'string'
+    }) ||
+    !('core' in record)
   ) {
     return undefined
   }
   return record as unknown as SchemaIR
 }
-
-export function decodeIrInterfaceRecord(value: unknown): Record<string, IrInterface> | undefined {
-  const record = asJsonRecord(value)
-  if (!record || !Object.values(record).every(isInterface)) return undefined
-  return record as unknown as Record<string, IrInterface>
-}