@astrale-os/cli 0.8.1-alpha.7 → 1.0.0-beta.0

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

@@ -0,0 +1,72 @@
+import { expect, test } from 'bun:test'
+
+import type { SchemaIR } from '../../shared/types'
+
+import { buildOverlay } from './overlay'
+
+test('preserves homonymous and cross-kind imports from the exact index', () => {
+  const ir = {
+    version: 'v1',
+    domain: 'app.example',
+    types: {},
+    interfaces: {},
+    classes: {},
+    functions: {},
+    imports: {},
+    importsByKey: {
+      'a.example:interface.Shared': {
+        origin: 'a.example',
+        definition: 'interface',
+        ref: { origin: 'a.example', kind: 'interface', name: 'Shared' },
+        key: 'a.example:interface.Shared',
+      },
+      'b.example:interface.Shared': {
+        origin: 'b.example',
+        definition: 'interface',
+        ref: { origin: 'b.example', kind: 'interface', name: 'Shared' },
+        key: 'b.example:interface.Shared',
+      },
+      'a.example:class.Shared': {
+        origin: 'a.example',
+        definition: 'class',
+        ref: { origin: 'a.example', kind: 'class', name: 'Shared' },
+        key: 'a.example:class.Shared',
+      },
+      'kernel.astrale.ai:interface.Identity': {
+        origin: 'kernel.astrale.ai',
+        definition: 'interface',
+        ref: { origin: 'kernel.astrale.ai', kind: 'interface', name: 'Identity' },
+        key: 'kernel.astrale.ai:interface.Identity',
+      },
+    },
+  } satisfies SchemaIR
+
+  const overlay = buildOverlay({ ir, domainRoot: '', schemaDir: '' })
+
+  expect(overlay.crossDomainImports).toEqual([
+    { name: 'Shared', origin: 'a.example', definition: 'interface' },
+    { name: 'Shared', origin: 'b.example', definition: 'interface' },
+    { name: 'Shared', origin: 'a.example', definition: 'class' },
+  ])
+  expect(overlay.mixins).toEqual([
+    { name: 'Identity', origin: 'kernel.astrale.ai', definition: 'interface' },
+  ])
+})
+
+test('retains the legacy short-name import fallback', () => {
+  const ir = {
+    version: 'legacy',
+    domain: 'app.example',
+    types: {},
+    interfaces: {},
+    classes: {},
+    functions: {},
+    imports: {
+      Identity: { origin: 'kernel.astrale.ai', definition: 'interface' },
+    },
+  } satisfies SchemaIR
+
+  expect(buildOverlay({ ir, domainRoot: '', schemaDir: '' }).mixins).toEqual([
+    { name: 'Identity', origin: 'kernel.astrale.ai', definition: 'interface' },
+  ])
+})

package/studio/server/introspect/overlay.ts

@@ -2,7 +2,8 @@
  * overlay.ts — the Studio overlay over the DSL IR. Computes what the IR cannot
  * carry. The imports split + requires/postInstall are done here (pure / light
  * static parse). handlerLinks, sourceSpans (+JSDoc) and annotations are filled
- * by a ts-morph pass over schema/*.ts, domain.ts and runtime/index.ts.
+ * by a ts-morph pass over the current implementation/schema files, with legacy
+ * domain.ts and runtime/index.ts support retained.
  */
 import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
@@ -21,13 +22,19 @@ export function buildOverlay({ ir, domainRoot, schemaDir }: OverlayArgs): Schema
   const origin = ir?.domain ?? ''
   const mixins: CrossDomainImport[] = []
   const crossDomainImports: CrossDomainImport[] = []
