@astrale-os/cli 0.8.1-alpha.0 → 0.8.1-alpha.2

package/src/connection/session.ts

@@ -0,0 +1,176 @@
+import type { AuthApi } from '@astrale-os/kernel-client/auth'
+import type { GraphApi } from '@astrale-os/kernel-client/graph'
+import type { ClientSessionOptions, SessionAuth } from '@astrale-os/kernel-client/session'
+
+import { call } from '@astrale-os/kernel-client'
+import { createAuth } from '@astrale-os/kernel-client/auth'
+import { createGraph } from '@astrale-os/kernel-client/graph'
+import { ClientSession } from '@astrale-os/kernel-client/session'
+
+import type { AstraleConfig } from '../lib/config'
+import type { AdminConnectionOptions, ConnectionOptions, ConnectionTarget } from './target'
+
+import {
+  AdminInstanceNotFoundError,
+  connectAdminInstances,
+  findOwnedInstance,
+  type InstanceInfo,
+} from '../admin/instance'
+import { AstraleError } from '../errors'
+import { fetchWithCaFile } from '../lib/ca-fetch'
+import { readConfig } from '../lib/config'
+import { createCliCredential, validateCredentialSelection } from './credential'
+import { resolveAdminConnectionTarget, resolveConnectionTarget } from './target'
+
+const DEFAULT_TIMEOUT_MS = 30_000
+const MAXIMUM_ROUTE_AGE_MS = 5 * 60_000
+
+export interface ConnectionContext {
+  readonly session: ClientSession
+  readonly graph: GraphApi
+  readonly auth: AuthApi
+  readonly target: ConnectionTarget
+}
+
+interface OwnedConnection {
+  readonly context: ConnectionContext
+  close(): void
+}
+
+export type ConnectionFactory = (
+  target: ConnectionTarget,
+  timeoutMs: number,
+  options: ConnectionOptions,
+  config: AstraleConfig,
+) => OwnedConnection
+
+/** Resolve one ordinary target, run a command action, then close terminally. */
+export async function withClientSession<Value>(
+  options: ConnectionOptions,
+  action: (context: ConnectionContext) => Promise<Value>,
+): Promise<Value> {
+  validateCredentialSelection(options)
+  const timeoutMs = resolveTimeoutMs(options.timeout)
+  const config = await readConfig()
+  const target = await resolveConnectionTarget(options, config, {
+    managed: (slug) => lookupManagedInstance(slug, options),
+  })
+  return runResolvedClientSession(target, timeoutMs, options, config, action, openConnection)
+}
+
+/** Resolve the configured Admin Domain target under the same terminal lifecycle. */
+export async function withAdminClientSession<Value>(
+  options: AdminConnectionOptions,
+  action: (context: ConnectionContext) => Promise<Value>,
+): Promise<Value> {
+  validateCredentialSelection(options)
+  const timeoutMs = resolveTimeoutMs(options.timeout)
+  const config = await readConfig()
+  const target = await resolveAdminConnectionTarget(options, config)
+  return runResolvedClientSession(target, timeoutMs, options, config, action, openConnection)
+}
+
+/** Owner-private seam used to prove validation order and cleanup without network I/O. */
+export async function withResolvedClientSession<Value>(
+  target: ConnectionTarget,
+  options: ConnectionOptions,
+  config: AstraleConfig,
+  action: (context: ConnectionContext) => Promise<Value>,
+  open: ConnectionFactory = openConnection,
+): Promise<Value> {
+  validateCredentialSelection(options)
+  const timeoutMs = resolveTimeoutMs(options.timeout)
+  return runResolvedClientSession(target, timeoutMs, options, config, action, open)
+}
+
+async function runResolvedClientSession<Value>(
+  target: ConnectionTarget,
+  timeoutMs: number,
+  options: ConnectionOptions,
+  config: AstraleConfig,
+  action: (context: ConnectionContext) => Promise<Value>,
+  open: ConnectionFactory,
+): Promise<Value> {
+  const connection = open(target, timeoutMs, options, config)
+  try {
+    return await action(connection.context)
+  } catch (error) {
+    if (error instanceof Error) (error as Error & { url?: string }).url = target.url
+    throw error
+  } finally {
+    connection.close()
+  }
+}
+
+export function resolveTimeoutMs(raw: string | undefined): number {
+  if (raw === undefined) return DEFAULT_TIMEOUT_MS
+  if (!/^\d+$/.test(raw)) {
+    throw new AstraleError(
+      'INVALID_FLAG',
+      `Invalid --timeout value "${raw}" — expected a positive integer (milliseconds)`,
+    )
+  }
+  const value = Number.parseInt(raw, 10)
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new AstraleError(
+      'INVALID_FLAG',
+      `Invalid --timeout value "${raw}" — must be a positive integer`,
+    )
+  }
+  return value
+}
+
+function openConnection(
+  target: ConnectionTarget,
+  timeoutMs: number,
+  options: ConnectionOptions,
+  config: AstraleConfig,
+): OwnedConnection {
+  const fetch = target.caFile === undefined ? globalThis.fetch : fetchWithCaFile(target.caFile)
+  const auth = createCliCredential(target, options, config, fetch, timeoutMs)
+  const session = new ClientSession(createClientSessionOptions(target, fetch, auth, timeoutMs))
+  const graph = createGraph((call, request) => session.call(call, request))
+  const authApi = createAuth((path, input, request) => session.call(call(path, input), request))
+  return {
+    context: Object.freeze({ session, graph, auth: authApi, target }),
+    close() {
+      session.close()
+    },
+  }
+}
+
+/** Owner-private construction seam proving that transport and source identity stay distinct. */
+export function createClientSessionOptions(
+  target: ConnectionTarget,
+  fetch: NonNullable<ClientSessionOptions['fetch']>,
+  auth: SessionAuth | undefined,
+  timeoutMs: number,
+): ClientSessionOptions {
+  return {
+    kernel: target.kernelIssuer,
+    fetch,
+    ...(auth === undefined ? {} : { auth }),
+    policy: {
+      maximumRouteAgeMs: MAXIMUM_ROUTE_AGE_MS,
+      ...(new URL(target.url).protocol === 'http:' ? { allowInsecureHttp: true } : {}),
+    },
+    envelopeTransport: 'http',
+    timeoutMs,
+  }
+}
+
+export async function lookupManagedInstance(
+  slug: string,
+  options: ConnectionOptions,
+  openAdmin: typeof withAdminClientSession = withAdminClientSession,
+  connect: typeof connectAdminInstances = connectAdminInstances,
+): Promise<InstanceInfo> {
+  return openAdmin(
+    Object.freeze(options.timeout === undefined ? {} : { timeout: options.timeout }),
+    async (context) => {
+      const found = findOwnedInstance(await (await connect(context)).list(), slug)
+      if (found === undefined) throw new AdminInstanceNotFoundError(slug)
+      return found
+    },
+  )
+}

