@things-factory/figure-service 10.1.64 → 10.1.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-service",
-  "version": "10.1.64",
+  "version": "10.1.66",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -23,7 +23,7 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.1.75",
+    "@hatiolab/figure-model": "^0.1.76",
     "@operato/typeorm-history": "^10.0.0",
     "@things-factory/ai-client-base": "^10.1.53",
     "@things-factory/auth-base": "^10.1.47",
@@ -33,5 +33,5 @@
     "graphql-upload": "^15.0.2",
     "koa-router": "^7.4.0"
   },
-  "gitHead": "9e10bdcadcc265c8e48b37a772d861221c4680ba"
+  "gitHead": "f92ae2a32e389f17eba0ce5770a98866ac3b1209"
 }

package/server/service/figure/figure-llm-smoke.test.ts

@@ -1,8 +1,8 @@
 /**
  * 실제 LLM Figure 후보 생성 smoke test (기본 비활성).
  *
- * 결정적 시험은 프롬프트·도구·검사 배선을 고정하지만, 실제 모델이 FigureSource JSON을 지키는지는
- * 대신할 수 없다. 이 시험은 `RUN_FIGURE_LLM_SMOKE=1`과 공급자 API 키가 모두 있을 때만 실행한다.
+ * 결정적 시험은 프롬프트·도구·검사 배선을 고정하지만, 실제 모델이 V3 명령 목록(ADR-0094)을 써서 게이트를
+ * 지나는 도형을 만드는지는 대신할 수 없다. 이 시험은 `RUN_FIGURE_LLM_SMOKE=1`과 공급자 API 키가 모두 있을 때만 실행한다.
  * DB·GraphQL·Figure 저장을 건드리지 않고 후보 생성 함수만 호출하므로, 외부 영향은 API 비용뿐이다.
  *
  * 실행:
@@ -11,7 +11,9 @@
  */
 import { createAIClient, setDefaultAIClient } from '@things-factory/ai-client-base'
 
-import { proposeFigure } from './figure-propose'
+import { applyV3Proposal, createV3Asset, inspectV3Asset } from '@hatiolab/figure-model'
+
+import { proposeFigureV3 } from './figure-propose-v3'
 
 // Provider modules register themselves on import. Keep this separate from the deterministic tests.
 import '@things-factory/ai-client-base'
