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

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/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/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,37 +4,12 @@ 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: {
@@ -45,24 +20,21 @@ describe('view target definitions', () => {
             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' } } } },
@@ -70,66 +42,37 @@ describe('view target definitions', () => {
     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')
   })
 })

package/studio/server/views/target.ts

@@ -61,7 +61,7 @@ export async function listViewTargets(
 
   const queried = await Promise.all(
     bindings.map(async (binding) => {
-      const definition = targetDefinition(binding.className, binding.classOrigin, binding.kind)
+      const definition = targetDefinition(binding.className, binding.classOrigin)
       const result = await runAstraleJson<RawQueryResult>(
         [
           'query',
@@ -116,21 +116,17 @@ export async function listViewTargets(
   }
 }
 
-export function targetDefinition(
-  className: string,
-  classOrigin: string,
-  kind: 'class' | 'interface' = 'class',
-): string {
-  return `/:${assertOrigin(classOrigin)}:${kind}.${assertSchemaName(className)}`
+export function targetDefinition(className: string, classOrigin: string): string {
+  return `/:${assertOrigin(classOrigin)}:class.${assertSchemaName(className)}`
 }
 
 export interface ViewDefinitionBinding {
   className: string
   classOrigin: string
-  kind: 'class' | 'interface'
+  kind: 'class'
 }
 
-/** Preserve exact canonical View target coordinates; short-name anatomy is legacy-only. */
+/** Preserve exact canonical View target coordinates. */
 export function viewDefinitionBindings(
   origin: string,
   view: ViewInfo,
@@ -140,16 +136,17 @@ export function viewDefinitionBindings(
   if (target) {
     if (target.kind === 'domain') return []
     return uniqueViewBindings(
-      target.definitions
-        .filter(
-          (definition): definition is typeof definition & { kind: 'class' | 'interface' } =>
-            definition.kind === 'class' || definition.kind === 'interface',
-        )
-        .map((definition) => ({
-          className: definition.name,
-          classOrigin: definition.origin,
-          kind: definition.kind,
-        })),
+      target.definitions.flatMap((definition) =>
+        definition.kind === 'class'
+          ? [
+              {
+                className: definition.name,
+                classOrigin: definition.origin,
+                kind: 'class' as const,
+              },
+            ]
+          : [],
+      ),
     )
   }
 
@@ -165,7 +162,6 @@ export function viewDefinitionBindings(
     names.flatMap((className) => {
       const local: ViewDefinitionBinding[] = []
       const localClass = ir.classes[className]
-      const localInterface = ir.interfaces[className]
       if (localClass) {
         local.push({
           className,
@@ -173,33 +169,11 @@ export function viewDefinitionBindings(
           kind: 'class',
         })
       }
-      if (localInterface) {
-        local.push({
-          className,
-          classOrigin: localInterface.ref?.origin ?? localInterface.origin ?? ir.domain ?? origin,
-          kind: 'interface',
-        })
-      }
-
-      if (ir.importsByKey !== undefined) {
-        const imported = Object.keys(ir.importsByKey).flatMap((key) => {
-          const binding = viewBindingFromDefinitionKey(key)
-          return binding?.className === className ? [binding] : []
-        })
-        return [...local, ...imported]
-      }
-
-      const legacy = ir.imports[className]
-      if (legacy) {
-        return [
-          ...local,
-          {
-            className,
-            classOrigin: legacy.origin,
-            kind: legacy.definition,
-          } satisfies ViewDefinitionBinding,
-        ]
-      }
+      const imported = Object.keys(ir.importsByKey).flatMap((key) => {
+        const binding = viewBindingFromDefinitionKey(key)
+        return binding?.className === className ? [binding] : []
+      })
+      if (imported.length > 0) return [...local, ...imported]
 
       return local.length > 0 ? local : [{ className, classOrigin: origin, kind: 'class' }]
     }),
@@ -211,12 +185,12 @@ function viewBindingFromDefinitionKey(key: string): ViewDefinitionBinding | null
   if (separator <= 0) return null
   const classOrigin = key.slice(0, separator)
   const ref = key.slice(separator + 1)
-  const match = /^(class|interface)\.([A-Za-z_$][\w$]*)$/.exec(ref)
+  const match = /^class\.([A-Za-z_$][\w$]*)$/.exec(ref)
   if (!match) return null
   return {
-    className: match[2]!,
+    className: match[1]!,
     classOrigin,
-    kind: match[1] as ViewDefinitionBinding['kind'],
+    kind: 'class',
   }
 }
 

package/studio/server/watch.test.ts

@@ -10,27 +10,27 @@ const handle: DomainHandle = {
   id: 'current',
   root: '/workspace/current',
   configFile: '/workspace/current/astrale.config.ts',
-  domainFile: '/workspace/current/implementation.ts',
+  applicationFile: '/workspace/current/application.ts',
   schemaDirName: 'schema',
   schemaDir: '/workspace/current/schema',
   schemaIndex: '/workspace/current/schema/index.ts',
 }
 
-test('watches current layout roots and reconciles either composition entry', () => {
-  expect(ANATOMY_PATHS).toContain('implementation.ts')
+test('watches current Application, Runtime, and vertical authoring roots', () => {
+  expect(ANATOMY_PATHS).toContain('application.ts')
+  expect(ANATOMY_PATHS).toContain('runtime.ts')
   expect(ANATOMY_PATHS).toContain('ui')
-  expect(ANATOMY_PATHS).toContain('handlers')
+  expect(ANATOMY_PATHS).toContain('providers')
   expect(ANATOMY_PATHS).toContain('queries')
   expect(ANATOMY_PATHS).toContain('workflows')
-  expect(DOMAIN_SET_TRIGGER_FILES.has('implementation.ts')).toBe(true)
-  expect(DOMAIN_SET_TRIGGER_FILES.has('domain.ts')).toBe(true)
+  expect(DOMAIN_SET_TRIGGER_FILES.has('application.ts')).toBe(true)
+  expect(DOMAIN_SET_TRIGGER_FILES.has('schema.ts')).toBe(true)
 })
 
-test('composition and handler source changes invalidate the schema bundle', () => {
-  expect(affectsBundle(handle, join(handle.root, 'implementation.ts'))).toBe(true)
-  expect(affectsBundle(handle, join(handle.root, 'domain.ts'))).toBe(true)
+test('Application, Runtime, Action, and Workflow changes invalidate the schema bundle', () => {
+  expect(affectsBundle(handle, join(handle.root, 'application.ts'))).toBe(true)
+  expect(affectsBundle(handle, join(handle.root, 'runtime.ts'))).toBe(true)
   expect(affectsBundle(handle, join(handle.root, 'actions', 'risk', 'create.ts'))).toBe(true)
-  expect(affectsBundle(handle, join(handle.root, 'functions', 'user', 'ensure.ts'))).toBe(true)
-  expect(affectsBundle(handle, join(handle.root, 'handlers', 'create.ts'))).toBe(true)
+  expect(affectsBundle(handle, join(handle.root, 'workflows', 'user', 'ensure.ts'))).toBe(true)
   expect(affectsBundle(handle, join(handle.root, 'views', 'routes.ts'))).toBe(false)
 })

package/studio/server/watch.ts

@@ -19,10 +19,9 @@ export const ANATOMY_PATHS = [...ANATOMY_GLOBS.files, ...ANATOMY_GLOBS.dirs]
 // part of the schema bundle cache even though they are outside schema/ itself.
 const BUNDLE_SOURCE_DIRS = new Set([
   'actions',
-  'capabilities',
-  'functions',
-  'handlers',
+  'integrations',
   'mutations',
+  'providers',
   'queries',
   'rules',
   'runtime',
@@ -42,7 +41,12 @@ function ignored(p: string): boolean {
 export function affectsBundle(handle: DomainHandle, path: string): boolean {
   const rel = relative(handle.root, path).split('\\').join('/')
   const topLevel = rel.split('/')[0]
-  return rel === 'implementation.ts' || rel === 'domain.ts' || BUNDLE_SOURCE_DIRS.has(topLevel)
+  return (
+    path === handle.applicationFile ||
+    rel === 'runtime.ts' ||
+    rel.endsWith('/runtime.ts') ||
+    BUNDLE_SOURCE_DIRS.has(topLevel)
+  )
 }
 
 export function watchDomain(handle: DomainHandle): () => void {

package/studio/server/workspace-watch.ts

@@ -19,8 +19,8 @@ const IGNORED =
 // only these file changes can change the domain SET (vs. ordinary in-domain edits)
 export const DOMAIN_SET_TRIGGER_FILES = new Set([
   'astrale.config.ts',
-  'implementation.ts',
-  'domain.ts',
+  'application.ts',
+  'schema.ts',
   'index.ts',
 ])