@astrale-os/cli 1.0.0-beta.12 → 1.0.0-beta.13

package/src/ui/project.ts

@@ -0,0 +1,146 @@
+import { access, lstat, readFile } from 'node:fs/promises'
+import path from 'node:path'
+
+import { UiError, type PackageManager } from './model'
+
+export type UiProject = {
+  root: string
+  packageJsonPath: string
+  packageJson: Record<string, unknown>
+  manager: PackageManager
+  lockPath?: string
+  cssPath: string
+  componentsPath: string
+  uiLockPath: string
+}
+
+const MANAGERS: readonly [string, PackageManager][] = [
+  ['pnpm-lock.yaml', 'pnpm'],
+  ['bun.lock', 'bun'],
+  ['bun.lockb', 'bun'],
+  ['yarn.lock', 'yarn'],
+  ['package-lock.json', 'npm'],
+]
+
+async function exists(target: string): Promise<boolean> {
+  return access(target).then(
+    () => true,
+    () => false,
+  )
+}
+
+export async function discoverUiProject(input = process.cwd()): Promise<UiProject> {
+  let root = path.resolve(input)
+  if (!(await exists(root))) {
+    throw new UiError('UI_PROJECT_UNSUPPORTED', 'Project path does not exist: ' + root)
+  }
+  if (!(await lstat(root)).isDirectory()) root = path.dirname(root)
+
+  while (!(await exists(path.join(root, 'package.json')))) {
+    const parent = path.dirname(root)
+    if (parent === root) {
+      throw new UiError(
+        'UI_PROJECT_UNSUPPORTED',
+        'No package.json found from ' + path.resolve(input),
+        'Run the command inside an existing React application or pass its path.',
+      )
+    }
+    root = parent
+  }
+
+  const packageJsonPath = path.join(root, 'package.json')
+  let packageJson: Record<string, unknown>
+  try {
+    packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8')) as Record<string, unknown>
+  } catch (cause) {
+    throw new UiError('UI_PROJECT_UNSUPPORTED', 'package.json is not valid JSON.', undefined, {
+      cause,
+    })
+  }
+
+  let manager: PackageManager = 'npm'
+  let lockPath: string | undefined
+  for (const [file, candidate] of MANAGERS) {
+    const target = path.join(root, file)
+    if (await exists(target)) {
+      manager = candidate
+      lockPath = target
+      break
+    }
+  }
+  const declared = packageJson.packageManager
+  if (!lockPath && typeof declared === 'string') {
+    const candidate = declared.split('@')[0]
+    if (
+      candidate === 'pnpm' ||
+      candidate === 'npm' ||
+      candidate === 'yarn' ||
+      candidate === 'bun'
+    ) {
+      manager = candidate
+    }
+  }
+  if (!lockPath) {
+    const expectedLock = {
+      pnpm: 'pnpm-lock.yaml',
+      npm: 'package-lock.json',
+      yarn: 'yarn.lock',
+      bun: 'bun.lock',
+    }[manager]
+    lockPath = path.join(root, expectedLock)
+  }
+
+  const cssCandidates = ['src/index.css', 'src/app.css', 'app/globals.css', 'src/styles.css']
+  const resolvedCss = await Promise.all(
+    cssCandidates.map(async (file) => ((await exists(path.join(root, file))) ? file : undefined)),
+  )
+  const cssRelative = resolvedCss.find(Boolean) ?? 'src/astrale-ui.css'
+
+  return {
+    root,
+    packageJsonPath,
+    packageJson,
+    manager,
+    lockPath,
+    cssPath: path.join(root, cssRelative),
+    componentsPath: path.join(root, 'components.json'),
+    uiLockPath: path.join(root, 'astrale-ui.lock.json'),
+  }
+}
+
+export function assertSupportedUiProject(project: UiProject): void {
+  const manifest = project.packageJson
+  const dependencies = {
+    ...(manifest.dependencies as Record<string, string> | undefined),
+    ...(manifest.devDependencies as Record<string, string> | undefined),
+    ...(manifest.peerDependencies as Record<string, string> | undefined),
+  }
+  if (!dependencies.react || !dependencies['react-dom']) {
+    throw new UiError(
+      'UI_PROJECT_UNSUPPORTED',
+      'Astrale UI requires an existing React application.',
+      'Install React first or choose a non-UI project scaffold.',
+    )
+  }
+  const tailwind = dependencies.tailwindcss
+  if (!tailwind || !/(?:^|[^0-9])4(?:\.|$)/u.test(tailwind)) {
+    throw new UiError(
+      'UI_PROJECT_UNSUPPORTED',
+      'Astrale UI V1 requires Tailwind CSS 4.',
+      'Upgrade Tailwind to v4 before initializing Astrale UI.',
+    )
+  }
+}
+
+export function projectRelative(project: UiProject, target: string): string {
+  const relative = path.relative(project.root, target)
+  if (
+    relative === '' ||
+    relative === '..' ||
+    relative.startsWith('..' + path.sep) ||
+    path.isAbsolute(relative)
+  ) {
+    throw new UiError('UI_LOCK_INVALID', 'Path escapes the project root: ' + target)
+  }
+  return relative.split(path.sep).join('/')
+}