package/src/connection/target.ts

@@ -0,0 +1,111 @@
+import type { IssuerId } from '@astrale-os/sdk/auth'
+
+import { issuer } from '@astrale-os/sdk/auth'
+
+import type { InstanceInfo } from '../lib/admin-instance'
+import type { AdminTargetCommandOpts } from '../lib/admin-target'
+import type { AstraleConfig } from '../lib/config'
+import type { InstanceStore } from '../lib/instance'
+import type { ResolvedInstanceTarget } from '../lib/instance-target'
+
+import { resolveInstanceTarget } from '../lib/instance-target'
+
+export interface ConnectionOptions {
+  readonly url?: string
+  readonly instance?: string
+  readonly timeout?: string
+  readonly as?: string
+  readonly creds?: string
+  readonly anonymous?: boolean
+}
+
+export interface AdminConnectionOptions extends ConnectionOptions {
+  readonly admin?: string
+  readonly adminUrl?: string
+  readonly domainIssuer?: string
+}
+
+export interface ConnectionTarget {
+  readonly url: string
+  readonly kernelIssuer: IssuerId
+  readonly domainIssuer?: IssuerId
+  readonly slug?: string
+  readonly defaultIdentity?: string
+  readonly caFile?: string
+}
+
+export interface TargetDependencies {
+  readonly instances?: InstanceStore
+  readonly managed?: (slug: string) => Promise<InstanceInfo>
+}
+
+/** Stable local identity-registration key for the exact selected source Kernel. */
+export function registrationKeyForTarget(target: ConnectionTarget): string {
+  return target.slug ?? target.url
+}
+
+/** Resolve the existing URL / instance / active precedence into one exact source Kernel. */
+export async function resolveConnectionTarget(
+  options: ConnectionOptions,
+  config: AstraleConfig,
+  dependencies: TargetDependencies = {},
+): Promise<ConnectionTarget> {
+  const request =
+    options.url !== undefined && options.instance === undefined
+      ? ({ source: 'url', url: options.url } as const)
+      : options.instance !== undefined
+        ? ({ source: 'name', name: options.instance } as const)
+        : ({ source: 'active' } as const)
+  const resolved = await resolveInstanceTarget(request, {
+    config,
+    ...(dependencies.instances === undefined ? {} : { instances: dependencies.instances }),
+    admin: {},
+    ...(dependencies.managed === undefined ? {} : { managed: dependencies.managed }),
+  })
+  return connectionTarget(resolved, options.url)
+}
+
+/** Resolve the configured Admin Domain target without entering managed-instance discovery. */
+export async function resolveAdminConnectionTarget(
+  options: AdminConnectionOptions,
+  config: AstraleConfig,
+  instances?: InstanceStore,
+): Promise<ConnectionTarget> {
+  const resolved = await resolveInstanceTarget(
+    { source: 'admin' },
+    {
+      config,
+      admin: adminLookupOptions(options),
+      ...(instances === undefined ? {} : { instances }),
+    },
+  )
+  return connectionTarget(resolved)
+}
+
+export function adminLookupOptions(options: AdminConnectionOptions): AdminTargetCommandOpts {
+  return {
+    ...(options.admin === undefined ? {} : { admin: options.admin }),
+    ...(options.adminUrl === undefined ? {} : { adminUrl: options.adminUrl }),
+    ...(options.domainIssuer === undefined ? {} : { domainIssuer: options.domainIssuer }),
+    ...(options.instance === undefined ? {} : { instance: options.instance }),
+    ...(options.url === undefined ? {} : { url: options.url }),
+  }
+}
+
+function connectionTarget(
+  resolved: ResolvedInstanceTarget,
+  urlOverride?: string,
+): ConnectionTarget {
+  return Object.freeze({
+    url: urlOverride ?? resolved.url,
+    kernelIssuer: issuer.accept(resolved.kernelIssuer),
+    ...(resolved.domainIssuer === undefined
+      ? {}
+      : { domainIssuer: issuer.accept(resolved.domainIssuer) }),
+    ...(resolved.name === undefined ? {} : { slug: resolved.name }),
+    ...(resolved.defaultIdentity === undefined
+      ? {}
+      : { defaultIdentity: resolved.defaultIdentity }),
+    ...(resolved.caFile === undefined ? {} : { caFile: resolved.caFile }),
+  })
+}

