@things-factory/figure-service 10.1.146 → 10.1.149

package/server/service/figure/figure-mesh-db.test.ts

@@ -0,0 +1,244 @@
+/**
+ * A mesh part's file on the authoring server (ADR-0129 decisions 5, 6 and 8), on sqlite through the real doors: kept
+ * once per content per domain after it is read, refused by name when a board cannot draw it, required by every save
+ * that names it, served behind the figure permission from this domain or its parent, and carried by a package.
+ * The files go to a map instead of the configured storage.
+ */
+import type { DataSource } from 'typeorm'
+
+const { DataSource: TypeOrmDataSource } = require('typeorm')
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+const attachmentBase = require('@things-factory/attachment-base')
+const settingBase = require('@things-factory/setting-base')
+const JSZip = require('jszip')
+const { createFigureAsset, addFigurePrimitive, serializeFigureAsset, readFigurePackage } = require('@hatiolab/figure-model')
+
+let dataSource: DataSource | null = null
+let Figure: any, FigureHistory: any, FigureReplacedDraft: any, FigureMutation: any
+let keepMesh: any, useThumbnailFiles: any, sha256Of: any, sendFigureMesh: any, figurePackageOf: 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)
+}
+
+function mapFiles() {
+  const kept = new Map<string, Buffer>()
+  let n = 0
+  return {
+    kept,
+    async put(bytes: Buffer, _mimetype: string, name: string) {
+      const id = `00000000-0000-4000-8000-${String(++n).padStart(12, '0')}`
+      const path = `${id}.${name.split('.').pop()}`
+      kept.set(path, bytes)
+      return { id, path, size: bytes.length }
+    },
+    async send(koa: any, path: string) {
+      koa.body = kept.get(path)
+    },
+    async read(path: string) {
+      return kept.get(path)!
+    }
+  }
+}
+
+/** A GLB of one box, 2 m along X: its JSON, padded, and an empty binary chunk. `tag` makes another file of it. */
+function glb(tag = 'crane', over: Record<string, unknown> = {}): Buffer {
+  let text = JSON.stringify({
+    asset: { version: '2.0', generator: tag },
+    scenes: [{ nodes: [0] }],
+    nodes: [{ name: 'body', mesh: 0 }],
+    meshes: [{ primitives: [{ attributes: { POSITION: 0 }, indices: 1 }] }],
+    accessors: [{ count: 24, min: [-1, 0, -0.2], max: [1, 0.5, 0.2] }, { count: 36 }],
+    buffers: [{ byteLength: 0 }],
+    ...over
+  })
+  while (text.length % 4) text += ' '
+  const body = Buffer.from(text)
+  const out = Buffer.alloc(28 + body.length)
+  out.writeUInt32LE(0x46546c67, 0)
+  out.writeUInt32LE(2, 4)
+  out.writeUInt32LE(out.length, 8)
+  out.writeUInt32LE(body.length, 12)
+  out.writeUInt32LE(0x4e4f534a, 16)
+  body.copy(out, 20)
+  out.writeUInt32LE(0, 20 + body.length)
+  out.writeUInt32LE(0x004e4942, 24 + body.length)
+  return out
+}
+
+const sourceWith = (hash: string) =>
+  serializeFigureAsset(
+    addFigurePrimitive(createFigureAsset('Crane'), {
+      id: 'body',
+      kind: 'mesh',
+      dimensions: { size: 2000 },
+      mesh: { asset: hash, format: 'glb', unit: 'm', bounds: { min: { x: -1000, y: 0, z: -200 }, max: { x: 1000, y: 500, z: 200 } }, triangles: 12, primitives: 1 },
+      position: { x: 0, y: 0, z: 0 }
+    })
+  )
+
+let files: ReturnType<typeof mapFiles>
+let restore: any
+beforeAll(async () => {
+  Figure = loadCompiled('service/figure/figure').Figure
+  FigureHistory = loadCompiled('service/figure/figure-history').FigureHistory
+  FigureReplacedDraft = loadCompiled('service/figure/figure-replaced-draft').FigureReplacedDraft
+  FigureMutation = loadCompiled('service/figure/figure-mutation').FigureMutation
+  ;({ keepMesh } = loadCompiled('service/figure/figure-mesh-store'))
+  ;({ useThumbnailFiles, sha256Of } = loadCompiled('service/figure/figure-thumbnail-store'))
+  ;({ sendFigureMesh } = loadCompiled('routers/figure-mesh-router'))
+  ;({ figurePackageOf } = loadCompiled('service/figure/figure-package-export'))
+  dataSource = new TypeOrmDataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [...shell.entities, ...authBase.entities, ...attachmentBase.entities, ...settingBase.entities, Figure, FigureHistory, FigureReplacedDraft],
+    logging: false
+  })
+  await dataSource.initialize()
+  shell.addDataSource('default', dataSource)
+  shell.addDataSource('tx', dataSource)
+})
+
+afterAll(async () => {
+  shell.removeDataSource('default')
+  shell.removeDataSource('tx')
+  await dataSource?.destroy()
+  dataSource = null
+})
+
+beforeEach(() => {
+  files = mapFiles()
+  restore = useThumbnailFiles(files)
+})
+afterEach(() => useThumbnailFiles(restore))
+
+let seq = 0
+const newDomain = async (parent?: any) => {
+  const name = `mesh-${++seq}`
+  const saved = await dataSource!.getRepository(shell.Domain).save({ name, subdomain: name, ...(parent ? { parent } : {}) })
+  const domain = await dataSource!.getRepository(shell.Domain).findOneOrFail({ where: { id: saved.id } })
+  await dataSource!.getRepository(settingBase.Setting).save({ domain, name: 'figure-namespace', category: 'figure', value: 'system' })
+  return domain
+}
+const meshRows = (domainId: string) => dataSource!.getRepository(attachmentBase.Attachment).find({ where: { refType: 'figure-mesh', domain: { id: domainId } } })
+const upload = (domain: any, bytes: Buffer) =>
+  dataSource!.transaction(tx =>
+    new FigureMutation().uploadFigureMesh(Promise.resolve({ createReadStream: () => require('stream').Readable.from([bytes]) }), { state: { domain, user: undefined, tx } })
+  )
+const save = (domain: any, source: string) =>
+  dataSource!.transaction(tx =>
+    new FigureMutation().saveFigure(source, { state: { domain, user: undefined, tx } }, undefined, undefined, require('crypto').randomUUID())
+  )
+const koa = () => ({ status: 404, type: '', body: undefined as any, headers: {} as Record<string, string>, set(k: string, v: string) { this.headers[k] = v }, fresh: false })
+
+describe('keeping a GLB', () => {
+  it('reads it, keeps it once per content in a domain, and answers its hash and what it holds', async () => {
+    const domain = await newDomain()
+    const first = await upload(domain, glb())
+    const again = await upload(domain, glb())
+    expect(first.hash).toBe(sha256Of(glb()))
+    expect(again.hash).toBe(first.hash)
+    expect(first.summary).toMatchObject({ triangles: 12, primitives: 1, bounds: { min: { x: -1000, y: 0, z: -200 }, max: { x: 1000, y: 500, z: 200 } } })
+    expect(await meshRows(domain.id)).toHaveLength(1)
+    expect(files.kept.size).toBe(1)
+  })
+
+  it('refuses a file a board cannot draw, by its reason, and keeps nothing', async () => {
+    const domain = await newDomain()
+    await expect(upload(domain, glb('draco', { extensionsRequired: ['KHR_draco_mesh_compression'] }))).rejects.toMatchObject({
+      code: 'figure-mesh-extension',
+      params: { extensions: 'KHR_draco_mesh_compression' }
+    })
+    await expect(upload(domain, Buffer.from('not a model'))).rejects.toMatchObject({ code: 'figure-mesh-not-glb' })
+    expect(await meshRows(domain.id)).toHaveLength(0)
+    expect(files.kept.size).toBe(0)
+  })
+})
+
+describe('a save names only files the domain holds', () => {
+  it('refuses a figure whose mesh file was never kept here, and saves it once it is', async () => {
+    const domain = await newDomain()
+    const hash = sha256Of(glb())
+    await expect(save(domain, sourceWith(hash))).rejects.toMatchObject({ code: 'figure-mesh-missing' })
+    expect(await dataSource!.getRepository(Figure).count({ where: { domain: { id: domain.id } } })).toBe(0)
+    await upload(domain, glb())
+    const saved = await save(domain, sourceWith(hash))
+    expect(saved.id).toBeTruthy()
+  })
+
+  it("a child domain may name its parent's files, and not another domain's", async () => {
+    const parent = await newDomain()
+    const child = await newDomain(parent)
+    const stranger = await newDomain()
+    const hash = (await upload(parent, glb())).hash
+    await expect(save(child, sourceWith(hash))).resolves.toBeTruthy()
+    await expect(save(stranger, sourceWith(hash))).rejects.toMatchObject({ code: 'figure-mesh-missing' })
+  })
+})
+
+describe('serving a mesh file', () => {
+  it("serves it from this domain or its parent, with its hash as its tag, and never another domain's", async () => {
+    const parent = await newDomain()
+    const child = await newDomain(parent)
+    const stranger = await newDomain()
+    const hash = (await upload(parent, glb())).hash
+    const asked = async (domain: any) => {
+      const k = koa()
+      await sendFigureMesh(k, async () => {}, hash, domain, files)
+      return k
+    }
+    const ok = await asked(child)
+    expect(ok.status).toBe(200)
+    expect(ok.type).toBe('model/gltf-binary')
+    expect(ok.headers.ETag).toBe(`"${hash}"`)
+    expect(Buffer.compare(ok.body, glb())).toBe(0)
+    expect((await asked(stranger)).status).toBe(404)
+    const k = koa()
+    await sendFigureMesh(k, async () => {}, '../etc/passwd', child, files)
+    expect(k.status).toBe(404)
+  })
+})
+
+describe('a package carries the files its releases draw from', () => {
+  const release = async (domain: any, hash: string) => {
+    const figure = await save(domain, sourceWith(hash))
+    await dataSource!.getRepository(Figure).update({ id: figure.id }, { namespace: 'system', type: 'crane' })
+    await dataSource!.getRepository(FigureHistory).save({
+      originalId: figure.id, version: 1, type: 'crane', name: 'Crane', source: sourceWith(hash), state: 'released', domain
+    })
+  }
+  const unpack = async (bytes: Buffer) => {
+    const zip = await JSZip.loadAsync(bytes)
+    const out = new Map<string, Uint8Array>()
+    for (const name of Object.keys(zip.files)) out.set(name, await zip.files[name].async('uint8array'))
+    return readFigurePackage(out, (b: Uint8Array) => sha256Of(Buffer.from(b)))
+  }
+
+  it('writes the GLB as a mesh blob a board reads back whole', async () => {
+    const domain = await newDomain()
+    const hash = (await upload(domain, glb())).hash
+    await release(domain, hash)
+    const packed = await figurePackageOf({ refs: ['system/crane@1'], domain, exportedBy: null, sourceUrl: 'https://figure.example', files })
+    const read = await unpack(packed.bytes)
+    expect(read.problems).toEqual([])
+    expect(read.refused).toEqual([])
+    expect(read.blobs.get(hash)?.contentType).toBe('model/gltf-binary')
+  })
+
+  it('refuses a package whose release draws from a file that is gone', async () => {
+    const domain = await newDomain()
+    const hash = (await upload(domain, glb())).hash
+    await release(domain, hash)
+    files.kept.clear()
+    await expect(figurePackageOf({ refs: ['system/crane@1'], domain, exportedBy: null, sourceUrl: 'u', files })).rejects.toMatchObject({ code: 'figure-package-mesh-missing' })
+  })
+})

