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

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` (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.
+ * 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,26 +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.domainFile,
-    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,
   }

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

@@ -7,22 +7,22 @@ import { diffSchemas, structuralStatusOf } 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',
+  format: 'astrale.dsl',
   domain: 'example.test',
-  types: {},
-  interfaces: {},
   classes: {},
-  imports: {},
+  importsByKey: {},
+  importedClassesByKey: {},
   functions,
+  views: {},
+  policies: {},
+  dependencies: [],
+  core: {},
 })
 
 const withClass = (member: IrClass): SchemaIR => ({
@@ -63,6 +63,8 @@ describe('canonical standalone Function diffs', () => {
     const member = (required: string[], minLength: number): IrClass => ({
       type: 'node',
       name: 'Person',
+      origin: 'example.test',
+      ref: { origin: 'example.test', kind: 'class', name: 'Person' },
       properties: { name: { type: 'string', minLength } },
       required,
       methods: {},
@@ -87,13 +89,15 @@ describe('canonical standalone Function diffs', () => {
       ...withClass({
         type: 'edge',
         name: 'owns',
+        origin: 'example.test',
+        ref: { origin: 'example.test', kind: 'class', name: 'owns' },
         properties: {},
         required: [],
         methods: {},
         orientation: 'directed',
         endpoints: [],
       }),
-      views: { home: { name: 'home', target: { kind: 'domain' }, auth: 'public' } },
+      views: { home: { name: 'home', target: { kind: 'domain' } } },
       policies: { canRead: { anyOf: [] } },
       dependencies: [{ origin: 'kernel.astrale.ai', revision: 'sha256:one' }],
       core: { nodes: {}, edges: [] },
@@ -103,7 +107,15 @@ describe('canonical standalone Function diffs', () => {
       classes: {
         owns: { ...before.classes.owns, orientation: 'undirected' },
       },
-      views: { home: { ...before.views!.home, auth: 'required' } },
+      views: {
+        home: {
+          ...before.views.home,
+          target: {
+            kind: 'definition',
+            definitions: [{ origin: 'example.test', kind: 'class', name: 'owns' }],
+          },
+        },
+      },
       policies: { canRead: { anyOf: [{ name: 'owner' }] } },
       dependencies: [{ origin: 'kernel.astrale.ai', revision: 'sha256:two' }],
       core: { nodes: { root: {} }, edges: [] },

package/studio/server/introspect/diff.ts

@@ -2,14 +2,12 @@
  * diff.ts — indicative structural diff of two Studio render IRs. Pure.
  *
  * Canonical V1 keeps optionality in the owning `required` arrays and nullability
- * in each value schema. Legacy nullable projections remain supported. This
- * inventory deliberately makes no installation or data-migration claim;
+ * in each value schema. This inventory makes no installation or data-migration claim;
  * only the Kernel Runtime can assess those transitions against installed data.
  */
 import type {
   IrClass,
   IrFunction,
-  IrInterface,
   IrMethod,
   JsonSchema,
   SchemaChange,
@@ -32,28 +30,11 @@ export function baseType(s: JsonSchema | undefined): string {
   return s.enum ? `enum(${s.enum.join(',')})` : 'unknown'
 }
 
-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,
+    input: m.input,
+    output: m.output,
+    ...('static' in m ? { static: m.static, inheritance: m.inheritance } : {}),
     auth: m.auth,
     policy: m.policy,
   }
@@ -76,15 +57,8 @@ export function diffSchemas(prev: SchemaIR | null, next: SchemaIR | null): Schem
     changes.push({ kind: 'schema-metadata-changed', target: next.domain })
   }
 
-  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)
+  diffValueRecord(prev.importsByKey, next.importsByKey, 'import', changes)
+  diffMembers(prev.classes, next.classes, changes)
   diffFunctions(prev.functions ?? {}, next.functions ?? {}, changes)
   diffViews(prev.views ?? {}, next.views ?? {}, changes)
   diffValueRecord(prev.policies ?? {}, next.policies ?? {}, 'policy', changes)
@@ -98,7 +72,7 @@ export function diffSchemas(prev: SchemaIR | null, next: SchemaIR | null): Schem
 function diffValueRecord(
   prev: Record<string, unknown>,
   next: Record<string, unknown>,
-  scope: 'type' | 'import' | 'policy',
+  scope: 'import' | 'policy',
   out: SchemaChange[],
 ): void {
   for (const name of sortedKeys(next)) {
@@ -150,15 +124,7 @@ function diffViews(
       out.push({ kind: 'view-removed', target: name })
       continue
     }
-    if (
-      !same(
-        { target: prev[name].target, auth: prev[name].auth },
-        {
-          target: next[name].target,
-          auth: next[name].auth,
-        },
-      )
-    ) {
+    if (!same(prev[name].target, next[name].target)) {
       out.push({ kind: 'view-changed', target: name })
     }
     if (prev[name].description !== next[name].description) {
@@ -196,15 +162,13 @@ function diffDependencies(
   }
 }
 
-function memberKind(m: IrClass | IrInterface): 'class' | 'edge' | 'interface' {
-  if ((m as IrInterface).type === 'interface') return 'interface'
-  return (m as IrClass).type === 'edge' ? 'edge' : 'class'
+function memberKind(member: IrClass): 'class' | 'edge' {
+  return member.type === 'edge' ? 'edge' : 'class'
 }
 
 function diffMembers(
-  prev: Record<string, IrClass | IrInterface>,
-  next: Record<string, IrClass | IrInterface>,
-  _scope: 'class' | 'interface',
+  prev: Record<string, IrClass>,
+  next: Record<string, IrClass>,
   out: SchemaChange[],
 ): void {
   for (const name of sortedKeys(next)) {
@@ -223,12 +187,7 @@ function diffMembers(
   }
 }
 
-function diffMemberBody(
-  name: string,
-  a: IrClass | IrInterface,
-  b: IrClass | IrInterface,
-  out: SchemaChange[],
-): void {
+function diffMemberBody(name: string, a: IrClass, b: IrClass, out: SchemaChange[]): void {
   const pa = a.properties ?? {}
   const pb = b.properties ?? {}
   for (const p of sortedKeys(pb)) {
@@ -302,31 +261,27 @@ function diffMemberBody(
   }
 }
 
-function propertyRequired(member: IrClass | IrInterface, name: string): boolean {
+function propertyRequired(member: IrClass, 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
+function memberContract(member: IrClass): unknown {
   return {
     type: member.type,
     origin: member.origin,
     ref: member.ref,
-    family: iface.family,
-    extends: iface.extendsRefs ?? iface.extends,
-    implements: cls.implementsRefs ?? cls.implements,
+    extends: member.extendsRefs ?? member.extends,
     endpoints: member.endpoints,
     orientation: member.orientation,
     constraints: member.constraints,
     propertyMetadata: member.propertyMetadata,
     data: member.data,
-    policies: cls.policies,
+    policies: member.policies,
   }
 }
 
-function memberMetadata(member: IrClass | IrInterface): unknown {
-  return { description: member.description, icon: (member as IrClass).icon }
+function memberMetadata(member: IrClass): unknown {
+  return { description: member.description, icon: member.icon }
 }
 
 function sortedKeys(value: Record<string, unknown>): string[] {

package/studio/server/introspect/extractor.ts

@@ -1,136 +1,37 @@
-/**
- * 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 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>
- *
- * A thrown error prints { ok:false } and exits 0 — the driver treats it as a
- * render state, never a crash.
- */
-import {
-  admitCanonicalSchemaFromSdk,
-  findCanonicalDomainSchemaExport,
-  normalizeLegacySchemaIR,
-  projectCanonicalSchema,
-} from './canonical-schema'
+/** Bun subprocess that imports only the authored Schema entry and its installed SDK. */
+import type { SchemaSdk } from './canonical-schema'
 
-const schemaPath = process.argv[2]
-const domainDir = process.argv[3] ?? process.cwd()
-
-async function main() {
-  if (!schemaPath) throw new Error('extractor: missing <schemaIndexPath>')
-  const mod: Record<string, any> = await import(schemaPath)
-
-  // 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)
-    )
-    sdk = loaded
-    return loaded
-  }
+import { extractCanonicalSchemaFromSdk, findCanonicalDomainSchemaExport } from './canonical-schema'
 
-  const canonicalRoot = findCanonicalDomainSchemaExport(mod)
-  if (canonicalRoot) {
-    const domainSdk = await loadSdkSchema()
-    const admission = admitCanonicalSchemaFromSdk(domainSdk, canonicalRoot)
-    const projected = projectCanonicalSchema(admission.root, admission.closure)
-    process.stdout.write(
-      JSON.stringify({
-        ok: true,
-        ir: projected.ir,
-        root: admission.root,
-        schemaMode: admission.status === 'admitted' ? 'canonical-admitted' : 'canonical-preview',
-        revision: admission.revision,
-        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`).
-  let ir: unknown = mod?.D?.$?.ir
-  if (!ir) {
-    for (const v of Object.values(mod)) {
-      const candidate = (v as any)?.$?.ir
-      if (candidate) {
-        ir = candidate
-        break
-      }
-    }
-  }
-  if (!ir) {
-    // Fallback: serialize a raw schema — the conventional `schema`, else any
-    // exported `defineSchema(...)` result (recognized by its `kind === 'schema'`).
-    const schema =
-      mod?.schema ??
-      Object.values(mod).find(
-        (v) =>
-          typeof (v as any)?.domain === 'string' && !!(v as any)?.classes && !!(v as any)?.imports,
-      )
-    if (!schema) {
-      throw new Error(
-        'schema entry exports no compiled domain (a `compileDomain(...)` value with `.$.ir`, e.g. `D`) nor a raw `schema`',
-      )
-    }
-    const d = await loadSdkSchema()
-    if (typeof d.serialize !== 'function') throw new Error('kernel-dsl.serialize unavailable')
-    ir = d.serialize(schema)
-  }
-
-  // Recover member bodies of IMPORTED interfaces (kernel mixins + cross-domain
-  // interfaces). `serialize()` emits them in `ir.imports` as name-only
-  // descriptors, so re-serialize each imported schema (KernelSchema, other
-  // domains) and collect its interface definitions. Best-effort: a single import
-  // failing to serialize must never break extraction of the primary IR.
-  const importedInterfaces: Record<string, unknown> = {}
-  const importSchemas: any[] = Array.isArray(mod?.schema?.imports) ? mod.schema.imports : []
-  if (importSchemas.length > 0) {
-    try {
-      const d = await loadSdkSchema()
-      if (typeof d.serialize === 'function') {
-        for (const imp of importSchemas) {
-          try {
-            const sub = d.serialize(imp)
-            for (const [name, def] of Object.entries(sub?.interfaces ?? {})) {
-              if (!(name in importedInterfaces)) importedInterfaces[name] = def
-            }
-          } catch {
-            /* skip this import — keep going */
-          }
-        }
-      }
-    } catch {
-      /* dsl unavailable — degrade gracefully (no imported-interface bodies) */
-    }
+const schemaPath = process.argv[2]
+const projectRoot = process.argv[3] ?? process.cwd()
+
+async function main(): Promise<void> {
+  if (!schemaPath) throw new Error('extractor: missing <schemaPath>')
+  const exports = (await import(schemaPath)) as Record<string, unknown>
+  const candidate = findCanonicalDomainSchemaExport(exports)
+  if (candidate === null) {
+    throw new Error('Schema entry exports no canonical V1 DomainSchema.')
   }
-
+  const sdk = (await import(
+    Bun.resolveSync('@astrale-os/sdk/schema', projectRoot)
+  )) as unknown as SchemaSdk
+  const extraction = extractCanonicalSchemaFromSdk(sdk, candidate)
   process.stdout.write(
     JSON.stringify({
       ok: true,
-      ir: normalizeLegacySchemaIR(ir),
-      root: null,
-      schemaMode: 'legacy',
-      revision: null,
-      importedInterfaces,
+      ir: extraction.ir,
+      root: extraction.root,
+      schemaMode: extraction.status === 'admitted' ? 'canonical-admitted' : 'canonical-preview',
+      revision: extraction.revision,
     }),
   )
 }
 
-main().catch((err: any) => {
+main().catch((cause: unknown) => {
+  const error = cause instanceof Error ? cause : new Error(String(cause))
   process.stdout.write(
-    JSON.stringify({
-      ok: false,
-      error: { message: String(err?.message ?? err), stack: String(err?.stack ?? '') },
-    }),
+    JSON.stringify({ ok: false, error: { message: error.message, stack: error.stack ?? '' } }),
   )
   process.exit(0)
 })