package/src/connection/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": { "types": ["@types/node"] },
+  "include": ["*.ts"],
+  "exclude": ["__tests__"]
+}

package/src/graph/.spec/api.d.ts

@@ -0,0 +1,34 @@
+import type { MutationAST } from '@astrale-os/sdk/mutation'
+import type { QueryAST, QueryDirection } from '@astrale-os/sdk/query'
+
+/** Untrusted CLI fields used to author or admit one exact Query V5 request. */
+export interface QueryCommandInput {
+  readonly sources: readonly string[]
+  readonly definition?: string
+  readonly ast?: unknown
+  readonly edge?: string
+  readonly direction?: QueryDirection
+  readonly limit?: string
+  readonly cursor?: string
+}
+
+/** Canonical query plus the caller-bound continuation token kept outside the AST. */
+export interface PreparedQuery {
+  readonly ast: QueryAST
+  readonly cursor?: string
+}
+
+/** Admit canonical Query V5 or author its supported Path/Definition/one-edge CLI subset. */
+export function prepareQuery(input: QueryCommandInput): PreparedQuery
+
+/** Admit canonical Mutation V2 or its exact authoring input; legacy PatchData is rejected. */
+export function prepareMutation(input: unknown): MutationAST
+
+/** Return the user-facing leaf of one exact qualified Property key. */
+export function unqualifyProperty(key: string): string
+
+/** Read one property by exact key first, then by its qualified leaf name. */
+export function nodeProperty(
+  node: { readonly props: Readonly<Record<string, unknown>> } | null | undefined,
+  name: string,
+): unknown