package/src/ui/release.ts

@@ -0,0 +1,267 @@
+import { UiError, type UiCompatibility, type UiRegistry, type UiRelease } from './model'
+
+const NPM_PACKAGE = 'https://registry.npmjs.org/@astrale-os/ui'
+const GITHUB_API = 'https://api.github.com/repos/astrale-os/ui'
+const RAW = 'https://raw.githubusercontent.com/astrale-os/ui'
+const MAX_DOCUMENT_BYTES = 1_048_576
+const MAX_REGISTRY_DOCUMENTS = 100
+
+type Fetch = typeof fetch
+type RegistrySource = {
+  name?: string
+  homepage?: string
+  include?: string[]
+  items?: unknown[]
+}
+
+async function json<T>(fetcher: Fetch, url: string, label: string): Promise<T> {
+  let response: Response
+  try {
+    response = await fetcher(url, { headers: { accept: 'application/json' } })
+  } catch (cause) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', 'Unable to reach ' + label + '.', undefined, {
+      cause,
+    })
+  }
+  if (!response.ok) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', label + ' returned HTTP ' + response.status + '.')
+  }
+  const declaredLength = Number(response.headers.get('content-length'))
+  if (Number.isFinite(declaredLength) && declaredLength > MAX_DOCUMENT_BYTES) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', label + ' exceeds the supported response size.')
+  }
+  if (!response.body) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', label + ' returned an empty response.')
+  }
+  const reader = response.body.getReader()
+  const chunks: Uint8Array[] = []
+  let bytes = 0
+  while (true) {
+    const result = await reader.read()
+    if (result.done) break
+    bytes += result.value.byteLength
+    if (bytes > MAX_DOCUMENT_BYTES) {
+      await reader.cancel()
+      throw new UiError('UI_REGISTRY_UNAVAILABLE', label + ' exceeds the supported response size.')
+    }
+    chunks.push(result.value)
+  }
+  const body = new Uint8Array(bytes)
+  let offset = 0
+  for (const chunk of chunks) {
+    body.set(chunk, offset)
+    offset += chunk.byteLength
+  }
+  try {
+    return JSON.parse(new TextDecoder().decode(body)) as T
+  } catch (cause) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', label + ' returned malformed JSON.', undefined, {
+      cause,
+    })
+  }
+}
+
+export async function resolveUiRelease(
+  requested?: string,
+  fetcher: Fetch = fetch,
+): Promise<UiRelease> {
+  const versionDocument = requested
+    ? { version: requested.replace(/^v/u, '') }
+    : await json<{ version: string }>(fetcher, NPM_PACKAGE + '/latest', 'npm UI release')
+  const version = versionDocument.version
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u.test(version)) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', 'Invalid UI release version: ' + version)
+  }
+  const ref = 'v' + version
+  const reference = await json<{
+    object: { type: 'commit' | 'tag'; sha: string; url: string }
+  }>(fetcher, GITHUB_API + '/git/ref/tags/' + encodeURIComponent(ref), 'UI ref ' + ref)
+  const commit =
+    reference.object.type === 'commit'
+      ? reference.object.sha
+      : (
+          await json<{ object: { sha: string } }>(
+            fetcher,
+            reference.object.url,
+            'annotated UI tag ' + ref,
+          )
+        ).object.sha
+  if (!/^[0-9a-f]{40}$/u.test(commit)) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', 'UI ref ' + ref + ' did not resolve to a commit.')
+  }
+  return readUiReleaseSnapshot({ version, ref, commit }, fetcher)
+}
+
+export async function readUiReleaseSnapshot(
+  identity: Pick<UiRelease, 'version' | 'ref' | 'commit'>,
+  fetcher: Fetch = fetch,
+): Promise<UiRelease> {
+  const [compatibility, registry] = await Promise.all([
+    json<UiCompatibility>(
+      fetcher,
+      RAW + '/' + identity.commit + '/tooling/compatibility.json',
+      'UI compatibility metadata',
+    ),
+    readRegistry(identity.commit, fetcher),
+  ])
+  if (
+    compatibility.version !== 1 ||
+    compatibility.base !== 'base' ||
+    compatibility.style !== 'nova' ||
+    !/^\d+\.\d+\.\d+$/u.test(compatibility.shadcn)
+  ) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', 'UI compatibility metadata is invalid.')
+  }
+  return { ...identity, compatibility, registry }
+}
+
+async function readRegistry(commit: string, fetcher: Fetch): Promise<UiRegistry> {
+  const candidate = RAW + '/' + commit + '/registry.json'
+  const root = await json<RegistrySource>(fetcher, candidate, 'UI registry')
+  const items = await resolveRegistryItems(root, candidate, commit, fetcher, new Set([candidate]))
+  const publicItems = items.filter(
+    (item) =>
+      !(item && typeof item === 'object' && (item as { type?: unknown }).type === 'registry:base'),
+  )
+  if (!publicItems.every(isInstallableItem)) {
+    throw new UiError(
+      'UI_REGISTRY_UNAVAILABLE',
+      'UI registry contains an invalid installable item.',
+    )
+  }
+  const installable = publicItems
+  if (installable.length === 0) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', 'UI registry has no installable items.')
+  }
+  if (
+    new Set(installable.map((item) => item.name)).size !== installable.length ||
+    new Set(installable.map((item) => item.meta.canonicalAddress)).size !== installable.length
+  ) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', 'UI registry contains duplicate item identities.')
+  }
+  return { name: root.name ?? 'astrale-ui', homepage: root.homepage, items: installable }
+}
+
+async function resolveRegistryItems(
+  source: RegistrySource,
+  sourceUrl: string,
+  commit: string,
+  fetcher: Fetch,
+  visited: Set<string>,
+): Promise<unknown[]> {
+  const direct = Array.isArray(source.items) ? source.items : []
+  const includes = source.include ?? []
+  if (!Array.isArray(includes)) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', 'UI registry include must be an array.')
+  }
+  if (visited.size + includes.length > MAX_REGISTRY_DOCUMENTS) {
+    throw new UiError(
+      'UI_REGISTRY_UNAVAILABLE',
+      'UI registry contains too many included documents.',
+    )
+  }
+  const nested = await Promise.all(
+    includes.map(async (include) => {
+      if (
+        typeof include !== 'string' ||
+        include.startsWith('/') ||
+        !include.endsWith('registry.json') ||
+        include.split('/').includes('..')
+      ) {
+        throw new UiError('UI_REGISTRY_UNAVAILABLE', 'UI registry contains an unsafe include.')
+      }
+      const url = new URL(include, sourceUrl).toString()
+      const releaseRoot = RAW + '/' + commit + '/'
+      if (!url.startsWith(releaseRoot) || visited.has(url)) {
+        throw new UiError(
+          'UI_REGISTRY_UNAVAILABLE',
+          'UI registry include escaped or repeated the release snapshot.',
+        )
+      }
+      visited.add(url)
+      const child = await json<RegistrySource>(fetcher, url, 'UI registry include')
+      return resolveRegistryItems(child, url, commit, fetcher, visited)
+    }),
+  )
+  return direct.concat(nested.flat())
+}
+
+function isInstallableItem(item: unknown): item is UiRegistry['items'][number] {
+  if (!item || typeof item !== 'object') return false
+  const candidate = item as Partial<UiRegistry['items'][number]>
+  return (
+    typeof candidate.name === 'string' &&
+    /^(?:pattern|block)-[a-z0-9-]+$/u.test(candidate.name) &&
+    candidate.type === 'registry:block' &&
+    (candidate.dependencies === undefined ||
+      (Array.isArray(candidate.dependencies) &&
+        candidate.dependencies.every(
+          (dependency) =>
+            typeof dependency === 'string' &&
+            /^(?:@[a-z0-9-]+\/)?[a-z0-9-]+@[~^<>=0-9A-Za-z.* -]+$/u.test(dependency),
+        ))) &&
+    Array.isArray(candidate.files) &&
+    candidate.files.length > 0 &&
+    candidate.files.every(
+      (file) =>
+        file &&
+        typeof file.path === 'string' &&
+        isSafeRelative(file.path) &&
+        typeof file.type === 'string' &&
+        typeof file.target === 'string' &&
+        file.target.startsWith('components/astrale/') &&
+        isSafeRelative(file.target),
+    ) &&
+    typeof candidate.meta?.canonicalAddress === 'string' &&
+    /^(?:pattern|block)\/[a-z0-9-]+\/[a-z0-9-/]+$/u.test(candidate.meta.canonicalAddress)
+  )
+}
+
+export async function readUiRegistryItem(
+  release: UiRelease,
+  expected: UiRegistry['items'][number],
+  fetcher: Fetch = fetch,
+): Promise<UiRegistry['items'][number]> {
+  const item = await json<unknown>(
+    fetcher,
+    registryItemUrl(release, expected.name),
+    'UI registry item ' + expected.name,
+  )
+  if (
+    !isInstallableItem(item) ||
+    item.name !== expected.name ||
+    item.meta.canonicalAddress !== expected.meta.canonicalAddress ||
+    item.files.length !== expected.files.length ||
+    item.files.some((file, index) => {
+      const declared = expected.files[index]
+      return (
+        typeof file.content !== 'string' ||
+        file.content.length === 0 ||
+        !declared ||
+        file.path !== declared.path ||
+        file.type !== declared.type ||
+        file.target !== declared.target
+      )
+    })
+  ) {
+    throw new UiError(
+      'UI_REGISTRY_UNAVAILABLE',
+      'UI registry item ' + expected.name + ' does not match the admitted release index.',
+    )
+  }
+  return item
+}
+
+function isSafeRelative(value: string): boolean {
+  return (
+    value.length > 0 &&
+    !value.startsWith('/') &&
+    !/^[A-Za-z]:[\\/]/u.test(value) &&
+    !value.includes('\\') &&
+    !value.split('/').includes('..')
+  )
+}
+
+export function registryItemUrl(release: UiRelease, itemName: string): string {
+  return RAW + '/' + release.commit + '/registry/public/r/' + encodeURIComponent(itemName) + '.json'
+}

