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

package/studio/server/introspect/source-overlay/kernel-calls.ts

@@ -22,10 +22,7 @@ const KERNEL_TOKENS: KernelToken[] = [
   { token: 'auth.check' },
   { token: 'graph.tree' },
   { token: 'graph.node' },
-  { token: 'revokePerm', label: 'revokePerm (legacy)' },
-  { token: 'checkPerm', label: 'checkPerm (legacy)' },
   { token: 'graph.get' },
-  { token: 'grantPerm', label: 'grantPerm (legacy)' },
 ]
 
 /** Scan handler file text for kernel-op tokens. */

package/studio/server/introspect/source-overlay/spans.ts

@@ -58,18 +58,14 @@ function cleanComment(raw: string): string {
   return lines.join(' ').replace(/\s+/g, ' ').trim()
 }
 
-const DECL_HELPERS: Record<string, 'node' | 'interface' | 'edge' | 'function'> = {
+const DECL_HELPERS: Record<string, 'node' | 'edge' | 'function'> = {
   nodeClass: 'node',
-  nodeInterface: 'interface',
   edgeClass: 'edge',
   fn: 'function',
 }
 
-/** Recognize both legacy `edgeClass(...)` and current
- * `edgeClass.directed/undirected({...})` authoring forms. */
-function declarationHelper(
-  call: CallExpression,
-): 'node' | 'interface' | 'edge' | 'function' | undefined {
+/** Recognize current Class and Function declaration helpers. */
+function declarationHelper(call: CallExpression): 'node' | 'edge' | 'function' | undefined {
   const direct = calleeName(call)
   if (direct && direct in DECL_HELPERS) return DECL_HELPERS[direct]
   const expression = call.getExpression()
@@ -85,22 +81,17 @@ function declarationHelper(
 
 /**
  * A schema member's true NAME + section, resolved from the `defineSchema` map.
- * The declaration helpers (nodeClass/nodeInterface/edgeClass) carry no name — a
- * member is named by the KEY it is registered under, not by its variable — and a
- * domain may register a class and an interface under the SAME name (the
- * intentional same-name pattern: the `iUser` interface alongside the `User`
- * class). So the map is the sole authority for both the anchor name and the
- * interface-vs-class distinction; the variable identifier alone tells us neither.
+ * Declaration helpers carry no name: the `defineSchema` key is authoritative.
  */
 interface MemberName {
   schemaName: string
-  section: 'interface' | 'class' | 'function' // the `classes` map also holds edge classes
+  section: 'class' | 'function'
 }
 
 interface MemberNameMap {
   /** Exact declaration initializer, robust to imported/local aliases. */
   byValue: Map<string, MemberName>
-  /** Legacy fallback when a symbol cannot be resolved. */
+  /** Fallback when a symbol cannot be resolved. */
   byIdentifier: Map<string, MemberName>
 }
 
@@ -132,7 +123,6 @@ function buildMemberNameMap(files: SourceFile[]): MemberNameMap {
       const input = call.getArguments()[1]
       const cfg = input ? resolveObjectLiteral(input) : undefined
       if (!cfg) continue
-      collectSchemaSection(map, cfg, 'interfaces', 'interface')
       collectSchemaSection(map, cfg, 'classes', 'class')
       collectSchemaSection(map, cfg, 'functions', 'function')
     }
@@ -145,8 +135,8 @@ function buildMemberNameMap(files: SourceFile[]): MemberNameMap {
 function collectSchemaSection(
   map: MemberNameMap,
   cfg: Node,
-  prop: 'interfaces' | 'classes' | 'functions',
-  section: 'interface' | 'class' | 'function',
+  prop: 'classes' | 'functions',
+  section: 'class' | 'function',
 ): void {
   const obj = getObjectProp(cfg, prop)
   if (!obj) return
@@ -163,24 +153,18 @@ function collectSchemaSection(
 }
 
 /**
- * The anchor namespace ('class' | 'interface' | 'edge') for a declared member.
- * The `defineSchema` SECTION is authoritative for interface-vs-class — a
- * `nodeClass` whose name collides with a same-named interface must still anchor
- * as a class. Within the class section, an `edgeClass` (or an IR edge type)
- * anchors as 'edge'. Falls back to the declaration helper when the member isn't
- * in a parseable `defineSchema` map (e.g. an imported kernel member).
+ * The anchor namespace for a declared member. The Class section plus helper/IR
+ * kind distinguishes Node and Edge Classes.
  */
 function resolveMemberKind(
   ir: SchemaIR | null,
   name: string,
-  section: 'interface' | 'class' | 'function' | undefined,
-  helperKind: 'node' | 'interface' | 'edge' | 'function',
-): 'class' | 'interface' | 'edge' | 'function' {
+  section: 'class' | 'function' | undefined,
+  helperKind: 'node' | 'edge' | 'function',
+): 'class' | 'edge' | 'function' {
   if (section === 'function' || helperKind === 'function') return 'function'
-  if (section === 'interface') return 'interface'
   const isEdge = helperKind === 'edge' || ir?.classes?.[name]?.type === 'edge'
   if (section === 'class') return isEdge ? 'edge' : 'class'
-  if (helperKind === 'interface') return 'interface'
   return isEdge ? 'edge' : 'class'
 }
 
@@ -206,9 +190,7 @@ export function buildSourceSpans(args: {
   const spans: Record<string, SourceSpan> = {}
 
   const sourceFiles = files.map((f) => project.getSourceFile(f)).filter((f): f is SourceFile => !!f)
-  // The domain's `defineSchema` map is authoritative for each member's name +
-  // interface-vs-class kind, so an aliased interface (`iUser`→`User`) and a class
-  // sharing its name (`User`) each anchor correctly instead of colliding.
+  // The Domain's `defineSchema` map is authoritative for each member's name.
   const memberNames = buildMemberNameMap(sourceFiles)
 
   for (const sf of sourceFiles) {
@@ -287,7 +269,7 @@ function collectPropsAndMethods(
   }
 }
 
-/** Record edge endpoint spans `edge.<Name>.endpoint.<role>` from the two args. */
+/** Record edge endpoint and property spans from current directed/undirected forms. */
 function collectEdge(
   spans: Record<string, SourceSpan>,
   name: string,
@@ -331,18 +313,6 @@ function collectEdge(
     if (!role) continue
     spans[`edge.${name}.endpoint.${role}`] = makeSpan(domainRoot, fileRel, ep, ep)
   }
-  // Legacy edge props live in the third (config) arg.
-  const cfgArg = argsList[2]
-  if (cfgArg && Node.isObjectLiteralExpression(cfgArg)) {
-    const propsObj = getObjectProp(cfgArg, 'properties') ?? getObjectProp(cfgArg, 'props')
-    if (propsObj) {
-      for (const p of propsObj.getProperties()) {
-        const pName = propertyKey(p)
-        if (!pName) continue
-        spans[`edge.${name}.property.${pName}`] = makeSpan(domainRoot, fileRel, p, p)
-      }
-    }
-  }
 }
 
 /** The object-literal value of a named property, if it is itself an object. */

package/studio/server/lifecycle.ts

@@ -9,6 +9,7 @@ import type { DomainHandle } from './domain'
  */
 import { getBundle } from './cache'
 import { captureBaseline, hashAnatomyFiles, loadBaseline } from './state/baseline'
+import { migrateDocuments } from './state/documents'
 import { initDotDir } from './state/store'
 import { watchDomain } from './watch'
 
@@ -22,6 +23,8 @@ export interface BootedDomain {
 /** Initialize + start watching one domain. Returns its origin + a stop handle. */
 export async function bootDomain(handle: DomainHandle): Promise<BootedDomain> {
   initDotDir(handle.root)
+  // one-shot: uuid-named documents become readable file names under context/docs
+  migrateDocuments(handle.root)
   const bundle = await getBundle(handle.id)
   if (!loadBaseline(handle.root))
     captureBaseline(
@@ -35,7 +38,7 @@ export async function bootDomain(handle: DomainHandle): Promise<BootedDomain> {
     )
   const stop = watchDomain(handle)
   return {
-    origin: bundle?.overlay.origin ?? handle.id,
+    origin: bundle?.ir?.domain ?? handle.origin ?? handle.id,
     depsInstalled: !!bundle?.depsInstalled,
     stop,
   }

package/studio/server/state/baseline.test.ts

@@ -21,13 +21,13 @@ afterEach(() => {
   while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
 })
 
-test('hashes current implementation and semantic layer files alongside legacy anatomy', () => {
+test('hashes current Application and vertical authoring files', () => {
   const root = mkdtempSync(join(tmpdir(), 'studio-current-baseline-'))
   roots.push(root)
   for (const dir of [
     'schema',
     'actions/risk',
-    'handlers/risk',
+    'providers/mail',
     'queries/risk',
     'ui/risk',
     'views/risk',
@@ -36,9 +36,10 @@ test('hashes current implementation and semantic layer files alongside legacy an
   }
   for (const file of [
     'schema/index.ts',
-    'implementation.ts',
+    'application.ts',
+    'runtime.ts',
     'actions/risk/index.ts',
-    'handlers/risk/index.ts',
+    'providers/mail/index.ts',
     'queries/risk/index.ts',
     'ui/risk/screen.tsx',
     'views/risk/index.ts',
@@ -50,10 +51,11 @@ test('hashes current implementation and semantic layer files alongside legacy an
 
   expect(Object.keys(hashAnatomyFiles(root, 'schema')).sort()).toEqual([
     'actions/risk/index.ts',
-    'handlers/risk/index.ts',
-    'implementation.ts',
+    'application.ts',
     'package.json',
+    'providers/mail/index.ts',
     'queries/risk/index.ts',
+    'runtime.ts',
     'schema/index.ts',
     'ui/risk/screen.tsx',
     'views/risk/index.ts',
@@ -64,11 +66,14 @@ const schema = (domain: string): SchemaIR => ({
   format: 'astrale.dsl',
   version: 'v1',
   domain,
-  types: {},
-  interfaces: {},
   classes: {},
-  imports: {},
+  importsByKey: {},
+  importedClassesByKey: {},
   functions: {},
+  views: {},
+  policies: {},
+  dependencies: [],
+  core: {},
 })
 
 const canonicalRoot = {

package/studio/server/state/baseline.ts

@@ -45,12 +45,10 @@ const SKIP_DIRS = new Set(['node_modules', '.dist', 'dist', '.domain-studio', '.
 export const ANATOMY_GLOBS = {
   dirs: [
     'actions',
-    'capabilities',
     'core',
+    'providers',
     'runtime',
     'views',
-    'functions',
-    'handlers',
     'integrations',
     'migrations',
     'mutations',
@@ -64,8 +62,8 @@ export const ANATOMY_GLOBS = {
     'client/src',
   ],
   files: [
-    'implementation.ts',
-    'domain.ts',
+    'application.ts',
+    'runtime.ts',
     'index.ts',
     'core.ts',
     'deps.ts',

package/studio/server/state/documents.test.ts

@@ -0,0 +1,69 @@
+import { afterEach, expect, test } from 'bun:test'
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { addDocument, listDocuments, migrateDocuments, readDocument } from './documents'
+import { statePath, writeJson, writeStateBuffer } from './store'
+
+const roots: string[] = []
+
+function root(): string {
+  const created = mkdtempSync(join(tmpdir(), 'studio-documents-'))
+  roots.push(created)
+  return created
+}
+
+afterEach(() => {
+  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+
+const bytes = (text: string) => new TextEncoder().encode(text)
+
+test('a document is stored under a readable name, not its id', () => {
+  const domain = root()
+  const meta = addDocument(domain, 'Pricing Decisions.MD', 'text/markdown', bytes('# pricing'))
+
+  expect(meta.stored).toBe('context/docs/pricing-decisions.md')
+  expect(readFileSync(statePath(domain, meta.stored), 'utf8')).toBe('# pricing')
+  expect(readDocument(domain, meta.id)?.meta.name).toBe('Pricing Decisions.MD')
+})
+
+test('same-named documents never overwrite each other', () => {
+  const domain = root()
+  const first = addDocument(domain, 'notes.md', 'text/markdown', bytes('first'))
+  const second = addDocument(domain, 'notes.md', 'text/markdown', bytes('second'))
+
+  expect([first.stored, second.stored]).toEqual([
+    'context/docs/notes.md',
+    'context/docs/notes-2.md',
+  ])
+  expect(readFileSync(statePath(domain, first.stored), 'utf8')).toBe('first')
+})
+
+test('uuid-named documents are migrated in place, once', () => {
+  const domain = root()
+  const legacy = 'context/documents/2b0d9d7e-1f2a-4a10-9f0c-1a2b3c4d5e6f.md'
+  writeStateBuffer(domain, legacy, bytes('legacy body'))
+  writeJson(domain, 'context/documents/index.json', [
+    {
+      id: '2b0d9d7e-1f2a-4a10-9f0c-1a2b3c4d5e6f',
+      name: 'Meeting notes.md',
+      type: 'text/markdown',
+      size: 11,
+      addedAt: new Date(0).toISOString(),
+      stored: legacy,
+    },
+  ])
+
+  migrateDocuments(domain)
+  const [migrated] = listDocuments(domain)
+
+  expect(migrated?.stored).toBe('context/docs/meeting-notes.md')
+  expect(readFileSync(statePath(domain, migrated!.stored), 'utf8')).toBe('legacy body')
+  expect(existsSync(statePath(domain, legacy))).toBe(false)
+
+  // idempotent: a second boot leaves the already-migrated store alone
+  migrateDocuments(domain)
+  expect(listDocuments(domain)[0]?.stored).toBe('context/docs/meeting-notes.md')
+})

package/studio/server/state/documents.ts

@@ -1,10 +1,11 @@
 /**
- * documents.ts — context DOCUMENTS the user drops in for the AI agent. Files are
- * stored under `.domain-studio/context/documents/` (allow-listed) and tracked in
- * an index. They travel with the domain and are part of the agent handoff context.
+ * documents.ts — context DOCUMENTS the user drops in for the AI agent. Files live
+ * under `.domain-studio/context/docs/`, named after the document (not its id), so
+ * the folder is readable by a human and by the agent that is handed its path.
+ * They travel with the domain and are part of the agent handoff context.
  */
 import { randomUUID } from 'node:crypto'
-import { existsSync } from 'node:fs'
+import { existsSync, readFileSync } from 'node:fs'
 import { extname } from 'node:path'
 
 import type { DocMeta } from '../../shared/types'
@@ -13,7 +14,54 @@ import { asFiniteNumber, asJsonRecord, asString } from '../json'
 import { readJson, removeState, statePath, writeJson, writeStateBuffer } from './store'
 
 const INDEX = 'context/documents/index.json'
-const storedPath = (id: string, name: string) => `context/documents/${id}${extname(name)}`
+const DIR = 'context/docs'
+/** Where documents lived before they were named: `context/documents/<uuid>.<ext>`. */
+const LEGACY_DIR = 'context/documents'
+
+/** `Pricing decisions.md` → `pricing-decisions` — a file name you can read. */
+function slugify(name: string): string {
+  const base = name.replace(/\.[^.]+$/, '')
+  const slug = base
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60)
+  return slug || 'document'
+}
+
+/** A stored path no other document (and no file on disk) already claims. */
+function uniqueStoredPath(root: string, docs: DocMeta[], name: string): string {
+  const extension = extname(name).toLowerCase()
+  const slug = slugify(name)
+  const taken = new Set(docs.map((doc) => doc.stored))
+  for (let attempt = 0; ; attempt++) {
+    const candidate = `${DIR}/${slug}${attempt === 0 ? '' : `-${attempt + 1}`}${extension}`
+    if (!taken.has(candidate) && !existsSync(statePath(root, candidate))) return candidate
+  }
+}
+
+/**
+ * Move documents written under the old uuid-named layout into `context/docs/`.
+ * Idempotent and only ever renames inside the studio's own state directory.
+ */
+export function migrateDocuments(root: string): void {
+  const docs = listDocuments(root)
+  if (!docs.some((doc) => doc.stored.startsWith(`${LEGACY_DIR}/`))) return
+  let moved = false
+  for (const doc of docs) {
+    if (!doc.stored.startsWith(`${LEGACY_DIR}/`)) continue
+    const from = statePath(root, doc.stored)
+    if (!existsSync(from)) continue
+    const next = uniqueStoredPath(root, docs, doc.name)
+    writeStateBuffer(root, next, readFileSync(from))
+    removeState(root, doc.stored)
+    doc.stored = next
+    moved = true
+  }
+  if (moved) writeJson(root, INDEX, docs)
+}
 
 function decodeDocument(value: unknown): DocMeta | undefined {
   const record = asJsonRecord(value)
@@ -30,7 +78,7 @@ function decodeDocument(value: unknown): DocMeta | undefined {
     size === undefined ||
     size < 0 ||
     !addedAt ||
-    !stored?.startsWith('context/documents/') ||
+    !(stored?.startsWith(`${DIR}/`) || stored?.startsWith(`${LEGACY_DIR}/`)) ||
     stored.split('/').includes('..')
   ) {
     return undefined
@@ -60,18 +108,17 @@ export function listDocuments(root: string): DocMeta[] {
 }
 
 export function addDocument(root: string, name: string, type: string, data: Uint8Array): DocMeta {
-  const id = randomUUID()
-  const stored = storedPath(id, name)
+  const docs = listDocuments(root)
+  const stored = uniqueStoredPath(root, docs, name || 'untitled')
   writeStateBuffer(root, stored, data)
   const meta: DocMeta = {
-    id,
+    id: randomUUID(),
     name: name || 'untitled',
     type: type || 'application/octet-stream',
     size: data.byteLength,
     addedAt: new Date().toISOString(),
     stored,
   }
-  const docs = listDocuments(root)
   docs.unshift(meta)
   writeJson(root, INDEX, docs)
   return meta

package/studio/server/state/visibility.ts

@@ -1,6 +1,6 @@
 /**
  * visibility.ts — persisted per-domain canvas visibility (the manual hide-set,
- * inherited-edge category toggle, and materialized-interface set). Sibling of
+ * and inherited-edge category toggle). Sibling of
  * layout.ts: layout owns node POSITIONS, this owns what's SHOWN. All entries use
  * stable refs, so they survive schema edits (a removed ref is harmless).
  * Persisted via the allow-listed store (visibility.json).
@@ -14,7 +14,6 @@ const FILE = 'visibility.json'
 const DEFAULT: VisibilityState = {
   hidden: {},
   showInheritedEdges: true,
-  materializedInterfaces: {},
 }
 
 function trueSet(value: unknown): Record<string, true> {
@@ -31,13 +30,10 @@ function decodeVisibility(value: unknown): VisibilityState | undefined {
   return {
     hidden: trueSet(record.hidden),
     showInheritedEdges: asBoolean(record.showInheritedEdges) ?? DEFAULT.showInheritedEdges,
-    materializedInterfaces: trueSet(record.materializedInterfaces),
   }
 }
 
 export function readVisibility(root: string): VisibilityState {
-  // merge over DEFAULT so a file written before a field existed (e.g. pre-materialize)
-  // still returns the complete shape — the client reads every field unconditionally.
   return readJson(root, FILE, decodeVisibility, { ...DEFAULT })
 }
 

package/studio/server/views/model.ts

@@ -4,9 +4,9 @@ import type {
   ViewTargetResult,
 } from '../../shared/types'
 
-const NAMED_NAME = 'kernel.astrale.ai:interface.Named.property.name'
-const DESCRIPTABLE_DESCRIPTION = 'kernel.astrale.ai:interface.Descriptable.property.description'
-const STATUSED_STATUS = 'kernel.astrale.ai:interface.Statused.property.status'
+const NAMED_NAME = 'kernel.astrale.ai:class.Named.property.name'
+const DESCRIPTABLE_DESCRIPTION = 'kernel.astrale.ai:class.Descriptable.property.description'
+const STATUSED_STATUS = 'kernel.astrale.ai:class.Statused.property.status'
 
 export interface RawTargetRow {
   id?: unknown

package/studio/server/views/target.test.ts

@@ -4,132 +4,74 @@ import type { StudioSchemaBundle, ViewInfo } from '../../shared/types'
 
 import { targetDefinition, viewDefinitionBindings } from './target'
 
-describe('view target definitions', () => {
-  test('preserves canonical interface View target coordinates', () => {
-    const view = { slug: 'users', kind: 'unknown' } satisfies ViewInfo
-    const bundle = {
-      ir: {
-        views: {
-          users: {
-            name: 'users',
-            auth: 'required',
-            target: {
-              kind: 'definition',
-              definitions: [{ origin: 'kernel.astrale.ai', kind: 'interface', name: 'Identity' }],
-            },
-          },
-        },
-      },
-    } as unknown as StudioSchemaBundle
-
-    expect(viewDefinitionBindings('shell.astrale.ai', view, bundle)).toEqual([
-      { className: 'Identity', classOrigin: 'kernel.astrale.ai', kind: 'interface' },
-    ])
-    expect(targetDefinition('Identity', 'kernel.astrale.ai', 'interface')).toBe(
-      '/:kernel.astrale.ai:interface.Identity',
-    )
-  })
-
-  test('preserves every exact canonical homonym and ignores short-name metadata', () => {
+describe('View target definitions', () => {
+  test('preserves every exact canonical Class target and ignores short-name metadata', () => {
     const view = {
       slug: 'named',
       kind: 'unknown',
-      viewFor: 'WrongLegacyTarget',
+      viewFor: 'WrongFallback',
     } satisfies ViewInfo
     const bundle = {
       ir: {
         views: {
           named: {
             name: 'named',
-            auth: 'required',
             target: {
               kind: 'definition',
               definitions: [
-                { origin: 'directory.example.dev', kind: 'interface', name: 'Named' },
-                { origin: 'people.example.dev', kind: 'interface', name: 'Named' },
-                { origin: 'catalog.example.dev', kind: 'class', name: 'Named' },
+                { origin: 'directory.example.dev', kind: 'class', name: 'Named' },
+                { origin: 'people.example.dev', kind: 'class', name: 'Named' },
               ],
             },
           },
         },
       },
     } as unknown as StudioSchemaBundle
-
     expect(viewDefinitionBindings('shell.astrale.ai', view, bundle)).toEqual([
-      { className: 'Named', classOrigin: 'directory.example.dev', kind: 'interface' },
-      { className: 'Named', classOrigin: 'people.example.dev', kind: 'interface' },
-      { className: 'Named', classOrigin: 'catalog.example.dev', kind: 'class' },
+      { className: 'Named', classOrigin: 'directory.example.dev', kind: 'class' },
+      { className: 'Named', classOrigin: 'people.example.dev', kind: 'class' },
     ])
   })
 
-  test('treats an exact Domain target as authoritative over legacy viewFor', () => {
+  test('treats a canonical Domain target as authoritative', () => {
     const view = { slug: 'home', kind: 'unknown', viewFor: 'User' } satisfies ViewInfo
     const bundle = {
-      ir: { views: { home: { name: 'home', auth: 'required', target: { kind: 'domain' } } } },
+      ir: { views: { home: { name: 'home', target: { kind: 'domain' } } } },
     } as unknown as StudioSchemaBundle
     expect(viewDefinitionBindings('shell.astrale.ai', view, bundle)).toEqual([])
   })
 
-  test('uses every exact fallback candidate across origin and definition-kind collisions', () => {
-    const view = { slug: 'legacy-named', kind: 'unknown', viewFor: 'Named' } satisfies ViewInfo
+  test('resolves fallback targets through local and exact imported Classes', () => {
+    const view = { slug: 'named', kind: 'unknown', viewFor: 'Named' } satisfies ViewInfo
     const bundle = {
       ir: {
         domain: 'shell.astrale.ai',
         views: {},
         classes: {
           Named: {
+            type: 'node',
+            name: 'Named',
             origin: 'shell.astrale.ai',
-            ref: { origin: 'shell.astrale.ai', kind: 'class', name: 'Named' },
-          },
-        },
-        interfaces: {
-          Named: {
-            origin: 'shell.astrale.ai',
-            ref: { origin: 'shell.astrale.ai', kind: 'interface', name: 'Named' },
+            properties: {},
+            methods: {},
           },
         },
-        imports: { Named: { origin: 'legacy.invalid', definition: 'class' } },
         importsByKey: {
-          'directory.example.dev:interface.Named': {
-            origin: 'directory.example.dev',
-            definition: 'interface',
-          },
           'catalog.example.dev:class.Named': {
             origin: 'catalog.example.dev',
-            definition: 'class',
+            ref: { origin: 'catalog.example.dev', kind: 'class', name: 'Named' },
+            key: 'catalog.example.dev:class.Named',
           },
         },
       },
     } as unknown as StudioSchemaBundle
-
     expect(viewDefinitionBindings('shell.astrale.ai', view, bundle)).toEqual([
       { className: 'Named', classOrigin: 'shell.astrale.ai', kind: 'class' },
-      { className: 'Named', classOrigin: 'shell.astrale.ai', kind: 'interface' },
-      { className: 'Named', classOrigin: 'directory.example.dev', kind: 'interface' },
       { className: 'Named', classOrigin: 'catalog.example.dev', kind: 'class' },
     ])
   })
 
-  test('uses the short-name import only for legacy bundles without an exact index', () => {
-    const view = { slug: 'legacy-users', kind: 'unknown', viewFor: 'User' } satisfies ViewInfo
-    const legacy = {
-      ir: {
-        domain: 'shell.astrale.ai',
-        views: {},
-        classes: {},
-        interfaces: {},
-        imports: { User: { origin: 'accounts.example.dev', definition: 'interface' } },
-      },
-    } as unknown as StudioSchemaBundle
-    const exact = { ir: { ...legacy.ir, importsByKey: {} } } as unknown as StudioSchemaBundle
-
-    expect(viewDefinitionBindings('shell.astrale.ai', view, legacy)).toEqual([
-      { className: 'User', classOrigin: 'accounts.example.dev', kind: 'interface' },
-    ])
-    expect(viewDefinitionBindings('shell.astrale.ai', view, exact)).toEqual([])
-  })
-
-  test('addresses exact class instances through a canonical Definition source', () => {
+  test('addresses exact Class instances through a canonical Definition source', () => {
     expect(targetDefinition('Issue', 'issues.astrale.ai')).toBe('/:issues.astrale.ai:class.Issue')
   })
 })