package/src/graph/.spec/laws/documents.ts

@@ -0,0 +1,24 @@
+import { defineLaw } from '@astrale-os/spec/authoring'
+
+export const CLI_GRAPH_QUERY_V5 = defineLaw({
+  id: 'CLI-GRAPH-QUERY-V5',
+  statement:
+    'CLI query input becomes exactly one canonical Query V5 document with an explicit finite limit; exact Property ordering and Node or Edge projection profiles are admitted through the canonical AST surface, while legacy versions and unsupported selector combinations fail before a Graph call.',
+  tests: [
+    { file: '__tests__/query.test.ts', id: 'TEST-CLI-GRAPH-AUTHORS-QUERY-V5' },
+    { file: '__tests__/query.test.ts', id: 'TEST-CLI-GRAPH-AUTHORS-DEFINITION-QUERY' },
+    { file: '__tests__/query.test.ts', id: 'TEST-CLI-GRAPH-ADMITS-QUERY-V5-ORDERING' },
+    { file: '__tests__/query.test.ts', id: 'TEST-CLI-GRAPH-ADMITS-QUERY-V5-PROJECTIONS' },
+    { file: '__tests__/query.test.ts', id: 'TEST-CLI-GRAPH-REJECTS-LEGACY-QUERY' },
+  ],
+})
+
+export const CLI_GRAPH_MUTATION_V2 = defineLaw({
+  id: 'CLI-GRAPH-MUTATION-V2',
+  statement:
+    'CLI mutation input is admitted as canonical Mutation V2 or its exact authoring input; PatchData and other historical shapes never reach GraphApi.mutate.',
+  tests: [
+    { file: '__tests__/mutation.test.ts', id: 'TEST-CLI-GRAPH-ADMITS-MUTATION-V2' },
+    { file: '__tests__/mutation.test.ts', id: 'TEST-CLI-GRAPH-REJECTS-PATCH-DATA' },
+  ],
+})

package/src/graph/.spec/laws/projection.ts

@@ -0,0 +1,13 @@
+import { defineLaw } from '@astrale-os/spec/authoring'
+
+export const CLI_GRAPH_PROPERTY_PROJECTION = defineLaw({
+  id: 'CLI-GRAPH-PROPERTY-PROJECTION',
+  statement:
+    'An exact property key wins over a qualified leaf-name match; otherwise the first canonical property with that leaf is presented without rewriting the Node.',
+  tests: [
+    {
+      file: '__tests__/projection.test.ts',
+      id: 'TEST-CLI-GRAPH-PROJECTS-QUALIFIED-PROPERTIES',
+    },
+  ],
+})

package/src/graph/.spec/layout.ts

@@ -0,0 +1,6 @@
+import { defineLayout } from '@astrale-os/spec/authoring'
+
+export default defineLayout({
+  entries: ['__tests__/', 'index.ts', 'mutation.ts', 'projection.ts', 'query.ts', 'tsconfig.json'],
+  exact: true,
+})

package/src/graph/__tests__/mutation.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from 'bun:test'
+
+import { prepareMutation } from '../mutation'
+
+describe('prepareMutation', () => {
+  /** @evidence TEST-CLI-GRAPH-ADMITS-MUTATION-V3 */
+  test('creates one canonical Mutation V3 document from exact authoring input', () => {
+    expect(
+      JSON.parse(
+        JSON.stringify(
+          prepareMutation({
+            preconditions: [],
+            operations: [
+              {
+                op: 'node.create',
+                as: 'note',
+                class: '/:notes.example.dev:class.Note',
+                props: {},
+              },
+            ],
+          }),
+        ),
+      ),
+    ).toEqual({
+      format: 'astrale.graph.mutation',
+      version: 'v3',
+      preconditions: [],
+      operations: [
+        {
+          op: 'node.create',
+          as: 'note',
+          class: '/:notes.example.dev:class.Note',
+          props: {},
+        },
+      ],
+    })
+  })
+
+  /** @evidence TEST-CLI-GRAPH-REJECTS-PATCH-DATA */
+  test('rejects legacy PatchData instead of narrowing it', () => {
+    expect(() => prepareMutation({ nodes: { create: [] }, edges: { create: [] } })).toThrow()
+  })
+})