-  for (const [name, d] of Object.entries(ir?.imports ?? {})) {
+  const imports =
+    ir?.importsByKey !== undefined
+      ? Object.values(ir.importsByKey).flatMap((descriptor) =>
+          descriptor.ref ? [[descriptor.ref.name, descriptor] as const] : [],
+        )
+      : Object.entries(ir?.imports ?? {})
+  for (const [name, d] of imports) {
     const entry: CrossDomainImport = { name, origin: d.origin, definition: d.definition }
     if (d.origin === 'kernel.astrale.ai') mixins.push(entry)
     else crossDomainImports.push(entry)
   }
 
-  const { requires, postInstall } = parseDomainTs(domainRoot, origin)
+  const { requires, postInstall } = parseCompositionEntry(domainRoot, origin)
 
   return {
     origin,
@@ -41,11 +48,14 @@ export function buildOverlay({ ir, domainRoot, schemaDir }: OverlayArgs): Schema
   }
 }
 
-function parseDomainTs(root: string, origin: string): { requires: string[]; postInstall?: string } {
-  const f = join(root, 'domain.ts')
+function parseCompositionEntry(
+  root: string,
+  origin: string,
+): { requires: string[]; postInstall?: string } {
+  const f = ['implementation.ts', 'domain.ts'].map((file) => join(root, file)).find(existsSync)
   let requires: string[] = []
   let postInstall: string | undefined
-  if (existsSync(f)) {
+  if (f) {
     const src = readFileSync(f, 'utf8')
     const rm = src.match(/requires\s*:\s*\[([^\]]*)\]/)
     if (rm) requires = [...rm[1].matchAll(/['"`]([^'"`]+)['"`]/g)].map((x) => x[1])

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

@@ -0,0 +1,217 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import type { DomainHandle } from '../domain'
+
+import { buildBundle } from './bundle'
+import { schemaHashOf } from './hash'
+import { coreExtract, runtimeExtract } from './runtime'
+
+const roots: string[] = []
+
+afterEach(() => {
+  while (roots.length > 0) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+
+function fixtureRoot(label: string): string {
+  const root = mkdtempSync(join(tmpdir(), `studio-${label}-`))
+  roots.push(root)
+  mkdirSync(join(root, 'schema'), { recursive: true })
+  writeFileSync(join(root, 'package.json'), '{"type":"module"}\n')
+  writeFileSync(join(root, 'astrale.config.ts'), 'export default {}\n')
+  return root
+}
+
+function linkCurrentSdk(root: string): void {
+  const sdk = realpathSync(join(import.meta.dir, '../../../node_modules/@astrale-os/sdk'))
+  const scope = join(root, 'node_modules', '@astrale-os')
+  mkdirSync(scope, { recursive: true })
+  symlinkSync(sdk, join(scope, 'sdk'), 'dir')
+}
+
+function currentFixture(): DomainHandle {
+  const root = fixtureRoot('canonical-runtime')
+  linkCurrentSdk(root)
+  const schemaIndex = join(root, 'schema', 'index.ts')
+  const domainFile = join(root, 'implementation.ts')
+  writeFileSync(
+    schemaIndex,
+    `
+import {
+  defineSchema, domain, edge, edgeClass, fn, node, nodeClass,
+  nodeInterface, output, property, view,
+} from '@astrale-os/sdk/schema'
+
+const Named = nodeInterface()
+export const Directory = defineSchema('directory.runtime.test', {
+  interfaces: { Named },
+})
+
+const rename = fn({
+  input: {
+    type: 'object', properties: { title: { type: 'string' } },
+    required: ['title'], additionalProperties: false,
+  },
+  output: { type: 'boolean' },
+  auth: 'authenticated',
+})
+const Document = nodeClass({
+  implements: [Named],
+  properties: { title: property({ type: 'string' }, { required: true }) },
+  methods: { rename },
+})
+const owned_by = edgeClass.directed({
+  source: { as: 'document', accepts: [Document], outgoing: '0..*' },
+  target: { as: 'owner', accepts: [Document], incoming: '0..*' },
+})
+const welcome = node(Document, { title: 'Welcome' })
+
+export const schema = defineSchema('documents.runtime.test', {
+  dependencies: [Directory],
+  classes: { Document, owned_by },
+  functions: {
+    exportAll: fn({
+      input: { type: 'object', properties: {}, required: [], additionalProperties: false },
+      output: output.binary(),
+      auth: 'authenticated',
+    }),
+  },
+  views: { editor: view({ target: Document, auth: 'optional' }) },
+  core: {
+    nodes: { welcome },
+    edges: [edge(welcome, owned_by, domain(), {})],
+  },
+})
+`,
+  )
+  // Canonical core extraction must not import the effectful composition entry.
+  writeFileSync(domainFile, `throw new Error('composition entry was imported')\n`)
+  return {
+    id: 'documents-runtime-test',
+    root,
+    configFile: join(root, 'astrale.config.ts'),
+    domainFile,
+    schemaDirName: 'schema',
+    schemaDir: join(root, 'schema'),
+    schemaIndex,
+  }
+}
+
+describe('current SDK schema extractor', () => {
+  test('resolves the domain SDK, returns its raw root, and projects current members', async () => {
+    const handle = currentFixture()
+    const result = await runtimeExtract(handle.schemaIndex, handle.root)
+
+    expect(result.ok).toBe(true)
+    expect(result.root).toMatchObject({
+      format: 'astrale.dsl',
+      version: 'v1',
+      origin: 'documents.runtime.test',
+    })
+    expect(result.ir).toMatchObject({
+      format: 'astrale.dsl',
+      domain: 'documents.runtime.test',
+      functions: {
+        exportAll: {
+          static: true,
+          inheritance: 'default',
+          output: { mode: 'binary' },
+        },
+      },
+      views: {
+        editor: {
+          auth: 'optional',
+          target: { kind: 'definition' },
+        },
+      },
+    })
+    expect(result.importedInterfaces?.Named).toMatchObject({
+      name: 'Named',
+      origin: 'directory.runtime.test',
+    })
+  })
+
+  test('hashes the raw canonical root instead of the render projection', async () => {
+    const handle = currentFixture()
+    const extracted = await runtimeExtract(handle.schemaIndex, handle.root)
+    expect(extracted.ok).toBe(true)
+
+    const bundle = await buildBundle(handle)
+    expect(bundle.schemaRoot).toEqual(extracted.root)
+    expect(bundle.schemaHash).toBe(schemaHashOf(extracted.root))
+    expect(bundle.schemaHash).not.toBe(schemaHashOf(extracted.ir))
+  })
+
+  test('extracts canonical core without importing implementation.ts', async () => {
+    const handle = currentFixture()
+    const result = await coreExtract(handle.schemaIndex, handle.domainFile, handle.root)
+
+    expect(result).toEqual({
+      ok: true,
+      core: {
+        domain: 'documents.runtime.test',
+        nodes: [
+          {
+            path: '/:documents.runtime.test:core.welcome',
+            className: 'Document',
+            data: { 'documents.runtime.test:class.Document.property.title': 'Welcome' },
+          },
+        ],
+        edges: [
+          {
+            from: '/:documents.runtime.test:core.welcome',
+            to: '/:documents.runtime.test',
+            edgeName: 'owned_by',
+            data: {},
+          },
+        ],
+      },
+    })
+  })
+})
+
+test('core extractor preserves the legacy defineCore fallback', async () => {
+  const root = fixtureRoot('legacy-core')
+  const schemaIndex = join(root, 'schema', 'index.ts')
+  const domainFile = join(root, 'domain.ts')
+  writeFileSync(schemaIndex, `export const schema = { domain: 'legacy.runtime.test' }\n`)
+  writeFileSync(
+    domainFile,
+    `
+const Item = { config: { name: 'Item' } }
+const linked = { config: { name: 'linked' } }
+const schema = { interfaces: {}, classes: { Item, linked }, imports: [] }
+export const core = {
+  domain: 'legacy.runtime.test', schema,
+  __nodes: [
+    { path: '/legacy/left', def: Item, data: { name: 'Left' } },
+    { path: '/legacy/right', def: Item, data: { name: 'Right' } },
+  ],
+  __edges: [
+    { from: '/legacy/left', to: '/legacy/right', edge: linked, data: { order: 1 } },
+  ],
+}
+`,
+  )
+
+  expect(await coreExtract(schemaIndex, domainFile, root)).toEqual({
+    ok: true,
+    core: {
+      domain: 'legacy.runtime.test',
+      nodes: [
+        { path: '/legacy/left', className: 'Item', data: { name: 'Left' } },
+        { path: '/legacy/right', className: 'Item', data: { name: 'Right' } },
+      ],
+      edges: [
+        {
+          from: '/legacy/left',
+          to: '/legacy/right',
+          edgeName: 'linked',
+          data: { order: 1 },
+        },
+      ],
+    },
+  })
+})

package/studio/server/introspect/runtime.ts

@@ -2,7 +2,8 @@
  * runtime.ts — the introspection driver. Spawns the Bun extractor island in a
  * short-lived subprocess (cwd = domain dir so the domain's own node_modules
  * resolve the @astrale-os/* packages), with a hard timeout. Returns the raw
- * SchemaIR or an error render-state — never throws.
+ * render IR plus the raw canonical root (when present), or an error render-state
+ * — never throws.
  */
 import type { IrInterface, SchemaIR, StudioCore } from '../../shared/types'
 
@@ -12,6 +13,8 @@ const CORE_EXTRACTOR = new URL('./core-extractor.ts', import.meta.url).pathname
 export interface RuntimeExtractResult {
   ok: boolean
   ir: SchemaIR | null
+  /** Exact canonical V1 root. Null for legacy `D.$.ir` domains and failures. */
+  root: unknown | null
   /** member bodies of imported (kernel + cross-domain) interfaces, by name */
   importedInterfaces?: Record<string, IrInterface>
   error?: { message: string }
@@ -38,19 +41,26 @@ export async function runtimeExtract(
       return {
         ok: false,
         ir: null,
+        root: null,
         error: { message: err.trim() || 'extractor produced no output' },
       }
     }
     const parsed = JSON.parse(out)
     if (!parsed.ok)
-      return { ok: false, ir: null, error: parsed.error ?? { message: 'extraction failed' } }
+      return {
+        ok: false,
+        ir: null,
+        root: null,
+        error: parsed.error ?? { message: 'extraction failed' },
+      }
     return {
       ok: true,
       ir: parsed.ir as SchemaIR,
+      root: parsed.root ?? null,
       importedInterfaces: (parsed.importedInterfaces ?? {}) as Record<string, IrInterface>,
     }
   } catch (e: any) {
-    return { ok: false, ir: null, error: { message: String(e?.message ?? e) } }
+    return { ok: false, ir: null, root: null, error: { message: String(e?.message ?? e) } }
   }
 }
 
@@ -62,16 +72,18 @@ export interface CoreExtractResult {
 }
 
 /**
- * Spawn the core-extractor island over a domain's `domain.ts` (cwd = domainDir),
- * with a hard timeout. Returns the resolved core graph or an error — never throws.
+ * Spawn the core-extractor island over the pure schema entry first, retaining the
+ * composition entry only as the legacy `defineCore` fallback. Returns the
+ * resolved core graph or an error — never throws.
  */
 export async function coreExtract(
+  schemaIndexPath: string,
   domainFile: string,
   domainDir: string,
   timeoutMs = 20000,
 ): Promise<CoreExtractResult> {
   try {
-    const proc = Bun.spawn(['bun', 'run', CORE_EXTRACTOR, domainFile, domainDir], {
+    const proc = Bun.spawn(['bun', 'run', CORE_EXTRACTOR, schemaIndexPath, domainFile, domainDir], {
       cwd: domainDir,
       stdout: 'pipe',
       stderr: 'pipe',

package/studio/server/introspect/schema-refs.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from 'bun:test'
+
+import type { IrInterface, StudioSchemaBundle } from '../../shared/types'
+
+import { schemaRefs } from './schema-refs'
+
+function importedInterface(
+  name: string,
+  origin: string,
+  properties: string[] = [],
+  methods: string[] = [],
+): IrInterface {
+  return {
+    type: 'interface',
+    name,
+    origin,
+    ref: { origin, kind: 'interface', name },
+    properties: Object.fromEntries(properties.map((property) => [property, { type: 'string' }])),
+    methods: Object.fromEntries(
+      methods.map((method) => [
+        method,
+        {
+          name: method,
+          params: {},
+          returns: {},
+          static: false,
+          inheritance: 'default',
+        },
+      ]),
+    ),
+  }
+}
+
+function bundleWithImports(
+  exact: NonNullable<StudioSchemaBundle['ir']>['importedInterfacesByKey'],
+  legacy: Record<string, IrInterface>,
+): StudioSchemaBundle {
+  return {
+    ir: {
+      domain: 'root.example.dev',
+      interfaces: {},
+      classes: {},
+      functions: {},
+      ...(exact === undefined ? {} : { importedInterfacesByKey: exact }),
+    },
+    importedInterfaces: legacy,
+  } as unknown as StudioSchemaBundle
+}
+
+describe('schema refs for imported interfaces', () => {
+  test('enumerates every exact homonym without selecting a name-keyed winner', () => {
+    const refs = schemaRefs(
+      bundleWithImports(
+        {
+          'directory.example.dev:interface.Named': importedInterface(
+            'Named',
+            'directory.example.dev',
+            ['directoryName'],
+          ),
+          'people.example.dev:interface.Named': importedInterface(
+            'Named',
+            'people.example.dev',
+            [],
+            ['rename'],
+          ),
+        },
+        {
+          Named: importedInterface('Named', 'legacy.invalid', ['legacyOnly']),
+        },
+      ),
+    )
+
+    expect(refs).toContain('interface.directory.example.dev:interface.Named')
+    expect(refs).toContain('interface.directory.example.dev:interface.Named.property.directoryName')
+    expect(refs).toContain('interface.people.example.dev:interface.Named.method.rename')
+    expect(refs).not.toContain('interface.Named')
+    expect(refs).not.toContain('interface.Named.property.legacyOnly')
+  })
+
+  test('uses the name-keyed imported interface only when the exact index is absent', () => {
+    expect(
+      schemaRefs(
+        bundleWithImports(undefined, {
+          Named: importedInterface('Named', 'legacy.example.dev', ['name']),
+        }),
+      ),
+    ).toEqual(['interface.Named', 'interface.Named.property.name'])
+
+    expect(
+      schemaRefs(
+        bundleWithImports(
+          {},
+          {
+            Named: importedInterface('Named', 'legacy.example.dev', ['name']),
+          },
+        ),
+      ),
+    ).toEqual([])
+  })
+})

package/studio/server/introspect/schema-refs.ts

@@ -37,10 +37,31 @@ export function schemaRefs(bundle: StudioSchemaBundle): string[] {
         if (ep.name) refs.add(`edge.${name}.endpoint.${ep.name}`)
   }
 
+  for (const name of Object.keys(ir.functions ?? {})) refs.add(`function.${name}`)
+
   // Imported interfaces (kernel mixins + cross-domain) are rendered — and so are
   // commentable — in the Inherited section, keyed under the `interface.` namespace.
-  for (const [name, iface] of Object.entries(bundle.importedInterfaces ?? {}))
-    addMember(`interface.${name}`, iface.properties, iface.methods)
+  // Canonical bundles retain every exact `(origin, kind, name)` identity. Iterate
+  // all of them: a short-name map must never pick one homonym by traversal order.
+  // The name-keyed bundle field remains a legacy-only fallback.
+  if (ir.importedInterfacesByKey !== undefined) {
+    for (const [key, iface] of Object.entries(ir.importedInterfacesByKey)) {
+      const anchor = importedInterfaceAnchor(key)
+      if (anchor) addMember(anchor, iface.properties, iface.methods)
+    }
+  } else {
+    for (const [name, iface] of Object.entries(bundle.importedInterfaces ?? {}))
+      addMember(`interface.${name}`, iface.properties, iface.methods)
+  }
 
   return [...refs]
 }
+
+function importedInterfaceAnchor(key: string): string | null {
+  const separator = key.lastIndexOf(':')
+  if (separator <= 0) return null
+  const ref = key.slice(separator + 1)
+  if (!ref.startsWith('interface.')) return null
+  const name = ref.slice('interface.'.length)
+  return /^[A-Za-z_$][\w$]*$/.test(name) ? `interface.${key}` : null
+}

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

@@ -0,0 +1,51 @@
+import { afterEach, expect, test } from 'bun:test'
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { hashAnatomyFiles } from './baseline'
+
+const roots: string[] = []
+
+afterEach(() => {
+  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+
+test('hashes current implementation and semantic layer files alongside legacy anatomy', () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-current-baseline-'))
+  roots.push(root)
+  for (const dir of [
+    'schema',
+    'actions/risk',
+    'handlers/risk',
+    'queries/risk',
+    'ui/risk',
+    'views/risk',
+  ]) {
+    mkdirSync(join(root, dir), { recursive: true })
+  }
+  for (const file of [
+    'schema/index.ts',
+    'implementation.ts',
+    'actions/risk/index.ts',
+    'handlers/risk/index.ts',
+    'queries/risk/index.ts',
+    'ui/risk/screen.tsx',
+    'views/risk/index.ts',
+    'package.json',
+  ]) {
+    writeFileSync(join(root, file), `${file}\n`)
+  }
+  writeFileSync(join(root, 'README.md'), 'not part of the anatomy fileset\n')
+
+  expect(Object.keys(hashAnatomyFiles(root, 'schema')).sort()).toEqual([
+    'actions/risk/index.ts',
+    'handlers/risk/index.ts',
+    'implementation.ts',
+    'package.json',
+    'queries/risk/index.ts',
+    'schema/index.ts',
+    'ui/risk/screen.tsx',
+    'views/risk/index.ts',
+  ])
+})

package/studio/server/state/baseline.ts

@@ -31,8 +31,37 @@ const SKIP_DIRS = new Set(['node_modules', '.dist', 'dist', '.domain-studio', '.
  * is NOT listed here — see hashAnatomyFiles. Everything else is a fixed contract.
  */
 export const ANATOMY_GLOBS = {
-  dirs: ['runtime', 'views', 'functions', 'client/src'],
-  files: ['domain.ts', 'deps.ts', 'env.ts', 'package.json', 'astrale.config.ts'],
+  dirs: [
+    'actions',
+    'capabilities',
+    'core',
+    'runtime',
+    'views',
+    'functions',
+    'handlers',
+    'integrations',
+    'migrations',
+    'mutations',
+    'queries',
+    'rules',
+    'scripts',
+    'states',
+    'ui',
+    'utils',
+    'workflows',
+    'client/src',
+  ],
+  files: [
+    'implementation.ts',
+    'domain.ts',
+    'index.ts',
+    'core.ts',
+    'deps.ts',
+    'env.ts',
+    'package.json',
+    'pnpm-workspace.yaml',
+    'astrale.config.ts',
+  ],
 } as const
 
 function sha256(buf: Buffer): string {

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

@@ -0,0 +1,37 @@
+import { afterEach, expect, test } from 'bun:test'
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { annotateOrigin } from './create'
+
+const roots: string[] = []
+
+afterEach(() => {
+  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+
+test('annotates the schema definition behind a current barrel', () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-create-origin-'))
+  roots.push(root)
+  mkdirSync(join(root, 'schema', 'application'), { recursive: true })
+  const barrel = join(root, 'schema', 'index.ts')
+  const definition = join(root, 'schema', 'application', 'index.ts')
+  writeFileSync(barrel, `export { schema } from './application/index.js'\n`)
+  writeFileSync(
+    definition,
+    `export const ORIGIN = 'application.example.dev' as const
+const input = { classes: {} } as const
+export const schema = defineSchema(ORIGIN, input)
+`,
+  )
+
+  annotateOrigin(root)
+  annotateOrigin(root)
+
+  expect(readFileSync(barrel, 'utf8')).not.toContain('ORIGIN —')
+  const source = readFileSync(definition, 'utf8')
+  expect(source).toContain('// ORIGIN —')
+  expect(source.indexOf('// ORIGIN —')).toBeLessThan(source.indexOf('defineSchema(ORIGIN'))
+  expect(source.match(/\/\/ ORIGIN —/g)).toHaveLength(1)
+})