@things-factory/figure-service 10.1.205 → 10.1.206

package/recipes/traffic-cones/recipe.json

@@ -81,8 +81,7 @@
             "param": "pitch"
           }
         }
-      },
-      "narrowRange": true
+      }
     },
     {
       "kind": "set-joint",

package/recipes/transfer-belts/recipe.json

@@ -65,8 +65,7 @@
         "of": "part",
         "part": "{target}",
         "axis": "z"
-      },
-      "narrowRange": true
+      }
     },
     {
       "kind": "link-dimension",
@@ -76,8 +75,7 @@
         "of": "part",
         "part": "{target}",
         "axis": "z"
-      },
-      "narrowRange": true
+      }
     },
     {
       "kind": "set-joint",

package/recipes/trough/recipe.json

@@ -42,8 +42,7 @@
         "of": "part",
         "part": "{target}",
         "axis": "x"
-      },
-      "narrowRange": true
+      }
     },
     {
       "kind": "set-joint",

package/recipes/turntable/recipe.json

@@ -66,8 +66,7 @@
       },
       "times": {
         "param": "size"
-      },
-      "narrowRange": true
+      }
     },
     {
       "kind": "set-joint",

package/recipes/workbench-top/recipe.json

@@ -55,8 +55,7 @@
         "of": "part",
         "part": "{target}",
         "axis": "x"
-      },
-      "narrowRange": true
+      }
     },
     {
       "kind": "link-dimension",
@@ -66,8 +65,7 @@
         "of": "part",
         "part": "{target}",
         "axis": "z"
-      },
-      "narrowRange": true
+      }
     },
     {
       "kind": "set-joint",

package/server/service/figure/event-subscriber.ts

@@ -12,6 +12,8 @@ import { FigureHistory } from './figure-history.js'
  * 그 전부를 남기면 판본 목록이 「내가 오늘 몇 번 눌렀나」가 된다. 사람이 판이라고 부르는 것은
  * **발행한 것**이므로 그때만 베낀다. board 가 같은 규칙으로 돈다(`board-service` 의 같은 이름 파일).
  *
+ * 발행판의 정본(`__releaseSource`)은 크기 범위를 적은 발행판 사본이다 — Figure 행에는 작성자가 좁힌 끝만 남는다.
+ *
  * 발행 메모는 Figure 의 칸이 아니다. `releaseFigure` 가 저장할 엔티티에 `__releaseComment` 로 얹어
  * 두면 여기서 판본의 `comment` 로 옮긴다 — 메모는 그 판의 것이지 도형의 것이 아니다. 정본 형식
  * (`__releaseFormat`), 잰 커널의 판(`__releaseKernel`, ADR-0109 C1), 직전 판에 견준 변경(`__releaseChanges`), 발행 때 잰 값(`__releaseMetrics`)과
@@ -20,6 +22,8 @@ import { FigureHistory } from './figure-history.js'
 /** What `releaseFigure` laid on the entity for this release, moved onto the history row. */
 function releaseRecordOnto(history: FigureHistory, entity: Figure): FigureHistory {
   const e = entity as any
+  /* What a board reads of this release: its own copy, with the size range written down (ADR-0087 decision 6). */
+  if (e.__releaseSource) history.source = e.__releaseSource
   ;(history as any).comment = e.__releaseComment ?? null
   history.assetFormat = e.__releaseFormat ?? null
   history.kernelVersion = e.__releaseKernel ?? null

package/server/service/figure/figure-blueprint-query.test.ts

@@ -44,6 +44,8 @@ beforeAll(async () => {
   Figure = loadCompiled('service/figure/figure').Figure
   FigureHistory = loadCompiled('service/figure/figure-history').FigureHistory
   FigureQuery = loadCompiled('service/figure/figure-query').FigureQuery
+  /* A released row is saved with its history row, as releasing does: a board reads the release's own copy there (ADR-0087 decision 6). */
+  const Subscriber = loadCompiled('service/figure/event-subscriber').FigureHistoryEntitySubscriber
 
   dataSource = new TypeOrmDataSource({
     type: 'sqlite',
@@ -52,6 +54,7 @@ beforeAll(async () => {
     dropSchema: true,
     namingStrategy: new shell.NamingStrategy(),
     entities: [...shell.entities, ...authBase.entities, Figure, FigureHistory],
+    subscribers: [Subscriber],
     logging: false
   })
 

package/server/service/figure/figure-context.test.ts

@@ -193,7 +193,7 @@ describe('a proposal changes only what it was shown', () => {
   it('a shown part may change, a new part may be fastened to any part, the figure as a whole may change', () => {
     const steps = [
       { kind: 'set-material', target: 'shelf-2', material: { token: 'palette.primary' } },
-      { kind: 'add-part', part: { id: 'lamp', kind: 'sphere', dimensions: { radiusX: 40, radiusY: 40, radiusZ: 40 } } },
+      { kind: 'add-part', part: { id: 'lamp', kind: 'sphere', dimensions: { radius: 40, radiusY: 40 } } },
       { kind: 'attach', part: 'lamp', to: { part: 'shelf-9', face: 'top' } },
       { kind: 'link-dimension', part: 'lamp', axis: 'x', source: { of: 'part', part: 'shelf-7', axis: 'x' }, times: 0.1 },
       { kind: 'fit-room', placement: 'floor' }

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

@@ -1,9 +1,10 @@
 /*
- * The doors a stored source goes through: saving (`parseSource`), publishing (`inspectSource`) and handing it to a
- * board (`consumablePayloadOf`). The format is `figure-asset-1`, and the asset says so in its `version`; a source
+ * The doors a stored source goes through: saving (`parseSource`), publishing (`inspectSource`, and the release's own
+ * copy in `releaseRecordOf`), bringing a release back as a draft (`draftSourceOfRelease`) and handing it to a board
+ * (`consumablePayloadOf`). The format is `figure-asset-1`, and the asset says so in its `version`; a source
  * that does not is refused by name, because a source the server cannot identify is one it must not save.
  */
-import { FIGURE_KERNEL_VERSION, compileFigureAsset, inspectFigureAsset, isPlaceholderType, parseFigureAsset, serializeFigureAsset, figureContractChanges, figureCostOf, figureOriginCentredOf, figurePlaneGapOf, figureReleaseMetricsOf, figureScoreOf, figureTopViewOf } from '@hatiolab/figure-model'
+import { FIGURE_KERNEL_VERSION, compileFigureAsset, inspectFigureAsset, isPlaceholderType, parseFigureAsset, serializeFigureAsset, figureContractChanges, figureCostOf, figureOriginCentredOf, figurePlaneGapOf, figureReleaseMetricsOf, figureScoreOf, figureTopViewOf, forgetRecordedInstanceSize, recordFigureInstanceSize } from '@hatiolab/figure-model'
 import type { FigureAsset, FigureContractChange, FigureContractError, FigureReleaseMetrics, FigureTopView, FigureViolation } from '@hatiolab/figure-model'
 
 import type { FigureFinding } from './figure-type.js'
@@ -711,9 +712,20 @@ function figureContractWording(change: FigureContractChange, say: Say): Pick<Gat
 export function releaseRecordOf(
   sourceJson: string,
   releasedJson?: string | null
-): { format: string; kernel: string; changes: FigureContractChange[] | null; metrics: FigureReleaseMetrics; topView: FigureTopView } {
+): { source: string; format: string; kernel: string; changes: FigureContractChange[] | null; metrics: FigureReleaseMetrics; topView: FigureTopView } {
   const asset = parseFigureAsset(sourceJson)
-  const measured = { format: asset.version, kernel: FIGURE_KERNEL_VERSION, metrics: figureReleaseMetricsOf(asset), topView: figureTopViewOf(asset, null) }
+  /*
+    The release's own copy carries its size range as it is now: the author's ends, and the rest as far as the parts
+    allow (ADR-0087 decision 6). A board reads the ends from it and does not measure; the figure's row keeps only what
+    the author narrowed.
+  */
+  const measured = {
+    source: serializeFigureAsset(recordFigureInstanceSize(asset)),
+    format: asset.version,
+    kernel: FIGURE_KERNEL_VERSION,
+    metrics: figureReleaseMetricsOf(asset),
+    topView: figureTopViewOf(asset, null)
+  }
   if (!releasedJson) return { ...measured, changes: [] }
   let before: FigureAsset
   try {
@@ -724,6 +736,16 @@ export function releaseRecordOf(
   return { ...measured, changes: figureContractChanges(before, asset) }
 }
 
+/**
+ * A release's source made a draft's again (a revert): the size ends its release wrote down, as far as the parts allow,
+ * are opened, and the author's own are kept (ADR-0087 decision 6). An author's end that equals the computed one is
+ * opened with them.
+ */
+export function draftSourceOfRelease(releasedJson: string): string {
+  assertFormat(releasedJson)
+  return serializeFigureAsset(forgetRecordedInstanceSize(parseFigureAsset(releasedJson)))
+}
+
 /**
  * What a consumer is handed for a released figure: the asset itself, because what draws it -- `registerFigure` in
  * things-scene -- takes the asset and compiles it with the kernel.

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

@@ -447,6 +447,8 @@ export class FigureMutation {
       state: 'released',
       updater: user,
       /* 판본 구독자가 이것들을 판본의 comment · assetFormat · kernelVersion · changes 로 옮긴다. Figure 의 칸이 아니다. */
+      /* The release's own copy, its size range written down; the figure keeps the author's (ADR-0087 decision 6). */
+      __releaseSource: record.source,
       __releaseComment: comment ?? null,
       __releaseFormat: record.format,
       __releaseKernel: record.kernel,

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

@@ -442,8 +442,9 @@ async function releaseNumbered(figure: Figure, version: number): Promise<{ figur
 /**
  * Finds the released source of a type in one domain, or null.
  *
- * A released row gives its own source; a draft row gives the source of its latest released history.
- * A figure that was never released gives null, because drafts never reach consumers.
+ * Always the latest release's own copy, from history: it carries the size range written down at release (ADR-0087
+ * decision 6), and the figure's row -- released or a draft -- keeps only the ends its author narrowed. A figure that
+ * was never released gives null, because drafts never reach consumers.
  */
 async function releasedSourceOf(
   domainId: string,
@@ -452,10 +453,6 @@ async function releasedSourceOf(
   const figure = await getRepository(Figure).findOne({ where: { domain: { id: domainId }, type } })
   if (!figure) return null
 
-  if (figure.state === 'released' && figure.source) {
-    return { figure, source: figure.source, version: figure.version }
-  }
-
   const latestReleased = await getRepository(FigureHistory).findOne({
     where: { domain: { id: domainId }, originalId: figure.id, state: 'released' },
     order: { version: 'DESC' }

package/server/service/figure/figure-release-size-db.test.ts

@@ -0,0 +1,156 @@
+/**
+ * The size range a board reads is the release's own copy (ADR-0087 decision 10, user 2026-10-21). The figure's row keeps
+ * only the ends its author narrowed; a release writes the rest down as far as the parts allow, on its history row. Every
+ * door a release leaves by -- one figure for a board, several by full name, the package another server imports -- hands
+ * out that copy, never the row. A release made a draft again opens what the release wrote down.
+ */
+import type { DataSource } from 'typeorm'
+
+const { DataSource: TypeOrmDataSource } = require('typeorm')
+const { createHash } = require('crypto')
+const JSZip = require('jszip')
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+const settingBase = require('@things-factory/setting-base')
+const { createFigureAsset, addFigureBox, serializeFigureAsset, applyFigureAuthoring, proposeFigureOccupancy, readFigurePackage } = require('@hatiolab/figure-model')
+
+let dataSource: DataSource | null = null
+let Figure: any
+let FigureMutation: any
+let FigureQuery: any
+let figurePackageOf: any
+let revertKeepingDraft: any
+let FigureHistory: any
+let FigureNamespace: any
+
+function loadCompiled(modulePath: string): any {
+  const { existsSync } = require('fs')
+  const { join } = require('path')
+  const resolved = join(__dirname, '..', '..', '..', 'dist-server', `${modulePath}.js`)
+  if (!existsSync(resolved))
+    throw new Error(`figure-service 산출물이 없다: ${resolved}\n먼저 빌드할 것:\n  yarn workspace @things-factory/figure-service build:server`)
+  return require(resolved)
+}
+
+beforeAll(async () => {
+  Figure = loadCompiled('service/figure/figure').Figure
+  FigureHistory = loadCompiled('service/figure/figure-history').FigureHistory
+  FigureNamespace = loadCompiled('service/figure/figure-namespace-entity').FigureNamespace
+  const FigureReplacedDraft = loadCompiled('service/figure/figure-replaced-draft').FigureReplacedDraft
+  const Subscriber = loadCompiled('service/figure/event-subscriber').FigureHistoryEntitySubscriber
+  ;({ FigureMutation } = loadCompiled('service/figure/figure-mutation'))
+  ;({ FigureQuery } = loadCompiled('service/figure/figure-query'))
+  ;({ figurePackageOf } = loadCompiled('service/figure/figure-package-export'))
+  ;({ revertKeepingDraft } = loadCompiled('service/figure/figure-revert'))
+  dataSource = new TypeOrmDataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [...shell.entities, ...authBase.entities, ...settingBase.entities, Figure, FigureHistory, FigureNamespace, FigureReplacedDraft],
+    subscribers: [Subscriber],
+    logging: false
+  })
+  await dataSource.initialize()
+  shell.addDataSource('default', dataSource)
+  shell.addDataSource('tx', dataSource)
+})
+
+afterAll(async () => {
+  await dataSource?.destroy()
+  dataSource = null
+})
+
+/*
+  The user's figure (2026-10-21): a box that follows the figure's size, with a cavity ticked on it. Below twice its wall it
+  has no inside, so its width has a smallest size its parts set; nothing limits how large it grows. The height is
+  narrowed by the author, 50 to 400 mm.
+*/
+const buttonBox = () => {
+  let a = addFigureBox(createFigureAsset('Button box'), { id: 'box', size: { x: 120, y: 60, z: 80 }, position: { x: 0, y: 30, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'box', to: { plane: 'mounting-plane' } })
+  a = applyFigureAuthoring(a, { kind: 'follow-size', part: 'box' })
+  a = applyFigureAuthoring(a, { kind: 'set-cavity', part: 'box', cavity: { wall: 10, start: { closed: 10 }, end: 'open' } })
+  a = applyFigureAuthoring(a, { kind: 'declare-instance-size', range: { y: { min: 50, max: 400 } }, replace: true })
+  return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a, { over: 'range' }), placement: 'floor' }))
+}
+const sizeOf = (source: string | object, axis: 'x' | 'y' | 'z') => {
+  const asset = typeof source === 'string' ? JSON.parse(source) : source
+  const { min, max } = asset.document.model.inputs.find((i: any) => i.id === `size.${axis}`)
+  return { min, max }
+}
+/** The width's smallest size as the parts set it: twice the wall, and the kernel's numerical step above it. */
+const widthFloor = (min: number | undefined) => typeof min === 'number' && min > 20 && min < 20.001
+
+let seq = 0
+async function domainWith(namespace: string) {
+  const name = `size-${++seq}`
+  const domain = await dataSource!.getRepository(shell.Domain).save({ name, subdomain: name })
+  await dataSource!.getRepository(FigureNamespace).save({ domain, name: namespace, state: 'active', isDefault: true })
+  return { domain, context: { state: { domain, user: undefined, tx: dataSource!.manager } } }
+}
+const creationId = () => require('crypto').randomUUID()
+
+async function released(type: string) {
+  const ns = `size-${++seq}.hatiolab.com`
+  const { domain, context } = await domainWith(ns)
+  const saved = await new FigureMutation().saveFigure(buttonBox(), context, undefined, undefined, creationId(), undefined, type, undefined, undefined)
+  await new FigureMutation().releaseFigure(saved.id, 'first', context)
+  const figure = await dataSource!.getRepository(Figure).findOneOrFail({ where: { id: saved.id } })
+  const history = await dataSource!.getRepository(FigureHistory).findOneOrFail({ where: { originalId: saved.id, version: 1 } })
+  return { ns, domain, context, figure, history }
+}
+
+describe('the size range a release carries', () => {
+  it('is written on the release, and the figure keeps only what its author narrowed', async () => {
+    const { figure, history } = await released('button-box')
+    expect(figure.state).toBe('released')
+    expect(sizeOf(figure.source, 'x')).toEqual({ min: undefined, max: undefined })
+    expect(sizeOf(figure.source, 'y')).toEqual({ min: 50, max: 400 })
+    const x = sizeOf(history.source, 'x')
+    expect(widthFloor(x.min)).toBe(true)
+    expect(x.max).toBeUndefined()
+    expect(sizeOf(history.source, 'y')).toEqual({ min: 50, max: 400 })
+  })
+
+  it('is what every door a release leaves by hands out: one for a board, several by full name, a package', async () => {
+    const { ns, domain, context, history } = await released('button-box')
+    const one = await new FigureQuery().figureBlueprint('button-box', context)
+    expect(widthFloor(sizeOf(one.asset, 'x').min)).toBe(true)
+    const pinned = await new FigureQuery().figureBlueprint('button-box', context, 1)
+    expect(widthFloor(sizeOf(pinned.asset, 'x').min)).toBe(true)
+    const several = await new FigureQuery().figureBlueprints([`${ns}/button-box`], context)
+    expect(widthFloor(sizeOf(several.items[0].asset, 'x').min)).toBe(true)
+
+    const { bytes } = await figurePackageOf({
+      refs: [`${ns}/button-box@1`],
+      domain,
+      exportedBy: 'author',
+      sourceUrl: 'https://figure.hatiolab.com',
+      files: { put: async () => ({}), send: async () => {}, read: async () => Buffer.alloc(0) }
+    })
+    const zip = await JSZip.loadAsync(bytes)
+    const files = new Map<string, Uint8Array>()
+    for (const path of Object.keys(zip.files)) if (!zip.files[path].dir) files.set(path, await zip.files[path].async('uint8array'))
+    const read = readFigurePackage(files, (b: Uint8Array) => createHash('sha256').update(b).digest('hex'))
+    expect(read.releases[0].source).toBe(history.source)
+  })
+
+  it('released again unchanged, nothing is said to have narrowed', async () => {
+    const { figure, context } = await released('button-box')
+    await dataSource!.getRepository(Figure).save({ ...figure, state: 'draft' })
+    await new FigureMutation().releaseFigure(figure.id, 'again', context)
+    const second = await dataSource!.getRepository(FigureHistory).findOneOrFail({ where: { originalId: figure.id, version: 2 } })
+    expect(JSON.parse(second.changes)).toEqual([])
+  })
+
+  it('made a draft again by a revert, what the release wrote down is opened and the author keeps theirs', async () => {
+    const { figure, domain } = await released('button-box')
+    const draft = await dataSource!.getRepository(Figure).save({ ...figure, state: 'draft' })
+    await dataSource!.transaction(tx => revertKeepingDraft(tx, domain, undefined, { id: figure.id, version: 1, requestId: creationId(), expectedSource: draft.source }))
+    const back = await dataSource!.getRepository(Figure).findOneOrFail({ where: { id: figure.id } })
+    expect(sizeOf(back.source, 'x')).toEqual({ min: undefined, max: undefined })
+    expect(sizeOf(back.source, 'y')).toEqual({ min: 50, max: 400 })
+  })
+})

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

@@ -5,7 +5,7 @@ import { GraphQLError } from 'graphql'
 import { Figure } from './figure.js'
 import { FigureHistory } from './figure-history.js'
 import { FigureReplacedDraft } from './figure-replaced-draft.js'
-import { parseSource } from './figure-format.js'
+import { draftSourceOfRelease, parseSource } from './figure-format.js'
 import { sourceConflict } from './figure-write.js'
 
 /*
@@ -77,7 +77,7 @@ export async function revertKeepingDraft(
   })
   if (!history) throw refused('FIGURE_VERSION_NOT_FOUND', `Figure '${figure.type}' 에 ${request.version} 판이 없습니다.`)
   /* The format is checked again: an old version may break today's rules, and is not let in quietly. */
-  const { source, derived, violations } = parseSource(history.source)
+  const { source, derived, violations } = parseSource(draftSourceOfRelease(history.source!))
 
   const record = await keep(kept, {
     domain: { id: domain.id },