package/src/graph/__tests__/projection.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, test } from 'bun:test'
+
+import { nodeProperty, unqualifyProperty } from '../projection'
+
+describe('graph presentation properties', () => {
+  /** @evidence TEST-CLI-GRAPH-PROJECTS-QUALIFIED-PROPERTIES */
+  test('prefers exact keys and otherwise projects a qualified leaf', () => {
+    const node = {
+      props: {
+        name: 'exact',
+        '/:example.test:class.Widget.property.name': 'qualified',
+        '/:example.test:class.Widget.property.description': 'shown',
+      },
+    }
+
+    expect(nodeProperty(node, 'name')).toBe('exact')
+    expect(nodeProperty(node, 'description')).toBe('shown')
+    expect(unqualifyProperty('/:example.test:class.Widget.property.description')).toBe(
+      'description',
+    )
+  })
+})

package/src/graph/__tests__/query.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, test } from 'bun:test'
+
+import { prepareQuery } from '../query'
+
+describe('prepareQuery', () => {
+  /** @evidence TEST-CLI-GRAPH-AUTHORS-QUERY-V6 */
+  test('authors the supported Path and exact-edge subset as canonical Query V6', () => {
+    const prepared = prepareQuery({
+      sources: ['/:notes.example.dev:class.Note'],
+      edge: '/:notes.example.dev:class.references',
+      direction: 'incoming',
+      limit: '25',
+      cursor: 'next-page',
+    })
+
+    expect(JSON.parse(JSON.stringify(prepared))).toEqual({
+      ast: {
+        format: 'astrale.graph.query',
+        version: 'v6',
+        source: {
+          kind: 'node',
+          terms: [{ kind: 'path', path: '/:notes.example.dev:class.Note' }],
+          binding: 'n0',
+        },
+        steps: [
+          {
+            op: 'expand',
+            from: 'n0',
+            via: [{ origin: 'notes.example.dev', kind: 'class', name: 'references' }],
+            direction: 'incoming',
+            bindings: { edge: 'e0', node: 'n1' },
+          },
+        ],
+        select: { kind: 'graph', binding: 'n1' },
+      },
+      page: { size: 25, after: 'next-page' },
+    })
+  })
+
+  /** @evidence TEST-CLI-GRAPH-AUTHORS-DEFINITION-QUERY */
+  test('authors an exact Definition source without backend query text', () => {
+    const prepared = prepareQuery({
+      sources: [],
+      definition: '/:issues.astrale.ai:class.Issue',
+      limit: '201',
+    })
+
+    expect(JSON.parse(JSON.stringify(prepared.ast))).toEqual({
+      format: 'astrale.graph.query',
+      version: 'v6',
+      source: {
+        kind: 'node',
+        terms: [
+          {
+            kind: 'definition',
+            definition: { origin: 'issues.astrale.ai', kind: 'class', name: 'Issue' },
+          },
+        ],
+        binding: 'n0',
+      },
+      steps: [],
+      select: { kind: 'graph', binding: 'n0' },
+    })
+    expect(prepared.page).toEqual({ size: 201 })
+  })
+
+  /** @evidence TEST-CLI-GRAPH-ADMITS-QUERY-V6-ORDERING */
+  test('admits one exact Property-ordered Query V6 document', () => {
+    const ast = {
+      format: 'astrale.graph.query',
+      version: 'v6',
+      source: {
+        kind: 'node',
+        terms: [
+          {
+            kind: 'definition',
+            definition: { origin: 'notes.example.dev', kind: 'class', name: 'Note' },
+          },
+        ],
+        binding: 'n0',
+      },
+      steps: [],
+      select: {
+        kind: 'graph',
+        binding: 'n0',
+        order: {
+          property: 'notes.example.dev:class.Note.property.sequence',
+          direction: 'desc',
+          unranked: 'last',
+        },
+      },
+    }
+
+    const prepared = prepareQuery({ sources: [], ast, limit: '3' })
+    expect(JSON.parse(JSON.stringify(prepared.ast))).toEqual(ast)
+    expect(prepared.page).toEqual({ size: 3 })
+  })
+
+  /** @evidence TEST-CLI-GRAPH-ADMITS-QUERY-V6-PROJECTIONS */
+  test('admits exact Node and Edge projection profiles in Query V6 documents', () => {
+    const source = {
+      terms: [{ kind: 'path', path: '/:notes.example.dev:class.Note' }],
+      binding: 'n0',
+      kind: 'node',
+    } as const
+    const node = {
+      format: 'astrale.graph.query',
+      version: 'v6',
+      source,
+      steps: [],
+      select: { kind: 'nodes', binding: 'n0', projection: { kind: 'reference' } },
+    }
+    const edge = {
+      format: 'astrale.graph.query',
+      version: 'v6',
+      source,
+      steps: [
+        {
+          op: 'expand',
+          from: 'n0',
+          via: [{ origin: 'notes.example.dev', kind: 'class', name: 'references' }],
+          direction: 'outgoing',
+          bindings: { edge: 'e0', node: 'n1' },
+        },
+      ],
+      select: {
+        kind: 'edges',
+        binding: 'e0',
+        projection: { edge: 'value', source: 'reference', target: 'value' },
+      },
+    }
+
+    expect(
+      JSON.parse(JSON.stringify(prepareQuery({ sources: [], ast: node, limit: '5' }).ast)),
+    ).toEqual(node)
+    expect(
+      JSON.parse(JSON.stringify(prepareQuery({ sources: [], ast: edge, limit: '5' }).ast)),
+    ).toEqual(edge)
+  })
+
+  /** @evidence TEST-CLI-GRAPH-REJECTS-LEGACY-QUERY */
+  test('rejects V1 queries and unsupported combinations locally', () => {
+    expect(() => prepareQuery({ sources: [], ast: { version: 1, from: ['/'] } })).toThrow()
+    expect(() =>
+      prepareQuery({ sources: ['/:notes.example.dev:class.Note'], direction: 'incident' }),
+    ).toThrow('--direction requires --edge')
+    expect(() =>
+      prepareQuery({ sources: ['/:notes.example.dev:class.Note'], limit: 'all' }),
+    ).toThrow('--limit must be a positive integer')
+    expect(() =>
+      prepareQuery({ sources: [], definition: '/:notes.example.dev:view.note' }),
+    ).toThrow('--definition must be one canonical Class or Interface Path')
+  })
+})

