@things-factory/figure-ui 10.1.70 → 10.1.71

package/client/modeller/v3-editor.ts

@@ -5,6 +5,8 @@ import '@operato/layout'
 import { customElement, property, state } from 'lit/decorators.js'
 import { live } from 'lit/directives/live.js'
 import { PART_LIMIT, parseV3Recipe, resolveV3Recipe, v3PartCountOf, v3RecipeIdFor } from '@hatiolab/figure-model'
+import type { RecipeTemplate } from './v3-recipes.js'
+import './figure-v3-recipe-catalog.js'
 import type { V3Asset, V3AuthoringAction, V3InputChange, V3PartEdit, V3PrimitiveCreation, V3Recipe, V3RecipeValue } from '@hatiolab/figure-model'
 import type { V3ProductSession } from './v3-product-session.js'
 import { captureV3Thumbnail } from './v3-thumbnail.js'
@@ -262,8 +264,12 @@ export class FigureV3Editor extends LitElement {
     }
   `]
   @property({ attribute: false }) session?: V3ProductSession
-  /** The recipes this domain sees (ADR-0095), given by the page. */
-  @property({ attribute: false }) recipes: V3Recipe[] = []
+  /** The recipe templates (ADR-0095), read by the page from the server. */
+  @property({ attribute: false }) templates: RecipeTemplate[] = []
+  /** Reads a template's guide; given by the page. */
+  @property({ attribute: false }) guideOf?: (name: string) => Promise<string>
+  @property({ attribute: false }) thumbnailOf?: (name: string) => string
+  @state() private catalogOpen = false
   /** Why the last recipe was refused, in the kernel's words. */
   @state() private recipeError = ''
   @property({ type: Number }) revision = 0
@@ -534,6 +540,7 @@ export class FigureV3Editor extends LitElement {
       const steps = resolveV3Recipe(checked, { id, ...(checked.target === 'part' ? { target: this.selected } : {}), values })
       this.session!.applyRecipe(steps)
       this.recipeError = ''
+      this.catalogOpen = false
       this.error = ''
       this.changed()
     } catch (error) {
@@ -989,6 +996,8 @@ export class FigureV3Editor extends LitElement {
   private renderRepeat(asset: V3Asset | undefined, geometry: readonly { id: string }[], unavailable: boolean) {
     const repeat = repeatOf(this.selected, geometry)
     if (!asset || !repeat || repeat.index) return nothing
+    /* The row is set on its part; what hangs from that part is copied with it and has no row of its own. */
+    if (!asset.document.model.nodes.some(n => n.id === `${this.selected}.repeat`)) return nothing
     const model = asset.document.model as unknown as {
       nodes: { id: string; op: string; args: string[]; params?: Record<string, string> }[]
       constants: { id: string; value: number }[]
@@ -1143,6 +1152,18 @@ export class FigureV3Editor extends LitElement {
           </div>`
         : null}
       ${this.notice ? html`<div role="status" class="notice">${this.notice}</div>` : null}
+      ${this.catalogOpen
+        ? html`<figure-v3-recipe-catalog
+            .templates=${this.templates}
+            .selected=${this.selected}
+            .error=${this.recipeError}
+            .guideOf=${this.guideOf}
+            .thumbnailOf=${this.thumbnailOf}
+            ?locked=${unavailable}
+              @insert-recipe=${(e: CustomEvent) => this.insertRecipe(e.detail.recipe, e.detail.values)}
+              @close-catalog=${() => (this.catalogOpen = false)}
+          ></figure-v3-recipe-catalog>`
+        : null}
       <ox-three-pane>
         <figure-v3-parts
           slot="start"