package/src/ui/runner.ts

@@ -0,0 +1,18 @@
+import type { PackageManager } from './model'
+
+import { run, type RunResult } from '../lib/proc'
+
+export type UiRunner = (file: string, args: string[], cwd: string) => Promise<RunResult>
+
+export const defaultUiRunner: UiRunner = (file, args, cwd) => run(file, args, { cwd })
+
+export function shadcnInvocation(
+  manager: PackageManager,
+  version: string,
+  args: string[],
+): { file: string; args: string[] } {
+  if (manager === 'pnpm') return { file: 'pnpm', args: ['dlx', 'shadcn@' + version, ...args] }
+  if (manager === 'bun') return { file: 'bunx', args: ['shadcn@' + version, ...args] }
+  if (manager === 'yarn') return { file: 'yarn', args: ['dlx', 'shadcn@' + version, ...args] }
+  return { file: 'npx', args: ['--yes', 'shadcn@' + version, ...args] }
+}

package/studio/server/agent/harness/gateway/token.test.ts

@@ -79,7 +79,7 @@ test('mints with the exact audience and instance, caches, and coalesces concurre
   expect(await broker.acquireGatewayToken(config, audience)).toBe(token)
   expect(calls).toEqual([
     {
-      args: ['token', '--audience', audience, '--ttl', '3600', '--raw', '-i', 'prod'],
+      args: ['token', '--audience', audience, '--ttl', '240', '--raw', '-i', 'prod'],
       timeoutMs: 12_000,
     },
   ])

package/studio/server/agent/harness/gateway/token.ts

@@ -12,8 +12,8 @@ import type { HarnessGatewayConfig } from '../../../../shared/types'
 
 import { captureCommand, type CapturedCommand, type CaptureOptions } from '../process'
 
-const MINT_TTL_SECONDS = 3600
-const REFRESH_SKEW_MS = 5 * 60_000
+const MINT_TTL_SECONDS = 4 * 60
+const REFRESH_SKEW_MS = 60_000
 
 interface CachedToken {
   token: string
@@ -141,7 +141,7 @@ export class HarnessTokenBroker {
       (claims.expiresAtMs !== undefined && claims.expiresAtMs <= this.now())
     )
       throw new HarnessTokenError(
-        'could not mint a delegation token — is the instance reachable and are you signed in? (try `astrale login` / `astrale use <instance>`)',
+        'could not mint a delegation token — is the instance reachable and are you signed in? (try `astrale auth login` / `astrale instance use <instance>`)',
         'mint-failed',
       )
     this.mintCache.set(key, {

package/dist/types/admin/binding.d.ts

@@ -1,19 +0,0 @@
-import type { Input } from '@astrale-os/sdk/client';
-import type { ClientSession } from '@astrale-os/sdk/client/session';
-import type { ResolvedClass, ResolvedProperty } from '@astrale-os/sdk/schema';
-import type { DomainBinding } from '@astrale-os/shell';
-import { Path } from '@astrale-os/sdk/graph/path';
-export type AdminBinding = DomainBinding;
-/** Bind the exact Admin revision installed on this source Kernel. */
-export declare function bindAdmin(session: ClientSession): Promise<AdminBinding>;
-/** Admit an injected dynamic binding as the Admin Domain. */
-export declare function requireAdminBinding(binding: AdminBinding): AdminBinding;
-/** Resolve one required Admin Class without rebuilding its schema contract. */
-export declare function requireAdminClass(binding: AdminBinding, name: string, kind: 'node'): ResolvedClass<'node'>;
-export declare function requireAdminClass(binding: AdminBinding, name: string, kind: 'edge'): ResolvedClass<'edge'>;
-/** Resolve one required Admin Core Node as its canonical projection Path. */
-export declare function requireAdminCore(binding: AdminBinding, name: string): Path;
-/** Resolve one effective Property by unambiguous member name. */
-export declare function requireAdminProperty(owner: ResolvedClass, name: string): ResolvedProperty<unknown>;
-/** Invoke one resolved executable instance Method through Kernel Client. */
-export declare function invokeAdminMethod(session: ClientSession, binding: AdminBinding, owner: ResolvedClass<'node'>, name: string, receiver: Path, input: Input): Promise<unknown>;

package/src/admin/__tests__/binding.test.ts

@@ -1,31 +0,0 @@
-import type { ClientSession } from '@astrale-os/sdk/client/session'
-
-import { bundle, defineSchema, schema as schemaApi } from '@astrale-os/sdk/schema'
-import { expect, mock, test } from 'bun:test'
-
-import { releaseFor } from '../../__tests__/fixtures/publication'
-import { bindAdmin } from '../binding'
-
-const schema = defineSchema('admin.astrale.ai', {})
-const release = releaseFor(schema, 'https://admin.beta.astrale.ai')
-
-test('binds the installed Admin Domain instead of the source Kernel publication', async () => {
-  const installation = mock(async () => ({
-    state: 'ready' as const,
-    target: 'sha256:admin-target' as const,
-    source: { kind: 'remote' as const, publication: release.publication },
-    bundle: bundle.create(schema),
-    readiness: 'sha256:admin-readiness' as const,
-    capabilities: { requested: [], materialized: [] },
-  }))
-  const session = {
-    installation,
-    bind: (domain: unknown) => ({ domain, graph: {} }),
-  } as unknown as ClientSession
-
-  const binding = await bindAdmin(session)
-
-  expect(installation).toHaveBeenCalledWith('admin.astrale.ai')
-  expect(binding.domain.origin).toBe('admin.astrale.ai')
-  expect(binding.domain.revision).toBe(schemaApi.revision(schema))
-})

package/src/admin/binding.ts

@@ -1,98 +0,0 @@
-import type { Input } from '@astrale-os/sdk/client'
-import type { ClientSession } from '@astrale-os/sdk/client/session'
-import type {
-  ResolvedClass,
-  ResolvedCoreDefinition,
-  ResolvedMethod,
-  ResolvedProperty,
-} from '@astrale-os/sdk/schema'
-import type { DomainBinding } from '@astrale-os/shell'
-
-import { reference } from '@astrale-os/sdk/client/session'
-import { Path } from '@astrale-os/sdk/graph/path'
-import { bindDomain } from '@astrale-os/shell'
-
-const ADMIN_ORIGIN = 'admin.astrale.ai'
-
-export type AdminBinding = DomainBinding
-
-/** Bind the exact Admin revision installed on this source Kernel. */
-export async function bindAdmin(session: ClientSession): Promise<AdminBinding> {
-  const installed = await session.installation(ADMIN_ORIGIN)
-  return requireAdminBinding(await bindDomain(session, installed.bundle.root))
-}
-
-/** Admit an injected dynamic binding as the Admin Domain. */
-export function requireAdminBinding(binding: AdminBinding): AdminBinding {
-  if (binding.domain.origin !== ADMIN_ORIGIN) {
-    throw new TypeError('Configured Admin target does not serve the Admin Domain.')
-  }
-  return binding
-}
-
-/** Resolve one required Admin Class without rebuilding its schema contract. */
-export function requireAdminClass(
-  binding: AdminBinding,
-  name: string,
-  kind: 'node',
-): ResolvedClass<'node'>
-export function requireAdminClass(
-  binding: AdminBinding,
-  name: string,
-  kind: 'edge',
-): ResolvedClass<'edge'>
-export function requireAdminClass(
-  binding: AdminBinding,
-  name: string,
-  kind: 'node' | 'edge',
-): ResolvedClass<'node'> | ResolvedClass<'edge'> {
-  const selected = binding.domain.classes[name]
-  if (selected?.kind !== kind) throw new TypeError(`Admin ${name} is not a ${kind} Class.`)
-  return selected
-}
-
-/** Resolve one required Admin Core Node as its canonical projection Path. */
-export function requireAdminCore(binding: AdminBinding, name: string): Path {
-  const selected = binding.domain.core.nodes[name] as ResolvedCoreDefinition | undefined
-  if (selected === undefined) throw new TypeError(`Admin has no Core Node ${name}.`)
-  return Path.project(selected.ref)
-}
-
-/** Resolve one effective Property by unambiguous member name. */
-export function requireAdminProperty(
-  owner: ResolvedClass,
-  name: string,
-): ResolvedProperty<unknown> {
-  const selected = [...owner.properties].find((property) => property.name === name)
-  if (selected === undefined) {
-    throw new TypeError(`Admin ${owner.ref.name}.${name} Property is absent.`)
-  }
-  return selected
-}
-
-/** Invoke one resolved executable instance Method through Kernel Client. */
-export async function invokeAdminMethod(
-  session: ClientSession,
-  binding: AdminBinding,
-  owner: ResolvedClass<'node'>,
-  name: string,
-  receiver: Path,
-  input: Input,
-): Promise<unknown> {
-  const method = [...owner.methods].find((candidate) => candidate.name === name)
-  if (method === undefined || !isExecutableInstanceMethod(method)) {
-    throw new TypeError(`Admin ${owner.ref.name}.${name} is not an executable instance Method.`)
-  }
-  return session.invoke(reference(binding.domain, method)(receiver), input)
-}
-
-type ExecutableInstanceMethod = ResolvedMethod<
-  unknown,
-  unknown,
-  false,
-  Exclude<ResolvedMethod['inheritance'], 'abstract'>
->
-
-function isExecutableInstanceMethod(method: ResolvedMethod): method is ExecutableInstanceMethod {
-  return method.static === false && method.inheritance !== 'abstract'
-}