package/src/graph/index.ts

@@ -0,0 +1,3 @@
+export { prepareMutation } from './mutation'
+export { nodeProperty, unqualifyProperty } from './projection'
+export { prepareQuery, type PreparedQuery, type QueryCommandInput } from './query'

package/src/graph/mutation.ts

@@ -0,0 +1,18 @@
+import type { MutationAST as MutationASTValue, MutationInput } from '@astrale-os/sdk/mutation'
+
+import { MutationAST } from '@astrale-os/sdk/mutation'
+
+/** Admit the canonical document or Core's exact rich authoring input at the CLI JSON boundary. */
+export function prepareMutation(input: unknown): MutationASTValue {
+  if (isCanonicalCandidate(input)) return MutationAST.decode(input)
+  return MutationAST.create(input as MutationInput)
+}
+
+function isCanonicalCandidate(input: unknown): boolean {
+  return (
+    input !== null &&
+    typeof input === 'object' &&
+    !Array.isArray(input) &&
+    (Object.hasOwn(input, 'format') || Object.hasOwn(input, 'version'))
+  )
+}

package/src/graph/projection.ts

@@ -0,0 +1,21 @@
+/** Strip a fully-qualified Property key to the leaf used by CLI presentation. */
+export function unqualifyProperty(key: string): string {
+  const property = key.lastIndexOf('.property.')
+  if (property >= 0) return key.slice(property + '.property.'.length)
+  const slash = key.lastIndexOf('/')
+  return slash >= 0 ? key.slice(slash + 1) : key
+}
+
+/** Read an exact key first, then one canonical qualified key with the requested leaf. */
+export function nodeProperty(
+  node: { readonly props: Readonly<Record<string, unknown>> } | null | undefined,
+  name: string,
+): unknown {
+  const props = node?.props
+  if (props === undefined) return undefined
+  if (Object.hasOwn(props, name)) return props[name]
+  for (const [key, value] of Object.entries(props)) {
+    if (unqualifyProperty(key) === name) return value
+  }
+  return undefined
+}