package/server/service/figure/figure-mesh-store.ts

@@ -0,0 +1,91 @@
+import { In } from 'typeorm'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { figureFilesOf } from '@hatiolab/figure-model'
+import { Refusal } from '@things-factory/shell'
+
+import { GLB_MIMETYPE, readGlb, type GlbSummary } from './figure-glb.js'
+import { sha256Of, thumbnailFiles, type ThumbnailFiles } from './figure-thumbnail-store.js'
+
+/*
+ * A mesh part's file (ADR-0129 decision 6), kept as a thumbnail is (ADR-0104 decision 6): by attachment-base's storage,
+ * one attachment per (domain, content), refType `figure-mesh`, refBy the SHA-256 of the bytes. A figure's source names
+ * it by that hash and nothing else; the bytes are served only through `/figure-mesh/:hash`, behind the figure query
+ * permission.
+ *
+ * A file is read before it is kept (`readGlb`): one a board cannot draw is refused by name, never kept under a hash.
+ * The file is written before the row that names it, as a picture is: a file cannot be rolled back.
+ */
+
+export const MESH_REF_TYPE = 'figure-mesh'
+
+type Tx = { getRepository: (target: any) => any }
+
+/** The attachment holding this file in one of these domains -- the asker's first, then its parent's -- or undefined. */
+export async function meshAttachmentOf(tx: Tx, domainIds: readonly string[], hash: string): Promise<Attachment | undefined> {
+  const found: Attachment[] = await tx.getRepository(Attachment).find({
+    where: { domain: { id: In([...domainIds]) }, refType: MESH_REF_TYPE, refBy: hash },
+    relations: { domain: true }
+  })
+  return domainIds.map(id => found.find(a => a.domain?.id === id)).find(Boolean)
+}
+
+/** Keeps a GLB and gives its hash and what it holds. Refused, by the reader's code, when a board cannot draw it. */
+export async function keepMesh(
+  tx: Tx,
+  domain: { id: string },
+  user: unknown,
+  bytes: Buffer,
+  files: ThumbnailFiles = thumbnailFiles()
+): Promise<{ hash: string; summary: GlbSummary }> {
+  const summary = readGlb(bytes)
+  const hash = sha256Of(bytes)
+  if (await meshAttachmentOf(tx, [domain.id], hash)) return { hash, summary }
+  const name = `${hash}.glb`
+  /* The file first: it cannot be rolled back. The row that names it comes after, in the caller's transaction. */
+  const put = await files.put(bytes, GLB_MIMETYPE, name, { state: { domain, user, tx } })
+  await tx.getRepository(Attachment).save({
+    domain,
+    creator: user,
+    updater: user,
+    id: put.id,
+    name,
+    mimetype: GLB_MIMETYPE,
+    encoding: 'binary',
+    refType: MESH_REF_TYPE,
+    refBy: hash,
+    category: 'model',
+    size: String(put.size),
+    path: put.path,
+    ...(put.contents ? { contents: put.contents } : {})
+  })
+  return { hash, summary }
+}
+
+/** What a kept file holds, read again from its bytes: the modeller asks when it reopens a figure. */
+export async function meshSummaryOf(
+  tx: Tx,
+  domain: { id: string; parentId?: string | null },
+  hash: string,
+  files: ThumbnailFiles = thumbnailFiles()
+): Promise<GlbSummary | undefined> {
+  const kept = await meshAttachmentOf(tx, [domain.id, domain.parentId].filter(Boolean) as string[], hash)
+  return kept ? readGlb(await files.read(kept.path!)) : undefined
+}
+
+/**
+ * A source may name only files this domain holds (or its parent, whose figures it reads): a figure that names a file
+ * nobody kept cannot be drawn anywhere, and is refused when it is saved, not when a board finds out.
+ */
+export async function requireMeshFiles(tx: Tx, domain: { id: string; parentId?: string | null }, source: string): Promise<void> {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(source)
+  } catch {
+    return /* the format check refuses it, with its own words */
+  }
+  const ids = [domain.id, domain.parentId].filter(Boolean) as string[]
+  for (const hash of figureFilesOf(parsed))
+    if (!(await meshAttachmentOf(tx, ids, hash)))
+      throw new Refusal('figure-mesh-missing', { hash }, 'the figure names a mesh file this domain does not hold: {hash}. Upload the file again.')
+}

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