@@ -1154,9 +1175,8 @@ export class FigureV3Editor extends LitElement {
           .selected=${this.selected}
           ?locked=${unavailable}
           @add-part=${(e: CustomEvent) => this.add(e.detail.kind)}
-          .recipes=${this.recipes}
-          .recipeError=${this.recipeError}
-          @insert-recipe=${(e: CustomEvent) => this.insertRecipe(e.detail.recipe, e.detail.values)}
+          .recipeCount=${this.templates.length}
+          @open-recipe-catalog=${() => ((this.catalogOpen = true), (this.recipeError = ''))}
           @select-part=${(e: CustomEvent) => this.choose(e.detail.id)}
           @toggle-part-hidden=${(e: CustomEvent) => this.toggleHiddenPart(e.detail.id)}
           @set-all-parts-hidden=${(e: CustomEvent) =>

package/client/modeller/v3-fields.ts

@@ -42,22 +42,25 @@ export function groupFields(fields: readonly FieldLike[], part?: string): { vect
   return { vectors, singles }
 }
 
+/**
+ * The part a copy copies: the member at the end of its path. A row repeats its part and what is fastened to it
+ * (ADR-0093, 2026-09-26), so the copies of one row are of several parts -- a roller's and the mark on it.
+ */
+const memberOf = (path: unknown[]): string => {
+  const last = [...path].reverse().find((step): step is string => typeof step === 'string')!
+  return last.replace(/\.(placed|value)$/, '').replace(/\.repeat$/, '')
+}
+
 /**
  * The name a person reads for a body. A repeated body's id is its path through the repeats (`["roller.repeat",0,
- * "roller.value"]`), which the list showed as it was; it reads as the repeat's name and the member's place counted
- * from 1 -- `roller 1`, and `rack 2·3` inside two repeats. Any other id is its own name.
+ * "roller.placed"]`), which the list showed as it was; it reads as the part it copies and its place counted from 1 --
+ * `roller 1`, and `mark 1` for the mark the first roller carries. Any other id is its own name.
  */
 export function partLabelOf(id: string): string {
-  if (!id.startsWith('[')) return id
-  let path: unknown
-  try {
-    path = JSON.parse(id)
-  } catch {
-    return id
-  }
-  if (!Array.isArray(path) || typeof path[0] !== 'string') return id
+  const path = pathOf(id)
+  if (!path) return id
   const places = path.filter((step): step is number => typeof step === 'number').map(n => n + 1)
-  return places.length ? `${path[0].replace(/\.repeat$/, '')} ${places.join('·')}` : id
+  return places.length ? `${memberOf(path)} ${places.join('·')}` : id
 }
 
 /**
@@ -66,14 +69,16 @@ export function partLabelOf(id: string): string {
  */
 export function repeatOf(id: string, geometry: readonly unknown[] | undefined): { name: string; count: number; index: number } | null {
   const path = pathOf(id)
+  const paths = (geometry ?? []).map(g => pathOf((g as { id?: string }).id ?? '')).filter((p): p is unknown[] => !!p)
   if (!path) {
-    /* The repeat itself, by its name: how many copies it makes now. */
-    const copies = (geometry ?? []).filter(g => pathOf((g as { id?: string }).id ?? '')?.[0] === `${id}.repeat`).length
+    /* The part itself, by its name: how many copies of it the row makes now. */
+    const copies = paths.filter(p => memberOf(p) === id).length
     return copies ? { name: id, count: copies, index: 0 } : null
   }
-  const count = (geometry ?? []).filter(g => pathOf((g as { id?: string }).id ?? '')?.[0] === path[0]).length
+  const name = memberOf(path)
+  const count = paths.filter(p => p[0] === path[0] && memberOf(p) === name).length
   const index = path.find((step): step is number => typeof step === 'number')
-  return { name: String(path[0]).replace(/\.repeat$/, ''), count, index: (index ?? 0) + 1 }
+  return { name, count, index: (index ?? 0) + 1 }
 }
 
 function pathOf(id: string): unknown[] | null {
@@ -93,6 +98,6 @@ function pathOf(id: string): unknown[] | null {
  */
 export function ownerOf(id: string): string {
   const path = pathOf(id)
-  return path ? String(path[0]).replace(/\.repeat$/, '') : id
+  return path ? memberOf(path) : id
 }
 

package/client/modeller/v3-gizmo.ts

@@ -30,7 +30,7 @@ export interface GizmoReach {
 }
 
 /** Shapes whose first three arguments are the extent along X, Y and Z: a door frame's too (its width, height, depth). */
-const BOXES = new Set(['box-shape@1', 'rounded-box@1', 'portal-profile@2'])
+const BOXES = new Set(['box-shape@1', 'rounded-box@1', 'portal-profile@2', 'hollow-box@2'])
 
 interface Node {
   id: string

package/client/modeller/v3-links.ts

@@ -1,5 +1,5 @@
-import { V3_FACES, v3ShapeFaces, v3PartsExtentOf, compileV3Asset, compileV3Graph, proposeV3Proportion, defaultInstanceSizeRange, foldInstanceSizeRange, v3AttachmentsOf, v3BindingsOf, v3InstanceSizeLimitsOf } from '@hatiolab/figure-model'
-import type { V3SizeRange } from '@hatiolab/figure-model'
+import { V3_FACES, v3ShapeFaces, v3PartsExtentOf, compileV3Asset, compileV3Graph, v3FollowOf, proposeV3Proportion, defaultInstanceSizeRange, foldInstanceSizeRange, v3AttachmentsOf, v3BindingsOf, v3InstanceSizeLimitsOf } from '@hatiolab/figure-model'
+import type { V3Follow, V3SizeRange } from '@hatiolab/figure-model'
 import type { V3Asset, V3BindingPlace, V3Face, V3Joint } from '@hatiolab/figure-model'
 
 /*
@@ -18,76 +18,17 @@ interface Node {
 const modelOf = (asset: V3Asset) =>
   asset.document.model as unknown as { nodes: Node[]; inputs: Array<{ id: string; role?: string; unit?: string; min?: number; max?: number }>; constants: Array<{ id: string; value: number }> }
 
-/** What one dimension of a part is worked out from. */
-export type Follow =
-  | { of: 'own' }
-  /** `times` 1 is the instance size itself; any other is a share of it. */
-  | { of: 'instance'; axis: Axis; times: number; plus?: number }
-  | { of: 'part'; part: string; axis: Axis; times?: number; plus?: number }
-  | { of: 'input'; input: string }
-  /** Worked out some other way (an expression) — shown, not offered as a choice. */
-  | { of: 'expression' }
+/** What one dimension of a part is worked out from (figure-model's `V3Follow`). */
+export type Follow = V3Follow
 
 /**
  * `link-dimension` routes a part's dimension through `<part>.dimension.<axis>` and points its first argument at the
  * source, directly or through the nodes that scale it. Walking back through those nodes finds the source: the
  * instance size (`size.<axis>`), another part's dimension (`<part>.dimension.<axis>.value`) or a declared input.
  */
+/** What one measure of a part is worked out from, read back from the graph (figure-model's reader, one copy). */
 export function followOf(asset: V3Asset, part: string, axis: Axis): Follow {
-  const m = modelOf(asset)
-  /*
-    A link routes the dimension through `<part>.dimension.<axis>`; before any link the shape reads its measure directly,
-    and that may already be worked out (ROBOT_ARM's flange fills what is left).
-  */
-  const node = m.nodes.find(n => n.id === `${part}.dimension.${axis}`)
-  const start = node ? node.args[0] : m.nodes.find(n => n.id === `${part}.shape`)?.args[AXES.indexOf(axis)]
-  if (!start || m.constants.some(c => c.id === start)) return { of: 'own' }
-  const writerOf = (ref: string) => m.nodes.find(n => Object.values(n.outputs).includes(ref))
-  const seen = new Set<string>()
-  const constant = (ref: string) => m.constants.find(c => c.id === ref)
-  /* The constant factors met on the way back: a share of the instance size is `size × share`. */
-  let times = 1
-  /*
-    A link the author made is `source × times + plus` (link-dimension): its outermost sum with a number is the plus --
-    a leaf the opening's width less its gaps. Deeper sums, or a measure no link routes, read as worked out elsewhere.
-  */
-  let plus = 0
-  let at = start
-  const outer = node && writerOf(start)
-  if (outer?.op === 'add@1') {
-    const numbers = outer.args.filter(arg => constant(arg))
-    const onward = outer.args.filter(arg => !constant(arg))
-    if (numbers.length === 1 && onward.length === 1) {
-      plus = constant(numbers[0]!)!.value
-      at = onward[0]!
-    }
-  }
-  const withPlus = <T extends object>(f: T) => (plus ? { ...f, plus } : f)
-  const walk = (ref: string): Follow => {
-    if (seen.has(ref)) return { of: 'expression' }
-    seen.add(ref)
-    const instance = /^size\.([xyz])$/.exec(ref)
-    if (instance) return withPlus({ of: 'instance' as const, axis: instance[1] as Axis, times: Math.round(times * 1e6) / 1e6 })
-    const other = /^(.+)\.dimension\.([xyz])\.value$/.exec(ref)
-    if (other) return withPlus({ of: 'part' as const, part: other[1]!, axis: other[2] as Axis, ...(times !== 1 ? { times: Math.round(times * 1e6) / 1e6 } : {}) })
-    const input = m.inputs.find(i => i.id === ref)
-    if (input) return ref.startsWith(`${part}.`) ? { of: 'own' } : { of: 'input', input: ref }
-    const writer = writerOf(ref)
-    if (!writer) return { of: 'expression' }
-    /* Follow the one argument that is not a constant factor. */
-    const onward = writer.args.filter(arg => !constant(arg))
-    if (onward.length !== 1) return { of: 'expression' }
-    /*
-      Only a product is a share of its source. A sum with a number is not (「fill what is left」 is the size plus a negative
-      gap -- ROBOT_ARM's tool flange), nor anything else; those read as worked out some other way.
-    */
-    const factors = writer.args.filter(arg => constant(arg)).map(arg => constant(arg)!.value)
-    if (writer.op === 'mul@1') times *= factors.reduce((a, b) => a * b, 1)
-    else if (writer.op === 'div@1' && writer.args[0] === onward[0] && factors.length === 1 && factors[0] !== 0) times /= factors[0]!
-    else if (factors.some(v => v !== 0) || !['mul@1', 'div@1', 'add@1', 'sub@1'].includes(writer.op)) return { of: 'expression' }
-    return walk(onward[0]!)
-  }
-  return walk(at)
+  return v3FollowOf(asset, part, axis)
 }
 
 /** Whether the asset declares an instance size on an axis — only then can a dimension follow it. */
@@ -123,7 +64,7 @@ export function followableAxes(asset: V3Asset, part: string): Axis[] {
   const shape = modelOf(asset).nodes.find(n => n.id === `${part}.shape`)
   if (!shape) return []
   /* A door frame's first three measures are its width, height and depth, as a box's (figure-model portal-profile@2). */
-  if (shape.op === 'box-shape@1' || shape.op === 'rounded-box@1' || shape.op === 'portal-profile@2') return [...AXES]
+  if (shape.op === 'box-shape@1' || shape.op === 'rounded-box@1' || shape.op === 'portal-profile@2' || shape.op === 'hollow-box@2') return [...AXES]
   if (shape.op === 'cylinder-shape@1') return ['x', 'y']
   return []
 }

package/client/modeller/v3-palette.ts

@@ -34,6 +34,9 @@ export function paletteRecipe(kind: V3PaletteKind, id: string): V3PrimitiveCreat
       return { ...standing(10), kind: 'box', dimensions: { width: 600, height: 10, depth: 400 } }
     case 'wall':
       return { ...standing(2400), kind: 'box', dimensions: { width: 1000, height: 2400, depth: 100 } }
+    case 'hollow-box':
+      /* A tote at a tote's size: walls and floor that keep their thickness when it grows. */
+      return { ...standing(300), kind: 'hollow-box', dimensions: { width: 600, height: 300, depth: 400, roundX: 20, roundZ: 20, wallX: 10, wallZ: 10, floor: 15 } }
     case 'portal':
       return {
         id,

package/client/modeller/v3-recipe-source.ts

@@ -0,0 +1,15 @@
+import { fetchRecipeGuide, fetchRecipeTemplates } from '../graphql/index.js'
+import { templatesOf, type RecipeTemplate } from './v3-recipes.js'
+
+/**
+ * Where the modeller gets its recipe templates: the server's static files (ADR-0095, amended 2026-09-26). The one place
+ * they are read -- the rules in `v3-recipes.ts` stay free of the network so they are tested without it.
+ */
+export async function availableRecipes(lang: string): Promise<RecipeTemplate[]> {
+  return templatesOf(await fetchRecipeTemplates(lang))
+}
+
+/** One template's guide, or '' while none is written -- the screen then shows no guide and no word about one. */
+export function recipeGuide(name: string, lang: string): Promise<string> {
+  return fetchRecipeGuide(name, lang)
+}

package/client/modeller/v3-recipes.ts

@@ -1,22 +1,24 @@
+import { describeV3Recipe } from '@hatiolab/figure-model'
 import type { V3Recipe, V3RecipeParam, V3RecipeValue } from '@hatiolab/figure-model'
 
+import type { RecipeTemplateRow } from '../graphql/index.js'
+
+/** A template in the catalog: the server's row, its recipe parsed. */
+export interface RecipeTemplate extends Omit<RecipeTemplateRow, 'source'> {
+  recipe: V3Recipe
+}
+
 /*
  * The recipe section's rules (ADR-0095), kept apart from the element so they can be tested without a browser.
  */
 
-/** A recipe's words in the language on screen: that language, else English, else the first it has. */
-export function recipeWord(words: Record<string, string> | undefined, language: string): string {
-  if (!words) return ''
-  return words[language] ?? words[language.split('-')[0]!] ?? words.en ?? Object.values(words)[0] ?? ''
-}
-
-/** The recipes as the server gave them, parsed; a row that is not a recipe is left out rather than breaking the list. */
-export function recipesOf(rows: ReadonlyArray<{ source: string }>): V3Recipe[] {
-  const out: V3Recipe[] = []
-  for (const row of rows) {
+/** The server's rows as templates. A row that is not a recipe is left out rather than breaking the catalog. */
+export function templatesOf(rows: ReadonlyArray<RecipeTemplateRow>): RecipeTemplate[] {
+  const out: RecipeTemplate[] = []
+  for (const { source, ...row } of rows) {
     try {
-      const recipe = JSON.parse(row.source)
-      if (recipe && typeof recipe.name === 'string' && Array.isArray(recipe.steps)) out.push(recipe)
+      const recipe = JSON.parse(source)
+      if (recipe && typeof recipe.name === 'string' && Array.isArray(recipe.steps)) out.push({ ...row, recipe })
     } catch {
       /* not a recipe */
     }
@@ -24,6 +26,34 @@ export function recipesOf(rows: ReadonlyArray<{ source: string }>): V3Recipe[] {
   return out
 }
 
+/** A part the recipe makes, as the catalog names it: its own name, the placeholder left off. */
+export const recipePartName = (part: string) => part.replace(/^\{id\}-/, '')
+
+/**
+ * How a template works, in lines the catalog shows -- worked out from its steps (figure-model `describeV3Recipe`), each
+ * a translation key and its words.
+ */
+export function recipeWorkings(recipe: V3Recipe): Array<{ key: string; words: Record<string, string | number> }> {
+  const d = describeV3Recipe(recipe)
+  const lines: Array<{ key: string; words: Record<string, string | number> }> = []
+  for (const m of d.moves)
+    lines.push(
+      m.follows
+        ? { key: 'figure.text.recipe-moves-with', words: { part: recipePartName(m.part), leader: recipePartName(m.follows) } }
+        : { key: m.kind === 'slide' ? 'figure.text.recipe-slides' : 'figure.text.recipe-turns', words: { part: recipePartName(m.part) } }
+    )
+  if (d.controls.length) lines.push({ key: 'figure.text.recipe-controls', words: { count: d.controls.length } })
+  if (d.shownByControl.length) lines.push({ key: 'figure.text.recipe-shown-by-control', words: { parts: d.shownByControl.map(recipePartName).join(', ') } })
+  for (const row of d.rows) lines.push({ key: 'figure.text.recipe-row', words: { part: recipePartName(row) } })
+  return lines
+}
+
+/** A recipe's words in the language on screen: that language, else English, else the first it has. */
+export function recipeWord(words: Record<string, string> | undefined, language: string): string {
+  if (!words) return ''
+  return words[language] ?? words[language.split('-')[0]!] ?? words.en ?? Object.values(words)[0] ?? ''
+}
+
 /** Whether a recipe can be put in now: one for a part needs a part chosen. */
 export function recipeReady(recipe: Pick<V3Recipe, 'target'>, selected: string): boolean {
   return recipe.target === 'figure' || !!selected
@@ -50,20 +80,13 @@ export function recipeFieldOf(param: V3RecipeParam, value: V3RecipeValue): strin
   return String(value)
 }
 
-/** The domain on screen, from the address (`/domain/<subdomain>/…`); '' when the address names none. */
-export function subdomainOf(pathname: string): string {
-  return /^\/domain\/([^/]+)/.exec(pathname)?.[1] ?? ''
-}
-
-/** Whose a recipe row is: this domain's own (it may change it) or a parent's (copied in to be changed). */
-export function recipeIsOwn(row: { domain?: { subdomain?: string } }, subdomain: string): boolean {
-  return !!subdomain && row.domain?.subdomain === subdomain
-}
 
-/** What a parameter takes, in a few words: a range, a percentage range, or its options. */
-export function paramRangeOf(param: V3RecipeParam): string {
-  if (param.kind === 'ratio') return `${recipeFieldOf(param, param.min ?? 0)} – ${recipeFieldOf(param, param.max ?? 1)} %`
-  if (param.kind === 'mm') return `${param.min ?? ''} – ${param.max ?? ''} mm`
-  if (param.kind === 'flag') return ''
-  return (param.options ?? []).join(' / ')
+/** The templates a category and words find: a word matches the title, the description, the name or a tag. */
+export function recipesMatching<T extends { category: string; title: string; description: string; name: string; tags: string[] }>(templates: readonly T[], category: string, query: string): T[] {
+  const words = query.trim().toLowerCase().split(/\s+/).filter(Boolean)
+  return templates.filter(t => {
+    if (category && t.category !== category) return false
+    const text = [t.title, t.description, t.name, ...t.tags].join(' ').toLowerCase()
+    return words.every(w => text.includes(w))
+  })
 }

package/client/pages/figure-v3-modeller-page.ts

@@ -1,13 +1,14 @@
 import { html, css } from 'lit'
 import { customElement, state } from 'lit/decorators.js'
 import { navigate, PageView } from '@operato/shell'
+import { getPathInfo } from '@operato/utils'
 import { modellerPathOf } from '../modeller/modeller-route.js'
 import { createV3ProductSession } from '../modeller/v3-product-session.js'
 import { v3ProductStore } from '../graphql/v3-store.js'
 import { i18next } from '@operato/i18n'
-import { fetchFigure, fetchFigureRecipes, fetchFigureTypeNames, updateFigure } from '../graphql/index.js'
-import { recipesOf } from '../modeller/v3-recipes.js'
-import type { V3Recipe } from '@hatiolab/figure-model'
+import { fetchFigure, fetchFigureTypeNames, updateFigure } from '../graphql/index.js'
+import { availableRecipes, recipeGuide } from '../modeller/v3-recipe-source.js'
+import type { RecipeTemplate } from '../modeller/v3-recipes.js'
 import { occupancyFromParts } from '../modeller/v3-occupancy.js'
 import type { V3AuthoringAction } from '@hatiolab/figure-model'
 import '../modeller/v3-editor.js'
@@ -95,9 +96,12 @@ export class FigureV3ModellerPage extends PageView {
   private routeId: string | undefined
   private discardApproved = false
   @state() private revision = 0
-  /** The recipes this domain sees (ADR-0095), read once when the page is first shown. */
-  @state() private recipes: V3Recipe[] = []
-  private recipesRead = false
+  /** The recipe templates (ADR-0095), read once when the page is first shown; none read, and the section is not drawn. */
+  @state() private templates: RecipeTemplate[] = []
+  private templatesRead = false
+  private guideOf = (name: string) => recipeGuide(name, i18next.language || 'en')
+  /* The domain part of the address is read the way the shell reads it (figure-thumb does the same). */
+  private thumbnailOf = (name: string) => `${getPathInfo(location.pathname).contextPath}/figure-recipe-thumbnail/${name}`
   @state() private error = ''
   /**
    * 발행 패널이 읽는 행의 사실 — 상태와 발행 판 번호. 원본은 세션이 들고, 이 둘은 행에 있다.
@@ -376,12 +380,11 @@ export class FigureV3ModellerPage extends PageView {
       this.withdrawAssistant()
       return
     }
-    if (!this.recipesRead) {
-      this.recipesRead = true
-      /* A recipe list that cannot be read leaves the section out; the modeller works without it. */
-      fetchFigureRecipes()
-        .then(rows => (this.recipes = recipesOf(rows)))
-        .catch(() => (this.recipesRead = false))
+    if (!this.templatesRead) {
+      this.templatesRead = true
+      availableRecipes(i18next.language || 'en')
+        .then(templates => (this.templates = templates))
+        .catch(() => (this.templatesRead = false))
     }
     const id = lifecycle?.resourceId
     if (this.session.read().context && id === this.routeId && !changes.active) return
@@ -447,7 +450,7 @@ export class FigureV3ModellerPage extends PageView {
   render() {
     if (this.error) return html`<p role="alert" class="error">${this.error}</p>`
     const view = this.session.read()
-    return html`<figure-v3-editor .session=${this.session} .recipes=${this.recipes} .firstSave=${this.askFirstSave} .revision=${this.revision} .instances=${this.instances} .budget=${this.budget} @v3-changed=${this.changed}>
+    return html`<figure-v3-editor .session=${this.session} .templates=${this.templates} .guideOf=${this.guideOf} .thumbnailOf=${this.thumbnailOf} .firstSave=${this.askFirstSave} .revision=${this.revision} .instances=${this.instances} .budget=${this.budget} @v3-changed=${this.changed}>
       ${this.commandError ? html`<p slot="notice" fit-error role="alert">${this.commandError}</p>` : ''}
       <figure-v3-properties
         slot="figure"

package/client/route.ts

@@ -4,10 +4,6 @@ export default function route(page: string) {
       import('./pages/figure-list-page')
       return page
 
-    case 'figure-recipes':
-      import('./pages/figure-recipe-page')
-      return page
-
     /*
       One modeller since ADR-0087 step 5. `figure-v3-modeller` is kept as an alias for links made before the switch.
     */

package/dist-client/graphql/index.d.ts

@@ -65,24 +65,17 @@ export declare function inspectFigureDraft(source: string, id?: string): Promise
  */
 export declare function fetchReleasedSource(id: string): Promise<string | undefined>;
 export declare function fetchFigureVersions(id: string): Promise<FigureVersion[]>;
-/** The recipes this domain sees (ADR-0095): released ones, its own and its parent's. Each is a figure-model V3Recipe. */
-export declare function fetchFigureRecipes(): Promise<Array<{
+/** A recipe template as the server gives it (ADR-0095, amended): words in the language asked, the recipe as JSON. */
+export interface RecipeTemplateRow {
     name: string;
+    category: string;
+    tags: string[];
+    target: 'part' | 'figure';
+    title: string;
+    description: string;
     source: string;
-}>>;
-/** A recipe row as the management screen reads it: whose it is and whether it is released. */
-export interface FigureRecipeRow {
-    name: string;
-    source: string;
-    state: 'draft' | 'released';
-    updatedAt?: string;
-    domain?: {
-        id: string;
-        subdomain?: string;
-    };
+    hasThumbnail: boolean;
 }
-/** Every recipe this domain sees, drafts too (ADR-0095). */
-export declare function fetchFigureRecipeRows(): Promise<FigureRecipeRow[]>;
-export declare function saveFigureRecipe(source: string, state: 'draft' | 'released'): Promise<FigureRecipeRow>;
-export declare function setFigureRecipeState(name: string, state: 'draft' | 'released'): Promise<void>;
-export declare function deleteFigureRecipe(name: string): Promise<void>;
+export declare function fetchRecipeTemplates(lang: string): Promise<RecipeTemplateRow[]>;
+/** One template's guide in the language asked, or '' while none is written. */
+export declare function fetchRecipeGuide(name: string, lang: string): Promise<string>;

package/dist-client/graphql/index.js

@@ -283,79 +283,38 @@ export async function fetchFigureVersions(id) {
     });
     return unwrap(response, 'figureVersions') ?? [];
 }
-/** The recipes this domain sees (ADR-0095): released ones, its own and its parent's. Each is a figure-model V3Recipe. */
-export async function fetchFigureRecipes() {
+export async function fetchRecipeTemplates(lang) {
     const response = await client.query({
         query: gql `
-      query {
-        figureRecipes {
+      query ($lang: String) {
+        figureRecipeTemplates(lang: $lang) {
           name
+          category
+          tags
+          target
+          title
+          description
           source
+          hasThumbnail
         }
       }
     `,
-        fetchPolicy: 'network-only'
+        variables: { lang }
     });
-    return unwrap(response, 'figureRecipes') ?? [];
+    return unwrap(response, 'figureRecipeTemplates') ?? [];
 }
-/** Every recipe this domain sees, drafts too (ADR-0095). */
-export async function fetchFigureRecipeRows() {
+/** One template's guide in the language asked, or '' while none is written. */
+export async function fetchRecipeGuide(name, lang) {
     const response = await client.query({
         query: gql `
-      query {
-        figureRecipes(all: true) {
-          name
-          source
-          state
-          updatedAt
-          domain {
-            id
-            subdomain
-          }
+      query ($name: String!, $lang: String) {
+        figureRecipeTemplate(name: $name, lang: $lang) {
+          guide
         }
       }
     `,
-        fetchPolicy: 'network-only'
-    });
-    return unwrap(response, 'figureRecipes') ?? [];
-}
-export async function saveFigureRecipe(source, state) {
-    const response = await client.mutate({
-        mutation: gql `
-      mutation ($source: String!, $state: String) {
-        saveFigureRecipe(source: $source, state: $state) {
-          name
-          source
-          state
-        }
-      }
-    `,
-        variables: { source, state }
-    });
-    return unwrap(response, 'saveFigureRecipe');
-}
-export async function setFigureRecipeState(name, state) {
-    const response = await client.mutate({
-        mutation: gql `
-      mutation ($name: String!, $state: String!) {
-        setFigureRecipeState(name: $name, state: $state) {
-          name
-        }
-      }
-    `,
-        variables: { name, state }
-    });
-    unwrap(response, 'setFigureRecipeState');
-}
-export async function deleteFigureRecipe(name) {
-    const response = await client.mutate({
-        mutation: gql `
-      mutation ($name: String!) {
-        deleteFigureRecipe(name: $name)
-      }
-    `,
-        variables: { name }
+        variables: { name, lang }
     });
-    unwrap(response, 'deleteFigureRecipe');
+    return unwrap(response, 'figureRecipeTemplate')?.guide ?? '';
 }
 //# sourceMappingURL=index.js.map