@astrale-os/cli 1.0.0-beta.26 → 1.0.0-beta.28

package/studio/server/introspect/canonical-schema.ts

@@ -1,7 +1,7 @@
 /**
- * Pure projection from an SDK-admitted portable DomainSchema into Studio's
- * intentionally lossy render model. The extractor calls the authored Domain's
- * own installed SDK for admission before this module interprets the document.
+ * Project the DSL's portable Schema into Studio's deliberately smaller render
+ * model. Admission, dependency reachability, and reference resolution remain
+ * owned by the Domain's installed DSL.
  */
 import type {
   IrCallableAuth,
@@ -17,37 +17,78 @@ import type {
   IrView,
   JsonSchema,
   SchemaIR,
+  SchemaRevision,
   StudioCore,
 } from '../../shared/types'
 
-import { classRefKey, isIrClassRef, schemaRefKey } from '../../shared/schema/identity'
 import { isSchemaRevision } from '../../shared/types'
 
 type AnyRecord = Record<string, unknown>
 
-export type CanonicalDomainSchemaV1 = AnyRecord & {
+/** The portable V1 value transported across the extractor process boundary. */
+export interface CanonicalDomainSchemaV1 {
   readonly format: 'astrale.dsl'
   readonly version: 'v1'
   readonly origin: string
+  readonly dependencies: Readonly<
+    Record<string, { readonly origin: string; readonly revision: string }>
+  >
+  readonly classes: Readonly<Record<string, unknown>>
+  readonly functions: Readonly<Record<string, unknown>>
+  readonly policies: Readonly<Record<string, unknown>>
+  readonly views: Readonly<Record<string, unknown>>
+  readonly core: unknown
+}
+
+interface ResolvedSchemaDomain {
+  readonly source: CanonicalDomainSchemaV1
+  readonly revision: unknown
+  definition(ref: IrClassRef): { readonly definition: unknown } | undefined
+}
+
+/** Runtime facade supplied by the inspected Domain, not by Studio's package. */
+export interface SchemaSdk {
+  readonly bundle: {
+    create(input: any): unknown
+    accept(input: any): {
+      readonly root: CanonicalDomainSchemaV1
+      readonly closure: readonly CanonicalDomainSchemaV1[]
+    }
+  }
+  readonly schema: {
+    resolve(input: any): ResolvedSchemaDomain
+    compareDependencyMeaning(
+      source: CanonicalDomainSchemaV1,
+      target: CanonicalDomainSchemaV1,
+    ): { readonly footprint: readonly unknown[] }
+  }
+  readonly ClassKey: {
+    is(input: unknown): input is IrClassKey
+    ref(input: IrClassKey): IrClassRef
+  }
 }
 
-export interface CanonicalSchemaProjection {
+/** Smaller facade used when re-admitting an installed Bundle for drift checks. */
+export interface SchemaAdmissionSdk {
+  readonly bundle: {
+    accept(input: any): { readonly root: CanonicalDomainSchemaV1 }
+  }
+  readonly schema: {
+    resolve(input: any): { readonly source: unknown; readonly revision: unknown }
+  }
+}
+
+export interface CanonicalSchemaExtraction {
+  readonly status: 'admitted' | 'preview'
+  readonly root: CanonicalDomainSchemaV1
+  readonly revision: SchemaRevision | null
   readonly ir: SchemaIR
 }
 
-export type CanonicalSchemaAdmission =
-  | {
-      readonly status: 'admitted'
-      readonly root: CanonicalDomainSchemaV1
-      readonly closure: CanonicalDomainSchemaV1[]
-      readonly revision: `sha256:${string}`
-    }
-  | {
-      readonly status: 'preview'
-      readonly root: CanonicalDomainSchemaV1
-      readonly closure: CanonicalDomainSchemaV1[]
-      readonly revision: null
-    }
+interface ImportProjection {
+  importsByKey: Record<IrClassKey, IrImportDescriptor>
+  importedClassesByKey: Record<IrClassKey, IrClass>
+}
 
 export function isCanonicalDomainSchemaV1(value: unknown): value is CanonicalDomainSchemaV1 {
   const candidate = asRecord(value)
@@ -74,134 +115,32 @@ export function findCanonicalDomainSchemaExport(
   )
 }
 
-/** Read the exact retained dependency closure through the authored SDK. */
-export function closureFromSdk(
-  sdkModule: Record<string, unknown>,
-  root: CanonicalDomainSchemaV1,
-): CanonicalDomainSchemaV1[] {
-  const create = asRecord(sdkModule.bundle)?.create
-  if (typeof create !== 'function') return []
-  try {
-    const candidate = asRecord(Reflect.apply(create, undefined, [root]))
-    if (candidate?.root !== root) return []
-    return admitClosure(candidate.closure, root) ?? []
-  } catch {
-    return []
-  }
-}
-
-/** Re-admit one portable root and prove its revision through the authored SDK. */
-export function admitCanonicalSchemaFromSdk(
-  sdkModule: Record<string, unknown>,
+/**
+ * Re-admit the authored Schema as one exact DSL Bundle and resolve its Domain.
+ * A V1-shaped value rejected by the installed DSL remains a best-effort local
+ * preview while the author is in the middle of an edit.
+ */
+export function extractCanonicalSchemaFromSdk(
+  sdk: SchemaSdk,
   candidate: CanonicalDomainSchemaV1,
-): CanonicalSchemaAdmission {
-  const retainedClosure = closureFromSdk(sdkModule, candidate)
-  const schemaApi = asRecord(sdkModule.schema)
-  const accept = schemaApi?.accept
-  const revision = schemaApi?.revision
-  const resolve = schemaApi?.resolve
-  if (
-    typeof accept !== 'function' ||
-    typeof revision !== 'function' ||
-    typeof resolve !== 'function'
-  ) {
-    return { status: 'preview', root: candidate, closure: retainedClosure, revision: null }
-  }
-
+): CanonicalSchemaExtraction {
   try {
-    const revisions = new Map<string, string>()
-    for (const dependency of retainedClosure) {
-      const value = Reflect.apply(revision, schemaApi, [dependency])
-      if (!isSchemaRevision(value)) throw new TypeError('SDK returned an invalid revision.')
-      revisions.set(dependency.origin, value)
+    const admitted = sdk.bundle.accept(sdk.bundle.create(candidate))
+    if (admitted.root.origin !== candidate.origin) {
+      throw new TypeError('DSL Bundle admission returned another Schema root.')
     }
-    const lookup = {
-      get(origin: string, expected: string): CanonicalDomainSchemaV1 | undefined {
-        const dependency = retainedClosure.find((entry) => entry.origin === origin)
-        return dependency && revisions.get(origin) === expected ? dependency : undefined
-      },
+    const domain = sdk.schema.resolve(admitted.root)
+    if (domain.source !== admitted.root || !isSchemaRevision(domain.revision)) {
+      throw new TypeError('DSL resolution did not retain the admitted Schema root.')
     }
-    const accepted = Reflect.apply(accept, schemaApi, [candidate, lookup])
-    if (!isCanonicalDomainSchemaV1(accepted) || accepted.origin !== candidate.origin) {
-      throw new TypeError('SDK admission returned another root.')
-    }
-    const acceptedRevision = Reflect.apply(revision, schemaApi, [accepted])
-    if (!isSchemaRevision(acceptedRevision))
-      throw new TypeError('SDK returned an invalid revision.')
-    const domain = asRecord(Reflect.apply(resolve, schemaApi, [accepted]))
-    if (domain?.source !== accepted || domain.origin !== accepted.origin) {
-      throw new TypeError('SDK resolution did not retain the admitted root.')
+    return {
+      status: 'admitted',
+      root: admitted.root,
+      revision: domain.revision,
+      ir: projectSchema(admitted.root, projectImports(sdk, domain, admitted.closure)),
     }
-    const closure = closureFromSdk(sdkModule, accepted)
-    return { status: 'admitted', root: accepted, closure, revision: acceptedRevision }
   } catch {
-    return { status: 'preview', root: candidate, closure: retainedClosure, revision: null }
-  }
-}
-
-export function projectCanonicalSchema(
-  root: CanonicalDomainSchemaV1,
-  closure: readonly CanonicalDomainSchemaV1[] = [],
-): CanonicalSchemaProjection {
-  const origin = root.origin
-  const classes = Object.fromEntries(
-    entriesOf(root.classes).map(([name, declaration]) => [
-      name,
-      projectClass(origin, name, declaration),
-    ]),
-  )
-  const functions = Object.fromEntries(
-    entriesOf(root.functions).map(([name, declaration]) => [
-      name,
-      projectFunction(name, declaration),
-    ]),
-  )
-  const views = Object.fromEntries(
-    entriesOf(root.views).map(([name, declaration]) => [name, projectView(name, declaration)]),
-  )
-  const schemas = new Map(
-    closure.filter(isCanonicalDomainSchemaV1).map((value) => [value.origin, value]),
-  )
-  const importsByKey = {} as Record<IrClassKey, IrImportDescriptor>
-  const importedClassesByKey = {} as Record<IrClassKey, IrClass>
-  const pending = collectClassRefs(root)
-  const visited = new Set<string>()
-
-  for (let index = 0; index < pending.length; index += 1) {
-    const ref = pending[index]
-    if (ref.origin === origin) continue
-    const key = classRefKey(ref)
-    if (visited.has(key)) continue
-    visited.add(key)
-    importsByKey[key] = { origin: ref.origin, ref, key }
-    const owner = schemas.get(ref.origin)
-    const declaration = asRecord(asRecord(owner?.classes)?.[ref.name])
-    if (owner === undefined || declaration === null) continue
-    importedClassesByKey[key] = projectClass(owner.origin, ref.name, declaration)
-    pending.push(...collectClassRefsFromClass(declaration))
-  }
-
-  const dependencies = arrayOf(root.dependencies).flatMap((value) => {
-    const dependency = asRecord(value)
-    return typeof dependency?.origin === 'string' && typeof dependency.revision === 'string'
-      ? [{ origin: dependency.origin, revision: dependency.revision }]
-      : []
-  })
-
-  return {
-    ir: {
-      format: 'astrale.dsl',
-      version: 'v1',
-      domain: origin,
-      classes,
-      importsByKey,
-      importedClassesByKey,
-      functions,
-      views,
-      policies: recordCopy(root.policies),
-      dependencies,
-      core: jsonCopy(root.core),
-    },
+    return { status: 'preview', root: candidate, revision: null, ir: projectSchema(candidate) }
   }
 }
 
@@ -212,10 +151,9 @@ export function projectCanonicalCore(
   const core = asRecord(root.core) ?? {}
   const nodes = entriesOf(core.nodes).map(([slug, raw]) => {
     const node = asRecord(raw) ?? {}
-    const selectedClass = classRef(node.class)
     return {
       path: corePath({ origin: root.origin, name: slug }),
-      className: selectedClass?.name ?? '?',
+      className: classRef(node.class)?.name ?? '?',
       data: recordCopy(node.properties),
     }
   })
@@ -231,20 +169,64 @@ export function projectCanonicalCore(
   return { domain: root.origin, nodes, edges }
 }
 
+function projectSchema(root: CanonicalDomainSchemaV1, imports?: ImportProjection): SchemaIR {
+  return {
+    format: 'astrale.dsl',
+    version: 'v1',
+    domain: root.origin,
+    classes: Object.fromEntries(
+      entriesOf(root.classes).map(([name, value]) => [
+        name,
+        projectClass(root.origin, name, value),
+      ]),
+    ),
+    importsByKey: imports?.importsByKey ?? {},
+    importedClassesByKey: imports?.importedClassesByKey ?? {},
+    functions: Object.fromEntries(
+      entriesOf(root.functions).map(([name, value]) => [name, projectFunction(name, value)]),
+    ),
+    views: Object.fromEntries(
+      entriesOf(root.views).map(([name, value]) => [name, projectView(name, value)]),
+    ),
+    policies: recordCopy(root.policies),
+    dependencies: Object.values(root.dependencies ?? {}).map(({ origin, revision }) => ({
+      origin,
+      revision,
+    })),
+    core: jsonCopy(root.core),
+  }
+}
+
+function projectImports(
+  sdk: SchemaSdk,
+  domain: ReturnType<SchemaSdk['schema']['resolve']>,
+  closure: readonly CanonicalDomainSchemaV1[],
+): ImportProjection {
+  const importsByKey = {} as Record<IrClassKey, IrImportDescriptor>
+  const importedClassesByKey = {} as Record<IrClassKey, IrClass>
+
+  // The DSL computes the exact reachable footprint. Studio no longer recurses
+  // through JSON Schemas, policies, Views, and Core declarations to rediscover it.
+  for (const dependency of closure) {
+    const footprint = sdk.schema.compareDependencyMeaning(domain.source, dependency).footprint
+    for (const candidate of footprint) {
+      if (!sdk.ClassKey.is(candidate)) continue
+      const ref = sdk.ClassKey.ref(candidate)
+      const definition = domain.definition(ref)
+      if (!definition) continue
+      const key = candidate as IrClassKey
+      importsByKey[key] = { origin: ref.origin, ref, key }
+      importedClassesByKey[key] = projectClass(ref.origin, ref.name, definition.definition)
+    }
+  }
+  return { importsByKey, importedClassesByKey }
+}
+
 function projectClass(origin: string, name: string, value: unknown): IrClass {
   const declaration = asRecord(value) ?? {}
   const kind = declaration.kind === 'edge' ? 'edge' : 'node'
   const extendsRefs = refsOf(declaration.extends)
   const propertyEntries = entriesOf(declaration.properties)
-  const properties = Object.fromEntries(
-    propertyEntries.map(([propertyName, raw]) => [
-      propertyName,
-      studioSchema(asRecord(raw)?.schema),
-    ]),
-  )
-  const required = propertyEntries.flatMap(([propertyName, raw]) =>
-    asRecord(raw)?.required === true ? [propertyName] : [],
-  )
   const propertyMetadata = Object.fromEntries(
     propertyEntries.map(([propertyName, raw]) => {
       const member = { ...(asRecord(raw) ?? {}) }
@@ -265,52 +247,54 @@ function projectClass(origin: string, name: string, value: unknown): IrClass {
     ref: { origin, kind: 'class', name },
     extends: extendsRefs.map((ref) => ref.name),
     extendsRefs,
-    properties,
-    required,
-    methods: projectMethods(declaration.methods),
+    properties: Object.fromEntries(
+      propertyEntries.map(([propertyName, raw]) => [
+        propertyName,
+        studioSchema(asRecord(raw)?.schema),
+      ]),
+    ),
+    required: propertyEntries.flatMap(([propertyName, raw]) =>
+      asRecord(raw)?.required === true ? [propertyName] : [],
+    ),
+    methods: Object.fromEntries(
+      entriesOf(declaration.methods).map(([methodName, raw]) => [
+        methodName,
+        projectMethod(methodName, raw),
+      ]),
+    ),
     ...(kind === 'edge' ? edgeFields(declaration) : {}),
+    ...(typeof declaration.icon === 'string' ? { icon: declaration.icon } : {}),
     ...(typeof declaration.description === 'string'
       ? { description: declaration.description }
       : {}),
+    // the SDK lets a Class carry its own glyph; without this the schema declared one
+    // and every surface still drew the generic box
+    ...(typeof declaration.icon === 'string' ? { icon: declaration.icon } : {}),
     ...(Object.keys(propertyMetadata).length === 0 ? {} : { propertyMetadata }),
     ...(dataDeclaration(declaration.data) ? { data: dataDeclaration(declaration.data) } : {}),
     ...(Object.keys(policies).length === 0 ? {} : { policies }),
   }
 }
 
-function projectMethods(value: unknown): Record<string, IrMethod> {
-  return Object.fromEntries(
-    entriesOf(value).map(([name, raw]) => {
-      const declaration = asRecord(raw) ?? {}
-      const inheritance =
-        declaration.inheritance === 'abstract' || declaration.inheritance === 'sealed'
-          ? declaration.inheritance
-          : 'default'
-      return [
-        name,
-        {
-          ...projectCallable(name, declaration),
-          static: declaration.static === true,
-          inheritance,
-        } satisfies IrMethod,
-      ]
-    }),
-  )
+function projectMethod(name: string, value: unknown): IrMethod {
+  const declaration = asRecord(value) ?? {}
+  return {
+    ...projectFunction(name, declaration),
+    static: declaration.static === true,
+    inheritance:
+      declaration.inheritance === 'abstract' || declaration.inheritance === 'sealed'
+        ? declaration.inheritance
+        : 'default',
+  }
 }
 
 function projectFunction(name: string, value: unknown): IrFunction {
-  return projectCallable(name, value)
-}
-
-function projectCallable(name: string, value: unknown): IrFunction {
   const declaration = asRecord(value) ?? {}
-  const input = studioSchema(declaration.input)
-  const output = callableOutput(declaration.output)
   const auth = callableAuth(declaration.auth)
   return {
     name,
-    input,
-    output,
+    input: studioSchema(declaration.input),
+    output: callableOutput(declaration.output),
     ...(typeof declaration.description === 'string'
       ? { description: declaration.description }
       : {}),
@@ -363,99 +347,35 @@ function projectEndpoint(
 ): IrEndpoint {
   const endpoint = asRecord(value) ?? {}
   const refs = refsOf(endpoint.accepts)
-  const count = edgeCount(endpoint[cardinality])
+  const count = endpoint[cardinality]
   return {
     name: typeof endpoint.role === 'string' ? endpoint.role : '',
     types: refs.map((ref) => ref.name),
     refs,
-    ...(count === undefined ? {} : { cardinality: count }),
+    ...(count === '0..*' || count === '1..*' || count === '0..1' || count === '1'
+      ? { cardinality: edgeCount(count) }
+      : {}),
   }
 }
 
-function edgeCount(value: unknown): IrEndpoint['cardinality'] | undefined {
+function edgeCount(value: '0..*' | '1..*' | '0..1' | '1'): IrEndpoint['cardinality'] {
   if (value === '0..*') return { min: 0, max: null }
   if (value === '1..*') return { min: 1, max: null }
   if (value === '0..1') return { min: 0, max: 1 }
-  if (value === '1') return { min: 1, max: 1 }
-  return undefined
+  return { min: 1, max: 1 }
 }
 
-function collectClassRefs(root: CanonicalDomainSchemaV1): IrClassRef[] {
-  const refs: IrClassRef[] = []
-  for (const [, declaration] of entriesOf(root.classes)) {
-    refs.push(...collectClassRefsFromClass(declaration))
-  }
-  for (const [, callable] of entriesOf(root.functions)) collectCallableRefs(callable, refs)
-  for (const [, view] of entriesOf(root.views)) {
-    refs.push(...refsOf(asRecord(asRecord(view)?.target)?.definitions))
-  }
-  const core = asRecord(root.core)
-  for (const [, node] of entriesOf(core?.nodes)) addClassRef(asRecord(node)?.class, refs)
-  for (const edge of arrayOf(core?.edges)) {
-    const declaration = asRecord(edge)
-    addClassRef(declaration?.class, refs)
-  }
-  for (const [, policy] of entriesOf(root.policies)) collectPolicyRefs(policy, refs)
-  return uniqueClassRefs(refs)
-}
-
-function collectClassRefsFromClass(value: unknown): IrClassRef[] {
-  const declaration = asRecord(value) ?? {}
-  const refs = [...refsOf(declaration.extends)]
-  const endpoints = asRecord(declaration.endpoints)
-  for (const endpoint of [
-    endpoints?.source,
-    endpoints?.target,
-    ...arrayOf(declaration.endpoints),
-  ]) {
-    refs.push(...refsOf(asRecord(endpoint)?.accepts))
-  }
-  for (const [, property] of entriesOf(declaration.properties)) {
-    collectPathSchemaRefs(asRecord(property)?.schema, refs)
-  }
-  for (const [, callable] of entriesOf(declaration.methods)) collectCallableRefs(callable, refs)
-  for (const [, policy] of entriesOf(declaration.policies)) collectPolicyRefs(policy, refs)
-  return uniqueClassRefs(refs)
-}
-
-function collectCallableRefs(value: unknown, refs: IrClassRef[]): void {
-  const callable = asRecord(value)
-  if (callable === null) return
-  collectPathSchemaRefs(callable.input, refs)
-  const output = asRecord(callable.output)
-  collectPathSchemaRefs(output?.schema ?? output?.item, refs)
-  collectPolicyRefs(callable.policy, refs)
-}
-
-function collectPathSchemaRefs(value: unknown, refs: IrClassRef[]): void {
-  if (Array.isArray(value)) {
-    for (const item of value) collectPathSchemaRefs(item, refs)
-    return
-  }
-  const object = asRecord(value)
-  if (object === null) return
-  const annotation = asRecord(object['x-astrale-path'])
-  refs.push(...refsOf(annotation?.accepts))
-  for (const [key, child] of Object.entries(object)) {
-    if (key === 'const' || key === 'enum' || key === 'default' || key === 'examples') continue
-    collectPathSchemaRefs(child, refs)
-  }
-}
-
-function collectPolicyRefs(value: unknown, refs: IrClassRef[]): void {
-  if (Array.isArray(value)) {
-    for (const item of value) collectPolicyRefs(item, refs)
-    return
-  }
-  const object = asRecord(value)
-  if (object === null) return
-  addClassRef(object.class, refs)
-  for (const child of Object.values(object)) collectPolicyRefs(child, refs)
+function callableOutput(value: unknown): IrCallableOutput {
+  const output = asRecord(value)
+  if (output?.mode === 'stream') return { mode: 'stream', item: studioSchema(output.item) }
+  if (output?.mode === 'binary') return { mode: 'binary' }
+  return { mode: 'value', schema: studioSchema(output?.schema) }
 }
 
-function addClassRef(value: unknown, refs: IrClassRef[]): void {
-  const ref = classRef(value)
-  if (ref !== null) refs.push(ref)
+function callableAuth(value: unknown): IrCallableAuth | undefined {
+  return value === 'anonymous' || value === 'authenticated' || value === 'authorized'
+    ? value
+    : undefined
 }
 
 function refsOf(value: unknown): IrClassRef[] {
@@ -466,7 +386,7 @@ function refsOf(value: unknown): IrClassRef[] {
 
 function classRef(value: unknown): IrClassRef | null {
   const ref = definitionRefOf(value)
-  return ref !== null && isIrClassRef(ref) ? ref : null
+  return ref?.kind === 'class' ? { origin: ref.origin, kind: 'class', name: ref.name } : null
 }
 
 function definitionRefOf(value: unknown): IrSchemaRef | null {
@@ -484,29 +404,6 @@ function definitionRefOf(value: unknown): IrSchemaRef | null {
   return { origin: ref.origin, kind: ref.kind, name: ref.name }
 }
 
-function uniqueClassRefs(refs: readonly IrClassRef[]): IrClassRef[] {
-  const seen = new Set<string>()
-  return refs.filter((ref) => {
-    const key = classRefKey(ref)
-    if (seen.has(key)) return false
-    seen.add(key)
-    return true
-  })
-}
-
-function callableOutput(value: unknown): IrCallableOutput {
-  const output = asRecord(value)
-  if (output?.mode === 'stream') return { mode: 'stream', item: studioSchema(output.item) }
-  if (output?.mode === 'binary') return { mode: 'binary' }
-  return { mode: 'value', schema: studioSchema(output?.schema) }
-}
-
-function callableAuth(value: unknown): IrCallableAuth | undefined {
-  return value === 'anonymous' || value === 'authenticated' || value === 'authorized'
-    ? value
-    : undefined
-}
-
 function dataDeclaration(
   value: unknown,
 ): { mediaType: string; [key: string]: unknown } | undefined {
@@ -518,8 +415,8 @@ function dataDeclaration(
 
 function coreEndpoint(value: unknown, rootOrigin: string): string {
   const endpoint = asRecord(value)
-  if (endpoint?.kind === 'domain' && typeof endpoint.origin === 'string') {
-    return `/:${endpoint.origin}`
+  if (endpoint?.kind === 'domain') {
+    return `/:${typeof endpoint.origin === 'string' ? endpoint.origin : rootOrigin}`
   }
   const ref = definitionRefOf(value)
   return ref?.kind === 'core' ? corePath(ref) : `/:${rootOrigin}`
@@ -529,22 +426,6 @@ function corePath(ref: Pick<IrSchemaRef, 'origin' | 'name'>): string {
   return `/:${ref.origin}:core.${ref.name}`
 }
 
-function admitClosure(
-  value: unknown,
-  root: CanonicalDomainSchemaV1,
-): CanonicalDomainSchemaV1[] | null {
-  if (!Array.isArray(value)) return null
-  const closure: CanonicalDomainSchemaV1[] = []
-  const origins = new Set<string>()
-  for (const candidate of value) {
-    if (!isCanonicalDomainSchemaV1(candidate) || candidate.origin === root.origin) return null
-    if (origins.has(candidate.origin)) return null
-    origins.add(candidate.origin)
-    closure.push(candidate)
-  }
-  return closure
-}
-
 function studioSchema(value: unknown): JsonSchema {
   if (value === true) return {}
   if (value === false) return { not: {} }

package/studio/server/introspect/core.ts

@@ -1,16 +1,13 @@
 /**
- * core.ts — assembles a domain's StudioCore: the genesis node/edge graph
- * extracted from canonical `schema.core`, gated
- * on installed deps. Never throws; a failed import or a domain with no core both
- * become a well-formed (empty) render state.
+ * core.ts — derives a domain's genesis graph from the canonical Schema already
+ * extracted for its Studio bundle. Schema code is imported exactly once.
  */
-import type { StudioCore } from '../../shared/types'
+import type { StudioCore, StudioSchemaBundle } from '../../shared/types'
+import type { DomainHandle } from '../domain'
 
-import { type DomainHandle, depsInstalled } from '../domain'
-import { readSettings } from '../state/settings'
-import { coreExtract } from './runtime'
+import { isCanonicalDomainSchemaV1, projectCanonicalCore } from './canonical-schema'
 
-export async function buildCore(handle: DomainHandle): Promise<StudioCore> {
+export function buildCore(handle: DomainHandle, bundle: StudioSchemaBundle | null): StudioCore {
   const at = new Date().toISOString()
   const empty = (error: StudioCore['error']): StudioCore => ({
     domain: handle.origin ?? handle.id,
@@ -20,25 +17,21 @@ export async function buildCore(handle: DomainHandle): Promise<StudioCore> {
     extractedAt: at,
   })
 
-  if (!depsInstalled(handle.root)) {
+  if (!bundle?.depsInstalled) {
     return empty({
       message: 'dependencies not installed — run `pnpm install` in the domain for core extraction',
     })
   }
+  if (!isCanonicalDomainSchemaV1(bundle.schemaRoot)) {
+    return empty(bundle.error ?? { message: 'canonical schema unavailable for core extraction' })
+  }
 
-  const r = await coreExtract(
-    handle.schemaIndex,
-    handle.root,
-    readSettings(handle.root).introspectTimeoutMs,
-  )
-  // r.ok && r.core===null  → the domain simply defines no core (not an error).
-  if (!r.ok) return empty(r.error ?? { message: 'core extraction failed' })
-  if (!r.core) return empty(null)
+  const core = projectCanonicalCore(bundle.schemaRoot)
 
   return {
-    domain: r.core.domain,
-    nodes: r.core.nodes,
-    edges: r.core.edges,
+    domain: core.domain,
+    nodes: core.nodes,
+    edges: core.edges,
     error: null,
     extractedAt: at,
   }