@@ -35,7 +37,6 @@ function provider(): { provider: Provider; apiKey: string } | undefined {
 
 const picked = process.env.RUN_FIGURE_LLM_SMOKE === '1' ? provider() : undefined
 const describeIf = picked ? describe : describe.skip
-const PALETTE = ['palette.primary', 'palette.accent', 'palette.neutral']
 
 describeIf('Figure 실제 LLM smoke', () => {
   beforeAll(() => {
@@ -47,45 +48,40 @@ describeIf('Figure 실제 LLM smoke', () => {
   afterAll(() => setDefaultAIClient(undefined))
 
   test(
-    '새 Figure 후보는 유효한 어휘·팔레트·품질 근거를 가진다',
+    '새 Figure 는 게이트를 지나는 명령 목록으로 온다',
     async () => {
-      const result = await proposeFigure({
+      const result = await proposeFigureV3({
         prompt: 'two cylindrical rollers inside a simple rectangular press frame; make the rollers visually distinct',
-        type: 'ROLL_PRESS_SMOKE',
-        palette: PALETTE,
-        refine: true
+        name: 'Roll press'
       })
 
-      expect(result.source.type).toBe('ROLL_PRESS_SMOKE')
-      expect(result.source.parts.length).toBeGreaterThan(0)
-      expect(result.source.parts.every(part => PALETTE.includes(part.material.token))).toBe(true)
-      expect(result.quality.status).toMatch(/^(ready|review)$/)
+      expect(result.steps.length).toBeGreaterThan(0)
+      expect(inspectV3Asset(result.source).violations).toEqual([])
       expect(result.cost.triangles).toBeGreaterThan(0)
+      // eslint-disable-next-line no-console
+      console.log(`[figure-llm-smoke] new: ${result.steps.length} steps, ${result.attempts} attempt(s)`)
     },
-    90_000
+    120_000
   )
 
   test(
-    '수정 후보는 type을 보존하고 명시적 세션 피드백을 참고한다',
+    '고치는 제안은 건드리지 않은 부품을 그대로 둔다',
     async () => {
-      const result = await proposeFigure({
-        prompt: 'make the port more visible from above while keeping the body and port part names',
-        palette: PALETTE,
-        refine: true,
-        base: {
-          version: 2, type: 'MIXER_SMOKE', base: { x: 300, y: 400, z: 300 }, detailLevel: 'M',
-          parts: [
-            { name: 'body', primitive: 'cylinder', segments: 12, transform: { position: { x: 0, y: 200, z: 0 }, size: { x: 280, y: 320, z: 280 } }, material: { token: 'palette.primary' } },
-            { name: 'port', primitive: 'cube', transform: { position: { x: 0, y: 230, z: -155 }, size: { x: 80, y: 60, z: 30 } }, material: { token: 'palette.accent' } }
-          ]
-        },
-        feedback: [{ outcome: 'discarded', selectedChanges: 0, totalChanges: 2, note: 'the port must read clearly in top view' }]
-      })
+      const draft = applyV3Proposal(createV3Asset('Mixer'), [
+        { kind: 'add-part', part: { id: 'body', kind: 'cylinder', dimensions: { radius: 140, length: 320 } } },
+        { kind: 'add-part', part: { id: 'port', kind: 'box', dimensions: { width: 80, height: 60, depth: 30 } } },
+        { kind: 'attach', part: 'body', face: 'bottom', to: { plane: 'mounting-plane' } },
+        { kind: 'attach', part: 'port', face: 'back', to: { part: 'body', face: 'front' } },
+        { kind: 'fit-room', placement: 'floor' }
+      ] as any)
+      const result = await proposeFigureV3({ prompt: 'make the port twice as wide and give it an accent colour', base: draft })
 
-      expect(result.source.type).toBe('MIXER_SMOKE')
-      expect(result.source.parts.map(part => part.name)).toEqual(expect.arrayContaining(['body', 'port']))
-      expect(result.quality).toBeDefined()
+      const ids = result.source.document.model.nodes.map((n: any) => n.id)
+      expect(ids.some((id: string) => id.includes('body'))).toBe(true)
+      expect(ids.some((id: string) => id.includes('port'))).toBe(true)
+      // eslint-disable-next-line no-console
+      console.log(`[figure-llm-smoke] revise: ${JSON.stringify(result.steps)}`)
     },
-    90_000
+    120_000
   )
 })

package/server/service/figure/figure-mutation.ts

@@ -1,7 +1,7 @@
 import { In } from 'typeorm'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 
-import { placeholderType } from '@hatiolab/figure-model'
+import { parseV3Asset, placeholderType } from '@hatiolab/figure-model'
 import { getRepository } from '@things-factory/shell'
 
 import { Figure } from './figure.js'
@@ -11,7 +11,7 @@ import { FigureProposal, ProposeRequest } from './figure-propose-type.js'
 import { inspectAnySource } from './figure-format.js'
 import { renameDraftType, renameFacts } from './figure-rename.js'
 import { parseAnySource } from './figure-format.js'
-import { ProposeFailure, proposeFigure } from './figure-propose.js'
+import { ProposeV3Failure, proposeFigureV3 } from './figure-propose-v3.js'
 import { prepareV3Write, compareAndSwapV3, pictureOf } from './figure-v3-write.js'
 
 @Resolver(Figure)
@@ -399,19 +399,15 @@ export class FigureMutation {
   }
 
   /**
-   * 저작 보조에게 후보를 시킨다.
+   * 저작 보조에게 제안을 시킨다(ADR-0094).
    *
-   * **저장하지 않는다.** 후보를 돌려줄 뿐이고, 정본이 되는 것은 저작자가 보고 받은
-   * 뒤다. AI 가 정본에 직접 쓰면 저작자가 무엇이 자기 것이고 무엇이 기계 것인지
-   * 모르게 된다.
-   *
-   * 형식을 어긴 후보는 여기까지 오지 않는다 — `proposeFigure` 가 사유를 모델에
-   * 돌려주고 다시 시킨다. 끝내 못 만들면 **사유와 함께 던진다.** 반쯤 만든 것을
-   * 돌려주지 않는다.
+   * **저장하지 않는다.** 모델러 명령 목록과 그것이 만드는 도형을 돌려줄 뿐이고, 정본이 되는 것은 저작자가 모델러에
+   * 적용하고 저장한 뒤다. 커널이 거절한 명령이나 게이트가 잡은 것은 여기까지 오지 않는다 — 제안기가 사유를 모델에
+   * 돌려주고 다시 시킨다. 끝내 못 만들면 **사유와 함께 던진다.** 반쯤 만든 것을 돌려주지 않는다.
    */
   @Directive('@privilege(category: "figure", privilege: "mutation", domainOwnerGranted: true)')
   @Mutation(returns => FigureProposal, {
-    description: 'Asks the authoring assistant for a figure. Returns a candidate — nothing is saved.'
+    description: 'Asks the authoring assistant for modeller commands that make or revise a figure. Nothing is saved.'
   })
   async proposeFigure(@Arg('request') request: ProposeRequest): Promise<FigureProposal> {
     // 그림은 메모리로 받는다. 참고용이라 저장하지 않는다 — 남기면 지울 사람이 없다.
@@ -426,33 +422,23 @@ export class FigureMutation {
     }
 
     try {
-      const result = await proposeFigure({
+      const result = await proposeFigureV3({
         prompt: request.prompt,
-        base: request.base ? JSON.parse(request.base) : undefined,
-        type: request.type,
-        palette: request.palette,
-        refine: request.refine,
-        feedback: request.feedback,
+        base: request.base ? parseV3Asset(request.base) : undefined,
+        name: request.name,
         image
       })
 
       return {
+        steps: JSON.stringify(result.steps),
         source: JSON.stringify(result.source),
-        score: Math.round(result.score.score),
-        grade: result.score.grade,
+        score: result.score ? Math.round(result.score.score) : undefined,
+        grade: result.score?.grade,
         triangles: result.cost.triangles,
-        groups: result.cost.groups,
-        quality: {
-          ...result.quality,
-          visualRegions: result.quality.visual.regions,
-          visualCoverage: result.quality.visual.coverage,
-          visualReadability: result.quality.visual.readability
-        },
-        violations: result.violations,
         attempts: result.attempts
       }
     } catch (e) {
-      if (e instanceof ProposeFailure) {
+      if (e instanceof ProposeV3Failure) {
         // 사유를 삼키지 않는다. 저작자가 무엇이 막혔는지 알아야 말을 고쳐 다시 시킨다.
         throw new Error([e.message, ...e.reasons].join('\n'))
       }

package/server/service/figure/figure-propose-type.ts

@@ -2,153 +2,45 @@ import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
 import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
 import { Field, InputType, Int, ObjectType } from 'type-graphql'
 
-import { FigureFinding } from './figure-type.js'
-
-@ObjectType({ description: 'One explainable consideration from the model-grounded candidate review.' })
-export class FigureQualityFinding {
-  @Field({ description: 'What the consideration concerns: identity, silhouette, palette, performance, or resilience.' })
-  dimension: string
-
-  @Field({ description: 'Stable machine-readable review code.' })
-  code: string
-
-  @Field({ description: 'Human-readable evidence and recommended review.' })
-  message: string
-}
-
-@ObjectType({ description: 'Explainable design review based on Figure-model evidence, not a visual aesthetic claim.' })
-export class FigureQualityReview {
-  @Field({ description: 'ready when measurable checks are clear; review when author attention is recommended.' })
-  status: string
-
-  @Field({ description: 'Compact explanation of this review.' })
-  summary: string
-
-  @Field(type => [FigureQualityFinding], { description: 'Measured considerations for the author and assistant.' })
-  findings: FigureQualityFinding[]
-
-  @Field(type => Int, { description: 'Visible material regions in the reproducible top-view evidence.' })
-  visualRegions: number
-
-  @Field({ description: 'Top-view footprint coverage from 0 to 1.' })
-  visualCoverage: number
-
-  @Field({ description: 'Normalized top-view readability evidence from 0 to 1.' })
-  visualReadability: number
-
-}
-
-/** 제한된 후보 품질 코드. 현재 요청의 참고 데이터이며 어떤 Figure에도 저장되지 않는다. */
-@InputType({ description: 'Measured review summary from an earlier candidate in this authoring session.' })
-export class ProposalFeedbackQualityInput {
-  @Field({ nullable: true })
-  status?: string
-
-  @Field(type => [String], { nullable: true })
-  findingCodes?: string[]
-}
-
-/** 사람이 명시적으로 수락하거나 거절한 후보의 제한된 세션 반응. */
-@InputType({ description: 'Explicit author feedback for the next candidate. Session-only; never persisted.' })
-export class ProposalFeedbackInput {
-  @Field()
-  outcome: string
-
-  @Field(type => Int)
-  selectedChanges: number
-
-  @Field(type => Int)
-  totalChanges: number
-
-  @Field({ nullable: true })
-  note?: string
-
-  @Field({ nullable: true })
-  grade?: string
-
-  @Field(type => ProposalFeedbackQualityInput, { nullable: true })
-  quality?: ProposalFeedbackQualityInput
-}
-
-/**
- * 저작 보조에 넘기는 것.
- *
- * ## 팔레트를 클라이언트가 보낸다
- *
- * 서버가 팔레트를 알 수 없다. 팔레트는 things-scene 이 갖고 있는데, 그 패키지의
- * node 조건은 transfer 번들로 가고 거기에는 `activePalette` 이 없다 [확인함].
- * 그리는 쪽이 어떤 토큰을 풀 수 있는지 아는 유일한 자리이므로 그쪽이 보낸다.
- *
- * **그래서 저장 문(`parseSource`)은 토큰을 검사하지 못한다.** `validate()` 도
- * 못 한다 — figure-model 이 형식은 갖고 있지만 색 어휘는 things-scene 에 있다.
- * 색 어휘가 형식의 일부라면 figure-model 이 갖는 것이 맞다. **figure-model 에 올릴 것.**
- */
+/** What the authoring assistant is asked for (ADR-0094). */
 @InputType({ description: 'What to ask the authoring assistant for' })
 export class ProposeRequest {
   @Field({ description: 'What the author asked for, in their own words' })
   prompt: string
 
-  @Field({ nullable: true, description: 'The figure source to revise, as JSON. Omit to create a new one.' })
+  @Field({ nullable: true, description: 'The V3 figure source to revise, as JSON. Omit to create a new one.' })
   base?: string
 
-  @Field({ nullable: true, description: 'Type name for a new figure. Ignored when base is given.' })
-  type?: string
+  @Field({ nullable: true, description: 'The name a person reads for a new figure. Ignored when base is given.' })
+  name?: string
 
-  /**
-   * 그림.
-   *
-   * 비율과 덩어리를 읽는 데 쓴다. 표면 무늬를 옮기는 데 쓰지 않는다 — 로우폴리는
-   * 텍스처가 0 인 것이 목표다.
-   */
+  /** For proportions and masses, not surface detail: a low-poly figure carries no texture. */
   @Field(type => GraphQLUpload, { nullable: true, description: 'Reference photo or render' })
   image?: FileUpload
-
-  @Field(type => [String], { description: 'Palette tokens the client can resolve. Anything else is rejected.' })
-  palette: string[]
-
-  @Field({ nullable: true, description: 'Ask for one evidence-grounded refinement when the first valid candidate needs review.' })
-  refine?: boolean
-
-  @Field(type => [ProposalFeedbackInput], {
-    nullable: true,
-    description: 'Explicit session-only feedback on earlier candidates. It is constrained again before prompting and never stored.'
-  })
-  feedback?: ProposalFeedbackInput[]
 }
 
 /**
- * 후보 하나.
+ * A proposal: the modeller commands, and what the figure they make weighs.
  *
- * **정본이 아니다.** 저작자가 보고 받아야 정본이 된다. 그래서 서버는 저장하지 않고
- * 돌려주기만 한다.
+ * **Not the canon.** The modeller applies the steps as one step of its history; nothing is saved here.
  */
-@ObjectType({ description: 'A figure the assistant proposes. Not saved — the author accepts or discards it.' })
+@ObjectType({ description: 'A figure the assistant proposes, as modeller commands. Not saved — the author applies it or leaves it.' })
 export class FigureProposal {
-  @Field({ description: 'The proposed figure source, as JSON' })
+  @Field({ description: 'The V3 authoring commands, as a JSON array, in the order they apply' })
+  steps: string
+
+  @Field({ description: 'The V3 figure source the steps make, as JSON' })
   source: string
 
-  @Field(type => Int, { description: 'Reuse score out of 100' })
-  score: number
+  @Field(type => Int, { nullable: true, description: 'Reuse score out of 100' })
+  score?: number
 
-  @Field({ description: 'Grade from the score — A, B, C or D' })
-  grade: string
+  @Field({ nullable: true, description: 'Grade from the score — A, B, C or D' })
+  grade?: string
 
   @Field(type => Int, { description: 'Triangles in one instance' })
   triangles: number
 
-  @Field(type => Int, { description: 'Material groups — the draw calls one instance costs' })
-  groups: number
-
-  @Field(type => FigureQualityReview, {
-    description: 'Explainable design review. It advises the author and never saves or rejects the candidate.'
-  })
-  quality: FigureQualityReview
-
-  @Field(type => [FigureFinding], {
-    description: 'Policy violations. These do not block the proposal — the author decides.'
-  })
-  violations: FigureFinding[]
-
   @Field(type => Int, { description: 'How many attempts the assistant needed. Diagnostic.' })
   attempts: number
 }

package/server/service/figure/figure-propose-v3.test.ts

@@ -0,0 +1,117 @@
+/**
+ * figure-propose-v3 — an AI proposal for a V3 figure is a list of the modeller's commands (ADR-0094).
+ *
+ * What is held here is our filter, not the model's skill: the model is not called. The steps are applied on a copy;
+ * the step the kernel refuses, and the gate findings the steps bring in, go back to the model; after three attempts
+ * the proposer says it could not make it, and nothing half made comes back.
+ */
+import { V3_PROPOSAL_GRAMMAR, applyV3Proposal, createV3Asset, inspectV3Asset } from '@hatiolab/figure-model'
+import { setDefaultAIClient } from '@things-factory/ai-client-base'
+import type { AIClient } from '@things-factory/ai-client-base'
+
+import { ProposeV3Failure, proposeFigureV3, rulesPromptV3 } from './figure-propose-v3'
+
+function stubClient(answers: unknown[]): AIClient & { calls: number; sent: any[][]; system?: string } {
+  const client = {
+    id: 'stub',
+    calls: 0,
+    sent: [] as any[][],
+    system: undefined as string | undefined,
+    async chat() {
+      return ''
+    },
+    async generateJSON(messages: any[], options?: { systemPrompt?: string }) {
+      client.sent.push(JSON.parse(JSON.stringify(messages)))
+      client.system = options?.systemPrompt
+      const answer = answers[client.calls]
+      client.calls++
+      if (answer instanceof Error) throw answer
+      return answer
+    }
+  }
+  return client as unknown as AIClient & { calls: number; sent: any[][]; system?: string }
+}
+
+afterEach(() => setDefaultAIClient(undefined))
+
+const liftTable = [
+  { kind: 'add-part', part: { id: 'base', kind: 'box', dimensions: { width: 1200, height: 80, depth: 800 } } },
+  { kind: 'add-part', part: { id: 'column', kind: 'cylinder', dimensions: { radius: 90, length: 600 } } },
+  { kind: 'add-part', part: { id: 'top', kind: 'box', dimensions: { width: 1200, height: 60, depth: 800 } } },
+  { kind: 'attach', part: 'base', face: 'bottom', to: { plane: 'mounting-plane' } },
+  { kind: 'attach', part: 'column', face: 'bottom', to: { part: 'base', face: 'top' } },
+  { kind: 'attach', part: 'top', face: 'bottom', to: { part: 'column', face: 'top' } },
+  { kind: 'set-material', target: 'top', material: { token: 'palette.accent' }, palette: { 'palette.accent': '#d08a2c' } },
+  { kind: 'fit-room', placement: 'floor' }
+]
+const withoutRoom = liftTable.slice(0, -1)
+const wrongFace = liftTable.map((s, i) => (i === 4 ? { ...s, face: 'left' } : s))
+
+describe('the model is told the kernel\'s commands and the open draft, never V2', () => {
+  it('teaches every word of the grammar, in its own shape', () => {
+    const rules = rulesPromptV3()
+    for (const word of V3_PROPOSAL_GRAMMAR) expect(rules).toContain(word.shape)
+    expect(rules).not.toMatch(/figure-v1|"parts"\s*:\s*\[|anchor/i)
+  })
+
+  it('a measure asked to be the same as another is linked, not copied (:3300, 2026-09-26: 「몸통 지름과 같게」 came as a fixed 100)', () => {
+    expect(rulesPromptV3()).toMatch(/same as, matches or follows another part or the figure, write link-dimension/)
+  })
+
+  it('a revision carries the draft\'s V3 source', async () => {
+    const draft = applyV3Proposal(createV3Asset('Lift table'), liftTable as any)
+    const client = stubClient([{ steps: [{ kind: 'rename', name: 'Lift table 2' }] }])
+    setDefaultAIClient(client)
+    const made = await proposeFigureV3({ prompt: '이름을 바꿔 줘', base: draft })
+    expect(client.sent[0]![0]!.content).toContain('"version":"figure-v3-asset-1"')
+    expect(made.source.name).toBe('Lift table 2')
+    expect(draft.name).toBe('Lift table')
+  })
+})
+
+describe('the steps are held to the kernel and the gate', () => {
+  it('a list the kernel takes comes back with the figure it makes, the gate clean, on the first attempt', async () => {
+    setDefaultAIClient(stubClient([{ steps: liftTable }]))
+    const made = await proposeFigureV3({ prompt: '리프트 테이블', name: 'Lift table' })
+    expect(made.attempts).toBe(1)
+    expect(made.steps).toEqual(liftTable)
+    expect(inspectV3Asset(made.source).violations).toEqual([])
+    expect(made.score?.grade).toMatch(/^[ABCD]$/)
+  })
+
+  it('a refused step goes back with its place and the kernel\'s code, and the next answer is taken', async () => {
+    const client = stubClient([{ steps: wrongFace }, { steps: liftTable }])
+    setDefaultAIClient(client)
+    const made = await proposeFigureV3({ prompt: '리프트 테이블', name: 'Lift table' })
+    expect(made.attempts).toBe(2)
+    const said = client.sent[1]!.at(-1)!.content as string
+    expect(said).toMatch(/ATTACH_FACE: steps\[4\]: attach: /)
+  })
+
+  it('a new figure must come out whole: a list that leaves the room undeclared is sent back', async () => {
+    const client = stubClient([{ steps: withoutRoom }, { steps: liftTable }])
+    setDefaultAIClient(client)
+    const made = await proposeFigureV3({ prompt: '리프트 테이블', name: 'Lift table' })
+    expect(made.attempts).toBe(2)
+    expect(client.sent[1]!.at(-1)!.content).toMatch(/OCCUPANCY_UNDECLARED/)
+  })
+
+  it('a revision is not blamed for what the draft already had', async () => {
+    const draft = applyV3Proposal(createV3Asset('Lift table'), withoutRoom as any)
+    setDefaultAIClient(stubClient([{ steps: [{ kind: 'rename', name: 'Lift' }] }]))
+    const made = await proposeFigureV3({ prompt: '이름', base: draft })
+    expect(made.attempts).toBe(1)
+  })
+
+  it('three refusals said back, then it says it could not make it, with the last reasons -- nothing half made', async () => {
+    const client = stubClient([{ steps: wrongFace }, new Error('cut short'), { nope: true }])
+    setDefaultAIClient(client)
+    const failure = await proposeFigureV3({ prompt: '리프트 테이블', name: 'Lift table' }).catch(e => e)
+    expect(failure).toBeInstanceOf(ProposeV3Failure)
+    expect(failure.message).toBe('만들지 못했습니다.')
+    expect(failure.attempts).toBe(3)
+    expect(failure.reasons).toEqual(['The answer must be { "steps": [ ... ] }.'])
+    expect(client.calls).toBe(3)
+    expect(client.sent[2]!.at(-1)!.content).toMatch(/not valid JSON: cut short/)
+  })
+})