@formicoidea/labre-core 0.40.0 → 0.42.0

package/dist/_pkgs/affine-gfx-template/builtin/other.js

@@ -1,6 +1,8 @@
 import { ConnectorMode, FontFamily, FontWeight, PointStyle, ShapeStyle, StrokeStyle, TextAlign, } from '../../affine-model/index.js';
 import { NOTATION_NEUTRALS } from '../../affine-shared/consts/index.js';
+import { fillPlaceholders, translateKey, } from '../../affine-shared/services/index.js';
 import { makeTemplateSnapshot, surfaceText, } from '../make-snapshot.js';
+import { BMC_SEED_CHANNELS, BMC_SEED_COST_STRUCTURE, BMC_SEED_CUSTOMER_RELATIONSHIPS, BMC_SEED_CUSTOMER_SEGMENTS, BMC_SEED_DATE, BMC_SEED_DESIGNED_BY, BMC_SEED_DESIGNED_FOR, BMC_SEED_KEY_ACTIVITIES, BMC_SEED_KEY_PARTNERSHIPS, BMC_SEED_KEY_RESOURCES, BMC_SEED_REVENUE_STREAMS, BMC_SEED_TITLE, BMC_SEED_VALUE_PROPOSITIONS, BMC_SEED_VERSION, FISHBONE_SEED_CATEGORY, FISHBONE_SEED_EFFECT, FISHBONE_SEED_ITEM_1, FISHBONE_SEED_ITEM_2, GANTT_SEED_BUILD, GANTT_SEED_DESIGN, GANTT_SEED_DISCOVERY, GANTT_SEED_LAUNCH, GANTT_SEED_WEEK, KANBAN_SEED_CARD, KANBAN_SEED_DOING, KANBAN_SEED_DONE, KANBAN_SEED_TODO, SWOT_SEED_OPPORTUNITIES, SWOT_SEED_STRENGTHS, SWOT_SEED_THREATS, SWOT_SEED_WEAKNESSES, TEMPLATE_PANEL_CATEGORY_OTHER, } from '../translations.js';
 /**
  * The generic ("Other") diagrams: built ONLY from general BlockSuite shapes
  * (`shape` rect/polygon, `text`, `connector`) per the composition principle —
@@ -63,21 +65,27 @@ function line(x1, y1, x2, y2, opts = {}) {
         target: { position: [x2, y2] },
     };
 }
+/** Resolve a wording through the host, or its English fallback with no host. */
+function tr(std, wording, params) {
+    return std
+        ? translateKey(std, ...wording, params)
+        : fillPlaceholders(wording[1], params);
+}
 // ── SWOT (window-mullion quadrant, black labels) ──────────────────────