@@ -17,6 +17,26 @@ import { namespaceForNewFigure, namespaceOf } from './figure-namespace.js'
 import { parseSource } from './figure-format.js'
 import { ProposeFigureFailure, proposeFigureSteps } from './figure-propose-steps.js'
 import { prepareFigureWrite, compareAndSwapFigure, pictureOf } from './figure-write.js'
+import { keepMesh, requireMeshFiles } from './figure-mesh-store.js'
+import { GlbRefusal, GLB_MAX_BYTES } from './figure-glb.js'
+import { FigureMeshUpload } from './figure-type.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+
+/*
+ * A GLB a board cannot draw, said by its reason (ADR-0129): each reason its own code, so a screen speaks it in its own
+ * words (`error.figure-mesh-*`) and never the reader's English.
+ */
+const MESH_REFUSALS: Record<GlbRefusal['code'], string> = {
+  GLB_NOT_BINARY: 'figure-mesh-not-glb',
+  GLB_VERSION: 'figure-mesh-version',
+  GLB_UNREADABLE: 'figure-mesh-unreadable',
+  GLB_EXTERNAL: 'figure-mesh-external',
+  GLB_EXTENSION: 'figure-mesh-extension',
+  GLB_NO_MESH: 'figure-mesh-empty',
+  GLB_TOO_LARGE: 'figure-mesh-too-large'
+}
+const meshRefusal = (e: GlbRefusal) => new Refusal(MESH_REFUSALS[e.code], e.params, e.message)
 
 /** Display names by language: a language code to a name of 1-128 characters. Refused whole, with the bad entry named. */
 export function assertNames(names: unknown): asserts names is Record<string, string> {
@@ -64,6 +84,8 @@ export class FigureMutation {
   ): Promise<Figure> {
     const { domain, user, tx } = context.state
     const repository = tx.getRepository(Figure)
+    /* Every file the source draws from is one this domain holds (ADR-0129). */
+    await requireMeshFiles(tx, domain, source)
     if (!id) {
       if (!creationId || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(creationId))
         throw Error('새 모델 저장에는 생성 요청 식별자가 필요합니다.')
@@ -111,6 +133,34 @@ export class FigureMutation {
     return repository.findOneOrFail({ where: { id, domain: { id: domain.id } } })
   }
 
+  /**
+   * A GLB for a mesh part (ADR-0129 decision 6): read, then kept by its hash. Answers the hash and what the file holds --
+   * its bounds in mm, its triangles and primitives, and its nodes -- which the modeller turns into a part. A file a board
+   * cannot draw is refused by name and not kept.
+   */
+  @Directive('@transaction')
+  @Directive('@privilege(category: "figure", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => FigureMeshUpload, { description: 'Keeps a GLB for mesh parts and answers its hash and what it holds.' })
+  async uploadFigureMesh(@Arg('file', type => GraphQLUpload) file: FileUpload, @Ctx() context: ResolverContext): Promise<FigureMeshUpload> {
+    const { domain, user, tx } = context.state
+    const { createReadStream } = await file
+    const chunks: Buffer[] = []
+    let size = 0
+    for await (const chunk of createReadStream()) {
+      size += chunk.length
+      /* Refused as it arrives: a file past the limit is not read whole first. */
+      if (size > GLB_MAX_BYTES) throw meshRefusal(new GlbRefusal('GLB_TOO_LARGE', 'too large', { max: Math.round(GLB_MAX_BYTES / 1024 / 1024) }))
+      chunks.push(Buffer.from(chunk))
+    }
+    try {
+      const { hash, summary } = await keepMesh(tx, domain, user, Buffer.concat(chunks))
+      return { hash, summary }
+    } catch (e) {
+      if (e instanceof GlbRefusal) throw meshRefusal(e)
+      throw e
+    }
+  }
+
   @Directive('@transaction')
   @Directive('@privilege(category: "figure", privilege: "mutation", domainOwnerGranted: true)')
   @Mutation(returns => FigureSaveResult, { description: 'Creates a figure. Rejects when the source violates the format.' })
@@ -139,6 +189,7 @@ export class FigureMutation {
 
     // 형식을 어기면 여기서 던진다. 파생값은 서버가 계산한다.
     const { source, derived, violations } = parseSource(figure.source)
+    await requireMeshFiles(tx, domain, source)
 
     const { thumbnail, ...rest } = figure
     const saved = await repository.save({
@@ -182,6 +233,7 @@ export class FigureMutation {
 
     if (patch.source !== undefined && patch.source !== figure.source) {
       const parsed = parseSource(patch.source)
+      await requireMeshFiles(tx, domain, parsed.source)
       source = parsed.source
       derived = parsed.derived
       violations = parsed.violations

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

@@ -2,6 +2,7 @@ import JSZip from 'jszip'
 import { In } from 'typeorm'
 
 import {
+  figureFilesOf,
   formatFigureRef,
   parseFigureRef,
   writeFigurePackage,
@@ -14,6 +15,8 @@ import { getRepository, Refusal } from '@things-factory/shell'
 import { Figure } from './figure.js'
 import { FigureHistory } from './figure-history.js'
 import { sha256Of, thumbnailAttachmentOf, thumbnailFiles, type ThumbnailFiles } from './figure-thumbnail-store.js'
+import { meshAttachmentOf } from './figure-mesh-store.js'
+import { GLB_MIMETYPE } from './figure-glb.js'
 
 /** The most releases one package carries. */
 export const FIGURE_PACKAGE_MAX = 200
@@ -55,6 +58,18 @@ export async function figurePackageOf(request: FigurePackageRequest): Promise<{
         if (sha256Of(bytes) === history.thumbnailHash) blobs.set(history.thumbnailHash, { bytes, contentType: picture.mimetype })
       }
     }
+    /*
+      Every file the release draws from goes with it (ADR-0129 decision 5). Looked for in the figure's own domain, then
+      the asker's; one that is gone, or whose bytes are not its hash, refuses the package -- a board could not draw it.
+    */
+    for (const hash of figureFilesOf(JSON.parse(history.source!))) {
+      if (blobs.has(hash)) continue
+      const kept = await meshAttachmentOf({ getRepository }, [figure.domainId!, request.domain.id], hash)
+      const bytes = kept ? await files.read(kept.path!) : undefined
+      if (!bytes || sha256Of(bytes) !== hash)
+        throw new Refusal('figure-package-mesh-missing', { ref: formatFigureRef(ref), hash }, '{ref} draws from a mesh file this server does not hold: {hash}.')
+      blobs.set(hash, { bytes, contentType: GLB_MIMETYPE })
+    }
     releases.push(packageReleaseOf(ref, figure, history, blobs))
   }
 

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

@@ -20,6 +20,7 @@ import { FigureInspection, FigureList, FigureProposalOutcome } from './figure-ty
 import { FigureReplacedDraft } from './figure-replaced-draft.js'
 import { replacedDraftsOf } from './figure-revert.js'
 import { proposalOutcomeOf } from './figure-proposal.js'
+import { meshSummaryOf } from './figure-mesh-store.js'
 
 @Resolver(Figure)
 @UseMiddleware(SpeakRefusals)
@@ -93,6 +94,14 @@ export class FigureQuery {
    * 도형의 현재 정본은 저작 중일 수 있다(초안). 배치된 것이 보는 것은 **마지막으로 발행된 판**이고,
    * 그것을 이 자리가 답한다.
    */
+  /** What a kept GLB holds, read again from its bytes (ADR-0129): the modeller asks when it reopens a figure. */
+  @Directive('@privilege(category: "figure", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => GraphQLJSON, { nullable: true, description: 'What a kept GLB holds, by its hash: bounds in mm, triangles, primitives and nodes. None when this domain does not hold it.' })
+  async figureMeshSummary(@Arg('hash') hash: string, @Ctx() context: ResolverContext): Promise<unknown> {
+    const { domain, tx } = context.state
+    return (await meshSummaryOf(getRepository(Figure, tx).manager, domain, hash)) ?? null
+  }
+
   /** What became of an AI proposal: the figures a save put it into (ADR-0097 §5.6 item 5). */
   @Directive('@privilege(category: "figure", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => [FigureProposalOutcome], {

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

@@ -206,3 +206,13 @@ export class FigureInspection {
   @Field(type => [FigureGateFinding], { description: 'Findings, blocking and advisory together.' })
   findings: FigureGateFinding[]
 }
+
+/** A GLB kept for mesh parts (ADR-0129): its hash, and what it holds as the upload read it. */
+@ObjectType({ description: 'A GLB kept for mesh parts: its hash and what it holds.' })
+export class FigureMeshUpload {
+  @Field({ description: "The file's SHA-256, lower-case hex: what a mesh part names it by." })
+  hash: string
+
+  @Field(type => GraphQLJSON, { description: 'Bounds in mm, triangles, primitives and nodes, as read from the file.' })
+  summary: unknown
+}

package/translations/en.json

@@ -106,5 +106,14 @@
   "error.figure-names-too-many": "at most {max} figure names can be asked at once, not {count}.",
   "error.figure-package-size": "a package carries 1 to {max} releases, not {count}.",
   "error.figure-ref-malformed": "{ref} is not a release reference of the form namespace/type@version.",
-  "error.figure-package-release-not-found": "{ref} is not a release this domain can read."
+  "error.figure-package-release-not-found": "{ref} is not a release this domain can read.",
+  "error.figure-mesh-not-glb": "the file is not a binary glTF (.glb). export it as GLB and upload it again.",
+  "error.figure-mesh-version": "the file is not glTF 2.0. export it as glTF 2.0 and upload it again.",
+  "error.figure-mesh-unreadable": "the file cannot be read: it is cut short or damaged. export it again and upload it.",
+  "error.figure-mesh-external": "the file reads data from other files. export it as one self-contained GLB and upload it again.",
+  "error.figure-mesh-extension": "a board cannot draw this file yet: it needs {extensions}. export it without that compression and upload it again.",
+  "error.figure-mesh-empty": "the file holds no mesh to draw.",
+  "error.figure-mesh-too-large": "the file is larger than {max} MB, the most a board downloads for one part. make it smaller and upload it again.",
+  "error.figure-mesh-missing": "this figure uses a mesh file this domain does not hold ({hash}). upload the file again.",
+  "error.figure-package-mesh-missing": "{ref} uses a mesh file this server does not hold ({hash}); it cannot be packaged."
 }

package/translations/es.json

@@ -106,5 +106,14 @@
   "error.figure-names-too-many": "se pueden consultar como máximo {max} nombres de figura a la vez, no {count}.",
   "error.figure-package-size": "un paquete contiene de 1 a {max} publicaciones, no {count}.",
   "error.figure-ref-malformed": "{ref} no es una referencia de publicación con el formato namespace/type@version.",
-  "error.figure-package-release-not-found": "{ref} no es una publicación que este dominio pueda leer."
+  "error.figure-package-release-not-found": "{ref} no es una publicación que este dominio pueda leer.",
+  "error.figure-mesh-not-glb": "el archivo no es un glTF binario (.glb). expórtelo como GLB y vuelva a subirlo.",
+  "error.figure-mesh-version": "el archivo no es glTF 2.0. expórtelo como glTF 2.0 y vuelva a subirlo.",
+  "error.figure-mesh-unreadable": "no se puede leer el archivo: está cortado o dañado. expórtelo de nuevo y súbalo.",
+  "error.figure-mesh-external": "el archivo lee datos de otros archivos. expórtelo como un único GLB autónomo y vuelva a subirlo.",
+  "error.figure-mesh-extension": "un tablero aún no puede dibujar este archivo: necesita {extensions}. expórtelo sin esa compresión y vuelva a subirlo.",
+  "error.figure-mesh-empty": "el archivo no contiene ninguna malla que dibujar.",
+  "error.figure-mesh-too-large": "el archivo supera los {max} MB, lo máximo que un tablero descarga para una pieza. redúzcalo y vuelva a subirlo.",
+  "error.figure-mesh-missing": "esta figura usa un archivo de malla que este dominio no tiene ({hash}). vuelva a subir el archivo.",
+  "error.figure-package-mesh-missing": "{ref} usa un archivo de malla que este servidor no tiene ({hash}); no se puede empaquetar."
 }

package/translations/ja.json

@@ -106,5 +106,14 @@
   "error.figure-names-too-many": "一度に問い合わせられる Figure 名は {max} 個までです({count} 個)。",
   "error.figure-package-size": "パッケージに含められるリリースは 1〜{max} 個です({count} 個)。",
   "error.figure-ref-malformed": "{ref} は namespace/type@version 形式のリリース参照ではありません。",
-  "error.figure-package-release-not-found": "{ref} はこのドメインで読み込めるリリースではありません。"
+  "error.figure-package-release-not-found": "{ref} はこのドメインで読み込めるリリースではありません。",
+  "error.figure-mesh-not-glb": "ファイルがバイナリ glTF(.glb)ではありません。GLB で書き出して再度アップロードしてください。",
+  "error.figure-mesh-version": "ファイルが glTF 2.0 ではありません。glTF 2.0 で書き出して再度アップロードしてください。",
+  "error.figure-mesh-unreadable": "ファイルを読めません。途中で切れているか破損しています。書き出し直してアップロードしてください。",
+  "error.figure-mesh-external": "ファイルが他のファイルのデータを読みます。1 つにまとめた GLB で書き出して再度アップロードしてください。",
+  "error.figure-mesh-extension": "ボードはまだこのファイルを描けません: {extensions} が必要です。その圧縮なしで書き出して再度アップロードしてください。",
+  "error.figure-mesh-empty": "ファイルに描画するメッシュがありません。",
+  "error.figure-mesh-too-large": "ファイルが {max} MB を超えています。ボードが部品 1 つにダウンロードする上限です。小さくして再度アップロードしてください。",
+  "error.figure-mesh-missing": "この図形が使うメッシュファイル({hash})がこのドメインにありません。ファイルを再度アップロードしてください。",
+  "error.figure-package-mesh-missing": "{ref} が使うメッシュファイル({hash})がこのサーバーにないため、パッケージにできません。"
 }

package/translations/ko.json

@@ -106,5 +106,14 @@
   "error.figure-names-too-many": "Figure 이름은 한 번에 {max}개까지 물을 수 있습니다({count}개).",
   "error.figure-package-size": "꾸러미에는 발행판을 1~{max}개 담을 수 있습니다({count}개).",
   "error.figure-ref-malformed": "{ref} 은 namespace/type@버전 형식의 발행판 참조가 아닙니다.",
-  "error.figure-package-release-not-found": "{ref} 은 이 도메인에서 읽을 수 있는 발행판이 아닙니다."
+  "error.figure-package-release-not-found": "{ref} 은 이 도메인에서 읽을 수 있는 발행판이 아닙니다.",
+  "error.figure-mesh-not-glb": "파일이 바이너리 glTF(.glb)가 아닙니다. GLB 로 내보내 다시 올려 주세요.",
+  "error.figure-mesh-version": "파일이 glTF 2.0 이 아닙니다. glTF 2.0 으로 내보내 다시 올려 주세요.",
+  "error.figure-mesh-unreadable": "파일을 읽을 수 없습니다. 잘렸거나 손상되었습니다. 다시 내보내 올려 주세요.",
+  "error.figure-mesh-external": "파일이 다른 파일의 데이터를 읽습니다. 하나로 묶은 GLB 로 내보내 다시 올려 주세요.",
+  "error.figure-mesh-extension": "보드가 아직 이 파일을 그리지 못합니다: {extensions} 가 필요합니다. 그 압축 없이 내보내 다시 올려 주세요.",
+  "error.figure-mesh-empty": "파일에 그릴 메시가 없습니다.",
+  "error.figure-mesh-too-large": "파일이 {max} MB 보다 큽니다. 보드가 부품 하나에 내려받는 최대 크기입니다. 줄여서 다시 올려 주세요.",
+  "error.figure-mesh-missing": "이 도형이 쓰는 메시 파일({hash})이 이 도메인에 없습니다. 파일을 다시 올려 주세요.",
+  "error.figure-package-mesh-missing": "{ref} 가 쓰는 메시 파일({hash})이 이 서버에 없어 묶을 수 없습니다."
 }

package/translations/ms.json

@@ -106,5 +106,14 @@
   "error.figure-names-too-many": "paling banyak {max} nama figure boleh ditanya sekali gus, bukan {count}.",
   "error.figure-package-size": "pakej membawa 1 hingga {max} terbitan, bukan {count}.",
   "error.figure-ref-malformed": "{ref} bukan rujukan terbitan dalam bentuk namespace/type@version.",
-  "error.figure-package-release-not-found": "{ref} bukan terbitan yang boleh dibaca oleh domain ini."
+  "error.figure-package-release-not-found": "{ref} bukan terbitan yang boleh dibaca oleh domain ini.",
+  "error.figure-mesh-not-glb": "fail ini bukan glTF binari (.glb). eksport sebagai GLB dan muat naik semula.",
+  "error.figure-mesh-version": "fail ini bukan glTF 2.0. eksport sebagai glTF 2.0 dan muat naik semula.",
+  "error.figure-mesh-unreadable": "fail tidak dapat dibaca: ia terpotong atau rosak. eksport semula dan muat naik.",
+  "error.figure-mesh-external": "fail ini membaca data daripada fail lain. eksport sebagai satu GLB yang lengkap dan muat naik semula.",
+  "error.figure-mesh-extension": "papan belum dapat melukis fail ini: ia memerlukan {extensions}. eksport tanpa pemampatan itu dan muat naik semula.",
+  "error.figure-mesh-empty": "fail ini tidak mengandungi jejaring untuk dilukis.",
+  "error.figure-mesh-too-large": "fail ini melebihi {max} MB, had muat turun papan untuk satu bahagian. kecilkan dan muat naik semula.",
+  "error.figure-mesh-missing": "figura ini menggunakan fail jejaring yang tiada dalam domain ini ({hash}). muat naik fail itu semula.",
+  "error.figure-package-mesh-missing": "{ref} menggunakan fail jejaring yang tiada pada pelayan ini ({hash}); ia tidak dapat dipakej."
 }

package/translations/zh.json

@@ -106,5 +106,14 @@
   "error.figure-names-too-many": "一次最多可查询 {max} 个图形名称，而不是 {count} 个。",
   "error.figure-package-size": "一个包可包含 1 到 {max} 个发布版本，而不是 {count} 个。",
   "error.figure-ref-malformed": "{ref} 不是 namespace/type@version 形式的发布版本引用。",
-  "error.figure-package-release-not-found": "{ref} 不是此域可以读取的发布版本。"
+  "error.figure-package-release-not-found": "{ref} 不是此域可以读取的发布版本。",
+  "error.figure-mesh-not-glb": "文件不是二进制 glTF(.glb)。请导出为 GLB 后重新上传。",
+  "error.figure-mesh-version": "文件不是 glTF 2.0。请导出为 glTF 2.0 后重新上传。",
+  "error.figure-mesh-unreadable": "无法读取文件:文件被截断或已损坏。请重新导出后上传。",
+  "error.figure-mesh-external": "文件会读取其他文件中的数据。请导出为单个自包含的 GLB 后重新上传。",
+  "error.figure-mesh-extension": "看板暂时无法绘制此文件:需要 {extensions}。请不使用该压缩重新导出后上传。",
+  "error.figure-mesh-empty": "文件中没有可绘制的网格。",
+  "error.figure-mesh-too-large": "文件大于 {max} MB,这是看板为一个部件下载的上限。请缩小后重新上传。",
+  "error.figure-mesh-missing": "此图形使用的网格文件({hash})不在此域中。请重新上传该文件。",
+  "error.figure-package-mesh-missing": "{ref} 使用的网格文件({hash})不在此服务器上,无法打包。"
 }