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

package/studio/server/introspect/anatomy.ts

@@ -10,24 +10,32 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
 import { join, relative } from 'node:path'
 
-import type { DomainAnatomy, DomainOverview } from '../../shared/types'
+import type { DomainAnatomy, DomainOverview, SchemaIR } from '../../shared/types'
 
+import { asJsonRecord, asString, parseJson } from '../json'
 import { readSettings } from '../state/settings'
 import { buildClientTree, buildEnvFields, buildViews, findSchemaDefinition } from './anatomy-extras'
+import { readConfigPreview } from './config-preview'
 
 export interface AnatomyArgs {
   root: string
   schemaDirName: string
   clientDir?: string
+  canonicalViews?: NonNullable<SchemaIR['views']>
 }
 
-export function buildAnatomy({ root, schemaDirName, clientDir }: AnatomyArgs): DomainAnatomy {
+export function buildAnatomy({
+  root,
+  schemaDirName,
+  clientDir,
+  canonicalViews,
+}: AnatomyArgs): DomainAnatomy {
   const schema = findSchemaDefinition(root, schemaDirName)
   const authoredClientDir =
     clientDir ?? (existsSync(join(root, 'ui')) ? join(root, 'ui') : undefined)
   return {
     overview: buildOverview(root, schemaDirName, authoredClientDir, schema?.origin),
-    views: buildViews(root, schemaDirName),
+    views: buildViews(root, schemaDirName, canonicalViews),
     client: buildClientTree(root, clientDir ?? null),
     env: buildEnvFields(root),
     detectedIntegrations: detectIntegrations(root),
@@ -40,7 +48,7 @@ function buildOverview(
   clientDir?: string,
   schemaOrigin?: string,
 ): DomainOverview {
-  const pkg = readJsonSafe(join(root, 'package.json'))
+  const pkg = readPackageJsonSafe(join(root, 'package.json'))
   const astraleDeps: Record<string, string> = {}
   for (const [k, v] of Object.entries({
     ...(pkg?.dependencies ?? {}),
@@ -49,16 +57,7 @@ function buildOverview(
     if (k.startsWith('@astrale-os/')) astraleDeps[k] = String(v)
   }
 
-  const config = readTextSafe(join(root, 'astrale.config.ts'))
-  let adapter: DomainOverview['adapter'] = 'unknown'
-  if (/\bastrale\s*\(/.test(config)) adapter = 'astrale'
-  else if (/\bcloudflare\s*\(/.test(config)) adapter = 'cloudflare'
-
-  const instance = config.match(/instance\s*:\s*['"]([^'"]+)['"]/)?.[1]
-  const route = config.match(/route\s*:\s*['"]([^'"]+)['"]/)?.[1]
-  const devSecrets =
-    config.match(/dev\s*:\s*\{[^}]*secrets\s*:\s*['"]([^'"]+)['"]/)?.[1] ??
-    config.match(/secrets\s*:\s*['"]([^'"]+)['"]/)?.[1]
+  const config = readConfigPreview(root)
 
   const compositionFile = existsSync(join(root, 'implementation.ts'))
     ? 'implementation.ts'
@@ -77,9 +76,9 @@ function buildOverview(
   return {
     origin,
     compositionFile,
-    adapter,
-    prodTarget: instance ? `instance: ${instance}` : route ? `route: ${route}` : undefined,
-    devSecrets,
+    adapter: config.adapter,
+    prodTarget: config.prodTarget,
+    devSecrets: config.devSecrets,
     postInstall: undefined,
     requires: [],
     packageName: pkg?.name,
@@ -114,9 +113,37 @@ function readTextSafe(f: string): string {
   }
 }
 
-function readJsonSafe(f: string): any {
+interface PackageOverview {
+  name?: string
+  version?: string
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+}
+
+function decodeDependencyMap(value: unknown): Record<string, string> | undefined {
+  const record = asJsonRecord(value)
+  if (!record) return undefined
+  return Object.fromEntries(
+    Object.entries(record).filter(
+      (entry): entry is [string, string] => typeof entry[1] === 'string',
+    ),
+  )
+}
+
+function readPackageJsonSafe(f: string): PackageOverview | null {
   try {
-    return JSON.parse(readFileSync(f, 'utf8'))
+    const record = asJsonRecord(parseJson(readFileSync(f, 'utf8')))
+    if (!record) return null
+    const name = asString(record.name)
+    const version = asString(record.version)
+    const dependencies = decodeDependencyMap(record.dependencies)
+    const devDependencies = decodeDependencyMap(record.devDependencies)
+    return {
+      ...(name === undefined ? {} : { name }),
+      ...(version === undefined ? {} : { version }),
+      ...(dependencies === undefined ? {} : { dependencies }),
+      ...(devDependencies === undefined ? {} : { devDependencies }),
+    }
   } catch {
     return null
   }

package/studio/server/introspect/bundle.ts

@@ -1,6 +1,6 @@
 /**
  * bundle.ts — assembles the StudioSchemaBundle: runtime IR (PRIMARY) + ts-morph
- * overlay + schemaHash + deps-installed precondition. Never throws; a failed
+ * overlay + render fingerprint + deps-installed precondition. Never throws; a failed
  * runtime import becomes a render-state error (with the overlay still computed
  * statically, so anchors/handler-links survive a mid-edit compile break).
  */
@@ -8,7 +8,7 @@ import type { StudioSchemaBundle } from '../../shared/types'
 
 import { type DomainHandle, depsInstalled } from '../domain'
 import { readSettings } from '../state/settings'
-import { schemaHashOf } from './hash'
+import { renderFingerprintOf } from './hash'
 import { buildOverlay } from './overlay'
 import { runtimeExtract } from './runtime'
 
@@ -16,6 +16,8 @@ export async function buildBundle(handle: DomainHandle): Promise<StudioSchemaBun
   const installed = depsInstalled(handle.root)
   let ir = null
   let schemaRoot: unknown | undefined
+  let schemaMode: StudioSchemaBundle['schemaMode'] = 'unavailable'
+  let schemaRevision: StudioSchemaBundle['schemaRevision']
   let importedInterfaces: StudioSchemaBundle['importedInterfaces']
   let error: StudioSchemaBundle['error'] = null
   let extractedBy: StudioSchemaBundle['extractedBy'] = 'runtime-bun'
@@ -29,6 +31,8 @@ export async function buildBundle(handle: DomainHandle): Promise<StudioSchemaBun
     if (r.ok) {
       ir = r.ir
       if (r.root !== null) schemaRoot = r.root
+      schemaMode = r.schemaMode
+      if (r.revision !== null) schemaRevision = r.revision
       importedInterfaces = r.importedInterfaces
     } else {
       error = { message: r.error?.message ?? 'schema failed to compile' }
@@ -44,13 +48,18 @@ export async function buildBundle(handle: DomainHandle): Promise<StudioSchemaBun
 
   const overlay = buildOverlay({ ir, domainRoot: handle.root, schemaDir: handle.schemaDir })
   if (ir) handle.origin = ir.domain
+  const renderFingerprint =
+    schemaRoot !== undefined
+      ? renderFingerprintOf(schemaRoot)
+      : ir
+        ? renderFingerprintOf(ir)
+        : 'sha-none'
 
   return {
     domainId: handle.id,
-    // The Kernel installs the canonical DomainSchema root, not the Studio's
-    // lossy render projection. Legacy domains have no root and retain IR hashing.
-    schemaHash:
-      schemaRoot !== undefined ? schemaHashOf(schemaRoot) : ir ? schemaHashOf(ir) : 'sha-none',
+    renderFingerprint,
+    schemaMode,
+    ...(schemaRevision === undefined ? {} : { schemaRevision }),
     extractedBy,
     depsInstalled: installed,
     ir,

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

@@ -344,6 +344,85 @@ describe('canonical DomainSchema V1 projection', () => {
     expect(projected.importedInterfaces.Named).toBeUndefined()
   })
 
+  test('collects an exact external Definition referenced only by a top-level Policy', () => {
+    const policyOrigin = 'authorization.example.dev'
+    const subjectRef = { origin: policyOrigin, kind: 'class', name: 'Subject' } as const
+    const objectRef = { origin: policyOrigin, kind: 'class', name: 'Object' } as const
+    const policyOnlyRef = { origin: policyOrigin, kind: 'class', name: 'may_access' } as const
+    const policyDependency = {
+      format: 'astrale.dsl',
+      version: 'v1',
+      origin: policyOrigin,
+      dependencies: [],
+      types: {},
+      interfaces: {},
+      classes: {
+        Subject: {
+          family: 'node',
+          implements: [],
+          properties: emptyProperties,
+          propertyMetadata: {},
+          methods: {},
+          policies: {},
+        },
+        Object: {
+          family: 'node',
+          implements: [],
+          properties: emptyProperties,
+          propertyMetadata: {},
+          methods: {},
+          policies: {},
+        },
+        may_access: {
+          family: 'edge',
+          implements: [],
+          properties: emptyProperties,
+          propertyMetadata: {},
+          orientation: 'directed',
+          endpoints: {
+            source: { role: 'subject', accepts: [subjectRef], outgoing: '0..*' },
+            target: { role: 'object', accepts: [objectRef], incoming: '0..*' },
+          },
+          policies: {},
+          constraints: {},
+        },
+      },
+      functions: {},
+      policies: {},
+      views: {},
+      core: { nodes: {}, edges: [] },
+    } satisfies CanonicalDomainSchemaV1
+    const policyOnlyRoot = {
+      format: 'astrale.dsl',
+      version: 'v1',
+      origin: 'policy-consumer.example.dev',
+      dependencies: [{ origin: policyDependency.origin, revision: `sha256:${'2'.repeat(64)}` }],
+      types: {},
+      interfaces: {},
+      classes: {},
+      functions: {},
+      policies: {
+        canRead: {
+          match: {
+            source: { kind: 'subject' },
+            class: policyOnlyRef,
+            target: { kind: 'object' },
+          },
+        },
+      },
+      views: {},
+      core: { nodes: {}, edges: [] },
+    } satisfies CanonicalDomainSchemaV1
+
+    const projected = projectCanonicalSchema(policyOnlyRoot, [policyDependency])
+    expect(projected.ir.importsByKey?.['authorization.example.dev:class.may_access']).toEqual({
+      origin: policyDependency.origin,
+      definition: 'class',
+      ref: policyOnlyRef,
+      key: 'authorization.example.dev:class.may_access',
+    })
+  })
+
   test('projects canonical core paths and the owning Domain endpoint', () => {
     expect(projectCanonicalCore(root)).toEqual({
       domain: root.origin,

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

@@ -9,13 +9,11 @@ import type {
   IrCallableOutput,
   IrClass,
   IrDefinitionKey,
-  IrDefinitionRef,
   IrEndpoint,
   IrFunction,
   IrImportDescriptor,
   IrInterface,
   IrMethod,
-  IrSchemaKey,
   IrSchemaRef,
   IrView,
   JsonSchema,
@@ -23,6 +21,9 @@ import type {
   StudioCore,
 } from '../../shared/types'
 
+import { definitionRefKey, isIrDefinitionRef, schemaRefKey } from '../../shared/schema/identity'
+import { isSchemaRevision } from '../../shared/types'
+
 type AnyRecord = Record<string, unknown>
 
 export type CanonicalDomainSchemaV1 = AnyRecord & {
@@ -36,6 +37,20 @@ export interface CanonicalSchemaProjection {
   importedInterfaces: Record<string, IrInterface>
 }
 
+export type CanonicalSchemaAdmission =
+  | {
+      status: 'admitted'
+      root: CanonicalDomainSchemaV1
+      closure: CanonicalDomainSchemaV1[]
+      revision: `sha256:${string}`
+    }
+  | {
+      status: 'preview'
+      root: CanonicalDomainSchemaV1
+      closure: CanonicalDomainSchemaV1[]
+      revision: null
+    }
+
 export function isCanonicalDomainSchemaV1(value: unknown): value is CanonicalDomainSchemaV1 {
   const candidate = asRecord(value)
   return (
@@ -103,6 +118,65 @@ export function closureFromSdk(
   return []
 }
 
+/**
+ * Re-admit a structurally V1-looking export through the Domain's own SDK cohort.
+ * Retained Builder context supplies the exact dependency closure. If that proof
+ * is unavailable or admission fails, Studio may still render the document as a
+ * structural preview, but it must not assign a canonical revision to it.
+ */
+export function admitCanonicalSchemaFromSdk(
+  sdkModule: Record<string, unknown>,
+  candidate: CanonicalDomainSchemaV1,
+): CanonicalSchemaAdmission {
+  const retainedClosure = closureFromSdk(sdkModule, candidate)
+  const schemaApi = asRecord(sdkModule.schema)
+  const accept = schemaApi?.accept
+  const revision = schemaApi?.revision
+  if (!schemaApi || typeof accept !== 'function' || typeof revision !== 'function') {
+    return { status: 'preview', root: candidate, closure: retainedClosure, revision: null }
+  }
+
+  try {
+    const revisions = new Map<string, string>()
+    for (const dependency of retainedClosure) {
+      const value = Reflect.apply(revision, schemaApi, [dependency])
+      if (!isSchemaRevision(value)) throw new TypeError('SDK returned an invalid schema revision')
+      revisions.set(dependency.origin, value)
+    }
+    const lookup = {
+      get(origin: string, expected: string): CanonicalDomainSchemaV1 | undefined {
+        const dependency = retainedClosure.find((entry) => entry.origin === origin)
+        return dependency && revisions.get(origin) === expected ? dependency : undefined
+      },
+    }
+    const accepted = Reflect.apply(accept, schemaApi, [candidate, lookup])
+    if (!isCanonicalDomainSchemaV1(accepted) || accepted.origin !== candidate.origin) {
+      throw new TypeError('SDK admission returned a different schema root')
+    }
+    const acceptedRevision = Reflect.apply(revision, schemaApi, [accepted])
+    if (!isSchemaRevision(acceptedRevision)) {
+      throw new TypeError('SDK returned an invalid schema revision')
+    }
+
+    // Resolve the newly accepted value once more so its retained closure, rather
+    // than Studio's structural candidate, is what feeds exact-ref projection.
+    const resolve = schemaApi.resolve
+    let closure = retainedClosure
+    if (typeof resolve === 'function') {
+      const resolved = asRecord(Reflect.apply(resolve, schemaApi, [accepted]))
+      const proof = asRecord(resolved?.$)
+      if (proof?.schema !== accepted) throw new TypeError('SDK resolution did not retain the root')
+      const admitted = admitClosure(proof.closure, accepted)
+      if (!admitted) throw new TypeError('SDK resolution returned an invalid dependency closure')
+      closure = admitted
+    }
+
+    return { status: 'admitted', root: accepted, closure, revision: acceptedRevision }
+  } catch {
+    return { status: 'preview', root: candidate, closure: retainedClosure, revision: null }
+  }
+}
+
 /** Add fields required by the current shared contract to a legacy serializer IR. */
 export function normalizeLegacySchemaIR(value: unknown): SchemaIR {
   const ir = asRecord(value)
@@ -174,8 +248,8 @@ export function projectCanonicalSchema(
 
   for (let index = 0; index < pending.length; index++) {
     const ref = pending[index]
-    if (!isDefinitionRef(ref) || ref.origin === origin) continue
-    const key = definitionKey(ref)
+    if (!isIrDefinitionRef(ref) || ref.origin === origin) continue
+    const key = definitionRefKey(ref)
     if (visited.has(key)) continue
     visited.add(key)
 
@@ -556,7 +630,7 @@ function collectDefinitionRefs(root: CanonicalDomainSchemaV1): IrSchemaRef[] {
     addRef(declaration?.source, refs)
     addRef(declaration?.target, refs)
   }
-  collectPolicyRefs(root.policies, refs)
+  for (const [, policy] of entriesOf(root.policies)) collectPolicyRefs(policy, refs)
   return uniqueRefs(refs)
 }
 
@@ -636,25 +710,13 @@ function addRef(value: unknown, refs: IrSchemaRef[]): void {
 function uniqueRefs(refs: readonly IrSchemaRef[]): IrSchemaRef[] {
   const seen = new Set<string>()
   return refs.filter((ref) => {
-    const key = refKey(ref)
+    const key = schemaRefKey(ref)
     if (seen.has(key)) return false
     seen.add(key)
     return true
   })
 }
 
-function refKey(ref: IrSchemaRef): IrSchemaKey {
-  return `${ref.origin}:${ref.kind}.${ref.name}`
-}
-
-function isDefinitionRef(ref: IrSchemaRef): ref is IrDefinitionRef {
-  return ref.kind === 'class' || ref.kind === 'interface'
-}
-
-function definitionKey(ref: IrDefinitionRef): IrDefinitionKey {
-  return `${ref.origin}:${ref.kind}.${ref.name}`
-}
-
 function coreEndpoint(value: unknown, rootOrigin: string): string {
   const endpoint = asRecord(value)
   if (endpoint?.kind === 'domain') return `/:${rootOrigin}`

package/studio/server/introspect/config-preview.test.ts

@@ -0,0 +1,32 @@
+import { expect, test } from 'bun:test'
+
+import { parseConfigPreview } from './config-preview'
+
+test('config preview ignores examples in comments and preserves URL literals', () => {
+  const preview = parseConfigPreview(`
+// cloudflare({ prod: { route: 'commented.invalid', secrets: '.env.fake' } })
+/* astrale({ prod: { instance: 'commented-instance' } }) */
+export default deploy(domain, cloudflare({
+  dev: { client: { dir: 'client' }, secrets: '.env.dev' },
+  prod: {
+    client: { dir: 'client' },
+    route: 'https://services.example.dev/path',
+    secrets: '.env.prod',
+  },
+}))
+`)
+
+  expect(preview).toEqual({
+    adapter: 'cloudflare',
+    prodTarget: 'route: https://services.example.dev/path',
+    devSecrets: '.env.dev',
+    configuredSecretFiles: ['.env.dev', '.env.prod'],
+  })
+})
+
+test('config preview reports dynamic configuration as unknown instead of inventing authority', () => {
+  expect(parseConfigPreview(`export default makeDeployment(domain)`)).toEqual({
+    adapter: 'unknown',
+    configuredSecretFiles: [],
+  })
+})

package/studio/server/introspect/config-preview.ts

@@ -0,0 +1,119 @@
+/**
+ * Static, non-authoritative preview of astrale.config.ts.
+ *
+ * Deployment configuration is owned by the SDK adapter and is executable
+ * TypeScript. Studio deliberately does not execute it during anatomy/env reads;
+ * these few fields are only display/editor hints and may be unknown when the
+ * configuration is computed dynamically.
+ */
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+export interface ConfigPreview {
+  adapter: 'astrale' | 'cloudflare' | 'unknown'
+  prodTarget?: string
+  devSecrets?: string
+  configuredSecretFiles: string[]
+}
+
+function withoutComments(source: string): string {
+  let output = ''
+  let quote: "'" | '"' | '`' | null = null
+  let escaped = false
+  for (let index = 0; index < source.length; index++) {
+    const char = source[index]!
+    const next = source[index + 1]
+    if (quote) {
+      output += char
+      if (escaped) escaped = false
+      else if (char === '\\') escaped = true
+      else if (char === quote) quote = null
+      continue
+    }
+    if (char === "'" || char === '"' || char === '`') {
+      quote = char
+      output += char
+      continue
+    }
+    if (char === '/' && next === '/') {
+      while (index + 1 < source.length && source[index + 1] !== '\n') index++
+      continue
+    }
+    if (char === '/' && next === '*') {
+      index += 2
+      while (index < source.length && !(source[index] === '*' && source[index + 1] === '/')) {
+        if (source[index] === '\n') output += '\n'
+        index++
+      }
+      index++
+      continue
+    }
+    output += char
+  }
+  return output
+}
+
+function stringField(source: string, name: string): string | undefined {
+  const match = new RegExp(`\\b${name}\\s*:\\s*(['"])(.*?)\\1`).exec(source)
+  return match?.[2]
+}
+
+function objectBody(source: string, name: string): string | undefined {
+  const start = new RegExp(`\\b${name}\\s*:\\s*\\{`).exec(source)
+  if (!start) return undefined
+  const opening = source.indexOf('{', start.index)
+  let depth = 1
+  let quote: "'" | '"' | '`' | null = null
+  let escaped = false
+  for (let index = opening + 1; index < source.length; index++) {
+    const char = source[index]!
+    if (quote) {
+      if (escaped) escaped = false
+      else if (char === '\\') escaped = true
+      else if (char === quote) quote = null
+      continue
+    }
+    if (char === "'" || char === '"' || char === '`') {
+      quote = char
+      continue
+    }
+    if (char === '{') depth++
+    else if (char === '}' && --depth === 0) return source.slice(opening + 1, index)
+  }
+  return undefined
+}
+
+export function parseConfigPreview(source: string): ConfigPreview {
+  const active = withoutComments(source)
+  const adapter: ConfigPreview['adapter'] = /\bastrale\s*\(/.test(active)
+    ? 'astrale'
+    : /\bcloudflare\s*\(/.test(active)
+      ? 'cloudflare'
+      : 'unknown'
+  const prod = objectBody(active, 'prod') ?? active
+  const dev = objectBody(active, 'dev') ?? ''
+  const instance = stringField(prod, 'instance')
+  const route = stringField(prod, 'route')
+  const configuredSecretFiles = [...active.matchAll(/\bsecrets\s*:\s*(['"])(.*?)\1/g)].map(
+    (match) => match[2]!,
+  )
+  const devSecrets = stringField(dev, 'secrets')
+  return {
+    adapter,
+    ...(instance
+      ? { prodTarget: `instance: ${instance}` }
+      : route
+        ? { prodTarget: `route: ${route}` }
+        : {}),
+    ...(devSecrets ? { devSecrets } : {}),
+    configuredSecretFiles: [...new Set(configuredSecretFiles)],
+  }
+}
+
+export function readConfigPreview(root: string): ConfigPreview {
+  try {
+    return parseConfigPreview(readFileSync(join(root, 'astrale.config.ts'), 'utf8'))
+  } catch {
+    return { adapter: 'unknown', configuredSecretFiles: [] }
+  }
+}

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

@@ -2,7 +2,7 @@ import { describe, expect, test } from 'bun:test'
 
 import type { IrClass, IrFunction, SchemaIR } from '../../shared/types'
 
-import { classify, diffSchemas } from './diff'
+import { diffSchemas, structuralStatusOf } from './diff'
 
 const callable = (returnsType = 'string'): IrFunction => ({
   name: 'inspect',
@@ -31,21 +31,19 @@ const withClass = (member: IrClass): SchemaIR => ({
 })
 
 describe('canonical standalone Function diffs', () => {
-  test('classifies addition as additive and removal as breaking', () => {
+  test('reports additions and removals without claiming Runtime compatibility', () => {
     const empty = schema({})
     const populated = schema({ inspect: callable() })
-    expect(diffSchemas(empty, populated)).toEqual([
-      { kind: 'function-added', target: 'inspect', breaking: false },
-    ])
+    expect(diffSchemas(empty, populated)).toEqual([{ kind: 'function-added', target: 'inspect' }])
     const removed = diffSchemas(populated, empty)
-    expect(removed).toEqual([{ kind: 'function-removed', target: 'inspect', breaking: true }])
-    expect(classify(removed)).toBe('breaking')
+    expect(removed).toEqual([{ kind: 'function-removed', target: 'inspect' }])
+    expect(structuralStatusOf(removed)).toBe('changed')
   })
 
   test('detects a standalone Function signature change', () => {
     expect(
       diffSchemas(schema({ inspect: callable() }), schema({ inspect: callable('number') })),
-    ).toEqual([{ kind: 'function-signature-changed', target: 'inspect', breaking: true }])
+    ).toEqual([{ kind: 'function-signature-changed', target: 'inspect' }])
   })
 
   test('detects auth and output-mode changes in callable contracts', () => {
@@ -57,7 +55,7 @@ describe('canonical standalone Function diffs', () => {
     }
 
     expect(diffSchemas(schema({ inspect: before }), schema({ inspect: after }))).toEqual([
-      { kind: 'function-signature-changed', target: 'inspect', breaking: true },
+      { kind: 'function-signature-changed', target: 'inspect' },
     ])
   })
 
@@ -75,13 +73,11 @@ describe('canonical standalone Function diffs', () => {
         kind: 'prop-schema-changed',
         target: 'Person.name',
         detail: 'value constraints changed',
-        breaking: true,
       },
       {
         kind: 'prop-required-changed',
         target: 'Person.name',
         detail: 'optional → required',
-        breaking: true,
       },
     ])
   })