-function swot() {
+function swot(std) {
     const M = { fontSize: 22, weight: FontWeight.Medium };
     return {
         box: rect(0, 0, 520, 340),
         v: line(260, 0, 260, 340),
         h: line(0, 170, 520, 170),
-        s: label(24, 24, 220, 30, 'Strengths', M),
-        w: label(284, 24, 220, 30, 'Weaknesses', M),
-        o: label(24, 194, 220, 30, 'Opportunities', M),
-        t: label(284, 194, 220, 30, 'Threats', M),
+        s: label(24, 24, 220, 30, tr(std, SWOT_SEED_STRENGTHS), M),
+        w: label(284, 24, 220, 30, tr(std, SWOT_SEED_WEAKNESSES), M),
+        o: label(24, 194, 220, 30, tr(std, SWOT_SEED_OPPORTUNITIES), M),
+        t: label(284, 194, 220, 30, tr(std, SWOT_SEED_THREATS), M),
     };
 }
 // ── Kanban (To do / Doing / Done) ─────────────────────────────────────
-function kanban() {
+function kanban(std) {
     const colOpts = {
         fill: NOTATION_NEUTRALS.cardFill,
         stroke: MUTED,
@@ -89,21 +97,22 @@ function kanban() {
         weight: FontWeight.Medium,
         align: TextAlign.Center,
     };
+    const cardText = tr(std, KANBAN_SEED_CARD);
     const card = (x, y, fill, stroke) => rect(x, y, 188, 60, {
         fill,
         stroke,
         sw: 1.5,
         radius: 8,
-        text: 'Card',
+        text: cardText,
         fontSize: 14,
     });
     return {
         c1: rect(0, 0, 220, 420, colOpts),
         c2: rect(244, 0, 220, 420, colOpts),
         c3: rect(488, 0, 220, 420, colOpts),
-        h1: label(0, 16, 220, 24, 'To do', head),
-        h2: label(244, 16, 220, 24, 'Doing', head),
-        h3: label(488, 16, 220, 24, 'Done', head),
+        h1: label(0, 16, 220, 24, tr(std, KANBAN_SEED_TODO), head),
+        h2: label(244, 16, 220, 24, tr(std, KANBAN_SEED_DOING), head),
+        h3: label(488, 16, 220, 24, tr(std, KANBAN_SEED_DONE), head),
         a1: card(16, 56, '#fde6c8', '#e0a23a'),
         a2: card(16, 128, '#fde6c8', '#e0a23a'),
         b1: card(260, 56, '#d6e4fb', '#4574c4'),
@@ -112,7 +121,7 @@ function kanban() {
     };
 }
 // ── Business Model Canvas (Strategyzer 9-block layout) ────────────────
-function bmc() {
+function bmc(std) {
     const blk = { stroke: DARK, sw: 1.5 };
     const t = (x, y, s) => label(x + 12, y + 12, 180, 22, s, {
         fontSize: 14,
@@ -125,12 +134,12 @@ function bmc() {
             color: NOTATION_NEUTRALS.label,
         }),
     });
-    const h1 = hdr(470, 'Designed for');
-    const h2 = hdr(602, 'Designed by');
-    const h3 = hdr(734, 'Date');
-    const h4 = hdr(866, 'Version');
+    const h1 = hdr(470, tr(std, BMC_SEED_DESIGNED_FOR));
+    const h2 = hdr(602, tr(std, BMC_SEED_DESIGNED_BY));
+    const h3 = hdr(734, tr(std, BMC_SEED_DATE));
+    const h4 = hdr(866, tr(std, BMC_SEED_VERSION));
     return {
-        title: label(0, 8, 440, 32, 'Business model canvas', {
+        title: label(0, 8, 440, 32, tr(std, BMC_SEED_TITLE), {
             fontSize: 24,
             weight: FontWeight.Medium,
         }),
@@ -151,20 +160,23 @@ function bmc() {
         cs: rect(800, 56, 196, 300, blk),
         cost: rect(0, 360, 496, 84, blk),
         rev: rect(500, 360, 496, 84, blk),
-        tkp: t(0, 56, 'Key partnerships'),
-        tka: t(200, 56, 'Key activities'),
-        tkr: t(200, 206, 'Key resources'),
-        tvp: t(400, 56, 'Value propositions'),
-        tcr: t(600, 56, 'Customer relationships'),
-        tch: t(600, 206, 'Channels'),
-        tcs: t(800, 56, 'Customer segments'),
-        tcost: t(0, 360, 'Cost structure'),
-        trev: t(500, 360, 'Revenue streams'),
+        tkp: t(0, 56, tr(std, BMC_SEED_KEY_PARTNERSHIPS)),
+        tka: t(200, 56, tr(std, BMC_SEED_KEY_ACTIVITIES)),
+        tkr: t(200, 206, tr(std, BMC_SEED_KEY_RESOURCES)),
+        tvp: t(400, 56, tr(std, BMC_SEED_VALUE_PROPOSITIONS)),
+        tcr: t(600, 56, tr(std, BMC_SEED_CUSTOMER_RELATIONSHIPS)),
+        tch: t(600, 206, tr(std, BMC_SEED_CHANNELS)),
+        tcs: t(800, 56, tr(std, BMC_SEED_CUSTOMER_SEGMENTS)),
+        tcost: t(0, 360, tr(std, BMC_SEED_COST_STRUCTURE)),
+        trev: t(500, 360, tr(std, BMC_SEED_REVENUE_STREAMS)),
     };
 }
 // ── Fishbone / Ishikawa (spine + arrowhead bones + CATEGORY/ITEM) ─────
-function fishbone() {
-    const cat = (x, y) => rect(x, y, 150, 44, { text: 'CATEGORY', fontSize: 13 });
+function fishbone(std) {
+    const categoryText = tr(std, FISHBONE_SEED_CATEGORY);
+    const item1Text = tr(std, FISHBONE_SEED_ITEM_1);
+    const item2Text = tr(std, FISHBONE_SEED_ITEM_2);
+    const cat = (x, y) => rect(x, y, 150, 44, { text: categoryText, fontSize: 13 });
     const item = (x, y, n) => rect(x, y, 130, 40, {
         stroke: MUTED,
         sw: 1.4,
@@ -175,7 +187,10 @@ function fishbone() {
     });
     const out = {
         spine: line(80, 360, 1120, 360, { sw: 6 }),
-        head: rect(1124, 332, 130, 56, { text: 'Effect', fontSize: 16 }),
+        head: rect(1124, 332, 130, 56, {
+            text: tr(std, FISHBONE_SEED_EFFECT),
+            fontSize: 16,
+        }),
     };
     // two rib-groups (junctions at x = 360 and 760)
     [360, 760].forEach((jx, g) => {
@@ -184,16 +199,21 @@ function fishbone() {
         out[`lb${g}`] = line(ox + 200, 470, jx, 362, { sw: 3, arrow: true });
         out[`uc${g}`] = cat(ox + 150, 224);
         out[`lc${g}`] = cat(ox + 150, 452);
-        out[`ui1${g}`] = item(ox + 130, 286, 'ITEM 1');
-        out[`ui2${g}`] = item(ox + 170, 326, 'ITEM 2');
-        out[`li1${g}`] = item(ox + 130, 396, 'ITEM 1');
-        out[`li2${g}`] = item(ox + 170, 356, 'ITEM 2');
+        out[`ui1${g}`] = item(ox + 130, 286, item1Text);
+        out[`ui2${g}`] = item(ox + 170, 326, item2Text);
+        out[`li1${g}`] = item(ox + 130, 396, item1Text);
+        out[`li2${g}`] = item(ox + 170, 356, item2Text);
     });
     return out;
 }
 // ── Gantt chart ───────────────────────────────────────────────────────
-function gantt() {
-    const rows = ['Discovery', 'Design', 'Build', 'Launch'];
+function gantt(std) {
+    const rows = [
+        tr(std, GANTT_SEED_DISCOVERY),
+        tr(std, GANTT_SEED_DESIGN),
+        tr(std, GANTT_SEED_BUILD),
+        tr(std, GANTT_SEED_LAUNCH),
+    ];
     const bars = [
         [220, 280, '#4574c4'],
         [340, 360, '#2f9e95'],
@@ -208,7 +228,7 @@ function gantt() {
             stroke: NOTATION_NEUTRALS.cardBorder,
             sw: 1,
         });
-        out[`w${i}`] = label(x - 16, 12, 40, 20, `W${i + 1}`, {
+        out[`w${i}`] = label(x - 16, 12, 40, 20, tr(std, GANTT_SEED_WEEK, { n: i + 1 }), {
             fontSize: 12,
             color: NOTATION_NEUTRALS.label,
             align: TextAlign.Center,
@@ -235,21 +255,29 @@ const previews = {
     fishbone: `<svg ${ATTRS} fill="none"><path d="M14 40 H112" stroke="${DARK}" stroke-width="3"/><rect x="112" y="33" width="20" height="14" stroke="${DARK}" stroke-width="1.4"/><path d="M40 18 L52 40 M40 62 L52 40 M84 18 L96 40 M84 62 L96 40" stroke="${DARK}" stroke-width="1.4"/></svg>`,
     gantt: `<svg ${ATTRS} fill="none"><path d="M40 14 V70 M62 14 V70 M84 14 V70 M106 14 V70" stroke="${NOTATION_NEUTRALS.cardBorder}"/><rect x="40" y="22" width="34" height="8" rx="2" fill="#4574c4"/><rect x="52" y="36" width="44" height="8" rx="2" fill="#2f9e95"/><rect x="62" y="50" width="50" height="8" rx="2" fill="#d99a2b"/><rect x="84" y="64" width="28" height="8" rx="2" fill="#43a06b"/></svg>`,
 };
-function t(name, preview, elements) {
+/**
+ * A hand-composed template — what is left once the artefacts are derived. The
+ * seeds a template writes into the document go through the translation seam
+ * at placement (ADR 0023); `content` stays the English build, and `localize`
+ * rebuilds the same snapshot with translated seeds.
+ */
+function t(name, preview, build) {
     return {
         name,
         type: 'template',
         preview,
-        content: makeTemplateSnapshot(elements, name),
+        content: makeTemplateSnapshot(build(), name),
+        localize: std => makeTemplateSnapshot(build(std), name),
     };
 }
 export const otherTemplateCategory = {
     name: 'Other',
+    nameKey: TEMPLATE_PANEL_CATEGORY_OTHER[0],
     templates: [
-        t('SWOT', previews.swot, swot()),
-        t('Kanban board', previews.kanban, kanban()),
-        t('Business model canvas', previews.bmc, bmc()),
-        t('Fishbone (Ishikawa)', previews.fishbone, fishbone()),
-        t('Gantt chart', previews.gantt, gantt()),
+        t('SWOT', previews.swot, swot),
+        t('Kanban board', previews.kanban, kanban),
+        t('Business model canvas', previews.bmc, bmc),
+        t('Fishbone (Ishikawa)', previews.fishbone, fishbone),
+        t('Gantt chart', previews.gantt, gantt),
     ],
 };

package/dist/_pkgs/affine-gfx-template/contribute.js

@@ -1,5 +1,6 @@
 import { createIdentifier } from '../global/di/index.js';
 import { builtInTemplates } from './toolbar/builtin-templates.js';
+import { resolveTemplateName } from './toolbar/resolve-name.js';
 /**
  * A framework registers its Templates-panel categories here; the panel reads
  * them back from the std of the edgeless it opens on. One identifier per
@@ -55,6 +56,7 @@ export function templateManagerFor(std) {
                 ...contributed.map(c => c.name),
             ]),
         ],
+        categoryLabel: name => byName(name)?.nameKey ?? builtInTemplates.categoryLabel(name),
         // Both halves, so a host's `extend(...)` can still append to a framework's
         // own category (the global half answers `[]` for a name it does not know).
         list: async (name) => {
@@ -67,9 +69,14 @@ export function templateManagerFor(std) {
         search: async (keyword, name) => {
             const k = keyword.trim().toLocaleLowerCase();
             const pool = name ? [byName(name)].filter(c => !!c) : contributed;
+            // Matches the ENGLISH name (`templateFromCommand`'s baked-in `name`,
+            // still what a catalogue-less playground shows) or the host's own
+            // translation of it (`resolveTemplateName`, through the command's
+            // `labelKey`) — a search box must not go blind on a translated tile.
             const own = (await Promise.all(pool.map(loadCategory)))
                 .flat()
-                .filter(t => t.name?.toLocaleLowerCase().includes(k));
+                .filter(t => t.name?.toLocaleLowerCase().includes(k) ||
+                resolveTemplateName(std, t).toLocaleLowerCase().includes(k));
             return [...(await builtInTemplates.search(keyword, name)), ...own];
         },
     };

package/dist/_pkgs/affine-gfx-template/index.d.ts

@@ -3,6 +3,8 @@ export * from './make-snapshot.js';
 export * from './services/template.js';
 export * from './snapshot-from-action.js';
 export * from './template-tool.js';
+export * from './toolbar/resolve-name.js';
 export * from './toolbar/senior-tool.js';
 export * from './toolbar/template-panel.js';
 export * from './toolbar/template-type.js';
+export * from './translations.js';

package/dist/_pkgs/affine-gfx-template/index.js

@@ -3,6 +3,8 @@ export * from './make-snapshot.js';
 export * from './services/template.js';
 export * from './snapshot-from-action.js';
 export * from './template-tool.js';
+export * from './toolbar/resolve-name.js';
 export * from './toolbar/senior-tool.js';
 export * from './toolbar/template-panel.js';
 export * from './toolbar/template-type.js';
+export * from './translations.js';

package/dist/_pkgs/affine-gfx-template/snapshot-from-action.d.ts

@@ -10,8 +10,13 @@ import type { Template } from './toolbar/template-type.js';
  * placement actions actually touch and throws on anything else, so an
  * unsupported action fails loudly at build time instead of producing a
  * half-empty template.
+ *
+ * `host` is the editor the template is being inserted into. Its
+ * `TranslationProvider`, and nothing else from it, is handed to the action, so
+ * the seeds the action writes come out in the host's language. Without a host,
+ * the action writes its English fallbacks.
  */
-export declare function snapshotFromAction(run: (std: BlockStdScope) => void, name: string): ReturnType<typeof makeTemplateSnapshot>;
+export declare function snapshotFromAction(run: (std: BlockStdScope) => void, name: string, host?: BlockStdScope): ReturnType<typeof makeTemplateSnapshot>;
 /**
  * Derive a template from the command a user would have run — the template IS
  * the command, so the two can never say different things about what a

package/dist/_pkgs/affine-gfx-template/snapshot-from-action.js

@@ -1,6 +1,5 @@
-import { EdgelessCRUDIdentifier } from '../affine-block-surface/index.js';
+import { recordAction } from '../affine-block-surface/index.js';
 import { Bound } from '../global/gfx/index.js';
-import { generateKeyBetween, GfxControllerIdentifier } from '../std/gfx/index.js';
 import * as Y from 'yjs';
 import { makeTemplateSnapshot, surfaceText, surfaceYMap, } from './make-snapshot.js';
 /**
@@ -27,124 +26,46 @@ function materialize(text) {
  * placement actions actually touch and throws on anything else, so an
  * unsupported action fails loudly at build time instead of producing a
  * half-empty template.
+ *
+ * `host` is the editor the template is being inserted into. Its
+ * `TranslationProvider`, and nothing else from it, is handed to the action, so
+ * the seeds the action writes come out in the host's language. Without a host,
+ * the action writes its English fallbacks.
  */
-export function snapshotFromAction(run, name) {
-    const elements = new Map();
-    let n = 0;
-    let lastIndex = null;
-    const nextIndex = () => (lastIndex = generateKeyBetween(lastIndex, null));
-    const addElement = (props) => {
-        const id = `el-${n++}`;
-        const record = {};
-        for (const [key, value] of Object.entries(props)) {
-            if (value !== undefined)
-                record[key] = value;
-        }
-        record['id'] = id;
-        // ponytail: the Y conversions are hard-coded (`text`, and a group's
-        // `children` / `title`) instead of asking each element class for its own
-        // `propsToY`. Ceiling: it covers every prop the framework actions pass
-        // today. Upgrade path: run the real `propsToY` once the element-ctor map is
-        // reachable without a live surface.
-        const text = record['text'];
-        if (typeof text === 'string')
-            record['text'] = surfaceText(text);
-        else if (text instanceof Y.Text)
-            record['text'] = surfaceText(materialize(text));
-        if (record['type'] === 'group') {
-            const children = record['children'];
-            if (children && typeof children === 'object') {
-                record['children'] = surfaceYMap(Object.fromEntries(Object.keys(children).map(key => [key, true])));
-            }
-            const title = record['title'];
-            if (typeof title === 'string')
-                record['title'] = surfaceText(title);
-            else if (title instanceof Y.Text)
-                record['title'] = surfaceText(materialize(title));
-        }
-        if (record['index'] === undefined)
-            record['index'] = nextIndex();
-        // The model members an action reads back off `getElementById`, kept
-        // non-enumerable so they never leak into the snapshot.
-        Object.defineProperties(record, {
-            group: { value: null },
-            deserializedXYWH: {
-                get: () => typeof record['xywh'] === 'string'
-                    ? Bound.deserialize(record['xywh'])
-                    : null,
-            },
-        });
-        elements.set(id, record);
-        return id;
-    };
-    const records = () => [...elements.values()];
-    const surface = {
-        addElement,
-        getElementById: (id) => elements.get(id) ?? null,
-        getElementsByType: (type) => records().filter(el => el['type'] === type),
-        get elementModels() {
-            return records();
-        },
-    };
-    const gfx = {
-        surface,
-        viewport: { centerX: 0, centerY: 0, zoom: 1, center: { x: 0, y: 0 } },
-        doc: { captureSync: () => { } },
-        selection: { set: () => { }, selectedElements: [] },
-        tool: { setTool: () => { } },
-        layer: {
-            generateIndex: () => nextIndex(),
-            getReorderedIndex: (_model, direction) => {
-                const sorted = records()
-                    .map(el => String(el['index']))
-                    .sort();
-                return direction === 'back'
-                    ? generateKeyBetween(null, sorted[0] ?? null)
-                    : generateKeyBetween(sorted[sorted.length - 1] ?? null, null);
-            },
-            get canvasElements() {
-                return records();
-            },
-        },
-        std: null,
-    };
-    const crud = {
-        addElement: (type, props) => addElement({ ...props, type }),
-    };
-    const std = {
-        get: (identifier) => {
-            if (identifier === GfxControllerIdentifier)
-                return gfx;
-            if (identifier === EdgelessCRUDIdentifier)
-                return crud;
-            throw new Error(`snapshotFromAction: unsupported service "${identifier?.identifierName ?? String(identifier)}"`);
-        },
-        getOptional: () => undefined,
-        command: {
-            // Really run the command, so a group built by `createGroupCommand` is
-            // whatever that command says a group is — no second definition here.
-            exec: (cmd, payload) => {
-                let out;
-                cmd({ std: gfx.std, ...payload }, r => {
-                    out = r;
-                });
-                return [{}, out ?? {}];
-            },
-        },
-        store: {
-            readonly: false,
-            captureSync: () => { },
-            id: 'doc:template',
-            workspace: { meta: { getDocMeta: () => undefined } },
-        },
-    };
-    gfx.std = std;
-    run(gfx.std);
-    if (elements.size === 0) {
+export function snapshotFromAction(run, name, host) {
+    const { records } = recordAction(run, { host, encode: toSnapshotProps });
+    if (records.length === 0) {
         throw new Error('snapshotFromAction: the action added no element (a tool-arming command?)');
     }
-    normalizeToOrigin(records());
-    return makeTemplateSnapshot(Object.fromEntries(elements), name);
+    normalizeToOrigin(records);
+    return makeTemplateSnapshot(Object.fromEntries(records.map(record => [String(record['id']), record])), name);
+}
+/**
+ * The Y-carrying props, in the serialized form a snapshot holds them in.
+ *
+ * ponytail: the conversions are hard-coded (`text`, and a group's `children` /
+ * `title`) instead of asking each element class for its own `propsToY`.
+ * Ceiling: it covers every prop the framework actions pass today. Upgrade path:
+ * run the real `propsToY` once the element-ctor map is reachable without a live
+ * surface.
+ */
+function toSnapshotProps(record) {
+    const text = record['text'];
+    if (typeof text === 'string')
+        record['text'] = surfaceText(text);
+    else if (text instanceof Y.Text)
+        record['text'] = surfaceText(materialize(text));
+    if (record['type'] === 'group') {
+        const children = record['children'];
+        if (children && typeof children === 'object') {
+            record['children'] = surfaceYMap(Object.fromEntries(Object.keys(children).map(key => [key, true])));
+        }
+        const title = record['title'];
+        if (typeof title === 'string')
+            record['title'] = surfaceText(title);
+        else if (title instanceof Y.Text)
+            record['title'] = surfaceText(materialize(title));
+    }
 }
 /** The connector endpoints that carry a free position rather than an anchor. */
 function freeEndpoints(el) {
@@ -193,13 +114,15 @@ function normalizeToOrigin(records) {
  * framework's artefact looks like.
  */
 export function templateFromCommand(command, preview, name = command.labelFallback ?? command.id) {
+    const run = (std) => {
+        void command.run(std, INVOCATION);
+    };
     return {
         name,
         type: 'template',
         preview,
         commandId: command.id,
-        content: snapshotFromAction(std => {
-            void command.run(std, INVOCATION);
-        }, name),
+        content: snapshotFromAction(run, name),
+        localize: host => snapshotFromAction(run, name, host),
     };
 }

package/dist/_pkgs/affine-gfx-template/toolbar/builtin-templates.d.ts

@@ -3,6 +3,7 @@ export declare const templates: TemplateCategory[];
 export declare const builtInTemplates: {
     list: (category: string) => Promise<Template[]>;
     categories: () => Promise<string[]>;
+    categoryLabel: (name: string) => string | undefined;
     search: (keyword: string, cateName?: string) => Promise<Template[]>;
     extend(manager: TemplateManager): void;
 };

package/dist/_pkgs/affine-gfx-template/toolbar/builtin-templates.js

@@ -40,6 +40,18 @@ export const builtInTemplates = {
         // eslint-disable-next-line sonarjs/no-empty-collection
         return templates.map(cate => cate.name).concat(extendCates);
     },
+    categoryLabel: (name) => {
+        // eslint-disable-next-line sonarjs/no-empty-collection
+        const own = templates.find(cate => cate.name === name)?.nameKey;
+        if (own)
+            return own;
+        for (const manager of extendTemplate) {
+            const key = manager.categoryLabel?.(name);
+            if (key)
+                return key;
+        }
+        return undefined;
+    },
     search: async (keyword, cateName) => {
         const candidates = flat(await Promise.all(extendTemplate.map(manager => manager.search(keyword, cateName))));
         keyword = keyword.trim().toLocaleLowerCase();

package/dist/_pkgs/affine-gfx-template/toolbar/resolve-name.d.ts

@@ -0,0 +1,25 @@
+import { type BlockStdScope } from '../../std/index.js';
+import type { Template } from './template-type.js';
+/**
+ * The DISPLAYED name of a template — resolved through the command it was
+ * derived from ({@link Template.commandId}, set by `templateFromCommand`)
+ * when it carries one, so a framework artefact's tile shows the command's own
+ * translated label rather than the raw English text baked into `name` at
+ * build time. A hand-written template (no `commandId`) shows its own `name`,
+ * unresolved — those get a key of their own on a case-by-case basis, not
+ * through this generic seam.
+ *
+ * `Template.name` itself stays the STABLE identity `templateFromCommand`
+ * bakes in (the drag payload, the `repeat` key, the `templateCache` storage
+ * key) — and it is ALSO what gets passed as `translateKey`'s fallback, never
+ * `command.labelFallback`: most derived templates leave `name` at its default
+ * (the command's own fallback, so the two agree anyway), but a few tiles
+ * deliberately keep a name of their own, more specific than the command's
+ * (`edgy.addFacets`'s own label is "Enterprise Design facets"; its tile has
+ * always said "Facets diagram"). Falling back to `command.labelFallback`
+ * would silently swap that wording out from under a catalogue-less
+ * playground; reading through the command's `labelKey` while keeping the
+ * TEMPLATE's own fallback is what lets a host translate the tile without
+ * this function inventing a different English sentence for it first.
+ */
+export declare function resolveTemplateName(std: BlockStdScope, template: Template): string;

package/dist/_pkgs/affine-gfx-template/toolbar/resolve-name.js

@@ -0,0 +1,36 @@
+import { translateKey } from '../../affine-shared/services/index.js';
+import { getRegisteredCommands } from '../../std/index.js';
+/**
+ * The DISPLAYED name of a template — resolved through the command it was
+ * derived from ({@link Template.commandId}, set by `templateFromCommand`)
+ * when it carries one, so a framework artefact's tile shows the command's own
+ * translated label rather than the raw English text baked into `name` at
+ * build time. A hand-written template (no `commandId`) shows its own `name`,
+ * unresolved — those get a key of their own on a case-by-case basis, not
+ * through this generic seam.
+ *
+ * `Template.name` itself stays the STABLE identity `templateFromCommand`
+ * bakes in (the drag payload, the `repeat` key, the `templateCache` storage
+ * key) — and it is ALSO what gets passed as `translateKey`'s fallback, never
+ * `command.labelFallback`: most derived templates leave `name` at its default
+ * (the command's own fallback, so the two agree anyway), but a few tiles
+ * deliberately keep a name of their own, more specific than the command's
+ * (`edgy.addFacets`'s own label is "Enterprise Design facets"; its tile has
+ * always said "Facets diagram"). Falling back to `command.labelFallback`
+ * would silently swap that wording out from under a catalogue-less
+ * playground; reading through the command's `labelKey` while keeping the
+ * TEMPLATE's own fallback is what lets a host translate the tile without
+ * this function inventing a different English sentence for it first.
+ */
+export function resolveTemplateName(std, template) {
+    const fallback = template.name ?? '';
+    // Checked FIRST: a hand-composed template (a worked scene, an example map)
+    // carries no `commandId` at all, and `nameKey` is the only way its tile
+    // gets a translated wording of its own.
+    if (template.nameKey)
+        return translateKey(std, template.nameKey, fallback);
+    if (!template.commandId)
+        return fallback;
+    const command = getRegisteredCommands(std).find(c => c.id === template.commandId);
+    return command ? translateKey(std, command.labelKey, fallback) : fallback;
+}

package/dist/_pkgs/affine-gfx-template/toolbar/senior-tool.js

@@ -1,8 +1,10 @@
 import { SeniorToolExtension } from '../../affine-widget-edgeless-toolbar/index.js';
 import { html } from 'lit';
+import { TEMPLATE_SENIOR_TOOL_NAME } from '../translations.js';
 export const templateSeniorTool = SeniorToolExtension('template', ({ block }) => {
     return {
-        name: 'Template',
+        name: TEMPLATE_SENIOR_TOOL_NAME[1],
+        labelKey: TEMPLATE_SENIOR_TOOL_NAME[0],
         // Render after every framework senior tool (default order is 0).
         order: 100,
         content: html `<edgeless-template-button .edgeless=${block}>

package/dist/_pkgs/affine-gfx-template/toolbar/template-panel.d.ts

@@ -13,6 +13,7 @@ export declare class EdgelessTemplatePanel extends EdgelessTemplatePanel_base {
     static templates: {
         list: (category: string) => Promise<Template[]>;
         categories: () => Promise<string[]>;
+        categoryLabel: (name: string) => string | undefined;
         search: (keyword: string, cateName?: string) => Promise<Template[]>;
         extend(manager: import("./template-type.js").TemplateManager): void;
     };